dlls/mfmediaengine/main.c

   1 /*
   2  * Copyright 2019 Jactry Zeng for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include <math.h>
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26
  27 #include "mfapi.h"
  28 #include "mfmediaengine.h"
  29 #include "mferror.h"
  30 #include "dxgi.h"
  31
  32 #include "wine/debug.h"
  33 #include "wine/heap.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  36
  37 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
  38 {
  39     switch (reason)
  40     {
  41         case DLL_WINE_PREATTACH:
  42             return FALSE;    /* prefer native version */
  43         case DLL_PROCESS_ATTACH:
  44             DisableThreadLibraryCalls(instance);
  45             break;
  46     }
  47
  48     return TRUE;
  49 }
  50
  51 enum media_engine_mode
  52 {
  53     MEDIA_ENGINE_INVALID,
  54     MEDIA_ENGINE_AUDIO_MODE,
  55     MEDIA_ENGINE_RENDERING_MODE,
  56     MEDIA_ENGINE_FRAME_SERVER_MODE,
  57 };
  58
  59 /* Used with create flags. */
  60 enum media_engine_flags
  61 {
  62     /* MF_MEDIA_ENGINE_CREATEFLAGS_MASK is 0x1f. */
  63     FLAGS_ENGINE_SHUT_DOWN = 0x20,
  64     FLAGS_ENGINE_AUTO_PLAY = 0x40,
  65     FLAGS_ENGINE_LOOP = 0x80,
  66     FLAGS_ENGINE_PAUSED = 0x100,
  67     FLAGS_ENGINE_WAITING = 0x200,
  68     FLAGS_ENGINE_MUTED = 0x400,
  69     FLAGS_ENGINE_HAS_AUDIO = 0x800,
  70     FLAGS_ENGINE_HAS_VIDEO = 0x1000,
  71 };
  72
  73 struct media_engine
  74 {
  75     IMFMediaEngine IMFMediaEngine_iface;
  76     IMFAsyncCallback session_events;
  77     IMFAsyncCallback load_handler;
  78     LONG refcount;
  79     IMFMediaEngineNotify *callback;
  80     IMFAttributes *attributes;
  81     enum media_engine_mode mode;
  82     unsigned int flags;
  83     double playback_rate;
  84     double default_playback_rate;
  85     double volume;
  86     double duration;
  87     MF_MEDIA_ENGINE_ERR error_code;
  88     HRESULT extended_code;
  89     IMFMediaSession *session;
  90     IMFSourceResolver *resolver;
  91     BSTR current_source;
  92     CRITICAL_SECTION cs;
  93 };
  94
  95 struct media_error
  96 {
  97     IMFMediaError IMFMediaError_iface;
  98     LONG refcount;
  99     unsigned int code;
 100     HRESULT extended_code;
 101 };
 102
 103 static struct media_error *impl_from_IMFMediaError(IMFMediaError *iface)
 104 {
 105     return CONTAINING_RECORD(iface, struct media_error, IMFMediaError_iface);
 106 }
 107
 108 static HRESULT WINAPI media_error_QueryInterface(IMFMediaError *iface, REFIID riid, void **obj)
 109 {
 110     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 111
 112     if (IsEqualIID(riid, &IID_IMFMediaError) ||
 113             IsEqualIID(riid, &IID_IUnknown))
 114     {
 115         *obj = iface;
 116         IMFMediaError_AddRef(iface);
 117         return S_OK;
 118     }
 119
 120     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 121     *obj = NULL;
 122     return E_NOINTERFACE;
 123 }
 124
 125 static ULONG WINAPI media_error_AddRef(IMFMediaError *iface)
 126 {
 127     struct media_error *me = impl_from_IMFMediaError(iface);
 128     ULONG refcount = InterlockedIncrement(&me->refcount);
 129
 130     TRACE("%p, refcount %u.\n", iface, refcount);
 131
 132     return refcount;
 133 }
 134
 135 static ULONG WINAPI media_error_Release(IMFMediaError *iface)
 136 {
 137     struct media_error *me = impl_from_IMFMediaError(iface);
 138     ULONG refcount = InterlockedDecrement(&me->refcount);
 139
 140     TRACE("%p, refcount %u.\n", iface, refcount);
 141
 142     if (!refcount)
 143         heap_free(me);
 144
 145     return refcount;
 146 }
 147
 148 static USHORT WINAPI media_error_GetErrorCode(IMFMediaError *iface)
 149 {
 150     struct media_error *me = impl_from_IMFMediaError(iface);
 151     TRACE("%p.\n", iface);
 152     return me->code;
 153 }
 154
 155 static HRESULT WINAPI media_error_GetExtendedErrorCode(IMFMediaError *iface)
 156 {
 157     struct media_error *me = impl_from_IMFMediaError(iface);
 158     TRACE("%p.\n", iface);
 159     return me->extended_code;
 160 }
 161
 162 static HRESULT WINAPI media_error_SetErrorCode(IMFMediaError *iface, MF_MEDIA_ENGINE_ERR code)
 163 {
 164     struct media_error *me = impl_from_IMFMediaError(iface);
 165
 166     TRACE("%p, %u.\n", iface, code);
 167
 168     if ((unsigned int)code > MF_MEDIA_ENGINE_ERR_ENCRYPTED)
 169         return E_INVALIDARG;
 170
 171     me->code = code;
 172
 173     return S_OK;
 174 }
 175
 176 static HRESULT WINAPI media_error_SetExtendedErrorCode(IMFMediaError *iface, HRESULT code)
 177 {
 178     struct media_error *me = impl_from_IMFMediaError(iface);
 179
 180     TRACE("%p, %#x.\n", iface, code);
 181
 182     me->extended_code = code;
 183
 184     return S_OK;
 185 }
 186
 187 static const IMFMediaErrorVtbl media_error_vtbl =
 188 {
 189     media_error_QueryInterface,
 190     media_error_AddRef,
 191     media_error_Release,
 192     media_error_GetErrorCode,
 193     media_error_GetExtendedErrorCode,
 194     media_error_SetErrorCode,
 195     media_error_SetExtendedErrorCode,
 196 };
 197
 198 static HRESULT create_media_error(IMFMediaError **ret)
 199 {
 200     struct media_error *object;
 201
 202     *ret = NULL;
 203
 204     if (!(object = heap_alloc_zero(sizeof(*object))))
 205         return E_OUTOFMEMORY;
 206
 207     object->IMFMediaError_iface.lpVtbl = &media_error_vtbl;
 208     object->refcount = 1;
 209
 210     *ret = &object->IMFMediaError_iface;
 211
 212     return S_OK;
 213 }
 214
 215 static void media_engine_set_flag(struct media_engine *engine, unsigned int mask, BOOL value)
 216 {
 217     if (value)
 218         engine->flags |= mask;
 219     else
 220         engine->flags &= ~mask;
 221 }
 222
 223 static inline struct media_engine *impl_from_IMFMediaEngine(IMFMediaEngine *iface)
 224 {
 225     return CONTAINING_RECORD(iface, struct media_engine, IMFMediaEngine_iface);
 226 }
 227
 228 static struct media_engine *impl_from_session_events_IMFAsyncCallback(IMFAsyncCallback *iface)
 229 {
 230     return CONTAINING_RECORD(iface, struct media_engine, session_events);
 231 }
 232
 233 static struct media_engine *impl_from_load_handler_IMFAsyncCallback(IMFAsyncCallback *iface)
 234 {
 235     return CONTAINING_RECORD(iface, struct media_engine, load_handler);
 236 }
 237
 238 static HRESULT WINAPI media_engine_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
 239 {
 240     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 241             IsEqualIID(riid, &IID_IUnknown))
 242     {
 243         *obj = iface;
 244         IMFAsyncCallback_AddRef(iface);
 245         return S_OK;
 246     }
 247
 248     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 249     *obj = NULL;
 250     return E_NOINTERFACE;
 251 }
 252
 253 static ULONG WINAPI media_engine_session_events_AddRef(IMFAsyncCallback *iface)
 254 {
 255     struct media_engine *engine = impl_from_session_events_IMFAsyncCallback(iface);
 256     return IMFMediaEngine_AddRef(&engine->IMFMediaEngine_iface);
 257 }
 258
 259 static ULONG WINAPI media_engine_session_events_Release(IMFAsyncCallback *iface)
 260 {
 261     struct media_engine *engine = impl_from_session_events_IMFAsyncCallback(iface);
 262     return IMFMediaEngine_Release(&engine->IMFMediaEngine_iface);
 263 }
 264
 265 static HRESULT WINAPI media_engine_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
 266 {
 267     return E_NOTIMPL;
 268 }
 269
 270 static HRESULT WINAPI media_engine_session_events_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 271 {
 272     struct media_engine *engine = impl_from_session_events_IMFAsyncCallback(iface);
 273     IMFMediaEvent *event = NULL;
 274     MediaEventType event_type;
 275     HRESULT hr;
 276
 277     if (FAILED(hr = IMFMediaSession_EndGetEvent(engine->session, result, &event)))
 278     {
 279         WARN("Failed to get session event, hr %#x.\n", hr);
 280         goto failed;
 281     }
 282
 283     if (FAILED(hr = IMFMediaEvent_GetType(event, &event_type)))
 284     {
 285         WARN("Failed to get event type, hr %#x.\n", hr);
 286         goto failed;
 287     }
 288
 289     switch (event_type)
 290     {
 291         case MEBufferingStarted:
 292         case MEBufferingStopped:
 293
 294             IMFMediaEngineNotify_EventNotify(engine->callback, event_type == MEBufferingStarted ?
 295                     MF_MEDIA_ENGINE_EVENT_BUFFERINGSTARTED : MF_MEDIA_ENGINE_EVENT_BUFFERINGENDED, 0, 0);
 296             break;
 297     }
 298
 299 failed:
 300
 301     if (event)
 302         IMFMediaEvent_Release(event);
 303
 304     if (FAILED(hr = IMFMediaSession_BeginGetEvent(engine->session, iface, NULL)))
 305         WARN("Failed to subscribe to session events, hr %#x.\n", hr);
 306
 307     return S_OK;
 308 }
 309
 310 static const IMFAsyncCallbackVtbl media_engine_session_events_vtbl =
 311 {
 312     media_engine_callback_QueryInterface,
 313     media_engine_session_events_AddRef,
 314     media_engine_session_events_Release,
 315     media_engine_callback_GetParameters,
 316     media_engine_session_events_Invoke,
 317 };
 318
 319 static ULONG WINAPI media_engine_load_handler_AddRef(IMFAsyncCallback *iface)
 320 {
 321     struct media_engine *engine = impl_from_load_handler_IMFAsyncCallback(iface);
 322     return IMFMediaEngine_AddRef(&engine->IMFMediaEngine_iface);
 323 }
 324
 325 static ULONG WINAPI media_engine_load_handler_Release(IMFAsyncCallback *iface)
 326 {
 327     struct media_engine *engine = impl_from_load_handler_IMFAsyncCallback(iface);
 328     return IMFMediaEngine_Release(&engine->IMFMediaEngine_iface);
 329 }
 330
 331 static HRESULT media_engine_create_topology(struct media_engine *engine, IMFMediaSource *source)
 332 {
 333     IMFStreamDescriptor *sd_audio = NULL, *sd_video = NULL;
 334     unsigned int stream_count = 0, i;
 335     IMFPresentationDescriptor *pd;
 336     UINT64 duration;
 337     HRESULT hr;
 338
 339     if (FAILED(hr = IMFMediaSource_CreatePresentationDescriptor(source, &pd)))
 340         return hr;
 341
 342     if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorCount(pd, &stream_count)))
 343         WARN("Failed to get stream count, hr %#x.\n", hr);
 344
 345     /* Enable first video stream and first audio stream. */
 346
 347     for (i = 0; i < stream_count; ++i)
 348     {
 349         IMFMediaTypeHandler *type_handler;
 350         IMFStreamDescriptor *sd;
 351         BOOL selected;
 352
 353         IMFPresentationDescriptor_DeselectStream(pd, i);
 354
 355         if (sd_audio && sd_video)
 356             continue;
 357
 358         IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, i, &selected, &sd);
 359
 360         if (SUCCEEDED(IMFStreamDescriptor_GetMediaTypeHandler(sd, &type_handler)))
 361         {
 362             GUID major = { 0 };
 363
 364             IMFMediaTypeHandler_GetMajorType(type_handler, &major);
 365
 366             if (IsEqualGUID(&major, &MFMediaType_Audio) && !sd_audio)
 367             {
 368                 sd_audio = sd;
 369                 IMFStreamDescriptor_AddRef(sd_audio);
 370                 IMFPresentationDescriptor_SelectStream(pd, i);
 371             }
 372             else if (IsEqualGUID(&major, &MFMediaType_Video) && !sd_video && !(engine->flags & MF_MEDIA_ENGINE_AUDIOONLY))
 373             {
 374                 sd_video = sd;
 375                 IMFStreamDescriptor_AddRef(sd_video);
 376                 IMFPresentationDescriptor_SelectStream(pd, i);
 377             }
 378
 379             IMFMediaTypeHandler_Release(type_handler);
 380         }
 381     }
 382
 383     if (!sd_video && !sd_audio)
 384     {
 385         IMFPresentationDescriptor_Release(pd);
 386         return E_UNEXPECTED;
 387     }
 388
 389     if (sd_video)
 390         engine->flags |= FLAGS_ENGINE_HAS_VIDEO;
 391     if (sd_audio)
 392         engine->flags |= FLAGS_ENGINE_HAS_AUDIO;
 393
 394     /* Assume live source if duration was not provided. */
 395     if (SUCCEEDED(IMFPresentationDescriptor_GetUINT64(pd, &MF_PD_DURATION, &duration)))
 396     {
 397         /* Convert 100ns to seconds. */
 398         engine->duration = duration / 10000000;
 399     }
 400     else
 401         engine->duration = INFINITY;
 402
 403     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_DURATIONCHANGE, 0, 0);
 404     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_LOADEDMETADATA, 0, 0);
 405     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_LOADEDDATA, 0, 0);
 406
 407     /* TODO: set up topology nodes */
 408
 409     if (sd_video)
 410         IMFStreamDescriptor_Release(sd_video);
 411     if (sd_audio)
 412         IMFStreamDescriptor_Release(sd_audio);
 413
 414     IMFPresentationDescriptor_Release(pd);
 415
 416     return S_OK;
 417 }
 418
 419 static HRESULT WINAPI media_engine_load_handler_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 420 {
 421     struct media_engine *engine = impl_from_load_handler_IMFAsyncCallback(iface);
 422     MF_OBJECT_TYPE obj_type;
 423     IMFMediaSource *source;
 424     IUnknown *object = NULL;
 425     HRESULT hr;
 426
 427     EnterCriticalSection(&engine->cs);
 428
 429     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_LOADSTART, 0, 0);
 430
 431     if (FAILED(hr = IMFSourceResolver_EndCreateObjectFromURL(engine->resolver, result, &obj_type, &object)))
 432         WARN("Failed to create source object, hr %#x.\n", hr);
 433
 434     if (object)
 435     {
 436         if (SUCCEEDED(hr = IUnknown_QueryInterface(object, &IID_IMFMediaSource, (void **)&source)))
 437         {
 438             hr = media_engine_create_topology(engine, source);
 439             IMFMediaSource_Release(source);
 440         }
 441         IUnknown_Release(object);
 442     }
 443
 444     if (FAILED(hr))
 445     {
 446         engine->error_code = MF_MEDIA_ENGINE_ERR_SRC_NOT_SUPPORTED;
 447         engine->extended_code = hr;
 448         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_ERROR, engine->error_code,
 449                 engine->extended_code);
 450     }
 451
 452     LeaveCriticalSection(&engine->cs);
 453
 454     return S_OK;
 455 }
 456
 457 static const IMFAsyncCallbackVtbl media_engine_load_handler_vtbl =
 458 {
 459     media_engine_callback_QueryInterface,
 460     media_engine_load_handler_AddRef,
 461     media_engine_load_handler_Release,
 462     media_engine_callback_GetParameters,
 463     media_engine_load_handler_Invoke,
 464 };
 465
 466 static HRESULT WINAPI media_engine_QueryInterface(IMFMediaEngine *iface, REFIID riid, void **obj)
 467 {
 468     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(riid), obj);
 469
 470     if (IsEqualIID(riid, &IID_IMFMediaEngine) ||
 471         IsEqualIID(riid, &IID_IUnknown))
 472     {
 473         *obj = iface;
 474         IMFMediaEngine_AddRef(iface);
 475         return S_OK;
 476     }
 477
 478     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 479     *obj = NULL;
 480     return E_NOINTERFACE;
 481 }
 482
 483 static ULONG WINAPI media_engine_AddRef(IMFMediaEngine *iface)
 484 {
 485     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 486     ULONG refcount = InterlockedIncrement(&engine->refcount);
 487
 488     TRACE("(%p) ref=%u.\n", iface, refcount);
 489
 490     return refcount;
 491 }
 492
 493 static void free_media_engine(struct media_engine *engine)
 494 {
 495     if (engine->callback)
 496         IMFMediaEngineNotify_Release(engine->callback);
 497     if (engine->session)
 498         IMFMediaSession_Release(engine->session);
 499     if (engine->attributes)
 500         IMFAttributes_Release(engine->attributes);
 501     if (engine->resolver)
 502         IMFSourceResolver_Release(engine->resolver);
 503     SysFreeString(engine->current_source);
 504     DeleteCriticalSection(&engine->cs);
 505     heap_free(engine);
 506 }
 507
 508 static ULONG WINAPI media_engine_Release(IMFMediaEngine *iface)
 509 {
 510     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 511     ULONG refcount = InterlockedDecrement(&engine->refcount);
 512
 513     TRACE("(%p) ref=%u.\n", iface, refcount);
 514
 515     if (!refcount)
 516         free_media_engine(engine);
 517
 518     return refcount;
 519 }
 520
 521 static HRESULT WINAPI media_engine_GetError(IMFMediaEngine *iface, IMFMediaError **error)
 522 {
 523     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 524     HRESULT hr = S_OK;
 525
 526     TRACE("%p, %p.\n", iface, error);
 527
 528     *error = NULL;
 529
 530     EnterCriticalSection(&engine->cs);
 531     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
 532         hr = MF_E_SHUTDOWN;
 533     else if (engine->error_code)
 534     {
 535         if (SUCCEEDED(hr = create_media_error(error)))
 536         {
 537             IMFMediaError_SetErrorCode(*error, engine->error_code);
 538             IMFMediaError_SetExtendedErrorCode(*error, engine->extended_code);
 539         }
 540     }
 541     LeaveCriticalSection(&engine->cs);
 542
 543     return hr;
 544 }
 545
 546 static HRESULT WINAPI media_engine_SetErrorCode(IMFMediaEngine *iface, MF_MEDIA_ENGINE_ERR code)
 547 {
 548     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 549     HRESULT hr = S_OK;
 550
 551     TRACE("%p, %u.\n", iface, code);
 552
 553     if ((unsigned int)code > MF_MEDIA_ENGINE_ERR_ENCRYPTED)
 554         return E_INVALIDARG;
 555
 556     EnterCriticalSection(&engine->cs);
 557     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
 558         hr = MF_E_SHUTDOWN;
 559     else
 560         engine->error_code = code;
 561     LeaveCriticalSection(&engine->cs);
 562
 563     return hr;
 564 }
 565
 566 static HRESULT WINAPI media_engine_SetSourceElements(IMFMediaEngine *iface, IMFMediaEngineSrcElements *elements)
 567 {
 568     FIXME("(%p, %p): stub.\n", iface, elements);
 569
 570     return E_NOTIMPL;
 571 }
 572
 573 static HRESULT WINAPI media_engine_SetSource(IMFMediaEngine *iface, BSTR url)
 574 {
 575     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 576     HRESULT hr = S_OK;
 577
 578     TRACE("%p, %s.\n", iface, debugstr_w(url));
 579
 580     EnterCriticalSection(&engine->cs);
 581
 582     SysFreeString(engine->current_source);
 583     engine->current_source = NULL;
 584     if (url)
 585         engine->current_source = SysAllocString(url);
 586
 587     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PURGEQUEUEDEVENTS, 0, 0);
 588
 589     if (url)
 590     {
 591         IPropertyStore *props = NULL;
 592         unsigned int flags;
 593
 594         flags = MF_RESOLUTION_MEDIASOURCE;
 595         if (engine->flags & MF_MEDIA_ENGINE_DISABLE_LOCAL_PLUGINS)
 596             flags |= MF_RESOLUTION_DISABLE_LOCAL_PLUGINS;
 597
 598         IMFAttributes_GetUnknown(engine->attributes, &MF_MEDIA_ENGINE_SOURCE_RESOLVER_CONFIG_STORE,
 599                 &IID_IPropertyStore, (void **)&props);
 600         hr = IMFSourceResolver_BeginCreateObjectFromURL(engine->resolver, url, flags, props, NULL, &engine->load_handler, NULL);
 601         if (props)
 602             IPropertyStore_Release(props);
 603     }
 604
 605     LeaveCriticalSection(&engine->cs);
 606
 607     return hr;
 608 }
 609
 610 static HRESULT WINAPI media_engine_GetCurrentSource(IMFMediaEngine *iface, BSTR *url)
 611 {
 612     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 613     HRESULT hr = S_OK;
 614
 615     TRACE("%p, %p.\n", iface, url);
 616
 617     *url = NULL;
 618
 619     EnterCriticalSection(&engine->cs);
 620     if (engine->current_source)
 621     {
 622         if (!(*url = SysAllocString(engine->current_source)))
 623             hr = E_OUTOFMEMORY;
 624     }
 625     LeaveCriticalSection(&engine->cs);
 626
 627     return hr;
 628 }
 629
 630 static USHORT WINAPI media_engine_GetNetworkState(IMFMediaEngine *iface)
 631 {
 632     FIXME("(%p): stub.\n", iface);
 633
 634     return 0;
 635 }
 636
 637 static MF_MEDIA_ENGINE_PRELOAD WINAPI media_engine_GetPreload(IMFMediaEngine *iface)
 638 {
 639     FIXME("(%p): stub.\n", iface);
 640
 641     return MF_MEDIA_ENGINE_PRELOAD_NONE;
 642 }
 643
 644 static HRESULT WINAPI media_engine_SetPreload(IMFMediaEngine *iface, MF_MEDIA_ENGINE_PRELOAD preload)
 645 {
 646     FIXME("(%p, %d): stub.\n", iface, preload);
 647
 648     return E_NOTIMPL;
 649 }
 650
 651 static HRESULT WINAPI media_engine_GetBuffered(IMFMediaEngine *iface, IMFMediaTimeRange **buffered)
 652 {
 653     FIXME("(%p, %p): stub.\n", iface, buffered);
 654
 655     return E_NOTIMPL;
 656 }
 657
 658 static HRESULT WINAPI media_engine_Load(IMFMediaEngine *iface)
 659 {
 660     FIXME("(%p): stub.\n", iface);
 661
 662     return E_NOTIMPL;
 663 }
 664
 665 static HRESULT WINAPI media_engine_CanPlayType(IMFMediaEngine *iface, BSTR type, MF_MEDIA_ENGINE_CANPLAY *answer)
 666 {
 667     FIXME("(%p, %s, %p): stub.\n", iface, debugstr_w(type), answer);
 668
 669     return E_NOTIMPL;
 670 }
 671
 672 static USHORT WINAPI media_engine_GetReadyState(IMFMediaEngine *iface)
 673 {
 674     FIXME("(%p): stub.\n", iface);
 675
 676     return 0;
 677 }
 678
 679 static BOOL WINAPI media_engine_IsSeeking(IMFMediaEngine *iface)
 680 {
 681     FIXME("(%p): stub.\n", iface);
 682
 683     return FALSE;
 684 }
 685
 686 static double WINAPI media_engine_GetCurrentTime(IMFMediaEngine *iface)
 687 {
 688     FIXME("(%p): stub.\n", iface);
 689
 690     return 0.0;
 691 }
 692
 693 static HRESULT WINAPI media_engine_SetCurrentTime(IMFMediaEngine *iface, double time)
 694 {
 695     FIXME("(%p, %f): stub.\n", iface, time);
 696
 697     return E_NOTIMPL;
 698 }
 699
 700 static double WINAPI media_engine_GetStartTime(IMFMediaEngine *iface)
 701 {
 702     FIXME("(%p): stub.\n", iface);
 703
 704     return 0.0;
 705 }
 706
 707 static double WINAPI media_engine_GetDuration(IMFMediaEngine *iface)
 708 {
 709     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 710     double value;
 711
 712     TRACE("%p.\n", iface);
 713
 714     EnterCriticalSection(&engine->cs);
 715     value = engine->duration;
 716     LeaveCriticalSection(&engine->cs);
 717
 718     return value;
 719 }
 720
 721 static BOOL WINAPI media_engine_IsPaused(IMFMediaEngine *iface)
 722 {
 723     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 724     BOOL value;
 725
 726     TRACE("%p.\n", iface);
 727
 728     EnterCriticalSection(&engine->cs);
 729     value = !!(engine->flags & FLAGS_ENGINE_PAUSED);
 730     LeaveCriticalSection(&engine->cs);
 731
 732     return value;
 733 }
 734
 735 static double WINAPI media_engine_GetDefaultPlaybackRate(IMFMediaEngine *iface)
 736 {
 737     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 738     double rate;
 739
 740     TRACE("%p.\n", iface);
 741
 742     EnterCriticalSection(&engine->cs);
 743     rate = engine->default_playback_rate;
 744     LeaveCriticalSection(&engine->cs);
 745
 746     return rate;
 747 }
 748
 749 static HRESULT WINAPI media_engine_SetDefaultPlaybackRate(IMFMediaEngine *iface, double rate)
 750 {
 751     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 752     HRESULT hr = S_OK;
 753
 754     TRACE("%p, %f.\n", iface, rate);
 755
 756     EnterCriticalSection(&engine->cs);
 757     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
 758         hr = MF_E_SHUTDOWN;
 759     else if (engine->default_playback_rate != rate)
 760     {
 761         engine->default_playback_rate = rate;
 762         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_RATECHANGE, 0, 0);
 763     }
 764     LeaveCriticalSection(&engine->cs);
 765
 766     return hr;
 767 }
 768
 769 static double WINAPI media_engine_GetPlaybackRate(IMFMediaEngine *iface)
 770 {
 771     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 772     double rate;
 773
 774     TRACE("%p.\n", iface);
 775
 776     EnterCriticalSection(&engine->cs);
 777     rate = engine->playback_rate;
 778     LeaveCriticalSection(&engine->cs);
 779
 780     return rate;
 781 }
 782
 783 static HRESULT WINAPI media_engine_SetPlaybackRate(IMFMediaEngine *iface, double rate)
 784 {
 785     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 786     HRESULT hr = S_OK;
 787
 788     TRACE("%p, %f.\n", iface, rate);
 789
 790     EnterCriticalSection(&engine->cs);
 791     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
 792         hr = MF_E_SHUTDOWN;
 793     else if (engine->playback_rate != rate)
 794     {
 795         engine->playback_rate = rate;
 796         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_RATECHANGE, 0, 0);
 797     }
 798     LeaveCriticalSection(&engine->cs);
 799
 800     return hr;
 801 }
 802
 803 static HRESULT WINAPI media_engine_GetPlayed(IMFMediaEngine *iface, IMFMediaTimeRange **played)
 804 {
 805     FIXME("(%p, %p): stub.\n", iface, played);
 806
 807     return E_NOTIMPL;
 808 }
 809
 810 static HRESULT WINAPI media_engine_GetSeekable(IMFMediaEngine *iface, IMFMediaTimeRange **seekable)
 811 {
 812     FIXME("(%p, %p): stub.\n", iface, seekable);
 813
 814     return E_NOTIMPL;
 815 }
 816
 817 static BOOL WINAPI media_engine_IsEnded(IMFMediaEngine *iface)
 818 {
 819     FIXME("(%p): stub.\n", iface);
 820
 821     return FALSE;
 822 }
 823
 824 static BOOL WINAPI media_engine_GetAutoPlay(IMFMediaEngine *iface)
 825 {
 826     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 827     BOOL value;
 828
 829     TRACE("%p.\n", iface);
 830
 831     EnterCriticalSection(&engine->cs);
 832     value = !!(engine->flags & FLAGS_ENGINE_AUTO_PLAY);
 833     LeaveCriticalSection(&engine->cs);
 834
 835     return value;
 836 }
 837
 838 static HRESULT WINAPI media_engine_SetAutoPlay(IMFMediaEngine *iface, BOOL autoplay)
 839 {
 840     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 841
 842     FIXME("(%p, %d): stub.\n", iface, autoplay);
 843
 844     EnterCriticalSection(&engine->cs);
 845     media_engine_set_flag(engine, FLAGS_ENGINE_AUTO_PLAY, autoplay);
 846     LeaveCriticalSection(&engine->cs);
 847
 848     return S_OK;
 849 }
 850
 851 static BOOL WINAPI media_engine_GetLoop(IMFMediaEngine *iface)
 852 {
 853     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 854     BOOL value;
 855
 856     TRACE("%p.\n", iface);
 857
 858     EnterCriticalSection(&engine->cs);
 859     value = !!(engine->flags & FLAGS_ENGINE_LOOP);
 860     LeaveCriticalSection(&engine->cs);
 861
 862     return value;
 863 }
 864
 865 static HRESULT WINAPI media_engine_SetLoop(IMFMediaEngine *iface, BOOL loop)
 866 {
 867     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 868
 869     FIXME("(%p, %d): stub.\n", iface, loop);
 870
 871     EnterCriticalSection(&engine->cs);
 872     media_engine_set_flag(engine, FLAGS_ENGINE_LOOP, loop);
 873     LeaveCriticalSection(&engine->cs);
 874
 875     return S_OK;
 876 }
 877
 878 static HRESULT WINAPI media_engine_Play(IMFMediaEngine *iface)
 879 {
 880     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 881     PROPVARIANT var;
 882
 883     TRACE("%p.\n", iface);
 884
 885     EnterCriticalSection(&engine->cs);
 886
 887     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PURGEQUEUEDEVENTS, 0, 0);
 888
 889     if (!(engine->flags & FLAGS_ENGINE_WAITING))
 890     {
 891         engine->flags &= ~FLAGS_ENGINE_PAUSED;
 892         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PLAY, 0, 0);
 893
 894         var.vt = VT_EMPTY;
 895         IMFMediaSession_Start(engine->session, &GUID_NULL, &var);
 896
 897         engine->flags |= FLAGS_ENGINE_WAITING;
 898     }
 899
 900     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_WAITING, 0, 0);
 901
 902     LeaveCriticalSection(&engine->cs);
 903
 904     return S_OK;
 905 }
 906
 907 static HRESULT WINAPI media_engine_Pause(IMFMediaEngine *iface)
 908 {
 909     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 910
 911     TRACE("%p.\n", iface);
 912
 913     EnterCriticalSection(&engine->cs);
 914
 915     if (!(engine->flags & FLAGS_ENGINE_PAUSED))
 916     {
 917         engine->flags &= ~FLAGS_ENGINE_WAITING;
 918         engine->flags |= FLAGS_ENGINE_PAUSED;
 919
 920         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_TIMEUPDATE, 0, 0);
 921         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PAUSE, 0, 0);
 922     }
 923
 924     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PURGEQUEUEDEVENTS, 0, 0);
 925
 926     LeaveCriticalSection(&engine->cs);
 927
 928     return S_OK;
 929 }
 930
 931 static BOOL WINAPI media_engine_GetMuted(IMFMediaEngine *iface)
 932 {
 933     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 934     BOOL ret;
 935
 936     TRACE("%p.\n", iface);
 937
 938     EnterCriticalSection(&engine->cs);
 939     ret = !!(engine->flags & FLAGS_ENGINE_MUTED);
 940     LeaveCriticalSection(&engine->cs);
 941
 942     return ret;
 943 }
 944
 945 static HRESULT WINAPI media_engine_SetMuted(IMFMediaEngine *iface, BOOL muted)
 946 {
 947     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 948     HRESULT hr = S_OK;
 949
 950     TRACE("%p, %d.\n", iface, muted);
 951
 952     EnterCriticalSection(&engine->cs);
 953     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
 954         hr = MF_E_SHUTDOWN;
 955     else if (!!(engine->flags & FLAGS_ENGINE_MUTED) ^ !!muted)
 956     {
 957         media_engine_set_flag(engine, FLAGS_ENGINE_MUTED, muted);
 958         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_VOLUMECHANGE, 0, 0);
 959     }
 960     LeaveCriticalSection(&engine->cs);
 961
 962     return hr;
 963 }
 964
 965 static double WINAPI media_engine_GetVolume(IMFMediaEngine *iface)
 966 {
 967     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 968     double volume;
 969
 970     TRACE("%p.\n", iface);
 971
 972     EnterCriticalSection(&engine->cs);
 973     volume = engine->volume;
 974     LeaveCriticalSection(&engine->cs);
 975
 976     return volume;
 977 }
 978
 979 static HRESULT WINAPI media_engine_SetVolume(IMFMediaEngine *iface, double volume)
 980 {
 981     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
 982     HRESULT hr = S_OK;
 983
 984     TRACE("%p, %f.\n", iface, volume);
 985
 986     EnterCriticalSection(&engine->cs);
 987     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
 988         hr = MF_E_SHUTDOWN;
 989     else if (volume != engine->volume)
 990     {
 991         engine->volume = volume;
 992         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_VOLUMECHANGE, 0, 0);
 993     }
 994     LeaveCriticalSection(&engine->cs);
 995
 996     return hr;
 997 }
 998
 999 static BOOL WINAPI media_engine_HasVideo(IMFMediaEngine *iface)
1000 {
1001     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
1002     BOOL value;
1003
1004     TRACE("%p.\n", iface);
1005
1006     EnterCriticalSection(&engine->cs);
1007     value = !!(engine->flags & FLAGS_ENGINE_HAS_VIDEO);
1008     LeaveCriticalSection(&engine->cs);
1009
1010     return value;
1011 }
1012
1013 static BOOL WINAPI media_engine_HasAudio(IMFMediaEngine *iface)
1014 {
1015     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
1016     BOOL value;
1017
1018     TRACE("%p.\n", iface);
1019
1020     EnterCriticalSection(&engine->cs);
1021     value = !!(engine->flags & FLAGS_ENGINE_HAS_AUDIO);
1022     LeaveCriticalSection(&engine->cs);
1023
1024     return value;
1025 }
1026
1027 static HRESULT WINAPI media_engine_GetNativeVideoSize(IMFMediaEngine *iface, DWORD *cx, DWORD *cy)
1028 {
1029     FIXME("(%p, %p, %p): stub.\n", iface, cx, cy);
1030
1031     return E_NOTIMPL;
1032 }
1033
1034 static HRESULT WINAPI media_engine_GetVideoAspectRatio(IMFMediaEngine *iface, DWORD *cx, DWORD *cy)
1035 {
1036     FIXME("(%p, %p, %p): stub.\n", iface, cx, cy);
1037
1038     return E_NOTIMPL;
1039 }
1040
1041 static HRESULT WINAPI media_engine_Shutdown(IMFMediaEngine *iface)
1042 {
1043     struct media_engine *engine = impl_from_IMFMediaEngine(iface);
1044     HRESULT hr = S_OK;
1045
1046     FIXME("(%p): stub.\n", iface);
1047
1048     EnterCriticalSection(&engine->cs);
1049     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1050         hr = MF_E_SHUTDOWN;
1051     else
1052     {
1053         engine->flags |= FLAGS_ENGINE_SHUT_DOWN;
1054         IMFMediaSession_Shutdown(engine->session);
1055     }
1056     LeaveCriticalSection(&engine->cs);
1057
1058     return hr;
1059 }
1060
1061 static HRESULT WINAPI media_engine_TransferVideoFrame(IMFMediaEngine *iface, IUnknown *surface,
1062                                                       const MFVideoNormalizedRect *src,
1063                                                       const RECT *dst, const MFARGB *color)
1064 {
1065     FIXME("(%p, %p, %p, %p, %p): stub.\n", iface, surface, src, dst, color);
1066
1067     return E_NOTIMPL;
1068 }
1069
1070 static HRESULT WINAPI media_engine_OnVideoStreamTick(IMFMediaEngine *iface, LONGLONG *time)
1071 {
1072     FIXME("(%p, %p): stub.\n", iface, time);
1073
1074     return E_NOTIMPL;
1075 }
1076
1077 static const IMFMediaEngineVtbl media_engine_vtbl =
1078 {
1079     media_engine_QueryInterface,
1080     media_engine_AddRef,
1081     media_engine_Release,
1082     media_engine_GetError,
1083     media_engine_SetErrorCode,
1084     media_engine_SetSourceElements,
1085     media_engine_SetSource,
1086     media_engine_GetCurrentSource,
1087     media_engine_GetNetworkState,
1088     media_engine_GetPreload,
1089     media_engine_SetPreload,
1090     media_engine_GetBuffered,
1091     media_engine_Load,
1092     media_engine_CanPlayType,
1093     media_engine_GetReadyState,
1094     media_engine_IsSeeking,
1095     media_engine_GetCurrentTime,
1096     media_engine_SetCurrentTime,
1097     media_engine_GetStartTime,
1098     media_engine_GetDuration,
1099     media_engine_IsPaused,
1100     media_engine_GetDefaultPlaybackRate,
1101     media_engine_SetDefaultPlaybackRate,
1102     media_engine_GetPlaybackRate,
1103     media_engine_SetPlaybackRate,
1104     media_engine_GetPlayed,
1105     media_engine_GetSeekable,
1106     media_engine_IsEnded,
1107     media_engine_GetAutoPlay,
1108     media_engine_SetAutoPlay,
1109     media_engine_GetLoop,
1110     media_engine_SetLoop,
1111     media_engine_Play,
1112     media_engine_Pause,
1113     media_engine_GetMuted,
1114     media_engine_SetMuted,
1115     media_engine_GetVolume,
1116     media_engine_SetVolume,
1117     media_engine_HasVideo,
1118     media_engine_HasAudio,
1119     media_engine_GetNativeVideoSize,
1120     media_engine_GetVideoAspectRatio,
1121     media_engine_Shutdown,
1122     media_engine_TransferVideoFrame,
1123     media_engine_OnVideoStreamTick,
1124 };
1125
1126 static HRESULT WINAPI media_engine_factory_QueryInterface(IMFMediaEngineClassFactory *iface, REFIID riid, void **obj)
1127 {
1128     if (IsEqualIID(riid, &IID_IMFMediaEngineClassFactory) ||
1129         IsEqualIID(riid, &IID_IUnknown))
1130     {
1131         *obj = iface;
1132         IMFMediaEngineClassFactory_AddRef(iface);
1133         return S_OK;
1134     }
1135
1136     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1137     *obj = NULL;
1138     return E_NOINTERFACE;
1139 }
1140
1141 static ULONG WINAPI media_engine_factory_AddRef(IMFMediaEngineClassFactory *iface)
1142 {
1143     return 2;
1144 }
1145
1146 static ULONG WINAPI media_engine_factory_Release(IMFMediaEngineClassFactory *iface)
1147 {
1148     return 1;
1149 }
1150
1151 static HRESULT init_media_engine(DWORD flags, IMFAttributes *attributes, struct media_engine *engine)
1152 {
1153     DXGI_FORMAT output_format;
1154     UINT64 playback_hwnd;
1155     HRESULT hr;
1156
1157     engine->IMFMediaEngine_iface.lpVtbl = &media_engine_vtbl;
1158     engine->session_events.lpVtbl = &media_engine_session_events_vtbl;
1159     engine->load_handler.lpVtbl = &media_engine_load_handler_vtbl;
1160     engine->refcount = 1;
1161     engine->flags = (flags & MF_MEDIA_ENGINE_CREATEFLAGS_MASK) | FLAGS_ENGINE_PAUSED;
1162     engine->default_playback_rate = 1.0;
1163     engine->playback_rate = 1.0;
1164     engine->volume = 1.0;
1165     engine->duration = NAN;
1166     InitializeCriticalSection(&engine->cs);
1167
1168     hr = IMFAttributes_GetUnknown(attributes, &MF_MEDIA_ENGINE_CALLBACK, &IID_IMFMediaEngineNotify,
1169             (void **)&engine->callback);
1170     if (FAILED(hr))
1171         return hr;
1172
1173     if (FAILED(hr = MFCreateMediaSession(NULL, &engine->session)))
1174         return hr;
1175
1176     if (FAILED(hr = IMFMediaSession_BeginGetEvent(engine->session, &engine->session_events, NULL)))
1177         return hr;
1178
1179     if (FAILED(hr = MFCreateSourceResolver(&engine->resolver)))
1180         return hr;
1181
1182     if (FAILED(hr = MFCreateAttributes(&engine->attributes, 0)))
1183         return hr;
1184
1185     if (FAILED(hr = IMFAttributes_CopyAllItems(attributes, engine->attributes)))
1186         return hr;
1187
1188     IMFAttributes_GetUINT64(attributes, &MF_MEDIA_ENGINE_PLAYBACK_HWND, &playback_hwnd);
1189     hr = IMFAttributes_GetUINT32(attributes, &MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT, &output_format);
1190     if (playback_hwnd) /* FIXME: handle MF_MEDIA_ENGINE_PLAYBACK_VISUAL */
1191         engine->mode = MEDIA_ENGINE_RENDERING_MODE;
1192     else
1193     {
1194         if (SUCCEEDED(hr))
1195             engine->mode = MEDIA_ENGINE_FRAME_SERVER_MODE;
1196         else
1197             engine->mode = MEDIA_ENGINE_AUDIO_MODE;
1198     }
1199
1200     return S_OK;
1201 }
1202
1203 static HRESULT WINAPI media_engine_factory_CreateInstance(IMFMediaEngineClassFactory *iface, DWORD flags,
1204                                                           IMFAttributes *attributes, IMFMediaEngine **engine)
1205 {
1206     struct media_engine *object;
1207     HRESULT hr;
1208
1209     TRACE("%p, %#x, %p, %p.\n", iface, flags, attributes, engine);
1210
1211     if (!attributes || !engine)
1212         return E_POINTER;
1213
1214     object = heap_alloc_zero(sizeof(*object));
1215     if (!object)
1216         return E_OUTOFMEMORY;
1217
1218     hr = init_media_engine(flags, attributes, object);
1219     if (FAILED(hr))
1220     {
1221         free_media_engine(object);
1222         return hr;
1223     }
1224
1225     *engine = &object->IMFMediaEngine_iface;
1226
1227     return S_OK;
1228 }
1229
1230 static HRESULT WINAPI media_engine_factory_CreateTimeRange(IMFMediaEngineClassFactory *iface,
1231                                                            IMFMediaTimeRange **range)
1232 {
1233     FIXME("(%p, %p): stub.\n", iface, range);
1234
1235     return E_NOTIMPL;
1236 }
1237
1238 static HRESULT WINAPI media_engine_factory_CreateError(IMFMediaEngineClassFactory *iface, IMFMediaError **error)
1239 {
1240     TRACE("%p, %p.\n", iface, error);
1241
1242     return create_media_error(error);
1243 }
1244
1245 static const IMFMediaEngineClassFactoryVtbl media_engine_factory_vtbl =
1246 {
1247     media_engine_factory_QueryInterface,
1248     media_engine_factory_AddRef,
1249     media_engine_factory_Release,
1250     media_engine_factory_CreateInstance,
1251     media_engine_factory_CreateTimeRange,
1252     media_engine_factory_CreateError,
1253 };
1254
1255 static IMFMediaEngineClassFactory media_engine_factory = { &media_engine_factory_vtbl };
1256
1257 static HRESULT WINAPI classfactory_QueryInterface(IClassFactory *iface, REFIID riid, void **obj)
1258 {
1259     TRACE("(%s, %p).\n", debugstr_guid(riid), obj);
1260
1261     if (IsEqualGUID(riid, &IID_IClassFactory) ||
1262         IsEqualGUID(riid, &IID_IUnknown))
1263     {
1264         IClassFactory_AddRef(iface);
1265         *obj = iface;
1266         return S_OK;
1267     }
1268
1269     WARN("interface %s not implemented.\n", debugstr_guid(riid));
1270     *obj = NULL;
1271     return E_NOINTERFACE;
1272 }
1273
1274 static ULONG WINAPI classfactory_AddRef(IClassFactory *iface)
1275 {
1276     return 2;
1277 }
1278
1279 static ULONG WINAPI classfactory_Release(IClassFactory *iface)
1280 {
1281     return 1;
1282 }
1283
1284 static HRESULT WINAPI classfactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
1285 {
1286     TRACE("(%p, %s, %p).\n", outer, debugstr_guid(riid), obj);
1287
1288     *obj = NULL;
1289
1290     if (outer)
1291         return CLASS_E_NOAGGREGATION;
1292
1293     return IMFMediaEngineClassFactory_QueryInterface(&media_engine_factory, riid, obj);
1294 }
1295
1296 static HRESULT WINAPI classfactory_LockServer(IClassFactory *iface, BOOL dolock)
1297 {
1298     FIXME("(%d): stub.\n", dolock);
1299     return S_OK;
1300 }
1301
1302 static const struct IClassFactoryVtbl class_factory_vtbl =
1303 {
1304     classfactory_QueryInterface,
1305     classfactory_AddRef,
1306     classfactory_Release,
1307     classfactory_CreateInstance,
1308     classfactory_LockServer,
1309 };
1310
1311 static IClassFactory classfactory = { &class_factory_vtbl };
1312
1313 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, void **obj)
1314 {
1315     TRACE("(%s, %s, %p).\n", debugstr_guid(clsid), debugstr_guid(riid), obj);
1316
1317     if (IsEqualGUID(clsid, &CLSID_MFMediaEngineClassFactory))
1318         return IClassFactory_QueryInterface(&classfactory, riid, obj);
1319
1320     WARN("Unsupported class %s.\n", debugstr_guid(clsid));
1321     *obj = NULL;
1322     return CLASS_E_CLASSNOTAVAILABLE;
1323 }
1324
1325 HRESULT WINAPI DllCanUnloadNow(void)
1326 {
1327     return S_FALSE;
1328 }