#include "gstwavparse.h"
#include "gst/riff/riff-media.h"
#include <gst/base/gsttypefindhelper.h>
+#include <gst/pbutils/descriptions.h>
#include <gst/gst-i18n-plugin.h>
GST_DEBUG_CATEGORY_STATIC (wavparse_debug);
#define GST_CAT_DEFAULT (wavparse_debug)
-#define GST_BWF_TAG_iXML GST_MAKE_FOURCC ('i','X','M','L')
-#define GST_BWF_TAG_qlty GST_MAKE_FOURCC ('q','l','t','y')
-#define GST_BWF_TAG_mext GST_MAKE_FOURCC ('m','e','x','t')
-#define GST_BWF_TAG_levl GST_MAKE_FOURCC ('l','e','v','l')
-#define GST_BWF_TAG_link GST_MAKE_FOURCC ('l','i','n','k')
-#define GST_BWF_TAG_axml GST_MAKE_FOURCC ('a','x','m','l')
-
/* Data size chunk of RF64,
* see http://tech.ebu.ch/docs/tech/tech3306-2009.pdf */
#define GST_RS64_TAG_DS64 GST_MAKE_FOURCC ('d','s','6','4')
};
static GstStaticPadTemplate sink_template_factory =
-GST_STATIC_PAD_TEMPLATE ("sink",
+ GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
- GST_STATIC_CAPS ("audio/x-wav")
+ GST_STATIC_CAPS ("audio/x-wav;audio/x-rf64")
);
#define DEBUG_INIT \
gstelement_class->send_event = gst_wavparse_send_event;
/* register pads */
- gst_element_class_add_pad_template (gstelement_class,
- gst_static_pad_template_get (&sink_template_factory));
+ gst_element_class_add_static_pad_template (gstelement_class,
+ &sink_template_factory);
src_template = gst_pad_template_new ("src", GST_PAD_SRC,
GST_PAD_ALWAYS, gst_riff_create_audio_template_caps ());
}
static void
+gst_wavparse_notes_free (GstWavParseNote * note)
+{
+ if (note)
+ g_free (note->text);
+ g_free (note);
+}
+
+static void
+gst_wavparse_labls_free (GstWavParseLabl * labl)
+{
+ if (labl)
+ g_free (labl->text);
+ g_free (labl);
+}
+
+static void
gst_wavparse_reset (GstWavParse * wav)
{
wav->state = GST_WAVPARSE_START;
wav->dataleft = 0;
wav->datasize = 0;
wav->datastart = 0;
+ wav->chunk_size = 0;
wav->duration = 0;
wav->got_fmt = FALSE;
wav->first = TRUE;
g_list_free_full (wav->cues, g_free);
wav->cues = NULL;
if (wav->labls)
- g_list_free_full (wav->labls, g_free);
+ g_list_free_full (wav->labls, (GDestroyNotify) gst_wavparse_labls_free);
wav->labls = NULL;
+ if (wav->notes)
+ g_list_free_full (wav->notes, (GDestroyNotify) gst_wavparse_notes_free);
+ wav->notes = NULL;
if (wav->caps)
gst_caps_unref (wav->caps);
wav->caps = NULL;
gboolean update;
GstSegment seeksegment = { 0, };
gint64 last_stop;
+ guint32 seqnum = GST_SEQNUM_INVALID;
if (event) {
GST_DEBUG_OBJECT (wav, "doing seek with event");
gst_event_parse_seek (event, &rate, &format, &flags,
&cur_type, &cur, &stop_type, &stop);
+ seqnum = gst_event_get_seqnum (event);
/* no negative rates yet */
if (rate < 0.0)
/* BYTE seek event */
event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags, cur_type, cur,
stop_type, stop);
+ if (seqnum != GST_SEQNUM_INVALID)
+ gst_event_set_seqnum (event, seqnum);
res = gst_pad_push_event (wav->sinkpad, event);
}
return res;
* as it completes one iteration (and thus might block when the sink is
* blocking in preroll). */
if (flush) {
+ GstEvent *fevent;
GST_DEBUG_OBJECT (wav, "sending flush start");
- gst_pad_push_event (wav->srcpad, gst_event_new_flush_start ());
+
+ fevent = gst_event_new_flush_start ();
+ if (seqnum != GST_SEQNUM_INVALID)
+ gst_event_set_seqnum (fevent, seqnum);
+ gst_pad_push_event (wav->sinkpad, gst_event_ref (fevent));
+ gst_pad_push_event (wav->srcpad, fevent);
} else {
gst_pad_pause_task (wav->sinkpad);
}
if (gst_pad_peer_query_duration (wav->sinkpad, bformat, &upstream_size))
wav->end_offset = MIN (wav->end_offset, upstream_size);
+ if (wav->datasize > 0 && wav->end_offset > wav->datastart + wav->datasize)
+ wav->end_offset = wav->datastart + wav->datasize;
+
/* this is the range of bytes we will use for playback */
wav->offset = MIN (wav->offset, wav->end_offset);
wav->dataleft = wav->end_offset - wav->offset;
/* prepare for streaming again */
if (flush) {
+ GstEvent *fevent;
+
/* if we sent a FLUSH_START, we now send a FLUSH_STOP */
GST_DEBUG_OBJECT (wav, "sending flush stop");
- gst_pad_push_event (wav->srcpad, gst_event_new_flush_stop (TRUE));
+
+ fevent = gst_event_new_flush_stop (TRUE);
+ if (seqnum != GST_SEQNUM_INVALID)
+ gst_event_set_seqnum (fevent, seqnum);
+ gst_pad_push_event (wav->sinkpad, gst_event_ref (fevent));
+ gst_pad_push_event (wav->srcpad, fevent);
}
/* now we did the seek and can activate the new segment values */
if (wav->start_segment)
gst_event_unref (wav->start_segment);
wav->start_segment = gst_event_new_segment (&wav->segment);
+ if (seqnum != GST_SEQNUM_INVALID)
+ gst_event_set_seqnum (wav->start_segment, seqnum);
/* mark discont if we are going to stream from another position. */
if (last_stop != wav->segment.position) {
while (size >= 8) {
ltag = GST_READ_UINT32_LE (data + offset);
lsize = GST_READ_UINT32_LE (data + offset + 4);
+
+ if (lsize + 8 > size) {
+ GST_WARNING_OBJECT (wav, "Invalid adtl size: %u + 8 > %u", lsize, size);
+ return FALSE;
+ }
+
switch (ltag) {
case GST_RIFF_TAG_labl:
gst_wavparse_labl_chunk (wav, data + offset, size);
gboolean gotdata = FALSE;
GstCaps *caps = NULL;
gchar *codec_name = NULL;
- GstEvent **event_p;
gint64 upstream_size = 0;
GstStructure *s;
- /* search for "_fmt" chunk, which should be first */
+ /* search for "_fmt" chunk, which must be before "data" */
while (!wav->got_fmt) {
GstBuffer *extra;
- /* The header starts with a 'fmt ' tag */
if (wav->streaming) {
if (!gst_wavparse_peek_chunk (wav, &tag, &size))
return res;
return res;
}
- if (tag == GST_RIFF_TAG_JUNK || tag == GST_RIFF_TAG_JUNQ ||
- tag == GST_RIFF_TAG_bext || tag == GST_RIFF_TAG_BEXT ||
- tag == GST_RIFF_TAG_LIST || tag == GST_RIFF_TAG_ID32 ||
- tag == GST_RIFF_TAG_id3 || tag == GST_RIFF_TAG_IDVX ||
- tag == GST_BWF_TAG_iXML || tag == GST_BWF_TAG_qlty ||
- tag == GST_BWF_TAG_mext || tag == GST_BWF_TAG_levl ||
- tag == GST_BWF_TAG_link || tag == GST_BWF_TAG_axml) {
- GST_DEBUG_OBJECT (wav, "skipping %" GST_FOURCC_FORMAT " chunk",
- GST_FOURCC_ARGS (tag));
- gst_buffer_unref (buf);
- buf = NULL;
- continue;
- }
-
if (tag == GST_RS64_TAG_DS64) {
if (!parse_ds64 (wav, buf))
goto fail;
continue;
}
- if (tag != GST_RIFF_TAG_fmt)
- goto invalid_wav;
+ if (tag != GST_RIFF_TAG_fmt) {
+ GST_DEBUG_OBJECT (wav, "skipping %" GST_FOURCC_FORMAT " chunk",
+ GST_FOURCC_ARGS (tag));
+ gst_buffer_unref (buf);
+ buf = NULL;
+ continue;
+ }
if (!(gst_riff_parse_strf_auds (GST_ELEMENT_CAST (wav), buf, &header,
&extra)))
wav->got_fmt = TRUE;
- if (codec_name) {
+ if (wav->tags == NULL)
wav->tags = gst_tag_list_new_empty ();
+ {
+ GstCaps *templ_caps = gst_pad_get_pad_template_caps (wav->sinkpad);
+ gst_pb_utils_add_codec_description_to_tag_list (wav->tags,
+ GST_TAG_CONTAINER_FORMAT, templ_caps);
+ gst_caps_unref (templ_caps);
+ }
+
+ /* If bps is nonzero, then we do have a valid bitrate that can be
+ * announced in a tag list. */
+ if (wav->bps) {
+ guint bitrate = wav->bps * 8;
+ gst_tag_list_add (wav->tags, GST_TAG_MERGE_REPLACE,
+ GST_TAG_BITRATE, bitrate, NULL);
+ }
+
+ if (codec_name) {
gst_tag_list_add (wav->tags, GST_TAG_MERGE_REPLACE,
GST_TAG_AUDIO_CODEC, codec_name, NULL);
}
GST_INFO_OBJECT (wav,
- "Got TAG: %" GST_FOURCC_FORMAT ", offset %" G_GUINT64_FORMAT,
- GST_FOURCC_ARGS (tag), wav->offset);
+ "Got TAG: %" GST_FOURCC_FORMAT ", offset %" G_GUINT64_FORMAT ", size %"
+ G_GUINT32_FORMAT, GST_FOURCC_ARGS (tag), wav->offset, size);
+
+ /* Maximum valid size is INT_MAX */
+ if (size & 0x80000000) {
+ GST_WARNING_OBJECT (wav, "Invalid size, clipping to 0x7fffffff");
+ size = 0x7fffffff;
+ }
+
+ /* Clip to upstream size if known */
+ if (upstream_size > 0 && size + wav->offset > upstream_size) {
+ GST_WARNING_OBJECT (wav, "Clipping chunk size to file size");
+ g_assert (upstream_size >= wav->offset);
+ size = upstream_size - wav->offset;
+ }
/* wav is a st00pid format, we don't know for sure where data starts.
* So we have to go bit by bit until we find the 'data' header
*/
switch (tag) {
case GST_RIFF_TAG_data:{
+ guint64 size64;
+
GST_DEBUG_OBJECT (wav, "Got 'data' TAG, size : %u", size);
+ size64 = size;
if (wav->ignore_length) {
GST_DEBUG_OBJECT (wav, "Ignoring length");
- size = 0;
+ size64 = 0;
}
if (wav->streaming) {
gst_adapter_flush (wav->adapter, 8);
wav->offset += 8;
wav->datastart = wav->offset;
/* use size from ds64 chunk if available */
- if (size == -1 && wav->datasize > 0) {
+ if (size64 == -1 && wav->datasize > 0) {
GST_DEBUG_OBJECT (wav, "Using ds64 datasize");
- size = wav->datasize;
+ size64 = wav->datasize;
}
+ wav->chunk_size = size64;
+
/* If size is zero, then the data chunk probably actually extends to
the end of the file */
- if (size == 0 && upstream_size) {
- size = upstream_size - wav->datastart;
+ if (size64 == 0 && upstream_size) {
+ size64 = upstream_size - wav->datastart;
}
/* Or the file might be truncated */
else if (upstream_size) {
- size = MIN (size, (upstream_size - wav->datastart));
+ size64 = MIN (size64, (upstream_size - wav->datastart));
}
- wav->datasize = (guint64) size;
- wav->dataleft = (guint64) size;
- wav->end_offset = size + wav->datastart;
+ wav->datasize = size64;
+ wav->dataleft = size64;
+ wav->end_offset = size64 + wav->datastart;
if (!wav->streaming) {
/* We will continue parsing tags 'till end */
- wav->offset += size;
+ wav->offset += size64;
}
- GST_DEBUG_OBJECT (wav, "datasize = %u", size);
+ GST_DEBUG_OBJECT (wav, "datasize = %" G_GUINT64_FORMAT, size64);
break;
}
case GST_RIFF_TAG_fact:{
break;
}
case GST_RIFF_LIST_adtl:{
- const gint data_size = size;
+ const gint data_size = size - 4;
GST_INFO_OBJECT (wav, "Have 'adtl' LIST, size %u", data_size);
if (wav->streaming) {
const guint8 *data = NULL;
gst_adapter_flush (wav->adapter, 12);
+ wav->offset += 12;
data = gst_adapter_map (wav->adapter, data_size);
gst_wavparse_adtl_chunk (wav, data, data_size);
gst_adapter_unmap (wav->adapter);
gst_buffer_unref (buf);
buf = NULL;
+ wav->offset += 12;
if ((res =
- gst_pad_pull_range (wav->sinkpad, wav->offset + 12,
+ gst_pad_pull_range (wav->sinkpad, wav->offset,
data_size, &buf)) != GST_FLOW_OK)
goto header_read_error;
gst_buffer_map (buf, &map, GST_MAP_READ);
* the right newsegment event downstream. */
gst_wavparse_perform_seek (wav, wav->seek_event);
/* remove pending event */
- event_p = &wav->seek_event;
- gst_event_replace (event_p, NULL);
+ gst_event_replace (&wav->seek_event, NULL);
/* we just started, we are discont */
wav->discont = TRUE;
/* ERROR */
exit:
{
- if (codec_name)
- g_free (codec_name);
- if (header)
- g_free (header);
+ g_free (codec_name);
+ g_free (header);
if (caps)
gst_caps_unref (caps);
return res;
res = GST_FLOW_ERROR;
goto exit;
}
-invalid_wav:
- {
- GST_ELEMENT_ERROR (wav, STREAM, TYPE_NOT_FOUND, (NULL),
- ("Invalid WAV header (no fmt at start): %"
- GST_FOURCC_FORMAT, GST_FOURCC_ARGS (tag)));
- goto fail;
- }
parse_header_error:
{
GST_ELEMENT_ERROR (wav, STREAM, DEMUX, (NULL),
{
GstWavParse *wav = GST_WAVPARSE (element);
gboolean res = FALSE;
- GstEvent **event_p;
GST_DEBUG_OBJECT (wav, "received event %s", GST_EVENT_TYPE_NAME (event));
} else {
GST_DEBUG_OBJECT (wav, "queuing seek for later");
- event_p = &wav->seek_event;
- gst_event_replace (event_p, event);
+ gst_event_replace (&wav->seek_event, event);
/* we always return true */
res = TRUE;
s = gst_caps_get_structure (caps, 0);
if (!gst_structure_has_name (s, "audio/x-dts"))
return FALSE;
- if (prob >= GST_TYPE_FIND_LIKELY)
+ /* typefind behavior for DTS:
+ * MAXIMUM: multiple frame syncs detected, certainly DTS
+ * LIKELY: single frame sync at offset 0. Maybe DTS?
+ * POSSIBLE: single frame sync, not at offset 0. Highly unlikely
+ * to be DTS. */
+ if (prob > GST_TYPE_FIND_LIKELY)
return TRUE;
- /* DTS at non-0 offsets and without second sync may yield POSSIBLE .. */
- if (prob < GST_TYPE_FIND_POSSIBLE)
+ if (prob <= GST_TYPE_FIND_POSSIBLE)
return FALSE;
- /* .. in which case we want at least a valid-looking rate and channels */
+ /* for maybe, check for at least a valid-looking rate and channels */
if (!gst_structure_has_field (s, "channels"))
return FALSE;
/* and for extra assurance we could also check the rate from the DTS frame
}
gst_pad_set_caps (wav->srcpad, wav->caps);
- gst_caps_replace (&wav->caps, NULL);
if (wav->start_segment) {
GST_DEBUG_OBJECT (wav, "Send start segment event on newpad");
}
static GstFlowReturn
-gst_wavparse_stream_data (GstWavParse * wav)
+gst_wavparse_stream_data (GstWavParse * wav, gboolean flushing)
{
GstBuffer *buf = NULL;
GstFlowReturn res = GST_FLOW_OK;
"offset: %" G_GINT64_FORMAT " , end: %" G_GINT64_FORMAT " , dataleft: %"
G_GINT64_FORMAT, wav->offset, wav->end_offset, wav->dataleft);
- /* Get the next n bytes and output them */
- if (wav->dataleft == 0 || wav->dataleft < wav->blockalign)
- goto found_eos;
+ if ((wav->dataleft == 0 || wav->dataleft < wav->blockalign)) {
+ /* In case chunk size is not declared in the begining get size from the
+ * file size directly */
+ if (wav->chunk_size == 0) {
+ gint64 upstream_size = 0;
+
+ /* Get the size of the file */
+ if (!gst_pad_peer_query_duration (wav->sinkpad, GST_FORMAT_BYTES,
+ &upstream_size))
+ goto found_eos;
+
+ if (upstream_size < wav->offset + wav->datastart)
+ goto found_eos;
+
+ /* If file has updated since the beggining continue reading the file */
+ wav->dataleft = upstream_size - wav->offset - wav->datastart;
+ wav->end_offset = upstream_size;
+
+ /* Get the next n bytes and output them, if we can */
+ if (wav->dataleft == 0 || wav->dataleft < wav->blockalign)
+ goto found_eos;
+ } else {
+ goto found_eos;
+ }
+ }
/* scale the amount of data by the segment rate so we get equal
* amounts of data regardless of the playback rate */
if (avail < desired) {
GST_LOG_OBJECT (wav, "Got only %u bytes of data from the sinkpad", avail);
- return GST_FLOW_OK;
- }
- buf = gst_adapter_take_buffer (wav->adapter, desired);
+ /* If we are at the end of the stream, we need to flush whatever we have left */
+ if (avail > 0 && flushing) {
+ if (avail >= wav->blockalign && wav->blockalign > 0) {
+ avail -= (avail % wav->blockalign);
+ buf = gst_adapter_take_buffer (wav->adapter, avail);
+ } else {
+ return GST_FLOW_OK;
+ }
+ } else {
+ return GST_FLOW_OK;
+ }
+ } else {
+ buf = gst_adapter_take_buffer (wav->adapter, desired);
+ }
} else {
if ((res = gst_pad_pull_range (wav->sinkpad, wav->offset,
desired, &buf)) != GST_FLOW_OK)
/* fall-through */
case GST_WAVPARSE_DATA:
- if ((ret = gst_wavparse_stream_data (wav)) != GST_FLOW_OK)
+ if ((ret = gst_wavparse_stream_data (wav, FALSE)) != GST_FLOW_OK)
goto pause;
break;
default:
else if (wav->segment.rate < 0.0)
wav->segment.position = wav->segment.start;
}
- if (wav->state == GST_WAVPARSE_START) {
+ if (wav->state == GST_WAVPARSE_START || !wav->caps) {
GST_ELEMENT_ERROR (wav, STREAM, WRONG_TYPE, (NULL),
("No valid input found before end of stream"));
gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
} else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
/* for fatal errors we post an error message, post the error
* first so the app knows about the error first. */
- GST_ELEMENT_ERROR (wav, STREAM, FAILED,
- (_("Internal data flow error.")),
- ("streaming task paused, reason %s (%d)", reason, ret));
+ GST_ELEMENT_FLOW_ERROR (wav, ret);
gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
}
return;
case GST_WAVPARSE_DATA:
if (buf && GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DISCONT))
wav->discont = TRUE;
- if ((ret = gst_wavparse_stream_data (wav)) != GST_FLOW_OK)
+ if ((ret = gst_wavparse_stream_data (wav, FALSE)) != GST_FLOW_OK)
goto done;
break;
default:
guint av;
if ((av = gst_adapter_available (wav->adapter)) > 0) {
- wav->dataleft = av;
- wav->end_offset = wav->offset + av;
- ret = gst_wavparse_stream_data (wav);
+ ret = gst_wavparse_stream_data (wav, TRUE);
}
return ret;
}
if (stop > 0) {
end_offset = stop;
- segment.stop -= wav->datastart;
- segment.stop = MAX (stop, 0);
+ stop -= wav->datastart;
+ stop = MAX (stop, 0);
}
if (wav->segment.format == GST_FORMAT_TIME) {
guint64 bps = wav->bps;
/* and set up streaming thread for next one */
wav->offset = offset;
wav->end_offset = end_offset;
- if (wav->end_offset > 0) {
+
+ if (wav->datasize > 0 && (wav->end_offset == -1
+ || wav->end_offset > wav->datastart + wav->datasize))
+ wav->end_offset = wav->datastart + wav->datasize;
+
+ if (wav->end_offset != -1) {
wav->dataleft = wav->end_offset - wav->offset;
} else {
/* infinity; upstream will EOS when done */
break;
}
case GST_EVENT_EOS:
- if (wav->state == GST_WAVPARSE_START) {
+ if (wav->state == GST_WAVPARSE_START || !wav->caps) {
GST_ELEMENT_ERROR (wav, STREAM, WRONG_TYPE, (NULL),
("No valid input found before end of stream"));
} else {
if (G_UNLIKELY (wav->first)) {
wav->first = FALSE;
gst_wavparse_add_src_pad (wav, NULL);
- } else {
- /* stream leftover data in current segment */
- gst_wavparse_flush_data (wav);
}
+
+ /* stream leftover data in current segment */
+ gst_wavparse_flush_data (wav);
}
/* fall-through */
{
GstClockTime dur;
- gst_adapter_clear (wav->adapter);
+ if (wav->adapter)
+ gst_adapter_clear (wav->adapter);
wav->discont = TRUE;
dur = wav->segment.duration;
gst_segment_init (&wav->segment, wav->segment.format);
static const GstFormat *
gst_wavparse_get_formats (GstPad * pad)
{
- static GstFormat formats[] = {
+ static const GstFormat formats[] = {
GST_FORMAT_TIME,
GST_FORMAT_BYTES,
GST_FORMAT_DEFAULT, /* a "frame", ie a set of samples per Hz */
}
break;
}
+ case GST_QUERY_SEGMENT:
+ {
+ GstFormat format;
+ gint64 start, stop;
+
+ format = wav->segment.format;
+
+ start =
+ gst_segment_to_stream_time (&wav->segment, format,
+ wav->segment.start);
+ if ((stop = wav->segment.stop) == -1)
+ stop = wav->segment.duration;
+ else
+ stop = gst_segment_to_stream_time (&wav->segment, format, stop);
+
+ gst_query_set_segment (query, wav->segment.rate, format, start, stop);
+ res = TRUE;
+ break;
+ }
default:
res = gst_pad_query_default (pad, parent, query);
break;
projects / platform / upstream / gst-plugins-good.git / blobdiff