1 /* GStreamer Matroska muxer/demuxer
2 * (c) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
3 * (c) 2006 Tim-Philipp Müller <tim centricular net>
4 * (c) 2008 Sebastian Dröge <slomo@circular-chaos.org>
5 * (c) 2011 Debarshi Ray <rishi@gnu.org>
7 * matroska-demux.c: matroska file/stream demuxer
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Library General Public
11 * License as published by the Free Software Foundation; either
12 * version 2 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Library General Public License for more details.
19 * You should have received a copy of the GNU Library General Public
20 * License along with this library; if not, write to the
21 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
22 * Boston, MA 02110-1301, USA.
25 /* TODO: check CRC32 if present
26 * TODO: there can be a segment after the first segment. Handle like
27 * chained oggs. Fixes #334082
28 * TODO: Test samples: http://www.matroska.org/samples/matrix/index.html
29 * http://samples.mplayerhq.hu/Matroska/
30 * TODO: check if demuxing is done correct for all codecs according to spec
31 * TODO: seeking with incomplete or without CUE
35 * SECTION:element-matroskademux
37 * matroskademux demuxes a Matroska file into the different contained streams.
40 * <title>Example launch line</title>
42 * gst-launch-1.0 -v filesrc location=/path/to/mkv ! matroskademux ! vorbisdec ! audioconvert ! audioresample ! autoaudiosink
43 * ]| This pipeline demuxes a Matroska file and outputs the contained Vorbis audio.
54 #include <glib/gprintf.h>
56 #include <gst/base/base.h>
58 /* For AVI compatibility mode
59 and for fourcc stuff */
60 #include <gst/riff/riff-read.h>
61 #include <gst/riff/riff-ids.h>
62 #include <gst/riff/riff-media.h>
64 #include <gst/audio/audio.h>
65 #include <gst/tag/tag.h>
66 #include <gst/pbutils/pbutils.h>
67 #include <gst/video/video.h>
69 #include "matroska-demux.h"
70 #include "matroska-ids.h"
72 GST_DEBUG_CATEGORY_STATIC (matroskademux_debug);
73 #define GST_CAT_DEFAULT matroskademux_debug
75 #define DEBUG_ELEMENT_START(demux, ebml, element) \
76 GST_DEBUG_OBJECT (demux, "Parsing " element " element at offset %" \
77 G_GUINT64_FORMAT, gst_ebml_read_get_pos (ebml))
79 #define DEBUG_ELEMENT_STOP(demux, ebml, element, ret) \
80 GST_DEBUG_OBJECT (demux, "Parsing " element " element " \
81 " finished with '%s'", gst_flow_get_name (ret))
89 PROP_MAX_BACKTRACK_DISTANCE
92 #define DEFAULT_MAX_GAP_TIME (2 * GST_SECOND)
93 #define DEFAULT_MAX_BACKTRACK_DISTANCE 30
94 #define INVALID_DATA_THRESHOLD (2 * 1024 * 1024)
96 static GstStaticPadTemplate sink_templ = GST_STATIC_PAD_TEMPLATE ("sink",
99 GST_STATIC_CAPS ("audio/x-matroska; video/x-matroska; "
100 "video/x-matroska-3d; audio/webm; video/webm")
103 /* TODO: fill in caps! */
105 static GstStaticPadTemplate audio_src_templ =
106 GST_STATIC_PAD_TEMPLATE ("audio_%u",
109 GST_STATIC_CAPS ("ANY")
112 static GstStaticPadTemplate video_src_templ =
113 GST_STATIC_PAD_TEMPLATE ("video_%u",
116 GST_STATIC_CAPS ("ANY")
119 static GstStaticPadTemplate subtitle_src_templ =
120 GST_STATIC_PAD_TEMPLATE ("subtitle_%u",
123 GST_STATIC_CAPS ("text/x-raw, format=pango-markup; application/x-ssa; "
124 "application/x-ass;application/x-usf; subpicture/x-dvd; "
125 "subpicture/x-pgs; subtitle/x-kate; " "application/x-subtitle-unknown")
128 static GstFlowReturn gst_matroska_demux_parse_id (GstMatroskaDemux * demux,
129 guint32 id, guint64 length, guint needed);
131 /* element functions */
132 static void gst_matroska_demux_loop (GstPad * pad);
134 static gboolean gst_matroska_demux_element_send_event (GstElement * element,
136 static gboolean gst_matroska_demux_element_query (GstElement * element,
140 static gboolean gst_matroska_demux_sink_activate (GstPad * sinkpad,
142 static gboolean gst_matroska_demux_sink_activate_mode (GstPad * sinkpad,
143 GstObject * parent, GstPadMode mode, gboolean active);
145 static gboolean gst_matroska_demux_handle_seek_event (GstMatroskaDemux * demux,
146 GstPad * pad, GstEvent * event);
147 static gboolean gst_matroska_demux_handle_src_event (GstPad * pad,
148 GstObject * parent, GstEvent * event);
149 static gboolean gst_matroska_demux_handle_src_query (GstPad * pad,
150 GstObject * parent, GstQuery * query);
152 static gboolean gst_matroska_demux_handle_sink_event (GstPad * pad,
153 GstObject * parent, GstEvent * event);
154 static gboolean gst_matroska_demux_handle_sink_query (GstPad * pad,
155 GstObject * parent, GstQuery * query);
156 static GstFlowReturn gst_matroska_demux_chain (GstPad * pad,
157 GstObject * object, GstBuffer * buffer);
159 static GstStateChangeReturn
160 gst_matroska_demux_change_state (GstElement * element,
161 GstStateChange transition);
164 gst_matroska_demux_set_index (GstElement * element, GstIndex * index);
165 static GstIndex *gst_matroska_demux_get_index (GstElement * element);
169 static GstCaps *gst_matroska_demux_video_caps (GstMatroskaTrackVideoContext
170 * videocontext, const gchar * codec_id, guint8 * data, guint size,
171 gchar ** codec_name, guint32 * riff_fourcc);
172 static GstCaps *gst_matroska_demux_audio_caps (GstMatroskaTrackAudioContext
173 * audiocontext, const gchar * codec_id, guint8 * data, guint size,
174 gchar ** codec_name, guint16 * riff_audio_fmt);
176 * gst_matroska_demux_subtitle_caps (GstMatroskaTrackSubtitleContext *
177 subtitlecontext, const gchar * codec_id, gpointer data, guint size);
178 static const gchar *gst_matroska_track_encryption_algorithm_name (gint val);
179 static const gchar *gst_matroska_track_encryption_cipher_mode_name (gint val);
180 static const gchar *gst_matroska_track_encoding_scope_name (gint val);
183 static void gst_matroska_demux_reset (GstElement * element);
184 static gboolean perform_seek_to_offset (GstMatroskaDemux * demux,
185 gdouble rate, guint64 offset, guint32 seqnum, GstSeekFlags flags);
187 /* gobject functions */
188 static void gst_matroska_demux_set_property (GObject * object,
189 guint prop_id, const GValue * value, GParamSpec * pspec);
190 static void gst_matroska_demux_get_property (GObject * object,
191 guint prop_id, GValue * value, GParamSpec * pspec);
193 GType gst_matroska_demux_get_type (void);
194 #define parent_class gst_matroska_demux_parent_class
195 G_DEFINE_TYPE (GstMatroskaDemux, gst_matroska_demux, GST_TYPE_ELEMENT);
198 gst_matroska_demux_finalize (GObject * object)
200 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (object);
202 gst_matroska_read_common_finalize (&demux->common);
203 gst_flow_combiner_free (demux->flowcombiner);
204 G_OBJECT_CLASS (parent_class)->finalize (object);
208 gst_matroska_demux_class_init (GstMatroskaDemuxClass * klass)
210 GObjectClass *gobject_class = (GObjectClass *) klass;
211 GstElementClass *gstelement_class = (GstElementClass *) klass;
213 GST_DEBUG_CATEGORY_INIT (matroskademux_debug, "matroskademux", 0,
216 gobject_class->finalize = gst_matroska_demux_finalize;
218 gobject_class->get_property = gst_matroska_demux_get_property;
219 gobject_class->set_property = gst_matroska_demux_set_property;
221 g_object_class_install_property (gobject_class, PROP_MAX_GAP_TIME,
222 g_param_spec_uint64 ("max-gap-time", "Maximum gap time",
223 "The demuxer sends out segment events for skipping "
224 "gaps longer than this (0 = disabled).", 0, G_MAXUINT64,
225 DEFAULT_MAX_GAP_TIME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
227 g_object_class_install_property (gobject_class, PROP_MAX_BACKTRACK_DISTANCE,
228 g_param_spec_uint ("max-backtrack-distance",
229 "Maximum backtrack distance",
230 "Maximum backtrack distance in seconds when seeking without "
231 "and index in pull mode and search for a keyframe "
232 "(0 = disable backtracking).",
233 0, G_MAXUINT, DEFAULT_MAX_BACKTRACK_DISTANCE,
234 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
236 gstelement_class->change_state =
237 GST_DEBUG_FUNCPTR (gst_matroska_demux_change_state);
238 gstelement_class->send_event =
239 GST_DEBUG_FUNCPTR (gst_matroska_demux_element_send_event);
240 gstelement_class->query =
241 GST_DEBUG_FUNCPTR (gst_matroska_demux_element_query);
243 gstelement_class->set_index =
244 GST_DEBUG_FUNCPTR (gst_matroska_demux_set_index);
245 gstelement_class->get_index =
246 GST_DEBUG_FUNCPTR (gst_matroska_demux_get_index);
249 gst_element_class_add_static_pad_template (gstelement_class,
251 gst_element_class_add_static_pad_template (gstelement_class,
253 gst_element_class_add_static_pad_template (gstelement_class,
254 &subtitle_src_templ);
255 gst_element_class_add_static_pad_template (gstelement_class, &sink_templ);
257 gst_element_class_set_static_metadata (gstelement_class, "Matroska demuxer",
259 "Demuxes Matroska/WebM streams into video/audio/subtitles",
260 "GStreamer maintainers <gstreamer-devel@lists.freedesktop.org>");
264 gst_matroska_demux_init (GstMatroskaDemux * demux)
266 demux->common.sinkpad = gst_pad_new_from_static_template (&sink_templ,
268 gst_pad_set_activate_function (demux->common.sinkpad,
269 GST_DEBUG_FUNCPTR (gst_matroska_demux_sink_activate));
270 gst_pad_set_activatemode_function (demux->common.sinkpad,
271 GST_DEBUG_FUNCPTR (gst_matroska_demux_sink_activate_mode));
272 gst_pad_set_chain_function (demux->common.sinkpad,
273 GST_DEBUG_FUNCPTR (gst_matroska_demux_chain));
274 gst_pad_set_event_function (demux->common.sinkpad,
275 GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_sink_event));
276 gst_pad_set_query_function (demux->common.sinkpad,
277 GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_sink_query));
278 gst_element_add_pad (GST_ELEMENT (demux), demux->common.sinkpad);
280 /* init defaults for common read context */
281 gst_matroska_read_common_init (&demux->common);
283 /* property defaults */
284 demux->max_gap_time = DEFAULT_MAX_GAP_TIME;
285 demux->max_backtrack_distance = DEFAULT_MAX_BACKTRACK_DISTANCE;
287 GST_OBJECT_FLAG_SET (demux, GST_ELEMENT_FLAG_INDEXABLE);
289 demux->flowcombiner = gst_flow_combiner_new ();
292 gst_matroska_demux_reset (GST_ELEMENT (demux));
296 gst_matroska_demux_reset (GstElement * element)
298 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
300 GST_DEBUG_OBJECT (demux, "Resetting state");
302 gst_matroska_read_common_reset (GST_ELEMENT (demux), &demux->common);
304 demux->num_a_streams = 0;
305 demux->num_t_streams = 0;
306 demux->num_v_streams = 0;
307 demux->have_nonintraonly_v_streams = FALSE;
309 demux->have_group_id = FALSE;
310 demux->group_id = G_MAXUINT;
313 demux->tracks_parsed = FALSE;
315 if (demux->clusters) {
316 g_array_free (demux->clusters, TRUE);
317 demux->clusters = NULL;
320 g_list_foreach (demux->seek_parsed,
321 (GFunc) gst_matroska_read_common_free_parsed_el, NULL);
322 g_list_free (demux->seek_parsed);
323 demux->seek_parsed = NULL;
325 demux->last_stop_end = GST_CLOCK_TIME_NONE;
326 demux->seek_block = 0;
327 demux->stream_start_time = GST_CLOCK_TIME_NONE;
328 demux->to_time = GST_CLOCK_TIME_NONE;
329 demux->cluster_time = GST_CLOCK_TIME_NONE;
330 demux->cluster_offset = 0;
331 demux->cluster_prevsize = 0;
332 demux->seen_cluster_prevsize = FALSE;
333 demux->next_cluster_offset = 0;
334 demux->stream_last_time = GST_CLOCK_TIME_NONE;
335 demux->last_cluster_offset = 0;
336 demux->index_offset = 0;
337 demux->seekable = FALSE;
338 demux->need_segment = FALSE;
339 demux->segment_seqnum = 0;
340 demux->requested_seek_time = GST_CLOCK_TIME_NONE;
341 demux->seek_offset = -1;
342 demux->building_index = FALSE;
343 if (demux->seek_event) {
344 gst_event_unref (demux->seek_event);
345 demux->seek_event = NULL;
348 demux->seek_index = NULL;
349 demux->seek_entry = 0;
351 if (demux->new_segment) {
352 gst_event_unref (demux->new_segment);
353 demux->new_segment = NULL;
356 demux->invalid_duration = FALSE;
358 demux->cached_length = G_MAXUINT64;
360 if (demux->deferred_seek_event)
361 gst_event_unref (demux->deferred_seek_event);
362 demux->deferred_seek_event = NULL;
363 demux->deferred_seek_pad = NULL;
365 gst_flow_combiner_clear (demux->flowcombiner);
369 gst_matroska_decode_buffer (GstMatroskaTrackContext * context, GstBuffer * buf)
374 GstBuffer *out_buf = buf;
376 g_return_val_if_fail (GST_IS_BUFFER (buf), NULL);
378 GST_DEBUG ("decoding buffer %p", buf);
380 gst_buffer_map (out_buf, &map, GST_MAP_READ);
384 g_return_val_if_fail (size > 0, buf);
386 if (gst_matroska_decode_data (context->encodings, &data, &size,
387 GST_MATROSKA_TRACK_ENCODING_SCOPE_FRAME, FALSE)) {
388 if (data != map.data) {
389 gst_buffer_unmap (out_buf, &map);
390 gst_buffer_unref (out_buf);
391 out_buf = gst_buffer_new_wrapped (data, size);
393 gst_buffer_unmap (out_buf, &map);
396 GST_DEBUG ("decode data failed");
397 gst_buffer_unmap (out_buf, &map);
398 gst_buffer_unref (out_buf);
401 /* Encrypted stream */
402 if (context->protection_info) {
404 GstStructure *info_protect = gst_structure_copy (context->protection_info);
405 gboolean encrypted = FALSE;
407 gst_buffer_map (out_buf, &map, GST_MAP_READ);
411 if (gst_matroska_parse_protection_meta (&data, &size, info_protect,
413 if (data != map.data) {
416 gst_buffer_unmap (out_buf, &map);
418 out_buf = gst_buffer_copy_region (tmp_buf, GST_BUFFER_COPY_ALL,
419 gst_buffer_get_size (tmp_buf) - size, size);
420 gst_buffer_unref (tmp_buf);
422 gst_buffer_add_protection_meta (out_buf, info_protect);
424 gst_structure_free (info_protect);
426 gst_buffer_unmap (out_buf, &map);
427 gst_structure_free (info_protect);
430 GST_WARNING ("Adding protection metadata failed");
431 gst_buffer_unmap (out_buf, &map);
432 gst_buffer_unref (out_buf);
433 gst_structure_free (info_protect);
442 gst_matroska_demux_add_stream_headers_to_caps (GstMatroskaDemux * demux,
443 GstBufferList * list, GstCaps * caps)
446 GValue arr_val = G_VALUE_INIT;
447 GValue buf_val = G_VALUE_INIT;
450 g_assert (gst_caps_is_writable (caps));
452 g_value_init (&arr_val, GST_TYPE_ARRAY);
453 g_value_init (&buf_val, GST_TYPE_BUFFER);
455 num = gst_buffer_list_length (list);
456 for (i = 0; i < num; ++i) {
457 g_value_set_boxed (&buf_val, gst_buffer_list_get (list, i));
458 gst_value_array_append_value (&arr_val, &buf_val);
461 s = gst_caps_get_structure (caps, 0);
462 gst_structure_take_value (s, "streamheader", &arr_val);
463 g_value_unset (&buf_val);
467 gst_matroska_demux_parse_colour (GstMatroskaDemux * demux, GstEbmlRead * ebml,
468 GstMatroskaTrackVideoContext * video_context)
471 GstVideoColorimetry colorimetry;
475 colorimetry.range = GST_VIDEO_COLOR_RANGE_UNKNOWN;
476 colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_UNKNOWN;
477 colorimetry.transfer = GST_VIDEO_TRANSFER_UNKNOWN;
478 colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_UNKNOWN;
480 DEBUG_ELEMENT_START (demux, ebml, "TrackVideoColour");
482 if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK)
485 while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
486 if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
490 case GST_MATROSKA_ID_VIDEOMATRIXCOEFFICIENTS:{
491 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
496 colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_RGB;
499 colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_BT709;
502 colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_UNKNOWN;
505 colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_FCC;
507 /* FIXME: "5: BT470BG" is undefined in GstVideoColorMatrix
508 * but it's functionally same as "6: BT601" */
511 colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_BT601;
514 colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_SMPTE240M;
517 colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_BT2020;
520 GST_FIXME_OBJECT (demux, "Unsupported color matrix coefficients %"
521 G_GUINT64_FORMAT, num);
527 case GST_MATROSKA_ID_VIDEORANGE:{
528 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
533 colorimetry.range = GST_VIDEO_COLOR_RANGE_UNKNOWN;
536 colorimetry.range = GST_VIDEO_COLOR_RANGE_16_235;
539 colorimetry.range = GST_VIDEO_COLOR_RANGE_0_255;
542 GST_FIXME_OBJECT (demux, "Unsupported color range %"
543 G_GUINT64_FORMAT, num);
549 case GST_MATROSKA_ID_VIDEOTRANSFERCHARACTERISTICS:{
550 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
554 /* FIXME: "6: BT601" and "14: BT2020_10" are undefined in
555 * GstVideoTransferFunction, but functionally same as "1: BT709" */
559 colorimetry.transfer = GST_VIDEO_TRANSFER_BT709;
562 colorimetry.transfer = GST_VIDEO_TRANSFER_UNKNOWN;
565 colorimetry.transfer = GST_VIDEO_TRANSFER_GAMMA22;
568 colorimetry.transfer = GST_VIDEO_TRANSFER_GAMMA28;
571 colorimetry.transfer = GST_VIDEO_TRANSFER_SMPTE240M;
574 colorimetry.transfer = GST_VIDEO_TRANSFER_GAMMA10;
577 colorimetry.transfer = GST_VIDEO_TRANSFER_LOG100;
580 colorimetry.transfer = GST_VIDEO_TRANSFER_LOG316;
583 colorimetry.transfer = GST_VIDEO_TRANSFER_SRGB;
586 colorimetry.transfer = GST_VIDEO_TRANSFER_BT2020_12;
589 GST_FIXME_OBJECT (demux,
590 "Unsupported color transfer characteristics %"
591 G_GUINT64_FORMAT, num);
597 case GST_MATROSKA_ID_VIDEOPRIMARIES:{
598 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
603 colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_BT709;
606 colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_UNKNOWN;
609 colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_BT470M;
612 colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_BT470BG;
615 colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_SMPTE170M;
618 colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_SMPTE240M;
621 colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_FILM;
624 colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_BT2020;
627 GST_FIXME_OBJECT (demux, "Unsupported color primaries %"
628 G_GUINT64_FORMAT, num);
635 GST_FIXME_OBJECT (demux, "Unsupported subelement 0x%x in Colour", id);
636 ret = gst_ebml_read_skip (ebml);
641 memcpy (&video_context->colorimetry, &colorimetry,
642 sizeof (GstVideoColorimetry));
645 DEBUG_ELEMENT_STOP (demux, ebml, "TrackVideoColour", ret);
650 gst_matroska_demux_parse_stream (GstMatroskaDemux * demux, GstEbmlRead * ebml,
651 GstMatroskaTrackContext ** dest_context)
653 GstMatroskaTrackContext *context;
654 GstCaps *caps = NULL;
655 GstTagList *cached_taglist;
657 guint32 id, riff_fourcc = 0;
658 guint16 riff_audio_fmt = 0;
661 DEBUG_ELEMENT_START (demux, ebml, "TrackEntry");
663 /* start with the master */
664 if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
665 DEBUG_ELEMENT_STOP (demux, ebml, "TrackEntry", ret);
669 /* allocate generic... if we know the type, we'll g_renew()
670 * with the precise type */
671 context = g_new0 (GstMatroskaTrackContext, 1);
672 context->index_writer_id = -1;
673 context->type = 0; /* no type yet */
674 context->default_duration = 0;
676 context->set_discont = TRUE;
677 context->timecodescale = 1.0;
679 GST_MATROSKA_TRACK_ENABLED | GST_MATROSKA_TRACK_DEFAULT |
680 GST_MATROSKA_TRACK_LACING;
681 context->from_time = GST_CLOCK_TIME_NONE;
682 context->from_offset = -1;
683 context->to_offset = G_MAXINT64;
684 context->alignment = 1;
685 context->dts_only = FALSE;
686 context->intra_only = FALSE;
687 context->tags = gst_tag_list_new_empty ();
688 g_queue_init (&context->protection_event_queue);
689 context->protection_info = NULL;
691 GST_DEBUG_OBJECT (demux, "Parsing a TrackEntry (%d tracks parsed so far)",
692 demux->common.num_streams);
694 /* try reading the trackentry headers */
695 while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
696 if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
700 /* track number (unique stream ID) */
701 case GST_MATROSKA_ID_TRACKNUMBER:{
704 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
708 GST_ERROR_OBJECT (demux, "Invalid TrackNumber 0");
709 ret = GST_FLOW_ERROR;
713 GST_DEBUG_OBJECT (demux, "TrackNumber: %" G_GUINT64_FORMAT, num);
717 /* track UID (unique identifier) */
718 case GST_MATROSKA_ID_TRACKUID:{
721 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
725 GST_ERROR_OBJECT (demux, "Invalid TrackUID 0");
726 ret = GST_FLOW_ERROR;
730 GST_DEBUG_OBJECT (demux, "TrackUID: %" G_GUINT64_FORMAT, num);
735 /* track type (video, audio, combined, subtitle, etc.) */
736 case GST_MATROSKA_ID_TRACKTYPE:{
739 if ((ret = gst_ebml_read_uint (ebml, &id, &track_type)) != GST_FLOW_OK) {
743 if (context->type != 0 && context->type != track_type) {
744 GST_WARNING_OBJECT (demux,
745 "More than one tracktype defined in a TrackEntry - skipping");
747 } else if (track_type < 1 || track_type > 254) {
748 GST_WARNING_OBJECT (demux, "Invalid TrackType %" G_GUINT64_FORMAT,
753 GST_DEBUG_OBJECT (demux, "TrackType: %" G_GUINT64_FORMAT, track_type);
755 /* ok, so we're actually going to reallocate this thing */
756 switch (track_type) {
757 case GST_MATROSKA_TRACK_TYPE_VIDEO:
758 gst_matroska_track_init_video_context (&context);
760 case GST_MATROSKA_TRACK_TYPE_AUDIO:
761 gst_matroska_track_init_audio_context (&context);
763 case GST_MATROSKA_TRACK_TYPE_SUBTITLE:
764 gst_matroska_track_init_subtitle_context (&context);
766 case GST_MATROSKA_TRACK_TYPE_COMPLEX:
767 case GST_MATROSKA_TRACK_TYPE_LOGO:
768 case GST_MATROSKA_TRACK_TYPE_BUTTONS:
769 case GST_MATROSKA_TRACK_TYPE_CONTROL:
771 GST_WARNING_OBJECT (demux,
772 "Unknown or unsupported TrackType %" G_GUINT64_FORMAT,
780 /* tracktype specific stuff for video */
781 case GST_MATROSKA_ID_TRACKVIDEO:{
782 GstMatroskaTrackVideoContext *videocontext;
784 DEBUG_ELEMENT_START (demux, ebml, "TrackVideo");
786 if (!gst_matroska_track_init_video_context (&context)) {
787 GST_WARNING_OBJECT (demux,
788 "TrackVideo element in non-video track - ignoring track");
789 ret = GST_FLOW_ERROR;
791 } else if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
794 videocontext = (GstMatroskaTrackVideoContext *) context;
796 while (ret == GST_FLOW_OK &&
797 gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
798 if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
802 /* Should be one level up but some broken muxers write it here. */
803 case GST_MATROSKA_ID_TRACKDEFAULTDURATION:{
806 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
810 GST_WARNING_OBJECT (demux, "Invalid TrackDefaultDuration 0");
814 GST_DEBUG_OBJECT (demux,
815 "TrackDefaultDuration: %" G_GUINT64_FORMAT, num);
816 context->default_duration = num;
820 /* video framerate */
821 /* NOTE: This one is here only for backward compatibility.
822 * Use _TRACKDEFAULDURATION one level up. */
823 case GST_MATROSKA_ID_VIDEOFRAMERATE:{
826 if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK)
830 GST_WARNING_OBJECT (demux, "Invalid TrackVideoFPS %lf", num);
834 GST_DEBUG_OBJECT (demux, "TrackVideoFrameRate: %lf", num);
835 if (context->default_duration == 0)
836 context->default_duration =
837 gst_gdouble_to_guint64 ((gdouble) GST_SECOND * (1.0 / num));
838 videocontext->default_fps = num;
842 /* width of the size to display the video at */
843 case GST_MATROSKA_ID_VIDEODISPLAYWIDTH:{
846 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
850 GST_WARNING_OBJECT (demux, "Invalid TrackVideoDisplayWidth 0");
854 GST_DEBUG_OBJECT (demux,
855 "TrackVideoDisplayWidth: %" G_GUINT64_FORMAT, num);
856 videocontext->display_width = num;
860 /* height of the size to display the video at */
861 case GST_MATROSKA_ID_VIDEODISPLAYHEIGHT:{
864 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
868 GST_WARNING_OBJECT (demux, "Invalid TrackVideoDisplayHeight 0");
872 GST_DEBUG_OBJECT (demux,
873 "TrackVideoDisplayHeight: %" G_GUINT64_FORMAT, num);
874 videocontext->display_height = num;
878 /* width of the video in the file */
879 case GST_MATROSKA_ID_VIDEOPIXELWIDTH:{
882 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
886 GST_WARNING_OBJECT (demux, "Invalid TrackVideoPixelWidth 0");
890 GST_DEBUG_OBJECT (demux,
891 "TrackVideoPixelWidth: %" G_GUINT64_FORMAT, num);
892 videocontext->pixel_width = num;
896 /* height of the video in the file */
897 case GST_MATROSKA_ID_VIDEOPIXELHEIGHT:{
900 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
904 GST_WARNING_OBJECT (demux, "Invalid TrackVideoPixelHeight 0");
908 GST_DEBUG_OBJECT (demux,
909 "TrackVideoPixelHeight: %" G_GUINT64_FORMAT, num);
910 videocontext->pixel_height = num;
914 /* whether the video is interlaced */
915 case GST_MATROSKA_ID_VIDEOFLAGINTERLACED:{
918 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
922 videocontext->interlace_mode =
923 GST_MATROSKA_INTERLACE_MODE_INTERLACED;
925 videocontext->interlace_mode =
926 GST_MATROSKA_INTERLACE_MODE_PROGRESSIVE;
928 videocontext->interlace_mode =
929 GST_MATROSKA_INTERLACE_MODE_UNKNOWN;
931 GST_DEBUG_OBJECT (demux, "video track interlacing mode: %d",
932 videocontext->interlace_mode);
936 /* aspect ratio behaviour */
937 case GST_MATROSKA_ID_VIDEOASPECTRATIOTYPE:{
940 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
943 if (num != GST_MATROSKA_ASPECT_RATIO_MODE_FREE &&
944 num != GST_MATROSKA_ASPECT_RATIO_MODE_KEEP &&
945 num != GST_MATROSKA_ASPECT_RATIO_MODE_FIXED) {
946 GST_WARNING_OBJECT (demux,
947 "Unknown TrackVideoAspectRatioType 0x%x", (guint) num);
950 GST_DEBUG_OBJECT (demux,
951 "TrackVideoAspectRatioType: %" G_GUINT64_FORMAT, num);
952 videocontext->asr_mode = num;
956 /* colourspace (only matters for raw video) fourcc */
957 case GST_MATROSKA_ID_VIDEOCOLOURSPACE:{
962 gst_ebml_read_binary (ebml, &id, &data,
963 &datalen)) != GST_FLOW_OK)
968 GST_WARNING_OBJECT (demux,
969 "Invalid TrackVideoColourSpace length %" G_GUINT64_FORMAT,
974 memcpy (&videocontext->fourcc, data, 4);
975 GST_DEBUG_OBJECT (demux,
976 "TrackVideoColourSpace: %" GST_FOURCC_FORMAT,
977 GST_FOURCC_ARGS (videocontext->fourcc));
983 case GST_MATROSKA_ID_VIDEOCOLOUR:{
984 ret = gst_matroska_demux_parse_colour (demux, ebml, videocontext);
988 case GST_MATROSKA_ID_VIDEOSTEREOMODE:
992 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
995 GST_DEBUG_OBJECT (demux, "StereoMode: %" G_GUINT64_FORMAT, num);
998 case GST_MATROSKA_STEREO_MODE_SBS_RL:
999 videocontext->multiview_flags =
1000 GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
1002 case GST_MATROSKA_STEREO_MODE_SBS_LR:
1003 videocontext->multiview_mode =
1004 GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE;
1006 case GST_MATROSKA_STEREO_MODE_TB_RL:
1007 videocontext->multiview_flags =
1008 GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
1010 case GST_MATROSKA_STEREO_MODE_TB_LR:
1011 videocontext->multiview_mode =
1012 GST_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM;
1014 case GST_MATROSKA_STEREO_MODE_CHECKER_RL:
1015 videocontext->multiview_flags =
1016 GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
1018 case GST_MATROSKA_STEREO_MODE_CHECKER_LR:
1019 videocontext->multiview_mode =
1020 GST_VIDEO_MULTIVIEW_MODE_CHECKERBOARD;
1022 case GST_MATROSKA_STEREO_MODE_FBF_RL:
1023 videocontext->multiview_flags =
1024 GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
1026 case GST_MATROSKA_STEREO_MODE_FBF_LR:
1027 videocontext->multiview_mode =
1028 GST_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME;
1029 /* FIXME: In frame-by-frame mode, left/right frame buffers are
1030 * laced within one block, and we'll need to apply FIRST_IN_BUNDLE
1031 * accordingly. See http://www.matroska.org/technical/specs/index.html#StereoMode */
1032 GST_FIXME_OBJECT (demux,
1033 "Frame-by-frame stereoscopic mode not fully implemented");
1040 GST_WARNING_OBJECT (demux,
1041 "Unknown TrackVideo subelement 0x%x - ignoring", id);
1043 case GST_MATROSKA_ID_VIDEODISPLAYUNIT:
1044 case GST_MATROSKA_ID_VIDEOPIXELCROPBOTTOM:
1045 case GST_MATROSKA_ID_VIDEOPIXELCROPTOP:
1046 case GST_MATROSKA_ID_VIDEOPIXELCROPLEFT:
1047 case GST_MATROSKA_ID_VIDEOPIXELCROPRIGHT:
1048 case GST_MATROSKA_ID_VIDEOGAMMAVALUE:
1049 ret = gst_ebml_read_skip (ebml);
1054 DEBUG_ELEMENT_STOP (demux, ebml, "TrackVideo", ret);
1058 /* tracktype specific stuff for audio */
1059 case GST_MATROSKA_ID_TRACKAUDIO:{
1060 GstMatroskaTrackAudioContext *audiocontext;
1062 DEBUG_ELEMENT_START (demux, ebml, "TrackAudio");
1064 if (!gst_matroska_track_init_audio_context (&context)) {
1065 GST_WARNING_OBJECT (demux,
1066 "TrackAudio element in non-audio track - ignoring track");
1067 ret = GST_FLOW_ERROR;
1071 if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK)
1074 audiocontext = (GstMatroskaTrackAudioContext *) context;
1076 while (ret == GST_FLOW_OK &&
1077 gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1078 if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1083 case GST_MATROSKA_ID_AUDIOSAMPLINGFREQ:{
1086 if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK)
1091 GST_WARNING_OBJECT (demux,
1092 "Invalid TrackAudioSamplingFrequency %lf", num);
1096 GST_DEBUG_OBJECT (demux, "TrackAudioSamplingFrequency: %lf", num);
1097 audiocontext->samplerate = num;
1102 case GST_MATROSKA_ID_AUDIOBITDEPTH:{
1105 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1109 GST_WARNING_OBJECT (demux, "Invalid TrackAudioBitDepth 0");
1113 GST_DEBUG_OBJECT (demux, "TrackAudioBitDepth: %" G_GUINT64_FORMAT,
1115 audiocontext->bitdepth = num;
1120 case GST_MATROSKA_ID_AUDIOCHANNELS:{
1123 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1127 GST_WARNING_OBJECT (demux, "Invalid TrackAudioChannels 0");
1131 GST_DEBUG_OBJECT (demux, "TrackAudioChannels: %" G_GUINT64_FORMAT,
1133 audiocontext->channels = num;
1138 GST_WARNING_OBJECT (demux,
1139 "Unknown TrackAudio subelement 0x%x - ignoring", id);
1141 case GST_MATROSKA_ID_AUDIOCHANNELPOSITIONS:
1142 case GST_MATROSKA_ID_AUDIOOUTPUTSAMPLINGFREQ:
1143 ret = gst_ebml_read_skip (ebml);
1148 DEBUG_ELEMENT_STOP (demux, ebml, "TrackAudio", ret);
1153 /* codec identifier */
1154 case GST_MATROSKA_ID_CODECID:{
1157 if ((ret = gst_ebml_read_ascii (ebml, &id, &text)) != GST_FLOW_OK)
1160 GST_DEBUG_OBJECT (demux, "CodecID: %s", GST_STR_NULL (text));
1161 context->codec_id = text;
1165 /* codec private data */
1166 case GST_MATROSKA_ID_CODECPRIVATE:{
1171 gst_ebml_read_binary (ebml, &id, &data, &size)) != GST_FLOW_OK)
1174 context->codec_priv = data;
1175 context->codec_priv_size = size;
1177 GST_DEBUG_OBJECT (demux, "CodecPrivate of size %" G_GUINT64_FORMAT,
1182 /* name of the codec */
1183 case GST_MATROSKA_ID_CODECNAME:{
1186 if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
1189 GST_DEBUG_OBJECT (demux, "CodecName: %s", GST_STR_NULL (text));
1190 context->codec_name = text;
1195 case GST_MATROSKA_ID_CODECDELAY:{
1198 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1201 context->codec_delay = num;
1203 GST_DEBUG_OBJECT (demux, "CodecDelay: %" GST_TIME_FORMAT,
1204 GST_TIME_ARGS (num));
1209 case GST_MATROSKA_ID_SEEKPREROLL:{
1212 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1215 context->seek_preroll = num;
1217 GST_DEBUG_OBJECT (demux, "SeekPreroll: %" GST_TIME_FORMAT,
1218 GST_TIME_ARGS (num));
1222 /* name of this track */
1223 case GST_MATROSKA_ID_TRACKNAME:{
1226 if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
1229 context->name = text;
1230 GST_DEBUG_OBJECT (demux, "TrackName: %s", GST_STR_NULL (text));
1234 /* language (matters for audio/subtitles, mostly) */
1235 case GST_MATROSKA_ID_TRACKLANGUAGE:{
1238 if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
1242 context->language = text;
1245 if (strlen (context->language) >= 4 && context->language[3] == '-')
1246 context->language[3] = '\0';
1248 GST_DEBUG_OBJECT (demux, "TrackLanguage: %s",
1249 GST_STR_NULL (context->language));
1253 /* whether this is actually used */
1254 case GST_MATROSKA_ID_TRACKFLAGENABLED:{
1257 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1261 context->flags |= GST_MATROSKA_TRACK_ENABLED;
1263 context->flags &= ~GST_MATROSKA_TRACK_ENABLED;
1265 GST_DEBUG_OBJECT (demux, "TrackEnabled: %d",
1266 (context->flags & GST_MATROSKA_TRACK_ENABLED) ? 1 : 0);
1270 /* whether it's the default for this track type */
1271 case GST_MATROSKA_ID_TRACKFLAGDEFAULT:{
1274 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1278 context->flags |= GST_MATROSKA_TRACK_DEFAULT;
1280 context->flags &= ~GST_MATROSKA_TRACK_DEFAULT;
1282 GST_DEBUG_OBJECT (demux, "TrackDefault: %d",
1283 (context->flags & GST_MATROSKA_TRACK_DEFAULT) ? 1 : 0);
1287 /* whether the track must be used during playback */
1288 case GST_MATROSKA_ID_TRACKFLAGFORCED:{
1291 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1295 context->flags |= GST_MATROSKA_TRACK_FORCED;
1297 context->flags &= ~GST_MATROSKA_TRACK_FORCED;
1299 GST_DEBUG_OBJECT (demux, "TrackForced: %d",
1300 (context->flags & GST_MATROSKA_TRACK_FORCED) ? 1 : 0);
1304 /* lacing (like MPEG, where blocks don't end/start on frame
1306 case GST_MATROSKA_ID_TRACKFLAGLACING:{
1309 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1313 context->flags |= GST_MATROSKA_TRACK_LACING;
1315 context->flags &= ~GST_MATROSKA_TRACK_LACING;
1317 GST_DEBUG_OBJECT (demux, "TrackLacing: %d",
1318 (context->flags & GST_MATROSKA_TRACK_LACING) ? 1 : 0);
1322 /* default length (in time) of one data block in this track */
1323 case GST_MATROSKA_ID_TRACKDEFAULTDURATION:{
1326 if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1331 GST_WARNING_OBJECT (demux, "Invalid TrackDefaultDuration 0");
1335 GST_DEBUG_OBJECT (demux, "TrackDefaultDuration: %" G_GUINT64_FORMAT,
1337 context->default_duration = num;
1341 case GST_MATROSKA_ID_CONTENTENCODINGS:{
1342 ret = gst_matroska_read_common_read_track_encodings (&demux->common,
1347 case GST_MATROSKA_ID_TRACKTIMECODESCALE:{
1350 if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK)
1354 GST_WARNING_OBJECT (demux, "Invalid TrackTimeCodeScale %lf", num);
1358 GST_DEBUG_OBJECT (demux, "TrackTimeCodeScale: %lf", num);
1359 context->timecodescale = num;
1364 GST_WARNING ("Unknown TrackEntry subelement 0x%x - ignoring", id);
1367 /* we ignore these because they're nothing useful (i.e. crap)
1368 * or simply not implemented yet. */
1369 case GST_MATROSKA_ID_TRACKMINCACHE:
1370 case GST_MATROSKA_ID_TRACKMAXCACHE:
1371 case GST_MATROSKA_ID_MAXBLOCKADDITIONID:
1372 case GST_MATROSKA_ID_TRACKATTACHMENTLINK:
1373 case GST_MATROSKA_ID_TRACKOVERLAY:
1374 case GST_MATROSKA_ID_TRACKTRANSLATE:
1375 case GST_MATROSKA_ID_TRACKOFFSET:
1376 case GST_MATROSKA_ID_CODECSETTINGS:
1377 case GST_MATROSKA_ID_CODECINFOURL:
1378 case GST_MATROSKA_ID_CODECDOWNLOADURL:
1379 case GST_MATROSKA_ID_CODECDECODEALL:
1380 ret = gst_ebml_read_skip (ebml);
1385 DEBUG_ELEMENT_STOP (demux, ebml, "TrackEntry", ret);
1387 /* Decode codec private data if necessary */
1388 if (context->encodings && context->encodings->len > 0 && context->codec_priv
1389 && context->codec_priv_size > 0) {
1390 if (!gst_matroska_decode_data (context->encodings,
1391 &context->codec_priv, &context->codec_priv_size,
1392 GST_MATROSKA_TRACK_ENCODING_SCOPE_CODEC_DATA, TRUE)) {
1393 GST_WARNING_OBJECT (demux, "Decoding codec private data failed");
1394 ret = GST_FLOW_ERROR;
1398 if (context->type == 0 || context->codec_id == NULL || (ret != GST_FLOW_OK
1399 && ret != GST_FLOW_EOS)) {
1400 if (ret == GST_FLOW_OK || ret == GST_FLOW_EOS)
1401 GST_WARNING_OBJECT (ebml, "Unknown stream/codec in track entry header");
1403 gst_matroska_track_free (context);
1405 *dest_context = NULL;
1409 /* check for a cached track taglist */
1411 (GstTagList *) g_hash_table_lookup (demux->common.cached_track_taglists,
1412 GUINT_TO_POINTER (context->uid));
1414 gst_tag_list_insert (context->tags, cached_taglist, GST_TAG_MERGE_APPEND);
1417 switch (context->type) {
1418 case GST_MATROSKA_TRACK_TYPE_VIDEO:{
1419 GstMatroskaTrackVideoContext *videocontext =
1420 (GstMatroskaTrackVideoContext *) context;
1422 caps = gst_matroska_demux_video_caps (videocontext,
1423 context->codec_id, context->codec_priv,
1424 context->codec_priv_size, &codec, &riff_fourcc);
1427 gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE,
1428 GST_TAG_VIDEO_CODEC, codec, NULL);
1429 context->tags_changed = TRUE;
1435 case GST_MATROSKA_TRACK_TYPE_AUDIO:{
1436 GstMatroskaTrackAudioContext *audiocontext =
1437 (GstMatroskaTrackAudioContext *) context;
1439 caps = gst_matroska_demux_audio_caps (audiocontext,
1440 context->codec_id, context->codec_priv, context->codec_priv_size,
1441 &codec, &riff_audio_fmt);
1444 gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE,
1445 GST_TAG_AUDIO_CODEC, codec, NULL);
1446 context->tags_changed = TRUE;
1452 case GST_MATROSKA_TRACK_TYPE_SUBTITLE:{
1453 GstMatroskaTrackSubtitleContext *subtitlecontext =
1454 (GstMatroskaTrackSubtitleContext *) context;
1456 caps = gst_matroska_demux_subtitle_caps (subtitlecontext,
1457 context->codec_id, context->codec_priv, context->codec_priv_size);
1461 case GST_MATROSKA_TRACK_TYPE_COMPLEX:
1462 case GST_MATROSKA_TRACK_TYPE_LOGO:
1463 case GST_MATROSKA_TRACK_TYPE_BUTTONS:
1464 case GST_MATROSKA_TRACK_TYPE_CONTROL:
1466 /* we should already have quit by now */
1467 g_assert_not_reached ();
1470 if ((context->language == NULL || *context->language == '\0') &&
1471 (context->type == GST_MATROSKA_TRACK_TYPE_AUDIO ||
1472 context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE)) {
1473 GST_LOG ("stream %d: language=eng (assuming default)", context->index);
1474 context->language = g_strdup ("eng");
1477 if (context->language) {
1480 /* Matroska contains ISO 639-2B codes, we want ISO 639-1 */
1481 lang = gst_tag_get_language_code (context->language);
1482 gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE,
1483 GST_TAG_LANGUAGE_CODE, (lang) ? lang : context->language, NULL);
1485 if (context->name) {
1486 gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE,
1487 GST_TAG_TITLE, context->name, NULL);
1489 context->tags_changed = TRUE;
1493 GST_WARNING_OBJECT (demux, "could not determine caps for stream with "
1494 "codec_id='%s'", context->codec_id);
1495 switch (context->type) {
1496 case GST_MATROSKA_TRACK_TYPE_VIDEO:
1497 caps = gst_caps_new_empty_simple ("video/x-unknown");
1499 case GST_MATROSKA_TRACK_TYPE_AUDIO:
1500 caps = gst_caps_new_empty_simple ("audio/x-unknown");
1502 case GST_MATROSKA_TRACK_TYPE_SUBTITLE:
1503 caps = gst_caps_new_empty_simple ("application/x-subtitle-unknown");
1505 case GST_MATROSKA_TRACK_TYPE_COMPLEX:
1507 caps = gst_caps_new_empty_simple ("application/x-matroska-unknown");
1510 gst_caps_set_simple (caps, "codec-id", G_TYPE_STRING, context->codec_id,
1513 /* add any unrecognised riff fourcc / audio format, but after codec-id */
1514 if (context->type == GST_MATROSKA_TRACK_TYPE_AUDIO && riff_audio_fmt != 0)
1515 gst_caps_set_simple (caps, "format", G_TYPE_INT, riff_audio_fmt, NULL);
1516 else if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO && riff_fourcc != 0) {
1517 gchar *fstr = g_strdup_printf ("%" GST_FOURCC_FORMAT,
1518 GST_FOURCC_ARGS (riff_fourcc));
1519 gst_caps_set_simple (caps, "fourcc", G_TYPE_STRING, fstr, NULL);
1522 } else if (context->stream_headers != NULL) {
1523 gst_matroska_demux_add_stream_headers_to_caps (demux,
1524 context->stream_headers, caps);
1527 if (context->encodings) {
1528 GstMatroskaTrackEncoding *enc;
1531 for (i = 0; i < context->encodings->len; i++) {
1532 enc = &g_array_index (context->encodings, GstMatroskaTrackEncoding, i);
1533 if (enc->type == GST_MATROSKA_ENCODING_ENCRYPTION /* encryption */ ) {
1534 GstStructure *s = gst_caps_get_structure (caps, 0);
1535 if (!gst_structure_has_name (s, "application/x-webm-enc")) {
1536 gst_structure_set (s, "original-media-type", G_TYPE_STRING,
1537 gst_structure_get_name (s), NULL);
1538 gst_structure_set (s, "encryption-algorithm", G_TYPE_STRING,
1539 gst_matroska_track_encryption_algorithm_name (enc->enc_algo),
1541 gst_structure_set (s, "encoding-scope", G_TYPE_STRING,
1542 gst_matroska_track_encoding_scope_name (enc->scope), NULL);
1543 gst_structure_set (s, "cipher-mode", G_TYPE_STRING,
1544 gst_matroska_track_encryption_cipher_mode_name
1545 (enc->enc_cipher_mode), NULL);
1546 gst_structure_set_name (s, "application/x-webm-enc");
1552 context->caps = caps;
1555 *dest_context = context;
1560 gst_matroska_demux_add_stream (GstMatroskaDemux * demux,
1561 GstMatroskaTrackContext * context)
1563 GstElementClass *klass = GST_ELEMENT_GET_CLASS (demux);
1564 gchar *padname = NULL;
1565 GstPadTemplate *templ = NULL;
1566 GstStreamFlags stream_flags;
1568 GstEvent *stream_start;
1572 g_ptr_array_add (demux->common.src, context);
1573 context->index = demux->common.num_streams++;
1574 g_assert (demux->common.src->len == demux->common.num_streams);
1575 g_ptr_array_index (demux->common.src, demux->common.num_streams - 1) =
1578 /* now create the GStreamer connectivity */
1579 switch (context->type) {
1580 case GST_MATROSKA_TRACK_TYPE_VIDEO:
1581 padname = g_strdup_printf ("video_%u", demux->num_v_streams++);
1582 templ = gst_element_class_get_pad_template (klass, "video_%u");
1584 if (!context->intra_only)
1585 demux->have_nonintraonly_v_streams = TRUE;
1588 case GST_MATROSKA_TRACK_TYPE_AUDIO:
1589 padname = g_strdup_printf ("audio_%u", demux->num_a_streams++);
1590 templ = gst_element_class_get_pad_template (klass, "audio_%u");
1593 case GST_MATROSKA_TRACK_TYPE_SUBTITLE:
1594 padname = g_strdup_printf ("subtitle_%u", demux->num_t_streams++);
1595 templ = gst_element_class_get_pad_template (klass, "subtitle_%u");
1599 /* we should already have quit by now */
1600 g_assert_not_reached ();
1603 /* the pad in here */
1604 context->pad = gst_pad_new_from_template (templ, padname);
1606 gst_pad_set_event_function (context->pad,
1607 GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_src_event));
1608 gst_pad_set_query_function (context->pad,
1609 GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_src_query));
1611 GST_INFO_OBJECT (demux, "Adding pad '%s' with caps %" GST_PTR_FORMAT,
1612 padname, context->caps);
1614 gst_pad_set_element_private (context->pad, context);
1616 gst_pad_use_fixed_caps (context->pad);
1617 gst_pad_set_active (context->pad, TRUE);
1620 gst_pad_create_stream_id_printf (context->pad, GST_ELEMENT_CAST (demux),
1621 "%03" G_GUINT64_FORMAT ":%03" G_GUINT64_FORMAT,
1622 context->num, context->uid);
1624 gst_pad_get_sticky_event (demux->common.sinkpad, GST_EVENT_STREAM_START,
1627 if (gst_event_parse_group_id (stream_start, &demux->group_id))
1628 demux->have_group_id = TRUE;
1630 demux->have_group_id = FALSE;
1631 gst_event_unref (stream_start);
1632 } else if (!demux->have_group_id) {
1633 demux->have_group_id = TRUE;
1634 demux->group_id = gst_util_group_id_next ();
1637 stream_start = gst_event_new_stream_start (stream_id);
1639 if (demux->have_group_id)
1640 gst_event_set_group_id (stream_start, demux->group_id);
1641 stream_flags = GST_STREAM_FLAG_NONE;
1642 if (context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE)
1643 stream_flags |= GST_STREAM_FLAG_SPARSE;
1644 if (context->flags & GST_MATROSKA_TRACK_DEFAULT)
1645 stream_flags |= GST_STREAM_FLAG_SELECT;
1646 else if (!(context->flags & GST_MATROSKA_TRACK_ENABLED))
1647 stream_flags |= GST_STREAM_FLAG_UNSELECT;
1649 gst_event_set_stream_flags (stream_start, stream_flags);
1650 gst_pad_push_event (context->pad, stream_start);
1651 gst_pad_set_caps (context->pad, context->caps);
1654 if (demux->common.global_tags) {
1655 GstEvent *tag_event;
1657 gst_tag_list_add (demux->common.global_tags, GST_TAG_MERGE_REPLACE,
1658 GST_TAG_CONTAINER_FORMAT, "Matroska", NULL);
1659 GST_DEBUG_OBJECT (context->pad, "Sending global_tags %p: %" GST_PTR_FORMAT,
1660 demux->common.global_tags, demux->common.global_tags);
1663 gst_event_new_tag (gst_tag_list_copy (demux->common.global_tags));
1665 gst_pad_push_event (context->pad, tag_event);
1668 if (G_UNLIKELY (context->tags_changed)) {
1669 GST_DEBUG_OBJECT (context->pad, "Sending tags %p: %"
1670 GST_PTR_FORMAT, context->tags, context->tags);
1671 gst_pad_push_event (context->pad,
1672 gst_event_new_tag (gst_tag_list_copy (context->tags)));
1673 context->tags_changed = FALSE;
1676 gst_element_add_pad (GST_ELEMENT (demux), context->pad);
1677 gst_flow_combiner_add_pad (demux->flowcombiner, context->pad);
1683 gst_matroska_demux_query (GstMatroskaDemux * demux, GstPad * pad,
1686 gboolean res = FALSE;
1687 GstMatroskaTrackContext *context = NULL;
1690 context = gst_pad_get_element_private (pad);
1693 switch (GST_QUERY_TYPE (query)) {
1694 case GST_QUERY_POSITION:
1698 gst_query_parse_position (query, &format, NULL);
1701 if (format == GST_FORMAT_TIME) {
1702 GST_OBJECT_LOCK (demux);
1704 gst_query_set_position (query, GST_FORMAT_TIME,
1705 MAX (context->pos, demux->stream_start_time) -
1706 demux->stream_start_time);
1708 gst_query_set_position (query, GST_FORMAT_TIME,
1709 MAX (demux->common.segment.position, demux->stream_start_time) -
1710 demux->stream_start_time);
1711 GST_OBJECT_UNLOCK (demux);
1712 } else if (format == GST_FORMAT_DEFAULT && context
1713 && context->default_duration) {
1714 GST_OBJECT_LOCK (demux);
1715 gst_query_set_position (query, GST_FORMAT_DEFAULT,
1716 context->pos / context->default_duration);
1717 GST_OBJECT_UNLOCK (demux);
1719 GST_DEBUG_OBJECT (demux,
1720 "only position query in TIME and DEFAULT format is supported");
1726 case GST_QUERY_DURATION:
1730 gst_query_parse_duration (query, &format, NULL);
1733 if (format == GST_FORMAT_TIME) {
1734 GST_OBJECT_LOCK (demux);
1735 gst_query_set_duration (query, GST_FORMAT_TIME,
1736 demux->common.segment.duration);
1737 GST_OBJECT_UNLOCK (demux);
1738 } else if (format == GST_FORMAT_DEFAULT && context
1739 && context->default_duration) {
1740 GST_OBJECT_LOCK (demux);
1741 gst_query_set_duration (query, GST_FORMAT_DEFAULT,
1742 demux->common.segment.duration / context->default_duration);
1743 GST_OBJECT_UNLOCK (demux);
1745 GST_DEBUG_OBJECT (demux,
1746 "only duration query in TIME and DEFAULT format is supported");
1752 case GST_QUERY_SEEKING:
1756 gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
1757 GST_OBJECT_LOCK (demux);
1758 if (fmt == GST_FORMAT_TIME) {
1761 if (demux->streaming) {
1762 /* assuming we'll be able to get an index ... */
1763 seekable = demux->seekable;
1768 gst_query_set_seeking (query, GST_FORMAT_TIME, seekable,
1769 0, demux->common.segment.duration);
1772 GST_OBJECT_UNLOCK (demux);
1775 case GST_QUERY_SEGMENT:
1780 format = demux->common.segment.format;
1783 gst_segment_to_stream_time (&demux->common.segment, format,
1784 demux->common.segment.start);
1785 if ((stop = demux->common.segment.stop) == -1)
1786 stop = demux->common.segment.duration;
1789 gst_segment_to_stream_time (&demux->common.segment, format, stop);
1791 gst_query_set_segment (query, demux->common.segment.rate, format, start,
1798 res = gst_pad_query_default (pad, (GstObject *) demux, query);
1801 GST_ELEMENT_CLASS (parent_class)->query (GST_ELEMENT_CAST (demux),
1810 gst_matroska_demux_element_query (GstElement * element, GstQuery * query)
1812 return gst_matroska_demux_query (GST_MATROSKA_DEMUX (element), NULL, query);
1816 gst_matroska_demux_handle_src_query (GstPad * pad, GstObject * parent,
1819 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
1821 return gst_matroska_demux_query (demux, pad, query);
1824 /* returns FALSE if there are no pads to deliver event to,
1825 * otherwise TRUE (whatever the outcome of event sending),
1826 * takes ownership of the passed event! */
1828 gst_matroska_demux_send_event (GstMatroskaDemux * demux, GstEvent * event)
1830 gboolean ret = FALSE;
1833 g_return_val_if_fail (event != NULL, FALSE);
1835 GST_DEBUG_OBJECT (demux, "Sending event of type %s to all source pads",
1836 GST_EVENT_TYPE_NAME (event));
1838 g_assert (demux->common.src->len == demux->common.num_streams);
1839 for (i = 0; i < demux->common.src->len; i++) {
1840 GstMatroskaTrackContext *stream;
1842 stream = g_ptr_array_index (demux->common.src, i);
1843 gst_event_ref (event);
1844 gst_pad_push_event (stream->pad, event);
1848 gst_event_unref (event);
1853 gst_matroska_demux_send_tags (GstMatroskaDemux * demux)
1857 if (G_UNLIKELY (demux->common.global_tags_changed)) {
1858 GstEvent *tag_event;
1859 gst_tag_list_add (demux->common.global_tags, GST_TAG_MERGE_REPLACE,
1860 GST_TAG_CONTAINER_FORMAT, "Matroska", NULL);
1861 GST_DEBUG_OBJECT (demux, "Sending global_tags %p : %" GST_PTR_FORMAT,
1862 demux->common.global_tags, demux->common.global_tags);
1865 gst_event_new_tag (gst_tag_list_copy (demux->common.global_tags));
1867 for (i = 0; i < demux->common.src->len; i++) {
1868 GstMatroskaTrackContext *stream;
1870 stream = g_ptr_array_index (demux->common.src, i);
1871 gst_pad_push_event (stream->pad, gst_event_ref (tag_event));
1874 gst_event_unref (tag_event);
1875 demux->common.global_tags_changed = FALSE;
1878 g_assert (demux->common.src->len == demux->common.num_streams);
1879 for (i = 0; i < demux->common.src->len; i++) {
1880 GstMatroskaTrackContext *stream;
1882 stream = g_ptr_array_index (demux->common.src, i);
1884 if (G_UNLIKELY (stream->tags_changed)) {
1885 GST_DEBUG_OBJECT (demux, "Sending tags %p for pad %s:%s : %"
1886 GST_PTR_FORMAT, stream->tags,
1887 GST_DEBUG_PAD_NAME (stream->pad), stream->tags);
1888 gst_pad_push_event (stream->pad,
1889 gst_event_new_tag (gst_tag_list_copy (stream->tags)));
1890 stream->tags_changed = FALSE;
1896 gst_matroska_demux_element_send_event (GstElement * element, GstEvent * event)
1898 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
1901 g_return_val_if_fail (event != NULL, FALSE);
1903 if (GST_EVENT_TYPE (event) == GST_EVENT_SEEK) {
1904 /* no seeking until we are (safely) ready */
1905 if (demux->common.state != GST_MATROSKA_READ_STATE_DATA) {
1906 GST_DEBUG_OBJECT (demux,
1907 "not ready for seeking yet, deferring seek: %" GST_PTR_FORMAT, event);
1908 if (demux->deferred_seek_event)
1909 gst_event_unref (demux->deferred_seek_event);
1910 demux->deferred_seek_event = event;
1911 demux->deferred_seek_pad = NULL;
1914 res = gst_matroska_demux_handle_seek_event (demux, NULL, event);
1916 GST_WARNING_OBJECT (demux, "Unhandled event of type %s",
1917 GST_EVENT_TYPE_NAME (event));
1920 gst_event_unref (event);
1925 gst_matroska_demux_move_to_entry (GstMatroskaDemux * demux,
1926 GstMatroskaIndex * entry, gboolean reset, gboolean update)
1930 GST_OBJECT_LOCK (demux);
1933 /* seek (relative to matroska segment) */
1934 /* position might be invalid; will error when streaming resumes ... */
1935 demux->common.offset = entry->pos + demux->common.ebml_segment_start;
1936 demux->next_cluster_offset = 0;
1938 GST_DEBUG_OBJECT (demux,
1939 "Seeked to offset %" G_GUINT64_FORMAT ", block %d, " "time %"
1940 GST_TIME_FORMAT, entry->pos + demux->common.ebml_segment_start,
1941 entry->block, GST_TIME_ARGS (entry->time));
1943 /* update the time */
1944 gst_matroska_read_common_reset_streams (&demux->common, entry->time, TRUE);
1945 gst_flow_combiner_reset (demux->flowcombiner);
1946 demux->common.segment.position = entry->time;
1947 demux->seek_block = entry->block;
1948 demux->seek_first = TRUE;
1949 demux->last_stop_end = GST_CLOCK_TIME_NONE;
1952 for (i = 0; i < demux->common.src->len; i++) {
1953 GstMatroskaTrackContext *stream = g_ptr_array_index (demux->common.src, i);
1956 stream->to_offset = G_MAXINT64;
1958 if (stream->from_offset != -1)
1959 stream->to_offset = stream->from_offset;
1961 stream->from_offset = -1;
1962 stream->from_time = GST_CLOCK_TIME_NONE;
1965 GST_OBJECT_UNLOCK (demux);
1971 gst_matroska_cluster_compare (gint64 * i1, gint64 * i2)
1981 /* searches for a cluster start from @pos,
1982 * return GST_FLOW_OK and cluster position in @pos if found */
1983 static GstFlowReturn
1984 gst_matroska_demux_search_cluster (GstMatroskaDemux * demux, gint64 * pos,
1987 gint64 newpos = *pos;
1989 GstFlowReturn ret = GST_FLOW_OK;
1990 const guint chunk = 128 * 1024;
1991 GstBuffer *buf = NULL;
1993 gpointer data = NULL;
1998 gint64 oldpos, oldlength;
2000 orig_offset = demux->common.offset;
2002 GST_LOG_OBJECT (demux, "searching cluster %s offset %" G_GINT64_FORMAT,
2003 forward ? "following" : "preceding", *pos);
2005 if (demux->clusters) {
2008 cpos = gst_util_array_binary_search (demux->clusters->data,
2009 demux->clusters->len, sizeof (gint64),
2010 (GCompareDataFunc) gst_matroska_cluster_compare,
2011 forward ? GST_SEARCH_MODE_AFTER : GST_SEARCH_MODE_BEFORE, pos, NULL);
2014 GST_DEBUG_OBJECT (demux,
2015 "cluster reported at offset %" G_GINT64_FORMAT, *cpos);
2016 demux->common.offset = *cpos;
2017 ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
2018 GST_ELEMENT_CAST (demux), &id, &length, &needed);
2019 if (ret == GST_FLOW_OK && id == GST_MATROSKA_ID_CLUSTER) {
2026 /* read in at newpos and scan for ebml cluster id */
2027 oldpos = oldlength = -1;
2029 GstByteReader reader;
2031 guint toread = chunk;
2034 /* never read beyond the requested target */
2035 if (G_UNLIKELY (newpos < chunk)) {
2043 gst_buffer_unmap (buf, &map);
2044 gst_buffer_unref (buf);
2047 ret = gst_pad_pull_range (demux->common.sinkpad, newpos, toread, &buf);
2048 if (ret != GST_FLOW_OK)
2050 GST_DEBUG_OBJECT (demux,
2051 "read buffer size %" G_GSIZE_FORMAT " at offset %" G_GINT64_FORMAT,
2052 gst_buffer_get_size (buf), newpos);
2053 gst_buffer_map (buf, &map, GST_MAP_READ);
2056 if (oldpos == newpos && oldlength == map.size) {
2057 GST_ERROR_OBJECT (demux, "Stuck at same position");
2058 ret = GST_FLOW_ERROR;
2062 oldlength = map.size;
2065 gst_byte_reader_init (&reader, data, size);
2068 gint found = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff,
2069 GST_MATROSKA_ID_CLUSTER, 0, gst_byte_reader_get_remaining (&reader));
2071 cluster_pos = found;
2074 /* need last occurrence when searching backwards */
2076 cluster_pos = gst_byte_reader_get_pos (&reader) + found;
2077 gst_byte_reader_skip (&reader, found + 4);
2083 if (cluster_pos >= 0) {
2084 newpos += cluster_pos;
2085 GST_DEBUG_OBJECT (demux,
2086 "found cluster ebml id at offset %" G_GINT64_FORMAT, newpos);
2087 /* extra checks whether we really sync'ed to a cluster:
2088 * - either it is the first and only cluster
2089 * - either there is a cluster after this one
2090 * - either cluster length is undefined
2092 /* ok if first cluster (there may not a subsequent one) */
2093 if (newpos == demux->first_cluster_offset) {
2094 GST_DEBUG_OBJECT (demux, "cluster is first cluster -> OK");
2097 demux->common.offset = newpos;
2098 ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
2099 GST_ELEMENT_CAST (demux), &id, &length, &needed);
2100 if (ret != GST_FLOW_OK) {
2101 GST_DEBUG_OBJECT (demux, "need more data -> continue");
2104 g_assert (id == GST_MATROSKA_ID_CLUSTER);
2105 GST_DEBUG_OBJECT (demux, "cluster size %" G_GUINT64_FORMAT ", prefix %d",
2107 /* ok if undefined length or first cluster */
2108 if (length == GST_EBML_SIZE_UNKNOWN || length == G_MAXUINT64) {
2109 GST_DEBUG_OBJECT (demux, "cluster has undefined length -> OK");
2113 demux->common.offset += length + needed;
2114 ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
2115 GST_ELEMENT_CAST (demux), &id, &length, &needed);
2116 if (ret != GST_FLOW_OK)
2118 GST_DEBUG_OBJECT (demux, "next element is %scluster",
2119 id == GST_MATROSKA_ID_CLUSTER ? "" : "not ");
2120 if (id == GST_MATROSKA_ID_CLUSTER)
2126 /* partial cluster id may have been in tail of buffer */
2128 forward ? MAX (gst_byte_reader_get_remaining (&reader), 4) - 3 : 3;
2133 gst_buffer_unmap (buf, &map);
2134 gst_buffer_unref (buf);
2139 demux->common.offset = orig_offset;
2144 /* Three states to express: starts with I-frame, starts with delta, don't know */
2147 CLUSTER_STATUS_NONE = 0,
2148 CLUSTER_STATUS_STARTS_WITH_KEYFRAME,
2149 CLUSTER_STATUS_STARTS_WITH_DELTAUNIT,
2158 ClusterStatus status;
2161 static const gchar *
2162 cluster_status_get_nick (ClusterStatus status)
2165 case CLUSTER_STATUS_NONE:
2167 case CLUSTER_STATUS_STARTS_WITH_KEYFRAME:
2169 case CLUSTER_STATUS_STARTS_WITH_DELTAUNIT:
2175 /* Skip ebml-coded number:
2178 * 001x.. = 3 bytes, etc.
2181 bit_reader_skip_ebml_num (GstBitReader * br)
2185 if (!gst_bit_reader_peek_bits_uint8 (br, &v, 8))
2188 for (i = 0; i < 8; i++) {
2189 if ((v & (0x80 >> i)) != 0)
2192 return gst_bit_reader_skip (br, (i + 1) * 8);
2195 /* Don't probe more than that many bytes into the cluster for keyframe info
2196 * (random value, mostly for sanity checking) */
2197 #define MAX_CLUSTER_INFO_PROBE_LENGTH 256
2200 gst_matroska_demux_peek_cluster_info (GstMatroskaDemux * demux,
2201 ClusterInfo * cluster, guint64 offset)
2203 demux->common.offset = offset;
2204 demux->cluster_time = GST_CLOCK_TIME_NONE;
2206 cluster->offset = offset;
2208 cluster->prev_size = 0;
2209 cluster->time = GST_CLOCK_TIME_NONE;
2210 cluster->status = CLUSTER_STATUS_NONE;
2212 /* parse first few elements in cluster */
2219 flow = gst_matroska_read_common_peek_id_length_pull (&demux->common,
2220 GST_ELEMENT_CAST (demux), &id, &length, &needed);
2222 if (flow != GST_FLOW_OK)
2225 GST_LOG_OBJECT (demux, "Offset %" G_GUINT64_FORMAT ", Element id 0x%x, "
2226 "size %" G_GUINT64_FORMAT ", needed %d", demux->common.offset, id,
2229 /* Reached start of next cluster without finding data, stop processing */
2230 if (id == GST_MATROSKA_ID_CLUSTER && cluster->offset != offset)
2233 /* Not going to parse into these for now, stop processing */
2234 if (id == GST_MATROSKA_ID_ENCRYPTEDBLOCK
2235 || id == GST_MATROSKA_ID_BLOCKGROUP || id == GST_MATROSKA_ID_BLOCK)
2238 /* SimpleBlock: peek at headers to check if it's a keyframe */
2239 if (id == GST_MATROSKA_ID_SIMPLEBLOCK) {
2241 guint8 *d, hdr_len, v = 0;
2243 GST_DEBUG_OBJECT (demux, "SimpleBlock found");
2245 /* SimpleBlock header is max. 21 bytes */
2246 hdr_len = MIN (21, length);
2248 flow = gst_matroska_read_common_peek_bytes (&demux->common,
2249 demux->common.offset, hdr_len, NULL, &d);
2251 if (flow != GST_FLOW_OK)
2254 gst_bit_reader_init (&br, d, hdr_len);
2256 /* skip prefix: ebml id (SimpleBlock) + element length */
2257 if (!gst_bit_reader_skip (&br, 8 * needed))
2260 /* skip track number (ebml coded) */
2261 if (!bit_reader_skip_ebml_num (&br))
2265 if (!gst_bit_reader_skip (&br, 16))
2269 if (!gst_bit_reader_get_bits_uint8 (&br, &v, 8))
2272 if ((v & 0x80) != 0)
2273 cluster->status = CLUSTER_STATUS_STARTS_WITH_KEYFRAME;
2275 cluster->status = CLUSTER_STATUS_STARTS_WITH_DELTAUNIT;
2280 flow = gst_matroska_demux_parse_id (demux, id, length, needed);
2282 if (flow != GST_FLOW_OK)
2286 case GST_MATROSKA_ID_CLUSTER:
2287 if (length == G_MAXUINT64)
2290 cluster->size = length + needed;
2292 case GST_MATROSKA_ID_PREVSIZE:
2293 cluster->prev_size = demux->cluster_prevsize;
2295 case GST_MATROSKA_ID_CLUSTERTIMECODE:
2296 cluster->time = demux->cluster_time * demux->common.time_scale;
2298 case GST_MATROSKA_ID_SILENTTRACKS:
2299 /* ignore and continue */
2302 GST_WARNING_OBJECT (demux, "Unknown ebml id 0x%08x (possibly garbage), "
2306 } while (demux->common.offset - offset < MAX_CLUSTER_INFO_PROBE_LENGTH);
2310 GST_INFO_OBJECT (demux, "Cluster @ %" G_GUINT64_FORMAT ": "
2311 "time %" GST_TIME_FORMAT ", size %" G_GUINT64_FORMAT ", "
2312 "prev_size %" G_GUINT64_FORMAT ", %s", cluster->offset,
2313 GST_TIME_ARGS (cluster->time), cluster->size, cluster->prev_size,
2314 cluster_status_get_nick (cluster->status));
2316 /* return success as long as we could extract the minimum useful information */
2317 return cluster->time != GST_CLOCK_TIME_NONE;
2320 /* returns TRUE if the cluster offset was updated */
2322 gst_matroska_demux_scan_back_for_keyframe_cluster (GstMatroskaDemux * demux,
2323 gint64 * cluster_offset, GstClockTime * cluster_time)
2325 GstClockTime stream_start_time = demux->stream_start_time;
2326 guint64 first_cluster_offset = demux->first_cluster_offset;
2327 gint64 off = *cluster_offset;
2328 ClusterInfo cluster = { 0, };
2330 GST_INFO_OBJECT (demux, "Checking if cluster starts with keyframe");
2331 while (off > first_cluster_offset) {
2332 if (!gst_matroska_demux_peek_cluster_info (demux, &cluster, off)) {
2333 GST_LOG_OBJECT (demux,
2334 "Couldn't get info on cluster @ %" G_GUINT64_FORMAT, off);
2338 /* Keyframe? Then we're done */
2339 if (cluster.status == CLUSTER_STATUS_STARTS_WITH_KEYFRAME) {
2340 GST_LOG_OBJECT (demux,
2341 "Found keyframe at start of cluster @ %" G_GUINT64_FORMAT, off);
2345 /* We only scan back if we *know* we landed on a cluster that
2346 * starts with a delta frame. */
2347 if (cluster.status != CLUSTER_STATUS_STARTS_WITH_DELTAUNIT) {
2348 GST_LOG_OBJECT (demux,
2349 "No delta frame at start of cluster @ %" G_GUINT64_FORMAT, off);
2353 GST_DEBUG_OBJECT (demux, "Cluster starts with delta frame, backtracking");
2355 /* Don't scan back more than this much in time from the cluster we
2356 * originally landed on. This is mostly a sanity check in case a file
2357 * always has keyframes in the middle of clusters and never at the
2358 * beginning. Without this we would always scan back to the beginning
2359 * of the file in that case. */
2360 if (cluster.time != GST_CLOCK_TIME_NONE) {
2361 GstClockTimeDiff distance = GST_CLOCK_DIFF (cluster.time, *cluster_time);
2363 if (distance < 0 || distance > demux->max_backtrack_distance * GST_SECOND) {
2364 GST_DEBUG_OBJECT (demux, "Haven't found cluster with keyframe within "
2365 "%u secs of original seek target cluster, stopping",
2366 demux->max_backtrack_distance);
2371 /* If we have cluster prev_size we can skip back efficiently. If not,
2372 * we'll just do a brute force search for a cluster identifier */
2373 if (cluster.prev_size > 0 && off >= cluster.prev_size) {
2374 off -= cluster.prev_size;
2378 GST_LOG_OBJECT (demux, "Cluster has no or invalid prev size, searching "
2379 "for previous cluster instead then");
2381 flow = gst_matroska_demux_search_cluster (demux, &off, FALSE);
2382 if (flow != GST_FLOW_OK) {
2383 GST_DEBUG_OBJECT (demux, "cluster search yielded flow %s, stopping",
2384 gst_flow_get_name (flow));
2389 if (off <= first_cluster_offset) {
2390 GST_LOG_OBJECT (demux, "Reached first cluster, stopping");
2391 *cluster_offset = first_cluster_offset;
2392 *cluster_time = stream_start_time;
2395 GST_LOG_OBJECT (demux, "Trying prev cluster @ %" G_GUINT64_FORMAT, off);
2398 /* If we found a cluster starting with a keyframe jump to that instead,
2399 * otherwise leave everything as it was before */
2400 if (cluster.time != GST_CLOCK_TIME_NONE
2401 && (cluster.offset == first_cluster_offset
2402 || cluster.status == CLUSTER_STATUS_STARTS_WITH_KEYFRAME)) {
2403 *cluster_offset = cluster.offset;
2404 *cluster_time = cluster.time;
2411 /* bisect and scan through file for cluster starting before @time,
2412 * returns fake index entry with corresponding info on cluster */
2413 static GstMatroskaIndex *
2414 gst_matroska_demux_search_pos (GstMatroskaDemux * demux, GstClockTime time)
2416 GstMatroskaIndex *entry = NULL;
2417 GstMatroskaReadState current_state;
2418 GstClockTime otime, prev_cluster_time, current_cluster_time, cluster_time;
2420 gint64 opos, newpos, current_offset;
2421 gint64 prev_cluster_offset = -1, current_cluster_offset, cluster_offset;
2422 gint64 apos, maxpos;
2423 guint64 cluster_size = 0;
2429 /* estimate new position, resync using cluster ebml id,
2430 * and bisect further or scan forward to appropriate cluster */
2432 /* save some current global state which will be touched by our scanning */
2433 current_state = demux->common.state;
2434 g_return_val_if_fail (current_state == GST_MATROSKA_READ_STATE_DATA, NULL);
2436 current_cluster_offset = demux->cluster_offset;
2437 current_cluster_time = demux->cluster_time;
2438 current_offset = demux->common.offset;
2440 demux->common.state = GST_MATROSKA_READ_STATE_SCANNING;
2442 /* estimate using start and last known cluster */
2443 GST_OBJECT_LOCK (demux);
2444 apos = demux->first_cluster_offset;
2445 atime = demux->stream_start_time;
2446 opos = demux->last_cluster_offset;
2447 otime = demux->stream_last_time;
2448 GST_OBJECT_UNLOCK (demux);
2451 time = MAX (time, atime);
2452 otime = MAX (otime, atime);
2453 opos = MAX (opos, apos);
2455 maxpos = gst_matroska_read_common_get_length (&demux->common);
2460 * apos always refer to a cluster before target time;
2461 * opos may or may not be after target time, but if it is once so,
2462 * then also in next iteration
2466 GST_LOG_OBJECT (demux,
2467 "apos: %" G_GUINT64_FORMAT ", atime: %" GST_TIME_FORMAT ", %"
2468 GST_TIME_FORMAT " in stream time, "
2469 "opos: %" G_GUINT64_FORMAT ", otime: %" GST_TIME_FORMAT ", %"
2470 GST_TIME_FORMAT " in stream time (start %" GST_TIME_FORMAT "), time %"
2471 GST_TIME_FORMAT, apos, GST_TIME_ARGS (atime),
2472 GST_TIME_ARGS (atime - demux->stream_start_time), opos,
2473 GST_TIME_ARGS (otime), GST_TIME_ARGS (otime - demux->stream_start_time),
2474 GST_TIME_ARGS (demux->stream_start_time), GST_TIME_ARGS (time));
2476 g_assert (atime <= otime);
2477 g_assert (apos <= opos);
2478 if (time == GST_CLOCK_TIME_NONE) {
2479 GST_DEBUG_OBJECT (demux, "searching last cluster");
2482 GST_DEBUG_OBJECT (demux, "unknown file size; bailing out");
2485 } else if (otime <= atime) {
2489 gst_util_uint64_scale (opos - apos, time - atime, otime - atime);
2490 if (maxpos != -1 && newpos > maxpos)
2494 GST_DEBUG_OBJECT (demux,
2495 "estimated offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT,
2496 GST_TIME_ARGS (time), newpos);
2498 /* search backwards */
2499 if (newpos > apos) {
2500 ret = gst_matroska_demux_search_cluster (demux, &newpos, FALSE);
2501 if (ret != GST_FLOW_OK)
2505 /* then start scanning and parsing for cluster time,
2506 * re-estimate if possible, otherwise next cluster and so on */
2507 /* note that each re-estimate is entered with a change in apos or opos,
2508 * avoiding infinite loop */
2509 demux->common.offset = newpos;
2510 demux->cluster_time = cluster_time = GST_CLOCK_TIME_NONE;
2512 prev_cluster_time = GST_CLOCK_TIME_NONE;
2514 /* peek and parse some elements */
2515 ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
2516 GST_ELEMENT_CAST (demux), &id, &length, &needed);
2517 if (ret != GST_FLOW_OK)
2519 GST_LOG_OBJECT (demux, "Offset %" G_GUINT64_FORMAT ", Element id 0x%x, "
2520 "size %" G_GUINT64_FORMAT ", needed %d", demux->common.offset, id,
2522 ret = gst_matroska_demux_parse_id (demux, id, length, needed);
2523 if (ret != GST_FLOW_OK)
2526 if (id == GST_MATROSKA_ID_CLUSTER) {
2527 cluster_time = GST_CLOCK_TIME_NONE;
2528 if (length == G_MAXUINT64)
2531 cluster_size = length + needed;
2533 if (demux->cluster_time != GST_CLOCK_TIME_NONE &&
2534 cluster_time == GST_CLOCK_TIME_NONE) {
2535 cluster_time = demux->cluster_time * demux->common.time_scale;
2536 cluster_offset = demux->cluster_offset;
2537 GST_DEBUG_OBJECT (demux, "found cluster at offset %" G_GINT64_FORMAT
2538 " with time %" GST_TIME_FORMAT, cluster_offset,
2539 GST_TIME_ARGS (cluster_time));
2540 if (time == GST_CLOCK_TIME_NONE) {
2541 GST_DEBUG_OBJECT (demux, "found last cluster");
2542 prev_cluster_time = cluster_time;
2543 prev_cluster_offset = cluster_offset;
2546 if (cluster_time > time) {
2547 GST_DEBUG_OBJECT (demux, "overshot target");
2548 /* cluster overshoots */
2549 if (cluster_offset == demux->first_cluster_offset) {
2550 /* but no prev one */
2551 GST_DEBUG_OBJECT (demux, "but using first cluster anyway");
2552 prev_cluster_time = cluster_time;
2553 prev_cluster_offset = cluster_offset;
2556 if (prev_cluster_time != GST_CLOCK_TIME_NONE) {
2557 /* prev cluster did not overshoot, so prev cluster is target */
2560 /* re-estimate using this new position info */
2561 opos = cluster_offset;
2562 otime = cluster_time;
2566 /* cluster undershoots */
2567 GST_DEBUG_OBJECT (demux, "undershot target");
2568 /* ok if close enough */
2569 if (GST_CLOCK_DIFF (cluster_time, time) < 5 * GST_SECOND) {
2570 GST_DEBUG_OBJECT (demux, "target close enough");
2571 prev_cluster_time = cluster_time;
2572 prev_cluster_offset = cluster_offset;
2576 /* we are in between atime and otime => can bisect if worthwhile */
2577 if (prev_cluster_time != GST_CLOCK_TIME_NONE &&
2578 cluster_time > prev_cluster_time &&
2579 (GST_CLOCK_DIFF (prev_cluster_time, cluster_time) * 10 <
2580 GST_CLOCK_DIFF (cluster_time, time))) {
2581 /* we moved at least one cluster forward,
2582 * and it looks like target is still far away,
2583 * let's estimate again */
2584 GST_DEBUG_OBJECT (demux, "bisecting with new apos");
2585 apos = cluster_offset;
2586 atime = cluster_time;
2590 /* cluster undershoots, goto next one */
2591 prev_cluster_time = cluster_time;
2592 prev_cluster_offset = cluster_offset;
2593 /* skip cluster if length is defined,
2594 * otherwise will be skippingly parsed into */
2596 GST_DEBUG_OBJECT (demux, "skipping to next cluster");
2597 demux->common.offset = cluster_offset + cluster_size;
2598 demux->cluster_time = GST_CLOCK_TIME_NONE;
2600 GST_DEBUG_OBJECT (demux, "parsing/skipping cluster elements");
2607 if (ret == GST_FLOW_EOS) {
2608 if (prev_cluster_time != GST_CLOCK_TIME_NONE)
2614 /* In the bisect loop above we always undershoot and then jump forward
2615 * cluster-by-cluster until we overshoot, so if we get here we've gone
2616 * over and the previous cluster is where we need to go to. */
2617 cluster_offset = prev_cluster_offset;
2618 cluster_time = prev_cluster_time;
2620 /* If we have video and can easily backtrack, check if we landed on a cluster
2621 * that starts with a keyframe - and if not backtrack until we find one that
2623 if (demux->have_nonintraonly_v_streams && demux->max_backtrack_distance > 0) {
2624 if (gst_matroska_demux_scan_back_for_keyframe_cluster (demux,
2625 &cluster_offset, &cluster_time)) {
2626 GST_INFO_OBJECT (demux, "Adjusted cluster to %" GST_TIME_FORMAT " @ "
2627 "%" G_GUINT64_FORMAT, GST_TIME_ARGS (cluster_time), cluster_offset);
2631 entry = g_new0 (GstMatroskaIndex, 1);
2632 entry->time = cluster_time;
2633 entry->pos = cluster_offset - demux->common.ebml_segment_start;
2634 GST_DEBUG_OBJECT (demux, "simulated index entry; time %" GST_TIME_FORMAT
2635 ", pos %" G_GUINT64_FORMAT, GST_TIME_ARGS (entry->time), entry->pos);
2639 /* restore some state */
2640 demux->cluster_offset = current_cluster_offset;
2641 demux->cluster_time = current_cluster_time;
2642 demux->common.offset = current_offset;
2643 demux->common.state = current_state;
2649 gst_matroska_demux_handle_seek_event (GstMatroskaDemux * demux,
2650 GstPad * pad, GstEvent * event)
2652 GstMatroskaIndex *entry = NULL;
2653 GstMatroskaIndex scan_entry;
2655 GstSeekType cur_type, stop_type;
2657 gboolean flush, keyunit, before, after, snap_next;
2660 GstMatroskaTrackContext *track = NULL;
2661 GstSegment seeksegment = { 0, };
2662 gboolean update = TRUE;
2663 gboolean pad_locked = FALSE;
2665 GstSearchMode snap_dir;
2667 g_return_val_if_fail (event != NULL, FALSE);
2670 track = gst_pad_get_element_private (pad);
2672 GST_DEBUG_OBJECT (demux, "Have seek %" GST_PTR_FORMAT, event);
2674 gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,
2676 seqnum = gst_event_get_seqnum (event);
2678 /* we can only seek on time */
2679 if (format != GST_FORMAT_TIME) {
2680 GST_DEBUG_OBJECT (demux, "Can only seek on TIME");
2684 /* copy segment, we need this because we still need the old
2685 * segment when we close the current segment. */
2686 memcpy (&seeksegment, &demux->common.segment, sizeof (GstSegment));
2688 /* pull mode without index means that the actual duration is not known,
2689 * we might be playing a file that's still being recorded
2690 * so, invalidate our current duration, which is only a moving target,
2691 * and should not be used to clamp anything */
2692 if (!demux->streaming && !demux->common.index && demux->invalid_duration) {
2693 seeksegment.duration = GST_CLOCK_TIME_NONE;
2696 GST_DEBUG_OBJECT (demux, "configuring seek");
2697 /* Subtract stream_start_time so we always seek on a segment
2699 if (GST_CLOCK_TIME_IS_VALID (demux->stream_start_time)) {
2700 seeksegment.start -= demux->stream_start_time;
2701 seeksegment.position -= demux->stream_start_time;
2702 if (GST_CLOCK_TIME_IS_VALID (seeksegment.stop))
2703 seeksegment.stop -= demux->stream_start_time;
2705 seeksegment.stop = seeksegment.duration;
2708 gst_segment_do_seek (&seeksegment, rate, format, flags,
2709 cur_type, cur, stop_type, stop, &update);
2711 /* Restore the clip timestamp offset */
2712 if (GST_CLOCK_TIME_IS_VALID (demux->stream_start_time)) {
2713 seeksegment.position += demux->stream_start_time;
2714 seeksegment.start += demux->stream_start_time;
2715 if (!GST_CLOCK_TIME_IS_VALID (seeksegment.stop))
2716 seeksegment.stop = seeksegment.duration;
2717 if (GST_CLOCK_TIME_IS_VALID (seeksegment.stop))
2718 seeksegment.stop += demux->stream_start_time;
2721 /* restore segment duration (if any effect),
2722 * would be determined again when parsing, but anyway ... */
2723 seeksegment.duration = demux->common.segment.duration;
2725 flush = !!(flags & GST_SEEK_FLAG_FLUSH);
2726 keyunit = !!(flags & GST_SEEK_FLAG_KEY_UNIT);
2727 after = !!(flags & GST_SEEK_FLAG_SNAP_AFTER);
2728 before = !!(flags & GST_SEEK_FLAG_SNAP_BEFORE);
2730 /* always do full update if flushing,
2731 * otherwise problems might arise downstream with missing keyframes etc */
2732 update = update || flush;
2734 GST_DEBUG_OBJECT (demux, "New segment %" GST_SEGMENT_FORMAT, &seeksegment);
2736 /* check sanity before we start flushing and all that */
2737 snap_next = after && !before;
2738 if (seeksegment.rate < 0)
2739 snap_dir = snap_next ? GST_SEARCH_MODE_BEFORE : GST_SEARCH_MODE_AFTER;
2741 snap_dir = snap_next ? GST_SEARCH_MODE_AFTER : GST_SEARCH_MODE_BEFORE;
2743 GST_OBJECT_LOCK (demux);
2744 track = gst_matroska_read_common_get_seek_track (&demux->common, track);
2745 if ((entry = gst_matroska_read_common_do_index_seek (&demux->common, track,
2746 seeksegment.position, &demux->seek_index, &demux->seek_entry,
2747 snap_dir)) == NULL) {
2748 /* pull mode without index can scan later on */
2749 if (demux->streaming) {
2750 GST_DEBUG_OBJECT (demux, "No matching seek entry in index");
2751 GST_OBJECT_UNLOCK (demux);
2753 } else if (rate < 0.0) {
2754 /* FIXME: We should build an index during playback or when scanning
2755 * that can be used here. The reverse playback code requires seek_index
2756 * and seek_entry to be set!
2758 GST_DEBUG_OBJECT (demux,
2759 "No matching seek entry in index, needed for reverse playback");
2760 GST_OBJECT_UNLOCK (demux);
2764 GST_DEBUG_OBJECT (demux, "Seek position looks sane");
2765 GST_OBJECT_UNLOCK (demux);
2768 /* only have to update some segment,
2769 * but also still have to honour flush and so on */
2770 GST_DEBUG_OBJECT (demux, "... no update");
2771 /* bad goto, bad ... */
2775 if (demux->streaming)
2780 GstEvent *flush_event = gst_event_new_flush_start ();
2781 gst_event_set_seqnum (flush_event, seqnum);
2782 GST_DEBUG_OBJECT (demux, "Starting flush");
2783 gst_pad_push_event (demux->common.sinkpad, gst_event_ref (flush_event));
2784 gst_matroska_demux_send_event (demux, flush_event);
2786 GST_DEBUG_OBJECT (demux, "Non-flushing seek, pausing task");
2787 gst_pad_pause_task (demux->common.sinkpad);
2791 GST_PAD_STREAM_LOCK (demux->common.sinkpad);
2796 /* now grab the stream lock so that streaming cannot continue, for
2797 * non flushing seeks when the element is in PAUSED this could block
2799 GST_DEBUG_OBJECT (demux, "Waiting for streaming to stop");
2800 GST_PAD_STREAM_LOCK (demux->common.sinkpad);
2803 /* pull mode without index can do some scanning */
2804 if (!demux->streaming && !entry) {
2805 GstEvent *flush_event;
2807 /* need to stop flushing upstream as we need it next */
2809 flush_event = gst_event_new_flush_stop (TRUE);
2810 gst_event_set_seqnum (flush_event, seqnum);
2811 gst_pad_push_event (demux->common.sinkpad, flush_event);
2813 entry = gst_matroska_demux_search_pos (demux, seeksegment.position);
2814 /* keep local copy */
2816 scan_entry = *entry;
2818 entry = &scan_entry;
2820 GST_DEBUG_OBJECT (demux, "Scan failed to find matching position");
2822 flush_event = gst_event_new_flush_stop (TRUE);
2823 gst_event_set_seqnum (flush_event, seqnum);
2824 gst_matroska_demux_send_event (demux, flush_event);
2831 if (keyunit && seeksegment.rate > 0) {
2832 GST_DEBUG_OBJECT (demux, "seek to key unit, adjusting segment start from %"
2833 GST_TIME_FORMAT " to %" GST_TIME_FORMAT,
2834 GST_TIME_ARGS (seeksegment.start), GST_TIME_ARGS (entry->time));
2835 seeksegment.start = MAX (entry->time, demux->stream_start_time);
2836 seeksegment.position = seeksegment.start;
2837 seeksegment.time = seeksegment.start - demux->stream_start_time;
2838 } else if (keyunit) {
2839 GST_DEBUG_OBJECT (demux, "seek to key unit, adjusting segment stop from %"
2840 GST_TIME_FORMAT " to %" GST_TIME_FORMAT,
2841 GST_TIME_ARGS (seeksegment.stop), GST_TIME_ARGS (entry->time));
2842 seeksegment.stop = MAX (entry->time, demux->stream_start_time);
2843 seeksegment.position = seeksegment.stop;
2846 if (demux->streaming) {
2847 GST_OBJECT_LOCK (demux);
2848 /* track real position we should start at */
2849 GST_DEBUG_OBJECT (demux, "storing segment start");
2850 demux->requested_seek_time = seeksegment.position;
2851 demux->seek_offset = entry->pos + demux->common.ebml_segment_start;
2852 GST_OBJECT_UNLOCK (demux);
2853 /* need to seek to cluster start to pick up cluster time */
2854 /* upstream takes care of flushing and all that
2855 * ... and newsegment event handling takes care of the rest */
2856 return perform_seek_to_offset (demux, rate,
2857 entry->pos + demux->common.ebml_segment_start, seqnum, flags);
2862 GstEvent *flush_event = gst_event_new_flush_stop (TRUE);
2863 gst_event_set_seqnum (flush_event, seqnum);
2864 GST_DEBUG_OBJECT (demux, "Stopping flush");
2865 gst_pad_push_event (demux->common.sinkpad, gst_event_ref (flush_event));
2866 gst_matroska_demux_send_event (demux, flush_event);
2869 GST_OBJECT_LOCK (demux);
2870 /* now update the real segment info */
2871 GST_DEBUG_OBJECT (demux, "Committing new seek segment");
2872 memcpy (&demux->common.segment, &seeksegment, sizeof (GstSegment));
2873 GST_OBJECT_UNLOCK (demux);
2875 /* update some (segment) state */
2876 if (!gst_matroska_demux_move_to_entry (demux, entry, TRUE, update))
2879 /* notify start of new segment */
2880 if (demux->common.segment.flags & GST_SEEK_FLAG_SEGMENT) {
2883 msg = gst_message_new_segment_start (GST_OBJECT (demux),
2884 GST_FORMAT_TIME, demux->common.segment.start);
2885 gst_message_set_seqnum (msg, seqnum);
2886 gst_element_post_message (GST_ELEMENT (demux), msg);
2889 GST_OBJECT_LOCK (demux);
2890 if (demux->new_segment)
2891 gst_event_unref (demux->new_segment);
2893 /* On port from 0.10, discarded !update (for segment.update) here, FIXME? */
2894 demux->new_segment = gst_event_new_segment (&demux->common.segment);
2895 gst_event_set_seqnum (demux->new_segment, seqnum);
2896 if (demux->common.segment.rate < 0 && demux->common.segment.stop == -1)
2897 demux->to_time = demux->common.segment.position;
2899 demux->to_time = GST_CLOCK_TIME_NONE;
2900 demux->segment_seqnum = seqnum;
2901 GST_OBJECT_UNLOCK (demux);
2903 /* restart our task since it might have been stopped when we did the
2905 gst_pad_start_task (demux->common.sinkpad,
2906 (GstTaskFunction) gst_matroska_demux_loop, demux->common.sinkpad, NULL);
2908 /* streaming can continue now */
2910 GST_PAD_STREAM_UNLOCK (demux->common.sinkpad);
2918 GST_PAD_STREAM_UNLOCK (demux->common.sinkpad);
2920 GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL), ("Got a seek error"));
2926 * Handle whether we can perform the seek event or if we have to let the chain
2927 * function handle seeks to build the seek indexes first.
2930 gst_matroska_demux_handle_seek_push (GstMatroskaDemux * demux, GstPad * pad,
2934 GstSeekType cur_type, stop_type;
2939 gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,
2944 /* we can only seek on time */
2945 if (format != GST_FORMAT_TIME) {
2946 GST_DEBUG_OBJECT (demux, "Can only seek on TIME");
2950 if (stop_type != GST_SEEK_TYPE_NONE && stop != GST_CLOCK_TIME_NONE) {
2951 GST_DEBUG_OBJECT (demux, "Seek end-time not supported in streaming mode");
2955 if (!(flags & GST_SEEK_FLAG_FLUSH)) {
2956 GST_DEBUG_OBJECT (demux,
2957 "Non-flushing seek not supported in streaming mode");
2961 if (flags & GST_SEEK_FLAG_SEGMENT) {
2962 GST_DEBUG_OBJECT (demux, "Segment seek not supported in streaming mode");
2966 /* check for having parsed index already */
2967 if (!demux->common.index_parsed) {
2968 gboolean building_index;
2971 if (!demux->index_offset) {
2972 GST_DEBUG_OBJECT (demux, "no index (location); no seek in push mode");
2976 GST_OBJECT_LOCK (demux);
2977 /* handle the seek event in the chain function */
2978 demux->common.state = GST_MATROSKA_READ_STATE_SEEK;
2979 /* no more seek can be issued until state reset to _DATA */
2981 /* copy the event */
2982 if (demux->seek_event)
2983 gst_event_unref (demux->seek_event);
2984 demux->seek_event = gst_event_ref (event);
2986 /* set the building_index flag so that only one thread can setup the
2987 * structures for index seeking. */
2988 building_index = demux->building_index;
2989 if (!building_index) {
2990 demux->building_index = TRUE;
2991 offset = demux->index_offset;
2993 GST_OBJECT_UNLOCK (demux);
2995 if (!building_index) {
2996 /* seek to the first subindex or legacy index */
2997 GST_INFO_OBJECT (demux, "Seeking to Cues at %" G_GUINT64_FORMAT, offset);
2998 return perform_seek_to_offset (demux, rate, offset,
2999 gst_event_get_seqnum (event), GST_SEEK_FLAG_NONE);
3002 /* well, we are handling it already */
3006 /* delegate to tweaked regular seek */
3007 return gst_matroska_demux_handle_seek_event (demux, pad, event);
3011 gst_matroska_demux_handle_src_event (GstPad * pad, GstObject * parent,
3014 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
3015 gboolean res = TRUE;
3017 switch (GST_EVENT_TYPE (event)) {
3018 case GST_EVENT_SEEK:
3019 /* no seeking until we are (safely) ready */
3020 if (demux->common.state != GST_MATROSKA_READ_STATE_DATA) {
3021 GST_DEBUG_OBJECT (demux,
3022 "not ready for seeking yet, deferring seek event: %" GST_PTR_FORMAT,
3024 if (demux->deferred_seek_event)
3025 gst_event_unref (demux->deferred_seek_event);
3026 demux->deferred_seek_event = event;
3027 demux->deferred_seek_pad = pad;
3032 guint32 seqnum = gst_event_get_seqnum (event);
3033 if (seqnum == demux->segment_seqnum) {
3034 GST_LOG_OBJECT (pad,
3035 "Drop duplicated SEEK event seqnum %" G_GUINT32_FORMAT, seqnum);
3036 gst_event_unref (event);
3041 if (!demux->streaming)
3042 res = gst_matroska_demux_handle_seek_event (demux, pad, event);
3044 res = gst_matroska_demux_handle_seek_push (demux, pad, event);
3045 gst_event_unref (event);
3050 GstMatroskaTrackContext *context = gst_pad_get_element_private (pad);
3051 if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO) {
3052 GstMatroskaTrackVideoContext *videocontext =
3053 (GstMatroskaTrackVideoContext *) context;
3055 GstClockTimeDiff diff;
3056 GstClockTime timestamp;
3058 gst_event_parse_qos (event, NULL, &proportion, &diff, ×tamp);
3060 GST_OBJECT_LOCK (demux);
3061 videocontext->earliest_time = timestamp + diff;
3062 GST_OBJECT_UNLOCK (demux);
3065 gst_event_unref (event);
3069 case GST_EVENT_TOC_SELECT:
3072 GstTocEntry *entry = NULL;
3073 GstEvent *seek_event;
3076 if (!demux->common.toc) {
3077 GST_DEBUG_OBJECT (demux, "no TOC to select");
3080 gst_event_parse_toc_select (event, &uid);
3082 GST_OBJECT_LOCK (demux);
3083 entry = gst_toc_find_entry (demux->common.toc, uid);
3084 if (entry == NULL) {
3085 GST_OBJECT_UNLOCK (demux);
3086 GST_WARNING_OBJECT (demux, "no TOC entry with given UID: %s", uid);
3089 gst_toc_entry_get_start_stop_times (entry, &start_pos, NULL);
3090 GST_OBJECT_UNLOCK (demux);
3091 seek_event = gst_event_new_seek (1.0,
3093 GST_SEEK_FLAG_FLUSH,
3094 GST_SEEK_TYPE_SET, start_pos, GST_SEEK_TYPE_SET, -1);
3095 res = gst_matroska_demux_handle_seek_event (demux, pad, seek_event);
3096 gst_event_unref (seek_event);
3100 GST_WARNING_OBJECT (demux, "received empty TOC select event");
3104 gst_event_unref (event);
3108 /* events we don't need to handle */
3109 case GST_EVENT_NAVIGATION:
3110 gst_event_unref (event);
3114 case GST_EVENT_LATENCY:
3116 res = gst_pad_push_event (demux->common.sinkpad, event);
3124 gst_matroska_demux_handle_sink_query (GstPad * pad, GstObject * parent,
3127 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
3128 gboolean res = FALSE;
3130 switch (GST_QUERY_TYPE (query)) {
3131 case GST_QUERY_BITRATE:
3133 if (G_UNLIKELY (demux->cached_length == G_MAXUINT64 ||
3134 demux->common.offset >= demux->cached_length)) {
3135 demux->cached_length =
3136 gst_matroska_read_common_get_length (&demux->common);
3139 if (demux->cached_length < G_MAXUINT64
3140 && demux->common.segment.duration > 0) {
3141 /* TODO: better results based on ranges/index tables */
3143 gst_util_uint64_scale (8 * demux->cached_length, GST_SECOND,
3144 demux->common.segment.duration);
3146 GST_LOG_OBJECT (demux, "bitrate query byte length: %" G_GUINT64_FORMAT
3147 " duration %" GST_TIME_FORMAT " resulting in a bitrate of %u",
3148 demux->cached_length,
3149 GST_TIME_ARGS (demux->common.segment.duration), bitrate);
3151 gst_query_set_bitrate (query, bitrate);
3157 res = gst_pad_query_default (pad, (GstObject *) demux, query);
3164 static GstFlowReturn
3165 gst_matroska_demux_seek_to_previous_keyframe (GstMatroskaDemux * demux)
3167 GstFlowReturn ret = GST_FLOW_EOS;
3168 gboolean done = TRUE;
3171 g_return_val_if_fail (demux->seek_index, GST_FLOW_EOS);
3172 g_return_val_if_fail (demux->seek_entry < demux->seek_index->len,
3175 GST_DEBUG_OBJECT (demux, "locating previous keyframe");
3177 if (!demux->seek_entry) {
3178 GST_DEBUG_OBJECT (demux, "no earlier index entry");
3182 for (i = 0; i < demux->common.src->len; i++) {
3183 GstMatroskaTrackContext *stream = g_ptr_array_index (demux->common.src, i);
3185 GST_DEBUG_OBJECT (demux, "segment start %" GST_TIME_FORMAT
3186 ", stream %d at %" GST_TIME_FORMAT,
3187 GST_TIME_ARGS (demux->common.segment.start), stream->index,
3188 GST_TIME_ARGS (stream->from_time));
3189 if (GST_CLOCK_TIME_IS_VALID (stream->from_time)) {
3190 if (stream->from_time > demux->common.segment.start) {
3191 GST_DEBUG_OBJECT (demux, "stream %d not finished yet", stream->index);
3195 /* nothing pushed for this stream;
3196 * likely seek entry did not start at keyframe, so all was skipped.
3197 * So we need an earlier entry */
3203 GstMatroskaIndex *entry;
3205 entry = &g_array_index (demux->seek_index, GstMatroskaIndex,
3206 --demux->seek_entry);
3207 if (!gst_matroska_demux_move_to_entry (demux, entry, FALSE, TRUE))
3217 static GstFlowReturn
3218 gst_matroska_demux_parse_tracks (GstMatroskaDemux * demux, GstEbmlRead * ebml)
3220 GstFlowReturn ret = GST_FLOW_OK;
3223 DEBUG_ELEMENT_START (demux, ebml, "Tracks");
3225 if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
3226 DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret);
3230 while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
3231 if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
3235 /* one track within the "all-tracks" header */
3236 case GST_MATROSKA_ID_TRACKENTRY:{
3237 GstMatroskaTrackContext *track;
3238 ret = gst_matroska_demux_parse_stream (demux, ebml, &track);
3239 if (track != NULL) {
3240 if (gst_matroska_read_common_tracknumber_unique (&demux->common,
3242 gst_matroska_demux_add_stream (demux, track);
3244 GST_ERROR_OBJECT (demux,
3245 "TrackNumber %" G_GUINT64_FORMAT " is not unique", track->num);
3246 ret = GST_FLOW_ERROR;
3247 gst_matroska_track_free (track);
3255 ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
3260 DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret);
3262 demux->tracks_parsed = TRUE;
3263 GST_DEBUG_OBJECT (demux, "signaling no more pads");
3264 gst_element_no_more_pads (GST_ELEMENT (demux));
3269 static GstFlowReturn
3270 gst_matroska_demux_update_tracks (GstMatroskaDemux * demux, GstEbmlRead * ebml)
3272 GstFlowReturn ret = GST_FLOW_OK;
3273 guint num_tracks_found = 0;
3276 GST_INFO_OBJECT (demux, "Reparsing Tracks element");
3278 DEBUG_ELEMENT_START (demux, ebml, "Tracks");
3280 if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
3281 DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret);
3285 while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
3286 if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
3290 /* one track within the "all-tracks" header */
3291 case GST_MATROSKA_ID_TRACKENTRY:{
3292 GstMatroskaTrackContext *new_track;
3293 gint old_track_index;
3294 GstMatroskaTrackContext *old_track;
3295 ret = gst_matroska_demux_parse_stream (demux, ebml, &new_track);
3296 if (new_track == NULL)
3300 if (gst_matroska_read_common_tracknumber_unique (&demux->common,
3302 GST_ERROR_OBJECT (demux,
3303 "Unexpected new TrackNumber: %" G_GUINT64_FORMAT, new_track->num);
3304 goto track_mismatch_error;
3308 gst_matroska_read_common_stream_from_num (&demux->common,
3310 g_assert (old_track_index != -1);
3311 old_track = g_ptr_array_index (demux->common.src, old_track_index);
3313 if (old_track->type != new_track->type) {
3314 GST_ERROR_OBJECT (demux,
3315 "Mismatch reparsing track %" G_GUINT64_FORMAT
3316 " on track type. Expected %d, found %d", new_track->num,
3317 old_track->type, new_track->type);
3318 goto track_mismatch_error;
3321 if (g_strcmp0 (old_track->codec_id, new_track->codec_id) != 0) {
3322 GST_ERROR_OBJECT (demux,
3323 "Mismatch reparsing track %" G_GUINT64_FORMAT
3324 " on codec id. Expected '%s', found '%s'", new_track->num,
3325 old_track->codec_id, new_track->codec_id);
3326 goto track_mismatch_error;
3329 /* The new track matches the old track. No problems on our side.
3330 * Let's make it replace the old track. */
3331 new_track->pad = old_track->pad;
3332 new_track->index = old_track->index;
3333 new_track->pos = old_track->pos;
3334 g_ptr_array_index (demux->common.src, old_track_index) = new_track;
3335 gst_pad_set_element_private (new_track->pad, new_track);
3337 if (!gst_caps_is_equal (old_track->caps, new_track->caps)) {
3338 gst_pad_set_caps (new_track->pad, new_track->caps);
3340 gst_caps_replace (&old_track->caps, NULL);
3342 if (!gst_tag_list_is_equal (old_track->tags, new_track->tags)) {
3343 GST_DEBUG_OBJECT (old_track->pad, "Sending tags %p: %"
3344 GST_PTR_FORMAT, new_track->tags, new_track->tags);
3345 gst_pad_push_event (new_track->pad,
3346 gst_event_new_tag (gst_tag_list_copy (new_track->tags)));
3349 gst_matroska_track_free (old_track);
3352 track_mismatch_error:
3353 gst_matroska_track_free (new_track);
3355 ret = GST_FLOW_ERROR;
3360 ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
3365 DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret);
3367 if (ret != GST_FLOW_ERROR && demux->common.num_streams != num_tracks_found) {
3368 GST_ERROR_OBJECT (demux,
3369 "Mismatch on the number of tracks. Expected %du tracks, found %du",
3370 demux->common.num_streams, num_tracks_found);
3371 ret = GST_FLOW_ERROR;
3378 * Read signed/unsigned "EBML" numbers.
3379 * Return: number of bytes processed.
3383 gst_matroska_ebmlnum_uint (guint8 * data, guint size, guint64 * num)
3385 gint len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
3393 while (read <= 8 && !(total & len_mask)) {
3400 if ((total &= (len_mask - 1)) == len_mask - 1)
3405 if (data[n] == 0xff)
3407 total = (total << 8) | data[n];
3411 if (read == num_ffs && total != 0)
3420 gst_matroska_ebmlnum_sint (guint8 * data, guint size, gint64 * num)
3425 /* read as unsigned number first */
3426 if ((res = gst_matroska_ebmlnum_uint (data, size, &unum)) < 0)
3430 if (unum == G_MAXUINT64)
3433 *num = unum - ((1 << ((7 * res) - 1)) - 1);
3439 * Mostly used for subtitles. We add void filler data for each
3440 * lagging stream to make sure we don't deadlock.
3444 gst_matroska_demux_sync_streams (GstMatroskaDemux * demux)
3446 GstClockTime gap_threshold;
3449 GST_OBJECT_LOCK (demux);
3451 GST_LOG_OBJECT (demux, "Sync to %" GST_TIME_FORMAT,
3452 GST_TIME_ARGS (demux->common.segment.position));
3454 g_assert (demux->common.num_streams == demux->common.src->len);
3455 for (stream_nr = 0; stream_nr < demux->common.src->len; stream_nr++) {
3456 GstMatroskaTrackContext *context;
3458 context = g_ptr_array_index (demux->common.src, stream_nr);
3460 GST_LOG_OBJECT (demux,
3461 "Checking for resync on stream %d (%" GST_TIME_FORMAT ")", stream_nr,
3462 GST_TIME_ARGS (context->pos));
3464 /* Only send gap events on non-subtitle streams if lagging way behind.
3465 * The 0.5 second threshold for subtitle streams is also quite random. */
3466 if (context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE)
3467 gap_threshold = GST_SECOND / 2;
3469 gap_threshold = 3 * GST_SECOND;
3471 /* Lag need only be considered if we have advanced into requested segment */
3472 if (GST_CLOCK_TIME_IS_VALID (context->pos) &&
3473 GST_CLOCK_TIME_IS_VALID (demux->common.segment.position) &&
3474 demux->common.segment.position > demux->common.segment.start &&
3475 context->pos + gap_threshold < demux->common.segment.position) {
3478 guint64 start = context->pos;
3479 guint64 stop = demux->common.segment.position - gap_threshold;
3481 GST_DEBUG_OBJECT (demux,
3482 "Synchronizing stream %d with other by advancing time from %"
3483 GST_TIME_FORMAT " to %" GST_TIME_FORMAT, stream_nr,
3484 GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
3486 context->pos = stop;
3488 event = gst_event_new_gap (start, stop - start);
3489 GST_OBJECT_UNLOCK (demux);
3490 gst_pad_push_event (context->pad, event);
3491 GST_OBJECT_LOCK (demux);
3495 GST_OBJECT_UNLOCK (demux);
3498 static GstFlowReturn
3499 gst_matroska_demux_push_stream_headers (GstMatroskaDemux * demux,
3500 GstMatroskaTrackContext * stream)
3502 GstFlowReturn ret = GST_FLOW_OK;
3505 num = gst_buffer_list_length (stream->stream_headers);
3506 for (i = 0; i < num; ++i) {
3509 buf = gst_buffer_list_get (stream->stream_headers, i);
3510 buf = gst_buffer_copy (buf);
3512 GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_HEADER);
3514 if (stream->set_discont) {
3515 GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
3516 stream->set_discont = FALSE;
3518 GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
3521 /* push out all headers in one go and use last flow return */
3522 ret = gst_pad_push (stream->pad, buf);
3525 /* don't need these any longer */
3526 gst_buffer_list_unref (stream->stream_headers);
3527 stream->stream_headers = NULL;
3530 ret = gst_flow_combiner_update_flow (demux->flowcombiner, ret);
3536 gst_matroska_demux_push_dvd_clut_change_event (GstMatroskaDemux * demux,
3537 GstMatroskaTrackContext * stream)
3541 g_assert (!strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_VOBSUB));
3543 if (!stream->codec_priv)
3546 /* ideally, VobSub private data should be parsed and stored more convenient
3547 * elsewhere, but for now, only interested in a small part */
3549 /* make sure we have terminating 0 */
3550 buf = g_strndup (stream->codec_priv, stream->codec_priv_size);
3552 /* just locate and parse palette part */
3553 start = strstr (buf, "palette:");
3558 guint8 r, g, b, y, u, v;
3561 while (g_ascii_isspace (*start))
3563 for (i = 0; i < 16; i++) {
3564 if (sscanf (start, "%06x", &col) != 1)
3567 while ((*start == ',') || g_ascii_isspace (*start))
3569 /* sigh, need to convert this from vobsub pseudo-RGB to YUV */
3570 r = (col >> 16) & 0xff;
3571 g = (col >> 8) & 0xff;
3573 y = CLAMP ((0.1494 * r + 0.6061 * g + 0.2445 * b) * 219 / 255 + 16, 0,
3575 u = CLAMP (0.6066 * r - 0.4322 * g - 0.1744 * b + 128, 0, 255);
3576 v = CLAMP (-0.08435 * r - 0.3422 * g + 0.4266 * b + 128, 0, 255);
3577 clut[i] = (y << 16) | (u << 8) | v;
3580 /* got them all without problems; build and send event */
3584 s = gst_structure_new ("application/x-gst-dvd", "event", G_TYPE_STRING,
3585 "dvd-spu-clut-change", "clut00", G_TYPE_INT, clut[0], "clut01",
3586 G_TYPE_INT, clut[1], "clut02", G_TYPE_INT, clut[2], "clut03",
3587 G_TYPE_INT, clut[3], "clut04", G_TYPE_INT, clut[4], "clut05",
3588 G_TYPE_INT, clut[5], "clut06", G_TYPE_INT, clut[6], "clut07",
3589 G_TYPE_INT, clut[7], "clut08", G_TYPE_INT, clut[8], "clut09",
3590 G_TYPE_INT, clut[9], "clut10", G_TYPE_INT, clut[10], "clut11",
3591 G_TYPE_INT, clut[11], "clut12", G_TYPE_INT, clut[12], "clut13",
3592 G_TYPE_INT, clut[13], "clut14", G_TYPE_INT, clut[14], "clut15",
3593 G_TYPE_INT, clut[15], NULL);
3595 gst_pad_push_event (stream->pad,
3596 gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM_STICKY, s));
3603 gst_matroska_demux_push_codec_data_all (GstMatroskaDemux * demux)
3607 g_assert (demux->common.num_streams == demux->common.src->len);
3608 for (stream_nr = 0; stream_nr < demux->common.src->len; stream_nr++) {
3609 GstMatroskaTrackContext *stream;
3611 stream = g_ptr_array_index (demux->common.src, stream_nr);
3613 if (stream->send_stream_headers) {
3614 if (stream->stream_headers != NULL) {
3615 gst_matroska_demux_push_stream_headers (demux, stream);
3617 /* FIXME: perhaps we can just disable and skip this stream then */
3618 GST_ELEMENT_ERROR (demux, STREAM, DECODE, (NULL),
3619 ("Failed to extract stream headers from codec private data"));
3621 stream->send_stream_headers = FALSE;
3624 if (stream->send_dvd_event) {
3625 gst_matroska_demux_push_dvd_clut_change_event (demux, stream);
3626 /* FIXME: should we send this event again after (flushing) seek ? */
3627 stream->send_dvd_event = FALSE;
3633 static GstFlowReturn
3634 gst_matroska_demux_add_mpeg_seq_header (GstElement * element,
3635 GstMatroskaTrackContext * stream, GstBuffer ** buf)
3638 guint seq_header_len;
3639 guint32 header, tmp;
3641 if (stream->codec_state) {
3642 seq_header = stream->codec_state;
3643 seq_header_len = stream->codec_state_size;
3644 } else if (stream->codec_priv) {
3645 seq_header = stream->codec_priv;
3646 seq_header_len = stream->codec_priv_size;
3651 /* Sequence header only needed for keyframes */
3652 if (GST_BUFFER_FLAG_IS_SET (*buf, GST_BUFFER_FLAG_DELTA_UNIT))
3655 if (gst_buffer_get_size (*buf) < 4)
3658 gst_buffer_extract (*buf, 0, &tmp, sizeof (guint32));
3659 header = GUINT32_FROM_BE (tmp);
3661 /* Sequence start code, if not found prepend */
3662 if (header != 0x000001b3) {
3665 GST_DEBUG_OBJECT (element, "Prepending MPEG sequence header");
3667 newbuf = gst_buffer_new_wrapped (g_memdup (seq_header, seq_header_len),
3670 gst_buffer_copy_into (newbuf, *buf, GST_BUFFER_COPY_TIMESTAMPS |
3671 GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_MEMORY, 0,
3672 gst_buffer_get_size (*buf));
3674 gst_buffer_unref (*buf);
3681 static GstFlowReturn
3682 gst_matroska_demux_add_wvpk_header (GstElement * element,
3683 GstMatroskaTrackContext * stream, GstBuffer ** buf)
3685 GstMatroskaTrackAudioContext *audiocontext =
3686 (GstMatroskaTrackAudioContext *) stream;
3687 GstBuffer *newbuf = NULL;
3688 GstMapInfo map, outmap;
3689 guint8 *buf_data, *data;
3697 wvh.version = GST_READ_UINT16_LE (stream->codec_priv);
3700 wvh.total_samples = -1;
3701 wvh.block_index = audiocontext->wvpk_block_index;
3703 if (audiocontext->channels <= 2) {
3704 guint32 block_samples, tmp;
3705 gsize size = gst_buffer_get_size (*buf);
3707 gst_buffer_extract (*buf, 0, &tmp, sizeof (guint32));
3708 block_samples = GUINT32_FROM_LE (tmp);
3709 /* we need to reconstruct the header of the wavpack block */
3711 /* -20 because ck_size is the size of the wavpack block -8
3712 * and lace_size is the size of the wavpack block + 12
3713 * (the three guint32 of the header that already are in the buffer) */
3714 wvh.ck_size = size + sizeof (Wavpack4Header) - 20;
3716 /* block_samples, flags and crc are already in the buffer */
3717 newbuf = gst_buffer_new_allocate (NULL, sizeof (Wavpack4Header) - 12, NULL);
3719 gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE);
3725 GST_WRITE_UINT32_LE (data + 4, wvh.ck_size);
3726 GST_WRITE_UINT16_LE (data + 8, wvh.version);
3727 GST_WRITE_UINT8 (data + 10, wvh.track_no);
3728 GST_WRITE_UINT8 (data + 11, wvh.index_no);
3729 GST_WRITE_UINT32_LE (data + 12, wvh.total_samples);
3730 GST_WRITE_UINT32_LE (data + 16, wvh.block_index);
3731 gst_buffer_unmap (newbuf, &outmap);
3733 /* Append data from buf: */
3734 gst_buffer_copy_into (newbuf, *buf, GST_BUFFER_COPY_TIMESTAMPS |
3735 GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_MEMORY, 0, size);
3737 gst_buffer_unref (*buf);
3739 audiocontext->wvpk_block_index += block_samples;
3741 guint8 *outdata = NULL;
3743 gsize buf_size, size, out_size = 0;
3744 guint32 block_samples, flags, crc, blocksize;
3746 gst_buffer_map (*buf, &map, GST_MAP_READ);
3747 buf_data = map.data;
3748 buf_size = map.size;
3751 GST_ERROR_OBJECT (element, "Too small wavpack buffer");
3752 gst_buffer_unmap (*buf, &map);
3753 return GST_FLOW_ERROR;
3759 block_samples = GST_READ_UINT32_LE (data);
3764 flags = GST_READ_UINT32_LE (data);
3767 crc = GST_READ_UINT32_LE (data);
3770 blocksize = GST_READ_UINT32_LE (data);
3774 if (blocksize == 0 || size < blocksize)
3777 g_assert ((newbuf == NULL) == (outdata == NULL));
3779 if (newbuf == NULL) {
3780 out_size = sizeof (Wavpack4Header) + blocksize;
3781 newbuf = gst_buffer_new_allocate (NULL, out_size, NULL);
3783 gst_buffer_copy_into (newbuf, *buf,
3784 GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS, 0, -1);
3787 gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE);
3788 outdata = outmap.data;
3790 gst_buffer_unmap (newbuf, &outmap);
3791 out_size += sizeof (Wavpack4Header) + blocksize;
3792 gst_buffer_set_size (newbuf, out_size);
3793 gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE);
3794 outdata = outmap.data;
3797 outdata[outpos] = 'w';
3798 outdata[outpos + 1] = 'v';
3799 outdata[outpos + 2] = 'p';
3800 outdata[outpos + 3] = 'k';
3803 GST_WRITE_UINT32_LE (outdata + outpos,
3804 blocksize + sizeof (Wavpack4Header) - 8);
3805 GST_WRITE_UINT16_LE (outdata + outpos + 4, wvh.version);
3806 GST_WRITE_UINT8 (outdata + outpos + 6, wvh.track_no);
3807 GST_WRITE_UINT8 (outdata + outpos + 7, wvh.index_no);
3808 GST_WRITE_UINT32_LE (outdata + outpos + 8, wvh.total_samples);
3809 GST_WRITE_UINT32_LE (outdata + outpos + 12, wvh.block_index);
3810 GST_WRITE_UINT32_LE (outdata + outpos + 16, block_samples);
3811 GST_WRITE_UINT32_LE (outdata + outpos + 20, flags);
3812 GST_WRITE_UINT32_LE (outdata + outpos + 24, crc);
3815 memmove (outdata + outpos, data, blocksize);
3816 outpos += blocksize;
3820 gst_buffer_unmap (*buf, &map);
3821 gst_buffer_unref (*buf);
3824 gst_buffer_unmap (newbuf, &outmap);
3827 audiocontext->wvpk_block_index += block_samples;
3833 static GstFlowReturn
3834 gst_matroska_demux_add_prores_header (GstElement * element,
3835 GstMatroskaTrackContext * stream, GstBuffer ** buf)
3837 GstBuffer *newbuf = gst_buffer_new_allocate (NULL, 8, NULL);
3841 if (!gst_buffer_map (newbuf, &map, GST_MAP_WRITE)) {
3842 GST_ERROR ("Failed to map newly allocated buffer");
3843 return GST_FLOW_ERROR;
3846 frame_size = gst_buffer_get_size (*buf);
3848 GST_WRITE_UINT32_BE (map.data, frame_size);
3854 gst_buffer_unmap (newbuf, &map);
3855 *buf = gst_buffer_append (newbuf, *buf);
3860 /* @text must be null-terminated */
3862 gst_matroska_demux_subtitle_chunk_has_tag (GstElement * element,
3867 g_return_val_if_fail (text != NULL, FALSE);
3869 /* yes, this might all lead to false positives ... */
3870 tag = (gchar *) text;
3871 while ((tag = strchr (tag, '<'))) {
3873 if (*tag != '\0' && *(tag + 1) == '>') {
3874 /* some common convenience ones */
3875 /* maybe any character will do here ? */
3888 if (strstr (text, "<span"))
3894 static GstFlowReturn
3895 gst_matroska_demux_check_subtitle_buffer (GstElement * element,
3896 GstMatroskaTrackContext * stream, GstBuffer ** buf)
3898 GstMatroskaTrackSubtitleContext *sub_stream;
3899 const gchar *encoding;
3904 gboolean needs_unmap = TRUE;
3906 sub_stream = (GstMatroskaTrackSubtitleContext *) stream;
3908 if (!gst_buffer_get_size (*buf) || !gst_buffer_map (*buf, &map, GST_MAP_READ))
3911 /* The subtitle buffer we push out should not include a NUL terminator as
3912 * part of the data. */
3913 if (map.data[map.size - 1] == '\0') {
3914 gst_buffer_set_size (*buf, map.size - 1);
3915 gst_buffer_unmap (*buf, &map);
3916 gst_buffer_map (*buf, &map, GST_MAP_READ);
3919 if (!sub_stream->invalid_utf8) {
3920 if (g_utf8_validate ((gchar *) map.data, map.size, NULL)) {
3923 GST_WARNING_OBJECT (element, "subtitle stream %" G_GUINT64_FORMAT
3924 " is not valid UTF-8, this is broken according to the matroska"
3925 " specification", stream->num);
3926 sub_stream->invalid_utf8 = TRUE;
3929 /* file with broken non-UTF8 subtitle, do the best we can do to fix it */
3930 encoding = g_getenv ("GST_SUBTITLE_ENCODING");
3931 if (encoding == NULL || *encoding == '\0') {
3932 /* if local encoding is UTF-8 and no encoding specified
3933 * via the environment variable, assume ISO-8859-15 */
3934 if (g_get_charset (&encoding)) {
3935 encoding = "ISO-8859-15";
3940 g_convert_with_fallback ((gchar *) map.data, map.size, "UTF-8", encoding,
3941 (char *) "*", NULL, NULL, &err);
3944 GST_LOG_OBJECT (element, "could not convert string from '%s' to UTF-8: %s",
3945 encoding, err->message);
3949 /* invalid input encoding, fall back to ISO-8859-15 (always succeeds) */
3950 encoding = "ISO-8859-15";
3952 g_convert_with_fallback ((gchar *) map.data, map.size, "UTF-8",
3953 encoding, (char *) "*", NULL, NULL, NULL);
3956 GST_LOG_OBJECT (element, "converted subtitle text from %s to UTF-8 %s",
3957 encoding, (err) ? "(using ISO-8859-15 as fallback)" : "");
3960 utf8 = g_strdup ("invalid subtitle");
3962 newbuf = gst_buffer_new_wrapped (utf8, strlen (utf8));
3963 gst_buffer_unmap (*buf, &map);
3964 gst_buffer_copy_into (newbuf, *buf,
3965 GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_META,
3967 gst_buffer_unref (*buf);
3970 gst_buffer_map (*buf, &map, GST_MAP_READ);
3974 if (sub_stream->check_markup) {
3975 /* caps claim markup text, so we need to escape text,
3976 * except if text is already markup and then needs no further escaping */
3977 sub_stream->seen_markup_tag = sub_stream->seen_markup_tag ||
3978 gst_matroska_demux_subtitle_chunk_has_tag (element, (gchar *) map.data);
3980 if (!sub_stream->seen_markup_tag) {
3981 utf8 = g_markup_escape_text ((gchar *) map.data, map.size);
3983 newbuf = gst_buffer_new_wrapped (utf8, strlen (utf8));
3984 gst_buffer_unmap (*buf, &map);
3985 gst_buffer_copy_into (newbuf, *buf,
3986 GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS |
3987 GST_BUFFER_COPY_META, 0, -1);
3988 gst_buffer_unref (*buf);
3991 needs_unmap = FALSE;
3996 gst_buffer_unmap (*buf, &map);
4001 static GstFlowReturn
4002 gst_matroska_demux_check_aac (GstElement * element,
4003 GstMatroskaTrackContext * stream, GstBuffer ** buf)
4008 gst_buffer_extract (*buf, 0, data, 2);
4009 size = gst_buffer_get_size (*buf);
4011 if (size > 2 && data[0] == 0xff && (data[1] >> 4 == 0x0f)) {
4014 /* tss, ADTS data, remove codec_data
4015 * still assume it is at least parsed */
4016 stream->caps = gst_caps_make_writable (stream->caps);
4017 s = gst_caps_get_structure (stream->caps, 0);
4019 gst_structure_remove_field (s, "codec_data");
4020 gst_pad_set_caps (stream->pad, stream->caps);
4021 GST_DEBUG_OBJECT (element, "ADTS AAC audio data; removing codec-data, "
4022 "new caps: %" GST_PTR_FORMAT, stream->caps);
4025 /* disable subsequent checking */
4026 stream->postprocess_frame = NULL;
4032 gst_matroska_demux_align_buffer (GstMatroskaDemux * demux,
4033 GstBuffer * buffer, gsize alignment)
4037 gst_buffer_map (buffer, &map, GST_MAP_READ);
4039 if (map.size < sizeof (guintptr)) {
4040 gst_buffer_unmap (buffer, &map);
4044 if (((guintptr) map.data) & (alignment - 1)) {
4045 GstBuffer *new_buffer;
4046 GstAllocationParams params = { 0, alignment - 1, 0, 0, };
4048 new_buffer = gst_buffer_new_allocate (NULL,
4049 gst_buffer_get_size (buffer), ¶ms);
4051 /* Copy data "by hand", so ensure alignment is kept: */
4052 gst_buffer_fill (new_buffer, 0, map.data, map.size);
4054 gst_buffer_copy_into (new_buffer, buffer, GST_BUFFER_COPY_METADATA, 0, -1);
4055 GST_DEBUG_OBJECT (demux,
4056 "We want output aligned on %" G_GSIZE_FORMAT ", reallocated",
4059 gst_buffer_unmap (buffer, &map);
4060 gst_buffer_unref (buffer);
4065 gst_buffer_unmap (buffer, &map);
4069 static GstFlowReturn
4070 gst_matroska_demux_parse_blockgroup_or_simpleblock (GstMatroskaDemux * demux,
4071 GstEbmlRead * ebml, guint64 cluster_time, guint64 cluster_offset,
4072 gboolean is_simpleblock)
4074 GstMatroskaTrackContext *stream = NULL;
4075 GstFlowReturn ret = GST_FLOW_OK;
4076 gboolean readblock = FALSE;
4078 guint64 block_duration = -1;
4079 gint64 block_discardpadding = 0;
4080 GstBuffer *buf = NULL;
4082 gint stream_num = -1, n, laces = 0;
4084 gint *lace_size = NULL;
4087 gint64 referenceblock = 0;
4089 GstClockTime buffer_timestamp;
4091 offset = gst_ebml_read_get_offset (ebml);
4093 while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
4094 if (!is_simpleblock) {
4095 if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK) {
4099 id = GST_MATROSKA_ID_SIMPLEBLOCK;
4103 /* one block inside the group. Note, block parsing is one
4104 * of the harder things, so this code is a bit complicated.
4105 * See http://www.matroska.org/ for documentation. */
4106 case GST_MATROSKA_ID_SIMPLEBLOCK:
4107 case GST_MATROSKA_ID_BLOCK:
4113 gst_buffer_unmap (buf, &map);
4114 gst_buffer_unref (buf);
4117 if ((ret = gst_ebml_read_buffer (ebml, &id, &buf)) != GST_FLOW_OK)
4120 gst_buffer_map (buf, &map, GST_MAP_READ);
4124 /* first byte(s): blocknum */
4125 if ((n = gst_matroska_ebmlnum_uint (data, size, &num)) < 0)
4130 /* fetch stream from num */
4131 stream_num = gst_matroska_read_common_stream_from_num (&demux->common,
4133 if (G_UNLIKELY (size < 3)) {
4134 GST_WARNING_OBJECT (demux, "Invalid size %u", size);
4135 /* non-fatal, try next block(group) */
4138 } else if (G_UNLIKELY (stream_num < 0 ||
4139 stream_num >= demux->common.num_streams)) {
4140 /* let's not give up on a stray invalid track number */
4141 GST_WARNING_OBJECT (demux,
4142 "Invalid stream %d for track number %" G_GUINT64_FORMAT
4143 "; ignoring block", stream_num, num);
4147 stream = g_ptr_array_index (demux->common.src, stream_num);
4149 /* time (relative to cluster time) */
4150 time = ((gint16) GST_READ_UINT16_BE (data));
4153 flags = GST_READ_UINT8 (data);
4157 GST_LOG_OBJECT (demux, "time %" G_GUINT64_FORMAT ", flags %d", time,
4160 switch ((flags & 0x06) >> 1) {
4161 case 0x0: /* no lacing */
4163 lace_size = g_new (gint, 1);
4164 lace_size[0] = size;
4167 case 0x1: /* xiph lacing */
4168 case 0x2: /* fixed-size lacing */
4169 case 0x3: /* EBML lacing */
4171 goto invalid_lacing;
4172 laces = GST_READ_UINT8 (data) + 1;
4175 lace_size = g_new0 (gint, laces);
4177 switch ((flags & 0x06) >> 1) {
4178 case 0x1: /* xiph lacing */ {
4179 guint temp, total = 0;
4181 for (n = 0; ret == GST_FLOW_OK && n < laces - 1; n++) {
4184 goto invalid_lacing;
4185 temp = GST_READ_UINT8 (data);
4186 lace_size[n] += temp;
4192 total += lace_size[n];
4194 lace_size[n] = size - total;
4198 case 0x2: /* fixed-size lacing */
4199 for (n = 0; n < laces; n++)
4200 lace_size[n] = size / laces;
4203 case 0x3: /* EBML lacing */ {
4206 if ((n = gst_matroska_ebmlnum_uint (data, size, &num)) < 0)
4210 total = lace_size[0] = num;
4211 for (n = 1; ret == GST_FLOW_OK && n < laces - 1; n++) {
4215 if ((r = gst_matroska_ebmlnum_sint (data, size, &snum)) < 0)
4219 lace_size[n] = lace_size[n - 1] + snum;
4220 total += lace_size[n];
4223 lace_size[n] = size - total;
4230 if (ret != GST_FLOW_OK)
4237 case GST_MATROSKA_ID_BLOCKDURATION:{
4238 ret = gst_ebml_read_uint (ebml, &id, &block_duration);
4239 GST_DEBUG_OBJECT (demux, "BlockDuration: %" G_GUINT64_FORMAT,
4244 case GST_MATROSKA_ID_DISCARDPADDING:{
4245 ret = gst_ebml_read_sint (ebml, &id, &block_discardpadding);
4246 GST_DEBUG_OBJECT (demux, "DiscardPadding: %" GST_STIME_FORMAT,
4247 GST_STIME_ARGS (block_discardpadding));
4251 case GST_MATROSKA_ID_REFERENCEBLOCK:{
4252 ret = gst_ebml_read_sint (ebml, &id, &referenceblock);
4253 GST_DEBUG_OBJECT (demux, "ReferenceBlock: %" G_GINT64_FORMAT,
4258 case GST_MATROSKA_ID_CODECSTATE:{
4260 guint64 data_len = 0;
4263 gst_ebml_read_binary (ebml, &id, &data,
4264 &data_len)) != GST_FLOW_OK)
4267 if (G_UNLIKELY (stream == NULL)) {
4268 GST_WARNING_OBJECT (demux,
4269 "Unexpected CodecState subelement - ignoring");
4273 g_free (stream->codec_state);
4274 stream->codec_state = data;
4275 stream->codec_state_size = data_len;
4277 /* Decode if necessary */
4278 if (stream->encodings && stream->encodings->len > 0
4279 && stream->codec_state && stream->codec_state_size > 0) {
4280 if (!gst_matroska_decode_data (stream->encodings,
4281 &stream->codec_state, &stream->codec_state_size,
4282 GST_MATROSKA_TRACK_ENCODING_SCOPE_CODEC_DATA, TRUE)) {
4283 GST_WARNING_OBJECT (demux, "Decoding codec state failed");
4287 GST_DEBUG_OBJECT (demux, "CodecState of %" G_GSIZE_FORMAT " bytes",
4288 stream->codec_state_size);
4293 ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
4297 case GST_MATROSKA_ID_BLOCKVIRTUAL:
4298 case GST_MATROSKA_ID_BLOCKADDITIONS:
4299 case GST_MATROSKA_ID_REFERENCEPRIORITY:
4300 case GST_MATROSKA_ID_REFERENCEVIRTUAL:
4301 case GST_MATROSKA_ID_SLICES:
4302 GST_DEBUG_OBJECT (demux,
4303 "Skipping BlockGroup subelement 0x%x - ignoring", id);
4304 ret = gst_ebml_read_skip (ebml);
4312 /* reading a number or so could have failed */
4313 if (ret != GST_FLOW_OK)
4316 if (ret == GST_FLOW_OK && readblock) {
4317 gboolean invisible_frame = FALSE;
4318 gboolean delta_unit = FALSE;
4319 guint64 duration = 0;
4320 gint64 lace_time = 0;
4321 GstEvent *protect_event;
4323 stream = g_ptr_array_index (demux->common.src, stream_num);
4325 if (cluster_time != GST_CLOCK_TIME_NONE) {
4326 /* FIXME: What to do with negative timestamps? Give timestamp 0 or -1?
4327 * Drop unless the lace contains timestamp 0? */
4328 if (time < 0 && (-time) > cluster_time) {
4331 if (stream->timecodescale == 1.0)
4332 lace_time = (cluster_time + time) * demux->common.time_scale;
4335 gst_util_guint64_to_gdouble ((cluster_time + time) *
4336 demux->common.time_scale) * stream->timecodescale;
4339 lace_time = GST_CLOCK_TIME_NONE;
4341 /* Send the GST_PROTECTION event */
4342 while ((protect_event = g_queue_pop_head (&stream->protection_event_queue))) {
4343 GST_TRACE_OBJECT (demux, "pushing protection event for stream %d:%s",
4344 stream->index, GST_STR_NULL (stream->name));
4345 gst_pad_push_event (stream->pad, protect_event);
4348 /* need to refresh segment info ASAP */
4349 if (GST_CLOCK_TIME_IS_VALID (lace_time) && demux->need_segment) {
4350 GstSegment *segment = &demux->common.segment;
4352 GstEvent *segment_event;
4354 if (!GST_CLOCK_TIME_IS_VALID (demux->stream_start_time)) {
4355 demux->stream_start_time = lace_time;
4356 GST_DEBUG_OBJECT (demux,
4357 "Setting stream start time to %" GST_TIME_FORMAT,
4358 GST_TIME_ARGS (lace_time));
4360 clace_time = MAX (lace_time, demux->stream_start_time);
4361 if (GST_CLOCK_TIME_IS_VALID (demux->common.segment.position) &&
4362 demux->common.segment.position != 0) {
4363 GST_DEBUG_OBJECT (demux,
4364 "using stored seek position %" GST_TIME_FORMAT,
4365 GST_TIME_ARGS (demux->common.segment.position));
4366 clace_time = demux->common.segment.position;
4367 segment->position = GST_CLOCK_TIME_NONE;
4369 segment->start = clace_time;
4370 segment->stop = GST_CLOCK_TIME_NONE;
4371 segment->time = segment->start - demux->stream_start_time;
4372 segment->position = segment->start - demux->stream_start_time;
4373 GST_DEBUG_OBJECT (demux,
4374 "generated segment starting at %" GST_TIME_FORMAT ": %"
4375 GST_SEGMENT_FORMAT, GST_TIME_ARGS (lace_time), segment);
4376 /* now convey our segment notion downstream */
4377 segment_event = gst_event_new_segment (segment);
4378 if (demux->segment_seqnum)
4379 gst_event_set_seqnum (segment_event, demux->segment_seqnum);
4380 gst_matroska_demux_send_event (demux, segment_event);
4381 demux->need_segment = FALSE;
4382 demux->segment_seqnum = 0;
4385 /* send pending codec data headers for all streams,
4386 * before we perform sync across all streams */
4387 gst_matroska_demux_push_codec_data_all (demux);
4389 if (block_duration != -1) {
4390 if (stream->timecodescale == 1.0)
4391 duration = gst_util_uint64_scale (block_duration,
4392 demux->common.time_scale, 1);
4395 gst_util_gdouble_to_guint64 (gst_util_guint64_to_gdouble
4396 (gst_util_uint64_scale (block_duration, demux->common.time_scale,
4397 1)) * stream->timecodescale);
4398 } else if (stream->default_duration) {
4399 duration = stream->default_duration * laces;
4401 /* else duration is diff between timecode of this and next block */
4403 if (stream->type == GST_MATROSKA_TRACK_TYPE_VIDEO) {
4404 /* For SimpleBlock, look at the keyframe bit in flags. Otherwise,
4405 a ReferenceBlock implies that this is not a keyframe. In either
4406 case, it only makes sense for video streams. */
4407 if ((is_simpleblock && !(flags & 0x80)) || referenceblock) {
4409 invisible_frame = ((flags & 0x08)) &&
4410 (!strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VP8) ||
4411 !strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VP9) ||
4412 !strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_VIDEO_AV1));
4415 /* If we're doing a keyframe-only trickmode, only push keyframes on video
4418 && demux->common.segment.
4419 flags & GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS) {
4420 GST_LOG_OBJECT (demux, "Skipping non-keyframe on stream %d",
4427 for (n = 0; n < laces; n++) {
4430 if (G_UNLIKELY (lace_size[n] > size)) {
4431 GST_WARNING_OBJECT (demux, "Invalid lace size");
4435 /* QoS for video track with an index. the assumption is that
4436 index entries point to keyframes, but if that is not true we
4437 will instad skip until the next keyframe. */
4438 if (GST_CLOCK_TIME_IS_VALID (lace_time) &&
4439 stream->type == GST_MATROSKA_TRACK_TYPE_VIDEO &&
4440 stream->index_table && demux->common.segment.rate > 0.0) {
4441 GstMatroskaTrackVideoContext *videocontext =
4442 (GstMatroskaTrackVideoContext *) stream;
4443 GstClockTime earliest_time;
4444 GstClockTime earliest_stream_time;
4446 GST_OBJECT_LOCK (demux);
4447 earliest_time = videocontext->earliest_time;
4448 GST_OBJECT_UNLOCK (demux);
4449 earliest_stream_time =
4450 gst_segment_position_from_running_time (&demux->common.segment,
4451 GST_FORMAT_TIME, earliest_time);
4453 if (GST_CLOCK_TIME_IS_VALID (lace_time) &&
4454 GST_CLOCK_TIME_IS_VALID (earliest_stream_time) &&
4455 lace_time <= earliest_stream_time) {
4456 /* find index entry (keyframe) <= earliest_stream_time */
4457 GstMatroskaIndex *entry =
4458 gst_util_array_binary_search (stream->index_table->data,
4459 stream->index_table->len, sizeof (GstMatroskaIndex),
4460 (GCompareDataFunc) gst_matroska_index_seek_find,
4461 GST_SEARCH_MODE_BEFORE, &earliest_stream_time, NULL);
4463 /* if that entry (keyframe) is after the current the current
4464 buffer, we can skip pushing (and thus decoding) all
4465 buffers until that keyframe. */
4466 if (entry && GST_CLOCK_TIME_IS_VALID (entry->time) &&
4467 entry->time > lace_time) {
4468 GST_LOG_OBJECT (demux, "Skipping lace before late keyframe");
4469 stream->set_discont = TRUE;
4475 sub = gst_buffer_copy_region (buf, GST_BUFFER_COPY_ALL,
4476 gst_buffer_get_size (buf) - size, lace_size[n]);
4477 GST_DEBUG_OBJECT (demux, "created subbuffer %p", sub);
4480 GST_BUFFER_FLAG_SET (sub, GST_BUFFER_FLAG_DELTA_UNIT);
4482 GST_BUFFER_FLAG_UNSET (sub, GST_BUFFER_FLAG_DELTA_UNIT);
4484 if (invisible_frame)
4485 GST_BUFFER_FLAG_SET (sub, GST_BUFFER_FLAG_DECODE_ONLY);
4487 if (stream->encodings != NULL && stream->encodings->len > 0)
4488 sub = gst_matroska_decode_buffer (stream, sub);
4491 GST_WARNING_OBJECT (demux, "Decoding buffer failed");
4495 if (!stream->dts_only) {
4496 GST_BUFFER_PTS (sub) = lace_time;
4498 GST_BUFFER_DTS (sub) = lace_time;
4499 if (stream->intra_only)
4500 GST_BUFFER_PTS (sub) = lace_time;
4503 buffer_timestamp = gst_matroska_track_get_buffer_timestamp (stream, sub);
4505 if (GST_CLOCK_TIME_IS_VALID (lace_time)) {
4506 GstClockTime last_stop_end;
4508 /* Check if this stream is after segment stop */
4509 if (GST_CLOCK_TIME_IS_VALID (demux->common.segment.stop) &&
4510 lace_time >= demux->common.segment.stop) {
4511 GST_DEBUG_OBJECT (demux,
4512 "Stream %d after segment stop %" GST_TIME_FORMAT, stream->index,
4513 GST_TIME_ARGS (demux->common.segment.stop));
4514 gst_buffer_unref (sub);
4517 if (offset >= stream->to_offset
4518 || (GST_CLOCK_TIME_IS_VALID (demux->to_time)
4519 && lace_time > demux->to_time)) {
4520 GST_DEBUG_OBJECT (demux, "Stream %d after playback section",
4522 gst_buffer_unref (sub);
4526 /* handle gaps, e.g. non-zero start-time, or an cue index entry
4527 * that landed us with timestamps not quite intended */
4528 GST_OBJECT_LOCK (demux);
4529 if (demux->max_gap_time &&
4530 GST_CLOCK_TIME_IS_VALID (demux->last_stop_end) &&
4531 demux->common.segment.rate > 0.0) {
4532 GstClockTimeDiff diff;
4534 /* only send segments with increasing start times,
4535 * otherwise if these go back and forth downstream (sinks) increase
4536 * accumulated time and running_time */
4537 diff = GST_CLOCK_DIFF (demux->last_stop_end, lace_time);
4538 if (diff > 0 && diff > demux->max_gap_time
4539 && lace_time > demux->common.segment.start
4540 && (!GST_CLOCK_TIME_IS_VALID (demux->common.segment.stop)
4541 || lace_time < demux->common.segment.stop)) {
4543 GST_DEBUG_OBJECT (demux,
4544 "Gap of %" G_GINT64_FORMAT " ns detected in"
4545 "stream %d (%" GST_TIME_FORMAT " -> %" GST_TIME_FORMAT "). "
4546 "Sending updated SEGMENT events", diff,
4547 stream->index, GST_TIME_ARGS (stream->pos),
4548 GST_TIME_ARGS (lace_time));
4550 event = gst_event_new_gap (demux->last_stop_end, diff);
4551 GST_OBJECT_UNLOCK (demux);
4552 gst_pad_push_event (stream->pad, event);
4553 GST_OBJECT_LOCK (demux);
4557 if (!GST_CLOCK_TIME_IS_VALID (demux->common.segment.position)
4558 || demux->common.segment.position < lace_time) {
4559 demux->common.segment.position = lace_time;
4561 GST_OBJECT_UNLOCK (demux);
4563 last_stop_end = lace_time;
4565 GST_BUFFER_DURATION (sub) = duration / laces;
4566 last_stop_end += GST_BUFFER_DURATION (sub);
4569 if (!GST_CLOCK_TIME_IS_VALID (demux->last_stop_end) ||
4570 demux->last_stop_end < last_stop_end)
4571 demux->last_stop_end = last_stop_end;
4573 GST_OBJECT_LOCK (demux);
4574 if (demux->common.segment.duration == -1 ||
4575 demux->stream_start_time + demux->common.segment.duration <
4577 demux->common.segment.duration =
4578 last_stop_end - demux->stream_start_time;
4579 GST_OBJECT_UNLOCK (demux);
4580 if (!demux->invalid_duration) {
4581 gst_element_post_message (GST_ELEMENT_CAST (demux),
4582 gst_message_new_duration_changed (GST_OBJECT_CAST (demux)));
4583 demux->invalid_duration = TRUE;
4586 GST_OBJECT_UNLOCK (demux);
4590 stream->pos = lace_time;
4592 gst_matroska_demux_sync_streams (demux);
4594 if (stream->set_discont) {
4595 GST_DEBUG_OBJECT (demux, "marking DISCONT");
4596 GST_BUFFER_FLAG_SET (sub, GST_BUFFER_FLAG_DISCONT);
4597 stream->set_discont = FALSE;
4599 GST_BUFFER_FLAG_UNSET (sub, GST_BUFFER_FLAG_DISCONT);
4602 /* reverse playback book-keeping */
4603 if (!GST_CLOCK_TIME_IS_VALID (stream->from_time))
4604 stream->from_time = lace_time;
4605 if (stream->from_offset == -1)
4606 stream->from_offset = offset;
4608 GST_DEBUG_OBJECT (demux,
4609 "Pushing lace %d, data of size %" G_GSIZE_FORMAT
4610 " for stream %d, time=%" GST_TIME_FORMAT " and duration=%"
4611 GST_TIME_FORMAT, n, gst_buffer_get_size (sub), stream_num,
4612 GST_TIME_ARGS (buffer_timestamp),
4613 GST_TIME_ARGS (GST_BUFFER_DURATION (sub)));
4616 if (demux->common.element_index) {
4617 if (stream->index_writer_id == -1)
4618 gst_index_get_writer_id (demux->common.element_index,
4619 GST_OBJECT (stream->pad), &stream->index_writer_id);
4621 GST_LOG_OBJECT (demux, "adding association %" GST_TIME_FORMAT "-> %"
4622 G_GUINT64_FORMAT " for writer id %d",
4623 GST_TIME_ARGS (buffer_timestamp), cluster_offset,
4624 stream->index_writer_id);
4625 gst_index_add_association (demux->common.element_index,
4626 stream->index_writer_id, GST_BUFFER_FLAG_IS_SET (sub,
4627 GST_BUFFER_FLAG_DELTA_UNIT) ? 0 : GST_ASSOCIATION_FLAG_KEY_UNIT,
4628 GST_FORMAT_TIME, buffer_timestamp, GST_FORMAT_BYTES, cluster_offset,
4633 /* Postprocess the buffers depending on the codec used */
4634 if (stream->postprocess_frame) {
4635 GST_LOG_OBJECT (demux, "running post process");
4636 ret = stream->postprocess_frame (GST_ELEMENT (demux), stream, &sub);
4639 /* At this point, we have a sub-buffer pointing at data within a larger
4640 buffer. This data might not be aligned with anything. If the data is
4641 raw samples though, we want it aligned to the raw type (eg, 4 bytes
4642 for 32 bit samples, etc), or bad things will happen downstream as
4643 elements typically assume minimal alignment.
4644 Therefore, create an aligned copy if necessary. */
4645 sub = gst_matroska_demux_align_buffer (demux, sub, stream->alignment);
4647 if (!strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_AUDIO_OPUS)) {
4648 guint64 start_clip = 0, end_clip = 0;
4650 /* Codec delay is part of the timestamps */
4651 if (GST_BUFFER_PTS_IS_VALID (sub) && stream->codec_delay) {
4652 if (GST_BUFFER_PTS (sub) > stream->codec_delay) {
4653 GST_BUFFER_PTS (sub) -= stream->codec_delay;
4655 GST_BUFFER_PTS (sub) = 0;
4657 /* Opus GstAudioClippingMeta units are scaled by 48000/sample_rate.
4658 That is, if a Opus track has audio encoded at 24000 Hz and 132
4659 samples need to be clipped, GstAudioClippingMeta.start will be
4660 set to 264. (This is also the case for buffer offsets.)
4661 Opus sample rates are always divisors of 48000 Hz, which is the
4662 maximum allowed sample rate. */
4664 gst_util_uint64_scale_round (stream->codec_delay, 48000,
4667 if (GST_BUFFER_DURATION_IS_VALID (sub)) {
4668 if (GST_BUFFER_DURATION (sub) > stream->codec_delay)
4669 GST_BUFFER_DURATION (sub) -= stream->codec_delay;
4671 GST_BUFFER_DURATION (sub) = 0;
4676 if (block_discardpadding) {
4678 gst_util_uint64_scale_round (block_discardpadding, 48000,
4682 if (start_clip || end_clip) {
4683 gst_buffer_add_audio_clipping_meta (sub, GST_FORMAT_DEFAULT,
4684 start_clip, end_clip);
4688 if (GST_BUFFER_PTS_IS_VALID (sub)) {
4689 stream->pos = GST_BUFFER_PTS (sub);
4690 if (GST_BUFFER_DURATION_IS_VALID (sub))
4691 stream->pos += GST_BUFFER_DURATION (sub);
4692 } else if (GST_BUFFER_DTS_IS_VALID (sub)) {
4693 stream->pos = GST_BUFFER_DTS (sub);
4694 if (GST_BUFFER_DURATION_IS_VALID (sub))
4695 stream->pos += GST_BUFFER_DURATION (sub);
4698 ret = gst_pad_push (stream->pad, sub);
4700 if (demux->common.segment.rate < 0) {
4701 if (lace_time > demux->common.segment.stop && ret == GST_FLOW_EOS) {
4702 /* In reverse playback we can get a GST_FLOW_EOS when
4703 * we are at the end of the segment, so we just need to jump
4704 * back to the previous section. */
4705 GST_DEBUG_OBJECT (demux, "downstream has reached end of segment");
4710 ret = gst_flow_combiner_update_pad_flow (demux->flowcombiner,
4714 size -= lace_size[n];
4715 if (lace_time != GST_CLOCK_TIME_NONE && duration)
4716 lace_time += duration / laces;
4718 lace_time = GST_CLOCK_TIME_NONE;
4724 gst_buffer_unmap (buf, &map);
4725 gst_buffer_unref (buf);
4737 ret = gst_flow_combiner_update_pad_flow (demux->flowcombiner, stream->pad,
4743 GST_ELEMENT_WARNING (demux, STREAM, DEMUX, (NULL), ("Invalid lacing size"));
4744 /* non-fatal, try next block(group) */
4750 GST_ELEMENT_WARNING (demux, STREAM, DEMUX, (NULL), ("Data error"));
4751 /* non-fatal, try next block(group) */
4757 /* return FALSE if block(group) should be skipped (due to a seek) */
4758 static inline gboolean
4759 gst_matroska_demux_seek_block (GstMatroskaDemux * demux)
4761 if (G_UNLIKELY (demux->seek_block)) {
4762 if (!(--demux->seek_block)) {
4765 GST_LOG_OBJECT (demux, "should skip block due to seek");
4773 static GstFlowReturn
4774 gst_matroska_demux_parse_contents_seekentry (GstMatroskaDemux * demux,
4778 guint64 seek_pos = (guint64) - 1;
4779 guint32 seek_id = 0;
4782 DEBUG_ELEMENT_START (demux, ebml, "Seek");
4784 if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
4785 DEBUG_ELEMENT_STOP (demux, ebml, "Seek", ret);
4789 while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
4790 if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
4794 case GST_MATROSKA_ID_SEEKID:
4798 if ((ret = gst_ebml_read_uint (ebml, &id, &t)) != GST_FLOW_OK)
4801 GST_DEBUG_OBJECT (demux, "SeekID: %" G_GUINT64_FORMAT, t);
4806 case GST_MATROSKA_ID_SEEKPOSITION:
4810 if ((ret = gst_ebml_read_uint (ebml, &id, &t)) != GST_FLOW_OK)
4813 if (t > G_MAXINT64) {
4814 GST_WARNING_OBJECT (demux,
4815 "Too large SeekPosition %" G_GUINT64_FORMAT, t);
4819 GST_DEBUG_OBJECT (demux, "SeekPosition: %" G_GUINT64_FORMAT, t);
4825 ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
4831 if (ret != GST_FLOW_OK && ret != GST_FLOW_EOS)
4834 if (!seek_id || seek_pos == (guint64) - 1) {
4835 GST_WARNING_OBJECT (demux, "Incomplete seekhead entry (0x%x/%"
4836 G_GUINT64_FORMAT ")", seek_id, seek_pos);
4841 case GST_MATROSKA_ID_SEEKHEAD:
4844 case GST_MATROSKA_ID_CUES:
4845 case GST_MATROSKA_ID_TAGS:
4846 case GST_MATROSKA_ID_TRACKS:
4847 case GST_MATROSKA_ID_SEGMENTINFO:
4848 case GST_MATROSKA_ID_ATTACHMENTS:
4849 case GST_MATROSKA_ID_CHAPTERS:
4851 guint64 before_pos, length;
4855 length = gst_matroska_read_common_get_length (&demux->common);
4856 before_pos = demux->common.offset;
4858 if (length == (guint64) - 1) {
4859 GST_DEBUG_OBJECT (demux, "no upstream length, skipping SeakHead entry");
4863 /* check for validity */
4864 if (seek_pos + demux->common.ebml_segment_start + 12 >= length) {
4865 GST_WARNING_OBJECT (demux,
4866 "SeekHead reference lies outside file!" " (%"
4867 G_GUINT64_FORMAT "+%" G_GUINT64_FORMAT "+12 >= %"
4868 G_GUINT64_FORMAT ")", seek_pos, demux->common.ebml_segment_start,
4873 /* only pick up index location when streaming */
4874 if (demux->streaming) {
4875 if (seek_id == GST_MATROSKA_ID_CUES) {
4876 demux->index_offset = seek_pos + demux->common.ebml_segment_start;
4877 GST_DEBUG_OBJECT (demux, "Cues located at offset %" G_GUINT64_FORMAT,
4878 demux->index_offset);
4884 demux->common.offset = seek_pos + demux->common.ebml_segment_start;
4887 if ((ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
4888 GST_ELEMENT_CAST (demux), &id, &length, &needed)) !=
4892 if (id != seek_id) {
4893 GST_WARNING_OBJECT (demux,
4894 "We looked for ID=0x%x but got ID=0x%x (pos=%" G_GUINT64_FORMAT ")",
4895 seek_id, id, seek_pos + demux->common.ebml_segment_start);
4898 ret = gst_matroska_demux_parse_id (demux, id, length, needed);
4903 demux->common.offset = before_pos;
4907 case GST_MATROSKA_ID_CLUSTER:
4909 guint64 pos = seek_pos + demux->common.ebml_segment_start;
4911 GST_LOG_OBJECT (demux, "Cluster position");
4912 if (G_UNLIKELY (!demux->clusters))
4913 demux->clusters = g_array_sized_new (TRUE, TRUE, sizeof (guint64), 100);
4914 g_array_append_val (demux->clusters, pos);
4919 GST_DEBUG_OBJECT (demux, "Ignoring Seek entry for ID=0x%x", seek_id);
4922 DEBUG_ELEMENT_STOP (demux, ebml, "Seek", ret);
4927 static GstFlowReturn
4928 gst_matroska_demux_parse_contents (GstMatroskaDemux * demux, GstEbmlRead * ebml)
4930 GstFlowReturn ret = GST_FLOW_OK;
4933 DEBUG_ELEMENT_START (demux, ebml, "SeekHead");
4935 if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
4936 DEBUG_ELEMENT_STOP (demux, ebml, "SeekHead", ret);
4940 while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
4941 if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
4945 case GST_MATROSKA_ID_SEEKENTRY:
4947 ret = gst_matroska_demux_parse_contents_seekentry (demux, ebml);
4948 /* Ignore EOS and errors here */
4949 if (ret != GST_FLOW_OK) {
4950 GST_DEBUG_OBJECT (demux, "Ignoring %s", gst_flow_get_name (ret));
4957 ret = gst_matroska_read_common_parse_skip (&demux->common,
4958 ebml, "SeekHead", id);
4963 DEBUG_ELEMENT_STOP (demux, ebml, "SeekHead", ret);
4965 /* Sort clusters by position for easier searching */
4966 if (demux->clusters)
4967 g_array_sort (demux->clusters, (GCompareFunc) gst_matroska_cluster_compare);
4972 #define GST_FLOW_OVERFLOW GST_FLOW_CUSTOM_ERROR
4974 #define MAX_BLOCK_SIZE (15 * 1024 * 1024)
4976 static inline GstFlowReturn
4977 gst_matroska_demux_check_read_size (GstMatroskaDemux * demux, guint64 bytes)
4979 if (G_UNLIKELY (bytes > MAX_BLOCK_SIZE)) {
4980 /* only a few blocks are expected/allowed to be large,
4981 * and will be recursed into, whereas others will be read and must fit */
4982 if (demux->streaming) {
4983 /* fatal in streaming case, as we can't step over easily */
4984 GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL),
4985 ("reading large block of size %" G_GUINT64_FORMAT " not supported; "
4986 "file might be corrupt.", bytes));
4987 return GST_FLOW_ERROR;
4989 /* indicate higher level to quietly give up */
4990 GST_DEBUG_OBJECT (demux,
4991 "too large block of size %" G_GUINT64_FORMAT, bytes);
4992 return GST_FLOW_ERROR;
4999 /* returns TRUE if we truely are in error state, and should give up */
5000 static inline GstFlowReturn
5001 gst_matroska_demux_check_parse_error (GstMatroskaDemux * demux)
5003 if (!demux->streaming && demux->next_cluster_offset > 0) {
5004 /* just repositioning to where next cluster should be and try from there */
5005 GST_WARNING_OBJECT (demux, "parse error, trying next cluster expected at %"
5006 G_GUINT64_FORMAT, demux->next_cluster_offset);
5007 demux->common.offset = demux->next_cluster_offset;
5008 demux->next_cluster_offset = 0;
5014 /* sigh, one last attempt above and beyond call of duty ...;
5015 * search for cluster mark following current pos */
5016 pos = demux->common.offset;
5017 GST_WARNING_OBJECT (demux, "parse error, looking for next cluster");
5018 if ((ret = gst_matroska_demux_search_cluster (demux, &pos, TRUE)) !=
5020 /* did not work, give up */
5023 GST_DEBUG_OBJECT (demux, "... found at %" G_GUINT64_FORMAT, pos);
5024 /* try that position */
5025 demux->common.offset = pos;
5031 static inline GstFlowReturn
5032 gst_matroska_demux_flush (GstMatroskaDemux * demux, guint flush)
5034 GST_LOG_OBJECT (demux, "skipping %d bytes", flush);
5035 demux->common.offset += flush;
5036 if (demux->streaming) {
5039 /* hard to skip large blocks when streaming */
5040 ret = gst_matroska_demux_check_read_size (demux, flush);
5041 if (ret != GST_FLOW_OK)
5043 if (flush <= gst_adapter_available (demux->common.adapter))
5044 gst_adapter_flush (demux->common.adapter, flush);
5046 return GST_FLOW_EOS;
5051 /* initializes @ebml with @bytes from input stream at current offset.
5052 * Returns EOS if insufficient available,
5053 * ERROR if too much was attempted to read. */
5054 static inline GstFlowReturn
5055 gst_matroska_demux_take (GstMatroskaDemux * demux, guint64 bytes,
5058 GstBuffer *buffer = NULL;
5059 GstFlowReturn ret = GST_FLOW_OK;
5061 GST_LOG_OBJECT (demux, "taking %" G_GUINT64_FORMAT " bytes for parsing",
5063 ret = gst_matroska_demux_check_read_size (demux, bytes);
5064 if (G_UNLIKELY (ret != GST_FLOW_OK)) {
5065 if (!demux->streaming) {
5066 /* in pull mode, we can skip */
5067 if ((ret = gst_matroska_demux_flush (demux, bytes)) == GST_FLOW_OK)
5068 ret = GST_FLOW_OVERFLOW;
5070 /* otherwise fatal */
5071 ret = GST_FLOW_ERROR;
5075 if (demux->streaming) {
5076 if (gst_adapter_available (demux->common.adapter) >= bytes)
5077 buffer = gst_adapter_take_buffer (demux->common.adapter, bytes);
5081 ret = gst_matroska_read_common_peek_bytes (&demux->common,
5082 demux->common.offset, bytes, &buffer, NULL);
5083 if (G_LIKELY (buffer)) {
5084 gst_ebml_read_init (ebml, GST_ELEMENT_CAST (demux), buffer,
5085 demux->common.offset);
5086 demux->common.offset += bytes;
5093 gst_matroska_demux_check_seekability (GstMatroskaDemux * demux)
5096 gboolean seekable = FALSE;
5097 gint64 start = -1, stop = -1;
5099 query = gst_query_new_seeking (GST_FORMAT_BYTES);
5100 if (!gst_pad_peer_query (demux->common.sinkpad, query)) {
5101 GST_DEBUG_OBJECT (demux, "seeking query failed");
5105 gst_query_parse_seeking (query, NULL, &seekable, &start, &stop);
5107 /* try harder to query upstream size if we didn't get it the first time */
5108 if (seekable && stop == -1) {
5109 GST_DEBUG_OBJECT (demux, "doing duration query to fix up unset stop");
5110 gst_pad_peer_query_duration (demux->common.sinkpad, GST_FORMAT_BYTES,
5114 /* if upstream doesn't know the size, it's likely that it's not seekable in
5115 * practice even if it technically may be seekable */
5116 if (seekable && (start != 0 || stop <= start)) {
5117 GST_DEBUG_OBJECT (demux, "seekable but unknown start/stop -> disable");
5122 GST_INFO_OBJECT (demux, "seekable: %d (%" G_GUINT64_FORMAT " - %"
5123 G_GUINT64_FORMAT ")", seekable, start, stop);
5124 demux->seekable = seekable;
5126 gst_query_unref (query);
5129 static GstFlowReturn
5130 gst_matroska_demux_find_tracks (GstMatroskaDemux * demux)
5136 GstFlowReturn ret = GST_FLOW_OK;
5138 GST_WARNING_OBJECT (demux,
5139 "Found Cluster element before Tracks, searching Tracks");
5142 before_pos = demux->common.offset;
5144 /* Search Tracks element */
5146 ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
5147 GST_ELEMENT_CAST (demux), &id, &length, &needed);
5148 if (ret != GST_FLOW_OK)
5151 if (id != GST_MATROSKA_ID_TRACKS) {
5152 /* we may be skipping large cluster here, so forego size check etc */
5153 /* ... but we can't skip undefined size; force error */
5154 if (length == G_MAXUINT64) {
5155 ret = gst_matroska_demux_check_read_size (demux, length);
5158 demux->common.offset += needed;
5159 demux->common.offset += length;
5164 /* will lead to track parsing ... */
5165 ret = gst_matroska_demux_parse_id (demux, id, length, needed);
5170 demux->common.offset = before_pos;
5175 #define GST_READ_CHECK(stmt) \
5177 if (G_UNLIKELY ((ret = (stmt)) != GST_FLOW_OK)) { \
5178 if (ret == GST_FLOW_OVERFLOW) { \
5179 ret = GST_FLOW_OK; \
5185 static GstFlowReturn
5186 gst_matroska_demux_parse_id (GstMatroskaDemux * demux, guint32 id,
5187 guint64 length, guint needed)
5189 GstEbmlRead ebml = { 0, };
5190 GstFlowReturn ret = GST_FLOW_OK;
5193 GST_LOG_OBJECT (demux, "Parsing Element id 0x%x, "
5194 "size %" G_GUINT64_FORMAT ", prefix %d", id, length, needed);
5196 /* if we plan to read and parse this element, we need prefix (id + length)
5197 * and the contents */
5198 /* mind about overflow wrap-around when dealing with undefined size */
5200 if (G_LIKELY (length != G_MAXUINT64))
5203 switch (demux->common.state) {
5204 case GST_MATROSKA_READ_STATE_START:
5206 case GST_EBML_ID_HEADER:
5207 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5208 ret = gst_matroska_read_common_parse_header (&demux->common, &ebml);
5209 if (ret != GST_FLOW_OK)
5211 demux->common.state = GST_MATROSKA_READ_STATE_SEGMENT;
5212 gst_matroska_demux_check_seekability (demux);
5215 goto invalid_header;
5219 case GST_MATROSKA_READ_STATE_SEGMENT:
5221 case GST_MATROSKA_ID_SEGMENT:
5222 /* eat segment prefix */
5223 GST_READ_CHECK (gst_matroska_demux_flush (demux, needed));
5224 GST_DEBUG_OBJECT (demux,
5225 "Found Segment start at offset %" G_GUINT64_FORMAT " with size %"
5226 G_GUINT64_FORMAT, demux->common.offset, length);
5227 /* seeks are from the beginning of the segment,
5228 * after the segment ID/length */
5229 demux->common.ebml_segment_start = demux->common.offset;
5231 length = G_MAXUINT64;
5232 demux->common.ebml_segment_length = length;
5233 demux->common.state = GST_MATROSKA_READ_STATE_HEADER;
5236 GST_WARNING_OBJECT (demux,
5237 "Expected a Segment ID (0x%x), but received 0x%x!",
5238 GST_MATROSKA_ID_SEGMENT, id);
5239 GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
5243 case GST_MATROSKA_READ_STATE_SCANNING:
5244 if (id != GST_MATROSKA_ID_CLUSTER &&
5245 id != GST_MATROSKA_ID_PREVSIZE &&
5246 id != GST_MATROSKA_ID_CLUSTERTIMECODE) {
5247 if (demux->common.start_resync_offset != -1) {
5248 /* we need to skip byte per byte if we are scanning for a new cluster
5249 * after invalid data is found
5255 if (demux->common.start_resync_offset != -1) {
5256 GST_LOG_OBJECT (demux, "Resync done, new cluster found!");
5257 demux->common.start_resync_offset = -1;
5258 demux->common.state = demux->common.state_to_restore;
5262 case GST_MATROSKA_READ_STATE_HEADER:
5263 case GST_MATROSKA_READ_STATE_DATA:
5264 case GST_MATROSKA_READ_STATE_SEEK:
5266 case GST_EBML_ID_HEADER:
5267 GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
5268 demux->common.state = GST_MATROSKA_READ_STATE_SEGMENT;
5269 gst_matroska_demux_check_seekability (demux);
5271 case GST_MATROSKA_ID_SEGMENTINFO:
5272 if (!demux->common.segmentinfo_parsed) {
5273 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5274 ret = gst_matroska_read_common_parse_info (&demux->common,
5275 GST_ELEMENT_CAST (demux), &ebml);
5276 if (ret == GST_FLOW_OK)
5277 gst_matroska_demux_send_tags (demux);
5279 GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
5282 case GST_MATROSKA_ID_TRACKS:
5283 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5284 if (!demux->tracks_parsed) {
5285 ret = gst_matroska_demux_parse_tracks (demux, &ebml);
5287 ret = gst_matroska_demux_update_tracks (demux, &ebml);
5290 case GST_MATROSKA_ID_CLUSTER:
5291 if (G_UNLIKELY (!demux->tracks_parsed)) {
5292 if (demux->streaming) {
5293 GST_DEBUG_OBJECT (demux, "Cluster before Track");
5294 goto not_streamable;
5296 ret = gst_matroska_demux_find_tracks (demux);
5297 if (!demux->tracks_parsed)
5301 if (demux->common.state == GST_MATROSKA_READ_STATE_HEADER) {
5302 demux->common.state = GST_MATROSKA_READ_STATE_DATA;
5303 demux->first_cluster_offset = demux->common.offset;
5305 if (!demux->streaming &&
5306 !GST_CLOCK_TIME_IS_VALID (demux->common.segment.duration)) {
5307 GstMatroskaIndex *last = NULL;
5309 GST_DEBUG_OBJECT (demux,
5310 "estimating duration using last cluster");
5311 if ((last = gst_matroska_demux_search_pos (demux,
5312 GST_CLOCK_TIME_NONE)) != NULL) {
5313 demux->last_cluster_offset =
5314 last->pos + demux->common.ebml_segment_start;
5315 demux->stream_last_time = last->time;
5316 demux->common.segment.duration =
5317 demux->stream_last_time - demux->stream_start_time;
5318 /* above estimate should not be taken all too strongly */
5319 demux->invalid_duration = TRUE;
5320 GST_DEBUG_OBJECT (demux,
5321 "estimated duration as %" GST_TIME_FORMAT,
5322 GST_TIME_ARGS (demux->common.segment.duration));
5326 /* Peek at second cluster in order to figure out if we have cluster
5327 * prev_size or not (which is never set on the first cluster for
5328 * obvious reasons). This is useful in case someone initiates a
5329 * seek or direction change before we reach the second cluster. */
5330 if (!demux->streaming) {
5331 ClusterInfo cluster = { 0, };
5333 if (gst_matroska_demux_peek_cluster_info (demux, &cluster,
5334 demux->first_cluster_offset) && cluster.size > 0) {
5335 gst_matroska_demux_peek_cluster_info (demux, &cluster,
5336 demux->first_cluster_offset + cluster.size);
5338 demux->common.offset = demux->first_cluster_offset;
5341 if (demux->deferred_seek_event) {
5342 GstEvent *seek_event;
5344 seek_event = demux->deferred_seek_event;
5345 seek_pad = demux->deferred_seek_pad;
5346 demux->deferred_seek_event = NULL;
5347 demux->deferred_seek_pad = NULL;
5348 GST_DEBUG_OBJECT (demux,
5349 "Handling deferred seek event: %" GST_PTR_FORMAT, seek_event);
5350 gst_matroska_demux_handle_seek_event (demux, seek_pad,
5352 gst_event_unref (seek_event);
5355 /* send initial segment - we wait till we know the first
5356 incoming timestamp, so we can properly set the start of
5358 demux->need_segment = TRUE;
5360 demux->cluster_time = GST_CLOCK_TIME_NONE;
5361 demux->cluster_offset = demux->common.offset;
5362 demux->cluster_prevsize = 0;
5363 if (G_UNLIKELY (!demux->seek_first && demux->seek_block)) {
5364 GST_DEBUG_OBJECT (demux, "seek target block %" G_GUINT64_FORMAT
5365 " not found in Cluster, trying next Cluster's first block instead",
5367 demux->seek_block = 0;
5369 demux->seek_first = FALSE;
5370 /* record next cluster for recovery */
5371 if (read != G_MAXUINT64)
5372 demux->next_cluster_offset = demux->cluster_offset + read;
5373 /* eat cluster prefix */
5374 gst_matroska_demux_flush (demux, needed);
5376 case GST_MATROSKA_ID_CLUSTERTIMECODE:
5380 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5381 if ((ret = gst_ebml_read_uint (&ebml, &id, &num)) != GST_FLOW_OK)
5383 GST_DEBUG_OBJECT (demux, "ClusterTimeCode: %" G_GUINT64_FORMAT, num);
5384 demux->cluster_time = num;
5385 /* track last cluster */
5386 if (demux->cluster_offset > demux->last_cluster_offset) {
5387 demux->last_cluster_offset = demux->cluster_offset;
5388 demux->stream_last_time =
5389 demux->cluster_time * demux->common.time_scale;
5392 if (demux->common.element_index) {
5393 if (demux->common.element_index_writer_id == -1)
5394 gst_index_get_writer_id (demux->common.element_index,
5395 GST_OBJECT (demux), &demux->common.element_index_writer_id);
5396 GST_LOG_OBJECT (demux, "adding association %" GST_TIME_FORMAT "-> %"
5397 G_GUINT64_FORMAT " for writer id %d",
5398 GST_TIME_ARGS (demux->cluster_time), demux->cluster_offset,
5399 demux->common.element_index_writer_id);
5400 gst_index_add_association (demux->common.element_index,
5401 demux->common.element_index_writer_id,
5402 GST_ASSOCIATION_FLAG_KEY_UNIT,
5403 GST_FORMAT_TIME, demux->cluster_time,
5404 GST_FORMAT_BYTES, demux->cluster_offset, NULL);
5409 case GST_MATROSKA_ID_BLOCKGROUP:
5410 if (!gst_matroska_demux_seek_block (demux))
5412 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5413 DEBUG_ELEMENT_START (demux, &ebml, "BlockGroup");
5414 if ((ret = gst_ebml_read_master (&ebml, &id)) == GST_FLOW_OK) {
5415 ret = gst_matroska_demux_parse_blockgroup_or_simpleblock (demux,
5416 &ebml, demux->cluster_time, demux->cluster_offset, FALSE);
5418 DEBUG_ELEMENT_STOP (demux, &ebml, "BlockGroup", ret);
5420 case GST_MATROSKA_ID_SIMPLEBLOCK:
5421 if (!gst_matroska_demux_seek_block (demux))
5423 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5424 DEBUG_ELEMENT_START (demux, &ebml, "SimpleBlock");
5425 ret = gst_matroska_demux_parse_blockgroup_or_simpleblock (demux,
5426 &ebml, demux->cluster_time, demux->cluster_offset, TRUE);
5427 DEBUG_ELEMENT_STOP (demux, &ebml, "SimpleBlock", ret);
5429 case GST_MATROSKA_ID_ATTACHMENTS:
5430 if (!demux->common.attachments_parsed) {
5431 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5432 ret = gst_matroska_read_common_parse_attachments (&demux->common,
5433 GST_ELEMENT_CAST (demux), &ebml);
5434 if (ret == GST_FLOW_OK)
5435 gst_matroska_demux_send_tags (demux);
5437 GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
5440 case GST_MATROSKA_ID_TAGS:
5441 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5442 ret = gst_matroska_read_common_parse_metadata (&demux->common,
5443 GST_ELEMENT_CAST (demux), &ebml);
5444 if (ret == GST_FLOW_OK)
5445 gst_matroska_demux_send_tags (demux);
5447 case GST_MATROSKA_ID_CHAPTERS:
5448 if (!demux->common.chapters_parsed) {
5449 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5451 gst_matroska_read_common_parse_chapters (&demux->common, &ebml);
5453 if (demux->common.toc) {
5454 gst_matroska_demux_send_event (demux,
5455 gst_event_new_toc (demux->common.toc, FALSE));
5458 GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
5460 case GST_MATROSKA_ID_SEEKHEAD:
5461 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5462 ret = gst_matroska_demux_parse_contents (demux, &ebml);
5464 case GST_MATROSKA_ID_CUES:
5465 if (demux->common.index_parsed) {
5466 GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
5469 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5470 ret = gst_matroska_read_common_parse_index (&demux->common, &ebml);
5471 /* only push based; delayed index building */
5472 if (ret == GST_FLOW_OK
5473 && demux->common.state == GST_MATROSKA_READ_STATE_SEEK) {
5476 GST_OBJECT_LOCK (demux);
5477 event = demux->seek_event;
5478 demux->seek_event = NULL;
5479 GST_OBJECT_UNLOCK (demux);
5482 /* unlikely to fail, since we managed to seek to this point */
5483 if (!gst_matroska_demux_handle_seek_event (demux, NULL, event)) {
5484 gst_event_unref (event);
5487 gst_event_unref (event);
5488 /* resume data handling, main thread clear to seek again */
5489 GST_OBJECT_LOCK (demux);
5490 demux->common.state = GST_MATROSKA_READ_STATE_DATA;
5491 GST_OBJECT_UNLOCK (demux);
5494 case GST_MATROSKA_ID_PREVSIZE:{
5497 GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
5498 if ((ret = gst_ebml_read_uint (&ebml, &id, &num)) != GST_FLOW_OK)
5500 GST_LOG_OBJECT (demux, "ClusterPrevSize: %" G_GUINT64_FORMAT, num);
5501 demux->cluster_prevsize = num;
5502 demux->seen_cluster_prevsize = TRUE;
5505 case GST_MATROSKA_ID_POSITION:
5506 case GST_MATROSKA_ID_ENCRYPTEDBLOCK:
5507 /* The WebM doesn't support the EncryptedBlock element.
5508 * The Matroska spec doesn't give us more detail, how to parse this element,
5509 * for example the field TransformID isn't specified yet.*/
5510 case GST_MATROSKA_ID_SILENTTRACKS:
5511 GST_DEBUG_OBJECT (demux,
5512 "Skipping Cluster subelement 0x%x - ignoring", id);
5516 GST_DEBUG_OBJECT (demux, "skipping Element 0x%x", id);
5517 GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
5523 if (ret == GST_FLOW_PARSE)
5527 gst_ebml_read_clear (&ebml);
5533 /* simply exit, maybe not enough data yet */
5534 /* no ebml to clear if read error */
5539 GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL),
5540 ("Failed to parse Element 0x%x", id));
5541 ret = GST_FLOW_ERROR;
5546 GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL),
5547 ("File layout does not permit streaming"));
5548 ret = GST_FLOW_ERROR;
5553 GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL),
5554 ("No Tracks element found"));
5555 ret = GST_FLOW_ERROR;
5560 GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL), ("Invalid header"));
5561 ret = GST_FLOW_ERROR;
5566 GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL), ("Failed to seek"));
5567 ret = GST_FLOW_ERROR;
5573 gst_matroska_demux_loop (GstPad * pad)
5575 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (GST_PAD_PARENT (pad));
5581 /* If we have to close a segment, send a new segment to do this now */
5582 if (G_LIKELY (demux->common.state == GST_MATROSKA_READ_STATE_DATA)) {
5583 if (G_UNLIKELY (demux->new_segment)) {
5584 gst_matroska_demux_send_event (demux, demux->new_segment);
5585 demux->new_segment = NULL;
5589 ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
5590 GST_ELEMENT_CAST (demux), &id, &length, &needed);
5591 if (ret == GST_FLOW_EOS) {
5593 } else if (ret == GST_FLOW_FLUSHING) {
5595 } else if (ret != GST_FLOW_OK) {
5596 ret = gst_matroska_demux_check_parse_error (demux);
5598 /* Only handle EOS as no error if we're outside the segment already */
5599 if (ret == GST_FLOW_EOS && (demux->common.ebml_segment_length != G_MAXUINT64
5600 && demux->common.offset >=
5601 demux->common.ebml_segment_start +
5602 demux->common.ebml_segment_length))
5604 else if (ret != GST_FLOW_OK)
5610 GST_LOG_OBJECT (demux, "Offset %" G_GUINT64_FORMAT ", Element id 0x%x, "
5611 "size %" G_GUINT64_FORMAT ", needed %d", demux->common.offset, id,
5614 ret = gst_matroska_demux_parse_id (demux, id, length, needed);
5615 if (ret == GST_FLOW_EOS)
5617 if (ret != GST_FLOW_OK)
5620 /* check if we're at the end of a configured segment */
5621 if (G_LIKELY (demux->common.src->len)) {
5624 g_assert (demux->common.num_streams == demux->common.src->len);
5625 for (i = 0; i < demux->common.src->len; i++) {
5626 GstMatroskaTrackContext *context = g_ptr_array_index (demux->common.src,
5628 GST_DEBUG_OBJECT (context->pad, "pos %" GST_TIME_FORMAT,
5629 GST_TIME_ARGS (context->pos));
5630 if (context->eos == FALSE)
5634 GST_INFO_OBJECT (demux, "All streams are EOS");
5640 if (G_UNLIKELY (demux->cached_length == G_MAXUINT64 ||
5641 demux->common.offset >= demux->cached_length)) {
5642 demux->cached_length = gst_matroska_read_common_get_length (&demux->common);
5643 if (demux->common.offset == demux->cached_length) {
5644 GST_LOG_OBJECT (demux, "Reached end of stream");
5655 if (demux->common.segment.rate < 0.0) {
5656 ret = gst_matroska_demux_seek_to_previous_keyframe (demux);
5657 if (ret == GST_FLOW_OK)
5664 const gchar *reason = gst_flow_get_name (ret);
5665 gboolean push_eos = FALSE;
5667 GST_LOG_OBJECT (demux, "pausing task, reason %s", reason);
5668 gst_pad_pause_task (demux->common.sinkpad);
5670 if (ret == GST_FLOW_EOS) {
5671 /* perform EOS logic */
5673 /* If we were in the headers, make sure we send no-more-pads.
5674 This will ensure decodebin does not get stuck thinking
5675 the chain is not complete yet, and waiting indefinitely. */
5676 if (G_UNLIKELY (demux->common.state == GST_MATROSKA_READ_STATE_HEADER)) {
5677 if (demux->common.src->len == 0) {
5678 GST_ELEMENT_ERROR (demux, STREAM, FAILED, (NULL),
5679 ("No pads created"));
5681 GST_ELEMENT_WARNING (demux, STREAM, DEMUX, (NULL),
5682 ("Failed to finish reading headers"));
5684 gst_element_no_more_pads (GST_ELEMENT (demux));
5687 if (demux->common.segment.flags & GST_SEEK_FLAG_SEGMENT) {
5692 /* for segment playback we need to post when (in stream time)
5693 * we stopped, this is either stop (when set) or the duration. */
5694 if ((stop = demux->common.segment.stop) == -1)
5695 stop = demux->last_stop_end;
5697 GST_LOG_OBJECT (demux, "Sending segment done, at end of segment");
5698 msg = gst_message_new_segment_done (GST_OBJECT (demux), GST_FORMAT_TIME,
5700 if (demux->segment_seqnum)
5701 gst_message_set_seqnum (msg, demux->segment_seqnum);
5702 gst_element_post_message (GST_ELEMENT (demux), msg);
5704 event = gst_event_new_segment_done (GST_FORMAT_TIME, stop);
5705 if (demux->segment_seqnum)
5706 gst_event_set_seqnum (event, demux->segment_seqnum);
5707 gst_matroska_demux_send_event (demux, event);
5711 } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
5712 /* for fatal errors we post an error message */
5713 GST_ELEMENT_FLOW_ERROR (demux, ret);
5719 /* send EOS, and prevent hanging if no streams yet */
5720 GST_LOG_OBJECT (demux, "Sending EOS, at end of stream");
5721 event = gst_event_new_eos ();
5722 if (demux->segment_seqnum)
5723 gst_event_set_seqnum (event, demux->segment_seqnum);
5724 if (!gst_matroska_demux_send_event (demux, event) &&
5725 (ret == GST_FLOW_EOS)) {
5726 GST_ELEMENT_ERROR (demux, STREAM, DEMUX,
5727 (NULL), ("got eos but no streams (yet)"));
5735 * Create and push a flushing seek event upstream
5738 perform_seek_to_offset (GstMatroskaDemux * demux, gdouble rate, guint64 offset,
5739 guint32 seqnum, GstSeekFlags flags)
5744 GST_DEBUG_OBJECT (demux, "Seeking to %" G_GUINT64_FORMAT, offset);
5747 gst_event_new_seek (rate, GST_FORMAT_BYTES,
5748 flags | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
5749 GST_SEEK_TYPE_SET, offset, GST_SEEK_TYPE_NONE, -1);
5750 gst_event_set_seqnum (event, seqnum);
5752 res = gst_pad_push_event (demux->common.sinkpad, event);
5754 /* segment event will update offset */
5758 static GstFlowReturn
5759 gst_matroska_demux_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
5761 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
5763 GstFlowReturn ret = GST_FLOW_OK;
5768 if (G_UNLIKELY (GST_BUFFER_IS_DISCONT (buffer))) {
5769 GST_DEBUG_OBJECT (demux, "got DISCONT");
5770 gst_adapter_clear (demux->common.adapter);
5771 GST_OBJECT_LOCK (demux);
5772 gst_matroska_read_common_reset_streams (&demux->common,
5773 GST_CLOCK_TIME_NONE, FALSE);
5774 GST_OBJECT_UNLOCK (demux);
5777 gst_adapter_push (demux->common.adapter, buffer);
5781 available = gst_adapter_available (demux->common.adapter);
5783 ret = gst_matroska_read_common_peek_id_length_push (&demux->common,
5784 GST_ELEMENT_CAST (demux), &id, &length, &needed);
5785 if (G_UNLIKELY (ret != GST_FLOW_OK && ret != GST_FLOW_EOS)) {
5786 if (demux->common.ebml_segment_length != G_MAXUINT64
5787 && demux->common.offset >=
5788 demux->common.ebml_segment_start + demux->common.ebml_segment_length) {
5791 gint64 bytes_scanned;
5792 if (demux->common.start_resync_offset == -1) {
5793 demux->common.start_resync_offset = demux->common.offset;
5794 demux->common.state_to_restore = demux->common.state;
5796 bytes_scanned = demux->common.offset - demux->common.start_resync_offset;
5797 if (bytes_scanned <= INVALID_DATA_THRESHOLD) {
5798 GST_WARNING_OBJECT (demux,
5799 "parse error, looking for next cluster, actual offset %"
5800 G_GUINT64_FORMAT ", start resync offset %" G_GUINT64_FORMAT,
5801 demux->common.offset, demux->common.start_resync_offset);
5802 demux->common.state = GST_MATROSKA_READ_STATE_SCANNING;
5805 GST_WARNING_OBJECT (demux,
5806 "unrecoverable parse error, next cluster not found and threshold "
5807 "exceeded, bytes scanned %" G_GINT64_FORMAT, bytes_scanned);
5813 GST_LOG_OBJECT (demux, "Offset %" G_GUINT64_FORMAT ", Element id 0x%x, "
5814 "size %" G_GUINT64_FORMAT ", needed %d, available %d",
5815 demux->common.offset, id, length, needed, available);
5817 if (needed > available)
5820 ret = gst_matroska_demux_parse_id (demux, id, length, needed);
5821 if (ret == GST_FLOW_EOS) {
5822 /* need more data */
5824 } else if (ret != GST_FLOW_OK) {
5831 gst_matroska_demux_handle_sink_event (GstPad * pad, GstObject * parent,
5834 gboolean res = TRUE;
5835 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
5837 GST_DEBUG_OBJECT (demux,
5838 "have event type %s: %p on sink pad", GST_EVENT_TYPE_NAME (event), event);
5840 switch (GST_EVENT_TYPE (event)) {
5841 case GST_EVENT_SEGMENT:
5843 const GstSegment *segment;
5845 /* some debug output */
5846 gst_event_parse_segment (event, &segment);
5847 /* FIXME: do we need to update segment base here (like accum in 0.10)? */
5848 GST_DEBUG_OBJECT (demux,
5849 "received format %d segment %" GST_SEGMENT_FORMAT, segment->format,
5852 if (demux->common.state < GST_MATROSKA_READ_STATE_DATA) {
5853 GST_DEBUG_OBJECT (demux, "still starting");
5857 /* we only expect a BYTE segment, e.g. following a seek */
5858 if (segment->format != GST_FORMAT_BYTES) {
5859 GST_DEBUG_OBJECT (demux, "unsupported segment format, ignoring");
5863 GST_DEBUG_OBJECT (demux, "clearing segment state");
5864 GST_OBJECT_LOCK (demux);
5865 /* clear current segment leftover */
5866 gst_adapter_clear (demux->common.adapter);
5867 /* and some streaming setup */
5868 demux->common.offset = segment->start;
5869 /* accumulate base based on current position */
5870 if (GST_CLOCK_TIME_IS_VALID (demux->common.segment.position))
5871 demux->common.segment.base +=
5872 (MAX (demux->common.segment.position, demux->stream_start_time)
5873 - demux->stream_start_time) / fabs (demux->common.segment.rate);
5874 /* do not know where we are;
5875 * need to come across a cluster and generate segment */
5876 demux->common.segment.position = GST_CLOCK_TIME_NONE;
5877 demux->cluster_time = GST_CLOCK_TIME_NONE;
5878 demux->cluster_offset = 0;
5879 demux->cluster_prevsize = 0;
5880 demux->need_segment = TRUE;
5881 demux->segment_seqnum = gst_event_get_seqnum (event);
5882 /* but keep some of the upstream segment */
5883 demux->common.segment.rate = segment->rate;
5884 demux->common.segment.flags = segment->flags;
5885 /* also check if need to keep some of the requested seek position */
5886 if (demux->seek_offset == segment->start) {
5887 GST_DEBUG_OBJECT (demux, "position matches requested seek");
5888 demux->common.segment.position = demux->requested_seek_time;
5890 GST_DEBUG_OBJECT (demux, "unexpected segment position");
5892 demux->requested_seek_time = GST_CLOCK_TIME_NONE;
5893 demux->seek_offset = -1;
5894 GST_OBJECT_UNLOCK (demux);
5896 /* chain will send initial segment after pads have been added,
5897 * or otherwise come up with one */
5898 GST_DEBUG_OBJECT (demux, "eating event");
5899 gst_event_unref (event);
5905 if (demux->common.state != GST_MATROSKA_READ_STATE_DATA
5906 && demux->common.state != GST_MATROSKA_READ_STATE_SCANNING) {
5907 gst_event_unref (event);
5908 GST_ELEMENT_ERROR (demux, STREAM, DEMUX,
5909 (NULL), ("got eos and didn't receive a complete header object"));
5910 } else if (demux->common.num_streams == 0) {
5911 GST_ELEMENT_ERROR (demux, STREAM, DEMUX,
5912 (NULL), ("got eos but no streams (yet)"));
5914 gst_matroska_demux_send_event (demux, event);
5918 case GST_EVENT_FLUSH_STOP:
5922 gst_adapter_clear (demux->common.adapter);
5923 GST_OBJECT_LOCK (demux);
5924 gst_matroska_read_common_reset_streams (&demux->common,
5925 GST_CLOCK_TIME_NONE, TRUE);
5926 gst_flow_combiner_reset (demux->flowcombiner);
5927 dur = demux->common.segment.duration;
5928 gst_segment_init (&demux->common.segment, GST_FORMAT_TIME);
5929 demux->common.segment.duration = dur;
5930 demux->cluster_time = GST_CLOCK_TIME_NONE;
5931 demux->cluster_offset = 0;
5932 demux->cluster_prevsize = 0;
5933 GST_OBJECT_UNLOCK (demux);
5937 res = gst_pad_event_default (pad, parent, event);
5945 gst_matroska_demux_sink_activate (GstPad * sinkpad, GstObject * parent)
5947 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
5949 gboolean pull_mode = FALSE;
5951 query = gst_query_new_scheduling ();
5953 if (gst_pad_peer_query (sinkpad, query))
5954 pull_mode = gst_query_has_scheduling_mode_with_flags (query,
5955 GST_PAD_MODE_PULL, GST_SCHEDULING_FLAG_SEEKABLE);
5957 gst_query_unref (query);
5960 GST_DEBUG ("going to pull mode");
5961 demux->streaming = FALSE;
5962 return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
5964 GST_DEBUG ("going to push (streaming) mode");
5965 demux->streaming = TRUE;
5966 return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
5971 gst_matroska_demux_sink_activate_mode (GstPad * sinkpad, GstObject * parent,
5972 GstPadMode mode, gboolean active)
5975 case GST_PAD_MODE_PULL:
5977 /* if we have a scheduler we can start the task */
5978 gst_pad_start_task (sinkpad, (GstTaskFunction) gst_matroska_demux_loop,
5981 gst_pad_stop_task (sinkpad);
5984 case GST_PAD_MODE_PUSH:
5992 gst_matroska_demux_video_caps (GstMatroskaTrackVideoContext *
5993 videocontext, const gchar * codec_id, guint8 * data, guint size,
5994 gchar ** codec_name, guint32 * riff_fourcc)
5996 GstMatroskaTrackContext *context = (GstMatroskaTrackContext *) videocontext;
5997 GstCaps *caps = NULL;
5999 g_assert (videocontext != NULL);
6000 g_assert (codec_name != NULL);
6005 /* TODO: check if we have all codec types from matroska-ids.h
6006 * check if we have to do more special things with codec_private
6009 * GST_MATROSKA_CODEC_ID_VIDEO_QUICKTIME
6010 * GST_MATROSKA_CODEC_ID_VIDEO_SNOW
6013 if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC)) {
6014 gst_riff_strf_vids *vids = NULL;
6017 GstBuffer *buf = NULL;
6019 vids = (gst_riff_strf_vids *) data;
6021 /* assure size is big enough */
6023 GST_WARNING ("Too small BITMAPINFOHEADER (%d bytes)", size);
6026 if (size < sizeof (gst_riff_strf_vids)) {
6027 vids = g_new (gst_riff_strf_vids, 1);
6028 memcpy (vids, data, size);
6031 context->dts_only = TRUE; /* VFW files only store DTS */
6033 /* little-endian -> byte-order */
6034 vids->size = GUINT32_FROM_LE (vids->size);
6035 vids->width = GUINT32_FROM_LE (vids->width);
6036 vids->height = GUINT32_FROM_LE (vids->height);
6037 vids->planes = GUINT16_FROM_LE (vids->planes);
6038 vids->bit_cnt = GUINT16_FROM_LE (vids->bit_cnt);
6039 vids->compression = GUINT32_FROM_LE (vids->compression);
6040 vids->image_size = GUINT32_FROM_LE (vids->image_size);
6041 vids->xpels_meter = GUINT32_FROM_LE (vids->xpels_meter);
6042 vids->ypels_meter = GUINT32_FROM_LE (vids->ypels_meter);
6043 vids->num_colors = GUINT32_FROM_LE (vids->num_colors);
6044 vids->imp_colors = GUINT32_FROM_LE (vids->imp_colors);
6046 if (size > sizeof (gst_riff_strf_vids)) { /* some extra_data */
6047 gsize offset = sizeof (gst_riff_strf_vids);
6050 gst_buffer_new_wrapped (g_memdup ((guint8 *) vids + offset,
6051 size - offset), size - offset);
6055 *riff_fourcc = vids->compression;
6057 caps = gst_riff_create_video_caps (vids->compression, NULL, vids,
6058 buf, NULL, codec_name);
6061 GST_WARNING ("Unhandled RIFF fourcc %" GST_FOURCC_FORMAT,
6062 GST_FOURCC_ARGS (vids->compression));
6064 static GstStaticCaps intra_caps = GST_STATIC_CAPS ("image/jpeg; "
6065 "video/x-raw; image/png; video/x-dv; video/x-huffyuv; video/x-ffv; "
6066 "video/x-compressed-yuv");
6067 context->intra_only =
6068 gst_caps_can_intersect (gst_static_caps_get (&intra_caps), caps);
6072 gst_buffer_unref (buf);
6074 if (vids != (gst_riff_strf_vids *) data)
6077 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_UNCOMPRESSED)) {
6079 GstVideoFormat format;
6081 gst_video_info_init (&info);
6082 switch (videocontext->fourcc) {
6083 case GST_MAKE_FOURCC ('I', '4', '2', '0'):
6084 format = GST_VIDEO_FORMAT_I420;
6086 case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
6087 format = GST_VIDEO_FORMAT_YUY2;
6089 case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
6090 format = GST_VIDEO_FORMAT_YV12;
6092 case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
6093 format = GST_VIDEO_FORMAT_UYVY;
6095 case GST_MAKE_FOURCC ('A', 'Y', 'U', 'V'):
6096 format = GST_VIDEO_FORMAT_AYUV;
6098 case GST_MAKE_FOURCC ('Y', '8', '0', '0'):
6099 case GST_MAKE_FOURCC ('Y', '8', ' ', ' '):
6100 format = GST_VIDEO_FORMAT_GRAY8;
6102 case GST_MAKE_FOURCC ('R', 'G', 'B', 24):
6103 format = GST_VIDEO_FORMAT_RGB;
6105 case GST_MAKE_FOURCC ('B', 'G', 'R', 24):
6106 format = GST_VIDEO_FORMAT_BGR;
6109 GST_DEBUG ("Unknown fourcc %" GST_FOURCC_FORMAT,
6110 GST_FOURCC_ARGS (videocontext->fourcc));
6114 context->intra_only = TRUE;
6116 gst_video_info_set_format (&info, format, videocontext->pixel_width,
6117 videocontext->pixel_height);
6118 caps = gst_video_info_to_caps (&info);
6119 *codec_name = gst_pb_utils_get_codec_description (caps);
6120 context->alignment = 32;
6121 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_SP)) {
6122 caps = gst_caps_new_simple ("video/x-divx",
6123 "divxversion", G_TYPE_INT, 4, NULL);
6124 *codec_name = g_strdup ("MPEG-4 simple profile");
6125 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_ASP) ||
6126 !strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_AP)) {
6127 caps = gst_caps_new_simple ("video/mpeg",
6128 "mpegversion", G_TYPE_INT, 4,
6129 "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
6133 priv = gst_buffer_new_wrapped (g_memdup (data, size), size);
6134 gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
6135 gst_buffer_unref (priv);
6137 gst_codec_utils_mpeg4video_caps_set_level_and_profile (caps, data, size);
6139 if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_ASP))
6140 *codec_name = g_strdup ("MPEG-4 advanced simple profile");
6142 *codec_name = g_strdup ("MPEG-4 advanced profile");
6143 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MSMPEG4V3)) {
6145 caps = gst_caps_new_full (gst_structure_new ("video/x-divx",
6146 "divxversion", G_TYPE_INT, 3, NULL),
6147 gst_structure_new ("video/x-msmpeg",
6148 "msmpegversion", G_TYPE_INT, 43, NULL), NULL);
6150 caps = gst_caps_new_simple ("video/x-msmpeg",
6151 "msmpegversion", G_TYPE_INT, 43, NULL);
6152 *codec_name = g_strdup ("Microsoft MPEG-4 v.3");
6153 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG1) ||
6154 !strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG2)) {
6157 if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG1))
6162 caps = gst_caps_new_simple ("video/mpeg",
6163 "systemstream", G_TYPE_BOOLEAN, FALSE,
6164 "mpegversion", G_TYPE_INT, mpegversion, NULL);
6165 *codec_name = g_strdup_printf ("MPEG-%d video", mpegversion);
6166 context->postprocess_frame = gst_matroska_demux_add_mpeg_seq_header;
6167 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MJPEG)) {
6168 caps = gst_caps_new_empty_simple ("image/jpeg");
6169 *codec_name = g_strdup ("Motion-JPEG");
6170 context->intra_only = TRUE;
6171 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_AVC)) {
6172 caps = gst_caps_new_empty_simple ("video/x-h264");
6176 /* First byte is the version, second is the profile indication, and third
6177 * is the 5 contraint_set_flags and 3 reserved bits. Fourth byte is the
6178 * level indication. */
6179 gst_codec_utils_h264_caps_set_level_and_profile (caps, data + 1,
6182 priv = gst_buffer_new_wrapped (g_memdup (data, size), size);
6183 gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
6184 gst_buffer_unref (priv);
6186 gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, "avc",
6187 "alignment", G_TYPE_STRING, "au", NULL);
6189 GST_WARNING ("No codec data found, assuming output is byte-stream");
6190 gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, "byte-stream",
6193 *codec_name = g_strdup ("H264");
6194 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEGH_HEVC)) {
6195 caps = gst_caps_new_empty_simple ("video/x-h265");
6199 gst_codec_utils_h265_caps_set_level_tier_and_profile (caps, data + 1,
6202 priv = gst_buffer_new_wrapped (g_memdup (data, size), size);
6203 gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
6204 gst_buffer_unref (priv);
6206 gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, "hvc1",
6207 "alignment", G_TYPE_STRING, "au", NULL);
6209 GST_WARNING ("No codec data found, assuming output is byte-stream");
6210 gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, "byte-stream",
6213 *codec_name = g_strdup ("HEVC");
6214 } else if ((!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO1)) ||
6215 (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO2)) ||
6216 (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO3)) ||
6217 (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO4))) {
6218 gint rmversion = -1;
6220 if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO1))
6222 else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO2))
6224 else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO3))
6226 else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO4))
6229 caps = gst_caps_new_simple ("video/x-pn-realvideo",
6230 "rmversion", G_TYPE_INT, rmversion, NULL);
6231 GST_DEBUG ("data:%p, size:0x%x", data, size);
6232 /* We need to extract the extradata ! */
6233 if (data && (size >= 0x22)) {
6238 subformat = GST_READ_UINT32_BE (data + 0x1a);
6239 rformat = GST_READ_UINT32_BE (data + 0x1e);
6242 gst_buffer_new_wrapped (g_memdup (data + 0x1a, size - 0x1a),
6244 gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, "format",
6245 G_TYPE_INT, rformat, "subformat", G_TYPE_INT, subformat, NULL);
6246 gst_buffer_unref (priv);
6249 *codec_name = g_strdup_printf ("RealVideo %d.0", rmversion);
6250 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_THEORA)) {
6251 caps = gst_caps_new_empty_simple ("video/x-theora");
6252 context->stream_headers =
6253 gst_matroska_parse_xiph_stream_headers (context->codec_priv,
6254 context->codec_priv_size);
6255 /* FIXME: mark stream as broken and skip if there are no stream headers */
6256 context->send_stream_headers = TRUE;
6257 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_DIRAC)) {
6258 caps = gst_caps_new_empty_simple ("video/x-dirac");
6259 *codec_name = g_strdup_printf ("Dirac");
6260 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VP8)) {
6261 caps = gst_caps_new_empty_simple ("video/x-vp8");
6262 *codec_name = g_strdup_printf ("On2 VP8");
6263 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VP9)) {
6264 caps = gst_caps_new_empty_simple ("video/x-vp9");
6265 *codec_name = g_strdup_printf ("On2 VP9");
6266 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_AV1)) {
6267 caps = gst_caps_new_empty_simple ("video/x-av1");
6271 priv = gst_buffer_new_wrapped (g_memdup (data, size), size);
6272 gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
6273 gst_buffer_unref (priv);
6275 GST_WARNING ("No codec data found, assuming output is byte-stream");
6276 gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, "byte-stream",
6279 *codec_name = g_strdup_printf ("AOM AV1");
6280 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_PRORES)) {
6282 const gchar *variant, *variant_descr = "";
6284 /* Expect a fourcc in the codec private data */
6285 if (!data || size < 4) {
6286 GST_WARNING ("No or too small PRORESS fourcc (%d bytes)", size);
6290 fourcc = GST_STR_FOURCC (data);
6292 case GST_MAKE_FOURCC ('a', 'p', 'c', 's'):
6293 variant_descr = " 4:2:2 LT";
6296 case GST_MAKE_FOURCC ('a', 'p', 'c', 'h'):
6298 variant_descr = " 4:2:2 HQ";
6300 case GST_MAKE_FOURCC ('a', 'p', '4', 'h'):
6302 variant_descr = " 4:4:4:4";
6304 case GST_MAKE_FOURCC ('a', 'p', 'c', 'o'):
6306 variant_descr = " 4:2:2 Proxy";
6308 case GST_MAKE_FOURCC ('a', 'p', 'c', 'n'):
6310 variant = "standard";
6311 variant_descr = " 4:2:2 SD";
6315 GST_LOG ("Prores video, codec fourcc %" GST_FOURCC_FORMAT,
6316 GST_FOURCC_ARGS (fourcc));
6318 caps = gst_caps_new_simple ("video/x-prores",
6319 "format", G_TYPE_STRING, variant, NULL);
6320 *codec_name = g_strdup_printf ("Apple ProRes%s", variant_descr);
6321 context->postprocess_frame = gst_matroska_demux_add_prores_header;
6323 GST_WARNING ("Unknown codec '%s', cannot build Caps", codec_id);
6329 GstStructure *structure;
6331 for (i = 0; i < gst_caps_get_size (caps); i++) {
6332 structure = gst_caps_get_structure (caps, i);
6334 /* FIXME: use the real unit here! */
6335 GST_DEBUG ("video size %dx%d, target display size %dx%d (any unit)",
6336 videocontext->pixel_width,
6337 videocontext->pixel_height,
6338 videocontext->display_width, videocontext->display_height);
6340 /* pixel width and height are the w and h of the video in pixels */
6341 if (videocontext->pixel_width > 0 && videocontext->pixel_height > 0) {
6342 gint w = videocontext->pixel_width;
6343 gint h = videocontext->pixel_height;
6345 gst_structure_set (structure,
6346 "width", G_TYPE_INT, w, "height", G_TYPE_INT, h, NULL);
6349 if (videocontext->display_width > 0 || videocontext->display_height > 0) {
6352 if (videocontext->display_width <= 0)
6353 videocontext->display_width = videocontext->pixel_width;
6354 if (videocontext->display_height <= 0)
6355 videocontext->display_height = videocontext->pixel_height;
6357 /* calculate the pixel aspect ratio using the display and pixel w/h */
6358 n = videocontext->display_width * videocontext->pixel_height;
6359 d = videocontext->display_height * videocontext->pixel_width;
6360 GST_DEBUG ("setting PAR to %d/%d", n, d);
6361 gst_structure_set (structure, "pixel-aspect-ratio",
6363 videocontext->display_width * videocontext->pixel_height,
6364 videocontext->display_height * videocontext->pixel_width, NULL);
6367 if (videocontext->default_fps > 0.0) {
6370 gst_util_double_to_fraction (videocontext->default_fps, &fps_n, &fps_d);
6372 GST_DEBUG ("using default fps %d/%d", fps_n, fps_d);
6374 gst_structure_set (structure, "framerate", GST_TYPE_FRACTION, fps_n,
6376 } else if (context->default_duration > 0) {
6379 gst_video_guess_framerate (context->default_duration, &fps_n, &fps_d);
6381 GST_INFO ("using default duration %" G_GUINT64_FORMAT
6382 " framerate %d/%d", context->default_duration, fps_n, fps_d);
6384 gst_structure_set (structure, "framerate", GST_TYPE_FRACTION,
6385 fps_n, fps_d, NULL);
6387 gst_structure_set (structure, "framerate", GST_TYPE_FRACTION,
6391 switch (videocontext->interlace_mode) {
6392 case GST_MATROSKA_INTERLACE_MODE_PROGRESSIVE:
6393 gst_structure_set (structure,
6394 "interlace-mode", G_TYPE_STRING, "progressive", NULL);
6396 case GST_MATROSKA_INTERLACE_MODE_INTERLACED:
6397 gst_structure_set (structure,
6398 "interlace-mode", G_TYPE_STRING, "mixed", NULL);
6404 if (videocontext->multiview_mode != GST_VIDEO_MULTIVIEW_MODE_NONE) {
6405 if (gst_video_multiview_guess_half_aspect (videocontext->multiview_mode,
6406 videocontext->pixel_width, videocontext->pixel_height,
6407 videocontext->display_width * videocontext->pixel_height,
6408 videocontext->display_height * videocontext->pixel_width)) {
6409 videocontext->multiview_flags |= GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT;
6411 gst_caps_set_simple (caps,
6412 "multiview-mode", G_TYPE_STRING,
6413 gst_video_multiview_mode_to_caps_string
6414 (videocontext->multiview_mode), "multiview-flags",
6415 GST_TYPE_VIDEO_MULTIVIEW_FLAGSET, videocontext->multiview_flags,
6416 GST_FLAG_SET_MASK_EXACT, NULL);
6419 if (videocontext->colorimetry.range != GST_VIDEO_COLOR_RANGE_UNKNOWN ||
6420 videocontext->colorimetry.matrix != GST_VIDEO_COLOR_MATRIX_UNKNOWN ||
6421 videocontext->colorimetry.transfer != GST_VIDEO_TRANSFER_UNKNOWN ||
6422 videocontext->colorimetry.primaries !=
6423 GST_VIDEO_COLOR_PRIMARIES_UNKNOWN) {
6424 gchar *colorimetry =
6425 gst_video_colorimetry_to_string (&videocontext->colorimetry);
6426 gst_caps_set_simple (caps, "colorimetry", G_TYPE_STRING, colorimetry,
6428 GST_DEBUG ("setting colorimetry to %s", colorimetry);
6429 g_free (colorimetry);
6432 caps = gst_caps_simplify (caps);
6439 * Some AAC specific code... *sigh*
6440 * FIXME: maybe we should use '15' and code the sample rate explicitly
6441 * if the sample rate doesn't match the predefined rates exactly? (tpm)
6445 aac_rate_idx (gint rate)
6449 else if (75132 <= rate)
6451 else if (55426 <= rate)
6453 else if (46009 <= rate)
6455 else if (37566 <= rate)
6457 else if (27713 <= rate)
6459 else if (23004 <= rate)
6461 else if (18783 <= rate)
6463 else if (13856 <= rate)
6465 else if (11502 <= rate)
6467 else if (9391 <= rate)
6474 aac_profile_idx (const gchar * codec_id)
6478 if (strlen (codec_id) <= 12)
6480 else if (!strncmp (&codec_id[12], "MAIN", 4))
6482 else if (!strncmp (&codec_id[12], "LC", 2))
6484 else if (!strncmp (&codec_id[12], "SSR", 3))
6493 round_up_pow2 (guint n)
6504 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
6507 gst_matroska_demux_audio_caps (GstMatroskaTrackAudioContext *
6508 audiocontext, const gchar * codec_id, guint8 * data, guint size,
6509 gchar ** codec_name, guint16 * riff_audio_fmt)
6511 GstMatroskaTrackContext *context = (GstMatroskaTrackContext *) audiocontext;
6512 GstCaps *caps = NULL;
6514 g_assert (audiocontext != NULL);
6515 g_assert (codec_name != NULL);
6518 *riff_audio_fmt = 0;
6520 /* TODO: check if we have all codec types from matroska-ids.h
6521 * check if we have to do more special things with codec_private
6522 * check if we need bitdepth in different places too
6523 * implement channel position magic
6525 * GST_MATROSKA_CODEC_ID_AUDIO_AC3_BSID9
6526 * GST_MATROSKA_CODEC_ID_AUDIO_AC3_BSID10
6527 * GST_MATROSKA_CODEC_ID_AUDIO_QUICKTIME_QDMC
6528 * GST_MATROSKA_CODEC_ID_AUDIO_QUICKTIME_QDM2
6531 if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L1) ||
6532 !strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L2) ||
6533 !strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L3)) {
6536 if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L1))
6538 else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L2))
6543 caps = gst_caps_new_simple ("audio/mpeg",
6544 "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, layer, NULL);
6545 *codec_name = g_strdup_printf ("MPEG-1 layer %d", layer);
6546 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_PCM_INT_BE) ||
6547 !strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_PCM_INT_LE)) {
6550 GstAudioFormat format;
6552 sign = (audiocontext->bitdepth != 8);
6553 if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_PCM_INT_BE))
6554 endianness = G_BIG_ENDIAN;
6556 endianness = G_LITTLE_ENDIAN;
6558 format = gst_audio_format_build_integer (sign, endianness,
6559 audiocontext->bitdepth, audiocontext->bitdepth);
6561 /* FIXME: Channel mask and reordering */
6562 caps = gst_caps_new_simple ("audio/x-raw",
6563 "format", G_TYPE_STRING, gst_audio_format_to_string (format),
6564 "layout", G_TYPE_STRING, "interleaved",
6565 "channel-mask", GST_TYPE_BITMASK,
6566 gst_audio_channel_get_fallback_mask (audiocontext->channels), NULL);
6568 *codec_name = g_strdup_printf ("Raw %d-bit PCM audio",
6569 audiocontext->bitdepth);
6570 context->alignment = GST_ROUND_UP_8 (audiocontext->bitdepth) / 8;
6571 context->alignment = round_up_pow2 (context->alignment);
6572 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_PCM_FLOAT)) {
6573 const gchar *format;
6574 if (audiocontext->bitdepth == 32)
6578 /* FIXME: Channel mask and reordering */
6579 caps = gst_caps_new_simple ("audio/x-raw",
6580 "format", G_TYPE_STRING, format,
6581 "layout", G_TYPE_STRING, "interleaved",
6582 "channel-mask", GST_TYPE_BITMASK,
6583 gst_audio_channel_get_fallback_mask (audiocontext->channels), NULL);
6584 *codec_name = g_strdup_printf ("Raw %d-bit floating-point audio",
6585 audiocontext->bitdepth);
6586 context->alignment = audiocontext->bitdepth / 8;
6587 context->alignment = round_up_pow2 (context->alignment);
6588 } else if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AC3,
6589 strlen (GST_MATROSKA_CODEC_ID_AUDIO_AC3))) {
6590 caps = gst_caps_new_simple ("audio/x-ac3",
6591 "framed", G_TYPE_BOOLEAN, TRUE, NULL);
6592 *codec_name = g_strdup ("AC-3 audio");
6593 } else if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_EAC3,
6594 strlen (GST_MATROSKA_CODEC_ID_AUDIO_EAC3))) {
6595 caps = gst_caps_new_simple ("audio/x-eac3",
6596 "framed", G_TYPE_BOOLEAN, TRUE, NULL);
6597 *codec_name = g_strdup ("E-AC-3 audio");
6598 } else if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_TRUEHD,
6599 strlen (GST_MATROSKA_CODEC_ID_AUDIO_TRUEHD))) {
6600 caps = gst_caps_new_empty_simple ("audio/x-true-hd");
6601 *codec_name = g_strdup ("Dolby TrueHD");
6602 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_DTS)) {
6603 caps = gst_caps_new_empty_simple ("audio/x-dts");
6604 *codec_name = g_strdup ("DTS audio");
6605 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_VORBIS)) {
6606 caps = gst_caps_new_empty_simple ("audio/x-vorbis");
6607 context->stream_headers =
6608 gst_matroska_parse_xiph_stream_headers (context->codec_priv,
6609 context->codec_priv_size);
6610 /* FIXME: mark stream as broken and skip if there are no stream headers */
6611 context->send_stream_headers = TRUE;
6612 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_FLAC)) {
6613 caps = gst_caps_new_empty_simple ("audio/x-flac");
6614 context->stream_headers =
6615 gst_matroska_parse_flac_stream_headers (context->codec_priv,
6616 context->codec_priv_size);
6617 /* FIXME: mark stream as broken and skip if there are no stream headers */
6618 context->send_stream_headers = TRUE;
6619 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_SPEEX)) {
6620 caps = gst_caps_new_empty_simple ("audio/x-speex");
6621 context->stream_headers =
6622 gst_matroska_parse_speex_stream_headers (context->codec_priv,
6623 context->codec_priv_size);
6624 /* FIXME: mark stream as broken and skip if there are no stream headers */
6625 context->send_stream_headers = TRUE;
6626 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_OPUS)) {
6629 if (context->codec_priv_size >= 19) {
6630 if (audiocontext->samplerate)
6631 GST_WRITE_UINT32_LE ((guint8 *) context->codec_priv + 12,
6632 audiocontext->samplerate);
6633 if (context->codec_delay) {
6635 gst_util_uint64_scale_round (context->codec_delay, 48000,
6637 GST_WRITE_UINT16_LE ((guint8 *) context->codec_priv + 10, delay);
6641 gst_buffer_new_wrapped (g_memdup (context->codec_priv,
6642 context->codec_priv_size), context->codec_priv_size);
6643 caps = gst_codec_utils_opus_create_caps_from_header (tmp, NULL);
6644 gst_buffer_unref (tmp);
6645 *codec_name = g_strdup ("Opus");
6646 } else if (context->codec_priv_size == 0) {
6647 GST_WARNING ("No Opus codec data found, trying to create one");
6648 if (audiocontext->channels <= 2) {
6649 guint8 streams, coupled, channels;
6653 audiocontext->samplerate == 0 ? 48000 : audiocontext->samplerate;
6654 channels = audiocontext->channels == 0 ? 2 : audiocontext->channels;
6655 if (channels == 1) {
6664 gst_codec_utils_opus_create_caps (samplerate, channels, 0, streams,
6667 *codec_name = g_strdup ("Opus");
6669 GST_WARNING ("Failed to create Opus caps from audio context");
6672 GST_WARNING ("No Opus codec data, and not enough info to create one");
6675 GST_WARNING ("Invalid Opus codec data size (got %" G_GSIZE_FORMAT
6676 ", expected 19)", context->codec_priv_size);
6678 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_ACM)) {
6679 gst_riff_strf_auds auds;
6681 if (data && size >= 18) {
6682 GstBuffer *codec_data = NULL;
6684 /* little-endian -> byte-order */
6685 auds.format = GST_READ_UINT16_LE (data);
6686 auds.channels = GST_READ_UINT16_LE (data + 2);
6687 auds.rate = GST_READ_UINT32_LE (data + 4);
6688 auds.av_bps = GST_READ_UINT32_LE (data + 8);
6689 auds.blockalign = GST_READ_UINT16_LE (data + 12);
6690 auds.bits_per_sample = GST_READ_UINT16_LE (data + 16);
6692 /* 18 is the waveformatex size */
6694 codec_data = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
6695 data + 18, size - 18, 0, size - 18, NULL, NULL);
6699 *riff_audio_fmt = auds.format;
6701 /* FIXME: Handle reorder map */
6702 caps = gst_riff_create_audio_caps (auds.format, NULL, &auds, NULL,
6703 codec_data, codec_name, NULL);
6705 gst_buffer_unref (codec_data);
6708 GST_WARNING ("Unhandled RIFF audio format 0x%02x", auds.format);
6711 GST_WARNING ("Invalid codec data size (%d expected, got %d)", 18, size);
6713 } else if (g_str_has_prefix (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC)) {
6714 GstBuffer *priv = NULL;
6716 gint rate_idx, profile;
6717 guint8 *data = NULL;
6719 /* unspecified AAC profile with opaque private codec data */
6720 if (strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC) == 0) {
6721 if (context->codec_priv_size >= 2) {
6722 guint obj_type, freq_index, explicit_freq_bytes = 0;
6724 codec_id = GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4;
6726 freq_index = (GST_READ_UINT16_BE (context->codec_priv) & 0x780) >> 7;
6727 obj_type = (GST_READ_UINT16_BE (context->codec_priv) & 0xF800) >> 11;
6728 if (freq_index == 15)
6729 explicit_freq_bytes = 3;
6730 GST_DEBUG ("obj_type = %u, freq_index = %u", obj_type, freq_index);
6731 priv = gst_buffer_new_wrapped (g_memdup (context->codec_priv,
6732 context->codec_priv_size), context->codec_priv_size);
6733 /* assume SBR if samplerate <= 24kHz */
6734 if (obj_type == 5 || (freq_index >= 6 && freq_index != 15) ||
6735 (context->codec_priv_size == (5 + explicit_freq_bytes))) {
6736 audiocontext->samplerate *= 2;
6739 GST_WARNING ("Opaque A_AAC codec ID, but no codec private data");
6740 /* this is pretty broken;
6741 * maybe we need to make up some default private,
6742 * or maybe ADTS data got dumped in.
6743 * Let's set up some private data now, and check actual data later */
6744 /* just try this and see what happens ... */
6745 codec_id = GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4;
6746 context->postprocess_frame = gst_matroska_demux_check_aac;
6750 /* make up decoder-specific data if it is not supplied */
6754 priv = gst_buffer_new_allocate (NULL, 5, NULL);
6755 gst_buffer_map (priv, &map, GST_MAP_WRITE);
6757 rate_idx = aac_rate_idx (audiocontext->samplerate);
6758 profile = aac_profile_idx (codec_id);
6760 data[0] = ((profile + 1) << 3) | ((rate_idx & 0xE) >> 1);
6761 data[1] = ((rate_idx & 0x1) << 7) | (audiocontext->channels << 3);
6763 if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG2,
6764 strlen (GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG2))) {
6766 gst_buffer_unmap (priv, &map);
6767 gst_buffer_set_size (priv, 2);
6768 } else if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4,
6769 strlen (GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4))) {
6772 if (g_strrstr (codec_id, "SBR")) {
6773 /* HE-AAC (aka SBR AAC) */
6774 audiocontext->samplerate *= 2;
6775 rate_idx = aac_rate_idx (audiocontext->samplerate);
6776 data[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
6777 data[3] = ((AAC_SYNC_EXTENSION_TYPE & 0x07) << 5) | 5;
6778 data[4] = (1 << 7) | (rate_idx << 3);
6779 gst_buffer_unmap (priv, &map);
6781 gst_buffer_unmap (priv, &map);
6782 gst_buffer_set_size (priv, 2);
6785 gst_buffer_unmap (priv, &map);
6786 gst_buffer_unref (priv);
6788 GST_ERROR ("Unknown AAC profile and no codec private data");
6793 caps = gst_caps_new_simple ("audio/mpeg",
6794 "mpegversion", G_TYPE_INT, mpegversion,
6795 "framed", G_TYPE_BOOLEAN, TRUE,
6796 "stream-format", G_TYPE_STRING, "raw", NULL);
6797 gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
6798 if (context->codec_priv && context->codec_priv_size > 0)
6799 gst_codec_utils_aac_caps_set_level_and_profile (caps,
6800 context->codec_priv, context->codec_priv_size);
6801 *codec_name = g_strdup_printf ("MPEG-%d AAC audio", mpegversion);
6802 gst_buffer_unref (priv);
6804 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_TTA)) {
6805 caps = gst_caps_new_simple ("audio/x-tta",
6806 "width", G_TYPE_INT, audiocontext->bitdepth, NULL);
6807 *codec_name = g_strdup ("TTA audio");
6808 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_WAVPACK4)) {
6809 caps = gst_caps_new_simple ("audio/x-wavpack",
6810 "width", G_TYPE_INT, audiocontext->bitdepth,
6811 "framed", G_TYPE_BOOLEAN, TRUE, NULL);
6812 *codec_name = g_strdup ("Wavpack audio");
6813 context->postprocess_frame = gst_matroska_demux_add_wvpk_header;
6814 audiocontext->wvpk_block_index = 0;
6815 } else if ((!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_14_4)) ||
6816 (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_28_8)) ||
6817 (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_COOK))) {
6818 gint raversion = -1;
6820 if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_14_4))
6822 else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_COOK))
6827 caps = gst_caps_new_simple ("audio/x-pn-realaudio",
6828 "raversion", G_TYPE_INT, raversion, NULL);
6829 /* Extract extra information from caps, mapping varies based on codec */
6830 if (data && (size >= 0x50)) {
6837 guint extra_data_size;
6839 GST_DEBUG ("real audio raversion:%d", raversion);
6840 if (raversion == 8) {
6842 flavor = GST_READ_UINT16_BE (data + 22);
6843 packet_size = GST_READ_UINT32_BE (data + 24);
6844 height = GST_READ_UINT16_BE (data + 40);
6845 leaf_size = GST_READ_UINT16_BE (data + 44);
6846 sample_width = GST_READ_UINT16_BE (data + 58);
6847 extra_data_size = GST_READ_UINT32_BE (data + 74);
6850 ("flavor:%d, packet_size:%d, height:%d, leaf_size:%d, sample_width:%d, extra_data_size:%d",
6851 flavor, packet_size, height, leaf_size, sample_width,
6853 gst_caps_set_simple (caps, "flavor", G_TYPE_INT, flavor, "packet_size",
6854 G_TYPE_INT, packet_size, "height", G_TYPE_INT, height, "leaf_size",
6855 G_TYPE_INT, leaf_size, "width", G_TYPE_INT, sample_width, NULL);
6857 if ((size - 78) >= extra_data_size) {
6858 priv = gst_buffer_new_wrapped (g_memdup (data + 78, extra_data_size),
6860 gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
6861 gst_buffer_unref (priv);
6866 *codec_name = g_strdup_printf ("RealAudio %d.0", raversion);
6867 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_SIPR)) {
6868 caps = gst_caps_new_empty_simple ("audio/x-sipro");
6869 *codec_name = g_strdup ("Sipro/ACELP.NET Voice Codec");
6870 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_RALF)) {
6871 caps = gst_caps_new_empty_simple ("audio/x-ralf-mpeg4-generic");
6872 *codec_name = g_strdup ("Real Audio Lossless");
6873 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_ATRC)) {
6874 caps = gst_caps_new_empty_simple ("audio/x-vnd.sony.atrac3");
6875 *codec_name = g_strdup ("Sony ATRAC3");
6877 GST_WARNING ("Unknown codec '%s', cannot build Caps", codec_id);
6882 if (audiocontext->samplerate > 0 && audiocontext->channels > 0) {
6885 for (i = 0; i < gst_caps_get_size (caps); i++) {
6886 gst_structure_set (gst_caps_get_structure (caps, i),
6887 "channels", G_TYPE_INT, audiocontext->channels,
6888 "rate", G_TYPE_INT, audiocontext->samplerate, NULL);
6892 caps = gst_caps_simplify (caps);
6899 gst_matroska_demux_subtitle_caps (GstMatroskaTrackSubtitleContext *
6900 subtitlecontext, const gchar * codec_id, gpointer data, guint size)
6902 GstCaps *caps = NULL;
6903 GstMatroskaTrackContext *context =
6904 (GstMatroskaTrackContext *) subtitlecontext;
6906 /* for backwards compatibility */
6907 if (!g_ascii_strcasecmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_ASCII))
6908 codec_id = GST_MATROSKA_CODEC_ID_SUBTITLE_UTF8;
6909 else if (!g_ascii_strcasecmp (codec_id, "S_SSA"))
6910 codec_id = GST_MATROSKA_CODEC_ID_SUBTITLE_SSA;
6911 else if (!g_ascii_strcasecmp (codec_id, "S_ASS"))
6912 codec_id = GST_MATROSKA_CODEC_ID_SUBTITLE_ASS;
6913 else if (!g_ascii_strcasecmp (codec_id, "S_USF"))
6914 codec_id = GST_MATROSKA_CODEC_ID_SUBTITLE_USF;
6916 /* TODO: Add GST_MATROSKA_CODEC_ID_SUBTITLE_BMP support
6917 * Check if we have to do something with codec_private */
6918 if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_UTF8)) {
6919 /* well, plain text simply does not have a lot of markup ... */
6920 caps = gst_caps_new_simple ("text/x-raw", "format", G_TYPE_STRING,
6921 "pango-markup", NULL);
6922 context->postprocess_frame = gst_matroska_demux_check_subtitle_buffer;
6923 subtitlecontext->check_markup = TRUE;
6924 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_SSA)) {
6925 caps = gst_caps_new_empty_simple ("application/x-ssa");
6926 context->postprocess_frame = gst_matroska_demux_check_subtitle_buffer;
6927 subtitlecontext->check_markup = FALSE;
6928 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_ASS)) {
6929 caps = gst_caps_new_empty_simple ("application/x-ass");
6930 context->postprocess_frame = gst_matroska_demux_check_subtitle_buffer;
6931 subtitlecontext->check_markup = FALSE;
6932 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_USF)) {
6933 caps = gst_caps_new_empty_simple ("application/x-usf");
6934 context->postprocess_frame = gst_matroska_demux_check_subtitle_buffer;
6935 subtitlecontext->check_markup = FALSE;
6936 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_VOBSUB)) {
6937 caps = gst_caps_new_empty_simple ("subpicture/x-dvd");
6938 ((GstMatroskaTrackContext *) subtitlecontext)->send_dvd_event = TRUE;
6939 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_HDMVPGS)) {
6940 caps = gst_caps_new_empty_simple ("subpicture/x-pgs");
6941 } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_KATE)) {
6942 caps = gst_caps_new_empty_simple ("subtitle/x-kate");
6943 context->stream_headers =
6944 gst_matroska_parse_xiph_stream_headers (context->codec_priv,
6945 context->codec_priv_size);
6946 /* FIXME: mark stream as broken and skip if there are no stream headers */
6947 context->send_stream_headers = TRUE;
6949 GST_DEBUG ("Unknown subtitle stream: codec_id='%s'", codec_id);
6950 caps = gst_caps_new_empty_simple ("application/x-subtitle-unknown");
6953 if (data != NULL && size > 0) {
6956 buf = gst_buffer_new_wrapped (g_memdup (data, size), size);
6957 gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
6958 gst_buffer_unref (buf);
6966 gst_matroska_demux_set_index (GstElement * element, GstIndex * index)
6968 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
6970 GST_OBJECT_LOCK (demux);
6971 if (demux->common.element_index)
6972 gst_object_unref (demux->common.element_index);
6973 demux->common.element_index = index ? gst_object_ref (index) : NULL;
6974 GST_OBJECT_UNLOCK (demux);
6975 GST_DEBUG_OBJECT (demux, "Set index %" GST_PTR_FORMAT,
6976 demux->common.element_index);
6980 gst_matroska_demux_get_index (GstElement * element)
6982 GstIndex *result = NULL;
6983 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
6985 GST_OBJECT_LOCK (demux);
6986 if (demux->common.element_index)
6987 result = gst_object_ref (demux->common.element_index);
6988 GST_OBJECT_UNLOCK (demux);
6990 GST_DEBUG_OBJECT (demux, "Returning index %" GST_PTR_FORMAT, result);
6996 static GstStateChangeReturn
6997 gst_matroska_demux_change_state (GstElement * element,
6998 GstStateChange transition)
7000 GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
7001 GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
7003 /* handle upwards state changes here */
7004 switch (transition) {
7009 ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
7011 /* handle downwards state changes */
7012 switch (transition) {
7013 case GST_STATE_CHANGE_PAUSED_TO_READY:
7014 gst_matroska_demux_reset (GST_ELEMENT (demux));
7024 gst_matroska_demux_set_property (GObject * object,
7025 guint prop_id, const GValue * value, GParamSpec * pspec)
7027 GstMatroskaDemux *demux;
7029 g_return_if_fail (GST_IS_MATROSKA_DEMUX (object));
7030 demux = GST_MATROSKA_DEMUX (object);
7033 case PROP_MAX_GAP_TIME:
7034 GST_OBJECT_LOCK (demux);
7035 demux->max_gap_time = g_value_get_uint64 (value);
7036 GST_OBJECT_UNLOCK (demux);
7038 case PROP_MAX_BACKTRACK_DISTANCE:
7039 GST_OBJECT_LOCK (demux);
7040 demux->max_backtrack_distance = g_value_get_uint (value);
7041 GST_OBJECT_UNLOCK (demux);
7044 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
7050 gst_matroska_demux_get_property (GObject * object,
7051 guint prop_id, GValue * value, GParamSpec * pspec)
7053 GstMatroskaDemux *demux;
7055 g_return_if_fail (GST_IS_MATROSKA_DEMUX (object));
7056 demux = GST_MATROSKA_DEMUX (object);
7059 case PROP_MAX_GAP_TIME:
7060 GST_OBJECT_LOCK (demux);
7061 g_value_set_uint64 (value, demux->max_gap_time);
7062 GST_OBJECT_UNLOCK (demux);
7064 case PROP_MAX_BACKTRACK_DISTANCE:
7065 GST_OBJECT_LOCK (demux);
7066 g_value_set_uint (value, demux->max_backtrack_distance);
7067 GST_OBJECT_UNLOCK (demux);
7070 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
7075 static const gchar *
7076 gst_matroska_track_encryption_algorithm_name (gint val)
7079 GEnumClass *enum_class =
7080 g_type_class_ref (MATROSKA_TRACK_ENCRYPTION_ALGORITHM_TYPE);
7081 en = g_enum_get_value (G_ENUM_CLASS (enum_class), val);
7082 return en ? en->value_nick : NULL;
7085 static const gchar *
7086 gst_matroska_track_encryption_cipher_mode_name (gint val)
7089 GEnumClass *enum_class =
7090 g_type_class_ref (MATROSKA_TRACK_ENCRYPTION_CIPHER_MODE_TYPE);
7091 en = g_enum_get_value (G_ENUM_CLASS (enum_class), val);
7092 return en ? en->value_nick : NULL;
7095 static const gchar *
7096 gst_matroska_track_encoding_scope_name (gint val)
7099 GEnumClass *enum_class =
7100 g_type_class_ref (MATROSKA_TRACK_ENCODING_SCOPE_TYPE);
7102 en = g_enum_get_value (G_ENUM_CLASS (enum_class), val);
7103 return en ? en->value_nick : NULL;
7107 gst_matroska_demux_plugin_init (GstPlugin * plugin)
7111 /* parser helper separate debug */
7112 GST_DEBUG_CATEGORY_INIT (ebmlread_debug, "ebmlread",
7113 0, "EBML stream helper class");
7115 /* create an elementfactory for the matroska_demux element */
7116 if (!gst_element_register (plugin, "matroskademux",
7117 GST_RANK_PRIMARY, GST_TYPE_MATROSKA_DEMUX))