/* GStreamer * Copyright (C) <1999> Erik Walthinsen * Copyright (C) <2006> Tim-Philipp Müller * Copyright (C) <2006> Jan Schmidt * * 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. */ /** * SECTION:element-flacdec * @seealso: flacenc * * * * flacdec decodes FLAC streams. * FLAC * is a Free Lossless Audio Codec. * * Example launch line * * * gst-launch filesrc location=media/small/dark.441-16-s.flac ! flacdec ! audioconvert ! audioresample ! autoaudiosink * * * Another example launch line * * * gst-launch gnomevfssrc location=http://gstreamer.freedesktop.org/media/small/dark.441-16-s.flac ! flacdec ! audioconvert ! audioresample ! queue min-threshold-buffers=10 ! autoaudiosink * * * */ /* TODO: add seeking when operating chain-based with unframed input */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include "gstflacdec.h" #include #include #include #include #include /* Taken from http://flac.sourceforge.net/format.html#frame_header */ static const GstAudioChannelPosition channel_positions[8][8] = { {GST_AUDIO_CHANNEL_POSITION_FRONT_MONO}, {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, { GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, { GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, { GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, { GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_LFE, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, /* FIXME: 7/8 channel layouts are not defined in the FLAC specs */ { GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_LFE, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, { GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER, GST_AUDIO_CHANNEL_POSITION_LFE, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT} }; GST_DEBUG_CATEGORY_STATIC (flacdec_debug); #define GST_CAT_DEFAULT flacdec_debug static GstPadTemplate *src_template, *sink_template; static const GstElementDetails flacdec_details = GST_ELEMENT_DETAILS ("FLAC audio decoder", "Codec/Decoder/Audio", "Decodes FLAC lossless audio streams", "Wim Taymans "); static void gst_flac_dec_finalize (GObject * object); static void gst_flac_dec_loop (GstPad * pad); static GstStateChangeReturn gst_flac_dec_change_state (GstElement * element, GstStateChange transition); static const GstQueryType *gst_flac_dec_get_src_query_types (GstPad * pad); static const GstQueryType *gst_flac_dec_get_sink_query_types (GstPad * pad); static gboolean gst_flac_dec_sink_query (GstPad * pad, GstQuery * query); static gboolean gst_flac_dec_src_query (GstPad * pad, GstQuery * query); static gboolean gst_flac_dec_convert_src (GstPad * pad, GstFormat src_format, gint64 src_value, GstFormat * dest_format, gint64 * dest_value); static gboolean gst_flac_dec_src_event (GstPad * pad, GstEvent * event); static gboolean gst_flac_dec_sink_activate (GstPad * sinkpad); static gboolean gst_flac_dec_sink_activate_pull (GstPad * sinkpad, gboolean active); static gboolean gst_flac_dec_sink_activate_push (GstPad * sinkpad, gboolean active); static gboolean gst_flac_dec_sink_event (GstPad * pad, GstEvent * event); static GstFlowReturn gst_flac_dec_chain (GstPad * pad, GstBuffer * buf); static void gst_flac_dec_reset_decoders (GstFlacDec * flacdec); static void gst_flac_dec_setup_seekable_decoder (GstFlacDec * flacdec); static void gst_flac_dec_setup_stream_decoder (GstFlacDec * flacdec); #ifdef LEGACY_FLAC static FLAC__SeekableStreamDecoderReadStatus gst_flac_dec_read_seekable (const FLAC__SeekableStreamDecoder * decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data); static FLAC__SeekableStreamDecoderSeekStatus gst_flac_dec_seek (const FLAC__SeekableStreamDecoder * decoder, FLAC__uint64 position, void *client_data); static FLAC__SeekableStreamDecoderTellStatus gst_flac_dec_tell (const FLAC__SeekableStreamDecoder * decoder, FLAC__uint64 * position, void *client_data); static FLAC__SeekableStreamDecoderLengthStatus gst_flac_dec_length (const FLAC__SeekableStreamDecoder * decoder, FLAC__uint64 * length, void *client_data); static FLAC__bool gst_flac_dec_eof (const FLAC__SeekableStreamDecoder * decoder, void *client_data); static FLAC__StreamDecoderReadStatus gst_flac_dec_read_stream (const FLAC__StreamDecoder * decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data); static FLAC__StreamDecoderWriteStatus gst_flac_dec_write_seekable (const FLAC__SeekableStreamDecoder * decoder, const FLAC__Frame * frame, const FLAC__int32 * const buffer[], void *client_data); static FLAC__StreamDecoderWriteStatus gst_flac_dec_write_stream (const FLAC__StreamDecoder * decoder, const FLAC__Frame * frame, const FLAC__int32 * const buffer[], void *client_data); static void gst_flac_dec_metadata_callback_seekable (const FLAC__SeekableStreamDecoder * decoder, const FLAC__StreamMetadata * metadata, void *client_data); static void gst_flac_dec_metadata_callback_stream (const FLAC__StreamDecoder * decoder, const FLAC__StreamMetadata * metadata, void *client_data); static void gst_flac_dec_metadata_callback (GstFlacDec * flacdec, const FLAC__StreamMetadata * metadata); static void gst_flac_dec_error_callback_seekable (const FLAC__SeekableStreamDecoder * decoder, FLAC__StreamDecoderErrorStatus status, void *client_data); static void gst_flac_dec_error_callback_stream (const FLAC__StreamDecoder * decoder, FLAC__StreamDecoderErrorStatus status, void *client_data); #else static FLAC__StreamDecoderReadStatus gst_flac_dec_read_seekable (const FLAC__StreamDecoder * decoder, FLAC__byte buffer[], size_t * bytes, void *client_data); static FLAC__StreamDecoderReadStatus gst_flac_dec_read_stream (const FLAC__StreamDecoder * decoder, FLAC__byte buffer[], size_t * bytes, void *client_data); static FLAC__StreamDecoderSeekStatus gst_flac_dec_seek (const FLAC__StreamDecoder * decoder, FLAC__uint64 position, void *client_data); static FLAC__StreamDecoderTellStatus gst_flac_dec_tell (const FLAC__StreamDecoder * decoder, FLAC__uint64 * position, void *client_data); static FLAC__StreamDecoderLengthStatus gst_flac_dec_length (const FLAC__StreamDecoder * decoder, FLAC__uint64 * length, void *client_data); static FLAC__bool gst_flac_dec_eof (const FLAC__StreamDecoder * decoder, void *client_data); static FLAC__StreamDecoderWriteStatus gst_flac_dec_write_stream (const FLAC__StreamDecoder * decoder, const FLAC__Frame * frame, const FLAC__int32 * const buffer[], void *client_data); static void gst_flac_dec_metadata_callback_stream (const FLAC__StreamDecoder * decoder, const FLAC__StreamMetadata * metadata, void *client_data); static void gst_flac_dec_error_callback_stream (const FLAC__StreamDecoder * decoder, FLAC__StreamDecoderErrorStatus status, void *client_data); #endif GST_BOILERPLATE (GstFlacDec, gst_flac_dec, GstElement, GST_TYPE_ELEMENT); #define GST_FLAC_DEC_SRC_CAPS \ "audio/x-raw-int, " \ "endianness = (int) BYTE_ORDER, " \ "signed = (boolean) true, " \ "width = (int) { 8, 16, 32 }, " \ "depth = (int) { 8, 12, 16, 20, 24, 32 }, " \ "rate = (int) [ 8000, 96000 ], " \ "channels = (int) [ 1, 8 ]" static void gst_flac_dec_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); GstCaps *raw_caps, *flac_caps; raw_caps = gst_caps_from_string (GST_FLAC_DEC_SRC_CAPS); flac_caps = gst_caps_new_simple ("audio/x-flac", NULL); sink_template = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, flac_caps); src_template = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, raw_caps); gst_element_class_add_pad_template (element_class, sink_template); gst_element_class_add_pad_template (element_class, src_template); gst_element_class_set_details (element_class, &flacdec_details); GST_DEBUG_CATEGORY_INIT (flacdec_debug, "flacdec", 0, "flac decoder"); } static void gst_flac_dec_class_init (GstFlacDecClass * klass) { GstElementClass *gstelement_class; GObjectClass *gobject_class; gstelement_class = (GstElementClass *) klass; gobject_class = (GObjectClass *) klass; gobject_class->finalize = gst_flac_dec_finalize; gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_flac_dec_change_state); } static void gst_flac_dec_init (GstFlacDec * flacdec, GstFlacDecClass * klass) { flacdec->sinkpad = gst_pad_new_from_template (sink_template, "sink"); gst_pad_set_activate_function (flacdec->sinkpad, GST_DEBUG_FUNCPTR (gst_flac_dec_sink_activate)); gst_pad_set_activatepull_function (flacdec->sinkpad, GST_DEBUG_FUNCPTR (gst_flac_dec_sink_activate_pull)); gst_pad_set_activatepush_function (flacdec->sinkpad, GST_DEBUG_FUNCPTR (gst_flac_dec_sink_activate_push)); gst_pad_set_query_type_function (flacdec->sinkpad, GST_DEBUG_FUNCPTR (gst_flac_dec_get_sink_query_types)); gst_pad_set_query_function (flacdec->sinkpad, GST_DEBUG_FUNCPTR (gst_flac_dec_sink_query)); gst_pad_set_event_function (flacdec->sinkpad, GST_DEBUG_FUNCPTR (gst_flac_dec_sink_event)); gst_pad_set_chain_function (flacdec->sinkpad, GST_DEBUG_FUNCPTR (gst_flac_dec_chain)); gst_element_add_pad (GST_ELEMENT (flacdec), flacdec->sinkpad); flacdec->srcpad = gst_pad_new_from_template (src_template, "src"); gst_pad_set_query_type_function (flacdec->srcpad, GST_DEBUG_FUNCPTR (gst_flac_dec_get_src_query_types)); gst_pad_set_query_function (flacdec->srcpad, GST_DEBUG_FUNCPTR (gst_flac_dec_src_query)); gst_pad_set_event_function (flacdec->srcpad, GST_DEBUG_FUNCPTR (gst_flac_dec_src_event)); gst_pad_use_fixed_caps (flacdec->srcpad); gst_element_add_pad (GST_ELEMENT (flacdec), flacdec->srcpad); gst_flac_dec_reset_decoders (flacdec); } static void gst_flac_dec_reset_decoders (GstFlacDec * flacdec) { if (flacdec->seekable_decoder) { #ifdef LEGACY_FLAC FLAC__seekable_stream_decoder_delete (flacdec->seekable_decoder); #else FLAC__stream_decoder_delete (flacdec->seekable_decoder); #endif flacdec->seekable_decoder = NULL; } /* Clean up the stream_decoder */ if (flacdec->stream_decoder) { FLAC__stream_decoder_delete (flacdec->stream_decoder); flacdec->stream_decoder = NULL; } if (flacdec->adapter) { gst_adapter_clear (flacdec->adapter); g_object_unref (flacdec->adapter); flacdec->adapter = NULL; } if (flacdec->close_segment) { gst_event_unref (flacdec->close_segment); flacdec->close_segment = NULL; } if (flacdec->start_segment) { gst_event_unref (flacdec->start_segment); flacdec->start_segment = NULL; } if (flacdec->tags) { gst_tag_list_free (flacdec->tags); flacdec->tags = NULL; } flacdec->segment.last_stop = 0; flacdec->offset = 0; flacdec->init = TRUE; } static void gst_flac_dec_setup_seekable_decoder (GstFlacDec * dec) { gst_flac_dec_reset_decoders (dec); #ifdef LEGACY_FLAC dec->seekable_decoder = FLAC__seekable_stream_decoder_new (); FLAC__seekable_stream_decoder_set_read_callback (dec->seekable_decoder, gst_flac_dec_read_seekable); FLAC__seekable_stream_decoder_set_seek_callback (dec->seekable_decoder, gst_flac_dec_seek); FLAC__seekable_stream_decoder_set_tell_callback (dec->seekable_decoder, gst_flac_dec_tell); FLAC__seekable_stream_decoder_set_length_callback (dec->seekable_decoder, gst_flac_dec_length); FLAC__seekable_stream_decoder_set_eof_callback (dec->seekable_decoder, gst_flac_dec_eof); FLAC__seekable_stream_decoder_set_write_callback (dec->seekable_decoder, gst_flac_dec_write_seekable); FLAC__seekable_stream_decoder_set_metadata_respond (dec->seekable_decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); FLAC__seekable_stream_decoder_set_metadata_callback (dec->seekable_decoder, gst_flac_dec_metadata_callback_seekable); FLAC__seekable_stream_decoder_set_error_callback (dec->seekable_decoder, gst_flac_dec_error_callback_seekable); FLAC__seekable_stream_decoder_set_client_data (dec->seekable_decoder, dec); #else dec->seekable_decoder = FLAC__stream_decoder_new (); FLAC__stream_decoder_set_metadata_respond (dec->seekable_decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); FLAC__stream_decoder_set_metadata_respond (dec->seekable_decoder, FLAC__METADATA_TYPE_PICTURE); FLAC__stream_decoder_set_md5_checking (dec->seekable_decoder, false); /* no point calculating since it's never checked here */ #endif } static void gst_flac_dec_setup_stream_decoder (GstFlacDec * dec) { gst_flac_dec_reset_decoders (dec); dec->adapter = gst_adapter_new (); dec->stream_decoder = FLAC__stream_decoder_new (); #ifdef LEGACY_FLAC FLAC__stream_decoder_set_read_callback (dec->stream_decoder, gst_flac_dec_read_stream); FLAC__stream_decoder_set_write_callback (dec->stream_decoder, gst_flac_dec_write_stream); FLAC__stream_decoder_set_metadata_respond (dec->stream_decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); FLAC__stream_decoder_set_metadata_callback (dec->stream_decoder, gst_flac_dec_metadata_callback_stream); FLAC__stream_decoder_set_error_callback (dec->stream_decoder, gst_flac_dec_error_callback_stream); FLAC__stream_decoder_set_client_data (dec->stream_decoder, dec); #else FLAC__stream_decoder_set_md5_checking (dec->stream_decoder, false); /* no point calculating since it's never checked here */ FLAC__stream_decoder_set_metadata_respond (dec->stream_decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); FLAC__stream_decoder_set_metadata_respond (dec->stream_decoder, FLAC__METADATA_TYPE_PICTURE); #endif } static void gst_flac_dec_finalize (GObject * object) { GstFlacDec *flacdec; flacdec = GST_FLAC_DEC (object); gst_flac_dec_reset_decoders (flacdec); G_OBJECT_CLASS (parent_class)->finalize (object); } static gboolean gst_flac_dec_update_metadata (GstFlacDec * flacdec, const FLAC__StreamMetadata * metadata) { GstTagList *list; guint num, i; list = gst_tag_list_new (); num = metadata->data.vorbis_comment.num_comments; GST_DEBUG ("%u tag(s) found", num); for (i = 0; i < num; ++i) { gchar *vc, *name, *value; vc = g_strndup ((gchar *) metadata->data.vorbis_comment.comments[i].entry, metadata->data.vorbis_comment.comments[i].length); if (gst_tag_parse_extended_comment (vc, &name, NULL, &value, TRUE)) { GST_DEBUG ("%s : %s", name, value); gst_vorbis_tag_add (list, name, value); g_free (name); g_free (value); } g_free (vc); } gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, GST_TAG_AUDIO_CODEC, "FLAC", NULL); if (flacdec->tags) gst_tag_list_free (flacdec->tags); flacdec->tags = list; return TRUE; } /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */ static const guint8 crc8_table[256] = { 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D, 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D, 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD, 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD, 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA, 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A, 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A, 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A, 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4, 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4, 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44, 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34, 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63, 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13, 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83, 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3 }; static guint8 gst_flac_calculate_crc8 (guint8 * data, guint length) { guint8 crc = 0; while (length--) { crc = crc8_table[crc ^ *data]; ++data; } return crc; } static gboolean gst_flac_dec_scan_got_frame (GstFlacDec * flacdec, guint8 * data, guint size, gint64 * last_sample_num) { guint headerlen; guint sr_from_end = 0; /* can be 0, 8 or 16 */ guint bs_from_end = 0; /* can be 0, 8 or 16 */ guint32 val = 0; guint8 bs, sr, ca, ss, pb; if (size < 10) return FALSE; /* sync */ if (data[0] != 0xFF || data[1] != 0xF8) return FALSE; bs = (data[2] & 0xF0) >> 8; /* blocksize marker */ sr = (data[2] & 0x0F); /* samplerate marker */ ca = (data[3] & 0xF0) >> 8; /* channel assignment */ ss = (data[3] & 0x0F) >> 1; /* sample size marker */ pb = (data[3] & 0x01); /* padding bit */ GST_LOG ("got sync, bs=%x,sr=%x,ca=%x,ss=%x,pb=%x", bs, sr, ca, ss, pb); if (sr == 0x0F || sr == 0x01 || sr == 0x02 || sr == 0x03 || ca >= 0x0B || ss == 0x03 || ss == 0x07) { return FALSE; } /* read block size from end of header? */ if (bs == 6) bs_from_end = 8; else if (bs == 7) bs_from_end = 16; /* read sample rate from end of header? */ if (sr == 0x0C) sr_from_end = 8; else if (sr == 0x0D || sr == 0x0E) sr_from_end = 16; val = (guint32) g_utf8_get_char_validated ((gchar *) data + 4, -1); if (val == (guint32) - 1 || val == (guint32) - 2) { GST_LOG_OBJECT (flacdec, "failed to read sample/frame"); return FALSE; } headerlen = 4 + g_unichar_to_utf8 ((gunichar) val, NULL) + (bs_from_end / 8) + (sr_from_end / 8); if (gst_flac_calculate_crc8 (data, headerlen) != data[headerlen]) return FALSE; if (flacdec->min_blocksize == flacdec->max_blocksize) { *last_sample_num = (val + 1) * flacdec->min_blocksize; } else { *last_sample_num = val; /* FIXME: + length of last block in samples */ } if (flacdec->sample_rate > 0) { GST_DEBUG_OBJECT (flacdec, "last sample %" G_GINT64_FORMAT " = %" GST_TIME_FORMAT, *last_sample_num, GST_TIME_ARGS (*last_sample_num * GST_SECOND / flacdec->sample_rate)); } return TRUE; } #define SCANBLOCK_SIZE (64*1024) static void gst_flac_dec_scan_for_last_block (GstFlacDec * flacdec, gint64 * samples) { GstFormat format = GST_FORMAT_BYTES; gint64 file_size, offset; GST_INFO_OBJECT (flacdec, "total number of samples unknown, scanning file"); if (!gst_pad_query_peer_duration (flacdec->sinkpad, &format, &file_size)) { GST_WARNING_OBJECT (flacdec, "failed to query upstream size!"); return; } GST_DEBUG_OBJECT (flacdec, "upstream size: %" G_GINT64_FORMAT, file_size); offset = file_size - 1; while (offset >= MAX (SCANBLOCK_SIZE / 2, file_size / 2)) { GstFlowReturn flow; GstBuffer *buf = NULL; guint8 *data; guint size; /* divide by 2 = not very sophisticated way to deal with overlapping */ offset -= SCANBLOCK_SIZE / 2; GST_LOG_OBJECT (flacdec, "looking for frame at %" G_GINT64_FORMAT "-%" G_GINT64_FORMAT, offset, offset + SCANBLOCK_SIZE); flow = gst_pad_pull_range (flacdec->sinkpad, offset, SCANBLOCK_SIZE, &buf); if (flow != GST_FLOW_OK) { GST_DEBUG_OBJECT (flacdec, "flow = %s", gst_flow_get_name (flow)); return; } size = GST_BUFFER_SIZE (buf); data = GST_BUFFER_DATA (buf); while (size > 16) { if (gst_flac_dec_scan_got_frame (flacdec, data, size, samples)) { GST_DEBUG_OBJECT (flacdec, "frame sync at offset %" G_GINT64_FORMAT, offset + GST_BUFFER_SIZE (buf) - size); gst_buffer_unref (buf); return; } ++data; --size; } gst_buffer_unref (buf); } } /* FIXME: remove ifndef once we depend on flac >= 1.2.x */ #ifndef LEGACY_FLAC static gchar * gst_flac_normalize_picture_mime_type (const gchar * old_mime_type, gboolean * is_pic_uri) { gchar *mime_str; g_return_val_if_fail (old_mime_type != NULL, NULL); /* Make lower-case */ mime_str = g_ascii_strdown (old_mime_type, -1); /* Fix up 'jpg' => 'jpeg' in mime/media type */ if (g_ascii_strcasecmp (mime_str, "jpg") == 0 || g_ascii_strcasecmp (mime_str, "image/jpg") == 0) { g_free (mime_str); mime_str = g_strdup ("image/jpeg"); } /* Check if the picture is a URI reference */ *is_pic_uri = (strcmp (mime_str, "-->") == 0); if (!(*is_pic_uri) && *mime_str && strchr (mime_str, '/') == NULL) { gchar *tmp = g_strdup_printf ("image/%s", mime_str); g_free (mime_str); mime_str = tmp; } return mime_str; } static void gst_flac_extract_picture_buffer (GstFlacDec * flacdec, const FLAC__StreamMetadata * metadata) { /* Most of this is copied from gst/id3demux/id3v2frames.c */ gchar *mime_type; GstBuffer *image; GstCaps *image_caps; FLAC__StreamMetadata_Picture picture; gboolean is_pic_uri; g_return_if_fail (metadata->type == FLAC__METADATA_TYPE_PICTURE); GST_LOG ("Got PICTURE block"); picture = metadata->data.picture; is_pic_uri = FALSE; mime_type = gst_flac_normalize_picture_mime_type (picture.mime_type, &is_pic_uri); GST_DEBUG ("PICTURE MIME-type is: \"%s\"", mime_type); GST_DEBUG ("image data is %u bytes", picture.data_length); if (is_pic_uri) { gchar *uri; uri = g_strndup ((gchar *) picture.data, picture.data_length); GST_DEBUG ("image URI: %s", uri); image = gst_buffer_new (); GST_BUFFER_MALLOCDATA (image) = (guint8 *) uri; /* take ownership */ GST_BUFFER_DATA (image) = (guint8 *) uri; GST_BUFFER_SIZE (image) = picture.data_length; image_caps = gst_caps_new_simple ("text/uri-list", NULL); } else { image = gst_buffer_new_and_alloc (picture.data_length); memcpy (GST_BUFFER_DATA (image), picture.data, picture.data_length); /* if possible use GStreamer media type rather than declared type */ image_caps = gst_type_find_helper_for_buffer (NULL, image, NULL); if (image_caps) { GST_DEBUG ("Found GStreamer media type: %" GST_PTR_FORMAT, image_caps); } else if (mime_type && *mime_type) { GST_DEBUG ("No GStreamer media type found, using declared type: \"%s\"", mime_type); image_caps = gst_caps_new_simple (mime_type, NULL); } else { GST_DEBUG ("Empty declared mime type, ignoring image frame"); image = NULL; image_caps = NULL; } } g_free (mime_type); if (image && image_caps) { GstTagList *tags = gst_tag_list_new (); if (picture.type == 1 || picture.type == 2) { /* file icon for preview. Don't add image-type to caps, since it only * makes sense for there to be one of these. */ gst_buffer_set_caps (image, image_caps); gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, GST_TAG_PREVIEW_IMAGE, image, NULL); } else { GstTagImageType gst_tag_pic_type = GST_TAG_IMAGE_TYPE_UNDEFINED; if (picture.type >= 0x03 && picture.type <= 0x14) gst_tag_pic_type = (GstTagImageType) ((gint) (picture.type) - 2); gst_structure_set (gst_caps_get_structure (image_caps, 0), "image-type", GST_TYPE_TAG_IMAGE_TYPE, gst_tag_pic_type, NULL); gst_buffer_set_caps (image, image_caps); gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, GST_TAG_IMAGE, image, NULL); } gst_caps_unref (image_caps); gst_buffer_unref (image); /* Announce discovered tags */ gst_element_found_tags_for_pad (GST_ELEMENT (flacdec), flacdec->srcpad, tags); } else { if (image) gst_buffer_unref (image); GST_DEBUG ("problem parsing PICTURE block, skipping"); } } #endif /* LEGACY_FLAC */ static void gst_flac_dec_metadata_callback (GstFlacDec * flacdec, const FLAC__StreamMetadata * metadata) { switch (metadata->type) { case FLAC__METADATA_TYPE_STREAMINFO:{ gint64 samples; samples = metadata->data.stream_info.total_samples; flacdec->min_blocksize = metadata->data.stream_info.min_blocksize; flacdec->max_blocksize = metadata->data.stream_info.max_blocksize; flacdec->sample_rate = metadata->data.stream_info.sample_rate; GST_DEBUG_OBJECT (flacdec, "blocksize: min=%u, max=%u", flacdec->min_blocksize, flacdec->max_blocksize); /* Only scan for last block in pull-mode, since it uses pull_range() */ if (samples == 0 && flacdec->seekable_decoder) { gst_flac_dec_scan_for_last_block (flacdec, &samples); } GST_DEBUG_OBJECT (flacdec, "total samples = %" G_GINT64_FORMAT, samples); if (samples > 0) { gint64 duration; gst_segment_set_duration (&flacdec->segment, GST_FORMAT_DEFAULT, samples); /* convert duration to time */ duration = gst_util_uint64_scale_int (samples, GST_SECOND, flacdec->sample_rate); /* fixme, at this time we could seek to the queued seek event if we have * any */ if (flacdec->start_segment) gst_event_unref (flacdec->start_segment); flacdec->start_segment = gst_event_new_new_segment_full (FALSE, flacdec->segment.rate, flacdec->segment.applied_rate, GST_FORMAT_TIME, 0, duration, 0); } break; } /* FIXME: remove ifndef once we depend on flac >= 1.2.x */ #ifndef LEGACY_FLAC case FLAC__METADATA_TYPE_PICTURE:{ gst_flac_extract_picture_buffer (flacdec, metadata); break; } #endif case FLAC__METADATA_TYPE_VORBIS_COMMENT: gst_flac_dec_update_metadata (flacdec, metadata); break; default: break; } } #ifdef LEGACY_FLAC static void gst_flac_dec_metadata_callback_seekable (const FLAC__SeekableStreamDecoder * d, const FLAC__StreamMetadata * metadata, void *client_data) { GstFlacDec *dec = GST_FLAC_DEC (client_data); gst_flac_dec_metadata_callback (dec, metadata); } #endif static void gst_flac_dec_metadata_callback_stream (const FLAC__StreamDecoder * decoder, const FLAC__StreamMetadata * metadata, void *client_data) { GstFlacDec *dec = GST_FLAC_DEC (client_data); gst_flac_dec_metadata_callback (dec, metadata); } static void gst_flac_dec_error_callback (GstFlacDec * dec, FLAC__StreamDecoderErrorStatus status) { const gchar *error; switch (status) { case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC: /* Ignore this error and keep processing */ return; case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER: error = "bad header"; break; case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH: error = "CRC mismatch"; break; default: error = "unknown error"; break; } GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), ("%s (%d)", error, status)); dec->last_flow = GST_FLOW_ERROR; } #ifdef LEGACY_FLAC static void gst_flac_dec_error_callback_seekable (const FLAC__SeekableStreamDecoder * d, FLAC__StreamDecoderErrorStatus status, void *client_data) { gst_flac_dec_error_callback (GST_FLAC_DEC (client_data), status); } #endif static void gst_flac_dec_error_callback_stream (const FLAC__StreamDecoder * d, FLAC__StreamDecoderErrorStatus status, void *client_data) { gst_flac_dec_error_callback (GST_FLAC_DEC (client_data), status); } #ifdef LEGACY_FLAC static FLAC__SeekableStreamDecoderSeekStatus gst_flac_dec_seek (const FLAC__SeekableStreamDecoder * decoder, FLAC__uint64 position, void *client_data) #else static FLAC__StreamDecoderSeekStatus gst_flac_dec_seek (const FLAC__StreamDecoder * decoder, FLAC__uint64 position, void *client_data) #endif { GstFlacDec *flacdec; flacdec = GST_FLAC_DEC (client_data); GST_DEBUG ("seek %" G_GINT64_FORMAT, position); flacdec->offset = position; #ifdef LEGACY_FLAC return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK; #else return FLAC__STREAM_DECODER_SEEK_STATUS_OK; #endif } #ifdef LEGACY_FLAC static FLAC__SeekableStreamDecoderTellStatus gst_flac_dec_tell (const FLAC__SeekableStreamDecoder * decoder, FLAC__uint64 * position, void *client_data) #else static FLAC__StreamDecoderTellStatus gst_flac_dec_tell (const FLAC__StreamDecoder * decoder, FLAC__uint64 * position, void *client_data) #endif { GstFlacDec *flacdec; flacdec = GST_FLAC_DEC (client_data); *position = flacdec->offset; GST_DEBUG ("tell %" G_GINT64_FORMAT, *position); #ifdef LEGACY_FLAC return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK; #else return FLAC__STREAM_DECODER_TELL_STATUS_OK; #endif } #ifdef LEGACY_FLAC static FLAC__SeekableStreamDecoderLengthStatus gst_flac_dec_length (const FLAC__SeekableStreamDecoder * decoder, FLAC__uint64 * length, void *client_data) #else static FLAC__StreamDecoderLengthStatus gst_flac_dec_length (const FLAC__StreamDecoder * decoder, FLAC__uint64 * length, void *client_data) #endif { GstFlacDec *flacdec; GstFormat fmt = GST_FORMAT_BYTES; gint64 len; GstPad *peer; flacdec = GST_FLAC_DEC (client_data); if (!(peer = gst_pad_get_peer (flacdec->sinkpad))) #ifdef LEGACY_FLAC return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR; #else return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR; #endif gst_pad_query_duration (peer, &fmt, &len); gst_object_unref (peer); if (fmt != GST_FORMAT_BYTES || len == -1) #ifdef LEGACY_FLAC return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR; #else return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR; #endif *length = len; GST_DEBUG ("length %" G_GINT64_FORMAT, *length); #ifdef LEGACY_FLAC return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK; #else return FLAC__STREAM_DECODER_LENGTH_STATUS_OK; #endif } #ifdef LEGACY_FLAC static FLAC__bool gst_flac_dec_eof (const FLAC__SeekableStreamDecoder * decoder, void *client_data) #else static FLAC__bool gst_flac_dec_eof (const FLAC__StreamDecoder * decoder, void *client_data) #endif { GstFlacDec *flacdec; GstFormat fmt; GstPad *peer; gboolean ret = FALSE; gint64 len; flacdec = GST_FLAC_DEC (client_data); if (!(peer = gst_pad_get_peer (flacdec->sinkpad))) { GST_WARNING_OBJECT (flacdec, "no peer pad, returning EOF"); return TRUE; } fmt = GST_FORMAT_BYTES; if (gst_pad_query_duration (peer, &fmt, &len) && fmt == GST_FORMAT_BYTES && len != -1 && flacdec->offset >= len) { GST_DEBUG ("offset=%" G_GINT64_FORMAT ", len=%" G_GINT64_FORMAT ", returning EOF", flacdec->offset, len); ret = TRUE; } gst_object_unref (peer); return ret; } #ifdef LEGACY_FLAC static FLAC__SeekableStreamDecoderReadStatus gst_flac_dec_read_seekable (const FLAC__SeekableStreamDecoder * decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data) #else static FLAC__StreamDecoderReadStatus gst_flac_dec_read_seekable (const FLAC__StreamDecoder * decoder, FLAC__byte buffer[], size_t * bytes, void *client_data) #endif { GstFlacDec *flacdec; GstBuffer *buf; flacdec = GST_FLAC_DEC (client_data); if (gst_pad_pull_range (flacdec->sinkpad, flacdec->offset, *bytes, &buf) != GST_FLOW_OK) #ifdef LEGACY_FLAC return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR; #else return FLAC__STREAM_DECODER_READ_STATUS_ABORT; #endif GST_DEBUG ("Read %d bytes at %" G_GUINT64_FORMAT, GST_BUFFER_SIZE (buf), flacdec->offset); memcpy (buffer, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf)); *bytes = GST_BUFFER_SIZE (buf); gst_buffer_unref (buf); flacdec->offset += *bytes; #ifdef LEGACY_FLAC return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK; #else return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; #endif } #ifdef LEGACY_FLAC static FLAC__StreamDecoderReadStatus gst_flac_dec_read_stream (const FLAC__StreamDecoder * decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data) #else static FLAC__StreamDecoderReadStatus gst_flac_dec_read_stream (const FLAC__StreamDecoder * decoder, FLAC__byte buffer[], size_t * bytes, void *client_data) #endif { GstFlacDec *dec = GST_FLAC_DEC (client_data); guint len; len = MIN (gst_adapter_available (dec->adapter), *bytes); if (len == 0) { GST_LOG_OBJECT (dec, "0 bytes available at the moment"); return FLAC__STREAM_DECODER_READ_STATUS_ABORT; } GST_LOG_OBJECT (dec, "feeding %u bytes to decoder (available=%u, bytes=%u)", len, gst_adapter_available (dec->adapter), *bytes); memcpy (buffer, gst_adapter_peek (dec->adapter, len), len); *bytes = len; gst_adapter_flush (dec->adapter, len); return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; } static FLAC__StreamDecoderWriteStatus gst_flac_dec_write (GstFlacDec * flacdec, const FLAC__Frame * frame, const FLAC__int32 * const buffer[]) { GstFlowReturn ret = GST_FLOW_OK; GstBuffer *outbuf; guint depth = frame->header.bits_per_sample; guint width; guint channels = frame->header.channels; guint samples = frame->header.blocksize; guint j, i; GstClockTime next; switch (depth) { case 8: width = 8; break; case 12: case 16: width = 16; break; case 20: case 24: case 32: width = 32; break; default: GST_ERROR_OBJECT (flacdec, "unsupported depth %d", depth); ret = GST_FLOW_ERROR; goto done; } if (!GST_PAD_CAPS (flacdec->srcpad)) { GstCaps *caps; GST_DEBUG ("Negotiating %d Hz @ %d channels", frame->header.sample_rate, channels); 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, width, "depth", G_TYPE_INT, depth, "rate", G_TYPE_INT, frame->header.sample_rate, "channels", G_TYPE_INT, channels, NULL); if (channels > 2) { GstStructure *s = gst_caps_get_structure (caps, 0); gst_audio_set_channel_positions (s, channel_positions[channels - 1]); } flacdec->depth = depth; flacdec->width = width; flacdec->channels = channels; flacdec->sample_rate = frame->header.sample_rate; gst_pad_set_caps (flacdec->srcpad, caps); gst_caps_unref (caps); } if (flacdec->close_segment) { gst_pad_push_event (flacdec->srcpad, flacdec->close_segment); flacdec->close_segment = NULL; } if (flacdec->start_segment) { gst_pad_push_event (flacdec->srcpad, flacdec->start_segment); flacdec->start_segment = NULL; } if (flacdec->tags) { gst_element_found_tags_for_pad (GST_ELEMENT (flacdec), flacdec->srcpad, flacdec->tags); flacdec->tags = NULL; } ret = gst_pad_alloc_buffer_and_set_caps (flacdec->srcpad, flacdec->segment.last_stop, samples * channels * (width / 8), GST_PAD_CAPS (flacdec->srcpad), &outbuf); if (ret != GST_FLOW_OK) { GST_DEBUG ("gst_pad_alloc_buffer() returned %s", gst_flow_get_name (ret)); goto done; } if (flacdec->cur_granulepos != GST_BUFFER_OFFSET_NONE) { /* this should be fine since it should be one flac frame per ogg packet */ flacdec->segment.last_stop = flacdec->cur_granulepos - samples; GST_LOG_OBJECT (flacdec, "granulepos = %" G_GINT64_FORMAT ", samples = %u", flacdec->cur_granulepos, samples); } GST_BUFFER_TIMESTAMP (outbuf) = gst_util_uint64_scale_int (flacdec->segment.last_stop, GST_SECOND, frame->header.sample_rate); /* get next timestamp to calculate the duration */ next = gst_util_uint64_scale_int (flacdec->segment.last_stop + samples, GST_SECOND, frame->header.sample_rate); GST_BUFFER_DURATION (outbuf) = next - GST_BUFFER_TIMESTAMP (outbuf); if (depth == 8) { gint8 *outbuffer = (gint8 *) GST_BUFFER_DATA (outbuf); for (i = 0; i < samples; i++) { for (j = 0; j < channels; j++) { *outbuffer++ = (gint8) buffer[j][i]; } } } else if (depth == 12 || depth == 16) { gint16 *outbuffer = (gint16 *) GST_BUFFER_DATA (outbuf); for (i = 0; i < samples; i++) { for (j = 0; j < channels; j++) { *outbuffer++ = (gint16) buffer[j][i]; } } } else if (depth == 20 || depth == 24 || depth == 32) { gint32 *outbuffer = (gint32 *) GST_BUFFER_DATA (outbuf); for (i = 0; i < samples; i++) { for (j = 0; j < channels; j++) { *outbuffer++ = (gint32) buffer[j][i]; } } } else { g_assert_not_reached (); } if (!flacdec->seeking) { GST_DEBUG ("pushing %d samples at offset %" G_GINT64_FORMAT " (%" GST_TIME_FORMAT " + %" GST_TIME_FORMAT ")", samples, GST_BUFFER_OFFSET (outbuf), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)), GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf))); if (flacdec->discont) { outbuf = gst_buffer_make_metadata_writable (outbuf); GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT); flacdec->discont = FALSE; } ret = gst_pad_push (flacdec->srcpad, outbuf); } else { GST_DEBUG ("not pushing %d samples at offset %" G_GINT64_FORMAT " (in seek)", samples, GST_BUFFER_OFFSET (outbuf)); gst_buffer_unref (outbuf); ret = GST_FLOW_OK; } if (ret != GST_FLOW_OK) { GST_DEBUG ("gst_pad_push() returned %s", gst_flow_get_name (ret)); } done: flacdec->segment.last_stop += samples; /* we act on the flow return value later in the loop function, as we don't * want to mess up the internal decoder state by returning ABORT when the * error is in fact non-fatal (like a pad in flushing mode) and we want * to continue later. So just pretend everything's dandy and act later. */ flacdec->last_flow = ret; return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; } #ifdef LEGACY_FLAC static FLAC__StreamDecoderWriteStatus gst_flac_dec_write_seekable (const FLAC__SeekableStreamDecoder * decoder, const FLAC__Frame * frame, const FLAC__int32 * const buffer[], void *client_data) { return gst_flac_dec_write (GST_FLAC_DEC (client_data), frame, buffer); } #endif static FLAC__StreamDecoderWriteStatus gst_flac_dec_write_stream (const FLAC__StreamDecoder * decoder, const FLAC__Frame * frame, const FLAC__int32 * const buffer[], void *client_data) { return gst_flac_dec_write (GST_FLAC_DEC (client_data), frame, buffer); } static void gst_flac_dec_loop (GstPad * sinkpad) { GstFlacDec *flacdec; #ifdef LEGACY_FLAC FLAC__SeekableStreamDecoderState s; #else FLAC__StreamDecoderState s; FLAC__StreamDecoderInitStatus is; #endif flacdec = GST_FLAC_DEC (GST_OBJECT_PARENT (sinkpad)); GST_LOG_OBJECT (flacdec, "entering loop"); if (flacdec->init) { GST_DEBUG_OBJECT (flacdec, "initializing decoder"); #ifdef LEGACY_FLAC s = FLAC__seekable_stream_decoder_init (flacdec->seekable_decoder); if (s != FLAC__SEEKABLE_STREAM_DECODER_OK) goto analyze_state; #else is = FLAC__stream_decoder_init_stream (flacdec->seekable_decoder, gst_flac_dec_read_seekable, gst_flac_dec_seek, gst_flac_dec_tell, gst_flac_dec_length, gst_flac_dec_eof, gst_flac_dec_write_stream, gst_flac_dec_metadata_callback_stream, gst_flac_dec_error_callback_stream, flacdec); if (is != FLAC__STREAM_DECODER_INIT_STATUS_OK) goto analyze_state; #endif /* FLAC__seekable_stream_decoder_process_metadata (flacdec->seekable_decoder); */ flacdec->init = FALSE; } flacdec->cur_granulepos = GST_BUFFER_OFFSET_NONE; flacdec->last_flow = GST_FLOW_OK; GST_LOG_OBJECT (flacdec, "processing single"); #ifdef LEGACY_FLAC FLAC__seekable_stream_decoder_process_single (flacdec->seekable_decoder); #else FLAC__stream_decoder_process_single (flacdec->seekable_decoder); #endif analyze_state: GST_LOG_OBJECT (flacdec, "done processing, checking encoder state"); #ifdef LEGACY_FLAC s = FLAC__seekable_stream_decoder_get_state (flacdec->seekable_decoder); #else s = FLAC__stream_decoder_get_state (flacdec->seekable_decoder); #endif switch (s) { #ifdef LEGACY_FLAC case FLAC__SEEKABLE_STREAM_DECODER_OK: case FLAC__SEEKABLE_STREAM_DECODER_SEEKING: #else case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA: case FLAC__STREAM_DECODER_READ_METADATA: case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC: case FLAC__STREAM_DECODER_READ_FRAME: #endif { GST_DEBUG_OBJECT (flacdec, "everything ok"); if (GST_FLOW_IS_FATAL (flacdec->last_flow) || flacdec->last_flow == GST_FLOW_NOT_LINKED) { GST_ELEMENT_ERROR (flacdec, STREAM, FAILED, (_("Internal data stream error.")), ("stream stopped, reason %s", gst_flow_get_name (flacdec->last_flow))); goto eos_and_pause; } else if (flacdec->last_flow != GST_FLOW_OK) { goto pause; } /* check if we're at the end of a configured segment */ if (flacdec->segment.stop != -1 && flacdec->segment.last_stop > 0 && flacdec->segment.last_stop >= flacdec->segment.stop) { GST_DEBUG_OBJECT (flacdec, "reached end of the configured segment"); if ((flacdec->segment.flags & GST_SEEK_FLAG_SEGMENT) == 0) { goto eos_and_pause; } else { goto segment_done_and_pause; } g_assert_not_reached (); } return; } #ifdef LEGACY_FLAC case FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM:{ #else case FLAC__STREAM_DECODER_END_OF_STREAM:{ #endif GST_DEBUG_OBJECT (flacdec, "EOS"); #ifdef LEGACY_FLAC FLAC__seekable_stream_decoder_reset (flacdec->seekable_decoder); #else FLAC__stream_decoder_reset (flacdec->seekable_decoder); #endif if ((flacdec->segment.flags & GST_SEEK_FLAG_SEGMENT) != 0) { if (flacdec->segment.duration > 0) { flacdec->segment.stop = flacdec->segment.duration; } else { flacdec->segment.stop = flacdec->segment.last_stop; } goto segment_done_and_pause; } goto eos_and_pause; } #ifdef LEGACY_FLAC case FLAC__SEEKABLE_STREAM_DECODER_MEMORY_ALLOCATION_ERROR: case FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR: case FLAC__SEEKABLE_STREAM_DECODER_READ_ERROR: case FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR: case FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED: case FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK: case FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED: #else case FLAC__STREAM_DECODER_OGG_ERROR: case FLAC__STREAM_DECODER_SEEK_ERROR: case FLAC__STREAM_DECODER_ABORTED: case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR: case FLAC__STREAM_DECODER_UNINITIALIZED: #endif default:{ /* fixme: this error sucks -- should try to figure out when/if an more specific error was already sent via the callback */ #ifdef LEGACY_FLAC GST_ELEMENT_ERROR (flacdec, STREAM, DECODE, (NULL), ("%s", FLAC__SeekableStreamDecoderStateString[s])); #else GST_ELEMENT_ERROR (flacdec, STREAM, DECODE, (NULL), ("%s", FLAC__StreamDecoderStateString[s])); #endif goto eos_and_pause; } } return; segment_done_and_pause: { gint64 stop_time; stop_time = gst_util_uint64_scale_int (flacdec->segment.stop, GST_SECOND, flacdec->sample_rate); GST_DEBUG_OBJECT (flacdec, "posting SEGMENT_DONE message, stop time %" GST_TIME_FORMAT, GST_TIME_ARGS (stop_time)); gst_element_post_message (GST_ELEMENT (flacdec), gst_message_new_segment_done (GST_OBJECT (flacdec), GST_FORMAT_TIME, stop_time)); goto pause; } eos_and_pause: { GST_DEBUG_OBJECT (flacdec, "sending EOS event"); flacdec->running = FALSE; gst_pad_push_event (flacdec->srcpad, gst_event_new_eos ()); /* fall through to pause */ } pause: { GST_DEBUG_OBJECT (flacdec, "pausing"); gst_pad_pause_task (sinkpad); return; } } static gboolean gst_flac_dec_sink_event (GstPad * pad, GstEvent * event) { GstFlacDec *dec; gboolean res; dec = GST_FLAC_DEC (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP:{ if (dec->stream_decoder) { FLAC__stream_decoder_flush (dec->stream_decoder); gst_adapter_clear (dec->adapter); } res = gst_pad_push_event (dec->srcpad, event); break; } case GST_EVENT_NEWSEGMENT:{ GstFormat fmt; gboolean update; gdouble rate, applied_rate; gint64 cur, stop, time; gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate, &fmt, &cur, &stop, &time); if (fmt == GST_FORMAT_TIME) { GstFormat dformat = GST_FORMAT_DEFAULT; GST_DEBUG_OBJECT (dec, "newsegment event in TIME format => framed"); dec->framed = TRUE; res = gst_pad_push_event (dec->srcpad, event); /* this won't work for the first newsegment event though ... */ if (gst_flac_dec_convert_src (dec->srcpad, GST_FORMAT_TIME, cur, &dformat, &cur) && cur != -1 && gst_flac_dec_convert_src (dec->srcpad, GST_FORMAT_TIME, stop, &dformat, &stop) && stop != -1) { gst_segment_set_newsegment_full (&dec->segment, update, rate, applied_rate, dformat, cur, stop, time); GST_DEBUG_OBJECT (dec, "segment %" GST_SEGMENT_FORMAT, &dec->segment); } else { GST_WARNING_OBJECT (dec, "couldn't convert time => samples"); } } else if (fmt == GST_FORMAT_BYTES || TRUE) { GST_DEBUG_OBJECT (dec, "newsegment event in %s format => not framed", gst_format_get_name (fmt)); dec->framed = FALSE; gst_event_unref (event); res = TRUE; } break; } case GST_EVENT_EOS:{ GST_LOG_OBJECT (dec, "EOS, with %u bytes available in adapter", gst_adapter_available (dec->adapter)); if (gst_adapter_available (dec->adapter) > 0) { FLAC__stream_decoder_process_until_end_of_stream (dec->stream_decoder); } FLAC__stream_decoder_flush (dec->stream_decoder); gst_adapter_clear (dec->adapter); res = gst_pad_push_event (dec->srcpad, event); break; } default: res = gst_pad_event_default (pad, event); break; } gst_object_unref (dec); return res; } static GstFlowReturn gst_flac_dec_chain (GstPad * pad, GstBuffer * buf) { #ifdef LEGACY_FLAC FLAC__StreamDecoderState s; #else FLAC__StreamDecoderInitStatus s; #endif GstFlacDec *dec; gboolean got_audio_frame; dec = GST_FLAC_DEC (GST_PAD_PARENT (pad)); GST_LOG_OBJECT (dec, "buffer with ts=%" GST_TIME_FORMAT ", end_offset=%" G_GINT64_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)), GST_BUFFER_OFFSET_END (buf)); if (dec->init) { GST_DEBUG_OBJECT (dec, "initializing decoder"); #ifdef LEGACY_FLAC s = FLAC__stream_decoder_init (dec->stream_decoder); if (s != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA) { GST_ELEMENT_ERROR (GST_ELEMENT (dec), LIBRARY, INIT, (NULL), (NULL)); return GST_FLOW_ERROR; } #else s = FLAC__stream_decoder_init_stream (dec->stream_decoder, gst_flac_dec_read_stream, NULL, NULL, NULL, NULL, gst_flac_dec_write_stream, gst_flac_dec_metadata_callback_stream, gst_flac_dec_error_callback_stream, dec); if (s != FLAC__STREAM_DECODER_INIT_STATUS_OK) { GST_ELEMENT_ERROR (GST_ELEMENT (dec), LIBRARY, INIT, (NULL), (NULL)); return GST_FLOW_ERROR; } #endif GST_DEBUG_OBJECT (dec, "initialized (framed=%d)", dec->framed); dec->init = FALSE; } if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DISCONT)) { /* Clear the adapter and the decoder */ gst_adapter_clear (dec->adapter); FLAC__stream_decoder_flush (dec->stream_decoder); } if (dec->framed) { gint64 unused; /* check if this is a flac audio frame (rather than a header or junk) */ got_audio_frame = gst_flac_dec_scan_got_frame (dec, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf), &unused); /* oggdemux will set granulepos in OFFSET_END instead of timestamp */ if (got_audio_frame && !GST_BUFFER_TIMESTAMP_IS_VALID (buf)) { dec->cur_granulepos = GST_BUFFER_OFFSET_END (buf); } } else { dec->cur_granulepos = GST_BUFFER_OFFSET_NONE; got_audio_frame = TRUE; } gst_adapter_push (dec->adapter, buf); buf = NULL; dec->last_flow = GST_FLOW_OK; if (!dec->framed) { /* wait until we have at least 64kB because libflac's StreamDecoder * interface is a bit dumb it seems (if we don't have as much data as * it wants it will call our read callback repeatedly and the only * way to stop that is to error out or EOS, which will affect the * decoder state). And the decoder seems to always ask for MAX_BLOCK_SIZE * bytes rather than the max. block size from the header). Requiring * MAX_BLOCK_SIZE bytes here should make sure it always gets enough data * to decode at least one block */ while (gst_adapter_available (dec->adapter) >= FLAC__MAX_BLOCK_SIZE && dec->last_flow == GST_FLOW_OK) { GST_LOG_OBJECT (dec, "%u bytes available", gst_adapter_available (dec->adapter)); if (!FLAC__stream_decoder_process_single (dec->stream_decoder)) { GST_DEBUG_OBJECT (dec, "process_single failed"); break; } } } else if (dec->framed && got_audio_frame) { /* framed - there should always be enough data to decode something */ GST_LOG_OBJECT (dec, "%u bytes available", gst_adapter_available (dec->adapter)); if (!FLAC__stream_decoder_process_single (dec->stream_decoder)) { GST_DEBUG_OBJECT (dec, "process_single failed"); } } else { GST_DEBUG_OBJECT (dec, "don't have all headers yet"); } return dec->last_flow; } static gboolean gst_flac_dec_convert_sink (GstFlacDec * dec, GstFormat src_format, gint64 src_value, GstFormat * dest_format, gint64 * dest_value) { gboolean res = TRUE; if (dec->width == 0 || dec->channels == 0 || dec->sample_rate == 0) { /* no frame decoded yet */ GST_DEBUG_OBJECT (dec, "cannot convert: not set up yet"); return FALSE; } switch (src_format) { case GST_FORMAT_BYTES:{ res = FALSE; break; } case GST_FORMAT_DEFAULT: switch (*dest_format) { case GST_FORMAT_BYTES: res = FALSE; break; case GST_FORMAT_TIME: /* granulepos = sample */ *dest_value = gst_util_uint64_scale_int (src_value, GST_SECOND, dec->sample_rate); break; default: res = FALSE; break; } break; case GST_FORMAT_TIME: switch (*dest_format) { case GST_FORMAT_BYTES: res = FALSE; break; case GST_FORMAT_DEFAULT: *dest_value = gst_util_uint64_scale_int (src_value, dec->sample_rate, GST_SECOND); break; default: res = FALSE; break; } break; default: res = FALSE; break; } return res; } static const GstQueryType * gst_flac_dec_get_sink_query_types (GstPad * pad) { static const GstQueryType types[] = { GST_QUERY_CONVERT, 0, }; return types; } static gboolean gst_flac_dec_sink_query (GstPad * pad, GstQuery * query) { GstFlacDec *dec; gboolean res = FALSE; dec = GST_FLAC_DEC (gst_pad_get_parent (pad)); GST_LOG_OBJECT (dec, "%s query", GST_QUERY_TYPE_NAME (query)); switch (GST_QUERY_TYPE (query)) { 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, NULL); res = gst_flac_dec_convert_sink (dec, src_fmt, src_val, &dest_fmt, &dest_val); if (res) { gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); } GST_LOG_OBJECT (dec, "conversion %s", (res) ? "ok" : "FAILED"); break; } default:{ res = gst_pad_query_default (pad, query); break; } } gst_object_unref (dec); return res; } static gboolean gst_flac_dec_convert_src (GstPad * pad, GstFormat src_format, gint64 src_value, GstFormat * dest_format, gint64 * dest_value) { GstFlacDec *flacdec = GST_FLAC_DEC (GST_PAD_PARENT (pad)); gboolean res = TRUE; guint bytes_per_sample; guint scale = 1; if (flacdec->width == 0 || flacdec->channels == 0 || flacdec->sample_rate == 0) { /* no frame decoded yet */ GST_DEBUG_OBJECT (flacdec, "cannot convert: not set up yet"); return FALSE; } bytes_per_sample = flacdec->channels * (flacdec->width / 8); switch (src_format) { case GST_FORMAT_BYTES:{ switch (*dest_format) { case GST_FORMAT_DEFAULT: *dest_value = gst_util_uint64_scale_int (src_value, 1, bytes_per_sample); break; case GST_FORMAT_TIME: { gint byterate = bytes_per_sample * flacdec->sample_rate; *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: *dest_value = gst_util_uint64_scale_int (src_value, GST_SECOND, flacdec->sample_rate); break; default: res = FALSE; } break; case GST_FORMAT_TIME: switch (*dest_format) { case GST_FORMAT_BYTES: scale = bytes_per_sample; case GST_FORMAT_DEFAULT: *dest_value = gst_util_uint64_scale_int (src_value, scale * flacdec->sample_rate, GST_SECOND); break; default: res = FALSE; } break; default: res = FALSE; } return res; } static const GstQueryType * gst_flac_dec_get_src_query_types (GstPad * pad) { static const GstQueryType types[] = { GST_QUERY_POSITION, GST_QUERY_DURATION, GST_QUERY_CONVERT, 0, }; return types; } static gboolean gst_flac_dec_src_query (GstPad * pad, GstQuery * query) { GstFlacDec *flacdec; gboolean res = TRUE; GstPad *peer; flacdec = GST_FLAC_DEC (gst_pad_get_parent (pad)); peer = gst_pad_get_peer (flacdec->sinkpad); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION:{ GstFormat fmt; gint64 pos; gst_query_parse_position (query, &fmt, NULL); /* there might be a demuxer in front of us who can handle this */ if (fmt == GST_FORMAT_TIME && (res = gst_pad_query (peer, query))) break; if (fmt != GST_FORMAT_DEFAULT) { if (!gst_flac_dec_convert_src (flacdec->srcpad, GST_FORMAT_DEFAULT, flacdec->segment.last_stop, &fmt, &pos)) { GST_DEBUG_OBJECT (flacdec, "failed to convert position into %s " "format", gst_format_get_name (fmt)); res = FALSE; goto done; } } else { pos = flacdec->segment.last_stop; } gst_query_set_position (query, fmt, pos); GST_DEBUG_OBJECT (flacdec, "returning position %" G_GUINT64_FORMAT " (format: %s)", pos, gst_format_get_name (fmt)); res = TRUE; break; } case GST_QUERY_DURATION:{ GstFormat fmt; gint64 len; gst_query_parse_duration (query, &fmt, NULL); /* try any demuxers before us first */ if (fmt == GST_FORMAT_TIME && peer && gst_pad_query (peer, query)) { gst_query_parse_duration (query, NULL, &len); GST_DEBUG_OBJECT (flacdec, "peer returned duration %" GST_TIME_FORMAT, GST_TIME_ARGS (len)); res = TRUE; goto done; } if (flacdec->segment.duration == 0 || flacdec->segment.duration == -1) { GST_DEBUG_OBJECT (flacdec, "duration not known yet"); res = FALSE; goto done; } /* convert total number of samples to request format */ if (fmt != GST_FORMAT_DEFAULT) { if (!gst_flac_dec_convert_src (flacdec->srcpad, GST_FORMAT_DEFAULT, flacdec->segment.duration, &fmt, &len)) { GST_DEBUG_OBJECT (flacdec, "failed to convert duration into %s " "format", gst_format_get_name (fmt)); res = FALSE; goto done; } } else { len = flacdec->segment.duration; } gst_query_set_duration (query, fmt, len); GST_DEBUG_OBJECT (flacdec, "returning duration %" G_GUINT64_FORMAT " (format: %s)", len, gst_format_get_name (fmt)); res = TRUE; 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, NULL); res = gst_flac_dec_convert_src (pad, src_fmt, src_val, &dest_fmt, &dest_val); if (res) { gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); } break; } default:{ res = gst_pad_query_default (pad, query); break; } } done: if (peer) gst_object_unref (peer); gst_object_unref (flacdec); return res; } static gboolean gst_flac_dec_handle_seek_event (GstFlacDec * flacdec, GstEvent * event) { FLAC__bool seek_ok; GstSeekFlags seek_flags; GstSeekType start_type; GstSeekType stop_type; GstSegment segment; GstFormat seek_format; gboolean only_update = FALSE; gboolean flush; gdouble rate; gint64 start, last_stop; gint64 stop; if (flacdec->seekable_decoder == NULL) { GST_DEBUG_OBJECT (flacdec, "seeking in streaming mode not implemented yet"); return FALSE; } gst_event_parse_seek (event, &rate, &seek_format, &seek_flags, &start_type, &start, &stop_type, &stop); if (seek_format != GST_FORMAT_DEFAULT && seek_format != GST_FORMAT_TIME) { GST_DEBUG ("seeking is only supported in TIME or DEFAULT format"); return FALSE; } if (rate < 0.0) { GST_DEBUG ("only forward playback supported, rate %f not allowed", rate); return FALSE; } if (seek_format != GST_FORMAT_DEFAULT) { GstFormat target_format = GST_FORMAT_DEFAULT; if (start_type != GST_SEEK_TYPE_NONE && !gst_flac_dec_convert_src (flacdec->srcpad, seek_format, start, &target_format, &start)) { GST_DEBUG ("failed to convert start to DEFAULT format"); return FALSE; } if (stop_type != GST_SEEK_TYPE_NONE && !gst_flac_dec_convert_src (flacdec->srcpad, seek_format, stop, &target_format, &stop)) { GST_DEBUG ("failed to convert stop to DEFAULT format"); return FALSE; } } flush = ((seek_flags & GST_SEEK_FLAG_FLUSH) == GST_SEEK_FLAG_FLUSH); if (flush) { /* flushing seek, clear the pipeline of stuff, we need a newsegment after * this. */ GST_DEBUG_OBJECT (flacdec, "flushing"); gst_pad_push_event (flacdec->srcpad, gst_event_new_flush_start ()); } else { /* non flushing seek, pause the task */ GST_DEBUG_OBJECT (flacdec, "stopping task"); gst_pad_stop_task (flacdec->sinkpad); } /* acquire the stream lock, this either happens when the streaming thread * stopped because of the flush or when the task is paused after the loop * function finished an iteration, which can never happen when it's blocked * downstream in PAUSED, for example */ GST_PAD_STREAM_LOCK (flacdec->sinkpad); /* operate on segment copy until we know the seek worked. The idea is that * when the seek fails, we want to continue with what we were doing without * having the segment being updated. */ segment = flacdec->segment; /* update the segment with the seek values, last_stop will contain the new * position we should seek to */ gst_segment_set_seek (&segment, rate, GST_FORMAT_DEFAULT, seek_flags, start_type, start, stop_type, stop, &only_update); GST_DEBUG ("configured segment: [%" G_GINT64_FORMAT "-%" G_GINT64_FORMAT "] = [%" GST_TIME_FORMAT "-%" GST_TIME_FORMAT "]", segment.start, segment.stop, GST_TIME_ARGS (segment.start * GST_SECOND / flacdec->sample_rate), GST_TIME_ARGS (segment.stop * GST_SECOND / flacdec->sample_rate)); GST_DEBUG_OBJECT (flacdec, "performing seek to sample %" G_GINT64_FORMAT, segment.last_stop); /* mark ourselves as seeking because the above lines will trigger some * callbacks that need to behave differently when seeking */ flacdec->seeking = TRUE; seek_ok = #ifdef LEGACY_FLAC FLAC__seekable_stream_decoder_seek_absolute (flacdec->seekable_decoder, segment.last_stop); #else FLAC__stream_decoder_seek_absolute (flacdec->seekable_decoder, segment.last_stop); #endif flacdec->seeking = FALSE; if (!seek_ok) { /* seek failed, segment was not updated and we start streaming again with * the previous segment values */ GST_WARNING_OBJECT (flacdec, "seek failed"); } else if (!flush && flacdec->running) { /* we are running the current segment and doing a non-flushing seek, * close the segment first based on the last_stop. */ GST_DEBUG_OBJECT (flacdec, "closing running segment %" G_GINT64_FORMAT " to %" G_GINT64_FORMAT, segment.start, segment.last_stop); /* convert the old segment values to time to close the old segment */ start = gst_util_uint64_scale_int (flacdec->segment.start, GST_SECOND, flacdec->sample_rate); last_stop = gst_util_uint64_scale_int (flacdec->segment.last_stop, GST_SECOND, flacdec->sample_rate); /* queue the segment for sending in the stream thread, start and time are * always the same. */ if (flacdec->close_segment) gst_event_unref (flacdec->close_segment); flacdec->close_segment = gst_event_new_new_segment_full (TRUE, flacdec->segment.rate, flacdec->segment.applied_rate, GST_FORMAT_TIME, start, last_stop, start); } if (seek_ok) { /* seek succeeded, copy new segment values */ flacdec->segment = segment; GST_DEBUG_OBJECT (flacdec, "seek successful"); } /* convert the (new) segment values to time, we will need them to generate the * new segment events. */ start = gst_util_uint64_scale_int (flacdec->segment.start, GST_SECOND, flacdec->sample_rate); last_stop = gst_util_uint64_scale_int (flacdec->segment.last_stop, GST_SECOND, flacdec->sample_rate); /* for deriving a stop position for the playback segment from the seek * segment, we must take the duration when the stop is not set */ if (flacdec->segment.stop != -1) stop = gst_util_uint64_scale_int (flacdec->segment.stop, GST_SECOND, flacdec->sample_rate); else stop = gst_util_uint64_scale_int (flacdec->segment.duration, GST_SECOND, flacdec->sample_rate); /* notify start of new segment when we were asked to do so. */ if (segment.flags & GST_SEEK_FLAG_SEGMENT) { /* last_stop contains the position we start from */ gst_element_post_message (GST_ELEMENT (flacdec), gst_message_new_segment_start (GST_OBJECT (flacdec), GST_FORMAT_TIME, last_stop)); } /* if the seek was ok or (when it failed) we are flushing, we need to send out * a new segment. If we did not flush and the seek failed, we simply do * nothing here and continue where we were. */ if (seek_ok || flush) { GST_DEBUG_OBJECT (flacdec, "Creating newsegment from %" G_GINT64_FORMAT " to %" G_GINT64_FORMAT, segment.last_stop, stop); /* now replace the old segment so that we send it in the stream thread the * next time it is scheduled. */ if (flacdec->start_segment) gst_event_unref (flacdec->start_segment); flacdec->start_segment = gst_event_new_new_segment_full (FALSE, segment.rate, segment.applied_rate, GST_FORMAT_TIME, last_stop, stop, last_stop); } /* prepare for streaming again, start with a flush stop when we issued a flush * start before. */ if (flush) { GST_DEBUG_OBJECT (flacdec, "flushing stop"); gst_pad_push_event (flacdec->srcpad, gst_event_new_flush_stop ()); } /* we'll generate a discont on the next buffer */ flacdec->discont = TRUE; /* the task is running again now */ flacdec->running = TRUE; gst_pad_start_task (flacdec->sinkpad, (GstTaskFunction) gst_flac_dec_loop, flacdec->sinkpad); GST_PAD_STREAM_UNLOCK (flacdec->sinkpad); return seek_ok; } static gboolean gst_flac_dec_src_event (GstPad * pad, GstEvent * event) { gboolean res = TRUE; GstFlacDec *flacdec = GST_FLAC_DEC (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEEK:{ /* first, see if we're before a demuxer that * might handle the seek for us */ gst_event_ref (event); res = gst_pad_event_default (pad, event); /* if not, try to handle it ourselves */ if (!res) { res = gst_flac_dec_handle_seek_event (flacdec, event); } gst_event_unref (event); break; } default: res = gst_pad_event_default (pad, event); break; } gst_object_unref (flacdec); return res; } static gboolean gst_flac_dec_sink_activate (GstPad * sinkpad) { if (gst_pad_check_pull_range (sinkpad)) return gst_pad_activate_pull (sinkpad, TRUE); return gst_pad_activate_push (sinkpad, TRUE); } static gboolean gst_flac_dec_sink_activate_push (GstPad * sinkpad, gboolean active) { GstFlacDec *dec = GST_FLAC_DEC (GST_OBJECT_PARENT (sinkpad)); gst_flac_dec_setup_stream_decoder (dec); return TRUE; } static gboolean gst_flac_dec_sink_activate_pull (GstPad * sinkpad, gboolean active) { gboolean res; if (active) { GstFlacDec *flacdec; flacdec = GST_FLAC_DEC (GST_PAD_PARENT (sinkpad)); flacdec->offset = 0; gst_flac_dec_setup_seekable_decoder (flacdec); flacdec->running = TRUE; res = gst_pad_start_task (sinkpad, (GstTaskFunction) gst_flac_dec_loop, sinkpad); } else { res = gst_pad_stop_task (sinkpad); } return res; } static GstStateChangeReturn gst_flac_dec_change_state (GstElement * element, GstStateChange transition) { GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstFlacDec *flacdec = GST_FLAC_DEC (element); switch (transition) { case GST_STATE_CHANGE_READY_TO_PAUSED: flacdec->seeking = FALSE; flacdec->channels = 0; flacdec->depth = 0; flacdec->width = 0; flacdec->sample_rate = 0; gst_segment_init (&flacdec->segment, GST_FORMAT_DEFAULT); break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); if (ret == GST_STATE_CHANGE_FAILURE) return ret; switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: gst_segment_init (&flacdec->segment, GST_FORMAT_UNDEFINED); gst_flac_dec_reset_decoders (flacdec); break; default: break; } return ret; }