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 (ebmlread_debug);
  44 #define GST_CAT_DEFAULT ebmlread_debug
  45
  46 /* Peeks following element id and element length in datastream provided
  47  * by @peek with @ctx as user data.
  48  * Returns GST_FLOW_EOS if not enough data to read id and length.
  49  * Otherwise, @needed provides the prefix length (id + length), and
  50  * @length provides element length.
  51  *
  52  * @object and @offset are provided for informative messaging/debug purposes.
  53  */
  54 GstFlowReturn
  55 gst_ebml_peek_id_length (guint32 * _id, guint64 * _length, guint * _needed,
  56     GstPeekData peek, gpointer * ctx, GstElement * el, guint64 offset)
  57 {
  58   guint needed;
  59   const guint8 *buf;
  60   gint len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
  61   guint64 total;
  62   guint8 b;
  63   GstFlowReturn ret;
  64
  65   g_return_val_if_fail (_id != NULL, GST_FLOW_ERROR);
  66   g_return_val_if_fail (_length != NULL, GST_FLOW_ERROR);
  67   g_return_val_if_fail (_needed != NULL, GST_FLOW_ERROR);
  68
  69   /* well ... */
  70   *_id = (guint32) GST_EBML_SIZE_UNKNOWN;
  71   *_length = GST_EBML_SIZE_UNKNOWN;
  72
  73   /* read element id */
  74   needed = 2;
  75   ret = peek (ctx, needed, &buf);
  76   if (ret != GST_FLOW_OK)
  77     goto peek_error;
  78   b = GST_READ_UINT8 (buf);
  79   total = (guint64) b;
  80   while (read <= 4 && !(total & len_mask)) {
  81     read++;
  82     len_mask >>= 1;
  83   }
  84   if (G_UNLIKELY (read > 4))
  85     goto invalid_id;
  86
  87   /* need id and at least something for subsequent length */
  88   needed = read + 1;
  89   ret = peek (ctx, needed, &buf);
  90   if (ret != GST_FLOW_OK)
  91     goto peek_error;
  92   while (n < read) {
  93     b = GST_READ_UINT8 (buf + n);
  94     total = (total << 8) | b;
  95     ++n;
  96   }
  97   *_id = (guint32) total;
  98
  99   /* read element length */
 100   b = GST_READ_UINT8 (buf + n);
 101   total = (guint64) b;
 102   len_mask = 0x80;
 103   read = 1;
 104   while (read <= 8 && !(total & len_mask)) {
 105     read++;
 106     len_mask >>= 1;
 107   }
 108   if (G_UNLIKELY (read > 8))
 109     goto invalid_length;
 110   if ((total &= (len_mask - 1)) == len_mask - 1)
 111     num_ffs++;
 112
 113   needed += read - 1;
 114   ret = peek (ctx, needed, &buf);
 115   if (ret != GST_FLOW_OK)
 116     goto peek_error;
 117   buf += (needed - read);
 118   n = 1;
 119   while (n < read) {
 120     guint8 b = GST_READ_UINT8 (buf + n);
 121
 122     if (G_UNLIKELY (b == 0xff))
 123       num_ffs++;
 124     total = (total << 8) | b;
 125     ++n;
 126   }
 127
 128   if (G_UNLIKELY (read == num_ffs))
 129     *_length = G_MAXUINT64;
 130   else
 131     *_length = total;
 132
 133   *_needed = needed;
 134
 135   return GST_FLOW_OK;
 136
 137   /* ERRORS */
 138 peek_error:
 139   {
 140     GST_WARNING_OBJECT (el, "peek failed, ret = %d", ret);
 141     *_needed = needed;
 142     return ret;
 143   }
 144 invalid_id:
 145   {
 146     GST_ERROR_OBJECT (el,
 147         "Invalid EBML ID size tag (0x%x) at position %" G_GUINT64_FORMAT " (0x%"
 148         G_GINT64_MODIFIER "x)", (guint) b, offset, offset);
 149     return GST_FLOW_ERROR;
 150   }
 151 invalid_length:
 152   {
 153     GST_ERROR_OBJECT (el,
 154         "Invalid EBML length size tag (0x%x) at position %" G_GUINT64_FORMAT
 155         " (0x%" G_GINT64_MODIFIER "x)", (guint) b, offset, offset);
 156     return GST_FLOW_ERROR;
 157   }
 158 }
 159
 160 /* setup for parsing @buf at position @offset on behalf of @el.
 161  * Takes ownership of @buf. */
 162 void
 163 gst_ebml_read_init (GstEbmlRead * ebml, GstElement * el, GstBuffer * buf,
 164     guint64 offset)
 165 {
 166   GstEbmlMaster m;
 167
 168   g_return_if_fail (el);
 169   g_return_if_fail (buf);
 170
 171   ebml->el = el;
 172   ebml->offset = offset;
 173   ebml->buf = buf;
 174   gst_buffer_map (buf, &ebml->map, GST_MAP_READ);
 175   ebml->readers = g_array_sized_new (FALSE, FALSE, sizeof (GstEbmlMaster), 10);
 176   m.offset = ebml->offset;
 177   gst_byte_reader_init (&m.br, ebml->map.data, ebml->map.size);
 178   g_array_append_val (ebml->readers, m);
 179 }
 180
 181 void
 182 gst_ebml_read_clear (GstEbmlRead * ebml)
 183 {
 184   if (ebml->readers)
 185     g_array_free (ebml->readers, TRUE);
 186   ebml->readers = NULL;
 187   if (ebml->buf) {
 188     gst_buffer_unmap (ebml->buf, &ebml->map);
 189     gst_buffer_unref (ebml->buf);
 190   }
 191   ebml->buf = NULL;
 192   ebml->el = NULL;
 193 }
 194
 195 static GstFlowReturn
 196 gst_ebml_read_peek (GstByteReader * br, guint peek, const guint8 ** data)
 197 {
 198   if (G_LIKELY (gst_byte_reader_peek_data (br, peek, data)))
 199     return GST_FLOW_OK;
 200   else
 201     return GST_FLOW_EOS;
 202 }
 203
 204 static GstFlowReturn
 205 gst_ebml_peek_id_full (GstEbmlRead * ebml, guint32 * id, guint64 * length,
 206     guint * prefix)
 207 {
 208   GstFlowReturn ret;
 209
 210   ret = gst_ebml_peek_id_length (id, length, prefix,
 211       (GstPeekData) gst_ebml_read_peek, (gpointer) gst_ebml_read_br (ebml),
 212       ebml->el, gst_ebml_read_get_pos (ebml));
 213   if (ret != GST_FLOW_OK)
 214     return ret;
 215
 216   GST_LOG_OBJECT (ebml->el, "id 0x%x at offset 0x%" G_GINT64_MODIFIER "x"
 217       " of length %" G_GUINT64_FORMAT ", prefix %d", *id,
 218       gst_ebml_read_get_pos (ebml), *length, *prefix);
 219
 220 #ifndef GST_DISABLE_GST_DEBUG
 221   {
 222     const guint8 *data = NULL;
 223     GstByteReader *br = gst_ebml_read_br (ebml);
 224     guint size = gst_byte_reader_get_remaining (br);
 225
 226     if (gst_byte_reader_peek_data (br, size, &data)) {
 227
 228       GST_LOG_OBJECT (ebml->el, "current br %p; remaining %d", br, size);
 229       if (data)
 230         GST_MEMDUMP_OBJECT (ebml->el, "element", data, MIN (size, *length));
 231     }
 232   }
 233 #endif
 234
 235   return ret;
 236 }
 237
 238 GstFlowReturn
 239 gst_ebml_peek_id (GstEbmlRead * ebml, guint32 * id)
 240 {
 241   guint64 length;
 242   guint needed;
 243
 244   return gst_ebml_peek_id_full (ebml, id, &length, &needed);
 245 }
 246
 247 /*
 248  * Read the next element, the contents are supposed to be sub-elements which
 249  * can be read separately.  A new bytereader is setup for doing so.
 250  */
 251 GstFlowReturn
 252 gst_ebml_read_master (GstEbmlRead * ebml, guint32 * id)
 253 {
 254   guint64 length;
 255   guint prefix;
 256   const guint8 *data = NULL;
 257   GstFlowReturn ret;
 258   GstEbmlMaster m;
 259
 260   ret = gst_ebml_peek_id_full (ebml, id, &length, &prefix);
 261   if (ret != GST_FLOW_OK)
 262     return ret;
 263
 264   /* we just at least peeked the id */
 265   if (!gst_byte_reader_skip (gst_ebml_read_br (ebml), prefix))
 266     return GST_FLOW_ERROR;      /* FIXME: do proper error handling */
 267
 268   m.offset = gst_ebml_read_get_pos (ebml);
 269   if (!gst_byte_reader_get_data (gst_ebml_read_br (ebml), length, &data))
 270     return GST_FLOW_PARSE;
 271
 272   GST_LOG_OBJECT (ebml->el, "pushing level %d at offset %" G_GUINT64_FORMAT,
 273       ebml->readers->len, m.offset);
 274   gst_byte_reader_init (&m.br, data, length);
 275   g_array_append_val (ebml->readers, m);
 276
 277   return GST_FLOW_OK;
 278 }
 279
 280 /* explicitly pop a bytereader from stack.  Usually invoked automagically. */
 281 GstFlowReturn
 282 gst_ebml_read_pop_master (GstEbmlRead * ebml)
 283 {
 284   g_return_val_if_fail (ebml->readers, GST_FLOW_ERROR);
 285
 286   /* never remove initial bytereader */
 287   if (ebml->readers->len > 1) {
 288     GST_LOG_OBJECT (ebml->el, "popping level %d", ebml->readers->len - 1);
 289     g_array_remove_index (ebml->readers, ebml->readers->len - 1);
 290   }
 291
 292   return GST_FLOW_OK;
 293 }
 294
 295 /*
 296  * Skip the next element.
 297  */
 298
 299 GstFlowReturn
 300 gst_ebml_read_skip (GstEbmlRead * ebml)
 301 {
 302   guint64 length;
 303   guint32 id;
 304   guint prefix;
 305   GstFlowReturn ret;
 306
 307   ret = gst_ebml_peek_id_full (ebml, &id, &length, &prefix);
 308   if (ret != GST_FLOW_OK)
 309     return ret;
 310
 311   if (!gst_byte_reader_skip (gst_ebml_read_br (ebml), length + prefix))
 312     return GST_FLOW_PARSE;
 313
 314   return ret;
 315 }
 316
 317 /*
 318  * Read the next element as a GstBuffer (binary).
 319  */
 320
 321 GstFlowReturn
 322 gst_ebml_read_buffer (GstEbmlRead * ebml, guint32 * id, GstBuffer ** buf)
 323 {
 324   guint64 length;
 325   guint prefix;
 326   GstFlowReturn ret;
 327
 328   ret = gst_ebml_peek_id_full (ebml, id, &length, &prefix);
 329   if (ret != GST_FLOW_OK)
 330     return ret;
 331
 332   /* we just at least peeked the id */
 333   if (!gst_byte_reader_skip (gst_ebml_read_br (ebml), prefix))
 334     return GST_FLOW_ERROR;      /* FIXME: do proper error handling */
 335
 336   if (G_LIKELY (length > 0)) {
 337     guint offset;
 338
 339     offset = gst_ebml_read_get_pos (ebml) - ebml->offset;
 340     if (G_LIKELY (gst_byte_reader_skip (gst_ebml_read_br (ebml), length))) {
 341       *buf = gst_buffer_copy_region (ebml->buf, GST_BUFFER_COPY_ALL,
 342           offset, length);
 343     } else {
 344       *buf = NULL;
 345       return GST_FLOW_PARSE;
 346     }
 347   } else {
 348     *buf = gst_buffer_new ();
 349   }
 350
 351   return ret;
 352 }
 353
 354 /*
 355  * Read the next element, return a pointer to it and its size.
 356  */
 357
 358 static GstFlowReturn
 359 gst_ebml_read_bytes (GstEbmlRead * ebml, guint32 * id, const guint8 ** data,
 360     guint * size)
 361 {
 362   guint64 length;
 363   guint prefix;
 364   GstFlowReturn ret;
 365
 366   *size = 0;
 367
 368   ret = gst_ebml_peek_id_full (ebml, id, &length, &prefix);
 369   if (ret != GST_FLOW_OK)
 370     return ret;
 371
 372   /* we just at least peeked the id */
 373   if (!gst_byte_reader_skip (gst_ebml_read_br (ebml), prefix))
 374     return GST_FLOW_ERROR;      /* FIXME: do proper error handling */
 375
 376   *data = NULL;
 377   if (G_LIKELY (length >= 0)) {
 378     if (!gst_byte_reader_get_data (gst_ebml_read_br (ebml), length, data))
 379       return GST_FLOW_PARSE;
 380   }
 381
 382   *size = length;
 383
 384   return ret;
 385 }
 386
 387 /*
 388  * Read the next element as an unsigned int.
 389  */
 390
 391 GstFlowReturn
 392 gst_ebml_read_uint (GstEbmlRead * ebml, guint32 * id, guint64 * num)
 393 {
 394   const guint8 *data;
 395   guint size;
 396   GstFlowReturn ret;
 397
 398   ret = gst_ebml_read_bytes (ebml, id, &data, &size);
 399   if (ret != GST_FLOW_OK)
 400     return ret;
 401
 402   if (size > 8) {
 403     GST_ERROR_OBJECT (ebml->el,
 404         "Invalid integer element size %d at position %" G_GUINT64_FORMAT " (0x%"
 405         G_GINT64_MODIFIER "x)", size, gst_ebml_read_get_pos (ebml) - size,
 406         gst_ebml_read_get_pos (ebml) - size);
 407     return GST_FLOW_ERROR;
 408   }
 409
 410   if (size == 0) {
 411     *num = 0;
 412     return ret;
 413   }
 414
 415   *num = 0;
 416   while (size > 0) {
 417     *num = (*num << 8) | *data;
 418     size--;
 419     data++;
 420   }
 421
 422   return ret;
 423 }
 424
 425 /*
 426  * Read the next element as a signed int.
 427  */
 428
 429 GstFlowReturn
 430 gst_ebml_read_sint (GstEbmlRead * ebml, guint32 * id, gint64 * num)
 431 {
 432   const guint8 *data;
 433   guint size;
 434   gboolean negative = 0;
 435   GstFlowReturn ret;
 436
 437   ret = gst_ebml_read_bytes (ebml, id, &data, &size);
 438   if (ret != GST_FLOW_OK)
 439     return ret;
 440
 441   if (size > 8) {
 442     GST_ERROR_OBJECT (ebml->el,
 443         "Invalid integer element size %d at position %" G_GUINT64_FORMAT " (0x%"
 444         G_GINT64_MODIFIER "x)", size, gst_ebml_read_get_pos (ebml) - size,
 445         gst_ebml_read_get_pos (ebml) - size);
 446     return GST_FLOW_ERROR;
 447   }
 448
 449   if (size == 0) {
 450     *num = 0;
 451     return ret;
 452   }
 453
 454   *num = 0;
 455   if (*data & 0x80) {
 456     negative = 1;
 457     *num = *data & ~0x80;
 458     size--;
 459     data++;
 460   }
 461
 462   while (size > 0) {
 463     *num = (*num << 8) | *data;
 464     size--;
 465     data++;
 466   }
 467
 468   /* make signed */
 469   if (negative) {
 470     *num = 0 - *num;
 471   }
 472
 473   return ret;
 474 }
 475
 476 /* Convert 80 bit extended precision float in big endian format to double.
 477  * Code taken from libavutil/intfloat_readwrite.c from ffmpeg,
 478  * licensed under LGPL */
 479
 480 struct _ext_float
 481 {
 482   guint8 exponent[2];
 483   guint8 mantissa[8];
 484 };
 485
 486 static gdouble
 487 _ext2dbl (const guint8 * data)
 488 {
 489   struct _ext_float ext;
 490   guint64 m = 0;
 491   gint e, i;
 492
 493   memcpy (&ext.exponent, data, 2);
 494   memcpy (&ext.mantissa, data + 2, 8);
 495
 496   for (i = 0; i < 8; i++)
 497     m = (m << 8) + ext.mantissa[i];
 498   e = (((gint) ext.exponent[0] & 0x7f) << 8) | ext.exponent[1];
 499   if (e == 0x7fff && m)
 500     return NAN;
 501   e -= 16383 + 63;              /* In IEEE 80 bits, the whole (i.e. 1.xxxx)
 502                                  * mantissa bit is written as opposed to the
 503                                  * single and double precision formats */
 504   if (ext.exponent[0] & 0x80)
 505     m = -m;
 506   return ldexp (m, e);
 507 }
 508
 509 /*
 510  * Read the next element as a float.
 511  */
 512
 513 GstFlowReturn
 514 gst_ebml_read_float (GstEbmlRead * ebml, guint32 * id, gdouble * num)
 515 {
 516   const guint8 *data;
 517   guint size;
 518   GstFlowReturn ret;
 519
 520   ret = gst_ebml_read_bytes (ebml, id, &data, &size);
 521   if (ret != GST_FLOW_OK)
 522     return ret;
 523
 524   if (size != 0 && size != 4 && size != 8 && size != 10) {
 525     GST_ERROR_OBJECT (ebml->el,
 526         "Invalid float element size %d at position %" G_GUINT64_FORMAT " (0x%"
 527         G_GINT64_MODIFIER "x)", size, gst_ebml_read_get_pos (ebml) - size,
 528         gst_ebml_read_get_pos (ebml) - size);
 529     return GST_FLOW_ERROR;
 530   }
 531
 532   if (size == 4) {
 533     gfloat f;
 534
 535     memcpy (&f, data, 4);
 536     f = GFLOAT_FROM_BE (f);
 537
 538     *num = f;
 539   } else if (size == 8) {
 540     gdouble d;
 541
 542     memcpy (&d, data, 8);
 543     d = GDOUBLE_FROM_BE (d);
 544
 545     *num = d;
 546   } else if (size == 10) {
 547     *num = _ext2dbl (data);
 548   } else {
 549     /* size == 0 means a value of 0.0 */
 550     *num = 0.0;
 551   }
 552
 553   return ret;
 554 }
 555
 556 /*
 557  * Read the next element as a C string.
 558  */
 559
 560 static GstFlowReturn
 561 gst_ebml_read_string (GstEbmlRead * ebml, guint32 * id, gchar ** str)
 562 {
 563   const guint8 *data;
 564   guint size;
 565   GstFlowReturn ret;
 566
 567   ret = gst_ebml_read_bytes (ebml, id, &data, &size);
 568   if (ret != GST_FLOW_OK)
 569     return ret;
 570
 571   *str = g_malloc (size + 1);
 572   memcpy (*str, data, size);
 573   (*str)[size] = '\0';
 574
 575   return ret;
 576 }
 577
 578 /*
 579  * Read the next element as an ASCII string.
 580  */
 581
 582 GstFlowReturn
 583 gst_ebml_read_ascii (GstEbmlRead * ebml, guint32 * id, gchar ** str_out)
 584 {
 585   GstFlowReturn ret;
 586   gchar *str;
 587   gchar *iter;
 588
 589 #ifndef GST_DISABLE_GST_DEBUG
 590   guint64 oldoff = ebml->offset;
 591 #endif
 592
 593   ret = gst_ebml_read_string (ebml, id, &str);
 594   if (ret != GST_FLOW_OK)
 595     return ret;
 596
 597   for (iter = str; *iter != '\0'; iter++) {
 598     if (G_UNLIKELY (*iter & 0x80)) {
 599       GST_ERROR_OBJECT (ebml,
 600           "Invalid ASCII string at offset %" G_GUINT64_FORMAT, oldoff);
 601       g_free (str);
 602       return GST_FLOW_ERROR;
 603     }
 604   }
 605
 606   *str_out = str;
 607   return ret;
 608 }
 609
 610 /*
 611  * Read the next element as a UTF-8 string.
 612  */
 613
 614 GstFlowReturn
 615 gst_ebml_read_utf8 (GstEbmlRead * ebml, guint32 * id, gchar ** str)
 616 {
 617   GstFlowReturn ret;
 618
 619 #ifndef GST_DISABLE_GST_DEBUG
 620   guint64 oldoff = gst_ebml_read_get_pos (ebml);
 621 #endif
 622
 623   ret = gst_ebml_read_string (ebml, id, str);
 624   if (ret != GST_FLOW_OK)
 625     return ret;
 626
 627   if (str != NULL && *str != NULL && **str != '\0' &&
 628       !g_utf8_validate (*str, -1, NULL)) {
 629     GST_WARNING_OBJECT (ebml->el,
 630         "Invalid UTF-8 string at offset %" G_GUINT64_FORMAT, oldoff);
 631   }
 632
 633   return ret;
 634 }
 635
 636 /*
 637  * Read the next element as a date.
 638  * Returns the seconds since the unix epoch.
 639  */
 640
 641 GstFlowReturn
 642 gst_ebml_read_date (GstEbmlRead * ebml, guint32 * id, gint64 * date)
 643 {
 644   gint64 ebml_date;
 645   GstFlowReturn ret;
 646
 647   ret = gst_ebml_read_sint (ebml, id, &ebml_date);
 648   if (ret != GST_FLOW_OK)
 649     return ret;
 650
 651   *date = (ebml_date / GST_SECOND) + GST_EBML_DATE_OFFSET;
 652
 653   return ret;
 654 }
 655
 656 /*
 657  * Read the next element as binary data.
 658  */
 659
 660 GstFlowReturn
 661 gst_ebml_read_binary (GstEbmlRead * ebml,
 662     guint32 * id, guint8 ** binary, guint64 * length)
 663 {
 664   const guint8 *data;
 665   guint size;
 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   *length = size;
 673   *binary = g_memdup (data, size);
 674
 675   return GST_FLOW_OK;
 676 }