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, %u.\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, %u.\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, %#x.\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 %#x.\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 %u.\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 %u.\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, %#x.\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, %u, %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 %u.\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;
 924
 925     IMFSample_LockStore(sample->sample);
 926     if (sample->tracked_result && sample->tracked_refcount == (sample->refcount - 1))
 927     {
 928         video_sample_tracking_thread_invoke(sample->tracked_result);
 929         IMFAsyncResult_Release(sample->tracked_result);
 930         sample->tracked_result = NULL;
 931         sample->tracked_refcount = 0;
 932     }
 933     IMFSample_UnlockStore(sample->sample);
 934
 935     refcount = InterlockedDecrement(&sample->refcount);
 936
 937     TRACE("%p, refcount %u.\n", iface, refcount);
 938
 939     if (!refcount)
 940     {
 941         video_sample_stop_tracking_thread();
 942         if (sample->sample)
 943             IMFSample_Release(sample->sample);
 944         DeleteCriticalSection(&sample->cs);
 945         free(sample);
 946     }
 947
 948     return refcount;
 949 }
 950
 951 static HRESULT WINAPI video_sample_GetItem(IMFSample *iface, REFGUID key, PROPVARIANT *value)
 952 {
 953     struct video_sample *sample = impl_from_IMFSample(iface);
 954
 955     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 956
 957     return IMFSample_GetItem(sample->sample, key, value);
 958 }
 959
 960 static HRESULT WINAPI video_sample_GetItemType(IMFSample *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 961 {
 962     struct video_sample *sample = impl_from_IMFSample(iface);
 963
 964     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
 965
 966     return IMFSample_GetItemType(sample->sample, key, type);
 967 }
 968
 969 static HRESULT WINAPI video_sample_CompareItem(IMFSample *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
 970 {
 971     struct video_sample *sample = impl_from_IMFSample(iface);
 972
 973     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
 974
 975     return IMFSample_CompareItem(sample->sample, key, value, result);
 976 }
 977
 978 static HRESULT WINAPI video_sample_Compare(IMFSample *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
 979         BOOL *result)
 980 {
 981     struct video_sample *sample = impl_from_IMFSample(iface);
 982
 983     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
 984
 985     return IMFSample_Compare(sample->sample, theirs, type, result);
 986 }
 987
 988 static HRESULT WINAPI video_sample_GetUINT32(IMFSample *iface, REFGUID key, UINT32 *value)
 989 {
 990     struct video_sample *sample = impl_from_IMFSample(iface);
 991
 992     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 993
 994     return IMFSample_GetUINT32(sample->sample, key, value);
 995 }
 996
 997 static HRESULT WINAPI video_sample_GetUINT64(IMFSample *iface, REFGUID key, UINT64 *value)
 998 {
 999     struct video_sample *sample = impl_from_IMFSample(iface);
1000
1001     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1002
1003     return IMFSample_GetUINT64(sample->sample, key, value);
1004 }
1005
1006 static HRESULT WINAPI video_sample_GetDouble(IMFSample *iface, REFGUID key, double *value)
1007 {
1008     struct video_sample *sample = impl_from_IMFSample(iface);
1009
1010     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1011
1012     return IMFSample_GetDouble(sample->sample, key, value);
1013 }
1014
1015 static HRESULT WINAPI video_sample_GetGUID(IMFSample *iface, REFGUID key, GUID *value)
1016 {
1017     struct video_sample *sample = impl_from_IMFSample(iface);
1018
1019     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1020
1021     return IMFSample_GetGUID(sample->sample, key, value);
1022 }
1023
1024 static HRESULT WINAPI video_sample_GetStringLength(IMFSample *iface, REFGUID key, UINT32 *length)
1025 {
1026     struct video_sample *sample = impl_from_IMFSample(iface);
1027
1028     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
1029
1030     return IMFSample_GetStringLength(sample->sample, key, length);
1031 }
1032
1033 static HRESULT WINAPI video_sample_GetString(IMFSample *iface, REFGUID key, WCHAR *value, UINT32 size, UINT32 *length)
1034 {
1035     struct video_sample *sample = impl_from_IMFSample(iface);
1036
1037     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), value, size, length);
1038
1039     return IMFSample_GetString(sample->sample, key, value, size, length);
1040 }
1041
1042 static HRESULT WINAPI video_sample_GetAllocatedString(IMFSample *iface, REFGUID key, WCHAR **value, UINT32 *length)
1043 {
1044     struct video_sample *sample = impl_from_IMFSample(iface);
1045
1046     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
1047
1048     return IMFSample_GetAllocatedString(sample->sample, key, value, length);
1049 }
1050
1051 static HRESULT WINAPI video_sample_GetBlobSize(IMFSample *iface, REFGUID key, UINT32 *size)
1052 {
1053     struct video_sample *sample = impl_from_IMFSample(iface);
1054
1055     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
1056
1057     return IMFSample_GetBlobSize(sample->sample, key, size);
1058 }
1059
1060 static HRESULT WINAPI video_sample_GetBlob(IMFSample *iface, REFGUID key, UINT8 *buf, UINT32 bufsize, UINT32 *blobsize)
1061 {
1062     struct video_sample *sample = impl_from_IMFSample(iface);
1063
1064     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
1065
1066     return IMFSample_GetBlob(sample->sample, key, buf, bufsize, blobsize);
1067 }
1068
1069 static HRESULT WINAPI video_sample_GetAllocatedBlob(IMFSample *iface, REFGUID key, UINT8 **buf, UINT32 *size)
1070 {
1071     struct video_sample *sample = impl_from_IMFSample(iface);
1072
1073     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
1074
1075     return IMFSample_GetAllocatedBlob(sample->sample, key, buf, size);
1076 }
1077
1078 static HRESULT WINAPI video_sample_GetUnknown(IMFSample *iface, REFGUID key, REFIID riid, void **out)
1079 {
1080     struct video_sample *sample = impl_from_IMFSample(iface);
1081
1082     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), out);
1083
1084     return IMFSample_GetUnknown(sample->sample, key, riid, out);
1085 }
1086
1087 static HRESULT WINAPI video_sample_SetItem(IMFSample *iface, REFGUID key, REFPROPVARIANT value)
1088 {
1089     struct video_sample *sample = impl_from_IMFSample(iface);
1090
1091     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1092
1093     return IMFSample_SetItem(sample->sample, key, value);
1094 }
1095
1096 static HRESULT WINAPI video_sample_DeleteItem(IMFSample *iface, REFGUID key)
1097 {
1098     struct video_sample *sample = impl_from_IMFSample(iface);
1099
1100     TRACE("%p, %s.\n", iface, debugstr_guid(key));
1101
1102     return IMFSample_DeleteItem(sample->sample, key);
1103 }
1104
1105 static HRESULT WINAPI video_sample_DeleteAllItems(IMFSample *iface)
1106 {
1107     struct video_sample *sample = impl_from_IMFSample(iface);
1108
1109     TRACE("%p.\n", iface);
1110
1111     return IMFSample_DeleteAllItems(sample->sample);
1112 }
1113
1114 static HRESULT WINAPI video_sample_SetUINT32(IMFSample *iface, REFGUID key, UINT32 value)
1115 {
1116     struct video_sample *sample = impl_from_IMFSample(iface);
1117
1118     TRACE("%p, %s, %u.\n", iface, debugstr_guid(key), value);
1119
1120     return IMFSample_SetUINT32(sample->sample, key, value);
1121 }
1122
1123 static HRESULT WINAPI video_sample_SetUINT64(IMFSample *iface, REFGUID key, UINT64 value)
1124 {
1125     struct video_sample *sample = impl_from_IMFSample(iface);
1126
1127     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
1128
1129     return IMFSample_SetUINT64(sample->sample, key, value);
1130 }
1131
1132 static HRESULT WINAPI video_sample_SetDouble(IMFSample *iface, REFGUID key, double value)
1133 {
1134     struct video_sample *sample = impl_from_IMFSample(iface);
1135
1136     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
1137
1138     return IMFSample_SetDouble(sample->sample, key, value);
1139 }
1140
1141 static HRESULT WINAPI video_sample_SetGUID(IMFSample *iface, REFGUID key, REFGUID value)
1142 {
1143     struct video_sample *sample = impl_from_IMFSample(iface);
1144
1145     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
1146
1147     return IMFSample_SetGUID(sample->sample, key, value);
1148 }
1149
1150 static HRESULT WINAPI video_sample_SetString(IMFSample *iface, REFGUID key, const WCHAR *value)
1151 {
1152     struct video_sample *sample = impl_from_IMFSample(iface);
1153
1154     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
1155
1156     return IMFSample_SetString(sample->sample, key, value);
1157 }
1158
1159 static HRESULT WINAPI video_sample_SetBlob(IMFSample *iface, REFGUID key, const UINT8 *buf, UINT32 size)
1160 {
1161     struct video_sample *sample = impl_from_IMFSample(iface);
1162
1163     TRACE("%p, %s, %p, %u.\n", iface, debugstr_guid(key), buf, size);
1164
1165     return IMFSample_SetBlob(sample->sample, key, buf, size);
1166 }
1167
1168 static HRESULT WINAPI video_sample_SetUnknown(IMFSample *iface, REFGUID key, IUnknown *unknown)
1169 {
1170     struct video_sample *sample = impl_from_IMFSample(iface);
1171
1172     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), unknown);
1173
1174     return IMFSample_SetUnknown(sample->sample, key, unknown);
1175 }
1176
1177 static HRESULT WINAPI video_sample_LockStore(IMFSample *iface)
1178 {
1179     struct video_sample *sample = impl_from_IMFSample(iface);
1180
1181     TRACE("%p.\n", iface);
1182
1183     return IMFSample_LockStore(sample->sample);
1184 }
1185
1186 static HRESULT WINAPI video_sample_UnlockStore(IMFSample *iface)
1187 {
1188     struct video_sample *sample = impl_from_IMFSample(iface);
1189
1190     TRACE("%p.\n", iface);
1191
1192     return IMFSample_UnlockStore(sample->sample);
1193 }
1194
1195 static HRESULT WINAPI video_sample_GetCount(IMFSample *iface, UINT32 *count)
1196 {
1197     struct video_sample *sample = impl_from_IMFSample(iface);
1198
1199     TRACE("%p, %p.\n", iface, count);
1200
1201     return IMFSample_GetCount(sample->sample, count);
1202 }
1203
1204 static HRESULT WINAPI video_sample_GetItemByIndex(IMFSample *iface, UINT32 index, GUID *key, PROPVARIANT *value)
1205 {
1206     struct video_sample *sample = impl_from_IMFSample(iface);
1207
1208     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
1209
1210     return IMFSample_GetItemByIndex(sample->sample, index, key, value);
1211 }
1212
1213 static HRESULT WINAPI video_sample_CopyAllItems(IMFSample *iface, IMFAttributes *dest)
1214 {
1215     struct video_sample *sample = impl_from_IMFSample(iface);
1216
1217     TRACE("%p, %p.\n", iface, dest);
1218
1219     return IMFSample_CopyAllItems(sample->sample, dest);
1220 }
1221
1222 static HRESULT WINAPI video_sample_GetSampleFlags(IMFSample *iface, DWORD *flags)
1223 {
1224     struct video_sample *sample = impl_from_IMFSample(iface);
1225
1226     TRACE("%p, %p.\n", iface, flags);
1227
1228     return IMFSample_GetSampleFlags(sample->sample, flags);
1229 }
1230
1231 static HRESULT WINAPI video_sample_SetSampleFlags(IMFSample *iface, DWORD flags)
1232 {
1233     struct video_sample *sample = impl_from_IMFSample(iface);
1234
1235     TRACE("%p, %#x.\n", iface, flags);
1236
1237     return IMFSample_SetSampleFlags(sample->sample, flags);
1238 }
1239
1240 static HRESULT WINAPI video_sample_GetSampleTime(IMFSample *iface, LONGLONG *timestamp)
1241 {
1242     struct video_sample *sample = impl_from_IMFSample(iface);
1243     HRESULT hr = S_OK;
1244
1245     TRACE("%p, %p.\n", iface, timestamp);
1246
1247     EnterCriticalSection(&sample->cs);
1248     if (sample->flags & SAMPLE_PROP_HAS_TIMESTAMP)
1249         *timestamp = sample->timestamp;
1250     else
1251         hr = MF_E_NO_SAMPLE_TIMESTAMP;
1252     LeaveCriticalSection(&sample->cs);
1253
1254     return hr;
1255 }
1256
1257 static HRESULT WINAPI video_sample_SetSampleTime(IMFSample *iface, LONGLONG timestamp)
1258 {
1259     struct video_sample *sample = impl_from_IMFSample(iface);
1260
1261     TRACE("%p, %s.\n", iface, debugstr_time(timestamp));
1262
1263     EnterCriticalSection(&sample->cs);
1264     sample->timestamp = timestamp;
1265     sample->flags |= SAMPLE_PROP_HAS_TIMESTAMP;
1266     LeaveCriticalSection(&sample->cs);
1267
1268     return S_OK;
1269 }
1270
1271 static HRESULT WINAPI video_sample_GetSampleDuration(IMFSample *iface, LONGLONG *duration)
1272 {
1273     struct video_sample *sample = impl_from_IMFSample(iface);
1274     HRESULT hr = S_OK;
1275
1276     TRACE("%p, %p.\n", iface, duration);
1277
1278     EnterCriticalSection(&sample->cs);
1279     if (sample->flags & SAMPLE_PROP_HAS_DURATION)
1280         *duration = sample->duration;
1281     else
1282         hr = MF_E_NO_SAMPLE_DURATION;
1283     LeaveCriticalSection(&sample->cs);
1284
1285     return hr;
1286 }
1287
1288 static HRESULT WINAPI video_sample_SetSampleDuration(IMFSample *iface, LONGLONG duration)
1289 {
1290     struct video_sample *sample = impl_from_IMFSample(iface);
1291
1292     TRACE("%p, %s.\n", iface, debugstr_time(duration));
1293
1294     EnterCriticalSection(&sample->cs);
1295     sample->duration = duration;
1296     sample->flags |= SAMPLE_PROP_HAS_DURATION;
1297     LeaveCriticalSection(&sample->cs);
1298
1299     return S_OK;
1300 }
1301
1302 static HRESULT WINAPI video_sample_GetBufferCount(IMFSample *iface, DWORD *count)
1303 {
1304     struct video_sample *sample = impl_from_IMFSample(iface);
1305
1306     TRACE("%p, %p.\n", iface, count);
1307
1308     return IMFSample_GetBufferCount(sample->sample, count);
1309 }
1310
1311 static HRESULT WINAPI video_sample_GetBufferByIndex(IMFSample *iface, DWORD index, IMFMediaBuffer **buffer)
1312 {
1313     struct video_sample *sample = impl_from_IMFSample(iface);
1314
1315     TRACE("%p, %u, %p.\n", iface, index, buffer);
1316
1317     return IMFSample_GetBufferByIndex(sample->sample, index, buffer);
1318 }
1319
1320 static HRESULT WINAPI video_sample_ConvertToContiguousBuffer(IMFSample *iface, IMFMediaBuffer **buffer)
1321 {
1322     TRACE("%p, %p.\n", iface, buffer);
1323
1324     return E_NOTIMPL;
1325 }
1326
1327 static HRESULT WINAPI video_sample_AddBuffer(IMFSample *iface, IMFMediaBuffer *buffer)
1328 {
1329     struct video_sample *sample = impl_from_IMFSample(iface);
1330
1331     TRACE("%p, %p.\n", iface, buffer);
1332
1333     return IMFSample_AddBuffer(sample->sample, buffer);
1334 }
1335
1336 static HRESULT WINAPI video_sample_RemoveBufferByIndex(IMFSample *iface, DWORD index)
1337 {
1338     struct video_sample *sample = impl_from_IMFSample(iface);
1339
1340     TRACE("%p, %u.\n", iface, index);
1341
1342     return IMFSample_RemoveBufferByIndex(sample->sample, index);
1343 }
1344
1345 static HRESULT WINAPI video_sample_RemoveAllBuffers(IMFSample *iface)
1346 {
1347     struct video_sample *sample = impl_from_IMFSample(iface);
1348
1349     TRACE("%p.\n", iface);
1350
1351     return IMFSample_RemoveAllBuffers(sample->sample);
1352 }
1353
1354 static HRESULT WINAPI video_sample_GetTotalLength(IMFSample *iface, DWORD *total_length)
1355 {
1356     TRACE("%p, %p.\n", iface, total_length);
1357
1358     *total_length = 0;
1359
1360     return S_OK;
1361 }
1362
1363 static HRESULT WINAPI video_sample_CopyToBuffer(IMFSample *iface, IMFMediaBuffer *buffer)
1364 {
1365     TRACE("%p, %p.\n", iface, buffer);
1366
1367     return E_NOTIMPL;
1368 }
1369
1370 static const IMFSampleVtbl video_sample_vtbl =
1371 {
1372     video_sample_QueryInterface,
1373     video_sample_AddRef,
1374     video_sample_Release,
1375     video_sample_GetItem,
1376     video_sample_GetItemType,
1377     video_sample_CompareItem,
1378     video_sample_Compare,
1379     video_sample_GetUINT32,
1380     video_sample_GetUINT64,
1381     video_sample_GetDouble,
1382     video_sample_GetGUID,
1383     video_sample_GetStringLength,
1384     video_sample_GetString,
1385     video_sample_GetAllocatedString,
1386     video_sample_GetBlobSize,
1387     video_sample_GetBlob,
1388     video_sample_GetAllocatedBlob,
1389     video_sample_GetUnknown,
1390     video_sample_SetItem,
1391     video_sample_DeleteItem,
1392     video_sample_DeleteAllItems,
1393     video_sample_SetUINT32,
1394     video_sample_SetUINT64,
1395     video_sample_SetDouble,
1396     video_sample_SetGUID,
1397     video_sample_SetString,
1398     video_sample_SetBlob,
1399     video_sample_SetUnknown,
1400     video_sample_LockStore,
1401     video_sample_UnlockStore,
1402     video_sample_GetCount,
1403     video_sample_GetItemByIndex,
1404     video_sample_CopyAllItems,
1405     video_sample_GetSampleFlags,
1406     video_sample_SetSampleFlags,
1407     video_sample_GetSampleTime,
1408     video_sample_SetSampleTime,
1409     video_sample_GetSampleDuration,
1410     video_sample_SetSampleDuration,
1411     video_sample_GetBufferCount,
1412     video_sample_GetBufferByIndex,
1413     video_sample_ConvertToContiguousBuffer,
1414     video_sample_AddBuffer,
1415     video_sample_RemoveBufferByIndex,
1416     video_sample_RemoveAllBuffers,
1417     video_sample_GetTotalLength,
1418     video_sample_CopyToBuffer,
1419 };
1420
1421 static HRESULT WINAPI tracked_video_sample_QueryInterface(IMFTrackedSample *iface, REFIID riid, void **obj)
1422 {
1423     struct video_sample *sample = impl_from_IMFTrackedSample(iface);
1424     return IMFSample_QueryInterface(&sample->IMFSample_iface, riid, obj);
1425 }
1426
1427 static ULONG WINAPI tracked_video_sample_AddRef(IMFTrackedSample *iface)
1428 {
1429     struct video_sample *sample = impl_from_IMFTrackedSample(iface);
1430     return IMFSample_AddRef(&sample->IMFSample_iface);
1431 }
1432
1433 static ULONG WINAPI tracked_video_sample_Release(IMFTrackedSample *iface)
1434 {
1435     struct video_sample *sample = impl_from_IMFTrackedSample(iface);
1436     return IMFSample_Release(&sample->IMFSample_iface);
1437 }
1438
1439 static HRESULT WINAPI tracked_video_sample_SetAllocator(IMFTrackedSample *iface,
1440         IMFAsyncCallback *sample_allocator, IUnknown *state)
1441 {
1442     struct video_sample *sample = impl_from_IMFTrackedSample(iface);
1443     HRESULT hr = S_OK;
1444
1445     TRACE("%p, %p, %p.\n", iface, sample_allocator, state);
1446
1447     IMFSample_LockStore(sample->sample);
1448
1449     if (sample->tracked_result)
1450         hr = MF_E_NOTACCEPTING;
1451     else
1452     {
1453         if (SUCCEEDED(hr = create_async_result((IUnknown *)iface, sample_allocator, state, &sample->tracked_result)))
1454         {
1455             /* Account for additional refcount brought by 'state' object. This threshold is used
1456                on Release() to invoke tracker callback.  */
1457             sample->tracked_refcount = 1;
1458             if (state == (IUnknown *)&sample->IMFTrackedSample_iface ||
1459                     state == (IUnknown *)&sample->IMFSample_iface)
1460             {
1461                 ++sample->tracked_refcount;
1462             }
1463         }
1464     }
1465
1466     IMFSample_UnlockStore(sample->sample);
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 %u.\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 %u.\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         IMFSample_AddBuffer(object->sample, buffer);
1751
1752     video_sample_create_tracking_thread();
1753
1754     *sample = &object->IMFSample_iface;
1755
1756     return S_OK;
1757 }