/* GStreamer RealMedia demuxer * Copyright (C) <1999> Erik Walthinsen * Copyright (C) <2003> David A. Schleef * Copyright (C) <2004> Stephane Loeuillet * Copyright (C) <2005> Owen Fraser-Green * Copyright (C) <2005> Michael Smith * Copyright (C) <2006> Wim Taymans * Copyright (C) <2006> Tim-Philipp Müller * Copyright (C) <2007> Wim Taymans * * 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., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include "rmdemux.h" #include "rmutils.h" #include #include #define RMDEMUX_GUINT32_GET(a) GST_READ_UINT32_BE(a) #define RMDEMUX_GUINT16_GET(a) GST_READ_UINT16_BE(a) #define RMDEMUX_FOURCC_GET(a) GST_READ_UINT32_LE(a) #define HEADER_SIZE 10 #define DATA_SIZE 8 #define MAX_FRAGS 256 static const guint8 sipr_subpk_size[4] = { 29, 19, 37, 20 }; typedef struct _GstRMDemuxIndex GstRMDemuxIndex; struct _GstRMDemuxStream { guint32 subtype; guint32 fourcc; guint32 subformat; guint32 format; int id; GstPad *pad; gboolean discont; int timescale; int sample_index; GstRMDemuxIndex *index; int index_length; gint framerate_numerator; gint framerate_denominator; guint32 seek_offset; guint16 width; guint16 height; guint16 flavor; guint16 rate; /* samplerate */ guint16 n_channels; /* channels */ guint16 sample_width; /* bits_per_sample */ guint16 leaf_size; /* subpacket_size */ guint32 packet_size; /* coded_frame_size */ guint16 version; guint32 extra_data_size; /* codec_data_length */ guint8 *extra_data; /* extras */ guint32 bitrate; gboolean needs_descrambling; guint subpackets_needed; /* subpackets needed for descrambling */ GPtrArray *subpackets; /* array containing subpacket GstBuffers */ /* Variables needed for fixing timestamps. */ GstClockTime next_ts, last_ts; guint16 next_seq, last_seq; gint frag_seqnum; gint frag_subseq; guint frag_length; guint frag_current; guint frag_count; guint frag_offset[MAX_FRAGS]; GstAdapter *adapter; GstTagList *pending_tags; }; struct _GstRMDemuxIndex { guint32 offset; GstClockTime timestamp; }; static GstStaticPadTemplate gst_rmdemux_sink_template = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("application/vnd.rn-realmedia") ); static GstStaticPadTemplate gst_rmdemux_videosrc_template = GST_STATIC_PAD_TEMPLATE ("video_%u", GST_PAD_SRC, GST_PAD_SOMETIMES, GST_STATIC_CAPS_ANY); static GstStaticPadTemplate gst_rmdemux_audiosrc_template = GST_STATIC_PAD_TEMPLATE ("audio_%u", GST_PAD_SRC, GST_PAD_SOMETIMES, GST_STATIC_CAPS_ANY); GST_DEBUG_CATEGORY_STATIC (rmdemux_debug); #define GST_CAT_DEFAULT rmdemux_debug static GstElementClass *parent_class = NULL; static void gst_rmdemux_class_init (GstRMDemuxClass * klass); static void gst_rmdemux_base_init (GstRMDemuxClass * klass); static void gst_rmdemux_init (GstRMDemux * rmdemux); static void gst_rmdemux_finalize (GObject * object); static GstStateChangeReturn gst_rmdemux_change_state (GstElement * element, GstStateChange transition); static GstFlowReturn gst_rmdemux_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer); static void gst_rmdemux_loop (GstPad * pad); static gboolean gst_rmdemux_sink_activate (GstPad * sinkpad, GstObject * parent); static gboolean gst_rmdemux_sink_activate_mode (GstPad * sinkpad, GstObject * parent, GstPadMode mode, gboolean active); static gboolean gst_rmdemux_sink_event (GstPad * pad, GstObject * parent, GstEvent * event); static gboolean gst_rmdemux_src_event (GstPad * pad, GstObject * parent, GstEvent * event); static void gst_rmdemux_send_event (GstRMDemux * rmdemux, GstEvent * event); static gboolean gst_rmdemux_src_query (GstPad * pad, GstObject * parent, GstQuery * query); static gboolean gst_rmdemux_perform_seek (GstRMDemux * rmdemux, GstEvent * event); static void gst_rmdemux_parse__rmf (GstRMDemux * rmdemux, const guint8 * data, int length); static void gst_rmdemux_parse_prop (GstRMDemux * rmdemux, const guint8 * data, int length); static void gst_rmdemux_parse_mdpr (GstRMDemux * rmdemux, const guint8 * data, int length); static guint gst_rmdemux_parse_indx (GstRMDemux * rmdemux, const guint8 * data, int length); static void gst_rmdemux_parse_data (GstRMDemux * rmdemux, const guint8 * data, int length); static void gst_rmdemux_parse_cont (GstRMDemux * rmdemux, const guint8 * data, int length); static GstFlowReturn gst_rmdemux_parse_packet (GstRMDemux * rmdemux, GstBuffer * in, guint16 version); static void gst_rmdemux_parse_indx_data (GstRMDemux * rmdemux, const guint8 * data, int length); static void gst_rmdemux_stream_clear_cached_subpackets (GstRMDemux * rmdemux, GstRMDemuxStream * stream); static GstRMDemuxStream *gst_rmdemux_get_stream_by_id (GstRMDemux * rmdemux, int id); static GType gst_rmdemux_get_type (void) { static GType rmdemux_type = 0; if (!rmdemux_type) { static const GTypeInfo rmdemux_info = { sizeof (GstRMDemuxClass), (GBaseInitFunc) gst_rmdemux_base_init, NULL, (GClassInitFunc) gst_rmdemux_class_init, NULL, NULL, sizeof (GstRMDemux), 0, (GInstanceInitFunc) gst_rmdemux_init, }; rmdemux_type = g_type_register_static (GST_TYPE_ELEMENT, "GstRMDemux", &rmdemux_info, 0); } return rmdemux_type; } GST_ELEMENT_REGISTER_DEFINE (rmdemux, "rmdemux", GST_RANK_PRIMARY, GST_TYPE_RMDEMUX); static void gst_rmdemux_base_init (GstRMDemuxClass * klass) { GstElementClass *element_class = GST_ELEMENT_CLASS (klass); gst_element_class_add_static_pad_template (element_class, &gst_rmdemux_sink_template); gst_element_class_add_static_pad_template (element_class, &gst_rmdemux_videosrc_template); gst_element_class_add_static_pad_template (element_class, &gst_rmdemux_audiosrc_template); gst_element_class_set_static_metadata (element_class, "RealMedia Demuxer", "Codec/Demuxer", "Demultiplex a RealMedia file into audio and video streams", "David Schleef "); } static void gst_rmdemux_class_init (GstRMDemuxClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; gobject_class = (GObjectClass *) klass; gstelement_class = (GstElementClass *) klass; parent_class = g_type_class_peek_parent (klass); gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_rmdemux_change_state); GST_DEBUG_CATEGORY_INIT (rmdemux_debug, "rmdemux", 0, "Demuxer for Realmedia streams"); gobject_class->finalize = gst_rmdemux_finalize; } static void gst_rmdemux_finalize (GObject * object) { GstRMDemux *rmdemux = GST_RMDEMUX (object); if (rmdemux->adapter) { g_object_unref (rmdemux->adapter); rmdemux->adapter = NULL; } if (rmdemux->flowcombiner) { gst_flow_combiner_free (rmdemux->flowcombiner); rmdemux->flowcombiner = NULL; } GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object)); } static void gst_rmdemux_init (GstRMDemux * rmdemux) { rmdemux->sinkpad = gst_pad_new_from_static_template (&gst_rmdemux_sink_template, "sink"); gst_pad_set_event_function (rmdemux->sinkpad, GST_DEBUG_FUNCPTR (gst_rmdemux_sink_event)); gst_pad_set_chain_function (rmdemux->sinkpad, GST_DEBUG_FUNCPTR (gst_rmdemux_chain)); gst_pad_set_activate_function (rmdemux->sinkpad, GST_DEBUG_FUNCPTR (gst_rmdemux_sink_activate)); gst_pad_set_activatemode_function (rmdemux->sinkpad, GST_DEBUG_FUNCPTR (gst_rmdemux_sink_activate_mode)); gst_element_add_pad (GST_ELEMENT (rmdemux), rmdemux->sinkpad); rmdemux->adapter = gst_adapter_new (); rmdemux->first_ts = GST_CLOCK_TIME_NONE; rmdemux->base_ts = GST_CLOCK_TIME_NONE; rmdemux->need_newsegment = TRUE; rmdemux->have_group_id = FALSE; rmdemux->group_id = G_MAXUINT; rmdemux->flowcombiner = gst_flow_combiner_new (); rmdemux->seek_seqnum = GST_SEQNUM_INVALID; gst_rm_utils_run_tests (); } static gboolean gst_rmdemux_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { gboolean ret; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEGMENT: gst_event_unref (event); ret = TRUE; break; default: ret = gst_pad_event_default (pad, parent, event); break; } return ret; } static gboolean gst_rmdemux_src_event (GstPad * pad, GstObject * parent, GstEvent * event) { gboolean ret = TRUE; GstRMDemux *rmdemux = GST_RMDEMUX (parent); GST_LOG_OBJECT (rmdemux, "handling src event"); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEEK: { gboolean running; guint32 seqnum; GST_LOG_OBJECT (rmdemux, "Event on src: SEEK"); seqnum = gst_event_get_seqnum (event); if (seqnum == rmdemux->seek_seqnum) { GST_LOG_OBJECT (pad, "Drop duplicated SEEK event seqnum %" G_GUINT32_FORMAT, seqnum); gst_event_unref (event); break; } /* can't seek if we are not seekable, FIXME could pass the * seek query upstream after converting it to bytes using * the average bitrate of the stream. */ if (!rmdemux->seekable) { ret = FALSE; GST_DEBUG ("seek on non seekable stream"); goto done_unref; } GST_OBJECT_LOCK (rmdemux); /* check if we can do the seek now */ running = rmdemux->running; GST_OBJECT_UNLOCK (rmdemux); /* now do the seek */ if (running) { ret = gst_rmdemux_perform_seek (rmdemux, event); } else ret = TRUE; gst_event_unref (event); break; } default: GST_LOG_OBJECT (rmdemux, "Event on src: type=%d", GST_EVENT_TYPE (event)); ret = gst_pad_event_default (pad, parent, event); break; } return ret; done_unref: GST_DEBUG ("error handling event"); gst_event_unref (event); return ret; } /* Validate that this looks like a reasonable point to seek to */ static gboolean gst_rmdemux_validate_offset (GstRMDemux * rmdemux) { GstBuffer *buffer; GstFlowReturn flowret; guint16 version, length; gboolean ret = TRUE; GstMapInfo map; buffer = NULL; flowret = gst_pad_pull_range (rmdemux->sinkpad, rmdemux->offset, 4, &buffer); if (flowret != GST_FLOW_OK) { GST_DEBUG_OBJECT (rmdemux, "Failed to pull data at offset %d", rmdemux->offset); return FALSE; } /* TODO: Can we also be seeking to a 'DATA' chunk header? Check this. * Also, for the case we currently handle, can we check any more? It's pretty * sucky to not be validating a little more heavily than this... */ /* This should now be the start of a data packet header. That begins with * a 2-byte 'version' field, which has to be 0 or 1, then a length. I'm not * certain what values are valid for length, but it must always be at least * 4 bytes, and we can check that it won't take us past our known total size */ gst_buffer_map (buffer, &map, GST_MAP_READ); version = RMDEMUX_GUINT16_GET (map.data); if (version != 0 && version != 1) { GST_DEBUG_OBJECT (rmdemux, "Expected version 0 or 1, got %d", (int) version); ret = FALSE; } length = RMDEMUX_GUINT16_GET (map.data + 2); /* TODO: Also check against total stream length */ if (length < 4) { GST_DEBUG_OBJECT (rmdemux, "Expected length >= 4, got %d", (int) length); ret = FALSE; } gst_buffer_unmap (buffer, &map); if (ret) { rmdemux->offset += 4; gst_adapter_clear (rmdemux->adapter); gst_adapter_push (rmdemux->adapter, buffer); } else { GST_WARNING_OBJECT (rmdemux, "Failed to validate seek offset at %d", rmdemux->offset); gst_buffer_unref (buffer); } return ret; } static gboolean find_seek_offset_bytes (GstRMDemux * rmdemux, guint target) { int i; GSList *cur; gboolean ret = FALSE; for (cur = rmdemux->streams; cur; cur = cur->next) { GstRMDemuxStream *stream = cur->data; /* Search backwards through this stream's index until we find the first * timestamp before our target time */ for (i = stream->index_length - 1; i >= 0; i--) { if (stream->index[i].offset <= target) { /* Set the seek_offset for the stream so we don't bother parsing it * until we've passed that point */ stream->seek_offset = stream->index[i].offset; rmdemux->offset = stream->index[i].offset; ret = TRUE; break; } } } return ret; } static gboolean find_seek_offset_time (GstRMDemux * rmdemux, GstClockTime time) { int i, n_stream; gboolean ret = FALSE; GSList *cur; GstClockTime earliest = GST_CLOCK_TIME_NONE; n_stream = 0; for (cur = rmdemux->streams; cur; cur = cur->next, n_stream++) { GstRMDemuxStream *stream = cur->data; /* Search backwards through this stream's index until we find the first * timestamp before our target time */ for (i = stream->index_length - 1; i >= 0; i--) { if (stream->index[i].timestamp <= time) { /* Set the seek_offset for the stream so we don't bother parsing it * until we've passed that point */ stream->seek_offset = stream->index[i].offset; /* If it's also the earliest timestamp we've seen of all streams, then * that's our target! */ if (earliest == GST_CLOCK_TIME_NONE || stream->index[i].timestamp < earliest) { earliest = stream->index[i].timestamp; rmdemux->offset = stream->index[i].offset; GST_DEBUG_OBJECT (rmdemux, "We're looking for %" GST_TIME_FORMAT " and we found that stream %d has the latest index at %" GST_TIME_FORMAT, GST_TIME_ARGS (rmdemux->segment.start), n_stream, GST_TIME_ARGS (earliest)); } ret = TRUE; break; } } stream->discont = TRUE; } return ret; } static gboolean gst_rmdemux_perform_seek (GstRMDemux * rmdemux, GstEvent * event) { gboolean validated; gboolean ret = TRUE; gboolean flush; GstFormat format; gdouble rate; GstSeekFlags flags; GstSeekType cur_type, stop_type; gint64 cur, stop; gboolean update; guint32 seqnum = GST_SEQNUM_INVALID; GstEvent *fl_event; if (event) { GST_DEBUG_OBJECT (rmdemux, "seek with event"); seqnum = gst_event_get_seqnum (event); gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur, &stop_type, &stop); /* we can only seek on time */ if (format != GST_FORMAT_TIME) { GST_DEBUG_OBJECT (rmdemux, "can only seek on TIME"); goto error; } /* cannot yet do backwards playback */ if (rate <= 0.0) { GST_DEBUG_OBJECT (rmdemux, "can only seek with positive rate, not %lf", rate); goto error; } } else { GST_DEBUG_OBJECT (rmdemux, "seek without event"); flags = 0; rate = 1.0; } GST_DEBUG_OBJECT (rmdemux, "seek, rate %g", rate); flush = flags & GST_SEEK_FLAG_FLUSH; /* first step is to unlock the streaming thread if it is * blocked in a chain call, we do this by starting the flush. */ if (flush) { fl_event = gst_event_new_flush_start (); if (seqnum != GST_SEQNUM_INVALID) gst_event_set_seqnum (fl_event, seqnum); gst_pad_push_event (rmdemux->sinkpad, fl_event); fl_event = gst_event_new_flush_start (); if (seqnum != GST_SEQNUM_INVALID) gst_event_set_seqnum (fl_event, seqnum); gst_rmdemux_send_event (rmdemux, fl_event); } else { gst_pad_pause_task (rmdemux->sinkpad); } GST_LOG_OBJECT (rmdemux, "Done starting flushes"); /* now grab the stream lock so that streaming cannot continue, for * non flushing seeks when the element is in PAUSED this could block * forever. */ GST_PAD_STREAM_LOCK (rmdemux->sinkpad); GST_LOG_OBJECT (rmdemux, "Took streamlock"); if (event) { if (!gst_segment_do_seek (&rmdemux->segment, rate, format, flags, cur_type, cur, stop_type, stop, &update)) { ret = FALSE; goto done; } rmdemux->seek_seqnum = seqnum; } GST_DEBUG_OBJECT (rmdemux, "segment positions set to %" GST_TIME_FORMAT "-%" GST_TIME_FORMAT, GST_TIME_ARGS (rmdemux->segment.start), GST_TIME_ARGS (rmdemux->segment.stop)); /* we need to stop flushing on the sinkpad as we're going to use it * next. We can do this as we have the STREAM lock now. */ fl_event = gst_event_new_flush_stop (TRUE); if (seqnum != GST_SEQNUM_INVALID) gst_event_set_seqnum (fl_event, seqnum); gst_pad_push_event (rmdemux->sinkpad, fl_event); GST_LOG_OBJECT (rmdemux, "Pushed FLUSH_STOP event"); /* For each stream, find the first index offset equal to or before our seek * target. Of these, find the smallest offset. That's where we seek to. * * Then we pull 4 bytes from that offset, and validate that we've seeked to a * what looks like a plausible packet. * If that fails, restart, with the seek target set to one less than the * offset we just tried. If we run out of places to try, treat that as a fatal * error. */ if (!find_seek_offset_time (rmdemux, rmdemux->segment.position)) { GST_LOG_OBJECT (rmdemux, "Failed to find seek offset by time"); ret = FALSE; goto done; } GST_LOG_OBJECT (rmdemux, "Validating offset %u", rmdemux->offset); validated = gst_rmdemux_validate_offset (rmdemux); while (!validated) { GST_INFO_OBJECT (rmdemux, "Failed to validate offset at %u", rmdemux->offset); if (!find_seek_offset_bytes (rmdemux, rmdemux->offset - 1)) { ret = FALSE; goto done; } validated = gst_rmdemux_validate_offset (rmdemux); } GST_LOG_OBJECT (rmdemux, "Found final offset. Excellent!"); /* now we have a new position, prepare for streaming again */ { /* Reset the demuxer state */ rmdemux->state = RMDEMUX_STATE_DATA_PACKET; if (flush) { fl_event = gst_event_new_flush_stop (TRUE); if (seqnum != GST_SEQNUM_INVALID) gst_event_set_seqnum (fl_event, seqnum); gst_rmdemux_send_event (rmdemux, fl_event); } /* must send newsegment event from streaming thread, so just set flag */ rmdemux->need_newsegment = TRUE; /* notify start of new segment */ if (rmdemux->segment.flags & GST_SEEK_FLAG_SEGMENT) { GstMessage *msg = gst_message_new_segment_start (GST_OBJECT_CAST (rmdemux), GST_FORMAT_TIME, rmdemux->segment.position); if (seqnum != GST_SEQNUM_INVALID) gst_message_set_seqnum (msg, seqnum); gst_element_post_message (GST_ELEMENT_CAST (rmdemux), msg); } /* restart our task since it might have been stopped when we did the * flush. */ gst_pad_start_task (rmdemux->sinkpad, (GstTaskFunction) gst_rmdemux_loop, rmdemux->sinkpad, NULL); } done: /* streaming can continue now */ GST_PAD_STREAM_UNLOCK (rmdemux->sinkpad); return ret; error: { GST_DEBUG_OBJECT (rmdemux, "seek failed"); return FALSE; } } static gboolean gst_rmdemux_src_query (GstPad * pad, GstObject * parent, GstQuery * query) { gboolean res = FALSE; GstRMDemux *rmdemux; rmdemux = GST_RMDEMUX (parent); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: GST_DEBUG_OBJECT (rmdemux, "Position query: no idea from demuxer!"); break; case GST_QUERY_DURATION:{ GstFormat fmt; gst_query_parse_duration (query, &fmt, NULL); if (fmt == GST_FORMAT_TIME) { GST_OBJECT_LOCK (rmdemux); if (G_LIKELY (rmdemux->running)) { gst_query_set_duration (query, GST_FORMAT_TIME, rmdemux->duration); GST_DEBUG_OBJECT (rmdemux, "duration set to %" GST_TIME_FORMAT, GST_TIME_ARGS (rmdemux->duration)); res = TRUE; } GST_OBJECT_UNLOCK (rmdemux); } break; } case GST_QUERY_SEEKING:{ GstFormat fmt; gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL); if (fmt == GST_FORMAT_TIME) { GST_OBJECT_LOCK (rmdemux); if (G_LIKELY (rmdemux->running)) { gst_query_set_seeking (query, GST_FORMAT_TIME, rmdemux->seekable, 0, rmdemux->duration); res = TRUE; } GST_OBJECT_UNLOCK (rmdemux); } break; } case GST_QUERY_SEGMENT: { GstFormat format; gint64 start, stop; format = rmdemux->segment.format; start = gst_segment_to_stream_time (&rmdemux->segment, format, rmdemux->segment.start); if ((stop = rmdemux->segment.stop) == -1) stop = rmdemux->segment.duration; else stop = gst_segment_to_stream_time (&rmdemux->segment, format, stop); gst_query_set_segment (query, rmdemux->segment.rate, format, start, stop); res = TRUE; break; } default: res = gst_pad_query_default (pad, parent, query); break; } return res; } static void gst_rmdemux_free_stream (GstRMDemux * rmdemux, GstRMDemuxStream * stream) { g_object_unref (stream->adapter); gst_rmdemux_stream_clear_cached_subpackets (rmdemux, stream); if (stream->pending_tags) gst_tag_list_unref (stream->pending_tags); if (stream->subpackets) g_ptr_array_free (stream->subpackets, TRUE); g_free (stream->index); g_free (stream); } static void gst_rmdemux_reset (GstRMDemux * rmdemux) { GSList *cur; GST_OBJECT_LOCK (rmdemux); rmdemux->running = FALSE; GST_OBJECT_UNLOCK (rmdemux); for (cur = rmdemux->streams; cur; cur = cur->next) { GstRMDemuxStream *stream = cur->data; gst_flow_combiner_remove_pad (rmdemux->flowcombiner, stream->pad); gst_element_remove_pad (GST_ELEMENT (rmdemux), stream->pad); gst_rmdemux_free_stream (rmdemux, stream); } g_slist_free (rmdemux->streams); rmdemux->streams = NULL; rmdemux->n_audio_streams = 0; rmdemux->n_video_streams = 0; if (rmdemux->pending_tags != NULL) { gst_tag_list_unref (rmdemux->pending_tags); rmdemux->pending_tags = NULL; } gst_adapter_clear (rmdemux->adapter); rmdemux->state = RMDEMUX_STATE_HEADER; rmdemux->have_pads = FALSE; gst_segment_init (&rmdemux->segment, GST_FORMAT_UNDEFINED); rmdemux->first_ts = GST_CLOCK_TIME_NONE; rmdemux->base_ts = GST_CLOCK_TIME_NONE; rmdemux->need_newsegment = TRUE; rmdemux->have_group_id = FALSE; rmdemux->group_id = G_MAXUINT; rmdemux->seek_seqnum = GST_SEQNUM_INVALID; } static GstStateChangeReturn gst_rmdemux_change_state (GstElement * element, GstStateChange transition) { GstRMDemux *rmdemux = GST_RMDEMUX (element); GstStateChangeReturn res; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: rmdemux->state = RMDEMUX_STATE_HEADER; rmdemux->have_pads = FALSE; gst_segment_init (&rmdemux->segment, GST_FORMAT_TIME); rmdemux->running = FALSE; break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY:{ gst_rmdemux_reset (rmdemux); break; } case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return res; } /* this function is called when the pad is activated and should start * processing data. * * We check if we can do random access to decide if we work push or * pull based. */ static gboolean gst_rmdemux_sink_activate (GstPad * sinkpad, GstObject * parent) { GstQuery *query; gboolean pull_mode; query = gst_query_new_scheduling (); if (!gst_pad_peer_query (sinkpad, query)) { gst_query_unref (query); goto activate_push; } pull_mode = gst_query_has_scheduling_mode_with_flags (query, GST_PAD_MODE_PULL, GST_SCHEDULING_FLAG_SEEKABLE); gst_query_unref (query); if (!pull_mode) goto activate_push; GST_DEBUG_OBJECT (sinkpad, "activating pull"); return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE); activate_push: { GST_DEBUG_OBJECT (sinkpad, "activating push"); return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE); } } static gboolean gst_rmdemux_sink_activate_mode (GstPad * sinkpad, GstObject * parent, GstPadMode mode, gboolean active) { gboolean res; GstRMDemux *demux; demux = GST_RMDEMUX (parent); switch (mode) { case GST_PAD_MODE_PUSH: demux->seekable = FALSE; demux->running = active; res = TRUE; break; case GST_PAD_MODE_PULL: if (active) { demux->seekable = TRUE; demux->offset = 0; demux->loop_state = RMDEMUX_LOOP_STATE_HEADER; demux->data_offset = G_MAXUINT; res = gst_pad_start_task (sinkpad, (GstTaskFunction) gst_rmdemux_loop, sinkpad, NULL); } else { res = gst_pad_stop_task (sinkpad); } break; default: res = FALSE; break; } return res; } /* random access mode - just pass over to our chain function */ static void gst_rmdemux_loop (GstPad * pad) { GstRMDemux *rmdemux; GstBuffer *buffer; GstFlowReturn ret = GST_FLOW_OK; guint size; rmdemux = GST_RMDEMUX (GST_PAD_PARENT (pad)); GST_LOG_OBJECT (rmdemux, "loop with state=%d and offset=0x%x", rmdemux->loop_state, rmdemux->offset); switch (rmdemux->state) { case RMDEMUX_STATE_HEADER: size = HEADER_SIZE; break; case RMDEMUX_STATE_HEADER_DATA: size = DATA_SIZE; break; case RMDEMUX_STATE_DATA_PACKET: size = rmdemux->avg_packet_size; break; case RMDEMUX_STATE_EOS: GST_LOG_OBJECT (rmdemux, "At EOS, pausing task"); ret = GST_FLOW_EOS; goto need_pause; default: GST_LOG_OBJECT (rmdemux, "Default: requires %d bytes (state is %d)", (int) rmdemux->size, rmdemux->state); size = rmdemux->size; } buffer = NULL; ret = gst_pad_pull_range (pad, rmdemux->offset, size, &buffer); if (ret != GST_FLOW_OK) { if (rmdemux->offset == rmdemux->index_offset) { /* The index isn't available so forget about it */ rmdemux->loop_state = RMDEMUX_LOOP_STATE_DATA; rmdemux->offset = rmdemux->data_offset; GST_OBJECT_LOCK (rmdemux); rmdemux->running = TRUE; rmdemux->seekable = FALSE; GST_OBJECT_UNLOCK (rmdemux); return; } else { GST_DEBUG_OBJECT (rmdemux, "Unable to pull %d bytes at offset 0x%08x " "(pull_range returned flow %s, state is %d)", (gint) size, rmdemux->offset, gst_flow_get_name (ret), GST_STATE (rmdemux)); goto need_pause; } } size = gst_buffer_get_size (buffer); /* Defer to the chain function */ ret = gst_rmdemux_chain (pad, GST_OBJECT_CAST (rmdemux), buffer); if (ret != GST_FLOW_OK) { GST_DEBUG_OBJECT (rmdemux, "Chain flow failed at offset 0x%08x", rmdemux->offset); goto need_pause; } rmdemux->offset += size; switch (rmdemux->loop_state) { case RMDEMUX_LOOP_STATE_HEADER: if (rmdemux->offset >= rmdemux->data_offset) { /* It's the end of the header */ rmdemux->loop_state = RMDEMUX_LOOP_STATE_INDEX; rmdemux->offset = rmdemux->index_offset; } break; case RMDEMUX_LOOP_STATE_INDEX: if (rmdemux->state == RMDEMUX_STATE_HEADER) { if (rmdemux->index_offset == 0) { /* We've read the last index */ rmdemux->loop_state = RMDEMUX_LOOP_STATE_DATA; rmdemux->offset = rmdemux->data_offset; GST_OBJECT_LOCK (rmdemux); rmdemux->running = TRUE; GST_OBJECT_UNLOCK (rmdemux); } else { /* Get the next index */ rmdemux->offset = rmdemux->index_offset; } } break; case RMDEMUX_LOOP_STATE_DATA: break; } return; /* ERRORS */ need_pause: { const gchar *reason = gst_flow_get_name (ret); GST_LOG_OBJECT (rmdemux, "pausing task, reason %s", reason); rmdemux->segment_running = FALSE; gst_pad_pause_task (rmdemux->sinkpad); if (ret == GST_FLOW_EOS) { /* perform EOS logic */ if (rmdemux->segment.flags & GST_SEEK_FLAG_SEGMENT) { gint64 stop; /* for segment playback we need to post when (in stream time) * we stopped, this is either stop (when set) or the duration. */ if ((stop = rmdemux->segment.stop) == -1) stop = rmdemux->segment.duration; GST_LOG_OBJECT (rmdemux, "Sending segment done, at end of segment"); gst_element_post_message (GST_ELEMENT (rmdemux), gst_message_new_segment_done (GST_OBJECT (rmdemux), GST_FORMAT_TIME, stop)); gst_rmdemux_send_event (rmdemux, gst_event_new_segment_done (GST_FORMAT_TIME, stop)); } else { /* normal playback, send EOS to all linked pads */ GST_LOG_OBJECT (rmdemux, "Sending EOS, at end of stream"); gst_rmdemux_send_event (rmdemux, gst_event_new_eos ()); } } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) { GST_ELEMENT_FLOW_ERROR (rmdemux, ret); gst_rmdemux_send_event (rmdemux, gst_event_new_eos ()); } return; } } static gboolean gst_rmdemux_fourcc_isplausible (guint32 fourcc) { int i; for (i = 0; i < 4; i++) { if (!isprint ((int) ((unsigned char *) (&fourcc))[i])) { return FALSE; } } return TRUE; } static GstFlowReturn gst_rmdemux_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer) { GstFlowReturn ret = GST_FLOW_OK; const guint8 *data; guint16 version; guint avail; GstRMDemux *rmdemux = GST_RMDEMUX (parent); if (rmdemux->base_ts == -1) { if (GST_BUFFER_DTS_IS_VALID (buffer)) rmdemux->base_ts = GST_BUFFER_DTS (buffer); else rmdemux->base_ts = GST_BUFFER_PTS (buffer); GST_LOG_OBJECT (rmdemux, "base_ts %" GST_TIME_FORMAT, GST_TIME_ARGS (rmdemux->base_ts)); } gst_adapter_push (rmdemux->adapter, buffer); GST_LOG_OBJECT (rmdemux, "Chaining buffer of size %" G_GSIZE_FORMAT, gst_buffer_get_size (buffer)); while (TRUE) { avail = gst_adapter_available (rmdemux->adapter); GST_LOG_OBJECT (rmdemux, "looping in chain, avail %u", avail); switch (rmdemux->state) { case RMDEMUX_STATE_HEADER: { if (gst_adapter_available (rmdemux->adapter) < HEADER_SIZE) goto unlock; data = gst_adapter_map (rmdemux->adapter, HEADER_SIZE); rmdemux->object_id = RMDEMUX_FOURCC_GET (data + 0); rmdemux->size = RMDEMUX_GUINT32_GET (data + 4) - HEADER_SIZE; rmdemux->object_version = RMDEMUX_GUINT16_GET (data + 8); /* Sanity-check. We assume that the FOURCC is printable ASCII */ if (!gst_rmdemux_fourcc_isplausible (rmdemux->object_id)) { /* Failed. Remain in HEADER state, try again... We flush only * the actual FOURCC, not the entire header, because we could * need to resync anywhere at all... really, this should never * happen. */ GST_WARNING_OBJECT (rmdemux, "Bogus looking header, unprintable " "FOURCC"); gst_adapter_unmap (rmdemux->adapter); gst_adapter_flush (rmdemux->adapter, 4); break; } GST_LOG_OBJECT (rmdemux, "header found with object_id=%" GST_FOURCC_FORMAT " size=%08x object_version=%d", GST_FOURCC_ARGS (rmdemux->object_id), rmdemux->size, rmdemux->object_version); gst_adapter_unmap (rmdemux->adapter); gst_adapter_flush (rmdemux->adapter, HEADER_SIZE); switch (rmdemux->object_id) { case GST_MAKE_FOURCC ('.', 'R', 'M', 'F'): rmdemux->state = RMDEMUX_STATE_HEADER_RMF; break; case GST_MAKE_FOURCC ('P', 'R', 'O', 'P'): rmdemux->state = RMDEMUX_STATE_HEADER_PROP; break; case GST_MAKE_FOURCC ('M', 'D', 'P', 'R'): rmdemux->state = RMDEMUX_STATE_HEADER_MDPR; break; case GST_MAKE_FOURCC ('I', 'N', 'D', 'X'): rmdemux->state = RMDEMUX_STATE_HEADER_INDX; break; case GST_MAKE_FOURCC ('D', 'A', 'T', 'A'): rmdemux->state = RMDEMUX_STATE_HEADER_DATA; break; case GST_MAKE_FOURCC ('C', 'O', 'N', 'T'): rmdemux->state = RMDEMUX_STATE_HEADER_CONT; break; default: rmdemux->state = RMDEMUX_STATE_HEADER_UNKNOWN; break; } break; } case RMDEMUX_STATE_HEADER_UNKNOWN: { if (gst_adapter_available (rmdemux->adapter) < rmdemux->size) goto unlock; GST_WARNING_OBJECT (rmdemux, "Unknown object_id %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (rmdemux->object_id)); gst_adapter_flush (rmdemux->adapter, rmdemux->size); rmdemux->state = RMDEMUX_STATE_HEADER; break; } case RMDEMUX_STATE_HEADER_RMF: { if (gst_adapter_available (rmdemux->adapter) < rmdemux->size) goto unlock; if ((rmdemux->object_version == 0) || (rmdemux->object_version == 1)) { data = gst_adapter_map (rmdemux->adapter, rmdemux->size); gst_rmdemux_parse__rmf (rmdemux, data, rmdemux->size); gst_adapter_unmap (rmdemux->adapter); gst_adapter_flush (rmdemux->adapter, rmdemux->size); } else { gst_adapter_flush (rmdemux->adapter, rmdemux->size); } rmdemux->state = RMDEMUX_STATE_HEADER; break; } case RMDEMUX_STATE_HEADER_PROP: { if (gst_adapter_available (rmdemux->adapter) < rmdemux->size) goto unlock; data = gst_adapter_map (rmdemux->adapter, rmdemux->size); gst_rmdemux_parse_prop (rmdemux, data, rmdemux->size); gst_adapter_unmap (rmdemux->adapter); gst_adapter_flush (rmdemux->adapter, rmdemux->size); rmdemux->state = RMDEMUX_STATE_HEADER; break; } case RMDEMUX_STATE_HEADER_MDPR: { if (gst_adapter_available (rmdemux->adapter) < rmdemux->size) goto unlock; data = gst_adapter_map (rmdemux->adapter, rmdemux->size); gst_rmdemux_parse_mdpr (rmdemux, data, rmdemux->size); gst_adapter_unmap (rmdemux->adapter); gst_adapter_flush (rmdemux->adapter, rmdemux->size); rmdemux->state = RMDEMUX_STATE_HEADER; break; } case RMDEMUX_STATE_HEADER_CONT: { if (gst_adapter_available (rmdemux->adapter) < rmdemux->size) goto unlock; data = gst_adapter_map (rmdemux->adapter, rmdemux->size); gst_rmdemux_parse_cont (rmdemux, data, rmdemux->size); gst_adapter_unmap (rmdemux->adapter); gst_adapter_flush (rmdemux->adapter, rmdemux->size); rmdemux->state = RMDEMUX_STATE_HEADER; break; } case RMDEMUX_STATE_HEADER_DATA: { /* If we haven't already done so then signal there are no more pads */ if (!rmdemux->have_pads) { GST_LOG_OBJECT (rmdemux, "no more pads"); gst_element_no_more_pads (GST_ELEMENT (rmdemux)); rmdemux->have_pads = TRUE; } /* The actual header is only 8 bytes */ rmdemux->size = DATA_SIZE; GST_LOG_OBJECT (rmdemux, "data available %" G_GSIZE_FORMAT, gst_adapter_available (rmdemux->adapter)); if (gst_adapter_available (rmdemux->adapter) < rmdemux->size) goto unlock; data = gst_adapter_map (rmdemux->adapter, rmdemux->size); gst_rmdemux_parse_data (rmdemux, data, rmdemux->size); gst_adapter_unmap (rmdemux->adapter); gst_adapter_flush (rmdemux->adapter, rmdemux->size); rmdemux->state = RMDEMUX_STATE_DATA_PACKET; break; } case RMDEMUX_STATE_HEADER_INDX: { if (gst_adapter_available (rmdemux->adapter) < rmdemux->size) goto unlock; data = gst_adapter_map (rmdemux->adapter, rmdemux->size); rmdemux->size = gst_rmdemux_parse_indx (rmdemux, data, rmdemux->size); /* Only flush the header */ gst_adapter_unmap (rmdemux->adapter); gst_adapter_flush (rmdemux->adapter, HEADER_SIZE); rmdemux->state = RMDEMUX_STATE_INDX_DATA; break; } case RMDEMUX_STATE_INDX_DATA: { /* There's not always an data to get... */ if (rmdemux->size > 0) { if (gst_adapter_available (rmdemux->adapter) < rmdemux->size) goto unlock; data = gst_adapter_map (rmdemux->adapter, rmdemux->size); gst_rmdemux_parse_indx_data (rmdemux, data, rmdemux->size); gst_adapter_unmap (rmdemux->adapter); gst_adapter_flush (rmdemux->adapter, rmdemux->size); } rmdemux->state = RMDEMUX_STATE_HEADER; break; } case RMDEMUX_STATE_DATA_PACKET: { guint8 header[4]; if (gst_adapter_available (rmdemux->adapter) < 2) goto unlock; gst_adapter_copy (rmdemux->adapter, header, 0, 2); version = RMDEMUX_GUINT16_GET (header); GST_LOG_OBJECT (rmdemux, "Data packet with version=%d", version); if (version == 0 || version == 1) { guint16 length; if (gst_adapter_available (rmdemux->adapter) < 4) goto unlock; gst_adapter_copy (rmdemux->adapter, header, 0, 4); length = RMDEMUX_GUINT16_GET (header + 2); GST_LOG_OBJECT (rmdemux, "Got length %d", length); if (length < 4) { GST_LOG_OBJECT (rmdemux, "length too small, dropping"); /* Invalid, just drop it */ gst_adapter_flush (rmdemux->adapter, 4); } else { GstBuffer *buffer; avail = gst_adapter_available (rmdemux->adapter); if (avail < length) goto unlock; GST_LOG_OBJECT (rmdemux, "we have %u available and we needed %d", avail, length); /* flush version and length */ gst_adapter_flush (rmdemux->adapter, 4); length -= 4; buffer = gst_adapter_take_buffer (rmdemux->adapter, length); ret = gst_rmdemux_parse_packet (rmdemux, buffer, version); rmdemux->chunk_index++; } if (rmdemux->chunk_index == rmdemux->n_chunks || length == 0) rmdemux->state = RMDEMUX_STATE_HEADER; } else { /* Stream done */ gst_adapter_flush (rmdemux->adapter, 2); if (rmdemux->data_offset == 0) { GST_LOG_OBJECT (rmdemux, "No further data, internal demux state EOS"); rmdemux->state = RMDEMUX_STATE_EOS; } else rmdemux->state = RMDEMUX_STATE_HEADER; } break; } case RMDEMUX_STATE_EOS: gst_rmdemux_send_event (rmdemux, gst_event_new_eos ()); goto unlock; default: GST_WARNING_OBJECT (rmdemux, "Unhandled state %d", rmdemux->state); goto unlock; } } unlock: return ret; } static GstRMDemuxStream * gst_rmdemux_get_stream_by_id (GstRMDemux * rmdemux, int id) { GSList *cur; for (cur = rmdemux->streams; cur; cur = cur->next) { GstRMDemuxStream *stream = cur->data; if (stream->id == id) { return stream; } } return NULL; } static void gst_rmdemux_send_event (GstRMDemux * rmdemux, GstEvent * event) { GSList *cur; for (cur = rmdemux->streams; cur; cur = cur->next) { GstRMDemuxStream *stream = cur->data; GST_DEBUG_OBJECT (rmdemux, "Pushing %s event on pad %s", GST_EVENT_TYPE_NAME (event), GST_PAD_NAME (stream->pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_STOP: stream->last_ts = -1; stream->next_ts = -1; stream->last_seq = -1; stream->next_seq = -1; break; default: break; } gst_event_ref (event); gst_pad_push_event (stream->pad, event); } gst_event_unref (event); } static void gst_rmdemux_add_stream (GstRMDemux * rmdemux, GstRMDemuxStream * stream) { GstCaps *stream_caps = NULL; const gchar *codec_tag = NULL; gchar *codec_name = NULL; gchar *stream_id; int version = 0; if (stream->subtype == GST_RMDEMUX_STREAM_VIDEO) { char *name = g_strdup_printf ("video_%u", rmdemux->n_video_streams); stream->pad = gst_pad_new_from_static_template (&gst_rmdemux_videosrc_template, name); g_free (name); codec_tag = GST_TAG_VIDEO_CODEC; switch (stream->fourcc) { case GST_RM_VDO_RV10: version = 1; break; case GST_RM_VDO_RV20: version = 2; break; case GST_RM_VDO_RV30: version = 3; break; case GST_RM_VDO_RV40: version = 4; break; default: stream_caps = gst_caps_new_simple ("video/x-unknown-fourcc", "fourcc", G_TYPE_UINT, stream->fourcc, NULL); GST_WARNING_OBJECT (rmdemux, "Unknown video FOURCC code \"%" GST_FOURCC_FORMAT "\" (%08x)", GST_FOURCC_ARGS (stream->fourcc), stream->fourcc); } if (version) { stream_caps = gst_caps_new_simple ("video/x-pn-realvideo", "rmversion", G_TYPE_INT, (int) version, "format", G_TYPE_INT, (int) stream->format, "subformat", G_TYPE_INT, (int) stream->subformat, NULL); } if (stream_caps) { gst_caps_set_simple (stream_caps, "width", G_TYPE_INT, stream->width, "height", G_TYPE_INT, stream->height, "framerate", GST_TYPE_FRACTION, stream->framerate_numerator, stream->framerate_denominator, NULL); } rmdemux->n_video_streams++; } else if (stream->subtype == GST_RMDEMUX_STREAM_AUDIO) { char *name = g_strdup_printf ("audio_%u", rmdemux->n_audio_streams); stream->pad = gst_pad_new_from_static_template (&gst_rmdemux_audiosrc_template, name); GST_LOG_OBJECT (rmdemux, "Created audio pad \"%s\"", name); g_free (name); codec_tag = GST_TAG_AUDIO_CODEC; switch (stream->fourcc) { /* Older RealAudio Codecs */ case GST_RM_AUD_14_4: version = 1; break; case GST_RM_AUD_28_8: version = 2; break; /* DolbyNet (Dolby AC3, low bitrate) */ case GST_RM_AUD_DNET: stream_caps = gst_caps_new_simple ("audio/x-ac3", "rate", G_TYPE_INT, (int) stream->rate, NULL); stream->needs_descrambling = TRUE; stream->subpackets_needed = 1; stream->subpackets = NULL; break; /* MPEG-4 based */ case GST_RM_AUD_RAAC: case GST_RM_AUD_RACP: stream_caps = gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, (int) 4, "framed", G_TYPE_BOOLEAN, TRUE, NULL); if (stream->extra_data_size > 0) { /* strip off an unknown byte in the extra data */ stream->extra_data_size--; stream->extra_data++; } stream->needs_descrambling = TRUE; stream->subpackets_needed = 1; stream->subpackets = NULL; break; /* Sony ATRAC3 */ case GST_RM_AUD_ATRC: stream_caps = gst_caps_new_empty_simple ("audio/x-vnd.sony.atrac3"); stream->needs_descrambling = TRUE; stream->subpackets_needed = stream->height; stream->subpackets = NULL; break; /* RealAudio G2 audio */ case GST_RM_AUD_COOK: version = 8; stream->needs_descrambling = TRUE; stream->subpackets_needed = stream->height; stream->subpackets = NULL; break; /* RALF is lossless */ case GST_RM_AUD_RALF: GST_DEBUG_OBJECT (rmdemux, "RALF"); stream_caps = gst_caps_new_empty_simple ("audio/x-ralf-mpeg4-generic"); break; case GST_RM_AUD_SIPR: if (stream->flavor > 3) { GST_WARNING_OBJECT (rmdemux, "bad SIPR flavor %d, freeing it", stream->flavor); g_object_unref (stream->pad); gst_rmdemux_free_stream (rmdemux, stream); goto beach; } GST_DEBUG_OBJECT (rmdemux, "SIPR"); stream_caps = gst_caps_new_empty_simple ("audio/x-sipro"); stream->needs_descrambling = TRUE; stream->subpackets_needed = stream->height; stream->subpackets = NULL; stream->leaf_size = sipr_subpk_size[stream->flavor]; break; default: stream_caps = gst_caps_new_simple ("video/x-unknown-fourcc", "fourcc", G_TYPE_UINT, stream->fourcc, NULL); GST_WARNING_OBJECT (rmdemux, "Unknown audio FOURCC code \"%" GST_FOURCC_FORMAT "\" (%08x)", GST_FOURCC_ARGS (stream->fourcc), stream->fourcc); break; } if (version) { stream_caps = gst_caps_new_simple ("audio/x-pn-realaudio", "raversion", G_TYPE_INT, (int) version, NULL); } if (stream_caps) { gst_caps_set_simple (stream_caps, "flavor", G_TYPE_INT, (int) stream->flavor, "rate", G_TYPE_INT, (int) stream->rate, "channels", G_TYPE_INT, (int) stream->n_channels, "width", G_TYPE_INT, (int) stream->sample_width, "leaf_size", G_TYPE_INT, (int) stream->leaf_size, "packet_size", G_TYPE_INT, (int) stream->packet_size, "bitrate", G_TYPE_INT, (int) stream->bitrate, "height", G_TYPE_INT, (int) stream->height, NULL); } rmdemux->n_audio_streams++; } else { GST_WARNING_OBJECT (rmdemux, "not adding stream of type %d, freeing it", stream->subtype); gst_rmdemux_free_stream (rmdemux, stream); goto beach; } GST_PAD_ELEMENT_PRIVATE (stream->pad) = stream; rmdemux->streams = g_slist_append (rmdemux->streams, stream); GST_LOG_OBJECT (rmdemux, "n_streams is now %d", g_slist_length (rmdemux->streams)); GST_LOG ("stream->pad = %p, stream_caps = %" GST_PTR_FORMAT, stream->pad, stream_caps); if (stream->pad && stream_caps) { GstEvent *event; GST_LOG_OBJECT (rmdemux, "%d bytes of extra data for stream %s", stream->extra_data_size, GST_PAD_NAME (stream->pad)); /* add codec_data if there is any */ if (stream->extra_data_size > 0) { GstBuffer *buffer; buffer = gst_buffer_new_and_alloc (stream->extra_data_size); gst_buffer_fill (buffer, 0, stream->extra_data, stream->extra_data_size); gst_caps_set_simple (stream_caps, "codec_data", GST_TYPE_BUFFER, buffer, NULL); gst_buffer_unref (buffer); } gst_pad_use_fixed_caps (stream->pad); gst_pad_set_event_function (stream->pad, GST_DEBUG_FUNCPTR (gst_rmdemux_src_event)); gst_pad_set_query_function (stream->pad, GST_DEBUG_FUNCPTR (gst_rmdemux_src_query)); GST_DEBUG_OBJECT (rmdemux, "adding pad %s with caps %" GST_PTR_FORMAT ", stream_id=%d", GST_PAD_NAME (stream->pad), stream_caps, stream->id); gst_pad_set_active (stream->pad, TRUE); stream_id = gst_pad_create_stream_id_printf (stream->pad, GST_ELEMENT_CAST (rmdemux), "%03u", stream->id); event = gst_pad_get_sticky_event (rmdemux->sinkpad, GST_EVENT_STREAM_START, 0); if (event) { if (gst_event_parse_group_id (event, &rmdemux->group_id)) rmdemux->have_group_id = TRUE; else rmdemux->have_group_id = FALSE; gst_event_unref (event); } else if (!rmdemux->have_group_id) { rmdemux->have_group_id = TRUE; rmdemux->group_id = gst_util_group_id_next (); } event = gst_event_new_stream_start (stream_id); if (rmdemux->have_group_id) gst_event_set_group_id (event, rmdemux->group_id); gst_pad_push_event (stream->pad, event); g_free (stream_id); gst_pad_set_caps (stream->pad, stream_caps); codec_name = gst_pb_utils_get_codec_description (stream_caps); /* save for later, we must send the tags after the newsegment event */ if (codec_tag != NULL && codec_name != NULL) { if (stream->pending_tags == NULL) stream->pending_tags = gst_tag_list_new_empty (); gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_KEEP, codec_tag, codec_name, NULL); g_free (codec_name); } gst_element_add_pad (GST_ELEMENT_CAST (rmdemux), stream->pad); gst_flow_combiner_add_pad (rmdemux->flowcombiner, stream->pad); } beach: if (stream_caps) gst_caps_unref (stream_caps); } static int re_skip_pascal_string (const guint8 * ptr) { int length; length = ptr[0]; return length + 1; } static void gst_rmdemux_parse__rmf (GstRMDemux * rmdemux, const guint8 * data, int length) { GST_LOG_OBJECT (rmdemux, "file_version: %d", RMDEMUX_GUINT32_GET (data)); GST_LOG_OBJECT (rmdemux, "num_headers: %d", RMDEMUX_GUINT32_GET (data + 4)); } static void gst_rmdemux_parse_prop (GstRMDemux * rmdemux, const guint8 * data, int length) { GST_LOG_OBJECT (rmdemux, "max bitrate: %d", RMDEMUX_GUINT32_GET (data)); GST_LOG_OBJECT (rmdemux, "avg bitrate: %d", RMDEMUX_GUINT32_GET (data + 4)); GST_LOG_OBJECT (rmdemux, "max packet size: %d", RMDEMUX_GUINT32_GET (data + 8)); rmdemux->avg_packet_size = RMDEMUX_GUINT32_GET (data + 12); GST_LOG_OBJECT (rmdemux, "avg packet size: %d", rmdemux->avg_packet_size); rmdemux->num_packets = RMDEMUX_GUINT32_GET (data + 16); GST_LOG_OBJECT (rmdemux, "number of packets: %d", rmdemux->num_packets); GST_LOG_OBJECT (rmdemux, "duration: %d", RMDEMUX_GUINT32_GET (data + 20)); rmdemux->duration = RMDEMUX_GUINT32_GET (data + 20) * GST_MSECOND; GST_LOG_OBJECT (rmdemux, "preroll: %d", RMDEMUX_GUINT32_GET (data + 24)); rmdemux->index_offset = RMDEMUX_GUINT32_GET (data + 28); GST_LOG_OBJECT (rmdemux, "offset of INDX section: 0x%08x", rmdemux->index_offset); rmdemux->data_offset = RMDEMUX_GUINT32_GET (data + 32); GST_LOG_OBJECT (rmdemux, "offset of DATA section: 0x%08x", rmdemux->data_offset); GST_LOG_OBJECT (rmdemux, "n streams: %d", RMDEMUX_GUINT16_GET (data + 36)); GST_LOG_OBJECT (rmdemux, "flags: 0x%04x", RMDEMUX_GUINT16_GET (data + 38)); } static void gst_rmdemux_parse_mdpr (GstRMDemux * rmdemux, const guint8 * data, int length) { GstRMDemuxStream *stream; char *stream1_type_string; char *stream2_type_string; guint str_len = 0; int stream_type; int offset; guint32 max_bitrate; guint32 avg_bitrate; stream = g_new0 (GstRMDemuxStream, 1); stream->id = RMDEMUX_GUINT16_GET (data); stream->index = NULL; stream->seek_offset = 0; stream->last_ts = -1; stream->next_ts = -1; stream->discont = TRUE; stream->adapter = gst_adapter_new (); GST_LOG_OBJECT (rmdemux, "stream_number=%d", stream->id); /* parse the bitrates */ max_bitrate = RMDEMUX_GUINT32_GET (data + 2); avg_bitrate = RMDEMUX_GUINT32_GET (data + 6); stream->bitrate = avg_bitrate; GST_LOG_OBJECT (rmdemux, "Stream max bitrate=%u", max_bitrate); GST_LOG_OBJECT (rmdemux, "Stream avg bitrate=%u", avg_bitrate); if (max_bitrate != 0) { if (stream->pending_tags == NULL) stream->pending_tags = gst_tag_list_new_empty (); gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_REPLACE, GST_TAG_MAXIMUM_BITRATE, max_bitrate, NULL); } if (avg_bitrate != 0) { if (stream->pending_tags == NULL) stream->pending_tags = gst_tag_list_new_empty (); gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_REPLACE, GST_TAG_BITRATE, avg_bitrate, NULL); } offset = 30; stream1_type_string = gst_rm_utils_read_string8 (data + offset, length - offset, &str_len); offset += str_len; stream2_type_string = gst_rm_utils_read_string8 (data + offset, length - offset, &str_len); offset += str_len; /* stream1_type_string for audio and video stream is a "put_whatever_you_want" field : * observed values : * - "[The ]Video/Audio Stream" (File produced by an official Real encoder) * - "RealVideoPremierePlugIn-VIDEO/AUDIO" (File produced by Abobe Premiere) * * so, we should not rely on it to know which stream type it is */ GST_LOG_OBJECT (rmdemux, "stream type: %s", stream1_type_string); GST_LOG_OBJECT (rmdemux, "MIME type=%s", stream2_type_string); if (strcmp (stream2_type_string, "video/x-pn-realvideo") == 0) { stream_type = GST_RMDEMUX_STREAM_VIDEO; } else if (strcmp (stream2_type_string, "video/x-pn-multirate-realvideo") == 0) { stream_type = GST_RMDEMUX_STREAM_VIDEO; } else if (strcmp (stream2_type_string, "audio/x-pn-realaudio") == 0) { stream_type = GST_RMDEMUX_STREAM_AUDIO; } else if (strcmp (stream2_type_string, "audio/x-pn-multirate-realaudio") == 0) { stream_type = GST_RMDEMUX_STREAM_AUDIO; } else if (strcmp (stream2_type_string, "audio/x-pn-multirate-realaudio-live") == 0) { stream_type = GST_RMDEMUX_STREAM_AUDIO; } else if (strcmp (stream2_type_string, "audio/x-ralf-mpeg4-generic") == 0) { /* Another audio type found in the real testsuite */ stream_type = GST_RMDEMUX_STREAM_AUDIO; } else if (strcmp (stream1_type_string, "") == 0 && strcmp (stream2_type_string, "logical-fileinfo") == 0) { stream_type = GST_RMDEMUX_STREAM_FILEINFO; } else { stream_type = GST_RMDEMUX_STREAM_UNKNOWN; GST_WARNING_OBJECT (rmdemux, "unknown stream type \"%s\",\"%s\"", stream1_type_string, stream2_type_string); } g_free (stream1_type_string); g_free (stream2_type_string); offset += 4; stream->subtype = stream_type; switch (stream_type) { case GST_RMDEMUX_STREAM_VIDEO: /* RV10/RV20/RV30/RV40 => video/x-pn-realvideo, version=1,2,3,4 */ stream->fourcc = RMDEMUX_FOURCC_GET (data + offset + 8); stream->width = RMDEMUX_GUINT16_GET (data + offset + 12); stream->height = RMDEMUX_GUINT16_GET (data + offset + 14); stream->rate = RMDEMUX_GUINT16_GET (data + offset + 16); stream->subformat = RMDEMUX_GUINT32_GET (data + offset + 26); stream->format = RMDEMUX_GUINT32_GET (data + offset + 30); stream->extra_data_size = length - (offset + 26); stream->extra_data = (guint8 *) data + offset + 26; /* Natural way to represent framerates here requires unsigned 32 bit * numerator, which we don't have. For the nasty case, approximate... */ { guint32 numerator = RMDEMUX_GUINT16_GET (data + offset + 22) * 65536 + RMDEMUX_GUINT16_GET (data + offset + 24); if (numerator > G_MAXINT) { stream->framerate_numerator = (gint) (numerator >> 1); stream->framerate_denominator = 32768; } else { stream->framerate_numerator = (gint) numerator; stream->framerate_denominator = 65536; } } GST_DEBUG_OBJECT (rmdemux, "Video stream with fourcc=%" GST_FOURCC_FORMAT " width=%d height=%d rate=%d framerate=%d/%d subformat=%x format=%x extra_data_size=%d", GST_FOURCC_ARGS (stream->fourcc), stream->width, stream->height, stream->rate, stream->framerate_numerator, stream->framerate_denominator, stream->subformat, stream->format, stream->extra_data_size); break; case GST_RMDEMUX_STREAM_AUDIO:{ stream->version = RMDEMUX_GUINT16_GET (data + offset + 4); GST_INFO ("stream version = %u", stream->version); switch (stream->version) { case 3: stream->fourcc = GST_RM_AUD_14_4; stream->packet_size = 20; stream->rate = 8000; stream->n_channels = 1; stream->sample_width = 16; stream->flavor = 1; stream->leaf_size = 0; stream->height = 0; break; case 4: stream->flavor = RMDEMUX_GUINT16_GET (data + offset + 22); stream->packet_size = RMDEMUX_GUINT32_GET (data + offset + 24); /* stream->frame_size = RMDEMUX_GUINT32_GET (data + offset + 42); */ stream->leaf_size = RMDEMUX_GUINT16_GET (data + offset + 44); stream->height = RMDEMUX_GUINT16_GET (data + offset + 40); stream->rate = RMDEMUX_GUINT16_GET (data + offset + 48); stream->sample_width = RMDEMUX_GUINT16_GET (data + offset + 52); stream->n_channels = RMDEMUX_GUINT16_GET (data + offset + 54); stream->fourcc = RMDEMUX_FOURCC_GET (data + offset + 62); stream->extra_data_size = RMDEMUX_GUINT32_GET (data + offset + 69); GST_DEBUG_OBJECT (rmdemux, "%u bytes of extra codec data", stream->extra_data_size); if (length - (offset + 73) >= stream->extra_data_size) { stream->extra_data = (guint8 *) data + offset + 73; } else { GST_WARNING_OBJECT (rmdemux, "codec data runs beyond MDPR chunk"); stream->extra_data_size = 0; } break; case 5: stream->flavor = RMDEMUX_GUINT16_GET (data + offset + 22); stream->packet_size = RMDEMUX_GUINT32_GET (data + offset + 24); /* stream->frame_size = RMDEMUX_GUINT32_GET (data + offset + 42); */ stream->leaf_size = RMDEMUX_GUINT16_GET (data + offset + 44); stream->height = RMDEMUX_GUINT16_GET (data + offset + 40); stream->rate = RMDEMUX_GUINT16_GET (data + offset + 54); stream->sample_width = RMDEMUX_GUINT16_GET (data + offset + 58); stream->n_channels = RMDEMUX_GUINT16_GET (data + offset + 60); stream->fourcc = RMDEMUX_FOURCC_GET (data + offset + 66); stream->extra_data_size = RMDEMUX_GUINT32_GET (data + offset + 74); GST_DEBUG_OBJECT (rmdemux, "%u bytes of extra codec data", stream->extra_data_size); if (length - (offset + 78) >= stream->extra_data_size) { stream->extra_data = (guint8 *) data + offset + 78; } else { GST_WARNING_OBJECT (rmdemux, "codec data runs beyond MDPR chunk"); stream->extra_data_size = 0; } break; default:{ GST_WARNING_OBJECT (rmdemux, "Unhandled audio stream version %d", stream->version); break; } } /* 14_4, 28_8, cook, dnet, sipr, raac, racp, ralf, atrc */ GST_DEBUG_OBJECT (rmdemux, "Audio stream with rate=%d sample_width=%d n_channels=%d", stream->rate, stream->sample_width, stream->n_channels); break; } case GST_RMDEMUX_STREAM_FILEINFO: { int element_nb; /* Length of this section */ GST_DEBUG_OBJECT (rmdemux, "length2: 0x%08x", RMDEMUX_GUINT32_GET (data + offset)); offset += 4; /* Unknown : 00 00 00 00 */ offset += 4; /* Number of variables that would follow (loop iterations) */ element_nb = RMDEMUX_GUINT32_GET (data + offset); offset += 4; while (element_nb) { /* Category Id : 00 00 00 XX 00 00 */ offset += 6; /* Variable Name */ offset += re_skip_pascal_string (data + offset); /* Variable Value Type */ /* 00 00 00 00 00 => integer/boolean, preceded by length */ /* 00 00 00 02 00 => pascal string, preceded by length, no trailing \0 */ offset += 5; /* Variable Value */ offset += re_skip_pascal_string (data + offset); element_nb--; } } break; case GST_RMDEMUX_STREAM_UNKNOWN: default: break; } gst_rmdemux_add_stream (rmdemux, stream); } static guint gst_rmdemux_parse_indx (GstRMDemux * rmdemux, const guint8 * data, int length) { int n; int id; n = RMDEMUX_GUINT32_GET (data); id = RMDEMUX_GUINT16_GET (data + 4); rmdemux->index_offset = RMDEMUX_GUINT32_GET (data + 6); GST_DEBUG_OBJECT (rmdemux, "Number of indices=%d Stream ID=%d length=%d", n, id, length); /* Point to the next index_stream */ rmdemux->index_stream = gst_rmdemux_get_stream_by_id (rmdemux, id); /* Return the length of the index */ return 14 * n; } static void gst_rmdemux_parse_indx_data (GstRMDemux * rmdemux, const guint8 * data, int length) { int i; int n; GstRMDemuxIndex *index; /* The number of index records */ n = length / 14; if (rmdemux->index_stream == NULL) return; /* don't parse the index a second time when operating pull-based and * reaching the end of the file */ if (rmdemux->index_stream->index_length > 0) { GST_DEBUG_OBJECT (rmdemux, "Already have an index for this stream"); return; } index = g_malloc (sizeof (GstRMDemuxIndex) * n); rmdemux->index_stream->index = index; rmdemux->index_stream->index_length = n; for (i = 0; i < n; i++) { index[i].timestamp = RMDEMUX_GUINT32_GET (data + 2) * GST_MSECOND; index[i].offset = RMDEMUX_GUINT32_GET (data + 6); GST_DEBUG_OBJECT (rmdemux, "Index found for timestamp=%f (at offset=%x)", gst_guint64_to_gdouble (index[i].timestamp) / GST_SECOND, index[i].offset); data += 14; } } static void gst_rmdemux_parse_data (GstRMDemux * rmdemux, const guint8 * data, int length) { rmdemux->n_chunks = RMDEMUX_GUINT32_GET (data); rmdemux->data_offset = RMDEMUX_GUINT32_GET (data + 4); rmdemux->chunk_index = 0; GST_DEBUG_OBJECT (rmdemux, "Data chunk found with %d packets " "(next data at 0x%08x)", rmdemux->n_chunks, rmdemux->data_offset); } static void gst_rmdemux_parse_cont (GstRMDemux * rmdemux, const guint8 * data, int length) { GstTagList *tags; tags = gst_rm_utils_read_tags (data, length, gst_rm_utils_read_string16); if (tags) { GstTagList *old_tags = rmdemux->pending_tags; GST_LOG_OBJECT (rmdemux, "tags: %" GST_PTR_FORMAT, tags); rmdemux->pending_tags = gst_tag_list_merge (old_tags, tags, GST_TAG_MERGE_APPEND); gst_tag_list_unref (tags); if (old_tags) gst_tag_list_unref (old_tags); gst_tag_list_set_scope (rmdemux->pending_tags, GST_TAG_SCOPE_GLOBAL); } } static void gst_rmdemux_stream_clear_cached_subpackets (GstRMDemux * rmdemux, GstRMDemuxStream * stream) { if (stream->subpackets == NULL || stream->subpackets->len == 0) return; GST_DEBUG_OBJECT (rmdemux, "discarding %u previously collected subpackets", stream->subpackets->len); g_ptr_array_foreach (stream->subpackets, (GFunc) gst_mini_object_unref, NULL); g_ptr_array_set_size (stream->subpackets, 0); } static GstFlowReturn gst_rmdemux_descramble_audio (GstRMDemux * rmdemux, GstRMDemuxStream * stream) { GstFlowReturn ret = GST_FLOW_ERROR; GstBuffer *outbuf; GstMapInfo outmap; guint packet_size = stream->packet_size; guint height = stream->subpackets->len; guint leaf_size = stream->leaf_size; guint size; guint p, x; g_assert (stream->height == height); GST_LOG_OBJECT (rmdemux, "packet_size = %u, leaf_size = %u, height= %u", packet_size, leaf_size, height); if (!g_uint_checked_mul (&size, height, packet_size)) { GST_ERROR_OBJECT (rmdemux, "overflowing audio packet size"); return GST_FLOW_ERROR; } outbuf = gst_buffer_new_and_alloc (size); gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE); for (p = 0; p < height; ++p) { GstBuffer *b = g_ptr_array_index (stream->subpackets, p); GstMapInfo map; gst_buffer_map (b, &map, GST_MAP_READ); if (p == 0) { GST_BUFFER_PTS (outbuf) = GST_BUFFER_PTS (b); GST_BUFFER_DTS (outbuf) = GST_BUFFER_DTS (b); } for (x = 0; x < packet_size / leaf_size; ++x) { guint idx; idx = height * x + ((height + 1) / 2) * (p % 2) + (p / 2); /* GST_LOG ("%3u => %3u", (height * p) + x, idx); */ memcpy (outmap.data + leaf_size * idx, map.data + leaf_size * x, leaf_size); } gst_buffer_unmap (b, &map); } gst_buffer_unmap (outbuf, &outmap); /* some decoders, such as realaudiodec, need to be fed in packet units */ for (p = 0; p < height; ++p) { GstBuffer *subbuf; subbuf = gst_buffer_copy_region (outbuf, GST_BUFFER_COPY_ALL, p * packet_size, packet_size); GST_LOG_OBJECT (rmdemux, "pushing buffer dts %" GST_TIME_FORMAT ", pts %" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_DTS (subbuf)), GST_TIME_ARGS (GST_BUFFER_PTS (subbuf))); if (stream->discont) { GST_BUFFER_FLAG_SET (subbuf, GST_BUFFER_FLAG_DISCONT); stream->discont = FALSE; } ret = gst_pad_push (stream->pad, subbuf); if (ret != GST_FLOW_OK) break; } gst_buffer_unref (outbuf); gst_rmdemux_stream_clear_cached_subpackets (rmdemux, stream); return ret; } static GstFlowReturn gst_rmdemux_descramble_dnet_audio (GstRMDemux * rmdemux, GstRMDemuxStream * stream) { GstBuffer *buf; buf = g_ptr_array_index (stream->subpackets, 0); g_ptr_array_index (stream->subpackets, 0) = NULL; g_ptr_array_set_size (stream->subpackets, 0); buf = gst_rm_utils_descramble_dnet_buffer (buf); if (stream->discont) { GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT); stream->discont = FALSE; } return gst_pad_push (stream->pad, buf); } static GstFlowReturn gst_rmdemux_descramble_mp4a_audio (GstRMDemux * rmdemux, GstRMDemuxStream * stream) { GstFlowReturn res; GstBuffer *buf, *outbuf; guint frames, index, i; GstMapInfo map; GstClockTime timestamp; res = GST_FLOW_OK; buf = g_ptr_array_index (stream->subpackets, 0); g_ptr_array_index (stream->subpackets, 0) = NULL; g_ptr_array_set_size (stream->subpackets, 0); gst_buffer_map (buf, &map, GST_MAP_READ); timestamp = GST_BUFFER_PTS (buf); frames = (map.data[1] & 0xf0) >> 4; index = 2 * frames + 2; for (i = 0; i < frames; i++) { guint len = (map.data[i * 2 + 2] << 8) | map.data[i * 2 + 3]; outbuf = gst_buffer_copy_region (buf, GST_BUFFER_COPY_ALL, index, len); if (i == 0) { GST_BUFFER_PTS (outbuf) = timestamp; GST_BUFFER_DTS (outbuf) = timestamp; } index += len; if (stream->discont) { GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT); stream->discont = FALSE; } res = gst_pad_push (stream->pad, outbuf); if (res != GST_FLOW_OK) break; } gst_buffer_unmap (buf, &map); gst_buffer_unref (buf); return res; } static GstFlowReturn gst_rmdemux_descramble_sipr_audio (GstRMDemux * rmdemux, GstRMDemuxStream * stream) { GstFlowReturn ret; GstBuffer *outbuf; GstMapInfo outmap; guint packet_size = stream->packet_size; guint height = stream->subpackets->len; guint size; guint p; g_assert (stream->height == height); GST_LOG_OBJECT (rmdemux, "packet_size = %u, leaf_size = %u, height= %u", packet_size, stream->leaf_size, height); if (!g_uint_checked_mul (&size, height, packet_size)) { GST_ERROR_OBJECT (rmdemux, "overflowing SIPR audio packet size"); return GST_FLOW_ERROR; } outbuf = gst_buffer_new_and_alloc (size); gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE); for (p = 0; p < height; ++p) { GstBuffer *b = g_ptr_array_index (stream->subpackets, p); if (p == 0) { GST_BUFFER_DTS (outbuf) = GST_BUFFER_DTS (b); GST_BUFFER_PTS (outbuf) = GST_BUFFER_PTS (b); } if (gst_buffer_extract (b, 0, outmap.data + packet_size * p, packet_size) != packet_size) { GST_ERROR_OBJECT (rmdemux, "not enough SIPR audio data available"); gst_buffer_unmap (outbuf, &outmap); gst_buffer_unref (outbuf); return GST_FLOW_ERROR; } } gst_buffer_unmap (outbuf, &outmap); GST_LOG_OBJECT (rmdemux, "pushing buffer dts %" GST_TIME_FORMAT ", pts %" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_DTS (outbuf)), GST_TIME_ARGS (GST_BUFFER_PTS (outbuf))); if (stream->discont) { GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT); stream->discont = FALSE; } outbuf = gst_rm_utils_descramble_sipr_buffer (outbuf); ret = gst_pad_push (stream->pad, outbuf); gst_rmdemux_stream_clear_cached_subpackets (rmdemux, stream); return ret; } static GstFlowReturn gst_rmdemux_handle_scrambled_packet (GstRMDemux * rmdemux, GstRMDemuxStream * stream, GstBuffer * buf, gboolean keyframe) { GstFlowReturn ret; if (stream->subpackets == NULL) stream->subpackets = g_ptr_array_sized_new (stream->subpackets_needed); GST_LOG ("Got subpacket %u/%u, len=%" G_GSIZE_FORMAT ", key=%d", stream->subpackets->len + 1, stream->subpackets_needed, gst_buffer_get_size (buf), keyframe); if (keyframe && stream->subpackets->len > 0) { gst_rmdemux_stream_clear_cached_subpackets (rmdemux, stream); } g_ptr_array_add (stream->subpackets, buf); if (stream->subpackets->len < stream->subpackets_needed) return GST_FLOW_OK; g_assert (stream->subpackets->len >= 1); switch (stream->fourcc) { case GST_RM_AUD_DNET: ret = gst_rmdemux_descramble_dnet_audio (rmdemux, stream); break; case GST_RM_AUD_COOK: case GST_RM_AUD_ATRC: ret = gst_rmdemux_descramble_audio (rmdemux, stream); break; case GST_RM_AUD_RAAC: case GST_RM_AUD_RACP: ret = gst_rmdemux_descramble_mp4a_audio (rmdemux, stream); break; case GST_RM_AUD_SIPR: ret = gst_rmdemux_descramble_sipr_audio (rmdemux, stream); break; default: ret = GST_FLOW_ERROR; g_assert_not_reached (); } return ret; } #define PARSE_NUMBER(data, size, number, label) \ G_STMT_START { \ if (size < 2) \ goto label; \ number = GST_READ_UINT16_BE (data); \ if (!(number & 0xc000)) { \ if (size < 4) \ goto label; \ number = GST_READ_UINT32_BE (data); \ data += 4; \ size -= 4; \ } else { \ number &= 0x3fff; \ data += 2; \ size -= 2; \ } \ } G_STMT_END static GstFlowReturn gst_rmdemux_parse_video_packet (GstRMDemux * rmdemux, GstRMDemuxStream * stream, GstBuffer * in, guint offset, guint16 version, GstClockTime timestamp, gboolean key) { GstFlowReturn ret; GstMapInfo map; const guint8 *data; gsize size; gst_buffer_map (in, &map, GST_MAP_READ); if (map.size < offset) goto not_enough_data; data = map.data + offset; size = map.size - offset; /* if size <= 2, we want this method to return the same GstFlowReturn as it * was previously for that given stream. */ ret = GST_PAD_LAST_FLOW_RETURN (stream->pad); while (size > 2) { guint8 pkg_header; guint pkg_offset; guint pkg_length; guint pkg_subseq = 0, pkg_seqnum = G_MAXUINT; guint fragment_size; GstBuffer *fragment; pkg_header = *data++; size--; /* packet header * bit 7: 1=last block in block chain * bit 6: 1=short header (only one block?) */ if ((pkg_header & 0xc0) == 0x40) { /* skip unknown byte */ data++; size--; pkg_offset = 0; pkg_length = size; } else { if ((pkg_header & 0x40) == 0) { pkg_subseq = (*data++) & 0x7f; size--; } else { pkg_subseq = 0; } /* length */ PARSE_NUMBER (data, size, pkg_length, not_enough_data); /* offset */ PARSE_NUMBER (data, size, pkg_offset, not_enough_data); /* seqnum */ if (size < 1) goto not_enough_data; pkg_seqnum = *data++; size--; } GST_DEBUG_OBJECT (rmdemux, "seq %d, subseq %d, offset %d, length %d, size %" G_GSIZE_FORMAT ", header %02x", pkg_seqnum, pkg_subseq, pkg_offset, pkg_length, size, pkg_header); /* calc size of fragment */ if ((pkg_header & 0xc0) == 0x80) { fragment_size = pkg_offset; } else { if ((pkg_header & 0xc0) == 0) fragment_size = size; else fragment_size = pkg_length; } GST_DEBUG_OBJECT (rmdemux, "fragment size %d", fragment_size); if (fragment_size > map.size || (data - map.data) > map.size - fragment_size) goto not_enough_data; /* get the fragment */ fragment = gst_buffer_copy_region (in, GST_BUFFER_COPY_ALL, data - map.data, fragment_size); if (pkg_subseq == 1) { GST_DEBUG_OBJECT (rmdemux, "start new fragment"); gst_adapter_clear (stream->adapter); stream->frag_current = 0; stream->frag_count = 0; stream->frag_length = pkg_length; } else if (pkg_subseq == 0) { GST_DEBUG_OBJECT (rmdemux, "non fragmented packet"); stream->frag_current = 0; stream->frag_count = 0; stream->frag_length = fragment_size; } if (stream->frag_count >= MAX_FRAGS) { gst_buffer_unref (fragment); goto too_many_fragments; } /* put fragment in adapter */ gst_adapter_push (stream->adapter, fragment); stream->frag_offset[stream->frag_count] = stream->frag_current; stream->frag_current += fragment_size; stream->frag_count++; GST_DEBUG_OBJECT (rmdemux, "stored fragment in adapter %d/%d", stream->frag_current, stream->frag_length); /* flush fragment when complete */ if (stream->frag_current >= stream->frag_length) { GstBuffer *out; GstMapInfo outmap; guint8 *outdata; guint header_size; gint i, avail; /* calculate header size, which is: * 1 byte for the number of fragments - 1 * for each fragment: * 4 bytes 0x00000001 little endian * 4 bytes fragment offset * * This is also the matroska header for realvideo, the decoder needs the * fragment offsets, both in ffmpeg and real .so, so we just give it that * in front of the data. */ header_size = 1 + (8 * (stream->frag_count)); GST_DEBUG_OBJECT (rmdemux, "fragmented completed. count %d, header_size %u", stream->frag_count, header_size); avail = gst_adapter_available (stream->adapter); out = gst_buffer_new_and_alloc (header_size + avail); gst_buffer_map (out, &outmap, GST_MAP_WRITE); outdata = outmap.data; /* create header */ *outdata++ = stream->frag_count - 1; for (i = 0; i < stream->frag_count; i++) { GST_WRITE_UINT32_LE (outdata, 0x00000001); outdata += 4; GST_WRITE_UINT32_LE (outdata, stream->frag_offset[i]); outdata += 4; } /* copy packet data after the header now */ gst_adapter_copy (stream->adapter, outdata, 0, avail); gst_adapter_flush (stream->adapter, avail); stream->frag_current = 0; stream->frag_count = 0; stream->frag_length = 0; if (timestamp != -1) { if (rmdemux->first_ts != -1 && timestamp > rmdemux->first_ts) timestamp -= rmdemux->first_ts; else timestamp = 0; if (rmdemux->base_ts != -1) timestamp += rmdemux->base_ts; } gst_buffer_unmap (out, &outmap); /* video has DTS */ GST_BUFFER_DTS (out) = timestamp; GST_BUFFER_PTS (out) = GST_CLOCK_TIME_NONE; GST_LOG_OBJECT (rmdemux, "pushing timestamp %" GST_TIME_FORMAT, GST_TIME_ARGS (timestamp)); if (stream->discont) { GST_BUFFER_FLAG_SET (out, GST_BUFFER_FLAG_DISCONT); stream->discont = FALSE; } if (!key) { GST_BUFFER_FLAG_SET (out, GST_BUFFER_FLAG_DELTA_UNIT); } ret = gst_pad_push (stream->pad, out); ret = gst_flow_combiner_update_flow (rmdemux->flowcombiner, ret); if (ret != GST_FLOW_OK) break; timestamp = GST_CLOCK_TIME_NONE; } data += fragment_size; size -= fragment_size; } GST_DEBUG_OBJECT (rmdemux, "%" G_GSIZE_FORMAT " bytes left", size); done: gst_buffer_unmap (in, &map); gst_buffer_unref (in); return ret; /* ERRORS */ not_enough_data: { GST_ELEMENT_WARNING (rmdemux, STREAM, DECODE, ("Skipping bad packet."), (NULL)); ret = GST_FLOW_OK; goto done; } too_many_fragments: { GST_ELEMENT_ERROR (rmdemux, STREAM, DECODE, ("Got more fragments (%u) than can be handled (%u)", stream->frag_count, MAX_FRAGS), (NULL)); ret = GST_FLOW_ERROR; goto done; } } static GstFlowReturn gst_rmdemux_parse_audio_packet (GstRMDemux * rmdemux, GstRMDemuxStream * stream, GstBuffer * in, guint offset, guint16 version, GstClockTime timestamp, gboolean key) { GstFlowReturn ret; GstBuffer *buffer; if (gst_buffer_get_size (in) < offset) goto not_enough_data; buffer = gst_buffer_copy_region (in, GST_BUFFER_COPY_MEMORY, offset, -1); if (rmdemux->first_ts != -1 && timestamp > rmdemux->first_ts) timestamp -= rmdemux->first_ts; else timestamp = 0; if (rmdemux->base_ts != -1) timestamp += rmdemux->base_ts; GST_BUFFER_PTS (buffer) = timestamp; GST_BUFFER_DTS (buffer) = timestamp; if (stream->needs_descrambling) { GST_LOG_OBJECT (rmdemux, "descramble timestamp %" GST_TIME_FORMAT, GST_TIME_ARGS (timestamp)); ret = gst_rmdemux_handle_scrambled_packet (rmdemux, stream, buffer, key); } else { GST_LOG_OBJECT (rmdemux, "Pushing buffer of size %" G_GSIZE_FORMAT ", timestamp %" GST_TIME_FORMAT "to pad %s", gst_buffer_get_size (buffer), GST_TIME_ARGS (timestamp), GST_PAD_NAME (stream->pad)); if (stream->discont) { GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT); stream->discont = FALSE; } ret = gst_pad_push (stream->pad, buffer); } done: gst_buffer_unref (in); return ret; /* ERRORS */ not_enough_data: { GST_ELEMENT_WARNING (rmdemux, STREAM, DECODE, ("Skipping bad packet."), (NULL)); ret = GST_FLOW_OK; goto done; } } static GstFlowReturn gst_rmdemux_parse_packet (GstRMDemux * rmdemux, GstBuffer * in, guint16 version) { guint16 id; GstRMDemuxStream *stream; gsize size, offset; GstFlowReturn cret, ret; GstClockTime timestamp; gboolean key; GstMapInfo map; guint8 *data; guint8 flags; guint32 ts; gst_buffer_map (in, &map, GST_MAP_READ); data = map.data; size = map.size; if (size < 2 + 4 + 2) goto not_enough_data; /* stream number */ id = RMDEMUX_GUINT16_GET (data); stream = gst_rmdemux_get_stream_by_id (rmdemux, id); if (!stream || !stream->pad) goto unknown_stream; /* timestamp in Msec */ ts = RMDEMUX_GUINT32_GET (data + 2); timestamp = ts * GST_MSECOND; rmdemux->segment.position = timestamp; GST_LOG_OBJECT (rmdemux, "Parsing a packet for stream=%d, timestamp=%" GST_TIME_FORMAT ", size %" G_GSIZE_FORMAT ", version=%d, ts=%u", id, GST_TIME_ARGS (timestamp), size, version, ts); if (rmdemux->first_ts == GST_CLOCK_TIME_NONE) { GST_DEBUG_OBJECT (rmdemux, "First timestamp: %" GST_TIME_FORMAT, GST_TIME_ARGS (timestamp)); rmdemux->first_ts = timestamp; } /* skip stream_id and timestamp */ data += (2 + 4); size -= (2 + 4); /* get flags */ flags = GST_READ_UINT8 (data + 1); data += 2; size -= 2; /* version 1 has an extra byte */ if (version == 1) { if (size < 1) goto not_enough_data; data += 1; size -= 1; } offset = data - map.data; gst_buffer_unmap (in, &map); key = (flags & 0x02) != 0; GST_DEBUG_OBJECT (rmdemux, "flags %d, Keyframe %d", flags, key); if (rmdemux->need_newsegment) { GstEvent *event; event = gst_event_new_segment (&rmdemux->segment); GST_DEBUG_OBJECT (rmdemux, "sending NEWSEGMENT event, segment.start= %" GST_TIME_FORMAT, GST_TIME_ARGS (rmdemux->segment.start)); gst_rmdemux_send_event (rmdemux, event); rmdemux->need_newsegment = FALSE; if (rmdemux->pending_tags != NULL) { gst_rmdemux_send_event (rmdemux, gst_event_new_tag (rmdemux->pending_tags)); rmdemux->pending_tags = NULL; } } if (stream->pending_tags != NULL) { GST_LOG_OBJECT (stream->pad, "tags %" GST_PTR_FORMAT, stream->pending_tags); gst_pad_push_event (stream->pad, gst_event_new_tag (stream->pending_tags)); stream->pending_tags = NULL; } if ((rmdemux->offset + size) <= stream->seek_offset) { GST_DEBUG_OBJECT (rmdemux, "Stream %d is skipping: seek_offset=%d, offset=%d, size=%" G_GSIZE_FORMAT, stream->id, stream->seek_offset, rmdemux->offset, size); cret = GST_FLOW_OK; gst_buffer_unref (in); goto beach; } /* do special headers */ if (stream->subtype == GST_RMDEMUX_STREAM_VIDEO) { ret = gst_rmdemux_parse_video_packet (rmdemux, stream, in, offset, version, timestamp, key); } else if (stream->subtype == GST_RMDEMUX_STREAM_AUDIO) { ret = gst_rmdemux_parse_audio_packet (rmdemux, stream, in, offset, version, timestamp, key); } else { gst_buffer_unref (in); ret = GST_FLOW_OK; } cret = gst_flow_combiner_update_pad_flow (rmdemux->flowcombiner, stream->pad, ret); beach: return cret; /* ERRORS */ unknown_stream: { GST_WARNING_OBJECT (rmdemux, "No stream for stream id %d in parsing " "data packet", id); gst_buffer_unmap (in, &map); gst_buffer_unref (in); return GST_FLOW_OK; } /* ERRORS */ not_enough_data: { GST_ELEMENT_WARNING (rmdemux, STREAM, DECODE, ("Skipping bad packet."), (NULL)); gst_buffer_unmap (in, &map); gst_buffer_unref (in); return GST_FLOW_OK; } }