It fails if samples lie outside of the current segment, but DirectShow filters (in particular, the native AVI splitter) will happily set timestamps outside of the current segment.
Signed-off-by: Zebediah Figura z.figura12@gmail.com --- dlls/winegstreamer/gstdemux.c | 25 +++++-------------------- 1 file changed, 5 insertions(+), 20 deletions(-)
diff --git a/dlls/winegstreamer/gstdemux.c b/dlls/winegstreamer/gstdemux.c index 7b3a4fd48bd..c05b1e24018 100644 --- a/dlls/winegstreamer/gstdemux.c +++ b/dlls/winegstreamer/gstdemux.c @@ -103,7 +103,6 @@ struct wg_parser_stream { GstPad *their_src, *post_sink, *post_src, *my_sink; GstElement *flip; - GstSegment *segment; GstCaps *caps;
pthread_cond_t event_cond, event_empty_cond; @@ -769,8 +768,6 @@ static gboolean event_sink(GstPad *pad, GstObject *parent, GstEvent *event) break; }
- gst_segment_copy_into(segment, stream->segment); - stream_event.type = WG_PARSER_EVENT_SEGMENT; stream_event.u.segment.position = segment->position / 100; stream_event.u.segment.stop = segment->stop / 100; @@ -822,7 +819,6 @@ static gboolean event_sink(GstPad *pad, GstObject *parent, GstEvent *event) break;
case GST_EVENT_FLUSH_STOP: - gst_segment_init(stream->segment, GST_FORMAT_TIME); if (stream->enabled) { pthread_mutex_lock(&parser->mutex); @@ -928,7 +924,6 @@ static GstFlowReturn got_data_sink(GstPad *pad, GstObject *parent, GstBuffer *bu static HRESULT send_sample(struct parser_source *pin, IMediaSample *sample, GstBuffer *buf, GstMapInfo *info, gsize offset, gsize size, DWORD bytes_per_second) { - struct wg_parser_stream *stream = pin->wg_stream; HRESULT hr; BYTE *ptr = NULL;
@@ -943,26 +938,19 @@ static HRESULT send_sample(struct parser_source *pin, IMediaSample *sample, memcpy(ptr, &info->data[offset], size);
if (GST_BUFFER_PTS_IS_VALID(buf)) { - REFERENCE_TIME rtStart; - GstClockTime ptsStart = buf->pts; + REFERENCE_TIME rtStart, ptsStart = buf->pts; + if (offset > 0) ptsStart = buf->pts + gst_util_uint64_scale(offset, GST_SECOND, bytes_per_second); - rtStart = gst_segment_to_running_time(stream->segment, GST_FORMAT_TIME, ptsStart); - if (rtStart >= 0) - rtStart /= 100; + rtStart = ((ptsStart / 100) - pin->seek.llCurrent) * pin->seek.dRate;
if (GST_BUFFER_DURATION_IS_VALID(buf)) { - REFERENCE_TIME rtStop; - REFERENCE_TIME tStart; - REFERENCE_TIME tStop; - GstClockTime ptsStop = buf->pts + buf->duration; + REFERENCE_TIME rtStop, tStart, tStop, ptsStop = buf->pts + buf->duration; if (offset + size < info->size) ptsStop = buf->pts + gst_util_uint64_scale(offset + size, GST_SECOND, bytes_per_second); tStart = ptsStart / 100; tStop = ptsStop / 100; - rtStop = gst_segment_to_running_time(stream->segment, GST_FORMAT_TIME, ptsStop); - if (rtStop >= 0) - rtStop /= 100; + rtStop = ((ptsStop / 100) - pin->seek.llCurrent) * pin->seek.dRate; TRACE("Current time on %p: %i to %i ms\n", pin, (int)(rtStart / 10000), (int)(rtStop / 10000)); IMediaSample_SetTime(sample, &rtStart, rtStop >= 0 ? &rtStop : NULL); IMediaSample_SetMediaTime(sample, &tStart, &tStop); @@ -2473,7 +2461,6 @@ static void free_stream(struct wg_parser_stream *stream) gst_object_unref(stream->their_src); } gst_object_unref(stream->my_sink); - gst_segment_free(stream->segment);
pthread_cond_destroy(&stream->event_cond); pthread_cond_destroy(&stream->event_empty_cond); @@ -2538,8 +2525,6 @@ static struct parser_source *create_pin(struct parser *filter, const WCHAR *name pin->wg_stream = stream;
strmbase_source_init(&pin->pin, &filter->filter, name, &source_ops); - stream->segment = gst_segment_new(); - gst_segment_init(stream->segment, GST_FORMAT_TIME); pin->IQualityControl_iface.lpVtbl = &GSTOutPin_QualityControl_Vtbl; strmbase_seeking_init(&pin->seek, &GST_Seeking_Vtbl, GST_ChangeStop, GST_ChangeCurrent, GST_ChangeRate);
The fundamental idea here is to provide a type which can be used in the unixlib interface. Obviously GstCaps can't be used from PE, and while AM_MEDIA_TYPE can in theory be used from the Unix library, allocation of the format block makes things a little tricky. Moreover, we'd ideally like to use the same backend for DirectShow and Media Foundation, and while it wouldn't be a problem currently, in general AM_MEDIA_TYPE is not quite expressive enough to translate from GstCaps to IMFMediaType, and the latter can't be used from the Unix library.
Signed-off-by: Zebediah Figura z.figura12@gmail.com --- dlls/winegstreamer/gst_private.h | 60 ++++ dlls/winegstreamer/gstdemux.c | 516 +++++++++++++++++++++++++------ 2 files changed, 486 insertions(+), 90 deletions(-)
diff --git a/dlls/winegstreamer/gst_private.h b/dlls/winegstreamer/gst_private.h index b6942e5ae77..adef709d8fa 100644 --- a/dlls/winegstreamer/gst_private.h +++ b/dlls/winegstreamer/gst_private.h @@ -66,6 +66,66 @@ static inline const char *debugstr_time(REFERENCE_TIME time)
#define MEDIATIME_FROM_BYTES(x) ((LONGLONG)(x) * 10000000)
+struct wg_format +{ + enum wg_major_type + { + WG_MAJOR_TYPE_UNKNOWN, + WG_MAJOR_TYPE_VIDEO, + WG_MAJOR_TYPE_AUDIO, + } major_type; + + union + { + struct + { + enum wg_video_format + { + WG_VIDEO_FORMAT_UNKNOWN, + + WG_VIDEO_FORMAT_BGRA, + WG_VIDEO_FORMAT_BGRx, + WG_VIDEO_FORMAT_BGR, + WG_VIDEO_FORMAT_RGB15, + WG_VIDEO_FORMAT_RGB16, + + WG_VIDEO_FORMAT_AYUV, + WG_VIDEO_FORMAT_I420, + WG_VIDEO_FORMAT_NV12, + WG_VIDEO_FORMAT_UYVY, + WG_VIDEO_FORMAT_YUY2, + WG_VIDEO_FORMAT_YV12, + WG_VIDEO_FORMAT_YVYU, + + WG_VIDEO_FORMAT_CINEPAK, + } format; + uint32_t width, height; + uint32_t fps_n, fps_d; + } video; + struct + { + enum wg_audio_format + { + WG_AUDIO_FORMAT_UNKNOWN, + + WG_AUDIO_FORMAT_U8, + WG_AUDIO_FORMAT_S16LE, + WG_AUDIO_FORMAT_S24LE, + WG_AUDIO_FORMAT_S32LE, + WG_AUDIO_FORMAT_F32LE, + WG_AUDIO_FORMAT_F64LE, + + WG_AUDIO_FORMAT_MPEG1_LAYER1, + WG_AUDIO_FORMAT_MPEG1_LAYER2, + WG_AUDIO_FORMAT_MPEG1_LAYER3, + } format; + + uint32_t channels; + uint32_t rate; + } audio; + } u; +}; + extern LONG object_locks;
HRESULT avi_splitter_create(IUnknown *outer, IUnknown **out) DECLSPEC_HIDDEN; diff --git a/dlls/winegstreamer/gstdemux.c b/dlls/winegstreamer/gstdemux.c index c05b1e24018..96405f89e53 100644 --- a/dlls/winegstreamer/gstdemux.c +++ b/dlls/winegstreamer/gstdemux.c @@ -45,6 +45,7 @@ GST_DEBUG_CATEGORY_STATIC(wine); #define GST_CAT_DEFAULT wine
static const GUID MEDIASUBTYPE_CVID = {mmioFOURCC('c','v','i','d'), 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}}; +static const GUID MEDIASUBTYPE_MP3 = {WAVE_FORMAT_MPEGLAYER3, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
struct wg_parser { @@ -317,133 +318,468 @@ static gboolean amt_from_gst_video_info(const GstVideoInfo *info, AM_MEDIA_TYPE return TRUE; }
-static gboolean amt_from_gst_caps_audio_mpeg(const GstCaps *caps, AM_MEDIA_TYPE *mt) +static enum wg_audio_format wg_audio_format_from_gst(GstAudioFormat format) { - GstStructure *structure = gst_caps_get_structure(caps, 0); - gint layer, channels, rate; + switch (format) + { + case GST_AUDIO_FORMAT_U8: + return WG_AUDIO_FORMAT_U8; + case GST_AUDIO_FORMAT_S16LE: + return WG_AUDIO_FORMAT_S16LE; + case GST_AUDIO_FORMAT_S24LE: + return WG_AUDIO_FORMAT_S24LE; + case GST_AUDIO_FORMAT_S32LE: + return WG_AUDIO_FORMAT_S32LE; + case GST_AUDIO_FORMAT_F32LE: + return WG_AUDIO_FORMAT_F32LE; + case GST_AUDIO_FORMAT_F64LE: + return WG_AUDIO_FORMAT_F64LE; + default: + return WG_AUDIO_FORMAT_UNKNOWN; + } +}
- mt->majortype = MEDIATYPE_Audio; - mt->subtype = MEDIASUBTYPE_MPEG1AudioPayload; - mt->bFixedSizeSamples = FALSE; - mt->bTemporalCompression = FALSE; - mt->lSampleSize = 0; - mt->formattype = FORMAT_WaveFormatEx; - mt->pUnk = NULL; +static void wg_format_from_audio_info(struct wg_format *format, const GstAudioInfo *info) +{ + format->major_type = WG_MAJOR_TYPE_AUDIO; + format->u.audio.format = wg_audio_format_from_gst(GST_AUDIO_INFO_FORMAT(info)); + format->u.audio.channels = GST_AUDIO_INFO_CHANNELS(info); + format->u.audio.rate = GST_AUDIO_INFO_RATE(info); +} + +static enum wg_video_format wg_video_format_from_gst(GstVideoFormat format) +{ + switch (format) + { + case GST_VIDEO_FORMAT_BGRA: + return WG_VIDEO_FORMAT_BGRA; + case GST_VIDEO_FORMAT_BGRx: + return WG_VIDEO_FORMAT_BGRx; + case GST_VIDEO_FORMAT_BGR: + return WG_VIDEO_FORMAT_BGR; + case GST_VIDEO_FORMAT_RGB15: + return WG_VIDEO_FORMAT_RGB15; + case GST_VIDEO_FORMAT_AYUV: + return WG_VIDEO_FORMAT_AYUV; + case GST_VIDEO_FORMAT_I420: + return WG_VIDEO_FORMAT_I420; + case GST_VIDEO_FORMAT_NV12: + return WG_VIDEO_FORMAT_NV12; + case GST_VIDEO_FORMAT_UYVY: + return WG_VIDEO_FORMAT_UYVY; + case GST_VIDEO_FORMAT_YUY2: + return WG_VIDEO_FORMAT_YUY2; + case GST_VIDEO_FORMAT_YV12: + return WG_VIDEO_FORMAT_YV12; + case GST_VIDEO_FORMAT_YVYU: + return WG_VIDEO_FORMAT_YVYU; + default: + return WG_VIDEO_FORMAT_UNKNOWN; + } +} + +static void wg_format_from_video_info(struct wg_format *format, const GstVideoInfo *info) +{ + format->major_type = WG_MAJOR_TYPE_VIDEO; + format->u.video.format = wg_video_format_from_gst(GST_VIDEO_INFO_FORMAT(info)); + format->u.video.width = GST_VIDEO_INFO_WIDTH(info); + format->u.video.height = GST_VIDEO_INFO_HEIGHT(info); + format->u.video.fps_n = GST_VIDEO_INFO_FPS_N(info); + format->u.video.fps_d = GST_VIDEO_INFO_FPS_D(info); +} + +static void wg_format_from_caps_audio_mpeg(struct wg_format *format, const GstCaps *caps) +{ + const GstStructure *structure = gst_caps_get_structure(caps, 0); + gint layer, channels, rate;
if (!gst_structure_get_int(structure, "layer", &layer)) { - WARN("Missing 'layer' value.\n"); - return FALSE; + GST_WARNING("Missing "layer" value."); + return; } if (!gst_structure_get_int(structure, "channels", &channels)) { - WARN("Missing 'channels' value.\n"); - return FALSE; + GST_WARNING("Missing "channels" value."); + return; } if (!gst_structure_get_int(structure, "rate", &rate)) { - WARN("Missing 'rate' value.\n"); - return FALSE; + GST_WARNING("Missing "rate" value."); + return; + } + + format->major_type = WG_MAJOR_TYPE_AUDIO; + + if (layer == 1) + format->u.audio.format = WG_AUDIO_FORMAT_MPEG1_LAYER1; + else if (layer == 2) + format->u.audio.format = WG_AUDIO_FORMAT_MPEG1_LAYER2; + else if (layer == 3) + format->u.audio.format = WG_AUDIO_FORMAT_MPEG1_LAYER3; + + format->u.audio.channels = channels; + format->u.audio.rate = rate; +} + +static void wg_format_from_caps_video_cinepak(struct wg_format *format, const GstCaps *caps) +{ + const GstStructure *structure = gst_caps_get_structure(caps, 0); + gint width, height, fps_n, fps_d; + + if (!gst_structure_get_int(structure, "width", &width)) + { + GST_WARNING("Missing "width" value."); + return; + } + if (!gst_structure_get_int(structure, "height", &height)) + { + GST_WARNING("Missing "height" value."); + return; + } + if (!gst_structure_get_fraction(structure, "framerate", &fps_n, &fps_d)) + { + fps_n = 0; + fps_d = 1; }
- if (layer == 3) + format->major_type = WG_MAJOR_TYPE_VIDEO; + format->u.video.format = WG_VIDEO_FORMAT_CINEPAK; + format->u.video.width = width; + format->u.video.height = height; + format->u.video.fps_n = fps_n; + format->u.video.fps_d = fps_d; +} + +static void wg_format_from_caps(struct wg_format *format, const GstCaps *caps) +{ + const GstStructure *structure = gst_caps_get_structure(caps, 0); + const char *name = gst_structure_get_name(structure); + + memset(format, 0, sizeof(*format)); + + if (!strcmp(name, "audio/x-raw")) { - MPEGLAYER3WAVEFORMAT *wfx = CoTaskMemAlloc(sizeof(*wfx)); - memset(wfx, 0, sizeof(*wfx)); + GstAudioInfo info;
- mt->subtype.Data1 = WAVE_FORMAT_MPEGLAYER3; - mt->cbFormat = sizeof(*wfx); - mt->pbFormat = (BYTE *)wfx; - wfx->wfx.wFormatTag = WAVE_FORMAT_MPEGLAYER3; - wfx->wfx.nChannels = channels; - wfx->wfx.nSamplesPerSec = rate; - /* FIXME: We can't get most of the MPEG data from the caps. We may have - * to manually parse the header. */ - wfx->wfx.cbSize = sizeof(*wfx) - sizeof(WAVEFORMATEX); - wfx->wID = MPEGLAYER3_ID_MPEG; - wfx->fdwFlags = MPEGLAYER3_FLAG_PADDING_ON; - wfx->nFramesPerBlock = 1; - wfx->nCodecDelay = 1393; + if (gst_audio_info_from_caps(&info, caps)) + wg_format_from_audio_info(format, &info); + } + else if (!strcmp(name, "video/x-raw")) + { + GstVideoInfo info; + + if (gst_video_info_from_caps(&info, caps)) + wg_format_from_video_info(format, &info); + } + else if (!strcmp(name, "audio/mpeg")) + { + wg_format_from_caps_audio_mpeg(format, caps); + } + else if (!strcmp(name, "video/x-cinepak")) + { + wg_format_from_caps_video_cinepak(format, caps); } else { - MPEG1WAVEFORMAT *wfx = CoTaskMemAlloc(sizeof(*wfx)); - memset(wfx, 0, sizeof(*wfx)); + gchar *str = gst_caps_to_string(caps);
- mt->subtype.Data1 = WAVE_FORMAT_MPEG; - mt->cbFormat = sizeof(*wfx); - mt->pbFormat = (BYTE *)wfx; - wfx->wfx.wFormatTag = WAVE_FORMAT_MPEG; - wfx->wfx.nChannels = channels; - wfx->wfx.nSamplesPerSec = rate; - wfx->wfx.cbSize = sizeof(*wfx) - sizeof(WAVEFORMATEX); - wfx->fwHeadLayer = layer; + GST_FIXME("Unhandled caps %s.", str); + g_free(str); } +}
- return TRUE; +static DWORD channel_mask_from_count(uint32_t count) +{ + switch (count) + { + case 1: return KSAUDIO_SPEAKER_MONO; + case 2: return KSAUDIO_SPEAKER_STEREO; + case 4: return KSAUDIO_SPEAKER_SURROUND; + case 5: return KSAUDIO_SPEAKER_5POINT1 & ~SPEAKER_LOW_FREQUENCY; + case 6: return KSAUDIO_SPEAKER_5POINT1; + case 8: return KSAUDIO_SPEAKER_7POINT1; + default: return 0; + } }
-static gboolean amt_from_gst_caps(const GstCaps *caps, AM_MEDIA_TYPE *mt) +static bool amt_from_wg_format_audio(AM_MEDIA_TYPE *mt, const struct wg_format *format) { - const char *type = gst_structure_get_name(gst_caps_get_structure(caps, 0)); - GstStructure *structure = gst_caps_get_structure(caps, 0); + mt->majortype = MEDIATYPE_Audio; + mt->formattype = FORMAT_WaveFormatEx;
- memset(mt, 0, sizeof(AM_MEDIA_TYPE)); + switch (format->u.audio.format) + { + case WG_AUDIO_FORMAT_UNKNOWN: + return false;
- if (!strcmp(type, "audio/x-raw")) + case WG_AUDIO_FORMAT_MPEG1_LAYER1: + case WG_AUDIO_FORMAT_MPEG1_LAYER2: { - GstAudioInfo info; + MPEG1WAVEFORMAT *wave_format;
- if (!(gst_audio_info_from_caps(&info, caps))) - return FALSE; - return amt_from_gst_audio_info(&info, mt); + if (!(wave_format = CoTaskMemAlloc(sizeof(*wave_format)))) + return false; + memset(wave_format, 0, sizeof(*wave_format)); + + mt->subtype = MEDIASUBTYPE_MPEG1AudioPayload; + mt->cbFormat = sizeof(*wave_format); + mt->pbFormat = (BYTE *)wave_format; + wave_format->wfx.wFormatTag = WAVE_FORMAT_MPEG; + wave_format->wfx.nChannels = format->u.audio.channels; + wave_format->wfx.nSamplesPerSec = format->u.audio.rate; + wave_format->wfx.cbSize = sizeof(*wave_format) - sizeof(WAVEFORMATEX); + wave_format->fwHeadLayer = (format->u.audio.format == WG_AUDIO_FORMAT_MPEG1_LAYER1 ? 1 : 2); + return true; } - else if (!strcmp(type, "video/x-raw")) + + case WG_AUDIO_FORMAT_MPEG1_LAYER3: { - GstVideoInfo info; + MPEGLAYER3WAVEFORMAT *wave_format;
- if (!gst_video_info_from_caps(&info, caps)) - return FALSE; - return amt_from_gst_video_info(&info, mt); + if (!(wave_format = CoTaskMemAlloc(sizeof(*wave_format)))) + return false; + memset(wave_format, 0, sizeof(*wave_format)); + + mt->subtype = MEDIASUBTYPE_MP3; + mt->cbFormat = sizeof(*wave_format); + mt->pbFormat = (BYTE *)wave_format; + wave_format->wfx.wFormatTag = WAVE_FORMAT_MPEGLAYER3; + wave_format->wfx.nChannels = format->u.audio.channels; + wave_format->wfx.nSamplesPerSec = format->u.audio.rate; + wave_format->wfx.cbSize = sizeof(*wave_format) - sizeof(WAVEFORMATEX); + /* FIXME: We can't get most of the MPEG data from the caps. We may have + * to manually parse the header. */ + wave_format->wID = MPEGLAYER3_ID_MPEG; + wave_format->fdwFlags = MPEGLAYER3_FLAG_PADDING_ON; + wave_format->nFramesPerBlock = 1; + wave_format->nCodecDelay = 1393; + return true; + } + + case WG_AUDIO_FORMAT_U8: + case WG_AUDIO_FORMAT_S16LE: + case WG_AUDIO_FORMAT_S24LE: + case WG_AUDIO_FORMAT_S32LE: + case WG_AUDIO_FORMAT_F32LE: + case WG_AUDIO_FORMAT_F64LE: + { + static const struct + { + bool is_float; + WORD depth; + } + format_table[] = + { + {0}, + {false, 8}, + {false, 16}, + {false, 24}, + {false, 32}, + {true, 32}, + {true, 64}, + }; + + bool is_float; + WORD depth; + + assert(format->u.audio.format < ARRAY_SIZE(format_table)); + is_float = format_table[format->u.audio.format].is_float; + depth = format_table[format->u.audio.format].depth; + + if (is_float || format->u.audio.channels > 2) + { + WAVEFORMATEXTENSIBLE *wave_format; + + if (!(wave_format = CoTaskMemAlloc(sizeof(*wave_format)))) + return false; + memset(wave_format, 0, sizeof(*wave_format)); + + mt->subtype = is_float ? MEDIASUBTYPE_IEEE_FLOAT : MEDIASUBTYPE_PCM; + mt->bFixedSizeSamples = TRUE; + mt->pbFormat = (BYTE *)wave_format; + mt->cbFormat = sizeof(*wave_format); + wave_format->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; + wave_format->Format.nChannels = format->u.audio.channels; + wave_format->Format.nSamplesPerSec = format->u.audio.rate; + wave_format->Format.nAvgBytesPerSec = format->u.audio.rate * format->u.audio.channels * depth / 8; + wave_format->Format.nBlockAlign = format->u.audio.channels * depth / 8; + wave_format->Format.wBitsPerSample = depth; + wave_format->Format.cbSize = sizeof(*wave_format) - sizeof(WAVEFORMATEX); + wave_format->Samples.wValidBitsPerSample = depth; + wave_format->dwChannelMask = channel_mask_from_count(format->u.audio.channels); + wave_format->SubFormat = is_float ? KSDATAFORMAT_SUBTYPE_IEEE_FLOAT : KSDATAFORMAT_SUBTYPE_PCM; + mt->lSampleSize = wave_format->Format.nBlockAlign; + } + else + { + WAVEFORMATEX *wave_format; + + if (!(wave_format = CoTaskMemAlloc(sizeof(*wave_format)))) + return false; + memset(wave_format, 0, sizeof(*wave_format)); + + mt->subtype = MEDIASUBTYPE_PCM; + mt->bFixedSizeSamples = TRUE; + mt->pbFormat = (BYTE *)wave_format; + mt->cbFormat = sizeof(*wave_format); + wave_format->wFormatTag = WAVE_FORMAT_PCM; + wave_format->nChannels = format->u.audio.channels; + wave_format->nSamplesPerSec = format->u.audio.rate; + wave_format->nAvgBytesPerSec = format->u.audio.rate * format->u.audio.channels * depth / 8; + wave_format->nBlockAlign = format->u.audio.channels * depth / 8; + wave_format->wBitsPerSample = depth; + wave_format->cbSize = 0; + mt->lSampleSize = wave_format->nBlockAlign; + } + return true; + } } - else if (!strcmp(type, "audio/mpeg")) - return amt_from_gst_caps_audio_mpeg(caps, mt); - else if (!strcmp(type, "video/x-cinepak")) + + assert(0); + return false; +} + +#define ALIGN(n, alignment) (((n) + (alignment) - 1) & ~((alignment) - 1)) + +static unsigned int get_image_size(const struct wg_format *format) +{ + unsigned int width = format->u.video.width, height = format->u.video.height; + + switch (format->u.video.format) { - VIDEOINFOHEADER *vih; - gint i; + case WG_VIDEO_FORMAT_BGRA: + case WG_VIDEO_FORMAT_BGRx: + case WG_VIDEO_FORMAT_AYUV: + return width * height * 4;
- mt->majortype = MEDIATYPE_Video; - mt->subtype = MEDIASUBTYPE_CVID; - mt->bTemporalCompression = TRUE; - mt->lSampleSize = 1; - mt->formattype = FORMAT_VideoInfo; - if (!(vih = CoTaskMemAlloc(sizeof(VIDEOINFOHEADER)))) - return FALSE; - mt->cbFormat = sizeof(VIDEOINFOHEADER); - mt->pbFormat = (BYTE *)vih; - - memset(vih, 0, sizeof(VIDEOINFOHEADER)); - vih->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); - if (gst_structure_get_int(structure, "width", &i)) - vih->bmiHeader.biWidth = i; - if (gst_structure_get_int(structure, "height", &i)) - vih->bmiHeader.biHeight = i; - vih->bmiHeader.biPlanes = 1; - /* Both ffmpeg's encoder and a Cinepak file seen in the wild report - * 24 bpp. ffmpeg sets biSizeImage as below; others may be smaller, but - * as long as every sample fits into our allocator, we're fine. */ - vih->bmiHeader.biBitCount = 24; - vih->bmiHeader.biCompression = mmioFOURCC('c','v','i','d'); - vih->bmiHeader.biSizeImage = vih->bmiHeader.biWidth - * vih->bmiHeader.biHeight * vih->bmiHeader.biBitCount / 8; - return TRUE; + case WG_VIDEO_FORMAT_BGR: + return ALIGN(width * 3, 4) * height; + + case WG_VIDEO_FORMAT_RGB15: + case WG_VIDEO_FORMAT_RGB16: + case WG_VIDEO_FORMAT_UYVY: + case WG_VIDEO_FORMAT_YUY2: + case WG_VIDEO_FORMAT_YVYU: + return ALIGN(width * 2, 4) * height; + + case WG_VIDEO_FORMAT_I420: + case WG_VIDEO_FORMAT_YV12: + return ALIGN(width, 4) * ALIGN(height, 2) /* Y plane */ + + 2 * ALIGN((width + 1) / 2, 4) * ((height + 1) / 2); /* U and V planes */ + + case WG_VIDEO_FORMAT_NV12: + return ALIGN(width, 4) * ALIGN(height, 2) /* Y plane */ + + ALIGN(width, 4) * ((height + 1) / 2); /* U/V plane */ + + case WG_VIDEO_FORMAT_CINEPAK: + /* Both ffmpeg's encoder and a Cinepak file seen in the wild report + * 24 bpp. ffmpeg sets biSizeImage as below; others may be smaller, + * but as long as every sample fits into our allocator, we're fine. */ + return width * height * 3; + + case WG_VIDEO_FORMAT_UNKNOWN: + break; } - else + + assert(0); + return 0; +} + +static bool amt_from_wg_format_video(AM_MEDIA_TYPE *mt, const struct wg_format *format) +{ + static const struct { - FIXME("Unhandled type %s.\n", debugstr_a(type)); - return FALSE; + const GUID *subtype; + DWORD compression; + WORD depth; + } + format_table[] = + { + {0}, + {&MEDIASUBTYPE_ARGB32, BI_RGB, 32}, + {&MEDIASUBTYPE_RGB32, BI_RGB, 32}, + {&MEDIASUBTYPE_RGB24, BI_RGB, 24}, + {&MEDIASUBTYPE_RGB555, BI_RGB, 16}, + {&MEDIASUBTYPE_RGB565, BI_BITFIELDS, 16}, + {&MEDIASUBTYPE_AYUV, mmioFOURCC('A','Y','U','V'), 32}, + {&MEDIASUBTYPE_I420, mmioFOURCC('I','4','2','0'), 12}, + {&MEDIASUBTYPE_NV12, mmioFOURCC('N','V','1','2'), 12}, + {&MEDIASUBTYPE_UYVY, mmioFOURCC('U','Y','V','Y'), 16}, + {&MEDIASUBTYPE_YUY2, mmioFOURCC('Y','U','Y','2'), 16}, + {&MEDIASUBTYPE_YV12, mmioFOURCC('Y','V','1','2'), 12}, + {&MEDIASUBTYPE_YVYU, mmioFOURCC('Y','V','Y','U'), 16}, + {&MEDIASUBTYPE_CVID, mmioFOURCC('C','V','I','D'), 24}, + }; + + VIDEOINFO *video_format; + uint32_t frame_time; + + if (format->u.video.format == WG_VIDEO_FORMAT_UNKNOWN) + return false; + + if (!(video_format = CoTaskMemAlloc(sizeof(*video_format)))) + return false; + + assert(format->u.video.format < ARRAY_SIZE(format_table)); + + mt->majortype = MEDIATYPE_Video; + mt->subtype = *format_table[format->u.video.format].subtype; + mt->bTemporalCompression = TRUE; + mt->lSampleSize = 1; + mt->formattype = FORMAT_VideoInfo; + mt->cbFormat = sizeof(VIDEOINFOHEADER); + mt->pbFormat = (BYTE *)video_format; + + memset(video_format, 0, sizeof(*video_format)); + + if ((frame_time = MulDiv(10000000, format->u.video.fps_d, format->u.video.fps_n)) != -1) + video_format->AvgTimePerFrame = frame_time; + video_format->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + video_format->bmiHeader.biWidth = format->u.video.width; + video_format->bmiHeader.biHeight = format->u.video.height; + video_format->bmiHeader.biPlanes = 1; + video_format->bmiHeader.biBitCount = format_table[format->u.video.format].depth; + video_format->bmiHeader.biCompression = format_table[format->u.video.format].compression; + video_format->bmiHeader.biSizeImage = get_image_size(format); + + if (format->u.video.format == WG_VIDEO_FORMAT_RGB16) + { + mt->cbFormat = offsetof(VIDEOINFO, u.dwBitMasks[3]); + video_format->u.dwBitMasks[iRED] = 0xf800; + video_format->u.dwBitMasks[iGREEN] = 0x07e0; + video_format->u.dwBitMasks[iBLUE] = 0x001f; + } + + return true; +} + +static bool amt_from_wg_format(AM_MEDIA_TYPE *mt, const struct wg_format *format) +{ + memset(mt, 0, sizeof(*mt)); + + switch (format->major_type) + { + case WG_MAJOR_TYPE_UNKNOWN: + return false; + + case WG_MAJOR_TYPE_AUDIO: + return amt_from_wg_format_audio(mt, format); + + case WG_MAJOR_TYPE_VIDEO: + return amt_from_wg_format_video(mt, format); } + + assert(0); + return false; +} + +static bool amt_from_gst_caps(const GstCaps *caps, AM_MEDIA_TYPE *mt) +{ + struct wg_format wg_format; + + wg_format_from_caps(&wg_format, caps); + return amt_from_wg_format(mt, &wg_format); }
static GstCaps *amt_to_gst_caps_video(const AM_MEDIA_TYPE *mt)
Signed-off-by: Zebediah Figura z.figura12@gmail.com --- dlls/winegstreamer/gstdemux.c | 222 +++++++++++++++++++++++++--------- 1 file changed, 167 insertions(+), 55 deletions(-)
diff --git a/dlls/winegstreamer/gstdemux.c b/dlls/winegstreamer/gstdemux.c index 96405f89e53..73458d9210e 100644 --- a/dlls/winegstreamer/gstdemux.c +++ b/dlls/winegstreamer/gstdemux.c @@ -782,105 +782,217 @@ static bool amt_from_gst_caps(const GstCaps *caps, AM_MEDIA_TYPE *mt) return amt_from_wg_format(mt, &wg_format); }
-static GstCaps *amt_to_gst_caps_video(const AM_MEDIA_TYPE *mt) +static bool amt_to_wg_format_audio(const AM_MEDIA_TYPE *mt, struct wg_format *format) { static const struct { const GUID *subtype; - GstVideoFormat format; + WORD depth; + enum wg_audio_format format; } format_map[] = { - {&MEDIASUBTYPE_ARGB32, GST_VIDEO_FORMAT_BGRA}, - {&MEDIASUBTYPE_RGB32, GST_VIDEO_FORMAT_BGRx}, - {&MEDIASUBTYPE_RGB24, GST_VIDEO_FORMAT_BGR}, - {&MEDIASUBTYPE_RGB565, GST_VIDEO_FORMAT_RGB16}, - {&MEDIASUBTYPE_RGB555, GST_VIDEO_FORMAT_RGB15}, + {&MEDIASUBTYPE_PCM, 8, WG_AUDIO_FORMAT_U8}, + {&MEDIASUBTYPE_PCM, 16, WG_AUDIO_FORMAT_S16LE}, + {&MEDIASUBTYPE_PCM, 24, WG_AUDIO_FORMAT_S24LE}, + {&MEDIASUBTYPE_PCM, 32, WG_AUDIO_FORMAT_S32LE}, + {&MEDIASUBTYPE_IEEE_FLOAT, 32, WG_AUDIO_FORMAT_F32LE}, + {&MEDIASUBTYPE_IEEE_FLOAT, 64, WG_AUDIO_FORMAT_F64LE}, };
- const VIDEOINFOHEADER *vih = (VIDEOINFOHEADER *)mt->pbFormat; - GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN; - GstVideoInfo info; + const WAVEFORMATEX *audio_format = (const WAVEFORMATEX *)mt->pbFormat; unsigned int i; - GstCaps *caps;
- if (!IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo) - || mt->cbFormat < sizeof(VIDEOINFOHEADER) || !mt->pbFormat) - return NULL; + if (!IsEqualGUID(&mt->formattype, &FORMAT_WaveFormatEx)) + { + FIXME("Unknown format type %s.\n", debugstr_guid(&mt->formattype)); + return false; + } + if (mt->cbFormat < sizeof(WAVEFORMATEX) || !mt->pbFormat) + { + ERR("Unexpected format size %u.\n", mt->cbFormat); + return false; + } + + format->major_type = WG_MAJOR_TYPE_AUDIO; + format->u.audio.channels = audio_format->nChannels; + format->u.audio.rate = audio_format->nSamplesPerSec;
for (i = 0; i < ARRAY_SIZE(format_map); ++i) { - if (IsEqualGUID(&mt->subtype, format_map[i].subtype)) + if (IsEqualGUID(&mt->subtype, format_map[i].subtype) + && audio_format->wBitsPerSample == format_map[i].depth) { - format = format_map[i].format; - break; + format->u.audio.format = format_map[i].format; + return true; } }
- if (format == GST_VIDEO_FORMAT_UNKNOWN) - format = gst_video_format_from_fourcc(vih->bmiHeader.biCompression); + FIXME("Unknown subtype %s, depth %u.\n", debugstr_guid(&mt->subtype), audio_format->wBitsPerSample); + return false; +}
- if (format == GST_VIDEO_FORMAT_UNKNOWN) +static bool amt_to_wg_format_video(const AM_MEDIA_TYPE *mt, struct wg_format *format) +{ + static const struct { - FIXME("Unknown video format (subtype %s, compression %#x).\n", - debugstr_guid(&mt->subtype), vih->bmiHeader.biCompression); - return NULL; + const GUID *subtype; + enum wg_video_format format; } + format_map[] = + { + {&MEDIASUBTYPE_ARGB32, WG_VIDEO_FORMAT_BGRA}, + {&MEDIASUBTYPE_RGB32, WG_VIDEO_FORMAT_BGRx}, + {&MEDIASUBTYPE_RGB24, WG_VIDEO_FORMAT_BGR}, + {&MEDIASUBTYPE_RGB555, WG_VIDEO_FORMAT_RGB15}, + {&MEDIASUBTYPE_RGB565, WG_VIDEO_FORMAT_RGB16}, + {&MEDIASUBTYPE_AYUV, WG_VIDEO_FORMAT_AYUV}, + {&MEDIASUBTYPE_I420, WG_VIDEO_FORMAT_I420}, + {&MEDIASUBTYPE_NV12, WG_VIDEO_FORMAT_NV12}, + {&MEDIASUBTYPE_UYVY, WG_VIDEO_FORMAT_UYVY}, + {&MEDIASUBTYPE_YUY2, WG_VIDEO_FORMAT_YUY2}, + {&MEDIASUBTYPE_YV12, WG_VIDEO_FORMAT_YV12}, + {&MEDIASUBTYPE_YVYU, WG_VIDEO_FORMAT_YVYU}, + {&MEDIASUBTYPE_CVID, WG_VIDEO_FORMAT_CINEPAK}, + };
- gst_video_info_set_format(&info, format, vih->bmiHeader.biWidth, vih->bmiHeader.biHeight); - if ((caps = gst_video_info_to_caps(&info))) + const VIDEOINFOHEADER *video_format = (const VIDEOINFOHEADER *)mt->pbFormat; + unsigned int i; + + if (!IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo)) { - /* Clear some fields that shouldn't prevent us from connecting. */ - for (i = 0; i < gst_caps_get_size(caps); ++i) + FIXME("Unknown format type %s.\n", debugstr_guid(&mt->formattype)); + return false; + } + if (mt->cbFormat < sizeof(VIDEOINFOHEADER) || !mt->pbFormat) + { + ERR("Unexpected format size %u.\n", mt->cbFormat); + return false; + } + + format->major_type = WG_MAJOR_TYPE_VIDEO; + format->u.video.width = video_format->bmiHeader.biWidth; + format->u.video.height = video_format->bmiHeader.biHeight; + format->u.video.fps_n = 10000000; + format->u.video.fps_d = video_format->AvgTimePerFrame; + + for (i = 0; i < ARRAY_SIZE(format_map); ++i) + { + if (IsEqualGUID(&mt->subtype, format_map[i].subtype)) { - gst_structure_remove_fields(gst_caps_get_structure(caps, i), - "framerate", "pixel-aspect-ratio", "colorimetry", "chroma-site", NULL); + format->u.video.format = format_map[i].format; + return true; } } - return caps; + + FIXME("Unknown subtype %s.\n", debugstr_guid(&mt->subtype)); + return false; +} + +static bool amt_to_wg_format(const AM_MEDIA_TYPE *mt, struct wg_format *format) +{ + memset(format, 0, sizeof(*format)); + + if (IsEqualGUID(&mt->majortype, &MEDIATYPE_Video)) + return amt_to_wg_format_video(mt, format); + if (IsEqualGUID(&mt->majortype, &MEDIATYPE_Audio)) + return amt_to_wg_format_audio(mt, format); + + FIXME("Unknown major type %s.\n", debugstr_guid(&mt->majortype)); + return false; +} + +static GstAudioFormat wg_audio_format_to_gst(enum wg_audio_format format) +{ + switch (format) + { + case WG_AUDIO_FORMAT_U8: return GST_AUDIO_FORMAT_U8; + case WG_AUDIO_FORMAT_S16LE: return GST_AUDIO_FORMAT_S16LE; + case WG_AUDIO_FORMAT_S24LE: return GST_AUDIO_FORMAT_S24LE; + case WG_AUDIO_FORMAT_S32LE: return GST_AUDIO_FORMAT_S32LE; + case WG_AUDIO_FORMAT_F32LE: return GST_AUDIO_FORMAT_F32LE; + case WG_AUDIO_FORMAT_F64LE: return GST_AUDIO_FORMAT_F64LE; + default: return GST_AUDIO_FORMAT_UNKNOWN; + } }
-static GstCaps *amt_to_gst_caps_audio(const AM_MEDIA_TYPE *mt) +static GstCaps *wg_format_to_caps_audio(const struct wg_format *format) { - const WAVEFORMATEX *wfx = (WAVEFORMATEX *)mt->pbFormat; - GstAudioFormat format = GST_AUDIO_FORMAT_UNKNOWN; + GstAudioFormat audio_format; GstAudioInfo info;
- if (!IsEqualGUID(&mt->formattype, &FORMAT_WaveFormatEx) - || mt->cbFormat < sizeof(WAVEFORMATEX) || !mt->pbFormat) + if ((audio_format = wg_audio_format_to_gst(format->u.audio.format)) == GST_AUDIO_FORMAT_UNKNOWN) return NULL;
- if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_PCM)) - format = gst_audio_format_build_integer(wfx->wBitsPerSample != 8, - G_LITTLE_ENDIAN, wfx->wBitsPerSample, wfx->wBitsPerSample); - else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_IEEE_FLOAT)) + gst_audio_info_set_format(&info, audio_format, format->u.audio.rate, format->u.audio.channels, NULL); + return gst_audio_info_to_caps(&info); +} + +static GstVideoFormat wg_video_format_to_gst(enum wg_video_format format) +{ + switch (format) { - if (wfx->wBitsPerSample == 32) - format = GST_AUDIO_FORMAT_F32LE; - else if (wfx->wBitsPerSample == 64) - format = GST_AUDIO_FORMAT_F64LE; + case WG_VIDEO_FORMAT_BGRA: return GST_VIDEO_FORMAT_BGRA; + case WG_VIDEO_FORMAT_BGRx: return GST_VIDEO_FORMAT_BGRx; + case WG_VIDEO_FORMAT_BGR: return GST_VIDEO_FORMAT_BGR; + case WG_VIDEO_FORMAT_RGB15: return GST_VIDEO_FORMAT_RGB15; + case WG_VIDEO_FORMAT_RGB16: return GST_VIDEO_FORMAT_RGB16; + case WG_VIDEO_FORMAT_AYUV: return GST_VIDEO_FORMAT_AYUV; + case WG_VIDEO_FORMAT_I420: return GST_VIDEO_FORMAT_I420; + case WG_VIDEO_FORMAT_NV12: return GST_VIDEO_FORMAT_NV12; + case WG_VIDEO_FORMAT_UYVY: return GST_VIDEO_FORMAT_UYVY; + case WG_VIDEO_FORMAT_YUY2: return GST_VIDEO_FORMAT_YUY2; + case WG_VIDEO_FORMAT_YV12: return GST_VIDEO_FORMAT_YV12; + case WG_VIDEO_FORMAT_YVYU: return GST_VIDEO_FORMAT_YVYU; + default: return GST_VIDEO_FORMAT_UNKNOWN; } +}
- if (format == GST_AUDIO_FORMAT_UNKNOWN) - { - FIXME("Unknown audio format (subtype %s, depth %u).\n", - debugstr_guid(&mt->subtype), wfx->wBitsPerSample); +static GstCaps *wg_format_to_caps_video(const struct wg_format *format) +{ + GstVideoFormat video_format; + GstVideoInfo info; + unsigned int i; + GstCaps *caps; + + if ((video_format = wg_video_format_to_gst(format->u.video.format)) == GST_VIDEO_FORMAT_UNKNOWN) return NULL; + + gst_video_info_set_format(&info, video_format, format->u.video.width, format->u.video.height); + if ((caps = gst_video_info_to_caps(&info))) + { + /* Clear some fields that shouldn't prevent us from connecting. */ + for (i = 0; i < gst_caps_get_size(caps); ++i) + { + gst_structure_remove_fields(gst_caps_get_structure(caps, i), + "framerate", "pixel-aspect-ratio", "colorimetry", "chroma-site", NULL); + } } + return caps; +}
- gst_audio_info_set_format(&info, format, wfx->nSamplesPerSec, wfx->nChannels, NULL); - return gst_audio_info_to_caps(&info); +static GstCaps *wg_format_to_caps(const struct wg_format *format) +{ + switch (format->major_type) + { + case WG_MAJOR_TYPE_UNKNOWN: + return NULL; + case WG_MAJOR_TYPE_AUDIO: + return wg_format_to_caps_audio(format); + case WG_MAJOR_TYPE_VIDEO: + return wg_format_to_caps_video(format); + } + assert(0); + return NULL; }
static GstCaps *amt_to_gst_caps(const AM_MEDIA_TYPE *mt) { - if (IsEqualGUID(&mt->majortype, &MEDIATYPE_Video)) - return amt_to_gst_caps_video(mt); - else if (IsEqualGUID(&mt->majortype, &MEDIATYPE_Audio)) - return amt_to_gst_caps_audio(mt); + struct wg_format wg_format;
- FIXME("Unknown major type %s.\n", debugstr_guid(&mt->majortype)); - return NULL; + if (!amt_to_wg_format(mt, &wg_format)) + return NULL; + return wg_format_to_caps(&wg_format); }
static gboolean query_sink(GstPad *pad, GstObject *parent, GstQuery *query)
Signed-off-by: Zebediah Figura z.figura12@gmail.com --- dlls/winegstreamer/gstdemux.c | 229 +++++----------------------------- 1 file changed, 32 insertions(+), 197 deletions(-)
diff --git a/dlls/winegstreamer/gstdemux.c b/dlls/winegstreamer/gstdemux.c index 73458d9210e..82801900a15 100644 --- a/dlls/winegstreamer/gstdemux.c +++ b/dlls/winegstreamer/gstdemux.c @@ -104,12 +104,12 @@ struct wg_parser_stream { GstPad *their_src, *post_sink, *post_src, *my_sink; GstElement *flip; - GstCaps *caps; + struct wg_format preferred_format;
pthread_cond_t event_cond, event_empty_cond; struct wg_parser_event event;
- bool flushing, eos, enabled; + bool flushing, eos, enabled, has_caps;
uint64_t duration; }; @@ -172,152 +172,6 @@ static HRESULT WINAPI GST_ChangeCurrent(IMediaSeeking *iface); static HRESULT WINAPI GST_ChangeStop(IMediaSeeking *iface); static HRESULT WINAPI GST_ChangeRate(IMediaSeeking *iface);
-static gboolean amt_from_gst_audio_info(const GstAudioInfo *info, AM_MEDIA_TYPE *amt) -{ - WAVEFORMATEXTENSIBLE *wfe; - WAVEFORMATEX *wfx; - gint32 depth, bpp; - - wfe = CoTaskMemAlloc(sizeof(*wfe)); - wfx = (WAVEFORMATEX*)wfe; - amt->majortype = MEDIATYPE_Audio; - amt->subtype = MEDIASUBTYPE_PCM; - amt->formattype = FORMAT_WaveFormatEx; - amt->pbFormat = (BYTE*)wfe; - amt->cbFormat = sizeof(*wfe); - amt->bFixedSizeSamples = TRUE; - amt->bTemporalCompression = FALSE; - amt->pUnk = NULL; - - wfx->wFormatTag = WAVE_FORMAT_EXTENSIBLE; - - wfx->nChannels = info->channels; - wfx->nSamplesPerSec = info->rate; - depth = GST_AUDIO_INFO_WIDTH(info); - bpp = GST_AUDIO_INFO_DEPTH(info); - - if (!depth || depth > 32 || depth % 8) - depth = bpp; - else if (!bpp) - bpp = depth; - wfe->Samples.wValidBitsPerSample = depth; - wfx->wBitsPerSample = bpp; - wfx->cbSize = sizeof(*wfe)-sizeof(*wfx); - switch (wfx->nChannels) { - case 1: wfe->dwChannelMask = KSAUDIO_SPEAKER_MONO; break; - case 2: wfe->dwChannelMask = KSAUDIO_SPEAKER_STEREO; break; - case 4: wfe->dwChannelMask = KSAUDIO_SPEAKER_SURROUND; break; - case 5: wfe->dwChannelMask = (KSAUDIO_SPEAKER_5POINT1 & ~SPEAKER_LOW_FREQUENCY); break; - case 6: wfe->dwChannelMask = KSAUDIO_SPEAKER_5POINT1; break; - case 8: wfe->dwChannelMask = KSAUDIO_SPEAKER_7POINT1; break; - default: - wfe->dwChannelMask = 0; - } - if (GST_AUDIO_INFO_IS_FLOAT(info)) - { - amt->subtype = MEDIASUBTYPE_IEEE_FLOAT; - wfe->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT; - } else { - wfe->SubFormat = KSDATAFORMAT_SUBTYPE_PCM; - if (wfx->nChannels <= 2 && bpp <= 16 && depth == bpp) { - wfx->wFormatTag = WAVE_FORMAT_PCM; - wfx->cbSize = 0; - amt->cbFormat = sizeof(WAVEFORMATEX); - } - } - amt->lSampleSize = wfx->nBlockAlign = wfx->nChannels * wfx->wBitsPerSample/8; - wfx->nAvgBytesPerSec = wfx->nSamplesPerSec * wfx->nBlockAlign; - return TRUE; -} - -static gboolean amt_from_gst_video_info(const GstVideoInfo *info, AM_MEDIA_TYPE *amt) -{ - VIDEOINFO *vih; - BITMAPINFOHEADER *bih; - gint32 width, height; - - width = GST_VIDEO_INFO_WIDTH(info); - height = GST_VIDEO_INFO_HEIGHT(info); - - vih = CoTaskMemAlloc(sizeof(*vih)); - bih = &vih->bmiHeader; - - amt->formattype = FORMAT_VideoInfo; - amt->pbFormat = (BYTE*)vih; - amt->cbFormat = sizeof(VIDEOINFOHEADER); - amt->bFixedSizeSamples = FALSE; - amt->bTemporalCompression = TRUE; - amt->lSampleSize = 1; - amt->pUnk = NULL; - ZeroMemory(vih, sizeof(*vih)); - amt->majortype = MEDIATYPE_Video; - - if (GST_VIDEO_INFO_IS_RGB(info)) - { - bih->biCompression = BI_RGB; - switch (GST_VIDEO_INFO_FORMAT(info)) - { - case GST_VIDEO_FORMAT_BGRA: - amt->subtype = MEDIASUBTYPE_ARGB32; - bih->biBitCount = 32; - break; - case GST_VIDEO_FORMAT_BGRx: - amt->subtype = MEDIASUBTYPE_RGB32; - bih->biBitCount = 32; - break; - case GST_VIDEO_FORMAT_BGR: - amt->subtype = MEDIASUBTYPE_RGB24; - bih->biBitCount = 24; - break; - case GST_VIDEO_FORMAT_RGB16: - amt->subtype = MEDIASUBTYPE_RGB565; - amt->cbFormat = offsetof(VIDEOINFO, u.dwBitMasks[3]); - vih->u.dwBitMasks[iRED] = 0xf800; - vih->u.dwBitMasks[iGREEN] = 0x07e0; - vih->u.dwBitMasks[iBLUE] = 0x001f; - bih->biBitCount = 16; - bih->biCompression = BI_BITFIELDS; - break; - case GST_VIDEO_FORMAT_RGB15: - amt->subtype = MEDIASUBTYPE_RGB555; - bih->biBitCount = 16; - break; - default: - WARN("Cannot convert %s to a DirectShow type.\n", GST_VIDEO_INFO_NAME(info)); - CoTaskMemFree(vih); - return FALSE; - } - } else { - amt->subtype = MEDIATYPE_Video; - if (!(amt->subtype.Data1 = gst_video_format_to_fourcc(GST_VIDEO_INFO_FORMAT(info)))) - { - CoTaskMemFree(vih); - return FALSE; - } - switch (amt->subtype.Data1) { - case mmioFOURCC('I','4','2','0'): - case mmioFOURCC('Y','V','1','2'): - case mmioFOURCC('N','V','1','2'): - case mmioFOURCC('N','V','2','1'): - bih->biBitCount = 12; break; - case mmioFOURCC('Y','U','Y','2'): - case mmioFOURCC('Y','V','Y','U'): - case mmioFOURCC('U','Y','V','Y'): - bih->biBitCount = 16; break; - } - bih->biCompression = amt->subtype.Data1; - } - bih->biSizeImage = GST_VIDEO_INFO_SIZE(info); - if ((vih->AvgTimePerFrame = (REFERENCE_TIME)MulDiv(10000000, - GST_VIDEO_INFO_FPS_D(info), GST_VIDEO_INFO_FPS_N(info))) == -1) - vih->AvgTimePerFrame = 0; /* zero division or integer overflow */ - bih->biSize = sizeof(*bih); - bih->biWidth = width; - bih->biHeight = height; - bih->biPlanes = 1; - return TRUE; -} - static enum wg_audio_format wg_audio_format_from_gst(GstAudioFormat format) { switch (format) @@ -1281,7 +1135,8 @@ static gboolean event_sink(GstPad *pad, GstObject *parent, GstEvent *event)
gst_event_parse_caps(event, &caps); pthread_mutex_lock(&parser->mutex); - gst_caps_replace(&stream->caps, caps); + wg_format_from_caps(&stream->preferred_format, caps); + stream->has_caps = true; pthread_mutex_unlock(&parser->mutex); pthread_cond_signal(&parser->init_cond); break; @@ -2080,7 +1935,7 @@ static HRESULT GST_Connect(struct parser *This, IPin *pConnectPin) stream->duration = query_duration(stream->their_src); pin->seek.llDuration = pin->seek.llStop = stream->duration; pin->seek.llCurrent = 0; - while (!stream->caps && !parser->error) + while (!stream->has_caps && !parser->error) pthread_cond_wait(&parser->init_cond, &parser->mutex); if (parser->error) { @@ -2375,67 +2230,47 @@ static HRESULT decodebin_parser_source_get_media_type(struct parser_source *pin, unsigned int index, AM_MEDIA_TYPE *mt) { struct wg_parser_stream *stream = pin->wg_stream; - const GstCaps *caps = stream->caps; - const GstStructure *structure; - const char *type; + struct wg_format format = stream->preferred_format;
- static const GstVideoFormat video_formats[] = + static const enum wg_video_format video_formats[] = { /* Try to prefer YUV formats over RGB ones. Most decoders output in the * YUV color space, and it's generally much less expensive for * videoconvert to do YUV -> YUV transformations. */ - GST_VIDEO_FORMAT_AYUV, - GST_VIDEO_FORMAT_I420, - GST_VIDEO_FORMAT_YV12, - GST_VIDEO_FORMAT_YUY2, - GST_VIDEO_FORMAT_UYVY, - GST_VIDEO_FORMAT_YVYU, - GST_VIDEO_FORMAT_NV12, - GST_VIDEO_FORMAT_BGRA, - GST_VIDEO_FORMAT_BGRx, - GST_VIDEO_FORMAT_BGR, - GST_VIDEO_FORMAT_RGB16, - GST_VIDEO_FORMAT_RGB15, + WG_VIDEO_FORMAT_AYUV, + WG_VIDEO_FORMAT_I420, + WG_VIDEO_FORMAT_YV12, + WG_VIDEO_FORMAT_YUY2, + WG_VIDEO_FORMAT_UYVY, + WG_VIDEO_FORMAT_YVYU, + WG_VIDEO_FORMAT_NV12, + WG_VIDEO_FORMAT_BGRA, + WG_VIDEO_FORMAT_BGRx, + WG_VIDEO_FORMAT_BGR, + WG_VIDEO_FORMAT_RGB16, + WG_VIDEO_FORMAT_RGB15, };
- assert(caps); /* We shouldn't be able to get here if caps haven't been set. */ - structure = gst_caps_get_structure(caps, 0); - type = gst_structure_get_name(structure); - memset(mt, 0, sizeof(AM_MEDIA_TYPE));
- if (amt_from_gst_caps(caps, mt)) + if (amt_from_wg_format(mt, &format)) { if (!index--) return S_OK; FreeMediaType(mt); }
- if (!strcmp(type, "video/x-raw") && index < ARRAY_SIZE(video_formats)) + if (format.major_type == WG_MAJOR_TYPE_VIDEO && index < ARRAY_SIZE(video_formats)) { - gint width, height, fps_n, fps_d; - GstVideoInfo info; - - gst_structure_get_int(structure, "width", &width); - gst_structure_get_int(structure, "height", &height); - gst_video_info_set_format(&info, video_formats[index], width, height); - if (gst_structure_get_fraction(structure, "framerate", &fps_n, &fps_d) && fps_n) - { - info.fps_n = fps_n; - info.fps_d = fps_d; - } - if (!amt_from_gst_video_info(&info, mt)) + format.u.video.format = video_formats[index]; + if (!amt_from_wg_format(mt, &format)) return E_OUTOFMEMORY; return S_OK; } - else if (!strcmp(type, "audio/x-raw") && !index) + else if (format.major_type == WG_MAJOR_TYPE_AUDIO && !index) { - GstAudioInfo info; - gint rate; - - gst_structure_get_int(structure, "rate", &rate); - gst_audio_info_set_format(&info, GST_AUDIO_FORMAT_S16LE, rate, 2, NULL); - if (!amt_from_gst_audio_info(&info, mt)) + format.u.audio.format = WG_AUDIO_FORMAT_S16LE; + if (!amt_from_wg_format(mt, &format)) return E_OUTOFMEMORY; return S_OK; } @@ -3152,7 +2987,7 @@ static HRESULT wave_parser_source_query_accept(struct parser_source *pin, const AM_MEDIA_TYPE pad_mt; HRESULT hr;
- if (!amt_from_gst_caps(stream->caps, &pad_mt)) + if (!amt_from_wg_format(&pad_mt, &stream->preferred_format)) return E_OUTOFMEMORY; hr = compare_media_types(mt, &pad_mt) ? S_OK : S_FALSE; FreeMediaType(&pad_mt); @@ -3166,7 +3001,7 @@ static HRESULT wave_parser_source_get_media_type(struct parser_source *pin,
if (index > 0) return VFW_S_NO_MORE_ITEMS; - if (!amt_from_gst_caps(stream->caps, mt)) + if (!amt_from_wg_format(mt, &stream->preferred_format)) return E_OUTOFMEMORY; return S_OK; } @@ -3273,7 +3108,7 @@ static HRESULT avi_splitter_source_query_accept(struct parser_source *pin, const AM_MEDIA_TYPE pad_mt; HRESULT hr;
- if (!amt_from_gst_caps(stream->caps, &pad_mt)) + if (!amt_from_wg_format(&pad_mt, &stream->preferred_format)) return E_OUTOFMEMORY; hr = compare_media_types(mt, &pad_mt) ? S_OK : S_FALSE; FreeMediaType(&pad_mt); @@ -3287,7 +3122,7 @@ static HRESULT avi_splitter_source_get_media_type(struct parser_source *pin,
if (index > 0) return VFW_S_NO_MORE_ITEMS; - if (!amt_from_gst_caps(stream->caps, mt)) + if (!amt_from_wg_format(mt, &stream->preferred_format)) return E_OUTOFMEMORY; return S_OK; } @@ -3404,7 +3239,7 @@ static HRESULT mpeg_splitter_source_query_accept(struct parser_source *pin, cons AM_MEDIA_TYPE pad_mt; HRESULT hr;
- if (!amt_from_gst_caps(stream->caps, &pad_mt)) + if (!amt_from_wg_format(&pad_mt, &stream->preferred_format)) return E_OUTOFMEMORY; hr = compare_media_types(mt, &pad_mt) ? S_OK : S_FALSE; FreeMediaType(&pad_mt); @@ -3418,7 +3253,7 @@ static HRESULT mpeg_splitter_source_get_media_type(struct parser_source *pin,
if (index > 0) return VFW_S_NO_MORE_ITEMS; - if (!amt_from_gst_caps(stream->caps, mt)) + if (!amt_from_wg_format(mt, &stream->preferred_format)) return E_OUTOFMEMORY; return S_OK; }
Bleh, typo in the title, that should be "Store the preferred stream format as a wg_format structure."
-
Zebediah Figura -
Zebediah Figura (she/her)