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