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 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     EnterCriticalSection(&renderer->cs);
1295     if (renderer->flags & EVR_SHUT_DOWN)
1296         hr = MF_E_SHUTDOWN;
1297     else if (!count)
1298         hr = E_POINTER;
1299     else
1300         *count = renderer->stream_count;
1301     LeaveCriticalSection(&renderer->cs);
1302
1303     return hr;
1304 }
1305
1306 static HRESULT WINAPI video_renderer_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index,
1307         IMFStreamSink **stream)
1308 {
1309     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1310     HRESULT hr = S_OK;
1311
1312     TRACE("%p, %u, %p.\n", iface, index, stream);
1313
1314     EnterCriticalSection(&renderer->cs);
1315     if (renderer->flags & EVR_SHUT_DOWN)
1316         hr = MF_E_SHUTDOWN;
1317     else if (!stream)
1318         hr = E_POINTER;
1319     else if (index >= renderer->stream_count)
1320         hr = E_INVALIDARG;
1321     else
1322     {
1323         *stream = &renderer->streams[index]->IMFStreamSink_iface;
1324         IMFStreamSink_AddRef(*stream);
1325     }
1326     LeaveCriticalSection(&renderer->cs);
1327
1328     return hr;
1329 }
1330
1331 static HRESULT WINAPI video_renderer_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD id,
1332         IMFStreamSink **stream)
1333 {
1334     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1335     HRESULT hr = S_OK;
1336     size_t i;
1337
1338     TRACE("%p, %#x, %p.\n", iface, id, stream);
1339
1340     EnterCriticalSection(&renderer->cs);
1341     if (renderer->flags & EVR_SHUT_DOWN)
1342         hr = MF_E_SHUTDOWN;
1343     else if (!stream)
1344         hr = E_POINTER;
1345     else
1346     {
1347         for (i = 0; i < renderer->stream_count; ++i)
1348         {
1349             if (renderer->streams[i]->id == id)
1350                 break;
1351         }
1352
1353         if (i == renderer->stream_count)
1354             hr = MF_E_INVALIDSTREAMNUMBER;
1355         else
1356         {
1357             *stream = &renderer->streams[i]->IMFStreamSink_iface;
1358             IMFStreamSink_AddRef(*stream);
1359         }
1360     }
1361     LeaveCriticalSection(&renderer->cs);
1362
1363     return hr;
1364 }
1365
1366 static void video_renderer_set_presentation_clock(struct video_renderer *renderer, IMFPresentationClock *clock)
1367 {
1368     if (renderer->clock)
1369     {
1370         IMFPresentationClock_RemoveClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
1371         IMFPresentationClock_Release(renderer->clock);
1372     }
1373     video_renderer_release_presenter_services(renderer);
1374
1375     renderer->clock = clock;
1376     if (renderer->clock)
1377     {
1378         IMFPresentationClock_AddRef(renderer->clock);
1379         IMFPresentationClock_AddClockStateSink(renderer->clock, &renderer->IMFClockStateSink_iface);
1380     }
1381     video_renderer_init_presenter_services(renderer);
1382 }
1383
1384 static HRESULT WINAPI video_renderer_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
1385 {
1386     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1387     HRESULT hr = S_OK;
1388
1389     TRACE("%p, %p.\n", iface, clock);
1390
1391     EnterCriticalSection(&renderer->cs);
1392
1393     if (renderer->flags & EVR_SHUT_DOWN)
1394         hr = MF_E_SHUTDOWN;
1395     else
1396         video_renderer_set_presentation_clock(renderer, clock);
1397
1398     LeaveCriticalSection(&renderer->cs);
1399
1400     return hr;
1401 }
1402
1403 static HRESULT WINAPI video_renderer_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
1404 {
1405     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1406     HRESULT hr = S_OK;
1407
1408     TRACE("%p, %p.\n", iface, clock);
1409
1410     if (!clock)
1411         return E_POINTER;
1412
1413     EnterCriticalSection(&renderer->cs);
1414
1415     if (renderer->flags & EVR_SHUT_DOWN)
1416         hr = MF_E_SHUTDOWN;
1417     else if (renderer->clock)
1418     {
1419         *clock = renderer->clock;
1420         IMFPresentationClock_AddRef(*clock);
1421     }
1422     else
1423         hr = MF_E_NO_CLOCK;
1424
1425     LeaveCriticalSection(&renderer->cs);
1426
1427     return hr;
1428 }
1429
1430 static HRESULT WINAPI video_renderer_sink_Shutdown(IMFMediaSink *iface)
1431 {
1432     struct video_renderer *renderer = impl_from_IMFMediaSink(iface);
1433     size_t i;
1434
1435     TRACE("%p.\n", iface);
1436
1437     if (renderer->flags & EVR_SHUT_DOWN)
1438         return MF_E_SHUTDOWN;
1439
1440     EnterCriticalSection(&renderer->cs);
1441     renderer->flags |= EVR_SHUT_DOWN;
1442     /* Detach streams from the sink. */
1443     for (i = 0; i < renderer->stream_count; ++i)
1444     {
1445         struct video_stream *stream = renderer->streams[i];
1446
1447         EnterCriticalSection(&stream->cs);
1448         stream->parent = NULL;
1449         LeaveCriticalSection(&stream->cs);
1450
1451         IMFMediaEventQueue_Shutdown(stream->event_queue);
1452         IMFStreamSink_Release(&stream->IMFStreamSink_iface);
1453         IMFMediaSink_Release(iface);
1454         renderer->streams[i] = NULL;
1455     }
1456     free(renderer->streams);
1457     renderer->stream_count = 0;
1458     renderer->stream_size = 0;
1459     IMFMediaEventQueue_Shutdown(renderer->event_queue);
1460     video_renderer_set_presentation_clock(renderer, NULL);
1461     video_renderer_release_services(renderer);
1462     LeaveCriticalSection(&renderer->cs);
1463
1464     return S_OK;
1465 }
1466
1467 static const IMFMediaSinkVtbl video_renderer_sink_vtbl =
1468 {
1469     video_renderer_sink_QueryInterface,
1470     video_renderer_sink_AddRef,
1471     video_renderer_sink_Release,
1472     video_renderer_sink_GetCharacteristics,
1473     video_renderer_sink_AddStreamSink,
1474     video_renderer_sink_RemoveStreamSink,
1475     video_renderer_sink_GetStreamSinkCount,
1476     video_renderer_sink_GetStreamSinkByIndex,
1477     video_renderer_sink_GetStreamSinkById,
1478     video_renderer_sink_SetPresentationClock,
1479     video_renderer_sink_GetPresentationClock,
1480     video_renderer_sink_Shutdown,
1481 };
1482
1483 static HRESULT WINAPI video_renderer_preroll_QueryInterface(IMFMediaSinkPreroll *iface, REFIID riid, void **obj)
1484 {
1485     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1486     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1487 }
1488
1489 static ULONG WINAPI video_renderer_preroll_AddRef(IMFMediaSinkPreroll *iface)
1490 {
1491     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1492     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1493 }
1494
1495 static ULONG WINAPI video_renderer_preroll_Release(IMFMediaSinkPreroll *iface)
1496 {
1497     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1498     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1499 }
1500
1501 static HRESULT WINAPI video_renderer_preroll_NotifyPreroll(IMFMediaSinkPreroll *iface, MFTIME start_time)
1502 {
1503     struct video_renderer *renderer = impl_from_IMFMediaSinkPreroll(iface);
1504     HRESULT hr = S_OK;
1505     size_t i;
1506
1507     TRACE("%p, %s.\n", iface, debugstr_time(start_time));
1508
1509     EnterCriticalSection(&renderer->cs);
1510     if (renderer->flags & EVR_SHUT_DOWN)
1511         hr = MF_E_SHUTDOWN;
1512     else
1513     {
1514         for (i = 0; i < renderer->stream_count; ++i)
1515         {
1516             struct video_stream *stream = renderer->streams[i];
1517
1518             EnterCriticalSection(&stream->cs);
1519             if (!(stream->flags & (EVR_STREAM_PREROLLING | EVR_STREAM_PREROLLED)))
1520             {
1521                 IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkRequestSample,
1522                         &GUID_NULL, S_OK, NULL);
1523                 stream->flags |= EVR_STREAM_PREROLLING;
1524             }
1525             LeaveCriticalSection(&stream->cs);
1526         }
1527     }
1528     LeaveCriticalSection(&renderer->cs);
1529
1530     return hr;
1531 }
1532
1533 static const IMFMediaSinkPrerollVtbl video_renderer_preroll_vtbl =
1534 {
1535     video_renderer_preroll_QueryInterface,
1536     video_renderer_preroll_AddRef,
1537     video_renderer_preroll_Release,
1538     video_renderer_preroll_NotifyPreroll,
1539 };
1540
1541 static HRESULT WINAPI video_renderer_QueryInterface(IMFVideoRenderer *iface, REFIID riid, void **obj)
1542 {
1543     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1544     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1545 }
1546
1547 static ULONG WINAPI video_renderer_AddRef(IMFVideoRenderer *iface)
1548 {
1549     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1550     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1551 }
1552
1553 static ULONG WINAPI video_renderer_Release(IMFVideoRenderer *iface)
1554 {
1555     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1556     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1557 }
1558
1559 static HRESULT video_renderer_create_mixer(IMFAttributes *attributes, IMFTransform **out)
1560 {
1561     unsigned int flags = 0;
1562     IMFActivate *activate;
1563     CLSID clsid;
1564     HRESULT hr;
1565
1566     if (attributes && SUCCEEDED(hr = IMFAttributes_GetUnknown(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_ACTIVATE,
1567             &IID_IMFActivate, (void **)&activate)))
1568     {
1569         IMFAttributes_GetUINT32(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_FLAGS, &flags);
1570         hr = IMFActivate_ActivateObject(activate, &IID_IMFTransform, (void **)out);
1571         IMFActivate_Release(activate);
1572         if (SUCCEEDED(hr) || !(flags & MF_ACTIVATE_CUSTOM_MIXER_ALLOWFAIL))
1573             return hr;
1574     }
1575
1576     if (!attributes || FAILED(IMFAttributes_GetGUID(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_MIXER_CLSID, &clsid)))
1577         memcpy(&clsid, &CLSID_MFVideoMixer9, sizeof(clsid));
1578
1579     return CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTransform, (void **)out);
1580 }
1581
1582 static HRESULT video_renderer_create_presenter(struct video_renderer *renderer, IMFAttributes *attributes,
1583         IMFVideoPresenter **out)
1584 {
1585     unsigned int flags = 0;
1586     IMFActivate *activate;
1587     UINT64 value;
1588     CLSID clsid;
1589     HRESULT hr;
1590
1591     if (attributes && SUCCEEDED(IMFAttributes_GetUINT64(attributes, &MF_ACTIVATE_VIDEO_WINDOW, &value)))
1592         renderer->window = UlongToHandle(value);
1593
1594     if (attributes && SUCCEEDED(IMFAttributes_GetUnknown(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE,
1595             &IID_IMFActivate, (void **)&activate)))
1596     {
1597         IMFAttributes_GetUINT32(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_FLAGS, &flags);
1598         hr = IMFActivate_ActivateObject(activate, &IID_IMFVideoPresenter, (void **)out);
1599         IMFActivate_Release(activate);
1600         if (SUCCEEDED(hr) || !(flags & MF_ACTIVATE_CUSTOM_PRESENTER_ALLOWFAIL))
1601             return hr;
1602     }
1603
1604     if (!attributes || FAILED(IMFAttributes_GetGUID(attributes, &MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID, &clsid)))
1605         memcpy(&clsid, &CLSID_MFVideoPresenter9, sizeof(clsid));
1606
1607     return CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFVideoPresenter, (void **)out);
1608 }
1609
1610 static HRESULT video_renderer_get_device_manager(struct video_renderer *renderer, IUnknown **device_manager)
1611 {
1612     return MFGetService((IUnknown *)renderer->presenter, &MR_VIDEO_RENDER_SERVICE,
1613                 &IID_IDirect3DDeviceManager9, (void **)device_manager);
1614 }
1615
1616 static HRESULT video_renderer_configure_mixer(struct video_renderer *renderer)
1617 {
1618     IMFTopologyServiceLookupClient *lookup_client;
1619     HRESULT hr;
1620
1621     if (SUCCEEDED(hr = IMFTransform_QueryInterface(renderer->mixer, &IID_IMFTopologyServiceLookupClient,
1622             (void **)&lookup_client)))
1623     {
1624         renderer->flags |= EVR_INIT_SERVICES;
1625         if (SUCCEEDED(hr = IMFTopologyServiceLookupClient_InitServicePointers(lookup_client,
1626                 &renderer->IMFTopologyServiceLookup_iface)))
1627         {
1628             renderer->flags |= EVR_MIXER_INITED_SERVICES;
1629         }
1630         renderer->flags &= ~EVR_INIT_SERVICES;
1631         IMFTopologyServiceLookupClient_Release(lookup_client);
1632     }
1633
1634     if (SUCCEEDED(hr))
1635     {
1636         unsigned int input_count, output_count;
1637         unsigned int *ids, *oids;
1638         size_t i;
1639
1640         /* Create stream sinks for inputs that mixer already has by default. */
1641         if (SUCCEEDED(IMFTransform_GetStreamCount(renderer->mixer, &input_count, &output_count)))
1642         {
1643             ids = calloc(input_count, sizeof(*ids));
1644             oids = calloc(output_count, sizeof(*oids));
1645
1646             if (ids && oids)
1647             {
1648                 if (SUCCEEDED(IMFTransform_GetStreamIDs(renderer->mixer, input_count, ids, output_count, oids)))
1649                 {
1650                     for (i = 0; i < input_count; ++i)
1651                     {
1652                         video_renderer_add_stream(renderer, ids[i], NULL);
1653                     }
1654                 }
1655
1656             }
1657
1658             free(ids);
1659             free(oids);
1660         }
1661     }
1662
1663     /* Set device manager that presenter should have created. */
1664     if (video_renderer_is_mixer_d3d_aware(renderer))
1665     {
1666         IUnknown *device_manager;
1667
1668         if (SUCCEEDED(video_renderer_get_device_manager(renderer, &device_manager)))
1669         {
1670             IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_SET_D3D_MANAGER, (ULONG_PTR)device_manager);
1671             IUnknown_Release(device_manager);
1672         }
1673     }
1674
1675     return hr;
1676 }
1677
1678 static HRESULT video_renderer_configure_presenter(struct video_renderer *renderer)
1679 {
1680     IMFVideoDisplayControl *control;
1681     RECT rect = { 0 };
1682     HRESULT hr;
1683
1684     if (SUCCEEDED(IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFVideoDisplayControl, (void **)&control)))
1685     {
1686         GetClientRect(renderer->window, &rect);
1687
1688         if (SUCCEEDED(hr = IMFVideoDisplayControl_SetVideoWindow(control, renderer->window)))
1689             hr = IMFVideoDisplayControl_SetVideoPosition(control, NULL, &rect);
1690         IMFVideoDisplayControl_Release(control);
1691     }
1692
1693     hr = video_renderer_init_presenter_services(renderer);
1694
1695     if (FAILED(video_renderer_get_device_manager(renderer, &renderer->device_manager)))
1696     {
1697         WARN("Failed to get device manager from the presenter.\n");
1698     }
1699
1700     return hr;
1701 }
1702
1703 static HRESULT video_renderer_initialize(struct video_renderer *renderer, IMFTransform *mixer,
1704         IMFVideoPresenter *presenter)
1705 {
1706     HRESULT hr;
1707
1708     if (renderer->mixer)
1709     {
1710         IMFTransform_Release(renderer->mixer);
1711         renderer->mixer = NULL;
1712     }
1713
1714     if (renderer->presenter)
1715     {
1716         IMFVideoPresenter_Release(renderer->presenter);
1717         renderer->presenter = NULL;
1718     }
1719
1720     if (renderer->device_manager)
1721     {
1722         IUnknown_Release(renderer->device_manager);
1723         renderer->device_manager = NULL;
1724     }
1725
1726     renderer->mixer = mixer;
1727     IMFTransform_AddRef(renderer->mixer);
1728
1729     renderer->presenter = presenter;
1730     IMFVideoPresenter_AddRef(renderer->presenter);
1731
1732     if (SUCCEEDED(hr = video_renderer_configure_mixer(renderer)))
1733         hr = video_renderer_configure_presenter(renderer);
1734
1735     return hr;
1736 }
1737
1738 static HRESULT WINAPI video_renderer_InitializeRenderer(IMFVideoRenderer *iface, IMFTransform *mixer,
1739         IMFVideoPresenter *presenter)
1740 {
1741     struct video_renderer *renderer = impl_from_IMFVideoRenderer(iface);
1742     HRESULT hr;
1743
1744     TRACE("%p, %p, %p.\n", iface, mixer, presenter);
1745
1746     if (mixer)
1747         IMFTransform_AddRef(mixer);
1748     else if (FAILED(hr = video_renderer_create_mixer(NULL, &mixer)))
1749     {
1750         WARN("Failed to create default mixer object, hr %#x.\n", hr);
1751         return hr;
1752     }
1753
1754     if (presenter)
1755         IMFVideoPresenter_AddRef(presenter);
1756     else if (FAILED(hr = video_renderer_create_presenter(renderer, NULL, &presenter)))
1757     {
1758         WARN("Failed to create default presenter, hr %#x.\n", hr);
1759         IMFTransform_Release(mixer);
1760         return hr;
1761     }
1762
1763     EnterCriticalSection(&renderer->cs);
1764
1765     if (renderer->flags & EVR_SHUT_DOWN)
1766         hr = MF_E_SHUTDOWN;
1767     else
1768     {
1769         /* FIXME: check clock state */
1770         /* FIXME: check that streams are not initialized */
1771
1772         hr = video_renderer_initialize(renderer, mixer, presenter);
1773     }
1774
1775     LeaveCriticalSection(&renderer->cs);
1776
1777     IMFTransform_Release(mixer);
1778     IMFVideoPresenter_Release(presenter);
1779
1780     return hr;
1781 }
1782
1783 static const IMFVideoRendererVtbl video_renderer_vtbl =
1784 {
1785     video_renderer_QueryInterface,
1786     video_renderer_AddRef,
1787     video_renderer_Release,
1788     video_renderer_InitializeRenderer,
1789 };
1790
1791 static HRESULT WINAPI video_renderer_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
1792 {
1793     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1794     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1795 }
1796
1797 static ULONG WINAPI video_renderer_events_AddRef(IMFMediaEventGenerator *iface)
1798 {
1799     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1800     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1801 }
1802
1803 static ULONG WINAPI video_renderer_events_Release(IMFMediaEventGenerator *iface)
1804 {
1805     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1806     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1807 }
1808
1809 static HRESULT WINAPI video_renderer_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
1810 {
1811     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1812
1813     TRACE("%p, %#x, %p.\n", iface, flags, event);
1814
1815     return IMFMediaEventQueue_GetEvent(renderer->event_queue, flags, event);
1816 }
1817
1818 static HRESULT WINAPI video_renderer_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
1819         IUnknown *state)
1820 {
1821     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1822
1823     TRACE("%p, %p, %p.\n", iface, callback, state);
1824
1825     return IMFMediaEventQueue_BeginGetEvent(renderer->event_queue, callback, state);
1826 }
1827
1828 static HRESULT WINAPI video_renderer_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
1829         IMFMediaEvent **event)
1830 {
1831     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1832
1833     TRACE("%p, %p, %p.\n", iface, result, event);
1834
1835     return IMFMediaEventQueue_EndGetEvent(renderer->event_queue, result, event);
1836 }
1837
1838 static HRESULT WINAPI video_renderer_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
1839         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
1840 {
1841     struct video_renderer *renderer = impl_from_IMFMediaEventGenerator(iface);
1842
1843     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
1844
1845     return IMFMediaEventQueue_QueueEventParamVar(renderer->event_queue, event_type, ext_type, hr, value);
1846 }
1847
1848 static const IMFMediaEventGeneratorVtbl video_renderer_events_vtbl =
1849 {
1850     video_renderer_events_QueryInterface,
1851     video_renderer_events_AddRef,
1852     video_renderer_events_Release,
1853     video_renderer_events_GetEvent,
1854     video_renderer_events_BeginGetEvent,
1855     video_renderer_events_EndGetEvent,
1856     video_renderer_events_QueueEvent,
1857 };
1858
1859 static HRESULT WINAPI video_renderer_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
1860 {
1861     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1862     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
1863 }
1864
1865 static ULONG WINAPI video_renderer_clock_sink_AddRef(IMFClockStateSink *iface)
1866 {
1867     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1868     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
1869 }
1870
1871 static ULONG WINAPI video_renderer_clock_sink_Release(IMFClockStateSink *iface)
1872 {
1873     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1874     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
1875 }
1876
1877 static HRESULT WINAPI video_renderer_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
1878 {
1879     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1880     unsigned int state, request_sample;
1881     size_t i;
1882
1883     TRACE("%p, %s, %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
1884
1885     EnterCriticalSection(&renderer->cs);
1886
1887     state = renderer->state;
1888
1889     /* Update sink state before sending sample requests, to avoid potentially receiving new sample in stopped state */
1890     renderer->state = EVR_STATE_RUNNING;
1891
1892     if (state == EVR_STATE_STOPPED)
1893     {
1894         IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
1895         IMFVideoPresenter_ProcessMessage(renderer->presenter, MFVP_MESSAGE_BEGINSTREAMING, 0);
1896
1897         for (i = 0; i < renderer->stream_count; ++i)
1898         {
1899             struct video_stream *stream = renderer->streams[i];
1900
1901             EnterCriticalSection(&stream->cs);
1902             request_sample = !(stream->flags & EVR_STREAM_PREROLLED) || (stream->flags & EVR_STREAM_SAMPLE_NEEDED);
1903             stream->flags |= EVR_STREAM_PREROLLED;
1904             stream->flags &= ~EVR_STREAM_SAMPLE_NEEDED;
1905             LeaveCriticalSection(&stream->cs);
1906
1907             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkStarted, &GUID_NULL, S_OK, NULL);
1908             if (request_sample)
1909                 IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkRequestSample,
1910                         &GUID_NULL, S_OK, NULL);
1911         }
1912     }
1913
1914     IMFVideoPresenter_OnClockStart(renderer->presenter, systime, offset);
1915
1916     LeaveCriticalSection(&renderer->cs);
1917
1918     return S_OK;
1919 }
1920
1921 static HRESULT WINAPI video_renderer_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
1922 {
1923     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1924     size_t i;
1925
1926     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1927
1928     EnterCriticalSection(&renderer->cs);
1929
1930     IMFVideoPresenter_OnClockStop(renderer->presenter, systime);
1931
1932     IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_COMMAND_FLUSH, 0);
1933     IMFVideoPresenter_ProcessMessage(renderer->presenter, MFVP_MESSAGE_FLUSH, 0);
1934
1935     if (renderer->state == EVR_STATE_RUNNING ||
1936             renderer->state == EVR_STATE_PAUSED)
1937     {
1938         IMFTransform_ProcessMessage(renderer->mixer, MFT_MESSAGE_NOTIFY_END_STREAMING, 0);
1939         IMFVideoPresenter_ProcessMessage(renderer->presenter, MFVP_MESSAGE_ENDSTREAMING, 0);
1940
1941         for (i = 0; i < renderer->stream_count; ++i)
1942         {
1943             struct video_stream *stream = renderer->streams[i];
1944             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkStopped, &GUID_NULL, S_OK, NULL);
1945
1946             EnterCriticalSection(&stream->cs);
1947             stream->flags &= ~(EVR_STREAM_PREROLLED | EVR_STREAM_SAMPLE_NEEDED);
1948             LeaveCriticalSection(&stream->cs);
1949         }
1950         renderer->state = EVR_STATE_STOPPED;
1951     }
1952
1953     LeaveCriticalSection(&renderer->cs);
1954
1955     return S_OK;
1956 }
1957
1958 static HRESULT WINAPI video_renderer_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
1959 {
1960     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1961     size_t i;
1962
1963     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1964
1965     EnterCriticalSection(&renderer->cs);
1966
1967     IMFVideoPresenter_OnClockPause(renderer->presenter, systime);
1968
1969     if (renderer->state == EVR_STATE_RUNNING)
1970     {
1971         for (i = 0; i < renderer->stream_count; ++i)
1972         {
1973             struct video_stream *stream = renderer->streams[i];
1974             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkPaused, &GUID_NULL, S_OK, NULL);
1975         }
1976     }
1977
1978     renderer->state = EVR_STATE_PAUSED;
1979
1980     LeaveCriticalSection(&renderer->cs);
1981
1982     return S_OK;
1983 }
1984
1985 static HRESULT WINAPI video_renderer_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
1986 {
1987     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
1988     size_t i;
1989
1990     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1991
1992     EnterCriticalSection(&renderer->cs);
1993
1994     IMFVideoPresenter_OnClockRestart(renderer->presenter, systime);
1995
1996     for (i = 0; i < renderer->stream_count; ++i)
1997     {
1998         struct video_stream *stream = renderer->streams[i];
1999         IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamSinkStarted, &GUID_NULL, S_OK, NULL);
2000     }
2001     renderer->state = EVR_STATE_RUNNING;
2002
2003     LeaveCriticalSection(&renderer->cs);
2004
2005     return S_OK;
2006 }
2007
2008 static HRESULT WINAPI video_renderer_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
2009 {
2010     struct video_renderer *renderer = impl_from_IMFClockStateSink(iface);
2011     IMFClockStateSink *sink;
2012
2013     TRACE("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
2014
2015     EnterCriticalSection(&renderer->cs);
2016
2017     IMFVideoPresenter_OnClockSetRate(renderer->presenter, systime, rate);
2018     if (SUCCEEDED(IMFTransform_QueryInterface(renderer->mixer, &IID_IMFClockStateSink, (void **)&sink)))
2019     {
2020         IMFClockStateSink_OnClockSetRate(sink, systime, rate);
2021         IMFClockStateSink_Release(sink);
2022     }
2023
2024     LeaveCriticalSection(&renderer->cs);
2025
2026     return S_OK;
2027 }
2028
2029 static const IMFClockStateSinkVtbl video_renderer_clock_sink_vtbl =
2030 {
2031     video_renderer_clock_sink_QueryInterface,
2032     video_renderer_clock_sink_AddRef,
2033     video_renderer_clock_sink_Release,
2034     video_renderer_clock_sink_OnClockStart,
2035     video_renderer_clock_sink_OnClockStop,
2036     video_renderer_clock_sink_OnClockPause,
2037     video_renderer_clock_sink_OnClockRestart,
2038     video_renderer_clock_sink_OnClockSetRate,
2039 };
2040
2041 static HRESULT WINAPI video_renderer_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
2042 {
2043     struct video_renderer *renderer = impl_from_IMFGetService(iface);
2044     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
2045 }
2046
2047 static ULONG WINAPI video_renderer_get_service_AddRef(IMFGetService *iface)
2048 {
2049     struct video_renderer *renderer = impl_from_IMFGetService(iface);
2050     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2051 }
2052
2053 static ULONG WINAPI video_renderer_get_service_Release(IMFGetService *iface)
2054 {
2055     struct video_renderer *renderer = impl_from_IMFGetService(iface);
2056     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2057 }
2058
2059 static HRESULT WINAPI video_renderer_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
2060 {
2061     struct video_renderer *renderer = impl_from_IMFGetService(iface);
2062     HRESULT hr = E_NOINTERFACE;
2063     IMFGetService *gs = NULL;
2064
2065     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
2066
2067     EnterCriticalSection(&renderer->cs);
2068
2069     if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE))
2070     {
2071         hr = IMFTransform_QueryInterface(renderer->mixer, &IID_IMFGetService, (void **)&gs);
2072     }
2073     else if (IsEqualGUID(service, &MR_VIDEO_RENDER_SERVICE))
2074     {
2075         hr = IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFGetService, (void **)&gs);
2076     }
2077     else if (IsEqualGUID(service, &MR_VIDEO_ACCELERATION_SERVICE) && IsEqualIID(riid, &IID_IDirect3DDeviceManager9))
2078     {
2079         if (renderer->device_manager)
2080             hr = IUnknown_QueryInterface(renderer->device_manager, riid, obj);
2081     }
2082     else if (IsEqualGUID(service, &MF_RATE_CONTROL_SERVICE) && IsEqualIID(riid, &IID_IMFRateSupport))
2083     {
2084         hr = IMFVideoRenderer_QueryInterface(&renderer->IMFVideoRenderer_iface, riid, obj);
2085     }
2086     else
2087     {
2088         FIXME("Unsupported service %s.\n", debugstr_guid(service));
2089     }
2090
2091     LeaveCriticalSection(&renderer->cs);
2092
2093     if (gs)
2094     {
2095         hr = IMFGetService_GetService(gs, service, riid, obj);
2096         IMFGetService_Release(gs);
2097     }
2098
2099     return hr;
2100 }
2101
2102 static const IMFGetServiceVtbl video_renderer_get_service_vtbl =
2103 {
2104     video_renderer_get_service_QueryInterface,
2105     video_renderer_get_service_AddRef,
2106     video_renderer_get_service_Release,
2107     video_renderer_get_service_GetService,
2108 };
2109
2110 static HRESULT WINAPI video_renderer_service_lookup_QueryInterface(IMFTopologyServiceLookup *iface, REFIID riid, void **obj)
2111 {
2112     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
2113
2114     if (IsEqualIID(riid, &IID_IMFTopologyServiceLookup) ||
2115             IsEqualIID(riid, &IID_IUnknown))
2116     {
2117         *obj = iface;
2118         IMFTopologyServiceLookup_AddRef(iface);
2119         return S_OK;
2120     }
2121
2122     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
2123     *obj = NULL;
2124     return E_NOINTERFACE;
2125 }
2126
2127 static ULONG WINAPI video_renderer_service_lookup_AddRef(IMFTopologyServiceLookup *iface)
2128 {
2129     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
2130     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2131 }
2132
2133 static ULONG WINAPI video_renderer_service_lookup_Release(IMFTopologyServiceLookup *iface)
2134 {
2135     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
2136     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2137 }
2138
2139 static HRESULT WINAPI video_renderer_service_lookup_LookupService(IMFTopologyServiceLookup *iface,
2140         MF_SERVICE_LOOKUP_TYPE lookup_type, DWORD index, REFGUID service, REFIID riid,
2141         void **objects, DWORD *num_objects)
2142 {
2143     struct video_renderer *renderer = impl_from_IMFTopologyServiceLookup(iface);
2144     HRESULT hr = S_OK;
2145
2146     TRACE("%p, %u, %u, %s, %s, %p, %p.\n", iface, lookup_type, index, debugstr_guid(service), debugstr_guid(riid),
2147             objects, num_objects);
2148
2149     EnterCriticalSection(&renderer->cs);
2150
2151     if (!(renderer->flags & EVR_INIT_SERVICES))
2152         hr = MF_E_NOTACCEPTING;
2153     else if (IsEqualGUID(service, &MR_VIDEO_RENDER_SERVICE))
2154     {
2155         if (IsEqualIID(riid, &IID_IMediaEventSink))
2156         {
2157             *objects = &renderer->IMediaEventSink_iface;
2158             IUnknown_AddRef((IUnknown *)*objects);
2159         }
2160         else if (IsEqualIID(riid, &IID_IMFClock))
2161         {
2162             *objects = renderer->clock;
2163             if (*objects)
2164                 IUnknown_AddRef((IUnknown *)*objects);
2165             hr = *objects ? S_OK : E_NOINTERFACE;
2166         }
2167         else
2168         {
2169             FIXME("Unsupported interface %s for render service.\n", debugstr_guid(riid));
2170             hr = E_NOINTERFACE;
2171         }
2172     }
2173     else if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE))
2174     {
2175         if (IsEqualIID(riid, &IID_IMFTransform))
2176         {
2177             *objects = renderer->mixer;
2178             IUnknown_AddRef((IUnknown *)*objects);
2179         }
2180         else
2181         {
2182             FIXME("Unsupported interface %s for mixer service.\n", debugstr_guid(riid));
2183             hr = E_NOINTERFACE;
2184         }
2185     }
2186     else
2187     {
2188         WARN("Unsupported service %s.\n", debugstr_guid(service));
2189         hr = MF_E_UNSUPPORTED_SERVICE;
2190     }
2191
2192     LeaveCriticalSection(&renderer->cs);
2193
2194     return hr;
2195 }
2196
2197 static const IMFTopologyServiceLookupVtbl video_renderer_service_lookup_vtbl =
2198 {
2199     video_renderer_service_lookup_QueryInterface,
2200     video_renderer_service_lookup_AddRef,
2201     video_renderer_service_lookup_Release,
2202     video_renderer_service_lookup_LookupService,
2203 };
2204
2205 static HRESULT WINAPI video_renderer_event_sink_QueryInterface(IMediaEventSink *iface, REFIID riid, void **obj)
2206 {
2207     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
2208
2209     if (IsEqualIID(riid, &IID_IMediaEventSink) ||
2210             IsEqualIID(riid, &IID_IUnknown))
2211     {
2212         *obj = iface;
2213         IMediaEventSink_AddRef(iface);
2214         return S_OK;
2215     }
2216
2217     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
2218     *obj = NULL;
2219     return E_NOINTERFACE;
2220 }
2221
2222 static ULONG WINAPI video_renderer_event_sink_AddRef(IMediaEventSink *iface)
2223 {
2224     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
2225     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2226 }
2227
2228 static ULONG WINAPI video_renderer_event_sink_Release(IMediaEventSink *iface)
2229 {
2230     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
2231     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2232 }
2233
2234 static HRESULT WINAPI video_renderer_event_sink_Notify(IMediaEventSink *iface, LONG event, LONG_PTR param1, LONG_PTR param2)
2235 {
2236     struct video_renderer *renderer = impl_from_IMediaEventSink(iface);
2237     HRESULT hr = S_OK;
2238     unsigned int idx;
2239
2240     TRACE("%p, %d, %ld, %ld.\n", iface, event, param1, param2);
2241
2242     EnterCriticalSection(&renderer->cs);
2243
2244     if (event == EC_SAMPLE_NEEDED)
2245     {
2246         idx = param1;
2247         if (idx >= renderer->stream_count)
2248             hr = MF_E_INVALIDSTREAMNUMBER;
2249         else if (renderer->state == EVR_STATE_RUNNING)
2250         {
2251             hr = IMFMediaEventQueue_QueueEventParamVar(renderer->streams[idx]->event_queue,
2252                 MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
2253         }
2254         else
2255         {
2256             /* Mixer asks for more input right after preroll too, before renderer finished running state transition.
2257                Mark such streams here, and issue requests later in OnClockStart(). */
2258             renderer->streams[idx]->flags |= EVR_STREAM_SAMPLE_NEEDED;
2259         }
2260     }
2261     else if (event == EC_DISPLAY_CHANGED)
2262     {
2263         for (idx = 0; idx < renderer->stream_count; ++idx)
2264             IMFMediaEventQueue_QueueEventParamVar(renderer->streams[idx]->event_queue,
2265                     MEStreamSinkDeviceChanged, &GUID_NULL, S_OK, NULL);
2266     }
2267     else if (event >= EC_USER)
2268     {
2269         PROPVARIANT code;
2270
2271         code.vt = VT_I4;
2272         code.lVal = event;
2273         hr = IMFMediaEventQueue_QueueEventParamVar(renderer->event_queue, MERendererEvent,
2274                 &GUID_NULL, S_OK, &code);
2275     }
2276     else
2277     {
2278         WARN("Unhandled event %d.\n", event);
2279         hr = MF_E_UNEXPECTED;
2280     }
2281
2282     LeaveCriticalSection(&renderer->cs);
2283
2284     return hr;
2285 }
2286
2287 static const IMediaEventSinkVtbl media_event_sink_vtbl =
2288 {
2289     video_renderer_event_sink_QueryInterface,
2290     video_renderer_event_sink_AddRef,
2291     video_renderer_event_sink_Release,
2292     video_renderer_event_sink_Notify,
2293 };
2294
2295 static HRESULT WINAPI video_renderer_attributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **obj)
2296 {
2297     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2298     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, obj);
2299 }
2300
2301 static ULONG WINAPI video_renderer_attributes_AddRef(IMFAttributes *iface)
2302 {
2303     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2304     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2305 }
2306
2307 static ULONG WINAPI video_renderer_attributes_Release(IMFAttributes *iface)
2308 {
2309     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2310     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2311 }
2312
2313 static HRESULT WINAPI video_renderer_attributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
2314 {
2315     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2316
2317     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2318
2319     return IMFAttributes_GetItem(renderer->attributes, key, value);
2320 }
2321
2322 static HRESULT WINAPI video_renderer_attributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
2323 {
2324     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2325
2326     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
2327
2328     return IMFAttributes_GetItemType(renderer->attributes, key, type);
2329 }
2330
2331 static HRESULT WINAPI video_renderer_attributes_CompareItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value,
2332         BOOL *result)
2333 {
2334     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2335
2336     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
2337
2338     return IMFAttributes_CompareItem(renderer->attributes, key, value, result);
2339 }
2340
2341 static HRESULT WINAPI video_renderer_attributes_Compare(IMFAttributes *iface, IMFAttributes *theirs,
2342         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
2343 {
2344     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2345
2346     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
2347
2348     return IMFAttributes_Compare(renderer->attributes, theirs, type, result);
2349 }
2350
2351 static HRESULT WINAPI video_renderer_attributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
2352 {
2353     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2354
2355     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2356
2357     return IMFAttributes_GetUINT32(renderer->attributes, key, value);
2358 }
2359
2360 static HRESULT WINAPI video_renderer_attributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
2361 {
2362     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2363
2364     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2365
2366     return IMFAttributes_GetUINT64(renderer->attributes, key, value);
2367 }
2368
2369 static HRESULT WINAPI video_renderer_attributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
2370 {
2371     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2372
2373     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2374
2375     return IMFAttributes_GetDouble(renderer->attributes, key, value);
2376 }
2377
2378 static HRESULT WINAPI video_renderer_attributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
2379 {
2380     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2381
2382     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2383
2384     return IMFAttributes_GetGUID(renderer->attributes, key, value);
2385 }
2386
2387 static HRESULT WINAPI video_renderer_attributes_GetStringLength(IMFAttributes *iface, REFGUID key,
2388         UINT32 *length)
2389 {
2390     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2391
2392     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
2393
2394     return IMFAttributes_GetStringLength(renderer->attributes, key, length);
2395 }
2396
2397 static HRESULT WINAPI video_renderer_attributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
2398         UINT32 size, UINT32 *length)
2399 {
2400     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2401
2402     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), value, size, length);
2403
2404     return IMFAttributes_GetString(renderer->attributes, key, value, size, length);
2405 }
2406
2407 static HRESULT WINAPI video_renderer_attributes_GetAllocatedString(IMFAttributes *iface, REFGUID key,
2408         WCHAR **value, UINT32 *length)
2409 {
2410     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2411
2412     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
2413
2414     return IMFAttributes_GetAllocatedString(renderer->attributes, key, value, length);
2415 }
2416
2417 static HRESULT WINAPI video_renderer_attributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
2418 {
2419     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2420
2421     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
2422
2423     return IMFAttributes_GetBlobSize(renderer->attributes, key, size);
2424 }
2425
2426 static HRESULT WINAPI video_renderer_attributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
2427          UINT32 bufsize, UINT32 *blobsize)
2428 {
2429     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2430
2431     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
2432
2433     return IMFAttributes_GetBlob(renderer->attributes, key, buf, bufsize, blobsize);
2434 }
2435
2436 static HRESULT WINAPI video_renderer_attributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key,
2437         UINT8 **buf, UINT32 *size)
2438 {
2439     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2440
2441     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
2442
2443     return IMFAttributes_GetAllocatedBlob(renderer->attributes, key, buf, size);
2444 }
2445
2446 static HRESULT WINAPI video_renderer_attributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **out)
2447 {
2448     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2449
2450     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), out);
2451
2452     return IMFAttributes_GetUnknown(renderer->attributes, key, riid, out);
2453 }
2454
2455 static HRESULT WINAPI video_renderer_attributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value)
2456 {
2457     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2458
2459     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2460
2461     return IMFAttributes_SetItem(renderer->attributes, key, value);
2462 }
2463
2464 static HRESULT WINAPI video_renderer_attributes_DeleteItem(IMFAttributes *iface, REFGUID key)
2465 {
2466     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2467
2468     TRACE("%p, %s.\n", iface, debugstr_guid(key));
2469
2470     return IMFAttributes_DeleteItem(renderer->attributes, key);
2471 }
2472
2473 static HRESULT WINAPI video_renderer_attributes_DeleteAllItems(IMFAttributes *iface)
2474 {
2475     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2476
2477     TRACE("%p.\n", iface);
2478
2479     return IMFAttributes_DeleteAllItems(renderer->attributes);
2480 }
2481
2482 static HRESULT WINAPI video_renderer_attributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
2483 {
2484     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2485
2486     TRACE("%p, %s, %u.\n", iface, debugstr_guid(key), value);
2487
2488     return IMFAttributes_SetUINT32(renderer->attributes, key, value);
2489 }
2490
2491 static HRESULT WINAPI video_renderer_attributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
2492 {
2493     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2494
2495     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
2496
2497     return IMFAttributes_SetUINT64(renderer->attributes, key, value);
2498 }
2499
2500 static HRESULT WINAPI video_renderer_attributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
2501 {
2502     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2503
2504     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
2505
2506     return IMFAttributes_SetDouble(renderer->attributes, key, value);
2507 }
2508
2509 static HRESULT WINAPI video_renderer_attributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
2510 {
2511     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2512
2513     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
2514
2515     return IMFAttributes_SetGUID(renderer->attributes, key, value);
2516 }
2517
2518 static HRESULT WINAPI video_renderer_attributes_SetString(IMFAttributes *iface, REFGUID key,
2519         const WCHAR *value)
2520 {
2521     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2522
2523     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
2524
2525     return IMFAttributes_SetString(renderer->attributes, key, value);
2526 }
2527
2528 static HRESULT WINAPI video_renderer_attributes_SetBlob(IMFAttributes *iface, REFGUID key,
2529         const UINT8 *buf, UINT32 size)
2530 {
2531     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2532
2533     TRACE("%p, %s, %p, %u.\n", iface, debugstr_guid(key), buf, size);
2534
2535     return IMFAttributes_SetBlob(renderer->attributes, key, buf, size);
2536 }
2537
2538 static HRESULT WINAPI video_renderer_attributes_SetUnknown(IMFAttributes *iface, REFGUID key,
2539         IUnknown *unknown)
2540 {
2541     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2542
2543     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), unknown);
2544
2545     return IMFAttributes_SetUnknown(renderer->attributes, key, unknown);
2546 }
2547
2548 static HRESULT WINAPI video_renderer_attributes_LockStore(IMFAttributes *iface)
2549 {
2550     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2551
2552     TRACE("%p.\n", iface);
2553
2554     return IMFAttributes_LockStore(renderer->attributes);
2555 }
2556
2557 static HRESULT WINAPI video_renderer_attributes_UnlockStore(IMFAttributes *iface)
2558 {
2559     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2560
2561     TRACE("%p.\n", iface);
2562
2563     return IMFAttributes_UnlockStore(renderer->attributes);
2564 }
2565
2566 static HRESULT WINAPI video_renderer_attributes_GetCount(IMFAttributes *iface, UINT32 *count)
2567 {
2568     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2569
2570     TRACE("%p, %p.\n", iface, count);
2571
2572     return IMFAttributes_GetCount(renderer->attributes, count);
2573 }
2574
2575 static HRESULT WINAPI video_renderer_attributes_GetItemByIndex(IMFAttributes *iface, UINT32 index,
2576         GUID *key, PROPVARIANT *value)
2577 {
2578     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2579
2580     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
2581
2582     return IMFAttributes_GetItemByIndex(renderer->attributes, index, key, value);
2583 }
2584
2585 static HRESULT WINAPI video_renderer_attributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
2586 {
2587     struct video_renderer *renderer = impl_from_IMFAttributes(iface);
2588
2589     TRACE("%p, %p.\n", iface, dest);
2590
2591     return IMFAttributes_CopyAllItems(renderer->attributes, dest);
2592 }
2593
2594 static const IMFAttributesVtbl video_renderer_attributes_vtbl =
2595 {
2596     video_renderer_attributes_QueryInterface,
2597     video_renderer_attributes_AddRef,
2598     video_renderer_attributes_Release,
2599     video_renderer_attributes_GetItem,
2600     video_renderer_attributes_GetItemType,
2601     video_renderer_attributes_CompareItem,
2602     video_renderer_attributes_Compare,
2603     video_renderer_attributes_GetUINT32,
2604     video_renderer_attributes_GetUINT64,
2605     video_renderer_attributes_GetDouble,
2606     video_renderer_attributes_GetGUID,
2607     video_renderer_attributes_GetStringLength,
2608     video_renderer_attributes_GetString,
2609     video_renderer_attributes_GetAllocatedString,
2610     video_renderer_attributes_GetBlobSize,
2611     video_renderer_attributes_GetBlob,
2612     video_renderer_attributes_GetAllocatedBlob,
2613     video_renderer_attributes_GetUnknown,
2614     video_renderer_attributes_SetItem,
2615     video_renderer_attributes_DeleteItem,
2616     video_renderer_attributes_DeleteAllItems,
2617     video_renderer_attributes_SetUINT32,
2618     video_renderer_attributes_SetUINT64,
2619     video_renderer_attributes_SetDouble,
2620     video_renderer_attributes_SetGUID,
2621     video_renderer_attributes_SetString,
2622     video_renderer_attributes_SetBlob,
2623     video_renderer_attributes_SetUnknown,
2624     video_renderer_attributes_LockStore,
2625     video_renderer_attributes_UnlockStore,
2626     video_renderer_attributes_GetCount,
2627     video_renderer_attributes_GetItemByIndex,
2628     video_renderer_attributes_CopyAllItems,
2629 };
2630
2631 static HRESULT WINAPI video_renderer_quality_advise_QueryInterface(IMFQualityAdvise *iface, REFIID riid, void **out)
2632 {
2633     struct video_renderer *renderer = impl_from_IMFQualityAdvise(iface);
2634     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, out);
2635 }
2636
2637 static ULONG WINAPI video_renderer_quality_advise_AddRef(IMFQualityAdvise *iface)
2638 {
2639     struct video_renderer *renderer = impl_from_IMFQualityAdvise(iface);
2640     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2641 }
2642
2643 static ULONG WINAPI video_renderer_quality_Release(IMFQualityAdvise *iface)
2644 {
2645     struct video_renderer *renderer = impl_from_IMFQualityAdvise(iface);
2646     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2647 }
2648
2649 static HRESULT WINAPI video_renderer_quality_advise_SetDropMode(IMFQualityAdvise *iface,
2650         MF_QUALITY_DROP_MODE mode)
2651 {
2652     FIXME("%p, %u.\n", iface, mode);
2653
2654     return E_NOTIMPL;
2655 }
2656
2657 static HRESULT WINAPI video_renderer_quality_advise_SetQualityLevel(IMFQualityAdvise *iface,
2658         MF_QUALITY_LEVEL level)
2659 {
2660     FIXME("%p, %u.\n", iface, level);
2661
2662     return E_NOTIMPL;
2663 }
2664
2665 static HRESULT WINAPI video_renderer_quality_advise_GetDropMode(IMFQualityAdvise *iface,
2666         MF_QUALITY_DROP_MODE *mode)
2667 {
2668     FIXME("%p, %p.\n", iface, mode);
2669
2670     return E_NOTIMPL;
2671 }
2672
2673 static HRESULT WINAPI video_renderer_quality_advise_GetQualityLevel(IMFQualityAdvise *iface,
2674         MF_QUALITY_LEVEL *level)
2675 {
2676     FIXME("%p, %p.\n", iface, level);
2677
2678     return E_NOTIMPL;
2679 }
2680
2681 static HRESULT WINAPI video_renderer_quality_advise_DropTime(IMFQualityAdvise *iface, LONGLONG interval)
2682 {
2683     FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(interval));
2684
2685     return E_NOTIMPL;
2686 }
2687
2688 static const IMFQualityAdviseVtbl video_renderer_quality_advise_vtbl =
2689 {
2690     video_renderer_quality_advise_QueryInterface,
2691     video_renderer_quality_advise_AddRef,
2692     video_renderer_quality_Release,
2693     video_renderer_quality_advise_SetDropMode,
2694     video_renderer_quality_advise_SetQualityLevel,
2695     video_renderer_quality_advise_GetDropMode,
2696     video_renderer_quality_advise_GetQualityLevel,
2697     video_renderer_quality_advise_DropTime,
2698 };
2699
2700 static HRESULT WINAPI video_renderer_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **out)
2701 {
2702     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2703     return IMFMediaSink_QueryInterface(&renderer->IMFMediaSink_iface, riid, out);
2704 }
2705
2706 static ULONG WINAPI video_renderer_rate_support_AddRef(IMFRateSupport *iface)
2707 {
2708     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2709     return IMFMediaSink_AddRef(&renderer->IMFMediaSink_iface);
2710 }
2711
2712 static ULONG WINAPI video_renderer_rate_support_Release(IMFRateSupport *iface)
2713 {
2714     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2715     return IMFMediaSink_Release(&renderer->IMFMediaSink_iface);
2716 }
2717
2718 static HRESULT WINAPI video_renderer_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
2719         BOOL thin, float *rate)
2720 {
2721     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2722
2723     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
2724
2725     if (renderer->flags & EVR_SHUT_DOWN)
2726         return MF_E_SHUTDOWN;
2727
2728     *rate = 0.0f;
2729
2730     return S_OK;
2731 }
2732
2733 static HRESULT WINAPI video_renderer_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
2734         BOOL thin, float *rate)
2735 {
2736     struct video_renderer *renderer = impl_from_IMFRateSupport(iface);
2737
2738     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
2739
2740     return renderer->flags & EVR_SHUT_DOWN ? MF_E_SHUTDOWN : MF_E_INVALIDREQUEST;
2741 }
2742
2743 static HRESULT WINAPI video_renderer_rate_support_IsRateSupported(IMFRateSupport *iface, BOOL thin, float rate,
2744         float *nearest_supported_rate)
2745 {
2746     FIXME("%p, %d, %f, %p.\n", iface, thin, rate, nearest_supported_rate);
2747
2748     return E_NOTIMPL;
2749 }
2750
2751 static const IMFRateSupportVtbl video_renderer_rate_support_vtbl =
2752 {
2753     video_renderer_rate_support_QueryInterface,
2754     video_renderer_rate_support_AddRef,
2755     video_renderer_rate_support_Release,
2756     video_renderer_rate_support_GetSlowestRate,
2757     video_renderer_rate_support_GetFastestRate,
2758     video_renderer_rate_support_IsRateSupported,
2759 };
2760
2761 static HRESULT evr_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj)
2762 {
2763     struct video_renderer *object;
2764     IMFVideoPresenter *presenter = NULL;
2765     IMFTransform *mixer = NULL;
2766     HRESULT hr;
2767
2768     TRACE("%p, %p, %p.\n", attributes, user_context, obj);
2769
2770     if (!(object = calloc(1, sizeof(*object))))
2771         return E_OUTOFMEMORY;
2772
2773     object->IMFMediaSink_iface.lpVtbl = &video_renderer_sink_vtbl;
2774     object->IMFMediaSinkPreroll_iface.lpVtbl = &video_renderer_preroll_vtbl;
2775     object->IMFVideoRenderer_iface.lpVtbl = &video_renderer_vtbl;
2776     object->IMFMediaEventGenerator_iface.lpVtbl = &video_renderer_events_vtbl;
2777     object->IMFClockStateSink_iface.lpVtbl = &video_renderer_clock_sink_vtbl;
2778     object->IMFGetService_iface.lpVtbl = &video_renderer_get_service_vtbl;
2779     object->IMFTopologyServiceLookup_iface.lpVtbl = &video_renderer_service_lookup_vtbl;
2780     object->IMediaEventSink_iface.lpVtbl = &media_event_sink_vtbl;
2781     object->IMFAttributes_iface.lpVtbl = &video_renderer_attributes_vtbl;
2782     object->IMFQualityAdvise_iface.lpVtbl = &video_renderer_quality_advise_vtbl;
2783     object->IMFRateSupport_iface.lpVtbl = &video_renderer_rate_support_vtbl;
2784     object->refcount = 1;
2785     InitializeCriticalSection(&object->cs);
2786
2787     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
2788         goto failed;
2789
2790     if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
2791         goto failed;
2792
2793     /* Create mixer and presenter. */
2794     if (FAILED(hr = video_renderer_create_mixer(attributes, &mixer)))
2795         goto failed;
2796
2797     if (FAILED(hr = video_renderer_create_presenter(object, attributes, &presenter)))
2798         goto failed;
2799
2800     if (FAILED(hr = video_renderer_initialize(object, mixer, presenter)))
2801         goto failed;
2802
2803     IMFTransform_Release(mixer);
2804     IMFVideoPresenter_Release(presenter);
2805
2806     /* Default attributes */
2807     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceBob, 0);
2808     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowDropToBob, 0);
2809     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceThrottle, 0);
2810     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowDropToThrottle, 0);
2811     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceHalfInterlace, 0);
2812     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowDropToHalfInterlace, 0);
2813     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceScaling, 0);
2814     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowScaling, 0);
2815     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_ForceBatching, 0);
2816     IMFAttributes_SetUINT32(object->attributes, &EVRConfig_AllowBatching, 0);
2817
2818     *obj = (IUnknown *)&object->IMFMediaSink_iface;
2819
2820     return S_OK;
2821
2822 failed:
2823
2824     if (mixer)
2825         IMFTransform_Release(mixer);
2826
2827     if (presenter)
2828         IMFVideoPresenter_Release(presenter);
2829
2830     video_renderer_release_services(object);
2831     IMFMediaSink_Release(&object->IMFMediaSink_iface);
2832
2833     return hr;
2834 }
2835
2836 static void evr_shutdown_object(void *user_context, IUnknown *obj)
2837 {
2838     IMFMediaSink *sink;
2839
2840     if (SUCCEEDED(IUnknown_QueryInterface(obj, &IID_IMFMediaSink, (void **)&sink)))
2841     {
2842         IMFMediaSink_Shutdown(sink);
2843         IMFMediaSink_Release(sink);
2844     }
2845 }
2846
2847 static const struct activate_funcs evr_activate_funcs =
2848 {
2849     .create_object = evr_create_object,
2850     .shutdown_object = evr_shutdown_object,
2851 };
2852
2853 /***********************************************************************
2854  *      MFCreateVideoRendererActivate (mf.@)
2855  */
2856 HRESULT WINAPI MFCreateVideoRendererActivate(HWND hwnd, IMFActivate **activate)
2857 {
2858     HRESULT hr;
2859
2860     TRACE("%p, %p.\n", hwnd, activate);
2861
2862     if (!activate)
2863         return E_POINTER;
2864
2865     hr = create_activation_object(NULL, &evr_activate_funcs, activate);
2866     if (SUCCEEDED(hr))
2867         IMFActivate_SetUINT64(*activate, &MF_ACTIVATE_VIDEO_WINDOW, (ULONG_PTR)hwnd);
2868
2869     return hr;
2870 }
2871
2872 /***********************************************************************
2873  *      MFCreateVideoRenderer (mf.@)
2874  */
2875 HRESULT WINAPI MFCreateVideoRenderer(REFIID riid, void **renderer)
2876 {
2877     IUnknown *obj;
2878     HRESULT hr;
2879
2880     TRACE("%s, %p.\n", debugstr_guid(riid), renderer);
2881
2882     *renderer = NULL;
2883
2884     if (SUCCEEDED(hr = evr_create_object(NULL, NULL, &obj)))
2885     {
2886         hr = IUnknown_QueryInterface(obj, riid, renderer);
2887         IUnknown_Release(obj);
2888     }
2889
2890     return hr;
2891 }