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