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     EVR_STREAM_SAMPLE_NEEDED = 0x4,
  51     EVR_STREAM_STARTED = 0x8,
  52 };
  53
  54 struct video_renderer;
  55
  56 struct video_stream
  57 {
  58     IMFStreamSink IMFStreamSink_iface;
  59     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
  60     IMFGetService IMFGetService_iface;
  61     IMFAttributes IMFAttributes_iface;
  62     LONG refcount;
  63     unsigned int id;
  64     unsigned int flags;
  65     struct video_renderer *parent;
  66     IMFMediaEventQueue *event_queue;
  67     IMFVideoSampleAllocator *allocator;
  68     IMFAttributes *attributes;
  69     CRITICAL_SECTION cs;
  70 };
  71
  72 struct video_renderer
  73 {
  74     IMFMediaSink IMFMediaSink_iface;
  75     IMFMediaSinkPreroll IMFMediaSinkPreroll_iface;
  76     IMFVideoRenderer IMFVideoRenderer_iface;
  77     IMFClockStateSink IMFClockStateSink_iface;
  78     IMFMediaEventGenerator IMFMediaEventGenerator_iface;
  79     IMFGetService IMFGetService_iface;
  80     IMFTopologyServiceLookup IMFTopologyServiceLookup_iface;
  81     IMediaEventSink IMediaEventSink_iface;
  82     IMFAttributes IMFAttributes_iface;
  83     IMFQualityAdvise IMFQualityAdvise_iface;
  84     IMFRateSupport IMFRateSupport_iface;
  85     LONG refcount;
  86
  87     IMFMediaEventQueue *event_queue;
  88     IMFAttributes *attributes;
  89     IMFPresentationClock *clock;
  90
  91     IMFTransform *mixer;
  92     IMFVideoPresenter *presenter;
  93     HWND window;
  94     IUnknown *device_manager;
  95     unsigned int flags;
  96     unsigned int state;
  97
  98     struct video_stream **streams;
  99     size_t stream_size;
 100     size_t stream_count;
 101
 102     CRITICAL_SECTION cs;
 103 };
 104
 105 static struct video_renderer *impl_from_IMFMediaSink(IMFMediaSink *iface)
 106 {
 107     return CONTAINING_RECORD(iface, struct video_renderer, IMFMediaSink_iface);
 108 }
 109
 110 static struct video_renderer *impl_from_IMFMediaSinkPreroll(IMFMediaSinkPreroll *iface)
 111 {
 112     return CONTAINING_RECORD(iface, struct video_renderer, IMFMediaSinkPreroll_iface);
 113 }
 114
 115 static struct video_renderer *impl_from_IMFVideoRenderer(IMFVideoRenderer *iface)
 116 {
 117     return CONTAINING_RECORD(iface, struct video_renderer, IMFVideoRenderer_iface);
 118 }
 119
 120 static struct video_renderer *impl_from_IMFMediaEventGenerator(IMFMediaEventGenerator *iface)
 121 {
 122     return CONTAINING_RECORD(iface, struct video_renderer, IMFMediaEventGenerator_iface);
 123 }
 124
 125 static struct video_renderer *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
 126 {
 127     return CONTAINING_RECORD(iface, struct video_renderer, IMFClockStateSink_iface);
 128 }
 129
 130 static struct video_renderer *impl_from_IMFGetService(IMFGetService *iface)
 131 {
 132     return CONTAINING_RECORD(iface, struct video_renderer, IMFGetService_iface);
 133 }
 134
 135 static struct video_renderer *impl_from_IMFTopologyServiceLookup(IMFTopologyServiceLookup *iface)
 136 {
 137     return CONTAINING_RECORD(iface, struct video_renderer, IMFTopologyServiceLookup_iface);
 138 }
 139
 140 static struct video_renderer *impl_from_IMediaEventSink(IMediaEventSink *iface)
 141 {
 142     return CONTAINING_RECORD(iface, struct video_renderer, IMediaEventSink_iface);
 143 }
 144
 145 static struct video_renderer *impl_from_IMFAttributes(IMFAttributes *iface)
 146 {
 147     return CONTAINING_RECORD(iface, struct video_renderer, IMFAttributes_iface);
 148 }
 149
 150 static struct video_renderer *impl_from_IMFQualityAdvise(IMFQualityAdvise *iface)
 151 {
 152     return CONTAINING_RECORD(iface, struct video_renderer, IMFQualityAdvise_iface);
 153 }
 154
 155 static struct video_renderer *impl_from_IMFRateSupport(IMFRateSupport *iface)
 156 {
 157     return CONTAINING_RECORD(iface, struct video_renderer, IMFRateSupport_iface);
 158 }
 159
 160 static struct video_stream *impl_from_IMFStreamSink(IMFStreamSink *iface)
 161 {
 162     return CONTAINING_RECORD(iface, struct video_stream, IMFStreamSink_iface);
 163 }
 164
 165 static struct video_stream *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
 166 {
 167     return CONTAINING_RECORD(iface, struct video_stream, IMFMediaTypeHandler_iface);
 168 }
 169
 170 static struct video_stream *impl_from_stream_IMFGetService(IMFGetService *iface)
 171 {
 172     return CONTAINING_RECORD(iface, struct video_stream, IMFGetService_iface);
 173 }
 174
 175 static struct video_stream *impl_from_stream_IMFAttributes(IMFAttributes *iface)
 176 {
 177     return CONTAINING_RECORD(iface, struct video_stream, IMFAttributes_iface);
 178 }
 179
 180 static HRESULT video_renderer_init_presenter_services(struct video_renderer *renderer)
 181 {
 182     IMFTopologyServiceLookupClient *lookup_client;
 183     HRESULT hr;
 184
 185     if (SUCCEEDED(hr = IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFTopologyServiceLookupClient,
 186             (void **)&lookup_client)))
 187     {
 188         renderer->flags |= EVR_INIT_SERVICES;
 189         if (SUCCEEDED(hr = IMFTopologyServiceLookupClient_InitServicePointers(lookup_client,
 190                 &renderer->IMFTopologyServiceLookup_iface)))
 191         {
 192             renderer->flags |= EVR_PRESENTER_INITED_SERVICES;
 193         }
 194         renderer->flags &= ~EVR_INIT_SERVICES;
 195         IMFTopologyServiceLookupClient_Release(lookup_client);
 196     }
 197
 198     return hr;
 199 }
 200
 201 static void video_renderer_release_presenter_services(struct video_renderer *renderer)
 202 {
 203     IMFTopologyServiceLookupClient *lookup_client;
 204
 205     if (renderer->flags & EVR_PRESENTER_INITED_SERVICES && SUCCEEDED(IMFVideoPresenter_QueryInterface(renderer->presenter,
 206             &IID_IMFTopologyServiceLookupClient, (void **)&lookup_client)))
 207     {
 208         IMFTopologyServiceLookupClient_ReleaseServicePointers(lookup_client);
 209         IMFTopologyServiceLookupClient_Release(lookup_client);
 210         renderer->flags &= ~EVR_PRESENTER_INITED_SERVICES;
 211     }
 212 }
 213
 214 static void video_renderer_release_services(struct video_renderer *renderer)
 215 {
 216     IMFTopologyServiceLookupClient *lookup_client;
 217
 218     if (renderer->flags & EVR_MIXER_INITED_SERVICES && SUCCEEDED(IMFTransform_QueryInterface(renderer->mixer,
 219             &IID_IMFTopologyServiceLookupClient, (void **)&lookup_client)))
 220     {
 221         IMFTopologyServiceLookupClient_ReleaseServicePointers(lookup_client);
 222         IMFTopologyServiceLookupClient_Release(lookup_client);
 223         renderer->flags &= ~EVR_MIXER_INITED_SERVICES;
 224     }
 225
 226     video_renderer_release_presenter_services(renderer);
 227 }
 228
 229 static HRESULT WINAPI video_stream_sink_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj)
 230 {
 231     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 232
 233     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 234
 235     if (IsEqualIID(riid, &IID_IMFStreamSink) ||
 236             IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
 237             IsEqualIID(riid, &IID_IUnknown))
 238     {
 239         *obj = iface;
 240     }
 241     else if (IsEqualIID(riid, &IID_IMFMediaTypeHandler))
 242     {
 243         *obj = &stream->IMFMediaTypeHandler_iface;
 244     }
 245     else if (IsEqualIID(riid, &IID_IMFGetService))
 246     {
 247         *obj = &stream->IMFGetService_iface;
 248     }
 249     else if (IsEqualIID(riid, &IID_IMFAttributes))
 250     {
 251         *obj = &stream->IMFAttributes_iface;
 252     }
 253     else
 254     {
 255         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 256         *obj = NULL;
 257         return E_NOINTERFACE;
 258     }
 259
 260     IUnknown_AddRef((IUnknown *)*obj);
 261
 262     return S_OK;
 263 }
 264
 265 static ULONG WINAPI video_stream_sink_AddRef(IMFStreamSink *iface)
 266 {
 267     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 268     ULONG refcount = InterlockedIncrement(&stream->refcount);
 269
 270     TRACE("%p, refcount %u.\n", iface, refcount);
 271
 272     return refcount;
 273 }
 274
 275 static ULONG WINAPI video_stream_sink_Release(IMFStreamSink *iface)
 276 {
 277     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 278     ULONG refcount = InterlockedDecrement(&stream->refcount);
 279
 280     if (!refcount)
 281     {
 282         if (stream->event_queue)
 283             IMFMediaEventQueue_Release(stream->event_queue);
 284         if (stream->attributes)
 285             IMFAttributes_Release(stream->attributes);
 286         if (stream->allocator)
 287             IMFVideoSampleAllocator_Release(stream->allocator);
 288         DeleteCriticalSection(&stream->cs);
 289         free(stream);
 290     }
 291
 292     return refcount;
 293 }
 294
 295 static HRESULT WINAPI video_stream_sink_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event)
 296 {
 297     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 298
 299     TRACE("%p, %#x, %p.\n", iface, flags, event);
 300
 301     return IMFMediaEventQueue_GetEvent(stream->event_queue, flags, event);
 302 }
 303
 304 static HRESULT WINAPI video_stream_sink_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback, IUnknown *state)
 305 {
 306     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 307
 308     TRACE("%p, %p, %p.\n", iface, callback, state);
 309
 310     return IMFMediaEventQueue_BeginGetEvent(stream->event_queue, callback, state);
 311 }
 312
 313 static HRESULT WINAPI video_stream_sink_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result,
 314         IMFMediaEvent **event)
 315 {
 316     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 317
 318     TRACE("%p, %p, %p.\n", iface, result, event);
 319
 320     return IMFMediaEventQueue_EndGetEvent(stream->event_queue, result, event);
 321 }
 322
 323 static HRESULT WINAPI video_stream_sink_QueueEvent(IMFStreamSink *iface, MediaEventType event_type,
 324         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 325 {
 326     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 327
 328     TRACE("%p, %d, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
 329
 330     return IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, event_type, ext_type, hr, value);
 331 }
 332
 333 static HRESULT WINAPI video_stream_sink_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink)
 334 {
 335     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 336     HRESULT hr = S_OK;
 337
 338     TRACE("%p, %p.\n", iface, sink);
 339
 340     EnterCriticalSection(&stream->cs);
 341     if (!stream->parent)
 342         hr = MF_E_STREAMSINK_REMOVED;
 343     else if (!sink)
 344         hr = E_POINTER;
 345     else
 346     {
 347         *sink = &stream->parent->IMFMediaSink_iface;
 348         IMFMediaSink_AddRef(*sink);
 349     }
 350     LeaveCriticalSection(&stream->cs);
 351
 352     return hr;
 353 }
 354
 355 static HRESULT WINAPI video_stream_sink_GetIdentifier(IMFStreamSink *iface, DWORD *id)
 356 {
 357     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 358
 359     TRACE("%p, %p.\n", iface, id);
 360
 361     if (!stream->parent)
 362         return MF_E_STREAMSINK_REMOVED;
 363
 364     if (!id)
 365         return E_INVALIDARG;
 366
 367     *id = stream->id;
 368
 369     return S_OK;
 370 }
 371
 372 static HRESULT WINAPI video_stream_sink_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler)
 373 {
 374     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 375
 376     TRACE("%p, %p.\n", iface, handler);
 377
 378     if (!handler)
 379         return E_POINTER;
 380
 381     if (!stream->parent)
 382         return MF_E_STREAMSINK_REMOVED;
 383
 384     *handler = &stream->IMFMediaTypeHandler_iface;
 385     IMFMediaTypeHandler_AddRef(*handler);
 386
 387     return S_OK;
 388 }
 389
 390 static HRESULT WINAPI video_stream_sink_ProcessSample(IMFStreamSink *iface, IMFSample *sample)
 391 {
 392     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 393     LONGLONG timestamp;
 394     HRESULT hr = S_OK;
 395
 396     TRACE("%p, %p.\n", iface, sample);
 397
 398     EnterCriticalSection(&stream->cs);
 399
 400     if (!stream->parent)
 401         hr = MF_E_STREAMSINK_REMOVED;
 402     else if (!stream->parent->clock)
 403         hr = MF_E_NO_CLOCK;
 404     else if (FAILED(hr = IMFSample_GetSampleTime(sample, &timestamp)))
 405     {
 406         WARN("No sample timestamp, hr %#x.\n", hr);
 407     }
 408     else if (stream->parent->state == EVR_STATE_RUNNING || stream->flags & EVR_STREAM_PREROLLING)
 409     {
 410         if (!(stream->flags & EVR_STREAM_STARTED))
 411         {
 412             IMFTransform_ProcessMessage(stream->parent->mixer, MFT_MESSAGE_NOTIFY_START_OF_STREAM, stream->id);
 413             stream->flags |= EVR_STREAM_STARTED;
 414         }
 415
 416         if (SUCCEEDED(IMFTransform_ProcessInput(stream->parent->mixer, stream->id, sample, 0)))
 417             IMFVideoPresenter_ProcessMessage(stream->parent->presenter, MFVP_MESSAGE_PROCESSINPUTNOTIFY, 0);
 418
 419         if (stream->flags & EVR_STREAM_PREROLLING)
 420         {
 421             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkPrerolled, &GUID_NULL, S_OK, NULL);
 422             stream->flags &= ~EVR_STREAM_PREROLLING;
 423             stream->flags |= EVR_STREAM_PREROLLED;
 424         }
 425     }
 426
 427     LeaveCriticalSection(&stream->cs);
 428
 429     return hr;
 430 }
 431
 432 static void video_stream_end_of_stream(struct video_stream *stream)
 433 {
 434     if (!(stream->flags & EVR_STREAM_STARTED))
 435         return;
 436
 437     IMFTransform_ProcessMessage(stream->parent->mixer, MFT_MESSAGE_NOTIFY_END_OF_STREAM, stream->id);
 438     stream->flags &= ~EVR_STREAM_STARTED;
 439 }
 440
 441 static HRESULT WINAPI video_stream_sink_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type,
 442         const PROPVARIANT *marker_value, const PROPVARIANT *context)
 443 {
 444     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 445     HRESULT hr = S_OK;
 446
 447     TRACE("%p, %d, %p, %p.\n", iface, marker_type, marker_value, context);
 448
 449     EnterCriticalSection(&stream->cs);
 450     if (!stream->parent)
 451         hr = MF_E_STREAMSINK_REMOVED;
 452     else
 453     {
 454         if (marker_type == MFSTREAMSINK_MARKER_ENDOFSEGMENT)
 455             video_stream_end_of_stream(stream);
 456         IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkMarker, &GUID_NULL, S_OK, context);
 457     }
 458     LeaveCriticalSection(&stream->cs);
 459
 460     return hr;
 461 }
 462
 463 static HRESULT WINAPI video_stream_sink_Flush(IMFStreamSink *iface)
 464 {
 465     struct video_stream *stream = impl_from_IMFStreamSink(iface);
 466     HRESULT hr;
 467
 468     TRACE("%p.\n", iface);
 469
 470     EnterCriticalSection(&stream->cs);
 471     if (!stream->parent)
 472         hr = MF_E_STREAMSINK_REMOVED;
 473     else if (SUCCEEDED(hr = IMFTransform_ProcessMessage(stream->parent->mixer, MFT_MESSAGE_COMMAND_FLUSH, 0)))
 474         hr = IMFVideoPresenter_ProcessMessage(stream->parent->presenter, MFVP_MESSAGE_FLUSH, 0);
 475     LeaveCriticalSection(&stream->cs);
 476
 477     return hr;
 478 }
 479
 480 static const IMFStreamSinkVtbl video_stream_sink_vtbl =
 481 {
 482     video_stream_sink_QueryInterface,
 483     video_stream_sink_AddRef,
 484     video_stream_sink_Release,
 485     video_stream_sink_GetEvent,
 486     video_stream_sink_BeginGetEvent,
 487     video_stream_sink_EndGetEvent,
 488     video_stream_sink_QueueEvent,
 489     video_stream_sink_GetMediaSink,
 490     video_stream_sink_GetIdentifier,
 491     video_stream_sink_GetMediaTypeHandler,
 492     video_stream_sink_ProcessSample,
 493     video_stream_sink_PlaceMarker,
 494     video_stream_sink_Flush,
 495 };
 496
 497 static HRESULT WINAPI video_stream_typehandler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid,
 498         void **obj)
 499 {
 500     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 501     return IMFStreamSink_QueryInterface(&stream->IMFStreamSink_iface, riid, obj);
 502 }
 503
 504 static ULONG WINAPI video_stream_typehandler_AddRef(IMFMediaTypeHandler *iface)
 505 {
 506     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 507     return IMFStreamSink_AddRef(&stream->IMFStreamSink_iface);
 508 }
 509
 510 static ULONG WINAPI video_stream_typehandler_Release(IMFMediaTypeHandler *iface)
 511 {
 512     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 513     return IMFStreamSink_Release(&stream->IMFStreamSink_iface);
 514 }
 515
 516 static HRESULT WINAPI video_stream_typehandler_IsMediaTypeSupported(IMFMediaTypeHandler *iface,
 517         IMFMediaType *in_type, IMFMediaType **out_type)
 518 {
 519     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 520     HRESULT hr;
 521
 522     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
 523
 524     if (!in_type)
 525         return E_POINTER;
 526
 527     if (!stream->parent)
 528         return MF_E_INVALIDMEDIATYPE;
 529
 530     if (SUCCEEDED(hr = IMFTransform_SetInputType(stream->parent->mixer, stream->id, in_type,
 531             MFT_SET_TYPE_TEST_ONLY)))
 532     {
 533         if (out_type) *out_type = NULL;
 534     }
 535
 536     return hr;
 537 }
 538
 539 static HRESULT WINAPI video_stream_typehandler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
 540 {
 541     TRACE("%p, %p.\n", iface, count);
 542
 543     if (!count)
 544         return E_POINTER;
 545
 546     *count = 0;
 547
 548     return S_OK;
 549 }
 550
 551 static HRESULT WINAPI video_stream_typehandler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
 552         IMFMediaType **type)
 553 {
 554     TRACE("%p, %u, %p.\n", iface, index, type);
 555
 556     return MF_E_NO_MORE_TYPES;
 557 }
 558
 559 static HRESULT WINAPI video_stream_typehandler_SetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType *type)
 560 {
 561     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 562     HRESULT hr;
 563
 564     TRACE("%p, %p.\n", iface, type);
 565
 566     if (!type)
 567         return E_POINTER;
 568
 569     if (!stream->parent)
 570         return MF_E_STREAMSINK_REMOVED;
 571
 572     hr = IMFTransform_SetInputType(stream->parent->mixer, stream->id, type, 0);
 573     if (SUCCEEDED(hr) && !stream->id)
 574         hr = IMFVideoPresenter_ProcessMessage(stream->parent->presenter, MFVP_MESSAGE_INVALIDATEMEDIATYPE, 0);
 575
 576     return hr;
 577 }
 578
 579 static HRESULT WINAPI video_stream_typehandler_GetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType **type)
 580 {
 581     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 582
 583     TRACE("%p, %p.\n", iface, type);
 584
 585     if (!type)
 586         return E_POINTER;
 587
 588     if (!stream->parent)
 589         return MF_E_STREAMSINK_REMOVED;
 590
 591     return IMFTransform_GetInputCurrentType(stream->parent->mixer, stream->id, type);
 592 }
 593
 594 static HRESULT WINAPI video_stream_typehandler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
 595 {
 596     struct video_stream *stream = impl_from_IMFMediaTypeHandler(iface);
 597
 598     TRACE("%p, %p.\n", iface, type);
 599
 600     if (!stream->parent)
 601         return MF_E_STREAMSINK_REMOVED;
 602
 603     if (!type)
 604         return E_POINTER;
 605
 606     memcpy(type, &MFMediaType_Video, sizeof(*type));
 607     return S_OK;
 608 }
 609
 610 static const IMFMediaTypeHandlerVtbl video_stream_type_handler_vtbl =
 611 {
 612     video_stream_typehandler_QueryInterface,
 613     video_stream_typehandler_AddRef,
 614     video_stream_typehandler_Release,
 615     video_stream_typehandler_IsMediaTypeSupported,
 616     video_stream_typehandler_GetMediaTypeCount,
 617     video_stream_typehandler_GetMediaTypeByIndex,
 618     video_stream_typehandler_SetCurrentMediaType,
 619     video_stream_typehandler_GetCurrentMediaType,
 620     video_stream_typehandler_GetMajorType,
 621 };
 622
 623 static HRESULT WINAPI video_stream_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
 624 {
 625     struct video_stream *stream = impl_from_stream_IMFGetService(iface);
 626     return IMFStreamSink_QueryInterface(&stream->IMFStreamSink_iface, riid, obj);
 627 }
 628
 629 static ULONG WINAPI video_stream_get_service_AddRef(IMFGetService *iface)
 630 {
 631     struct video_stream *stream = impl_from_stream_IMFGetService(iface);
 632     return IMFStreamSink_AddRef(&stream->IMFStreamSink_iface);
 633 }
 634
 635 static ULONG WINAPI video_stream_get_service_Release(IMFGetService *iface)
 636 {
 637     struct video_stream *stream = impl_from_stream_IMFGetService(iface);
 638     return IMFStreamSink_Release(&stream->IMFStreamSink_iface);
 639 }
 640
 641 static HRESULT WINAPI video_stream_get_service(struct video_stream *stream, REFGUID service, REFIID riid, void **obj)
 642 {
 643     HRESULT hr = S_OK;
 644
 645     if (IsEqualGUID(service, &MR_VIDEO_ACCELERATION_SERVICE))
 646     {
 647         if (IsEqualIID(riid, &IID_IMFVideoSampleAllocator))
 648         {
 649             if (!stream->allocator)
 650             {
 651                 hr = MFCreateVideoSampleAllocator(&IID_IMFVideoSampleAllocator, (void **)&stream->allocator);
 652                 if (SUCCEEDED(hr))
 653                     hr = IMFVideoSampleAllocator_SetDirectXManager(stream->allocator, stream->parent->device_manager);
 654             }
 655             if (SUCCEEDED(hr))
 656                 hr = IMFVideoSampleAllocator_QueryInterface(stream->allocator, riid, obj);
 657
 658             return hr;
 659         }
 660         else if (IsEqualIID(riid, &IID_IDirect3DDeviceManager9) && stream->parent->device_manager)
 661         {
 662             return IUnknown_QueryInterface(stream->parent->device_manager, riid, obj);
 663         }
 664
 665         return E_NOINTERFACE;
 666     }
 667
 668     FIXME("Unsupported service %s.\n", debugstr_guid(service));
 669
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI video_stream_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 674 {
 675     struct video_stream *stream = impl_from_stream_IMFGetService(iface);
 676     HRESULT hr;
 677
 678     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 679
 680     EnterCriticalSection(&stream->cs);
 681     if (!stream->parent)
 682         hr = MF_E_STREAMSINK_REMOVED;
 683     else
 684         hr = video_stream_get_service(stream, service, riid, obj);
 685     LeaveCriticalSection(&stream->cs);
 686
 687     return hr;
 688 }
 689
 690 static const IMFGetServiceVtbl video_stream_get_service_vtbl =
 691 {
 692     video_stream_get_service_QueryInterface,
 693     video_stream_get_service_AddRef,
 694     video_stream_get_service_Release,
 695     video_stream_get_service_GetService,
 696 };
 697
 698 static HRESULT WINAPI video_stream_attributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **obj)
 699 {
 700     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 701     return IMFStreamSink_QueryInterface(&stream->IMFStreamSink_iface, riid, obj);
 702 }
 703
 704 static ULONG WINAPI video_stream_attributes_AddRef(IMFAttributes *iface)
 705 {
 706     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 707     return IMFStreamSink_AddRef(&stream->IMFStreamSink_iface);
 708 }
 709
 710 static ULONG WINAPI video_stream_attributes_Release(IMFAttributes *iface)
 711 {
 712     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 713     return IMFStreamSink_Release(&stream->IMFStreamSink_iface);
 714 }
 715
 716 static HRESULT WINAPI video_stream_attributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
 717 {
 718     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 719
 720     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 721
 722     return IMFAttributes_GetItem(stream->attributes, key, value);
 723 }
 724
 725 static HRESULT WINAPI video_stream_attributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 726 {
 727     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 728
 729     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
 730
 731     return IMFAttributes_GetItemType(stream->attributes, key, type);
 732 }
 733
 734 static HRESULT WINAPI video_stream_attributes_CompareItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value,
 735         BOOL *result)
 736 {
 737     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 738
 739     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
 740
 741     return IMFAttributes_CompareItem(stream->attributes, key, value, result);
 742 }
 743
 744 static HRESULT WINAPI video_stream_attributes_Compare(IMFAttributes *iface, IMFAttributes *theirs,
 745         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
 746 {
 747     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 748
 749     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
 750
 751     return IMFAttributes_Compare(stream->attributes, theirs, type, result);
 752 }
 753
 754 static HRESULT WINAPI video_stream_attributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
 755 {
 756     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 757
 758     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 759
 760     return IMFAttributes_GetUINT32(stream->attributes, key, value);
 761 }
 762
 763 static HRESULT WINAPI video_stream_attributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
 764 {
 765     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 766
 767     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 768
 769     return IMFAttributes_GetUINT64(stream->attributes, key, value);
 770 }
 771
 772 static HRESULT WINAPI video_stream_attributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
 773 {
 774     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 775
 776     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 777
 778     return IMFAttributes_GetDouble(stream->attributes, key, value);
 779 }
 780
 781 static HRESULT WINAPI video_stream_attributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
 782 {
 783     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 784
 785     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 786
 787     return IMFAttributes_GetGUID(stream->attributes, key, value);
 788 }
 789
 790 static HRESULT WINAPI video_stream_attributes_GetStringLength(IMFAttributes *iface, REFGUID key,
 791         UINT32 *length)
 792 {
 793     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 794
 795     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
 796
 797     return IMFAttributes_GetStringLength(stream->attributes, key, length);
 798 }
 799
 800 static HRESULT WINAPI video_stream_attributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
 801         UINT32 size, UINT32 *length)
 802 {
 803     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 804
 805     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), value, size, length);
 806
 807     return IMFAttributes_GetString(stream->attributes, key, value, size, length);
 808 }
 809
 810 static HRESULT WINAPI video_stream_attributes_GetAllocatedString(IMFAttributes *iface, REFGUID key,
 811         WCHAR **value, UINT32 *length)
 812 {
 813     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 814
 815     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
 816
 817     return IMFAttributes_GetAllocatedString(stream->attributes, key, value, length);
 818 }
 819
 820 static HRESULT WINAPI video_stream_attributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
 821 {
 822     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 823
 824     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
 825
 826     return IMFAttributes_GetBlobSize(stream->attributes, key, size);
 827 }
 828
 829 static HRESULT WINAPI video_stream_attributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
 830          UINT32 bufsize, UINT32 *blobsize)
 831 {
 832     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 833
 834     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
 835
 836     return IMFAttributes_GetBlob(stream->attributes, key, buf, bufsize, blobsize);
 837 }
 838
 839 static HRESULT WINAPI video_stream_attributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key,
 840         UINT8 **buf, UINT32 *size)
 841 {
 842     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 843
 844     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
 845
 846     return IMFAttributes_GetAllocatedBlob(stream->attributes, key, buf, size);
 847 }
 848
 849 static HRESULT WINAPI video_stream_attributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **out)
 850 {
 851     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 852
 853     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), out);
 854
 855     return IMFAttributes_GetUnknown(stream->attributes, key, riid, out);
 856 }
 857
 858 static HRESULT WINAPI video_stream_attributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value)
 859 {
 860     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 861
 862     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 863
 864     return IMFAttributes_SetItem(stream->attributes, key, value);
 865 }
 866
 867 static HRESULT WINAPI video_stream_attributes_DeleteItem(IMFAttributes *iface, REFGUID key)
 868 {
 869     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 870
 871     TRACE("%p, %s.\n", iface, debugstr_guid(key));
 872
 873     return IMFAttributes_DeleteItem(stream->attributes, key);
 874 }
 875
 876 static HRESULT WINAPI video_stream_attributes_DeleteAllItems(IMFAttributes *iface)
 877 {
 878     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 879
 880     TRACE("%p.\n", iface);
 881
 882     return IMFAttributes_DeleteAllItems(stream->attributes);
 883 }
 884
 885 static HRESULT WINAPI video_stream_attributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
 886 {
 887     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 888
 889     TRACE("%p, %s, %u.\n", iface, debugstr_guid(key), value);
 890
 891     return IMFAttributes_SetUINT32(stream->attributes, key, value);
 892 }
 893
 894 static HRESULT WINAPI video_stream_attributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
 895 {
 896     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 897
 898     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
 899
 900     return IMFAttributes_SetUINT64(stream->attributes, key, value);
 901 }
 902
 903 static HRESULT WINAPI video_stream_attributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
 904 {
 905     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 906
 907     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
 908
 909     return IMFAttributes_SetDouble(stream->attributes, key, value);
 910 }
 911
 912 static HRESULT WINAPI video_stream_attributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
 913 {
 914     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 915
 916     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
 917
 918     return IMFAttributes_SetGUID(stream->attributes, key, value);
 919 }
 920
 921 static HRESULT WINAPI video_stream_attributes_SetString(IMFAttributes *iface, REFGUID key,
 922         const WCHAR *value)
 923 {
 924     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 925
 926     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
 927
 928     return IMFAttributes_SetString(stream->attributes, key, value);
 929 }
 930
 931 static HRESULT WINAPI video_stream_attributes_SetBlob(IMFAttributes *iface, REFGUID key,
 932         const UINT8 *buf, UINT32 size)
 933 {
 934     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 935
 936     TRACE("%p, %s, %p, %u.\n", iface, debugstr_guid(key), buf, size);
 937
 938     return IMFAttributes_SetBlob(stream->attributes, key, buf, size);
 939 }
 940
 941 static HRESULT WINAPI video_stream_attributes_SetUnknown(IMFAttributes *iface, REFGUID key,
 942         IUnknown *unknown)
 943 {
 944     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 945
 946     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), unknown);
 947
 948     return IMFAttributes_SetUnknown(stream->attributes, key, unknown);
 949 }
 950
 951 static HRESULT WINAPI video_stream_attributes_LockStore(IMFAttributes *iface)
 952 {
 953     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 954
 955     TRACE("%p.\n", iface);
 956
 957     return IMFAttributes_LockStore(stream->attributes);
 958 }
 959
 960 static HRESULT WINAPI video_stream_attributes_UnlockStore(IMFAttributes *iface)
 961 {
 962     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 963
 964     TRACE("%p.\n", iface);
 965
 966     return IMFAttributes_UnlockStore(stream->attributes);
 967 }
 968
 969 static HRESULT WINAPI video_stream_attributes_GetCount(IMFAttributes *iface, UINT32 *count)
 970 {
 971     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 972
 973     TRACE("%p, %p.\n", iface, count);
 974
 975     return IMFAttributes_GetCount(stream->attributes, count);
 976 }
 977
 978 static HRESULT WINAPI video_stream_attributes_GetItemByIndex(IMFAttributes *iface, UINT32 index,
 979         GUID *key, PROPVARIANT *value)
 980 {
 981     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 982
 983     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
 984
 985     return IMFAttributes_GetItemByIndex(stream->attributes, index, key, value);
 986 }
 987
 988 static HRESULT WINAPI video_stream_attributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
 989 {
 990     struct video_stream *stream = impl_from_stream_IMFAttributes(iface);
 991
 992     TRACE("%p, %p.\n", iface, dest);
 993
 994     return IMFAttributes_CopyAllItems(stream->attributes, dest);
 995 }
 996
 997 static const IMFAttributesVtbl video_stream_attributes_vtbl =
 998 {
 999     video_stream_attributes_QueryInterface,
1000     video_stream_attributes_AddRef,
1001     video_stream_attributes_Release,
1002     video_stream_attributes_GetItem,
1003     video_stream_attributes_GetItemType,
1004     video_stream_attributes_CompareItem,
1005     video_stream_attributes_Compare,
1006     video_stream_attributes_GetUINT32,
1007     video_stream_attributes_GetUINT64,
1008     video_stream_attributes_GetDouble,
1009     video_stream_attributes_GetGUID,
1010     video_stream_attributes_GetStringLength,
1011     video_stream_attributes_GetString,
1012     video_stream_attributes_GetAllocatedString,
1013     video_stream_attributes_GetBlobSize,
1014     video_stream_attributes_GetBlob,
1015     video_stream_attributes_GetAllocatedBlob,
1016     video_stream_attributes_GetUnknown,
1017     video_stream_attributes_SetItem,
1018     video_stream_attributes_DeleteItem,
1019     video_stream_attributes_DeleteAllItems,
1020     video_stream_attributes_SetUINT32,
1021     video_stream_attributes_SetUINT64,
1022     video_stream_attributes_SetDouble,
1023     video_stream_attributes_SetGUID,
1024     video_stream_attributes_SetString,
1025     video_stream_attributes_SetBlob,
1026     video_stream_attributes_SetUnknown,
1027     video_stream_attributes_LockStore,
1028     video_stream_attributes_UnlockStore,
1029     video_stream_attributes_GetCount,
1030     video_stream_attributes_GetItemByIndex,
1031     video_stream_attributes_CopyAllItems,
1032 };
1033
1034 static BOOL video_renderer_is_mixer_d3d_aware(const struct video_renderer *renderer)
1035 {
1036     IMFAttributes *attributes;
1037     unsigned int value = 0;
1038     BOOL ret;
1039
1040     if (FAILED(IMFTransform_QueryInterface(renderer->mixer, &IID_IMFAttributes, (void **)&attributes)))
1041         return FALSE;
1042
1043     ret = SUCCEEDED(IMFAttributes_GetUINT32(attributes, &MF_SA_D3D_AWARE, &value)) && value;
1044     IMFAttributes_Release(attributes);
1045     return ret;
1046 }
1047
1048 static HRESULT video_renderer_stream_create(struct video_renderer *renderer, unsigned int id,
1049         struct video_stream **ret)
1050 {
1051     struct video_stream *stream;
1052     IMFAttributes *attributes;
1053     unsigned int value;
1054     HRESULT hr;
1055
1056     if (!(stream = calloc(1, sizeof(*stream))))
1057         return E_OUTOFMEMORY;
1058
1059     stream->IMFStreamSink_iface.lpVtbl = &video_stream_sink_vtbl;
1060     stream->IMFMediaTypeHandler_iface.lpVtbl = &video_stream_type_handler_vtbl;
1061     stream->IMFGetService_iface.lpVtbl = &video_stream_get_service_vtbl;
1062     stream->IMFAttributes_iface.lpVtbl = &video_stream_attributes_vtbl;
1063     stream->refcount = 1;
1064     InitializeCriticalSection(&stream->cs);
1065
1066     if (FAILED(hr = MFCreateEventQueue(&stream->event_queue)))
1067         goto failed;
1068
1069     if (FAILED(hr = MFCreateAttributes(&stream->attributes, 0)))
1070         goto failed;
1071
1072     stream->parent = renderer;
1073     IMFMediaSink_AddRef(&stream->parent->IMFMediaSink_iface);
1074     stream->id = id;
1075
1076     if (video_renderer_is_mixer_d3d_aware(renderer))
1077         IMFAttributes_SetUINT32(stream->attributes, &MF_SA_D3D_AWARE, 1);
1078
1079     if (SUCCEEDED(IMFTransform_GetInputStreamAttributes(renderer->mixer, id, &attributes)))
1080     {
1081         if (SUCCEEDED(IMFAttributes_GetUINT32(attributes, &MF_SA_REQUIRED_SAMPLE_COUNT, &value)))
1082             IMFAttributes_SetUINT32(stream->attributes, &MF_SA_REQUIRED_SAMPLE_COUNT, value);
1083         IMFAttributes_Release(attributes);
1084     }
1085
1086     *ret = stream;
1087
1088     return S_OK;
1089
1090 failed:
1091
1092     IMFStreamSink_Release(&stream->IMFStreamSink_iface);
1093
1094     return hr;
1095 }
1096
1097 static HRESULT WINAPI video_renderer_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj)
1098 {
1099     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1100
1101     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1102
1103     if (IsEqualIID(riid, &IID_IMFMediaSink) ||
1104             IsEqualIID(riid, &IID_IUnknown))
1105     {
1106         *obj = &renderer->IMFMediaSink_iface;
1107     }
1108     else if (IsEqualIID(riid, &IID_IMFMediaSinkPreroll))
1109     {
1110         *obj = &renderer->IMFMediaSinkPreroll_iface;
1111     }
1112     else if (IsEqualIID(riid, &IID_IMFVideoRenderer))
1113     {
1114         *obj = &renderer->IMFVideoRenderer_iface;
1115     }
1116     else if (IsEqualIID(riid, &IID_IMFMediaEventGenerator))
1117     {
1118         *obj = &renderer->IMFMediaEventGenerator_iface;
1119     }
1120     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
1121     {
1122         *obj = &renderer->IMFClockStateSink_iface;
1123     }
1124     else if (IsEqualIID(riid, &IID_IMFGetService))
1125     {
1126         *obj = &renderer->IMFGetService_iface;
1127     }
1128     else if (IsEqualIID(riid, &IID_IMFAttributes))
1129     {
1130         *obj = &renderer->IMFAttributes_iface;
1131     }
1132     else if (IsEqualIID(riid, &IID_IMFQualityAdvise))
1133     {
1134         *obj = &renderer->IMFQualityAdvise_iface;
1135     }
1136     else if (IsEqualIID(riid, &IID_IMFRateSupport))
1137     {
1138         *obj = &renderer->IMFRateSupport_iface;
1139     }
1140     else
1141     {
1142         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1143         *obj = NULL;
1144         return E_NOINTERFACE;
1145     }
1146
1147     IUnknown_AddRef((IUnknown *)*obj);
1148
1149     return S_OK;
1150 }
1151
1152 static ULONG WINAPI video_renderer_sink_AddRef(IMFMediaSink *iface)
1153 {
1154     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1155     ULONG refcount = InterlockedIncrement(&renderer->refcount);
1156     TRACE("%p, refcount %u.\n", iface, refcount);
1157     return refcount;
1158 }
1159
1160 static ULONG WINAPI video_renderer_sink_Release(IMFMediaSink *iface)
1161 {
1162     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1163     ULONG refcount = InterlockedDecrement(&renderer->refcount);
1164
1165     TRACE("%p, refcount %u.\n", iface, refcount);
1166
1167     if (!refcount)
1168     {
1169         if (renderer->event_queue)
1170             IMFMediaEventQueue_Release(renderer->event_queue);
1171         if (renderer->mixer)
1172             IMFTransform_Release(renderer->mixer);
1173         if (renderer->presenter)
1174             IMFVideoPresenter_Release(renderer->presenter);
1175         if (renderer->device_manager)
1176             IUnknown_Release(renderer->device_manager);
1177         if (renderer->clock)
1178             IMFPresentationClock_Release(renderer->clock);
1179         if (renderer->attributes)
1180             IMFAttributes_Release(renderer->attributes);
1181         DeleteCriticalSection(&renderer->cs);
1182         free(renderer);
1183     }
1184
1185     return refcount;
1186 }
1187
1188 static HRESULT WINAPI video_renderer_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags)
1189 {
1190     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1191
1192     TRACE("%p, %p.\n", iface, flags);
1193
1194     if (renderer->flags & EVR_SHUT_DOWN)
1195         return MF_E_SHUTDOWN;
1196
1197     *flags = MEDIASINK_CLOCK_REQUIRED | MEDIASINK_CAN_PREROLL;
1198
1199     return S_OK;
1200 }
1201
1202 static HRESULT video_renderer_add_stream(struct video_renderer *renderer, unsigned int id,
1203         IMFStreamSink **stream_sink)
1204 {
1205     struct video_stream *stream;
1206     HRESULT hr;
1207
1208     if (!mf_array_reserve((void **)&renderer->streams, &renderer->stream_size, renderer->stream_count + 1,
1209             sizeof(*renderer->streams)))
1210     {
1211         return E_OUTOFMEMORY;
1212     }
1213
1214     if (SUCCEEDED(hr = video_renderer_stream_create(renderer, id, &stream)))
1215     {
1216         if (stream_sink)
1217         {
1218             *stream_sink = &stream->IMFStreamSink_iface;
1219             IMFStreamSink_AddRef(*stream_sink);
1220         }
1221         renderer->streams[renderer->stream_count++] = stream;
1222     }
1223
1224     return hr;
1225 }
1226
1227 static HRESULT WINAPI video_renderer_sink_AddStreamSink(IMFMediaSink *iface, DWORD id,
1228     IMFMediaType *media_type, IMFStreamSink **stream_sink)
1229 {
1230     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1231     HRESULT hr;
1232
1233     TRACE("%p, %#x, %p, %p.\n", iface, id, media_type, stream_sink);
1234
1235     /* Rely on mixer for stream id validation. */
1236
1237     EnterCriticalSection(&renderer->cs);
1238     if (renderer->flags & EVR_SHUT_DOWN)
1239         hr = MF_E_SHUTDOWN;
1240     else if (SUCCEEDED(hr = IMFTransform_AddInputStreams(renderer->mixer, 1, &id)))
1241     {
1242         if (FAILED(hr = video_renderer_add_stream(renderer, id, stream_sink)))
1243             IMFTransform_DeleteInputStream(renderer->mixer, id);
1244
1245     }
1246     LeaveCriticalSection(&renderer->cs);
1247
1248     return hr;
1249 }
1250
1251 static HRESULT WINAPI video_renderer_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD id)
1252 {
1253     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1254     HRESULT hr;
1255     size_t i;
1256
1257     TRACE("%p, %#x.\n", iface, id);
1258
1259     /* Rely on mixer for stream id validation. */
1260
1261     EnterCriticalSection(&renderer->cs);
1262     if (renderer->flags & EVR_SHUT_DOWN)
1263         hr = MF_E_SHUTDOWN;
1264     else if (SUCCEEDED(hr = IMFTransform_DeleteInputStream(renderer->mixer, id)))
1265     {
1266         for (i = 0; i < renderer->stream_count; ++i)
1267         {
1268             if (renderer->streams[i]->id == id)
1269             {
1270                 IMFStreamSink_Release(&renderer->streams[i]->IMFStreamSink_iface);
1271                 renderer->streams[i] = NULL;
1272                 if (i < renderer->stream_count - 1)
1273                 {
1274                     memmove(&renderer->streams[i], &renderer->streams[i+1],
1275                             (renderer->stream_count - i - 1) * sizeof(*renderer->streams));
1276                 }
1277                 renderer->stream_count--;
1278                 break;
1279             }
1280         }
1281     }
1282     LeaveCriticalSection(&renderer->cs);
1283
1284     return hr;
1285 }
1286
1287 static HRESULT WINAPI video_renderer_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
1288 {
1289     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1290     HRESULT hr = S_OK;
1291
1292     TRACE("%p, %p.\n", iface, count);
1293
1294     if (!count)
1295         return E_POINTER;
1296
1297     EnterCriticalSection(&renderer->cs);
1298     if (renderer->flags & EVR_SHUT_DOWN)
1299         hr = MF_E_SHUTDOWN;
1300     else if (!count)
1301         hr = E_POINTER;
1302     else
1303         *count = renderer->stream_count;
1304     LeaveCriticalSection(&renderer->cs);
1305
1306     return hr;
1307 }
1308
1309 static HRESULT WINAPI video_renderer_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index,
1310         IMFStreamSink **stream)
1311 {
1312     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1313     HRESULT hr = S_OK;
1314
1315     TRACE("%p, %u, %p.\n", iface, index, stream);
1316
1317     EnterCriticalSection(&renderer->cs);
1318     if (renderer->flags & EVR_SHUT_DOWN)
1319         hr = MF_E_SHUTDOWN;
1320     else if (!stream)
1321         hr = E_POINTER;
1322     else if (index >= renderer->stream_count)
1323         hr = E_INVALIDARG;
1324     else
1325     {
1326         *stream = &renderer->streams[index]->IMFStreamSink_iface;
1327         IMFStreamSink_AddRef(*stream);
1328     }
1329     LeaveCriticalSection(&renderer->cs);
1330
1331     return hr;
1332 }
1333
1334 static HRESULT WINAPI video_renderer_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD id,
1335         IMFStreamSink **stream)
1336 {
1337     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1338     HRESULT hr = S_OK;
1339     size_t i;
1340
1341     TRACE("%p, %#x, %p.\n", iface, id, stream);
1342
1343     EnterCriticalSection(&renderer->cs);
1344     if (renderer->flags & EVR_SHUT_DOWN)
1345         hr = MF_E_SHUTDOWN;
1346     else if (!stream)
1347         hr = E_POINTER;
1348     else
1349     {
1350         for (i = 0; i < renderer->stream_count; ++i)
1351         {
1352             if (renderer->streams[i]->id == id)
1353                 break;
1354         }
1355
1356         if (i == renderer->stream_count)
1357             hr = MF_E_INVALIDSTREAMNUMBER;
1358         else
1359         {
1360             *stream = &renderer->streams[i]->IMFStreamSink_iface;
1361             IMFStreamSink_AddRef(*stream);
1362         }
1363     }
1364     LeaveCriticalSection(&renderer->cs);
1365
1366     return hr;
1367 }
1368
1369 static void video_renderer_set_presentation_clock(struct video_renderer *renderer, IMFPresentationClock *clock)
1370 {
1371     if (renderer->clock)
1372     {
1373         IMFPresentationClock_RemoveClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
1374         IMFPresentationClock_Release(renderer->clock);
1375     }
1376     video_renderer_release_presenter_services(renderer);
1377
1378     renderer->clock = clock;
1379     if (renderer->clock)
1380     {
1381         IMFPresentationClock_AddRef(renderer->clock);
1382         IMFPresentationClock_AddClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
1383     }
1384     video_renderer_init_presenter_services(renderer);
1385 }
1386
1387 static HRESULT WINAPI video_renderer_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
1388 {
1389     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1390     HRESULT hr = S_OK;
1391
1392     TRACE("%p, %p.\n", iface, clock);
1393
1394     EnterCriticalSection(&renderer->cs);
1395
1396     if (renderer->flags & EVR_SHUT_DOWN)
1397         hr = MF_E_SHUTDOWN;
1398     else
1399         video_renderer_set_presentation_clock(renderer, clock);
1400
1401     LeaveCriticalSection(&renderer->cs);
1402
1403     return hr;
1404 }
1405
1406 static HRESULT WINAPI video_renderer_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
1407 {
1408     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1409     HRESULT hr = S_OK;
1410
1411     TRACE("%p, %p.\n", iface, clock);
1412
1413     if (!clock)
1414         return E_POINTER;
1415
1416     EnterCriticalSection(&renderer->cs);
1417
1418     if (renderer->flags & EVR_SHUT_DOWN)
1419         hr = MF_E_SHUTDOWN;
1420     else if (renderer->clock)
1421     {
1422         *clock = renderer->clock;
1423         IMFPresentationClock_AddRef(*clock);
1424     }
1425     else
1426         hr = MF_E_NO_CLOCK;
1427
1428     LeaveCriticalSection(&renderer->cs);
1429
1430     return hr;
1431 }
1432
1433 static HRESULT WINAPI video_renderer_sink_Shutdown(IMFMediaSink *iface)
1434 {
1435     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1436     size_t i;
1437
1438     TRACE("%p.\n", iface);
1439
1440     if (renderer->flags & EVR_SHUT_DOWN)
1441         return MF_E_SHUTDOWN;
1442
1443     EnterCriticalSection(&renderer->cs);
1444     renderer->flags |= EVR_SHUT_DOWN;
1445     /* Detach streams from the sink. */
1446     for (i = 0; i < renderer->stream_count; ++i)
1447     {
1448         struct video_stream *stream = renderer->streams[i];
1449
1450         EnterCriticalSection(&stream->cs);
1451         stream->parent = NULL;
1452         LeaveCriticalSection(&stream->cs);
1453
1454         IMFMediaEventQueue_Shutdown(stream->event_queue);
1455         IMFStreamSink_Release(&stream->IMFStreamSink_iface);
1456         IMFMediaSink_Release(iface);
1457         renderer->streams[i] = NULL;
1458     }
1459     free(renderer->streams);
1460     renderer->stream_count = 0;
1461     renderer->stream_size = 0;
1462     IMFMediaEventQueue_Shutdown(renderer->event_queue);
1463     video_renderer_set_presentation_clock(renderer, NULL);
1464     video_renderer_release_services(renderer);
1465     LeaveCriticalSection(&renderer->cs);
1466
1467     return S_OK;
1468 }
1469
1470 static const IMFMediaSinkVtbl video_renderer_sink_vtbl =
1471 {
1472     video_renderer_sink_QueryInterface,
1473     video_renderer_sink_AddRef,
1474     video_renderer_sink_Release,
1475     video_renderer_sink_GetCharacteristics,
1476     video_renderer_sink_AddStreamSink,
1477     video_renderer_sink_RemoveStreamSink,
1478     video_renderer_sink_GetStreamSinkCount,
1479     video_renderer_sink_GetStreamSinkByIndex,
1480     video_renderer_sink_GetStreamSinkById,
1481     video_renderer_sink_SetPresentationClock,
1482     video_renderer_sink_GetPresentationClock,
1483     video_renderer_sink_Shutdown,
1484 };
1485
1486 static HRESULT WINAPI video_renderer_preroll_QueryInterface(IMFMediaSinkPreroll *iface, REFIID riid, void **obj)
1487 {
1488     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1489     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1490 }
1491
1492 static ULONG WINAPI video_renderer_preroll_AddRef(IMFMediaSinkPreroll *iface)
1493 {
1494     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1495     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1496 }
1497
1498 static ULONG WINAPI video_renderer_preroll_Release(IMFMediaSinkPreroll *iface)
1499 {
1500     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1501     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1502 }
1503
1504 static HRESULT WINAPI video_renderer_preroll_NotifyPreroll(IMFMediaSinkPreroll *iface, MFTIME start_time)
1505 {
1506     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1507     HRESULT hr = S_OK;
1508     size_t i;
1509
1510     TRACE("%p, %s.\n", iface, debugstr_time(start_time));
1511
1512     EnterCriticalSection(&renderer->cs);
1513     if (renderer->flags & EVR_SHUT_DOWN)
1514         hr = MF_E_SHUTDOWN;
1515     else
1516     {
1517         for (i = 0; i < renderer->stream_count; ++i)
1518         {
1519             struct video_stream *stream = renderer->streams[i];
1520
1521             EnterCriticalSection(&stream->cs);
1522             if (!(stream->flags & (EVR_STREAM_PREROLLING | EVR_STREAM_PREROLLED)))
1523             {
1524                 IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkRequestSample,
1525                         &GUID_NULL, S_OK, NULL);
1526                 stream->flags |= EVR_STREAM_PREROLLING;
1527             }
1528             LeaveCriticalSection(&stream->cs);
1529         }
1530     }
1531     LeaveCriticalSection(&renderer->cs);
1532
1533     return hr;
1534 }
1535
1536 static const IMFMediaSinkPrerollVtbl video_renderer_preroll_vtbl =
1537 {
1538     video_renderer_preroll_QueryInterface,
1539     video_renderer_preroll_AddRef,
1540     video_renderer_preroll_Release,
1541     video_renderer_preroll_NotifyPreroll,
1542 };
1543
1544 static HRESULT WINAPI video_renderer_QueryInterface(IMFVideoRenderer *iface, REFIID riid, void **obj)
1545 {
1546     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1547     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1548 }
1549
1550 static ULONG WINAPI video_renderer_AddRef(IMFVideoRenderer *iface)
1551 {
1552     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1553     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1554 }
1555
1556 static ULONG WINAPI video_renderer_Release(IMFVideoRenderer *iface)
1557 {
1558     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1559     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1560 }
1561
1562 static HRESULT video_renderer_create_mixer(IMFAttributes *attributes, IMFTransform **out)
1563 {
1564     unsigned int flags = 0;
1565     IMFActivate *activate;
1566     CLSID clsid;
1567     HRESULT hr;
1568
1569     if (attributes && SUCCEEDED(hr = IMFAttributes_GetUnknown(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_ACTIVATE,
1570             &IID_IMFActivate, (void **)&activate)))
1571     {
1572         IMFAttributes_GetUINT32(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_FLAGS, &flags);
1573         hr = IMFActivate_ActivateObject(activate, &IID_IMFTransform, (void **)out);
1574         IMFActivate_Release(activate);
1575         if (SUCCEEDED(hr) || !(flags & MF_ACTIVATE_CUSTOM_MIXER_ALLOWFAIL))
1576             return hr;
1577     }
1578
1579     if (!attributes || FAILED(IMFAttributes_GetGUID(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_CLSID, &clsid)))
1580         memcpy(&clsid, &CLSID_MFVideoMixer9, sizeof(clsid));
1581
1582     return CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTransform, (void **)out);
1583 }
1584
1585 static HRESULT video_renderer_create_presenter(struct video_renderer *renderer, IMFAttributes *attributes,
1586         IMFVideoPresenter **out)
1587 {
1588     unsigned int flags = 0;
1589     IMFActivate *activate;
1590     UINT64 value;
1591     CLSID clsid;
1592     HRESULT hr;
1593
1594     if (attributes && SUCCEEDED(IMFAttributes_GetUINT64(attributes, &MF_ACTIVATE_VIDEO_WINDOW, &value)))
1595         renderer->window = UlongToHandle(value);
1596
1597     if (attributes && SUCCEEDED(IMFAttributes_GetUnknown(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE,
1598             &IID_IMFActivate, (void **)&activate)))
1599     {
1600         IMFAttributes_GetUINT32(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_FLAGS, &flags);
1601         hr = IMFActivate_ActivateObject(activate, &IID_IMFVideoPresenter, (void **)out);
1602         IMFActivate_Release(activate);
1603         if (SUCCEEDED(hr) || !(flags & MF_ACTIVATE_CUSTOM_PRESENTER_ALLOWFAIL))
1604             return hr;
1605     }
1606
1607     if (!attributes || FAILED(IMFAttributes_GetGUID(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID, &clsid)))
1608         memcpy(&clsid, &CLSID_MFVideoPresenter9, sizeof(clsid));
1609
1610     return CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFVideoPresenter, (void **)out);
1611 }
1612
1613 static HRESULT video_renderer_configure_mixer(struct video_renderer *renderer)
1614 {
1615     IMFTopologyServiceLookupClient *lookup_client;
1616     HRESULT hr;
1617
1618     if (SUCCEEDED(hr = IMFTransform_QueryInterface(renderer->mixer, &IID_IMFTopologyServiceLookupClient,
1619             (void **)&lookup_client)))
1620     {
1621         renderer->flags |= EVR_INIT_SERVICES;
1622         if (SUCCEEDED(hr = IMFTopologyServiceLookupClient_InitServicePointers(lookup_client,
1623                 &renderer->IMFTopologyServiceLookup_iface)))
1624         {
1625             renderer->flags |= EVR_MIXER_INITED_SERVICES;
1626         }
1627         renderer->flags &= ~EVR_INIT_SERVICES;
1628         IMFTopologyServiceLookupClient_Release(lookup_client);
1629     }
1630
1631     if (SUCCEEDED(hr))
1632     {
1633         unsigned int input_count, output_count;
1634         unsigned int *ids, *oids;
1635         size_t i;
1636
1637         /* Create stream sinks for inputs that mixer already has by default. */
1638         if (SUCCEEDED(IMFTransform_GetStreamCount(renderer->mixer, &input_count, &output_count)))
1639         {
1640             ids = calloc(input_count, sizeof(*ids));
1641             oids = calloc(output_count, sizeof(*oids));
1642
1643             if (ids && oids)
1644             {
1645                 if (SUCCEEDED(IMFTransform_GetStreamIDs(renderer->mixer, input_count, ids, output_count, oids)))
1646                 {
1647                     for (i = 0; i < input_count; ++i)
1648                     {
1649                         video_renderer_add_stream(renderer, ids[i], NULL);
1650                     }
1651                 }
1652
1653             }
1654
1655             free(ids);
1656             free(oids);
1657         }
1658     }
1659
1660     /* Set device manager that presenter should have created. */
1661     if (video_renderer_is_mixer_d3d_aware(renderer))
1662     {
1663         IDirect3DDeviceManager9 *device_manager;
1664
1665         if (SUCCEEDED(MFGetService((IUnknown *)renderer->presenter, &MR_VIDEO_ACCELERATION_SERVICE,
1666                 &IID_IDirect3DDeviceManager9, (void **)&device_manager)))
1667         {
1668             IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_SET_D3D_MANAGER, (ULONG_PTR)device_manager);
1669             IDirect3DDeviceManager9_Release(device_manager);
1670         }
1671     }
1672
1673     return hr;
1674 }
1675
1676 static HRESULT video_renderer_configure_presenter(struct video_renderer *renderer)
1677 {
1678     IMFVideoDisplayControl *control;
1679     RECT rect = { 0 };
1680     HRESULT hr;
1681
1682     if (SUCCEEDED(IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFVideoDisplayControl, (void **)&control)))
1683     {
1684         GetClientRect(renderer->window, &rect);
1685
1686         if (SUCCEEDED(hr = IMFVideoDisplayControl_SetVideoWindow(control, renderer->window)))
1687             hr = IMFVideoDisplayControl_SetVideoPosition(control, NULL, &rect);
1688         IMFVideoDisplayControl_Release(control);
1689     }
1690
1691     hr = video_renderer_init_presenter_services(renderer);
1692
1693     if (FAILED(MFGetService((IUnknown *)renderer->presenter, &MR_VIDEO_ACCELERATION_SERVICE,
1694             &IID_IUnknown, (void **)&renderer->device_manager)))
1695     {
1696         WARN("Failed to get device manager from the presenter.\n");
1697     }
1698
1699     return hr;
1700 }
1701
1702 static HRESULT video_renderer_initialize(struct video_renderer *renderer, IMFTransform *mixer,
1703         IMFVideoPresenter *presenter)
1704 {
1705     HRESULT hr;
1706
1707     if (renderer->mixer)
1708     {
1709         IMFTransform_Release(renderer->mixer);
1710         renderer->mixer = NULL;
1711     }
1712
1713     if (renderer->presenter)
1714     {
1715         IMFVideoPresenter_Release(renderer->presenter);
1716         renderer->presenter = NULL;
1717     }
1718
1719     if (renderer->device_manager)
1720     {
1721         IUnknown_Release(renderer->device_manager);
1722         renderer->device_manager = NULL;
1723     }
1724
1725     renderer->mixer = mixer;
1726     IMFTransform_AddRef(renderer->mixer);
1727
1728     renderer->presenter = presenter;
1729     IMFVideoPresenter_AddRef(renderer->presenter);
1730
1731     if (SUCCEEDED(hr = video_renderer_configure_mixer(renderer)))
1732         hr = video_renderer_configure_presenter(renderer);
1733
1734     return hr;
1735 }
1736
1737 static HRESULT WINAPI video_renderer_InitializeRenderer(IMFVideoRenderer *iface, IMFTransform *mixer,
1738         IMFVideoPresenter *presenter)
1739 {
1740     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1741     HRESULT hr;
1742
1743     TRACE("%p, %p, %p.\n", iface, mixer, presenter);
1744
1745     if (mixer)
1746         IMFTransform_AddRef(mixer);
1747     else if (FAILED(hr = video_renderer_create_mixer(NULL, &mixer)))
1748     {
1749         WARN("Failed to create default mixer object, hr %#x.\n", hr);
1750         return hr;
1751     }
1752
1753     if (presenter)
1754         IMFVideoPresenter_AddRef(presenter);
1755     else if (FAILED(hr = video_renderer_create_presenter(renderer, NULL, &presenter)))
1756     {
1757         WARN("Failed to create default presenter, hr %#x.\n", hr);
1758         IMFTransform_Release(mixer);
1759         return hr;
1760     }
1761
1762     EnterCriticalSection(&renderer->cs);
1763
1764     if (renderer->flags & EVR_SHUT_DOWN)
1765         hr = MF_E_SHUTDOWN;
1766     else
1767     {
1768         /* FIXME: check clock state */
1769         /* FIXME: check that streams are not initialized */
1770
1771         hr = video_renderer_initialize(renderer, mixer, presenter);
1772     }
1773
1774     LeaveCriticalSection(&renderer->cs);
1775
1776     IMFTransform_Release(mixer);
1777     IMFVideoPresenter_Release(presenter);
1778
1779     return hr;
1780 }
1781
1782 static const IMFVideoRendererVtbl video_renderer_vtbl =
1783 {
1784     video_renderer_QueryInterface,
1785     video_renderer_AddRef,
1786     video_renderer_Release,
1787     video_renderer_InitializeRenderer,
1788 };
1789
1790 static HRESULT WINAPI video_renderer_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
1791 {
1792     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1793     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1794 }
1795
1796 static ULONG WINAPI video_renderer_events_AddRef(IMFMediaEventGenerator *iface)
1797 {
1798     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1799     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1800 }
1801
1802 static ULONG WINAPI video_renderer_events_Release(IMFMediaEventGenerator *iface)
1803 {
1804     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1805     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1806 }
1807
1808 static HRESULT WINAPI video_renderer_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
1809 {
1810     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1811
1812     TRACE("%p, %#x, %p.\n", iface, flags, event);
1813
1814     return IMFMediaEventQueue_GetEvent(renderer->event_queue, flags, event);
1815 }
1816
1817 static HRESULT WINAPI video_renderer_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
1818         IUnknown *state)
1819 {
1820     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1821
1822     TRACE("%p, %p, %p.\n", iface, callback, state);
1823
1824     return IMFMediaEventQueue_BeginGetEvent(renderer->event_queue, callback, state);
1825 }
1826
1827 static HRESULT WINAPI video_renderer_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
1828         IMFMediaEvent **event)
1829 {
1830     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1831
1832     TRACE("%p, %p, %p.\n", iface, result, event);
1833
1834     return IMFMediaEventQueue_EndGetEvent(renderer->event_queue, result, event);
1835 }
1836
1837 static HRESULT WINAPI video_renderer_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
1838         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
1839 {
1840     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1841
1842     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
1843
1844     return IMFMediaEventQueue_QueueEventParamVar(renderer->event_queue, event_type, ext_type, hr, value);
1845 }
1846
1847 static const IMFMediaEventGeneratorVtbl video_renderer_events_vtbl =
1848 {
1849     video_renderer_events_QueryInterface,
1850     video_renderer_events_AddRef,
1851     video_renderer_events_Release,
1852     video_renderer_events_GetEvent,
1853     video_renderer_events_BeginGetEvent,
1854     video_renderer_events_EndGetEvent,
1855     video_renderer_events_QueueEvent,
1856 };
1857
1858 static HRESULT WINAPI video_renderer_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
1859 {
1860     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1861     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1862 }
1863
1864 static ULONG WINAPI video_renderer_clock_sink_AddRef(IMFClockStateSink *iface)
1865 {
1866     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1867     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1868 }
1869
1870 static ULONG WINAPI video_renderer_clock_sink_Release(IMFClockStateSink *iface)
1871 {
1872     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1873     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1874 }
1875
1876 static HRESULT WINAPI video_renderer_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
1877 {
1878     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1879     unsigned int state, request_sample;
1880     size_t i;
1881
1882     TRACE("%p, %s, %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
1883
1884     EnterCriticalSection(&renderer->cs);
1885
1886     state = renderer->state;
1887
1888     /* Update sink state before sending sample requests, to avoid potentially receiving new sample in stopped state */
1889     renderer->state = EVR_STATE_RUNNING;
1890
1891     if (state == EVR_STATE_STOPPED)
1892     {
1893         IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
1894         IMFVideoPresenter_ProcessMessage(renderer->presenter, MFVP_MESSAGE_BEGINSTREAMING, 0);
1895
1896         for (i = 0; i < renderer->stream_count; ++i)
1897         {
1898             struct video_stream *stream = renderer->streams[i];
1899
1900             EnterCriticalSection(&stream->cs);
1901             request_sample = !(stream->flags & EVR_STREAM_PREROLLED) || (stream->flags & EVR_STREAM_SAMPLE_NEEDED);
1902             stream->flags |= EVR_STREAM_PREROLLED;
1903             stream->flags &= ~EVR_STREAM_SAMPLE_NEEDED;
1904             LeaveCriticalSection(&stream->cs);
1905
1906             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkStarted, &GUID_NULL, S_OK, NULL);
1907             if (request_sample)
1908                 IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkRequestSample,
1909                         &GUID_NULL, S_OK, NULL);
1910         }
1911     }
1912
1913     IMFVideoPresenter_OnClockStart(renderer->presenter, systime, offset);
1914
1915     LeaveCriticalSection(&renderer->cs);
1916
1917     return S_OK;
1918 }
1919
1920 static HRESULT WINAPI video_renderer_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
1921 {
1922     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1923     size_t i;
1924
1925     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1926
1927     EnterCriticalSection(&renderer->cs);
1928
1929     IMFVideoPresenter_OnClockStop(renderer->presenter, systime);
1930
1931     IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_COMMAND_FLUSH, 0);
1932     IMFVideoPresenter_ProcessMessage(renderer->presenter, MFVP_MESSAGE_FLUSH, 0);
1933
1934     if (renderer->state == EVR_STATE_RUNNING ||
1935             renderer->state == EVR_STATE_PAUSED)
1936     {
1937         IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_NOTIFY_END_STREAMING, 0);
1938         IMFVideoPresenter_ProcessMessage(renderer->presenter, MFVP_MESSAGE_ENDSTREAMING, 0);
1939
1940         for (i = 0; i < renderer->stream_count; ++i)
1941         {
1942             struct video_stream *stream = renderer->streams[i];
1943             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkStopped, &GUID_NULL, S_OK, NULL);
1944
1945             EnterCriticalSection(&stream->cs);
1946             stream->flags &= ~(EVR_STREAM_PREROLLED | EVR_STREAM_SAMPLE_NEEDED);
1947             LeaveCriticalSection(&stream->cs);
1948         }
1949         renderer->state = EVR_STATE_STOPPED;
1950     }
1951
1952     LeaveCriticalSection(&renderer->cs);
1953
1954     return S_OK;
1955 }
1956
1957 static HRESULT WINAPI video_renderer_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
1958 {
1959     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1960     size_t i;
1961
1962     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1963
1964     EnterCriticalSection(&renderer->cs);
1965
1966     IMFVideoPresenter_OnClockPause(renderer->presenter, systime);
1967
1968     if (renderer->state == EVR_STATE_RUNNING)
1969     {
1970         for (i = 0; i < renderer->stream_count; ++i)
1971         {
1972             struct video_stream *stream = renderer->streams[i];
1973             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkPaused, &GUID_NULL, S_OK, NULL);
1974         }
1975     }
1976
1977     renderer->state = EVR_STATE_PAUSED;
1978
1979     LeaveCriticalSection(&renderer->cs);
1980
1981     return S_OK;
1982 }
1983
1984 static HRESULT WINAPI video_renderer_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
1985 {
1986     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1987     size_t i;
1988
1989     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1990
1991     EnterCriticalSection(&renderer->cs);
1992
1993     IMFVideoPresenter_OnClockRestart(renderer->presenter, systime);
1994
1995     for (i = 0; i < renderer->stream_count; ++i)
1996     {
1997         struct video_stream *stream = renderer->streams[i];
1998         IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkStarted, &GUID_NULL, S_OK, NULL);
1999     }
2000     renderer->state = EVR_STATE_RUNNING;
2001
2002     LeaveCriticalSection(&renderer->cs);
2003
2004     return S_OK;
2005 }
2006
2007 static HRESULT WINAPI video_renderer_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
2008 {
2009     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
2010     IMFClockStateSink *sink;
2011
2012     TRACE("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
2013
2014     EnterCriticalSection(&renderer->cs);
2015
2016     IMFVideoPresenter_OnClockSetRate(renderer->presenter, systime, rate);
2017     if (SUCCEEDED(IMFTransform_QueryInterface(renderer->mixer, &IID_IMFClockStateSink, (void **)&sink)))
2018     {
2019         IMFClockStateSink_OnClockSetRate(sink, systime, rate);
2020         IMFClockStateSink_Release(sink);
2021     }
2022
2023     LeaveCriticalSection(&renderer->cs);
2024
2025     return S_OK;
2026 }
2027
2028 static const IMFClockStateSinkVtbl video_renderer_clock_sink_vtbl =
2029 {
2030     video_renderer_clock_sink_QueryInterface,
2031     video_renderer_clock_sink_AddRef,
2032     video_renderer_clock_sink_Release,
2033     video_renderer_clock_sink_OnClockStart,
2034     video_renderer_clock_sink_OnClockStop,
2035     video_renderer_clock_sink_OnClockPause,
2036     video_renderer_clock_sink_OnClockRestart,
2037     video_renderer_clock_sink_OnClockSetRate,
2038 };
2039
2040 static HRESULT WINAPI video_renderer_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
2041 {
2042     struct video_renderer *renderer = impl_from_IMFGetService(iface);
2043     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
2044 }
2045
2046 static ULONG WINAPI video_renderer_get_service_AddRef(IMFGetService *iface)
2047 {
2048     struct video_renderer *renderer = impl_from_IMFGetService(iface);
2049     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2050 }
2051
2052 static ULONG WINAPI video_renderer_get_service_Release(IMFGetService *iface)
2053 {
2054     struct video_renderer *renderer = impl_from_IMFGetService(iface);
2055     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2056 }
2057
2058 static HRESULT WINAPI video_renderer_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
2059 {
2060     struct video_renderer *renderer = impl_from_IMFGetService(iface);
2061     HRESULT hr = E_NOINTERFACE;
2062     IMFGetService *gs = NULL;
2063
2064     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
2065
2066     EnterCriticalSection(&renderer->cs);
2067
2068     if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE))
2069     {
2070         hr = IMFTransform_QueryInterface(renderer->mixer, &IID_IMFGetService, (void **)&gs);
2071     }
2072     else if (IsEqualGUID(service, &MR_VIDEO_RENDER_SERVICE))
2073     {
2074         hr = IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFGetService, (void **)&gs);
2075     }
2076     else if (IsEqualGUID(service, &MR_VIDEO_ACCELERATION_SERVICE) && IsEqualIID(riid, &IID_IDirect3DDeviceManager9))
2077     {
2078         if (renderer->device_manager)
2079             hr = IUnknown_QueryInterface(renderer->device_manager, riid, obj);
2080     }
2081     else if (IsEqualGUID(service, &MF_RATE_CONTROL_SERVICE) && IsEqualIID(riid, &IID_IMFRateSupport))
2082     {
2083         hr = IMFVideoRenderer_QueryInterface(&renderer->IMFVideoRenderer_iface, riid, obj);
2084     }
2085     else
2086     {
2087         FIXME("Unsupported service %s.\n", debugstr_guid(service));
2088     }
2089
2090     LeaveCriticalSection(&renderer->cs);
2091
2092     if (gs)
2093     {
2094         hr = IMFGetService_GetService(gs, service, riid, obj);
2095         IMFGetService_Release(gs);
2096     }
2097
2098     return hr;
2099 }
2100
2101 static const IMFGetServiceVtbl video_renderer_get_service_vtbl =
2102 {
2103     video_renderer_get_service_QueryInterface,
2104     video_renderer_get_service_AddRef,
2105     video_renderer_get_service_Release,
2106     video_renderer_get_service_GetService,
2107 };
2108
2109 static HRESULT WINAPI video_renderer_service_lookup_QueryInterface(IMFTopologyServiceLookup *iface, REFIID riid, void **obj)
2110 {
2111     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
2112
2113     if (IsEqualIID(riid, &IID_IMFTopologyServiceLookup) ||
2114             IsEqualIID(riid, &IID_IUnknown))
2115     {
2116         *obj = iface;
2117         IMFTopologyServiceLookup_AddRef(iface);
2118         return S_OK;
2119     }
2120
2121     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
2122     *obj = NULL;
2123     return E_NOINTERFACE;
2124 }
2125
2126 static ULONG WINAPI video_renderer_service_lookup_AddRef(IMFTopologyServiceLookup *iface)
2127 {
2128     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
2129     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2130 }
2131
2132 static ULONG WINAPI video_renderer_service_lookup_Release(IMFTopologyServiceLookup *iface)
2133 {
2134     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
2135     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2136 }
2137
2138 static HRESULT WINAPI video_renderer_service_lookup_LookupService(IMFTopologyServiceLookup *iface,
2139         MF_SERVICE_LOOKUP_TYPE lookup_type, DWORD index, REFGUID service, REFIID riid,
2140         void **objects, DWORD *num_objects)
2141 {
2142     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
2143     HRESULT hr = S_OK;
2144
2145     TRACE("%p, %u, %u, %s, %s, %p, %p.\n", iface, lookup_type, index, debugstr_guid(service), debugstr_guid(riid),
2146             objects, num_objects);
2147
2148     EnterCriticalSection(&renderer->cs);
2149
2150     if (!(renderer->flags & EVR_INIT_SERVICES))
2151         hr = MF_E_NOTACCEPTING;
2152     else if (IsEqualGUID(service, &MR_VIDEO_RENDER_SERVICE))
2153     {
2154         if (IsEqualIID(riid, &IID_IMediaEventSink))
2155         {
2156             *objects = &renderer->IMediaEventSink_iface;
2157             IUnknown_AddRef((IUnknown *)*objects);
2158         }
2159         else if (IsEqualIID(riid, &IID_IMFClock))
2160         {
2161             *objects = renderer->clock;
2162             if (*objects)
2163                 IUnknown_AddRef((IUnknown *)*objects);
2164             hr = *objects ? S_OK : E_NOINTERFACE;
2165         }
2166         else
2167         {
2168             FIXME("Unsupported interface %s for render service.\n", debugstr_guid(riid));
2169             hr = E_NOINTERFACE;
2170         }
2171     }
2172     else if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE))
2173     {
2174         if (IsEqualIID(riid, &IID_IMFTransform))
2175         {
2176             *objects = renderer->mixer;
2177             IUnknown_AddRef((IUnknown *)*objects);
2178         }
2179         else
2180         {
2181             FIXME("Unsupported interface %s for mixer service.\n", debugstr_guid(riid));
2182             hr = E_NOINTERFACE;
2183         }
2184     }
2185     else
2186     {
2187         WARN("Unsupported service %s.\n", debugstr_guid(service));
2188         hr = MF_E_UNSUPPORTED_SERVICE;
2189     }
2190
2191     LeaveCriticalSection(&renderer->cs);
2192
2193     return hr;
2194 }
2195
2196 static const IMFTopologyServiceLookupVtbl video_renderer_service_lookup_vtbl =
2197 {
2198     video_renderer_service_lookup_QueryInterface,
2199     video_renderer_service_lookup_AddRef,
2200     video_renderer_service_lookup_Release,
2201     video_renderer_service_lookup_LookupService,
2202 };
2203
2204 static HRESULT WINAPI video_renderer_event_sink_QueryInterface(IMediaEventSink *iface, REFIID riid, void **obj)
2205 {
2206     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
2207
2208     if (IsEqualIID(riid, &IID_IMediaEventSink) ||
2209             IsEqualIID(riid, &IID_IUnknown))
2210     {
2211         *obj = iface;
2212         IMediaEventSink_AddRef(iface);
2213         return S_OK;
2214     }
2215
2216     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
2217     *obj = NULL;
2218     return E_NOINTERFACE;
2219 }
2220
2221 static ULONG WINAPI video_renderer_event_sink_AddRef(IMediaEventSink *iface)
2222 {
2223     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
2224     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2225 }
2226
2227 static ULONG WINAPI video_renderer_event_sink_Release(IMediaEventSink *iface)
2228 {
2229     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
2230     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2231 }
2232
2233 static HRESULT WINAPI video_renderer_event_sink_Notify(IMediaEventSink *iface, LONG event, LONG_PTR param1, LONG_PTR param2)
2234 {
2235     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
2236     HRESULT hr = S_OK;
2237     unsigned int idx;
2238
2239     TRACE("%p, %d, %ld, %ld.\n", iface, event, param1, param2);
2240
2241     EnterCriticalSection(&renderer->cs);
2242
2243     if (event == EC_SAMPLE_NEEDED)
2244     {
2245         idx = param1;
2246         if (idx >= renderer->stream_count)
2247             hr = MF_E_INVALIDSTREAMNUMBER;
2248         else if (renderer->state == EVR_STATE_RUNNING)
2249         {
2250             hr = IMFMediaEventQueue_QueueEventParamVar(renderer->streams[idx]->event_queue,
2251                 MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
2252         }
2253         else
2254         {
2255             /* Mixer asks for more input right after preroll too, before renderer finished running state transition.
2256                Mark such streams here, and issue requests later in OnClockStart(). */
2257             renderer->streams[idx]->flags |= EVR_STREAM_SAMPLE_NEEDED;
2258         }
2259     }
2260     else if (event == EC_DISPLAY_CHANGED)
2261     {
2262         for (idx = 0; idx < renderer->stream_count; ++idx)
2263             IMFMediaEventQueue_QueueEventParamVar(renderer->streams[idx]->event_queue,
2264                     MEStreamSinkDeviceChanged, &GUID_NULL, S_OK, NULL);
2265     }
2266     else if (event >= EC_USER)
2267     {
2268         PROPVARIANT code;
2269
2270         code.vt = VT_I4;
2271         code.lVal = event;
2272         hr = IMFMediaEventQueue_QueueEventParamVar(renderer->event_queue, MERendererEvent,
2273                 &GUID_NULL, S_OK, &code);
2274     }
2275     else
2276     {
2277         WARN("Unhandled event %d.\n", event);
2278         hr = MF_E_UNEXPECTED;
2279     }
2280
2281     LeaveCriticalSection(&renderer->cs);
2282
2283     return hr;
2284 }
2285
2286 static const IMediaEventSinkVtbl media_event_sink_vtbl =
2287 {
2288     video_renderer_event_sink_QueryInterface,
2289     video_renderer_event_sink_AddRef,
2290     video_renderer_event_sink_Release,
2291     video_renderer_event_sink_Notify,
2292 };
2293
2294 static HRESULT WINAPI video_renderer_attributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **obj)
2295 {
2296     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2297     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
2298 }
2299
2300 static ULONG WINAPI video_renderer_attributes_AddRef(IMFAttributes *iface)
2301 {
2302     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2303     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2304 }
2305
2306 static ULONG WINAPI video_renderer_attributes_Release(IMFAttributes *iface)
2307 {
2308     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2309     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2310 }
2311
2312 static HRESULT WINAPI video_renderer_attributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
2313 {
2314     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2315
2316     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2317
2318     return IMFAttributes_GetItem(renderer->attributes, key, value);
2319 }
2320
2321 static HRESULT WINAPI video_renderer_attributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
2322 {
2323     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2324
2325     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
2326
2327     return IMFAttributes_GetItemType(renderer->attributes, key, type);
2328 }
2329
2330 static HRESULT WINAPI video_renderer_attributes_CompareItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value,
2331         BOOL *result)
2332 {
2333     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2334
2335     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
2336
2337     return IMFAttributes_CompareItem(renderer->attributes, key, value, result);
2338 }
2339
2340 static HRESULT WINAPI video_renderer_attributes_Compare(IMFAttributes *iface, IMFAttributes *theirs,
2341         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
2342 {
2343     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2344
2345     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
2346
2347     return IMFAttributes_Compare(renderer->attributes, theirs, type, result);
2348 }
2349
2350 static HRESULT WINAPI video_renderer_attributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
2351 {
2352     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2353
2354     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2355
2356     return IMFAttributes_GetUINT32(renderer->attributes, key, value);
2357 }
2358
2359 static HRESULT WINAPI video_renderer_attributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
2360 {
2361     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2362
2363     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2364
2365     return IMFAttributes_GetUINT64(renderer->attributes, key, value);
2366 }
2367
2368 static HRESULT WINAPI video_renderer_attributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
2369 {
2370     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2371
2372     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2373
2374     return IMFAttributes_GetDouble(renderer->attributes, key, value);
2375 }
2376
2377 static HRESULT WINAPI video_renderer_attributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
2378 {
2379     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2380
2381     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2382
2383     return IMFAttributes_GetGUID(renderer->attributes, key, value);
2384 }
2385
2386 static HRESULT WINAPI video_renderer_attributes_GetStringLength(IMFAttributes *iface, REFGUID key,
2387         UINT32 *length)
2388 {
2389     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2390
2391     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
2392
2393     return IMFAttributes_GetStringLength(renderer->attributes, key, length);
2394 }
2395
2396 static HRESULT WINAPI video_renderer_attributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
2397         UINT32 size, UINT32 *length)
2398 {
2399     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2400
2401     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), value, size, length);
2402
2403     return IMFAttributes_GetString(renderer->attributes, key, value, size, length);
2404 }
2405
2406 static HRESULT WINAPI video_renderer_attributes_GetAllocatedString(IMFAttributes *iface, REFGUID key,
2407         WCHAR **value, UINT32 *length)
2408 {
2409     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2410
2411     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
2412
2413     return IMFAttributes_GetAllocatedString(renderer->attributes, key, value, length);
2414 }
2415
2416 static HRESULT WINAPI video_renderer_attributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
2417 {
2418     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2419
2420     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
2421
2422     return IMFAttributes_GetBlobSize(renderer->attributes, key, size);
2423 }
2424
2425 static HRESULT WINAPI video_renderer_attributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
2426          UINT32 bufsize, UINT32 *blobsize)
2427 {
2428     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2429
2430     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
2431
2432     return IMFAttributes_GetBlob(renderer->attributes, key, buf, bufsize, blobsize);
2433 }
2434
2435 static HRESULT WINAPI video_renderer_attributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key,
2436         UINT8 **buf, UINT32 *size)
2437 {
2438     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2439
2440     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
2441
2442     return IMFAttributes_GetAllocatedBlob(renderer->attributes, key, buf, size);
2443 }
2444
2445 static HRESULT WINAPI video_renderer_attributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **out)
2446 {
2447     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2448
2449     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), out);
2450
2451     return IMFAttributes_GetUnknown(renderer->attributes, key, riid, out);
2452 }
2453
2454 static HRESULT WINAPI video_renderer_attributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value)
2455 {
2456     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2457
2458     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2459
2460     return IMFAttributes_SetItem(renderer->attributes, key, value);
2461 }
2462
2463 static HRESULT WINAPI video_renderer_attributes_DeleteItem(IMFAttributes *iface, REFGUID key)
2464 {
2465     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2466
2467     TRACE("%p, %s.\n", iface, debugstr_guid(key));
2468
2469     return IMFAttributes_DeleteItem(renderer->attributes, key);
2470 }
2471
2472 static HRESULT WINAPI video_renderer_attributes_DeleteAllItems(IMFAttributes *iface)
2473 {
2474     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2475
2476     TRACE("%p.\n", iface);
2477
2478     return IMFAttributes_DeleteAllItems(renderer->attributes);
2479 }
2480
2481 static HRESULT WINAPI video_renderer_attributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
2482 {
2483     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2484
2485     TRACE("%p, %s, %u.\n", iface, debugstr_guid(key), value);
2486
2487     return IMFAttributes_SetUINT32(renderer->attributes, key, value);
2488 }
2489
2490 static HRESULT WINAPI video_renderer_attributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
2491 {
2492     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2493
2494     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
2495
2496     return IMFAttributes_SetUINT64(renderer->attributes, key, value);
2497 }
2498
2499 static HRESULT WINAPI video_renderer_attributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
2500 {
2501     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2502
2503     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
2504
2505     return IMFAttributes_SetDouble(renderer->attributes, key, value);
2506 }
2507
2508 static HRESULT WINAPI video_renderer_attributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
2509 {
2510     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2511
2512     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
2513
2514     return IMFAttributes_SetGUID(renderer->attributes, key, value);
2515 }
2516
2517 static HRESULT WINAPI video_renderer_attributes_SetString(IMFAttributes *iface, REFGUID key,
2518         const WCHAR *value)
2519 {
2520     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2521
2522     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
2523
2524     return IMFAttributes_SetString(renderer->attributes, key, value);
2525 }
2526
2527 static HRESULT WINAPI video_renderer_attributes_SetBlob(IMFAttributes *iface, REFGUID key,
2528         const UINT8 *buf, UINT32 size)
2529 {
2530     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2531
2532     TRACE("%p, %s, %p, %u.\n", iface, debugstr_guid(key), buf, size);
2533
2534     return IMFAttributes_SetBlob(renderer->attributes, key, buf, size);
2535 }
2536
2537 static HRESULT WINAPI video_renderer_attributes_SetUnknown(IMFAttributes *iface, REFGUID key,
2538         IUnknown *unknown)
2539 {
2540     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2541
2542     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), unknown);
2543
2544     return IMFAttributes_SetUnknown(renderer->attributes, key, unknown);
2545 }
2546
2547 static HRESULT WINAPI video_renderer_attributes_LockStore(IMFAttributes *iface)
2548 {
2549     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2550
2551     TRACE("%p.\n", iface);
2552
2553     return IMFAttributes_LockStore(renderer->attributes);
2554 }
2555
2556 static HRESULT WINAPI video_renderer_attributes_UnlockStore(IMFAttributes *iface)
2557 {
2558     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2559
2560     TRACE("%p.\n", iface);
2561
2562     return IMFAttributes_UnlockStore(renderer->attributes);
2563 }
2564
2565 static HRESULT WINAPI video_renderer_attributes_GetCount(IMFAttributes *iface, UINT32 *count)
2566 {
2567     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2568
2569     TRACE("%p, %p.\n", iface, count);
2570
2571     return IMFAttributes_GetCount(renderer->attributes, count);
2572 }
2573
2574 static HRESULT WINAPI video_renderer_attributes_GetItemByIndex(IMFAttributes *iface, UINT32 index,
2575         GUID *key, PROPVARIANT *value)
2576 {
2577     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2578
2579     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
2580
2581     return IMFAttributes_GetItemByIndex(renderer->attributes, index, key, value);
2582 }
2583
2584 static HRESULT WINAPI video_renderer_attributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
2585 {
2586     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2587
2588     TRACE("%p, %p.\n", iface, dest);
2589
2590     return IMFAttributes_CopyAllItems(renderer->attributes, dest);
2591 }
2592
2593 static const IMFAttributesVtbl video_renderer_attributes_vtbl =
2594 {
2595     video_renderer_attributes_QueryInterface,
2596     video_renderer_attributes_AddRef,
2597     video_renderer_attributes_Release,
2598     video_renderer_attributes_GetItem,
2599     video_renderer_attributes_GetItemType,
2600     video_renderer_attributes_CompareItem,
2601     video_renderer_attributes_Compare,
2602     video_renderer_attributes_GetUINT32,
2603     video_renderer_attributes_GetUINT64,
2604     video_renderer_attributes_GetDouble,
2605     video_renderer_attributes_GetGUID,
2606     video_renderer_attributes_GetStringLength,
2607     video_renderer_attributes_GetString,
2608     video_renderer_attributes_GetAllocatedString,
2609     video_renderer_attributes_GetBlobSize,
2610     video_renderer_attributes_GetBlob,
2611     video_renderer_attributes_GetAllocatedBlob,
2612     video_renderer_attributes_GetUnknown,
2613     video_renderer_attributes_SetItem,
2614     video_renderer_attributes_DeleteItem,
2615     video_renderer_attributes_DeleteAllItems,
2616     video_renderer_attributes_SetUINT32,
2617     video_renderer_attributes_SetUINT64,
2618     video_renderer_attributes_SetDouble,
2619     video_renderer_attributes_SetGUID,
2620     video_renderer_attributes_SetString,
2621     video_renderer_attributes_SetBlob,
2622     video_renderer_attributes_SetUnknown,
2623     video_renderer_attributes_LockStore,
2624     video_renderer_attributes_UnlockStore,
2625     video_renderer_attributes_GetCount,
2626     video_renderer_attributes_GetItemByIndex,
2627     video_renderer_attributes_CopyAllItems,
2628 };
2629
2630 static HRESULT WINAPI video_renderer_quality_advise_QueryInterface(IMFQualityAdvise *iface, REFIID riid, void **out)
2631 {
2632     struct video_renderer *renderer = impl_from_IMFQualityAdvise(iface);
2633     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, out);
2634 }
2635
2636 static ULONG WINAPI video_renderer_quality_advise_AddRef(IMFQualityAdvise *iface)
2637 {
2638     struct video_renderer *renderer = impl_from_IMFQualityAdvise(iface);
2639     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2640 }
2641
2642 static ULONG WINAPI video_renderer_quality_Release(IMFQualityAdvise *iface)
2643 {
2644     struct video_renderer *renderer = impl_from_IMFQualityAdvise(iface);
2645     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2646 }
2647
2648 static HRESULT WINAPI video_renderer_quality_advise_SetDropMode(IMFQualityAdvise *iface,
2649         MF_QUALITY_DROP_MODE mode)
2650 {
2651     FIXME("%p, %u.\n", iface, mode);
2652
2653     return E_NOTIMPL;
2654 }
2655
2656 static HRESULT WINAPI video_renderer_quality_advise_SetQualityLevel(IMFQualityAdvise *iface,
2657         MF_QUALITY_LEVEL level)
2658 {
2659     FIXME("%p, %u.\n", iface, level);
2660
2661     return E_NOTIMPL;
2662 }
2663
2664 static HRESULT WINAPI video_renderer_quality_advise_GetDropMode(IMFQualityAdvise *iface,
2665         MF_QUALITY_DROP_MODE *mode)
2666 {
2667     FIXME("%p, %p.\n", iface, mode);
2668
2669     return E_NOTIMPL;
2670 }
2671
2672 static HRESULT WINAPI video_renderer_quality_advise_GetQualityLevel(IMFQualityAdvise *iface,
2673         MF_QUALITY_LEVEL *level)
2674 {
2675     FIXME("%p, %p.\n", iface, level);
2676
2677     return E_NOTIMPL;
2678 }
2679
2680 static HRESULT WINAPI video_renderer_quality_advise_DropTime(IMFQualityAdvise *iface, LONGLONG interval)
2681 {
2682     FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(interval));
2683
2684     return E_NOTIMPL;
2685 }
2686
2687 static const IMFQualityAdviseVtbl video_renderer_quality_advise_vtbl =
2688 {
2689     video_renderer_quality_advise_QueryInterface,
2690     video_renderer_quality_advise_AddRef,
2691     video_renderer_quality_Release,
2692     video_renderer_quality_advise_SetDropMode,
2693     video_renderer_quality_advise_SetQualityLevel,
2694     video_renderer_quality_advise_GetDropMode,
2695     video_renderer_quality_advise_GetQualityLevel,
2696     video_renderer_quality_advise_DropTime,
2697 };
2698
2699 static HRESULT WINAPI video_renderer_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **out)
2700 {
2701     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2702     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, out);
2703 }
2704
2705 static ULONG WINAPI video_renderer_rate_support_AddRef(IMFRateSupport *iface)
2706 {
2707     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2708     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2709 }
2710
2711 static ULONG WINAPI video_renderer_rate_support_Release(IMFRateSupport *iface)
2712 {
2713     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2714     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2715 }
2716
2717 static HRESULT WINAPI video_renderer_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
2718         BOOL thin, float *rate)
2719 {
2720     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2721
2722     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
2723
2724     if (renderer->flags & EVR_SHUT_DOWN)
2725         return MF_E_SHUTDOWN;
2726
2727     *rate = 0.0f;
2728
2729     return S_OK;
2730 }
2731
2732 static HRESULT WINAPI video_renderer_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
2733         BOOL thin, float *rate)
2734 {
2735     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2736
2737     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
2738
2739     return renderer->flags & EVR_SHUT_DOWN ? MF_E_SHUTDOWN : MF_E_INVALIDREQUEST;
2740 }
2741
2742 static HRESULT WINAPI video_renderer_rate_support_IsRateSupported(IMFRateSupport *iface, BOOL thin, float rate,
2743         float *nearest_supported_rate)
2744 {
2745     FIXME("%p, %d, %f, %p.\n", iface, thin, rate, nearest_supported_rate);
2746
2747     return E_NOTIMPL;
2748 }
2749
2750 static const IMFRateSupportVtbl video_renderer_rate_support_vtbl =
2751 {
2752     video_renderer_rate_support_QueryInterface,
2753     video_renderer_rate_support_AddRef,
2754     video_renderer_rate_support_Release,
2755     video_renderer_rate_support_GetSlowestRate,
2756     video_renderer_rate_support_GetFastestRate,
2757     video_renderer_rate_support_IsRateSupported,
2758 };
2759
2760 static HRESULT evr_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj)
2761 {
2762     struct video_renderer *object;
2763     IMFVideoPresenter *presenter = NULL;
2764     IMFTransform *mixer = NULL;
2765     HRESULT hr;
2766
2767     TRACE("%p, %p, %p.\n", attributes, user_context, obj);
2768
2769     if (!(object = calloc(1, sizeof(*object))))
2770         return E_OUTOFMEMORY;
2771
2772     object->IMFMediaSink_iface.lpVtbl = &video_renderer_sink_vtbl;
2773     object->IMFMediaSinkPreroll_iface.lpVtbl = &video_renderer_preroll_vtbl;
2774     object->IMFVideoRenderer_iface.lpVtbl = &video_renderer_vtbl;
2775     object->IMFMediaEventGenerator_iface.lpVtbl = &video_renderer_events_vtbl;
2776     object->IMFClockStateSink_iface.lpVtbl = &video_renderer_clock_sink_vtbl;
2777     object->IMFGetService_iface.lpVtbl = &video_renderer_get_service_vtbl;
2778     object->IMFTopologyServiceLookup_iface.lpVtbl = &video_renderer_service_lookup_vtbl;
2779     object->IMediaEventSink_iface.lpVtbl = &media_event_sink_vtbl;
2780     object->IMFAttributes_iface.lpVtbl = &video_renderer_attributes_vtbl;
2781     object->IMFQualityAdvise_iface.lpVtbl = &video_renderer_quality_advise_vtbl;
2782     object->IMFRateSupport_iface.lpVtbl = &video_renderer_rate_support_vtbl;
2783     object->refcount = 1;
2784     InitializeCriticalSection(&object->cs);
2785
2786     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
2787         goto failed;
2788
2789     if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
2790         goto failed;
2791
2792     /* Create mixer and presenter. */
2793     if (FAILED(hr = video_renderer_create_mixer(attributes, &mixer)))
2794         goto failed;
2795
2796     if (FAILED(hr = video_renderer_create_presenter(object, attributes, &presenter)))
2797         goto failed;
2798
2799     if (FAILED(hr = video_renderer_initialize(object, mixer, presenter)))
2800         goto failed;
2801
2802     IMFTransform_Release(mixer);
2803     IMFVideoPresenter_Release(presenter);
2804
2805     /* Default attributes */
2806     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceBob, 0);
2807     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowDropToBob, 0);
2808     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceThrottle, 0);
2809     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowDropToThrottle, 0);
2810     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceHalfInterlace, 0);
2811     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowDropToHalfInterlace, 0);
2812     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceScaling, 0);
2813     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowScaling, 0);
2814     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceBatching, 0);
2815     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowBatching, 0);
2816
2817     *obj = (IUnknown *)&object->IMFMediaSink_iface;
2818
2819     return S_OK;
2820
2821 failed:
2822
2823     if (mixer)
2824         IMFTransform_Release(mixer);
2825
2826     if (presenter)
2827         IMFVideoPresenter_Release(presenter);
2828
2829     video_renderer_release_services(object);
2830     IMFMediaSink_Release(&object->IMFMediaSink_iface);
2831
2832     return hr;
2833 }
2834
2835 static void evr_shutdown_object(void *user_context, IUnknown *obj)
2836 {
2837     IMFMediaSink *sink;
2838
2839     if (SUCCEEDED(IUnknown_QueryInterface(obj, &IID_IMFMediaSink, (void **)&sink)))
2840     {
2841         IMFMediaSink_Shutdown(sink);
2842         IMFMediaSink_Release(sink);
2843     }
2844 }
2845
2846 static const struct activate_funcs evr_activate_funcs =
2847 {
2848     .create_object = evr_create_object,
2849     .shutdown_object = evr_shutdown_object,
2850 };
2851
2852 /***********************************************************************
2853  *      MFCreateVideoRendererActivate (mf.@)
2854  */
2855 HRESULT WINAPI MFCreateVideoRendererActivate(HWND hwnd, IMFActivate **activate)
2856 {
2857     HRESULT hr;
2858
2859     TRACE("%p, %p.\n", hwnd, activate);
2860
2861     if (!activate)
2862         return E_POINTER;
2863
2864     hr = create_activation_object(NULL, &evr_activate_funcs, activate);
2865     if (SUCCEEDED(hr))
2866         IMFActivate_SetUINT64(*activate, &MF_ACTIVATE_VIDEO_WINDOW, (ULONG_PTR)hwnd);
2867
2868     return hr;
2869 }
2870
2871 /***********************************************************************
2872  *      MFCreateVideoRenderer (mf.@)
2873  */
2874 HRESULT WINAPI MFCreateVideoRenderer(REFIID riid, void **renderer)
2875 {
2876     IUnknown *obj;
2877     HRESULT hr;
2878
2879     TRACE("%s, %p.\n", debugstr_guid(riid), renderer);
2880
2881     *renderer = NULL;
2882
2883     if (SUCCEEDED(hr = evr_create_object(NULL, NULL, &obj)))
2884     {
2885         hr = IUnknown_QueryInterface(obj, riid, renderer);
2886         IUnknown_Release(obj);
2887     }
2888
2889     return hr;
2890 }