dlls/winegstreamer/media_sink.c

   1 /* Gstreamer Media Sink
   2  *
   3  * Copyright 2023 Ziqing Hui for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "gst_private.h"
  21 #include "mferror.h"
  22 #include "mfapi.h"
  23
  24 #include "wine/debug.h"
  25 #include "wine/list.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  28
  29 enum async_op
  30 {
  31     ASYNC_START,
  32     ASYNC_STOP,
  33     ASYNC_PAUSE,
  34 };
  35
  36 struct async_command
  37 {
  38     IUnknown IUnknown_iface;
  39     LONG refcount;
  40
  41     enum async_op op;
  42 };
  43
  44 struct stream_sink
  45 {
  46     IMFStreamSink IMFStreamSink_iface;
  47     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
  48     LONG refcount;
  49     DWORD id;
  50
  51     IMFMediaType *type;
  52     IMFFinalizableMediaSink *media_sink;
  53     IMFMediaEventQueue *event_queue;
  54
  55     struct list entry;
  56 };
  57
  58 struct media_sink
  59 {
  60     IMFFinalizableMediaSink IMFFinalizableMediaSink_iface;
  61     IMFMediaEventGenerator IMFMediaEventGenerator_iface;
  62     IMFClockStateSink IMFClockStateSink_iface;
  63     IMFAsyncCallback async_callback;
  64     LONG refcount;
  65     CRITICAL_SECTION cs;
  66
  67     enum
  68     {
  69         STATE_OPENED,
  70         STATE_STARTED,
  71         STATE_STOPPED,
  72         STATE_PAUSED,
  73         STATE_SHUTDOWN,
  74     } state;
  75
  76     IMFByteStream *bytestream;
  77     IMFMediaEventQueue *event_queue;
  78
  79     struct list stream_sinks;
  80 };
  81
  82 static struct stream_sink *impl_from_IMFStreamSink(IMFStreamSink *iface)
  83 {
  84     return CONTAINING_RECORD(iface, struct stream_sink, IMFStreamSink_iface);
  85 }
  86
  87 static struct stream_sink *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
  88 {
  89     return CONTAINING_RECORD(iface, struct stream_sink, IMFMediaTypeHandler_iface);
  90 }
  91
  92 static struct media_sink *impl_from_IMFFinalizableMediaSink(IMFFinalizableMediaSink *iface)
  93 {
  94     return CONTAINING_RECORD(iface, struct media_sink, IMFFinalizableMediaSink_iface);
  95 }
  96
  97 static struct media_sink *impl_from_IMFMediaEventGenerator(IMFMediaEventGenerator *iface)
  98 {
  99     return CONTAINING_RECORD(iface, struct media_sink, IMFMediaEventGenerator_iface);
 100 }
 101
 102 static struct media_sink *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
 103 {
 104     return CONTAINING_RECORD(iface, struct media_sink, IMFClockStateSink_iface);
 105 }
 106
 107 static struct media_sink *impl_from_async_callback(IMFAsyncCallback *iface)
 108 {
 109     return CONTAINING_RECORD(iface, struct media_sink, async_callback);
 110 }
 111
 112 static struct async_command *impl_from_async_command_IUnknown(IUnknown *iface)
 113 {
 114     return CONTAINING_RECORD(iface, struct async_command, IUnknown_iface);
 115 }
 116
 117 static HRESULT WINAPI async_command_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 118 {
 119     if (IsEqualIID(riid, &IID_IUnknown))
 120     {
 121         *obj = iface;
 122         IUnknown_AddRef(iface);
 123         return S_OK;
 124     }
 125
 126     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 127     *obj = NULL;
 128     return E_NOINTERFACE;
 129 }
 130
 131 static ULONG WINAPI async_command_AddRef(IUnknown *iface)
 132 {
 133     struct async_command *command = impl_from_async_command_IUnknown(iface);
 134     return InterlockedIncrement(&command->refcount);
 135 }
 136
 137 static ULONG WINAPI async_command_Release(IUnknown *iface)
 138 {
 139     struct async_command *command = impl_from_async_command_IUnknown(iface);
 140     ULONG refcount = InterlockedDecrement(&command->refcount);
 141
 142     if (!refcount)
 143         free(command);
 144
 145     return refcount;
 146 }
 147
 148 static const IUnknownVtbl async_command_vtbl =
 149 {
 150     async_command_QueryInterface,
 151     async_command_AddRef,
 152     async_command_Release,
 153 };
 154
 155 static HRESULT async_command_create(enum async_op op, struct async_command **out)
 156 {
 157     struct async_command *command;
 158
 159     if (!(command = calloc(1, sizeof(*command))))
 160         return E_OUTOFMEMORY;
 161
 162     command->IUnknown_iface.lpVtbl = &async_command_vtbl;
 163     command->refcount = 1;
 164     command->op = op;
 165
 166     TRACE("Created async command %p.\n", command);
 167     *out = command;
 168
 169     return S_OK;
 170 }
 171
 172 static HRESULT WINAPI stream_sink_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj)
 173 {
 174     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 175
 176     TRACE("iface %p, riid %s, obj %p.\n", iface, debugstr_guid(riid), obj);
 177
 178     if (IsEqualIID(riid, &IID_IMFStreamSink) ||
 179             IsEqualGUID(riid, &IID_IMFMediaEventGenerator) ||
 180             IsEqualIID(riid, &IID_IUnknown))
 181     {
 182         *obj = &stream_sink->IMFStreamSink_iface;
 183     }
 184     else if (IsEqualIID(riid, &IID_IMFMediaTypeHandler))
 185     {
 186         *obj = &stream_sink->IMFMediaTypeHandler_iface;
 187     }
 188     else
 189     {
 190         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 191         *obj = NULL;
 192         return E_NOINTERFACE;
 193     }
 194
 195     IUnknown_AddRef((IUnknown *)*obj);
 196
 197     return S_OK;
 198 }
 199
 200 static ULONG WINAPI stream_sink_AddRef(IMFStreamSink *iface)
 201 {
 202     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 203     ULONG refcount = InterlockedIncrement(&stream_sink->refcount);
 204     TRACE("iface %p, refcount %lu.\n", iface, refcount);
 205     return refcount;
 206 }
 207
 208 static ULONG WINAPI stream_sink_Release(IMFStreamSink *iface)
 209 {
 210     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 211     ULONG refcount = InterlockedDecrement(&stream_sink->refcount);
 212
 213     TRACE("iface %p, refcount %lu.\n", iface, refcount);
 214
 215     if (!refcount)
 216     {
 217         IMFMediaEventQueue_Release(stream_sink->event_queue);
 218         IMFFinalizableMediaSink_Release(stream_sink->media_sink);
 219         if (stream_sink->type)
 220             IMFMediaType_Release(stream_sink->type);
 221         free(stream_sink);
 222     }
 223
 224     return refcount;
 225 }
 226
 227 static HRESULT WINAPI stream_sink_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event)
 228 {
 229     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 230
 231     TRACE("iface %p, flags %#lx, event %p.\n", iface, flags, event);
 232
 233     return IMFMediaEventQueue_GetEvent(stream_sink->event_queue, flags, event);
 234 }
 235
 236 static HRESULT WINAPI stream_sink_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback,
 237         IUnknown *state)
 238 {
 239     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 240
 241     TRACE("iface %p, callback %p, state %p.\n", iface, callback, state);
 242
 243     return IMFMediaEventQueue_BeginGetEvent(stream_sink->event_queue, callback, state);
 244 }
 245
 246 static HRESULT WINAPI stream_sink_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result,
 247         IMFMediaEvent **event)
 248 {
 249     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 250
 251     TRACE("iface %p, result %p, event %p.\n", iface, result, event);
 252
 253     return IMFMediaEventQueue_EndGetEvent(stream_sink->event_queue, result, event);
 254 }
 255
 256 static HRESULT WINAPI stream_sink_QueueEvent(IMFStreamSink *iface, MediaEventType event_type,
 257         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 258 {
 259     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 260
 261     TRACE("iface %p, event_type %lu, ext_type %s, hr %#lx, value %p.\n",
 262             iface, event_type, debugstr_guid(ext_type), hr, value);
 263
 264     return IMFMediaEventQueue_QueueEventParamVar(stream_sink->event_queue, event_type, ext_type, hr, value);
 265 }
 266
 267 static HRESULT WINAPI stream_sink_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **ret)
 268 {
 269     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 270
 271     TRACE("iface %p, ret %p.\n", iface, ret);
 272
 273     IMFMediaSink_AddRef((*ret = (IMFMediaSink *)stream_sink->media_sink));
 274
 275     return S_OK;
 276 }
 277
 278 static HRESULT WINAPI stream_sink_GetIdentifier(IMFStreamSink *iface, DWORD *identifier)
 279 {
 280     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 281
 282     TRACE("iface %p, identifier %p.\n", iface, identifier);
 283
 284     *identifier = stream_sink->id;
 285
 286     return S_OK;
 287 }
 288
 289 static HRESULT WINAPI stream_sink_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler)
 290 {
 291     struct stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
 292
 293     TRACE("iface %p, handler %p.\n", iface, handler);
 294
 295     IMFMediaTypeHandler_AddRef((*handler = &stream_sink->IMFMediaTypeHandler_iface));
 296
 297     return S_OK;
 298 }
 299
 300 static HRESULT WINAPI stream_sink_ProcessSample(IMFStreamSink *iface, IMFSample *sample)
 301 {
 302     FIXME("iface %p, sample %p stub!\n", iface, sample);
 303
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI stream_sink_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type,
 308         const PROPVARIANT *marker_value, const PROPVARIANT *context_value)
 309 {
 310     FIXME("iface %p, marker_type %d, marker_value %p, context_value %p stub!\n",
 311             iface, marker_type, marker_value, context_value);
 312
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI stream_sink_Flush(IMFStreamSink *iface)
 317 {
 318     FIXME("iface %p stub!\n", iface);
 319
 320     return E_NOTIMPL;
 321 }
 322
 323 static const IMFStreamSinkVtbl stream_sink_vtbl =
 324 {
 325     stream_sink_QueryInterface,
 326     stream_sink_AddRef,
 327     stream_sink_Release,
 328     stream_sink_GetEvent,
 329     stream_sink_BeginGetEvent,
 330     stream_sink_EndGetEvent,
 331     stream_sink_QueueEvent,
 332     stream_sink_GetMediaSink,
 333     stream_sink_GetIdentifier,
 334     stream_sink_GetMediaTypeHandler,
 335     stream_sink_ProcessSample,
 336     stream_sink_PlaceMarker,
 337     stream_sink_Flush,
 338 };
 339
 340 static HRESULT WINAPI stream_sink_type_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid, void **obj)
 341 {
 342     struct stream_sink *stream_sink = impl_from_IMFMediaTypeHandler(iface);
 343     return IMFStreamSink_QueryInterface(&stream_sink->IMFStreamSink_iface, riid, obj);
 344 }
 345
 346 static ULONG WINAPI stream_sink_type_handler_AddRef(IMFMediaTypeHandler *iface)
 347 {
 348     struct stream_sink *stream_sink = impl_from_IMFMediaTypeHandler(iface);
 349     return IMFStreamSink_AddRef(&stream_sink->IMFStreamSink_iface);
 350 }
 351
 352 static ULONG WINAPI stream_sink_type_handler_Release(IMFMediaTypeHandler *iface)
 353 {
 354     struct stream_sink *stream_sink = impl_from_IMFMediaTypeHandler(iface);
 355     return IMFStreamSink_Release(&stream_sink->IMFStreamSink_iface);
 356 }
 357
 358 static HRESULT WINAPI stream_sink_type_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface,
 359         IMFMediaType *in_type, IMFMediaType **out_type)
 360 {
 361     FIXME("iface %p, in_type %p, out_type %p.\n", iface, in_type, out_type);
 362
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI stream_sink_type_handler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
 367 {
 368     FIXME("iface %p, count %p.\n", iface, count);
 369
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT WINAPI stream_sink_type_handler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
 374         IMFMediaType **type)
 375 {
 376     FIXME("iface %p, index %lu, type %p.\n", iface, index, type);
 377
 378     return E_NOTIMPL;
 379 }
 380
 381 static HRESULT WINAPI stream_sink_type_handler_SetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType *type)
 382 {
 383     FIXME("iface %p, type %p.\n", iface, type);
 384
 385     return E_NOTIMPL;
 386 }
 387
 388 static HRESULT WINAPI stream_sink_type_handler_GetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType **type)
 389 {
 390     struct stream_sink *stream_sink = impl_from_IMFMediaTypeHandler(iface);
 391
 392     TRACE("iface %p, type %p.\n", iface, type);
 393
 394     if (!type)
 395         return E_POINTER;
 396     if (!stream_sink->type)
 397         return MF_E_NOT_INITIALIZED;
 398
 399     IMFMediaType_AddRef((*type = stream_sink->type));
 400
 401     return S_OK;
 402 }
 403
 404 static HRESULT WINAPI stream_sink_type_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
 405 {
 406     FIXME("iface %p, type %p.\n", iface, type);
 407
 408     return E_NOTIMPL;
 409 }
 410
 411 static const IMFMediaTypeHandlerVtbl stream_sink_type_handler_vtbl =
 412 {
 413     stream_sink_type_handler_QueryInterface,
 414     stream_sink_type_handler_AddRef,
 415     stream_sink_type_handler_Release,
 416     stream_sink_type_handler_IsMediaTypeSupported,
 417     stream_sink_type_handler_GetMediaTypeCount,
 418     stream_sink_type_handler_GetMediaTypeByIndex,
 419     stream_sink_type_handler_SetCurrentMediaType,
 420     stream_sink_type_handler_GetCurrentMediaType,
 421     stream_sink_type_handler_GetMajorType,
 422 };
 423
 424 static HRESULT stream_sink_create(DWORD stream_sink_id, IMFMediaType *media_type, struct media_sink *media_sink,
 425         struct stream_sink **out)
 426 {
 427     struct stream_sink *stream_sink;
 428     HRESULT hr;
 429
 430     TRACE("stream_sink_id %#lx, media_type %p, media_sink %p, out %p.\n",
 431             stream_sink_id, media_type, media_sink, out);
 432
 433     if (!(stream_sink = calloc(1, sizeof(*stream_sink))))
 434         return E_OUTOFMEMORY;
 435
 436     if (FAILED(hr = MFCreateEventQueue(&stream_sink->event_queue)))
 437     {
 438         free(stream_sink);
 439         return hr;
 440     }
 441
 442     stream_sink->IMFStreamSink_iface.lpVtbl = &stream_sink_vtbl;
 443     stream_sink->IMFMediaTypeHandler_iface.lpVtbl = &stream_sink_type_handler_vtbl;
 444     stream_sink->refcount = 1;
 445     stream_sink->id = stream_sink_id;
 446     if (media_type)
 447         IMFMediaType_AddRef((stream_sink->type = media_type));
 448     IMFFinalizableMediaSink_AddRef((stream_sink->media_sink = &media_sink->IMFFinalizableMediaSink_iface));
 449
 450     TRACE("Created stream sink %p.\n", stream_sink);
 451     *out = stream_sink;
 452
 453     return S_OK;
 454 }
 455
 456 static struct stream_sink *media_sink_get_stream_sink_by_id(struct media_sink *media_sink, DWORD id)
 457 {
 458     struct stream_sink *stream_sink;
 459
 460     LIST_FOR_EACH_ENTRY(stream_sink, &media_sink->stream_sinks, struct stream_sink, entry)
 461     {
 462         if (stream_sink->id == id)
 463             return stream_sink;
 464     }
 465
 466     return NULL;
 467 }
 468
 469 static HRESULT media_sink_queue_command(struct media_sink *media_sink, enum async_op op)
 470 {
 471     struct async_command *command;
 472     HRESULT hr;
 473
 474     if (media_sink->state == STATE_SHUTDOWN)
 475         return MF_E_SHUTDOWN;
 476
 477     if (FAILED(hr = async_command_create(op, &command)))
 478         return hr;
 479
 480     return MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, &media_sink->async_callback, &command->IUnknown_iface);
 481 }
 482
 483 static HRESULT media_sink_queue_stream_event(struct media_sink *media_sink, MediaEventType type)
 484 {
 485     struct stream_sink *stream_sink;
 486     HRESULT hr;
 487
 488     LIST_FOR_EACH_ENTRY(stream_sink, &media_sink->stream_sinks, struct stream_sink, entry)
 489     {
 490         if (FAILED(hr = IMFMediaEventQueue_QueueEventParamVar(stream_sink->event_queue, type, &GUID_NULL, S_OK, NULL)))
 491             return hr;
 492     }
 493
 494     return S_OK;
 495 }
 496
 497 static HRESULT media_sink_start(struct media_sink *media_sink)
 498 {
 499     media_sink->state = STATE_STARTED;
 500     return media_sink_queue_stream_event(media_sink, MEStreamSinkStarted);
 501 }
 502
 503 static HRESULT media_sink_stop(struct media_sink *media_sink)
 504 {
 505     media_sink->state = STATE_STOPPED;
 506     return media_sink_queue_stream_event(media_sink, MEStreamSinkStopped);
 507
 508 }
 509
 510 static HRESULT media_sink_pause(struct media_sink *media_sink)
 511 {
 512     media_sink->state = STATE_PAUSED;
 513     return media_sink_queue_stream_event(media_sink, MEStreamSinkPaused);
 514 }
 515
 516 static HRESULT WINAPI media_sink_QueryInterface(IMFFinalizableMediaSink *iface, REFIID riid, void **obj)
 517 {
 518     struct media_sink *media_sink = impl_from_IMFFinalizableMediaSink(iface);
 519
 520     TRACE("iface %p, riid %s, obj %p.\n", iface, debugstr_guid(riid), obj);
 521
 522     if (IsEqualIID(riid, &IID_IMFFinalizableMediaSink) ||
 523             IsEqualIID(riid, &IID_IMFMediaSink) ||
 524             IsEqualIID(riid, &IID_IUnknown))
 525     {
 526         *obj = iface;
 527     }
 528     else if (IsEqualGUID(riid, &IID_IMFMediaEventGenerator))
 529     {
 530         *obj = &media_sink->IMFMediaEventGenerator_iface;
 531     }
 532     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
 533     {
 534         *obj = &media_sink->IMFClockStateSink_iface;
 535     }
 536     else
 537     {
 538         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 539         *obj = NULL;
 540         return E_NOINTERFACE;
 541     }
 542
 543     IUnknown_AddRef((IUnknown *)*obj);
 544
 545     return S_OK;
 546 }
 547
 548 static ULONG WINAPI media_sink_AddRef(IMFFinalizableMediaSink *iface)
 549 {
 550     struct media_sink *media_sink = impl_from_IMFFinalizableMediaSink(iface);
 551     ULONG refcount = InterlockedIncrement(&media_sink->refcount);
 552     TRACE("iface %p, refcount %lu.\n", iface, refcount);
 553     return refcount;
 554 }
 555
 556 static ULONG WINAPI media_sink_Release(IMFFinalizableMediaSink *iface)
 557 {
 558     struct media_sink *media_sink = impl_from_IMFFinalizableMediaSink(iface);
 559     ULONG refcount = InterlockedDecrement(&media_sink->refcount);
 560
 561     TRACE("iface %p, refcount %lu.\n", iface, refcount);
 562
 563     if (!refcount)
 564     {
 565         IMFFinalizableMediaSink_Shutdown(iface);
 566         IMFMediaEventQueue_Release(media_sink->event_queue);
 567         IMFByteStream_Release(media_sink->bytestream);
 568         media_sink->cs.DebugInfo->Spare[0] = 0;
 569         DeleteCriticalSection(&media_sink->cs);
 570         free(media_sink);
 571     }
 572
 573     return refcount;
 574 }
 575
 576 static HRESULT WINAPI media_sink_GetCharacteristics(IMFFinalizableMediaSink *iface, DWORD *flags)
 577 {
 578     FIXME("iface %p, flags %p stub!\n", iface, flags);
 579
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI media_sink_AddStreamSink(IMFFinalizableMediaSink *iface, DWORD stream_sink_id,
 584     IMFMediaType *media_type, IMFStreamSink **stream_sink)
 585 {
 586     struct media_sink *media_sink = impl_from_IMFFinalizableMediaSink(iface);
 587     struct stream_sink *object;
 588     HRESULT hr;
 589
 590     TRACE("iface %p, stream_sink_id %#lx, media_type %p, stream_sink %p.\n",
 591             iface, stream_sink_id, media_type, stream_sink);
 592
 593     EnterCriticalSection(&media_sink->cs);
 594
 595     if (media_sink_get_stream_sink_by_id(media_sink, stream_sink_id))
 596     {
 597         LeaveCriticalSection(&media_sink->cs);
 598         return MF_E_STREAMSINK_EXISTS;
 599     }
 600
 601     if (FAILED(hr = stream_sink_create(stream_sink_id, media_type, media_sink, &object)))
 602     {
 603         WARN("Failed to create stream sink, hr %#lx.\n", hr);
 604         LeaveCriticalSection(&media_sink->cs);
 605         return hr;
 606     }
 607
 608     list_add_tail(&media_sink->stream_sinks, &object->entry);
 609
 610     LeaveCriticalSection(&media_sink->cs);
 611
 612     if (stream_sink)
 613         IMFStreamSink_AddRef((*stream_sink = &object->IMFStreamSink_iface));
 614
 615     return S_OK;
 616 }
 617
 618 static HRESULT WINAPI media_sink_RemoveStreamSink(IMFFinalizableMediaSink *iface, DWORD stream_sink_id)
 619 {
 620     FIXME("iface %p, stream_sink_id %#lx stub!\n", iface, stream_sink_id);
 621
 622     return E_NOTIMPL;
 623 }
 624
 625 static HRESULT WINAPI media_sink_GetStreamSinkCount(IMFFinalizableMediaSink *iface, DWORD *count)
 626 {
 627     struct media_sink *media_sink = impl_from_IMFFinalizableMediaSink(iface);
 628
 629     TRACE("iface %p, count %p.\n", iface, count);
 630
 631     if (!count)
 632         return E_POINTER;
 633
 634     EnterCriticalSection(&media_sink->cs);
 635     *count = list_count(&media_sink->stream_sinks);
 636     LeaveCriticalSection(&media_sink->cs);
 637
 638     return S_OK;
 639 }
 640
 641 static HRESULT WINAPI media_sink_GetStreamSinkByIndex(IMFFinalizableMediaSink *iface, DWORD index,
 642         IMFStreamSink **stream)
 643 {
 644     struct media_sink *media_sink = impl_from_IMFFinalizableMediaSink(iface);
 645     struct stream_sink *stream_sink;
 646     HRESULT hr = MF_E_INVALIDINDEX;
 647     DWORD entry_index = 0;
 648
 649     TRACE("iface %p, index %lu, stream %p stub!\n", iface, index, stream);
 650
 651     if (!stream)
 652         return E_POINTER;
 653
 654     EnterCriticalSection(&media_sink->cs);
 655
 656     LIST_FOR_EACH_ENTRY(stream_sink, &media_sink->stream_sinks, struct stream_sink, entry)
 657     {
 658         if (entry_index++ == index)
 659         {
 660             IMFStreamSink_AddRef((*stream = &stream_sink->IMFStreamSink_iface));
 661             hr = S_OK;
 662             break;
 663         }
 664     }
 665
 666     LeaveCriticalSection(&media_sink->cs);
 667
 668     return hr;
 669 }
 670
 671 static HRESULT WINAPI media_sink_GetStreamSinkById(IMFFinalizableMediaSink *iface, DWORD stream_sink_id,
 672         IMFStreamSink **stream)
 673 {
 674     struct media_sink *media_sink = impl_from_IMFFinalizableMediaSink(iface);
 675     struct stream_sink *stream_sink;
 676     HRESULT hr;
 677
 678     TRACE("iface %p, stream_sink_id %#lx, stream %p.\n", iface, stream_sink_id, stream);
 679
 680     if (!stream)
 681         return E_POINTER;
 682
 683     EnterCriticalSection(&media_sink->cs);
 684
 685     hr = MF_E_INVALIDSTREAMNUMBER;
 686     if ((stream_sink = media_sink_get_stream_sink_by_id(media_sink, stream_sink_id)))
 687     {
 688         IMFStreamSink_AddRef((*stream = &stream_sink->IMFStreamSink_iface));
 689         hr = S_OK;
 690     }
 691
 692     LeaveCriticalSection(&media_sink->cs);
 693
 694     return hr;
 695 }
 696
 697 static HRESULT WINAPI media_sink_SetPresentationClock(IMFFinalizableMediaSink *iface, IMFPresentationClock *clock)
 698 {
 699     FIXME("iface %p, clock %p stub!\n", iface, clock);
 700
 701     return E_NOTIMPL;
 702 }
 703
 704 static HRESULT WINAPI media_sink_GetPresentationClock(IMFFinalizableMediaSink *iface, IMFPresentationClock **clock)
 705 {
 706     FIXME("iface %p, clock %p stub!\n", iface, clock);
 707
 708     return E_NOTIMPL;
 709 }
 710
 711 static HRESULT WINAPI media_sink_Shutdown(IMFFinalizableMediaSink *iface)
 712 {
 713     struct media_sink *media_sink = impl_from_IMFFinalizableMediaSink(iface);
 714     struct stream_sink *stream_sink, *next;
 715
 716     TRACE("iface %p.\n", iface);
 717
 718     EnterCriticalSection(&media_sink->cs);
 719
 720     if (media_sink->state == STATE_SHUTDOWN)
 721     {
 722         LeaveCriticalSection(&media_sink->cs);
 723         return MF_E_SHUTDOWN;
 724     }
 725
 726     LIST_FOR_EACH_ENTRY_SAFE(stream_sink, next, &media_sink->stream_sinks, struct stream_sink, entry)
 727     {
 728         list_remove(&stream_sink->entry);
 729         IMFMediaEventQueue_Shutdown(stream_sink->event_queue);
 730         IMFStreamSink_Release(&stream_sink->IMFStreamSink_iface);
 731     }
 732
 733     IMFMediaEventQueue_Shutdown(media_sink->event_queue);
 734     IMFByteStream_Close(media_sink->bytestream);
 735
 736     media_sink->state = STATE_SHUTDOWN;
 737
 738     LeaveCriticalSection(&media_sink->cs);
 739
 740     return S_OK;
 741 }
 742
 743 static HRESULT WINAPI media_sink_BeginFinalize(IMFFinalizableMediaSink *iface, IMFAsyncCallback *callback, IUnknown *state)
 744 {
 745     FIXME("iface %p, callback %p, state %p stub!\n", iface, callback, state);
 746
 747     return E_NOTIMPL;
 748 }
 749
 750 static HRESULT WINAPI media_sink_EndFinalize(IMFFinalizableMediaSink *iface, IMFAsyncResult *result)
 751 {
 752     FIXME("iface %p, result %p stub!\n", iface, result);
 753
 754     return E_NOTIMPL;
 755 }
 756
 757 static const IMFFinalizableMediaSinkVtbl media_sink_vtbl =
 758 {
 759     media_sink_QueryInterface,
 760     media_sink_AddRef,
 761     media_sink_Release,
 762     media_sink_GetCharacteristics,
 763     media_sink_AddStreamSink,
 764     media_sink_RemoveStreamSink,
 765     media_sink_GetStreamSinkCount,
 766     media_sink_GetStreamSinkByIndex,
 767     media_sink_GetStreamSinkById,
 768     media_sink_SetPresentationClock,
 769     media_sink_GetPresentationClock,
 770     media_sink_Shutdown,
 771     media_sink_BeginFinalize,
 772     media_sink_EndFinalize,
 773 };
 774
 775 static HRESULT WINAPI media_sink_event_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
 776 {
 777     struct media_sink *media_sink = impl_from_IMFMediaEventGenerator(iface);
 778     return IMFFinalizableMediaSink_QueryInterface(&media_sink->IMFFinalizableMediaSink_iface, riid, obj);
 779 }
 780
 781 static ULONG WINAPI media_sink_event_AddRef(IMFMediaEventGenerator *iface)
 782 {
 783     struct media_sink *media_sink = impl_from_IMFMediaEventGenerator(iface);
 784     return IMFFinalizableMediaSink_AddRef(&media_sink->IMFFinalizableMediaSink_iface);
 785 }
 786
 787 static ULONG WINAPI media_sink_event_Release(IMFMediaEventGenerator *iface)
 788 {
 789     struct media_sink *media_sink = impl_from_IMFMediaEventGenerator(iface);
 790     return IMFFinalizableMediaSink_Release(&media_sink->IMFFinalizableMediaSink_iface);
 791 }
 792
 793 static HRESULT WINAPI media_sink_event_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
 794 {
 795     struct media_sink *media_sink = impl_from_IMFMediaEventGenerator(iface);
 796
 797     TRACE("iface %p, flags %#lx, event %p.\n", iface, flags, event);
 798
 799     return IMFMediaEventQueue_GetEvent(media_sink->event_queue, flags, event);
 800 }
 801
 802 static HRESULT WINAPI media_sink_event_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback,
 803         IUnknown *state)
 804 {
 805     struct media_sink *media_sink = impl_from_IMFMediaEventGenerator(iface);
 806
 807     TRACE("iface %p, callback %p, state %p.\n", iface, callback, state);
 808
 809     return IMFMediaEventQueue_BeginGetEvent(media_sink->event_queue, callback, state);
 810 }
 811
 812 static HRESULT WINAPI media_sink_event_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result,
 813         IMFMediaEvent **event)
 814 {
 815     struct media_sink *media_sink = impl_from_IMFMediaEventGenerator(iface);
 816
 817     TRACE("iface %p, result %p, event %p.\n", iface, result, event);
 818
 819     return IMFMediaEventQueue_EndGetEvent(media_sink->event_queue, result, event);
 820 }
 821
 822 static HRESULT WINAPI media_sink_event_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType event_type,
 823         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 824 {
 825     struct media_sink *media_sink = impl_from_IMFMediaEventGenerator(iface);
 826
 827     TRACE("iface %p, event_type %lu, ext_type %s, hr %#lx, value %p.\n",
 828             iface, event_type, debugstr_guid(ext_type), hr, value);
 829
 830     return IMFMediaEventQueue_QueueEventParamVar(media_sink->event_queue, event_type, ext_type, hr, value);
 831 }
 832
 833 static const IMFMediaEventGeneratorVtbl media_sink_event_vtbl =
 834 {
 835     media_sink_event_QueryInterface,
 836     media_sink_event_AddRef,
 837     media_sink_event_Release,
 838     media_sink_event_GetEvent,
 839     media_sink_event_BeginGetEvent,
 840     media_sink_event_EndGetEvent,
 841     media_sink_event_QueueEvent,
 842 };
 843
 844 static HRESULT WINAPI media_sink_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
 845 {
 846     struct media_sink *media_sink = impl_from_IMFClockStateSink(iface);
 847     return IMFFinalizableMediaSink_QueryInterface(&media_sink->IMFFinalizableMediaSink_iface, riid, obj);
 848 }
 849
 850 static ULONG WINAPI media_sink_clock_sink_AddRef(IMFClockStateSink *iface)
 851 {
 852     struct media_sink *media_sink = impl_from_IMFClockStateSink(iface);
 853     return IMFFinalizableMediaSink_AddRef(&media_sink->IMFFinalizableMediaSink_iface);
 854 }
 855
 856 static ULONG WINAPI media_sink_clock_sink_Release(IMFClockStateSink *iface)
 857 {
 858     struct media_sink *media_sink = impl_from_IMFClockStateSink(iface);
 859     return IMFFinalizableMediaSink_Release(&media_sink->IMFFinalizableMediaSink_iface);
 860 }
 861
 862 static HRESULT WINAPI media_sink_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME systime, LONGLONG offset)
 863 {
 864     struct media_sink *media_sink = impl_from_IMFClockStateSink(iface);
 865     HRESULT hr;
 866
 867     TRACE("iface %p, systime %s, offset %s.\n", iface, debugstr_time(systime), debugstr_time(offset));
 868
 869     EnterCriticalSection(&media_sink->cs);
 870
 871     hr = media_sink_queue_command(media_sink, ASYNC_START);
 872
 873     LeaveCriticalSection(&media_sink->cs);
 874     return hr;
 875 }
 876
 877 static HRESULT WINAPI media_sink_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME systime)
 878 {
 879     struct media_sink *media_sink = impl_from_IMFClockStateSink(iface);
 880     HRESULT hr;
 881
 882     TRACE("iface %p, systime %s.\n", iface, debugstr_time(systime));
 883
 884     EnterCriticalSection(&media_sink->cs);
 885
 886     hr = media_sink_queue_command(media_sink, ASYNC_STOP);
 887
 888     LeaveCriticalSection(&media_sink->cs);
 889     return hr;
 890 }
 891
 892 static HRESULT WINAPI media_sink_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME systime)
 893 {
 894     struct media_sink *media_sink = impl_from_IMFClockStateSink(iface);
 895     HRESULT hr;
 896
 897     TRACE("iface %p, systime %s.\n", iface, debugstr_time(systime));
 898
 899     EnterCriticalSection(&media_sink->cs);
 900
 901     hr = media_sink_queue_command(media_sink, ASYNC_PAUSE);
 902
 903     LeaveCriticalSection(&media_sink->cs);
 904     return hr;
 905 }
 906
 907 static HRESULT WINAPI media_sink_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME systime)
 908 {
 909     struct media_sink *media_sink = impl_from_IMFClockStateSink(iface);
 910     HRESULT hr;
 911
 912     TRACE("iface %p, systime %s.\n", iface, debugstr_time(systime));
 913
 914     EnterCriticalSection(&media_sink->cs);
 915
 916     hr = media_sink_queue_command(media_sink, ASYNC_START);
 917
 918     LeaveCriticalSection(&media_sink->cs);
 919     return hr;
 920 }
 921
 922 static HRESULT WINAPI media_sink_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME systime, float rate)
 923 {
 924     FIXME("iface %p, systime %s, rate %f stub!\n", iface, debugstr_time(systime), rate);
 925
 926     return E_NOTIMPL;
 927 }
 928
 929 static const IMFClockStateSinkVtbl media_sink_clock_sink_vtbl =
 930 {
 931     media_sink_clock_sink_QueryInterface,
 932     media_sink_clock_sink_AddRef,
 933     media_sink_clock_sink_Release,
 934     media_sink_clock_sink_OnClockStart,
 935     media_sink_clock_sink_OnClockStop,
 936     media_sink_clock_sink_OnClockPause,
 937     media_sink_clock_sink_OnClockRestart,
 938     media_sink_clock_sink_OnClockSetRate,
 939 };
 940
 941 static HRESULT WINAPI media_sink_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
 942 {
 943     TRACE("iface %p, riid %s, obj %p.\n", iface, debugstr_guid(riid), obj);
 944
 945     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 946             IsEqualIID(riid, &IID_IUnknown))
 947     {
 948         *obj = iface;
 949         IMFAsyncCallback_AddRef(iface);
 950         return S_OK;
 951     }
 952
 953     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 954     *obj = NULL;
 955     return E_NOINTERFACE;
 956 }
 957
 958 static ULONG WINAPI media_sink_callback_AddRef(IMFAsyncCallback *iface)
 959 {
 960     struct media_sink *sink = impl_from_async_callback(iface);
 961     return IMFFinalizableMediaSink_AddRef(&sink->IMFFinalizableMediaSink_iface);
 962 }
 963
 964 static ULONG WINAPI media_sink_callback_Release(IMFAsyncCallback *iface)
 965 {
 966     struct media_sink *sink = impl_from_async_callback(iface);
 967     return IMFFinalizableMediaSink_Release(&sink->IMFFinalizableMediaSink_iface);
 968 }
 969
 970 static HRESULT WINAPI media_sink_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
 971 {
 972     TRACE("iface %p, flags %p, queue %p.\n", iface, flags, queue);
 973
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI media_sink_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *async_result)
 978 {
 979     struct media_sink *media_sink = impl_from_async_callback(iface);
 980     struct async_command *command;
 981     HRESULT hr = E_FAIL;
 982     IUnknown *state;
 983
 984     TRACE("iface %p, async_result %p.\n", iface, async_result);
 985
 986     EnterCriticalSection(&media_sink->cs);
 987
 988     if (!(state = IMFAsyncResult_GetStateNoAddRef(async_result)))
 989     {
 990         LeaveCriticalSection(&media_sink->cs);
 991         return hr;
 992     }
 993
 994     command = impl_from_async_command_IUnknown(state);
 995     switch (command->op)
 996     {
 997         case ASYNC_START:
 998             hr = media_sink_start(media_sink);
 999             break;
1000         case ASYNC_STOP:
1001             hr = media_sink_stop(media_sink);
1002             break;
1003         case ASYNC_PAUSE:
1004             hr = media_sink_pause(media_sink);
1005             break;
1006         default:
1007             WARN("Unsupported op %u.\n", command->op);
1008             break;
1009     }
1010
1011     LeaveCriticalSection(&media_sink->cs);
1012
1013     return hr;
1014 }
1015
1016 static const IMFAsyncCallbackVtbl media_sink_callback_vtbl =
1017 {
1018     media_sink_callback_QueryInterface,
1019     media_sink_callback_AddRef,
1020     media_sink_callback_Release,
1021     media_sink_callback_GetParameters,
1022     media_sink_callback_Invoke,
1023 };
1024
1025 static HRESULT media_sink_create(IMFByteStream *bytestream, struct media_sink **out)
1026 {
1027     struct media_sink *media_sink;
1028     HRESULT hr;
1029
1030     TRACE("bytestream %p, out %p.\n", bytestream, out);
1031
1032     if (!bytestream)
1033         return E_POINTER;
1034
1035     if (!(media_sink = calloc(1, sizeof(*media_sink))))
1036         return E_OUTOFMEMORY;
1037
1038     if (FAILED(hr = MFCreateEventQueue(&media_sink->event_queue)))
1039     {
1040         free(media_sink);
1041         return hr;
1042     }
1043
1044     media_sink->IMFFinalizableMediaSink_iface.lpVtbl = &media_sink_vtbl;
1045     media_sink->IMFMediaEventGenerator_iface.lpVtbl = &media_sink_event_vtbl;
1046     media_sink->IMFClockStateSink_iface.lpVtbl = &media_sink_clock_sink_vtbl;
1047     media_sink->async_callback.lpVtbl = &media_sink_callback_vtbl;
1048     media_sink->refcount = 1;
1049     media_sink->state = STATE_OPENED;
1050     InitializeCriticalSection(&media_sink->cs);
1051     media_sink->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": cs");
1052     IMFByteStream_AddRef((media_sink->bytestream = bytestream));
1053     list_init(&media_sink->stream_sinks);
1054
1055     *out = media_sink;
1056     TRACE("Created media sink %p.\n", media_sink);
1057
1058     return S_OK;
1059 }
1060
1061 static HRESULT WINAPI sink_class_factory_QueryInterface(IMFSinkClassFactory *iface, REFIID riid, void **out)
1062 {
1063     if (IsEqualIID(riid, &IID_IMFSinkClassFactory)
1064             || IsEqualIID(riid, &IID_IUnknown))
1065     {
1066         *out = iface;
1067         IMFSinkClassFactory_AddRef(iface);
1068         return S_OK;
1069     }
1070
1071     *out = NULL;
1072     return E_NOINTERFACE;
1073 }
1074
1075 static ULONG WINAPI sink_class_factory_AddRef(IMFSinkClassFactory *iface)
1076 {
1077     return 2;
1078 }
1079
1080 static ULONG WINAPI sink_class_factory_Release(IMFSinkClassFactory *iface)
1081 {
1082     return 1;
1083 }
1084
1085 static HRESULT WINAPI sink_class_factory_CreateMediaSink(IMFSinkClassFactory *iface, IMFByteStream *bytestream,
1086         IMFMediaType *video_type, IMFMediaType *audio_type, IMFMediaSink **out)
1087 {
1088     IMFFinalizableMediaSink *media_sink_iface;
1089     struct media_sink *media_sink;
1090     HRESULT hr;
1091
1092     TRACE("iface %p, bytestream %p, video_type %p, audio_type %p, out %p.\n",
1093             iface, bytestream, video_type, audio_type, out);
1094
1095     if (FAILED(hr = media_sink_create(bytestream, &media_sink)))
1096         return hr;
1097     media_sink_iface = &media_sink->IMFFinalizableMediaSink_iface;
1098
1099     if (video_type)
1100     {
1101         if (FAILED(hr = IMFFinalizableMediaSink_AddStreamSink(media_sink_iface, 1, video_type, NULL)))
1102         {
1103             IMFFinalizableMediaSink_Shutdown(media_sink_iface);
1104             IMFFinalizableMediaSink_Release(media_sink_iface);
1105             return hr;
1106         }
1107     }
1108     if (audio_type)
1109     {
1110         if (FAILED(hr = IMFFinalizableMediaSink_AddStreamSink(media_sink_iface, 2, audio_type, NULL)))
1111         {
1112             IMFFinalizableMediaSink_Shutdown(media_sink_iface);
1113             IMFFinalizableMediaSink_Release(media_sink_iface);
1114             return hr;
1115         }
1116     }
1117
1118     *out = (IMFMediaSink *)media_sink_iface;
1119     return S_OK;
1120 }
1121
1122 static const IMFSinkClassFactoryVtbl sink_class_factory_vtbl =
1123 {
1124     sink_class_factory_QueryInterface,
1125     sink_class_factory_AddRef,
1126     sink_class_factory_Release,
1127     sink_class_factory_CreateMediaSink,
1128 };
1129
1130 static IMFSinkClassFactory sink_class_factory = { &sink_class_factory_vtbl };
1131
1132 HRESULT sink_class_factory_create(IUnknown *outer, IUnknown **out)
1133 {
1134     *out = (IUnknown *)&sink_class_factory;
1135     return S_OK;
1136 }