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.util.BufferUtils');
  11. goog.require('shaka.util.Error');
  12. goog.require('shaka.util.IDestroyable');
  13. goog.require('shaka.util.ManifestParserUtils');
  14. goog.require('shaka.util.PublicPromise');
  15. goog.require('shaka.util.Uint8ArrayUtils');
  16. goog.require('shaka.dependencies');
  19. /**
  20.  * Transmuxer provides all operations for transmuxing from Transport
  21.  * Stream to MP4.
  22.  *
  23.  * @implements {shaka.util.IDestroyable}
  24.  */
  25. shaka.media.Transmuxer = class {
  26.   /** */
  27.   constructor() {
  28.     /** @private {?muxjs} */
  29.     this.muxjs_ = shaka.dependencies.muxjs();
  31.     /** @private {muxjs.mp4.Transmuxer} */
  32.     this.muxTransmuxer_ = null;
  34.     /** @private {shaka.util.PublicPromise} */
  35.     this.transmuxPromise_ = null;
  37.     /** @private {!Array.<!Uint8Array>} */
  38.     this.transmuxedData_ = [];
  40.     /** @private {!Array.<muxjs.mp4.ClosedCaption>} */
  41.     this.captions_ = [];
  43.     /** @private {!Array.<muxjs.mp4.Metadata>} */
  44.     this.metadata_ = [];
  46.     /** @private {boolean} */
  47.     this.isTransmuxing_ = false;
  49.     if (this.muxjs_) {
  50.       this.muxTransmuxer_ = new this.muxjs_.mp4.Transmuxer({
  51.         'keepOriginalTimestamps': true,
  52.       });
  53.       this.muxTransmuxer_.on('data', (segment) => this.onTransmuxed_(segment));
  54.       this.muxTransmuxer_.on('done', () => this.onTransmuxDone_());
  55.     }
  56.   }
  58.   /**
  59.    * @override
  60.    */
  61.   destroy() {
  62.     if (this.muxTransmuxer_) {
  63.       this.muxTransmuxer_.dispose();
  64.     }
  65.     this.muxTransmuxer_ = null;
  66.     return Promise.resolve();
  67.   }
  70.   /**
  71.    * Check if the content type is Transport Stream, and if muxjs is loaded.
  72.    * @param {string} mimeType
  73.    * @param {string=} contentType
  74.    * @return {boolean}
  75.    */
  76.   static isSupported(mimeType, contentType) {
  77.     const Transmuxer = shaka.media.Transmuxer;
  79.     if (!shaka.dependencies.muxjs() || !Transmuxer.isTsContainer(mimeType)) {
  80.       return false;
  81.     }
  83.     if (contentType) {
  84.       return MediaSource.isTypeSupported(
  85.           Transmuxer.convertTsCodecs(contentType, mimeType));
  86.     }
  88.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  90.     const audioMime = Transmuxer.convertTsCodecs(ContentType.AUDIO, mimeType);
  91.     const videoMime = Transmuxer.convertTsCodecs(ContentType.VIDEO, mimeType);
  92.     return MediaSource.isTypeSupported(audioMime) ||
  93.         MediaSource.isTypeSupported(videoMime);
  94.   }
  97.   /**
  98.    * Check if the mimetype contains 'mp2t'.
  99.    * @param {string} mimeType
  100.    * @return {boolean}
  101.    */
  102.   static isTsContainer(mimeType) {
  103.     return mimeType.toLowerCase().split(';')[0].split('/')[1] == 'mp2t';
  104.   }
  107.   /**
  108.    * For transport stream, convert its codecs to MP4 codecs.
  109.    * @param {string} contentType
  110.    * @param {string} tsMimeType
  111.    * @return {string}
  112.    */
  113.   static convertTsCodecs(contentType, tsMimeType) {
  114.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  115.     let mp4MimeType = tsMimeType.replace(/mp2t/i, 'mp4');
  116.     if (contentType == ContentType.AUDIO) {
  117.       mp4MimeType = mp4MimeType.replace('video', 'audio');
  118.     }
  120.     // Handle legacy AVC1 codec strings (pre-RFC 6381).
  121.     // Look for "avc1.<profile>.<level>", where profile is:
  122.     //   66 (baseline => 0x42)
  123.     //   77 (main => 0x4d)
  124.     //   100 (high => 0x64)
  125.     // Reference: https://bit.ly/2K9JI3x
  126.     const match = /avc1\.(66|77|100)\.(\d+)/.exec(mp4MimeType);
  127.     if (match) {
  128.       let newCodecString = 'avc1.';
  130.       const profile = match[1];
  131.       if (profile == '66') {
  132.         newCodecString += '4200';
  133.       } else if (profile == '77') {
  134.         newCodecString += '4d00';
  135.       } else {
  136.         goog.asserts.assert(profile == '100',
  137.             'Legacy avc1 parsing code out of sync with regex!');
  138.         newCodecString += '6400';
  139.       }
  141.       // Convert the level to hex and append to the codec string.
  142.       const level = Number(match[2]);
  143.       goog.asserts.assert(level < 256,
  144.           'Invalid legacy avc1 level number!');
  145.       newCodecString += (level >> 4).toString(16);
  146.       newCodecString += (level & 0xf).toString(16);
  148.       mp4MimeType = mp4MimeType.replace(match[0], newCodecString);
  149.     }
  151.     return mp4MimeType;
  152.   }
  155.   /**
  156.    * Transmux from Transport stream to MP4, using the mux.js library.
  157.    * @param {BufferSource} data
  158.    * @return {!Promise.<{data: !Uint8Array,
  159.    *                     captions: !Array.<!muxjs.mp4.ClosedCaption>,
  160.    *                     metadata: !Array.<!Object>}>}
  161.    */
  162.   transmux(data) {
  163.     goog.asserts.assert(this.muxTransmuxer_,
  164.         'mux.js should be available.');
  165.     goog.asserts.assert(!this.isTransmuxing_,
  166.         'No transmuxing should be in progress.');
  167.     this.isTransmuxing_ = true;
  168.     this.transmuxPromise_ = new shaka.util.PublicPromise();
  169.     this.transmuxedData_ = [];
  170.     this.captions_ = [];
  171.     this.metadata_ = [];
  173.     const dataArray = shaka.util.BufferUtils.toUint8(data);
  174.     this.muxTransmuxer_.push(dataArray);
  175.     this.muxTransmuxer_.flush();
  177.     // Workaround for https://bit.ly/Shaka1449 mux.js not
  178.     // emitting 'data' and 'done' events.
  179.     // mux.js code is synchronous, so if onTransmuxDone_ has
  180.     // not been called by now, it's not going to be.
  181.     // Treat it as a transmuxing failure and reject the promise.
  182.     if (this.isTransmuxing_) {
  183.       this.transmuxPromise_.reject(new shaka.util.Error(
  184.           shaka.util.Error.Severity.CRITICAL,
  185.           shaka.util.Error.Category.MEDIA,
  186.           shaka.util.Error.Code.TRANSMUXING_FAILED));
  187.     }
  188.     return this.transmuxPromise_;
  189.   }
  192.   /**
  193.    * Handles the 'data' event of the transmuxer.
  194.    * Extracts the cues from the transmuxed segment, and adds them to an array.
  195.    * Stores the transmuxed data in another array, to pass it back to
  196.    * MediaSourceEngine, and append to the source buffer.
  197.    *
  198.    * @param {muxjs.mp4.Transmuxer.Segment} segment
  199.    * @private
  200.    */
  201.   onTransmuxed_(segment) {
  202.     this.captions_ = segment.captions;
  203.     this.metadata_ = segment.metadata;
  204.     this.transmuxedData_.push(
  205.         shaka.util.Uint8ArrayUtils.concat(segment.initSegment, segment.data));
  206.   }
  209.   /**
  210.    * Handles the 'done' event of the transmuxer.
  211.    * Resolves the transmux Promise, and returns the transmuxed data.
  212.    * @private
  213.    */
  214.   onTransmuxDone_() {
  215.     const output = {
  216.       data: shaka.util.Uint8ArrayUtils.concat(...this.transmuxedData_),
  217.       captions: this.captions_,
  218.       metadata: this.metadata_,
  219.     };
  221.     this.transmuxPromise_.resolve(output);
  222.     this.isTransmuxing_ = false;
  223.   }
  224. };