FCL/sf/mw/gstreamer: comparison gst_plugins_good/gst/wavparse/gstwavparse.c

equal deleted inserted replaced

-:567bb019e3e3
+:7e817e7e631c
 */
 /**
 * SECTION:element-wavparse
 *
+* <refsect2>
+* <para>
 * Parse a .wav file into raw or compressed audio.
-*
+* </para>
-* Wavparse supports both push and pull mode operations, making it possible to
+* <para>
-* stream from a network source.
+* This element currently only supports pull based scheduling.
-*
+* </para>
-* <refsect2>
 * <title>Example launch line</title>
-* |[
+* <para>
+* <programlisting>
 * gst-launch filesrc location=sine.wav ! wavparse ! audioconvert ! alsasink
-* ]| Read a wav file and output to the soundcard using the ALSA element. The
+* </programlisting>
+* Read a wav file and output to the soundcard using the ALSA element. The
 * wav file is assumed to contain raw uncompressed samples.
-* |[
+* </para>
+* <para>
+* <programlisting>
 * gst-launch gnomevfssrc location=http://www.example.org/sine.wav ! queue ! wavparse ! audioconvert ! alsasink
-* ]| Stream data from a network url.
+* </programlisting>
+* Stream data from
+* </para>
 * </refsect2>
 *
-* Last reviewed on 2007-02-14 (0.10.6)
+* Last reviewed on 2006-03-03 (0.10.3)
-*/
-/*
-* TODO:
-* http://replaygain.hydrogenaudio.org/file_format_wav.html
 */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
-#include <string.h>
-#include <math.h>
+#include "string.h"
 #include "gstwavparse.h"
-#include "gst/riff/riff-ids.h"
+#include <gst/riff/riff-ids.h>
-#include "gst/riff/riff-media.h"
+#include <gst/riff/riff-media.h>
+#include <gst/riff/riff-read.h>
+#ifndef __SYMBIAN32__
 #include <gst/gst-i18n-plugin.h>
+#else
+#include "gst/gst-i18n-plugin.h"
+#endif
+#ifdef __SYMBIAN32__
+#include <gst/gstinfo.h>
+#endif
+#ifndef G_MAXUINT32
+#define G_MAXUINT32 0xffffffff
+#endif
 GST_DEBUG_CATEGORY_STATIC (wavparse_debug);
 #define GST_CAT_DEFAULT (wavparse_debug)
+static void gst_wavparse_base_init (gpointer g_class);
+static void gst_wavparse_class_init (GstWavParseClass * klass);
+static void gst_wavparse_init (GstWavParse * wavparse);
 static void gst_wavparse_dispose (GObject * object);
 static gboolean gst_wavparse_sink_activate (GstPad * sinkpad);
 static gboolean gst_wavparse_sink_activate_pull (GstPad * sinkpad,
 gboolean active);
 static gboolean gst_wavparse_send_event (GstElement * element,
 GstEvent * event);
+static GstFlowReturn gst_wavparse_chain (GstPad * pad, GstBuffer * buf);
 static GstStateChangeReturn gst_wavparse_change_state (GstElement * element,
 GstStateChange transition);
+static gboolean gst_wavparse_pad_query (GstPad * pad, GstQuery * query);
 static const GstQueryType *gst_wavparse_get_query_types (GstPad * pad);
-static gboolean gst_wavparse_pad_query (GstPad * pad, GstQuery * query);
 static gboolean gst_wavparse_pad_convert (GstPad * pad,
 GstFormat src_format,
 gint64 src_value, GstFormat * dest_format, gint64 * dest_value);
-static GstFlowReturn gst_wavparse_chain (GstPad * pad, GstBuffer * buf);
-static gboolean gst_wavparse_sink_event (GstPad * pad, GstEvent * event);
 static void gst_wavparse_loop (GstPad * pad);
 static gboolean gst_wavparse_srcpad_event (GstPad * pad, GstEvent * event);
+static void gst_wavparse_get_property (GObject * object, guint prop_id,
+GValue * value, GParamSpec * pspec);
 static const GstElementDetails gst_wavparse_details =
 GST_ELEMENT_DETAILS ("WAV audio demuxer",
 "Codec/Demuxer/Audio",
 "Parse a .wav file into raw audio",
 "Erik Walthinsen <omega@cse.ogi.edu>");
 static GstStaticPadTemplate sink_template_factory =
-GST_STATIC_PAD_TEMPLATE ("wavparse_sink",
+//GST_STATIC_PAD_TEMPLATE ("wavparse_sink",
+GST_STATIC_PAD_TEMPLATE ("sink",
 GST_PAD_SINK,
 GST_PAD_ALWAYS,
 GST_STATIC_CAPS ("audio/x-wav")
 );
-#define DEBUG_INIT(bla) \
+/* the pad is marked a sometimes and is added to the element when the
-GST_DEBUG_CATEGORY_INIT (wavparse_debug, "wavparse", 0, "WAV parser");
+* exact type is known. This makes it much easier for a static autoplugger
+* to connect the right decoder when needed.
-GST_BOILERPLATE_FULL (GstWavParse, gst_wavparse, GstElement,
+*/
-GST_TYPE_ELEMENT, DEBUG_INIT);
+static GstStaticPadTemplate src_template_factory =
+//   GST_STATIC_PAD_TEMPLATE ("wavparse_src",
+GST_STATIC_PAD_TEMPLATE ("src",
+GST_PAD_SRC,
+GST_PAD_SOMETIMES,
+GST_STATIC_CAPS ("audio/x-raw-int, "
+"endianness = (int) little_endian, "
+"signed = (boolean) { true, false }, "
+"width = (int) { 8, 16, 24, 32 }, "
+"depth = (int) { 8, 16, 24, 32 }, "
+"rate = (int) [ 8000, 96000 ], "
+"channels = (int) [ 1, 8 ]; "
+"audio/mpeg, "
+"mpegversion = (int) 1, "
+"layer = (int) [ 1, 3 ], "
+"rate = (int) [ 8000, 48000 ], "
+"channels = (int) [ 1, 2 ]; "
+"audio/x-alaw, "
+"rate = (int) [ 8000, 48000 ], "
+"channels = (int) [ 1, 2 ]; "
+"audio/x-mulaw, "
+"rate = (int) [ 8000, 48000 ], " "channels = (int) [ 1, 2 ];"
+"audio/x-adpcm, "
+"layout = (string) microsoft, "
+"block_align = (int) [ 1, 8192 ], "
+"rate = (int) [ 8000, 48000 ], "
+"channels = (int) [ 1, 2 ]; "
+"audio/x-adpcm, "
+"layout = (string) dvi, "
+"block_align = (int) [ 1, 8192 ], "
+"rate = (int) [ 8000, 48000 ], " "channels = (int) [ 1, 2 ];"
+"audio/x-vnd.sony.atrac3;"
+"audio/x-dts;" "audio/x-wma, " "wmaversion = (int) [ 1, 2 ]")
+);
+static GstElementClass *parent_class = NULL;
+GType
+gst_wavparse_get_type (void)
+{
+static GType wavparse_type = 0;
+if (!wavparse_type) {
+static const GTypeInfo wavparse_info = {
+sizeof (GstWavParseClass),
+gst_wavparse_base_init,
+NULL,
+(GClassInitFunc) gst_wavparse_class_init,
+NULL,
+NULL,
+sizeof (GstWavParse),
+0,
+(GInstanceInitFunc) gst_wavparse_init,
+};
+wavparse_type =
+g_type_register_static (GST_TYPE_ELEMENT, "GstWavParse",
+&wavparse_info, 0);
+}
+return wavparse_type;
+}
 static void
 gst_wavparse_base_init (gpointer g_class)
 {
 GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
-GstPadTemplate *src_template;
+/* register src pads */
-/* register pads */
 gst_element_class_add_pad_template (element_class,
 gst_static_pad_template_get (&sink_template_factory));
+gst_element_class_add_pad_template (element_class,
-src_template = gst_pad_template_new ("wavparse_src", GST_PAD_SRC,
+gst_static_pad_template_get (&src_template_factory));
-GST_PAD_SOMETIMES, gst_riff_create_audio_template_caps ());
-gst_element_class_add_pad_template (element_class, src_template);
-gst_object_unref (src_template);
 gst_element_class_set_details (element_class, &gst_wavparse_details);
 }
 static void
 gst_wavparse_class_init (GstWavParseClass * klass)
 gstelement_class = (GstElementClass *) klass;
 object_class = (GObjectClass *) klass;
 parent_class = g_type_class_peek_parent (klass);
+object_class->get_property = gst_wavparse_get_property;
 object_class->dispose = gst_wavparse_dispose;
 gstelement_class->change_state = gst_wavparse_change_state;
 gstelement_class->send_event = gst_wavparse_send_event;
 }
 static void
-gst_wavparse_reset (GstWavParse * wav)
+gst_wavparse_dispose (GObject * object)
 {
-wav->state = GST_WAVPARSE_START;
+	#ifndef __SYMBIAN32__
+GST_DEBUG("WAV: Dispose\n");
-/* These will all be set correctly in the fmt chunk */
+#endif
-wav->depth = 0;
+GstWavParse *wav = GST_WAVPARSE (object);
-wav->rate = 0;
+#ifdef __SYMBIAN32__
-wav->width = 0;
+GST_DEBUG("WAV: Dispose\n");
-wav->channels = 0;
+	#endif
-wav->blockalign = 0;
-wav->bps = 0;
-wav->fact = 0;
-wav->offset = 0;
-wav->end_offset = 0;
-wav->dataleft = 0;
-wav->datasize = 0;
-wav->datastart = 0;
-wav->duration = 0;
-wav->got_fmt = FALSE;
-wav->first = TRUE;
-if (wav->seek_event)
-gst_event_unref (wav->seek_event);
-wav->seek_event = NULL;
 if (wav->adapter) {
-gst_adapter_clear (wav->adapter);
 g_object_unref (wav->adapter);
 wav->adapter = NULL;
 }
-if (wav->tags)
-gst_tag_list_free (wav->tags);
+G_OBJECT_CLASS (parent_class)->dispose (object);
-wav->tags = NULL;
+}
-}
 static void
-gst_wavparse_dispose (GObject * object)
+gst_wavparse_reset (GstWavParse * wavparse)
 {
-GstWavParse *wav = GST_WAVPARSE (object);
+wavparse->state = GST_WAVPARSE_START;
-GST_DEBUG_OBJECT (wav, "WAV: Dispose");
+/* These will all be set correctly in the fmt chunk */
-gst_wavparse_reset (wav);
+wavparse->depth = 0;
+wavparse->rate = 0;
-G_OBJECT_CLASS (parent_class)->dispose (object);
+wavparse->width = 0;
+wavparse->channels = 0;
+wavparse->blockalign = 0;
+wavparse->bps = 0;
+wavparse->offset = 0;
+wavparse->end_offset = 0;
+wavparse->dataleft = 0;
+wavparse->datasize = 0;
+wavparse->datastart = 0;
+wavparse->got_fmt = FALSE;
+wavparse->first = TRUE;
+if (wavparse->seek_event)
+gst_event_unref (wavparse->seek_event);
+wavparse->seek_event = NULL;
+/* we keep the segment info in time */
+gst_segment_init (&wavparse->segment, GST_FORMAT_TIME);
 }
 static void
-gst_wavparse_init (GstWavParse * wavparse, GstWavParseClass * g_class)
+gst_wavparse_init (GstWavParse * wavparse)
 {
 gst_wavparse_reset (wavparse);
 /* sink */
 wavparse->sinkpad =
 GST_DEBUG_FUNCPTR (gst_wavparse_sink_activate));
 gst_pad_set_activatepull_function (wavparse->sinkpad,
 GST_DEBUG_FUNCPTR (gst_wavparse_sink_activate_pull));
 gst_pad_set_chain_function (wavparse->sinkpad,
 GST_DEBUG_FUNCPTR (gst_wavparse_chain));
