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