dlls/mf/sar.c

   1 /*
   2  * Copyright 2019 Nikolay Sivov for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include "mfapi.h"
  22 #include "mfidl.h"
  23 #include "mf_private.h"
  24 #include "initguid.h"
  25 #include "mmdeviceapi.h"
  26 #include "audioclient.h"
  27
  28 #include "wine/debug.h"
  29 #include "wine/heap.h"
  30 #include "wine/list.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  33
  34 enum stream_state
  35 {
  36     STREAM_STATE_STOPPED = 0,
  37     STREAM_STATE_RUNNING,
  38     STREAM_STATE_PAUSED,
  39 };
  40
  41 enum audio_renderer_flags
  42 {
  43     SAR_SHUT_DOWN = 0x1,
  44     SAR_PREROLLED = 0x2,
  45     SAR_SAMPLE_REQUESTED = 0x4,
  46 };
  47
  48 enum queued_object_type
  49 {
  50     OBJECT_TYPE_SAMPLE,
  51     OBJECT_TYPE_MARKER,
  52 };
  53
  54 struct queued_object
  55 {
  56     struct list entry;
  57     enum queued_object_type type;
  58     union
  59     {
  60         struct
  61         {
  62             IMFSample *sample;
  63             unsigned int frame_offset;
  64         } sample;
  65         struct
  66         {
  67             MFSTREAMSINK_MARKER_TYPE type;
  68             PROPVARIANT context;
  69         } marker;
  70     } u;
  71 };
  72
  73 struct audio_renderer
  74 {
  75     IMFMediaSink IMFMediaSink_iface;
  76     IMFMediaSinkPreroll IMFMediaSinkPreroll_iface;
  77     IMFStreamSink IMFStreamSink_iface;
  78     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
  79     IMFClockStateSink IMFClockStateSink_iface;
  80     IMFMediaEventGenerator IMFMediaEventGenerator_iface;
  81     IMFGetService IMFGetService_iface;
  82     IMFSimpleAudioVolume IMFSimpleAudioVolume_iface;
  83     IMFAudioStreamVolume IMFAudioStreamVolume_iface;
  84     IMFAudioPolicy IMFAudioPolicy_iface;
  85     IMFAsyncCallback render_callback;
  86     LONG refcount;
  87     IMFMediaEventQueue *event_queue;
  88     IMFMediaEventQueue *stream_event_queue;
  89     IMFPresentationClock *clock;
  90     IMFMediaType *media_type;
  91     IMFMediaType *current_media_type;
  92     IMMDevice *device;
  93     IAudioClient *audio_client;
  94     IAudioRenderClient *audio_render_client;
  95     IAudioStreamVolume *stream_volume;
  96     ISimpleAudioVolume *audio_volume;
  97     struct
  98     {
  99         unsigned int flags;
 100         GUID session_id;
 101     } stream_config;
 102     HANDLE buffer_ready_event;
 103     MFWORKITEM_KEY buffer_ready_key;
 104     unsigned int frame_size;
 105     struct list queue;
 106     enum stream_state state;
 107     unsigned int flags;
 108     CRITICAL_SECTION cs;
 109 };
 110
 111 static void release_pending_object(struct queued_object *object)
 112 {
 113     list_remove(&object->entry);
 114     switch (object->type)
 115     {
 116         case OBJECT_TYPE_SAMPLE:
 117             if (object->u.sample.sample)
 118                 IMFSample_Release(object->u.sample.sample);
 119             break;
 120         case OBJECT_TYPE_MARKER:
 121             PropVariantClear(&object->u.marker.context);
 122             break;
 123     }
 124     heap_free(object);
 125 }
 126
 127 static struct audio_renderer *impl_from_IMFMediaSink(IMFMediaSink *iface)
 128 {
 129     return CONTAINING_RECORD(iface, struct audio_renderer, IMFMediaSink_iface);
 130 }
 131
 132 static struct audio_renderer *impl_from_IMFMediaSinkPreroll(IMFMediaSinkPreroll *iface)
 133 {
 134     return CONTAINING_RECORD(iface, struct audio_renderer, IMFMediaSinkPreroll_iface);
 135 }
 136
 137 static struct audio_renderer *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
 138 {
 139     return CONTAINING_RECORD(iface, struct audio_renderer, IMFClockStateSink_iface);
 140 }
 141
 142 static struct audio_renderer *impl_from_IMFMediaEventGenerator(IMFMediaEventGenerator *iface)
 143 {
 144     return CONTAINING_RECORD(iface, struct audio_renderer, IMFMediaEventGenerator_iface);
 145 }
 146
 147 static struct audio_renderer *impl_from_IMFGetService(IMFGetService *iface)
 148 {
 149     return CONTAINING_RECORD(iface, struct audio_renderer, IMFGetService_iface);
 150 }
 151
 152 static struct audio_renderer *impl_from_IMFSimpleAudioVolume(IMFSimpleAudioVolume *iface)
 153 {
 154     return CONTAINING_RECORD(iface, struct audio_renderer, IMFSimpleAudioVolume_iface);
 155 }
 156
 157 static struct audio_renderer *impl_from_IMFAudioStreamVolume(IMFAudioStreamVolume *iface)
 158 {
 159     return CONTAINING_RECORD(iface, struct audio_renderer, IMFAudioStreamVolume_iface);
 160 }
 161
 162 static struct audio_renderer *impl_from_IMFAudioPolicy(IMFAudioPolicy *iface)
 163 {
 164     return CONTAINING_RECORD(iface, struct audio_renderer, IMFAudioPolicy_iface);
 165 }
 166
 167 static struct audio_renderer *impl_from_IMFStreamSink(IMFStreamSink *iface)
 168 {
 169     return CONTAINING_RECORD(iface, struct audio_renderer, IMFStreamSink_iface);
 170 }
 171
 172 static struct audio_renderer *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
 173 {
 174     return CONTAINING_RECORD(iface, struct audio_renderer, IMFMediaTypeHandler_iface);
 175 }
 176
 177 static struct audio_renderer *impl_from_render_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 178 {
 179     return CONTAINING_RECORD(iface, struct audio_renderer, render_callback);
 180 }
 181
 182 static HRESULT WINAPI audio_renderer_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj)
 183 {
 184     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 185
 186     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 187
 188     if (IsEqualIID(riid, &IID_IMFMediaSink) ||
 189             IsEqualIID(riid, &IID_IUnknown))
 190     {
 191         *obj = iface;
 192     }
 193     else if (IsEqualIID(riid, &IID_IMFMediaSinkPreroll))
 194     {
 195         *obj = &renderer->IMFMediaSinkPreroll_iface;
 196     }
 197     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
 198     {
 199         *obj = &renderer->IMFClockStateSink_iface;
 200     }
 201     else if (IsEqualIID(riid, &IID_IMFMediaEventGenerator))
 202     {
 203         *obj = &renderer->IMFMediaEventGenerator_iface;
 204     }
 205     else if (IsEqualIID(riid, &IID_IMFGetService))
 206     {
 207         *obj = &renderer->IMFGetService_iface;
 208     }
 209     else
 210     {
 211         WARN("Unsupported %s.\n", debugstr_guid(riid));
 212         *obj = NULL;
 213         return E_NOINTERFACE;
 214     }
 215
 216     IUnknown_AddRef((IUnknown *)*obj);
 217
 218     return S_OK;
 219 }
 220
 221 static ULONG WINAPI audio_renderer_sink_AddRef(IMFMediaSink *iface)
 222 {
 223     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 224     ULONG refcount = InterlockedIncrement(&renderer->refcount);
 225     TRACE("%p, refcount %u.\n", iface, refcount);
 226     return refcount;
 227 }
 228
 229 static void audio_renderer_release_audio_client(struct audio_renderer *renderer)
 230 {
 231     MFCancelWorkItem(renderer->buffer_ready_key);
 232     renderer->buffer_ready_key = 0;
 233     if (renderer->audio_client)
 234     {
 235         IAudioClient_Stop(renderer->audio_client);
 236         IAudioClient_Reset(renderer->audio_client);
 237         IAudioClient_Release(renderer->audio_client);
 238     }
 239     renderer->audio_client = NULL;
 240     if (renderer->audio_render_client)
 241         IAudioRenderClient_Release(renderer->audio_render_client);
 242     renderer->audio_render_client = NULL;
 243     if (renderer->stream_volume)
 244         IAudioStreamVolume_Release(renderer->stream_volume);
 245     renderer->stream_volume = NULL;
 246     if (renderer->audio_volume)
 247         ISimpleAudioVolume_Release(renderer->audio_volume);
 248     renderer->audio_volume = NULL;
 249     renderer->flags &= ~SAR_PREROLLED;
 250 }
 251
 252 static ULONG WINAPI audio_renderer_sink_Release(IMFMediaSink *iface)
 253 {
 254     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 255     ULONG refcount = InterlockedDecrement(&renderer->refcount);
 256     struct queued_object *obj, *obj2;
 257
 258     TRACE("%p, refcount %u.\n", iface, refcount);
 259
 260     if (!refcount)
 261     {
 262         if (renderer->event_queue)
 263             IMFMediaEventQueue_Release(renderer->event_queue);
 264         if (renderer->stream_event_queue)
 265             IMFMediaEventQueue_Release(renderer->stream_event_queue);
 266         if (renderer->clock)
 267             IMFPresentationClock_Release(renderer->clock);
 268         if (renderer->device)
 269             IMMDevice_Release(renderer->device);
 270         if (renderer->media_type)
 271             IMFMediaType_Release(renderer->media_type);
 272         if (renderer->current_media_type)
 273             IMFMediaType_Release(renderer->current_media_type);
 274         audio_renderer_release_audio_client(renderer);
 275         CloseHandle(renderer->buffer_ready_event);
 276         LIST_FOR_EACH_ENTRY_SAFE(obj, obj2, &renderer->queue, struct queued_object, entry)
 277         {
 278             release_pending_object(obj);
 279         }
 280         DeleteCriticalSection(&renderer->cs);
 281         heap_free(renderer);
 282     }
 283
 284     return refcount;
 285 }
 286
 287 static HRESULT WINAPI audio_renderer_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags)
 288 {
 289     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 290
 291     TRACE("%p, %p.\n", iface, flags);
 292
 293     if (renderer->flags & SAR_SHUT_DOWN)
 294         return MF_E_SHUTDOWN;
 295
 296     *flags = MEDIASINK_FIXED_STREAMS | MEDIASINK_CAN_PREROLL;
 297
 298     return S_OK;
 299 }
 300
 301 static HRESULT WINAPI audio_renderer_sink_AddStreamSink(IMFMediaSink *iface, DWORD stream_sink_id,
 302     IMFMediaType *media_type, IMFStreamSink **stream_sink)
 303 {
 304     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 305
 306     TRACE("%p, %#x, %p, %p.\n", iface, stream_sink_id, media_type, stream_sink);
 307
 308     return renderer->flags & SAR_SHUT_DOWN ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 309 }
 310
 311 static HRESULT WINAPI audio_renderer_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id)
 312 {
 313     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 314
 315     TRACE("%p, %#x.\n", iface, stream_sink_id);
 316
 317     return renderer->flags & SAR_SHUT_DOWN ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 318 }
 319
 320 static HRESULT WINAPI audio_renderer_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
 321 {
 322     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 323
 324     TRACE("%p, %p.\n", iface, count);
 325
 326     if (!count)
 327         return E_POINTER;
 328
 329     if (renderer->flags & SAR_SHUT_DOWN)
 330         return MF_E_SHUTDOWN;
 331
 332     *count = 1;
 333
 334     return S_OK;
 335 }
 336
 337 static HRESULT WINAPI audio_renderer_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index,
 338         IMFStreamSink **stream)
 339 {
 340     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 341     HRESULT hr = S_OK;
 342
 343     TRACE("%p, %u, %p.\n", iface, index, stream);
 344
 345     EnterCriticalSection(&renderer->cs);
 346
 347     if (renderer->flags & SAR_SHUT_DOWN)
 348         hr = MF_E_SHUTDOWN;
 349     else if (index > 0)
 350         hr = MF_E_INVALIDINDEX;
 351     else
 352     {
 353        *stream = &renderer->IMFStreamSink_iface;
 354        IMFStreamSink_AddRef(*stream);
 355     }
 356
 357     LeaveCriticalSection(&renderer->cs);
 358
 359     return hr;
 360 }
 361
 362 static HRESULT WINAPI audio_renderer_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id,
 363         IMFStreamSink **stream)
 364 {
 365     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 366     HRESULT hr = S_OK;
 367
 368     TRACE("%p, %#x, %p.\n", iface, stream_sink_id, stream);
 369
 370     EnterCriticalSection(&renderer->cs);
 371
 372     if (renderer->flags & SAR_SHUT_DOWN)
 373         hr = MF_E_SHUTDOWN;
 374     else if (stream_sink_id > 0)
 375         hr = MF_E_INVALIDSTREAMNUMBER;
 376     else
 377     {
 378         *stream = &renderer->IMFStreamSink_iface;
 379         IMFStreamSink_AddRef(*stream);
 380     }
 381
 382     LeaveCriticalSection(&renderer->cs);
 383
 384     return hr;
 385 }
 386
 387 static void audio_renderer_set_presentation_clock(struct audio_renderer *renderer, IMFPresentationClock *clock)
 388 {
 389     if (renderer->clock)
 390     {
 391         IMFPresentationClock_RemoveClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
 392         IMFPresentationClock_Release(renderer->clock);
 393     }
 394     renderer->clock = clock;
 395     if (renderer->clock)
 396     {
 397         IMFPresentationClock_AddRef(renderer->clock);
 398         IMFPresentationClock_AddClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
 399     }
 400 }
 401
 402 static HRESULT WINAPI audio_renderer_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
 403 {
 404     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 405     HRESULT hr = S_OK;
 406
 407     TRACE("%p, %p.\n", iface, clock);
 408
 409     EnterCriticalSection(&renderer->cs);
 410
 411     if (renderer->flags & SAR_SHUT_DOWN)
 412         hr = MF_E_SHUTDOWN;
 413     else
 414         audio_renderer_set_presentation_clock(renderer, clock);
 415
 416     LeaveCriticalSection(&renderer->cs);
 417
 418     return hr;
 419 }
 420
 421 static HRESULT WINAPI audio_renderer_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
 422 {
 423     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 424     HRESULT hr = S_OK;
 425
 426     TRACE("%p, %p.\n", iface, clock);
 427
 428     if (!clock)
 429         return E_POINTER;
 430
 431     EnterCriticalSection(&renderer->cs);
 432
 433     if (renderer->flags & SAR_SHUT_DOWN)
 434         hr = MF_E_SHUTDOWN;
 435     else if (renderer->clock)
 436     {
 437         *clock = renderer->clock;
 438         IMFPresentationClock_AddRef(*clock);
 439     }
 440     else
 441         hr = MF_E_NO_CLOCK;
 442
 443     LeaveCriticalSection(&renderer->cs);
 444
 445     return hr;
 446 }
 447
 448 static HRESULT WINAPI audio_renderer_sink_Shutdown(IMFMediaSink *iface)
 449 {
 450     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 451
 452     TRACE("%p.\n", iface);
 453
 454     if (renderer->flags & SAR_SHUT_DOWN)
 455         return MF_E_SHUTDOWN;
 456
 457     EnterCriticalSection(&renderer->cs);
 458     renderer->flags |= SAR_SHUT_DOWN;
 459     IMFMediaEventQueue_Shutdown(renderer->event_queue);
 460     IMFMediaEventQueue_Shutdown(renderer->stream_event_queue);
 461     audio_renderer_set_presentation_clock(renderer, NULL);
 462     audio_renderer_release_audio_client(renderer);
 463     LeaveCriticalSection(&renderer->cs);
 464
 465     return S_OK;
 466 }
 467
 468 static const IMFMediaSinkVtbl audio_renderer_sink_vtbl =
 469 {
 470     audio_renderer_sink_QueryInterface,
 471     audio_renderer_sink_AddRef,
 472     audio_renderer_sink_Release,
 473     audio_renderer_sink_GetCharacteristics,
 474     audio_renderer_sink_AddStreamSink,
 475     audio_renderer_sink_RemoveStreamSink,
 476     audio_renderer_sink_GetStreamSinkCount,
 477     audio_renderer_sink_GetStreamSinkByIndex,
 478     audio_renderer_sink_GetStreamSinkById,
 479     audio_renderer_sink_SetPresentationClock,
 480     audio_renderer_sink_GetPresentationClock,
 481     audio_renderer_sink_Shutdown,
 482 };
 483
 484 static void audio_renderer_preroll(struct audio_renderer *renderer)
 485 {
 486     unsigned int i;
 487
 488     if (renderer->flags & SAR_PREROLLED)
 489         return;
 490
 491     for (i = 0; i < 2; ++i)
 492         IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
 493     renderer->flags |= SAR_PREROLLED;
 494 }
 495
 496 static HRESULT WINAPI audio_renderer_preroll_QueryInterface(IMFMediaSinkPreroll *iface, REFIID riid, void **obj)
 497 {
 498     struct audio_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 499     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 500 }
 501
 502 static ULONG WINAPI audio_renderer_preroll_AddRef(IMFMediaSinkPreroll *iface)
 503 {
 504     struct audio_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 505     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 506 }
 507
 508 static ULONG WINAPI audio_renderer_preroll_Release(IMFMediaSinkPreroll *iface)
 509 {
 510     struct audio_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 511     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 512 }
 513
 514 static HRESULT WINAPI audio_renderer_preroll_NotifyPreroll(IMFMediaSinkPreroll *iface, MFTIME start_time)
 515 {
 516     struct audio_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 517
 518     TRACE("%p, %s.\n", iface, debugstr_time(start_time));
 519
 520     if (renderer->flags & SAR_SHUT_DOWN)
 521         return MF_E_SHUTDOWN;
 522
 523     audio_renderer_preroll(renderer);
 524     return IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkPrerolled, &GUID_NULL, S_OK, NULL);
 525 }
 526
 527 static const IMFMediaSinkPrerollVtbl audio_renderer_preroll_vtbl =
 528 {
 529     audio_renderer_preroll_QueryInterface,
 530     audio_renderer_preroll_AddRef,
 531     audio_renderer_preroll_Release,
 532     audio_renderer_preroll_NotifyPreroll,
 533 };
 534
 535 static HRESULT WINAPI audio_renderer_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
 536 {
 537     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 538     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 539 }
 540
 541 static ULONG WINAPI audio_renderer_events_AddRef(IMFMediaEventGenerator *iface)
 542 {
 543     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 544     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 545 }
 546
 547 static ULONG WINAPI audio_renderer_events_Release(IMFMediaEventGenerator *iface)
 548 {
 549     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 550     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 551 }
 552
 553 static HRESULT WINAPI audio_renderer_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
 554 {
 555     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 556
 557     TRACE("%p, %#x, %p.\n", iface, flags, event);
 558
 559     return IMFMediaEventQueue_GetEvent(renderer->event_queue, flags, event);
 560 }
 561
 562 static HRESULT WINAPI audio_renderer_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
 563         IUnknown *state)
 564 {
 565     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 566
 567     TRACE("%p, %p, %p.\n", iface, callback, state);
 568
 569     return IMFMediaEventQueue_BeginGetEvent(renderer->event_queue, callback, state);
 570 }
 571
 572 static HRESULT WINAPI audio_renderer_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
 573         IMFMediaEvent **event)
 574 {
 575     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 576
 577     TRACE("%p, %p, %p.\n", iface, result, event);
 578
 579     return IMFMediaEventQueue_EndGetEvent(renderer->event_queue, result, event);
 580 }
 581
 582 static HRESULT WINAPI audio_renderer_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
 583         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 584 {
 585     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 586
 587     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
 588
 589     return IMFMediaEventQueue_QueueEventParamVar(renderer->event_queue, event_type, ext_type, hr, value);
 590 }
 591
 592 static const IMFMediaEventGeneratorVtbl audio_renderer_events_vtbl =
 593 {
 594     audio_renderer_events_QueryInterface,
 595     audio_renderer_events_AddRef,
 596     audio_renderer_events_Release,
 597     audio_renderer_events_GetEvent,
 598     audio_renderer_events_BeginGetEvent,
 599     audio_renderer_events_EndGetEvent,
 600     audio_renderer_events_QueueEvent,
 601 };
 602
 603 static HRESULT WINAPI audio_renderer_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
 604 {
 605     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 606     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 607 }
 608
 609 static ULONG WINAPI audio_renderer_clock_sink_AddRef(IMFClockStateSink *iface)
 610 {
 611     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 612     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 613 }
 614
 615 static ULONG WINAPI audio_renderer_clock_sink_Release(IMFClockStateSink *iface)
 616 {
 617     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 618     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 619 }
 620
 621 static HRESULT WINAPI audio_renderer_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
 622 {
 623     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 624     HRESULT hr = S_OK;
 625
 626     TRACE("%p, %s, %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
 627
 628     EnterCriticalSection(&renderer->cs);
 629     if (renderer->audio_client)
 630     {
 631         if (renderer->state == STREAM_STATE_STOPPED)
 632         {
 633             if (FAILED(hr = IAudioClient_Start(renderer->audio_client)))
 634                 WARN("Failed to start audio client, hr %#x.\n", hr);
 635             renderer->state = STREAM_STATE_RUNNING;
 636         }
 637     }
 638     else
 639         hr = MF_E_NOT_INITIALIZED;
 640
 641     IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkStarted, &GUID_NULL, hr, NULL);
 642     if (SUCCEEDED(hr))
 643         audio_renderer_preroll(renderer);
 644     LeaveCriticalSection(&renderer->cs);
 645
 646     return hr;
 647 }
 648
 649 static HRESULT WINAPI audio_renderer_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
 650 {
 651     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 652     HRESULT hr = S_OK;
 653
 654     TRACE("%p, %s.\n", iface, debugstr_time(systime));
 655
 656     EnterCriticalSection(&renderer->cs);
 657     if (renderer->audio_client)
 658     {
 659         if (renderer->state != STREAM_STATE_STOPPED)
 660         {
 661             if (SUCCEEDED(hr = IAudioClient_Stop(renderer->audio_client)))
 662             {
 663                 if (FAILED(hr = IAudioClient_Reset(renderer->audio_client)))
 664                     WARN("Failed to reset audio client, hr %#x.\n", hr);
 665             }
 666             else
 667                 WARN("Failed to stop audio client, hr %#x.\n", hr);
 668             renderer->state = STREAM_STATE_STOPPED;
 669             renderer->flags &= ~SAR_PREROLLED;
 670         }
 671     }
 672     else
 673         hr = MF_E_NOT_INITIALIZED;
 674
 675     IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkStopped, &GUID_NULL, hr, NULL);
 676     LeaveCriticalSection(&renderer->cs);
 677
 678     return hr;
 679 }
 680
 681 static HRESULT WINAPI audio_renderer_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
 682 {
 683     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 684     HRESULT hr;
 685
 686     TRACE("%p, %s.\n", iface, debugstr_time(systime));
 687
 688     EnterCriticalSection(&renderer->cs);
 689     if (renderer->state == STREAM_STATE_RUNNING)
 690     {
 691         if (renderer->audio_client)
 692         {
 693             if (FAILED(hr = IAudioClient_Stop(renderer->audio_client)))
 694                 WARN("Failed to stop audio client, hr %#x.\n", hr);
 695             renderer->state = STREAM_STATE_PAUSED;
 696         }
 697         else
 698             hr = MF_E_NOT_INITIALIZED;
 699
 700         IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkPaused, &GUID_NULL, hr, NULL);
 701     }
 702     else
 703         hr = MF_E_INVALID_STATE_TRANSITION;
 704     LeaveCriticalSection(&renderer->cs);
 705
 706     return hr;
 707 }
 708
 709 static HRESULT WINAPI audio_renderer_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
 710 {
 711     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 712     BOOL preroll = FALSE;
 713     HRESULT hr = S_OK;
 714
 715     TRACE("%p, %s.\n", iface, debugstr_time(systime));
 716
 717     EnterCriticalSection(&renderer->cs);
 718     if (renderer->audio_client)
 719     {
 720         if ((preroll = (renderer->state != STREAM_STATE_RUNNING)))
 721         {
 722             if (FAILED(hr = IAudioClient_Start(renderer->audio_client)))
 723                 WARN("Failed to start audio client, hr %#x.\n", hr);
 724             renderer->state = STREAM_STATE_RUNNING;
 725         }
 726     }
 727     else
 728         hr = MF_E_NOT_INITIALIZED;
 729
 730     IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkStarted, &GUID_NULL, hr, NULL);
 731     if (preroll)
 732         audio_renderer_preroll(renderer);
 733
 734     LeaveCriticalSection(&renderer->cs);
 735
 736     return hr;
 737 }
 738
 739 static HRESULT WINAPI audio_renderer_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
 740 {
 741     FIXME("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
 742
 743     return E_NOTIMPL;
 744 }
 745
 746 static const IMFClockStateSinkVtbl audio_renderer_clock_sink_vtbl =
 747 {
 748     audio_renderer_clock_sink_QueryInterface,
 749     audio_renderer_clock_sink_AddRef,
 750     audio_renderer_clock_sink_Release,
 751     audio_renderer_clock_sink_OnClockStart,
 752     audio_renderer_clock_sink_OnClockStop,
 753     audio_renderer_clock_sink_OnClockPause,
 754     audio_renderer_clock_sink_OnClockRestart,
 755     audio_renderer_clock_sink_OnClockSetRate,
 756 };
 757
 758 static HRESULT WINAPI audio_renderer_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
 759 {
 760     struct audio_renderer *renderer = impl_from_IMFGetService(iface);
 761     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 762 }
 763
 764 static ULONG WINAPI audio_renderer_get_service_AddRef(IMFGetService *iface)
 765 {
 766     struct audio_renderer *renderer = impl_from_IMFGetService(iface);
 767     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 768 }
 769
 770 static ULONG WINAPI audio_renderer_get_service_Release(IMFGetService *iface)
 771 {
 772     struct audio_renderer *renderer = impl_from_IMFGetService(iface);
 773     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 774 }
 775
 776 static HRESULT WINAPI audio_renderer_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 777 {
 778     struct audio_renderer *renderer = impl_from_IMFGetService(iface);
 779
 780     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 781
 782     *obj = NULL;
 783
 784     if (IsEqualGUID(service, &MR_POLICY_VOLUME_SERVICE) && IsEqualIID(riid, &IID_IMFSimpleAudioVolume))
 785     {
 786         *obj = &renderer->IMFSimpleAudioVolume_iface;
 787     }
 788     else if (IsEqualGUID(service, &MR_STREAM_VOLUME_SERVICE) && IsEqualIID(riid, &IID_IMFAudioStreamVolume))
 789     {
 790         *obj = &renderer->IMFAudioStreamVolume_iface;
 791     }
 792     else if (IsEqualGUID(service, &MR_AUDIO_POLICY_SERVICE) && IsEqualIID(riid, &IID_IMFAudioPolicy))
 793     {
 794         *obj = &renderer->IMFAudioPolicy_iface;
 795     }
 796     else
 797         FIXME("Unsupported service %s, interface %s.\n", debugstr_guid(service), debugstr_guid(riid));
 798
 799     if (*obj)
 800         IUnknown_AddRef((IUnknown *)*obj);
 801
 802     return *obj ? S_OK : E_NOINTERFACE;
 803 }
 804
 805 static const IMFGetServiceVtbl audio_renderer_get_service_vtbl =
 806 {
 807     audio_renderer_get_service_QueryInterface,
 808     audio_renderer_get_service_AddRef,
 809     audio_renderer_get_service_Release,
 810     audio_renderer_get_service_GetService,
 811 };
 812
 813 static HRESULT WINAPI audio_renderer_simple_volume_QueryInterface(IMFSimpleAudioVolume *iface, REFIID riid, void **obj)
 814 {
 815     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 816
 817     if (IsEqualIID(riid, &IID_IMFSimpleAudioVolume) ||
 818             IsEqualIID(riid, &IID_IUnknown))
 819     {
 820         *obj = iface;
 821         IMFSimpleAudioVolume_AddRef(iface);
 822         return S_OK;
 823     }
 824
 825     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 826     *obj = NULL;
 827     return E_NOINTERFACE;
 828 }
 829
 830 static ULONG WINAPI audio_renderer_simple_volume_AddRef(IMFSimpleAudioVolume *iface)
 831 {
 832     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 833     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 834 }
 835
 836 static ULONG WINAPI audio_renderer_simple_volume_Release(IMFSimpleAudioVolume *iface)
 837 {
 838     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 839     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 840 }
 841
 842 static HRESULT WINAPI audio_renderer_simple_volume_SetMasterVolume(IMFSimpleAudioVolume *iface, float level)
 843 {
 844     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 845     HRESULT hr = S_OK;
 846
 847     TRACE("%p, %f.\n", iface, level);
 848
 849     EnterCriticalSection(&renderer->cs);
 850     if (renderer->audio_volume)
 851         hr = ISimpleAudioVolume_SetMasterVolume(renderer->audio_volume, level, NULL);
 852     LeaveCriticalSection(&renderer->cs);
 853
 854     return hr;
 855 }
 856
 857 static HRESULT WINAPI audio_renderer_simple_volume_GetMasterVolume(IMFSimpleAudioVolume *iface, float *level)
 858 {
 859     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 860     HRESULT hr = S_OK;
 861
 862     TRACE("%p, %p.\n", iface, level);
 863
 864     if (!level)
 865         return E_POINTER;
 866
 867     *level = 0.0f;
 868
 869     EnterCriticalSection(&renderer->cs);
 870     if (renderer->audio_volume)
 871         hr = ISimpleAudioVolume_GetMasterVolume(renderer->audio_volume, level);
 872     LeaveCriticalSection(&renderer->cs);
 873
 874     return hr;
 875 }
 876
 877 static HRESULT WINAPI audio_renderer_simple_volume_SetMute(IMFSimpleAudioVolume *iface, BOOL mute)
 878 {
 879     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 880     HRESULT hr = S_OK;
 881
 882     TRACE("%p, %d.\n", iface, mute);
 883
 884     EnterCriticalSection(&renderer->cs);
 885     if (renderer->audio_volume)
 886         hr = ISimpleAudioVolume_SetMute(renderer->audio_volume, mute, NULL);
 887     LeaveCriticalSection(&renderer->cs);
 888
 889     return hr;
 890 }
 891
 892 static HRESULT WINAPI audio_renderer_simple_volume_GetMute(IMFSimpleAudioVolume *iface, BOOL *mute)
 893 {
 894     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 895     HRESULT hr = S_OK;
 896
 897     TRACE("%p, %p.\n", iface, mute);
 898
 899     if (!mute)
 900         return E_POINTER;
 901
 902     *mute = FALSE;
 903
 904     EnterCriticalSection(&renderer->cs);
 905     if (renderer->audio_volume)
 906         hr = ISimpleAudioVolume_GetMute(renderer->audio_volume, mute);
 907     LeaveCriticalSection(&renderer->cs);
 908
 909     return hr;
 910 }
 911
 912 static const IMFSimpleAudioVolumeVtbl audio_renderer_simple_volume_vtbl =
 913 {
 914     audio_renderer_simple_volume_QueryInterface,
 915     audio_renderer_simple_volume_AddRef,
 916     audio_renderer_simple_volume_Release,
 917     audio_renderer_simple_volume_SetMasterVolume,
 918     audio_renderer_simple_volume_GetMasterVolume,
 919     audio_renderer_simple_volume_SetMute,
 920     audio_renderer_simple_volume_GetMute,
 921 };
 922
 923 static HRESULT WINAPI audio_renderer_stream_volume_QueryInterface(IMFAudioStreamVolume *iface, REFIID riid, void **obj)
 924 {
 925     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 926
 927     if (IsEqualIID(riid, &IID_IMFAudioStreamVolume) ||
 928             IsEqualIID(riid, &IID_IUnknown))
 929     {
 930         *obj = iface;
 931         IMFAudioStreamVolume_AddRef(iface);
 932         return S_OK;
 933     }
 934
 935     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 936     *obj = NULL;
 937     return E_NOINTERFACE;
 938 }
 939
 940 static ULONG WINAPI audio_renderer_stream_volume_AddRef(IMFAudioStreamVolume *iface)
 941 {
 942     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 943     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 944 }
 945
 946 static ULONG WINAPI audio_renderer_stream_volume_Release(IMFAudioStreamVolume *iface)
 947 {
 948     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 949     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 950 }
 951
 952 static HRESULT WINAPI audio_renderer_stream_volume_GetChannelCount(IMFAudioStreamVolume *iface, UINT32 *count)
 953 {
 954     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 955     HRESULT hr = S_OK;
 956
 957     TRACE("%p, %p.\n", iface, count);
 958
 959     if (!count)
 960         return E_POINTER;
 961
 962     *count = 0;
 963
 964     EnterCriticalSection(&renderer->cs);
 965     if (renderer->stream_volume)
 966         hr = IAudioStreamVolume_GetChannelCount(renderer->stream_volume, count);
 967     LeaveCriticalSection(&renderer->cs);
 968
 969     return hr;
 970 }
 971
 972 static HRESULT WINAPI audio_renderer_stream_volume_SetChannelVolume(IMFAudioStreamVolume *iface, UINT32 index, float level)
 973 {
 974     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 975     HRESULT hr = S_OK;
 976
 977     TRACE("%p, %u, %f.\n", iface, index, level);
 978
 979     EnterCriticalSection(&renderer->cs);
 980     if (renderer->stream_volume)
 981         hr = IAudioStreamVolume_SetChannelVolume(renderer->stream_volume, index, level);
 982     LeaveCriticalSection(&renderer->cs);
 983
 984     return hr;
 985 }
 986
 987 static HRESULT WINAPI audio_renderer_stream_volume_GetChannelVolume(IMFAudioStreamVolume *iface, UINT32 index, float *level)
 988 {
 989     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 990     HRESULT hr = S_OK;
 991
 992     TRACE("%p, %u, %p.\n", iface, index, level);
 993
 994     if (!level)
 995         return E_POINTER;
 996
 997     *level = 0.0f;
 998
 999     EnterCriticalSection(&renderer->cs);
1000     if (renderer->stream_volume)
1001         hr = IAudioStreamVolume_GetChannelVolume(renderer->stream_volume, index, level);
1002     LeaveCriticalSection(&renderer->cs);
1003
1004     return hr;
1005 }
1006
1007 static HRESULT WINAPI audio_renderer_stream_volume_SetAllVolumes(IMFAudioStreamVolume *iface, UINT32 count,
1008         const float *volumes)
1009 {
1010     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
1011     HRESULT hr = S_OK;
1012
1013     TRACE("%p, %u, %p.\n", iface, count, volumes);
1014
1015     EnterCriticalSection(&renderer->cs);
1016     if (renderer->stream_volume)
1017         hr = IAudioStreamVolume_SetAllVolumes(renderer->stream_volume, count, volumes);
1018     LeaveCriticalSection(&renderer->cs);
1019
1020     return hr;
1021 }
1022
1023 static HRESULT WINAPI audio_renderer_stream_volume_GetAllVolumes(IMFAudioStreamVolume *iface, UINT32 count, float *volumes)
1024 {
1025     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
1026     HRESULT hr = S_OK;
1027
1028     TRACE("%p, %u, %p.\n", iface, count, volumes);
1029
1030     if (!volumes)
1031         return E_POINTER;
1032
1033     if (count)
1034         memset(volumes, 0, sizeof(*volumes) * count);
1035
1036     EnterCriticalSection(&renderer->cs);
1037     if (renderer->stream_volume)
1038         hr = IAudioStreamVolume_GetAllVolumes(renderer->stream_volume, count, volumes);
1039     LeaveCriticalSection(&renderer->cs);
1040
1041     return hr;
1042 }
1043
1044 static const IMFAudioStreamVolumeVtbl audio_renderer_stream_volume_vtbl =
1045 {
1046     audio_renderer_stream_volume_QueryInterface,
1047     audio_renderer_stream_volume_AddRef,
1048     audio_renderer_stream_volume_Release,
1049     audio_renderer_stream_volume_GetChannelCount,
1050     audio_renderer_stream_volume_SetChannelVolume,
1051     audio_renderer_stream_volume_GetChannelVolume,
1052     audio_renderer_stream_volume_SetAllVolumes,
1053     audio_renderer_stream_volume_GetAllVolumes,
1054 };
1055
1056 static HRESULT WINAPI audio_renderer_policy_QueryInterface(IMFAudioPolicy *iface, REFIID riid, void **obj)
1057 {
1058     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1059
1060     if (IsEqualIID(riid, &IID_IMFAudioPolicy) ||
1061             IsEqualIID(riid, &IID_IUnknown))
1062     {
1063         *obj = iface;
1064         IMFAudioPolicy_AddRef(iface);
1065         return S_OK;
1066     }
1067
1068     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1069     *obj = NULL;
1070     return E_NOINTERFACE;
1071 }
1072
1073 static ULONG WINAPI audio_renderer_policy_AddRef(IMFAudioPolicy *iface)
1074 {
1075     struct audio_renderer *renderer = impl_from_IMFAudioPolicy(iface);
1076     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1077 }
1078
1079 static ULONG WINAPI audio_renderer_policy_Release(IMFAudioPolicy *iface)
1080 {
1081     struct audio_renderer *renderer = impl_from_IMFAudioPolicy(iface);
1082     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1083 }
1084
1085 static HRESULT WINAPI audio_renderer_policy_SetGroupingParam(IMFAudioPolicy *iface, REFGUID param)
1086 {
1087     FIXME("%p, %s.\n", iface, debugstr_guid(param));
1088
1089     return E_NOTIMPL;
1090 }
1091
1092 static HRESULT WINAPI audio_renderer_policy_GetGroupingParam(IMFAudioPolicy *iface, GUID *param)
1093 {
1094     FIXME("%p, %p.\n", iface, param);
1095
1096     return E_NOTIMPL;
1097 }
1098
1099 static HRESULT WINAPI audio_renderer_policy_SetDisplayName(IMFAudioPolicy *iface, const WCHAR *name)
1100 {
1101     FIXME("%p, %s.\n", iface, debugstr_w(name));
1102
1103     return E_NOTIMPL;
1104 }
1105
1106 static HRESULT WINAPI audio_renderer_policy_GetDisplayName(IMFAudioPolicy *iface, WCHAR **name)
1107 {
1108     FIXME("%p, %p.\n", iface, name);
1109
1110     return E_NOTIMPL;
1111 }
1112
1113 static HRESULT WINAPI audio_renderer_policy_SetIconPath(IMFAudioPolicy *iface, const WCHAR *path)
1114 {
1115     FIXME("%p, %s.\n", iface, debugstr_w(path));
1116
1117     return E_NOTIMPL;
1118 }
1119
1120 static HRESULT WINAPI audio_renderer_policy_GetIconPath(IMFAudioPolicy *iface, WCHAR **path)
1121 {
1122     FIXME("%p, %p.\n", iface, path);
1123
1124     return E_NOTIMPL;
1125 }
1126
1127 static const IMFAudioPolicyVtbl audio_renderer_policy_vtbl =
1128 {
1129     audio_renderer_policy_QueryInterface,
1130     audio_renderer_policy_AddRef,
1131     audio_renderer_policy_Release,
1132     audio_renderer_policy_SetGroupingParam,
1133     audio_renderer_policy_GetGroupingParam,
1134     audio_renderer_policy_SetDisplayName,
1135     audio_renderer_policy_GetDisplayName,
1136     audio_renderer_policy_SetIconPath,
1137     audio_renderer_policy_GetIconPath,
1138 };
1139
1140 static HRESULT sar_create_mmdevice(IMFAttributes *attributes, struct audio_renderer *renderer)
1141 {
1142     WCHAR *endpoint;
1143     unsigned int length, role = eMultimedia;
1144     IMMDeviceEnumerator *devenum;
1145     HRESULT hr;
1146
1147     if (attributes)
1148     {
1149         /* Mutually exclusive attributes. */
1150         if (SUCCEEDED(IMFAttributes_GetItem(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE, NULL)) &&
1151                 SUCCEEDED(IMFAttributes_GetItem(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID, NULL)))
1152         {
1153             return E_INVALIDARG;
1154         }
1155     }
1156
1157     if (FAILED(hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator,
1158             (void **)&devenum)))
1159     {
1160         return hr;
1161     }
1162
1163     role = eMultimedia;
1164     if (attributes && SUCCEEDED(IMFAttributes_GetUINT32(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE, &role)))
1165         TRACE("Specified role %d.\n", role);
1166
1167     if (attributes && SUCCEEDED(IMFAttributes_GetAllocatedString(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID,
1168             &endpoint, &length)))
1169     {
1170         TRACE("Specified end point %s.\n", debugstr_w(endpoint));
1171         hr = IMMDeviceEnumerator_GetDevice(devenum, endpoint, &renderer->device);
1172         CoTaskMemFree(endpoint);
1173     }
1174     else
1175         hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, eRender, role, &renderer->device);
1176
1177     /* Configuration attributes to be used later for audio client initialization. */
1178     if (attributes)
1179     {
1180         IMFAttributes_GetUINT32(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS, &renderer->stream_config.flags);
1181         IMFAttributes_GetGUID(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_SESSION_ID, &renderer->stream_config.session_id);
1182     }
1183
1184     if (FAILED(hr))
1185         hr = MF_E_NO_AUDIO_PLAYBACK_DEVICE;
1186
1187     IMMDeviceEnumerator_Release(devenum);
1188
1189     return hr;
1190 }
1191
1192 static HRESULT WINAPI audio_renderer_stream_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj)
1193 {
1194     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1195
1196     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1197
1198     if (IsEqualIID(riid, &IID_IMFStreamSink) ||
1199             IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
1200             IsEqualIID(riid, &IID_IUnknown))
1201     {
1202         *obj = &renderer->IMFStreamSink_iface;
1203     }
1204     else if (IsEqualIID(riid, &IID_IMFMediaTypeHandler))
1205     {
1206         *obj = &renderer->IMFMediaTypeHandler_iface;
1207     }
1208     else
1209     {
1210         WARN("Unsupported %s.\n", debugstr_guid(riid));
1211         *obj = NULL;
1212         return E_NOINTERFACE;
1213     }
1214
1215     IUnknown_AddRef((IUnknown *)*obj);
1216
1217     return S_OK;
1218 }
1219
1220 static ULONG WINAPI audio_renderer_stream_AddRef(IMFStreamSink *iface)
1221 {
1222     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1223     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1224 }
1225
1226 static ULONG WINAPI audio_renderer_stream_Release(IMFStreamSink *iface)
1227 {
1228     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1229     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1230 }
1231
1232 static HRESULT WINAPI audio_renderer_stream_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event)
1233 {
1234     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1235
1236     TRACE("%p, %#x, %p.\n", iface, flags, event);
1237
1238     if (renderer->flags & SAR_SHUT_DOWN)
1239         return MF_E_STREAMSINK_REMOVED;
1240
1241     return IMFMediaEventQueue_GetEvent(renderer->stream_event_queue, flags, event);
1242 }
1243
1244 static HRESULT WINAPI audio_renderer_stream_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback,
1245         IUnknown *state)
1246 {
1247     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1248
1249     TRACE("%p, %p, %p.\n", iface, callback, state);
1250
1251     if (renderer->flags & SAR_SHUT_DOWN)
1252         return MF_E_STREAMSINK_REMOVED;
1253
1254     return IMFMediaEventQueue_BeginGetEvent(renderer->stream_event_queue, callback, state);
1255 }
1256
1257 static HRESULT WINAPI audio_renderer_stream_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result,
1258         IMFMediaEvent **event)
1259 {
1260     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1261
1262     TRACE("%p, %p, %p.\n", iface, result, event);
1263
1264     if (renderer->flags & SAR_SHUT_DOWN)
1265         return MF_E_STREAMSINK_REMOVED;
1266
1267     return IMFMediaEventQueue_EndGetEvent(renderer->stream_event_queue, result, event);
1268 }
1269
1270 static HRESULT WINAPI audio_renderer_stream_QueueEvent(IMFStreamSink *iface, MediaEventType event_type,
1271         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
1272 {
1273     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1274
1275     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
1276
1277     if (renderer->flags & SAR_SHUT_DOWN)
1278         return MF_E_STREAMSINK_REMOVED;
1279
1280     return IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, event_type, ext_type, hr, value);
1281 }
1282
1283 static HRESULT WINAPI audio_renderer_stream_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink)
1284 {
1285     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1286
1287     TRACE("%p, %p.\n", iface, sink);
1288
1289     if (renderer->flags & SAR_SHUT_DOWN)
1290         return MF_E_STREAMSINK_REMOVED;
1291
1292     *sink = &renderer->IMFMediaSink_iface;
1293     IMFMediaSink_AddRef(*sink);
1294
1295     return S_OK;
1296 }
1297
1298 static HRESULT WINAPI audio_renderer_stream_GetIdentifier(IMFStreamSink *iface, DWORD *identifier)
1299 {
1300     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1301
1302     TRACE("%p, %p.\n", iface, identifier);
1303
1304     if (renderer->flags & SAR_SHUT_DOWN)
1305         return MF_E_STREAMSINK_REMOVED;
1306
1307     *identifier = 0;
1308
1309     return S_OK;
1310 }
1311
1312 static HRESULT WINAPI audio_renderer_stream_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler)
1313 {
1314     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1315
1316     TRACE("%p, %p.\n", iface, handler);
1317
1318     if (!handler)
1319         return E_POINTER;
1320
1321     if (renderer->flags & SAR_SHUT_DOWN)
1322         return MF_E_STREAMSINK_REMOVED;
1323
1324     *handler = &renderer->IMFMediaTypeHandler_iface;
1325     IMFMediaTypeHandler_AddRef(*handler);
1326
1327     return S_OK;
1328 }
1329
1330 static HRESULT stream_queue_sample(struct audio_renderer *renderer, IMFSample *sample)
1331 {
1332     struct queued_object *object;
1333
1334     if (!(object = heap_alloc_zero(sizeof(*object))))
1335         return E_OUTOFMEMORY;
1336
1337     object->type = OBJECT_TYPE_SAMPLE;
1338     object->u.sample.sample = sample;
1339     IMFSample_AddRef(object->u.sample.sample);
1340
1341     list_add_tail(&renderer->queue, &object->entry);
1342
1343     return S_OK;
1344 }
1345
1346 static HRESULT WINAPI audio_renderer_stream_ProcessSample(IMFStreamSink *iface, IMFSample *sample)
1347 {
1348     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1349     HRESULT hr = S_OK;
1350
1351     TRACE("%p, %p.\n", iface, sample);
1352
1353     if (!sample)
1354         return E_POINTER;
1355
1356     if (renderer->flags & SAR_SHUT_DOWN)
1357         return MF_E_STREAMSINK_REMOVED;
1358
1359     EnterCriticalSection(&renderer->cs);
1360     if (renderer->state == STREAM_STATE_RUNNING)
1361         hr = stream_queue_sample(renderer, sample);
1362     renderer->flags &= ~SAR_SAMPLE_REQUESTED;
1363     LeaveCriticalSection(&renderer->cs);
1364
1365     return hr;
1366 }
1367
1368 static HRESULT stream_place_marker(struct audio_renderer *renderer, MFSTREAMSINK_MARKER_TYPE marker_type,
1369         const PROPVARIANT *context_value)
1370 {
1371     struct queued_object *marker;
1372     HRESULT hr = S_OK;
1373
1374     if (!(marker = heap_alloc_zero(sizeof(*marker))))
1375         return E_OUTOFMEMORY;
1376
1377     marker->type = OBJECT_TYPE_MARKER;
1378     marker->u.marker.type = marker_type;
1379     PropVariantInit(&marker->u.marker.context);
1380     if (context_value)
1381         hr = PropVariantCopy(&marker->u.marker.context, context_value);
1382     if (SUCCEEDED(hr))
1383         list_add_tail(&renderer->queue, &marker->entry);
1384     else
1385         release_pending_object(marker);
1386
1387     return hr;
1388 }
1389
1390 static HRESULT WINAPI audio_renderer_stream_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type,
1391         const PROPVARIANT *marker_value, const PROPVARIANT *context_value)
1392 {
1393     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1394     HRESULT hr;
1395
1396     TRACE("%p, %d, %p, %p.\n", iface, marker_type, marker_value, context_value);
1397
1398     if (renderer->flags & SAR_SHUT_DOWN)
1399         return MF_E_STREAMSINK_REMOVED;
1400
1401     EnterCriticalSection(&renderer->cs);
1402     hr = stream_place_marker(renderer, marker_type, context_value);
1403     LeaveCriticalSection(&renderer->cs);
1404
1405     return hr;
1406 }
1407
1408 static HRESULT WINAPI audio_renderer_stream_Flush(IMFStreamSink *iface)
1409 {
1410     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1411     struct queued_object *obj, *obj2;
1412     HRESULT hr = S_OK;
1413
1414     TRACE("%p.\n", iface);
1415
1416     EnterCriticalSection(&renderer->cs);
1417     if (renderer->flags & SAR_SHUT_DOWN)
1418         hr = MF_E_STREAMSINK_REMOVED;
1419     else
1420     {
1421         LIST_FOR_EACH_ENTRY_SAFE(obj, obj2, &renderer->queue, struct queued_object, entry)
1422         {
1423             if (obj->type == OBJECT_TYPE_MARKER)
1424             {
1425                 IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkMarker,
1426                         &GUID_NULL, S_OK, &obj->u.marker.context);
1427             }
1428             release_pending_object(obj);
1429         }
1430     }
1431     LeaveCriticalSection(&renderer->cs);
1432
1433     return hr;
1434 }
1435
1436 static const IMFStreamSinkVtbl audio_renderer_stream_vtbl =
1437 {
1438     audio_renderer_stream_QueryInterface,
1439     audio_renderer_stream_AddRef,
1440     audio_renderer_stream_Release,
1441     audio_renderer_stream_GetEvent,
1442     audio_renderer_stream_BeginGetEvent,
1443     audio_renderer_stream_EndGetEvent,
1444     audio_renderer_stream_QueueEvent,
1445     audio_renderer_stream_GetMediaSink,
1446     audio_renderer_stream_GetIdentifier,
1447     audio_renderer_stream_GetMediaTypeHandler,
1448     audio_renderer_stream_ProcessSample,
1449     audio_renderer_stream_PlaceMarker,
1450     audio_renderer_stream_Flush,
1451 };
1452
1453 static HRESULT WINAPI audio_renderer_stream_type_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid,
1454         void **obj)
1455 {
1456     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1457     return IMFStreamSink_QueryInterface(&renderer->IMFStreamSink_iface, riid, obj);
1458 }
1459
1460 static ULONG WINAPI audio_renderer_stream_type_handler_AddRef(IMFMediaTypeHandler *iface)
1461 {
1462     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1463     return IMFStreamSink_AddRef(&renderer->IMFStreamSink_iface);
1464 }
1465
1466 static ULONG WINAPI audio_renderer_stream_type_handler_Release(IMFMediaTypeHandler *iface)
1467 {
1468     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1469     return IMFStreamSink_Release(&renderer->IMFStreamSink_iface);
1470 }
1471
1472 static HRESULT WINAPI audio_renderer_stream_type_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface,
1473         IMFMediaType *in_type, IMFMediaType **out_type)
1474 {
1475     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1476     unsigned int flags;
1477     HRESULT hr;
1478
1479     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
1480
1481     EnterCriticalSection(&renderer->cs);
1482     hr = renderer->current_media_type && IMFMediaType_IsEqual(renderer->current_media_type, in_type, &flags) == S_OK ?
1483             S_OK : MF_E_INVALIDMEDIATYPE;
1484     LeaveCriticalSection(&renderer->cs);
1485
1486     return hr;
1487 }
1488
1489 static HRESULT WINAPI audio_renderer_stream_type_handler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
1490 {
1491     TRACE("%p, %p.\n", iface, count);
1492
1493     *count = 1;
1494
1495     return S_OK;
1496 }
1497
1498 static HRESULT WINAPI audio_renderer_stream_type_handler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
1499         IMFMediaType **media_type)
1500 {
1501     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1502
1503     TRACE("%p, %u, %p.\n", iface, index, media_type);
1504
1505     if (index == 0)
1506     {
1507         *media_type = renderer->media_type;
1508         IMFMediaType_AddRef(*media_type);
1509     }
1510
1511     return S_OK;
1512 }
1513
1514 static HRESULT audio_renderer_create_audio_client(struct audio_renderer *renderer)
1515 {
1516     IMFAsyncResult *result;
1517     unsigned int flags;
1518     WAVEFORMATEX *wfx;
1519     HRESULT hr;
1520
1521     audio_renderer_release_audio_client(renderer);
1522
1523     hr = IMMDevice_Activate(renderer->device, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL,
1524             (void **)&renderer->audio_client);
1525     if (FAILED(hr))
1526     {
1527         WARN("Failed to create audio client, hr %#x.\n", hr);
1528         return hr;
1529     }
1530
1531     /* FIXME: for now always use default format. */
1532     if (FAILED(hr = IAudioClient_GetMixFormat(renderer->audio_client, &wfx)))
1533     {
1534         WARN("Failed to get audio format, hr %#x.\n", hr);
1535         return hr;
1536     }
1537
1538     renderer->frame_size = wfx->wBitsPerSample * wfx->nChannels / 8;
1539
1540     flags = AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
1541     if (renderer->stream_config.flags & MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS_CROSSPROCESS)
1542         flags |= AUDCLNT_STREAMFLAGS_CROSSPROCESS;
1543     if (renderer->stream_config.flags & MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS_NOPERSIST)
1544         flags |= AUDCLNT_STREAMFLAGS_NOPERSIST;
1545     hr = IAudioClient_Initialize(renderer->audio_client, AUDCLNT_SHAREMODE_SHARED, flags, 1000000, 0, wfx,
1546             &renderer->stream_config.session_id);
1547     CoTaskMemFree(wfx);
1548     if (FAILED(hr))
1549     {
1550         WARN("Failed to initialize audio client, hr %#x.\n", hr);
1551         return hr;
1552     }
1553
1554     if (FAILED(hr = IAudioClient_GetService(renderer->audio_client, &IID_IAudioStreamVolume,
1555             (void **)&renderer->stream_volume)))
1556     {
1557         WARN("Failed to get stream volume control, hr %#x.\n", hr);
1558         return hr;
1559     }
1560
1561     if (FAILED(hr = IAudioClient_GetService(renderer->audio_client, &IID_ISimpleAudioVolume, (void **)&renderer->audio_volume)))
1562     {
1563         WARN("Failed to get audio volume control, hr %#x.\n", hr);
1564         return hr;
1565     }
1566
1567     if (FAILED(hr = IAudioClient_GetService(renderer->audio_client, &IID_IAudioRenderClient,
1568             (void **)&renderer->audio_render_client)))
1569     {
1570         WARN("Failed to get audio render client, hr %#x.\n", hr);
1571         return hr;
1572     }
1573
1574     if (FAILED(hr = IAudioClient_SetEventHandle(renderer->audio_client, renderer->buffer_ready_event)))
1575     {
1576         WARN("Failed to set event handle, hr %#x.\n", hr);
1577         return hr;
1578     }
1579
1580     if (SUCCEEDED(hr = MFCreateAsyncResult(NULL, &renderer->render_callback, NULL, &result)))
1581     {
1582         if (FAILED(hr = MFPutWaitingWorkItem(renderer->buffer_ready_event, 0, result, &renderer->buffer_ready_key)))
1583             WARN("Failed to submit wait item, hr %#x.\n", hr);
1584         IMFAsyncResult_Release(result);
1585     }
1586
1587     return hr;
1588 }
1589
1590 static HRESULT WINAPI audio_renderer_stream_type_handler_SetCurrentMediaType(IMFMediaTypeHandler *iface,
1591         IMFMediaType *media_type)
1592 {
1593     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1594     const unsigned int test_flags = MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES;
1595     BOOL compare_result;
1596     unsigned int flags;
1597     HRESULT hr = S_OK;
1598
1599     TRACE("%p, %p.\n", iface, media_type);
1600
1601     if (!media_type)
1602         return E_POINTER;
1603
1604     EnterCriticalSection(&renderer->cs);
1605     if (SUCCEEDED(IMFMediaType_IsEqual(renderer->media_type, media_type, &flags)) && ((flags & test_flags) == test_flags))
1606     {
1607         if (renderer->current_media_type)
1608             IMFMediaType_Release(renderer->current_media_type);
1609         renderer->current_media_type = media_type;
1610         IMFMediaType_AddRef(renderer->current_media_type);
1611
1612         if (SUCCEEDED(hr = audio_renderer_create_audio_client(renderer)))
1613         {
1614             if (SUCCEEDED(IMFMediaType_Compare(renderer->media_type, (IMFAttributes *)media_type, MF_ATTRIBUTES_MATCH_OUR_ITEMS,
1615                     &compare_result)) && !compare_result)
1616             {
1617                 IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkFormatInvalidated, &GUID_NULL,
1618                         S_OK, NULL);
1619                 audio_renderer_preroll(renderer);
1620             }
1621         }
1622     }
1623     else
1624         hr = MF_E_INVALIDMEDIATYPE;
1625     LeaveCriticalSection(&renderer->cs);
1626
1627     return hr;
1628 }
1629
1630 static HRESULT WINAPI audio_renderer_stream_type_handler_GetCurrentMediaType(IMFMediaTypeHandler *iface,
1631         IMFMediaType **media_type)
1632 {
1633     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1634     HRESULT hr = S_OK;
1635
1636     TRACE("%p, %p.\n", iface, media_type);
1637
1638     EnterCriticalSection(&renderer->cs);
1639     if (renderer->current_media_type)
1640     {
1641         *media_type = renderer->current_media_type;
1642         IMFMediaType_AddRef(*media_type);
1643     }
1644     else
1645         hr = MF_E_NOT_INITIALIZED;
1646     LeaveCriticalSection(&renderer->cs);
1647
1648     return hr;
1649 }
1650
1651 static HRESULT WINAPI audio_renderer_stream_type_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
1652 {
1653     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1654
1655     TRACE("%p, %p.\n", iface, type);
1656
1657     if (!type)
1658         return E_POINTER;
1659
1660     if (renderer->flags & SAR_SHUT_DOWN)
1661         return MF_E_STREAMSINK_REMOVED;
1662
1663     memcpy(type, &MFMediaType_Audio, sizeof(*type));
1664     return S_OK;
1665 }
1666
1667 static const IMFMediaTypeHandlerVtbl audio_renderer_stream_type_handler_vtbl =
1668 {
1669     audio_renderer_stream_type_handler_QueryInterface,
1670     audio_renderer_stream_type_handler_AddRef,
1671     audio_renderer_stream_type_handler_Release,
1672     audio_renderer_stream_type_handler_IsMediaTypeSupported,
1673     audio_renderer_stream_type_handler_GetMediaTypeCount,
1674     audio_renderer_stream_type_handler_GetMediaTypeByIndex,
1675     audio_renderer_stream_type_handler_SetCurrentMediaType,
1676     audio_renderer_stream_type_handler_GetCurrentMediaType,
1677     audio_renderer_stream_type_handler_GetMajorType,
1678 };
1679
1680 static HRESULT audio_renderer_collect_supported_types(struct audio_renderer *renderer)
1681 {
1682     IAudioClient *client;
1683     WAVEFORMATEX *format;
1684     HRESULT hr;
1685
1686     if (FAILED(hr = MFCreateMediaType(&renderer->media_type)))
1687         return hr;
1688
1689     hr = IMMDevice_Activate(renderer->device, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, (void **)&client);
1690     if (FAILED(hr))
1691     {
1692         WARN("Failed to create audio client, hr %#x.\n", hr);
1693         return hr;
1694     }
1695
1696     /* FIXME:  */
1697
1698     hr = IAudioClient_GetMixFormat(client, &format);
1699     IAudioClient_Release(client);
1700     if (FAILED(hr))
1701     {
1702         WARN("Failed to get device audio format, hr %#x.\n", hr);
1703         return hr;
1704     }
1705
1706     hr = MFInitMediaTypeFromWaveFormatEx(renderer->media_type, format, format->cbSize + sizeof(*format));
1707     CoTaskMemFree(format);
1708     if (FAILED(hr))
1709     {
1710         WARN("Failed to initialize media type, hr %#x.\n", hr);
1711         return hr;
1712     }
1713
1714     IMFMediaType_DeleteItem(renderer->media_type, &MF_MT_AUDIO_PREFER_WAVEFORMATEX);
1715
1716     return hr;
1717 }
1718
1719 static HRESULT WINAPI audio_renderer_render_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
1720 {
1721     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1722
1723     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
1724             IsEqualIID(riid, &IID_IUnknown))
1725     {
1726         *obj = iface;
1727         IMFAsyncCallback_AddRef(iface);
1728         return S_OK;
1729     }
1730
1731     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1732     *obj = NULL;
1733     return E_NOINTERFACE;
1734 }
1735
1736 static ULONG WINAPI audio_renderer_render_callback_AddRef(IMFAsyncCallback *iface)
1737 {
1738     struct audio_renderer *renderer = impl_from_render_callback_IMFAsyncCallback(iface);
1739     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1740 }
1741
1742 static ULONG WINAPI audio_renderer_render_callback_Release(IMFAsyncCallback *iface)
1743 {
1744     struct audio_renderer *renderer = impl_from_render_callback_IMFAsyncCallback(iface);
1745     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1746 }
1747
1748 static HRESULT WINAPI audio_renderer_render_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
1749 {
1750     return E_NOTIMPL;
1751 }
1752
1753 static HRESULT WINAPI audio_renderer_render_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1754 {
1755     struct audio_renderer *renderer = impl_from_render_callback_IMFAsyncCallback(iface);
1756     unsigned int src_frames, dst_frames, max_frames, src_len;
1757     struct queued_object *obj, *obj2;
1758     BOOL keep_sample = FALSE;
1759     IMFMediaBuffer *buffer;
1760     BYTE *dst, *src;
1761     HRESULT hr;
1762
1763     EnterCriticalSection(&renderer->cs);
1764
1765     LIST_FOR_EACH_ENTRY_SAFE(obj, obj2, &renderer->queue, struct queued_object, entry)
1766     {
1767         if (obj->type == OBJECT_TYPE_MARKER)
1768         {
1769             IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkMarker,
1770                 &GUID_NULL, S_OK, &obj->u.marker.context);
1771         }
1772         else if (obj->type == OBJECT_TYPE_SAMPLE)
1773         {
1774             if (SUCCEEDED(IMFSample_ConvertToContiguousBuffer(obj->u.sample.sample, &buffer)))
1775             {
1776                 if (SUCCEEDED(IMFMediaBuffer_Lock(buffer, &src, NULL, &src_len)))
1777                 {
1778                     if ((src_frames = src_len / renderer->frame_size))
1779                     {
1780                         if (SUCCEEDED(IAudioClient_GetBufferSize(renderer->audio_client, &max_frames)))
1781                         {
1782                             src_frames -= obj->u.sample.frame_offset;
1783                             dst_frames = min(src_frames, max_frames);
1784
1785                             if (SUCCEEDED(hr = IAudioRenderClient_GetBuffer(renderer->audio_render_client, dst_frames, &dst)))
1786                             {
1787                                 memcpy(dst, src + obj->u.sample.frame_offset * renderer->frame_size,
1788                                         dst_frames * renderer->frame_size);
1789
1790                                 IAudioRenderClient_ReleaseBuffer(renderer->audio_render_client, dst_frames, 0);
1791
1792                                 obj->u.sample.frame_offset += dst_frames;
1793                             }
1794
1795                             keep_sample = FAILED(hr) || src_frames > max_frames;
1796                         }
1797                     }
1798                     IMFMediaBuffer_Unlock(buffer);
1799                 }
1800                 IMFMediaBuffer_Release(buffer);
1801             }
1802         }
1803
1804         if (keep_sample)
1805             break;
1806
1807         list_remove(&obj->entry);
1808         release_pending_object(obj);
1809     }
1810
1811     if (list_empty(&renderer->queue) && !(renderer->flags & SAR_SAMPLE_REQUESTED))
1812     {
1813         IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
1814         renderer->flags |= SAR_SAMPLE_REQUESTED;
1815     }
1816
1817     if (FAILED(hr = MFPutWaitingWorkItem(renderer->buffer_ready_event, 0, result, &renderer->buffer_ready_key)))
1818         WARN("Failed to submit wait item, hr %#x.\n", hr);
1819
1820     LeaveCriticalSection(&renderer->cs);
1821
1822     return S_OK;
1823 }
1824
1825 static const IMFAsyncCallbackVtbl audio_renderer_render_callback_vtbl =
1826 {
1827     audio_renderer_render_callback_QueryInterface,
1828     audio_renderer_render_callback_AddRef,
1829     audio_renderer_render_callback_Release,
1830     audio_renderer_render_callback_GetParameters,
1831     audio_renderer_render_callback_Invoke,
1832 };
1833
1834 static HRESULT sar_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj)
1835 {
1836     struct audio_renderer *renderer;
1837     HRESULT hr;
1838
1839     TRACE("%p, %p, %p.\n", attributes, user_context, obj);
1840
1841     if (!(renderer = heap_alloc_zero(sizeof(*renderer))))
1842         return E_OUTOFMEMORY;
1843
1844     renderer->IMFMediaSink_iface.lpVtbl = &audio_renderer_sink_vtbl;
1845     renderer->IMFMediaSinkPreroll_iface.lpVtbl = &audio_renderer_preroll_vtbl;
1846     renderer->IMFStreamSink_iface.lpVtbl = &audio_renderer_stream_vtbl;
1847     renderer->IMFMediaTypeHandler_iface.lpVtbl = &audio_renderer_stream_type_handler_vtbl;
1848     renderer->IMFClockStateSink_iface.lpVtbl = &audio_renderer_clock_sink_vtbl;
1849     renderer->IMFMediaEventGenerator_iface.lpVtbl = &audio_renderer_events_vtbl;
1850     renderer->IMFGetService_iface.lpVtbl = &audio_renderer_get_service_vtbl;
1851     renderer->IMFSimpleAudioVolume_iface.lpVtbl = &audio_renderer_simple_volume_vtbl;
1852     renderer->IMFAudioStreamVolume_iface.lpVtbl = &audio_renderer_stream_volume_vtbl;
1853     renderer->IMFAudioPolicy_iface.lpVtbl = &audio_renderer_policy_vtbl;
1854     renderer->render_callback.lpVtbl = &audio_renderer_render_callback_vtbl;
1855     renderer->refcount = 1;
1856     InitializeCriticalSection(&renderer->cs);
1857     renderer->buffer_ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1858     list_init(&renderer->queue);
1859
1860     if (FAILED(hr = MFCreateEventQueue(&renderer->event_queue)))
1861         goto failed;
1862
1863     if (FAILED(hr = MFCreateEventQueue(&renderer->stream_event_queue)))
1864         goto failed;
1865
1866     if (FAILED(hr = sar_create_mmdevice(attributes, renderer)))
1867         goto failed;
1868
1869     if (FAILED(hr = audio_renderer_collect_supported_types(renderer)))
1870         goto failed;
1871
1872     *obj = (IUnknown *)&renderer->IMFMediaSink_iface;
1873
1874     return S_OK;
1875
1876 failed:
1877
1878     IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1879
1880     return hr;
1881 }
1882
1883 static void sar_shutdown_object(void *user_context, IUnknown *obj)
1884 {
1885     IMFMediaSink *sink;
1886
1887     if (SUCCEEDED(IUnknown_QueryInterface(obj, &IID_IMFMediaSink, (void **)&sink)))
1888     {
1889         IMFMediaSink_Shutdown(sink);
1890         IMFMediaSink_Release(sink);
1891     }
1892 }
1893
1894 static const struct activate_funcs sar_activate_funcs =
1895 {
1896     .create_object = sar_create_object,
1897     .shutdown_object = sar_shutdown_object,
1898 };
1899
1900 /***********************************************************************
1901  *      MFCreateAudioRendererActivate (mf.@)
1902  */
1903 HRESULT WINAPI MFCreateAudioRendererActivate(IMFActivate **activate)
1904 {
1905     TRACE("%p.\n", activate);
1906
1907     if (!activate)
1908         return E_POINTER;
1909
1910     return create_activation_object(NULL, &sar_activate_funcs, activate);
1911 }
1912
1913 /***********************************************************************
1914  *      MFCreateAudioRenderer (mf.@)
1915  */
1916 HRESULT WINAPI MFCreateAudioRenderer(IMFAttributes *attributes, IMFMediaSink **sink)
1917 {
1918     IUnknown *object;
1919     HRESULT hr;
1920
1921     TRACE("%p, %p.\n", attributes, sink);
1922
1923     if (SUCCEEDED(hr = sar_create_object(attributes, NULL, &object)))
1924     {
1925         hr = IUnknown_QueryInterface(object, &IID_IMFMediaSink, (void **)sink);
1926         IUnknown_Release(object);
1927     }
1928
1929     return hr;
1930 }