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