dlls/winegstreamer/media_source.c

   1 /* GStreamer Media Source
   2  *
   3  * Copyright 2020 Derek Lesho
   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 "config.h"
  21
  22 #include <gst/gst.h>
  23
  24 #include "gst_private.h"
  25 #include "gst_cbs.h"
  26
  27 #include <assert.h>
  28 #include <stdarg.h>
  29 #include <assert.h>
  30
  31 #define COBJMACROS
  32 #define NONAMELESSUNION
  33
  34 #include "mfapi.h"
  35 #include "mferror.h"
  36 #include "mfidl.h"
  37 #include "mfobjects.h"
  38
  39 #include "wine/debug.h"
  40 #include "wine/heap.h"
  41 #include "wine/list.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  44
  45 struct media_stream
  46 {
  47     IMFMediaStream IMFMediaStream_iface;
  48     LONG ref;
  49     struct media_source *parent_source;
  50     IMFMediaEventQueue *event_queue;
  51     IMFStreamDescriptor *descriptor;
  52     GstElement *appsink;
  53     GstPad *their_src, *my_sink;
  54     enum
  55     {
  56         STREAM_INACTIVE,
  57         STREAM_SHUTDOWN,
  58     } state;
  59     DWORD stream_id;
  60 };
  61
  62 struct media_source
  63 {
  64     IMFMediaSource IMFMediaSource_iface;
  65     LONG ref;
  66     IMFMediaEventQueue *event_queue;
  67     IMFByteStream *byte_stream;
  68     struct media_stream **streams;
  69     ULONG stream_count;
  70     GstBus *bus;
  71     GstElement *container;
  72     GstElement *decodebin;
  73     GstPad *my_src, *their_sink;
  74     enum
  75     {
  76         SOURCE_OPENING,
  77         SOURCE_STOPPED,
  78         SOURCE_SHUTDOWN,
  79     } state;
  80     HANDLE no_more_pads_event;
  81 };
  82
  83 static inline struct media_stream *impl_from_IMFMediaStream(IMFMediaStream *iface)
  84 {
  85     return CONTAINING_RECORD(iface, struct media_stream, IMFMediaStream_iface);
  86 }
  87
  88 static inline struct media_source *impl_from_IMFMediaSource(IMFMediaSource *iface)
  89 {
  90     return CONTAINING_RECORD(iface, struct media_source, IMFMediaSource_iface);
  91 }
  92
  93 static GstFlowReturn bytestream_wrapper_pull(GstPad *pad, GstObject *parent, guint64 ofs, guint len,
  94         GstBuffer **buf)
  95 {
  96     struct media_source *source = gst_pad_get_element_private(pad);
  97     IMFByteStream *byte_stream = source->byte_stream;
  98     ULONG bytes_read;
  99     GstMapInfo info;
 100     BOOL is_eof;
 101     HRESULT hr;
 102
 103     TRACE("requesting %u bytes at %s from source %p into buffer %p\n", len, wine_dbgstr_longlong(ofs), source, *buf);
 104
 105     if (ofs != GST_BUFFER_OFFSET_NONE)
 106     {
 107         if (FAILED(IMFByteStream_SetCurrentPosition(byte_stream, ofs)))
 108             return GST_FLOW_ERROR;
 109     }
 110
 111     if (FAILED(IMFByteStream_IsEndOfStream(byte_stream, &is_eof)))
 112         return GST_FLOW_ERROR;
 113     if (is_eof)
 114         return GST_FLOW_EOS;
 115
 116     if (!(*buf))
 117         *buf = gst_buffer_new_and_alloc(len);
 118     gst_buffer_map(*buf, &info, GST_MAP_WRITE);
 119     hr = IMFByteStream_Read(byte_stream, info.data, len, &bytes_read);
 120     gst_buffer_unmap(*buf, &info);
 121
 122     gst_buffer_set_size(*buf, bytes_read);
 123
 124     if (FAILED(hr))
 125         return GST_FLOW_ERROR;
 126     return GST_FLOW_OK;
 127 }
 128
 129 static gboolean bytestream_query(GstPad *pad, GstObject *parent, GstQuery *query)
 130 {
 131     struct media_source *source = gst_pad_get_element_private(pad);
 132     GstFormat format;
 133     QWORD bytestream_len;
 134
 135     TRACE("GStreamer queries source %p for %s\n", source, GST_QUERY_TYPE_NAME(query));
 136
 137     if (FAILED(IMFByteStream_GetLength(source->byte_stream, &bytestream_len)))
 138         return FALSE;
 139
 140     switch (GST_QUERY_TYPE(query))
 141     {
 142         case GST_QUERY_DURATION:
 143         {
 144             gst_query_parse_duration(query, &format, NULL);
 145             if (format == GST_FORMAT_PERCENT)
 146             {
 147                 gst_query_set_duration(query, GST_FORMAT_PERCENT, GST_FORMAT_PERCENT_MAX);
 148                 return TRUE;
 149             }
 150             else if (format == GST_FORMAT_BYTES)
 151             {
 152                 QWORD length;
 153                 IMFByteStream_GetLength(source->byte_stream, &length);
 154                 gst_query_set_duration(query, GST_FORMAT_BYTES, length);
 155                 return TRUE;
 156             }
 157             return FALSE;
 158         }
 159         case GST_QUERY_SEEKING:
 160         {
 161             gst_query_parse_seeking (query, &format, NULL, NULL, NULL);
 162             if (format != GST_FORMAT_BYTES)
 163             {
 164                 WARN("Cannot seek using format \"%s\".\n", gst_format_get_name(format));
 165                 return FALSE;
 166             }
 167             gst_query_set_seeking(query, GST_FORMAT_BYTES, 1, 0, bytestream_len);
 168             return TRUE;
 169         }
 170         case GST_QUERY_SCHEDULING:
 171         {
 172             gst_query_set_scheduling(query, GST_SCHEDULING_FLAG_SEEKABLE, 1, -1, 0);
 173             gst_query_add_scheduling_mode(query, GST_PAD_MODE_PULL);
 174             return TRUE;
 175         }
 176         default:
 177         {
 178             WARN("Unhandled query type %s\n", GST_QUERY_TYPE_NAME(query));
 179             return FALSE;
 180         }
 181     }
 182 }
 183
 184 static gboolean bytestream_pad_mode_activate(GstPad *pad, GstObject *parent, GstPadMode mode, gboolean activate)
 185 {
 186     struct media_source *source = gst_pad_get_element_private(pad);
 187
 188     TRACE("%s source pad for mediasource %p in %s mode.\n",
 189             activate ? "Activating" : "Deactivating", source, gst_pad_mode_get_name(mode));
 190
 191     return mode == GST_PAD_MODE_PULL;
 192 }
 193
 194 static gboolean bytestream_pad_event_process(GstPad *pad, GstObject *parent, GstEvent *event)
 195 {
 196     struct media_source *source = gst_pad_get_element_private(pad);
 197
 198     TRACE("source %p, type \"%s\".\n", source, GST_EVENT_TYPE_NAME(event));
 199
 200     switch (event->type) {
 201         /* the seek event should fail in pull mode */
 202         case GST_EVENT_SEEK:
 203             return FALSE;
 204         default:
 205             WARN("Ignoring \"%s\" event.\n", GST_EVENT_TYPE_NAME(event));
 206         case GST_EVENT_TAG:
 207         case GST_EVENT_QOS:
 208         case GST_EVENT_RECONFIGURE:
 209             return gst_pad_event_default(pad, parent, event);
 210     }
 211     return TRUE;
 212 }
 213
 214 GstBusSyncReply bus_watch(GstBus *bus, GstMessage *message, gpointer user)
 215 {
 216     struct media_source *source = user;
 217     gchar *dbg_info = NULL;
 218     GError *err = NULL;
 219
 220     TRACE("source %p message type %s\n", source, GST_MESSAGE_TYPE_NAME(message));
 221
 222     switch (message->type)
 223     {
 224         case GST_MESSAGE_ERROR:
 225             gst_message_parse_error(message, &err, &dbg_info);
 226             ERR("%s: %s\n", GST_OBJECT_NAME(message->src), err->message);
 227             ERR("%s\n", dbg_info);
 228             g_error_free(err);
 229             g_free(dbg_info);
 230             break;
 231         case GST_MESSAGE_WARNING:
 232             gst_message_parse_warning(message, &err, &dbg_info);
 233             WARN("%s: %s\n", GST_OBJECT_NAME(message->src), err->message);
 234             WARN("%s\n", dbg_info);
 235             g_error_free(err);
 236             g_free(dbg_info);
 237             break;
 238         default:
 239             break;
 240     }
 241
 242     gst_message_unref(message);
 243     return GST_BUS_DROP;
 244 }
 245
 246 static HRESULT WINAPI media_stream_QueryInterface(IMFMediaStream *iface, REFIID riid, void **out)
 247 {
 248     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 249
 250     TRACE("(%p)->(%s %p)\n", stream, debugstr_guid(riid), out);
 251
 252     if (IsEqualIID(riid, &IID_IMFMediaStream) ||
 253         IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
 254         IsEqualIID(riid, &IID_IUnknown))
 255     {
 256         *out = &stream->IMFMediaStream_iface;
 257     }
 258     else
 259     {
 260         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
 261         *out = NULL;
 262         return E_NOINTERFACE;
 263     }
 264
 265     IUnknown_AddRef((IUnknown*)*out);
 266     return S_OK;
 267 }
 268
 269 static ULONG WINAPI media_stream_AddRef(IMFMediaStream *iface)
 270 {
 271     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 272     ULONG ref = InterlockedIncrement(&stream->ref);
 273
 274     TRACE("(%p) ref=%u\n", stream, ref);
 275
 276     return ref;
 277 }
 278
 279 static ULONG WINAPI media_stream_Release(IMFMediaStream *iface)
 280 {
 281     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 282
 283     ULONG ref = InterlockedDecrement(&stream->ref);
 284
 285     TRACE("(%p) ref=%u\n", stream, ref);
 286
 287     if (!ref)
 288     {
 289         if (stream->event_queue)
 290             IMFMediaEventQueue_Release(stream->event_queue);
 291         heap_free(stream);
 292     }
 293
 294     return ref;
 295 }
 296
 297 static HRESULT WINAPI media_stream_GetEvent(IMFMediaStream *iface, DWORD flags, IMFMediaEvent **event)
 298 {
 299     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 300
 301     TRACE("(%p)->(%#x, %p)\n", stream, flags, event);
 302
 303     return IMFMediaEventQueue_GetEvent(stream->event_queue, flags, event);
 304 }
 305
 306 static HRESULT WINAPI media_stream_BeginGetEvent(IMFMediaStream *iface, IMFAsyncCallback *callback, IUnknown *state)
 307 {
 308     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 309
 310     TRACE("(%p)->(%p, %p)\n", stream, callback, state);
 311
 312     return IMFMediaEventQueue_BeginGetEvent(stream->event_queue, callback, state);
 313 }
 314
 315 static HRESULT WINAPI media_stream_EndGetEvent(IMFMediaStream *iface, IMFAsyncResult *result, IMFMediaEvent **event)
 316 {
 317     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 318
 319     TRACE("(%p)->(%p, %p)\n", stream, result, event);
 320
 321     return IMFMediaEventQueue_EndGetEvent(stream->event_queue, result, event);
 322 }
 323
 324 static HRESULT WINAPI media_stream_QueueEvent(IMFMediaStream *iface, MediaEventType event_type, REFGUID ext_type,
 325         HRESULT hr, const PROPVARIANT *value)
 326 {
 327     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 328
 329     TRACE("(%p)->(%d, %s, %#x, %p)\n", stream, event_type, debugstr_guid(ext_type), hr, value);
 330
 331     return IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, event_type, ext_type, hr, value);
 332 }
 333
 334 static HRESULT WINAPI media_stream_GetMediaSource(IMFMediaStream *iface, IMFMediaSource **source)
 335 {
 336     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 337
 338     FIXME("stub (%p)->(%p)\n", stream, source);
 339
 340     if (stream->state == STREAM_SHUTDOWN)
 341         return MF_E_SHUTDOWN;
 342
 343     return E_NOTIMPL;
 344 }
 345
 346 static HRESULT WINAPI media_stream_GetStreamDescriptor(IMFMediaStream* iface, IMFStreamDescriptor **descriptor)
 347 {
 348     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 349
 350     TRACE("(%p)->(%p)\n", stream, descriptor);
 351
 352     if (stream->state == STREAM_SHUTDOWN)
 353         return MF_E_SHUTDOWN;
 354
 355     IMFStreamDescriptor_AddRef(stream->descriptor);
 356     *descriptor = stream->descriptor;
 357
 358     return S_OK;
 359 }
 360
 361 static HRESULT WINAPI media_stream_RequestSample(IMFMediaStream *iface, IUnknown *token)
 362 {
 363     struct media_stream *stream = impl_from_IMFMediaStream(iface);
 364
 365     TRACE("(%p)->(%p)\n", iface, token);
 366
 367     if (stream->state == STREAM_SHUTDOWN)
 368         return MF_E_SHUTDOWN;
 369
 370     return E_NOTIMPL;
 371 }
 372
 373 static const IMFMediaStreamVtbl media_stream_vtbl =
 374 {
 375     media_stream_QueryInterface,
 376     media_stream_AddRef,
 377     media_stream_Release,
 378     media_stream_GetEvent,
 379     media_stream_BeginGetEvent,
 380     media_stream_EndGetEvent,
 381     media_stream_QueueEvent,
 382     media_stream_GetMediaSource,
 383     media_stream_GetStreamDescriptor,
 384     media_stream_RequestSample
 385 };
 386
 387 static HRESULT new_media_stream(struct media_source *source, GstPad *pad, DWORD stream_id, struct media_stream **out_stream)
 388 {
 389     struct media_stream *object = heap_alloc_zero(sizeof(*object));
 390     HRESULT hr;
 391
 392     TRACE("(%p %p)->(%p)\n", source, pad, out_stream);
 393
 394     object->IMFMediaStream_iface.lpVtbl = &media_stream_vtbl;
 395     object->ref = 1;
 396
 397     IMFMediaSource_AddRef(&source->IMFMediaSource_iface);
 398     object->parent_source = source;
 399     object->their_src = pad;
 400     object->stream_id = stream_id;
 401
 402     object->state = STREAM_INACTIVE;
 403
 404     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
 405         goto fail;
 406
 407     if (!(object->appsink = gst_element_factory_make("appsink", NULL)))
 408     {
 409         hr = E_OUTOFMEMORY;
 410         goto fail;
 411     }
 412     gst_bin_add(GST_BIN(object->parent_source->container), object->appsink);
 413
 414     g_object_set(object->appsink, "sync", FALSE, NULL);
 415     g_object_set(object->appsink, "max-buffers", 5, NULL);
 416
 417     object->my_sink = gst_element_get_static_pad(object->appsink, "sink");
 418     gst_pad_link(object->their_src, object->my_sink);
 419
 420     gst_element_sync_state_with_parent(object->appsink);
 421
 422     TRACE("->(%p)\n", object);
 423     *out_stream = object;
 424
 425     return S_OK;
 426
 427 fail:
 428     WARN("Failed to construct media stream, hr %#x.\n", hr);
 429
 430     IMFMediaStream_Release(&object->IMFMediaStream_iface);
 431     return hr;
 432 }
 433
 434 static HRESULT media_stream_init_desc(struct media_stream *stream)
 435 {
 436     GstCaps *current_caps = gst_pad_get_current_caps(stream->their_src);
 437     IMFMediaTypeHandler *type_handler;
 438     IMFMediaType *stream_type = NULL;
 439     HRESULT hr;
 440
 441     stream_type = mf_media_type_from_caps(current_caps);
 442     gst_caps_unref(current_caps);
 443     if (!stream_type)
 444         return E_FAIL;
 445
 446     hr = MFCreateStreamDescriptor(stream->stream_id, 1, &stream_type, &stream->descriptor);
 447
 448     IMFMediaType_Release(stream_type);
 449
 450     if (FAILED(hr))
 451         return hr;
 452
 453     if (FAILED(hr = IMFStreamDescriptor_GetMediaTypeHandler(stream->descriptor, &type_handler)))
 454         return hr;
 455
 456     hr = IMFMediaTypeHandler_SetCurrentMediaType(type_handler, stream_type);
 457
 458     IMFMediaTypeHandler_Release(type_handler);
 459
 460     return hr;
 461 }
 462
 463 static HRESULT WINAPI media_source_QueryInterface(IMFMediaSource *iface, REFIID riid, void **out)
 464 {
 465     struct media_source *source = impl_from_IMFMediaSource(iface);
 466
 467     TRACE("(%p)->(%s %p)\n", source, debugstr_guid(riid), out);
 468
 469     if (IsEqualIID(riid, &IID_IMFMediaSource) ||
 470         IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
 471         IsEqualIID(riid, &IID_IUnknown))
 472     {
 473         *out = &source->IMFMediaSource_iface;
 474     }
 475     else
 476     {
 477         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
 478         *out = NULL;
 479         return E_NOINTERFACE;
 480     }
 481
 482     IUnknown_AddRef((IUnknown*)*out);
 483     return S_OK;
 484 }
 485
 486 static ULONG WINAPI media_source_AddRef(IMFMediaSource *iface)
 487 {
 488     struct media_source *source = impl_from_IMFMediaSource(iface);
 489     ULONG ref = InterlockedIncrement(&source->ref);
 490
 491     TRACE("(%p) ref=%u\n", source, ref);
 492
 493     return ref;
 494 }
 495
 496 static ULONG WINAPI media_source_Release(IMFMediaSource *iface)
 497 {
 498     struct media_source *source = impl_from_IMFMediaSource(iface);
 499     ULONG ref = InterlockedDecrement(&source->ref);
 500
 501     TRACE("(%p) ref=%u\n", source, ref);
 502
 503     if (!ref)
 504     {
 505         IMFMediaSource_Shutdown(&source->IMFMediaSource_iface);
 506         IMFMediaEventQueue_Release(source->event_queue);
 507         heap_free(source);
 508     }
 509
 510     return ref;
 511 }
 512
 513 static HRESULT WINAPI media_source_GetEvent(IMFMediaSource *iface, DWORD flags, IMFMediaEvent **event)
 514 {
 515     struct media_source *source = impl_from_IMFMediaSource(iface);
 516
 517     TRACE("(%p)->(%#x, %p)\n", source, flags, event);
 518
 519     return IMFMediaEventQueue_GetEvent(source->event_queue, flags, event);
 520 }
 521
 522 static HRESULT WINAPI media_source_BeginGetEvent(IMFMediaSource *iface, IMFAsyncCallback *callback, IUnknown *state)
 523 {
 524     struct media_source *source = impl_from_IMFMediaSource(iface);
 525
 526     TRACE("(%p)->(%p, %p)\n", source, callback, state);
 527
 528     return IMFMediaEventQueue_BeginGetEvent(source->event_queue, callback, state);
 529 }
 530
 531 static HRESULT WINAPI media_source_EndGetEvent(IMFMediaSource *iface, IMFAsyncResult *result, IMFMediaEvent **event)
 532 {
 533     struct media_source *source = impl_from_IMFMediaSource(iface);
 534
 535     TRACE("(%p)->(%p, %p)\n", source, result, event);
 536
 537     return IMFMediaEventQueue_EndGetEvent(source->event_queue, result, event);
 538 }
 539
 540 static HRESULT WINAPI media_source_QueueEvent(IMFMediaSource *iface, MediaEventType event_type, REFGUID ext_type,
 541         HRESULT hr, const PROPVARIANT *value)
 542 {
 543     struct media_source *source = impl_from_IMFMediaSource(iface);
 544
 545     TRACE("(%p)->(%d, %s, %#x, %p)\n", source, event_type, debugstr_guid(ext_type), hr, value);
 546
 547     return IMFMediaEventQueue_QueueEventParamVar(source->event_queue, event_type, ext_type, hr, value);
 548 }
 549
 550 static HRESULT WINAPI media_source_GetCharacteristics(IMFMediaSource *iface, DWORD *characteristics)
 551 {
 552     struct media_source *source = impl_from_IMFMediaSource(iface);
 553
 554     FIXME("(%p)->(%p): stub\n", source, characteristics);
 555
 556     if (source->state == SOURCE_SHUTDOWN)
 557         return MF_E_SHUTDOWN;
 558
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI media_source_CreatePresentationDescriptor(IMFMediaSource *iface, IMFPresentationDescriptor **descriptor)
 563 {
 564     struct media_source *source = impl_from_IMFMediaSource(iface);
 565
 566     FIXME("(%p)->(%p): stub\n", source, descriptor);
 567
 568     if (source->state == SOURCE_SHUTDOWN)
 569         return MF_E_SHUTDOWN;
 570
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI media_source_Start(IMFMediaSource *iface, IMFPresentationDescriptor *descriptor,
 575                                      const GUID *time_format, const PROPVARIANT *start_position)
 576 {
 577     struct media_source *source = impl_from_IMFMediaSource(iface);
 578
 579     FIXME("(%p)->(%p, %p, %p): stub\n", source, descriptor, time_format, start_position);
 580
 581     if (source->state == SOURCE_SHUTDOWN)
 582         return MF_E_SHUTDOWN;
 583
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI media_source_Stop(IMFMediaSource *iface)
 588 {
 589     struct media_source *source = impl_from_IMFMediaSource(iface);
 590
 591     FIXME("(%p): stub\n", source);
 592
 593     if (source->state == SOURCE_SHUTDOWN)
 594         return MF_E_SHUTDOWN;
 595
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI media_source_Pause(IMFMediaSource *iface)
 600 {
 601     struct media_source *source = impl_from_IMFMediaSource(iface);
 602
 603     FIXME("(%p): stub\n", source);
 604
 605     if (source->state == SOURCE_SHUTDOWN)
 606         return MF_E_SHUTDOWN;
 607
 608     return E_NOTIMPL;
 609 }
 610
 611 static HRESULT WINAPI media_source_Shutdown(IMFMediaSource *iface)
 612 {
 613     struct media_source *source = impl_from_IMFMediaSource(iface);
 614     unsigned int i;
 615
 616     TRACE("(%p)\n", source);
 617
 618     if (source->state == SOURCE_SHUTDOWN)
 619         return MF_E_SHUTDOWN;
 620
 621     source->state = SOURCE_SHUTDOWN;
 622
 623     if (source->container)
 624     {
 625         gst_element_set_state(source->container, GST_STATE_NULL);
 626         gst_object_unref(GST_OBJECT(source->container));
 627     }
 628
 629     if (source->my_src)
 630         gst_object_unref(GST_OBJECT(source->my_src));
 631     if (source->their_sink)
 632         gst_object_unref(GST_OBJECT(source->their_sink));
 633
 634     if (source->event_queue)
 635         IMFMediaEventQueue_Shutdown(source->event_queue);
 636     if (source->byte_stream)
 637         IMFByteStream_Release(source->byte_stream);
 638
 639     for (i = 0; i < source->stream_count; i++)
 640     {
 641         struct media_stream *stream = source->streams[i];
 642
 643         stream->state = STREAM_SHUTDOWN;
 644
 645         if (stream->my_sink)
 646             gst_object_unref(GST_OBJECT(stream->my_sink));
 647         if (stream->event_queue)
 648             IMFMediaEventQueue_Shutdown(stream->event_queue);
 649         if (stream->descriptor)
 650             IMFStreamDescriptor_Release(stream->descriptor);
 651         if (stream->parent_source)
 652             IMFMediaSource_Release(&stream->parent_source->IMFMediaSource_iface);
 653
 654         IMFMediaStream_Release(&stream->IMFMediaStream_iface);
 655     }
 656
 657     if (source->stream_count)
 658         heap_free(source->streams);
 659
 660     if (source->no_more_pads_event)
 661         CloseHandle(source->no_more_pads_event);
 662
 663     return S_OK;
 664 }
 665
 666 static const IMFMediaSourceVtbl IMFMediaSource_vtbl =
 667 {
 668     media_source_QueryInterface,
 669     media_source_AddRef,
 670     media_source_Release,
 671     media_source_GetEvent,
 672     media_source_BeginGetEvent,
 673     media_source_EndGetEvent,
 674     media_source_QueueEvent,
 675     media_source_GetCharacteristics,
 676     media_source_CreatePresentationDescriptor,
 677     media_source_Start,
 678     media_source_Stop,
 679     media_source_Pause,
 680     media_source_Shutdown,
 681 };
 682
 683 static void stream_added(GstElement *element, GstPad *pad, gpointer user)
 684 {
 685     struct media_source *source = user;
 686     struct media_stream **new_stream_array;
 687     struct media_stream *stream;
 688
 689     if (gst_pad_get_direction(pad) != GST_PAD_SRC)
 690         return;
 691
 692     if (FAILED(new_media_stream(source, pad, source->stream_count, &stream)))
 693         return;
 694
 695     if (!(new_stream_array = heap_realloc(source->streams, (source->stream_count + 1) * (sizeof(*new_stream_array)))))
 696     {
 697         ERR("Failed to add stream to source\n");
 698         IMFMediaStream_Release(&stream->IMFMediaStream_iface);
 699         return;
 700     }
 701
 702     source->streams = new_stream_array;
 703     source->streams[source->stream_count++] = stream;
 704 }
 705
 706 static void stream_removed(GstElement *element, GstPad *pad, gpointer user)
 707 {
 708     struct media_source *source = user;
 709     unsigned int i;
 710
 711     for (i = 0; i < source->stream_count; i++)
 712     {
 713         struct media_stream *stream = source->streams[i];
 714         if (stream->their_src != pad)
 715             continue;
 716         stream->their_src = NULL;
 717         stream->state = STREAM_INACTIVE;
 718     }
 719 }
 720
 721 static void no_more_pads(GstElement *element, gpointer user)
 722 {
 723     struct media_source *source = user;
 724
 725     SetEvent(source->no_more_pads_event);
 726 }
 727
 728 static HRESULT media_source_constructor(IMFByteStream *bytestream, struct media_source **out_media_source)
 729 {
 730     GstStaticPadTemplate src_template =
 731         GST_STATIC_PAD_TEMPLATE("mf_src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS_ANY);
 732
 733     struct media_source *object = heap_alloc_zero(sizeof(*object));
 734     unsigned int i;
 735     HRESULT hr;
 736     int ret;
 737
 738     if (!object)
 739         return E_OUTOFMEMORY;
 740
 741     object->IMFMediaSource_iface.lpVtbl = &IMFMediaSource_vtbl;
 742     object->ref = 1;
 743     object->byte_stream = bytestream;
 744     IMFByteStream_AddRef(bytestream);
 745     object->no_more_pads_event = CreateEventA(NULL, FALSE, FALSE, NULL);
 746
 747     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
 748         goto fail;
 749
 750     object->container = gst_bin_new(NULL);
 751     object->bus = gst_bus_new();
 752     gst_bus_set_sync_handler(object->bus, mf_src_bus_watch_wrapper, object, NULL);
 753     gst_element_set_bus(object->container, object->bus);
 754
 755     object->my_src = gst_pad_new_from_static_template(&src_template, "mf-src");
 756     gst_pad_set_element_private(object->my_src, object);
 757     gst_pad_set_getrange_function(object->my_src, bytestream_wrapper_pull_wrapper);
 758     gst_pad_set_query_function(object->my_src, bytestream_query_wrapper);
 759     gst_pad_set_activatemode_function(object->my_src, bytestream_pad_mode_activate_wrapper);
 760     gst_pad_set_event_function(object->my_src, bytestream_pad_event_process_wrapper);
 761
 762     if (!(object->decodebin = gst_element_factory_make("decodebin", NULL)))
 763     {
 764         WARN("Failed to create decodebin for source\n");
 765         hr = E_OUTOFMEMORY;
 766         goto fail;
 767     }
 768
 769     /* In Media Foundation, sources may read from any media source stream
 770        without fear of blocking due to buffering limits on another.  Trailmakers,
 771        a Unity3D engine game does this by only reading from the audio stream once,
 772        and never deselecting this.  These properties replicate that behavior.
 773
 774        Note that with most elements, this causes excessive memory use, however
 775        this is also what occurs on Windows.
 776     */
 777     g_object_set(object->decodebin, "max-size-buffers", 0, NULL);
 778     g_object_set(object->decodebin, "max-size-time", G_GUINT64_CONSTANT(0), NULL);
 779     g_object_set(object->decodebin, "max-size-bytes", 0, NULL);
 780
 781     gst_bin_add(GST_BIN(object->container), object->decodebin);
 782
 783     g_signal_connect(object->decodebin, "pad-added", G_CALLBACK(mf_src_stream_added_wrapper), object);
 784     g_signal_connect(object->decodebin, "pad-removed", G_CALLBACK(mf_src_stream_removed_wrapper), object);
 785     g_signal_connect(object->decodebin, "no-more-pads", G_CALLBACK(mf_src_no_more_pads_wrapper), object);
 786
 787     object->their_sink = gst_element_get_static_pad(object->decodebin, "sink");
 788
 789     if ((ret = gst_pad_link(object->my_src, object->their_sink)) < 0)
 790     {
 791         WARN("Failed to link our bytestream pad to the demuxer input, error %d.\n", ret);
 792         hr = E_FAIL;
 793         goto fail;
 794     }
 795
 796     object->state = SOURCE_OPENING;
 797
 798     gst_element_set_state(object->container, GST_STATE_PAUSED);
 799     ret = gst_element_get_state(object->container, NULL, NULL, -1);
 800     if (ret == GST_STATE_CHANGE_FAILURE)
 801     {
 802         ERR("Failed to play source, error %d.\n", ret);
 803         hr = E_FAIL;
 804         goto fail;
 805     }
 806
 807     WaitForSingleObject(object->no_more_pads_event, INFINITE);
 808     for (i = 0; i < object->stream_count; i++)
 809     {
 810         GstSample *preroll;
 811         g_signal_emit_by_name(object->streams[i]->appsink, "pull-preroll", &preroll);
 812         if (FAILED(hr = media_stream_init_desc(object->streams[i])))
 813         {
 814             ERR("Failed to finish initialization of media stream %p, hr %x.\n", object->streams[i], hr);
 815             IMFMediaStream_Release(&object->streams[i]->IMFMediaStream_iface);
 816             goto fail;
 817         }
 818         gst_sample_unref(preroll);
 819     }
 820
 821     object->state = SOURCE_STOPPED;
 822
 823     *out_media_source = object;
 824     return S_OK;
 825
 826     fail:
 827     WARN("Failed to construct MFMediaSource, hr %#x.\n", hr);
 828
 829     IMFMediaSource_Release(&object->IMFMediaSource_iface);
 830     return hr;
 831 }
 832
 833 struct winegstreamer_stream_handler_result
 834 {
 835     struct list entry;
 836     IMFAsyncResult *result;
 837     MF_OBJECT_TYPE obj_type;
 838     IUnknown *object;
 839 };
 840
 841 struct winegstreamer_stream_handler
 842 {
 843     IMFByteStreamHandler IMFByteStreamHandler_iface;
 844     IMFAsyncCallback IMFAsyncCallback_iface;
 845     LONG refcount;
 846     struct list results;
 847     CRITICAL_SECTION cs;
 848 };
 849
 850 static struct winegstreamer_stream_handler *impl_from_IMFByteStreamHandler(IMFByteStreamHandler *iface)
 851 {
 852     return CONTAINING_RECORD(iface, struct winegstreamer_stream_handler, IMFByteStreamHandler_iface);
 853 }
 854
 855 static struct winegstreamer_stream_handler *impl_from_IMFAsyncCallback(IMFAsyncCallback *iface)
 856 {
 857     return CONTAINING_RECORD(iface, struct winegstreamer_stream_handler, IMFAsyncCallback_iface);
 858 }
 859
 860 static HRESULT WINAPI winegstreamer_stream_handler_QueryInterface(IMFByteStreamHandler *iface, REFIID riid, void **obj)
 861 {
 862     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 863
 864     if (IsEqualIID(riid, &IID_IMFByteStreamHandler) ||
 865             IsEqualIID(riid, &IID_IUnknown))
 866     {
 867         *obj = iface;
 868         IMFByteStreamHandler_AddRef(iface);
 869         return S_OK;
 870     }
 871
 872     WARN("Unsupported %s.\n", debugstr_guid(riid));
 873     *obj = NULL;
 874     return E_NOINTERFACE;
 875 }
 876
 877 static ULONG WINAPI winegstreamer_stream_handler_AddRef(IMFByteStreamHandler *iface)
 878 {
 879     struct winegstreamer_stream_handler *handler = impl_from_IMFByteStreamHandler(iface);
 880     ULONG refcount = InterlockedIncrement(&handler->refcount);
 881
 882     TRACE("%p, refcount %u.\n", handler, refcount);
 883
 884     return refcount;
 885 }
 886
 887 static ULONG WINAPI winegstreamer_stream_handler_Release(IMFByteStreamHandler *iface)
 888 {
 889     struct winegstreamer_stream_handler *handler = impl_from_IMFByteStreamHandler(iface);
 890     ULONG refcount = InterlockedDecrement(&handler->refcount);
 891     struct winegstreamer_stream_handler_result *result, *next;
 892
 893     TRACE("%p, refcount %u.\n", iface, refcount);
 894
 895     if (!refcount)
 896     {
 897         LIST_FOR_EACH_ENTRY_SAFE(result, next, &handler->results, struct winegstreamer_stream_handler_result, entry)
 898         {
 899             list_remove(&result->entry);
 900             IMFAsyncResult_Release(result->result);
 901             if (result->object)
 902                 IUnknown_Release(result->object);
 903             heap_free(result);
 904         }
 905         DeleteCriticalSection(&handler->cs);
 906         heap_free(handler);
 907     }
 908
 909     return refcount;
 910 }
 911
 912 struct create_object_context
 913 {
 914     IUnknown IUnknown_iface;
 915     LONG refcount;
 916
 917     IPropertyStore *props;
 918     IMFByteStream *stream;
 919     WCHAR *url;
 920     DWORD flags;
 921 };
 922
 923 static struct create_object_context *impl_from_IUnknown(IUnknown *iface)
 924 {
 925     return CONTAINING_RECORD(iface, struct create_object_context, IUnknown_iface);
 926 }
 927
 928 static HRESULT WINAPI create_object_context_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 929 {
 930     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 931
 932     if (IsEqualIID(riid, &IID_IUnknown))
 933     {
 934         *obj = iface;
 935         IUnknown_AddRef(iface);
 936         return S_OK;
 937     }
 938
 939     WARN("Unsupported %s.\n", debugstr_guid(riid));
 940     *obj = NULL;
 941     return E_NOINTERFACE;
 942 }
 943
 944 static ULONG WINAPI create_object_context_AddRef(IUnknown *iface)
 945 {
 946     struct create_object_context *context = impl_from_IUnknown(iface);
 947     ULONG refcount = InterlockedIncrement(&context->refcount);
 948
 949     TRACE("%p, refcount %u.\n", iface, refcount);
 950
 951     return refcount;
 952 }
 953
 954 static ULONG WINAPI create_object_context_Release(IUnknown *iface)
 955 {
 956     struct create_object_context *context = impl_from_IUnknown(iface);
 957     ULONG refcount = InterlockedDecrement(&context->refcount);
 958
 959     TRACE("%p, refcount %u.\n", iface, refcount);
 960
 961     if (!refcount)
 962     {
 963         if (context->props)
 964             IPropertyStore_Release(context->props);
 965         if (context->stream)
 966             IMFByteStream_Release(context->stream);
 967         heap_free(context->url);
 968         heap_free(context);
 969     }
 970
 971     return refcount;
 972 }
 973
 974 static const IUnknownVtbl create_object_context_vtbl =
 975 {
 976     create_object_context_QueryInterface,
 977     create_object_context_AddRef,
 978     create_object_context_Release,
 979 };
 980
 981 static WCHAR *heap_strdupW(const WCHAR *str)
 982 {
 983     WCHAR *ret = NULL;
 984
 985     if (str)
 986     {
 987         unsigned int size;
 988
 989         size = (lstrlenW(str) + 1) * sizeof(WCHAR);
 990         ret = heap_alloc(size);
 991         if (ret)
 992             memcpy(ret, str, size);
 993     }
 994
 995     return ret;
 996 }
 997
 998 static HRESULT WINAPI winegstreamer_stream_handler_BeginCreateObject(IMFByteStreamHandler *iface, IMFByteStream *stream, const WCHAR *url, DWORD flags,
 999         IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback, IUnknown *state)
1000 {
1001     struct winegstreamer_stream_handler *this = impl_from_IMFByteStreamHandler(iface);
1002     struct create_object_context *context;
1003     IMFAsyncResult *caller, *item;
1004     HRESULT hr;
1005
1006     TRACE("%p, %s, %#x, %p, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, cancel_cookie, callback, state);
1007
1008     if (cancel_cookie)
1009         *cancel_cookie = NULL;
1010
1011     if (FAILED(hr = MFCreateAsyncResult(NULL, callback, state, &caller)))
1012         return hr;
1013
1014     context = heap_alloc(sizeof(*context));
1015     if (!context)
1016     {
1017         IMFAsyncResult_Release(caller);
1018         return E_OUTOFMEMORY;
1019     }
1020
1021     context->IUnknown_iface.lpVtbl = &create_object_context_vtbl;
1022     context->refcount = 1;
1023     context->props = props;
1024     if (context->props)
1025         IPropertyStore_AddRef(context->props);
1026     context->flags = flags;
1027     context->stream = stream;
1028     if (context->stream)
1029         IMFByteStream_AddRef(context->stream);
1030     if (url)
1031         context->url = heap_strdupW(url);
1032     if (!context->stream)
1033     {
1034         IMFAsyncResult_Release(caller);
1035         IUnknown_Release(&context->IUnknown_iface);
1036         return E_OUTOFMEMORY;
1037     }
1038
1039     hr = MFCreateAsyncResult(&context->IUnknown_iface, &this->IMFAsyncCallback_iface, (IUnknown *)caller, &item);
1040     IUnknown_Release(&context->IUnknown_iface);
1041     if (SUCCEEDED(hr))
1042     {
1043         if (SUCCEEDED(hr = MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_IO, item)))
1044         {
1045             if (cancel_cookie)
1046             {
1047                 *cancel_cookie = (IUnknown *)caller;
1048                 IUnknown_AddRef(*cancel_cookie);
1049             }
1050         }
1051
1052         IMFAsyncResult_Release(item);
1053     }
1054     IMFAsyncResult_Release(caller);
1055
1056     return hr;
1057 }
1058
1059 static HRESULT WINAPI winegstreamer_stream_handler_EndCreateObject(IMFByteStreamHandler *iface, IMFAsyncResult *result,
1060         MF_OBJECT_TYPE *obj_type, IUnknown **object)
1061 {
1062     struct winegstreamer_stream_handler *this = impl_from_IMFByteStreamHandler(iface);
1063     struct winegstreamer_stream_handler_result *found = NULL, *cur;
1064     HRESULT hr;
1065
1066     TRACE("%p, %p, %p, %p.\n", iface, result, obj_type, object);
1067
1068     EnterCriticalSection(&this->cs);
1069
1070     LIST_FOR_EACH_ENTRY(cur, &this->results, struct winegstreamer_stream_handler_result, entry)
1071     {
1072         if (result == cur->result)
1073         {
1074             list_remove(&cur->entry);
1075             found = cur;
1076             break;
1077         }
1078     }
1079
1080     LeaveCriticalSection(&this->cs);
1081
1082     if (found)
1083     {
1084         *obj_type = found->obj_type;
1085         *object = found->object;
1086         hr = IMFAsyncResult_GetStatus(found->result);
1087         IMFAsyncResult_Release(found->result);
1088         heap_free(found);
1089     }
1090     else
1091     {
1092         *obj_type = MF_OBJECT_INVALID;
1093         *object = NULL;
1094         hr = MF_E_UNEXPECTED;
1095     }
1096
1097     return hr;
1098 }
1099
1100 static HRESULT WINAPI winegstreamer_stream_handler_CancelObjectCreation(IMFByteStreamHandler *iface, IUnknown *cancel_cookie)
1101 {
1102     struct winegstreamer_stream_handler *this = impl_from_IMFByteStreamHandler(iface);
1103     struct winegstreamer_stream_handler_result *found = NULL, *cur;
1104
1105     TRACE("%p, %p.\n", iface, cancel_cookie);
1106
1107     EnterCriticalSection(&this->cs);
1108
1109     LIST_FOR_EACH_ENTRY(cur, &this->results, struct winegstreamer_stream_handler_result, entry)
1110     {
1111         if (cancel_cookie == (IUnknown *)cur->result)
1112         {
1113             list_remove(&cur->entry);
1114             found = cur;
1115             break;
1116         }
1117     }
1118
1119     LeaveCriticalSection(&this->cs);
1120
1121     if (found)
1122     {
1123         IMFAsyncResult_Release(found->result);
1124         if (found->object)
1125             IUnknown_Release(found->object);
1126         heap_free(found);
1127     }
1128
1129     return found ? S_OK : MF_E_UNEXPECTED;
1130 }
1131
1132 static HRESULT WINAPI winegstreamer_stream_handler_GetMaxNumberOfBytesRequiredForResolution(IMFByteStreamHandler *iface, QWORD *bytes)
1133 {
1134     FIXME("stub (%p %p)\n", iface, bytes);
1135     return E_NOTIMPL;
1136 }
1137
1138 static const IMFByteStreamHandlerVtbl winegstreamer_stream_handler_vtbl =
1139 {
1140     winegstreamer_stream_handler_QueryInterface,
1141     winegstreamer_stream_handler_AddRef,
1142     winegstreamer_stream_handler_Release,
1143     winegstreamer_stream_handler_BeginCreateObject,
1144     winegstreamer_stream_handler_EndCreateObject,
1145     winegstreamer_stream_handler_CancelObjectCreation,
1146     winegstreamer_stream_handler_GetMaxNumberOfBytesRequiredForResolution,
1147 };
1148
1149 static HRESULT WINAPI winegstreamer_stream_handler_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
1150 {
1151     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
1152             IsEqualIID(riid, &IID_IUnknown))
1153     {
1154         *obj = iface;
1155         IMFAsyncCallback_AddRef(iface);
1156         return S_OK;
1157     }
1158
1159     WARN("Unsupported %s.\n", debugstr_guid(riid));
1160     *obj = NULL;
1161     return E_NOINTERFACE;
1162 }
1163
1164 static ULONG WINAPI winegstreamer_stream_handler_callback_AddRef(IMFAsyncCallback *iface)
1165 {
1166     struct winegstreamer_stream_handler *handler = impl_from_IMFAsyncCallback(iface);
1167     return IMFByteStreamHandler_AddRef(&handler->IMFByteStreamHandler_iface);
1168 }
1169
1170 static ULONG WINAPI winegstreamer_stream_handler_callback_Release(IMFAsyncCallback *iface)
1171 {
1172     struct winegstreamer_stream_handler *handler = impl_from_IMFAsyncCallback(iface);
1173     return IMFByteStreamHandler_Release(&handler->IMFByteStreamHandler_iface);
1174 }
1175
1176 static HRESULT WINAPI winegstreamer_stream_handler_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
1177 {
1178     return E_NOTIMPL;
1179 }
1180
1181 static HRESULT winegstreamer_stream_handler_create_object(struct winegstreamer_stream_handler *This, WCHAR *url, IMFByteStream *stream, DWORD flags,
1182                                             IPropertyStore *props, IUnknown **out_object, MF_OBJECT_TYPE *out_obj_type)
1183 {
1184     TRACE("(%p %s %p %u %p %p %p)\n", This, debugstr_w(url), stream, flags, props, out_object, out_obj_type);
1185
1186     if (flags & MF_RESOLUTION_MEDIASOURCE)
1187     {
1188         HRESULT hr;
1189         struct media_source *new_source;
1190
1191         if (FAILED(hr = media_source_constructor(stream, &new_source)))
1192             return hr;
1193
1194         TRACE("->(%p)\n", new_source);
1195
1196         *out_object = (IUnknown*)&new_source->IMFMediaSource_iface;
1197         *out_obj_type = MF_OBJECT_MEDIASOURCE;
1198
1199         return S_OK;
1200     }
1201     else
1202     {
1203         FIXME("flags = %08x\n", flags);
1204         return E_NOTIMPL;
1205     }
1206 }
1207
1208 static HRESULT WINAPI winegstreamer_stream_handler_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1209 {
1210     struct winegstreamer_stream_handler *handler = impl_from_IMFAsyncCallback(iface);
1211     struct winegstreamer_stream_handler_result *handler_result;
1212     MF_OBJECT_TYPE obj_type = MF_OBJECT_INVALID;
1213     IUnknown *object = NULL, *context_object;
1214     struct create_object_context *context;
1215     IMFAsyncResult *caller;
1216     HRESULT hr;
1217
1218     caller = (IMFAsyncResult *)IMFAsyncResult_GetStateNoAddRef(result);
1219
1220     if (FAILED(hr = IMFAsyncResult_GetObject(result, &context_object)))
1221     {
1222         WARN("Expected context set for callee result.\n");
1223         return hr;
1224     }
1225
1226     context = impl_from_IUnknown(context_object);
1227
1228     hr = winegstreamer_stream_handler_create_object(handler, context->url, context->stream, context->flags, context->props, &object, &obj_type);
1229
1230     handler_result = heap_alloc(sizeof(*handler_result));
1231     if (handler_result)
1232     {
1233         handler_result->result = caller;
1234         IMFAsyncResult_AddRef(handler_result->result);
1235         handler_result->obj_type = obj_type;
1236         handler_result->object = object;
1237
1238         EnterCriticalSection(&handler->cs);
1239         list_add_tail(&handler->results, &handler_result->entry);
1240         LeaveCriticalSection(&handler->cs);
1241     }
1242     else
1243     {
1244         if (object)
1245             IUnknown_Release(object);
1246         hr = E_OUTOFMEMORY;
1247     }
1248
1249     IUnknown_Release(&context->IUnknown_iface);
1250
1251     IMFAsyncResult_SetStatus(caller, hr);
1252     MFInvokeCallback(caller);
1253
1254     return S_OK;
1255 }
1256
1257 static const IMFAsyncCallbackVtbl winegstreamer_stream_handler_callback_vtbl =
1258 {
1259     winegstreamer_stream_handler_callback_QueryInterface,
1260     winegstreamer_stream_handler_callback_AddRef,
1261     winegstreamer_stream_handler_callback_Release,
1262     winegstreamer_stream_handler_callback_GetParameters,
1263     winegstreamer_stream_handler_callback_Invoke,
1264 };
1265
1266 HRESULT winegstreamer_stream_handler_create(REFIID riid, void **obj)
1267 {
1268     struct winegstreamer_stream_handler *this;
1269     HRESULT hr;
1270
1271     TRACE("%s, %p.\n", debugstr_guid(riid), obj);
1272
1273     this = heap_alloc_zero(sizeof(*this));
1274     if (!this)
1275         return E_OUTOFMEMORY;
1276
1277     list_init(&this->results);
1278     InitializeCriticalSection(&this->cs);
1279
1280     this->IMFByteStreamHandler_iface.lpVtbl = &winegstreamer_stream_handler_vtbl;
1281     this->IMFAsyncCallback_iface.lpVtbl = &winegstreamer_stream_handler_callback_vtbl;
1282     this->refcount = 1;
1283
1284     hr = IMFByteStreamHandler_QueryInterface(&this->IMFByteStreamHandler_iface, riid, obj);
1285     IMFByteStreamHandler_Release(&this->IMFByteStreamHandler_iface);
1286
1287     return hr;
1288 }
1289
1290 /* helper for callback forwarding */
1291 void perform_cb_media_source(struct cb_data *cbdata)
1292 {
1293     switch(cbdata->type)
1294     {
1295     case BYTESTREAM_WRAPPER_PULL:
1296         {
1297             struct getrange_data *data = &cbdata->u.getrange_data;
1298             cbdata->u.getrange_data.ret = bytestream_wrapper_pull(data->pad, data->parent,
1299                     data->ofs, data->len, data->buf);
1300             break;
1301         }
1302     case BYTESTREAM_QUERY:
1303         {
1304             struct query_function_data *data = &cbdata->u.query_function_data;
1305             cbdata->u.query_function_data.ret = bytestream_query(data->pad, data->parent, data->query);
1306             break;
1307         }
1308     case BYTESTREAM_PAD_MODE_ACTIVATE:
1309         {
1310             struct activate_mode_data *data = &cbdata->u.activate_mode_data;
1311             cbdata->u.activate_mode_data.ret = bytestream_pad_mode_activate(data->pad, data->parent, data->mode, data->activate);
1312             break;
1313         }
1314     case BYTESTREAM_PAD_EVENT_PROCESS:
1315         {
1316             struct event_src_data *data = &cbdata->u.event_src_data;
1317             cbdata->u.event_src_data.ret = bytestream_pad_event_process(data->pad, data->parent, data->event);
1318             break;
1319         }
1320     case MF_SRC_BUS_WATCH:
1321         {
1322             struct watch_bus_data *data = &cbdata->u.watch_bus_data;
1323             cbdata->u.watch_bus_data.ret = bus_watch(data->bus, data->msg, data->user);
1324             break;
1325         }
1326     case MF_SRC_STREAM_ADDED:
1327         {
1328             struct pad_added_data *data = &cbdata->u.pad_added_data;
1329             stream_added(data->element, data->pad, data->user);
1330             break;
1331         }
1332     case MF_SRC_STREAM_REMOVED:
1333         {
1334             struct pad_removed_data *data = &cbdata->u.pad_removed_data;
1335             stream_removed(data->element, data->pad, data->user);
1336             break;
1337         }
1338     case MF_SRC_NO_MORE_PADS:
1339         {
1340             struct no_more_pads_data *data = &cbdata->u.no_more_pads_data;
1341             no_more_pads(data->element, data->user);
1342             break;
1343         }
1344     default:
1345         {
1346             assert(0);
1347         }
1348     }
1349 }