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. // cspell:words crypted usertype
  35. goog.provide('shaka.transmuxer.MssTransmuxer');
  37. goog.require('shaka.media.Capabilities');
  38. goog.require('shaka.transmuxer.TransmuxerEngine');
  39. goog.require('shaka.util.BufferUtils');
  40. goog.require('shaka.util.Error');
  41. goog.require('shaka.util.ManifestParserUtils');
  42. goog.require('shaka.dependencies');
  44. goog.requireType('shaka.media.SegmentReference');
  47. /**
  48.  * @implements {shaka.extern.Transmuxer}
  49.  * @export
  50.  */
  51. shaka.transmuxer.MssTransmuxer = class {
  52.   /**
  53.    * @param {string} mimeType
  54.    */
  55.   constructor(mimeType) {
  56.     /** @private {string} */
  57.     this.originalMimeType_ = mimeType;
  59.     /** @private {?ISOBoxer} */
  60.     this.isoBoxer_ = shaka.dependencies.isoBoxer();
  62.     if (this.isoBoxer_) {
  63.       this.addSpecificBoxProcessor_();
  64.     }
  65.   }
  67.   /**
  68.    * Add specific box processor for codem-isoboxer
  69.    *
  70.    * @private
  71.    */
  72.   addSpecificBoxProcessor_() {
  73.     // eslint-disable-next-line no-restricted-syntax
  74.     this.isoBoxer_.addBoxProcessor('saio', function() {
  75.       // eslint-disable-next-line no-invalid-this
  76.       const box = /** @type {!ISOBox} */(this);
  77.       box._procFullBox();
  78.       if (box.flags & 1) {
  79.         box._procField('aux_info_type', 'uint', 32);
  80.         box._procField('aux_info_type_parameter', 'uint', 32);
  81.       }
  82.       box._procField('entry_count', 'uint', 32);
  83.       box._procFieldArray('offset', box.entry_count, 'uint',
  84.           (box.version === 1) ? 64 : 32);
  85.     });
  86.     // eslint-disable-next-line no-restricted-syntax
  87.     this.isoBoxer_.addBoxProcessor('saiz', function() {
  88.       // eslint-disable-next-line no-invalid-this
  89.       const box = /** @type {!ISOBox} */(this);
  90.       box._procFullBox();
  91.       if (box.flags & 1) {
  92.         box._procField('aux_info_type', 'uint', 32);
  93.         box._procField('aux_info_type_parameter', 'uint', 32);
  94.       }
  95.       box._procField('default_sample_info_size', 'uint', 8);
  96.       box._procField('sample_count', 'uint', 32);
  97.       if (box.default_sample_info_size === 0) {
  98.         box._procFieldArray('sample_info_size',
  99.             box.sample_count, 'uint', 8);
  100.       }
  101.     });
  102.     // eslint-disable-next-line no-restricted-syntax
  103.     const sencProcessor = function() {
  104.       // eslint-disable-next-line no-invalid-this
  105.       const box = /** @type {!ISOBox} */(this);
  106.       box._procFullBox();
  107.       if (box.flags & 1) {
  108.         box._procField('AlgorithmID', 'uint', 24);
  109.         box._procField('IV_size', 'uint', 8);
  110.         box._procFieldArray('KID', 16, 'uint', 8);
  111.       }
  112.       box._procField('sample_count', 'uint', 32);
  113.       // eslint-disable-next-line no-restricted-syntax
  114.       box._procEntries('entry', box.sample_count, function(entry) {
  115.         // eslint-disable-next-line no-invalid-this
  116.         const boxEntry = /** @type {!ISOBox} */(this);
  117.         boxEntry._procEntryField(entry, 'InitializationVector', 'data', 8);
  118.         if (boxEntry.flags & 2) {
  119.           boxEntry._procEntryField(entry, 'NumberOfEntries', 'uint', 16);
  120.           boxEntry._procSubEntries(entry, 'clearAndCryptedData',
  121.               // eslint-disable-next-line no-restricted-syntax
  122.               entry.NumberOfEntries, function(clearAndCryptedData) {
  123.                 // eslint-disable-next-line no-invalid-this
  124.                 const subBoxEntry = /** @type {!ISOBox} */(this);
  125.                 subBoxEntry._procEntryField(clearAndCryptedData,
  126.                     'BytesOfClearData', 'uint', 16);
  127.                 subBoxEntry._procEntryField(clearAndCryptedData,
  128.                     'BytesOfEncryptedData', 'uint', 32);
  129.               });
  130.         }
  131.       });
  132.     };
  133.     this.isoBoxer_.addBoxProcessor('senc', sencProcessor);
  134.     // eslint-disable-next-line no-restricted-syntax
  135.     this.isoBoxer_.addBoxProcessor('uuid', function() {
  136.       const MssTransmuxer = shaka.transmuxer.MssTransmuxer;
  137.       // eslint-disable-next-line no-invalid-this
  138.       const box = /** @type {!ISOBox} */(this);
  139.       let isSENC = true;
  140.       for (let i = 0; i < 16; i++) {
  141.         if (box.usertype[i] !== MssTransmuxer.UUID_SENC_[i]) {
  142.           isSENC = false;
  143.         }
  144.         // Add support for other user types here
  145.       }
  147.       if (isSENC) {
  148.         if (box._parsing) {
  149.           // Convert this box to sepiff for later processing.
  150.           // See processMediaSegment_ function.
  151.           box.type = 'sepiff';
  152.         }
  153.         // eslint-disable-next-line no-restricted-syntax, no-invalid-this
  154.         sencProcessor.call(/** @type {!ISOBox} */(this));
  155.       }
  156.     });
  157.   }
  160.   /**
  161.    * @override
  162.    * @export
  163.    */
  164.   destroy() {
  165.     // Nothing
  166.   }
  169.   /**
  170.    * Check if the mime type and the content type is supported.
  171.    * @param {string} mimeType
  172.    * @param {string=} contentType
  173.    * @return {boolean}
  174.    * @override
  175.    * @export
  176.    */
  177.   isSupported(mimeType, contentType) {
  178.     const Capabilities = shaka.media.Capabilities;
  180.     const isMss = mimeType.startsWith('mss/');
  182.     if (!this.isoBoxer_ || !isMss) {
  183.       return false;
  184.     }
  186.     if (contentType) {
  187.       return Capabilities.isTypeSupported(
  188.           this.convertCodecs(contentType, mimeType));
  189.     }
  191.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  193.     const audioMime = this.convertCodecs(ContentType.AUDIO, mimeType);
  194.     const videoMime = this.convertCodecs(ContentType.VIDEO, mimeType);
  195.     return Capabilities.isTypeSupported(audioMime) ||
  196.         Capabilities.isTypeSupported(videoMime);
  197.   }
  200.   /**
  201.    * @override
  202.    * @export
  203.    */
  204.   convertCodecs(contentType, mimeType) {
  205.     return mimeType.replace('mss/', '');
  206.   }
  209.   /**
  210.    * @override
  211.    * @export
  212.    */
  213.   getOriginalMimeType() {
  214.     return this.originalMimeType_;
  215.   }
  218.   /**
  219.    * @override
  220.    * @export
  221.    */
  222.   transmux(data, stream, reference) {
  223.     if (!reference) {
  224.       // Init segment doesn't need transmux
  225.       return Promise.resolve(shaka.util.BufferUtils.toUint8(data));
  226.     }
  227.     if (!stream.mssPrivateData) {
  228.       return Promise.reject(new shaka.util.Error(
  229.           shaka.util.Error.Severity.CRITICAL,
  230.           shaka.util.Error.Category.MEDIA,
  231.           shaka.util.Error.Code.MSS_MISSING_DATA_FOR_TRANSMUXING,
  232.           reference ? reference.getUris()[0] : null));
  233.     }
  234.     try {
  235.       const transmuxedData = this.processMediaSegment_(
  236.           data, stream, reference);
  237.       return Promise.resolve(transmuxedData);
  238.     } catch (exception) {
  239.       if (exception instanceof shaka.util.Error) {
  240.         return Promise.reject(exception);
  241.       }
  242.       return Promise.reject(new shaka.util.Error(
  243.           shaka.util.Error.Severity.CRITICAL,
  244.           shaka.util.Error.Category.MEDIA,
  245.           shaka.util.Error.Code.MSS_TRANSMUXING_FAILED,
  246.           reference ? reference.getUris()[0] : null));
  247.     }
  248.   }
  250.   /**
  251.    * Process a media segment from a data and stream.
  252.    * @param {BufferSource} data
  253.    * @param {shaka.extern.Stream} stream
  254.    * @param {shaka.media.SegmentReference} reference
  255.    * @return {!Uint8Array}
  256.    * @private
  257.    */
  258.   processMediaSegment_(data, stream, reference) {
  259.     let i;
  260.     /** @type {!ISOFile} */
  261.     const isoFile = this.isoBoxer_.parseBuffer(data);
  262.     // Update track_Id in tfhd box
  263.     const tfhd = isoFile.fetch('tfhd');
  264.     tfhd.track_ID = stream.id + 1;
  265.     // Add tfdt box
  266.     let tfdt = isoFile.fetch('tfdt');
  267.     const traf = isoFile.fetch('traf');
  268.     if (tfdt === null) {
  269.       tfdt = this.isoBoxer_.createFullBox('tfdt', traf, tfhd);
  270.       tfdt.version = 1;
  271.       tfdt.flags = 0;
  272.       const timescale = stream.mssPrivateData.timescale;
  273.       const startTime = reference.startTime;
  274.       tfdt.baseMediaDecodeTime = Math.floor(startTime * timescale);
  275.     }
  276.     const trun = isoFile.fetch('trun');
  277.     // Process tfxd boxes
  278.     // This box provide absolute timestamp but we take the segment start
  279.     // time for tfdt
  280.     let tfxd = isoFile.fetch('tfxd');
  281.     if (tfxd) {
  282.       tfxd._parent.boxes.splice(tfxd._parent.boxes.indexOf(tfxd), 1);
  283.       tfxd = null;
  284.     }
  285.     let tfrf = isoFile.fetch('tfrf');
  286.     if (tfrf) {
  287.       tfrf._parent.boxes.splice(tfrf._parent.boxes.indexOf(tfrf), 1);
  288.       tfrf = null;
  289.     }
  291.     // If protected content in PIFF1.1 format
  292.     // (sepiff box = Sample Encryption PIFF)
  293.     // => convert sepiff box it into a senc box
  294.     // => create saio and saiz boxes (if not already present)
  295.     const sepiff = isoFile.fetch('sepiff');
  296.     if (sepiff !== null) {
  297.       sepiff.type = 'senc';
  298.       sepiff.usertype = undefined;
  300.       let saio = isoFile.fetch('saio');
  301.       if (saio === null) {
  302.         // Create Sample Auxiliary Information Offsets Box box (saio)
  303.         saio = this.isoBoxer_.createFullBox('saio', traf);
  304.         saio.version = 0;
  305.         saio.flags = 0;
  306.         saio.entry_count = 1;
  307.         saio.offset = [0];
  308.         const saiz = this.isoBoxer_.createFullBox('saiz', traf);
  309.         saiz.version = 0;
  310.         saiz.flags = 0;
  311.         saiz.sample_count = sepiff.sample_count;
  312.         saiz.default_sample_info_size = 0;
  313.         saiz.sample_info_size = [];
  314.         if (sepiff.flags & 0x02) {
  315.           // Sub-sample encryption => set sample_info_size for each sample
  316.           for (i = 0; i < sepiff.sample_count; i += 1) {
  317.             // 10 = 8 (InitializationVector field size) + 2
  318.             // (subsample_count field size)
  319.             // 6 = 2 (BytesOfClearData field size) + 4
  320.             // (BytesOfEncryptedData field size)
  321.             const entry = /** @type {!ISOEntry} */ (sepiff.entry[i]);
  322.             saiz.sample_info_size[i] = 10 + (6 * entry.NumberOfEntries);
  323.           }
  324.         } else {
  325.           // No sub-sample encryption => set default
  326.           // sample_info_size = InitializationVector field size (8)
  327.           saiz.default_sample_info_size = 8;
  328.         }
  329.       }
  330.     }
  332.     // set tfhd.base-data-offset-present to false
  333.     tfhd.flags &= 0xFFFFFE;
  334.     // set tfhd.default-base-is-moof to true
  335.     tfhd.flags |= 0x020000;
  336.     // set trun.data-offset-present to true
  337.     trun.flags |= 0x000001;
  339.     // Update trun.data_offset field that corresponds to first data byte
  340.     // (inside mdat box)
  341.     const moof = isoFile.fetch('moof');
  342.     const length = moof.getLength();
  343.     trun.data_offset = length + 8;
  345.     // Update saio box offset field according to new senc box offset
  346.     const saio = isoFile.fetch('saio');
  347.     if (saio !== null) {
  348.       const trafPosInMoof = this.getBoxOffset_(moof, 'traf');
  349.       const sencPosInTraf = this.getBoxOffset_(traf, 'senc');
  350.       // Set offset from begin fragment to the first IV field in senc box
  351.       // 16 = box header (12) + sample_count field size (4)
  352.       saio.offset[0] = trafPosInMoof + sencPosInTraf + 16;
  353.     }
  355.     return shaka.util.BufferUtils.toUint8(isoFile.write());
  356.   }
  358.   /**
  359.    * This function returns the offset of the 1st byte of a child box within
  360.    * a container box.
  361.    *
  362.    * @param {ISOBox} parent
  363.    * @param {string} type
  364.    * @return {number}
  365.    * @private
  366.    */
  367.   getBoxOffset_(parent, type) {
  368.     let offset = 8;
  369.     for (let i = 0; i < parent.boxes.length; i++) {
  370.       if (parent.boxes[i].type === type) {
  371.         return offset;
  372.       }
  373.       offset += parent.boxes[i].size;
  374.     }
  375.     return offset;
  376.   }
  377. };
  379. /**
  380.  * @private {!Uint8Array}
  381.  */
  382. shaka.transmuxer.MssTransmuxer.UUID_SENC_ = new Uint8Array([
  383.   0xA2, 0x39, 0x4F, 0x52, 0x5A, 0x9B, 0x4F, 0x14,
  384.   0xA2, 0x44, 0x6C, 0x42, 0x7C, 0x64, 0x8D, 0xF4,
  385. ]);
  387. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  388.     'mss/audio/mp4',
  389.     () => new shaka.transmuxer.MssTransmuxer('mss/audio/mp4'),
  390.     shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK);
  391. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  392.     'mss/video/mp4',
  393.     () => new shaka.transmuxer.MssTransmuxer('mss/video/mp4'),
  394.     shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK);