Source: lib/transmuxer/ac3_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.Ac3Transmuxer');
  9. goog.require('shaka.device.DeviceFactory');
  10. goog.require('shaka.media.Capabilities');
  11. goog.require('shaka.transmuxer.Ac3');
  12. goog.require('shaka.transmuxer.TransmuxerEngine');
  13. goog.require('shaka.util.BufferUtils');
  14. goog.require('shaka.util.Error');
  15. goog.require('shaka.util.Id3Utils');
  16. goog.require('shaka.util.ManifestParserUtils');
  17. goog.require('shaka.util.Mp4Generator');
  18. goog.require('shaka.util.Uint8ArrayUtils');
  21. /**
  22.  * @implements {shaka.extern.Transmuxer}
  23.  * @export
  24.  */
  25. shaka.transmuxer.Ac3Transmuxer = class {
  26.   /**
  27.    * @param {string} mimeType
  28.    */
  29.   constructor(mimeType) {
  30.     /** @private {string} */
  31.     this.originalMimeType_ = mimeType;
  33.     /** @private {number} */
  34.     this.frameIndex_ = 0;
  36.     /** @private {!Map<string, !Uint8Array>} */
  37.     this.initSegments = new Map();
  39.     /** @private {?Uint8Array} */
  40.     this.lastInitSegment_ = null;
  41.   }
  44.   /**
  45.    * @override
  46.    * @export
  47.    */
  48.   destroy() {
  49.     this.initSegments.clear();
  50.   }
  53.   /**
  54.    * Check if the mime type and the content type is supported.
  55.    * @param {string} mimeType
  56.    * @param {string=} contentType
  57.    * @return {boolean}
  58.    * @override
  59.    * @export
  60.    */
  61.   isSupported(mimeType, contentType) {
  62.     const Capabilities = shaka.media.Capabilities;
  64.     if (!this.isAc3Container_(mimeType)) {
  65.       return false;
  66.     }
  67.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  68.     return Capabilities.isTypeSupported(
  69.         this.convertCodecs(ContentType.AUDIO, mimeType));
  70.   }
  73.   /**
  74.    * Check if the mimetype is 'audio/ac3'.
  75.    * @param {string} mimeType
  76.    * @return {boolean}
  77.    * @private
  78.    */
  79.   isAc3Container_(mimeType) {
  80.     return mimeType.toLowerCase().split(';')[0] == 'audio/ac3';
  81.   }
  84.   /**
  85.    * @override
  86.    * @export
  87.    */
  88.   convertCodecs(contentType, mimeType) {
  89.     if (this.isAc3Container_(mimeType)) {
  90.       const device = shaka.device.DeviceFactory.getDevice();
  91.       if (device.requiresEC3InitSegments()) {
  92.         return 'audio/mp4; codecs="ec-3"';
  93.       } else {
  94.         return 'audio/mp4; codecs="ac-3"';
  95.       }
  96.     }
  97.     return mimeType;
  98.   }
  101.   /**
  102.    * @override
  103.    * @export
  104.    */
  105.   getOriginalMimeType() {
  106.     return this.originalMimeType_;
  107.   }
  110.   /**
  111.    * @override
  112.    * @export
  113.    */
  114.   transmux(data, stream, reference, duration) {
  115.     const Ac3 = shaka.transmuxer.Ac3;
  116.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  118.     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
  120.     const id3Data = shaka.util.Id3Utils.getID3Data(uint8ArrayData);
  121.     let offset = id3Data.length;
  122.     for (; offset < uint8ArrayData.length; offset++) {
  123.       if (Ac3.probe(uint8ArrayData, offset)) {
  124.         break;
  125.       }
  126.     }
  128.     let timestamp = reference.endTime * 1000;
  130.     const frames = shaka.util.Id3Utils.getID3Frames(id3Data);
  131.     if (frames.length && reference) {
  132.       const metadataTimestamp = frames.find((frame) => {
  133.         return frame.description ===
  134.             'com.apple.streaming.transportStreamTimestamp';
  135.       });
  136.       if (metadataTimestamp) {
  137.         timestamp = /** @type {!number} */(metadataTimestamp.data);
  138.       }
  139.     }
  141.     /** @type {number} */
  142.     let sampleRate = 0;
  144.     /** @type {!Uint8Array} */
  145.     let audioConfig = new Uint8Array([]);
  147.     /** @type {!Array<shaka.util.Mp4Generator.Mp4Sample>} */
  148.     const samples = [];
  150.     while (offset < uint8ArrayData.length) {
  151.       const frame = Ac3.parseFrame(uint8ArrayData, offset);
  152.       if (!frame) {
  153.         return Promise.reject(new shaka.util.Error(
  154.             shaka.util.Error.Severity.CRITICAL,
  155.             shaka.util.Error.Category.MEDIA,
  156.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  157.             reference ? reference.getUris()[0] : null));
  158.       }
  159.       stream.audioSamplingRate = frame.sampleRate;
  160.       stream.channelsCount = frame.channelCount;
  161.       sampleRate = frame.sampleRate;
  162.       audioConfig = frame.audioConfig;
  164.       const frameData = uint8ArrayData.subarray(
  165.           offset, offset + frame.frameLength);
  167.       samples.push({
  168.         data: frameData,
  169.         size: frame.frameLength,
  170.         duration: Ac3.AC3_SAMPLES_PER_FRAME,
  171.         cts: 0,
  172.         flags: {
  173.           isLeading: 0,
  174.           isDependedOn: 0,
  175.           hasRedundancy: 0,
  176.           degradPrio: 0,
  177.           dependsOn: 2,
  178.           isNonSync: 0,
  179.         },
  180.       });
  181.       offset += frame.frameLength;
  182.     }
  183.     /** @type {number} */
  184.     const baseMediaDecodeTime = Math.floor(timestamp * sampleRate / 1000);
  186.     /** @type {shaka.util.Mp4Generator.StreamInfo} */
  187.     const streamInfo = {
  188.       id: stream.id,
  189.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  190.       codecs: 'ac-3',
  191.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  192.       timescale: sampleRate,
  193.       duration: duration,
  194.       videoNalus: [],
  195.       audioConfig: audioConfig,
  196.       videoConfig: new Uint8Array([]),
  197.       hSpacing: 0,
  198.       vSpacing: 0,
  199.       data: {
  200.         sequenceNumber: this.frameIndex_,
  201.         baseMediaDecodeTime: baseMediaDecodeTime,
  202.         samples: samples,
  203.       },
  204.       stream: stream,
  205.     };
  206.     const mp4Generator = new shaka.util.Mp4Generator([streamInfo]);
  207.     let initSegment;
  208.     const initSegmentKey = stream.id + '_' + reference.discontinuitySequence;
  209.     if (!this.initSegments.has(initSegmentKey)) {
  210.       initSegment = mp4Generator.initSegment();
  211.       this.initSegments.set(initSegmentKey, initSegment);
  212.     } else {
  213.       initSegment = this.initSegments.get(initSegmentKey);
  214.     }
  215.     const appendInitSegment = this.lastInitSegment_ !== initSegment;
  216.     const segmentData = mp4Generator.segmentData();
  217.     this.lastInitSegment_ = initSegment;
  218.     this.frameIndex_++;
  219.     if (appendInitSegment) {
  220.       const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
  221.       return Promise.resolve(transmuxData);
  222.     } else {
  223.       return Promise.resolve(segmentData);
  224.     }
  225.   }
  226. };
  228. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  229.     'audio/ac3',
  230.     () => new shaka.transmuxer.Ac3Transmuxer('audio/ac3'),
  231.     shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK);