dlls/evr/mixer.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 "dxva2api.h"
  24 #include "mfapi.h"
  25 #include "mferror.h"
  26
  27 #include "evr_classes.h"
  28
  29 #include "initguid.h"
  30 #include "evr9.h"
  31 #include "evcode.h"
  32
  33 #include "wine/debug.h"
  34 #include "wine/heap.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(evr);
  37
  38 #define MAX_MIXER_INPUT_STREAMS 16
  39
  40 struct input_stream
  41 {
  42     unsigned int id;
  43     IMFAttributes *attributes;
  44     IMFMediaType *media_type;
  45     MFVideoNormalizedRect rect;
  46     unsigned int zorder;
  47     IMFSample *sample;
  48     unsigned int sample_requested : 1;
  49 };
  50
  51 struct rt_format
  52 {
  53     GUID device;
  54     D3DFORMAT format;
  55     IMFMediaType *media_type;
  56 };
  57
  58 struct output_stream
  59 {
  60     IMFMediaType *media_type;
  61     struct rt_format *rt_formats;
  62     unsigned int rt_formats_count;
  63 };
  64
  65 struct video_mixer
  66 {
  67     IMFTransform IMFTransform_iface;
  68     IMFVideoDeviceID IMFVideoDeviceID_iface;
  69     IMFTopologyServiceLookupClient IMFTopologyServiceLookupClient_iface;
  70     IMFVideoMixerControl2 IMFVideoMixerControl2_iface;
  71     IMFGetService IMFGetService_iface;
  72     IMFVideoMixerBitmap IMFVideoMixerBitmap_iface;
  73     IMFVideoPositionMapper IMFVideoPositionMapper_iface;
  74     IMFVideoProcessor IMFVideoProcessor_iface;
  75     IMFAttributes IMFAttributes_iface;
  76     IMFQualityAdvise IMFQualityAdvise_iface;
  77     IMFClockStateSink IMFClockStateSink_iface;
  78     IUnknown IUnknown_inner;
  79     IUnknown *outer_unk;
  80     LONG refcount;
  81
  82     struct input_stream inputs[MAX_MIXER_INPUT_STREAMS];
  83     unsigned int input_ids[MAX_MIXER_INPUT_STREAMS];
  84     unsigned int input_count;
  85     struct output_stream output;
  86
  87     IDirect3DDeviceManager9 *device_manager;
  88     IDirectXVideoProcessor *processor;
  89     HANDLE device_handle;
  90
  91     IMediaEventSink *event_sink;
  92     IMFAttributes *attributes;
  93     IMFAttributes *internal_attributes;
  94     unsigned int mixing_flags;
  95     unsigned int is_streaming;
  96     COLORREF bkgnd_color;
  97     LONGLONG lower_bound;
  98     LONGLONG upper_bound;
  99     CRITICAL_SECTION cs;
 100 };
 101
 102 static struct video_mixer *impl_from_IUnknown(IUnknown *iface)
 103 {
 104     return CONTAINING_RECORD(iface, struct video_mixer, IUnknown_inner);
 105 }
 106
 107 static struct video_mixer *impl_from_IMFTransform(IMFTransform *iface)
 108 {
 109     return CONTAINING_RECORD(iface, struct video_mixer, IMFTransform_iface);
 110 }
 111
 112 static struct video_mixer *impl_from_IMFVideoDeviceID(IMFVideoDeviceID *iface)
 113 {
 114     return CONTAINING_RECORD(iface, struct video_mixer, IMFVideoDeviceID_iface);
 115 }
 116
 117 static struct video_mixer *impl_from_IMFTopologyServiceLookupClient(IMFTopologyServiceLookupClient *iface)
 118 {
 119     return CONTAINING_RECORD(iface, struct video_mixer, IMFTopologyServiceLookupClient_iface);
 120 }
 121
 122 static struct video_mixer *impl_from_IMFVideoMixerControl2(IMFVideoMixerControl2 *iface)
 123 {
 124     return CONTAINING_RECORD(iface, struct video_mixer, IMFVideoMixerControl2_iface);
 125 }
 126
 127 static struct video_mixer *impl_from_IMFGetService(IMFGetService *iface)
 128 {
 129     return CONTAINING_RECORD(iface, struct video_mixer, IMFGetService_iface);
 130 }
 131
 132 static struct video_mixer *impl_from_IMFVideoMixerBitmap(IMFVideoMixerBitmap *iface)
 133 {
 134     return CONTAINING_RECORD(iface, struct video_mixer, IMFVideoMixerBitmap_iface);
 135 }
 136
 137 static struct video_mixer *impl_from_IMFVideoPositionMapper(IMFVideoPositionMapper *iface)
 138 {
 139     return CONTAINING_RECORD(iface, struct video_mixer, IMFVideoPositionMapper_iface);
 140 }
 141
 142 static struct video_mixer *impl_from_IMFVideoProcessor(IMFVideoProcessor *iface)
 143 {
 144     return CONTAINING_RECORD(iface, struct video_mixer, IMFVideoProcessor_iface);
 145 }
 146
 147 static struct video_mixer *impl_from_IMFAttributes(IMFAttributes *iface)
 148 {
 149     return CONTAINING_RECORD(iface, struct video_mixer, IMFAttributes_iface);
 150 }
 151
 152 static struct video_mixer *impl_from_IMFQualityAdvise(IMFQualityAdvise *iface)
 153 {
 154     return CONTAINING_RECORD(iface, struct video_mixer, IMFQualityAdvise_iface);
 155 }
 156
 157 static struct video_mixer *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
 158 {
 159     return CONTAINING_RECORD(iface, struct video_mixer, IMFClockStateSink_iface);
 160 }
 161
 162 static int __cdecl video_mixer_compare_input_id(const void *a, const void *b)
 163 {
 164     const unsigned int *key = a;
 165     const struct input_stream *input = b;
 166
 167     if (*key > input->id) return 1;
 168     if (*key < input->id) return -1;
 169     return 0;
 170 }
 171
 172 static HRESULT video_mixer_get_input(const struct video_mixer *mixer, unsigned int id, struct input_stream **stream)
 173 {
 174     *stream = bsearch(&id, mixer->inputs, mixer->input_count, sizeof(*mixer->inputs), video_mixer_compare_input_id);
 175     return *stream ? S_OK : MF_E_INVALIDSTREAMNUMBER;
 176 }
 177
 178 static void video_mixer_init_input(struct input_stream *stream)
 179 {
 180     if (SUCCEEDED(MFCreateAttributes(&stream->attributes, 1)))
 181         IMFAttributes_SetUINT32(stream->attributes, &MF_SA_REQUIRED_SAMPLE_COUNT, 1);
 182     stream->rect.left = stream->rect.top = 0.0f;
 183     stream->rect.right = stream->rect.bottom = 1.0f;
 184 }
 185
 186 static void video_mixer_clear_types(struct video_mixer *mixer)
 187 {
 188     unsigned int i;
 189
 190     for (i = 0; i < mixer->input_count; ++i)
 191     {
 192         if (mixer->inputs[i].media_type)
 193             IMFMediaType_Release(mixer->inputs[i].media_type);
 194         mixer->inputs[i].media_type = NULL;
 195         if (mixer->inputs[i].sample)
 196             IMFSample_Release(mixer->inputs[i].sample);
 197         mixer->inputs[i].sample = NULL;
 198     }
 199     for (i = 0; i < mixer->output.rt_formats_count; ++i)
 200     {
 201         IMFMediaType_Release(mixer->output.rt_formats[i].media_type);
 202     }
 203     heap_free(mixer->output.rt_formats);
 204     if (mixer->output.media_type)
 205         IMFMediaType_Release(mixer->output.media_type);
 206     mixer->output.media_type = NULL;
 207 }
 208
 209 static HRESULT WINAPI video_mixer_inner_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 210 {
 211     struct video_mixer *mixer = impl_from_IUnknown(iface);
 212
 213     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 214
 215     if (IsEqualIID(riid, &IID_IUnknown))
 216     {
 217         *obj = iface;
 218     }
 219     else if (IsEqualIID(riid, &IID_IMFTransform))
 220     {
 221         *obj = &mixer->IMFTransform_iface;
 222     }
 223     else if (IsEqualIID(riid, &IID_IMFVideoDeviceID))
 224     {
 225         *obj = &mixer->IMFVideoDeviceID_iface;
 226     }
 227     else if (IsEqualIID(riid, &IID_IMFTopologyServiceLookupClient))
 228     {
 229         *obj = &mixer->IMFTopologyServiceLookupClient_iface;
 230     }
 231     else if (IsEqualIID(riid, &IID_IMFVideoMixerControl2) ||
 232             IsEqualIID(riid, &IID_IMFVideoMixerControl))
 233     {
 234         *obj = &mixer->IMFVideoMixerControl2_iface;
 235     }
 236     else if (IsEqualIID(riid, &IID_IMFGetService))
 237     {
 238         *obj = &mixer->IMFGetService_iface;
 239     }
 240     else if (IsEqualIID(riid, &IID_IMFVideoMixerBitmap))
 241     {
 242         *obj = &mixer->IMFVideoMixerBitmap_iface;
 243     }
 244     else if (IsEqualIID(riid, &IID_IMFVideoPositionMapper))
 245     {
 246         *obj = &mixer->IMFVideoPositionMapper_iface;
 247     }
 248     else if (IsEqualIID(riid, &IID_IMFVideoProcessor))
 249     {
 250         *obj = &mixer->IMFVideoProcessor_iface;
 251     }
 252     else if (IsEqualIID(riid, &IID_IMFAttributes))
 253     {
 254         *obj = &mixer->IMFAttributes_iface;
 255     }
 256     else if (IsEqualIID(riid, &IID_IMFQualityAdvise))
 257     {
 258         *obj = &mixer->IMFQualityAdvise_iface;
 259     }
 260     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
 261     {
 262         *obj = &mixer->IMFClockStateSink_iface;
 263     }
 264     else
 265     {
 266         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 267         *obj = NULL;
 268         return E_NOINTERFACE;
 269     }
 270
 271     IUnknown_AddRef((IUnknown *)*obj);
 272     return S_OK;
 273 }
 274
 275 static ULONG WINAPI video_mixer_inner_AddRef(IUnknown *iface)
 276 {
 277     struct video_mixer *mixer = impl_from_IUnknown(iface);
 278     ULONG refcount = InterlockedIncrement(&mixer->refcount);
 279
 280     TRACE("%p, refcount %u.\n", iface, refcount);
 281
 282     return refcount;
 283 }
 284
 285 static void video_mixer_release_device_manager(struct video_mixer *mixer)
 286 {
 287     if (mixer->processor)
 288         IDirectXVideoProcessor_Release(mixer->processor);
 289     if (mixer->device_manager)
 290     {
 291         IDirect3DDeviceManager9_CloseDeviceHandle(mixer->device_manager, mixer->device_handle);
 292         IDirect3DDeviceManager9_Release(mixer->device_manager);
 293     }
 294     mixer->device_handle = NULL;
 295     mixer->device_manager = NULL;
 296     mixer->processor = NULL;
 297 }
 298
 299 static ULONG WINAPI video_mixer_inner_Release(IUnknown *iface)
 300 {
 301     struct video_mixer *mixer = impl_from_IUnknown(iface);
 302     ULONG refcount = InterlockedDecrement(&mixer->refcount);
 303     unsigned int i;
 304
 305     TRACE("%p, refcount %u.\n", iface, refcount);
 306
 307     if (!refcount)
 308     {
 309         for (i = 0; i < mixer->input_count; ++i)
 310         {
 311             if (mixer->inputs[i].attributes)
 312                 IMFAttributes_Release(mixer->inputs[i].attributes);
 313         }
 314         video_mixer_clear_types(mixer);
 315         video_mixer_release_device_manager(mixer);
 316         if (mixer->attributes)
 317             IMFAttributes_Release(mixer->attributes);
 318         if (mixer->internal_attributes)
 319             IMFAttributes_Release(mixer->internal_attributes);
 320         DeleteCriticalSection(&mixer->cs);
 321         free(mixer);
 322     }
 323
 324     return refcount;
 325 }
 326
 327 static const IUnknownVtbl video_mixer_inner_vtbl =
 328 {
 329     video_mixer_inner_QueryInterface,
 330     video_mixer_inner_AddRef,
 331     video_mixer_inner_Release,
 332 };
 333
 334 static HRESULT WINAPI video_mixer_transform_QueryInterface(IMFTransform *iface, REFIID riid, void **obj)
 335 {
 336     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 337     return IUnknown_QueryInterface(mixer->outer_unk, riid, obj);
 338 }
 339
 340 static ULONG WINAPI video_mixer_transform_AddRef(IMFTransform *iface)
 341 {
 342     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 343     return IUnknown_AddRef(mixer->outer_unk);
 344 }
 345
 346 static ULONG WINAPI video_mixer_transform_Release(IMFTransform *iface)
 347 {
 348     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 349     return IUnknown_Release(mixer->outer_unk);
 350 }
 351
 352 static HRESULT WINAPI video_mixer_transform_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum,
 353         DWORD *input_maximum, DWORD *output_minimum, DWORD *output_maximum)
 354 {
 355     TRACE("%p, %p, %p, %p, %p.\n", iface, input_minimum, input_maximum, output_minimum, output_maximum);
 356
 357     *input_minimum = 1;
 358     *input_maximum = MAX_MIXER_INPUT_STREAMS;
 359     *output_minimum = 1;
 360     *output_maximum = 1;
 361
 362     return S_OK;
 363 }
 364
 365 static HRESULT WINAPI video_mixer_transform_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs)
 366 {
 367     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 368
 369     TRACE("%p, %p, %p.\n", iface, inputs, outputs);
 370
 371     EnterCriticalSection(&mixer->cs);
 372     if (inputs) *inputs = mixer->input_count;
 373     if (outputs) *outputs = 1;
 374     LeaveCriticalSection(&mixer->cs);
 375
 376     return S_OK;
 377 }
 378
 379 static HRESULT WINAPI video_mixer_transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
 380         DWORD output_size, DWORD *outputs)
 381 {
 382     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 383     HRESULT hr = S_OK;
 384
 385     TRACE("%p, %u, %p, %u, %p.\n", iface, input_size, inputs, output_size, outputs);
 386
 387     EnterCriticalSection(&mixer->cs);
 388     if (mixer->input_count > input_size || !output_size)
 389         hr = MF_E_BUFFERTOOSMALL;
 390     else if (inputs)
 391         memcpy(inputs, mixer->input_ids, mixer->input_count * sizeof(*inputs));
 392     if (outputs) *outputs = 0;
 393     LeaveCriticalSection(&mixer->cs);
 394
 395     return hr;
 396 }
 397
 398 static HRESULT WINAPI video_mixer_transform_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 399 {
 400     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 401     struct input_stream *input;
 402     HRESULT hr;
 403
 404     TRACE("%p, %u, %p.\n", iface, id, info);
 405
 406     EnterCriticalSection(&mixer->cs);
 407
 408     if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &input)))
 409     {
 410         memset(info, 0, sizeof(*info));
 411         if (id)
 412             info->dwFlags |= MFT_INPUT_STREAM_REMOVABLE | MFT_INPUT_STREAM_OPTIONAL;
 413     }
 414
 415     LeaveCriticalSection(&mixer->cs);
 416
 417     return hr;
 418 }
 419
 420 static HRESULT WINAPI video_mixer_transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 421 {
 422     TRACE("%p, %u, %p.\n", iface, id, info);
 423
 424     if (id)
 425         return MF_E_INVALIDSTREAMNUMBER;
 426
 427     memset(info, 0, sizeof(*info));
 428
 429     return S_OK;
 430 }
 431
 432 static HRESULT WINAPI video_mixer_transform_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
 433 {
 434     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 435
 436     TRACE("%p, %p.\n", iface, attributes);
 437
 438     if (!attributes)
 439         return E_POINTER;
 440
 441     *attributes = mixer->attributes;
 442     IMFAttributes_AddRef(*attributes);
 443
 444     return S_OK;
 445 }
 446
 447 static HRESULT WINAPI video_mixer_transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id,
 448         IMFAttributes **attributes)
 449 {
 450     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 451     struct input_stream *input;
 452     HRESULT hr;
 453
 454     TRACE("%p, %u, %p.\n", iface, id, attributes);
 455
 456     EnterCriticalSection(&mixer->cs);
 457
 458     if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &input)))
 459     {
 460         *attributes = input->attributes;
 461         if (*attributes)
 462             IMFAttributes_AddRef(*attributes);
 463     }
 464
 465     LeaveCriticalSection(&mixer->cs);
 466
 467     return hr;
 468 }
 469
 470 static HRESULT WINAPI video_mixer_transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id,
 471         IMFAttributes **attributes)
 472 {
 473     TRACE("%p, %u, %p.\n", iface, id, attributes);
 474
 475     return E_NOTIMPL;
 476 }
 477
 478 static HRESULT WINAPI video_mixer_transform_DeleteInputStream(IMFTransform *iface, DWORD id)
 479 {
 480     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 481     struct input_stream *input;
 482     unsigned int idx;
 483     HRESULT hr;
 484
 485     TRACE("%p, %u.\n", iface, id);
 486
 487     if (!id)
 488         return MF_E_INVALIDSTREAMNUMBER;
 489
 490     EnterCriticalSection(&mixer->cs);
 491
 492     /* Can't delete reference stream. */
 493     if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &input)))
 494     {
 495         mixer->input_count--;
 496         idx = input - mixer->inputs;
 497         if (idx < mixer->input_count)
 498         {
 499             if (mixer->inputs[idx].attributes)
 500                 IMFAttributes_Release(mixer->inputs[idx].attributes);
 501             memmove(&mixer->inputs[idx], &mixer->inputs[idx + 1], (mixer->input_count - idx) * sizeof(*mixer->inputs));
 502             memmove(&mixer->input_ids[idx], &mixer->input_ids[idx + 1], (mixer->input_count - idx) *
 503                     sizeof(*mixer->input_ids));
 504         }
 505     }
 506
 507     LeaveCriticalSection(&mixer->cs);
 508
 509     return hr;
 510 }
 511
 512 static int __cdecl video_mixer_add_input_sort_compare(const void *a, const void *b)
 513 {
 514     const struct input_stream *left = a, *right = b;
 515     return left->id != right->id ? (left->id < right->id ? -1 : 1) : 0;
 516 };
 517
 518 static HRESULT WINAPI video_mixer_transform_AddInputStreams(IMFTransform *iface, DWORD count, DWORD *ids)
 519 {
 520     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 521     struct input_stream inputs[MAX_MIXER_INPUT_STREAMS] = { {0} };
 522     struct input_stream *input;
 523     unsigned int i, len;
 524     HRESULT hr = S_OK;
 525
 526     TRACE("%p, %u, %p.\n", iface, count, ids);
 527
 528     if (!ids)
 529         return E_POINTER;
 530
 531     EnterCriticalSection(&mixer->cs);
 532     if (count > ARRAY_SIZE(mixer->inputs) - mixer->input_count)
 533         hr = E_INVALIDARG;
 534     else
 535     {
 536         /* Test for collisions. */
 537         memcpy(inputs, mixer->inputs, mixer->input_count * sizeof(*inputs));
 538         for (i = 0; i < count; ++i)
 539             inputs[i + mixer->input_count].id = ids[i];
 540
 541         len = mixer->input_count + count;
 542
 543         qsort(inputs, len, sizeof(*inputs), video_mixer_add_input_sort_compare);
 544
 545         for (i = 1; i < len; ++i)
 546         {
 547             if (inputs[i - 1].id == inputs[i].id)
 548             {
 549                 hr = E_INVALIDARG;
 550                 break;
 551             }
 552         }
 553
 554         if (SUCCEEDED(hr))
 555         {
 556             unsigned int zorder = mixer->input_count;
 557
 558             for (i = 0; i < count; ++i)
 559             {
 560                 if ((input = bsearch(&ids[i], inputs, len, sizeof(*inputs), video_mixer_compare_input_id)))
 561                     video_mixer_init_input(input);
 562             }
 563             memcpy(&mixer->input_ids[mixer->input_count], ids, count * sizeof(*ids));
 564             memcpy(mixer->inputs, inputs, len * sizeof(*inputs));
 565             mixer->input_count += count;
 566
 567             for (i = 0; i < count; ++i)
 568             {
 569                 if (SUCCEEDED(video_mixer_get_input(mixer, ids[i], &input)))
 570                     input->zorder = zorder;
 571                 zorder++;
 572             }
 573         }
 574     }
 575     LeaveCriticalSection(&mixer->cs);
 576
 577     return hr;
 578 }
 579
 580 static HRESULT WINAPI video_mixer_transform_GetInputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 581         IMFMediaType **type)
 582 {
 583     TRACE("%p, %u, %u, %p.\n", iface, id, index, type);
 584
 585     return E_NOTIMPL;
 586 }
 587
 588 static HRESULT WINAPI video_mixer_transform_GetOutputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 589         IMFMediaType **type)
 590 {
 591     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 592     HRESULT hr = S_OK;
 593
 594     TRACE("%p, %u, %u, %p.\n", iface, id, index, type);
 595
 596     if (id)
 597         return MF_E_INVALIDSTREAMNUMBER;
 598
 599     EnterCriticalSection(&mixer->cs);
 600
 601     if (!mixer->inputs[0].media_type)
 602         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 603     else if (index >= mixer->output.rt_formats_count)
 604         hr = MF_E_NO_MORE_TYPES;
 605     else
 606     {
 607         *type = mixer->output.rt_formats[index].media_type;
 608         IMFMediaType_AddRef(*type);
 609     }
 610
 611     LeaveCriticalSection(&mixer->cs);
 612
 613     return hr;
 614 }
 615
 616 static HRESULT video_mixer_init_dxva_videodesc(IMFMediaType *media_type, DXVA2_VideoDesc *video_desc)
 617 {
 618     const MFVIDEOFORMAT *video_format;
 619     IMFVideoMediaType *video_type;
 620     BOOL is_compressed = TRUE;
 621     HRESULT hr = S_OK;
 622
 623     if (FAILED(IMFMediaType_QueryInterface(media_type, &IID_IMFVideoMediaType, (void **)&video_type)))
 624         return MF_E_INVALIDMEDIATYPE;
 625
 626     video_format = IMFVideoMediaType_GetVideoFormat(video_type);
 627     IMFVideoMediaType_IsCompressedFormat(video_type, &is_compressed);
 628
 629     if (!video_format || !video_format->videoInfo.dwWidth || !video_format->videoInfo.dwHeight || is_compressed)
 630     {
 631         hr = MF_E_INVALIDMEDIATYPE;
 632         goto done;
 633     }
 634
 635     memset(video_desc, 0, sizeof(*video_desc));
 636     video_desc->SampleWidth = video_format->videoInfo.dwWidth;
 637     video_desc->SampleHeight = video_format->videoInfo.dwHeight;
 638     video_desc->Format = video_format->surfaceInfo.Format;
 639
 640 done:
 641     IMFVideoMediaType_Release(video_type);
 642
 643     return hr;
 644 }
 645
 646 static int __cdecl rt_formats_sort_compare(const void *left, const void *right)
 647 {
 648     const struct rt_format *format1 = left, *format2 = right;
 649
 650     if (format1->format < format2->format) return -1;
 651     if (format1->format > format2->format) return 1;
 652     return 0;
 653 }
 654
 655 static HRESULT video_mixer_collect_output_types(struct video_mixer *mixer, const DXVA2_VideoDesc *video_desc,
 656         IMFMediaType *media_type, IDirectXVideoProcessorService *service, unsigned int device_count,
 657         const GUID *devices, unsigned int flags)
 658 {
 659     unsigned int i, j, format_count, count;
 660     struct rt_format *rt_formats = NULL, *ptr;
 661     HRESULT hr = MF_E_INVALIDMEDIATYPE;
 662     D3DFORMAT *formats;
 663     GUID subtype;
 664
 665     count = 0;
 666     for (i = 0; i < device_count; ++i)
 667     {
 668         if (SUCCEEDED(IDirectXVideoProcessorService_GetVideoProcessorRenderTargets(service, &devices[i], video_desc,
 669               &format_count, &formats)))
 670         {
 671             if (!(ptr = heap_realloc(rt_formats, (count + format_count) * sizeof(*rt_formats))))
 672             {
 673                 hr = E_OUTOFMEMORY;
 674                 count = 0;
 675                 CoTaskMemFree(formats);
 676                 break;
 677             }
 678             rt_formats = ptr;
 679
 680             for (j = 0; j < format_count; ++j)
 681             {
 682                 rt_formats[count + j].format = formats[j];
 683                 rt_formats[count + j].device = devices[i];
 684             }
 685             count += format_count;
 686
 687             CoTaskMemFree(formats);
 688         }
 689     }
 690
 691     if (count && !(flags & MFT_SET_TYPE_TEST_ONLY))
 692     {
 693         qsort(rt_formats, count, sizeof(*rt_formats), rt_formats_sort_compare);
 694
 695         j = 0;
 696         for (i = j + 1; i < count; ++i)
 697         {
 698             if (rt_formats[i].format != rt_formats[j].format)
 699             {
 700                 rt_formats[++j] = rt_formats[i];
 701             }
 702         }
 703         count = j + 1;
 704
 705         memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
 706         if ((mixer->output.rt_formats = heap_calloc(count, sizeof(*mixer->output.rt_formats))))
 707         {
 708             for (i = 0; i < count; ++i)
 709             {
 710                 IMFMediaType *rt_media_type;
 711
 712                 subtype.Data1 = rt_formats[i].format;
 713                 mixer->output.rt_formats[i] = rt_formats[i];
 714
 715                 MFCreateMediaType(&rt_media_type);
 716                 IMFMediaType_CopyAllItems(media_type, (IMFAttributes *)rt_media_type);
 717                 IMFMediaType_SetGUID(rt_media_type, &MF_MT_SUBTYPE, &subtype);
 718
 719                 mixer->output.rt_formats[i].media_type = rt_media_type;
 720             }
 721             mixer->output.rt_formats_count = count;
 722         }
 723         else
 724         {
 725             hr = E_OUTOFMEMORY;
 726             count = 0;
 727         }
 728     }
 729
 730     heap_free(rt_formats);
 731
 732     return count ? S_OK : hr;
 733 }
 734
 735 static HRESULT video_mixer_open_device_handle(struct video_mixer *mixer)
 736 {
 737     IDirect3DDeviceManager9_CloseDeviceHandle(mixer->device_manager, mixer->device_handle);
 738     mixer->device_handle = NULL;
 739     return IDirect3DDeviceManager9_OpenDeviceHandle(mixer->device_manager, &mixer->device_handle);
 740 }
 741
 742 static HRESULT video_mixer_get_processor_service(struct video_mixer *mixer, IDirectXVideoProcessorService **service)
 743 {
 744     HRESULT hr;
 745
 746     if (!mixer->device_handle)
 747     {
 748         if (FAILED(hr = IDirect3DDeviceManager9_OpenDeviceHandle(mixer->device_manager, &mixer->device_handle)))
 749             return hr;
 750     }
 751
 752     for (;;)
 753     {
 754         hr = IDirect3DDeviceManager9_GetVideoService(mixer->device_manager, mixer->device_handle,
 755                 &IID_IDirectXVideoProcessorService, (void **)service);
 756         if (hr == DXVA2_E_NEW_VIDEO_DEVICE)
 757         {
 758             if (SUCCEEDED(hr = video_mixer_open_device_handle(mixer)))
 759                 continue;
 760         }
 761         break;
 762     }
 763
 764     return hr;
 765 }
 766
 767 static HRESULT WINAPI video_mixer_transform_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *media_type, DWORD flags)
 768 {
 769     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 770     IDirectXVideoProcessorService *service;
 771     DXVA2_VideoDesc video_desc;
 772     HRESULT hr = E_NOTIMPL;
 773     unsigned int count;
 774     GUID *guids;
 775
 776     TRACE("%p, %u, %p, %#x.\n", iface, id, media_type, flags);
 777
 778     EnterCriticalSection(&mixer->cs);
 779
 780     if (!(flags & MFT_SET_TYPE_TEST_ONLY))
 781         video_mixer_clear_types(mixer);
 782
 783     if (!mixer->device_manager)
 784         hr = MF_E_NOT_INITIALIZED;
 785     else
 786     {
 787         if (SUCCEEDED(hr = video_mixer_get_processor_service(mixer, &service)))
 788         {
 789             if (SUCCEEDED(hr = video_mixer_init_dxva_videodesc(media_type, &video_desc)))
 790             {
 791                 if (!id)
 792                 {
 793                     if (SUCCEEDED(hr = IDirectXVideoProcessorService_GetVideoProcessorDeviceGuids(service, &video_desc,
 794                             &count, &guids)))
 795                     {
 796                         if (SUCCEEDED(hr = video_mixer_collect_output_types(mixer, &video_desc, media_type,
 797                                 service, count, guids, flags)) && !(flags & MFT_SET_TYPE_TEST_ONLY))
 798                         {
 799                             if (mixer->inputs[0].media_type)
 800                                 IMFMediaType_Release(mixer->inputs[0].media_type);
 801                             mixer->inputs[0].media_type = media_type;
 802                             IMFMediaType_AddRef(mixer->inputs[0].media_type);
 803                         }
 804                         CoTaskMemFree(guids);
 805                     }
 806                 }
 807                 else
 808                 {
 809                     FIXME("Unimplemented for substreams.\n");
 810                     hr = E_NOTIMPL;
 811                 }
 812             }
 813             IDirectXVideoProcessorService_Release(service);
 814         }
 815     }
 816
 817     LeaveCriticalSection(&mixer->cs);
 818
 819     return hr;
 820 }
 821
 822 static HRESULT WINAPI video_mixer_transform_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 823 {
 824     const unsigned int equality_flags = MF_MEDIATYPE_EQUAL_MAJOR_TYPES |
 825             MF_MEDIATYPE_EQUAL_FORMAT_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_DATA;
 826     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 827     HRESULT hr = MF_E_INVALIDMEDIATYPE;
 828     unsigned int i, compare_flags;
 829
 830     TRACE("%p, %u, %p, %#x.\n", iface, id, type, flags);
 831
 832     if (id)
 833         return MF_E_INVALIDSTREAMNUMBER;
 834
 835     EnterCriticalSection(&mixer->cs);
 836
 837     for (i = 0; i < mixer->output.rt_formats_count; ++i)
 838     {
 839         compare_flags = 0;
 840         if (FAILED(IMFMediaType_IsEqual(type, mixer->output.rt_formats[i].media_type, &compare_flags)))
 841             continue;
 842
 843         if ((compare_flags & equality_flags) == equality_flags)
 844         {
 845             hr = S_OK;
 846             break;
 847         }
 848     }
 849
 850     if (SUCCEEDED(hr) && !(flags & MFT_SET_TYPE_TEST_ONLY))
 851     {
 852         IDirectXVideoProcessorService *service;
 853
 854         if (SUCCEEDED(hr = video_mixer_get_processor_service(mixer, &service)))
 855         {
 856             DXVA2_VideoDesc video_desc;
 857             GUID subtype = { 0 };
 858             D3DFORMAT rt_format;
 859
 860             if (mixer->processor)
 861                 IDirectXVideoProcessor_Release(mixer->processor);
 862             mixer->processor = NULL;
 863
 864             video_mixer_init_dxva_videodesc(mixer->inputs[0].media_type, &video_desc);
 865             IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype);
 866             rt_format = subtype.Data1;
 867
 868             if (SUCCEEDED(hr = IDirectXVideoProcessorService_CreateVideoProcessor(service, &mixer->output.rt_formats[i].device,
 869                     &video_desc, rt_format, MAX_MIXER_INPUT_STREAMS, &mixer->processor)))
 870             {
 871                 if (mixer->output.media_type)
 872                     IMFMediaType_Release(mixer->output.media_type);
 873                 mixer->output.media_type = type;
 874                 IMFMediaType_AddRef(mixer->output.media_type);
 875             }
 876
 877             IDirectXVideoProcessorService_Release(service);
 878         }
 879     }
 880
 881     LeaveCriticalSection(&mixer->cs);
 882
 883     return hr;
 884 }
 885
 886 static HRESULT WINAPI video_mixer_transform_GetInputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 887 {
 888     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 889     struct input_stream *stream;
 890     HRESULT hr;
 891
 892     TRACE("%p, %u, %p.\n", iface, id, type);
 893
 894     EnterCriticalSection(&mixer->cs);
 895
 896     if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &stream)))
 897     {
 898         if (!stream->media_type)
 899             hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 900         else
 901         {
 902             *type = (IMFMediaType *)stream->media_type;
 903             IMFMediaType_AddRef(*type);
 904         }
 905     }
 906
 907     LeaveCriticalSection(&mixer->cs);
 908
 909     return hr;
 910 }
 911
 912 static HRESULT WINAPI video_mixer_transform_GetOutputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 913 {
 914     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 915     HRESULT hr = S_OK;
 916
 917     TRACE("%p, %u, %p.\n", iface, id, type);
 918
 919     if (id)
 920         return MF_E_INVALIDSTREAMNUMBER;
 921
 922     EnterCriticalSection(&mixer->cs);
 923
 924     if (!mixer->output.media_type)
 925         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 926     else
 927     {
 928         *type = (IMFMediaType *)mixer->output.media_type;
 929         IMFMediaType_AddRef(*type);
 930     }
 931
 932     LeaveCriticalSection(&mixer->cs);
 933
 934     return hr;
 935 }
 936
 937 static HRESULT WINAPI video_mixer_transform_GetInputStatus(IMFTransform *iface, DWORD id, DWORD *status)
 938 {
 939     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 940     struct input_stream *stream;
 941     HRESULT hr;
 942
 943     TRACE("%p, %u, %p.\n", iface, id, status);
 944
 945     if (!status)
 946         return E_POINTER;
 947
 948     EnterCriticalSection(&mixer->cs);
 949
 950     if (!mixer->output.media_type)
 951         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 952     else if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &stream)))
 953     {
 954         *status = stream->sample ? 0 : MFT_INPUT_STATUS_ACCEPT_DATA;
 955     }
 956
 957     LeaveCriticalSection(&mixer->cs);
 958
 959     return hr;
 960 }
 961
 962 static HRESULT WINAPI video_mixer_transform_GetOutputStatus(IMFTransform *iface, DWORD *status)
 963 {
 964     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 965     HRESULT hr = S_OK;
 966     unsigned int i;
 967
 968     TRACE("%p, %p.\n", iface, status);
 969
 970     if (!status)
 971         return E_POINTER;
 972
 973     EnterCriticalSection(&mixer->cs);
 974
 975     if (!mixer->output.media_type)
 976         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 977     else
 978     {
 979         *status = MFT_OUTPUT_STATUS_SAMPLE_READY;
 980         for (i = 0; i < mixer->input_count; ++i)
 981         {
 982             if (!mixer->inputs[i].sample)
 983             {
 984                 *status = 0;
 985                 break;
 986             }
 987         }
 988     }
 989
 990     LeaveCriticalSection(&mixer->cs);
 991
 992     return hr;
 993 }
 994
 995 static HRESULT WINAPI video_mixer_transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 996 {
 997     struct video_mixer *mixer = impl_from_IMFTransform(iface);
 998
 999     TRACE("%p, %s, %s.\n", iface, wine_dbgstr_longlong(lower), wine_dbgstr_longlong(upper));
1000
1001     EnterCriticalSection(&mixer->cs);
1002
1003     mixer->lower_bound = lower;
1004     mixer->upper_bound = upper;
1005
1006     LeaveCriticalSection(&mixer->cs);
1007
1008     return S_OK;
1009 }
1010
1011 static HRESULT WINAPI video_mixer_transform_ProcessEvent(IMFTransform *iface, DWORD id, IMFMediaEvent *event)
1012 {
1013     FIXME("%p, %u, %p.\n", iface, id, event);
1014
1015     return E_NOTIMPL;
1016 }
1017
1018 static void video_mixer_request_sample(struct video_mixer *mixer, unsigned int idx)
1019 {
1020     if (!mixer->event_sink || mixer->inputs[idx].sample_requested)
1021         return;
1022
1023     IMediaEventSink_Notify(mixer->event_sink, EC_SAMPLE_NEEDED, idx, 0);
1024     mixer->inputs[idx].sample_requested = 1;
1025 }
1026
1027 static HRESULT WINAPI video_mixer_transform_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_TYPE message, ULONG_PTR param)
1028 {
1029     struct video_mixer *mixer = impl_from_IMFTransform(iface);
1030     HRESULT hr = S_OK;
1031     unsigned int i;
1032
1033     TRACE("%p, %u, %#lx.\n", iface, message, param);
1034
1035     switch (message)
1036     {
1037         case MFT_MESSAGE_SET_D3D_MANAGER:
1038
1039             EnterCriticalSection(&mixer->cs);
1040
1041             video_mixer_release_device_manager(mixer);
1042             if (param)
1043                 hr = IUnknown_QueryInterface((IUnknown *)param, &IID_IDirect3DDeviceManager9, (void **)&mixer->device_manager);
1044
1045             LeaveCriticalSection(&mixer->cs);
1046
1047             break;
1048
1049         case MFT_MESSAGE_COMMAND_FLUSH:
1050
1051             EnterCriticalSection(&mixer->cs);
1052
1053             for (i = 0; i < mixer->input_count; ++i)
1054             {
1055                 if (mixer->inputs[i].sample)
1056                 {
1057                     IMFSample_Release(mixer->inputs[i].sample);
1058                     mixer->inputs[i].sample = NULL;
1059                     mixer->inputs[i].sample_requested = 0;
1060                 }
1061             }
1062
1063             LeaveCriticalSection(&mixer->cs);
1064
1065             break;
1066
1067         case MFT_MESSAGE_NOTIFY_BEGIN_STREAMING:
1068         case MFT_MESSAGE_NOTIFY_END_STREAMING:
1069
1070             EnterCriticalSection(&mixer->cs);
1071
1072             if (!mixer->is_streaming)
1073             {
1074                 for (i = 0; i < mixer->input_count; ++i)
1075                     video_mixer_request_sample(mixer, i);
1076             }
1077
1078             mixer->is_streaming = message == MFT_MESSAGE_NOTIFY_BEGIN_STREAMING;
1079
1080             LeaveCriticalSection(&mixer->cs);
1081
1082             break;
1083
1084         case MFT_MESSAGE_COMMAND_DRAIN:
1085             break;
1086
1087         default:
1088             WARN("Message not handled %d.\n", message);
1089             hr = E_NOTIMPL;
1090     }
1091
1092     return hr;
1093 }
1094
1095 static HRESULT WINAPI video_mixer_transform_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags)
1096 {
1097     struct video_mixer *mixer = impl_from_IMFTransform(iface);
1098     struct input_stream *input;
1099     HRESULT hr;
1100
1101     TRACE("%p, %u, %p, %#x.\n", iface, id, sample, flags);
1102
1103     if (!sample)
1104         return E_POINTER;
1105
1106     EnterCriticalSection(&mixer->cs);
1107
1108     if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &input)))
1109     {
1110         if (!input->media_type || !mixer->output.media_type)
1111             hr = MF_E_TRANSFORM_TYPE_NOT_SET;
1112         else if (input->sample)
1113             hr = MF_E_NOTACCEPTING;
1114         else
1115         {
1116             mixer->is_streaming = 1;
1117             input->sample_requested = 0;
1118             input->sample = sample;
1119             IMFSample_AddRef(input->sample);
1120         }
1121     }
1122
1123     LeaveCriticalSection(&mixer->cs);
1124
1125     return hr;
1126 }
1127
1128 static HRESULT video_mixer_get_sample_surface(IMFSample *sample, IDirect3DSurface9 **surface)
1129 {
1130     IMFMediaBuffer *buffer;
1131     IMFGetService *gs;
1132     HRESULT hr;
1133
1134     if (FAILED(hr = IMFSample_GetBufferByIndex(sample, 0, &buffer)))
1135         return hr;
1136
1137     hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMFGetService, (void **)&gs);
1138     IMFMediaBuffer_Release(buffer);
1139     if (FAILED(hr))
1140         return hr;
1141
1142     hr = IMFGetService_GetService(gs, &MR_BUFFER_SERVICE, &IID_IDirect3DSurface9, (void **)surface);
1143     IMFGetService_Release(gs);
1144     return hr;
1145 }
1146
1147 static HRESULT video_mixer_get_d3d_device(struct video_mixer *mixer, IDirect3DDevice9 **device)
1148 {
1149     HRESULT hr;
1150
1151     for (;;)
1152     {
1153         hr = IDirect3DDeviceManager9_LockDevice(mixer->device_manager, mixer->device_handle,
1154                 device, TRUE);
1155         if (hr == DXVA2_E_NEW_VIDEO_DEVICE)
1156         {
1157             if (SUCCEEDED(hr = video_mixer_open_device_handle(mixer)))
1158                 continue;
1159         }
1160         break;
1161     }
1162
1163     return hr;
1164 }
1165
1166 static void video_mixer_scale_rect(RECT *rect, unsigned int width, unsigned int height,
1167         const MFVideoNormalizedRect *scale)
1168 {
1169     if (rect->left == 0.0f && rect->top == 0.0f && rect->right == 1.0f && rect->bottom == 1.0f)
1170     {
1171         SetRect(rect, 0, 0, width, height);
1172     }
1173     else
1174     {
1175         rect->left = width * scale->left;
1176         rect->right = width * scale->right;
1177         rect->top = height * scale->top;
1178         rect->bottom = height * scale->bottom;
1179     }
1180 }
1181
1182 static void video_mixer_render(struct video_mixer *mixer, IDirect3DSurface9 *rt)
1183 {
1184     DXVA2_VideoSample samples[1] = {{ 0 }};
1185     DXVA2_VideoProcessBltParams params = { 0 };
1186     MFVideoNormalizedRect zoom_rect;
1187     struct input_stream *stream;
1188     IDirect3DSurface9 *surface;
1189     D3DSURFACE_DESC desc;
1190     HRESULT hr;
1191
1192     IDirect3DSurface9_GetDesc(rt, &desc);
1193
1194     if (FAILED(IMFAttributes_GetBlob(mixer->attributes, &VIDEO_ZOOM_RECT, (UINT8 *)&zoom_rect,
1195             sizeof(zoom_rect), NULL)))
1196     {
1197         zoom_rect.left = zoom_rect.top = 0.0f;
1198         zoom_rect.right = zoom_rect.bottom = 1.0f;
1199     }
1200
1201     video_mixer_scale_rect(&params.TargetRect, desc.Width, desc.Height, &zoom_rect);
1202
1203     /* FIXME: for now only handle reference stream. */
1204
1205     video_mixer_get_input(mixer, 0, &stream);
1206
1207     if (FAILED(hr = video_mixer_get_sample_surface(stream->sample, &surface)))
1208     {
1209         WARN("Failed to get source surface, hr %#x.\n", hr);
1210         return;
1211     }
1212
1213     IDirect3DSurface9_GetDesc(surface, &desc);
1214
1215     samples[0].SrcSurface = surface;
1216     SetRect(&samples[0].SrcRect, 0, 0, desc.Width, desc.Height);
1217     video_mixer_scale_rect(&samples[0].DstRect, desc.Width, desc.Height, &stream->rect);
1218
1219     if (FAILED(hr = IDirectXVideoProcessor_VideoProcessBlt(mixer->processor, rt, &params, samples, 1, NULL)))
1220         WARN("Failed to process samples, hr %#x.\n", hr);
1221
1222     IDirect3DSurface9_Release(surface);
1223 }
1224
1225 static HRESULT video_mixer_get_sample_desired_time(IMFSample *sample, LONGLONG *timestamp, LONGLONG *duration)
1226 {
1227     IMFDesiredSample *desired;
1228     HRESULT hr;
1229
1230     if (SUCCEEDED(hr = IMFSample_QueryInterface(sample, &IID_IMFDesiredSample, (void **)&desired)))
1231     {
1232         hr = IMFDesiredSample_GetDesiredSampleTimeAndDuration(desired, timestamp, duration);
1233         IMFDesiredSample_Release(desired);
1234     }
1235
1236     return hr;
1237 }
1238
1239 static HRESULT WINAPI video_mixer_transform_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count,
1240         MFT_OUTPUT_DATA_BUFFER *buffers, DWORD *status)
1241 {
1242     struct video_mixer *mixer = impl_from_IMFTransform(iface);
1243     LONGLONG timestamp, duration;
1244     IDirect3DSurface9 *surface;
1245     IDirect3DDevice9 *device;
1246     unsigned int i;
1247     HRESULT hr;
1248
1249     TRACE("%p, %#x, %u, %p, %p.\n", iface, flags, count, buffers, status);
1250
1251     if (!buffers || !count || count > 1 || !buffers->pSample)
1252         return E_INVALIDARG;
1253
1254     if (buffers->dwStreamID)
1255         return MF_E_INVALIDSTREAMNUMBER;
1256
1257     *status = 0;
1258
1259     EnterCriticalSection(&mixer->cs);
1260
1261     if (SUCCEEDED(hr = video_mixer_get_sample_surface(buffers->pSample, &surface)))
1262     {
1263         if (mixer->is_streaming)
1264         {
1265             for (i = 0; i < mixer->input_count; ++i)
1266             {
1267                 if (!mixer->inputs[i].sample)
1268                 {
1269                     hr = MF_E_TRANSFORM_NEED_MORE_INPUT;
1270                     break;
1271                 }
1272             }
1273
1274             if (SUCCEEDED(hr))
1275             {
1276                 video_mixer_render(mixer, surface);
1277
1278                 timestamp = duration = 0;
1279                 if (SUCCEEDED(IMFSample_GetSampleTime(mixer->inputs[0].sample, &timestamp)))
1280                 {
1281                     IMFSample_SetSampleTime(buffers->pSample, timestamp);
1282
1283                     IMFSample_GetSampleDuration(mixer->inputs[0].sample, &duration);
1284                     IMFSample_SetSampleDuration(buffers->pSample, duration);
1285                 }
1286             }
1287
1288             if (SUCCEEDED(hr))
1289             {
1290                 for (i = 0; i < mixer->input_count; ++i)
1291                 {
1292                     if (mixer->inputs[i].sample)
1293                         IMFSample_Release(mixer->inputs[i].sample);
1294                     mixer->inputs[i].sample = NULL;
1295                     video_mixer_request_sample(mixer, i);
1296                 }
1297             }
1298         }
1299         else
1300         {
1301             if (SUCCEEDED(video_mixer_get_sample_desired_time(buffers->pSample, &timestamp, &duration)))
1302             {
1303                 if (SUCCEEDED(hr = video_mixer_get_d3d_device(mixer, &device)))
1304                 {
1305                     IDirect3DDevice9_ColorFill(device, surface, NULL, 0);
1306                     IDirect3DDeviceManager9_UnlockDevice(mixer->device_manager, mixer->device_handle, FALSE);
1307                     IDirect3DDevice9_Release(device);
1308                 }
1309             }
1310             else
1311                 hr = MF_E_TRANSFORM_NEED_MORE_INPUT;
1312         }
1313         IDirect3DSurface9_Release(surface);
1314     }
1315
1316     LeaveCriticalSection(&mixer->cs);
1317
1318     return hr;
1319 }
1320
1321 static const IMFTransformVtbl video_mixer_transform_vtbl =
1322 {
1323     video_mixer_transform_QueryInterface,
1324     video_mixer_transform_AddRef,
1325     video_mixer_transform_Release,
1326     video_mixer_transform_GetStreamLimits,
1327     video_mixer_transform_GetStreamCount,
1328     video_mixer_transform_GetStreamIDs,
1329     video_mixer_transform_GetInputStreamInfo,
1330     video_mixer_transform_GetOutputStreamInfo,
1331     video_mixer_transform_GetAttributes,
1332     video_mixer_transform_GetInputStreamAttributes,
1333     video_mixer_transform_GetOutputStreamAttributes,
1334     video_mixer_transform_DeleteInputStream,
1335     video_mixer_transform_AddInputStreams,
1336     video_mixer_transform_GetInputAvailableType,
1337     video_mixer_transform_GetOutputAvailableType,
1338     video_mixer_transform_SetInputType,
1339     video_mixer_transform_SetOutputType,
1340     video_mixer_transform_GetInputCurrentType,
1341     video_mixer_transform_GetOutputCurrentType,
1342     video_mixer_transform_GetInputStatus,
1343     video_mixer_transform_GetOutputStatus,
1344     video_mixer_transform_SetOutputBounds,
1345     video_mixer_transform_ProcessEvent,
1346     video_mixer_transform_ProcessMessage,
1347     video_mixer_transform_ProcessInput,
1348     video_mixer_transform_ProcessOutput,
1349 };
1350
1351 static HRESULT WINAPI video_mixer_device_id_QueryInterface(IMFVideoDeviceID *iface, REFIID riid, void **obj)
1352 {
1353     struct video_mixer *mixer = impl_from_IMFVideoDeviceID(iface);
1354     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, obj);
1355 }
1356
1357 static ULONG WINAPI video_mixer_device_id_AddRef(IMFVideoDeviceID *iface)
1358 {
1359     struct video_mixer *mixer = impl_from_IMFVideoDeviceID(iface);
1360     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
1361 }
1362
1363 static ULONG WINAPI video_mixer_device_id_Release(IMFVideoDeviceID *iface)
1364 {
1365     struct video_mixer *mixer = impl_from_IMFVideoDeviceID(iface);
1366     return IMFTransform_Release(&mixer->IMFTransform_iface);
1367 }
1368
1369 static HRESULT WINAPI video_mixer_device_id_GetDeviceID(IMFVideoDeviceID *iface, IID *device_id)
1370 {
1371     TRACE("%p, %p.\n", iface, device_id);
1372
1373     if (!device_id)
1374         return E_POINTER;
1375
1376     memcpy(device_id, &IID_IDirect3DDevice9, sizeof(*device_id));
1377
1378     return S_OK;
1379 }
1380
1381 static const IMFVideoDeviceIDVtbl video_mixer_device_id_vtbl =
1382 {
1383     video_mixer_device_id_QueryInterface,
1384     video_mixer_device_id_AddRef,
1385     video_mixer_device_id_Release,
1386     video_mixer_device_id_GetDeviceID,
1387 };
1388
1389 static HRESULT WINAPI video_mixer_service_client_QueryInterface(IMFTopologyServiceLookupClient *iface,
1390         REFIID riid, void **obj)
1391 {
1392     struct video_mixer *mixer = impl_from_IMFTopologyServiceLookupClient(iface);
1393     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, obj);
1394 }
1395
1396 static ULONG WINAPI video_mixer_service_client_AddRef(IMFTopologyServiceLookupClient *iface)
1397 {
1398     struct video_mixer *mixer = impl_from_IMFTopologyServiceLookupClient(iface);
1399     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
1400 }
1401
1402 static ULONG WINAPI video_mixer_service_client_Release(IMFTopologyServiceLookupClient *iface)
1403 {
1404     struct video_mixer *mixer = impl_from_IMFTopologyServiceLookupClient(iface);
1405     return IMFTransform_Release(&mixer->IMFTransform_iface);
1406 }
1407
1408 static HRESULT WINAPI video_mixer_service_client_InitServicePointers(IMFTopologyServiceLookupClient *iface,
1409         IMFTopologyServiceLookup *service_lookup)
1410 {
1411     struct video_mixer *mixer = impl_from_IMFTopologyServiceLookupClient(iface);
1412     unsigned int count;
1413     HRESULT hr;
1414
1415     TRACE("%p, %p.\n", iface, service_lookup);
1416
1417     if (!service_lookup)
1418         return E_POINTER;
1419
1420     EnterCriticalSection(&mixer->cs);
1421
1422     count = 1;
1423     if (FAILED(hr = IMFTopologyServiceLookup_LookupService(service_lookup, MF_SERVICE_LOOKUP_GLOBAL, 0,
1424             &MR_VIDEO_RENDER_SERVICE, &IID_IMediaEventSink, (void **)&mixer->event_sink, &count)))
1425     {
1426         WARN("Failed to get renderer event sink, hr %#x.\n", hr);
1427     }
1428
1429     LeaveCriticalSection(&mixer->cs);
1430
1431     return hr;
1432 }
1433
1434 static HRESULT WINAPI video_mixer_service_client_ReleaseServicePointers(IMFTopologyServiceLookupClient *iface)
1435 {
1436     struct video_mixer *mixer = impl_from_IMFTopologyServiceLookupClient(iface);
1437
1438     TRACE("%p.\n", iface);
1439
1440     EnterCriticalSection(&mixer->cs);
1441
1442     if (mixer->event_sink)
1443         IMediaEventSink_Release(mixer->event_sink);
1444     mixer->event_sink = NULL;
1445
1446     LeaveCriticalSection(&mixer->cs);
1447
1448     return S_OK;
1449 }
1450
1451 static const IMFTopologyServiceLookupClientVtbl video_mixer_service_client_vtbl =
1452 {
1453     video_mixer_service_client_QueryInterface,
1454     video_mixer_service_client_AddRef,
1455     video_mixer_service_client_Release,
1456     video_mixer_service_client_InitServicePointers,
1457     video_mixer_service_client_ReleaseServicePointers,
1458 };
1459
1460 static HRESULT WINAPI video_mixer_control_QueryInterface(IMFVideoMixerControl2 *iface, REFIID riid, void **obj)
1461 {
1462     struct video_mixer *mixer = impl_from_IMFVideoMixerControl2(iface);
1463     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, obj);
1464 }
1465
1466 static ULONG WINAPI video_mixer_control_AddRef(IMFVideoMixerControl2 *iface)
1467 {
1468     struct video_mixer *mixer = impl_from_IMFVideoMixerControl2(iface);
1469     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
1470 }
1471
1472 static ULONG WINAPI video_mixer_control_Release(IMFVideoMixerControl2 *iface)
1473 {
1474     struct video_mixer *mixer = impl_from_IMFVideoMixerControl2(iface);
1475     return IMFTransform_Release(&mixer->IMFTransform_iface);
1476 }
1477
1478 static HRESULT WINAPI video_mixer_control_SetStreamZOrder(IMFVideoMixerControl2 *iface, DWORD id, DWORD zorder)
1479 {
1480     struct video_mixer *mixer = impl_from_IMFVideoMixerControl2(iface);
1481     struct input_stream *stream;
1482     HRESULT hr;
1483
1484     TRACE("%p, %u, %u.\n", iface, id, zorder);
1485
1486     /* Can't change reference stream. */
1487     if (!id && zorder)
1488         return E_INVALIDARG;
1489
1490     EnterCriticalSection(&mixer->cs);
1491
1492     if (zorder >= mixer->input_count)
1493         hr = E_INVALIDARG;
1494     else if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &stream)))
1495     {
1496         /* Lowest zorder only applies to reference stream. */
1497         if (id && !zorder)
1498             hr = MF_E_INVALIDREQUEST;
1499         else
1500             stream->zorder = zorder;
1501     }
1502
1503     LeaveCriticalSection(&mixer->cs);
1504
1505     return hr;
1506 }
1507
1508 static HRESULT WINAPI video_mixer_control_GetStreamZOrder(IMFVideoMixerControl2 *iface, DWORD id, DWORD *zorder)
1509 {
1510     struct video_mixer *mixer = impl_from_IMFVideoMixerControl2(iface);
1511     struct input_stream *stream;
1512     HRESULT hr;
1513
1514     TRACE("%p, %u, %p.\n", iface, id, zorder);
1515
1516     if (!zorder)
1517         return E_POINTER;
1518
1519     EnterCriticalSection(&mixer->cs);
1520
1521     if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &stream)))
1522         *zorder = stream->zorder;
1523
1524     LeaveCriticalSection(&mixer->cs);
1525
1526     return hr;
1527 }
1528
1529 static HRESULT WINAPI video_mixer_control_SetStreamOutputRect(IMFVideoMixerControl2 *iface, DWORD id,
1530         const MFVideoNormalizedRect *rect)
1531 {
1532     struct video_mixer *mixer = impl_from_IMFVideoMixerControl2(iface);
1533     struct input_stream *stream;
1534     HRESULT hr;
1535
1536     TRACE("%p, %u, %p.\n", iface, id, rect);
1537
1538     if (!rect)
1539         return E_POINTER;
1540
1541     if (rect->left > rect->right || rect->top > rect->bottom ||
1542             rect->left < 0.0f || rect->top < 0.0f || rect->right > 1.0f || rect->bottom > 1.0f)
1543     {
1544         return E_INVALIDARG;
1545     }
1546
1547     EnterCriticalSection(&mixer->cs);
1548
1549     if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &stream)))
1550         stream->rect = *rect;
1551
1552     LeaveCriticalSection(&mixer->cs);
1553
1554     return hr;
1555 }
1556
1557 static HRESULT WINAPI video_mixer_control_GetStreamOutputRect(IMFVideoMixerControl2 *iface, DWORD id,
1558         MFVideoNormalizedRect *rect)
1559 {
1560     struct video_mixer *mixer = impl_from_IMFVideoMixerControl2(iface);
1561     struct input_stream *stream;
1562     HRESULT hr;
1563
1564     TRACE("%p, %u, %p.\n", iface, id, rect);
1565
1566     if (!rect)
1567         return E_POINTER;
1568
1569     EnterCriticalSection(&mixer->cs);
1570
1571     if (SUCCEEDED(hr = video_mixer_get_input(mixer, id, &stream)))
1572         *rect = stream->rect;
1573
1574     LeaveCriticalSection(&mixer->cs);
1575
1576     return hr;
1577 }
1578
1579 static HRESULT WINAPI video_mixer_control_SetMixingPrefs(IMFVideoMixerControl2 *iface, DWORD flags)
1580 {
1581     struct video_mixer *mixer = impl_from_IMFVideoMixerControl2(iface);
1582
1583     TRACE("%p, %#x.\n", iface, flags);
1584
1585     EnterCriticalSection(&mixer->cs);
1586     mixer->mixing_flags = flags;
1587     LeaveCriticalSection(&mixer->cs);
1588
1589     return S_OK;
1590 }
1591
1592 static HRESULT WINAPI video_mixer_control_GetMixingPrefs(IMFVideoMixerControl2 *iface, DWORD *flags)
1593 {
1594     struct video_mixer *mixer = impl_from_IMFVideoMixerControl2(iface);
1595
1596     TRACE("%p, %p.\n", iface, flags);
1597
1598     if (!flags)
1599         return E_POINTER;
1600
1601     EnterCriticalSection(&mixer->cs);
1602     *flags = mixer->mixing_flags;
1603     LeaveCriticalSection(&mixer->cs);
1604
1605     return S_OK;
1606 }
1607
1608 static const IMFVideoMixerControl2Vtbl video_mixer_control_vtbl =
1609 {
1610     video_mixer_control_QueryInterface,
1611     video_mixer_control_AddRef,
1612     video_mixer_control_Release,
1613     video_mixer_control_SetStreamZOrder,
1614     video_mixer_control_GetStreamZOrder,
1615     video_mixer_control_SetStreamOutputRect,
1616     video_mixer_control_GetStreamOutputRect,
1617     video_mixer_control_SetMixingPrefs,
1618     video_mixer_control_GetMixingPrefs,
1619 };
1620
1621 static HRESULT WINAPI video_mixer_getservice_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
1622 {
1623     struct video_mixer *mixer = impl_from_IMFGetService(iface);
1624     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, obj);
1625 }
1626
1627 static ULONG WINAPI video_mixer_getservice_AddRef(IMFGetService *iface)
1628 {
1629     struct video_mixer *mixer = impl_from_IMFGetService(iface);
1630     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
1631 }
1632
1633 static ULONG WINAPI video_mixer_getservice_Release(IMFGetService *iface)
1634 {
1635     struct video_mixer *mixer = impl_from_IMFGetService(iface);
1636     return IMFTransform_Release(&mixer->IMFTransform_iface);
1637 }
1638
1639 static HRESULT WINAPI video_mixer_getservice_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
1640 {
1641     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
1642
1643     if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE))
1644     {
1645         if (IsEqualIID(riid, &IID_IMFVideoMixerBitmap) ||
1646                 IsEqualIID(riid, &IID_IMFVideoProcessor) ||
1647                 IsEqualIID(riid, &IID_IMFVideoPositionMapper) ||
1648                 IsEqualIID(riid, &IID_IMFVideoMixerControl) ||
1649                 IsEqualIID(riid, &IID_IMFVideoMixerControl2))
1650         {
1651             return IMFGetService_QueryInterface(iface, riid, obj);
1652         }
1653
1654         return E_NOINTERFACE;
1655     }
1656
1657     FIXME("Unsupported service %s, riid %s.\n", debugstr_guid(service), debugstr_guid(riid));
1658
1659     return MF_E_UNSUPPORTED_SERVICE;
1660 }
1661
1662 static const IMFGetServiceVtbl video_mixer_getservice_vtbl =
1663 {
1664     video_mixer_getservice_QueryInterface,
1665     video_mixer_getservice_AddRef,
1666     video_mixer_getservice_Release,
1667     video_mixer_getservice_GetService,
1668 };
1669
1670 static HRESULT WINAPI video_mixer_bitmap_QueryInterface(IMFVideoMixerBitmap *iface, REFIID riid, void **obj)
1671 {
1672     struct video_mixer *mixer = impl_from_IMFVideoMixerBitmap(iface);
1673     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, obj);
1674 }
1675
1676 static ULONG WINAPI video_mixer_bitmap_AddRef(IMFVideoMixerBitmap *iface)
1677 {
1678     struct video_mixer *mixer = impl_from_IMFVideoMixerBitmap(iface);
1679     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
1680 }
1681
1682 static ULONG WINAPI video_mixer_bitmap_Release(IMFVideoMixerBitmap *iface)
1683 {
1684     struct video_mixer *mixer = impl_from_IMFVideoMixerBitmap(iface);
1685     return IMFTransform_Release(&mixer->IMFTransform_iface);
1686 }
1687
1688 static HRESULT WINAPI video_mixer_bitmap_SetAlphaBitmap(IMFVideoMixerBitmap *iface, const MFVideoAlphaBitmap *bitmap)
1689 {
1690     FIXME("%p, %p.\n", iface, bitmap);
1691
1692     return E_NOTIMPL;
1693 }
1694
1695 static HRESULT WINAPI video_mixer_bitmap_ClearAlphaBitmap(IMFVideoMixerBitmap *iface)
1696 {
1697     FIXME("%p.\n", iface);
1698
1699     return E_NOTIMPL;
1700 }
1701
1702 static HRESULT WINAPI video_mixer_bitmap_UpdateAlphaBitmapParameters(IMFVideoMixerBitmap *iface,
1703         const MFVideoAlphaBitmapParams *params)
1704 {
1705     FIXME("%p, %p.\n", iface, params);
1706
1707     return E_NOTIMPL;
1708 }
1709
1710 static HRESULT WINAPI video_mixer_bitmap_GetAlphaBitmapParameters(IMFVideoMixerBitmap *iface, MFVideoAlphaBitmapParams *params)
1711 {
1712     FIXME("%p, %p.\n", iface, params);
1713
1714     return E_NOTIMPL;
1715 }
1716
1717 static const IMFVideoMixerBitmapVtbl video_mixer_bitmap_vtbl =
1718 {
1719     video_mixer_bitmap_QueryInterface,
1720     video_mixer_bitmap_AddRef,
1721     video_mixer_bitmap_Release,
1722     video_mixer_bitmap_SetAlphaBitmap,
1723     video_mixer_bitmap_ClearAlphaBitmap,
1724     video_mixer_bitmap_UpdateAlphaBitmapParameters,
1725     video_mixer_bitmap_GetAlphaBitmapParameters,
1726 };
1727
1728 static HRESULT WINAPI video_mixer_position_mapper_QueryInterface(IMFVideoPositionMapper *iface, REFIID riid, void **obj)
1729 {
1730     struct video_mixer *mixer = impl_from_IMFVideoPositionMapper(iface);
1731     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, obj);
1732 }
1733
1734 static ULONG WINAPI video_mixer_position_mapper_AddRef(IMFVideoPositionMapper *iface)
1735 {
1736     struct video_mixer *mixer = impl_from_IMFVideoPositionMapper(iface);
1737     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
1738 }
1739
1740 static ULONG WINAPI video_mixer_position_mapper_Release(IMFVideoPositionMapper *iface)
1741 {
1742     struct video_mixer *mixer = impl_from_IMFVideoPositionMapper(iface);
1743     return IMFTransform_Release(&mixer->IMFTransform_iface);
1744 }
1745
1746 static HRESULT WINAPI video_mixer_position_mapper_MapOutputCoordinateToInputStream(IMFVideoPositionMapper *iface,
1747         float x_out, float y_out, DWORD output_stream, DWORD input_stream, float *x_in, float *y_in)
1748 {
1749     FIXME("%p, %f, %f, %u, %u, %p, %p.\n", iface, x_out, y_out, output_stream, input_stream, x_in, y_in);
1750
1751     return E_NOTIMPL;
1752 }
1753
1754 static const IMFVideoPositionMapperVtbl video_mixer_position_mapper_vtbl =
1755 {
1756     video_mixer_position_mapper_QueryInterface,
1757     video_mixer_position_mapper_AddRef,
1758     video_mixer_position_mapper_Release,
1759     video_mixer_position_mapper_MapOutputCoordinateToInputStream,
1760 };
1761
1762 static HRESULT WINAPI video_mixer_processor_QueryInterface(IMFVideoProcessor *iface, REFIID riid, void **obj)
1763 {
1764     struct video_mixer *mixer = impl_from_IMFVideoProcessor(iface);
1765     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, obj);
1766 }
1767
1768 static ULONG WINAPI video_mixer_processor_AddRef(IMFVideoProcessor *iface)
1769 {
1770     struct video_mixer *mixer = impl_from_IMFVideoProcessor(iface);
1771     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
1772 }
1773
1774 static ULONG WINAPI video_mixer_processor_Release(IMFVideoProcessor *iface)
1775 {
1776     struct video_mixer *mixer = impl_from_IMFVideoProcessor(iface);
1777     return IMFTransform_Release(&mixer->IMFTransform_iface);
1778 }
1779
1780 static HRESULT WINAPI video_mixer_processor_GetAvailableVideoProcessorModes(IMFVideoProcessor *iface, UINT *count,
1781         GUID **modes)
1782 {
1783     FIXME("%p, %p, %p.\n", iface, count, modes);
1784
1785     return E_NOTIMPL;
1786 }
1787
1788 static HRESULT WINAPI video_mixer_processor_GetVideoProcessorCaps(IMFVideoProcessor *iface, GUID *mode,
1789         DXVA2_VideoProcessorCaps *caps)
1790 {
1791     FIXME("%p, %s, %p.\n", iface, debugstr_guid(mode), caps);
1792
1793     return E_NOTIMPL;
1794 }
1795
1796 static HRESULT WINAPI video_mixer_processor_GetVideoProcessorMode(IMFVideoProcessor *iface, GUID *mode)
1797 {
1798     FIXME("%p, %p.\n", iface, mode);
1799
1800     return E_NOTIMPL;
1801 }
1802
1803 static HRESULT WINAPI video_mixer_processor_SetVideoProcessorMode(IMFVideoProcessor *iface, GUID *mode)
1804 {
1805     FIXME("%p, %s.\n", iface, debugstr_guid(mode));
1806
1807     return E_NOTIMPL;
1808 }
1809
1810 static HRESULT WINAPI video_mixer_processor_GetProcAmpRange(IMFVideoProcessor *iface, DWORD prop, DXVA2_ValueRange *range)
1811 {
1812     FIXME("%p, %#x, %p.\n", iface, prop, range);
1813
1814     return E_NOTIMPL;
1815 }
1816
1817 static HRESULT WINAPI video_mixer_processor_GetProcAmpValues(IMFVideoProcessor *iface, DWORD flags, DXVA2_ProcAmpValues *values)
1818 {
1819     FIXME("%p, %#x, %p.\n", iface, flags, values);
1820
1821     return E_NOTIMPL;
1822 }
1823
1824 static HRESULT WINAPI video_mixer_processor_SetProcAmpValues(IMFVideoProcessor *iface, DWORD flags, DXVA2_ProcAmpValues *values)
1825 {
1826     FIXME("%p, %#x, %p.\n", iface, flags, values);
1827
1828     return E_NOTIMPL;
1829 }
1830
1831 static HRESULT WINAPI video_mixer_processor_GetFilteringRange(IMFVideoProcessor *iface, DWORD prop, DXVA2_ValueRange *range)
1832 {
1833     FIXME("%p, %#x, %p.\n", iface, prop, range);
1834
1835     return E_NOTIMPL;
1836 }
1837
1838 static HRESULT WINAPI video_mixer_processor_GetFilteringValue(IMFVideoProcessor *iface, DWORD prop, DXVA2_Fixed32 *value)
1839 {
1840     FIXME("%p, %#x, %p.\n", iface, prop, value);
1841
1842     return E_NOTIMPL;
1843 }
1844
1845 static HRESULT WINAPI video_mixer_processor_SetFilteringValue(IMFVideoProcessor *iface, DWORD prop, DXVA2_Fixed32 *value)
1846 {
1847     FIXME("%p, %#x, %p.\n", iface, prop, value);
1848
1849     return E_NOTIMPL;
1850 }
1851
1852 static HRESULT WINAPI video_mixer_processor_GetBackgroundColor(IMFVideoProcessor *iface, COLORREF *color)
1853 {
1854     struct video_mixer *mixer = impl_from_IMFVideoProcessor(iface);
1855
1856     TRACE("%p, %p.\n", iface, color);
1857
1858     if (!color)
1859         return E_POINTER;
1860
1861     EnterCriticalSection(&mixer->cs);
1862     *color = mixer->bkgnd_color;
1863     LeaveCriticalSection(&mixer->cs);
1864
1865     return S_OK;
1866 }
1867
1868 static HRESULT WINAPI video_mixer_processor_SetBackgroundColor(IMFVideoProcessor *iface, COLORREF color)
1869 {
1870     struct video_mixer *mixer = impl_from_IMFVideoProcessor(iface);
1871
1872     TRACE("%p, %#x.\n", iface, color);
1873
1874     EnterCriticalSection(&mixer->cs);
1875     mixer->bkgnd_color = color;
1876     LeaveCriticalSection(&mixer->cs);
1877
1878     return S_OK;
1879 }
1880
1881 static const IMFVideoProcessorVtbl video_mixer_processor_vtbl =
1882 {
1883     video_mixer_processor_QueryInterface,
1884     video_mixer_processor_AddRef,
1885     video_mixer_processor_Release,
1886     video_mixer_processor_GetAvailableVideoProcessorModes,
1887     video_mixer_processor_GetVideoProcessorCaps,
1888     video_mixer_processor_GetVideoProcessorMode,
1889     video_mixer_processor_SetVideoProcessorMode,
1890     video_mixer_processor_GetProcAmpRange,
1891     video_mixer_processor_GetProcAmpValues,
1892     video_mixer_processor_SetProcAmpValues,
1893     video_mixer_processor_GetFilteringRange,
1894     video_mixer_processor_GetFilteringValue,
1895     video_mixer_processor_SetFilteringValue,
1896     video_mixer_processor_GetBackgroundColor,
1897     video_mixer_processor_SetBackgroundColor,
1898 };
1899
1900 static HRESULT WINAPI video_mixer_attributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **out)
1901 {
1902     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1903     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, out);
1904 }
1905
1906 static ULONG WINAPI video_mixer_attributes_AddRef(IMFAttributes *iface)
1907 {
1908     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1909     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
1910 }
1911
1912 static ULONG WINAPI video_mixer_attributes_Release(IMFAttributes *iface)
1913 {
1914     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1915     return IMFTransform_Release(&mixer->IMFTransform_iface);
1916 }
1917
1918 static HRESULT WINAPI video_mixer_attributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
1919 {
1920     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1921
1922     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1923
1924     return IMFAttributes_GetItem(mixer->internal_attributes, key, value);
1925 }
1926
1927 static HRESULT WINAPI video_mixer_attributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
1928 {
1929     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1930
1931     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
1932
1933     return IMFAttributes_GetItemType(mixer->internal_attributes, key, type);
1934 }
1935
1936 static HRESULT WINAPI video_mixer_attributes_CompareItem(IMFAttributes *iface, REFGUID key,
1937         REFPROPVARIANT value, BOOL *result)
1938 {
1939     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1940
1941     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
1942
1943     return IMFAttributes_CompareItem(mixer->internal_attributes, key, value, result);
1944 }
1945
1946 static HRESULT WINAPI video_mixer_attributes_Compare(IMFAttributes *iface, IMFAttributes *theirs,
1947         MF_ATTRIBUTES_MATCH_TYPE match_type, BOOL *ret)
1948 {
1949     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1950
1951     TRACE("%p, %p, %d, %p.\n", iface, theirs, match_type, ret);
1952
1953     return IMFAttributes_Compare(mixer->internal_attributes, theirs, match_type, ret);
1954 }
1955
1956 static HRESULT WINAPI video_mixer_attributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
1957 {
1958     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1959
1960     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1961
1962     return IMFAttributes_GetUINT32(mixer->internal_attributes, key, value);
1963 }
1964
1965 static HRESULT WINAPI video_mixer_attributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
1966 {
1967     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1968
1969     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1970
1971     return IMFAttributes_GetUINT64(mixer->internal_attributes, key, value);
1972 }
1973
1974 static HRESULT WINAPI video_mixer_attributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
1975 {
1976     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1977
1978     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1979
1980     return IMFAttributes_GetDouble(mixer->internal_attributes, key, value);
1981 }
1982
1983 static HRESULT WINAPI video_mixer_attributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
1984 {
1985     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1986
1987     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1988
1989     return IMFAttributes_GetGUID(mixer->internal_attributes, key, value);
1990 }
1991
1992 static HRESULT WINAPI video_mixer_attributes_GetStringLength(IMFAttributes *iface, REFGUID key, UINT32 *length)
1993 {
1994     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
1995
1996     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
1997
1998     return IMFAttributes_GetStringLength(mixer->internal_attributes, key, length);
1999 }
2000
2001 static HRESULT WINAPI video_mixer_attributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
2002         UINT32 size, UINT32 *length)
2003 {
2004     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2005
2006     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), value, size, length);
2007
2008     return IMFAttributes_GetString(mixer->internal_attributes, key, value, size, length);
2009 }
2010
2011 static HRESULT WINAPI video_mixer_attributes_GetAllocatedString(IMFAttributes *iface, REFGUID key,
2012         WCHAR **value, UINT32 *length)
2013 {
2014     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2015
2016     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
2017
2018     return IMFAttributes_GetAllocatedString(mixer->internal_attributes, key, value, length);
2019 }
2020
2021 static HRESULT WINAPI video_mixer_attributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
2022 {
2023     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2024
2025     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
2026
2027     return IMFAttributes_GetBlobSize(mixer->internal_attributes, key, size);
2028 }
2029
2030 static HRESULT WINAPI video_mixer_attributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
2031                 UINT32 bufsize, UINT32 *blobsize)
2032 {
2033     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2034
2035     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
2036
2037     return IMFAttributes_GetBlob(mixer->internal_attributes, key, buf, bufsize, blobsize);
2038 }
2039
2040 static HRESULT WINAPI video_mixer_attributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key, UINT8 **buf, UINT32 *size)
2041 {
2042     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2043
2044     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
2045
2046     return IMFAttributes_GetAllocatedBlob(mixer->internal_attributes, key, buf, size);
2047 }
2048
2049 static HRESULT WINAPI video_mixer_attributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **out)
2050 {
2051     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2052
2053     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), out);
2054
2055     return IMFAttributes_GetUnknown(mixer->internal_attributes, key, riid, out);
2056 }
2057
2058 static HRESULT WINAPI video_mixer_attributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value)
2059 {
2060     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2061
2062     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
2063
2064     return IMFAttributes_SetItem(mixer->internal_attributes, key, value);
2065 }
2066
2067 static HRESULT WINAPI video_mixer_attributes_DeleteItem(IMFAttributes *iface, REFGUID key)
2068 {
2069     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2070
2071     TRACE("%p, %s.\n", iface, debugstr_guid(key));
2072
2073     return IMFAttributes_DeleteItem(mixer->internal_attributes, key);
2074 }
2075
2076 static HRESULT WINAPI video_mixer_attributes_DeleteAllItems(IMFAttributes *iface)
2077 {
2078     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2079
2080     TRACE("%p.\n", iface);
2081
2082     return IMFAttributes_DeleteAllItems(mixer->internal_attributes);
2083 }
2084
2085 static HRESULT WINAPI video_mixer_attributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
2086 {
2087     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2088
2089     TRACE("%p, %s, %u.\n", iface, debugstr_guid(key), value);
2090
2091     return IMFAttributes_SetUINT32(mixer->internal_attributes, key, value);
2092 }
2093
2094 static HRESULT WINAPI video_mixer_attributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
2095 {
2096     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2097
2098     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
2099
2100     return IMFAttributes_SetUINT64(mixer->internal_attributes, key, value);
2101 }
2102
2103 static HRESULT WINAPI video_mixer_attributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
2104 {
2105     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2106
2107     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
2108
2109     return IMFAttributes_SetDouble(mixer->internal_attributes, key, value);
2110 }
2111
2112 static HRESULT WINAPI video_mixer_attributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
2113 {
2114     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2115
2116     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
2117
2118     return IMFAttributes_SetGUID(mixer->internal_attributes, key, value);
2119 }
2120
2121 static HRESULT WINAPI video_mixer_attributes_SetString(IMFAttributes *iface, REFGUID key, const WCHAR *value)
2122 {
2123     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2124
2125     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
2126
2127     return IMFAttributes_SetString(mixer->internal_attributes, key, value);
2128 }
2129
2130 static HRESULT WINAPI video_mixer_attributes_SetBlob(IMFAttributes *iface, REFGUID key, const UINT8 *buf, UINT32 size)
2131 {
2132     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2133
2134     TRACE("%p, %s, %p, %u.\n", iface, debugstr_guid(key), buf, size);
2135
2136     return IMFAttributes_SetBlob(mixer->internal_attributes, key, buf, size);
2137 }
2138
2139 static HRESULT WINAPI video_mixer_attributes_SetUnknown(IMFAttributes *iface, REFGUID key, IUnknown *unknown)
2140 {
2141     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2142
2143     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), unknown);
2144
2145     return IMFAttributes_SetUnknown(mixer->internal_attributes, key, unknown);
2146 }
2147
2148 static HRESULT WINAPI video_mixer_attributes_LockStore(IMFAttributes *iface)
2149 {
2150     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2151
2152     TRACE("%p.\n", iface);
2153
2154     return IMFAttributes_LockStore(mixer->internal_attributes);
2155 }
2156
2157 static HRESULT WINAPI video_mixer_attributes_UnlockStore(IMFAttributes *iface)
2158 {
2159     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2160
2161     TRACE("%p.\n", iface);
2162
2163     return IMFAttributes_UnlockStore(mixer->internal_attributes);
2164 }
2165
2166 static HRESULT WINAPI video_mixer_attributes_GetCount(IMFAttributes *iface, UINT32 *count)
2167 {
2168     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2169
2170     TRACE("%p, %p.\n", iface, count);
2171
2172     return IMFAttributes_GetCount(mixer->internal_attributes, count);
2173 }
2174
2175 static HRESULT WINAPI video_mixer_attributes_GetItemByIndex(IMFAttributes *iface, UINT32 index,
2176         GUID *key, PROPVARIANT *value)
2177 {
2178     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2179
2180     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
2181
2182     return IMFAttributes_GetItemByIndex(mixer->internal_attributes, index, key, value);
2183 }
2184
2185 static HRESULT WINAPI video_mixer_attributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
2186 {
2187     struct video_mixer *mixer = impl_from_IMFAttributes(iface);
2188
2189     TRACE("%p, %p.\n", iface, dest);
2190
2191     return IMFAttributes_CopyAllItems(mixer->internal_attributes, dest);
2192 }
2193
2194 static const IMFAttributesVtbl video_mixer_attributes_vtbl =
2195 {
2196     video_mixer_attributes_QueryInterface,
2197     video_mixer_attributes_AddRef,
2198     video_mixer_attributes_Release,
2199     video_mixer_attributes_GetItem,
2200     video_mixer_attributes_GetItemType,
2201     video_mixer_attributes_CompareItem,
2202     video_mixer_attributes_Compare,
2203     video_mixer_attributes_GetUINT32,
2204     video_mixer_attributes_GetUINT64,
2205     video_mixer_attributes_GetDouble,
2206     video_mixer_attributes_GetGUID,
2207     video_mixer_attributes_GetStringLength,
2208     video_mixer_attributes_GetString,
2209     video_mixer_attributes_GetAllocatedString,
2210     video_mixer_attributes_GetBlobSize,
2211     video_mixer_attributes_GetBlob,
2212     video_mixer_attributes_GetAllocatedBlob,
2213     video_mixer_attributes_GetUnknown,
2214     video_mixer_attributes_SetItem,
2215     video_mixer_attributes_DeleteItem,
2216     video_mixer_attributes_DeleteAllItems,
2217     video_mixer_attributes_SetUINT32,
2218     video_mixer_attributes_SetUINT64,
2219     video_mixer_attributes_SetDouble,
2220     video_mixer_attributes_SetGUID,
2221     video_mixer_attributes_SetString,
2222     video_mixer_attributes_SetBlob,
2223     video_mixer_attributes_SetUnknown,
2224     video_mixer_attributes_LockStore,
2225     video_mixer_attributes_UnlockStore,
2226     video_mixer_attributes_GetCount,
2227     video_mixer_attributes_GetItemByIndex,
2228     video_mixer_attributes_CopyAllItems
2229 };
2230
2231 static HRESULT WINAPI video_mixer_quality_advise_QueryInterface(IMFQualityAdvise *iface, REFIID riid, void **out)
2232 {
2233     struct video_mixer *mixer = impl_from_IMFQualityAdvise(iface);
2234     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, out);
2235 }
2236
2237 static ULONG WINAPI video_mixer_quality_advise_AddRef(IMFQualityAdvise *iface)
2238 {
2239     struct video_mixer *mixer = impl_from_IMFQualityAdvise(iface);
2240     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
2241 }
2242
2243 static ULONG WINAPI video_mixer_quality_advise_Release(IMFQualityAdvise *iface)
2244 {
2245     struct video_mixer *mixer = impl_from_IMFQualityAdvise(iface);
2246     return IMFTransform_Release(&mixer->IMFTransform_iface);
2247 }
2248
2249 static HRESULT WINAPI video_mixer_quality_advise_SetDropMode(IMFQualityAdvise *iface, MF_QUALITY_DROP_MODE mode)
2250 {
2251     FIXME("%p, %u.\n", iface, mode);
2252
2253     return E_NOTIMPL;
2254 }
2255
2256 static HRESULT WINAPI video_mixer_quality_advise_SetQualityLevel(IMFQualityAdvise *iface, MF_QUALITY_LEVEL level)
2257 {
2258     FIXME("%p, %u.\n", iface, level);
2259
2260     return E_NOTIMPL;
2261 }
2262
2263 static HRESULT WINAPI video_mixer_quality_advise_GetDropMode(IMFQualityAdvise *iface, MF_QUALITY_DROP_MODE *mode)
2264 {
2265     FIXME("%p, %p.\n", iface, mode);
2266
2267     return E_NOTIMPL;
2268 }
2269
2270 static HRESULT WINAPI video_mixer_quality_advise_GetQualityLevel(IMFQualityAdvise *iface, MF_QUALITY_LEVEL *level)
2271 {
2272     FIXME("%p, %p.\n", iface, level);
2273
2274     return E_NOTIMPL;
2275 }
2276
2277 static HRESULT WINAPI video_mixer_quality_advise_DropTime(IMFQualityAdvise *iface, LONGLONG interval)
2278 {
2279     FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(interval));
2280
2281     return E_NOTIMPL;
2282 }
2283
2284 static const IMFQualityAdviseVtbl video_mixer_quality_advise_vtbl =
2285 {
2286     video_mixer_quality_advise_QueryInterface,
2287     video_mixer_quality_advise_AddRef,
2288     video_mixer_quality_advise_Release,
2289     video_mixer_quality_advise_SetDropMode,
2290     video_mixer_quality_advise_SetQualityLevel,
2291     video_mixer_quality_advise_GetDropMode,
2292     video_mixer_quality_advise_GetQualityLevel,
2293     video_mixer_quality_advise_DropTime,
2294 };
2295
2296 static HRESULT WINAPI video_mixer_clock_state_sink_QueryInterface(IMFClockStateSink *iface,
2297         REFIID riid, void **out)
2298 {
2299     struct video_mixer *mixer = impl_from_IMFClockStateSink(iface);
2300     return IMFTransform_QueryInterface(&mixer->IMFTransform_iface, riid, out);
2301 }
2302
2303 static ULONG WINAPI video_mixer_clock_state_sink_AddRef(IMFClockStateSink *iface)
2304 {
2305     struct video_mixer *mixer = impl_from_IMFClockStateSink(iface);
2306     return IMFTransform_AddRef(&mixer->IMFTransform_iface);
2307 }
2308
2309 static ULONG WINAPI video_mixer_clock_state_sink_Release(IMFClockStateSink *iface)
2310 {
2311     struct video_mixer *mixer = impl_from_IMFClockStateSink(iface);
2312     return IMFTransform_Release(&mixer->IMFTransform_iface);
2313 }
2314
2315 static HRESULT WINAPI video_mixer_clock_state_sink_OnClockStart(IMFClockStateSink *iface,
2316         MFTIME systime, LONGLONG offset)
2317 {
2318     FIXME("%p.\n", iface);
2319
2320     return E_NOTIMPL;
2321 }
2322
2323 static HRESULT WINAPI video_mixer_clock_state_sink_OnClockStop(IMFClockStateSink *iface,
2324         MFTIME systime)
2325 {
2326     FIXME("%p.\n", iface);
2327
2328     return E_NOTIMPL;
2329 }
2330
2331 static HRESULT WINAPI video_mixer_clock_state_sink_OnClockPause(IMFClockStateSink *iface,
2332         MFTIME systime)
2333 {
2334     FIXME("%p.\n", iface);
2335
2336     return E_NOTIMPL;
2337 }
2338
2339 static HRESULT WINAPI video_mixer_clock_state_sink_OnClockRestart(IMFClockStateSink *iface,
2340         MFTIME systime)
2341 {
2342     FIXME("%p.\n", iface);
2343
2344     return E_NOTIMPL;
2345 }
2346
2347 static HRESULT WINAPI video_mixer_clock_state_sink_OnClockSetRate(IMFClockStateSink *iface,
2348         MFTIME systime, float rate)
2349 {
2350     FIXME("%p, %f.\n", iface, rate);
2351
2352     return E_NOTIMPL;
2353 }
2354
2355 static const IMFClockStateSinkVtbl video_mixer_clock_state_sink_vtbl =
2356 {
2357     video_mixer_clock_state_sink_QueryInterface,
2358     video_mixer_clock_state_sink_AddRef,
2359     video_mixer_clock_state_sink_Release,
2360     video_mixer_clock_state_sink_OnClockStart,
2361     video_mixer_clock_state_sink_OnClockStop,
2362     video_mixer_clock_state_sink_OnClockPause,
2363     video_mixer_clock_state_sink_OnClockRestart,
2364     video_mixer_clock_state_sink_OnClockSetRate,
2365 };
2366
2367 HRESULT WINAPI MFCreateVideoMixer(IUnknown *owner, REFIID riid_device, REFIID riid, void **obj)
2368 {
2369     TRACE("%p, %s, %s, %p.\n", owner, debugstr_guid(riid_device), debugstr_guid(riid), obj);
2370
2371     *obj = NULL;
2372
2373     if (!IsEqualIID(riid_device, &IID_IDirect3DDevice9))
2374         return E_INVALIDARG;
2375
2376     return CoCreateInstance(&CLSID_MFVideoMixer9, owner, CLSCTX_INPROC_SERVER, riid, obj);
2377 }
2378
2379 HRESULT evr_mixer_create(IUnknown *outer, void **out)
2380 {
2381     struct video_mixer *object;
2382     MFVideoNormalizedRect rect;
2383     HRESULT hr;
2384
2385     if (!(object = calloc(1, sizeof(*object))))
2386         return E_OUTOFMEMORY;
2387
2388     object->IMFTransform_iface.lpVtbl = &video_mixer_transform_vtbl;
2389     object->IMFVideoDeviceID_iface.lpVtbl = &video_mixer_device_id_vtbl;
2390     object->IMFTopologyServiceLookupClient_iface.lpVtbl = &video_mixer_service_client_vtbl;
2391     object->IMFVideoMixerControl2_iface.lpVtbl = &video_mixer_control_vtbl;
2392     object->IMFGetService_iface.lpVtbl = &video_mixer_getservice_vtbl;
2393     object->IMFVideoMixerBitmap_iface.lpVtbl = &video_mixer_bitmap_vtbl;
2394     object->IMFVideoPositionMapper_iface.lpVtbl = &video_mixer_position_mapper_vtbl;
2395     object->IMFVideoProcessor_iface.lpVtbl = &video_mixer_processor_vtbl;
2396     object->IMFAttributes_iface.lpVtbl = &video_mixer_attributes_vtbl;
2397     object->IMFQualityAdvise_iface.lpVtbl = &video_mixer_quality_advise_vtbl;
2398     object->IMFClockStateSink_iface.lpVtbl = &video_mixer_clock_state_sink_vtbl;
2399     object->IUnknown_inner.lpVtbl = &video_mixer_inner_vtbl;
2400     object->outer_unk = outer ? outer : &object->IUnknown_inner;
2401     object->refcount = 1;
2402     object->input_count = 1;
2403     object->lower_bound = MFT_OUTPUT_BOUND_LOWER_UNBOUNDED;
2404     object->upper_bound = MFT_OUTPUT_BOUND_UPPER_UNBOUNDED;
2405     video_mixer_init_input(&object->inputs[0]);
2406     InitializeCriticalSection(&object->cs);
2407     if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
2408     {
2409         IUnknown_Release(&object->IUnknown_inner);
2410         return hr;
2411     }
2412     if (FAILED(hr = MFCreateAttributes(&object->internal_attributes, 0)))
2413     {
2414         IUnknown_Release(&object->IUnknown_inner);
2415         return hr;
2416     }
2417
2418     /* Default attributes configuration. */
2419
2420     rect.left = rect.top = 0.0f;
2421     rect.right = rect.bottom = 1.0f;
2422     IMFAttributes_SetBlob(object->attributes, &VIDEO_ZOOM_RECT, (const UINT8 *)&rect, sizeof(rect));
2423
2424     IMFAttributes_SetUINT32(object->internal_attributes, &MF_SA_D3D_AWARE, 1);
2425
2426     *out = &object->IUnknown_inner;
2427
2428     return S_OK;
2429 }