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.<number, !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.     if (!this.initSegments.has(stream.id)) {
  290.       initSegment = mp4Generator.initSegment();
  291.       this.initSegments.set(stream.id, initSegment);
  292.     } else {
  293.       initSegment = this.initSegments.get(stream.id);
  294.     }
  295.     const segmentData = mp4Generator.segmentData();
  297.     this.frameIndex_++;
  298.     const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
  299.     return Promise.resolve(transmuxData);
  300.   }
  303.   /**
  304.    * @param {shaka.util.TsParser} tsParser
  305.    * @param {shaka.extern.Stream} stream
  306.    * @param {number} duration
  307.    * @param {?shaka.media.SegmentReference} reference
  308.    * @return {shaka.util.Mp4Generator.StreamInfo}
  309.    * @private
  310.    */
  311.   getAacStreamInfo_(tsParser, stream, duration, reference) {
  312.     const ADTS = shaka.transmuxer.ADTS;
  313.     const timescale = shaka.util.TsParser.Timescale;
  315.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  316.     const samples = [];
  318.     let info;
  320.     let firstPts = null;
  322.     for (const audioData of tsParser.getAudioData()) {
  323.       const data = audioData.data;
  324.       if (!data) {
  325.         continue;
  326.       }
  327.       let offset = 0;
  328.       info = ADTS.parseInfo(data, offset);
  329.       if (!info) {
  330.         throw new shaka.util.Error(
  331.             shaka.util.Error.Severity.CRITICAL,
  332.             shaka.util.Error.Category.MEDIA,
  333.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  334.             reference ? reference.getUris()[0] : null);
  335.       }
  336.       stream.audioSamplingRate = info.sampleRate;
  337.       stream.channelsCount = info.channelCount;
  338.       if (firstPts == null && audioData.pts !== null) {
  339.         firstPts = audioData.pts;
  340.       }
  341.       while (offset < data.length) {
  342.         const header = ADTS.parseHeader(data, offset);
  343.         if (!header) {
  344.           // We will increment one byte each time until we find the header.
  345.           offset++;
  346.           continue;
  347.         }
  348.         const length = header.headerLength + header.frameLength;
  349.         if (offset + length <= data.length) {
  350.           const frameData = data.subarray(
  351.               offset + header.headerLength, offset + length);
  353.           samples.push({
  354.             data: frameData,
  355.             size: header.frameLength,
  356.             duration: ADTS.AAC_SAMPLES_PER_FRAME,
  357.             cts: 0,
  358.             flags: {
  359.               isLeading: 0,
  360.               isDependedOn: 0,
  361.               hasRedundancy: 0,
  362.               degradPrio: 0,
  363.               dependsOn: 2,
  364.               isNonSync: 0,
  365.             },
  366.           });
  367.         }
  368.         offset += length;
  369.       }
  370.     }
  372.     if (!info || firstPts == null) {
  373.       if (!tsParser.getVideoData().length) {
  374.         throw new shaka.util.Error(
  375.             shaka.util.Error.Severity.CRITICAL,
  376.             shaka.util.Error.Category.MEDIA,
  377.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  378.             reference ? reference.getUris()[0] : null);
  379.       }
  381.       firstPts = reference.startTime * timescale;
  383.       const allCodecs = shaka.util.MimeUtils.splitCodecs(stream.codecs);
  384.       const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  385.           shaka.util.ManifestParserUtils.ContentType.AUDIO, allCodecs);
  386.       if (!audioCodec || !stream.channelsCount || !stream.audioSamplingRate) {
  387.         throw new shaka.util.Error(
  388.             shaka.util.Error.Severity.CRITICAL,
  389.             shaka.util.Error.Category.MEDIA,
  390.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  391.             reference ? reference.getUris()[0] : null);
  392.       }
  393.       info = {
  394.         sampleRate: stream.audioSamplingRate,
  395.         channelCount: stream.channelsCount,
  396.         codec: audioCodec,
  397.       };
  398.       const silenceFrame =
  399.           ADTS.getSilentFrame(audioCodec, stream.channelsCount);
  400.       if (!silenceFrame) {
  401.         throw new shaka.util.Error(
  402.             shaka.util.Error.Severity.CRITICAL,
  403.             shaka.util.Error.Category.MEDIA,
  404.             shaka.util.Error.Code.TRANSMUXING_FAILED,
  405.             reference ? reference.getUris()[0] : null);
  406.       }
  407.       const segmentDuration =
  408.           (reference.endTime - reference.startTime) * timescale;
  409.       const finalPTs = firstPts + segmentDuration;
  410.       let currentPts = firstPts;
  411.       while (currentPts < finalPTs) {
  412.         samples.push({
  413.           data: silenceFrame,
  414.           size: silenceFrame.byteLength,
  415.           duration: ADTS.AAC_SAMPLES_PER_FRAME,
  416.           cts: 0,
  417.           flags: {
  418.             isLeading: 0,
  419.             isDependedOn: 0,
  420.             hasRedundancy: 0,
  421.             degradPrio: 0,
  422.             dependsOn: 2,
  423.             isNonSync: 0,
  424.           },
  425.         });
  426.         currentPts += ADTS.AAC_SAMPLES_PER_FRAME / info.sampleRate * timescale;
  427.       }
  428.     }
  430.     /** @type {number} */
  431.     const sampleRate = info.sampleRate;
  432.     /** @type {number} */
  433.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  435.     return {
  436.       id: stream.id,
  437.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  438.       codecs: info.codec,
  439.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  440.       timescale: sampleRate,
  441.       duration: duration,
  442.       videoNalus: [],
  443.       audioConfig: new Uint8Array([]),
  444.       videoConfig: new Uint8Array([]),
  445.       hSpacing: 0,
  446.       vSpacing: 0,
  447.       data: {
  448.         sequenceNumber: this.frameIndex_,
  449.         baseMediaDecodeTime: baseMediaDecodeTime,
  450.         samples: samples,
  451.       },
  452.       stream: stream,
  453.     };
  454.   }
  457.   /**
  458.    * @param {shaka.util.TsParser} tsParser
  459.    * @param {shaka.extern.Stream} stream
  460.    * @param {number} duration
  461.    * @param {?shaka.media.SegmentReference} reference
  462.    * @return {shaka.util.Mp4Generator.StreamInfo}
  463.    * @private
  464.    */
  465.   getAc3StreamInfo_(tsParser, stream, duration, reference) {
  466.     const Ac3 = shaka.transmuxer.Ac3;
  467.     const timescale = shaka.util.TsParser.Timescale;
  469.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  470.     const samples = [];
  472.     /** @type {number} */
  473.     let sampleRate = 0;
  475.     /** @type {!Uint8Array} */
  476.     let audioConfig = new Uint8Array([]);
  478.     let firstPts = null;
  480.     for (const audioData of tsParser.getAudioData()) {
  481.       const data = audioData.data;
  482.       if (firstPts == null && audioData.pts !== null) {
  483.         firstPts = audioData.pts;
  484.       }
  485.       let offset = 0;
  486.       while (offset < data.length) {
  487.         const frame = Ac3.parseFrame(data, offset);
  488.         if (!frame) {
  489.           offset++;
  490.           continue;
  491.         }
  492.         stream.audioSamplingRate = frame.sampleRate;
  493.         stream.channelsCount = frame.channelCount;
  494.         sampleRate = frame.sampleRate;
  495.         audioConfig = frame.audioConfig;
  497.         const frameData = data.subarray(
  498.             offset, offset + frame.frameLength);
  500.         samples.push({
  501.           data: frameData,
  502.           size: frame.frameLength,
  503.           duration: Ac3.AC3_SAMPLES_PER_FRAME,
  504.           cts: 0,
  505.           flags: {
  506.             isLeading: 0,
  507.             isDependedOn: 0,
  508.             hasRedundancy: 0,
  509.             degradPrio: 0,
  510.             dependsOn: 2,
  511.             isNonSync: 0,
  512.           },
  513.         });
  514.         offset += frame.frameLength;
  515.       }
  516.     }
  518.     if (sampleRate == 0 || audioConfig.byteLength == 0 || firstPts == null) {
  519.       throw new shaka.util.Error(
  520.           shaka.util.Error.Severity.CRITICAL,
  521.           shaka.util.Error.Category.MEDIA,
  522.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  523.           reference ? reference.getUris()[0] : null);
  524.     }
  527.     /** @type {number} */
  528.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  530.     return {
  531.       id: stream.id,
  532.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  533.       codecs: 'ac-3',
  534.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  535.       timescale: sampleRate,
  536.       duration: duration,
  537.       videoNalus: [],
  538.       audioConfig: audioConfig,
  539.       videoConfig: new Uint8Array([]),
  540.       hSpacing: 0,
  541.       vSpacing: 0,
  542.       data: {
  543.         sequenceNumber: this.frameIndex_,
  544.         baseMediaDecodeTime: baseMediaDecodeTime,
  545.         samples: samples,
  546.       },
  547.       stream: stream,
  548.     };
  549.   }
  552.   /**
  553.    * @param {shaka.util.TsParser} tsParser
  554.    * @param {shaka.extern.Stream} stream
  555.    * @param {number} duration
  556.    * @param {?shaka.media.SegmentReference} reference
  557.    * @return {shaka.util.Mp4Generator.StreamInfo}
  558.    * @private
  559.    */
  560.   getEc3StreamInfo_(tsParser, stream, duration, reference) {
  561.     const Ec3 = shaka.transmuxer.Ec3;
  562.     const timescale = shaka.util.TsParser.Timescale;
  564.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  565.     const samples = [];
  567.     /** @type {number} */
  568.     let sampleRate = 0;
  570.     /** @type {!Uint8Array} */
  571.     let audioConfig = new Uint8Array([]);
  573.     let firstPts = null;
  575.     for (const audioData of tsParser.getAudioData()) {
  576.       const data = audioData.data;
  577.       if (firstPts == null && audioData.pts !== null) {
  578.         firstPts = audioData.pts;
  579.       }
  580.       let offset = 0;
  581.       while (offset < data.length) {
  582.         const frame = Ec3.parseFrame(data, offset);
  583.         if (!frame) {
  584.           offset++;
  585.           continue;
  586.         }
  587.         stream.audioSamplingRate = frame.sampleRate;
  588.         stream.channelsCount = frame.channelCount;
  589.         sampleRate = frame.sampleRate;
  590.         audioConfig = frame.audioConfig;
  592.         const frameData = data.subarray(
  593.             offset, offset + frame.frameLength);
  595.         samples.push({
  596.           data: frameData,
  597.           size: frame.frameLength,
  598.           duration: Ec3.EC3_SAMPLES_PER_FRAME,
  599.           cts: 0,
  600.           flags: {
  601.             isLeading: 0,
  602.             isDependedOn: 0,
  603.             hasRedundancy: 0,
  604.             degradPrio: 0,
  605.             dependsOn: 2,
  606.             isNonSync: 0,
  607.           },
  608.         });
  609.         offset += frame.frameLength;
  610.       }
  611.     }
  613.     if (sampleRate == 0 || audioConfig.byteLength == 0 || firstPts == null) {
  614.       throw new shaka.util.Error(
  615.           shaka.util.Error.Severity.CRITICAL,
  616.           shaka.util.Error.Category.MEDIA,
  617.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  618.           reference ? reference.getUris()[0] : null);
  619.     }
  622.     /** @type {number} */
  623.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  625.     return {
  626.       id: stream.id,
  627.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  628.       codecs: 'ec-3',
  629.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  630.       timescale: sampleRate,
  631.       duration: duration,
  632.       videoNalus: [],
  633.       audioConfig: audioConfig,
  634.       videoConfig: new Uint8Array([]),
  635.       hSpacing: 0,
  636.       vSpacing: 0,
  637.       data: {
  638.         sequenceNumber: this.frameIndex_,
  639.         baseMediaDecodeTime: baseMediaDecodeTime,
  640.         samples: samples,
  641.       },
  642.       stream: stream,
  643.     };
  644.   }
  647.   /**
  648.    * @param {shaka.util.TsParser} tsParser
  649.    * @param {shaka.extern.Stream} stream
  650.    * @param {number} duration
  651.    * @param {?shaka.media.SegmentReference} reference
  652.    * @return {shaka.util.Mp4Generator.StreamInfo}
  653.    * @private
  654.    */
  655.   getMp3StreamInfo_(tsParser, stream, duration, reference) {
  656.     const MpegAudio = shaka.transmuxer.MpegAudio;
  657.     const timescale = shaka.util.TsParser.Timescale;
  659.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  660.     const samples = [];
  662.     let firstHeader;
  664.     let firstPts = null;
  666.     for (const audioData of tsParser.getAudioData()) {
  667.       const data = audioData.data;
  668.       if (!data) {
  669.         continue;
  670.       }
  671.       if (firstPts == null && audioData.pts !== null) {
  672.         firstPts = audioData.pts;
  673.       }
  674.       let offset = 0;
  675.       while (offset < data.length) {
  676.         const header = MpegAudio.parseHeader(data, offset);
  677.         if (!header) {
  678.           offset++;
  679.           continue;
  680.         }
  681.         if (!firstHeader) {
  682.           firstHeader = header;
  683.         }
  684.         if (offset + header.frameLength <= data.length) {
  685.           samples.push({
  686.             data: data.subarray(offset, offset + header.frameLength),
  687.             size: header.frameLength,
  688.             duration: MpegAudio.MPEG_AUDIO_SAMPLE_PER_FRAME,
  689.             cts: 0,
  690.             flags: {
  691.               isLeading: 0,
  692.               isDependedOn: 0,
  693.               hasRedundancy: 0,
  694.               degradPrio: 0,
  695.               dependsOn: 2,
  696.               isNonSync: 0,
  697.             },
  698.           });
  699.         }
  700.         offset += header.frameLength;
  701.       }
  702.     }
  703.     if (!firstHeader || firstPts == null) {
  704.       throw new shaka.util.Error(
  705.           shaka.util.Error.Severity.CRITICAL,
  706.           shaka.util.Error.Category.MEDIA,
  707.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  708.           reference ? reference.getUris()[0] : null);
  709.     }
  710.     /** @type {number} */
  711.     const sampleRate = firstHeader.sampleRate;
  712.     /** @type {number} */
  713.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  715.     return {
  716.       id: stream.id,
  717.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  718.       codecs: 'mp3',
  719.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  720.       timescale: sampleRate,
  721.       duration: duration,
  722.       videoNalus: [],
  723.       audioConfig: new Uint8Array([]),
  724.       videoConfig: new Uint8Array([]),
  725.       hSpacing: 0,
  726.       vSpacing: 0,
  727.       data: {
  728.         sequenceNumber: this.frameIndex_,
  729.         baseMediaDecodeTime: baseMediaDecodeTime,
  730.         samples: samples,
  731.       },
  732.       stream: stream,
  733.     };
  734.   }
  737.   /**
  738.    * @param {shaka.util.TsParser} tsParser
  739.    * @param {shaka.extern.Stream} stream
  740.    * @param {number} duration
  741.    * @param {?shaka.media.SegmentReference} reference
  742.    * @return {shaka.util.Mp4Generator.StreamInfo}
  743.    * @private
  744.    */
  745.   getOpusStreamInfo_(tsParser, stream, duration, reference) {
  746.     const Opus = shaka.transmuxer.Opus;
  747.     const timescale = shaka.util.TsParser.Timescale;
  749.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  750.     const samples = [];
  752.     let firstPts = null;
  754.     /** @type {?shaka.util.TsParser.OpusMetadata} */
  755.     const opusMetadata = tsParser.getOpusMetadata();
  757.     if (!opusMetadata) {
  758.       throw new shaka.util.Error(
  759.           shaka.util.Error.Severity.CRITICAL,
  760.           shaka.util.Error.Category.MEDIA,
  761.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  762.           reference ? reference.getUris()[0] : null);
  763.     }
  765.     /** @type {!Uint8Array} */
  766.     const audioConfig = Opus.getAudioConfig(opusMetadata);
  768.     /** @type {number} */
  769.     const sampleRate = opusMetadata.sampleRate;
  771.     for (const audioData of tsParser.getAudioData()) {
  772.       const data = audioData.data;
  773.       if (firstPts == null && audioData.pts !== null) {
  774.         firstPts = audioData.pts;
  775.       }
  776.       let offset = 0;
  777.       while (offset < data.length) {
  778.         const opusPendingTrimStart = (data[offset + 1] & 0x10) !== 0;
  779.         const trimEnd = (data[offset + 1] & 0x08) !== 0;
  780.         let index = offset + 2;
  781.         let size = 0;
  783.         while (data[index] === 0xFF) {
  784.           size += 255;
  785.           index += 1;
  786.         }
  787.         size += data[index];
  788.         index += 1;
  789.         index += opusPendingTrimStart ? 2 : 0;
  790.         index += trimEnd ? 2 : 0;
  792.         const sample = data.slice(index, index + size);
  794.         samples.push({
  795.           data: sample,
  796.           size: sample.byteLength,
  797.           duration: Opus.OPUS_AUDIO_SAMPLE_PER_FRAME,
  798.           cts: 0,
  799.           flags: {
  800.             isLeading: 0,
  801.             isDependedOn: 0,
  802.             hasRedundancy: 0,
  803.             degradPrio: 0,
  804.             dependsOn: 2,
  805.             isNonSync: 0,
  806.           },
  807.         });
  808.         offset = index + size;
  809.       }
  810.     }
  812.     if (audioConfig.byteLength == 0 || firstPts == null) {
  813.       throw new shaka.util.Error(
  814.           shaka.util.Error.Severity.CRITICAL,
  815.           shaka.util.Error.Category.MEDIA,
  816.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  817.           reference ? reference.getUris()[0] : null);
  818.     }
  820.     stream.audioSamplingRate = opusMetadata.sampleRate;
  821.     stream.channelsCount = opusMetadata.channelCount;
  824.     /** @type {number} */
  825.     const baseMediaDecodeTime = firstPts / timescale * sampleRate;
  827.     return {
  828.       id: stream.id,
  829.       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
  830.       codecs: 'opus',
  831.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  832.       timescale: sampleRate,
  833.       duration: duration,
  834.       videoNalus: [],
  835.       audioConfig: audioConfig,
  836.       videoConfig: new Uint8Array([]),
  837.       hSpacing: 0,
  838.       vSpacing: 0,
  839.       data: {
  840.         sequenceNumber: this.frameIndex_,
  841.         baseMediaDecodeTime: baseMediaDecodeTime,
  842.         samples: samples,
  843.       },
  844.       stream: stream,
  845.     };
  846.   }
  849.   /**
  850.    * @param {shaka.util.TsParser} tsParser
  851.    * @param {shaka.extern.Stream} stream
  852.    * @param {number} duration
  853.    * @param {?shaka.media.SegmentReference} reference
  854.    * @return {shaka.util.Mp4Generator.StreamInfo}
  855.    * @private
  856.    */
  857.   getAvcStreamInfo_(tsParser, stream, duration, reference) {
  858.     const H264 = shaka.transmuxer.H264;
  859.     const timescale = shaka.util.TsParser.Timescale;
  861.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  862.     const samples = [];
  864.     /** @type {?number} */
  865.     let baseMediaDecodeTime = null;
  867.     const nalus = [];
  868.     const videoData = tsParser.getVideoData();
  869.     if (!videoData.length) {
  870.       throw new shaka.util.Error(
  871.           shaka.util.Error.Severity.CRITICAL,
  872.           shaka.util.Error.Category.MEDIA,
  873.           shaka.util.Error.Code.TRANSMUXING_NO_VIDEO_DATA,
  874.           reference ? reference.getUris()[0] : null);
  875.     }
  876.     for (let i = 0; i < videoData.length; i++) {
  877.       const pes = videoData[i];
  878.       const dataNalus = pes.nalus;
  879.       nalus.push(...dataNalus);
  880.       const frame = H264.parseFrame(dataNalus);
  881.       if (!frame) {
  882.         continue;
  883.       }
  884.       if (baseMediaDecodeTime == null) {
  885.         baseMediaDecodeTime = pes.dts;
  886.       }
  887.       let duration;
  888.       if (i + 1 < videoData.length) {
  889.         duration = (videoData[i + 1].dts || 0) - (pes.dts || 0);
  890.       } else if (videoData.length > 1) {
  891.         duration = (pes.dts || 0) - (videoData[i - 1].dts || 0);
  892.       } else {
  893.         duration = (reference.endTime - reference.startTime) * timescale;
  894.       }
  895.       samples.push({
  896.         data: frame.data,
  897.         size: frame.data.byteLength,
  898.         duration: duration,
  899.         cts: Math.round((pes.pts || 0) - (pes.dts || 0)),
  900.         flags: {
  901.           isLeading: 0,
  902.           isDependedOn: 0,
  903.           hasRedundancy: 0,
  904.           degradPrio: 0,
  905.           dependsOn: frame.isKeyframe ? 2 : 1,
  906.           isNonSync: frame.isKeyframe ? 0 : 1,
  907.         },
  908.       });
  909.     }
  911.     const info = H264.parseInfo(nalus);
  913.     if (!info || baseMediaDecodeTime == null) {
  914.       throw new shaka.util.Error(
  915.           shaka.util.Error.Severity.CRITICAL,
  916.           shaka.util.Error.Category.MEDIA,
  917.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  918.           reference ? reference.getUris()[0] : null);
  919.     }
  920.     stream.height = info.height;
  921.     stream.width = info.width;
  923.     return {
  924.       id: stream.id,
  925.       type: shaka.util.ManifestParserUtils.ContentType.VIDEO,
  926.       codecs: 'avc1',
  927.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  928.       timescale: timescale,
  929.       duration: duration,
  930.       videoNalus: [],
  931.       audioConfig: new Uint8Array([]),
  932.       videoConfig: info.videoConfig,
  933.       hSpacing: info.hSpacing,
  934.       vSpacing: info.vSpacing,
  935.       data: {
  936.         sequenceNumber: this.frameIndex_,
  937.         baseMediaDecodeTime: baseMediaDecodeTime,
  938.         samples: samples,
  939.       },
  940.       stream: stream,
  941.     };
  942.   }
  945.   /**
  946.    * @param {shaka.util.TsParser} tsParser
  947.    * @param {shaka.extern.Stream} stream
  948.    * @param {number} duration
  949.    * @param {?shaka.media.SegmentReference} reference
  950.    * @return {shaka.util.Mp4Generator.StreamInfo}
  951.    * @private
  952.    */
  953.   getHvcStreamInfo_(tsParser, stream, duration, reference) {
  954.     const H265 = shaka.transmuxer.H265;
  955.     const timescale = shaka.util.TsParser.Timescale;
  957.     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
  958.     const samples = [];
  960.     /** @type {?number} */
  961.     let baseMediaDecodeTime = null;
  963.     const nalus = [];
  964.     const videoData = tsParser.getVideoData();
  965.     if (!videoData.length) {
  966.       throw new shaka.util.Error(
  967.           shaka.util.Error.Severity.CRITICAL,
  968.           shaka.util.Error.Category.MEDIA,
  969.           shaka.util.Error.Code.TRANSMUXING_NO_VIDEO_DATA,
  970.           reference ? reference.getUris()[0] : null);
  971.     }
  972.     for (let i = 0; i < videoData.length; i++) {
  973.       const pes = videoData[i];
  974.       const dataNalus = pes.nalus;
  975.       nalus.push(...dataNalus);
  976.       const frame = H265.parseFrame(dataNalus);
  977.       if (!frame) {
  978.         continue;
  979.       }
  980.       if (baseMediaDecodeTime == null && pes.dts != null) {
  981.         baseMediaDecodeTime = pes.dts;
  982.       }
  983.       let duration;
  984.       if (i + 1 < videoData.length) {
  985.         duration = (videoData[i + 1].dts || 0) - (pes.dts || 0);
  986.       } else if (videoData.length > 1) {
  987.         duration = (pes.dts || 0) - (videoData[i - 1].dts || 0);
  988.       } else {
  989.         duration = (reference.endTime - reference.startTime) * timescale;
  990.       }
  991.       samples.push({
  992.         data: frame.data,
  993.         size: frame.data.byteLength,
  994.         duration: duration,
  995.         cts: Math.round((pes.pts || 0) - (pes.dts || 0)),
  996.         flags: {
  997.           isLeading: 0,
  998.           isDependedOn: 0,
  999.           hasRedundancy: 0,
  1000.           degradPrio: 0,
  1001.           dependsOn: frame.isKeyframe ? 2 : 1,
  1002.           isNonSync: frame.isKeyframe ? 0 : 1,
  1003.         },
  1004.       });
  1005.     }
  1007.     const info = H265.parseInfo(nalus);
  1009.     if (!info || baseMediaDecodeTime == null) {
  1010.       throw new shaka.util.Error(
  1011.           shaka.util.Error.Severity.CRITICAL,
  1012.           shaka.util.Error.Category.MEDIA,
  1013.           shaka.util.Error.Code.TRANSMUXING_FAILED,
  1014.           reference ? reference.getUris()[0] : null);
  1015.     }
  1016.     stream.height = info.height;
  1017.     stream.width = info.width;
  1019.     return {
  1020.       id: stream.id,
  1021.       type: shaka.util.ManifestParserUtils.ContentType.VIDEO,
  1022.       codecs: 'hvc1',
  1023.       encrypted: stream.encrypted && stream.drmInfos.length > 0,
  1024.       timescale: timescale,
  1025.       duration: duration,
  1026.       videoNalus: [],
  1027.       audioConfig: new Uint8Array([]),
  1028.       videoConfig: info.videoConfig,
  1029.       hSpacing: info.hSpacing,
  1030.       vSpacing: info.vSpacing,
  1031.       data: {
  1032.         sequenceNumber: this.frameIndex_,
  1033.         baseMediaDecodeTime: baseMediaDecodeTime,
  1034.         samples: samples,
  1035.       },
  1036.       stream: stream,
  1037.     };
  1038.   }
  1039. };
  1041. /**
  1042.  * Supported audio codecs.
  1043.  *
  1044.  * @private
  1045.  * @const {!Array.<string>}
  1046.  */
  1047. shaka.transmuxer.TsTransmuxer.SUPPORTED_AUDIO_CODECS_ = [
  1048.   'aac',
  1049.   'ac-3',
  1050.   'ec-3',
  1051.   'mp3',
  1052.   'opus',
  1053. ];
  1055. /**
  1056.  * Supported audio codecs.
  1057.  *
  1058.  * @private
  1059.  * @const {!Array.<string>}
  1060.  */
  1061. shaka.transmuxer.TsTransmuxer.SUPPORTED_VIDEO_CODECS_ = [
  1062.   'avc',
  1063.   'hevc',
  1064. ];
  1067. shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
  1068.     'video/mp2t',
  1069.     () => new shaka.transmuxer.TsTransmuxer('video/mp2t'),
  1070.     shaka.transmuxer.TransmuxerEngine.PluginPriority.PREFERRED);