dlls/winegstreamer/media_source.c

   1 /* GStreamer Media Source
   2  *
   3  * Copyright 2020 Derek Lesho
   4  * Copyright 2020 Zebediah Figura for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "gst_private.h"
  22
  23 #include "mfapi.h"
  24 #include "mferror.h"
  25
  26 #include "wine/list.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  29
  30 struct media_stream
  31 {
  32     IMFMediaStream IMFMediaStream_iface;
  33     LONG ref;
  34     struct media_source *parent_source;
  35     IMFMediaEventQueue *event_queue;
  36     IMFStreamDescriptor *descriptor;
  37
  38     struct wg_parser_stream *wg_stream;
  39
  40     enum
  41     {
  42         STREAM_INACTIVE,
  43         STREAM_SHUTDOWN,
  44         STREAM_RUNNING,
  45     } state;
  46     DWORD stream_id;
  47     BOOL eos;
  48 };
  49
  50 enum source_async_op
  51 {
  52     SOURCE_ASYNC_START,
  53     SOURCE_ASYNC_STOP,
  54     SOURCE_ASYNC_REQUEST_SAMPLE,
  55 };
  56
  57 struct source_async_command
  58 {
  59     IUnknown IUnknown_iface;
  60     LONG refcount;
  61     enum source_async_op op;
  62     union
  63     {
  64         struct
  65         {
  66             IMFPresentationDescriptor *descriptor;
  67             GUID format;
  68             PROPVARIANT position;
  69         } start;
  70         struct
  71         {
  72             struct media_stream *stream;
  73             IUnknown *token;
  74         } request_sample;
  75     } u;
  76 };
  77
  78 struct media_source
  79 {
  80     IMFMediaSource IMFMediaSource_iface;
  81     IMFGetService IMFGetService_iface;
  82     IMFRateSupport IMFRateSupport_iface;
  83     IMFRateControl IMFRateControl_iface;
  84     IMFAsyncCallback async_commands_callback;
  85     LONG ref;
  86     DWORD async_commands_queue;
  87     IMFMediaEventQueue *event_queue;
  88     IMFByteStream *byte_stream;
  89
  90     struct wg_parser *wg_parser;
  91
  92     struct media_stream **streams;
  93     ULONG stream_count;
  94     IMFPresentationDescriptor *pres_desc;
  95     enum
  96     {
  97         SOURCE_OPENING,
  98         SOURCE_STOPPED,
  99         SOURCE_RUNNING,
 100         SOURCE_SHUTDOWN,
 101     } state;
 102
 103     LONGLONG start_time;
 104
 105     HANDLE read_thread;
 106     bool read_thread_shutdown;
 107 };
 108
 109 static inline struct media_stream *impl_from_IMFMediaStream(IMFMediaStream *iface)
 110 {
 111     return CONTAINING_RECORD(iface, struct media_stream, IMFMediaStream_iface);
 112 }
 113
 114 static inline struct media_source *impl_from_IMFMediaSource(IMFMediaSource *iface)
 115 {
 116     return CONTAINING_RECORD(iface, struct media_source, IMFMediaSource_iface);
 117 }
 118
 119 static inline struct media_source *impl_from_IMFGetService(IMFGetService *iface)
 120 {
 121     return CONTAINING_RECORD(iface, struct media_source, IMFGetService_iface);
 122 }
 123
 124 static inline struct media_source *impl_from_IMFRateSupport(IMFRateSupport *iface)
 125 {
 126     return CONTAINING_RECORD(iface, struct media_source, IMFRateSupport_iface);
 127 }
 128
 129 static inline struct media_source *impl_from_IMFRateControl(IMFRateControl *iface)
 130 {
 131     return CONTAINING_RECORD(iface, struct media_source, IMFRateControl_iface);
 132 }
 133
 134 static inline struct media_source *impl_from_async_commands_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 135 {
 136     return CONTAINING_RECORD(iface, struct media_source, async_commands_callback);
 137 }
 138
 139 static inline struct source_async_command *impl_from_async_command_IUnknown(IUnknown *iface)
 140 {
 141     return CONTAINING_RECORD(iface, struct source_async_command, IUnknown_iface);
 142 }
 143
 144 static HRESULT WINAPI source_async_command_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 145 {
 146     if (IsEqualIID(riid, &IID_IUnknown))
 147     {
 148         *obj = iface;
 149         IUnknown_AddRef(iface);
 150         return S_OK;
 151     }
 152
 153     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 154     *obj = NULL;
 155     return E_NOINTERFACE;
 156 }
 157
 158 static ULONG WINAPI source_async_command_AddRef(IUnknown *iface)
 159 {
 160     struct source_async_command *command = impl_from_async_command_IUnknown(iface);
 161     return InterlockedIncrement(&command->refcount);
 162 }
 163
 164 static ULONG WINAPI source_async_command_Release(IUnknown *iface)
 165 {
 166     struct source_async_command *command = impl_from_async_command_IUnknown(iface);
 167     ULONG refcount = InterlockedDecrement(&command->refcount);
 168
 169     if (!refcount)
 170     {
 171         if (command->op == SOURCE_ASYNC_START)
 172             PropVariantClear(&command->u.start.position);
 173         else if (command->op == SOURCE_ASYNC_REQUEST_SAMPLE)
 174         {
 175             if (command->u.request_sample.token)
 176                 IUnknown_Release(command->u.request_sample.token);
 177         }
 178         free(command);
 179     }
 180
 181     return refcount;
 182 }
 183
 184 static const IUnknownVtbl source_async_command_vtbl =
 185 {
 186     source_async_command_QueryInterface,
 187     source_async_command_AddRef,
 188     source_async_command_Release,
 189 };
 190
 191 static HRESULT source_create_async_op(enum source_async_op op, struct source_async_command **ret)
 192 {
 193     struct source_async_command *command;
 194
 195     if (!(command = calloc(1, sizeof(*command))))
 196         return E_OUTOFMEMORY;
 197
 198     command->IUnknown_iface.lpVtbl = &source_async_command_vtbl;
 199     command->op = op;
 200
 201     *ret = command;
 202
 203     return S_OK;
 204 }
 205
 206 static HRESULT WINAPI callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
 207 {
 208     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 209
 210     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 211             IsEqualIID(riid, &IID_IUnknown))
 212     {
 213         *obj = iface;
 214         IMFAsyncCallback_AddRef(iface);
 215         return S_OK;
 216     }
 217
 218     WARN("Unsupported %s.\n", debugstr_guid(riid));
 219     *obj = NULL;
 220     return E_NOINTERFACE;
 221 }
 222
 223 static HRESULT WINAPI callback_GetParameters(IMFAsyncCallback *iface,
 224         DWORD *flags, DWORD *queue)
 225 {
 226     return E_NOTIMPL;
 227 }
 228
 229 static ULONG WINAPI source_async_commands_callback_AddRef(IMFAsyncCallback *iface)
 230 {
 231     struct media_source *source = impl_from_async_commands_callback_IMFAsyncCallback(iface);
 232     return IMFMediaSource_AddRef(&source->IMFMediaSource_iface);
 233 }
 234
 235 static ULONG WINAPI source_async_commands_callback_Release(IMFAsyncCallback *iface)
 236 {
 237     struct media_source *source = impl_from_async_commands_callback_IMFAsyncCallback(iface);
 238     return IMFMediaSource_Release(&source->IMFMediaSource_iface);
 239 }
 240
 241 static IMFStreamDescriptor *stream_descriptor_from_id(IMFPresentationDescriptor *pres_desc, DWORD id, BOOL *selected)
 242 {
 243     ULONG sd_count;
 244     IMFStreamDescriptor *ret;
 245     unsigned int i;
 246
 247     if (FAILED(IMFPresentationDescriptor_GetStreamDescriptorCount(pres_desc, &sd_count)))
 248         return NULL;
 249
 250     for (i = 0; i < sd_count; i++)
 251     {
 252         DWORD stream_id;
 253
 254         if (FAILED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(pres_desc, i, selected, &ret)))
 255             return NULL;
 256
 257         if (SUCCEEDED(IMFStreamDescriptor_GetStreamIdentifier(ret, &stream_id)) && stream_id == id)
 258             return ret;
 259
 260         IMFStreamDescriptor_Release(ret);
 261     }
 262     return NULL;
 263 }
 264
 265 static void start_pipeline(struct media_source *source, struct source_async_command *command)
 266 {
 267     PROPVARIANT *position = &command->u.start.position;
 268     BOOL seek_message = source->state != SOURCE_STOPPED && position->vt != VT_EMPTY;
 269     unsigned int i;
 270
 271     /* seek to beginning on stop->play */
 272     if (source->state == SOURCE_STOPPED && position->vt == VT_EMPTY)
 273     {
 274         position->vt = VT_I8;
 275         position->hVal.QuadPart = 0;
 276     }
 277     source->start_time = position->hVal.QuadPart;
 278
 279     for (i = 0; i < source->stream_count; i++)
 280     {
 281         struct media_stream *stream;
 282         IMFStreamDescriptor *sd;
 283         IMFMediaTypeHandler *mth;
 284         IMFMediaType *current_mt;
 285         DWORD stream_id;
 286         BOOL was_active;
 287         BOOL selected;
 288
 289         stream = source->streams[i];
 290
 291         IMFStreamDescriptor_GetStreamIdentifier(stream->descriptor, &stream_id);
 292
 293         sd = stream_descriptor_from_id(command->u.start.descriptor, stream_id, &selected);
 294         IMFStreamDescriptor_Release(sd);
 295
 296         was_active = stream->state != STREAM_INACTIVE;
 297
 298         stream->state = selected ? STREAM_RUNNING : STREAM_INACTIVE;
 299
 300         if (selected)
 301         {
 302             struct wg_format format;
 303
 304             IMFStreamDescriptor_GetMediaTypeHandler(stream->descriptor, &mth);
 305             IMFMediaTypeHandler_GetCurrentMediaType(mth, &current_mt);
 306
 307             mf_media_type_to_wg_format(current_mt, &format);
 308             unix_funcs->wg_parser_stream_enable(stream->wg_stream, &format);
 309
 310             IMFMediaType_Release(current_mt);
 311             IMFMediaTypeHandler_Release(mth);
 312         }
 313
 314         if (position->vt != VT_EMPTY)
 315             stream->eos = FALSE;
 316
 317         if (selected)
 318         {
 319             TRACE("Stream %u (%p) selected\n", i, stream);
 320             IMFMediaEventQueue_QueueEventParamUnk(source->event_queue,
 321                 was_active ? MEUpdatedStream : MENewStream, &GUID_NULL,
 322                 S_OK, (IUnknown*) &stream->IMFMediaStream_iface);
 323
 324             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue,
 325                 seek_message ? MEStreamSeeked : MEStreamStarted, &GUID_NULL, S_OK, position);
 326         }
 327     }
 328
 329     IMFMediaEventQueue_QueueEventParamVar(source->event_queue,
 330         seek_message ? MESourceSeeked : MESourceStarted,
 331         &GUID_NULL, S_OK, position);
 332
 333     source->state = SOURCE_RUNNING;
 334
 335     unix_funcs->wg_parser_stream_seek(source->streams[0]->wg_stream, 1.0,
 336             position->hVal.QuadPart, 0, AM_SEEKING_AbsolutePositioning, AM_SEEKING_NoPositioning);
 337     unix_funcs->wg_parser_end_flush(source->wg_parser);
 338 }
 339
 340 static void stop_pipeline(struct media_source *source)
 341 {
 342     unsigned int i;
 343
 344     unix_funcs->wg_parser_begin_flush(source->wg_parser);
 345
 346     for (i = 0; i < source->stream_count; i++)
 347     {
 348         struct media_stream *stream = source->streams[i];
 349         if (stream->state != STREAM_INACTIVE)
 350         {
 351             IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamStopped, &GUID_NULL, S_OK, NULL);
 352             unix_funcs->wg_parser_stream_disable(stream->wg_stream);
 353         }
 354     }
 355
 356     IMFMediaEventQueue_QueueEventParamVar(source->event_queue, MESourceStopped, &GUID_NULL, S_OK, NULL);
 357
 358     source->state = SOURCE_STOPPED;
 359 }
 360
 361 static void dispatch_end_of_presentation(struct media_source *source)
 362 {
 363     PROPVARIANT empty = {.vt = VT_EMPTY};
 364     unsigned int i;
 365
 366     /* A stream has ended, check whether all have */
 367     for (i = 0; i < source->stream_count; i++)
 368     {
 369         struct media_stream *stream = source->streams[i];
 370
 371         if (stream->state != STREAM_INACTIVE && !stream->eos)
 372             return;
 373     }
 374
 375     IMFMediaEventQueue_QueueEventParamVar(source->event_queue, MEEndOfPresentation, &GUID_NULL, S_OK, &empty);
 376 }
 377
 378 static void send_buffer(struct media_stream *stream, const struct wg_parser_event *event, IUnknown *token)
 379 {
 380     IMFMediaBuffer *buffer;
 381     IMFSample *sample;
 382     HRESULT hr;
 383     BYTE *data;
 384
 385     if (FAILED(hr = MFCreateSample(&sample)))
 386     {
 387         ERR("Failed to create sample, hr %#x.\n", hr);
 388         return;
 389     }
 390
 391     if (FAILED(hr = MFCreateMemoryBuffer(event->u.buffer.size, &buffer)))
 392     {
 393         ERR("Failed to create buffer, hr %#x.\n", hr);
 394         IMFSample_Release(sample);
 395         return;
 396     }
 397
 398     if (FAILED(hr = IMFSample_AddBuffer(sample, buffer)))
 399     {
 400         ERR("Failed to add buffer, hr %#x.\n", hr);
 401         goto out;
 402     }
 403
 404     if (FAILED(hr = IMFMediaBuffer_SetCurrentLength(buffer, event->u.buffer.size)))
 405     {
 406         ERR("Failed to set size, hr %#x.\n", hr);
 407         goto out;
 408     }
 409
 410     if (FAILED(hr = IMFMediaBuffer_Lock(buffer, &data, NULL, NULL)))
 411     {
 412         ERR("Failed to lock buffer, hr %#x.\n", hr);
 413         goto out;
 414     }
 415
 416     if (!unix_funcs->wg_parser_stream_copy_buffer(stream->wg_stream, data, 0, event->u.buffer.size))
 417     {
 418         unix_funcs->wg_parser_stream_release_buffer(stream->wg_stream);
 419         IMFMediaBuffer_Unlock(buffer);
 420         goto out;
 421     }
 422     unix_funcs->wg_parser_stream_release_buffer(stream->wg_stream);
 423
 424     if (FAILED(hr = IMFMediaBuffer_Unlock(buffer)))
 425     {
 426         ERR("Failed to unlock buffer, hr %#x.\n", hr);
 427         goto out;
 428     }
 429
 430     if (FAILED(hr = IMFSample_SetSampleTime(sample, event->u.buffer.pts - stream->parent_source->start_time)))
 431     {
 432         ERR("Failed to set sample time, hr %#x.\n", hr);
 433         goto out;
 434     }
 435
 436     if (FAILED(hr = IMFSample_SetSampleDuration(sample, event->u.buffer.duration)))
 437     {
 438         ERR("Failed to set sample duration, hr %#x.\n", hr);
 439         goto out;
 440     }
 441
 442     if (token)
 443         IMFSample_SetUnknown(sample, &MFSampleExtension_Token, token);
 444
 445     IMFMediaEventQueue_QueueEventParamUnk(stream->event_queue, MEMediaSample,
 446             &GUID_NULL, S_OK, (IUnknown *)sample);
 447
 448 out:
 449     IMFMediaBuffer_Release(buffer);
 450     IMFSample_Release(sample);
 451 }
 452
 453 static void wait_on_sample(struct media_stream *stream, IUnknown *token)
 454 {
 455     PROPVARIANT empty_var = {.vt = VT_EMPTY};
 456     struct wg_parser_event event;
 457
 458     TRACE("%p, %p\n", stream, token);
 459
 460     for (;;)
 461     {
 462         if (!unix_funcs->wg_parser_stream_get_event(stream->wg_stream, &event))
 463             return;
 464
 465         TRACE("Got event of type %#x.\n", event.type);
 466
 467         switch (event.type)
 468         {
 469             case WG_PARSER_EVENT_BUFFER:
 470                 send_buffer(stream, &event, token);
 471                 return;
 472
 473             case WG_PARSER_EVENT_EOS:
 474                 stream->eos = TRUE;
 475                 IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEEndOfStream, &GUID_NULL, S_OK, &empty_var);
 476                 dispatch_end_of_presentation(stream->parent_source);
 477                 return;
 478
 479             case WG_PARSER_EVENT_SEGMENT:
 480                 break;
 481
 482             case WG_PARSER_EVENT_NONE:
 483                 assert(0);
 484         }
 485     }
 486 }
 487
 488 static HRESULT WINAPI source_async_commands_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 489 {
 490     struct media_source *source = impl_from_async_commands_callback_IMFAsyncCallback(iface);
 491     struct source_async_command *command;
 492     IUnknown *state;
 493     HRESULT hr;
 494
 495     if (source->state == SOURCE_SHUTDOWN)
 496         return S_OK;
 497
 498     if (FAILED(hr = IMFAsyncResult_GetState(result, &state)))
 499         return hr;
 500
 501     command = impl_from_async_command_IUnknown(state);
 502     switch (command->op)
 503     {
 504         case SOURCE_ASYNC_START:
 505             start_pipeline(source, command);
 506             break;
 507         case SOURCE_ASYNC_STOP:
 508             stop_pipeline(source);
 509             break;
 510         case SOURCE_ASYNC_REQUEST_SAMPLE:
 511             wait_on_sample(command->u.request_sample.stream, command->u.request_sample.token);
 512             break;
 513     }
 514
 515     IUnknown_Release(state);
 516
 517     return S_OK;
 518 }
 519
 520 static const IMFAsyncCallbackVtbl source_async_commands_callback_vtbl =
 521 {
 522     callback_QueryInterface,
 523     source_async_commands_callback_AddRef,
 524     source_async_commands_callback_Release,
 525     callback_GetParameters,
 526     source_async_commands_Invoke,
 527 };
 528
 529 static DWORD CALLBACK read_thread(void *arg)
 530 {
 531     struct media_source *source = arg;
 532     IMFByteStream *byte_stream = source->byte_stream;
 533
 534     TRACE("Starting read thread for media source %p.\n", source);
 535
 536     while (!source->read_thread_shutdown)
 537     {
 538         uint64_t offset;
 539         ULONG ret_size;
 540         uint32_t size;
 541         HRESULT hr;
 542         void *data;
 543
 544         if (!unix_funcs->wg_parser_get_read_request(source->wg_parser, &data, &offset, &size))
 545             continue;
 546
 547         if (SUCCEEDED(hr = IMFByteStream_SetCurrentPosition(byte_stream, offset)))
 548             hr = IMFByteStream_Read(byte_stream, data, size, &ret_size);
 549         if (SUCCEEDED(hr) && ret_size != size)
 550             ERR("Unexpected short read: requested %u bytes, got %u.\n", size, ret_size);
 551         unix_funcs->wg_parser_complete_read_request(source->wg_parser, SUCCEEDED(hr));
 552     }
 553
 554     TRACE("Media source is shutting down; exiting.\n");
 555     return 0;
 556 }
 557
 558 static HRESULT WINAPI media_stream_QueryInterface(IMFMediaStream *iface, REFIID riid, void **out)
 559 {
 560     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 561
 562     TRACE("(%p)->(%s %p)\n", stream, debugstr_guid(riid), out);
 563
 564     if (IsEqualIID(riid, &IID_IMFMediaStream) ||
 565         IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
 566         IsEqualIID(riid, &IID_IUnknown))
 567     {
 568         *out = &stream->IMFMediaStream_iface;
 569     }
 570     else
 571     {
 572         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
 573         *out = NULL;
 574         return E_NOINTERFACE;
 575     }
 576
 577     IUnknown_AddRef((IUnknown*)*out);
 578     return S_OK;
 579 }
 580
 581 static ULONG WINAPI media_stream_AddRef(IMFMediaStream *iface)
 582 {
 583     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 584     ULONG ref = InterlockedIncrement(&stream->ref);
 585
 586     TRACE("(%p) ref=%u\n", stream, ref);
 587
 588     return ref;
 589 }
 590
 591 static ULONG WINAPI media_stream_Release(IMFMediaStream *iface)
 592 {
 593     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 594
 595     ULONG ref = InterlockedDecrement(&stream->ref);
 596
 597     TRACE("(%p) ref=%u\n", stream, ref);
 598
 599     if (!ref)
 600     {
 601         if (stream->event_queue)
 602             IMFMediaEventQueue_Release(stream->event_queue);
 603         free(stream);
 604     }
 605
 606     return ref;
 607 }
 608
 609 static HRESULT WINAPI media_stream_GetEvent(IMFMediaStream *iface, DWORD flags, IMFMediaEvent **event)
 610 {
 611     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 612
 613     TRACE("(%p)->(%#x, %p)\n", stream, flags, event);
 614
 615     return IMFMediaEventQueue_GetEvent(stream->event_queue, flags, event);
 616 }
 617
 618 static HRESULT WINAPI media_stream_BeginGetEvent(IMFMediaStream *iface, IMFAsyncCallback *callback, IUnknown *state)
 619 {
 620     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 621
 622     TRACE("(%p)->(%p, %p)\n", stream, callback, state);
 623
 624     return IMFMediaEventQueue_BeginGetEvent(stream->event_queue, callback, state);
 625 }
 626
 627 static HRESULT WINAPI media_stream_EndGetEvent(IMFMediaStream *iface, IMFAsyncResult *result, IMFMediaEvent **event)
 628 {
 629     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 630
 631     TRACE("(%p)->(%p, %p)\n", stream, result, event);
 632
 633     return IMFMediaEventQueue_EndGetEvent(stream->event_queue, result, event);
 634 }
 635
 636 static HRESULT WINAPI media_stream_QueueEvent(IMFMediaStream *iface, MediaEventType event_type, REFGUID ext_type,
 637         HRESULT hr, const PROPVARIANT *value)
 638 {
 639     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 640
 641     TRACE("(%p)->(%d, %s, %#x, %p)\n", stream, event_type, debugstr_guid(ext_type), hr, value);
 642
 643     return IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, event_type, ext_type, hr, value);
 644 }
 645
 646 static HRESULT WINAPI media_stream_GetMediaSource(IMFMediaStream *iface, IMFMediaSource **source)
 647 {
 648     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 649
 650     TRACE("(%p)->(%p)\n", stream, source);
 651
 652     if (stream->state == STREAM_SHUTDOWN)
 653         return MF_E_SHUTDOWN;
 654
 655     IMFMediaSource_AddRef(&stream->parent_source->IMFMediaSource_iface);
 656     *source = &stream->parent_source->IMFMediaSource_iface;
 657
 658     return S_OK;
 659 }
 660
 661 static HRESULT WINAPI media_stream_GetStreamDescriptor(IMFMediaStream* iface, IMFStreamDescriptor **descriptor)
 662 {
 663     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 664
 665     TRACE("(%p)->(%p)\n", stream, descriptor);
 666
 667     if (stream->state == STREAM_SHUTDOWN)
 668         return MF_E_SHUTDOWN;
 669
 670     IMFStreamDescriptor_AddRef(stream->descriptor);
 671     *descriptor = stream->descriptor;
 672
 673     return S_OK;
 674 }
 675
 676 static HRESULT WINAPI media_stream_RequestSample(IMFMediaStream *iface, IUnknown *token)
 677 {
 678     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 679     struct source_async_command *command;
 680     HRESULT hr;
 681
 682     TRACE("(%p)->(%p)\n", iface, token);
 683
 684     if (stream->state == STREAM_SHUTDOWN)
 685         return MF_E_SHUTDOWN;
 686
 687     if (stream->state == STREAM_INACTIVE)
 688     {
 689         WARN("Stream isn't active\n");
 690         return MF_E_MEDIA_SOURCE_WRONGSTATE;
 691     }
 692
 693     if (stream->eos)
 694     {
 695         return MF_E_END_OF_STREAM;
 696     }
 697
 698     if (SUCCEEDED(hr = source_create_async_op(SOURCE_ASYNC_REQUEST_SAMPLE, &command)))
 699     {
 700         command->u.request_sample.stream = stream;
 701         if (token)
 702             IUnknown_AddRef(token);
 703         command->u.request_sample.token = token;
 704
 705         /* Once pause support is added, this will need to put into a stream queue, and synchronization will need to be added*/
 706         hr = MFPutWorkItem(stream->parent_source->async_commands_queue, &stream->parent_source->async_commands_callback, &command->IUnknown_iface);
 707     }
 708
 709     return hr;
 710 }
 711
 712 static const IMFMediaStreamVtbl media_stream_vtbl =
 713 {
 714     media_stream_QueryInterface,
 715     media_stream_AddRef,
 716     media_stream_Release,
 717     media_stream_GetEvent,
 718     media_stream_BeginGetEvent,
 719     media_stream_EndGetEvent,
 720     media_stream_QueueEvent,
 721     media_stream_GetMediaSource,
 722     media_stream_GetStreamDescriptor,
 723     media_stream_RequestSample
 724 };
 725
 726 static HRESULT new_media_stream(struct media_source *source,
 727         struct wg_parser_stream *wg_stream, DWORD stream_id, struct media_stream **out_stream)
 728 {
 729     struct media_stream *object = calloc(1, sizeof(*object));
 730     HRESULT hr;
 731
 732     TRACE("source %p, wg_stream %p, stream_id %u.\n", source, wg_stream, stream_id);
 733
 734     object->IMFMediaStream_iface.lpVtbl = &media_stream_vtbl;
 735     object->ref = 1;
 736
 737     IMFMediaSource_AddRef(&source->IMFMediaSource_iface);
 738     object->parent_source = source;
 739     object->stream_id = stream_id;
 740
 741     object->state = STREAM_INACTIVE;
 742     object->eos = FALSE;
 743     object->wg_stream = wg_stream;
 744
 745     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
 746         goto fail;
 747
 748     TRACE("->(%p)\n", object);
 749     *out_stream = object;
 750
 751     return S_OK;
 752
 753 fail:
 754     WARN("Failed to construct media stream, hr %#x.\n", hr);
 755
 756     IMFMediaStream_Release(&object->IMFMediaStream_iface);
 757     return hr;
 758 }
 759
 760 static HRESULT media_stream_init_desc(struct media_stream *stream)
 761 {
 762     IMFMediaTypeHandler *type_handler = NULL;
 763     IMFMediaType *stream_types[6];
 764     struct wg_format format;
 765     DWORD type_count = 0;
 766     unsigned int i;
 767     HRESULT hr;
 768
 769     unix_funcs->wg_parser_stream_get_preferred_format(stream->wg_stream, &format);
 770
 771     if (format.major_type == WG_MAJOR_TYPE_VIDEO)
 772     {
 773         /* These are the most common native output types of decoders:
 774             https://docs.microsoft.com/en-us/windows/win32/medfound/mft-decoder-expose-output-types-in-native-order */
 775         static const GUID *const video_types[] =
 776         {
 777             &MFVideoFormat_NV12,
 778             &MFVideoFormat_YV12,
 779             &MFVideoFormat_YUY2,
 780             &MFVideoFormat_IYUV,
 781             &MFVideoFormat_I420,
 782         };
 783
 784         IMFMediaType *base_type = mf_media_type_from_wg_format(&format);
 785         GUID base_subtype;
 786
 787         IMFMediaType_GetGUID(base_type, &MF_MT_SUBTYPE, &base_subtype);
 788
 789         stream_types[0] = base_type;
 790         type_count = 1;
 791
 792         for (i = 0; i < ARRAY_SIZE(video_types); i++)
 793         {
 794             IMFMediaType *new_type;
 795
 796             if (IsEqualGUID(&base_subtype, video_types[i]))
 797                 continue;
 798
 799             if (FAILED(hr = MFCreateMediaType(&new_type)))
 800                 goto done;
 801             stream_types[type_count++] = new_type;
 802
 803             if (FAILED(hr = IMFMediaType_CopyAllItems(base_type, (IMFAttributes *) new_type)))
 804                 goto done;
 805             if (FAILED(hr = IMFMediaType_SetGUID(new_type, &MF_MT_SUBTYPE, video_types[i])))
 806                 goto done;
 807         }
 808     }
 809     else if (format.major_type == WG_MAJOR_TYPE_AUDIO)
 810     {
 811         /* Expose at least one PCM and one floating point type for the
 812            consumer to pick from. */
 813         static const enum wg_audio_format audio_types[] =
 814         {
 815             WG_AUDIO_FORMAT_S16LE,
 816             WG_AUDIO_FORMAT_F32LE,
 817         };
 818
 819         stream_types[0] = mf_media_type_from_wg_format(&format);
 820         type_count = 1;
 821
 822         for (i = 0; i < ARRAY_SIZE(audio_types); i++)
 823         {
 824             struct wg_format new_format;
 825             if (format.u.audio.format == audio_types[i])
 826                 continue;
 827             new_format = format;
 828             new_format.u.audio.format = audio_types[i];
 829             stream_types[type_count++] = mf_media_type_from_wg_format(&new_format);
 830         }
 831     }
 832     else
 833     {
 834         if ((stream_types[0] = mf_media_type_from_wg_format(&format)))
 835             type_count = 1;
 836     }
 837
 838     assert(type_count <= ARRAY_SIZE(stream_types));
 839
 840     if (!type_count)
 841     {
 842         ERR("Failed to establish an IMFMediaType from any of the possible stream caps!\n");
 843         return E_FAIL;
 844     }
 845
 846     if (FAILED(hr = MFCreateStreamDescriptor(stream->stream_id, type_count, stream_types, &stream->descriptor)))
 847         goto done;
 848
 849     if (FAILED(hr = IMFStreamDescriptor_GetMediaTypeHandler(stream->descriptor, &type_handler)))
 850         goto done;
 851
 852     if (FAILED(hr = IMFMediaTypeHandler_SetCurrentMediaType(type_handler, stream_types[0])))
 853         goto done;
 854
 855 done:
 856     if (type_handler)
 857         IMFMediaTypeHandler_Release(type_handler);
 858     for (i = 0; i < type_count; i++)
 859         IMFMediaType_Release(stream_types[i]);
 860     return hr;
 861 }
 862
 863 static HRESULT WINAPI media_source_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
 864 {
 865     struct media_source *source = impl_from_IMFGetService(iface);
 866     return IMFMediaSource_QueryInterface(&source->IMFMediaSource_iface, riid, obj);
 867 }
 868
 869 static ULONG WINAPI media_source_get_service_AddRef(IMFGetService *iface)
 870 {
 871     struct media_source *source = impl_from_IMFGetService(iface);
 872     return IMFMediaSource_AddRef(&source->IMFMediaSource_iface);
 873 }
 874
 875 static ULONG WINAPI media_source_get_service_Release(IMFGetService *iface)
 876 {
 877     struct media_source *source = impl_from_IMFGetService(iface);
 878     return IMFMediaSource_Release(&source->IMFMediaSource_iface);
 879 }
 880
 881 static HRESULT WINAPI media_source_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 882 {
 883     struct media_source *source = impl_from_IMFGetService(iface);
 884
 885     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 886
 887     *obj = NULL;
 888
 889     if (IsEqualGUID(service, &MF_RATE_CONTROL_SERVICE))
 890     {
 891         if (IsEqualIID(riid, &IID_IMFRateSupport))
 892         {
 893             *obj = &source->IMFRateSupport_iface;
 894         }
 895         else if (IsEqualIID(riid, &IID_IMFRateControl))
 896         {
 897             *obj = &source->IMFRateControl_iface;
 898         }
 899     }
 900     else
 901         FIXME("Unsupported service %s.\n", debugstr_guid(service));
 902
 903     if (*obj)
 904         IUnknown_AddRef((IUnknown *)*obj);
 905
 906     return *obj ? S_OK : E_NOINTERFACE;
 907 }
 908
 909 static const IMFGetServiceVtbl media_source_get_service_vtbl =
 910 {
 911     media_source_get_service_QueryInterface,
 912     media_source_get_service_AddRef,
 913     media_source_get_service_Release,
 914     media_source_get_service_GetService,
 915 };
 916
 917 static HRESULT WINAPI media_source_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **obj)
 918 {
 919     struct media_source *source = impl_from_IMFRateSupport(iface);
 920     return IMFMediaSource_QueryInterface(&source->IMFMediaSource_iface, riid, obj);
 921 }
 922
 923 static ULONG WINAPI media_source_rate_support_AddRef(IMFRateSupport *iface)
 924 {
 925     struct media_source *source = impl_from_IMFRateSupport(iface);
 926     return IMFMediaSource_AddRef(&source->IMFMediaSource_iface);
 927 }
 928
 929 static ULONG WINAPI media_source_rate_support_Release(IMFRateSupport *iface)
 930 {
 931     struct media_source *source = impl_from_IMFRateSupport(iface);
 932     return IMFMediaSource_Release(&source->IMFMediaSource_iface);
 933 }
 934
 935 static HRESULT WINAPI media_source_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction, BOOL thin, float *rate)
 936 {
 937     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
 938
 939     *rate = 0.0f;
 940
 941     return S_OK;
 942 }
 943
 944 static HRESULT WINAPI media_source_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction, BOOL thin, float *rate)
 945 {
 946     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
 947
 948     *rate = direction == MFRATE_FORWARD ? 1e6f : -1e6f;
 949
 950     return S_OK;
 951 }
 952
 953 static HRESULT WINAPI media_source_rate_support_IsRateSupported(IMFRateSupport *iface, BOOL thin, float rate,
 954         float *nearest_rate)
 955 {
 956     TRACE("%p, %d, %f, %p.\n", iface, thin, rate, nearest_rate);
 957
 958     if (nearest_rate)
 959         *nearest_rate = rate;
 960
 961     return rate >= -1e6f && rate <= 1e6f ? S_OK : MF_E_UNSUPPORTED_RATE;
 962 }
 963
 964 static const IMFRateSupportVtbl media_source_rate_support_vtbl =
 965 {
 966     media_source_rate_support_QueryInterface,
 967     media_source_rate_support_AddRef,
 968     media_source_rate_support_Release,
 969     media_source_rate_support_GetSlowestRate,
 970     media_source_rate_support_GetFastestRate,
 971     media_source_rate_support_IsRateSupported,
 972 };
 973
 974 static HRESULT WINAPI media_source_rate_control_QueryInterface(IMFRateControl *iface, REFIID riid, void **obj)
 975 {
 976     struct media_source *source = impl_from_IMFRateControl(iface);
 977     return IMFMediaSource_QueryInterface(&source->IMFMediaSource_iface, riid, obj);
 978 }
 979
 980 static ULONG WINAPI media_source_rate_control_AddRef(IMFRateControl *iface)
 981 {
 982     struct media_source *source = impl_from_IMFRateControl(iface);
 983     return IMFMediaSource_AddRef(&source->IMFMediaSource_iface);
 984 }
 985
 986 static ULONG WINAPI media_source_rate_control_Release(IMFRateControl *iface)
 987 {
 988     struct media_source *source = impl_from_IMFRateControl(iface);
 989     return IMFMediaSource_Release(&source->IMFMediaSource_iface);
 990 }
 991
 992 static HRESULT WINAPI media_source_rate_control_SetRate(IMFRateControl *iface, BOOL thin, float rate)
 993 {
 994     FIXME("%p, %d, %f.\n", iface, thin, rate);
 995
 996     if (rate < 0.0f)
 997         return MF_E_REVERSE_UNSUPPORTED;
 998
 999     if (thin)
1000         return MF_E_THINNING_UNSUPPORTED;
1001
1002     if (rate != 1.0f)
1003         return MF_E_UNSUPPORTED_RATE;
1004
1005     return S_OK;
1006 }
1007
1008 static HRESULT WINAPI media_source_rate_control_GetRate(IMFRateControl *iface, BOOL *thin, float *rate)
1009 {
1010     TRACE("%p, %p, %p.\n", iface, thin, rate);
1011
1012     if (thin)
1013         *thin = FALSE;
1014
1015     *rate = 1.0f;
1016
1017     return S_OK;
1018 }
1019
1020 static const IMFRateControlVtbl media_source_rate_control_vtbl =
1021 {
1022     media_source_rate_control_QueryInterface,
1023     media_source_rate_control_AddRef,
1024     media_source_rate_control_Release,
1025     media_source_rate_control_SetRate,
1026     media_source_rate_control_GetRate,
1027 };
1028
1029 static HRESULT WINAPI media_source_QueryInterface(IMFMediaSource *iface, REFIID riid, void **out)
1030 {
1031     struct media_source *source = impl_from_IMFMediaSource(iface);
1032
1033     TRACE("(%p)->(%s %p)\n", source, debugstr_guid(riid), out);
1034
1035     if (IsEqualIID(riid, &IID_IMFMediaSource) ||
1036         IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
1037         IsEqualIID(riid, &IID_IUnknown))
1038     {
1039         *out = &source->IMFMediaSource_iface;
1040     }
1041     else if (IsEqualIID(riid, &IID_IMFGetService))
1042     {
1043         *out = &source->IMFGetService_iface;
1044     }
1045     else
1046     {
1047         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
1048         *out = NULL;
1049         return E_NOINTERFACE;
1050     }
1051
1052     IUnknown_AddRef((IUnknown*)*out);
1053     return S_OK;
1054 }
1055
1056 static ULONG WINAPI media_source_AddRef(IMFMediaSource *iface)
1057 {
1058     struct media_source *source = impl_from_IMFMediaSource(iface);
1059     ULONG ref = InterlockedIncrement(&source->ref);
1060
1061     TRACE("(%p) ref=%u\n", source, ref);
1062
1063     return ref;
1064 }
1065
1066 static ULONG WINAPI media_source_Release(IMFMediaSource *iface)
1067 {
1068     struct media_source *source = impl_from_IMFMediaSource(iface);
1069     ULONG ref = InterlockedDecrement(&source->ref);
1070
1071     TRACE("(%p) ref=%u\n", source, ref);
1072
1073     if (!ref)
1074     {
1075         IMFMediaSource_Shutdown(&source->IMFMediaSource_iface);
1076         IMFMediaEventQueue_Release(source->event_queue);
1077         free(source);
1078     }
1079
1080     return ref;
1081 }
1082
1083 static HRESULT WINAPI media_source_GetEvent(IMFMediaSource *iface, DWORD flags, IMFMediaEvent **event)
1084 {
1085     struct media_source *source = impl_from_IMFMediaSource(iface);
1086
1087     TRACE("(%p)->(%#x, %p)\n", source, flags, event);
1088
1089     return IMFMediaEventQueue_GetEvent(source->event_queue, flags, event);
1090 }
1091
1092 static HRESULT WINAPI media_source_BeginGetEvent(IMFMediaSource *iface, IMFAsyncCallback *callback, IUnknown *state)
1093 {
1094     struct media_source *source = impl_from_IMFMediaSource(iface);
1095
1096     TRACE("(%p)->(%p, %p)\n", source, callback, state);
1097
1098     return IMFMediaEventQueue_BeginGetEvent(source->event_queue, callback, state);
1099 }
1100
1101 static HRESULT WINAPI media_source_EndGetEvent(IMFMediaSource *iface, IMFAsyncResult *result, IMFMediaEvent **event)
1102 {
1103     struct media_source *source = impl_from_IMFMediaSource(iface);
1104
1105     TRACE("(%p)->(%p, %p)\n", source, result, event);
1106
1107     return IMFMediaEventQueue_EndGetEvent(source->event_queue, result, event);
1108 }
1109
1110 static HRESULT WINAPI media_source_QueueEvent(IMFMediaSource *iface, MediaEventType event_type, REFGUID ext_type,
1111         HRESULT hr, const PROPVARIANT *value)
1112 {
1113     struct media_source *source = impl_from_IMFMediaSource(iface);
1114
1115     TRACE("(%p)->(%d, %s, %#x, %p)\n", source, event_type, debugstr_guid(ext_type), hr, value);
1116
1117     return IMFMediaEventQueue_QueueEventParamVar(source->event_queue, event_type, ext_type, hr, value);
1118 }
1119
1120 static HRESULT WINAPI media_source_GetCharacteristics(IMFMediaSource *iface, DWORD *characteristics)
1121 {
1122     struct media_source *source = impl_from_IMFMediaSource(iface);
1123
1124     TRACE("(%p)->(%p)\n", source, characteristics);
1125
1126     if (source->state == SOURCE_SHUTDOWN)
1127         return MF_E_SHUTDOWN;
1128
1129     *characteristics = MFMEDIASOURCE_CAN_SEEK;
1130
1131     return S_OK;
1132 }
1133
1134 static HRESULT WINAPI media_source_CreatePresentationDescriptor(IMFMediaSource *iface, IMFPresentationDescriptor **descriptor)
1135 {
1136     struct media_source *source = impl_from_IMFMediaSource(iface);
1137
1138     TRACE("(%p)->(%p)\n", source, descriptor);
1139
1140     if (source->state == SOURCE_SHUTDOWN)
1141         return MF_E_SHUTDOWN;
1142
1143     return IMFPresentationDescriptor_Clone(source->pres_desc, descriptor);
1144 }
1145
1146 static HRESULT WINAPI media_source_Start(IMFMediaSource *iface, IMFPresentationDescriptor *descriptor,
1147                                      const GUID *time_format, const PROPVARIANT *position)
1148 {
1149     struct media_source *source = impl_from_IMFMediaSource(iface);
1150     struct source_async_command *command;
1151     HRESULT hr;
1152
1153     TRACE("(%p)->(%p, %p, %p)\n", source, descriptor, time_format, position);
1154
1155     if (source->state == SOURCE_SHUTDOWN)
1156         return MF_E_SHUTDOWN;
1157
1158     if (!(IsEqualIID(time_format, &GUID_NULL)))
1159         return MF_E_UNSUPPORTED_TIME_FORMAT;
1160
1161     if (SUCCEEDED(hr = source_create_async_op(SOURCE_ASYNC_START, &command)))
1162     {
1163         command->u.start.descriptor = descriptor;
1164         command->u.start.format = *time_format;
1165         PropVariantCopy(&command->u.start.position, position);
1166
1167         hr = MFPutWorkItem(source->async_commands_queue, &source->async_commands_callback, &command->IUnknown_iface);
1168     }
1169
1170     return hr;
1171 }
1172
1173 static HRESULT WINAPI media_source_Stop(IMFMediaSource *iface)
1174 {
1175     struct media_source *source = impl_from_IMFMediaSource(iface);
1176     struct source_async_command *command;
1177     HRESULT hr;
1178
1179     TRACE("(%p)\n", source);
1180
1181     if (source->state == SOURCE_SHUTDOWN)
1182         return MF_E_SHUTDOWN;
1183
1184     if (SUCCEEDED(hr = source_create_async_op(SOURCE_ASYNC_STOP, &command)))
1185         hr = MFPutWorkItem(source->async_commands_queue, &source->async_commands_callback, &command->IUnknown_iface);
1186
1187     return hr;
1188 }
1189
1190 static HRESULT WINAPI media_source_Pause(IMFMediaSource *iface)
1191 {
1192     struct media_source *source = impl_from_IMFMediaSource(iface);
1193
1194     FIXME("(%p): stub\n", source);
1195
1196     if (source->state == SOURCE_SHUTDOWN)
1197         return MF_E_SHUTDOWN;
1198
1199     return E_NOTIMPL;
1200 }
1201
1202 static HRESULT WINAPI media_source_Shutdown(IMFMediaSource *iface)
1203 {
1204     struct media_source *source = impl_from_IMFMediaSource(iface);
1205     unsigned int i;
1206
1207     TRACE("(%p)\n", source);
1208
1209     if (source->state == SOURCE_SHUTDOWN)
1210         return MF_E_SHUTDOWN;
1211
1212     source->state = SOURCE_SHUTDOWN;
1213
1214     unix_funcs->wg_parser_disconnect(source->wg_parser);
1215
1216     if (source->read_thread)
1217     {
1218         source->read_thread_shutdown = true;
1219         WaitForSingleObject(source->read_thread, INFINITE);
1220         CloseHandle(source->read_thread);
1221     }
1222
1223     if (source->pres_desc)
1224         IMFPresentationDescriptor_Release(source->pres_desc);
1225     if (source->event_queue)
1226         IMFMediaEventQueue_Shutdown(source->event_queue);
1227     if (source->byte_stream)
1228         IMFByteStream_Release(source->byte_stream);
1229
1230     for (i = 0; i < source->stream_count; i++)
1231     {
1232         struct media_stream *stream = source->streams[i];
1233
1234         stream->state = STREAM_SHUTDOWN;
1235
1236         if (stream->event_queue)
1237             IMFMediaEventQueue_Shutdown(stream->event_queue);
1238         if (stream->descriptor)
1239             IMFStreamDescriptor_Release(stream->descriptor);
1240         if (stream->parent_source)
1241             IMFMediaSource_Release(&stream->parent_source->IMFMediaSource_iface);
1242
1243         IMFMediaStream_Release(&stream->IMFMediaStream_iface);
1244     }
1245
1246     unix_funcs->wg_parser_destroy(source->wg_parser);
1247
1248     if (source->stream_count)
1249         free(source->streams);
1250
1251     if (source->async_commands_queue)
1252         MFUnlockWorkQueue(source->async_commands_queue);
1253
1254     return S_OK;
1255 }
1256
1257 static const IMFMediaSourceVtbl IMFMediaSource_vtbl =
1258 {
1259     media_source_QueryInterface,
1260     media_source_AddRef,
1261     media_source_Release,
1262     media_source_GetEvent,
1263     media_source_BeginGetEvent,
1264     media_source_EndGetEvent,
1265     media_source_QueueEvent,
1266     media_source_GetCharacteristics,
1267     media_source_CreatePresentationDescriptor,
1268     media_source_Start,
1269     media_source_Stop,
1270     media_source_Pause,
1271     media_source_Shutdown,
1272 };
1273
1274 static HRESULT media_source_constructor(IMFByteStream *bytestream, struct media_source **out_media_source)
1275 {
1276     IMFStreamDescriptor **descriptors = NULL;
1277     struct media_source *object;
1278     UINT64 total_pres_time = 0;
1279     struct wg_parser *parser;
1280     DWORD bytestream_caps;
1281     uint64_t file_size;
1282     unsigned int i;
1283     HRESULT hr;
1284
1285     if (FAILED(hr = IMFByteStream_GetCapabilities(bytestream, &bytestream_caps)))
1286         return hr;
1287
1288     if (!(bytestream_caps & MFBYTESTREAM_IS_SEEKABLE))
1289     {
1290         FIXME("Non-seekable bytestreams not supported.\n");
1291         return MF_E_BYTESTREAM_NOT_SEEKABLE;
1292     }
1293
1294     if (FAILED(hr = IMFByteStream_GetLength(bytestream, &file_size)))
1295     {
1296         FIXME("Failed to get byte stream length, hr %#x.\n", hr);
1297         return hr;
1298     }
1299
1300     if (!(object = calloc(1, sizeof(*object))))
1301         return E_OUTOFMEMORY;
1302
1303     object->IMFMediaSource_iface.lpVtbl = &IMFMediaSource_vtbl;
1304     object->IMFGetService_iface.lpVtbl = &media_source_get_service_vtbl;
1305     object->IMFRateSupport_iface.lpVtbl = &media_source_rate_support_vtbl;
1306     object->IMFRateControl_iface.lpVtbl = &media_source_rate_control_vtbl;
1307     object->async_commands_callback.lpVtbl = &source_async_commands_callback_vtbl;
1308     object->ref = 1;
1309     object->byte_stream = bytestream;
1310     IMFByteStream_AddRef(bytestream);
1311
1312     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
1313         goto fail;
1314
1315     if (FAILED(hr = MFAllocateWorkQueue(&object->async_commands_queue)))
1316         goto fail;
1317
1318     object->read_thread = CreateThread(NULL, 0, read_thread, object, 0, NULL);
1319
1320     if (!(parser = unix_funcs->wg_decodebin_parser_create()))
1321     {
1322         hr = E_OUTOFMEMORY;
1323         goto fail;
1324     }
1325     object->wg_parser = parser;
1326
1327     object->state = SOURCE_OPENING;
1328
1329     if (FAILED(hr = unix_funcs->wg_parser_connect(parser, file_size)))
1330         goto fail;
1331
1332     /* In Media Foundation, sources may read from any media source stream
1333      * without fear of blocking due to buffering limits on another. Trailmakers,
1334      * a Unity3D Engine game, only reads one sample from the audio stream (and
1335      * never deselects it). Remove buffering limits from decodebin in order to
1336      * account for this. Note that this does leak memory, but the same memory
1337      * leak occurs with native. */
1338     unix_funcs->wg_parser_set_unlimited_buffering(parser);
1339
1340     object->stream_count = unix_funcs->wg_parser_get_stream_count(parser);
1341
1342     if (!(object->streams = calloc(object->stream_count, sizeof(*object->streams))))
1343     {
1344         hr = E_OUTOFMEMORY;
1345         goto fail;
1346     }
1347
1348     for (i = 0; i < object->stream_count; ++i)
1349     {
1350         if (FAILED(hr = new_media_stream(object, unix_funcs->wg_parser_get_stream(parser, i), i, &object->streams[i])))
1351             goto fail;
1352
1353         if (FAILED(hr = media_stream_init_desc(object->streams[i])))
1354         {
1355             ERR("Failed to finish initialization of media stream %p, hr %x.\n", object->streams[i], hr);
1356             IMFMediaStream_Release(&object->streams[i]->IMFMediaStream_iface);
1357             goto fail;
1358         }
1359     }
1360
1361     /* init presentation descriptor */
1362
1363     descriptors = malloc(object->stream_count * sizeof(IMFStreamDescriptor *));
1364     for (i = 0; i < object->stream_count; i++)
1365     {
1366         IMFMediaStream_GetStreamDescriptor(&object->streams[i]->IMFMediaStream_iface, &descriptors[i]);
1367     }
1368
1369     if (FAILED(hr = MFCreatePresentationDescriptor(object->stream_count, descriptors, &object->pres_desc)))
1370         goto fail;
1371
1372     for (i = 0; i < object->stream_count; i++)
1373     {
1374         IMFPresentationDescriptor_SelectStream(object->pres_desc, i);
1375         IMFStreamDescriptor_Release(descriptors[i]);
1376     }
1377     free(descriptors);
1378     descriptors = NULL;
1379
1380     for (i = 0; i < object->stream_count; i++)
1381         total_pres_time = max(total_pres_time,
1382                 unix_funcs->wg_parser_stream_get_duration(object->streams[i]->wg_stream));
1383
1384     if (object->stream_count)
1385         IMFPresentationDescriptor_SetUINT64(object->pres_desc, &MF_PD_DURATION, total_pres_time);
1386
1387     object->state = SOURCE_STOPPED;
1388
1389     *out_media_source = object;
1390     return S_OK;
1391
1392     fail:
1393     WARN("Failed to construct MFMediaSource, hr %#x.\n", hr);
1394
1395     free(descriptors);
1396     IMFMediaSource_Release(&object->IMFMediaSource_iface);
1397     return hr;
1398 }
1399
1400 struct winegstreamer_stream_handler_result
1401 {
1402     struct list entry;
1403     IMFAsyncResult *result;
1404     MF_OBJECT_TYPE obj_type;
1405     IUnknown *object;
1406 };
1407
1408 struct winegstreamer_stream_handler
1409 {
1410     IMFByteStreamHandler IMFByteStreamHandler_iface;
1411     IMFAsyncCallback IMFAsyncCallback_iface;
1412     LONG refcount;
1413     struct list results;
1414     CRITICAL_SECTION cs;
1415 };
1416
1417 static struct winegstreamer_stream_handler *impl_from_IMFByteStreamHandler(IMFByteStreamHandler *iface)
1418 {
1419     return CONTAINING_RECORD(iface, struct winegstreamer_stream_handler, IMFByteStreamHandler_iface);
1420 }
1421
1422 static struct winegstreamer_stream_handler *impl_from_IMFAsyncCallback(IMFAsyncCallback *iface)
1423 {
1424     return CONTAINING_RECORD(iface, struct winegstreamer_stream_handler, IMFAsyncCallback_iface);
1425 }
1426
1427 static HRESULT WINAPI winegstreamer_stream_handler_QueryInterface(IMFByteStreamHandler *iface, REFIID riid, void **obj)
1428 {
1429     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1430
1431     if (IsEqualIID(riid, &IID_IMFByteStreamHandler) ||
1432             IsEqualIID(riid, &IID_IUnknown))
1433     {
1434         *obj = iface;
1435         IMFByteStreamHandler_AddRef(iface);
1436         return S_OK;
1437     }
1438
1439     WARN("Unsupported %s.\n", debugstr_guid(riid));
1440     *obj = NULL;
1441     return E_NOINTERFACE;
1442 }
1443
1444 static ULONG WINAPI winegstreamer_stream_handler_AddRef(IMFByteStreamHandler *iface)
1445 {
1446     struct winegstreamer_stream_handler *handler = impl_from_IMFByteStreamHandler(iface);
1447     ULONG refcount = InterlockedIncrement(&handler->refcount);
1448
1449     TRACE("%p, refcount %u.\n", handler, refcount);
1450
1451     return refcount;
1452 }
1453
1454 static ULONG WINAPI winegstreamer_stream_handler_Release(IMFByteStreamHandler *iface)
1455 {
1456     struct winegstreamer_stream_handler *handler = impl_from_IMFByteStreamHandler(iface);
1457     ULONG refcount = InterlockedDecrement(&handler->refcount);
1458     struct winegstreamer_stream_handler_result *result, *next;
1459
1460     TRACE("%p, refcount %u.\n", iface, refcount);
1461
1462     if (!refcount)
1463     {
1464         LIST_FOR_EACH_ENTRY_SAFE(result, next, &handler->results, struct winegstreamer_stream_handler_result, entry)
1465         {
1466             list_remove(&result->entry);
1467             IMFAsyncResult_Release(result->result);
1468             if (result->object)
1469                 IUnknown_Release(result->object);
1470             free(result);
1471         }
1472         DeleteCriticalSection(&handler->cs);
1473         free(handler);
1474     }
1475
1476     return refcount;
1477 }
1478
1479 struct create_object_context
1480 {
1481     IUnknown IUnknown_iface;
1482     LONG refcount;
1483
1484     IPropertyStore *props;
1485     IMFByteStream *stream;
1486     WCHAR *url;
1487     DWORD flags;
1488 };
1489
1490 static struct create_object_context *impl_from_IUnknown(IUnknown *iface)
1491 {
1492     return CONTAINING_RECORD(iface, struct create_object_context, IUnknown_iface);
1493 }
1494
1495 static HRESULT WINAPI create_object_context_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
1496 {
1497     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1498
1499     if (IsEqualIID(riid, &IID_IUnknown))
1500     {
1501         *obj = iface;
1502         IUnknown_AddRef(iface);
1503         return S_OK;
1504     }
1505
1506     WARN("Unsupported %s.\n", debugstr_guid(riid));
1507     *obj = NULL;
1508     return E_NOINTERFACE;
1509 }
1510
1511 static ULONG WINAPI create_object_context_AddRef(IUnknown *iface)
1512 {
1513     struct create_object_context *context = impl_from_IUnknown(iface);
1514     ULONG refcount = InterlockedIncrement(&context->refcount);
1515
1516     TRACE("%p, refcount %u.\n", iface, refcount);
1517
1518     return refcount;
1519 }
1520
1521 static ULONG WINAPI create_object_context_Release(IUnknown *iface)
1522 {
1523     struct create_object_context *context = impl_from_IUnknown(iface);
1524     ULONG refcount = InterlockedDecrement(&context->refcount);
1525
1526     TRACE("%p, refcount %u.\n", iface, refcount);
1527
1528     if (!refcount)
1529     {
1530         if (context->props)
1531             IPropertyStore_Release(context->props);
1532         if (context->stream)
1533             IMFByteStream_Release(context->stream);
1534         free(context->url);
1535         free(context);
1536     }
1537
1538     return refcount;
1539 }
1540
1541 static const IUnknownVtbl create_object_context_vtbl =
1542 {
1543     create_object_context_QueryInterface,
1544     create_object_context_AddRef,
1545     create_object_context_Release,
1546 };
1547
1548 static HRESULT WINAPI winegstreamer_stream_handler_BeginCreateObject(IMFByteStreamHandler *iface, IMFByteStream *stream, const WCHAR *url, DWORD flags,
1549         IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback, IUnknown *state)
1550 {
1551     struct winegstreamer_stream_handler *this = impl_from_IMFByteStreamHandler(iface);
1552     struct create_object_context *context;
1553     IMFAsyncResult *caller, *item;
1554     HRESULT hr;
1555
1556     TRACE("%p, %s, %#x, %p, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, cancel_cookie, callback, state);
1557
1558     if (cancel_cookie)
1559         *cancel_cookie = NULL;
1560
1561     if (FAILED(hr = MFCreateAsyncResult(NULL, callback, state, &caller)))
1562         return hr;
1563
1564     if (!(context = calloc(1, sizeof(*context))))
1565     {
1566         IMFAsyncResult_Release(caller);
1567         return E_OUTOFMEMORY;
1568     }
1569
1570     context->IUnknown_iface.lpVtbl = &create_object_context_vtbl;
1571     context->refcount = 1;
1572     context->props = props;
1573     if (context->props)
1574         IPropertyStore_AddRef(context->props);
1575     context->flags = flags;
1576     context->stream = stream;
1577     if (context->stream)
1578         IMFByteStream_AddRef(context->stream);
1579     if (url)
1580         context->url = wcsdup(url);
1581     if (!context->stream)
1582     {
1583         IMFAsyncResult_Release(caller);
1584         IUnknown_Release(&context->IUnknown_iface);
1585         return E_OUTOFMEMORY;
1586     }
1587
1588     hr = MFCreateAsyncResult(&context->IUnknown_iface, &this->IMFAsyncCallback_iface, (IUnknown *)caller, &item);
1589     IUnknown_Release(&context->IUnknown_iface);
1590     if (SUCCEEDED(hr))
1591     {
1592         if (SUCCEEDED(hr = MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_IO, item)))
1593         {
1594             if (cancel_cookie)
1595             {
1596                 *cancel_cookie = (IUnknown *)caller;
1597                 IUnknown_AddRef(*cancel_cookie);
1598             }
1599         }
1600
1601         IMFAsyncResult_Release(item);
1602     }
1603     IMFAsyncResult_Release(caller);
1604
1605     return hr;
1606 }
1607
1608 static HRESULT WINAPI winegstreamer_stream_handler_EndCreateObject(IMFByteStreamHandler *iface, IMFAsyncResult *result,
1609         MF_OBJECT_TYPE *obj_type, IUnknown **object)
1610 {
1611     struct winegstreamer_stream_handler *this = impl_from_IMFByteStreamHandler(iface);
1612     struct winegstreamer_stream_handler_result *found = NULL, *cur;
1613     HRESULT hr;
1614
1615     TRACE("%p, %p, %p, %p.\n", iface, result, obj_type, object);
1616
1617     EnterCriticalSection(&this->cs);
1618
1619     LIST_FOR_EACH_ENTRY(cur, &this->results, struct winegstreamer_stream_handler_result, entry)
1620     {
1621         if (result == cur->result)
1622         {
1623             list_remove(&cur->entry);
1624             found = cur;
1625             break;
1626         }
1627     }
1628
1629     LeaveCriticalSection(&this->cs);
1630
1631     if (found)
1632     {
1633         *obj_type = found->obj_type;
1634         *object = found->object;
1635         hr = IMFAsyncResult_GetStatus(found->result);
1636         IMFAsyncResult_Release(found->result);
1637         free(found);
1638     }
1639     else
1640     {
1641         *obj_type = MF_OBJECT_INVALID;
1642         *object = NULL;
1643         hr = MF_E_UNEXPECTED;
1644     }
1645
1646     return hr;
1647 }
1648
1649 static HRESULT WINAPI winegstreamer_stream_handler_CancelObjectCreation(IMFByteStreamHandler *iface, IUnknown *cancel_cookie)
1650 {
1651     struct winegstreamer_stream_handler *this = impl_from_IMFByteStreamHandler(iface);
1652     struct winegstreamer_stream_handler_result *found = NULL, *cur;
1653
1654     TRACE("%p, %p.\n", iface, cancel_cookie);
1655
1656     EnterCriticalSection(&this->cs);
1657
1658     LIST_FOR_EACH_ENTRY(cur, &this->results, struct winegstreamer_stream_handler_result, entry)
1659     {
1660         if (cancel_cookie == (IUnknown *)cur->result)
1661         {
1662             list_remove(&cur->entry);
1663             found = cur;
1664             break;
1665         }
1666     }
1667
1668     LeaveCriticalSection(&this->cs);
1669
1670     if (found)
1671     {
1672         IMFAsyncResult_Release(found->result);
1673         if (found->object)
1674             IUnknown_Release(found->object);
1675         free(found);
1676     }
1677
1678     return found ? S_OK : MF_E_UNEXPECTED;
1679 }
1680
1681 static HRESULT WINAPI winegstreamer_stream_handler_GetMaxNumberOfBytesRequiredForResolution(IMFByteStreamHandler *iface, QWORD *bytes)
1682 {
1683     FIXME("stub (%p %p)\n", iface, bytes);
1684     return E_NOTIMPL;
1685 }
1686
1687 static const IMFByteStreamHandlerVtbl winegstreamer_stream_handler_vtbl =
1688 {
1689     winegstreamer_stream_handler_QueryInterface,
1690     winegstreamer_stream_handler_AddRef,
1691     winegstreamer_stream_handler_Release,
1692     winegstreamer_stream_handler_BeginCreateObject,
1693     winegstreamer_stream_handler_EndCreateObject,
1694     winegstreamer_stream_handler_CancelObjectCreation,
1695     winegstreamer_stream_handler_GetMaxNumberOfBytesRequiredForResolution,
1696 };
1697
1698 static HRESULT WINAPI winegstreamer_stream_handler_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
1699 {
1700     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
1701             IsEqualIID(riid, &IID_IUnknown))
1702     {
1703         *obj = iface;
1704         IMFAsyncCallback_AddRef(iface);
1705         return S_OK;
1706     }
1707
1708     WARN("Unsupported %s.\n", debugstr_guid(riid));
1709     *obj = NULL;
1710     return E_NOINTERFACE;
1711 }
1712
1713 static ULONG WINAPI winegstreamer_stream_handler_callback_AddRef(IMFAsyncCallback *iface)
1714 {
1715     struct winegstreamer_stream_handler *handler = impl_from_IMFAsyncCallback(iface);
1716     return IMFByteStreamHandler_AddRef(&handler->IMFByteStreamHandler_iface);
1717 }
1718
1719 static ULONG WINAPI winegstreamer_stream_handler_callback_Release(IMFAsyncCallback *iface)
1720 {
1721     struct winegstreamer_stream_handler *handler = impl_from_IMFAsyncCallback(iface);
1722     return IMFByteStreamHandler_Release(&handler->IMFByteStreamHandler_iface);
1723 }
1724
1725 static HRESULT WINAPI winegstreamer_stream_handler_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
1726 {
1727     return E_NOTIMPL;
1728 }
1729
1730 static HRESULT winegstreamer_stream_handler_create_object(struct winegstreamer_stream_handler *This, WCHAR *url, IMFByteStream *stream, DWORD flags,
1731                                             IPropertyStore *props, IUnknown **out_object, MF_OBJECT_TYPE *out_obj_type)
1732 {
1733     TRACE("(%p %s %p %u %p %p %p)\n", This, debugstr_w(url), stream, flags, props, out_object, out_obj_type);
1734
1735     if (flags & MF_RESOLUTION_MEDIASOURCE)
1736     {
1737         HRESULT hr;
1738         struct media_source *new_source;
1739
1740         if (FAILED(hr = media_source_constructor(stream, &new_source)))
1741             return hr;
1742
1743         TRACE("->(%p)\n", new_source);
1744
1745         *out_object = (IUnknown*)&new_source->IMFMediaSource_iface;
1746         *out_obj_type = MF_OBJECT_MEDIASOURCE;
1747
1748         return S_OK;
1749     }
1750     else
1751     {
1752         FIXME("flags = %08x\n", flags);
1753         return E_NOTIMPL;
1754     }
1755 }
1756
1757 static HRESULT WINAPI winegstreamer_stream_handler_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1758 {
1759     struct winegstreamer_stream_handler *handler = impl_from_IMFAsyncCallback(iface);
1760     struct winegstreamer_stream_handler_result *handler_result;
1761     MF_OBJECT_TYPE obj_type = MF_OBJECT_INVALID;
1762     IUnknown *object = NULL, *context_object;
1763     struct create_object_context *context;
1764     IMFAsyncResult *caller;
1765     HRESULT hr;
1766
1767     caller = (IMFAsyncResult *)IMFAsyncResult_GetStateNoAddRef(result);
1768
1769     if (FAILED(hr = IMFAsyncResult_GetObject(result, &context_object)))
1770     {
1771         WARN("Expected context set for callee result.\n");
1772         return hr;
1773     }
1774
1775     context = impl_from_IUnknown(context_object);
1776
1777     hr = winegstreamer_stream_handler_create_object(handler, context->url, context->stream, context->flags, context->props, &object, &obj_type);
1778
1779     if ((handler_result = malloc(sizeof(*handler_result))))
1780     {
1781         handler_result->result = caller;
1782         IMFAsyncResult_AddRef(handler_result->result);
1783         handler_result->obj_type = obj_type;
1784         handler_result->object = object;
1785
1786         EnterCriticalSection(&handler->cs);
1787         list_add_tail(&handler->results, &handler_result->entry);
1788         LeaveCriticalSection(&handler->cs);
1789     }
1790     else
1791     {
1792         if (object)
1793             IUnknown_Release(object);
1794         hr = E_OUTOFMEMORY;
1795     }
1796
1797     IUnknown_Release(&context->IUnknown_iface);
1798
1799     IMFAsyncResult_SetStatus(caller, hr);
1800     MFInvokeCallback(caller);
1801
1802     return S_OK;
1803 }
1804
1805 static const IMFAsyncCallbackVtbl winegstreamer_stream_handler_callback_vtbl =
1806 {
1807     winegstreamer_stream_handler_callback_QueryInterface,
1808     winegstreamer_stream_handler_callback_AddRef,
1809     winegstreamer_stream_handler_callback_Release,
1810     winegstreamer_stream_handler_callback_GetParameters,
1811     winegstreamer_stream_handler_callback_Invoke,
1812 };
1813
1814 HRESULT winegstreamer_stream_handler_create(REFIID riid, void **obj)
1815 {
1816     struct winegstreamer_stream_handler *this;
1817     HRESULT hr;
1818
1819     TRACE("%s, %p.\n", debugstr_guid(riid), obj);
1820
1821     if (!(this = calloc(1, sizeof(*this))))
1822         return E_OUTOFMEMORY;
1823
1824     list_init(&this->results);
1825     InitializeCriticalSection(&this->cs);
1826
1827     this->IMFByteStreamHandler_iface.lpVtbl = &winegstreamer_stream_handler_vtbl;
1828     this->IMFAsyncCallback_iface.lpVtbl = &winegstreamer_stream_handler_callback_vtbl;
1829     this->refcount = 1;
1830
1831     hr = IMFByteStreamHandler_QueryInterface(&this->IMFByteStreamHandler_iface, riid, obj);
1832     IMFByteStreamHandler_Release(&this->IMFByteStreamHandler_iface);
1833
1834     return hr;
1835 }