dlls/evr/presenter.c

   1 /*
   2  * Copyright 2020 Nikolay Sivov
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include "evr.h"
  22 #include "d3d9.h"
  23 #include "mfapi.h"
  24 #include "mferror.h"
  25 #include "dxva2api.h"
  26
  27 #include "evr_classes.h"
  28 #include "evr_private.h"
  29
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(evr);
  33
  34 enum presenter_state
  35 {
  36     PRESENTER_STATE_SHUT_DOWN = 0,
  37     PRESENTER_STATE_STARTED,
  38     PRESENTER_STATE_STOPPED,
  39     PRESENTER_STATE_PAUSED,
  40 };
  41
  42 enum presenter_flags
  43 {
  44     PRESENTER_MIXER_HAS_INPUT = 0x1,
  45 };
  46
  47 enum streaming_thread_message
  48 {
  49     EVRM_STOP = WM_USER,
  50     EVRM_PRESENT = WM_USER + 1,
  51     EVRM_PROCESS_INPUT = WM_USER + 2,
  52 };
  53
  54 struct sample_queue
  55 {
  56     IMFSample **samples;
  57     unsigned int size;
  58     unsigned int used;
  59     unsigned int front;
  60     unsigned int back;
  61 };
  62
  63 struct streaming_thread
  64 {
  65     HANDLE hthread;
  66     HANDLE ready_event;
  67     DWORD tid;
  68     struct sample_queue queue;
  69 };
  70
  71 struct video_presenter
  72 {
  73     IMFVideoPresenter IMFVideoPresenter_iface;
  74     IMFVideoDeviceID IMFVideoDeviceID_iface;
  75     IMFTopologyServiceLookupClient IMFTopologyServiceLookupClient_iface;
  76     IMFVideoDisplayControl IMFVideoDisplayControl_iface;
  77     IMFRateSupport IMFRateSupport_iface;
  78     IMFGetService IMFGetService_iface;
  79     IMFVideoPositionMapper IMFVideoPositionMapper_iface;
  80     IQualProp IQualProp_iface;
  81     IMFQualityAdvise IMFQualityAdvise_iface;
  82     IDirect3DDeviceManager9 IDirect3DDeviceManager9_iface;
  83     IMFVideoSampleAllocatorNotify allocator_cb;
  84     IUnknown IUnknown_inner;
  85     IUnknown *outer_unk;
  86     LONG refcount;
  87
  88     IMFTransform *mixer;
  89     IMFClock *clock;
  90     IMediaEventSink *event_sink;
  91
  92     IDirect3DDeviceManager9 *device_manager;
  93     IDirect3DSwapChain9 *swapchain;
  94     HANDLE hdevice;
  95
  96     IMFVideoSampleAllocator *allocator;
  97     struct streaming_thread thread;
  98     unsigned int allocator_capacity;
  99     IMFMediaType *media_type;
 100     LONGLONG frame_time_threshold;
 101     UINT reset_token;
 102     HWND video_window;
 103     MFVideoNormalizedRect src_rect;
 104     RECT dst_rect;
 105     DWORD rendering_prefs;
 106     SIZE native_size;
 107     SIZE native_ratio;
 108     unsigned int ar_mode;
 109     unsigned int state;
 110     unsigned int flags;
 111     CRITICAL_SECTION cs;
 112 };
 113
 114 static struct video_presenter *impl_from_IUnknown(IUnknown *iface)
 115 {
 116     return CONTAINING_RECORD(iface, struct video_presenter, IUnknown_inner);
 117 }
 118
 119 static struct video_presenter *impl_from_IMFVideoPresenter(IMFVideoPresenter *iface)
 120 {
 121     return CONTAINING_RECORD(iface, struct video_presenter, IMFVideoPresenter_iface);
 122 }
 123
 124 static struct video_presenter *impl_from_IMFVideoDeviceID(IMFVideoDeviceID *iface)
 125 {
 126     return CONTAINING_RECORD(iface, struct video_presenter, IMFVideoDeviceID_iface);
 127 }
 128
 129 static struct video_presenter *impl_from_IMFTopologyServiceLookupClient(IMFTopologyServiceLookupClient *iface)
 130 {
 131     return CONTAINING_RECORD(iface, struct video_presenter, IMFTopologyServiceLookupClient_iface);
 132 }
 133
 134 static struct video_presenter *impl_from_IMFVideoDisplayControl(IMFVideoDisplayControl *iface)
 135 {
 136     return CONTAINING_RECORD(iface, struct video_presenter, IMFVideoDisplayControl_iface);
 137 }
 138
 139 static struct video_presenter *impl_from_IMFRateSupport(IMFRateSupport *iface)
 140 {
 141     return CONTAINING_RECORD(iface, struct video_presenter, IMFRateSupport_iface);
 142 }
 143
 144 static struct video_presenter *impl_from_IMFGetService(IMFGetService *iface)
 145 {
 146     return CONTAINING_RECORD(iface, struct video_presenter, IMFGetService_iface);
 147 }
 148
 149 static struct video_presenter *impl_from_IMFVideoPositionMapper(IMFVideoPositionMapper *iface)
 150 {
 151     return CONTAINING_RECORD(iface, struct video_presenter, IMFVideoPositionMapper_iface);
 152 }
 153
 154 static struct video_presenter *impl_from_IMFVideoSampleAllocatorNotify(IMFVideoSampleAllocatorNotify *iface)
 155 {
 156     return CONTAINING_RECORD(iface, struct video_presenter, allocator_cb);
 157 }
 158
 159 static struct video_presenter *impl_from_IQualProp(IQualProp *iface)
 160 {
 161     return CONTAINING_RECORD(iface, struct video_presenter, IQualProp_iface);
 162 }
 163
 164 static struct video_presenter *impl_from_IMFQualityAdvise(IMFQualityAdvise *iface)
 165 {
 166     return CONTAINING_RECORD(iface, struct video_presenter, IMFQualityAdvise_iface);
 167 }
 168
 169 static struct video_presenter *impl_from_IDirect3DDeviceManager9(IDirect3DDeviceManager9 *iface)
 170 {
 171     return CONTAINING_RECORD(iface, struct video_presenter, IDirect3DDeviceManager9_iface);
 172 }
 173
 174 static void video_presenter_notify_renderer(struct video_presenter *presenter,
 175         LONG event, LONG_PTR param1, LONG_PTR param2)
 176 {
 177     if (presenter->event_sink)
 178         IMediaEventSink_Notify(presenter->event_sink, event, param1, param2);
 179 }
 180
 181 static unsigned int get_gcd(unsigned int a, unsigned int b)
 182 {
 183     unsigned int m;
 184
 185     while (b)
 186     {
 187         m = a % b;
 188         a = b;
 189         b = m;
 190     }
 191
 192     return a;
 193 }
 194
 195 static HRESULT video_presenter_get_device(struct video_presenter *presenter, IDirect3DDevice9 **device)
 196 {
 197     HRESULT hr;
 198
 199     if (!presenter->hdevice)
 200     {
 201         if (FAILED(hr = IDirect3DDeviceManager9_OpenDeviceHandle(presenter->device_manager, &presenter->hdevice)))
 202             return hr;
 203     }
 204
 205     return IDirect3DDeviceManager9_LockDevice(presenter->device_manager, presenter->hdevice, device, TRUE);
 206 }
 207
 208 static void video_presenter_get_native_video_size(struct video_presenter *presenter)
 209 {
 210     IMFMediaType *media_type;
 211     UINT64 frame_size = 0;
 212
 213     memset(&presenter->native_size, 0, sizeof(presenter->native_size));
 214     memset(&presenter->native_ratio, 0, sizeof(presenter->native_ratio));
 215
 216     if (!presenter->mixer)
 217         return;
 218
 219     if (FAILED(IMFTransform_GetInputCurrentType(presenter->mixer, 0, &media_type)))
 220         return;
 221
 222     if (SUCCEEDED(IMFMediaType_GetUINT64(media_type, &MF_MT_FRAME_SIZE, &frame_size)))
 223     {
 224         unsigned int gcd;
 225
 226         presenter->native_size.cx = frame_size >> 32;
 227         presenter->native_size.cy = frame_size;
 228
 229         if ((gcd = get_gcd(presenter->native_size.cx, presenter->native_size.cy)))
 230         {
 231             presenter->native_ratio.cx = presenter->native_size.cx / gcd;
 232             presenter->native_ratio.cy = presenter->native_size.cy / gcd;
 233         }
 234     }
 235
 236     IMFMediaType_Release(media_type);
 237 }
 238
 239 /* It is important this is called to reset callback too to break circular referencing,
 240    when allocator keeps a reference of its container, that created it. */
 241 static void video_presenter_set_allocator_callback(struct video_presenter *presenter,
 242         IMFVideoSampleAllocatorNotify *notify_cb)
 243 {
 244     IMFVideoSampleAllocatorCallback *cb;
 245
 246     IMFVideoSampleAllocator_QueryInterface(presenter->allocator, &IID_IMFVideoSampleAllocatorCallback, (void **)&cb);
 247     IMFVideoSampleAllocatorCallback_SetCallback(cb, notify_cb);
 248     IMFVideoSampleAllocatorCallback_Release(cb);
 249 }
 250
 251 static void video_presenter_reset_media_type(struct video_presenter *presenter)
 252 {
 253     if (presenter->media_type)
 254         IMFMediaType_Release(presenter->media_type);
 255     presenter->media_type = NULL;
 256
 257     IMFVideoSampleAllocator_UninitializeSampleAllocator(presenter->allocator);
 258     video_presenter_set_allocator_callback(presenter, NULL);
 259 }
 260
 261 static HRESULT video_presenter_set_media_type(struct video_presenter *presenter, IMFMediaType *media_type)
 262 {
 263     unsigned int flags;
 264     HRESULT hr;
 265
 266     if (!media_type)
 267     {
 268         video_presenter_reset_media_type(presenter);
 269         return S_OK;
 270     }
 271
 272     if (presenter->media_type && IMFMediaType_IsEqual(presenter->media_type, media_type, &flags) == S_OK)
 273         return S_OK;
 274
 275     video_presenter_reset_media_type(presenter);
 276
 277     if (SUCCEEDED(hr = IMFVideoSampleAllocator_InitializeSampleAllocator(presenter->allocator,
 278             presenter->allocator_capacity, media_type)))
 279     {
 280         MFRatio ratio;
 281         UINT64 rate, frametime;
 282
 283         presenter->media_type = media_type;
 284         IMFMediaType_AddRef(presenter->media_type);
 285
 286         if (SUCCEEDED(IMFMediaType_GetUINT64(presenter->media_type, &MF_MT_FRAME_RATE, &rate)))
 287         {
 288             ratio.Denominator = rate;
 289             ratio.Numerator = rate >> 32;
 290         }
 291         else
 292         {
 293             ratio.Denominator = 1;
 294             ratio.Numerator = 30;
 295         }
 296
 297         MFFrameRateToAverageTimePerFrame(ratio.Numerator, ratio.Denominator, &frametime);
 298         presenter->frame_time_threshold = frametime / 4;
 299     }
 300     else
 301         WARN("Failed to initialize sample allocator, hr %#x.\n", hr);
 302
 303     return hr;
 304 }
 305
 306 static HRESULT video_presenter_invalidate_media_type(struct video_presenter *presenter)
 307 {
 308     IMFMediaType *media_type, *candidate_type;
 309     unsigned int idx = 0;
 310     UINT64 frame_size;
 311     MFVideoArea aperture;
 312     RECT rect;
 313     HRESULT hr;
 314
 315     if (FAILED(hr = MFCreateMediaType(&media_type)))
 316         return hr;
 317
 318     video_presenter_get_native_video_size(presenter);
 319
 320     rect = presenter->dst_rect;
 321     if (rect.left == 0 && rect.right == 0 && rect.bottom == 0 && rect.top == 0)
 322     {
 323         rect.right = presenter->native_size.cx;
 324         rect.bottom = presenter->native_size.cy;
 325     }
 326
 327     aperture.Area.cx = rect.right - rect.left;
 328     aperture.Area.cy = rect.bottom - rect.top;
 329     aperture.OffsetX.value = 0;
 330     aperture.OffsetX.fract = 0;
 331     aperture.OffsetY.value = 0;
 332     aperture.OffsetY.fract = 0;
 333     frame_size = (UINT64)aperture.Area.cx << 32 | aperture.Area.cy;
 334
 335     while (SUCCEEDED(hr = IMFTransform_GetOutputAvailableType(presenter->mixer, 0, idx++, &candidate_type)))
 336     {
 337         /* FIXME: check that d3d device supports this format */
 338
 339         if (FAILED(hr = IMFMediaType_CopyAllItems(candidate_type, (IMFAttributes *)media_type)))
 340             WARN("Failed to clone a media type, hr %#x.\n", hr);
 341         IMFMediaType_Release(candidate_type);
 342
 343         IMFMediaType_SetUINT64(media_type, &MF_MT_FRAME_SIZE, frame_size);
 344         IMFMediaType_SetBlob(media_type, &MF_MT_GEOMETRIC_APERTURE, (UINT8 *)&aperture, sizeof(aperture));
 345
 346         hr = IMFTransform_SetOutputType(presenter->mixer, 0, media_type, MFT_SET_TYPE_TEST_ONLY);
 347
 348         if (SUCCEEDED(hr))
 349             hr = video_presenter_set_media_type(presenter, media_type);
 350
 351         if (SUCCEEDED(hr))
 352             hr = IMFTransform_SetOutputType(presenter->mixer, 0, media_type, 0);
 353
 354         if (SUCCEEDED(hr))
 355             break;
 356     }
 357
 358     IMFMediaType_Release(media_type);
 359
 360     return hr;
 361 }
 362
 363 static void video_presenter_sample_queue_init(struct video_presenter *presenter)
 364 {
 365     struct sample_queue *queue = &presenter->thread.queue;
 366
 367     if (queue->size)
 368         return;
 369
 370     memset(queue, 0, sizeof(*queue));
 371     queue->samples = calloc(presenter->allocator_capacity, sizeof(*queue->samples));
 372     queue->size = presenter->allocator_capacity;
 373     queue->back = queue->size - 1;
 374 }
 375
 376 static void video_presenter_sample_queue_push(struct video_presenter *presenter, IMFSample *sample)
 377 {
 378     struct sample_queue *queue = &presenter->thread.queue;
 379
 380     EnterCriticalSection(&presenter->cs);
 381     if (queue->used != queue->size)
 382     {
 383         queue->back = (queue->back + 1) % queue->size;
 384         queue->samples[queue->back] = sample;
 385         queue->used++;
 386         IMFSample_AddRef(sample);
 387     }
 388     LeaveCriticalSection(&presenter->cs);
 389 }
 390
 391 static BOOL video_presenter_sample_queue_pop(struct video_presenter *presenter, IMFSample **sample)
 392 {
 393     struct sample_queue *queue = &presenter->thread.queue;
 394
 395     EnterCriticalSection(&presenter->cs);
 396     if (queue->used)
 397     {
 398         *sample = queue->samples[queue->front];
 399         queue->front = (queue->front + 1) % queue->size;
 400         queue->used--;
 401     }
 402     else
 403         *sample = NULL;
 404     LeaveCriticalSection(&presenter->cs);
 405
 406     return *sample != NULL;
 407 }
 408
 409 static HRESULT video_presenter_get_sample_surface(IMFSample *sample, IDirect3DSurface9 **surface)
 410 {
 411     IMFMediaBuffer *buffer;
 412     IMFGetService *gs;
 413     HRESULT hr;
 414
 415     if (FAILED(hr = IMFSample_GetBufferByIndex(sample, 0, &buffer)))
 416         return hr;
 417
 418     hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMFGetService, (void **)&gs);
 419     IMFMediaBuffer_Release(buffer);
 420     if (FAILED(hr))
 421         return hr;
 422
 423     hr = IMFGetService_GetService(gs, &MR_BUFFER_SERVICE, &IID_IDirect3DSurface9, (void **)surface);
 424     IMFGetService_Release(gs);
 425     return hr;
 426 }
 427
 428 static void scale_rect(RECT *rect, unsigned int width, unsigned int height, const MFVideoNormalizedRect *scale)
 429 {
 430     if (rect->left == 0.0f && rect->top == 0.0f && rect->right == 1.0f && rect->bottom == 1.0f)
 431     {
 432         SetRect(rect, 0, 0, width, height);
 433     }
 434     else
 435     {
 436         rect->left = width * scale->left;
 437         rect->right = width * scale->right;
 438         rect->top = height * scale->top;
 439         rect->bottom = height * scale->bottom;
 440     }
 441 }
 442
 443 static void video_presenter_sample_present(struct video_presenter *presenter, IMFSample *sample)
 444 {
 445     IDirect3DSurface9 *surface, *backbuffer;
 446     IDirect3DDevice9 *device;
 447     D3DSURFACE_DESC desc;
 448     RECT dst, src;
 449     HRESULT hr;
 450
 451     if (!presenter->swapchain)
 452         return;
 453
 454     if (FAILED(hr = video_presenter_get_sample_surface(sample, &surface)))
 455     {
 456         WARN("Failed to get sample surface, hr %#x.\n", hr);
 457         return;
 458     }
 459
 460     if (FAILED(hr = IDirect3DSwapChain9_GetBackBuffer(presenter->swapchain, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer)))
 461     {
 462         WARN("Failed to get a backbuffer, hr %#x.\n", hr);
 463         IDirect3DSurface9_Release(surface);
 464         return;
 465     }
 466
 467     IDirect3DSwapChain9_GetDevice(presenter->swapchain, &device);
 468     IDirect3DDevice9_StretchRect(device, surface, NULL, backbuffer, NULL, D3DTEXF_POINT);
 469
 470     IDirect3DSurface9_GetDesc(surface, &desc);
 471     scale_rect(&src, desc.Width, desc.Height, &presenter->src_rect);
 472
 473     IDirect3DSurface9_GetDesc(backbuffer, &desc);
 474     SetRect(&dst, 0, 0, desc.Width, desc.Height);
 475
 476     if (presenter->ar_mode & MFVideoARMode_PreservePicture)
 477     {
 478         unsigned int src_width = src.right - src.left, src_height = src.bottom - src.top;
 479         unsigned int dst_width = dst.right - dst.left, dst_height = dst.bottom - dst.top;
 480
 481         if (src_width * dst_height > dst_width * src_height)
 482         {
 483             /* src is "wider" than dst. */
 484             unsigned int dst_center = (dst.top + dst.bottom) / 2;
 485             unsigned int scaled_height = src_height * dst_width / src_width;
 486
 487             dst.top = dst_center - scaled_height / 2;
 488             dst.bottom = dst.top + scaled_height;
 489         }
 490         else if (src_width * dst_height < dst_width * src_height)
 491         {
 492             /* src is "taller" than dst. */
 493             unsigned int dst_center = (dst.left + dst.right) / 2;
 494             unsigned int scaled_width = src_width * dst_height / src_height;
 495
 496             dst.left = dst_center - scaled_width / 2;
 497             dst.right = dst.left + scaled_width;
 498         }
 499     }
 500
 501     IDirect3DSwapChain9_Present(presenter->swapchain, &src, &dst, NULL, NULL, 0);
 502
 503     IDirect3DDevice9_Release(device);
 504     IDirect3DSurface9_Release(backbuffer);
 505     IDirect3DSurface9_Release(surface);
 506 }
 507
 508 static void video_presenter_check_queue(struct video_presenter *presenter,
 509         unsigned int *next_wait)
 510 {
 511     LONGLONG pts, clocktime, delta;
 512     unsigned int wait = 0;
 513     BOOL present = TRUE;
 514     IMFSample *sample;
 515     MFTIME systime;
 516     HRESULT hr;
 517
 518     while (video_presenter_sample_queue_pop(presenter, &sample))
 519     {
 520         wait = 0;
 521
 522         if (presenter->clock)
 523         {
 524             pts = clocktime = 0;
 525
 526             hr = IMFSample_GetSampleTime(sample, &pts);
 527             if (SUCCEEDED(hr))
 528                 hr = IMFClock_GetCorrelatedTime(presenter->clock, 0, &clocktime, &systime);
 529
 530             delta = pts - clocktime;
 531             if (delta > 3 * presenter->frame_time_threshold)
 532             {
 533                 /* Convert 100ns -> msec */
 534                 wait = (delta - 3 * presenter->frame_time_threshold) / 100000;
 535                 present = FALSE;
 536             }
 537         }
 538
 539         if (present)
 540             video_presenter_sample_present(presenter, sample);
 541         else
 542             video_presenter_sample_queue_push(presenter, sample);
 543
 544         IMFSample_Release(sample);
 545
 546         if (wait > 0)
 547             break;
 548     }
 549
 550     if (!wait)
 551         wait = INFINITE;
 552
 553     *next_wait = wait;
 554 }
 555
 556 static void video_presenter_schedule_sample(struct video_presenter *presenter, IMFSample *sample)
 557 {
 558     if (!presenter->thread.tid)
 559     {
 560         WARN("Streaming thread hasn't been started.\n");
 561         return;
 562     }
 563
 564     if (presenter->clock)
 565     {
 566         video_presenter_sample_queue_push(presenter, sample);
 567         PostThreadMessageW(presenter->thread.tid, EVRM_PRESENT, 0, 0);
 568     }
 569     else
 570     {
 571         video_presenter_sample_present(presenter, sample);
 572     }
 573 }
 574
 575 static HRESULT video_presenter_process_input(struct video_presenter *presenter)
 576 {
 577     MFT_OUTPUT_DATA_BUFFER buffer;
 578     HRESULT hr = S_OK;
 579     IMFSample *sample;
 580     DWORD status;
 581
 582     if (!presenter->media_type)
 583         return S_OK;
 584
 585     while (hr == S_OK)
 586     {
 587         LONGLONG mixing_started, mixing_finished;
 588         MFTIME systime;
 589
 590         if (!(presenter->flags & PRESENTER_MIXER_HAS_INPUT))
 591             break;
 592
 593         if (FAILED(hr = IMFVideoSampleAllocator_AllocateSample(presenter->allocator, &sample)))
 594         {
 595             WARN("Failed to allocate a sample, hr %#x.\n", hr);
 596             break;
 597         }
 598
 599         memset(&buffer, 0, sizeof(buffer));
 600         buffer.pSample = sample;
 601
 602         if (presenter->clock)
 603             IMFClock_GetCorrelatedTime(presenter->clock, 0, &mixing_started, &systime);
 604
 605         if (FAILED(hr = IMFTransform_ProcessOutput(presenter->mixer, 0, 1, &buffer, &status)))
 606         {
 607             /* FIXME: failure path probably needs to handle some errors specifically */
 608             presenter->flags &= ~PRESENTER_MIXER_HAS_INPUT;
 609             IMFSample_Release(sample);
 610             break;
 611         }
 612         else
 613         {
 614             if (presenter->clock)
 615             {
 616                 LONGLONG latency;
 617
 618                 IMFClock_GetCorrelatedTime(presenter->clock, 0, &mixing_finished, &systime);
 619                 latency = mixing_finished - mixing_started;
 620                 video_presenter_notify_renderer(presenter, EC_PROCESSING_LATENCY, (LONG_PTR)&latency, 0);
 621             }
 622
 623             if (buffer.pEvents)
 624                 IMFCollection_Release(buffer.pEvents);
 625
 626             video_presenter_schedule_sample(presenter, sample);
 627
 628             IMFSample_Release(sample);
 629         }
 630     }
 631
 632     return S_OK;
 633 }
 634
 635 static DWORD CALLBACK video_presenter_streaming_thread(void *arg)
 636 {
 637     struct video_presenter *presenter = arg;
 638     unsigned int wait = INFINITE;
 639     BOOL stop_thread = FALSE;
 640     MSG msg;
 641
 642     PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 643
 644     SetEvent(presenter->thread.ready_event);
 645
 646     while (!stop_thread)
 647     {
 648         if (MsgWaitForMultipleObjects(0, NULL, FALSE, wait, QS_POSTMESSAGE) == WAIT_TIMEOUT)
 649             video_presenter_check_queue(presenter, &wait);
 650
 651         while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
 652         {
 653             BOOL peek = TRUE;
 654
 655             switch (msg.message)
 656             {
 657                 case EVRM_STOP:
 658                     stop_thread = TRUE;
 659                     break;
 660
 661                 case EVRM_PRESENT:
 662                     if (peek)
 663                     {
 664                         video_presenter_check_queue(presenter, &wait);
 665                         peek = wait != INFINITE;
 666                     }
 667                     break;
 668
 669                 case EVRM_PROCESS_INPUT:
 670                     EnterCriticalSection(&presenter->cs);
 671                     video_presenter_process_input(presenter);
 672                     LeaveCriticalSection(&presenter->cs);
 673                     break;
 674                 default:
 675                     ;
 676             }
 677         }
 678     }
 679
 680     return 0;
 681 }
 682
 683 static HRESULT video_presenter_start_streaming(struct video_presenter *presenter)
 684 {
 685     if (presenter->thread.hthread)
 686         return S_OK;
 687
 688     video_presenter_sample_queue_init(presenter);
 689
 690     if (!(presenter->thread.ready_event = CreateEventW(NULL, FALSE, FALSE, NULL)))
 691         return HRESULT_FROM_WIN32(GetLastError());
 692
 693     if (!(presenter->thread.hthread = CreateThread(NULL, 0, video_presenter_streaming_thread,
 694             presenter, 0, &presenter->thread.tid)))
 695     {
 696         WARN("Failed to create streaming thread.\n");
 697         CloseHandle(presenter->thread.ready_event);
 698         presenter->thread.ready_event = NULL;
 699         return E_FAIL;
 700     }
 701
 702     video_presenter_set_allocator_callback(presenter, &presenter->allocator_cb);
 703
 704     WaitForSingleObject(presenter->thread.ready_event, INFINITE);
 705     CloseHandle(presenter->thread.ready_event);
 706     presenter->thread.ready_event = NULL;
 707
 708     TRACE("Started streaming thread, tid %#x.\n", presenter->thread.tid);
 709
 710     return S_OK;
 711 }
 712
 713 static HRESULT video_presenter_end_streaming(struct video_presenter *presenter)
 714 {
 715     if (!presenter->thread.hthread)
 716         return S_OK;
 717
 718     PostThreadMessageW(presenter->thread.tid, EVRM_STOP, 0, 0);
 719
 720     WaitForSingleObject(presenter->thread.hthread, INFINITE);
 721     CloseHandle(presenter->thread.hthread);
 722
 723     TRACE("Terminated streaming thread tid %#x.\n", presenter->thread.tid);
 724
 725     memset(&presenter->thread, 0, sizeof(presenter->thread));
 726     video_presenter_set_allocator_callback(presenter, NULL);
 727
 728     return S_OK;
 729 }
 730
 731 static HRESULT WINAPI video_presenter_inner_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 732 {
 733     struct video_presenter *presenter = impl_from_IUnknown(iface);
 734
 735     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 736
 737     if (IsEqualIID(riid, &IID_IUnknown))
 738     {
 739         *obj = iface;
 740     }
 741     else if (IsEqualIID(riid, &IID_IMFClockStateSink)
 742             || IsEqualIID(riid, &IID_IMFVideoPresenter))
 743     {
 744         *obj = &presenter->IMFVideoPresenter_iface;
 745     }
 746     else if (IsEqualIID(riid, &IID_IMFVideoDeviceID))
 747     {
 748         *obj = &presenter->IMFVideoDeviceID_iface;
 749     }
 750     else if (IsEqualIID(riid, &IID_IMFTopologyServiceLookupClient))
 751     {
 752         *obj = &presenter->IMFTopologyServiceLookupClient_iface;
 753     }
 754     else if (IsEqualIID(riid, &IID_IMFVideoDisplayControl))
 755     {
 756         *obj = &presenter->IMFVideoDisplayControl_iface;
 757     }
 758     else if (IsEqualIID(riid, &IID_IMFRateSupport))
 759     {
 760         *obj = &presenter->IMFRateSupport_iface;
 761     }
 762     else if (IsEqualIID(riid, &IID_IMFGetService))
 763     {
 764         *obj = &presenter->IMFGetService_iface;
 765     }
 766     else if (IsEqualIID(riid, &IID_IMFVideoPositionMapper))
 767     {
 768         *obj = &presenter->IMFVideoPositionMapper_iface;
 769     }
 770     else if (IsEqualIID(riid, &IID_IQualProp))
 771     {
 772         *obj = &presenter->IQualProp_iface;
 773     }
 774     else if (IsEqualIID(riid, &IID_IMFQualityAdvise))
 775     {
 776         *obj = &presenter->IMFQualityAdvise_iface;
 777     }
 778     else if (IsEqualIID(riid, &IID_IDirect3DDeviceManager9))
 779     {
 780         *obj = &presenter->IDirect3DDeviceManager9_iface;
 781     }
 782     else
 783     {
 784         WARN("Unimplemented interface %s.\n", debugstr_guid(riid));
 785         *obj = NULL;
 786         return E_NOINTERFACE;
 787     }
 788
 789     IUnknown_AddRef((IUnknown *)*obj);
 790     return S_OK;
 791 }
 792
 793 static ULONG WINAPI video_presenter_inner_AddRef(IUnknown *iface)
 794 {
 795     struct video_presenter *presenter = impl_from_IUnknown(iface);
 796     ULONG refcount = InterlockedIncrement(&presenter->refcount);
 797
 798     TRACE("%p, refcount %u.\n", iface, refcount);
 799
 800     return refcount;
 801 }
 802
 803 static void video_presenter_clear_container(struct video_presenter *presenter)
 804 {
 805     if (presenter->clock)
 806         IMFClock_Release(presenter->clock);
 807     if (presenter->mixer)
 808         IMFTransform_Release(presenter->mixer);
 809     if (presenter->event_sink)
 810         IMediaEventSink_Release(presenter->event_sink);
 811     presenter->clock = NULL;
 812     presenter->mixer = NULL;
 813     presenter->event_sink = NULL;
 814 }
 815
 816 static ULONG WINAPI video_presenter_inner_Release(IUnknown *iface)
 817 {
 818     struct video_presenter *presenter = impl_from_IUnknown(iface);
 819     ULONG refcount = InterlockedDecrement(&presenter->refcount);
 820
 821     TRACE("%p, refcount %u.\n", iface, refcount);
 822
 823     if (!refcount)
 824     {
 825         video_presenter_end_streaming(presenter);
 826         video_presenter_clear_container(presenter);
 827         video_presenter_reset_media_type(presenter);
 828         DeleteCriticalSection(&presenter->cs);
 829         if (presenter->swapchain)
 830             IDirect3DSwapChain9_Release(presenter->swapchain);
 831         if (presenter->device_manager)
 832         {
 833             IDirect3DDeviceManager9_CloseDeviceHandle(presenter->device_manager, presenter->hdevice);
 834             IDirect3DDeviceManager9_Release(presenter->device_manager);
 835         }
 836         if (presenter->allocator)
 837             IMFVideoSampleAllocator_Release(presenter->allocator);
 838         free(presenter);
 839     }
 840
 841     return refcount;
 842 }
 843
 844 static const IUnknownVtbl video_presenter_inner_vtbl =
 845 {
 846     video_presenter_inner_QueryInterface,
 847     video_presenter_inner_AddRef,
 848     video_presenter_inner_Release,
 849 };
 850
 851 static HRESULT WINAPI video_presenter_QueryInterface(IMFVideoPresenter *iface, REFIID riid, void **obj)
 852 {
 853     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 854     return IUnknown_QueryInterface(presenter->outer_unk, riid, obj);
 855 }
 856
 857 static ULONG WINAPI video_presenter_AddRef(IMFVideoPresenter *iface)
 858 {
 859     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 860     return IUnknown_AddRef(presenter->outer_unk);
 861 }
 862
 863 static ULONG WINAPI video_presenter_Release(IMFVideoPresenter *iface)
 864 {
 865     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 866     return IUnknown_Release(presenter->outer_unk);
 867 }
 868
 869 static HRESULT WINAPI video_presenter_OnClockStart(IMFVideoPresenter *iface, MFTIME systime, LONGLONG offset)
 870 {
 871     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 872
 873     TRACE("%p, %s, %s.\n", iface, debugstr_time(systime), wine_dbgstr_longlong(offset));
 874
 875     EnterCriticalSection(&presenter->cs);
 876     presenter->state = PRESENTER_STATE_STARTED;
 877     LeaveCriticalSection(&presenter->cs);
 878
 879     return S_OK;
 880 }
 881
 882 static HRESULT WINAPI video_presenter_OnClockStop(IMFVideoPresenter *iface, MFTIME systime)
 883 {
 884     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 885
 886     TRACE("%p, %s.\n", iface, debugstr_time(systime));
 887
 888     EnterCriticalSection(&presenter->cs);
 889     presenter->state = PRESENTER_STATE_STOPPED;
 890     LeaveCriticalSection(&presenter->cs);
 891
 892     return S_OK;
 893 }
 894
 895 static HRESULT WINAPI video_presenter_OnClockPause(IMFVideoPresenter *iface, MFTIME systime)
 896 {
 897     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 898
 899     TRACE("%p, %s.\n", iface, debugstr_time(systime));
 900
 901     EnterCriticalSection(&presenter->cs);
 902     presenter->state = PRESENTER_STATE_PAUSED;
 903     LeaveCriticalSection(&presenter->cs);
 904
 905     return S_OK;
 906 }
 907
 908 static HRESULT WINAPI video_presenter_OnClockRestart(IMFVideoPresenter *iface, MFTIME systime)
 909 {
 910     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 911
 912     TRACE("%p, %s.\n", iface, debugstr_time(systime));
 913
 914     EnterCriticalSection(&presenter->cs);
 915     presenter->state = PRESENTER_STATE_STARTED;
 916     LeaveCriticalSection(&presenter->cs);
 917
 918     return S_OK;
 919 }
 920
 921 static HRESULT WINAPI video_presenter_OnClockSetRate(IMFVideoPresenter *iface, MFTIME systime, float rate)
 922 {
 923     FIXME("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
 924
 925     return E_NOTIMPL;
 926 }
 927
 928 static HRESULT WINAPI video_presenter_ProcessMessage(IMFVideoPresenter *iface, MFVP_MESSAGE_TYPE message, ULONG_PTR param)
 929 {
 930     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 931     HRESULT hr;
 932
 933     TRACE("%p, %d, %lu.\n", iface, message, param);
 934
 935     EnterCriticalSection(&presenter->cs);
 936
 937     switch (message)
 938     {
 939         case MFVP_MESSAGE_INVALIDATEMEDIATYPE:
 940             hr = video_presenter_invalidate_media_type(presenter);
 941             break;
 942         case MFVP_MESSAGE_BEGINSTREAMING:
 943             hr = video_presenter_start_streaming(presenter);
 944             break;
 945         case MFVP_MESSAGE_ENDSTREAMING:
 946             hr = video_presenter_end_streaming(presenter);
 947             break;
 948         case MFVP_MESSAGE_PROCESSINPUTNOTIFY:
 949             presenter->flags |= PRESENTER_MIXER_HAS_INPUT;
 950             hr = video_presenter_process_input(presenter);
 951             break;
 952         default:
 953             FIXME("Unsupported message %u.\n", message);
 954             hr = E_NOTIMPL;
 955     }
 956
 957     LeaveCriticalSection(&presenter->cs);
 958
 959     return hr;
 960 }
 961
 962 static HRESULT WINAPI video_presenter_GetCurrentMediaType(IMFVideoPresenter *iface,
 963         IMFVideoMediaType **media_type)
 964 {
 965     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 966     HRESULT hr;
 967
 968     TRACE("%p, %p.\n", iface, media_type);
 969
 970     EnterCriticalSection(&presenter->cs);
 971
 972     if (presenter->state == PRESENTER_STATE_SHUT_DOWN)
 973         hr = MF_E_SHUTDOWN;
 974     else if (!presenter->media_type)
 975         hr = MF_E_NOT_INITIALIZED;
 976     else
 977     {
 978         hr = IMFMediaType_QueryInterface(presenter->media_type, &IID_IMFVideoMediaType,
 979                 (void **)media_type);
 980     }
 981
 982     LeaveCriticalSection(&presenter->cs);
 983
 984     return hr;
 985 }
 986
 987 static const IMFVideoPresenterVtbl video_presenter_vtbl =
 988 {
 989     video_presenter_QueryInterface,
 990     video_presenter_AddRef,
 991     video_presenter_Release,
 992     video_presenter_OnClockStart,
 993     video_presenter_OnClockStop,
 994     video_presenter_OnClockPause,
 995     video_presenter_OnClockRestart,
 996     video_presenter_OnClockSetRate,
 997     video_presenter_ProcessMessage,
 998     video_presenter_GetCurrentMediaType,
 999 };
1000
1001 static HRESULT WINAPI video_presenter_device_id_QueryInterface(IMFVideoDeviceID *iface, REFIID riid, void **obj)
1002 {
1003     struct video_presenter *presenter = impl_from_IMFVideoDeviceID(iface);
1004     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
1005 }
1006
1007 static ULONG WINAPI video_presenter_device_id_AddRef(IMFVideoDeviceID *iface)
1008 {
1009     struct video_presenter *presenter = impl_from_IMFVideoDeviceID(iface);
1010     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1011 }
1012
1013 static ULONG WINAPI video_presenter_device_id_Release(IMFVideoDeviceID *iface)
1014 {
1015     struct video_presenter *presenter = impl_from_IMFVideoDeviceID(iface);
1016     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1017 }
1018
1019 static HRESULT WINAPI video_presenter_device_id_GetDeviceID(IMFVideoDeviceID *iface, IID *device_id)
1020 {
1021     TRACE("%p, %p.\n", iface, device_id);
1022
1023     if (!device_id)
1024         return E_POINTER;
1025
1026     memcpy(device_id, &IID_IDirect3DDevice9, sizeof(*device_id));
1027
1028     return S_OK;
1029 }
1030
1031 static const IMFVideoDeviceIDVtbl video_presenter_device_id_vtbl =
1032 {
1033     video_presenter_device_id_QueryInterface,
1034     video_presenter_device_id_AddRef,
1035     video_presenter_device_id_Release,
1036     video_presenter_device_id_GetDeviceID,
1037 };
1038
1039 static HRESULT WINAPI video_presenter_service_client_QueryInterface(IMFTopologyServiceLookupClient *iface,
1040         REFIID riid, void **obj)
1041 {
1042     struct video_presenter *presenter = impl_from_IMFTopologyServiceLookupClient(iface);
1043     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
1044 }
1045
1046 static ULONG WINAPI video_presenter_service_client_AddRef(IMFTopologyServiceLookupClient *iface)
1047 {
1048     struct video_presenter *presenter = impl_from_IMFTopologyServiceLookupClient(iface);
1049     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1050 }
1051
1052 static ULONG WINAPI video_presenter_service_client_Release(IMFTopologyServiceLookupClient *iface)
1053 {
1054     struct video_presenter *presenter = impl_from_IMFTopologyServiceLookupClient(iface);
1055     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1056 }
1057
1058 static void video_presenter_set_mixer_rect(struct video_presenter *presenter)
1059 {
1060     IMFAttributes *attributes;
1061     HRESULT hr;
1062
1063     if (!presenter->mixer)
1064         return;
1065
1066     if (SUCCEEDED(IMFTransform_GetAttributes(presenter->mixer, &attributes)))
1067     {
1068         if (FAILED(hr = IMFAttributes_SetBlob(attributes, &VIDEO_ZOOM_RECT, (const UINT8 *)&presenter->src_rect,
1069                 sizeof(presenter->src_rect))))
1070         {
1071             WARN("Failed to set zoom rectangle attribute, hr %#x.\n", hr);
1072         }
1073         IMFAttributes_Release(attributes);
1074     }
1075 }
1076
1077 static HRESULT video_presenter_attach_mixer(struct video_presenter *presenter, IMFTopologyServiceLookup *service_lookup)
1078 {
1079     IMFVideoDeviceID *device_id;
1080     unsigned int count;
1081     GUID id = { 0 };
1082     HRESULT hr;
1083
1084     count = 1;
1085     if (FAILED(hr = IMFTopologyServiceLookup_LookupService(service_lookup, MF_SERVICE_LOOKUP_GLOBAL, 0,
1086             &MR_VIDEO_MIXER_SERVICE, &IID_IMFTransform, (void **)&presenter->mixer, &count)))
1087     {
1088         WARN("Failed to get mixer interface, hr %#x.\n", hr);
1089         return hr;
1090     }
1091
1092     if (SUCCEEDED(hr = IMFTransform_QueryInterface(presenter->mixer, &IID_IMFVideoDeviceID, (void **)&device_id)))
1093     {
1094         if (SUCCEEDED(hr = IMFVideoDeviceID_GetDeviceID(device_id, &id)))
1095         {
1096             if (!IsEqualGUID(&id, &IID_IDirect3DDevice9))
1097                 hr = MF_E_INVALIDREQUEST;
1098         }
1099
1100         IMFVideoDeviceID_Release(device_id);
1101     }
1102
1103     if (FAILED(hr))
1104     {
1105         IMFTransform_Release(presenter->mixer);
1106         presenter->mixer = NULL;
1107     }
1108
1109     video_presenter_set_mixer_rect(presenter);
1110     video_presenter_get_native_video_size(presenter);
1111
1112     return hr;
1113 }
1114
1115 static HRESULT WINAPI video_presenter_service_client_InitServicePointers(IMFTopologyServiceLookupClient *iface,
1116         IMFTopologyServiceLookup *service_lookup)
1117 {
1118     struct video_presenter *presenter = impl_from_IMFTopologyServiceLookupClient(iface);
1119     unsigned int count;
1120     HRESULT hr = S_OK;
1121
1122     TRACE("%p, %p.\n", iface, service_lookup);
1123
1124     if (!service_lookup)
1125         return E_POINTER;
1126
1127     EnterCriticalSection(&presenter->cs);
1128
1129     if (presenter->state == PRESENTER_STATE_STARTED ||
1130             presenter->state == PRESENTER_STATE_PAUSED)
1131     {
1132         hr = MF_E_INVALIDREQUEST;
1133     }
1134     else
1135     {
1136         video_presenter_clear_container(presenter);
1137
1138         count = 1;
1139         IMFTopologyServiceLookup_LookupService(service_lookup, MF_SERVICE_LOOKUP_GLOBAL, 0,
1140                 &MR_VIDEO_RENDER_SERVICE, &IID_IMFClock, (void **)&presenter->clock, &count);
1141
1142         hr = video_presenter_attach_mixer(presenter, service_lookup);
1143
1144         if (SUCCEEDED(hr))
1145         {
1146             count = 1;
1147             if (FAILED(hr = IMFTopologyServiceLookup_LookupService(service_lookup, MF_SERVICE_LOOKUP_GLOBAL, 0,
1148                     &MR_VIDEO_RENDER_SERVICE, &IID_IMediaEventSink, (void **)&presenter->event_sink, &count)))
1149             {
1150                 WARN("Failed to get renderer event sink, hr %#x.\n", hr);
1151             }
1152         }
1153
1154         if (SUCCEEDED(hr))
1155             presenter->state = PRESENTER_STATE_STOPPED;
1156     }
1157
1158     LeaveCriticalSection(&presenter->cs);
1159
1160     return hr;
1161 }
1162
1163 static HRESULT WINAPI video_presenter_service_client_ReleaseServicePointers(IMFTopologyServiceLookupClient *iface)
1164 {
1165     struct video_presenter *presenter = impl_from_IMFTopologyServiceLookupClient(iface);
1166
1167     TRACE("%p.\n", iface);
1168
1169     EnterCriticalSection(&presenter->cs);
1170
1171     presenter->state = PRESENTER_STATE_SHUT_DOWN;
1172     video_presenter_clear_container(presenter);
1173
1174     LeaveCriticalSection(&presenter->cs);
1175
1176     return S_OK;
1177 }
1178
1179 static const IMFTopologyServiceLookupClientVtbl video_presenter_service_client_vtbl =
1180 {
1181     video_presenter_service_client_QueryInterface,
1182     video_presenter_service_client_AddRef,
1183     video_presenter_service_client_Release,
1184     video_presenter_service_client_InitServicePointers,
1185     video_presenter_service_client_ReleaseServicePointers,
1186 };
1187
1188 static HRESULT WINAPI video_presenter_control_QueryInterface(IMFVideoDisplayControl *iface, REFIID riid, void **obj)
1189 {
1190     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1191     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
1192 }
1193
1194 static ULONG WINAPI video_presenter_control_AddRef(IMFVideoDisplayControl *iface)
1195 {
1196     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1197     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1198 }
1199
1200 static ULONG WINAPI video_presenter_control_Release(IMFVideoDisplayControl *iface)
1201 {
1202     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1203     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1204 }
1205
1206 static HRESULT WINAPI video_presenter_control_GetNativeVideoSize(IMFVideoDisplayControl *iface, SIZE *video_size,
1207         SIZE *aspect_ratio)
1208 {
1209     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1210
1211     TRACE("%p, %p, %p.\n", iface, video_size, aspect_ratio);
1212
1213     if (!video_size && !aspect_ratio)
1214         return E_POINTER;
1215
1216     EnterCriticalSection(&presenter->cs);
1217     if (video_size)
1218         *video_size = presenter->native_size;
1219     if (aspect_ratio)
1220         *aspect_ratio = presenter->native_ratio;
1221     LeaveCriticalSection(&presenter->cs);
1222
1223     return S_OK;
1224 }
1225
1226 static HRESULT WINAPI video_presenter_control_GetIdealVideoSize(IMFVideoDisplayControl *iface, SIZE *min_size,
1227         SIZE *max_size)
1228 {
1229     FIXME("%p, %p, %p.\n", iface, min_size, max_size);
1230
1231     return E_NOTIMPL;
1232 }
1233
1234 static HRESULT WINAPI video_presenter_control_SetVideoPosition(IMFVideoDisplayControl *iface,
1235         const MFVideoNormalizedRect *src_rect, const RECT *dst_rect)
1236 {
1237     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1238     HRESULT hr = S_OK;
1239
1240     TRACE("%p, %p, %s.\n", iface, src_rect, wine_dbgstr_rect(dst_rect));
1241
1242     if (!src_rect && !dst_rect)
1243         return E_POINTER;
1244
1245     if (src_rect && (src_rect->left < 0.0f || src_rect->top < 0.0f ||
1246             src_rect->right > 1.0f || src_rect->bottom > 1.0f ||
1247             src_rect->left > src_rect->right ||
1248             src_rect->top > src_rect->bottom))
1249     {
1250         return E_INVALIDARG;
1251     }
1252
1253     if (dst_rect && (dst_rect->left > dst_rect->right ||
1254             dst_rect->top > dst_rect->bottom))
1255         return E_INVALIDARG;
1256
1257     EnterCriticalSection(&presenter->cs);
1258     if (!presenter->video_window)
1259         hr = E_POINTER;
1260     else
1261     {
1262         if (src_rect)
1263         {
1264             if (memcmp(&presenter->src_rect, src_rect, sizeof(*src_rect)))
1265             {
1266                 presenter->src_rect = *src_rect;
1267                 video_presenter_set_mixer_rect(presenter);
1268             }
1269         }
1270         if (dst_rect)
1271             presenter->dst_rect = *dst_rect;
1272     }
1273     LeaveCriticalSection(&presenter->cs);
1274
1275     return hr;
1276 }
1277
1278 static HRESULT WINAPI video_presenter_control_GetVideoPosition(IMFVideoDisplayControl *iface, MFVideoNormalizedRect *src_rect,
1279         RECT *dst_rect)
1280 {
1281     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1282
1283     TRACE("%p, %p, %p.\n", iface, src_rect, dst_rect);
1284
1285     if (!src_rect || !dst_rect)
1286         return E_POINTER;
1287
1288     EnterCriticalSection(&presenter->cs);
1289     *src_rect = presenter->src_rect;
1290     *dst_rect = presenter->dst_rect;
1291     LeaveCriticalSection(&presenter->cs);
1292
1293     return S_OK;
1294 }
1295
1296 static HRESULT WINAPI video_presenter_control_SetAspectRatioMode(IMFVideoDisplayControl *iface, DWORD mode)
1297 {
1298     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1299
1300     TRACE("%p, %#x.\n", iface, mode);
1301
1302     if (mode & ~MFVideoARMode_Mask)
1303         return E_INVALIDARG;
1304
1305     EnterCriticalSection(&presenter->cs);
1306     presenter->ar_mode = mode;
1307     LeaveCriticalSection(&presenter->cs);
1308
1309     return S_OK;
1310 }
1311
1312 static HRESULT WINAPI video_presenter_control_GetAspectRatioMode(IMFVideoDisplayControl *iface, DWORD *mode)
1313 {
1314     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1315
1316     TRACE("%p, %p.\n", iface, mode);
1317
1318     if (!mode)
1319         return E_POINTER;
1320
1321     EnterCriticalSection(&presenter->cs);
1322     *mode = presenter->ar_mode;
1323     LeaveCriticalSection(&presenter->cs);
1324
1325     return S_OK;
1326 }
1327
1328 static HRESULT video_presenter_create_swapchain(struct video_presenter *presenter)
1329 {
1330     D3DPRESENT_PARAMETERS present_params = { 0 };
1331     IDirect3DDevice9 *d3d_device;
1332     HRESULT hr;
1333
1334     if (SUCCEEDED(hr = video_presenter_get_device(presenter, &d3d_device)))
1335     {
1336         present_params.hDeviceWindow = presenter->video_window;
1337         present_params.Windowed = TRUE;
1338         present_params.SwapEffect = D3DSWAPEFFECT_COPY;
1339         present_params.Flags = D3DPRESENTFLAG_VIDEO;
1340         present_params.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
1341         hr = IDirect3DDevice9_CreateAdditionalSwapChain(d3d_device, &present_params, &presenter->swapchain);
1342
1343         IDirect3DDevice9_Release(d3d_device);
1344         IDirect3DDeviceManager9_UnlockDevice(presenter->device_manager, presenter->hdevice, FALSE);
1345     }
1346
1347     return hr;
1348 }
1349
1350 static HRESULT WINAPI video_presenter_control_SetVideoWindow(IMFVideoDisplayControl *iface, HWND window)
1351 {
1352     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1353     HRESULT hr = S_OK;
1354
1355     TRACE("%p, %p.\n", iface, window);
1356
1357     if (!IsWindow(window))
1358         return E_INVALIDARG;
1359
1360     EnterCriticalSection(&presenter->cs);
1361     if (presenter->video_window != window)
1362     {
1363         if (presenter->swapchain)
1364             IDirect3DSwapChain9_Release(presenter->swapchain);
1365         presenter->video_window = window;
1366         hr = video_presenter_create_swapchain(presenter);
1367     }
1368     LeaveCriticalSection(&presenter->cs);
1369
1370     return hr;
1371 }
1372
1373 static HRESULT WINAPI video_presenter_control_GetVideoWindow(IMFVideoDisplayControl *iface, HWND *window)
1374 {
1375     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1376
1377     TRACE("%p, %p.\n", iface, window);
1378
1379     if (!window)
1380         return E_POINTER;
1381
1382     EnterCriticalSection(&presenter->cs);
1383     *window = presenter->video_window;
1384     LeaveCriticalSection(&presenter->cs);
1385
1386     return S_OK;
1387 }
1388
1389 static HRESULT WINAPI video_presenter_control_RepaintVideo(IMFVideoDisplayControl *iface)
1390 {
1391     FIXME("%p.\n", iface);
1392
1393     return E_NOTIMPL;
1394 }
1395
1396 static HRESULT WINAPI video_presenter_control_GetCurrentImage(IMFVideoDisplayControl *iface, BITMAPINFOHEADER *header,
1397         BYTE **dib, DWORD *dib_size, LONGLONG *timestamp)
1398 {
1399     FIXME("%p, %p, %p, %p, %p.\n", iface, header, dib, dib_size, timestamp);
1400
1401     return E_NOTIMPL;
1402 }
1403
1404 static HRESULT WINAPI video_presenter_control_SetBorderColor(IMFVideoDisplayControl *iface, COLORREF color)
1405 {
1406     FIXME("%p, %#x.\n", iface, color);
1407
1408     return E_NOTIMPL;
1409 }
1410
1411 static HRESULT WINAPI video_presenter_control_GetBorderColor(IMFVideoDisplayControl *iface, COLORREF *color)
1412 {
1413     FIXME("%p, %p.\n", iface, color);
1414
1415     return E_NOTIMPL;
1416 }
1417
1418 static HRESULT WINAPI video_presenter_control_SetRenderingPrefs(IMFVideoDisplayControl *iface, DWORD flags)
1419 {
1420     FIXME("%p, %#x.\n", iface, flags);
1421
1422     return E_NOTIMPL;
1423 }
1424
1425 static HRESULT WINAPI video_presenter_control_GetRenderingPrefs(IMFVideoDisplayControl *iface, DWORD *flags)
1426 {
1427     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
1428
1429     TRACE("%p, %p.\n", iface, flags);
1430
1431     if (!flags)
1432         return E_POINTER;
1433
1434     EnterCriticalSection(&presenter->cs);
1435     *flags = presenter->rendering_prefs;
1436     LeaveCriticalSection(&presenter->cs);
1437
1438     return S_OK;
1439 }
1440
1441 static HRESULT WINAPI video_presenter_control_SetFullscreen(IMFVideoDisplayControl *iface, BOOL fullscreen)
1442 {
1443     FIXME("%p, %d.\n", iface, fullscreen);
1444
1445     return E_NOTIMPL;
1446 }
1447
1448 static HRESULT WINAPI video_presenter_control_GetFullscreen(IMFVideoDisplayControl *iface, BOOL *fullscreen)
1449 {
1450     FIXME("%p, %p.\n", iface, fullscreen);
1451
1452     return E_NOTIMPL;
1453 }
1454
1455 static const IMFVideoDisplayControlVtbl video_presenter_control_vtbl =
1456 {
1457     video_presenter_control_QueryInterface,
1458     video_presenter_control_AddRef,
1459     video_presenter_control_Release,
1460     video_presenter_control_GetNativeVideoSize,
1461     video_presenter_control_GetIdealVideoSize,
1462     video_presenter_control_SetVideoPosition,
1463     video_presenter_control_GetVideoPosition,
1464     video_presenter_control_SetAspectRatioMode,
1465     video_presenter_control_GetAspectRatioMode,
1466     video_presenter_control_SetVideoWindow,
1467     video_presenter_control_GetVideoWindow,
1468     video_presenter_control_RepaintVideo,
1469     video_presenter_control_GetCurrentImage,
1470     video_presenter_control_SetBorderColor,
1471     video_presenter_control_GetBorderColor,
1472     video_presenter_control_SetRenderingPrefs,
1473     video_presenter_control_GetRenderingPrefs,
1474     video_presenter_control_SetFullscreen,
1475     video_presenter_control_GetFullscreen,
1476 };
1477
1478 static HRESULT WINAPI video_presenter_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **obj)
1479 {
1480     struct video_presenter *presenter = impl_from_IMFRateSupport(iface);
1481     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
1482 }
1483
1484 static ULONG WINAPI video_presenter_rate_support_AddRef(IMFRateSupport *iface)
1485 {
1486     struct video_presenter *presenter = impl_from_IMFRateSupport(iface);
1487     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1488 }
1489
1490 static ULONG WINAPI video_presenter_rate_support_Release(IMFRateSupport *iface)
1491 {
1492     struct video_presenter *presenter = impl_from_IMFRateSupport(iface);
1493     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1494 }
1495
1496 static HRESULT WINAPI video_presenter_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
1497         BOOL thin, float *rate)
1498 {
1499     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
1500
1501     *rate = 0.0f;
1502
1503     return S_OK;
1504 }
1505
1506 static HRESULT WINAPI video_presenter_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
1507         BOOL thin, float *rate)
1508 {
1509     return E_NOTIMPL;
1510 }
1511
1512 static HRESULT WINAPI video_presenter_rate_support_IsRateSupported(IMFRateSupport *iface, BOOL thin, float rate,
1513         float *nearest_supported_rate)
1514 {
1515     return E_NOTIMPL;
1516 }
1517
1518 static const IMFRateSupportVtbl video_presenter_rate_support_vtbl =
1519 {
1520     video_presenter_rate_support_QueryInterface,
1521     video_presenter_rate_support_AddRef,
1522     video_presenter_rate_support_Release,
1523     video_presenter_rate_support_GetSlowestRate,
1524     video_presenter_rate_support_GetFastestRate,
1525     video_presenter_rate_support_IsRateSupported,
1526 };
1527
1528 static HRESULT WINAPI video_presenter_getservice_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
1529 {
1530     struct video_presenter *presenter = impl_from_IMFGetService(iface);
1531     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
1532 }
1533
1534 static ULONG WINAPI video_presenter_getservice_AddRef(IMFGetService *iface)
1535 {
1536     struct video_presenter *presenter = impl_from_IMFGetService(iface);
1537     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1538 }
1539
1540 static ULONG WINAPI video_presenter_getservice_Release(IMFGetService *iface)
1541 {
1542     struct video_presenter *presenter = impl_from_IMFGetService(iface);
1543     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1544 }
1545
1546 static HRESULT WINAPI video_presenter_getservice_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
1547 {
1548     struct video_presenter *presenter = impl_from_IMFGetService(iface);
1549
1550     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
1551
1552     if (IsEqualGUID(&MR_VIDEO_ACCELERATION_SERVICE, service))
1553         return IDirect3DDeviceManager9_QueryInterface(presenter->device_manager, riid, obj);
1554
1555     if (IsEqualGUID(&MR_VIDEO_RENDER_SERVICE, service))
1556         return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
1557
1558     FIXME("Unimplemented service %s.\n", debugstr_guid(service));
1559
1560     return MF_E_UNSUPPORTED_SERVICE;
1561 }
1562
1563 static const IMFGetServiceVtbl video_presenter_getservice_vtbl =
1564 {
1565     video_presenter_getservice_QueryInterface,
1566     video_presenter_getservice_AddRef,
1567     video_presenter_getservice_Release,
1568     video_presenter_getservice_GetService,
1569 };
1570
1571 static HRESULT WINAPI video_presenter_position_mapper_QueryInterface(IMFVideoPositionMapper *iface, REFIID riid, void **obj)
1572 {
1573     struct video_presenter *presenter = impl_from_IMFVideoPositionMapper(iface);
1574     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
1575 }
1576
1577 static ULONG WINAPI video_presenter_position_mapper_AddRef(IMFVideoPositionMapper *iface)
1578 {
1579     struct video_presenter *presenter = impl_from_IMFVideoPositionMapper(iface);
1580     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1581 }
1582
1583 static ULONG WINAPI video_presenter_position_mapper_Release(IMFVideoPositionMapper *iface)
1584 {
1585     struct video_presenter *presenter = impl_from_IMFVideoPositionMapper(iface);
1586     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1587 }
1588
1589 static HRESULT WINAPI video_presenter_position_mapper_MapOutputCoordinateToInputStream(IMFVideoPositionMapper *iface,
1590         float x_out, float y_out, DWORD output_stream, DWORD input_stream, float *x_in, float *y_in)
1591 {
1592     FIXME("%p, %f, %f, %u, %u, %p, %p.\n", iface, x_out, y_out, output_stream, input_stream, x_in, y_in);
1593
1594     return E_NOTIMPL;
1595 }
1596
1597 static const IMFVideoPositionMapperVtbl video_presenter_position_mapper_vtbl =
1598 {
1599     video_presenter_position_mapper_QueryInterface,
1600     video_presenter_position_mapper_AddRef,
1601     video_presenter_position_mapper_Release,
1602     video_presenter_position_mapper_MapOutputCoordinateToInputStream,
1603 };
1604
1605 static HRESULT WINAPI video_presenter_allocator_cb_QueryInterface(IMFVideoSampleAllocatorNotify *iface,
1606         REFIID riid, void **obj)
1607 {
1608     if (IsEqualIID(riid, &IID_IMFVideoSampleAllocatorNotify) ||
1609             IsEqualIID(riid, &IID_IUnknown))
1610     {
1611         *obj = iface;
1612         IMFVideoSampleAllocatorNotify_AddRef(iface);
1613         return S_OK;
1614     }
1615
1616     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1617     *obj = NULL;
1618     return E_NOINTERFACE;
1619 }
1620
1621 static ULONG WINAPI video_presenter_allocator_cb_AddRef(IMFVideoSampleAllocatorNotify *iface)
1622 {
1623     struct video_presenter *presenter = impl_from_IMFVideoSampleAllocatorNotify(iface);
1624     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1625 }
1626
1627 static ULONG WINAPI video_presenter_allocator_cb_Release(IMFVideoSampleAllocatorNotify *iface)
1628 {
1629     struct video_presenter *presenter = impl_from_IMFVideoSampleAllocatorNotify(iface);
1630     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1631 }
1632
1633 static HRESULT WINAPI video_presenter_allocator_cb_NotifyRelease(IMFVideoSampleAllocatorNotify *iface)
1634 {
1635     struct video_presenter *presenter = impl_from_IMFVideoSampleAllocatorNotify(iface);
1636
1637     /* Release notification is executed under allocator lock, instead of processing samples here
1638        notify streaming thread. */
1639     PostThreadMessageW(presenter->thread.tid, EVRM_PROCESS_INPUT, 0, 0);
1640
1641     return S_OK;
1642 }
1643
1644 static const IMFVideoSampleAllocatorNotifyVtbl video_presenter_allocator_cb_vtbl =
1645 {
1646     video_presenter_allocator_cb_QueryInterface,
1647     video_presenter_allocator_cb_AddRef,
1648     video_presenter_allocator_cb_Release,
1649     video_presenter_allocator_cb_NotifyRelease,
1650 };
1651
1652 static HRESULT WINAPI video_presenter_qualprop_QueryInterface(IQualProp *iface, REFIID riid, void **obj)
1653 {
1654     struct video_presenter *presenter = impl_from_IQualProp(iface);
1655     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
1656 }
1657
1658 static ULONG WINAPI video_presenter_qualprop_AddRef(IQualProp *iface)
1659 {
1660     struct video_presenter *presenter = impl_from_IQualProp(iface);
1661     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1662 }
1663
1664 static ULONG WINAPI video_presenter_qualprop_Release(IQualProp *iface)
1665 {
1666     struct video_presenter *presenter = impl_from_IQualProp(iface);
1667     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1668 }
1669
1670 static HRESULT WINAPI video_presenter_qualprop_get_FramesDroppedInRenderer(IQualProp *iface, int *frames)
1671 {
1672     FIXME("%p, %p stub.\n", iface, frames);
1673
1674     return E_NOTIMPL;
1675 }
1676
1677 static HRESULT WINAPI video_presenter_qualprop_get_FramesDrawn(IQualProp *iface, int *frames)
1678 {
1679     FIXME("%p, %p stub.\n", iface, frames);
1680
1681     return E_NOTIMPL;
1682 }
1683
1684 static HRESULT WINAPI video_presenter_qualprop_get_AvgFrameRate(IQualProp *iface, int *avg_frame_rate)
1685 {
1686     FIXME("%p, %p stub.\n", iface, avg_frame_rate);
1687
1688     return E_NOTIMPL;
1689 }
1690
1691 static HRESULT WINAPI video_presenter_qualprop_get_Jitter(IQualProp *iface, int *jitter)
1692 {
1693     FIXME("%p, %p stub.\n", iface, jitter);
1694
1695     return E_NOTIMPL;
1696 }
1697
1698 static HRESULT WINAPI video_presenter_qualprop_get_AvgSyncOffset(IQualProp *iface, int *offset)
1699 {
1700     FIXME("%p, %p stub.\n", iface, offset);
1701
1702     return E_NOTIMPL;
1703 }
1704
1705 static HRESULT WINAPI video_presenter_qualprop_get_DevSyncOffset(IQualProp *iface, int *devoffset)
1706 {
1707     FIXME("%p, %p stub.\n", iface, devoffset);
1708
1709     return E_NOTIMPL;
1710 }
1711
1712 static const IQualPropVtbl video_presenter_qualprop_vtbl =
1713 {
1714     video_presenter_qualprop_QueryInterface,
1715     video_presenter_qualprop_AddRef,
1716     video_presenter_qualprop_Release,
1717     video_presenter_qualprop_get_FramesDroppedInRenderer,
1718     video_presenter_qualprop_get_FramesDrawn,
1719     video_presenter_qualprop_get_AvgFrameRate,
1720     video_presenter_qualprop_get_Jitter,
1721     video_presenter_qualprop_get_AvgSyncOffset,
1722     video_presenter_qualprop_get_DevSyncOffset,
1723 };
1724
1725 static HRESULT WINAPI video_presenter_quality_advise_QueryInterface(IMFQualityAdvise *iface, REFIID riid, void **out)
1726 {
1727     struct video_presenter *presenter = impl_from_IMFQualityAdvise(iface);
1728     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, out);
1729 }
1730
1731 static ULONG WINAPI video_presenter_quality_advise_AddRef(IMFQualityAdvise *iface)
1732 {
1733     struct video_presenter *presenter = impl_from_IMFQualityAdvise(iface);
1734     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1735 }
1736
1737 static ULONG WINAPI video_presenter_quality_advise_Release(IMFQualityAdvise *iface)
1738 {
1739     struct video_presenter *presenter = impl_from_IMFQualityAdvise(iface);
1740     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1741 }
1742
1743 static HRESULT WINAPI video_presenter_quality_advise_SetDropMode(IMFQualityAdvise *iface,
1744         MF_QUALITY_DROP_MODE mode)
1745 {
1746     FIXME("%p, %u.\n", iface, mode);
1747
1748     return E_NOTIMPL;
1749 }
1750
1751 static HRESULT WINAPI video_presenter_quality_advise_SetQualityLevel(IMFQualityAdvise *iface,
1752         MF_QUALITY_LEVEL level)
1753 {
1754     FIXME("%p, %u.\n", iface, level);
1755
1756     return E_NOTIMPL;
1757 }
1758
1759 static HRESULT WINAPI video_presenter_quality_advise_GetDropMode(IMFQualityAdvise *iface,
1760         MF_QUALITY_DROP_MODE *mode)
1761 {
1762     FIXME("%p, %p.\n", iface, mode);
1763
1764     return E_NOTIMPL;
1765 }
1766
1767 static HRESULT WINAPI video_presenter_quality_advise_GetQualityLevel(IMFQualityAdvise *iface,
1768         MF_QUALITY_LEVEL *level)
1769 {
1770     FIXME("%p, %p.\n", iface, level);
1771
1772     return E_NOTIMPL;
1773 }
1774
1775 static HRESULT WINAPI video_presenter_quality_advise_DropTime(IMFQualityAdvise *iface, LONGLONG interval)
1776 {
1777     FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(interval));
1778
1779     return E_NOTIMPL;
1780 }
1781
1782 static const IMFQualityAdviseVtbl video_presenter_quality_advise_vtbl =
1783 {
1784     video_presenter_quality_advise_QueryInterface,
1785     video_presenter_quality_advise_AddRef,
1786     video_presenter_quality_advise_Release,
1787     video_presenter_quality_advise_SetDropMode,
1788     video_presenter_quality_advise_SetQualityLevel,
1789     video_presenter_quality_advise_GetDropMode,
1790     video_presenter_quality_advise_GetQualityLevel,
1791     video_presenter_quality_advise_DropTime,
1792 };
1793
1794 static HRESULT WINAPI video_presenter_device_manager_QueryInterface(IDirect3DDeviceManager9 *iface,
1795         REFIID riid, void **obj)
1796 {
1797     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1798     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
1799 }
1800
1801 static ULONG WINAPI video_presenter_device_manager_AddRef(IDirect3DDeviceManager9 *iface)
1802 {
1803     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1804     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
1805 }
1806
1807 static ULONG WINAPI video_presenter_device_manager_Release(IDirect3DDeviceManager9 *iface)
1808 {
1809     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1810     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
1811 }
1812
1813 static HRESULT WINAPI video_presenter_device_manager_ResetDevice(IDirect3DDeviceManager9 *iface,
1814         IDirect3DDevice9 *device, UINT token)
1815 {
1816     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1817     return IDirect3DDeviceManager9_ResetDevice(presenter->device_manager, device, token);
1818 }
1819
1820 static HRESULT WINAPI video_presenter_device_manager_OpenDeviceHandle(IDirect3DDeviceManager9 *iface, HANDLE *hdevice)
1821 {
1822     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1823     return IDirect3DDeviceManager9_OpenDeviceHandle(presenter->device_manager, hdevice);
1824 }
1825
1826 static HRESULT WINAPI video_presenter_device_manager_CloseDeviceHandle(IDirect3DDeviceManager9 *iface, HANDLE hdevice)
1827 {
1828     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1829     return IDirect3DDeviceManager9_CloseDeviceHandle(presenter->device_manager, hdevice);
1830 }
1831
1832 static HRESULT WINAPI video_presenter_device_manager_TestDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice)
1833 {
1834     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1835     return IDirect3DDeviceManager9_TestDevice(presenter->device_manager, hdevice);
1836 }
1837
1838 static HRESULT WINAPI video_presenter_device_manager_LockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice,
1839         IDirect3DDevice9 **device, BOOL block)
1840 {
1841     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1842     return IDirect3DDeviceManager9_LockDevice(presenter->device_manager, hdevice, device, block);
1843 }
1844
1845 static HRESULT WINAPI video_presenter_device_manager_UnlockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice,
1846         BOOL savestate)
1847 {
1848     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1849     return IDirect3DDeviceManager9_UnlockDevice(presenter->device_manager, hdevice, savestate);
1850 }
1851
1852 static HRESULT WINAPI video_presenter_device_manager_GetVideoService(IDirect3DDeviceManager9 *iface, HANDLE hdevice,
1853         REFIID riid, void **service)
1854 {
1855     struct video_presenter *presenter = impl_from_IDirect3DDeviceManager9(iface);
1856     return IDirect3DDeviceManager9_GetVideoService(presenter->device_manager, hdevice, riid, service);
1857 }
1858
1859 static const IDirect3DDeviceManager9Vtbl video_presenter_device_manager_vtbl =
1860 {
1861     video_presenter_device_manager_QueryInterface,
1862     video_presenter_device_manager_AddRef,
1863     video_presenter_device_manager_Release,
1864     video_presenter_device_manager_ResetDevice,
1865     video_presenter_device_manager_OpenDeviceHandle,
1866     video_presenter_device_manager_CloseDeviceHandle,
1867     video_presenter_device_manager_TestDevice,
1868     video_presenter_device_manager_LockDevice,
1869     video_presenter_device_manager_UnlockDevice,
1870     video_presenter_device_manager_GetVideoService,
1871 };
1872
1873 HRESULT WINAPI MFCreateVideoPresenter(IUnknown *owner, REFIID riid_device, REFIID riid, void **obj)
1874 {
1875     TRACE("%p, %s, %s, %p.\n", owner, debugstr_guid(riid_device), debugstr_guid(riid), obj);
1876
1877     *obj = NULL;
1878
1879     if (!IsEqualIID(riid_device, &IID_IDirect3DDevice9))
1880         return E_INVALIDARG;
1881
1882     return CoCreateInstance(&CLSID_MFVideoPresenter9, owner, CLSCTX_INPROC_SERVER, riid, obj);
1883 }
1884
1885 static HRESULT video_presenter_init_d3d(struct video_presenter *presenter)
1886 {
1887     D3DPRESENT_PARAMETERS present_params = { 0 };
1888     IDirect3DDevice9 *device;
1889     IDirect3D9 *d3d;
1890     HRESULT hr;
1891
1892     d3d = Direct3DCreate9(D3D_SDK_VERSION);
1893
1894     present_params.BackBufferCount = 1;
1895     present_params.SwapEffect = D3DSWAPEFFECT_COPY;
1896     present_params.hDeviceWindow = GetDesktopWindow();
1897     present_params.Windowed = TRUE;
1898     present_params.Flags = D3DPRESENTFLAG_VIDEO;
1899     present_params.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
1900     hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, GetDesktopWindow(),
1901             0, &present_params, &device);
1902
1903     IDirect3D9_Release(d3d);
1904
1905     if (FAILED(hr))
1906     {
1907         WARN("Failed to create d3d device, hr %#x.\n", hr);
1908         return hr;
1909     }
1910
1911     hr = IDirect3DDeviceManager9_ResetDevice(presenter->device_manager, device, presenter->reset_token);
1912     IDirect3DDevice9_Release(device);
1913     if (FAILED(hr))
1914         WARN("Failed to set new device for the manager, hr %#x.\n", hr);
1915
1916     if (SUCCEEDED(hr = MFCreateVideoSampleAllocator(&IID_IMFVideoSampleAllocator, (void **)&presenter->allocator)))
1917     {
1918         hr = IMFVideoSampleAllocator_SetDirectXManager(presenter->allocator, (IUnknown *)presenter->device_manager);
1919     }
1920
1921     return hr;
1922 }
1923
1924 HRESULT evr_presenter_create(IUnknown *outer, void **out)
1925 {
1926     struct video_presenter *object;
1927     HRESULT hr;
1928
1929     *out = NULL;
1930
1931     if (!(object = calloc(1, sizeof(*object))))
1932         return E_OUTOFMEMORY;
1933
1934     object->IMFVideoPresenter_iface.lpVtbl = &video_presenter_vtbl;
1935     object->IMFVideoDeviceID_iface.lpVtbl = &video_presenter_device_id_vtbl;
1936     object->IMFTopologyServiceLookupClient_iface.lpVtbl = &video_presenter_service_client_vtbl;
1937     object->IMFVideoDisplayControl_iface.lpVtbl = &video_presenter_control_vtbl;
1938     object->IMFRateSupport_iface.lpVtbl = &video_presenter_rate_support_vtbl;
1939     object->IMFGetService_iface.lpVtbl = &video_presenter_getservice_vtbl;
1940     object->IMFVideoPositionMapper_iface.lpVtbl = &video_presenter_position_mapper_vtbl;
1941     object->IQualProp_iface.lpVtbl = &video_presenter_qualprop_vtbl;
1942     object->IMFQualityAdvise_iface.lpVtbl = &video_presenter_quality_advise_vtbl;
1943     object->allocator_cb.lpVtbl = &video_presenter_allocator_cb_vtbl;
1944     object->IUnknown_inner.lpVtbl = &video_presenter_inner_vtbl;
1945     object->IDirect3DDeviceManager9_iface.lpVtbl = &video_presenter_device_manager_vtbl;
1946     object->outer_unk = outer ? outer : &object->IUnknown_inner;
1947     object->refcount = 1;
1948     object->src_rect.right = object->src_rect.bottom = 1.0f;
1949     object->ar_mode = MFVideoARMode_PreservePicture | MFVideoARMode_PreservePixel;
1950     object->allocator_capacity = 3;
1951     InitializeCriticalSection(&object->cs);
1952
1953     if (FAILED(hr = DXVA2CreateDirect3DDeviceManager9(&object->reset_token, &object->device_manager)))
1954         goto failed;
1955
1956     if (FAILED(hr = video_presenter_init_d3d(object)))
1957         goto failed;
1958
1959     *out = &object->IUnknown_inner;
1960
1961     return S_OK;
1962
1963 failed:
1964
1965     IUnknown_Release(&object->IUnknown_inner);
1966
1967     return hr;
1968 }