Source: lib/util/ebml_parser.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.util.EbmlElement');
  19. goog.provide('shaka.util.EbmlParser');
  21. goog.require('shaka.util.DataViewReader');
  22. goog.require('shaka.util.Error');
  23. goog.require('shaka.util.Uint8ArrayUtils');
  27. /**
  28.  * Creates an Extensible Binary Markup Language (EBML) parser.
  29.  * @param {!DataView} dataView The EBML data.
  30.  * @constructor
  31.  * @struct
  32.  */
  33. shaka.util.EbmlParser = function(dataView) {
  34.   /** @private {!DataView} */
  35.   this.dataView_ = dataView;
  37.   /** @private {!shaka.util.DataViewReader} */
  38.   this.reader_ = new shaka.util.DataViewReader(
  39.       dataView,
  40.       shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
  42.   // If not already constructed, build a list of EBML dynamic size constants.
  43.   // This is not done at load-time to avoid exceptions on unsupported browsers.
  44.   if (!shaka.util.EbmlParser.DYNAMIC_SIZES) {
  45.     shaka.util.EbmlParser.DYNAMIC_SIZES = [
  46.       new Uint8Array([0xff]),
  47.       new Uint8Array([0x7f, 0xff]),
  48.       new Uint8Array([0x3f, 0xff, 0xff]),
  49.       new Uint8Array([0x1f, 0xff, 0xff, 0xff]),
  50.       new Uint8Array([0x0f, 0xff, 0xff, 0xff, 0xff]),
  51.       new Uint8Array([0x07, 0xff, 0xff, 0xff, 0xff, 0xff]),
  52.       new Uint8Array([0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
  53.       new Uint8Array([0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
  54.     ];
  55.   }
  56. };
  59. /** @const {!Array.<!Uint8Array>} */
  60. shaka.util.EbmlParser.DYNAMIC_SIZES;
  63. /**
  64.  * @return {boolean} True if the parser has more data, false otherwise.
  65.  */
  66. shaka.util.EbmlParser.prototype.hasMoreData = function() {
  67.   return this.reader_.hasMoreData();
  68. };
  71. /**
  72.  * Parses an EBML element from the parser's current position, and advances
  73.  * the parser.
  74.  * @return {!shaka.util.EbmlElement} The EBML element.
  75.  * @throws {shaka.util.Error}
  76.  * @see http://matroska.org/technical/specs/rfc/index.html
  77.  */
  78. shaka.util.EbmlParser.prototype.parseElement = function() {
  79.   var id = this.parseId_();
  81.   // Parse the element's size.
  82.   var vint = this.parseVint_();
  83.   var size;
  84.   if (shaka.util.EbmlParser.isDynamicSizeValue_(vint)) {
  85.     // If this has an unknown size, assume that it takes up the rest of the
  86.     // data.
  87.     size = this.dataView_.byteLength - this.reader_.getPosition();
  88.   } else {
  89.     size = shaka.util.EbmlParser.getVintValue_(vint);
  90.   }
  92.   // Note that if the element's size is larger than the buffer then we are
  93.   // parsing a "partial element". This may occur if for example we are
  94.   // parsing the beginning of some WebM container data, but our buffer does
  95.   // not contain the entire WebM container data.
  96.   var elementSize =
  97.       this.reader_.getPosition() + size <= this.dataView_.byteLength ?
  98.       size :
  99.       this.dataView_.byteLength - this.reader_.getPosition();
  101.   var dataView = new DataView(
  102.       this.dataView_.buffer,
  103.       this.dataView_.byteOffset + this.reader_.getPosition(), elementSize);
  105.   this.reader_.skip(elementSize);
  107.   return new shaka.util.EbmlElement(id, dataView);
  108. };
  111. /**
  112.  * Parses an EBML ID from the parser's current position, and advances the
  113.  * parser.
  114.  * @throws {shaka.util.Error}
  115.  * @return {number} The EBML ID.
  116.  * @private
  117.  */
  118. shaka.util.EbmlParser.prototype.parseId_ = function() {
  119.   var vint = this.parseVint_();
  121.   if (vint.length > 7) {
  122.     throw new shaka.util.Error(
  123.         shaka.util.Error.Severity.CRITICAL,
  124.         shaka.util.Error.Category.MEDIA,
  125.         shaka.util.Error.Code.EBML_OVERFLOW);
  126.   }
  128.   var id = 0;
  129.   for (var i = 0; i < vint.length; i++) {
  130.     // Note that we cannot use << since |value| may exceed 32 bits.
  131.     id = (256 * id) + vint[i];
  132.   }
  134.   return id;
  135. };
  138. /**
  139.  * Parses a variable sized integer from the parser's current position, and
  140.  * advances the parser.
  141.  * For example:
  142.  *   1 byte  wide: 1xxx xxxx
  143.  *   2 bytes wide: 01xx xxxx xxxx xxxx
  144.  *   3 bytes wide: 001x xxxx xxxx xxxx xxxx xxxx
  145.  * @throws {shaka.util.Error}
  146.  * @return {!Uint8Array} The variable sized integer.
  147.  * @private
  148.  */
  149. shaka.util.EbmlParser.prototype.parseVint_ = function() {
  150.   var firstByte = this.reader_.readUint8();
  151.   var numBytes;
  153.   // Determine the byte width of the variable sized integer.
  154.   for (numBytes = 1; numBytes <= 8; numBytes++) {
  155.     var mask = 0x1 << (8 - numBytes);
  156.     if (firstByte & mask) {
  157.       break;
  158.     }
  159.   }
  161.   if (numBytes > 8) {
  162.     throw new shaka.util.Error(
  163.         shaka.util.Error.Severity.CRITICAL,
  164.         shaka.util.Error.Category.MEDIA,
  165.         shaka.util.Error.Code.EBML_OVERFLOW);
  166.   }
  168.   var vint = new Uint8Array(numBytes);
  169.   vint[0] = firstByte;
  171.   // Include the remaining bytes.
  172.   for (var i = 1; i < numBytes; i++) {
  173.     vint[i] = this.reader_.readUint8();
  174.   }
  176.   return vint;
  177. };
  180. /**
  181.  * Gets the value of a variable sized integer.
  182.  * For example, the x's below are part of the vint's value.
  183.  *    7-bit value: 1xxx xxxx
  184.  *   14-bit value: 01xx xxxx xxxx xxxx
  185.  *   21-bit value: 001x xxxx xxxx xxxx xxxx xxxx
  186.  * @param {!Uint8Array} vint The variable sized integer.
  187.  * @throws {shaka.util.Error}
  188.  * @return {number} The value of the variable sized integer.
  189.  * @private
  190.  */
  191. shaka.util.EbmlParser.getVintValue_ = function(vint) {
  192.   // If |vint| is 8 bytes wide then we must ensure that it does not have more
  193.   // than 53 meaningful bits. For example, assume |vint| is 8 bytes wide,
  194.   // so it has the following structure,
  195.   // 0000 0001 | xxxx xxxx ...
  196.   // Thus, the first 3 bits following the first byte of |vint| must be 0.
  197.   if ((vint.length == 8) && (vint[1] & 0xe0)) {
  198.     throw new shaka.util.Error(
  199.         shaka.util.Error.Severity.CRITICAL,
  200.         shaka.util.Error.Category.MEDIA,
  201.         shaka.util.Error.Code.JS_INTEGER_OVERFLOW);
  202.   }
  204.   // Mask out the first few bits of |vint|'s first byte to get the most
  205.   // significant bits of |vint|'s value. If |vint| is 8 bytes wide then |value|
  206.   // will be set to 0.
  207.   var mask = 0x1 << (8 - vint.length);
  208.   var value = vint[0] & (mask - 1);
  210.   // Add the remaining bytes.
  211.   for (var i = 1; i < vint.length; i++) {
  212.     // Note that we cannot use << since |value| may exceed 32 bits.
  213.     value = (256 * value) + vint[i];
  214.   }
  216.   return value;
  217. };
  220. /**
  221.  * Checks if the given variable sized integer represents a dynamic size value.
  222.  * @param {!Uint8Array} vint The variable sized integer.
  223.  * @return {boolean} true if |vint| represents a dynamic size value,
  224.  *   false otherwise.
  225.  * @private
  226.  */
  227. shaka.util.EbmlParser.isDynamicSizeValue_ = function(vint) {
  228.   var EbmlParser = shaka.util.EbmlParser;
  229.   var uint8ArrayEqual = shaka.util.Uint8ArrayUtils.equal;
  231.   for (var i = 0; i < EbmlParser.DYNAMIC_SIZES.length; i++) {
  232.     if (uint8ArrayEqual(vint, EbmlParser.DYNAMIC_SIZES[i])) {
  233.       return true;
  234.     }
  235.   }
  237.   return false;
  238. };
  242. /**
  243.  * Creates an EbmlElement.
  244.  * @param {number} id The ID.
  245.  * @param {!DataView} dataView The DataView.
  246.  * @constructor
  247.  */
  248. shaka.util.EbmlElement = function(id, dataView) {
  249.   /** @type {number} */
  250.   this.id = id;
  252.   /** @private {!DataView} */
  253.   this.dataView_ = dataView;
  254. };
  257. /**
  258.  * Gets the element's offset from the beginning of the buffer.
  259.  * @return {number}
  260.  */
  261. shaka.util.EbmlElement.prototype.getOffset = function() {
  262.   return this.dataView_.byteOffset;
  263. };
  266. /**
  267.  * Interpret the element's data as a list of sub-elements.
  268.  * @throws {shaka.util.Error}
  269.  * @return {!shaka.util.EbmlParser} A parser over the sub-elements.
  270.  */
  271. shaka.util.EbmlElement.prototype.createParser = function() {
  272.   return new shaka.util.EbmlParser(this.dataView_);
  273. };
  276. /**
  277.  * Interpret the element's data as an unsigned integer.
  278.  * @throws {shaka.util.Error}
  279.  * @return {number}
  280.  */
  281. shaka.util.EbmlElement.prototype.getUint = function() {
  282.   if (this.dataView_.byteLength > 8) {
  283.     throw new shaka.util.Error(
  284.         shaka.util.Error.Severity.CRITICAL,
  285.         shaka.util.Error.Category.MEDIA,
  286.         shaka.util.Error.Code.EBML_OVERFLOW);
  287.   }
  289.   // Ensure we have at most 53 meaningful bits.
  290.   if ((this.dataView_.byteLength == 8) && (this.dataView_.getUint8(0) & 0xe0)) {
  291.     throw new shaka.util.Error(
  292.         shaka.util.Error.Severity.CRITICAL,
  293.         shaka.util.Error.Category.MEDIA,
  294.         shaka.util.Error.Code.JS_INTEGER_OVERFLOW);
  295.   }
  297.   var value = 0;
  299.   for (var i = 0; i < this.dataView_.byteLength; i++) {
  300.     var chunk = this.dataView_.getUint8(i);
  301.     value = (256 * value) + chunk;
  302.   }
  304.   return value;
  305. };
  308. /**
  309.  * Interpret the element's data as a floating point number (32 bits or 64 bits).
  310.  * 80-bit floating point numbers are not supported.
  311.  * @throws {shaka.util.Error}
  312.  * @return {number}
  313.  */
  314. shaka.util.EbmlElement.prototype.getFloat = function() {
  315.   if (this.dataView_.byteLength == 4) {
  316.     return this.dataView_.getFloat32(0);
  317.   } else if (this.dataView_.byteLength == 8) {
  318.     return this.dataView_.getFloat64(0);
  319.   } else {
  320.     throw new shaka.util.Error(
  321.         shaka.util.Error.Severity.CRITICAL,
  322.         shaka.util.Error.Category.MEDIA,
  323.         shaka.util.Error.Code.EBML_BAD_FLOATING_POINT_SIZE);
  324.   }
  325. };