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);
  42 static gboolean gst_ebml_read_pull_bytes (GstEbmlRead * ebml, guint size,
  43     GstBuffer ** p_buf);
  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 {
 168   GstFlowReturn ret;
 169
 170   /* Caching here actually makes much less difference than one would expect.
 171    * We do it mainly to avoid pulling buffers of 1 byte all the time */
 172   if (ebml->cached_buffer) {
 173     guint64 cache_offset = GST_BUFFER_OFFSET (ebml->cached_buffer);
 174     guint cache_size = GST_BUFFER_SIZE (ebml->cached_buffer);
 175
 176     if (cache_offset <= ebml->offset &&
 177         (ebml->offset + size) < (cache_offset + cache_size)) {
 178       *p_buf = gst_buffer_create_sub (ebml->cached_buffer,
 179           ebml->offset - cache_offset, size);
 180       return TRUE;
 181     }
 182     gst_buffer_unref (ebml->cached_buffer);
 183     ebml->cached_buffer = NULL;
 184   }
 185
 186   if (gst_pad_pull_range (ebml->sinkpad, ebml->offset, MAX (size, 64 * 1024),
 187           &ebml->cached_buffer) == GST_FLOW_OK &&
 188       GST_BUFFER_SIZE (ebml->cached_buffer) >= size) {
 189     *p_buf = gst_buffer_create_sub (ebml->cached_buffer, 0, size);
 190     return TRUE;
 191   }
 192
 193   ret = gst_pad_pull_range (ebml->sinkpad, ebml->offset, size, p_buf);
 194   if (ret != GST_FLOW_OK) {
 195     GST_DEBUG ("pull_range returned %d", ret);
 196     return FALSE;
 197   }
 198
 199   if (GST_BUFFER_SIZE (*p_buf) < size) {
 200     GST_WARNING_OBJECT (ebml, "Dropping short buffer at offset %"
 201         G_GUINT64_FORMAT ": wanted %u bytes, got %u bytes", ebml->offset,
 202         size, GST_BUFFER_SIZE (*p_buf));
 203     gst_buffer_unref (*p_buf);
 204     *p_buf = NULL;
 205     return FALSE;
 206   }
 207
 208   return TRUE;
 209 }
 210
 211 /*
 212  * Calls pull_range for (offset,size) and advances our offset by size
 213  */
 214 static gboolean
 215 gst_ebml_read_pull_bytes (GstEbmlRead * ebml, guint size, GstBuffer ** p_buf)
 216 {
 217   if (!gst_ebml_read_peek_bytes (ebml, size, p_buf))
 218     return FALSE;
 219
 220   ebml->offset += size;
 221   return TRUE;
 222 }
 223
 224 /*
 225  * Read: the element content data ID.
 226  * Return: FALSE on error.
 227  */
 228
 229 static gboolean
 230 gst_ebml_read_element_id (GstEbmlRead * ebml, guint32 * id, guint * level_up)
 231 {
 232   GstBuffer *buf;
 233   gint len_mask = 0x80, read = 1, n = 1;
 234   guint32 total;
 235   guint8 b;
 236
 237   if (!gst_ebml_read_peek_bytes (ebml, 1, &buf))
 238     return FALSE;
 239
 240   b = GST_READ_UINT8 (GST_BUFFER_DATA (buf));
 241   gst_buffer_unref (buf);
 242
 243   total = (guint32) b;
 244
 245   while (read <= 4 && !(total & len_mask)) {
 246     read++;
 247     len_mask >>= 1;
 248   }
 249   if (read > 4) {
 250     guint64 pos = ebml->offset;
 251
 252     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 253         ("Invalid EBML ID size tag (0x%x) at position %llu (0x%llx)",
 254             (guint) b, pos, pos));
 255     return FALSE;
 256   }
 257
 258   if (!gst_ebml_read_peek_bytes (ebml, read, &buf))
 259     return FALSE;
 260
 261   while (n < read) {
 262     b = GST_READ_UINT8 (GST_BUFFER_DATA (buf) + n);
 263     total = (total << 8) | b;
 264     ++n;
 265   }
 266
 267   *id = total;
 268
 269   /* level */
 270   if (level_up)
 271     *level_up = gst_ebml_read_element_level_up (ebml);
 272
 273   gst_buffer_unref (buf);
 274
 275   ebml->offset += read;
 276   return TRUE;
 277 }
 278
 279 /*
 280  * Read: element content length.
 281  * Return: the number of bytes read or -1 on error.
 282  */
 283
 284 static gint
 285 gst_ebml_read_element_length (GstEbmlRead * ebml, guint64 * length)
 286 {
 287   GstBuffer *buf;
 288   gint len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
 289   guint64 total;
 290   guint8 b;
 291
 292   if (!gst_ebml_read_peek_bytes (ebml, 1, &buf))
 293     return -1;
 294
 295   b = GST_READ_UINT8 (GST_BUFFER_DATA (buf));
 296   gst_buffer_unref (buf);
 297
 298   total = (guint64) b;
 299
 300   while (read <= 8 && !(total & len_mask)) {
 301     read++;
 302     len_mask >>= 1;
 303   }
 304   if (read > 8) {
 305     guint64 pos = ebml->offset;
 306
 307     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 308         ("Invalid EBML length size tag (0x%x) at position %llu (0x%llx)",
 309             (guint) b, pos, pos));
 310     return -1;
 311   }
 312
 313   if ((total &= (len_mask - 1)) == len_mask - 1)
 314     num_ffs++;
 315
 316   if (!gst_ebml_read_peek_bytes (ebml, read, &buf))
 317     return -1;
 318
 319   while (n < read) {
 320     guint8 b = GST_READ_UINT8 (GST_BUFFER_DATA (buf) + n);
 321
 322     if (b == 0xff)
 323       num_ffs++;
 324     total = (total << 8) | b;
 325     ++n;
 326   }
 327   gst_buffer_unref (buf);
 328
 329   if (read == num_ffs)
 330     *length = G_MAXUINT64;
 331   else
 332     *length = total;
 333
 334   ebml->offset += read;
 335
 336   return read;
 337 }
 338
 339 /*
 340  * Return: the ID of the next element.
 341  * Level_up contains the amount of levels that this
 342  * next element lies higher than the previous one.
 343  */
 344
 345 gboolean
 346 gst_ebml_peek_id (GstEbmlRead * ebml, guint * level_up, guint32 * id)
 347 {
 348   guint64 off;
 349
 350   g_assert (level_up);
 351
 352   off = ebml->offset;           /* save offset */
 353
 354   if (!gst_ebml_read_element_id (ebml, id, level_up))
 355     return FALSE;
 356
 357   ebml->offset = off;           /* restore offset */
 358   return TRUE;
 359 }
 360
 361 /*
 362  * Return the length of the stream in bytes
 363  */
 364
 365 gint64
 366 gst_ebml_read_get_length (GstEbmlRead * ebml)
 367 {
 368   GstFormat fmt = GST_FORMAT_BYTES;
 369   gint64 end;
 370
 371   if (!gst_pad_query_duration (GST_PAD_PEER (ebml->sinkpad), &fmt, &end))
 372     g_return_val_if_reached (0);        ///// FIXME /////////
 373
 374   if (fmt != GST_FORMAT_BYTES || end < 0)
 375     g_return_val_if_reached (0);        ///// FIXME /////////
 376
 377   return end;
 378 }
 379
 380 /*
 381  * Seek to a given offset.
 382  */
 383
 384 gboolean
 385 gst_ebml_read_seek (GstEbmlRead * ebml, guint64 offset)
 386 {
 387   if (offset >= gst_ebml_read_get_length (ebml))
 388     return FALSE;
 389
 390   ebml->offset = offset;
 391
 392   return TRUE;
 393 }
 394
 395 /*
 396  * Skip the next element.
 397  */
 398
 399 gboolean
 400 gst_ebml_read_skip (GstEbmlRead * ebml)
 401 {
 402   guint64 length;
 403   guint32 id;
 404
 405   if (!gst_ebml_read_element_id (ebml, &id, NULL))
 406     return FALSE;
 407
 408   if (gst_ebml_read_element_length (ebml, &length) < 0)
 409     return FALSE;
 410
 411   ebml->offset += length;
 412   return TRUE;
 413 }
 414
 415 /*
 416  * Read the next element as a GstBuffer (binary).
 417  */
 418
 419 gboolean
 420 gst_ebml_read_buffer (GstEbmlRead * ebml, guint32 * id, GstBuffer ** buf)
 421 {
 422   guint64 length;
 423
 424   if (!gst_ebml_read_element_id (ebml, id, NULL))
 425     return FALSE;
 426
 427   if (gst_ebml_read_element_length (ebml, &length) < 0)
 428     return FALSE;
 429
 430   if (length == 0) {
 431     *buf = gst_buffer_new ();
 432     return TRUE;
 433   }
 434
 435   *buf = NULL;
 436   if (!gst_ebml_read_pull_bytes (ebml, (guint) length, buf))
 437     return FALSE;
 438
 439   return TRUE;
 440 }
 441
 442 /*
 443  * Read the next element as an unsigned int.
 444  */
 445
 446 gboolean
 447 gst_ebml_read_uint (GstEbmlRead * ebml, guint32 * id, guint64 * num)
 448 {
 449   GstBuffer *buf;
 450   guint8 *data;
 451   guint size;
 452
 453   if (!gst_ebml_read_buffer (ebml, id, &buf))
 454     return FALSE;
 455
 456   data = GST_BUFFER_DATA (buf);
 457   size = GST_BUFFER_SIZE (buf);
 458   if (size < 1 || size > 8) {
 459     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 460         ("Invalid integer element size %d at position %llu (0x%llu)",
 461             size, GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET (buf)));
 462     gst_buffer_unref (buf);
 463     return FALSE;
 464   }
 465   *num = 0;
 466   while (size > 0) {
 467     *num = (*num << 8) | data[GST_BUFFER_SIZE (buf) - size];
 468     size--;
 469   }
 470
 471   gst_buffer_unref (buf);
 472
 473   return TRUE;
 474 }
 475
 476 /*
 477  * Read the next element as a signed int.
 478  */
 479
 480 gboolean
 481 gst_ebml_read_sint (GstEbmlRead * ebml, guint32 * id, gint64 * num)
 482 {
 483   GstBuffer *buf;
 484   guint8 *data;
 485   guint size, negative = 0, n = 0;
 486
 487   if (!gst_ebml_read_buffer (ebml, id, &buf))
 488     return FALSE;
 489
 490   data = GST_BUFFER_DATA (buf);
 491   size = GST_BUFFER_SIZE (buf);
 492   if (size < 1 || size > 8) {
 493     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 494         ("Invalid integer element size %d at position %llu (0x%llx)",
 495             size, GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET (buf)));
 496     gst_buffer_unref (buf);
 497     return FALSE;
 498   }
 499   if (data[0] & 0x80) {
 500     negative = 1;
 501     data[0] &= ~0x80;
 502   }
 503   *num = 0;
 504   while (n < size) {
 505     *num = (*num << 8) | data[n++];
 506   }
 507
 508   /* make signed */
 509   if (negative) {
 510     *num = *num - (1LL << ((8 * size) - 1));
 511   }
 512
 513   gst_buffer_unref (buf);
 514
 515   return TRUE;
 516 }
 517
 518 /*
 519  * Read the next element as a float.
 520  */
 521
 522 gboolean
 523 gst_ebml_read_float (GstEbmlRead * ebml, guint32 * id, gdouble * num)
 524 {
 525   GstBuffer *buf;
 526   guint8 *data;
 527   guint size;
 528
 529   if (!gst_ebml_read_buffer (ebml, id, &buf))
 530     return FALSE;
 531
 532   data = GST_BUFFER_DATA (buf);
 533   size = GST_BUFFER_SIZE (buf);
 534
 535   if (size != 4 && size != 8 && size != 10) {
 536     GST_ELEMENT_ERROR (ebml, STREAM, DEMUX, (NULL),
 537         ("Invalid float element size %d at position %llu (0x%llx)",
 538             size, GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET (buf)));
 539     gst_buffer_unref (buf);
 540     return FALSE;
 541   }
 542
 543   if (size == 10) {
 544     GST_ELEMENT_ERROR (ebml, CORE, NOT_IMPLEMENTED, (NULL),
 545         ("FIXME! 10-byte floats unimplemented"));
 546     gst_buffer_unref (buf);
 547     return FALSE;
 548   }
 549
 550   if (size == 4) {
 551     gfloat f;
 552
 553 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
 554     f = *(gfloat *) data;
 555 #else
 556     while (size > 0) {
 557       ((guint8 *) & f)[size - 1] = data[4 - size];
 558       size--;
 559     }
 560 #endif
 561
 562     *num = f;
 563   } else {
 564     gdouble d;
 565
 566 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
 567     d = *(gdouble *) data;
 568 #else
 569     while (size > 0) {
 570       ((guint8 *) & d)[size - 1] = data[8 - size];
 571       size--;
 572     }
 573 #endif
 574
 575     *num = d;
 576   }
 577
 578   gst_buffer_unref (buf);
 579
 580   return TRUE;
 581 }
 582
 583 /*
 584  * Read the next element as an ASCII string.
 585  */
 586
 587 gboolean
 588 gst_ebml_read_ascii (GstEbmlRead * ebml, guint32 * id, gchar ** str)
 589 {
 590   GstBuffer *buf;
 591
 592   if (!gst_ebml_read_buffer (ebml, id, &buf))
 593     return FALSE;
 594
 595   *str = g_malloc (GST_BUFFER_SIZE (buf) + 1);
 596   memcpy (*str, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
 597   (*str)[GST_BUFFER_SIZE (buf)] = '\0';
 598
 599   gst_buffer_unref (buf);
 600
 601   return TRUE;
 602 }
 603
 604 /*
 605  * Read the next element as a UTF-8 string.
 606  */
 607
 608 gboolean
 609 gst_ebml_read_utf8 (GstEbmlRead * ebml, guint32 * id, gchar ** str)
 610 {
 611   gboolean ret;
 612   guint64 oldoff = ebml->offset;
 613
 614   ret = gst_ebml_read_ascii (ebml, id, str);
 615
 616   if (str != NULL && *str != NULL && **str != '\0' &&
 617       !g_utf8_validate (*str, -1, NULL)) {
 618     GST_WARNING ("Invalid UTF-8 string at offset %" G_GUINT64_FORMAT, oldoff);
 619   }
 620
 621   return ret;
 622 }
 623
 624 /*
 625  * Read the next element as a date.
 626  * Returns the seconds since the unix epoch.
 627  */
 628
 629 gboolean
 630 gst_ebml_read_date (GstEbmlRead * ebml, guint32 * id, gint64 * date)
 631 {
 632   gint64 ebml_date;
 633   gboolean res = gst_ebml_read_sint (ebml, id, &ebml_date);
 634
 635   *date = (ebml_date / GST_SECOND) + GST_EBML_DATE_OFFSET;
 636   return res;
 637 }
 638
 639 /*
 640  * Read the next element, but only the header. The contents
 641  * are supposed to be sub-elements which can be read separately.
 642  */
 643
 644 gboolean
 645 gst_ebml_read_master (GstEbmlRead * ebml, guint32 * id)
 646 {
 647   GstEbmlLevel *level;
 648   guint64 length;
 649
 650   if (!gst_ebml_read_element_id (ebml, id, NULL))
 651     return FALSE;
 652
 653   if (gst_ebml_read_element_length (ebml, &length) < 0)
 654     return FALSE;
 655
 656   /* remember level */
 657   level = g_new (GstEbmlLevel, 1);
 658   level->start = ebml->offset;
 659   level->length = length;
 660   ebml->level = g_list_append (ebml->level, level);
 661
 662   return TRUE;
 663 }
 664
 665 /*
 666  * Read the next element as binary data.
 667  */
 668
 669 gboolean
 670 gst_ebml_read_binary (GstEbmlRead * ebml,
 671     guint32 * id, guint8 ** binary, guint64 * length)
 672 {
 673   GstBuffer *buf;
 674
 675   if (!gst_ebml_read_buffer (ebml, id, &buf))
 676     return FALSE;
 677
 678   *length = GST_BUFFER_SIZE (buf);
 679   *binary = g_memdup (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
 680
 681   gst_buffer_unref (buf);
 682
 683   return TRUE;
 684 }
 685
 686 /*
 687  * Read an EBML header.
 688  */
 689
 690 gboolean
 691 gst_ebml_read_header (GstEbmlRead * ebml, gchar ** doctype, guint * version)
 692 {
 693   /* this function is the first to be called */
 694   guint32 id;
 695   guint level_up;
 696
 697   /* default init */
 698   if (doctype)
 699     *doctype = NULL;
 700   if (version)
 701     *version = 1;
 702
 703   if (!gst_ebml_peek_id (ebml, &level_up, &id))
 704     return FALSE;
 705
 706   GST_DEBUG_OBJECT (ebml, "id: %08x", GST_READ_UINT32_BE (&id));
 707
 708   if (level_up != 0 || id != GST_EBML_ID_HEADER) {
 709     GST_ELEMENT_ERROR (ebml, STREAM, WRONG_TYPE, (NULL), (NULL));
 710     return FALSE;
 711   }
 712   if (!gst_ebml_read_master (ebml, &id))
 713     return FALSE;
 714
 715   while (TRUE) {
 716     if (!gst_ebml_peek_id (ebml, &level_up, &id))
 717       return FALSE;
 718
 719     /* end-of-header */
 720     if (level_up)
 721       break;
 722
 723     switch (id) {
 724         /* is our read version uptodate? */
 725       case GST_EBML_ID_EBMLREADVERSION:{
 726         guint64 num;
 727
 728         if (!gst_ebml_read_uint (ebml, &id, &num))
 729           return FALSE;
 730         g_assert (id == GST_EBML_ID_EBMLREADVERSION);
 731         if (num != GST_EBML_VERSION)
 732           return FALSE;
 733         break;
 734       }
 735
 736         /* we only handle 8 byte lengths at max */
 737       case GST_EBML_ID_EBMLMAXSIZELENGTH:{
 738         guint64 num;
 739
 740         if (!gst_ebml_read_uint (ebml, &id, &num))
 741           return FALSE;
 742         g_assert (id == GST_EBML_ID_EBMLMAXSIZELENGTH);
 743         if (num != sizeof (guint64))
 744           return FALSE;
 745         break;
 746       }
 747
 748         /* we handle 4 byte IDs at max */
 749       case GST_EBML_ID_EBMLMAXIDLENGTH:{
 750         guint64 num;
 751
 752         if (!gst_ebml_read_uint (ebml, &id, &num))
 753           return FALSE;
 754         g_assert (id == GST_EBML_ID_EBMLMAXIDLENGTH);
 755         if (num != sizeof (guint32))
 756           return FALSE;
 757         break;
 758       }
 759
 760       case GST_EBML_ID_DOCTYPE:{
 761         gchar *text;
 762
 763         if (!gst_ebml_read_ascii (ebml, &id, &text))
 764           return FALSE;
 765         g_assert (id == GST_EBML_ID_DOCTYPE);
 766         if (doctype) {
 767           if (doctype)
 768             g_free (*doctype);
 769           *doctype = text;
 770         } else
 771           g_free (text);
 772         break;
 773       }
 774
 775       case GST_EBML_ID_DOCTYPEREADVERSION:{
 776         guint64 num;
 777
 778         if (!gst_ebml_read_uint (ebml, &id, &num))
 779           return FALSE;
 780         g_assert (id == GST_EBML_ID_DOCTYPEREADVERSION);
 781         if (version)
 782           *version = num;
 783         break;
 784       }
 785
 786       default:
 787         GST_WARNING ("Unknown data type 0x%x in EBML header (ignored)", id);
 788         /* pass-through */
 789
 790         /* we ignore these two, as they don't tell us anything we care about */
 791       case GST_EBML_ID_VOID:
 792       case GST_EBML_ID_EBMLVERSION:
 793       case GST_EBML_ID_DOCTYPEVERSION:
 794         if (!gst_ebml_read_skip (ebml))
 795           return FALSE;
 796         break;
 797     }
 798   }
 799
 800   return TRUE;
 801 }