-gst_pad_set_event_function (wavparse->sinkpad,
+gst_element_add_pad (GST_ELEMENT (wavparse), wavparse->sinkpad);
-GST_DEBUG_FUNCPTR (gst_wavparse_sink_event));
-gst_element_add_pad (GST_ELEMENT_CAST (wavparse), wavparse->sinkpad);
 /* src, will be created later */
 wavparse->srcpad = NULL;
 }
 static void
 gst_wavparse_destroy_sourcepad (GstWavParse * wavparse)
 {
 if (wavparse->srcpad) {
-gst_element_remove_pad (GST_ELEMENT_CAST (wavparse), wavparse->srcpad);
+gst_element_remove_pad (GST_ELEMENT (wavparse), wavparse->srcpad);
 wavparse->srcpad = NULL;
 }
 }
 static void
 gst_wavparse_create_sourcepad (GstWavParse * wavparse)
 {
-GstElementClass *klass = GST_ELEMENT_GET_CLASS (wavparse);
-GstPadTemplate *src_template;
 /* destroy previous one */
 gst_wavparse_destroy_sourcepad (wavparse);
 /* source */
-src_template = gst_element_class_get_pad_template (klass, "wavparse_src");
+wavparse->srcpad =
-wavparse->srcpad = gst_pad_new_from_template (src_template, "src");
+gst_pad_new_from_static_template (&src_template_factory, "src");
 gst_pad_use_fixed_caps (wavparse->srcpad);
 gst_pad_set_query_type_function (wavparse->srcpad,
 GST_DEBUG_FUNCPTR (gst_wavparse_get_query_types));
 gst_pad_set_query_function (wavparse->srcpad,
 GST_DEBUG_FUNCPTR (gst_wavparse_pad_query));
 GST_DEBUG_FUNCPTR (gst_wavparse_srcpad_event));
 GST_DEBUG_OBJECT (wavparse, "srcpad created");
 }
-/* Compute (value * nom) % denom, avoiding overflow.  This can be used
+static void
-* to perform ceiling or rounding division together with
+gst_wavparse_get_property (GObject * object,
-* gst_util_uint64_scale[_int]. */
+guint prop_id, GValue * value, GParamSpec * pspec)
-#define uint64_scale_modulo(val, nom, denom) \
+{
-((val % denom) * (nom % denom) % denom)
+GstWavParse *wavparse;
-/* Like gst_util_uint64_scale, but performs ceiling division. */
+wavparse = GST_WAVPARSE (object);
-static guint64
-uint64_ceiling_scale_int (guint64 val, gint num, gint denom)
+switch (prop_id) {
-{
+default:
-guint64 result = gst_util_uint64_scale_int (val, num, denom);
+break;
+}
-if (uint64_scale_modulo (val, num, denom) == 0)
+}
-return result;
-else
-return result + 1;
-}
-/* Like gst_util_uint64_scale, but performs ceiling division. */
-static guint64
-uint64_ceiling_scale (guint64 val, guint64 num, guint64 denom)
-{
-guint64 result = gst_util_uint64_scale (val, num, denom);
-if (uint64_scale_modulo (val, num, denom) == 0)
-return result;
-else
-return result + 1;
-}
-/* FIXME: why is that not in use? */
 #if 0
 static void
 gst_wavparse_parse_adtl (GstWavParse * wavparse, int len)
 {
 guint32 got_bytes;
 gst_wavparse_fmt (GstWavParse * wav)
 {
 gst_riff_strf_auds *header = NULL;
 GstCaps *caps;
-if (!gst_riff_read_strf_auds (wav, &header))
+if (!gst_riff_read_strf_auds (wav, &header)) {
-goto no_fmt;
+g_warning ("Not fmt");
+return FALSE;
+}
 wav->format = header->format;
 wav->rate = header->rate;
 wav->channels = header->channels;
-if (wav->channels == 0)
+if (wav->channels == 0) {
-goto no_channels;
+GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
+("Stream claims to contain zero channels - invalid data"));
+g_free (header);
+return FALSE;
+}
 wav->blockalign = header->blockalign;
 wav->width = (header->blockalign * 8) / header->channels;
 wav->depth = header->size;
 wav->bps = header->av_bps;
-if (wav->bps <= 0)
+if (wav->bps <= 0) {
-goto no_bps;
-/* Note: gst_riff_create_audio_caps might need to fix values in
-* the header header depending on the format, so call it first */
-caps = gst_riff_create_audio_caps (header->format, NULL, header, NULL);
-g_free (header);
-if (caps == NULL)
-goto no_caps;
-gst_wavparse_create_sourcepad (wav);
-gst_pad_use_fixed_caps (wav->srcpad);
-gst_pad_set_active (wav->srcpad, TRUE);
-gst_pad_set_caps (wav->srcpad, caps);
-gst_caps_free (caps);
-gst_element_add_pad (GST_ELEMENT_CAST (wav), wav->srcpad);
-gst_element_no_more_pads (GST_ELEMENT_CAST (wav));
-GST_DEBUG ("frequency %d, channels %d", wav->rate, wav->channels);
-return TRUE;
-/* ERRORS */
-no_fmt:
-{
-GST_ELEMENT_ERROR (wav, STREAM, TYPE_NOT_FOUND, (NULL),
-("No FMT tag found"));
-return FALSE;
-}
-no_channels:
-{
-GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
-("Stream claims to contain zero channels - invalid data"));
-g_free (header);
-return FALSE;
-}
-no_bps:
-{
 GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
 ("Stream claims to bitrate of <= zero - invalid data"));
 g_free (header);
 return FALSE;
 }
-no_caps:
-{
+/* Note: gst_riff_create_audio_caps might nedd to fix values in
+* the header header depending on the format, so call it first */
+caps = gst_riff_create_audio_caps (header->format, NULL, header, NULL);
+g_free (header);
+if (caps) {
+gst_wavparse_create_sourcepad (wav);
+gst_pad_use_fixed_caps (wav->srcpad);
+gst_pad_set_active (wav->srcpad, TRUE);
+gst_pad_set_caps (wav->srcpad, caps);
+gst_caps_free (caps);
+gst_element_add_pad (GST_ELEMENT (wav), wav->srcpad);
+gst_element_no_more_pads (GST_ELEMENT (wav));
+GST_DEBUG ("frequency %d, channels %d", wav->rate, wav->channels);
+} else {
 GST_ELEMENT_ERROR (wav, STREAM, TYPE_NOT_FOUND, (NULL), (NULL));
 return FALSE;
 }
+return TRUE;
 }
 static gboolean
 gst_wavparse_other (GstWavParse * wav)
 {
 length = file_length - wav->datastart;
 GST_DEBUG_OBJECT (wav, "datalength %lld", length);
 }
 }
 wav->datasize = (guint64) length;
-GST_DEBUG_OBJECT (wav, "datasize = %ld", length)
+break;
-break;
 case GST_RIFF_TAG_cue:
 if (!gst_riff_read_skip (wav)) {
 GST_WARNING_OBJECT (wav, "could not read skip");
 return FALSE;
 return TRUE;
 }
 #endif
 static gboolean
 gst_wavparse_parse_file_header (GstElement * element, GstBuffer * buf)
 {
 guint32 doctype;
 if (!gst_riff_parse_file_header (element, buf, &doctype))
 return FALSE;
 if (doctype != GST_RIFF_RIFF_WAVE)
 goto not_wav;
 return TRUE;
 /* ERRORS */
 not_wav:
 {
 GST_ELEMENT_ERROR (element, STREAM, WRONG_TYPE, (NULL),
-("File is not a WAVE file: %" GST_FOURCC_FORMAT,
+("File is not an WAVE file: %" GST_FOURCC_FORMAT,
 GST_FOURCC_ARGS (doctype)));
 return FALSE;
 }
 }
 gst_wavparse_stream_init (GstWavParse * wav)
 {
 GstFlowReturn res;
 GstBuffer *buf = NULL;
 if ((res = gst_pad_pull_range (wav->sinkpad,
 wav->offset, 12, &buf)) != GST_FLOW_OK)
+{
 return res;
-else if (!gst_wavparse_parse_file_header (GST_ELEMENT_CAST (wav), buf))
+}
+else if (!gst_wavparse_parse_file_header (GST_ELEMENT (wav), buf))
 return GST_FLOW_ERROR;
 wav->offset += 12;
 return GST_FLOW_OK;
 }
-static gboolean
+/* This function is used to perform seeks on the element in
-gst_wavparse_time_to_bytepos (GstWavParse * wav, gint64 ts, gint64 * bytepos)
+* pull mode.
-{
-/* -1 always maps to -1 */
-if (ts == -1) {
-*bytepos = -1;
-return TRUE;
-}
-/* 0 always maps to 0 */
-if (ts == 0) {
-*bytepos = 0;
-return TRUE;
-}
-if (wav->bps > 0) {
-*bytepos = uint64_ceiling_scale (ts, (guint64) wav->bps, GST_SECOND);
-return TRUE;
-} else if (wav->fact) {
-guint64 bps =
-gst_util_uint64_scale_int (wav->datasize, wav->rate, wav->fact);
-*bytepos = uint64_ceiling_scale (ts, bps, GST_SECOND);
-return TRUE;
-}
-return FALSE;
-}
-/* This function is used to perform seeks on the element.
 *
 * It also works when event is NULL, in which case it will just
 * start from the last configured segment. This technique is
 * used when activating the element and to perform the seek in
 * READY.
 static gboolean
 gst_wavparse_perform_seek (GstWavParse * wav, GstEvent * event)
 {
 gboolean res;
 gdouble rate;
-GstFormat format, bformat;
+GstEvent *newsegment;
+GstFormat format;
 GstSeekFlags flags;
-GstSeekType cur_type = GST_SEEK_TYPE_NONE, stop_type;
+GstSeekType cur_type, stop_type;
-gint64 cur, stop, upstream_size;
+gint64 cur, stop;
 gboolean flush;
 gboolean update;
-GstSegment seeksegment = { 0, };
+GstSegment seeksegment;
-gint64 last_stop;
 if (event) {
 GST_DEBUG_OBJECT (wav, "doing seek with event");
 gst_event_parse_seek (event, &rate, &format, &flags,
 &cur_type, &cur, &stop_type, &stop);
-/* no negative rates yet */
+/* we have to have a format as the segment format. Try to convert
-if (rate < 0.0)
+* if not. */
-goto negative_rate;
+if (format != GST_FORMAT_TIME) {
+GstFormat fmt;
-if (format != wav->segment.format) {
-GST_INFO_OBJECT (wav, "converting seek-event from %s to %s",
+fmt = GST_FORMAT_TIME;
-gst_format_get_name (format),
-gst_format_get_name (wav->segment.format));
 res = TRUE;
 if (cur_type != GST_SEEK_TYPE_NONE)
-res =
+res = gst_pad_query_convert (wav->srcpad, format, cur, &fmt, &cur);
-gst_pad_query_convert (wav->srcpad, format, cur,
-&wav->segment.format, &cur);
 if (res && stop_type != GST_SEEK_TYPE_NONE)
-res =
+res = gst_pad_query_convert (wav->srcpad, format, stop, &fmt, &stop);
-gst_pad_query_convert (wav->srcpad, format, stop,
-&wav->segment.format, &stop);
 if (!res)
 goto no_format;
-format = wav->segment.format;
+format = fmt;
 }
 } else {
 GST_DEBUG_OBJECT (wav, "doing seek without event");
 flags = 0;
-rate = 1.0;
+}
-cur_type = GST_SEEK_TYPE_SET;
-stop_type = GST_SEEK_TYPE_SET;
-}
-/* in push mode, we must delegate to upstream */
-if (wav->streaming) {
-gboolean res = FALSE;
-/* if streaming not yet started; only prepare initial newsegment */
-if (!event || wav->state != GST_WAVPARSE_DATA) {
-if (wav->start_segment)
-gst_event_unref (wav->start_segment);
-wav->start_segment =
-gst_event_new_new_segment (FALSE, wav->segment.rate,
-wav->segment.format, wav->segment.last_stop, wav->segment.duration,
-wav->segment.last_stop);
-res = TRUE;
-} else {
-/* convert seek positions to byte positions in data sections */
-if (format == GST_FORMAT_TIME) {
-/* should not fail */
-if (!gst_wavparse_time_to_bytepos (wav, cur, &cur))
-goto no_position;
-if (!gst_wavparse_time_to_bytepos (wav, stop, &stop))
-goto no_position;
-}
-/* mind sample boundary and header */
-if (cur >= 0) {
-cur -= (cur % wav->bytes_per_sample);
-cur += wav->datastart;
-}
-if (stop >= 0) {
-stop -= (stop % wav->bytes_per_sample);
-stop += wav->datastart;
-}
-GST_DEBUG_OBJECT (wav, "Pushing BYTE seek rate %g, "
-"start %" G_GINT64_FORMAT ", stop %" G_GINT64_FORMAT, rate, cur,
-stop);
-/* BYTE seek event */
-event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags, cur_type, cur,
-stop_type, stop);
-res = gst_pad_push_event (wav->sinkpad, event);
-}
-return res;
-}
-/* get flush flag */
 flush = flags & GST_SEEK_FLAG_FLUSH;
