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;
  56.     /** @private {?Uint8Array} */
  57.     this.lastInitSegment_ = null;
  58.   }
  61.   /**
  62.    * @override
  63.    * @export
  64.    */
  65.   destroy() {
  66.     this.initSegments.clear();
  68.     if (this.aacTransmuxer_) {
  69.       this.aacTransmuxer_.destroy();
  70.     }
  71.   }
  74.   /**
  75.    * Check if the mime type and the content type is supported.
  76.    * @param {string} mimeType
  77.    * @param {string=} contentType
  78.    * @return {boolean}
  79.    * @override
  80.    * @export
  81.    */
  82.   isSupported(mimeType, contentType) {
  83.     const Capabilities = shaka.media.Capabilities;
  85.     if (!this.isTsContainer_(mimeType)) {
  86.       return false;
  87.     }
  89.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  90.     const MimeUtils = shaka.util.MimeUtils;
  92.     let convertedMimeType = mimeType;
  93.     if (contentType) {
  94.       convertedMimeType = this.convertCodecs(contentType, mimeType);
  95.     }
  96.     const codecs = MimeUtils.getCodecs(convertedMimeType);
  97.     const allCodecs = MimeUtils.splitCodecs(codecs);
  99.     const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  100.         ContentType.AUDIO, allCodecs);
  101.     const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  102.         ContentType.VIDEO, allCodecs);
  104.     const TsTransmuxer = shaka.transmuxer.TsTransmuxer;
  106.     if (audioCodec) {
  107.       const normalizedCodec = MimeUtils.getNormalizedCodec(audioCodec);
  108.       if (!TsTransmuxer.SUPPORTED_AUDIO_CODECS_.includes(normalizedCodec)) {
  109.         return false;
  110.       }
  111.     }
  113.     if (videoCodec) {
  114.       const normalizedCodec = MimeUtils.getNormalizedCodec(videoCodec);
  115.       if (!TsTransmuxer.SUPPORTED_VIDEO_CODECS_.includes(normalizedCodec)) {
  116.         return false;
  117.       }
  118.     }
  120.     if (contentType) {
  121.       return Capabilities.isTypeSupported(
  122.           this.convertCodecs(contentType, mimeType));
  123.     }
  125.     const audioMime = this.convertCodecs(ContentType.AUDIO, mimeType);
  126.     const videoMime = this.convertCodecs(ContentType.VIDEO, mimeType);
  127.     return Capabilities.isTypeSupported(audioMime) ||
  128.         Capabilities.isTypeSupported(videoMime);
  129.   }
  132.   /**
  133.    * Check if the mimetype is 'video/mp2t'.
  134.    * @param {string} mimeType
  135.    * @return {boolean}
  136.    * @private
  137.    */
  138.   isTsContainer_(mimeType) {
  139.     return mimeType.toLowerCase().split(';')[0] == 'video/mp2t';
  140.   }
  143.   /**
  144.    * @override
  145.    * @export
  146.    */
  147.   convertCodecs(contentType, mimeType) {
  148.     if (this.isTsContainer_(mimeType)) {
  149.       const ContentType = shaka.util.ManifestParserUtils.ContentType;
  150.       const StreamUtils = shaka.util.StreamUtils;
  151.       // The replace it's necessary because Firefox(the only browser that
  152.       // supports MP3 in MP4) only support the MP3 codec with the mp3 string.
  153.       // MediaSource.isTypeSupported('audio/mp4; codecs="mp4a.40.34"') -> false
  154.       // MediaSource.isTypeSupported('audio/mp4; codecs="mp3"') -> true
  155.       const codecs = shaka.util.MimeUtils.getCodecs(mimeType)
  156.           .replace('mp4a.40.34', 'mp3').split(',')
  157.           .map((codecs) => {
  158.             return StreamUtils.getCorrectAudioCodecs(codecs, 'audio/mp4');
  159.           })
  160.           .map(StreamUtils.getCorrectVideoCodecs).join(',');
  161.       if (contentType == ContentType.AUDIO) {
  162.         return `audio/mp4; codecs="${codecs}"`;
  163.       }
  164.       return `video/mp4; codecs="${codecs}"`;
  165.     }
  166.     return mimeType;
  167.   }
  170.   /**
  171.    * @override
  172.    * @export
  173.    */
  174.   getOriginalMimeType() {
  175.     return this.originalMimeType_;
  176.   }
  179.   /**
  180.    * @override
  181.    * @export
  182.    */
  183.   transmux(data, stream, reference, duration, contentType) {
  184.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  185.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  187.     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
  189.     if (contentType == ContentType.AUDIO &&
  190.         !shaka.util.TsParser.probe(uint8ArrayData)) {
  191.       const id3Data = shaka.util.Id3Utils.getID3Data(uint8ArrayData);
  192.       let offset = id3Data.length;
  193.       for (; offset < uint8ArrayData.length; offset++) {
  194.         if (shaka.transmuxer.MpegAudio.probe(uint8ArrayData, offset)) {
  195.           return Promise.reject(new shaka.util.Error(
  196.               shaka.util.Error.Severity.CRITICAL,
  197.               shaka.util.Error.Category.MEDIA,
  198.               shaka.util.Error.Code.TRANSMUXING_FAILED,
  199.               reference ? reference.getUris()[0] : null));
  200.         }
  201.       }
  202.       offset = id3Data.length;
  203.       for (; offset < uint8ArrayData.length; offset++) {
  204.         if (shaka.transmuxer.ADTS.probe(uint8ArrayData, offset)) {
  205.           if (!this.aacTransmuxer_) {
  206.             this.aacTransmuxer_ =
  207.                 new shaka.transmuxer.AacTransmuxer('audio/aac');
  208.           }
  209.           return this.aacTransmuxer_
  210.               .transmux(data, stream, reference, duration, contentType);
  211.         }
  212.       }
  213.       return Promise.reject(new shaka.util.Error(
  214.           shaka.util.Error.Severity.CRITICAL,
  215.           shaka.util.Error.Category.MEDIA,
  216.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  217.           reference ? reference.getUris()[0] : null));
  218.     }
  220.     if (!this.tsParser_) {
  221.       this.tsParser_ = new shaka.util.TsParser();
  222.     } else {
  223.       this.tsParser_.clearData();
  224.     }
  225.     this.tsParser_.setDiscontinuitySequence(reference.discontinuitySequence);
  227.     const tsParser = this.tsParser_.parse(uint8ArrayData);
  228.     const streamInfos = [];
  229.     const codecs = tsParser.getCodecs();
  230.     try {
  231.       let streamInfo = null;
  232.       if (contentType == ContentType.VIDEO) {
  233.         switch (codecs.video) {
  234.           case 'avc':
  235.             streamInfo =
  236.               this.getAvcStreamInfo_(tsParser, stream, duration, reference);
  237.             break;
  238.           case 'hvc':
  239.             streamInfo =
  240.               this.getHvcStreamInfo_(tsParser, stream, duration, reference);
  241.             break;
  242.         }
  243.         if (streamInfo) {
  244.           streamInfos.push(streamInfo);
  245.           streamInfo = null;
  246.         }
  247.       }
  248.       if (contentType == ContentType.AUDIO) {
  249.         switch (codecs.audio) {
  250.           case 'aac':
  251.             streamInfo =
  252.               this.getAacStreamInfo_(tsParser, stream, duration, reference);
  253.             break;
  254.           case 'ac3':
  255.             streamInfo =
  256.               this.getAc3StreamInfo_(tsParser, stream, duration, reference);
  257.             break;
  258.           case 'ec3':
  259.             streamInfo =
  260.               this.getEc3StreamInfo_(tsParser, stream, duration, reference);
  261.             break;
  262.           case 'mp3':
  263.             streamInfo =
  264.               this.getMp3StreamInfo_(tsParser, stream, duration, reference);
  265.             break;
  266.           case 'opus':
  267.             streamInfo =
  268.               this.getOpusStreamInfo_(tsParser, stream, duration, reference);
  269.             break;
  270.         }
  271.         if (streamInfo) {
  272.           streamInfos.push(streamInfo);
  273.           streamInfo = null;
  274.         }
  275.       }
  276.     } catch (e) {
  277.       if (e && e.code == shaka.util.Error.Code.TRANSMUXING_NO_VIDEO_DATA) {
  278.         return Promise.resolve(new Uint8Array([]));
  279.       }
  280.       return Promise.reject(e);
  281.     }
  283.     if (!streamInfos.length) {
  284.       return Promise.reject(new shaka.util.Error(
  285.           shaka.util.Error.Severity.CRITICAL,
  286.           shaka.util.Error.Category.MEDIA,
  287.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  288.           reference ? reference.getUris()[0] : null));
  289.     }
  291.     const mp4Generator = new shaka.util.Mp4Generator(streamInfos);
  292.     let initSegment;
  293.     const initSegmentKey = stream.id + '_' + reference.discontinuitySequence;
  294.     if (!this.initSegments.has(initSegmentKey)) {
  295.       initSegment = mp4Generator.initSegment();
  296.       this.initSegments.set(initSegmentKey, initSegment);
  297.     } else {
  298.       initSegment = this.initSegments.get(initSegmentKey);
  299.     }
  300.     const appendInitSegment = this.lastInitSegment_ !== initSegment;
  301.     const segmentData = mp4Generator.segmentData();
  302.     this.lastInitSegment_ = initSegment;
  303.     this.frameIndex_++;
  304.     if (appendInitSegment) {
  305.       const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
  306.       return Promise.resolve(transmuxData);
  307.     } else {
  308.       return Promise.resolve(segmentData);
  309.     }
  310.   }
  313.   /**
  314.    * @param {shaka.util.TsParser} tsParser
  315.    * @param {shaka.extern.Stream} stream
  316.    * @param {number} duration
  317.    * @param {?shaka.media.SegmentReference} reference
  318.    * @return {shaka.util.Mp4Generator.StreamInfo}
  319.    * @private
  320.    */
  321.   getAacStreamInfo_(tsParser, stream, duration, reference) {
  322.     const ADTS = shaka.transmuxer.ADTS;
  323.     const timescale = shaka.util.TsParser.Timescale;
  324.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  326.     /** @type {!Array<shaka.util.Mp4Generator.Mp4Sample>} */
  327.     const samples = [];
  329.     let info;
  331.     let firstPts = null;
  333.     /** @type {?number} */
  334.     let nextStartOffset = null;
  335.     /** @type {?Uint8Array} */
  336.     let overflowBytes = null;
  338.     for (const audioData of tsParser.getAudioData()) {
  339.       let data = audioData.data;
  340.       if (!data) {
  341.         continue;
  342.       }
  343.       let offset = 0;
  344.       if (nextStartOffset == -1 && overflowBytes) {
  345.         data = Uint8ArrayUtils.concat(overflowBytes, audioData.data);
  346.         nextStartOffset = null;
  347.       } else if (nextStartOffset != null && overflowBytes) {
  348.         offset = Math.max(0, nextStartOffset);
  349.         const missingFrameData =
  350.             Uint8ArrayUtils.concat(overflowBytes, data.subarray(0, offset));
  351.         samples.push({
  352.           data: missingFrameData,
  353.           size: missingFrameData.byteLength,
  354.           duration: ADTS.AAC_SAMPLES_PER_FRAME,
  355.           cts: 0,
  356.           flags: {
  357.             isLeading: 0,
  358.             isDependedOn: 0,
  359.             hasRedundancy: 0,
  360.             degradPrio: 0,
  361.             dependsOn: 2,
  362.             isNonSync: 0,
  363.           },
  364.         });
  365.         overflowBytes = null;
  366.         nextStartOffset = null;
  367.       }
  368.       info = ADTS.parseInfo(data, offset);
  369.       if (!info) {
  370.         throw new shaka.util.Error(
  371.             shaka.util.Error.Severity.CRITICAL,
  372.             shaka.util.Error.Category.MEDIA,
  373.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  374.             reference ? reference.getUris()[0] : null);
  375.       }
  376.       stream.audioSamplingRate = info.sampleRate;
  377.       stream.channelsCount = info.channelCount;
  378.       if (firstPts == null && audioData.pts !== null) {
  379.         firstPts = audioData.pts;
  380.       }
  381.       while (offset < data.length) {
  382.         const header = ADTS.parseHeader(data, offset);
  383.         if (!header) {
  384.           overflowBytes = data.subarray(offset, data.length);
  385.           nextStartOffset = -1;
  386.           break;
  387.         }
  388.         const length = header.headerLength + header.frameLength;
  389.         nextStartOffset = Math.max(0, offset + length - data.length);
  390.         if (nextStartOffset != 0) {
  391.           overflowBytes = data.subarray(
  392.               offset + header.headerLength, offset + length);
  393.         } else if (offset + length <= data.length) {
  394.           const frameData = data.subarray(
  395.               offset + header.headerLength, offset + length);
  397.           samples.push({
  398.             data: frameData,
  399.             size: header.frameLength,
  400.             duration: ADTS.AAC_SAMPLES_PER_FRAME,
  401.             cts: 0,
  402.             flags: {
  403.               isLeading: 0,
  404.               isDependedOn: 0,
  405.               hasRedundancy: 0,
  406.               degradPrio: 0,
  407.               dependsOn: 2,
  408.               isNonSync: 0,
  409.             },
  410.           });
  411.         }
  412.         offset += length;
  413.       }
  414.     }
  416.     if (!info || firstPts == null) {
  417.       if (!tsParser.getVideoData().length) {
  418.         throw new shaka.util.Error(
  419.             shaka.util.Error.Severity.CRITICAL,
  420.             shaka.util.Error.Category.MEDIA,
  421.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  422.             reference ? reference.getUris()[0] : null);
  423.       }
  425.       firstPts = reference.startTime * timescale;
  427.       const allCodecs = shaka.util.MimeUtils.splitCodecs(stream.codecs);
  428.       const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  429.           shaka.util.ManifestParserUtils.ContentType.AUDIO, allCodecs);
  430.       if (!audioCodec || !stream.channelsCount || !stream.audioSamplingRate) {
  431.         throw new shaka.util.Error(
  432.             shaka.util.Error.Severity.CRITICAL,
  433.             shaka.util.Error.Category.MEDIA,
  434.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  435.             reference ? reference.getUris()[0] : null);
  436.       }
  437.       info = {
  438.         sampleRate: stream.audioSamplingRate,
  439.         channelCount: stream.channelsCount,
  440.         codec: audioCodec,
  441.       };
  442.       const silenceFrame =
  443.           ADTS.getSilentFrame(audioCodec, stream.channelsCount);
  444.       if (!silenceFrame) {
  445.         throw new shaka.util.Error(
  446.             shaka.util.Error.Severity.CRITICAL,
  447.             shaka.util.Error.Category.MEDIA,
  448.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  449.             reference ? reference.getUris()[0] : null);
  450.       }
  451.       const segmentDuration =
  452.           (reference.endTime - reference.startTime) * timescale;
  453.       const finalPTs = firstPts + segmentDuration;
  454.       let currentPts = firstPts;
  455.       while (currentPts < finalPTs) {
  456.         samples.push({
  457.           data: silenceFrame,
  458.           size: silenceFrame.byteLength,
  459.           duration: ADTS.AAC_SAMPLES_PER_FRAME,
  460.           cts: 0,
  461.           flags: {
  462.             isLeading: 0,
  463.             isDependedOn: 0,
  464.             hasRedundancy: 0,
  465.             degradPrio: 0,
  466.             dependsOn: 2,
  467.             isNonSync: 0,
  468.           },
  469.         });
  470.         currentPts += ADTS.AAC_SAMPLES_PER_FRAME / info.sampleRate * timescale;
  471.       }
  472.     }
  474.     /** @type {number} */
  475.     const sampleRate = info.sampleRate;
  476.     /** @type {number} */
  477.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  479.     return {
  480.       id: stream.id,
  481.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  482.       codecs: info.codec,
  483.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  484.       timescale: sampleRate,
  485.       duration: duration,
  486.       videoNalus: [],
  487.       audioConfig: new Uint8Array([]),
  488.       videoConfig: new Uint8Array([]),
  489.       hSpacing: 0,
  490.       vSpacing: 0,
  491.       data: {
  492.         sequenceNumber: this.frameIndex_,
  493.         baseMediaDecodeTime: baseMediaDecodeTime,
  494.         samples: samples,
  495.       },
  496.       stream: stream,
  497.     };
  498.   }
  501.   /**
  502.    * @param {shaka.util.TsParser} tsParser
  503.    * @param {shaka.extern.Stream} stream
  504.    * @param {number} duration
  505.    * @param {?shaka.media.SegmentReference} reference
  506.    * @return {shaka.util.Mp4Generator.StreamInfo}
  507.    * @private
  508.    */
  509.   getAc3StreamInfo_(tsParser, stream, duration, reference) {
  510.     const Ac3 = shaka.transmuxer.Ac3;
  511.     const timescale = shaka.util.TsParser.Timescale;
  513.     /** @type {!Array<shaka.util.Mp4Generator.Mp4Sample>} */
  514.     const samples = [];
  516.     /** @type {number} */
  517.     let sampleRate = 0;
  519.     /** @type {!Uint8Array} */
  520.     let audioConfig = new Uint8Array([]);
  522.     let firstPts = null;
  524.     for (const audioData of tsParser.getAudioData()) {
  525.       const data = audioData.data;
  526.       if (firstPts == null && audioData.pts !== null) {
  527.         firstPts = audioData.pts;
  528.       }
  529.       let offset = 0;
  530.       while (offset < data.length) {
  531.         const frame = Ac3.parseFrame(data, offset);
  532.         if (!frame) {
  533.           offset++;
  534.           continue;
  535.         }
  536.         stream.audioSamplingRate = frame.sampleRate;
  537.         stream.channelsCount = frame.channelCount;
  538.         sampleRate = frame.sampleRate;
  539.         audioConfig = frame.audioConfig;
  541.         const frameData = data.subarray(
  542.             offset, offset + frame.frameLength);
  544.         samples.push({
  545.           data: frameData,
  546.           size: frame.frameLength,
  547.           duration: Ac3.AC3_SAMPLES_PER_FRAME,
  548.           cts: 0,
  549.           flags: {
  550.             isLeading: 0,
  551.             isDependedOn: 0,
  552.             hasRedundancy: 0,
  553.             degradPrio: 0,
  554.             dependsOn: 2,
  555.             isNonSync: 0,
  556.           },
  557.         });
  558.         offset += frame.frameLength;
  559.       }
  560.     }
  562.     if (sampleRate == 0 || audioConfig.byteLength == 0 || firstPts == null) {
  563.       throw new shaka.util.Error(
  564.           shaka.util.Error.Severity.CRITICAL,
  565.           shaka.util.Error.Category.MEDIA,
  566.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  567.           reference ? reference.getUris()[0] : null);
  568.     }
  571.     /** @type {number} */
  572.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  574.     return {
  575.       id: stream.id,
  576.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  577.       codecs: 'ac-3',
  578.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  579.       timescale: sampleRate,
  580.       duration: duration,
  581.       videoNalus: [],
  582.       audioConfig: audioConfig,
  583.       videoConfig: new Uint8Array([]),
  584.       hSpacing: 0,
  585.       vSpacing: 0,
  586.       data: {
  587.         sequenceNumber: this.frameIndex_,
  588.         baseMediaDecodeTime: baseMediaDecodeTime,
  589.         samples: samples,
  590.       },
  591.       stream: stream,
  592.     };
  593.   }
  596.   /**
  597.    * @param {shaka.util.TsParser} tsParser
  598.    * @param {shaka.extern.Stream} stream
  599.    * @param {number} duration
  600.    * @param {?shaka.media.SegmentReference} reference
  601.    * @return {shaka.util.Mp4Generator.StreamInfo}
  602.    * @private
  603.    */
  604.   getEc3StreamInfo_(tsParser, stream, duration, reference) {
  605.     const Ec3 = shaka.transmuxer.Ec3;
  606.     const timescale = shaka.util.TsParser.Timescale;
  608.     /** @type {!Array<shaka.util.Mp4Generator.Mp4Sample>} */
  609.     const samples = [];
  611.     /** @type {number} */
  612.     let sampleRate = 0;
  614.     /** @type {!Uint8Array} */
  615.     let audioConfig = new Uint8Array([]);
  617.     let firstPts = null;
  619.     for (const audioData of tsParser.getAudioData()) {
  620.       const data = audioData.data;
  621.       if (firstPts == null && audioData.pts !== null) {
  622.         firstPts = audioData.pts;
  623.       }
  624.       let offset = 0;
  625.       while (offset < data.length) {
  626.         const frame = Ec3.parseFrame(data, offset);
  627.         if (!frame) {
  628.           offset++;
  629.           continue;
  630.         }
  631.         stream.audioSamplingRate = frame.sampleRate;
  632.         stream.channelsCount = frame.channelCount;
  633.         sampleRate = frame.sampleRate;
  634.         audioConfig = frame.audioConfig;
  636.         const frameData = data.subarray(
  637.             offset, offset + frame.frameLength);
  639.         samples.push({
  640.           data: frameData,
  641.           size: frame.frameLength,
  642.           duration: Ec3.EC3_SAMPLES_PER_FRAME,
  643.           cts: 0,
  644.           flags: {
  645.             isLeading: 0,
  646.             isDependedOn: 0,
  647.             hasRedundancy: 0,
  648.             degradPrio: 0,
  649.             dependsOn: 2,
  650.             isNonSync: 0,
  651.           },
  652.         });
  653.         offset += frame.frameLength;
  654.       }
  655.     }
  657.     if (sampleRate == 0 || audioConfig.byteLength == 0 || firstPts == null) {
  658.       throw new shaka.util.Error(
  659.           shaka.util.Error.Severity.CRITICAL,
  660.           shaka.util.Error.Category.MEDIA,
  661.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  662.           reference ? reference.getUris()[0] : null);
  663.     }
  666.     /** @type {number} */
  667.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  669.     return {
  670.       id: stream.id,
  671.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  672.       codecs: 'ec-3',
  673.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  674.       timescale: sampleRate,
  675.       duration: duration,
  676.       videoNalus: [],
  677.       audioConfig: audioConfig,
  678.       videoConfig: new Uint8Array([]),
  679.       hSpacing: 0,
  680.       vSpacing: 0,
  681.       data: {
  682.         sequenceNumber: this.frameIndex_,
  683.         baseMediaDecodeTime: baseMediaDecodeTime,
  684.         samples: samples,
  685.       },
  686.       stream: stream,
  687.     };
  688.   }
  691.   /**
  692.    * @param {shaka.util.TsParser} tsParser
  693.    * @param {shaka.extern.Stream} stream
  694.    * @param {number} duration
  695.    * @param {?shaka.media.SegmentReference} reference
  696.    * @return {shaka.util.Mp4Generator.StreamInfo}
  697.    * @private
  698.    */
  699.   getMp3StreamInfo_(tsParser, stream, duration, reference) {
  700.     const MpegAudio = shaka.transmuxer.MpegAudio;
  701.     const timescale = shaka.util.TsParser.Timescale;
  703.     /** @type {!Array<shaka.util.Mp4Generator.Mp4Sample>} */
  704.     const samples = [];
  706.     let firstHeader;
  708.     let firstPts = null;
  710.     for (const audioData of tsParser.getAudioData()) {
  711.       const data = audioData.data;
  712.       if (!data) {
  713.         continue;
  714.       }
  715.       if (firstPts == null && audioData.pts !== null) {
  716.         firstPts = audioData.pts;
  717.       }
  718.       let offset = 0;
  719.       while (offset < data.length) {
  720.         const header = MpegAudio.parseHeader(data, offset);
  721.         if (!header) {
  722.           offset++;
  723.           continue;
  724.         }
  725.         if (!firstHeader) {
  726.           firstHeader = header;
  727.         }
  728.         if (offset + header.frameLength <= data.length) {
  729.           samples.push({
  730.             data: data.subarray(offset, offset + header.frameLength),
  731.             size: header.frameLength,
  732.             duration: MpegAudio.MPEG_AUDIO_SAMPLE_PER_FRAME,
  733.             cts: 0,
  734.             flags: {
  735.               isLeading: 0,
  736.               isDependedOn: 0,
  737.               hasRedundancy: 0,
  738.               degradPrio: 0,
  739.               dependsOn: 2,
  740.               isNonSync: 0,
  741.             },
  742.           });
  743.         }
  744.         offset += header.frameLength;
  745.       }
  746.     }
  747.     if (!firstHeader || firstPts == null) {
  748.       throw new shaka.util.Error(
  749.           shaka.util.Error.Severity.CRITICAL,
  750.           shaka.util.Error.Category.MEDIA,
  751.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  752.           reference ? reference.getUris()[0] : null);
  753.     }
  754.     /** @type {number} */
  755.     const sampleRate = firstHeader.sampleRate;
  756.     /** @type {number} */
  757.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  759.     return {
  760.       id: stream.id,
  761.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  762.       codecs: 'mp3',
  763.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  764.       timescale: sampleRate,
  765.       duration: duration,
  766.       videoNalus: [],
  767.       audioConfig: new Uint8Array([]),
  768.       videoConfig: new Uint8Array([]),
  769.       hSpacing: 0,
  770.       vSpacing: 0,
  771.       data: {
  772.         sequenceNumber: this.frameIndex_,
  773.         baseMediaDecodeTime: baseMediaDecodeTime,
  774.         samples: samples,
  775.       },
  776.       stream: stream,
  777.     };
  778.   }
  781.   /**
  782.    * @param {shaka.util.TsParser} tsParser
  783.    * @param {shaka.extern.Stream} stream
  784.    * @param {number} duration
  785.    * @param {?shaka.media.SegmentReference} reference
  786.    * @return {shaka.util.Mp4Generator.StreamInfo}
  787.    * @private
  788.    */
  789.   getOpusStreamInfo_(tsParser, stream, duration, reference) {
  790.     const Opus = shaka.transmuxer.Opus;
  791.     const timescale = shaka.util.TsParser.Timescale;
  793.     /** @type {!Array<shaka.util.Mp4Generator.Mp4Sample>} */
  794.     const samples = [];
  796.     let firstPts = null;
  798.     /** @type {?shaka.util.TsParser.OpusMetadata} */
  799.     const opusMetadata = tsParser.getOpusMetadata();
  801.     if (!opusMetadata) {
  802.       throw new shaka.util.Error(
  803.           shaka.util.Error.Severity.CRITICAL,
  804.           shaka.util.Error.Category.MEDIA,
  805.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  806.           reference ? reference.getUris()[0] : null);
  807.     }
  809.     /** @type {!Uint8Array} */
  810.     const audioConfig = Opus.getAudioConfig(opusMetadata);
  812.     /** @type {number} */
  813.     const sampleRate = opusMetadata.sampleRate;
  815.     for (const audioData of tsParser.getAudioData()) {
  816.       const data = audioData.data;
  817.       if (firstPts == null && audioData.pts !== null) {
  818.         firstPts = audioData.pts;
  819.       }
  820.       let offset = 0;
  821.       while (offset < data.length) {
  822.         const opusPendingTrimStart = (data[offset + 1] & 0x10) !== 0;
  823.         const trimEnd = (data[offset + 1] & 0x08) !== 0;
  824.         let index = offset + 2;
  825.         let size = 0;
  827.         while (data[index] === 0xFF) {
  828.           size += 255;
  829.           index += 1;
  830.         }
  831.         size += data[index];
  832.         index += 1;
  833.         index += opusPendingTrimStart ? 2 : 0;
  834.         index += trimEnd ? 2 : 0;
  836.         const sample = data.slice(index, index + size);
  838.         samples.push({
  839.           data: sample,
  840.           size: sample.byteLength,
  841.           duration: Opus.OPUS_AUDIO_SAMPLE_PER_FRAME,
  842.           cts: 0,
  843.           flags: {
  844.             isLeading: 0,
  845.             isDependedOn: 0,
  846.             hasRedundancy: 0,
  847.             degradPrio: 0,
  848.             dependsOn: 2,
  849.             isNonSync: 0,
  850.           },
  851.         });
  852.         offset = index + size;
  853.       }
  854.     }
  856.     if (audioConfig.byteLength == 0 || firstPts == null) {
  857.       throw new shaka.util.Error(
  858.           shaka.util.Error.Severity.CRITICAL,
  859.           shaka.util.Error.Category.MEDIA,
  860.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  861.           reference ? reference.getUris()[0] : null);
  862.     }
  864.     stream.audioSamplingRate = opusMetadata.sampleRate;
  865.     stream.channelsCount = opusMetadata.channelCount;
  868.     /** @type {number} */
  869.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  871.     return {
  872.       id: stream.id,
  873.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  874.       codecs: 'opus',
  875.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  876.       timescale: sampleRate,
  877.       duration: duration,
  878.       videoNalus: [],
  879.       audioConfig: audioConfig,
  880.       videoConfig: new Uint8Array([]),
  881.       hSpacing: 0,
  882.       vSpacing: 0,
  883.       data: {
  884.         sequenceNumber: this.frameIndex_,
  885.         baseMediaDecodeTime: baseMediaDecodeTime,
  886.         samples: samples,
  887.       },
  888.       stream: stream,
  889.     };
  890.   }
  893.   /**
  894.    * @param {shaka.util.TsParser} tsParser
  895.    * @param {shaka.extern.Stream} stream
  896.    * @param {number} duration
  897.    * @param {?shaka.media.SegmentReference} reference
  898.    * @return {shaka.util.Mp4Generator.StreamInfo}
  899.    * @private
  900.    */
  901.   getAvcStreamInfo_(tsParser, stream, duration, reference) {
  902.     const H264 = shaka.transmuxer.H264;
  903.     const timescale = shaka.util.TsParser.Timescale;
  905.     /** @type {!Array<shaka.util.Mp4Generator.Mp4Sample>} */
  906.     const samples = [];
  908.     /** @type {?number} */
  909.     let baseMediaDecodeTime = null;
  911.     const videoData = tsParser.getVideoData();
  912.     const videoSamples = H264.getVideoSamples(videoData);
  913.     if (!videoSamples.length) {
  914.       throw new shaka.util.Error(
  915.           shaka.util.Error.Severity.CRITICAL,
  916.           shaka.util.Error.Category.MEDIA,
  917.           shaka.util.Error.Code.TRANSMUXING_NO_VIDEO_DATA,
  918.           reference ? reference.getUris()[0] : null);
  919.     }
  920.     for (let i = 0; i < videoSamples.length; i++) {
  921.       const videoSample = videoSamples[i];
  922.       if (baseMediaDecodeTime == null) {
  923.         baseMediaDecodeTime = videoSample.dts;
  924.       }
  925.       let duration;
  926.       if (i + 1 < videoSamples.length) {
  927.         duration = (videoSamples[i + 1].dts || 0) - (videoSample.dts || 0);
  928.       } else if (videoSamples.length > 1) {
  929.         duration = (videoSample.dts || 0) - (videoSamples[i - 1].dts || 0);
  930.       } else {
  931.         duration = (reference.endTime - reference.startTime) * timescale;
  932.       }
  933.       samples.push({
  934.         data: videoSample.data,
  935.         size: videoSample.data.byteLength,
  936.         duration: duration,
  937.         cts: Math.round((videoSample.pts || 0) - (videoSample.dts || 0)),
  938.         flags: {
  939.           isLeading: 0,
  940.           isDependedOn: 0,
  941.           hasRedundancy: 0,
  942.           degradPrio: 0,
  943.           dependsOn: videoSample.isKeyframe ? 2 : 1,
  944.           isNonSync: videoSample.isKeyframe ? 0 : 1,
  945.         },
  946.       });
  947.     }
  949.     const nalus = [];
  950.     for (const pes of videoData) {
  951.       nalus.push(...pes.nalus);
  952.     }
  953.     const info = H264.parseInfo(nalus);
  955.     if (!info || baseMediaDecodeTime == null) {
  956.       throw new shaka.util.Error(
  957.           shaka.util.Error.Severity.CRITICAL,
  958.           shaka.util.Error.Category.MEDIA,
  959.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  960.           reference ? reference.getUris()[0] : null);
  961.     }
  962.     stream.height = info.height;
  963.     stream.width = info.width;
  965.     return {
  966.       id: stream.id,
  967.       type: shaka.util.ManifestParserUtils.ContentType.VIDEO,
  968.       codecs: 'avc1',
  969.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  970.       timescale: timescale,
  971.       duration: duration,
  972.       videoNalus: [],
  973.       audioConfig: new Uint8Array([]),
  974.       videoConfig: info.videoConfig,
  975.       hSpacing: info.hSpacing,
  976.       vSpacing: info.vSpacing,
  977.       data: {
  978.         sequenceNumber: this.frameIndex_,
  979.         baseMediaDecodeTime: baseMediaDecodeTime,
  980.         samples: samples,
  981.       },
  982.       stream: stream,
  983.     };
  984.   }
  987.   /**
  988.    * @param {shaka.util.TsParser} tsParser
  989.    * @param {shaka.extern.Stream} stream
  990.    * @param {number} duration
  991.    * @param {?shaka.media.SegmentReference} reference
  992.    * @return {shaka.util.Mp4Generator.StreamInfo}
  993.    * @private
  994.    */
  995.   getHvcStreamInfo_(tsParser, stream, duration, reference) {
  996.     const H265 = shaka.transmuxer.H265;
  997.     const timescale = shaka.util.TsParser.Timescale;
  999.     /** @type {!Array<shaka.util.Mp4Generator.Mp4Sample>} */
  1000.     const samples = [];
  1002.     /** @type {?number} */
  1003.     let baseMediaDecodeTime = null;
  1005.     const nalus = [];
  1006.     const videoData = tsParser.getVideoData();
  1007.     if (!videoData.length) {
  1008.       throw new shaka.util.Error(
  1009.           shaka.util.Error.Severity.CRITICAL,
  1010.           shaka.util.Error.Category.MEDIA,
  1011.           shaka.util.Error.Code.TRANSMUXING_NO_VIDEO_DATA,
  1012.           reference ? reference.getUris()[0] : null);
  1013.     }
  1014.     for (let i = 0; i < videoData.length; i++) {
  1015.       const pes = videoData[i];
  1016.       const dataNalus = pes.nalus;
  1017.       nalus.push(...dataNalus);
  1018.       const frame = H265.parseFrame(dataNalus);
  1019.       if (!frame) {
  1020.         continue;
  1021.       }
  1022.       if (baseMediaDecodeTime == null && pes.dts != null) {
  1023.         baseMediaDecodeTime = pes.dts;
  1024.       }
  1025.       let duration;
  1026.       if (i + 1 < videoData.length) {
  1027.         duration = (videoData[i + 1].dts || 0) - (pes.dts || 0);
  1028.       } else if (videoData.length > 1) {
  1029.         duration = (pes.dts || 0) - (videoData[i - 1].dts || 0);
  1030.       } else {
  1031.         duration = (reference.endTime - reference.startTime) * timescale;
  1032.       }
  1033.       samples.push({
  1034.         data: frame.data,
  1035.         size: frame.data.byteLength,
  1036.         duration: duration,
  1037.         cts: Math.round((pes.pts || 0) - (pes.dts || 0)),
  1038.         flags: {
  1039.           isLeading: 0,
  1040.           isDependedOn: 0,
  1041.           hasRedundancy: 0,
  1042.           degradPrio: 0,
  1043.           dependsOn: frame.isKeyframe ? 2 : 1,
  1044.           isNonSync: frame.isKeyframe ? 0 : 1,
  1045.         },
  1046.       });
  1047.     }
  1049.     const info = H265.parseInfo(nalus);
  1051.     if (!info || baseMediaDecodeTime == null) {
  1052.       throw new shaka.util.Error(
  1053.           shaka.util.Error.Severity.CRITICAL,
  1054.           shaka.util.Error.Category.MEDIA,
  1055.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  1056.           reference ? reference.getUris()[0] : null);
  1057.     }
  1058.     stream.height = info.height;
  1059.     stream.width = info.width;
  1061.     return {
  1062.       id: stream.id,
  1063.       type: shaka.util.ManifestParserUtils.ContentType.VIDEO,
  1064.       codecs: 'hvc1',
  1065.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  1066.       timescale: timescale,
  1067.       duration: duration,
  1068.       videoNalus: [],
  1069.       audioConfig: new Uint8Array([]),
  1070.       videoConfig: info.videoConfig,
  1071.       hSpacing: info.hSpacing,
  1072.       vSpacing: info.vSpacing,
  1073.       data: {
  1074.         sequenceNumber: this.frameIndex_,
  1075.         baseMediaDecodeTime: baseMediaDecodeTime,
  1076.         samples: samples,
  1077.       },
  1078.       stream: stream,
  1079.     };
  1080.   }
  1081. };
  1083. /**
  1084.  * Supported audio codecs.
  1085.  *
  1086.  * @private
  1087.  * @const {!Array<string>}
  1088.  */
  1089. shaka.transmuxer.TsTransmuxer.SUPPORTED_AUDIO_CODECS_ = [
  1090.   'aac',
  1091.   'ac-3',
  1092.   'ec-3',
  1093.   'mp3',
  1094.   'opus',
  1095. ];
  1097. /**
  1098.  * Supported audio codecs.
  1099.  *
  1100.  * @private
  1101.  * @const {!Array<string>}
  1102.  */
  1103. shaka.transmuxer.TsTransmuxer.SUPPORTED_VIDEO_CODECS_ = [
  1104.   'avc',
  1105.   'hevc',
  1106. ];
  1109. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  1110.     'video/mp2t',
  1111.     () => new shaka.transmuxer.TsTransmuxer('video/mp2t'),
  1112.     shaka.transmuxer.TransmuxerEngine.PluginPriority.PREFERRED);