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 #include <gst/floatcast/floatcast.h>
  28
  29 #include "ebml-read.h"
  30 #include "ebml-ids.h"
  31
  32 #include <math.h>
  33
  34 /* NAN is supposed to be in math.h, Microsoft defines it in xmath.h */
  35 #ifdef _MSC_VER
  36 #include <xmath.h>
  37 #endif
  38
  39 /* If everything goes wrong try 0.0/0.0 which should be NAN */
  40 #ifndef NAN
  41 #define NAN (0.0 / 0.0)
  42 #endif
  43
  44 GST_DEBUG_CATEGORY_STATIC (ebmlread_debug);
  45 #define GST_CAT_DEFAULT ebmlread_debug
  46
  47 static void gst_ebml_read_class_init (GstEbmlReadClass * klass);
  48
  49 static void gst_ebml_read_init (GstEbmlRead * ebml);
  50
  51 static GstStateChangeReturn gst_ebml_read_change_state (GstElement * element,
  52     GstStateChange transition);
  53
  54 /* convenience functions */
  55 static GstFlowReturn gst_ebml_read_peek_bytes (GstEbmlRead * ebml, guint size,
  56     GstBuffer ** p_buf, guint8 ** bytes);
  57 static GstFlowReturn gst_ebml_read_pull_bytes (GstEbmlRead * ebml, guint size,
  58     GstBuffer ** p_buf, guint8 ** bytes);
  59
  60
  61 static GstElementClass *parent_class;   /* NULL */
  62
  63 GType
  64 gst_ebml_read_get_type (void)
  65 {
  66   static GType gst_ebml_read_type;      /* 0 */
  67
  68   if (!gst_ebml_read_type) {
  69     static const GTypeInfo gst_ebml_read_info = {
  70       sizeof (GstEbmlReadClass),
  71       NULL,
  72       NULL,
  73       (GClassInitFunc) gst_ebml_read_class_init,
  74       NULL,
  75       NULL,
  76       sizeof (GstEbmlRead),
  77       0,
  78       (GInstanceInitFunc) gst_ebml_read_init,
  79     };
  80
  81     gst_ebml_read_type =
  82         g_type_register_static (GST_TYPE_ELEMENT, "GstEbmlRead",
  83         &gst_ebml_read_info, 0);
  84   }
  85
  86   return gst_ebml_read_type;
  87 }
  88
  89 void
  90 gst_ebml_level_free (GstEbmlLevel * level)
  91 {
  92   g_slice_free (GstEbmlLevel, level);
  93 }
  94
  95 static void
  96 gst_ebml_finalize (GObject * obj)
  97 {
  98   GstEbmlRead *ebml = GST_EBML_READ (obj);
  99
 100   g_list_foreach (ebml->level, (GFunc) gst_ebml_level_free, NULL);
 101   g_list_free (ebml->level);
 102   ebml->level = NULL;
 103   if (ebml->cached_buffer) {
 104     gst_buffer_unref (ebml->cached_buffer);
 105     ebml->cached_buffer = NULL;
 106   }
 107
 108   G_OBJECT_CLASS (parent_class)->finalize (obj);
 109 }
 110
 111 static void
 112 gst_ebml_read_class_init (GstEbmlReadClass * klass)
 113 {
 114   GstElementClass *gstelement_class = (GstElementClass *) klass;
 115   GObjectClass *gobject_class = (GObjectClass *) klass;
 116
 117   parent_class = g_type_class_peek_parent (klass);
 118
 119   GST_DEBUG_CATEGORY_INIT (ebmlread_debug, "ebmlread",
 120       0, "EBML stream helper class");
 121
 122   gobject_class->finalize = gst_ebml_finalize;
 123
 124   gstelement_class->change_state =
 125       GST_DEBUG_FUNCPTR (gst_ebml_read_change_state);
 126 }
 127
 128 static void
 129 gst_ebml_read_init (GstEbmlRead * ebml)
 130 {
 131   ebml->sinkpad = NULL;
 132   ebml->level = NULL;
 133 }
 134
 135 static GstStateChangeReturn
 136 gst_ebml_read_change_state (GstElement * element, GstStateChange transition)
 137 {
 138   GstStateChangeReturn ret;
 139   GstEbmlRead *ebml = GST_EBML_READ (element);
 140
 141   switch (transition) {
 142     case GST_STATE_CHANGE_READY_TO_PAUSED:
 143       if (!ebml->sinkpad) {
 144         g_return_val_if_reached (GST_STATE_CHANGE_FAILURE);
 145       }
 146       break;
 147     default:
 148       break;
 149   }
 150
 151   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 152
 153   switch (transition) {
 154     case GST_STATE_CHANGE_PAUSED_TO_READY:
 155     {
 156       g_list_foreach (ebml->level, (GFunc) gst_ebml_level_free, NULL);
 157       g_list_free (ebml->level);
 158       ebml->level = NULL;
 159       if (ebml->cached_buffer) {
 160         gst_buffer_unref (ebml->cached_buffer);
 161         ebml->cached_buffer = NULL;
 162       }
 163       ebml->offset = 0;
 164       break;
 165     }
 166     default:
 167       break;
 168   }
 169
 170   return ret;
 171 }
 172
 173 /*
 174  * Used in push mode.
 175  * Provided buffer is used as cache, based on offset 0, and no further reads
 176  * will be issued.
 177  */
 178
 179 void
 180 gst_ebml_read_reset_cache (GstEbmlRead * ebml, GstBuffer * buffer,
 181     guint64 offset)
 182 {
 183   if (ebml->cached_buffer)
 184     gst_buffer_unref (ebml->cached_buffer);
 185
 186   ebml->cached_buffer = buffer;
 187   ebml->push_cache = TRUE;
 188   buffer = gst_buffer_make_metadata_writable (buffer);
 189   GST_BUFFER_OFFSET (buffer) = offset;
 190   ebml->offset = offset;
 191   g_list_foreach (ebml->level, (GFunc) gst_ebml_level_free, NULL);
 192   g_list_free (ebml->level);
 193   ebml->level = NULL;
 194 }
 195
 196 /*
 197  * Return: the amount of levels in the hierarchy that the
 198  * current element lies higher than the previous one.
 199  * The opposite isn't done - that's auto-done using master
 200  * element reading.
 201  */
 202
 203 static guint
 204 gst_ebml_read_element_level_up (GstEbmlRead * ebml)
 205 {
 206   guint num = 0;
 207   guint64 pos = ebml->offset;
 208
 209   while (ebml->level != NULL) {
 210     GstEbmlLevel *level = ebml->level->data;
 211
 212     if (pos >= level->start + level->length) {
 213       ebml->level = g_list_delete_link (ebml->level, ebml->level);
 214       gst_ebml_level_free (level);
 215       num++;
 216     } else {
 217       break;
 218     }
 219   }
 220
 221   return num;
 222 }
 223
 224 /*
 225  * Calls pull_range for (offset,size) without advancing our offset
 226  */
 227 static GstFlowReturn
 228 gst_ebml_read_peek_bytes (GstEbmlRead * ebml, guint size, GstBuffer ** p_buf,
 229     guint8 ** bytes)
 230 {
 231   GstFlowReturn ret;
 232
 233   /* Caching here actually makes much less difference than one would expect.
 234    * We do it mainly to avoid pulling buffers of 1 byte all the time */
 235   if (ebml->cached_buffer) {
 236     guint64 cache_offset = GST_BUFFER_OFFSET (ebml->cached_buffer);
 237     guint cache_size = GST_BUFFER_SIZE (ebml->cached_buffer);
 238
 239     if (cache_offset <= ebml->offset &&
 240         (ebml->offset + size) <= (cache_offset + cache_size)) {
 241       if (p_buf)
 242         *p_buf = gst_buffer_create_sub (ebml->cached_buffer,
 243             ebml->offset - cache_offset, size);
 244       if (bytes)
 245         *bytes =
 246             GST_BUFFER_DATA (ebml->cached_buffer) + ebml->offset - cache_offset;
 247       return GST_FLOW_OK;
 248     }
 249     /* not enough data in the cache, free cache and get a new one */
 250     /* never drop pushed cache */
 251     if (ebml->push_cache) {
 252       if (ebml->offset == cache_offset + cache_size)
 253         return GST_FLOW_END;
 254       else
 255         return GST_FLOW_UNEXPECTED;
 256     }
 257     gst_buffer_unref (ebml->cached_buffer);
 258     ebml->cached_buffer = NULL;
 259   }
 260
 261   /* refill the cache */
 262   ret = gst_pad_pull_range (ebml->sinkpad, ebml->offset, MAX (size, 64 * 1024),
 263       &ebml->cached_buffer);
 264   if (ret != GST_FLOW_OK) {
 265     ebml->cached_buffer = NULL;
 266     return ret;
 267   }
 268
 269   if (GST_BUFFER_SIZE (ebml->cached_buffer) >= size) {
 270     if (p_buf)
 271       *p_buf = gst_buffer_create_sub (ebml->cached_buffer, 0, size);
 272     if (bytes)
 273       *bytes = GST_BUFFER_DATA (ebml->cached_buffer);
 274     return GST_FLOW_OK;
 275   }
 276
 277   /* Not possible to get enough data, try a last time with
 278    * requesting exactly the size we need */
 279   gst_buffer_unref (ebml->cached_buffer);
 280   ebml->cached_buffer = NULL;
 281
 282   ret =
 283       gst_pad_pull_range (ebml->sinkpad, ebml->offset, size,
 284       &ebml->cached_buffer);
 285   if (ret != GST_FLOW_OK) {
 286     GST_DEBUG_OBJECT (ebml, "pull_range returned %d", ret);
 287     if (p_buf)
 288       *p_buf = NULL;
 289     if (bytes)
 290       *bytes = NULL;
 291     return ret;
 292   }
 293
 294   if (GST_BUFFER_SIZE (ebml->cached_buffer) < size) {
 295     GST_WARNING_OBJECT (ebml, "Dropping short buffer at offset %"
 296         G_GUINT64_FORMAT ": wanted %u bytes, got %u bytes", ebml->offset,
 297         size, GST_BUFFER_SIZE (ebml->cached_buffer));
 298
 299     gst_buffer_unref (ebml->cached_buffer);
 300     ebml->cached_buffer = NULL;
 301     if (p_buf)
 302       *p_buf = NULL;
 303     if (bytes)
 304       *bytes = NULL;
 305     return GST_FLOW_UNEXPECTED;
 306   }
 307
 308   if (p_buf)
 309     *p_buf = gst_buffer_create_sub (ebml->cached_buffer, 0, size);
 310   if (bytes)
 311     *bytes = GST_BUFFER_DATA (*p_buf);
 312
 313   return GST_FLOW_OK;
 314 }
 315
 316 /*
 317  * Calls pull_range for (offset,size) and advances our offset by size
 318  */
 319 static GstFlowReturn
 320 gst_ebml_read_pull_bytes (GstEbmlRead * ebml, guint size, GstBuffer ** p_buf,
 321     guint8 ** bytes)
 322 {
 323   GstFlowReturn ret;
 324
 325   ret = gst_ebml_read_peek_bytes (ebml, size, p_buf, bytes);
 326   if (ret != GST_FLOW_OK)
 327     return ret;
 328
 329   ebml->offset += size;
 330   return GST_FLOW_OK;
 331 }
 332
 333 /*
 334  * Read: the element content data ID.
 335  * Return: FALSE on error.
 336  */
 337
 338 static GstFlowReturn
 339 gst_ebml_read_element_id (GstEbmlRead * ebml, guint32 * id, guint * level_up)
 340 {
 341   guint8 *buf;
 342   gint len_mask = 0x80, read = 1, n = 1;
 343   guint32 total;
 344   guint8 b;
 345   GstFlowReturn ret;
 346
 347   ret = gst_ebml_read_peek_bytes (ebml, 1, NULL, &buf);
 348   if (ret != GST_FLOW_OK)
 349     return ret;
 350
 351   b = GST_READ_UINT8 (buf);
 352
 353   total = (guint32) b;
 354
 355   while (read <= 4 && !(total & len_mask)) {
 356     read++;
 357     len_mask >>= 1;
 358   }
 359   if (read > 4) {
 360     GST_ERROR_OBJECT (ebml,
 361         "Invalid EBML ID size tag (0x%x) at position %" G_GUINT64_FORMAT " (0x%"
 362         G_GINT64_MODIFIER "x)", (guint) b, ebml->offset, ebml->offset);
 363     return GST_FLOW_ERROR;
 364   }
 365
 366   ret = gst_ebml_read_peek_bytes (ebml, read, NULL, &buf);
 367   if (ret != GST_FLOW_OK)
 368     return ret;
 369
 370   while (n < read) {
 371     b = GST_READ_UINT8 (buf + n);
 372     total = (total << 8) | b;
 373     ++n;
 374   }
 375
 376   *id = total;
 377
 378   /* level */
 379   if (level_up)
 380     *level_up = gst_ebml_read_element_level_up (ebml);
 381
 382   ebml->offset += read;
 383   return GST_FLOW_OK;
 384 }
 385
 386 /*
 387  * Read: element content length.
 388  * Return: the number of bytes read or -1 on error.
 389  */
 390
 391 static GstFlowReturn
 392 gst_ebml_read_element_length (GstEbmlRead * ebml, guint64 * length,
 393     gint * rread)
 394 {
 395   GstFlowReturn ret;
 396   guint8 *buf;
 397   gint len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
 398   guint64 total;
 399   guint8 b;
 400
 401   ret = gst_ebml_read_peek_bytes (ebml, 1, NULL, &buf);
 402   if (ret != GST_FLOW_OK)
 403     return ret;
 404
 405   b = GST_READ_UINT8 (buf);
 406
 407   total = (guint64) b;
 408
 409   while (read <= 8 && !(total & len_mask)) {
 410     read++;
 411     len_mask >>= 1;
 412   }
 413   if (read > 8) {
 414     GST_ERROR_OBJECT (ebml,
 415         "Invalid EBML length size tag (0x%x) at position %" G_GUINT64_FORMAT
 416         " (0x%" G_GINT64_MODIFIER "x)", (guint) b, ebml->offset, ebml->offset);
 417     return GST_FLOW_ERROR;
 418   }
 419
 420   if ((total &= (len_mask - 1)) == len_mask - 1)
 421     num_ffs++;
 422
 423   ret = gst_ebml_read_peek_bytes (ebml, read, NULL, &buf);
 424   if (ret != GST_FLOW_OK)
 425     return ret;
 426
 427   while (n < read) {
 428     guint8 b = GST_READ_UINT8 (buf + n);
 429
 430     if (b == 0xff)
 431       num_ffs++;
 432     total = (total << 8) | b;
 433     ++n;
 434   }
 435
 436   if (read == num_ffs)
 437     *length = G_MAXUINT64;
 438   else
 439     *length = total;
 440
 441   if (rread)
 442     *rread = read;
 443
 444   ebml->offset += read;
 445
 446   return GST_FLOW_OK;
 447 }
 448
 449 /*
 450  * Return: the ID of the next element.
 451  * Level_up contains the amount of levels that this
 452  * next element lies higher than the previous one.
 453  */
 454
 455 GstFlowReturn
 456 gst_ebml_peek_id (GstEbmlRead * ebml, guint * level_up, guint32 * id)
 457 {
 458   guint64 off;
 459   guint level_up_tmp = 0;
 460   GstFlowReturn ret;
 461
 462   g_assert (level_up);
 463   g_assert (id);
 464
 465   *level_up = 0;
 466
 467 next:
 468   off = ebml->offset;           /* save offset */
 469
 470   if ((ret = gst_ebml_read_element_id (ebml, id, &level_up_tmp)) != GST_FLOW_OK) {
 471     if (ret != GST_FLOW_END)
 472       return ret;
 473     else {
 474       /* simulate dummy VOID element,
 475        * and have the call stack bail out all the way */
 476       *id = GST_EBML_ID_VOID;
 477       *level_up = G_MAXUINT32 >> 2;
 478       return GST_FLOW_OK;
 479     }
 480   }
 481
 482   ebml->offset = off;           /* restore offset */
 483
 484   *level_up += level_up_tmp;
 485   level_up_tmp = 0;
 486
 487   switch (*id) {
 488     case GST_EBML_ID_VOID:
 489       GST_DEBUG_OBJECT (ebml, "Skipping EBML Void element");
 490       if ((ret = gst_ebml_read_skip (ebml)) != GST_FLOW_OK)
 491         return ret;
 492       goto next;
 493       break;
 494     case GST_EBML_ID_CRC32:
 495       GST_DEBUG_OBJECT (ebml, "Skipping EBML CRC32 element");
 496       if ((ret = gst_ebml_read_skip (ebml)) != GST_FLOW_OK)
 497         return ret;
 498       goto next;
 499       break;
 500   }
 501
 502   return ret;
 503 }
 504
 505 /*
 506  * Return the length of the stream in bytes
 507  */
 508
 509 gint64
 510 gst_ebml_read_get_length (GstEbmlRead * ebml)
 511 {
 512   GstFormat fmt = GST_FORMAT_BYTES;
 513   gint64 end;
 514
 515   /* FIXME: what to do if we don't get the upstream length */
 516   if (!gst_pad_query_peer_duration (ebml->sinkpad, &fmt, &end) ||
 517       fmt != GST_FORMAT_BYTES || end < 0)
 518     g_return_val_if_reached (0);
 519
 520   return end;
 521 }
 522
 523 /*
 524  * Seek to a given offset.
 525  */
 526
 527 GstFlowReturn
 528 gst_ebml_read_seek (GstEbmlRead * ebml, guint64 offset)
 529 {
 530   if (offset >= gst_ebml_read_get_length (ebml))
 531     return GST_FLOW_UNEXPECTED;
 532
 533   ebml->offset = offset;
 534
 535   return GST_FLOW_OK;
 536 }
 537
 538 /*
 539  * Skip the next element.
 540  */
 541
 542 GstFlowReturn
 543 gst_ebml_read_skip (GstEbmlRead * ebml)
 544 {
 545   guint64 length;
 546   guint32 id;
 547   GstFlowReturn ret;
 548
 549   ret = gst_ebml_read_element_id (ebml, &id, NULL);
 550   if (ret != GST_FLOW_OK)
 551     return ret;
 552
 553   ret = gst_ebml_read_element_length (ebml, &length, NULL);
 554   if (ret != GST_FLOW_OK)
 555     return ret;
 556
 557   ebml->offset += length;
 558   return ret;
 559 }
 560
 561 /*
 562  * Read the next element as a GstBuffer (binary).
 563  */
 564
 565 GstFlowReturn
 566 gst_ebml_read_buffer (GstEbmlRead * ebml, guint32 * id, GstBuffer ** buf)
 567 {
 568   guint64 length;
 569   GstFlowReturn ret;
 570
 571   ret = gst_ebml_read_element_id (ebml, id, NULL);
 572   if (ret != GST_FLOW_OK)
 573     return ret;
 574
 575   ret = gst_ebml_read_element_length (ebml, &length, NULL);
 576   if (ret != GST_FLOW_OK)
 577     return ret;
 578
 579   if (length == 0) {
 580     *buf = gst_buffer_new ();
 581     return GST_FLOW_OK;
 582   }
 583
 584   *buf = NULL;
 585   ret = gst_ebml_read_pull_bytes (ebml, (guint) length, buf, NULL);
 586
 587   return ret;
 588 }
 589
 590 /*
 591  * Read the next element, return a pointer to it and its size.
 592  */
 593
 594 static GstFlowReturn
 595 gst_ebml_read_bytes (GstEbmlRead * ebml, guint32 * id, guint8 ** data,
 596     guint * size)
 597 {
 598   guint64 length;
 599   GstFlowReturn ret;
 600
 601   *size = 0;
 602
 603   ret = gst_ebml_read_element_id (ebml, id, NULL);
 604   if (ret != GST_FLOW_OK)
 605     return ret;
 606
 607   ret = gst_ebml_read_element_length (ebml, &length, NULL);
 608   if (ret != GST_FLOW_OK)
 609     return ret;
 610
 611   if (length == 0) {
 612     *data = NULL;
 613     return ret;
 614   }
 615
 616   *data = NULL;
 617   ret = gst_ebml_read_pull_bytes (ebml, (guint) length, NULL, data);
 618   if (ret != GST_FLOW_OK)
 619     return ret;
 620
 621   *size = (guint) length;
 622
 623   return ret;
 624 }
 625
 626 /*
 627  * Read the next element as an unsigned int.
 628  */
 629
 630 GstFlowReturn
 631 gst_ebml_read_uint (GstEbmlRead * ebml, guint32 * id, guint64 * num)
 632 {
 633   guint8 *data;
 634   guint size;
 635   GstFlowReturn ret;
 636
 637   ret = gst_ebml_read_bytes (ebml, id, &data, &size);
 638   if (ret != GST_FLOW_OK)
 639     return ret;
 640
 641   if (size < 1 || size > 8) {
 642     GST_ERROR_OBJECT (ebml,
 643         "Invalid integer element size %d at position %" G_GUINT64_FORMAT " (0x%"
 644         G_GINT64_MODIFIER "x)", size, ebml->offset - size, ebml->offset - size);
 645     return GST_FLOW_ERROR;
 646   }
 647   *num = 0;
 648   while (size > 0) {
 649     *num = (*num << 8) | *data;
 650     size--;
 651     data++;
 652   }
 653
 654   return ret;
 655 }
 656
 657 /*
 658  * Read the next element as a signed int.
 659  */
 660
 661 GstFlowReturn
 662 gst_ebml_read_sint (GstEbmlRead * ebml, guint32 * id, gint64 * num)
 663 {
 664   guint8 *data;
 665   guint size;
 666   gboolean negative = 0;
 667   GstFlowReturn ret;
 668
 669   ret = gst_ebml_read_bytes (ebml, id, &data, &size);
 670   if (ret != GST_FLOW_OK)
 671     return ret;
 672
 673   if (size < 1 || size > 8) {
 674     GST_ERROR_OBJECT (ebml,
 675         "Invalid integer element size %d at position %" G_GUINT64_FORMAT " (0x%"
 676         G_GINT64_MODIFIER "x)", size, ebml->offset - size, ebml->offset - size);
 677     return GST_FLOW_ERROR;
 678   }
 679
 680   *num = 0;
 681   if (*data & 0x80) {
 682     negative = 1;
 683     *num = *data & ~0x80;
 684     size--;
 685     data++;
 686   }
 687
 688   while (size > 0) {
 689     *num = (*num << 8) | *data;
 690     size--;
 691     data++;
 692   }
 693
 694   /* make signed */
 695   if (negative) {
 696     *num = 0 - *num;
 697   }
 698
 699   return ret;
 700 }
 701
 702 /* Convert 80 bit extended precision float in big endian format to double.
 703  * Code taken from libavutil/intfloat_readwrite.c from ffmpeg,
 704  * licensed under LGPL */
 705
 706 struct _ext_float
 707 {
 708   guint8 exponent[2];
 709   guint8 mantissa[8];
 710 };
 711
 712 static gdouble
 713 _ext2dbl (guint8 * data)
 714 {
 715   struct _ext_float ext;
 716   guint64 m = 0;
 717   gint e, i;
 718
 719   memcpy (&ext.exponent, data, 2);
 720   memcpy (&ext.mantissa, data + 2, 8);
 721
 722   for (i = 0; i < 8; i++)
 723     m = (m << 8) + ext.mantissa[i];
 724   e = (((gint) ext.exponent[0] & 0x7f) << 8) | ext.exponent[1];
 725   if (e == 0x7fff && m)
 726     return NAN;
 727   e -= 16383 + 63;              /* In IEEE 80 bits, the whole (i.e. 1.xxxx)
 728                                  * mantissa bit is written as opposed to the
 729                                  * single and double precision formats */
 730   if (ext.exponent[0] & 0x80)
 731     m = -m;
 732   return ldexp (m, e);
 733 }
 734
 735 /*
 736  * Read the next element as a float.
 737  */
 738
 739 GstFlowReturn
 740 gst_ebml_read_float (GstEbmlRead * ebml, guint32 * id, gdouble * num)
 741 {
 742   guint8 *data;
 743   guint size;
 744   GstFlowReturn ret;
 745
 746   ret = gst_ebml_read_bytes (ebml, id, &data, &size);
 747   if (ret != GST_FLOW_OK)
 748     return ret;
 749
 750   if (size != 4 && size != 8 && size != 10) {
 751     GST_ERROR_OBJECT (ebml,
 752         "Invalid float element size %d at position %" G_GUINT64_FORMAT " (0x%"
 753         G_GINT64_MODIFIER "x)", size, ebml->offset - size, ebml->offset - size);
 754     return GST_FLOW_ERROR;
 755   }
 756
 757   if (size == 4) {
 758     gfloat f;
 759
 760     memcpy (&f, data, 4);
 761     f = GFLOAT_FROM_BE (f);
 762
 763     *num = f;
 764   } else if (size == 8) {
 765     gdouble d;
 766
 767     memcpy (&d, data, 8);
 768     d = GDOUBLE_FROM_BE (d);
 769
 770     *num = d;
 771   } else {
 772     *num = _ext2dbl (data);
 773   }
 774
 775   return ret;
 776 }
 777
 778 /*
 779  * Read the next element as a C string.
 780  */
 781
 782 static GstFlowReturn
 783 gst_ebml_read_string (GstEbmlRead * ebml, guint32 * id, gchar ** str)
 784 {
 785   guint8 *data;
 786   guint size;
 787   GstFlowReturn ret;
 788
 789   ret = gst_ebml_read_bytes (ebml, id, &data, &size);
 790   if (ret != GST_FLOW_OK)
 791     return ret;
 792
 793   *str = g_malloc (size + 1);
 794   memcpy (*str, data, size);
 795   (*str)[size] = '\0';
 796
 797   return ret;
 798 }
 799
 800 /*
 801  * Read the next element as an ASCII string.
 802  */
 803
 804 GstFlowReturn
 805 gst_ebml_read_ascii (GstEbmlRead * ebml, guint32 * id, gchar ** str_out)
 806 {
 807   GstFlowReturn ret;
 808   gchar *str;
 809   gchar *iter;
 810
 811 #ifndef GST_DISABLE_GST_DEBUG
 812   guint64 oldoff = ebml->offset;
 813 #endif
 814
 815   ret = gst_ebml_read_string (ebml, id, &str);
 816   if (ret != GST_FLOW_OK)
 817     return ret;
 818
 819   for (iter = str; *iter != '\0'; iter++) {
 820     if (G_UNLIKELY (*iter & 0x80)) {
 821       GST_ERROR_OBJECT (ebml,
 822           "Invalid ASCII string at offset %" G_GUINT64_FORMAT, oldoff);
 823       g_free (str);
 824       return GST_FLOW_ERROR;
 825     }
 826   }
 827
 828   *str_out = str;
 829   return ret;
 830 }
 831
 832 /*
 833  * Read the next element as a UTF-8 string.
 834  */
 835
 836 GstFlowReturn
 837 gst_ebml_read_utf8 (GstEbmlRead * ebml, guint32 * id, gchar ** str)
 838 {
 839   GstFlowReturn ret;
 840
 841 #ifndef GST_DISABLE_GST_DEBUG
 842   guint64 oldoff = ebml->offset;
 843 #endif
 844
 845   ret = gst_ebml_read_string (ebml, id, str);
 846   if (ret != GST_FLOW_OK)
 847     return ret;
 848
 849   if (str != NULL && *str != NULL && **str != '\0' &&
 850       !g_utf8_validate (*str, -1, NULL)) {
 851     GST_WARNING_OBJECT (ebml,
 852         "Invalid UTF-8 string at offset %" G_GUINT64_FORMAT, oldoff);
 853   }
 854
 855   return ret;
 856 }
 857
 858 /*
 859  * Read the next element as a date.
 860  * Returns the seconds since the unix epoch.
 861  */
 862
 863 GstFlowReturn
 864 gst_ebml_read_date (GstEbmlRead * ebml, guint32 * id, gint64 * date)
 865 {
 866   gint64 ebml_date;
 867   GstFlowReturn ret;
 868
 869   ret = gst_ebml_read_sint (ebml, id, &ebml_date);
 870   if (ret != GST_FLOW_OK)
 871     return ret;
 872
 873   *date = (ebml_date / GST_SECOND) + GST_EBML_DATE_OFFSET;
 874
 875   return ret;
 876 }
 877
 878 /*
 879  * Read the next element, but only the header. The contents
 880  * are supposed to be sub-elements which can be read separately.
 881  */
 882
 883 GstFlowReturn
 884 gst_ebml_read_master (GstEbmlRead * ebml, guint32 * id)
 885 {
 886   GstEbmlLevel *level;
 887   guint64 length;
 888   GstFlowReturn ret;
 889
 890   ret = gst_ebml_read_element_id (ebml, id, NULL);
 891   if (ret != GST_FLOW_OK)
 892     return ret;
 893
 894   ret = gst_ebml_read_element_length (ebml, &length, NULL);
 895   if (ret != GST_FLOW_OK)
 896     return ret;
 897
 898   /* remember level */
 899   level = g_slice_new (GstEbmlLevel);
 900   level->start = ebml->offset;
 901   level->length = length;
 902   ebml->level = g_list_prepend (ebml->level, level);
 903
 904   return GST_FLOW_OK;
 905 }
 906
 907 /*
 908  * Read the next element as binary data.
 909  */
 910
 911 GstFlowReturn
 912 gst_ebml_read_binary (GstEbmlRead * ebml,
 913     guint32 * id, guint8 ** binary, guint64 * length)
 914 {
 915   guint8 *data;
 916   guint size;
 917   GstFlowReturn ret;
 918
 919   ret = gst_ebml_read_bytes (ebml, id, &data, &size);
 920   if (ret != GST_FLOW_OK)
 921     return ret;
 922
 923   *length = size;
 924   *binary = g_memdup (data, size);
 925
 926   return GST_FLOW_OK;
 927 }
 928
 929 /*
 930  * Read an EBML header.
 931  */
 932
 933 GstFlowReturn
 934 gst_ebml_read_header (GstEbmlRead * ebml, gchar ** doctype, guint * version)
 935 {
 936   /* this function is the first to be called */
 937   guint32 id;
 938   guint level_up;
 939   GstFlowReturn ret;
 940
 941   /* default init */
 942   if (doctype)
 943     *doctype = NULL;
 944   if (version)
 945     *version = 1;
 946
 947   ret = gst_ebml_peek_id (ebml, &level_up, &id);
 948   if (ret != GST_FLOW_OK)
 949     return ret;
 950
 951   GST_DEBUG_OBJECT (ebml, "id: %08x", GST_READ_UINT32_BE (&id));
 952
 953   if (level_up != 0 || id != GST_EBML_ID_HEADER) {
 954     GST_ERROR_OBJECT (ebml, "Failed to read header");
 955     return GST_FLOW_ERROR;
 956   }
 957   ret = gst_ebml_read_master (ebml, &id);
 958   if (ret != GST_FLOW_OK)
 959     return ret;
 960
 961   while (TRUE) {
 962     ret = gst_ebml_peek_id (ebml, &level_up, &id);
 963     if (ret != GST_FLOW_OK)
 964       return ret;
 965
 966     /* end-of-header */
 967     if (level_up)
 968       break;
 969
 970     switch (id) {
 971         /* is our read version uptodate? */
 972       case GST_EBML_ID_EBMLREADVERSION:{
 973         guint64 num;
 974
 975         ret = gst_ebml_read_uint (ebml, &id, &num);
 976         if (ret != GST_FLOW_OK)
 977           return ret;
 978         g_assert (id == GST_EBML_ID_EBMLREADVERSION);
 979         if (num != GST_EBML_VERSION) {
 980           GST_ERROR_OBJECT (ebml, "Unsupported EBML version %" G_GUINT64_FORMAT,
 981               num);
 982           return GST_FLOW_ERROR;
 983         }
 984
 985         GST_DEBUG_OBJECT (ebml, "EbmlReadVersion: %" G_GUINT64_FORMAT, num);
 986         break;
 987       }
 988
 989         /* we only handle 8 byte lengths at max */
 990       case GST_EBML_ID_EBMLMAXSIZELENGTH:{
 991         guint64 num;
 992
 993         ret = gst_ebml_read_uint (ebml, &id, &num);
 994         if (ret != GST_FLOW_OK)
 995           return ret;
 996         g_assert (id == GST_EBML_ID_EBMLMAXSIZELENGTH);
 997         if (num > sizeof (guint64)) {
 998           GST_ERROR_OBJECT (ebml,
 999               "Unsupported EBML maximum size %" G_GUINT64_FORMAT, num);
1000           return GST_FLOW_ERROR;
1001         }
1002         GST_DEBUG_OBJECT (ebml, "EbmlMaxSizeLength: %" G_GUINT64_FORMAT, num);
1003         break;
1004       }
1005
1006         /* we handle 4 byte IDs at max */
1007       case GST_EBML_ID_EBMLMAXIDLENGTH:{
1008         guint64 num;
1009
1010         ret = gst_ebml_read_uint (ebml, &id, &num);
1011         if (ret != GST_FLOW_OK)
1012           return ret;
1013         g_assert (id == GST_EBML_ID_EBMLMAXIDLENGTH);
1014         if (num > sizeof (guint32)) {
1015           GST_ERROR_OBJECT (ebml,
1016               "Unsupported EBML maximum ID %" G_GUINT64_FORMAT, num);
1017           return GST_FLOW_ERROR;
1018         }
1019         GST_DEBUG_OBJECT (ebml, "EbmlMaxIdLength: %" G_GUINT64_FORMAT, num);
1020         break;
1021       }
1022
1023       case GST_EBML_ID_DOCTYPE:{
1024         gchar *text;
1025
1026         ret = gst_ebml_read_ascii (ebml, &id, &text);
1027         if (ret != GST_FLOW_OK)
1028           return ret;
1029         g_assert (id == GST_EBML_ID_DOCTYPE);
1030
1031         GST_DEBUG_OBJECT (ebml, "EbmlDocType: %s", GST_STR_NULL (text));
1032
1033         if (doctype) {
1034           g_free (*doctype);
1035           *doctype = text;
1036         } else
1037           g_free (text);
1038         break;
1039       }
1040
1041       case GST_EBML_ID_DOCTYPEREADVERSION:{
1042         guint64 num;
1043
1044         ret = gst_ebml_read_uint (ebml, &id, &num);
1045         if (ret != GST_FLOW_OK)
1046           return ret;
1047         g_assert (id == GST_EBML_ID_DOCTYPEREADVERSION);
1048         if (version)
1049           *version = num;
1050         GST_DEBUG_OBJECT (ebml, "EbmlReadVersion: %" G_GUINT64_FORMAT, num);
1051         break;
1052       }
1053
1054       default:
1055         GST_WARNING_OBJECT (ebml,
1056             "Unknown data type 0x%x in EBML header (ignored)", id);
1057         /* pass-through */
1058
1059         /* we ignore these two, as they don't tell us anything we care about */
1060       case GST_EBML_ID_EBMLVERSION:
1061       case GST_EBML_ID_DOCTYPEVERSION:
1062         ret = gst_ebml_read_skip (ebml);
1063         if (ret != GST_FLOW_OK)
1064           return ret;
1065         break;
1066     }
1067   }
1068
1069   return GST_FLOW_OK;
1070 }