-/* now we need to make sure the streaming thread is stopped. We do this by
+if (flush && wav->srcpad) {
-* either sending a FLUSH_START event downstream which will cause the
+GST_DEBUG_OBJECT (wav, "sending flush start");
-* streaming thread to stop with a WRONG_STATE.
+gst_pad_push_event (wav->srcpad, gst_event_new_flush_start ());
-* For a non-flushing seek we simply pause the task, which will happen as soon
-* as it completes one iteration (and thus might block when the sink is
-* blocking in preroll). */
-if (flush) {
-if (wav->srcpad) {
-GST_DEBUG_OBJECT (wav, "sending flush start");
-gst_pad_push_event (wav->srcpad, gst_event_new_flush_start ());
-}
 } else {
 gst_pad_pause_task (wav->sinkpad);
 }
-/* we should now be able to grab the streaming thread because we stopped it
-* with the above flush/pause code */
 GST_PAD_STREAM_LOCK (wav->sinkpad);
-/* save current position */
-last_stop = wav->segment.last_stop;
-GST_DEBUG_OBJECT (wav, "stopped streaming at %" G_GINT64_FORMAT, last_stop);
 /* copy segment, we need this because we still need the old
 * segment when we close the current segment. */
 memcpy (&seeksegment, &wav->segment, sizeof (GstSegment));
-/* configure the seek parameters in the seeksegment. We will then have the
-* right values in the segment to perform the seek */
 if (event) {
 GST_DEBUG_OBJECT (wav, "configuring seek");
 gst_segment_set_seek (&seeksegment, rate, format, flags,
 cur_type, cur, stop_type, stop, &update);
 }
-/* figure out the last position we need to play. If it's configured (stop !=
-* -1), use that, else we play until the total duration of the file */
 if ((stop = seeksegment.stop) == -1)
 stop = seeksegment.duration;
-GST_DEBUG_OBJECT (wav, "cur_type =%d", cur_type);
+if (cur_type != GST_SEEK_TYPE_NONE) {
-if ((cur_type != GST_SEEK_TYPE_NONE)) {
+wav->offset =
-/* bring offset to bytes, if the bps is 0, we have the segment in BYTES and
+gst_util_uint64_scale_int (seeksegment.last_stop, wav->bps, GST_SECOND);
-* we can just copy the last_stop. If not, we use the bps to convert TIME to
+wav->offset -= wav->offset % wav->bytes_per_sample;
-* bytes. */
-if (!gst_wavparse_time_to_bytepos (wav, seeksegment.last_stop,
-(gint64 *) & wav->offset))
-wav->offset = seeksegment.last_stop;
-GST_LOG_OBJECT (wav, "offset=%" G_GUINT64_FORMAT, wav->offset);
-wav->offset -= (wav->offset % wav->bytes_per_sample);
-GST_LOG_OBJECT (wav, "offset=%" G_GUINT64_FORMAT, wav->offset);
 wav->offset += wav->datastart;
-GST_LOG_OBJECT (wav, "offset=%" G_GUINT64_FORMAT, wav->offset);
+}
+if (stop != -1) {
+wav->end_offset = gst_util_uint64_scale_int (stop, wav->bps, GST_SECOND);
+wav->end_offset +=
+wav->bytes_per_sample - (wav->end_offset % wav->bytes_per_sample);
+wav->end_offset += wav->datastart;
 } else {
-GST_LOG_OBJECT (wav, "continue from offset=%" G_GUINT64_FORMAT,
+wav->end_offset = wav->datasize + wav->datastart;
-wav->offset);
+}
-}
-if (stop_type != GST_SEEK_TYPE_NONE) {
-if (!gst_wavparse_time_to_bytepos (wav, stop, (gint64 *) & wav->end_offset))
-wav->end_offset = stop;
-GST_LOG_OBJECT (wav, "end_offset=%" G_GUINT64_FORMAT, wav->end_offset);
-wav->end_offset -= (wav->end_offset % wav->bytes_per_sample);
-GST_LOG_OBJECT (wav, "end_offset=%" G_GUINT64_FORMAT, wav->end_offset);
-wav->end_offset += wav->datastart;
-GST_LOG_OBJECT (wav, "end_offset=%" G_GUINT64_FORMAT, wav->end_offset);
-} else {
-GST_LOG_OBJECT (wav, "continue to end_offset=%" G_GUINT64_FORMAT,
-wav->end_offset);
-}
-/* make sure filesize is not exceeded due to rounding errors or so,
-* same precaution as in _stream_headers */
-bformat = GST_FORMAT_BYTES;
-if (gst_pad_query_peer_duration (wav->sinkpad, &bformat, &upstream_size))
-wav->end_offset = MIN (wav->end_offset, upstream_size);
-/* 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;
 GST_DEBUG_OBJECT (wav,
-"seek: rate %lf, offset %" G_GUINT64_FORMAT ", end %" G_GUINT64_FORMAT
+"seek: offset %" G_GUINT64_FORMAT ", end %" G_GUINT64_FORMAT ", segment %"
-", segment %" GST_TIME_FORMAT " -- %" GST_TIME_FORMAT, rate, wav->offset,
+GST_TIME_FORMAT " -- %" GST_TIME_FORMAT, wav->offset, wav->end_offset,
-wav->end_offset, GST_TIME_ARGS (seeksegment.start), GST_TIME_ARGS (stop));
+GST_TIME_ARGS (seeksegment.start), GST_TIME_ARGS (stop));
 /* prepare for streaming again */
 if (wav->srcpad) {
 if (flush) {
-/* 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 ());
 } else if (wav->segment_running) {
 /* we are running the current segment and doing a non-flushing seek,
-* close the segment first based on the previous last_stop. */
+* close the segment first based on the last_stop. */
 GST_DEBUG_OBJECT (wav, "closing running segment %" G_GINT64_FORMAT
-" to %" G_GINT64_FORMAT, wav->segment.accum, wav->segment.last_stop);
+" to %" G_GINT64_FORMAT, wav->segment.start, wav->segment.last_stop);
-/* queue the segment for sending in the stream thread */
+gst_pad_push_event (wav->srcpad,
-if (wav->close_segment)
+gst_event_new_new_segment (TRUE,
-gst_event_unref (wav->close_segment);
+wav->segment.rate, wav->segment.format,
-wav->close_segment = gst_event_new_new_segment (TRUE,
+wav->segment.start, wav->segment.last_stop, wav->segment.time));
-wav->segment.rate, wav->segment.format,
+}
-wav->segment.accum, wav->segment.last_stop, wav->segment.accum);
+}
-/* keep track of our last_stop */
-seeksegment.accum = wav->segment.last_stop;
-}
-}
-/* now we did the seek and can activate the new segment values */
 memcpy (&wav->segment, &seeksegment, sizeof (GstSegment));
