dlls/winegstreamer/gstdemux.c

   1 /*
   2  * GStreamer splitter + decoder, adapted from parser.c
   3  *
   4  * Copyright 2010 Maarten Lankhorst for CodeWeavers
   5  * Copyright 2010 Aric Stewart for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "gst_private.h"
  24 #include "gst_guids.h"
  25 #include "gst_cbs.h"
  26
  27 #include "vfwmsgs.h"
  28 #include "amvideo.h"
  29
  30 #include "wine/unicode.h"
  31 #include "wine/debug.h"
  32
  33 #include <assert.h>
  34
  35 #include "dvdmedia.h"
  36 #include "mmreg.h"
  37 #include "ks.h"
  38 #include "initguid.h"
  39 #include "wmcodecdsp.h"
  40 #include "ksmedia.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(gstreamer);
  43
  44 static const GUID MEDIASUBTYPE_CVID = {mmioFOURCC('c','v','i','d'), 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
  45
  46 struct gstdemux
  47 {
  48     struct strmbase_filter filter;
  49     IAMStreamSelect IAMStreamSelect_iface;
  50
  51     struct strmbase_sink sink;
  52     IAsyncReader *reader;
  53
  54     struct gstdemux_source **sources;
  55     unsigned int source_count;
  56     BOOL enum_sink_first;
  57
  58     LONGLONG filesize;
  59
  60     BOOL initial, ignore_flush;
  61     GstElement *container;
  62     GstPad *my_src, *their_sink;
  63     GstBus *bus;
  64     guint64 start, nextofs, nextpullofs, stop;
  65     HANDLE no_more_pads_event, duration_event, error_event;
  66
  67     HANDLE push_thread;
  68
  69     BOOL (*init_gst)(struct gstdemux *filter);
  70     HRESULT (*source_query_accept)(struct gstdemux_source *pin, const AM_MEDIA_TYPE *mt);
  71     HRESULT (*source_get_media_type)(struct gstdemux_source *pin, unsigned int index, AM_MEDIA_TYPE *mt);
  72 };
  73
  74 struct gstdemux_source
  75 {
  76     struct strmbase_source pin;
  77     IQualityControl IQualityControl_iface;
  78
  79     GstPad *their_src, *post_sink, *post_src, *my_sink;
  80     GstElement *flip;
  81     AM_MEDIA_TYPE mt;
  82     HANDLE caps_event, eos_event;
  83     GstSegment *segment;
  84     SourceSeeking seek;
  85 };
  86
  87 static inline struct gstdemux *impl_from_strmbase_filter(struct strmbase_filter *iface)
  88 {
  89     return CONTAINING_RECORD(iface, struct gstdemux, filter);
  90 }
  91
  92 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
  93 static const IMediaSeekingVtbl GST_Seeking_Vtbl;
  94 static const IQualityControlVtbl GSTOutPin_QualityControl_Vtbl;
  95
  96 static struct gstdemux_source *create_pin(struct gstdemux *filter, const WCHAR *name);
  97 static HRESULT GST_RemoveOutputPins(struct gstdemux *This);
  98 static HRESULT WINAPI GST_ChangeCurrent(IMediaSeeking *iface);
  99 static HRESULT WINAPI GST_ChangeStop(IMediaSeeking *iface);
 100 static HRESULT WINAPI GST_ChangeRate(IMediaSeeking *iface);
 101
 102 static gboolean amt_from_gst_caps_audio_raw(const GstCaps *caps, AM_MEDIA_TYPE *amt)
 103 {
 104     WAVEFORMATEXTENSIBLE *wfe;
 105     WAVEFORMATEX *wfx;
 106     gint32 depth, bpp;
 107     GstAudioInfo ainfo;
 108
 109     if (!gst_audio_info_from_caps (&ainfo, caps))
 110         return FALSE;
 111
 112     wfe = CoTaskMemAlloc(sizeof(*wfe));
 113     wfx = (WAVEFORMATEX*)wfe;
 114     amt->majortype = MEDIATYPE_Audio;
 115     amt->subtype = MEDIASUBTYPE_PCM;
 116     amt->formattype = FORMAT_WaveFormatEx;
 117     amt->pbFormat = (BYTE*)wfe;
 118     amt->cbFormat = sizeof(*wfe);
 119     amt->bFixedSizeSamples = TRUE;
 120     amt->bTemporalCompression = FALSE;
 121     amt->pUnk = NULL;
 122
 123     wfx->wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 124
 125     wfx->nChannels = ainfo.channels;
 126     wfx->nSamplesPerSec = ainfo.rate;
 127     depth = GST_AUDIO_INFO_WIDTH(&ainfo);
 128     bpp = GST_AUDIO_INFO_DEPTH(&ainfo);
 129
 130     if (!depth || depth > 32 || depth % 8)
 131         depth = bpp;
 132     else if (!bpp)
 133         bpp = depth;
 134     wfe->Samples.wValidBitsPerSample = depth;
 135     wfx->wBitsPerSample = bpp;
 136     wfx->cbSize = sizeof(*wfe)-sizeof(*wfx);
 137     switch (wfx->nChannels) {
 138         case 1: wfe->dwChannelMask = KSAUDIO_SPEAKER_MONO; break;
 139         case 2: wfe->dwChannelMask = KSAUDIO_SPEAKER_STEREO; break;
 140         case 4: wfe->dwChannelMask = KSAUDIO_SPEAKER_SURROUND; break;
 141         case 5: wfe->dwChannelMask = (KSAUDIO_SPEAKER_5POINT1 & ~SPEAKER_LOW_FREQUENCY); break;
 142         case 6: wfe->dwChannelMask = KSAUDIO_SPEAKER_5POINT1; break;
 143         case 8: wfe->dwChannelMask = KSAUDIO_SPEAKER_7POINT1; break;
 144         default:
 145         wfe->dwChannelMask = 0;
 146     }
 147     if (GST_AUDIO_INFO_IS_FLOAT(&ainfo)) {
 148         amt->subtype = MEDIASUBTYPE_IEEE_FLOAT;
 149         wfe->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 150     } else {
 151         wfe->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 152         if (wfx->nChannels <= 2 && bpp <= 16 && depth == bpp)  {
 153             wfx->wFormatTag = WAVE_FORMAT_PCM;
 154             wfx->cbSize = 0;
 155             amt->cbFormat = sizeof(WAVEFORMATEX);
 156         }
 157     }
 158     amt->lSampleSize = wfx->nBlockAlign = wfx->nChannels * wfx->wBitsPerSample/8;
 159     wfx->nAvgBytesPerSec = wfx->nSamplesPerSec * wfx->nBlockAlign;
 160     return TRUE;
 161 }
 162
 163 static gboolean amt_from_gst_video_info(const GstVideoInfo *info, AM_MEDIA_TYPE *amt)
 164 {
 165     VIDEOINFOHEADER *vih;
 166     BITMAPINFOHEADER *bih;
 167     gint32 width, height;
 168
 169     width = GST_VIDEO_INFO_WIDTH(info);
 170     height = GST_VIDEO_INFO_HEIGHT(info);
 171
 172     vih = CoTaskMemAlloc(sizeof(*vih));
 173     bih = &vih->bmiHeader;
 174
 175     amt->formattype = FORMAT_VideoInfo;
 176     amt->pbFormat = (BYTE*)vih;
 177     amt->cbFormat = sizeof(*vih);
 178     amt->bFixedSizeSamples = FALSE;
 179     amt->bTemporalCompression = TRUE;
 180     amt->lSampleSize = 1;
 181     amt->pUnk = NULL;
 182     ZeroMemory(vih, sizeof(*vih));
 183     amt->majortype = MEDIATYPE_Video;
 184
 185     if (GST_VIDEO_INFO_IS_RGB(info))
 186     {
 187         switch (GST_VIDEO_INFO_FORMAT(info))
 188         {
 189         case GST_VIDEO_FORMAT_BGRA:
 190             amt->subtype = MEDIASUBTYPE_ARGB32;
 191             bih->biBitCount = 32;
 192             break;
 193         case GST_VIDEO_FORMAT_BGRx:
 194             amt->subtype = MEDIASUBTYPE_RGB32;
 195             bih->biBitCount = 32;
 196             break;
 197         case GST_VIDEO_FORMAT_BGR:
 198             amt->subtype = MEDIASUBTYPE_RGB24;
 199             bih->biBitCount = 24;
 200             break;
 201         case GST_VIDEO_FORMAT_BGR16:
 202             amt->subtype = MEDIASUBTYPE_RGB565;
 203             bih->biBitCount = 16;
 204             break;
 205         case GST_VIDEO_FORMAT_BGR15:
 206             amt->subtype = MEDIASUBTYPE_RGB555;
 207             bih->biBitCount = 16;
 208             break;
 209         default:
 210             FIXME("Unhandled type %s.\n", GST_VIDEO_INFO_NAME(info));
 211             CoTaskMemFree(vih);
 212             return FALSE;
 213         }
 214         bih->biCompression = BI_RGB;
 215     } else {
 216         amt->subtype = MEDIATYPE_Video;
 217         if (!(amt->subtype.Data1 = gst_video_format_to_fourcc(GST_VIDEO_INFO_FORMAT(info))))
 218         {
 219             CoTaskMemFree(vih);
 220             return FALSE;
 221         }
 222         switch (amt->subtype.Data1) {
 223             case mmioFOURCC('I','4','2','0'):
 224             case mmioFOURCC('Y','V','1','2'):
 225             case mmioFOURCC('N','V','1','2'):
 226             case mmioFOURCC('N','V','2','1'):
 227                 bih->biBitCount = 12; break;
 228             case mmioFOURCC('Y','U','Y','2'):
 229             case mmioFOURCC('Y','V','Y','U'):
 230             case mmioFOURCC('U','Y','V','Y'):
 231                 bih->biBitCount = 16; break;
 232         }
 233         bih->biCompression = amt->subtype.Data1;
 234     }
 235     bih->biSizeImage = GST_VIDEO_INFO_SIZE(info);
 236     if ((vih->AvgTimePerFrame = (REFERENCE_TIME)MulDiv(10000000,
 237             GST_VIDEO_INFO_FPS_D(info), GST_VIDEO_INFO_FPS_N(info))) == -1)
 238         vih->AvgTimePerFrame = 0; /* zero division or integer overflow */
 239     bih->biSize = sizeof(*bih);
 240     bih->biWidth = width;
 241     bih->biHeight = height;
 242     bih->biPlanes = 1;
 243     return TRUE;
 244 }
 245
 246 static gboolean amt_from_gst_caps_audio_mpeg(const GstCaps *caps, AM_MEDIA_TYPE *mt)
 247 {
 248     GstStructure *structure = gst_caps_get_structure(caps, 0);
 249     gint layer, channels, rate;
 250
 251     mt->majortype = MEDIATYPE_Audio;
 252     mt->subtype = MEDIASUBTYPE_MPEG1AudioPayload;
 253     mt->bFixedSizeSamples = FALSE;
 254     mt->bTemporalCompression = FALSE;
 255     mt->lSampleSize = 0;
 256     mt->formattype = FORMAT_WaveFormatEx;
 257     mt->pUnk = NULL;
 258
 259     if (!gst_structure_get_int(structure, "layer", &layer))
 260     {
 261         WARN("Missing 'layer' value.\n");
 262         return FALSE;
 263     }
 264     if (!gst_structure_get_int(structure, "channels", &channels))
 265     {
 266         WARN("Missing 'channels' value.\n");
 267         return FALSE;
 268     }
 269     if (!gst_structure_get_int(structure, "rate", &rate))
 270     {
 271         WARN("Missing 'rate' value.\n");
 272         return FALSE;
 273     }
 274
 275     if (layer == 3)
 276     {
 277         MPEGLAYER3WAVEFORMAT *wfx = CoTaskMemAlloc(sizeof(*wfx));
 278         memset(wfx, 0, sizeof(*wfx));
 279
 280         mt->subtype.Data1 = WAVE_FORMAT_MPEGLAYER3;
 281         mt->cbFormat = sizeof(*wfx);
 282         mt->pbFormat = (BYTE *)wfx;
 283         wfx->wfx.wFormatTag = WAVE_FORMAT_MPEGLAYER3;
 284         wfx->wfx.nChannels = channels;
 285         wfx->wfx.nSamplesPerSec = rate;
 286         /* FIXME: We can't get most of the MPEG data from the caps. We may have
 287          * to manually parse the header. */
 288         wfx->wfx.cbSize = sizeof(*wfx) - sizeof(WAVEFORMATEX);
 289         wfx->wID = MPEGLAYER3_ID_MPEG;
 290         wfx->fdwFlags = MPEGLAYER3_FLAG_PADDING_ON;
 291         wfx->nFramesPerBlock = 1;
 292         wfx->nCodecDelay = 1393;
 293     }
 294     else
 295     {
 296         MPEG1WAVEFORMAT *wfx = CoTaskMemAlloc(sizeof(*wfx));
 297         memset(wfx, 0, sizeof(*wfx));
 298
 299         mt->subtype.Data1 = WAVE_FORMAT_MPEG;
 300         mt->cbFormat = sizeof(*wfx);
 301         mt->pbFormat = (BYTE *)wfx;
 302         wfx->wfx.wFormatTag = WAVE_FORMAT_MPEG;
 303         wfx->wfx.nChannels = channels;
 304         wfx->wfx.nSamplesPerSec = rate;
 305         wfx->wfx.cbSize = sizeof(*wfx) - sizeof(WAVEFORMATEX);
 306         wfx->fwHeadLayer = layer;
 307     }
 308
 309     return TRUE;
 310 }
 311
 312 static gboolean amt_from_gst_caps(const GstCaps *caps, AM_MEDIA_TYPE *mt)
 313 {
 314     const char *type = gst_structure_get_name(gst_caps_get_structure(caps, 0));
 315     GstStructure *structure = gst_caps_get_structure(caps, 0);
 316
 317     if (!strcmp(type, "audio/x-raw"))
 318         return amt_from_gst_caps_audio_raw(caps, mt);
 319     else if (!strcmp(type, "video/x-raw"))
 320     {
 321         GstVideoInfo info;
 322
 323         if (!gst_video_info_from_caps(&info, caps))
 324             return FALSE;
 325         return amt_from_gst_video_info(&info, mt);
 326     }
 327     else if (!strcmp(type, "audio/mpeg"))
 328         return amt_from_gst_caps_audio_mpeg(caps, mt);
 329     else if (!strcmp(type, "video/x-cinepak"))
 330     {
 331         VIDEOINFOHEADER *vih;
 332         gint i;
 333
 334         memset(mt, 0, sizeof(AM_MEDIA_TYPE));
 335         mt->majortype = MEDIATYPE_Video;
 336         mt->subtype = MEDIASUBTYPE_CVID;
 337         mt->bTemporalCompression = TRUE;
 338         mt->lSampleSize = 1;
 339         mt->formattype = FORMAT_VideoInfo;
 340         if (!(vih = CoTaskMemAlloc(sizeof(VIDEOINFOHEADER))))
 341             return FALSE;
 342         mt->cbFormat = sizeof(VIDEOINFOHEADER);
 343         mt->pbFormat = (BYTE *)vih;
 344
 345         memset(vih, 0, sizeof(VIDEOINFOHEADER));
 346         vih->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 347         if (gst_structure_get_int(structure, "width", &i))
 348             vih->bmiHeader.biWidth = i;
 349         if (gst_structure_get_int(structure, "height", &i))
 350             vih->bmiHeader.biHeight = i;
 351         vih->bmiHeader.biPlanes = 1;
 352         /* Both ffmpeg's encoder and a Cinepak file seen in the wild report
 353          * 24 bpp. ffmpeg sets biSizeImage as below; others may be smaller, but
 354          * as long as every sample fits into our allocator, we're fine. */
 355         vih->bmiHeader.biBitCount = 24;
 356         vih->bmiHeader.biCompression = mmioFOURCC('c','v','i','d');
 357         vih->bmiHeader.biSizeImage = vih->bmiHeader.biWidth
 358                 * vih->bmiHeader.biHeight * vih->bmiHeader.biBitCount / 8;
 359         return TRUE;
 360     }
 361     else
 362     {
 363         FIXME("Unhandled type %s.\n", debugstr_a(type));
 364         return FALSE;
 365     }
 366 }
 367
 368 static GstCaps *amt_to_gst_caps_video(const AM_MEDIA_TYPE *mt)
 369 {
 370     static const struct
 371     {
 372         const GUID *subtype;
 373         GstVideoFormat format;
 374     }
 375     format_map[] =
 376     {
 377         {&MEDIASUBTYPE_ARGB32,  GST_VIDEO_FORMAT_BGRA},
 378         {&MEDIASUBTYPE_RGB32,   GST_VIDEO_FORMAT_BGRx},
 379         {&MEDIASUBTYPE_RGB24,   GST_VIDEO_FORMAT_BGR},
 380         {&MEDIASUBTYPE_RGB565,  GST_VIDEO_FORMAT_BGR16},
 381         {&MEDIASUBTYPE_RGB555,  GST_VIDEO_FORMAT_BGR15},
 382     };
 383
 384     const VIDEOINFOHEADER *vih = (VIDEOINFOHEADER *)mt->pbFormat;
 385     GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN;
 386     GstVideoInfo info;
 387     unsigned int i;
 388     GstCaps *caps;
 389
 390     if (!IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo)
 391             || mt->cbFormat < sizeof(VIDEOINFOHEADER) || !mt->pbFormat)
 392         return NULL;
 393
 394     for (i = 0; i < ARRAY_SIZE(format_map); ++i)
 395     {
 396         if (IsEqualGUID(&mt->subtype, format_map[i].subtype))
 397         {
 398             format = format_map[i].format;
 399             break;
 400         }
 401     }
 402
 403     if (format == GST_VIDEO_FORMAT_UNKNOWN)
 404         format = gst_video_format_from_fourcc(vih->bmiHeader.biCompression);
 405
 406     if (format == GST_VIDEO_FORMAT_UNKNOWN)
 407     {
 408         FIXME("Unknown video format (subtype %s, compression %#x).\n",
 409                 debugstr_guid(&mt->subtype), vih->bmiHeader.biCompression);
 410         return NULL;
 411     }
 412
 413     gst_video_info_set_format(&info, format, vih->bmiHeader.biWidth, vih->bmiHeader.biHeight);
 414     if ((caps = gst_video_info_to_caps(&info)))
 415     {
 416         /* Clear some fields that shouldn't prevent us from connecting. */
 417         for (i = 0; i < gst_caps_get_size(caps); ++i)
 418         {
 419             gst_structure_remove_field(gst_caps_get_structure(caps, i), "framerate");
 420             gst_structure_remove_field(gst_caps_get_structure(caps, i), "pixel-aspect-ratio");
 421         }
 422     }
 423     return caps;
 424 }
 425
 426 static GstCaps *amt_to_gst_caps_audio(const AM_MEDIA_TYPE *mt)
 427 {
 428     const WAVEFORMATEX *wfx = (WAVEFORMATEX *)mt->pbFormat;
 429     GstAudioFormat format = GST_AUDIO_FORMAT_UNKNOWN;
 430     GstAudioInfo info;
 431
 432     if (!IsEqualGUID(&mt->formattype, &FORMAT_WaveFormatEx)
 433             || mt->cbFormat < sizeof(WAVEFORMATEX) || !mt->pbFormat)
 434         return NULL;
 435
 436     if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_PCM))
 437         format = gst_audio_format_build_integer(wfx->wBitsPerSample != 8,
 438                 G_LITTLE_ENDIAN, wfx->wBitsPerSample, wfx->wBitsPerSample);
 439     else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_IEEE_FLOAT))
 440     {
 441         if (wfx->wBitsPerSample == 32)
 442             format = GST_AUDIO_FORMAT_F32LE;
 443         else if (wfx->wBitsPerSample == 64)
 444             format = GST_AUDIO_FORMAT_F64LE;
 445     }
 446
 447     if (format == GST_AUDIO_FORMAT_UNKNOWN)
 448     {
 449         FIXME("Unknown audio format (subtype %s, depth %u).\n",
 450                 debugstr_guid(&mt->subtype), wfx->wBitsPerSample);
 451         return NULL;
 452     }
 453
 454     gst_audio_info_set_format(&info, format, wfx->nSamplesPerSec, wfx->nChannels, NULL);
 455     return gst_audio_info_to_caps(&info);
 456 }
 457
 458 static GstCaps *amt_to_gst_caps(const AM_MEDIA_TYPE *mt)
 459 {
 460     if (IsEqualGUID(&mt->majortype, &MEDIATYPE_Video))
 461         return amt_to_gst_caps_video(mt);
 462     else if (IsEqualGUID(&mt->majortype, &MEDIATYPE_Audio))
 463         return amt_to_gst_caps_audio(mt);
 464
 465     FIXME("Unknown major type %s.\n", debugstr_guid(&mt->majortype));
 466     return NULL;
 467 }
 468
 469 static gboolean setcaps_sink(GstPad *pad, GstCaps *caps)
 470 {
 471     struct gstdemux_source *pin = gst_pad_get_element_private(pad);
 472     struct gstdemux *filter = impl_from_strmbase_filter(pin->pin.pin.filter);
 473     gchar *caps_str = gst_caps_to_string(caps);
 474
 475     TRACE("filter %p, caps %s.\n", filter, debugstr_a(caps_str));
 476     g_free(caps_str);
 477
 478     FreeMediaType(&pin->mt);
 479
 480     if (!amt_from_gst_caps(caps, &pin->mt))
 481         return FALSE;
 482
 483     SetEvent(pin->caps_event);
 484     return TRUE;
 485 }
 486
 487 static gboolean query_sink(GstPad *pad, GstObject *parent, GstQuery *query)
 488 {
 489     struct gstdemux_source *pin = gst_pad_get_element_private(pad);
 490
 491     TRACE("pin %p, type \"%s\".\n", pin, gst_query_type_get_name(query->type));
 492
 493     switch (query->type)
 494     {
 495         case GST_QUERY_CAPS:
 496         {
 497             GstCaps *caps, *filter, *temp;
 498
 499             gst_query_parse_caps(query, &filter);
 500
 501             if (pin->pin.pin.peer)
 502                 caps = amt_to_gst_caps(&pin->pin.pin.mt);
 503             else
 504                 caps = gst_caps_new_any();
 505             if (!caps)
 506                 return FALSE;
 507
 508             if (filter)
 509             {
 510                 temp = gst_caps_intersect(caps, filter);
 511                 gst_caps_unref(caps);
 512                 caps = temp;
 513             }
 514
 515             gst_query_set_caps_result(query, caps);
 516             gst_caps_unref(caps);
 517             return TRUE;
 518         }
 519         case GST_QUERY_ACCEPT_CAPS:
 520         {
 521             gboolean ret = TRUE;
 522             AM_MEDIA_TYPE mt;
 523             GstCaps *caps;
 524
 525             if (!pin->pin.pin.peer)
 526             {
 527                 gst_query_set_accept_caps_result(query, TRUE);
 528                 return TRUE;
 529             }
 530
 531             gst_query_parse_accept_caps(query, &caps);
 532             if (!amt_from_gst_caps(caps, &mt))
 533                 return FALSE;
 534
 535             if (!IsEqualGUID(&mt.majortype, &pin->pin.pin.mt.majortype)
 536                     || !IsEqualGUID(&mt.subtype, &pin->pin.pin.mt.subtype)
 537                     || !IsEqualGUID(&mt.formattype, &pin->pin.pin.mt.formattype))
 538                 ret = FALSE;
 539
 540             if (IsEqualGUID(&mt.majortype, &MEDIATYPE_Video))
 541             {
 542                 const VIDEOINFOHEADER *req_vih = (VIDEOINFOHEADER *)mt.pbFormat;
 543                 const VIDEOINFOHEADER *our_vih = (VIDEOINFOHEADER *)pin->pin.pin.mt.pbFormat;
 544
 545                 if (req_vih->bmiHeader.biWidth != our_vih->bmiHeader.biWidth
 546                         || req_vih->bmiHeader.biHeight != our_vih->bmiHeader.biHeight
 547                         || req_vih->bmiHeader.biBitCount != our_vih->bmiHeader.biBitCount
 548                         || req_vih->bmiHeader.biCompression != our_vih->bmiHeader.biCompression)
 549                     ret = FALSE;
 550             }
 551             else if (IsEqualGUID(&mt.majortype, &MEDIATYPE_Audio))
 552             {
 553                 const WAVEFORMATEX *req_wfx = (WAVEFORMATEX *)mt.pbFormat;
 554                 const WAVEFORMATEX *our_wfx = (WAVEFORMATEX *)pin->pin.pin.mt.pbFormat;
 555
 556                 if (req_wfx->nChannels != our_wfx->nChannels
 557                         || req_wfx->nSamplesPerSec != our_wfx->nSamplesPerSec
 558                         || req_wfx->wBitsPerSample != our_wfx->wBitsPerSample)
 559                     ret = FALSE;
 560             }
 561
 562             FreeMediaType(&mt);
 563
 564             if (!ret && WARN_ON(gstreamer))
 565             {
 566                 gchar *str = gst_caps_to_string(caps);
 567                 WARN("Rejecting caps \"%s\".\n", debugstr_a(str));
 568                 g_free(str);
 569             }
 570
 571             gst_query_set_accept_caps_result(query, ret);
 572             return TRUE;
 573         }
 574         default:
 575             return gst_pad_query_default (pad, parent, query);
 576     }
 577 }
 578
 579 static gboolean gst_base_src_perform_seek(struct gstdemux *This, GstEvent *event)
 580 {
 581     gboolean res = TRUE;
 582     gdouble rate;
 583     GstFormat seek_format;
 584     GstSeekFlags flags;
 585     GstSeekType cur_type, stop_type;
 586     gint64 cur, stop;
 587     gboolean flush;
 588     guint32 seqnum;
 589     GstEvent *tevent;
 590     BOOL thread = !!This->push_thread;
 591
 592     gst_event_parse_seek(event, &rate, &seek_format, &flags,
 593                          &cur_type, &cur, &stop_type, &stop);
 594
 595     if (seek_format != GST_FORMAT_BYTES)
 596     {
 597         FIXME("Unhandled format \"%s\".\n", gst_format_get_name(seek_format));
 598         return FALSE;
 599     }
 600
 601     flush = flags & GST_SEEK_FLAG_FLUSH;
 602     seqnum = gst_event_get_seqnum(event);
 603
 604     /* send flush start */
 605     if (flush) {
 606         tevent = gst_event_new_flush_start();
 607         gst_event_set_seqnum(tevent, seqnum);
 608         gst_pad_push_event(This->my_src, tevent);
 609         if (This->reader)
 610             IAsyncReader_BeginFlush(This->reader);
 611         if (thread)
 612             gst_pad_set_active(This->my_src, 1);
 613     }
 614
 615     This->nextofs = This->start = cur;
 616
 617     /* and prepare to continue streaming */
 618     if (flush) {
 619         tevent = gst_event_new_flush_stop(TRUE);
 620         gst_event_set_seqnum(tevent, seqnum);
 621         gst_pad_push_event(This->my_src, tevent);
 622         if (This->reader)
 623             IAsyncReader_EndFlush(This->reader);
 624         if (thread)
 625             gst_pad_set_active(This->my_src, 1);
 626     }
 627
 628     return res;
 629 }
 630
 631 static gboolean event_src(GstPad *pad, GstObject *parent, GstEvent *event)
 632 {
 633     struct gstdemux *This = gst_pad_get_element_private(pad);
 634
 635     TRACE("filter %p, type \"%s\".\n", This, GST_EVENT_TYPE_NAME(event));
 636
 637     switch (event->type) {
 638         case GST_EVENT_SEEK:
 639             return gst_base_src_perform_seek(This, event);
 640         case GST_EVENT_FLUSH_START:
 641             EnterCriticalSection(&This->filter.csFilter);
 642             if (This->reader)
 643                 IAsyncReader_BeginFlush(This->reader);
 644             LeaveCriticalSection(&This->filter.csFilter);
 645             break;
 646         case GST_EVENT_FLUSH_STOP:
 647             EnterCriticalSection(&This->filter.csFilter);
 648             if (This->reader)
 649                 IAsyncReader_EndFlush(This->reader);
 650             LeaveCriticalSection(&This->filter.csFilter);
 651             break;
 652         default:
 653             WARN("Ignoring \"%s\" event.\n", GST_EVENT_TYPE_NAME(event));
 654         case GST_EVENT_TAG:
 655         case GST_EVENT_QOS:
 656         case GST_EVENT_RECONFIGURE:
 657             return gst_pad_event_default(pad, parent, event);
 658     }
 659     return TRUE;
 660 }
 661
 662 static gboolean event_sink(GstPad *pad, GstObject *parent, GstEvent *event)
 663 {
 664     struct gstdemux_source *pin = gst_pad_get_element_private(pad);
 665
 666     TRACE("pin %p, type \"%s\".\n", pin, GST_EVENT_TYPE_NAME(event));
 667
 668     switch (event->type) {
 669         case GST_EVENT_SEGMENT: {
 670             gdouble rate, applied_rate;
 671             gint64 stop, pos;
 672             const GstSegment *segment;
 673
 674             gst_event_parse_segment(event, &segment);
 675
 676             pos = segment->position;
 677             stop = segment->stop;
 678             rate = segment->rate;
 679             applied_rate = segment->applied_rate;
 680
 681             if (segment->format != GST_FORMAT_TIME)
 682             {
 683                 FIXME("Unhandled format \"%s\".\n", gst_format_get_name(segment->format));
 684                 return TRUE;
 685             }
 686
 687             gst_segment_copy_into(segment, pin->segment);
 688
 689             pos /= 100;
 690
 691             if (stop > 0)
 692                 stop /= 100;
 693
 694             if (pin->pin.pin.peer)
 695                 IPin_NewSegment(pin->pin.pin.peer, pos, stop, rate*applied_rate);
 696
 697             return TRUE;
 698         }
 699         case GST_EVENT_EOS:
 700             if (pin->pin.pin.peer)
 701                 IPin_EndOfStream(pin->pin.pin.peer);
 702             else
 703                 SetEvent(pin->eos_event);
 704             return TRUE;
 705         case GST_EVENT_FLUSH_START:
 706             if (impl_from_strmbase_filter(pin->pin.pin.filter)->ignore_flush) {
 707                 /* gst-plugins-base prior to 1.7 contains a bug which causes
 708                  * our sink pins to receive a flush-start event when the
 709                  * decodebin changes from PAUSED to READY (including
 710                  * PLAYING->PAUSED->READY), but no matching flush-stop event is
 711                  * sent. See <gst-plugins-base.git:60bad4815db966a8e4). Here we
 712                  * unset the flushing flag to avoid the problem. */
 713                 TRACE("Working around gst <1.7 bug, ignoring FLUSH_START\n");
 714                 GST_PAD_UNSET_FLUSHING (pad);
 715                 return TRUE;
 716             }
 717             if (pin->pin.pin.peer)
 718                 IPin_BeginFlush(pin->pin.pin.peer);
 719             return TRUE;
 720         case GST_EVENT_FLUSH_STOP:
 721             gst_segment_init(pin->segment, GST_FORMAT_TIME);
 722             if (pin->pin.pin.peer)
 723                 IPin_EndFlush(pin->pin.pin.peer);
 724             return TRUE;
 725         case GST_EVENT_CAPS: {
 726             GstCaps *caps;
 727             gst_event_parse_caps(event, &caps);
 728             return setcaps_sink(pad, caps);
 729         }
 730         default:
 731             WARN("Ignoring \"%s\" event.\n", GST_EVENT_TYPE_NAME(event));
 732             return gst_pad_event_default(pad, parent, event);
 733     }
 734 }
 735
 736 static DWORD CALLBACK push_data(LPVOID iface)
 737 {
 738     LONGLONG maxlen, curlen;
 739     struct gstdemux *This = iface;
 740     GstMapInfo mapping;
 741     GstBuffer *buffer;
 742     HRESULT hr;
 743
 744     if (!(buffer = gst_buffer_new_allocate(NULL, 16384, NULL)))
 745     {
 746         ERR("Failed to allocate memory.\n");
 747         return 0;
 748     }
 749
 750     IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
 751
 752     if (!This->stop)
 753         IAsyncReader_Length(This->reader, &maxlen, &curlen);
 754     else
 755         maxlen = This->stop;
 756
 757     TRACE("Starting..\n");
 758     for (;;) {
 759         ULONG len;
 760         int ret;
 761
 762         if (This->nextofs >= maxlen)
 763             break;
 764         len = min(16384, maxlen - This->nextofs);
 765
 766         if (!gst_buffer_map_range(buffer, -1, len, &mapping, GST_MAP_WRITE))
 767         {
 768             ERR("Failed to map buffer.\n");
 769             break;
 770         }
 771         hr = IAsyncReader_SyncRead(This->reader, This->nextofs, len, mapping.data);
 772         gst_buffer_unmap(buffer, &mapping);
 773         if (hr != S_OK)
 774         {
 775             ERR("Failed to read data, hr %#x.\n", hr);
 776             break;
 777         }
 778
 779         This->nextofs += len;
 780
 781         buffer->duration = buffer->pts = -1;
 782         ret = gst_pad_push(This->my_src, buffer);
 783         if (ret >= 0)
 784             hr = S_OK;
 785         else
 786             ERR("Sending returned: %i\n", ret);
 787         if (ret == GST_FLOW_ERROR)
 788             hr = E_FAIL;
 789         else if (ret == GST_FLOW_FLUSHING)
 790             hr = VFW_E_WRONG_STATE;
 791         if (hr != S_OK)
 792             break;
 793     }
 794
 795     gst_buffer_unref(buffer);
 796
 797     gst_pad_push_event(This->my_src, gst_event_new_eos());
 798
 799     TRACE("Stopping.. %08x\n", hr);
 800
 801     IBaseFilter_Release(&This->filter.IBaseFilter_iface);
 802
 803     return 0;
 804 }
 805
 806 static GstFlowReturn got_data_sink(GstPad *pad, GstObject *parent, GstBuffer *buf)
 807 {
 808     struct gstdemux_source *pin = gst_pad_get_element_private(pad);
 809     struct gstdemux *This = impl_from_strmbase_filter(pin->pin.pin.filter);
 810     HRESULT hr;
 811     BYTE *ptr = NULL;
 812     IMediaSample *sample;
 813     GstMapInfo info;
 814
 815     TRACE("%p %p\n", pad, buf);
 816
 817     if (This->initial) {
 818         gst_buffer_unref(buf);
 819         return GST_FLOW_OK;
 820     }
 821
 822     hr = BaseOutputPinImpl_GetDeliveryBuffer(&pin->pin, &sample, NULL, NULL, 0);
 823
 824     if (hr == VFW_E_NOT_CONNECTED) {
 825         gst_buffer_unref(buf);
 826         return GST_FLOW_NOT_LINKED;
 827     }
 828
 829     if (FAILED(hr)) {
 830         gst_buffer_unref(buf);
 831         ERR("Could not get a delivery buffer (%x), returning GST_FLOW_FLUSHING\n", hr);
 832         return GST_FLOW_FLUSHING;
 833     }
 834
 835     gst_buffer_map(buf, &info, GST_MAP_READ);
 836
 837     hr = IMediaSample_SetActualDataLength(sample, info.size);
 838     if(FAILED(hr)){
 839         WARN("SetActualDataLength failed: %08x\n", hr);
 840         return GST_FLOW_FLUSHING;
 841     }
 842
 843     IMediaSample_GetPointer(sample, &ptr);
 844
 845     memcpy(ptr, info.data, info.size);
 846
 847     gst_buffer_unmap(buf, &info);
 848
 849     if (GST_BUFFER_PTS_IS_VALID(buf)) {
 850         REFERENCE_TIME rtStart = gst_segment_to_running_time(pin->segment, GST_FORMAT_TIME, buf->pts);
 851         if (rtStart >= 0)
 852             rtStart /= 100;
 853
 854         if (GST_BUFFER_DURATION_IS_VALID(buf)) {
 855             REFERENCE_TIME tStart = buf->pts / 100;
 856             REFERENCE_TIME tStop = (buf->pts + buf->duration) / 100;
 857             REFERENCE_TIME rtStop;
 858             rtStop = gst_segment_to_running_time(pin->segment, GST_FORMAT_TIME, buf->pts + buf->duration);
 859             if (rtStop >= 0)
 860                 rtStop /= 100;
 861             TRACE("Current time on %p: %i to %i ms\n", pin, (int)(rtStart / 10000), (int)(rtStop / 10000));
 862             IMediaSample_SetTime(sample, &rtStart, rtStop >= 0 ? &rtStop : NULL);
 863             IMediaSample_SetMediaTime(sample, &tStart, &tStop);
 864         } else {
 865             IMediaSample_SetTime(sample, rtStart >= 0 ? &rtStart : NULL, NULL);
 866             IMediaSample_SetMediaTime(sample, NULL, NULL);
 867         }
 868     } else {
 869         IMediaSample_SetTime(sample, NULL, NULL);
 870         IMediaSample_SetMediaTime(sample, NULL, NULL);
 871     }
 872
 873     IMediaSample_SetDiscontinuity(sample, GST_BUFFER_FLAG_IS_SET(buf, GST_BUFFER_FLAG_DISCONT));
 874     IMediaSample_SetPreroll(sample, GST_BUFFER_FLAG_IS_SET(buf, GST_BUFFER_FLAG_LIVE));
 875     IMediaSample_SetSyncPoint(sample, !GST_BUFFER_FLAG_IS_SET(buf, GST_BUFFER_FLAG_DELTA_UNIT));
 876
 877     if (!pin->pin.pin.peer)
 878         hr = VFW_E_NOT_CONNECTED;
 879     else
 880         hr = IMemInputPin_Receive(pin->pin.pMemInputPin, sample);
 881
 882     TRACE("sending sample returned: %08x\n", hr);
 883
 884     gst_buffer_unref(buf);
 885     IMediaSample_Release(sample);
 886
 887     if (hr == VFW_E_NOT_CONNECTED)
 888         return GST_FLOW_NOT_LINKED;
 889
 890     if (FAILED(hr))
 891         return GST_FLOW_FLUSHING;
 892
 893     return GST_FLOW_OK;
 894 }
 895
 896 static GstFlowReturn request_buffer_src(GstPad *pad, GstObject *parent, guint64 ofs, guint len, GstBuffer **buf)
 897 {
 898     struct gstdemux *This = gst_pad_get_element_private(pad);
 899     HRESULT hr;
 900     GstMapInfo info;
 901
 902     TRACE("pad %p, offset %s, length %u, buffer %p.\n", pad, wine_dbgstr_longlong(ofs), len, *buf);
 903
 904     if (ofs == GST_BUFFER_OFFSET_NONE)
 905         ofs = This->nextpullofs;
 906     if (ofs >= This->filesize) {
 907         WARN("Reading past eof: %s, %u\n", wine_dbgstr_longlong(ofs), len);
 908         return GST_FLOW_EOS;
 909     }
 910     if (len + ofs > This->filesize)
 911         len = This->filesize - ofs;
 912     This->nextpullofs = ofs + len;
 913
 914     if (!*buf)
 915         *buf = gst_buffer_new_and_alloc(len);
 916     gst_buffer_map(*buf, &info, GST_MAP_WRITE);
 917     hr = IAsyncReader_SyncRead(This->reader, ofs, len, info.data);
 918     gst_buffer_unmap(*buf, &info);
 919     if (FAILED(hr)) {
 920         ERR("Returned %08x\n", hr);
 921         return GST_FLOW_ERROR;
 922     }
 923
 924     GST_BUFFER_OFFSET(*buf) = ofs;
 925     return GST_FLOW_OK;
 926 }
 927
 928 static DWORD CALLBACK push_data_init(LPVOID iface)
 929 {
 930     struct gstdemux *This = iface;
 931     DWORD64 ofs = 0;
 932
 933     TRACE("Starting..\n");
 934     for (;;) {
 935         GstBuffer *buf;
 936         GstFlowReturn ret = request_buffer_src(This->my_src, NULL, ofs, 4096, &buf);
 937         if (ret < 0) {
 938             ERR("Obtaining buffer returned: %i\n", ret);
 939             break;
 940         }
 941         ret = gst_pad_push(This->my_src, buf);
 942         ofs += 4096;
 943         if (ret)
 944             TRACE("Sending returned: %i\n", ret);
 945         if (ret < 0)
 946             break;
 947     }
 948     TRACE("Stopping..\n");
 949     return 0;
 950 }
 951
 952 static void removed_decoded_pad(GstElement *bin, GstPad *pad, gpointer user)
 953 {
 954     struct gstdemux *filter = user;
 955     unsigned int i;
 956     char *name;
 957
 958     TRACE("filter %p, bin %p, pad %p.\n", filter, bin, pad);
 959
 960     for (i = 0; i < filter->source_count; ++i)
 961     {
 962         struct gstdemux_source *pin = filter->sources[i];
 963
 964         if (pin->their_src == pad)
 965         {
 966             if (pin->post_sink)
 967                 gst_pad_unlink(pin->their_src, pin->post_sink);
 968             else
 969                 gst_pad_unlink(pin->their_src, pin->my_sink);
 970             gst_object_unref(pin->their_src);
 971             pin->their_src = NULL;
 972             return;
 973         }
 974     }
 975
 976     name = gst_pad_get_name(pad);
 977     WARN("No pin matching pad %s found.\n", debugstr_a(name));
 978     g_free(name);
 979 }
 980
 981 static void init_new_decoded_pad(GstElement *bin, GstPad *pad, struct gstdemux *This)
 982 {
 983     static const WCHAR formatW[] = {'S','t','r','e','a','m',' ','%','0','2','u',0};
 984     const char *typename;
 985     char *name;
 986     GstCaps *caps;
 987     GstStructure *arg;
 988     struct gstdemux_source *pin;
 989     int ret;
 990     WCHAR nameW[128];
 991
 992     TRACE("%p %p %p\n", This, bin, pad);
 993
 994     sprintfW(nameW, formatW, This->source_count);
 995
 996     name = gst_pad_get_name(pad);
 997     TRACE("Name: %s\n", name);
 998     g_free(name);
 999
1000     caps = gst_pad_query_caps(pad, NULL);
1001     caps = gst_caps_make_writable(caps);
1002     arg = gst_caps_get_structure(caps, 0);
1003     typename = gst_structure_get_name(arg);
1004
1005     if (!(pin = create_pin(This, nameW)))
1006     {
1007         ERR("Failed to allocate memory.\n");
1008         goto out;
1009     }
1010
1011     if (!strcmp(typename, "video/x-raw"))
1012     {
1013         GstElement *vconv, *flip;
1014
1015         /* decodebin considers many YUV formats to be "raw", but some quartz
1016          * filters can't handle those. Also, videoflip can't handle all "raw"
1017          * formats either. Add a videoconvert to swap color spaces. */
1018         if (!(vconv = gst_element_factory_make("videoconvert", NULL)))
1019         {
1020             ERR("Failed to create videoconvert, are %u-bit GStreamer \"base\" plugins installed?\n",
1021                     8 * (int)sizeof(void *));
1022             goto out;
1023         }
1024
1025         /* GStreamer outputs RGB video top-down, but DirectShow expects bottom-up. */
1026         if (!(flip = gst_element_factory_make("videoflip", NULL)))
1027         {
1028             ERR("Failed to create videoflip, are %u-bit GStreamer \"good\" plugins installed?\n",
1029                     8 * (int)sizeof(void *));
1030             goto out;
1031         }
1032
1033         gst_bin_add(GST_BIN(This->container), vconv); /* bin takes ownership */
1034         gst_element_sync_state_with_parent(vconv);
1035         gst_bin_add(GST_BIN(This->container), flip); /* bin takes ownership */
1036         gst_element_sync_state_with_parent(flip);
1037
1038         gst_element_link(vconv, flip);
1039
1040         pin->post_sink = gst_element_get_static_pad(vconv, "sink");
1041         pin->post_src = gst_element_get_static_pad(flip, "src");
1042         pin->flip = flip;
1043     }
1044     else if (!strcmp(typename, "audio/x-raw"))
1045     {
1046         GstElement *convert;
1047
1048         /* Currently our dsound can't handle 64-bit formats or all
1049          * surround-sound configurations. Native dsound can't always handle
1050          * 64-bit formats either. Add an audioconvert to allow changing bit
1051          * depth and channel count. */
1052         if (!(convert = gst_element_factory_make("audioconvert", NULL)))
1053         {
1054             ERR("Failed to create audioconvert, are %u-bit GStreamer \"base\" plugins installed?\n",
1055                     8 * (int)sizeof(void *));
1056             goto out;
1057         }
1058
1059         gst_bin_add(GST_BIN(This->container), convert);
1060         gst_element_sync_state_with_parent(convert);
1061
1062         pin->post_sink = gst_element_get_static_pad(convert, "sink");
1063         pin->post_src = gst_element_get_static_pad(convert, "src");
1064     }
1065
1066     if (pin->post_sink)
1067     {
1068         if ((ret = gst_pad_link(pad, pin->post_sink)) < 0)
1069         {
1070             ERR("Failed to link decodebin source pad to post-processing elements, error %s.\n",
1071                     gst_pad_link_get_name(ret));
1072             gst_object_unref(pin->post_sink);
1073             pin->post_sink = NULL;
1074             goto out;
1075         }
1076
1077         if ((ret = gst_pad_link(pin->post_src, pin->my_sink)) < 0)
1078         {
1079             ERR("Failed to link post-processing elements to our sink pad, error %s.\n",
1080                     gst_pad_link_get_name(ret));
1081             gst_object_unref(pin->post_src);
1082             pin->post_src = NULL;
1083             gst_object_unref(pin->post_sink);
1084             pin->post_sink = NULL;
1085             goto out;
1086         }
1087     }
1088     else if ((ret = gst_pad_link(pad, pin->my_sink)) < 0)
1089     {
1090         ERR("Failed to link decodebin source pad to our sink pad, error %s.\n",
1091                 gst_pad_link_get_name(ret));
1092         goto out;
1093     }
1094
1095     gst_pad_set_active(pin->my_sink, 1);
1096     gst_object_ref(pin->their_src = pad);
1097 out:
1098     gst_caps_unref(caps);
1099 }
1100
1101 static void existing_new_pad(GstElement *bin, GstPad *pad, gpointer user)
1102 {
1103     struct gstdemux *This = user;
1104     unsigned int i;
1105     int ret;
1106
1107     TRACE("%p %p %p\n", This, bin, pad);
1108
1109     if (gst_pad_is_linked(pad))
1110         return;
1111
1112     /* Still holding our own lock */
1113     if (This->initial) {
1114         init_new_decoded_pad(bin, pad, This);
1115         return;
1116     }
1117
1118     for (i = 0; i < This->source_count; ++i)
1119     {
1120         struct gstdemux_source *pin = This->sources[i];
1121         if (!pin->their_src) {
1122             gst_segment_init(pin->segment, GST_FORMAT_TIME);
1123
1124             if (pin->post_sink)
1125                 ret = gst_pad_link(pad, pin->post_sink);
1126             else
1127                 ret = gst_pad_link(pad, pin->my_sink);
1128
1129             if (ret >= 0) {
1130                 pin->their_src = pad;
1131                 gst_object_ref(pin->their_src);
1132                 TRACE("Relinked\n");
1133                 return;
1134             }
1135         }
1136     }
1137     init_new_decoded_pad(bin, pad, This);
1138 }
1139
1140 static gboolean query_function(GstPad *pad, GstObject *parent, GstQuery *query)
1141 {
1142     struct gstdemux *This = gst_pad_get_element_private(pad);
1143     GstFormat format;
1144
1145     TRACE("filter %p, type %s.\n", This, GST_QUERY_TYPE_NAME(query));
1146
1147     switch (GST_QUERY_TYPE(query)) {
1148         case GST_QUERY_DURATION:
1149             gst_query_parse_duration(query, &format, NULL);
1150             if (format == GST_FORMAT_PERCENT)
1151             {
1152                 gst_query_set_duration(query, GST_FORMAT_PERCENT, GST_FORMAT_PERCENT_MAX);
1153                 return TRUE;
1154             }
1155             else if (format == GST_FORMAT_BYTES)
1156             {
1157                 gst_query_set_duration(query, GST_FORMAT_BYTES, This->filesize);
1158                 return TRUE;
1159             }
1160             return FALSE;
1161         case GST_QUERY_SEEKING:
1162             gst_query_parse_seeking (query, &format, NULL, NULL, NULL);
1163             if (format != GST_FORMAT_BYTES)
1164             {
1165                 WARN("Cannot seek using format \"%s\".\n", gst_format_get_name(format));
1166                 return FALSE;
1167             }
1168             gst_query_set_seeking(query, GST_FORMAT_BYTES, 1, 0, This->filesize);
1169             return TRUE;
1170         case GST_QUERY_SCHEDULING:
1171             gst_query_set_scheduling(query, GST_SCHEDULING_FLAG_SEEKABLE, 1, -1, 0);
1172             gst_query_add_scheduling_mode(query, GST_PAD_MODE_PUSH);
1173             gst_query_add_scheduling_mode(query, GST_PAD_MODE_PULL);
1174             return TRUE;
1175         default:
1176             WARN("Unhandled query type %s.\n", GST_QUERY_TYPE_NAME(query));
1177             return FALSE;
1178     }
1179 }
1180
1181 static gboolean activate_push(GstPad *pad, gboolean activate)
1182 {
1183     struct gstdemux *This = gst_pad_get_element_private(pad);
1184
1185     EnterCriticalSection(&This->filter.csFilter);
1186     if (!activate) {
1187         TRACE("Deactivating\n");
1188         if (!This->initial)
1189             IAsyncReader_BeginFlush(This->reader);
1190         if (This->push_thread) {
1191             WaitForSingleObject(This->push_thread, -1);
1192             CloseHandle(This->push_thread);
1193             This->push_thread = NULL;
1194         }
1195         if (!This->initial)
1196             IAsyncReader_EndFlush(This->reader);
1197         if (This->filter.state == State_Stopped)
1198             This->nextofs = This->start;
1199     } else if (!This->push_thread) {
1200         TRACE("Activating\n");
1201         if (This->initial)
1202             This->push_thread = CreateThread(NULL, 0, push_data_init, This, 0, NULL);
1203         else
1204             This->push_thread = CreateThread(NULL, 0, push_data, This, 0, NULL);
1205     }
1206     LeaveCriticalSection(&This->filter.csFilter);
1207     return TRUE;
1208 }
1209
1210 static gboolean activate_mode(GstPad *pad, GstObject *parent, GstPadMode mode, gboolean activate)
1211 {
1212     struct gstdemux *filter = gst_pad_get_element_private(pad);
1213
1214     TRACE("%s source pad for filter %p in %s mode.\n",
1215             activate ? "Activating" : "Deactivating", filter, gst_pad_mode_get_name(mode));
1216
1217     switch (mode) {
1218       case GST_PAD_MODE_PULL:
1219         return TRUE;
1220       case GST_PAD_MODE_PUSH:
1221         return activate_push(pad, activate);
1222       default:
1223         return FALSE;
1224     }
1225     return FALSE;
1226 }
1227
1228 static void no_more_pads(GstElement *decodebin, gpointer user)
1229 {
1230     struct gstdemux *filter = user;
1231     TRACE("filter %p.\n", filter);
1232     SetEvent(filter->no_more_pads_event);
1233 }
1234
1235 static GstAutoplugSelectResult autoplug_blacklist(GstElement *bin, GstPad *pad, GstCaps *caps, GstElementFactory *fact, gpointer user)
1236 {
1237     const char *name = gst_element_factory_get_longname(fact);
1238
1239     if (strstr(name, "Player protection")) {
1240         WARN("Blacklisted a/52 decoder because it only works in Totem\n");
1241         return GST_AUTOPLUG_SELECT_SKIP;
1242     }
1243     if (!strcmp(name, "Fluendo Hardware Accelerated Video Decoder")) {
1244         WARN("Disabled video acceleration since it breaks in wine\n");
1245         return GST_AUTOPLUG_SELECT_SKIP;
1246     }
1247     TRACE("using \"%s\"\n", name);
1248     return GST_AUTOPLUG_SELECT_TRY;
1249 }
1250
1251 static GstBusSyncReply watch_bus(GstBus *bus, GstMessage *msg, gpointer data)
1252 {
1253     struct gstdemux *filter = data;
1254     GError *err = NULL;
1255     gchar *dbg_info = NULL;
1256
1257     TRACE("filter %p, message type %s.\n", filter, GST_MESSAGE_TYPE_NAME(msg));
1258
1259     switch (msg->type)
1260     {
1261     case GST_MESSAGE_ERROR:
1262         gst_message_parse_error(msg, &err, &dbg_info);
1263         ERR("%s: %s\n", GST_OBJECT_NAME(msg->src), err->message);
1264         ERR("%s\n", dbg_info);
1265         g_error_free(err);
1266         g_free(dbg_info);
1267         SetEvent(filter->error_event);
1268         break;
1269     case GST_MESSAGE_WARNING:
1270         gst_message_parse_warning(msg, &err, &dbg_info);
1271         WARN("%s: %s\n", GST_OBJECT_NAME(msg->src), err->message);
1272         WARN("%s\n", dbg_info);
1273         g_error_free(err);
1274         g_free(dbg_info);
1275         break;
1276     case GST_MESSAGE_DURATION_CHANGED:
1277         SetEvent(filter->duration_event);
1278         break;
1279     default:
1280         break;
1281     }
1282     return GST_BUS_DROP;
1283 }
1284
1285 static void unknown_type(GstElement *bin, GstPad *pad, GstCaps *caps, gpointer user)
1286 {
1287     gchar *strcaps = gst_caps_to_string(caps);
1288     ERR("Could not find a filter for caps: %s\n", debugstr_a(strcaps));
1289     g_free(strcaps);
1290 }
1291
1292 static HRESULT GST_Connect(struct gstdemux *This, IPin *pConnectPin)
1293 {
1294     LONGLONG avail;
1295     GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE(
1296         "quartz_src",
1297         GST_PAD_SRC,
1298         GST_PAD_ALWAYS,
1299         GST_STATIC_CAPS_ANY);
1300
1301     IAsyncReader_Length(This->reader, &This->filesize, &avail);
1302
1303     if (!This->bus) {
1304         This->bus = gst_bus_new();
1305         gst_bus_set_sync_handler(This->bus, watch_bus_wrapper, This, NULL);
1306     }
1307
1308     This->container = gst_bin_new(NULL);
1309     gst_element_set_bus(This->container, This->bus);
1310
1311     This->my_src = gst_pad_new_from_static_template(&src_template, "quartz-src");
1312     gst_pad_set_getrange_function(This->my_src, request_buffer_src_wrapper);
1313     gst_pad_set_query_function(This->my_src, query_function_wrapper);
1314     gst_pad_set_activatemode_function(This->my_src, activate_mode_wrapper);
1315     gst_pad_set_event_function(This->my_src, event_src_wrapper);
1316     gst_pad_set_element_private (This->my_src, This);
1317
1318     This->start = This->nextofs = This->nextpullofs = This->stop = 0;
1319
1320     This->initial = TRUE;
1321     if (!This->init_gst(This))
1322         return E_FAIL;
1323     This->initial = FALSE;
1324
1325     This->nextofs = This->nextpullofs = 0;
1326     return S_OK;
1327 }
1328
1329 static LONGLONG query_duration(GstPad *pad)
1330 {
1331     gint64 duration, byte_length;
1332
1333     if (gst_pad_query_duration(pad, GST_FORMAT_TIME, &duration))
1334         return duration / 100;
1335
1336     WARN("Failed to query time duration; trying to convert from byte length.\n");
1337
1338     /* To accurately get a duration for the stream, we want to only consider the
1339      * length of that stream. Hence, query for the pad duration, instead of
1340      * using the file duration. */
1341     if (gst_pad_query_duration(pad, GST_FORMAT_BYTES, &byte_length)
1342             && gst_pad_query_convert(pad, GST_FORMAT_BYTES, byte_length, GST_FORMAT_TIME, &duration))
1343         return duration / 100;
1344
1345     ERR("Failed to query duration.\n");
1346     return 0;
1347 }
1348
1349 static inline struct gstdemux_source *impl_from_IMediaSeeking(IMediaSeeking *iface)
1350 {
1351     return CONTAINING_RECORD(iface, struct gstdemux_source, seek.IMediaSeeking_iface);
1352 }
1353
1354 static struct strmbase_pin *gstdemux_get_pin(struct strmbase_filter *base, unsigned int index)
1355 {
1356     struct gstdemux *filter = impl_from_strmbase_filter(base);
1357
1358     if (filter->enum_sink_first)
1359     {
1360         if (!index)
1361             return &filter->sink.pin;
1362         else if (index <= filter->source_count)
1363             return &filter->sources[index - 1]->pin.pin;
1364     }
1365     else
1366     {
1367         if (index < filter->source_count)
1368             return &filter->sources[index]->pin.pin;
1369         else if (index == filter->source_count)
1370             return &filter->sink.pin;
1371     }
1372     return NULL;
1373 }
1374
1375 static void gstdemux_destroy(struct strmbase_filter *iface)
1376 {
1377     struct gstdemux *filter = impl_from_strmbase_filter(iface);
1378     HRESULT hr;
1379
1380     CloseHandle(filter->no_more_pads_event);
1381     CloseHandle(filter->duration_event);
1382     CloseHandle(filter->error_event);
1383
1384     /* Don't need to clean up output pins, disconnecting input pin will do that */
1385     if (filter->sink.pin.peer)
1386     {
1387         hr = IPin_Disconnect(filter->sink.pin.peer);
1388         assert(hr == S_OK);
1389         hr = IPin_Disconnect(&filter->sink.pin.IPin_iface);
1390         assert(hr == S_OK);
1391     }
1392
1393     if (filter->reader)
1394         IAsyncReader_Release(filter->reader);
1395     filter->reader = NULL;
1396
1397     if (filter->bus)
1398     {
1399         gst_bus_set_sync_handler(filter->bus, NULL, NULL, NULL);
1400         gst_object_unref(filter->bus);
1401     }
1402     strmbase_sink_cleanup(&filter->sink);
1403     strmbase_filter_cleanup(&filter->filter);
1404     heap_free(filter);
1405 }
1406
1407 static HRESULT gstdemux_init_stream(struct strmbase_filter *iface)
1408 {
1409     struct gstdemux *filter = impl_from_strmbase_filter(iface);
1410     HRESULT hr = VFW_E_NOT_CONNECTED, pin_hr;
1411     const SourceSeeking *seeking;
1412     GstStateChangeReturn ret;
1413     unsigned int i;
1414
1415     if (!filter->container)
1416         return VFW_E_NOT_CONNECTED;
1417
1418     for (i = 0; i < filter->source_count; ++i)
1419     {
1420         if (SUCCEEDED(pin_hr = BaseOutputPinImpl_Active(&filter->sources[i]->pin)))
1421             hr = pin_hr;
1422     }
1423
1424     if (FAILED(hr))
1425         return hr;
1426
1427     if (filter->no_more_pads_event)
1428         ResetEvent(filter->no_more_pads_event);
1429
1430     if ((ret = gst_element_set_state(filter->container, GST_STATE_PAUSED)) == GST_STATE_CHANGE_FAILURE)
1431     {
1432         ERR("Failed to pause stream.\n");
1433         return E_FAIL;
1434     }
1435
1436     /* Make sure that all of our pads are connected before returning, lest we
1437      * e.g. try to seek and fail. */
1438     if (filter->no_more_pads_event)
1439         WaitForSingleObject(filter->no_more_pads_event, INFINITE);
1440
1441     seeking = &filter->sources[0]->seek;
1442
1443     /* GStreamer can't seek while stopped, and it resets position to the
1444      * beginning of the stream every time it is stopped. */
1445     if (seeking->llCurrent)
1446     {
1447         GstSeekType stop_type = GST_SEEK_TYPE_NONE;
1448
1449         if (seeking->llStop && seeking->llStop != seeking->llDuration)
1450             stop_type = GST_SEEK_TYPE_SET;
1451
1452         gst_pad_push_event(filter->sources[0]->my_sink, gst_event_new_seek(
1453                 seeking->dRate, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH,
1454                 GST_SEEK_TYPE_SET, seeking->llCurrent * 100,
1455                 stop_type, seeking->llStop * 100));
1456     }
1457
1458     return hr;
1459 }
1460
1461 static HRESULT gstdemux_start_stream(struct strmbase_filter *iface, REFERENCE_TIME time)
1462 {
1463     struct gstdemux *filter = impl_from_strmbase_filter(iface);
1464     GstStateChangeReturn ret;
1465
1466     if (!filter->container)
1467         return VFW_E_NOT_CONNECTED;
1468
1469     if ((ret = gst_element_set_state(filter->container, GST_STATE_PLAYING)) == GST_STATE_CHANGE_FAILURE)
1470     {
1471         ERR("Failed to play stream.\n");
1472         return E_FAIL;
1473     }
1474     else if (ret == GST_STATE_CHANGE_ASYNC)
1475         return S_FALSE;
1476     return S_OK;
1477 }
1478
1479 static HRESULT gstdemux_stop_stream(struct strmbase_filter *iface)
1480 {
1481     struct gstdemux *filter = impl_from_strmbase_filter(iface);
1482     GstStateChangeReturn ret;
1483
1484     if (!filter->container)
1485         return VFW_E_NOT_CONNECTED;
1486
1487     if ((ret = gst_element_set_state(filter->container, GST_STATE_PAUSED)) == GST_STATE_CHANGE_FAILURE)
1488     {
1489         ERR("Failed to pause stream.\n");
1490         return E_FAIL;
1491     }
1492     else if (ret == GST_STATE_CHANGE_ASYNC)
1493         return S_FALSE;
1494     return S_OK;
1495 }
1496
1497 static HRESULT gstdemux_cleanup_stream(struct strmbase_filter *iface)
1498 {
1499     struct gstdemux *filter = impl_from_strmbase_filter(iface);
1500     GstStateChangeReturn ret;
1501     unsigned int i;
1502
1503     if (!filter->container)
1504         return S_OK;
1505
1506     filter->ignore_flush = TRUE;
1507     if ((ret = gst_element_set_state(filter->container, GST_STATE_READY)) == GST_STATE_CHANGE_FAILURE)
1508     {
1509         ERR("Failed to pause stream.\n");
1510         return E_FAIL;
1511     }
1512     gst_element_get_state(filter->container, NULL, NULL, GST_CLOCK_TIME_NONE);
1513     filter->ignore_flush = FALSE;
1514
1515     for (i = 0; i < filter->source_count; ++i)
1516     {
1517         if (filter->sources[i]->pin.pin.peer)
1518             IMemAllocator_Decommit(filter->sources[i]->pin.pAllocator);
1519     }
1520
1521     return S_OK;
1522 }
1523
1524 static HRESULT gstdemux_wait_state(struct strmbase_filter *iface, DWORD timeout)
1525 {
1526     struct gstdemux *filter = impl_from_strmbase_filter(iface);
1527     GstStateChangeReturn ret;
1528
1529     if (!filter->container)
1530         return S_OK;
1531
1532     ret = gst_element_get_state(filter->container, NULL, NULL,
1533             timeout == INFINITE ? GST_CLOCK_TIME_NONE : timeout * 1000000);
1534     if (ret == GST_STATE_CHANGE_FAILURE)
1535     {
1536         ERR("Failed to get state.\n");
1537         return E_FAIL;
1538     }
1539     else if (ret == GST_STATE_CHANGE_ASYNC)
1540         return VFW_S_STATE_INTERMEDIATE;
1541     return S_OK;
1542 }
1543
1544 static const struct strmbase_filter_ops filter_ops =
1545 {
1546     .filter_get_pin = gstdemux_get_pin,
1547     .filter_destroy = gstdemux_destroy,
1548     .filter_init_stream = gstdemux_init_stream,
1549     .filter_start_stream = gstdemux_start_stream,
1550     .filter_stop_stream = gstdemux_stop_stream,
1551     .filter_cleanup_stream = gstdemux_cleanup_stream,
1552     .filter_wait_state = gstdemux_wait_state,
1553 };
1554
1555 static inline struct gstdemux *impl_from_strmbase_sink(struct strmbase_sink *iface)
1556 {
1557     return CONTAINING_RECORD(iface, struct gstdemux, sink);
1558 }
1559
1560 static HRESULT sink_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt)
1561 {
1562     if (IsEqualGUID(&mt->majortype, &MEDIATYPE_Stream))
1563         return S_OK;
1564     return S_FALSE;
1565 }
1566
1567 static HRESULT gstdemux_sink_connect(struct strmbase_sink *iface, IPin *peer, const AM_MEDIA_TYPE *pmt)
1568 {
1569     struct gstdemux *filter = impl_from_strmbase_sink(iface);
1570     HRESULT hr = S_OK;
1571
1572     mark_wine_thread();
1573
1574     filter->reader = NULL;
1575     if (FAILED(hr = IPin_QueryInterface(peer, &IID_IAsyncReader, (void **)&filter->reader)))
1576         return hr;
1577
1578     if (FAILED(hr = GST_Connect(filter, peer)))
1579         goto err;
1580
1581     return S_OK;
1582 err:
1583     GST_RemoveOutputPins(filter);
1584     IAsyncReader_Release(filter->reader);
1585     filter->reader = NULL;
1586     return hr;
1587 }
1588
1589 static void gstdemux_sink_disconnect(struct strmbase_sink *iface)
1590 {
1591     struct gstdemux *filter = impl_from_strmbase_sink(iface);
1592
1593     mark_wine_thread();
1594
1595     GST_RemoveOutputPins(filter);
1596 }
1597
1598 static const struct strmbase_sink_ops sink_ops =
1599 {
1600     .base.pin_query_accept = sink_query_accept,
1601     .sink_connect = gstdemux_sink_connect,
1602     .sink_disconnect = gstdemux_sink_disconnect,
1603 };
1604
1605 static BOOL gstdecoder_init_gst(struct gstdemux *filter)
1606 {
1607     GstElement *element = gst_element_factory_make("decodebin", NULL);
1608     unsigned int i;
1609     int ret;
1610
1611     if (!element)
1612     {
1613         ERR("Failed to create decodebin; are %u-bit GStreamer \"base\" plugins installed?\n",
1614                 8 * (int)sizeof(void*));
1615         return FALSE;
1616     }
1617
1618     gst_bin_add(GST_BIN(filter->container), element);
1619
1620     g_signal_connect(element, "pad-added", G_CALLBACK(existing_new_pad_wrapper), filter);
1621     g_signal_connect(element, "pad-removed", G_CALLBACK(removed_decoded_pad_wrapper), filter);
1622     g_signal_connect(element, "autoplug-select", G_CALLBACK(autoplug_blacklist_wrapper), filter);
1623     g_signal_connect(element, "unknown-type", G_CALLBACK(unknown_type_wrapper), filter);
1624     g_signal_connect(element, "no-more-pads", G_CALLBACK(no_more_pads_wrapper), filter);
1625
1626     filter->their_sink = gst_element_get_static_pad(element, "sink");
1627     ResetEvent(filter->no_more_pads_event);
1628
1629     if ((ret = gst_pad_link(filter->my_src, filter->their_sink)) < 0)
1630     {
1631         ERR("Failed to link pads, error %d.\n", ret);
1632         return FALSE;
1633     }
1634
1635     gst_element_set_state(filter->container, GST_STATE_PLAYING);
1636     ret = gst_element_get_state(filter->container, NULL, NULL, -1);
1637     if (ret == GST_STATE_CHANGE_FAILURE)
1638     {
1639         ERR("Failed to play stream.\n");
1640         return FALSE;
1641     }
1642
1643     WaitForSingleObject(filter->no_more_pads_event, INFINITE);
1644
1645     for (i = 0; i < filter->source_count; ++i)
1646     {
1647         struct gstdemux_source *pin = filter->sources[i];
1648         const HANDLE events[2] = {pin->caps_event, filter->error_event};
1649
1650         pin->seek.llDuration = pin->seek.llStop = query_duration(pin->their_src);
1651         pin->seek.llCurrent = 0;
1652         if (WaitForMultipleObjects(2, events, FALSE, INFINITE))
1653             return FALSE;
1654     }
1655
1656     filter->ignore_flush = TRUE;
1657     gst_element_set_state(filter->container, GST_STATE_READY);
1658     gst_element_get_state(filter->container, NULL, NULL, -1);
1659     filter->ignore_flush = FALSE;
1660
1661     return TRUE;
1662 }
1663
1664 static HRESULT gstdecoder_source_query_accept(struct gstdemux_source *pin, const AM_MEDIA_TYPE *mt)
1665 {
1666     /* At least make sure we can convert it to GstCaps. */
1667     GstCaps *caps = amt_to_gst_caps(mt);
1668
1669     if (!caps)
1670         return S_FALSE;
1671     gst_caps_unref(caps);
1672     return S_OK;
1673 }
1674
1675 static HRESULT gstdecoder_source_get_media_type(struct gstdemux_source *pin,
1676         unsigned int index, AM_MEDIA_TYPE *mt)
1677 {
1678     static const GstVideoFormat video_formats[] =
1679     {
1680         /* Roughly ordered by preference from videoflip. */
1681         GST_VIDEO_FORMAT_AYUV,
1682         GST_VIDEO_FORMAT_BGRA,
1683         GST_VIDEO_FORMAT_BGRx,
1684         GST_VIDEO_FORMAT_BGR,
1685         GST_VIDEO_FORMAT_I420,
1686         GST_VIDEO_FORMAT_YV12,
1687         GST_VIDEO_FORMAT_YUY2,
1688         GST_VIDEO_FORMAT_UYVY,
1689         GST_VIDEO_FORMAT_YVYU,
1690         GST_VIDEO_FORMAT_NV12,
1691     };
1692
1693     if (!index)
1694     {
1695         CopyMediaType(mt, &pin->mt);
1696         return S_OK;
1697     }
1698     else if (IsEqualGUID(&pin->mt.majortype, &MEDIATYPE_Video)
1699             && index - 1 < ARRAY_SIZE(video_formats))
1700     {
1701         const VIDEOINFOHEADER *vih = (VIDEOINFOHEADER *)pin->mt.pbFormat;
1702         GstVideoInfo info;
1703
1704         gst_video_info_set_format(&info, video_formats[index - 1],
1705                 vih->bmiHeader.biWidth, vih->bmiHeader.biHeight);
1706         if (!amt_from_gst_video_info(&info, mt))
1707             return E_OUTOFMEMORY;
1708         return S_OK;
1709     }
1710     else if (IsEqualGUID(&pin->mt.majortype, &MEDIATYPE_Audio) && index == 1)
1711     {
1712         const WAVEFORMATEX *our_format = (WAVEFORMATEX *)pin->mt.pbFormat;
1713         WAVEFORMATEX *format;
1714
1715         *mt = pin->mt;
1716         mt->subtype = MEDIASUBTYPE_PCM;
1717         mt->pbFormat = CoTaskMemAlloc(sizeof(WAVEFORMATEX));
1718         format = (WAVEFORMATEX *)mt->pbFormat;
1719         format->wFormatTag = WAVE_FORMAT_PCM;
1720         format->nChannels = 2;
1721         format->nSamplesPerSec = our_format->nSamplesPerSec;
1722         format->wBitsPerSample = 16;
1723         format->nBlockAlign = 4;
1724         format->nAvgBytesPerSec = format->nSamplesPerSec * 4;
1725         format->cbSize = 0;
1726         return S_OK;
1727     }
1728
1729     return VFW_S_NO_MORE_ITEMS;
1730 }
1731
1732 HRESULT gstdemux_create(IUnknown *outer, IUnknown **out)
1733 {
1734     struct gstdemux *object;
1735
1736     if (!init_gstreamer())
1737         return E_FAIL;
1738
1739     mark_wine_thread();
1740
1741     if (!(object = heap_alloc_zero(sizeof(*object))))
1742         return E_OUTOFMEMORY;
1743
1744     strmbase_filter_init(&object->filter, outer, &CLSID_Gstreamer_Splitter, &filter_ops);
1745     strmbase_sink_init(&object->sink, &object->filter, wcsInputPinName, &sink_ops, NULL);
1746
1747     object->no_more_pads_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1748     object->error_event = CreateEventW(NULL, TRUE, FALSE, NULL);
1749     object->init_gst = gstdecoder_init_gst;
1750     object->source_query_accept = gstdecoder_source_query_accept;
1751     object->source_get_media_type = gstdecoder_source_get_media_type;
1752
1753     TRACE("Created GStreamer demuxer %p.\n", object);
1754     *out = &object->filter.IUnknown_inner;
1755     return S_OK;
1756 }
1757
1758 static struct gstdemux *impl_from_IAMStreamSelect(IAMStreamSelect *iface)
1759 {
1760     return CONTAINING_RECORD(iface, struct gstdemux, IAMStreamSelect_iface);
1761 }
1762
1763 static HRESULT WINAPI stream_select_QueryInterface(IAMStreamSelect *iface, REFIID iid, void **out)
1764 {
1765     struct gstdemux *filter = impl_from_IAMStreamSelect(iface);
1766     return IUnknown_QueryInterface(filter->filter.outer_unk, iid, out);
1767 }
1768
1769 static ULONG WINAPI stream_select_AddRef(IAMStreamSelect *iface)
1770 {
1771     struct gstdemux *filter = impl_from_IAMStreamSelect(iface);
1772     return IUnknown_AddRef(filter->filter.outer_unk);
1773 }
1774
1775 static ULONG WINAPI stream_select_Release(IAMStreamSelect *iface)
1776 {
1777     struct gstdemux *filter = impl_from_IAMStreamSelect(iface);
1778     return IUnknown_Release(filter->filter.outer_unk);
1779 }
1780
1781 static HRESULT WINAPI stream_select_Count(IAMStreamSelect *iface, DWORD *count)
1782 {
1783     FIXME("iface %p, count %p, stub!\n", iface, count);
1784     return E_NOTIMPL;
1785 }
1786
1787 static HRESULT WINAPI stream_select_Info(IAMStreamSelect *iface, LONG index,
1788         AM_MEDIA_TYPE **mt, DWORD *flags, LCID *lcid, DWORD *group, WCHAR **name,
1789         IUnknown **object, IUnknown **unknown)
1790 {
1791     FIXME("iface %p, index %d, mt %p, flags %p, lcid %p, group %p, name %p, object %p, unknown %p, stub!\n",
1792             iface, index, mt, flags, lcid, group, name, object, unknown);
1793     return E_NOTIMPL;
1794 }
1795
1796 static HRESULT WINAPI stream_select_Enable(IAMStreamSelect *iface, LONG index, DWORD flags)
1797 {
1798     FIXME("iface %p, index %d, flags %#x, stub!\n", iface, index, flags);
1799     return E_NOTIMPL;
1800 }
1801
1802 static const IAMStreamSelectVtbl stream_select_vtbl =
1803 {
1804     stream_select_QueryInterface,
1805     stream_select_AddRef,
1806     stream_select_Release,
1807     stream_select_Count,
1808     stream_select_Info,
1809     stream_select_Enable,
1810 };
1811
1812 static HRESULT WINAPI GST_ChangeCurrent(IMediaSeeking *iface)
1813 {
1814     struct gstdemux_source *This = impl_from_IMediaSeeking(iface);
1815     TRACE("(%p)\n", This);
1816     return S_OK;
1817 }
1818
1819 static HRESULT WINAPI GST_ChangeStop(IMediaSeeking *iface)
1820 {
1821     struct gstdemux_source *This = impl_from_IMediaSeeking(iface);
1822     TRACE("(%p)\n", This);
1823     return S_OK;
1824 }
1825
1826 static HRESULT WINAPI GST_ChangeRate(IMediaSeeking *iface)
1827 {
1828     struct gstdemux_source *This = impl_from_IMediaSeeking(iface);
1829     GstEvent *ev = gst_event_new_seek(This->seek.dRate, GST_FORMAT_TIME, 0, GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_NONE, -1);
1830     TRACE("(%p) New rate %g\n", This, This->seek.dRate);
1831     mark_wine_thread();
1832     gst_pad_push_event(This->my_sink, ev);
1833     return S_OK;
1834 }
1835
1836 static HRESULT WINAPI GST_Seeking_QueryInterface(IMediaSeeking *iface, REFIID riid, void **ppv)
1837 {
1838     struct gstdemux_source *This = impl_from_IMediaSeeking(iface);
1839     return IPin_QueryInterface(&This->pin.pin.IPin_iface, riid, ppv);
1840 }
1841
1842 static ULONG WINAPI GST_Seeking_AddRef(IMediaSeeking *iface)
1843 {
1844     struct gstdemux_source *This = impl_from_IMediaSeeking(iface);
1845     return IPin_AddRef(&This->pin.pin.IPin_iface);
1846 }
1847
1848 static ULONG WINAPI GST_Seeking_Release(IMediaSeeking *iface)
1849 {
1850     struct gstdemux_source *This = impl_from_IMediaSeeking(iface);
1851     return IPin_Release(&This->pin.pin.IPin_iface);
1852 }
1853
1854 static HRESULT WINAPI GST_Seeking_GetCurrentPosition(IMediaSeeking *iface, REFERENCE_TIME *pos)
1855 {
1856     struct gstdemux_source *This = impl_from_IMediaSeeking(iface);
1857
1858     TRACE("(%p)->(%p)\n", This, pos);
1859
1860     if (!pos)
1861         return E_POINTER;
1862
1863     mark_wine_thread();
1864
1865     if (This->pin.pin.filter->state == State_Stopped)
1866     {
1867         *pos = This->seek.llCurrent;
1868         TRACE("Cached value\n");
1869         return S_OK;
1870     }
1871
1872     if (!gst_pad_query_position(This->their_src, GST_FORMAT_TIME, pos)) {
1873         WARN("Could not query position\n");
1874         return E_NOTIMPL;
1875     }
1876     *pos /= 100;
1877     This->seek.llCurrent = *pos;
1878     return S_OK;
1879 }
1880
1881 static GstSeekType type_from_flags(DWORD flags)
1882 {
1883     switch (flags & AM_SEEKING_PositioningBitsMask) {
1884     case AM_SEEKING_NoPositioning:
1885         return GST_SEEK_TYPE_NONE;
1886     case AM_SEEKING_AbsolutePositioning:
1887     case AM_SEEKING_RelativePositioning:
1888         return GST_SEEK_TYPE_SET;
1889     case AM_SEEKING_IncrementalPositioning:
1890         return GST_SEEK_TYPE_END;
1891     }
1892     return GST_SEEK_TYPE_NONE;
1893 }
1894
1895 static HRESULT WINAPI GST_Seeking_SetPositions(IMediaSeeking *iface,
1896         REFERENCE_TIME *pCur, DWORD curflags, REFERENCE_TIME *pStop,
1897         DWORD stopflags)
1898 {
1899     HRESULT hr;
1900     struct gstdemux_source *This = impl_from_IMediaSeeking(iface);
1901     GstSeekFlags f = 0;
1902     GstSeekType curtype, stoptype;
1903     GstEvent *e;
1904     gint64 stop_pos = 0, curr_pos = 0;
1905
1906     TRACE("(%p)->(%p, 0x%x, %p, 0x%x)\n", This, pCur, curflags, pStop, stopflags);
1907
1908     mark_wine_thread();
1909
1910     hr = SourceSeekingImpl_SetPositions(iface, pCur, curflags, pStop, stopflags);
1911     if (This->pin.pin.filter->state == State_Stopped)
1912         return hr;
1913
1914     curtype = type_from_flags(curflags);
1915     stoptype = type_from_flags(stopflags);
1916     if (curflags & AM_SEEKING_SeekToKeyFrame)
1917         f |= GST_SEEK_FLAG_KEY_UNIT;
1918     if (curflags & AM_SEEKING_Segment)
1919         f |= GST_SEEK_FLAG_SEGMENT;
1920     if (!(curflags & AM_SEEKING_NoFlush))
1921         f |= GST_SEEK_FLAG_FLUSH;
1922
1923     if (((curflags & AM_SEEKING_PositioningBitsMask) == AM_SEEKING_RelativePositioning) ||
1924         ((stopflags & AM_SEEKING_PositioningBitsMask) == AM_SEEKING_RelativePositioning)) {
1925         gint64 tmp_pos;
1926         gst_pad_query_position (This->my_sink, GST_FORMAT_TIME, &tmp_pos);
1927         if ((curflags & AM_SEEKING_PositioningBitsMask) == AM_SEEKING_RelativePositioning)
1928             curr_pos = tmp_pos;
1929         if ((stopflags & AM_SEEKING_PositioningBitsMask) == AM_SEEKING_RelativePositioning)
1930             stop_pos = tmp_pos;
1931     }
1932
1933     e = gst_event_new_seek(This->seek.dRate, GST_FORMAT_TIME, f, curtype, pCur ? curr_pos + *pCur * 100 : -1, stoptype, pStop ? stop_pos + *pStop * 100 : -1);
1934     if (gst_pad_push_event(This->my_sink, e))
1935         return S_OK;
1936     else
1937         return E_NOTIMPL;
1938 }
1939
1940 static const IMediaSeekingVtbl GST_Seeking_Vtbl =
1941 {
1942     GST_Seeking_QueryInterface,
1943     GST_Seeking_AddRef,
1944     GST_Seeking_Release,
1945     SourceSeekingImpl_GetCapabilities,
1946     SourceSeekingImpl_CheckCapabilities,
1947     SourceSeekingImpl_IsFormatSupported,
1948     SourceSeekingImpl_QueryPreferredFormat,
1949     SourceSeekingImpl_GetTimeFormat,
1950     SourceSeekingImpl_IsUsingTimeFormat,
1951     SourceSeekingImpl_SetTimeFormat,
1952     SourceSeekingImpl_GetDuration,
1953     SourceSeekingImpl_GetStopPosition,
1954     GST_Seeking_GetCurrentPosition,
1955     SourceSeekingImpl_ConvertTimeFormat,
1956     GST_Seeking_SetPositions,
1957     SourceSeekingImpl_GetPositions,
1958     SourceSeekingImpl_GetAvailable,
1959     SourceSeekingImpl_SetRate,
1960     SourceSeekingImpl_GetRate,
1961     SourceSeekingImpl_GetPreroll
1962 };
1963
1964 static inline struct gstdemux_source *impl_from_IQualityControl( IQualityControl *iface )
1965 {
1966     return CONTAINING_RECORD(iface, struct gstdemux_source, IQualityControl_iface);
1967 }
1968
1969 static HRESULT WINAPI GST_QualityControl_QueryInterface(IQualityControl *iface, REFIID riid, void **ppv)
1970 {
1971     struct gstdemux_source *pin = impl_from_IQualityControl(iface);
1972     return IPin_QueryInterface(&pin->pin.pin.IPin_iface, riid, ppv);
1973 }
1974
1975 static ULONG WINAPI GST_QualityControl_AddRef(IQualityControl *iface)
1976 {
1977     struct gstdemux_source *pin = impl_from_IQualityControl(iface);
1978     return IPin_AddRef(&pin->pin.pin.IPin_iface);
1979 }
1980
1981 static ULONG WINAPI GST_QualityControl_Release(IQualityControl *iface)
1982 {
1983     struct gstdemux_source *pin = impl_from_IQualityControl(iface);
1984     return IPin_Release(&pin->pin.pin.IPin_iface);
1985 }
1986
1987 static HRESULT WINAPI GST_QualityControl_Notify(IQualityControl *iface, IBaseFilter *sender, Quality qm)
1988 {
1989     struct gstdemux_source *pin = impl_from_IQualityControl(iface);
1990     GstQOSType type = GST_QOS_TYPE_OVERFLOW;
1991     GstClockTime timestamp;
1992     GstClockTimeDiff diff;
1993     GstEvent *evt;
1994
1995     TRACE("(%p)->(%p, { 0x%x %u %s %s })\n", pin, sender,
1996             qm.Type, qm.Proportion,
1997             wine_dbgstr_longlong(qm.Late),
1998             wine_dbgstr_longlong(qm.TimeStamp));
1999
2000     mark_wine_thread();
2001
2002     /* GSTQOS_TYPE_OVERFLOW is also used for buffers that arrive on time, but
2003      * DirectShow filters might use Famine, so check that there actually is an
2004      * underrun. */
2005     if (qm.Type == Famine && qm.Proportion > 1000)
2006         type = GST_QOS_TYPE_UNDERFLOW;
2007
2008     /* DirectShow filters sometimes pass negative timestamps (Audiosurf uses the
2009      * current time instead of the time of the last buffer). GstClockTime is
2010      * unsigned, so clamp it to 0. */
2011     timestamp = max(qm.TimeStamp * 100, 0);
2012
2013     /* The documentation specifies that timestamp + diff must be nonnegative. */
2014     diff = qm.Late * 100;
2015     if (timestamp < -diff)
2016         diff = -timestamp;
2017
2018     evt = gst_event_new_qos(type, qm.Proportion / 1000.0, diff, timestamp);
2019
2020     if (!evt) {
2021         WARN("Failed to create QOS event\n");
2022         return E_INVALIDARG;
2023     }
2024
2025     gst_pad_push_event(pin->my_sink, evt);
2026
2027     return S_OK;
2028 }
2029
2030 static HRESULT WINAPI GST_QualityControl_SetSink(IQualityControl *iface, IQualityControl *tonotify)
2031 {
2032     struct gstdemux_source *pin = impl_from_IQualityControl(iface);
2033     TRACE("(%p)->(%p)\n", pin, pin);
2034     /* Do nothing */
2035     return S_OK;
2036 }
2037
2038 static const IQualityControlVtbl GSTOutPin_QualityControl_Vtbl = {
2039     GST_QualityControl_QueryInterface,
2040     GST_QualityControl_AddRef,
2041     GST_QualityControl_Release,
2042     GST_QualityControl_Notify,
2043     GST_QualityControl_SetSink
2044 };
2045
2046 static inline struct gstdemux_source *impl_source_from_IPin(IPin *iface)
2047 {
2048     return CONTAINING_RECORD(iface, struct gstdemux_source, pin.pin.IPin_iface);
2049 }
2050
2051 static HRESULT source_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
2052 {
2053     struct gstdemux_source *pin = impl_source_from_IPin(&iface->IPin_iface);
2054
2055     if (IsEqualGUID(iid, &IID_IMediaSeeking))
2056         *out = &pin->seek.IMediaSeeking_iface;
2057     else if (IsEqualGUID(iid, &IID_IQualityControl))
2058         *out = &pin->IQualityControl_iface;
2059     else
2060         return E_NOINTERFACE;
2061
2062     IUnknown_AddRef((IUnknown *)*out);
2063     return S_OK;
2064 }
2065
2066 static HRESULT source_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt)
2067 {
2068     struct gstdemux_source *pin = impl_source_from_IPin(&iface->IPin_iface);
2069     struct gstdemux *filter = impl_from_strmbase_filter(iface->filter);
2070     return filter->source_query_accept(pin, mt);
2071 }
2072
2073 static HRESULT source_get_media_type(struct strmbase_pin *iface, unsigned int index, AM_MEDIA_TYPE *mt)
2074 {
2075     struct gstdemux_source *pin = impl_source_from_IPin(&iface->IPin_iface);
2076     struct gstdemux *filter = impl_from_strmbase_filter(iface->filter);
2077     return filter->source_get_media_type(pin, index, mt);
2078 }
2079
2080 static HRESULT WINAPI GSTOutPin_DecideBufferSize(struct strmbase_source *iface,
2081         IMemAllocator *allocator, ALLOCATOR_PROPERTIES *props)
2082 {
2083     struct gstdemux_source *pin = impl_source_from_IPin(&iface->pin.IPin_iface);
2084     unsigned int buffer_size = 16384;
2085     ALLOCATOR_PROPERTIES ret_props;
2086
2087     if (IsEqualGUID(&pin->pin.pin.mt.formattype, &FORMAT_VideoInfo))
2088     {
2089         VIDEOINFOHEADER *format = (VIDEOINFOHEADER *)pin->pin.pin.mt.pbFormat;
2090         buffer_size = format->bmiHeader.biSizeImage;
2091
2092         gst_util_set_object_arg(G_OBJECT(pin->flip), "method",
2093                 format->bmiHeader.biCompression == BI_RGB ? "vertical-flip" : "none");
2094     }
2095     else if (IsEqualGUID(&pin->pin.pin.mt.formattype, &FORMAT_WaveFormatEx)
2096             && (IsEqualGUID(&pin->pin.pin.mt.subtype, &MEDIASUBTYPE_PCM)
2097             || IsEqualGUID(&pin->pin.pin.mt.subtype, &MEDIASUBTYPE_IEEE_FLOAT)))
2098     {
2099         WAVEFORMATEX *format = (WAVEFORMATEX *)pin->pin.pin.mt.pbFormat;
2100         buffer_size = format->nAvgBytesPerSec;
2101     }
2102
2103     props->cBuffers = max(props->cBuffers, 1);
2104     props->cbBuffer = max(props->cbBuffer, buffer_size);
2105     props->cbAlign = max(props->cbAlign, 1);
2106     return IMemAllocator_SetProperties(allocator, props, &ret_props);
2107 }
2108
2109 static void free_source_pin(struct gstdemux_source *pin)
2110 {
2111     if (pin->pin.pin.peer)
2112     {
2113         if (SUCCEEDED(IMemAllocator_Decommit(pin->pin.pAllocator)))
2114             IPin_Disconnect(pin->pin.pin.peer);
2115         IPin_Disconnect(&pin->pin.pin.IPin_iface);
2116     }
2117
2118     if (pin->their_src)
2119     {
2120         if (pin->post_sink)
2121         {
2122             gst_pad_unlink(pin->their_src, pin->post_sink);
2123             gst_pad_unlink(pin->post_src, pin->my_sink);
2124             gst_object_unref(pin->post_src);
2125             gst_object_unref(pin->post_sink);
2126             pin->post_src = pin->post_sink = NULL;
2127         }
2128         else
2129             gst_pad_unlink(pin->their_src, pin->my_sink);
2130         gst_object_unref(pin->their_src);
2131     }
2132     gst_object_unref(pin->my_sink);
2133     CloseHandle(pin->caps_event);
2134     CloseHandle(pin->eos_event);
2135     FreeMediaType(&pin->mt);
2136     gst_segment_free(pin->segment);
2137
2138     strmbase_seeking_cleanup(&pin->seek);
2139     strmbase_source_cleanup(&pin->pin);
2140     heap_free(pin);
2141 }
2142
2143 static const struct strmbase_source_ops source_ops =
2144 {
2145     .base.pin_query_interface = source_query_interface,
2146     .base.pin_query_accept = source_query_accept,
2147     .base.pin_get_media_type = source_get_media_type,
2148     .pfnAttemptConnection = BaseOutputPinImpl_AttemptConnection,
2149     .pfnDecideAllocator = BaseOutputPinImpl_DecideAllocator,
2150     .pfnDecideBufferSize = GSTOutPin_DecideBufferSize,
2151 };
2152
2153 static struct gstdemux_source *create_pin(struct gstdemux *filter, const WCHAR *name)
2154 {
2155     struct gstdemux_source *pin, **new_array;
2156     char pad_name[19];
2157
2158     if (!(new_array = heap_realloc(filter->sources, (filter->source_count + 1) * sizeof(*new_array))))
2159         return NULL;
2160     filter->sources = new_array;
2161
2162     if (!(pin = heap_alloc_zero(sizeof(*pin))))
2163         return NULL;
2164
2165     strmbase_source_init(&pin->pin, &filter->filter, name, &source_ops);
2166     pin->caps_event = CreateEventW(NULL, FALSE, FALSE, NULL);
2167     pin->eos_event = CreateEventW(NULL, FALSE, FALSE, NULL);
2168     pin->segment = gst_segment_new();
2169     gst_segment_init(pin->segment, GST_FORMAT_TIME);
2170     pin->IQualityControl_iface.lpVtbl = &GSTOutPin_QualityControl_Vtbl;
2171     strmbase_seeking_init(&pin->seek, &GST_Seeking_Vtbl, GST_ChangeStop,
2172             GST_ChangeCurrent, GST_ChangeRate);
2173     BaseFilterImpl_IncrementPinVersion(&filter->filter);
2174
2175     sprintf(pad_name, "qz_sink_%u", filter->source_count);
2176     pin->my_sink = gst_pad_new(pad_name, GST_PAD_SINK);
2177     gst_pad_set_element_private(pin->my_sink, pin);
2178     gst_pad_set_chain_function(pin->my_sink, got_data_sink_wrapper);
2179     gst_pad_set_event_function(pin->my_sink, event_sink_wrapper);
2180     gst_pad_set_query_function(pin->my_sink, query_sink_wrapper);
2181
2182     filter->sources[filter->source_count++] = pin;
2183     return pin;
2184 }
2185
2186 static HRESULT GST_RemoveOutputPins(struct gstdemux *This)
2187 {
2188     unsigned int i;
2189
2190     TRACE("(%p)\n", This);
2191     mark_wine_thread();
2192
2193     if (!This->container)
2194         return S_OK;
2195     gst_element_set_state(This->container, GST_STATE_NULL);
2196     gst_pad_unlink(This->my_src, This->their_sink);
2197     gst_object_unref(This->my_src);
2198     gst_object_unref(This->their_sink);
2199     This->my_src = This->their_sink = NULL;
2200
2201     for (i = 0; i < This->source_count; ++i)
2202         free_source_pin(This->sources[i]);
2203
2204     This->source_count = 0;
2205     heap_free(This->sources);
2206     This->sources = NULL;
2207     gst_element_set_bus(This->container, NULL);
2208     gst_object_unref(This->container);
2209     This->container = NULL;
2210     BaseFilterImpl_IncrementPinVersion(&This->filter);
2211     return S_OK;
2212 }
2213
2214 void perform_cb_gstdemux(struct cb_data *cbdata)
2215 {
2216     switch(cbdata->type)
2217     {
2218     case WATCH_BUS:
2219         {
2220             struct watch_bus_data *data = &cbdata->u.watch_bus_data;
2221             cbdata->u.watch_bus_data.ret = watch_bus(data->bus, data->msg, data->user);
2222             break;
2223         }
2224     case EXISTING_NEW_PAD:
2225         {
2226             struct pad_added_data *data = &cbdata->u.pad_added_data;
2227             existing_new_pad(data->element, data->pad, data->user);
2228             break;
2229         }
2230     case QUERY_FUNCTION:
2231         {
2232             struct query_function_data *data = &cbdata->u.query_function_data;
2233             cbdata->u.query_function_data.ret = query_function(data->pad, data->parent, data->query);
2234             break;
2235         }
2236     case ACTIVATE_MODE:
2237         {
2238             struct activate_mode_data *data = &cbdata->u.activate_mode_data;
2239             cbdata->u.activate_mode_data.ret = activate_mode(data->pad, data->parent, data->mode, data->activate);
2240             break;
2241         }
2242     case NO_MORE_PADS:
2243         {
2244             struct no_more_pads_data *data = &cbdata->u.no_more_pads_data;
2245             no_more_pads(data->element, data->user);
2246             break;
2247         }
2248     case REQUEST_BUFFER_SRC:
2249         {
2250             struct getrange_data *data = &cbdata->u.getrange_data;
2251             cbdata->u.getrange_data.ret = request_buffer_src(data->pad, data->parent,
2252                     data->ofs, data->len, data->buf);
2253             break;
2254         }
2255     case EVENT_SRC:
2256         {
2257             struct event_src_data *data = &cbdata->u.event_src_data;
2258             cbdata->u.event_src_data.ret = event_src(data->pad, data->parent, data->event);
2259             break;
2260         }
2261     case EVENT_SINK:
2262         {
2263             struct event_sink_data *data = &cbdata->u.event_sink_data;
2264             cbdata->u.event_sink_data.ret = event_sink(data->pad, data->parent, data->event);
2265             break;
2266         }
2267     case GOT_DATA_SINK:
2268         {
2269             struct got_data_sink_data *data = &cbdata->u.got_data_sink_data;
2270             cbdata->u.got_data_sink_data.ret = got_data_sink(data->pad, data->parent, data->buf);
2271             break;
2272         }
2273     case REMOVED_DECODED_PAD:
2274         {
2275             struct pad_removed_data *data = &cbdata->u.pad_removed_data;
2276             removed_decoded_pad(data->element, data->pad, data->user);
2277             break;
2278         }
2279     case AUTOPLUG_BLACKLIST:
2280         {
2281             struct autoplug_blacklist_data *data = &cbdata->u.autoplug_blacklist_data;
2282             cbdata->u.autoplug_blacklist_data.ret = autoplug_blacklist(data->bin,
2283                     data->pad, data->caps, data->fact, data->user);
2284             break;
2285         }
2286     case UNKNOWN_TYPE:
2287         {
2288             struct unknown_type_data *data = &cbdata->u.unknown_type_data;
2289             unknown_type(data->bin, data->pad, data->caps, data->user);
2290             break;
2291         }
2292     case QUERY_SINK:
2293         {
2294             struct query_sink_data *data = &cbdata->u.query_sink_data;
2295             cbdata->u.query_sink_data.ret = query_sink(data->pad, data->parent,
2296                     data->query);
2297             break;
2298         }
2299     default:
2300         {
2301             assert(0);
2302         }
2303     }
2304 }
2305
2306 static BOOL compare_media_types(const AM_MEDIA_TYPE *a, const AM_MEDIA_TYPE *b)
2307 {
2308     return IsEqualGUID(&a->majortype, &b->majortype)
2309             && IsEqualGUID(&a->subtype, &b->subtype)
2310             && IsEqualGUID(&a->formattype, &b->formattype)
2311             && a->cbFormat == b->cbFormat
2312             && !memcmp(a->pbFormat, b->pbFormat, a->cbFormat);
2313 }
2314
2315 static HRESULT wave_parser_sink_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt)
2316 {
2317     if (!IsEqualGUID(&mt->majortype, &MEDIATYPE_Stream))
2318         return S_FALSE;
2319     if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_WAVE))
2320         return S_OK;
2321     if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_AU) || IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_AIFF))
2322         FIXME("AU and AIFF files are not yet supported.\n");
2323     return S_FALSE;
2324 }
2325
2326 static const struct strmbase_sink_ops wave_parser_sink_ops =
2327 {
2328     .base.pin_query_accept = wave_parser_sink_query_accept,
2329     .sink_connect = gstdemux_sink_connect,
2330     .sink_disconnect = gstdemux_sink_disconnect,
2331 };
2332
2333 static BOOL wave_parser_init_gst(struct gstdemux *filter)
2334 {
2335     static const WCHAR source_name[] = {'o','u','t','p','u','t',0};
2336     struct gstdemux_source *pin;
2337     GstElement *element;
2338     HANDLE events[2];
2339     int ret;
2340
2341     if (!(element = gst_element_factory_make("wavparse", NULL)))
2342     {
2343         ERR("Failed to create wavparse; are %u-bit GStreamer \"good\" plugins installed?\n",
2344                 8 * (int)sizeof(void*));
2345         return FALSE;
2346     }
2347
2348     gst_bin_add(GST_BIN(filter->container), element);
2349
2350     filter->their_sink = gst_element_get_static_pad(element, "sink");
2351     if ((ret = gst_pad_link(filter->my_src, filter->their_sink)) < 0)
2352     {
2353         ERR("Failed to link sink pads, error %d.\n", ret);
2354         return FALSE;
2355     }
2356
2357     if (!(pin = create_pin(filter, source_name)))
2358         return FALSE;
2359     pin->their_src = gst_element_get_static_pad(element, "src");
2360     gst_object_ref(pin->their_src);
2361     if ((ret = gst_pad_link(pin->their_src, pin->my_sink)) < 0)
2362     {
2363         ERR("Failed to link source pads, error %d.\n", ret);
2364         return FALSE;
2365     }
2366
2367     gst_pad_set_active(pin->my_sink, 1);
2368     gst_element_set_state(filter->container, GST_STATE_PAUSED);
2369     ret = gst_element_get_state(filter->container, NULL, NULL, -1);
2370     if (ret == GST_STATE_CHANGE_FAILURE)
2371     {
2372         ERR("Failed to play stream.\n");
2373         return FALSE;
2374     }
2375
2376     pin->seek.llDuration = pin->seek.llStop = query_duration(pin->their_src);
2377     pin->seek.llCurrent = 0;
2378
2379     events[0] = pin->caps_event;
2380     events[1] = filter->error_event;
2381     if (WaitForMultipleObjects(2, events, FALSE, INFINITE))
2382         return FALSE;
2383
2384     filter->ignore_flush = TRUE;
2385     gst_element_set_state(filter->container, GST_STATE_READY);
2386     gst_element_get_state(filter->container, NULL, NULL, -1);
2387     filter->ignore_flush = FALSE;
2388
2389     return TRUE;
2390 }
2391
2392 static HRESULT wave_parser_source_query_accept(struct gstdemux_source *pin, const AM_MEDIA_TYPE *mt)
2393 {
2394     return compare_media_types(mt, &pin->mt) ? S_OK : S_FALSE;
2395 }
2396
2397 static HRESULT wave_parser_source_get_media_type(struct gstdemux_source *pin,
2398         unsigned int index, AM_MEDIA_TYPE *mt)
2399 {
2400     if (index > 0)
2401         return VFW_S_NO_MORE_ITEMS;
2402     CopyMediaType(mt, &pin->mt);
2403     return S_OK;
2404 }
2405
2406 HRESULT wave_parser_create(IUnknown *outer, IUnknown **out)
2407 {
2408     static const WCHAR sink_name[] = {'i','n','p','u','t',' ','p','i','n',0};
2409     struct gstdemux *object;
2410
2411     if (!init_gstreamer())
2412         return E_FAIL;
2413
2414     mark_wine_thread();
2415
2416     if (!(object = heap_alloc_zero(sizeof(*object))))
2417         return E_OUTOFMEMORY;
2418
2419     strmbase_filter_init(&object->filter, outer, &CLSID_WAVEParser, &filter_ops);
2420     strmbase_sink_init(&object->sink, &object->filter, sink_name, &wave_parser_sink_ops, NULL);
2421     object->init_gst = wave_parser_init_gst;
2422     object->error_event = CreateEventW(NULL, TRUE, FALSE, NULL);
2423     object->source_query_accept = wave_parser_source_query_accept;
2424     object->source_get_media_type = wave_parser_source_get_media_type;
2425
2426     TRACE("Created WAVE parser %p.\n", object);
2427     *out = &object->filter.IUnknown_inner;
2428     return S_OK;
2429 }
2430
2431 static HRESULT avi_splitter_sink_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt)
2432 {
2433     if (IsEqualGUID(&mt->majortype, &MEDIATYPE_Stream)
2434             && IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_Avi))
2435         return S_OK;
2436     return S_FALSE;
2437 }
2438
2439 static const struct strmbase_sink_ops avi_splitter_sink_ops =
2440 {
2441     .base.pin_query_accept = avi_splitter_sink_query_accept,
2442     .sink_connect = gstdemux_sink_connect,
2443     .sink_disconnect = gstdemux_sink_disconnect,
2444 };
2445
2446 static BOOL avi_splitter_init_gst(struct gstdemux *filter)
2447 {
2448     GstElement *element = gst_element_factory_make("avidemux", NULL);
2449     unsigned int i;
2450     int ret;
2451
2452     if (!element)
2453     {
2454         ERR("Failed to create avidemux; are %u-bit GStreamer \"good\" plugins installed?\n",
2455                 8 * (int)sizeof(void*));
2456         return FALSE;
2457     }
2458
2459     gst_bin_add(GST_BIN(filter->container), element);
2460
2461     g_signal_connect(element, "pad-added", G_CALLBACK(existing_new_pad_wrapper), filter);
2462     g_signal_connect(element, "pad-removed", G_CALLBACK(removed_decoded_pad_wrapper), filter);
2463     g_signal_connect(element, "no-more-pads", G_CALLBACK(no_more_pads_wrapper), filter);
2464
2465     filter->their_sink = gst_element_get_static_pad(element, "sink");
2466     ResetEvent(filter->no_more_pads_event);
2467
2468     if ((ret = gst_pad_link(filter->my_src, filter->their_sink)) < 0)
2469     {
2470         ERR("Failed to link pads, error %d.\n", ret);
2471         return FALSE;
2472     }
2473
2474     gst_element_set_state(filter->container, GST_STATE_PLAYING);
2475     ret = gst_element_get_state(filter->container, NULL, NULL, -1);
2476     if (ret == GST_STATE_CHANGE_FAILURE)
2477     {
2478         ERR("Failed to play stream.\n");
2479         return FALSE;
2480     }
2481
2482     WaitForSingleObject(filter->no_more_pads_event, INFINITE);
2483
2484     for (i = 0; i < filter->source_count; ++i)
2485     {
2486         struct gstdemux_source *pin = filter->sources[i];
2487         const HANDLE events[2] = {pin->caps_event, filter->error_event};
2488
2489         pin->seek.llDuration = pin->seek.llStop = query_duration(pin->their_src);
2490         pin->seek.llCurrent = 0;
2491         if (WaitForMultipleObjects(2, events, FALSE, INFINITE))
2492             return FALSE;
2493     }
2494
2495     filter->ignore_flush = TRUE;
2496     gst_element_set_state(filter->container, GST_STATE_READY);
2497     gst_element_get_state(filter->container, NULL, NULL, -1);
2498     filter->ignore_flush = FALSE;
2499
2500     return TRUE;
2501 }
2502
2503 static HRESULT avi_splitter_source_query_accept(struct gstdemux_source *pin, const AM_MEDIA_TYPE *mt)
2504 {
2505     return compare_media_types(mt, &pin->mt) ? S_OK : S_FALSE;
2506 }
2507
2508 static HRESULT avi_splitter_source_get_media_type(struct gstdemux_source *pin,
2509         unsigned int index, AM_MEDIA_TYPE *mt)
2510 {
2511     if (index > 0)
2512         return VFW_S_NO_MORE_ITEMS;
2513     CopyMediaType(mt, &pin->mt);
2514     return S_OK;
2515 }
2516
2517 HRESULT avi_splitter_create(IUnknown *outer, IUnknown **out)
2518 {
2519     static const WCHAR sink_name[] = {'i','n','p','u','t',' ','p','i','n',0};
2520     struct gstdemux *object;
2521
2522     if (!init_gstreamer())
2523         return E_FAIL;
2524
2525     mark_wine_thread();
2526
2527     if (!(object = heap_alloc_zero(sizeof(*object))))
2528         return E_OUTOFMEMORY;
2529
2530     strmbase_filter_init(&object->filter, outer, &CLSID_AviSplitter, &filter_ops);
2531     strmbase_sink_init(&object->sink, &object->filter, sink_name, &avi_splitter_sink_ops, NULL);
2532     object->no_more_pads_event = CreateEventW(NULL, FALSE, FALSE, NULL);
2533     object->error_event = CreateEventW(NULL, TRUE, FALSE, NULL);
2534     object->init_gst = avi_splitter_init_gst;
2535     object->source_query_accept = avi_splitter_source_query_accept;
2536     object->source_get_media_type = avi_splitter_source_get_media_type;
2537
2538     TRACE("Created AVI splitter %p.\n", object);
2539     *out = &object->filter.IUnknown_inner;
2540     return S_OK;
2541 }
2542
2543 static HRESULT mpeg_splitter_sink_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt)
2544 {
2545     if (!IsEqualGUID(&mt->majortype, &MEDIATYPE_Stream))
2546         return S_FALSE;
2547     if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_MPEG1Audio))
2548         return S_OK;
2549     if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_MPEG1Video)
2550             || IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_MPEG1System)
2551             || IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_MPEG1VideoCD))
2552         FIXME("Unsupported subtype %s.\n", wine_dbgstr_guid(&mt->subtype));
2553     return S_FALSE;
2554 }
2555
2556 static const struct strmbase_sink_ops mpeg_splitter_sink_ops =
2557 {
2558     .base.pin_query_accept = mpeg_splitter_sink_query_accept,
2559     .sink_connect = gstdemux_sink_connect,
2560     .sink_disconnect = gstdemux_sink_disconnect,
2561 };
2562
2563 static BOOL mpeg_splitter_init_gst(struct gstdemux *filter)
2564 {
2565     static const WCHAR source_name[] = {'A','u','d','i','o',0};
2566     struct gstdemux_source *pin;
2567     GstElement *element;
2568     HANDLE events[3];
2569     DWORD res;
2570     int ret;
2571
2572     if (!(element = gst_element_factory_make("mpegaudioparse", NULL)))
2573     {
2574         ERR("Failed to create mpegaudioparse; are %u-bit GStreamer \"good\" plugins installed?\n",
2575                 8 * (int)sizeof(void*));
2576         return FALSE;
2577     }
2578
2579     gst_bin_add(GST_BIN(filter->container), element);
2580
2581     filter->their_sink = gst_element_get_static_pad(element, "sink");
2582     if ((ret = gst_pad_link(filter->my_src, filter->their_sink)) < 0)
2583     {
2584         ERR("Failed to link sink pads, error %d.\n", ret);
2585         return FALSE;
2586     }
2587
2588     if (!(pin = create_pin(filter, source_name)))
2589         return FALSE;
2590     gst_object_ref(pin->their_src = gst_element_get_static_pad(element, "src"));
2591     if ((ret = gst_pad_link(pin->their_src, pin->my_sink)) < 0)
2592     {
2593         ERR("Failed to link source pads, error %d.\n", ret);
2594         return FALSE;
2595     }
2596
2597     gst_pad_set_active(pin->my_sink, 1);
2598     gst_element_set_state(filter->container, GST_STATE_PAUSED);
2599     ret = gst_element_get_state(filter->container, NULL, NULL, -1);
2600     if (ret == GST_STATE_CHANGE_FAILURE)
2601     {
2602         ERR("Failed to play stream.\n");
2603         return FALSE;
2604     }
2605
2606     events[0] = filter->duration_event;
2607     events[1] = filter->error_event;
2608     events[2] = pin->eos_event;
2609     res = WaitForMultipleObjects(3, events, FALSE, INFINITE);
2610     if (res == 1)
2611         return FALSE;
2612
2613     pin->seek.llDuration = pin->seek.llStop = query_duration(pin->their_src);
2614     pin->seek.llCurrent = 0;
2615
2616     events[0] = pin->caps_event;
2617     if (WaitForMultipleObjects(2, events, FALSE, INFINITE))
2618         return FALSE;
2619
2620     filter->ignore_flush = TRUE;
2621     gst_element_set_state(filter->container, GST_STATE_READY);
2622     gst_element_get_state(filter->container, NULL, NULL, -1);
2623     filter->ignore_flush = FALSE;
2624
2625     return TRUE;
2626 }
2627
2628 static HRESULT mpeg_splitter_source_query_accept(struct gstdemux_source *pin, const AM_MEDIA_TYPE *mt)
2629 {
2630     return compare_media_types(mt, &pin->mt) ? S_OK : S_FALSE;
2631 }
2632
2633 static HRESULT mpeg_splitter_source_get_media_type(struct gstdemux_source *pin,
2634         unsigned int index, AM_MEDIA_TYPE *mt)
2635 {
2636     if (index > 0)
2637         return VFW_S_NO_MORE_ITEMS;
2638     CopyMediaType(mt, &pin->mt);
2639     return S_OK;
2640 }
2641
2642 static HRESULT mpeg_splitter_query_interface(struct strmbase_filter *iface, REFIID iid, void **out)
2643 {
2644     struct gstdemux *filter = impl_from_strmbase_filter(iface);
2645
2646     if (IsEqualGUID(iid, &IID_IAMStreamSelect))
2647     {
2648         *out = &filter->IAMStreamSelect_iface;
2649         IUnknown_AddRef((IUnknown *)*out);
2650         return S_OK;
2651     }
2652
2653     return E_NOINTERFACE;
2654 }
2655
2656 static const struct strmbase_filter_ops mpeg_splitter_ops =
2657 {
2658     .filter_query_interface = mpeg_splitter_query_interface,
2659     .filter_get_pin = gstdemux_get_pin,
2660     .filter_destroy = gstdemux_destroy,
2661     .filter_init_stream = gstdemux_init_stream,
2662     .filter_start_stream = gstdemux_start_stream,
2663     .filter_stop_stream = gstdemux_stop_stream,
2664     .filter_cleanup_stream = gstdemux_cleanup_stream,
2665     .filter_wait_state = gstdemux_wait_state,
2666 };
2667
2668 HRESULT mpeg_splitter_create(IUnknown *outer, IUnknown **out)
2669 {
2670     static const WCHAR sink_name[] = {'I','n','p','u','t',0};
2671     struct gstdemux *object;
2672
2673     if (!init_gstreamer())
2674         return E_FAIL;
2675
2676     mark_wine_thread();
2677
2678     if (!(object = heap_alloc_zero(sizeof(*object))))
2679         return E_OUTOFMEMORY;
2680
2681     strmbase_filter_init(&object->filter, outer, &CLSID_MPEG1Splitter, &mpeg_splitter_ops);
2682     strmbase_sink_init(&object->sink, &object->filter, sink_name, &mpeg_splitter_sink_ops, NULL);
2683     object->IAMStreamSelect_iface.lpVtbl = &stream_select_vtbl;
2684
2685     object->duration_event = CreateEventW(NULL, FALSE, FALSE, NULL);
2686     object->error_event = CreateEventW(NULL, TRUE, FALSE, NULL);
2687     object->init_gst = mpeg_splitter_init_gst;
2688     object->source_query_accept = mpeg_splitter_source_query_accept;
2689     object->source_get_media_type = mpeg_splitter_source_get_media_type;
2690     object->enum_sink_first = TRUE;
2691
2692     TRACE("Created MPEG-1 splitter %p.\n", object);
2693     *out = &object->filter.IUnknown_inner;
2694     return S_OK;
2695 }