Source: lib/util/mp4_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.Mp4Parser');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.DataViewReader');
  14. /**
  15.  * @export
  16.  */
  17. shaka.util.Mp4Parser = class {
  18.   /** */
  19.   constructor() {
  20.     /** @private {!Map<number, shaka.util.Mp4Parser.BoxType_>} */
  21.     this.headers_ = new Map();
  23.     /** @private {!Map<number, !shaka.util.Mp4Parser.CallbackType>} */
  24.     this.boxDefinitions_ = new Map();
  26.     /** @private {boolean} */
  27.     this.done_ = false;
  28.   }
  31.   /**
  32.    * Declare a box type as a Box.
  33.    *
  34.    * @param {string} type
  35.    * @param {!shaka.util.Mp4Parser.CallbackType} definition
  36.    * @return {!shaka.util.Mp4Parser}
  37.    * @export
  38.    */
  39.   box(type, definition) {
  40.     const typeCode = shaka.util.Mp4Parser.typeFromString_(type);
  41.     this.headers_.set(typeCode, shaka.util.Mp4Parser.BoxType_.BASIC_BOX);
  42.     this.boxDefinitions_.set(typeCode, definition);
  43.     return this;
  44.   }
  47.   /**
  48.    * Declare a box type as a Full Box.
  49.    *
  50.    * @param {string} type
  51.    * @param {!shaka.util.Mp4Parser.CallbackType} definition
  52.    * @return {!shaka.util.Mp4Parser}
  53.    * @export
  54.    */
  55.   fullBox(type, definition) {
  56.     const typeCode = shaka.util.Mp4Parser.typeFromString_(type);
  57.     this.headers_.set(typeCode, shaka.util.Mp4Parser.BoxType_.FULL_BOX);
  58.     this.boxDefinitions_.set(typeCode, definition);
  59.     return this;
  60.   }
  63.   /**
  64.    * Stop parsing.  Useful for extracting information from partial segments and
  65.    * avoiding an out-of-bounds error once you find what you are looking for.
  66.    *
  67.    * @export
  68.    */
  69.   stop() {
  70.     this.done_ = true;
  71.   }
  74.   /**
  75.    * Parse the given data using the added callbacks.
  76.    *
  77.    * @param {!BufferSource} data
  78.    * @param {boolean=} partialOkay If true, allow reading partial payloads
  79.    *   from some boxes. If the goal is a child box, we can sometimes find it
  80.    *   without enough data to find all child boxes.
  81.    * @param {boolean=} stopOnPartial If true, stop reading if an incomplete
  82.    *   box is detected.
  83.    * @export
  84.    */
  85.   parse(data, partialOkay, stopOnPartial) {
  86.     const reader = new shaka.util.DataViewReader(
  87.         data, shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
  89.     this.done_ = false;
  90.     while (reader.hasMoreData() && !this.done_) {
  91.       this.parseNext(0, reader, partialOkay, stopOnPartial);
  92.     }
  93.   }
  96.   /**
  97.    * Parse the next box on the current level.
  98.    *
  99.    * @param {number} absStart The absolute start position in the original
  100.    *   byte array.
  101.    * @param {!shaka.util.DataViewReader} reader
  102.    * @param {boolean=} partialOkay If true, allow reading partial payloads
  103.    *   from some boxes. If the goal is a child box, we can sometimes find it
  104.    *   without enough data to find all child boxes.
  105.    * @param {boolean=} stopOnPartial If true, stop reading if an incomplete
  106.    *   box is detected.
  107.    * @export
  108.    */
  109.   parseNext(absStart, reader, partialOkay, stopOnPartial) {
  110.     const start = reader.getPosition();
  112.     // size(4 bytes) + type(4 bytes) = 8 bytes
  113.     if (stopOnPartial && start + 8 > reader.getLength()) {
  114.       this.done_ = true;
  115.       return;
  116.     }
  118.     let size = reader.readUint32();
  119.     const type = reader.readUint32();
  120.     const name = shaka.util.Mp4Parser.typeToString(type);
  121.     let has64BitSize = false;
  122.     shaka.log.v2('Parsing MP4 box', name);
  124.     switch (size) {
  125.       case 0:
  126.         size = reader.getLength() - start;
  127.         break;
  128.       case 1:
  129.         if (stopOnPartial && reader.getPosition() + 8 > reader.getLength()) {
  130.           this.done_ = true;
  131.           return;
  132.         }
  133.         size = reader.readUint64();
  134.         has64BitSize = true;
  135.         break;
  136.     }
  138.     const boxDefinition = this.boxDefinitions_.get(type);
  140.     if (boxDefinition) {
  141.       let version = null;
  142.       let flags = null;
  144.       if (this.headers_.get(type) == shaka.util.Mp4Parser.BoxType_.FULL_BOX) {
  145.         if (stopOnPartial && reader.getPosition() + 4 > reader.getLength()) {
  146.           this.done_ = true;
  147.           return;
  148.         }
  149.         const versionAndFlags = reader.readUint32();
  150.         version = versionAndFlags >>> 24;
  151.         flags = versionAndFlags & 0xFFFFFF;
  152.       }
  154.       // Read the whole payload so that the current level can be safely read
  155.       // regardless of how the payload is parsed.
  156.       let end = start + size;
  157.       if (partialOkay && end > reader.getLength()) {
  158.         // For partial reads, truncate the payload if we must.
  159.         end = reader.getLength();
  160.       }
  162.       if (stopOnPartial && end > reader.getLength()) {
  163.         this.done_ = true;
  164.         return;
  165.       }
  166.       const payloadSize = end - reader.getPosition();
  167.       const payload =
  168.       (payloadSize > 0) ? reader.readBytes(payloadSize) : new Uint8Array(0);
  170.       const payloadReader = new shaka.util.DataViewReader(
  171.           payload, shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
  173.       /** @type {shaka.extern.ParsedBox} */
  174.       const box = {
  175.         name,
  176.         parser: this,
  177.         partialOkay: partialOkay || false,
  178.         version,
  179.         flags,
  180.         reader: payloadReader,
  181.         size,
  182.         start: start + absStart,
  183.         has64BitSize,
  184.       };
  186.       boxDefinition(box);
  187.     } else {
  188.       // Move the read head to be at the end of the box.
  189.       // If the box is longer than the remaining parts of the file, e.g. the
  190.       // mp4 is improperly formatted, or this was a partial range request that
  191.       // ended in the middle of a box, just skip to the end.
  192.       const skipLength = Math.min(
  193.           start + size - reader.getPosition(),
  194.           reader.getLength() - reader.getPosition());
  195.       reader.skip(skipLength);
  196.     }
  197.   }
  200.   /**
  201.    * A callback that tells the Mp4 parser to treat the body of a box as a series
  202.    * of boxes. The number of boxes is limited by the size of the parent box.
  203.    *
  204.    * @param {!shaka.extern.ParsedBox} box
  205.    * @export
  206.    */
  207.   static children(box) {
  208.     // The "reader" starts at the payload, so we need to add the header to the
  209.     // start position.  The header size varies.
  210.     const headerSize = shaka.util.Mp4Parser.headerSize(box);
  211.     while (box.reader.hasMoreData() && !box.parser.done_) {
  212.       box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
  213.     }
  214.   }
  217.   /**
  218.    * A callback that tells the Mp4 parser to treat the body of a box as a sample
  219.    * description. A sample description box has a fixed number of children. The
  220.    * number of children is represented by a 4 byte unsigned integer. Each child
  221.    * is a box.
  222.    *
  223.    * @param {!shaka.extern.ParsedBox} box
  224.    * @export
  225.    */
  226.   static sampleDescription(box) {
  227.     // The "reader" starts at the payload, so we need to add the header to the
  228.     // start position.  The header size varies.
  229.     const headerSize = shaka.util.Mp4Parser.headerSize(box);
  230.     const count = box.reader.readUint32();
  231.     for (let i = 0; i < count; i++) {
  232.       box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
  233.       if (box.parser.done_) {
  234.         break;
  235.       }
  236.     }
  237.   }
  240.   /**
  241.    * A callback that tells the Mp4 parser to treat the body of a box as a visual
  242.    * sample entry.  A visual sample entry has some fixed-sized fields
  243.    * describing the video codec parameters, followed by an arbitrary number of
  244.    * appended children.  Each child is a box.
  245.    *
  246.    * @param {!shaka.extern.ParsedBox} box
  247.    * @export
  248.    */
  249.   static visualSampleEntry(box) {
  250.     // The "reader" starts at the payload, so we need to add the header to the
  251.     // start position.  The header size varies.
  252.     const headerSize = shaka.util.Mp4Parser.headerSize(box);
  254.     // Skip 6 reserved bytes.
  255.     // Skip 2-byte data reference index.
  256.     // Skip 16 more reserved bytes.
  257.     // Skip 4 bytes for width/height.
  258.     // Skip 8 bytes for horizontal/vertical resolution.
  259.     // Skip 4 more reserved bytes (0)
  260.     // Skip 2-byte frame count.
  261.     // Skip 32-byte compressor name (length byte, then name, then 0-padding).
  262.     // Skip 2-byte depth.
  263.     // Skip 2 more reserved bytes (0xff)
  264.     // 78 bytes total.
  265.     // See also https://github.com/shaka-project/shaka-packager/blob/d5ca6e84/packager/media/formats/mp4/box_definitions.cc#L1544
  266.     box.reader.skip(78);
  268.     while (box.reader.hasMoreData() && !box.parser.done_) {
  269.       box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
  270.     }
  271.   }
  274.   /**
  275.    * A callback that tells the Mp4 parser to treat the body of a box as a audio
  276.    * sample entry.  A audio sample entry has some fixed-sized fields
  277.    * describing the audio codec parameters, followed by an arbitrary number of
  278.    * appended children.  Each child is a box.
  279.    *
  280.    * @param {!shaka.extern.ParsedBox} box
  281.    * @export
  282.    */
  283.   static audioSampleEntry(box) {
  284.     // The "reader" starts at the payload, so we need to add the header to the
  285.     // start position.  The header size varies.
  286.     const headerSize = shaka.util.Mp4Parser.headerSize(box);
  288.     // 6 bytes reserved
  289.     // 2 bytes data reference index
  290.     box.reader.skip(8);
  291.     // 2 bytes version
  292.     const version = box.reader.readUint16();
  293.     // 2 bytes revision (0, could be ignored)
  294.     // 4 bytes reserved
  295.     box.reader.skip(6);
  297.     if (version == 2) {
  298.       // 16 bytes hard-coded values with no comments
  299.       // 8 bytes sample rate
  300.       // 4 bytes channel count
  301.       // 4 bytes hard-coded values with no comments
  302.       // 4 bytes bits per sample
  303.       // 4 bytes lpcm flags
  304.       // 4 bytes sample size
  305.       // 4 bytes samples per packet
  306.       box.reader.skip(48);
  307.     } else {
  308.       // 2 bytes channel count
  309.       // 2 bytes bits per sample
  310.       // 2 bytes compression ID
  311.       // 2 bytes packet size
  312.       // 2 bytes sample rate
  313.       // 2 byte reserved
  314.       box.reader.skip(12);
  315.     }
  317.     if (version == 1) {
  318.       // 4 bytes samples per packet
  319.       // 4 bytes bytes per packet
  320.       // 4 bytes bytes per frame
  321.       // 4 bytes bytes per sample
  322.       box.reader.skip(16);
  323.     }
  325.     while (box.reader.hasMoreData() && !box.parser.done_) {
  326.       box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
  327.     }
  328.   }
  331.   /**
  332.    * Create a callback that tells the Mp4 parser to treat the body of a box as a
  333.    * binary blob and to parse the body's contents using the provided callback.
  334.    *
  335.    * @param {function(!Uint8Array)} callback
  336.    * @return {!shaka.util.Mp4Parser.CallbackType}
  337.    * @export
  338.    */
  339.   static allData(callback) {
  340.     return (box) => {
  341.       const all = box.reader.getLength() - box.reader.getPosition();
  342.       callback(box.reader.readBytes(all));
  343.     };
  344.   }
  347.   /**
  348.    * Convert an ascii string name to the integer type for a box.
  349.    *
  350.    * @param {string} name The name of the box. The name must be four
  351.    *                      characters long.
  352.    * @return {number}
  353.    * @private
  354.    */
  355.   static typeFromString_(name) {
  356.     goog.asserts.assert(
  357.         name.length == 4,
  358.         'Mp4 box names must be 4 characters long');
  360.     let code = 0;
  361.     for (const chr of name) {
  362.       code = (code << 8) | chr.charCodeAt(0);
  363.     }
  364.     return code;
  365.   }
  368.   /**
  369.    * Convert an integer type from a box into an ascii string name.
  370.    * Useful for debugging.
  371.    *
  372.    * @param {number} type The type of the box, a uint32.
  373.    * @return {string}
  374.    * @export
  375.    */
  376.   static typeToString(type) {
  377.     const name = String.fromCharCode(
  378.         (type >> 24) & 0xff,
  379.         (type >> 16) & 0xff,
  380.         (type >> 8) & 0xff,
  381.         type & 0xff);
  382.     return name;
  383.   }
  385.   /**
  386.    * Find the header size of the box.
  387.    * Useful for modifying boxes in place or finding the exact offset of a field.
  388.    *
  389.    * @param {shaka.extern.ParsedBox} box
  390.    * @return {number}
  391.    * @export
  392.    */
  393.   static headerSize(box) {
  394.     const basicHeaderSize = 8;
  395.     const _64BitFieldSize = box.has64BitSize ? 8 : 0;
  396.     const versionAndFlagsSize = box.flags != null ? 4 : 0;
  397.     return basicHeaderSize + _64BitFieldSize + versionAndFlagsSize;
  398.   }
  399. };
  402. /**
  403.  * @typedef {function(!shaka.extern.ParsedBox)}
  404.  * @exportInterface
  405.  */
  406. shaka.util.Mp4Parser.CallbackType;
  409. /**
  410.  * An enum used to track the type of box so that the correct values can be
  411.  * read from the header.
  412.  *
  413.  * @enum {number}
  414.  * @private
  415.  */
  416. shaka.util.Mp4Parser.BoxType_ = {
  417.   BASIC_BOX: 0,
  418.   FULL_BOX: 1,
  419. };