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