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