dlls/mf/samplegrabber.c

   1 /*
   2  * Copyright 2019 Nikolay Sivov for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include <float.h>
  22
  23 #include "mfidl.h"
  24 #include "mf_private.h"
  25
  26 #include "wine/debug.h"
  27 #include "wine/heap.h"
  28 #include "wine/list.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  31
  32 enum sink_state
  33 {
  34     SINK_STATE_STOPPED = 0,
  35     SINK_STATE_RUNNING,
  36 };
  37
  38 struct sample_grabber;
  39
  40 enum scheduled_item_type
  41 {
  42     ITEM_TYPE_SAMPLE,
  43     ITEM_TYPE_MARKER,
  44 };
  45
  46 struct scheduled_item
  47 {
  48     struct list entry;
  49     enum scheduled_item_type type;
  50     union
  51     {
  52         IMFSample *sample;
  53         struct
  54         {
  55             MFSTREAMSINK_MARKER_TYPE type;
  56             PROPVARIANT context;
  57         } marker;
  58     } u;
  59 };
  60
  61 struct sample_grabber
  62 {
  63     IMFMediaSink IMFMediaSink_iface;
  64     IMFClockStateSink IMFClockStateSink_iface;
  65     IMFMediaEventGenerator IMFMediaEventGenerator_iface;
  66     IMFGetService IMFGetService_iface;
  67     IMFRateSupport IMFRateSupport_iface;
  68     IMFStreamSink IMFStreamSink_iface;
  69     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
  70     IMFAsyncCallback timer_callback;
  71     LONG refcount;
  72     IMFSampleGrabberSinkCallback *callback;
  73     IMFSampleGrabberSinkCallback2 *callback2;
  74     IMFMediaType *media_type;
  75     BOOL is_shut_down;
  76     IMFMediaEventQueue *event_queue;
  77     IMFMediaEventQueue *stream_event_queue;
  78     IMFPresentationClock *clock;
  79     IMFTimer *timer;
  80     IMFAttributes *sample_attributes;
  81     struct list items;
  82     IUnknown *cancel_key;
  83     UINT32 ignore_clock;
  84     UINT64 sample_time_offset;
  85     enum sink_state state;
  86     CRITICAL_SECTION cs;
  87 };
  88
  89 static IMFSampleGrabberSinkCallback *sample_grabber_get_callback(const struct sample_grabber *sink)
  90 {
  91     return sink->callback2 ? (IMFSampleGrabberSinkCallback *)sink->callback2 : sink->callback;
  92 }
  93
  94 struct sample_grabber_activate_context
  95 {
  96     IMFMediaType *media_type;
  97     IMFSampleGrabberSinkCallback *callback;
  98     BOOL shut_down;
  99 };
 100
 101 static void sample_grabber_free_private(void *user_context)
 102 {
 103     struct sample_grabber_activate_context *context = user_context;
 104     IMFMediaType_Release(context->media_type);
 105     IMFSampleGrabberSinkCallback_Release(context->callback);
 106     heap_free(context);
 107 }
 108
 109 static struct sample_grabber *impl_from_IMFMediaSink(IMFMediaSink *iface)
 110 {
 111     return CONTAINING_RECORD(iface, struct sample_grabber, IMFMediaSink_iface);
 112 }
 113
 114 static struct sample_grabber *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
 115 {
 116     return CONTAINING_RECORD(iface, struct sample_grabber, IMFClockStateSink_iface);
 117 }
 118
 119 static struct sample_grabber *impl_from_IMFMediaEventGenerator(IMFMediaEventGenerator *iface)
 120 {
 121     return CONTAINING_RECORD(iface, struct sample_grabber, IMFMediaEventGenerator_iface);
 122 }
 123
 124 static struct sample_grabber *impl_from_IMFGetService(IMFGetService *iface)
 125 {
 126     return CONTAINING_RECORD(iface, struct sample_grabber, IMFGetService_iface);
 127 }
 128
 129 static struct sample_grabber *impl_from_IMFRateSupport(IMFRateSupport *iface)
 130 {
 131     return CONTAINING_RECORD(iface, struct sample_grabber, IMFRateSupport_iface);
 132 }
 133
 134 static struct sample_grabber *impl_from_IMFStreamSink(IMFStreamSink *iface)
 135 {
 136     return CONTAINING_RECORD(iface, struct sample_grabber, IMFStreamSink_iface);
 137 }
 138
 139 static struct sample_grabber *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
 140 {
 141     return CONTAINING_RECORD(iface, struct sample_grabber, IMFMediaTypeHandler_iface);
 142 }
 143
 144 static struct sample_grabber *impl_from_IMFAsyncCallback(IMFAsyncCallback *iface)
 145 {
 146     return CONTAINING_RECORD(iface, struct sample_grabber, timer_callback);
 147 }
 148
 149 static HRESULT WINAPI sample_grabber_stream_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj)
 150 {
 151     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 152
 153     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 154
 155     if (IsEqualIID(riid, &IID_IMFStreamSink) ||
 156             IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
 157             IsEqualIID(riid, &IID_IUnknown))
 158     {
 159         *obj = &grabber->IMFStreamSink_iface;
 160     }
 161     else if (IsEqualIID(riid, &IID_IMFMediaTypeHandler))
 162     {
 163         *obj = &grabber->IMFMediaTypeHandler_iface;
 164     }
 165     else
 166     {
 167         WARN("Unsupported %s.\n", debugstr_guid(riid));
 168         *obj = NULL;
 169         return E_NOINTERFACE;
 170     }
 171
 172     IUnknown_AddRef((IUnknown *)*obj);
 173
 174     return S_OK;
 175 }
 176
 177 static ULONG WINAPI sample_grabber_stream_AddRef(IMFStreamSink *iface)
 178 {
 179     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 180     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
 181 }
 182
 183 static void stream_release_pending_item(struct scheduled_item *item)
 184 {
 185     list_remove(&item->entry);
 186     switch (item->type)
 187     {
 188         case ITEM_TYPE_SAMPLE:
 189             IMFSample_Release(item->u.sample);
 190             break;
 191         case ITEM_TYPE_MARKER:
 192             PropVariantClear(&item->u.marker.context);
 193             break;
 194     }
 195     heap_free(item);
 196 }
 197
 198 static ULONG WINAPI sample_grabber_stream_Release(IMFStreamSink *iface)
 199 {
 200     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 201     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
 202 }
 203
 204 static HRESULT WINAPI sample_grabber_stream_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event)
 205 {
 206     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 207
 208     TRACE("%p, %#x, %p.\n", iface, flags, event);
 209
 210     if (grabber->is_shut_down)
 211         return MF_E_STREAMSINK_REMOVED;
 212
 213     return IMFMediaEventQueue_GetEvent(grabber->stream_event_queue, flags, event);
 214 }
 215
 216 static HRESULT WINAPI sample_grabber_stream_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback,
 217         IUnknown *state)
 218 {
 219     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 220
 221     TRACE("%p, %p, %p.\n", iface, callback, state);
 222
 223     if (grabber->is_shut_down)
 224         return MF_E_STREAMSINK_REMOVED;
 225
 226     return IMFMediaEventQueue_BeginGetEvent(grabber->stream_event_queue, callback, state);
 227 }
 228
 229 static HRESULT WINAPI sample_grabber_stream_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result,
 230         IMFMediaEvent **event)
 231 {
 232     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 233
 234     TRACE("%p, %p, %p.\n", iface, result, event);
 235
 236     if (grabber->is_shut_down)
 237         return MF_E_STREAMSINK_REMOVED;
 238
 239     return IMFMediaEventQueue_EndGetEvent(grabber->stream_event_queue, result, event);
 240 }
 241
 242 static HRESULT WINAPI sample_grabber_stream_QueueEvent(IMFStreamSink *iface, MediaEventType event_type,
 243         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 244 {
 245     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 246
 247     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
 248
 249     if (grabber->is_shut_down)
 250         return MF_E_STREAMSINK_REMOVED;
 251
 252     return IMFMediaEventQueue_QueueEventParamVar(grabber->stream_event_queue, event_type, ext_type, hr, value);
 253 }
 254
 255 static HRESULT WINAPI sample_grabber_stream_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink)
 256 {
 257     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 258
 259     TRACE("%p, %p.\n", iface, sink);
 260
 261     if (grabber->is_shut_down)
 262         return MF_E_STREAMSINK_REMOVED;
 263
 264     *sink = &grabber->IMFMediaSink_iface;
 265     IMFMediaSink_AddRef(*sink);
 266
 267     return S_OK;
 268 }
 269
 270 static HRESULT WINAPI sample_grabber_stream_GetIdentifier(IMFStreamSink *iface, DWORD *identifier)
 271 {
 272     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 273
 274     TRACE("%p, %p.\n", iface, identifier);
 275
 276     if (grabber->is_shut_down)
 277         return MF_E_STREAMSINK_REMOVED;
 278
 279     *identifier = 0;
 280
 281     return S_OK;
 282 }
 283
 284 static HRESULT WINAPI sample_grabber_stream_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler)
 285 {
 286     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 287
 288     TRACE("%p, %p.\n", iface, handler);
 289
 290     if (!handler)
 291         return E_POINTER;
 292
 293     if (grabber->is_shut_down)
 294         return MF_E_STREAMSINK_REMOVED;
 295
 296     *handler = &grabber->IMFMediaTypeHandler_iface;
 297     IMFMediaTypeHandler_AddRef(*handler);
 298
 299     return S_OK;
 300 }
 301
 302 static HRESULT sample_grabber_report_sample(struct sample_grabber *grabber, IMFSample *sample, BOOL *sample_delivered)
 303 {
 304     LONGLONG sample_time, sample_duration = 0;
 305     IMFMediaBuffer *buffer;
 306     DWORD flags, size;
 307     GUID major_type;
 308     BYTE *data;
 309     HRESULT hr;
 310
 311     *sample_delivered = FALSE;
 312
 313     hr = IMFMediaType_GetMajorType(grabber->media_type, &major_type);
 314
 315     if (SUCCEEDED(hr))
 316         hr = IMFSample_GetSampleTime(sample, &sample_time);
 317
 318     if (FAILED(IMFSample_GetSampleDuration(sample, &sample_duration)))
 319         sample_duration = 0;
 320
 321     if (SUCCEEDED(hr))
 322         hr = IMFSample_GetSampleFlags(sample, &flags);
 323
 324     if (SUCCEEDED(hr))
 325     {
 326         if (FAILED(IMFSample_ConvertToContiguousBuffer(sample, &buffer)))
 327             return E_UNEXPECTED;
 328
 329         if (SUCCEEDED(hr = IMFMediaBuffer_Lock(buffer, &data, NULL, &size)))
 330         {
 331             *sample_delivered = TRUE;
 332
 333             if (grabber->callback2)
 334             {
 335                 hr = IMFSample_CopyAllItems(sample, grabber->sample_attributes);
 336                 if (SUCCEEDED(hr))
 337                     hr = IMFSampleGrabberSinkCallback2_OnProcessSampleEx(grabber->callback2, &major_type, flags,
 338                             sample_time, sample_duration, data, size, grabber->sample_attributes);
 339             }
 340             else
 341                 hr = IMFSampleGrabberSinkCallback_OnProcessSample(grabber->callback, &major_type, flags, sample_time,
 342                             sample_duration, data, size);
 343             IMFMediaBuffer_Unlock(buffer);
 344         }
 345
 346         IMFMediaBuffer_Release(buffer);
 347     }
 348
 349     return hr;
 350 }
 351
 352 static HRESULT stream_schedule_sample(struct sample_grabber *grabber, struct scheduled_item *item)
 353 {
 354     LONGLONG sampletime;
 355     HRESULT hr;
 356
 357     if (grabber->is_shut_down)
 358         return MF_E_STREAMSINK_REMOVED;
 359
 360     if (FAILED(hr = IMFSample_GetSampleTime(item->u.sample, &sampletime)))
 361         return hr;
 362
 363     if (grabber->cancel_key)
 364     {
 365         IUnknown_Release(grabber->cancel_key);
 366         grabber->cancel_key = NULL;
 367     }
 368
 369     if (FAILED(hr = IMFTimer_SetTimer(grabber->timer, 0, sampletime - grabber->sample_time_offset,
 370             &grabber->timer_callback, NULL, &grabber->cancel_key)))
 371     {
 372         grabber->cancel_key = NULL;
 373     }
 374
 375     return hr;
 376 }
 377
 378 static HRESULT stream_queue_sample(struct sample_grabber *grabber, IMFSample *sample)
 379 {
 380     struct scheduled_item *item;
 381     LONGLONG sampletime;
 382     HRESULT hr;
 383
 384     if (FAILED(hr = IMFSample_GetSampleTime(sample, &sampletime)))
 385         return hr;
 386
 387     if (!(item = heap_alloc_zero(sizeof(*item))))
 388         return E_OUTOFMEMORY;
 389
 390     item->type = ITEM_TYPE_SAMPLE;
 391     item->u.sample = sample;
 392     IMFSample_AddRef(item->u.sample);
 393     list_init(&item->entry);
 394     if (list_empty(&grabber->items))
 395         hr = stream_schedule_sample(grabber, item);
 396
 397     if (SUCCEEDED(hr))
 398         list_add_tail(&grabber->items, &item->entry);
 399     else
 400         stream_release_pending_item(item);
 401
 402     return hr;
 403 }
 404
 405 static void sample_grabber_stream_request_sample(struct sample_grabber *grabber)
 406 {
 407     IMFStreamSink_QueueEvent(&grabber->IMFStreamSink_iface, MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
 408 }
 409
 410 static HRESULT WINAPI sample_grabber_stream_ProcessSample(IMFStreamSink *iface, IMFSample *sample)
 411 {
 412     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 413     BOOL sample_delivered;
 414     LONGLONG sampletime;
 415     HRESULT hr = S_OK;
 416
 417     TRACE("%p, %p.\n", iface, sample);
 418
 419     if (!sample)
 420         return S_OK;
 421
 422     EnterCriticalSection(&grabber->cs);
 423
 424     if (grabber->is_shut_down)
 425         hr = MF_E_STREAMSINK_REMOVED;
 426     else if (grabber->state == SINK_STATE_RUNNING)
 427     {
 428         hr = IMFSample_GetSampleTime(sample, &sampletime);
 429
 430         if (SUCCEEDED(hr))
 431         {
 432             if (grabber->ignore_clock)
 433             {
 434                 /* OnProcessSample() could return error code, which has to be propagated but isn't a blocker.
 435                    Use additional flag indicating that user callback was called at all. */
 436                 hr = sample_grabber_report_sample(grabber, sample, &sample_delivered);
 437                 if (sample_delivered)
 438                     sample_grabber_stream_request_sample(grabber);
 439             }
 440             else
 441                 hr = stream_queue_sample(grabber, sample);
 442         }
 443     }
 444
 445     LeaveCriticalSection(&grabber->cs);
 446
 447     return hr;
 448 }
 449
 450 static void sample_grabber_stream_report_marker(struct sample_grabber *grabber, const PROPVARIANT *context,
 451         HRESULT hr)
 452 {
 453     IMFStreamSink_QueueEvent(&grabber->IMFStreamSink_iface, MEStreamSinkMarker, &GUID_NULL, hr, context);
 454 }
 455
 456 static HRESULT stream_place_marker(struct sample_grabber *grabber, MFSTREAMSINK_MARKER_TYPE marker_type,
 457         const PROPVARIANT *context_value)
 458 {
 459     struct scheduled_item *item;
 460     HRESULT hr = S_OK;
 461
 462     if (list_empty(&grabber->items))
 463     {
 464         sample_grabber_stream_report_marker(grabber, context_value, S_OK);
 465         return S_OK;
 466     }
 467
 468     if (!(item = heap_alloc_zero(sizeof(*item))))
 469         return E_OUTOFMEMORY;
 470
 471     item->type = ITEM_TYPE_MARKER;
 472     item->u.marker.type = marker_type;
 473     list_init(&item->entry);
 474     PropVariantInit(&item->u.marker.context);
 475     if (context_value)
 476         hr = PropVariantCopy(&item->u.marker.context, context_value);
 477     if (SUCCEEDED(hr))
 478         list_add_tail(&grabber->items, &item->entry);
 479     else
 480         stream_release_pending_item(item);
 481
 482     return hr;
 483 }
 484
 485 static HRESULT WINAPI sample_grabber_stream_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type,
 486         const PROPVARIANT *marker_value, const PROPVARIANT *context_value)
 487 {
 488     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 489     HRESULT hr = S_OK;
 490
 491     TRACE("%p, %d, %p, %p.\n", iface, marker_type, marker_value, context_value);
 492
 493     EnterCriticalSection(&grabber->cs);
 494
 495     if (grabber->is_shut_down)
 496         hr = MF_E_STREAMSINK_REMOVED;
 497     else if (grabber->state == SINK_STATE_RUNNING)
 498         hr = stream_place_marker(grabber, marker_type, context_value);
 499
 500     LeaveCriticalSection(&grabber->cs);
 501
 502     return hr;
 503 }
 504
 505 static HRESULT WINAPI sample_grabber_stream_Flush(IMFStreamSink *iface)
 506 {
 507     struct sample_grabber *grabber = impl_from_IMFStreamSink(iface);
 508     struct scheduled_item *item, *next_item;
 509
 510     TRACE("%p.\n", iface);
 511
 512     if (grabber->is_shut_down)
 513         return MF_E_STREAMSINK_REMOVED;
 514
 515     EnterCriticalSection(&grabber->cs);
 516
 517     LIST_FOR_EACH_ENTRY_SAFE(item, next_item, &grabber->items, struct scheduled_item, entry)
 518     {
 519         /* Samples are discarded, markers are processed immediately. */
 520         switch (item->type)
 521         {
 522             case ITEM_TYPE_SAMPLE:
 523                 break;
 524             case ITEM_TYPE_MARKER:
 525                 sample_grabber_stream_report_marker(grabber, &item->u.marker.context, E_ABORT);
 526                 break;
 527         }
 528
 529         stream_release_pending_item(item);
 530     }
 531
 532     LeaveCriticalSection(&grabber->cs);
 533
 534     return S_OK;
 535 }
 536
 537 static const IMFStreamSinkVtbl sample_grabber_stream_vtbl =
 538 {
 539     sample_grabber_stream_QueryInterface,
 540     sample_grabber_stream_AddRef,
 541     sample_grabber_stream_Release,
 542     sample_grabber_stream_GetEvent,
 543     sample_grabber_stream_BeginGetEvent,
 544     sample_grabber_stream_EndGetEvent,
 545     sample_grabber_stream_QueueEvent,
 546     sample_grabber_stream_GetMediaSink,
 547     sample_grabber_stream_GetIdentifier,
 548     sample_grabber_stream_GetMediaTypeHandler,
 549     sample_grabber_stream_ProcessSample,
 550     sample_grabber_stream_PlaceMarker,
 551     sample_grabber_stream_Flush,
 552 };
 553
 554 static HRESULT WINAPI sample_grabber_stream_type_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid,
 555         void **obj)
 556 {
 557     struct sample_grabber *grabber = impl_from_IMFMediaTypeHandler(iface);
 558     return IMFStreamSink_QueryInterface(&grabber->IMFStreamSink_iface, riid, obj);
 559 }
 560
 561 static ULONG WINAPI sample_grabber_stream_type_handler_AddRef(IMFMediaTypeHandler *iface)
 562 {
 563     struct sample_grabber *grabber = impl_from_IMFMediaTypeHandler(iface);
 564     return IMFStreamSink_AddRef(&grabber->IMFStreamSink_iface);
 565 }
 566
 567 static ULONG WINAPI sample_grabber_stream_type_handler_Release(IMFMediaTypeHandler *iface)
 568 {
 569     struct sample_grabber *grabber = impl_from_IMFMediaTypeHandler(iface);
 570     return IMFStreamSink_Release(&grabber->IMFStreamSink_iface);
 571 }
 572
 573 static HRESULT sample_grabber_stream_is_media_type_supported(struct sample_grabber *grabber, IMFMediaType *in_type)
 574 {
 575     const DWORD supported_flags = MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES;
 576     DWORD flags;
 577
 578     if (grabber->is_shut_down)
 579         return MF_E_STREAMSINK_REMOVED;
 580
 581     if (!in_type)
 582         return E_POINTER;
 583
 584     if (IMFMediaType_IsEqual(grabber->media_type, in_type, &flags) == S_OK)
 585         return S_OK;
 586
 587     return (flags & supported_flags) == supported_flags ? S_OK : MF_E_INVALIDMEDIATYPE;
 588 }
 589
 590 static HRESULT WINAPI sample_grabber_stream_type_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface,
 591         IMFMediaType *in_type, IMFMediaType **out_type)
 592 {
 593     struct sample_grabber *grabber = impl_from_IMFMediaTypeHandler(iface);
 594
 595     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
 596
 597     return sample_grabber_stream_is_media_type_supported(grabber, in_type);
 598 }
 599
 600 static HRESULT WINAPI sample_grabber_stream_type_handler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
 601 {
 602     TRACE("%p, %p.\n", iface, count);
 603
 604     if (!count)
 605         return E_POINTER;
 606
 607     *count = 0;
 608
 609     return S_OK;
 610 }
 611
 612 static HRESULT WINAPI sample_grabber_stream_type_handler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
 613         IMFMediaType **media_type)
 614 {
 615     TRACE("%p, %u, %p.\n", iface, index, media_type);
 616
 617     if (!media_type)
 618         return E_POINTER;
 619
 620     return MF_E_NO_MORE_TYPES;
 621 }
 622
 623 static HRESULT WINAPI sample_grabber_stream_type_handler_SetCurrentMediaType(IMFMediaTypeHandler *iface,
 624         IMFMediaType *media_type)
 625 {
 626     struct sample_grabber *grabber = impl_from_IMFMediaTypeHandler(iface);
 627     HRESULT hr;
 628
 629     TRACE("%p, %p.\n", iface, media_type);
 630
 631     if (FAILED(hr = sample_grabber_stream_is_media_type_supported(grabber, media_type)))
 632         return hr;
 633
 634     IMFMediaType_Release(grabber->media_type);
 635     grabber->media_type = media_type;
 636     IMFMediaType_AddRef(grabber->media_type);
 637
 638     return S_OK;
 639 }
 640
 641 static HRESULT WINAPI sample_grabber_stream_type_handler_GetCurrentMediaType(IMFMediaTypeHandler *iface,
 642         IMFMediaType **media_type)
 643 {
 644     struct sample_grabber *grabber = impl_from_IMFMediaTypeHandler(iface);
 645
 646     TRACE("%p, %p.\n", iface, media_type);
 647
 648     if (!media_type)
 649         return E_POINTER;
 650
 651     if (grabber->is_shut_down)
 652         return MF_E_STREAMSINK_REMOVED;
 653
 654     *media_type = grabber->media_type;
 655     IMFMediaType_AddRef(*media_type);
 656
 657     return S_OK;
 658 }
 659
 660 static HRESULT WINAPI sample_grabber_stream_type_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
 661 {
 662     struct sample_grabber *grabber = impl_from_IMFMediaTypeHandler(iface);
 663
 664     TRACE("%p, %p.\n", iface, type);
 665
 666     if (!type)
 667         return E_POINTER;
 668
 669     if (grabber->is_shut_down)
 670         return MF_E_STREAMSINK_REMOVED;
 671
 672     return IMFMediaType_GetMajorType(grabber->media_type, type);
 673 }
 674
 675 static const IMFMediaTypeHandlerVtbl sample_grabber_stream_type_handler_vtbl =
 676 {
 677     sample_grabber_stream_type_handler_QueryInterface,
 678     sample_grabber_stream_type_handler_AddRef,
 679     sample_grabber_stream_type_handler_Release,
 680     sample_grabber_stream_type_handler_IsMediaTypeSupported,
 681     sample_grabber_stream_type_handler_GetMediaTypeCount,
 682     sample_grabber_stream_type_handler_GetMediaTypeByIndex,
 683     sample_grabber_stream_type_handler_SetCurrentMediaType,
 684     sample_grabber_stream_type_handler_GetCurrentMediaType,
 685     sample_grabber_stream_type_handler_GetMajorType,
 686 };
 687
 688 static HRESULT WINAPI sample_grabber_stream_timer_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid,
 689         void **obj)
 690 {
 691     if (IsEqualIID(riid, &IID_IMFAsyncCallback) || IsEqualIID(riid, &IID_IUnknown))
 692     {
 693         *obj = iface;
 694         IMFAsyncCallback_AddRef(iface);
 695         return S_OK;
 696     }
 697
 698     WARN("Unsupported %s.\n", debugstr_guid(riid));
 699     *obj = NULL;
 700     return E_NOINTERFACE;
 701 }
 702
 703 static ULONG WINAPI sample_grabber_stream_timer_callback_AddRef(IMFAsyncCallback *iface)
 704 {
 705     struct sample_grabber *grabber = impl_from_IMFAsyncCallback(iface);
 706     return IMFStreamSink_AddRef(&grabber->IMFStreamSink_iface);
 707 }
 708
 709 static ULONG WINAPI sample_grabber_stream_timer_callback_Release(IMFAsyncCallback *iface)
 710 {
 711     struct sample_grabber *grabber = impl_from_IMFAsyncCallback(iface);
 712     return IMFStreamSink_Release(&grabber->IMFStreamSink_iface);
 713 }
 714
 715 static HRESULT WINAPI sample_grabber_stream_timer_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags,
 716         DWORD *queue)
 717 {
 718     return E_NOTIMPL;
 719 }
 720
 721 static HRESULT WINAPI sample_grabber_stream_timer_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 722 {
 723     struct sample_grabber *grabber = impl_from_IMFAsyncCallback(iface);
 724     BOOL sample_reported = FALSE, sample_delivered = FALSE;
 725     struct scheduled_item *item, *item2;
 726     HRESULT hr;
 727
 728     EnterCriticalSection(&grabber->cs);
 729
 730     LIST_FOR_EACH_ENTRY_SAFE(item, item2, &grabber->items, struct scheduled_item, entry)
 731     {
 732         if (item->type == ITEM_TYPE_MARKER)
 733         {
 734             sample_grabber_stream_report_marker(grabber, &item->u.marker.context, S_OK);
 735             stream_release_pending_item(item);
 736         }
 737         else if (item->type == ITEM_TYPE_SAMPLE)
 738         {
 739             if (!sample_reported)
 740             {
 741                 if (FAILED(hr = sample_grabber_report_sample(grabber, item->u.sample, &sample_delivered)))
 742                     WARN("Failed to report a sample, hr %#x.\n", hr);
 743                 stream_release_pending_item(item);
 744                 sample_reported = TRUE;
 745             }
 746             else
 747             {
 748                 if (FAILED(hr = stream_schedule_sample(grabber, item)))
 749                     WARN("Failed to schedule a sample, hr %#x.\n", hr);
 750                 break;
 751             }
 752         }
 753     }
 754     if (sample_delivered)
 755         sample_grabber_stream_request_sample(grabber);
 756
 757     LeaveCriticalSection(&grabber->cs);
 758
 759     return S_OK;
 760 }
 761
 762 static const IMFAsyncCallbackVtbl sample_grabber_stream_timer_callback_vtbl =
 763 {
 764     sample_grabber_stream_timer_callback_QueryInterface,
 765     sample_grabber_stream_timer_callback_AddRef,
 766     sample_grabber_stream_timer_callback_Release,
 767     sample_grabber_stream_timer_callback_GetParameters,
 768     sample_grabber_stream_timer_callback_Invoke,
 769 };
 770
 771 static HRESULT WINAPI sample_grabber_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj)
 772 {
 773     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 774
 775     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 776
 777     if (IsEqualIID(riid, &IID_IMFMediaSink) ||
 778             IsEqualIID(riid, &IID_IUnknown))
 779     {
 780         *obj = &grabber->IMFMediaSink_iface;
 781     }
 782     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
 783     {
 784         *obj = &grabber->IMFClockStateSink_iface;
 785     }
 786     else if (IsEqualIID(riid, &IID_IMFMediaEventGenerator))
 787     {
 788         *obj = &grabber->IMFMediaEventGenerator_iface;
 789     }
 790     else if (IsEqualIID(riid, &IID_IMFGetService))
 791     {
 792         *obj = &grabber->IMFGetService_iface;
 793     }
 794     else if (IsEqualIID(riid, &IID_IMFRateSupport))
 795     {
 796         *obj = &grabber->IMFRateSupport_iface;
 797     }
 798     else
 799     {
 800         WARN("Unsupported %s.\n", debugstr_guid(riid));
 801         *obj = NULL;
 802         return E_NOINTERFACE;
 803     }
 804
 805     IUnknown_AddRef((IUnknown *)*obj);
 806
 807     return S_OK;
 808 }
 809
 810 static ULONG WINAPI sample_grabber_sink_AddRef(IMFMediaSink *iface)
 811 {
 812     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 813     ULONG refcount = InterlockedIncrement(&grabber->refcount);
 814
 815     TRACE("%p, refcount %u.\n", iface, refcount);
 816
 817     return refcount;
 818 }
 819
 820 static void sample_grabber_release_pending_items(struct sample_grabber *grabber)
 821 {
 822     struct scheduled_item *item, *next_item;
 823
 824     LIST_FOR_EACH_ENTRY_SAFE(item, next_item, &grabber->items, struct scheduled_item, entry)
 825     {
 826         stream_release_pending_item(item);
 827     }
 828 }
 829
 830 static ULONG WINAPI sample_grabber_sink_Release(IMFMediaSink *iface)
 831 {
 832     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 833     ULONG refcount = InterlockedDecrement(&grabber->refcount);
 834
 835     TRACE("%p, refcount %u.\n", iface, refcount);
 836
 837     if (!refcount)
 838     {
 839         if (grabber->callback)
 840             IMFSampleGrabberSinkCallback_Release(grabber->callback);
 841         if (grabber->callback2)
 842             IMFSampleGrabberSinkCallback2_Release(grabber->callback2);
 843         IMFMediaType_Release(grabber->media_type);
 844         if (grabber->event_queue)
 845             IMFMediaEventQueue_Release(grabber->event_queue);
 846         if (grabber->clock)
 847             IMFPresentationClock_Release(grabber->clock);
 848         if (grabber->timer)
 849         {
 850             if (grabber->cancel_key)
 851                 IMFTimer_CancelTimer(grabber->timer, grabber->cancel_key);
 852             IMFTimer_Release(grabber->timer);
 853         }
 854         if (grabber->cancel_key)
 855             IUnknown_Release(grabber->cancel_key);
 856         if (grabber->stream_event_queue)
 857         {
 858             IMFMediaEventQueue_Shutdown(grabber->stream_event_queue);
 859             IMFMediaEventQueue_Release(grabber->stream_event_queue);
 860         }
 861         if (grabber->sample_attributes)
 862             IMFAttributes_Release(grabber->sample_attributes);
 863         sample_grabber_release_pending_items(grabber);
 864         DeleteCriticalSection(&grabber->cs);
 865         heap_free(grabber);
 866     }
 867
 868     return refcount;
 869 }
 870
 871 static HRESULT WINAPI sample_grabber_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags)
 872 {
 873     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 874
 875     TRACE("%p, %p.\n", iface, flags);
 876
 877     if (grabber->is_shut_down)
 878         return MF_E_SHUTDOWN;
 879
 880     *flags = MEDIASINK_FIXED_STREAMS;
 881     if (grabber->ignore_clock)
 882         *flags |= MEDIASINK_RATELESS;
 883
 884     return S_OK;
 885 }
 886
 887 static HRESULT WINAPI sample_grabber_sink_AddStreamSink(IMFMediaSink *iface, DWORD stream_sink_id,
 888     IMFMediaType *media_type, IMFStreamSink **stream_sink)
 889 {
 890     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 891
 892     TRACE("%p, %#x, %p, %p.\n", iface, stream_sink_id, media_type, stream_sink);
 893
 894     return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 895 }
 896
 897 static HRESULT WINAPI sample_grabber_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id)
 898 {
 899     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 900
 901     TRACE("%p, %#x.\n", iface, stream_sink_id);
 902
 903     return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 904 }
 905
 906 static HRESULT WINAPI sample_grabber_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
 907 {
 908     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 909
 910     TRACE("%p, %p.\n", iface, count);
 911
 912     if (grabber->is_shut_down)
 913         return MF_E_SHUTDOWN;
 914
 915     *count = 1;
 916
 917     return S_OK;
 918 }
 919
 920 static HRESULT WINAPI sample_grabber_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index,
 921         IMFStreamSink **stream)
 922 {
 923     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 924     HRESULT hr = S_OK;
 925
 926     TRACE("%p, %u, %p.\n", iface, index, stream);
 927
 928     if (grabber->is_shut_down)
 929         return MF_E_SHUTDOWN;
 930
 931     EnterCriticalSection(&grabber->cs);
 932
 933     if (grabber->is_shut_down)
 934         hr = MF_E_SHUTDOWN;
 935     else if (index > 0)
 936         hr = MF_E_INVALIDINDEX;
 937     else
 938     {
 939        *stream = &grabber->IMFStreamSink_iface;
 940        IMFStreamSink_AddRef(*stream);
 941     }
 942
 943     LeaveCriticalSection(&grabber->cs);
 944
 945     return hr;
 946 }
 947
 948 static HRESULT WINAPI sample_grabber_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id,
 949         IMFStreamSink **stream)
 950 {
 951     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 952     HRESULT hr = S_OK;
 953
 954     TRACE("%p, %#x, %p.\n", iface, stream_sink_id, stream);
 955
 956     EnterCriticalSection(&grabber->cs);
 957
 958     if (grabber->is_shut_down)
 959         hr = MF_E_SHUTDOWN;
 960     else if (stream_sink_id > 0)
 961         hr = MF_E_INVALIDSTREAMNUMBER;
 962     else
 963     {
 964         *stream = &grabber->IMFStreamSink_iface;
 965         IMFStreamSink_AddRef(*stream);
 966     }
 967
 968     LeaveCriticalSection(&grabber->cs);
 969
 970     return hr;
 971 }
 972
 973 static void sample_grabber_set_presentation_clock(struct sample_grabber *grabber, IMFPresentationClock *clock)
 974 {
 975     if (grabber->clock)
 976     {
 977         IMFPresentationClock_RemoveClockStateSink(grabber->clock, &grabber->IMFClockStateSink_iface);
 978         IMFPresentationClock_Release(grabber->clock);
 979         if (grabber->timer)
 980         {
 981             IMFTimer_Release(grabber->timer);
 982             grabber->timer = NULL;
 983         }
 984     }
 985     grabber->clock = clock;
 986     if (grabber->clock)
 987     {
 988         IMFPresentationClock_AddRef(grabber->clock);
 989         IMFPresentationClock_AddClockStateSink(grabber->clock, &grabber->IMFClockStateSink_iface);
 990         if (FAILED(IMFPresentationClock_QueryInterface(grabber->clock, &IID_IMFTimer, (void **)&grabber->timer)))
 991         {
 992             WARN("Failed to get IMFTimer interface.\n");
 993             grabber->timer = NULL;
 994         }
 995     }
 996 }
 997
 998 static HRESULT WINAPI sample_grabber_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
 999 {
1000     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
1001     HRESULT hr;
1002
1003     TRACE("%p, %p.\n", iface, clock);
1004
1005     EnterCriticalSection(&grabber->cs);
1006
1007     if (SUCCEEDED(hr = IMFSampleGrabberSinkCallback_OnSetPresentationClock(sample_grabber_get_callback(grabber),
1008             clock)))
1009     {
1010         sample_grabber_set_presentation_clock(grabber, clock);
1011     }
1012
1013     LeaveCriticalSection(&grabber->cs);
1014
1015     return hr;
1016 }
1017
1018 static HRESULT WINAPI sample_grabber_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
1019 {
1020     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
1021     HRESULT hr = S_OK;
1022
1023     TRACE("%p, %p.\n", iface, clock);
1024
1025     if (!clock)
1026         return E_POINTER;
1027
1028     EnterCriticalSection(&grabber->cs);
1029
1030     if (grabber->clock)
1031     {
1032         *clock = grabber->clock;
1033         IMFPresentationClock_AddRef(*clock);
1034     }
1035     else
1036         hr = MF_E_NO_CLOCK;
1037
1038     LeaveCriticalSection(&grabber->cs);
1039
1040     return hr;
1041 }
1042
1043 static HRESULT WINAPI sample_grabber_sink_Shutdown(IMFMediaSink *iface)
1044 {
1045     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
1046     HRESULT hr;
1047
1048     TRACE("%p.\n", iface);
1049
1050     if (grabber->is_shut_down)
1051         return MF_E_SHUTDOWN;
1052
1053     EnterCriticalSection(&grabber->cs);
1054     grabber->is_shut_down = TRUE;
1055     sample_grabber_release_pending_items(grabber);
1056     if (SUCCEEDED(hr = IMFSampleGrabberSinkCallback_OnShutdown(sample_grabber_get_callback(grabber))))
1057     {
1058         sample_grabber_set_presentation_clock(grabber, NULL);
1059         IMFMediaEventQueue_Shutdown(grabber->stream_event_queue);
1060         IMFMediaEventQueue_Shutdown(grabber->event_queue);
1061     }
1062     LeaveCriticalSection(&grabber->cs);
1063
1064     return hr;
1065 }
1066
1067 static const IMFMediaSinkVtbl sample_grabber_sink_vtbl =
1068 {
1069     sample_grabber_sink_QueryInterface,
1070     sample_grabber_sink_AddRef,
1071     sample_grabber_sink_Release,
1072     sample_grabber_sink_GetCharacteristics,
1073     sample_grabber_sink_AddStreamSink,
1074     sample_grabber_sink_RemoveStreamSink,
1075     sample_grabber_sink_GetStreamSinkCount,
1076     sample_grabber_sink_GetStreamSinkByIndex,
1077     sample_grabber_sink_GetStreamSinkById,
1078     sample_grabber_sink_SetPresentationClock,
1079     sample_grabber_sink_GetPresentationClock,
1080     sample_grabber_sink_Shutdown,
1081 };
1082
1083 static HRESULT WINAPI sample_grabber_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
1084 {
1085     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1086     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1087 }
1088
1089 static ULONG WINAPI sample_grabber_clock_sink_AddRef(IMFClockStateSink *iface)
1090 {
1091     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1092     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1093 }
1094
1095 static ULONG WINAPI sample_grabber_clock_sink_Release(IMFClockStateSink *iface)
1096 {
1097     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1098     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1099 }
1100
1101 static void sample_grabber_set_state(struct sample_grabber *grabber, enum sink_state state)
1102 {
1103     static const DWORD events[] =
1104     {
1105         MEStreamSinkStopped, /* SINK_STATE_STOPPED */
1106         MEStreamSinkStarted, /* SINK_STATE_RUNNING */
1107     };
1108     BOOL set_state = FALSE;
1109     unsigned int i;
1110
1111     EnterCriticalSection(&grabber->cs);
1112
1113     if (!grabber->is_shut_down)
1114     {
1115         switch (grabber->state)
1116         {
1117             case SINK_STATE_STOPPED:
1118                 set_state = state == SINK_STATE_RUNNING;
1119                 break;
1120             case SINK_STATE_RUNNING:
1121                 set_state = state == SINK_STATE_STOPPED;
1122                 break;
1123             default:
1124                 ;
1125         }
1126
1127         if (set_state)
1128         {
1129             grabber->state = state;
1130             if (state == SINK_STATE_RUNNING)
1131             {
1132                 /* Every transition to running state sends a bunch requests to build up initial queue. */
1133                 for (i = 0; i < 4; ++i)
1134                     sample_grabber_stream_request_sample(grabber);
1135             }
1136             IMFStreamSink_QueueEvent(&grabber->IMFStreamSink_iface, events[state], &GUID_NULL, S_OK, NULL);
1137         }
1138     }
1139
1140     LeaveCriticalSection(&grabber->cs);
1141 }
1142
1143 static HRESULT WINAPI sample_grabber_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
1144 {
1145     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1146
1147     TRACE("%p, %s, %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
1148
1149     sample_grabber_set_state(grabber, SINK_STATE_RUNNING);
1150
1151     return IMFSampleGrabberSinkCallback_OnClockStart(sample_grabber_get_callback(grabber), systime, offset);
1152 }
1153
1154 static HRESULT WINAPI sample_grabber_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
1155 {
1156     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1157
1158     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1159
1160     sample_grabber_set_state(grabber, SINK_STATE_STOPPED);
1161
1162     return IMFSampleGrabberSinkCallback_OnClockStop(sample_grabber_get_callback(grabber), systime);
1163 }
1164
1165 static HRESULT WINAPI sample_grabber_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
1166 {
1167     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1168
1169     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1170
1171     return IMFSampleGrabberSinkCallback_OnClockPause(sample_grabber_get_callback(grabber), systime);
1172 }
1173
1174 static HRESULT WINAPI sample_grabber_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
1175 {
1176     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1177
1178     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1179
1180     sample_grabber_set_state(grabber, SINK_STATE_RUNNING);
1181
1182     return IMFSampleGrabberSinkCallback_OnClockRestart(sample_grabber_get_callback(grabber), systime);
1183 }
1184
1185 static HRESULT WINAPI sample_grabber_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
1186 {
1187     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1188
1189     TRACE("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
1190
1191     return IMFSampleGrabberSinkCallback_OnClockSetRate(sample_grabber_get_callback(grabber), systime, rate);
1192 }
1193
1194 static HRESULT WINAPI sample_grabber_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
1195 {
1196     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1197     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1198 }
1199
1200 static ULONG WINAPI sample_grabber_events_AddRef(IMFMediaEventGenerator *iface)
1201 {
1202     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1203     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1204 }
1205
1206 static ULONG WINAPI sample_grabber_events_Release(IMFMediaEventGenerator *iface)
1207 {
1208     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1209     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1210 }
1211
1212 static HRESULT WINAPI sample_grabber_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
1213 {
1214     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1215
1216     TRACE("%p, %#x, %p.\n", iface, flags, event);
1217
1218     return IMFMediaEventQueue_GetEvent(grabber->event_queue, flags, event);
1219 }
1220
1221 static HRESULT WINAPI sample_grabber_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
1222         IUnknown *state)
1223 {
1224     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1225
1226     TRACE("%p, %p, %p.\n", iface, callback, state);
1227
1228     return IMFMediaEventQueue_BeginGetEvent(grabber->event_queue, callback, state);
1229 }
1230
1231 static HRESULT WINAPI sample_grabber_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
1232         IMFMediaEvent **event)
1233 {
1234     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1235
1236     TRACE("%p, %p, %p.\n", iface, result, event);
1237
1238     return IMFMediaEventQueue_EndGetEvent(grabber->event_queue, result, event);
1239 }
1240
1241 static HRESULT WINAPI sample_grabber_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
1242         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
1243 {
1244     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1245
1246     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
1247
1248     return IMFMediaEventQueue_QueueEventParamVar(grabber->event_queue, event_type, ext_type, hr, value);
1249 }
1250
1251 static const IMFMediaEventGeneratorVtbl sample_grabber_sink_events_vtbl =
1252 {
1253     sample_grabber_events_QueryInterface,
1254     sample_grabber_events_AddRef,
1255     sample_grabber_events_Release,
1256     sample_grabber_events_GetEvent,
1257     sample_grabber_events_BeginGetEvent,
1258     sample_grabber_events_EndGetEvent,
1259     sample_grabber_events_QueueEvent,
1260 };
1261
1262 static const IMFClockStateSinkVtbl sample_grabber_clock_sink_vtbl =
1263 {
1264     sample_grabber_clock_sink_QueryInterface,
1265     sample_grabber_clock_sink_AddRef,
1266     sample_grabber_clock_sink_Release,
1267     sample_grabber_clock_sink_OnClockStart,
1268     sample_grabber_clock_sink_OnClockStop,
1269     sample_grabber_clock_sink_OnClockPause,
1270     sample_grabber_clock_sink_OnClockRestart,
1271     sample_grabber_clock_sink_OnClockSetRate,
1272 };
1273
1274 static HRESULT WINAPI sample_grabber_getservice_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
1275 {
1276     struct sample_grabber *grabber = impl_from_IMFGetService(iface);
1277     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1278 }
1279
1280 static ULONG WINAPI sample_grabber_getservice_AddRef(IMFGetService *iface)
1281 {
1282     struct sample_grabber *grabber = impl_from_IMFGetService(iface);
1283     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1284 }
1285
1286 static ULONG WINAPI sample_grabber_getservice_Release(IMFGetService *iface)
1287 {
1288     struct sample_grabber *grabber = impl_from_IMFGetService(iface);
1289     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1290 }
1291
1292 static HRESULT WINAPI sample_grabber_getservice_GetService(IMFGetService *iface, REFGUID service,
1293         REFIID riid, void **obj)
1294 {
1295     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
1296
1297     if (IsEqualGUID(service, &MF_RATE_CONTROL_SERVICE))
1298     {
1299         if (IsEqualIID(riid, &IID_IMFRateSupport))
1300             return IMFGetService_QueryInterface(iface, riid, obj);
1301
1302         return E_NOINTERFACE;
1303     }
1304
1305     FIXME("Unsupported service %s, riid %s.\n", debugstr_guid(service), debugstr_guid(riid));
1306
1307     return MF_E_UNSUPPORTED_SERVICE;
1308 }
1309
1310 static const IMFGetServiceVtbl sample_grabber_getservice_vtbl =
1311 {
1312     sample_grabber_getservice_QueryInterface,
1313     sample_grabber_getservice_AddRef,
1314     sample_grabber_getservice_Release,
1315     sample_grabber_getservice_GetService,
1316 };
1317
1318 static HRESULT WINAPI sample_grabber_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **obj)
1319 {
1320     struct sample_grabber *grabber = impl_from_IMFRateSupport(iface);
1321     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1322 }
1323
1324 static ULONG WINAPI sample_grabber_rate_support_AddRef(IMFRateSupport *iface)
1325 {
1326     struct sample_grabber *grabber = impl_from_IMFRateSupport(iface);
1327     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1328 }
1329
1330 static ULONG WINAPI sample_grabber_rate_support_Release(IMFRateSupport *iface)
1331 {
1332     struct sample_grabber *grabber = impl_from_IMFRateSupport(iface);
1333     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1334 }
1335
1336 static HRESULT WINAPI sample_grabber_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
1337         BOOL thin, float *rate)
1338 {
1339     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
1340
1341     *rate = 0.0f;
1342
1343     return S_OK;
1344 }
1345
1346 static HRESULT WINAPI sample_grabber_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
1347         BOOL thin, float *rate)
1348 {
1349     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
1350
1351     *rate = direction == MFRATE_REVERSE ? -FLT_MAX : FLT_MAX;
1352
1353     return S_OK;
1354 }
1355
1356 static HRESULT WINAPI sample_grabber_rate_support_IsRateSupported(IMFRateSupport *iface, BOOL thin, float rate,
1357         float *ret_rate)
1358 {
1359     TRACE("%p, %d, %f, %p.\n", iface, thin, rate, ret_rate);
1360
1361     if (ret_rate)
1362         *ret_rate = rate;
1363
1364     return S_OK;
1365 }
1366
1367 static const IMFRateSupportVtbl sample_grabber_rate_support_vtbl =
1368 {
1369     sample_grabber_rate_support_QueryInterface,
1370     sample_grabber_rate_support_AddRef,
1371     sample_grabber_rate_support_Release,
1372     sample_grabber_rate_support_GetSlowestRate,
1373     sample_grabber_rate_support_GetFastestRate,
1374     sample_grabber_rate_support_IsRateSupported,
1375 };
1376
1377 static HRESULT sample_grabber_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj)
1378 {
1379     struct sample_grabber_activate_context *context = user_context;
1380     struct sample_grabber *object;
1381     HRESULT hr;
1382     GUID guid;
1383
1384     TRACE("%p, %p, %p.\n", attributes, user_context, obj);
1385
1386     if (context->shut_down)
1387         return MF_E_SHUTDOWN;
1388
1389     /* At least major type is required. */
1390     if (FAILED(IMFMediaType_GetMajorType(context->media_type, &guid)))
1391         return MF_E_INVALIDMEDIATYPE;
1392
1393     object = heap_alloc_zero(sizeof(*object));
1394     if (!object)
1395         return E_OUTOFMEMORY;
1396
1397     object->IMFMediaSink_iface.lpVtbl = &sample_grabber_sink_vtbl;
1398     object->IMFClockStateSink_iface.lpVtbl = &sample_grabber_clock_sink_vtbl;
1399     object->IMFMediaEventGenerator_iface.lpVtbl = &sample_grabber_sink_events_vtbl;
1400     object->IMFGetService_iface.lpVtbl = &sample_grabber_getservice_vtbl;
1401     object->IMFRateSupport_iface.lpVtbl = &sample_grabber_rate_support_vtbl;
1402     object->IMFStreamSink_iface.lpVtbl = &sample_grabber_stream_vtbl;
1403     object->IMFMediaTypeHandler_iface.lpVtbl = &sample_grabber_stream_type_handler_vtbl;
1404     object->timer_callback.lpVtbl = &sample_grabber_stream_timer_callback_vtbl;
1405     object->refcount = 1;
1406     if (FAILED(IMFSampleGrabberSinkCallback_QueryInterface(context->callback, &IID_IMFSampleGrabberSinkCallback2,
1407             (void **)&object->callback2)))
1408     {
1409         object->callback = context->callback;
1410         IMFSampleGrabberSinkCallback_AddRef(object->callback);
1411     }
1412     object->media_type = context->media_type;
1413     IMFMediaType_AddRef(object->media_type);
1414     IMFAttributes_GetUINT32(attributes, &MF_SAMPLEGRABBERSINK_IGNORE_CLOCK, &object->ignore_clock);
1415     IMFAttributes_GetUINT64(attributes, &MF_SAMPLEGRABBERSINK_SAMPLE_TIME_OFFSET, &object->sample_time_offset);
1416     list_init(&object->items);
1417     InitializeCriticalSection(&object->cs);
1418
1419     if (FAILED(hr = MFCreateEventQueue(&object->stream_event_queue)))
1420         goto failed;
1421
1422     if (FAILED(hr = MFCreateAttributes(&object->sample_attributes, 0)))
1423         goto failed;
1424
1425     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
1426         goto failed;
1427
1428     *obj = (IUnknown *)&object->IMFMediaSink_iface;
1429
1430     TRACE("Created %p.\n", *obj);
1431
1432     return S_OK;
1433
1434 failed:
1435
1436     IMFMediaSink_Release(&object->IMFMediaSink_iface);
1437
1438     return hr;
1439 }
1440
1441 static void sample_grabber_shutdown_object(void *user_context, IUnknown *obj)
1442 {
1443     struct sample_grabber_activate_context *context = user_context;
1444     context->shut_down = TRUE;
1445 }
1446
1447 static const struct activate_funcs sample_grabber_activate_funcs =
1448 {
1449     sample_grabber_create_object,
1450     sample_grabber_shutdown_object,
1451     sample_grabber_free_private,
1452 };
1453
1454 /***********************************************************************
1455  *      MFCreateSampleGrabberSinkActivate (mf.@)
1456  */
1457 HRESULT WINAPI MFCreateSampleGrabberSinkActivate(IMFMediaType *media_type, IMFSampleGrabberSinkCallback *callback,
1458         IMFActivate **activate)
1459 {
1460     struct sample_grabber_activate_context *context;
1461     HRESULT hr;
1462
1463     TRACE("%p, %p, %p.\n", media_type, callback, activate);
1464
1465     if (!media_type || !callback || !activate)
1466         return E_POINTER;
1467
1468     context = heap_alloc_zero(sizeof(*context));
1469     if (!context)
1470         return E_OUTOFMEMORY;
1471
1472     context->media_type = media_type;
1473     IMFMediaType_AddRef(context->media_type);
1474     context->callback = callback;
1475     IMFSampleGrabberSinkCallback_AddRef(context->callback);
1476
1477     if (FAILED(hr = create_activation_object(context, &sample_grabber_activate_funcs, activate)))
1478         sample_grabber_free_private(context);
1479
1480     return hr;
1481 }