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