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