/* GStreamer * Copyright (C) <1999> Erik Walthinsen * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include "gstmad.h" #define GST_TYPE_MAD \ (gst_mad_get_type()) #define GST_MAD(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MAD,GstMad)) #define GST_MAD_CLASS(klass) \ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MAD,GstMadClass)) #define GST_IS_MAD(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MAD)) #define GST_IS_MAD_CLASS(klass) \ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MAD)) typedef struct _GstMad GstMad; typedef struct _GstMadClass GstMadClass; struct _GstMad { GstElement element; /* pads */ GstPad *sinkpad, *srcpad; /* state */ struct mad_stream stream; struct mad_frame frame; struct mad_synth synth; guchar *tempbuffer; /* temporary buffer to serve to mad */ glong tempsize; /* running count of temp buffer size */ GstClockTime last_ts; guint64 base_byte_offset; guint64 bytes_consumed; /* since the base_byte_offset */ guint64 total_samples; /* the number of samples since the sync point */ gboolean in_error; /* set when mad's in an error state */ gboolean restart; guint64 segment_start; gboolean need_newsegment; /* info */ struct mad_header header; gboolean new_header; guint framecount; gint vbr_average; /* average bitrate */ guint64 vbr_rate; /* average * framecount */ gboolean half; gboolean ignore_crc; GstTagList *tags; /* negotiated format */ gint rate, pending_rate; gint channels, pending_channels; gint times_pending; gboolean caps_set; /* used to keep track of whether to change/update caps */ GstIndex *index; gint index_id; gboolean check_for_xing; gboolean xing_found; gboolean framed; /* whether there is a demuxer in front of us */ }; struct _GstMadClass { GstElementClass parent_class; }; /* elementfactory information */ static const GstElementDetails gst_mad_details = GST_ELEMENT_DETAILS ("mad mp3 decoder", "Codec/Decoder/Audio", "Uses mad code to decode mp3 streams", "Wim Taymans "); enum { ARG_0, ARG_HALF, ARG_IGNORE_CRC }; GST_DEBUG_CATEGORY_STATIC (mad_debug); #define GST_CAT_DEFAULT mad_debug static GstStaticPadTemplate mad_src_template_factory = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw-int, " "endianness = (int) " G_STRINGIFY (G_BYTE_ORDER) ", " "signed = (boolean) true, " "width = (int) 32, " "depth = (int) 32, " "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, " "channels = (int) [ 1, 2 ]") ); /* FIXME: make three caps, for mpegversion 1, 2 and 2.5 */ static GstStaticPadTemplate mad_sink_template_factory = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/mpeg, " "mpegversion = (int) 1, " "layer = (int) [ 1, 3 ], " "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, " "channels = (int) [ 1, 2 ]") ); static void gst_mad_base_init (gpointer g_class); static void gst_mad_class_init (GstMadClass * klass); static void gst_mad_init (GstMad * mad); static void gst_mad_dispose (GObject * object); static void gst_mad_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_mad_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static gboolean gst_mad_src_event (GstPad * pad, GstEvent * event); static const GstQueryType *gst_mad_get_query_types (GstPad * pad); static gboolean gst_mad_src_query (GstPad * pad, GstQuery * query); static gboolean gst_mad_convert_sink (GstPad * pad, GstFormat src_format, gint64 src_value, GstFormat * dest_format, gint64 * dest_value); static gboolean gst_mad_convert_src (GstPad * pad, GstFormat src_format, gint64 src_value, GstFormat * dest_format, gint64 * dest_value); static gboolean gst_mad_sink_event (GstPad * pad, GstEvent * event); static GstFlowReturn gst_mad_chain (GstPad * pad, GstBuffer * buffer); static GstStateChangeReturn gst_mad_change_state (GstElement * element, GstStateChange transition); static void gst_mad_set_index (GstElement * element, GstIndex * index); static GstIndex *gst_mad_get_index (GstElement * element); static GstElementClass *parent_class = NULL; GType gst_mad_get_type (void) { static GType mad_type = 0; if (!mad_type) { static const GTypeInfo mad_info = { sizeof (GstMadClass), gst_mad_base_init, NULL, (GClassInitFunc) gst_mad_class_init, NULL, NULL, sizeof (GstMad), 0, (GInstanceInitFunc) gst_mad_init, }; mad_type = g_type_register_static (GST_TYPE_ELEMENT, "GstMad", &mad_info, 0); } GST_DEBUG_CATEGORY_INIT (mad_debug, "mad", 0, "mad mp3 decoding"); return mad_type; } #define GST_TYPE_MAD_LAYER (gst_mad_layer_get_type()) G_GNUC_UNUSED static GType gst_mad_layer_get_type (void) { static GType mad_layer_type = 0; static GEnumValue mad_layer[] = { {0, "Unknown", "unknown"}, {MAD_LAYER_I, "Layer I", "1"}, {MAD_LAYER_II, "Layer II", "2"}, {MAD_LAYER_III, "Layer III", "3"}, {0, NULL, NULL}, }; if (!mad_layer_type) { mad_layer_type = g_enum_register_static ("GstMadLayer", mad_layer); } return mad_layer_type; } #define GST_TYPE_MAD_MODE (gst_mad_mode_get_type()) G_GNUC_UNUSED static GType gst_mad_mode_get_type (void) { static GType mad_mode_type = 0; static GEnumValue mad_mode[] = { {-1, "Unknown", "unknown"}, {MAD_MODE_SINGLE_CHANNEL, "Mono", "mono"}, {MAD_MODE_DUAL_CHANNEL, "Dual Channel", "dual"}, {MAD_MODE_JOINT_STEREO, "Joint Stereo", "joint"}, {MAD_MODE_STEREO, "Stereo", "stereo"}, {0, NULL, NULL}, }; if (!mad_mode_type) { mad_mode_type = g_enum_register_static ("GstMadMode", mad_mode); } return mad_mode_type; } #define GST_TYPE_MAD_EMPHASIS (gst_mad_emphasis_get_type()) G_GNUC_UNUSED static GType gst_mad_emphasis_get_type (void) { static GType mad_emphasis_type = 0; static GEnumValue mad_emphasis[] = { {-1, "Unknown", "unknown"}, {MAD_EMPHASIS_NONE, "None", "none"}, {MAD_EMPHASIS_50_15_US, "50/15 Microseconds", "50-15"}, {MAD_EMPHASIS_CCITT_J_17, "CCITT J.17", "j-17"}, {MAD_EMPHASIS_RESERVED, "Reserved", "reserved"}, {0, NULL, NULL}, }; if (!mad_emphasis_type) { mad_emphasis_type = g_enum_register_static ("GstMadEmphasis", mad_emphasis); } return mad_emphasis_type; } static void gst_mad_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&mad_sink_template_factory)); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&mad_src_template_factory)); gst_element_class_set_details (element_class, &gst_mad_details); } static void gst_mad_class_init (GstMadClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; gobject_class = (GObjectClass *) klass; gstelement_class = (GstElementClass *) klass; parent_class = g_type_class_peek_parent (klass); gobject_class->set_property = gst_mad_set_property; gobject_class->get_property = gst_mad_get_property; gobject_class->dispose = gst_mad_dispose; gstelement_class->change_state = gst_mad_change_state; gstelement_class->set_index = gst_mad_set_index; gstelement_class->get_index = gst_mad_get_index; /* init properties */ /* currently, string representations are used, we might want to change that */ /* FIXME: descriptions need to be more technical, * default values and ranges need to be selected right */ g_object_class_install_property (gobject_class, ARG_HALF, g_param_spec_boolean ("half", "Half", "Generate PCM at 1/2 sample rate", FALSE, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_IGNORE_CRC, g_param_spec_boolean ("ignore_crc", "Ignore CRC", "Ignore CRC errors", TRUE, G_PARAM_READWRITE)); /* register tags */ #define GST_TAG_LAYER "layer" #define GST_TAG_MODE "mode" #define GST_TAG_EMPHASIS "emphasis" gst_tag_register (GST_TAG_LAYER, GST_TAG_FLAG_ENCODED, G_TYPE_UINT, "layer", "MPEG audio layer", NULL); gst_tag_register (GST_TAG_MODE, GST_TAG_FLAG_ENCODED, G_TYPE_STRING, "mode", "MPEG audio channel mode", NULL); gst_tag_register (GST_TAG_EMPHASIS, GST_TAG_FLAG_ENCODED, G_TYPE_STRING, "emphasis", "MPEG audio emphasis", NULL); } static void gst_mad_init (GstMad * mad) { GstPadTemplate *template; /* create the sink and src pads */ template = gst_static_pad_template_get (&mad_sink_template_factory); mad->sinkpad = gst_pad_new_from_template (template, "sink"); gst_object_unref (template); gst_element_add_pad (GST_ELEMENT (mad), mad->sinkpad); gst_pad_set_chain_function (mad->sinkpad, GST_DEBUG_FUNCPTR (gst_mad_chain)); gst_pad_set_event_function (mad->sinkpad, GST_DEBUG_FUNCPTR (gst_mad_sink_event)); template = gst_static_pad_template_get (&mad_src_template_factory); mad->srcpad = gst_pad_new_from_template (template, "src"); gst_object_unref (template); gst_element_add_pad (GST_ELEMENT (mad), mad->srcpad); gst_pad_set_event_function (mad->srcpad, GST_DEBUG_FUNCPTR (gst_mad_src_event)); gst_pad_set_query_function (mad->srcpad, GST_DEBUG_FUNCPTR (gst_mad_src_query)); gst_pad_set_query_type_function (mad->srcpad, GST_DEBUG_FUNCPTR (gst_mad_get_query_types)); gst_pad_use_fixed_caps (mad->srcpad); mad->tempbuffer = g_malloc (MAD_BUFFER_MDLEN * 3); mad->tempsize = 0; mad->base_byte_offset = 0; mad->bytes_consumed = 0; mad->total_samples = 0; mad->new_header = TRUE; mad->framecount = 0; mad->vbr_average = 0; mad->vbr_rate = 0; mad->restart = TRUE; mad->segment_start = 0; mad->header.mode = -1; mad->header.emphasis = -1; mad->tags = NULL; mad->half = FALSE; mad->ignore_crc = TRUE; mad->check_for_xing = TRUE; mad->xing_found = FALSE; } static void gst_mad_dispose (GObject * object) { GstMad *mad = GST_MAD (object); gst_mad_set_index (GST_ELEMENT (object), NULL); G_OBJECT_CLASS (parent_class)->dispose (object); g_free (mad->tempbuffer); mad->tempbuffer = NULL; } static void gst_mad_set_index (GstElement * element, GstIndex * index) { GstMad *mad = GST_MAD (element); mad->index = index; if (index) gst_index_get_writer_id (index, GST_OBJECT (element), &mad->index_id); } static GstIndex * gst_mad_get_index (GstElement * element) { GstMad *mad = GST_MAD (element); return mad->index; } static gboolean gst_mad_convert_sink (GstPad * pad, GstFormat src_format, gint64 src_value, GstFormat * dest_format, gint64 * dest_value) { gboolean res = TRUE; GstMad *mad; if (src_format == *dest_format) { *dest_value = src_value; return TRUE; } mad = GST_MAD (GST_PAD_PARENT (pad)); if (mad->vbr_average == 0) return FALSE; switch (src_format) { case GST_FORMAT_BYTES: switch (*dest_format) { case GST_FORMAT_TIME: /* multiply by 8 because vbr is in bits/second */ *dest_value = gst_util_uint64_scale (src_value, 8 * GST_SECOND, mad->vbr_average); break; default: res = FALSE; } break; case GST_FORMAT_TIME: switch (*dest_format) { case GST_FORMAT_BYTES: /* multiply by 8 because vbr is in bits/second */ *dest_value = gst_util_uint64_scale (src_value, mad->vbr_average, 8 * GST_SECOND); break; default: res = FALSE; } break; default: res = FALSE; } return res; } static gboolean gst_mad_convert_src (GstPad * pad, GstFormat src_format, gint64 src_value, GstFormat * dest_format, gint64 * dest_value) { gboolean res = TRUE; guint scale = 1; gint bytes_per_sample; GstMad *mad; if (src_format == *dest_format) { *dest_value = src_value; return TRUE; } mad = GST_MAD (GST_PAD_PARENT (pad)); bytes_per_sample = MAD_NCHANNELS (&mad->frame.header) * 4; switch (src_format) { case GST_FORMAT_BYTES: switch (*dest_format) { case GST_FORMAT_DEFAULT: if (bytes_per_sample == 0) return FALSE; *dest_value = src_value / bytes_per_sample; break; case GST_FORMAT_TIME: { gint byterate = bytes_per_sample * mad->frame.header.samplerate; if (byterate == 0) return FALSE; *dest_value = gst_util_uint64_scale_int (src_value, GST_SECOND, byterate); break; } default: res = FALSE; } break; case GST_FORMAT_DEFAULT: switch (*dest_format) { case GST_FORMAT_BYTES: *dest_value = src_value * bytes_per_sample; break; case GST_FORMAT_TIME: if (mad->frame.header.samplerate == 0) return FALSE; *dest_value = gst_util_uint64_scale_int (src_value, GST_SECOND, mad->frame.header.samplerate); break; default: res = FALSE; } break; case GST_FORMAT_TIME: switch (*dest_format) { case GST_FORMAT_BYTES: scale = bytes_per_sample; /* fallthrough */ case GST_FORMAT_DEFAULT: *dest_value = gst_util_uint64_scale_int (src_value, scale * mad->frame.header.samplerate, GST_SECOND); break; default: res = FALSE; } break; default: res = FALSE; } return res; } static const GstQueryType * gst_mad_get_query_types (GstPad * pad) { static const GstQueryType gst_mad_src_query_types[] = { GST_QUERY_POSITION, GST_QUERY_DURATION, GST_QUERY_CONVERT, 0 }; return gst_mad_src_query_types; } static gboolean gst_mad_src_query (GstPad * pad, GstQuery * query) { gboolean res = TRUE; GstPad *peer; GstMad *mad; mad = GST_MAD (GST_PAD_PARENT (pad)); peer = gst_pad_get_peer (mad->sinkpad); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_FORMATS: gst_query_set_formats (query, 3, GST_FORMAT_DEFAULT, GST_FORMAT_TIME, GST_FORMAT_BYTES); break; case GST_QUERY_POSITION: { GstFormat format; gint64 cur; /* save requested format */ gst_query_parse_position (query, &format, NULL); /* try any demuxer before us first */ if (format == GST_FORMAT_TIME && peer && gst_pad_query (peer, query)) { gst_query_parse_position (query, NULL, &cur); GST_LOG_OBJECT (mad, "peer returned position %" GST_TIME_FORMAT, GST_TIME_ARGS (cur)); break; } /* and convert to the requested format */ if (format != GST_FORMAT_DEFAULT) { if (!gst_mad_convert_src (pad, GST_FORMAT_DEFAULT, mad->total_samples, &format, &cur)) goto error; } else { cur = mad->total_samples; } gst_query_set_position (query, format, cur); if (format == GST_FORMAT_TIME) { GST_LOG ("position=%" GST_TIME_FORMAT, GST_TIME_ARGS (cur)); } else { GST_LOG ("position=%" G_GINT64_FORMAT ", format=%u", cur, format); } break; } case GST_QUERY_DURATION: { GstFormat bytes_format = GST_FORMAT_BYTES; GstFormat time_format = GST_FORMAT_TIME; GstFormat req_format; gint64 total, total_bytes; /* save requested format */ gst_query_parse_duration (query, &req_format, NULL); if (peer == NULL) goto error; /* try any demuxer before us first */ if (req_format == GST_FORMAT_TIME && gst_pad_query (peer, query)) { gst_query_parse_duration (query, NULL, &total); GST_LOG_OBJECT (mad, "peer returned duration %" GST_TIME_FORMAT, GST_TIME_ARGS (total)); break; } /* query peer for total length in bytes */ if (!gst_pad_query_peer_duration (mad->sinkpad, &bytes_format, &total_bytes) || total_bytes <= 0) { GST_LOG_OBJECT (mad, "duration query on peer pad failed"); goto error; } GST_LOG_OBJECT (mad, "peer pad returned total=%" G_GINT64_FORMAT " bytes", total_bytes); if (!gst_mad_convert_sink (pad, GST_FORMAT_BYTES, total_bytes, &time_format, &total)) { GST_DEBUG_OBJECT (mad, "conversion BYTE => TIME failed"); goto error; } if (!gst_mad_convert_src (pad, GST_FORMAT_TIME, total, &req_format, &total)) { GST_DEBUG_OBJECT (mad, "conversion TIME => %s failed", gst_format_get_name (req_format)); goto error; } gst_query_set_duration (query, req_format, total); if (req_format == GST_FORMAT_TIME) { GST_LOG_OBJECT (mad, "duration=%" GST_TIME_FORMAT, GST_TIME_ARGS (total)); } else { GST_LOG_OBJECT (mad, "duration=%" G_GINT64_FORMAT " (%s)", gst_format_get_name (req_format)); } break; } case GST_QUERY_CONVERT: { GstFormat src_fmt, dest_fmt; gint64 src_val, dest_val; gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val); if (!(res = gst_mad_convert_src (pad, src_fmt, src_val, &dest_fmt, &dest_val))) goto error; gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); break; } default: res = gst_pad_query_default (pad, query); break; } if (peer) gst_object_unref (peer); return res; error: GST_DEBUG ("error handling query"); if (peer) gst_object_unref (peer); return FALSE; } static gboolean index_seek (GstMad * mad, GstPad * pad, GstEvent * event) { gdouble rate; GstFormat format; GstSeekFlags flags; GstSeekType cur_type, stop_type; gint64 cur, stop; GstIndexEntry *entry = NULL; /* since we know the exact byteoffset of the frame, make sure to try bytes first */ const GstFormat try_all_formats[] = { GST_FORMAT_BYTES, GST_FORMAT_TIME, 0 }; const GstFormat *try_formats = try_all_formats; const GstFormat *peer_formats; gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur, &stop_type, &stop); entry = gst_index_get_assoc_entry (mad->index, mad->index_id, GST_INDEX_LOOKUP_BEFORE, 0, format, cur); GST_DEBUG ("index seek"); if (!entry) return FALSE; #if 0 peer_formats = gst_pad_get_formats (GST_PAD_PEER (mad->sinkpad)); #else peer_formats = try_all_formats; /* FIXME */ #endif while (gst_formats_contains (peer_formats, *try_formats)) { gint64 value; GstEvent *seek_event; if (gst_index_entry_assoc_map (entry, *try_formats, &value)) { /* lookup succeeded, create the seek */ GST_DEBUG ("index %s %" G_GINT64_FORMAT " -> %s %" G_GINT64_FORMAT, gst_format_get_details (format)->nick, cur, gst_format_get_details (*try_formats)->nick, value); seek_event = gst_event_new_seek (rate, *try_formats, flags, cur_type, value, stop_type, stop); if (gst_pad_send_event (GST_PAD_PEER (mad->sinkpad), seek_event)) { /* seek worked, we're done, loop will exit */ mad->restart = TRUE; g_assert (format == GST_FORMAT_TIME); mad->segment_start = cur; return TRUE; } } try_formats++; } return FALSE; } static gboolean normal_seek (GstMad * mad, GstPad * pad, GstEvent * event) { gdouble rate; GstFormat format, conv; GstSeekFlags flags; GstSeekType cur_type, stop_type; gint64 cur, stop; gint64 time_cur, time_stop; gint64 bytes_cur, bytes_stop; gboolean flush; /* const GstFormat *peer_formats; */ gboolean res; GST_DEBUG ("normal seek"); gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur, &stop_type, &stop); if (format != GST_FORMAT_TIME) { conv = GST_FORMAT_TIME; if (!gst_mad_convert_src (pad, format, cur, &conv, &time_cur)) goto convert_error; if (!gst_mad_convert_src (pad, format, stop, &conv, &time_stop)) goto convert_error; } else { time_cur = cur; time_stop = stop; } GST_DEBUG ("seek to time %" GST_TIME_FORMAT "-%" GST_TIME_FORMAT, GST_TIME_ARGS (time_cur), GST_TIME_ARGS (time_stop)); /* shave off the flush flag, we'll need it later */ flush = ((flags & GST_SEEK_FLAG_FLUSH) != 0); /* assume the worst */ res = FALSE; conv = GST_FORMAT_BYTES; if (!gst_mad_convert_sink (pad, GST_FORMAT_TIME, time_cur, &conv, &bytes_cur)) goto convert_error; if (!gst_mad_convert_sink (pad, GST_FORMAT_TIME, time_stop, &conv, &bytes_stop)) goto convert_error; { GstEvent *seek_event; /* conversion succeeded, create the seek */ seek_event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags, cur_type, bytes_cur, stop_type, bytes_stop); /* do the seek */ res = gst_pad_push_event (mad->sinkpad, seek_event); if (res) { /* we need to break out of the processing loop on flush */ mad->restart = flush; mad->segment_start = time_cur; mad->last_ts = time_cur; } } #if 0 peer_formats = gst_pad_get_formats (GST_PAD_PEER (mad->sinkpad)); /* while we did not exhaust our seek formats without result */ while (peer_formats && *peer_formats && !res) { gint64 desired_offset; format = *peer_formats; /* try to convert requested format to one we can seek with on the sinkpad */ if (gst_pad_convert (mad->sinkpad, GST_FORMAT_TIME, src_offset, &format, &desired_offset)) { GstEvent *seek_event; /* conversion succeeded, create the seek */ seek_event = gst_event_new_seek (format | GST_EVENT_SEEK_METHOD (event) | flush, desired_offset); /* do the seek */ if (gst_pad_send_event (GST_PAD_PEER (mad->sinkpad), seek_event)) { /* seek worked, we're done, loop will exit */ res = TRUE; } } /* at this point, either the seek worked or res == FALSE */ if (res) /* we need to break out of the processing loop on flush */ mad->restart = flush; peer_formats++; } #endif return res; /* ERRORS */ convert_error: { /* probably unsupported seek format */ GST_DEBUG ("failed to convert format %u into GST_FORMAT_TIME", format); return FALSE; } } static gboolean gst_mad_src_event (GstPad * pad, GstEvent * event) { gboolean res = TRUE; GstMad *mad; mad = GST_MAD (GST_PAD_PARENT (pad)); switch (GST_EVENT_TYPE (event)) { /* the all-formats seek logic */ case GST_EVENT_SEEK: gst_event_ref (event); if (!(res = gst_pad_event_default (pad, event))) { if (mad->index) res = index_seek (mad, pad, event); else res = normal_seek (mad, pad, event); } break; default: res = FALSE; break; } gst_event_unref (event); return res; } static inline gint32 scale (mad_fixed_t sample) { #if MAD_F_FRACBITS < 28 /* round */ sample += (1L << (28 - MAD_F_FRACBITS - 1)); #endif /* clip */ if (sample >= MAD_F_ONE) sample = MAD_F_ONE - 1; else if (sample < -MAD_F_ONE) sample = -MAD_F_ONE; #if MAD_F_FRACBITS < 28 /* quantize */ sample >>= (28 - MAD_F_FRACBITS); #endif /* convert from 29 bits to 32 bits */ return (gint32) (sample << 3); } /* do we need this function? */ static void gst_mad_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMad *mad; mad = GST_MAD (object); switch (prop_id) { case ARG_HALF: mad->half = g_value_get_boolean (value); break; case ARG_IGNORE_CRC: mad->ignore_crc = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_mad_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstMad *mad; mad = GST_MAD (object); switch (prop_id) { case ARG_HALF: g_value_set_boolean (value, mad->half); break; case ARG_IGNORE_CRC: g_value_set_boolean (value, mad->ignore_crc); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_mad_update_info (GstMad * mad) { gint abr = mad->vbr_average; struct mad_header *header = &mad->frame.header; gboolean changed = FALSE; #define CHECK_HEADER(h1,str) \ G_STMT_START{ \ if (mad->header.h1 != header->h1 || mad->new_header) { \ mad->header.h1 = header->h1; \ changed = TRUE; \ }; \ } G_STMT_END /* update average bitrate */ if (mad->new_header) { mad->framecount = 1; mad->vbr_rate = header->bitrate; abr = 0; } else { mad->framecount++; mad->vbr_rate += header->bitrate; } mad->vbr_average = (gint) (mad->vbr_rate / mad->framecount); CHECK_HEADER (layer, "layer"); CHECK_HEADER (mode, "mode"); CHECK_HEADER (emphasis, "emphasis"); mad->header.bitrate = header->bitrate; mad->new_header = FALSE; if (changed) { GstTagList *list; GEnumValue *mode; GEnumValue *emphasis; mode = g_enum_get_value (g_type_class_ref (GST_TYPE_MAD_MODE), mad->header.mode); emphasis = g_enum_get_value (g_type_class_ref (GST_TYPE_MAD_EMPHASIS), mad->header.emphasis); list = gst_tag_list_new (); gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_LAYER, mad->header.layer, GST_TAG_MODE, mode->value_nick, GST_TAG_EMPHASIS, emphasis->value_nick, NULL); if (!mad->framed) { gchar *str; str = g_strdup_printf ("MPEG-1 layer %d", mad->header.layer); gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_AUDIO_CODEC, str, NULL); g_free (str); } if (!mad->xing_found) { gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_BITRATE, mad->header.bitrate, NULL); } gst_element_post_message (GST_ELEMENT (mad), gst_message_new_tag (GST_OBJECT (mad), list)); } #undef CHECK_HEADER } static gboolean gst_mad_sink_event (GstPad * pad, GstEvent * event) { GstMad *mad = GST_MAD (GST_PAD_PARENT (pad)); gboolean result; GST_DEBUG ("handling %s event", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_NEWSEGMENT:{ GstFormat format; gst_event_parse_new_segment (event, NULL, NULL, &format, NULL, NULL, NULL); if (format == GST_FORMAT_TIME) { /* FIXME: is this really correct? */ mad->tempsize = 0; result = gst_pad_push_event (mad->srcpad, event); /* we don't need to restart when we get here */ mad->restart = FALSE; mad->framed = TRUE; } else { GST_DEBUG ("dropping newsegment event in format %s", gst_format_get_name (format)); /* on restart the chain function will generate a new * newsegment event, so we can just drop this one */ mad->restart = TRUE; gst_event_unref (event); mad->tempsize = 0; mad->framed = FALSE; result = TRUE; } break; } case GST_EVENT_EOS: mad->caps_set = FALSE; /* could be a new stream */ result = gst_pad_push_event (mad->srcpad, event); break; case GST_EVENT_FLUSH_STOP: /* Clear any stored data, as it won't make sense once * the new data arrives */ mad->tempsize = 0; mad_frame_mute (&mad->frame); mad_synth_mute (&mad->synth); result = gst_pad_event_default (pad, event); break; default: result = gst_pad_event_default (pad, event); break; } return result; } static gboolean gst_mad_check_restart (GstMad * mad) { gboolean yes = mad->restart; if (mad->restart) { mad->restart = FALSE; mad->tempsize = 0; } return yes; } /* The following code has been taken from * rhythmbox/metadata/monkey-media/stream-info-impl/id3-vfs/mp3bitrate.c * which took it from xine-lib/src/demuxers/demux_mpgaudio.c * This code has been kindly relicensed to LGPL by Thibaut Mattern and * Bastien Nocera */ #define BE_32(x) GST_READ_UINT32_BE(x) #define FOURCC_TAG( ch0, ch1, ch2, ch3 ) \ ( (long)(unsigned char)(ch3) | \ ( (long)(unsigned char)(ch2) << 8 ) | \ ( (long)(unsigned char)(ch1) << 16 ) | \ ( (long)(unsigned char)(ch0) << 24 ) ) /* Xing header stuff */ #define XING_TAG FOURCC_TAG('X', 'i', 'n', 'g') #define XING_FRAMES_FLAG 0x0001 #define XING_BYTES_FLAG 0x0002 #define XING_TOC_FLAG 0x0004 #define XING_VBR_SCALE_FLAG 0x0008 #define XING_TOC_LENGTH 100 /* check for valid "Xing" VBR header */ static int is_xhead (unsigned char *buf) { return (BE_32 (buf) == XING_TAG); } #undef LOG /*#define LOG*/ #ifdef LOG #ifndef WIN32 #define lprintf(x...) g_print(x) #else #define lprintf GST_DEBUG #endif #else #ifndef WIN32 #define lprintf(x...) #else #define lprintf GST_DEBUG #endif #endif static int mpg123_parse_xing_header (struct mad_header *header, const guint8 * buf, int bufsize, int *bitrate, int *time) { int i; guint8 *ptr = (guint8 *) buf; double frame_duration; int xflags, xframes, xbytes, xvbr_scale; int abr; guint8 xtoc[XING_TOC_LENGTH]; int lsf_bit = !(header->flags & MAD_FLAG_LSF_EXT); xframes = xbytes = 0; /* offset of the Xing header */ if (lsf_bit) { if (header->mode != MAD_MODE_SINGLE_CHANNEL) ptr += (32 + 4); else ptr += (17 + 4); } else { if (header->mode != MAD_MODE_SINGLE_CHANNEL) ptr += (17 + 4); else ptr += (9 + 4); } if (ptr >= (buf + bufsize - 4)) return 0; if (is_xhead (ptr)) { lprintf ("Xing header found\n"); ptr += 4; if (ptr >= (buf + bufsize - 4)) return 0; xflags = BE_32 (ptr); ptr += 4; if (xflags & XING_FRAMES_FLAG) { if (ptr >= (buf + bufsize - 4)) return 0; xframes = BE_32 (ptr); lprintf ("xframes: %d\n", xframes); ptr += 4; } if (xflags & XING_BYTES_FLAG) { if (ptr >= (buf + bufsize - 4)) return 0; xbytes = BE_32 (ptr); lprintf ("xbytes: %d\n", xbytes); ptr += 4; } if (xflags & XING_TOC_FLAG) { lprintf ("toc found\n"); if (ptr >= (buf + bufsize - XING_TOC_LENGTH)) return 0; for (i = 0; i < XING_TOC_LENGTH; i++) { xtoc[i] = *(ptr + i); lprintf ("%d ", xtoc[i]); } lprintf ("\n"); ptr += XING_TOC_LENGTH; } xvbr_scale = -1; if (xflags & XING_VBR_SCALE_FLAG) { if (ptr >= (buf + bufsize - 4)) return 0; xvbr_scale = BE_32 (ptr); lprintf ("xvbr_scale: %d\n", xvbr_scale); } /* 1 kbit = 1000 bits ! (and not 1024 bits) */ if (xflags & (XING_FRAMES_FLAG | XING_BYTES_FLAG)) { if (header->layer == MAD_LAYER_I) { frame_duration = 384.0 / (double) header->samplerate; } else { int slots_per_frame; slots_per_frame = ((header->layer == MAD_LAYER_III) && !lsf_bit) ? 72 : 144; frame_duration = slots_per_frame * 8.0 / (double) header->samplerate; } abr = ((double) xbytes * 8.0) / ((double) xframes * frame_duration); lprintf ("abr: %d bps\n", abr); if (bitrate != NULL) { *bitrate = abr; } if (time != NULL) { *time = (double) xframes *frame_duration; lprintf ("stream_length: %d s, %d min %d s\n", *time, *time / 60, *time % 60); } } else { /* it's a stupid Xing header */ lprintf ("not a Xing VBR file\n"); } return 1; } else { lprintf ("Xing header not found\n"); return 0; } } /* End of Xine code */ /* internal function to check if the header has changed and thus the * caps need to be reset. Only call during normal mode, not resyncing */ static void gst_mad_check_caps_reset (GstMad * mad) { guint nchannels; guint rate, old_rate = mad->rate; nchannels = MAD_NCHANNELS (&mad->frame.header); #if MAD_VERSION_MINOR <= 12 rate = mad->header.sfreq; #else rate = mad->frame.header.samplerate; #endif /* rate and channels are not supposed to change in a continuous stream, * so check this first before doing anything */ /* only set caps if they weren't already set for this continuous stream */ if (mad->channels != nchannels || mad->rate != rate) { if (mad->caps_set) { GST_DEBUG ("Header changed from %d Hz/%d ch to %d Hz/%d ch, failed sync after seek ?", mad->rate, mad->channels, rate, nchannels); /* we're conservative on stream changes. However, our *initial* caps * might have been wrong as well - mad ain't perfect in syncing. So, * we count caps changes and change if we pass a limit treshold (3). */ if (nchannels != mad->pending_channels || rate != mad->pending_rate) { mad->times_pending = 0; mad->pending_channels = nchannels; mad->pending_rate = rate; } if (++mad->times_pending < 3) return; } } gst_mad_update_info (mad); if (mad->channels != nchannels || mad->rate != rate) { GstCaps *caps; if (mad->stream.options & MAD_OPTION_HALFSAMPLERATE) rate >>= 1; /* FIXME see if peer can accept the caps */ /* we set the caps even when the pad is not connected so they * can be gotten for streaminfo */ caps = gst_caps_new_simple ("audio/x-raw-int", "endianness", G_TYPE_INT, G_BYTE_ORDER, "signed", G_TYPE_BOOLEAN, TRUE, "width", G_TYPE_INT, 32, "depth", G_TYPE_INT, 32, "rate", G_TYPE_INT, rate, "channels", G_TYPE_INT, nchannels, NULL); gst_pad_set_caps (mad->srcpad, caps); gst_caps_unref (caps); mad->caps_set = TRUE; /* set back to FALSE on discont */ mad->channels = nchannels; mad->rate = rate; /* update sample count so we don't come up with crazy timestamps */ if (mad->total_samples && old_rate) { mad->total_samples = mad->total_samples * rate / old_rate; } } } static GstFlowReturn gst_mad_chain (GstPad * pad, GstBuffer * buffer) { GstMad *mad; guint8 *data; glong size, tempsize; gboolean new_pts = FALSE; GstClockTime timestamp; GstFlowReturn result = GST_FLOW_OK; mad = GST_MAD (GST_PAD_PARENT (pad)); /* restarts happen on discontinuities, ie. seek, flush, PAUSED to PLAYING */ if (gst_mad_check_restart (mad)) { mad->need_newsegment = TRUE; GST_DEBUG ("mad restarted"); } timestamp = GST_BUFFER_TIMESTAMP (buffer); GST_DEBUG ("mad in timestamp %" GST_TIME_FORMAT, GST_TIME_ARGS (timestamp)); /* handle timestamps */ if (GST_CLOCK_TIME_IS_VALID (timestamp)) { /* if there is nothing left to process in our temporary buffer, * we can set this timestamp on the next outgoing buffer */ if (mad->tempsize == 0) { /* we have to save the result here because we can't yet convert * the timestamp to a sample offset, as the samplerate might not * be known yet */ mad->last_ts = timestamp; mad->base_byte_offset = GST_BUFFER_OFFSET (buffer); mad->bytes_consumed = 0; } /* else we need to finish the current partial frame with the old timestamp * and queue this timestamp for the next frame */ else { new_pts = TRUE; } } GST_DEBUG ("last_ts %" GST_TIME_FORMAT, GST_TIME_ARGS (mad->last_ts)); /* handle data */ data = GST_BUFFER_DATA (buffer); size = GST_BUFFER_SIZE (buffer); tempsize = mad->tempsize; /* process the incoming buffer in chunks of maximum MAD_BUFFER_MDLEN bytes; * this is the upper limit on processable chunk sizes set by mad */ while (size > 0) { gint tocopy; guchar *mad_input_buffer; /* convenience pointer to tempbuffer */ tocopy = MIN (MAD_BUFFER_MDLEN, MIN (size, MAD_BUFFER_MDLEN * 3 - mad->tempsize)); if (tocopy == 0) { GST_ELEMENT_ERROR (mad, STREAM, DECODE, (NULL), ("mad claims to need more data than %u bytes, we don't have that much", MAD_BUFFER_MDLEN * 3)); result = GST_FLOW_ERROR; goto end; } /* append the chunk to process to our internal temporary buffer */ GST_LOG ("tempbuffer size %d, copying %d bytes from incoming buffer", mad->tempsize, tocopy); memcpy (mad->tempbuffer + mad->tempsize, data, tocopy); mad->tempsize += tocopy; /* update our incoming buffer's parameters to reflect this */ size -= tocopy; data += tocopy; mad_input_buffer = mad->tempbuffer; /* while we have data we can consume it */ while (mad->tempsize > 0) { gint consumed = 0; guint nsamples; guint64 time_offset; guint64 time_duration; unsigned char const *before_sync, *after_sync; gboolean goto_exit = FALSE; mad->in_error = FALSE; mad_stream_buffer (&mad->stream, mad_input_buffer, mad->tempsize); /* added separate header decoding to catch errors earlier, also fixes * some weird decoding errors... */ GST_LOG ("decoding the header now"); if (mad_header_decode (&mad->frame.header, &mad->stream) == -1) { if (mad->stream.error == MAD_ERROR_BUFLEN) { GST_LOG ("not enough data in tempbuffer (%d), breaking to get more", mad->tempsize); break; } else { GST_WARNING ("mad_header_decode had an error: %s", mad_stream_errorstr (&mad->stream)); } } GST_LOG ("decoding one frame now"); if (mad_frame_decode (&mad->frame, &mad->stream) == -1) { GST_LOG ("got error %d", mad->stream.error); /* not enough data, need to wait for next buffer? */ if (mad->stream.error == MAD_ERROR_BUFLEN) { if (mad->stream.next_frame == mad_input_buffer) { GST_LOG ("not enough data in tempbuffer (%d), breaking to get more", mad->tempsize); break; } else { GST_LOG ("sync error, flushing unneeded data"); goto next_no_samples; } } /* we are in an error state */ mad->in_error = TRUE; GST_WARNING ("mad_frame_decode had an error: %s", mad_stream_errorstr (&mad->stream)); if (!MAD_RECOVERABLE (mad->stream.error)) { GST_ELEMENT_ERROR (mad, STREAM, DECODE, (NULL), (NULL)); result = GST_FLOW_ERROR; goto end; } else if (mad->stream.error == MAD_ERROR_LOSTSYNC) { /* lost sync, force a resync */ signed long tagsize; GST_INFO ("recoverable lost sync error"); tagsize = id3_tag_query (mad->stream.this_frame, mad->stream.bufend - mad->stream.this_frame); if (tagsize > mad->tempsize) { GST_INFO ("mad: got partial id3 tag in buffer, skipping"); } else if (tagsize > 0) { struct id3_tag *tag; id3_byte_t const *data; GST_INFO ("mad: got ID3 tag size %ld", tagsize); data = mad->stream.this_frame; /* mad has moved the pointer to the next frame over the start of the * id3 tags, so we need to flush one byte less than the tagsize */ mad_stream_skip (&mad->stream, tagsize - 1); tag = id3_tag_parse (data, tagsize); if (tag) { GstTagList *list; list = gst_mad_id3_to_tag_list (tag); id3_tag_delete (tag); GST_DEBUG ("found tag"); gst_element_post_message (GST_ELEMENT (mad), gst_message_new_tag (GST_OBJECT (mad), gst_tag_list_copy (list))); if (mad->tags) { gst_tag_list_insert (mad->tags, list, GST_TAG_MERGE_PREPEND); } else { mad->tags = gst_tag_list_copy (list); } gst_pad_push_event (mad->srcpad, gst_event_new_tag (list)); } } } mad_frame_mute (&mad->frame); mad_synth_mute (&mad->synth); before_sync = mad->stream.ptr.byte; if (mad_stream_sync (&mad->stream) != 0) GST_WARNING ("mad_stream_sync failed"); after_sync = mad->stream.ptr.byte; /* a succesful resync should make us drop bytes as consumed, so calculate from the byte pointers before and after resync */ consumed = after_sync - before_sync; GST_DEBUG ("resynchronization consumes %d bytes", consumed); GST_DEBUG ("synced to data: 0x%0x 0x%0x", *mad->stream.ptr.byte, *(mad->stream.ptr.byte + 1)); mad_stream_sync (&mad->stream); /* recoverable errors pass */ goto next_no_samples; } if (mad->check_for_xing) { int bitrate = 0, time = 0; GstTagList *list; int frame_len = mad->stream.next_frame - mad->stream.this_frame; mad->check_for_xing = FALSE; /* Assume Xing headers can only be the first frame in a mp3 file */ if (mpg123_parse_xing_header (&mad->frame.header, mad->stream.this_frame, frame_len, &bitrate, &time)) { mad->xing_found = TRUE; list = gst_tag_list_new (); gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_DURATION, (gint64) time * 1000 * 1000 * 1000, GST_TAG_BITRATE, bitrate, NULL); gst_element_post_message (GST_ELEMENT (mad), gst_message_new_tag (GST_OBJECT (mad), gst_tag_list_copy (list))); gst_pad_push_event (mad->srcpad, gst_event_new_tag (list)); goto next_no_samples; } } /* if we're not resyncing/in error, check if caps need to be set again */ if (!mad->in_error) gst_mad_check_caps_reset (mad); nsamples = MAD_NSBSAMPLES (&mad->frame.header) * (mad->stream.options & MAD_OPTION_HALFSAMPLERATE ? 16 : 32); if (mad->frame.header.samplerate == 0) { g_warning ("mad->frame.header.samplerate is 0; timestamps cannot be calculated"); time_offset = GST_CLOCK_TIME_NONE; time_duration = GST_CLOCK_TIME_NONE; } else { /* if we have a pending timestamp, we can use it now to calculate the sample offset */ if (GST_CLOCK_TIME_IS_VALID (mad->last_ts)) { GstFormat format = GST_FORMAT_DEFAULT; gint64 total; gst_pad_query_convert (mad->srcpad, GST_FORMAT_TIME, mad->last_ts, &format, &total); mad->total_samples = total; mad->last_ts = GST_CLOCK_TIME_NONE; } time_offset = gst_util_uint64_scale_int (mad->total_samples, GST_SECOND, mad->rate); time_duration = gst_util_uint64_scale_int (nsamples, GST_SECOND, mad->rate); } if (mad->index) { guint64 x_bytes = mad->base_byte_offset + mad->bytes_consumed; gst_index_add_association (mad->index, mad->index_id, 0, GST_FORMAT_BYTES, x_bytes, GST_FORMAT_TIME, time_offset, NULL); } if (mad->segment_start <= (time_offset == GST_CLOCK_TIME_NONE ? 0 : time_offset)) { /* for sample accurate seeking, calculate how many samples to skip and send the remaining pcm samples */ GstBuffer *outbuffer = NULL; gint32 *outdata; mad_fixed_t const *left_ch, *right_ch; if (mad->need_newsegment) { gint64 start = time_offset; GST_DEBUG ("Sending NEWSEGMENT event, start=%" GST_TIME_FORMAT, GST_TIME_ARGS (start)); gst_pad_push_event (mad->srcpad, gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, start, GST_CLOCK_TIME_NONE, start)); mad->need_newsegment = FALSE; } /* will attach the caps to the buffer */ result = gst_pad_alloc_buffer_and_set_caps (mad->srcpad, 0, nsamples * mad->channels * 4, GST_PAD_CAPS (mad->srcpad), &outbuffer); if (result != GST_FLOW_OK) { /* Head for the exit, dropping samples as we go */ GST_LOG ("Skipping frame synthesis due to pad_alloc return value"); goto_exit = TRUE; goto skip_frame; } mad_synth_frame (&mad->synth, &mad->frame); left_ch = mad->synth.pcm.samples[0]; right_ch = mad->synth.pcm.samples[1]; outdata = (gint32 *) GST_BUFFER_DATA (outbuffer); GST_DEBUG ("mad out timestamp %" GST_TIME_FORMAT, GST_TIME_ARGS (time_offset)); GST_BUFFER_TIMESTAMP (outbuffer) = time_offset; GST_BUFFER_DURATION (outbuffer) = time_duration; GST_BUFFER_OFFSET (outbuffer) = mad->total_samples; /* output sample(s) in 16-bit signed native-endian PCM */ if (mad->channels == 1) { gint count = nsamples; while (count--) { *outdata++ = scale (*left_ch++) & 0xffffffff; } } else { gint count = nsamples; while (count--) { *outdata++ = scale (*left_ch++) & 0xffffffff; *outdata++ = scale (*right_ch++) & 0xffffffff; } } result = gst_pad_push (mad->srcpad, outbuffer); if (result != GST_FLOW_OK) { /* Head for the exit, dropping samples as we go */ goto_exit = TRUE; } } skip_frame: mad->total_samples += nsamples; /* we have a queued timestamp on the incoming buffer that we should * use for the next frame */ if (new_pts && (mad->stream.next_frame - mad_input_buffer >= tempsize)) { new_pts = FALSE; mad->last_ts = timestamp; mad->base_byte_offset = GST_BUFFER_OFFSET (buffer); mad->bytes_consumed = 0; } tempsize = 0; if (gst_mad_check_restart (mad)) { goto end; } next_no_samples: /* figure out how many bytes mad consumed */ /* if consumed is already set, it's from the resync higher up, so we need to use that value instead. Otherwise, recalculate from mad's consumption */ if (consumed == 0) consumed = mad->stream.next_frame - mad_input_buffer; GST_LOG ("mad consumed %d bytes", consumed); /* move out pointer to where mad want the next data */ mad_input_buffer += consumed; mad->tempsize -= consumed; mad->bytes_consumed += consumed; if (goto_exit == TRUE) goto end; } /* we only get here from breaks, tempsize never actually drops below 0 */ memmove (mad->tempbuffer, mad_input_buffer, mad->tempsize); } result = GST_FLOW_OK; end: gst_buffer_unref (buffer); return result; } static GstStateChangeReturn gst_mad_change_state (GstElement * element, GstStateChange transition) { GstMad *mad; GstStateChangeReturn ret; mad = GST_MAD (element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: { guint options = 0; mad_stream_init (&mad->stream); mad_frame_init (&mad->frame); mad_synth_init (&mad->synth); mad->tempsize = 0; mad->total_samples = 0; mad->rate = 0; mad->channels = 0; mad->caps_set = FALSE; mad->times_pending = mad->pending_rate = mad->pending_channels = 0; mad->vbr_average = 0; mad->segment_start = 0; mad->new_header = TRUE; mad->framed = FALSE; mad->framecount = 0; mad->vbr_rate = 0; mad->frame.header.samplerate = 0; mad->last_ts = GST_CLOCK_TIME_NONE; if (mad->ignore_crc) options |= MAD_OPTION_IGNORECRC; if (mad->half) options |= MAD_OPTION_HALFSAMPLERATE; mad_stream_options (&mad->stream, options); break; } case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = parent_class->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: mad_synth_finish (&mad->synth); mad_frame_finish (&mad->frame); mad_stream_finish (&mad->stream); mad->restart = TRUE; mad->check_for_xing = TRUE; if (mad->tags) { gst_tag_list_free (mad->tags); mad->tags = NULL; } break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }