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 enum
  32 {
  33   /* FILL ME */
  34   LAST_SIGNAL
  35 };
  36
  37 static void gst_ebml_read_class_init (GstEbmlReadClass * klass);
  38 static void gst_ebml_read_init (GstEbmlRead * ebml);
  39 static GstElementStateReturn gst_ebml_read_change_state (GstElement * element);
  40
  41 static GstElementClass *parent_class = NULL;
  42
  43 GType
  44 gst_ebml_read_get_type (void)
  45 {
  46   static GType gst_ebml_read_type = 0;
  47
  48   if (!gst_ebml_read_type) {
  49     static const GTypeInfo gst_ebml_read_info = {
  50       sizeof (GstEbmlReadClass),
  51       NULL,
  52       NULL,
  53       (GClassInitFunc) gst_ebml_read_class_init,
  54       NULL,
  55       NULL,
  56       sizeof (GstEbmlRead),
  57       0,
  58       (GInstanceInitFunc) gst_ebml_read_init,
  59     };
  60
  61     gst_ebml_read_type =
  62         g_type_register_static (GST_TYPE_ELEMENT, "GstEbmlRead",
  63         &gst_ebml_read_info, 0);
  64   }
  65
  66   return gst_ebml_read_type;
  67 }
  68
  69 static void
  70 gst_ebml_read_class_init (GstEbmlReadClass * klass)
  71 {
  72   GstElementClass *gstelement_class = (GstElementClass *) klass;
  73
  74   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
  75
  76   gstelement_class->change_state = gst_ebml_read_change_state;
  77 }
  78
  79 static void
  80 gst_ebml_read_init (GstEbmlRead * ebml)
  81 {
  82   ebml->sinkpad = NULL;
  83   ebml->bs = NULL;
  84   ebml->level = NULL;
  85 }
  86
  87 static GstElementStateReturn
  88 gst_ebml_read_change_state (GstElement * element)
  89 {
  90   GstEbmlRead *ebml = GST_EBML_READ (element);
  91
  92   switch (GST_STATE_TRANSITION (element)) {
  93     case GST_STATE_READY_TO_PAUSED:
  94       if (!ebml->sinkpad)
  95         return GST_STATE_FAILURE;
  96       ebml->bs = gst_bytestream_new (ebml->sinkpad);
  97       break;
  98     case GST_STATE_PAUSED_TO_READY:
  99       gst_bytestream_destroy (ebml->bs);
 100       while (ebml->level) {
 101         GstEbmlLevel *level = ebml->level->data;
 102
 103         ebml->level = g_list_remove (ebml->level, level);
 104         g_free (level);
 105       }
 106       break;
 107     default:
 108       break;
 109   }
 110
 111   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 112     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 113
 114   return GST_STATE_SUCCESS;
 115 }
 116
 117 /*
 118  * Event handler. Basic:
 119  * - EOS: end-of-file, stop processing, forward EOS.
 120  * - Interrupt: stop processing.
 121  * - Discont: shouldn't be handled here but in the seek handler. Error.
 122  * - Flush: ignore, since we check for flush flags manually. Don't forward.
 123  * - Others: warn, ignore.
 124  * Return value indicates whether to continue processing.
 125  */
 126
 127 static gboolean
 128 gst_ebml_read_use_event (GstEbmlRead * ebml, GstEvent * event)
 129 {
 130   if (!event) {
 131     GST_ELEMENT_ERROR (ebml, RESOURCE, READ, (NULL), (NULL));
 132     return FALSE;
 133   }
 134
 135   switch (GST_EVENT_TYPE (event)) {
 136     case GST_EVENT_EOS:
 137       gst_pad_event_default (ebml->sinkpad, event);
 138       return FALSE;
 139
 140     case GST_EVENT_INTERRUPT:
 141       gst_event_unref (event);
 142       return FALSE;
 143
 144     case GST_EVENT_DISCONTINUOUS:
 145       GST_WARNING_OBJECT (ebml, "Unexpected discont - might lose sync");
 146       gst_pad_event_default (ebml->sinkpad, event);
 147       return TRUE;
 148
 149     case GST_EVENT_FLUSH:
 150       gst_event_unref (event);
 151       return TRUE;
 152
 153     default:
 154       GST_WARNING ("don't know how to handle event %d", GST_EVENT_TYPE (event));
 155       gst_pad_event_default (ebml->sinkpad, event);
 156       return FALSE;
 157   }
 158
 159   /* happy */
 160   g_assert_not_reached ();
 161   return FALSE;
 162 }
 163
 164 static gboolean
 165 gst_ebml_read_handle_event (GstEbmlRead * ebml)
 166 {
 167   GstEvent *event = NULL;
 168   guint32 remaining;
 169
 170   gst_bytestream_get_status (ebml->bs, &remaining, &event);
 171
 172   return gst_ebml_read_use_event (ebml, event);
 173 }
 174
 175 /*
 176  * Return: the amount of levels in the hierarchy that the
 177  * current element lies higher than the previous one.
 178  * The opposite isn't done - that's auto-done using master
 179  * element reading.
 180  */
 181
 182 static guint
 183 gst_ebml_read_element_level_up (GstEbmlRead * ebml)
 184 {
 185   guint num = 0;
 186   guint64 pos = gst_bytestream_tell (ebml->bs);
 187
 188   while (ebml->level != NULL) {
 189     GList *last = g_list_last (ebml->level);
 190     GstEbmlLevel *level = last->data;
 191
 192     if (pos >= level->start + level->length) {
 193       ebml->level = g_list_remove (ebml->level, level);
 194       g_free (level);
 195       num++;
 196     } else
 197       break;
 198   }
 199
 200   return num;
 201 }
 202
 203 /*
 204  * Read: the element content data ID.
 205  * Return: the number of bytes read or -1 on error.
 206  */
 207
 208 static gint
 209 gst_ebml_read_element_id (GstEbmlRead * ebml, guint32 * id, guint * level_up)
 210 {
 211   guint8 *data;
 212   gint len_mask = 0x80, read = 1, n = 1;
 213   guint32 total;
 214
 215   while (gst_bytestream_peek_bytes (ebml->bs, &data, 1) != 1) {
 216     if (!gst_ebml_read_handle_event (ebml))
 217       return -1;
 218   }
 219   total = data[0];
 220   while (read <= 4 && !(total & len_mask)) {
 221     read++;
 222     len_mask >>= 1;
 223   }
 224   if (read > 4) {
 225     guint64 pos = gst_bytestream_tell (ebml->bs);
 226
 227     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 228         ("Invalid EBML ID size tag (0x%x) at position %llu (0x%llx)",
 229             data[0], pos, pos));
 230     return -1;
 231   }
 232
 233   while (gst_bytestream_peek_bytes (ebml->bs, &data, read) != read) {
 234     if (!gst_ebml_read_handle_event (ebml))
 235       return -1;
 236   }
 237   while (n < read)
 238     total = (total << 8) | data[n++];
 239
 240   *id = total;
 241
 242   /* level */
 243   if (level_up)
 244     *level_up = gst_ebml_read_element_level_up (ebml);
 245
 246   return read;
 247 }
 248
 249 /*
 250  * Read: element content length.
 251  * Return: the number of bytes read or -1 on error.
 252  */
 253
 254 static gint
 255 gst_ebml_read_element_length (GstEbmlRead * ebml, guint64 * length)
 256 {
 257   guint8 *data;
 258   gint len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
 259   guint64 total;
 260
 261   while (gst_bytestream_peek_bytes (ebml->bs, &data, 1) != 1) {
 262     if (!gst_ebml_read_handle_event (ebml))
 263       return -1;
 264   }
 265   total = data[0];
 266   while (read <= 8 && !(total & len_mask)) {
 267     read++;
 268     len_mask >>= 1;
 269   }
 270   if (read > 8) {
 271     guint64 pos = gst_bytestream_tell (ebml->bs);
 272
 273     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 274         ("Invalid EBML length size tag (0x%x) at position %llu (0x%llx)",
 275             data[0], pos, pos));
 276     return -1;
 277   }
 278
 279   if ((total &= (len_mask - 1)) == len_mask - 1)
 280     num_ffs++;
 281   while (gst_bytestream_peek_bytes (ebml->bs, &data, read) != read) {
 282     if (!gst_ebml_read_handle_event (ebml))
 283       return -1;
 284   }
 285   while (n < read) {
 286     if (data[n] == 0xff)
 287       num_ffs++;
 288     total = (total << 8) | data[n];
 289     n++;
 290   }
 291
 292   if (read == num_ffs)
 293     *length = G_MAXUINT64;
 294   else
 295     *length = total;
 296
 297   return read;
 298 }
 299
 300 /*
 301  * Read: the actual data.
 302  * Return: the data, as a GstBuffer.
 303  */
 304
 305 static GstBuffer *
 306 gst_ebml_read_element_data (GstEbmlRead * ebml, guint64 length)
 307 {
 308   GstBuffer *buf = NULL;
 309
 310   if (gst_bytestream_peek (ebml->bs, &buf, length) != length) {
 311     if (!gst_ebml_read_handle_event (ebml))
 312       return NULL;
 313   }
 314
 315   gst_bytestream_flush_fast (ebml->bs, length);
 316
 317   return buf;
 318 }
 319
 320 /*
 321  * Return: the ID of the next element.
 322  * Level_up contains the amount of levels that this
 323  * next element lies higher than the previous one.
 324  */
 325
 326 guint32
 327 gst_ebml_peek_id (GstEbmlRead * ebml, guint * level_up)
 328 {
 329   guint32 id;
 330
 331   g_assert (level_up);
 332
 333   if (gst_ebml_read_element_id (ebml, &id, level_up) <= 0)
 334     return 0;
 335
 336   return id;
 337 }
 338
 339 /*
 340  * Seek to a given offset.
 341  */
 342
 343 GstEvent *
 344 gst_ebml_read_seek (GstEbmlRead * ebml, guint64 offset)
 345 {
 346   guint32 remaining;
 347   GstEvent *event = NULL;
 348   guchar *data;
 349
 350   /* first, flush remaining buffers */
 351   gst_bytestream_get_status (ebml->bs, &remaining, &event);
 352   if (event) {
 353     GST_WARNING ("Unexpected event before seek");
 354     if (!gst_ebml_read_use_event (ebml, event))
 355       return NULL;
 356     event = NULL;
 357   }
 358   if (remaining)
 359     gst_bytestream_flush_fast (ebml->bs, remaining);
 360
 361   /* now seek */
 362   if (!gst_bytestream_seek (ebml->bs, offset, GST_SEEK_METHOD_SET)) {
 363     GST_ELEMENT_ERROR (ebml, RESOURCE, SEEK, (NULL),
 364         ("Seek to position %llu (0x%llx) failed", offset, offset));
 365     return NULL;
 366   }
 367
 368   while (!event) {
 369     /* and now, peek a new byte. This will fail because there's a
 370      * pending event. Then, take the event and return it. */
 371     if (gst_bytestream_peek_bytes (ebml->bs, &data, 1)) {
 372       GST_WARNING ("Unexpected data after seek - this means seek failed");
 373       break;
 374     }
 375
 376     /* get the discont event and return */
 377     gst_bytestream_get_status (ebml->bs, &remaining, &event);
 378     if (!event) {
 379       GST_WARNING ("No discontinuity event after seek - seek failed");
 380       break;
 381     } else if (GST_EVENT_TYPE (event) != GST_EVENT_DISCONTINUOUS) {
 382       if (!gst_ebml_read_use_event (ebml, event))
 383         return NULL;
 384       event = NULL;
 385     }
 386   }
 387
 388   return event;
 389 }
 390
 391 /*
 392  * Skip the next element.
 393  */
 394
 395 gboolean
 396 gst_ebml_read_skip (GstEbmlRead * ebml)
 397 {
 398   gint bytes;
 399   guint32 id, remaining;
 400   guint64 length;
 401   GstEvent *event;
 402
 403   if ((bytes = gst_ebml_read_element_id (ebml, &id, NULL)) < 0)
 404     return FALSE;
 405   gst_bytestream_flush_fast (ebml->bs, bytes);
 406
 407   if ((bytes = gst_ebml_read_element_length (ebml, &length)) < 0)
 408     return FALSE;
 409   gst_bytestream_flush_fast (ebml->bs, bytes);
 410
 411   /* do we have enough bytes left to skip? */
 412   gst_bytestream_get_status (ebml->bs, &remaining, &event);
 413   if (event) {
 414     g_warning ("Unexpected event before skip");
 415     if (!gst_ebml_read_use_event (ebml, event))
 416       return FALSE;
 417   }
 418
 419   if (remaining >= length)
 420     return gst_bytestream_flush (ebml->bs, length);
 421
 422   if (!(event = gst_ebml_read_seek (ebml,
 423               gst_bytestream_tell (ebml->bs) + length))) {
 424     return FALSE;
 425   }
 426
 427   gst_event_unref (event);
 428
 429   return TRUE;
 430 }
 431
 432 /*
 433  * Read the next element as a GstBuffer (binary).
 434  */
 435
 436 gboolean
 437 gst_ebml_read_buffer (GstEbmlRead * ebml, guint32 * id, GstBuffer ** buf)
 438 {
 439   gint bytes;
 440   guint64 length;
 441
 442   if ((bytes = gst_ebml_read_element_id (ebml, id, NULL)) < 0)
 443     return FALSE;
 444   gst_bytestream_flush_fast (ebml->bs, bytes);
 445
 446   if ((bytes = gst_ebml_read_element_length (ebml, &length)) < 0)
 447     return FALSE;
 448   gst_bytestream_flush_fast (ebml->bs, bytes);
 449
 450   return ((*buf = gst_ebml_read_element_data (ebml, length)) != NULL);
 451 }
 452
 453 /*
 454  * Read the next element as an unsigned int.
 455  */
 456
 457 gboolean
 458 gst_ebml_read_uint (GstEbmlRead * ebml, guint32 * id, guint64 * num)
 459 {
 460   GstBuffer *buf;
 461   guint8 *data;
 462   guint size;
 463
 464   if (!gst_ebml_read_buffer (ebml, id, &buf))
 465     return FALSE;
 466
 467   data = GST_BUFFER_DATA (buf);
 468   size = GST_BUFFER_SIZE (buf);
 469   if (size < 1 || size > 8) {
 470     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 471         ("Invalid integer element size %d at position %llu (0x%llu)",
 472             size, GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET (buf)));
 473     gst_buffer_unref (buf);
 474     return FALSE;
 475   }
 476   *num = 0;
 477   while (size > 0) {
 478     *num = (*num << 8) | data[GST_BUFFER_SIZE (buf) - size];
 479     size--;
 480   }
 481
 482   gst_buffer_unref (buf);
 483
 484   return TRUE;
 485 }
 486
 487 /*
 488  * Read the next element as a signed int.
 489  */
 490
 491 gboolean
 492 gst_ebml_read_sint (GstEbmlRead * ebml, guint32 * id, gint64 * num)
 493 {
 494   GstBuffer *buf;
 495   guint8 *data;
 496   guint size, negative = 0, n = 0;
 497
 498   if (!gst_ebml_read_buffer (ebml, id, &buf))
 499     return FALSE;
 500
 501   data = GST_BUFFER_DATA (buf);
 502   size = GST_BUFFER_SIZE (buf);
 503   if (size < 1 || size > 8) {
 504     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 505         ("Invalid integer element size %d at position %llu (0x%llx)",
 506             size, GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET (buf)));
 507     gst_buffer_unref (buf);
 508     return FALSE;
 509   }
 510   if (data[0] & 0x80) {
 511     negative = 1;
 512     data[0] &= ~0x80;
 513   }
 514   *num = 0;
 515   while (n < size) {
 516     *num = (*num << 8) | data[n++];
 517   }
 518
 519   /* make signed */
 520   if (negative) {
 521     *num = *num - (1LL << ((8 * size) - 1));
 522   }
 523
 524   gst_buffer_unref (buf);
 525
 526   return TRUE;
 527 }
 528
 529 /*
 530  * Read the next element as a float.
 531  */
 532
 533 gboolean
 534 gst_ebml_read_float (GstEbmlRead * ebml, guint32 * id, gdouble * num)
 535 {
 536   GstBuffer *buf;
 537   guint8 *data;
 538   guint size;
 539
 540   if (!gst_ebml_read_buffer (ebml, id, &buf))
 541     return FALSE;
 542
 543   data = GST_BUFFER_DATA (buf);
 544   size = GST_BUFFER_SIZE (buf);
 545
 546   if (size != 4 && size != 8 && size != 10) {
 547     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 548         ("Invalid float element size %d at position %llu (0x%llx)",
 549             size, GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET (buf)));
 550     gst_buffer_unref (buf);
 551     return FALSE;
 552   }
 553
 554   if (size == 10) {
 555     GST_ELEMENT_ERROR (ebml, CORE, NOT_IMPLEMENTED, (NULL),
 556         ("FIXME! 10-byte floats unimplemented"));
 557     gst_buffer_unref (buf);
 558     return FALSE;
 559   }
 560
 561   if (size == 4) {
 562     gfloat f;
 563
 564 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
 565     f = *(gfloat *) data;
 566 #else
 567     while (size > 0) {
 568       ((guint8 *) & f)[size - 1] = data[4 - size];
 569       size--;
 570     }
 571 #endif
 572
 573     *num = f;
 574   } else {
 575     gdouble d;
 576
 577 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
 578     d = *(gdouble *) data;
 579 #else
 580     while (size > 0) {
 581       ((guint8 *) & d)[size - 1] = data[8 - size];
 582       size--;
 583     }
 584 #endif
 585
 586     *num = d;
 587   }
 588
 589   gst_buffer_unref (buf);
 590
 591   return TRUE;
 592 }
 593
 594 /*
 595  * Read the next element as an ASCII string.
 596  */
 597
 598 gboolean
 599 gst_ebml_read_ascii (GstEbmlRead * ebml, guint32 * id, gchar ** str)
 600 {
 601   GstBuffer *buf;
 602
 603   if (!gst_ebml_read_buffer (ebml, id, &buf))
 604     return FALSE;
 605
 606   *str = g_malloc (GST_BUFFER_SIZE (buf) + 1);
 607   memcpy (*str, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
 608   (*str)[GST_BUFFER_SIZE (buf)] = '\0';
 609
 610   gst_buffer_unref (buf);
 611
 612   return TRUE;
 613 }
 614
 615 /*
 616  * Read the next element as a UTF-8 string.
 617  */
 618
 619 gboolean
 620 gst_ebml_read_utf8 (GstEbmlRead * ebml, guint32 * id, gchar ** str)
 621 {
 622   return gst_ebml_read_ascii (ebml, id, str);
 623 }
 624
 625 /*
 626  * Read the next element as a date.
 627  * Returns the seconds since the unix epoch.
 628  */
 629
 630 gboolean
 631 gst_ebml_read_date (GstEbmlRead * ebml, guint32 * id, gint64 * date)
 632 {
 633   gint64 ebml_date;
 634   gboolean res = gst_ebml_read_sint (ebml, id, &ebml_date);
 635
 636   *date = (ebml_date / GST_SECOND) + GST_EBML_DATE_OFFSET;
 637   return res;
 638 }
 639
 640 /*
 641  * Read the next element, but only the header. The contents
 642  * are supposed to be sub-elements which can be read separately.
 643  */
 644
 645 gboolean
 646 gst_ebml_read_master (GstEbmlRead * ebml, guint32 * id)
 647 {
 648   gint bytes;
 649   guint64 length;
 650   GstEbmlLevel *level;
 651
 652   if ((bytes = gst_ebml_read_element_id (ebml, id, NULL)) < 0)
 653     return FALSE;
 654   gst_bytestream_flush_fast (ebml->bs, bytes);
 655
 656   if ((bytes = gst_ebml_read_element_length (ebml, &length)) < 0)
 657     return FALSE;
 658   gst_bytestream_flush_fast (ebml->bs, bytes);
 659
 660   /* remember level */
 661   level = g_new (GstEbmlLevel, 1);
 662   level->start = gst_bytestream_tell (ebml->bs);
 663   level->length = length;
 664   ebml->level = g_list_append (ebml->level, level);
 665
 666   return TRUE;
 667 }
 668
 669 /*
 670  * Read the next element as binary data.
 671  */
 672
 673 gboolean
 674 gst_ebml_read_binary (GstEbmlRead * ebml,
 675     guint32 * id, guint8 ** binary, guint64 * length)
 676 {
 677   GstBuffer *buf;
 678
 679   if (!gst_ebml_read_buffer (ebml, id, &buf))
 680     return FALSE;
 681
 682   *length = GST_BUFFER_SIZE (buf);
 683   *binary = g_memdup (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
 684
 685   gst_buffer_unref (buf);
 686
 687   return TRUE;
 688 }
 689
 690 /*
 691  * Read an EBML header.
 692  */
 693
 694 gboolean
 695 gst_ebml_read_header (GstEbmlRead * ebml, gchar ** doctype, guint * version)
 696 {
 697   /* this function is the first to be called */
 698   guint32 id;
 699   guint level_up;
 700
 701   /* default init */
 702   if (doctype)
 703     *doctype = NULL;
 704   if (version)
 705     *version = 1;
 706
 707   if (!(id = gst_ebml_peek_id (ebml, &level_up)))
 708     return FALSE;
 709   if (level_up != 0 || id != GST_EBML_ID_HEADER) {
 710     GST_ELEMENT_ERROR (ebml, STREAM, WRONG_TYPE, (NULL), (NULL));
 711     return FALSE;
 712   }
 713   if (!gst_ebml_read_master (ebml, &id))
 714     return FALSE;
 715   g_assert (id == GST_EBML_ID_HEADER);
 716
 717   while (TRUE) {
 718     if (!(id = gst_ebml_peek_id (ebml, &level_up)))
 719       return FALSE;
 720
 721     /* end-of-header */
 722     if (level_up)
 723       break;
 724
 725     switch (id) {
 726         /* is our read version uptodate? */
 727       case GST_EBML_ID_EBMLREADVERSION:{
 728         guint64 num;
 729
 730         if (!gst_ebml_read_uint (ebml, &id, &num))
 731           return FALSE;
 732         g_assert (id == GST_EBML_ID_EBMLREADVERSION);
 733         if (num != GST_EBML_VERSION)
 734           return FALSE;
 735         break;
 736       }
 737
 738         /* we only handle 8 byte lengths at max */
 739       case GST_EBML_ID_EBMLMAXSIZELENGTH:{
 740         guint64 num;
 741
 742         if (!gst_ebml_read_uint (ebml, &id, &num))
 743           return FALSE;
 744         g_assert (id == GST_EBML_ID_EBMLMAXSIZELENGTH);
 745         if (num != sizeof (guint64))
 746           return FALSE;
 747         break;
 748       }
 749
 750         /* we handle 4 byte IDs at max */
 751       case GST_EBML_ID_EBMLMAXIDLENGTH:{
 752         guint64 num;
 753
 754         if (!gst_ebml_read_uint (ebml, &id, &num))
 755           return FALSE;
 756         g_assert (id == GST_EBML_ID_EBMLMAXIDLENGTH);
 757         if (num != sizeof (guint32))
 758           return FALSE;
 759         break;
 760       }
 761
 762       case GST_EBML_ID_DOCTYPE:{
 763         gchar *text;
 764
 765         if (!gst_ebml_read_ascii (ebml, &id, &text))
 766           return FALSE;
 767         g_assert (id == GST_EBML_ID_DOCTYPE);
 768         if (doctype) {
 769           if (doctype)
 770             g_free (*doctype);
 771           *doctype = text;
 772         } else
 773           g_free (text);
 774         break;
 775       }
 776
 777       case GST_EBML_ID_DOCTYPEREADVERSION:{
 778         guint64 num;
 779
 780         if (!gst_ebml_read_uint (ebml, &id, &num))
 781           return FALSE;
 782         g_assert (id == GST_EBML_ID_DOCTYPEREADVERSION);
 783         if (version)
 784           *version = num;
 785         break;
 786       }
 787
 788       default:
 789         GST_WARNING ("Unknown data type 0x%x in EBML header (ignored)", id);
 790         /* pass-through */
 791
 792         /* we ignore these two, as they don't tell us anything we care about */
 793       case GST_EBML_ID_VOID:
 794       case GST_EBML_ID_EBMLVERSION:
 795       case GST_EBML_ID_DOCTYPEVERSION:
 796         if (!gst_ebml_read_skip (ebml))
 797           return FALSE;
 798         break;
 799     }
 800   }
 801
 802   return TRUE;
 803 }