dlls/evr/sample.c

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