-/* if we're doing a segment seek, post a SEGMENT_START message */
 if (wav->segment.flags & GST_SEEK_FLAG_SEGMENT) {
-gst_element_post_message (GST_ELEMENT_CAST (wav),
+gst_element_post_message (GST_ELEMENT (wav),
-gst_message_new_segment_start (GST_OBJECT_CAST (wav),
+gst_message_new_segment_start (GST_OBJECT (wav),
 wav->segment.format, wav->segment.last_stop));
 }
-/* now create the newsegment */
+/* now send the newsegment */
-GST_DEBUG_OBJECT (wav, "Creating newsegment from %" G_GINT64_FORMAT
+GST_DEBUG_OBJECT (wav, "Sending newsegment from %" G_GINT64_FORMAT
-" to %" G_GINT64_FORMAT, wav->segment.last_stop, stop);
+" to %" G_GINT64_FORMAT, wav->segment.start, stop);
-/* store the newsegment event so it can be sent from the streaming thread. */
+newsegment =
-if (wav->start_segment)
-gst_event_unref (wav->start_segment);
-wav->start_segment =
 gst_event_new_new_segment (FALSE, wav->segment.rate,
-wav->segment.format, wav->segment.last_stop, stop,
+wav->segment.format, wav->segment.last_stop, stop, wav->segment.time);
-wav->segment.last_stop);
+if (wav->srcpad) {
-/* mark discont if we are going to stream from another position. */
+gst_pad_push_event (wav->srcpad, newsegment);
-if (last_stop != wav->segment.last_stop) {
+} else {
-GST_DEBUG_OBJECT (wav, "mark DISCONT, we did a seek to another position");
+/* send later when we actually create the source pad */
-wav->discont = TRUE;
+g_assert (wav->newsegment == NULL);
-}
+wav->newsegment = newsegment;
+}
-/* and start the streaming task again */
 wav->segment_running = TRUE;
 if (!wav->streaming) {
 gst_pad_start_task (wav->sinkpad, (GstTaskFunction) gst_wavparse_loop,
 wav->sinkpad);
 }
 GST_PAD_STREAM_UNLOCK (wav->sinkpad);
 return TRUE;
 /* ERRORS */
-negative_rate:
-{
-GST_DEBUG_OBJECT (wav, "negative playback rates are not supported yet.");
-return FALSE;
-}
 no_format:
 {
 GST_DEBUG_OBJECT (wav, "unsupported format given, seek aborted.");
-return FALSE;
-}
-no_position:
-{
-GST_DEBUG_OBJECT (wav,
-"Could not determine byte position for desired time");
 return FALSE;
 }
 }
 /*
 * gst_wavparse_peek_chunk_info:
 * @wav Wavparse object
 * @tag holder for tag
 * @size holder for tag size
+*
+* Peek next chunk info (tag and size)
 *
-* Peek next chunk info (tag and size)
+* Returns: %TRUE when one chunk info has been got from the adapter
-*
-* Returns: %TRUE when the chunk info (header) is available
 */
 static gboolean
 gst_wavparse_peek_chunk_info (GstWavParse * wav, guint32 * tag, guint32 * size)
 {
 const guint8 *data = NULL;
-if (gst_adapter_available (wav->adapter) < 8)
+if (gst_adapter_available (wav->adapter) < 8) {
 return FALSE;
+}
+GST_DEBUG ("Next chunk size is %d bytes", *size);
 data = gst_adapter_peek (wav->adapter, 8);
 *tag = GST_READ_UINT32_LE (data);
 *size = GST_READ_UINT32_LE (data + 4);
-GST_DEBUG ("Next chunk size is %d bytes, type %" GST_FOURCC_FORMAT, *size,
-GST_FOURCC_ARGS (*tag));
 return TRUE;
 }
 /*
 * @tag holder for tag
 * @size holder for tag size
 *
 * Peek enough data for one full chunk
 *
-* Returns: %TRUE when the full chunk is available
+* Returns: %TRUE when one chunk has been got
 */
 static gboolean
 gst_wavparse_peek_chunk (GstWavParse * wav, guint32 * tag, guint32 * size)
 {
 guint32 peek_size = 0;
-guint available;
+gst_wavparse_peek_chunk_info (wav, tag, size);
-if (!gst_wavparse_peek_chunk_info (wav, tag, size))
-return FALSE;
 GST_DEBUG ("Need to peek chunk of %d bytes", *size);
 peek_size = (*size + 1) & ~1;
-available = gst_adapter_available (wav->adapter);
+if (gst_adapter_available (wav->adapter) >= (8 + peek_size)) {
-if (available >= (8 + peek_size)) {
 return TRUE;
 } else {
-GST_LOG ("but only %u bytes available now", available);
 return FALSE;
 }
 }
-/*
-* gst_wavparse_calculate_duration:
-* @wav: wavparse object
-*
-* Calculate duration on demand and store in @wav. Prefer bps, but use fact as a
-* fallback.
-*
-* Returns: %TRUE if duration is available.
-*/
 static gboolean
-gst_wavparse_calculate_duration (GstWavParse * wav)
+gst_wavparse_get_upstream_size (GstWavParse * wav, gint64 * len)
 {
-if (wav->duration > 0)
+gboolean res = FALSE;
-return TRUE;
+GstFormat fmt = GST_FORMAT_BYTES;
+GstPad *peer;
-if (wav->bps > 0) {
-GST_INFO_OBJECT (wav, "Got datasize %" G_GUINT64_FORMAT, wav->datasize);
+if ((peer = gst_pad_get_peer (wav->sinkpad))) {
-wav->duration =
+res = gst_pad_query_duration (peer, &fmt, len);
-uint64_ceiling_scale (wav->datasize, GST_SECOND, (guint64) wav->bps);
+gst_object_unref (peer);
-GST_INFO_OBJECT (wav, "Got duration (bps) %" GST_TIME_FORMAT,
+}
-GST_TIME_ARGS (wav->duration));
-return TRUE;
+return res;
-} else if (wav->fact) {
-wav->duration = uint64_ceiling_scale_int (GST_SECOND, wav->fact, wav->rate);
-GST_INFO_OBJECT (wav, "Got duration (fact) %" GST_TIME_FORMAT,
-GST_TIME_ARGS (wav->duration));
-return TRUE;
-}
-return FALSE;
-}
-static void
-gst_waveparse_ignore_chunk (GstWavParse * wav, GstBuffer * buf, guint32 tag,
-guint32 size)
-{
-guint flush;
-if (wav->streaming) {
-if (!gst_wavparse_peek_chunk (wav, &tag, &size))
-return;
-}
-GST_DEBUG_OBJECT (wav, "Ignoring tag %" GST_FOURCC_FORMAT,
-GST_FOURCC_ARGS (tag));
-flush = 8 + ((size + 1) & ~1);
-wav->offset += flush;
-if (wav->streaming) {
-gst_adapter_flush (wav->adapter, flush);
-} else {
-gst_buffer_unref (buf);
-}
 }
 static GstFlowReturn
 gst_wavparse_stream_headers (GstWavParse * wav)
 {
 GstBuffer *buf;
 gst_riff_strf_auds *header = NULL;
 guint32 tag, size;
 gboolean gotdata = FALSE;
 GstCaps *caps;
+gint64 duration;
 gchar *codec_name = NULL;
 GstEvent **event_p;
-GstFormat bformat;
-gint64 upstream_size = 0;
+if (!wav->got_fmt) {
-/* search for "_fmt" chunk, which should be first */
-while (!wav->got_fmt) {
 GstBuffer *extra;
-/* The header starts with a 'fmt ' tag */
+/* The header start with a 'fmt ' tag */
 if (wav->streaming) {
 if (!gst_wavparse_peek_chunk (wav, &tag, &size))
 return GST_FLOW_OK;
+buf = gst_buffer_new ();
+gst_buffer_ref (buf);
 gst_adapter_flush (wav->adapter, 8);
 wav->offset += 8;
+GST_BUFFER_DATA (buf) = (guint8 *) gst_adapter_peek (wav->adapter, size);
-buf = gst_adapter_take_buffer (wav->adapter, size);
+GST_BUFFER_SIZE (buf) = size;
 } else {
-if ((res = gst_riff_read_chunk (GST_ELEMENT_CAST (wav), wav->sinkpad,
+if ((res = gst_riff_read_chunk (GST_ELEMENT (wav), wav->sinkpad,
 &wav->offset, &tag, &buf)) != GST_FLOW_OK)
 return res;
 }
-if (tag == GST_RIFF_TAG_JUNK || tag == GST_RIFF_TAG_bext ||
-tag == GST_RIFF_TAG_BEXT || tag == GST_RIFF_TAG_LIST) {
-GST_DEBUG_OBJECT (wav, "skipping %" GST_FOURCC_FORMAT " chunk",
-GST_FOURCC_ARGS (tag));
-gst_buffer_unref (buf);
-buf = NULL;
-continue;
-}
 if (tag != GST_RIFF_TAG_fmt)
 goto invalid_wav;
-if (!(gst_riff_parse_strf_auds (GST_ELEMENT_CAST (wav), buf, &header,
+if (!(gst_riff_parse_strf_auds (GST_ELEMENT (wav), buf, &header, &extra)))
-&extra)))
 goto parse_header_error;
-buf = NULL;                 /* parse_strf_auds() took ownership of buffer */
+if (wav->streaming) {
+gst_adapter_flush (wav->adapter, size);
-/* do sanity checks of header fields */
+wav->offset += size;
-if (header->channels == 0)
+GST_BUFFER_DATA (buf) = NULL;
-goto no_channels;
+gst_buffer_unref (buf);
-if (header->rate == 0)
+}
-goto no_rate;
+/* Note: gst_riff_create_audio_caps might nedd to fix values in
-GST_DEBUG_OBJECT (wav, "creating the caps");
-/* Note: gst_riff_create_audio_caps might need to fix values in
 * the header header depending on the format, so call it first */
-caps = gst_riff_create_audio_caps (header->format, NULL, header, extra,
+caps =
+gst_riff_create_audio_caps (header->format, NULL, header, extra,
 NULL, &codec_name);
 if (extra)
 gst_buffer_unref (extra);
-if (!caps)
-goto unknown_format;
-/* do more sanity checks of header fields
-* (these can be sanitized by gst_riff_create_audio_caps()
-*/
 wav->format = header->format;
 wav->rate = header->rate;
 wav->channels = header->channels;
+if (wav->channels == 0)
+goto no_channels;
 wav->blockalign = header->blockalign;
+wav->width = (header->blockalign * 8) / header->channels;
 wav->depth = header->size;
-wav->av_bps = header->av_bps;
+wav->bps = header->av_bps;
-wav->vbr = FALSE;
+if (wav->bps <= 0)
-g_free (header);
+goto no_bitrate;
-header = NULL;
-/* do format specific handling */
-switch (wav->format) {
-case GST_RIFF_WAVE_FORMAT_MPEGL12:
-case GST_RIFF_WAVE_FORMAT_MPEGL3:
-{
-/* Note: workaround for mp2/mp3 embedded in wav, that relies on the
-* bitrate inside the mpeg stream */
-GST_INFO ("resetting bps from %d to 0 for mp2/3", wav->av_bps);
-wav->bps = 0;
-break;
-}
-case GST_RIFF_WAVE_FORMAT_PCM:
-if (wav->blockalign > wav->channels * (guint) ceil (wav->depth / 8.0))
-goto invalid_blockalign;
-/* fall through */
-default:
-if (wav->av_bps > wav->blockalign * wav->rate)
-goto invalid_bps;
-/* use the configured bps */
-wav->bps = wav->av_bps;
-break;
-}
-wav->width = (wav->blockalign * 8) / wav->channels;
 wav->bytes_per_sample = wav->channels * wav->width / 8;
 if (wav->bytes_per_sample <= 0)
 goto no_bytes_per_sample;
+g_free (header);
+if (!caps)
+goto unknown_format;
 GST_DEBUG_OBJECT (wav, "blockalign = %u", (guint) wav->blockalign);
 GST_DEBUG_OBJECT (wav, "width      = %u", (guint) wav->width);
 GST_DEBUG_OBJECT (wav, "depth      = %u", (guint) wav->depth);
-GST_DEBUG_OBJECT (wav, "av_bps     = %u", (guint) wav->av_bps);
-GST_DEBUG_OBJECT (wav, "frequency  = %u", (guint) wav->rate);
-GST_DEBUG_OBJECT (wav, "channels   = %u", (guint) wav->channels);
-GST_DEBUG_OBJECT (wav, "bytes_per_sample = %u", wav->bytes_per_sample);
-/* bps can be 0 when we don't have a valid bitrate (mostly for compressed
-* formats). This will make the element output a BYTE format segment and
-* will not timestamp the outgoing buffers.
-*/
 GST_DEBUG_OBJECT (wav, "bps        = %u", (guint) wav->bps);
-GST_DEBUG_OBJECT (wav, "caps = %" GST_PTR_FORMAT, caps);
 /* create pad later so we can sniff the first few bytes
 * of the real data and correct our caps if necessary */
 gst_caps_replace (&wav->caps, caps);
 gst_caps_replace (&caps, NULL);
 g_free (codec_name);
 codec_name = NULL;
 }
-}
+GST_DEBUG_OBJECT (wav, "frequency %d, channels %d", wav->rate,
+wav->channels);
-bformat = GST_FORMAT_BYTES;
+}
-gst_pad_query_peer_duration (wav->sinkpad, &bformat, &upstream_size);
-GST_DEBUG_OBJECT (wav, "upstream size %" G_GUINT64_FORMAT, upstream_size);
 /* loop headers until we get data */
 while (!gotdata) {
 if (wav->streaming) {
 if (!gst_wavparse_peek_chunk_info (wav, &tag, &size))
 goto header_read_error;
 tag = GST_READ_UINT32_LE (GST_BUFFER_DATA (buf));
 size = GST_READ_UINT32_LE (GST_BUFFER_DATA (buf) + 4);
 }
-GST_INFO_OBJECT (wav,
+/*
-"Got TAG: %" GST_FOURCC_FORMAT ", offset %" G_GUINT64_FORMAT,
+wav is a st00pid format, we don't know for sure where data starts.
-GST_FOURCC_ARGS (tag), wav->offset);
+So we have to go bit by bit until we find the 'data' header
-/* 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) {
+/* TODO : Implement the various cases */
 case GST_RIFF_TAG_data:{
+gint64 upstream_size;
 GST_DEBUG_OBJECT (wav, "Got 'data' TAG, size : %d", size);
+gotdata = TRUE;
 if (wav->streaming) {
 gst_adapter_flush (wav->adapter, 8);
-gotdata = TRUE;
 } else {
 gst_buffer_unref (buf);
 }
 wav->offset += 8;
 wav->datastart = wav->offset;
 /* file might be truncated */
-if (upstream_size) {
+if (gst_wavparse_get_upstream_size (wav, &upstream_size)) {
 size = MIN (size, (upstream_size - wav->datastart));
 }
-wav->datasize = (guint64) size;
+wav->datasize = size;
-wav->dataleft = (guint64) size;
+wav->dataleft = size;
 wav->end_offset = size + wav->datastart;
-if (!wav->streaming) {
-/* We will continue parsing tags 'till end */
-wav->offset += size;
-}
-GST_DEBUG_OBJECT (wav, "datasize = %d", size);
-break;
-}
-case GST_RIFF_TAG_fact:{
-if (wav->format != GST_RIFF_WAVE_FORMAT_MPEGL12 &&
-wav->format != GST_RIFF_WAVE_FORMAT_MPEGL3) {
-const guint data_size = 4;
-/* number of samples (for compressed formats) */
-if (wav->streaming) {
-const guint8 *data = NULL;
-if (gst_adapter_available (wav->adapter) < 8 + data_size) {
-return GST_FLOW_OK;
-}
-gst_adapter_flush (wav->adapter, 8);
-data = gst_adapter_peek (wav->adapter, data_size);
-wav->fact = GST_READ_UINT32_LE (data);
-gst_adapter_flush (wav->adapter, data_size);
-} else {
-gst_buffer_unref (buf);
-if ((res =
-gst_pad_pull_range (wav->sinkpad, wav->offset + 8,
-data_size, &buf)) != GST_FLOW_OK)
-goto header_read_error;
-wav->fact = GST_READ_UINT32_LE (GST_BUFFER_DATA (buf));
-gst_buffer_unref (buf);
-}
-GST_DEBUG_OBJECT (wav, "have fact %u", wav->fact);
-wav->offset += 8 + data_size;
-break;
-} else {
-gst_waveparse_ignore_chunk (wav, buf, tag, size);
-}
-break;
-}
-case GST_RIFF_TAG_acid:{
-const gst_riff_acid *acid = NULL;
-const guint data_size = sizeof (gst_riff_acid);
-if (wav->streaming) {
-if (gst_adapter_available (wav->adapter) < 8 + data_size) {
-return GST_FLOW_OK;
-}
-gst_adapter_flush (wav->adapter, 8);
-acid = (const gst_riff_acid *) gst_adapter_peek (wav->adapter,
-data_size);
-} else {
-gst_buffer_unref (buf);
-if ((res =
-gst_pad_pull_range (wav->sinkpad, wav->offset + 8,
-data_size, &buf)) != GST_FLOW_OK)
-goto header_read_error;
-acid = (const gst_riff_acid *) GST_BUFFER_DATA (buf);
-}
-GST_INFO_OBJECT (wav, "Have acid chunk");
-/* send data as tags */
-if (!wav->tags)
-wav->tags = gst_tag_list_new ();
-gst_tag_list_add (wav->tags, GST_TAG_MERGE_REPLACE,
-GST_TAG_BEATS_PER_MINUTE, acid->tempo, NULL);
-if (wav->streaming) {
-gst_adapter_flush (wav->adapter, data_size);
-} else {
-gst_buffer_unref (buf);
-wav->offset += 8 + data_size;
-}
-break;
-}
-/* FIXME: all list tags after data are ignored in streaming mode */
-case GST_RIFF_TAG_LIST:{
-guint32 ltag;
-if (wav->streaming) {
-const guint8 *data = NULL;
-if (gst_adapter_available (wav->adapter) < 12) {
-return GST_FLOW_OK;
-}
-data = gst_adapter_peek (wav->adapter, 12);
-ltag = GST_READ_UINT32_LE (data + 8);
-} else {
-gst_buffer_unref (buf);
-if ((res =
-gst_pad_pull_range (wav->sinkpad, wav->offset, 12,
-&buf)) != GST_FLOW_OK)
-goto header_read_error;
-ltag = GST_READ_UINT32_LE (GST_BUFFER_DATA (buf) + 8);
-}
-switch (ltag) {
-case GST_RIFF_LIST_INFO:{
-const guint data_size = size - 4;
-GstTagList *new;
-GST_INFO_OBJECT (wav, "Have LIST chunk INFO size %u", data_size);
-if (wav->streaming) {
-gst_adapter_flush (wav->adapter, 12);
-if (gst_adapter_available (wav->adapter) < data_size) {
-return GST_FLOW_OK;
-}
-gst_buffer_unref (buf);
-if (data_size > 0)
-buf = gst_adapter_take_buffer (wav->adapter, data_size);
-} else {
-wav->offset += 12;
-gst_buffer_unref (buf);
-if (data_size > 0) {
-if ((res =
-gst_pad_pull_range (wav->sinkpad, wav->offset,
-data_size, &buf)) != GST_FLOW_OK)
-goto header_read_error;
-}
-}
-if (data_size > 0) {
-/* parse tags */
-gst_riff_parse_info (GST_ELEMENT (wav), buf, &new);
-if (new) {
-GstTagList *old = wav->tags;
-wav->tags =
-gst_tag_list_merge (old, new, GST_TAG_MERGE_REPLACE);
-if (old)
-gst_tag_list_free (old);
-gst_tag_list_free (new);
-}
-if (wav->streaming) {
-gst_adapter_flush (wav->adapter, data_size);
-} else {
-gst_buffer_unref (buf);
-wav->offset += data_size;
-}
-}
-break;
-}
-default:
-GST_INFO_OBJECT (wav, "Ignoring LIST chunk %" GST_FOURCC_FORMAT,
-GST_FOURCC_ARGS (ltag));
-gst_waveparse_ignore_chunk (wav, buf, tag, size);
-break;
-}
 break;
 }
 default:
-gst_waveparse_ignore_chunk (wav, buf, tag, size);
+if (wav->streaming) {
-}
+if (!gst_wavparse_peek_chunk (wav, &tag, &size))
+return GST_FLOW_OK;
-if (upstream_size && (wav->offset >= upstream_size)) {
+}
-/* Now we are gone through the whole file */
+GST_DEBUG_OBJECT (wav, "Ignoring tag %" GST_FOURCC_FORMAT,
-gotdata = TRUE;
+GST_FOURCC_ARGS (tag));
+wav->offset += 8 + ((size + 1) & ~1);
+if (wav->streaming) {
+gst_adapter_flush (wav->adapter, 8 + ((size + 1) & ~1));
+} else {
+gst_buffer_unref (buf);
+}
 }
 }
 GST_DEBUG_OBJECT (wav, "Finished parsing headers");
-if (wav->bps <= 0 && wav->fact) {
+duration = gst_util_uint64_scale_int (wav->datasize, GST_SECOND, wav->bps);
-#if 0
+GST_DEBUG_OBJECT (wav, "Got duration %" GST_TIME_FORMAT,
-/* not a good idea, as for embedded mp2/mp3 we set bps to 0 earlier */
+GST_TIME_ARGS (duration));
-wav->bps =
+gst_segment_set_duration (&wav->segment, GST_FORMAT_TIME, duration);
-(guint32) gst_util_uint64_scale ((guint64) wav->rate, wav->datasize,
-(guint64) wav->fact);
-GST_INFO_OBJECT (wav, "calculated bps : %d, enabling VBR", wav->bps);
-#endif
-wav->vbr = TRUE;
-}
-if (gst_wavparse_calculate_duration (wav)) {
-gst_segment_init (&wav->segment, GST_FORMAT_TIME);
-gst_segment_set_duration (&wav->segment, GST_FORMAT_TIME, wav->duration);
-} else {
-/* no bitrate, let downstream peer do the math, we'll feed it bytes. */
-gst_segment_init (&wav->segment, GST_FORMAT_BYTES);
-gst_segment_set_duration (&wav->segment, GST_FORMAT_BYTES, wav->datasize);
-}
 /* now we have all the info to perform a pending seek if any, if no
 * event, this will still do the right thing and it will also send
 * 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);
-/* we just started, we are discont */
-wav->discont = TRUE;
 wav->state = GST_WAVPARSE_DATA;
 return GST_FLOW_OK;
 /* ERROR */
 invalid_wav:
 {
-GST_ELEMENT_ERROR (wav, STREAM, TYPE_NOT_FOUND, (NULL),
+GST_ELEMENT_ERROR (wav, STREAM, DEMUX, (NULL),
 ("Invalid WAV header (no fmt at start): %"
 GST_FOURCC_FORMAT, GST_FOURCC_ARGS (tag)));
 g_free (codec_name);
 return GST_FLOW_ERROR;
 }
 parse_header_error:
 {
 GST_ELEMENT_ERROR (wav, STREAM, DEMUX, (NULL),
 ("Couldn't parse audio header"));
+gst_buffer_unref (buf);
 g_free (codec_name);
 return GST_FLOW_ERROR;
 }
 no_channels:
 {
 GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
 ("Stream claims to contain no channels - invalid data"));
 g_free (header);
 g_free (codec_name);
 return GST_FLOW_ERROR;
 }
-no_rate:
+no_bitrate:
 {
 GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
-("Stream with sample_rate == 0 - invalid data"));
+("Stream claims to have a bitrate of <= zero - invalid data"));
 g_free (header);
 g_free (codec_name);
 return GST_FLOW_ERROR;
 }
-invalid_blockalign:
-{
-GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
-("Stream claims blockalign = %u, which is more than %u - invalid data",
-wav->blockalign, wav->channels * (guint) ceil (wav->depth / 8.0)));
-g_free (codec_name);
-return GST_FLOW_ERROR;
-}
-invalid_bps:
-{
-GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
-("Stream claims av_bsp = %u, which is more than %u - invalid data",
-wav->av_bps, wav->blockalign * wav->rate));
-g_free (codec_name);
-return GST_FLOW_ERROR;
-}
 no_bytes_per_sample:
 {
 GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
-("Could not caluclate bytes per sample - invalid data"));
+("could not caluclate bytes per sample - invalid data"));
+g_free (header);
 g_free (codec_name);
 return GST_FLOW_ERROR;
 }
 unknown_format:
 {
 GST_ELEMENT_ERROR (wav, STREAM, TYPE_NOT_FOUND, (NULL),
 ("No caps found for format 0x%x, %d channels, %d Hz",
 wav->format, wav->channels, wav->rate));
-g_free (header);
 g_free (codec_name);
 return GST_FLOW_ERROR;
 }
 header_read_error:
 {
-GST_ELEMENT_ERROR (wav, STREAM, DEMUX, (NULL),
+GST_ELEMENT_ERROR (wav, STREAM, DEMUX, (NULL), ("Couldn't read in header"));
-("Couldn't read in header %d (%s)", res, gst_flow_get_name (res)));
 g_free (codec_name);
 return GST_FLOW_ERROR;
 }
 }
