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     HRESULT hr = S_OK;
 659
 660     TRACE("%p, %p.\n", iface, media_type);
 661
 662     if (!media_type)
 663         return E_POINTER;
 664
 665     EnterCriticalSection(&grabber->cs);
 666
 667     if (grabber->is_shut_down)
 668     {
 669         hr = MF_E_STREAMSINK_REMOVED;
 670     }
 671     else
 672     {
 673         *media_type = grabber->current_media_type;
 674         IMFMediaType_AddRef(*media_type);
 675     }
 676
 677     LeaveCriticalSection(&grabber->cs);
 678
 679     return hr;
 680 }
 681
 682 static HRESULT WINAPI sample_grabber_stream_type_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
 683 {
 684     struct sample_grabber *grabber = impl_from_IMFMediaTypeHandler(iface);
 685     HRESULT hr;
 686
 687     TRACE("%p, %p.\n", iface, type);
 688
 689     if (!type)
 690         return E_POINTER;
 691
 692     EnterCriticalSection(&grabber->cs);
 693
 694     if (grabber->is_shut_down)
 695         hr = MF_E_STREAMSINK_REMOVED;
 696     else
 697         hr = IMFMediaType_GetMajorType(grabber->current_media_type, type);
 698
 699     LeaveCriticalSection(&grabber->cs);
 700
 701     return hr;
 702 }
 703
 704 static const IMFMediaTypeHandlerVtbl sample_grabber_stream_type_handler_vtbl =
 705 {
 706     sample_grabber_stream_type_handler_QueryInterface,
 707     sample_grabber_stream_type_handler_AddRef,
 708     sample_grabber_stream_type_handler_Release,
 709     sample_grabber_stream_type_handler_IsMediaTypeSupported,
 710     sample_grabber_stream_type_handler_GetMediaTypeCount,
 711     sample_grabber_stream_type_handler_GetMediaTypeByIndex,
 712     sample_grabber_stream_type_handler_SetCurrentMediaType,
 713     sample_grabber_stream_type_handler_GetCurrentMediaType,
 714     sample_grabber_stream_type_handler_GetMajorType,
 715 };
 716
 717 static HRESULT WINAPI sample_grabber_stream_timer_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid,
 718         void **obj)
 719 {
 720     if (IsEqualIID(riid, &IID_IMFAsyncCallback) || IsEqualIID(riid, &IID_IUnknown))
 721     {
 722         *obj = iface;
 723         IMFAsyncCallback_AddRef(iface);
 724         return S_OK;
 725     }
 726
 727     WARN("Unsupported %s.\n", debugstr_guid(riid));
 728     *obj = NULL;
 729     return E_NOINTERFACE;
 730 }
 731
 732 static ULONG WINAPI sample_grabber_stream_timer_callback_AddRef(IMFAsyncCallback *iface)
 733 {
 734     struct sample_grabber *grabber = impl_from_IMFAsyncCallback(iface);
 735     return IMFStreamSink_AddRef(&grabber->IMFStreamSink_iface);
 736 }
 737
 738 static ULONG WINAPI sample_grabber_stream_timer_callback_Release(IMFAsyncCallback *iface)
 739 {
 740     struct sample_grabber *grabber = impl_from_IMFAsyncCallback(iface);
 741     return IMFStreamSink_Release(&grabber->IMFStreamSink_iface);
 742 }
 743
 744 static HRESULT WINAPI sample_grabber_stream_timer_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags,
 745         DWORD *queue)
 746 {
 747     return E_NOTIMPL;
 748 }
 749
 750 static HRESULT WINAPI sample_grabber_stream_timer_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 751 {
 752     struct sample_grabber *grabber = impl_from_IMFAsyncCallback(iface);
 753     BOOL sample_reported = FALSE, sample_delivered = FALSE;
 754     struct scheduled_item *item, *item2;
 755     HRESULT hr;
 756
 757     EnterCriticalSection(&grabber->cs);
 758
 759     LIST_FOR_EACH_ENTRY_SAFE(item, item2, &grabber->items, struct scheduled_item, entry)
 760     {
 761         if (item->type == ITEM_TYPE_MARKER)
 762         {
 763             sample_grabber_stream_report_marker(grabber, &item->u.marker.context, S_OK);
 764             stream_release_pending_item(item);
 765         }
 766         else if (item->type == ITEM_TYPE_SAMPLE)
 767         {
 768             if (!sample_reported)
 769             {
 770                 if (FAILED(hr = sample_grabber_report_sample(grabber, item->u.sample, &sample_delivered)))
 771                     WARN("Failed to report a sample, hr %#lx.\n", hr);
 772                 stream_release_pending_item(item);
 773                 sample_reported = TRUE;
 774             }
 775             else
 776             {
 777                 if (FAILED(hr = stream_schedule_sample(grabber, item)))
 778                     WARN("Failed to schedule a sample, hr %#lx.\n", hr);
 779                 break;
 780             }
 781         }
 782     }
 783     if (sample_delivered)
 784         sample_grabber_stream_request_sample(grabber);
 785
 786     LeaveCriticalSection(&grabber->cs);
 787
 788     return S_OK;
 789 }
 790
 791 static const IMFAsyncCallbackVtbl sample_grabber_stream_timer_callback_vtbl =
 792 {
 793     sample_grabber_stream_timer_callback_QueryInterface,
 794     sample_grabber_stream_timer_callback_AddRef,
 795     sample_grabber_stream_timer_callback_Release,
 796     sample_grabber_stream_timer_callback_GetParameters,
 797     sample_grabber_stream_timer_callback_Invoke,
 798 };
 799
 800 static HRESULT WINAPI sample_grabber_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj)
 801 {
 802     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 803
 804     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 805
 806     if (IsEqualIID(riid, &IID_IMFMediaSink) ||
 807             IsEqualIID(riid, &IID_IUnknown))
 808     {
 809         *obj = &grabber->IMFMediaSink_iface;
 810     }
 811     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
 812     {
 813         *obj = &grabber->IMFClockStateSink_iface;
 814     }
 815     else if (IsEqualIID(riid, &IID_IMFMediaEventGenerator))
 816     {
 817         *obj = &grabber->IMFMediaEventGenerator_iface;
 818     }
 819     else if (IsEqualIID(riid, &IID_IMFGetService))
 820     {
 821         *obj = &grabber->IMFGetService_iface;
 822     }
 823     else if (IsEqualIID(riid, &IID_IMFRateSupport))
 824     {
 825         *obj = &grabber->IMFRateSupport_iface;
 826     }
 827     else
 828     {
 829         WARN("Unsupported %s.\n", debugstr_guid(riid));
 830         *obj = NULL;
 831         return E_NOINTERFACE;
 832     }
 833
 834     IUnknown_AddRef((IUnknown *)*obj);
 835
 836     return S_OK;
 837 }
 838
 839 static ULONG WINAPI sample_grabber_sink_AddRef(IMFMediaSink *iface)
 840 {
 841     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 842     ULONG refcount = InterlockedIncrement(&grabber->refcount);
 843
 844     TRACE("%p, refcount %lu.\n", iface, refcount);
 845
 846     return refcount;
 847 }
 848
 849 static void sample_grabber_release_pending_items(struct sample_grabber *grabber)
 850 {
 851     struct scheduled_item *item, *next_item;
 852
 853     LIST_FOR_EACH_ENTRY_SAFE(item, next_item, &grabber->items, struct scheduled_item, entry)
 854     {
 855         stream_release_pending_item(item);
 856     }
 857 }
 858
 859 static void release_samples(struct sample_grabber *grabber)
 860 {
 861     unsigned int i;
 862
 863     for (i = 0; i < MAX_SAMPLE_QUEUE_LENGTH; ++i)
 864     {
 865         if (grabber->samples[i])
 866         {
 867             IMFSample_Release(grabber->samples[i]);
 868             grabber->samples[i] = NULL;
 869         }
 870     }
 871 }
 872
 873 static ULONG WINAPI sample_grabber_sink_Release(IMFMediaSink *iface)
 874 {
 875     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 876     ULONG refcount = InterlockedDecrement(&grabber->refcount);
 877
 878     TRACE("%p, refcount %lu.\n", iface, refcount);
 879
 880     if (!refcount)
 881     {
 882         if (grabber->callback)
 883             IMFSampleGrabberSinkCallback_Release(grabber->callback);
 884         if (grabber->callback2)
 885             IMFSampleGrabberSinkCallback2_Release(grabber->callback2);
 886         if (grabber->current_media_type)
 887             IMFMediaType_Release(grabber->current_media_type);
 888         IMFMediaType_Release(grabber->media_type);
 889         if (grabber->event_queue)
 890             IMFMediaEventQueue_Release(grabber->event_queue);
 891         if (grabber->clock)
 892             IMFPresentationClock_Release(grabber->clock);
 893         if (grabber->timer)
 894             IMFTimer_Release(grabber->timer);
 895         if (grabber->cancel_key)
 896             IUnknown_Release(grabber->cancel_key);
 897         if (grabber->stream_event_queue)
 898         {
 899             IMFMediaEventQueue_Shutdown(grabber->stream_event_queue);
 900             IMFMediaEventQueue_Release(grabber->stream_event_queue);
 901         }
 902         if (grabber->sample_attributes)
 903             IMFAttributes_Release(grabber->sample_attributes);
 904         sample_grabber_release_pending_items(grabber);
 905         release_samples(grabber);
 906         DeleteCriticalSection(&grabber->cs);
 907         free(grabber);
 908     }
 909
 910     return refcount;
 911 }
 912
 913 static HRESULT WINAPI sample_grabber_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags)
 914 {
 915     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 916
 917     TRACE("%p, %p.\n", iface, flags);
 918
 919     if (grabber->is_shut_down)
 920         return MF_E_SHUTDOWN;
 921
 922     *flags = MEDIASINK_FIXED_STREAMS;
 923     if (grabber->ignore_clock)
 924         *flags |= MEDIASINK_RATELESS;
 925
 926     return S_OK;
 927 }
 928
 929 static HRESULT WINAPI sample_grabber_sink_AddStreamSink(IMFMediaSink *iface, DWORD stream_sink_id,
 930     IMFMediaType *media_type, IMFStreamSink **stream_sink)
 931 {
 932     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 933
 934     TRACE("%p, %#lx, %p, %p.\n", iface, stream_sink_id, media_type, stream_sink);
 935
 936     return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 937 }
 938
 939 static HRESULT WINAPI sample_grabber_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id)
 940 {
 941     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 942
 943     TRACE("%p, %#lx.\n", iface, stream_sink_id);
 944
 945     return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED;
 946 }
 947
 948 static HRESULT WINAPI sample_grabber_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
 949 {
 950     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 951
 952     TRACE("%p, %p.\n", iface, count);
 953
 954     if (grabber->is_shut_down)
 955         return MF_E_SHUTDOWN;
 956
 957     *count = 1;
 958
 959     return S_OK;
 960 }
 961
 962 static HRESULT WINAPI sample_grabber_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index,
 963         IMFStreamSink **stream)
 964 {
 965     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 966     HRESULT hr = S_OK;
 967
 968     TRACE("%p, %lu, %p.\n", iface, index, stream);
 969
 970     EnterCriticalSection(&grabber->cs);
 971
 972     if (grabber->is_shut_down)
 973         hr = MF_E_SHUTDOWN;
 974     else if (index > 0)
 975         hr = MF_E_INVALIDINDEX;
 976     else
 977     {
 978        *stream = &grabber->IMFStreamSink_iface;
 979        IMFStreamSink_AddRef(*stream);
 980     }
 981
 982     LeaveCriticalSection(&grabber->cs);
 983
 984     return hr;
 985 }
 986
 987 static HRESULT WINAPI sample_grabber_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id,
 988         IMFStreamSink **stream)
 989 {
 990     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
 991     HRESULT hr = S_OK;
 992
 993     TRACE("%p, %#lx, %p.\n", iface, stream_sink_id, stream);
 994
 995     EnterCriticalSection(&grabber->cs);
 996
 997     if (grabber->is_shut_down)
 998         hr = MF_E_SHUTDOWN;
 999     else if (stream_sink_id > 0)
1000         hr = MF_E_INVALIDSTREAMNUMBER;
1001     else
1002     {
1003         *stream = &grabber->IMFStreamSink_iface;
1004         IMFStreamSink_AddRef(*stream);
1005     }
1006
1007     LeaveCriticalSection(&grabber->cs);
1008
1009     return hr;
1010 }
1011
1012 static void sample_grabber_cancel_timer(struct sample_grabber *grabber)
1013 {
1014     if (grabber->timer && grabber->cancel_key)
1015     {
1016         IMFTimer_CancelTimer(grabber->timer, grabber->cancel_key);
1017         IUnknown_Release(grabber->cancel_key);
1018         grabber->cancel_key = NULL;
1019     }
1020 }
1021
1022 static HRESULT sample_grabber_set_presentation_clock(struct sample_grabber *grabber, IMFPresentationClock *clock)
1023 {
1024     HRESULT hr;
1025
1026     if (FAILED(hr = IMFSampleGrabberSinkCallback_OnSetPresentationClock(sample_grabber_get_callback(grabber), clock)))
1027         return hr;
1028
1029     if (grabber->clock)
1030     {
1031         sample_grabber_cancel_timer(grabber);
1032         IMFPresentationClock_RemoveClockStateSink(grabber->clock, &grabber->IMFClockStateSink_iface);
1033         IMFPresentationClock_Release(grabber->clock);
1034         if (grabber->timer)
1035         {
1036             IMFTimer_Release(grabber->timer);
1037             grabber->timer = NULL;
1038         }
1039     }
1040     grabber->clock = clock;
1041     if (grabber->clock)
1042     {
1043         IMFPresentationClock_AddRef(grabber->clock);
1044         IMFPresentationClock_AddClockStateSink(grabber->clock, &grabber->IMFClockStateSink_iface);
1045         if (FAILED(IMFPresentationClock_QueryInterface(grabber->clock, &IID_IMFTimer, (void **)&grabber->timer)))
1046         {
1047             WARN("Failed to get IMFTimer interface.\n");
1048             grabber->timer = NULL;
1049         }
1050     }
1051
1052     return hr;
1053 }
1054
1055 static HRESULT WINAPI sample_grabber_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
1056 {
1057     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
1058     HRESULT hr;
1059
1060     TRACE("%p, %p.\n", iface, clock);
1061
1062     EnterCriticalSection(&grabber->cs);
1063
1064     if (grabber->is_shut_down)
1065     {
1066         hr = MF_E_SHUTDOWN;
1067     }
1068     else
1069     {
1070         hr = sample_grabber_set_presentation_clock(grabber, clock);
1071     }
1072
1073     LeaveCriticalSection(&grabber->cs);
1074
1075     return hr;
1076 }
1077
1078 static HRESULT WINAPI sample_grabber_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
1079 {
1080     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
1081     HRESULT hr = S_OK;
1082
1083     TRACE("%p, %p.\n", iface, clock);
1084
1085     if (!clock)
1086         return E_POINTER;
1087
1088     EnterCriticalSection(&grabber->cs);
1089
1090     if (grabber->clock)
1091     {
1092         *clock = grabber->clock;
1093         IMFPresentationClock_AddRef(*clock);
1094     }
1095     else
1096         hr = MF_E_NO_CLOCK;
1097
1098     LeaveCriticalSection(&grabber->cs);
1099
1100     return hr;
1101 }
1102
1103 static HRESULT WINAPI sample_grabber_sink_Shutdown(IMFMediaSink *iface)
1104 {
1105     struct sample_grabber *grabber = impl_from_IMFMediaSink(iface);
1106     HRESULT hr;
1107
1108     TRACE("%p.\n", iface);
1109
1110     EnterCriticalSection(&grabber->cs);
1111
1112     if (grabber->is_shut_down)
1113         hr = MF_E_SHUTDOWN;
1114     else
1115     {
1116         grabber->is_shut_down = TRUE;
1117         sample_grabber_release_pending_items(grabber);
1118         if (SUCCEEDED(hr = sample_grabber_set_presentation_clock(grabber, NULL)))
1119             hr = IMFSampleGrabberSinkCallback_OnShutdown(sample_grabber_get_callback(grabber));
1120         if (SUCCEEDED(hr))
1121         {
1122             IMFMediaType_Release(grabber->current_media_type);
1123             grabber->current_media_type = NULL;
1124             IMFMediaEventQueue_Shutdown(grabber->stream_event_queue);
1125             IMFMediaEventQueue_Shutdown(grabber->event_queue);
1126         }
1127     }
1128
1129     LeaveCriticalSection(&grabber->cs);
1130
1131     return hr;
1132 }
1133
1134 static const IMFMediaSinkVtbl sample_grabber_sink_vtbl =
1135 {
1136     sample_grabber_sink_QueryInterface,
1137     sample_grabber_sink_AddRef,
1138     sample_grabber_sink_Release,
1139     sample_grabber_sink_GetCharacteristics,
1140     sample_grabber_sink_AddStreamSink,
1141     sample_grabber_sink_RemoveStreamSink,
1142     sample_grabber_sink_GetStreamSinkCount,
1143     sample_grabber_sink_GetStreamSinkByIndex,
1144     sample_grabber_sink_GetStreamSinkById,
1145     sample_grabber_sink_SetPresentationClock,
1146     sample_grabber_sink_GetPresentationClock,
1147     sample_grabber_sink_Shutdown,
1148 };
1149
1150 static HRESULT WINAPI sample_grabber_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
1151 {
1152     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1153     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1154 }
1155
1156 static ULONG WINAPI sample_grabber_clock_sink_AddRef(IMFClockStateSink *iface)
1157 {
1158     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1159     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1160 }
1161
1162 static ULONG WINAPI sample_grabber_clock_sink_Release(IMFClockStateSink *iface)
1163 {
1164     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1165     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1166 }
1167
1168 static HRESULT sample_grabber_set_state(struct sample_grabber *grabber, enum sink_state state,
1169                                         MFTIME systime, LONGLONG offset)
1170 {
1171     static const DWORD events[] =
1172     {
1173         MEStreamSinkStopped, /* SINK_STATE_STOPPED */
1174         MEStreamSinkPaused,  /* SINK_STATE_PAUSED */
1175         MEStreamSinkStarted, /* SINK_STATE_RUNNING */
1176     };
1177     BOOL do_callback = FALSE;
1178     HRESULT hr = S_OK;
1179     unsigned int i;
1180
1181     EnterCriticalSection(&grabber->cs);
1182
1183     if (!grabber->is_shut_down)
1184     {
1185         if (state == SINK_STATE_PAUSED && grabber->state == SINK_STATE_STOPPED)
1186             hr = MF_E_INVALID_STATE_TRANSITION;
1187         else
1188         {
1189             if (state == SINK_STATE_STOPPED)
1190             {
1191                 sample_grabber_cancel_timer(grabber);
1192                 release_samples(grabber);
1193                 grabber->sample_count = MAX_SAMPLE_QUEUE_LENGTH;
1194             }
1195
1196             if (state == SINK_STATE_RUNNING && grabber->state != SINK_STATE_RUNNING)
1197             {
1198                 /* Every transition to running state sends a bunch requests to build up initial queue. */
1199                 for (i = 0; i < grabber->sample_count; ++i)
1200                 {
1201                     if (grabber->state == SINK_STATE_PAUSED && offset == PRESENTATION_CURRENT_POSITION)
1202                     {
1203                         assert(grabber->samples[i]);
1204                         stream_queue_sample(grabber, grabber->samples[i]);
1205                     }
1206                     else
1207                     {
1208                         sample_grabber_stream_request_sample(grabber);
1209                     }
1210                 }
1211                 release_samples(grabber);
1212                 grabber->sample_count = 0;
1213             }
1214
1215             do_callback = state != grabber->state || state != SINK_STATE_PAUSED;
1216             if (do_callback)
1217             {
1218                 if (grabber->rate == 0.0f && state == SINK_STATE_RUNNING)
1219                     IMFStreamSink_QueueEvent(&grabber->IMFStreamSink_iface, MEStreamSinkScrubSampleComplete,
1220                             &GUID_NULL, S_OK, NULL);
1221
1222                 IMFStreamSink_QueueEvent(&grabber->IMFStreamSink_iface, events[state], &GUID_NULL, S_OK, NULL);
1223             }
1224             grabber->state = state;
1225         }
1226     }
1227
1228     LeaveCriticalSection(&grabber->cs);
1229
1230     if (do_callback)
1231     {
1232         switch (state)
1233         {
1234         case SINK_STATE_STOPPED:
1235             hr = IMFSampleGrabberSinkCallback_OnClockStop(sample_grabber_get_callback(grabber), systime);
1236             break;
1237         case SINK_STATE_PAUSED:
1238             hr = IMFSampleGrabberSinkCallback_OnClockPause(sample_grabber_get_callback(grabber), systime);
1239             break;
1240         case SINK_STATE_RUNNING:
1241             hr = IMFSampleGrabberSinkCallback_OnClockStart(sample_grabber_get_callback(grabber), systime, offset);
1242             break;
1243         }
1244     }
1245
1246     return hr;
1247 }
1248
1249 static HRESULT WINAPI sample_grabber_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
1250 {
1251     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1252
1253     TRACE("%p, %s, %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
1254
1255     return sample_grabber_set_state(grabber, SINK_STATE_RUNNING, systime, offset);
1256 }
1257
1258 static HRESULT WINAPI sample_grabber_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
1259 {
1260     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1261
1262     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1263
1264     return sample_grabber_set_state(grabber, SINK_STATE_STOPPED, systime, 0);
1265 }
1266
1267 static HRESULT WINAPI sample_grabber_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
1268 {
1269     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1270
1271     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1272
1273     return sample_grabber_set_state(grabber, SINK_STATE_PAUSED, systime, 0);
1274 }
1275
1276 static HRESULT WINAPI sample_grabber_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
1277 {
1278     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1279
1280     TRACE("%p, %s.\n", iface, debugstr_time(systime));
1281
1282     return sample_grabber_set_state(grabber, SINK_STATE_RUNNING, systime, PRESENTATION_CURRENT_POSITION);
1283 }
1284
1285 static HRESULT WINAPI sample_grabber_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
1286 {
1287     struct sample_grabber *grabber = impl_from_IMFClockStateSink(iface);
1288     HRESULT hr = S_OK;
1289
1290     TRACE("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
1291
1292     EnterCriticalSection(&grabber->cs);
1293
1294     if (grabber->is_shut_down)
1295         hr = MF_E_SHUTDOWN;
1296     else
1297     {
1298         IMFStreamSink_QueueEvent(&grabber->IMFStreamSink_iface, MEStreamSinkRateChanged, &GUID_NULL, S_OK, NULL);
1299         grabber->rate = rate;
1300     }
1301
1302     LeaveCriticalSection(&grabber->cs);
1303
1304     if (SUCCEEDED(hr))
1305         hr = IMFSampleGrabberSinkCallback_OnClockSetRate(sample_grabber_get_callback(grabber), systime, rate);
1306
1307     return hr;
1308 }
1309
1310 static HRESULT WINAPI sample_grabber_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
1311 {
1312     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1313     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1314 }
1315
1316 static ULONG WINAPI sample_grabber_events_AddRef(IMFMediaEventGenerator *iface)
1317 {
1318     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1319     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1320 }
1321
1322 static ULONG WINAPI sample_grabber_events_Release(IMFMediaEventGenerator *iface)
1323 {
1324     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1325     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1326 }
1327
1328 static HRESULT WINAPI sample_grabber_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
1329 {
1330     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1331
1332     TRACE("%p, %#lx, %p.\n", iface, flags, event);
1333
1334     return IMFMediaEventQueue_GetEvent(grabber->event_queue, flags, event);
1335 }
1336
1337 static HRESULT WINAPI sample_grabber_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
1338         IUnknown *state)
1339 {
1340     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1341
1342     TRACE("%p, %p, %p.\n", iface, callback, state);
1343
1344     return IMFMediaEventQueue_BeginGetEvent(grabber->event_queue, callback, state);
1345 }
1346
1347 static HRESULT WINAPI sample_grabber_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
1348         IMFMediaEvent **event)
1349 {
1350     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1351
1352     TRACE("%p, %p, %p.\n", iface, result, event);
1353
1354     return IMFMediaEventQueue_EndGetEvent(grabber->event_queue, result, event);
1355 }
1356
1357 static HRESULT WINAPI sample_grabber_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
1358         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
1359 {
1360     struct sample_grabber *grabber = impl_from_IMFMediaEventGenerator(iface);
1361
1362     TRACE("%p, %lu, %s, %#lx, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
1363
1364     return IMFMediaEventQueue_QueueEventParamVar(grabber->event_queue, event_type, ext_type, hr, value);
1365 }
1366
1367 static const IMFMediaEventGeneratorVtbl sample_grabber_sink_events_vtbl =
1368 {
1369     sample_grabber_events_QueryInterface,
1370     sample_grabber_events_AddRef,
1371     sample_grabber_events_Release,
1372     sample_grabber_events_GetEvent,
1373     sample_grabber_events_BeginGetEvent,
1374     sample_grabber_events_EndGetEvent,
1375     sample_grabber_events_QueueEvent,
1376 };
1377
1378 static const IMFClockStateSinkVtbl sample_grabber_clock_sink_vtbl =
1379 {
1380     sample_grabber_clock_sink_QueryInterface,
1381     sample_grabber_clock_sink_AddRef,
1382     sample_grabber_clock_sink_Release,
1383     sample_grabber_clock_sink_OnClockStart,
1384     sample_grabber_clock_sink_OnClockStop,
1385     sample_grabber_clock_sink_OnClockPause,
1386     sample_grabber_clock_sink_OnClockRestart,
1387     sample_grabber_clock_sink_OnClockSetRate,
1388 };
1389
1390 static HRESULT WINAPI sample_grabber_getservice_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
1391 {
1392     struct sample_grabber *grabber = impl_from_IMFGetService(iface);
1393     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1394 }
1395
1396 static ULONG WINAPI sample_grabber_getservice_AddRef(IMFGetService *iface)
1397 {
1398     struct sample_grabber *grabber = impl_from_IMFGetService(iface);
1399     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1400 }
1401
1402 static ULONG WINAPI sample_grabber_getservice_Release(IMFGetService *iface)
1403 {
1404     struct sample_grabber *grabber = impl_from_IMFGetService(iface);
1405     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1406 }
1407
1408 static HRESULT WINAPI sample_grabber_getservice_GetService(IMFGetService *iface, REFGUID service,
1409         REFIID riid, void **obj)
1410 {
1411     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
1412
1413     if (IsEqualGUID(service, &MF_RATE_CONTROL_SERVICE))
1414     {
1415         if (IsEqualIID(riid, &IID_IMFRateSupport))
1416             return IMFGetService_QueryInterface(iface, riid, obj);
1417
1418         return E_NOINTERFACE;
1419     }
1420
1421     FIXME("Unsupported service %s, riid %s.\n", debugstr_guid(service), debugstr_guid(riid));
1422
1423     return MF_E_UNSUPPORTED_SERVICE;
1424 }
1425
1426 static const IMFGetServiceVtbl sample_grabber_getservice_vtbl =
1427 {
1428     sample_grabber_getservice_QueryInterface,
1429     sample_grabber_getservice_AddRef,
1430     sample_grabber_getservice_Release,
1431     sample_grabber_getservice_GetService,
1432 };
1433
1434 static HRESULT WINAPI sample_grabber_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **obj)
1435 {
1436     struct sample_grabber *grabber = impl_from_IMFRateSupport(iface);
1437     return IMFMediaSink_QueryInterface(&grabber->IMFMediaSink_iface, riid, obj);
1438 }
1439
1440 static ULONG WINAPI sample_grabber_rate_support_AddRef(IMFRateSupport *iface)
1441 {
1442     struct sample_grabber *grabber = impl_from_IMFRateSupport(iface);
1443     return IMFMediaSink_AddRef(&grabber->IMFMediaSink_iface);
1444 }
1445
1446 static ULONG WINAPI sample_grabber_rate_support_Release(IMFRateSupport *iface)
1447 {
1448     struct sample_grabber *grabber = impl_from_IMFRateSupport(iface);
1449     return IMFMediaSink_Release(&grabber->IMFMediaSink_iface);
1450 }
1451
1452 static HRESULT WINAPI sample_grabber_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
1453         BOOL thin, float *rate)
1454 {
1455     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
1456
1457     *rate = 0.0f;
1458
1459     return S_OK;
1460 }
1461
1462 static HRESULT WINAPI sample_grabber_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
1463         BOOL thin, float *rate)
1464 {
1465     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
1466
1467     *rate = direction == MFRATE_REVERSE ? -FLT_MAX : FLT_MAX;
1468
1469     return S_OK;
1470 }
1471
1472 static HRESULT WINAPI sample_grabber_rate_support_IsRateSupported(IMFRateSupport *iface, BOOL thin, float rate,
1473         float *ret_rate)
1474 {
1475     TRACE("%p, %d, %f, %p.\n", iface, thin, rate, ret_rate);
1476
1477     if (ret_rate)
1478         *ret_rate = rate;
1479
1480     return S_OK;
1481 }
1482
1483 static const IMFRateSupportVtbl sample_grabber_rate_support_vtbl =
1484 {
1485     sample_grabber_rate_support_QueryInterface,
1486     sample_grabber_rate_support_AddRef,
1487     sample_grabber_rate_support_Release,
1488     sample_grabber_rate_support_GetSlowestRate,
1489     sample_grabber_rate_support_GetFastestRate,
1490     sample_grabber_rate_support_IsRateSupported,
1491 };
1492
1493 static HRESULT sample_grabber_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj)
1494 {
1495     struct sample_grabber_activate_context *context = user_context;
1496     struct sample_grabber *object;
1497     HRESULT hr;
1498     GUID guid;
1499
1500     TRACE("%p, %p, %p.\n", attributes, user_context, obj);
1501
1502     if (context->shut_down)
1503         return MF_E_SHUTDOWN;
1504
1505     /* At least major type is required. */
1506     if (FAILED(IMFMediaType_GetMajorType(context->media_type, &guid)))
1507         return MF_E_INVALIDMEDIATYPE;
1508
1509     if (!(object = calloc(1, sizeof(*object))))
1510         return E_OUTOFMEMORY;
1511
1512     object->IMFMediaSink_iface.lpVtbl = &sample_grabber_sink_vtbl;
1513     object->IMFClockStateSink_iface.lpVtbl = &sample_grabber_clock_sink_vtbl;
1514     object->IMFMediaEventGenerator_iface.lpVtbl = &sample_grabber_sink_events_vtbl;
1515     object->IMFGetService_iface.lpVtbl = &sample_grabber_getservice_vtbl;
1516     object->IMFRateSupport_iface.lpVtbl = &sample_grabber_rate_support_vtbl;
1517     object->IMFStreamSink_iface.lpVtbl = &sample_grabber_stream_vtbl;
1518     object->IMFMediaTypeHandler_iface.lpVtbl = &sample_grabber_stream_type_handler_vtbl;
1519     object->timer_callback.lpVtbl = &sample_grabber_stream_timer_callback_vtbl;
1520     object->sample_count = MAX_SAMPLE_QUEUE_LENGTH;
1521     object->refcount = 1;
1522     object->rate = 1.0f;
1523     if (FAILED(IMFSampleGrabberSinkCallback_QueryInterface(context->callback, &IID_IMFSampleGrabberSinkCallback2,
1524             (void **)&object->callback2)))
1525     {
1526         object->callback = context->callback;
1527         IMFSampleGrabberSinkCallback_AddRef(object->callback);
1528     }
1529     object->media_type = context->media_type;
1530     IMFMediaType_AddRef(object->media_type);
1531     object->current_media_type = context->media_type;
1532     IMFMediaType_AddRef(object->current_media_type);
1533     IMFAttributes_GetUINT32(attributes, &MF_SAMPLEGRABBERSINK_IGNORE_CLOCK, &object->ignore_clock);
1534     IMFAttributes_GetUINT64(attributes, &MF_SAMPLEGRABBERSINK_SAMPLE_TIME_OFFSET, &object->sample_time_offset);
1535     list_init(&object->items);
1536     InitializeCriticalSection(&object->cs);
1537
1538     if (FAILED(hr = MFCreateEventQueue(&object->stream_event_queue)))
1539         goto failed;
1540
1541     if (FAILED(hr = MFCreateAttributes(&object->sample_attributes, 0)))
1542         goto failed;
1543
1544     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
1545         goto failed;
1546
1547     *obj = (IUnknown *)&object->IMFMediaSink_iface;
1548
1549     TRACE("Created %p.\n", *obj);
1550
1551     return S_OK;
1552
1553 failed:
1554
1555     IMFMediaSink_Release(&object->IMFMediaSink_iface);
1556
1557     return hr;
1558 }
1559
1560 static void sample_grabber_shutdown_object(void *user_context, IUnknown *obj)
1561 {
1562     struct sample_grabber_activate_context *context = user_context;
1563     context->shut_down = TRUE;
1564 }
1565
1566 static const struct activate_funcs sample_grabber_activate_funcs =
1567 {
1568     sample_grabber_create_object,
1569     sample_grabber_shutdown_object,
1570     sample_grabber_free_private,
1571 };
1572
1573 /***********************************************************************
1574  *      MFCreateSampleGrabberSinkActivate (mf.@)
1575  */
1576 HRESULT WINAPI MFCreateSampleGrabberSinkActivate(IMFMediaType *media_type, IMFSampleGrabberSinkCallback *callback,
1577         IMFActivate **activate)
1578 {
1579     struct sample_grabber_activate_context *context;
1580     HRESULT hr;
1581
1582     TRACE("%p, %p, %p.\n", media_type, callback, activate);
1583
1584     if (!media_type || !callback || !activate)
1585         return E_POINTER;
1586
1587     if (!(context = calloc(1, sizeof(*context))))
1588         return E_OUTOFMEMORY;
1589
1590     context->media_type = media_type;
1591     IMFMediaType_AddRef(context->media_type);
1592     context->callback = callback;
1593     IMFSampleGrabberSinkCallback_AddRef(context->callback);
1594
1595     if (FAILED(hr = create_activation_object(context, &sample_grabber_activate_funcs, activate)))
1596         sample_grabber_free_private(context);
1597
1598     return hr;
1599 }