Source: lib/media/transmuxer.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.media.Transmuxer');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.util.Error');
  22. goog.require('shaka.util.IDestroyable');
  23. goog.require('shaka.util.ManifestParserUtils');
  24. goog.require('shaka.util.PublicPromise');
  25. goog.require('shaka.util.Uint8ArrayUtils');
  28. /**
  29.  * Transmuxer provides all operations for transmuxing from Transport
  30.  * Stream to MP4.
  31.  *
  32.  * @struct
  33.  * @constructor
  34.  * @implements {shaka.util.IDestroyable}
  35.  */
  36. shaka.media.Transmuxer = function() {
  37.   /** @private {muxjs.mp4.Transmuxer} */
  38.   this.muxTransmuxer_ = new muxjs.mp4.Transmuxer({
  39.     'keepOriginalTimestamps': true,
  40.   });
  42.   /** @private {shaka.util.PublicPromise} */
  43.   this.transmuxPromise_ = null;
  45.   /** @private {!Array.<!Uint8Array>} */
  46.   this.transmuxedData_ = [];
  48.   /** @private {!Array.<muxjs.mp4.ClosedCaption>} */
  49.   this.captions_ = [];
  51.   /** @private {boolean} */
  52.   this.isTransmuxing_ = false;
  54.   this.muxTransmuxer_.on('data', this.onTransmuxed_.bind(this));
  56.   this.muxTransmuxer_.on('done', this.onTransmuxDone_.bind(this));
  57. };
  60. /**
  61.  * @override
  62.  */
  63. shaka.media.Transmuxer.prototype.destroy = function() {
  64.   this.muxTransmuxer_.dispose();
  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. shaka.media.Transmuxer.isSupported = function(mimeType, contentType) {
  77.   if (!window.muxjs || !shaka.media.Transmuxer.isTsContainer(mimeType)) {
  78.     return false;
  79.   }
  80.   let convertTsCodecs = shaka.media.Transmuxer.convertTsCodecs;
  81.   if (contentType) {
  82.     return MediaSource.isTypeSupported(convertTsCodecs(contentType, mimeType));
  83.   }
  84.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  85.   return MediaSource.isTypeSupported(
  86.              convertTsCodecs(ContentType.AUDIO, mimeType)) ||
  87.       MediaSource.isTypeSupported(convertTsCodecs(ContentType.VIDEO, mimeType));
  88. };
  91. /**
  92.  * Check if the mimetype contains 'mp2t'.
  93.  * @param {string} mimeType
  94.  * @return {boolean}
  95.  */
  96. shaka.media.Transmuxer.isTsContainer = function(mimeType) {
  97.   return mimeType.toLowerCase().split(';')[0].split('/')[1] == 'mp2t';
  98. };
  101. /**
  102.  * For transport stream, convert its codecs to MP4 codecs.
  103.  * @param {string} contentType
  104.  * @param {string} tsMimeType
  105.  * @return {string}
  106.  */
  107. shaka.media.Transmuxer.convertTsCodecs = function(contentType, tsMimeType) {
  108.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  109.   let mp4MimeType = tsMimeType.replace(/mp2t/i, 'mp4');
  110.   if (contentType == ContentType.AUDIO) {
  111.     mp4MimeType = mp4MimeType.replace('video', 'audio');
  112.   }
  114.   // Handle legacy AVC1 codec strings (pre-RFC 6381).
  115.   // Look for "avc1.<profile>.<level>", where profile is:
  116.   //   66 (baseline => 0x42)
  117.   //   77 (main => 0x4d)
  118.   //   100 (high => 0x64)
  119.   // Reference: https://bit.ly/2K9JI3x
  120.   let match = /avc1\.(66|77|100)\.(\d+)/.exec(mp4MimeType);
  121.   if (match) {
  122.     let newCodecString = 'avc1.';
  124.     let profile = match[1];
  125.     if (profile == '66') {
  126.       newCodecString += '4200';
  127.     } else if (profile == '77') {
  128.       newCodecString += '4d00';
  129.     } else {
  130.       goog.asserts.assert(profile == '100',
  131.                           'Legacy avc1 parsing code out of sync with regex!');
  132.       newCodecString += '6400';
  133.     }
  135.     // Convert the level to hex and append to the codec string.
  136.     let level = Number(match[2]);
  137.     goog.asserts.assert(level < 256,
  138.                         'Invalid legacy avc1 level number!');
  139.     newCodecString += (level >> 4).toString(16);
  140.     newCodecString += (level & 0xf).toString(16);
  142.     mp4MimeType = mp4MimeType.replace(match[0], newCodecString);
  143.   }
  145.   return mp4MimeType;
  146. };
  149. /**
  150.  * Transmux from Transport stream to MP4, using the mux.js library.
  151.  * @param {!ArrayBuffer} data
  152.  * @return {!Promise.<{data: !Uint8Array,
  153.  *                     captions: !Array.<!muxjs.mp4.ClosedCaption>}>}
  154.  */
  155. shaka.media.Transmuxer.prototype.transmux = function(data) {
  156.   goog.asserts.assert(!this.isTransmuxing_,
  157.       'No transmuxing should be in progress.');
  158.   this.isTransmuxing_ = true;
  159.   this.transmuxPromise_ = new shaka.util.PublicPromise();
  160.   this.transmuxedData_ = [];
  161.   this.captions_ = [];
  163.   let dataArray = new Uint8Array(data);
  164.   this.muxTransmuxer_.push(dataArray);
  165.   this.muxTransmuxer_.flush();
  167.   // Workaround for https://bit.ly/Shaka1449 mux.js not
  168.   // emitting 'data' and 'done' events.
  169.   // mux.js code is synchronous, so if onTransmuxDone_ has
  170.   // not been called by now, it's not going to be.
  171.   // Treat it as a transmuxing failure and reject the promise.
  172.   if (this.isTransmuxing_) {
  173.     this.transmuxPromise_.reject(new shaka.util.Error(
  174.             shaka.util.Error.Severity.CRITICAL,
  175.             shaka.util.Error.Category.MEDIA,
  176.             shaka.util.Error.Code.TRANSMUXING_FAILED));
  177.   }
  178.   return this.transmuxPromise_;
  179. };
  182. /**
  183.  * Handles the 'data' event of the transmuxer.
  184.  * Extracts the cues from the transmuxed segment, and adds them to an array.
  185.  * Stores the transmuxed data in another array, to pass it back to
  186.  * MediaSourceEngine, and append to the source buffer.
  187.  *
  188.  * @param {muxjs.mp4.Transmuxer.Segment} segment
  189.  * @private
  190.  */
  191. shaka.media.Transmuxer.prototype.onTransmuxed_ = function(segment) {
  192.   this.captions_ = segment.captions;
  193.   let segmentWithInit = new Uint8Array(segment.data.byteLength +
  194.       segment.initSegment.byteLength);
  195.   segmentWithInit.set(segment.initSegment, 0);
  196.   segmentWithInit.set(segment.data, segment.initSegment.byteLength);
  197.   this.transmuxedData_.push(segmentWithInit);
  198. };
  201. /**
  202.  * Handles the 'done' event of the transmuxer.
  203.  * Resolves the transmux Promise, and returns the transmuxed data.
  204.  * @private
  205.  */
  206. shaka.media.Transmuxer.prototype.onTransmuxDone_ = function() {
  207.   let output = {
  208.     data: shaka.util.Uint8ArrayUtils.concat.apply(null, this.transmuxedData_),
  209.     captions: this.captions_,
  210.   };
  212.   this.transmuxPromise_.resolve(output);
  213.   this.isTransmuxing_ = false;
  214. };