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 #include "d3d11.h"
  32 #include "mmdeviceapi.h"
  33 #include "audiosessiontypes.h"
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  38
  39 static BOOL mf_array_reserve(void **elements, size_t *capacity, size_t count, size_t size)
  40 {
  41     size_t new_capacity, max_capacity;
  42     void *new_elements;
  43
  44     if (count <= *capacity)
  45         return TRUE;
  46
  47     max_capacity = ~(SIZE_T)0 / size;
  48     if (count > max_capacity)
  49         return FALSE;
  50
  51     new_capacity = max(4, *capacity);
  52     while (new_capacity < count && new_capacity <= max_capacity / 2)
  53         new_capacity *= 2;
  54     if (new_capacity < count)
  55         new_capacity = max_capacity;
  56
  57     if (!(new_elements = realloc(*elements, new_capacity * size)))
  58         return FALSE;
  59
  60     *elements = new_elements;
  61     *capacity = new_capacity;
  62
  63     return TRUE;
  64 }
  65
  66 enum media_engine_mode
  67 {
  68     MEDIA_ENGINE_INVALID,
  69     MEDIA_ENGINE_AUDIO_MODE,
  70     MEDIA_ENGINE_RENDERING_MODE,
  71     MEDIA_ENGINE_FRAME_SERVER_MODE,
  72 };
  73
  74 /* Used with create flags. */
  75 enum media_engine_flags
  76 {
  77     /* MF_MEDIA_ENGINE_CREATEFLAGS_MASK is 0x1f. */
  78     FLAGS_ENGINE_SHUT_DOWN = 0x20,
  79     FLAGS_ENGINE_AUTO_PLAY = 0x40,
  80     FLAGS_ENGINE_LOOP = 0x80,
  81     FLAGS_ENGINE_PAUSED = 0x100,
  82     FLAGS_ENGINE_WAITING = 0x200,
  83     FLAGS_ENGINE_MUTED = 0x400,
  84     FLAGS_ENGINE_HAS_AUDIO = 0x800,
  85     FLAGS_ENGINE_HAS_VIDEO = 0x1000,
  86     FLAGS_ENGINE_FIRST_FRAME = 0x2000,
  87     FLAGS_ENGINE_IS_ENDED = 0x4000,
  88     FLAGS_ENGINE_NEW_FRAME = 0x8000,
  89     FLAGS_ENGINE_SOURCE_PENDING = 0x10000,
  90     FLAGS_ENGINE_PLAY_PENDING = 0x20000,
  91 };
  92
  93 struct vec3
  94 {
  95     float x, y, z;
  96 };
  97
  98 struct color
  99 {
 100     float r, g, b, a;
 101 };
 102
 103 static const struct vec3 fullquad[] =
 104 {
 105     {-1.0f, -1.0f, 0.0f},
 106     {-1.0f,  1.0f, 0.0f},
 107     { 1.0f, -1.0f, 0.0f},
 108     { 1.0f,  1.0f, 0.0f},
 109 };
 110
 111 struct rect
 112 {
 113     float left, top, right, bottom;
 114 };
 115
 116 struct media_engine
 117 {
 118     IMFMediaEngineEx IMFMediaEngineEx_iface;
 119     IMFGetService IMFGetService_iface;
 120     IMFAsyncCallback session_events;
 121     IMFAsyncCallback load_handler;
 122     IMFSampleGrabberSinkCallback grabber_callback;
 123     LONG refcount;
 124     IMFMediaEngineNotify *callback;
 125     IMFAttributes *attributes;
 126     IMFDXGIDeviceManager *device_manager;
 127     HANDLE device_handle;
 128     enum media_engine_mode mode;
 129     unsigned int flags;
 130     double playback_rate;
 131     double default_playback_rate;
 132     double volume;
 133     double duration;
 134     MF_MEDIA_ENGINE_NETWORK network_state;
 135     MF_MEDIA_ENGINE_ERR error_code;
 136     HRESULT extended_code;
 137     MF_MEDIA_ENGINE_READY ready_state;
 138     MF_MEDIA_ENGINE_PRELOAD preload;
 139     IMFMediaSession *session;
 140     IMFPresentationClock *clock;
 141     IMFSourceResolver *resolver;
 142     BSTR current_source;
 143     struct
 144     {
 145         IMFMediaSource *source;
 146         IMFPresentationDescriptor *pd;
 147     } presentation;
 148     struct
 149     {
 150         LONGLONG pts;
 151         SIZE size;
 152         SIZE ratio;
 153         TOPOID node_id;
 154         BYTE *buffer;
 155         UINT buffer_size;
 156         DXGI_FORMAT output_format;
 157
 158         struct
 159         {
 160             ID3D11Buffer *vb;
 161             ID3D11Buffer *ps_cb;
 162             ID3D11Texture2D *source;
 163             ID3D11ShaderResourceView *srv;
 164             ID3D11SamplerState *sampler;
 165             ID3D11InputLayout *input_layout;
 166             ID3D11VertexShader *vs;
 167             ID3D11PixelShader *ps;
 168             struct vec3 quad[4];
 169             struct
 170             {
 171                 struct rect dst;
 172                 struct rect src;
 173                 struct color backcolor;
 174             } cb;
 175         } d3d11;
 176     } video_frame;
 177     CRITICAL_SECTION cs;
 178 };
 179
 180 static void media_engine_release_video_frame_resources(struct media_engine *engine)
 181 {
 182     if (engine->video_frame.d3d11.vb)
 183         ID3D11Buffer_Release(engine->video_frame.d3d11.vb);
 184     if (engine->video_frame.d3d11.ps_cb)
 185         ID3D11Buffer_Release(engine->video_frame.d3d11.ps_cb);
 186     if (engine->video_frame.d3d11.source)
 187         ID3D11Texture2D_Release(engine->video_frame.d3d11.source);
 188     if (engine->video_frame.d3d11.srv)
 189         ID3D11ShaderResourceView_Release(engine->video_frame.d3d11.srv);
 190     if (engine->video_frame.d3d11.sampler)
 191         ID3D11SamplerState_Release(engine->video_frame.d3d11.sampler);
 192     if (engine->video_frame.d3d11.input_layout)
 193         ID3D11InputLayout_Release(engine->video_frame.d3d11.input_layout);
 194     if (engine->video_frame.d3d11.vs)
 195         ID3D11VertexShader_Release(engine->video_frame.d3d11.vs);
 196     if (engine->video_frame.d3d11.ps)
 197         ID3D11PixelShader_Release(engine->video_frame.d3d11.ps);
 198
 199     memset(&engine->video_frame.d3d11, 0, sizeof(engine->video_frame.d3d11));
 200     memcpy(engine->video_frame.d3d11.quad, fullquad, sizeof(fullquad));
 201 }
 202
 203 static HRESULT media_engine_lock_d3d_device(struct media_engine *engine, ID3D11Device **device)
 204 {
 205     HRESULT hr;
 206
 207     if (!engine->device_manager)
 208     {
 209         FIXME("Device manager wasn't set.\n");
 210         return E_UNEXPECTED;
 211     }
 212
 213     if (!engine->device_handle)
 214     {
 215         if (FAILED(hr = IMFDXGIDeviceManager_OpenDeviceHandle(engine->device_manager, &engine->device_handle)))
 216         {
 217             WARN("Failed to open device handle, hr %#lx.\n", hr);
 218             return hr;
 219         }
 220     }
 221
 222     hr = IMFDXGIDeviceManager_LockDevice(engine->device_manager, engine->device_handle, &IID_ID3D11Device,
 223             (void **)device, TRUE);
 224     if (hr == MF_E_DXGI_NEW_VIDEO_DEVICE)
 225     {
 226         IMFDXGIDeviceManager_CloseDeviceHandle(engine->device_manager, engine->device_handle);
 227         engine->device_handle = NULL;
 228
 229         media_engine_release_video_frame_resources(engine);
 230
 231         if (FAILED(hr = IMFDXGIDeviceManager_OpenDeviceHandle(engine->device_manager, &engine->device_handle)))
 232         {
 233             WARN("Failed to open a device handle, hr %#lx.\n", hr);
 234             return hr;
 235         }
 236         hr = IMFDXGIDeviceManager_LockDevice(engine->device_manager, engine->device_handle, &IID_ID3D11Device,
 237                 (void **)device, TRUE);
 238     }
 239
 240     return hr;
 241 }
 242
 243 static void media_engine_unlock_d3d_device(struct media_engine *engine, ID3D11Device *device)
 244 {
 245     ID3D11Device_Release(device);
 246     IMFDXGIDeviceManager_UnlockDevice(engine->device_manager, engine->device_handle, FALSE);
 247 }
 248
 249 static HRESULT media_engine_create_d3d11_video_frame_resources(struct media_engine *engine, ID3D11Device *device)
 250 {
 251     static const D3D11_INPUT_ELEMENT_DESC layout_desc[] =
 252     {
 253         { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
 254     };
 255     static const DWORD vs_code[] =
 256     {
 257 #if 0
 258         float4 main(float4 position : POSITION) : SV_POSITION
 259         {
 260             return position;
 261         }
 262 #endif
 263         0x43425844, 0xa7a2f22d, 0x83ff2560, 0xe61638bd, 0x87e3ce90, 0x00000001, 0x000000d8, 0x00000003,
 264         0x0000002c, 0x00000060, 0x00000094, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, 0x00000020,
 265         0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x49534f50, 0x4e4f4954, 0xababab00,
 266         0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000001, 0x00000003,
 267         0x00000000, 0x0000000f, 0x505f5653, 0x5449534f, 0x004e4f49, 0x52444853, 0x0000003c, 0x00010040,
 268         0x0000000f, 0x0300005f, 0x001010f2, 0x00000000, 0x04000067, 0x001020f2, 0x00000000, 0x00000001,
 269         0x05000036, 0x001020f2, 0x00000000, 0x00101e46, 0x00000000, 0x0100003e,
 270     };
 271     static const DWORD ps_code[] =
 272     {
 273 #if 0
 274         Texture2D t;
 275         SamplerState s;
 276         float4 dst;
 277         float4 src;
 278         float4 backcolor;
 279
 280         float4 main(float4 position : SV_POSITION) : SV_TARGET
 281         {
 282             float2 p;
 283
 284             if (position.x < dst.x || position.x > dst.z) return backcolor;
 285             if (position.y < dst.y || position.y > dst.w) return backcolor;
 286             p.x = (position.x - dst.x) / (dst.z - dst.x);
 287             p.y = 1.0f - (position.y - dst.y) / (dst.w - dst.y);
 288             p.x = src.x + p.x * (src.z - src.x);
 289             p.y = src.y + p.y * (src.w - src.y);
 290             return t.Sample(s, p);
 291         }
 292 #endif
 293         0x43425844, 0x5892e3b1, 0x24c17f7c, 0x9999f143, 0x49667872, 0x00000001, 0x0000032c, 0x00000003,
 294         0x0000002c, 0x00000060, 0x00000094, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, 0x00000020,
 295         0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000030f, 0x505f5653, 0x5449534f, 0x004e4f49,
 296         0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003,
 297         0x00000000, 0x0000000f, 0x545f5653, 0x45475241, 0xabab0054, 0x52444853, 0x00000290, 0x00000040,
 298         0x000000a4, 0x04000059, 0x00208e46, 0x00000000, 0x00000003, 0x0300005a, 0x00106000, 0x00000000,
 299         0x04001858, 0x00107000, 0x00000000, 0x00005555, 0x04002064, 0x00101032, 0x00000000, 0x00000001,
 300         0x03000065, 0x001020f2, 0x00000000, 0x02000068, 0x00000002, 0x08000031, 0x00100012, 0x00000000,
 301         0x0010100a, 0x00000000, 0x0020800a, 0x00000000, 0x00000000, 0x08000031, 0x00100022, 0x00000000,
 302         0x0020802a, 0x00000000, 0x00000000, 0x0010100a, 0x00000000, 0x0700003c, 0x00100012, 0x00000000,
 303         0x0010001a, 0x00000000, 0x0010000a, 0x00000000, 0x0304001f, 0x0010000a, 0x00000000, 0x06000036,
 304         0x001020f2, 0x00000000, 0x00208e46, 0x00000000, 0x00000002, 0x0100003e, 0x01000015, 0x08000031,
 305         0x00100012, 0x00000000, 0x0010101a, 0x00000000, 0x0020801a, 0x00000000, 0x00000000, 0x08000031,
 306         0x00100022, 0x00000000, 0x0020803a, 0x00000000, 0x00000000, 0x0010101a, 0x00000000, 0x0700003c,
 307         0x00100012, 0x00000000, 0x0010001a, 0x00000000, 0x0010000a, 0x00000000, 0x0304001f, 0x0010000a,
 308         0x00000000, 0x06000036, 0x001020f2, 0x00000000, 0x00208e46, 0x00000000, 0x00000002, 0x0100003e,
 309         0x01000015, 0x09000000, 0x00100032, 0x00000000, 0x00101046, 0x00000000, 0x80208046, 0x00000041,
 310         0x00000000, 0x00000000, 0x0a000000, 0x001000c2, 0x00000000, 0x80208406, 0x00000041, 0x00000000,
 311         0x00000000, 0x00208ea6, 0x00000000, 0x00000000, 0x0700000e, 0x00100032, 0x00000000, 0x00100046,
 312         0x00000000, 0x00100ae6, 0x00000000, 0x08000000, 0x00100022, 0x00000000, 0x8010001a, 0x00000041,
 313         0x00000000, 0x00004001, 0x3f800000, 0x0a000000, 0x001000c2, 0x00000000, 0x80208406, 0x00000041,
 314         0x00000000, 0x00000001, 0x00208ea6, 0x00000000, 0x00000001, 0x0a000032, 0x00100012, 0x00000001,
 315         0x0010000a, 0x00000000, 0x0010002a, 0x00000000, 0x0020800a, 0x00000000, 0x00000001, 0x0a000032,
 316         0x00100022, 0x00000001, 0x0010001a, 0x00000000, 0x0010003a, 0x00000000, 0x0020801a, 0x00000000,
 317         0x00000001, 0x09000045, 0x001020f2, 0x00000000, 0x00100046, 0x00000001, 0x00107e46, 0x00000000,
 318         0x00106000, 0x00000000, 0x0100003e,
 319     };
 320     D3D11_SUBRESOURCE_DATA resource_data;
 321     D3D11_TEXTURE2D_DESC texture_desc;
 322     D3D11_SAMPLER_DESC sampler_desc;
 323     D3D11_BUFFER_DESC buffer_desc;
 324     HRESULT hr;
 325
 326     if (engine->video_frame.d3d11.source)
 327         return S_OK;
 328
 329     /* Default vertex buffer, updated on first transfer call. */
 330     buffer_desc.ByteWidth = sizeof(engine->video_frame.d3d11.quad);
 331     buffer_desc.Usage = D3D11_USAGE_DEFAULT;
 332     buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
 333     buffer_desc.CPUAccessFlags = 0;
 334     buffer_desc.MiscFlags = 0;
 335     buffer_desc.StructureByteStride = 0;
 336
 337     resource_data.pSysMem = engine->video_frame.d3d11.quad;
 338     resource_data.SysMemPitch = 0;
 339     resource_data.SysMemSlicePitch = 0;
 340
 341     if (FAILED(hr = ID3D11Device_CreateBuffer(device, &buffer_desc, &resource_data, &engine->video_frame.d3d11.vb)))
 342     {
 343         WARN("Failed to create a vertex buffer, hr %#lx.\n", hr);
 344         goto failed;
 345     }
 346
 347     buffer_desc.ByteWidth = sizeof(engine->video_frame.d3d11.cb);
 348     buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
 349
 350     if (FAILED(hr = ID3D11Device_CreateBuffer(device, &buffer_desc, NULL, &engine->video_frame.d3d11.ps_cb)))
 351     {
 352         WARN("Failed to create a buffer, hr %#lx.\n", hr);
 353         goto failed;
 354     }
 355
 356     /* Source texture. */
 357     texture_desc.Width = engine->video_frame.size.cx;
 358     texture_desc.Height = engine->video_frame.size.cy;
 359     texture_desc.MipLevels = 1;
 360     texture_desc.ArraySize = 1;
 361     texture_desc.Format = engine->video_frame.output_format;
 362     texture_desc.SampleDesc.Count = 1;
 363     texture_desc.SampleDesc.Quality = 0;
 364     texture_desc.Usage = D3D11_USAGE_DEFAULT;
 365     texture_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
 366     texture_desc.CPUAccessFlags = 0;
 367     texture_desc.MiscFlags = 0;
 368
 369     if (FAILED(hr = ID3D11Device_CreateTexture2D(device, &texture_desc, NULL, &engine->video_frame.d3d11.source)))
 370     {
 371         WARN("Failed to create source texture, hr %#lx.\n", hr);
 372         goto failed;
 373     }
 374
 375     if (FAILED(hr = ID3D11Device_CreateShaderResourceView(device, (ID3D11Resource *)engine->video_frame.d3d11.source,
 376             NULL, &engine->video_frame.d3d11.srv)))
 377     {
 378         WARN("Failed to create SRV, hr %#lx.\n", hr);
 379         goto failed;
 380     }
 381
 382     /* Sampler state. */
 383     memset(&sampler_desc, 0, sizeof(sampler_desc));
 384     sampler_desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
 385     sampler_desc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
 386     sampler_desc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
 387     sampler_desc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
 388
 389     if (FAILED(hr = ID3D11Device_CreateSamplerState(device, &sampler_desc, &engine->video_frame.d3d11.sampler)))
 390     {
 391         WARN("Failed to create a sampler state, hr %#lx.\n", hr);
 392         goto failed;
 393     }
 394
 395     /* Input layout */
 396     if (FAILED(hr = ID3D11Device_CreateInputLayout(device, layout_desc, ARRAY_SIZE(layout_desc), vs_code, sizeof(vs_code),
 397             &engine->video_frame.d3d11.input_layout)))
 398     {
 399         WARN("Failed to create input layout, hr %#lx.\n", hr);
 400         goto failed;
 401     }
 402
 403     /* Shaders */
 404     if (FAILED(hr = ID3D11Device_CreateVertexShader(device, vs_code, sizeof(vs_code), NULL, &engine->video_frame.d3d11.vs)))
 405     {
 406         WARN("Failed to create the vertex shader, hr %#lx.\n", hr);
 407         goto failed;
 408     }
 409
 410     if (FAILED(hr = ID3D11Device_CreatePixelShader(device, ps_code, sizeof(ps_code), NULL, &engine->video_frame.d3d11.ps)))
 411     {
 412         WARN("Failed to create the pixel shader, hr %#lx.\n", hr);
 413         goto failed;
 414     }
 415
 416 failed:
 417
 418     return hr;
 419 }
 420
 421 struct range
 422 {
 423     double start;
 424     double end;
 425 };
 426
 427 struct time_range
 428 {
 429     IMFMediaTimeRange IMFMediaTimeRange_iface;
 430     LONG refcount;
 431
 432     struct range *ranges;
 433     size_t count;
 434     size_t capacity;
 435 };
 436
 437 static struct time_range *impl_from_IMFMediaTimeRange(IMFMediaTimeRange *iface)
 438 {
 439     return CONTAINING_RECORD(iface, struct time_range, IMFMediaTimeRange_iface);
 440 }
 441
 442 struct media_error
 443 {
 444     IMFMediaError IMFMediaError_iface;
 445     LONG refcount;
 446     unsigned int code;
 447     HRESULT extended_code;
 448 };
 449
 450 static struct media_error *impl_from_IMFMediaError(IMFMediaError *iface)
 451 {
 452     return CONTAINING_RECORD(iface, struct media_error, IMFMediaError_iface);
 453 }
 454
 455 static HRESULT WINAPI media_error_QueryInterface(IMFMediaError *iface, REFIID riid, void **obj)
 456 {
 457     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 458
 459     if (IsEqualIID(riid, &IID_IMFMediaError) ||
 460             IsEqualIID(riid, &IID_IUnknown))
 461     {
 462         *obj = iface;
 463         IMFMediaError_AddRef(iface);
 464         return S_OK;
 465     }
 466
 467     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 468     *obj = NULL;
 469     return E_NOINTERFACE;
 470 }
 471
 472 static ULONG WINAPI media_error_AddRef(IMFMediaError *iface)
 473 {
 474     struct media_error *me = impl_from_IMFMediaError(iface);
 475     ULONG refcount = InterlockedIncrement(&me->refcount);
 476
 477     TRACE("%p, refcount %lu.\n", iface, refcount);
 478
 479     return refcount;
 480 }
 481
 482 static ULONG WINAPI media_error_Release(IMFMediaError *iface)
 483 {
 484     struct media_error *me = impl_from_IMFMediaError(iface);
 485     ULONG refcount = InterlockedDecrement(&me->refcount);
 486
 487     TRACE("%p, refcount %lu.\n", iface, refcount);
 488
 489     if (!refcount)
 490         free(me);
 491
 492     return refcount;
 493 }
 494
 495 static USHORT WINAPI media_error_GetErrorCode(IMFMediaError *iface)
 496 {
 497     struct media_error *me = impl_from_IMFMediaError(iface);
 498     TRACE("%p.\n", iface);
 499     return me->code;
 500 }
 501
 502 static HRESULT WINAPI media_error_GetExtendedErrorCode(IMFMediaError *iface)
 503 {
 504     struct media_error *me = impl_from_IMFMediaError(iface);
 505     TRACE("%p.\n", iface);
 506     return me->extended_code;
 507 }
 508
 509 static HRESULT WINAPI media_error_SetErrorCode(IMFMediaError *iface, MF_MEDIA_ENGINE_ERR code)
 510 {
 511     struct media_error *me = impl_from_IMFMediaError(iface);
 512
 513     TRACE("%p, %u.\n", iface, code);
 514
 515     if ((unsigned int)code > MF_MEDIA_ENGINE_ERR_ENCRYPTED)
 516         return E_INVALIDARG;
 517
 518     me->code = code;
 519
 520     return S_OK;
 521 }
 522
 523 static HRESULT WINAPI media_error_SetExtendedErrorCode(IMFMediaError *iface, HRESULT code)
 524 {
 525     struct media_error *me = impl_from_IMFMediaError(iface);
 526
 527     TRACE("%p, %#lx.\n", iface, code);
 528
 529     me->extended_code = code;
 530
 531     return S_OK;
 532 }
 533
 534 static const IMFMediaErrorVtbl media_error_vtbl =
 535 {
 536     media_error_QueryInterface,
 537     media_error_AddRef,
 538     media_error_Release,
 539     media_error_GetErrorCode,
 540     media_error_GetExtendedErrorCode,
 541     media_error_SetErrorCode,
 542     media_error_SetExtendedErrorCode,
 543 };
 544
 545 static HRESULT create_media_error(IMFMediaError **ret)
 546 {
 547     struct media_error *object;
 548
 549     *ret = NULL;
 550
 551     if (!(object = calloc(1, sizeof(*object))))
 552         return E_OUTOFMEMORY;
 553
 554     object->IMFMediaError_iface.lpVtbl = &media_error_vtbl;
 555     object->refcount = 1;
 556
 557     *ret = &object->IMFMediaError_iface;
 558
 559     return S_OK;
 560 }
 561
 562 static HRESULT WINAPI time_range_QueryInterface(IMFMediaTimeRange *iface, REFIID riid, void **obj)
 563 {
 564     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 565
 566     if (IsEqualIID(riid, &IID_IMFMediaTimeRange) ||
 567             IsEqualIID(riid, &IID_IUnknown))
 568     {
 569         *obj = iface;
 570         IMFMediaTimeRange_AddRef(iface);
 571         return S_OK;
 572     }
 573
 574     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 575     *obj = NULL;
 576     return E_NOINTERFACE;
 577 }
 578
 579 static ULONG WINAPI time_range_AddRef(IMFMediaTimeRange *iface)
 580 {
 581     struct time_range *range = impl_from_IMFMediaTimeRange(iface);
 582     ULONG refcount = InterlockedIncrement(&range->refcount);
 583
 584     TRACE("%p, refcount %lu.\n", iface, refcount);
 585
 586     return refcount;
 587 }
 588
 589 static ULONG WINAPI time_range_Release(IMFMediaTimeRange *iface)
 590 {
 591     struct time_range *range = impl_from_IMFMediaTimeRange(iface);
 592     ULONG refcount = InterlockedDecrement(&range->refcount);
 593
 594     TRACE("%p, refcount %lu.\n", iface, refcount);
 595
 596     if (!refcount)
 597     {
 598         free(range->ranges);
 599         free(range);
 600     }
 601
 602     return refcount;
 603 }
 604
 605 static DWORD WINAPI time_range_GetLength(IMFMediaTimeRange *iface)
 606 {
 607     struct time_range *range = impl_from_IMFMediaTimeRange(iface);
 608
 609     TRACE("%p.\n", iface);
 610
 611     return range->count;
 612 }
 613
 614 static HRESULT WINAPI time_range_GetStart(IMFMediaTimeRange *iface, DWORD idx, double *start)
 615 {
 616     struct time_range *range = impl_from_IMFMediaTimeRange(iface);
 617
 618     TRACE("%p, %lu, %p.\n", iface, idx, start);
 619
 620     if (idx >= range->count)
 621         return E_INVALIDARG;
 622
 623     *start = range->ranges[idx].start;
 624
 625     return S_OK;
 626 }
 627
 628 static HRESULT WINAPI time_range_GetEnd(IMFMediaTimeRange *iface, DWORD idx, double *end)
 629 {
 630     struct time_range *range = impl_from_IMFMediaTimeRange(iface);
 631
 632     TRACE("%p, %lu, %p.\n", iface, idx, end);
 633
 634     if (idx >= range->count)
 635         return E_INVALIDARG;
 636
 637     *end = range->ranges[idx].end;
 638
 639     return S_OK;
 640 }
 641
 642 static BOOL WINAPI time_range_ContainsTime(IMFMediaTimeRange *iface, double time)
 643 {
 644     struct time_range *range = impl_from_IMFMediaTimeRange(iface);
 645     size_t i;
 646
 647     TRACE("%p, %.8e.\n", iface, time);
 648
 649     for (i = 0; i < range->count; ++i)
 650     {
 651         if (time >= range->ranges[i].start && time <= range->ranges[i].end)
 652             return TRUE;
 653     }
 654
 655     return FALSE;
 656 }
 657
 658 static HRESULT WINAPI time_range_AddRange(IMFMediaTimeRange *iface, double start, double end)
 659 {
 660     struct time_range *range = impl_from_IMFMediaTimeRange(iface);
 661     struct range *c;
 662     size_t i;
 663
 664     TRACE("%p, %.8e, %.8e.\n", iface, start, end);
 665
 666     for (i = 0; i < range->count; ++i)
 667     {
 668         c = &range->ranges[i];
 669
 670         /* New range is fully contained within existing one. */
 671         if (c->start <= start && c->end >= end)
 672             return S_OK;
 673
 674         /* New range fully contains existing one. */
 675         if (c->start >= start && c->end <= end)
 676         {
 677             c->start = start;
 678             c->end = end;
 679             return S_OK;
 680         }
 681
 682         /* Merge if ranges intersect. */
 683         if ((start >= c->start && start <= c->end) ||
 684                 (end >= c->start && end <= c->end))
 685         {
 686             c->start = min(c->start, start);
 687             c->end = max(c->end, end);
 688             return S_OK;
 689         }
 690     }
 691
 692     if (!mf_array_reserve((void **)&range->ranges, &range->capacity, range->count + 1, sizeof(*range->ranges)))
 693         return E_OUTOFMEMORY;
 694
 695     range->ranges[range->count].start = start;
 696     range->ranges[range->count].end = end;
 697     range->count++;
 698
 699     return S_OK;
 700 }
 701
 702 static HRESULT WINAPI time_range_Clear(IMFMediaTimeRange *iface)
 703 {
 704     struct time_range *range = impl_from_IMFMediaTimeRange(iface);
 705
 706     TRACE("%p.\n", iface);
 707
 708     range->count = 0;
 709
 710     return S_OK;
 711 }
 712
 713 static const IMFMediaTimeRangeVtbl time_range_vtbl =
 714 {
 715     time_range_QueryInterface,
 716     time_range_AddRef,
 717     time_range_Release,
 718     time_range_GetLength,
 719     time_range_GetStart,
 720     time_range_GetEnd,
 721     time_range_ContainsTime,
 722     time_range_AddRange,
 723     time_range_Clear,
 724 };
 725
 726 static HRESULT create_time_range(IMFMediaTimeRange **range)
 727 {
 728     struct time_range *object;
 729
 730     object = calloc(1, sizeof(*object));
 731     if (!object)
 732         return E_OUTOFMEMORY;
 733
 734     object->IMFMediaTimeRange_iface.lpVtbl = &time_range_vtbl;
 735     object->refcount = 1;
 736
 737     *range = &object->IMFMediaTimeRange_iface;
 738
 739     return S_OK;
 740 }
 741
 742 static void media_engine_set_flag(struct media_engine *engine, unsigned int mask, BOOL value)
 743 {
 744     if (value)
 745         engine->flags |= mask;
 746     else
 747         engine->flags &= ~mask;
 748 }
 749
 750 static inline struct media_engine *impl_from_IMFMediaEngineEx(IMFMediaEngineEx *iface)
 751 {
 752     return CONTAINING_RECORD(iface, struct media_engine, IMFMediaEngineEx_iface);
 753 }
 754
 755 static inline struct media_engine *impl_from_IMFGetService(IMFGetService *iface)
 756 {
 757     return CONTAINING_RECORD(iface, struct media_engine, IMFGetService_iface);
 758 }
 759
 760 static struct media_engine *impl_from_session_events_IMFAsyncCallback(IMFAsyncCallback *iface)
 761 {
 762     return CONTAINING_RECORD(iface, struct media_engine, session_events);
 763 }
 764
 765 static struct media_engine *impl_from_load_handler_IMFAsyncCallback(IMFAsyncCallback *iface)
 766 {
 767     return CONTAINING_RECORD(iface, struct media_engine, load_handler);
 768 }
 769
 770 static struct media_engine *impl_from_IMFSampleGrabberSinkCallback(IMFSampleGrabberSinkCallback *iface)
 771 {
 772     return CONTAINING_RECORD(iface, struct media_engine, grabber_callback);
 773 }
 774
 775 static unsigned int get_gcd(unsigned int a, unsigned int b)
 776 {
 777     unsigned int m;
 778
 779     while (b)
 780     {
 781         m = a % b;
 782         a = b;
 783         b = m;
 784     }
 785
 786     return a;
 787 }
 788
 789 static void media_engine_get_frame_size(struct media_engine *engine, IMFTopology *topology)
 790 {
 791     IMFMediaTypeHandler *handler;
 792     IMFMediaType *media_type;
 793     IMFStreamDescriptor *sd;
 794     IMFTopologyNode *node;
 795     unsigned int gcd;
 796     UINT64 size;
 797     HRESULT hr;
 798
 799     engine->video_frame.size.cx = 0;
 800     engine->video_frame.size.cy = 0;
 801     engine->video_frame.ratio.cx = 1;
 802     engine->video_frame.ratio.cy = 1;
 803
 804     if (FAILED(IMFTopology_GetNodeByID(topology, engine->video_frame.node_id, &node)))
 805         return;
 806
 807     hr = IMFTopologyNode_GetUnknown(node, &MF_TOPONODE_STREAM_DESCRIPTOR,
 808             &IID_IMFStreamDescriptor, (void **)&sd);
 809     IMFTopologyNode_Release(node);
 810     if (FAILED(hr))
 811         return;
 812
 813     hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler);
 814     IMFStreamDescriptor_Release(sd);
 815     if (FAILED(hr))
 816         return;
 817
 818     hr = IMFMediaTypeHandler_GetCurrentMediaType(handler, &media_type);
 819     IMFMediaTypeHandler_Release(handler);
 820     if (FAILED(hr))
 821     {
 822         WARN("Failed to get current media type %#lx.\n", hr);
 823         return;
 824     }
 825
 826     IMFMediaType_GetUINT64(media_type, &MF_MT_FRAME_SIZE, &size);
 827
 828     engine->video_frame.size.cx = size >> 32;
 829     engine->video_frame.size.cy = size;
 830
 831     if ((gcd = get_gcd(engine->video_frame.size.cx, engine->video_frame.size.cy)))
 832     {
 833         engine->video_frame.ratio.cx = engine->video_frame.size.cx / gcd;
 834         engine->video_frame.ratio.cy = engine->video_frame.size.cy / gcd;
 835     }
 836
 837     IMFMediaType_Release(media_type);
 838 }
 839
 840 static HRESULT WINAPI media_engine_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
 841 {
 842     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 843             IsEqualIID(riid, &IID_IUnknown))
 844     {
 845         *obj = iface;
 846         IMFAsyncCallback_AddRef(iface);
 847         return S_OK;
 848     }
 849
 850     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 851     *obj = NULL;
 852     return E_NOINTERFACE;
 853 }
 854
 855 static ULONG WINAPI media_engine_session_events_AddRef(IMFAsyncCallback *iface)
 856 {
 857     struct media_engine *engine = impl_from_session_events_IMFAsyncCallback(iface);
 858     return IMFMediaEngineEx_AddRef(&engine->IMFMediaEngineEx_iface);
 859 }
 860
 861 static ULONG WINAPI media_engine_session_events_Release(IMFAsyncCallback *iface)
 862 {
 863     struct media_engine *engine = impl_from_session_events_IMFAsyncCallback(iface);
 864     return IMFMediaEngineEx_Release(&engine->IMFMediaEngineEx_iface);
 865 }
 866
 867 static HRESULT WINAPI media_engine_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
 868 {
 869     return E_NOTIMPL;
 870 }
 871
 872 static HRESULT WINAPI media_engine_session_events_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 873 {
 874     struct media_engine *engine = impl_from_session_events_IMFAsyncCallback(iface);
 875     IMFMediaEvent *event = NULL;
 876     MediaEventType event_type;
 877     HRESULT hr;
 878
 879     if (FAILED(hr = IMFMediaSession_EndGetEvent(engine->session, result, &event)))
 880     {
 881         WARN("Failed to get session event, hr %#lx.\n", hr);
 882         goto failed;
 883     }
 884
 885     if (FAILED(hr = IMFMediaEvent_GetType(event, &event_type)))
 886     {
 887         WARN("Failed to get event type, hr %#lx.\n", hr);
 888         goto failed;
 889     }
 890
 891     switch (event_type)
 892     {
 893         case MEBufferingStarted:
 894         case MEBufferingStopped:
 895
 896             IMFMediaEngineNotify_EventNotify(engine->callback, event_type == MEBufferingStarted ?
 897                     MF_MEDIA_ENGINE_EVENT_BUFFERINGSTARTED : MF_MEDIA_ENGINE_EVENT_BUFFERINGENDED, 0, 0);
 898             break;
 899         case MESessionTopologyStatus:
 900         {
 901             UINT32 topo_status = 0;
 902             IMFTopology *topology;
 903             PROPVARIANT value;
 904
 905             IMFMediaEvent_GetUINT32(event, &MF_EVENT_TOPOLOGY_STATUS, &topo_status);
 906             if (topo_status != MF_TOPOSTATUS_READY)
 907                 break;
 908
 909             value.vt = VT_EMPTY;
 910             if (FAILED(IMFMediaEvent_GetValue(event, &value)))
 911                 break;
 912
 913             if (value.vt != VT_UNKNOWN)
 914             {
 915                 PropVariantClear(&value);
 916                 break;
 917             }
 918
 919             topology = (IMFTopology *)value.punkVal;
 920
 921             EnterCriticalSection(&engine->cs);
 922
 923             engine->ready_state = MF_MEDIA_ENGINE_READY_HAVE_METADATA;
 924
 925             media_engine_get_frame_size(engine, topology);
 926
 927             IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_DURATIONCHANGE, 0, 0);
 928             IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_LOADEDMETADATA, 0, 0);
 929
 930             engine->ready_state = MF_MEDIA_ENGINE_READY_HAVE_ENOUGH_DATA;
 931
 932             IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_LOADEDDATA, 0, 0);
 933             IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_CANPLAY, 0, 0);
 934
 935             LeaveCriticalSection(&engine->cs);
 936
 937             PropVariantClear(&value);
 938
 939             break;
 940         }
 941         case MESessionStarted:
 942
 943             IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PLAYING, 0, 0);
 944             break;
 945         case MESessionEnded:
 946
 947             EnterCriticalSection(&engine->cs);
 948             media_engine_set_flag(engine, FLAGS_ENGINE_FIRST_FRAME, FALSE);
 949             media_engine_set_flag(engine, FLAGS_ENGINE_IS_ENDED, TRUE);
 950             engine->video_frame.pts = MINLONGLONG;
 951             LeaveCriticalSection(&engine->cs);
 952
 953             IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_ENDED, 0, 0);
 954             break;
 955     }
 956
 957 failed:
 958
 959     if (event)
 960         IMFMediaEvent_Release(event);
 961
 962     if (FAILED(hr = IMFMediaSession_BeginGetEvent(engine->session, iface, NULL)))
 963         WARN("Failed to subscribe to session events, hr %#lx.\n", hr);
 964
 965     return S_OK;
 966 }
 967
 968 static const IMFAsyncCallbackVtbl media_engine_session_events_vtbl =
 969 {
 970     media_engine_callback_QueryInterface,
 971     media_engine_session_events_AddRef,
 972     media_engine_session_events_Release,
 973     media_engine_callback_GetParameters,
 974     media_engine_session_events_Invoke,
 975 };
 976
 977 static ULONG WINAPI media_engine_load_handler_AddRef(IMFAsyncCallback *iface)
 978 {
 979     struct media_engine *engine = impl_from_load_handler_IMFAsyncCallback(iface);
 980     return IMFMediaEngineEx_AddRef(&engine->IMFMediaEngineEx_iface);
 981 }
 982
 983 static ULONG WINAPI media_engine_load_handler_Release(IMFAsyncCallback *iface)
 984 {
 985     struct media_engine *engine = impl_from_load_handler_IMFAsyncCallback(iface);
 986     return IMFMediaEngineEx_Release(&engine->IMFMediaEngineEx_iface);
 987 }
 988
 989 static HRESULT media_engine_create_source_node(IMFMediaSource *source, IMFPresentationDescriptor *pd, IMFStreamDescriptor *sd,
 990         IMFTopologyNode **node)
 991 {
 992     HRESULT hr;
 993
 994     if (FAILED(hr = MFCreateTopologyNode(MF_TOPOLOGY_SOURCESTREAM_NODE, node)))
 995         return hr;
 996
 997     IMFTopologyNode_SetUnknown(*node, &MF_TOPONODE_SOURCE, (IUnknown *)source);
 998     IMFTopologyNode_SetUnknown(*node, &MF_TOPONODE_PRESENTATION_DESCRIPTOR, (IUnknown *)pd);
 999     IMFTopologyNode_SetUnknown(*node, &MF_TOPONODE_STREAM_DESCRIPTOR, (IUnknown *)sd);
1000
1001     return S_OK;
1002 }
1003
1004 static HRESULT media_engine_create_audio_renderer(struct media_engine *engine, IMFTopologyNode **node)
1005 {
1006     unsigned int category, role;
1007     IMFActivate *sar_activate;
1008     HRESULT hr;
1009
1010     *node = NULL;
1011
1012     if (FAILED(hr = MFCreateAudioRendererActivate(&sar_activate)))
1013         return hr;
1014
1015     /* Configuration attributes keys differ between Engine and SAR. */
1016     if (SUCCEEDED(IMFAttributes_GetUINT32(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_CATEGORY, &category)))
1017         IMFActivate_SetUINT32(sar_activate, &MF_AUDIO_RENDERER_ATTRIBUTE_STREAM_CATEGORY, category);
1018     if (SUCCEEDED(IMFAttributes_GetUINT32(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_ENDPOINT_ROLE, &role)))
1019         IMFActivate_SetUINT32(sar_activate, &MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE, role);
1020
1021     if (SUCCEEDED(hr = MFCreateTopologyNode(MF_TOPOLOGY_OUTPUT_NODE, node)))
1022     {
1023         IMFTopologyNode_SetObject(*node, (IUnknown *)sar_activate);
1024         IMFTopologyNode_SetUINT32(*node, &MF_TOPONODE_NOSHUTDOWN_ON_REMOVE, FALSE);
1025     }
1026
1027     IMFActivate_Release(sar_activate);
1028
1029     return hr;
1030 }
1031
1032 static HRESULT media_engine_create_video_renderer(struct media_engine *engine, IMFTopologyNode **node)
1033 {
1034     DXGI_FORMAT output_format;
1035     IMFMediaType *media_type;
1036     IMFActivate *activate;
1037     GUID subtype;
1038     HRESULT hr;
1039
1040     *node = NULL;
1041
1042     if (FAILED(IMFAttributes_GetUINT32(engine->attributes, &MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT, &output_format)))
1043     {
1044         WARN("Output format was not specified.\n");
1045         return E_FAIL;
1046     }
1047
1048     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
1049     if (!(subtype.Data1 = MFMapDXGIFormatToDX9Format(output_format)))
1050     {
1051         WARN("Unrecognized output format %#x.\n", output_format);
1052         return E_FAIL;
1053     }
1054
1055     if (FAILED(hr = MFCreateMediaType(&media_type)))
1056         return hr;
1057
1058     IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
1059     IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &subtype);
1060
1061     hr = MFCreateSampleGrabberSinkActivate(media_type, &engine->grabber_callback, &activate);
1062     IMFMediaType_Release(media_type);
1063     if (FAILED(hr))
1064         return hr;
1065
1066     if (SUCCEEDED(hr = MFCreateTopologyNode(MF_TOPOLOGY_OUTPUT_NODE, node)))
1067     {
1068         IMFTopologyNode_SetObject(*node, (IUnknown *)activate);
1069         IMFTopologyNode_SetUINT32(*node, &MF_TOPONODE_NOSHUTDOWN_ON_REMOVE, FALSE);
1070     }
1071
1072     IMFActivate_Release(activate);
1073
1074     engine->video_frame.output_format = output_format;
1075
1076     return hr;
1077 }
1078
1079 static void media_engine_clear_presentation(struct media_engine *engine)
1080 {
1081     if (engine->presentation.source)
1082     {
1083         IMFMediaSource_Shutdown(engine->presentation.source);
1084         IMFMediaSource_Release(engine->presentation.source);
1085     }
1086     if (engine->presentation.pd)
1087         IMFPresentationDescriptor_Release(engine->presentation.pd);
1088     memset(&engine->presentation, 0, sizeof(engine->presentation));
1089 }
1090
1091 static HRESULT media_engine_create_topology(struct media_engine *engine, IMFMediaSource *source)
1092 {
1093     IMFStreamDescriptor *sd_audio = NULL, *sd_video = NULL;
1094     IMFPresentationDescriptor *pd;
1095     DWORD stream_count = 0, i;
1096     IMFTopology *topology;
1097     UINT64 duration;
1098     HRESULT hr;
1099
1100     media_engine_release_video_frame_resources(engine);
1101     media_engine_clear_presentation(engine);
1102
1103     if (FAILED(hr = IMFMediaSource_CreatePresentationDescriptor(source, &pd)))
1104         return hr;
1105
1106     if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorCount(pd, &stream_count)))
1107         WARN("Failed to get stream count, hr %#lx.\n", hr);
1108
1109     /* Enable first video stream and first audio stream. */
1110
1111     for (i = 0; i < stream_count; ++i)
1112     {
1113         IMFMediaTypeHandler *type_handler;
1114         IMFStreamDescriptor *sd;
1115         BOOL selected;
1116
1117         IMFPresentationDescriptor_DeselectStream(pd, i);
1118
1119         if (sd_audio && sd_video)
1120             continue;
1121
1122         IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, i, &selected, &sd);
1123
1124         if (SUCCEEDED(IMFStreamDescriptor_GetMediaTypeHandler(sd, &type_handler)))
1125         {
1126             GUID major = { 0 };
1127
1128             IMFMediaTypeHandler_GetMajorType(type_handler, &major);
1129
1130             if (IsEqualGUID(&major, &MFMediaType_Audio) && !sd_audio)
1131             {
1132                 sd_audio = sd;
1133                 IMFStreamDescriptor_AddRef(sd_audio);
1134                 IMFPresentationDescriptor_SelectStream(pd, i);
1135             }
1136             else if (IsEqualGUID(&major, &MFMediaType_Video) && !sd_video && !(engine->flags & MF_MEDIA_ENGINE_AUDIOONLY))
1137             {
1138                 sd_video = sd;
1139                 IMFStreamDescriptor_AddRef(sd_video);
1140                 IMFPresentationDescriptor_SelectStream(pd, i);
1141             }
1142
1143             IMFMediaTypeHandler_Release(type_handler);
1144         }
1145
1146         IMFStreamDescriptor_Release(sd);
1147     }
1148
1149     if (!sd_video && !sd_audio)
1150     {
1151         IMFPresentationDescriptor_Release(pd);
1152         return E_UNEXPECTED;
1153     }
1154
1155     engine->presentation.source = source;
1156     IMFMediaSource_AddRef(engine->presentation.source);
1157     engine->presentation.pd = pd;
1158     IMFPresentationDescriptor_AddRef(engine->presentation.pd);
1159
1160     media_engine_set_flag(engine, FLAGS_ENGINE_HAS_VIDEO, !!sd_video);
1161     media_engine_set_flag(engine, FLAGS_ENGINE_HAS_AUDIO, !!sd_audio);
1162
1163     /* Assume live source if duration was not provided. */
1164     if (SUCCEEDED(IMFPresentationDescriptor_GetUINT64(pd, &MF_PD_DURATION, &duration)))
1165     {
1166         /* Convert 100ns to seconds. */
1167         engine->duration = duration / 10000000;
1168     }
1169     else
1170         engine->duration = INFINITY;
1171
1172     if (SUCCEEDED(hr = MFCreateTopology(&topology)))
1173     {
1174         IMFTopologyNode *sar_node = NULL, *audio_src = NULL;
1175         IMFTopologyNode *grabber_node = NULL, *video_src = NULL;
1176
1177         if (engine->flags & MF_MEDIA_ENGINE_REAL_TIME_MODE)
1178             IMFTopology_SetUINT32(topology, &MF_LOW_LATENCY, TRUE);
1179
1180         if (sd_audio)
1181         {
1182             if (FAILED(hr = media_engine_create_source_node(source, pd, sd_audio, &audio_src)))
1183                 WARN("Failed to create audio source node, hr %#lx.\n", hr);
1184
1185             if (FAILED(hr = media_engine_create_audio_renderer(engine, &sar_node)))
1186                 WARN("Failed to create audio renderer node, hr %#lx.\n", hr);
1187
1188             if (sar_node && audio_src)
1189             {
1190                 IMFTopology_AddNode(topology, audio_src);
1191                 IMFTopology_AddNode(topology, sar_node);
1192                 IMFTopologyNode_ConnectOutput(audio_src, 0, sar_node, 0);
1193             }
1194
1195             if (sar_node)
1196                 IMFTopologyNode_Release(sar_node);
1197             if (audio_src)
1198                 IMFTopologyNode_Release(audio_src);
1199         }
1200
1201         if (SUCCEEDED(hr) && sd_video)
1202         {
1203             if (FAILED(hr = media_engine_create_source_node(source, pd, sd_video, &video_src)))
1204                 WARN("Failed to create video source node, hr %#lx.\n", hr);
1205
1206             if (FAILED(hr = media_engine_create_video_renderer(engine, &grabber_node)))
1207                 WARN("Failed to create video grabber node, hr %#lx.\n", hr);
1208
1209             if (grabber_node && video_src)
1210             {
1211                 IMFTopology_AddNode(topology, video_src);
1212                 IMFTopology_AddNode(topology, grabber_node);
1213                 IMFTopologyNode_ConnectOutput(video_src, 0, grabber_node, 0);
1214             }
1215
1216             if (SUCCEEDED(hr))
1217                 IMFTopologyNode_GetTopoNodeID(video_src, &engine->video_frame.node_id);
1218
1219             if (grabber_node)
1220                 IMFTopologyNode_Release(grabber_node);
1221             if (video_src)
1222                 IMFTopologyNode_Release(video_src);
1223         }
1224
1225         IMFTopology_SetUINT32(topology, &MF_TOPOLOGY_ENUMERATE_SOURCE_TYPES, TRUE);
1226
1227         if (SUCCEEDED(hr))
1228             hr = IMFMediaSession_SetTopology(engine->session, MFSESSION_SETTOPOLOGY_IMMEDIATE, topology);
1229     }
1230
1231     if (topology)
1232         IMFTopology_Release(topology);
1233
1234     if (sd_video)
1235         IMFStreamDescriptor_Release(sd_video);
1236     if (sd_audio)
1237         IMFStreamDescriptor_Release(sd_audio);
1238
1239     IMFPresentationDescriptor_Release(pd);
1240
1241     return hr;
1242 }
1243
1244 static void media_engine_start_playback(struct media_engine *engine)
1245 {
1246     PROPVARIANT var;
1247
1248     var.vt = VT_EMPTY;
1249     IMFMediaSession_Start(engine->session, &GUID_NULL, &var);
1250 }
1251
1252 static HRESULT WINAPI media_engine_load_handler_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1253 {
1254     struct media_engine *engine = impl_from_load_handler_IMFAsyncCallback(iface);
1255     IUnknown *object = NULL, *state;
1256     unsigned int start_playback;
1257     MF_OBJECT_TYPE obj_type;
1258     IMFMediaSource *source;
1259     HRESULT hr;
1260
1261     EnterCriticalSection(&engine->cs);
1262
1263     engine->network_state = MF_MEDIA_ENGINE_NETWORK_LOADING;
1264     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_LOADSTART, 0, 0);
1265
1266     start_playback = engine->flags & FLAGS_ENGINE_PLAY_PENDING;
1267     media_engine_set_flag(engine, FLAGS_ENGINE_SOURCE_PENDING | FLAGS_ENGINE_PLAY_PENDING, FALSE);
1268
1269     if (SUCCEEDED(IMFAsyncResult_GetState(result, &state)))
1270     {
1271         hr = IMFSourceResolver_EndCreateObjectFromByteStream(engine->resolver, result, &obj_type, &object);
1272         IUnknown_Release(state);
1273     }
1274     else
1275         hr = IMFSourceResolver_EndCreateObjectFromURL(engine->resolver, result, &obj_type, &object);
1276
1277     if (FAILED(hr))
1278         WARN("Failed to create source object, hr %#lx.\n", hr);
1279
1280     if (object)
1281     {
1282         if (SUCCEEDED(hr = IUnknown_QueryInterface(object, &IID_IMFMediaSource, (void **)&source)))
1283         {
1284             hr = media_engine_create_topology(engine, source);
1285             IMFMediaSource_Release(source);
1286         }
1287         IUnknown_Release(object);
1288     }
1289
1290     if (SUCCEEDED(hr))
1291     {
1292         engine->network_state = MF_MEDIA_ENGINE_NETWORK_IDLE;
1293         if (start_playback)
1294             media_engine_start_playback(engine);
1295     }
1296     else
1297     {
1298         engine->network_state = MF_MEDIA_ENGINE_NETWORK_NO_SOURCE;
1299         engine->error_code = MF_MEDIA_ENGINE_ERR_SRC_NOT_SUPPORTED;
1300         engine->extended_code = hr;
1301         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_ERROR, engine->error_code,
1302                 engine->extended_code);
1303     }
1304
1305     LeaveCriticalSection(&engine->cs);
1306
1307     return S_OK;
1308 }
1309
1310 static const IMFAsyncCallbackVtbl media_engine_load_handler_vtbl =
1311 {
1312     media_engine_callback_QueryInterface,
1313     media_engine_load_handler_AddRef,
1314     media_engine_load_handler_Release,
1315     media_engine_callback_GetParameters,
1316     media_engine_load_handler_Invoke,
1317 };
1318
1319 static HRESULT WINAPI media_engine_QueryInterface(IMFMediaEngineEx *iface, REFIID riid, void **obj)
1320 {
1321     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1322
1323     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1324
1325     if (IsEqualIID(riid, &IID_IMFMediaEngineEx) ||
1326         IsEqualIID(riid, &IID_IMFMediaEngine) ||
1327         IsEqualIID(riid, &IID_IUnknown))
1328     {
1329         *obj = iface;
1330     }
1331     else if (IsEqualIID(riid, &IID_IMFGetService))
1332     {
1333         *obj = &engine->IMFGetService_iface;
1334     }
1335     else
1336     {
1337         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1338         *obj = NULL;
1339         return E_NOINTERFACE;
1340     }
1341
1342     IUnknown_AddRef((IUnknown *)*obj);
1343     return S_OK;
1344 }
1345
1346 static ULONG WINAPI media_engine_AddRef(IMFMediaEngineEx *iface)
1347 {
1348     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1349     ULONG refcount = InterlockedIncrement(&engine->refcount);
1350
1351     TRACE("%p, refcount %lu.\n", iface, refcount);
1352
1353     return refcount;
1354 }
1355
1356 static void free_media_engine(struct media_engine *engine)
1357 {
1358     if (engine->callback)
1359         IMFMediaEngineNotify_Release(engine->callback);
1360     if (engine->clock)
1361         IMFPresentationClock_Release(engine->clock);
1362     if (engine->session)
1363         IMFMediaSession_Release(engine->session);
1364     if (engine->attributes)
1365         IMFAttributes_Release(engine->attributes);
1366     if (engine->resolver)
1367         IMFSourceResolver_Release(engine->resolver);
1368     media_engine_release_video_frame_resources(engine);
1369     media_engine_clear_presentation(engine);
1370     if (engine->device_manager)
1371     {
1372         IMFDXGIDeviceManager_CloseDeviceHandle(engine->device_manager, engine->device_handle);
1373         IMFDXGIDeviceManager_Release(engine->device_manager);
1374     }
1375     SysFreeString(engine->current_source);
1376     DeleteCriticalSection(&engine->cs);
1377     free(engine->video_frame.buffer);
1378     free(engine);
1379 }
1380
1381 static ULONG WINAPI media_engine_Release(IMFMediaEngineEx *iface)
1382 {
1383     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1384     ULONG refcount = InterlockedDecrement(&engine->refcount);
1385
1386     TRACE("%p, refcount %lu.\n", iface, refcount);
1387
1388     if (!refcount)
1389         free_media_engine(engine);
1390
1391     return refcount;
1392 }
1393
1394 static HRESULT WINAPI media_engine_GetError(IMFMediaEngineEx *iface, IMFMediaError **error)
1395 {
1396     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1397     HRESULT hr = S_OK;
1398
1399     TRACE("%p, %p.\n", iface, error);
1400
1401     *error = NULL;
1402
1403     EnterCriticalSection(&engine->cs);
1404     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1405         hr = MF_E_SHUTDOWN;
1406     else if (engine->error_code)
1407     {
1408         if (SUCCEEDED(hr = create_media_error(error)))
1409         {
1410             IMFMediaError_SetErrorCode(*error, engine->error_code);
1411             IMFMediaError_SetExtendedErrorCode(*error, engine->extended_code);
1412         }
1413     }
1414     LeaveCriticalSection(&engine->cs);
1415
1416     return hr;
1417 }
1418
1419 static HRESULT WINAPI media_engine_SetErrorCode(IMFMediaEngineEx *iface, MF_MEDIA_ENGINE_ERR code)
1420 {
1421     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1422     HRESULT hr = S_OK;
1423
1424     TRACE("%p, %u.\n", iface, code);
1425
1426     if ((unsigned int)code > MF_MEDIA_ENGINE_ERR_ENCRYPTED)
1427         return E_INVALIDARG;
1428
1429     EnterCriticalSection(&engine->cs);
1430     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1431         hr = MF_E_SHUTDOWN;
1432     else
1433         engine->error_code = code;
1434     LeaveCriticalSection(&engine->cs);
1435
1436     return hr;
1437 }
1438
1439 static HRESULT WINAPI media_engine_SetSourceElements(IMFMediaEngineEx *iface, IMFMediaEngineSrcElements *elements)
1440 {
1441     FIXME("(%p, %p): stub.\n", iface, elements);
1442
1443     return E_NOTIMPL;
1444 }
1445
1446 static HRESULT media_engine_set_source(struct media_engine *engine, IMFByteStream *bytestream, BSTR url)
1447 {
1448     IPropertyStore *props = NULL;
1449     unsigned int flags;
1450     HRESULT hr = S_OK;
1451
1452     SysFreeString(engine->current_source);
1453     engine->current_source = NULL;
1454     if (url)
1455         engine->current_source = SysAllocString(url);
1456
1457     engine->ready_state = MF_MEDIA_ENGINE_READY_HAVE_NOTHING;
1458
1459     IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PURGEQUEUEDEVENTS, 0, 0);
1460
1461     engine->network_state = MF_MEDIA_ENGINE_NETWORK_NO_SOURCE;
1462
1463     if (url || bytestream)
1464     {
1465         flags = MF_RESOLUTION_MEDIASOURCE | MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE;
1466         if (engine->flags & MF_MEDIA_ENGINE_DISABLE_LOCAL_PLUGINS)
1467             flags |= MF_RESOLUTION_DISABLE_LOCAL_PLUGINS;
1468
1469         IMFAttributes_GetUnknown(engine->attributes, &MF_MEDIA_ENGINE_SOURCE_RESOLVER_CONFIG_STORE,
1470                 &IID_IPropertyStore, (void **)&props);
1471         if (bytestream)
1472             hr = IMFSourceResolver_BeginCreateObjectFromByteStream(engine->resolver, bytestream, url, flags,
1473                     props, NULL, &engine->load_handler, (IUnknown *)bytestream);
1474         else
1475             hr = IMFSourceResolver_BeginCreateObjectFromURL(engine->resolver, url, flags, props, NULL,
1476                     &engine->load_handler, NULL);
1477         if (SUCCEEDED(hr))
1478             media_engine_set_flag(engine, FLAGS_ENGINE_SOURCE_PENDING, TRUE);
1479
1480         if (props)
1481             IPropertyStore_Release(props);
1482     }
1483
1484     return hr;
1485 }
1486
1487 static HRESULT WINAPI media_engine_SetSource(IMFMediaEngineEx *iface, BSTR url)
1488 {
1489     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1490     HRESULT hr;
1491
1492     TRACE("%p, %s.\n", iface, debugstr_w(url));
1493
1494     EnterCriticalSection(&engine->cs);
1495
1496     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1497         hr = MF_E_SHUTDOWN;
1498     else
1499         hr = media_engine_set_source(engine, NULL, url);
1500
1501     LeaveCriticalSection(&engine->cs);
1502
1503     return hr;
1504 }
1505
1506 static HRESULT WINAPI media_engine_GetCurrentSource(IMFMediaEngineEx *iface, BSTR *url)
1507 {
1508     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1509     HRESULT hr = S_OK;
1510
1511     TRACE("%p, %p.\n", iface, url);
1512
1513     *url = NULL;
1514
1515     EnterCriticalSection(&engine->cs);
1516
1517     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1518         hr = MF_E_SHUTDOWN;
1519     if (engine->current_source)
1520     {
1521         if (!(*url = SysAllocString(engine->current_source)))
1522             hr = E_OUTOFMEMORY;
1523     }
1524
1525     LeaveCriticalSection(&engine->cs);
1526
1527     return hr;
1528 }
1529
1530 static USHORT WINAPI media_engine_GetNetworkState(IMFMediaEngineEx *iface)
1531 {
1532     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1533
1534     TRACE("%p.\n", iface);
1535
1536     return engine->network_state;
1537 }
1538
1539 static MF_MEDIA_ENGINE_PRELOAD WINAPI media_engine_GetPreload(IMFMediaEngineEx *iface)
1540 {
1541     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1542     MF_MEDIA_ENGINE_PRELOAD preload;
1543
1544     TRACE("%p.\n", iface);
1545
1546     EnterCriticalSection(&engine->cs);
1547     preload = engine->preload;
1548     LeaveCriticalSection(&engine->cs);
1549
1550     return preload;
1551 }
1552
1553 static HRESULT WINAPI media_engine_SetPreload(IMFMediaEngineEx *iface, MF_MEDIA_ENGINE_PRELOAD preload)
1554 {
1555     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1556
1557     TRACE("%p, %d.\n", iface, preload);
1558
1559     EnterCriticalSection(&engine->cs);
1560     engine->preload = preload;
1561     LeaveCriticalSection(&engine->cs);
1562
1563     return S_OK;
1564 }
1565
1566 static HRESULT WINAPI media_engine_GetBuffered(IMFMediaEngineEx *iface, IMFMediaTimeRange **range)
1567 {
1568     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1569     HRESULT hr;
1570
1571     TRACE("%p, %p.\n", iface, range);
1572
1573     if (FAILED(hr = create_time_range(range)))
1574         return hr;
1575
1576     EnterCriticalSection(&engine->cs);
1577
1578     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1579         hr = MF_E_SHUTDOWN;
1580     else if (!isnan(engine->duration))
1581         hr = IMFMediaTimeRange_AddRange(*range, 0.0, engine->duration);
1582
1583     LeaveCriticalSection(&engine->cs);
1584
1585     return hr;
1586 }
1587
1588 static HRESULT WINAPI media_engine_Load(IMFMediaEngineEx *iface)
1589 {
1590     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1591     HRESULT hr = E_NOTIMPL;
1592
1593     FIXME("(%p): stub.\n", iface);
1594
1595     EnterCriticalSection(&engine->cs);
1596
1597     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1598         hr = MF_E_SHUTDOWN;
1599
1600     LeaveCriticalSection(&engine->cs);
1601
1602     return hr;
1603 }
1604
1605 static HRESULT WINAPI media_engine_CanPlayType(IMFMediaEngineEx *iface, BSTR type, MF_MEDIA_ENGINE_CANPLAY *answer)
1606 {
1607     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1608     HRESULT hr = E_NOTIMPL;
1609
1610     FIXME("(%p, %s, %p): stub.\n", iface, debugstr_w(type), answer);
1611
1612     EnterCriticalSection(&engine->cs);
1613
1614     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1615         hr = MF_E_SHUTDOWN;
1616
1617     LeaveCriticalSection(&engine->cs);
1618
1619     return hr;
1620 }
1621
1622 static USHORT WINAPI media_engine_GetReadyState(IMFMediaEngineEx *iface)
1623 {
1624     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1625     unsigned short state;
1626
1627     TRACE("%p.\n", iface);
1628
1629     EnterCriticalSection(&engine->cs);
1630     state = engine->ready_state;
1631     LeaveCriticalSection(&engine->cs);
1632
1633     return state;
1634 }
1635
1636 static BOOL WINAPI media_engine_IsSeeking(IMFMediaEngineEx *iface)
1637 {
1638     FIXME("(%p): stub.\n", iface);
1639
1640     return FALSE;
1641 }
1642
1643 static double WINAPI media_engine_GetCurrentTime(IMFMediaEngineEx *iface)
1644 {
1645     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1646     double ret = 0.0;
1647     MFTIME clocktime;
1648
1649     TRACE("%p.\n", iface);
1650
1651     EnterCriticalSection(&engine->cs);
1652     if (engine->flags & FLAGS_ENGINE_IS_ENDED)
1653     {
1654         ret = engine->duration;
1655     }
1656     else if (SUCCEEDED(IMFPresentationClock_GetTime(engine->clock, &clocktime)))
1657     {
1658         ret = (double)clocktime / 10000000.0;
1659     }
1660     LeaveCriticalSection(&engine->cs);
1661
1662     return ret;
1663 }
1664
1665 static HRESULT WINAPI media_engine_SetCurrentTime(IMFMediaEngineEx *iface, double time)
1666 {
1667     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1668     HRESULT hr = E_NOTIMPL;
1669
1670     FIXME("(%p, %f): stub.\n", iface, time);
1671
1672     EnterCriticalSection(&engine->cs);
1673
1674     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1675         hr = MF_E_SHUTDOWN;
1676
1677     LeaveCriticalSection(&engine->cs);
1678
1679     return hr;
1680 }
1681
1682 static double WINAPI media_engine_GetStartTime(IMFMediaEngineEx *iface)
1683 {
1684     FIXME("(%p): stub.\n", iface);
1685
1686     return 0.0;
1687 }
1688
1689 static double WINAPI media_engine_GetDuration(IMFMediaEngineEx *iface)
1690 {
1691     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1692     double value;
1693
1694     TRACE("%p.\n", iface);
1695
1696     EnterCriticalSection(&engine->cs);
1697     value = engine->duration;
1698     LeaveCriticalSection(&engine->cs);
1699
1700     return value;
1701 }
1702
1703 static BOOL WINAPI media_engine_IsPaused(IMFMediaEngineEx *iface)
1704 {
1705     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1706     BOOL value;
1707
1708     TRACE("%p.\n", iface);
1709
1710     EnterCriticalSection(&engine->cs);
1711     value = !!(engine->flags & FLAGS_ENGINE_PAUSED);
1712     LeaveCriticalSection(&engine->cs);
1713
1714     return value;
1715 }
1716
1717 static double WINAPI media_engine_GetDefaultPlaybackRate(IMFMediaEngineEx *iface)
1718 {
1719     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1720     double rate;
1721
1722     TRACE("%p.\n", iface);
1723
1724     EnterCriticalSection(&engine->cs);
1725     rate = engine->default_playback_rate;
1726     LeaveCriticalSection(&engine->cs);
1727
1728     return rate;
1729 }
1730
1731 static HRESULT WINAPI media_engine_SetDefaultPlaybackRate(IMFMediaEngineEx *iface, double rate)
1732 {
1733     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1734     HRESULT hr = S_OK;
1735
1736     TRACE("%p, %f.\n", iface, rate);
1737
1738     EnterCriticalSection(&engine->cs);
1739     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1740         hr = MF_E_SHUTDOWN;
1741     else if (engine->default_playback_rate != rate)
1742     {
1743         engine->default_playback_rate = rate;
1744         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_RATECHANGE, 0, 0);
1745     }
1746     LeaveCriticalSection(&engine->cs);
1747
1748     return hr;
1749 }
1750
1751 static double WINAPI media_engine_GetPlaybackRate(IMFMediaEngineEx *iface)
1752 {
1753     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1754     double rate;
1755
1756     TRACE("%p.\n", iface);
1757
1758     EnterCriticalSection(&engine->cs);
1759     rate = engine->playback_rate;
1760     LeaveCriticalSection(&engine->cs);
1761
1762     return rate;
1763 }
1764
1765 static HRESULT WINAPI media_engine_SetPlaybackRate(IMFMediaEngineEx *iface, double rate)
1766 {
1767     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1768     HRESULT hr = S_OK;
1769
1770     TRACE("%p, %f.\n", iface, rate);
1771
1772     EnterCriticalSection(&engine->cs);
1773     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1774         hr = MF_E_SHUTDOWN;
1775     else if (engine->playback_rate != rate)
1776     {
1777         engine->playback_rate = rate;
1778         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_RATECHANGE, 0, 0);
1779     }
1780     LeaveCriticalSection(&engine->cs);
1781
1782     return hr;
1783 }
1784
1785 static HRESULT WINAPI media_engine_GetPlayed(IMFMediaEngineEx *iface, IMFMediaTimeRange **played)
1786 {
1787     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1788     HRESULT hr = E_NOTIMPL;
1789
1790     FIXME("(%p, %p): stub.\n", iface, played);
1791
1792     EnterCriticalSection(&engine->cs);
1793
1794     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1795         hr = MF_E_SHUTDOWN;
1796
1797     LeaveCriticalSection(&engine->cs);
1798
1799     return hr;
1800 }
1801
1802 static HRESULT WINAPI media_engine_GetSeekable(IMFMediaEngineEx *iface, IMFMediaTimeRange **seekable)
1803 {
1804     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1805     HRESULT hr = E_NOTIMPL;
1806
1807     FIXME("(%p, %p): stub.\n", iface, seekable);
1808
1809     EnterCriticalSection(&engine->cs);
1810
1811     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1812         hr = MF_E_SHUTDOWN;
1813
1814     LeaveCriticalSection(&engine->cs);
1815
1816     return hr;
1817 }
1818
1819 static BOOL WINAPI media_engine_IsEnded(IMFMediaEngineEx *iface)
1820 {
1821     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1822     BOOL value;
1823
1824     TRACE("%p.\n", iface);
1825
1826     EnterCriticalSection(&engine->cs);
1827     value = !!(engine->flags & FLAGS_ENGINE_IS_ENDED);
1828     LeaveCriticalSection(&engine->cs);
1829
1830     return value;
1831 }
1832
1833 static BOOL WINAPI media_engine_GetAutoPlay(IMFMediaEngineEx *iface)
1834 {
1835     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1836     BOOL value;
1837
1838     TRACE("%p.\n", iface);
1839
1840     EnterCriticalSection(&engine->cs);
1841     value = !!(engine->flags & FLAGS_ENGINE_AUTO_PLAY);
1842     LeaveCriticalSection(&engine->cs);
1843
1844     return value;
1845 }
1846
1847 static HRESULT WINAPI media_engine_SetAutoPlay(IMFMediaEngineEx *iface, BOOL autoplay)
1848 {
1849     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1850
1851     FIXME("(%p, %d): stub.\n", iface, autoplay);
1852
1853     EnterCriticalSection(&engine->cs);
1854     media_engine_set_flag(engine, FLAGS_ENGINE_AUTO_PLAY, autoplay);
1855     LeaveCriticalSection(&engine->cs);
1856
1857     return S_OK;
1858 }
1859
1860 static BOOL WINAPI media_engine_GetLoop(IMFMediaEngineEx *iface)
1861 {
1862     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1863     BOOL value;
1864
1865     TRACE("%p.\n", iface);
1866
1867     EnterCriticalSection(&engine->cs);
1868     value = !!(engine->flags & FLAGS_ENGINE_LOOP);
1869     LeaveCriticalSection(&engine->cs);
1870
1871     return value;
1872 }
1873
1874 static HRESULT WINAPI media_engine_SetLoop(IMFMediaEngineEx *iface, BOOL loop)
1875 {
1876     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1877
1878     FIXME("(%p, %d): stub.\n", iface, loop);
1879
1880     EnterCriticalSection(&engine->cs);
1881     media_engine_set_flag(engine, FLAGS_ENGINE_LOOP, loop);
1882     LeaveCriticalSection(&engine->cs);
1883
1884     return S_OK;
1885 }
1886
1887 static HRESULT WINAPI media_engine_Play(IMFMediaEngineEx *iface)
1888 {
1889     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1890     HRESULT hr = S_OK;
1891
1892     TRACE("%p.\n", iface);
1893
1894     EnterCriticalSection(&engine->cs);
1895
1896     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1897         hr = MF_E_SHUTDOWN;
1898     else
1899     {
1900         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PURGEQUEUEDEVENTS, 0, 0);
1901
1902         if (!(engine->flags & FLAGS_ENGINE_WAITING))
1903         {
1904             media_engine_set_flag(engine, FLAGS_ENGINE_PAUSED | FLAGS_ENGINE_IS_ENDED, FALSE);
1905             IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PLAY, 0, 0);
1906
1907             if (!(engine->flags & FLAGS_ENGINE_SOURCE_PENDING))
1908                 media_engine_start_playback(engine);
1909             else
1910                 media_engine_set_flag(engine, FLAGS_ENGINE_PLAY_PENDING, TRUE);
1911
1912             media_engine_set_flag(engine, FLAGS_ENGINE_WAITING, TRUE);
1913         }
1914
1915         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_WAITING, 0, 0);
1916     }
1917
1918     LeaveCriticalSection(&engine->cs);
1919
1920     return hr;
1921 }
1922
1923 static HRESULT WINAPI media_engine_Pause(IMFMediaEngineEx *iface)
1924 {
1925     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1926     HRESULT hr = S_OK;
1927
1928     TRACE("%p.\n", iface);
1929
1930     EnterCriticalSection(&engine->cs);
1931
1932     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1933         hr = MF_E_SHUTDOWN;
1934     else
1935     {
1936         if (!(engine->flags & FLAGS_ENGINE_PAUSED))
1937         {
1938             media_engine_set_flag(engine, FLAGS_ENGINE_WAITING | FLAGS_ENGINE_IS_ENDED, FALSE);
1939             media_engine_set_flag(engine, FLAGS_ENGINE_PAUSED, TRUE);
1940
1941             IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_TIMEUPDATE, 0, 0);
1942             IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PAUSE, 0, 0);
1943         }
1944
1945         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_PURGEQUEUEDEVENTS, 0, 0);
1946     }
1947
1948     LeaveCriticalSection(&engine->cs);
1949
1950     return hr;
1951 }
1952
1953 static BOOL WINAPI media_engine_GetMuted(IMFMediaEngineEx *iface)
1954 {
1955     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1956     BOOL ret;
1957
1958     TRACE("%p.\n", iface);
1959
1960     EnterCriticalSection(&engine->cs);
1961     ret = !!(engine->flags & FLAGS_ENGINE_MUTED);
1962     LeaveCriticalSection(&engine->cs);
1963
1964     return ret;
1965 }
1966
1967 static HRESULT WINAPI media_engine_SetMuted(IMFMediaEngineEx *iface, BOOL muted)
1968 {
1969     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1970     HRESULT hr = S_OK;
1971
1972     TRACE("%p, %d.\n", iface, muted);
1973
1974     EnterCriticalSection(&engine->cs);
1975     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
1976         hr = MF_E_SHUTDOWN;
1977     else if (!!(engine->flags & FLAGS_ENGINE_MUTED) ^ !!muted)
1978     {
1979         media_engine_set_flag(engine, FLAGS_ENGINE_MUTED, muted);
1980         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_VOLUMECHANGE, 0, 0);
1981     }
1982     LeaveCriticalSection(&engine->cs);
1983
1984     return hr;
1985 }
1986
1987 static double WINAPI media_engine_GetVolume(IMFMediaEngineEx *iface)
1988 {
1989     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
1990     double volume;
1991
1992     TRACE("%p.\n", iface);
1993
1994     EnterCriticalSection(&engine->cs);
1995     volume = engine->volume;
1996     LeaveCriticalSection(&engine->cs);
1997
1998     return volume;
1999 }
2000
2001 static HRESULT WINAPI media_engine_SetVolume(IMFMediaEngineEx *iface, double volume)
2002 {
2003     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2004     HRESULT hr = S_OK;
2005
2006     TRACE("%p, %f.\n", iface, volume);
2007
2008     EnterCriticalSection(&engine->cs);
2009     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2010         hr = MF_E_SHUTDOWN;
2011     else if (volume != engine->volume)
2012     {
2013         engine->volume = volume;
2014         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_VOLUMECHANGE, 0, 0);
2015     }
2016     LeaveCriticalSection(&engine->cs);
2017
2018     return hr;
2019 }
2020
2021 static BOOL WINAPI media_engine_HasVideo(IMFMediaEngineEx *iface)
2022 {
2023     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2024     BOOL value;
2025
2026     TRACE("%p.\n", iface);
2027
2028     EnterCriticalSection(&engine->cs);
2029     value = !!(engine->flags & FLAGS_ENGINE_HAS_VIDEO);
2030     LeaveCriticalSection(&engine->cs);
2031
2032     return value;
2033 }
2034
2035 static BOOL WINAPI media_engine_HasAudio(IMFMediaEngineEx *iface)
2036 {
2037     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2038     BOOL value;
2039
2040     TRACE("%p.\n", iface);
2041
2042     EnterCriticalSection(&engine->cs);
2043     value = !!(engine->flags & FLAGS_ENGINE_HAS_AUDIO);
2044     LeaveCriticalSection(&engine->cs);
2045
2046     return value;
2047 }
2048
2049 static HRESULT WINAPI media_engine_GetNativeVideoSize(IMFMediaEngineEx *iface, DWORD *cx, DWORD *cy)
2050 {
2051     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2052     HRESULT hr = S_OK;
2053
2054     TRACE("%p, %p, %p.\n", iface, cx, cy);
2055
2056     if (!cx && !cy)
2057         return E_INVALIDARG;
2058
2059     EnterCriticalSection(&engine->cs);
2060
2061     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2062         hr = MF_E_SHUTDOWN;
2063     else if (!engine->video_frame.size.cx && !engine->video_frame.size.cy)
2064         hr = E_FAIL;
2065     else
2066     {
2067         if (cx) *cx = engine->video_frame.size.cx;
2068         if (cy) *cy = engine->video_frame.size.cy;
2069     }
2070
2071     LeaveCriticalSection(&engine->cs);
2072
2073     return hr;
2074 }
2075
2076 static HRESULT WINAPI media_engine_GetVideoAspectRatio(IMFMediaEngineEx *iface, DWORD *cx, DWORD *cy)
2077 {
2078     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2079     HRESULT hr = S_OK;
2080
2081     TRACE("%p, %p, %p.\n", iface, cx, cy);
2082
2083     if (!cx && !cy)
2084         return E_INVALIDARG;
2085
2086     EnterCriticalSection(&engine->cs);
2087
2088     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2089         hr = MF_E_SHUTDOWN;
2090     else if (!engine->video_frame.size.cx && !engine->video_frame.size.cy)
2091         hr = E_FAIL;
2092     else
2093     {
2094         if (cx) *cx = engine->video_frame.ratio.cx;
2095         if (cy) *cy = engine->video_frame.ratio.cy;
2096     }
2097
2098     LeaveCriticalSection(&engine->cs);
2099
2100     return hr;
2101 }
2102
2103 static HRESULT WINAPI media_engine_Shutdown(IMFMediaEngineEx *iface)
2104 {
2105     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2106     HRESULT hr = S_OK;
2107
2108     FIXME("(%p): stub.\n", iface);
2109
2110     EnterCriticalSection(&engine->cs);
2111     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2112         hr = MF_E_SHUTDOWN;
2113     else
2114     {
2115         media_engine_set_flag(engine, FLAGS_ENGINE_SHUT_DOWN, TRUE);
2116         media_engine_clear_presentation(engine);
2117         IMFMediaSession_Shutdown(engine->session);
2118     }
2119     LeaveCriticalSection(&engine->cs);
2120
2121     return hr;
2122 }
2123
2124 static void set_rect(struct rect *rect, float left, float top, float right, float bottom)
2125 {
2126     rect->left = left;
2127     rect->top = top;
2128     rect->right = right;
2129     rect->bottom = bottom;
2130 }
2131
2132 static void media_engine_adjust_destination_for_ratio(const struct media_engine *engine,
2133         struct rect *src_n, struct rect *dst)
2134 {
2135     float dst_width = dst->right - dst->left, dst_height = dst->bottom - dst->top;
2136     D3D11_TEXTURE2D_DESC source_desc;
2137     float src_width, src_height;
2138     struct rect src;
2139
2140     ID3D11Texture2D_GetDesc(engine->video_frame.d3d11.source, &source_desc);
2141     set_rect(&src, src_n->left * source_desc.Width, src_n->top * source_desc.Height,
2142             src_n->right * source_desc.Width, src_n->bottom * source_desc.Height);
2143
2144     src_width = src.right - src.left;
2145     src_height = src.bottom - src.top;
2146
2147     if (src_width * dst_height > dst_width * src_height)
2148     {
2149         /* src is "wider" than dst. */
2150         float dst_center = (dst->top + dst->bottom) / 2.0f;
2151         float scaled_height = src_height * dst_width / src_width;
2152
2153         dst->top = dst_center - scaled_height / 2.0f;
2154         dst->bottom = dst->top + scaled_height;
2155     }
2156     else if (src_width * dst_height < dst_width * src_height)
2157     {
2158         /* src is "taller" than dst. */
2159         float dst_center = (dst->left + dst->right) / 2.0f;
2160         float scaled_width = src_width * dst_height / src_height;
2161
2162         dst->left = dst_center - scaled_width / 2.0f;
2163         dst->right = dst->left + scaled_width;
2164     }
2165 }
2166
2167 static void media_engine_update_d3d11_frame_surface(ID3D11DeviceContext *context, struct media_engine *engine)
2168 {
2169     D3D11_TEXTURE2D_DESC surface_desc;
2170
2171     if (!(engine->flags & FLAGS_ENGINE_NEW_FRAME))
2172         return;
2173
2174     ID3D11Texture2D_GetDesc(engine->video_frame.d3d11.source, &surface_desc);
2175
2176     switch (surface_desc.Format)
2177     {
2178     case DXGI_FORMAT_B8G8R8A8_UNORM:
2179     case DXGI_FORMAT_B8G8R8X8_UNORM:
2180         surface_desc.Width *= 4;
2181         break;
2182     default:
2183         FIXME("Unsupported format %#x.\n", surface_desc.Format);
2184         surface_desc.Width = 0;
2185     }
2186
2187     if (engine->video_frame.buffer_size == surface_desc.Width * surface_desc.Height)
2188     {
2189         ID3D11DeviceContext_UpdateSubresource(context, (ID3D11Resource *)engine->video_frame.d3d11.source,
2190                 0, NULL, engine->video_frame.buffer, surface_desc.Width, 0);
2191     }
2192
2193     media_engine_set_flag(engine, FLAGS_ENGINE_NEW_FRAME, FALSE);
2194 }
2195
2196 static HRESULT media_engine_transfer_to_d3d11_texture(struct media_engine *engine, ID3D11Texture2D *texture,
2197         const MFVideoNormalizedRect *src_rect, const RECT *dst_rect, const MFARGB *color)
2198 {
2199     static const float black[] = {0.0f, 0.0f, 0.0f, 0.0f};
2200     ID3D11Device *device, *dst_device;
2201     ID3D11DeviceContext *context;
2202     ID3D11RenderTargetView *rtv;
2203     unsigned int stride, offset;
2204     D3D11_TEXTURE2D_DESC desc;
2205     BOOL device_mismatch;
2206     struct vec3 quad[4];
2207     D3D11_VIEWPORT vp;
2208     struct rect src, dst;
2209     struct color backcolor;
2210     HRESULT hr;
2211     RECT rect;
2212
2213     if (FAILED(hr = media_engine_lock_d3d_device(engine, &device)))
2214         return hr;
2215
2216     if (FAILED(hr = media_engine_create_d3d11_video_frame_resources(engine, device)))
2217     {
2218         WARN("Failed to create d3d resources, hr %#lx.\n", hr);
2219         goto done;
2220     }
2221
2222     ID3D11Texture2D_GetDevice(texture, &dst_device);
2223     device_mismatch = device != dst_device;
2224     ID3D11Device_Release(dst_device);
2225
2226     if (device_mismatch)
2227     {
2228         WARN("Destination target from different device.\n");
2229         hr = E_UNEXPECTED;
2230         goto done;
2231     }
2232
2233     ID3D11Texture2D_GetDesc(texture, &desc);
2234
2235     if (FAILED(hr = ID3D11Device_CreateRenderTargetView(device, (ID3D11Resource *)texture, NULL, &rtv)))
2236     {
2237         WARN("Failed to create an rtv, hr %#lx.\n", hr);
2238         goto done;
2239     }
2240
2241     ID3D11Device_GetImmediateContext(device, &context);
2242
2243     /* Whole destination is cleared, regardless of specified rectangle. */
2244     ID3D11DeviceContext_ClearRenderTargetView(context, rtv, black);
2245
2246     if (dst_rect)
2247     {
2248         rect.left = max(0, dst_rect->left);
2249         rect.top = max(0, dst_rect->top);
2250         rect.right = min(desc.Width, dst_rect->right);
2251         rect.bottom = min(desc.Height, dst_rect->bottom);
2252
2253         quad[0].x = 2.0f * rect.left / desc.Width - 1.0f;
2254         quad[0].y = -2.0f * rect.bottom / desc.Height + 1.0f;
2255         quad[0].z = 0.0f;
2256
2257         quad[1].x = quad[0].x;
2258         quad[1].y = -2.0f * rect.top / desc.Height + 1.0f;
2259         quad[1].z = 0.0f;
2260
2261         quad[2].x = 2.0f * rect.right / desc.Width - 1.0f;
2262         quad[2].y = quad[0].y;
2263         quad[2].z = 0.0f;
2264
2265         quad[3].x = quad[2].x;
2266         quad[3].y = quad[1].y;
2267         quad[3].z = 0.0f;
2268
2269         set_rect(&dst, dst_rect->left, dst_rect->top, dst_rect->right, dst_rect->bottom);
2270     }
2271     else
2272     {
2273         memcpy(quad, fullquad, sizeof(quad));
2274         set_rect(&dst, 0.0f, 0.0f, desc.Width, desc.Height);
2275     }
2276
2277     if (src_rect)
2278         memcpy(&src, src_rect, sizeof(src));
2279     else
2280         set_rect(&src, 0.0f, 0.0f, 1.0f, 1.0f);
2281
2282     media_engine_adjust_destination_for_ratio(engine, &src, &dst);
2283
2284     if (memcmp(quad, engine->video_frame.d3d11.quad, sizeof(quad)))
2285     {
2286         memcpy(engine->video_frame.d3d11.quad, quad, sizeof(quad));
2287         ID3D11DeviceContext_UpdateSubresource(context, (ID3D11Resource *)engine->video_frame.d3d11.vb, 0, NULL, quad, 0, 0);
2288     }
2289
2290     if (color)
2291     {
2292         backcolor.r = color->rgbRed / 255.0f;
2293         backcolor.g = color->rgbGreen / 255.0f;
2294         backcolor.b = color->rgbBlue / 255.0f;
2295         backcolor.a = color->rgbAlpha / 255.0f;
2296     }
2297     else
2298         memcpy(&backcolor, black, sizeof(backcolor));
2299
2300     if (memcmp(&dst, &engine->video_frame.d3d11.cb.dst, sizeof(dst)) ||
2301             memcmp(&src, &engine->video_frame.d3d11.cb.src, sizeof(src)) ||
2302             memcmp(&backcolor, &engine->video_frame.d3d11.cb.backcolor, sizeof(backcolor)))
2303     {
2304         memcpy(&engine->video_frame.d3d11.cb.dst, &dst, sizeof(dst));
2305         memcpy(&engine->video_frame.d3d11.cb.src, &src, sizeof(src));
2306         memcpy(&engine->video_frame.d3d11.cb.backcolor, &backcolor, sizeof(backcolor));
2307
2308         ID3D11DeviceContext_UpdateSubresource(context, (ID3D11Resource *)engine->video_frame.d3d11.ps_cb, 0, NULL,
2309                 &engine->video_frame.d3d11.cb, 0, 0);
2310     }
2311
2312     /* Update with new frame contents */
2313     media_engine_update_d3d11_frame_surface(context, engine);
2314
2315     vp.TopLeftX = 0.0f;
2316     vp.TopLeftY = 0.0f;
2317     vp.Width = desc.Width;
2318     vp.Height = desc.Height;
2319     vp.MinDepth = 0.0f;
2320     vp.MaxDepth = 1.0f;
2321     ID3D11DeviceContext_RSSetViewports(context, 1, &vp);
2322
2323     ID3D11DeviceContext_IASetInputLayout(context, engine->video_frame.d3d11.input_layout);
2324     ID3D11DeviceContext_IASetPrimitiveTopology(context, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
2325     stride = sizeof(*quad);
2326     offset = 0;
2327     ID3D11DeviceContext_IASetVertexBuffers(context, 0, 1, &engine->video_frame.d3d11.vb, &stride, &offset);
2328     ID3D11DeviceContext_VSSetShader(context, engine->video_frame.d3d11.vs, NULL, 0);
2329     ID3D11DeviceContext_PSSetShader(context, engine->video_frame.d3d11.ps, NULL, 0);
2330     ID3D11DeviceContext_PSSetShaderResources(context, 0, 1, &engine->video_frame.d3d11.srv);
2331     ID3D11DeviceContext_PSSetConstantBuffers(context, 0, 1, &engine->video_frame.d3d11.ps_cb);
2332     ID3D11DeviceContext_PSSetSamplers(context, 0, 1, &engine->video_frame.d3d11.sampler);
2333     ID3D11DeviceContext_OMSetRenderTargets(context, 1, &rtv, NULL);
2334
2335     ID3D11DeviceContext_Draw(context, 4, 0);
2336
2337     ID3D11RenderTargetView_Release(rtv);
2338     ID3D11DeviceContext_Release(context);
2339
2340 done:
2341     media_engine_unlock_d3d_device(engine, device);
2342
2343     return hr;
2344 }
2345
2346 static HRESULT WINAPI media_engine_TransferVideoFrame(IMFMediaEngineEx *iface, IUnknown *surface,
2347         const MFVideoNormalizedRect *src_rect, const RECT *dst_rect, const MFARGB *color)
2348 {
2349     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2350     ID3D11Texture2D *texture;
2351     HRESULT hr = E_NOINTERFACE;
2352
2353     TRACE("%p, %p, %s, %s, %p.\n", iface, surface, src_rect ? wine_dbg_sprintf("(%f,%f)-(%f,%f)",
2354             src_rect->left, src_rect->top, src_rect->right, src_rect->bottom) : "(null)",
2355             wine_dbgstr_rect(dst_rect), color);
2356
2357     EnterCriticalSection(&engine->cs);
2358
2359     if (SUCCEEDED(IUnknown_QueryInterface(surface, &IID_ID3D11Texture2D, (void **)&texture)))
2360     {
2361         hr = media_engine_transfer_to_d3d11_texture(engine, texture, src_rect, dst_rect, color);
2362         ID3D11Texture2D_Release(texture);
2363     }
2364     else
2365     {
2366         FIXME("Unsupported destination type.\n");
2367     }
2368
2369     LeaveCriticalSection(&engine->cs);
2370
2371     return hr;
2372 }
2373
2374 static HRESULT WINAPI media_engine_OnVideoStreamTick(IMFMediaEngineEx *iface, LONGLONG *pts)
2375 {
2376     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2377     HRESULT hr;
2378
2379     TRACE("%p, %p.\n", iface, pts);
2380
2381     EnterCriticalSection(&engine->cs);
2382
2383     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2384         hr = MF_E_SHUTDOWN;
2385     else if (!pts)
2386         hr = E_POINTER;
2387     else
2388     {
2389         *pts = engine->video_frame.pts;
2390         hr = *pts == MINLONGLONG ? S_FALSE : S_OK;
2391     }
2392
2393     LeaveCriticalSection(&engine->cs);
2394
2395     return hr;
2396 }
2397
2398 static HRESULT WINAPI media_engine_SetSourceFromByteStream(IMFMediaEngineEx *iface, IMFByteStream *bytestream, BSTR url)
2399 {
2400     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2401     HRESULT hr;
2402
2403     TRACE("%p, %p, %s.\n", iface, bytestream, debugstr_w(url));
2404
2405     EnterCriticalSection(&engine->cs);
2406
2407     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2408         hr = MF_E_SHUTDOWN;
2409     else if (!bytestream || !url)
2410         hr = E_POINTER;
2411     else
2412         hr = media_engine_set_source(engine, bytestream, url);
2413
2414     LeaveCriticalSection(&engine->cs);
2415
2416     return hr;
2417 }
2418
2419 static HRESULT WINAPI media_engine_GetStatistics(IMFMediaEngineEx *iface, MF_MEDIA_ENGINE_STATISTIC stat_id, PROPVARIANT *stat)
2420 {
2421     FIXME("%p, %x, %p stub.\n", iface, stat_id, stat);
2422
2423     return E_NOTIMPL;
2424 }
2425
2426 static HRESULT WINAPI media_engine_UpdateVideoStream(IMFMediaEngineEx *iface, const MFVideoNormalizedRect *src,
2427         const RECT *dst, const MFARGB *border_color)
2428 {
2429     FIXME("%p, %p, %p, %p stub.\n", iface, src, dst, border_color);
2430
2431     return E_NOTIMPL;
2432 }
2433
2434 static double WINAPI media_engine_GetBalance(IMFMediaEngineEx *iface)
2435 {
2436     FIXME("%p stub.\n", iface);
2437
2438     return 0.0;
2439 }
2440
2441 static HRESULT WINAPI media_engine_SetBalance(IMFMediaEngineEx *iface, double balance)
2442 {
2443     FIXME("%p, %f stub.\n", iface, balance);
2444
2445     return E_NOTIMPL;
2446 }
2447
2448 static BOOL WINAPI media_engine_IsPlaybackRateSupported(IMFMediaEngineEx *iface, double rate)
2449 {
2450     FIXME("%p, %f stub.\n", iface, rate);
2451
2452     return FALSE;
2453 }
2454
2455 static HRESULT WINAPI media_engine_FrameStep(IMFMediaEngineEx *iface, BOOL forward)
2456 {
2457     FIXME("%p, %d stub.\n", iface, forward);
2458
2459     return E_NOTIMPL;
2460 }
2461
2462 static HRESULT WINAPI media_engine_GetResourceCharacteristics(IMFMediaEngineEx *iface, DWORD *flags)
2463 {
2464     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2465     HRESULT hr = E_FAIL;
2466
2467     TRACE("%p, %p.\n", iface, flags);
2468
2469     EnterCriticalSection(&engine->cs);
2470     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2471         hr = MF_E_SHUTDOWN;
2472     else if (engine->presentation.source)
2473         hr = IMFMediaSource_GetCharacteristics(engine->presentation.source, flags);
2474     LeaveCriticalSection(&engine->cs);
2475
2476     return hr;
2477 }
2478
2479 static HRESULT WINAPI media_engine_GetPresentationAttribute(IMFMediaEngineEx *iface, REFGUID attribute,
2480         PROPVARIANT *value)
2481 {
2482     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2483     HRESULT hr = E_FAIL;
2484
2485     TRACE("%p, %s, %p.\n", iface, debugstr_guid(attribute), value);
2486
2487     EnterCriticalSection(&engine->cs);
2488     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2489         hr = MF_E_SHUTDOWN;
2490     else if (engine->presentation.pd)
2491         hr = IMFPresentationDescriptor_GetItem(engine->presentation.pd, attribute, value);
2492     LeaveCriticalSection(&engine->cs);
2493
2494     return hr;
2495 }
2496
2497 static HRESULT WINAPI media_engine_GetNumberOfStreams(IMFMediaEngineEx *iface, DWORD *stream_count)
2498 {
2499     FIXME("%p, %p stub.\n", iface, stream_count);
2500
2501     return E_NOTIMPL;
2502 }
2503
2504 static HRESULT WINAPI media_engine_GetStreamAttribute(IMFMediaEngineEx *iface, DWORD stream_index, REFGUID attribute,
2505         PROPVARIANT *value)
2506 {
2507     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2508     IMFStreamDescriptor *sd;
2509     HRESULT hr = E_FAIL;
2510     BOOL selected;
2511
2512     TRACE("%p, %ld, %s, %p.\n", iface, stream_index, debugstr_guid(attribute), value);
2513
2514     EnterCriticalSection(&engine->cs);
2515     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2516         hr = MF_E_SHUTDOWN;
2517     else if (engine->presentation.pd)
2518     {
2519         if (SUCCEEDED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(engine->presentation.pd,
2520                 stream_index, &selected, &sd)))
2521         {
2522             hr = IMFStreamDescriptor_GetItem(sd, attribute, value);
2523             IMFStreamDescriptor_Release(sd);
2524         }
2525     }
2526     LeaveCriticalSection(&engine->cs);
2527
2528     return hr;
2529 }
2530
2531 static HRESULT WINAPI media_engine_GetStreamSelection(IMFMediaEngineEx *iface, DWORD stream_index, BOOL *enabled)
2532 {
2533     FIXME("%p, %ld, %p stub.\n", iface, stream_index, enabled);
2534
2535     return E_NOTIMPL;
2536 }
2537
2538 static HRESULT WINAPI media_engine_SetStreamSelection(IMFMediaEngineEx *iface, DWORD stream_index, BOOL enabled)
2539 {
2540     FIXME("%p, %ld, %d stub.\n", iface, stream_index, enabled);
2541
2542     return E_NOTIMPL;
2543 }
2544
2545 static HRESULT WINAPI media_engine_ApplyStreamSelections(IMFMediaEngineEx *iface)
2546 {
2547     FIXME("%p stub.\n", iface);
2548
2549     return E_NOTIMPL;
2550 }
2551
2552 static HRESULT WINAPI media_engine_IsProtected(IMFMediaEngineEx *iface, BOOL *protected)
2553 {
2554     FIXME("%p, %p stub.\n", iface, protected);
2555
2556     return E_NOTIMPL;
2557 }
2558
2559 static HRESULT WINAPI media_engine_InsertVideoEffect(IMFMediaEngineEx *iface, IUnknown *effect, BOOL is_optional)
2560 {
2561     FIXME("%p, %p, %d stub.\n", iface, effect, is_optional);
2562
2563     return E_NOTIMPL;
2564 }
2565
2566 static HRESULT WINAPI media_engine_InsertAudioEffect(IMFMediaEngineEx *iface, IUnknown *effect, BOOL is_optional)
2567 {
2568     FIXME("%p, %p, %d stub.\n", iface, effect, is_optional);
2569
2570     return E_NOTIMPL;
2571 }
2572
2573 static HRESULT WINAPI media_engine_RemoveAllEffects(IMFMediaEngineEx *iface)
2574 {
2575     FIXME("%p stub.\n", iface);
2576
2577     return E_NOTIMPL;
2578 }
2579
2580 static HRESULT WINAPI media_engine_SetTimelineMarkerTimer(IMFMediaEngineEx *iface, double timeout)
2581 {
2582     FIXME("%p, %f stub.\n", iface, timeout);
2583
2584     return E_NOTIMPL;
2585 }
2586
2587 static HRESULT WINAPI media_engine_GetTimelineMarkerTimer(IMFMediaEngineEx *iface, double *timeout)
2588 {
2589     FIXME("%p, %p stub.\n", iface, timeout);
2590
2591     return E_NOTIMPL;
2592 }
2593
2594 static HRESULT WINAPI media_engine_CancelTimelineMarkerTimer(IMFMediaEngineEx *iface)
2595 {
2596     FIXME("%p stub.\n", iface);
2597
2598     return E_NOTIMPL;
2599 }
2600
2601 static BOOL WINAPI media_engine_IsStereo3D(IMFMediaEngineEx *iface)
2602 {
2603     FIXME("%p stub.\n", iface);
2604
2605     return FALSE;
2606 }
2607
2608 static HRESULT WINAPI media_engine_GetStereo3DFramePackingMode(IMFMediaEngineEx *iface, MF_MEDIA_ENGINE_S3D_PACKING_MODE *mode)
2609 {
2610     FIXME("%p, %p stub.\n", iface, mode);
2611
2612     return E_NOTIMPL;
2613 }
2614
2615 static HRESULT WINAPI media_engine_SetStereo3DFramePackingMode(IMFMediaEngineEx *iface, MF_MEDIA_ENGINE_S3D_PACKING_MODE mode)
2616 {
2617     FIXME("%p, %#x stub.\n", iface, mode);
2618
2619     return E_NOTIMPL;
2620 }
2621
2622 static HRESULT WINAPI media_engine_GetStereo3DRenderMode(IMFMediaEngineEx *iface, MF3DVideoOutputType *output_type)
2623 {
2624     FIXME("%p, %p stub.\n", iface, output_type);
2625
2626     return E_NOTIMPL;
2627 }
2628
2629 static HRESULT WINAPI media_engine_SetStereo3DRenderMode(IMFMediaEngineEx *iface, MF3DVideoOutputType output_type)
2630 {
2631     FIXME("%p, %#x stub.\n", iface, output_type);
2632
2633     return E_NOTIMPL;
2634 }
2635
2636 static HRESULT WINAPI media_engine_EnableWindowlessSwapchainMode(IMFMediaEngineEx *iface, BOOL enable)
2637 {
2638     FIXME("%p, %d stub.\n", iface, enable);
2639
2640     return E_NOTIMPL;
2641 }
2642
2643 static HRESULT WINAPI media_engine_GetVideoSwapchainHandle(IMFMediaEngineEx *iface, HANDLE *swapchain)
2644 {
2645     FIXME("%p, %p stub.\n", iface, swapchain);
2646
2647     return E_NOTIMPL;
2648 }
2649
2650 static HRESULT WINAPI media_engine_EnableHorizontalMirrorMode(IMFMediaEngineEx *iface, BOOL enable)
2651 {
2652     FIXME("%p, %d stub.\n", iface, enable);
2653
2654     return E_NOTIMPL;
2655 }
2656
2657 static HRESULT WINAPI media_engine_GetAudioStreamCategory(IMFMediaEngineEx *iface, UINT32 *category)
2658 {
2659     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2660     HRESULT hr;
2661
2662     TRACE("%p, %p.\n", iface, category);
2663
2664     EnterCriticalSection(&engine->cs);
2665
2666     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2667         hr = MF_E_SHUTDOWN;
2668     else
2669         hr = IMFAttributes_GetUINT32(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_CATEGORY, category);
2670
2671     LeaveCriticalSection(&engine->cs);
2672
2673     return hr;
2674 }
2675
2676 static HRESULT WINAPI media_engine_SetAudioStreamCategory(IMFMediaEngineEx *iface, UINT32 category)
2677 {
2678     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2679     HRESULT hr;
2680
2681     TRACE("%p, %u.\n", iface, category);
2682
2683     EnterCriticalSection(&engine->cs);
2684
2685     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2686         hr = MF_E_SHUTDOWN;
2687     else
2688         hr = IMFAttributes_SetUINT32(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_CATEGORY, category);
2689
2690     LeaveCriticalSection(&engine->cs);
2691
2692     return hr;
2693 }
2694
2695 static HRESULT WINAPI media_engine_GetAudioEndpointRole(IMFMediaEngineEx *iface, UINT32 *role)
2696 {
2697     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2698     HRESULT hr;
2699
2700     TRACE("%p, %p.\n", iface, role);
2701
2702     EnterCriticalSection(&engine->cs);
2703
2704     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2705         hr = MF_E_SHUTDOWN;
2706     else
2707         hr = IMFAttributes_GetUINT32(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_ENDPOINT_ROLE, role);
2708
2709     LeaveCriticalSection(&engine->cs);
2710
2711     return hr;
2712 }
2713
2714 static HRESULT WINAPI media_engine_SetAudioEndpointRole(IMFMediaEngineEx *iface, UINT32 role)
2715 {
2716     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2717     HRESULT hr;
2718
2719     TRACE("%p, %u.\n", iface, role);
2720
2721     EnterCriticalSection(&engine->cs);
2722
2723     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2724         hr = MF_E_SHUTDOWN;
2725     else
2726         hr = IMFAttributes_SetUINT32(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_ENDPOINT_ROLE, role);
2727
2728     LeaveCriticalSection(&engine->cs);
2729
2730     return hr;
2731 }
2732
2733 static HRESULT WINAPI media_engine_GetRealTimeMode(IMFMediaEngineEx *iface, BOOL *enabled)
2734 {
2735     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2736     HRESULT hr = S_OK;
2737
2738     TRACE("%p, %p.\n", iface, enabled);
2739
2740     EnterCriticalSection(&engine->cs);
2741     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2742         hr = MF_E_SHUTDOWN;
2743     else
2744         *enabled = !!(engine->flags & MF_MEDIA_ENGINE_REAL_TIME_MODE);
2745     LeaveCriticalSection(&engine->cs);
2746
2747     return hr;
2748 }
2749
2750 static HRESULT WINAPI media_engine_SetRealTimeMode(IMFMediaEngineEx *iface, BOOL enable)
2751 {
2752     struct media_engine *engine = impl_from_IMFMediaEngineEx(iface);
2753     HRESULT hr = S_OK;
2754
2755     TRACE("%p, %d.\n", iface, enable);
2756
2757     EnterCriticalSection(&engine->cs);
2758     if (engine->flags & FLAGS_ENGINE_SHUT_DOWN)
2759         hr = MF_E_SHUTDOWN;
2760     else
2761         media_engine_set_flag(engine, MF_MEDIA_ENGINE_REAL_TIME_MODE, enable);
2762     LeaveCriticalSection(&engine->cs);
2763
2764     return hr;
2765 }
2766
2767 static HRESULT WINAPI media_engine_SetCurrentTimeEx(IMFMediaEngineEx *iface, double seektime, MF_MEDIA_ENGINE_SEEK_MODE mode)
2768 {
2769     FIXME("%p, %f, %#x stub.\n", iface, seektime, mode);
2770
2771     return E_NOTIMPL;
2772 }
2773
2774 static HRESULT WINAPI media_engine_EnableTimeUpdateTimer(IMFMediaEngineEx *iface, BOOL enable)
2775 {
2776     FIXME("%p, %d stub.\n", iface, enable);
2777
2778     return E_NOTIMPL;
2779 }
2780
2781 static const IMFMediaEngineExVtbl media_engine_vtbl =
2782 {
2783     media_engine_QueryInterface,
2784     media_engine_AddRef,
2785     media_engine_Release,
2786     media_engine_GetError,
2787     media_engine_SetErrorCode,
2788     media_engine_SetSourceElements,
2789     media_engine_SetSource,
2790     media_engine_GetCurrentSource,
2791     media_engine_GetNetworkState,
2792     media_engine_GetPreload,
2793     media_engine_SetPreload,
2794     media_engine_GetBuffered,
2795     media_engine_Load,
2796     media_engine_CanPlayType,
2797     media_engine_GetReadyState,
2798     media_engine_IsSeeking,
2799     media_engine_GetCurrentTime,
2800     media_engine_SetCurrentTime,
2801     media_engine_GetStartTime,
2802     media_engine_GetDuration,
2803     media_engine_IsPaused,
2804     media_engine_GetDefaultPlaybackRate,
2805     media_engine_SetDefaultPlaybackRate,
2806     media_engine_GetPlaybackRate,
2807     media_engine_SetPlaybackRate,
2808     media_engine_GetPlayed,
2809     media_engine_GetSeekable,
2810     media_engine_IsEnded,
2811     media_engine_GetAutoPlay,
2812     media_engine_SetAutoPlay,
2813     media_engine_GetLoop,
2814     media_engine_SetLoop,
2815     media_engine_Play,
2816     media_engine_Pause,
2817     media_engine_GetMuted,
2818     media_engine_SetMuted,
2819     media_engine_GetVolume,
2820     media_engine_SetVolume,
2821     media_engine_HasVideo,
2822     media_engine_HasAudio,
2823     media_engine_GetNativeVideoSize,
2824     media_engine_GetVideoAspectRatio,
2825     media_engine_Shutdown,
2826     media_engine_TransferVideoFrame,
2827     media_engine_OnVideoStreamTick,
2828     media_engine_SetSourceFromByteStream,
2829     media_engine_GetStatistics,
2830     media_engine_UpdateVideoStream,
2831     media_engine_GetBalance,
2832     media_engine_SetBalance,
2833     media_engine_IsPlaybackRateSupported,
2834     media_engine_FrameStep,
2835     media_engine_GetResourceCharacteristics,
2836     media_engine_GetPresentationAttribute,
2837     media_engine_GetNumberOfStreams,
2838     media_engine_GetStreamAttribute,
2839     media_engine_GetStreamSelection,
2840     media_engine_SetStreamSelection,
2841     media_engine_ApplyStreamSelections,
2842     media_engine_IsProtected,
2843     media_engine_InsertVideoEffect,
2844     media_engine_InsertAudioEffect,
2845     media_engine_RemoveAllEffects,
2846     media_engine_SetTimelineMarkerTimer,
2847     media_engine_GetTimelineMarkerTimer,
2848     media_engine_CancelTimelineMarkerTimer,
2849     media_engine_IsStereo3D,
2850     media_engine_GetStereo3DFramePackingMode,
2851     media_engine_SetStereo3DFramePackingMode,
2852     media_engine_GetStereo3DRenderMode,
2853     media_engine_SetStereo3DRenderMode,
2854     media_engine_EnableWindowlessSwapchainMode,
2855     media_engine_GetVideoSwapchainHandle,
2856     media_engine_EnableHorizontalMirrorMode,
2857     media_engine_GetAudioStreamCategory,
2858     media_engine_SetAudioStreamCategory,
2859     media_engine_GetAudioEndpointRole,
2860     media_engine_SetAudioEndpointRole,
2861     media_engine_GetRealTimeMode,
2862     media_engine_SetRealTimeMode,
2863     media_engine_SetCurrentTimeEx,
2864     media_engine_EnableTimeUpdateTimer,
2865 };
2866
2867 static HRESULT WINAPI media_engine_gs_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
2868 {
2869     struct media_engine *engine = impl_from_IMFGetService(iface);
2870     return IMFMediaEngineEx_QueryInterface(&engine->IMFMediaEngineEx_iface, riid, obj);
2871 }
2872
2873 static ULONG WINAPI media_engine_gs_AddRef(IMFGetService *iface)
2874 {
2875     struct media_engine *engine = impl_from_IMFGetService(iface);
2876     return IMFMediaEngineEx_AddRef(&engine->IMFMediaEngineEx_iface);
2877 }
2878
2879 static ULONG WINAPI media_engine_gs_Release(IMFGetService *iface)
2880 {
2881     struct media_engine *engine = impl_from_IMFGetService(iface);
2882     return IMFMediaEngineEx_Release(&engine->IMFMediaEngineEx_iface);
2883 }
2884
2885 static HRESULT WINAPI media_engine_gs_GetService(IMFGetService *iface, REFGUID service,
2886         REFIID riid, void **object)
2887 {
2888     FIXME("%p, %s, %s, %p stub.\n", iface, debugstr_guid(service), debugstr_guid(riid), object);
2889
2890     return E_NOTIMPL;
2891 }
2892
2893 static const IMFGetServiceVtbl media_engine_get_service_vtbl =
2894 {
2895     media_engine_gs_QueryInterface,
2896     media_engine_gs_AddRef,
2897     media_engine_gs_Release,
2898     media_engine_gs_GetService,
2899 };
2900
2901 static HRESULT WINAPI media_engine_grabber_callback_QueryInterface(IMFSampleGrabberSinkCallback *iface,
2902         REFIID riid, void **obj)
2903 {
2904     if (IsEqualIID(riid, &IID_IMFSampleGrabberSinkCallback) ||
2905             IsEqualIID(riid, &IID_IUnknown))
2906     {
2907         *obj = iface;
2908         IMFSampleGrabberSinkCallback_AddRef(iface);
2909         return S_OK;
2910     }
2911
2912     *obj = NULL;
2913     return E_NOINTERFACE;
2914 }
2915
2916 static ULONG WINAPI media_engine_grabber_callback_AddRef(IMFSampleGrabberSinkCallback *iface)
2917 {
2918     struct media_engine *engine = impl_from_IMFSampleGrabberSinkCallback(iface);
2919     return IMFMediaEngineEx_AddRef(&engine->IMFMediaEngineEx_iface);
2920 }
2921
2922 static ULONG WINAPI media_engine_grabber_callback_Release(IMFSampleGrabberSinkCallback *iface)
2923 {
2924     struct media_engine *engine = impl_from_IMFSampleGrabberSinkCallback(iface);
2925     return IMFMediaEngineEx_Release(&engine->IMFMediaEngineEx_iface);
2926 }
2927
2928 static HRESULT WINAPI media_engine_grabber_callback_OnClockStart(IMFSampleGrabberSinkCallback *iface,
2929         MFTIME systime, LONGLONG start_offset)
2930 {
2931     return S_OK;
2932 }
2933
2934 static HRESULT WINAPI media_engine_grabber_callback_OnClockStop(IMFSampleGrabberSinkCallback *iface,
2935         MFTIME systime)
2936 {
2937     struct media_engine *engine = impl_from_IMFSampleGrabberSinkCallback(iface);
2938
2939     EnterCriticalSection(&engine->cs);
2940     media_engine_set_flag(engine, FLAGS_ENGINE_FIRST_FRAME, FALSE);
2941     engine->video_frame.pts = MINLONGLONG;
2942     LeaveCriticalSection(&engine->cs);
2943
2944     return S_OK;
2945 }
2946
2947 static HRESULT WINAPI media_engine_grabber_callback_OnClockPause(IMFSampleGrabberSinkCallback *iface,
2948         MFTIME systime)
2949 {
2950     return S_OK;
2951 }
2952
2953 static HRESULT WINAPI media_engine_grabber_callback_OnClockRestart(IMFSampleGrabberSinkCallback *iface,
2954         MFTIME systime)
2955 {
2956     return S_OK;
2957 }
2958
2959 static HRESULT WINAPI media_engine_grabber_callback_OnClockSetRate(IMFSampleGrabberSinkCallback *iface,
2960         MFTIME systime, float rate)
2961 {
2962     return S_OK;
2963 }
2964
2965 static HRESULT WINAPI media_engine_grabber_callback_OnSetPresentationClock(IMFSampleGrabberSinkCallback *iface,
2966         IMFPresentationClock *clock)
2967 {
2968     return S_OK;
2969 }
2970
2971 static HRESULT WINAPI media_engine_grabber_callback_OnProcessSample(IMFSampleGrabberSinkCallback *iface,
2972         REFGUID major_type, DWORD sample_flags, LONGLONG sample_time, LONGLONG sample_duration,
2973         const BYTE *buffer, DWORD buffer_size)
2974 {
2975     struct media_engine *engine = impl_from_IMFSampleGrabberSinkCallback(iface);
2976
2977     EnterCriticalSection(&engine->cs);
2978
2979     if (!(engine->flags & FLAGS_ENGINE_FIRST_FRAME))
2980     {
2981         IMFMediaEngineNotify_EventNotify(engine->callback, MF_MEDIA_ENGINE_EVENT_FIRSTFRAMEREADY, 0, 0);
2982         media_engine_set_flag(engine, FLAGS_ENGINE_FIRST_FRAME, TRUE);
2983     }
2984     engine->video_frame.pts = sample_time;
2985     if (engine->video_frame.buffer_size < buffer_size)
2986     {
2987         free(engine->video_frame.buffer);
2988         if ((engine->video_frame.buffer = malloc(buffer_size)))
2989             engine->video_frame.buffer_size = buffer_size;
2990     }
2991     if (engine->video_frame.buffer)
2992     {
2993         memcpy(engine->video_frame.buffer, buffer, buffer_size);
2994         engine->flags |= FLAGS_ENGINE_NEW_FRAME;
2995     }
2996
2997     LeaveCriticalSection(&engine->cs);
2998
2999     return S_OK;
3000 }
3001
3002 static HRESULT WINAPI media_engine_grabber_callback_OnShutdown(IMFSampleGrabberSinkCallback *iface)
3003 {
3004     return S_OK;
3005 }
3006
3007 static const IMFSampleGrabberSinkCallbackVtbl media_engine_grabber_callback_vtbl =
3008 {
3009     media_engine_grabber_callback_QueryInterface,
3010     media_engine_grabber_callback_AddRef,
3011     media_engine_grabber_callback_Release,
3012     media_engine_grabber_callback_OnClockStart,
3013     media_engine_grabber_callback_OnClockStop,
3014     media_engine_grabber_callback_OnClockPause,
3015     media_engine_grabber_callback_OnClockRestart,
3016     media_engine_grabber_callback_OnClockSetRate,
3017     media_engine_grabber_callback_OnSetPresentationClock,
3018     media_engine_grabber_callback_OnProcessSample,
3019     media_engine_grabber_callback_OnShutdown,
3020 };
3021
3022 static HRESULT WINAPI media_engine_factory_QueryInterface(IMFMediaEngineClassFactory *iface, REFIID riid, void **obj)
3023 {
3024     if (IsEqualIID(riid, &IID_IMFMediaEngineClassFactory) ||
3025         IsEqualIID(riid, &IID_IUnknown))
3026     {
3027         *obj = iface;
3028         IMFMediaEngineClassFactory_AddRef(iface);
3029         return S_OK;
3030     }
3031
3032     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
3033     *obj = NULL;
3034     return E_NOINTERFACE;
3035 }
3036
3037 static ULONG WINAPI media_engine_factory_AddRef(IMFMediaEngineClassFactory *iface)
3038 {
3039     return 2;
3040 }
3041
3042 static ULONG WINAPI media_engine_factory_Release(IMFMediaEngineClassFactory *iface)
3043 {
3044     return 1;
3045 }
3046
3047 static HRESULT init_media_engine(DWORD flags, IMFAttributes *attributes, struct media_engine *engine)
3048 {
3049     DXGI_FORMAT output_format;
3050     UINT64 playback_hwnd;
3051     IMFClock *clock;
3052     HRESULT hr;
3053
3054     engine->IMFMediaEngineEx_iface.lpVtbl = &media_engine_vtbl;
3055     engine->IMFGetService_iface.lpVtbl = &media_engine_get_service_vtbl;
3056     engine->session_events.lpVtbl = &media_engine_session_events_vtbl;
3057     engine->load_handler.lpVtbl = &media_engine_load_handler_vtbl;
3058     engine->grabber_callback.lpVtbl = &media_engine_grabber_callback_vtbl;
3059     engine->refcount = 1;
3060     engine->flags = (flags & MF_MEDIA_ENGINE_CREATEFLAGS_MASK) | FLAGS_ENGINE_PAUSED;
3061     engine->default_playback_rate = 1.0;
3062     engine->playback_rate = 1.0;
3063     engine->volume = 1.0;
3064     engine->duration = NAN;
3065     engine->video_frame.pts = MINLONGLONG;
3066     InitializeCriticalSection(&engine->cs);
3067
3068     hr = IMFAttributes_GetUnknown(attributes, &MF_MEDIA_ENGINE_CALLBACK, &IID_IMFMediaEngineNotify,
3069             (void **)&engine->callback);
3070     if (FAILED(hr))
3071         return hr;
3072
3073     IMFAttributes_GetUnknown(attributes, &MF_MEDIA_ENGINE_DXGI_MANAGER, &IID_IMFDXGIDeviceManager,
3074             (void **)&engine->device_manager);
3075
3076     if (FAILED(hr = MFCreateMediaSession(NULL, &engine->session)))
3077         return hr;
3078
3079     if (FAILED(hr = IMFMediaSession_GetClock(engine->session, &clock)))
3080         return hr;
3081
3082     hr = IMFClock_QueryInterface(clock, &IID_IMFPresentationClock, (void **)&engine->clock);
3083     IMFClock_Release(clock);
3084     if (FAILED(hr))
3085         return hr;
3086
3087     if (FAILED(hr = IMFMediaSession_BeginGetEvent(engine->session, &engine->session_events, NULL)))
3088         return hr;
3089
3090     if (FAILED(hr = MFCreateSourceResolver(&engine->resolver)))
3091         return hr;
3092
3093     if (FAILED(hr = MFCreateAttributes(&engine->attributes, 0)))
3094         return hr;
3095
3096     if (FAILED(hr = IMFAttributes_CopyAllItems(attributes, engine->attributes)))
3097         return hr;
3098
3099     /* Set default audio configuration */
3100     if (FAILED(IMFAttributes_GetItem(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_CATEGORY, NULL)))
3101         IMFAttributes_SetUINT32(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_CATEGORY, AudioCategory_Other);
3102     if (FAILED(IMFAttributes_GetItem(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_ENDPOINT_ROLE, NULL)))
3103         IMFAttributes_SetUINT32(engine->attributes, &MF_MEDIA_ENGINE_AUDIO_ENDPOINT_ROLE, eMultimedia);
3104
3105     IMFAttributes_GetUINT64(attributes, &MF_MEDIA_ENGINE_PLAYBACK_HWND, &playback_hwnd);
3106     hr = IMFAttributes_GetUINT32(attributes, &MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT, &output_format);
3107     if (playback_hwnd) /* FIXME: handle MF_MEDIA_ENGINE_PLAYBACK_VISUAL */
3108         engine->mode = MEDIA_ENGINE_RENDERING_MODE;
3109     else
3110     {
3111         if (SUCCEEDED(hr))
3112             engine->mode = MEDIA_ENGINE_FRAME_SERVER_MODE;
3113         else
3114             engine->mode = MEDIA_ENGINE_AUDIO_MODE;
3115     }
3116
3117     return S_OK;
3118 }
3119
3120 static HRESULT WINAPI media_engine_factory_CreateInstance(IMFMediaEngineClassFactory *iface, DWORD flags,
3121                                                           IMFAttributes *attributes, IMFMediaEngine **engine)
3122 {
3123     struct media_engine *object;
3124     HRESULT hr;
3125
3126     TRACE("%p, %#lx, %p, %p.\n", iface, flags, attributes, engine);
3127
3128     if (!attributes || !engine)
3129         return E_POINTER;
3130
3131     object = calloc(1, sizeof(*object));
3132     if (!object)
3133         return E_OUTOFMEMORY;
3134
3135     hr = init_media_engine(flags, attributes, object);
3136     if (FAILED(hr))
3137     {
3138         free_media_engine(object);
3139         return hr;
3140     }
3141
3142     *engine = (IMFMediaEngine *)&object->IMFMediaEngineEx_iface;
3143
3144     return S_OK;
3145 }
3146
3147 static HRESULT WINAPI media_engine_factory_CreateTimeRange(IMFMediaEngineClassFactory *iface,
3148         IMFMediaTimeRange **range)
3149 {
3150     TRACE("%p, %p.\n", iface, range);
3151
3152     return create_time_range(range);
3153 }
3154
3155 static HRESULT WINAPI media_engine_factory_CreateError(IMFMediaEngineClassFactory *iface, IMFMediaError **error)
3156 {
3157     TRACE("%p, %p.\n", iface, error);
3158
3159     return create_media_error(error);
3160 }
3161
3162 static const IMFMediaEngineClassFactoryVtbl media_engine_factory_vtbl =
3163 {
3164     media_engine_factory_QueryInterface,
3165     media_engine_factory_AddRef,
3166     media_engine_factory_Release,
3167     media_engine_factory_CreateInstance,
3168     media_engine_factory_CreateTimeRange,
3169     media_engine_factory_CreateError,
3170 };
3171
3172 static IMFMediaEngineClassFactory media_engine_factory = { &media_engine_factory_vtbl };
3173
3174 static HRESULT WINAPI classfactory_QueryInterface(IClassFactory *iface, REFIID riid, void **obj)
3175 {
3176     TRACE("%s, %p.\n", debugstr_guid(riid), obj);
3177
3178     if (IsEqualGUID(riid, &IID_IClassFactory) ||
3179         IsEqualGUID(riid, &IID_IUnknown))
3180     {
3181         IClassFactory_AddRef(iface);
3182         *obj = iface;
3183         return S_OK;
3184     }
3185
3186     WARN("interface %s not implemented.\n", debugstr_guid(riid));
3187     *obj = NULL;
3188     return E_NOINTERFACE;
3189 }
3190
3191 static ULONG WINAPI classfactory_AddRef(IClassFactory *iface)
3192 {
3193     return 2;
3194 }
3195
3196 static ULONG WINAPI classfactory_Release(IClassFactory *iface)
3197 {
3198     return 1;
3199 }
3200
3201 static HRESULT WINAPI classfactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
3202 {
3203     TRACE("%p, %s, %p.\n", outer, debugstr_guid(riid), obj);
3204
3205     *obj = NULL;
3206
3207     if (outer)
3208         return CLASS_E_NOAGGREGATION;
3209
3210     return IMFMediaEngineClassFactory_QueryInterface(&media_engine_factory, riid, obj);
3211 }
3212
3213 static HRESULT WINAPI classfactory_LockServer(IClassFactory *iface, BOOL dolock)
3214 {
3215     FIXME("(%d): stub.\n", dolock);
3216     return S_OK;
3217 }
3218
3219 static const IClassFactoryVtbl class_factory_vtbl =
3220 {
3221     classfactory_QueryInterface,
3222     classfactory_AddRef,
3223     classfactory_Release,
3224     classfactory_CreateInstance,
3225     classfactory_LockServer,
3226 };
3227
3228 static IClassFactory classfactory = { &class_factory_vtbl };
3229
3230 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, void **obj)
3231 {
3232     TRACE("%s, %s, %p.\n", debugstr_guid(clsid), debugstr_guid(riid), obj);
3233
3234     if (IsEqualGUID(clsid, &CLSID_MFMediaEngineClassFactory))
3235         return IClassFactory_QueryInterface(&classfactory, riid, obj);
3236
3237     WARN("Unsupported class %s.\n", debugstr_guid(clsid));
3238     *obj = NULL;
3239     return CLASS_E_CLASSNOTAVAILABLE;
3240 }