Source: lib/transmuxer/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.transmuxer.Mp4Generator');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.util.ManifestParserUtils');
  11. goog.require('shaka.util.Platform');
  12. goog.require('shaka.util.Uint8ArrayUtils');
  15. shaka.transmuxer.Mp4Generator = class {
  16.   /**
  17.    * @param {!Array<shaka.transmuxer.Mp4Generator.StreamInfo>} streamInfos
  18.    */
  19.   constructor(streamInfos) {
  20.     shaka.transmuxer.Mp4Generator.initStaticProperties_();
  22.     /** @private {!Array<shaka.transmuxer.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.transmuxer.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.transmuxer.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.transmuxer.Mp4Generator.StreamInfo} streamInfo
  68.    * @return {!Uint8Array}
  69.    * @private
  70.    */
  71.   mvhd_(streamInfo) {
  72.     const Mp4Generator = shaka.transmuxer.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.transmuxer.Mp4Generator.StreamInfo} streamInfo
  117.    * @return {!Uint8Array}
  118.    * @private
  119.    */
  120.   trak_(streamInfo) {
  121.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  122.     return Mp4Generator.box('trak',
  123.         this.tkhd_(streamInfo), this.mdia_(streamInfo));
  124.   }
  126.   /**
  127.    * Generate a TKHD box
  128.    *
  129.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  130.    * @return {!Uint8Array}
  131.    * @private
  132.    */
  133.   tkhd_(streamInfo) {
  134.     const Mp4Generator = shaka.transmuxer.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.transmuxer.Mp4Generator.StreamInfo} streamInfo
  186.    * @return {!Uint8Array}
  187.    * @private
  188.    */
  189.   mdia_(streamInfo) {
  190.     const Mp4Generator = shaka.transmuxer.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.transmuxer.Mp4Generator.StreamInfo} streamInfo
  199.    * @return {!Uint8Array}
  200.    * @private
  201.    */
  202.   mdhd_(streamInfo) {
  203.     const Mp4Generator = shaka.transmuxer.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.transmuxer.Mp4Generator.StreamInfo} streamInfo
  233.    * @return {!Uint8Array}
  234.    * @private
  235.    */
  236.   hdlr_(streamInfo) {
  237.     const Mp4Generator = shaka.transmuxer.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.transmuxer.Mp4Generator.StreamInfo} streamInfo
  255.    * @return {!Uint8Array}
  256.    * @private
  257.    */
  258.   minf_(streamInfo) {
  259.     const Mp4Generator = shaka.transmuxer.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.transmuxer.Mp4Generator.StreamInfo} streamInfo
  278.    * @return {!Uint8Array}
  279.    * @private
  280.    */
  281.   stbl_(streamInfo) {
  282.     const Mp4Generator = shaka.transmuxer.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.transmuxer.Mp4Generator.StreamInfo} streamInfo
  296.    * @return {!Uint8Array}
  297.    * @private
  298.    */
  299.   stsd_(streamInfo) {
  300.     const Mp4Generator = shaka.transmuxer.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.       if (shaka.util.Platform.requiresEC3InitSegments()) {
  307.         audioCodec = 'ec-3';
  308.       } else {
  309.         audioCodec = 'ac-3';
  310.       }
  311.     } else if (streamInfo.codecs.includes('ec-3')) {
  312.       audioCodec = 'ec-3';
  313.     } else if (streamInfo.codecs.includes('opus')) {
  314.       audioCodec = 'opus';
  315.     }
  316.     let bytes = new Uint8Array([]);
  317.     switch (streamInfo.type) {
  318.       case ContentType.VIDEO:
  319.         if (streamInfo.codecs.includes('avc1')) {
  320.           bytes = this.avc1_(streamInfo);
  321.         } else if (streamInfo.codecs.includes('hvc1')) {
  322.           bytes = this.hvc1_(streamInfo);
  323.         }
  324.         break;
  325.       case ContentType.AUDIO:
  326.         if (audioCodec == 'mp3') {
  327.           bytes = this.mp3_(streamInfo);
  328.         } else if (audioCodec == 'ac-3') {
  329.           bytes = this.ac3_(streamInfo);
  330.         } else if (audioCodec == 'ec-3') {
  331.           bytes = this.ec3_(streamInfo);
  332.         } else if (audioCodec == 'opus') {
  333.           bytes = this.opus_(streamInfo);
  334.         } else {
  335.           bytes = this.mp4a_(streamInfo);
  336.         }
  337.         break;
  338.     }
  339.     return Mp4Generator.box('stsd', Mp4Generator.STSD_, bytes);
  340.   }
  342.   /**
  343.    * Generate a AVC1 box
  344.    *
  345.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  346.    * @return {!Uint8Array}
  347.    * @private
  348.    */
  349.   avc1_(streamInfo) {
  350.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  352.     const width = streamInfo.stream.width || 0;
  353.     const height = streamInfo.stream.height || 0;
  355.     let avcCBox;
  356.     if (streamInfo.videoConfig.byteLength > 0) {
  357.       avcCBox = Mp4Generator.box('avcC', streamInfo.videoConfig);
  358.     } else {
  359.       avcCBox = Mp4Generator.box('avcC', this.avcC_(streamInfo));
  360.     }
  362.     const avc1Bytes = new Uint8Array([
  363.       0x00, 0x00, 0x00,
  364.       0x00, 0x00, 0x00, // reserved
  365.       0x00, 0x01, // data_reference_index
  366.       0x00, 0x00, // pre_defined
  367.       0x00, 0x00, // reserved
  368.       0x00, 0x00, 0x00, 0x00,
  369.       0x00, 0x00, 0x00, 0x00,
  370.       0x00, 0x00, 0x00, 0x00, // pre_defined
  371.       ...this.breakNumberIntoBytes_(width, 2), // width
  372.       ...this.breakNumberIntoBytes_(height, 2), // height
  373.       0x00, 0x48, 0x00, 0x00, // horizontal resolution
  374.       0x00, 0x48, 0x00, 0x00, // vertical resolution
  375.       0x00, 0x00, 0x00, 0x00, // reserved
  376.       0x00, 0x01, // frame_count
  377.       0x13,
  378.       0x76, 0x69, 0x64, 0x65,
  379.       0x6f, 0x6a, 0x73, 0x2d,
  380.       0x63, 0x6f, 0x6e, 0x74,
  381.       0x72, 0x69, 0x62, 0x2d,
  382.       0x68, 0x6c, 0x73, 0x00,
  383.       0x00, 0x00, 0x00, 0x00,
  384.       0x00, 0x00, 0x00, 0x00,
  385.       0x00, 0x00, 0x00, // compressor name
  386.       0x00, 0x18, // depth = 24
  387.       0x11, 0x11, // pre_defined = -1
  388.     ]);
  390.     let boxName = 'avc1';
  391.     const paspBox = this.pasp_(streamInfo);
  392.     let sinfBox = new Uint8Array([]);
  393.     if (streamInfo.encrypted) {
  394.       sinfBox = this.sinf_(streamInfo);
  395.       boxName = 'encv';
  396.     }
  397.     return Mp4Generator.box(boxName, avc1Bytes, avcCBox, paspBox, sinfBox);
  398.   }
  400.   /**
  401.    * Generate a AVCC box
  402.    *
  403.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  404.    * @return {!Uint8Array}
  405.    * @private
  406.    */
  407.   avcC_(streamInfo) {
  408.     const NALU_TYPE_SPS = 7;
  409.     const NALU_TYPE_PPS = 8;
  411.     // length = 7 by default (0 SPS and 0 PPS)
  412.     let avcCLength = 7;
  414.     // First get all SPS and PPS from nalus
  415.     const sps = [];
  416.     const pps = [];
  417.     let AVCProfileIndication = 0;
  418.     let AVCLevelIndication = 0;
  419.     let profileCompatibility = 0;
  420.     for (let i = 0; i < streamInfo.videoNalus.length; i++) {
  421.       const naluBytes = this.hexStringToBuffer_(streamInfo.videoNalus[i]);
  422.       const naluType = naluBytes[0] & 0x1F;
  423.       switch (naluType) {
  424.         case NALU_TYPE_SPS:
  425.           sps.push(naluBytes);
  426.           // 2 = sequenceParameterSetLength field length
  427.           avcCLength += naluBytes.length + 2;
  428.           break;
  429.         case NALU_TYPE_PPS:
  430.           pps.push(naluBytes);
  431.           // 2 = pictureParameterSetLength field length
  432.           avcCLength += naluBytes.length + 2;
  433.           break;
  434.         default:
  435.           break;
  436.       }
  437.     }
  438.     // Get profile and level from SPS
  439.     if (sps.length > 0) {
  440.       AVCProfileIndication = sps[0][1];
  441.       profileCompatibility = sps[0][2];
  442.       AVCLevelIndication = sps[0][3];
  443.     }
  445.     // Generate avcC buffer
  446.     const avcCBytes = new Uint8Array(avcCLength);
  447.     let i = 0;
  448.     // configurationVersion = 1
  449.     avcCBytes[i++] = 1;
  450.     avcCBytes[i++] = AVCProfileIndication;
  451.     avcCBytes[i++] = profileCompatibility;
  452.     avcCBytes[i++] = AVCLevelIndication;
  453.     // '11111' + lengthSizeMinusOne = 3
  454.     avcCBytes[i++] = 0xFF;
  455.     // '111' + numOfSequenceParameterSets
  456.     avcCBytes[i++] = 0xE0 | sps.length;
  457.     for (let n = 0; n < sps.length; n++) {
  458.       avcCBytes[i++] = (sps[n].length & 0xFF00) >> 8;
  459.       avcCBytes[i++] = (sps[n].length & 0x00FF);
  460.       avcCBytes.set(sps[n], i);
  461.       i += sps[n].length;
  462.     }
  463.     // numOfPictureParameterSets
  464.     avcCBytes[i++] = pps.length;
  465.     for (let n = 0; n < pps.length; n++) {
  466.       avcCBytes[i++] = (pps[n].length & 0xFF00) >> 8;
  467.       avcCBytes[i++] = (pps[n].length & 0x00FF);
  468.       avcCBytes.set(pps[n], i);
  469.       i += pps[n].length;
  470.     }
  471.     return avcCBytes;
  472.   }
  474.   /**
  475.    * Generate a HVC1 box
  476.    *
  477.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  478.    * @return {!Uint8Array}
  479.    * @private
  480.    */
  481.   hvc1_(streamInfo) {
  482.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  484.     const width = streamInfo.stream.width || 0;
  485.     const height = streamInfo.stream.height || 0;
  487.     let hvcCBox = new Uint8Array([]);
  488.     if (streamInfo.videoConfig.byteLength > 0) {
  489.       hvcCBox = Mp4Generator.box('hvcC', streamInfo.videoConfig);
  490.     }
  492.     const hvc1Bytes = new Uint8Array([
  493.       0x00, 0x00, 0x00,
  494.       0x00, 0x00, 0x00, // reserved
  495.       0x00, 0x01, // data_reference_index
  496.       0x00, 0x00, // pre_defined
  497.       0x00, 0x00, // reserved
  498.       0x00, 0x00, 0x00, 0x00,
  499.       0x00, 0x00, 0x00, 0x00,
  500.       0x00, 0x00, 0x00, 0x00, // pre_defined
  501.       ...this.breakNumberIntoBytes_(width, 2), // width
  502.       ...this.breakNumberIntoBytes_(height, 2), // height
  503.       0x00, 0x48, 0x00, 0x00, // horizontal resolution
  504.       0x00, 0x48, 0x00, 0x00, // vertical resolution
  505.       0x00, 0x00, 0x00, 0x00, // reserved
  506.       0x00, 0x01, // frame_count
  507.       0x13,
  508.       0x76, 0x69, 0x64, 0x65,
  509.       0x6f, 0x6a, 0x73, 0x2d,
  510.       0x63, 0x6f, 0x6e, 0x74,
  511.       0x72, 0x69, 0x62, 0x2d,
  512.       0x68, 0x6c, 0x73, 0x00,
  513.       0x00, 0x00, 0x00, 0x00,
  514.       0x00, 0x00, 0x00, 0x00,
  515.       0x00, 0x00, 0x00, // compressor name
  516.       0x00, 0x18, // depth = 24
  517.       0x11, 0x11, // pre_defined = -1
  518.     ]);
  520.     let boxName = 'hvc1';
  521.     const paspBox = this.pasp_(streamInfo);
  522.     let sinfBox = new Uint8Array([]);
  523.     if (streamInfo.encrypted) {
  524.       sinfBox = this.sinf_(streamInfo);
  525.       boxName = 'encv';
  526.     }
  527.     return Mp4Generator.box(boxName, hvc1Bytes, hvcCBox, paspBox, sinfBox);
  528.   }
  530.   /**
  531.    * Generate a PASP box
  532.    *
  533.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  534.    * @return {!Uint8Array}
  535.    * @private
  536.    */
  537.   pasp_(streamInfo) {
  538.     if (!streamInfo.hSpacing && !streamInfo.vSpacing) {
  539.       return new Uint8Array([]);
  540.     }
  541.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  542.     const hSpacing = streamInfo.hSpacing;
  543.     const vSpacing = streamInfo.vSpacing;
  544.     const bytes = new Uint8Array([
  545.       ...this.breakNumberIntoBytes_(hSpacing, 4), // hSpacing
  546.       ...this.breakNumberIntoBytes_(vSpacing, 4), // vSpacing
  547.     ]);
  548.     return Mp4Generator.box('pasp', bytes);
  549.   }
  551.   /**
  552.    * Generate STSD bytes
  553.    *
  554.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  555.    * @return {!Uint8Array}
  556.    * @private
  557.    */
  558.   audioStsd_(streamInfo) {
  559.     const channelsCount = streamInfo.stream.channelsCount || 2;
  560.     const audioSamplingRate = streamInfo.stream.audioSamplingRate || 44100;
  561.     const bytes = new Uint8Array([
  562.       0x00, 0x00, 0x00, // reserved
  563.       0x00, 0x00, 0x00, // reserved
  564.       0x00, 0x01, // data_reference_index
  565.       0x00, 0x00, 0x00, 0x00,
  566.       0x00, 0x00, 0x00, 0x00, // reserved
  567.       0x00,
  568.       channelsCount, // channel count
  569.       0x00, 0x10, // sampleSize:16bits
  570.       0x00, 0x00, 0x00, 0x00, // reserved2
  571.       ...this.breakNumberIntoBytes_(audioSamplingRate, 2), // Sample Rate
  572.       0x00, 0x00,
  573.     ]);
  574.     return bytes;
  575.   }
  577.   /**
  578.    * Generate a .MP3 box
  579.    *
  580.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  581.    * @return {!Uint8Array}
  582.    * @private
  583.    */
  584.   mp3_(streamInfo) {
  585.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  586.     return Mp4Generator.box('.mp3', this.audioStsd_(streamInfo));
  587.   }
  589.   /**
  590.    * Generate a AC-3 box
  591.    *
  592.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  593.    * @return {!Uint8Array}
  594.    * @private
  595.    */
  596.   ac3_(streamInfo) {
  597.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  598.     const dac3Box = Mp4Generator.box('dac3', streamInfo.audioConfig);
  600.     let boxName = 'ac-3';
  601.     let sinfBox = new Uint8Array([]);
  602.     if (streamInfo.encrypted) {
  603.       sinfBox = this.sinf_(streamInfo);
  604.       boxName = 'enca';
  605.     }
  606.     return Mp4Generator.box(boxName,
  607.         this.audioStsd_(streamInfo), dac3Box, sinfBox);
  608.   }
  610.   /**
  611.    * Generate a EC-3 box
  612.    *
  613.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  614.    * @return {!Uint8Array}
  615.    * @private
  616.    */
  617.   ec3_(streamInfo) {
  618.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  619.     const dec3Box = Mp4Generator.box('dec3', streamInfo.audioConfig);
  621.     let boxName = 'ec-3';
  622.     let sinfBox = new Uint8Array([]);
  623.     if (streamInfo.encrypted) {
  624.       sinfBox = this.sinf_(streamInfo);
  625.       boxName = 'enca';
  626.     }
  627.     return Mp4Generator.box(boxName,
  628.         this.audioStsd_(streamInfo), dec3Box, sinfBox);
  629.   }
  631.   /**
  632.    * Generate a Opus box
  633.    *
  634.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  635.    * @return {!Uint8Array}
  636.    * @private
  637.    */
  638.   opus_(streamInfo) {
  639.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  640.     const dopsBox = Mp4Generator.box('dOps', streamInfo.audioConfig);
  642.     let boxName = 'Opus';
  643.     let sinfBox = new Uint8Array([]);
  644.     if (streamInfo.encrypted) {
  645.       sinfBox = this.sinf_(streamInfo);
  646.       boxName = 'enca';
  647.     }
  648.     return Mp4Generator.box(boxName,
  649.         this.audioStsd_(streamInfo), dopsBox, sinfBox);
  650.   }
  652.   /**
  653.    * Generate a MP4A box
  654.    *
  655.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  656.    * @return {!Uint8Array}
  657.    * @private
  658.    */
  659.   mp4a_(streamInfo) {
  660.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  661.     let esdsBox;
  662.     if (streamInfo.audioConfig.byteLength > 0) {
  663.       esdsBox = Mp4Generator.box('esds', streamInfo.audioConfig);
  664.     } else {
  665.       esdsBox = Mp4Generator.box('esds', this.esds_(streamInfo));
  666.     }
  668.     let boxName = 'mp4a';
  669.     let sinfBox = new Uint8Array([]);
  670.     if (streamInfo.encrypted) {
  671.       sinfBox = this.sinf_(streamInfo);
  672.       boxName = 'enca';
  673.     }
  674.     return Mp4Generator.box(boxName,
  675.         this.audioStsd_(streamInfo), esdsBox, sinfBox);
  676.   }
  678.   /**
  679.    * Generate a ESDS box
  680.    *
  681.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  682.    * @return {!Uint8Array}
  683.    * @private
  684.    */
  685.   esds_(streamInfo) {
  686.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  688.     const id = streamInfo.id + 1;
  689.     const channelsCount = streamInfo.stream.channelsCount || 2;
  690.     const audioSamplingRate = streamInfo.stream.audioSamplingRate || 44100;
  692.     const audioCodec = shaka.util.ManifestParserUtils.guessCodecs(
  693.         ContentType.AUDIO, streamInfo.codecs.split(','));
  695.     const samplingFrequencyIndex = {
  696.       96000: 0x0,
  697.       88200: 0x1,
  698.       64000: 0x2,
  699.       48000: 0x3,
  700.       44100: 0x4,
  701.       32000: 0x5,
  702.       24000: 0x6,
  703.       22050: 0x7,
  704.       16000: 0x8,
  705.       12000: 0x9,
  706.       11025: 0xA,
  707.       8000: 0xB,
  708.       7350: 0xC,
  709.     };
  711.     let indexFreq = samplingFrequencyIndex[audioSamplingRate];
  712.     // In HE AAC Sampling frequence equals to SamplingRate * 2
  713.     if (audioCodec === 'mp4a.40.5' || audioCodec === 'mp4a.40.29') {
  714.       indexFreq = samplingFrequencyIndex[audioSamplingRate * 2];
  715.     }
  717.     const audioObjectType = parseInt(audioCodec.split('.').pop(), 10);
  719.     return new Uint8Array([
  720.       0x00, // version
  721.       0x00, 0x00, 0x00, // flags
  723.       // ES_Descriptor
  724.       0x03, // tag, ES_DescriptionTag
  725.       0x19, // length
  726.       ...this.breakNumberIntoBytes_(id, 2), // ES_ID
  727.       0x00, // streamDependenceFlag, URL_flag, reserved, streamPriority
  729.       // DecoderConfigDescriptor
  730.       0x04, // tag, DecoderConfigDescriptionTag
  731.       0x11, // length
  732.       0x40, // object type
  733.       0x15,  // streamType
  734.       0x00, 0x00, 0x00, // bufferSizeDB
  735.       0x00, 0x00, 0x00, 0x00, // maxBitrate
  736.       0x00, 0x00, 0x00, 0x00, // avgBitrate
  738.       // DecoderSpecificInfo
  739.       0x05, // tag, DecoderSpecificInfoTag
  740.       0x02, // length
  741.       // ISO/IEC 14496-3, AudioSpecificConfig
  742.       // for samplingFrequencyIndex see
  743.       // ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35
  744.       (audioObjectType << 3) | (indexFreq >>> 1),
  745.       (indexFreq << 7) | (channelsCount << 3),
  746.       0x06, 0x01, 0x02, // GASpecificConfig
  747.     ]);
  748.   }
  750.   /**
  751.    * Generate a MVEX box
  752.    *
  753.    * @return {!Uint8Array}
  754.    * @private
  755.    */
  756.   mvex_() {
  757.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  758.     const trexArrays = [];
  759.     for (const streamInfo of this.streamInfos_) {
  760.       trexArrays.push(this.trex_(streamInfo));
  761.     }
  762.     const trexs = shaka.util.Uint8ArrayUtils.concat(...trexArrays);
  763.     return Mp4Generator.box('mvex', trexs);
  764.   }
  766.   /**
  767.    * Generate a TREX box
  768.    *
  769.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  770.    * @return {!Uint8Array}
  771.    * @private
  772.    */
  773.   trex_(streamInfo) {
  774.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  775.     const id = streamInfo.id + 1;
  776.     const bytes = new Uint8Array([
  777.       0x00, // version 0
  778.       0x00, 0x00, 0x00, // flags
  779.       ...this.breakNumberIntoBytes_(id, 4), // track_ID
  780.       0x00, 0x00, 0x00, 0x01, // default_sample_description_index
  781.       0x00, 0x00, 0x00, 0x00, // default_sample_duration
  782.       0x00, 0x00, 0x00, 0x00, // default_sample_size
  783.       0x00, 0x00, 0x00, 0x00, // default_sample_flags
  784.     ]);
  785.     return Mp4Generator.box('trex', bytes);
  786.   }
  788.   /**
  789.    * Generate a PSSH box
  790.    *
  791.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  792.    * @return {!Uint8Array}
  793.    * @private
  794.    */
  795.   pssh_(streamInfo) {
  796.     const initDatas = [];
  797.     if (!streamInfo.encrypted) {
  798.       return new Uint8Array([]);
  799.     }
  801.     for (const drmInfo of streamInfo.stream.drmInfos) {
  802.       if (!drmInfo.initData) {
  803.         continue;
  804.       }
  805.       for (const initData of drmInfo.initData) {
  806.         initDatas.push(initData.initData);
  807.       }
  808.     }
  809.     const boxes = shaka.util.Uint8ArrayUtils.concat(...initDatas);
  810.     return boxes;
  811.   }
  813.   /**
  814.    * Generate a SINF box
  815.    *
  816.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  817.    * @return {!Uint8Array}
  818.    * @private
  819.    */
  820.   sinf_(streamInfo) {
  821.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  822.     return Mp4Generator.box('sinf',
  823.         this.frma_(streamInfo), this.schm_(), this.schi_(streamInfo));
  824.   }
  826.   /**
  827.    * Generate a FRMA box
  828.    *
  829.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  830.    * @return {!Uint8Array}
  831.    * @private
  832.    */
  833.   frma_(streamInfo) {
  834.     const codec = streamInfo.codecs.substring(
  835.         0, streamInfo.codecs.indexOf('.'));
  836.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  837.     const codecNumber = this.stringToCharCode_(codec);
  838.     const bytes = new Uint8Array([
  839.       ...this.breakNumberIntoBytes_(codecNumber, 4),
  840.     ]);
  841.     return Mp4Generator.box('frma', bytes);
  842.   }
  844.   /**
  845.    * Generate a SCHM box
  846.    *
  847.    * @return {!Uint8Array}
  848.    * @private
  849.    */
  850.   schm_() {
  851.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  852.     const bytes = new Uint8Array([
  853.       0x00, // version 0
  854.       0x00, 0x00, 0x00, // flags
  855.       0x63, 0x65, 0x6e, 0x63, // Scheme: cenc
  856.       0x00, 0x01, 0x00, 0x00, // Scheme version: 1.0
  857.     ]);
  858.     return Mp4Generator.box('schm', bytes);
  859.   }
  861.   /**
  862.    * Generate a SCHI box
  863.    *
  864.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  865.    * @return {!Uint8Array}
  866.    * @private
  867.    */
  868.   schi_(streamInfo) {
  869.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  870.     return Mp4Generator.box('schi', this.tenc_(streamInfo));
  871.   }
  873.   /**
  874.    * Generate a TENC box
  875.    *
  876.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  877.    * @return {!Uint8Array}
  878.    * @private
  879.    */
  880.   tenc_(streamInfo) {
  881.     // Default key ID: all zeros (dummy)
  882.     let defaultKeyId = new Uint8Array([
  883.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  884.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  885.     ]);
  886.     for (const drmInfo of streamInfo.stream.drmInfos) {
  887.       if (drmInfo && drmInfo.keyIds && drmInfo.keyIds.size) {
  888.         for (const keyId of drmInfo.keyIds) {
  889.           defaultKeyId = this.hexStringToBuffer_(keyId);
  890.         }
  891.       }
  892.     }
  894.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  895.     const bytes = new Uint8Array([
  896.       0x00, // version 0
  897.       0x00, 0x00, 0x00, // flags
  898.       0x00, 0x00, // Reserved fields
  899.       0x01, // Default protected: true
  900.       0x08, // Default per-sample IV size: 8
  901.     ]);
  902.     goog.asserts.assert(defaultKeyId, 'Default KID should be non-null');
  903.     return Mp4Generator.box('tenc', bytes, defaultKeyId);
  904.   }
  906.   /**
  907.    * Generate a Segment Data (MP4).
  908.    *
  909.    * @return {!Uint8Array}
  910.    */
  911.   segmentData() {
  912.     const segmentDataArray = [];
  913.     for (const streamInfo of this.streamInfos_) {
  914.       segmentDataArray.push(
  915.           ...[this.moof_(streamInfo), this.mdat_(streamInfo)]);
  916.     }
  917.     const result = shaka.util.Uint8ArrayUtils.concat(...segmentDataArray);
  918.     return result;
  919.   }
  921.   /**
  922.    * Generate a MOOF box
  923.    *
  924.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  925.    * @return {!Uint8Array}
  926.    * @private
  927.    */
  928.   moof_(streamInfo) {
  929.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  930.     return Mp4Generator.box('moof',
  931.         this.mfhd_(streamInfo), this.traf_(streamInfo));
  932.   }
  934.   /**
  935.    * Generate a MOOF box
  936.    *
  937.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  938.    * @return {!Uint8Array}
  939.    * @private
  940.    */
  941.   mfhd_(streamInfo) {
  942.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  943.     const sequenceNumber =
  944.         streamInfo.data ? streamInfo.data.sequenceNumber : 0;
  945.     const bytes = new Uint8Array([
  946.       0x00, // version 0
  947.       0x00, 0x00, 0x00, // flags
  948.       ...this.breakNumberIntoBytes_(sequenceNumber, 4),
  949.     ]);
  950.     return Mp4Generator.box('mfhd', bytes);
  951.   }
  953.   /**
  954.    * Generate a TRAF box
  955.    *
  956.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  957.    * @return {!Uint8Array}
  958.    * @private
  959.    */
  960.   traf_(streamInfo) {
  961.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  962.     const sampleDependencyTable = this.sdtp_(streamInfo);
  963.     const offset = sampleDependencyTable.length +
  964.           32 + // tfhd
  965.           20 + // tfdt
  966.           8 + // traf header
  967.           16 + // mfhd
  968.           8 + // moof header
  969.           8; // mdat header;
  970.     return Mp4Generator.box('traf',
  971.         this.tfhd_(streamInfo),
  972.         this.tfdt_(streamInfo),
  973.         this.trun_(streamInfo, offset),
  974.         sampleDependencyTable);
  975.   }
  977.   /**
  978.    * Generate a SDTP box
  979.    *
  980.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  981.    * @return {!Uint8Array}
  982.    * @private
  983.    */
  984.   sdtp_(streamInfo) {
  985.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  986.     const samples = streamInfo.data ? streamInfo.data.samples : [];
  987.     const bytes = new Uint8Array(4 + samples.length);
  988.     // leave the full box header (4 bytes) all zero
  989.     // write the sample table
  990.     for (let i = 0; i < samples.length; i++) {
  991.       const flags = samples[i].flags;
  992.       bytes[i + 4] = (flags.dependsOn << 4) |
  993.           (flags.isDependedOn << 2) |
  994.           flags.hasRedundancy;
  995.     }
  996.     return Mp4Generator.box('sdtp', bytes);
  997.   }
  999.   /**
  1000.    * Generate a TFHD box
  1001.    *
  1002.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  1003.    * @return {!Uint8Array}
  1004.    * @private
  1005.    */
  1006.   tfhd_(streamInfo) {
  1007.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  1008.     const id = streamInfo.id + 1;
  1009.     const bytes = new Uint8Array([
  1010.       0x00, // version 0
  1011.       0x00, 0x00, 0x3a, // flags
  1012.       ...this.breakNumberIntoBytes_(id, 4), // track_ID
  1013.       0x00, 0x00, 0x00, 0x01, // sample_description_index
  1014.       0x00, 0x00, 0x00, 0x00, // default_sample_duration
  1015.       0x00, 0x00, 0x00, 0x00, // default_sample_size
  1016.       0x00, 0x00, 0x00, 0x00,  // default_sample_flags
  1017.     ]);
  1018.     return Mp4Generator.box('tfhd', bytes);
  1019.   }
  1021.   /**
  1022.    * Generate a TFDT box
  1023.    *
  1024.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  1025.    * @return {!Uint8Array}
  1026.    * @private
  1027.    */
  1028.   tfdt_(streamInfo) {
  1029.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  1030.     const baseMediaDecodeTime =
  1031.         streamInfo.data ? streamInfo.data.baseMediaDecodeTime : 0;
  1032.     const upperWordBaseMediaDecodeTime =
  1033.       Math.floor(baseMediaDecodeTime / (Mp4Generator.UINT32_MAX_ + 1));
  1034.     const lowerWordBaseMediaDecodeTime =
  1035.       Math.floor(baseMediaDecodeTime % (Mp4Generator.UINT32_MAX_ + 1));
  1036.     const bytes = new Uint8Array([
  1037.       0x01, // version 1
  1038.       0x00, 0x00, 0x00, // flags
  1039.       ...this.breakNumberIntoBytes_(upperWordBaseMediaDecodeTime, 4),
  1040.       ...this.breakNumberIntoBytes_(lowerWordBaseMediaDecodeTime, 4),
  1041.     ]);
  1042.     return Mp4Generator.box('tfdt', bytes);
  1043.   }
  1045.   /**
  1046.    * Generate a TRUN box
  1047.    *
  1048.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  1049.    * @param {number} offset
  1050.    * @return {!Uint8Array}
  1051.    * @private
  1052.    */
  1053.   trun_(streamInfo, offset) {
  1054.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1055.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  1057.     const samples = streamInfo.data ? streamInfo.data.samples : [];
  1058.     const samplesLength = samples.length;
  1059.     const bytesLen = 12 + 16 * samplesLength;
  1060.     const bytes = new Uint8Array(bytesLen);
  1061.     offset += 8 + bytesLen;
  1062.     const isVideo = streamInfo.type === ContentType.VIDEO;
  1063.     bytes.set(
  1064.         [
  1065.         // version 1 for video with signed-int sample_composition_time_offset
  1066.         isVideo ? 0x01 : 0x00,
  1067.         0x00, 0x0f, 0x01, // flags
  1068.         ...this.breakNumberIntoBytes_(samplesLength, 4), // sample_count
  1069.         ...this.breakNumberIntoBytes_(offset, 4), // data_offset
  1070.         ],
  1071.         0,
  1072.     );
  1073.     for (let i = 0; i < samplesLength; i++) {
  1074.       const sample = samples[i];
  1075.       const duration = this.breakNumberIntoBytes_(sample.duration, 4);
  1076.       const size = this.breakNumberIntoBytes_(sample.size, 4);
  1077.       const flags = sample.flags;
  1078.       const cts = this.breakNumberIntoBytes_(sample.cts, 4);
  1079.       bytes.set(
  1080.           [
  1081.             ...duration, // sample_duration
  1082.             ...size, // sample_size
  1083.             (flags.isLeading << 2) | flags.dependsOn,
  1084.             (flags.isDependedOn << 6) | (flags.hasRedundancy << 4) |
  1085.               flags.isNonSync,
  1086.             flags.degradPrio & (0xf0 << 8),
  1087.             flags.degradPrio & 0x0f, // sample_flags
  1088.             ...cts, // sample_composition_time_offset
  1089.           ],
  1090.           12 + 16 * i,
  1091.       );
  1092.     }
  1093.     return Mp4Generator.box('trun', bytes);
  1094.   }
  1096.   /**
  1097.    * Generate a MDAT box
  1098.    *
  1099.    * @param {shaka.transmuxer.Mp4Generator.StreamInfo} streamInfo
  1100.    * @return {!Uint8Array}
  1101.    * @private
  1102.    */
  1103.   mdat_(streamInfo) {
  1104.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  1105.     const samples = streamInfo.data ? streamInfo.data.samples : [];
  1106.     const allData = samples.map((sample) => sample.data);
  1107.     const bytes = shaka.util.Uint8ArrayUtils.concat(...allData);
  1108.     return Mp4Generator.box('mdat', bytes);
  1109.   }
  1112.   /**
  1113.    * @param {number} number
  1114.    * @param {number} numBytes
  1115.    * @return {!Array<number>}
  1116.    * @private
  1117.    */
  1118.   breakNumberIntoBytes_(number, numBytes) {
  1119.     const bytes = [];
  1120.     for (let byte = numBytes - 1; byte >= 0; byte--) {
  1121.       bytes.push((number >> (8 * byte)) & 0xff);
  1122.     }
  1123.     return bytes;
  1124.   }
  1126.   /**
  1127.    * Convert a hex string to buffer.
  1128.    *
  1129.    * @param {string} str
  1130.    * @return {Uint8Array}
  1131.    * @private
  1132.    */
  1133.   hexStringToBuffer_(str) {
  1134.     const buf = new Uint8Array(str.length / 2);
  1135.     for (let i = 0; i < str.length / 2; i += 1) {
  1136.       buf[i] = parseInt(String(str[i * 2] + str[i * 2 + 1]), 16);
  1137.     }
  1138.     return buf;
  1139.   }
  1141.   /**
  1142.    * Convert a string to char code.
  1143.    *
  1144.    * @param {string} str
  1145.    * @return {number}
  1146.    * @private
  1147.    */
  1148.   stringToCharCode_(str) {
  1149.     let code = 0;
  1150.     for (let i = 0; i < str.length; i += 1) {
  1151.       code |= str.charCodeAt(i) << ((str.length - i - 1) * 8);
  1152.     }
  1153.     return code;
  1154.   }
  1156.   /**
  1157.    * @private
  1158.    */
  1159.   static initStaticProperties_() {
  1160.     const Mp4Generator = shaka.transmuxer.Mp4Generator;
  1161.     if (Mp4Generator.initialized_) {
  1162.       return;
  1163.     }
  1165.     Mp4Generator.initialized_ = true;
  1167.     const majorBrand = new Uint8Array([105, 115, 111, 109]); // isom
  1168.     const avc1Brand = new Uint8Array([97, 118, 99, 49]); // avc1
  1169.     const minorVersion = new Uint8Array([0, 0, 0, 1]);
  1171.     Mp4Generator.FTYP_ = Mp4Generator.box(
  1172.         'ftyp', majorBrand, minorVersion, majorBrand, avc1Brand);
  1173.     const drefBox = Mp4Generator.box('dref', Mp4Generator.DREF_);
  1174.     Mp4Generator.DINF_ = Mp4Generator.box('dinf', drefBox);
  1175.   }
  1177.   /**
  1178.    * Generate a box
  1179.    *
  1180.    * @param {string} boxName
  1181.    * @param {...!Uint8Array} payload
  1182.    * @return {!Uint8Array}
  1183.    */
  1184.   static box(boxName, ...payload) {
  1185.     let type = shaka.transmuxer.Mp4Generator.BOX_TYPES_.get(boxName);
  1186.     if (!type) {
  1187.       type = [
  1188.         boxName.charCodeAt(0),
  1189.         boxName.charCodeAt(1),
  1190.         boxName.charCodeAt(2),
  1191.         boxName.charCodeAt(3),
  1192.       ];
  1193.       shaka.transmuxer.Mp4Generator.BOX_TYPES_.set(boxName, type);
  1194.     }
  1195.     // make the header for the box
  1196.     let size = 8;
  1197.     // calculate the total size we need to allocate
  1198.     for (let i = payload.length - 1; i >= 0; i--) {
  1199.       size += payload[i].byteLength;
  1200.     }
  1201.     const result = new Uint8Array(size);
  1202.     result[0] = (size >> 24) & 0xff;
  1203.     result[1] = (size >> 16) & 0xff;
  1204.     result[2] = (size >> 8) & 0xff;
  1205.     result[3] = size & 0xff;
  1206.     result.set(type, 4);
  1208.     // copy the payload into the result
  1209.     for (let i = 0, pointer = 8; i < payload.length; i++) {
  1210.       // copy payload[i] array @ offset pointer
  1211.       result.set(payload[i], pointer);
  1212.       pointer += payload[i].byteLength;
  1213.     }
  1214.     return result;
  1215.   }
  1216. };
  1218. /**
  1219.  * @private {boolean}
  1220.  */
  1221. shaka.transmuxer.Mp4Generator.initialized_ = false;
  1224. /**
  1225.  * @private {number}
  1226.  */
  1227. shaka.transmuxer.Mp4Generator.UINT32_MAX_ = Math.pow(2, 32) - 1;
  1229. /**
  1230.  * @private {!Map<string, !Array<number>>}
  1231.  */
  1232. shaka.transmuxer.Mp4Generator.BOX_TYPES_ = new Map();
  1234. /**
  1235.  * @private {{video: !Uint8Array, audio: !Uint8Array}}
  1236.  */
  1237. shaka.transmuxer.Mp4Generator.HDLR_TYPES_ = {
  1238.   video: new Uint8Array([
  1239.     0x00, // version 0
  1240.     0x00, 0x00, 0x00, // flags
  1241.     0x00, 0x00, 0x00, 0x00, // pre_defined
  1242.     0x76, 0x69, 0x64, 0x65, // handler_type: 'vide'
  1243.     0x00, 0x00, 0x00, 0x00, // reserved
  1244.     0x00, 0x00, 0x00, 0x00, // reserved
  1245.     0x00, 0x00, 0x00, 0x00, // reserved
  1246.     0x56, 0x69, 0x64, 0x65,
  1247.     0x6f, 0x48, 0x61, 0x6e,
  1248.     0x64, 0x6c, 0x65, 0x72, 0x00, // name: 'VideoHandler'
  1249.   ]),
  1250.   audio: new Uint8Array([
  1251.     0x00, // version 0
  1252.     0x00, 0x00, 0x00, // flags
  1253.     0x00, 0x00, 0x00, 0x00, // pre_defined
  1254.     0x73, 0x6f, 0x75, 0x6e, // handler_type: 'soun'
  1255.     0x00, 0x00, 0x00, 0x00, // reserved
  1256.     0x00, 0x00, 0x00, 0x00, // reserved
  1257.     0x00, 0x00, 0x00, 0x00, // reserved
  1258.     0x53, 0x6f, 0x75, 0x6e,
  1259.     0x64, 0x48, 0x61, 0x6e,
  1260.     0x64, 0x6c, 0x65, 0x72, 0x00, // name: 'SoundHandler'
  1261.   ]),
  1262. };
  1264. /**
  1265.  * @private {!Uint8Array}
  1266.  */
  1267. shaka.transmuxer.Mp4Generator.STTS_ = new Uint8Array([
  1268.   0x00, // version
  1269.   0x00, 0x00, 0x00, // flags
  1270.   0x00, 0x00, 0x00, 0x00, // entry_count
  1271. ]);
  1273. /**
  1274.  * @private {!Uint8Array}
  1275.  */
  1276. shaka.transmuxer.Mp4Generator.STSC_ = 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.transmuxer.Mp4Generator.STCO_ = 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.transmuxer.Mp4Generator.STSZ_ = new Uint8Array([
  1295.   0x00, // version
  1296.   0x00, 0x00, 0x00, // flags
  1297.   0x00, 0x00, 0x00, 0x00, // sample_size
  1298.   0x00, 0x00, 0x00, 0x00, // sample_count
  1299. ]);
  1301. /**
  1302.  * @private {!Uint8Array}
  1303.  */
  1304. shaka.transmuxer.Mp4Generator.VMHD_ = new Uint8Array([
  1305.   0x00, // version
  1306.   0x00, 0x00, 0x01, // flags
  1307.   0x00, 0x00, // graphics mode
  1308.   0x00, 0x00,
  1309.   0x00, 0x00,
  1310.   0x00, 0x00, // op color
  1311. ]);
  1313. /**
  1314.  * @private {!Uint8Array}
  1315.  */
  1316. shaka.transmuxer.Mp4Generator.SMHD_ = new Uint8Array([
  1317.   0x00, // version
  1318.   0x00, 0x00, 0x00, // flags
  1319.   0x00, 0x00, // balance, 0 means centered
  1320.   0x00, 0x00, // reserved
  1321. ]);
  1323. /**
  1324.  * @private {!Uint8Array}
  1325.  */
  1326. shaka.transmuxer.Mp4Generator.STSD_ = new Uint8Array([
  1327.   0x00, // version 0
  1328.   0x00, 0x00, 0x00, // flags
  1329.   0x00, 0x00, 0x00, 0x01, // entry_count
  1330. ]);
  1332. /**
  1333.  * @private {!Uint8Array}
  1334.  */
  1335. shaka.transmuxer.Mp4Generator.FTYP_ = new Uint8Array([]);
  1337. /**
  1338.  * @private {!Uint8Array}
  1339.  */
  1340. shaka.transmuxer.Mp4Generator.DREF_ = new Uint8Array([
  1341.   0x00, // version 0
  1342.   0x00, 0x00, 0x00, // flags
  1343.   0x00, 0x00, 0x00, 0x01, // entry_count
  1344.   0x00, 0x00, 0x00, 0x0c, // entry_size
  1345.   0x75, 0x72, 0x6c, 0x20, // 'url' type
  1346.   0x00, // version 0
  1347.   0x00, 0x00, 0x01, // entry_flags
  1348. ]);
  1350. /**
  1351.  * @private {!Uint8Array}
  1352.  */
  1353. shaka.transmuxer.Mp4Generator.DINF_ = new Uint8Array([]);
  1355. /**
  1356.  * @typedef {{
  1357.  *    id: number,
  1358.  *    type: string,
  1359.  *    codecs: string,
  1360.  *    encrypted: boolean,
  1361.  *    timescale: number,
  1362.  *    duration: number,
  1363.  *    videoNalus: !Array<string>,
  1364.  *    audioConfig: !Uint8Array,
  1365.  *    videoConfig: !Uint8Array,
  1366.  *    hSpacing: number,
  1367.  *    vSpacing: number,
  1368.  *    data: ?shaka.transmuxer.Mp4Generator.Data,
  1369.  *    stream: !shaka.extern.Stream
  1370.  * }}
  1371.  *
  1372.  * @property {number} id
  1373.  *   A unique ID
  1374.  * @property {string} type
  1375.  *   Indicate the content type: 'video' or 'audio'.
  1376.  * @property {string} codecs
  1377.  *   <i>Defaults to '' (i.e., unknown / not needed).</i> <br>
  1378.  *   The Stream's codecs, e.g., 'avc1.4d4015' or 'vp9'<br>
  1379.  *   See {@link https://tools.ietf.org/html/rfc6381}
  1380.  * @property {boolean} encrypted
  1381.  *   Indicate if the stream is encrypted.
  1382.  * @property {number} timescale
  1383.  *   The Stream's timescale.
  1384.  * @property {number} duration
  1385.  *   The Stream's duration.
  1386.  * @property {!Array<string>} videoNalus
  1387.  *   The stream's video nalus.
  1388.  * @property {!Uint8Array} audioConfig
  1389.  *   The stream's audio config.
  1390.  * @property {!Uint8Array} videoConfig
  1391.  *   The stream's video config.
  1392.  * @property {number} hSpacing
  1393.  *   The stream's video horizontal spacing of pixels.
  1394.  * @property {number} vSpacing
  1395.  *   The stream's video vertical spacing of pixels.
  1396.  * @property {?shaka.transmuxer.Mp4Generator.Data} data
  1397.  *   The stream's data.
  1398.  * @property {!shaka.extern.Stream} stream
  1399.  *   The Stream.
  1400.  */
  1401. shaka.transmuxer.Mp4Generator.StreamInfo;
  1403. /**
  1404.  * @typedef {{
  1405.  *    sequenceNumber: number,
  1406.  *    baseMediaDecodeTime: number,
  1407.  *    samples: !Array<shaka.transmuxer.Mp4Generator.Mp4Sample>
  1408.  * }}
  1409.  *
  1410.  * @property {number} sequenceNumber
  1411.  *   The sequence number.
  1412.  * @property {number} baseMediaDecodeTime
  1413.  *   The base media decode time.
  1414.  * @property {!Array<shaka.transmuxer.Mp4Generator.Mp4Sample>} samples
  1415.  *   The data samples.
  1416.  */
  1417. shaka.transmuxer.Mp4Generator.Data;
  1419. /**
  1420.  * @typedef {{
  1421.  *    data: !Uint8Array,
  1422.  *    size: number,
  1423.  *    duration: number,
  1424.  *    cts: number,
  1425.  *    flags: !shaka.transmuxer.Mp4Generator.Mp4SampleFlags
  1426.  * }}
  1427.  *
  1428.  * @property {!Uint8Array} data
  1429.  *   The sample data.
  1430.  * @property {number} size
  1431.  *   The sample size.
  1432.  * @property {number} duration
  1433.  *   The sample duration.
  1434.  * @property {number} cts
  1435.  *   The sample composition time.
  1436.  * @property {!shaka.transmuxer.Mp4Generator.Mp4SampleFlags} flags
  1437.  *   The sample flags.
  1438.  */
  1439. shaka.transmuxer.Mp4Generator.Mp4Sample;
  1441. /**
  1442.  * @typedef {{
  1443.  *    isLeading: number,
  1444.  *    isDependedOn: number,
  1445.  *    hasRedundancy: number,
  1446.  *    degradPrio: number,
  1447.  *    dependsOn: number,
  1448.  *    isNonSync: number
  1449.  * }}
  1450.  *
  1451.  * @property {number} isLeading
  1452.  * @property {number} isDependedOn
  1453.  * @property {number} hasRedundancy
  1454.  * @property {number} degradPrio
  1455.  * @property {number} dependsOn
  1456.  * @property {number} isNonSync
  1457.  */
  1458. shaka.transmuxer.Mp4Generator.Mp4SampleFlags;