matroska: refactor code common to matroskademux and matroskaparse
[gstreamer-omap:gst-plugins-good.git] / gst / matroska / matroska-demux.c
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>
6  *
7  * matroska-demux.c: matroska file/stream demuxer
8  *
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.
13  *
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.
18  *
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., 59 Temple Place - Suite 330,
22  * Boston, MA 02111-1307, USA.
23  */
24
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
32  */
33
34 /**
35  * SECTION:element-matroskademux
36  *
37  * matroskademux demuxes a Matroska file into the different contained streams.
38  *
39  * <refsect2>
40  * <title>Example launch line</title>
41  * |[
42  * gst-launch -v filesrc location=/path/to/mkv ! matroskademux ! vorbisdec ! audioconvert ! audioresample ! autoaudiosink
43  * ]| This pipeline demuxes a Matroska file and outputs the contained Vorbis audio.
44  * </refsect2>
45  */
46
47
48 #ifdef HAVE_CONFIG_H
49 #include "config.h"
50 #endif
51
52 #include <math.h>
53 #include <string.h>
54 #include <glib/gprintf.h>
55
56 /* For AVI compatibility mode
57    and for fourcc stuff */
58 #include <gst/riff/riff-read.h>
59 #include <gst/riff/riff-ids.h>
60 #include <gst/riff/riff-media.h>
61
62 #include <gst/tag/tag.h>
63
64 #include <gst/base/gsttypefindhelper.h>
65
66 #include <gst/pbutils/pbutils.h>
67
68 #include "matroska-demux.h"
69 #include "matroska-ids.h"
70
71 GST_DEBUG_CATEGORY_STATIC (matroskademux_debug);
72 #define GST_CAT_DEFAULT matroskademux_debug
73
74 #define DEBUG_ELEMENT_START(demux, ebml, element) \
75     GST_DEBUG_OBJECT (demux, "Parsing " element " element at offset %" \
76         G_GUINT64_FORMAT, gst_ebml_read_get_pos (ebml))
77
78 #define DEBUG_ELEMENT_STOP(demux, ebml, element, ret) \
79     GST_DEBUG_OBJECT (demux, "Parsing " element " element " \
80         " finished with '%s'", gst_flow_get_name (ret))
81
82 enum
83 {
84   ARG_0,
85   ARG_METADATA,
86   ARG_STREAMINFO
87 };
88
89 static GstStaticPadTemplate sink_templ = GST_STATIC_PAD_TEMPLATE ("sink",
90     GST_PAD_SINK,
91     GST_PAD_ALWAYS,
92     GST_STATIC_CAPS ("video/x-matroska; video/webm")
93     );
94
95 /* TODO: fill in caps! */
96
97 static GstStaticPadTemplate audio_src_templ =
98 GST_STATIC_PAD_TEMPLATE ("audio_%02d",
99     GST_PAD_SRC,
100     GST_PAD_SOMETIMES,
101     GST_STATIC_CAPS ("ANY")
102     );
103
104 static GstStaticPadTemplate video_src_templ =
105 GST_STATIC_PAD_TEMPLATE ("video_%02d",
106     GST_PAD_SRC,
107     GST_PAD_SOMETIMES,
108     GST_STATIC_CAPS ("ANY")
109     );
110
111 static GstStaticPadTemplate subtitle_src_templ =
112     GST_STATIC_PAD_TEMPLATE ("subtitle_%02d",
113     GST_PAD_SRC,
114     GST_PAD_SOMETIMES,
115     GST_STATIC_CAPS ("text/x-pango-markup; application/x-ssa; "
116         "application/x-ass;application/x-usf; video/x-dvd-subpicture; "
117         "subpicture/x-pgs; subtitle/x-kate; " "application/x-subtitle-unknown")
118     );
119
120 static GstFlowReturn gst_matroska_demux_parse_id (GstMatroskaDemux * demux,
121     guint32 id, guint64 length, guint needed);
122
123 /* element functions */
124 static void gst_matroska_demux_loop (GstPad * pad);
125
126 static gboolean gst_matroska_demux_element_send_event (GstElement * element,
127     GstEvent * event);
128 static gboolean gst_matroska_demux_element_query (GstElement * element,
129     GstQuery * query);
130
131 /* pad functions */
132 static gboolean gst_matroska_demux_sink_activate_pull (GstPad * sinkpad,
133     gboolean active);
134 static gboolean gst_matroska_demux_sink_activate (GstPad * sinkpad);
135
136 static gboolean gst_matroska_demux_handle_seek_event (GstMatroskaDemux * demux,
137     GstPad * pad, GstEvent * event);
138 static gboolean gst_matroska_demux_handle_src_event (GstPad * pad,
139     GstEvent * event);
140 static const GstQueryType *gst_matroska_demux_get_src_query_types (GstPad *
141     pad);
142 static gboolean gst_matroska_demux_handle_src_query (GstPad * pad,
143     GstQuery * query);
144
145 static gboolean gst_matroska_demux_handle_sink_event (GstPad * pad,
146     GstEvent * event);
147 static GstFlowReturn gst_matroska_demux_chain (GstPad * pad,
148     GstBuffer * buffer);
149
150 static GstStateChangeReturn
151 gst_matroska_demux_change_state (GstElement * element,
152     GstStateChange transition);
153 static void
154 gst_matroska_demux_set_index (GstElement * element, GstIndex * index);
155 static GstIndex *gst_matroska_demux_get_index (GstElement * element);
156
157 /* caps functions */
158 static GstCaps *gst_matroska_demux_video_caps (GstMatroskaTrackVideoContext
159     * videocontext, const gchar * codec_id, guint8 * data, guint size,
160     gchar ** codec_name, guint32 * riff_fourcc);
161 static GstCaps *gst_matroska_demux_audio_caps (GstMatroskaTrackAudioContext
162     * audiocontext, const gchar * codec_id, guint8 * data, guint size,
163     gchar ** codec_name, guint16 * riff_audio_fmt);
164 static GstCaps
165     * gst_matroska_demux_subtitle_caps (GstMatroskaTrackSubtitleContext *
166     subtitlecontext, const gchar * codec_id, gpointer data, guint size);
167
168 /* stream methods */
169 static void gst_matroska_demux_reset (GstElement * element);
170 static gboolean perform_seek_to_offset (GstMatroskaDemux * demux,
171     guint64 offset);
172
173 GType gst_matroska_demux_get_type (void);
174 GST_BOILERPLATE (GstMatroskaDemux, gst_matroska_demux, GstElement,
175     GST_TYPE_ELEMENT);
176
177 static void
178 gst_matroska_demux_base_init (gpointer klass)
179 {
180   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
181
182   gst_element_class_add_pad_template (element_class,
183       gst_static_pad_template_get (&video_src_templ));
184   gst_element_class_add_pad_template (element_class,
185       gst_static_pad_template_get (&audio_src_templ));
186   gst_element_class_add_pad_template (element_class,
187       gst_static_pad_template_get (&subtitle_src_templ));
188   gst_element_class_add_pad_template (element_class,
189       gst_static_pad_template_get (&sink_templ));
190
191   gst_element_class_set_details_simple (element_class, "Matroska demuxer",
192       "Codec/Demuxer",
193       "Demuxes Matroska/WebM streams into video/audio/subtitles",
194       "GStreamer maintainers <gstreamer-devel@lists.sourceforge.net>");
195 }
196
197 static void
198 gst_matroska_demux_finalize (GObject * object)
199 {
200   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (object);
201
202   if (demux->common.src) {
203     g_ptr_array_free (demux->common.src, TRUE);
204     demux->common.src = NULL;
205   }
206
207   if (demux->global_tags) {
208     gst_tag_list_free (demux->global_tags);
209     demux->global_tags = NULL;
210   }
211
212   g_object_unref (demux->common.adapter);
213
214   G_OBJECT_CLASS (parent_class)->finalize (object);
215 }
216
217 static void
218 gst_matroska_demux_class_init (GstMatroskaDemuxClass * klass)
219 {
220   GObjectClass *gobject_class = (GObjectClass *) klass;
221   GstElementClass *gstelement_class = (GstElementClass *) klass;
222
223   GST_DEBUG_CATEGORY_INIT (matroskademux_debug, "matroskademux", 0,
224       "Matroska demuxer");
225
226   gobject_class->finalize = gst_matroska_demux_finalize;
227
228   gstelement_class->change_state =
229       GST_DEBUG_FUNCPTR (gst_matroska_demux_change_state);
230   gstelement_class->send_event =
231       GST_DEBUG_FUNCPTR (gst_matroska_demux_element_send_event);
232   gstelement_class->query =
233       GST_DEBUG_FUNCPTR (gst_matroska_demux_element_query);
234
235   gstelement_class->set_index =
236       GST_DEBUG_FUNCPTR (gst_matroska_demux_set_index);
237   gstelement_class->get_index =
238       GST_DEBUG_FUNCPTR (gst_matroska_demux_get_index);
239 }
240
241 static void
242 gst_matroska_demux_init (GstMatroskaDemux * demux,
243     GstMatroskaDemuxClass * klass)
244 {
245   demux->common.sinkpad = gst_pad_new_from_static_template (&sink_templ,
246       "sink");
247   gst_pad_set_activate_function (demux->common.sinkpad,
248       GST_DEBUG_FUNCPTR (gst_matroska_demux_sink_activate));
249   gst_pad_set_activatepull_function (demux->common.sinkpad,
250       GST_DEBUG_FUNCPTR (gst_matroska_demux_sink_activate_pull));
251   gst_pad_set_chain_function (demux->common.sinkpad,
252       GST_DEBUG_FUNCPTR (gst_matroska_demux_chain));
253   gst_pad_set_event_function (demux->common.sinkpad,
254       GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_sink_event));
255   gst_element_add_pad (GST_ELEMENT (demux), demux->common.sinkpad);
256
257   /* initial stream no. */
258   demux->common.src = NULL;
259
260   demux->writing_app = NULL;
261   demux->muxing_app = NULL;
262   demux->common.index = NULL;
263   demux->global_tags = NULL;
264
265   demux->common.adapter = gst_adapter_new ();
266
267   /* finish off */
268   gst_matroska_demux_reset (GST_ELEMENT (demux));
269 }
270
271 static void
272 gst_matroska_track_free (GstMatroskaTrackContext * track)
273 {
274   g_free (track->codec_id);
275   g_free (track->codec_name);
276   g_free (track->name);
277   g_free (track->language);
278   g_free (track->codec_priv);
279   g_free (track->codec_state);
280
281   if (track->encodings != NULL) {
282     int i;
283
284     for (i = 0; i < track->encodings->len; ++i) {
285       GstMatroskaTrackEncoding *enc = &g_array_index (track->encodings,
286           GstMatroskaTrackEncoding,
287           i);
288
289       g_free (enc->comp_settings);
290     }
291     g_array_free (track->encodings, TRUE);
292   }
293
294   if (track->pending_tags)
295     gst_tag_list_free (track->pending_tags);
296
297   if (track->index_table)
298     g_array_free (track->index_table, TRUE);
299
300   g_free (track);
301 }
302
303 /*
304  * Returns the aggregated GstFlowReturn.
305  */
306 static GstFlowReturn
307 gst_matroska_demux_combine_flows (GstMatroskaDemux * demux,
308     GstMatroskaTrackContext * track, GstFlowReturn ret)
309 {
310   guint i;
311
312   /* store the value */
313   track->last_flow = ret;
314
315   /* any other error that is not-linked can be returned right away */
316   if (ret != GST_FLOW_NOT_LINKED)
317     goto done;
318
319   /* only return NOT_LINKED if all other pads returned NOT_LINKED */
320   g_assert (demux->common.src->len == demux->common.num_streams);
321   for (i = 0; i < demux->common.src->len; i++) {
322     GstMatroskaTrackContext *ostream = g_ptr_array_index (demux->common.src,
323         i);
324
325     if (ostream == NULL)
326       continue;
327
328     ret = ostream->last_flow;
329     /* some other return value (must be SUCCESS but we can return
330      * other values as well) */
331     if (ret != GST_FLOW_NOT_LINKED)
332       goto done;
333   }
334   /* if we get here, all other pads were unlinked and we return
335    * NOT_LINKED then */
336 done:
337   GST_LOG_OBJECT (demux, "combined return %s", gst_flow_get_name (ret));
338   return ret;
339 }
340
341 static void
342 gst_matroska_demux_free_parsed_el (gpointer mem, gpointer user_data)
343 {
344   g_slice_free (guint64, mem);
345 }
346
347 static void
348 gst_matroska_demux_reset (GstElement * element)
349 {
350   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
351   guint i;
352
353   GST_DEBUG_OBJECT (demux, "Resetting state");
354
355   /* reset input */
356   demux->common.state = GST_MATROSKA_READ_STATE_START;
357
358   /* clean up existing streams */
359   if (demux->common.src) {
360     g_assert (demux->common.src->len == demux->common.num_streams);
361     for (i = 0; i < demux->common.src->len; i++) {
362       GstMatroskaTrackContext *context = g_ptr_array_index (demux->common.src,
363           i);
364
365       if (context->pad != NULL)
366         gst_element_remove_pad (GST_ELEMENT (demux), context->pad);
367
368       gst_caps_replace (&context->caps, NULL);
369       gst_matroska_track_free (context);
370     }
371     g_ptr_array_free (demux->common.src, TRUE);
372   }
373   demux->common.src = g_ptr_array_new ();
374
375   demux->common.num_streams = 0;
376   demux->num_a_streams = 0;
377   demux->num_t_streams = 0;
378   demux->num_v_streams = 0;
379
380   /* reset media info */
381   g_free (demux->writing_app);
382   demux->writing_app = NULL;
383   g_free (demux->muxing_app);
384   demux->muxing_app = NULL;
385
386   /* reset indexes */
387   if (demux->common.index) {
388     g_array_free (demux->common.index, TRUE);
389     demux->common.index = NULL;
390   }
391
392   if (demux->clusters) {
393     g_array_free (demux->clusters, TRUE);
394     demux->clusters = NULL;
395   }
396
397   /* reset timers */
398   demux->clock = NULL;
399   demux->common.time_scale = 1000000;
400   demux->created = G_MININT64;
401
402   demux->common.index_parsed = FALSE;
403   demux->tracks_parsed = FALSE;
404   demux->segmentinfo_parsed = FALSE;
405   demux->attachments_parsed = FALSE;
406
407   g_list_foreach (demux->tags_parsed,
408       (GFunc) gst_matroska_demux_free_parsed_el, NULL);
409   g_list_free (demux->tags_parsed);
410   demux->tags_parsed = NULL;
411
412   g_list_foreach (demux->seek_parsed,
413       (GFunc) gst_matroska_demux_free_parsed_el, NULL);
414   g_list_free (demux->seek_parsed);
415   demux->seek_parsed = NULL;
416
417   gst_segment_init (&demux->segment, GST_FORMAT_TIME);
418   demux->last_stop_end = GST_CLOCK_TIME_NONE;
419   demux->seek_block = 0;
420
421   demux->common.offset = 0;
422   demux->cluster_time = GST_CLOCK_TIME_NONE;
423   demux->cluster_offset = 0;
424   demux->next_cluster_offset = 0;
425   demux->index_offset = 0;
426   demux->seekable = FALSE;
427   demux->need_newsegment = FALSE;
428   demux->building_index = FALSE;
429   if (demux->seek_event) {
430     gst_event_unref (demux->seek_event);
431     demux->seek_event = NULL;
432   }
433
434   demux->seek_index = NULL;
435   demux->seek_entry = 0;
436
437   if (demux->close_segment) {
438     gst_event_unref (demux->close_segment);
439     demux->close_segment = NULL;
440   }
441
442   if (demux->new_segment) {
443     gst_event_unref (demux->new_segment);
444     demux->new_segment = NULL;
445   }
446
447   if (demux->common.element_index) {
448     gst_object_unref (demux->common.element_index);
449     demux->common.element_index = NULL;
450   }
451   demux->common.element_index_writer_id = -1;
452
453   if (demux->global_tags) {
454     gst_tag_list_free (demux->global_tags);
455   }
456   demux->global_tags = gst_tag_list_new ();
457
458   if (demux->common.cached_buffer) {
459     gst_buffer_unref (demux->common.cached_buffer);
460     demux->common.cached_buffer = NULL;
461   }
462 }
463
464 static gboolean
465 gst_matroska_decode_data (GArray * encodings, guint8 ** data_out,
466     guint * size_out, GstMatroskaTrackEncodingScope scope, gboolean free)
467 {
468   guint8 *data;
469   guint size;
470   gboolean ret = TRUE;
471   gint i;
472
473   g_return_val_if_fail (encodings != NULL, FALSE);
474   g_return_val_if_fail (data_out != NULL && *data_out != NULL, FALSE);
475   g_return_val_if_fail (size_out != NULL, FALSE);
476
477   data = *data_out;
478   size = *size_out;
479
480   for (i = 0; i < encodings->len; i++) {
481     GstMatroskaTrackEncoding *enc =
482         &g_array_index (encodings, GstMatroskaTrackEncoding, i);
483     guint8 *new_data = NULL;
484     guint new_size = 0;
485
486     if ((enc->scope & scope) == 0)
487       continue;
488
489     /* Encryption not supported yet */
490     if (enc->type != 0) {
491       ret = FALSE;
492       break;
493     }
494
495     new_data = data;
496     new_size = size;
497
498     ret =
499         gst_matroska_decompress_data (enc, &new_data, &new_size,
500         enc->comp_algo);
501
502     if (!ret)
503       break;
504
505     if ((data == *data_out && free) || (data != *data_out))
506       g_free (data);
507
508     data = new_data;
509     size = new_size;
510   }
511
512   if (!ret) {
513     if ((data == *data_out && free) || (data != *data_out))
514       g_free (data);
515
516     *data_out = NULL;
517     *size_out = 0;
518   } else {
519     *data_out = data;
520     *size_out = size;
521   }
522
523   return ret;
524 }
525
526 static GstBuffer *
527 gst_matroska_decode_buffer (GstMatroskaTrackContext * context, GstBuffer * buf)
528 {
529   guint8 *data;
530   guint size;
531   GstBuffer *new_buf;
532
533   g_return_val_if_fail (GST_IS_BUFFER (buf), NULL);
534
535   GST_DEBUG ("decoding buffer %p", buf);
536
537   data = GST_BUFFER_DATA (buf);
538   size = GST_BUFFER_SIZE (buf);
539
540   g_return_val_if_fail (data != NULL && size > 0, buf);
541
542   if (gst_matroska_decode_data (context->encodings, &data, &size,
543           GST_MATROSKA_TRACK_ENCODING_SCOPE_FRAME, FALSE)) {
544     new_buf = gst_buffer_new ();
545     GST_BUFFER_MALLOCDATA (new_buf) = (guint8 *) data;
546     GST_BUFFER_DATA (new_buf) = (guint8 *) data;
547     GST_BUFFER_SIZE (new_buf) = size;
548
549     gst_buffer_unref (buf);
550     buf = new_buf;
551
552     return buf;
553   } else {
554     GST_DEBUG ("decode data failed");
555     gst_buffer_unref (buf);
556     return NULL;
557   }
558 }
559
560 static gboolean
561 gst_matroska_demux_tracknumber_unique (GstMatroskaDemux * demux, guint64 num)
562 {
563   gint i;
564
565   g_assert (demux->common.src->len == demux->common.num_streams);
566   for (i = 0; i < demux->common.src->len; i++) {
567     GstMatroskaTrackContext *context = g_ptr_array_index (demux->common.src,
568         i);
569
570     if (context->num == num)
571       return FALSE;
572   }
573
574   return TRUE;
575 }
576
577 static GstFlowReturn
578 gst_matroska_demux_add_stream (GstMatroskaDemux * demux, GstEbmlRead * ebml)
579 {
580   GstElementClass *klass = GST_ELEMENT_GET_CLASS (demux);
581   GstMatroskaTrackContext *context;
582   GstPadTemplate *templ = NULL;
583   GstCaps *caps = NULL;
584   gchar *padname = NULL;
585   GstFlowReturn ret;
586   guint32 id, riff_fourcc = 0;
587   guint16 riff_audio_fmt = 0;
588   GstTagList *list = NULL;
589   gchar *codec = NULL;
590
591   DEBUG_ELEMENT_START (demux, ebml, "TrackEntry");
592
593   /* start with the master */
594   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
595     DEBUG_ELEMENT_STOP (demux, ebml, "TrackEntry", ret);
596     return ret;
597   }
598
599   /* allocate generic... if we know the type, we'll g_renew()
600    * with the precise type */
601   context = g_new0 (GstMatroskaTrackContext, 1);
602   g_ptr_array_add (demux->common.src, context);
603   context->index = demux->common.num_streams;
604   context->index_writer_id = -1;
605   context->type = 0;            /* no type yet */
606   context->default_duration = 0;
607   context->pos = 0;
608   context->set_discont = TRUE;
609   context->timecodescale = 1.0;
610   context->flags =
611       GST_MATROSKA_TRACK_ENABLED | GST_MATROSKA_TRACK_DEFAULT |
612       GST_MATROSKA_TRACK_LACING;
613   context->last_flow = GST_FLOW_OK;
614   context->to_offset = G_MAXINT64;
615   demux->common.num_streams++;
616   g_assert (demux->common.src->len == demux->common.num_streams);
617
618   GST_DEBUG_OBJECT (demux, "Stream number %d", context->index);
619
620   /* try reading the trackentry headers */
621   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
622     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
623       break;
624
625     switch (id) {
626         /* track number (unique stream ID) */
627       case GST_MATROSKA_ID_TRACKNUMBER:{
628         guint64 num;
629
630         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
631           break;
632
633         if (num == 0) {
634           GST_ERROR_OBJECT (demux, "Invalid TrackNumber 0");
635           ret = GST_FLOW_ERROR;
636           break;
637         } else if (!gst_matroska_demux_tracknumber_unique (demux, num)) {
638           GST_ERROR_OBJECT (demux, "TrackNumber %" G_GUINT64_FORMAT
639               " is not unique", num);
640           ret = GST_FLOW_ERROR;
641           break;
642         }
643
644         GST_DEBUG_OBJECT (demux, "TrackNumber: %" G_GUINT64_FORMAT, num);
645         context->num = num;
646         break;
647       }
648         /* track UID (unique identifier) */
649       case GST_MATROSKA_ID_TRACKUID:{
650         guint64 num;
651
652         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
653           break;
654
655         if (num == 0) {
656           GST_ERROR_OBJECT (demux, "Invalid TrackUID 0");
657           ret = GST_FLOW_ERROR;
658           break;
659         }
660
661         GST_DEBUG_OBJECT (demux, "TrackUID: %" G_GUINT64_FORMAT, num);
662         context->uid = num;
663         break;
664       }
665
666         /* track type (video, audio, combined, subtitle, etc.) */
667       case GST_MATROSKA_ID_TRACKTYPE:{
668         guint64 track_type;
669
670         if ((ret = gst_ebml_read_uint (ebml, &id, &track_type)) != GST_FLOW_OK) {
671           break;
672         }
673
674         if (context->type != 0 && context->type != track_type) {
675           GST_WARNING_OBJECT (demux,
676               "More than one tracktype defined in a TrackEntry - skipping");
677           break;
678         } else if (track_type < 1 || track_type > 254) {
679           GST_WARNING_OBJECT (demux, "Invalid TrackType %" G_GUINT64_FORMAT,
680               track_type);
681           break;
682         }
683
684         GST_DEBUG_OBJECT (demux, "TrackType: %" G_GUINT64_FORMAT, track_type);
685
686         /* ok, so we're actually going to reallocate this thing */
687         switch (track_type) {
688           case GST_MATROSKA_TRACK_TYPE_VIDEO:
689             gst_matroska_track_init_video_context (&context);
690             break;
691           case GST_MATROSKA_TRACK_TYPE_AUDIO:
692             gst_matroska_track_init_audio_context (&context);
693             break;
694           case GST_MATROSKA_TRACK_TYPE_SUBTITLE:
695             gst_matroska_track_init_subtitle_context (&context);
696             break;
697           case GST_MATROSKA_TRACK_TYPE_COMPLEX:
698           case GST_MATROSKA_TRACK_TYPE_LOGO:
699           case GST_MATROSKA_TRACK_TYPE_BUTTONS:
700           case GST_MATROSKA_TRACK_TYPE_CONTROL:
701           default:
702             GST_WARNING_OBJECT (demux,
703                 "Unknown or unsupported TrackType %" G_GUINT64_FORMAT,
704                 track_type);
705             context->type = 0;
706             break;
707         }
708         g_ptr_array_index (demux->common.src, demux->common.num_streams - 1)
709             = context;
710         break;
711       }
712
713         /* tracktype specific stuff for video */
714       case GST_MATROSKA_ID_TRACKVIDEO:{
715         GstMatroskaTrackVideoContext *videocontext;
716
717         DEBUG_ELEMENT_START (demux, ebml, "TrackVideo");
718
719         if (!gst_matroska_track_init_video_context (&context)) {
720           GST_WARNING_OBJECT (demux,
721               "TrackVideo element in non-video track - ignoring track");
722           ret = GST_FLOW_ERROR;
723           break;
724         } else if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
725           break;
726         }
727         videocontext = (GstMatroskaTrackVideoContext *) context;
728         g_ptr_array_index (demux->common.src, demux->common.num_streams - 1)
729             = context;
730
731         while (ret == GST_FLOW_OK &&
732             gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
733           if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
734             break;
735
736           switch (id) {
737               /* Should be one level up but some broken muxers write it here. */
738             case GST_MATROSKA_ID_TRACKDEFAULTDURATION:{
739               guint64 num;
740
741               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
742                 break;
743
744               if (num == 0) {
745                 GST_WARNING_OBJECT (demux, "Invalid TrackDefaultDuration 0");
746                 break;
747               }
748
749               GST_DEBUG_OBJECT (demux,
750                   "TrackDefaultDuration: %" G_GUINT64_FORMAT, num);
751               context->default_duration = num;
752               break;
753             }
754
755               /* video framerate */
756               /* NOTE: This one is here only for backward compatibility.
757                * Use _TRACKDEFAULDURATION one level up. */
758             case GST_MATROSKA_ID_VIDEOFRAMERATE:{
759               gdouble num;
760
761               if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK)
762                 break;
763
764               if (num <= 0.0) {
765                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoFPS %lf", num);
766                 break;
767               }
768
769               GST_DEBUG_OBJECT (demux, "TrackVideoFrameRate: %lf", num);
770               if (context->default_duration == 0)
771                 context->default_duration =
772                     gst_gdouble_to_guint64 ((gdouble) GST_SECOND * (1.0 / num));
773               videocontext->default_fps = num;
774               break;
775             }
776
777               /* width of the size to display the video at */
778             case GST_MATROSKA_ID_VIDEODISPLAYWIDTH:{
779               guint64 num;
780
781               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
782                 break;
783
784               if (num == 0) {
785                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoDisplayWidth 0");
786                 break;
787               }
788
789               GST_DEBUG_OBJECT (demux,
790                   "TrackVideoDisplayWidth: %" G_GUINT64_FORMAT, num);
791               videocontext->display_width = num;
792               break;
793             }
794
795               /* height of the size to display the video at */
796             case GST_MATROSKA_ID_VIDEODISPLAYHEIGHT:{
797               guint64 num;
798
799               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
800                 break;
801
802               if (num == 0) {
803                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoDisplayHeight 0");
804                 break;
805               }
806
807               GST_DEBUG_OBJECT (demux,
808                   "TrackVideoDisplayHeight: %" G_GUINT64_FORMAT, num);
809               videocontext->display_height = num;
810               break;
811             }
812
813               /* width of the video in the file */
814             case GST_MATROSKA_ID_VIDEOPIXELWIDTH:{
815               guint64 num;
816
817               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
818                 break;
819
820               if (num == 0) {
821                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoPixelWidth 0");
822                 break;
823               }
824
825               GST_DEBUG_OBJECT (demux,
826                   "TrackVideoPixelWidth: %" G_GUINT64_FORMAT, num);
827               videocontext->pixel_width = num;
828               break;
829             }
830
831               /* height of the video in the file */
832             case GST_MATROSKA_ID_VIDEOPIXELHEIGHT:{
833               guint64 num;
834
835               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
836                 break;
837
838               if (num == 0) {
839                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoPixelHeight 0");
840                 break;
841               }
842
843               GST_DEBUG_OBJECT (demux,
844                   "TrackVideoPixelHeight: %" G_GUINT64_FORMAT, num);
845               videocontext->pixel_height = num;
846               break;
847             }
848
849               /* whether the video is interlaced */
850             case GST_MATROSKA_ID_VIDEOFLAGINTERLACED:{
851               guint64 num;
852
853               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
854                 break;
855
856               if (num)
857                 context->flags |= GST_MATROSKA_VIDEOTRACK_INTERLACED;
858               else
859                 context->flags &= ~GST_MATROSKA_VIDEOTRACK_INTERLACED;
860               GST_DEBUG_OBJECT (demux, "TrackVideoInterlaced: %d",
861                   (context->flags & GST_MATROSKA_VIDEOTRACK_INTERLACED) ? 1 :
862                   0);
863               break;
864             }
865
866               /* aspect ratio behaviour */
867             case GST_MATROSKA_ID_VIDEOASPECTRATIOTYPE:{
868               guint64 num;
869
870               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
871                 break;
872
873               if (num != GST_MATROSKA_ASPECT_RATIO_MODE_FREE &&
874                   num != GST_MATROSKA_ASPECT_RATIO_MODE_KEEP &&
875                   num != GST_MATROSKA_ASPECT_RATIO_MODE_FIXED) {
876                 GST_WARNING_OBJECT (demux,
877                     "Unknown TrackVideoAspectRatioType 0x%x", (guint) num);
878                 break;
879               }
880               GST_DEBUG_OBJECT (demux,
881                   "TrackVideoAspectRatioType: %" G_GUINT64_FORMAT, num);
882               videocontext->asr_mode = num;
883               break;
884             }
885
886               /* colourspace (only matters for raw video) fourcc */
887             case GST_MATROSKA_ID_VIDEOCOLOURSPACE:{
888               guint8 *data;
889               guint64 datalen;
890
891               if ((ret =
892                       gst_ebml_read_binary (ebml, &id, &data,
893                           &datalen)) != GST_FLOW_OK)
894                 break;
895
896               if (datalen != 4) {
897                 g_free (data);
898                 GST_WARNING_OBJECT (demux,
899                     "Invalid TrackVideoColourSpace length %" G_GUINT64_FORMAT,
900                     datalen);
901                 break;
902               }
903
904               memcpy (&videocontext->fourcc, data, 4);
905               GST_DEBUG_OBJECT (demux,
906                   "TrackVideoColourSpace: %" GST_FOURCC_FORMAT,
907                   GST_FOURCC_ARGS (videocontext->fourcc));
908               g_free (data);
909               break;
910             }
911
912             default:
913               GST_WARNING_OBJECT (demux,
914                   "Unknown TrackVideo subelement 0x%x - ignoring", id);
915               /* fall through */
916             case GST_MATROSKA_ID_VIDEOSTEREOMODE:
917             case GST_MATROSKA_ID_VIDEODISPLAYUNIT:
918             case GST_MATROSKA_ID_VIDEOPIXELCROPBOTTOM:
919             case GST_MATROSKA_ID_VIDEOPIXELCROPTOP:
920             case GST_MATROSKA_ID_VIDEOPIXELCROPLEFT:
921             case GST_MATROSKA_ID_VIDEOPIXELCROPRIGHT:
922             case GST_MATROSKA_ID_VIDEOGAMMAVALUE:
923               ret = gst_ebml_read_skip (ebml);
924               break;
925           }
926         }
927
928         DEBUG_ELEMENT_STOP (demux, ebml, "TrackVideo", ret);
929         break;
930       }
931
932         /* tracktype specific stuff for audio */
933       case GST_MATROSKA_ID_TRACKAUDIO:{
934         GstMatroskaTrackAudioContext *audiocontext;
935
936         DEBUG_ELEMENT_START (demux, ebml, "TrackAudio");
937
938         if (!gst_matroska_track_init_audio_context (&context)) {
939           GST_WARNING_OBJECT (demux,
940               "TrackAudio element in non-audio track - ignoring track");
941           ret = GST_FLOW_ERROR;
942           break;
943         }
944
945         if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK)
946           break;
947
948         audiocontext = (GstMatroskaTrackAudioContext *) context;
949         g_ptr_array_index (demux->common.src, demux->common.num_streams - 1)
950             = context;
951
952         while (ret == GST_FLOW_OK &&
953             gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
954           if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
955             break;
956
957           switch (id) {
958               /* samplerate */
959             case GST_MATROSKA_ID_AUDIOSAMPLINGFREQ:{
960               gdouble num;
961
962               if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK)
963                 break;
964
965
966               if (num <= 0.0) {
967                 GST_WARNING_OBJECT (demux,
968                     "Invalid TrackAudioSamplingFrequency %lf", num);
969                 break;
970               }
971
972               GST_DEBUG_OBJECT (demux, "TrackAudioSamplingFrequency: %lf", num);
973               audiocontext->samplerate = num;
974               break;
975             }
976
977               /* bitdepth */
978             case GST_MATROSKA_ID_AUDIOBITDEPTH:{
979               guint64 num;
980
981               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
982                 break;
983
984               if (num == 0) {
985                 GST_WARNING_OBJECT (demux, "Invalid TrackAudioBitDepth 0");
986                 break;
987               }
988
989               GST_DEBUG_OBJECT (demux, "TrackAudioBitDepth: %" G_GUINT64_FORMAT,
990                   num);
991               audiocontext->bitdepth = num;
992               break;
993             }
994
995               /* channels */
996             case GST_MATROSKA_ID_AUDIOCHANNELS:{
997               guint64 num;
998
999               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1000                 break;
1001
1002               if (num == 0) {
1003                 GST_WARNING_OBJECT (demux, "Invalid TrackAudioChannels 0");
1004                 break;
1005               }
1006
1007               GST_DEBUG_OBJECT (demux, "TrackAudioChannels: %" G_GUINT64_FORMAT,
1008                   num);
1009               audiocontext->channels = num;
1010               break;
1011             }
1012
1013             default:
1014               GST_WARNING_OBJECT (demux,
1015                   "Unknown TrackAudio subelement 0x%x - ignoring", id);
1016               /* fall through */
1017             case GST_MATROSKA_ID_AUDIOCHANNELPOSITIONS:
1018             case GST_MATROSKA_ID_AUDIOOUTPUTSAMPLINGFREQ:
1019               ret = gst_ebml_read_skip (ebml);
1020               break;
1021           }
1022         }
1023
1024         DEBUG_ELEMENT_STOP (demux, ebml, "TrackAudio", ret);
1025
1026         break;
1027       }
1028
1029         /* codec identifier */
1030       case GST_MATROSKA_ID_CODECID:{
1031         gchar *text;
1032
1033         if ((ret = gst_ebml_read_ascii (ebml, &id, &text)) != GST_FLOW_OK)
1034           break;
1035
1036         GST_DEBUG_OBJECT (demux, "CodecID: %s", GST_STR_NULL (text));
1037         context->codec_id = text;
1038         break;
1039       }
1040
1041         /* codec private data */
1042       case GST_MATROSKA_ID_CODECPRIVATE:{
1043         guint8 *data;
1044         guint64 size;
1045
1046         if ((ret =
1047                 gst_ebml_read_binary (ebml, &id, &data, &size)) != GST_FLOW_OK)
1048           break;
1049
1050         context->codec_priv = data;
1051         context->codec_priv_size = size;
1052
1053         GST_DEBUG_OBJECT (demux, "CodecPrivate of size %" G_GUINT64_FORMAT,
1054             size);
1055         break;
1056       }
1057
1058         /* name of the codec */
1059       case GST_MATROSKA_ID_CODECNAME:{
1060         gchar *text;
1061
1062         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
1063           break;
1064
1065         GST_DEBUG_OBJECT (demux, "CodecName: %s", GST_STR_NULL (text));
1066         context->codec_name = text;
1067         break;
1068       }
1069
1070         /* name of this track */
1071       case GST_MATROSKA_ID_TRACKNAME:{
1072         gchar *text;
1073
1074         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
1075           break;
1076
1077         context->name = text;
1078         GST_DEBUG_OBJECT (demux, "TrackName: %s", GST_STR_NULL (text));
1079         break;
1080       }
1081
1082         /* language (matters for audio/subtitles, mostly) */
1083       case GST_MATROSKA_ID_TRACKLANGUAGE:{
1084         gchar *text;
1085
1086         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
1087           break;
1088
1089
1090         context->language = text;
1091
1092         /* fre-ca => fre */
1093         if (strlen (context->language) >= 4 && context->language[3] == '-')
1094           context->language[3] = '\0';
1095
1096         GST_DEBUG_OBJECT (demux, "TrackLanguage: %s",
1097             GST_STR_NULL (context->language));
1098         break;
1099       }
1100
1101         /* whether this is actually used */
1102       case GST_MATROSKA_ID_TRACKFLAGENABLED:{
1103         guint64 num;
1104
1105         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1106           break;
1107
1108         if (num)
1109           context->flags |= GST_MATROSKA_TRACK_ENABLED;
1110         else
1111           context->flags &= ~GST_MATROSKA_TRACK_ENABLED;
1112
1113         GST_DEBUG_OBJECT (demux, "TrackEnabled: %d",
1114             (context->flags & GST_MATROSKA_TRACK_ENABLED) ? 1 : 0);
1115         break;
1116       }
1117
1118         /* whether it's the default for this track type */
1119       case GST_MATROSKA_ID_TRACKFLAGDEFAULT:{
1120         guint64 num;
1121
1122         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1123           break;
1124
1125         if (num)
1126           context->flags |= GST_MATROSKA_TRACK_DEFAULT;
1127         else
1128           context->flags &= ~GST_MATROSKA_TRACK_DEFAULT;
1129
1130         GST_DEBUG_OBJECT (demux, "TrackDefault: %d",
1131             (context->flags & GST_MATROSKA_TRACK_ENABLED) ? 1 : 0);
1132         break;
1133       }
1134
1135         /* whether the track must be used during playback */
1136       case GST_MATROSKA_ID_TRACKFLAGFORCED:{
1137         guint64 num;
1138
1139         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1140           break;
1141
1142         if (num)
1143           context->flags |= GST_MATROSKA_TRACK_FORCED;
1144         else
1145           context->flags &= ~GST_MATROSKA_TRACK_FORCED;
1146
1147         GST_DEBUG_OBJECT (demux, "TrackForced: %d",
1148             (context->flags & GST_MATROSKA_TRACK_ENABLED) ? 1 : 0);
1149         break;
1150       }
1151
1152         /* lacing (like MPEG, where blocks don't end/start on frame
1153          * boundaries) */
1154       case GST_MATROSKA_ID_TRACKFLAGLACING:{
1155         guint64 num;
1156
1157         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1158           break;
1159
1160         if (num)
1161           context->flags |= GST_MATROSKA_TRACK_LACING;
1162         else
1163           context->flags &= ~GST_MATROSKA_TRACK_LACING;
1164
1165         GST_DEBUG_OBJECT (demux, "TrackLacing: %d",
1166             (context->flags & GST_MATROSKA_TRACK_ENABLED) ? 1 : 0);
1167         break;
1168       }
1169
1170         /* default length (in time) of one data block in this track */
1171       case GST_MATROSKA_ID_TRACKDEFAULTDURATION:{
1172         guint64 num;
1173
1174         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1175           break;
1176
1177
1178         if (num == 0) {
1179           GST_WARNING_OBJECT (demux, "Invalid TrackDefaultDuration 0");
1180           break;
1181         }
1182
1183         GST_DEBUG_OBJECT (demux, "TrackDefaultDuration: %" G_GUINT64_FORMAT,
1184             num);
1185         context->default_duration = num;
1186         break;
1187       }
1188
1189       case GST_MATROSKA_ID_CONTENTENCODINGS:{
1190         ret = gst_matroska_read_common_read_track_encodings (&demux->common,
1191             ebml, context);
1192         break;
1193       }
1194
1195       case GST_MATROSKA_ID_TRACKTIMECODESCALE:{
1196         gdouble num;
1197
1198         if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK)
1199           break;
1200
1201         if (num <= 0.0) {
1202           GST_WARNING_OBJECT (demux, "Invalid TrackTimeCodeScale %lf", num);
1203           break;
1204         }
1205
1206         GST_DEBUG_OBJECT (demux, "TrackTimeCodeScale: %lf", num);
1207         context->timecodescale = num;
1208         break;
1209       }
1210
1211       default:
1212         GST_WARNING ("Unknown TrackEntry subelement 0x%x - ignoring", id);
1213         /* pass-through */
1214
1215         /* we ignore these because they're nothing useful (i.e. crap)
1216          * or simply not implemented yet. */
1217       case GST_MATROSKA_ID_TRACKMINCACHE:
1218       case GST_MATROSKA_ID_TRACKMAXCACHE:
1219       case GST_MATROSKA_ID_MAXBLOCKADDITIONID:
1220       case GST_MATROSKA_ID_TRACKATTACHMENTLINK:
1221       case GST_MATROSKA_ID_TRACKOVERLAY:
1222       case GST_MATROSKA_ID_TRACKTRANSLATE:
1223       case GST_MATROSKA_ID_TRACKOFFSET:
1224       case GST_MATROSKA_ID_CODECSETTINGS:
1225       case GST_MATROSKA_ID_CODECINFOURL:
1226       case GST_MATROSKA_ID_CODECDOWNLOADURL:
1227       case GST_MATROSKA_ID_CODECDECODEALL:
1228         ret = gst_ebml_read_skip (ebml);
1229         break;
1230     }
1231   }
1232
1233   DEBUG_ELEMENT_STOP (demux, ebml, "TrackEntry", ret);
1234
1235   /* Decode codec private data if necessary */
1236   if (context->encodings && context->encodings->len > 0 && context->codec_priv
1237       && context->codec_priv_size > 0) {
1238     if (!gst_matroska_decode_data (context->encodings,
1239             &context->codec_priv, &context->codec_priv_size,
1240             GST_MATROSKA_TRACK_ENCODING_SCOPE_CODEC_DATA, TRUE)) {
1241       GST_WARNING_OBJECT (demux, "Decoding codec private data failed");
1242       ret = GST_FLOW_ERROR;
1243     }
1244   }
1245
1246   if (context->type == 0 || context->codec_id == NULL || (ret != GST_FLOW_OK
1247           && ret != GST_FLOW_UNEXPECTED)) {
1248     if (ret == GST_FLOW_OK || ret == GST_FLOW_UNEXPECTED)
1249       GST_WARNING_OBJECT (ebml, "Unknown stream/codec in track entry header");
1250
1251     demux->common.num_streams--;
1252     g_ptr_array_remove_index (demux->common.src, demux->common.num_streams);
1253     g_assert (demux->common.src->len == demux->common.num_streams);
1254     if (context) {
1255       gst_matroska_track_free (context);
1256     }
1257
1258     return ret;
1259   }
1260
1261   /* now create the GStreamer connectivity */
1262   switch (context->type) {
1263     case GST_MATROSKA_TRACK_TYPE_VIDEO:{
1264       GstMatroskaTrackVideoContext *videocontext =
1265           (GstMatroskaTrackVideoContext *) context;
1266
1267       padname = g_strdup_printf ("video_%02d", demux->num_v_streams++);
1268       templ = gst_element_class_get_pad_template (klass, "video_%02d");
1269       caps = gst_matroska_demux_video_caps (videocontext,
1270           context->codec_id, (guint8 *) context->codec_priv,
1271           context->codec_priv_size, &codec, &riff_fourcc);
1272
1273       if (codec) {
1274         list = gst_tag_list_new ();
1275         gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
1276             GST_TAG_VIDEO_CODEC, codec, NULL);
1277         g_free (codec);
1278       }
1279       break;
1280     }
1281
1282     case GST_MATROSKA_TRACK_TYPE_AUDIO:{
1283       GstMatroskaTrackAudioContext *audiocontext =
1284           (GstMatroskaTrackAudioContext *) context;
1285
1286       padname = g_strdup_printf ("audio_%02d", demux->num_a_streams++);
1287       templ = gst_element_class_get_pad_template (klass, "audio_%02d");
1288       caps = gst_matroska_demux_audio_caps (audiocontext,
1289           context->codec_id, context->codec_priv, context->codec_priv_size,
1290           &codec, &riff_audio_fmt);
1291
1292       if (codec) {
1293         list = gst_tag_list_new ();
1294         gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
1295             GST_TAG_AUDIO_CODEC, codec, NULL);
1296         g_free (codec);
1297       }
1298       break;
1299     }
1300
1301     case GST_MATROSKA_TRACK_TYPE_SUBTITLE:{
1302       GstMatroskaTrackSubtitleContext *subtitlecontext =
1303           (GstMatroskaTrackSubtitleContext *) context;
1304
1305       padname = g_strdup_printf ("subtitle_%02d", demux->num_t_streams++);
1306       templ = gst_element_class_get_pad_template (klass, "subtitle_%02d");
1307       caps = gst_matroska_demux_subtitle_caps (subtitlecontext,
1308           context->codec_id, context->codec_priv, context->codec_priv_size);
1309       break;
1310     }
1311
1312     case GST_MATROSKA_TRACK_TYPE_COMPLEX:
1313     case GST_MATROSKA_TRACK_TYPE_LOGO:
1314     case GST_MATROSKA_TRACK_TYPE_BUTTONS:
1315     case GST_MATROSKA_TRACK_TYPE_CONTROL:
1316     default:
1317       /* we should already have quit by now */
1318       g_assert_not_reached ();
1319   }
1320
1321   if ((context->language == NULL || *context->language == '\0') &&
1322       (context->type == GST_MATROSKA_TRACK_TYPE_AUDIO ||
1323           context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE)) {
1324     GST_LOG ("stream %d: language=eng (assuming default)", context->index);
1325     context->language = g_strdup ("eng");
1326   }
1327
1328   if (context->language) {
1329     const gchar *lang;
1330
1331     if (!list)
1332       list = gst_tag_list_new ();
1333
1334     /* Matroska contains ISO 639-2B codes, we want ISO 639-1 */
1335     lang = gst_tag_get_language_code (context->language);
1336     gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
1337         GST_TAG_LANGUAGE_CODE, (lang) ? lang : context->language, NULL);
1338   }
1339
1340   if (caps == NULL) {
1341     GST_WARNING_OBJECT (demux, "could not determine caps for stream with "
1342         "codec_id='%s'", context->codec_id);
1343     switch (context->type) {
1344       case GST_MATROSKA_TRACK_TYPE_VIDEO:
1345         caps = gst_caps_new_simple ("video/x-unknown", NULL);
1346         break;
1347       case GST_MATROSKA_TRACK_TYPE_AUDIO:
1348         caps = gst_caps_new_simple ("audio/x-unknown", NULL);
1349         break;
1350       case GST_MATROSKA_TRACK_TYPE_SUBTITLE:
1351         caps = gst_caps_new_simple ("application/x-subtitle-unknown", NULL);
1352         break;
1353       case GST_MATROSKA_TRACK_TYPE_COMPLEX:
1354       default:
1355         caps = gst_caps_new_simple ("application/x-matroska-unknown", NULL);
1356         break;
1357     }
1358     gst_caps_set_simple (caps, "codec-id", G_TYPE_STRING, context->codec_id,
1359         NULL);
1360
1361     /* add any unrecognised riff fourcc / audio format, but after codec-id */
1362     if (context->type == GST_MATROSKA_TRACK_TYPE_AUDIO && riff_audio_fmt != 0)
1363       gst_caps_set_simple (caps, "format", G_TYPE_INT, riff_audio_fmt, NULL);
1364     else if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO && riff_fourcc != 0)
1365       gst_caps_set_simple (caps, "fourcc", GST_TYPE_FOURCC, riff_fourcc, NULL);
1366   }
1367
1368   /* the pad in here */
1369   context->pad = gst_pad_new_from_template (templ, padname);
1370   context->caps = caps;
1371
1372   gst_pad_set_event_function (context->pad,
1373       GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_src_event));
1374   gst_pad_set_query_type_function (context->pad,
1375       GST_DEBUG_FUNCPTR (gst_matroska_demux_get_src_query_types));
1376   gst_pad_set_query_function (context->pad,
1377       GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_src_query));
1378
1379   GST_INFO_OBJECT (demux, "Adding pad '%s' with caps %" GST_PTR_FORMAT,
1380       padname, caps);
1381
1382   context->pending_tags = list;
1383
1384   gst_pad_set_element_private (context->pad, context);
1385
1386   gst_pad_use_fixed_caps (context->pad);
1387   gst_pad_set_caps (context->pad, context->caps);
1388   gst_pad_set_active (context->pad, TRUE);
1389   gst_element_add_pad (GST_ELEMENT (demux), context->pad);
1390
1391   g_free (padname);
1392
1393   /* tadaah! */
1394   return ret;
1395 }
1396
1397 static const GstQueryType *
1398 gst_matroska_demux_get_src_query_types (GstPad * pad)
1399 {
1400   static const GstQueryType query_types[] = {
1401     GST_QUERY_POSITION,
1402     GST_QUERY_DURATION,
1403     GST_QUERY_SEEKING,
1404     0
1405   };
1406
1407   return query_types;
1408 }
1409
1410 static gboolean
1411 gst_matroska_demux_query (GstMatroskaDemux * demux, GstPad * pad,
1412     GstQuery * query)
1413 {
1414   gboolean res = FALSE;
1415   GstMatroskaTrackContext *context = NULL;
1416
1417   if (pad) {
1418     context = gst_pad_get_element_private (pad);
1419   }
1420
1421   switch (GST_QUERY_TYPE (query)) {
1422     case GST_QUERY_POSITION:
1423     {
1424       GstFormat format;
1425
1426       gst_query_parse_position (query, &format, NULL);
1427
1428       if (format == GST_FORMAT_TIME) {
1429         GST_OBJECT_LOCK (demux);
1430         if (context)
1431           gst_query_set_position (query, GST_FORMAT_TIME, context->pos);
1432         else
1433           gst_query_set_position (query, GST_FORMAT_TIME,
1434               demux->segment.last_stop);
1435         GST_OBJECT_UNLOCK (demux);
1436       } else if (format == GST_FORMAT_DEFAULT && context
1437           && context->default_duration) {
1438         GST_OBJECT_LOCK (demux);
1439         gst_query_set_position (query, GST_FORMAT_DEFAULT,
1440             context->pos / context->default_duration);
1441         GST_OBJECT_UNLOCK (demux);
1442       } else {
1443         GST_DEBUG_OBJECT (demux,
1444             "only position query in TIME and DEFAULT format is supported");
1445       }
1446
1447       res = TRUE;
1448       break;
1449     }
1450     case GST_QUERY_DURATION:
1451     {
1452       GstFormat format;
1453
1454       gst_query_parse_duration (query, &format, NULL);
1455
1456       if (format == GST_FORMAT_TIME) {
1457         GST_OBJECT_LOCK (demux);
1458         gst_query_set_duration (query, GST_FORMAT_TIME,
1459             demux->segment.duration);
1460         GST_OBJECT_UNLOCK (demux);
1461       } else if (format == GST_FORMAT_DEFAULT && context
1462           && context->default_duration) {
1463         GST_OBJECT_LOCK (demux);
1464         gst_query_set_duration (query, GST_FORMAT_DEFAULT,
1465             demux->segment.duration / context->default_duration);
1466         GST_OBJECT_UNLOCK (demux);
1467       } else {
1468         GST_DEBUG_OBJECT (demux,
1469             "only duration query in TIME and DEFAULT format is supported");
1470       }
1471
1472       res = TRUE;
1473       break;
1474     }
1475
1476     case GST_QUERY_SEEKING:
1477     {
1478       GstFormat fmt;
1479
1480       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
1481       GST_OBJECT_LOCK (demux);
1482       if (fmt == GST_FORMAT_TIME) {
1483         gboolean seekable;
1484
1485         if (demux->streaming) {
1486           /* assuming we'll be able to get an index ... */
1487           seekable = demux->seekable;
1488         } else {
1489           seekable = TRUE;
1490         }
1491
1492         gst_query_set_seeking (query, GST_FORMAT_TIME, seekable,
1493             0, demux->segment.duration);
1494         res = TRUE;
1495       }
1496       GST_OBJECT_UNLOCK (demux);
1497       break;
1498     }
1499     default:
1500       res = gst_pad_query_default (pad, query);
1501       break;
1502   }
1503
1504   return res;
1505 }
1506
1507 static gboolean
1508 gst_matroska_demux_element_query (GstElement * element, GstQuery * query)
1509 {
1510   return gst_matroska_demux_query (GST_MATROSKA_DEMUX (element), NULL, query);
1511 }
1512
1513 static gboolean
1514 gst_matroska_demux_handle_src_query (GstPad * pad, GstQuery * query)
1515 {
1516   gboolean ret;
1517   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (gst_pad_get_parent (pad));
1518
1519   ret = gst_matroska_demux_query (demux, pad, query);
1520
1521   gst_object_unref (demux);
1522
1523   return ret;
1524 }
1525
1526 static gint
1527 gst_matroska_index_seek_find (GstMatroskaIndex * i1, GstClockTime * time,
1528     gpointer user_data)
1529 {
1530   if (i1->time < *time)
1531     return -1;
1532   else if (i1->time > *time)
1533     return 1;
1534   else
1535     return 0;
1536 }
1537
1538 static GstMatroskaIndex *
1539 gst_matroskademux_do_index_seek (GstMatroskaDemux * demux,
1540     GstMatroskaTrackContext * track, gint64 seek_pos, GArray ** _index,
1541     gint * _entry_index)
1542 {
1543   GstMatroskaIndex *entry = NULL;
1544   GArray *index;
1545
1546   if (!demux->common.index || !demux->common.index->len)
1547     return NULL;
1548
1549   /* find entry just before or at the requested position */
1550   if (track && track->index_table)
1551     index = track->index_table;
1552   else
1553     index = demux->common.index;
1554
1555   entry =
1556       gst_util_array_binary_search (index->data, index->len,
1557       sizeof (GstMatroskaIndex),
1558       (GCompareDataFunc) gst_matroska_index_seek_find, GST_SEARCH_MODE_BEFORE,
1559       &seek_pos, NULL);
1560
1561   if (entry == NULL)
1562     entry = &g_array_index (index, GstMatroskaIndex, 0);
1563
1564   if (_index)
1565     *_index = index;
1566   if (_entry_index)
1567     *_entry_index = entry - (GstMatroskaIndex *) index->data;
1568
1569   return entry;
1570 }
1571
1572 /* takes ownership of taglist */
1573 static void
1574 gst_matroska_demux_found_global_tag (GstMatroskaDemux * demux,
1575     GstTagList * taglist)
1576 {
1577   if (demux->global_tags) {
1578     /* nothing sent yet, add to cache */
1579     gst_tag_list_insert (demux->global_tags, taglist, GST_TAG_MERGE_APPEND);
1580     gst_tag_list_free (taglist);
1581   } else {
1582     /* hm, already sent, no need to cache and wait anymore */
1583     GST_DEBUG_OBJECT (demux, "Sending late global tags %" GST_PTR_FORMAT,
1584         taglist);
1585     gst_element_found_tags (GST_ELEMENT (demux), taglist);
1586   }
1587 }
1588
1589 /* returns FALSE if there are no pads to deliver event to,
1590  * otherwise TRUE (whatever the outcome of event sending),
1591  * takes ownership of the passed event! */
1592 static gboolean
1593 gst_matroska_demux_send_event (GstMatroskaDemux * demux, GstEvent * event)
1594 {
1595   gboolean is_newsegment;
1596   gboolean ret = FALSE;
1597   gint i;
1598
1599   g_return_val_if_fail (event != NULL, FALSE);
1600
1601   GST_DEBUG_OBJECT (demux, "Sending event of type %s to all source pads",
1602       GST_EVENT_TYPE_NAME (event));
1603
1604   is_newsegment = (GST_EVENT_TYPE (event) == GST_EVENT_NEWSEGMENT);
1605
1606   g_assert (demux->common.src->len == demux->common.num_streams);
1607   for (i = 0; i < demux->common.src->len; i++) {
1608     GstMatroskaTrackContext *stream;
1609
1610     stream = g_ptr_array_index (demux->common.src, i);
1611     gst_event_ref (event);
1612     gst_pad_push_event (stream->pad, event);
1613     ret = TRUE;
1614
1615     /* FIXME: send global tags before stream tags */
1616     if (G_UNLIKELY (is_newsegment && stream->pending_tags != NULL)) {
1617       GST_DEBUG_OBJECT (demux, "Sending pending_tags %p for pad %s:%s : %"
1618           GST_PTR_FORMAT, stream->pending_tags,
1619           GST_DEBUG_PAD_NAME (stream->pad), stream->pending_tags);
1620       gst_element_found_tags_for_pad (GST_ELEMENT (demux), stream->pad,
1621           stream->pending_tags);
1622       stream->pending_tags = NULL;
1623     }
1624   }
1625
1626   if (G_UNLIKELY (is_newsegment && demux->global_tags != NULL)) {
1627     gst_tag_list_add (demux->global_tags, GST_TAG_MERGE_REPLACE,
1628         GST_TAG_CONTAINER_FORMAT, "Matroska", NULL);
1629     GST_DEBUG_OBJECT (demux, "Sending global_tags %p : %" GST_PTR_FORMAT,
1630         demux->global_tags, demux->global_tags);
1631     gst_element_found_tags (GST_ELEMENT (demux), demux->global_tags);
1632     demux->global_tags = NULL;
1633   }
1634
1635   gst_event_unref (event);
1636   return ret;
1637 }
1638
1639 static gboolean
1640 gst_matroska_demux_element_send_event (GstElement * element, GstEvent * event)
1641 {
1642   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
1643   gboolean res;
1644
1645   g_return_val_if_fail (event != NULL, FALSE);
1646
1647   if (GST_EVENT_TYPE (event) == GST_EVENT_SEEK) {
1648     res = gst_matroska_demux_handle_seek_event (demux, NULL, event);
1649   } else {
1650     GST_WARNING_OBJECT (demux, "Unhandled event of type %s",
1651         GST_EVENT_TYPE_NAME (event));
1652     res = FALSE;
1653   }
1654   gst_event_unref (event);
1655   return res;
1656 }
1657
1658 /* determine track to seek in */
1659 static GstMatroskaTrackContext *
1660 gst_matroska_demux_get_seek_track (GstMatroskaDemux * demux,
1661     GstMatroskaTrackContext * track)
1662 {
1663   gint i;
1664
1665   if (track && track->type == GST_MATROSKA_TRACK_TYPE_VIDEO)
1666     return track;
1667
1668   for (i = 0; i < demux->common.src->len; i++) {
1669     GstMatroskaTrackContext *stream;
1670
1671     stream = g_ptr_array_index (demux->common.src, i);
1672     if (stream->type == GST_MATROSKA_TRACK_TYPE_VIDEO && stream->index_table)
1673       track = stream;
1674   }
1675
1676   return track;
1677 }
1678
1679 /* call with object lock held */
1680 static void
1681 gst_matroska_demux_reset_streams (GstMatroskaDemux * demux, GstClockTime time,
1682     gboolean full)
1683 {
1684   gint i;
1685
1686   GST_DEBUG_OBJECT (demux, "resetting stream state");
1687
1688   g_assert (demux->common.src->len == demux->common.num_streams);
1689   for (i = 0; i < demux->common.src->len; i++) {
1690     GstMatroskaTrackContext *context = g_ptr_array_index (demux->common.src,
1691         i);
1692     context->pos = time;
1693     context->set_discont = TRUE;
1694     context->eos = FALSE;
1695     context->from_time = GST_CLOCK_TIME_NONE;
1696     if (full)
1697       context->last_flow = GST_FLOW_OK;
1698     if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO) {
1699       GstMatroskaTrackVideoContext *videocontext =
1700           (GstMatroskaTrackVideoContext *) context;
1701       /* demux object lock held by caller */
1702       videocontext->earliest_time = GST_CLOCK_TIME_NONE;
1703     }
1704   }
1705 }
1706
1707 static gboolean
1708 gst_matroska_demux_move_to_entry (GstMatroskaDemux * demux,
1709     GstMatroskaIndex * entry, gboolean reset)
1710 {
1711   gint i;
1712
1713   GST_OBJECT_LOCK (demux);
1714
1715   /* seek (relative to matroska segment) */
1716   /* position might be invalid; will error when streaming resumes ... */
1717   demux->common.offset = entry->pos + demux->common.ebml_segment_start;
1718
1719   GST_DEBUG_OBJECT (demux, "Seeked to offset %" G_GUINT64_FORMAT ", block %d, "
1720       "time %" GST_TIME_FORMAT, entry->pos + demux->common.ebml_segment_start,
1721       entry->block, GST_TIME_ARGS (entry->time));
1722
1723   /* update the time */
1724   gst_matroska_demux_reset_streams (demux, entry->time, TRUE);
1725   demux->segment.last_stop = entry->time;
1726   demux->seek_block = entry->block;
1727   demux->seek_first = TRUE;
1728   demux->last_stop_end = GST_CLOCK_TIME_NONE;
1729
1730   for (i = 0; i < demux->common.src->len; i++) {
1731     GstMatroskaTrackContext *stream = g_ptr_array_index (demux->common.src, i);
1732
1733     if (reset) {
1734       stream->to_offset = G_MAXINT64;
1735     } else {
1736       if (stream->from_offset != -1)
1737         stream->to_offset = stream->from_offset;
1738     }
1739     stream->from_offset = -1;
1740   }
1741
1742   GST_OBJECT_UNLOCK (demux);
1743
1744   return TRUE;
1745 }
1746
1747 static gint
1748 gst_matroska_cluster_compare (gint64 * i1, gint64 * i2)
1749 {
1750   if (*i1 < *i2)
1751     return -1;
1752   else if (*i1 > *i2)
1753     return 1;
1754   else
1755     return 0;
1756 }
1757
1758 /* searches for a cluster start from @pos,
1759  * return GST_FLOW_OK and cluster position in @pos if found */
1760 static GstFlowReturn
1761 gst_matroska_demux_search_cluster (GstMatroskaDemux * demux, gint64 * pos)
1762 {
1763   gint64 newpos = *pos;
1764   gint64 orig_offset;
1765   GstFlowReturn ret = GST_FLOW_OK;
1766   const guint chunk = 64 * 1024;
1767   GstBuffer *buf = NULL;
1768   guint64 length;
1769   guint32 id;
1770   guint needed;
1771
1772   orig_offset = demux->common.offset;
1773
1774   GST_LOG_OBJECT (demux, "searching cluster following offset %" G_GINT64_FORMAT,
1775       *pos);
1776
1777   if (demux->clusters) {
1778     gint64 *cpos;
1779
1780     cpos = gst_util_array_binary_search (demux->clusters->data,
1781         demux->clusters->len, sizeof (gint64),
1782         (GCompareDataFunc) gst_matroska_cluster_compare,
1783         GST_SEARCH_MODE_AFTER, pos, NULL);
1784     /* sanity check */
1785     if (cpos) {
1786       GST_DEBUG_OBJECT (demux,
1787           "cluster reported at offset %" G_GINT64_FORMAT, *cpos);
1788       demux->common.offset = *cpos;
1789       ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
1790           GST_ELEMENT_CAST (demux), &id, &length, &needed);
1791       if (ret == GST_FLOW_OK && id == GST_MATROSKA_ID_CLUSTER) {
1792         newpos = *cpos;
1793         goto exit;
1794       }
1795     }
1796   }
1797
1798   /* read in at newpos and scan for ebml cluster id */
1799   while (1) {
1800     GstByteReader reader;
1801     gint cluster_pos;
1802
1803     ret = gst_pad_pull_range (demux->common.sinkpad, newpos, chunk, &buf);
1804     if (ret != GST_FLOW_OK)
1805       break;
1806     GST_DEBUG_OBJECT (demux, "read buffer size %d at offset %" G_GINT64_FORMAT,
1807         GST_BUFFER_SIZE (buf), newpos);
1808     gst_byte_reader_init_from_buffer (&reader, buf);
1809   resume:
1810     cluster_pos = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff,
1811         GST_MATROSKA_ID_CLUSTER, 0, gst_byte_reader_get_remaining (&reader));
1812     if (cluster_pos >= 0) {
1813       newpos += cluster_pos;
1814       /* prepare resuming at next byte */
1815       gst_byte_reader_skip (&reader, cluster_pos + 1);
1816       GST_DEBUG_OBJECT (demux,
1817           "found cluster ebml id at offset %" G_GINT64_FORMAT, newpos);
1818       /* extra checks whether we really sync'ed to a cluster:
1819        * - either it is the first and only cluster
1820        * - either there is a cluster after this one
1821        * - either cluster length is undefined
1822        */
1823       /* ok if first cluster (there may not a subsequent one) */
1824       if (newpos == demux->first_cluster_offset) {
1825         GST_DEBUG_OBJECT (demux, "cluster is first cluster -> OK");
1826         break;
1827       }
1828       demux->common.offset = newpos;
1829       ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
1830           GST_ELEMENT_CAST (demux), &id, &length, &needed);
1831       if (ret != GST_FLOW_OK)
1832         goto resume;
1833       g_assert (id == GST_MATROSKA_ID_CLUSTER);
1834       GST_DEBUG_OBJECT (demux, "cluster size %" G_GUINT64_FORMAT ", prefix %d",
1835           length, needed);
1836       /* ok if undefined length or first cluster */
1837       if (length == G_MAXUINT64) {
1838         GST_DEBUG_OBJECT (demux, "cluster has undefined length -> OK");
1839         break;
1840       }
1841       /* skip cluster */
1842       demux->common.offset += length + needed;
1843       ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
1844           GST_ELEMENT_CAST (demux), &id, &length, &needed);
1845       if (ret != GST_FLOW_OK)
1846         goto resume;
1847       GST_DEBUG_OBJECT (demux, "next element is %scluster",
1848           id == GST_MATROSKA_ID_CLUSTER ? "" : "not ");
1849       if (id == GST_MATROSKA_ID_CLUSTER)
1850         break;
1851       /* not ok, resume */
1852       goto resume;
1853     } else {
1854       /* partial cluster id may have been in tail of buffer */
1855       newpos += MAX (gst_byte_reader_get_remaining (&reader), 4) - 3;
1856       gst_buffer_unref (buf);
1857       buf = NULL;
1858     }
1859   }
1860
1861   if (buf) {
1862     gst_buffer_unref (buf);
1863     buf = NULL;
1864   }
1865
1866 exit:
1867   demux->common.offset = orig_offset;
1868   *pos = newpos;
1869   return ret;
1870 }
1871
1872 /* bisect and scan through file for cluster starting before @time,
1873  * returns fake index entry with corresponding info on cluster */
1874 static GstMatroskaIndex *
1875 gst_matroska_demux_search_pos (GstMatroskaDemux * demux, GstClockTime time)
1876 {
1877   GstMatroskaIndex *entry = NULL;
1878   GstMatroskaReadState current_state;
1879   GstClockTime otime, prev_cluster_time, current_cluster_time, cluster_time;
1880   gint64 opos, newpos, startpos = 0, current_offset;
1881   gint64 prev_cluster_offset = -1, current_cluster_offset, cluster_offset;
1882   const guint chunk = 64 * 1024;
1883   GstBuffer *buf = NULL;
1884   GstFlowReturn ret;
1885   guint64 length;
1886   guint32 id;
1887   guint needed;
1888
1889   /* (under)estimate new position, resync using cluster ebml id,
1890    * and scan forward to appropriate cluster
1891    * (and re-estimate if need to go backward) */
1892
1893   prev_cluster_time = GST_CLOCK_TIME_NONE;
1894
1895   /* store some current state */
1896   current_state = demux->common.state;
1897   g_return_val_if_fail (current_state == GST_MATROSKA_READ_STATE_DATA, NULL);
1898
1899   current_cluster_offset = demux->cluster_offset;
1900   current_cluster_time = demux->cluster_time;
1901   current_offset = demux->common.offset;
1902
1903   demux->common.state = GST_MATROSKA_READ_STATE_SCANNING;
1904
1905   /* estimate using start and current position */
1906   GST_OBJECT_LOCK (demux);
1907   opos = demux->common.offset - demux->common.ebml_segment_start;
1908   otime = demux->segment.last_stop;
1909   GST_OBJECT_UNLOCK (demux);
1910
1911 retry:
1912   GST_LOG_OBJECT (demux,
1913       "opos: %" G_GUINT64_FORMAT ", otime: %" GST_TIME_FORMAT, opos,
1914       GST_TIME_ARGS (otime));
1915   newpos = gst_util_uint64_scale (opos, time, otime) - chunk;
1916   if (newpos < 0)
1917     newpos = 0;
1918   /* favour undershoot */
1919   newpos = newpos * 90 / 100;
1920   newpos += demux->common.ebml_segment_start;
1921
1922   GST_DEBUG_OBJECT (demux,
1923       "estimated offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT,
1924       GST_TIME_ARGS (time), newpos);
1925
1926   /* and at least start scanning before previous scan start to avoid looping */
1927   startpos = startpos * 90 / 100;
1928   if (startpos && startpos < newpos)
1929     newpos = startpos;
1930
1931   /* read in at newpos and scan for ebml cluster id */
1932   startpos = newpos;
1933   while (1) {
1934
1935     ret = gst_matroska_demux_search_cluster (demux, &newpos);
1936     if (ret == GST_FLOW_UNEXPECTED) {
1937       /* heuristic HACK */
1938       newpos = startpos * 80 / 100;
1939       GST_DEBUG_OBJECT (demux, "EOS; "
1940           "new estimated offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT,
1941           GST_TIME_ARGS (time), newpos);
1942       startpos = newpos;
1943       continue;
1944     } else if (ret != GST_FLOW_OK) {
1945       goto exit;
1946     } else {
1947       break;
1948     }
1949   }
1950
1951   /* then start scanning and parsing for cluster time,
1952    * re-estimate if overshoot, otherwise next cluster and so on */
1953   demux->common.offset = newpos;
1954   demux->cluster_time = cluster_time = GST_CLOCK_TIME_NONE;
1955   while (1) {
1956     guint64 cluster_size = 0;
1957
1958     /* peek and parse some elements */
1959     ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
1960         GST_ELEMENT_CAST (demux), &id, &length, &needed);
1961     if (ret != GST_FLOW_OK)
1962       goto error;
1963     GST_LOG_OBJECT (demux, "Offset %" G_GUINT64_FORMAT ", Element id 0x%x, "
1964         "size %" G_GUINT64_FORMAT ", needed %d", demux->common.offset, id,
1965         length, needed);
1966     ret = gst_matroska_demux_parse_id (demux, id, length, needed);
1967     if (ret != GST_FLOW_OK)
1968       goto error;
1969
1970     if (id == GST_MATROSKA_ID_CLUSTER) {
1971       cluster_time = GST_CLOCK_TIME_NONE;
1972       if (length == G_MAXUINT64)
1973         cluster_size = 0;
1974       else
1975         cluster_size = length + needed;
1976     }
1977     if (demux->cluster_time != GST_CLOCK_TIME_NONE &&
1978         cluster_time == GST_CLOCK_TIME_NONE) {
1979       cluster_time = demux->cluster_time * demux->common.time_scale;
1980       cluster_offset = demux->cluster_offset;
1981       GST_DEBUG_OBJECT (demux, "found cluster at offset %" G_GINT64_FORMAT
1982           " with time %" GST_TIME_FORMAT, cluster_offset,
1983           GST_TIME_ARGS (cluster_time));
1984       if (cluster_time > time) {
1985         GST_DEBUG_OBJECT (demux, "overshot target");
1986         /* cluster overshoots */
1987         if (cluster_offset == demux->first_cluster_offset) {
1988           /* but no prev one */
1989           GST_DEBUG_OBJECT (demux, "but using first cluster anyway");
1990           prev_cluster_time = cluster_time;
1991           prev_cluster_offset = cluster_offset;
1992           break;
1993         }
1994         if (prev_cluster_time != GST_CLOCK_TIME_NONE) {
1995           /* prev cluster did not overshoot, so prev cluster is target */
1996           break;
1997         } else {
1998           /* re-estimate using this new position info */
1999           opos = cluster_offset;
2000           otime = cluster_time;
2001           goto retry;
2002         }
2003       } else {
2004         /* cluster undershoots, goto next one */
2005         prev_cluster_time = cluster_time;
2006         prev_cluster_offset = cluster_offset;
2007         /* skip cluster if length is defined,
2008          * otherwise will be skippingly parsed into */
2009         if (cluster_size) {
2010           GST_DEBUG_OBJECT (demux, "skipping to next cluster");
2011           demux->common.offset = cluster_offset + cluster_size;
2012           demux->cluster_time = GST_CLOCK_TIME_NONE;
2013         } else {
2014           GST_DEBUG_OBJECT (demux, "parsing/skipping cluster elements");
2015         }
2016       }
2017     }
2018     continue;
2019
2020   error:
2021     if (ret == GST_FLOW_UNEXPECTED) {
2022       if (prev_cluster_time != GST_CLOCK_TIME_NONE)
2023         break;
2024     }
2025     goto exit;
2026   }
2027
2028   entry = g_new0 (GstMatroskaIndex, 1);
2029   entry->time = prev_cluster_time;
2030   entry->pos = prev_cluster_offset - demux->common.ebml_segment_start;
2031   GST_DEBUG_OBJECT (demux, "simulated index entry; time %" GST_TIME_FORMAT
2032       ", pos %" G_GUINT64_FORMAT, GST_TIME_ARGS (entry->time), entry->pos);
2033
2034 exit:
2035   if (buf)
2036     gst_buffer_unref (buf);
2037
2038   /* restore some state */
2039   demux->cluster_offset = current_cluster_offset;
2040   demux->cluster_time = current_cluster_time;
2041   demux->common.offset = current_offset;
2042   demux->common.state = current_state;
2043
2044   return entry;
2045 }
2046
2047 static gboolean
2048 gst_matroska_demux_handle_seek_event (GstMatroskaDemux * demux,
2049     GstPad * pad, GstEvent * event)
2050 {
2051   GstMatroskaIndex *entry = NULL;
2052   GstMatroskaIndex scan_entry;
2053   GstSeekFlags flags;
2054   GstSeekType cur_type, stop_type;
2055   GstFormat format;
2056   gboolean flush, keyunit;
2057   gdouble rate;
2058   gint64 cur, stop;
2059   GstMatroskaTrackContext *track = NULL;
2060   GstSegment seeksegment = { 0, };
2061   gboolean update;
2062
2063   if (pad)
2064     track = gst_pad_get_element_private (pad);
2065
2066   gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,
2067       &stop_type, &stop);
2068
2069   /* we can only seek on time */
2070   if (format != GST_FORMAT_TIME) {
2071     GST_DEBUG_OBJECT (demux, "Can only seek on TIME");
2072     return FALSE;
2073   }
2074
2075   /* copy segment, we need this because we still need the old
2076    * segment when we close the current segment. */
2077   memcpy (&seeksegment, &demux->segment, sizeof (GstSegment));
2078
2079   if (event) {
2080     GST_DEBUG_OBJECT (demux, "configuring seek");
2081     gst_segment_set_seek (&seeksegment, rate, format, flags,
2082         cur_type, cur, stop_type, stop, &update);
2083   }
2084
2085   GST_DEBUG_OBJECT (demux, "New segment %" GST_SEGMENT_FORMAT, &seeksegment);
2086
2087   /* check sanity before we start flushing and all that */
2088   GST_OBJECT_LOCK (demux);
2089   track = gst_matroska_demux_get_seek_track (demux, track);
2090   if ((entry = gst_matroskademux_do_index_seek (demux, track,
2091               seeksegment.last_stop, &demux->seek_index, &demux->seek_entry)) ==
2092       NULL) {
2093     /* pull mode without index can scan later on */
2094     if (demux->common.index || demux->streaming) {
2095       GST_DEBUG_OBJECT (demux, "No matching seek entry in index");
2096       GST_OBJECT_UNLOCK (demux);
2097       return FALSE;
2098     }
2099   }
2100   GST_DEBUG_OBJECT (demux, "Seek position looks sane");
2101   GST_OBJECT_UNLOCK (demux);
2102
2103   if (demux->streaming) {
2104     /* need to seek to cluster start to pick up cluster time */
2105     /* upstream takes care of flushing and all that
2106      * ... and newsegment event handling takes care of the rest */
2107     return perform_seek_to_offset (demux,
2108         entry->pos + demux->common.ebml_segment_start);
2109   }
2110
2111   flush = ! !(flags & GST_SEEK_FLAG_FLUSH);
2112   keyunit = ! !(flags & GST_SEEK_FLAG_KEY_UNIT);
2113
2114   if (flush) {
2115     GST_DEBUG_OBJECT (demux, "Starting flush");
2116     gst_pad_push_event (demux->common.sinkpad, gst_event_new_flush_start ());
2117     gst_matroska_demux_send_event (demux, gst_event_new_flush_start ());
2118   } else {
2119     GST_DEBUG_OBJECT (demux, "Non-flushing seek, pausing task");
2120     gst_pad_pause_task (demux->common.sinkpad);
2121   }
2122
2123   /* now grab the stream lock so that streaming cannot continue, for
2124    * non flushing seeks when the element is in PAUSED this could block
2125    * forever. */
2126   GST_DEBUG_OBJECT (demux, "Waiting for streaming to stop");
2127   GST_PAD_STREAM_LOCK (demux->common.sinkpad);
2128
2129   /* pull mode without index can do some scanning */
2130   if (!demux->streaming && !demux->common.index) {
2131     /* need to stop flushing upstream as we need it next */
2132     if (flush)
2133       gst_pad_push_event (demux->common.sinkpad, gst_event_new_flush_stop ());
2134     entry = gst_matroska_demux_search_pos (demux, seeksegment.last_stop);
2135     /* keep local copy */
2136     if (entry) {
2137       scan_entry = *entry;
2138       g_free (entry);
2139       entry = &scan_entry;
2140     } else {
2141       GST_DEBUG_OBJECT (demux, "Scan failed to find matching position");
2142       if (flush)
2143         gst_matroska_demux_send_event (demux, gst_event_new_flush_stop ());
2144       goto seek_error;
2145     }
2146   }
2147
2148   if (keyunit) {
2149     GST_DEBUG_OBJECT (demux, "seek to key unit, adjusting segment start to %"
2150         GST_TIME_FORMAT, GST_TIME_ARGS (entry->time));
2151     seeksegment.start = entry->time;
2152     seeksegment.last_stop = entry->time;
2153     seeksegment.time = entry->time;
2154   }
2155
2156   if (flush) {
2157     GST_DEBUG_OBJECT (demux, "Stopping flush");
2158     gst_pad_push_event (demux->common.sinkpad, gst_event_new_flush_stop ());
2159     gst_matroska_demux_send_event (demux, gst_event_new_flush_stop ());
2160   } else if (demux->segment_running) {
2161     GST_DEBUG_OBJECT (demux, "Closing currently running segment");
2162
2163     GST_OBJECT_LOCK (demux);
2164     if (demux->close_segment)
2165       gst_event_unref (demux->close_segment);
2166
2167     demux->close_segment = gst_event_new_new_segment (TRUE,
2168         demux->segment.rate, GST_FORMAT_TIME, demux->segment.start,
2169         demux->segment.last_stop, demux->segment.time);
2170     GST_OBJECT_UNLOCK (demux);
2171   }
2172
2173   GST_OBJECT_LOCK (demux);
2174   /* now update the real segment info */
2175   GST_DEBUG_OBJECT (demux, "Committing new seek segment");
2176   memcpy (&demux->segment, &seeksegment, sizeof (GstSegment));
2177   GST_OBJECT_UNLOCK (demux);
2178
2179   /* update some (segment) state */
2180   if (!gst_matroska_demux_move_to_entry (demux, entry, TRUE))
2181     goto seek_error;
2182
2183   /* notify start of new segment */
2184   if (demux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
2185     GstMessage *msg;
2186
2187     msg = gst_message_new_segment_start (GST_OBJECT (demux),
2188         GST_FORMAT_TIME, demux->segment.start);
2189     gst_element_post_message (GST_ELEMENT (demux), msg);
2190   }
2191
2192   GST_OBJECT_LOCK (demux);
2193   if (demux->new_segment)
2194     gst_event_unref (demux->new_segment);
2195   demux->new_segment = gst_event_new_new_segment_full (FALSE,
2196       demux->segment.rate, demux->segment.applied_rate, demux->segment.format,
2197       demux->segment.start, demux->segment.stop, demux->segment.time);
2198   GST_OBJECT_UNLOCK (demux);
2199
2200   /* restart our task since it might have been stopped when we did the
2201    * flush. */
2202   demux->segment_running = TRUE;
2203   gst_pad_start_task (demux->common.sinkpad,
2204       (GstTaskFunction) gst_matroska_demux_loop, demux->common.sinkpad);
2205
2206   /* streaming can continue now */
2207   GST_PAD_STREAM_UNLOCK (demux->common.sinkpad);
2208
2209   return TRUE;
2210
2211 seek_error:
2212   {
2213     GST_PAD_STREAM_UNLOCK (demux->common.sinkpad);
2214     GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL), ("Got a seek error"));
2215     return FALSE;
2216   }
2217 }
2218
2219 /*
2220  * Handle whether we can perform the seek event or if we have to let the chain
2221  * function handle seeks to build the seek indexes first.
2222  */
2223 static gboolean
2224 gst_matroska_demux_handle_seek_push (GstMatroskaDemux * demux, GstPad * pad,
2225     GstEvent * event)
2226 {
2227   GstSeekFlags flags;
2228   GstSeekType cur_type, stop_type;
2229   GstFormat format;
2230   gdouble rate;
2231   gint64 cur, stop;
2232
2233   gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,
2234       &stop_type, &stop);
2235
2236   /* sanity checks */
2237
2238   /* we can only seek on time */
2239   if (format != GST_FORMAT_TIME) {
2240     GST_DEBUG_OBJECT (demux, "Can only seek on TIME");
2241     return FALSE;
2242   }
2243
2244   if (stop_type != GST_SEEK_TYPE_NONE && stop != GST_CLOCK_TIME_NONE) {
2245     GST_DEBUG_OBJECT (demux, "Seek end-time not supported in streaming mode");
2246     return FALSE;
2247   }
2248
2249   if (!(flags & GST_SEEK_FLAG_FLUSH)) {
2250     GST_DEBUG_OBJECT (demux,
2251         "Non-flushing seek not supported in streaming mode");
2252     return FALSE;
2253   }
2254
2255   if (flags & GST_SEEK_FLAG_SEGMENT) {
2256     GST_DEBUG_OBJECT (demux, "Segment seek not supported in streaming mode");
2257     return FALSE;
2258   }
2259
2260   /* check for having parsed index already */
2261   if (!demux->common.index_parsed) {
2262     gboolean building_index;
2263     guint64 offset = 0;
2264
2265     if (!demux->index_offset) {
2266       GST_DEBUG_OBJECT (demux, "no index (location); no seek in push mode");
2267       return FALSE;
2268     }
2269
2270     GST_OBJECT_LOCK (demux);
2271     /* handle the seek event in the chain function */
2272     demux->common.state = GST_MATROSKA_READ_STATE_SEEK;
2273     /* no more seek can be issued until state reset to _DATA */
2274
2275     /* copy the event */
2276     if (demux->seek_event)
2277       gst_event_unref (demux->seek_event);
2278     demux->seek_event = gst_event_ref (event);
2279
2280     /* set the building_index flag so that only one thread can setup the
2281      * structures for index seeking. */
2282     building_index = demux->building_index;
2283     if (!building_index) {
2284       demux->building_index = TRUE;
2285       offset = demux->index_offset;
2286     }
2287     GST_OBJECT_UNLOCK (demux);
2288
2289     if (!building_index) {
2290       /* seek to the first subindex or legacy index */
2291       GST_INFO_OBJECT (demux, "Seeking to Cues at %" G_GUINT64_FORMAT, offset);
2292       return perform_seek_to_offset (demux, offset);
2293     }
2294
2295     /* well, we are handling it already */
2296     return TRUE;
2297   }
2298
2299   /* delegate to tweaked regular seek */
2300   return gst_matroska_demux_handle_seek_event (demux, pad, event);
2301 }
2302
2303 static gboolean
2304 gst_matroska_demux_handle_src_event (GstPad * pad, GstEvent * event)
2305 {
2306   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (gst_pad_get_parent (pad));
2307   gboolean res = TRUE;
2308
2309   switch (GST_EVENT_TYPE (event)) {
2310     case GST_EVENT_SEEK:
2311       /* no seeking until we are (safely) ready */
2312       if (demux->common.state != GST_MATROSKA_READ_STATE_DATA) {
2313         GST_DEBUG_OBJECT (demux, "not ready for seeking yet");
2314         return FALSE;
2315       }
2316       if (!demux->streaming)
2317         res = gst_matroska_demux_handle_seek_event (demux, pad, event);
2318       else
2319         res = gst_matroska_demux_handle_seek_push (demux, pad, event);
2320       gst_event_unref (event);
2321       break;
2322
2323     case GST_EVENT_QOS:
2324     {
2325       GstMatroskaTrackContext *context = gst_pad_get_element_private (pad);
2326       if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO) {
2327         GstMatroskaTrackVideoContext *videocontext =
2328             (GstMatroskaTrackVideoContext *) context;
2329         gdouble proportion;
2330         GstClockTimeDiff diff;
2331         GstClockTime timestamp;
2332
2333         gst_event_parse_qos (event, &proportion, &diff, &timestamp);
2334
2335         GST_OBJECT_LOCK (demux);
2336         videocontext->earliest_time = timestamp + diff;
2337         GST_OBJECT_UNLOCK (demux);
2338       }
2339       res = TRUE;
2340       gst_event_unref (event);
2341       break;
2342     }
2343
2344       /* events we don't need to handle */
2345     case GST_EVENT_NAVIGATION:
2346       gst_event_unref (event);
2347       res = FALSE;
2348       break;
2349
2350     case GST_EVENT_LATENCY:
2351     default:
2352       res = gst_pad_push_event (demux->common.sinkpad, event);
2353       break;
2354   }
2355
2356   gst_object_unref (demux);
2357
2358   return res;
2359 }
2360
2361 static GstFlowReturn
2362 gst_matroska_demux_seek_to_previous_keyframe (GstMatroskaDemux * demux)
2363 {
2364   GstFlowReturn ret = GST_FLOW_UNEXPECTED;
2365   gboolean done = TRUE;
2366   gint i;
2367
2368   g_return_val_if_fail (demux->seek_index, GST_FLOW_UNEXPECTED);
2369   g_return_val_if_fail (demux->seek_entry < demux->seek_index->len,
2370       GST_FLOW_UNEXPECTED);
2371
2372   GST_DEBUG_OBJECT (demux, "locating previous keyframe");
2373
2374   if (!demux->seek_entry) {
2375     GST_DEBUG_OBJECT (demux, "no earlier index entry");
2376     goto exit;
2377   }
2378
2379   for (i = 0; i < demux->common.src->len; i++) {
2380     GstMatroskaTrackContext *stream = g_ptr_array_index (demux->common.src, i);
2381
2382     GST_DEBUG_OBJECT (demux, "segment start %" GST_TIME_FORMAT
2383         ", stream %d at %" GST_TIME_FORMAT,
2384         GST_TIME_ARGS (demux->segment.start), stream->index,
2385         GST_TIME_ARGS (stream->from_time));
2386     if (GST_CLOCK_TIME_IS_VALID (stream->from_time)) {
2387       if (stream->from_time > demux->segment.start) {
2388         GST_DEBUG_OBJECT (demux, "stream %d not finished yet", stream->index);
2389         done = FALSE;
2390       }
2391     } else {
2392       /* nothing pushed for this stream;
2393        * likely seek entry did not start at keyframe, so all was skipped.
2394        * So we need an earlier entry */
2395       done = FALSE;
2396     }
2397   }
2398
2399   if (!done) {
2400     GstMatroskaIndex *entry;
2401
2402     entry = &g_array_index (demux->seek_index, GstMatroskaIndex,
2403         --demux->seek_entry);
2404     if (!gst_matroska_demux_move_to_entry (demux, entry, FALSE))
2405       goto exit;
2406
2407     ret = GST_FLOW_OK;
2408   }
2409
2410 exit:
2411   return ret;
2412 }
2413
2414 static GstFlowReturn
2415 gst_matroska_demux_parse_header (GstMatroskaDemux * demux, GstEbmlRead * ebml)
2416 {
2417   GstFlowReturn ret;
2418   gchar *doctype;
2419   guint version;
2420   guint32 id;
2421
2422   /* this function is the first to be called */
2423
2424   /* default init */
2425   doctype = NULL;
2426   version = 1;
2427
2428   ret = gst_ebml_peek_id (ebml, &id);
2429   if (ret != GST_FLOW_OK)
2430     return ret;
2431
2432   GST_DEBUG_OBJECT (demux, "id: %08x", id);
2433
2434   if (id != GST_EBML_ID_HEADER) {
2435     GST_ERROR_OBJECT (demux, "Failed to read header");
2436     goto exit;
2437   }
2438
2439   ret = gst_ebml_read_master (ebml, &id);
2440   if (ret != GST_FLOW_OK)
2441     return ret;
2442
2443   while (gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
2444     ret = gst_ebml_peek_id (ebml, &id);
2445     if (ret != GST_FLOW_OK)
2446       return ret;
2447
2448     switch (id) {
2449         /* is our read version uptodate? */
2450       case GST_EBML_ID_EBMLREADVERSION:{
2451         guint64 num;
2452
2453         ret = gst_ebml_read_uint (ebml, &id, &num);
2454         if (ret != GST_FLOW_OK)
2455           return ret;
2456         if (num != GST_EBML_VERSION) {
2457           GST_ERROR_OBJECT (ebml, "Unsupported EBML version %" G_GUINT64_FORMAT,
2458               num);
2459           return GST_FLOW_ERROR;
2460         }
2461
2462         GST_DEBUG_OBJECT (ebml, "EbmlReadVersion: %" G_GUINT64_FORMAT, num);
2463         break;
2464       }
2465
2466         /* we only handle 8 byte lengths at max */
2467       case GST_EBML_ID_EBMLMAXSIZELENGTH:{
2468         guint64 num;
2469
2470         ret = gst_ebml_read_uint (ebml, &id, &num);
2471         if (ret != GST_FLOW_OK)
2472           return ret;
2473         if (num > sizeof (guint64)) {
2474           GST_ERROR_OBJECT (ebml,
2475               "Unsupported EBML maximum size %" G_GUINT64_FORMAT, num);
2476           return GST_FLOW_ERROR;
2477         }
2478         GST_DEBUG_OBJECT (ebml, "EbmlMaxSizeLength: %" G_GUINT64_FORMAT, num);
2479         break;
2480       }
2481
2482         /* we handle 4 byte IDs at max */
2483       case GST_EBML_ID_EBMLMAXIDLENGTH:{
2484         guint64 num;
2485
2486         ret = gst_ebml_read_uint (ebml, &id, &num);
2487         if (ret != GST_FLOW_OK)
2488           return ret;
2489         if (num > sizeof (guint32)) {
2490           GST_ERROR_OBJECT (ebml,
2491               "Unsupported EBML maximum ID %" G_GUINT64_FORMAT, num);
2492           return GST_FLOW_ERROR;
2493         }
2494         GST_DEBUG_OBJECT (ebml, "EbmlMaxIdLength: %" G_GUINT64_FORMAT, num);
2495         break;
2496       }
2497
2498       case GST_EBML_ID_DOCTYPE:{
2499         gchar *text;
2500
2501         ret = gst_ebml_read_ascii (ebml, &id, &text);
2502         if (ret != GST_FLOW_OK)
2503           return ret;
2504
2505         GST_DEBUG_OBJECT (ebml, "EbmlDocType: %s", GST_STR_NULL (text));
2506
2507         if (doctype)
2508           g_free (doctype);
2509         doctype = text;
2510         break;
2511       }
2512
2513       case GST_EBML_ID_DOCTYPEREADVERSION:{
2514         guint64 num;
2515
2516         ret = gst_ebml_read_uint (ebml, &id, &num);
2517         if (ret != GST_FLOW_OK)
2518           return ret;
2519         version = num;
2520         GST_DEBUG_OBJECT (ebml, "EbmlReadVersion: %" G_GUINT64_FORMAT, num);
2521         break;
2522       }
2523
2524       default:
2525         ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
2526             "EBML header", id);
2527         if (ret != GST_FLOW_OK)
2528           return ret;
2529         break;
2530
2531         /* we ignore these two, as they don't tell us anything we care about */
2532       case GST_EBML_ID_EBMLVERSION:
2533       case GST_EBML_ID_DOCTYPEVERSION:
2534         ret = gst_ebml_read_skip (ebml);
2535         if (ret != GST_FLOW_OK)
2536           return ret;
2537         break;
2538     }
2539   }
2540
2541 exit:
2542
2543   if ((doctype != NULL && !strcmp (doctype, GST_MATROSKA_DOCTYPE_MATROSKA)) ||
2544       (doctype != NULL && !strcmp (doctype, GST_MATROSKA_DOCTYPE_WEBM)) ||
2545       (doctype == NULL)) {
2546     if (version <= 2) {
2547       if (doctype) {
2548         GST_INFO_OBJECT (demux, "Input is %s version %d", doctype, version);
2549       } else {
2550         GST_WARNING_OBJECT (demux, "Input is EBML without doctype, assuming "
2551             "matroska (version %d)", version);
2552       }
2553       ret = GST_FLOW_OK;
2554     } else {
2555       GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL),
2556           ("Demuxer version (2) is too old to read %s version %d",
2557               GST_STR_NULL (doctype), version));
2558       ret = GST_FLOW_ERROR;
2559     }
2560     g_free (doctype);
2561   } else {
2562     GST_ELEMENT_ERROR (demux, STREAM, WRONG_TYPE, (NULL),
2563         ("Input is not a matroska stream (doctype=%s)", doctype));
2564     ret = GST_FLOW_ERROR;
2565     g_free (doctype);
2566   }
2567
2568   return ret;
2569 }
2570
2571 static GstFlowReturn
2572 gst_matroska_demux_parse_tracks (GstMatroskaDemux * demux, GstEbmlRead * ebml)
2573 {
2574   GstFlowReturn ret = GST_FLOW_OK;
2575   guint32 id;
2576
2577   DEBUG_ELEMENT_START (demux, ebml, "Tracks");
2578
2579   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
2580     DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret);
2581     return ret;
2582   }
2583
2584   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
2585     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
2586       break;
2587
2588     switch (id) {
2589         /* one track within the "all-tracks" header */
2590       case GST_MATROSKA_ID_TRACKENTRY:
2591         ret = gst_matroska_demux_add_stream (demux, ebml);
2592         break;
2593
2594       default:
2595         ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
2596             "Track", id);
2597         break;
2598     }
2599   }
2600   DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret);
2601
2602   demux->tracks_parsed = TRUE;
2603
2604   return ret;
2605 }
2606
2607 static GstFlowReturn
2608 gst_matroska_demux_parse_info (GstMatroskaDemux * demux, GstEbmlRead * ebml)
2609 {
2610   GstFlowReturn ret = GST_FLOW_OK;
2611   gdouble dur_f = -1.0;
2612   guint32 id;
2613
2614   DEBUG_ELEMENT_START (demux, ebml, "SegmentInfo");
2615
2616   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
2617     DEBUG_ELEMENT_STOP (demux, ebml, "SegmentInfo", ret);
2618     return ret;
2619   }
2620
2621   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
2622     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
2623       break;
2624
2625     switch (id) {
2626         /* cluster timecode */
2627       case GST_MATROSKA_ID_TIMECODESCALE:{
2628         guint64 num;
2629
2630         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
2631           break;
2632
2633
2634         GST_DEBUG_OBJECT (demux, "TimeCodeScale: %" G_GUINT64_FORMAT, num);
2635         demux->common.time_scale = num;
2636         break;
2637       }
2638
2639       case GST_MATROSKA_ID_DURATION:{
2640         if ((ret = gst_ebml_read_float (ebml, &id, &dur_f)) != GST_FLOW_OK)
2641           break;
2642
2643         if (dur_f <= 0.0) {
2644           GST_WARNING_OBJECT (demux, "Invalid duration %lf", dur_f);
2645           break;
2646         }
2647
2648         GST_DEBUG_OBJECT (demux, "Duration: %lf", dur_f);
2649         break;
2650       }
2651
2652       case GST_MATROSKA_ID_WRITINGAPP:{
2653         gchar *text;
2654
2655         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
2656           break;
2657
2658         GST_DEBUG_OBJECT (demux, "WritingApp: %s", GST_STR_NULL (text));
2659         demux->writing_app = text;
2660         break;
2661       }
2662
2663       case GST_MATROSKA_ID_MUXINGAPP:{
2664         gchar *text;
2665
2666         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
2667           break;
2668
2669         GST_DEBUG_OBJECT (demux, "MuxingApp: %s", GST_STR_NULL (text));
2670         demux->muxing_app = text;
2671         break;
2672       }
2673
2674       case GST_MATROSKA_ID_DATEUTC:{
2675         gint64 time;
2676
2677         if ((ret = gst_ebml_read_date (ebml, &id, &time)) != GST_FLOW_OK)
2678           break;
2679
2680         GST_DEBUG_OBJECT (demux, "DateUTC: %" G_GINT64_FORMAT, time);
2681         demux->created = time;
2682         break;
2683       }
2684
2685       case GST_MATROSKA_ID_TITLE:{
2686         gchar *text;
2687         GstTagList *taglist;
2688
2689         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
2690           break;
2691
2692         GST_DEBUG_OBJECT (demux, "Title: %s", GST_STR_NULL (text));
2693         taglist = gst_tag_list_new ();
2694         gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND, GST_TAG_TITLE, text,
2695             NULL);
2696         gst_matroska_demux_found_global_tag (demux, taglist);
2697         g_free (text);
2698         break;
2699       }
2700
2701       default:
2702         ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
2703             "SegmentInfo", id);
2704         break;
2705
2706         /* fall through */
2707       case GST_MATROSKA_ID_SEGMENTUID:
2708       case GST_MATROSKA_ID_SEGMENTFILENAME:
2709       case GST_MATROSKA_ID_PREVUID:
2710       case GST_MATROSKA_ID_PREVFILENAME:
2711       case GST_MATROSKA_ID_NEXTUID:
2712       case GST_MATROSKA_ID_NEXTFILENAME: