Source: lib/util/mp4_generator.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.Mp4Generator');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.util.ManifestParserUtils');
  11. goog.require('shaka.util.Uint8ArrayUtils');
  14. shaka.util.Mp4Generator = class {
  15.   /**
  16.    * @param {!Array.<shaka.util.Mp4Generator.StreamInfo>} streamInfos
  17.    */
  18.   constructor(streamInfos) {
  19.     shaka.util.Mp4Generator.initStaticProperties_();
  21.     /** @private {!Array.<shaka.util.Mp4Generator.StreamInfo>} */
  22.     this.streamInfos_ = streamInfos;
  23.   }
  25.   /**
  26.    * Generate a Init Segment (MP4).
  27.    *
  28.    * @return {!Uint8Array}
  29.    */
  30.   initSegment() {
  31.     const Mp4Generator = shaka.util.Mp4Generator;
  32.     const movie = this.moov_();
  33.     const length = Mp4Generator.FTYP_.byteLength + movie.byteLength;
  34.     const result = new Uint8Array(length);
  35.     result.set(Mp4Generator.FTYP_);
  36.     result.set(movie, Mp4Generator.FTYP_.byteLength);
  37.     return result;
  38.   }
  40.   /**
  41.    * Generate a MOOV box
  42.    *
  43.    * @return {!Uint8Array}
  44.    * @private
  45.    */
  46.   moov_() {
  47.     goog.asserts.assert(this.streamInfos_.length > 0,
  48.         'StreamInfos must have elements');
  49.     const Mp4Generator = shaka.util.Mp4Generator;
  50.     const trakArrays = [];
  51.     for (const streamInfo of this.streamInfos_) {
  52.       trakArrays.push(this.trak_(streamInfo));
  53.     }
  54.     const traks = shaka.util.Uint8ArrayUtils.concat(...trakArrays);
  55.     const firstStreamInfo = this.streamInfos_[0];
  56.     return Mp4Generator.box('moov',
  57.         this.mvhd_(firstStreamInfo),
  58.         traks,
  59.         this.mvex_(),
  60.         this.pssh_(firstStreamInfo));
  61.   }
  63.   /**
  64.    * Generate a MVHD box
  65.    *
  66.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  67.    * @return {!Uint8Array}
  68.    * @private
  69.    */
  70.   mvhd_(streamInfo) {
  71.     const Mp4Generator = shaka.util.Mp4Generator;
  72.     const duration = streamInfo.duration * streamInfo.timescale;
  73.     const upperWordDuration =
  74.         Math.floor(duration / (Mp4Generator.UINT32_MAX_ + 1));
  75.     const lowerWordDuration =
  76.         Math.floor(duration % (Mp4Generator.UINT32_MAX_ + 1));
  77.     const bytes = new Uint8Array([
  78.       0x01, // version 1
  79.       0x00, 0x00, 0x00, // flags
  80.       0x00, 0x00, 0x00, 0x00,
  81.       0x00, 0x00, 0x00, 0x02, // creation_time
  82.       0x00, 0x00, 0x00, 0x00,
  83.       0x00, 0x00, 0x00, 0x03, // modification_time
  84.       ...this.breakNumberIntoBytes_(streamInfo.timescale, 4), // timescale
  85.       ...this.breakNumberIntoBytes_(upperWordDuration, 4),
  86.       ...this.breakNumberIntoBytes_(lowerWordDuration, 4), // duration
  87.       0x00, 0x01, 0x00, 0x00, // 1.0 rate
  88.       0x01, 0x00, // 1.0 volume
  89.       0x00, 0x00, // reserved
  90.       0x00, 0x00, 0x00, 0x00, // reserved
  91.       0x00, 0x00, 0x00, 0x00, // reserved
  92.       0x00, 0x01, 0x00, 0x00,
  93.       0x00, 0x00, 0x00, 0x00,
  94.       0x00, 0x00, 0x00, 0x00,
  95.       0x00, 0x00, 0x00, 0x00,
  96.       0x00, 0x01, 0x00, 0x00,
  97.       0x00, 0x00, 0x00, 0x00,
  98.       0x00, 0x00, 0x00, 0x00,
  99.       0x00, 0x00, 0x00, 0x00,
  100.       0x40, 0x00, 0x00, 0x00, // transformation: unity matrix
  101.       0x00, 0x00, 0x00, 0x00,
  102.       0x00, 0x00, 0x00, 0x00,
  103.       0x00, 0x00, 0x00, 0x00,
  104.       0x00, 0x00, 0x00, 0x00,
  105.       0x00, 0x00, 0x00, 0x00,
  106.       0x00, 0x00, 0x00, 0x00, // pre_defined
  107.       0xff, 0xff, 0xff, 0xff, // next_track_ID
  108.     ]);
  109.     return Mp4Generator.box('mvhd', bytes);
  110.   }
  112.   /**
  113.    * Generate a TRAK box
  114.    *
  115.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  116.    * @return {!Uint8Array}
  117.    * @private
  118.    */
  119.   trak_(streamInfo) {
  120.     const Mp4Generator = shaka.util.Mp4Generator;
  121.     return Mp4Generator.box('trak',
  122.         this.tkhd_(streamInfo), this.mdia_(streamInfo));
  123.   }
  125.   /**
  126.    * Generate a TKHD box
  127.    *
  128.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  129.    * @return {!Uint8Array}
  130.    * @private
  131.    */
  132.   tkhd_(streamInfo) {
  133.     const Mp4Generator = shaka.util.Mp4Generator;
  134.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  135.     const id = streamInfo.id + 1;
  136.     let width = streamInfo.stream.width || 0;
  137.     let height = streamInfo.stream.height || 0;
  138.     if (streamInfo.type == ContentType.AUDIO) {
  139.       width = 0;
  140.       height = 0;
  141.     }
  142.     const duration = streamInfo.duration * streamInfo.timescale;
  143.     const upperWordDuration =
  144.         Math.floor(duration / (Mp4Generator.UINT32_MAX_ + 1));
  145.     const lowerWordDuration =
  146.         Math.floor(duration % (Mp4Generator.UINT32_MAX_ + 1));
  147.     const bytes = new Uint8Array([
  148.       0x01, // version 1
  149.       0x00, 0x00, 0x07, // flags
  150.       0x00, 0x00, 0x00, 0x00,
  151.       0x00, 0x00, 0x00, 0x02, // creation_time
  152.       0x00, 0x00, 0x00, 0x00,
  153.       0x00, 0x00, 0x00, 0x03, // modification_time
  154.       ...this.breakNumberIntoBytes_(id, 4), // track_ID
  155.       0x00, 0x00, 0x00, 0x00, // reserved
  156.       ...this.breakNumberIntoBytes_(upperWordDuration, 4),
  157.       ...this.breakNumberIntoBytes_(lowerWordDuration, 4), // duration
  158.       0x00, 0x00, 0x00, 0x00,
  159.       0x00, 0x00, 0x00, 0x00, // reserved
  160.       0x00, 0x00, // layer
  161.       0x00, 0x00, // alternate_group
  162.       0x00, 0x00, // non-audio track volume
  163.       0x00, 0x00, // reserved
  164.       0x00, 0x01, 0x00, 0x00,
  165.       0x00, 0x00, 0x00, 0x00,
  166.       0x00, 0x00, 0x00, 0x00,
  167.       0x00, 0x00, 0x00, 0x00,
  168.       0x00, 0x01, 0x00, 0x00,
  169.       0x00, 0x00, 0x00, 0x00,
  170.       0x00, 0x00, 0x00, 0x00,
  171.       0x00, 0x00, 0x00, 0x00,
  172.       0x40, 0x00, 0x00, 0x00, // transformation: unity matrix
  173.       ...this.breakNumberIntoBytes_(width, 2),
  174.       0x00, 0x00, // width
  175.       ...this.breakNumberIntoBytes_(height, 2),
  176.       0x00, 0x00, // height
  177.     ]);
  178.     return Mp4Generator.box('tkhd', bytes);
  179.   }
  181.   /**
  182.    * Generate a MDIA box
  183.    *
  184.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  185.    * @return {!Uint8Array}
  186.    * @private
  187.    */
  188.   mdia_(streamInfo) {
  189.     const Mp4Generator = shaka.util.Mp4Generator;
  190.     return Mp4Generator.box('mdia', this.mdhd_(streamInfo),
  191.         this.hdlr_(streamInfo), this.minf_(streamInfo));
  192.   }
  194.   /**
  195.    * Generate a MDHD box
  196.    *
  197.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  198.    * @return {!Uint8Array}
  199.    * @private
  200.    */
  201.   mdhd_(streamInfo) {
  202.     const Mp4Generator = shaka.util.Mp4Generator;
  203.     const duration = streamInfo.duration * streamInfo.timescale;
  204.     const upperWordDuration =
  205.         Math.floor(duration / (Mp4Generator.UINT32_MAX_ + 1));
  206.     const lowerWordDuration =
  207.         Math.floor(duration % (Mp4Generator.UINT32_MAX_ + 1));
  208.     const language = streamInfo.stream.language;
  209.     const languageNumber = ((language.charCodeAt(0) - 0x60) << 10) |
  210.                 ((language.charCodeAt(1) - 0x60) << 5) |
  211.                 ((language.charCodeAt(2) - 0x60));
  212.     const bytes = new Uint8Array([
  213.       0x01, // version 1
  214.       0x00, 0x00, 0x00, // flags
  215.       0x00, 0x00, 0x00, 0x00,
  216.       0x00, 0x00, 0x00, 0x02, // creation_time
  217.       0x00, 0x00, 0x00, 0x00,
  218.       0x00, 0x00, 0x00, 0x03, // modification_time
  219.       ...this.breakNumberIntoBytes_(streamInfo.timescale, 4), // timescale
  220.       ...this.breakNumberIntoBytes_(upperWordDuration, 4),
  221.       ...this.breakNumberIntoBytes_(lowerWordDuration, 4), // duration
  222.       ...this.breakNumberIntoBytes_(languageNumber, 2), // language
  223.       0x00, 0x00,
  224.     ]);
  225.     return Mp4Generator.box('mdhd', bytes);
  226.   }
  228.   /**
  229.    * Generate a HDLR box
  230.    *
  231.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  232.    * @return {!Uint8Array}
  233.    * @private
  234.    */
  235.   hdlr_(streamInfo) {
  236.     const Mp4Generator = shaka.util.Mp4Generator;
  237.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  238.     let bytes = new Uint8Array([]);
  239.     switch (streamInfo.type) {
  240.       case ContentType.VIDEO:
  241.         bytes = Mp4Generator.HDLR_TYPES_.video;
  242.         break;
  243.       case ContentType.AUDIO:
  244.         bytes = Mp4Generator.HDLR_TYPES_.audio;
  245.         break;
  246.     }
  247.     return Mp4Generator.box('hdlr', bytes);
  248.   }
  250.   /**
  251.    * Generate a MINF box
  252.    *
  253.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  254.    * @return {!Uint8Array}
  255.    * @private
  256.    */
  257.   minf_(streamInfo) {
  258.     const Mp4Generator = shaka.util.Mp4Generator;
  259.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  260.     switch (streamInfo.type) {
  261.       case ContentType.VIDEO:
  262.         return Mp4Generator.box(
  263.             'minf', Mp4Generator.box('vmhd', Mp4Generator.VMHD_),
  264.             Mp4Generator.DINF_, this.stbl_(streamInfo));
  265.       case ContentType.AUDIO:
  266.         return Mp4Generator.box(
  267.             'minf', Mp4Generator.box('smhd', Mp4Generator.SMHD_),
  268.             Mp4Generator.DINF_, this.stbl_(streamInfo));
  269.     }
  270.     return new Uint8Array([]);
  271.   }
  273.   /**
  274.    * Generate a STBL box
  275.    *
  276.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  277.    * @return {!Uint8Array}
  278.    * @private
  279.    */
  280.   stbl_(streamInfo) {
  281.     const Mp4Generator = shaka.util.Mp4Generator;
  282.     return Mp4Generator.box(
  283.         'stbl',
  284.         this.stsd_(streamInfo),
  285.         Mp4Generator.box('stts', Mp4Generator.STTS_),
  286.         Mp4Generator.box('stsc', Mp4Generator.STSC_),
  287.         Mp4Generator.box('stsz', Mp4Generator.STSZ_),
  288.         Mp4Generator.box('stco', Mp4Generator.STCO_));
  289.   }
  291.   /**
  292.    * Generate a STSD box
  293.    *
  294.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  295.    * @return {!Uint8Array}
  296.    * @private
  297.    */
  298.   stsd_(streamInfo) {
  299.     const Mp4Generator = shaka.util.Mp4Generator;
  300.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  301.     let bytes = new Uint8Array([]);
  302.     switch (streamInfo.type) {
  303.       case ContentType.VIDEO:
  304.         if (streamInfo.codecs.includes('avc1')) {
  305.           bytes = this.avc1_(streamInfo);
  306.         } else if (streamInfo.codecs.includes('hvc1')) {
  307.           bytes = this.hvc1_(streamInfo);
  308.         }
  309.         break;
  310.       case ContentType.AUDIO:
  311.         if (streamInfo.codecs.includes('mp3')) {
  312.           bytes = this.mp3_(streamInfo);
  313.         } else if (streamInfo.codecs.includes('ac-3')) {
  314.           bytes = this.ac3_(streamInfo);
  315.         } else if (streamInfo.codecs.includes('ec-3')) {
  316.           bytes = this.ec3_(streamInfo);
  317.         } else if (streamInfo.codecs.includes('opus')) {
  318.           bytes = this.opus_(streamInfo);
  319.         } else {
  320.           bytes = this.mp4a_(streamInfo);
  321.         }
  322.         break;
  323.     }
  324.     return Mp4Generator.box('stsd', Mp4Generator.STSD_, bytes);
  325.   }
  327.   /**
  328.    * Generate a AVC1 box
  329.    *
  330.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  331.    * @return {!Uint8Array}
  332.    * @private
  333.    */
  334.   avc1_(streamInfo) {
  335.     const Mp4Generator = shaka.util.Mp4Generator;
  337.     const width = streamInfo.stream.width || 0;
  338.     const height = streamInfo.stream.height || 0;
  340.     let avcCBox;
  341.     if (streamInfo.videoConfig.byteLength > 0) {
  342.       avcCBox = Mp4Generator.box('avcC', streamInfo.videoConfig);
  343.     } else {
  344.       avcCBox = Mp4Generator.box('avcC', this.avcC_(streamInfo));
  345.     }
  347.     const avc1Bytes = new Uint8Array([
  348.       0x00, 0x00, 0x00,
  349.       0x00, 0x00, 0x00, // reserved
  350.       0x00, 0x01, // data_reference_index
  351.       0x00, 0x00, // pre_defined
  352.       0x00, 0x00, // reserved
  353.       0x00, 0x00, 0x00, 0x00,
  354.       0x00, 0x00, 0x00, 0x00,
  355.       0x00, 0x00, 0x00, 0x00, // pre_defined
  356.       ...this.breakNumberIntoBytes_(width, 2), // width
  357.       ...this.breakNumberIntoBytes_(height, 2), // height
  358.       0x00, 0x48, 0x00, 0x00, // horizresolution
  359.       0x00, 0x48, 0x00, 0x00, // vertresolution
  360.       0x00, 0x00, 0x00, 0x00, // reserved
  361.       0x00, 0x01, // frame_count
  362.       0x13,
  363.       0x76, 0x69, 0x64, 0x65,
  364.       0x6f, 0x6a, 0x73, 0x2d,
  365.       0x63, 0x6f, 0x6e, 0x74,
  366.       0x72, 0x69, 0x62, 0x2d,
  367.       0x68, 0x6c, 0x73, 0x00,
  368.       0x00, 0x00, 0x00, 0x00,
  369.       0x00, 0x00, 0x00, 0x00,
  370.       0x00, 0x00, 0x00, // compressorname
  371.       0x00, 0x18, // depth = 24
  372.       0x11, 0x11, // pre_defined = -1
  373.     ]);
  375.     let boxName = 'avc1';
  376.     const paspBox = this.pasp_(streamInfo);
  377.     let sinfBox = new Uint8Array([]);
  378.     if (streamInfo.encrypted) {
  379.       sinfBox = this.sinf_(streamInfo);
  380.       boxName = 'encv';
  381.     }
  382.     return Mp4Generator.box(boxName, avc1Bytes, avcCBox, paspBox, sinfBox);
  383.   }
  385.   /**
  386.    * Generate a AVCC box
  387.    *
  388.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  389.    * @return {!Uint8Array}
  390.    * @private
  391.    */
  392.   avcC_(streamInfo) {
  393.     const NALUTYPE_SPS = 7;
  394.     const NALUTYPE_PPS = 8;
  396.     // length = 7 by default (0 SPS and 0 PPS)
  397.     let avcCLength = 7;
  399.     // First get all SPS and PPS from nalus
  400.     const sps = [];
  401.     const pps = [];
  402.     let AVCProfileIndication = 0;
  403.     let AVCLevelIndication = 0;
  404.     let profileCompatibility = 0;
  405.     for (let i = 0; i < streamInfo.videoNalus.length; i++) {
  406.       const naluBytes = this.hexStringToBuffer_(streamInfo.videoNalus[i]);
  407.       const naluType = naluBytes[0] & 0x1F;
  408.       switch (naluType) {
  409.         case NALUTYPE_SPS:
  410.           sps.push(naluBytes);
  411.           // 2 = sequenceParameterSetLength field length
  412.           avcCLength += naluBytes.length + 2;
  413.           break;
  414.         case NALUTYPE_PPS:
  415.           pps.push(naluBytes);
  416.           // 2 = pictureParameterSetLength field length
  417.           avcCLength += naluBytes.length + 2;
  418.           break;
  419.         default:
  420.           break;
  421.       }
  422.     }
  423.     // Get profile and level from SPS
  424.     if (sps.length > 0) {
  425.       AVCProfileIndication = sps[0][1];
  426.       profileCompatibility = sps[0][2];
  427.       AVCLevelIndication = sps[0][3];
  428.     }
  430.     // Generate avcC buffer
  431.     const avcCBytes = new Uint8Array(avcCLength);
  432.     let i = 0;
  433.     // configurationVersion = 1
  434.     avcCBytes[i++] = 1;
  435.     avcCBytes[i++] = AVCProfileIndication;
  436.     avcCBytes[i++] = profileCompatibility;
  437.     avcCBytes[i++] = AVCLevelIndication;
  438.     // '11111' + lengthSizeMinusOne = 3
  439.     avcCBytes[i++] = 0xFF;
  440.     // '111' + numOfSequenceParameterSets
  441.     avcCBytes[i++] = 0xE0 | sps.length;
  442.     for (let n = 0; n < sps.length; n++) {
  443.       avcCBytes[i++] = (sps[n].length & 0xFF00) >> 8;
  444.       avcCBytes[i++] = (sps[n].length & 0x00FF);
  445.       avcCBytes.set(sps[n], i);
  446.       i += sps[n].length;
  447.     }
  448.     // numOfPictureParameterSets
  449.     avcCBytes[i++] = pps.length;
  450.     for (let n = 0; n < pps.length; n++) {
  451.       avcCBytes[i++] = (pps[n].length & 0xFF00) >> 8;
  452.       avcCBytes[i++] = (pps[n].length & 0x00FF);
  453.       avcCBytes.set(pps[n], i);
  454.       i += pps[n].length;
  455.     }
  456.     return avcCBytes;
  457.   }
  459.   /**
  460.    * Generate a HVC1 box
  461.    *
  462.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  463.    * @return {!Uint8Array}
  464.    * @private
  465.    */
  466.   hvc1_(streamInfo) {
  467.     const Mp4Generator = shaka.util.Mp4Generator;
  469.     const width = streamInfo.stream.width || 0;
  470.     const height = streamInfo.stream.height || 0;
  472.     let hvcCBox = new Uint8Array([]);
  473.     if (streamInfo.videoConfig.byteLength > 0) {
  474.       hvcCBox = Mp4Generator.box('hvcC', streamInfo.videoConfig);
  475.     }
  477.     const hvc1Bytes = new Uint8Array([
  478.       0x00, 0x00, 0x00,
  479.       0x00, 0x00, 0x00, // reserved
  480.       0x00, 0x01, // data_reference_index
  481.       0x00, 0x00, // pre_defined
  482.       0x00, 0x00, // reserved
  483.       0x00, 0x00, 0x00, 0x00,
  484.       0x00, 0x00, 0x00, 0x00,
  485.       0x00, 0x00, 0x00, 0x00, // pre_defined
  486.       ...this.breakNumberIntoBytes_(width, 2), // width
  487.       ...this.breakNumberIntoBytes_(height, 2), // height
  488.       0x00, 0x48, 0x00, 0x00, // horizresolution
  489.       0x00, 0x48, 0x00, 0x00, // vertresolution
  490.       0x00, 0x00, 0x00, 0x00, // reserved
  491.       0x00, 0x01, // frame_count
  492.       0x13,
  493.       0x76, 0x69, 0x64, 0x65,
  494.       0x6f, 0x6a, 0x73, 0x2d,
  495.       0x63, 0x6f, 0x6e, 0x74,
  496.       0x72, 0x69, 0x62, 0x2d,
  497.       0x68, 0x6c, 0x73, 0x00,
  498.       0x00, 0x00, 0x00, 0x00,
  499.       0x00, 0x00, 0x00, 0x00,
  500.       0x00, 0x00, 0x00, // compressorname
  501.       0x00, 0x18, // depth = 24
  502.       0x11, 0x11, // pre_defined = -1
  503.     ]);
  505.     let boxName = 'hvc1';
  506.     const paspBox = this.pasp_(streamInfo);
  507.     let sinfBox = new Uint8Array([]);
  508.     if (streamInfo.encrypted) {
  509.       sinfBox = this.sinf_(streamInfo);
  510.       boxName = 'encv';
  511.     }
  512.     return Mp4Generator.box(boxName, hvc1Bytes, hvcCBox, paspBox, sinfBox);
  513.   }
  515.   /**
  516.    * Generate a PASP box
  517.    *
  518.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  519.    * @return {!Uint8Array}
  520.    * @private
  521.    */
  522.   pasp_(streamInfo) {
  523.     if (!streamInfo.hSpacing && !streamInfo.vSpacing) {
  524.       return new Uint8Array([]);
  525.     }
  526.     const Mp4Generator = shaka.util.Mp4Generator;
  527.     const hSpacing = streamInfo.hSpacing;
  528.     const vSpacing = streamInfo.vSpacing;
  529.     const bytes = new Uint8Array([
  530.       ...this.breakNumberIntoBytes_(hSpacing, 4), // hSpacing
  531.       ...this.breakNumberIntoBytes_(vSpacing, 4), // vSpacing
  532.     ]);
  533.     return Mp4Generator.box('pasp', bytes);
  534.   }
  536.   /**
  537.    * Generate STSD bytes
  538.    *
  539.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  540.    * @return {!Uint8Array}
  541.    * @private
  542.    */
  543.   audioStsd_(streamInfo) {
  544.     const channelsCount = streamInfo.stream.channelsCount || 2;
  545.     const audioSamplingRate = streamInfo.stream.audioSamplingRate || 44100;
  546.     const bytes = new Uint8Array([
  547.       0x00, 0x00, 0x00, // reserved
  548.       0x00, 0x00, 0x00, // reserved
  549.       0x00, 0x01, // data_reference_index
  550.       0x00, 0x00, 0x00, 0x00,
  551.       0x00, 0x00, 0x00, 0x00, // reserved
  552.       0x00,
  553.       channelsCount, // channelcount
  554.       0x00, 0x10, // sampleSize:16bits
  555.       0x00, 0x00, 0x00, 0x00, // reserved2
  556.       ...this.breakNumberIntoBytes_(audioSamplingRate, 2), // Sample Rate
  557.       0x00, 0x00,
  558.     ]);
  559.     return bytes;
  560.   }
  562.   /**
  563.    * Generate a .MP3 box
  564.    *
  565.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  566.    * @return {!Uint8Array}
  567.    * @private
  568.    */
  569.   mp3_(streamInfo) {
  570.     const Mp4Generator = shaka.util.Mp4Generator;
  571.     return Mp4Generator.box('.mp3', this.audioStsd_(streamInfo));
  572.   }
  574.   /**
  575.    * Generate a AC-3 box
  576.    *
  577.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  578.    * @return {!Uint8Array}
  579.    * @private
  580.    */
  581.   ac3_(streamInfo) {
  582.     const Mp4Generator = shaka.util.Mp4Generator;
  583.     const dac3Box = Mp4Generator.box('dac3', streamInfo.audioConfig);
  585.     let boxName = 'ac-3';
  586.     let sinfBox = new Uint8Array([]);
  587.     if (streamInfo.encrypted) {
  588.       sinfBox = this.sinf_(streamInfo);
  589.       boxName = 'enca';
  590.     }
  591.     return Mp4Generator.box(boxName,
  592.         this.audioStsd_(streamInfo), dac3Box, sinfBox);
  593.   }
  595.   /**
  596.    * Generate a EC-3 box
  597.    *
  598.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  599.    * @return {!Uint8Array}
  600.    * @private
  601.    */
  602.   ec3_(streamInfo) {
  603.     const Mp4Generator = shaka.util.Mp4Generator;
  604.     const dec3Box = Mp4Generator.box('dec3', streamInfo.audioConfig);
  606.     let boxName = 'ec-3';
  607.     let sinfBox = new Uint8Array([]);
  608.     if (streamInfo.encrypted) {
  609.       sinfBox = this.sinf_(streamInfo);
  610.       boxName = 'enca';
  611.     }
  612.     return Mp4Generator.box(boxName,
  613.         this.audioStsd_(streamInfo), dec3Box, sinfBox);
  614.   }
  616.   /**
  617.    * Generate a Opus box
  618.    *
  619.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  620.    * @return {!Uint8Array}
  621.    * @private
  622.    */
  623.   opus_(streamInfo) {
  624.     const Mp4Generator = shaka.util.Mp4Generator;
  625.     const dopsBox = Mp4Generator.box('dOps', streamInfo.audioConfig);
  627.     let boxName = 'Opus';
  628.     let sinfBox = new Uint8Array([]);
  629.     if (streamInfo.encrypted) {
  630.       sinfBox = this.sinf_(streamInfo);
  631.       boxName = 'enca';
  632.     }
  633.     return Mp4Generator.box(boxName,
  634.         this.audioStsd_(streamInfo), dopsBox, sinfBox);
  635.   }
  637.   /**
  638.    * Generate a MP4A box
  639.    *
  640.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  641.    * @return {!Uint8Array}
  642.    * @private
  643.    */
  644.   mp4a_(streamInfo) {
  645.     const Mp4Generator = shaka.util.Mp4Generator;
  646.     let esdsBox;
  647.     if (streamInfo.audioConfig.byteLength > 0) {
  648.       esdsBox = Mp4Generator.box('esds', streamInfo.audioConfig);
  649.     } else {
  650.       esdsBox = Mp4Generator.box('esds', this.esds_(streamInfo));
  651.     }
  653.     let boxName = 'mp4a';
  654.     let sinfBox = new Uint8Array([]);
  655.     if (streamInfo.encrypted) {
  656.       sinfBox = this.sinf_(streamInfo);
  657.       boxName = 'enca';
  658.     }
  659.     return Mp4Generator.box(boxName,
  660.         this.audioStsd_(streamInfo), esdsBox, sinfBox);
  661.   }
  663.   /**
  664.    * Generate a ESDS box
  665.    *
  666.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  667.    * @return {!Uint8Array}
  668.    * @private
  669.    */
  670.   esds_(streamInfo) {
  671.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  673.     const id = streamInfo.id + 1;
  674.     const channelsCount = streamInfo.stream.channelsCount || 2;
  675.     const audioSamplingRate = streamInfo.stream.audioSamplingRate || 44100;
  677.     const audioCodec = shaka.util.ManifestParserUtils.guessCodecs(
  678.         ContentType.AUDIO, streamInfo.codecs.split(','));
  680.     const samplingFrequencyIndex = {
  681.       96000: 0x0,
  682.       88200: 0x1,
  683.       64000: 0x2,
  684.       48000: 0x3,
  685.       44100: 0x4,
  686.       32000: 0x5,
  687.       24000: 0x6,
  688.       22050: 0x7,
  689.       16000: 0x8,
  690.       12000: 0x9,
  691.       11025: 0xA,
  692.       8000: 0xB,
  693.       7350: 0xC,
  694.     };
  696.     let indexFreq = samplingFrequencyIndex[audioSamplingRate];
  697.     // In HE AAC Sampling frequence equals to SamplingRate * 2
  698.     if (audioCodec === 'mp4a.40.5' || audioCodec === 'mp4a.40.29') {
  699.       indexFreq = samplingFrequencyIndex[audioSamplingRate * 2];
  700.     }
  702.     const audioObjectType = parseInt(audioCodec.split('.').pop(), 10);
  704.     return new Uint8Array([
  705.       0x00, // version
  706.       0x00, 0x00, 0x00, // flags
  708.       // ES_Descriptor
  709.       0x03, // tag, ES_DescrTag
  710.       0x19, // length
  711.       ...this.breakNumberIntoBytes_(id, 2), // ES_ID
  712.       0x00, // streamDependenceFlag, URL_flag, reserved, streamPriority
  714.       // DecoderConfigDescriptor
  715.       0x04, // tag, DecoderConfigDescrTag
  716.       0x11, // length
  717.       0x40, // object type
  718.       0x15,  // streamType
  719.       0x00, 0x00, 0x00, // bufferSizeDB
  720.       0x00, 0x00, 0x00, 0x00, // maxBitrate
  721.       0x00, 0x00, 0x00, 0x00, // avgBitrate
  723.       // DecoderSpecificInfo
  724.       0x05, // tag, DecoderSpecificInfoTag
  725.       0x02, // length
  726.       // ISO/IEC 14496-3, AudioSpecificConfig
  727.       // for samplingFrequencyIndex see
  728.       // ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35
  729.       (audioObjectType << 3) | (indexFreq >>> 1),
  730.       (indexFreq << 7) | (channelsCount << 3),
  731.       0x06, 0x01, 0x02, // GASpecificConfig
  732.     ]);
  733.   }
  735.   /**
  736.    * Generate a MVEX box
  737.    *
  738.    * @return {!Uint8Array}
  739.    * @private
  740.    */
  741.   mvex_() {
  742.     const Mp4Generator = shaka.util.Mp4Generator;
  743.     const trexArrays = [];
  744.     for (const streamInfo of this.streamInfos_) {
  745.       trexArrays.push(this.trex_(streamInfo));
  746.     }
  747.     const trexs = shaka.util.Uint8ArrayUtils.concat(...trexArrays);
  748.     return Mp4Generator.box('mvex', trexs);
  749.   }
  751.   /**
  752.    * Generate a TREX box
  753.    *
  754.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  755.    * @return {!Uint8Array}
  756.    * @private
  757.    */
  758.   trex_(streamInfo) {
  759.     const Mp4Generator = shaka.util.Mp4Generator;
  760.     const id = streamInfo.id + 1;
  761.     const bytes = new Uint8Array([
  762.       0x00, // version 0
  763.       0x00, 0x00, 0x00, // flags
  764.       ...this.breakNumberIntoBytes_(id, 4), // track_ID
  765.       0x00, 0x00, 0x00, 0x01, // default_sample_description_index
  766.       0x00, 0x00, 0x00, 0x00, // default_sample_duration
  767.       0x00, 0x00, 0x00, 0x00, // default_sample_size
  768.       0x00, 0x01, 0x00, 0x01, // default_sample_flags
  769.     ]);
  770.     return Mp4Generator.box('trex', bytes);
  771.   }
  773.   /**
  774.    * Generate a PSSH box
  775.    *
  776.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  777.    * @return {!Uint8Array}
  778.    * @private
  779.    */
  780.   pssh_(streamInfo) {
  781.     const initDatas = [];
  782.     if (!streamInfo.encrypted) {
  783.       return new Uint8Array([]);
  784.     }
  786.     for (const drmInfo of streamInfo.stream.drmInfos) {
  787.       if (!drmInfo.initData) {
  788.         continue;
  789.       }
  790.       for (const initData of drmInfo.initData) {
  791.         initDatas.push(initData.initData);
  792.       }
  793.     }
  794.     const boxes = shaka.util.Uint8ArrayUtils.concat(...initDatas);
  795.     return boxes;
  796.   }
  798.   /**
  799.    * Generate a SINF box
  800.    *
  801.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  802.    * @return {!Uint8Array}
  803.    * @private
  804.    */
  805.   sinf_(streamInfo) {
  806.     const Mp4Generator = shaka.util.Mp4Generator;
  807.     return Mp4Generator.box('sinf',
  808.         this.frma_(streamInfo), this.schm_(), this.schi_(streamInfo));
  809.   }
  811.   /**
  812.    * Generate a FRMA box
  813.    *
  814.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  815.    * @return {!Uint8Array}
  816.    * @private
  817.    */
  818.   frma_(streamInfo) {
  819.     const codec = streamInfo.codecs.substring(
  820.         0, streamInfo.codecs.indexOf('.'));
  821.     const Mp4Generator = shaka.util.Mp4Generator;
  822.     const codecNumber = this.stringToCharCode_(codec);
  823.     const bytes = new Uint8Array([
  824.       ...this.breakNumberIntoBytes_(codecNumber, 4),
  825.     ]);
  826.     return Mp4Generator.box('frma', bytes);
  827.   }
  829.   /**
  830.    * Generate a SCHM box
  831.    *
  832.    * @return {!Uint8Array}
  833.    * @private
  834.    */
  835.   schm_() {
  836.     const Mp4Generator = shaka.util.Mp4Generator;
  837.     const bytes = new Uint8Array([
  838.       0x00, // version 0
  839.       0x00, 0x00, 0x00, // flags
  840.       0x63, 0x65, 0x6e, 0x63, // Scheme: cenc
  841.       0x00, 0x01, 0x00, 0x00, // Scheme version: 1.0
  842.     ]);
  843.     return Mp4Generator.box('schm', bytes);
  844.   }
  846.   /**
  847.    * Generate a SCHI box
  848.    *
  849.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  850.    * @return {!Uint8Array}
  851.    * @private
  852.    */
  853.   schi_(streamInfo) {
  854.     const Mp4Generator = shaka.util.Mp4Generator;
  855.     return Mp4Generator.box('schi', this.tenc_(streamInfo));
  856.   }
  858.   /**
  859.    * Generate a TENC box
  860.    *
  861.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  862.    * @return {!Uint8Array}
  863.    * @private
  864.    */
  865.   tenc_(streamInfo) {
  866.     // Default key ID: all zeros (dummy)
  867.     let defaultKeyId = new Uint8Array([
  868.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  869.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  870.     ]);
  871.     for (const drmInfo of streamInfo.stream.drmInfos) {
  872.       if (drmInfo && drmInfo.keyIds && drmInfo.keyIds.size) {
  873.         for (const keyId of drmInfo.keyIds) {
  874.           defaultKeyId = this.hexStringToBuffer_(keyId);
  875.         }
  876.       }
  877.     }
  879.     const Mp4Generator = shaka.util.Mp4Generator;
  880.     const bytes = new Uint8Array([
  881.       0x00, // version 0
  882.       0x00, 0x00, 0x00, // flags
  883.       0x00, 0x00, // Reserved fields
  884.       0x01, // Default protected: true
  885.       0x08, // Default per-sample IV size: 8
  886.     ]);
  887.     goog.asserts.assert(defaultKeyId, 'Default KID should be non-null');
  888.     return Mp4Generator.box('tenc', bytes, defaultKeyId);
  889.   }
  891.   /**
  892.    * Generate a Segment Data (MP4).
  893.    *
  894.    * @return {!Uint8Array}
  895.    */
  896.   segmentData() {
  897.     const segmentDataArray = [];
  898.     for (const streamInfo of this.streamInfos_) {
  899.       segmentDataArray.push(
  900.           ...[this.moof_(streamInfo), this.mdat_(streamInfo)]);
  901.     }
  902.     const result = shaka.util.Uint8ArrayUtils.concat(...segmentDataArray);
  903.     return result;
  904.   }
  906.   /**
  907.    * Generate a MOOF box
  908.    *
  909.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  910.    * @return {!Uint8Array}
  911.    * @private
  912.    */
  913.   moof_(streamInfo) {
  914.     const Mp4Generator = shaka.util.Mp4Generator;
  915.     return Mp4Generator.box('moof',
  916.         this.mfhd_(streamInfo), this.traf_(streamInfo));
  917.   }
  919.   /**
  920.    * Generate a MOOF box
  921.    *
  922.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  923.    * @return {!Uint8Array}
  924.    * @private
  925.    */
  926.   mfhd_(streamInfo) {
  927.     const Mp4Generator = shaka.util.Mp4Generator;
  928.     const sequenceNumber =
  929.         streamInfo.data ? streamInfo.data.sequenceNumber : 0;
  930.     const bytes = new Uint8Array([
  931.       0x00, // version 0
  932.       0x00, 0x00, 0x00, // flags
  933.       ...this.breakNumberIntoBytes_(sequenceNumber, 4),
  934.     ]);
  935.     return Mp4Generator.box('mfhd', bytes);
  936.   }
  938.   /**
  939.    * Generate a TRAF box
  940.    *
  941.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  942.    * @return {!Uint8Array}
  943.    * @private
  944.    */
  945.   traf_(streamInfo) {
  946.     const Mp4Generator = shaka.util.Mp4Generator;
  947.     const sampleDependencyTable = this.sdtp_(streamInfo);
  948.     const offset = sampleDependencyTable.length +
  949.           32 + // tfhd
  950.           20 + // tfdt
  951.           8 + // traf header
  952.           16 + // mfhd
  953.           8 + // moof header
  954.           8; // mdat header;
  955.     return Mp4Generator.box('traf',
  956.         this.tfhd_(streamInfo),
  957.         this.tfdt_(streamInfo),
  958.         this.trun_(streamInfo, offset),
  959.         sampleDependencyTable);
  960.   }
  962.   /**
  963.    * Generate a SDTP box
  964.    *
  965.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  966.    * @return {!Uint8Array}
  967.    * @private
  968.    */
  969.   sdtp_(streamInfo) {
  970.     const Mp4Generator = shaka.util.Mp4Generator;
  971.     const samples = streamInfo.data ? streamInfo.data.samples : [];
  972.     const bytes = new Uint8Array(4 + samples.length);
  973.     // leave the full box header (4 bytes) all zero
  974.     // write the sample table
  975.     for (let i = 0; i < samples.length; i++) {
  976.       const flags = samples[i].flags;
  977.       bytes[i + 4] = (flags.dependsOn << 4) |
  978.           (flags.isDependedOn << 2) |
  979.           flags.hasRedundancy;
  980.     }
  981.     return Mp4Generator.box('sdtp', bytes);
  982.   }
  984.   /**
  985.    * Generate a TFHD box
  986.    *
  987.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  988.    * @return {!Uint8Array}
  989.    * @private
  990.    */
  991.   tfhd_(streamInfo) {
  992.     const Mp4Generator = shaka.util.Mp4Generator;
  993.     const id = streamInfo.id + 1;
  994.     const bytes = new Uint8Array([
  995.       0x00, // version 0
  996.       0x00, 0x00, 0x3a, // flags
  997.       ...this.breakNumberIntoBytes_(id, 4), // track_ID
  998.       0x00, 0x00, 0x00, 0x01, // sample_description_index
  999.       0x00, 0x00, 0x00, 0x00, // default_sample_duration
  1000.       0x00, 0x00, 0x00, 0x00, // default_sample_size
  1001.       0x00, 0x00, 0x00, 0x00,  // default_sample_flags
  1002.     ]);
  1003.     return Mp4Generator.box('tfhd', bytes);
  1004.   }
  1006.   /**
  1007.    * Generate a TFDT box
  1008.    *
  1009.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  1010.    * @return {!Uint8Array}
  1011.    * @private
  1012.    */
  1013.   tfdt_(streamInfo) {
  1014.     const Mp4Generator = shaka.util.Mp4Generator;
  1015.     const baseMediaDecodeTime =
  1016.         streamInfo.data ? streamInfo.data.baseMediaDecodeTime : 0;
  1017.     const upperWordBaseMediaDecodeTime =
  1018.       Math.floor(baseMediaDecodeTime / (Mp4Generator.UINT32_MAX_ + 1));
  1019.     const lowerWordBaseMediaDecodeTime =
  1020.       Math.floor(baseMediaDecodeTime % (Mp4Generator.UINT32_MAX_ + 1));
  1021.     const bytes = new Uint8Array([
  1022.       0x01, // version 1
  1023.       0x00, 0x00, 0x00, // flags
  1024.       ...this.breakNumberIntoBytes_(upperWordBaseMediaDecodeTime, 4),
  1025.       ...this.breakNumberIntoBytes_(lowerWordBaseMediaDecodeTime, 4),
  1026.     ]);
  1027.     return Mp4Generator.box('tfdt', bytes);
  1028.   }
  1030.   /**
  1031.    * Generate a TRUN box
  1032.    *
  1033.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  1034.    * @param {number} offset
  1035.    * @return {!Uint8Array}
  1036.    * @private
  1037.    */
  1038.   trun_(streamInfo, offset) {
  1039.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1040.     const Mp4Generator = shaka.util.Mp4Generator;
  1042.     const samples = streamInfo.data ? streamInfo.data.samples : [];
  1043.     const samplesLength = samples.length;
  1044.     const byteslen = 12 + 16 * samplesLength;
  1045.     const bytes = new Uint8Array(byteslen);
  1046.     offset += 8 + byteslen;
  1047.     const isVideo = streamInfo.type === ContentType.VIDEO;
  1048.     bytes.set(
  1049.         [
  1050.         // version 1 for video with signed-int sample_composition_time_offset
  1051.         isVideo ? 0x01 : 0x00,
  1052.         0x00, 0x0f, 0x01, // flags
  1053.         ...this.breakNumberIntoBytes_(samplesLength, 4), // sample_count
  1054.         ...this.breakNumberIntoBytes_(offset, 4), // data_offset
  1055.         ],
  1056.         0,
  1057.     );
  1058.     for (let i = 0; i < samplesLength; i++) {
  1059.       const sample = samples[i];
  1060.       const duration = this.breakNumberIntoBytes_(sample.duration, 4);
  1061.       const size = this.breakNumberIntoBytes_(sample.size, 4);
  1062.       const flags = sample.flags;
  1063.       const cts = this.breakNumberIntoBytes_(sample.cts, 4);
  1064.       bytes.set(
  1065.           [
  1066.             ...duration, // sample_duration
  1067.             ...size, // sample_size
  1068.             (flags.isLeading << 2) | flags.dependsOn,
  1069.             (flags.isDependedOn << 6) | (flags.hasRedundancy << 4) |
  1070.               flags.isNonSync,
  1071.             flags.degradPrio & (0xf0 << 8),
  1072.             flags.degradPrio & 0x0f, // sample_flags
  1073.             ...cts, // sample_composition_time_offset
  1074.           ],
  1075.           12 + 16 * i,
  1076.       );
  1077.     }
  1078.     return Mp4Generator.box('trun', bytes);
  1079.   }
  1081.   /**
  1082.    * Generate a MDAT box
  1083.    *
  1084.    * @return {!Uint8Array}
  1085.    * @private
  1086.    */
  1087.   mdat_(streamInfo) {
  1088.     const Mp4Generator = shaka.util.Mp4Generator;
  1089.     const samples = streamInfo.data ? streamInfo.data.samples : [];
  1090.     const allData = samples.map((sample) => sample.data);
  1091.     const bytes = shaka.util.Uint8ArrayUtils.concat(...allData);
  1092.     return Mp4Generator.box('mdat', bytes);
  1093.   }
  1096.   /**
  1097.    * @param {number} number
  1098.    * @param {number} numBytes
  1099.    * @return {!Array.<number>}
  1100.    * @private
  1101.    */
  1102.   breakNumberIntoBytes_(number, numBytes) {
  1103.     const bytes = [];
  1104.     for (let byte = numBytes - 1; byte >= 0; byte--) {
  1105.       bytes.push((number >> (8 * byte)) & 0xff);
  1106.     }
  1107.     return bytes;
  1108.   }
  1110.   /**
  1111.    * Convert a hex string to buffer.
  1112.    *
  1113.    * @param {string} str
  1114.    * @return {Uint8Array}
  1115.    * @private
  1116.    */
  1117.   hexStringToBuffer_(str) {
  1118.     const buf = new Uint8Array(str.length / 2);
  1119.     for (let i = 0; i < str.length / 2; i += 1) {
  1120.       buf[i] = parseInt(String(str[i * 2] + str[i * 2 + 1]), 16);
  1121.     }
  1122.     return buf;
  1123.   }
  1125.   /**
  1126.    * Convert a string to char code.
  1127.    *
  1128.    * @param {string} str
  1129.    * @return {number}
  1130.    * @private
  1131.    */
  1132.   stringToCharCode_(str) {
  1133.     let code = 0;
  1134.     for (let i = 0; i < str.length; i += 1) {
  1135.       code |= str.charCodeAt(i) << ((str.length - i - 1) * 8);
  1136.     }
  1137.     return code;
  1138.   }
  1140.   /**
  1141.    * @private
  1142.    */
  1143.   static initStaticProperties_() {
  1144.     const Mp4Generator = shaka.util.Mp4Generator;
  1145.     if (Mp4Generator.initializated_) {
  1146.       return;
  1147.     }
  1149.     Mp4Generator.initializated_ = true;
  1151.     const majorBrand = new Uint8Array([105, 115, 111, 109]); // isom
  1152.     const avc1Brand = new Uint8Array([97, 118, 99, 49]); // avc1
  1153.     const minorVersion = new Uint8Array([0, 0, 0, 1]);
  1155.     Mp4Generator.FTYP_ = Mp4Generator.box(
  1156.         'ftyp', majorBrand, minorVersion, majorBrand, avc1Brand);
  1157.     const drefBox = Mp4Generator.box('dref', Mp4Generator.DREF_);
  1158.     Mp4Generator.DINF_ = Mp4Generator.box('dinf', drefBox);
  1159.   }
  1161.   /**
  1162.    * Generate a box
  1163.    *
  1164.    * @param {string} boxName
  1165.    * @param {...!Uint8Array} payload
  1166.    * @return {!Uint8Array}
  1167.    */
  1168.   static box(boxName, ...payload) {
  1169.     let type = shaka.util.Mp4Generator.BOX_TYPES_[boxName];
  1170.     if (!type) {
  1171.       type = [
  1172.         boxName.charCodeAt(0),
  1173.         boxName.charCodeAt(1),
  1174.         boxName.charCodeAt(2),
  1175.         boxName.charCodeAt(3),
  1176.       ];
  1177.       shaka.util.Mp4Generator.BOX_TYPES_[boxName] = type;
  1178.     }
  1179.     // make the header for the box
  1180.     let size = 8;
  1181.     // calculate the total size we need to allocate
  1182.     for (let i = payload.length - 1; i >= 0; i--) {
  1183.       size += payload[i].byteLength;
  1184.     }
  1185.     const result = new Uint8Array(size);
  1186.     result[0] = (size >> 24) & 0xff;
  1187.     result[1] = (size >> 16) & 0xff;
  1188.     result[2] = (size >> 8) & 0xff;
  1189.     result[3] = size & 0xff;
  1190.     result.set(type, 4);
  1192.     // copy the payload into the result
  1193.     for (let i = 0, pointer = 8; i < payload.length; i++) {
  1194.       // copy payload[i] array @ offset pointer
  1195.       result.set(payload[i], pointer);
  1196.       pointer += payload[i].byteLength;
  1197.     }
  1198.     return result;
  1199.   }
  1200. };
  1202. /**
  1203.  * @private {boolean}
  1204.  */
  1205. shaka.util.Mp4Generator.initializated_ = false;
  1208. /**
  1209.  * @private {number}
  1210.  */
  1211. shaka.util.Mp4Generator.UINT32_MAX_ = Math.pow(2, 32) - 1;
  1213. /**
  1214.  * @private {!Object.<string, !Array.<number>>}
  1215.  */
  1216. shaka.util.Mp4Generator.BOX_TYPES_ = {};
  1218. /**
  1219.  * @private {{video: !Uint8Array, audio: !Uint8Array}}
  1220.  */
  1221. shaka.util.Mp4Generator.HDLR_TYPES_ = {
  1222.   video: new Uint8Array([
  1223.     0x00, // version 0
  1224.     0x00, 0x00, 0x00, // flags
  1225.     0x00, 0x00, 0x00, 0x00, // pre_defined
  1226.     0x76, 0x69, 0x64, 0x65, // handler_type: 'vide'
  1227.     0x00, 0x00, 0x00, 0x00, // reserved
  1228.     0x00, 0x00, 0x00, 0x00, // reserved
  1229.     0x00, 0x00, 0x00, 0x00, // reserved
  1230.     0x56, 0x69, 0x64, 0x65,
  1231.     0x6f, 0x48, 0x61, 0x6e,
  1232.     0x64, 0x6c, 0x65, 0x72, 0x00, // name: 'VideoHandler'
  1233.   ]),
  1234.   audio: new Uint8Array([
  1235.     0x00, // version 0
  1236.     0x00, 0x00, 0x00, // flags
  1237.     0x00, 0x00, 0x00, 0x00, // pre_defined
  1238.     0x73, 0x6f, 0x75, 0x6e, // handler_type: 'soun'
  1239.     0x00, 0x00, 0x00, 0x00, // reserved
  1240.     0x00, 0x00, 0x00, 0x00, // reserved
  1241.     0x00, 0x00, 0x00, 0x00, // reserved
  1242.     0x53, 0x6f, 0x75, 0x6e,
  1243.     0x64, 0x48, 0x61, 0x6e,
  1244.     0x64, 0x6c, 0x65, 0x72, 0x00, // name: 'SoundHandler'
  1245.   ]),
  1246. };
  1248. /**
  1249.  * @private {!Uint8Array}
  1250.  */
  1251. shaka.util.Mp4Generator.STTS_ = new Uint8Array([
  1252.   0x00, // version
  1253.   0x00, 0x00, 0x00, // flags
  1254.   0x00, 0x00, 0x00, 0x00, // entry_count
  1255. ]);
  1257. /**
  1258.  * @private {!Uint8Array}
  1259.  */
  1260. shaka.util.Mp4Generator.STSC_ = new Uint8Array([
  1261.   0x00, // version
  1262.   0x00, 0x00, 0x00, // flags
  1263.   0x00, 0x00, 0x00, 0x00, // entry_count
  1264. ]);
  1266. /**
  1267.  * @private {!Uint8Array}
  1268.  */
  1269. shaka.util.Mp4Generator.STCO_ = new Uint8Array([
  1270.   0x00, // version
  1271.   0x00, 0x00, 0x00, // flags
  1272.   0x00, 0x00, 0x00, 0x00, // entry_count
  1273. ]);
  1275. /**
  1276.  * @private {!Uint8Array}
  1277.  */
  1278. shaka.util.Mp4Generator.STSZ_ = new Uint8Array([
  1279.   0x00, // version
  1280.   0x00, 0x00, 0x00, // flags
  1281.   0x00, 0x00, 0x00, 0x00, // sample_size
  1282.   0x00, 0x00, 0x00, 0x00, // sample_count
  1283. ]);
  1285. /**
  1286.  * @private {!Uint8Array}
  1287.  */
  1288. shaka.util.Mp4Generator.VMHD_ = new Uint8Array([
  1289.   0x00, // version
  1290.   0x00, 0x00, 0x01, // flags
  1291.   0x00, 0x00, // graphicsmode
  1292.   0x00, 0x00,
  1293.   0x00, 0x00,
  1294.   0x00, 0x00, // opcolor
  1295. ]);
  1297. /**
  1298.  * @private {!Uint8Array}
  1299.  */
  1300. shaka.util.Mp4Generator.SMHD_ = new Uint8Array([
  1301.   0x00, // version
  1302.   0x00, 0x00, 0x00, // flags
  1303.   0x00, 0x00, // balance, 0 means centered
  1304.   0x00, 0x00, // reserved
  1305. ]);
  1307. /**
  1308.  * @private {!Uint8Array}
  1309.  */
  1310. shaka.util.Mp4Generator.STSD_ = new Uint8Array([
  1311.   0x00, // version 0
  1312.   0x00, 0x00, 0x00, // flags
  1313.   0x00, 0x00, 0x00, 0x01, // entry_count
  1314. ]);
  1316. /**
  1317.  * @private {!Uint8Array}
  1318.  */
  1319. shaka.util.Mp4Generator.FTYP_ = new Uint8Array([]);
  1321. /**
  1322.  * @private {!Uint8Array}
  1323.  */
  1324. shaka.util.Mp4Generator.DREF_ = new Uint8Array([
  1325.   0x00, // version 0
  1326.   0x00, 0x00, 0x00, // flags
  1327.   0x00, 0x00, 0x00, 0x01, // entry_count
  1328.   0x00, 0x00, 0x00, 0x0c, // entry_size
  1329.   0x75, 0x72, 0x6c, 0x20, // 'url' type
  1330.   0x00, // version 0
  1331.   0x00, 0x00, 0x01, // entry_flags
  1332. ]);
  1334. /**
  1335.  * @private {!Uint8Array}
  1336.  */
  1337. shaka.util.Mp4Generator.DINF_ = new Uint8Array([]);
  1339. /**
  1340.  * @typedef {{
  1341.  *    id: number,
  1342.  *    type: string,
  1343.  *    codecs: string,
  1344.  *    encrypted: boolean,
  1345.  *    timescale: number,
  1346.  *    duration: number,
  1347.  *    videoNalus: !Array.<string>,
  1348.  *    audioConfig: !Uint8Array,
  1349.  *    videoConfig: !Uint8Array,
  1350.  *    hSpacing: number,
  1351.  *    vSpacing: number,
  1352.  *    data: ?shaka.util.Mp4Generator.Data,
  1353.  *    stream: !shaka.extern.Stream
  1354.  * }}
  1355.  *
  1356.  * @property {number} id
  1357.  *   A unique ID
  1358.  * @property {string} type
  1359.  *   Indicate the content type: 'video' or 'audio'.
  1360.  * @property {string} codecs
  1361.  *   <i>Defaults to '' (i.e., unknown / not needed).</i> <br>
  1362.  *   The Stream's codecs, e.g., 'avc1.4d4015' or 'vp9'<br>
  1363.  *   See {@link https://tools.ietf.org/html/rfc6381}
  1364.  * @property {boolean} encrypted
  1365.  *   Indicate if the stream is encrypted.
  1366.  * @property {number} timescale
  1367.  *   The Stream's timescale.
  1368.  * @property {number} duration
  1369.  *   The Stream's duration.
  1370.  * @property {!Array.<string>} videoNalus
  1371.  *   The stream's video nalus.
  1372.  * @property {!Uint8Array} audioConfig
  1373.  *   The stream's audio config.
  1374.  * @property {!Uint8Array} videoConfig
  1375.  *   The stream's video config.
  1376.  * @property {number} hSpacing
  1377.  *   The stream's video horizontal spacing of pixels.
  1378.  * @property {number} vSpacing
  1379.  *   The stream's video vertial spacing of pixels.
  1380.  * @property {?shaka.util.Mp4Generator.Data} data
  1381.  *   The stream's data.
  1382.  * @property {!shaka.extern.Stream} stream
  1383.  *   The Stream.
  1384.  */
  1385. shaka.util.Mp4Generator.StreamInfo;
  1387. /**
  1388.  * @typedef {{
  1389.  *    sequenceNumber: number,
  1390.  *    baseMediaDecodeTime: number,
  1391.  *    samples: !Array.<shaka.util.Mp4Generator.Mp4Sample>
  1392.  * }}
  1393.  *
  1394.  * @property {number} sequenceNumber
  1395.  *   The sequence number.
  1396.  * @property {number} baseMediaDecodeTime
  1397.  *   The base media decode time.
  1398.  * @property {!Array.<shaka.util.Mp4Generator.Mp4Sample>} samples
  1399.  *   The data samples.
  1400.  */
  1401. shaka.util.Mp4Generator.Data;
  1403. /**
  1404.  * @typedef {{
  1405.  *    data: !Uint8Array,
  1406.  *    size: number,
  1407.  *    duration: number,
  1408.  *    cts: number,
  1409.  *    flags: !shaka.util.Mp4Generator.Mp4SampleFlags
  1410.  * }}
  1411.  *
  1412.  * @property {!Uint8Array} data
  1413.  *   The sample data.
  1414.  * @property {number} size
  1415.  *   The sample size.
  1416.  * @property {number} duration
  1417.  *   The sample duration.
  1418.  * @property {number} cts
  1419.  *   The sample composition time.
  1420.  * @property {!shaka.util.Mp4Generator.Mp4SampleFlags} flags
  1421.  *   The sample flags.
  1422.  */
  1423. shaka.util.Mp4Generator.Mp4Sample;
  1425. /**
  1426.  * @typedef {{
  1427.  *    isLeading: number,
  1428.  *    isDependedOn: number,
  1429.  *    hasRedundancy: number,
  1430.  *    degradPrio: number,
  1431.  *    dependsOn: number,
  1432.  *    isNonSync: number
  1433.  * }}
  1434.  *
  1435.  * @property {number} isLeading
  1436.  * @property {number} isDependedOn
  1437.  * @property {number} hasRedundancy
  1438.  * @property {number} degradPrio
  1439.  * @property {number} dependsOn
  1440.  * @property {number} isNonSync
  1441.  */
  1442. shaka.util.Mp4Generator.Mp4SampleFlags;