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