Source: lib/dash/ebml_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.EbmlElement');
  8. goog.provide('shaka.dash.EbmlParser');
  10. goog.require('goog.asserts');
  11. goog.require('shaka.util.BufferUtils');
  12. goog.require('shaka.util.DataViewReader');
  13. goog.require('shaka.util.Error');
  16. /**
  17.  * @summary
  18.  * Extensible Binary Markup Language (EBML) parser.
  19.  */
  20. shaka.dash.EbmlParser = class {
  21.   /**
  22.    * @param {BufferSource} data
  23.    */
  24.   constructor(data) {
  25.     /** @private {!DataView} */
  26.     this.dataView_ = shaka.util.BufferUtils.toDataView(data);
  28.     /** @private {!shaka.util.DataViewReader} */
  29.     this.reader_ = new shaka.util.DataViewReader(
  30.         this.dataView_, shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
  31.   }
  34.   /**
  35.    * @return {boolean} True if the parser has more data, false otherwise.
  36.    */
  37.   hasMoreData() {
  38.     return this.reader_.hasMoreData();
  39.   }
  42.   /**
  43.    * Parses an EBML element from the parser's current position, and advances
  44.    * the parser.
  45.    * @return {!shaka.util.EbmlElement} The EBML element.
  46.    * @see http://matroska.org/technical/specs/rfc/index.html
  47.    */
  48.   parseElement() {
  49.     const id = this.parseId_();
  51.     // Parse the element's size.
  52.     const vint = this.parseVint_();
  53.     let size;
  54.     if (shaka.dash.EbmlParser.isDynamicSizeValue_(vint)) {
  55.       // If this has an unknown size, assume that it takes up the rest of the
  56.       // data.
  57.       size = this.dataView_.byteLength - this.reader_.getPosition();
  58.     } else {
  59.       size = shaka.dash.EbmlParser.getVintValue_(vint);
  60.     }
  62.     // Note that if the element's size is larger than the buffer then we are
  63.     // parsing a "partial element". This may occur if for example we are
  64.     // parsing the beginning of some WebM container data, but our buffer does
  65.     // not contain the entire WebM container data.
  66.     const elementSize =
  67.         this.reader_.getPosition() + size <= this.dataView_.byteLength ?
  68.         size :
  69.         this.dataView_.byteLength - this.reader_.getPosition();
  71.     const dataView = shaka.util.BufferUtils.toDataView(
  72.         this.dataView_, this.reader_.getPosition(), elementSize);
  74.     this.reader_.skip(elementSize);
  76.     return new shaka.util.EbmlElement(id, dataView);
  77.   }
  80.   /**
  81.    * Parses an EBML ID from the parser's current position, and advances the
  82.    * parser.
  83.    * @return {number} The EBML ID.
  84.    * @private
  85.    */
  86.   parseId_() {
  87.     const vint = this.parseVint_();
  89.     if (vint.length > 7) {
  90.       throw new shaka.util.Error(
  91.           shaka.util.Error.Severity.CRITICAL,
  92.           shaka.util.Error.Category.MEDIA,
  93.           shaka.util.Error.Code.EBML_OVERFLOW);
  94.     }
  96.     let id = 0;
  97.     for (const /* byte */ b of vint) {
  98.       // Note that we cannot use << since |value| may exceed 32 bits.
  99.       id = (256 * id) + b;
  100.     }
  102.     return id;
  103.   }
  106.   /**
  107.    * Parses a variable sized integer from the parser's current position, and
  108.    * advances the parser.
  109.    * For example:
  110.    *   1 byte  wide: 1xxx xxxx
  111.    *   2 bytes wide: 01xx xxxx xxxx xxxx
  112.    *   3 bytes wide: 001x xxxx xxxx xxxx xxxx xxxx
  113.    * @return {!Uint8Array} The variable sized integer.
  114.    * @private
  115.    */
  116.   parseVint_() {
  117.     const position = this.reader_.getPosition();
  118.     const firstByte = this.reader_.readUint8();
  119.     if (firstByte == 0) {
  120.       throw new shaka.util.Error(
  121.           shaka.util.Error.Severity.CRITICAL,
  122.           shaka.util.Error.Category.MEDIA,
  123.           shaka.util.Error.Code.EBML_OVERFLOW);
  124.     }
  126.     // Determine the index of the highest bit set.
  127.     const index = Math.floor(Math.log2(firstByte));
  128.     const numBytes = 8 - index;
  129.     goog.asserts.assert(numBytes <= 8 && numBytes >= 1, 'Incorrect log2 value');
  130.     this.reader_.skip(numBytes - 1);
  131.     return shaka.util.BufferUtils.toUint8(this.dataView_, position, numBytes);
  132.   }
  135.   /**
  136.    * Gets the value of a variable sized integer.
  137.    * For example, the x's below are part of the vint's value.
  138.    *    7-bit value: 1xxx xxxx
  139.    *   14-bit value: 01xx xxxx xxxx xxxx
  140.    *   21-bit value: 001x xxxx xxxx xxxx xxxx xxxx
  141.    * @param {!Uint8Array} vint The variable sized integer.
  142.    * @return {number} The value of the variable sized integer.
  143.    * @private
  144.    */
  145.   static getVintValue_(vint) {
  146.     // If |vint| is 8 bytes wide then we must ensure that it does not have more
  147.     // than 53 meaningful bits. For example, assume |vint| is 8 bytes wide,
  148.     // so it has the following structure,
  149.     // 0000 0001 | xxxx xxxx ...
  150.     // Thus, the first 3 bits following the first byte of |vint| must be 0.
  151.     if ((vint.length == 8) && (vint[1] & 0xe0)) {
  152.       throw new shaka.util.Error(
  153.           shaka.util.Error.Severity.CRITICAL,
  154.           shaka.util.Error.Category.MEDIA,
  155.           shaka.util.Error.Code.JS_INTEGER_OVERFLOW);
  156.     }
  158.     let value = 0;
  159.     for (let i = 0; i < vint.length; i++) {
  160.       const item = vint[i];
  161.       if (i == 0) {
  162.         // Mask out the first few bits of |vint|'s first byte to get the most
  163.         // significant bits of |vint|'s value. If |vint| is 8 bytes wide then
  164.         // |value| will be set to 0.
  165.         const mask = 0x1 << (8 - vint.length);
  166.         value = item & (mask - 1);
  167.       } else {
  168.         // Note that we cannot use << since |value| may exceed 32 bits.
  169.         value = (256 * value) + item;
  170.       }
  171.     }
  173.     return value;
  174.   }
  177.   /**
  178.    * Checks if the given variable sized integer represents a dynamic size value.
  179.    * @param {!Uint8Array} vint The variable sized integer.
  180.    * @return {boolean} true if |vint| represents a dynamic size value,
  181.    *   false otherwise.
  182.    * @private
  183.    */
  184.   static isDynamicSizeValue_(vint) {
  185.     const EbmlParser = shaka.dash.EbmlParser;
  186.     const BufferUtils = shaka.util.BufferUtils;
  188.     for (const dynamicSizeConst of EbmlParser.DYNAMIC_SIZES) {
  189.       if (BufferUtils.equal(vint, new Uint8Array(dynamicSizeConst))) {
  190.         return true;
  191.       }
  192.     }
  194.     return false;
  195.   }
  196. };
  199. /**
  200.  * A list of EBML dynamic size constants.
  201.  * @const {!Array<!Array<number>>}
  202.  */
  203. shaka.dash.EbmlParser.DYNAMIC_SIZES = [
  204.   [0xff],
  205.   [0x7f, 0xff],
  206.   [0x3f, 0xff, 0xff],
  207.   [0x1f, 0xff, 0xff, 0xff],
  208.   [0x0f, 0xff, 0xff, 0xff, 0xff],
  209.   [0x07, 0xff, 0xff, 0xff, 0xff, 0xff],
  210.   [0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
  211.   [0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
  212. ];
  215. shaka.util.EbmlElement = class {
  216.   /**
  217.    * @param {number} id The ID.
  218.    * @param {!DataView} dataView The DataView.
  219.    */
  220.   constructor(id, dataView) {
  221.     /** @type {number} */
  222.     this.id = id;
  224.     /** @private {!DataView} */
  225.     this.dataView_ = dataView;
  226.   }
  229.   /**
  230.    * Gets the element's offset from the beginning of the buffer.
  231.    * @return {number}
  232.    */
  233.   getOffset() {
  234.     return this.dataView_.byteOffset;
  235.   }
  238.   /**
  239.    * Interpret the element's data as a list of sub-elements.
  240.    * @return {!shaka.dash.EbmlParser} A parser over the sub-elements.
  241.    */
  242.   createParser() {
  243.     return new shaka.dash.EbmlParser(this.dataView_);
  244.   }
  247.   /**
  248.    * Interpret the element's data as an unsigned integer.
  249.    * @return {number}
  250.    */
  251.   getUint() {
  252.     if (this.dataView_.byteLength > 8) {
  253.       throw new shaka.util.Error(
  254.           shaka.util.Error.Severity.CRITICAL,
  255.           shaka.util.Error.Category.MEDIA,
  256.           shaka.util.Error.Code.EBML_OVERFLOW);
  257.     }
  259.     // Ensure we have at most 53 meaningful bits.
  260.     if ((this.dataView_.byteLength == 8) &&
  261.         (this.dataView_.getUint8(0) & 0xe0)) {
  262.       throw new shaka.util.Error(
  263.           shaka.util.Error.Severity.CRITICAL,
  264.           shaka.util.Error.Category.MEDIA,
  265.           shaka.util.Error.Code.JS_INTEGER_OVERFLOW);
  266.     }
  268.     let value = 0;
  270.     for (let i = 0; i < this.dataView_.byteLength; i++) {
  271.       const chunk = this.dataView_.getUint8(i);
  272.       value = (256 * value) + chunk;
  273.     }
  275.     return value;
  276.   }
  279.   /**
  280.    * Interpret the element's data as a floating point number
  281.    * (32 bits or 64 bits). 80-bit floating point numbers are not supported.
  282.    * @return {number}
  283.    */
  284.   getFloat() {
  285.     if (this.dataView_.byteLength == 4) {
  286.       return this.dataView_.getFloat32(0);
  287.     } else if (this.dataView_.byteLength == 8) {
  288.       return this.dataView_.getFloat64(0);
  289.     } else {
  290.       throw new shaka.util.Error(
  291.           shaka.util.Error.Severity.CRITICAL,
  292.           shaka.util.Error.Category.MEDIA,
  293.           shaka.util.Error.Code.EBML_BAD_FLOATING_POINT_SIZE);
  294.     }
  295.   }
  296. };