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 "lzo.h"
40
41 #include "ebml-read.h"
42 #include "matroska-read-common.h"
43
44 GST_DEBUG_CATEGORY_STATIC (matroskareadcommon_debug);
45 #define GST_CAT_DEFAULT matroskareadcommon_debug
46
47 #define DEBUG_ELEMENT_START(common, ebml, element) \
48     GST_DEBUG_OBJECT (common, "Parsing " element " element at offset %" \
49         G_GUINT64_FORMAT, gst_ebml_read_get_pos (ebml))
50
51 #define DEBUG_ELEMENT_STOP(common, ebml, element, ret) \
52     GST_DEBUG_OBJECT (common, "Parsing " element " element " \
53         " finished with '%s'", gst_flow_get_name (ret))
54
55 static gboolean
56 gst_matroska_decompress_data (GstMatroskaTrackEncoding * enc,
57     guint8 ** data_out, guint * size_out,
58     GstMatroskaTrackCompressionAlgorithm algo)
59 {
60   guint8 *new_data = NULL;
61   guint new_size = 0;
62   guint8 *data = *data_out;
63   guint size = *size_out;
64   gboolean ret = TRUE;
65
66   if (algo == GST_MATROSKA_TRACK_COMPRESSION_ALGORITHM_ZLIB) {
67 #ifdef HAVE_ZLIB
68     /* zlib encoded data */
69     z_stream zstream;
70     guint orig_size;
71     int result;
72
73     orig_size = size;
74     zstream.zalloc = (alloc_func) 0;
75     zstream.zfree = (free_func) 0;
76     zstream.opaque = (voidpf) 0;
77     if (inflateInit (&zstream) != Z_OK) {
78       GST_WARNING ("zlib initialization failed.");
79       ret = FALSE;
80       goto out;
81     }
82     zstream.next_in = (Bytef *) data;
83     zstream.avail_in = orig_size;
84     new_size = orig_size;
85     new_data = g_malloc (new_size);
86     zstream.avail_out = new_size;
87     zstream.next_out = (Bytef *) new_data;
88
89     do {
90       result = inflate (&zstream, Z_NO_FLUSH);
91       if (result != Z_OK && result != Z_STREAM_END) {
92         GST_WARNING ("zlib decompression failed.");
93         g_free (new_data);
94         inflateEnd (&zstream);
95         break;
96       }
97       new_size += 4000;
98       new_data = g_realloc (new_data, new_size);
99       zstream.next_out = (Bytef *) (new_data + zstream.total_out);
100       zstream.avail_out += 4000;
101     } while (zstream.avail_in != 0 && result != Z_STREAM_END);
102
103     if (result != Z_STREAM_END) {
104       ret = FALSE;
105       goto out;
106     } else {
107       new_size = zstream.total_out;
108       inflateEnd (&zstream);
109     }
110 #else
111     GST_WARNING ("zlib encoded tracks not supported.");
112     ret = FALSE;
113     goto out;
114 #endif
115   } else if (algo == GST_MATROSKA_TRACK_COMPRESSION_ALGORITHM_BZLIB) {
116 #ifdef HAVE_BZ2
117     /* bzip2 encoded data */
118     bz_stream bzstream;
119     guint orig_size;
120     int result;
121
122     bzstream.bzalloc = NULL;
123     bzstream.bzfree = NULL;
124     bzstream.opaque = NULL;
125     orig_size = size;
126
127     if (BZ2_bzDecompressInit (&bzstream, 0, 0) != BZ_OK) {
128       GST_WARNING ("bzip2 initialization failed.");
129       ret = FALSE;
130       goto out;
131     }
132
133     bzstream.next_in = (char *) data;
134     bzstream.avail_in = orig_size;
135     new_size = orig_size;
136     new_data = g_malloc (new_size);
137     bzstream.avail_out = new_size;
138     bzstream.next_out = (char *) new_data;
139
140     do {
141       result = BZ2_bzDecompress (&bzstream);
142       if (result != BZ_OK && result != BZ_STREAM_END) {
143         GST_WARNING ("bzip2 decompression failed.");
144         g_free (new_data);
145         BZ2_bzDecompressEnd (&bzstream);
146         break;
147       }
148       new_size += 4000;
149       new_data = g_realloc (new_data, new_size);
150       bzstream.next_out = (char *) (new_data + bzstream.total_out_lo32);
151       bzstream.avail_out += 4000;
152     } while (bzstream.avail_in != 0 && result != BZ_STREAM_END);
153
154     if (result != BZ_STREAM_END) {
155       ret = FALSE;
156       goto out;
157     } else {
158       new_size = bzstream.total_out_lo32;
159       BZ2_bzDecompressEnd (&bzstream);
160     }
161 #else
162     GST_WARNING ("bzip2 encoded tracks not supported.");
163     ret = FALSE;
164     goto out;
165 #endif
166   } else if (algo == GST_MATROSKA_TRACK_COMPRESSION_ALGORITHM_LZO1X) {
167     /* lzo encoded data */
168     int result;
169     int orig_size, out_size;
170
171     orig_size = size;
172     out_size = size;
173     new_size = size;
174     new_data = g_malloc (new_size);
175
176     do {
177       orig_size = size;
178       out_size = new_size;
179
180       result = lzo1x_decode (new_data, &out_size, data, &orig_size);
181
182       if (orig_size > 0) {
183         new_size += 4000;
184         new_data = g_realloc (new_data, new_size);
185       }
186     } while (orig_size > 0 && result == LZO_OUTPUT_FULL);
187
188     new_size -= out_size;
189
190     if (result != LZO_OUTPUT_FULL) {
191       GST_WARNING ("lzo decompression failed");
192       g_free (new_data);
193
194       ret = FALSE;
195       goto out;
196     }
197
198   } else if (algo == GST_MATROSKA_TRACK_COMPRESSION_ALGORITHM_HEADERSTRIP) {
199     /* header stripped encoded data */
200     if (enc->comp_settings_length > 0) {
201       new_data = g_malloc (size + enc->comp_settings_length);
202       new_size = size + enc->comp_settings_length;
203
204       memcpy (new_data, enc->comp_settings, enc->comp_settings_length);
205       memcpy (new_data + enc->comp_settings_length, data, size);
206     }
207   } else {
208     GST_ERROR ("invalid compression algorithm %d", algo);
209     ret = FALSE;
210   }
211
212 out:
213
214   if (!ret) {
215     *data_out = NULL;
216     *size_out = 0;
217   } else {
218     *data_out = new_data;
219     *size_out = new_size;
220   }
221
222   return ret;
223 }
224
225 GstFlowReturn
226 gst_matroska_decode_content_encodings (GArray * encodings)
227 {
228   gint i;
229
230   if (encodings == NULL)
231     return GST_FLOW_OK;
232
233   for (i = 0; i < encodings->len; i++) {
234     GstMatroskaTrackEncoding *enc =
235         &g_array_index (encodings, GstMatroskaTrackEncoding, i);
236     guint8 *data = NULL;
237     guint size;
238
239     if ((enc->scope & GST_MATROSKA_TRACK_ENCODING_SCOPE_NEXT_CONTENT_ENCODING)
240         == 0)
241       continue;
242
243     /* Encryption not supported yet */
244     if (enc->type != 0)
245       return GST_FLOW_ERROR;
246
247     if (i + 1 >= encodings->len)
248       return GST_FLOW_ERROR;
249
250     if (enc->comp_settings_length == 0)
251       continue;
252
253     data = enc->comp_settings;
254     size = enc->comp_settings_length;
255
256     if (!gst_matroska_decompress_data (enc, &data, &size, enc->comp_algo))
257       return GST_FLOW_ERROR;
258
259     g_free (enc->comp_settings);
260
261     enc->comp_settings = data;
262     enc->comp_settings_length = size;
263   }
264
265   return GST_FLOW_OK;
266 }
267
268 gboolean
269 gst_matroska_decode_data (GArray * encodings, guint8 ** data_out,
270     guint * size_out, GstMatroskaTrackEncodingScope scope, gboolean free)
271 {
272   guint8 *data;
273   guint size;
274   gboolean ret = TRUE;
275   gint i;
276
277   g_return_val_if_fail (encodings != NULL, FALSE);
278   g_return_val_if_fail (data_out != NULL && *data_out != NULL, FALSE);
279   g_return_val_if_fail (size_out != NULL, FALSE);
280
281   data = *data_out;
282   size = *size_out;
283
284   for (i = 0; i < encodings->len; i++) {
285     GstMatroskaTrackEncoding *enc =
286         &g_array_index (encodings, GstMatroskaTrackEncoding, i);
287     guint8 *new_data = NULL;
288     guint new_size = 0;
289
290     if ((enc->scope & scope) == 0)
291       continue;
292
293     /* Encryption not supported yet */
294     if (enc->type != 0) {
295       ret = FALSE;
296       break;
297     }
298
299     new_data = data;
300     new_size = size;
301
302     ret =
303         gst_matroska_decompress_data (enc, &new_data, &new_size,
304         enc->comp_algo);
305
306     if (!ret)
307       break;
308
309     if ((data == *data_out && free) || (data != *data_out))
310       g_free (data);
311
312     data = new_data;
313     size = new_size;
314   }
315
316   if (!ret) {
317     if ((data == *data_out && free) || (data != *data_out))
318       g_free (data);
319
320     *data_out = NULL;
321     *size_out = 0;
322   } else {
323     *data_out = data;
324     *size_out = size;
325   }
326
327   return ret;
328 }
329
330 static gint
331 gst_matroska_index_compare (GstMatroskaIndex * i1, GstMatroskaIndex * i2)
332 {
333   if (i1->time < i2->time)
334     return -1;
335   else if (i1->time > i2->time)
336     return 1;
337   else if (i1->block < i2->block)
338     return -1;
339   else if (i1->block > i2->block)
340     return 1;
341   else
342     return 0;
343 }
344
345 gint
346 gst_matroska_index_seek_find (GstMatroskaIndex * i1, GstClockTime * time,
347     gpointer user_data)
348 {
349   if (i1->time < *time)
350     return -1;
351   else if (i1->time > *time)
352     return 1;
353   else
354     return 0;
355 }
356
357 GstMatroskaIndex *
358 gst_matroska_read_common_do_index_seek (GstMatroskaReadCommon * common,
359     GstMatroskaTrackContext * track, gint64 seek_pos, GArray ** _index,
360     gint * _entry_index)
361 {
362   GstMatroskaIndex *entry = NULL;
363   GArray *index;
364
365   if (!common->index || !common->index->len)
366     return NULL;
367
368   /* find entry just before or at the requested position */
369   if (track && track->index_table)
370     index = track->index_table;
371   else
372     index = common->index;
373
374   entry =
375       gst_util_array_binary_search (index->data, index->len,
376       sizeof (GstMatroskaIndex),
377       (GCompareDataFunc) gst_matroska_index_seek_find, GST_SEARCH_MODE_BEFORE,
378       &seek_pos, NULL);
379
380   if (entry == NULL)
381     entry = &g_array_index (index, GstMatroskaIndex, 0);
382
383   if (_index)
384     *_index = index;
385   if (_entry_index)
386     *_entry_index = entry - (GstMatroskaIndex *) index->data;
387
388   return entry;
389 }
390
391 static gint
392 gst_matroska_read_common_encoding_cmp (GstMatroskaTrackEncoding * a,
393     GstMatroskaTrackEncoding * b)
394 {
395   if (b->order > a->order)
396     return 1;
397   else if (b->order < a->order)
398     return -1;
399   else
400     return 0;
401 }
402
403 static gboolean
404 gst_matroska_read_common_encoding_order_unique (GArray * encodings, guint64
405     order)
406 {
407   gint i;
408
409   if (encodings == NULL || encodings->len == 0)
410     return TRUE;
411
412   for (i = 0; i < encodings->len; i++)
413     if (g_array_index (encodings, GstMatroskaTrackEncoding, i).order == order)
414       return FALSE;
415
416   return TRUE;
417 }
418
419 /* takes ownership of taglist */
420 void
421 gst_matroska_read_common_found_global_tag (GstMatroskaReadCommon * common,
422     GstElement * el, GstTagList * taglist)
423 {
424   if (common->global_tags) {
425     /* nothing sent yet, add to cache */
426     gst_tag_list_insert (common->global_tags, taglist, GST_TAG_MERGE_APPEND);
427     gst_tag_list_free (taglist);
428   } else {
429     /* hm, already sent, no need to cache and wait anymore */
430     GST_DEBUG_OBJECT (common, "Sending late global tags %" GST_PTR_FORMAT,
431         taglist);
432     gst_element_found_tags (el, taglist);
433   }
434 }
435
436 gint64
437 gst_matroska_read_common_get_length (GstMatroskaReadCommon * common)
438 {
439   GstFormat fmt = GST_FORMAT_BYTES;
440   gint64 end = -1;
441
442   if (!gst_pad_query_peer_duration (common->sinkpad, &fmt, &end) ||
443       fmt != GST_FORMAT_BYTES || end < 0)
444     GST_DEBUG_OBJECT (common, "no upstream length");
445
446   return end;
447 }
448
449 /* determine track to seek in */
450 GstMatroskaTrackContext *
451 gst_matroska_read_common_get_seek_track (GstMatroskaReadCommon * common,
452     GstMatroskaTrackContext * track)
453 {
454   gint i;
455
456   if (track && track->type == GST_MATROSKA_TRACK_TYPE_VIDEO)
457     return track;
458
459   for (i = 0; i < common->src->len; i++) {
460     GstMatroskaTrackContext *stream;
461
462     stream = g_ptr_array_index (common->src, i);
463     if (stream->type == GST_MATROSKA_TRACK_TYPE_VIDEO && stream->index_table)
464       track = stream;
465   }
466
467   return track;
468 }
469
470 /* skip unknown or alike element */
471 GstFlowReturn
472 gst_matroska_read_common_parse_skip (GstMatroskaReadCommon * common,
473     GstEbmlRead * ebml, const gchar * parent_name, guint id)
474 {
475   if (id == GST_EBML_ID_VOID) {
476     GST_DEBUG_OBJECT (common, "Skipping EBML Void element");
477   } else if (id == GST_EBML_ID_CRC32) {
478     GST_DEBUG_OBJECT (common, "Skipping EBML CRC32 element");
479   } else {
480     GST_WARNING_OBJECT (common,
481         "Unknown %s subelement 0x%x - ignoring", parent_name, id);
482   }
483
484   return gst_ebml_read_skip (ebml);
485 }
486
487 GstFlowReturn
488 gst_matroska_read_common_parse_header (GstMatroskaReadCommon * common,
489     GstEbmlRead * ebml)
490 {
491   GstFlowReturn ret;
492   gchar *doctype;
493   guint version;
494   guint32 id;
495
496   /* this function is the first to be called */
497
498   /* default init */
499   doctype = NULL;
500   version = 1;
501
502   ret = gst_ebml_peek_id (ebml, &id);
503   if (ret != GST_FLOW_OK)
504     return ret;
505
506   GST_DEBUG_OBJECT (common, "id: %08x", id);
507
508   if (id != GST_EBML_ID_HEADER) {
509     GST_ERROR_OBJECT (common, "Failed to read header");
510     goto exit;
511   }
512
513   ret = gst_ebml_read_master (ebml, &id);
514   if (ret != GST_FLOW_OK)
515     return ret;
516
517   while (gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
518     ret = gst_ebml_peek_id (ebml, &id);
519     if (ret != GST_FLOW_OK)
520       return ret;
521
522     switch (id) {
523         /* is our read version uptodate? */
524       case GST_EBML_ID_EBMLREADVERSION:{
525         guint64 num;
526
527         ret = gst_ebml_read_uint (ebml, &id, &num);
528         if (ret != GST_FLOW_OK)
529           return ret;
530         if (num != GST_EBML_VERSION) {
531           GST_ERROR_OBJECT (ebml, "Unsupported EBML version %" G_GUINT64_FORMAT,
532               num);
533           return GST_FLOW_ERROR;
534         }
535
536         GST_DEBUG_OBJECT (ebml, "EbmlReadVersion: %" G_GUINT64_FORMAT, num);
537         break;
538       }
539
540         /* we only handle 8 byte lengths at max */
541       case GST_EBML_ID_EBMLMAXSIZELENGTH:{
542         guint64 num;
543
544         ret = gst_ebml_read_uint (ebml, &id, &num);
545         if (ret != GST_FLOW_OK)
546           return ret;
547         if (num > sizeof (guint64)) {
548           GST_ERROR_OBJECT (ebml,
549               "Unsupported EBML maximum size %" G_GUINT64_FORMAT, num);
550           return GST_FLOW_ERROR;
551         }
552         GST_DEBUG_OBJECT (ebml, "EbmlMaxSizeLength: %" G_GUINT64_FORMAT, num);
553         break;
554       }
555
556         /* we handle 4 byte IDs at max */
557       case GST_EBML_ID_EBMLMAXIDLENGTH:{
558         guint64 num;
559
560         ret = gst_ebml_read_uint (ebml, &id, &num);
561         if (ret != GST_FLOW_OK)
562           return ret;
563         if (num > sizeof (guint32)) {
564           GST_ERROR_OBJECT (ebml,
565               "Unsupported EBML maximum ID %" G_GUINT64_FORMAT, num);
566           return GST_FLOW_ERROR;
567         }
568         GST_DEBUG_OBJECT (ebml, "EbmlMaxIdLength: %" G_GUINT64_FORMAT, num);
569         break;
570       }
571
572       case GST_EBML_ID_DOCTYPE:{
573         gchar *text;
574
575         ret = gst_ebml_read_ascii (ebml, &id, &text);
576         if (ret != GST_FLOW_OK)
577           return ret;
578
579         GST_DEBUG_OBJECT (ebml, "EbmlDocType: %s", GST_STR_NULL (text));
580
581         if (doctype)
582           g_free (doctype);
583         doctype = text;
584         break;
585       }
586
587       case GST_EBML_ID_DOCTYPEREADVERSION:{
588         guint64 num;
589
590         ret = gst_ebml_read_uint (ebml, &id, &num);
591         if (ret != GST_FLOW_OK)
592           return ret;
593         version = num;
594         GST_DEBUG_OBJECT (ebml, "EbmlReadVersion: %" G_GUINT64_FORMAT, num);
595         break;
596       }
597
598       default:
599         ret = gst_matroska_read_common_parse_skip (common, ebml,
600             "EBML header", id);
601         if (ret != GST_FLOW_OK)
602           return ret;
603         break;
604
605         /* we ignore these two, as they don't tell us anything we care about */
606       case GST_EBML_ID_EBMLVERSION:
607       case GST_EBML_ID_DOCTYPEVERSION:
608         ret = gst_ebml_read_skip (ebml);
609         if (ret != GST_FLOW_OK)
610           return ret;
611         break;
612     }
613   }
614
615 exit:
616
617   if ((doctype != NULL && !strcmp (doctype, GST_MATROSKA_DOCTYPE_MATROSKA)) ||
618       (doctype != NULL && !strcmp (doctype, GST_MATROSKA_DOCTYPE_WEBM)) ||
619       (doctype == NULL)) {
620     if (version <= 2) {
621       if (doctype) {
622         GST_INFO_OBJECT (common, "Input is %s version %d", doctype, version);
623       } else {
624         GST_WARNING_OBJECT (common, "Input is EBML without doctype, assuming "
625             "matroska (version %d)", version);
626       }
627       ret = GST_FLOW_OK;
628     } else {
629       GST_ELEMENT_ERROR (common, STREAM, DEMUX, (NULL),
630           ("Demuxer version (2) is too old to read %s version %d",
631               GST_STR_NULL (doctype), version));
632       ret = GST_FLOW_ERROR;
633     }
634     g_free (doctype);
635   } else {
636     GST_ELEMENT_ERROR (common, STREAM, WRONG_TYPE, (NULL),
637         ("Input is not a matroska stream (doctype=%s)", doctype));
638     ret = GST_FLOW_ERROR;
639     g_free (doctype);
640   }
641
642   return ret;
643 }
644
645 static GstFlowReturn
646 gst_matroska_read_common_parse_index_cuetrack (GstMatroskaReadCommon * common,
647     GstEbmlRead * ebml, guint * nentries)
648 {
649   guint32 id;
650   GstFlowReturn ret;
651   GstMatroskaIndex idx;
652
653   idx.pos = (guint64) - 1;
654   idx.track = 0;
655   idx.time = GST_CLOCK_TIME_NONE;
656   idx.block = 1;
657
658   DEBUG_ELEMENT_START (common, ebml, "CueTrackPositions");
659
660   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
661     DEBUG_ELEMENT_STOP (common, ebml, "CueTrackPositions", ret);
662     return ret;
663   }
664
665   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
666     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
667       break;
668
669     switch (id) {
670         /* track number */
671       case GST_MATROSKA_ID_CUETRACK:
672       {
673         guint64 num;
674
675         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
676           break;
677
678         if (num == 0) {
679           idx.track = 0;
680           GST_WARNING_OBJECT (common, "Invalid CueTrack 0");
681           break;
682         }
683
684         GST_DEBUG_OBJECT (common, "CueTrack: %" G_GUINT64_FORMAT, num);
685         idx.track = num;
686         break;
687       }
688
689         /* position in file */
690       case GST_MATROSKA_ID_CUECLUSTERPOSITION:
691       {
692         guint64 num;
693
694         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
695           break;
696
697         if (num > G_MAXINT64) {
698           GST_WARNING_OBJECT (common, "CueClusterPosition %" G_GUINT64_FORMAT
699               " too large", num);
700           break;
701         }
702
703         idx.pos = num;
704         break;
705       }
706
707         /* number of block in the cluster */
708       case GST_MATROSKA_ID_CUEBLOCKNUMBER:
709       {
710         guint64 num;
711
712         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
713           break;
714
715         if (num == 0) {
716           GST_WARNING_OBJECT (common, "Invalid CueBlockNumber 0");
717           break;
718         }
719
720         GST_DEBUG_OBJECT (common, "CueBlockNumber: %" G_GUINT64_FORMAT, num);
721         idx.block = num;
722
723         /* mild sanity check, disregard strange cases ... */
724         if (idx.block > G_MAXUINT16) {
725           GST_DEBUG_OBJECT (common, "... looks suspicious, ignoring");
726           idx.block = 1;
727         }
728         break;
729       }
730
731       default:
732         ret = gst_matroska_read_common_parse_skip (common, ebml,
733             "CueTrackPositions", id);
734         break;
735
736       case GST_MATROSKA_ID_CUECODECSTATE:
737       case GST_MATROSKA_ID_CUEREFERENCE:
738         ret = gst_ebml_read_skip (ebml);
739         break;
740     }
741   }
742
743   DEBUG_ELEMENT_STOP (common, ebml, "CueTrackPositions", ret);
744
745   if ((ret == GST_FLOW_OK || ret == GST_FLOW_UNEXPECTED)
746       && idx.pos != (guint64) - 1 && idx.track > 0) {
747     g_array_append_val (common->index, idx);
748     (*nentries)++;
749   } else if (ret == GST_FLOW_OK || ret == GST_FLOW_UNEXPECTED) {
750     GST_DEBUG_OBJECT (common, "CueTrackPositions without valid content");
751   }
752
753   return ret;
754 }
755
756 static GstFlowReturn
757 gst_matroska_read_common_parse_index_pointentry (GstMatroskaReadCommon *
758     common, GstEbmlRead * ebml)
759 {
760   guint32 id;
761   GstFlowReturn ret;
762   GstClockTime time = GST_CLOCK_TIME_NONE;
763   guint nentries = 0;
764
765   DEBUG_ELEMENT_START (common, ebml, "CuePoint");
766
767   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
768     DEBUG_ELEMENT_STOP (common, ebml, "CuePoint", ret);
769     return ret;
770   }
771
772   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
773     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
774       break;
775
776     switch (id) {
777         /* one single index entry ('point') */
778       case GST_MATROSKA_ID_CUETIME:
779       {
780         if ((ret = gst_ebml_read_uint (ebml, &id, &time)) != GST_FLOW_OK)
781           break;
782
783         GST_DEBUG_OBJECT (common, "CueTime: %" G_GUINT64_FORMAT, time);
784         time = time * common->time_scale;
785         break;
786       }
787
788         /* position in the file + track to which it belongs */
789       case GST_MATROSKA_ID_CUETRACKPOSITIONS:
790       {
791         if ((ret =
792                 gst_matroska_read_common_parse_index_cuetrack (common, ebml,
793                     &nentries)) != GST_FLOW_OK)
794           break;
795         break;
796       }
797
798       default:
799         ret = gst_matroska_read_common_parse_skip (common, ebml, "CuePoint",
800             id);
801         break;
802     }
803   }
804
805   DEBUG_ELEMENT_STOP (common, ebml, "CuePoint", ret);
806
807   if (nentries > 0) {
808     if (time == GST_CLOCK_TIME_NONE) {
809       GST_WARNING_OBJECT (common, "CuePoint without valid time");
810       g_array_remove_range (common->index, common->index->len - nentries,
811           nentries);
812     } else {
813       gint i;
814
815       for (i = common->index->len - nentries; i < common->index->len; i++) {
816         GstMatroskaIndex *idx =
817             &g_array_index (common->index, GstMatroskaIndex, i);
818
819         idx->time = time;
820         GST_DEBUG_OBJECT (common, "Index entry: pos=%" G_GUINT64_FORMAT
821             ", time=%" GST_TIME_FORMAT ", track=%u, block=%u", idx->pos,
822             GST_TIME_ARGS (idx->time), (guint) idx->track, (guint) idx->block);
823       }
824     }
825   } else {
826     GST_DEBUG_OBJECT (common, "Empty CuePoint");
827   }
828
829   return ret;
830 }
831
832 gint
833 gst_matroska_read_common_stream_from_num (GstMatroskaReadCommon * common,
834     guint track_num)
835 {
836   guint n;
837
838   g_assert (common->src->len == common->num_streams);
839   for (n = 0; n < common->src->len; n++) {
840     GstMatroskaTrackContext *context = g_ptr_array_index (common->src, n);
841
842     if (context->num == track_num) {
843       return n;
844     }
845   }
846
847   if (n == common->num_streams)
848     GST_WARNING_OBJECT (common,
849         "Failed to find corresponding pad for tracknum %d", track_num);
850
851   return -1;
852 }
853
854 GstFlowReturn
855 gst_matroska_read_common_parse_index (GstMatroskaReadCommon * common,
856     GstEbmlRead * ebml)
857 {
858   guint32 id;
859   GstFlowReturn ret = GST_FLOW_OK;
860   guint i;
861
862   if (common->index)
863     g_array_free (common->index, TRUE);
864   common->index =
865       g_array_sized_new (FALSE, FALSE, sizeof (GstMatroskaIndex), 128);
866
867   DEBUG_ELEMENT_START (common, ebml, "Cues");
868
869   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
870     DEBUG_ELEMENT_STOP (common, ebml, "Cues", ret);
871     return ret;
872   }
873
874   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
875     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
876       break;
877
878     switch (id) {
879         /* one single index entry ('point') */
880       case GST_MATROSKA_ID_POINTENTRY:
881         ret = gst_matroska_read_common_parse_index_pointentry (common, ebml);
882         break;
883
884       default:
885         ret = gst_matroska_read_common_parse_skip (common, ebml, "Cues", id);
886         break;
887     }
888   }
889   DEBUG_ELEMENT_STOP (common, ebml, "Cues", ret);
890
891   /* Sort index by time, smallest time first, for easier searching */
892   g_array_sort (common->index, (GCompareFunc) gst_matroska_index_compare);
893
894   /* Now sort the track specific index entries into their own arrays */
895   for (i = 0; i < common->index->len; i++) {
896     GstMatroskaIndex *idx = &g_array_index (common->index, GstMatroskaIndex,
897         i);
898     gint track_num;
899     GstMatroskaTrackContext *ctx;
900
901     if (common->element_index) {
902       gint writer_id;
903
904       if (idx->track != 0 &&
905           (track_num =
906               gst_matroska_read_common_stream_from_num (common,
907                   idx->track)) != -1) {
908         ctx = g_ptr_array_index (common->src, track_num);
909
910         if (ctx->index_writer_id == -1)
911           gst_index_get_writer_id (common->element_index,
912               GST_OBJECT (ctx->pad), &ctx->index_writer_id);
913         writer_id = ctx->index_writer_id;
914       } else {
915         if (common->element_index_writer_id == -1)
916           gst_index_get_writer_id (common->element_index, GST_OBJECT (common),
917               &common->element_index_writer_id);
918         writer_id = common->element_index_writer_id;
919       }
920
921       GST_LOG_OBJECT (common, "adding association %" GST_TIME_FORMAT "-> %"
922           G_GUINT64_FORMAT " for writer id %d", GST_TIME_ARGS (idx->time),
923           idx->pos, writer_id);
924       gst_index_add_association (common->element_index, writer_id,
925           GST_ASSOCIATION_FLAG_KEY_UNIT, GST_FORMAT_TIME, idx->time,
926           GST_FORMAT_BYTES, idx->pos + common->ebml_segment_start, NULL);
927     }
928
929     if (idx->track == 0)
930       continue;
931
932     track_num = gst_matroska_read_common_stream_from_num (common, idx->track);
933     if (track_num == -1)
934       continue;
935
936     ctx = g_ptr_array_index (common->src, track_num);
937
938     if (ctx->index_table == NULL)
939       ctx->index_table =
940           g_array_sized_new (FALSE, FALSE, sizeof (GstMatroskaIndex), 128);
941
942     g_array_append_vals (ctx->index_table, idx, 1);
943   }
944
945   common->index_parsed = TRUE;
946
947   /* sanity check; empty index normalizes to no index */
948   if (common->index->len == 0) {
949     g_array_free (common->index, TRUE);
950     common->index = NULL;
951   }
952
953   return ret;
954 }
955
956 static const guint8 *
957 gst_matroska_read_common_peek_adapter (GstMatroskaReadCommon * common, guint
958     peek)
959 {
960   return gst_adapter_peek (common->adapter, peek);
961 }
962
963 /*
964  * Calls pull_range for (offset,size) without advancing our offset
965  */
966 GstFlowReturn
967 gst_matroska_read_common_peek_bytes (GstMatroskaReadCommon * common, guint64
968     offset, guint size, GstBuffer ** p_buf, guint8 ** bytes)
969 {
970   GstFlowReturn ret;
971
972   /* Caching here actually makes much less difference than one would expect.
973    * We do it mainly to avoid pulling buffers of 1 byte all the time */
974   if (common->cached_buffer) {
975     guint64 cache_offset = GST_BUFFER_OFFSET (common->cached_buffer);
976     guint cache_size = GST_BUFFER_SIZE (common->cached_buffer);
977
978     if (cache_offset <= common->offset &&
979         (common->offset + size) <= (cache_offset + cache_size)) {
980       if (p_buf)
981         *p_buf = gst_buffer_create_sub (common->cached_buffer,
982             common->offset - cache_offset, size);
983       if (bytes)
984         *bytes = GST_BUFFER_DATA (common->cached_buffer) + common->offset -
985             cache_offset;
986       return GST_FLOW_OK;
987     }
988     /* not enough data in the cache, free cache and get a new one */
989     gst_buffer_unref (common->cached_buffer);
990     common->cached_buffer = NULL;
991   }
992
993   /* refill the cache */
994   ret = gst_pad_pull_range (common->sinkpad, common->offset,
995       MAX (size, 64 * 1024), &common->cached_buffer);
996   if (ret != GST_FLOW_OK) {
997     common->cached_buffer = NULL;
998     return ret;
999   }
1000
1001   if (GST_BUFFER_SIZE (common->cached_buffer) >= size) {
1002     if (p_buf)
1003       *p_buf = gst_buffer_create_sub (common->cached_buffer, 0, size);
1004     if (bytes)
1005       *bytes = GST_BUFFER_DATA (common->cached_buffer);
1006     return GST_FLOW_OK;
1007   }
1008
1009   /* Not possible to get enough data, try a last time with
1010    * requesting exactly the size we need */
1011   gst_buffer_unref (common->cached_buffer);
1012   common->cached_buffer = NULL;
1013
1014   ret =
1015       gst_pad_pull_range (common->sinkpad, common->offset, size,
1016       &common->cached_buffer);
1017   if (ret != GST_FLOW_OK) {
1018     GST_DEBUG_OBJECT (common, "pull_range returned %d", ret);
1019     if (p_buf)
1020       *p_buf = NULL;
1021     if (bytes)
1022       *bytes = NULL;
1023     return ret;
1024   }
1025
1026   if (GST_BUFFER_SIZE (common->cached_buffer) < size) {
1027     GST_WARNING_OBJECT (common, "Dropping short buffer at offset %"
1028         G_GUINT64_FORMAT ": wanted %u bytes, got %u bytes", common->offset,
1029         size, GST_BUFFER_SIZE (common->cached_buffer));
1030
1031     gst_buffer_unref (common->cached_buffer);
1032     common->cached_buffer = NULL;
1033     if (p_buf)
1034       *p_buf = NULL;
1035     if (bytes)
1036       *bytes = NULL;
1037     return GST_FLOW_UNEXPECTED;
1038   }
1039
1040   if (p_buf)
1041     *p_buf = gst_buffer_create_sub (common->cached_buffer, 0, size);
1042   if (bytes)
1043     *bytes = GST_BUFFER_DATA (common->cached_buffer);
1044
1045   return GST_FLOW_OK;
1046 }
1047
1048 static const guint8 *
1049 gst_matroska_read_common_peek_pull (GstMatroskaReadCommon * common, guint peek)
1050 {
1051   guint8 *data = NULL;
1052
1053   gst_matroska_read_common_peek_bytes (common, common->offset, peek, NULL,
1054       &data);
1055   return data;
1056 }
1057
1058 GstFlowReturn
1059 gst_matroska_read_common_peek_id_length_pull (GstMatroskaReadCommon * common,
1060     GstElement * el, guint32 * _id, guint64 * _length, guint * _needed)
1061 {
1062   return gst_ebml_peek_id_length (_id, _length, _needed,
1063       (GstPeekData) gst_matroska_read_common_peek_pull, (gpointer) common, el,
1064       common->offset);
1065 }
1066
1067 GstFlowReturn
1068 gst_matroska_read_common_peek_id_length_push (GstMatroskaReadCommon * common,
1069     GstElement * el, guint32 * _id, guint64 * _length, guint * _needed)
1070 {
1071   return gst_ebml_peek_id_length (_id, _length, _needed,
1072       (GstPeekData) gst_matroska_read_common_peek_adapter, (gpointer) common,
1073       el, common->offset);
1074 }
1075
1076 static GstFlowReturn
1077 gst_matroska_read_common_read_track_encoding (GstMatroskaReadCommon * common,
1078     GstEbmlRead * ebml, GstMatroskaTrackContext * context)
1079 {
1080   GstMatroskaTrackEncoding enc = { 0, };
1081   GstFlowReturn ret;
1082   guint32 id;
1083
1084   DEBUG_ELEMENT_START (common, ebml, "ContentEncoding");
1085   /* Set default values */
1086   enc.scope = 1;
1087   /* All other default values are 0 */
1088
1089   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
1090     DEBUG_ELEMENT_STOP (common, ebml, "ContentEncoding", ret);
1091     return ret;
1092   }
1093
1094   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1095     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1096       break;
1097
1098     switch (id) {
1099       case GST_MATROSKA_ID_CONTENTENCODINGORDER:{
1100         guint64 num;
1101
1102         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1103           break;
1104
1105         if (!gst_matroska_read_common_encoding_order_unique (context->encodings,
1106                 num)) {
1107           GST_ERROR_OBJECT (common, "ContentEncodingOrder %" G_GUINT64_FORMAT
1108               "is not unique for track %d", num, context->num);
1109           ret = GST_FLOW_ERROR;
1110           break;
1111         }
1112
1113         GST_DEBUG_OBJECT (common, "ContentEncodingOrder: %" G_GUINT64_FORMAT,
1114             num);
1115         enc.order = num;
1116         break;
1117       }
1118       case GST_MATROSKA_ID_CONTENTENCODINGSCOPE:{
1119         guint64 num;
1120
1121         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1122           break;
1123
1124         if (num > 7 && num == 0) {
1125           GST_ERROR_OBJECT (common, "Invalid ContentEncodingScope %"
1126               G_GUINT64_FORMAT, num);
1127           ret = GST_FLOW_ERROR;
1128           break;
1129         }
1130
1131         GST_DEBUG_OBJECT (common, "ContentEncodingScope: %" G_GUINT64_FORMAT,
1132             num);
1133         enc.scope = num;
1134
1135         break;
1136       }
1137       case GST_MATROSKA_ID_CONTENTENCODINGTYPE:{
1138         guint64 num;
1139
1140         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1141           break;
1142
1143         if (num > 1) {
1144           GST_ERROR_OBJECT (common, "Invalid ContentEncodingType %"
1145               G_GUINT64_FORMAT, num);
1146           ret = GST_FLOW_ERROR;
1147           break;
1148         } else if (num != 0) {
1149           GST_ERROR_OBJECT (common, "Encrypted tracks are not supported yet");
1150           ret = GST_FLOW_ERROR;
1151           break;
1152         }
1153         GST_DEBUG_OBJECT (common, "ContentEncodingType: %" G_GUINT64_FORMAT,
1154             num);
1155         enc.type = num;
1156         break;
1157       }
1158       case GST_MATROSKA_ID_CONTENTCOMPRESSION:{
1159
1160         DEBUG_ELEMENT_START (common, ebml, "ContentCompression");
1161
1162         if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK)
1163           break;
1164
1165         while (ret == GST_FLOW_OK &&
1166             gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1167           if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1168             break;
1169
1170           switch (id) {
1171             case GST_MATROSKA_ID_CONTENTCOMPALGO:{
1172               guint64 num;
1173
1174               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK) {
1175                 break;
1176               }
1177               if (num > 3) {
1178                 GST_ERROR_OBJECT (common, "Invalid ContentCompAlgo %"
1179                     G_GUINT64_FORMAT, num);
1180                 ret = GST_FLOW_ERROR;
1181                 break;
1182               }
1183               GST_DEBUG_OBJECT (common, "ContentCompAlgo: %" G_GUINT64_FORMAT,
1184                   num);
1185               enc.comp_algo = num;
1186
1187               break;
1188             }
1189             case GST_MATROSKA_ID_CONTENTCOMPSETTINGS:{
1190               guint8 *data;
1191               guint64 size;
1192
1193               if ((ret =
1194                       gst_ebml_read_binary (ebml, &id, &data,
1195                           &size)) != GST_FLOW_OK) {
1196                 break;
1197               }
1198               enc.comp_settings = data;
1199               enc.comp_settings_length = size;
1200               GST_DEBUG_OBJECT (common,
1201                   "ContentCompSettings of size %" G_GUINT64_FORMAT, size);
1202               break;
1203             }
1204             default:
1205               GST_WARNING_OBJECT (common,
1206                   "Unknown ContentCompression subelement 0x%x - ignoring", id);
1207               ret = gst_ebml_read_skip (ebml);
1208               break;
1209           }
1210         }
1211         DEBUG_ELEMENT_STOP (common, ebml, "ContentCompression", ret);
1212         break;
1213       }
1214
1215       case GST_MATROSKA_ID_CONTENTENCRYPTION:
1216         GST_ERROR_OBJECT (common, "Encrypted tracks not yet supported");
1217         gst_ebml_read_skip (ebml);
1218         ret = GST_FLOW_ERROR;
1219         break;
1220       default:
1221         GST_WARNING_OBJECT (common,
1222             "Unknown ContentEncoding subelement 0x%x - ignoring", id);
1223         ret = gst_ebml_read_skip (ebml);
1224         break;
1225     }
1226   }
1227
1228   DEBUG_ELEMENT_STOP (common, ebml, "ContentEncoding", ret);
1229   if (ret != GST_FLOW_OK && ret != GST_FLOW_UNEXPECTED)
1230     return ret;
1231
1232   /* TODO: Check if the combination of values is valid */
1233
1234   g_array_append_val (context->encodings, enc);
1235
1236   return ret;
1237 }
1238
1239 GstFlowReturn
1240 gst_matroska_read_common_read_track_encodings (GstMatroskaReadCommon * common,
1241     GstEbmlRead * ebml, GstMatroskaTrackContext * context)
1242 {
1243   GstFlowReturn ret;
1244   guint32 id;
1245
1246   DEBUG_ELEMENT_START (common, ebml, "ContentEncodings");
1247
1248   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
1249     DEBUG_ELEMENT_STOP (common, ebml, "ContentEncodings", ret);
1250     return ret;
1251   }
1252
1253   context->encodings =
1254       g_array_sized_new (FALSE, FALSE, sizeof (GstMatroskaTrackEncoding), 1);
1255
1256   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
1257     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
1258       break;
1259
1260     switch (id) {
1261       case GST_MATROSKA_ID_CONTENTENCODING:
1262         ret = gst_matroska_read_common_read_track_encoding (common, ebml,
1263             context);
1264         break;
1265       default:
1266         GST_WARNING_OBJECT (common,
1267             "Unknown ContentEncodings subelement 0x%x - ignoring", id);
1268         ret = gst_ebml_read_skip (ebml);
1269         break;
1270     }
1271   }
1272
1273   DEBUG_ELEMENT_STOP (common, ebml, "ContentEncodings", ret);
1274   if (ret != GST_FLOW_OK && ret != GST_FLOW_UNEXPECTED)
1275     return ret;
1276
1277   /* Sort encodings according to their order */
1278   g_array_sort (context->encodings,
1279       (GCompareFunc) gst_matroska_read_common_encoding_cmp);
1280
1281   return gst_matroska_decode_content_encodings (context->encodings);
1282 }
1283
1284 /* call with object lock held */
1285 void
1286 gst_matroska_read_common_reset_streams (GstMatroskaReadCommon * common,
1287     GstClockTime time, gboolean full)
1288 {
1289   gint i;
1290
1291   GST_DEBUG_OBJECT (common, "resetting stream state");
1292
1293   g_assert (common->src->len == common->num_streams);
1294   for (i = 0; i < common->src->len; i++) {
1295     GstMatroskaTrackContext *context = g_ptr_array_index (common->src, i);
1296     context->pos = time;
1297     context->set_discont = TRUE;
1298     context->eos = FALSE;
1299     context->from_time = GST_CLOCK_TIME_NONE;
1300     if (full)
1301       context->last_flow = GST_FLOW_OK;
1302     if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO) {
1303       GstMatroskaTrackVideoContext *videocontext =
1304           (GstMatroskaTrackVideoContext *) context;
1305       /* demux object lock held by caller */
1306       videocontext->earliest_time = GST_CLOCK_TIME_NONE;
1307     }
1308   }
1309 }
1310
1311 gboolean
1312 gst_matroska_read_common_tracknumber_unique (GstMatroskaReadCommon * common,
1313     guint64 num)
1314 {
1315   gint i;
1316
1317   g_assert (common->src->len == common->num_streams);
1318   for (i = 0; i < common->src->len; i++) {
1319     GstMatroskaTrackContext *context = g_ptr_array_index (common->src, i);
1320
1321     if (context->num == num)
1322       return FALSE;
1323   }
1324
1325   return TRUE;
1326 }