dlls/mf/evr.c

   1 /*
   2  * Copyright 2020 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 "mf_private.h"
  22 #include "uuids.h"
  23 #include "evr.h"
  24 #include "evcode.h"
  25 #include "d3d9.h"
  26 #include "initguid.h"
  27 #include "dxva2api.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  30
  31 enum video_renderer_flags
  32 {
  33     EVR_SHUT_DOWN = 0x1,
  34     EVR_INIT_SERVICES = 0x2, /* Currently in InitServices() call. */
  35     EVR_MIXER_INITED_SERVICES = 0x4,
  36     EVR_PRESENTER_INITED_SERVICES = 0x8,
  37 };
  38
  39 enum video_renderer_state
  40 {
  41     EVR_STATE_STOPPED = 0,
  42     EVR_STATE_RUNNING,
  43     EVR_STATE_PAUSED,
  44 };
  45
  46 enum video_stream_flags
  47 {
  48     EVR_STREAM_PREROLLING = 0x1,
  49     EVR_STREAM_PREROLLED = 0x2,
  50 };
  51
  52 struct video_renderer;
  53
  54 struct video_stream
  55 {
  56     IMFStreamSink IMFStreamSink_iface;
  57     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
  58     IMFGetService IMFGetService_iface;
  59     LONG refcount;
  60     unsigned int id;
  61     unsigned int flags;
  62     struct video_renderer *parent;
  63     IMFMediaEventQueue *event_queue;
  64     IMFVideoSampleAllocator *allocator;
  65     CRITICAL_SECTION cs;
  66 };
  67
  68 struct video_renderer
  69 {
  70     IMFMediaSink IMFMediaSink_iface;
  71     IMFMediaSinkPreroll IMFMediaSinkPreroll_iface;
  72     IMFVideoRenderer IMFVideoRenderer_iface;
  73     IMFClockStateSink IMFClockStateSink_iface;
  74     IMFMediaEventGenerator IMFMediaEventGenerator_iface;
  75     IMFGetService IMFGetService_iface;
  76     IMFTopologyServiceLookup IMFTopologyServiceLookup_iface;
  77     IMediaEventSink IMediaEventSink_iface;
  78     IMFAttributes IMFAttributes_iface;
  79     IMFQualityAdvise IMFQualityAdvise_iface;
  80     LONG refcount;
  81
  82     IMFMediaEventQueue *event_queue;
  83     IMFAttributes *attributes;
  84     IMFPresentationClock *clock;
  85
  86     IMFTransform *mixer;
  87     IMFVideoPresenter *presenter;
  88     HWND window;
  89     IUnknown *device_manager;
  90     unsigned int flags;
  91     unsigned int state;
  92
  93     struct video_stream **streams;
  94     size_t stream_size;
  95     size_t stream_count;
  96
  97     CRITICAL_SECTION cs;
  98 };
  99
 100 static struct video_renderer *impl_from_IMFMediaSink(IMFMediaSink *iface)
 101 {
 102     return CONTAINING_RECORD(iface, struct video_renderer, IMFMediaSink_iface);
 103 }
 104
 105 static struct video_renderer *impl_from_IMFMediaSinkPreroll(IMFMediaSinkPreroll *iface)
 106 {
 107     return CONTAINING_RECORD(iface, struct video_renderer, IMFMediaSinkPreroll_iface);
 108 }
 109
 110 static struct video_renderer *impl_from_IMFVideoRenderer(IMFVideoRenderer *iface)
 111 {
 112     return CONTAINING_RECORD(iface, struct video_renderer, IMFVideoRenderer_iface);
 113 }
 114
 115 static struct video_renderer *impl_from_IMFMediaEventGenerator(IMFMediaEventGenerator *iface)
 116 {
 117     return CONTAINING_RECORD(iface, struct video_renderer, IMFMediaEventGenerator_iface);
 118 }
 119
 120 static struct video_renderer *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
 121 {
 122     return CONTAINING_RECORD(iface, struct video_renderer, IMFClockStateSink_iface);
 123 }
 124
 125 static struct video_renderer *impl_from_IMFGetService(IMFGetService *iface)
 126 {
 127     return CONTAINING_RECORD(iface, struct video_renderer, IMFGetService_iface);
 128 }
 129
 130 static struct video_renderer *impl_from_IMFTopologyServiceLookup(IMFTopologyServiceLookup *iface)
 131 {
 132     return CONTAINING_RECORD(iface, struct video_renderer, IMFTopologyServiceLookup_iface);
 133 }
 134
 135 static struct video_renderer *impl_from_IMediaEventSink(IMediaEventSink *iface)
 136 {
 137     return CONTAINING_RECORD(iface, struct video_renderer, IMediaEventSink_iface);
 138 }
 139
 140 static struct video_renderer *impl_from_IMFAttributes(IMFAttributes *iface)
 141 {
 142     return CONTAINING_RECORD(iface, struct video_renderer, IMFAttributes_iface);
 143 }
 144
 145 static struct video_renderer *impl_from_IMFQualityAdvise(IMFQualityAdvise *iface)
 146 {
 147     return CONTAINING_RECORD(iface, struct video_renderer, IMFQualityAdvise_iface);
 148 }
 149
 150 static struct video_stream *impl_from_IMFStreamSink(IMFStreamSink *iface)
 151 {
 152     return CONTAINING_RECORD(iface, struct video_stream, IMFStreamSink_iface);
 153 }
 154
 155 static struct video_stream *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
 156 {
 157     return CONTAINING_RECORD(iface, struct video_stream, IMFMediaTypeHandler_iface);
 158 }
 159
 160 static struct video_stream *impl_from_stream_IMFGetService(IMFGetService *iface)
 161 {
 162     return CONTAINING_RECORD(iface, struct video_stream, IMFGetService_iface);
 163 }
 164
 165 static void video_renderer_release_services(struct video_renderer *renderer)
 166 {
 167     IMFTopologyServiceLookupClient *lookup_client;
 168
 169     if (renderer->flags & EVR_MIXER_INITED_SERVICES && SUCCEEDED(IMFTransform_QueryInterface(renderer->mixer,
 170             &IID_IMFTopologyServiceLookupClient, (void **)&lookup_client)))
 171     {
 172         IMFTopologyServiceLookupClient_ReleaseServicePointers(lookup_client);
 173         IMFTopologyServiceLookupClient_Release(lookup_client);
 174         renderer->flags &= ~EVR_MIXER_INITED_SERVICES;
 175     }
 176
 177     if (renderer->flags & EVR_PRESENTER_INITED_SERVICES && SUCCEEDED(IMFVideoPresenter_QueryInterface(renderer->presenter,
 178             &IID_IMFTopologyServiceLookupClient, (void **)&lookup_client)))
 179     {
 180         IMFTopologyServiceLookupClient_ReleaseServicePointers(lookup_client);
 181         IMFTopologyServiceLookupClient_Release(lookup_client);
 182         renderer->flags &= ~EVR_PRESENTER_INITED_SERVICES;
 183     }
 184 }
 185
 186 static HRESULT WINAPI video_stream_sink_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj)
 187 {
 188     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 189
 190     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 191
 192     *obj = NULL;
 193
 194     if (IsEqualIID(riid, &IID_IMFStreamSink) ||
 195             IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
 196             IsEqualIID(riid, &IID_IUnknown))
 197     {
 198         *obj = iface;
 199     }
 200     else if (IsEqualIID(riid, &IID_IMFMediaTypeHandler))
 201     {
 202         *obj = &stream->IMFMediaTypeHandler_iface;
 203     }
 204     else if (IsEqualIID(riid, &IID_IMFGetService))
 205     {
 206         *obj = &stream->IMFGetService_iface;
 207     }
 208
 209     if (*obj)
 210     {
 211         IUnknown_AddRef((IUnknown *)*obj);
 212         return S_OK;
 213     }
 214
 215     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 216     *obj = NULL;
 217     return E_NOINTERFACE;
 218 }
 219
 220 static ULONG WINAPI video_stream_sink_AddRef(IMFStreamSink *iface)
 221 {
 222     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 223     ULONG refcount = InterlockedIncrement(&stream->refcount);
 224
 225     TRACE("%p, refcount %u.\n", iface, refcount);
 226
 227     return refcount;
 228 }
 229
 230 static ULONG WINAPI video_stream_sink_Release(IMFStreamSink *iface)
 231 {
 232     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 233     ULONG refcount = InterlockedDecrement(&stream->refcount);
 234
 235     if (!refcount)
 236     {
 237         if (stream->event_queue)
 238             IMFMediaEventQueue_Release(stream->event_queue);
 239         if (stream->allocator)
 240             IMFVideoSampleAllocator_Release(stream->allocator);
 241         DeleteCriticalSection(&stream->cs);
 242         heap_free(stream);
 243     }
 244
 245     return refcount;
 246 }
 247
 248 static HRESULT WINAPI video_stream_sink_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event)
 249 {
 250     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 251
 252     TRACE("%p, %#x, %p.\n", iface, flags, event);
 253
 254     return IMFMediaEventQueue_GetEvent(stream->event_queue, flags, event);
 255 }
 256
 257 static HRESULT WINAPI video_stream_sink_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback, IUnknown *state)
 258 {
 259     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 260
 261     TRACE("%p, %p, %p.\n", iface, callback, state);
 262
 263     return IMFMediaEventQueue_BeginGetEvent(stream->event_queue, callback, state);
 264 }
 265
 266 static HRESULT WINAPI video_stream_sink_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result,
 267         IMFMediaEvent **event)
 268 {
 269     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 270
 271     TRACE("%p, %p, %p.\n", iface, result, event);
 272
 273     return IMFMediaEventQueue_EndGetEvent(stream->event_queue, result, event);
 274 }
 275
 276 static HRESULT WINAPI video_stream_sink_QueueEvent(IMFStreamSink *iface, MediaEventType event_type,
 277         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 278 {
 279     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 280
 281     TRACE("%p, %d, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
 282
 283     return IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, event_type, ext_type, hr, value);
 284 }
 285
 286 static HRESULT WINAPI video_stream_sink_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink)
 287 {
 288     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 289     HRESULT hr = S_OK;
 290
 291     TRACE("%p, %p.\n", iface, sink);
 292
 293     EnterCriticalSection(&stream->cs);
 294     if (!stream->parent)
 295         hr = MF_E_STREAMSINK_REMOVED;
 296     else if (!sink)
 297         hr = E_POINTER;
 298     else
 299     {
 300         *sink = &stream->parent->IMFMediaSink_iface;
 301         IMFMediaSink_AddRef(*sink);
 302     }
 303     LeaveCriticalSection(&stream->cs);
 304
 305     return hr;
 306 }
 307
 308 static HRESULT WINAPI video_stream_sink_GetIdentifier(IMFStreamSink *iface, DWORD *id)
 309 {
 310     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 311
 312     TRACE("%p, %p.\n", iface, id);
 313
 314     if (!stream->parent)
 315         return MF_E_STREAMSINK_REMOVED;
 316
 317     if (!id)
 318         return E_INVALIDARG;
 319
 320     *id = stream->id;
 321
 322     return S_OK;
 323 }
 324
 325 static HRESULT WINAPI video_stream_sink_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler)
 326 {
 327     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 328
 329     TRACE("%p, %p.\n", iface, handler);
 330
 331     if (!handler)
 332         return E_POINTER;
 333
 334     if (!stream->parent)
 335         return MF_E_STREAMSINK_REMOVED;
 336
 337     *handler = &stream->IMFMediaTypeHandler_iface;
 338     IMFMediaTypeHandler_AddRef(*handler);
 339
 340     return S_OK;
 341 }
 342
 343 static HRESULT WINAPI video_stream_sink_ProcessSample(IMFStreamSink *iface, IMFSample *sample)
 344 {
 345     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 346     LONGLONG timestamp;
 347     HRESULT hr = S_OK;
 348
 349     TRACE("%p, %p.\n", iface, sample);
 350
 351     EnterCriticalSection(&stream->cs);
 352
 353     if (!stream->parent)
 354         hr = MF_E_STREAMSINK_REMOVED;
 355     else if (!stream->parent->clock)
 356         hr = MF_E_NO_CLOCK;
 357     else if (FAILED(hr = IMFSample_GetSampleTime(sample, &timestamp)))
 358     {
 359         WARN("No sample timestamp, hr %#x.\n", hr);
 360     }
 361     else if (stream->parent->state == EVR_STATE_RUNNING || stream->flags & EVR_STREAM_PREROLLING)
 362     {
 363         if (SUCCEEDED(IMFTransform_ProcessInput(stream->parent->mixer, stream->id, sample, 0)))
 364             IMFVideoPresenter_ProcessMessage(stream->parent->presenter, MFVP_MESSAGE_PROCESSINPUTNOTIFY, 0);
 365
 366         if (stream->flags & EVR_STREAM_PREROLLING)
 367         {
 368             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkPrerolled, &GUID_NULL, S_OK, NULL);
 369             stream->flags &= ~EVR_STREAM_PREROLLING;
 370             stream->flags |= EVR_STREAM_PREROLLED;
 371         }
 372     }
 373
 374     LeaveCriticalSection(&stream->cs);
 375
 376     return hr;
 377 }
 378
 379 static HRESULT WINAPI video_stream_sink_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type,
 380         const PROPVARIANT *marker_value, const PROPVARIANT *context_value)
 381 {
 382     FIXME("%p, %d, %p, %p.\n", iface, marker_type, marker_value, context_value);
 383
 384     return E_NOTIMPL;
 385 }
 386
 387 static HRESULT WINAPI video_stream_sink_Flush(IMFStreamSink *iface)
 388 {
 389     FIXME("%p.\n", iface);
 390
 391     return E_NOTIMPL;
 392 }
 393
 394 static const IMFStreamSinkVtbl video_stream_sink_vtbl =
 395 {
 396     video_stream_sink_QueryInterface,
 397     video_stream_sink_AddRef,
 398     video_stream_sink_Release,
 399     video_stream_sink_GetEvent,
 400     video_stream_sink_BeginGetEvent,
 401     video_stream_sink_EndGetEvent,
 402     video_stream_sink_QueueEvent,
 403     video_stream_sink_GetMediaSink,
 404     video_stream_sink_GetIdentifier,
 405     video_stream_sink_GetMediaTypeHandler,
 406     video_stream_sink_ProcessSample,
 407     video_stream_sink_PlaceMarker,
 408     video_stream_sink_Flush,
 409 };
 410
 411 static HRESULT WINAPI video_stream_typehandler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid,
 412         void **obj)
 413 {
 414     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 415     return IMFStreamSink_QueryInterface(&stream->IMFStreamSink_iface, riid, obj);
 416 }
 417
 418 static ULONG WINAPI video_stream_typehandler_AddRef(IMFMediaTypeHandler *iface)
 419 {
 420     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 421     return IMFStreamSink_AddRef(&stream->IMFStreamSink_iface);
 422 }
 423
 424 static ULONG WINAPI video_stream_typehandler_Release(IMFMediaTypeHandler *iface)
 425 {
 426     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 427     return IMFStreamSink_Release(&stream->IMFStreamSink_iface);
 428 }
 429
 430 static HRESULT WINAPI video_stream_typehandler_IsMediaTypeSupported(IMFMediaTypeHandler *iface,
 431         IMFMediaType *in_type, IMFMediaType **out_type)
 432 {
 433     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 434     HRESULT hr;
 435
 436     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
 437
 438     if (!in_type)
 439         return E_POINTER;
 440
 441     if (!stream->parent)
 442         return MF_E_INVALIDMEDIATYPE;
 443
 444     if (SUCCEEDED(hr = IMFTransform_SetInputType(stream->parent->mixer, stream->id, in_type,
 445             MFT_SET_TYPE_TEST_ONLY)))
 446     {
 447         if (out_type) *out_type = NULL;
 448     }
 449
 450     return hr;
 451 }
 452
 453 static HRESULT WINAPI video_stream_typehandler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
 454 {
 455     TRACE("%p, %p.\n", iface, count);
 456
 457     if (!count)
 458         return E_POINTER;
 459
 460     *count = 0;
 461
 462     return S_OK;
 463 }
 464
 465 static HRESULT WINAPI video_stream_typehandler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
 466         IMFMediaType **type)
 467 {
 468     TRACE("%p, %u, %p.\n", iface, index, type);
 469
 470     return MF_E_NO_MORE_TYPES;
 471 }
 472
 473 static HRESULT WINAPI video_stream_typehandler_SetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType *type)
 474 {
 475     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 476     HRESULT hr;
 477
 478     TRACE("%p, %p.\n", iface, type);
 479
 480     if (!type)
 481         return E_POINTER;
 482
 483     if (!stream->parent)
 484         return MF_E_STREAMSINK_REMOVED;
 485
 486     hr = IMFTransform_SetInputType(stream->parent->mixer, stream->id, type, 0);
 487     if (SUCCEEDED(hr) && !stream->id)
 488         hr = IMFVideoPresenter_ProcessMessage(stream->parent->presenter, MFVP_MESSAGE_INVALIDATEMEDIATYPE, 0);
 489
 490     return hr;
 491 }
 492
 493 static HRESULT WINAPI video_stream_typehandler_GetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType **type)
 494 {
 495     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 496
 497     TRACE("%p, %p.\n", iface, type);
 498
 499     if (!type)
 500         return E_POINTER;
 501
 502     if (!stream->parent)
 503         return MF_E_STREAMSINK_REMOVED;
 504
 505     return IMFTransform_GetInputCurrentType(stream->parent->mixer, stream->id, type);
 506 }
 507
 508 static HRESULT WINAPI video_stream_typehandler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
 509 {
 510     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 511
 512     TRACE("%p, %p.\n", iface, type);
 513
 514     if (!stream->parent)
 515         return MF_E_STREAMSINK_REMOVED;
 516
 517     if (!type)
 518         return E_POINTER;
 519
 520     memcpy(type, &MFMediaType_Video, sizeof(*type));
 521     return S_OK;
 522 }
 523
 524 static const IMFMediaTypeHandlerVtbl video_stream_type_handler_vtbl =
 525 {
 526     video_stream_typehandler_QueryInterface,
 527     video_stream_typehandler_AddRef,
 528     video_stream_typehandler_Release,
 529     video_stream_typehandler_IsMediaTypeSupported,
 530     video_stream_typehandler_GetMediaTypeCount,
 531     video_stream_typehandler_GetMediaTypeByIndex,
 532     video_stream_typehandler_SetCurrentMediaType,
 533     video_stream_typehandler_GetCurrentMediaType,
 534     video_stream_typehandler_GetMajorType,
 535 };
 536
 537 static HRESULT WINAPI video_stream_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
 538 {
 539     struct video_stream *stream = impl_from_stream_IMFGetService(iface);
 540     return IMFStreamSink_QueryInterface(&stream->IMFStreamSink_iface, riid, obj);
 541 }
 542
 543 static ULONG WINAPI video_stream_get_service_AddRef(IMFGetService *iface)
 544 {
 545     struct video_stream *stream = impl_from_stream_IMFGetService(iface);
 546     return IMFStreamSink_AddRef(&stream->IMFStreamSink_iface);
 547 }
 548
 549 static ULONG WINAPI video_stream_get_service_Release(IMFGetService *iface)
 550 {
 551     struct video_stream *stream = impl_from_stream_IMFGetService(iface);
 552     return IMFStreamSink_Release(&stream->IMFStreamSink_iface);
 553 }
 554
 555 static HRESULT WINAPI video_stream_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 556 {
 557     struct video_stream *stream = impl_from_stream_IMFGetService(iface);
 558     HRESULT hr = S_OK;
 559
 560     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 561
 562     if (IsEqualGUID(service, &MR_VIDEO_ACCELERATION_SERVICE))
 563     {
 564         if (IsEqualIID(riid, &IID_IMFVideoSampleAllocator))
 565         {
 566             EnterCriticalSection(&stream->cs);
 567
 568             if (!stream->allocator)
 569             {
 570                 hr = MFCreateVideoSampleAllocator(&IID_IMFVideoSampleAllocator, (void **)&stream->allocator);
 571                 if (SUCCEEDED(hr))
 572                     hr = IMFVideoSampleAllocator_SetDirectXManager(stream->allocator, stream->parent->device_manager);
 573             }
 574             if (SUCCEEDED(hr))
 575                 hr = IMFVideoSampleAllocator_QueryInterface(stream->allocator, riid, obj);
 576
 577             LeaveCriticalSection(&stream->cs);
 578
 579             return hr;
 580         }
 581
 582         return E_NOINTERFACE;
 583     }
 584
 585     FIXME("Unsupported service %s.\n", debugstr_guid(service));
 586
 587     return E_NOTIMPL;
 588 }
 589
 590 static const IMFGetServiceVtbl video_stream_get_service_vtbl =
 591 {
 592     video_stream_get_service_QueryInterface,
 593     video_stream_get_service_AddRef,
 594     video_stream_get_service_Release,
 595     video_stream_get_service_GetService,
 596 };
 597
 598 static HRESULT video_renderer_stream_create(struct video_renderer *renderer, unsigned int id,
 599         struct video_stream **ret)
 600 {
 601     struct video_stream *stream;
 602     HRESULT hr;
 603
 604     if (!(stream = heap_alloc_zero(sizeof(*stream))))
 605         return E_OUTOFMEMORY;
 606
 607     stream->IMFStreamSink_iface.lpVtbl = &video_stream_sink_vtbl;
 608     stream->IMFMediaTypeHandler_iface.lpVtbl = &video_stream_type_handler_vtbl;
 609     stream->IMFGetService_iface.lpVtbl = &video_stream_get_service_vtbl;
 610     stream->refcount = 1;
 611     InitializeCriticalSection(&stream->cs);
 612
 613     if (FAILED(hr = MFCreateEventQueue(&stream->event_queue)))
 614         goto failed;
 615
 616     stream->parent = renderer;
 617     IMFMediaSink_AddRef(&stream->parent->IMFMediaSink_iface);
 618     stream->id = id;
 619
 620     *ret = stream;
 621
 622     return S_OK;
 623
 624 failed:
 625
 626     IMFStreamSink_Release(&stream->IMFStreamSink_iface);
 627
 628     return hr;
 629 }
 630
 631 static HRESULT WINAPI video_renderer_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj)
 632 {
 633     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 634
 635     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 636
 637     if (IsEqualIID(riid, &IID_IMFMediaSink) ||
 638             IsEqualIID(riid, &IID_IUnknown))
 639     {
 640         *obj = &renderer->IMFMediaSink_iface;
 641     }
 642     else if (IsEqualIID(riid, &IID_IMFMediaSinkPreroll))
 643     {
 644         *obj = &renderer->IMFMediaSinkPreroll_iface;
 645     }
 646     else if (IsEqualIID(riid, &IID_IMFVideoRenderer))
 647     {
 648         *obj = &renderer->IMFVideoRenderer_iface;
 649     }
 650     else if (IsEqualIID(riid, &IID_IMFMediaEventGenerator))
 651     {
 652         *obj = &renderer->IMFMediaEventGenerator_iface;
 653     }
 654     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
 655     {
 656         *obj = &renderer->IMFClockStateSink_iface;
 657     }
 658     else if (IsEqualIID(riid, &IID_IMFGetService))
 659     {
 660         *obj = &renderer->IMFGetService_iface;
 661     }
 662     else if (IsEqualIID(riid, &IID_IMFAttributes))
 663     {
 664         *obj = &renderer->IMFAttributes_iface;
 665     }
 666     else if (IsEqualIID(riid, &IID_IMFQualityAdvise))
 667     {
 668         *obj = &renderer->IMFQualityAdvise_iface;
 669     }
 670     else
 671     {
 672         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 673         *obj = NULL;
 674         return E_NOINTERFACE;
 675     }
 676
 677     IUnknown_AddRef((IUnknown *)*obj);
 678
 679     return S_OK;
 680 }
 681
 682 static ULONG WINAPI video_renderer_sink_AddRef(IMFMediaSink *iface)
 683 {
 684     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 685     ULONG refcount = InterlockedIncrement(&renderer->refcount);
 686     TRACE("%p, refcount %u.\n", iface, refcount);
 687     return refcount;
 688 }
 689
 690 static ULONG WINAPI video_renderer_sink_Release(IMFMediaSink *iface)
 691 {
 692     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 693     ULONG refcount = InterlockedDecrement(&renderer->refcount);
 694
 695     TRACE("%p, refcount %u.\n", iface, refcount);
 696
 697     if (!refcount)
 698     {
 699         if (renderer->event_queue)
 700             IMFMediaEventQueue_Release(renderer->event_queue);
 701         if (renderer->mixer)
 702             IMFTransform_Release(renderer->mixer);
 703         if (renderer->presenter)
 704             IMFVideoPresenter_Release(renderer->presenter);
 705         if (renderer->device_manager)
 706             IUnknown_Release(renderer->device_manager);
 707         if (renderer->clock)
 708             IMFPresentationClock_Release(renderer->clock);
 709         if (renderer->attributes)
 710             IMFAttributes_Release(renderer->attributes);
 711         DeleteCriticalSection(&renderer->cs);
 712         heap_free(renderer);
 713     }
 714
 715     return refcount;
 716 }
 717
 718 static HRESULT WINAPI video_renderer_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags)
 719 {
 720     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 721
 722     TRACE("%p, %p.\n", iface, flags);
 723
 724     if (renderer->flags & EVR_SHUT_DOWN)
 725         return MF_E_SHUTDOWN;
 726
 727     *flags = MEDIASINK_CLOCK_REQUIRED | MEDIASINK_CAN_PREROLL;
 728
 729     return S_OK;
 730 }
 731
 732 static HRESULT video_renderer_add_stream(struct video_renderer *renderer, unsigned int id,
 733         IMFStreamSink **stream_sink)
 734 {
 735     struct video_stream *stream;
 736     HRESULT hr;
 737
 738     if (!mf_array_reserve((void **)&renderer->streams, &renderer->stream_size, renderer->stream_count + 1,
 739             sizeof(*renderer->streams)))
 740     {
 741         return E_OUTOFMEMORY;
 742     }
 743
 744     if (SUCCEEDED(hr = video_renderer_stream_create(renderer, id, &stream)))
 745     {
 746         if (stream_sink)
 747         {
 748             *stream_sink = &stream->IMFStreamSink_iface;
 749             IMFStreamSink_AddRef(*stream_sink);
 750         }
 751         renderer->streams[renderer->stream_count++] = stream;
 752     }
 753
 754     return hr;
 755 }
 756
 757 static HRESULT WINAPI video_renderer_sink_AddStreamSink(IMFMediaSink *iface, DWORD id,
 758     IMFMediaType *media_type, IMFStreamSink **stream_sink)
 759 {
 760     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 761     HRESULT hr;
 762
 763     TRACE("%p, %#x, %p, %p.\n", iface, id, media_type, stream_sink);
 764
 765     /* Rely on mixer for stream id validation. */
 766
 767     EnterCriticalSection(&renderer->cs);
 768     if (renderer->flags & EVR_SHUT_DOWN)
 769         hr = MF_E_SHUTDOWN;
 770     else if (SUCCEEDED(hr = IMFTransform_AddInputStreams(renderer->mixer, 1, &id)))
 771     {
 772         if (FAILED(hr = video_renderer_add_stream(renderer, id, stream_sink)))
 773             IMFTransform_DeleteInputStream(renderer->mixer, id);
 774
 775     }
 776     LeaveCriticalSection(&renderer->cs);
 777
 778     return hr;
 779 }
 780
 781 static HRESULT WINAPI video_renderer_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD id)
 782 {
 783     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 784     HRESULT hr;
 785     size_t i;
 786
 787     TRACE("%p, %#x.\n", iface, id);
 788
 789     /* Rely on mixer for stream id validation. */
 790
 791     EnterCriticalSection(&renderer->cs);
 792     if (renderer->flags & EVR_SHUT_DOWN)
 793         hr = MF_E_SHUTDOWN;
 794     else if (SUCCEEDED(hr = IMFTransform_DeleteInputStream(renderer->mixer, id)))
 795     {
 796         for (i = 0; i < renderer->stream_count; ++i)
 797         {
 798             if (renderer->streams[i]->id == id)
 799             {
 800                 IMFStreamSink_Release(&renderer->streams[i]->IMFStreamSink_iface);
 801                 renderer->streams[i] = NULL;
 802                 if (i < renderer->stream_count - 1)
 803                 {
 804                     memmove(&renderer->streams[i], &renderer->streams[i+1],
 805                             (renderer->stream_count - i - 1) * sizeof(*renderer->streams));
 806                 }
 807                 renderer->stream_count--;
 808                 break;
 809             }
 810         }
 811     }
 812     LeaveCriticalSection(&renderer->cs);
 813
 814     return hr;
 815 }
 816
 817 static HRESULT WINAPI video_renderer_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
 818 {
 819     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 820     HRESULT hr = S_OK;
 821
 822     TRACE("%p, %p.\n", iface, count);
 823
 824     if (!count)
 825         return E_POINTER;
 826
 827     EnterCriticalSection(&renderer->cs);
 828     if (renderer->flags & EVR_SHUT_DOWN)
 829         hr = MF_E_SHUTDOWN;
 830     else if (!count)
 831         hr = E_POINTER;
 832     else
 833         *count = renderer->stream_count;
 834     LeaveCriticalSection(&renderer->cs);
 835
 836     return hr;
 837 }
 838
 839 static HRESULT WINAPI video_renderer_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index,
 840         IMFStreamSink **stream)
 841 {
 842     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 843     HRESULT hr = S_OK;
 844
 845     TRACE("%p, %u, %p.\n", iface, index, stream);
 846
 847     EnterCriticalSection(&renderer->cs);
 848     if (renderer->flags & EVR_SHUT_DOWN)
 849         hr = MF_E_SHUTDOWN;
 850     else if (!stream)
 851         hr = E_POINTER;
 852     else if (index >= renderer->stream_count)
 853         hr = E_INVALIDARG;
 854     else
 855     {
 856         *stream = &renderer->streams[index]->IMFStreamSink_iface;
 857         IMFStreamSink_AddRef(*stream);
 858     }
 859     LeaveCriticalSection(&renderer->cs);
 860
 861     return hr;
 862 }
 863
 864 static HRESULT WINAPI video_renderer_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD id,
 865         IMFStreamSink **stream)
 866 {
 867     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 868     HRESULT hr = S_OK;
 869     size_t i;
 870
 871     TRACE("%p, %#x, %p.\n", iface, id, stream);
 872
 873     EnterCriticalSection(&renderer->cs);
 874     if (renderer->flags & EVR_SHUT_DOWN)
 875         hr = MF_E_SHUTDOWN;
 876     else if (!stream)
 877         hr = E_POINTER;
 878     else
 879     {
 880         for (i = 0; i < renderer->stream_count; ++i)
 881         {
 882             if (renderer->streams[i]->id == id)
 883                 break;
 884         }
 885
 886         if (i == renderer->stream_count)
 887             hr = MF_E_INVALIDSTREAMNUMBER;
 888         else
 889         {
 890             *stream = &renderer->streams[i]->IMFStreamSink_iface;
 891             IMFStreamSink_AddRef(*stream);
 892         }
 893     }
 894     LeaveCriticalSection(&renderer->cs);
 895
 896     return hr;
 897 }
 898
 899 static void video_renderer_set_presentation_clock(struct video_renderer *renderer, IMFPresentationClock *clock)
 900 {
 901     if (renderer->clock)
 902     {
 903         IMFPresentationClock_RemoveClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
 904         IMFPresentationClock_Release(renderer->clock);
 905     }
 906     renderer->clock = clock;
 907     if (renderer->clock)
 908     {
 909         IMFPresentationClock_AddRef(renderer->clock);
 910         IMFPresentationClock_AddClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
 911     }
 912 }
 913
 914 static HRESULT WINAPI video_renderer_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
 915 {
 916     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 917     HRESULT hr = S_OK;
 918
 919     TRACE("%p, %p.\n", iface, clock);
 920
 921     EnterCriticalSection(&renderer->cs);
 922
 923     if (renderer->flags & EVR_SHUT_DOWN)
 924         hr = MF_E_SHUTDOWN;
 925     else
 926         video_renderer_set_presentation_clock(renderer, clock);
 927
 928     LeaveCriticalSection(&renderer->cs);
 929
 930     return hr;
 931 }
 932
 933 static HRESULT WINAPI video_renderer_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
 934 {
 935     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 936     HRESULT hr = S_OK;
 937
 938     TRACE("%p, %p.\n", iface, clock);
 939
 940     if (!clock)
 941         return E_POINTER;
 942
 943     EnterCriticalSection(&renderer->cs);
 944
 945     if (renderer->flags & EVR_SHUT_DOWN)
 946         hr = MF_E_SHUTDOWN;
 947     else if (renderer->clock)
 948     {
 949         *clock = renderer->clock;
 950         IMFPresentationClock_AddRef(*clock);
 951     }
 952     else
 953         hr = MF_E_NO_CLOCK;
 954
 955     LeaveCriticalSection(&renderer->cs);
 956
 957     return hr;
 958 }
 959
 960 static HRESULT WINAPI video_renderer_sink_Shutdown(IMFMediaSink *iface)
 961 {
 962     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 963     size_t i;
 964
 965     TRACE("%p.\n", iface);
 966
 967     if (renderer->flags & EVR_SHUT_DOWN)
 968         return MF_E_SHUTDOWN;
 969
 970     EnterCriticalSection(&renderer->cs);
 971     renderer->flags |= EVR_SHUT_DOWN;
 972     /* Detach streams from the sink. */
 973     for (i = 0; i < renderer->stream_count; ++i)
 974     {
 975         struct video_stream *stream = renderer->streams[i];
 976
 977         EnterCriticalSection(&stream->cs);
 978         stream->parent = NULL;
 979         LeaveCriticalSection(&stream->cs);
 980
 981         IMFMediaEventQueue_Shutdown(stream->event_queue);
 982         IMFStreamSink_Release(&stream->IMFStreamSink_iface);
 983         IMFMediaSink_Release(iface);
 984         renderer->streams[i] = NULL;
 985     }
 986     heap_free(renderer->streams);
 987     renderer->stream_count = 0;
 988     renderer->stream_size = 0;
 989     IMFMediaEventQueue_Shutdown(renderer->event_queue);
 990     video_renderer_set_presentation_clock(renderer, NULL);
 991     video_renderer_release_services(renderer);
 992     LeaveCriticalSection(&renderer->cs);
 993
 994     return S_OK;
 995 }
 996
 997 static const IMFMediaSinkVtbl video_renderer_sink_vtbl =
 998 {
 999     video_renderer_sink_QueryInterface,
1000     video_renderer_sink_AddRef,
1001     video_renderer_sink_Release,
1002     video_renderer_sink_GetCharacteristics,
1003     video_renderer_sink_AddStreamSink,
1004     video_renderer_sink_RemoveStreamSink,
1005     video_renderer_sink_GetStreamSinkCount,
1006     video_renderer_sink_GetStreamSinkByIndex,
1007     video_renderer_sink_GetStreamSinkById,
1008     video_renderer_sink_SetPresentationClock,
1009     video_renderer_sink_GetPresentationClock,
1010     video_renderer_sink_Shutdown,
1011 };
1012
1013 static HRESULT WINAPI video_renderer_preroll_QueryInterface(IMFMediaSinkPreroll *iface, REFIID riid, void **obj)
1014 {
1015     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1016     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1017 }
1018
1019 static ULONG WINAPI video_renderer_preroll_AddRef(IMFMediaSinkPreroll *iface)
1020 {
1021     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1022     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1023 }
1024
1025 static ULONG WINAPI video_renderer_preroll_Release(IMFMediaSinkPreroll *iface)
1026 {
1027     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1028     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1029 }
1030
1031 static HRESULT WINAPI video_renderer_preroll_NotifyPreroll(IMFMediaSinkPreroll *iface, MFTIME start_time)
1032 {
1033     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1034     HRESULT hr = S_OK;
1035     size_t i;
1036
1037     TRACE("%p, %s.\n", iface, debugstr_time(start_time));
1038
1039     EnterCriticalSection(&renderer->cs);
1040     if (renderer->flags & EVR_SHUT_DOWN)
1041         hr = MF_E_SHUTDOWN;
1042     else
1043     {
1044         for (i = 0; i < renderer->stream_count; ++i)
1045         {
1046             struct video_stream *stream = renderer->streams[i];
1047
1048             EnterCriticalSection(&stream->cs);
1049             if (!(stream->flags & (EVR_STREAM_PREROLLING | EVR_STREAM_PREROLLED)))
1050             {
1051                 IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkRequestSample,
1052                         &GUID_NULL, S_OK, NULL);
1053                 stream->flags |= EVR_STREAM_PREROLLING;
1054             }
1055             LeaveCriticalSection(&stream->cs);
1056         }
1057     }
1058     LeaveCriticalSection(&renderer->cs);
1059
1060     return hr;
1061 }
1062
1063 static const IMFMediaSinkPrerollVtbl video_renderer_preroll_vtbl =
1064 {
1065     video_renderer_preroll_QueryInterface,
1066     video_renderer_preroll_AddRef,
1067     video_renderer_preroll_Release,
1068     video_renderer_preroll_NotifyPreroll,
1069 };
1070
1071 static HRESULT WINAPI video_renderer_QueryInterface(IMFVideoRenderer *iface, REFIID riid, void **obj)
1072 {
1073     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1074     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1075 }
1076
1077 static ULONG WINAPI video_renderer_AddRef(IMFVideoRenderer *iface)
1078 {
1079     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1080     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1081 }
1082
1083 static ULONG WINAPI video_renderer_Release(IMFVideoRenderer *iface)
1084 {
1085     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1086     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1087 }
1088
1089 static HRESULT video_renderer_create_mixer(IMFAttributes *attributes, IMFTransform **out)
1090 {
1091     unsigned int flags = 0;
1092     IMFActivate *activate;
1093     CLSID clsid;
1094     HRESULT hr;
1095
1096     if (attributes && SUCCEEDED(hr = IMFAttributes_GetUnknown(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_ACTIVATE,
1097             &IID_IMFActivate, (void **)&activate)))
1098     {
1099         IMFAttributes_GetUINT32(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_FLAGS, &flags);
1100         hr = IMFActivate_ActivateObject(activate, &IID_IMFTransform, (void **)out);
1101         IMFActivate_Release(activate);
1102         if (SUCCEEDED(hr) || !(flags & MF_ACTIVATE_CUSTOM_MIXER_ALLOWFAIL))
1103             return hr;
1104     }
1105
1106     if (!attributes || FAILED(IMFAttributes_GetGUID(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_CLSID, &clsid)))
1107         memcpy(&clsid, &CLSID_MFVideoMixer9, sizeof(clsid));
1108
1109     return CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTransform, (void **)out);
1110 }
1111
1112 static HRESULT video_renderer_create_presenter(struct video_renderer *renderer, IMFAttributes *attributes,
1113         IMFVideoPresenter **out)
1114 {
1115     unsigned int flags = 0;
1116     IMFActivate *activate;
1117     UINT64 value;
1118     CLSID clsid;
1119     HRESULT hr;
1120
1121     if (attributes && SUCCEEDED(IMFAttributes_GetUINT64(attributes, &MF_ACTIVATE_VIDEO_WINDOW, &value)))
1122         renderer->window = UlongToHandle(value);
1123
1124     if (attributes && SUCCEEDED(IMFAttributes_GetUnknown(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE,
1125             &IID_IMFActivate, (void **)&activate)))
1126     {
1127         IMFAttributes_GetUINT32(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_FLAGS, &flags);
1128         hr = IMFActivate_ActivateObject(activate, &IID_IMFVideoPresenter, (void **)out);
1129         IMFActivate_Release(activate);
1130         if (SUCCEEDED(hr) || !(flags & MF_ACTIVATE_CUSTOM_PRESENTER_ALLOWFAIL))
1131             return hr;
1132     }
1133
1134     if (!attributes || FAILED(IMFAttributes_GetGUID(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID, &clsid)))
1135         memcpy(&clsid, &CLSID_MFVideoPresenter9, sizeof(clsid));
1136
1137     return CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFVideoPresenter, (void **)out);
1138 }
1139
1140 static HRESULT video_renderer_configure_mixer(struct video_renderer *renderer)
1141 {
1142     IMFTopologyServiceLookupClient *lookup_client;
1143     IMFAttributes *attributes;
1144     HRESULT hr;
1145
1146     if (SUCCEEDED(hr = IMFTransform_QueryInterface(renderer->mixer, &IID_IMFTopologyServiceLookupClient,
1147             (void **)&lookup_client)))
1148     {
1149         renderer->flags |= EVR_INIT_SERVICES;
1150         if (SUCCEEDED(hr = IMFTopologyServiceLookupClient_InitServicePointers(lookup_client,
1151                 &renderer->IMFTopologyServiceLookup_iface)))
1152         {
1153             renderer->flags |= EVR_MIXER_INITED_SERVICES;
1154         }
1155         renderer->flags &= ~EVR_INIT_SERVICES;
1156         IMFTopologyServiceLookupClient_Release(lookup_client);
1157     }
1158
1159     if (SUCCEEDED(hr))
1160     {
1161         unsigned int input_count, output_count;
1162         unsigned int *ids, *oids;
1163         size_t i;
1164
1165         /* Create stream sinks for inputs that mixer already has by default. */
1166         if (SUCCEEDED(IMFTransform_GetStreamCount(renderer->mixer, &input_count, &output_count)))
1167         {
1168             ids = heap_calloc(input_count, sizeof(*ids));
1169             oids = heap_calloc(output_count, sizeof(*oids));
1170
1171             if (ids && oids)
1172             {
1173                 if (SUCCEEDED(IMFTransform_GetStreamIDs(renderer->mixer, input_count, ids, output_count, oids)))
1174                 {
1175                     for (i = 0; i < input_count; ++i)
1176                     {
1177                         video_renderer_add_stream(renderer, ids[i], NULL);
1178                     }
1179                 }
1180
1181             }
1182
1183             heap_free(ids);
1184             heap_free(oids);
1185         }
1186     }
1187
1188     /* Set device manager that presenter should have created. */
1189     if (SUCCEEDED(IMFTransform_QueryInterface(renderer->mixer, &IID_IMFAttributes, (void **)&attributes)))
1190     {
1191         IDirect3DDeviceManager9 *device_manager;
1192         unsigned int value;
1193
1194         if (SUCCEEDED(IMFAttributes_GetUINT32(attributes, &MF_SA_D3D_AWARE, &value)) && value)
1195         {
1196             if (SUCCEEDED(MFGetService((IUnknown *)renderer->presenter, &MR_VIDEO_ACCELERATION_SERVICE,
1197                     &IID_IDirect3DDeviceManager9, (void **)&device_manager)))
1198             {
1199                 IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_SET_D3D_MANAGER, (ULONG_PTR)device_manager);
1200                 IDirect3DDeviceManager9_Release(device_manager);
1201             }
1202         }
1203         IMFAttributes_Release(attributes);
1204     }
1205
1206     return hr;
1207 }
1208
1209 static HRESULT video_renderer_configure_presenter(struct video_renderer *renderer)
1210 {
1211     IMFTopologyServiceLookupClient *lookup_client;
1212     IMFVideoDisplayControl *control;
1213     HRESULT hr;
1214
1215     if (SUCCEEDED(IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFVideoDisplayControl, (void **)&control)))
1216     {
1217         IMFVideoDisplayControl_SetVideoWindow(control, renderer->window);
1218         IMFVideoDisplayControl_Release(control);
1219     }
1220
1221     if (SUCCEEDED(hr = IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFTopologyServiceLookupClient,
1222             (void **)&lookup_client)))
1223     {
1224         renderer->flags |= EVR_INIT_SERVICES;
1225         if (SUCCEEDED(hr = IMFTopologyServiceLookupClient_InitServicePointers(lookup_client,
1226                 &renderer->IMFTopologyServiceLookup_iface)))
1227         {
1228             renderer->flags |= EVR_PRESENTER_INITED_SERVICES;
1229         }
1230         renderer->flags &= ~EVR_INIT_SERVICES;
1231         IMFTopologyServiceLookupClient_Release(lookup_client);
1232     }
1233
1234     if (FAILED(MFGetService((IUnknown *)renderer->presenter, &MR_VIDEO_ACCELERATION_SERVICE,
1235             &IID_IUnknown, (void **)&renderer->device_manager)))
1236     {
1237         WARN("Failed to get device manager from the presenter.\n");
1238     }
1239
1240     return hr;
1241 }
1242
1243 static HRESULT video_renderer_initialize(struct video_renderer *renderer, IMFTransform *mixer,
1244         IMFVideoPresenter *presenter)
1245 {
1246     HRESULT hr;
1247
1248     if (renderer->mixer)
1249     {
1250         IMFTransform_Release(renderer->mixer);
1251         renderer->mixer = NULL;
1252     }
1253
1254     if (renderer->presenter)
1255     {
1256         IMFVideoPresenter_Release(renderer->presenter);
1257         renderer->presenter = NULL;
1258     }
1259
1260     if (renderer->device_manager)
1261     {
1262         IUnknown_Release(renderer->device_manager);
1263         renderer->device_manager = NULL;
1264     }
1265
1266     renderer->mixer = mixer;
1267     IMFTransform_AddRef(renderer->mixer);
1268
1269     renderer->presenter = presenter;
1270     IMFVideoPresenter_AddRef(renderer->presenter);
1271
1272     if (SUCCEEDED(hr = video_renderer_configure_mixer(renderer)))
1273         hr = video_renderer_configure_presenter(renderer);
1274
1275     return hr;
1276 }
1277
1278 static HRESULT WINAPI video_renderer_InitializeRenderer(IMFVideoRenderer *iface, IMFTransform *mixer,
1279         IMFVideoPresenter *presenter)
1280 {
1281     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1282     HRESULT hr;
1283
1284     TRACE("%p, %p, %p.\n", iface, mixer, presenter);
1285
1286     if (mixer)
1287         IMFTransform_AddRef(mixer);
1288     else if (FAILED(hr = video_renderer_create_mixer(NULL, &mixer)))
1289     {
1290         WARN("Failed to create default mixer object, hr %#x.\n", hr);
1291         return hr;
1292     }
1293
1294     if (presenter)
1295         IMFVideoPresenter_AddRef(presenter);
1296     else if (FAILED(hr = video_renderer_create_presenter(renderer, NULL, &presenter)))
1297     {
1298         WARN("Failed to create default presenter, hr %#x.\n", hr);
1299         IMFTransform_Release(mixer);
1300         return hr;
1301     }
1302
1303     EnterCriticalSection(&renderer->cs);
1304
1305     if (renderer->flags & EVR_SHUT_DOWN)
1306         hr = MF_E_SHUTDOWN;
1307     else
1308     {
1309         /* FIXME: check clock state */
1310         /* FIXME: check that streams are not initialized */
1311
1312         hr = video_renderer_initialize(renderer, mixer, presenter);
1313     }
1314
1315     LeaveCriticalSection(&renderer->cs);
1316
1317     IMFTransform_Release(mixer);
1318     IMFVideoPresenter_Release(presenter);
1319
1320     return hr;
1321 }
1322
1323 static const IMFVideoRendererVtbl video_renderer_vtbl =
1324 {
1325     video_renderer_QueryInterface,
1326     video_renderer_AddRef,
1327     video_renderer_Release,
1328     video_renderer_InitializeRenderer,
1329 };
1330
1331 static HRESULT WINAPI video_renderer_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
1332 {
1333     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1334     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1335 }
1336
1337 static ULONG WINAPI video_renderer_events_AddRef(IMFMediaEventGenerator *iface)
1338 {
1339     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1340     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1341 }
1342
1343 static ULONG WINAPI video_renderer_events_Release(IMFMediaEventGenerator *iface)
1344 {
1345     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1346     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1347 }
1348
1349 static HRESULT WINAPI video_renderer_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
1350 {
1351     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1352
1353     TRACE("%p, %#x, %p.\n", iface, flags, event);
1354
1355     return IMFMediaEventQueue_GetEvent(renderer->event_queue, flags, event);
1356 }
1357
1358 static HRESULT WINAPI video_renderer_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
1359         IUnknown *state)
1360 {
1361     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1362
1363     TRACE("%p, %p, %p.\n", iface, callback, state);
1364
1365     return IMFMediaEventQueue_BeginGetEvent(renderer->event_queue, callback, state);
1366 }
1367
1368 static HRESULT WINAPI video_renderer_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
1369         IMFMediaEvent **event)
1370 {
1371     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1372
1373     TRACE("%p, %p, %p.\n", iface, result, event);
1374
1375     return IMFMediaEventQueue_EndGetEvent(renderer->event_queue, result, event);
1376 }
1377
1378 static HRESULT WINAPI video_renderer_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
1379         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
1380 {
1381     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1382
1383     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
1384
1385     return IMFMediaEventQueue_QueueEventParamVar(renderer->event_queue, event_type, ext_type, hr, value);
1386 }
1387
1388 static const IMFMediaEventGeneratorVtbl video_renderer_events_vtbl =
1389 {
1390     video_renderer_events_QueryInterface,
1391     video_renderer_events_AddRef,
1392     video_renderer_events_Release,
1393     video_renderer_events_GetEvent,
1394     video_renderer_events_BeginGetEvent,
1395     video_renderer_events_EndGetEvent,
1396     video_renderer_events_QueueEvent,
1397 };
1398
1399 static HRESULT WINAPI video_renderer_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
1400 {
1401     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1402     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1403 }
1404
1405 static ULONG WINAPI video_renderer_clock_sink_AddRef(IMFClockStateSink *iface)
1406 {
1407     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1408     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1409 }
1410
1411 static ULONG WINAPI video_renderer_clock_sink_Release(IMFClockStateSink *iface)
1412 {
1413     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1414     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1415 }
1416
1417 static HRESULT WINAPI video_renderer_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
1418 {
1419     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1420     size_t i;
1421
1422     TRACE("%p, %s, %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
1423
1424     EnterCriticalSection(&renderer->cs);
1425
1426     if (renderer->state == EVR_STATE_STOPPED)
1427     {
1428         IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
1429         IMFVideoPresenter_ProcessMessage(renderer->presenter, MFVP_MESSAGE_BEGINSTREAMING, 0);
1430
1431         for (i = 0; i < renderer->stream_count; ++i)
1432         {
1433             struct video_stream *stream = renderer->streams[i];
1434
1435             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkStarted, &GUID_NULL, S_OK, NULL);
1436
1437             EnterCriticalSection(&stream->cs);
1438             if (!(stream->flags & EVR_STREAM_PREROLLED))
1439                 IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkRequestSample,
1440                         &GUID_NULL, S_OK, NULL);
1441             stream->flags |= EVR_STREAM_PREROLLED;
1442             LeaveCriticalSection(&stream->cs);
1443         }
1444     }
1445
1446     renderer->state = EVR_STATE_RUNNING;
1447
1448     IMFVideoPresenter_OnClockStart(renderer->presenter, systime, offset);
1449
1450     LeaveCriticalSection(&renderer->cs);
1451
1452     return S_OK;
1453 }
1454
1455 static HRESULT WINAPI video_renderer_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
1456 {
1457     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1458     size_t i;
1459
1460     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1461
1462     EnterCriticalSection(&renderer->cs);
1463
1464     IMFVideoPresenter_OnClockStop(renderer->presenter, systime);
1465
1466     IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_COMMAND_FLUSH, 0);
1467     IMFVideoPresenter_ProcessMessage(renderer->presenter, MFVP_MESSAGE_FLUSH, 0);
1468
1469     if (renderer->state == EVR_STATE_RUNNING ||
1470             renderer->state == EVR_STATE_PAUSED)
1471     {
1472         IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_NOTIFY_END_STREAMING, 0);
1473         IMFVideoPresenter_ProcessMessage(renderer->presenter, MFVP_MESSAGE_ENDSTREAMING, 0);
1474
1475         for (i = 0; i < renderer->stream_count; ++i)
1476         {
1477             struct video_stream *stream = renderer->streams[i];
1478             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkStopped, &GUID_NULL, S_OK, NULL);
1479
1480             EnterCriticalSection(&stream->cs);
1481             stream->flags &= ~EVR_STREAM_PREROLLED;
1482             LeaveCriticalSection(&stream->cs);
1483         }
1484         renderer->state = EVR_STATE_STOPPED;
1485     }
1486
1487     LeaveCriticalSection(&renderer->cs);
1488
1489     return S_OK;
1490 }
1491
1492 static HRESULT WINAPI video_renderer_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
1493 {
1494     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1495     size_t i;
1496
1497     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1498
1499     EnterCriticalSection(&renderer->cs);
1500
1501     IMFVideoPresenter_OnClockPause(renderer->presenter, systime);
1502
1503     if (renderer->state == EVR_STATE_RUNNING)
1504     {
1505         for (i = 0; i < renderer->stream_count; ++i)
1506         {
1507             struct video_stream *stream = renderer->streams[i];
1508             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkPaused, &GUID_NULL, S_OK, NULL);
1509         }
1510     }
1511
1512     renderer->state = EVR_STATE_PAUSED;
1513
1514     LeaveCriticalSection(&renderer->cs);
1515
1516     return S_OK;
1517 }
1518
1519 static HRESULT WINAPI video_renderer_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
1520 {
1521     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1522     size_t i;
1523
1524     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1525
1526     EnterCriticalSection(&renderer->cs);
1527
1528     IMFVideoPresenter_OnClockRestart(renderer->presenter, systime);
1529
1530     for (i = 0; i < renderer->stream_count; ++i)
1531     {
1532         struct video_stream *stream = renderer->streams[i];
1533         IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkStarted, &GUID_NULL, S_OK, NULL);
1534     }
1535     renderer->state = EVR_STATE_RUNNING;
1536
1537     LeaveCriticalSection(&renderer->cs);
1538
1539     return S_OK;
1540 }
1541
1542 static HRESULT WINAPI video_renderer_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
1543 {
1544     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1545     IMFClockStateSink *sink;
1546
1547     TRACE("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
1548
1549     EnterCriticalSection(&renderer->cs);
1550
1551     IMFVideoPresenter_OnClockSetRate(renderer->presenter, systime, rate);
1552     if (SUCCEEDED(IMFTransform_QueryInterface(renderer->mixer, &IID_IMFClockStateSink, (void **)&sink)))
1553     {
1554         IMFClockStateSink_OnClockSetRate(sink, systime, rate);
1555         IMFClockStateSink_Release(sink);
1556     }
1557
1558     LeaveCriticalSection(&renderer->cs);
1559
1560     return S_OK;
1561 }
1562
1563 static const IMFClockStateSinkVtbl video_renderer_clock_sink_vtbl =
1564 {
1565     video_renderer_clock_sink_QueryInterface,
1566     video_renderer_clock_sink_AddRef,
1567     video_renderer_clock_sink_Release,
1568     video_renderer_clock_sink_OnClockStart,
1569     video_renderer_clock_sink_OnClockStop,
1570     video_renderer_clock_sink_OnClockPause,
1571     video_renderer_clock_sink_OnClockRestart,
1572     video_renderer_clock_sink_OnClockSetRate,
1573 };
1574
1575 static HRESULT WINAPI video_renderer_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
1576 {
1577     struct video_renderer *renderer = impl_from_IMFGetService(iface);
1578     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1579 }
1580
1581 static ULONG WINAPI video_renderer_get_service_AddRef(IMFGetService *iface)
1582 {
1583     struct video_renderer *renderer = impl_from_IMFGetService(iface);
1584     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1585 }
1586
1587 static ULONG WINAPI video_renderer_get_service_Release(IMFGetService *iface)
1588 {
1589     struct video_renderer *renderer = impl_from_IMFGetService(iface);
1590     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1591 }
1592
1593 static HRESULT WINAPI video_renderer_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
1594 {
1595     struct video_renderer *renderer = impl_from_IMFGetService(iface);
1596     HRESULT hr = E_NOINTERFACE;
1597     IMFGetService *gs = NULL;
1598
1599     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
1600
1601     if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE))
1602     {
1603         hr = IMFTransform_QueryInterface(renderer->mixer, &IID_IMFGetService, (void **)&gs);
1604     }
1605     else if (IsEqualGUID(service, &MR_VIDEO_RENDER_SERVICE))
1606     {
1607         hr = IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFGetService, (void **)&gs);
1608     }
1609     else
1610     {
1611         FIXME("Unsupported service %s.\n", debugstr_guid(service));
1612     }
1613
1614     if (gs)
1615     {
1616         hr = IMFGetService_GetService(gs, service, riid, obj);
1617         IMFGetService_Release(gs);
1618     }
1619
1620     return hr;
1621 }
1622
1623 static const IMFGetServiceVtbl video_renderer_get_service_vtbl =
1624 {
1625     video_renderer_get_service_QueryInterface,
1626     video_renderer_get_service_AddRef,
1627     video_renderer_get_service_Release,
1628     video_renderer_get_service_GetService,
1629 };
1630
1631 static HRESULT WINAPI video_renderer_service_lookup_QueryInterface(IMFTopologyServiceLookup *iface, REFIID riid, void **obj)
1632 {
1633     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1634
1635     if (IsEqualIID(riid, &IID_IMFTopologyServiceLookup) ||
1636             IsEqualIID(riid, &IID_IUnknown))
1637     {
1638         *obj = iface;
1639         IMFTopologyServiceLookup_AddRef(iface);
1640         return S_OK;
1641     }
1642
1643     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1644     *obj = NULL;
1645     return E_NOINTERFACE;
1646 }
1647
1648 static ULONG WINAPI video_renderer_service_lookup_AddRef(IMFTopologyServiceLookup *iface)
1649 {
1650     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
1651     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1652 }
1653
1654 static ULONG WINAPI video_renderer_service_lookup_Release(IMFTopologyServiceLookup *iface)
1655 {
1656     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
1657     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1658 }
1659
1660 static HRESULT WINAPI video_renderer_service_lookup_LookupService(IMFTopologyServiceLookup *iface,
1661         MF_SERVICE_LOOKUP_TYPE lookup_type, DWORD index, REFGUID service, REFIID riid,
1662         void **objects, DWORD *num_objects)
1663 {
1664     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
1665     HRESULT hr = S_OK;
1666
1667     TRACE("%p, %u, %u, %s, %s, %p, %p.\n", iface, lookup_type, index, debugstr_guid(service), debugstr_guid(riid),
1668             objects, num_objects);
1669
1670     EnterCriticalSection(&renderer->cs);
1671
1672     if (!(renderer->flags & EVR_INIT_SERVICES))
1673         hr = MF_E_NOTACCEPTING;
1674     else if (IsEqualGUID(service, &MR_VIDEO_RENDER_SERVICE))
1675     {
1676         if (IsEqualIID(riid, &IID_IMediaEventSink))
1677         {
1678             *objects = &renderer->IMediaEventSink_iface;
1679             IUnknown_AddRef((IUnknown *)*objects);
1680         }
1681         else
1682         {
1683             FIXME("Unsupported interface %s for render service.\n", debugstr_guid(riid));
1684             hr = E_NOINTERFACE;
1685         }
1686     }
1687     else if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE))
1688     {
1689         if (IsEqualIID(riid, &IID_IMFTransform))
1690         {
1691             *objects = renderer->mixer;
1692             IUnknown_AddRef((IUnknown *)*objects);
1693         }
1694         else
1695         {
1696             FIXME("Unsupported interface %s for mixer service.\n", debugstr_guid(riid));
1697             hr = E_NOINTERFACE;
1698         }
1699     }
1700     else
1701     {
1702         WARN("Unsupported service %s.\n", debugstr_guid(service));
1703         hr = MF_E_UNSUPPORTED_SERVICE;
1704     }
1705
1706     LeaveCriticalSection(&renderer->cs);
1707
1708     return hr;
1709 }
1710
1711 static const IMFTopologyServiceLookupVtbl video_renderer_service_lookup_vtbl =
1712 {
1713     video_renderer_service_lookup_QueryInterface,
1714     video_renderer_service_lookup_AddRef,
1715     video_renderer_service_lookup_Release,
1716     video_renderer_service_lookup_LookupService,
1717 };
1718
1719 static HRESULT WINAPI video_renderer_event_sink_QueryInterface(IMediaEventSink *iface, REFIID riid, void **obj)
1720 {
1721     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1722
1723     if (IsEqualIID(riid, &IID_IMediaEventSink) ||
1724             IsEqualIID(riid, &IID_IUnknown))
1725     {
1726         *obj = iface;
1727         IMediaEventSink_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 video_renderer_event_sink_AddRef(IMediaEventSink *iface)
1737 {
1738     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
1739     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1740 }
1741
1742 static ULONG WINAPI video_renderer_event_sink_Release(IMediaEventSink *iface)
1743 {
1744     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
1745     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1746 }
1747
1748 static HRESULT WINAPI video_renderer_event_sink_Notify(IMediaEventSink *iface, LONG event, LONG_PTR param1, LONG_PTR param2)
1749 {
1750     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
1751     HRESULT hr = S_OK;
1752     unsigned int idx;
1753
1754     TRACE("%p, %d, %ld, %ld.\n", iface, event, param1, param2);
1755
1756     EnterCriticalSection(&renderer->cs);
1757
1758     if (event == EC_SAMPLE_NEEDED)
1759     {
1760         idx = param1;
1761         if (idx >= renderer->stream_count)
1762             hr = MF_E_INVALIDSTREAMNUMBER;
1763         else
1764         {
1765             hr = IMFMediaEventQueue_QueueEventParamVar(renderer->streams[idx]->event_queue,
1766                 MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
1767         }
1768     }
1769     else if (event >= EC_USER)
1770     {
1771         PROPVARIANT code;
1772
1773         code.vt = VT_I4;
1774         code.lVal = event;
1775         hr = IMFMediaEventQueue_QueueEventParamVar(renderer->event_queue, MERendererEvent,
1776                 &GUID_NULL, S_OK, &code);
1777     }
1778     else
1779     {
1780         WARN("Unhandled event %d.\n", event);
1781         hr = MF_E_UNEXPECTED;
1782     }
1783
1784     LeaveCriticalSection(&renderer->cs);
1785
1786     return hr;
1787 }
1788
1789 static const IMediaEventSinkVtbl media_event_sink_vtbl =
1790 {
1791     video_renderer_event_sink_QueryInterface,
1792     video_renderer_event_sink_AddRef,
1793     video_renderer_event_sink_Release,
1794     video_renderer_event_sink_Notify,
1795 };
1796
1797 static HRESULT WINAPI video_renderer_attributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **obj)
1798 {
1799     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1800     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1801 }
1802
1803 static ULONG WINAPI video_renderer_attributes_AddRef(IMFAttributes *iface)
1804 {
1805     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1806     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1807 }
1808
1809 static ULONG WINAPI video_renderer_attributes_Release(IMFAttributes *iface)
1810 {
1811     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1812     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1813 }
1814
1815 static HRESULT WINAPI video_renderer_attributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
1816 {
1817     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1818
1819     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1820
1821     return IMFAttributes_GetItem(renderer->attributes, key, value);
1822 }
1823
1824 static HRESULT WINAPI video_renderer_attributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
1825 {
1826     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1827
1828     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
1829
1830     return IMFAttributes_GetItemType(renderer->attributes, key, type);
1831 }
1832
1833 static HRESULT WINAPI video_renderer_attributes_CompareItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value,
1834         BOOL *result)
1835 {
1836     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1837
1838     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
1839
1840     return IMFAttributes_CompareItem(renderer->attributes, key, value, result);
1841 }
1842
1843 static HRESULT WINAPI video_renderer_attributes_Compare(IMFAttributes *iface, IMFAttributes *theirs,
1844         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
1845 {
1846     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1847
1848     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
1849
1850     return IMFAttributes_Compare(renderer->attributes, theirs, type, result);
1851 }
1852
1853 static HRESULT WINAPI video_renderer_attributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
1854 {
1855     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1856
1857     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1858
1859     return IMFAttributes_GetUINT32(renderer->attributes, key, value);
1860 }
1861
1862 static HRESULT WINAPI video_renderer_attributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
1863 {
1864     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1865
1866     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1867
1868     return IMFAttributes_GetUINT64(renderer->attributes, key, value);
1869 }
1870
1871 static HRESULT WINAPI video_renderer_attributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
1872 {
1873     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1874
1875     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1876
1877     return IMFAttributes_GetDouble(renderer->attributes, key, value);
1878 }
1879
1880 static HRESULT WINAPI video_renderer_attributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
1881 {
1882     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1883
1884     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1885
1886     return IMFAttributes_GetGUID(renderer->attributes, key, value);
1887 }
1888
1889 static HRESULT WINAPI video_renderer_attributes_GetStringLength(IMFAttributes *iface, REFGUID key,
1890         UINT32 *length)
1891 {
1892     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1893
1894     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
1895
1896     return IMFAttributes_GetStringLength(renderer->attributes, key, length);
1897 }
1898
1899 static HRESULT WINAPI video_renderer_attributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
1900         UINT32 size, UINT32 *length)
1901 {
1902     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1903
1904     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), value, size, length);
1905
1906     return IMFAttributes_GetString(renderer->attributes, key, value, size, length);
1907 }
1908
1909 static HRESULT WINAPI video_renderer_attributes_GetAllocatedString(IMFAttributes *iface, REFGUID key,
1910         WCHAR **value, UINT32 *length)
1911 {
1912     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1913
1914     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
1915
1916     return IMFAttributes_GetAllocatedString(renderer->attributes, key, value, length);
1917 }
1918
1919 static HRESULT WINAPI video_renderer_attributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
1920 {
1921     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1922
1923     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
1924
1925     return IMFAttributes_GetBlobSize(renderer->attributes, key, size);
1926 }
1927
1928 static HRESULT WINAPI video_renderer_attributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
1929          UINT32 bufsize, UINT32 *blobsize)
1930 {
1931     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1932
1933     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
1934
1935     return IMFAttributes_GetBlob(renderer->attributes, key, buf, bufsize, blobsize);
1936 }
1937
1938 static HRESULT WINAPI video_renderer_attributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key,
1939         UINT8 **buf, UINT32 *size)
1940 {
1941     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1942
1943     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
1944
1945     return IMFAttributes_GetAllocatedBlob(renderer->attributes, key, buf, size);
1946 }
1947
1948 static HRESULT WINAPI video_renderer_attributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **out)
1949 {
1950     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1951
1952     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), out);
1953
1954     return IMFAttributes_GetUnknown(renderer->attributes, key, riid, out);
1955 }
1956
1957 static HRESULT WINAPI video_renderer_attributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value)
1958 {
1959     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1960
1961     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1962
1963     return IMFAttributes_SetItem(renderer->attributes, key, value);
1964 }
1965
1966 static HRESULT WINAPI video_renderer_attributes_DeleteItem(IMFAttributes *iface, REFGUID key)
1967 {
1968     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1969
1970     TRACE("%p, %s.\n", iface, debugstr_guid(key));
1971
1972     return IMFAttributes_DeleteItem(renderer->attributes, key);
1973 }
1974
1975 static HRESULT WINAPI video_renderer_attributes_DeleteAllItems(IMFAttributes *iface)
1976 {
1977     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1978
1979     TRACE("%p.\n", iface);
1980
1981     return IMFAttributes_DeleteAllItems(renderer->attributes);
1982 }
1983
1984 static HRESULT WINAPI video_renderer_attributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
1985 {
1986     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1987
1988     TRACE("%p, %s, %u.\n", iface, debugstr_guid(key), value);
1989
1990     return IMFAttributes_SetUINT32(renderer->attributes, key, value);
1991 }
1992
1993 static HRESULT WINAPI video_renderer_attributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
1994 {
1995     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
1996
1997     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
1998
1999     return IMFAttributes_SetUINT64(renderer->attributes, key, value);
2000 }
2001
2002 static HRESULT WINAPI video_renderer_attributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
2003 {
2004     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2005
2006     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
2007
2008     return IMFAttributes_SetDouble(renderer->attributes, key, value);
2009 }
2010
2011 static HRESULT WINAPI video_renderer_attributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
2012 {
2013     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2014
2015     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
2016
2017     return IMFAttributes_SetGUID(renderer->attributes, key, value);
2018 }
2019
2020 static HRESULT WINAPI video_renderer_attributes_SetString(IMFAttributes *iface, REFGUID key,
2021         const WCHAR *value)
2022 {
2023     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2024
2025     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
2026
2027     return IMFAttributes_SetString(renderer->attributes, key, value);
2028 }
2029
2030 static HRESULT WINAPI video_renderer_attributes_SetBlob(IMFAttributes *iface, REFGUID key,
2031         const UINT8 *buf, UINT32 size)
2032 {
2033     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2034
2035     TRACE("%p, %s, %p, %u.\n", iface, debugstr_guid(key), buf, size);
2036
2037     return IMFAttributes_SetBlob(renderer->attributes, key, buf, size);
2038 }
2039
2040 static HRESULT WINAPI video_renderer_attributes_SetUnknown(IMFAttributes *iface, REFGUID key,
2041         IUnknown *unknown)
2042 {
2043     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2044
2045     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), unknown);
2046
2047     return IMFAttributes_SetUnknown(renderer->attributes, key, unknown);
2048 }
2049
2050 static HRESULT WINAPI video_renderer_attributes_LockStore(IMFAttributes *iface)
2051 {
2052     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2053
2054     TRACE("%p.\n", iface);
2055
2056     return IMFAttributes_LockStore(renderer->attributes);
2057 }
2058
2059 static HRESULT WINAPI video_renderer_attributes_UnlockStore(IMFAttributes *iface)
2060 {
2061     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2062
2063     TRACE("%p.\n", iface);
2064
2065     return IMFAttributes_UnlockStore(renderer->attributes);
2066 }
2067
2068 static HRESULT WINAPI video_renderer_attributes_GetCount(IMFAttributes *iface, UINT32 *count)
2069 {
2070     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2071
2072     TRACE("%p, %p.\n", iface, count);
2073
2074     return IMFAttributes_GetCount(renderer->attributes, count);
2075 }
2076
2077 static HRESULT WINAPI video_renderer_attributes_GetItemByIndex(IMFAttributes *iface, UINT32 index,
2078         GUID *key, PROPVARIANT *value)
2079 {
2080     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2081
2082     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
2083
2084     return IMFAttributes_GetItemByIndex(renderer->attributes, index, key, value);
2085 }
2086
2087 static HRESULT WINAPI video_renderer_attributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
2088 {
2089     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2090
2091     TRACE("%p, %p.\n", iface, dest);
2092
2093     return IMFAttributes_CopyAllItems(renderer->attributes, dest);
2094 }
2095
2096 static const IMFAttributesVtbl video_renderer_attributes_vtbl =
2097 {
2098     video_renderer_attributes_QueryInterface,
2099     video_renderer_attributes_AddRef,
2100     video_renderer_attributes_Release,
2101     video_renderer_attributes_GetItem,
2102     video_renderer_attributes_GetItemType,
2103     video_renderer_attributes_CompareItem,
2104     video_renderer_attributes_Compare,
2105     video_renderer_attributes_GetUINT32,
2106     video_renderer_attributes_GetUINT64,
2107     video_renderer_attributes_GetDouble,
2108     video_renderer_attributes_GetGUID,
2109     video_renderer_attributes_GetStringLength,
2110     video_renderer_attributes_GetString,
2111     video_renderer_attributes_GetAllocatedString,
2112     video_renderer_attributes_GetBlobSize,
2113     video_renderer_attributes_GetBlob,
2114     video_renderer_attributes_GetAllocatedBlob,
2115     video_renderer_attributes_GetUnknown,
2116     video_renderer_attributes_SetItem,
2117     video_renderer_attributes_DeleteItem,
2118     video_renderer_attributes_DeleteAllItems,
2119     video_renderer_attributes_SetUINT32,
2120     video_renderer_attributes_SetUINT64,
2121     video_renderer_attributes_SetDouble,
2122     video_renderer_attributes_SetGUID,
2123     video_renderer_attributes_SetString,
2124     video_renderer_attributes_SetBlob,
2125     video_renderer_attributes_SetUnknown,
2126     video_renderer_attributes_LockStore,
2127     video_renderer_attributes_UnlockStore,
2128     video_renderer_attributes_GetCount,
2129     video_renderer_attributes_GetItemByIndex,
2130     video_renderer_attributes_CopyAllItems,
2131 };
2132
2133 static HRESULT WINAPI video_renderer_quality_advise_QueryInterface(IMFQualityAdvise *iface, REFIID riid, void **out)
2134 {
2135     struct video_renderer *renderer = impl_from_IMFQualityAdvise(iface);
2136     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, out);
2137 }
2138
2139 static ULONG WINAPI video_renderer_quality_advise_AddRef(IMFQualityAdvise *iface)
2140 {
2141     struct video_renderer *renderer = impl_from_IMFQualityAdvise(iface);
2142     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2143 }
2144
2145 static ULONG WINAPI video_renderer_quality_Release(IMFQualityAdvise *iface)
2146 {
2147     struct video_renderer *renderer = impl_from_IMFQualityAdvise(iface);
2148     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2149 }
2150
2151 static HRESULT WINAPI video_renderer_quality_advise_SetDropMode(IMFQualityAdvise *iface,
2152         MF_QUALITY_DROP_MODE mode)
2153 {
2154     FIXME("%p, %u.\n", iface, mode);
2155
2156     return E_NOTIMPL;
2157 }
2158
2159 static HRESULT WINAPI video_renderer_quality_advise_SetQualityLevel(IMFQualityAdvise *iface,
2160         MF_QUALITY_LEVEL level)
2161 {
2162     FIXME("%p, %u.\n", iface, level);
2163
2164     return E_NOTIMPL;
2165 }
2166
2167 static HRESULT WINAPI video_renderer_quality_advise_GetDropMode(IMFQualityAdvise *iface,
2168         MF_QUALITY_DROP_MODE *mode)
2169 {
2170     FIXME("%p, %p.\n", iface, mode);
2171
2172     return E_NOTIMPL;
2173 }
2174
2175 static HRESULT WINAPI video_renderer_quality_advise_GetQualityLevel(IMFQualityAdvise *iface,
2176         MF_QUALITY_LEVEL *level)
2177 {
2178     FIXME("%p, %p.\n", iface, level);
2179
2180     return E_NOTIMPL;
2181 }
2182
2183 static HRESULT WINAPI video_renderer_quality_advise_DropTime(IMFQualityAdvise *iface, LONGLONG interval)
2184 {
2185     FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(interval));
2186
2187     return E_NOTIMPL;
2188 }
2189
2190 static const IMFQualityAdviseVtbl video_renderer_quality_advise_vtbl =
2191 {
2192     video_renderer_quality_advise_QueryInterface,
2193     video_renderer_quality_advise_AddRef,
2194     video_renderer_quality_Release,
2195     video_renderer_quality_advise_SetDropMode,
2196     video_renderer_quality_advise_SetQualityLevel,
2197     video_renderer_quality_advise_GetDropMode,
2198     video_renderer_quality_advise_GetQualityLevel,
2199     video_renderer_quality_advise_DropTime,
2200 };
2201
2202 static HRESULT evr_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj)
2203 {
2204     struct video_renderer *object;
2205     IMFVideoPresenter *presenter = NULL;
2206     IMFTransform *mixer = NULL;
2207     HRESULT hr;
2208
2209     TRACE("%p, %p, %p.\n", attributes, user_context, obj);
2210
2211     if (!(object = heap_alloc_zero(sizeof(*object))))
2212         return E_OUTOFMEMORY;
2213
2214     object->IMFMediaSink_iface.lpVtbl = &video_renderer_sink_vtbl;
2215     object->IMFMediaSinkPreroll_iface.lpVtbl = &video_renderer_preroll_vtbl;
2216     object->IMFVideoRenderer_iface.lpVtbl = &video_renderer_vtbl;
2217     object->IMFMediaEventGenerator_iface.lpVtbl = &video_renderer_events_vtbl;
2218     object->IMFClockStateSink_iface.lpVtbl = &video_renderer_clock_sink_vtbl;
2219     object->IMFGetService_iface.lpVtbl = &video_renderer_get_service_vtbl;
2220     object->IMFTopologyServiceLookup_iface.lpVtbl = &video_renderer_service_lookup_vtbl;
2221     object->IMediaEventSink_iface.lpVtbl = &media_event_sink_vtbl;
2222     object->IMFAttributes_iface.lpVtbl = &video_renderer_attributes_vtbl;
2223     object->IMFQualityAdvise_iface.lpVtbl = &video_renderer_quality_advise_vtbl;
2224     object->refcount = 1;
2225     InitializeCriticalSection(&object->cs);
2226
2227     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
2228         goto failed;
2229
2230     if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
2231         goto failed;
2232
2233     /* Create mixer and presenter. */
2234     if (FAILED(hr = video_renderer_create_mixer(attributes, &mixer)))
2235         goto failed;
2236
2237     if (FAILED(hr = video_renderer_create_presenter(object, attributes, &presenter)))
2238         goto failed;
2239
2240     if (FAILED(hr = video_renderer_initialize(object, mixer, presenter)))
2241         goto failed;
2242
2243     IMFTransform_Release(mixer);
2244     IMFVideoPresenter_Release(presenter);
2245
2246     /* Default attributes */
2247     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceBob, 0);
2248     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowDropToBob, 0);
2249     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceThrottle, 0);
2250     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowDropToThrottle, 0);
2251     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceHalfInterlace, 0);
2252     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowDropToHalfInterlace, 0);
2253     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceScaling, 0);
2254     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowScaling, 0);
2255     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceBatching, 0);
2256     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowBatching, 0);
2257
2258     *obj = (IUnknown *)&object->IMFMediaSink_iface;
2259
2260     return S_OK;
2261
2262 failed:
2263
2264     if (mixer)
2265         IMFTransform_Release(mixer);
2266
2267     if (presenter)
2268         IMFVideoPresenter_Release(presenter);
2269
2270     video_renderer_release_services(object);
2271     IMFMediaSink_Release(&object->IMFMediaSink_iface);
2272
2273     return hr;
2274 }
2275
2276 static void evr_shutdown_object(void *user_context, IUnknown *obj)
2277 {
2278     IMFMediaSink *sink;
2279
2280     if (SUCCEEDED(IUnknown_QueryInterface(obj, &IID_IMFMediaSink, (void **)&sink)))
2281     {
2282         IMFMediaSink_Shutdown(sink);
2283         IMFMediaSink_Release(sink);
2284     }
2285 }
2286
2287 static const struct activate_funcs evr_activate_funcs =
2288 {
2289     .create_object = evr_create_object,
2290     .shutdown_object = evr_shutdown_object,
2291 };
2292
2293 /***********************************************************************
2294  *      MFCreateVideoRendererActivate (mf.@)
2295  */
2296 HRESULT WINAPI MFCreateVideoRendererActivate(HWND hwnd, IMFActivate **activate)
2297 {
2298     HRESULT hr;
2299
2300     TRACE("%p, %p.\n", hwnd, activate);
2301
2302     if (!activate)
2303         return E_POINTER;
2304
2305     hr = create_activation_object(NULL, &evr_activate_funcs, activate);
2306     if (SUCCEEDED(hr))
2307         IMFActivate_SetUINT64(*activate, &MF_ACTIVATE_VIDEO_WINDOW, (ULONG_PTR)hwnd);
2308
2309     return hr;
2310 }
2311
2312 /***********************************************************************
2313  *      MFCreateVideoRenderer (mf.@)
2314  */
2315 HRESULT WINAPI MFCreateVideoRenderer(REFIID riid, void **renderer)
2316 {
2317     IUnknown *obj;
2318     HRESULT hr;
2319
2320     TRACE("%s, %p.\n", debugstr_guid(riid), renderer);
2321
2322     *renderer = NULL;
2323
2324     if (SUCCEEDED(hr = evr_create_object(NULL, NULL, &obj)))
2325     {
2326         hr = IUnknown_QueryInterface(obj, riid, renderer);
2327         IUnknown_Release(obj);
2328     }
2329
2330     return hr;
2331 }