-/*
+/*
 * Read WAV file tag when streaming
 */
 static GstFlowReturn
 gst_wavparse_parse_stream_init (GstWavParse * wav)
 {
 if (gst_adapter_available (wav->adapter) >= 12) {
-GstBuffer *tmp;
+GstBuffer *tmp = gst_buffer_new ();
 /* _take flushes the data */
-tmp = gst_adapter_take_buffer (wav->adapter, 12);
+GST_BUFFER_DATA (tmp) = gst_adapter_take (wav->adapter, 12);
+GST_BUFFER_SIZE (tmp) = 12;
 GST_DEBUG ("Parsing wav header");
-if (!gst_wavparse_parse_file_header (GST_ELEMENT_CAST (wav), tmp))
+if (!gst_wavparse_parse_file_header (GST_ELEMENT (wav), tmp)) {
 return GST_FLOW_ERROR;
+}
 wav->offset += 12;
 /* Go to next state */
 wav->state = GST_WAVPARSE_HEADER;
 }
 gst_wavparse_add_src_pad (GstWavParse * wav, GstBuffer * buf)
 {
 GstStructure *s;
 const guint8 dts_marker[] = { 0xFF, 0x1F, 0x00, 0xE8, 0xF1, 0x07 };
-GST_DEBUG_OBJECT (wav, "adding src pad");
+s = gst_caps_get_structure (wav->caps, 0);
-if (wav->caps) {
+if (gst_structure_has_name (s, "audio/x-raw-int") &&
-s = gst_caps_get_structure (wav->caps, 0);
+GST_BUFFER_SIZE (buf) > 6 &&
-if (s && gst_structure_has_name (s, "audio/x-raw-int") && buf &&
+memcmp (GST_BUFFER_DATA (buf), dts_marker, 6) == 0) {
-GST_BUFFER_SIZE (buf) > 6 &&
-memcmp (GST_BUFFER_DATA (buf), dts_marker, 6) == 0) {
+GST_WARNING_OBJECT (wav, "Found DTS marker in file marked as raw PCM");
+gst_caps_unref (wav->caps);
-GST_WARNING_OBJECT (wav, "Found DTS marker in file marked as raw PCM");
+wav->caps = gst_caps_from_string ("audio/x-dts");
-gst_caps_unref (wav->caps);
-wav->caps = gst_caps_from_string ("audio/x-dts");
+gst_tag_list_add (wav->tags, GST_TAG_MERGE_REPLACE,
+GST_TAG_AUDIO_CODEC, "dts", NULL);
-gst_tag_list_add (wav->tags, GST_TAG_MERGE_REPLACE,
-GST_TAG_AUDIO_CODEC, "dts", NULL);
-}
 }
 gst_wavparse_create_sourcepad (wav);
 gst_pad_set_active (wav->srcpad, TRUE);
 gst_pad_set_caps (wav->srcpad, wav->caps);
 gst_caps_replace (&wav->caps, NULL);
-gst_element_add_pad (GST_ELEMENT_CAST (wav), wav->srcpad);
+gst_element_add_pad (GST_ELEMENT (wav), wav->srcpad);
-gst_element_no_more_pads (GST_ELEMENT_CAST (wav));
-if (wav->close_segment) {
+gst_element_no_more_pads (GST_ELEMENT (wav));
-GST_DEBUG_OBJECT (wav, "Send close segment event on newpad");
-gst_pad_push_event (wav->srcpad, wav->close_segment);
+GST_DEBUG_OBJECT (wav, "Send newsegment event on newpad");
-wav->close_segment = NULL;
+gst_pad_push_event (wav->srcpad, wav->newsegment);
-}
+wav->newsegment = NULL;
-if (wav->start_segment) {
-GST_DEBUG_OBJECT (wav, "Send start segment event on newpad");
-gst_pad_push_event (wav->srcpad, wav->start_segment);
-wav->start_segment = NULL;
-}
 if (wav->tags) {
-gst_element_found_tags_for_pad (GST_ELEMENT_CAST (wav), wav->srcpad,
+gst_element_found_tags_for_pad (GST_ELEMENT (wav), wav->srcpad, wav->tags);
-wav->tags);
 wav->tags = NULL;
 }
 }
 #define MAX_BUFFER_SIZE 4096
 static GstFlowReturn
 gst_wavparse_stream_data (GstWavParse * wav)
 {
 GstBuffer *buf = NULL;
 GstFlowReturn res = GST_FLOW_OK;
 guint64 desired, obtained;
-GstClockTime timestamp, next_timestamp, duration;
+GstClockTime timestamp, next_timestamp;
 guint64 pos, nextpos;
 iterate_adapter:
 GST_LOG_OBJECT (wav,
 "offset: %" G_GINT64_FORMAT " , end: %" G_GINT64_FORMAT " , dataleft: %"
 G_GINT64_FORMAT, wav->offset, wav->end_offset, wav->dataleft);
 /* scale the amount of data by the segment rate so we get equal
 * amounts of data regardless of the playback rate */
 desired =
 MIN (gst_guint64_to_gdouble (wav->dataleft),
-MAX_BUFFER_SIZE * wav->segment.abs_rate);
+MAX_BUFFER_SIZE * ABS (wav->segment.rate));
 if (desired >= wav->blockalign && wav->blockalign > 0)
 desired -= (desired % wav->blockalign);
 GST_LOG_OBJECT (wav, "Fetching %" G_GINT64_FORMAT " bytes of data "
 "from the sinkpad", desired);
 if (wav->streaming) {
 guint avail = gst_adapter_available (wav->adapter);
-guint extra;
-/* flush some bytes if evil upstream sends segment that starts
-* before data or does is not send sample aligned segment */
-if (G_LIKELY (wav->offset >= wav->datastart)) {
-extra = (wav->offset - wav->datastart) % wav->bytes_per_sample;
-} else {
-extra = wav->datastart - wav->offset;
-}
-if (G_UNLIKELY (extra)) {
-extra = wav->bytes_per_sample - extra;
-if (extra <= avail) {
-GST_DEBUG_OBJECT (wav, "flushing %d bytes to sample boundary", extra);
-gst_adapter_flush (wav->adapter, extra);
-wav->offset += extra;
-wav->dataleft -= extra;
-goto iterate_adapter;
-} else {
-GST_DEBUG_OBJECT (wav, "flushing %d bytes", avail);
-gst_adapter_clear (wav->adapter);
-wav->offset += avail;
-wav->dataleft -= avail;
-return GST_FLOW_OK;
-}
-}
 if (avail < desired) {
 GST_LOG_OBJECT (wav, "Got only %d bytes of data from the sinkpad", avail);
 return GST_FLOW_OK;
 }
-buf = gst_adapter_take_buffer (wav->adapter, desired);
+buf = gst_buffer_new ();
+GST_BUFFER_DATA (buf) = gst_adapter_take (wav->adapter, desired);
+GST_BUFFER_SIZE (buf) = desired;
 } else {
 if ((res = gst_pad_pull_range (wav->sinkpad, wav->offset,
 desired, &buf)) != GST_FLOW_OK)
+{
 goto pull_error;
+}
 }
 /* first chunk of data? create the source pad. We do this only here so
 * we can detect broken .wav files with dts disguised as raw PCM (sigh) */
 if (G_UNLIKELY (wav->first)) {
 wav->first = FALSE;
-/* this will also push the segment events */
 gst_wavparse_add_src_pad (wav, buf);
-} else {
-/* If we have a pending close/start segment, send it now. */
-if (G_UNLIKELY (wav->close_segment != NULL)) {
-gst_pad_push_event (wav->srcpad, wav->close_segment);
-wav->close_segment = NULL;
-}
-if (G_UNLIKELY (wav->start_segment != NULL)) {
-gst_pad_push_event (wav->srcpad, wav->start_segment);
-wav->start_segment = NULL;
-}
 }
 obtained = GST_BUFFER_SIZE (buf);
-/* our positions in bytes */
+/* our positions */
 pos = wav->offset - wav->datastart;
 nextpos = pos + obtained;
 /* update offsets, does not overflow. */
 GST_BUFFER_OFFSET (buf) = pos / wav->bytes_per_sample;
 GST_BUFFER_OFFSET_END (buf) = nextpos / wav->bytes_per_sample;
-if (wav->bps > 0) {
+/* and timestamps, be carefull for overflows */
-/* and timestamps if we have a bitrate, be careful for overflows */
+timestamp = gst_util_uint64_scale_int (pos, GST_SECOND, wav->bps);
-timestamp = uint64_ceiling_scale (pos, GST_SECOND, (guint64) wav->bps);
+next_timestamp = gst_util_uint64_scale_int (nextpos, GST_SECOND, wav->bps);
-next_timestamp =
-uint64_ceiling_scale (nextpos, GST_SECOND, (guint64) wav->bps);
-duration = next_timestamp - timestamp;
-/* update current running segment position */
-gst_segment_set_last_stop (&wav->segment, GST_FORMAT_TIME, next_timestamp);
-} else if (wav->fact) {
-guint64 bps =
-gst_util_uint64_scale_int (wav->datasize, wav->rate, wav->fact);
-/* and timestamps if we have a bitrate, be careful for overflows */
-timestamp = uint64_ceiling_scale (pos, GST_SECOND, bps);
-next_timestamp = uint64_ceiling_scale (nextpos, GST_SECOND, bps);
-duration = next_timestamp - timestamp;
-} else {
-/* no bitrate, all we know is that the first sample has timestamp 0, all
-* other positions and durations have unknown timestamp. */
-if (pos == 0)
-timestamp = 0;
-else
-timestamp = GST_CLOCK_TIME_NONE;
-duration = GST_CLOCK_TIME_NONE;
-/* update current running segment position with byte offset */
-gst_segment_set_last_stop (&wav->segment, GST_FORMAT_BYTES, nextpos);
-}
-if ((pos > 0) && wav->vbr) {
-/* don't set timestamps for VBR files if it's not the first buffer */
-timestamp = GST_CLOCK_TIME_NONE;
-duration = GST_CLOCK_TIME_NONE;
-}
-if (wav->discont) {
-GST_DEBUG_OBJECT (wav, "marking DISCONT");
-GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
-wav->discont = FALSE;
-}
 GST_BUFFER_TIMESTAMP (buf) = timestamp;
-GST_BUFFER_DURATION (buf) = duration;
+GST_BUFFER_DURATION (buf) = next_timestamp - timestamp;
+/* update current running segment position */
+gst_segment_set_last_stop (&wav->segment, GST_FORMAT_TIME, next_timestamp);
 /* don't forget to set the caps on the buffer */
 gst_buffer_set_caps (buf, GST_PAD_CAPS (wav->srcpad));
 GST_LOG_OBJECT (wav,
 "Got buffer. timestamp:%" GST_TIME_FORMAT " , duration:%" GST_TIME_FORMAT
-", size:%u", GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration),
+", size:%u", GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
-GST_BUFFER_SIZE (buf));
+GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_BUFFER_SIZE (buf));
 if ((res = gst_pad_push (wav->srcpad, buf)) != GST_FLOW_OK)
