| /* GStreamer Matroska muxer/demuxer |
| * (c) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net> |
| * (c) 2006 Tim-Philipp Müller <tim centricular net> |
| * (c) 2008 Sebastian Dröge <slomo@circular-chaos.org> |
| * (c) 2011 Debarshi Ray <rishi@gnu.org> |
| * |
| * matroska-demux.c: matroska file/stream demuxer |
| * |
| * 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. |
| */ |
| |
| /* TODO: check CRC32 if present |
| * TODO: there can be a segment after the first segment. Handle like |
| * chained oggs. Fixes #334082 |
| * TODO: Test samples: http://www.matroska.org/samples/matrix/index.html |
| * http://samples.mplayerhq.hu/Matroska/ |
| * TODO: check if demuxing is done correct for all codecs according to spec |
| * TODO: seeking with incomplete or without CUE |
| */ |
| |
| /** |
| * SECTION:element-matroskademux |
| * |
| * matroskademux demuxes a Matroska file into the different contained streams. |
| * |
| * <refsect2> |
| * <title>Example launch line</title> |
| * |[ |
| * gst-launch-1.0 -v filesrc location=/path/to/mkv ! matroskademux ! vorbisdec ! audioconvert ! audioresample ! autoaudiosink |
| * ]| This pipeline demuxes a Matroska file and outputs the contained Vorbis audio. |
| * </refsect2> |
| */ |
| |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include <math.h> |
| #include <string.h> |
| #include <glib/gprintf.h> |
| |
| /* For AVI compatibility mode |
| and for fourcc stuff */ |
| #include <gst/riff/riff-read.h> |
| #include <gst/riff/riff-ids.h> |
| #include <gst/riff/riff-media.h> |
| |
| #include <gst/audio/audio.h> |
| #include <gst/tag/tag.h> |
| #include <gst/pbutils/pbutils.h> |
| #include <gst/video/video.h> |
| |
| #include "matroska-demux.h" |
| #include "matroska-ids.h" |
| |
| GST_DEBUG_CATEGORY_STATIC (matroskademux_debug); |
| #define GST_CAT_DEFAULT matroskademux_debug |
| |
| #define DEBUG_ELEMENT_START(demux, ebml, element) \ |
| GST_DEBUG_OBJECT (demux, "Parsing " element " element at offset %" \ |
| G_GUINT64_FORMAT, gst_ebml_read_get_pos (ebml)) |
| |
| #define DEBUG_ELEMENT_STOP(demux, ebml, element, ret) \ |
| GST_DEBUG_OBJECT (demux, "Parsing " element " element " \ |
| " finished with '%s'", gst_flow_get_name (ret)) |
| |
| enum |
| { |
| PROP_0, |
| PROP_METADATA, |
| PROP_STREAMINFO, |
| PROP_MAX_GAP_TIME |
| }; |
| |
| #define DEFAULT_MAX_GAP_TIME (2 * GST_SECOND) |
| |
| static GstStaticPadTemplate sink_templ = GST_STATIC_PAD_TEMPLATE ("sink", |
| GST_PAD_SINK, |
| GST_PAD_ALWAYS, |
| GST_STATIC_CAPS ("audio/x-matroska; video/x-matroska; " |
| "video/x-matroska-3d; audio/webm; video/webm") |
| ); |
| |
| /* TODO: fill in caps! */ |
| |
| static GstStaticPadTemplate audio_src_templ = |
| GST_STATIC_PAD_TEMPLATE ("audio_%u", |
| GST_PAD_SRC, |
| GST_PAD_SOMETIMES, |
| GST_STATIC_CAPS ("ANY") |
| ); |
| |
| static GstStaticPadTemplate video_src_templ = |
| GST_STATIC_PAD_TEMPLATE ("video_%u", |
| GST_PAD_SRC, |
| GST_PAD_SOMETIMES, |
| GST_STATIC_CAPS ("ANY") |
| ); |
| |
| static GstStaticPadTemplate subtitle_src_templ = |
| GST_STATIC_PAD_TEMPLATE ("subtitle_%u", |
| GST_PAD_SRC, |
| GST_PAD_SOMETIMES, |
| GST_STATIC_CAPS ("text/x-raw, format=pango-markup; application/x-ssa; " |
| "application/x-ass;application/x-usf; subpicture/x-dvd; " |
| "subpicture/x-pgs; subtitle/x-kate; " "application/x-subtitle-unknown") |
| ); |
| |
| static GstFlowReturn gst_matroska_demux_parse_id (GstMatroskaDemux * demux, |
| guint32 id, guint64 length, guint needed); |
| |
| /* element functions */ |
| static void gst_matroska_demux_loop (GstPad * pad); |
| |
| static gboolean gst_matroska_demux_element_send_event (GstElement * element, |
| GstEvent * event); |
| static gboolean gst_matroska_demux_element_query (GstElement * element, |
| GstQuery * query); |
| |
| /* pad functions */ |
| static gboolean gst_matroska_demux_sink_activate (GstPad * sinkpad, |
| GstObject * parent); |
| static gboolean gst_matroska_demux_sink_activate_mode (GstPad * sinkpad, |
| GstObject * parent, GstPadMode mode, gboolean active); |
| |
| static gboolean gst_matroska_demux_handle_seek_event (GstMatroskaDemux * demux, |
| GstPad * pad, GstEvent * event); |
| static gboolean gst_matroska_demux_handle_src_event (GstPad * pad, |
| GstObject * parent, GstEvent * event); |
| static gboolean gst_matroska_demux_handle_src_query (GstPad * pad, |
| GstObject * parent, GstQuery * query); |
| |
| static gboolean gst_matroska_demux_handle_sink_event (GstPad * pad, |
| GstObject * parent, GstEvent * event); |
| static GstFlowReturn gst_matroska_demux_chain (GstPad * pad, |
| GstObject * object, GstBuffer * buffer); |
| |
| static GstStateChangeReturn |
| gst_matroska_demux_change_state (GstElement * element, |
| GstStateChange transition); |
| #if 0 |
| static void |
| gst_matroska_demux_set_index (GstElement * element, GstIndex * index); |
| static GstIndex *gst_matroska_demux_get_index (GstElement * element); |
| #endif |
| |
| /* caps functions */ |
| static GstCaps *gst_matroska_demux_video_caps (GstMatroskaTrackVideoContext |
| * videocontext, const gchar * codec_id, guint8 * data, guint size, |
| gchar ** codec_name, guint32 * riff_fourcc); |
| static GstCaps *gst_matroska_demux_audio_caps (GstMatroskaTrackAudioContext |
| * audiocontext, const gchar * codec_id, guint8 * data, guint size, |
| gchar ** codec_name, guint16 * riff_audio_fmt); |
| static GstCaps |
| * gst_matroska_demux_subtitle_caps (GstMatroskaTrackSubtitleContext * |
| subtitlecontext, const gchar * codec_id, gpointer data, guint size); |
| |
| /* stream methods */ |
| static void gst_matroska_demux_reset (GstElement * element); |
| static gboolean perform_seek_to_offset (GstMatroskaDemux * demux, |
| gdouble rate, guint64 offset, guint32 seqnum, GstSeekFlags flags); |
| |
| /* gobject functions */ |
| static void gst_matroska_demux_set_property (GObject * object, |
| guint prop_id, const GValue * value, GParamSpec * pspec); |
| static void gst_matroska_demux_get_property (GObject * object, |
| guint prop_id, GValue * value, GParamSpec * pspec); |
| |
| GType gst_matroska_demux_get_type (void); |
| #define parent_class gst_matroska_demux_parent_class |
| G_DEFINE_TYPE (GstMatroskaDemux, gst_matroska_demux, GST_TYPE_ELEMENT); |
| |
| static void |
| gst_matroska_demux_finalize (GObject * object) |
| { |
| GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (object); |
| |
| gst_matroska_read_common_finalize (&demux->common); |
| gst_flow_combiner_free (demux->flowcombiner); |
| G_OBJECT_CLASS (parent_class)->finalize (object); |
| } |
| |
| static void |
| gst_matroska_demux_class_init (GstMatroskaDemuxClass * klass) |
| { |
| GObjectClass *gobject_class = (GObjectClass *) klass; |
| GstElementClass *gstelement_class = (GstElementClass *) klass; |
| |
| GST_DEBUG_CATEGORY_INIT (matroskademux_debug, "matroskademux", 0, |
| "Matroska demuxer"); |
| |
| gobject_class->finalize = gst_matroska_demux_finalize; |
| |
| gobject_class->get_property = gst_matroska_demux_get_property; |
| gobject_class->set_property = gst_matroska_demux_set_property; |
| |
| g_object_class_install_property (gobject_class, PROP_MAX_GAP_TIME, |
| g_param_spec_uint64 ("max-gap-time", "Maximum gap time", |
| "The demuxer sends out segment events for skipping " |
| "gaps longer than this (0 = disabled).", 0, G_MAXUINT64, |
| DEFAULT_MAX_GAP_TIME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); |
| |
| gstelement_class->change_state = |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_change_state); |
| gstelement_class->send_event = |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_element_send_event); |
| gstelement_class->query = |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_element_query); |
| #if 0 |
| gstelement_class->set_index = |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_set_index); |
| gstelement_class->get_index = |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_get_index); |
| #endif |
| |
| gst_element_class_add_static_pad_template (gstelement_class, |
| &video_src_templ); |
| gst_element_class_add_static_pad_template (gstelement_class, |
| &audio_src_templ); |
| gst_element_class_add_static_pad_template (gstelement_class, |
| &subtitle_src_templ); |
| gst_element_class_add_static_pad_template (gstelement_class, &sink_templ); |
| |
| gst_element_class_set_static_metadata (gstelement_class, "Matroska demuxer", |
| "Codec/Demuxer", |
| "Demuxes Matroska/WebM streams into video/audio/subtitles", |
| "GStreamer maintainers <gstreamer-devel@lists.freedesktop.org>"); |
| } |
| |
| static void |
| gst_matroska_demux_init (GstMatroskaDemux * demux) |
| { |
| demux->common.sinkpad = gst_pad_new_from_static_template (&sink_templ, |
| "sink"); |
| gst_pad_set_activate_function (demux->common.sinkpad, |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_sink_activate)); |
| gst_pad_set_activatemode_function (demux->common.sinkpad, |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_sink_activate_mode)); |
| gst_pad_set_chain_function (demux->common.sinkpad, |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_chain)); |
| gst_pad_set_event_function (demux->common.sinkpad, |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_sink_event)); |
| gst_element_add_pad (GST_ELEMENT (demux), demux->common.sinkpad); |
| |
| /* init defaults for common read context */ |
| gst_matroska_read_common_init (&demux->common); |
| |
| /* property defaults */ |
| demux->max_gap_time = DEFAULT_MAX_GAP_TIME; |
| |
| GST_OBJECT_FLAG_SET (demux, GST_ELEMENT_FLAG_INDEXABLE); |
| |
| demux->flowcombiner = gst_flow_combiner_new (); |
| |
| /* finish off */ |
| gst_matroska_demux_reset (GST_ELEMENT (demux)); |
| } |
| |
| static void |
| gst_matroska_demux_reset (GstElement * element) |
| { |
| GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element); |
| |
| GST_DEBUG_OBJECT (demux, "Resetting state"); |
| |
| gst_matroska_read_common_reset (GST_ELEMENT (demux), &demux->common); |
| |
| demux->num_a_streams = 0; |
| demux->num_t_streams = 0; |
| demux->num_v_streams = 0; |
| |
| demux->have_group_id = FALSE; |
| demux->group_id = G_MAXUINT; |
| |
| demux->clock = NULL; |
| demux->tracks_parsed = FALSE; |
| |
| if (demux->clusters) { |
| g_array_free (demux->clusters, TRUE); |
| demux->clusters = NULL; |
| } |
| |
| g_list_foreach (demux->seek_parsed, |
| (GFunc) gst_matroska_read_common_free_parsed_el, NULL); |
| g_list_free (demux->seek_parsed); |
| demux->seek_parsed = NULL; |
| |
| demux->last_stop_end = GST_CLOCK_TIME_NONE; |
| demux->seek_block = 0; |
| demux->stream_start_time = GST_CLOCK_TIME_NONE; |
| demux->to_time = GST_CLOCK_TIME_NONE; |
| demux->cluster_time = GST_CLOCK_TIME_NONE; |
| demux->cluster_offset = 0; |
| demux->next_cluster_offset = 0; |
| demux->index_offset = 0; |
| demux->seekable = FALSE; |
| demux->need_segment = FALSE; |
| demux->segment_seqnum = 0; |
| demux->requested_seek_time = GST_CLOCK_TIME_NONE; |
| demux->seek_offset = -1; |
| demux->building_index = FALSE; |
| if (demux->seek_event) { |
| gst_event_unref (demux->seek_event); |
| demux->seek_event = NULL; |
| } |
| |
| demux->seek_index = NULL; |
| demux->seek_entry = 0; |
| |
| if (demux->new_segment) { |
| gst_event_unref (demux->new_segment); |
| demux->new_segment = NULL; |
| } |
| |
| demux->invalid_duration = FALSE; |
| |
| demux->cached_length = G_MAXUINT64; |
| |
| gst_flow_combiner_clear (demux->flowcombiner); |
| } |
| |
| static GstBuffer * |
| gst_matroska_decode_buffer (GstMatroskaTrackContext * context, GstBuffer * buf) |
| { |
| GstMapInfo map; |
| gpointer data; |
| gsize size; |
| |
| g_return_val_if_fail (GST_IS_BUFFER (buf), NULL); |
| |
| GST_DEBUG ("decoding buffer %p", buf); |
| |
| gst_buffer_map (buf, &map, GST_MAP_READ); |
| data = map.data; |
| size = map.size; |
| |
| g_return_val_if_fail (size > 0, buf); |
| |
| if (gst_matroska_decode_data (context->encodings, &data, &size, |
| GST_MATROSKA_TRACK_ENCODING_SCOPE_FRAME, FALSE)) { |
| gst_buffer_unmap (buf, &map); |
| gst_buffer_unref (buf); |
| return gst_buffer_new_wrapped (data, size); |
| } else { |
| GST_DEBUG ("decode data failed"); |
| gst_buffer_unmap (buf, &map); |
| gst_buffer_unref (buf); |
| return NULL; |
| } |
| } |
| |
| static void |
| gst_matroska_demux_add_stream_headers_to_caps (GstMatroskaDemux * demux, |
| GstBufferList * list, GstCaps * caps) |
| { |
| GstStructure *s; |
| GValue arr_val = G_VALUE_INIT; |
| GValue buf_val = G_VALUE_INIT; |
| gint i, num; |
| |
| g_assert (gst_caps_is_writable (caps)); |
| |
| g_value_init (&arr_val, GST_TYPE_ARRAY); |
| g_value_init (&buf_val, GST_TYPE_BUFFER); |
| |
| num = gst_buffer_list_length (list); |
| for (i = 0; i < num; ++i) { |
| g_value_set_boxed (&buf_val, gst_buffer_list_get (list, i)); |
| gst_value_array_append_value (&arr_val, &buf_val); |
| } |
| |
| s = gst_caps_get_structure (caps, 0); |
| gst_structure_take_value (s, "streamheader", &arr_val); |
| g_value_unset (&buf_val); |
| } |
| |
| static GstFlowReturn |
| gst_matroska_demux_add_stream (GstMatroskaDemux * demux, GstEbmlRead * ebml) |
| { |
| GstElementClass *klass = GST_ELEMENT_GET_CLASS (demux); |
| GstMatroskaTrackContext *context; |
| GstPadTemplate *templ = NULL; |
| GstStreamFlags stream_flags; |
| GstCaps *caps = NULL; |
| GstTagList *cached_taglist; |
| gchar *padname = NULL; |
| GstFlowReturn ret; |
| guint32 id, riff_fourcc = 0; |
| guint16 riff_audio_fmt = 0; |
| GstEvent *stream_start; |
| gchar *codec = NULL; |
| gchar *stream_id; |
| |
| DEBUG_ELEMENT_START (demux, ebml, "TrackEntry"); |
| |
| /* start with the master */ |
| if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) { |
| DEBUG_ELEMENT_STOP (demux, ebml, "TrackEntry", ret); |
| return ret; |
| } |
| |
| /* allocate generic... if we know the type, we'll g_renew() |
| * with the precise type */ |
| context = g_new0 (GstMatroskaTrackContext, 1); |
| g_ptr_array_add (demux->common.src, context); |
| context->index = demux->common.num_streams; |
| context->index_writer_id = -1; |
| context->type = 0; /* no type yet */ |
| context->default_duration = 0; |
| context->pos = 0; |
| context->set_discont = TRUE; |
| context->timecodescale = 1.0; |
| context->flags = |
| GST_MATROSKA_TRACK_ENABLED | GST_MATROSKA_TRACK_DEFAULT | |
| GST_MATROSKA_TRACK_LACING; |
| context->from_time = GST_CLOCK_TIME_NONE; |
| context->from_offset = -1; |
| context->to_offset = G_MAXINT64; |
| context->alignment = 1; |
| context->dts_only = FALSE; |
| context->intra_only = FALSE; |
| context->tags = gst_tag_list_new_empty (); |
| demux->common.num_streams++; |
| g_assert (demux->common.src->len == demux->common.num_streams); |
| |
| GST_DEBUG_OBJECT (demux, "Stream number %d", context->index); |
| |
| /* try reading the trackentry headers */ |
| while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) { |
| if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK) |
| break; |
| |
| switch (id) { |
| /* track number (unique stream ID) */ |
| case GST_MATROSKA_ID_TRACKNUMBER:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num == 0) { |
| GST_ERROR_OBJECT (demux, "Invalid TrackNumber 0"); |
| ret = GST_FLOW_ERROR; |
| break; |
| } else if (!gst_matroska_read_common_tracknumber_unique (&demux->common, |
| num)) { |
| GST_ERROR_OBJECT (demux, "TrackNumber %" G_GUINT64_FORMAT |
| " is not unique", num); |
| ret = GST_FLOW_ERROR; |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "TrackNumber: %" G_GUINT64_FORMAT, num); |
| context->num = num; |
| break; |
| } |
| /* track UID (unique identifier) */ |
| case GST_MATROSKA_ID_TRACKUID:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num == 0) { |
| GST_ERROR_OBJECT (demux, "Invalid TrackUID 0"); |
| ret = GST_FLOW_ERROR; |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "TrackUID: %" G_GUINT64_FORMAT, num); |
| context->uid = num; |
| break; |
| } |
| |
| /* track type (video, audio, combined, subtitle, etc.) */ |
| case GST_MATROSKA_ID_TRACKTYPE:{ |
| guint64 track_type; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &track_type)) != GST_FLOW_OK) { |
| break; |
| } |
| |
| if (context->type != 0 && context->type != track_type) { |
| GST_WARNING_OBJECT (demux, |
| "More than one tracktype defined in a TrackEntry - skipping"); |
| break; |
| } else if (track_type < 1 || track_type > 254) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackType %" G_GUINT64_FORMAT, |
| track_type); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "TrackType: %" G_GUINT64_FORMAT, track_type); |
| |
| /* ok, so we're actually going to reallocate this thing */ |
| switch (track_type) { |
| case GST_MATROSKA_TRACK_TYPE_VIDEO: |
| gst_matroska_track_init_video_context (&context); |
| break; |
| case GST_MATROSKA_TRACK_TYPE_AUDIO: |
| gst_matroska_track_init_audio_context (&context); |
| break; |
| case GST_MATROSKA_TRACK_TYPE_SUBTITLE: |
| gst_matroska_track_init_subtitle_context (&context); |
| break; |
| case GST_MATROSKA_TRACK_TYPE_COMPLEX: |
| case GST_MATROSKA_TRACK_TYPE_LOGO: |
| case GST_MATROSKA_TRACK_TYPE_BUTTONS: |
| case GST_MATROSKA_TRACK_TYPE_CONTROL: |
| default: |
| GST_WARNING_OBJECT (demux, |
| "Unknown or unsupported TrackType %" G_GUINT64_FORMAT, |
| track_type); |
| context->type = 0; |
| break; |
| } |
| g_ptr_array_index (demux->common.src, demux->common.num_streams - 1) |
| = context; |
| break; |
| } |
| |
| /* tracktype specific stuff for video */ |
| case GST_MATROSKA_ID_TRACKVIDEO:{ |
| GstMatroskaTrackVideoContext *videocontext; |
| |
| DEBUG_ELEMENT_START (demux, ebml, "TrackVideo"); |
| |
| if (!gst_matroska_track_init_video_context (&context)) { |
| GST_WARNING_OBJECT (demux, |
| "TrackVideo element in non-video track - ignoring track"); |
| ret = GST_FLOW_ERROR; |
| break; |
| } else if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) { |
| break; |
| } |
| videocontext = (GstMatroskaTrackVideoContext *) context; |
| g_ptr_array_index (demux->common.src, demux->common.num_streams - 1) |
| = context; |
| |
| while (ret == GST_FLOW_OK && |
| gst_ebml_read_has_remaining (ebml, 1, TRUE)) { |
| if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK) |
| break; |
| |
| switch (id) { |
| /* Should be one level up but some broken muxers write it here. */ |
| case GST_MATROSKA_ID_TRACKDEFAULTDURATION:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num == 0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackDefaultDuration 0"); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, |
| "TrackDefaultDuration: %" G_GUINT64_FORMAT, num); |
| context->default_duration = num; |
| break; |
| } |
| |
| /* video framerate */ |
| /* NOTE: This one is here only for backward compatibility. |
| * Use _TRACKDEFAULDURATION one level up. */ |
| case GST_MATROSKA_ID_VIDEOFRAMERATE:{ |
| gdouble num; |
| |
| if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num <= 0.0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackVideoFPS %lf", num); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "TrackVideoFrameRate: %lf", num); |
| if (context->default_duration == 0) |
| context->default_duration = |
| gst_gdouble_to_guint64 ((gdouble) GST_SECOND * (1.0 / num)); |
| videocontext->default_fps = num; |
| break; |
| } |
| |
| /* width of the size to display the video at */ |
| case GST_MATROSKA_ID_VIDEODISPLAYWIDTH:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num == 0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackVideoDisplayWidth 0"); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, |
| "TrackVideoDisplayWidth: %" G_GUINT64_FORMAT, num); |
| videocontext->display_width = num; |
| break; |
| } |
| |
| /* height of the size to display the video at */ |
| case GST_MATROSKA_ID_VIDEODISPLAYHEIGHT:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num == 0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackVideoDisplayHeight 0"); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, |
| "TrackVideoDisplayHeight: %" G_GUINT64_FORMAT, num); |
| videocontext->display_height = num; |
| break; |
| } |
| |
| /* width of the video in the file */ |
| case GST_MATROSKA_ID_VIDEOPIXELWIDTH:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num == 0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackVideoPixelWidth 0"); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, |
| "TrackVideoPixelWidth: %" G_GUINT64_FORMAT, num); |
| videocontext->pixel_width = num; |
| break; |
| } |
| |
| /* height of the video in the file */ |
| case GST_MATROSKA_ID_VIDEOPIXELHEIGHT:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num == 0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackVideoPixelHeight 0"); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, |
| "TrackVideoPixelHeight: %" G_GUINT64_FORMAT, num); |
| videocontext->pixel_height = num; |
| break; |
| } |
| |
| /* whether the video is interlaced */ |
| case GST_MATROSKA_ID_VIDEOFLAGINTERLACED:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num) |
| context->flags |= GST_MATROSKA_VIDEOTRACK_INTERLACED; |
| else |
| context->flags &= ~GST_MATROSKA_VIDEOTRACK_INTERLACED; |
| GST_DEBUG_OBJECT (demux, "TrackVideoInterlaced: %d", |
| (context->flags & GST_MATROSKA_VIDEOTRACK_INTERLACED) ? 1 : |
| 0); |
| break; |
| } |
| |
| /* aspect ratio behaviour */ |
| case GST_MATROSKA_ID_VIDEOASPECTRATIOTYPE:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num != GST_MATROSKA_ASPECT_RATIO_MODE_FREE && |
| num != GST_MATROSKA_ASPECT_RATIO_MODE_KEEP && |
| num != GST_MATROSKA_ASPECT_RATIO_MODE_FIXED) { |
| GST_WARNING_OBJECT (demux, |
| "Unknown TrackVideoAspectRatioType 0x%x", (guint) num); |
| break; |
| } |
| GST_DEBUG_OBJECT (demux, |
| "TrackVideoAspectRatioType: %" G_GUINT64_FORMAT, num); |
| videocontext->asr_mode = num; |
| break; |
| } |
| |
| /* colourspace (only matters for raw video) fourcc */ |
| case GST_MATROSKA_ID_VIDEOCOLOURSPACE:{ |
| guint8 *data; |
| guint64 datalen; |
| |
| if ((ret = |
| gst_ebml_read_binary (ebml, &id, &data, |
| &datalen)) != GST_FLOW_OK) |
| break; |
| |
| if (datalen != 4) { |
| g_free (data); |
| GST_WARNING_OBJECT (demux, |
| "Invalid TrackVideoColourSpace length %" G_GUINT64_FORMAT, |
| datalen); |
| break; |
| } |
| |
| memcpy (&videocontext->fourcc, data, 4); |
| GST_DEBUG_OBJECT (demux, |
| "TrackVideoColourSpace: %" GST_FOURCC_FORMAT, |
| GST_FOURCC_ARGS (videocontext->fourcc)); |
| g_free (data); |
| break; |
| } |
| case GST_MATROSKA_ID_VIDEOSTEREOMODE: |
| { |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| GST_DEBUG_OBJECT (demux, "StereoMode: %" G_GUINT64_FORMAT, num); |
| |
| switch (num) { |
| case GST_MATROSKA_STEREO_MODE_SBS_RL: |
| videocontext->multiview_flags = |
| GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST; |
| /* fall through */ |
| case GST_MATROSKA_STEREO_MODE_SBS_LR: |
| videocontext->multiview_mode = |
| GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE; |
| break; |
| case GST_MATROSKA_STEREO_MODE_TB_RL: |
| videocontext->multiview_flags = |
| GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST; |
| /* fall through */ |
| case GST_MATROSKA_STEREO_MODE_TB_LR: |
| videocontext->multiview_mode = |
| GST_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM; |
| break; |
| case GST_MATROSKA_STEREO_MODE_CHECKER_RL: |
| videocontext->multiview_flags = |
| GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST; |
| /* fall through */ |
| case GST_MATROSKA_STEREO_MODE_CHECKER_LR: |
| videocontext->multiview_mode = |
| GST_VIDEO_MULTIVIEW_MODE_CHECKERBOARD; |
| break; |
| case GST_MATROSKA_STEREO_MODE_FBF_RL: |
| videocontext->multiview_flags = |
| GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST; |
| /* fall through */ |
| case GST_MATROSKA_STEREO_MODE_FBF_LR: |
| videocontext->multiview_mode = |
| GST_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME; |
| /* FIXME: In frame-by-frame mode, left/right frame buffers are |
| * laced within one block, and we'll need to apply FIRST_IN_BUNDLE |
| * accordingly. See http://www.matroska.org/technical/specs/index.html#StereoMode */ |
| GST_FIXME_OBJECT (demux, |
| "Frame-by-frame stereoscopic mode not fully implemented"); |
| break; |
| } |
| break; |
| } |
| |
| default: |
| GST_WARNING_OBJECT (demux, |
| "Unknown TrackVideo subelement 0x%x - ignoring", id); |
| /* fall through */ |
| case GST_MATROSKA_ID_VIDEODISPLAYUNIT: |
| case GST_MATROSKA_ID_VIDEOPIXELCROPBOTTOM: |
| case GST_MATROSKA_ID_VIDEOPIXELCROPTOP: |
| case GST_MATROSKA_ID_VIDEOPIXELCROPLEFT: |
| case GST_MATROSKA_ID_VIDEOPIXELCROPRIGHT: |
| case GST_MATROSKA_ID_VIDEOGAMMAVALUE: |
| ret = gst_ebml_read_skip (ebml); |
| break; |
| } |
| } |
| |
| DEBUG_ELEMENT_STOP (demux, ebml, "TrackVideo", ret); |
| break; |
| } |
| |
| /* tracktype specific stuff for audio */ |
| case GST_MATROSKA_ID_TRACKAUDIO:{ |
| GstMatroskaTrackAudioContext *audiocontext; |
| |
| DEBUG_ELEMENT_START (demux, ebml, "TrackAudio"); |
| |
| if (!gst_matroska_track_init_audio_context (&context)) { |
| GST_WARNING_OBJECT (demux, |
| "TrackAudio element in non-audio track - ignoring track"); |
| ret = GST_FLOW_ERROR; |
| break; |
| } |
| |
| if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) |
| break; |
| |
| audiocontext = (GstMatroskaTrackAudioContext *) context; |
| g_ptr_array_index (demux->common.src, demux->common.num_streams - 1) |
| = context; |
| |
| while (ret == GST_FLOW_OK && |
| gst_ebml_read_has_remaining (ebml, 1, TRUE)) { |
| if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK) |
| break; |
| |
| switch (id) { |
| /* samplerate */ |
| case GST_MATROSKA_ID_AUDIOSAMPLINGFREQ:{ |
| gdouble num; |
| |
| if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| |
| if (num <= 0.0) { |
| GST_WARNING_OBJECT (demux, |
| "Invalid TrackAudioSamplingFrequency %lf", num); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "TrackAudioSamplingFrequency: %lf", num); |
| audiocontext->samplerate = num; |
| break; |
| } |
| |
| /* bitdepth */ |
| case GST_MATROSKA_ID_AUDIOBITDEPTH:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num == 0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackAudioBitDepth 0"); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "TrackAudioBitDepth: %" G_GUINT64_FORMAT, |
| num); |
| audiocontext->bitdepth = num; |
| break; |
| } |
| |
| /* channels */ |
| case GST_MATROSKA_ID_AUDIOCHANNELS:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num == 0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackAudioChannels 0"); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "TrackAudioChannels: %" G_GUINT64_FORMAT, |
| num); |
| audiocontext->channels = num; |
| break; |
| } |
| |
| default: |
| GST_WARNING_OBJECT (demux, |
| "Unknown TrackAudio subelement 0x%x - ignoring", id); |
| /* fall through */ |
| case GST_MATROSKA_ID_AUDIOCHANNELPOSITIONS: |
| case GST_MATROSKA_ID_AUDIOOUTPUTSAMPLINGFREQ: |
| ret = gst_ebml_read_skip (ebml); |
| break; |
| } |
| } |
| |
| DEBUG_ELEMENT_STOP (demux, ebml, "TrackAudio", ret); |
| |
| break; |
| } |
| |
| /* codec identifier */ |
| case GST_MATROSKA_ID_CODECID:{ |
| gchar *text; |
| |
| if ((ret = gst_ebml_read_ascii (ebml, &id, &text)) != GST_FLOW_OK) |
| break; |
| |
| GST_DEBUG_OBJECT (demux, "CodecID: %s", GST_STR_NULL (text)); |
| context->codec_id = text; |
| break; |
| } |
| |
| /* codec private data */ |
| case GST_MATROSKA_ID_CODECPRIVATE:{ |
| guint8 *data; |
| guint64 size; |
| |
| if ((ret = |
| gst_ebml_read_binary (ebml, &id, &data, &size)) != GST_FLOW_OK) |
| break; |
| |
| context->codec_priv = data; |
| context->codec_priv_size = size; |
| |
| GST_DEBUG_OBJECT (demux, "CodecPrivate of size %" G_GUINT64_FORMAT, |
| size); |
| break; |
| } |
| |
| /* name of the codec */ |
| case GST_MATROSKA_ID_CODECNAME:{ |
| gchar *text; |
| |
| if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK) |
| break; |
| |
| GST_DEBUG_OBJECT (demux, "CodecName: %s", GST_STR_NULL (text)); |
| context->codec_name = text; |
| break; |
| } |
| |
| /* codec delay */ |
| case GST_MATROSKA_ID_CODECDELAY:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| context->codec_delay = num; |
| |
| GST_DEBUG_OBJECT (demux, "CodecDelay: %" GST_TIME_FORMAT, |
| GST_TIME_ARGS (num)); |
| break; |
| } |
| |
| /* codec delay */ |
| case GST_MATROSKA_ID_SEEKPREROLL:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| context->seek_preroll = num; |
| |
| GST_DEBUG_OBJECT (demux, "SeekPreroll: %" GST_TIME_FORMAT, |
| GST_TIME_ARGS (num)); |
| break; |
| } |
| |
| /* name of this track */ |
| case GST_MATROSKA_ID_TRACKNAME:{ |
| gchar *text; |
| |
| if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK) |
| break; |
| |
| context->name = text; |
| GST_DEBUG_OBJECT (demux, "TrackName: %s", GST_STR_NULL (text)); |
| break; |
| } |
| |
| /* language (matters for audio/subtitles, mostly) */ |
| case GST_MATROSKA_ID_TRACKLANGUAGE:{ |
| gchar *text; |
| |
| if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK) |
| break; |
| |
| |
| context->language = text; |
| |
| /* fre-ca => fre */ |
| if (strlen (context->language) >= 4 && context->language[3] == '-') |
| context->language[3] = '\0'; |
| |
| GST_DEBUG_OBJECT (demux, "TrackLanguage: %s", |
| GST_STR_NULL (context->language)); |
| break; |
| } |
| |
| /* whether this is actually used */ |
| case GST_MATROSKA_ID_TRACKFLAGENABLED:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num) |
| context->flags |= GST_MATROSKA_TRACK_ENABLED; |
| else |
| context->flags &= ~GST_MATROSKA_TRACK_ENABLED; |
| |
| GST_DEBUG_OBJECT (demux, "TrackEnabled: %d", |
| (context->flags & GST_MATROSKA_TRACK_ENABLED) ? 1 : 0); |
| break; |
| } |
| |
| /* whether it's the default for this track type */ |
| case GST_MATROSKA_ID_TRACKFLAGDEFAULT:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num) |
| context->flags |= GST_MATROSKA_TRACK_DEFAULT; |
| else |
| context->flags &= ~GST_MATROSKA_TRACK_DEFAULT; |
| |
| GST_DEBUG_OBJECT (demux, "TrackDefault: %d", |
| (context->flags & GST_MATROSKA_TRACK_DEFAULT) ? 1 : 0); |
| break; |
| } |
| |
| /* whether the track must be used during playback */ |
| case GST_MATROSKA_ID_TRACKFLAGFORCED:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num) |
| context->flags |= GST_MATROSKA_TRACK_FORCED; |
| else |
| context->flags &= ~GST_MATROSKA_TRACK_FORCED; |
| |
| GST_DEBUG_OBJECT (demux, "TrackForced: %d", |
| (context->flags & GST_MATROSKA_TRACK_FORCED) ? 1 : 0); |
| break; |
| } |
| |
| /* lacing (like MPEG, where blocks don't end/start on frame |
| * boundaries) */ |
| case GST_MATROSKA_ID_TRACKFLAGLACING:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num) |
| context->flags |= GST_MATROSKA_TRACK_LACING; |
| else |
| context->flags &= ~GST_MATROSKA_TRACK_LACING; |
| |
| GST_DEBUG_OBJECT (demux, "TrackLacing: %d", |
| (context->flags & GST_MATROSKA_TRACK_LACING) ? 1 : 0); |
| break; |
| } |
| |
| /* default length (in time) of one data block in this track */ |
| case GST_MATROSKA_ID_TRACKDEFAULTDURATION:{ |
| guint64 num; |
| |
| if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| |
| if (num == 0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackDefaultDuration 0"); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "TrackDefaultDuration: %" G_GUINT64_FORMAT, |
| num); |
| context->default_duration = num; |
| break; |
| } |
| |
| case GST_MATROSKA_ID_CONTENTENCODINGS:{ |
| ret = gst_matroska_read_common_read_track_encodings (&demux->common, |
| ebml, context); |
| break; |
| } |
| |
| case GST_MATROSKA_ID_TRACKTIMECODESCALE:{ |
| gdouble num; |
| |
| if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK) |
| break; |
| |
| if (num <= 0.0) { |
| GST_WARNING_OBJECT (demux, "Invalid TrackTimeCodeScale %lf", num); |
| break; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "TrackTimeCodeScale: %lf", num); |
| context->timecodescale = num; |
| break; |
| } |
| |
| default: |
| GST_WARNING ("Unknown TrackEntry subelement 0x%x - ignoring", id); |
| /* pass-through */ |
| |
| /* we ignore these because they're nothing useful (i.e. crap) |
| * or simply not implemented yet. */ |
| case GST_MATROSKA_ID_TRACKMINCACHE: |
| case GST_MATROSKA_ID_TRACKMAXCACHE: |
| case GST_MATROSKA_ID_MAXBLOCKADDITIONID: |
| case GST_MATROSKA_ID_TRACKATTACHMENTLINK: |
| case GST_MATROSKA_ID_TRACKOVERLAY: |
| case GST_MATROSKA_ID_TRACKTRANSLATE: |
| case GST_MATROSKA_ID_TRACKOFFSET: |
| case GST_MATROSKA_ID_CODECSETTINGS: |
| case GST_MATROSKA_ID_CODECINFOURL: |
| case GST_MATROSKA_ID_CODECDOWNLOADURL: |
| case GST_MATROSKA_ID_CODECDECODEALL: |
| ret = gst_ebml_read_skip (ebml); |
| break; |
| } |
| } |
| |
| DEBUG_ELEMENT_STOP (demux, ebml, "TrackEntry", ret); |
| |
| /* Decode codec private data if necessary */ |
| if (context->encodings && context->encodings->len > 0 && context->codec_priv |
| && context->codec_priv_size > 0) { |
| if (!gst_matroska_decode_data (context->encodings, |
| &context->codec_priv, &context->codec_priv_size, |
| GST_MATROSKA_TRACK_ENCODING_SCOPE_CODEC_DATA, TRUE)) { |
| GST_WARNING_OBJECT (demux, "Decoding codec private data failed"); |
| ret = GST_FLOW_ERROR; |
| } |
| } |
| |
| if (context->type == 0 || context->codec_id == NULL || (ret != GST_FLOW_OK |
| && ret != GST_FLOW_EOS)) { |
| if (ret == GST_FLOW_OK || ret == GST_FLOW_EOS) |
| GST_WARNING_OBJECT (ebml, "Unknown stream/codec in track entry header"); |
| |
| demux->common.num_streams--; |
| g_ptr_array_remove_index (demux->common.src, demux->common.num_streams); |
| g_assert (demux->common.src->len == demux->common.num_streams); |
| gst_matroska_track_free (context); |
| |
| return ret; |
| } |
| |
| /* check for a cached track taglist */ |
| cached_taglist = |
| (GstTagList *) g_hash_table_lookup (demux->common.cached_track_taglists, |
| GUINT_TO_POINTER (context->uid)); |
| if (cached_taglist) |
| gst_tag_list_insert (context->tags, cached_taglist, GST_TAG_MERGE_APPEND); |
| |
| /* now create the GStreamer connectivity */ |
| switch (context->type) { |
| case GST_MATROSKA_TRACK_TYPE_VIDEO:{ |
| GstMatroskaTrackVideoContext *videocontext = |
| (GstMatroskaTrackVideoContext *) context; |
| |
| padname = g_strdup_printf ("video_%u", demux->num_v_streams++); |
| templ = gst_element_class_get_pad_template (klass, "video_%u"); |
| caps = gst_matroska_demux_video_caps (videocontext, |
| context->codec_id, context->codec_priv, |
| context->codec_priv_size, &codec, &riff_fourcc); |
| |
| if (codec) { |
| gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE, |
| GST_TAG_VIDEO_CODEC, codec, NULL); |
| context->tags_changed = TRUE; |
| g_free (codec); |
| } |
| break; |
| } |
| |
| case GST_MATROSKA_TRACK_TYPE_AUDIO:{ |
| GstMatroskaTrackAudioContext *audiocontext = |
| (GstMatroskaTrackAudioContext *) context; |
| |
| padname = g_strdup_printf ("audio_%u", demux->num_a_streams++); |
| templ = gst_element_class_get_pad_template (klass, "audio_%u"); |
| caps = gst_matroska_demux_audio_caps (audiocontext, |
| context->codec_id, context->codec_priv, context->codec_priv_size, |
| &codec, &riff_audio_fmt); |
| |
| if (codec) { |
| gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE, |
| GST_TAG_AUDIO_CODEC, codec, NULL); |
| context->tags_changed = TRUE; |
| g_free (codec); |
| } |
| break; |
| } |
| |
| case GST_MATROSKA_TRACK_TYPE_SUBTITLE:{ |
| GstMatroskaTrackSubtitleContext *subtitlecontext = |
| (GstMatroskaTrackSubtitleContext *) context; |
| |
| padname = g_strdup_printf ("subtitle_%u", demux->num_t_streams++); |
| templ = gst_element_class_get_pad_template (klass, "subtitle_%u"); |
| caps = gst_matroska_demux_subtitle_caps (subtitlecontext, |
| context->codec_id, context->codec_priv, context->codec_priv_size); |
| break; |
| } |
| |
| case GST_MATROSKA_TRACK_TYPE_COMPLEX: |
| case GST_MATROSKA_TRACK_TYPE_LOGO: |
| case GST_MATROSKA_TRACK_TYPE_BUTTONS: |
| case GST_MATROSKA_TRACK_TYPE_CONTROL: |
| default: |
| /* we should already have quit by now */ |
| g_assert_not_reached (); |
| } |
| |
| if ((context->language == NULL || *context->language == '\0') && |
| (context->type == GST_MATROSKA_TRACK_TYPE_AUDIO || |
| context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE)) { |
| GST_LOG ("stream %d: language=eng (assuming default)", context->index); |
| context->language = g_strdup ("eng"); |
| } |
| |
| if (context->language) { |
| const gchar *lang; |
| |
| /* Matroska contains ISO 639-2B codes, we want ISO 639-1 */ |
| lang = gst_tag_get_language_code (context->language); |
| gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE, |
| GST_TAG_LANGUAGE_CODE, (lang) ? lang : context->language, NULL); |
| context->tags_changed = TRUE; |
| } |
| |
| if (caps == NULL) { |
| GST_WARNING_OBJECT (demux, "could not determine caps for stream with " |
| "codec_id='%s'", context->codec_id); |
| switch (context->type) { |
| case GST_MATROSKA_TRACK_TYPE_VIDEO: |
| caps = gst_caps_new_empty_simple ("video/x-unknown"); |
| break; |
| case GST_MATROSKA_TRACK_TYPE_AUDIO: |
| caps = gst_caps_new_empty_simple ("audio/x-unknown"); |
| break; |
| case GST_MATROSKA_TRACK_TYPE_SUBTITLE: |
| caps = gst_caps_new_empty_simple ("application/x-subtitle-unknown"); |
| break; |
| case GST_MATROSKA_TRACK_TYPE_COMPLEX: |
| default: |
| caps = gst_caps_new_empty_simple ("application/x-matroska-unknown"); |
| break; |
| } |
| gst_caps_set_simple (caps, "codec-id", G_TYPE_STRING, context->codec_id, |
| NULL); |
| |
| /* add any unrecognised riff fourcc / audio format, but after codec-id */ |
| if (context->type == GST_MATROSKA_TRACK_TYPE_AUDIO && riff_audio_fmt != 0) |
| gst_caps_set_simple (caps, "format", G_TYPE_INT, riff_audio_fmt, NULL); |
| else if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO && riff_fourcc != 0) { |
| gchar *fstr = g_strdup_printf ("%" GST_FOURCC_FORMAT, |
| GST_FOURCC_ARGS (riff_fourcc)); |
| gst_caps_set_simple (caps, "fourcc", G_TYPE_STRING, fstr, NULL); |
| g_free (fstr); |
| } |
| } else if (context->stream_headers != NULL) { |
| gst_matroska_demux_add_stream_headers_to_caps (demux, |
| context->stream_headers, caps); |
| } |
| |
| /* the pad in here */ |
| context->pad = gst_pad_new_from_template (templ, padname); |
| context->caps = caps; |
| |
| gst_pad_set_event_function (context->pad, |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_src_event)); |
| gst_pad_set_query_function (context->pad, |
| GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_src_query)); |
| |
| GST_INFO_OBJECT (demux, "Adding pad '%s' with caps %" GST_PTR_FORMAT, |
| padname, caps); |
| |
| gst_pad_set_element_private (context->pad, context); |
| |
| gst_pad_use_fixed_caps (context->pad); |
| gst_pad_set_active (context->pad, TRUE); |
| |
| stream_id = |
| gst_pad_create_stream_id_printf (context->pad, GST_ELEMENT_CAST (demux), |
| "%03" G_GUINT64_FORMAT ":%03" G_GUINT64_FORMAT, |
| context->num, context->uid); |
| stream_start = |
| gst_pad_get_sticky_event (demux->common.sinkpad, GST_EVENT_STREAM_START, |
| 0); |
| if (stream_start) { |
| if (gst_event_parse_group_id (stream_start, &demux->group_id)) |
| demux->have_group_id = TRUE; |
| else |
| demux->have_group_id = FALSE; |
| gst_event_unref (stream_start); |
| } else if (!demux->have_group_id) { |
| demux->have_group_id = TRUE; |
| demux->group_id = gst_util_group_id_next (); |
| } |
| |
| stream_start = gst_event_new_stream_start (stream_id); |
| g_free (stream_id); |
| if (demux->have_group_id) |
| gst_event_set_group_id (stream_start, demux->group_id); |
| stream_flags = GST_STREAM_FLAG_NONE; |
| if (context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE) |
| stream_flags |= GST_STREAM_FLAG_SPARSE; |
| if (context->flags & GST_MATROSKA_TRACK_DEFAULT) |
| stream_flags |= GST_STREAM_FLAG_SELECT; |
| gst_event_set_stream_flags (stream_start, stream_flags); |
| gst_pad_push_event (context->pad, stream_start); |
| gst_pad_set_caps (context->pad, context->caps); |
| |
| |
| if (demux->common.global_tags) { |
| GstEvent *tag_event; |
| |
| gst_tag_list_add (demux->common.global_tags, GST_TAG_MERGE_REPLACE, |
| GST_TAG_CONTAINER_FORMAT, "Matroska", NULL); |
| GST_DEBUG_OBJECT (context->pad, "Sending global_tags %p: %" GST_PTR_FORMAT, |
| demux->common.global_tags, demux->common.global_tags); |
| |
| tag_event = |
| gst_event_new_tag (gst_tag_list_copy (demux->common.global_tags)); |
| |
| gst_pad_push_event (context->pad, tag_event); |
| } |
| |
| if (G_UNLIKELY (context->tags_changed)) { |
| GST_DEBUG_OBJECT (context->pad, "Sending tags %p: %" |
| GST_PTR_FORMAT, context->tags, context->tags); |
| gst_pad_push_event (context->pad, |
| gst_event_new_tag (gst_tag_list_copy (context->tags))); |
| context->tags_changed = FALSE; |
| } |
| |
| gst_element_add_pad (GST_ELEMENT (demux), context->pad); |
| gst_flow_combiner_add_pad (demux->flowcombiner, context->pad); |
| |
| g_free (padname); |
| |
| /* tadaah! */ |
| return ret; |
| } |
| |
| static gboolean |
| gst_matroska_demux_query (GstMatroskaDemux * demux, GstPad * pad, |
| GstQuery * query) |
| { |
| gboolean res = FALSE; |
| GstMatroskaTrackContext *context = NULL; |
| |
| if (pad) { |
| context = gst_pad_get_element_private (pad); |
| } |
| |
| switch (GST_QUERY_TYPE (query)) { |
| case GST_QUERY_POSITION: |
| { |
| GstFormat format; |
| |
| gst_query_parse_position (query, &format, NULL); |
| |
| res = TRUE; |
| if (format == GST_FORMAT_TIME) { |
| GST_OBJECT_LOCK (demux); |
| if (context) |
| gst_query_set_position (query, GST_FORMAT_TIME, |
| MAX (context->pos, demux->stream_start_time) - |
| demux->stream_start_time); |
| else |
| gst_query_set_position (query, GST_FORMAT_TIME, |
| MAX (demux->common.segment.position, demux->stream_start_time) - |
| demux->stream_start_time); |
| GST_OBJECT_UNLOCK (demux); |
| } else if (format == GST_FORMAT_DEFAULT && context |
| && context->default_duration) { |
| GST_OBJECT_LOCK (demux); |
| gst_query_set_position (query, GST_FORMAT_DEFAULT, |
| context->pos / context->default_duration); |
| GST_OBJECT_UNLOCK (demux); |
| } else { |
| GST_DEBUG_OBJECT (demux, |
| "only position query in TIME and DEFAULT format is supported"); |
| res = FALSE; |
| } |
| |
| break; |
| } |
| case GST_QUERY_DURATION: |
| { |
| GstFormat format; |
| |
| gst_query_parse_duration (query, &format, NULL); |
| |
| res = TRUE; |
| if (format == GST_FORMAT_TIME) { |
| GST_OBJECT_LOCK (demux); |
| gst_query_set_duration (query, GST_FORMAT_TIME, |
| demux->common.segment.duration); |
| GST_OBJECT_UNLOCK (demux); |
| } else if (format == GST_FORMAT_DEFAULT && context |
| && context->default_duration) { |
| GST_OBJECT_LOCK (demux); |
| gst_query_set_duration (query, GST_FORMAT_DEFAULT, |
| demux->common.segment.duration / context->default_duration); |
| GST_OBJECT_UNLOCK (demux); |
| } else { |
| GST_DEBUG_OBJECT (demux, |
| "only duration query in TIME and DEFAULT format is supported"); |
| res = FALSE; |
| } |
| break; |
| } |
| |
| case GST_QUERY_SEEKING: |
| { |
| GstFormat fmt; |
| |
| gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL); |
| GST_OBJECT_LOCK (demux); |
| if (fmt == GST_FORMAT_TIME) { |
| gboolean seekable; |
| |
| if (demux->streaming) { |
| /* assuming we'll be able to get an index ... */ |
| seekable = demux->seekable; |
| } else { |
| seekable = TRUE; |
| } |
| |
| gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, |
| 0, demux->common.segment.duration); |
| res = TRUE; |
| } |
| GST_OBJECT_UNLOCK (demux); |
| break; |
| } |
| case GST_QUERY_SEGMENT: |
| { |
| GstFormat format; |
| gint64 start, stop; |
| |
| format = demux->common.segment.format; |
| |
| start = |
| gst_segment_to_stream_time (&demux->common.segment, format, |
| demux->common.segment.start); |
| if ((stop = demux->common.segment.stop) == -1) |
| stop = demux->common.segment.duration; |
| else |
| stop = |
| gst_segment_to_stream_time (&demux->common.segment, format, stop); |
| |
| gst_query_set_segment (query, demux->common.segment.rate, format, start, |
| stop); |
| res = TRUE; |
| break; |
| } |
| default: |
| if (pad) |
| res = gst_pad_query_default (pad, (GstObject *) demux, query); |
| else |
| res = |
| GST_ELEMENT_CLASS (parent_class)->query (GST_ELEMENT_CAST (demux), |
| query); |
| break; |
| } |
| |
| return res; |
| } |
| |
| static gboolean |
| gst_matroska_demux_element_query (GstElement * element, GstQuery * query) |
| { |
| return gst_matroska_demux_query (GST_MATROSKA_DEMUX (element), NULL, query); |
| } |
| |
| static gboolean |
| gst_matroska_demux_handle_src_query (GstPad * pad, GstObject * parent, |
| GstQuery * query) |
| { |
| GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent); |
| |
| return gst_matroska_demux_query (demux, pad, query); |
| } |
| |
| /* returns FALSE if there are no pads to deliver event to, |
| * otherwise TRUE (whatever the outcome of event sending), |
| * takes ownership of the passed event! */ |
| static gboolean |
| gst_matroska_demux_send_event (GstMatroskaDemux * demux, GstEvent * event) |
| { |
| gboolean ret = FALSE; |
| gint i; |
| |
| g_return_val_if_fail (event != NULL, FALSE); |
| |
| GST_DEBUG_OBJECT (demux, "Sending event of type %s to all source pads", |
| GST_EVENT_TYPE_NAME (event)); |
| |
| g_assert (demux->common.src->len == demux->common.num_streams); |
| for (i = 0; i < demux->common.src->len; i++) { |
| GstMatroskaTrackContext *stream; |
| |
| stream = g_ptr_array_index (demux->common.src, i); |
| gst_event_ref (event); |
| gst_pad_push_event (stream->pad, event); |
| ret = TRUE; |
| } |
| |
| gst_event_unref (event); |
| return ret; |
| } |
| |
| static void |
| gst_matroska_demux_send_tags (GstMatroskaDemux * demux) |
| { |
| gint i; |
| |
| if (G_UNLIKELY (demux->common.global_tags_changed)) { |
| GstEvent *tag_event; |
| gst_tag_list_add (demux->common.global_tags, GST_TAG_MERGE_REPLACE, |
| GST_TAG_CONTAINER_FORMAT, "Matroska", NULL); |
| GST_DEBUG_OBJECT (demux, "Sending global_tags %p : %" GST_PTR_FORMAT, |
| demux->common.global_tags, demux->common.global_tags); |
| |
| tag_event = |
| gst_event_new_tag (gst_tag_list_copy (demux->common.global_tags)); |
| |
| for (i = 0; i < demux->common.src->len; i++) { |
| GstMatroskaTrackContext *stream; |
| |
| stream = g_ptr_array_index (demux->common.src, i); |
| gst_pad_push_event (stream->pad, gst_event_ref (tag_event)); |
| } |
| |
| gst_event_unref (tag_event); |
| demux->common.global_tags_changed = FALSE; |
| } |
| |
| g_assert (demux->common.src->len == demux->common.num_streams); |
| for (i = 0; i < demux->common.src->len; i++) { |
| GstMatroskaTrackContext *stream; |
| |
| stream = g_ptr_array_index (demux->common.src, i); |
| |
| if (G_UNLIKELY (stream->tags_changed)) { |
| GST_DEBUG_OBJECT (demux, "Sending tags %p for pad %s:%s : %" |
| GST_PTR_FORMAT, stream->tags, |
| GST_DEBUG_PAD_NAME (stream->pad), stream->tags); |
| gst_pad_push_event (stream->pad, |
| gst_event_new_tag (gst_tag_list_copy (stream->tags))); |
| stream->tags_changed = FALSE; |
| } |
| } |
| } |
| |
| static gboolean |
| gst_matroska_demux_element_send_event (GstElement * element, GstEvent * event) |
| { |
| GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element); |
| gboolean res; |
| |
| g_return_val_if_fail (event != NULL, FALSE); |
| |
| if (GST_EVENT_TYPE (event) == GST_EVENT_SEEK) { |
| /* no seeking until we are (safely) ready */ |
| if (demux->common.state != GST_MATROSKA_READ_STATE_DATA) { |
| GST_DEBUG_OBJECT (demux, "not ready for seeking yet"); |
| gst_event_unref (event); |
| return FALSE; |
| } |
| res = gst_matroska_demux_handle_seek_event (demux, NULL, event); |
| } else { |
| GST_WARNING_OBJECT (demux, "Unhandled event of type %s", |
| GST_EVENT_TYPE_NAME (event)); |
| res = FALSE; |
| } |
| gst_event_unref (event); |
| return res; |
| } |
| |
| static gboolean |
| gst_matroska_demux_move_to_entry (GstMatroskaDemux * demux, |
| GstMatroskaIndex * entry, gboolean reset, gboolean update) |
| { |
| gint i; |
| |
| GST_OBJECT_LOCK (demux); |
| |
| if (update) { |
| /* seek (relative to matroska segment) */ |
| /* position might be invalid; will error when streaming resumes ... */ |
| demux->common.offset = entry->pos + demux->common.ebml_segment_start; |
| demux->next_cluster_offset = 0; |
| |
| GST_DEBUG_OBJECT (demux, |
| "Seeked to offset %" G_GUINT64_FORMAT ", block %d, " "time %" |
| GST_TIME_FORMAT, entry->pos + demux->common.ebml_segment_start, |
| entry->block, GST_TIME_ARGS (entry->time)); |
| |
| /* update the time */ |
| gst_matroska_read_common_reset_streams (&demux->common, entry->time, TRUE); |
| gst_flow_combiner_reset (demux->flowcombiner); |
| demux->common.segment.position = entry->time; |
| demux->seek_block = entry->block; |
| demux->seek_first = TRUE; |
| demux->last_stop_end = GST_CLOCK_TIME_NONE; |
| } |
| |
| for (i = 0; i < demux->common.src->len; i++) { |
| GstMatroskaTrackContext *stream = g_ptr_array_index (demux->common.src, i); |
| |
| if (reset) { |
| stream->to_offset = G_MAXINT64; |
| } else { |
| if (stream->from_offset != -1) |
| stream->to_offset = stream->from_offset; |
| } |
| stream->from_offset = -1; |
| stream->from_time = GST_CLOCK_TIME_NONE; |
| } |
| |
| GST_OBJECT_UNLOCK (demux); |
| |
| return TRUE; |
| } |
| |
| static gint |
| gst_matroska_cluster_compare (gint64 * i1, gint64 * i2) |
| { |
| if (*i1 < *i2) |
| return -1; |
| else if (*i1 > *i2) |
| return 1; |
| else |
| return 0; |
| } |
| |
| /* searches for a cluster start from @pos, |
| * return GST_FLOW_OK and cluster position in @pos if found */ |
| static GstFlowReturn |
| gst_matroska_demux_search_cluster (GstMatroskaDemux * demux, gint64 * pos) |
| { |
| gint64 newpos = *pos; |
| gint64 orig_offset; |
| GstFlowReturn ret = GST_FLOW_OK; |
| const guint chunk = 64 * 1024; |
| GstBuffer *buf = NULL; |
| GstMapInfo map; |
| gpointer data = NULL; |
| gsize size; |
| guint64 length; |
| guint32 id; |
| guint needed; |
| gint64 oldpos, oldlength; |
| |
| orig_offset = demux->common.offset; |
| |
| GST_LOG_OBJECT (demux, "searching cluster following offset %" G_GINT64_FORMAT, |
| *pos); |
| |
| if (demux->clusters) { |
| gint64 *cpos; |
| |
| cpos = gst_util_array_binary_search (demux->clusters->data, |
| demux->clusters->len, sizeof (gint64), |
| (GCompareDataFunc) gst_matroska_cluster_compare, |
| GST_SEARCH_MODE_AFTER, pos, NULL); |
| /* sanity check */ |
| if (cpos) { |
| GST_DEBUG_OBJECT (demux, |
| "cluster reported at offset %" G_GINT64_FORMAT, *cpos); |
| demux->common.offset = *cpos; |
| ret = gst_matroska_read_common_peek_id_length_pull (&demux->common, |
| GST_ELEMENT_CAST (demux), &id, &length, &needed); |
| if (ret == GST_FLOW_OK && id == GST_MATROSKA_ID_CLUSTER) { |
| newpos = *cpos; |
| goto exit; |
| } |
| } |
| } |
| |
| /* read in at newpos and scan for ebml cluster id */ |
| oldpos = oldlength = -1; |
| while (1) { |
| GstByteReader reader; |
| gint cluster_pos; |
| |
| if (buf != NULL) { |
| gst_buffer_unmap (buf, &map); |
| gst_buffer_unref (buf); |
| buf = NULL; |
| } |
| ret = gst_pad_pull_range (demux->common.sinkpad, newpos, chunk, &buf); |
| if (ret != GST_FLOW_OK) |
| break; |
| GST_DEBUG_OBJECT (demux, |
| "read buffer size %" G_GSIZE_FORMAT " at offset %" G_GINT64_FORMAT, |
| gst_buffer_get_size (buf), newpos); |
| gst_buffer_map (buf, &map, GST_MAP_READ); |
| data = map.data; |
| size = map.size; |
| if (oldpos == newpos && oldlength == map.size) { |
| GST_ERROR_OBJECT (demux, "Stuck at same position"); |
| ret = GST_FLOW_ERROR; |
| goto exit; |
| } else { |
| oldpos = newpos; |
| oldlength = map.size; |
| } |
| |
| gst_byte_reader_init (&reader, data, size); |
| resume: |
| cluster_pos = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff, |
| GST_MATROSKA_ID_CLUSTER, 0, gst_byte_reader_get_remaining (&reader)); |
| if (cluster_pos >= 0) { |
| newpos += cluster_pos; |
| /* prepare resuming at next byte */ |
| if (!gst_byte_reader_skip (&reader, cluster_pos + 1)) { |
| GST_DEBUG_OBJECT (demux, "Need more data -> continue"); |
| continue; |
| } |
| GST_DEBUG_OBJECT (demux, |
| "found cluster ebml id at offset %" G_GINT64_FORMAT, newpos); |
| /* extra checks whether we really sync'ed to a cluster: |
| * - either it is the first and only cluster |
| * - either there is a cluster after this one |
| * - either cluster length is undefined |
| */ |
| /* ok if first cluster (there may not a subsequent one) */ |
| if (newpos == demux->first_cluster_offset) { |
| GST_DEBUG_OBJECT (demux, "cluster is first cluster -> OK"); |
| break; |
| } |
| demux->common.offset = newpos; |
| ret = gst_matroska_read_common_peek_id_length_pull (&demux->common, |
| GST_ELEMENT_CAST (demux), &id, &length, &needed); |
| if (ret != GST_FLOW_OK) { |
| GST_DEBUG_OBJECT (demux, "need more data -> continue"); |
| continue; |
| } |
| g_assert (id == GST_MATROSKA_ID_CLUSTER); |
| GST_DEBUG_OBJECT (demux, "cluster size %" G_GUINT64_FORMAT ", prefix %d", |
| length, needed); |
| /* ok if undefined length or first cluster */ |
| if (length == GST_EBML_SIZE_UNKNOWN || length == G_MAXUINT64) { |
| GST_DEBUG_OBJECT (demux, "cluster has undefined length -> OK"); |
| break; |
| } |
| /* skip cluster */ |
| demux->common.offset += length + needed; |
| ret = gst_matroska_read_common_peek_id_length_pull (&demux->common, |
| GST_ELEMENT_CAST (demux), &id, &length, &needed); |
| if (ret != GST_FLOW_OK) { |
| /* we skipped one byte in the reader above, need to accomodate for |
| * that when resuming skipping from the reader instead of reading a |
| * new chunk */ |
| newpos += 1; |
| goto resume; |
| } |
| GST_DEBUG_OBJECT (demux, "next element is %scluster", |
| id == GST_MATROSKA_ID_CLUSTER ? "" : "not "); |
| if (id == GST_MATROSKA_ID_CLUSTER) |
| break; |
| /* not ok, resume |
| * we skipped one byte in the reader above, need to accomodate for |
| * that when resuming skipping from the reader instead of reading a |
| * new chunk */ |
| newpos += 1; |
| goto resume; |
| } else { |
| /* partial cluster id may have been in tail of buffer */ |
| newpos += MAX (gst_byte_reader_get_remaining (&reader), 4) - 3; |
| } |
| } |
| |
| if (buf) { |
| gst_buffer_unmap (buf, &map); |
| gst_buffer_unref (buf); |
| buf = NULL; |
| } |
| |
| exit: |
| demux->common.offset = orig_offset; |
| *pos = newpos; |
| return ret; |
| } |
| |
| /* bisect and scan through file for cluster starting before @time, |
| * returns fake index entry with corresponding info on cluster */ |
| static GstMatroskaIndex * |
| gst_matroska_demux_search_pos (GstMatroskaDemux * demux, GstClockTime time) |
| { |
| GstMatroskaIndex *entry = NULL; |
| GstMatroskaReadState current_state; |
| GstClockTime otime, prev_cluster_time, current_cluster_time, cluster_time; |
| gint64 opos, newpos, startpos = 0, current_offset; |
| gint64 prev_cluster_offset = -1, current_cluster_offset, cluster_offset; |
| const guint chunk = 64 * 1024; |
| GstFlowReturn ret; |
| guint64 length; |
| guint32 id; |
| guint needed; |
| |
| /* (under)estimate new position, resync using cluster ebml id, |
| * and scan forward to appropriate cluster |
| * (and re-estimate if need to go backward) */ |
| |
| prev_cluster_time = GST_CLOCK_TIME_NONE; |
| |
| /* store some current state */ |
| current_state = demux->common.state; |
| g_return_val_if_fail (current_state == GST_MATROSKA_READ_STATE_DATA, NULL); |
| |
| current_cluster_offset = demux->cluster_offset; |
| current_cluster_time = demux->cluster_time; |
| current_offset = demux->common.offset; |
| |
| demux->common.state = GST_MATROSKA_READ_STATE_SCANNING; |
| |
| /* estimate using start and current position */ |
| GST_OBJECT_LOCK (demux); |
| opos = demux->common.offset - demux->common.ebml_segment_start; |
| otime = demux->common.segment.position; |
| GST_OBJECT_UNLOCK (demux); |
| |
| /* sanitize */ |
| time = MAX (time, demux->stream_start_time); |
| |
| /* avoid division by zero in first estimation below */ |
| if (otime <= demux->stream_start_time) |
| otime = time; |
| |
| retry: |
| GST_LOG_OBJECT (demux, |
| "opos: %" G_GUINT64_FORMAT ", otime: %" GST_TIME_FORMAT ", %" |
| GST_TIME_FORMAT " in stream time (start %" GST_TIME_FORMAT "), time %" |
| GST_TIME_FORMAT, opos, GST_TIME_ARGS (otime), |
| GST_TIME_ARGS (otime - demux->stream_start_time), |
| GST_TIME_ARGS (demux->stream_start_time), GST_TIME_ARGS (time)); |
| |
| if (otime <= demux->stream_start_time) { |
| newpos = 0; |
| } else { |
| newpos = |
| gst_util_uint64_scale (opos - demux->common.ebml_segment_start, |
| time - demux->stream_start_time, |
| otime - demux->stream_start_time) - chunk; |
| if (newpos < 0) |
| newpos = 0; |
| } |
| /* favour undershoot */ |
| newpos = newpos * 90 / 100; |
| newpos += demux->common.ebml_segment_start; |
| |
| GST_DEBUG_OBJECT (demux, |
| "estimated offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT, |
| GST_TIME_ARGS (time), newpos); |
| |
| /* and at least start scanning before previous scan start to avoid looping */ |
| startpos = startpos * 90 / 100; |
| if (startpos && startpos < newpos) |
| newpos = startpos; |
| |
| /* read in at newpos and scan for ebml cluster id */ |
| startpos = newpos; |
| while (1) { |
| |
| ret = gst_matroska_demux_search_cluster (demux, &newpos); |
| if (ret == GST_FLOW_EOS) { |
| /* heuristic HACK */ |
| newpos = startpos * 80 / 100; |
| GST_DEBUG_OBJECT (demux, "EOS; " |
| "new estimated offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT, |
| GST_TIME_ARGS (time), newpos); |
| startpos = newpos; |
| continue; |
| } else if (ret != GST_FLOW_OK) { |
| goto exit; |
| } else { |
| break; |
| } |
| } |
| |
| /* then start scanning and parsing for cluster time, |
| * re-estimate if overshoot, otherwise next cluster and so on */ |
| demux->common.offset = newpos; |
| demux->cluster_time = cluster_time = GST_CLOCK_TIME_NONE; |
| while (1) { |
| guint64 cluster_size = 0; |
| |
| /* peek and parse some elements */ |
| ret = gst_matroska_read_common_peek_id_length_pull (&demux->common, |
| GST_ELEMENT_CAST (demux), &id, &length, &needed); |
| if (ret != GST_FLOW_OK) |
| goto error; |
| GST_LOG_OBJECT (demux, "Offset %" G_GUINT64_FORMAT ", Element id 0x%x, " |
| "size %" G_GUINT64_FORMAT ", needed %d", demux->common.offset, id, |
| length, needed); |
| ret = gst_matroska_demux_parse_id (demux, id, length, needed); |
| if (ret != GST_FLOW_OK) |
| goto error; |
| |
| if (id == GST_MATROSKA_ID_CLUSTER) { |
| cluster_time = GST_CLOCK_TIME_NONE; |
| if (length == G_MAXUINT64) |
| cluster_size = 0; |
| else |
| cluster_size = length + needed; |
| } |
| if (demux->cluster_time != GST_CLOCK_TIME_NONE && |
| cluster_time == GST_CLOCK_TIME_NONE) { |
| cluster_time = demux->cluster_time * demux->common.time_scale; |
| cluster_offset = demux->cluster_offset; |
| GST_DEBUG_OBJECT (demux, "found cluster at offset %" G_GINT64_FORMAT |
| " with time %" GST_TIME_FORMAT, cluster_offset, |
| GST_TIME_ARGS (cluster_time)); |
| if (cluster_time > time) { |
| GST_DEBUG_OBJECT (demux, "overshot target"); |
| /* cluster overshoots */ |
| if (cluster_offset == demux->first_cluster_offset) { |
| /* but no prev one */ |
| GST_DEBUG_OBJECT (demux, "but using first cluster anyway"); |
| prev_cluster_time = cluster_time; |
| prev_cluster_offset = cluster_offset; |
| break; |
| } |
| if (prev_cluster_time != GST_CLOCK_TIME_NONE) { |
| /* prev cluster did not overshoot, so prev cluster is target */ |
| break; |
| } else { |
| /* re-estimate using this new position info */ |
| opos = cluster_offset; |
| otime = cluster_time; |
| goto retry; |
| } |
| } else { |
| /* cluster undershoots, goto next one */ |
| prev_cluster_time = cluster_time; |
| prev_cluster_offset = cluster_offset; |
| /* skip cluster if length is defined, |
| * otherwise will be skippingly parsed into */ |
| if (cluster_size) { |
| GST_DEBUG_OBJECT (demux, "skipping to next cluster"); |
| demux->common.offset = cluster_offset + cluster_size; |
| demux->cluster_time = GST_CLOCK_TIME_NONE; |
| } else { |
| GST_DEBUG_OBJECT (demux, "parsing/skipping cluster elements"); |
| } |
| } |
| } |
| continue; |
| |
| error: |
| if (ret == GST_FLOW_EOS) { |
| if (prev_cluster_time != GST_CLOCK_TIME_NONE) |
| break; |
| } |
| goto exit; |
| } |
| |
| entry = g_new0 (GstMatroskaIndex, 1); |
| entry->time = prev_cluster_time; |
| entry->pos = prev_cluster_offset - demux->common.ebml_segment_start; |
| GST_DEBUG_OBJECT (demux, "simulated index entry; time %" GST_TIME_FORMAT |
| ", pos %" G_GUINT64_FORMAT, GST_TIME_ARGS (entry->time), entry->pos); |
| |
| exit: |
| |
| /* restore some state */ |
| demux->cluster_offset = current_cluster_offset; |
| demux->cluster_time = current_cluster_time; |
| demux->common.offset = current_offset; |
| demux->common.state = current_state; |
| |
| return entry; |
| } |
| |
| static gboolean |
| gst_matroska_demux_handle_seek_event (GstMatroskaDemux * demux, |
| GstPad * pad, GstEvent * event) |
| { |
| GstMatroskaIndex *entry = NULL; |
| GstMatroskaIndex scan_entry; |
| GstSeekFlags flags; |
| GstSeekType cur_type, stop_type; |
| GstFormat format; |
| gboolean flush, keyunit, before, after, snap_next; |
| gdouble rate; |
| gint64 cur, stop; |
| GstMatroskaTrackContext *track = NULL; |
| GstSegment seeksegment = { 0, }; |
| gboolean update = TRUE; |
| gboolean pad_locked = FALSE; |
| guint32 seqnum; |
| GstSearchMode snap_dir; |
| |
| g_return_val_if_fail (event != NULL, FALSE); |
| |
| if (pad) |
| track = gst_pad_get_element_private (pad); |
| |
| GST_DEBUG_OBJECT (demux, "Have seek %" GST_PTR_FORMAT, event); |
| |
| gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur, |
| &stop_type, &stop); |
| seqnum = gst_event_get_seqnum (event); |
| |
| /* we can only seek on time */ |
| if (format != GST_FORMAT_TIME) { |
| GST_DEBUG_OBJECT (demux, "Can only seek on TIME"); |
| return FALSE; |
| } |
| |
| /* copy segment, we need this because we still need the old |
| * segment when we close the current segment. */ |
| memcpy (&seeksegment, &demux->common.segment, sizeof (GstSegment)); |
| |
| /* pull mode without index means that the actual duration is not known, |
| * we might be playing a file that's still being recorded |
| * so, invalidate our current duration, which is only a moving target, |
| * and should not be used to clamp anything */ |
| if (!demux->streaming && !demux->common.index && demux->invalid_duration) { |
| seeksegment.duration = GST_CLOCK_TIME_NONE; |
| } |
| |
| GST_DEBUG_OBJECT (demux, "configuring seek"); |
| /* Subtract stream_start_time so we always seek on a segment |
| * in stream time */ |
| if (GST_CLOCK_TIME_IS_VALID (demux->stream_start_time)) { |
| seeksegment.start -= demux->stream_start_time; |
| seeksegment.position -= demux->stream_start_time; |
| if (GST_CLOCK_TIME_IS_VALID (seeksegment.stop)) |
| seeksegment.stop -= demux->stream_start_time; |
| else |
| seeksegment.stop = seeksegment.duration; |
| } |
| |
| gst_segment_do_seek (&seeksegment, rate, format, flags, |
| cur_type, cur, stop_type, stop, &update); |
| |
| /* Restore the clip timestamp offset */ |
| if (GST_CLOCK_TIME_IS_VALID (demux->stream_start_time)) { |
| seeksegment.position += demux->stream_start_time; |
| seeksegment.start += demux->stream_start_time; |
| if (!GST_CLOCK_TIME_IS_VALID (seeksegment.stop)) |
| seeksegment.stop = seeksegment.duration; |
| if (GST_CLOCK_TIME_IS_VALID (seeksegment.stop)) |
| seeksegment.stop += demux->stream_start_time; |
| } |
| |
| /* restore segment duration (if any effect), |
| * would be determined again when parsing, but anyway ... */ |
| seeksegment.duration = demux->common.segment.duration; |
| |
| flush = ! !(flags & GST_SEEK_FLAG_FLUSH); |
| keyunit = ! !(flags & GST_SEEK_FLAG_KEY_UNIT); |
| after = ! !(flags & GST_SEEK_FLAG_SNAP_AFTER); |
| before = ! !(flags & GST_SEEK_FLAG_SNAP_BEFORE); |
| |
| /* always do full update if flushing, |
| * otherwise problems might arise downstream with missing keyframes etc */ |
| update = update || flush; |
| |
| GST_DEBUG_OBJECT (demux, "New segment %" GST_SEGMENT_FORMAT, &seeksegment); |
| |
| /* check sanity before we start flushing and all that */ |
| snap_next = after && !before; |
| if (seeksegment.rate < 0) |
| snap_dir = snap_next ? GST_SEARCH_MODE_BEFORE : GST_SEARCH_MODE_AFTER; |
| else |
| snap_dir = snap_next ? GST_SEARCH_MODE_AFTER : GST_SEARCH_MODE_BEFORE; |
| |
| GST_OBJECT_LOCK (demux); |
| track = gst_matroska_read_common_get_seek_track (&demux->common, track); |
| if ((entry = gst_matroska_read_common_do_index_seek (&demux->common, track, |
| seeksegment.position, &demux->seek_index, &demux->seek_entry, |
| snap_dir)) == NULL) { |
| /* pull mode without index can scan later on */ |
| if (demux->streaming) { |
| GST_DEBUG_OBJECT (demux, "No matching seek entry in index"); |
| GST_OBJECT_UNLOCK (demux); |
| return FALSE; |
| } else if (rate < 0.0) { |
| /* FIXME: We should build an index during playback or when scanning |
| * that can be used here. The reverse playback code requires seek_index |
| * and seek_entry to be set! |
| */ |
| GST_DEBUG_OBJECT (demux, |
| "No matching seek entry in index, needed for reverse playback"); |
| GST_OBJECT_UNLOCK (demux); |
| return FALSE; |
| } |
| } |
| GST_DEBUG_OBJECT (demux, "Seek position looks sane"); |
| GST_OBJECT_UNLOCK (demux); |
| |
| if (!update) { |
| /* only have to update some segment, |
| * but also still have to honour flush and so on */ |
| GST_DEBUG_OBJECT (demux, "... no update"); |
| /* bad goto, bad ... */ |
| goto next; |
| } |
| |
| if (demux->streaming) |
| goto finish; |
| |
| next: |
| if (flush) { |
| GstEvent *flush_event = gst_event_new_flush_start (); |
| gst_event_set_seqnum (flush_event, seqnum); |
| GST_DEBUG_OBJECT (demux, "Starting flush"); |
| gst_pad_push_event (demux->common.sinkpad, gst_event_ref (flush_event)); |
| gst_matroska_demux_send_event (demux, flush_event); |
| } else { |
| GST_DEBUG_OBJECT (demux, "Non-flushing seek, pausing task"); |
| gst_pad_pause_task (demux->common.sinkpad); |
| } |
| /* ouch */ |
| if (!update) { |
| GST_PAD_STREAM_LOCK (demux->common.sinkpad); |
| pad_locked = TRUE; |
| goto exit; |
| } |
| |
| /* 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_DEBUG_OBJECT (demux, "Waiting for streaming to stop"); |
| GST_PAD_STREAM_LOCK (demux->common.sinkpad); |
| pad_locked = TRUE; |
| |
| /* pull mode without index can do some scanning */ |
| if (!demux->streaming && !entry) { |
| GstEvent *flush_event; |
| |
| /* need to stop flushing upstream as we need it next */ |
| if (flush) { |
| flush_event = gst_event_new_flush_stop (TRUE); |
| gst_event_set_seqnum (flush_event, seqnum); |
| gst_pad_push_event (demux->common.sinkpad, flush_event); |
| } |
| entry = gst_matroska_demux_search_pos (demux, seeksegment.position); |
| /* keep local copy */ |
| if (entry) { |
| scan_entry = *entry; |
| g_free (entry); |
| entry = &scan_entry; |
| } else { |
| GST_DEBUG_OBJECT (demux, "Scan failed to find matching position"); |
| if (flush) { |
| flush_event = gst_event_new_flush_stop (TRUE); |
| gst_event_set_seqnum (flush_event, seqnum); |
| gst_matroska_demux_send_event (demux, flush_event); |
| } |
| goto seek_error; |
| } |
| } |
| |
| finish: |
| if (keyunit) { |
| GST_DEBUG_OBJECT (demux, "seek to key unit, adjusting segment start from %" |
| GST_TIME_FORMAT " to %" GST_TIME_FORMAT, |
| GST_TIME_ARGS (seeksegment.start), GST_TIME_ARGS (entry->time)); |
| seeksegment.start = MAX (entry->time, demux->stream_start_time); |
| seeksegment.position = seeksegment.start; |
| seeksegment.time = seeksegment.start - demux->stream_start_time; |
| } |
| |
| if (demux->streaming) { |
| GST_OBJECT_LOCK (demux); |
| /* track real position we should start at */ |
| GST_DEBUG_OBJECT (demux, "storing segment start"); |
| demux->requested_seek_time = seeksegment.position; |
| demux->seek_offset = entry->pos + demux->common.ebml_segment_start; |
| GST_OBJECT_UNLOCK (demux); |
| /* need to seek to cluster start to pick up cluster time */ |
| /* upstream takes care of flushing and all that |
| * ... and newsegment event handling takes care of the rest */ |
| return perform_seek_to_offset (demux, rate, |
| entry->pos + demux->common.ebml_segment_start, seqnum, flags); |
| } |
| |
| exit: |
| if (flush) { |
| GstEvent *flush_event = gst_event_new_flush_stop (TRUE); |
| gst_event_set_seqnum (flush_event, seqnum); |
| GST_DEBUG_OBJECT (demux, "Stopping flush"); |
| gst_pad_push_event (demux->common.sinkpad, gst_event_ref (flush_event)); |
| gst_matroska_demux_send_event (demux, flush_event); |
| } |
| |
| GST_OBJECT_LOCK (demux); |
| /* now update the real segment info */ |
| GST_DEBUG_OBJECT (demux, "Committing new seek segment"); |
| memcpy (&demux->common.segment, &seeksegment, sizeof (GstSegment)); |
| GST_OBJECT_UNLOCK (demux); |
| |
| /* update some (segment) state */ |
| if (!gst_matroska_demux_move_to_entry (demux, entry, TRUE, update)) |
| goto seek_error; |
| |
| /* notify start of new segment */ |
| if (demux->common.segment.flags & GST_SEEK_FLAG_SEGMENT) { |
| GstMessage *msg; |
| |
| msg = gst_message_new_segment_start (GST_OBJECT (demux), |
| GST_FORMAT_TIME, demux->common.segment.start); |
| gst_message_set_seqnum (msg, seqnum); |
| gst_element_post_message (GST_ELEMENT (demux), msg); |
| } |
| |
| GST_OBJECT_LOCK (demux); |
| if (demux->new_segment) |
| gst_event_unref (demux->new_segment); |
| |
| /* On port from 0.10, discarded !update (for segment.update) here, FIXME? */ |
| demux->new_segment = gst_event_new_segment (&demux->common.segment); |
| gst_event_set_seqnum (demux->new_segment, seqnum); |
| if (demux->common.segment.rate < 0 && demux->common.segment.stop == -1) |
| demux->to_time = demux->common.segment.position; |
| else |
| demux->to_time = GST_CLOCK_TIME_NONE; |
| demux->segment_seqnum = seqnum; |
| GST_OBJECT_UNLOCK (demux); |
| |
| /* restart our task since it might have been stopped when we did the |
| * flush. */ |
| gst_pad_start_task (demux->common.sinkpad, |
| (GstTaskFunction) gst_matroska_demux_loop, demux->common.sinkpad, NULL); |
| |
| /* streaming can continue now */ |
| if (pad_locked) { |
| GST_PAD_STREAM_UNLOCK (demux->common.sinkpad); |
| } |
| |
| return TRUE; |
| |
| seek_error: |
| { |
| if (pad_locked) { |
| GST_PAD_STREAM_UNLOCK (demux->common.sinkpad); |
| } |
| GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL), ("Got a seek error")); |
| return FALSE; |
| } |
| } |
| |
| /* |
| * Handle whether we can perform the seek event or if we have to let the chain |
| * function handle seeks to build the seek indexes first. |
| */ |
| static gboolean |
| gst_matroska_demux_handle_seek_push (GstMatroskaDemux * demux, GstPad * pad, |
| GstEvent * event) |
| { |
| GstSeekFlags flags; |
| GstSeekType cur_type, stop_type; |
| GstFormat format; |
| gdouble rate; |
| gint64 cur, stop; |
| |
| gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur, |
| &stop_type, &stop); |
| |
| /* sanity checks */ |
| |
| /* we can only seek on time */ |
| if (format != GST_FORMAT_TIME) { |
| GST_DEBUG_OBJECT (demux, "Can only seek on TIME"); |
| return FALSE; |
| } |
| |
| if (stop_type != GST_SEEK_TYPE_NONE && stop != GST_CLOCK_TIME_NONE) { |
| GST_DEBUG_OBJECT (demux, "Seek end-time not supported in streaming mode"); |
| return FALSE; |
| } |
| |
| if (!(flags & GST_SEEK_FLAG_FLUSH)) { |
| GST_DEBUG_OBJECT (demux, |
| "Non-flushing seek not supported in streaming mode"); |
| return FALSE; |
| } |
| |
| if (flags & GST_SEEK_FLAG_SEGMENT) { |
| GST_DEBUG_OBJECT (demux, "Segment seek not supported in streaming mode"); |
| return FALSE; |
| } |
| |
| /* check for having parsed index already */ |
| if (!demux->common.index_parsed) { |
| gboolean building_index; |
| guint64 offset = 0; |
| |
| if (!demux->index_offset) { |
| GST_DEBUG_OBJECT (demux, "no index (location); no seek in push mode"); |
| return FALSE; |
| } |
| |
| GST_OBJECT_LOCK (demux); |
| /* handle the seek event in the chain function */ |
| demux->common.state = GST_MATROSKA_READ_STATE_SEEK; |
| /* no more seek can be issued until state reset to _DATA */ |
| |
| /* copy the event */ |
| if (demux->seek_event) |
| gst_event_unref (demux->seek_event); |
| demux->seek_event = gst_event_ref (event); |
| |
| /* set the building_index flag so that only one thread can setup the |
| * structures for index seeking. */ |
| building_index = demux->building_index; |
| if (!building_index) { |
| demux->building_index = TRUE; |
| offset = demux->index_offset; |
| } |
| GST_OBJECT_UNLOCK (demux); |
| |
| if (!building_index) { |
| /* seek to the first subindex or legacy index */ |
| GST_INFO_OBJECT (demux, "Seeking to Cues at %" G_GUINT64_FORMAT, offset); |
| return perform_seek_to_offset (demux, rate, offset, |
| gst_event_get_seqnum (event), GST_SEEK_FLAG_NONE); |
| } |
| |
| /* well, we are handling it already */ |
| return TRUE; |
| } |
| |
| /* delegate to tweaked regular seek */ |
| return gst_matroska_demux_handle_seek_event (demux, pad, event); |
| } |
| |
| static gboolean |
| gst_matroska_demux_handle_src_event (GstPad * pad, GstObject * parent, |
| GstEvent * event) |
| { |
| GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent); |
| gboolean res = TRUE; |
| |
| switch (GST_EVENT_TYPE (event)) { |
| case GST_EVENT_SEEK: |
| /* no seeking until we are (safely) ready */ |
| if (demux->common.state != GST_MATROSKA_READ_STATE_DATA) { |
| GST_DEBUG_OBJECT (demux, "not ready for seeking yet"); |
| gst_event_unref (event); |
| return FALSE; |
| } |
| if (!demux->streaming) |
| res = gst_matroska_demux_handle_seek_event (demux, pad, event); |
| else |
| res = gst_matroska_demux_handle_seek_push (demux, pad, event); |
| gst_event_unref (event); |
| break; |
| |
| case GST_EVENT_QOS: |
| { |
| GstMatroskaTrackContext *context = gst_pad_get_element_private (pad); |
| if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO) { |
| GstMatroskaTrackVideoContext *videocontext = |
| (GstMatroskaTrackVideoContext *) context; |
| gdouble proportion; |
| GstClockTimeDiff diff; |
| GstClockTime timestamp; |
| |
| gst_event_parse_qos (event, NULL, &proportion, &diff, ×tamp); |
| |
| GST_OBJECT_LOCK (demux); |
| videocontext->earliest_time = timestamp + diff; |
| GST_OBJECT_UNLOCK (demux); |
| } |
| res = TRUE; |
| gst_event_unref (event); |
| break; |
| } |
| |
| case GST_EVENT_TOC_SELECT: |
| { |
| char *uid = NULL; |
| GstTocEntry *entry = NULL; |
| GstEvent *seek_event; |
| gint64 start_pos; |
| |
| if (!demux->common.toc) { |
| GST_DEBUG_OBJECT (demux, "no TOC to select"); |
| return FALSE; |
| } else { |
| gst_event_parse_toc_select (event, &uid); |
| if (uid != NULL) { |
| GST_OBJECT_LOCK (demux); |
| entry = gst_toc_find_entry (demux->common.toc, uid); |
| if (entry == NULL) { |
| GST_OBJECT_UNLOCK (demux); |
| GST_WARNING_OBJECT (demux, "no TOC entry with given UID: %s", uid); |
| res = FALSE; |
| } else { |
| gst_toc_entry_get_start_stop_times (entry, &start_pos, NULL); |
| GST_OBJECT_UNLOCK (demux); |
| seek_event = gst_event_new_seek (1.0, |
| GST_FORMAT_TIME, |
| GST_SEEK_FLAG_FLUSH, |
| GST_SEEK_TYPE_SET, start_pos, GST_SEEK_TYPE_SET, -1); |
| res = gst_matroska_demux_handle_seek_event (demux, pad, seek_event); |
| gst_event_unref (seek_event); |
| } |
| g_free (uid); |
| } else { |
| GST_WARNING_OBJECT (demux, "received empty TOC select event"); |
| res = FALSE; |
| } |
| } |
| gst_event_unref (event); |
| break; |
| } |
| |
| /* events we don't need to handle */ |
| case GST_EVENT_NAVIGATION: |
| gst_event_unref (event); |
| res = FALSE; |
| break; |
| |
| case GST_EVENT_LATENCY: |
| default: |
| res = gst_pad_push_event (demux->common.sinkpad, event); |
| break; |
| } |
| |
| return res; |
| } |
| |
| static GstFlowReturn |
| gst_matroska_demux_seek_to_previous_keyframe (GstMatroskaDemux * demux) |
| { |
| GstFlowReturn ret = GST_FLOW_EOS; |
| gboolean done = TRUE; |
| gint i; |
| |
| g_return_val_if_fail (demux->seek_index, GST_FLOW_EOS); |
| g_return_val_if_fail (demux->seek_entry < demux->seek_index->len, |
| GST_FLOW_EOS); |
| |
| GST_DEBUG_OBJECT (demux, "locating previous keyframe"); |
| |
| if (!demux->seek_entry) { |
| GST_DEBUG_OBJECT (demux, "no earlier index entry"); |
| goto exit; |
| } |
| |
| for (i = 0; i < demux->common.src->len; i++) { |
| GstMatroskaTrackContext *stream = g_ptr_array_index (demux->common.src, i); |
| |
| GST_DEBUG_OBJECT (demux, "segment start %" GST_TIME_FORMAT |
| ", stream %d at %" GST_TIME_FORMAT, |
| GST_TIME_ARGS (demux->common.segment.start), stream->index, |
| GST_TIME_ARGS (stream->from_time)); |
| if (GST_CLOCK_TIME_IS_VALID (stream->from_time)) { |
| if (stream->from_time > demux->common.segment.start) { |
| GST_DEBUG_OBJECT (demux, "stream %d not finished yet", stream->index); |
| done = FALSE; |
| } |
| } else { |
| /* nothing pushed for this stream; |
| * likely seek entry did not start at keyframe, so all was skipped. |
| * So we need an earlier entry */ |
| done = FALSE; |
| } |
| } |
| |
| if (!done) { |
| GstMatroskaIndex *entry; |
| |
| entry = &g_array_index (demux->seek_index, GstMatroskaIndex, |
| --demux->seek_entry); |
| if (!gst_matroska_demux_move_to_entry (demux, entry, FALSE, TRUE)) |
| goto exit; |
| |
| ret = GST_FLOW_OK; |
| } |
| |
| exit: |
| return ret; |
| } |
| |
| static GstFlowReturn |
| gst_matroska_demux_parse_tracks (GstMatroskaDemux * demux, GstEbmlRead * ebml) |
| { |
| GstFlowReturn ret = GST_FLOW_OK; |
| guint32 id; |
| |
| DEBUG_ELEMENT_START (demux, ebml, "Tracks"); |
| |
| if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) { |
| DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret); |
| return ret; |
| } |
| |
| while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) { |
| if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK) |
| break; |
| |
| switch (id) { |
| /* one track within the "all-tracks" header */ |
| case GST_MATROSKA_ID_TRACKENTRY: |
| ret = gst_matroska_demux_add_stream (demux, ebml); |
| break; |
| |
| default: |
| ret = gst_matroska_read_common_parse_skip (&demux->common, ebml, |
| "Track", id); |
| break; |
| } |
| } |
| DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret); |
| |
| demux->tracks_parsed = TRUE; |
| |
| return ret; |
| } |
| |
| /* |
| * Read signed/unsigned "EBML" numbers. |
| * Return: number of bytes processed. |
| */ |
| |
| static gint |
| gst_matroska_ebmlnum_uint (guint8 * data, guint size, guint64 * num) |
| { |
| gint len_mask = 0x80, read = 1, n = 1, num_ffs = 0; |
| guint64 total; |
| |
| if (size <= 0) { |
| return -1; |
| } |
| |
| total = data[0]; |
| while (read <= 8 && !(total & len_mask)) { |
| read++; |
| len_mask >>= 1; |
| } |
| if (read > 8) |
| return -1; |
| |
| if ((total &= (len_mask - 1)) == len_mask - 1) |
| num_ffs++; |
| if (size < read) |
| return -1; |
| while (n < read) { |
| if (data[n] == 0xff) |
| num_ffs++; |
| total = (total << 8) | data[n]; |
| n++; |
| } |
| |
| if (read == num_ffs && total != 0) |
| *num = G_MAXUINT64; |
| else |
| *num = total; |
| |
| return read; |
| } |
| |
| static gint |
| gst_matroska_ebmlnum_sint (guint8 * data, guint size, gint64 * num) |
| { |
| guint64 unum; |
| gint res; |
| |
| /* read as unsigned number first */ |
| if ((res = gst_matroska_ebmlnum_uint (data, size, &unum)) < 0) |
| return -1; |
| |
| /* make signed */ |
| if (unum == G_MAXUINT64) |
| *num = G_MAXINT64; |
| else |
| *num = unum - ((1 << ((7 * res) - 1)) - 1); |
| |
| return res; |
| } |
| |
| /* |
| * Mostly used for subtitles. We add void filler data for each |
| * lagging stream to make sure we don't deadlock. |
| */ |
| |
| static void |
| gst_matroska_demux_sync_streams (GstMatroskaDemux * demux) |
| { |
| GstClockTime gap_threshold; |
| gint stream_nr; |
| |
| GST_OBJECT_LOCK (demux); |
| |
| GST_LOG_OBJECT (demux, "Sync to %" GST_TIME_FORMAT, |
| GST_TIME_ARGS (demux->common.segment.position)); |
| |
| g_assert (demux->common.num_streams == demux->common.src->len); |
| for (stream_nr = 0; stream_nr < demux->common.src->len; stream_nr++) { |
| GstMatroskaTrackContext *context; |
| |
| context = g_ptr_array_index (demux->common.src, stream_nr); |
| |
| GST_LOG_OBJECT (demux, |
| "Checking for resync on stream %d (%" GST_TIME_FORMAT ")", stream_nr, |
| GST_TIME_ARGS (context->pos)); |
| |
| /* Only send gap events on non-subtitle streams if lagging way behind. |
| * The 0.5 second threshold for subtitle streams is also quite random. */ |
| if (context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE) |
| gap_threshold = GST_SECOND / 2; |
| else |
| gap_threshold = 3 * GST_SECOND; |
| |
| /* Lag need only be considered if we have advanced into requested segment */ |
| if (GST_CLOCK_TIME_IS_VALID (context->pos) && |
| GST_CLOCK_TIME_IS_VALID (demux->common.segment.position) && |
| demux->common.segment.position > demux->common.segment.start && |
| context->pos + gap_threshold < demux->common.segment.position) { |
| |
| GstEvent *event; |
| guint64 start = context->pos; |
| guint64 stop = demux->common.segment.position - gap_threshold; |
| |
| GST_DEBUG_OBJECT (demux, |
| "Synchronizing stream %d with other by advancing time from %" |
| GST_TIME_FORMAT " to %" GST_TIME_FORMAT, stream_nr, |
| GST_TIME_ARGS (start), GST_TIME_ARGS (stop)); |
| |
| context->pos = stop; |
| |
| event = gst_event_new_gap (start, stop - start); |
| GST_OBJECT_UNLOCK (demux); |
| gst_pad_push_event (context->pad, event); |
| GST_OBJECT_LOCK (demux); |
| } |
| } |
| |
| GST_OBJECT_UNLOCK (demux); |
| } |
| |
| static GstFlowReturn |
| gst_matroska_demux_push_stream_headers (GstMatroskaDemux * demux, |
| GstMatroskaTrackContext * stream) |
| { |
| GstFlowReturn ret = GST_FLOW_OK; |
| gint i, num; |
| |
| num = gst_buffer_list_length (stream->stream_headers); |
| for (i = 0; i < num; ++i) { |
| GstBuffer *buf; |
| |
| buf = gst_buffer_list_get (stream->stream_headers, i); |
| buf = gst_buffer_copy (buf); |
| |
| GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_HEADER); |
| |
| if (stream->set_discont) { |
| GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT); |
| stream->set_discont = FALSE; |
| } else { |
| GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT); |
| } |
| |
| /* push out all headers in one go and use last flow return */ |
| ret = gst_pad_push (stream->pad, buf); |
| } |
| |
| /* don't need these any longer */ |
| gst_buffer_list_unref (stream->stream_headers); |
| stream->stream_headers = NULL; |
| |
| /* combine flows */ |
| ret = gst_flow_combiner_update_flow (demux->flowcombiner, ret); |
| |
| return ret; |
| } |
| |
| static void |
| gst_matroska_demux_push_dvd_clut_change_event (GstMatroskaDemux * demux, |
| GstMatroskaTrackContext * stream) |
| { |
| gchar *buf, *start; |
| |
| g_assert (!strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_VOBSUB)); |
| |
| if (!stream->codec_priv) |
| return; |
| |
| /* ideally, VobSub private data should be parsed and stored more convenient |
| * elsewhere, but for now, only interested in a small part */ |
| |
| /* make sure we have terminating 0 */ |
| buf = g_strndup (stream->codec_priv, stream->codec_priv_size); |
| |
| /* just locate and parse palette part */ |
| start = strstr (buf, "palette:"); |
| if (start) { |
| gint i; |
| guint32 clut[16]; |
| guint32 col; |
| guint8 r, g, b, y, u, v; |
| |
| start += 8; |
| while (g_ascii_isspace (*start)) |
| start++; |
| for (i = 0; i < 16; i++) { |
| if (sscanf (start, "%06x", &col) != 1) |
| break; |
| start += 6; |
| while ((*start == ',') || g_ascii_isspace (*start)) |
| start++; |
| /* sigh, need to convert this from vobsub pseudo-RGB to YUV */ |
| r = (col >> 16) & 0xff; |
| g = (col >> 8) & 0xff; |
| b = col & 0xff; |
| y = CLAMP ((0.1494 * r + 0.6061 * g + 0.2445 * b) * 219 / 255 + 16, 0, |
| 255); |
| u = CLAMP (0.6066 * r - 0.4322 * g - 0.1744 * b + 128, 0, 255); |
| v = CLAMP (-0.08435 * r - 0.3422 * g + 0.4266 * b + 128, 0, 255); |
| clut[i] = (y << 16) | (u << 8) | v; |
| } |
| |
| /* got them all without problems; build and send event */ |
| if (i == 16) { |
| GstStructure *s; |
| |
| s = gst_structure_new ("application/x-gst-dvd", "event", G_TYPE_STRING, |
| "dvd-spu-clut-change", "clut00", G_TYPE_INT, clut[0], "clut01", |
| G_TYPE_INT, clut[1], "clut02", G_TYPE_INT, clut[2], "clut03", |
| G_TYPE_INT, clut[3], "clut04", G_TYPE_INT, clut[4], "clut05", |
| G_TYPE_INT, clut[5], "clut06", G_TYPE_INT, clut[6], "clut07", |
| G_TYPE_INT, clut[7], "clut08", G_TYPE_INT, clut[8], "clut09", |
| G_TYPE_INT, clut[9], "clut10", G_TYPE_INT, clut[10], "clut11", |
| G_TYPE_INT, clut[11], "clut12", G_TYPE_INT, clut[12], "clut13", |
| G_TYPE_INT, clut[13], "clut14", G_TYPE_INT, clut[14], "clut15", |
| G_TYPE_INT, clut[15], NULL); |
| |
| gst_pad_push_event (stream->pad, |
| gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM_STICKY, s)); |
| } |
| } |
| g_free (buf); |
| } |
| |
| static void |
| gst_matroska_demux_push_codec_data_all (GstMatroskaDemux * demux) |
| { |
| gint stream_nr; |
| |
| g_assert (demux->common.num_streams == demux->common.src->len); |
| for (stream_nr = 0; stream_nr < demux->common.src->len; stream_nr++) { |
| GstMatroskaTrackContext *stream; |
| |
| stream = g_ptr_array_index (demux->common.src, stream_nr); |
| |
| if (stream->send_stream_headers) { |
| if (stream->stream_headers != NULL) { |
| gst_matroska_demux_push_stream_headers (demux, stream); |
| } else { |
| /* FIXME: perhaps we can just disable and skip this stream then */ |
| GST_ELEMENT_ERROR (demux, STREAM, DECODE, (NULL), |
| ("Failed to extract stream headers from codec private data")); |
| } |
| stream->send_stream_headers = FALSE; |
| } |
| |
| if (stream->send_dvd_event) { |
| gst_matroska_demux_push_dvd_clut_change_event (demux, stream); |
| /* FIXME: should we send this event again after (flushing) seek ? */ |
| stream->send_dvd_event = FALSE; |
| } |
| } |
| |
| } |
| |
| static GstFlowReturn |
| gst_matroska_demux_add_mpeg_seq_header (GstElement * element, |
| GstMatroskaTrackContext * stream, GstBuffer ** buf) |
| { |
| guint8 *seq_header; |
| guint seq_header_len; |
| guint32 header, tmp; |
| |
| if (stream->codec_state) { |
| seq_header = stream->codec_state; |
| seq_header_len = stream->codec_state_size; |
| } else if (stream->codec_priv) { |
| seq_header = stream->codec_priv; |
| seq_header_len = stream->codec_priv_size; |
| } else { |
| return GST_FLOW_OK; |
| } |
| |
| /* Sequence header only needed for keyframes */ |
| if (GST_BUFFER_FLAG_IS_SET (*buf, GST_BUFFER_FLAG_DELTA_UNIT)) |
| return GST_FLOW_OK; |
| |
| if (gst_buffer_get_size (*buf) < 4) |
| return GST_FLOW_OK; |
| |
| gst_buffer_extract (*buf, 0, &tmp, sizeof (guint32)); |
| header = GUINT32_FROM_BE (tmp); |
| |
| /* Sequence start code, if not found prepend */ |
| if (header != 0x000001b3) { |
| GstBuffer *newbuf; |
| |
| GST_DEBUG_OBJECT (element, "Prepending MPEG sequence header"); |
| |
| newbuf = gst_buffer_new_wrapped (g_memdup (seq_header, seq_header_len), |
| seq_header_len); |
| |
| gst_buffer_copy_into (newbuf, *buf, GST_BUFFER_COPY_TIMESTAMPS | |
| GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_MEMORY, 0, |
| gst_buffer_get_size (*buf)); |
| |
| gst_buffer_unref (*buf); |
| *buf = newbuf; |
| } |
| |
| return GST_FLOW_OK; |
| } |
| |
| static GstFlowReturn |
| gst_matroska_demux_add_wvpk_header (GstElement * element, |
| GstMatroskaTrackContext * stream, GstBuffer ** buf) |
| { |
| GstMatroskaTrackAudioContext *audiocontext = |
| (GstMatroskaTrackAudioContext *) stream; |
| GstBuffer *newbuf = NULL; |
| GstMapInfo map, outmap; |
| guint8 *buf_data, *data; |
| Wavpack4Header wvh; |
| |
| wvh.ck_id[0] = 'w'; |
| wvh.ck_id[1] = 'v'; |
| wvh.ck_id[2] = 'p'; |
| wvh.ck_id[3] = 'k'; |
| |
| wvh.version = GST_READ_UINT16_LE (stream->codec_priv); |
| wvh.track_no = 0; |
| wvh.index_no = 0; |
| wvh.total_samples = -1; |
| wvh.block_index = audiocontext->wvpk_block_index; |
| |
| if (audiocontext->channels <= 2) { |
| guint32 block_samples, tmp; |
| gsize size = gst_buffer_get_size (*buf); |
| |
| gst_buffer_extract (*buf, 0, &tmp, sizeof (guint32)); |
| block_samples = GUINT32_FROM_LE (tmp); |
| /* we need to reconstruct the header of the wavpack block */ |
| |
| /* -20 because ck_size is the size of the wavpack block -8 |
| * and lace_size is the size of the wavpack block + 12 |
| * (the three guint32 of the header that already are in the buffer) */ |
| wvh.ck_size = size + sizeof (Wavpack4Header) - 20; |
| |
| /* block_samples, flags and crc are already in the buffer */ |
| newbuf = gst_buffer_new_allocate (NULL, sizeof (Wavpack4Header) - 12, NULL); |
| |
| gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE); |
| data = outmap.data; |
| data[0] = 'w'; |
| data[1] = 'v'; |
| data[2] = 'p'; |
| data[3] = 'k'; |
| GST_WRITE_UINT32_LE (data + 4, wvh.ck_size); |
| GST_WRITE_UINT16_LE (data + 8, wvh.version); |
| GST_WRITE_UINT8 (data + 10, wvh.track_no); |
| GST_WRITE_UINT8 (data + 11, wvh.index_no); |
| GST_WRITE_UINT32_LE (data + 12, wvh.total_samples); |
| GST_WRITE_UINT32_LE (data + 16, wvh.block_index); |
| gst_buffer_unmap (newbuf, &outmap); |
| |
| /* Append data from buf: */ |
| gst_buffer_copy_into (newbuf, *buf, GST_BUFFER_COPY_TIMESTAMPS | |
| GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_MEMORY, 0, size); |
| |
| gst_buffer_unref (*buf); |
| *buf = newbuf; |
| audiocontext->wvpk_block_index += block_samples; |
| } else { |
| guint8 *outdata = NULL; |
| guint outpos = 0; |
| gsize buf_size, size, out_size = 0; |
| guint32 block_samples, flags, crc, blocksize; |
| |
| gst_buffer_map (*buf, &map, GST_MAP_READ); |
| buf_data = map.data; |
| buf_size = map.size; |
| |
| if (buf_size < 4) { |
| GST_ERROR_OBJECT (element, "Too small wavpack buffer"); |
| gst_buffer_unmap (*buf, &map); |
| return GST_FLOW_ERROR; |
| } |
| |
| data = buf_data; |
| size = buf_size; |
| |
| block_samples = GST_READ_UINT32_LE (data); |
| data += 4; |
| size -= 4; |
| |
| while (size > 12) { |
| flags = GST_READ_UINT32_LE (data); |
| data += 4; |
| size -= 4; |
| crc = GST_READ_UINT32_LE (data); |
| data += 4; |
| size -= 4; |
| blocksize = GST_READ_UINT32_LE (data); |
| data += 4; |
| size -= 4; |
| |
| if (blocksize == 0 || size < blocksize) |
| break; |
| |
| g_assert ((newbuf == NULL) == (outdata == NULL)); |
| |
| if (newbuf == NULL) { |
| out_size = sizeof (Wavpack4Header) + blocksize; |
| newbuf = gst_buffer_new_allocate (NULL, out_size, NULL); |
| |
| gst_buffer_copy_into (newbuf, *buf, |
| GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS, 0, -1); |
| |
| outpos = 0; |
| gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE); |
| outdata = outmap.data; |
| } else { |
| gst_buffer_unmap (newbuf, &outmap); |
| out_size += sizeof (Wavpack4Header) + blocksize; |
| gst_buffer_set_size (newbuf, out_size); |
| gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE); |
| outdata = outmap.data; |
| } |
| |
| outdata[outpos] = 'w'; |
| outdata[outpos + 1] = 'v'; |
| outdata[outpos + 2] = 'p'; |
| outdata[outpos + 3] = 'k'; |
| outpos += 4; |
| |
| GST_WRITE_UINT32_LE (outdata + outpos, |
| blocksize + sizeof (Wavpack4Header) - 8); |
| GST_WRITE_UINT16_LE (outdata + outpos + 4, wvh.version); |
| GST_WRITE_UINT8 (outdata + outpos + 6, wvh.track_no); |
| GST_WRITE_UINT8 (outdata + outpos + 7, wvh.index_no); |
| GST_WRITE_UINT32_LE (outdata + outpos + 8, wvh.total_samples); |
| GST_WRITE_UINT32_LE (outdata + outpos + 12, wvh.block_index); |
| GST_WRITE_UINT32_LE (outdata + outpos + 16, block_samples); |
| GST_WRITE_UINT32_LE (outdata + outpos + 20, flags); |
| GST_WRITE_UINT32_LE (outdata + outpos + 24, crc); |
| outpos += 28; |
| |
| memmove (outdata + outpos, data, blocksize); |
| outpos += blocksize; |
| data += blocksize; |
| size -= blocksize; |
| } |
| gst_buffer_unmap (*buf, &map); |
| gst_buffer_unref (*buf); |
| |
| if (newbuf) |
| gst_buffer_unmap (newbuf, &outmap); |
| |
| *buf = newbuf; |
| audiocontext->wvpk_block_index += block_samples; |
| } |
| |
| return GST_FLOW_OK; |
| } |
| |
| static GstFlowReturn |
| gst_matroska_demux_add_prores_header (GstElement * element, |
| GstMatroskaTrackContext * stream, GstBuffer ** buf) |
| { |
| GstBuffer *newbuf = gst_buffer_new_allocate (NULL, 8, NULL); |
| GstMapInfo map; |
| guint32 frame_size; |
| |
| if (!gst_buffer_map (newbuf, &map, GST_MAP_WRITE)) { |
| GST_ERROR ("Failed to map newly allocated buffer"); |
| return GST_FLOW_ERROR; |
| } |
| |
| frame_size = gst_buffer_get_size (*buf); |
| |
| GST_WRITE_UINT32_BE (map.data, frame_size); |
| map.data[4] = 'i'; |
| map.data[5] = 'c'; |
| map.data[6] = 'p'; |
| map.data[7] = 'f'; |
| |
| gst_buffer_unmap (newbuf, &map); |
| *buf = gst_buffer_append (newbuf, *buf); |
| |
| return GST_FLOW_OK; |
| } |
| |
| /* @text must be null-terminated */ |
| static gboolean |
| gst_matroska_demux_subtitle_chunk_has_tag (GstElement * element,<
|