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
  25 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  26
  27 enum video_renderer_flags
  28 {
  29     EVR_SHUT_DOWN = 0x1,
  30     EVR_INIT_SERVICES = 0x2, /* Currently in InitServices() call. */
  31     EVR_MIXER_INITED_SERVICES = 0x4,
  32     EVR_PRESENTER_INITED_SERVICES = 0x8,
  33 };
  34
  35 struct video_renderer
  36 {
  37     IMFMediaSink IMFMediaSink_iface;
  38     IMFMediaSinkPreroll IMFMediaSinkPreroll_iface;
  39     IMFVideoRenderer IMFVideoRenderer_iface;
  40     IMFClockStateSink IMFClockStateSink_iface;
  41     IMFMediaEventGenerator IMFMediaEventGenerator_iface;
  42     IMFGetService IMFGetService_iface;
  43     IMFTopologyServiceLookup IMFTopologyServiceLookup_iface;
  44     IMediaEventSink IMediaEventSink_iface;
  45     LONG refcount;
  46
  47     IMFMediaEventQueue *event_queue;
  48     IMFPresentationClock *clock;
  49
  50     IMFTransform *mixer;
  51     IMFVideoPresenter *presenter;
  52     unsigned int flags;
  53     CRITICAL_SECTION cs;
  54 };
  55
  56 static struct video_renderer *impl_from_IMFMediaSink(IMFMediaSink *iface)
  57 {
  58     return CONTAINING_RECORD(iface, struct video_renderer, IMFMediaSink_iface);
  59 }
  60
  61 static struct video_renderer *impl_from_IMFMediaSinkPreroll(IMFMediaSinkPreroll *iface)
  62 {
  63     return CONTAINING_RECORD(iface, struct video_renderer, IMFMediaSinkPreroll_iface);
  64 }
  65
  66 static struct video_renderer *impl_from_IMFVideoRenderer(IMFVideoRenderer *iface)
  67 {
  68     return CONTAINING_RECORD(iface, struct video_renderer, IMFVideoRenderer_iface);
  69 }
  70
  71 static struct video_renderer *impl_from_IMFMediaEventGenerator(IMFMediaEventGenerator *iface)
  72 {
  73     return CONTAINING_RECORD(iface, struct video_renderer, IMFMediaEventGenerator_iface);
  74 }
  75
  76 static struct video_renderer *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
  77 {
  78     return CONTAINING_RECORD(iface, struct video_renderer, IMFClockStateSink_iface);
  79 }
  80
  81 static struct video_renderer *impl_from_IMFGetService(IMFGetService *iface)
  82 {
  83     return CONTAINING_RECORD(iface, struct video_renderer, IMFGetService_iface);
  84 }
  85
  86 static struct video_renderer *impl_from_IMFTopologyServiceLookup(IMFTopologyServiceLookup *iface)
  87 {
  88     return CONTAINING_RECORD(iface, struct video_renderer, IMFTopologyServiceLookup_iface);
  89 }
  90
  91 static struct video_renderer *impl_from_IMediaEventSink(IMediaEventSink *iface)
  92 {
  93     return CONTAINING_RECORD(iface, struct video_renderer, IMediaEventSink_iface);
  94 }
  95
  96 static void video_renderer_release_services(struct video_renderer *renderer)
  97 {
  98     IMFTopologyServiceLookupClient *lookup_client;
  99
 100     if (renderer->flags & EVR_MIXER_INITED_SERVICES && SUCCEEDED(IMFTransform_QueryInterface(renderer->mixer,
 101             &IID_IMFTopologyServiceLookupClient, (void **)&lookup_client)))
 102     {
 103         IMFTopologyServiceLookupClient_ReleaseServicePointers(lookup_client);
 104         IMFTopologyServiceLookupClient_Release(lookup_client);
 105         renderer->flags &= ~EVR_MIXER_INITED_SERVICES;
 106     }
 107
 108     if (renderer->flags & EVR_PRESENTER_INITED_SERVICES && SUCCEEDED(IMFVideoPresenter_QueryInterface(renderer->presenter,
 109             &IID_IMFTopologyServiceLookupClient, (void **)&lookup_client)))
 110     {
 111         IMFTopologyServiceLookupClient_ReleaseServicePointers(lookup_client);
 112         IMFTopologyServiceLookupClient_Release(lookup_client);
 113         renderer->flags &= ~EVR_PRESENTER_INITED_SERVICES;
 114     }
 115 }
 116
 117 static HRESULT WINAPI video_renderer_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj)
 118 {
 119     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 120
 121     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 122
 123     if (IsEqualIID(riid, &IID_IMFMediaSink) ||
 124             IsEqualIID(riid, &IID_IUnknown))
 125     {
 126         *obj = &renderer->IMFMediaSink_iface;
 127     }
 128     else if (IsEqualIID(riid, &IID_IMFMediaSinkPreroll))
 129     {
 130         *obj = &renderer->IMFMediaSinkPreroll_iface;
 131     }
 132     else if (IsEqualIID(riid, &IID_IMFVideoRenderer))
 133     {
 134         *obj = &renderer->IMFVideoRenderer_iface;
 135     }
 136     else if (IsEqualIID(riid, &IID_IMFMediaEventGenerator))
 137     {
 138         *obj = &renderer->IMFMediaEventGenerator_iface;
 139     }
 140     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
 141     {
 142         *obj = &renderer->IMFClockStateSink_iface;
 143     }
 144     else if (IsEqualIID(riid, &IID_IMFGetService))
 145     {
 146         *obj = &renderer->IMFGetService_iface;
 147     }
 148     else
 149     {
 150         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 151         *obj = NULL;
 152         return E_NOINTERFACE;
 153     }
 154
 155     IUnknown_AddRef((IUnknown *)*obj);
 156
 157     return S_OK;
 158 }
 159
 160 static ULONG WINAPI video_renderer_sink_AddRef(IMFMediaSink *iface)
 161 {
 162     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 163     ULONG refcount = InterlockedIncrement(&renderer->refcount);
 164     TRACE("%p, refcount %u.\n", iface, refcount);
 165     return refcount;
 166 }
 167
 168 static ULONG WINAPI video_renderer_sink_Release(IMFMediaSink *iface)
 169 {
 170     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 171     ULONG refcount = InterlockedDecrement(&renderer->refcount);
 172
 173     TRACE("%p, refcount %u.\n", iface, refcount);
 174
 175     if (!refcount)
 176     {
 177         if (renderer->event_queue)
 178             IMFMediaEventQueue_Release(renderer->event_queue);
 179         if (renderer->mixer)
 180             IMFTransform_Release(renderer->mixer);
 181         if (renderer->presenter)
 182             IMFVideoPresenter_Release(renderer->presenter);
 183         if (renderer->clock)
 184             IMFPresentationClock_Release(renderer->clock);
 185         DeleteCriticalSection(&renderer->cs);
 186         heap_free(renderer);
 187     }
 188
 189     return refcount;
 190 }
 191
 192 static HRESULT WINAPI video_renderer_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags)
 193 {
 194     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 195
 196     TRACE("%p, %p.\n", iface, flags);
 197
 198     if (renderer->flags & EVR_SHUT_DOWN)
 199         return MF_E_SHUTDOWN;
 200
 201     *flags = MEDIASINK_CLOCK_REQUIRED | MEDIASINK_CAN_PREROLL;
 202
 203     return S_OK;
 204 }
 205
 206 static HRESULT WINAPI video_renderer_sink_AddStreamSink(IMFMediaSink *iface, DWORD stream_sink_id,
 207     IMFMediaType *media_type, IMFStreamSink **stream_sink)
 208 {
 209     FIXME("%p, %#x, %p, %p.\n", iface, stream_sink_id, media_type, stream_sink);
 210
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI video_renderer_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id)
 215 {
 216     FIXME("%p, %#x.\n", iface, stream_sink_id);
 217
 218     return E_NOTIMPL;
 219 }
 220
 221 static HRESULT WINAPI video_renderer_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
 222 {
 223     FIXME("%p, %p.\n", iface, count);
 224
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI video_renderer_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index,
 229         IMFStreamSink **stream)
 230 {
 231     FIXME("%p, %u, %p.\n", iface, index, stream);
 232
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI video_renderer_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id,
 237         IMFStreamSink **stream)
 238 {
 239     FIXME("%p, %#x, %p.\n", iface, stream_sink_id, stream);
 240
 241     return E_NOTIMPL;
 242 }
 243
 244 static void video_renderer_set_presentation_clock(struct video_renderer *renderer, IMFPresentationClock *clock)
 245 {
 246     if (renderer->clock)
 247     {
 248         IMFPresentationClock_RemoveClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
 249         IMFPresentationClock_Release(renderer->clock);
 250     }
 251     renderer->clock = clock;
 252     if (renderer->clock)
 253     {
 254         IMFPresentationClock_AddRef(renderer->clock);
 255         IMFPresentationClock_AddClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
 256     }
 257 }
 258
 259 static HRESULT WINAPI video_renderer_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
 260 {
 261     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 262     HRESULT hr = S_OK;
 263
 264     TRACE("%p, %p.\n", iface, clock);
 265
 266     EnterCriticalSection(&renderer->cs);
 267
 268     if (renderer->flags & EVR_SHUT_DOWN)
 269         hr = MF_E_SHUTDOWN;
 270     else
 271         video_renderer_set_presentation_clock(renderer, clock);
 272
 273     LeaveCriticalSection(&renderer->cs);
 274
 275     return hr;
 276 }
 277
 278 static HRESULT WINAPI video_renderer_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
 279 {
 280     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 281     HRESULT hr = S_OK;
 282
 283     TRACE("%p, %p.\n", iface, clock);
 284
 285     if (!clock)
 286         return E_POINTER;
 287
 288     EnterCriticalSection(&renderer->cs);
 289
 290     if (renderer->flags & EVR_SHUT_DOWN)
 291         hr = MF_E_SHUTDOWN;
 292     else if (renderer->clock)
 293     {
 294         *clock = renderer->clock;
 295         IMFPresentationClock_AddRef(*clock);
 296     }
 297     else
 298         hr = MF_E_NO_CLOCK;
 299
 300     LeaveCriticalSection(&renderer->cs);
 301
 302     return hr;
 303 }
 304
 305 static HRESULT WINAPI video_renderer_sink_Shutdown(IMFMediaSink *iface)
 306 {
 307     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
 308
 309     TRACE("%p.\n", iface);
 310
 311     if (renderer->flags & EVR_SHUT_DOWN)
 312         return MF_E_SHUTDOWN;
 313
 314     EnterCriticalSection(&renderer->cs);
 315     renderer->flags |= EVR_SHUT_DOWN;
 316     IMFMediaEventQueue_Shutdown(renderer->event_queue);
 317     video_renderer_set_presentation_clock(renderer, NULL);
 318     video_renderer_release_services(renderer);
 319     LeaveCriticalSection(&renderer->cs);
 320
 321     return S_OK;
 322 }
 323
 324 static const IMFMediaSinkVtbl video_renderer_sink_vtbl =
 325 {
 326     video_renderer_sink_QueryInterface,
 327     video_renderer_sink_AddRef,
 328     video_renderer_sink_Release,
 329     video_renderer_sink_GetCharacteristics,
 330     video_renderer_sink_AddStreamSink,
 331     video_renderer_sink_RemoveStreamSink,
 332     video_renderer_sink_GetStreamSinkCount,
 333     video_renderer_sink_GetStreamSinkByIndex,
 334     video_renderer_sink_GetStreamSinkById,
 335     video_renderer_sink_SetPresentationClock,
 336     video_renderer_sink_GetPresentationClock,
 337     video_renderer_sink_Shutdown,
 338 };
 339
 340 static HRESULT WINAPI video_renderer_preroll_QueryInterface(IMFMediaSinkPreroll *iface, REFIID riid, void **obj)
 341 {
 342     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 343     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 344 }
 345
 346 static ULONG WINAPI video_renderer_preroll_AddRef(IMFMediaSinkPreroll *iface)
 347 {
 348     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 349     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 350 }
 351
 352 static ULONG WINAPI video_renderer_preroll_Release(IMFMediaSinkPreroll *iface)
 353 {
 354     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
 355     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 356 }
 357
 358 static HRESULT WINAPI video_renderer_preroll_NotifyPreroll(IMFMediaSinkPreroll *iface, MFTIME start_time)
 359 {
 360     FIXME("%p, %s.\n", iface, debugstr_time(start_time));
 361
 362     return E_NOTIMPL;
 363 }
 364
 365 static const IMFMediaSinkPrerollVtbl video_renderer_preroll_vtbl =
 366 {
 367     video_renderer_preroll_QueryInterface,
 368     video_renderer_preroll_AddRef,
 369     video_renderer_preroll_Release,
 370     video_renderer_preroll_NotifyPreroll,
 371 };
 372
 373 static HRESULT WINAPI video_renderer_QueryInterface(IMFVideoRenderer *iface, REFIID riid, void **obj)
 374 {
 375     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
 376     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 377 }
 378
 379 static ULONG WINAPI video_renderer_AddRef(IMFVideoRenderer *iface)
 380 {
 381     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
 382     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 383 }
 384
 385 static ULONG WINAPI video_renderer_Release(IMFVideoRenderer *iface)
 386 {
 387     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
 388     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 389 }
 390
 391 static HRESULT WINAPI video_renderer_InitializeRenderer(IMFVideoRenderer *iface, IMFTransform *mixer,
 392         IMFVideoPresenter *presenter)
 393 {
 394     FIXME("%p, %p, %p.\n", iface, mixer, presenter);
 395
 396     return E_NOTIMPL;
 397 }
 398
 399 static const IMFVideoRendererVtbl video_renderer_vtbl =
 400 {
 401     video_renderer_QueryInterface,
 402     video_renderer_AddRef,
 403     video_renderer_Release,
 404     video_renderer_InitializeRenderer,
 405 };
 406
 407 static HRESULT WINAPI video_renderer_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
 408 {
 409     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 410     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 411 }
 412
 413 static ULONG WINAPI video_renderer_events_AddRef(IMFMediaEventGenerator *iface)
 414 {
 415     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 416     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 417 }
 418
 419 static ULONG WINAPI video_renderer_events_Release(IMFMediaEventGenerator *iface)
 420 {
 421     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 422     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 423 }
 424
 425 static HRESULT WINAPI video_renderer_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
 426 {
 427     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 428
 429     TRACE("%p, %#x, %p.\n", iface, flags, event);
 430
 431     return IMFMediaEventQueue_GetEvent(renderer->event_queue, flags, event);
 432 }
 433
 434 static HRESULT WINAPI video_renderer_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
 435         IUnknown *state)
 436 {
 437     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 438
 439     TRACE("%p, %p, %p.\n", iface, callback, state);
 440
 441     return IMFMediaEventQueue_BeginGetEvent(renderer->event_queue, callback, state);
 442 }
 443
 444 static HRESULT WINAPI video_renderer_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
 445         IMFMediaEvent **event)
 446 {
 447     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 448
 449     TRACE("%p, %p, %p.\n", iface, result, event);
 450
 451     return IMFMediaEventQueue_EndGetEvent(renderer->event_queue, result, event);
 452 }
 453
 454 static HRESULT WINAPI video_renderer_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
 455         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 456 {
 457     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
 458
 459     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
 460
 461     return IMFMediaEventQueue_QueueEventParamVar(renderer->event_queue, event_type, ext_type, hr, value);
 462 }
 463
 464 static const IMFMediaEventGeneratorVtbl video_renderer_events_vtbl =
 465 {
 466     video_renderer_events_QueryInterface,
 467     video_renderer_events_AddRef,
 468     video_renderer_events_Release,
 469     video_renderer_events_GetEvent,
 470     video_renderer_events_BeginGetEvent,
 471     video_renderer_events_EndGetEvent,
 472     video_renderer_events_QueueEvent,
 473 };
 474
 475 static HRESULT WINAPI video_renderer_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
 476 {
 477     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
 478     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 479 }
 480
 481 static ULONG WINAPI video_renderer_clock_sink_AddRef(IMFClockStateSink *iface)
 482 {
 483     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
 484     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 485 }
 486
 487 static ULONG WINAPI video_renderer_clock_sink_Release(IMFClockStateSink *iface)
 488 {
 489     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
 490     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 491 }
 492
 493 static HRESULT WINAPI video_renderer_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
 494 {
 495     FIXME("%p, %s, %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
 496
 497     return E_NOTIMPL;
 498 }
 499
 500 static HRESULT WINAPI video_renderer_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
 501 {
 502     FIXME("%p, %s.\n", iface, debugstr_time(systime));
 503
 504     return E_NOTIMPL;
 505 }
 506
 507 static HRESULT WINAPI video_renderer_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
 508 {
 509     FIXME("%p, %s.\n", iface, debugstr_time(systime));
 510
 511     return E_NOTIMPL;
 512 }
 513
 514 static HRESULT WINAPI video_renderer_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
 515 {
 516     FIXME("%p, %s.\n", iface, debugstr_time(systime));
 517
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT WINAPI video_renderer_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
 522 {
 523     FIXME("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
 524
 525     return E_NOTIMPL;
 526 }
 527
 528 static const IMFClockStateSinkVtbl video_renderer_clock_sink_vtbl =
 529 {
 530     video_renderer_clock_sink_QueryInterface,
 531     video_renderer_clock_sink_AddRef,
 532     video_renderer_clock_sink_Release,
 533     video_renderer_clock_sink_OnClockStart,
 534     video_renderer_clock_sink_OnClockStop,
 535     video_renderer_clock_sink_OnClockPause,
 536     video_renderer_clock_sink_OnClockRestart,
 537     video_renderer_clock_sink_OnClockSetRate,
 538 };
 539
 540 static HRESULT WINAPI video_renderer_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
 541 {
 542     struct video_renderer *renderer = impl_from_IMFGetService(iface);
 543     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
 544 }
 545
 546 static ULONG WINAPI video_renderer_get_service_AddRef(IMFGetService *iface)
 547 {
 548     struct video_renderer *renderer = impl_from_IMFGetService(iface);
 549     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 550 }
 551
 552 static ULONG WINAPI video_renderer_get_service_Release(IMFGetService *iface)
 553 {
 554     struct video_renderer *renderer = impl_from_IMFGetService(iface);
 555     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 556 }
 557
 558 static HRESULT WINAPI video_renderer_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 559 {
 560     struct video_renderer *renderer = impl_from_IMFGetService(iface);
 561     HRESULT hr = E_NOINTERFACE;
 562     IMFGetService *gs = NULL;
 563
 564     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 565
 566     if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE))
 567     {
 568         hr = IMFTransform_QueryInterface(renderer->mixer, &IID_IMFGetService, (void **)&gs);
 569     }
 570     else if (IsEqualGUID(service, &MR_VIDEO_RENDER_SERVICE))
 571     {
 572         hr = IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFGetService, (void **)&gs);
 573     }
 574     else
 575     {
 576         FIXME("Unsupported service %s.\n", debugstr_guid(service));
 577     }
 578
 579     if (gs)
 580     {
 581         hr = IMFGetService_GetService(gs, service, riid, obj);
 582         IMFGetService_Release(gs);
 583     }
 584
 585     return hr;
 586 }
 587
 588 static const IMFGetServiceVtbl video_renderer_get_service_vtbl =
 589 {
 590     video_renderer_get_service_QueryInterface,
 591     video_renderer_get_service_AddRef,
 592     video_renderer_get_service_Release,
 593     video_renderer_get_service_GetService,
 594 };
 595
 596 static HRESULT WINAPI video_renderer_service_lookup_QueryInterface(IMFTopologyServiceLookup *iface, REFIID riid, void **obj)
 597 {
 598     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 599
 600     if (IsEqualIID(riid, &IID_IMFTopologyServiceLookup) ||
 601             IsEqualIID(riid, &IID_IUnknown))
 602     {
 603         *obj = iface;
 604         IMFTopologyServiceLookup_AddRef(iface);
 605         return S_OK;
 606     }
 607
 608     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 609     *obj = NULL;
 610     return E_NOINTERFACE;
 611 }
 612
 613 static ULONG WINAPI video_renderer_service_lookup_AddRef(IMFTopologyServiceLookup *iface)
 614 {
 615     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
 616     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 617 }
 618
 619 static ULONG WINAPI video_renderer_service_lookup_Release(IMFTopologyServiceLookup *iface)
 620 {
 621     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
 622     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 623 }
 624
 625 static HRESULT WINAPI video_renderer_service_lookup_LookupService(IMFTopologyServiceLookup *iface,
 626         MF_SERVICE_LOOKUP_TYPE lookup_type, DWORD index, REFGUID service, REFIID riid,
 627         void **objects, DWORD *num_objects)
 628 {
 629     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
 630     HRESULT hr = S_OK;
 631
 632     TRACE("%p, %u, %u, %s, %s, %p, %p.\n", iface, lookup_type, index, debugstr_guid(service), debugstr_guid(riid),
 633             objects, num_objects);
 634
 635     EnterCriticalSection(&renderer->cs);
 636
 637     if (!(renderer->flags & EVR_INIT_SERVICES))
 638         hr = MF_E_NOTACCEPTING;
 639     else if (IsEqualGUID(service, &MR_VIDEO_RENDER_SERVICE))
 640     {
 641         if (IsEqualIID(riid, &IID_IMediaEventSink))
 642         {
 643             *objects = &renderer->IMediaEventSink_iface;
 644             IUnknown_AddRef((IUnknown *)*objects);
 645         }
 646         else
 647         {
 648             FIXME("Unsupported interface %s for render service.\n", debugstr_guid(riid));
 649             hr = E_NOINTERFACE;
 650         }
 651     }
 652     else if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE))
 653     {
 654         if (IsEqualIID(riid, &IID_IMFTransform))
 655         {
 656             *objects = renderer->mixer;
 657             IUnknown_AddRef((IUnknown *)*objects);
 658         }
 659         else
 660         {
 661             FIXME("Unsupported interface %s for mixer service.\n", debugstr_guid(riid));
 662             hr = E_NOINTERFACE;
 663         }
 664     }
 665     else
 666     {
 667         WARN("Unsupported service %s.\n", debugstr_guid(service));
 668         hr = MF_E_UNSUPPORTED_SERVICE;
 669     }
 670
 671     LeaveCriticalSection(&renderer->cs);
 672
 673     return hr;
 674 }
 675
 676 static const IMFTopologyServiceLookupVtbl video_renderer_service_lookup_vtbl =
 677 {
 678     video_renderer_service_lookup_QueryInterface,
 679     video_renderer_service_lookup_AddRef,
 680     video_renderer_service_lookup_Release,
 681     video_renderer_service_lookup_LookupService,
 682 };
 683
 684 static HRESULT WINAPI video_renderer_event_sink_QueryInterface(IMediaEventSink *iface, REFIID riid, void **obj)
 685 {
 686     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 687
 688     if (IsEqualIID(riid, &IID_IMediaEventSink) ||
 689             IsEqualIID(riid, &IID_IUnknown))
 690     {
 691         *obj = iface;
 692         IMediaEventSink_AddRef(iface);
 693         return S_OK;
 694     }
 695
 696     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 697     *obj = NULL;
 698     return E_NOINTERFACE;
 699 }
 700
 701 static ULONG WINAPI video_renderer_event_sink_AddRef(IMediaEventSink *iface)
 702 {
 703     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
 704     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
 705 }
 706
 707 static ULONG WINAPI video_renderer_event_sink_Release(IMediaEventSink *iface)
 708 {
 709     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
 710     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
 711 }
 712
 713 static HRESULT WINAPI video_renderer_event_sink_Notify(IMediaEventSink *iface, LONG event, LONG_PTR param1, LONG_PTR param2)
 714 {
 715     FIXME("%p, %d, %ld, %ld.\n", iface, event, param1, param2);
 716
 717     return E_NOTIMPL;
 718 }
 719
 720 static const IMediaEventSinkVtbl media_event_sink_vtbl =
 721 {
 722     video_renderer_event_sink_QueryInterface,
 723     video_renderer_event_sink_AddRef,
 724     video_renderer_event_sink_Release,
 725     video_renderer_event_sink_Notify,
 726 };
 727
 728 static HRESULT video_renderer_create_mixer(struct video_renderer *renderer, IMFAttributes *attributes,
 729         IMFTransform **out)
 730 {
 731     IMFTopologyServiceLookupClient *lookup_client;
 732     unsigned int flags = 0;
 733     IMFActivate *activate;
 734     CLSID clsid;
 735     HRESULT hr;
 736
 737     if (SUCCEEDED(IMFAttributes_GetUnknown(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_ACTIVATE,
 738             &IID_IMFActivate, (void **)&activate)))
 739     {
 740         IMFAttributes_GetUINT32(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_FLAGS, &flags);
 741         hr = IMFActivate_ActivateObject(activate, &IID_IMFTransform, (void **)out);
 742         IMFActivate_Release(activate);
 743         if (FAILED(hr) && !(flags & MF_ACTIVATE_CUSTOM_MIXER_ALLOWFAIL))
 744             return hr;
 745     }
 746
 747     if (FAILED(IMFAttributes_GetGUID(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_CLSID, &clsid)))
 748         memcpy(&clsid, &CLSID_MFVideoMixer9, sizeof(clsid));
 749
 750     if (SUCCEEDED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTransform, (void **)out)))
 751     {
 752         if (SUCCEEDED(hr = IMFTransform_QueryInterface(*out, &IID_IMFTopologyServiceLookupClient,
 753                 (void **)&lookup_client)))
 754         {
 755             renderer->flags |= EVR_INIT_SERVICES;
 756             if (SUCCEEDED(hr = IMFTopologyServiceLookupClient_InitServicePointers(lookup_client,
 757                     &renderer->IMFTopologyServiceLookup_iface)))
 758             {
 759                 renderer->flags |= EVR_MIXER_INITED_SERVICES;
 760             }
 761             renderer->flags &= ~EVR_INIT_SERVICES;
 762             IMFTopologyServiceLookupClient_Release(lookup_client);
 763         }
 764     }
 765
 766     return hr;
 767 }
 768
 769 static HRESULT video_renderer_create_presenter(struct video_renderer *renderer, IMFAttributes *attributes,
 770         IMFVideoPresenter **out)
 771 {
 772     IMFTopologyServiceLookupClient *lookup_client;
 773     unsigned int flags = 0;
 774     IMFActivate *activate;
 775     CLSID clsid;
 776     HRESULT hr;
 777
 778     if (SUCCEEDED(IMFAttributes_GetUnknown(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE,
 779             &IID_IMFActivate, (void **)&activate)))
 780     {
 781         IMFAttributes_GetUINT32(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_FLAGS, &flags);
 782         hr = IMFActivate_ActivateObject(activate, &IID_IMFVideoPresenter, (void **)out);
 783         IMFActivate_Release(activate);
 784         if (FAILED(hr) && !(flags & MF_ACTIVATE_CUSTOM_PRESENTER_ALLOWFAIL))
 785             return hr;
 786     }
 787
 788     if (FAILED(IMFAttributes_GetGUID(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID, &clsid)))
 789         memcpy(&clsid, &CLSID_MFVideoPresenter9, sizeof(clsid));
 790
 791     if (SUCCEEDED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFVideoPresenter, (void **)out)))
 792     {
 793         if (SUCCEEDED(hr = IMFVideoPresenter_QueryInterface(*out, &IID_IMFTopologyServiceLookupClient,
 794                 (void **)&lookup_client)))
 795         {
 796             renderer->flags |= EVR_INIT_SERVICES;
 797             if (SUCCEEDED(hr = IMFTopologyServiceLookupClient_InitServicePointers(lookup_client,
 798                     &renderer->IMFTopologyServiceLookup_iface)))
 799             {
 800                 renderer->flags |= EVR_PRESENTER_INITED_SERVICES;
 801             }
 802             renderer->flags &= ~EVR_INIT_SERVICES;
 803             IMFTopologyServiceLookupClient_Release(lookup_client);
 804         }
 805     }
 806
 807     return hr;
 808 }
 809
 810 static HRESULT evr_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj)
 811 {
 812     struct video_renderer *object;
 813     HRESULT hr;
 814
 815     TRACE("%p, %p, %p.\n", attributes, user_context, obj);
 816
 817     if (!(object = heap_alloc_zero(sizeof(*object))))
 818         return E_OUTOFMEMORY;
 819
 820     object->IMFMediaSink_iface.lpVtbl = &video_renderer_sink_vtbl;
 821     object->IMFMediaSinkPreroll_iface.lpVtbl = &video_renderer_preroll_vtbl;
 822     object->IMFVideoRenderer_iface.lpVtbl = &video_renderer_vtbl;
 823     object->IMFMediaEventGenerator_iface.lpVtbl = &video_renderer_events_vtbl;
 824     object->IMFClockStateSink_iface.lpVtbl = &video_renderer_clock_sink_vtbl;
 825     object->IMFGetService_iface.lpVtbl = &video_renderer_get_service_vtbl;
 826     object->IMFTopologyServiceLookup_iface.lpVtbl = &video_renderer_service_lookup_vtbl;
 827     object->IMediaEventSink_iface.lpVtbl = &media_event_sink_vtbl;
 828     object->refcount = 1;
 829     InitializeCriticalSection(&object->cs);
 830
 831     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
 832         goto failed;
 833
 834     /* Create mixer and presenter. */
 835     if (FAILED(hr = video_renderer_create_mixer(object, attributes, &object->mixer)))
 836         goto failed;
 837
 838     if (FAILED(hr = video_renderer_create_presenter(object, attributes, &object->presenter)))
 839         goto failed;
 840
 841     *obj = (IUnknown *)&object->IMFMediaSink_iface;
 842
 843     return S_OK;
 844
 845 failed:
 846
 847     video_renderer_release_services(object);
 848     IMFMediaSink_Release(&object->IMFMediaSink_iface);
 849
 850     return hr;
 851 }
 852
 853 static void evr_shutdown_object(void *user_context, IUnknown *obj)
 854 {
 855     IMFMediaSink *sink;
 856
 857     if (SUCCEEDED(IUnknown_QueryInterface(obj, &IID_IMFMediaSink, (void **)&sink)))
 858     {
 859         IMFMediaSink_Shutdown(sink);
 860         IMFMediaSink_Release(sink);
 861     }
 862 }
 863
 864 static const struct activate_funcs evr_activate_funcs =
 865 {
 866     .create_object = evr_create_object,
 867     .shutdown_object = evr_shutdown_object,
 868 };
 869
 870 /***********************************************************************
 871  *      MFCreateVideoRendererActivate (mf.@)
 872  */
 873 HRESULT WINAPI MFCreateVideoRendererActivate(HWND hwnd, IMFActivate **activate)
 874 {
 875     HRESULT hr;
 876
 877     TRACE("%p, %p.\n", hwnd, activate);
 878
 879     if (!activate)
 880         return E_POINTER;
 881
 882     hr = create_activation_object(NULL, &evr_activate_funcs, activate);
 883     if (SUCCEEDED(hr))
 884         IMFActivate_SetUINT64(*activate, &MF_ACTIVATE_VIDEO_WINDOW, (ULONG_PTR)hwnd);
 885
 886     return hr;
 887 }