Source: lib/transmuxer/mpeg_ts_transmuxer.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.transmuxer.MpegTsTransmuxer');
  9. goog.require('shaka.media.Capabilities');
  10. goog.require('shaka.transmuxer.MpegAudio');
  11. goog.require('shaka.transmuxer.TransmuxerEngine');
  12. goog.require('shaka.util.BufferUtils');
  13. goog.require('shaka.util.Error');
  14. goog.require('shaka.util.ManifestParserUtils');
  15. goog.require('shaka.util.MimeUtils');
  16. goog.require('shaka.util.TsParser');
  17. goog.require('shaka.util.Uint8ArrayUtils');
  19. /**
  20.  * @fileoverview
  21.  *
  22.  * This transmuxer takes an audio-only TS with MP3, and converts it to
  23.  * raw MP3(audio/mpeg). We don't do it in ts_transmuxer.js because the
  24.  * output of it is always MP4. This transmuxer is necessary because the only
  25.  * browser that supports MP3 in MP4 is Firefox(audio/mp4; codecs="mp3"),
  26.  * other browsers don't support it.
  27.  */
  29. /**
  30.  * @implements {shaka.extern.Transmuxer}
  31.  * @export
  32.  */
  33. shaka.transmuxer.MpegTsTransmuxer = class {
  34.   /**
  35.    * @param {string} mimeType
  36.    */
  37.   constructor(mimeType) {
  38.     /** @private {string} */
  39.     this.originalMimeType_ = mimeType;
  41.     /** @private {?shaka.util.TsParser} */
  42.     this.tsParser_ = null;
  43.   }
  46.   /**
  47.    * @override
  48.    * @export
  49.    */
  50.   destroy() {
  51.     // Nothing
  52.   }
  55.   /**
  56.    * Check if the mime type and the content type is supported.
  57.    * @param {string} mimeType
  58.    * @param {string=} contentType
  59.    * @return {boolean}
  60.    * @override
  61.    * @export
  62.    */
  63.   isSupported(mimeType, contentType) {
  64.     const Capabilities = shaka.media.Capabilities;
  66.     if (!this.isTsContainer_(mimeType)) {
  67.       return false;
  68.     }
  70.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  71.     const MimeUtils = shaka.util.MimeUtils;
  73.     const codecs = MimeUtils.getCodecs(mimeType);
  74.     const allCodecs = MimeUtils.splitCodecs(codecs);
  76.     const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  77.         ContentType.AUDIO, allCodecs);
  78.     const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  79.         ContentType.VIDEO, allCodecs);
  81.     if (!audioCodec || videoCodec) {
  82.       return false;
  83.     }
  84.     const normalizedCodec = MimeUtils.getNormalizedCodec(audioCodec);
  86.     if (normalizedCodec != 'mp3') {
  87.       return false;
  88.     }
  90.     return Capabilities.isTypeSupported(
  91.         this.convertCodecs(ContentType.AUDIO, mimeType));
  92.   }
  95.   /**
  96.    * Check if the mimetype is 'video/mp2t'.
  97.    * @param {string} mimeType
  98.    * @return {boolean}
  99.    * @private
  100.    */
  101.   isTsContainer_(mimeType) {
  102.     return mimeType.toLowerCase().split(';')[0] == 'video/mp2t';
  103.   }
  106.   /**
  107.    * @override
  108.    * @export
  109.    */
  110.   convertCodecs(contentType, mimeType) {
  111.     if (this.isTsContainer_(mimeType)) {
  112.       return 'audio/mpeg';
  113.     }
  114.     return mimeType;
  115.   }
  118.   /**
  119.    * @override
  120.    * @export
  121.    */
  122.   getOriginalMimeType() {
  123.     return this.originalMimeType_;
  124.   }
  127.   /**
  128.    * @override
  129.    * @export
  130.    */
  131.   transmux(data, stream, reference, duration, contentType) {
  132.     const MpegAudio = shaka.transmuxer.MpegAudio;
  133.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  134.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  136.     if (!this.tsParser_) {
  137.       this.tsParser_ = new shaka.util.TsParser();
  138.     } else {
  139.       this.tsParser_.clearData();
  140.     }
  142.     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
  144.     const tsParser = this.tsParser_.parse(uint8ArrayData);
  145.     const codecs = tsParser.getCodecs();
  146.     if (codecs.audio != 'mp3' || contentType != ContentType.AUDIO) {
  147.       return Promise.reject(new shaka.util.Error(
  148.           shaka.util.Error.Severity.CRITICAL,
  149.           shaka.util.Error.Category.MEDIA,
  150.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  151.           reference ? reference.getUris()[0] : null));
  152.     }
  154.     let transmuxData = new Uint8Array([]);
  156.     for (const audioData of tsParser.getAudioData()) {
  157.       const data = audioData.data;
  158.       if (!data) {
  159.         continue;
  160.       }
  161.       let offset = 0;
  162.       while (offset < data.length) {
  163.         const header = MpegAudio.parseHeader(data, offset);
  164.         if (!header) {
  165.           offset++;
  166.           continue;
  167.         }
  168.         if (offset + header.frameLength <= data.length) {
  169.           transmuxData = Uint8ArrayUtils.concat(transmuxData,
  170.               data.subarray(offset, offset + header.frameLength));
  171.         }
  172.         offset += header.frameLength;
  173.       }
  174.     }
  176.     return Promise.resolve(transmuxData);
  177.   }
  178. };
  181. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  182.     'video/mp2t',
  183.     () => new shaka.transmuxer.MpegTsTransmuxer('video/mp2t'),
  184.     shaka.transmuxer.TransmuxerEngine.PluginPriority.PREFERRED_SECONDARY);