Source: lib/media/transmuxer.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.Transmuxer');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.media.Capabilities');
  11. goog.require('shaka.util.BufferUtils');
  12. goog.require('shaka.util.Error');
  13. goog.require('shaka.util.IDestroyable');
  14. goog.require('shaka.util.ManifestParserUtils');
  15. goog.require('shaka.util.PublicPromise');
  16. goog.require('shaka.util.Uint8ArrayUtils');
  17. goog.require('shaka.dependencies');
  20. /**
  21.  * Transmuxer provides all operations for transmuxing from Transport
  22.  * Stream or AAC to MP4.
  23.  *
  24.  * @implements {shaka.util.IDestroyable}
  25.  */
  26. shaka.media.Transmuxer = class {
  27.   /**
  28.    * @param {string} mimeType
  29.    */
  30.   constructor(mimeType) {
  31.     /** @private {string} */
  32.     this.originalMimeType_ = mimeType;
  34.     /** @private {?muxjs} */
  35.     this.muxjs_ = shaka.dependencies.muxjs();
  37.     /** @private {muxjs.mp4.Transmuxer} */
  38.     this.muxTransmuxer_ = null;
  40.     /** @private {shaka.util.PublicPromise} */
  41.     this.transmuxPromise_ = null;
  43.     /** @private {!Array.<!Uint8Array>} */
  44.     this.transmuxedData_ = [];
  46.     /** @private {!Array.<muxjs.mp4.ClosedCaption>} */
  47.     this.captions_ = [];
  49.     /** @private {boolean} */
  50.     this.isTransmuxing_ = false;
  52.     if (this.muxjs_) {
  53.       this.muxTransmuxer_ = new this.muxjs_.mp4.Transmuxer({
  54.         'keepOriginalTimestamps': true,
  55.       });
  56.       this.muxTransmuxer_.on('data', (segment) => this.onTransmuxed_(segment));
  57.       this.muxTransmuxer_.on('done', () => this.onTransmuxDone_());
  58.     }
  59.   }
  61.   /**
  62.    * @override
  63.    */
  64.   destroy() {
  65.     if (this.muxTransmuxer_) {
  66.       this.muxTransmuxer_.dispose();
  67.     }
  68.     this.muxTransmuxer_ = null;
  69.     return Promise.resolve();
  70.   }
  73.   /**
  74.    * Check if the content type is Transport Stream or AAC, and if muxjs is
  75.    * loaded.
  76.    * @param {string} mimeType
  77.    * @param {string=} contentType
  78.    * @return {boolean}
  79.    */
  80.   static isSupported(mimeType, contentType) {
  81.     const Transmuxer = shaka.media.Transmuxer;
  82.     const Capabilities = shaka.media.Capabilities;
  84.     const isTs = Transmuxer.isTsContainer_(mimeType);
  85.     const isAac = Transmuxer.isAacContainer_(mimeType);
  87.     if (!shaka.dependencies.muxjs() || (!isTs && !isAac)) {
  88.       return false;
  89.     }
  91.     if (isAac) {
  92.       return Capabilities.isTypeSupported(Transmuxer.convertAacCodecs_());
  93.     }
  95.     if (contentType) {
  96.       return Capabilities.isTypeSupported(
  97.           Transmuxer.convertTsCodecs_(contentType, mimeType));
  98.     }
  100.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  102.     const audioMime = Transmuxer.convertTsCodecs_(ContentType.AUDIO, mimeType);
  103.     const videoMime = Transmuxer.convertTsCodecs_(ContentType.VIDEO, mimeType);
  104.     return Capabilities.isTypeSupported(audioMime) ||
  105.         Capabilities.isTypeSupported(videoMime);
  106.   }
  109.   /**
  110.    * Check if the mimetype is 'audio/aac'.
  111.    * @param {string} mimeType
  112.    * @return {boolean}
  113.    * @private
  114.    */
  115.   static isAacContainer_(mimeType) {
  116.     return mimeType.toLowerCase().split(';')[0] == 'audio/aac';
  117.   }
  120.   /**
  121.    * Check if the mimetype contains 'mp2t'.
  122.    * @param {string} mimeType
  123.    * @return {boolean}
  124.    * @private
  125.    */
  126.   static isTsContainer_(mimeType) {
  127.     return mimeType.toLowerCase().split(';')[0].split('/')[1] == 'mp2t';
  128.   }
  131.   /**
  132.    * For any stream, convert its codecs to MP4 codecs.
  133.    * @param {string} contentType
  134.    * @param {string} mimeType
  135.    * @return {string}
  136.    */
  137.   static convertCodecs(contentType, mimeType) {
  138.     const Transmuxer = shaka.media.Transmuxer;
  139.     if (Transmuxer.isAacContainer_(mimeType)) {
  140.       return Transmuxer.convertAacCodecs_();
  141.     } else if (Transmuxer.isTsContainer_(mimeType)) {
  142.       return Transmuxer.convertTsCodecs_(contentType, mimeType);
  143.     }
  144.     return mimeType;
  145.   }
  148.   /**
  149.    * For aac stream, convert its codecs to MP4 codecs.
  150.    * @return {string}
  151.    * @private
  152.    */
  153.   static convertAacCodecs_() {
  154.     return 'audio/mp4; codecs="mp4a.40.2"';
  155.   }
  158.   /**
  159.    * For transport stream, convert its codecs to MP4 codecs.
  160.    * @param {string} contentType
  161.    * @param {string} tsMimeType
  162.    * @return {string}
  163.    * @private
  164.    */
  165.   static convertTsCodecs_(contentType, tsMimeType) {
  166.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  167.     let mp4MimeType = tsMimeType.replace(/mp2t/i, 'mp4');
  168.     if (contentType == ContentType.AUDIO) {
  169.       mp4MimeType = mp4MimeType.replace('video', 'audio');
  170.     }
  172.     // Handle legacy AVC1 codec strings (pre-RFC 6381).
  173.     // Look for "avc1.<profile>.<level>", where profile is:
  174.     //   66 (baseline => 0x42)
  175.     //   77 (main => 0x4d)
  176.     //   100 (high => 0x64)
  177.     // Reference: https://bit.ly/2K9JI3x
  178.     const match = /avc1\.(66|77|100)\.(\d+)/.exec(mp4MimeType);
  179.     if (match) {
  180.       let newCodecString = 'avc1.';
  182.       const profile = match[1];
  183.       if (profile == '66') {
  184.         newCodecString += '4200';
  185.       } else if (profile == '77') {
  186.         newCodecString += '4d00';
  187.       } else {
  188.         goog.asserts.assert(profile == '100',
  189.             'Legacy avc1 parsing code out of sync with regex!');
  190.         newCodecString += '6400';
  191.       }
  193.       // Convert the level to hex and append to the codec string.
  194.       const level = Number(match[2]);
  195.       goog.asserts.assert(level < 256,
  196.           'Invalid legacy avc1 level number!');
  197.       newCodecString += (level >> 4).toString(16);
  198.       newCodecString += (level & 0xf).toString(16);
  200.       mp4MimeType = mp4MimeType.replace(match[0], newCodecString);
  201.     }
  203.     return mp4MimeType;
  204.   }
  207.   /**
  208.    * Returns the original mimetype of the transmuxer.
  209.    * @return {string}
  210.    */
  211.   getOriginalMimeType() {
  212.     return this.originalMimeType_;
  213.   }
  216.   /**
  217.    * Transmux from Transport stream to MP4, using the mux.js library.
  218.    * @param {BufferSource} data
  219.    * @return {!Promise.<{data: !Uint8Array,
  220.    *                     captions: !Array.<!muxjs.mp4.ClosedCaption>}>}
  221.    */
  222.   transmux(data) {
  223.     goog.asserts.assert(this.muxTransmuxer_,
  224.         'mux.js should be available.');
  225.     goog.asserts.assert(!this.isTransmuxing_,
  226.         'No transmuxing should be in progress.');
  227.     this.isTransmuxing_ = true;
  228.     this.transmuxPromise_ = new shaka.util.PublicPromise();
  229.     this.transmuxedData_ = [];
  230.     this.captions_ = [];
  232.     const dataArray = shaka.util.BufferUtils.toUint8(data);
  233.     this.muxTransmuxer_.push(dataArray);
  234.     this.muxTransmuxer_.flush();
  236.     // Workaround for https://bit.ly/Shaka1449 mux.js not
  237.     // emitting 'data' and 'done' events.
  238.     // mux.js code is synchronous, so if onTransmuxDone_ has
  239.     // not been called by now, it's not going to be.
  240.     // Treat it as a transmuxing failure and reject the promise.
  241.     if (this.isTransmuxing_) {
  242.       this.transmuxPromise_.reject(new shaka.util.Error(
  243.           shaka.util.Error.Severity.CRITICAL,
  244.           shaka.util.Error.Category.MEDIA,
  245.           shaka.util.Error.Code.TRANSMUXING_FAILED));
  246.     }
  247.     return this.transmuxPromise_;
  248.   }
  250.   /**
  251.    * Reset captions from Transport stream to MP4, using the mux.js library.
  252.   */
  253.   resetCaptions() {
  254.     this.muxTransmuxer_.resetCaptions();
  255.   }
  257.   /**
  258.    * Handles the 'data' event of the transmuxer.
  259.    * Extracts the cues from the transmuxed segment, and adds them to an array.
  260.    * Stores the transmuxed data in another array, to pass it back to
  261.    * MediaSourceEngine, and append to the source buffer.
  262.    *
  263.    * @param {muxjs.mp4.Transmuxer.Segment} segment
  264.    * @private
  265.    */
  266.   onTransmuxed_(segment) {
  267.     this.captions_ = segment.captions;
  268.     this.transmuxedData_.push(
  269.         shaka.util.Uint8ArrayUtils.concat(segment.initSegment, segment.data));
  270.   }
  273.   /**
  274.    * Handles the 'done' event of the transmuxer.
  275.    * Resolves the transmux Promise, and returns the transmuxed data.
  276.    * @private
  277.    */
  278.   onTransmuxDone_() {
  279.     const output = {
  280.       data: shaka.util.Uint8ArrayUtils.concat(...this.transmuxedData_),
  281.       captions: this.captions_,
  282.     };
  284.     this.transmuxPromise_.resolve(output);
  285.     this.isTransmuxing_ = false;
  286.   }
  287. };