Source: lib/transmuxer/aac_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.AacTransmuxer');
  9. goog.require('shaka.media.Capabilities');
  10. goog.require('shaka.transmuxer.ADTS');
  11. goog.require('shaka.transmuxer.Mp4Generator');
  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.MimeUtils');
  18. goog.require('shaka.util.Uint8ArrayUtils');
  21. /**
  22.  * @implements {shaka.extern.Transmuxer}
  23.  * @export
  24.  */
  25. shaka.transmuxer.AacTransmuxer = 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.isAacContainer_(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/aac'.
  75.    * @param {string} mimeType
  76.    * @return {boolean}
  77.    * @private
  78.    */
  79.   isAacContainer_(mimeType) {
  80.     return mimeType.toLowerCase().split(';')[0] == 'audio/aac';
  81.   }
  84.   /**
  85.    * @override
  86.    * @export
  87.    */
  88.   convertCodecs(contentType, mimeType) {
  89.     if (this.isAacContainer_(mimeType)) {
  90.       const codecs = shaka.util.MimeUtils.getCodecs(mimeType);
  91.       return `audio/mp4; codecs="${codecs || 'mp4a.40.2'}"`;
  92.     }
  93.     return mimeType;
  94.   }
  97.   /**
  98.    * @override
  99.    * @export
  100.    */
  101.   getOriginalMimeType() {
  102.     return this.originalMimeType_;
  103.   }
  106.   /**
  107.    * @override
  108.    * @export
  109.    */
  110.   transmux(data, stream, reference, duration) {
  111.     const ADTS = shaka.transmuxer.ADTS;
  112.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  114.     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
  116.     // Check for the ADTS sync word
  117.     // Look for ADTS header | 1111 1111 | 1111 X00X | where X can be
  118.     // either 0 or 1
  119.     // Layer bits (position 14 and 15) in header should be always 0 for ADTS
  120.     // More info https://wiki.multimedia.cx/index.php?title=ADTS
  121.     const id3Data = shaka.util.Id3Utils.getID3Data(uint8ArrayData);
  122.     let offset = id3Data.length;
  123.     for (; offset < uint8ArrayData.length; offset++) {
  124.       if (ADTS.probe(uint8ArrayData, offset)) {
  125.         break;
  126.       }
  127.     }
  129.     let timestamp = reference.endTime * 1000;
  131.     const frames = shaka.util.Id3Utils.getID3Frames(id3Data);
  132.     if (frames.length && reference) {
  133.       const metadataTimestamp = frames.find((frame) => {
  134.         return frame.description ===
  135.             'com.apple.streaming.transportStreamTimestamp';
  136.       });
  137.       if (metadataTimestamp) {
  138.         timestamp = /** @type {!number} */(metadataTimestamp.data);
  139.       }
  140.     }
  142.     const info = ADTS.parseInfo(uint8ArrayData, offset);
  143.     if (!info) {
  144.       return Promise.reject(new shaka.util.Error(
  145.           shaka.util.Error.Severity.CRITICAL,
  146.           shaka.util.Error.Category.MEDIA,
  147.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  148.           reference ? reference.getUris()[0] : null));
  149.     }
  150.     stream.audioSamplingRate = info.sampleRate;
  151.     stream.channelsCount = info.channelCount;
  153.     /** @type {!Array<shaka.transmuxer.Mp4Generator.Mp4Sample>} */
  154.     const samples = [];
  156.     while (offset < uint8ArrayData.length) {
  157.       const header = ADTS.parseHeader(uint8ArrayData, offset);
  158.       if (!header) {
  159.         return Promise.reject(new shaka.util.Error(
  160.             shaka.util.Error.Severity.CRITICAL,
  161.             shaka.util.Error.Category.MEDIA,
  162.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  163.             reference ? reference.getUris()[0] : null));
  164.       }
  165.       const length = header.headerLength + header.frameLength;
  166.       if (offset + length <= uint8ArrayData.length) {
  167.         const data = uint8ArrayData.subarray(
  168.             offset + header.headerLength, offset + length);
  169.         samples.push({
  170.           data: data,
  171.           size: header.frameLength,
  172.           duration: ADTS.AAC_SAMPLES_PER_FRAME,
  173.           cts: 0,
  174.           flags: {
  175.             isLeading: 0,
  176.             isDependedOn: 0,
  177.             hasRedundancy: 0,
  178.             degradPrio: 0,
  179.             dependsOn: 2,
  180.             isNonSync: 0,
  181.           },
  182.         });
  183.       }
  184.       offset += length;
  185.     }
  187.     /** @type {number} */
  188.     const sampleRate = info.sampleRate;
  189.     /** @type {number} */
  190.     const baseMediaDecodeTime = Math.floor(timestamp * sampleRate / 1000);
  192.     /** @type {shaka.transmuxer.Mp4Generator.StreamInfo} */
  193.     const streamInfo = {
  194.       id: stream.id,
  195.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  196.       codecs: info.codec,
  197.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  198.       timescale: sampleRate,
  199.       duration: duration,
  200.       videoNalus: [],
  201.       audioConfig: new Uint8Array([]),
  202.       videoConfig: new Uint8Array([]),
  203.       hSpacing: 0,
  204.       vSpacing: 0,
  205.       data: {
  206.         sequenceNumber: this.frameIndex_,
  207.         baseMediaDecodeTime: baseMediaDecodeTime,
  208.         samples: samples,
  209.       },
  210.       stream: stream,
  211.     };
  212.     const mp4Generator = new shaka.transmuxer.Mp4Generator([streamInfo]);
  213.     let initSegment;
  214.     const initSegmentKey = stream.id + '_' + reference.discontinuitySequence;
  215.     if (!this.initSegments.has(initSegmentKey)) {
  216.       initSegment = mp4Generator.initSegment();
  217.       this.initSegments.set(initSegmentKey, initSegment);
  218.     } else {
  219.       initSegment = this.initSegments.get(initSegmentKey);
  220.     }
  221.     const appendInitSegment = this.lastInitSegment_ !== initSegment;
  222.     const segmentData = mp4Generator.segmentData();
  223.     this.lastInitSegment_ = initSegment;
  224.     this.frameIndex_++;
  225.     if (appendInitSegment) {
  226.       const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
  227.       return Promise.resolve(transmuxData);
  228.     } else {
  229.       return Promise.resolve(segmentData);
  230.     }
  231.   }
  232. };
  234. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  235.     'audio/aac',
  236.     () => new shaka.transmuxer.AacTransmuxer('audio/aac'),
  237.     shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK);