Source: lib/transmuxer/mss_transmuxer.js

  1. /*! @license
  2.  * MSS Transmuxer
  3.  * Copyright 2015 Dash Industry Forum
  4.  * SPDX-License-Identifier: BSD-3-Clause
  5.  */
  7. /*
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions are met:
  10.  *
  11.  * - Redistributions of source code must retain the above copyright notice,
  12.  *   this list of conditions and the following disclaimer.
  13.  * - Redistributions in binary form must reproduce the above copyright notice,
  14.  *   this list of conditions and the following disclaimer in the documentation
  15.  *   and/or other materials provided with the distribution.
  16.  * - Neither the name of the Dash Industry Forum nor the names of its
  17.  *   contributors may be used to endorse or promote products derived from this
  18.  *   software without specific prior written permission.
  19.  *
  20.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
  21.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23.  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  24.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30.  * POSSIBILITY OF SUCH DAMAGE.
  31.  */
  33. goog.provide('shaka.transmuxer.MssTransmuxer');
  35. goog.require('shaka.media.Capabilities');
  36. goog.require('shaka.transmuxer.TransmuxerEngine');
  37. goog.require('shaka.util.BufferUtils');
  38. goog.require('shaka.util.Error');
  39. goog.require('shaka.util.ManifestParserUtils');
  40. goog.require('shaka.dependencies');
  42. goog.requireType('shaka.media.SegmentReference');
  45. /**
  46.  * @implements {shaka.extern.Transmuxer}
  47.  * @export
  48.  */
  49. shaka.transmuxer.MssTransmuxer = class {
  50.   /**
  51.    * @param {string} mimeType
  52.    */
  53.   constructor(mimeType) {
  54.     /** @private {string} */
  55.     this.originalMimeType_ = mimeType;
  57.     /** @private {?ISOBoxer} */
  58.     this.isoBoxer_ = shaka.dependencies.isoBoxer();
  60.     if (this.isoBoxer_) {
  61.       this.addSpecificBoxProcessor_();
  62.     }
  63.   }
  65.   /**
  66.    * Add specific box processor for codem-isoboxer
  67.    *
  68.    * @private
  69.    */
  70.   addSpecificBoxProcessor_() {
  71.     // eslint-disable-next-line no-restricted-syntax
  72.     this.isoBoxer_.addBoxProcessor('saio', function() {
  73.       // eslint-disable-next-line no-invalid-this
  74.       const box = /** @type {!ISOBox} */(this);
  75.       box._procFullBox();
  76.       if (box.flags & 1) {
  77.         box._procField('aux_info_type', 'uint', 32);
  78.         box._procField('aux_info_type_parameter', 'uint', 32);
  79.       }
  80.       box._procField('entry_count', 'uint', 32);
  81.       box._procFieldArray('offset', box.entry_count, 'uint',
  82.           (box.version === 1) ? 64 : 32);
  83.     });
  84.     // eslint-disable-next-line no-restricted-syntax
  85.     this.isoBoxer_.addBoxProcessor('saiz', function() {
  86.       // eslint-disable-next-line no-invalid-this
  87.       const box = /** @type {!ISOBox} */(this);
  88.       box._procFullBox();
  89.       if (box.flags & 1) {
  90.         box._procField('aux_info_type', 'uint', 32);
  91.         box._procField('aux_info_type_parameter', 'uint', 32);
  92.       }
  93.       box._procField('default_sample_info_size', 'uint', 8);
  94.       box._procField('sample_count', 'uint', 32);
  95.       if (box.default_sample_info_size === 0) {
  96.         box._procFieldArray('sample_info_size',
  97.             box.sample_count, 'uint', 8);
  98.       }
  99.     });
  100.     // eslint-disable-next-line no-restricted-syntax
  101.     const sencProcessor = function() {
  102.       // eslint-disable-next-line no-invalid-this
  103.       const box = /** @type {!ISOBox} */(this);
  104.       box._procFullBox();
  105.       if (box.flags & 1) {
  106.         box._procField('AlgorithmID', 'uint', 24);
  107.         box._procField('IV_size', 'uint', 8);
  108.         box._procFieldArray('KID', 16, 'uint', 8);
  109.       }
  110.       box._procField('sample_count', 'uint', 32);
  111.       // eslint-disable-next-line no-restricted-syntax
  112.       box._procEntries('entry', box.sample_count, function(entry) {
  113.         // eslint-disable-next-line no-invalid-this
  114.         const boxEntry = /** @type {!ISOBox} */(this);
  115.         boxEntry._procEntryField(entry, 'InitializationVector', 'data', 8);
  116.         if (boxEntry.flags & 2) {
  117.           boxEntry._procEntryField(entry, 'NumberOfEntries', 'uint', 16);
  118.           boxEntry._procSubEntries(entry, 'clearAndCryptedData',
  119.               // eslint-disable-next-line no-restricted-syntax
  120.               entry.NumberOfEntries, function(clearAndCryptedData) {
  121.                 // eslint-disable-next-line no-invalid-this
  122.                 const subBoxEntry = /** @type {!ISOBox} */(this);
  123.                 subBoxEntry._procEntryField(clearAndCryptedData,
  124.                     'BytesOfClearData', 'uint', 16);
  125.                 subBoxEntry._procEntryField(clearAndCryptedData,
  126.                     'BytesOfEncryptedData', 'uint', 32);
  127.               });
  128.         }
  129.       });
  130.     };
  131.     this.isoBoxer_.addBoxProcessor('senc', sencProcessor);
  132.     // eslint-disable-next-line no-restricted-syntax
  133.     this.isoBoxer_.addBoxProcessor('uuid', function() {
  134.       const MssTransmuxer = shaka.transmuxer.MssTransmuxer;
  135.       // eslint-disable-next-line no-invalid-this
  136.       const box = /** @type {!ISOBox} */(this);
  137.       let isSENC = true;
  138.       for (let i = 0; i < 16; i++) {
  139.         if (box.usertype[i] !== MssTransmuxer.UUID_SENC_[i]) {
  140.           isSENC = false;
  141.         }
  142.         // Add support for other user types here
  143.       }
  145.       if (isSENC) {
  146.         if (box._parsing) {
  147.           // Convert this box to sepiff for later processing.
  148.           // See processMediaSegment_ function.
  149.           box.type = 'sepiff';
  150.         }
  151.         // eslint-disable-next-line no-restricted-syntax, no-invalid-this
  152.         sencProcessor.call(/** @type {!ISOBox} */(this));
  153.       }
  154.     });
  155.   }
  158.   /**
  159.    * @override
  160.    * @export
  161.    */
  162.   destroy() {
  163.     // Nothing
  164.   }
  167.   /**
  168.    * Check if the mime type and the content type is supported.
  169.    * @param {string} mimeType
  170.    * @param {string=} contentType
  171.    * @return {boolean}
  172.    * @override
  173.    * @export
  174.    */
  175.   isSupported(mimeType, contentType) {
  176.     const Capabilities = shaka.media.Capabilities;
  178.     const isMss = mimeType.startsWith('mss/');
  180.     if (!this.isoBoxer_ || !isMss) {
  181.       return false;
  182.     }
  184.     if (contentType) {
  185.       return Capabilities.isTypeSupported(
  186.           this.convertCodecs(contentType, mimeType));
  187.     }
  189.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  191.     const audioMime = this.convertCodecs(ContentType.AUDIO, mimeType);
  192.     const videoMime = this.convertCodecs(ContentType.VIDEO, mimeType);
  193.     return Capabilities.isTypeSupported(audioMime) ||
  194.         Capabilities.isTypeSupported(videoMime);
  195.   }
  198.   /**
  199.    * @override
  200.    * @export
  201.    */
  202.   convertCodecs(contentType, mimeType) {
  203.     return mimeType.replace('mss/', '');
  204.   }
  207.   /**
  208.    * @override
  209.    * @export
  210.    */
  211.   getOriginalMimeType() {
  212.     return this.originalMimeType_;
  213.   }
  216.   /**
  217.    * @override
  218.    * @export
  219.    */
  220.   transmux(data, stream, reference) {
  221.     if (!reference) {
  222.       // Init segment doesn't need transmux
  223.       return Promise.resolve(shaka.util.BufferUtils.toUint8(data));
  224.     }
  225.     if (!stream.mssPrivateData) {
  226.       return Promise.reject(new shaka.util.Error(
  227.           shaka.util.Error.Severity.CRITICAL,
  228.           shaka.util.Error.Category.MEDIA,
  229.           shaka.util.Error.Code.MSS_MISSING_DATA_FOR_TRANSMUXING));
  230.     }
  231.     try {
  232.       const transmuxedData = this.processMediaSegment_(
  233.           data, stream, reference);
  234.       return Promise.resolve(transmuxedData);
  235.     } catch (exception) {
  236.       if (exception instanceof shaka.util.Error) {
  237.         return Promise.reject(exception);
  238.       }
  239.       return Promise.reject(new shaka.util.Error(
  240.           shaka.util.Error.Severity.CRITICAL,
  241.           shaka.util.Error.Category.MEDIA,
  242.           shaka.util.Error.Code.MSS_TRANSMUXING_FAILED));
  243.     }
  244.   }
  246.   /**
  247.    * Process a media segment from a data and stream.
  248.    * @param {BufferSource} data
  249.    * @param {shaka.extern.Stream} stream
  250.    * @param {shaka.media.SegmentReference} reference
  251.    * @return {!Uint8Array}
  252.    * @private
  253.    */
  254.   processMediaSegment_(data, stream, reference) {
  255.     let i;
  256.     /** @type {!ISOFile} */
  257.     const isoFile = this.isoBoxer_.parseBuffer(data);
  258.     // Update track_Id in tfhd box
  259.     const tfhd = isoFile.fetch('tfhd');
  260.     tfhd.track_ID = stream.id + 1;
  261.     // Add tfdt box
  262.     let tfdt = isoFile.fetch('tfdt');
  263.     const traf = isoFile.fetch('traf');
  264.     if (tfdt === null) {
  265.       tfdt = this.isoBoxer_.createFullBox('tfdt', traf, tfhd);
  266.       tfdt.version = 1;
  267.       tfdt.flags = 0;
  268.       const timescale = stream.mssPrivateData.timescale;
  269.       const startTime = reference.startTime;
  270.       tfdt.baseMediaDecodeTime = Math.floor(startTime * timescale);
  271.     }
  272.     const trun = isoFile.fetch('trun');
  273.     // Process tfxd boxes
  274.     // This box provide absolute timestamp but we take the segment start
  275.     // time for tfdt
  276.     let tfxd = isoFile.fetch('tfxd');
  277.     if (tfxd) {
  278.       tfxd._parent.boxes.splice(tfxd._parent.boxes.indexOf(tfxd), 1);
  279.       tfxd = null;
  280.     }
  281.     let tfrf = isoFile.fetch('tfrf');
  282.     if (tfrf) {
  283.       tfrf._parent.boxes.splice(tfrf._parent.boxes.indexOf(tfrf), 1);
  284.       tfrf = null;
  285.     }
  287.     // If protected content in PIFF1.1 format
  288.     // (sepiff box = Sample Encryption PIFF)
  289.     // => convert sepiff box it into a senc box
  290.     // => create saio and saiz boxes (if not already present)
  291.     const sepiff = isoFile.fetch('sepiff');
  292.     if (sepiff !== null) {
  293.       sepiff.type = 'senc';
  294.       sepiff.usertype = undefined;
  296.       let saio = isoFile.fetch('saio');
  297.       if (saio === null) {
  298.         // Create Sample Auxiliary Information Offsets Box box (saio)
  299.         saio = this.isoBoxer_.createFullBox('saio', traf);
  300.         saio.version = 0;
  301.         saio.flags = 0;
  302.         saio.entry_count = 1;
  303.         saio.offset = [0];
  304.         const saiz = this.isoBoxer_.createFullBox('saiz', traf);
  305.         saiz.version = 0;
  306.         saiz.flags = 0;
  307.         saiz.sample_count = sepiff.sample_count;
  308.         saiz.default_sample_info_size = 0;
  309.         saiz.sample_info_size = [];
  310.         if (sepiff.flags & 0x02) {
  311.           // Sub-sample encryption => set sample_info_size for each sample
  312.           for (i = 0; i < sepiff.sample_count; i += 1) {
  313.             // 10 = 8 (InitializationVector field size) + 2
  314.             // (subsample_count field size)
  315.             // 6 = 2 (BytesOfClearData field size) + 4
  316.             // (BytesOfEncryptedData field size)
  317.             const entry = /** @type {!ISOEntry} */ (sepiff.entry[i]);
  318.             saiz.sample_info_size[i] = 10 + (6 * entry.NumberOfEntries);
  319.           }
  320.         } else {
  321.           // No sub-sample encryption => set default
  322.           // sample_info_size = InitializationVector field size (8)
  323.           saiz.default_sample_info_size = 8;
  324.         }
  325.       }
  326.     }
  328.     // set tfhd.base-data-offset-present to false
  329.     tfhd.flags &= 0xFFFFFE;
  330.     // set tfhd.default-base-is-moof to true
  331.     tfhd.flags |= 0x020000;
  332.     // set trun.data-offset-present to true
  333.     trun.flags |= 0x000001;
  335.     // Update trun.data_offset field that corresponds to first data byte
  336.     // (inside mdat box)
  337.     const moof = isoFile.fetch('moof');
  338.     const length = moof.getLength();
  339.     trun.data_offset = length + 8;
  341.     // Update saio box offset field according to new senc box offset
  342.     const saio = isoFile.fetch('saio');
  343.     if (saio !== null) {
  344.       const trafPosInMoof = this.getBoxOffset_(moof, 'traf');
  345.       const sencPosInTraf = this.getBoxOffset_(traf, 'senc');
  346.       // Set offset from begin fragment to the first IV field in senc box
  347.       // 16 = box header (12) + sample_count field size (4)
  348.       saio.offset[0] = trafPosInMoof + sencPosInTraf + 16;
  349.     }
  351.     return shaka.util.BufferUtils.toUint8(isoFile.write());
  352.   }
  354.   /**
  355.    * This function returns the offset of the 1st byte of a child box within
  356.    * a container box.
  357.    *
  358.    * @param {ISOBox} parent
  359.    * @param {string} type
  360.    * @return {number}
  361.    * @private
  362.    */
  363.   getBoxOffset_(parent, type) {
  364.     let offset = 8;
  365.     for (let i = 0; i < parent.boxes.length; i++) {
  366.       if (parent.boxes[i].type === type) {
  367.         return offset;
  368.       }
  369.       offset += parent.boxes[i].size;
  370.     }
  371.     return offset;
  372.   }
  373. };
  375. /**
  376.  * @private {!Uint8Array}
  377.  */
  378. shaka.transmuxer.MssTransmuxer.UUID_SENC_ = new Uint8Array([
  379.   0xA2, 0x39, 0x4F, 0x52, 0x5A, 0x9B, 0x4F, 0x14,
  380.   0xA2, 0x44, 0x6C, 0x42, 0x7C, 0x64, 0x8D, 0xF4,
  381. ]);
  383. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  384.     'mss/audio/mp4',
  385.     () => new shaka.transmuxer.MssTransmuxer('mss/audio/mp4'),
  386.     shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK);
  387. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  388.     'mss/video/mp4',
  389.     () => new shaka.transmuxer.MssTransmuxer('mss/video/mp4'),
  390.     shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK);