Source: lib/util/mp4_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.Mp4Parser');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.util.DataViewReader');
  26. /**
  27.  * Create a new MP4 Parser
  28.  * @struct
  29.  * @constructor
  30.  * @export
  31.  */
  32. shaka.util.Mp4Parser = function() {
  33.   /** @private {!Object.<number, shaka.util.Mp4Parser.BoxType_>} */
  34.   this.headers_ = [];
  36.   /** @private {!Object.<number, !shaka.util.Mp4Parser.CallbackType>} */
  37.   this.boxDefinitions_ = [];
  39.   /** @private {boolean} */
  40.   this.done_ = false;
  41. };
  44. /**
  45.  * @typedef {function(!shakaExtern.ParsedBox)}
  46.  * @exportInterface
  47.  */
  48. shaka.util.Mp4Parser.CallbackType;
  51. /**
  52.  * An enum used to track the type of box so that the correct values can be
  53.  * read from the header.
  54.  *
  55.  * @enum {number}
  56.  * @private
  57.  */
  58. shaka.util.Mp4Parser.BoxType_ = {
  59.   BASIC_BOX: 0,
  60.   FULL_BOX: 1
  61. };
  64. /**
  65.  * Declare a box type as a Box.
  66.  *
  67.  * @param {string} type
  68.  * @param {!shaka.util.Mp4Parser.CallbackType} definition
  69.  * @return {!shaka.util.Mp4Parser}
  70.  * @export
  71.  */
  72. shaka.util.Mp4Parser.prototype.box = function(type, definition) {
  73.   let typeCode = shaka.util.Mp4Parser.typeFromString_(type);
  74.   this.headers_[typeCode] = shaka.util.Mp4Parser.BoxType_.BASIC_BOX;
  75.   this.boxDefinitions_[typeCode] = definition;
  76.   return this;
  77. };
  80. /**
  81.  * Declare a box type as a Full Box.
  82.  *
  83.  * @param {string} type
  84.  * @param {!shaka.util.Mp4Parser.CallbackType} definition
  85.  * @return {!shaka.util.Mp4Parser}
  86.  * @export
  87.  */
  88. shaka.util.Mp4Parser.prototype.fullBox = function(type, definition) {
  89.   let typeCode = shaka.util.Mp4Parser.typeFromString_(type);
  90.   this.headers_[typeCode] = shaka.util.Mp4Parser.BoxType_.FULL_BOX;
  91.   this.boxDefinitions_[typeCode] = definition;
  92.   return this;
  93. };
  96. /**
  97.  * Stop parsing.  Useful for extracting information from partial segments and
  98.  * avoiding an out-of-bounds error once you find what you are looking for.
  99.  *
  100.  * @export
  101.  */
  102. shaka.util.Mp4Parser.prototype.stop = function() {
  103.   this.done_ = true;
  104. };
  107. /**
  108.  * Parse the given data using the added callbacks.
  109.  *
  110.  * @param {!BufferSource} data
  111.  * @param {boolean=} opt_partialOkay If true, allow reading partial payloads
  112.  *   from some boxes. If the goal is a child box, we can sometimes find it
  113.  *   without enough data to find all child boxes.
  114.  * @export
  115.  */
  116. shaka.util.Mp4Parser.prototype.parse = function(data, opt_partialOkay) {
  117.   let wrapped = new Uint8Array(data);
  118.   let reader = new shaka.util.DataViewReader(
  119.       new DataView(wrapped.buffer, wrapped.byteOffset, wrapped.byteLength),
  120.       shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
  122.   this.done_ = false;
  123.   while (reader.hasMoreData() && !this.done_) {
  124.     this.parseNext(0, reader, opt_partialOkay);
  125.   }
  126. };
  129. /**
  130.  * Parse the next box on the current level.
  131.  *
  132.  * @param {number} absStart The absolute start position in the original
  133.  *   byte array.
  134.  * @param {!shaka.util.DataViewReader} reader
  135.  * @param {boolean=} opt_partialOkay If true, allow reading partial payloads
  136.  *   from some boxes. If the goal is a child box, we can sometimes find it
  137.  *   without enough data to find all child boxes.
  138.  * @export
  139.  */
  140. shaka.util.Mp4Parser.prototype.parseNext =
  141.     function(absStart, reader, opt_partialOkay) {
  142.   let start = reader.getPosition();
  144.   let size = reader.readUint32();
  145.   let type = reader.readUint32();
  146.   let name = shaka.util.Mp4Parser.typeToString(type);
  147.   shaka.log.v2('Parsing MP4 box', name);
  149.   switch (size) {
  150.     case 0:
  151.       size = reader.getLength() - start;
  152.       break;
  153.     case 1:
  154.       size = reader.readUint64();
  155.       break;
  156.   }
  158.   let boxDefinition = this.boxDefinitions_[type];
  160.   if (boxDefinition) {
  161.     let version = null;
  162.     let flags = null;
  164.     if (this.headers_[type] == shaka.util.Mp4Parser.BoxType_.FULL_BOX) {
  165.       let versionAndFlags = reader.readUint32();
  166.       version = versionAndFlags >>> 24;
  167.       flags = versionAndFlags & 0xFFFFFF;
  168.     }
  170.     // Read the whole payload so that the current level can be safely read
  171.     // regardless of how the payload is parsed.
  172.     let end = start + size;
  173.     if (opt_partialOkay && end > reader.getLength()) {
  174.       // For partial reads, truncate the payload if we must.
  175.       end = reader.getLength();
  176.     }
  177.     let payloadSize = end - reader.getPosition();
  178.     let payload =
  179.         (payloadSize > 0) ? reader.readBytes(payloadSize) : new Uint8Array(0);
  181.     let payloadReader = new shaka.util.DataViewReader(
  182.         new DataView(payload.buffer, payload.byteOffset, payload.byteLength),
  183.         shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
  185.     /** @type {shakaExtern.ParsedBox} */
  186.     let box = {
  187.       parser: this,
  188.       partialOkay: opt_partialOkay || false,
  189.       version: version,
  190.       flags: flags,
  191.       reader: payloadReader,
  192.       size: size,
  193.       start: start + absStart
  194.     };
  196.     boxDefinition(box);
  197.   } else {
  198.     // Move the read head to be at the end of the box.
  199.     // If the box is longer than the remaining parts of the file, e.g. the
  200.     // mp4 is improperly formatted, or this was a partial range request that
  201.     // ended in the middle of a box, just skip to the end.
  202.     const skipLength = Math.min(
  203.         start + size - reader.getPosition(),
  204.         reader.getLength() - reader.getPosition());
  205.     reader.skip(skipLength);
  206.   }
  207. };
  210. /**
  211.  * A callback that tells the Mp4 parser to treat the body of a box as a series
  212.  * of boxes. The number of boxes is limited by the size of the parent box.
  213.  *
  214.  * @param {!shakaExtern.ParsedBox} box
  215.  * @export
  216.  */
  217. shaka.util.Mp4Parser.children = function(box) {
  218.   while (box.reader.hasMoreData() && !box.parser.done_) {
  219.     box.parser.parseNext(box.start, box.reader, box.partialOkay);
  220.   }
  221. };
  224. /**
  225.  * A callback that tells the Mp4 parser to treat the body of a box as a sample
  226.  * description. A sample description box has a fixed number of children. The
  227.  * number of children is represented by a 4 byte unsigned integer. Each child
  228.  * is a box.
  229.  *
  230.  * @param {!shakaExtern.ParsedBox} box
  231.  * @export
  232.  */
  233. shaka.util.Mp4Parser.sampleDescription = function(box) {
  234.   for (let count = box.reader.readUint32();
  235.        count > 0 && !box.parser.done_;
  236.        count -= 1) {
  237.     box.parser.parseNext(box.start, box.reader, box.partialOkay);
  238.   }
  239. };
  242. /**
  243.  * Create a callback that tells the Mp4 parser to treat the body of a box as a
  244.  * binary blob and to parse the body's contents using the provided callback.
  245.  *
  246.  * @param {function(!Uint8Array)} callback
  247.  * @return {!shaka.util.Mp4Parser.CallbackType}
  248.  * @export
  249.  */
  250. shaka.util.Mp4Parser.allData = function(callback) {
  251.   return function(box) {
  252.     let all = box.reader.getLength() - box.reader.getPosition();
  253.     callback(box.reader.readBytes(all));
  254.   };
  255. };
  258. /**
  259.  * Convert an ascii string name to the integer type for a box.
  260.  *
  261.  * @param {string} name The name of the box. The name must be four
  262.  *                      characters long.
  263.  * @return {number}
  264.  * @private
  265.  */
  266. shaka.util.Mp4Parser.typeFromString_ = function(name) {
  267.   goog.asserts.assert(
  268.       name.length == 4,
  269.       'Mp4 box names must be 4 characters long');
  271.   let code = 0;
  272.   for (let i = 0; i < name.length; i++) {
  273.     code = (code << 8) | name.charCodeAt(i);
  274.   }
  275.   return code;
  276. };
  279. /**
  280.  * Convert an integer type from a box into an ascii string name.
  281.  * Useful for debugging.
  282.  *
  283.  * @param {number} type The type of the box, a uint32.
  284.  * @return {string}
  285.  * @export
  286.  */
  287. shaka.util.Mp4Parser.typeToString = function(type) {
  288.   let name = String.fromCharCode(
  289.       (type >> 24) & 0xff,
  290.       (type >> 16) & 0xff,
  291.       (type >> 8) & 0xff,
  292.       type & 0xff);
  293.   return name;
  294. };