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/list.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  30
  31 enum sink_state
  32 {
  33     SINK_STATE_STOPPED = 0,
  34     SINK_STATE_PAUSED,
  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     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     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 = calloc(1, 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 = calloc(1, 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             IMFTimer_Release(grabber->timer);
 853         if (grabber->cancel_key)
 854             IUnknown_Release(grabber->cancel_key);
 855         if (grabber->stream_event_queue)
 856         {
 857             IMFMediaEventQueue_Shutdown(grabber->stream_event_queue);
 858             IMFMediaEventQueue_Release(grabber->stream_event_queue);
 859         }
 860         if (grabber->sample_attributes)
 861             IMFAttributes_Release(grabber->sample_attributes);
 862         sample_grabber_release_pending_items(grabber);
 863         DeleteCriticalSection(&grabber->cs);
 864         free(grabber);
 865     }
 866
 867     return refcount;
 868 }
 869
 870 static HRESULT WINAPI sample_grabber_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags)
 871 {
 872     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 873
 874     TRACE("%p, %p.\n", iface, flags);
 875
 876     if (grabber->is_shut_down)
 877         return MF_E_SHUTDOWN;
 878
 879     *flags = MEDIASINK_FIXED_STREAMS;
 880     if (grabber->ignore_clock)
 881         *flags |= MEDIASINK_RATELESS;
 882
 883     return S_OK;
 884 }
 885
 886 static HRESULT WINAPI sample_grabber_sink_AddStreamSink(IMFMediaSink *iface, DWORD stream_sink_id,
 887     IMFMediaType *media_type, IMFStreamSink **stream_sink)
 888 {
 889     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 890
 891     TRACE("%p, %#x, %p, %p.\n", iface, stream_sink_id, media_type, stream_sink);
 892
 893     return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 894 }
 895
 896 static HRESULT WINAPI sample_grabber_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id)
 897 {
 898     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 899
 900     TRACE("%p, %#x.\n", iface, stream_sink_id);
 901
 902     return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 903 }
 904
 905 static HRESULT WINAPI sample_grabber_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
 906 {
 907     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 908
 909     TRACE("%p, %p.\n", iface, count);
 910
 911     if (grabber->is_shut_down)
 912         return MF_E_SHUTDOWN;
 913
 914     *count = 1;
 915
 916     return S_OK;
 917 }
 918
 919 static HRESULT WINAPI sample_grabber_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index,
 920         IMFStreamSink **stream)
 921 {
 922     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 923     HRESULT hr = S_OK;
 924
 925     TRACE("%p, %u, %p.\n", iface, index, stream);
 926
 927     if (grabber->is_shut_down)
 928         return MF_E_SHUTDOWN;
 929
 930     EnterCriticalSection(&grabber->cs);
 931
 932     if (grabber->is_shut_down)
 933         hr = MF_E_SHUTDOWN;
 934     else if (index > 0)
 935         hr = MF_E_INVALIDINDEX;
 936     else
 937     {
 938        *stream = &grabber->IMFStreamSink_iface;
 939        IMFStreamSink_AddRef(*stream);
 940     }
 941
 942     LeaveCriticalSection(&grabber->cs);
 943
 944     return hr;
 945 }
 946
 947 static HRESULT WINAPI sample_grabber_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id,
 948         IMFStreamSink **stream)
 949 {
 950     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 951     HRESULT hr = S_OK;
 952
 953     TRACE("%p, %#x, %p.\n", iface, stream_sink_id, stream);
 954
 955     EnterCriticalSection(&grabber->cs);
 956
 957     if (grabber->is_shut_down)
 958         hr = MF_E_SHUTDOWN;
 959     else if (stream_sink_id > 0)
 960         hr = MF_E_INVALIDSTREAMNUMBER;
 961     else
 962     {
 963         *stream = &grabber->IMFStreamSink_iface;
 964         IMFStreamSink_AddRef(*stream);
 965     }
 966
 967     LeaveCriticalSection(&grabber->cs);
 968
 969     return hr;
 970 }
 971
 972 static void sample_grabber_cancel_timer(struct sample_grabber *grabber)
 973 {
 974     if (grabber->timer && grabber->cancel_key)
 975     {
 976         IMFTimer_CancelTimer(grabber->timer, grabber->cancel_key);
 977         IUnknown_Release(grabber->cancel_key);
 978         grabber->cancel_key = NULL;
 979     }
 980 }
 981
 982 static void sample_grabber_set_presentation_clock(struct sample_grabber *grabber, IMFPresentationClock *clock)
 983 {
 984     if (grabber->clock)
 985     {
 986         sample_grabber_cancel_timer(grabber);
 987         IMFPresentationClock_RemoveClockStateSink(grabber->clock, &grabber->IMFClockStateSink_iface);
 988         IMFPresentationClock_Release(grabber->clock);
 989         if (grabber->timer)
 990         {
 991             IMFTimer_Release(grabber->timer);
 992             grabber->timer = NULL;
 993         }
 994     }
 995     grabber->clock = clock;
 996     if (grabber->clock)
 997     {
 998         IMFPresentationClock_AddRef(grabber->clock);
 999         IMFPresentationClock_AddClockStateSink(grabber->clock, &grabber->IMFClockStateSink_iface);
1000         if (FAILED(IMFPresentationClock_QueryInterface(grabber->clock, &IID_IMFTimer, (void **)&grabber->timer)))
1001         {
1002             WARN("Failed to get IMFTimer interface.\n");
1003             grabber->timer = NULL;
1004         }
1005     }
1006 }
1007
1008 static HRESULT WINAPI sample_grabber_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
1009 {
1010     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
1011     HRESULT hr;
1012
1013     TRACE("%p, %p.\n", iface, clock);
1014
1015     EnterCriticalSection(&grabber->cs);
1016
1017     if (SUCCEEDED(hr = IMFSampleGrabberSinkCallback_OnSetPresentationClock(sample_grabber_get_callback(grabber),
1018             clock)))
1019     {
1020         sample_grabber_set_presentation_clock(grabber, clock);
1021     }
1022
1023     LeaveCriticalSection(&grabber->cs);
1024
1025     return hr;
1026 }
1027
1028 static HRESULT WINAPI sample_grabber_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
1029 {
1030     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
1031     HRESULT hr = S_OK;
1032
1033     TRACE("%p, %p.\n", iface, clock);
1034
1035     if (!clock)
1036         return E_POINTER;
1037
1038     EnterCriticalSection(&grabber->cs);
1039
1040     if (grabber->clock)
1041     {
1042         *clock = grabber->clock;
1043         IMFPresentationClock_AddRef(*clock);
1044     }
1045     else
1046         hr = MF_E_NO_CLOCK;
1047
1048     LeaveCriticalSection(&grabber->cs);
1049
1050     return hr;
1051 }
1052
1053 static HRESULT WINAPI sample_grabber_sink_Shutdown(IMFMediaSink *iface)
1054 {
1055     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
1056     HRESULT hr;
1057
1058     TRACE("%p.\n", iface);
1059
1060     if (grabber->is_shut_down)
1061         return MF_E_SHUTDOWN;
1062
1063     EnterCriticalSection(&grabber->cs);
1064     grabber->is_shut_down = TRUE;
1065     sample_grabber_release_pending_items(grabber);
1066     if (SUCCEEDED(hr = IMFSampleGrabberSinkCallback_OnShutdown(sample_grabber_get_callback(grabber))))
1067     {
1068         sample_grabber_set_presentation_clock(grabber, NULL);
1069         IMFMediaEventQueue_Shutdown(grabber->stream_event_queue);
1070         IMFMediaEventQueue_Shutdown(grabber->event_queue);
1071     }
1072     LeaveCriticalSection(&grabber->cs);
1073
1074     return hr;
1075 }
1076
1077 static const IMFMediaSinkVtbl sample_grabber_sink_vtbl =
1078 {
1079     sample_grabber_sink_QueryInterface,
1080     sample_grabber_sink_AddRef,
1081     sample_grabber_sink_Release,
1082     sample_grabber_sink_GetCharacteristics,
1083     sample_grabber_sink_AddStreamSink,
1084     sample_grabber_sink_RemoveStreamSink,
1085     sample_grabber_sink_GetStreamSinkCount,
1086     sample_grabber_sink_GetStreamSinkByIndex,
1087     sample_grabber_sink_GetStreamSinkById,
1088     sample_grabber_sink_SetPresentationClock,
1089     sample_grabber_sink_GetPresentationClock,
1090     sample_grabber_sink_Shutdown,
1091 };
1092
1093 static HRESULT WINAPI sample_grabber_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
1094 {
1095     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1096     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1097 }
1098
1099 static ULONG WINAPI sample_grabber_clock_sink_AddRef(IMFClockStateSink *iface)
1100 {
1101     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1102     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1103 }
1104
1105 static ULONG WINAPI sample_grabber_clock_sink_Release(IMFClockStateSink *iface)
1106 {
1107     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1108     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1109 }
1110
1111 static HRESULT sample_grabber_set_state(struct sample_grabber *grabber, enum sink_state state,
1112                                         MFTIME systime, LONGLONG offset)
1113 {
1114     static const DWORD events[] =
1115     {
1116         MEStreamSinkStopped, /* SINK_STATE_STOPPED */
1117         MEStreamSinkPaused,  /* SINK_STATE_PAUSED */
1118         MEStreamSinkStarted, /* SINK_STATE_RUNNING */
1119     };
1120     BOOL do_callback = FALSE;
1121     HRESULT hr = S_OK;
1122     unsigned int i;
1123
1124     EnterCriticalSection(&grabber->cs);
1125
1126     if (!grabber->is_shut_down)
1127     {
1128         if (state == SINK_STATE_PAUSED && grabber->state == SINK_STATE_STOPPED)
1129             hr = MF_E_INVALID_STATE_TRANSITION;
1130         else
1131         {
1132             if (state == SINK_STATE_STOPPED)
1133                 sample_grabber_cancel_timer(grabber);
1134
1135             if (state == SINK_STATE_RUNNING && grabber->state == SINK_STATE_STOPPED)
1136             {
1137                 /* Every transition to running state sends a bunch requests to build up initial queue. */
1138                 for (i = 0; i < 4; ++i)
1139                     sample_grabber_stream_request_sample(grabber);
1140             }
1141             do_callback = state != grabber->state || state != SINK_STATE_PAUSED;
1142             if (do_callback)
1143                 IMFStreamSink_QueueEvent(&grabber->IMFStreamSink_iface, events[state], &GUID_NULL, S_OK, NULL);
1144             grabber->state = state;
1145         }
1146     }
1147
1148     LeaveCriticalSection(&grabber->cs);
1149
1150     if (do_callback)
1151     {
1152         switch (state)
1153         {
1154         case SINK_STATE_STOPPED:
1155             hr = IMFSampleGrabberSinkCallback_OnClockStop(sample_grabber_get_callback(grabber), systime);
1156             break;
1157         case SINK_STATE_PAUSED:
1158             hr = IMFSampleGrabberSinkCallback_OnClockPause(sample_grabber_get_callback(grabber), systime);
1159             break;
1160         case SINK_STATE_RUNNING:
1161             hr = IMFSampleGrabberSinkCallback_OnClockStart(sample_grabber_get_callback(grabber), systime, offset);
1162             break;
1163         }
1164     }
1165
1166     return hr;
1167 }
1168
1169 static HRESULT WINAPI sample_grabber_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
1170 {
1171     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1172
1173     TRACE("%p, %s, %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
1174
1175     return sample_grabber_set_state(grabber, SINK_STATE_RUNNING, systime, offset);
1176 }
1177
1178 static HRESULT WINAPI sample_grabber_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
1179 {
1180     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1181
1182     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1183
1184     return sample_grabber_set_state(grabber, SINK_STATE_STOPPED, systime, 0);
1185 }
1186
1187 static HRESULT WINAPI sample_grabber_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
1188 {
1189     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1190
1191     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1192
1193     return sample_grabber_set_state(grabber, SINK_STATE_PAUSED, systime, 0);
1194 }
1195
1196 static HRESULT WINAPI sample_grabber_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
1197 {
1198     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1199
1200     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1201
1202     return sample_grabber_set_state(grabber, SINK_STATE_RUNNING, systime, PRESENTATION_CURRENT_POSITION);
1203 }
1204
1205 static HRESULT WINAPI sample_grabber_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
1206 {
1207     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1208
1209     TRACE("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
1210
1211     return IMFSampleGrabberSinkCallback_OnClockSetRate(sample_grabber_get_callback(grabber), systime, rate);
1212 }
1213
1214 static HRESULT WINAPI sample_grabber_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
1215 {
1216     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1217     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1218 }
1219
1220 static ULONG WINAPI sample_grabber_events_AddRef(IMFMediaEventGenerator *iface)
1221 {
1222     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1223     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1224 }
1225
1226 static ULONG WINAPI sample_grabber_events_Release(IMFMediaEventGenerator *iface)
1227 {
1228     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1229     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1230 }
1231
1232 static HRESULT WINAPI sample_grabber_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
1233 {
1234     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1235
1236     TRACE("%p, %#x, %p.\n", iface, flags, event);
1237
1238     return IMFMediaEventQueue_GetEvent(grabber->event_queue, flags, event);
1239 }
1240
1241 static HRESULT WINAPI sample_grabber_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
1242         IUnknown *state)
1243 {
1244     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1245
1246     TRACE("%p, %p, %p.\n", iface, callback, state);
1247
1248     return IMFMediaEventQueue_BeginGetEvent(grabber->event_queue, callback, state);
1249 }
1250
1251 static HRESULT WINAPI sample_grabber_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
1252         IMFMediaEvent **event)
1253 {
1254     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1255
1256     TRACE("%p, %p, %p.\n", iface, result, event);
1257
1258     return IMFMediaEventQueue_EndGetEvent(grabber->event_queue, result, event);
1259 }
1260
1261 static HRESULT WINAPI sample_grabber_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
1262         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
1263 {
1264     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1265
1266     TRACE("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
1267
1268     return IMFMediaEventQueue_QueueEventParamVar(grabber->event_queue, event_type, ext_type, hr, value);
1269 }
1270
1271 static const IMFMediaEventGeneratorVtbl sample_grabber_sink_events_vtbl =
1272 {
1273     sample_grabber_events_QueryInterface,
1274     sample_grabber_events_AddRef,
1275     sample_grabber_events_Release,
1276     sample_grabber_events_GetEvent,
1277     sample_grabber_events_BeginGetEvent,
1278     sample_grabber_events_EndGetEvent,
1279     sample_grabber_events_QueueEvent,
1280 };
1281
1282 static const IMFClockStateSinkVtbl sample_grabber_clock_sink_vtbl =
1283 {
1284     sample_grabber_clock_sink_QueryInterface,
1285     sample_grabber_clock_sink_AddRef,
1286     sample_grabber_clock_sink_Release,
1287     sample_grabber_clock_sink_OnClockStart,
1288     sample_grabber_clock_sink_OnClockStop,
1289     sample_grabber_clock_sink_OnClockPause,
1290     sample_grabber_clock_sink_OnClockRestart,
1291     sample_grabber_clock_sink_OnClockSetRate,
1292 };
1293
1294 static HRESULT WINAPI sample_grabber_getservice_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
1295 {
1296     struct sample_grabber *grabber = impl_from_IMFGetService(iface);
1297     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1298 }
1299
1300 static ULONG WINAPI sample_grabber_getservice_AddRef(IMFGetService *iface)
1301 {
1302     struct sample_grabber *grabber = impl_from_IMFGetService(iface);
1303     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1304 }
1305
1306 static ULONG WINAPI sample_grabber_getservice_Release(IMFGetService *iface)
1307 {
1308     struct sample_grabber *grabber = impl_from_IMFGetService(iface);
1309     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1310 }
1311
1312 static HRESULT WINAPI sample_grabber_getservice_GetService(IMFGetService *iface, REFGUID service,
1313         REFIID riid, void **obj)
1314 {
1315     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
1316
1317     if (IsEqualGUID(service, &MF_RATE_CONTROL_SERVICE))
1318     {
1319         if (IsEqualIID(riid, &IID_IMFRateSupport))
1320             return IMFGetService_QueryInterface(iface, riid, obj);
1321
1322         return E_NOINTERFACE;
1323     }
1324
1325     FIXME("Unsupported service %s, riid %s.\n", debugstr_guid(service), debugstr_guid(riid));
1326
1327     return MF_E_UNSUPPORTED_SERVICE;
1328 }
1329
1330 static const IMFGetServiceVtbl sample_grabber_getservice_vtbl =
1331 {
1332     sample_grabber_getservice_QueryInterface,
1333     sample_grabber_getservice_AddRef,
1334     sample_grabber_getservice_Release,
1335     sample_grabber_getservice_GetService,
1336 };
1337
1338 static HRESULT WINAPI sample_grabber_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **obj)
1339 {
1340     struct sample_grabber *grabber = impl_from_IMFRateSupport(iface);
1341     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1342 }
1343
1344 static ULONG WINAPI sample_grabber_rate_support_AddRef(IMFRateSupport *iface)
1345 {
1346     struct sample_grabber *grabber = impl_from_IMFRateSupport(iface);
1347     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1348 }
1349
1350 static ULONG WINAPI sample_grabber_rate_support_Release(IMFRateSupport *iface)
1351 {
1352     struct sample_grabber *grabber = impl_from_IMFRateSupport(iface);
1353     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1354 }
1355
1356 static HRESULT WINAPI sample_grabber_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
1357         BOOL thin, float *rate)
1358 {
1359     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
1360
1361     *rate = 0.0f;
1362
1363     return S_OK;
1364 }
1365
1366 static HRESULT WINAPI sample_grabber_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
1367         BOOL thin, float *rate)
1368 {
1369     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
1370
1371     *rate = direction == MFRATE_REVERSE ? -FLT_MAX : FLT_MAX;
1372
1373     return S_OK;
1374 }
1375
1376 static HRESULT WINAPI sample_grabber_rate_support_IsRateSupported(IMFRateSupport *iface, BOOL thin, float rate,
1377         float *ret_rate)
1378 {
1379     TRACE("%p, %d, %f, %p.\n", iface, thin, rate, ret_rate);
1380
1381     if (ret_rate)
1382         *ret_rate = rate;
1383
1384     return S_OK;
1385 }
1386
1387 static const IMFRateSupportVtbl sample_grabber_rate_support_vtbl =
1388 {
1389     sample_grabber_rate_support_QueryInterface,
1390     sample_grabber_rate_support_AddRef,
1391     sample_grabber_rate_support_Release,
1392     sample_grabber_rate_support_GetSlowestRate,
1393     sample_grabber_rate_support_GetFastestRate,
1394     sample_grabber_rate_support_IsRateSupported,
1395 };
1396
1397 static HRESULT sample_grabber_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj)
1398 {
1399     struct sample_grabber_activate_context *context = user_context;
1400     struct sample_grabber *object;
1401     HRESULT hr;
1402     GUID guid;
1403
1404     TRACE("%p, %p, %p.\n", attributes, user_context, obj);
1405
1406     if (context->shut_down)
1407         return MF_E_SHUTDOWN;
1408
1409     /* At least major type is required. */
1410     if (FAILED(IMFMediaType_GetMajorType(context->media_type, &guid)))
1411         return MF_E_INVALIDMEDIATYPE;
1412
1413     if (!(object = calloc(1, sizeof(*object))))
1414         return E_OUTOFMEMORY;
1415
1416     object->IMFMediaSink_iface.lpVtbl = &sample_grabber_sink_vtbl;
1417     object->IMFClockStateSink_iface.lpVtbl = &sample_grabber_clock_sink_vtbl;
1418     object->IMFMediaEventGenerator_iface.lpVtbl = &sample_grabber_sink_events_vtbl;
1419     object->IMFGetService_iface.lpVtbl = &sample_grabber_getservice_vtbl;
1420     object->IMFRateSupport_iface.lpVtbl = &sample_grabber_rate_support_vtbl;
1421     object->IMFStreamSink_iface.lpVtbl = &sample_grabber_stream_vtbl;
1422     object->IMFMediaTypeHandler_iface.lpVtbl = &sample_grabber_stream_type_handler_vtbl;
1423     object->timer_callback.lpVtbl = &sample_grabber_stream_timer_callback_vtbl;
1424     object->refcount = 1;
1425     if (FAILED(IMFSampleGrabberSinkCallback_QueryInterface(context->callback, &IID_IMFSampleGrabberSinkCallback2,
1426             (void **)&object->callback2)))
1427     {
1428         object->callback = context->callback;
1429         IMFSampleGrabberSinkCallback_AddRef(object->callback);
1430     }
1431     object->media_type = context->media_type;
1432     IMFMediaType_AddRef(object->media_type);
1433     object->current_media_type = context->media_type;
1434     IMFMediaType_AddRef(object->current_media_type);
1435     IMFAttributes_GetUINT32(attributes, &MF_SAMPLEGRABBERSINK_IGNORE_CLOCK, &object->ignore_clock);
1436     IMFAttributes_GetUINT64(attributes, &MF_SAMPLEGRABBERSINK_SAMPLE_TIME_OFFSET, &object->sample_time_offset);
1437     list_init(&object->items);
1438     InitializeCriticalSection(&object->cs);
1439
1440     if (FAILED(hr = MFCreateEventQueue(&object->stream_event_queue)))
1441         goto failed;
1442
1443     if (FAILED(hr = MFCreateAttributes(&object->sample_attributes, 0)))
1444         goto failed;
1445
1446     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
1447         goto failed;
1448
1449     *obj = (IUnknown *)&object->IMFMediaSink_iface;
1450
1451     TRACE("Created %p.\n", *obj);
1452
1453     return S_OK;
1454
1455 failed:
1456
1457     IMFMediaSink_Release(&object->IMFMediaSink_iface);
1458
1459     return hr;
1460 }
1461
1462 static void sample_grabber_shutdown_object(void *user_context, IUnknown *obj)
1463 {
1464     struct sample_grabber_activate_context *context = user_context;
1465     context->shut_down = TRUE;
1466 }
1467
1468 static const struct activate_funcs sample_grabber_activate_funcs =
1469 {
1470     sample_grabber_create_object,
1471     sample_grabber_shutdown_object,
1472     sample_grabber_free_private,
1473 };
1474
1475 /***********************************************************************
1476  *      MFCreateSampleGrabberSinkActivate (mf.@)
1477  */
1478 HRESULT WINAPI MFCreateSampleGrabberSinkActivate(IMFMediaType *media_type, IMFSampleGrabberSinkCallback *callback,
1479         IMFActivate **activate)
1480 {
1481     struct sample_grabber_activate_context *context;
1482     HRESULT hr;
1483
1484     TRACE("%p, %p, %p.\n", media_type, callback, activate);
1485
1486     if (!media_type || !callback || !activate)
1487         return E_POINTER;
1488
1489     if (!(context = calloc(1, sizeof(*context))))
1490         return E_OUTOFMEMORY;
1491
1492     context->media_type = media_type;
1493     IMFMediaType_AddRef(context->media_type);
1494     context->callback = callback;
1495     IMFSampleGrabberSinkCallback_AddRef(context->callback);
1496
1497     if (FAILED(hr = create_activation_object(context, &sample_grabber_activate_funcs, activate)))
1498         sample_grabber_free_private(context);
1499
1500     return hr;
1501 }