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