+{
 goto push_error;
+}
 if (obtained < wav->dataleft) {
-wav->offset += obtained;
 wav->dataleft -= obtained;
 } else {
-wav->offset += wav->dataleft;
 wav->dataleft = 0;
 }
+wav->offset += obtained;
 /* Iterate until need more data, so adapter size won't grow */
 if (wav->streaming) {
 GST_LOG_OBJECT (wav,
 "offset: %" G_GINT64_FORMAT " , end: %" G_GINT64_FORMAT, wav->offset,
 wav->end_offset);
 goto iterate_adapter;
 }
 return res;
 /* ERROR */
 found_eos:
 {
 GST_DEBUG_OBJECT (wav, "found EOS");
-return GST_FLOW_UNEXPECTED;
+/* we completed the segment */
+wav->segment_running = FALSE;
+if (wav->segment.flags & GST_SEEK_FLAG_SEGMENT) {
+GstClockTime stop;
+if ((stop = wav->segment.stop) == -1)
+stop = wav->segment.duration;
+gst_element_post_message (GST_ELEMENT (wav),
+gst_message_new_segment_done (GST_OBJECT (wav), GST_FORMAT_TIME,
+stop));
+} else {
+gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
+}
+return GST_FLOW_WRONG_STATE;
 }
 pull_error:
 {
-/* check if we got EOS */
-if (res == GST_FLOW_UNEXPECTED)
+GST_DEBUG_OBJECT (wav, "Error getting %" G_GINT64_FORMAT " bytes from the "
-goto found_eos;
-GST_WARNING_OBJECT (wav,
-"Error getting %" G_GINT64_FORMAT " bytes from the "
 "sinkpad (dataleft = %" G_GINT64_FORMAT ")", desired, wav->dataleft);
 return res;
 }
 push_error:
 {
-GST_INFO_OBJECT (wav,
-"Error pushing on srcpad %s:%s, reason %s, is linked? = %d",
+GST_DEBUG_OBJECT (wav, "Error pushing on srcpad");
-GST_DEBUG_PAD_NAME (wav->srcpad), gst_flow_get_name (res),
-gst_pad_is_linked (wav->srcpad));
 return res;
 }
 }
 static void
 GST_LOG_OBJECT (wav, "process data");
 switch (wav->state) {
 case GST_WAVPARSE_START:
-GST_INFO_OBJECT (wav, "GST_WAVPARSE_START");
+GST_DEBUG_OBJECT (wav, "GST_WAVPARSE_START");
 if ((ret = gst_wavparse_stream_init (wav)) != GST_FLOW_OK)
 goto pause;
 wav->state = GST_WAVPARSE_HEADER;
 /* fall-through */
 case GST_WAVPARSE_HEADER:
-GST_INFO_OBJECT (wav, "GST_WAVPARSE_HEADER");
+GST_DEBUG_OBJECT (wav, "GST_WAVPARSE_HEADER");
 if ((ret = gst_wavparse_stream_headers (wav)) != GST_FLOW_OK)
 goto pause;
 wav->state = GST_WAVPARSE_DATA;
-GST_INFO_OBJECT (wav, "GST_WAVPARSE_DATA");
 /* fall-through */
 case GST_WAVPARSE_DATA:
 if ((ret = gst_wavparse_stream_data (wav)) != GST_FLOW_OK)
+{
 goto pause;
-break;
+}
+break;
 default:
 g_assert_not_reached ();
 }
 return;
 /* ERRORS */
 pause:
