Source: lib/transmuxer/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.TsTransmuxer');
  9. goog.require('shaka.media.Capabilities');
  10. goog.require('shaka.transmuxer.AacTransmuxer');
  11. goog.require('shaka.transmuxer.Ac3');
  12. goog.require('shaka.transmuxer.ADTS');
  13. goog.require('shaka.transmuxer.Ec3');
  14. goog.require('shaka.transmuxer.H264');
  15. goog.require('shaka.transmuxer.H265');
  16. goog.require('shaka.transmuxer.MpegAudio');
  17. goog.require('shaka.transmuxer.Opus');
  18. goog.require('shaka.transmuxer.TransmuxerEngine');
  19. goog.require('shaka.util.BufferUtils');
  20. goog.require('shaka.util.Error');
  21. goog.require('shaka.util.Id3Utils');
  22. goog.require('shaka.util.ManifestParserUtils');
  23. goog.require('shaka.util.MimeUtils');
  24. goog.require('shaka.util.Mp4Generator');
  25. goog.require('shaka.util.StreamUtils');
  26. goog.require('shaka.util.TsParser');
  27. goog.require('shaka.util.Uint8ArrayUtils');
  29. goog.requireType('shaka.media.SegmentReference');
  32. /**
  33.  * @implements {shaka.extern.Transmuxer}
  34.  * @export
  35.  */
  36. shaka.transmuxer.TsTransmuxer = class {
  37.   /**
  38.    * @param {string} mimeType
  39.    */
  40.   constructor(mimeType) {
  41.     /** @private {string} */
  42.     this.originalMimeType_ = mimeType;
  44.     /** @private {number} */
  45.     this.frameIndex_ = 0;
  47.     /** @private {!Map.<string, !Uint8Array>} */
  48.     this.initSegments = new Map();
  50.     /** @private {?shaka.util.TsParser} */
  51.     this.tsParser_ = null;
  53.     /** @private {?shaka.transmuxer.AacTransmuxer} */
  54.     this.aacTransmuxer_ = null;
  55.   }
  58.   /**
  59.    * @override
  60.    * @export
  61.    */
  62.   destroy() {
  63.     this.initSegments.clear();
  65.     if (this.aacTransmuxer_) {
  66.       this.aacTransmuxer_.destroy();
  67.     }
  68.   }
  71.   /**
  72.    * Check if the mime type and the content type is supported.
  73.    * @param {string} mimeType
  74.    * @param {string=} contentType
  75.    * @return {boolean}
  76.    * @override
  77.    * @export
  78.    */
  79.   isSupported(mimeType, contentType) {
  80.     const Capabilities = shaka.media.Capabilities;
  82.     if (!this.isTsContainer_(mimeType)) {
  83.       return false;
  84.     }
  86.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  87.     const MimeUtils = shaka.util.MimeUtils;
  89.     let convertedMimeType = mimeType;
  90.     if (contentType) {
  91.       convertedMimeType = this.convertCodecs(contentType, mimeType);
  92.     }
  93.     const codecs = MimeUtils.getCodecs(convertedMimeType);
  94.     const allCodecs = MimeUtils.splitCodecs(codecs);
  96.     const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  97.         ContentType.AUDIO, allCodecs);
  98.     const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  99.         ContentType.VIDEO, allCodecs);
  101.     const TsTransmuxer = shaka.transmuxer.TsTransmuxer;
  103.     if (audioCodec) {
  104.       const normalizedCodec = MimeUtils.getNormalizedCodec(audioCodec);
  105.       if (!TsTransmuxer.SUPPORTED_AUDIO_CODECS_.includes(normalizedCodec)) {
  106.         return false;
  107.       }
  108.     }
  110.     if (videoCodec) {
  111.       const normalizedCodec = MimeUtils.getNormalizedCodec(videoCodec);
  112.       if (!TsTransmuxer.SUPPORTED_VIDEO_CODECS_.includes(normalizedCodec)) {
  113.         return false;
  114.       }
  115.     }
  117.     if (contentType) {
  118.       return Capabilities.isTypeSupported(
  119.           this.convertCodecs(contentType, mimeType));
  120.     }
  122.     const audioMime = this.convertCodecs(ContentType.AUDIO, mimeType);
  123.     const videoMime = this.convertCodecs(ContentType.VIDEO, mimeType);
  124.     return Capabilities.isTypeSupported(audioMime) ||
  125.         Capabilities.isTypeSupported(videoMime);
  126.   }
  129.   /**
  130.    * Check if the mimetype is 'video/mp2t'.
  131.    * @param {string} mimeType
  132.    * @return {boolean}
  133.    * @private
  134.    */
  135.   isTsContainer_(mimeType) {
  136.     return mimeType.toLowerCase().split(';')[0] == 'video/mp2t';
  137.   }
  140.   /**
  141.    * @override
  142.    * @export
  143.    */
  144.   convertCodecs(contentType, mimeType) {
  145.     if (this.isTsContainer_(mimeType)) {
  146.       const ContentType = shaka.util.ManifestParserUtils.ContentType;
  147.       const StreamUtils = shaka.util.StreamUtils;
  148.       // The replace it's necessary because Firefox(the only browser that
  149.       // supports MP3 in MP4) only support the MP3 codec with the mp3 string.
  150.       // MediaSource.isTypeSupported('audio/mp4; codecs="mp4a.40.34"') -> false
  151.       // MediaSource.isTypeSupported('audio/mp4; codecs="mp3"') -> true
  152.       const codecs = shaka.util.MimeUtils.getCodecs(mimeType)
  153.           .replace('mp4a.40.34', 'mp3').split(',')
  154.           .map((codecs) => {
  155.             return StreamUtils.getCorrectAudioCodecs(codecs, 'audio/mp4');
  156.           })
  157.           .map(StreamUtils.getCorrectVideoCodecs).join(',');
  158.       if (contentType == ContentType.AUDIO) {
  159.         return `audio/mp4; codecs="${codecs}"`;
  160.       }
  161.       return `video/mp4; codecs="${codecs}"`;
  162.     }
  163.     return mimeType;
  164.   }
  167.   /**
  168.    * @override
  169.    * @export
  170.    */
  171.   getOriginalMimeType() {
  172.     return this.originalMimeType_;
  173.   }
  176.   /**
  177.    * @override
  178.    * @export
  179.    */
  180.   transmux(data, stream, reference, duration, contentType) {
  181.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  182.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  184.     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
  186.     if (contentType == ContentType.AUDIO &&
  187.         !shaka.util.TsParser.probe(uint8ArrayData)) {
  188.       const id3Data = shaka.util.Id3Utils.getID3Data(uint8ArrayData);
  189.       let offset = id3Data.length;
  190.       for (; offset < uint8ArrayData.length; offset++) {
  191.         if (shaka.transmuxer.MpegAudio.probe(uint8ArrayData, offset)) {
  192.           return Promise.reject(new shaka.util.Error(
  193.               shaka.util.Error.Severity.CRITICAL,
  194.               shaka.util.Error.Category.MEDIA,
  195.               shaka.util.Error.Code.TRANSMUXING_FAILED,
  196.               reference ? reference.getUris()[0] : null));
  197.         }
  198.       }
  199.       offset = id3Data.length;
  200.       for (; offset < uint8ArrayData.length; offset++) {
  201.         if (shaka.transmuxer.ADTS.probe(uint8ArrayData, offset)) {
  202.           if (!this.aacTransmuxer_) {
  203.             this.aacTransmuxer_ =
  204.                 new shaka.transmuxer.AacTransmuxer('audio/aac');
  205.           }
  206.           return this.aacTransmuxer_
  207.               .transmux(data, stream, reference, duration, contentType);
  208.         }
  209.       }
  210.       return Promise.reject(new shaka.util.Error(
  211.           shaka.util.Error.Severity.CRITICAL,
  212.           shaka.util.Error.Category.MEDIA,
  213.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  214.           reference ? reference.getUris()[0] : null));
  215.     }
  217.     if (!this.tsParser_) {
  218.       this.tsParser_ = new shaka.util.TsParser();
  219.     } else {
  220.       this.tsParser_.clearData();
  221.     }
  223.     const tsParser = this.tsParser_.parse(uint8ArrayData);
  224.     const streamInfos = [];
  225.     const codecs = tsParser.getCodecs();
  226.     try {
  227.       let streamInfo = null;
  228.       if (contentType == ContentType.VIDEO) {
  229.         switch (codecs.video) {
  230.           case 'avc':
  231.             streamInfo =
  232.               this.getAvcStreamInfo_(tsParser, stream, duration, reference);
  233.             break;
  234.           case 'hvc':
  235.             streamInfo =
  236.               this.getHvcStreamInfo_(tsParser, stream, duration, reference);
  237.             break;
  238.         }
  239.         if (streamInfo) {
  240.           streamInfos.push(streamInfo);
  241.           streamInfo = null;
  242.         }
  243.       }
  244.       if (contentType == ContentType.AUDIO) {
  245.         switch (codecs.audio) {
  246.           case 'aac':
  247.             streamInfo =
  248.               this.getAacStreamInfo_(tsParser, stream, duration, reference);
  249.             break;
  250.           case 'ac3':
  251.             streamInfo =
  252.               this.getAc3StreamInfo_(tsParser, stream, duration, reference);
  253.             break;
  254.           case 'ec3':
  255.             streamInfo =
  256.               this.getEc3StreamInfo_(tsParser, stream, duration, reference);
  257.             break;
  258.           case 'mp3':
  259.             streamInfo =
  260.               this.getMp3StreamInfo_(tsParser, stream, duration, reference);
  261.             break;
  262.           case 'opus':
  263.             streamInfo =
  264.               this.getOpusStreamInfo_(tsParser, stream, duration, reference);
  265.             break;
  266.         }
  267.         if (streamInfo) {
  268.           streamInfos.push(streamInfo);
  269.           streamInfo = null;
  270.         }
  271.       }
  272.     } catch (e) {
  273.       if (e && e.code == shaka.util.Error.Code.TRANSMUXING_NO_VIDEO_DATA) {
  274.         return Promise.resolve(new Uint8Array([]));
  275.       }
  276.       return Promise.reject(e);
  277.     }
  279.     if (!streamInfos.length) {
  280.       return Promise.reject(new shaka.util.Error(
  281.           shaka.util.Error.Severity.CRITICAL,
  282.           shaka.util.Error.Category.MEDIA,
  283.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  284.           reference ? reference.getUris()[0] : null));
  285.     }
  287.     const mp4Generator = new shaka.util.Mp4Generator(streamInfos);
  288.     let initSegment;
  289.     const initSegmentKey = stream.id + '_' + reference.discontinuitySequence;
  290.     if (!this.initSegments.has(initSegmentKey)) {
  291.       initSegment = mp4Generator.initSegment();
  292.       this.initSegments.set(initSegmentKey, initSegment);
  293.     } else {
  294.       initSegment = this.initSegments.get(initSegmentKey);
  295.     }
  296.     const segmentData = mp4Generator.segmentData();
  298.     this.frameIndex_++;
  299.     const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
  300.     return Promise.resolve(transmuxData);
  301.   }
  304.   /**
  305.    * @param {shaka.util.TsParser} tsParser
  306.    * @param {shaka.extern.Stream} stream
  307.    * @param {number} duration
  308.    * @param {?shaka.media.SegmentReference} reference
  309.    * @return {shaka.util.Mp4Generator.StreamInfo}
  310.    * @private
  311.    */
  312.   getAacStreamInfo_(tsParser, stream, duration, reference) {
  313.     const ADTS = shaka.transmuxer.ADTS;
  314.     const timescale = shaka.util.TsParser.Timescale;
  316.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  317.     const samples = [];
  319.     let info;
  321.     let firstPts = null;
  323.     for (const audioData of tsParser.getAudioData()) {
  324.       const data = audioData.data;
  325.       if (!data) {
  326.         continue;
  327.       }
  328.       let offset = 0;
  329.       info = ADTS.parseInfo(data, offset);
  330.       if (!info) {
  331.         throw new shaka.util.Error(
  332.             shaka.util.Error.Severity.CRITICAL,
  333.             shaka.util.Error.Category.MEDIA,
  334.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  335.             reference ? reference.getUris()[0] : null);
  336.       }
  337.       stream.audioSamplingRate = info.sampleRate;
  338.       stream.channelsCount = info.channelCount;
  339.       if (firstPts == null && audioData.pts !== null) {
  340.         firstPts = audioData.pts;
  341.       }
  342.       while (offset < data.length) {
  343.         const header = ADTS.parseHeader(data, offset);
  344.         if (!header) {
  345.           // We will increment one byte each time until we find the header.
  346.           offset++;
  347.           continue;
  348.         }
  349.         const length = header.headerLength + header.frameLength;
  350.         if (offset + length <= data.length) {
  351.           const frameData = data.subarray(
  352.               offset + header.headerLength, offset + length);
  354.           samples.push({
  355.             data: frameData,
  356.             size: header.frameLength,
  357.             duration: ADTS.AAC_SAMPLES_PER_FRAME,
  358.             cts: 0,
  359.             flags: {
  360.               isLeading: 0,
  361.               isDependedOn: 0,
  362.               hasRedundancy: 0,
  363.               degradPrio: 0,
  364.               dependsOn: 2,
  365.               isNonSync: 0,
  366.             },
  367.           });
  368.         }
  369.         offset += length;
  370.       }
  371.     }
  373.     if (!info || firstPts == null) {
  374.       if (!tsParser.getVideoData().length) {
  375.         throw new shaka.util.Error(
  376.             shaka.util.Error.Severity.CRITICAL,
  377.             shaka.util.Error.Category.MEDIA,
  378.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  379.             reference ? reference.getUris()[0] : null);
  380.       }
  382.       firstPts = reference.startTime * timescale;
  384.       const allCodecs = shaka.util.MimeUtils.splitCodecs(stream.codecs);
  385.       const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  386.           shaka.util.ManifestParserUtils.ContentType.AUDIO, allCodecs);
  387.       if (!audioCodec || !stream.channelsCount || !stream.audioSamplingRate) {
  388.         throw new shaka.util.Error(
  389.             shaka.util.Error.Severity.CRITICAL,
  390.             shaka.util.Error.Category.MEDIA,
  391.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  392.             reference ? reference.getUris()[0] : null);
  393.       }
  394.       info = {
  395.         sampleRate: stream.audioSamplingRate,
  396.         channelCount: stream.channelsCount,
  397.         codec: audioCodec,
  398.       };
  399.       const silenceFrame =
  400.           ADTS.getSilentFrame(audioCodec, stream.channelsCount);
  401.       if (!silenceFrame) {
  402.         throw new shaka.util.Error(
  403.             shaka.util.Error.Severity.CRITICAL,
  404.             shaka.util.Error.Category.MEDIA,
  405.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  406.             reference ? reference.getUris()[0] : null);
  407.       }
  408.       const segmentDuration =
  409.           (reference.endTime - reference.startTime) * timescale;
  410.       const finalPTs = firstPts + segmentDuration;
  411.       let currentPts = firstPts;
  412.       while (currentPts < finalPTs) {
  413.         samples.push({
  414.           data: silenceFrame,
  415.           size: silenceFrame.byteLength,
  416.           duration: ADTS.AAC_SAMPLES_PER_FRAME,
  417.           cts: 0,
  418.           flags: {
  419.             isLeading: 0,
  420.             isDependedOn: 0,
  421.             hasRedundancy: 0,
  422.             degradPrio: 0,
  423.             dependsOn: 2,
  424.             isNonSync: 0,
  425.           },
  426.         });
  427.         currentPts += ADTS.AAC_SAMPLES_PER_FRAME / info.sampleRate * timescale;
  428.       }
  429.     }
  431.     /** @type {number} */
  432.     const sampleRate = info.sampleRate;
  433.     /** @type {number} */
  434.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  436.     return {
  437.       id: stream.id,
  438.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  439.       codecs: info.codec,
  440.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  441.       timescale: sampleRate,
  442.       duration: duration,
  443.       videoNalus: [],
  444.       audioConfig: new Uint8Array([]),
  445.       videoConfig: new Uint8Array([]),
  446.       hSpacing: 0,
  447.       vSpacing: 0,
  448.       data: {
  449.         sequenceNumber: this.frameIndex_,
  450.         baseMediaDecodeTime: baseMediaDecodeTime,
  451.         samples: samples,
  452.       },
  453.       stream: stream,
  454.     };
  455.   }
  458.   /**
  459.    * @param {shaka.util.TsParser} tsParser
  460.    * @param {shaka.extern.Stream} stream
  461.    * @param {number} duration
  462.    * @param {?shaka.media.SegmentReference} reference
  463.    * @return {shaka.util.Mp4Generator.StreamInfo}
  464.    * @private
  465.    */
  466.   getAc3StreamInfo_(tsParser, stream, duration, reference) {
  467.     const Ac3 = shaka.transmuxer.Ac3;
  468.     const timescale = shaka.util.TsParser.Timescale;
  470.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  471.     const samples = [];
  473.     /** @type {number} */
  474.     let sampleRate = 0;
  476.     /** @type {!Uint8Array} */
  477.     let audioConfig = new Uint8Array([]);
  479.     let firstPts = null;
  481.     for (const audioData of tsParser.getAudioData()) {
  482.       const data = audioData.data;
  483.       if (firstPts == null && audioData.pts !== null) {
  484.         firstPts = audioData.pts;
  485.       }
  486.       let offset = 0;
  487.       while (offset < data.length) {
  488.         const frame = Ac3.parseFrame(data, offset);
  489.         if (!frame) {
  490.           offset++;
  491.           continue;
  492.         }
  493.         stream.audioSamplingRate = frame.sampleRate;
  494.         stream.channelsCount = frame.channelCount;
  495.         sampleRate = frame.sampleRate;
  496.         audioConfig = frame.audioConfig;
  498.         const frameData = data.subarray(
  499.             offset, offset + frame.frameLength);
  501.         samples.push({
  502.           data: frameData,
  503.           size: frame.frameLength,
  504.           duration: Ac3.AC3_SAMPLES_PER_FRAME,
  505.           cts: 0,
  506.           flags: {
  507.             isLeading: 0,
  508.             isDependedOn: 0,
  509.             hasRedundancy: 0,
  510.             degradPrio: 0,
  511.             dependsOn: 2,
  512.             isNonSync: 0,
  513.           },
  514.         });
  515.         offset += frame.frameLength;
  516.       }
  517.     }
  519.     if (sampleRate == 0 || audioConfig.byteLength == 0 || firstPts == null) {
  520.       throw new shaka.util.Error(
  521.           shaka.util.Error.Severity.CRITICAL,
  522.           shaka.util.Error.Category.MEDIA,
  523.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  524.           reference ? reference.getUris()[0] : null);
  525.     }
  528.     /** @type {number} */
  529.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  531.     return {
  532.       id: stream.id,
  533.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  534.       codecs: 'ac-3',
  535.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  536.       timescale: sampleRate,
  537.       duration: duration,
  538.       videoNalus: [],
  539.       audioConfig: audioConfig,
  540.       videoConfig: new Uint8Array([]),
  541.       hSpacing: 0,
  542.       vSpacing: 0,
  543.       data: {
  544.         sequenceNumber: this.frameIndex_,
  545.         baseMediaDecodeTime: baseMediaDecodeTime,
  546.         samples: samples,
  547.       },
  548.       stream: stream,
  549.     };
  550.   }
  553.   /**
  554.    * @param {shaka.util.TsParser} tsParser
  555.    * @param {shaka.extern.Stream} stream
  556.    * @param {number} duration
  557.    * @param {?shaka.media.SegmentReference} reference
  558.    * @return {shaka.util.Mp4Generator.StreamInfo}
  559.    * @private
  560.    */
  561.   getEc3StreamInfo_(tsParser, stream, duration, reference) {
  562.     const Ec3 = shaka.transmuxer.Ec3;
  563.     const timescale = shaka.util.TsParser.Timescale;
  565.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  566.     const samples = [];
  568.     /** @type {number} */
  569.     let sampleRate = 0;
  571.     /** @type {!Uint8Array} */
  572.     let audioConfig = new Uint8Array([]);
  574.     let firstPts = null;
  576.     for (const audioData of tsParser.getAudioData()) {
  577.       const data = audioData.data;
  578.       if (firstPts == null && audioData.pts !== null) {
  579.         firstPts = audioData.pts;
  580.       }
  581.       let offset = 0;
  582.       while (offset < data.length) {
  583.         const frame = Ec3.parseFrame(data, offset);
  584.         if (!frame) {
  585.           offset++;
  586.           continue;
  587.         }
  588.         stream.audioSamplingRate = frame.sampleRate;
  589.         stream.channelsCount = frame.channelCount;
  590.         sampleRate = frame.sampleRate;
  591.         audioConfig = frame.audioConfig;
  593.         const frameData = data.subarray(
  594.             offset, offset + frame.frameLength);
  596.         samples.push({
  597.           data: frameData,
  598.           size: frame.frameLength,
  599.           duration: Ec3.EC3_SAMPLES_PER_FRAME,
  600.           cts: 0,
  601.           flags: {
  602.             isLeading: 0,
  603.             isDependedOn: 0,
  604.             hasRedundancy: 0,
  605.             degradPrio: 0,
  606.             dependsOn: 2,
  607.             isNonSync: 0,
  608.           },
  609.         });
  610.         offset += frame.frameLength;
  611.       }
  612.     }
  614.     if (sampleRate == 0 || audioConfig.byteLength == 0 || firstPts == null) {
  615.       throw new shaka.util.Error(
  616.           shaka.util.Error.Severity.CRITICAL,
  617.           shaka.util.Error.Category.MEDIA,
  618.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  619.           reference ? reference.getUris()[0] : null);
  620.     }
  623.     /** @type {number} */
  624.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  626.     return {
  627.       id: stream.id,
  628.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  629.       codecs: 'ec-3',
  630.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  631.       timescale: sampleRate,
  632.       duration: duration,
  633.       videoNalus: [],
  634.       audioConfig: audioConfig,
  635.       videoConfig: new Uint8Array([]),
  636.       hSpacing: 0,
  637.       vSpacing: 0,
  638.       data: {
  639.         sequenceNumber: this.frameIndex_,
  640.         baseMediaDecodeTime: baseMediaDecodeTime,
  641.         samples: samples,
  642.       },
  643.       stream: stream,
  644.     };
  645.   }
  648.   /**
  649.    * @param {shaka.util.TsParser} tsParser
  650.    * @param {shaka.extern.Stream} stream
  651.    * @param {number} duration
  652.    * @param {?shaka.media.SegmentReference} reference
  653.    * @return {shaka.util.Mp4Generator.StreamInfo}
  654.    * @private
  655.    */
  656.   getMp3StreamInfo_(tsParser, stream, duration, reference) {
  657.     const MpegAudio = shaka.transmuxer.MpegAudio;
  658.     const timescale = shaka.util.TsParser.Timescale;
  660.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  661.     const samples = [];
  663.     let firstHeader;
  665.     let firstPts = null;
  667.     for (const audioData of tsParser.getAudioData()) {
  668.       const data = audioData.data;
  669.       if (!data) {
  670.         continue;
  671.       }
  672.       if (firstPts == null && audioData.pts !== null) {
  673.         firstPts = audioData.pts;
  674.       }
  675.       let offset = 0;
  676.       while (offset < data.length) {
  677.         const header = MpegAudio.parseHeader(data, offset);
  678.         if (!header) {
  679.           offset++;
  680.           continue;
  681.         }
  682.         if (!firstHeader) {
  683.           firstHeader = header;
  684.         }
  685.         if (offset + header.frameLength <= data.length) {
  686.           samples.push({
  687.             data: data.subarray(offset, offset + header.frameLength),
  688.             size: header.frameLength,
  689.             duration: MpegAudio.MPEG_AUDIO_SAMPLE_PER_FRAME,
  690.             cts: 0,
  691.             flags: {
  692.               isLeading: 0,
  693.               isDependedOn: 0,
  694.               hasRedundancy: 0,
  695.               degradPrio: 0,
  696.               dependsOn: 2,
  697.               isNonSync: 0,
  698.             },
  699.           });
  700.         }
  701.         offset += header.frameLength;
  702.       }
  703.     }
  704.     if (!firstHeader || firstPts == null) {
  705.       throw new shaka.util.Error(
  706.           shaka.util.Error.Severity.CRITICAL,
  707.           shaka.util.Error.Category.MEDIA,
  708.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  709.           reference ? reference.getUris()[0] : null);
  710.     }
  711.     /** @type {number} */
  712.     const sampleRate = firstHeader.sampleRate;
  713.     /** @type {number} */
  714.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  716.     return {
  717.       id: stream.id,
  718.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  719.       codecs: 'mp3',
  720.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  721.       timescale: sampleRate,
  722.       duration: duration,
  723.       videoNalus: [],
  724.       audioConfig: new Uint8Array([]),
  725.       videoConfig: new Uint8Array([]),
  726.       hSpacing: 0,
  727.       vSpacing: 0,
  728.       data: {
  729.         sequenceNumber: this.frameIndex_,
  730.         baseMediaDecodeTime: baseMediaDecodeTime,
  731.         samples: samples,
  732.       },
  733.       stream: stream,
  734.     };
  735.   }
  738.   /**
  739.    * @param {shaka.util.TsParser} tsParser
  740.    * @param {shaka.extern.Stream} stream
  741.    * @param {number} duration
  742.    * @param {?shaka.media.SegmentReference} reference
  743.    * @return {shaka.util.Mp4Generator.StreamInfo}
  744.    * @private
  745.    */
  746.   getOpusStreamInfo_(tsParser, stream, duration, reference) {
  747.     const Opus = shaka.transmuxer.Opus;
  748.     const timescale = shaka.util.TsParser.Timescale;
  750.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  751.     const samples = [];
  753.     let firstPts = null;
  755.     /** @type {?shaka.util.TsParser.OpusMetadata} */
  756.     const opusMetadata = tsParser.getOpusMetadata();
  758.     if (!opusMetadata) {
  759.       throw new shaka.util.Error(
  760.           shaka.util.Error.Severity.CRITICAL,
  761.           shaka.util.Error.Category.MEDIA,
  762.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  763.           reference ? reference.getUris()[0] : null);
  764.     }
  766.     /** @type {!Uint8Array} */
  767.     const audioConfig = Opus.getAudioConfig(opusMetadata);
  769.     /** @type {number} */
  770.     const sampleRate = opusMetadata.sampleRate;
  772.     for (const audioData of tsParser.getAudioData()) {
  773.       const data = audioData.data;
  774.       if (firstPts == null && audioData.pts !== null) {
  775.         firstPts = audioData.pts;
  776.       }
  777.       let offset = 0;
  778.       while (offset < data.length) {
  779.         const opusPendingTrimStart = (data[offset + 1] & 0x10) !== 0;
  780.         const trimEnd = (data[offset + 1] & 0x08) !== 0;
  781.         let index = offset + 2;
  782.         let size = 0;
  784.         while (data[index] === 0xFF) {
  785.           size += 255;
  786.           index += 1;
  787.         }
  788.         size += data[index];
  789.         index += 1;
  790.         index += opusPendingTrimStart ? 2 : 0;
  791.         index += trimEnd ? 2 : 0;
  793.         const sample = data.slice(index, index + size);
  795.         samples.push({
  796.           data: sample,
  797.           size: sample.byteLength,
  798.           duration: Opus.OPUS_AUDIO_SAMPLE_PER_FRAME,
  799.           cts: 0,
  800.           flags: {
  801.             isLeading: 0,
  802.             isDependedOn: 0,
  803.             hasRedundancy: 0,
  804.             degradPrio: 0,
  805.             dependsOn: 2,
  806.             isNonSync: 0,
  807.           },
  808.         });
  809.         offset = index + size;
  810.       }
  811.     }
  813.     if (audioConfig.byteLength == 0 || firstPts == null) {
  814.       throw new shaka.util.Error(
  815.           shaka.util.Error.Severity.CRITICAL,
  816.           shaka.util.Error.Category.MEDIA,
  817.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  818.           reference ? reference.getUris()[0] : null);
  819.     }
  821.     stream.audioSamplingRate = opusMetadata.sampleRate;
  822.     stream.channelsCount = opusMetadata.channelCount;
  825.     /** @type {number} */
  826.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  828.     return {
  829.       id: stream.id,
  830.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  831.       codecs: 'opus',
  832.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  833.       timescale: sampleRate,
  834.       duration: duration,
  835.       videoNalus: [],
  836.       audioConfig: audioConfig,
  837.       videoConfig: new Uint8Array([]),
  838.       hSpacing: 0,
  839.       vSpacing: 0,
  840.       data: {
  841.         sequenceNumber: this.frameIndex_,
  842.         baseMediaDecodeTime: baseMediaDecodeTime,
  843.         samples: samples,
  844.       },
  845.       stream: stream,
  846.     };
  847.   }
  850.   /**
  851.    * @param {shaka.util.TsParser} tsParser
  852.    * @param {shaka.extern.Stream} stream
  853.    * @param {number} duration
  854.    * @param {?shaka.media.SegmentReference} reference
  855.    * @return {shaka.util.Mp4Generator.StreamInfo}
  856.    * @private
  857.    */
  858.   getAvcStreamInfo_(tsParser, stream, duration, reference) {
  859.     const H264 = shaka.transmuxer.H264;
  860.     const timescale = shaka.util.TsParser.Timescale;
  862.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  863.     const samples = [];
  865.     /** @type {?number} */
  866.     let baseMediaDecodeTime = null;
  868.     const nalus = [];
  869.     const videoData = tsParser.getVideoData();
  870.     if (!videoData.length) {
  871.       throw new shaka.util.Error(
  872.           shaka.util.Error.Severity.CRITICAL,
  873.           shaka.util.Error.Category.MEDIA,
  874.           shaka.util.Error.Code.TRANSMUXING_NO_VIDEO_DATA,
  875.           reference ? reference.getUris()[0] : null);
  876.     }
  877.     for (let i = 0; i < videoData.length; i++) {
  878.       const pes = videoData[i];
  879.       const dataNalus = pes.nalus;
  880.       nalus.push(...dataNalus);
  881.       const frame = H264.parseFrame(dataNalus);
  882.       if (!frame) {
  883.         continue;
  884.       }
  885.       if (baseMediaDecodeTime == null) {
  886.         baseMediaDecodeTime = pes.dts;
  887.       }
  888.       let duration;
  889.       if (i + 1 < videoData.length) {
  890.         duration = (videoData[i + 1].dts || 0) - (pes.dts || 0);
  891.       } else if (videoData.length > 1) {
  892.         duration = (pes.dts || 0) - (videoData[i - 1].dts || 0);
  893.       } else {
  894.         duration = (reference.endTime - reference.startTime) * timescale;
  895.       }
  896.       samples.push({
  897.         data: frame.data,
  898.         size: frame.data.byteLength,
  899.         duration: duration,
  900.         cts: Math.round((pes.pts || 0) - (pes.dts || 0)),
  901.         flags: {
  902.           isLeading: 0,
  903.           isDependedOn: 0,
  904.           hasRedundancy: 0,
  905.           degradPrio: 0,
  906.           dependsOn: frame.isKeyframe ? 2 : 1,
  907.           isNonSync: frame.isKeyframe ? 0 : 1,
  908.         },
  909.       });
  910.     }
  912.     const info = H264.parseInfo(nalus);
  914.     if (!info || baseMediaDecodeTime == null) {
  915.       throw new shaka.util.Error(
  916.           shaka.util.Error.Severity.CRITICAL,
  917.           shaka.util.Error.Category.MEDIA,
  918.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  919.           reference ? reference.getUris()[0] : null);
  920.     }
  921.     stream.height = info.height;
  922.     stream.width = info.width;
  924.     return {
  925.       id: stream.id,
  926.       type: shaka.util.ManifestParserUtils.ContentType.VIDEO,
  927.       codecs: 'avc1',
  928.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  929.       timescale: timescale,
  930.       duration: duration,
  931.       videoNalus: [],
  932.       audioConfig: new Uint8Array([]),
  933.       videoConfig: info.videoConfig,
  934.       hSpacing: info.hSpacing,
  935.       vSpacing: info.vSpacing,
  936.       data: {
  937.         sequenceNumber: this.frameIndex_,
  938.         baseMediaDecodeTime: baseMediaDecodeTime,
  939.         samples: samples,
  940.       },
  941.       stream: stream,
  942.     };
  943.   }
  946.   /**
  947.    * @param {shaka.util.TsParser} tsParser
  948.    * @param {shaka.extern.Stream} stream
  949.    * @param {number} duration
  950.    * @param {?shaka.media.SegmentReference} reference
  951.    * @return {shaka.util.Mp4Generator.StreamInfo}
  952.    * @private
  953.    */
  954.   getHvcStreamInfo_(tsParser, stream, duration, reference) {
  955.     const H265 = shaka.transmuxer.H265;
  956.     const timescale = shaka.util.TsParser.Timescale;
  958.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  959.     const samples = [];
  961.     /** @type {?number} */
  962.     let baseMediaDecodeTime = null;
  964.     const nalus = [];
  965.     const videoData = tsParser.getVideoData();
  966.     if (!videoData.length) {
  967.       throw new shaka.util.Error(
  968.           shaka.util.Error.Severity.CRITICAL,
  969.           shaka.util.Error.Category.MEDIA,
  970.           shaka.util.Error.Code.TRANSMUXING_NO_VIDEO_DATA,
  971.           reference ? reference.getUris()[0] : null);
  972.     }
  973.     for (let i = 0; i < videoData.length; i++) {
  974.       const pes = videoData[i];
  975.       const dataNalus = pes.nalus;
  976.       nalus.push(...dataNalus);
  977.       const frame = H265.parseFrame(dataNalus);
  978.       if (!frame) {
  979.         continue;
  980.       }
  981.       if (baseMediaDecodeTime == null && pes.dts != null) {
  982.         baseMediaDecodeTime = pes.dts;
  983.       }
  984.       let duration;
  985.       if (i + 1 < videoData.length) {
  986.         duration = (videoData[i + 1].dts || 0) - (pes.dts || 0);
  987.       } else if (videoData.length > 1) {
  988.         duration = (pes.dts || 0) - (videoData[i - 1].dts || 0);
  989.       } else {
  990.         duration = (reference.endTime - reference.startTime) * timescale;
  991.       }
  992.       samples.push({
  993.         data: frame.data,
  994.         size: frame.data.byteLength,
  995.         duration: duration,
  996.         cts: Math.round((pes.pts || 0) - (pes.dts || 0)),
  997.         flags: {
  998.           isLeading: 0,
  999.           isDependedOn: 0,
  1000.           hasRedundancy: 0,
  1001.           degradPrio: 0,
  1002.           dependsOn: frame.isKeyframe ? 2 : 1,
  1003.           isNonSync: frame.isKeyframe ? 0 : 1,
  1004.         },
  1005.       });
  1006.     }
  1008.     const info = H265.parseInfo(nalus);
  1010.     if (!info || baseMediaDecodeTime == null) {
  1011.       throw new shaka.util.Error(
  1012.           shaka.util.Error.Severity.CRITICAL,
  1013.           shaka.util.Error.Category.MEDIA,
  1014.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  1015.           reference ? reference.getUris()[0] : null);
  1016.     }
  1017.     stream.height = info.height;
  1018.     stream.width = info.width;
  1020.     return {
  1021.       id: stream.id,
  1022.       type: shaka.util.ManifestParserUtils.ContentType.VIDEO,
  1023.       codecs: 'hvc1',
  1024.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  1025.       timescale: timescale,
  1026.       duration: duration,
  1027.       videoNalus: [],
  1028.       audioConfig: new Uint8Array([]),
  1029.       videoConfig: info.videoConfig,
  1030.       hSpacing: info.hSpacing,
  1031.       vSpacing: info.vSpacing,
  1032.       data: {
  1033.         sequenceNumber: this.frameIndex_,
  1034.         baseMediaDecodeTime: baseMediaDecodeTime,
  1035.         samples: samples,
  1036.       },
  1037.       stream: stream,
  1038.     };
  1039.   }
  1040. };
  1042. /**
  1043.  * Supported audio codecs.
  1044.  *
  1045.  * @private
  1046.  * @const {!Array.<string>}
  1047.  */
  1048. shaka.transmuxer.TsTransmuxer.SUPPORTED_AUDIO_CODECS_ = [
  1049.   'aac',
  1050.   'ac-3',
  1051.   'ec-3',
  1052.   'mp3',
  1053.   'opus',
  1054. ];
  1056. /**
  1057.  * Supported audio codecs.
  1058.  *
  1059.  * @private
  1060.  * @const {!Array.<string>}
  1061.  */
  1062. shaka.transmuxer.TsTransmuxer.SUPPORTED_VIDEO_CODECS_ = [
  1063.   'avc',
  1064.   'hevc',
  1065. ];
  1068. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  1069.     'video/mp2t',
  1070.     () => new shaka.transmuxer.TsTransmuxer('video/mp2t'),
  1071.     shaka.transmuxer.TransmuxerEngine.PluginPriority.PREFERRED);