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