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.text.Cue');
  22. goog.require('shaka.util.Error');
  23. goog.require('shaka.util.IDestroyable');
  24. goog.require('shaka.util.ManifestParserUtils');
  25. goog.require('shaka.util.PublicPromise');
  26. goog.require('shaka.util.Uint8ArrayUtils');
  30. /**
  31.  * Transmuxer provides all operations for transmuxing from Transport
  32.  * Stream to MP4.
  33.  *
  34.  * @struct
  35.  * @constructor
  36.  * @implements {shaka.util.IDestroyable}
  37.  */
  38. shaka.media.Transmuxer = function() {
  39.   /** @private {muxjs.mp4.Transmuxer} */
  40.   this.muxTransmuxer_ = new muxjs.mp4.Transmuxer({
  41.     'keepOriginalTimestamps': true
  42.   });
  44.   /** @private {shaka.util.PublicPromise} */
  45.   this.transmuxPromise_ = null;
  47.   /** @private {!Array} */
  48.   this.transmuxedData_ = [];
  50.   /** @private {!Array.<shaka.text.Cue>} */
  51.   this.cues_ = [];
  53.   /** @private {boolean} */
  54.   this.isTransmuxing_ = false;
  56.   this.muxTransmuxer_.on('data', this.onTransmuxed_.bind(this));
  58.   this.muxTransmuxer_.on('done', this.onTransmuxDone_.bind(this));
  59. };
  62. /**
  63.  * @override
  64.  */
  65. shaka.media.Transmuxer.prototype.destroy = function() {
  66.   this.muxTransmuxer_.dispose();
  67.   this.muxTransmuxer_ = null;
  68.   return Promise.resolve();
  69. };
  72. /**
  73.  * Check if the content type is Transport Stream, and if muxjs is loaded.
  74.  * @param {string} mimeType
  75.  * @param {string=} contentType
  76.  * @return {boolean}
  77.  */
  78. shaka.media.Transmuxer.isSupported = function(mimeType, contentType) {
  79.   if (!window.muxjs || !shaka.media.Transmuxer.isTsContainer(mimeType)) {
  80.     return false;
  81.   }
  82.   let convertTsCodecs = shaka.media.Transmuxer.convertTsCodecs;
  83.   if (contentType) {
  84.     return MediaSource.isTypeSupported(convertTsCodecs(contentType, mimeType));
  85.   }
  86.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  87.   return MediaSource.isTypeSupported(
  88.              convertTsCodecs(ContentType.AUDIO, mimeType)) ||
  89.       MediaSource.isTypeSupported(convertTsCodecs(ContentType.VIDEO, mimeType));
  90. };
  93. /**
  94.  * Check if the mimetype contains 'mp2t'.
  95.  * @param {string} mimeType
  96.  * @return {boolean}
  97.  */
  98. shaka.media.Transmuxer.isTsContainer = function(mimeType) {
  99.   return mimeType.split(';')[0].split('/')[1] == 'mp2t';
  100. };
  103. /**
  104.  * For transport stream, convert its codecs to MP4 codecs.
  105.  * @param {string} contentType
  106.  * @param {string} tsMimeType
  107.  * @return {string}
  108.  */
  109. shaka.media.Transmuxer.convertTsCodecs = function(contentType, tsMimeType) {
  110.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  111.   let mp4MimeType = tsMimeType.replace('mp2t', 'mp4');
  112.   if (contentType == ContentType.AUDIO) {
  113.     mp4MimeType = mp4MimeType.replace('video', 'audio');
  114.   }
  116.   // Handle legacy AVC1 codec strings (pre-RFC 6381).
  117.   // Look for "avc1.<profile>.<level>", where profile is:
  118.   //   66 (baseline => 0x42)
  119.   //   77 (main => 0x4d)
  120.   //   100 (high => 0x64)
  121.   // Reference: https://goo.gl/ofyyqN
  122.   let match = /avc1\.(66|77|100)\.(\d+)/.exec(mp4MimeType);
  123.   if (match) {
  124.     let newCodecString = 'avc1.';
  126.     let profile = match[1];
  127.     if (profile == '66') {
  128.       newCodecString += '4200';
  129.     } else if (profile == '77') {
  130.       newCodecString += '4d00';
  131.     } else {
  132.       goog.asserts.assert(profile == '100',
  133.                           'Legacy avc1 parsing code out of sync with regex!');
  134.       newCodecString += '6400';
  135.     }
  137.     // Convert the level to hex and append to the codec string.
  138.     let level = Number(match[2]);
  139.     goog.asserts.assert(level < 256,
  140.                         'Invalid legacy avc1 level number!');
  141.     newCodecString += (level >> 4).toString(16);
  142.     newCodecString += (level & 0xf).toString(16);
  144.     mp4MimeType = mp4MimeType.replace(match[0], newCodecString);
  145.   }
  147.   return mp4MimeType;
  148. };
  151. /**
  152.  * Transmux from Transport stream to MP4, using the mux.js library.
  153.  * @param {!ArrayBuffer} data
  154.  * @return {!Promise.<{data: !Uint8Array, cues: !Array.<!shaka.text.Cue>}>}
  155.  */
  156. shaka.media.Transmuxer.prototype.transmux = function(data) {
  157.   goog.asserts.assert(!this.isTransmuxing_,
  158.       'No transmuxing should be in progress.');
  159.   this.isTransmuxing_ = true;
  160.   this.transmuxPromise_ = new shaka.util.PublicPromise();
  161.   this.transmuxedData_ = [];
  162.   this.cues_ = [];
  164.   let dataArray = new Uint8Array(data);
  165.   this.muxTransmuxer_.push(dataArray);
  166.   this.muxTransmuxer_.flush();
  168.   // Workaround for https://goo.gl/Q2ob1E: mux.js not
  169.   // emitting 'data' and 'done' events.
  170.   // mux.js code is synchronous, so if onTransmuxDone_ has
  171.   // not been called by now, it's not going to be.
  172.   // Treat it as a transmuxing failure and reject the promise.
  173.   if (this.isTransmuxing_) {
  174.     this.transmuxPromise_.reject(new shaka.util.Error(
  175.             shaka.util.Error.Severity.CRITICAL,
  176.             shaka.util.Error.Category.MEDIA,
  177.             shaka.util.Error.Code.TRANSMUXING_FAILED));
  178.   }
  179.   return this.transmuxPromise_;
  180. };
  183. /**
  184.  * Handles the 'data' event of the transmuxer.
  185.  * Extracts the cues from the transmuxed segment, and adds them to an array.
  186.  * Stores the transmuxed data in another array, to pass it back to
  187.  * MediaSourceEngine, and append to the source buffer.
  188.  *
  189.  * @param {muxjs.mp4.Transmuxer.Segment} segment
  190.  * @private
  191.  */
  192. shaka.media.Transmuxer.prototype.onTransmuxed_ = function(segment) {
  193.   for (let i = 0; i < segment.captions.length; i++) {
  194.     let cue = segment.captions[i];
  195.     this.cues_.push(
  196.         new shaka.text.Cue(cue.startTime, cue.endTime, cue.text));
  197.   }
  199.   let segmentWithInit = new Uint8Array(segment.data.byteLength +
  200.       segment.initSegment.byteLength);
  201.   segmentWithInit.set(segment.initSegment, 0);
  202.   segmentWithInit.set(segment.data, segment.initSegment.byteLength);
  203.   this.transmuxedData_.push(segmentWithInit);
  204. };
  207. /**
  208.  * Handles the 'done' event of the transmuxer.
  209.  * Resolves the transmux Promise, and returns the transmuxed data.
  210.  * @private
  211.  */
  212. shaka.media.Transmuxer.prototype.onTransmuxDone_ = function() {
  213.   let output = {
  214.     data: shaka.util.Uint8ArrayUtils.concat.apply(null, this.transmuxedData_),
  215.     cues: this.cues_
  216.   };
  218.   this.transmuxPromise_.resolve(output);
  219.   this.isTransmuxing_ = false;
  220. };