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