Source: lib/util/mp4_generator.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.Mp4Generator');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.util.ManifestParserUtils');
  11. goog.require('shaka.util.Platform');
  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.       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.util.Mp4Generator.StreamInfo} streamInfo
  346.    * @return {!Uint8Array}
  347.    * @private
  348.    */
  349.   avc1_(streamInfo) {
  350.     const Mp4Generator = shaka.util.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.stream, streamInfo.codecs);
  395.       boxName = 'encv';
  396.     }
  397.     return Mp4Generator.box(boxName, avc1Bytes, avcCBox, paspBox, sinfBox);
  398.   }
  400.   /**
  401.    * Generate a AVCC box
  402.    *
  403.    * @param {shaka.util.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.util.Mp4Generator.StreamInfo} streamInfo
  478.    * @return {!Uint8Array}
  479.    * @private
  480.    */
  481.   hvc1_(streamInfo) {
  482.     const Mp4Generator = shaka.util.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.stream, streamInfo.codecs);
  525.       boxName = 'encv';
  526.     }
  527.     return Mp4Generator.box(boxName, hvc1Bytes, hvcCBox, paspBox, sinfBox);
  528.   }
  530.   /**
  531.    * Generate a PASP box
  532.    *
  533.    * @param {shaka.util.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.util.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.util.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.util.Mp4Generator.StreamInfo} streamInfo
  581.    * @return {!Uint8Array}
  582.    * @private
  583.    */
  584.   mp3_(streamInfo) {
  585.     const Mp4Generator = shaka.util.Mp4Generator;
  586.     return Mp4Generator.box('.mp3', this.audioStsd_(streamInfo));
  587.   }
  589.   /**
  590.    * Generate a AC-3 box
  591.    *
  592.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  593.    * @return {!Uint8Array}
  594.    * @private
  595.    */
  596.   ac3_(streamInfo) {
  597.     const Mp4Generator = shaka.util.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.stream, streamInfo.codecs);
  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.util.Mp4Generator.StreamInfo} streamInfo
  614.    * @return {!Uint8Array}
  615.    * @private
  616.    */
  617.   ec3_(streamInfo) {
  618.     const Mp4Generator = shaka.util.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.stream, streamInfo.codecs);
  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.util.Mp4Generator.StreamInfo} streamInfo
  635.    * @return {!Uint8Array}
  636.    * @private
  637.    */
  638.   opus_(streamInfo) {
  639.     const Mp4Generator = shaka.util.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.stream, streamInfo.codecs);
  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.util.Mp4Generator.StreamInfo} streamInfo
  656.    * @return {!Uint8Array}
  657.    * @private
  658.    */
  659.   mp4a_(streamInfo) {
  660.     const Mp4Generator = shaka.util.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.stream, streamInfo.codecs);
  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.util.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.util.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.util.Mp4Generator.StreamInfo} streamInfo
  770.    * @return {!Uint8Array}
  771.    * @private
  772.    */
  773.   trex_(streamInfo) {
  774.     const Mp4Generator = shaka.util.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.util.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.extern.Stream} stream
  817.    * @param {string} codecs
  818.    * @return {!Uint8Array}
  819.    */
  820.   sinf(stream, codecs) {
  821.     const Mp4Generator = shaka.util.Mp4Generator;
  822.     return Mp4Generator.box('sinf',
  823.         this.frma_(codecs),
  824.         this.schm_(stream),
  825.         this.schi_(stream));
  826.   }
  828.   /**
  829.    * Generate a FRMA box
  830.    *
  831.    * @param {string} codecs
  832.    * @return {!Uint8Array}
  833.    * @private
  834.    */
  835.   frma_(codecs) {
  836.     const codec = codecs.split('.')[0];
  837.     const Mp4Generator = shaka.util.Mp4Generator;
  838.     const codecNumber = this.stringToCharCode_(codec);
  839.     const bytes = new Uint8Array([
  840.       ...this.breakNumberIntoBytes_(codecNumber, 4),
  841.     ]);
  842.     return Mp4Generator.box('frma', bytes);
  843.   }
  845.   /**
  846.    * Generate a SCHM box
  847.    *
  848.    * @param {!shaka.extern.Stream} stream
  849.    * @return {!Uint8Array}
  850.    * @private
  851.    */
  852.   schm_(stream) {
  853.     let encryptionScheme = 'cenc';
  854.     const drmInfo = stream.drmInfos[0];
  855.     if (drmInfo && drmInfo.encryptionScheme) {
  856.       encryptionScheme = drmInfo.encryptionScheme;
  857.     }
  858.     const Mp4Generator = shaka.util.Mp4Generator;
  859.     const schemeNumber = this.stringToCharCode_(encryptionScheme);
  860.     const bytes = new Uint8Array([
  861.       0x00, // version 0
  862.       0x00, 0x00, 0x00, // flags
  863.       ...this.breakNumberIntoBytes_(schemeNumber, 4), // Scheme
  864.       0x00, 0x01, 0x00, 0x00, // Scheme version: 1.0
  865.     ]);
  866.     return Mp4Generator.box('schm', bytes);
  867.   }
  869.   /**
  870.    * Generate a SCHI box
  871.    *
  872.    * @param {!shaka.extern.Stream} stream
  873.    * @return {!Uint8Array}
  874.    * @private
  875.    */
  876.   schi_(stream) {
  877.     const Mp4Generator = shaka.util.Mp4Generator;
  878.     return Mp4Generator.box('schi', this.tenc_(stream));
  879.   }
  881.   /**
  882.    * Generate a TENC box
  883.    *
  884.    * @param {!shaka.extern.Stream} stream
  885.    * @return {!Uint8Array}
  886.    * @private
  887.    */
  888.   tenc_(stream) {
  889.     // Default key ID: all zeros (dummy)
  890.     let defaultKeyId = new Uint8Array([
  891.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  892.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  893.     ]);
  894.     for (const drmInfo of stream.drmInfos) {
  895.       if (drmInfo && drmInfo.keyIds && drmInfo.keyIds.size) {
  896.         for (const keyId of drmInfo.keyIds) {
  897.           defaultKeyId = this.hexStringToBuffer_(keyId);
  898.         }
  899.       }
  900.     }
  902.     const Mp4Generator = shaka.util.Mp4Generator;
  903.     const bytes = new Uint8Array([
  904.       0x00, // version 0
  905.       0x00, 0x00, 0x00, // flags
  906.       0x00, 0x00, // Reserved fields
  907.       0x01, // Default protected: true
  908.       0x08, // Default per-sample IV size: 8
  909.     ]);
  910.     goog.asserts.assert(defaultKeyId, 'Default KID should be non-null');
  911.     return Mp4Generator.box('tenc', bytes, defaultKeyId);
  912.   }
  914.   /**
  915.    * Generate a Segment Data (MP4).
  916.    *
  917.    * @return {!Uint8Array}
  918.    */
  919.   segmentData() {
  920.     const segmentDataArray = [];
  921.     for (const streamInfo of this.streamInfos_) {
  922.       segmentDataArray.push(
  923.           ...[this.moof_(streamInfo), this.mdat_(streamInfo)]);
  924.     }
  925.     const result = shaka.util.Uint8ArrayUtils.concat(...segmentDataArray);
  926.     return result;
  927.   }
  929.   /**
  930.    * Generate a MOOF box
  931.    *
  932.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  933.    * @return {!Uint8Array}
  934.    * @private
  935.    */
  936.   moof_(streamInfo) {
  937.     const Mp4Generator = shaka.util.Mp4Generator;
  938.     return Mp4Generator.box('moof',
  939.         this.mfhd_(streamInfo), this.traf_(streamInfo));
  940.   }
  942.   /**
  943.    * Generate a MOOF box
  944.    *
  945.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  946.    * @return {!Uint8Array}
  947.    * @private
  948.    */
  949.   mfhd_(streamInfo) {
  950.     const Mp4Generator = shaka.util.Mp4Generator;
  951.     const sequenceNumber =
  952.         streamInfo.data ? streamInfo.data.sequenceNumber : 0;
  953.     const bytes = new Uint8Array([
  954.       0x00, // version 0
  955.       0x00, 0x00, 0x00, // flags
  956.       ...this.breakNumberIntoBytes_(sequenceNumber, 4),
  957.     ]);
  958.     return Mp4Generator.box('mfhd', bytes);
  959.   }
  961.   /**
  962.    * Generate a TRAF box
  963.    *
  964.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  965.    * @return {!Uint8Array}
  966.    * @private
  967.    */
  968.   traf_(streamInfo) {
  969.     const Mp4Generator = shaka.util.Mp4Generator;
  970.     const sampleDependencyTable = this.sdtp_(streamInfo);
  971.     const offset = sampleDependencyTable.length +
  972.           32 + // tfhd
  973.           20 + // tfdt
  974.           8 + // traf header
  975.           16 + // mfhd
  976.           8 + // moof header
  977.           8; // mdat header;
  978.     return Mp4Generator.box('traf',
  979.         this.tfhd_(streamInfo),
  980.         this.tfdt_(streamInfo),
  981.         this.trun_(streamInfo, offset),
  982.         sampleDependencyTable);
  983.   }
  985.   /**
  986.    * Generate a SDTP box
  987.    *
  988.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  989.    * @return {!Uint8Array}
  990.    * @private
  991.    */
  992.   sdtp_(streamInfo) {
  993.     const Mp4Generator = shaka.util.Mp4Generator;
  994.     const samples = streamInfo.data ? streamInfo.data.samples : [];
  995.     const bytes = new Uint8Array(4 + samples.length);
  996.     // leave the full box header (4 bytes) all zero
  997.     // write the sample table
  998.     for (let i = 0; i < samples.length; i++) {
  999.       const flags = samples[i].flags;
  1000.       bytes[i + 4] = (flags.dependsOn << 4) |
  1001.           (flags.isDependedOn << 2) |
  1002.           flags.hasRedundancy;
  1003.     }
  1004.     return Mp4Generator.box('sdtp', bytes);
  1005.   }
  1007.   /**
  1008.    * Generate a TFHD box
  1009.    *
  1010.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  1011.    * @return {!Uint8Array}
  1012.    * @private
  1013.    */
  1014.   tfhd_(streamInfo) {
  1015.     const Mp4Generator = shaka.util.Mp4Generator;
  1016.     const id = streamInfo.id + 1;
  1017.     const bytes = new Uint8Array([
  1018.       0x00, // version 0
  1019.       0x00, 0x00, 0x3a, // flags
  1020.       ...this.breakNumberIntoBytes_(id, 4), // track_ID
  1021.       0x00, 0x00, 0x00, 0x01, // sample_description_index
  1022.       0x00, 0x00, 0x00, 0x00, // default_sample_duration
  1023.       0x00, 0x00, 0x00, 0x00, // default_sample_size
  1024.       0x00, 0x00, 0x00, 0x00,  // default_sample_flags
  1025.     ]);
  1026.     return Mp4Generator.box('tfhd', bytes);
  1027.   }
  1029.   /**
  1030.    * Generate a TFDT box
  1031.    *
  1032.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  1033.    * @return {!Uint8Array}
  1034.    * @private
  1035.    */
  1036.   tfdt_(streamInfo) {
  1037.     const Mp4Generator = shaka.util.Mp4Generator;
  1038.     const baseMediaDecodeTime =
  1039.         streamInfo.data ? streamInfo.data.baseMediaDecodeTime : 0;
  1040.     const upperWordBaseMediaDecodeTime =
  1041.       Math.floor(baseMediaDecodeTime / (Mp4Generator.UINT32_MAX_ + 1));
  1042.     const lowerWordBaseMediaDecodeTime =
  1043.       Math.floor(baseMediaDecodeTime % (Mp4Generator.UINT32_MAX_ + 1));
  1044.     const bytes = new Uint8Array([
  1045.       0x01, // version 1
  1046.       0x00, 0x00, 0x00, // flags
  1047.       ...this.breakNumberIntoBytes_(upperWordBaseMediaDecodeTime, 4),
  1048.       ...this.breakNumberIntoBytes_(lowerWordBaseMediaDecodeTime, 4),
  1049.     ]);
  1050.     return Mp4Generator.box('tfdt', bytes);
  1051.   }
  1053.   /**
  1054.    * Generate a TRUN box
  1055.    *
  1056.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  1057.    * @param {number} offset
  1058.    * @return {!Uint8Array}
  1059.    * @private
  1060.    */
  1061.   trun_(streamInfo, offset) {
  1062.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1063.     const Mp4Generator = shaka.util.Mp4Generator;
  1065.     const samples = streamInfo.data ? streamInfo.data.samples : [];
  1066.     const samplesLength = samples.length;
  1067.     const bytesLen = 12 + 16 * samplesLength;
  1068.     const bytes = new Uint8Array(bytesLen);
  1069.     offset += 8 + bytesLen;
  1070.     const isVideo = streamInfo.type === ContentType.VIDEO;
  1071.     bytes.set(
  1072.         [
  1073.         // version 1 for video with signed-int sample_composition_time_offset
  1074.         isVideo ? 0x01 : 0x00,
  1075.         0x00, 0x0f, 0x01, // flags
  1076.         ...this.breakNumberIntoBytes_(samplesLength, 4), // sample_count
  1077.         ...this.breakNumberIntoBytes_(offset, 4), // data_offset
  1078.         ],
  1079.         0,
  1080.     );
  1081.     for (let i = 0; i < samplesLength; i++) {
  1082.       const sample = samples[i];
  1083.       const duration = this.breakNumberIntoBytes_(sample.duration, 4);
  1084.       const size = this.breakNumberIntoBytes_(sample.size, 4);
  1085.       const flags = sample.flags;
  1086.       const cts = this.breakNumberIntoBytes_(sample.cts, 4);
  1087.       bytes.set(
  1088.           [
  1089.             ...duration, // sample_duration
  1090.             ...size, // sample_size
  1091.             (flags.isLeading << 2) | flags.dependsOn,
  1092.             (flags.isDependedOn << 6) | (flags.hasRedundancy << 4) |
  1093.               flags.isNonSync,
  1094.             flags.degradPrio & (0xf0 << 8),
  1095.             flags.degradPrio & 0x0f, // sample_flags
  1096.             ...cts, // sample_composition_time_offset
  1097.           ],
  1098.           12 + 16 * i,
  1099.       );
  1100.     }
  1101.     return Mp4Generator.box('trun', bytes);
  1102.   }
  1104.   /**
  1105.    * Generate a MDAT box
  1106.    *
  1107.    * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
  1108.    * @return {!Uint8Array}
  1109.    * @private
  1110.    */
  1111.   mdat_(streamInfo) {
  1112.     const Mp4Generator = shaka.util.Mp4Generator;
  1113.     const samples = streamInfo.data ? streamInfo.data.samples : [];
  1114.     const allData = samples.map((sample) => sample.data);
  1115.     const bytes = shaka.util.Uint8ArrayUtils.concat(...allData);
  1116.     return Mp4Generator.box('mdat', bytes);
  1117.   }
  1120.   /**
  1121.    * @param {number} number
  1122.    * @param {number} numBytes
  1123.    * @return {!Array<number>}
  1124.    * @private
  1125.    */
  1126.   breakNumberIntoBytes_(number, numBytes) {
  1127.     const bytes = [];
  1128.     for (let byte = numBytes - 1; byte >= 0; byte--) {
  1129.       bytes.push((number >> (8 * byte)) & 0xff);
  1130.     }
  1131.     return bytes;
  1132.   }
  1134.   /**
  1135.    * Convert a hex string to buffer.
  1136.    *
  1137.    * @param {string} str
  1138.    * @return {Uint8Array}
  1139.    * @private
  1140.    */
  1141.   hexStringToBuffer_(str) {
  1142.     const buf = new Uint8Array(str.length / 2);
  1143.     for (let i = 0; i < str.length / 2; i += 1) {
  1144.       buf[i] = parseInt(String(str[i * 2] + str[i * 2 + 1]), 16);
  1145.     }
  1146.     return buf;
  1147.   }
  1149.   /**
  1150.    * Convert a string to char code.
  1151.    *
  1152.    * @param {string} str
  1153.    * @return {number}
  1154.    * @private
  1155.    */
  1156.   stringToCharCode_(str) {
  1157.     let code = 0;
  1158.     for (let i = 0; i < str.length; i += 1) {
  1159.       code |= str.charCodeAt(i) << ((str.length - i - 1) * 8);
  1160.     }
  1161.     return code;
  1162.   }
  1164.   /**
  1165.    * @private
  1166.    */
  1167.   static initStaticProperties_() {
  1168.     const Mp4Generator = shaka.util.Mp4Generator;
  1169.     if (Mp4Generator.initialized_) {
  1170.       return;
  1171.     }
  1173.     Mp4Generator.initialized_ = true;
  1175.     const majorBrand = new Uint8Array([105, 115, 111, 109]); // isom
  1176.     const avc1Brand = new Uint8Array([97, 118, 99, 49]); // avc1
  1177.     const minorVersion = new Uint8Array([0, 0, 0, 1]);
  1179.     Mp4Generator.FTYP_ = Mp4Generator.box(
  1180.         'ftyp', majorBrand, minorVersion, majorBrand, avc1Brand);
  1181.     const drefBox = Mp4Generator.box('dref', Mp4Generator.DREF_);
  1182.     Mp4Generator.DINF_ = Mp4Generator.box('dinf', drefBox);
  1183.   }
  1185.   /**
  1186.    * Generate a box
  1187.    *
  1188.    * @param {string} boxName
  1189.    * @param {...!Uint8Array} payload
  1190.    * @return {!Uint8Array}
  1191.    */
  1192.   static box(boxName, ...payload) {
  1193.     let type = shaka.util.Mp4Generator.BOX_TYPES_.get(boxName);
  1194.     if (!type) {
  1195.       type = [
  1196.         boxName.charCodeAt(0),
  1197.         boxName.charCodeAt(1),
  1198.         boxName.charCodeAt(2),
  1199.         boxName.charCodeAt(3),
  1200.       ];
  1201.       shaka.util.Mp4Generator.BOX_TYPES_.set(boxName, type);
  1202.     }
  1203.     // make the header for the box
  1204.     let size = 8;
  1205.     // calculate the total size we need to allocate
  1206.     for (let i = payload.length - 1; i >= 0; i--) {
  1207.       size += payload[i].byteLength;
  1208.     }
  1209.     const result = new Uint8Array(size);
  1210.     result[0] = (size >> 24) & 0xff;
  1211.     result[1] = (size >> 16) & 0xff;
  1212.     result[2] = (size >> 8) & 0xff;
  1213.     result[3] = size & 0xff;
  1214.     result.set(type, 4);
  1216.     // copy the payload into the result
  1217.     for (let i = 0, pointer = 8; i < payload.length; i++) {
  1218.       // copy payload[i] array @ offset pointer
  1219.       result.set(payload[i], pointer);
  1220.       pointer += payload[i].byteLength;
  1221.     }
  1222.     return result;
  1223.   }
  1224. };
  1226. /**
  1227.  * @private {boolean}
  1228.  */
  1229. shaka.util.Mp4Generator.initialized_ = false;
  1232. /**
  1233.  * @private {number}
  1234.  */
  1235. shaka.util.Mp4Generator.UINT32_MAX_ = Math.pow(2, 32) - 1;
  1237. /**
  1238.  * @private {!Map<string, !Array<number>>}
  1239.  */
  1240. shaka.util.Mp4Generator.BOX_TYPES_ = new Map();
  1242. /**
  1243.  * @private {{video: !Uint8Array, audio: !Uint8Array}}
  1244.  */
  1245. shaka.util.Mp4Generator.HDLR_TYPES_ = {
  1246.   video: new Uint8Array([
  1247.     0x00, // version 0
  1248.     0x00, 0x00, 0x00, // flags
  1249.     0x00, 0x00, 0x00, 0x00, // pre_defined
  1250.     0x76, 0x69, 0x64, 0x65, // handler_type: 'vide'
  1251.     0x00, 0x00, 0x00, 0x00, // reserved
  1252.     0x00, 0x00, 0x00, 0x00, // reserved
  1253.     0x00, 0x00, 0x00, 0x00, // reserved
  1254.     0x56, 0x69, 0x64, 0x65,
  1255.     0x6f, 0x48, 0x61, 0x6e,
  1256.     0x64, 0x6c, 0x65, 0x72, 0x00, // name: 'VideoHandler'
  1257.   ]),
  1258.   audio: new Uint8Array([
  1259.     0x00, // version 0
  1260.     0x00, 0x00, 0x00, // flags
  1261.     0x00, 0x00, 0x00, 0x00, // pre_defined
  1262.     0x73, 0x6f, 0x75, 0x6e, // handler_type: 'soun'
  1263.     0x00, 0x00, 0x00, 0x00, // reserved
  1264.     0x00, 0x00, 0x00, 0x00, // reserved
  1265.     0x00, 0x00, 0x00, 0x00, // reserved
  1266.     0x53, 0x6f, 0x75, 0x6e,
  1267.     0x64, 0x48, 0x61, 0x6e,
  1268.     0x64, 0x6c, 0x65, 0x72, 0x00, // name: 'SoundHandler'
  1269.   ]),
  1270. };
  1272. /**
  1273.  * @private {!Uint8Array}
  1274.  */
  1275. shaka.util.Mp4Generator.STTS_ = new Uint8Array([
  1276.   0x00, // version
  1277.   0x00, 0x00, 0x00, // flags
  1278.   0x00, 0x00, 0x00, 0x00, // entry_count
  1279. ]);
  1281. /**
  1282.  * @private {!Uint8Array}
  1283.  */
  1284. shaka.util.Mp4Generator.STSC_ = new Uint8Array([
  1285.   0x00, // version
  1286.   0x00, 0x00, 0x00, // flags
  1287.   0x00, 0x00, 0x00, 0x00, // entry_count
  1288. ]);
  1290. /**
  1291.  * @private {!Uint8Array}
  1292.  */
  1293. shaka.util.Mp4Generator.STCO_ = new Uint8Array([
  1294.   0x00, // version
  1295.   0x00, 0x00, 0x00, // flags
  1296.   0x00, 0x00, 0x00, 0x00, // entry_count
  1297. ]);
  1299. /**
  1300.  * @private {!Uint8Array}
  1301.  */
  1302. shaka.util.Mp4Generator.STSZ_ = new Uint8Array([
  1303.   0x00, // version
  1304.   0x00, 0x00, 0x00, // flags
  1305.   0x00, 0x00, 0x00, 0x00, // sample_size
  1306.   0x00, 0x00, 0x00, 0x00, // sample_count
  1307. ]);
  1309. /**
  1310.  * @private {!Uint8Array}
  1311.  */
  1312. shaka.util.Mp4Generator.VMHD_ = new Uint8Array([
  1313.   0x00, // version
  1314.   0x00, 0x00, 0x01, // flags
  1315.   0x00, 0x00, // graphics mode
  1316.   0x00, 0x00,
  1317.   0x00, 0x00,
  1318.   0x00, 0x00, // op color
  1319. ]);
  1321. /**
  1322.  * @private {!Uint8Array}
  1323.  */
  1324. shaka.util.Mp4Generator.SMHD_ = new Uint8Array([
  1325.   0x00, // version
  1326.   0x00, 0x00, 0x00, // flags
  1327.   0x00, 0x00, // balance, 0 means centered
  1328.   0x00, 0x00, // reserved
  1329. ]);
  1331. /**
  1332.  * @private {!Uint8Array}
  1333.  */
  1334. shaka.util.Mp4Generator.STSD_ = new Uint8Array([
  1335.   0x00, // version 0
  1336.   0x00, 0x00, 0x00, // flags
  1337.   0x00, 0x00, 0x00, 0x01, // entry_count
  1338. ]);
  1340. /**
  1341.  * @private {!Uint8Array}
  1342.  */
  1343. shaka.util.Mp4Generator.FTYP_ = new Uint8Array([]);
  1345. /**
  1346.  * @private {!Uint8Array}
  1347.  */
  1348. shaka.util.Mp4Generator.DREF_ = new Uint8Array([
  1349.   0x00, // version 0
  1350.   0x00, 0x00, 0x00, // flags
  1351.   0x00, 0x00, 0x00, 0x01, // entry_count
  1352.   0x00, 0x00, 0x00, 0x0c, // entry_size
  1353.   0x75, 0x72, 0x6c, 0x20, // 'url' type
  1354.   0x00, // version 0
  1355.   0x00, 0x00, 0x01, // entry_flags
  1356. ]);
  1358. /**
  1359.  * @private {!Uint8Array}
  1360.  */
  1361. shaka.util.Mp4Generator.DINF_ = new Uint8Array([]);
  1363. /**
  1364.  * @typedef {{
  1365.  *    id: number,
  1366.  *    type: string,
  1367.  *    codecs: string,
  1368.  *    encrypted: boolean,
  1369.  *    timescale: number,
  1370.  *    duration: number,
  1371.  *    videoNalus: !Array<string>,
  1372.  *    audioConfig: !Uint8Array,
  1373.  *    videoConfig: !Uint8Array,
  1374.  *    hSpacing: number,
  1375.  *    vSpacing: number,
  1376.  *    data: ?shaka.util.Mp4Generator.Data,
  1377.  *    stream: !shaka.extern.Stream
  1378.  * }}
  1379.  *
  1380.  * @property {number} id
  1381.  *   A unique ID
  1382.  * @property {string} type
  1383.  *   Indicate the content type: 'video' or 'audio'.
  1384.  * @property {string} codecs
  1385.  *   <i>Defaults to '' (i.e., unknown / not needed).</i> <br>
  1386.  *   The Stream's codecs, e.g., 'avc1.4d4015' or 'vp9'<br>
  1387.  *   See {@link https://tools.ietf.org/html/rfc6381}
  1388.  * @property {boolean} encrypted
  1389.  *   Indicate if the stream is encrypted.
  1390.  * @property {number} timescale
  1391.  *   The Stream's timescale.
  1392.  * @property {number} duration
  1393.  *   The Stream's duration.
  1394.  * @property {!Array<string>} videoNalus
  1395.  *   The stream's video nalus.
  1396.  * @property {!Uint8Array} audioConfig
  1397.  *   The stream's audio config.
  1398.  * @property {!Uint8Array} videoConfig
  1399.  *   The stream's video config.
  1400.  * @property {number} hSpacing
  1401.  *   The stream's video horizontal spacing of pixels.
  1402.  * @property {number} vSpacing
  1403.  *   The stream's video vertical spacing of pixels.
  1404.  * @property {?shaka.util.Mp4Generator.Data} data
  1405.  *   The stream's data.
  1406.  * @property {!shaka.extern.Stream} stream
  1407.  *   The Stream.
  1408.  */
  1409. shaka.util.Mp4Generator.StreamInfo;
  1411. /**
  1412.  * @typedef {{
  1413.  *    sequenceNumber: number,
  1414.  *    baseMediaDecodeTime: number,
  1415.  *    samples: !Array<shaka.util.Mp4Generator.Mp4Sample>
  1416.  * }}
  1417.  *
  1418.  * @property {number} sequenceNumber
  1419.  *   The sequence number.
  1420.  * @property {number} baseMediaDecodeTime
  1421.  *   The base media decode time.
  1422.  * @property {!Array<shaka.util.Mp4Generator.Mp4Sample>} samples
  1423.  *   The data samples.
  1424.  */
  1425. shaka.util.Mp4Generator.Data;
  1427. /**
  1428.  * @typedef {{
  1429.  *    data: !Uint8Array,
  1430.  *    size: number,
  1431.  *    duration: number,
  1432.  *    cts: number,
  1433.  *    flags: !shaka.util.Mp4Generator.Mp4SampleFlags
  1434.  * }}
  1435.  *
  1436.  * @property {!Uint8Array} data
  1437.  *   The sample data.
  1438.  * @property {number} size
  1439.  *   The sample size.
  1440.  * @property {number} duration
  1441.  *   The sample duration.
  1442.  * @property {number} cts
  1443.  *   The sample composition time.
  1444.  * @property {!shaka.util.Mp4Generator.Mp4SampleFlags} flags
  1445.  *   The sample flags.
  1446.  */
  1447. shaka.util.Mp4Generator.Mp4Sample;
  1449. /**
  1450.  * @typedef {{
  1451.  *    isLeading: number,
  1452.  *    isDependedOn: number,
  1453.  *    hasRedundancy: number,
  1454.  *    degradPrio: number,
  1455.  *    dependsOn: number,
  1456.  *    isNonSync: number
  1457.  * }}
  1458.  *
  1459.  * @property {number} isLeading
  1460.  * @property {number} isDependedOn
  1461.  * @property {number} hasRedundancy
  1462.  * @property {number} degradPrio
  1463.  * @property {number} dependsOn
  1464.  * @property {number} isNonSync
  1465.  */
  1466. shaka.util.Mp4Generator.Mp4SampleFlags;