dlls/mfplat/sample.c

   1 /*
   2  * Copyright 2021 Nikolay Sivov 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 "mfplat_private.h"
  22 #include "rtworkq.h"
  23 #include "d3d9.h"
  24 #include "d3d11.h"
  25 #include "initguid.h"
  26 #include "dxva2api.h"
  27
  28 #include "wine/debug.h"
  29 #include "wine/list.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  32
  33 enum sample_prop_flags
  34 {
  35     SAMPLE_PROP_HAS_DURATION  = 1 << 0,
  36     SAMPLE_PROP_HAS_TIMESTAMP = 1 << 1,
  37 };
  38
  39 struct sample
  40 {
  41     struct attributes attributes;
  42     IMFSample IMFSample_iface;
  43     IMFTrackedSample IMFTrackedSample_iface;
  44
  45     IMFMediaBuffer **buffers;
  46     size_t buffer_count;
  47     size_t capacity;
  48     DWORD flags;
  49     DWORD prop_flags;
  50     LONGLONG duration;
  51     LONGLONG timestamp;
  52
  53     /* Tracked sample functionality. */
  54     IRtwqAsyncResult *tracked_result;
  55     LONG tracked_refcount;
  56 };
  57
  58 struct sample_allocator
  59 {
  60     IMFVideoSampleAllocatorEx IMFVideoSampleAllocatorEx_iface;
  61     IMFVideoSampleAllocatorCallback IMFVideoSampleAllocatorCallback_iface;
  62     IMFAsyncCallback tracking_callback;
  63     LONG refcount;
  64
  65     IMFVideoSampleAllocatorNotify *callback;
  66     IDirect3DDeviceManager9 *d3d9_device_manager;
  67     IMFDXGIDeviceManager *dxgi_device_manager;
  68
  69     struct
  70     {
  71         unsigned int width;
  72         unsigned int height;
  73         D3DFORMAT d3d9_format;
  74         DXGI_FORMAT dxgi_format;
  75         unsigned int usage;
  76         unsigned int bindflags;
  77         unsigned int buffer_count;
  78     } frame_desc;
  79
  80     IMFAttributes *attributes;
  81     IMFMediaType *media_type;
  82
  83     unsigned int free_sample_count;
  84     unsigned int cold_sample_count;
  85     struct list free_samples;
  86     struct list used_samples;
  87     CRITICAL_SECTION cs;
  88 };
  89
  90 struct queued_sample
  91 {
  92     struct list entry;
  93     IMFSample *sample;
  94 };
  95
  96 static struct sample_allocator *impl_from_IMFVideoSampleAllocatorEx(IMFVideoSampleAllocatorEx *iface)
  97 {
  98     return CONTAINING_RECORD(iface, struct sample_allocator, IMFVideoSampleAllocatorEx_iface);
  99 }
 100
 101 static struct sample_allocator *impl_from_IMFVideoSampleAllocatorCallback(IMFVideoSampleAllocatorCallback *iface)
 102 {
 103     return CONTAINING_RECORD(iface, struct sample_allocator, IMFVideoSampleAllocatorCallback_iface);
 104 }
 105
 106 static struct sample_allocator *impl_from_IMFAsyncCallback(IMFAsyncCallback *iface)
 107 {
 108     return CONTAINING_RECORD(iface, struct sample_allocator, tracking_callback);
 109 }
 110
 111 static struct sample *impl_from_IMFSample(IMFSample *iface)
 112 {
 113     return CONTAINING_RECORD(iface, struct sample, IMFSample_iface);
 114 }
 115
 116 static struct sample *impl_from_IMFTrackedSample(IMFTrackedSample *iface)
 117 {
 118     return CONTAINING_RECORD(iface, struct sample, IMFTrackedSample_iface);
 119 }
 120
 121 static HRESULT WINAPI sample_QueryInterface(IMFSample *iface, REFIID riid, void **out)
 122 {
 123     struct sample *sample = impl_from_IMFSample(iface);
 124
 125     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 126
 127     if (IsEqualIID(riid, &IID_IMFSample) ||
 128             IsEqualIID(riid, &IID_IMFAttributes) ||
 129             IsEqualIID(riid, &IID_IUnknown))
 130     {
 131         *out = &sample->IMFSample_iface;
 132     }
 133     else if (sample->IMFTrackedSample_iface.lpVtbl && IsEqualIID(riid, &IID_IMFTrackedSample))
 134     {
 135         *out = &sample->IMFTrackedSample_iface;
 136     }
 137     else
 138     {
 139         WARN("Unsupported %s.\n", debugstr_guid(riid));
 140         *out = NULL;
 141         return E_NOINTERFACE;
 142     }
 143
 144     IUnknown_AddRef((IUnknown *)*out);
 145     return S_OK;
 146 }
 147
 148 static ULONG WINAPI sample_AddRef(IMFSample *iface)
 149 {
 150     struct sample *sample = impl_from_IMFSample(iface);
 151     ULONG refcount = InterlockedIncrement(&sample->attributes.ref);
 152
 153     TRACE("%p, refcount %u.\n", iface, refcount);
 154
 155     return refcount;
 156 }
 157
 158 static void release_sample_object(struct sample *sample)
 159 {
 160     size_t i;
 161
 162     for (i = 0; i < sample->buffer_count; ++i)
 163         IMFMediaBuffer_Release(sample->buffers[i]);
 164     clear_attributes_object(&sample->attributes);
 165     free(sample->buffers);
 166     free(sample);
 167 }
 168
 169 static ULONG WINAPI sample_Release(IMFSample *iface)
 170 {
 171     struct sample *sample = impl_from_IMFSample(iface);
 172     ULONG refcount = InterlockedDecrement(&sample->attributes.ref);
 173
 174     TRACE("%p, refcount %u.\n", iface, refcount);
 175
 176     if (!refcount)
 177         release_sample_object(sample);
 178
 179     return refcount;
 180 }
 181
 182 static ULONG WINAPI sample_tracked_Release(IMFSample *iface)
 183 {
 184     struct sample *sample = impl_from_IMFSample(iface);
 185     ULONG refcount;
 186     HRESULT hr;
 187
 188     EnterCriticalSection(&sample->attributes.cs);
 189     if (sample->tracked_result && sample->tracked_refcount == (sample->attributes.ref - 1))
 190     {
 191         IRtwqAsyncResult *tracked_result = sample->tracked_result;
 192         sample->tracked_result = NULL;
 193         sample->tracked_refcount = 0;
 194
 195         /* Call could fail if queue system is not initialized, it's not critical. */
 196         if (FAILED(hr = RtwqInvokeCallback(tracked_result)))
 197             WARN("Failed to invoke tracking callback, hr %#x.\n", hr);
 198         IRtwqAsyncResult_Release(tracked_result);
 199     }
 200     LeaveCriticalSection(&sample->attributes.cs);
 201
 202     refcount = InterlockedDecrement(&sample->attributes.ref);
 203
 204     TRACE("%p, refcount %u.\n", iface, refcount);
 205
 206     if (!refcount)
 207         release_sample_object(sample);
 208
 209     return refcount;
 210 }
 211
 212 static HRESULT WINAPI sample_GetItem(IMFSample *iface, REFGUID key, PROPVARIANT *value)
 213 {
 214     struct sample *sample = impl_from_IMFSample(iface);
 215
 216     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 217
 218     return attributes_GetItem(&sample->attributes, key, value);
 219 }
 220
 221 static HRESULT WINAPI sample_GetItemType(IMFSample *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 222 {
 223     struct sample *sample = impl_from_IMFSample(iface);
 224
 225     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
 226
 227     return attributes_GetItemType(&sample->attributes, key, type);
 228 }
 229
 230 static HRESULT WINAPI sample_CompareItem(IMFSample *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
 231 {
 232     struct sample *sample = impl_from_IMFSample(iface);
 233
 234     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
 235
 236     return attributes_CompareItem(&sample->attributes, key, value, result);
 237 }
 238
 239 static HRESULT WINAPI sample_Compare(IMFSample *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
 240         BOOL *result)
 241 {
 242     struct sample *sample = impl_from_IMFSample(iface);
 243
 244     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
 245
 246     return attributes_Compare(&sample->attributes, theirs, type, result);
 247 }
 248
 249 static HRESULT WINAPI sample_GetUINT32(IMFSample *iface, REFGUID key, UINT32 *value)
 250 {
 251     struct sample *sample = impl_from_IMFSample(iface);
 252
 253     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 254
 255     return attributes_GetUINT32(&sample->attributes, key, value);
 256 }
 257
 258 static HRESULT WINAPI sample_GetUINT64(IMFSample *iface, REFGUID key, UINT64 *value)
 259 {
 260     struct sample *sample = impl_from_IMFSample(iface);
 261
 262     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 263
 264     return attributes_GetUINT64(&sample->attributes, key, value);
 265 }
 266
 267 static HRESULT WINAPI sample_GetDouble(IMFSample *iface, REFGUID key, double *value)
 268 {
 269     struct sample *sample = impl_from_IMFSample(iface);
 270
 271     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 272
 273     return attributes_GetDouble(&sample->attributes, key, value);
 274 }
 275
 276 static HRESULT WINAPI sample_GetGUID(IMFSample *iface, REFGUID key, GUID *value)
 277 {
 278     struct sample *sample = impl_from_IMFSample(iface);
 279
 280     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 281
 282     return attributes_GetGUID(&sample->attributes, key, value);
 283 }
 284
 285 static HRESULT WINAPI sample_GetStringLength(IMFSample *iface, REFGUID key, UINT32 *length)
 286 {
 287     struct sample *sample = impl_from_IMFSample(iface);
 288
 289     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
 290
 291     return attributes_GetStringLength(&sample->attributes, key, length);
 292 }
 293
 294 static HRESULT WINAPI sample_GetString(IMFSample *iface, REFGUID key, WCHAR *value, UINT32 size, UINT32 *length)
 295 {
 296     struct sample *sample = impl_from_IMFSample(iface);
 297
 298     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
 299
 300     return attributes_GetString(&sample->attributes, key, value, size, length);
 301 }
 302
 303 static HRESULT WINAPI sample_GetAllocatedString(IMFSample *iface, REFGUID key, WCHAR **value, UINT32 *length)
 304 {
 305     struct sample *sample = impl_from_IMFSample(iface);
 306
 307     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
 308
 309     return attributes_GetAllocatedString(&sample->attributes, key, value, length);
 310 }
 311
 312 static HRESULT WINAPI sample_GetBlobSize(IMFSample *iface, REFGUID key, UINT32 *size)
 313 {
 314     struct sample *sample = impl_from_IMFSample(iface);
 315
 316     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
 317
 318     return attributes_GetBlobSize(&sample->attributes, key, size);
 319 }
 320
 321 static HRESULT WINAPI sample_GetBlob(IMFSample *iface, REFGUID key, UINT8 *buf, UINT32 bufsize, UINT32 *blobsize)
 322 {
 323     struct sample *sample = impl_from_IMFSample(iface);
 324
 325     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
 326
 327     return attributes_GetBlob(&sample->attributes, key, buf, bufsize, blobsize);
 328 }
 329
 330 static HRESULT WINAPI sample_GetAllocatedBlob(IMFSample *iface, REFGUID key, UINT8 **buf, UINT32 *size)
 331 {
 332     struct sample *sample = impl_from_IMFSample(iface);
 333
 334     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
 335
 336     return attributes_GetAllocatedBlob(&sample->attributes, key, buf, size);
 337 }
 338
 339 static HRESULT WINAPI sample_GetUnknown(IMFSample *iface, REFGUID key, REFIID riid, void **out)
 340 {
 341     struct sample *sample = impl_from_IMFSample(iface);
 342
 343     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
 344
 345     return attributes_GetUnknown(&sample->attributes, key, riid, out);
 346 }
 347
 348 static HRESULT WINAPI sample_SetItem(IMFSample *iface, REFGUID key, REFPROPVARIANT value)
 349 {
 350     struct sample *sample = impl_from_IMFSample(iface);
 351
 352     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
 353
 354     return attributes_SetItem(&sample->attributes, key, value);
 355 }
 356
 357 static HRESULT WINAPI sample_DeleteItem(IMFSample *iface, REFGUID key)
 358 {
 359     struct sample *sample = impl_from_IMFSample(iface);
 360
 361     TRACE("%p, %s.\n", iface, debugstr_attr(key));
 362
 363     return attributes_DeleteItem(&sample->attributes, key);
 364 }
 365
 366 static HRESULT WINAPI sample_DeleteAllItems(IMFSample *iface)
 367 {
 368     struct sample *sample = impl_from_IMFSample(iface);
 369
 370     TRACE("%p.\n", iface);
 371
 372     return attributes_DeleteAllItems(&sample->attributes);
 373 }
 374
 375 static HRESULT WINAPI sample_SetUINT32(IMFSample *iface, REFGUID key, UINT32 value)
 376 {
 377     struct sample *sample = impl_from_IMFSample(iface);
 378
 379     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
 380
 381     return attributes_SetUINT32(&sample->attributes, key, value);
 382 }
 383
 384 static HRESULT WINAPI sample_SetUINT64(IMFSample *iface, REFGUID key, UINT64 value)
 385 {
 386     struct sample *sample = impl_from_IMFSample(iface);
 387
 388     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
 389
 390     return attributes_SetUINT64(&sample->attributes, key, value);
 391 }
 392
 393 static HRESULT WINAPI sample_SetDouble(IMFSample *iface, REFGUID key, double value)
 394 {
 395     struct sample *sample = impl_from_IMFSample(iface);
 396
 397     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
 398
 399     return attributes_SetDouble(&sample->attributes, key, value);
 400 }
 401
 402 static HRESULT WINAPI sample_SetGUID(IMFSample *iface, REFGUID key, REFGUID value)
 403 {
 404     struct sample *sample = impl_from_IMFSample(iface);
 405
 406     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
 407
 408     return attributes_SetGUID(&sample->attributes, key, value);
 409 }
 410
 411 static HRESULT WINAPI sample_SetString(IMFSample *iface, REFGUID key, const WCHAR *value)
 412 {
 413     struct sample *sample = impl_from_IMFSample(iface);
 414
 415     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
 416
 417     return attributes_SetString(&sample->attributes, key, value);
 418 }
 419
 420 static HRESULT WINAPI sample_SetBlob(IMFSample *iface, REFGUID key, const UINT8 *buf, UINT32 size)
 421 {
 422     struct sample *sample = impl_from_IMFSample(iface);
 423
 424     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
 425
 426     return attributes_SetBlob(&sample->attributes, key, buf, size);
 427 }
 428
 429 static HRESULT WINAPI sample_SetUnknown(IMFSample *iface, REFGUID key, IUnknown *unknown)
 430 {
 431     struct sample *sample = impl_from_IMFSample(iface);
 432
 433     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
 434
 435     return attributes_SetUnknown(&sample->attributes, key, unknown);
 436 }
 437
 438 static HRESULT WINAPI sample_LockStore(IMFSample *iface)
 439 {
 440     struct sample *sample = impl_from_IMFSample(iface);
 441
 442     TRACE("%p.\n", iface);
 443
 444     return attributes_LockStore(&sample->attributes);
 445 }
 446
 447 static HRESULT WINAPI sample_UnlockStore(IMFSample *iface)
 448 {
 449     struct sample *sample = impl_from_IMFSample(iface);
 450
 451     TRACE("%p.\n", iface);
 452
 453     return attributes_UnlockStore(&sample->attributes);
 454 }
 455
 456 static HRESULT WINAPI sample_GetCount(IMFSample *iface, UINT32 *count)
 457 {
 458     struct sample *sample = impl_from_IMFSample(iface);
 459
 460     TRACE("%p, %p.\n", iface, count);
 461
 462     return attributes_GetCount(&sample->attributes, count);
 463 }
 464
 465 static HRESULT WINAPI sample_GetItemByIndex(IMFSample *iface, UINT32 index, GUID *key, PROPVARIANT *value)
 466 {
 467     struct sample *sample = impl_from_IMFSample(iface);
 468
 469     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
 470
 471     return attributes_GetItemByIndex(&sample->attributes, index, key, value);
 472 }
 473
 474 static HRESULT WINAPI sample_CopyAllItems(IMFSample *iface, IMFAttributes *dest)
 475 {
 476     struct sample *sample = impl_from_IMFSample(iface);
 477
 478     TRACE("%p, %p.\n", iface, dest);
 479
 480     return attributes_CopyAllItems(&sample->attributes, dest);
 481 }
 482
 483 static HRESULT WINAPI sample_GetSampleFlags(IMFSample *iface, DWORD *flags)
 484 {
 485     struct sample *sample = impl_from_IMFSample(iface);
 486
 487     TRACE("%p, %p.\n", iface, flags);
 488
 489     EnterCriticalSection(&sample->attributes.cs);
 490     *flags = sample->flags;
 491     LeaveCriticalSection(&sample->attributes.cs);
 492
 493     return S_OK;
 494 }
 495
 496 static HRESULT WINAPI sample_SetSampleFlags(IMFSample *iface, DWORD flags)
 497 {
 498     struct sample *sample = impl_from_IMFSample(iface);
 499
 500     TRACE("%p, %#x.\n", iface, flags);
 501
 502     EnterCriticalSection(&sample->attributes.cs);
 503     sample->flags = flags;
 504     LeaveCriticalSection(&sample->attributes.cs);
 505
 506     return S_OK;
 507 }
 508
 509 static HRESULT WINAPI sample_GetSampleTime(IMFSample *iface, LONGLONG *timestamp)
 510 {
 511     struct sample *sample = impl_from_IMFSample(iface);
 512     HRESULT hr = S_OK;
 513
 514     TRACE("%p, %p.\n", iface, timestamp);
 515
 516     EnterCriticalSection(&sample->attributes.cs);
 517     if (sample->prop_flags & SAMPLE_PROP_HAS_TIMESTAMP)
 518         *timestamp = sample->timestamp;
 519     else
 520         hr = MF_E_NO_SAMPLE_TIMESTAMP;
 521     LeaveCriticalSection(&sample->attributes.cs);
 522
 523     return hr;
 524 }
 525
 526 static HRESULT WINAPI sample_SetSampleTime(IMFSample *iface, LONGLONG timestamp)
 527 {
 528     struct sample *sample = impl_from_IMFSample(iface);
 529
 530     TRACE("%p, %s.\n", iface, debugstr_time(timestamp));
 531
 532     EnterCriticalSection(&sample->attributes.cs);
 533     sample->timestamp = timestamp;
 534     sample->prop_flags |= SAMPLE_PROP_HAS_TIMESTAMP;
 535     LeaveCriticalSection(&sample->attributes.cs);
 536
 537     return S_OK;
 538 }
 539
 540 static HRESULT WINAPI sample_GetSampleDuration(IMFSample *iface, LONGLONG *duration)
 541 {
 542     struct sample *sample = impl_from_IMFSample(iface);
 543     HRESULT hr = S_OK;
 544
 545     TRACE("%p, %p.\n", iface, duration);
 546
 547     EnterCriticalSection(&sample->attributes.cs);
 548     if (sample->prop_flags & SAMPLE_PROP_HAS_DURATION)
 549         *duration = sample->duration;
 550     else
 551         hr = MF_E_NO_SAMPLE_DURATION;
 552     LeaveCriticalSection(&sample->attributes.cs);
 553
 554     return hr;
 555 }
 556
 557 static HRESULT WINAPI sample_SetSampleDuration(IMFSample *iface, LONGLONG duration)
 558 {
 559     struct sample *sample = impl_from_IMFSample(iface);
 560
 561     TRACE("%p, %s.\n", iface, debugstr_time(duration));
 562
 563     EnterCriticalSection(&sample->attributes.cs);
 564     sample->duration = duration;
 565     sample->prop_flags |= SAMPLE_PROP_HAS_DURATION;
 566     LeaveCriticalSection(&sample->attributes.cs);
 567
 568     return S_OK;
 569 }
 570
 571 static HRESULT WINAPI sample_GetBufferCount(IMFSample *iface, DWORD *count)
 572 {
 573     struct sample *sample = impl_from_IMFSample(iface);
 574
 575     TRACE("%p, %p.\n", iface, count);
 576
 577     if (!count)
 578         return E_INVALIDARG;
 579
 580     EnterCriticalSection(&sample->attributes.cs);
 581     *count = sample->buffer_count;
 582     LeaveCriticalSection(&sample->attributes.cs);
 583
 584     return S_OK;
 585 }
 586
 587 static HRESULT WINAPI sample_GetBufferByIndex(IMFSample *iface, DWORD index, IMFMediaBuffer **buffer)
 588 {
 589     struct sample *sample = impl_from_IMFSample(iface);
 590     HRESULT hr = S_OK;
 591
 592     TRACE("%p, %u, %p.\n", iface, index, buffer);
 593
 594     EnterCriticalSection(&sample->attributes.cs);
 595     if (index < sample->buffer_count)
 596     {
 597         *buffer = sample->buffers[index];
 598         IMFMediaBuffer_AddRef(*buffer);
 599     }
 600     else
 601         hr = E_INVALIDARG;
 602     LeaveCriticalSection(&sample->attributes.cs);
 603
 604     return hr;
 605 }
 606
 607 static unsigned int sample_get_total_length(struct sample *sample)
 608 {
 609     DWORD total_length = 0, length;
 610     size_t i;
 611
 612     for (i = 0; i < sample->buffer_count; ++i)
 613     {
 614         length = 0;
 615         if (SUCCEEDED(IMFMediaBuffer_GetCurrentLength(sample->buffers[i], &length)))
 616             total_length += length;
 617     }
 618
 619     return total_length;
 620 }
 621
 622 static HRESULT sample_copy_to_buffer(struct sample *sample, IMFMediaBuffer *buffer)
 623 {
 624     DWORD total_length, dst_length, dst_current_length, src_max_length, current_length;
 625     BYTE *src_ptr, *dst_ptr;
 626     BOOL locked;
 627     HRESULT hr;
 628     size_t i;
 629
 630     total_length = sample_get_total_length(sample);
 631     dst_current_length = 0;
 632
 633     dst_ptr = NULL;
 634     dst_length = current_length = 0;
 635     locked = SUCCEEDED(hr = IMFMediaBuffer_Lock(buffer, &dst_ptr, &dst_length, &current_length));
 636     if (locked)
 637     {
 638         if (dst_length < total_length)
 639             hr = MF_E_BUFFERTOOSMALL;
 640         else if (dst_ptr)
 641         {
 642             for (i = 0; i < sample->buffer_count && SUCCEEDED(hr); ++i)
 643             {
 644                 src_ptr = NULL;
 645                 src_max_length = current_length = 0;
 646                 if (SUCCEEDED(hr = IMFMediaBuffer_Lock(sample->buffers[i], &src_ptr, &src_max_length, &current_length)))
 647                 {
 648                     if (src_ptr)
 649                     {
 650                         if (current_length > dst_length)
 651                             hr = MF_E_BUFFERTOOSMALL;
 652                         else if (current_length)
 653                         {
 654                             memcpy(dst_ptr, src_ptr, current_length);
 655                             dst_length -= current_length;
 656                             dst_current_length += current_length;
 657                             dst_ptr += current_length;
 658                         }
 659                     }
 660                     IMFMediaBuffer_Unlock(sample->buffers[i]);
 661                 }
 662             }
 663         }
 664     }
 665
 666     if (FAILED(IMFMediaBuffer_SetCurrentLength(buffer, dst_current_length)))
 667         WARN("Failed to set buffer length.\n");
 668
 669     if (locked)
 670         IMFMediaBuffer_Unlock(buffer);
 671
 672     return hr;
 673 }
 674
 675 static HRESULT WINAPI sample_ConvertToContiguousBuffer(IMFSample *iface, IMFMediaBuffer **buffer)
 676 {
 677     struct sample *sample = impl_from_IMFSample(iface);
 678     unsigned int total_length, i;
 679     IMFMediaBuffer *dest_buffer;
 680     HRESULT hr = S_OK;
 681
 682     TRACE("%p, %p.\n", iface, buffer);
 683
 684     EnterCriticalSection(&sample->attributes.cs);
 685
 686     if (sample->buffer_count == 0)
 687         hr = E_UNEXPECTED;
 688     else if (sample->buffer_count > 1)
 689     {
 690         total_length = sample_get_total_length(sample);
 691         if (SUCCEEDED(hr = MFCreateMemoryBuffer(total_length, &dest_buffer)))
 692         {
 693             if (SUCCEEDED(hr = sample_copy_to_buffer(sample, dest_buffer)))
 694             {
 695                 for (i = 0; i < sample->buffer_count; ++i)
 696                     IMFMediaBuffer_Release(sample->buffers[i]);
 697
 698                 sample->buffers[0] = dest_buffer;
 699                 IMFMediaBuffer_AddRef(sample->buffers[0]);
 700
 701                 sample->buffer_count = 1;
 702             }
 703             IMFMediaBuffer_Release(dest_buffer);
 704         }
 705     }
 706
 707     if (SUCCEEDED(hr) && buffer)
 708     {
 709         *buffer = sample->buffers[0];
 710         IMFMediaBuffer_AddRef(*buffer);
 711     }
 712
 713     LeaveCriticalSection(&sample->attributes.cs);
 714
 715     return hr;
 716 }
 717
 718 static HRESULT WINAPI sample_AddBuffer(IMFSample *iface, IMFMediaBuffer *buffer)
 719 {
 720     struct sample *sample = impl_from_IMFSample(iface);
 721     HRESULT hr = S_OK;
 722
 723     TRACE("%p, %p.\n", iface, buffer);
 724
 725     EnterCriticalSection(&sample->attributes.cs);
 726     if (!mf_array_reserve((void **)&sample->buffers, &sample->capacity, sample->buffer_count + 1,
 727             sizeof(*sample->buffers)))
 728         hr = E_OUTOFMEMORY;
 729     else
 730     {
 731         sample->buffers[sample->buffer_count++] = buffer;
 732         IMFMediaBuffer_AddRef(buffer);
 733     }
 734     LeaveCriticalSection(&sample->attributes.cs);
 735
 736     return hr;
 737 }
 738
 739 static HRESULT WINAPI sample_RemoveBufferByIndex(IMFSample *iface, DWORD index)
 740 {
 741     struct sample *sample = impl_from_IMFSample(iface);
 742     HRESULT hr = S_OK;
 743
 744     TRACE("%p, %u.\n", iface, index);
 745
 746     EnterCriticalSection(&sample->attributes.cs);
 747     if (index < sample->buffer_count)
 748     {
 749         IMFMediaBuffer_Release(sample->buffers[index]);
 750         if (index < sample->buffer_count - 1)
 751         {
 752             memmove(&sample->buffers[index], &sample->buffers[index+1],
 753                     (sample->buffer_count - index - 1) * sizeof(*sample->buffers));
 754         }
 755         sample->buffer_count--;
 756     }
 757     else
 758         hr = E_INVALIDARG;
 759     LeaveCriticalSection(&sample->attributes.cs);
 760
 761     return hr;
 762 }
 763
 764 static HRESULT WINAPI sample_RemoveAllBuffers(IMFSample *iface)
 765 {
 766     struct sample *sample = impl_from_IMFSample(iface);
 767     size_t i;
 768
 769     TRACE("%p.\n", iface);
 770
 771     EnterCriticalSection(&sample->attributes.cs);
 772     for (i = 0; i < sample->buffer_count; ++i)
 773          IMFMediaBuffer_Release(sample->buffers[i]);
 774     sample->buffer_count = 0;
 775     LeaveCriticalSection(&sample->attributes.cs);
 776
 777     return S_OK;
 778 }
 779
 780 static HRESULT WINAPI sample_GetTotalLength(IMFSample *iface, DWORD *total_length)
 781 {
 782     struct sample *sample = impl_from_IMFSample(iface);
 783
 784     TRACE("%p, %p.\n", iface, total_length);
 785
 786     EnterCriticalSection(&sample->attributes.cs);
 787     *total_length = sample_get_total_length(sample);
 788     LeaveCriticalSection(&sample->attributes.cs);
 789
 790     return S_OK;
 791 }
 792
 793 static HRESULT WINAPI sample_CopyToBuffer(IMFSample *iface, IMFMediaBuffer *buffer)
 794 {
 795     struct sample *sample = impl_from_IMFSample(iface);
 796     DWORD total_length, dst_length, dst_current_length, src_max_length, current_length;
 797     BYTE *src_ptr, *dst_ptr;
 798     BOOL locked;
 799     HRESULT hr;
 800     size_t i;
 801
 802     TRACE("%p, %p.\n", iface, buffer);
 803
 804     EnterCriticalSection(&sample->attributes.cs);
 805
 806     total_length = sample_get_total_length(sample);
 807     dst_current_length = 0;
 808
 809     dst_ptr = NULL;
 810     dst_length = current_length = 0;
 811     locked = SUCCEEDED(hr = IMFMediaBuffer_Lock(buffer, &dst_ptr, &dst_length, &current_length));
 812     if (locked)
 813     {
 814         if (dst_length < total_length)
 815             hr = MF_E_BUFFERTOOSMALL;
 816         else if (dst_ptr)
 817         {
 818             for (i = 0; i < sample->buffer_count && SUCCEEDED(hr); ++i)
 819             {
 820                 src_ptr = NULL;
 821                 src_max_length = current_length = 0;
 822                 if (SUCCEEDED(hr = IMFMediaBuffer_Lock(sample->buffers[i], &src_ptr, &src_max_length, &current_length)))
 823                 {
 824                     if (src_ptr)
 825                     {
 826                         if (current_length > dst_length)
 827                             hr = MF_E_BUFFERTOOSMALL;
 828                         else if (current_length)
 829                         {
 830                             memcpy(dst_ptr, src_ptr, current_length);
 831                             dst_length -= current_length;
 832                             dst_current_length += current_length;
 833                             dst_ptr += current_length;
 834                         }
 835                     }
 836                     IMFMediaBuffer_Unlock(sample->buffers[i]);
 837                 }
 838             }
 839         }
 840     }
 841
 842     IMFMediaBuffer_SetCurrentLength(buffer, dst_current_length);
 843
 844     if (locked)
 845         IMFMediaBuffer_Unlock(buffer);
 846
 847     LeaveCriticalSection(&sample->attributes.cs);
 848
 849     return hr;
 850 }
 851
 852 static const IMFSampleVtbl samplevtbl =
 853 {
 854     sample_QueryInterface,
 855     sample_AddRef,
 856     sample_Release,
 857     sample_GetItem,
 858     sample_GetItemType,
 859     sample_CompareItem,
 860     sample_Compare,
 861     sample_GetUINT32,
 862     sample_GetUINT64,
 863     sample_GetDouble,
 864     sample_GetGUID,
 865     sample_GetStringLength,
 866     sample_GetString,
 867     sample_GetAllocatedString,
 868     sample_GetBlobSize,
 869     sample_GetBlob,
 870     sample_GetAllocatedBlob,
 871     sample_GetUnknown,
 872     sample_SetItem,
 873     sample_DeleteItem,
 874     sample_DeleteAllItems,
 875     sample_SetUINT32,
 876     sample_SetUINT64,
 877     sample_SetDouble,
 878     sample_SetGUID,
 879     sample_SetString,
 880     sample_SetBlob,
 881     sample_SetUnknown,
 882     sample_LockStore,
 883     sample_UnlockStore,
 884     sample_GetCount,
 885     sample_GetItemByIndex,
 886     sample_CopyAllItems,
 887     sample_GetSampleFlags,
 888     sample_SetSampleFlags,
 889     sample_GetSampleTime,
 890     sample_SetSampleTime,
 891     sample_GetSampleDuration,
 892     sample_SetSampleDuration,
 893     sample_GetBufferCount,
 894     sample_GetBufferByIndex,
 895     sample_ConvertToContiguousBuffer,
 896     sample_AddBuffer,
 897     sample_RemoveBufferByIndex,
 898     sample_RemoveAllBuffers,
 899     sample_GetTotalLength,
 900     sample_CopyToBuffer,
 901 };
 902
 903 static HRESULT WINAPI tracked_sample_QueryInterface(IMFTrackedSample *iface, REFIID riid, void **obj)
 904 {
 905     struct sample *sample = impl_from_IMFTrackedSample(iface);
 906     return IMFSample_QueryInterface(&sample->IMFSample_iface, riid, obj);
 907 }
 908
 909 static ULONG WINAPI tracked_sample_AddRef(IMFTrackedSample *iface)
 910 {
 911     struct sample *sample = impl_from_IMFTrackedSample(iface);
 912     return IMFSample_AddRef(&sample->IMFSample_iface);
 913 }
 914
 915 static ULONG WINAPI tracked_sample_Release(IMFTrackedSample *iface)
 916 {
 917     struct sample *sample = impl_from_IMFTrackedSample(iface);
 918     return IMFSample_Release(&sample->IMFSample_iface);
 919 }
 920
 921 static HRESULT WINAPI tracked_sample_SetAllocator(IMFTrackedSample *iface,
 922         IMFAsyncCallback *sample_allocator, IUnknown *state)
 923 {
 924     struct sample *sample = impl_from_IMFTrackedSample(iface);
 925     HRESULT hr = S_OK;
 926
 927     TRACE("%p, %p, %p.\n", iface, sample_allocator, state);
 928
 929     EnterCriticalSection(&sample->attributes.cs);
 930
 931     if (sample->tracked_result)
 932         hr = MF_E_NOTACCEPTING;
 933     else
 934     {
 935         if (SUCCEEDED(hr = RtwqCreateAsyncResult((IUnknown *)iface, (IRtwqAsyncCallback *)sample_allocator,
 936                 state, &sample->tracked_result)))
 937         {
 938             /* Account for additional refcount brought by 'state' object. This threshold is used
 939                on Release() to invoke tracker callback.  */
 940             sample->tracked_refcount = 1;
 941             if (state == (IUnknown *)&sample->IMFTrackedSample_iface ||
 942                     state == (IUnknown *)&sample->IMFSample_iface)
 943             {
 944                 ++sample->tracked_refcount;
 945             }
 946         }
 947     }
 948
 949     LeaveCriticalSection(&sample->attributes.cs);
 950
 951     return hr;
 952 }
 953
 954 static const IMFTrackedSampleVtbl tracked_sample_vtbl =
 955 {
 956     tracked_sample_QueryInterface,
 957     tracked_sample_AddRef,
 958     tracked_sample_Release,
 959     tracked_sample_SetAllocator,
 960 };
 961
 962 static const IMFSampleVtbl sample_tracked_vtbl =
 963 {
 964     sample_QueryInterface,
 965     sample_AddRef,
 966     sample_tracked_Release,
 967     sample_GetItem,
 968     sample_GetItemType,
 969     sample_CompareItem,
 970     sample_Compare,
 971     sample_GetUINT32,
 972     sample_GetUINT64,
 973     sample_GetDouble,
 974     sample_GetGUID,
 975     sample_GetStringLength,
 976     sample_GetString,
 977     sample_GetAllocatedString,
 978     sample_GetBlobSize,
 979     sample_GetBlob,
 980     sample_GetAllocatedBlob,
 981     sample_GetUnknown,
 982     sample_SetItem,
 983     sample_DeleteItem,
 984     sample_DeleteAllItems,
 985     sample_SetUINT32,
 986     sample_SetUINT64,
 987     sample_SetDouble,
 988     sample_SetGUID,
 989     sample_SetString,
 990     sample_SetBlob,
 991     sample_SetUnknown,
 992     sample_LockStore,
 993     sample_UnlockStore,
 994     sample_GetCount,
 995     sample_GetItemByIndex,
 996     sample_CopyAllItems,
 997     sample_GetSampleFlags,
 998     sample_SetSampleFlags,
 999     sample_GetSampleTime,
1000     sample_SetSampleTime,
1001     sample_GetSampleDuration,
1002     sample_SetSampleDuration,
1003     sample_GetBufferCount,
1004     sample_GetBufferByIndex,
1005     sample_ConvertToContiguousBuffer,
1006     sample_AddBuffer,
1007     sample_RemoveBufferByIndex,
1008     sample_RemoveAllBuffers,
1009     sample_GetTotalLength,
1010     sample_CopyToBuffer,
1011 };
1012
1013 /***********************************************************************
1014  *      MFCreateSample (mfplat.@)
1015  */
1016 HRESULT WINAPI MFCreateSample(IMFSample **sample)
1017 {
1018     struct sample *object;
1019     HRESULT hr;
1020
1021     TRACE("%p.\n", sample);
1022
1023     if (!(object = calloc(1, sizeof(*object))))
1024         return E_OUTOFMEMORY;
1025
1026     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
1027     {
1028         free(object);
1029         return hr;
1030     }
1031
1032     object->IMFSample_iface.lpVtbl = &samplevtbl;
1033
1034     *sample = &object->IMFSample_iface;
1035
1036     TRACE("Created sample %p.\n", *sample);
1037
1038     return S_OK;
1039 }
1040
1041 /***********************************************************************
1042  *      MFCreateTrackedSample (mfplat.@)
1043  */
1044 HRESULT WINAPI MFCreateTrackedSample(IMFTrackedSample **sample)
1045 {
1046     struct sample *object;
1047     HRESULT hr;
1048
1049     TRACE("%p.\n", sample);
1050
1051     if (!(object = calloc(1, sizeof(*object))))
1052         return E_OUTOFMEMORY;
1053
1054     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
1055     {
1056         free(object);
1057         return hr;
1058     }
1059
1060     object->IMFSample_iface.lpVtbl = &sample_tracked_vtbl;
1061     object->IMFTrackedSample_iface.lpVtbl = &tracked_sample_vtbl;
1062
1063     *sample = &object->IMFTrackedSample_iface;
1064
1065     return S_OK;
1066 }
1067
1068 static HRESULT WINAPI sample_allocator_QueryInterface(IMFVideoSampleAllocatorEx *iface, REFIID riid, void **obj)
1069 {
1070     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorEx(iface);
1071
1072     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1073
1074     if (IsEqualIID(riid, &IID_IMFVideoSampleAllocatorEx) ||
1075             IsEqualIID(riid, &IID_IMFVideoSampleAllocator) ||
1076             IsEqualIID(riid, &IID_IUnknown))
1077     {
1078         *obj = &allocator->IMFVideoSampleAllocatorEx_iface;
1079     }
1080     else if (IsEqualIID(riid, &IID_IMFVideoSampleAllocatorCallback))
1081     {
1082         *obj = &allocator->IMFVideoSampleAllocatorCallback_iface;
1083     }
1084     else
1085     {
1086         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1087         *obj = NULL;
1088         return E_NOINTERFACE;
1089     }
1090
1091     IUnknown_AddRef((IUnknown *)*obj);
1092     return S_OK;
1093 }
1094
1095 static ULONG WINAPI sample_allocator_AddRef(IMFVideoSampleAllocatorEx *iface)
1096 {
1097     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorEx(iface);
1098     ULONG refcount = InterlockedIncrement(&allocator->refcount);
1099
1100     TRACE("%p, refcount %u.\n", iface, refcount);
1101
1102     return refcount;
1103 }
1104
1105 static void sample_allocator_release_samples(struct sample_allocator *allocator)
1106 {
1107     struct queued_sample *iter, *iter2;
1108
1109     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &allocator->free_samples, struct queued_sample, entry)
1110     {
1111         list_remove(&iter->entry);
1112         IMFSample_Release(iter->sample);
1113         free(iter);
1114     }
1115
1116     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &allocator->used_samples, struct queued_sample, entry)
1117     {
1118         list_remove(&iter->entry);
1119         free(iter);
1120     }
1121
1122     allocator->free_sample_count = 0;
1123     allocator->cold_sample_count = 0;
1124 }
1125
1126 static void sample_allocator_set_media_type(struct sample_allocator *allocator, IMFMediaType *media_type)
1127 {
1128     UINT64 frame_size;
1129     GUID subtype;
1130
1131     if (!media_type)
1132     {
1133         if (allocator->media_type)
1134             IMFMediaType_Release(allocator->media_type);
1135         allocator->media_type = NULL;
1136         return;
1137     }
1138
1139     /* Check if type is the same. */
1140     IMFMediaType_GetUINT64(media_type, &MF_MT_FRAME_SIZE, &frame_size);
1141     IMFMediaType_GetGUID(media_type, &MF_MT_SUBTYPE, &subtype);
1142
1143     if (frame_size == ((UINT64) allocator->frame_desc.width << 32 | allocator->frame_desc.height) &&
1144             subtype.Data1 == allocator->frame_desc.d3d9_format)
1145     {
1146         return;
1147     }
1148
1149     if (allocator->media_type)
1150         IMFMediaType_Release(allocator->media_type);
1151     allocator->media_type = media_type;
1152     if (allocator->media_type)
1153         IMFMediaType_AddRef(allocator->media_type);
1154 }
1155
1156 static void sample_allocator_set_attributes(struct sample_allocator *allocator, IMFAttributes *attributes)
1157 {
1158     if (allocator->attributes)
1159         IMFAttributes_Release(allocator->attributes);
1160     allocator->attributes = attributes;
1161     if (allocator->attributes)
1162         IMFAttributes_AddRef(allocator->attributes);
1163 }
1164
1165 static ULONG WINAPI sample_allocator_Release(IMFVideoSampleAllocatorEx *iface)
1166 {
1167     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorEx(iface);
1168     ULONG refcount = InterlockedDecrement(&allocator->refcount);
1169
1170     TRACE("%p, refcount %u.\n", iface, refcount);
1171
1172     if (!refcount)
1173     {
1174         if (allocator->callback)
1175             IMFVideoSampleAllocatorNotify_Release(allocator->callback);
1176         if (allocator->d3d9_device_manager)
1177             IDirect3DDeviceManager9_Release(allocator->d3d9_device_manager);
1178         if (allocator->dxgi_device_manager)
1179             IMFDXGIDeviceManager_Release(allocator->dxgi_device_manager);
1180         sample_allocator_set_media_type(allocator, NULL);
1181         sample_allocator_set_attributes(allocator, NULL);
1182         sample_allocator_release_samples(allocator);
1183         DeleteCriticalSection(&allocator->cs);
1184         free(allocator);
1185     }
1186
1187     return refcount;
1188 }
1189
1190 static HRESULT WINAPI sample_allocator_SetDirectXManager(IMFVideoSampleAllocatorEx *iface,
1191         IUnknown *manager)
1192 {
1193     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorEx(iface);
1194     IDirect3DDeviceManager9 *d3d9_device_manager = NULL;
1195     IMFDXGIDeviceManager *dxgi_device_manager = NULL;
1196     HRESULT hr;
1197
1198     TRACE("%p, %p.\n", iface, manager);
1199
1200     if (manager)
1201     {
1202         if (FAILED(hr = IUnknown_QueryInterface(manager, &IID_IMFDXGIDeviceManager, (void **)&dxgi_device_manager)))
1203         {
1204             hr = IUnknown_QueryInterface(manager, &IID_IDirect3DDeviceManager9, (void **)&d3d9_device_manager);
1205         }
1206
1207         if (FAILED(hr))
1208             return hr;
1209     }
1210
1211     EnterCriticalSection(&allocator->cs);
1212
1213     if (allocator->d3d9_device_manager)
1214         IDirect3DDeviceManager9_Release(allocator->d3d9_device_manager);
1215     if (allocator->dxgi_device_manager)
1216         IMFDXGIDeviceManager_Release(allocator->dxgi_device_manager);
1217     allocator->d3d9_device_manager = NULL;
1218     allocator->dxgi_device_manager = NULL;
1219
1220     if (dxgi_device_manager)
1221         allocator->dxgi_device_manager = dxgi_device_manager;
1222     else if (d3d9_device_manager)
1223         allocator->d3d9_device_manager = d3d9_device_manager;
1224
1225     LeaveCriticalSection(&allocator->cs);
1226
1227     return S_OK;
1228 }
1229
1230 static HRESULT WINAPI sample_allocator_UninitializeSampleAllocator(IMFVideoSampleAllocatorEx *iface)
1231 {
1232     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorEx(iface);
1233
1234     TRACE("%p.\n", iface);
1235
1236     EnterCriticalSection(&allocator->cs);
1237
1238     sample_allocator_release_samples(allocator);
1239     sample_allocator_set_media_type(allocator, NULL);
1240     sample_allocator_set_attributes(allocator, NULL);
1241     memset(&allocator->frame_desc, 0, sizeof(allocator->frame_desc));
1242
1243     LeaveCriticalSection(&allocator->cs);
1244
1245     return S_OK;
1246 }
1247
1248 struct surface_service
1249 {
1250     IDirectXVideoProcessorService *dxva_service;
1251     ID3D11Device *d3d11_device;
1252     HANDLE hdevice;
1253 };
1254
1255 static HRESULT sample_allocator_get_surface_service(struct sample_allocator *allocator, struct surface_service *service)
1256 {
1257     HRESULT hr = S_OK;
1258
1259     memset(service, 0, sizeof(*service));
1260
1261     if (allocator->d3d9_device_manager)
1262     {
1263         if (SUCCEEDED(hr = IDirect3DDeviceManager9_OpenDeviceHandle(allocator->d3d9_device_manager, &service->hdevice)))
1264         {
1265             if (FAILED(hr = IDirect3DDeviceManager9_GetVideoService(allocator->d3d9_device_manager, service->hdevice,
1266                     &IID_IDirectXVideoProcessorService, (void **)&service->dxva_service)))
1267             {
1268                 WARN("Failed to get DXVA processor service, hr %#x.\n", hr);
1269                 IDirect3DDeviceManager9_CloseDeviceHandle(allocator->d3d9_device_manager, service->hdevice);
1270             }
1271         }
1272     }
1273     else if (allocator->dxgi_device_manager)
1274     {
1275         if (SUCCEEDED(hr = IMFDXGIDeviceManager_OpenDeviceHandle(allocator->dxgi_device_manager, &service->hdevice)))
1276         {
1277             if (FAILED(hr = IMFDXGIDeviceManager_GetVideoService(allocator->dxgi_device_manager, service->hdevice,
1278                     &IID_ID3D11Device, (void **)&service->d3d11_device)))
1279             {
1280                 WARN("Failed to get D3D11 device, hr %#x.\n", hr);
1281                 IMFDXGIDeviceManager_CloseDeviceHandle(allocator->dxgi_device_manager, service->hdevice);
1282             }
1283         }
1284     }
1285
1286     if (FAILED(hr))
1287         memset(service, 0, sizeof(*service));
1288
1289     return hr;
1290 }
1291
1292 static void sample_allocator_release_surface_service(struct sample_allocator *allocator,
1293         struct surface_service *service)
1294 {
1295     if (service->dxva_service)
1296         IDirectXVideoProcessorService_Release(service->dxva_service);
1297     if (service->d3d11_device)
1298         ID3D11Device_Release(service->d3d11_device);
1299
1300     if (allocator->d3d9_device_manager)
1301         IDirect3DDeviceManager9_CloseDeviceHandle(allocator->d3d9_device_manager, service->hdevice);
1302     else if (allocator->dxgi_device_manager)
1303         IMFDXGIDeviceManager_CloseDeviceHandle(allocator->dxgi_device_manager, service->hdevice);
1304 }
1305
1306 static HRESULT sample_allocator_allocate_sample(struct sample_allocator *allocator, const struct surface_service *service,
1307         IMFSample **sample)
1308 {
1309     struct queued_sample *queued_sample = malloc(sizeof(*queued_sample));
1310     IMFTrackedSample *tracked_sample;
1311     IMFMediaBuffer *buffer;
1312     unsigned int i;
1313     HRESULT hr;
1314
1315     if (FAILED(hr = MFCreateTrackedSample(&tracked_sample)))
1316     {
1317         return hr;
1318     }
1319
1320     IMFTrackedSample_QueryInterface(tracked_sample, &IID_IMFSample, (void **)sample);
1321     IMFTrackedSample_Release(tracked_sample);
1322
1323     for (i = 0; i < allocator->frame_desc.buffer_count; ++i)
1324     {
1325         if (service->dxva_service)
1326         {
1327             IDirect3DSurface9 *surface;
1328
1329             if (SUCCEEDED(hr = IDirectXVideoProcessorService_CreateSurface(service->dxva_service, allocator->frame_desc.width,
1330                     allocator->frame_desc.height, 0, allocator->frame_desc.d3d9_format, D3DPOOL_DEFAULT, 0,
1331                     DXVA2_VideoProcessorRenderTarget, &surface, NULL)))
1332             {
1333                 hr = MFCreateDXSurfaceBuffer(&IID_IDirect3DSurface9, (IUnknown *)surface, FALSE, &buffer);
1334                 IDirect3DSurface9_Release(surface);
1335             }
1336         }
1337         else if (service->d3d11_device)
1338         {
1339             D3D11_TEXTURE2D_DESC desc = { 0 };
1340             ID3D11Texture2D *texture;
1341
1342             desc.Width = allocator->frame_desc.width;
1343             desc.Height = allocator->frame_desc.height;
1344             desc.MipLevels = 1;
1345             desc.ArraySize = 1;
1346             desc.Format = allocator->frame_desc.dxgi_format;
1347             desc.SampleDesc.Count = 1;
1348             desc.SampleDesc.Quality = 0;
1349             desc.Usage = allocator->frame_desc.usage;
1350             desc.BindFlags = allocator->frame_desc.bindflags;
1351             if (desc.Usage == D3D11_USAGE_DYNAMIC)
1352                 desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
1353             else if (desc.Usage == D3D11_USAGE_STAGING)
1354                 desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
1355
1356             if (SUCCEEDED(hr = ID3D11Device_CreateTexture2D(service->d3d11_device, &desc, NULL, &texture)))
1357             {
1358                 hr = MFCreateDXGISurfaceBuffer(&IID_ID3D11Texture2D, (IUnknown *)texture, 0, FALSE, &buffer);
1359                 ID3D11Texture2D_Release(texture);
1360             }
1361         }
1362         else
1363         {
1364             hr = MFCreate2DMediaBuffer(allocator->frame_desc.width, allocator->frame_desc.height,
1365                     allocator->frame_desc.d3d9_format, FALSE, &buffer);
1366         }
1367
1368         if (SUCCEEDED(hr))
1369         {
1370             hr = IMFSample_AddBuffer(*sample, buffer);
1371             IMFMediaBuffer_Release(buffer);
1372         }
1373     }
1374
1375     return hr;
1376 }
1377
1378 static HRESULT sample_allocator_initialize(struct sample_allocator *allocator, unsigned int sample_count,
1379         unsigned int max_sample_count, IMFAttributes *attributes, IMFMediaType *media_type)
1380 {
1381     struct surface_service service;
1382     DXGI_FORMAT dxgi_format;
1383     unsigned int i;
1384     GUID major, subtype;
1385     UINT64 frame_size;
1386     IMFSample *sample;
1387     D3D11_USAGE usage;
1388     HRESULT hr;
1389
1390     if (FAILED(hr = IMFMediaType_GetMajorType(media_type, &major)))
1391         return hr;
1392
1393     if (!IsEqualGUID(&major, &MFMediaType_Video))
1394         return MF_E_INVALIDMEDIATYPE;
1395
1396     if (FAILED(hr = IMFMediaType_GetUINT64(media_type, &MF_MT_FRAME_SIZE, &frame_size)))
1397         return hr;
1398
1399     if (FAILED(hr = IMFMediaType_GetGUID(media_type, &MF_MT_SUBTYPE, &subtype)))
1400         return hr;
1401
1402     if (sample_count > max_sample_count)
1403         return E_INVALIDARG;
1404
1405     usage = D3D11_USAGE_DEFAULT;
1406     if (attributes)
1407     {
1408         IMFAttributes_GetUINT32(attributes, &MF_SA_BUFFERS_PER_SAMPLE, &allocator->frame_desc.buffer_count);
1409         IMFAttributes_GetUINT32(attributes, &MF_SA_D3D11_USAGE, &usage);
1410     }
1411
1412     if (usage == D3D11_USAGE_IMMUTABLE || usage > D3D11_USAGE_STAGING)
1413         return E_INVALIDARG;
1414
1415     dxgi_format = MFMapDX9FormatToDXGIFormat(subtype.Data1);
1416
1417     allocator->frame_desc.bindflags = 0;
1418     allocator->frame_desc.usage = D3D11_USAGE_DEFAULT;
1419
1420     if (dxgi_format == DXGI_FORMAT_B8G8R8A8_UNORM ||
1421             dxgi_format == DXGI_FORMAT_B8G8R8X8_UNORM)
1422     {
1423         allocator->frame_desc.usage = usage;
1424         if (allocator->frame_desc.usage == D3D11_USAGE_DEFAULT)
1425             allocator->frame_desc.bindflags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
1426         else if (allocator->frame_desc.usage == D3D11_USAGE_DYNAMIC)
1427             allocator->frame_desc.bindflags = D3D11_BIND_SHADER_RESOURCE;
1428     }
1429
1430     if (attributes)
1431         IMFAttributes_GetUINT32(attributes, &MF_SA_D3D11_BINDFLAGS, &allocator->frame_desc.bindflags);
1432
1433     sample_allocator_set_media_type(allocator, media_type);
1434     sample_allocator_set_attributes(allocator, attributes);
1435
1436     sample_count = max(1, sample_count);
1437     max_sample_count = max(1, max_sample_count);
1438
1439     allocator->frame_desc.d3d9_format = subtype.Data1;
1440     allocator->frame_desc.dxgi_format = dxgi_format;
1441     allocator->frame_desc.width = frame_size >> 32;
1442     allocator->frame_desc.height = frame_size;
1443     allocator->frame_desc.buffer_count = max(1, allocator->frame_desc.buffer_count);
1444
1445     if (FAILED(hr = sample_allocator_get_surface_service(allocator, &service)))
1446         return hr;
1447
1448     sample_allocator_release_samples(allocator);
1449
1450     for (i = 0; i < sample_count; ++i)
1451     {
1452         struct queued_sample *queued_sample;
1453
1454         if (SUCCEEDED(hr = sample_allocator_allocate_sample(allocator, &service, &sample)))
1455         {
1456             queued_sample = malloc(sizeof(*queued_sample));
1457             queued_sample->sample = sample;
1458             list_add_tail(&allocator->free_samples, &queued_sample->entry);
1459             allocator->free_sample_count++;
1460         }
1461     }
1462     allocator->cold_sample_count = max_sample_count - allocator->free_sample_count;
1463
1464     sample_allocator_release_surface_service(allocator, &service);
1465
1466     return hr;
1467 }
1468
1469 static HRESULT WINAPI sample_allocator_InitializeSampleAllocator(IMFVideoSampleAllocatorEx *iface,
1470         DWORD sample_count, IMFMediaType *media_type)
1471 {
1472     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorEx(iface);
1473     HRESULT hr;
1474
1475     TRACE("%p, %u, %p.\n", iface, sample_count, media_type);
1476
1477     if (!sample_count)
1478         return E_INVALIDARG;
1479
1480     EnterCriticalSection(&allocator->cs);
1481
1482     hr = sample_allocator_initialize(allocator, sample_count, sample_count, NULL, media_type);
1483
1484     LeaveCriticalSection(&allocator->cs);
1485
1486     return hr;
1487 }
1488
1489 static HRESULT sample_allocator_track_sample(struct sample_allocator *allocator, IMFSample *sample)
1490 {
1491     IMFTrackedSample *tracked_sample;
1492     HRESULT hr;
1493
1494     if (SUCCEEDED(hr = IMFSample_QueryInterface(sample, &IID_IMFTrackedSample, (void **)&tracked_sample)))
1495     {
1496         hr = IMFTrackedSample_SetAllocator(tracked_sample, &allocator->tracking_callback, NULL);
1497         IMFTrackedSample_Release(tracked_sample);
1498     }
1499
1500     return hr;
1501 }
1502
1503 static HRESULT WINAPI sample_allocator_AllocateSample(IMFVideoSampleAllocatorEx *iface, IMFSample **out)
1504 {
1505     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorEx(iface);
1506     IMFSample *sample;
1507     HRESULT hr;
1508
1509     TRACE("%p, %p.\n", iface, out);
1510
1511     EnterCriticalSection(&allocator->cs);
1512
1513     if (list_empty(&allocator->free_samples) && list_empty(&allocator->used_samples))
1514         hr = MF_E_NOT_INITIALIZED;
1515     else if (list_empty(&allocator->free_samples) && !allocator->cold_sample_count)
1516         hr = MF_E_SAMPLEALLOCATOR_EMPTY;
1517     else if (!list_empty(&allocator->free_samples))
1518     {
1519         struct list *head = list_head(&allocator->free_samples);
1520
1521         sample = LIST_ENTRY(head, struct queued_sample, entry)->sample;
1522
1523         if (SUCCEEDED(hr = sample_allocator_track_sample(allocator, sample)))
1524         {
1525             list_remove(head);
1526             list_add_tail(&allocator->used_samples, head);
1527             allocator->free_sample_count--;
1528
1529             /* Reference counter is not increased when sample is returned, so next release could trigger
1530                tracking condition. This is balanced by incremented reference counter when sample is returned
1531                back to the free list. */
1532             *out = sample;
1533         }
1534     }
1535     else /* allocator->cold_sample_count != 0 */
1536     {
1537         struct surface_service service;
1538
1539         if (SUCCEEDED(hr = sample_allocator_get_surface_service(allocator, &service)))
1540         {
1541             if (SUCCEEDED(hr = sample_allocator_allocate_sample(allocator, &service, &sample)))
1542             {
1543                 if (SUCCEEDED(hr = sample_allocator_track_sample(allocator, sample)))
1544                 {
1545                     struct queued_sample *queued_sample = malloc(sizeof(*queued_sample));
1546
1547                     queued_sample->sample = sample;
1548                     list_add_tail(&allocator->used_samples, &queued_sample->entry);
1549                     allocator->cold_sample_count--;
1550
1551                     *out = queued_sample->sample;
1552                 }
1553             }
1554
1555             sample_allocator_release_surface_service(allocator, &service);
1556         }
1557     }
1558
1559     LeaveCriticalSection(&allocator->cs);
1560
1561     return hr;
1562 }
1563
1564 static HRESULT WINAPI sample_allocator_InitializeSampleAllocatorEx(IMFVideoSampleAllocatorEx *iface, DWORD initial_sample_count,
1565         DWORD max_sample_count, IMFAttributes *attributes, IMFMediaType *media_type)
1566 {
1567     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorEx(iface);
1568     HRESULT hr;
1569
1570     TRACE("%p, %u, %u, %p, %p.\n", iface, initial_sample_count, max_sample_count, attributes, media_type);
1571
1572     EnterCriticalSection(&allocator->cs);
1573
1574     hr = sample_allocator_initialize(allocator, initial_sample_count, max_sample_count, attributes, media_type);
1575
1576     LeaveCriticalSection(&allocator->cs);
1577
1578     return hr;
1579 }
1580
1581 static const IMFVideoSampleAllocatorExVtbl sample_allocator_vtbl =
1582 {
1583     sample_allocator_QueryInterface,
1584     sample_allocator_AddRef,
1585     sample_allocator_Release,
1586     sample_allocator_SetDirectXManager,
1587     sample_allocator_UninitializeSampleAllocator,
1588     sample_allocator_InitializeSampleAllocator,
1589     sample_allocator_AllocateSample,
1590     sample_allocator_InitializeSampleAllocatorEx,
1591 };
1592
1593 static HRESULT WINAPI sample_allocator_callback_QueryInterface(IMFVideoSampleAllocatorCallback *iface,
1594         REFIID riid, void **obj)
1595 {
1596     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorCallback(iface);
1597     return IMFVideoSampleAllocatorEx_QueryInterface(&allocator->IMFVideoSampleAllocatorEx_iface, riid, obj);
1598 }
1599
1600 static ULONG WINAPI sample_allocator_callback_AddRef(IMFVideoSampleAllocatorCallback *iface)
1601 {
1602     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorCallback(iface);
1603     return IMFVideoSampleAllocatorEx_AddRef(&allocator->IMFVideoSampleAllocatorEx_iface);
1604 }
1605
1606 static ULONG WINAPI sample_allocator_callback_Release(IMFVideoSampleAllocatorCallback *iface)
1607 {
1608     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorCallback(iface);
1609     return IMFVideoSampleAllocatorEx_Release(&allocator->IMFVideoSampleAllocatorEx_iface);
1610 }
1611
1612 static HRESULT WINAPI sample_allocator_callback_SetCallback(IMFVideoSampleAllocatorCallback *iface,
1613         IMFVideoSampleAllocatorNotify *callback)
1614 {
1615     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorCallback(iface);
1616
1617     TRACE("%p, %p.\n", iface, callback);
1618
1619     EnterCriticalSection(&allocator->cs);
1620     if (allocator->callback)
1621         IMFVideoSampleAllocatorNotify_Release(allocator->callback);
1622     allocator->callback = callback;
1623     if (allocator->callback)
1624         IMFVideoSampleAllocatorNotify_AddRef(allocator->callback);
1625     LeaveCriticalSection(&allocator->cs);
1626
1627     return S_OK;
1628 }
1629
1630 static HRESULT WINAPI sample_allocator_callback_GetFreeSampleCount(IMFVideoSampleAllocatorCallback *iface,
1631         LONG *count)
1632 {
1633     struct sample_allocator *allocator = impl_from_IMFVideoSampleAllocatorCallback(iface);
1634
1635     TRACE("%p, %p.\n", iface, count);
1636
1637     if (!count)
1638         return E_POINTER;
1639
1640     EnterCriticalSection(&allocator->cs);
1641     *count = allocator->free_sample_count;
1642     LeaveCriticalSection(&allocator->cs);
1643
1644     return S_OK;
1645 }
1646
1647 static const IMFVideoSampleAllocatorCallbackVtbl sample_allocator_callback_vtbl =
1648 {
1649     sample_allocator_callback_QueryInterface,
1650     sample_allocator_callback_AddRef,
1651     sample_allocator_callback_Release,
1652     sample_allocator_callback_SetCallback,
1653     sample_allocator_callback_GetFreeSampleCount,
1654 };
1655
1656 static HRESULT WINAPI sample_allocator_tracking_callback_QueryInterface(IMFAsyncCallback *iface,
1657         REFIID riid, void **obj)
1658 {
1659     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
1660             IsEqualIID(riid, &IID_IUnknown))
1661     {
1662         *obj = iface;
1663         IMFAsyncCallback_AddRef(iface);
1664         return S_OK;
1665     }
1666
1667     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1668     *obj = NULL;
1669     return E_NOINTERFACE;
1670 }
1671
1672 static ULONG WINAPI sample_allocator_tracking_callback_AddRef(IMFAsyncCallback *iface)
1673 {
1674     struct sample_allocator *allocator = impl_from_IMFAsyncCallback(iface);
1675     return IMFVideoSampleAllocatorEx_AddRef(&allocator->IMFVideoSampleAllocatorEx_iface);
1676 }
1677
1678 static ULONG WINAPI sample_allocator_tracking_callback_Release(IMFAsyncCallback *iface)
1679 {
1680     struct sample_allocator *allocator = impl_from_IMFAsyncCallback(iface);
1681     return IMFVideoSampleAllocatorEx_Release(&allocator->IMFVideoSampleAllocatorEx_iface);
1682 }
1683
1684 static HRESULT WINAPI sample_allocator_tracking_callback_GetParameters(IMFAsyncCallback *iface,
1685         DWORD *flags, DWORD *queue)
1686 {
1687     return E_NOTIMPL;
1688 }
1689
1690 static HRESULT WINAPI sample_allocator_tracking_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1691 {
1692     struct sample_allocator *allocator = impl_from_IMFAsyncCallback(iface);
1693     struct queued_sample *iter;
1694     IUnknown *object = NULL;
1695     IMFSample *sample = NULL;
1696     HRESULT hr;
1697
1698     if (FAILED(IMFAsyncResult_GetObject(result, &object)))
1699         return E_UNEXPECTED;
1700
1701     hr = IUnknown_QueryInterface(object, &IID_IMFSample, (void **)&sample);
1702     IUnknown_Release(object);
1703     if (FAILED(hr))
1704         return E_UNEXPECTED;
1705
1706     EnterCriticalSection(&allocator->cs);
1707
1708     LIST_FOR_EACH_ENTRY(iter, &allocator->used_samples, struct queued_sample, entry)
1709     {
1710         if (sample == iter->sample)
1711         {
1712             list_remove(&iter->entry);
1713             list_add_tail(&allocator->free_samples, &iter->entry);
1714             IMFSample_AddRef(iter->sample);
1715             allocator->free_sample_count++;
1716             break;
1717         }
1718     }
1719
1720     IMFSample_Release(sample);
1721
1722     if (allocator->callback)
1723         IMFVideoSampleAllocatorNotify_NotifyRelease(allocator->callback);
1724
1725     LeaveCriticalSection(&allocator->cs);
1726
1727     return S_OK;
1728 }
1729
1730 static const IMFAsyncCallbackVtbl sample_allocator_tracking_callback_vtbl =
1731 {
1732     sample_allocator_tracking_callback_QueryInterface,
1733     sample_allocator_tracking_callback_AddRef,
1734     sample_allocator_tracking_callback_Release,
1735     sample_allocator_tracking_callback_GetParameters,
1736     sample_allocator_tracking_callback_Invoke,
1737 };
1738
1739 /***********************************************************************
1740  *      MFCreateVideoSampleAllocatorEx (mfplat.@)
1741  */
1742 HRESULT WINAPI MFCreateVideoSampleAllocatorEx(REFIID riid, void **obj)
1743 {
1744     struct sample_allocator *object;
1745     HRESULT hr;
1746
1747     TRACE("%s, %p.\n", debugstr_guid(riid), obj);
1748
1749     if (!(object = calloc(1, sizeof(*object))))
1750         return E_OUTOFMEMORY;
1751
1752     object->IMFVideoSampleAllocatorEx_iface.lpVtbl = &sample_allocator_vtbl;
1753     object->IMFVideoSampleAllocatorCallback_iface.lpVtbl = &sample_allocator_callback_vtbl;
1754     object->tracking_callback.lpVtbl = &sample_allocator_tracking_callback_vtbl;
1755     object->refcount = 1;
1756     list_init(&object->used_samples);
1757     list_init(&object->free_samples);
1758     InitializeCriticalSection(&object->cs);
1759
1760     hr = IMFVideoSampleAllocatorEx_QueryInterface(&object->IMFVideoSampleAllocatorEx_iface, riid, obj);
1761     IMFVideoSampleAllocatorEx_Release(&object->IMFVideoSampleAllocatorEx_iface);
1762
1763     return hr;
1764 }