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