gst/matroska/ebml-read.c: Use GINT64 formatting constants from GLIB.
[platform/upstream/gst-plugins-good.git] / gst / matroska / ebml-read.c
1 /* GStreamer EBML I/O
2  * (c) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
3  *
4  * ebml-read.c: read EBML data from file/stream
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public
17  * License along with this library; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25
26 #include <string.h>
27
28 #include "ebml-read.h"
29 #include "ebml-ids.h"
30
31 GST_DEBUG_CATEGORY_STATIC (ebmlread_debug);
32 #define GST_CAT_DEFAULT ebmlread_debug
33
34 static void gst_ebml_read_class_init (GstEbmlReadClass * klass);
35 static void gst_ebml_read_init (GstEbmlRead * ebml);
36 static GstStateChangeReturn gst_ebml_read_change_state (GstElement * element,
37     GstStateChange transition);
38
39 /* convenience functions */
40 static gboolean gst_ebml_read_peek_bytes (GstEbmlRead * ebml, guint size,
41     GstBuffer ** p_buf, guint8 ** bytes);
42 static gboolean gst_ebml_read_pull_bytes (GstEbmlRead * ebml, guint size,
43     GstBuffer ** p_buf, guint8 ** bytes);
44
45
46 static GstElementClass *parent_class;   /* NULL */
47
48 GType
49 gst_ebml_read_get_type (void)
50 {
51   static GType gst_ebml_read_type;      /* 0 */
52
53   if (!gst_ebml_read_type) {
54     static const GTypeInfo gst_ebml_read_info = {
55       sizeof (GstEbmlReadClass),
56       NULL,
57       NULL,
58       (GClassInitFunc) gst_ebml_read_class_init,
59       NULL,
60       NULL,
61       sizeof (GstEbmlRead),
62       0,
63       (GInstanceInitFunc) gst_ebml_read_init,
64     };
65
66     gst_ebml_read_type =
67         g_type_register_static (GST_TYPE_ELEMENT, "GstEbmlRead",
68         &gst_ebml_read_info, 0);
69   }
70
71   return gst_ebml_read_type;
72 }
73
74 static void
75 gst_ebml_read_class_init (GstEbmlReadClass * klass)
76 {
77   GstElementClass *gstelement_class = (GstElementClass *) klass;
78
79   parent_class = g_type_class_peek_parent (klass);
80
81   GST_DEBUG_CATEGORY_INIT (ebmlread_debug, "ebmlread",
82       0, "EBML stream helper class");
83
84   gstelement_class->change_state =
85       GST_DEBUG_FUNCPTR (gst_ebml_read_change_state);
86 }
87
88 static void
89 gst_ebml_read_init (GstEbmlRead * ebml)
90 {
91   ebml->sinkpad = NULL;
92   ebml->level = NULL;
93 }
94
95 static GstStateChangeReturn
96 gst_ebml_read_change_state (GstElement * element, GstStateChange transition)
97 {
98   GstStateChangeReturn ret;
99   GstEbmlRead *ebml = GST_EBML_READ (element);
100
101   switch (transition) {
102     case GST_STATE_CHANGE_READY_TO_PAUSED:
103       if (!ebml->sinkpad) {
104         g_return_val_if_reached (GST_STATE_CHANGE_FAILURE);
105       }
106       break;
107     default:
108       break;
109   }
110
111   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
112
113   switch (transition) {
114     case GST_STATE_CHANGE_PAUSED_TO_READY:
115     {
116       g_list_foreach (ebml->level, (GFunc) g_free, NULL);
117       g_list_free (ebml->level);
118       ebml->level = NULL;
119       if (ebml->cached_buffer) {
120         gst_buffer_unref (ebml->cached_buffer);
121         ebml->cached_buffer = NULL;
122       }
123       ebml->offset = 0;
124       break;
125     }
126     default:
127       break;
128   }
129
130   return ret;
131 }
132
133 /*
134  * Return: the amount of levels in the hierarchy that the
135  * current element lies higher than the previous one.
136  * The opposite isn't done - that's auto-done using master
137  * element reading.
138  */
139
140 static guint
141 gst_ebml_read_element_level_up (GstEbmlRead * ebml)
142 {
143   guint num = 0;
144   guint64 pos = ebml->offset;
145
146   while (ebml->level != NULL) {
147     GList *last = g_list_last (ebml->level);
148     GstEbmlLevel *level = last->data;
149
150     if (pos >= level->start + level->length) {
151       ebml->level = g_list_remove (ebml->level, level);
152       g_free (level);
153       num++;
154     } else {
155       break;
156     }
157   }
158
159   return num;
160 }
161
162 /*
163  * Calls pull_range for (offset,size) without advancing our offset
164  */
165 static gboolean
166 gst_ebml_read_peek_bytes (GstEbmlRead * ebml, guint size, GstBuffer ** p_buf,
167     guint8 ** bytes)
168 {
169   GstFlowReturn ret;
170
171   /* Caching here actually makes much less difference than one would expect.
172    * We do it mainly to avoid pulling buffers of 1 byte all the time */
173   if (ebml->cached_buffer) {
174     guint64 cache_offset = GST_BUFFER_OFFSET (ebml->cached_buffer);
175     guint cache_size = GST_BUFFER_SIZE (ebml->cached_buffer);
176
177     if (cache_offset <= ebml->offset &&
178         (ebml->offset + size) < (cache_offset + cache_size)) {
179       if (p_buf)
180         *p_buf = gst_buffer_create_sub (ebml->cached_buffer,
181             ebml->offset - cache_offset, size);
182       if (bytes)
183         *bytes =
184             GST_BUFFER_DATA (ebml->cached_buffer) + ebml->offset - cache_offset;
185       return TRUE;
186     }
187     gst_buffer_unref (ebml->cached_buffer);
188     ebml->cached_buffer = NULL;
189   }
190
191   if (gst_pad_pull_range (ebml->sinkpad, ebml->offset, MAX (size, 64 * 1024),
192           &ebml->cached_buffer) == GST_FLOW_OK &&
193       GST_BUFFER_SIZE (ebml->cached_buffer) >= size) {
194     if (p_buf)
195       *p_buf = gst_buffer_create_sub (ebml->cached_buffer, 0, size);
196     if (bytes)
197       *bytes = GST_BUFFER_DATA (ebml->cached_buffer);
198     return TRUE;
199   }
200
201   if (!p_buf)
202     return FALSE;
203
204   ret = gst_pad_pull_range (ebml->sinkpad, ebml->offset, size, p_buf);
205   if (ret != GST_FLOW_OK) {
206     GST_DEBUG ("pull_range returned %d", ret);
207     return FALSE;
208   }
209
210   if (GST_BUFFER_SIZE (*p_buf) < size) {
211     GST_WARNING_OBJECT (ebml, "Dropping short buffer at offset %"
212         G_GUINT64_FORMAT ": wanted %u bytes, got %u bytes", ebml->offset,
213         size, GST_BUFFER_SIZE (*p_buf));
214     gst_buffer_unref (*p_buf);
215     *p_buf = NULL;
216     if (bytes)
217       *bytes = NULL;
218     return FALSE;
219   }
220
221   if (bytes)
222     *bytes = GST_BUFFER_DATA (*p_buf);
223
224   return TRUE;
225 }
226
227 /*
228  * Calls pull_range for (offset,size) and advances our offset by size
229  */
230 static gboolean
231 gst_ebml_read_pull_bytes (GstEbmlRead * ebml, guint size, GstBuffer ** p_buf,
232     guint8 ** bytes)
233 {
234   if (!gst_ebml_read_peek_bytes (ebml, size, p_buf, bytes))
235     return FALSE;
236
237   ebml->offset += size;
238   return TRUE;
239 }
240
241 /*
242  * Read: the element content data ID.
243  * Return: FALSE on error.
244  */
245
246 static gboolean
247 gst_ebml_read_element_id (GstEbmlRead * ebml, guint32 * id, guint * level_up)
248 {
249   guint8 *buf;
250   gint len_mask = 0x80, read = 1, n = 1;
251   guint32 total;
252   guint8 b;
253
254   if (!gst_ebml_read_peek_bytes (ebml, 1, NULL, &buf))
255     return FALSE;
256
257   b = GST_READ_UINT8 (buf);
258
259   total = (guint32) b;
260
261   while (read <= 4 && !(total & len_mask)) {
262     read++;
263     len_mask >>= 1;
264   }
265   if (read > 4) {
266     guint64 pos = ebml->offset;
267
268     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
269         ("Invalid EBML ID size tag (0x%x) at position %" G_GUINT64_FORMAT
270             " (0x%" G_GINT64_MODIFIER "x)", (guint) b, pos, pos));
271     return FALSE;
272   }
273
274   if (!gst_ebml_read_peek_bytes (ebml, read, NULL, &buf))
275     return FALSE;
276
277   while (n < read) {
278     b = GST_READ_UINT8 (buf + n);
279     total = (total << 8) | b;
280     ++n;
281   }
282
283   *id = total;
284
285   /* level */
286   if (level_up)
287     *level_up = gst_ebml_read_element_level_up (ebml);
288
289   ebml->offset += read;
290   return TRUE;
291 }
292
293 /*
294  * Read: element content length.
295  * Return: the number of bytes read or -1 on error.
296  */
297
298 static gint
299 gst_ebml_read_element_length (GstEbmlRead * ebml, guint64 * length)
300 {
301   guint8 *buf;
302   gint len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
303   guint64 total;
304   guint8 b;
305
306   if (!gst_ebml_read_peek_bytes (ebml, 1, NULL, &buf))
307     return -1;
308
309   b = GST_READ_UINT8 (buf);
310
311   total = (guint64) b;
312
313   while (read <= 8 && !(total & len_mask)) {
314     read++;
315     len_mask >>= 1;
316   }
317   if (read > 8) {
318     guint64 pos = ebml->offset;
319
320     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
321         ("Invalid EBML length size tag (0x%x) at position %" G_GUINT64_FORMAT
322             " (0x%" G_GINT64_MODIFIER "x)", (guint) b, pos, pos));
323     return -1;
324   }
325
326   if ((total &= (len_mask - 1)) == len_mask - 1)
327     num_ffs++;
328
329   if (!gst_ebml_read_peek_bytes (ebml, read, NULL, &buf))
330     return -1;
331
332   while (n < read) {
333     guint8 b = GST_READ_UINT8 (buf + n);
334
335     if (b == 0xff)
336       num_ffs++;
337     total = (total << 8) | b;
338     ++n;
339   }
340
341   if (read == num_ffs)
342     *length = G_MAXUINT64;
343   else
344     *length = total;
345
346   ebml->offset += read;
347
348   return read;
349 }
350
351 /*
352  * Return: the ID of the next element.
353  * Level_up contains the amount of levels that this
354  * next element lies higher than the previous one.
355  */
356
357 gboolean
358 gst_ebml_peek_id (GstEbmlRead * ebml, guint * level_up, guint32 * id)
359 {
360   guint64 off;
361
362   g_assert (level_up);
363
364   off = ebml->offset;           /* save offset */
365
366   if (!gst_ebml_read_element_id (ebml, id, level_up))
367     return FALSE;
368
369   ebml->offset = off;           /* restore offset */
370   return TRUE;
371 }
372
373 /*
374  * Return the length of the stream in bytes
375  */
376
377 gint64
378 gst_ebml_read_get_length (GstEbmlRead * ebml)
379 {
380   GstFormat fmt = GST_FORMAT_BYTES;
381   gint64 end;
382
383   if (!gst_pad_query_duration (GST_PAD_PEER (ebml->sinkpad), &fmt, &end))
384     g_return_val_if_reached (0);        ///// FIXME /////////
385
386   if (fmt != GST_FORMAT_BYTES || end < 0)
387     g_return_val_if_reached (0);        ///// FIXME /////////
388
389   return end;
390 }
391
392 /*
393  * Seek to a given offset.
394  */
395
396 gboolean
397 gst_ebml_read_seek (GstEbmlRead * ebml, guint64 offset)
398 {
399   if (offset >= gst_ebml_read_get_length (ebml))
400     return FALSE;
401
402   ebml->offset = offset;
403
404   return TRUE;
405 }
406
407 /*
408  * Skip the next element.
409  */
410
411 gboolean
412 gst_ebml_read_skip (GstEbmlRead * ebml)
413 {
414   guint64 length;
415   guint32 id;
416
417   if (!gst_ebml_read_element_id (ebml, &id, NULL))
418     return FALSE;
419
420   if (gst_ebml_read_element_length (ebml, &length) < 0)
421     return FALSE;
422
423   ebml->offset += length;
424   return TRUE;
425 }
426
427 /*
428  * Read the next element as a GstBuffer (binary).
429  */
430
431 gboolean
432 gst_ebml_read_buffer (GstEbmlRead * ebml, guint32 * id, GstBuffer ** buf)
433 {
434   guint64 length;
435
436   if (!gst_ebml_read_element_id (ebml, id, NULL))
437     return FALSE;
438
439   if (gst_ebml_read_element_length (ebml, &length) < 0)
440     return FALSE;
441
442   if (length == 0) {
443     *buf = gst_buffer_new ();
444     return TRUE;
445   }
446
447   *buf = NULL;
448   if (!gst_ebml_read_pull_bytes (ebml, (guint) length, buf, NULL))
449     return FALSE;
450
451   return TRUE;
452 }
453
454 /*
455  * Read the next element, return a pointer to it and its size.
456  */
457
458 static gboolean
459 gst_ebml_read_bytes (GstEbmlRead * ebml, guint32 * id, guint8 ** data,
460     guint * size)
461 {
462   guint64 length;
463
464   *size = 0;
465
466   if (!gst_ebml_read_element_id (ebml, id, NULL))
467     return FALSE;
468
469   if (gst_ebml_read_element_length (ebml, &length) < 0)
470     return FALSE;
471
472   if (length == 0) {
473     *data = NULL;
474     return TRUE;
475   }
476
477   *data = NULL;
478   if (!gst_ebml_read_pull_bytes (ebml, (guint) length, NULL, data))
479     return FALSE;
480
481   *size = (guint) length;
482
483   return TRUE;
484 }
485
486 /*
487  * Read the next element as an unsigned int.
488  */
489
490 gboolean
491 gst_ebml_read_uint (GstEbmlRead * ebml, guint32 * id, guint64 * num)
492 {
493   guint8 *data;
494   guint size;
495
496   if (!gst_ebml_read_bytes (ebml, id, &data, &size))
497     return FALSE;
498
499   if (size < 1 || size > 8) {
500     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
501         ("Invalid integer element size %d at position %" G_GUINT64_FORMAT
502             " (0x%" G_GINT64_MODIFIER "x)",
503             size, ebml->offset - size, ebml->offset - size));
504     return FALSE;
505   }
506   *num = 0;
507   while (size > 0) {
508     *num = (*num << 8) | *data;
509     size--;
510     data++;
511   }
512
513   return TRUE;
514 }
515
516 /*
517  * Read the next element as a signed int.
518  */
519
520 gboolean
521 gst_ebml_read_sint (GstEbmlRead * ebml, guint32 * id, gint64 * num)
522 {
523   guint8 *data;
524   guint size;
525   gboolean negative = 0;
526
527   if (!gst_ebml_read_bytes (ebml, id, &data, &size))
528     return FALSE;
529
530   if (size < 1 || size > 8) {
531     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
532         ("Invalid integer element size %d at position %" G_GUINT64_FORMAT
533             " (0x%" G_GINT64_MODIFIER "x)", size, ebml->offset - size,
534             ebml->offset - size));
535     return FALSE;
536   }
537
538   *num = 0;
539   if (*data & 0x80) {
540     negative = 1;
541     *num = *data & ~0x80;
542     size--;
543     data++;
544   }
545
546   while (size > 0) {
547     *num = (*num << 8) | *data;
548     size--;
549     data++;
550   }
551
552   /* make signed */
553   if (negative) {
554     *num = 0 - *num;
555   }
556
557   return TRUE;
558 }
559
560 /*
561  * Read the next element as a float.
562  */
563
564 gboolean
565 gst_ebml_read_float (GstEbmlRead * ebml, guint32 * id, gdouble * num)
566 {
567   guint8 *data;
568   guint size;
569
570   if (!gst_ebml_read_bytes (ebml, id, &data, &size))
571     return FALSE;
572
573   if (size != 4 && size != 8 && size != 10) {
574     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
575         ("Invalid float element size %d at position %" G_GUINT64_FORMAT
576             " (0x%" G_GINT64_MODIFIER "x)", size, ebml->offset - size,
577             ebml->offset - size));
578     return FALSE;
579   }
580
581   if (size == 10) {
582     GST_ELEMENT_ERROR (ebml, CORE, NOT_IMPLEMENTED, (NULL),
583         ("FIXME! 10-byte floats unimplemented"));
584     return FALSE;
585   }
586
587   if (size == 4) {
588     gfloat f;
589
590 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
591     f = *(gfloat *) data;
592 #else
593     while (size > 0) {
594       ((guint8 *) & f)[size - 1] = data[4 - size];
595       size--;
596     }
597 #endif
598
599     *num = f;
600   } else {
601     gdouble d;
602
603 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
604     d = *(gdouble *) data;
605 #else
606     while (size > 0) {
607       ((guint8 *) & d)[size - 1] = data[8 - size];
608       size--;
609     }
610 #endif
611
612     *num = d;
613   }
614
615   return TRUE;
616 }
617
618 /*
619  * Read the next element as an ASCII string.
620  */
621
622 gboolean
623 gst_ebml_read_ascii (GstEbmlRead * ebml, guint32 * id, gchar ** str)
624 {
625   guint8 *data;
626   guint size;
627
628   if (!gst_ebml_read_bytes (ebml, id, &data, &size))
629     return FALSE;
630
631   *str = g_malloc (size + 1);
632   memcpy (*str, data, size);
633   (*str)[size] = '\0';
634
635   return TRUE;
636 }
637
638 /*
639  * Read the next element as a UTF-8 string.
640  */
641
642 gboolean
643 gst_ebml_read_utf8 (GstEbmlRead * ebml, guint32 * id, gchar ** str)
644 {
645   gboolean ret;
646
647 #ifndef GST_DISABLE_GST_DEBUG
648   guint64 oldoff = ebml->offset;
649 #endif
650
651   ret = gst_ebml_read_ascii (ebml, id, str);
652
653   if (str != NULL && *str != NULL && **str != '\0' &&
654       !g_utf8_validate (*str, -1, NULL)) {
655     GST_WARNING ("Invalid UTF-8 string at offset %" G_GUINT64_FORMAT, oldoff);
656   }
657
658   return ret;
659 }
660
661 /*
662  * Read the next element as a date.
663  * Returns the seconds since the unix epoch.
664  */
665
666 gboolean
667 gst_ebml_read_date (GstEbmlRead * ebml, guint32 * id, gint64 * date)
668 {
669   gint64 ebml_date;
670   gboolean res = gst_ebml_read_sint (ebml, id, &ebml_date);
671
672   *date = (ebml_date / GST_SECOND) + GST_EBML_DATE_OFFSET;
673   return res;
674 }
675
676 /*
677  * Read the next element, but only the header. The contents
678  * are supposed to be sub-elements which can be read separately.
679  */
680
681 gboolean
682 gst_ebml_read_master (GstEbmlRead * ebml, guint32 * id)
683 {
684   GstEbmlLevel *level;
685   guint64 length;
686
687   if (!gst_ebml_read_element_id (ebml, id, NULL))
688     return FALSE;
689
690   if (gst_ebml_read_element_length (ebml, &length) < 0)
691     return FALSE;
692
693   /* remember level */
694   level = g_new (GstEbmlLevel, 1);
695   level->start = ebml->offset;
696   level->length = length;
697   ebml->level = g_list_append (ebml->level, level);
698
699   return TRUE;
700 }
701
702 /*
703  * Read the next element as binary data.
704  */
705
706 gboolean
707 gst_ebml_read_binary (GstEbmlRead * ebml,
708     guint32 * id, guint8 ** binary, guint64 * length)
709 {
710   guint8 *data;
711   guint size;
712
713   if (!gst_ebml_read_bytes (ebml, id, &data, &size))
714     return FALSE;
715
716   *length = size;
717   *binary = g_memdup (data, size);
718
719   return TRUE;
720 }
721
722 /*
723  * Read an EBML header.
724  */
725
726 gboolean
727 gst_ebml_read_header (GstEbmlRead * ebml, gchar ** doctype, guint * version)
728 {
729   /* this function is the first to be called */
730   guint32 id;
731   guint level_up;
732
733   /* default init */
734   if (doctype)
735     *doctype = NULL;
736   if (version)
737     *version = 1;
738
739   if (!gst_ebml_peek_id (ebml, &level_up, &id))
740     return FALSE;
741
742   GST_DEBUG_OBJECT (ebml, "id: %08x", GST_READ_UINT32_BE (&id));
743
744   if (level_up != 0 || id != GST_EBML_ID_HEADER) {
745     GST_ELEMENT_ERROR (ebml, STREAM, WRONG_TYPE, (NULL), (NULL));
746     return FALSE;
747   }
748   if (!gst_ebml_read_master (ebml, &id))
749     return FALSE;
750
751   while (TRUE) {
752     if (!gst_ebml_peek_id (ebml, &level_up, &id))
753       return FALSE;
754
755     /* end-of-header */
756     if (level_up)
757       break;
758
759     switch (id) {
760         /* is our read version uptodate? */
761       case GST_EBML_ID_EBMLREADVERSION:{
762         guint64 num;
763
764         if (!gst_ebml_read_uint (ebml, &id, &num))
765           return FALSE;
766         g_assert (id == GST_EBML_ID_EBMLREADVERSION);
767         if (num != GST_EBML_VERSION)
768           return FALSE;
769         break;
770       }
771
772         /* we only handle 8 byte lengths at max */
773       case GST_EBML_ID_EBMLMAXSIZELENGTH:{
774         guint64 num;
775
776         if (!gst_ebml_read_uint (ebml, &id, &num))
777           return FALSE;
778         g_assert (id == GST_EBML_ID_EBMLMAXSIZELENGTH);
779         if (num != sizeof (guint64))
780           return FALSE;
781         break;
782       }
783
784         /* we handle 4 byte IDs at max */
785       case GST_EBML_ID_EBMLMAXIDLENGTH:{
786         guint64 num;
787
788         if (!gst_ebml_read_uint (ebml, &id, &num))
789           return FALSE;
790         g_assert (id == GST_EBML_ID_EBMLMAXIDLENGTH);
791         if (num != sizeof (guint32))
792           return FALSE;
793         break;
794       }
795
796       case GST_EBML_ID_DOCTYPE:{
797         gchar *text;
798
799         if (!gst_ebml_read_ascii (ebml, &id, &text))
800           return FALSE;
801         g_assert (id == GST_EBML_ID_DOCTYPE);
802         if (doctype) {
803           if (doctype)
804             g_free (*doctype);
805           *doctype = text;
806         } else
807           g_free (text);
808         break;
809       }
810
811       case GST_EBML_ID_DOCTYPEREADVERSION:{
812         guint64 num;
813
814         if (!gst_ebml_read_uint (ebml, &id, &num))
815           return FALSE;
816         g_assert (id == GST_EBML_ID_DOCTYPEREADVERSION);
817         if (version)
818           *version = num;
819         break;
820       }
821
822       default:
823         GST_WARNING ("Unknown data type 0x%x in EBML header (ignored)", id);
824         /* pass-through */
825
826         /* we ignore these two, as they don't tell us anything we care about */
827       case GST_EBML_ID_VOID:
828       case GST_EBML_ID_EBMLVERSION:
829       case GST_EBML_ID_DOCTYPEVERSION:
830         if (!gst_ebml_read_skip (ebml))
831           return FALSE;
832         break;
833     }
834   }
835
836   return TRUE;
837 }