-{
+GST_LOG_OBJECT (wav, "pausing task %d", ret);
-const gchar *reason = gst_flow_get_name (ret);
+gst_pad_pause_task (wav->sinkpad);
+if (GST_FLOW_IS_FATAL (ret)) {
-GST_DEBUG_OBJECT (wav, "pausing task, reason %s", reason);
-wav->segment_running = FALSE;
-gst_pad_pause_task (pad);
+/* for fatal errors we post an error message */
+GST_ELEMENT_ERROR (wav, STREAM, FAILED,
-if (GST_FLOW_IS_FATAL (ret) || ret == GST_FLOW_NOT_LINKED) {
+(_("Internal data stream error.")),
-if (ret == GST_FLOW_UNEXPECTED) {
+("streaming stopped, reason %s", gst_flow_get_name (ret)));
-/* add pad before we perform EOS */
+if (wav->srcpad != NULL)
-if (G_UNLIKELY (wav->first)) {
+{
-wav->first = FALSE;
+gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
-gst_wavparse_add_src_pad (wav, NULL);
+}
 }
-/* perform EOS logic */
-if (wav->segment.flags & GST_SEEK_FLAG_SEGMENT) {
-GstClockTime stop;
-if ((stop = wav->segment.stop) == -1)
-stop = wav->segment.duration;
-gst_element_post_message (GST_ELEMENT_CAST (wav),
-gst_message_new_segment_done (GST_OBJECT_CAST (wav),
-wav->segment.format, stop));
-} else {
-if (wav->srcpad != NULL)
-gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
-}
-} else {
-/* 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));
-if (wav->srcpad != NULL)
-gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
-}
-}
-return;
-}
 }
 static GstFlowReturn
 gst_wavparse_chain (GstPad * pad, GstBuffer * buf)
 {
 GstFlowReturn ret;
 GstWavParse *wav = GST_WAVPARSE (GST_PAD_PARENT (pad));
+GST_LOG_OBJECT (wav, "adapter_push %" G_GINT64_FORMAT " bytes",
-GST_LOG_OBJECT (wav, "adapter_push %u bytes", GST_BUFFER_SIZE (buf));
+GST_BUFFER_SIZE (buf));
 gst_adapter_push (wav->adapter, buf);
 switch (wav->state) {
 case GST_WAVPARSE_START:
-GST_INFO_OBJECT (wav, "GST_WAVPARSE_START");
+GST_DEBUG_OBJECT (wav, "GST_WAVPARSE_START");
 if ((ret = gst_wavparse_parse_stream_init (wav)) != GST_FLOW_OK)
-goto done;
+{
-if (wav->state != GST_WAVPARSE_HEADER)
+goto pause;
-break;
+			}
-/* otherwise fall-through */
+wav->state = GST_WAVPARSE_HEADER;
+/* fall-through */
 case GST_WAVPARSE_HEADER:
-GST_INFO_OBJECT (wav, "GST_WAVPARSE_HEADER");
+GST_DEBUG_OBJECT (wav, "GST_WAVPARSE_HEADER");
 if ((ret = gst_wavparse_stream_headers (wav)) != GST_FLOW_OK)
-goto done;
+goto pause;
-if (!wav->got_fmt || wav->datastart == 0)
-break;
 wav->state = GST_WAVPARSE_DATA;
-GST_INFO_OBJECT (wav, "GST_WAVPARSE_DATA");
 /* fall-through */
 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)
-goto done;
+{
-break;
+goto pause;
+}
+break;
 default:
-g_return_val_if_reached (GST_FLOW_ERROR);
+g_assert_not_reached ();
 }
-done:
 return ret;
-}
+pause:
-static GstFlowReturn
-gst_wavparse_flush_data (GstWavParse * wav)
+GST_LOG_OBJECT (wav, "pausing task %d", ret);
-{
+gst_pad_pause_task (wav->sinkpad);
-GstFlowReturn ret = GST_FLOW_OK;
+if (GST_FLOW_IS_FATAL (ret)) {
-guint av;
+/* for fatal errors we post an error message */
-if ((av = gst_adapter_available (wav->adapter)) > 0) {
+GST_ELEMENT_ERROR (wav, STREAM, FAILED,
-wav->dataleft = av;
+(_("Internal data stream error.")),
-wav->end_offset = wav->offset + av;
+("streaming stopped, reason %s", gst_flow_get_name (ret)));
-ret = gst_wavparse_stream_data (wav);
+if (wav->srcpad != NULL)
-}
-return ret;
-}
-static gboolean
-gst_wavparse_sink_event (GstPad * pad, GstEvent * event)
-{
-GstWavParse *wav = GST_WAVPARSE (GST_PAD_PARENT (pad));
-gboolean ret = TRUE;
-GST_LOG_OBJECT (wav, "handling %s event", GST_EVENT_TYPE_NAME (event));
-switch (GST_EVENT_TYPE (event)) {
-case GST_EVENT_NEWSEGMENT:
 {
-GstFormat format;
+gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
-gdouble rate, arate;
-gint64 start, stop, time, offset = 0, end_offset = -1;
+	}
-gboolean update;
-GstSegment segment;
-/* some debug output */
-gst_segment_init (&segment, GST_FORMAT_UNDEFINED);
-gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,
-&start, &stop, &time);
-gst_segment_set_newsegment_full (&segment, update, rate, arate, format,
-start, stop, time);
-GST_DEBUG_OBJECT (wav,
-"received format %d newsegment %" GST_SEGMENT_FORMAT, format,
-&segment);
-if (wav->state != GST_WAVPARSE_DATA) {
-GST_DEBUG_OBJECT (wav, "still starting, eating event");
-goto exit;
-}
-/* now we are either committed to TIME or BYTE format,
-* and we only expect a BYTE segment, e.g. following a seek */
-if (format == GST_FORMAT_BYTES) {
-if (start > 0) {
-offset = start;
-start -= wav->datastart;
-start = MAX (start, 0);
-}
-if (stop > 0) {
-end_offset = stop;
-stop -= wav->datastart;
-stop = MAX (stop, 0);
-}
-if (wav->segment.format == GST_FORMAT_TIME) {
-guint64 bps = wav->bps;
-/* operating in format TIME, so we can convert */
-if (!bps && wav->fact)
-bps =
-gst_util_uint64_scale_int (wav->datasize, wav->rate, wav->fact);
-if (bps) {
-if (start >= 0)
-start =
-uint64_ceiling_scale (start, GST_SECOND, (guint64) wav->bps);
-if (stop >= 0)
-stop =
-uint64_ceiling_scale (stop, GST_SECOND, (guint64) wav->bps);
-}
-}
-} else {
-GST_DEBUG_OBJECT (wav, "unsupported segment format, ignoring");
-goto exit;
-}
-/* accept upstream's notion of segment and distribute along */
-gst_segment_set_newsegment_full (&wav->segment, update, rate, arate,
-wav->segment.format, start, stop, start);
-/* also store the newsegment event for the streaming thread */
-if (wav->start_segment)
-gst_event_unref (wav->start_segment);
-wav->start_segment =
-gst_event_new_new_segment_full (update, rate, arate,
-wav->segment.format, start, stop, start);
-GST_DEBUG_OBJECT (wav, "Pushing newseg update %d, rate %g, "
-"applied rate %g, format %d, start %" G_GINT64_FORMAT ", "
-"stop %" G_GINT64_FORMAT, update, rate, arate, wav->segment.format,
-start, stop);
-/* stream leftover data in current segment */
-gst_wavparse_flush_data (wav);
-/* and set up streaming thread for next one */
-wav->offset = offset;
-wav->end_offset = end_offset;
-if (wav->end_offset > 0) {
-wav->dataleft = wav->end_offset - wav->offset;
-} else {
-/* infinity; upstream will EOS when done */
-wav->dataleft = G_MAXUINT64;
-}
-exit:
-gst_event_unref (event);
-break;
-}
-case GST_EVENT_EOS:
-/* stream leftover data in current segment */
-gst_wavparse_flush_data (wav);
-/* fall-through */
-case GST_EVENT_FLUSH_STOP:
-gst_adapter_clear (wav->adapter);
-wav->discont = TRUE;
-/* fall-through */
-default:
-ret = gst_pad_event_default (wav->sinkpad, event);
-break;
 }
 return ret;
 }
 GstFormat * dest_format, gint64 * dest_value)
 {
 GstWavParse *wavparse;
 gboolean res = TRUE;
-wavparse = GST_WAVPARSE (GST_PAD_PARENT (pad));
+wavparse = GST_WAVPARSE (gst_pad_get_parent (pad));
-if (*dest_format == src_format) {
+if (wavparse->bytes_per_sample == 0)
-*dest_value = src_value;
+goto no_bytes_per_sample;
-return TRUE;
-}
+if (wavparse->bps == 0)
+goto no_bps;
-if ((wavparse->bps == 0) && !wavparse->fact)
-goto no_bps_fact;
-GST_INFO_OBJECT (wavparse, "converting value from %s to %s",
-gst_format_get_name (src_format), gst_format_get_name (*dest_format));
 switch (src_format) {
 case GST_FORMAT_BYTES:
 switch (*dest_format) {
 case GST_FORMAT_DEFAULT:
 *dest_value = src_value / wavparse->bytes_per_sample;
-/* make sure we end up on a sample boundary */
-*dest_value -= *dest_value % wavparse->bytes_per_sample;
 break;
 case GST_FORMAT_TIME:
-/* src_value + datastart = offset */
+*dest_value =
-GST_INFO_OBJECT (wavparse,
+gst_util_uint64_scale_int (src_value, GST_SECOND, wavparse->bps);
-"src=%" G_GINT64_FORMAT ", offset=%" G_GINT64_FORMAT, src_value,
-wavparse->offset);
-if (wavparse->bps > 0)
-*dest_value = uint64_ceiling_scale (src_value, GST_SECOND,
-(guint64) wavparse->bps);
-else if (wavparse->fact) {
-guint64 bps = uint64_ceiling_scale_int (wavparse->datasize,
-wavparse->rate, wavparse->fact);
-*dest_value = uint64_ceiling_scale_int (src_value, GST_SECOND, bps);
-} else {
-res = FALSE;
-}
 break;
 default:
 res = FALSE;
 goto done;
 }
+*dest_value -= *dest_value % wavparse->bytes_per_sample;
 break;
 case GST_FORMAT_DEFAULT:
 switch (*dest_format) {
 case GST_FORMAT_BYTES:
 *dest_value = src_value * wavparse->bytes_per_sample;
 break;
 case GST_FORMAT_TIME:
-*dest_value = gst_util_uint64_scale (src_value, GST_SECOND,
+*dest_value =
-(guint64) wavparse->rate);
+gst_util_uint64_scale_int (src_value, GST_SECOND, wavparse->rate);
 break;
 default:
 res = FALSE;
 goto done;
 }
 break;
 case GST_FORMAT_TIME:
 switch (*dest_format) {
 case GST_FORMAT_BYTES:
-if (wavparse->bps > 0)
-*dest_value = gst_util_uint64_scale (src_value,
-(guint64) wavparse->bps, GST_SECOND);
-else {
-guint64 bps = gst_util_uint64_scale_int (wavparse->datasize,
-wavparse->rate, wavparse->fact);
-*dest_value = gst_util_uint64_scale (src_value, bps, GST_SECOND);
-}
 /* make sure we end up on a sample boundary */
+*dest_value =
+gst_util_uint64_scale_int (src_value, wavparse->bps, GST_SECOND);
 *dest_value -= *dest_value % wavparse->blockalign;
 break;
 case GST_FORMAT_DEFAULT:
-*dest_value = gst_util_uint64_scale (src_value,
+*dest_value =
-(guint64) wavparse->rate, GST_SECOND);
+gst_util_uint64_scale_int (src_value, wavparse->rate, GST_SECOND);
 break;
 default:
 res = FALSE;
 goto done;
 }
 res = FALSE;
 goto done;
 }
 done:
+gst_object_unref (wavparse);
 return res;
 /* ERRORS */
-no_bps_fact:
+no_bytes_per_sample:
 {
-GST_DEBUG_OBJECT (wavparse, "bps 0 or no fact chunk, cannot convert");
+GST_DEBUG_OBJECT (wavparse,
+"bytes_per_sample 0, probably an mp3 - channels %d, width %d",
+wavparse->channels, wavparse->width);
+res = FALSE;
+goto done;
+}
+no_bps:
+{
+GST_DEBUG_OBJECT (wavparse, "bps 0, cannot convert");
 res = FALSE;
 goto done;
 }
 }
 {
 static const GstQueryType types[] = {
 GST_QUERY_POSITION,
 GST_QUERY_DURATION,
 GST_QUERY_CONVERT,
-GST_QUERY_SEEKING,
 0
 };
 return types;
 }
 /* handle queries for location and length in requested format */
 static gboolean
 gst_wavparse_pad_query (GstPad * pad, GstQuery * query)
 {
 gboolean res = TRUE;
-GstWavParse *wav = GST_WAVPARSE (gst_pad_get_parent (pad));
+GstWavParse *wav = GST_WAVPARSE (GST_PAD_PARENT (pad));
 /* only if we know */
-if (wav->state != GST_WAVPARSE_DATA) {
+if (wav->state != GST_WAVPARSE_DATA)
-gst_object_unref (wav);
 return FALSE;
-}
-GST_LOG_OBJECT (pad, "%s query", GST_QUERY_TYPE_NAME (query));
 switch (GST_QUERY_TYPE (query)) {
 case GST_QUERY_POSITION:
 {
 gint64 curb;
 gint64 cur;
 GstFormat format;
+gboolean res = TRUE;
-/* this is not very precise, as we have pushed severla buffer upstream for prerolling */
 curb = wav->offset - wav->datastart;
 gst_query_parse_position (query, &format, NULL);
-GST_INFO_OBJECT (wav, "pos query at %" G_GINT64_FORMAT, curb);
 switch (format) {
 case GST_FORMAT_TIME:
-res = gst_wavparse_pad_convert (pad, GST_FORMAT_BYTES, curb,
+res &=
+gst_wavparse_pad_convert (pad, GST_FORMAT_BYTES, curb,
 &format, &cur);
 break;
 default:
 format = GST_FORMAT_BYTES;
 cur = curb;
 gst_query_set_position (query, format, cur);
 break;
 }
 case GST_QUERY_DURATION:
 {
-gint64 duration = 0;
+gint64 endb;
+gint64 end;
 GstFormat format;
+gboolean res = TRUE;
+endb = wav->datasize;
 gst_query_parse_duration (query, &format, NULL);
 switch (format) {
-case GST_FORMAT_TIME:{
+case GST_FORMAT_TIME:
-if ((res = gst_wavparse_calculate_duration (wav))) {
+res &=
-duration = wav->duration;
+gst_wavparse_pad_convert (pad, GST_FORMAT_BYTES, endb,
-}
+&format, &end);
 break;
-}
 default:
 format = GST_FORMAT_BYTES;
-duration = wav->datasize;
+end = endb;
 break;
 }
-gst_query_set_duration (query, format, duration);
+if (res)
+gst_query_set_duration (query, format, end);
 break;
 }
 case GST_QUERY_CONVERT:
 {
 gint64 srcvalue, dstvalue;
 GstFormat srcformat, dstformat;
 gst_query_parse_convert (query, &srcformat, &srcvalue,
 &dstformat, &dstvalue);
-res = gst_wavparse_pad_convert (pad, srcformat, srcvalue,
+res &=
+gst_wavparse_pad_convert (pad, srcformat, srcvalue,
 &dstformat, &dstvalue);
 if (res)
 gst_query_set_convert (query, srcformat, srcvalue, dstformat, dstvalue);
 break;
 }
-case GST_QUERY_SEEKING:{
-GstFormat fmt;
-gboolean seekable = FALSE;
-gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
-if (fmt == wav->segment.format) {
-if (wav->streaming) {
-GstQuery *q;
-q = gst_query_new_seeking (GST_FORMAT_BYTES);
-if ((res = gst_pad_peer_query (wav->sinkpad, q))) {
-gst_query_parse_seeking (q, &fmt, &seekable, NULL, NULL);
-GST_LOG_OBJECT (wav, "upstream BYTE seekable %d", seekable);
-}
-gst_query_unref (q);
-} else {
-GST_LOG_OBJECT (wav, "looping => seekable");
-seekable = TRUE;
-res = TRUE;
-}
-} else if (fmt == GST_FORMAT_TIME) {
-res = TRUE;
-}
-if (res) {
-gst_query_set_seeking (query, fmt, seekable, 0, wav->segment.duration);
-}
-break;
-}
 default:
 res = gst_pad_query_default (pad, query);
 break;
 }
-gst_object_unref (wav);
 return res;
 }
 static gboolean
 gst_wavparse_srcpad_event (GstPad * pad, GstEvent * event)
 {
-GstWavParse *wavparse = GST_WAVPARSE (gst_pad_get_parent (pad));
+GstWavParse *wavparse = GST_WAVPARSE (GST_PAD_PARENT (pad));
-gboolean res = FALSE;
+gboolean res = TRUE;
-GST_DEBUG_OBJECT (wavparse, "%s event", GST_EVENT_TYPE_NAME (event));
+GST_DEBUG_OBJECT (wavparse, "event %d, %s", GST_EVENT_TYPE (event),
+GST_EVENT_TYPE_NAME (event));
+/* can only handle events when we are in the data state */
+if (wavparse->state != GST_WAVPARSE_DATA)
+return FALSE;
 switch (GST_EVENT_TYPE (event)) {
 case GST_EVENT_SEEK:
-/* can only handle events when we are in the data state */
+{
-if (wavparse->state == GST_WAVPARSE_DATA) {
+res = gst_wavparse_perform_seek (wavparse, event);
-res = gst_wavparse_perform_seek (wavparse, event);
+break;
 }
-gst_event_unref (event);
-break;
 default:
-res = gst_pad_push_event (wavparse->sinkpad, event);
+res = FALSE;
 break;
 }
-gst_object_unref (wavparse);
+gst_event_unref (event);
 return res;
 }
 static gboolean
 gst_wavparse_sink_activate (GstPad * sinkpad)
 {
 GstWavParse *wav = GST_WAVPARSE (gst_pad_get_parent (sinkpad));
 gboolean res;
-if (wav->adapter)
-gst_object_unref (wav->adapter);
 if (gst_pad_check_pull_range (sinkpad)) {
 GST_DEBUG ("going to pull mode");
 wav->streaming = FALSE;
-if (wav->adapter) {
-gst_adapter_clear (wav->adapter);
-g_object_unref (wav->adapter);
-}
 wav->adapter = NULL;
 res = gst_pad_activate_pull (sinkpad, TRUE);
 } else {
 GST_DEBUG ("going to push (streaming) mode");
 wav->streaming = TRUE;
-if (wav->adapter == NULL)
+wav->adapter = gst_adapter_new ();
-wav->adapter = gst_adapter_new ();
 res = gst_pad_activate_push (sinkpad, TRUE);
 }
 gst_object_unref (wav);
 return res;
 }
 static gboolean
 gst_wavparse_sink_activate_pull (GstPad * sinkpad, gboolean active)
 {
-GstWavParse *wav = GST_WAVPARSE (GST_OBJECT_PARENT (sinkpad));
+GstWavParse *wav = GST_WAVPARSE (gst_pad_get_parent (sinkpad));
+GST_DEBUG_OBJECT (wav, "activating pull");
 if (active) {
 /* if we have a scheduler we can start the task */
 wav->segment_running = TRUE;
-return gst_pad_start_task (sinkpad, (GstTaskFunction) gst_wavparse_loop,
+gst_pad_start_task (sinkpad, (GstTaskFunction) gst_wavparse_loop, sinkpad);
-sinkpad);
 } else {
-wav->segment_running = FALSE;
+gst_pad_stop_task (sinkpad);
-return gst_pad_stop_task (sinkpad);
+}
-}
+gst_object_unref (wav);
-};
+return TRUE;
+}
 static GstStateChangeReturn
 gst_wavparse_change_state (GstElement * element, GstStateChange transition)
 {
 GstStateChangeReturn ret;
 GstWavParse *wav = GST_WAVPARSE (element);
+GST_DEBUG_OBJECT (wav, "changing state %s - %s",
+gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
+gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
 switch (transition) {
 case GST_STATE_CHANGE_NULL_TO_READY:
 break;
 case GST_STATE_CHANGE_READY_TO_PAUSED:
 gst_wavparse_reset (wav);
 ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 switch (transition) {
 case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 break;
-case GST_STATE_CHANGE_PAUSED_TO_READY:
+case GST_STATE_CHANGE_PAUSED_TO_READY:{
+GstEvent **event_p = &wav->seek_event;
 gst_wavparse_destroy_sourcepad (wav);
+gst_event_replace (event_p, NULL);
 gst_wavparse_reset (wav);
-break;
+if (wav->adapter) {
+gst_adapter_clear (wav->adapter);
+}
+break;
+}
 case GST_STATE_CHANGE_READY_TO_NULL:
 break;
 default:
 break;
 }
 static gboolean
 plugin_init (GstPlugin * plugin)
 {
 gst_riff_init ();
+GST_DEBUG_CATEGORY_INIT (wavparse_debug, "wavparse", 0, "WAV parser");
 return gst_element_register (plugin, "wavparse", GST_RANK_PRIMARY,
 GST_TYPE_WAVPARSE);
 }
 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 GST_VERSION_MINOR,
 "wavparse",
 "Parse a .wav file into raw audio",
 plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)
 EXPORT_C GstPluginDesc* _GST_PLUGIN_DESC()
 {
 	return &gst_plugin_desc;
 }

branch	RCL_3
changeset 30	7e817e7e631c
parent 29	567bb019e3e3