matroska: refactor code common to matroskademux and matroskaparse
[gstreamer-omap:gst-plugins-good.git] / gst / matroska / matroska-read-common.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-read-common.c: shared by matroska file/stream demuxer and parser
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 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include <string.h>
30
31 #ifdef HAVE_ZLIB
32 #include <zlib.h>
33 #endif
34
35 #ifdef HAVE_BZ2
36 #include <bzlib.h>
37 #endif
38
39 #include <gst/tag/tag.h>
40 #include <gst/base/gsttypefindhelper.h>
41
42 #include "lzo.h"
43
44 #include "ebml-read.h"
45 #include "matroska-read-common.h"
46
47 GST_DEBUG_CATEGORY_STATIC (matroskareadcommon_debug);
48 #define GST_CAT_DEFAULT matroskareadcommon_debug
49
50 #define DEBUG_ELEMENT_START(common, ebml, element) \
51     GST_DEBUG_OBJECT (common, "Parsing " element " element at offset %" \
52         G_GUINT64_FORMAT, gst_ebml_read_get_pos (ebml))
53
54 #define DEBUG_ELEMENT_STOP(common, ebml, element, ret) \
55     GST_DEBUG_OBJECT (common, "Parsing " element " element " \
56         " finished with '%s'", gst_flow_get_name (ret))
57
58 static gboolean
59 gst_matroska_decompress_data (GstMatroskaTrackEncoding * enc,
60     guint8 ** data_out, guint * size_out,
61     GstMatroskaTrackCompressionAlgorithm algo)
62 {
63   guint8 *new_data = NULL;
64   guint new_size = 0;
65   guint8 *data = *data_out;
66   guint size = *size_out;
67   gboolean ret = TRUE;
68
69   if (algo == GST_MATROSKA_TRACK_COMPRESSION_ALGORITHM_ZLIB) {
70 #ifdef HAVE_ZLIB
71     /* zlib encoded data */
72     z_stream zstream;
73     guint orig_size;
74     int result;
75
76     orig_size = size;
77     zstream.zalloc = (alloc_func) 0;
78     zstream.zfree = (free_func) 0;
79     zstream.opaque = (voidpf) 0;
80     if (inflateInit (&zstream) != Z_OK) {
81       GST_WARNING ("zlib initialization failed.");
82       ret = FALSE;
83       goto out;
84     }
85     zstream.next_in = (Bytef *) data;
86     zstream.avail_in = orig_size;
87     new_size = orig_size;
88     new_data = g_malloc (new_size);
89     zstream.avail_out = new_size;
90     zstream.next_out = (Bytef *) new_data;
91
92     do {
93       result = inflate (&zstream, Z_NO_FLUSH);
94       if (result != Z_OK && result != Z_STREAM_END) {
95         GST_WARNING ("zlib decompression failed.");
96         g_free (new_data);
97         inflateEnd (&zstream);
98         break;
99       }
100       new_size += 4000;
101       new_data = g_realloc (new_data, new_size);
102       zstream.next_out = (Bytef *) (new_data + zstream.total_out);
103       zstream.avail_out += 4000;
104     } while (zstream.avail_in != 0 && result != Z_STREAM_END);
105
106     if (result != Z_STREAM_END) {
107       ret = FALSE;
108       goto out;
109     } else {
110       new_size = zstream.total_out;
111       inflateEnd (&zstream);
112     }
113 #else
114     GST_WARNING ("zlib encoded tracks not supported.");
115     ret = FALSE;
116     goto out;
117 #endif
118   } else if (algo == GST_MATROSKA_TRACK_COMPRESSION_ALGORITHM_BZLIB) {
119 #ifdef HAVE_BZ2
120     /* bzip2 encoded data */
121     bz_stream bzstream;
122     guint orig_size;
123     int result;
124
125     bzstream.bzalloc = NULL;
126     bzstream.bzfree = NULL;
127     bzstream.opaque = NULL;
128     orig_size = size;
129
130     if (BZ2_bzDecompressInit (&bzstream, 0, 0) != BZ_OK) {
131       GST_WARNING ("bzip2 initialization failed.");
132       ret = FALSE;
133       goto out;
134     }
135
136     bzstream.next_in = (char *) data;
137     bzstream.avail_in = orig_size;
138     new_size = orig_size;
139     new_data = g_malloc (new_size);
140     bzstream.avail_out = new_size;
141     bzstream.next_out = (char *) new_data;
142
143     do {
144       result = BZ2_bzDecompress (&bzstream);
145       if (result != BZ_OK && result != BZ_STREAM_END) {
146         GST_WARNING ("bzip2 decompression failed.");
147         g_free (new_data);
148         BZ2_bzDecompressEnd (&bzstream);
149         break;
150       }
151       new_size += 4000;
152       new_data = g_realloc (new_data, new_size);
153       bzstream.next_out = (char *) (new_data + bzstream.total_out_lo32);
154       bzstream.avail_out += 4000;
155     } while (bzstream.avail_in != 0 && result != BZ_STREAM_END);
156
157     if (result != BZ_STREAM_END) {
158       ret = FALSE;
159       goto out;
160     } else {
161       new_size = bzstream.total_out_lo32;
162       BZ2_bzDecompressEnd (&bzstream);
163     }
164 #else
165     GST_WARNING ("bzip2 encoded tracks not supported.");
166     ret = FALSE;
167     goto out;
168 #endif
169   } else if (algo == GST_MATROSKA_TRACK_COMPRESSION_ALGORITHM_LZO1X) {
170     /* lzo encoded data */
171     int result;
172     int orig_size, out_size;
173
174     orig_size = size;
175     out_size = size;
176     new_size = size;
177     new_data = g_malloc (new_size);
178
179     do {
180       orig_size = size;
181       out_size = new_size;
182
183       result = lzo1x_decode (new_data, &out_size, data, &orig_size);
184
185       if (orig_size > 0) {
186         new_size += 4000;
187         new_data = g_realloc (new_data, new_size);
188       }
189     } while (orig_size > 0 && result == LZO_OUTPUT_FULL);
190
191     new_size -= out_size;
192
193     if (result != LZO_OUTPUT_FULL) {
194       GST_WARNING ("lzo decompression failed");
195       g_free (new_data);
196
197       ret = FALSE;
198       goto out;
199     }
200
201   } else if (algo == GST_MATROSKA_TRACK_COMPRESSION_ALGORITHM_HEADERSTRIP) {
202     /* header stripped encoded data */
203     if (enc->comp_settings_length > 0) {
204       new_data = g_malloc (size + enc->comp_settings_length);
205       new_size = size + enc->comp_settings_length;
206
207       memcpy (new_data, enc->comp_settings, enc->comp_settings_length);
208       memcpy (new_data + enc->comp_settings_length, data, size);
209     }
210   } else {
211     GST_ERROR ("invalid compression algorithm %d", algo);
212     ret = FALSE;
213   }
214
215 out:
216
217   if (!ret) {
218     *data_out = NULL;
219     *size_out = 0;
220   } else {
221     *data_out = new_data;
222     *size_out = new_size;
223   }
224
225   return ret;
226 }
227
228 GstFlowReturn
229 gst_matroska_decode_content_encodings (GArray * encodings)
230 {
231   gint i;
232
233   if (encodings == NULL)
234     return GST_FLOW_OK;
235
236   for (i = 0; i < encodings->len; i++) {
237     GstMatroskaTrackEncoding *enc =
238         &g_array_index (encodings, GstMatroskaTrackEncoding, i);
239     guint8 *data = NULL;
240     guint size;
241
242     if ((enc->scope & GST_MATROSKA_TRACK_ENCODING_SCOPE_NEXT_CONTENT_ENCODING)
243         == 0)
244       continue;
245
246     /* Encryption not supported yet */
247     if (enc->type != 0)
248       return GST_FLOW_ERROR;
249
250     if (i + 1 >= encodings->len)
251       return GST_FLOW_ERROR;
252
253     if (enc->comp_settings_length == 0)
254       continue;
255
256     data = enc->comp_settings;
257     size = enc->comp_settings_length;
258
259     if (!gst_matroska_decompress_data (enc, &data, &size, enc->comp_algo))
260       return GST_FLOW_ERROR;
261
262     g_free (enc->comp_settings);
263
264     enc->comp_settings = data;
265     enc->comp_settings_length = size;
266   }
267
268   return GST_FLOW_OK;
269 }
270
271 gboolean
272 gst_matroska_decode_data (GArray * encodings, guint8 ** data_out,
273     guint * size_out, GstMatroskaTrackEncodingScope scope, gboolean free)
274 {
275   guint8 *data;
276   guint size;
277   gboolean ret = TRUE;
278   gint i;
279
280   g_return_val_if_fail (encodings != NULL, FALSE);
281   g_return_val_if_fail (data_out != NULL && *data_out != NULL, FALSE);
282   g_return_val_if_fail (size_out != NULL, FALSE);
283
284   data = *data_out;
285   size = *size_out;
286
287   for (i = 0; i < encodings->len; i++) {
288     GstMatroskaTrackEncoding *enc =
289         &g_array_index (encodings, GstMatroskaTrackEncoding, i);
290     guint8 *new_data = NULL;
291     guint new_size = 0;
292
293     if ((enc->scope & scope) == 0)
294       continue;
295
296     /* Encryption not supported yet */
297     if (enc->type != 0) {
298       ret = FALSE;
299       break;
300     }
301
302     new_data = data;
303     new_size = size;
304
305     ret =
306         gst_matroska_decompress_data (enc, &new_data, &new_size,
307         enc->comp_algo);
308
309     if (!ret)
310       break;
311
312     if ((data == *data_out && free) || (data != *data_out))
313       g_free (data);
314
315     data = new_data;
316     size = new_size;
317   }
318
319   if (!ret) {
320     if ((data == *data_out && free) || (data != *data_out))
321       g_free (data);
322
323     *data_out = NULL;
324     *size_out = 0;
325   } else {
326     *data_out = data;
327     *size_out = size;
328   }
329
330   return ret;
331 }
332
333 static gint
334 gst_matroska_index_compare (GstMatroskaIndex * i1, GstMatroskaIndex * i2)
335 {
336   if (i1->time < i2->time)
337     return -1;
338   else if (i1->time > i2->time)
339     return 1;
340   else if (i1->block < i2->block)
341     return -1;
342   else if (i1->block > i2->block)
343     return 1;
344   else
345     return 0;
346 }
347
348 gint
349 gst_matroska_index_seek_find (GstMatroskaIndex * i1, GstClockTime * time,
350     gpointer user_data)
351 {
352   if (i1->time < *time)
353     return -1;
354   else if (i1->time > *time)
355     return 1;
356   else
357     return 0;
358 }
359
360 GstMatroskaIndex *
361 gst_matroska_read_common_do_index_seek (GstMatroskaReadCommon * common,
362     GstMatroskaTrackContext * track, gint64 seek_pos, GArray ** _index,
363     gint * _entry_index)
364 {
365   GstMatroskaIndex *entry = NULL;
366   GArray *index;
367
368   if (!common->index || !common->index->len)
369     return NULL;
370
371   /* find entry just before or at the requested position */
372   if (track && track->index_table)
373     index = track->index_table;
374   else
375     index = common->index;
376
377   entry =
378       gst_util_array_binary_search (index->data, index->len,
379       sizeof (GstMatroskaIndex),
380       (GCompareDataFunc) gst_matroska_index_seek_find, GST_SEARCH_MODE_BEFORE,
381       &seek_pos, NULL);
382
383   if (entry == NULL)
384     entry = &g_array_index (index, GstMatroskaIndex, 0);
385
386   if (_index)
387     *_index = index;
388   if (_entry_index)
389     *_entry_index = entry - (GstMatroskaIndex *) index->data;
390
391   return entry;
392 }
393
394 static gint
395 gst_matroska_read_common_encoding_cmp (GstMatroskaTrackEncoding * a,
396     GstMatroskaTrackEncoding * b)
397 {
398   if (b->order > a->order)
399     return 1;
400   else if (b->order < a->order)
401     return -1;
402   else
403     return 0;
404 }
405
406 static gboolean
407 gst_matroska_read_common_encoding_order_unique (GArray * encodings, guint64
408     order)
409 {
410   gint i;
411
412   if (encodings == NULL || encodings->len == 0)
413     return TRUE;
414
415   for (i = 0; i < encodings->len; i++)
416     if (g_array_index (encodings, GstMatroskaTrackEncoding, i).order == order)
417       return FALSE;
418
419   return TRUE;
420 }
421
422 /* takes ownership of taglist */
423 void
424 gst_matroska_read_common_found_global_tag (GstMatroskaReadCommon * common,
425     GstElement * el, GstTagList * taglist)
426 {
427   if (common->global_tags) {
428     /* nothing sent yet, add to cache */
429     gst_tag_list_insert (common->global_tags, taglist, GST_TAG_MERGE_APPEND);
430     gst_tag_list_free (taglist);
431   } else {
432     /* hm, already sent, no need to cache and wait anymore */
433     GST_DEBUG_OBJECT (common, "Sending late global tags %" GST_PTR_FORMAT,
434         taglist);
435     gst_element_found_tags (el, taglist);
436   }
437 }
438
439 gint64
440 gst_matroska_read_common_get_length (GstMatroskaReadCommon * common)
441 {
442   GstFormat fmt = GST_FORMAT_BYTES;
443   gint64 end = -1;
444
445   if (!gst_pad_query_peer_duration (common->sinkpad, &fmt, &end) ||
446       fmt != GST_FORMAT_BYTES || end < 0)
447     GST_DEBUG_OBJECT (common, "no upstream length");
448
449   return end;
450 }
451
452 /* determine track to seek in */
453 GstMatroskaTrackContext *
454 gst_matroska_read_common_get_seek_track (GstMatroskaReadCommon * common,
455     GstMatroskaTrackContext * track)
456 {
457   gint i;
458
459   if (track && track->type == GST_MATROSKA_TRACK_TYPE_VIDEO)
460     return track;
461
462   for (i = 0; i < common->src->len; i++) {
463     GstMatroskaTrackContext *stream;
464
465     stream = g_ptr_array_index (common->src, i);
466     if (stream->type == GST_MATROSKA_TRACK_TYPE_VIDEO && stream->index_table)
467       track = stream;
468   }
469
470   return track;
471 }
472
473 /* skip unknown or alike element */
474 GstFlowReturn
475 gst_matroska_read_common_parse_skip (GstMatroskaReadCommon * common,
476     GstEbmlRead * ebml, const gchar * parent_name, guint id)
477 {
478   if (id == GST_EBML_ID_VOID) {
479     GST_DEBUG_OBJECT (common, "Skipping EBML Void element");
480   } else if (id == GST_EBML_ID_CRC32) {
481     GST_DEBUG_OBJECT (common, "Skipping EBML CRC32 element");
482   } else {
483     GST_WARNING_OBJECT (common,
484         "Unknown %s subelement 0x%x - ignoring", parent_name, id);
485   }
486
487   return gst_ebml_read_skip (ebml);
488 }
489
490 static GstFlowReturn
491 gst_matroska_read_common_parse_attached_file (GstMatroskaReadCommon * common,
492     GstEbmlRead * ebml, GstTagList * taglist)
493 {
494   guint32 id;
495   GstFlowReturn ret;
496   gchar *description = NULL;
497   gchar *filename = NULL;
498   gchar *mimetype = NULL;
499   guint8 *data = NULL;
500   guint64 datalen = 0;
501
502   DEBUG_ELEMENT_START (common, ebml, "AttachedFile");
503
504   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
505     DEBUG_ELEMENT_STOP (common, ebml, "AttachedFile", ret);
506     return ret;
507   }
508
509   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
510     /* read all sub-entries */
511
512     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
513       break;
514
515     switch (id) {
516       case GST_MATROSKA_ID_FILEDESCRIPTION:
517         if (description) {
518           GST_WARNING_OBJECT (common, "FileDescription can only appear once");
519           break;
520         }
521
522         ret = gst_ebml_read_utf8 (ebml, &id, &description);
523         GST_DEBUG_OBJECT (common, "FileDescription: %s",
524             GST_STR_NULL (description));
525         break;
526       case GST_MATROSKA_ID_FILENAME:
527         if (filename) {
528           GST_WARNING_OBJECT (common, "FileName can only appear once");
529           break;
530         }
531
532         ret = gst_ebml_read_utf8 (ebml, &id, &filename);
533
534         GST_DEBUG_OBJECT (common, "FileName: %s", GST_STR_NULL (filename));
535         break;
536       case GST_MATROSKA_ID_FILEMIMETYPE:
537         if (mimetype) {
538           GST_WARNING_OBJECT (common, "FileMimeType can only appear once");
539           break;
540         }
541
542         ret = gst_ebml_read_ascii (ebml, &id, &mimetype);
543         GST_DEBUG_OBJECT (common, "FileMimeType: %s", GST_STR_NULL (mimetype));
544         break;
545       case GST_MATROSKA_ID_FILEDATA:
546         if (data) {
547           GST_WARNING_OBJECT (common, "FileData can only appear once");
548           break;
549         }
550
551         ret = gst_ebml_read_binary (ebml, &id, &data, &datalen);
552         GST_DEBUG_OBJECT (common, "FileData of size %" G_GUINT64_FORMAT,
553             datalen);
554         break;
555
556       default:
557         ret = gst_matroska_read_common_parse_skip (common, ebml,
558             "AttachedFile", id);
559         break;
560       case GST_MATROSKA_ID_FILEUID:
561         ret = gst_ebml_read_skip (ebml);
562         break;
563     }
564   }
565
566   DEBUG_ELEMENT_STOP (common, ebml, "AttachedFile", ret);
567
568   if (filename && mimetype && data && datalen > 0) {
569     GstTagImageType image_type = GST_TAG_IMAGE_TYPE_NONE;
570     GstBuffer *tagbuffer = NULL;
571     GstCaps *caps;
572     gchar *filename_lc = g_utf8_strdown (filename, -1);
573
574     GST_DEBUG_OBJECT (common, "Creating tag for attachment with "
575         "filename '%s', mimetype '%s', description '%s', "
576         "size %" G_GUINT64_FORMAT, filename, mimetype,
577         GST_STR_NULL (description), datalen);
578
579     /* TODO: better heuristics for different image types */
580     if (strstr (filename_lc, "cover")) {
581       if (strstr (filename_lc, "back"))
582         image_type = GST_TAG_IMAGE_TYPE_BACK_COVER;
583       else
584         image_type = GST_TAG_IMAGE_TYPE_FRONT_COVER;
585     } else if (g_str_has_prefix (mimetype, "image/") ||
586         g_str_has_suffix (filename_lc, "png") ||
587         g_str_has_suffix (filename_lc, "jpg") ||
588         g_str_has_suffix (filename_lc, "jpeg") ||
589         g_str_has_suffix (filename_lc, "gif") ||
590         g_str_has_suffix (filename_lc, "bmp")) {
591       image_type = GST_TAG_IMAGE_TYPE_UNDEFINED;
592     }
593     g_free (filename_lc);
594
595     /* First try to create an image tag buffer from this */
596     if (image_type != GST_TAG_IMAGE_TYPE_NONE) {
597       tagbuffer =
598           gst_tag_image_data_to_image_buffer (data, datalen, image_type);
599
600       if (!tagbuffer)
601         image_type = GST_TAG_IMAGE_TYPE_NONE;
602     }
603
604     /* if this failed create an attachment buffer */
605     if (!tagbuffer) {
606       tagbuffer = gst_buffer_new_and_alloc (datalen);
607
608       memcpy (GST_BUFFER_DATA (tagbuffer), data, datalen);
609       GST_BUFFER_SIZE (tagbuffer) = datalen;
610
611       caps = gst_type_find_helper_for_buffer (NULL, tagbuffer, NULL);
612       if (caps == NULL)
613         caps = gst_caps_new_simple (mimetype, NULL);
614       gst_buffer_set_caps (tagbuffer, caps);
615       gst_caps_unref (caps);
616     }
617
618     /* Set filename and description on the caps */
619     caps = GST_BUFFER_CAPS (tagbuffer);
620     gst_caps_set_simple (caps, "filename", G_TYPE_STRING, filename, NULL);
621     if (description)
622       gst_caps_set_simple (caps, "description", G_TYPE_STRING, description,
623           NULL);
624
625     GST_DEBUG_OBJECT (common,
626         "Created attachment buffer with caps: %" GST_PTR_FORMAT, caps);
627
628     /* and append to the tag list */
629     if (image_type != GST_TAG_IMAGE_TYPE_NONE)
630       gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND, GST_TAG_IMAGE, tagbuffer,
631           NULL);
632     else
633       gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND, GST_TAG_ATTACHMENT,
634           tagbuffer, NULL);
635   }
636
637   g_free (filename);
638   g_free (mimetype);
639   g_free (data);
640   g_free (description);
641
642   return ret;
643 }
644
645 GstFlowReturn
646 gst_matroska_read_common_parse_attachments (GstMatroskaReadCommon * common,
647     GstElement * el, GstEbmlRead * ebml)
648 {
649   guint32 id;
650   GstFlowReturn ret = GST_FLOW_OK;
651   GstTagList *taglist;
652
653   DEBUG_ELEMENT_START (common, ebml, "Attachments");
654
655   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
656     DEBUG_ELEMENT_STOP (common, ebml, "Attachments", ret);
657     return ret;
658   }
659
660   taglist = gst_tag_list_new ();
661
662   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
663     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
664       break;
665
666     switch (id) {
667       case GST_MATROSKA_ID_ATTACHEDFILE:
668         ret = gst_matroska_read_common_parse_attached_file (common, ebml,
669             taglist);
670         break;
671
672       default:
673         ret = gst_matroska_read_common_parse_skip (common, ebml,
674             "Attachments", id);
675         break;
676     }
677   }
678   DEBUG_ELEMENT_STOP (common, ebml, "Attachments", ret);
679
680   if (gst_structure_n_fields (GST_STRUCTURE (taglist)) > 0) {
681     GST_DEBUG_OBJECT (common, "Storing attachment tags");
682     gst_matroska_read_common_found_global_tag (common, el, taglist);
683   } else {
684     GST_DEBUG_OBJECT (common, "No valid attachments found");
685     gst_tag_list_free (taglist);
686   }
687
688   common->attachments_parsed = TRUE;
689
690   return ret;
691 }
692
693 GstFlowReturn
694 gst_matroska_read_common_parse_header (GstMatroskaReadCommon * common,
695     GstEbmlRead * ebml)
696 {
697   GstFlowReturn ret;
698   gchar *doctype;
699   guint version;
700   guint32 id;
701
702   /* this function is the first to be called */
703
704   /* default init */
705   doctype = NULL;
706   version = 1;
707
708   ret = gst_ebml_peek_id (ebml, &id);
709   if (ret != GST_FLOW_OK)
710     return ret;
711
712   GST_DEBUG_OBJECT (common, "id: %08x", id);
713
714   if (id != GST_EBML_ID_HEADER) {
715     GST_ERROR_OBJECT (common, "Failed to read header");
716     goto exit;
717   }
718
719   ret = gst_ebml_read_master (ebml, &id);
720   if (ret != GST_FLOW_OK)
721     return ret;
722
723   while (gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
724     ret = gst_ebml_peek_id (ebml, &id);
725     if (ret != GST_FLOW_OK)
726       return ret;
727
728     switch (id) {
729         /* is our read version uptodate? */
730       case GST_EBML_ID_EBMLREADVERSION:{
731         guint64 num;
732
733         ret = gst_ebml_read_uint (ebml, &id, &num);
734         if (ret != GST_FLOW_OK)
735           return ret;
736         if (num != GST_EBML_VERSION) {
737           GST_ERROR_OBJECT (ebml, "Unsupported EBML version %" G_GUINT64_FORMAT,
738               num);
739           return GST_FLOW_ERROR;
740         }
741
742         GST_DEBUG_OBJECT (ebml, "EbmlReadVersion: %" G_GUINT64_FORMAT, num);
743         break;
744       }
745
746         /* we only handle 8 byte lengths at max */
747       case GST_EBML_ID_EBMLMAXSIZELENGTH:{
748         guint64 num;
749
750         ret = gst_ebml_read_uint (ebml, &id, &num);
751         if (ret != GST_FLOW_OK)
752           return ret;
753         if (num > sizeof (guint64)) {
754           GST_ERROR_OBJECT (ebml,
755               "Unsupported EBML maximum size %" G_GUINT64_FORMAT, num);
756           return GST_FLOW_ERROR;
757         }
758         GST_DEBUG_OBJECT (ebml, "EbmlMaxSizeLength: %" G_GUINT64_FORMAT, num);
759         break;
760       }
761
762         /* we handle 4 byte IDs at max */
763       case GST_EBML_ID_EBMLMAXIDLENGTH:{
764         guint64 num;
765
766         ret = gst_ebml_read_uint (ebml, &id, &num);
767         if (ret != GST_FLOW_OK)
768           return ret;
769         if (num > sizeof (guint32)) {
770           GST_ERROR_OBJECT (ebml,
771               "Unsupported EBML maximum ID %" G_GUINT64_FORMAT, num);
772           return GST_FLOW_ERROR;
773         }
774         GST_DEBUG_OBJECT (ebml, "EbmlMaxIdLength: %" G_GUINT64_FORMAT, num);
775         break;
776       }
777
778       case GST_EBML_ID_DOCTYPE:{
779         gchar *text;
780
781         ret = gst_ebml_read_ascii (ebml, &id, &text);
782         if (ret != GST_FLOW_OK)
783           return ret;
784
785         GST_DEBUG_OBJECT (ebml, "EbmlDocType: %s", GST_STR_NULL (text));
786
787         if (doctype)
788           g_free (doctype);
789         doctype = text;
790         break;
791       }
792
793       case GST_EBML_ID_DOCTYPEREADVERSION:{
794         guint64 num;
795
796         ret = gst_ebml_read_uint (ebml, &id, &num);
797         if (ret != GST_FLOW_OK)
798           return ret;
799         version = num;
800         GST_DEBUG_OBJECT (ebml, "EbmlReadVersion: %" G_GUINT64_FORMAT, num);
801         break;
802       }
803
804       default:
805         ret = gst_matroska_read_common_parse_skip (common, ebml,
806             "EBML header", id);
807         if (ret != GST_FLOW_OK)
808           return ret;
809         break;
810
811         /* we ignore these two, as they don't tell us anything we care about */
812       case GST_EBML_ID_EBMLVERSION:
813       case GST_EBML_ID_DOCTYPEVERSION:
814         ret = gst_ebml_read_skip (ebml);
815         if (ret != GST_FLOW_OK)
816           return ret;
817         break;
818     }
819   }
820
821 exit:
822
823   if ((doctype != NULL && !strcmp (doctype, GST_MATROSKA_DOCTYPE_MATROSKA)) ||
824       (doctype != NULL && !strcmp (doctype, GST_MATROSKA_DOCTYPE_WEBM)) ||
825       (doctype == NULL)) {
826     if (version <= 2) {
827       if (doctype) {
828         GST_INFO_OBJECT (common, "Input is %s version %d", doctype, version);
829       } else {
830         GST_WARNING_OBJECT (common, "Input is EBML without doctype, assuming "
831             "matroska (version %d)", version);
832       }
833       ret = GST_FLOW_OK;
834     } else {
835       GST_ELEMENT_ERROR (common, STREAM, DEMUX, (NULL),
836           ("Demuxer version (2) is too old to read %s version %d",
837               GST_STR_NULL (doctype), version));
838       ret = GST_FLOW_ERROR;
839     }
840     g_free (doctype);
841   } else {
842     GST_ELEMENT_ERROR (common, STREAM, WRONG_TYPE, (NULL),
843         ("Input is not a matroska stream (doctype=%s)", doctype));
844     ret = GST_FLOW_ERROR;
845     g_free (doctype);
846   }
847
848   return ret;
849 }
850
851 static GstFlowReturn
852 gst_matroska_read_common_parse_index_cuetrack (GstMatroskaReadCommon * common,
853     GstEbmlRead * ebml, guint * nentries)
854 {
855   guint32 id;
856   GstFlowReturn ret;
857   GstMatroskaIndex idx;
858
859   idx.pos = (guint64) - 1;
860   idx.track = 0;
861   idx.time = GST_CLOCK_TIME_NONE;
862   idx.block = 1;
863
864   DEBUG_ELEMENT_START (common, ebml, "CueTrackPositions");
865
866   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
867     DEBUG_ELEMENT_STOP (common, ebml, "CueTrackPositions", ret);
868     return ret;
869   }
870
871   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
872     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
873       break;
874
875     switch (id) {
876         /* track number */
877       case GST_MATROSKA_ID_CUETRACK:
878       {
879         guint64 num;
880
881         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
882           break;
883
884         if (num == 0) {
885           idx.track = 0;
886           GST_WARNING_OBJECT (common, "Invalid CueTrack 0");
887           break;
888         }
889
890         GST_DEBUG_OBJECT (common, "CueTrack: %" G_GUINT64_FORMAT, num);
891         idx.track = num;
892         break;
893       }
894
895         /* position in file */
896       case GST_MATROSKA_ID_CUECLUSTERPOSITION:
897       {
898         guint64 num;
899
900         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
901           break;
902
903         if (num > G_MAXINT64) {
904           GST_WARNING_OBJECT (common, "CueClusterPosition %" G_GUINT64_FORMAT
905               " too large", num);
906           break;
907         }
908
909         idx.pos = num;
910         break;
911       }
912
913         /* number of block in the cluster */
914       case GST_MATROSKA_ID_CUEBLOCKNUMBER:
915       {
916         guint64 num;
917
918         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
919           break;
920
921         if (num == 0) {
922           GST_WARNING_OBJECT (common, "Invalid CueBlockNumber 0");
923           break;
924         }
925
926         GST_DEBUG_OBJECT (common, "CueBlockNumber: %" G_GUINT64_FORMAT, num);
927         idx.block = num;
928
929         /* mild sanity check, disregard strange cases ... */
930         if (idx.block > G_MAXUINT16) {
931           GST_DEBUG_OBJECT (common, "... looks suspicious, ignoring");
932           idx.block = 1;
933         }
934         break;
935       }
936
937       default:
938         ret = gst_matroska_read_common_parse_skip (common, ebml,
939             "CueTrackPositions", id);
940         break;
941
942       case GST_MATROSKA_ID_CUECODECSTATE:
943       case GST_MATROSKA_ID_CUEREFERENCE:
944         ret = gst_ebml_read_skip (ebml);
945         break;
946     }
947   }
948
949   DEBUG_ELEMENT_STOP (common, ebml, "CueTrackPositions", ret);
950
951   if ((ret == GST_FLOW_OK || ret == GST_FLOW_UNEXPECTED)
952       && idx.pos != (guint64) - 1 && idx.track > 0) {
953     g_array_append_val (common->index, idx);
954     (*nentries)++;
955   } else if (ret == GST_FLOW_OK || ret == GST_FLOW_UNEXPECTED) {
956     GST_DEBUG_OBJECT (common, "CueTrackPositions without valid content");
957   }
958
959   return ret;
960 }
961
962 static GstFlowReturn
963 gst_matroska_read_common_parse_index_pointentry (GstMatroskaReadCommon *
964     common, GstEbmlRead * ebml)
965 {
966   guint32 id;
967   GstFlowReturn ret;
968   GstClockTime time = GST_CLOCK_TIME_NONE;
969   guint nentries = 0;
970
971   DEBUG_ELEMENT_START (common, ebml, "CuePoint");
972
973   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
974     DEBUG_ELEMENT_STOP (common, ebml, "CuePoint", ret);
975     return ret;
976   }
977
978   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
979     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
980       break;
981
982     switch (id) {
983         /* one single index entry ('point') */
984       case GST_MATROSKA_ID_CUETIME:
985       {
986         if ((ret = gst_ebml_read_uint (ebml, &id, &time)) != GST_FLOW_OK)
987           break;
988
989         GST_DEBUG_OBJECT (common, "CueTime: %" G_GUINT64_FORMAT, time);
990         time = time * common->time_scale;
991         break;
992       }
993
994         /* position in the file + track to which it belongs */
995       case GST_MATROSKA_ID_CUETRACKPOSITIONS:
996       {
997         if ((ret =
998                 gst_matroska_read_common_parse_index_cuetrack (common, ebml,
999                     &nentries)) != GST_FLOW_OK)
1000           break;
1001         break;
1002       }
1003
1004       default:
1005         ret = gst_matroska_read_common_parse_skip (common, ebml, "CuePoint",
1006             id);
1007         break;
1008     }
1009   }
1010
1011   DEBUG_ELEMENT_STOP (common, ebml, "CuePoint", ret);
1012
1013   if (nentries > 0) {
1014     if (time == GST_CLOCK_TIME_NONE) {
1015       GST_WARNING_OBJECT (common, "CuePoint without valid time");
1016       g_array_remove_range (common->index, common->index->len - nentries,
1017           nentries);
1018     } else {
1019       gint i;
1020
1021       for (i = common->index->len - nentries; i < common->index->len; i++) {
1022         GstMatroskaIndex *idx =
1023             &g_array_index (common->index, GstMatroskaIndex, i);
1024
1025         idx->time = time;
1026         GST_DEBUG_OBJECT (common, "Index entry: pos=%" G_GUINT64_FORMAT
1027             ", time=%" GST_TIME_FORMAT ", track=%u, block=%u", idx->pos,
1028             GST_TIME_ARGS (idx->time), (guint) idx->track, (guint) idx->block);
1029       }
1030     }
1031   } else {
1032     GST_DEBUG_OBJECT (common, "Empty CuePoint");
1033   }
1034
1035   return ret;
1036 }
1037
1038 gint
1039 gst_matroska_read_common_stream_from_num (GstMatroskaReadCommon * common,
1040     guint track_num)
1041 {
1042   guint n;
1043
1044   g_assert (common->src->len == common->num_streams);
1045   for (n = 0; n < common->src->len; n++) {
1046     GstMatroskaTrackContext *context = g_ptr_array_index (common->src, n);
1047
1048     if (context->num == track_num) {
1049       return n;
1050     }
1051   }
1052
1053   if (n == common->num_streams)
1054     GST_WARNING_OBJECT (common,
1055         "Failed to find corresponding pad for tracknum %d", track_num);
1056
1057   return -1;
1058 }
1059
1060 GstFlowReturn
1061 gst_matroska_read_common_parse_index (GstMatroskaReadCommon * common,
1062     GstEbmlRead * ebml)
1063 {
1064   guint32 id;
1065   GstFlowReturn ret = GST_FLOW_OK;
1066   guint i;
1067
1068   if (common->index)
1069     g_array_free (common->index, TRUE);
1070   common->index =
1071       g_array_sized_new (FALSE, FALSE, sizeof (GstMatroskaIndex), 128);
1072
1073   DEBUG_ELEMENT_START (common, ebml, "Cues");
1074
1075   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
1076     DEBUG_ELEMENT_STOP (common, ebml, "Cues", ret);
1077     return ret;
1078   }
1079
1080   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1081     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1082       break;
1083
1084     switch (id) {
1085         /* one single index entry ('point') */
1086       case GST_MATROSKA_ID_POINTENTRY:
1087         ret = gst_matroska_read_common_parse_index_pointentry (common, ebml);
1088         break;
1089
1090       default:
1091         ret = gst_matroska_read_common_parse_skip (common, ebml, "Cues", id);
1092         break;
1093     }
1094   }
1095   DEBUG_ELEMENT_STOP (common, ebml, "Cues", ret);
1096
1097   /* Sort index by time, smallest time first, for easier searching */
1098   g_array_sort (common->index, (GCompareFunc) gst_matroska_index_compare);
1099
1100   /* Now sort the track specific index entries into their own arrays */
1101   for (i = 0; i < common->index->len; i++) {
1102     GstMatroskaIndex *idx = &g_array_index (common->index, GstMatroskaIndex,
1103         i);
1104     gint track_num;
1105     GstMatroskaTrackContext *ctx;
1106
1107     if (common->element_index) {
1108       gint writer_id;
1109
1110       if (idx->track != 0 &&
1111           (track_num =
1112               gst_matroska_read_common_stream_from_num (common,
1113                   idx->track)) != -1) {
1114         ctx = g_ptr_array_index (common->src, track_num);
1115
1116         if (ctx->index_writer_id == -1)
1117           gst_index_get_writer_id (common->element_index,
1118               GST_OBJECT (ctx->pad), &ctx->index_writer_id);
1119         writer_id = ctx->index_writer_id;
1120       } else {
1121         if (common->element_index_writer_id == -1)
1122           gst_index_get_writer_id (common->element_index, GST_OBJECT (common),
1123               &common->element_index_writer_id);
1124         writer_id = common->element_index_writer_id;
1125       }
1126
1127       GST_LOG_OBJECT (common, "adding association %" GST_TIME_FORMAT "-> %"
1128           G_GUINT64_FORMAT " for writer id %d", GST_TIME_ARGS (idx->time),
1129           idx->pos, writer_id);
1130       gst_index_add_association (common->element_index, writer_id,
1131           GST_ASSOCIATION_FLAG_KEY_UNIT, GST_FORMAT_TIME, idx->time,
1132           GST_FORMAT_BYTES, idx->pos + common->ebml_segment_start, NULL);
1133     }
1134
1135     if (idx->track == 0)
1136       continue;
1137
1138     track_num = gst_matroska_read_common_stream_from_num (common, idx->track);
1139     if (track_num == -1)
1140       continue;
1141
1142     ctx = g_ptr_array_index (common->src, track_num);
1143
1144     if (ctx->index_table == NULL)
1145       ctx->index_table =
1146           g_array_sized_new (FALSE, FALSE, sizeof (GstMatroskaIndex), 128);
1147
1148     g_array_append_vals (ctx->index_table, idx, 1);
1149   }
1150
1151   common->index_parsed = TRUE;
1152
1153   /* sanity check; empty index normalizes to no index */
1154   if (common->index->len == 0) {
1155     g_array_free (common->index, TRUE);
1156     common->index = NULL;
1157   }
1158
1159   return ret;
1160 }
1161
1162 GstFlowReturn
1163 gst_matroska_read_common_parse_info (GstMatroskaReadCommon * common,
1164     GstElement * el, GstEbmlRead * ebml)
1165 {
1166   GstFlowReturn ret = GST_FLOW_OK;
1167   gdouble dur_f = -1.0;
1168   guint32 id;
1169
1170   DEBUG_ELEMENT_START (common, ebml, "SegmentInfo");
1171
1172   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
1173     DEBUG_ELEMENT_STOP (common, ebml, "SegmentInfo", ret);
1174     return ret;
1175   }
1176
1177   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1178     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1179       break;
1180
1181     switch (id) {
1182         /* cluster timecode */
1183       case GST_MATROSKA_ID_TIMECODESCALE:{
1184         guint64 num;
1185
1186         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1187           break;
1188
1189
1190         GST_DEBUG_OBJECT (common, "TimeCodeScale: %" G_GUINT64_FORMAT, num);
1191         common->time_scale = num;
1192         break;
1193       }
1194
1195       case GST_MATROSKA_ID_DURATION:{
1196         if ((ret = gst_ebml_read_float (ebml, &id, &dur_f)) != GST_FLOW_OK)
1197           break;
1198
1199         if (dur_f <= 0.0) {
1200           GST_WARNING_OBJECT (common, "Invalid duration %lf", dur_f);
1201           break;
1202         }
1203
1204         GST_DEBUG_OBJECT (common, "Duration: %lf", dur_f);
1205         break;
1206       }
1207
1208       case GST_MATROSKA_ID_WRITINGAPP:{
1209         gchar *text;
1210
1211         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
1212           break;
1213
1214         GST_DEBUG_OBJECT (common, "WritingApp: %s", GST_STR_NULL (text));
1215         common->writing_app = text;
1216         break;
1217       }
1218
1219       case GST_MATROSKA_ID_MUXINGAPP:{
1220         gchar *text;
1221
1222         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
1223           break;
1224
1225         GST_DEBUG_OBJECT (common, "MuxingApp: %s", GST_STR_NULL (text));
1226         common->muxing_app = text;
1227         break;
1228       }
1229
1230       case GST_MATROSKA_ID_DATEUTC:{
1231         gint64 time;
1232
1233         if ((ret = gst_ebml_read_date (ebml, &id, &time)) != GST_FLOW_OK)
1234           break;
1235
1236         GST_DEBUG_OBJECT (common, "DateUTC: %" G_GINT64_FORMAT, time);
1237         common->created = time;
1238         break;
1239       }
1240
1241       case GST_MATROSKA_ID_TITLE:{
1242         gchar *text;
1243         GstTagList *taglist;
1244
1245         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
1246           break;
1247
1248         GST_DEBUG_OBJECT (common, "Title: %s", GST_STR_NULL (text));
1249         taglist = gst_tag_list_new ();
1250         gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND, GST_TAG_TITLE, text,
1251             NULL);
1252         gst_matroska_read_common_found_global_tag (common, el, taglist);
1253         g_free (text);
1254         break;
1255       }
1256
1257       default:
1258         ret = gst_matroska_read_common_parse_skip (common, ebml,
1259             "SegmentInfo", id);
1260         break;
1261
1262         /* fall through */
1263       case GST_MATROSKA_ID_SEGMENTUID:
1264       case GST_MATROSKA_ID_SEGMENTFILENAME:
1265       case GST_MATROSKA_ID_PREVUID:
1266       case GST_MATROSKA_ID_PREVFILENAME:
1267       case GST_MATROSKA_ID_NEXTUID:
1268       case GST_MATROSKA_ID_NEXTFILENAME:
1269       case GST_MATROSKA_ID_SEGMENTFAMILY:
1270       case GST_MATROSKA_ID_CHAPTERTRANSLATE:
1271         ret = gst_ebml_read_skip (ebml);
1272         break;
1273     }
1274   }
1275
1276   if (dur_f > 0.0) {
1277     GstClockTime dur_u;
1278
1279     dur_u = gst_gdouble_to_guint64 (dur_f *
1280         gst_guint64_to_gdouble (common->time_scale));
1281     if (GST_CLOCK_TIME_IS_VALID (dur_u) && dur_u <= G_MAXINT64)
1282       gst_segment_set_duration (&common->segment, GST_FORMAT_TIME, dur_u);
1283   }
1284
1285   DEBUG_ELEMENT_STOP (common, ebml, "SegmentInfo", ret);
1286
1287   common->segmentinfo_parsed = TRUE;
1288
1289   return ret;
1290 }
1291
1292 static GstFlowReturn
1293 gst_matroska_read_common_parse_metadata_id_simple_tag (GstMatroskaReadCommon *
1294     common, GstEbmlRead * ebml, GstTagList ** p_taglist)
1295 {
1296   /* FIXME: check if there are more useful mappings */
1297   static const struct
1298   {
1299     const gchar *matroska_tagname;
1300     const gchar *gstreamer_tagname;
1301   }
1302   tag_conv[] = {
1303     {
1304     GST_MATROSKA_TAG_ID_TITLE, GST_TAG_TITLE}, {
1305     GST_MATROSKA_TAG_ID_ARTIST, GST_TAG_ARTIST}, {
1306     GST_MATROSKA_TAG_ID_AUTHOR, GST_TAG_ARTIST}, {
1307     GST_MATROSKA_TAG_ID_ALBUM, GST_TAG_ALBUM}, {
1308     GST_MATROSKA_TAG_ID_COMMENTS, GST_TAG_COMMENT}, {
1309     GST_MATROSKA_TAG_ID_BITSPS, GST_TAG_BITRATE}, {
1310     GST_MATROSKA_TAG_ID_BPS, GST_TAG_BITRATE}, {
1311     GST_MATROSKA_TAG_ID_ENCODER, GST_TAG_ENCODER}, {
1312     GST_MATROSKA_TAG_ID_DATE, GST_TAG_DATE}, {
1313     GST_MATROSKA_TAG_ID_ISRC, GST_TAG_ISRC}, {
1314     GST_MATROSKA_TAG_ID_COPYRIGHT, GST_TAG_COPYRIGHT}, {
1315     GST_MATROSKA_TAG_ID_BPM, GST_TAG_BEATS_PER_MINUTE}, {
1316     GST_MATROSKA_TAG_ID_TERMS_OF_USE, GST_TAG_LICENSE}, {
1317     GST_MATROSKA_TAG_ID_COMPOSER, GST_TAG_COMPOSER}, {
1318     GST_MATROSKA_TAG_ID_LEAD_PERFORMER, GST_TAG_PERFORMER}, {
1319     GST_MATROSKA_TAG_ID_GENRE, GST_TAG_GENRE}
1320   };
1321   GstFlowReturn ret;
1322   guint32 id;
1323   gchar *value = NULL;
1324   gchar *tag = NULL;
1325
1326   DEBUG_ELEMENT_START (common, ebml, "SimpleTag");
1327
1328   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
1329     DEBUG_ELEMENT_STOP (common, ebml, "SimpleTag", ret);
1330     return ret;
1331   }
1332
1333   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1334     /* read all sub-entries */
1335
1336     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1337       break;
1338
1339     switch (id) {
1340       case GST_MATROSKA_ID_TAGNAME:
1341         g_free (tag);
1342         tag = NULL;
1343         ret = gst_ebml_read_ascii (ebml, &id, &tag);
1344         GST_DEBUG_OBJECT (common, "TagName: %s", GST_STR_NULL (tag));
1345         break;
1346
1347       case GST_MATROSKA_ID_TAGSTRING:
1348         g_free (value);
1349         value = NULL;
1350         ret = gst_ebml_read_utf8 (ebml, &id, &value);
1351         GST_DEBUG_OBJECT (common, "TagString: %s", GST_STR_NULL (value));
1352         break;
1353
1354       default:
1355         ret = gst_matroska_read_common_parse_skip (common, ebml, "SimpleTag",
1356             id);
1357         break;
1358         /* fall-through */
1359
1360       case GST_MATROSKA_ID_TAGLANGUAGE:
1361       case GST_MATROSKA_ID_TAGDEFAULT:
1362       case GST_MATROSKA_ID_TAGBINARY:
1363         ret = gst_ebml_read_skip (ebml);
1364         break;
1365     }
1366   }
1367
1368   DEBUG_ELEMENT_STOP (common, ebml, "SimpleTag", ret);
1369
1370   if (tag && value) {
1371     guint i;
1372
1373     for (i = 0; i < G_N_ELEMENTS (tag_conv); i++) {
1374       const gchar *tagname_gst = tag_conv[i].gstreamer_tagname;
1375
1376       const gchar *tagname_mkv = tag_conv[i].matroska_tagname;
1377
1378       if (strcmp (tagname_mkv, tag) == 0) {
1379         GValue dest = { 0, };
1380         GType dest_type = gst_tag_get_type (tagname_gst);
1381
1382         /* Ensure that any date string is complete */
1383         if (dest_type == GST_TYPE_DATE) {
1384           guint year = 1901, month = 1, day = 1;
1385
1386           /* Dates can be yyyy-MM-dd, yyyy-MM or yyyy, but we need
1387            * the first type */
1388           if (sscanf (value, "%04u-%02u-%02u", &year, &month, &day) != 0) {
1389             g_free (value);
1390             value = g_strdup_printf ("%04u-%02u-%02u", year, month, day);
1391           }
1392         }
1393
1394         g_value_init (&dest, dest_type);
1395         if (gst_value_deserialize (&dest, value)) {
1396           gst_tag_list_add_values (*p_taglist, GST_TAG_MERGE_APPEND,
1397               tagname_gst, &dest, NULL);
1398         } else {
1399           GST_WARNING_OBJECT (common, "Can't transform tag '%s' with "
1400               "value '%s' to target type '%s'", tag, value,
1401               g_type_name (dest_type));
1402         }
1403         g_value_unset (&dest);
1404         break;
1405       }
1406     }
1407   }
1408
1409   g_free (tag);
1410   g_free (value);
1411
1412   return ret;
1413 }
1414
1415 static GstFlowReturn
1416 gst_matroska_read_common_parse_metadata_id_tag (GstMatroskaReadCommon * common,
1417     GstEbmlRead * ebml, GstTagList ** p_taglist)
1418 {
1419   guint32 id;
1420   GstFlowReturn ret;
1421
1422   DEBUG_ELEMENT_START (common, ebml, "Tag");
1423
1424   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
1425     DEBUG_ELEMENT_STOP (common, ebml, "Tag", ret);
1426     return ret;
1427   }
1428
1429   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1430     /* read all sub-entries */
1431
1432     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1433       break;
1434
1435     switch (id) {
1436       case GST_MATROSKA_ID_SIMPLETAG:
1437         ret = gst_matroska_read_common_parse_metadata_id_simple_tag (common,
1438             ebml, p_taglist);
1439         break;
1440
1441       default:
1442         ret = gst_matroska_read_common_parse_skip (common, ebml, "Tag", id);
1443         break;
1444     }
1445   }
1446
1447   DEBUG_ELEMENT_STOP (common, ebml, "Tag", ret);
1448
1449   return ret;
1450 }
1451
1452 GstFlowReturn
1453 gst_matroska_read_common_parse_metadata (GstMatroskaReadCommon * common,
1454     GstElement * el, GstEbmlRead * ebml)
1455 {
1456   GstTagList *taglist;
1457   GstFlowReturn ret = GST_FLOW_OK;
1458   guint32 id;
1459   GList *l;
1460   guint64 curpos;
1461
1462   curpos = gst_ebml_read_get_pos (ebml);
1463
1464   /* Make sure we don't parse a tags element twice and
1465    * post it's tags twice */
1466   curpos = gst_ebml_read_get_pos (ebml);
1467   for (l = common->tags_parsed; l; l = l->next) {
1468     guint64 *pos = l->data;
1469
1470     if (*pos == curpos) {
1471       GST_DEBUG_OBJECT (common, "Skipping already parsed Tags at offset %"
1472           G_GUINT64_FORMAT, curpos);
1473       return GST_FLOW_OK;
1474     }
1475   }
1476
1477   common->tags_parsed =
1478       g_list_prepend (common->tags_parsed, g_slice_new (guint64));
1479   *((guint64 *) common->tags_parsed->data) = curpos;
1480   /* fall-through */
1481
1482   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
1483     DEBUG_ELEMENT_STOP (common, ebml, "Tags", ret);
1484     return ret;
1485   }
1486
1487   taglist = gst_tag_list_new ();
1488
1489   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1490     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1491       break;
1492
1493     switch (id) {
1494       case GST_MATROSKA_ID_TAG:
1495         ret = gst_matroska_read_common_parse_metadata_id_tag (common, ebml,
1496             &taglist);
1497         break;
1498
1499       default:
1500         ret = gst_matroska_read_common_parse_skip (common, ebml, "Tags", id);
1501         break;
1502         /* FIXME: Use to limit the tags to specific pads */
1503       case GST_MATROSKA_ID_TARGETS:
1504         ret = gst_ebml_read_skip (ebml);
1505         break;
1506     }
1507   }
1508
1509   DEBUG_ELEMENT_STOP (common, ebml, "Tags", ret);
1510
1511   gst_matroska_read_common_found_global_tag (common, el, taglist);
1512
1513   return ret;
1514 }
1515
1516 static const guint8 *
1517 gst_matroska_read_common_peek_adapter (GstMatroskaReadCommon * common, guint
1518     peek)
1519 {
1520   return gst_adapter_peek (common->adapter, peek);
1521 }
1522
1523 /*
1524  * Calls pull_range for (offset,size) without advancing our offset
1525  */
1526 GstFlowReturn
1527 gst_matroska_read_common_peek_bytes (GstMatroskaReadCommon * common, guint64
1528     offset, guint size, GstBuffer ** p_buf, guint8 ** bytes)
1529 {
1530   GstFlowReturn ret;
1531
1532   /* Caching here actually makes much less difference than one would expect.
1533    * We do it mainly to avoid pulling buffers of 1 byte all the time */
1534   if (common->cached_buffer) {
1535     guint64 cache_offset = GST_BUFFER_OFFSET (common->cached_buffer);
1536     guint cache_size = GST_BUFFER_SIZE (common->cached_buffer);
1537
1538     if (cache_offset <= common->offset &&
1539         (common->offset + size) <= (cache_offset + cache_size)) {
1540       if (p_buf)
1541         *p_buf = gst_buffer_create_sub (common->cached_buffer,
1542             common->offset - cache_offset, size);
1543       if (bytes)
1544         *bytes = GST_BUFFER_DATA (common->cached_buffer) + common->offset -
1545             cache_offset;
1546       return GST_FLOW_OK;
1547     }
1548     /* not enough data in the cache, free cache and get a new one */
1549     gst_buffer_unref (common->cached_buffer);
1550     common->cached_buffer = NULL;
1551   }
1552
1553   /* refill the cache */
1554   ret = gst_pad_pull_range (common->sinkpad, common->offset,
1555       MAX (size, 64 * 1024), &common->cached_buffer);
1556   if (ret != GST_FLOW_OK) {
1557     common->cached_buffer = NULL;
1558     return ret;
1559   }
1560
1561   if (GST_BUFFER_SIZE (common->cached_buffer) >= size) {
1562     if (p_buf)
1563       *p_buf = gst_buffer_create_sub (common->cached_buffer, 0, size);
1564     if (bytes)
1565       *bytes = GST_BUFFER_DATA (common->cached_buffer);
1566     return GST_FLOW_OK;
1567   }
1568
1569   /* Not possible to get enough data, try a last time with
1570    * requesting exactly the size we need */
1571   gst_buffer_unref (common->cached_buffer);
1572   common->cached_buffer = NULL;
1573
1574   ret =
1575       gst_pad_pull_range (common->sinkpad, common->offset, size,
1576       &common->cached_buffer);
1577   if (ret != GST_FLOW_OK) {
1578     GST_DEBUG_OBJECT (common, "pull_range returned %d", ret);
1579     if (p_buf)
1580       *p_buf = NULL;
1581     if (bytes)
1582       *bytes = NULL;
1583     return ret;
1584   }
1585
1586   if (GST_BUFFER_SIZE (common->cached_buffer) < size) {
1587     GST_WARNING_OBJECT (common, "Dropping short buffer at offset %"
1588         G_GUINT64_FORMAT ": wanted %u bytes, got %u bytes", common->offset,
1589         size, GST_BUFFER_SIZE (common->cached_buffer));
1590
1591     gst_buffer_unref (common->cached_buffer);
1592     common->cached_buffer = NULL;
1593     if (p_buf)
1594       *p_buf = NULL;
1595     if (bytes)
1596       *bytes = NULL;
1597     return GST_FLOW_UNEXPECTED;
1598   }
1599
1600   if (p_buf)
1601     *p_buf = gst_buffer_create_sub (common->cached_buffer, 0, size);
1602   if (bytes)
1603     *bytes = GST_BUFFER_DATA (common->cached_buffer);
1604
1605   return GST_FLOW_OK;
1606 }
1607
1608 static const guint8 *
1609 gst_matroska_read_common_peek_pull (GstMatroskaReadCommon * common, guint peek)
1610 {
1611   guint8 *data = NULL;
1612
1613   gst_matroska_read_common_peek_bytes (common, common->offset, peek, NULL,
1614       &data);
1615   return data;
1616 }
1617
1618 GstFlowReturn
1619 gst_matroska_read_common_peek_id_length_pull (GstMatroskaReadCommon * common,
1620     GstElement * el, guint32 * _id, guint64 * _length, guint * _needed)
1621 {
1622   return gst_ebml_peek_id_length (_id, _length, _needed,
1623       (GstPeekData) gst_matroska_read_common_peek_pull, (gpointer) common, el,
1624       common->offset);
1625 }
1626
1627 GstFlowReturn
1628 gst_matroska_read_common_peek_id_length_push (GstMatroskaReadCommon * common,
1629     GstElement * el, guint32 * _id, guint64 * _length, guint * _needed)
1630 {
1631   return gst_ebml_peek_id_length (_id, _length, _needed,
1632       (GstPeekData) gst_matroska_read_common_peek_adapter, (gpointer) common,
1633       el, common->offset);
1634 }
1635
1636 static GstFlowReturn
1637 gst_matroska_read_common_read_track_encoding (GstMatroskaReadCommon * common,
1638     GstEbmlRead * ebml, GstMatroskaTrackContext * context)
1639 {
1640   GstMatroskaTrackEncoding enc = { 0, };
1641   GstFlowReturn ret;
1642   guint32 id;
1643
1644   DEBUG_ELEMENT_START (common, ebml, "ContentEncoding");
1645   /* Set default values */
1646   enc.scope = 1;
1647   /* All other default values are 0 */
1648
1649   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
1650     DEBUG_ELEMENT_STOP (common, ebml, "ContentEncoding", ret);
1651     return ret;
1652   }
1653
1654   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1655     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1656       break;
1657
1658     switch (id) {
1659       case GST_MATROSKA_ID_CONTENTENCODINGORDER:{
1660         guint64 num;
1661
1662         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1663           break;
1664
1665         if (!gst_matroska_read_common_encoding_order_unique (context->encodings,
1666                 num)) {
1667           GST_ERROR_OBJECT (common, "ContentEncodingOrder %" G_GUINT64_FORMAT
1668               "is not unique for track %d", num, context->num);
1669           ret = GST_FLOW_ERROR;
1670           break;
1671         }
1672
1673         GST_DEBUG_OBJECT (common, "ContentEncodingOrder: %" G_GUINT64_FORMAT,
1674             num);
1675         enc.order = num;
1676         break;
1677       }
1678       case GST_MATROSKA_ID_CONTENTENCODINGSCOPE:{
1679         guint64 num;
1680
1681         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1682           break;
1683
1684         if (num > 7 && num == 0) {
1685           GST_ERROR_OBJECT (common, "Invalid ContentEncodingScope %"
1686               G_GUINT64_FORMAT, num);
1687           ret = GST_FLOW_ERROR;
1688           break;
1689         }
1690
1691         GST_DEBUG_OBJECT (common, "ContentEncodingScope: %" G_GUINT64_FORMAT,
1692             num);
1693         enc.scope = num;
1694
1695         break;
1696       }
1697       case GST_MATROSKA_ID_CONTENTENCODINGTYPE:{
1698         guint64 num;
1699
1700         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1701           break;
1702
1703         if (num > 1) {
1704           GST_ERROR_OBJECT (common, "Invalid ContentEncodingType %"
1705               G_GUINT64_FORMAT, num);
1706           ret = GST_FLOW_ERROR;
1707           break;
1708         } else if (num != 0) {
1709           GST_ERROR_OBJECT (common, "Encrypted tracks are not supported yet");
1710           ret = GST_FLOW_ERROR;
1711           break;
1712         }
1713         GST_DEBUG_OBJECT (common, "ContentEncodingType: %" G_GUINT64_FORMAT,
1714             num);
1715         enc.type = num;
1716         break;
1717       }
1718       case GST_MATROSKA_ID_CONTENTCOMPRESSION:{
1719
1720         DEBUG_ELEMENT_START (common, ebml, "ContentCompression");
1721
1722         if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK)
1723           break;
1724
1725         while (ret == GST_FLOW_OK &&
1726             gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1727           if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1728             break;
1729
1730           switch (id) {
1731             case GST_MATROSKA_ID_CONTENTCOMPALGO:{
1732               guint64 num;
1733
1734               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) {
1735                 break;
1736               }
1737               if (num > 3) {
1738                 GST_ERROR_OBJECT (common, "Invalid ContentCompAlgo %"
1739                     G_GUINT64_FORMAT, num);
1740                 ret = GST_FLOW_ERROR;
1741                 break;
1742               }
1743               GST_DEBUG_OBJECT (common, "ContentCompAlgo: %" G_GUINT64_FORMAT,
1744                   num);
1745               enc.comp_algo = num;
1746
1747               break;
1748             }
1749             case GST_MATROSKA_ID_CONTENTCOMPSETTINGS:{
1750               guint8 *data;
1751               guint64 size;
1752
1753               if ((ret =
1754                       gst_ebml_read_binary (ebml, &id, &data,
1755                           &size)) != GST_FLOW_OK) {
1756                 break;
1757               }
1758               enc.comp_settings = data;
1759               enc.comp_settings_length = size;
1760               GST_DEBUG_OBJECT (common,
1761                   "ContentCompSettings of size %" G_GUINT64_FORMAT, size);
1762               break;
1763             }
1764             default:
1765               GST_WARNING_OBJECT (common,
1766                   "Unknown ContentCompression subelement 0x%x - ignoring", id);
1767               ret = gst_ebml_read_skip (ebml);
1768               break;
1769           }
1770         }
1771         DEBUG_ELEMENT_STOP (common, ebml, "ContentCompression", ret);
1772         break;
1773       }
1774
1775       case GST_MATROSKA_ID_CONTENTENCRYPTION:
1776         GST_ERROR_OBJECT (common, "Encrypted tracks not yet supported");
1777         gst_ebml_read_skip (ebml);
1778         ret = GST_FLOW_ERROR;
1779         break;
1780       default:
1781         GST_WARNING_OBJECT (common,
1782             "Unknown ContentEncoding subelement 0x%x - ignoring", id);
1783         ret = gst_ebml_read_skip (ebml);
1784         break;
1785     }
1786   }
1787
1788   DEBUG_ELEMENT_STOP (common, ebml, "ContentEncoding", ret);
1789   if (ret != GST_FLOW_OK && ret != GST_FLOW_UNEXPECTED)
1790     return ret;
1791
1792   /* TODO: Check if the combination of values is valid */
1793
1794   g_array_append_val (context->encodings, enc);
1795
1796   return ret;
1797 }
1798
1799 GstFlowReturn
1800 gst_matroska_read_common_read_track_encodings (GstMatroskaReadCommon * common,
1801     GstEbmlRead * ebml, GstMatroskaTrackContext * context)
1802 {
1803   GstFlowReturn ret;
1804   guint32 id;
1805
1806   DEBUG_ELEMENT_START (common, ebml, "ContentEncodings");
1807
1808   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
1809     DEBUG_ELEMENT_STOP (common, ebml, "ContentEncodings", ret);
1810     return ret;
1811   }
1812
1813   context->encodings =
1814       g_array_sized_new (FALSE, FALSE, sizeof (GstMatroskaTrackEncoding), 1);
1815
1816   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1817     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1818       break;
1819
1820     switch (id) {
1821       case GST_MATROSKA_ID_CONTENTENCODING:
1822         ret = gst_matroska_read_common_read_track_encoding (common, ebml,
1823             context);
1824         break;
1825       default:
1826         GST_WARNING_OBJECT (common,
1827             "Unknown ContentEncodings subelement 0x%x - ignoring", id);
1828         ret = gst_ebml_read_skip (ebml);
1829         break;
1830     }
1831   }
1832
1833   DEBUG_ELEMENT_STOP (common, ebml, "ContentEncodings", ret);
1834   if (ret != GST_FLOW_OK && ret != GST_FLOW_UNEXPECTED)
1835     return ret;
1836
1837   /* Sort encodings according to their order */
1838   g_array_sort (context->encodings,
1839       (GCompareFunc) gst_matroska_read_common_encoding_cmp);
1840
1841   return gst_matroska_decode_content_encodings (context->encodings);
1842 }
1843
1844 /* call with object lock held */
1845 void
1846 gst_matroska_read_common_reset_streams (GstMatroskaReadCommon * common,
1847     GstClockTime time, gboolean full)
1848 {
1849   gint i;
1850
1851   GST_DEBUG_OBJECT (common, "resetting stream state");
1852
1853   g_assert (common->src->len == common->num_streams);
1854   for (i = 0; i < common->src->len; i++) {
1855     GstMatroskaTrackContext *context = g_ptr_array_index (common->src, i);
1856     context->pos = time;
1857     context->set_discont = TRUE;
1858     context->eos = FALSE;
1859     context->from_time = GST_CLOCK_TIME_NONE;
1860     if (full)
1861       context->last_flow = GST_FLOW_OK;
1862     if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO) {
1863       GstMatroskaTrackVideoContext *videocontext =
1864           (GstMatroskaTrackVideoContext *) context;
1865       /* demux object lock held by caller */
1866       videocontext->earliest_time = GST_CLOCK_TIME_NONE;
1867     }
1868   }
1869 }
1870
1871 gboolean
1872 gst_matroska_read_common_tracknumber_unique (GstMatroskaReadCommon * common,
1873     guint64 num)
1874 {
1875   gint i;
1876
1877   g_assert (common->src->len == common->num_streams);
1878   for (i = 0; i < common->src->len; i++) {
1879     GstMatroskaTrackContext *context = g_ptr_array_index (common->src, i);
1880
1881     if (context->num == num)
1882       return FALSE;
1883   }
1884
1885   return TRUE;
1886 }