dlls/amstream/audiostream.c

   1 /*
   2  * Primary audio stream
   3  *
   4  * Copyright 2012 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22 #include "amstream_private.h"
  23 #include "wine/debug.h"
  24 #include "wine/strmbase.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(amstream);
  27
  28 static const WCHAR sink_id[] = L"I{A35FF56B-9FDA-11D0-8FDF-00C04FD9189D}";
  29
  30 struct queued_receive
  31 {
  32     struct list entry;
  33     IMediaSample *sample;
  34     DWORD length;
  35     BYTE *pointer;
  36     DWORD position;
  37     STREAM_TIME start_time;
  38 };
  39
  40 struct audio_stream
  41 {
  42     IAMMediaStream IAMMediaStream_iface;
  43     IAudioMediaStream IAudioMediaStream_iface;
  44     IMemInputPin IMemInputPin_iface;
  45     IPin IPin_iface;
  46     LONG ref;
  47
  48     IMultiMediaStream* parent;
  49     MSPID purpose_id;
  50     STREAM_TYPE stream_type;
  51     CRITICAL_SECTION cs;
  52     IMediaStreamFilter *filter;
  53
  54     IPin *peer;
  55     IMemAllocator *allocator;
  56     AM_MEDIA_TYPE mt;
  57     WAVEFORMATEX format;
  58     FILTER_STATE state;
  59     REFERENCE_TIME segment_start;
  60     BOOL eos;
  61     BOOL flushing;
  62     struct list receive_queue;
  63     struct list update_queue;
  64 };
  65
  66 typedef struct {
  67     IAudioStreamSample IAudioStreamSample_iface;
  68     LONG ref;
  69     struct audio_stream *parent;
  70     IAudioData *audio_data;
  71     STREAM_TIME start_time;
  72     STREAM_TIME end_time;
  73     HANDLE update_event;
  74
  75     struct list entry;
  76     DWORD length;
  77     BYTE *pointer;
  78     DWORD position;
  79     HRESULT update_hr;
  80 } IAudioStreamSampleImpl;
  81
  82 static void remove_queued_receive(struct queued_receive *receive)
  83 {
  84     list_remove(&receive->entry);
  85     IMediaSample_Release(receive->sample);
  86     free(receive);
  87 }
  88
  89 static void remove_queued_update(IAudioStreamSampleImpl *sample)
  90 {
  91     HRESULT hr;
  92
  93     hr = IAudioData_SetActual(sample->audio_data, sample->position);
  94     if (FAILED(hr))
  95         sample->update_hr = hr;
  96
  97     list_remove(&sample->entry);
  98     SetEvent(sample->update_event);
  99 }
 100
 101 static void flush_receive_queue(struct audio_stream *stream)
 102 {
 103     struct list *entry;
 104
 105     while ((entry = list_head(&stream->receive_queue)))
 106         remove_queued_receive(LIST_ENTRY(entry, struct queued_receive, entry));
 107 }
 108
 109 static STREAM_TIME stream_time_from_position(struct audio_stream *stream, struct queued_receive *receive)
 110 {
 111     const WAVEFORMATEX *format = (WAVEFORMATEX *)stream->mt.pbFormat;
 112     return receive->start_time + (receive->position * 10000000 + format->nAvgBytesPerSec / 2) / format->nAvgBytesPerSec;
 113 }
 114
 115 static void process_update(IAudioStreamSampleImpl *sample, struct queued_receive *receive)
 116 {
 117     DWORD advance;
 118
 119     advance = min(receive->length - receive->position, sample->length - sample->position);
 120     memcpy(&sample->pointer[sample->position], &receive->pointer[receive->position], advance);
 121
 122     if (!sample->position)
 123         sample->start_time = stream_time_from_position(sample->parent, receive);
 124
 125     receive->position += advance;
 126     sample->position += advance;
 127
 128     sample->end_time = stream_time_from_position(sample->parent, receive);
 129
 130     sample->update_hr = (sample->position == sample->length) ? S_OK : MS_S_PENDING;
 131 }
 132
 133 static void process_updates(struct audio_stream *stream)
 134 {
 135     while (!list_empty(&stream->update_queue) && !list_empty(&stream->receive_queue))
 136     {
 137         IAudioStreamSampleImpl *sample = LIST_ENTRY(list_head(&stream->update_queue), IAudioStreamSampleImpl, entry);
 138         struct queued_receive *receive = LIST_ENTRY(list_head(&stream->receive_queue), struct queued_receive, entry);
 139
 140         process_update(sample, receive);
 141
 142         if (sample->update_hr != MS_S_PENDING)
 143             remove_queued_update(sample);
 144         if (receive->position == receive->length)
 145             remove_queued_receive(receive);
 146     }
 147     if (stream->eos)
 148     {
 149         while (!list_empty(&stream->update_queue))
 150         {
 151             IAudioStreamSampleImpl *sample = LIST_ENTRY(list_head(&stream->update_queue), IAudioStreamSampleImpl, entry);
 152
 153             sample->update_hr = sample->position ? S_OK : MS_S_ENDOFSTREAM;
 154             remove_queued_update(sample);
 155         }
 156     }
 157 }
 158
 159 static inline IAudioStreamSampleImpl *impl_from_IAudioStreamSample(IAudioStreamSample *iface)
 160 {
 161     return CONTAINING_RECORD(iface, IAudioStreamSampleImpl, IAudioStreamSample_iface);
 162 }
 163
 164 /*** IUnknown methods ***/
 165 static HRESULT WINAPI IAudioStreamSampleImpl_QueryInterface(IAudioStreamSample *iface,
 166         REFIID riid, void **ret_iface)
 167 {
 168     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(riid), ret_iface);
 169
 170     if (IsEqualGUID(riid, &IID_IUnknown) ||
 171         IsEqualGUID(riid, &IID_IStreamSample) ||
 172         IsEqualGUID(riid, &IID_IAudioStreamSample))
 173     {
 174         IAudioStreamSample_AddRef(iface);
 175         *ret_iface = iface;
 176         return S_OK;
 177     }
 178
 179     *ret_iface = NULL;
 180
 181     ERR("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ret_iface);
 182     return E_NOINTERFACE;
 183 }
 184
 185 static ULONG WINAPI IAudioStreamSampleImpl_AddRef(IAudioStreamSample *iface)
 186 {
 187     IAudioStreamSampleImpl *This = impl_from_IAudioStreamSample(iface);
 188     ULONG ref = InterlockedIncrement(&This->ref);
 189
 190     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 191
 192     return ref;
 193 }
 194
 195 static ULONG WINAPI IAudioStreamSampleImpl_Release(IAudioStreamSample *iface)
 196 {
 197     IAudioStreamSampleImpl *This = impl_from_IAudioStreamSample(iface);
 198     ULONG ref = InterlockedDecrement(&This->ref);
 199
 200     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 201
 202     if (!ref)
 203     {
 204         CloseHandle(This->update_event);
 205         HeapFree(GetProcessHeap(), 0, This);
 206     }
 207
 208     return ref;
 209 }
 210
 211 /*** IStreamSample methods ***/
 212 static HRESULT WINAPI IAudioStreamSampleImpl_GetMediaStream(IAudioStreamSample *iface, IMediaStream **media_stream)
 213 {
 214     FIXME("(%p)->(%p): stub\n", iface, media_stream);
 215
 216     return E_NOTIMPL;
 217 }
 218
 219 static HRESULT WINAPI IAudioStreamSampleImpl_GetSampleTimes(IAudioStreamSample *iface, STREAM_TIME *start_time,
 220                                                                  STREAM_TIME *end_time, STREAM_TIME *current_time)
 221 {
 222     IAudioStreamSampleImpl *sample = impl_from_IAudioStreamSample(iface);
 223
 224     TRACE("sample %p, start_time %p, end_time %p, current_time %p.\n", sample, start_time, end_time, current_time);
 225
 226     if (current_time)
 227         IMediaStreamFilter_GetCurrentStreamTime(sample->parent->filter, current_time);
 228
 229     if (start_time)
 230         *start_time = sample->start_time;
 231     if (end_time)
 232         *end_time = sample->end_time;
 233
 234     return S_OK;
 235 }
 236
 237 static HRESULT WINAPI IAudioStreamSampleImpl_SetSampleTimes(IAudioStreamSample *iface, const STREAM_TIME *start_time,
 238                                                                  const STREAM_TIME *end_time)
 239 {
 240     FIXME("(%p)->(%p,%p): stub\n", iface, start_time, end_time);
 241
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI IAudioStreamSampleImpl_Update(IAudioStreamSample *iface,
 246         DWORD flags, HANDLE event, PAPCFUNC apc_func, DWORD apc_data)
 247 {
 248     IAudioStreamSampleImpl *sample = impl_from_IAudioStreamSample(iface);
 249     BYTE *pointer;
 250     DWORD length;
 251     HRESULT hr;
 252
 253     TRACE("sample %p, flags %#x, event %p, apc_func %p, apc_data %#x.\n",
 254             sample, flags, event, apc_func, apc_data);
 255
 256     hr = IAudioData_GetInfo(sample->audio_data, &length, &pointer, NULL);
 257     if (FAILED(hr))
 258         return hr;
 259
 260     if (event && apc_func)
 261         return E_INVALIDARG;
 262
 263     if (apc_func)
 264     {
 265         FIXME("APC support is not implemented!\n");
 266         return E_NOTIMPL;
 267     }
 268
 269     if (event)
 270     {
 271         FIXME("Event parameter support is not implemented!\n");
 272         return E_NOTIMPL;
 273     }
 274
 275     if (flags & ~SSUPDATE_ASYNC)
 276     {
 277         FIXME("Unsupported flags %#x.\n", flags);
 278         return E_NOTIMPL;
 279     }
 280
 281     EnterCriticalSection(&sample->parent->cs);
 282
 283     if (sample->parent->state != State_Running)
 284     {
 285         LeaveCriticalSection(&sample->parent->cs);
 286         return MS_E_NOTRUNNING;
 287     }
 288     if (!sample->parent->peer)
 289     {
 290         LeaveCriticalSection(&sample->parent->cs);
 291         return MS_S_ENDOFSTREAM;
 292     }
 293     if (MS_S_PENDING == sample->update_hr)
 294     {
 295         LeaveCriticalSection(&sample->parent->cs);
 296         return MS_E_BUSY;
 297     }
 298
 299     sample->length = length;
 300     sample->pointer = pointer;
 301     sample->position = 0;
 302     sample->update_hr = MS_S_PENDING;
 303     ResetEvent(sample->update_event);
 304     list_add_tail(&sample->parent->update_queue, &sample->entry);
 305
 306     process_updates(sample->parent);
 307     hr = sample->update_hr;
 308
 309     LeaveCriticalSection(&sample->parent->cs);
 310
 311     if (hr != MS_S_PENDING || (flags & SSUPDATE_ASYNC))
 312         return hr;
 313
 314     WaitForSingleObject(sample->update_event, INFINITE);
 315
 316     return sample->update_hr;
 317 }
 318
 319 static HRESULT WINAPI IAudioStreamSampleImpl_CompletionStatus(IAudioStreamSample *iface, DWORD flags, DWORD milliseconds)
 320 {
 321     IAudioStreamSampleImpl *sample = impl_from_IAudioStreamSample(iface);
 322     HRESULT hr;
 323
 324     TRACE("sample %p, flags %#x, milliseconds %u.\n", sample, flags, milliseconds);
 325
 326     if (flags)
 327     {
 328         FIXME("Unhandled flags %#x.\n", flags);
 329         return E_NOTIMPL;
 330     }
 331
 332     EnterCriticalSection(&sample->parent->cs);
 333
 334     hr = sample->update_hr;
 335
 336     LeaveCriticalSection(&sample->parent->cs);
 337
 338     return hr;
 339 }
 340
 341 /*** IAudioStreamSample methods ***/
 342 static HRESULT WINAPI IAudioStreamSampleImpl_GetAudioData(IAudioStreamSample *iface, IAudioData **audio_data)
 343 {
 344     FIXME("(%p)->(%p): stub\n", iface, audio_data);
 345
 346     return E_NOTIMPL;
 347 }
 348
 349 static const struct IAudioStreamSampleVtbl AudioStreamSample_Vtbl =
 350 {
 351     /*** IUnknown methods ***/
 352     IAudioStreamSampleImpl_QueryInterface,
 353     IAudioStreamSampleImpl_AddRef,
 354     IAudioStreamSampleImpl_Release,
 355     /*** IStreamSample methods ***/
 356     IAudioStreamSampleImpl_GetMediaStream,
 357     IAudioStreamSampleImpl_GetSampleTimes,
 358     IAudioStreamSampleImpl_SetSampleTimes,
 359     IAudioStreamSampleImpl_Update,
 360     IAudioStreamSampleImpl_CompletionStatus,
 361     /*** IAudioStreamSample methods ***/
 362     IAudioStreamSampleImpl_GetAudioData
 363 };
 364
 365 static HRESULT audiostreamsample_create(struct audio_stream *parent, IAudioData *audio_data, IAudioStreamSample **audio_stream_sample)
 366 {
 367     IAudioStreamSampleImpl *object;
 368
 369     TRACE("(%p)\n", audio_stream_sample);
 370
 371     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAudioStreamSampleImpl));
 372     if (!object)
 373         return E_OUTOFMEMORY;
 374
 375     object->IAudioStreamSample_iface.lpVtbl = &AudioStreamSample_Vtbl;
 376     object->ref = 1;
 377     object->parent = parent;
 378     object->audio_data = audio_data;
 379     object->update_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 380
 381     *audio_stream_sample = &object->IAudioStreamSample_iface;
 382
 383     return S_OK;
 384 }
 385
 386 static inline struct audio_stream *impl_from_IAMMediaStream(IAMMediaStream *iface)
 387 {
 388     return CONTAINING_RECORD(iface, struct audio_stream, IAMMediaStream_iface);
 389 }
 390
 391 /*** IUnknown methods ***/
 392 static HRESULT WINAPI audio_IAMMediaStream_QueryInterface(IAMMediaStream *iface,
 393         REFIID riid, void **ret_iface)
 394 {
 395     struct audio_stream *This = impl_from_IAMMediaStream(iface);
 396
 397     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ret_iface);
 398
 399     if (IsEqualGUID(riid, &IID_IUnknown) ||
 400         IsEqualGUID(riid, &IID_IMediaStream) ||
 401         IsEqualGUID(riid, &IID_IAMMediaStream))
 402     {
 403         IAMMediaStream_AddRef(iface);
 404         *ret_iface = iface;
 405         return S_OK;
 406     }
 407     else if (IsEqualGUID(riid, &IID_IAudioMediaStream))
 408     {
 409         IAMMediaStream_AddRef(iface);
 410         *ret_iface = &This->IAudioMediaStream_iface;
 411         return S_OK;
 412     }
 413     else if (IsEqualGUID(riid, &IID_IPin))
 414     {
 415         IAMMediaStream_AddRef(iface);
 416         *ret_iface = &This->IPin_iface;
 417         return S_OK;
 418     }
 419     else if (IsEqualGUID(riid, &IID_IMemInputPin))
 420     {
 421         IAMMediaStream_AddRef(iface);
 422         *ret_iface = &This->IMemInputPin_iface;
 423         return S_OK;
 424     }
 425
 426     ERR("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ret_iface);
 427     return E_NOINTERFACE;
 428 }
 429
 430 static ULONG WINAPI audio_IAMMediaStream_AddRef(IAMMediaStream *iface)
 431 {
 432     struct audio_stream *This = impl_from_IAMMediaStream(iface);
 433     ULONG ref = InterlockedIncrement(&This->ref);
 434
 435     TRACE("(%p/%p)->(): new ref = %u\n", iface, This, ref);
 436
 437     return ref;
 438 }
 439
 440 static ULONG WINAPI audio_IAMMediaStream_Release(IAMMediaStream *iface)
 441 {
 442     struct audio_stream *This = impl_from_IAMMediaStream(iface);
 443     ULONG ref = InterlockedDecrement(&This->ref);
 444
 445     TRACE("(%p/%p)->(): new ref = %u\n", iface, This, ref);
 446
 447     if (!ref)
 448     {
 449         DeleteCriticalSection(&This->cs);
 450         HeapFree(GetProcessHeap(), 0, This);
 451     }
 452
 453     return ref;
 454 }
 455
 456 /*** IMediaStream methods ***/
 457 static HRESULT WINAPI audio_IAMMediaStream_GetMultiMediaStream(IAMMediaStream *iface,
 458         IMultiMediaStream **mmstream)
 459 {
 460     struct audio_stream *stream = impl_from_IAMMediaStream(iface);
 461
 462     TRACE("stream %p, mmstream %p.\n", stream, mmstream);
 463
 464     if (!mmstream)
 465         return E_POINTER;
 466
 467     if (stream->parent)
 468         IMultiMediaStream_AddRef(stream->parent);
 469     *mmstream = stream->parent;
 470     return S_OK;
 471 }
 472
 473 static HRESULT WINAPI audio_IAMMediaStream_GetInformation(IAMMediaStream *iface,
 474         MSPID *purpose_id, STREAM_TYPE *type)
 475 {
 476     struct audio_stream *This = impl_from_IAMMediaStream(iface);
 477
 478     TRACE("(%p/%p)->(%p,%p)\n", This, iface, purpose_id, type);
 479
 480     if (purpose_id)
 481         *purpose_id = This->purpose_id;
 482     if (type)
 483         *type = This->stream_type;
 484
 485     return S_OK;
 486 }
 487
 488 static HRESULT WINAPI audio_IAMMediaStream_SetSameFormat(IAMMediaStream *iface,
 489         IMediaStream *pStreamThatHasDesiredFormat, DWORD flags)
 490 {
 491     struct audio_stream *This = impl_from_IAMMediaStream(iface);
 492
 493     FIXME("(%p/%p)->(%p,%x) stub!\n", This, iface, pStreamThatHasDesiredFormat, flags);
 494
 495     return S_FALSE;
 496 }
 497
 498 static HRESULT WINAPI audio_IAMMediaStream_AllocateSample(IAMMediaStream *iface,
 499         DWORD flags, IStreamSample **sample)
 500 {
 501     struct audio_stream *This = impl_from_IAMMediaStream(iface);
 502
 503     FIXME("(%p/%p)->(%x,%p) stub!\n", This, iface, flags, sample);
 504
 505     return S_FALSE;
 506 }
 507
 508 static HRESULT WINAPI audio_IAMMediaStream_CreateSharedSample(IAMMediaStream *iface,
 509         IStreamSample *existing_sample, DWORD flags, IStreamSample **sample)
 510 {
 511     struct audio_stream *This = impl_from_IAMMediaStream(iface);
 512
 513     FIXME("(%p/%p)->(%p,%x,%p) stub!\n", This, iface, existing_sample, flags, sample);
 514
 515     return S_FALSE;
 516 }
 517
 518 static HRESULT WINAPI audio_IAMMediaStream_SendEndOfStream(IAMMediaStream *iface, DWORD flags)
 519 {
 520     struct audio_stream *This = impl_from_IAMMediaStream(iface);
 521
 522     FIXME("(%p/%p)->(%x) stub!\n", This, iface, flags);
 523
 524     return S_FALSE;
 525 }
 526
 527 /*** IAMMediaStream methods ***/
 528 static HRESULT WINAPI audio_IAMMediaStream_Initialize(IAMMediaStream *iface, IUnknown *source_object, DWORD flags,
 529                                                     REFMSPID purpose_id, const STREAM_TYPE stream_type)
 530 {
 531     struct audio_stream *stream = impl_from_IAMMediaStream(iface);
 532
 533     TRACE("stream %p, source_object %p, flags %x, purpose_id %s, stream_type %u.\n", stream, source_object, flags,
 534             debugstr_guid(purpose_id), stream_type);
 535
 536     if (!purpose_id)
 537         return E_POINTER;
 538
 539     if (source_object)
 540         FIXME("Specifying a stream object is not yet supported.\n");
 541
 542     if (flags & AMMSF_CREATEPEER)
 543         FIXME("AMMSF_CREATEPEER is not yet supported.\n");
 544
 545     stream->purpose_id = *purpose_id;
 546     stream->stream_type = stream_type;
 547
 548     return S_OK;
 549 }
 550
 551 static HRESULT WINAPI audio_IAMMediaStream_SetState(IAMMediaStream *iface, FILTER_STATE state)
 552 {
 553     struct audio_stream *stream = impl_from_IAMMediaStream(iface);
 554
 555     TRACE("stream %p, state %u.\n", stream, state);
 556
 557     EnterCriticalSection(&stream->cs);
 558
 559     if (state == State_Stopped)
 560         flush_receive_queue(stream);
 561     if (stream->state == State_Stopped)
 562         stream->eos = FALSE;
 563
 564     stream->state = state;
 565
 566     LeaveCriticalSection(&stream->cs);
 567
 568     return S_OK;
 569 }
 570
 571 static HRESULT WINAPI audio_IAMMediaStream_JoinAMMultiMediaStream(IAMMediaStream *iface,
 572         IAMMultiMediaStream *mmstream)
 573 {
 574     struct audio_stream *stream = impl_from_IAMMediaStream(iface);
 575
 576     TRACE("stream %p, mmstream %p.\n", stream, mmstream);
 577
 578     stream->parent = (IMultiMediaStream *)mmstream;
 579
 580     return S_OK;
 581 }
 582
 583 static HRESULT WINAPI audio_IAMMediaStream_JoinFilter(IAMMediaStream *iface, IMediaStreamFilter *filter)
 584 {
 585     struct audio_stream *stream = impl_from_IAMMediaStream(iface);
 586
 587     TRACE("stream %p, filter %p.\n", stream, filter);
 588
 589     stream->filter = filter;
 590
 591     return S_OK;
 592 }
 593
 594 static HRESULT WINAPI audio_IAMMediaStream_JoinFilterGraph(IAMMediaStream *iface, IFilterGraph *filtergraph)
 595 {
 596     struct audio_stream *This = impl_from_IAMMediaStream(iface);
 597
 598     FIXME("(%p/%p)->(%p) stub!\n", This, iface, filtergraph);
 599
 600     return S_FALSE;
 601 }
 602
 603 static const struct IAMMediaStreamVtbl audio_IAMMediaStream_vtbl =
 604 {
 605     audio_IAMMediaStream_QueryInterface,
 606     audio_IAMMediaStream_AddRef,
 607     audio_IAMMediaStream_Release,
 608     audio_IAMMediaStream_GetMultiMediaStream,
 609     audio_IAMMediaStream_GetInformation,
 610     audio_IAMMediaStream_SetSameFormat,
 611     audio_IAMMediaStream_AllocateSample,
 612     audio_IAMMediaStream_CreateSharedSample,
 613     audio_IAMMediaStream_SendEndOfStream,
 614     audio_IAMMediaStream_Initialize,
 615     audio_IAMMediaStream_SetState,
 616     audio_IAMMediaStream_JoinAMMultiMediaStream,
 617     audio_IAMMediaStream_JoinFilter,
 618     audio_IAMMediaStream_JoinFilterGraph,
 619 };
 620
 621 static inline struct audio_stream *impl_from_IAudioMediaStream(IAudioMediaStream *iface)
 622 {
 623     return CONTAINING_RECORD(iface, struct audio_stream, IAudioMediaStream_iface);
 624 }
 625
 626 /*** IUnknown methods ***/
 627 static HRESULT WINAPI audio_IAudioMediaStream_QueryInterface(IAudioMediaStream *iface,
 628         REFIID riid, void **ret_iface)
 629 {
 630     struct audio_stream *This = impl_from_IAudioMediaStream(iface);
 631     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ret_iface);
 632     return IAMMediaStream_QueryInterface(&This->IAMMediaStream_iface, riid, ret_iface);
 633 }
 634
 635 static ULONG WINAPI audio_IAudioMediaStream_AddRef(IAudioMediaStream *iface)
 636 {
 637     struct audio_stream *This = impl_from_IAudioMediaStream(iface);
 638     TRACE("(%p/%p)\n", iface, This);
 639     return IAMMediaStream_AddRef(&This->IAMMediaStream_iface);
 640 }
 641
 642 static ULONG WINAPI audio_IAudioMediaStream_Release(IAudioMediaStream *iface)
 643 {
 644     struct audio_stream *This = impl_from_IAudioMediaStream(iface);
 645     TRACE("(%p/%p)\n", iface, This);
 646     return IAMMediaStream_Release(&This->IAMMediaStream_iface);
 647 }
 648
 649 static HRESULT WINAPI audio_IAudioMediaStream_GetMultiMediaStream(IAudioMediaStream *iface,
 650         IMultiMediaStream **mmstream)
 651 {
 652     struct audio_stream *stream = impl_from_IAudioMediaStream(iface);
 653     return IAMMediaStream_GetMultiMediaStream(&stream->IAMMediaStream_iface, mmstream);
 654 }
 655
 656 static HRESULT WINAPI audio_IAudioMediaStream_GetInformation(IAudioMediaStream *iface,
 657         MSPID *purpose_id, STREAM_TYPE *type)
 658 {
 659     struct audio_stream *stream = impl_from_IAudioMediaStream(iface);
 660     return IAMMediaStream_GetInformation(&stream->IAMMediaStream_iface, purpose_id, type);
 661 }
 662
 663 static HRESULT WINAPI audio_IAudioMediaStream_SetSameFormat(IAudioMediaStream *iface,
 664         IMediaStream *other, DWORD flags)
 665 {
 666     struct audio_stream *stream = impl_from_IAudioMediaStream(iface);
 667     return IAMMediaStream_SetSameFormat(&stream->IAMMediaStream_iface, other, flags);
 668 }
 669
 670 static HRESULT WINAPI audio_IAudioMediaStream_AllocateSample(IAudioMediaStream *iface,
 671         DWORD flags, IStreamSample **sample)
 672 {
 673     struct audio_stream *stream = impl_from_IAudioMediaStream(iface);
 674     return IAMMediaStream_AllocateSample(&stream->IAMMediaStream_iface, flags, sample);
 675 }
 676
 677 static HRESULT WINAPI audio_IAudioMediaStream_CreateSharedSample(IAudioMediaStream *iface,
 678         IStreamSample *existing_sample, DWORD flags, IStreamSample **sample)
 679 {
 680     struct audio_stream *stream = impl_from_IAudioMediaStream(iface);
 681     return IAMMediaStream_CreateSharedSample(&stream->IAMMediaStream_iface, existing_sample, flags, sample);
 682 }
 683
 684 static HRESULT WINAPI audio_IAudioMediaStream_SendEndOfStream(IAudioMediaStream *iface, DWORD flags)
 685 {
 686     struct audio_stream *stream = impl_from_IAudioMediaStream(iface);
 687     return IAMMediaStream_SendEndOfStream(&stream->IAMMediaStream_iface, flags);
 688 }
 689
 690 /*** IAudioMediaStream methods ***/
 691 static HRESULT WINAPI audio_IAudioMediaStream_GetFormat(IAudioMediaStream *iface, WAVEFORMATEX *format)
 692 {
 693     struct audio_stream *stream = impl_from_IAudioMediaStream(iface);
 694
 695     TRACE("stream %p, format %p.\n", stream, format);
 696
 697     if (!format)
 698         return E_POINTER;
 699
 700     EnterCriticalSection(&stream->cs);
 701
 702     if (!stream->peer)
 703     {
 704         LeaveCriticalSection(&stream->cs);
 705         return MS_E_NOSTREAM;
 706     }
 707
 708     *format = *(WAVEFORMATEX *)stream->mt.pbFormat;
 709
 710     LeaveCriticalSection(&stream->cs);
 711
 712     return S_OK;
 713 }
 714
 715 static HRESULT WINAPI audio_IAudioMediaStream_SetFormat(IAudioMediaStream *iface, const WAVEFORMATEX *format)
 716 {
 717     struct audio_stream *stream = impl_from_IAudioMediaStream(iface);
 718
 719     TRACE("stream %p, format %p.\n", stream, format);
 720
 721     if (!format)
 722         return E_POINTER;
 723
 724     if (format->wFormatTag != WAVE_FORMAT_PCM)
 725         return E_INVALIDARG;
 726
 727     EnterCriticalSection(&stream->cs);
 728
 729     if ((stream->peer && memcmp(format, stream->mt.pbFormat, sizeof(WAVEFORMATEX)))
 730             || (stream->format.wFormatTag && memcmp(format, &stream->format, sizeof(WAVEFORMATEX))))
 731     {
 732         LeaveCriticalSection(&stream->cs);
 733         return E_INVALIDARG;
 734     }
 735
 736     stream->format = *format;
 737
 738     LeaveCriticalSection(&stream->cs);
 739
 740     return S_OK;
 741 }
 742
 743 static HRESULT WINAPI audio_IAudioMediaStream_CreateSample(IAudioMediaStream *iface, IAudioData *audio_data,
 744                                                          DWORD flags, IAudioStreamSample **sample)
 745 {
 746     struct audio_stream *This = impl_from_IAudioMediaStream(iface);
 747
 748     TRACE("(%p/%p)->(%p,%u,%p)\n", iface, This, audio_data, flags, sample);
 749
 750     if (!audio_data)
 751         return E_POINTER;
 752
 753     return audiostreamsample_create(This, audio_data, sample);
 754 }
 755
 756 static const struct IAudioMediaStreamVtbl audio_IAudioMediaStream_vtbl =
 757 {
 758     audio_IAudioMediaStream_QueryInterface,
 759     audio_IAudioMediaStream_AddRef,
 760     audio_IAudioMediaStream_Release,
 761     audio_IAudioMediaStream_GetMultiMediaStream,
 762     audio_IAudioMediaStream_GetInformation,
 763     audio_IAudioMediaStream_SetSameFormat,
 764     audio_IAudioMediaStream_AllocateSample,
 765     audio_IAudioMediaStream_CreateSharedSample,
 766     audio_IAudioMediaStream_SendEndOfStream,
 767     audio_IAudioMediaStream_GetFormat,
 768     audio_IAudioMediaStream_SetFormat,
 769     audio_IAudioMediaStream_CreateSample,
 770 };
 771
 772 struct enum_media_types
 773 {
 774     IEnumMediaTypes IEnumMediaTypes_iface;
 775     LONG refcount;
 776     unsigned int index;
 777 };
 778
 779 static const IEnumMediaTypesVtbl enum_media_types_vtbl;
 780
 781 static struct enum_media_types *impl_from_IEnumMediaTypes(IEnumMediaTypes *iface)
 782 {
 783     return CONTAINING_RECORD(iface, struct enum_media_types, IEnumMediaTypes_iface);
 784 }
 785
 786 static HRESULT WINAPI enum_media_types_QueryInterface(IEnumMediaTypes *iface, REFIID iid, void **out)
 787 {
 788     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 789
 790     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IEnumMediaTypes))
 791     {
 792         IEnumMediaTypes_AddRef(iface);
 793         *out = iface;
 794         return S_OK;
 795     }
 796
 797     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 798     *out = NULL;
 799     return E_NOINTERFACE;
 800 }
 801
 802 static ULONG WINAPI enum_media_types_AddRef(IEnumMediaTypes *iface)
 803 {
 804     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 805     ULONG refcount = InterlockedIncrement(&enum_media_types->refcount);
 806     TRACE("%p increasing refcount to %u.\n", enum_media_types, refcount);
 807     return refcount;
 808 }
 809
 810 static ULONG WINAPI enum_media_types_Release(IEnumMediaTypes *iface)
 811 {
 812     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 813     ULONG refcount = InterlockedDecrement(&enum_media_types->refcount);
 814     TRACE("%p decreasing refcount to %u.\n", enum_media_types, refcount);
 815     if (!refcount)
 816         heap_free(enum_media_types);
 817     return refcount;
 818 }
 819
 820 static HRESULT WINAPI enum_media_types_Next(IEnumMediaTypes *iface, ULONG count, AM_MEDIA_TYPE **mts, ULONG *ret_count)
 821 {
 822     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 823
 824     TRACE("iface %p, count %u, mts %p, ret_count %p.\n", iface, count, mts, ret_count);
 825
 826     if (!ret_count)
 827         return E_POINTER;
 828
 829     if (count && !enum_media_types->index)
 830     {
 831         mts[0] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 832         memset(mts[0], 0, sizeof(AM_MEDIA_TYPE));
 833         mts[0]->majortype = MEDIATYPE_Audio;
 834         mts[0]->subtype = MEDIASUBTYPE_PCM;
 835         ++enum_media_types->index;
 836         *ret_count = 1;
 837         return count == 1 ? S_OK : S_FALSE;
 838     }
 839
 840     *ret_count = 0;
 841     return count ? S_FALSE : S_OK;
 842 }
 843
 844 static HRESULT WINAPI enum_media_types_Skip(IEnumMediaTypes *iface, ULONG count)
 845 {
 846     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 847
 848     TRACE("iface %p, count %u.\n", iface, count);
 849
 850     enum_media_types->index += count;
 851     return S_OK;
 852 }
 853
 854 static HRESULT WINAPI enum_media_types_Reset(IEnumMediaTypes *iface)
 855 {
 856     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 857
 858     TRACE("iface %p.\n", iface);
 859
 860     enum_media_types->index = 0;
 861     return S_OK;
 862 }
 863
 864 static HRESULT WINAPI enum_media_types_Clone(IEnumMediaTypes *iface, IEnumMediaTypes **out)
 865 {
 866     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 867     struct enum_media_types *object;
 868
 869     TRACE("iface %p, out %p.\n", iface, out);
 870
 871     if (!(object = heap_alloc(sizeof(*object))))
 872         return E_OUTOFMEMORY;
 873
 874     object->IEnumMediaTypes_iface.lpVtbl = &enum_media_types_vtbl;
 875     object->refcount = 1;
 876     object->index = enum_media_types->index;
 877
 878     *out = &object->IEnumMediaTypes_iface;
 879     return S_OK;
 880 }
 881
 882 static const IEnumMediaTypesVtbl enum_media_types_vtbl =
 883 {
 884     enum_media_types_QueryInterface,
 885     enum_media_types_AddRef,
 886     enum_media_types_Release,
 887     enum_media_types_Next,
 888     enum_media_types_Skip,
 889     enum_media_types_Reset,
 890     enum_media_types_Clone,
 891 };
 892
 893 static inline struct audio_stream *impl_from_IPin(IPin *iface)
 894 {
 895     return CONTAINING_RECORD(iface, struct audio_stream, IPin_iface);
 896 }
 897
 898 static HRESULT WINAPI audio_sink_QueryInterface(IPin *iface, REFIID iid, void **out)
 899 {
 900     struct audio_stream *stream = impl_from_IPin(iface);
 901     return IAMMediaStream_QueryInterface(&stream->IAMMediaStream_iface, iid, out);
 902 }
 903
 904 static ULONG WINAPI audio_sink_AddRef(IPin *iface)
 905 {
 906     struct audio_stream *stream = impl_from_IPin(iface);
 907     return IAMMediaStream_AddRef(&stream->IAMMediaStream_iface);
 908 }
 909
 910 static ULONG WINAPI audio_sink_Release(IPin *iface)
 911 {
 912     struct audio_stream *stream = impl_from_IPin(iface);
 913     return IAMMediaStream_Release(&stream->IAMMediaStream_iface);
 914 }
 915
 916 static HRESULT WINAPI audio_sink_Connect(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 917 {
 918     WARN("iface %p, peer %p, mt %p, unexpected call!\n", iface, peer, mt);
 919     return E_UNEXPECTED;
 920 }
 921
 922 static HRESULT WINAPI audio_sink_ReceiveConnection(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 923 {
 924     struct audio_stream *stream = impl_from_IPin(iface);
 925     PIN_DIRECTION dir;
 926
 927     TRACE("stream %p, peer %p, mt %p.\n", stream, peer, mt);
 928
 929     if (!IsEqualGUID(&mt->majortype, &MEDIATYPE_Audio)
 930             || !IsEqualGUID(&mt->formattype, &FORMAT_WaveFormatEx)
 931             || mt->cbFormat < sizeof(WAVEFORMATEX))
 932         return VFW_E_TYPE_NOT_ACCEPTED;
 933
 934     if (((const WAVEFORMATEX *)mt->pbFormat)->wFormatTag != WAVE_FORMAT_PCM)
 935         return E_INVALIDARG;
 936
 937     EnterCriticalSection(&stream->cs);
 938
 939     if (stream->peer)
 940     {
 941         LeaveCriticalSection(&stream->cs);
 942         return VFW_E_ALREADY_CONNECTED;
 943     }
 944
 945     IPin_QueryDirection(peer, &dir);
 946     if (dir != PINDIR_OUTPUT)
 947     {
 948         WARN("Rejecting connection from input pin.\n");
 949         LeaveCriticalSection(&stream->cs);
 950         return VFW_E_INVALID_DIRECTION;
 951     }
 952
 953     if (stream->format.wFormatTag && memcmp(mt->pbFormat, &stream->format, sizeof(WAVEFORMATEX)))
 954     {
 955         LeaveCriticalSection(&stream->cs);
 956         return E_INVALIDARG;
 957     }
 958
 959     CopyMediaType(&stream->mt, mt);
 960     IPin_AddRef(stream->peer = peer);
 961
 962     LeaveCriticalSection(&stream->cs);
 963
 964     return S_OK;
 965 }
 966
 967 static HRESULT WINAPI audio_sink_Disconnect(IPin *iface)
 968 {
 969     struct audio_stream *stream = impl_from_IPin(iface);
 970
 971     TRACE("stream %p.\n", stream);
 972
 973     EnterCriticalSection(&stream->cs);
 974
 975     if (!stream->peer)
 976     {
 977         LeaveCriticalSection(&stream->cs);
 978         return S_FALSE;
 979     }
 980
 981     IPin_Release(stream->peer);
 982     stream->peer = NULL;
 983     FreeMediaType(&stream->mt);
 984     memset(&stream->mt, 0, sizeof(AM_MEDIA_TYPE));
 985
 986     LeaveCriticalSection(&stream->cs);
 987
 988     return S_OK;
 989 }
 990
 991 static HRESULT WINAPI audio_sink_ConnectedTo(IPin *iface, IPin **peer)
 992 {
 993     struct audio_stream *stream = impl_from_IPin(iface);
 994     HRESULT hr;
 995
 996     TRACE("stream %p, peer %p.\n", stream, peer);
 997
 998     EnterCriticalSection(&stream->cs);
 999
1000     if (stream->peer)
1001     {
1002         IPin_AddRef(*peer = stream->peer);
1003         hr = S_OK;
1004     }
1005     else
1006     {
1007         *peer = NULL;
1008         hr = VFW_E_NOT_CONNECTED;
1009     }
1010
1011     LeaveCriticalSection(&stream->cs);
1012
1013     return hr;
1014 }
1015
1016 static HRESULT WINAPI audio_sink_ConnectionMediaType(IPin *iface, AM_MEDIA_TYPE *mt)
1017 {
1018     struct audio_stream *stream = impl_from_IPin(iface);
1019     HRESULT hr;
1020
1021     TRACE("stream %p, mt %p.\n", stream, mt);
1022
1023     EnterCriticalSection(&stream->cs);
1024
1025     if (stream->peer)
1026     {
1027         CopyMediaType(mt, &stream->mt);
1028         hr = S_OK;
1029     }
1030     else
1031     {
1032         memset(mt, 0, sizeof(AM_MEDIA_TYPE));
1033         hr = VFW_E_NOT_CONNECTED;
1034     }
1035
1036     LeaveCriticalSection(&stream->cs);
1037
1038     return hr;
1039 }
1040
1041 static HRESULT WINAPI audio_sink_QueryPinInfo(IPin *iface, PIN_INFO *info)
1042 {
1043     struct audio_stream *stream = impl_from_IPin(iface);
1044
1045     TRACE("stream %p, info %p.\n", stream, info);
1046
1047     IBaseFilter_AddRef(info->pFilter = (IBaseFilter *)stream->filter);
1048     info->dir = PINDIR_INPUT;
1049     wcscpy(info->achName, sink_id);
1050
1051     return S_OK;
1052 }
1053
1054 static HRESULT WINAPI audio_sink_QueryDirection(IPin *iface, PIN_DIRECTION *dir)
1055 {
1056     TRACE("iface %p, dir %p.\n", iface, dir);
1057     *dir = PINDIR_INPUT;
1058     return S_OK;
1059 }
1060
1061 static HRESULT WINAPI audio_sink_QueryId(IPin *iface, WCHAR **id)
1062 {
1063     TRACE("iface %p, id %p.\n", iface, id);
1064
1065     if (!(*id = CoTaskMemAlloc(sizeof(sink_id))))
1066         return E_OUTOFMEMORY;
1067
1068     wcscpy(*id, sink_id);
1069
1070     return S_OK;
1071 }
1072
1073 static HRESULT WINAPI audio_sink_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *mt)
1074 {
1075     TRACE("iface %p, mt %p.\n", iface, mt);
1076     return S_OK;
1077 }
1078
1079 static HRESULT WINAPI audio_sink_EnumMediaTypes(IPin *iface, IEnumMediaTypes **enum_media_types)
1080 {
1081     struct enum_media_types *object;
1082
1083     TRACE("iface %p, enum_media_types %p.\n", iface, enum_media_types);
1084
1085     if (!enum_media_types)
1086         return E_POINTER;
1087
1088     if (!(object = heap_alloc(sizeof(*object))))
1089         return E_OUTOFMEMORY;
1090
1091     object->IEnumMediaTypes_iface.lpVtbl = &enum_media_types_vtbl;
1092     object->refcount = 1;
1093     object->index = 0;
1094
1095     *enum_media_types = &object->IEnumMediaTypes_iface;
1096     return S_OK;
1097 }
1098
1099 static HRESULT WINAPI audio_sink_QueryInternalConnections(IPin *iface, IPin **pins, ULONG *count)
1100 {
1101     TRACE("iface %p, pins %p, count %p.\n", iface, pins, count);
1102     return E_NOTIMPL;
1103 }
1104
1105 static HRESULT WINAPI audio_sink_EndOfStream(IPin *iface)
1106 {
1107     struct audio_stream *stream = impl_from_IPin(iface);
1108
1109     TRACE("stream %p.\n", stream);
1110
1111     EnterCriticalSection(&stream->cs);
1112
1113     if (stream->eos || stream->flushing)
1114     {
1115         LeaveCriticalSection(&stream->cs);
1116         return E_FAIL;
1117     }
1118
1119     stream->eos = TRUE;
1120
1121     process_updates(stream);
1122
1123     LeaveCriticalSection(&stream->cs);
1124
1125     return S_OK;
1126 }
1127
1128 static HRESULT WINAPI audio_sink_BeginFlush(IPin *iface)
1129 {
1130     struct audio_stream *stream = impl_from_IPin(iface);
1131
1132     TRACE("stream %p.\n", stream);
1133
1134     EnterCriticalSection(&stream->cs);
1135
1136     stream->flushing = TRUE;
1137     stream->eos = FALSE;
1138     flush_receive_queue(stream);
1139
1140     LeaveCriticalSection(&stream->cs);
1141
1142     return S_OK;
1143 }
1144
1145 static HRESULT WINAPI audio_sink_EndFlush(IPin *iface)
1146 {
1147     struct audio_stream *stream = impl_from_IPin(iface);
1148
1149     TRACE("stream %p.\n", stream);
1150
1151     EnterCriticalSection(&stream->cs);
1152
1153     stream->flushing = FALSE;
1154
1155     LeaveCriticalSection(&stream->cs);
1156
1157     return S_OK;
1158 }
1159
1160 static HRESULT WINAPI audio_sink_NewSegment(IPin *iface, REFERENCE_TIME start, REFERENCE_TIME stop, double rate)
1161 {
1162     struct audio_stream *stream = impl_from_IPin(iface);
1163
1164     TRACE("stream %p, start %s, stop %s, rate %0.16e\n",
1165             stream, wine_dbgstr_longlong(start), wine_dbgstr_longlong(stop), rate);
1166
1167     EnterCriticalSection(&stream->cs);
1168
1169     stream->segment_start = start;
1170
1171     LeaveCriticalSection(&stream->cs);
1172
1173     return S_OK;
1174 }
1175
1176 static const IPinVtbl audio_sink_vtbl =
1177 {
1178     audio_sink_QueryInterface,
1179     audio_sink_AddRef,
1180     audio_sink_Release,
1181     audio_sink_Connect,
1182     audio_sink_ReceiveConnection,
1183     audio_sink_Disconnect,
1184     audio_sink_ConnectedTo,
1185     audio_sink_ConnectionMediaType,
1186     audio_sink_QueryPinInfo,
1187     audio_sink_QueryDirection,
1188     audio_sink_QueryId,
1189     audio_sink_QueryAccept,
1190     audio_sink_EnumMediaTypes,
1191     audio_sink_QueryInternalConnections,
1192     audio_sink_EndOfStream,
1193     audio_sink_BeginFlush,
1194     audio_sink_EndFlush,
1195     audio_sink_NewSegment,
1196 };
1197
1198 static inline struct audio_stream *impl_from_IMemInputPin(IMemInputPin *iface)
1199 {
1200     return CONTAINING_RECORD(iface, struct audio_stream, IMemInputPin_iface);
1201 }
1202
1203 static HRESULT WINAPI audio_meminput_QueryInterface(IMemInputPin *iface, REFIID iid, void **out)
1204 {
1205     struct audio_stream *stream = impl_from_IMemInputPin(iface);
1206     return IAMMediaStream_QueryInterface(&stream->IAMMediaStream_iface, iid, out);
1207 }
1208
1209 static ULONG WINAPI audio_meminput_AddRef(IMemInputPin *iface)
1210 {
1211     struct audio_stream *stream = impl_from_IMemInputPin(iface);
1212     return IAMMediaStream_AddRef(&stream->IAMMediaStream_iface);
1213 }
1214
1215 static ULONG WINAPI audio_meminput_Release(IMemInputPin *iface)
1216 {
1217     struct audio_stream *stream = impl_from_IMemInputPin(iface);
1218     return IAMMediaStream_Release(&stream->IAMMediaStream_iface);
1219 }
1220
1221 static HRESULT WINAPI audio_meminput_GetAllocator(IMemInputPin *iface, IMemAllocator **allocator)
1222 {
1223     struct audio_stream *stream = impl_from_IMemInputPin(iface);
1224
1225     TRACE("stream %p, allocator %p.\n", stream, allocator);
1226
1227     if (stream->allocator)
1228     {
1229         IMemAllocator_AddRef(*allocator = stream->allocator);
1230         return S_OK;
1231     }
1232
1233     *allocator = NULL;
1234     return VFW_E_NO_ALLOCATOR;
1235 }
1236
1237 static HRESULT WINAPI audio_meminput_NotifyAllocator(IMemInputPin *iface, IMemAllocator *allocator, BOOL readonly)
1238 {
1239     struct audio_stream *stream = impl_from_IMemInputPin(iface);
1240
1241     TRACE("stream %p, allocator %p, readonly %d.\n", stream, allocator, readonly);
1242
1243     if (!allocator)
1244         return E_POINTER;
1245
1246     if (allocator)
1247         IMemAllocator_AddRef(allocator);
1248     if (stream->allocator)
1249         IMemAllocator_Release(stream->allocator);
1250     stream->allocator = allocator;
1251
1252     return S_OK;
1253 }
1254
1255 static HRESULT WINAPI audio_meminput_GetAllocatorRequirements(IMemInputPin *iface, ALLOCATOR_PROPERTIES *props)
1256 {
1257     TRACE("iface %p, props %p.\n", iface, props);
1258     return E_NOTIMPL;
1259 }
1260
1261 static HRESULT WINAPI audio_meminput_Receive(IMemInputPin *iface, IMediaSample *sample)
1262 {
1263     struct audio_stream *stream = impl_from_IMemInputPin(iface);
1264     struct queued_receive *receive;
1265     REFERENCE_TIME start_time = 0;
1266     REFERENCE_TIME end_time = 0;
1267     BYTE *pointer;
1268     HRESULT hr;
1269
1270     TRACE("stream %p, sample %p.\n", stream, sample);
1271
1272     EnterCriticalSection(&stream->cs);
1273
1274     if (stream->state == State_Stopped)
1275     {
1276         LeaveCriticalSection(&stream->cs);
1277         return VFW_E_WRONG_STATE;
1278     }
1279     if (stream->flushing)
1280     {
1281         LeaveCriticalSection(&stream->cs);
1282         return S_FALSE;
1283     }
1284
1285     hr = IMediaSample_GetPointer(sample, &pointer);
1286     if (FAILED(hr))
1287     {
1288         LeaveCriticalSection(&stream->cs);
1289         return hr;
1290     }
1291
1292     IMediaSample_GetTime(sample, &start_time, &end_time);
1293
1294     receive = calloc(1, sizeof(*receive));
1295     if (!receive)
1296     {
1297         LeaveCriticalSection(&stream->cs);
1298         return E_OUTOFMEMORY;
1299     }
1300
1301     receive->length = IMediaSample_GetActualDataLength(sample);
1302     receive->pointer = pointer;
1303     receive->sample = sample;
1304     receive->start_time = start_time + stream->segment_start;
1305     IMediaSample_AddRef(receive->sample);
1306     list_add_tail(&stream->receive_queue, &receive->entry);
1307
1308     process_updates(stream);
1309
1310     LeaveCriticalSection(&stream->cs);
1311
1312     return S_OK;
1313 }
1314
1315 static HRESULT WINAPI audio_meminput_ReceiveMultiple(IMemInputPin *iface,
1316         IMediaSample **samples, LONG count, LONG *processed)
1317 {
1318     FIXME("iface %p, samples %p, count %u, processed %p, stub!\n", iface, samples, count, processed);
1319     return E_NOTIMPL;
1320 }
1321
1322 static HRESULT WINAPI audio_meminput_ReceiveCanBlock(IMemInputPin *iface)
1323 {
1324     TRACE("iface %p.\n", iface);
1325     return S_OK;
1326 }
1327
1328 static const IMemInputPinVtbl audio_meminput_vtbl =
1329 {
1330     audio_meminput_QueryInterface,
1331     audio_meminput_AddRef,
1332     audio_meminput_Release,
1333     audio_meminput_GetAllocator,
1334     audio_meminput_NotifyAllocator,
1335     audio_meminput_GetAllocatorRequirements,
1336     audio_meminput_Receive,
1337     audio_meminput_ReceiveMultiple,
1338     audio_meminput_ReceiveCanBlock,
1339 };
1340
1341 HRESULT audio_stream_create(IUnknown *outer, void **out)
1342 {
1343     struct audio_stream *object;
1344
1345     if (outer)
1346         return CLASS_E_NOAGGREGATION;
1347
1348     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1349     if (!object)
1350         return E_OUTOFMEMORY;
1351
1352     object->IAMMediaStream_iface.lpVtbl = &audio_IAMMediaStream_vtbl;
1353     object->IAudioMediaStream_iface.lpVtbl = &audio_IAudioMediaStream_vtbl;
1354     object->IMemInputPin_iface.lpVtbl = &audio_meminput_vtbl;
1355     object->IPin_iface.lpVtbl = &audio_sink_vtbl;
1356     object->ref = 1;
1357
1358     InitializeCriticalSection(&object->cs);
1359     list_init(&object->receive_queue);
1360     list_init(&object->update_queue);
1361
1362     TRACE("Created audio stream %p.\n", object);
1363
1364     *out = &object->IAMMediaStream_iface;
1365
1366     return S_OK;
1367 }