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