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