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     struct queued_object *obj, *obj2;
 232
 233     MFCancelWorkItem(renderer->buffer_ready_key);
 234     LIST_FOR_EACH_ENTRY_SAFE(obj, obj2, &renderer->queue, struct queued_object, entry)
 235     {
 236         release_pending_object(obj);
 237     }
 238     renderer->buffer_ready_key = 0;
 239     if (renderer->audio_client)
 240     {
 241         IAudioClient_Stop(renderer->audio_client);
 242         IAudioClient_Reset(renderer->audio_client);
 243         IAudioClient_Release(renderer->audio_client);
 244     }
 245     renderer->audio_client = NULL;
 246     if (renderer->audio_render_client)
 247         IAudioRenderClient_Release(renderer->audio_render_client);
 248     renderer->audio_render_client = NULL;
 249     if (renderer->stream_volume)
 250         IAudioStreamVolume_Release(renderer->stream_volume);
 251     renderer->stream_volume = NULL;
 252     if (renderer->audio_volume)
 253         ISimpleAudioVolume_Release(renderer->audio_volume);
 254     renderer->audio_volume = NULL;
 255     renderer->flags &= ~SAR_PREROLLED;
 256 }
 257
 258 static ULONG WINAPI audio_renderer_sink_Release(IMFMediaSink *iface)
 259 {
 260     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 261     ULONG refcount = InterlockedDecrement(&renderer->refcount);
 262
 263     TRACE("%p, refcount %u.\n", iface, refcount);
 264
 265     if (!refcount)
 266     {
 267         if (renderer->event_queue)
 268             IMFMediaEventQueue_Release(renderer->event_queue);
 269         if (renderer->stream_event_queue)
 270             IMFMediaEventQueue_Release(renderer->stream_event_queue);
 271         if (renderer->clock)
 272             IMFPresentationClock_Release(renderer->clock);
 273         if (renderer->device)
 274             IMMDevice_Release(renderer->device);
 275         if (renderer->media_type)
 276             IMFMediaType_Release(renderer->media_type);
 277         if (renderer->current_media_type)
 278             IMFMediaType_Release(renderer->current_media_type);
 279         audio_renderer_release_audio_client(renderer);
 280         CloseHandle(renderer->buffer_ready_event);
 281         DeleteCriticalSection(&renderer->cs);
 282         heap_free(renderer);
 283     }
 284
 285     return refcount;
 286 }
 287
 288 static HRESULT WINAPI audio_renderer_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags)
 289 {
 290     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 291
 292     TRACE("%p, %p.\n", iface, flags);
 293
 294     if (renderer->flags & SAR_SHUT_DOWN)
 295         return MF_E_SHUTDOWN;
 296
 297     *flags = MEDIASINK_FIXED_STREAMS | MEDIASINK_CAN_PREROLL;
 298
 299     return S_OK;
 300 }
 301
 302 static HRESULT WINAPI audio_renderer_sink_AddStreamSink(IMFMediaSink *iface, DWORD stream_sink_id,
 303     IMFMediaType *media_type, IMFStreamSink **stream_sink)
 304 {
 305     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 306
 307     TRACE("%p, %#x, %p, %p.\n", iface, stream_sink_id, media_type, stream_sink);
 308
 309     return renderer->flags & SAR_SHUT_DOWN ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 310 }
 311
 312 static HRESULT WINAPI audio_renderer_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id)
 313 {
 314     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 315
 316     TRACE("%p, %#x.\n", iface, stream_sink_id);
 317
 318     return renderer->flags & SAR_SHUT_DOWN ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 319 }
 320
 321 static HRESULT WINAPI audio_renderer_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
 322 {
 323     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 324
 325     TRACE("%p, %p.\n", iface, count);
 326
 327     if (!count)
 328         return E_POINTER;
 329
 330     if (renderer->flags & SAR_SHUT_DOWN)
 331         return MF_E_SHUTDOWN;
 332
 333     *count = 1;
 334
 335     return S_OK;
 336 }
 337
 338 static HRESULT WINAPI audio_renderer_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index,
 339         IMFStreamSink **stream)
 340 {
 341     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 342     HRESULT hr = S_OK;
 343
 344     TRACE("%p, %u, %p.\n", iface, index, stream);
 345
 346     EnterCriticalSection(&renderer->cs);
 347
 348     if (renderer->flags & SAR_SHUT_DOWN)
 349         hr = MF_E_SHUTDOWN;
 350     else if (index > 0)
 351         hr = MF_E_INVALIDINDEX;
 352     else
 353     {
 354        *stream = &renderer->IMFStreamSink_iface;
 355        IMFStreamSink_AddRef(*stream);
 356     }
 357
 358     LeaveCriticalSection(&renderer->cs);
 359
 360     return hr;
 361 }
 362
 363 static HRESULT WINAPI audio_renderer_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id,
 364         IMFStreamSink **stream)
 365 {
 366     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 367     HRESULT hr = S_OK;
 368
 369     TRACE("%p, %#x, %p.\n", iface, stream_sink_id, stream);
 370
 371     EnterCriticalSection(&renderer->cs);
 372
 373     if (renderer->flags & SAR_SHUT_DOWN)
 374         hr = MF_E_SHUTDOWN;
 375     else if (stream_sink_id > 0)
 376         hr = MF_E_INVALIDSTREAMNUMBER;
 377     else
 378     {
 379         *stream = &renderer->IMFStreamSink_iface;
 380         IMFStreamSink_AddRef(*stream);
 381     }
 382
 383     LeaveCriticalSection(&renderer->cs);
 384
 385     return hr;
 386 }
 387
 388 static void audio_renderer_set_presentation_clock(struct audio_renderer *renderer, IMFPresentationClock *clock)
 389 {
 390     if (renderer->clock)
 391     {
 392         IMFPresentationClock_RemoveClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
 393         IMFPresentationClock_Release(renderer->clock);
 394     }
 395     renderer->clock = clock;
 396     if (renderer->clock)
 397     {
 398         IMFPresentationClock_AddRef(renderer->clock);
 399         IMFPresentationClock_AddClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
 400     }
 401 }
 402
 403 static HRESULT WINAPI audio_renderer_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
 404 {
 405     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 406     HRESULT hr = S_OK;
 407
 408     TRACE("%p, %p.\n", iface, clock);
 409
 410     EnterCriticalSection(&renderer->cs);
 411
 412     if (renderer->flags & SAR_SHUT_DOWN)
 413         hr = MF_E_SHUTDOWN;
 414     else
 415         audio_renderer_set_presentation_clock(renderer, clock);
 416
 417     LeaveCriticalSection(&renderer->cs);
 418
 419     return hr;
 420 }
 421
 422 static HRESULT WINAPI audio_renderer_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
 423 {
 424     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 425     HRESULT hr = S_OK;
 426
 427     TRACE("%p, %p.\n", iface, clock);
 428
 429     if (!clock)
 430         return E_POINTER;
 431
 432     EnterCriticalSection(&renderer->cs);
 433
 434     if (renderer->flags & SAR_SHUT_DOWN)
 435         hr = MF_E_SHUTDOWN;
 436     else if (renderer->clock)
 437     {
 438         *clock = renderer->clock;
 439         IMFPresentationClock_AddRef(*clock);
 440     }
 441     else
 442         hr = MF_E_NO_CLOCK;
 443
 444     LeaveCriticalSection(&renderer->cs);
 445
 446     return hr;
 447 }
 448
 449 static HRESULT WINAPI audio_renderer_sink_Shutdown(IMFMediaSink *iface)
 450 {
 451     struct audio_renderer *renderer = impl_from_IMFMediaSink(iface);
 452
 453     TRACE("%p.\n", iface);
 454
 455     if (renderer->flags & SAR_SHUT_DOWN)
 456         return MF_E_SHUTDOWN;
 457
 458     EnterCriticalSection(&renderer->cs);
 459     renderer->flags |= SAR_SHUT_DOWN;
 460     IMFMediaEventQueue_Shutdown(renderer->event_queue);
 461     IMFMediaEventQueue_Shutdown(renderer->stream_event_queue);
 462     audio_renderer_set_presentation_clock(renderer, NULL);
 463     audio_renderer_release_audio_client(renderer);
 464     LeaveCriticalSection(&renderer->cs);
 465
 466     return S_OK;
 467 }
 468
 469 static const IMFMediaSinkVtbl audio_renderer_sink_vtbl =
 470 {
 471     audio_renderer_sink_QueryInterface,
 472     audio_renderer_sink_AddRef,
 473     audio_renderer_sink_Release,
 474     audio_renderer_sink_GetCharacteristics,
 475     audio_renderer_sink_AddStreamSink,
 476     audio_renderer_sink_RemoveStreamSink,
 477     audio_renderer_sink_GetStreamSinkCount,
 478     audio_renderer_sink_GetStreamSinkByIndex,
 479     audio_renderer_sink_GetStreamSinkById,
 480     audio_renderer_sink_SetPresentationClock,
 481     audio_renderer_sink_GetPresentationClock,
 482     audio_renderer_sink_Shutdown,
 483 };
 484
 485 static void audio_renderer_preroll(struct audio_renderer *renderer)
 486 {
 487     unsigned int i;
 488
 489     if (renderer->flags & SAR_PREROLLED)
 490         return;
 491
 492     for (i = 0; i < 2; ++i)
 493         IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
 494     renderer->flags |= SAR_PREROLLED;
 495 }
 496
 497 static HRESULT WINAPI audio_renderer_preroll_QueryInterface(IMFMediaSinkPreroll *iface, REFIID riid, void **obj)
 498 {
 499     struct audio_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 500     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 501 }
 502
 503 static ULONG WINAPI audio_renderer_preroll_AddRef(IMFMediaSinkPreroll *iface)
 504 {
 505     struct audio_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 506     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 507 }
 508
 509 static ULONG WINAPI audio_renderer_preroll_Release(IMFMediaSinkPreroll *iface)
 510 {
 511     struct audio_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 512     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 513 }
 514
 515 static HRESULT WINAPI audio_renderer_preroll_NotifyPreroll(IMFMediaSinkPreroll *iface, MFTIME start_time)
 516 {
 517     struct audio_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 518
 519     TRACE("%p, %s.\n", iface, debugstr_time(start_time));
 520
 521     if (renderer->flags & SAR_SHUT_DOWN)
 522         return MF_E_SHUTDOWN;
 523
 524     audio_renderer_preroll(renderer);
 525     return IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkPrerolled, &GUID_NULL, S_OK, NULL);
 526 }
 527
 528 static const IMFMediaSinkPrerollVtbl audio_renderer_preroll_vtbl =
 529 {
 530     audio_renderer_preroll_QueryInterface,
 531     audio_renderer_preroll_AddRef,
 532     audio_renderer_preroll_Release,
 533     audio_renderer_preroll_NotifyPreroll,
 534 };
 535
 536 static HRESULT WINAPI audio_renderer_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
 537 {
 538     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 539     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 540 }
 541
 542 static ULONG WINAPI audio_renderer_events_AddRef(IMFMediaEventGenerator *iface)
 543 {
 544     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 545     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 546 }
 547
 548 static ULONG WINAPI audio_renderer_events_Release(IMFMediaEventGenerator *iface)
 549 {
 550     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 551     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 552 }
 553
 554 static HRESULT WINAPI audio_renderer_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
 555 {
 556     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 557
 558     TRACE("%p, %#x, %p.\n", iface, flags, event);
 559
 560     return IMFMediaEventQueue_GetEvent(renderer->event_queue, flags, event);
 561 }
 562
 563 static HRESULT WINAPI audio_renderer_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
 564         IUnknown *state)
 565 {
 566     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 567
 568     TRACE("%p, %p, %p.\n", iface, callback, state);
 569
 570     return IMFMediaEventQueue_BeginGetEvent(renderer->event_queue, callback, state);
 571 }
 572
 573 static HRESULT WINAPI audio_renderer_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
 574         IMFMediaEvent **event)
 575 {
 576     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 577
 578     TRACE("%p, %p, %p.\n", iface, result, event);
 579
 580     return IMFMediaEventQueue_EndGetEvent(renderer->event_queue, result, event);
 581 }
 582
 583 static HRESULT WINAPI audio_renderer_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
 584         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 585 {
 586     struct audio_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 587
 588     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
 589
 590     return IMFMediaEventQueue_QueueEventParamVar(renderer->event_queue, event_type, ext_type, hr, value);
 591 }
 592
 593 static const IMFMediaEventGeneratorVtbl audio_renderer_events_vtbl =
 594 {
 595     audio_renderer_events_QueryInterface,
 596     audio_renderer_events_AddRef,
 597     audio_renderer_events_Release,
 598     audio_renderer_events_GetEvent,
 599     audio_renderer_events_BeginGetEvent,
 600     audio_renderer_events_EndGetEvent,
 601     audio_renderer_events_QueueEvent,
 602 };
 603
 604 static HRESULT WINAPI audio_renderer_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
 605 {
 606     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 607     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 608 }
 609
 610 static ULONG WINAPI audio_renderer_clock_sink_AddRef(IMFClockStateSink *iface)
 611 {
 612     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 613     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 614 }
 615
 616 static ULONG WINAPI audio_renderer_clock_sink_Release(IMFClockStateSink *iface)
 617 {
 618     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 619     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 620 }
 621
 622 static HRESULT WINAPI audio_renderer_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
 623 {
 624     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 625     HRESULT hr = S_OK;
 626
 627     TRACE("%p, %s, %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
 628
 629     EnterCriticalSection(&renderer->cs);
 630     if (renderer->audio_client)
 631     {
 632         if (renderer->state == STREAM_STATE_STOPPED)
 633         {
 634             if (FAILED(hr = IAudioClient_Start(renderer->audio_client)))
 635                 WARN("Failed to start audio client, hr %#x.\n", hr);
 636             renderer->state = STREAM_STATE_RUNNING;
 637         }
 638     }
 639     else
 640         hr = MF_E_NOT_INITIALIZED;
 641
 642     IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkStarted, &GUID_NULL, hr, NULL);
 643     if (SUCCEEDED(hr))
 644         audio_renderer_preroll(renderer);
 645     LeaveCriticalSection(&renderer->cs);
 646
 647     return hr;
 648 }
 649
 650 static HRESULT WINAPI audio_renderer_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
 651 {
 652     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 653     HRESULT hr = S_OK;
 654
 655     TRACE("%p, %s.\n", iface, debugstr_time(systime));
 656
 657     EnterCriticalSection(&renderer->cs);
 658     if (renderer->audio_client)
 659     {
 660         if (renderer->state != STREAM_STATE_STOPPED)
 661         {
 662             if (SUCCEEDED(hr = IAudioClient_Stop(renderer->audio_client)))
 663             {
 664                 if (FAILED(hr = IAudioClient_Reset(renderer->audio_client)))
 665                     WARN("Failed to reset audio client, hr %#x.\n", hr);
 666             }
 667             else
 668                 WARN("Failed to stop audio client, hr %#x.\n", hr);
 669             renderer->state = STREAM_STATE_STOPPED;
 670             renderer->flags &= ~SAR_PREROLLED;
 671         }
 672     }
 673     else
 674         hr = MF_E_NOT_INITIALIZED;
 675
 676     IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkStopped, &GUID_NULL, hr, NULL);
 677     LeaveCriticalSection(&renderer->cs);
 678
 679     return hr;
 680 }
 681
 682 static HRESULT WINAPI audio_renderer_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
 683 {
 684     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 685     HRESULT hr;
 686
 687     TRACE("%p, %s.\n", iface, debugstr_time(systime));
 688
 689     EnterCriticalSection(&renderer->cs);
 690     if (renderer->state == STREAM_STATE_RUNNING)
 691     {
 692         if (renderer->audio_client)
 693         {
 694             if (FAILED(hr = IAudioClient_Stop(renderer->audio_client)))
 695                 WARN("Failed to stop audio client, hr %#x.\n", hr);
 696             renderer->state = STREAM_STATE_PAUSED;
 697         }
 698         else
 699             hr = MF_E_NOT_INITIALIZED;
 700
 701         IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkPaused, &GUID_NULL, hr, NULL);
 702     }
 703     else
 704         hr = MF_E_INVALID_STATE_TRANSITION;
 705     LeaveCriticalSection(&renderer->cs);
 706
 707     return hr;
 708 }
 709
 710 static HRESULT WINAPI audio_renderer_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
 711 {
 712     struct audio_renderer *renderer = impl_from_IMFClockStateSink(iface);
 713     BOOL preroll = FALSE;
 714     HRESULT hr = S_OK;
 715
 716     TRACE("%p, %s.\n", iface, debugstr_time(systime));
 717
 718     EnterCriticalSection(&renderer->cs);
 719     if (renderer->audio_client)
 720     {
 721         if ((preroll = (renderer->state != STREAM_STATE_RUNNING)))
 722         {
 723             if (FAILED(hr = IAudioClient_Start(renderer->audio_client)))
 724                 WARN("Failed to start audio client, hr %#x.\n", hr);
 725             renderer->state = STREAM_STATE_RUNNING;
 726         }
 727     }
 728     else
 729         hr = MF_E_NOT_INITIALIZED;
 730
 731     IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkStarted, &GUID_NULL, hr, NULL);
 732     if (preroll)
 733         audio_renderer_preroll(renderer);
 734
 735     LeaveCriticalSection(&renderer->cs);
 736
 737     return hr;
 738 }
 739
 740 static HRESULT WINAPI audio_renderer_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
 741 {
 742     FIXME("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
 743
 744     return E_NOTIMPL;
 745 }
 746
 747 static const IMFClockStateSinkVtbl audio_renderer_clock_sink_vtbl =
 748 {
 749     audio_renderer_clock_sink_QueryInterface,
 750     audio_renderer_clock_sink_AddRef,
 751     audio_renderer_clock_sink_Release,
 752     audio_renderer_clock_sink_OnClockStart,
 753     audio_renderer_clock_sink_OnClockStop,
 754     audio_renderer_clock_sink_OnClockPause,
 755     audio_renderer_clock_sink_OnClockRestart,
 756     audio_renderer_clock_sink_OnClockSetRate,
 757 };
 758
 759 static HRESULT WINAPI audio_renderer_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
 760 {
 761     struct audio_renderer *renderer = impl_from_IMFGetService(iface);
 762     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 763 }
 764
 765 static ULONG WINAPI audio_renderer_get_service_AddRef(IMFGetService *iface)
 766 {
 767     struct audio_renderer *renderer = impl_from_IMFGetService(iface);
 768     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 769 }
 770
 771 static ULONG WINAPI audio_renderer_get_service_Release(IMFGetService *iface)
 772 {
 773     struct audio_renderer *renderer = impl_from_IMFGetService(iface);
 774     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 775 }
 776
 777 static HRESULT WINAPI audio_renderer_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 778 {
 779     struct audio_renderer *renderer = impl_from_IMFGetService(iface);
 780
 781     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 782
 783     *obj = NULL;
 784
 785     if (IsEqualGUID(service, &MR_POLICY_VOLUME_SERVICE) && IsEqualIID(riid, &IID_IMFSimpleAudioVolume))
 786     {
 787         *obj = &renderer->IMFSimpleAudioVolume_iface;
 788     }
 789     else if (IsEqualGUID(service, &MR_STREAM_VOLUME_SERVICE) && IsEqualIID(riid, &IID_IMFAudioStreamVolume))
 790     {
 791         *obj = &renderer->IMFAudioStreamVolume_iface;
 792     }
 793     else if (IsEqualGUID(service, &MR_AUDIO_POLICY_SERVICE) && IsEqualIID(riid, &IID_IMFAudioPolicy))
 794     {
 795         *obj = &renderer->IMFAudioPolicy_iface;
 796     }
 797     else
 798         FIXME("Unsupported service %s, interface %s.\n", debugstr_guid(service), debugstr_guid(riid));
 799
 800     if (*obj)
 801         IUnknown_AddRef((IUnknown *)*obj);
 802
 803     return *obj ? S_OK : E_NOINTERFACE;
 804 }
 805
 806 static const IMFGetServiceVtbl audio_renderer_get_service_vtbl =
 807 {
 808     audio_renderer_get_service_QueryInterface,
 809     audio_renderer_get_service_AddRef,
 810     audio_renderer_get_service_Release,
 811     audio_renderer_get_service_GetService,
 812 };
 813
 814 static HRESULT WINAPI audio_renderer_simple_volume_QueryInterface(IMFSimpleAudioVolume *iface, REFIID riid, void **obj)
 815 {
 816     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 817
 818     if (IsEqualIID(riid, &IID_IMFSimpleAudioVolume) ||
 819             IsEqualIID(riid, &IID_IUnknown))
 820     {
 821         *obj = iface;
 822         IMFSimpleAudioVolume_AddRef(iface);
 823         return S_OK;
 824     }
 825
 826     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 827     *obj = NULL;
 828     return E_NOINTERFACE;
 829 }
 830
 831 static ULONG WINAPI audio_renderer_simple_volume_AddRef(IMFSimpleAudioVolume *iface)
 832 {
 833     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 834     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 835 }
 836
 837 static ULONG WINAPI audio_renderer_simple_volume_Release(IMFSimpleAudioVolume *iface)
 838 {
 839     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 840     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 841 }
 842
 843 static HRESULT WINAPI audio_renderer_simple_volume_SetMasterVolume(IMFSimpleAudioVolume *iface, float level)
 844 {
 845     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 846     HRESULT hr = S_OK;
 847
 848     TRACE("%p, %f.\n", iface, level);
 849
 850     EnterCriticalSection(&renderer->cs);
 851     if (renderer->audio_volume)
 852         hr = ISimpleAudioVolume_SetMasterVolume(renderer->audio_volume, level, NULL);
 853     LeaveCriticalSection(&renderer->cs);
 854
 855     return hr;
 856 }
 857
 858 static HRESULT WINAPI audio_renderer_simple_volume_GetMasterVolume(IMFSimpleAudioVolume *iface, float *level)
 859 {
 860     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 861     HRESULT hr = S_OK;
 862
 863     TRACE("%p, %p.\n", iface, level);
 864
 865     if (!level)
 866         return E_POINTER;
 867
 868     *level = 0.0f;
 869
 870     EnterCriticalSection(&renderer->cs);
 871     if (renderer->audio_volume)
 872         hr = ISimpleAudioVolume_GetMasterVolume(renderer->audio_volume, level);
 873     LeaveCriticalSection(&renderer->cs);
 874
 875     return hr;
 876 }
 877
 878 static HRESULT WINAPI audio_renderer_simple_volume_SetMute(IMFSimpleAudioVolume *iface, BOOL mute)
 879 {
 880     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 881     HRESULT hr = S_OK;
 882
 883     TRACE("%p, %d.\n", iface, mute);
 884
 885     EnterCriticalSection(&renderer->cs);
 886     if (renderer->audio_volume)
 887         hr = ISimpleAudioVolume_SetMute(renderer->audio_volume, mute, NULL);
 888     LeaveCriticalSection(&renderer->cs);
 889
 890     return hr;
 891 }
 892
 893 static HRESULT WINAPI audio_renderer_simple_volume_GetMute(IMFSimpleAudioVolume *iface, BOOL *mute)
 894 {
 895     struct audio_renderer *renderer = impl_from_IMFSimpleAudioVolume(iface);
 896     HRESULT hr = S_OK;
 897
 898     TRACE("%p, %p.\n", iface, mute);
 899
 900     if (!mute)
 901         return E_POINTER;
 902
 903     *mute = FALSE;
 904
 905     EnterCriticalSection(&renderer->cs);
 906     if (renderer->audio_volume)
 907         hr = ISimpleAudioVolume_GetMute(renderer->audio_volume, mute);
 908     LeaveCriticalSection(&renderer->cs);
 909
 910     return hr;
 911 }
 912
 913 static const IMFSimpleAudioVolumeVtbl audio_renderer_simple_volume_vtbl =
 914 {
 915     audio_renderer_simple_volume_QueryInterface,
 916     audio_renderer_simple_volume_AddRef,
 917     audio_renderer_simple_volume_Release,
 918     audio_renderer_simple_volume_SetMasterVolume,
 919     audio_renderer_simple_volume_GetMasterVolume,
 920     audio_renderer_simple_volume_SetMute,
 921     audio_renderer_simple_volume_GetMute,
 922 };
 923
 924 static HRESULT WINAPI audio_renderer_stream_volume_QueryInterface(IMFAudioStreamVolume *iface, REFIID riid, void **obj)
 925 {
 926     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 927
 928     if (IsEqualIID(riid, &IID_IMFAudioStreamVolume) ||
 929             IsEqualIID(riid, &IID_IUnknown))
 930     {
 931         *obj = iface;
 932         IMFAudioStreamVolume_AddRef(iface);
 933         return S_OK;
 934     }
 935
 936     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 937     *obj = NULL;
 938     return E_NOINTERFACE;
 939 }
 940
 941 static ULONG WINAPI audio_renderer_stream_volume_AddRef(IMFAudioStreamVolume *iface)
 942 {
 943     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 944     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 945 }
 946
 947 static ULONG WINAPI audio_renderer_stream_volume_Release(IMFAudioStreamVolume *iface)
 948 {
 949     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 950     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 951 }
 952
 953 static HRESULT WINAPI audio_renderer_stream_volume_GetChannelCount(IMFAudioStreamVolume *iface, UINT32 *count)
 954 {
 955     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 956     HRESULT hr = S_OK;
 957
 958     TRACE("%p, %p.\n", iface, count);
 959
 960     if (!count)
 961         return E_POINTER;
 962
 963     *count = 0;
 964
 965     EnterCriticalSection(&renderer->cs);
 966     if (renderer->stream_volume)
 967         hr = IAudioStreamVolume_GetChannelCount(renderer->stream_volume, count);
 968     LeaveCriticalSection(&renderer->cs);
 969
 970     return hr;
 971 }
 972
 973 static HRESULT WINAPI audio_renderer_stream_volume_SetChannelVolume(IMFAudioStreamVolume *iface, UINT32 index, float level)
 974 {
 975     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 976     HRESULT hr = S_OK;
 977
 978     TRACE("%p, %u, %f.\n", iface, index, level);
 979
 980     EnterCriticalSection(&renderer->cs);
 981     if (renderer->stream_volume)
 982         hr = IAudioStreamVolume_SetChannelVolume(renderer->stream_volume, index, level);
 983     LeaveCriticalSection(&renderer->cs);
 984
 985     return hr;
 986 }
 987
 988 static HRESULT WINAPI audio_renderer_stream_volume_GetChannelVolume(IMFAudioStreamVolume *iface, UINT32 index, float *level)
 989 {
 990     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
 991     HRESULT hr = S_OK;
 992
 993     TRACE("%p, %u, %p.\n", iface, index, level);
 994
 995     if (!level)
 996         return E_POINTER;
 997
 998     *level = 0.0f;
 999
1000     EnterCriticalSection(&renderer->cs);
1001     if (renderer->stream_volume)
1002         hr = IAudioStreamVolume_GetChannelVolume(renderer->stream_volume, index, level);
1003     LeaveCriticalSection(&renderer->cs);
1004
1005     return hr;
1006 }
1007
1008 static HRESULT WINAPI audio_renderer_stream_volume_SetAllVolumes(IMFAudioStreamVolume *iface, UINT32 count,
1009         const float *volumes)
1010 {
1011     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
1012     HRESULT hr = S_OK;
1013
1014     TRACE("%p, %u, %p.\n", iface, count, volumes);
1015
1016     EnterCriticalSection(&renderer->cs);
1017     if (renderer->stream_volume)
1018         hr = IAudioStreamVolume_SetAllVolumes(renderer->stream_volume, count, volumes);
1019     LeaveCriticalSection(&renderer->cs);
1020
1021     return hr;
1022 }
1023
1024 static HRESULT WINAPI audio_renderer_stream_volume_GetAllVolumes(IMFAudioStreamVolume *iface, UINT32 count, float *volumes)
1025 {
1026     struct audio_renderer *renderer = impl_from_IMFAudioStreamVolume(iface);
1027     HRESULT hr = S_OK;
1028
1029     TRACE("%p, %u, %p.\n", iface, count, volumes);
1030
1031     if (!volumes)
1032         return E_POINTER;
1033
1034     if (count)
1035         memset(volumes, 0, sizeof(*volumes) * count);
1036
1037     EnterCriticalSection(&renderer->cs);
1038     if (renderer->stream_volume)
1039         hr = IAudioStreamVolume_GetAllVolumes(renderer->stream_volume, count, volumes);
1040     LeaveCriticalSection(&renderer->cs);
1041
1042     return hr;
1043 }
1044
1045 static const IMFAudioStreamVolumeVtbl audio_renderer_stream_volume_vtbl =
1046 {
1047     audio_renderer_stream_volume_QueryInterface,
1048     audio_renderer_stream_volume_AddRef,
1049     audio_renderer_stream_volume_Release,
1050     audio_renderer_stream_volume_GetChannelCount,
1051     audio_renderer_stream_volume_SetChannelVolume,
1052     audio_renderer_stream_volume_GetChannelVolume,
1053     audio_renderer_stream_volume_SetAllVolumes,
1054     audio_renderer_stream_volume_GetAllVolumes,
1055 };
1056
1057 static HRESULT WINAPI audio_renderer_policy_QueryInterface(IMFAudioPolicy *iface, REFIID riid, void **obj)
1058 {
1059     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1060
1061     if (IsEqualIID(riid, &IID_IMFAudioPolicy) ||
1062             IsEqualIID(riid, &IID_IUnknown))
1063     {
1064         *obj = iface;
1065         IMFAudioPolicy_AddRef(iface);
1066         return S_OK;
1067     }
1068
1069     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1070     *obj = NULL;
1071     return E_NOINTERFACE;
1072 }
1073
1074 static ULONG WINAPI audio_renderer_policy_AddRef(IMFAudioPolicy *iface)
1075 {
1076     struct audio_renderer *renderer = impl_from_IMFAudioPolicy(iface);
1077     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1078 }
1079
1080 static ULONG WINAPI audio_renderer_policy_Release(IMFAudioPolicy *iface)
1081 {
1082     struct audio_renderer *renderer = impl_from_IMFAudioPolicy(iface);
1083     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1084 }
1085
1086 static HRESULT WINAPI audio_renderer_policy_SetGroupingParam(IMFAudioPolicy *iface, REFGUID param)
1087 {
1088     FIXME("%p, %s.\n", iface, debugstr_guid(param));
1089
1090     return E_NOTIMPL;
1091 }
1092
1093 static HRESULT WINAPI audio_renderer_policy_GetGroupingParam(IMFAudioPolicy *iface, GUID *param)
1094 {
1095     FIXME("%p, %p.\n", iface, param);
1096
1097     return E_NOTIMPL;
1098 }
1099
1100 static HRESULT WINAPI audio_renderer_policy_SetDisplayName(IMFAudioPolicy *iface, const WCHAR *name)
1101 {
1102     FIXME("%p, %s.\n", iface, debugstr_w(name));
1103
1104     return E_NOTIMPL;
1105 }
1106
1107 static HRESULT WINAPI audio_renderer_policy_GetDisplayName(IMFAudioPolicy *iface, WCHAR **name)
1108 {
1109     FIXME("%p, %p.\n", iface, name);
1110
1111     return E_NOTIMPL;
1112 }
1113
1114 static HRESULT WINAPI audio_renderer_policy_SetIconPath(IMFAudioPolicy *iface, const WCHAR *path)
1115 {
1116     FIXME("%p, %s.\n", iface, debugstr_w(path));
1117
1118     return E_NOTIMPL;
1119 }
1120
1121 static HRESULT WINAPI audio_renderer_policy_GetIconPath(IMFAudioPolicy *iface, WCHAR **path)
1122 {
1123     FIXME("%p, %p.\n", iface, path);
1124
1125     return E_NOTIMPL;
1126 }
1127
1128 static const IMFAudioPolicyVtbl audio_renderer_policy_vtbl =
1129 {
1130     audio_renderer_policy_QueryInterface,
1131     audio_renderer_policy_AddRef,
1132     audio_renderer_policy_Release,
1133     audio_renderer_policy_SetGroupingParam,
1134     audio_renderer_policy_GetGroupingParam,
1135     audio_renderer_policy_SetDisplayName,
1136     audio_renderer_policy_GetDisplayName,
1137     audio_renderer_policy_SetIconPath,
1138     audio_renderer_policy_GetIconPath,
1139 };
1140
1141 static HRESULT sar_create_mmdevice(IMFAttributes *attributes, struct audio_renderer *renderer)
1142 {
1143     WCHAR *endpoint;
1144     unsigned int length, role = eMultimedia;
1145     IMMDeviceEnumerator *devenum;
1146     HRESULT hr;
1147
1148     if (attributes)
1149     {
1150         /* Mutually exclusive attributes. */
1151         if (SUCCEEDED(IMFAttributes_GetItem(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE, NULL)) &&
1152                 SUCCEEDED(IMFAttributes_GetItem(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID, NULL)))
1153         {
1154             return E_INVALIDARG;
1155         }
1156     }
1157
1158     if (FAILED(hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator,
1159             (void **)&devenum)))
1160     {
1161         return hr;
1162     }
1163
1164     role = eMultimedia;
1165     if (attributes && SUCCEEDED(IMFAttributes_GetUINT32(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE, &role)))
1166         TRACE("Specified role %d.\n", role);
1167
1168     if (attributes && SUCCEEDED(IMFAttributes_GetAllocatedString(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID,
1169             &endpoint, &length)))
1170     {
1171         TRACE("Specified end point %s.\n", debugstr_w(endpoint));
1172         hr = IMMDeviceEnumerator_GetDevice(devenum, endpoint, &renderer->device);
1173         CoTaskMemFree(endpoint);
1174     }
1175     else
1176         hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, eRender, role, &renderer->device);
1177
1178     /* Configuration attributes to be used later for audio client initialization. */
1179     if (attributes)
1180     {
1181         IMFAttributes_GetUINT32(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS, &renderer->stream_config.flags);
1182         IMFAttributes_GetGUID(attributes, &MF_AUDIO_RENDERER_ATTRIBUTE_SESSION_ID, &renderer->stream_config.session_id);
1183     }
1184
1185     if (FAILED(hr))
1186         hr = MF_E_NO_AUDIO_PLAYBACK_DEVICE;
1187
1188     IMMDeviceEnumerator_Release(devenum);
1189
1190     return hr;
1191 }
1192
1193 static HRESULT WINAPI audio_renderer_stream_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj)
1194 {
1195     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1196
1197     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1198
1199     if (IsEqualIID(riid, &IID_IMFStreamSink) ||
1200             IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
1201             IsEqualIID(riid, &IID_IUnknown))
1202     {
1203         *obj = &renderer->IMFStreamSink_iface;
1204     }
1205     else if (IsEqualIID(riid, &IID_IMFMediaTypeHandler))
1206     {
1207         *obj = &renderer->IMFMediaTypeHandler_iface;
1208     }
1209     else
1210     {
1211         WARN("Unsupported %s.\n", debugstr_guid(riid));
1212         *obj = NULL;
1213         return E_NOINTERFACE;
1214     }
1215
1216     IUnknown_AddRef((IUnknown *)*obj);
1217
1218     return S_OK;
1219 }
1220
1221 static ULONG WINAPI audio_renderer_stream_AddRef(IMFStreamSink *iface)
1222 {
1223     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1224     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1225 }
1226
1227 static ULONG WINAPI audio_renderer_stream_Release(IMFStreamSink *iface)
1228 {
1229     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1230     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1231 }
1232
1233 static HRESULT WINAPI audio_renderer_stream_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event)
1234 {
1235     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1236
1237     TRACE("%p, %#x, %p.\n", iface, flags, event);
1238
1239     if (renderer->flags & SAR_SHUT_DOWN)
1240         return MF_E_STREAMSINK_REMOVED;
1241
1242     return IMFMediaEventQueue_GetEvent(renderer->stream_event_queue, flags, event);
1243 }
1244
1245 static HRESULT WINAPI audio_renderer_stream_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback,
1246         IUnknown *state)
1247 {
1248     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1249
1250     TRACE("%p, %p, %p.\n", iface, callback, state);
1251
1252     if (renderer->flags & SAR_SHUT_DOWN)
1253         return MF_E_STREAMSINK_REMOVED;
1254
1255     return IMFMediaEventQueue_BeginGetEvent(renderer->stream_event_queue, callback, state);
1256 }
1257
1258 static HRESULT WINAPI audio_renderer_stream_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result,
1259         IMFMediaEvent **event)
1260 {
1261     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1262
1263     TRACE("%p, %p, %p.\n", iface, result, event);
1264
1265     if (renderer->flags & SAR_SHUT_DOWN)
1266         return MF_E_STREAMSINK_REMOVED;
1267
1268     return IMFMediaEventQueue_EndGetEvent(renderer->stream_event_queue, result, event);
1269 }
1270
1271 static HRESULT WINAPI audio_renderer_stream_QueueEvent(IMFStreamSink *iface, MediaEventType event_type,
1272         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
1273 {
1274     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1275
1276     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
1277
1278     if (renderer->flags & SAR_SHUT_DOWN)
1279         return MF_E_STREAMSINK_REMOVED;
1280
1281     return IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, event_type, ext_type, hr, value);
1282 }
1283
1284 static HRESULT WINAPI audio_renderer_stream_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink)
1285 {
1286     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1287
1288     TRACE("%p, %p.\n", iface, sink);
1289
1290     if (renderer->flags & SAR_SHUT_DOWN)
1291         return MF_E_STREAMSINK_REMOVED;
1292
1293     *sink = &renderer->IMFMediaSink_iface;
1294     IMFMediaSink_AddRef(*sink);
1295
1296     return S_OK;
1297 }
1298
1299 static HRESULT WINAPI audio_renderer_stream_GetIdentifier(IMFStreamSink *iface, DWORD *identifier)
1300 {
1301     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1302
1303     TRACE("%p, %p.\n", iface, identifier);
1304
1305     if (renderer->flags & SAR_SHUT_DOWN)
1306         return MF_E_STREAMSINK_REMOVED;
1307
1308     *identifier = 0;
1309
1310     return S_OK;
1311 }
1312
1313 static HRESULT WINAPI audio_renderer_stream_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler)
1314 {
1315     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1316
1317     TRACE("%p, %p.\n", iface, handler);
1318
1319     if (!handler)
1320         return E_POINTER;
1321
1322     if (renderer->flags & SAR_SHUT_DOWN)
1323         return MF_E_STREAMSINK_REMOVED;
1324
1325     *handler = &renderer->IMFMediaTypeHandler_iface;
1326     IMFMediaTypeHandler_AddRef(*handler);
1327
1328     return S_OK;
1329 }
1330
1331 static HRESULT stream_queue_sample(struct audio_renderer *renderer, IMFSample *sample)
1332 {
1333     struct queued_object *object;
1334
1335     if (!(object = heap_alloc_zero(sizeof(*object))))
1336         return E_OUTOFMEMORY;
1337
1338     object->type = OBJECT_TYPE_SAMPLE;
1339     object->u.sample.sample = sample;
1340     IMFSample_AddRef(object->u.sample.sample);
1341
1342     list_add_tail(&renderer->queue, &object->entry);
1343
1344     return S_OK;
1345 }
1346
1347 static HRESULT WINAPI audio_renderer_stream_ProcessSample(IMFStreamSink *iface, IMFSample *sample)
1348 {
1349     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1350     HRESULT hr = S_OK;
1351
1352     TRACE("%p, %p.\n", iface, sample);
1353
1354     if (!sample)
1355         return E_POINTER;
1356
1357     if (renderer->flags & SAR_SHUT_DOWN)
1358         return MF_E_STREAMSINK_REMOVED;
1359
1360     EnterCriticalSection(&renderer->cs);
1361     if (renderer->state == STREAM_STATE_RUNNING)
1362         hr = stream_queue_sample(renderer, sample);
1363     renderer->flags &= ~SAR_SAMPLE_REQUESTED;
1364     LeaveCriticalSection(&renderer->cs);
1365
1366     return hr;
1367 }
1368
1369 static HRESULT stream_place_marker(struct audio_renderer *renderer, MFSTREAMSINK_MARKER_TYPE marker_type,
1370         const PROPVARIANT *context_value)
1371 {
1372     struct queued_object *marker;
1373     HRESULT hr = S_OK;
1374
1375     if (!(marker = heap_alloc_zero(sizeof(*marker))))
1376         return E_OUTOFMEMORY;
1377
1378     marker->type = OBJECT_TYPE_MARKER;
1379     marker->u.marker.type = marker_type;
1380     PropVariantInit(&marker->u.marker.context);
1381     if (context_value)
1382         hr = PropVariantCopy(&marker->u.marker.context, context_value);
1383     if (SUCCEEDED(hr))
1384         list_add_tail(&renderer->queue, &marker->entry);
1385     else
1386         release_pending_object(marker);
1387
1388     return hr;
1389 }
1390
1391 static HRESULT WINAPI audio_renderer_stream_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type,
1392         const PROPVARIANT *marker_value, const PROPVARIANT *context_value)
1393 {
1394     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1395     HRESULT hr;
1396
1397     TRACE("%p, %d, %p, %p.\n", iface, marker_type, marker_value, context_value);
1398
1399     if (renderer->flags & SAR_SHUT_DOWN)
1400         return MF_E_STREAMSINK_REMOVED;
1401
1402     EnterCriticalSection(&renderer->cs);
1403     hr = stream_place_marker(renderer, marker_type, context_value);
1404     LeaveCriticalSection(&renderer->cs);
1405
1406     return hr;
1407 }
1408
1409 static HRESULT WINAPI audio_renderer_stream_Flush(IMFStreamSink *iface)
1410 {
1411     struct audio_renderer *renderer = impl_from_IMFStreamSink(iface);
1412     struct queued_object *obj, *obj2;
1413     HRESULT hr = S_OK;
1414
1415     TRACE("%p.\n", iface);
1416
1417     EnterCriticalSection(&renderer->cs);
1418     if (renderer->flags & SAR_SHUT_DOWN)
1419         hr = MF_E_STREAMSINK_REMOVED;
1420     else
1421     {
1422         LIST_FOR_EACH_ENTRY_SAFE(obj, obj2, &renderer->queue, struct queued_object, entry)
1423         {
1424             if (obj->type == OBJECT_TYPE_MARKER)
1425             {
1426                 IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkMarker,
1427                         &GUID_NULL, S_OK, &obj->u.marker.context);
1428             }
1429             release_pending_object(obj);
1430         }
1431     }
1432     LeaveCriticalSection(&renderer->cs);
1433
1434     return hr;
1435 }
1436
1437 static const IMFStreamSinkVtbl audio_renderer_stream_vtbl =
1438 {
1439     audio_renderer_stream_QueryInterface,
1440     audio_renderer_stream_AddRef,
1441     audio_renderer_stream_Release,
1442     audio_renderer_stream_GetEvent,
1443     audio_renderer_stream_BeginGetEvent,
1444     audio_renderer_stream_EndGetEvent,
1445     audio_renderer_stream_QueueEvent,
1446     audio_renderer_stream_GetMediaSink,
1447     audio_renderer_stream_GetIdentifier,
1448     audio_renderer_stream_GetMediaTypeHandler,
1449     audio_renderer_stream_ProcessSample,
1450     audio_renderer_stream_PlaceMarker,
1451     audio_renderer_stream_Flush,
1452 };
1453
1454 static HRESULT WINAPI audio_renderer_stream_type_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid,
1455         void **obj)
1456 {
1457     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1458     return IMFStreamSink_QueryInterface(&renderer->IMFStreamSink_iface, riid, obj);
1459 }
1460
1461 static ULONG WINAPI audio_renderer_stream_type_handler_AddRef(IMFMediaTypeHandler *iface)
1462 {
1463     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1464     return IMFStreamSink_AddRef(&renderer->IMFStreamSink_iface);
1465 }
1466
1467 static ULONG WINAPI audio_renderer_stream_type_handler_Release(IMFMediaTypeHandler *iface)
1468 {
1469     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1470     return IMFStreamSink_Release(&renderer->IMFStreamSink_iface);
1471 }
1472
1473 static HRESULT WINAPI audio_renderer_stream_type_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface,
1474         IMFMediaType *in_type, IMFMediaType **out_type)
1475 {
1476     struct audio_renderer *renderer = impl_from_IMFMediaTypeHandler(iface);
1477     unsigned int flags;
1478     HRESULT hr;
1479
1480     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
1481
1482     EnterCriticalSection(&renderer->cs);
1483     hr = IMFMediaType_IsEqual(renderer->media_type, in_type, &flags);
1484     LeaveCriticalSection(&renderer->cs);
1485
1486     return hr != S_OK ? MF_E_INVALIDMEDIATYPE : 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 void audio_renderer_render(struct audio_renderer *renderer, IMFAsyncResult *result)
1754 {
1755     unsigned int src_frames, dst_frames, max_frames, src_len;
1756     struct queued_object *obj, *obj2;
1757     BOOL keep_sample = FALSE;
1758     IMFMediaBuffer *buffer;
1759     BYTE *dst, *src;
1760     HRESULT hr;
1761
1762     LIST_FOR_EACH_ENTRY_SAFE(obj, obj2, &renderer->queue, struct queued_object, entry)
1763     {
1764         if (obj->type == OBJECT_TYPE_MARKER)
1765         {
1766             IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkMarker,
1767                 &GUID_NULL, S_OK, &obj->u.marker.context);
1768         }
1769         else if (obj->type == OBJECT_TYPE_SAMPLE)
1770         {
1771             if (SUCCEEDED(IMFSample_ConvertToContiguousBuffer(obj->u.sample.sample, &buffer)))
1772             {
1773                 if (SUCCEEDED(IMFMediaBuffer_Lock(buffer, &src, NULL, &src_len)))
1774                 {
1775                     if ((src_frames = src_len / renderer->frame_size))
1776                     {
1777                         if (SUCCEEDED(IAudioClient_GetBufferSize(renderer->audio_client, &max_frames)))
1778                         {
1779                             src_frames -= obj->u.sample.frame_offset;
1780                             dst_frames = min(src_frames, max_frames);
1781
1782                             if (SUCCEEDED(hr = IAudioRenderClient_GetBuffer(renderer->audio_render_client, dst_frames, &dst)))
1783                             {
1784                                 memcpy(dst, src + obj->u.sample.frame_offset * renderer->frame_size,
1785                                         dst_frames * renderer->frame_size);
1786
1787                                 IAudioRenderClient_ReleaseBuffer(renderer->audio_render_client, dst_frames, 0);
1788
1789                                 obj->u.sample.frame_offset += dst_frames;
1790                             }
1791
1792                             keep_sample = FAILED(hr) || src_frames > max_frames;
1793                         }
1794                     }
1795                     IMFMediaBuffer_Unlock(buffer);
1796                 }
1797                 IMFMediaBuffer_Release(buffer);
1798             }
1799         }
1800
1801         if (keep_sample)
1802             break;
1803
1804         list_remove(&obj->entry);
1805         release_pending_object(obj);
1806     }
1807
1808     if (list_empty(&renderer->queue) && !(renderer->flags & SAR_SAMPLE_REQUESTED))
1809     {
1810         IMFMediaEventQueue_QueueEventParamVar(renderer->stream_event_queue, MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
1811         renderer->flags |= SAR_SAMPLE_REQUESTED;
1812     }
1813
1814     if (FAILED(hr = MFPutWaitingWorkItem(renderer->buffer_ready_event, 0, result, &renderer->buffer_ready_key)))
1815         WARN("Failed to submit wait item, hr %#x.\n", hr);
1816 }
1817
1818 static HRESULT WINAPI audio_renderer_render_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1819 {
1820     struct audio_renderer *renderer = impl_from_render_callback_IMFAsyncCallback(iface);
1821
1822     EnterCriticalSection(&renderer->cs);
1823     if (!(renderer->flags & SAR_SHUT_DOWN))
1824         audio_renderer_render(renderer, result);
1825     LeaveCriticalSection(&renderer->cs);
1826
1827     return S_OK;
1828 }
1829
1830 static const IMFAsyncCallbackVtbl audio_renderer_render_callback_vtbl =
1831 {
1832     audio_renderer_render_callback_QueryInterface,
1833     audio_renderer_render_callback_AddRef,
1834     audio_renderer_render_callback_Release,
1835     audio_renderer_render_callback_GetParameters,
1836     audio_renderer_render_callback_Invoke,
1837 };
1838
1839 static HRESULT sar_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj)
1840 {
1841     struct audio_renderer *renderer;
1842     HRESULT hr;
1843
1844     TRACE("%p, %p, %p.\n", attributes, user_context, obj);
1845
1846     if (!(renderer = heap_alloc_zero(sizeof(*renderer))))
1847         return E_OUTOFMEMORY;
1848
1849     renderer->IMFMediaSink_iface.lpVtbl = &audio_renderer_sink_vtbl;
1850     renderer->IMFMediaSinkPreroll_iface.lpVtbl = &audio_renderer_preroll_vtbl;
1851     renderer->IMFStreamSink_iface.lpVtbl = &audio_renderer_stream_vtbl;
1852     renderer->IMFMediaTypeHandler_iface.lpVtbl = &audio_renderer_stream_type_handler_vtbl;
1853     renderer->IMFClockStateSink_iface.lpVtbl = &audio_renderer_clock_sink_vtbl;
1854     renderer->IMFMediaEventGenerator_iface.lpVtbl = &audio_renderer_events_vtbl;
1855     renderer->IMFGetService_iface.lpVtbl = &audio_renderer_get_service_vtbl;
1856     renderer->IMFSimpleAudioVolume_iface.lpVtbl = &audio_renderer_simple_volume_vtbl;
1857     renderer->IMFAudioStreamVolume_iface.lpVtbl = &audio_renderer_stream_volume_vtbl;
1858     renderer->IMFAudioPolicy_iface.lpVtbl = &audio_renderer_policy_vtbl;
1859     renderer->render_callback.lpVtbl = &audio_renderer_render_callback_vtbl;
1860     renderer->refcount = 1;
1861     InitializeCriticalSection(&renderer->cs);
1862     renderer->buffer_ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1863     list_init(&renderer->queue);
1864
1865     if (FAILED(hr = MFCreateEventQueue(&renderer->event_queue)))
1866         goto failed;
1867
1868     if (FAILED(hr = MFCreateEventQueue(&renderer->stream_event_queue)))
1869         goto failed;
1870
1871     if (FAILED(hr = sar_create_mmdevice(attributes, renderer)))
1872         goto failed;
1873
1874     if (FAILED(hr = audio_renderer_collect_supported_types(renderer)))
1875         goto failed;
1876
1877     *obj = (IUnknown *)&renderer->IMFMediaSink_iface;
1878
1879     return S_OK;
1880
1881 failed:
1882
1883     IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1884
1885     return hr;
1886 }
1887
1888 static void sar_shutdown_object(void *user_context, IUnknown *obj)
1889 {
1890     IMFMediaSink *sink;
1891
1892     if (SUCCEEDED(IUnknown_QueryInterface(obj, &IID_IMFMediaSink, (void **)&sink)))
1893     {
1894         IMFMediaSink_Shutdown(sink);
1895         IMFMediaSink_Release(sink);
1896     }
1897 }
1898
1899 static const struct activate_funcs sar_activate_funcs =
1900 {
1901     .create_object = sar_create_object,
1902     .shutdown_object = sar_shutdown_object,
1903 };
1904
1905 /***********************************************************************
1906  *      MFCreateAudioRendererActivate (mf.@)
1907  */
1908 HRESULT WINAPI MFCreateAudioRendererActivate(IMFActivate **activate)
1909 {
1910     TRACE("%p.\n", activate);
1911
1912     if (!activate)
1913         return E_POINTER;
1914
1915     return create_activation_object(NULL, &sar_activate_funcs, activate);
1916 }
1917
1918 /***********************************************************************
1919  *      MFCreateAudioRenderer (mf.@)
1920  */
1921 HRESULT WINAPI MFCreateAudioRenderer(IMFAttributes *attributes, IMFMediaSink **sink)
1922 {
1923     IUnknown *object;
1924     HRESULT hr;
1925
1926     TRACE("%p, %p.\n", attributes, sink);
1927
1928     if (SUCCEEDED(hr = sar_create_object(attributes, NULL, &object)))
1929     {
1930         hr = IUnknown_QueryInterface(object, &IID_IMFMediaSink, (void **)sink);
1931         IUnknown_Release(object);
1932     }
1933
1934     return hr;
1935 }