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