Source: lib/util/ts_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.TsParser');
  9. goog.require('shaka.Deprecate');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.ExpGolomb');
  12. goog.require('shaka.util.Id3Utils');
  13. goog.require('shaka.util.StringUtils');
  14. goog.require('shaka.util.Uint8ArrayUtils');
  17. /**
  18.  * @see https://en.wikipedia.org/wiki/MPEG_transport_stream
  19.  * @export
  20.  */
  21. shaka.util.TsParser = class {
  22.   /** */
  23.   constructor() {
  24.     /** @private {?number} */
  25.     this.pmtId_ = null;
  27.     /** @private {boolean} */
  28.     this.pmtParsed_ = false;
  30.     /** @private {?number} */
  31.     this.videoPid_ = null;
  33.     /** @private {?string} */
  34.     this.videoCodec_ = null;
  36.     /** @private {!Array.<!Array.<Uint8Array>>} */
  37.     this.videoData_ = [];
  39.     /** @private {!Array.<shaka.extern.MPEG_PES>} */
  40.     this.videoPes_ = [];
  42.     /** @private {?number} */
  43.     this.audioPid_ = null;
  45.     /** @private {?string} */
  46.     this.audioCodec_ = null;
  48.     /** @private {!Array.<!Array.<Uint8Array>>} */
  49.     this.audioData_ = [];
  51.     /** @private {!Array.<shaka.extern.MPEG_PES>} */
  52.     this.audioPes_ = [];
  54.     /** @private {?number} */
  55.     this.id3Pid_ = null;
  57.     /** @private {!Array.<!Array.<Uint8Array>>} */
  58.     this.id3Data_ = [];
  60.     /** @private {?number} */
  61.     this.referencePts_ = null;
  63.     /** @private {?number} */
  64.     this.referenceDts_ = null;
  66.     /** @private {?shaka.util.TsParser.OpusMetadata} */
  67.     this.opusMetadata_ = null;
  68.   }
  70.   /**
  71.    * Clear previous data
  72.    *
  73.    * @export
  74.    */
  75.   clearData() {
  76.     this.videoData_ = [];
  77.     this.videoPes_ = [];
  78.     this.audioData_ = [];
  79.     this.audioPes_ = [];
  80.     this.id3Data_ = [];
  81.   }
  83.   /**
  84.    * Parse the given data
  85.    *
  86.    * @param {Uint8Array} data
  87.    * @return {!shaka.util.TsParser}
  88.    * @export
  89.    */
  90.   parse(data) {
  91.     const packetLength = shaka.util.TsParser.PacketLength_;
  93.     // A TS fragment should contain at least 3 TS packets, a PAT, a PMT, and
  94.     // one PID.
  95.     if (data.length < 3 * packetLength) {
  96.       return this;
  97.     }
  98.     const syncOffset = Math.max(0, shaka.util.TsParser.syncOffset(data));
  100.     const length = data.length - (data.length + syncOffset) % packetLength;
  102.     let unknownPIDs = false;
  104.     // loop through TS packets
  105.     for (let start = syncOffset; start < length; start += packetLength) {
  106.       if (data[start] == 0x47) {
  107.         const payloadUnitStartIndicator = !!(data[start + 1] & 0x40);
  108.         // pid is a 13-bit field starting at the last 5 bits of TS[1]
  109.         const pid = ((data[start + 1] & 0x1f) << 8) + data[start + 2];
  110.         const adaptationFieldControl = (data[start + 3] & 0x30) >> 4;
  112.         // if an adaption field is present, its length is specified by the
  113.         // fifth byte of the TS packet header.
  114.         let offset;
  115.         if (adaptationFieldControl > 1) {
  116.           offset = start + 5 + data[start + 4];
  117.           // continue if there is only adaptation field
  118.           if (offset == start + packetLength) {
  119.             continue;
  120.           }
  121.         } else {
  122.           offset = start + 4;
  123.         }
  124.         switch (pid) {
  125.           case 0:
  126.             if (payloadUnitStartIndicator) {
  127.               offset += data[offset] + 1;
  128.             }
  130.             this.pmtId_ = this.getPmtId_(data, offset);
  131.             break;
  132.           case 17:
  133.           case 0x1fff:
  134.             break;
  135.           case this.pmtId_: {
  136.             if (payloadUnitStartIndicator) {
  137.               offset += data[offset] + 1;
  138.             }
  140.             const parsedPIDs = this.parsePMT_(data, offset);
  142.             // only update track id if track PID found while parsing PMT
  143.             // this is to avoid resetting the PID to -1 in case
  144.             // track PID transiently disappears from the stream
  145.             // this could happen in case of transient missing audio samples
  146.             // for example
  147.             // NOTE this is only the PID of the track as found in TS,
  148.             // but we are not using this for MP4 track IDs.
  149.             if (parsedPIDs.video != -1) {
  150.               this.videoPid_ = parsedPIDs.video;
  151.               this.videoCodec_ = parsedPIDs.videoCodec;
  152.             }
  153.             if (parsedPIDs.audio != -1) {
  154.               this.audioPid_ = parsedPIDs.audio;
  155.               this.audioCodec_ = parsedPIDs.audioCodec;
  156.             }
  157.             if (parsedPIDs.id3 != -1) {
  158.               this.id3Pid_ = parsedPIDs.id3;
  159.             }
  161.             if (unknownPIDs && !this.pmtParsed_) {
  162.               shaka.log.debug('reparse from beginning');
  163.               unknownPIDs = false;
  164.               // we set it to -188, the += 188 in the for loop will reset
  165.               // start to 0
  166.               start = syncOffset - packetLength;
  167.             }
  168.             this.pmtParsed_ = true;
  169.             break;
  170.           }
  171.           case this.videoPid_: {
  172.             const videoData = data.subarray(offset, start + packetLength);
  173.             if (payloadUnitStartIndicator) {
  174.               this.videoData_.push([videoData]);
  175.             } else if (this.videoData_.length) {
  176.               const prevVideoData = this.videoData_[this.videoData_.length - 1];
  177.               if (prevVideoData) {
  178.                 this.videoData_[this.videoData_.length - 1].push(videoData);
  179.               }
  180.             }
  181.             break;
  182.           }
  183.           case this.audioPid_: {
  184.             const audioData = data.subarray(offset, start + packetLength);
  185.             if (payloadUnitStartIndicator) {
  186.               this.audioData_.push([audioData]);
  187.             } else if (this.audioData_.length) {
  188.               const prevAudioData = this.audioData_[this.audioData_.length - 1];
  189.               if (prevAudioData) {
  190.                 this.audioData_[this.audioData_.length - 1].push(audioData);
  191.               }
  192.             }
  193.             break;
  194.           }
  195.           case this.id3Pid_: {
  196.             const id3Data = data.subarray(offset, start + packetLength);
  197.             if (payloadUnitStartIndicator) {
  198.               this.id3Data_.push([id3Data]);
  199.             } else if (this.id3Data_.length) {
  200.               const prevId3Data = this.id3Data_[this.id3Data_.length - 1];
  201.               if (prevId3Data) {
  202.                 this.id3Data_[this.id3Data_.length - 1].push(id3Data);
  203.               }
  204.             }
  205.             break;
  206.           }
  207.           default:
  208.             unknownPIDs = true;
  209.             break;
  210.         }
  211.       } else {
  212.         shaka.log.warning('Found TS packet that do not start with 0x47');
  213.       }
  214.     }
  215.     return this;
  216.   }
  218.   /**
  219.    * Get the PMT ID from the PAT
  220.    *
  221.    * @param {Uint8Array} data
  222.    * @param {number} offset
  223.    * @return {number}
  224.    * @private
  225.    */
  226.   getPmtId_(data, offset) {
  227.     // skip the PSI header and parse the first PMT entry
  228.     return ((data[offset + 10] & 0x1f) << 8) | data[offset + 11];
  229.   }
  231.   /**
  232.    * Parse PMT
  233.    *
  234.    * @param {Uint8Array} data
  235.    * @param {number} offset
  236.    * @return {!shaka.util.TsParser.PMT}
  237.    * @private
  238.    */
  239.   parsePMT_(data, offset) {
  240.     const StringUtils = shaka.util.StringUtils;
  241.     const result = {
  242.       audio: -1,
  243.       video: -1,
  244.       id3: -1,
  245.       audioCodec: '',
  246.       videoCodec: '',
  247.     };
  248.     const sectionLength = ((data[offset + 1] & 0x0f) << 8) | data[offset + 2];
  249.     const tableEnd = offset + 3 + sectionLength - 4;
  250.     // to determine where the table is, we have to figure out how
  251.     // long the program info descriptors are
  252.     const programInfoLength =
  253.       ((data[offset + 10] & 0x0f) << 8) | data[offset + 11];
  254.     // advance the offset to the first entry in the mapping table
  255.     offset += 12 + programInfoLength;
  256.     while (offset < tableEnd) {
  257.       const pid = ((data[offset + 1] & 0x1f) << 8) | data[offset + 2];
  258.       const esInfoLength = ((data[offset + 3] & 0x0f) << 8) | data[offset + 4];
  259.       switch (data[offset]) {
  260.         case 0x06:
  261.           // stream_type 6 can mean a lot of different things in case of DVB.
  262.           // We need to look at the descriptors. Right now, we're only
  263.           // interested in a few audio and video formats,.
  264.           if (esInfoLength > 0) {
  265.             let parsePos = offset + 5;
  266.             let remaining = esInfoLength;
  267.             // Descriptor info: https://www.streamguru.de/mpeg-analyzer/supported-descriptor-list/
  268.             while (remaining > 2) {
  269.               const descriptorId = data[parsePos];
  270.               const descriptorLen = data[parsePos + 1] + 2;
  271.               switch (descriptorId) {
  272.                 // Registration descriptor
  273.                 case 0x05: {
  274.                   const registrationData =
  275.                       data.subarray(parsePos + 2, parsePos + descriptorLen);
  276.                   const registration =
  277.                       StringUtils.fromCharCode(registrationData);
  278.                   if (result.audio == -1 && registration === 'Opus') {
  279.                     result.audio = pid;
  280.                     result.audioCodec = 'opus';
  281.                   } else if (result.video == -1 && registration === 'AV01') {
  282.                     result.video = pid;
  283.                     result.videoCodec = 'av1';
  284.                   }
  285.                   break;
  286.                 }
  287.                 // DVB Descriptor for AC-3
  288.                 case 0x6a:
  289.                   if (result.audio == -1) {
  290.                     result.audio = pid;
  291.                     result.audioCodec = 'ac3';
  292.                   }
  293.                   break;
  294.                 // DVB Descriptor for EC-3
  295.                 case 0x7a:
  296.                   if (result.audio == -1) {
  297.                     result.audio = pid;
  298.                     result.audioCodec = 'ec3';
  299.                   }
  300.                   break;
  301.                 // DVB Descriptor for AAC
  302.                 case 0x7c:
  303.                   if (result.audio == -1) {
  304.                     result.audio = pid;
  305.                     result.audioCodec = 'aac';
  306.                   }
  307.                   break;
  308.                 // DVB extension descriptor
  309.                 case 0x7f:
  310.                   if (result.audioCodec == 'opus') {
  311.                     const extensionDescriptorId = data[parsePos + 2];
  312.                     let channelConfigCode = null;
  313.                     // User defined (provisional Opus)
  314.                     if (extensionDescriptorId === 0x80) {
  315.                       channelConfigCode = data[parsePos + 3];
  316.                     }
  318.                     if (channelConfigCode == null) {
  319.                       // Not Supported Opus channel count.
  320.                       break;
  321.                     }
  322.                     const channelCount = (channelConfigCode & 0x0F) === 0 ?
  323.                         2 : (channelConfigCode & 0x0F);
  324.                     this.opusMetadata_ = {
  325.                       channelCount,
  326.                       channelConfigCode,
  327.                       sampleRate: 48000,
  328.                     };
  329.                   }
  330.                   break;
  331.               }
  332.               parsePos += descriptorLen;
  333.               remaining -= descriptorLen;
  334.             }
  335.           }
  336.           break;
  337.         // SAMPLE-AES AAC
  338.         case 0xcf:
  339.           break;
  340.         // ISO/IEC 13818-7 ADTS AAC (MPEG-2 lower bit-rate audio)
  341.         case 0x0f:
  342.           if (result.audio == -1) {
  343.             result.audio = pid;
  344.             result.audioCodec = 'aac';
  345.           }
  346.           break;
  347.         // LOAS/LATM AAC
  348.         case 0x11:
  349.           if (result.audio == -1) {
  350.             result.audio = pid;
  351.             result.audioCodec = 'aac-loas';
  352.           }
  353.           break;
  354.         // Packetized metadata (ID3)
  355.         case 0x15:
  356.           if (result.id3 == -1) {
  357.             result.id3 = pid;
  358.           }
  359.           break;
  360.         // SAMPLE-AES AVC
  361.         case 0xdb:
  362.           break;
  363.         // ITU-T Rec. H.264 and ISO/IEC 14496-10 (lower bit-rate video)
  364.         case 0x1b:
  365.           if (result.video == -1) {
  366.             result.video = pid;
  367.             result.videoCodec = 'avc';
  368.           }
  369.           break;
  370.         // ISO/IEC 11172-3 (MPEG-1 audio)
  371.         // or ISO/IEC 13818-3 (MPEG-2 halved sample rate audio)
  372.         case 0x03:
  373.         case 0x04:
  374.           if (result.audio == -1) {
  375.             result.audio = pid;
  376.             result.audioCodec = 'mp3';
  377.           }
  378.           break;
  379.         // HEVC
  380.         case 0x24:
  381.           if (result.video == -1) {
  382.             result.video = pid;
  383.             result.videoCodec = 'hvc';
  384.           }
  385.           break;
  386.         // AC-3
  387.         case 0x81:
  388.           if (result.audio == -1) {
  389.             result.audio = pid;
  390.             result.audioCodec = 'ac3';
  391.           }
  392.           break;
  393.         // EC-3
  394.         case 0x84:
  395.         case 0x87:
  396.           if (result.audio == -1) {
  397.             result.audio = pid;
  398.             result.audioCodec = 'ec3';
  399.           }
  400.           break;
  401.         default:
  402.           // shaka.log.warning('Unknown stream type:', data[offset]);
  403.           break;
  404.       }
  405.       // move to the next table entry
  406.       // skip past the elementary stream descriptors, if present
  407.       offset += esInfoLength + 5;
  408.     }
  409.     return result;
  410.   }
  412.   /**
  413.    * Parse PES
  414.    *
  415.    * @param {Uint8Array} data
  416.    * @return {?shaka.extern.MPEG_PES}
  417.    * @private
  418.    */
  419.   parsePES_(data) {
  420.     const startPrefix = (data[0] << 16) | (data[1] << 8) | data[2];
  421.     // In certain live streams, the start of a TS fragment has ts packets
  422.     // that are frame data that is continuing from the previous fragment. This
  423.     // is to check that the pes data is the start of a new pes data
  424.     if (startPrefix !== 1) {
  425.       return null;
  426.     }
  427.     /** @type {shaka.extern.MPEG_PES} */
  428.     const pes = {
  429.       data: new Uint8Array(0),
  430.       // get the packet length, this will be 0 for video
  431.       packetLength: ((data[4] << 8) | data[5]),
  432.       pts: null,
  433.       dts: null,
  434.       nalus: [],
  435.     };
  437.     // if PES parsed length is not zero and greater than total received length,
  438.     // stop parsing. PES might be truncated. minus 6 : PES header size
  439.     if (pes.packetLength && pes.packetLength > data.byteLength - 6) {
  440.       return null;
  441.     }
  443.     // PES packets may be annotated with a PTS value, or a PTS value
  444.     // and a DTS value. Determine what combination of values is
  445.     // available to work with.
  446.     const ptsDtsFlags = data[7];
  448.     // PTS and DTS are normally stored as a 33-bit number.  Javascript
  449.     // performs all bitwise operations on 32-bit integers but javascript
  450.     // supports a much greater range (52-bits) of integer using standard
  451.     // mathematical operations.
  452.     // We construct a 31-bit value using bitwise operators over the 31
  453.     // most significant bits and then multiply by 4 (equal to a left-shift
  454.     // of 2) before we add the final 2 least significant bits of the
  455.     // timestamp (equal to an OR.)
  456.     if (ptsDtsFlags & 0xC0) {
  457.       // the PTS and DTS are not written out directly. For information
  458.       // on how they are encoded, see
  459.       // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
  460.       const pts =
  461.         (data[9] & 0x0e) * 536870912 + // 1 << 29
  462.         (data[10] & 0xff) * 4194304 + // 1 << 22
  463.         (data[11] & 0xfe) * 16384 + // 1 << 14
  464.         (data[12] & 0xff) * 128 + // 1 << 7
  465.         (data[13] & 0xfe) / 2;
  467.       if (this.referencePts_ == null) {
  468.         this.referencePts_ = pts;
  469.       }
  471.       pes.pts = this.handleRollover_(pts, this.referencePts_);
  472.       this.referencePts_ = pes.pts;
  474.       pes.dts = pes.pts;
  475.       if (ptsDtsFlags & 0x40) {
  476.         const dts =
  477.           (data[14] & 0x0e) * 536870912 + // 1 << 29
  478.           (data[15] & 0xff) * 4194304 + // 1 << 22
  479.           (data[16] & 0xfe) * 16384 + // 1 << 14
  480.           (data[17] & 0xff) * 128 + // 1 << 7
  481.           (data[18] & 0xfe) / 2;
  483.         if (this.referenceDts_ == null) {
  484.           this.referenceDts_ = dts;
  485.         }
  487.         pes.dts = this.handleRollover_(dts, this.referenceDts_);
  488.       }
  489.       this.referenceDts_ = pes.dts;
  490.     }
  492.     const pesHdrLen = data[8];
  493.     // 9 bytes : 6 bytes for PES header + 3 bytes for PES extension
  494.     const payloadStartOffset = pesHdrLen + 9;
  495.     if (data.byteLength <= payloadStartOffset) {
  496.       return null;
  497.     }
  499.     pes.data = data.subarray(payloadStartOffset);
  501.     return pes;
  502.   }
  504.   /**
  505.    * Parse AVC Nalus
  506.    *
  507.    * The code is based on hls.js
  508.    * Credit to https://github.com/video-dev/hls.js/blob/master/src/demux/tsdemuxer.ts
  509.    *
  510.    * @param {shaka.extern.MPEG_PES} pes
  511.    * @param {?shaka.extern.MPEG_PES=} nextPes
  512.    * @return {!Array.<shaka.extern.VideoNalu>}
  513.    * @export
  514.    */
  515.   parseAvcNalus(pes, nextPes) {
  516.     shaka.Deprecate.deprecateFeature(5,
  517.         'TsParser.parseAvcNalus',
  518.         'Please use parseNalus function instead.');
  519.     return this.parseNalus(pes);
  520.   }
  522.   /**
  523.    * Parse AVC and HVC Nalus
  524.    *
  525.    * The code is based on hls.js
  526.    * Credit to https://github.com/video-dev/hls.js/blob/master/src/demux/tsdemuxer.ts
  527.    *
  528.    * @param {shaka.extern.MPEG_PES} pes
  529.    * @param {?shaka.extern.VideoNalu=} lastNalu
  530.    * @param {?number=} lastState
  531.    * @return {!Array.<shaka.extern.VideoNalu>}
  532.    * @export
  533.    */
  534.   parseNalus(pes, lastNalu, lastState) {
  535.     const timescale = shaka.util.TsParser.Timescale;
  536.     const time = pes.pts ? pes.pts / timescale : null;
  537.     const data = pes.data;
  538.     const len = data.byteLength;
  540.     let naluHeaderSize = 1;
  541.     if (this.videoCodec_ == 'hvc') {
  542.       naluHeaderSize = 2;
  543.     }
  545.     // A NALU does not contain is its size.
  546.     // The Annex B specification solves this by requiring ‘Start Codes’ to
  547.     // precede each NALU. A start code is 2 or 3 0x00 bytes followed with a
  548.     // 0x01 byte. e.g. 0x000001 or 0x00000001.
  549.     // More info in: https://stackoverflow.com/questions/24884827/possible-locations-for-sequence-picture-parameter-sets-for-h-264-stream/24890903#24890903
  550.     let numZeros = lastState || 0;
  552.     /** @type {!Array.<shaka.extern.VideoNalu>} */
  553.     const nalus = [];
  555.     // Start position includes the first byte where we read the type.
  556.     // The data we extract begins at the next byte.
  557.     let lastNaluStart = -1;
  558.     // Extracted from the first byte.
  559.     let lastNaluType = 0;
  561.     /** @type {?shaka.extern.VideoNalu} */
  562.     let infoOfLastNalu;
  564.     for (let i = 0; i < len; ++i) {
  565.       const value = data[i];
  566.       if (!value) {
  567.         numZeros++;
  568.       } else if (numZeros >= 2 && value == 1) {
  569.         if (lastNalu && !nalus.length && lastNaluStart == -1) {
  570.           // If we are scanning the next PES, we need append the data to the
  571.           // previous Nalu and don't scan for more nalus.
  572.           const startCodeSize = numZeros > 3 ? 3 : numZeros;
  573.           const lastByteToKeep = i - startCodeSize;
  574.           // Optimization
  575.           if (lastState && lastByteToKeep != 0) {
  576.             const prevData = data.subarray(0, lastByteToKeep);
  577.             lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
  578.                 lastNalu.data, prevData);
  579.             lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
  580.                 lastNalu.fullData, prevData);
  581.           }
  582.         }
  583.         // We just read a start code.  Consume the NALU we passed, if any.
  584.         if (lastNaluStart >= 0) {
  585.           // Because the start position includes the header size.
  586.           const firstByteToKeep = lastNaluStart + naluHeaderSize;
  588.           // Compute the last byte to keep.  The start code is at most 3 zeros.
  589.           // Any earlier zeros are not part of the start code.
  590.           const startCodeSize = (numZeros > 3 ? 3 : numZeros) + 1;
  591.           const lastByteToKeep = i - startCodeSize;
  593.           /** @type {shaka.extern.VideoNalu} */
  594.           const nalu = {
  595.             // subarray's end position is exclusive, so add one.
  596.             data: data.subarray(firstByteToKeep, lastByteToKeep + 1),
  597.             fullData: data.subarray(lastNaluStart, lastByteToKeep + 1),
  598.             type: lastNaluType,
  599.             time: time,
  600.           };
  601.           nalus.push(nalu);
  602.         } else if (lastNalu && !nalus.length) {
  603.           const overflow = i - numZeros;
  604.           if (overflow > 0) {
  605.             const prevData = data.subarray(0, overflow);
  606.             lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
  607.                 lastNalu.data, prevData);
  608.             lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
  609.                 lastNalu.fullData, prevData);
  610.           }
  611.         }
  613.         // We just read a start code, so there should be another byte here, at
  614.         // least, for the NALU type.  Check just in case.
  615.         if (i >= len - naluHeaderSize) {
  616.           shaka.log.warning('Malformed TS, incomplete NALU, ignoring.');
  617.           return nalus;
  618.         }
  620.         // Advance and read the type of the next NALU.
  621.         i++;
  622.         lastNaluStart = i;
  623.         if (this.videoCodec_ == 'hvc') {
  624.           lastNaluType = (data[i] >> 1) & 0x3f;
  625.         } else {
  626.           lastNaluType = data[i] & 0x1f;
  627.         }
  628.         numZeros = 0;
  629.       } else {
  630.         numZeros = 0;
  631.       }
  632.       // If we have gone through all the data from the PES and we have an
  633.       // unfinished Nalu, we will try to use the next PES to complete the
  634.       // unfinished Nalu.
  635.       if (i >= (len - 1) && lastNaluStart >= 0 && numZeros >= 0) {
  636.         // The rest of the buffer was a NALU.
  637.         // Because the start position includes the header size.
  638.         const firstByteToKeep = lastNaluStart + naluHeaderSize;
  639.         infoOfLastNalu = {
  640.           data: data.subarray(firstByteToKeep, len),
  641.           fullData: data.subarray(lastNaluStart, len),
  642.           type: lastNaluType,
  643.           time: time,
  644.         };
  645.       }
  646.     }
  648.     if (infoOfLastNalu) {
  649.       nalus.push(infoOfLastNalu);
  650.     }
  651.     if (!nalus.length && lastNalu) {
  652.       lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
  653.           lastNalu.data, data);
  654.       lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
  655.           lastNalu.fullData, data);
  656.     }
  657.     lastState = Math.min(3, numZeros);
  658.     return nalus;
  659.   }
  661.   /**
  662.    * Return the ID3 metadata
  663.    *
  664.    * @return {!Array.<shaka.extern.ID3Metadata>}
  665.    * @export
  666.    */
  667.   getMetadata() {
  668.     const timescale = shaka.util.TsParser.Timescale;
  669.     const metadata = [];
  670.     for (const id3DataArray of this.id3Data_) {
  671.       const id3Data = shaka.util.Uint8ArrayUtils.concat(...id3DataArray);
  672.       const pes = this.parsePES_(id3Data);
  673.       if (pes) {
  674.         metadata.push({
  675.           cueTime: pes.pts ? pes.pts / timescale : null,
  676.           data: pes.data,
  677.           frames: shaka.util.Id3Utils.getID3Frames(pes.data),
  678.           dts: pes.dts,
  679.           pts: pes.pts,
  680.         });
  681.       }
  682.     }
  683.     return metadata;
  684.   }
  686.   /**
  687.    * Return the audio data
  688.    *
  689.    * @return {!Array.<shaka.extern.MPEG_PES>}
  690.    * @export
  691.    */
  692.   getAudioData() {
  693.     if (this.audioData_.length && !this.audioPes_.length) {
  694.       let sort = false;
  695.       for (const audioDataArray of this.audioData_) {
  696.         const audioData = shaka.util.Uint8ArrayUtils.concat(...audioDataArray);
  697.         const pes = this.parsePES_(audioData);
  698.         let previousPes = this.audioPes_.length ?
  699.             this.audioPes_[this.audioPes_.length - 1] : null;
  700.         if (pes && pes.pts != null && pes.dts != null && (!previousPes ||
  701.             (previousPes.pts != pes.pts && previousPes.dts != pes.dts))) {
  702.           if (this.audioPes_.length && pes.dts < (previousPes.dts || 0)) {
  703.             sort = true;
  704.           }
  705.           this.audioPes_.push(pes);
  706.         } else if (this.audioPes_.length) {
  707.           const data = pes ? pes.data : audioData;
  708.           if (!data) {
  709.             continue;
  710.           }
  711.           previousPes = this.audioPes_.pop();
  712.           previousPes.data =
  713.               shaka.util.Uint8ArrayUtils.concat(previousPes.data, data);
  714.           this.audioPes_.push(previousPes);
  715.         }
  716.       }
  717.       if (sort) {
  718.         this.audioPes_ = this.audioPes_.sort((a, b) => {
  719.           const deltadts = (a.dts || 0) - (b.dts || 0);
  720.           const deltapts = (a.pts || 0) - (b.pts || 0);
  721.           return deltadts || deltapts;
  722.         });
  723.       }
  724.     }
  725.     return this.audioPes_;
  726.   }
  728.   /**
  729.    * Return the video data
  730.    *
  731.    * @param {boolean=} naluProcessing
  732.    * @return {!Array.<shaka.extern.MPEG_PES>}
  733.    * @export
  734.    */
  735.   getVideoData(naluProcessing = true) {
  736.     if (this.videoData_.length && !this.videoPes_.length) {
  737.       let sort = false;
  738.       for (const videoDataArray of this.videoData_) {
  739.         const videoData = shaka.util.Uint8ArrayUtils.concat(...videoDataArray);
  740.         const pes = this.parsePES_(videoData);
  741.         let previousPes = this.videoPes_.length ?
  742.             this.videoPes_[this.videoPes_.length - 1] : null;
  743.         if (pes && pes.pts != null && pes.dts != null && (!previousPes ||
  744.             (previousPes.pts != pes.pts && previousPes.dts != pes.dts))) {
  745.           if (this.videoPes_.length && pes.dts < (previousPes.dts || 0)) {
  746.             sort = true;
  747.           }
  748.           this.videoPes_.push(pes);
  749.         } else if (this.videoPes_.length) {
  750.           const data = pes ? pes.data : videoData;
  751.           if (!data) {
  752.             continue;
  753.           }
  754.           previousPes = this.videoPes_.pop();
  755.           previousPes.data =
  756.               shaka.util.Uint8ArrayUtils.concat(previousPes.data, data);
  757.           this.videoPes_.push(previousPes);
  758.         }
  759.       }
  760.       if (naluProcessing) {
  761.         let lastNalu;
  762.         let lastState;
  763.         const pesWithLength = [];
  764.         for (const pes of this.videoPes_) {
  765.           pes.nalus = this.parseNalus(pes, lastNalu, lastState);
  766.           if (pes.nalus.length) {
  767.             pesWithLength.push(pes);
  768.             lastNalu = pes.nalus[pes.nalus.length - 1];
  769.           }
  770.         }
  771.         this.videoPes_ = pesWithLength;
  772.       }
  773.       if (sort) {
  774.         this.videoPes_ = this.videoPes_.sort((a, b) => {
  775.           const deltadts = (a.dts || 0) - (b.dts || 0);
  776.           const deltapts = (a.pts || 0) - (b.pts || 0);
  777.           return deltadts || deltapts;
  778.         });
  779.       }
  780.     }
  781.     if (!naluProcessing) {
  782.       const prevVideoPes = this.videoPes_;
  783.       this.videoPes_ = [];
  784.       return prevVideoPes;
  785.     }
  786.     return this.videoPes_;
  787.   }
  789.   /**
  790.    * Return the start time for the audio and video
  791.    *
  792.    * @param {string} contentType
  793.    * @return {?number}
  794.    * @export
  795.    */
  796.   getStartTime(contentType) {
  797.     const timescale = shaka.util.TsParser.Timescale;
  798.     if (contentType == 'audio') {
  799.       let audioStartTime = null;
  800.       const audioData = this.getAudioData();
  801.       if (audioData.length) {
  802.         const pes = audioData[0];
  803.         audioStartTime = Math.min(pes.dts, pes.pts) / timescale;
  804.       }
  805.       return audioStartTime;
  806.     } else if (contentType == 'video') {
  807.       let videoStartTime = null;
  808.       const videoData = this.getVideoData(/* naluProcessing= */ false);
  809.       if (videoData.length) {
  810.         const pes = videoData[0];
  811.         videoStartTime = Math.min(pes.dts, pes.pts) / timescale;
  812.       }
  813.       return videoStartTime;
  814.     }
  815.     return null;
  816.   }
  818.   /**
  819.    * Return the audio and video codecs
  820.    *
  821.    * @return {{audio: ?string, video: ?string}}
  822.    * @export
  823.    */
  824.   getCodecs() {
  825.     return {
  826.       audio: this.audioCodec_,
  827.       video: this.videoCodec_,
  828.     };
  829.   }
  831.   /**
  832.    * Return the video data
  833.    *
  834.    * @return {!Array.<shaka.extern.VideoNalu>}
  835.    * @export
  836.    */
  837.   getVideoNalus() {
  838.     const nalus = [];
  839.     for (const pes of this.getVideoData()) {
  840.       nalus.push(...pes.nalus);
  841.     }
  842.     return nalus;
  843.   }
  845.   /**
  846.    * Return the video resolution
  847.    *
  848.    * @return {{height: ?string, width: ?string}}
  849.    * @export
  850.    */
  851.   getVideoResolution() {
  852.     shaka.Deprecate.deprecateFeature(5,
  853.         'TsParser.getVideoResolution',
  854.         'Please use getVideoInfo function instead.');
  855.     const videoInfo = this.getVideoInfo();
  856.     return {
  857.       height: videoInfo.height,
  858.       width: videoInfo.width,
  859.     };
  860.   }
  862.   /**
  863.    * Return the video information
  864.    *
  865.    * @return {{height: ?string, width: ?string, codec: ?string}}
  866.    * @export
  867.    */
  868.   getVideoInfo() {
  869.     if (this.videoCodec_ == 'hvc') {
  870.       return this.getHvcInfo_();
  871.     }
  872.     return this.getAvcInfo_();
  873.   }
  875.   /**
  876.    * Return the video information for AVC
  877.    *
  878.    * @return {{height: ?string, width: ?string, codec: ?string}}
  879.    * @private
  880.    */
  881.   getAvcInfo_() {
  882.     const TsParser = shaka.util.TsParser;
  883.     const videoInfo = {
  884.       height: null,
  885.       width: null,
  886.       codec: null,
  887.     };
  888.     const videoNalus = this.getVideoNalus();
  889.     if (!videoNalus.length) {
  890.       return videoInfo;
  891.     }
  892.     const spsNalu = videoNalus.find((nalu) => {
  893.       return nalu.type == TsParser.H264_NALU_TYPE_SPS_;
  894.     });
  895.     if (!spsNalu) {
  896.       return videoInfo;
  897.     }
  899.     const expGolombDecoder = new shaka.util.ExpGolomb(spsNalu.data);
  900.     // profile_idc
  901.     const profileIdc = expGolombDecoder.readUnsignedByte();
  902.     // constraint_set[0-5]_flag
  903.     const profileCompatibility = expGolombDecoder.readUnsignedByte();
  904.     // level_idc u(8)
  905.     const levelIdc = expGolombDecoder.readUnsignedByte();
  906.     // seq_parameter_set_id
  907.     expGolombDecoder.skipExpGolomb();
  909.     // some profiles have more optional data we don't need
  910.     if (TsParser.PROFILES_WITH_OPTIONAL_SPS_DATA_.includes(profileIdc)) {
  911.       const chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();
  912.       if (chromaFormatIdc === 3) {
  913.         // separate_colour_plane_flag
  914.         expGolombDecoder.skipBits(1);
  915.       }
  916.       // bit_depth_luma_minus8
  917.       expGolombDecoder.skipExpGolomb();
  918.       // bit_depth_chroma_minus8
  919.       expGolombDecoder.skipExpGolomb();
  920.       // qpprime_y_zero_transform_bypass_flag
  921.       expGolombDecoder.skipBits(1);
  922.       // seq_scaling_matrix_present_flag
  923.       if (expGolombDecoder.readBoolean()) {
  924.         const scalingListCount = (chromaFormatIdc !== 3) ? 8 : 12;
  925.         for (let i = 0; i < scalingListCount; i++) {
  926.           // seq_scaling_list_present_flag[ i ]
  927.           if (expGolombDecoder.readBoolean()) {
  928.             if (i < 6) {
  929.               expGolombDecoder.skipScalingList(16);
  930.             } else {
  931.               expGolombDecoder.skipScalingList(64);
  932.             }
  933.           }
  934.         }
  935.       }
  936.     }
  938.     // log2_max_frame_num_minus4
  939.     expGolombDecoder.skipExpGolomb();
  940.     const picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();
  942.     if (picOrderCntType === 0) {
  943.       // log2_max_pic_order_cnt_lsb_minus4
  944.       expGolombDecoder.readUnsignedExpGolomb();
  945.     } else if (picOrderCntType === 1) {
  946.       // delta_pic_order_always_zero_flag
  947.       expGolombDecoder.skipBits(1);
  948.       // offset_for_non_ref_pic
  949.       expGolombDecoder.skipExpGolomb();
  950.       // offset_for_top_to_bottom_field
  951.       expGolombDecoder.skipExpGolomb();
  952.       const numRefFramesInPicOrderCntCycle =
  953.           expGolombDecoder.readUnsignedExpGolomb();
  954.       for (let i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
  955.         // offset_for_ref_frame[ i ]
  956.         expGolombDecoder.skipExpGolomb();
  957.       }
  958.     }
  960.     // max_num_ref_frames
  961.     expGolombDecoder.skipExpGolomb();
  962.     // gaps_in_frame_num_value_allowed_flag
  963.     expGolombDecoder.skipBits(1);
  965.     const picWidthInMbsMinus1 =
  966.         expGolombDecoder.readUnsignedExpGolomb();
  967.     const picHeightInMapUnitsMinus1 =
  968.         expGolombDecoder.readUnsignedExpGolomb();
  970.     const frameMbsOnlyFlag = expGolombDecoder.readBits(1);
  971.     if (frameMbsOnlyFlag === 0) {
  972.       // mb_adaptive_frame_field_flag
  973.       expGolombDecoder.skipBits(1);
  974.     }
  975.     // direct_8x8_inference_flag
  976.     expGolombDecoder.skipBits(1);
  978.     let frameCropLeftOffset = 0;
  979.     let frameCropRightOffset = 0;
  980.     let frameCropTopOffset = 0;
  981.     let frameCropBottomOffset = 0;
  983.     // frame_cropping_flag
  984.     if (expGolombDecoder.readBoolean()) {
  985.       frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();
  986.       frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();
  987.       frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();
  988.       frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();
  989.     }
  991.     videoInfo.height = String(((2 - frameMbsOnlyFlag) *
  992.         (picHeightInMapUnitsMinus1 + 1) * 16) - (frameCropTopOffset * 2) -
  993.         (frameCropBottomOffset * 2));
  994.     videoInfo.width = String(((picWidthInMbsMinus1 + 1) * 16) -
  995.         frameCropLeftOffset * 2 - frameCropRightOffset * 2);
  996.     videoInfo.codec = 'avc1.' + this.byteToHex_(profileIdc) +
  997.         this.byteToHex_(profileCompatibility) + this.byteToHex_(levelIdc);
  999.     return videoInfo;
  1000.   }
  1002.   /**
  1003.    * Return the video information for HVC
  1004.    *
  1005.    * @return {{height: ?string, width: ?string, codec: ?string}}
  1006.    * @private
  1007.    */
  1008.   getHvcInfo_() {
  1009.     const TsParser = shaka.util.TsParser;
  1010.     const videoInfo = {
  1011.       height: null,
  1012.       width: null,
  1013.       codec: null,
  1014.     };
  1015.     const videoNalus = this.getVideoNalus();
  1016.     if (!videoNalus.length) {
  1017.       return videoInfo;
  1018.     }
  1019.     const spsNalu = videoNalus.find((nalu) => {
  1020.       return nalu.type == TsParser.H265_NALU_TYPE_SPS_;
  1021.     });
  1022.     if (!spsNalu) {
  1023.       return videoInfo;
  1024.     }
  1026.     const gb = new shaka.util.ExpGolomb(
  1027.         spsNalu.fullData, /* convertEbsp2rbsp= */ true);
  1029.     // remove NALu Header
  1030.     gb.readUnsignedByte();
  1031.     gb.readUnsignedByte();
  1033.     // SPS
  1034.     gb.readBits(4); // video_paramter_set_id
  1035.     const maxSubLayersMinus1 = gb.readBits(3);
  1036.     gb.readBoolean(); // temporal_id_nesting_flag
  1038.     // profile_tier_level begin
  1039.     const generalProfileSpace = gb.readBits(2);
  1040.     const generalTierFlag = gb.readBits(1);
  1041.     const generalProfileIdc = gb.readBits(5);
  1042.     const generalProfileCompatibilityFlags = gb.readBits(32);
  1043.     const generalConstraintIndicatorFlags1 = gb.readUnsignedByte();
  1044.     const generalConstraintIndicatorFlags2 = gb.readUnsignedByte();
  1045.     const generalConstraintIndicatorFlags3 = gb.readUnsignedByte();
  1046.     const generalConstraintIndicatorFlags4 = gb.readUnsignedByte();
  1047.     const generalConstraintIndicatorFlags5 = gb.readUnsignedByte();
  1048.     const generalConstraintIndicatorFlags6 = gb.readUnsignedByte();
  1049.     const generalLevelIdc = gb.readUnsignedByte();
  1050.     const subLayerProfilePresentFlag = [];
  1051.     const subLayerLevelPresentFlag = [];
  1052.     for (let i = 0; i < maxSubLayersMinus1; i++) {
  1053.       subLayerProfilePresentFlag.push(gb.readBoolean());
  1054.       subLayerLevelPresentFlag.push(gb.readBoolean());
  1055.     }
  1056.     if (maxSubLayersMinus1 > 0) {
  1057.       for (let i = maxSubLayersMinus1; i < 8; i++) {
  1058.         gb.readBits(2);
  1059.       }
  1060.     }
  1061.     for (let i = 0; i < maxSubLayersMinus1; i++) {
  1062.       if (subLayerProfilePresentFlag[i]) {
  1063.         gb.readBits(88);
  1064.       }
  1065.       if (subLayerLevelPresentFlag[i]) {
  1066.         gb.readUnsignedByte();
  1067.       }
  1068.     }
  1069.     // profile_tier_level end
  1071.     gb.readUnsignedExpGolomb(); // seq_parameter_set_id
  1072.     const chromaFormatIdc = gb.readUnsignedExpGolomb();
  1073.     if (chromaFormatIdc == 3) {
  1074.       gb.readBits(1); // separate_colour_plane_flag
  1075.     }
  1076.     const picWidthInLumaSamples = gb.readUnsignedExpGolomb();
  1077.     const picHeightInLumaSamples = gb.readUnsignedExpGolomb();
  1078.     let leftOffset = 0;
  1079.     let rightOffset = 0;
  1080.     let topOffset = 0;
  1081.     let bottomOffset = 0;
  1082.     const conformanceWindowFlag = gb.readBoolean();
  1083.     if (conformanceWindowFlag) {
  1084.       leftOffset += gb.readUnsignedExpGolomb();
  1085.       rightOffset += gb.readUnsignedExpGolomb();
  1086.       topOffset += gb.readUnsignedExpGolomb();
  1087.       bottomOffset += gb.readUnsignedExpGolomb();
  1088.     }
  1090.     const subWc = chromaFormatIdc === 1 || chromaFormatIdc === 2 ? 2 : 1;
  1091.     const subHc = chromaFormatIdc === 1 ? 2 : 1;
  1092.     videoInfo.width =
  1093.         String(picWidthInLumaSamples - (leftOffset + rightOffset) * subWc);
  1094.     videoInfo.height =
  1095.         String(picHeightInLumaSamples - (topOffset + bottomOffset) * subHc);
  1097.     const reverseBits = (integer) => {
  1098.       let result = 0;
  1099.       for (let i = 0; i < 32; i++) {
  1100.         result |= ((integer >> i) & 1) << (31 - i);
  1101.       }
  1102.       return result >>> 0;
  1103.     };
  1105.     const profileSpace = ['', 'A', 'B', 'C'][generalProfileSpace];
  1106.     const profileCompatibility = reverseBits(generalProfileCompatibilityFlags);
  1107.     const tierFlag = generalTierFlag == 1 ? 'H' : 'L';
  1109.     let codec = 'hvc1';
  1110.     codec += '.' + profileSpace + generalProfileIdc;
  1111.     codec += '.' + profileCompatibility.toString(16).toUpperCase();
  1112.     codec += '.' + tierFlag + generalLevelIdc;
  1113.     if (generalConstraintIndicatorFlags6) {
  1114.       codec += '.' +
  1115.           generalConstraintIndicatorFlags6.toString(16).toUpperCase();
  1116.     }
  1117.     if (generalConstraintIndicatorFlags5) {
  1118.       codec += '.' +
  1119.           generalConstraintIndicatorFlags5.toString(16).toUpperCase();
  1120.     }
  1121.     if (generalConstraintIndicatorFlags4) {
  1122.       codec += '.' +
  1123.           generalConstraintIndicatorFlags4.toString(16).toUpperCase();
  1124.     }
  1125.     if (generalConstraintIndicatorFlags3) {
  1126.       codec += '.' +
  1127.           generalConstraintIndicatorFlags3.toString(16).toUpperCase();
  1128.     }
  1129.     if (generalConstraintIndicatorFlags2) {
  1130.       codec += '.' +
  1131.           generalConstraintIndicatorFlags2.toString(16).toUpperCase();
  1132.     }
  1133.     if (generalConstraintIndicatorFlags1) {
  1134.       codec += '.' +
  1135.           generalConstraintIndicatorFlags1.toString(16).toUpperCase();
  1136.     }
  1137.     videoInfo.codec = codec;
  1139.     return videoInfo;
  1140.   }
  1142.   /**
  1143.    * Return the Opus metadata
  1144.    *
  1145.    * @return {?shaka.util.TsParser.OpusMetadata}
  1146.    */
  1147.   getOpusMetadata() {
  1148.     return this.opusMetadata_;
  1149.   }
  1151.   /**
  1152.    * Convert a byte to 2 digits of hex.  (Only handles values 0-255.)
  1153.    *
  1154.    * @param {number} x
  1155.    * @return {string}
  1156.    * @private
  1157.    */
  1158.   byteToHex_(x) {
  1159.     return ('0' + x.toString(16).toUpperCase()).slice(-2);
  1160.   }
  1162.   /**
  1163.    * @param {number} value
  1164.    * @param {number} reference
  1165.    * @return {number}
  1166.    * @private
  1167.    */
  1168.   handleRollover_(value, reference) {
  1169.     const MAX_TS = 8589934592;
  1170.     const RO_THRESH = 4294967296;
  1172.     let direction = 1;
  1174.     if (value > reference) {
  1175.       // If the current timestamp value is greater than our reference timestamp
  1176.       // and we detect a timestamp rollover, this means the roll over is
  1177.       // happening in the opposite direction.
  1178.       // Example scenario: Enter a long stream/video just after a rollover
  1179.       // occurred. The reference point will be set to a small number, e.g. 1.
  1180.       // The user then seeks backwards over the rollover point. In loading this
  1181.       // segment, the timestamp values will be very large, e.g. 2^33 - 1. Since
  1182.       // this comes before the data we loaded previously, we want to adjust the
  1183.       // time stamp to be `value - 2^33`.
  1184.       direction = -1;
  1185.     }
  1187.     // Note: A seek forwards or back that is greater than the RO_THRESH
  1188.     // (2^32, ~13 hours) will cause an incorrect adjustment.
  1189.     while (Math.abs(reference - value) > RO_THRESH) {
  1190.       value += (direction * MAX_TS);
  1191.     }
  1193.     return value;
  1194.   }
  1196.   /**
  1197.    * Check if the passed data corresponds to an MPEG2-TS
  1198.    *
  1199.    * @param {Uint8Array} data
  1200.    * @return {boolean}
  1201.    * @export
  1202.    */
  1203.   static probe(data) {
  1204.     const syncOffset = shaka.util.TsParser.syncOffset(data);
  1205.     if (syncOffset < 0) {
  1206.       return false;
  1207.     } else {
  1208.       if (syncOffset > 0) {
  1209.         shaka.log.warning('MPEG2-TS detected but first sync word found @ ' +
  1210.             'offset ' + syncOffset + ', junk ahead ?');
  1211.       }
  1212.       return true;
  1213.     }
  1214.   }
  1216.   /**
  1217.    * Returns the synchronization offset
  1218.    *
  1219.    * @param {Uint8Array} data
  1220.    * @return {number}
  1221.    * @export
  1222.    */
  1223.   static syncOffset(data) {
  1224.     const packetLength = shaka.util.TsParser.PacketLength_;
  1225.     // scan 1000 first bytes
  1226.     const scanwindow = Math.min(1000, data.length - 3 * packetLength);
  1227.     let i = 0;
  1228.     while (i < scanwindow) {
  1229.       // a TS fragment should contain at least 3 TS packets, a PAT, a PMT, and
  1230.       // one PID, each starting with 0x47
  1231.       if (data[i] == 0x47 &&
  1232.           data[i + packetLength] == 0x47 &&
  1233.           data[i + 2 * packetLength] == 0x47) {
  1234.         return i;
  1235.       } else {
  1236.         i++;
  1237.       }
  1238.     }
  1239.     return -1;
  1240.   }
  1241. };
  1244. /**
  1245.  * @const {number}
  1246.  * @export
  1247.  */
  1248. shaka.util.TsParser.Timescale = 90000;
  1251. /**
  1252.  * @const {number}
  1253.  * @private
  1254.  */
  1255. shaka.util.TsParser.PacketLength_ = 188;
  1258. /**
  1259.  * NALU type for Sequence Parameter Set (SPS) for H.264.
  1260.  * @const {number}
  1261.  * @private
  1262.  */
  1263. shaka.util.TsParser.H264_NALU_TYPE_SPS_ = 0x07;
  1266. /**
  1267.  * NALU type for Sequence Parameter Set (SPS) for H.265.
  1268.  * @const {number}
  1269.  * @private
  1270.  */
  1271. shaka.util.TsParser.H265_NALU_TYPE_SPS_ = 0x21;
  1274. /**
  1275.  * Values of profile_idc that indicate additional fields are included in the
  1276.  * SPS.
  1277.  * see Recommendation ITU-T H.264 (4/2013)
  1278.  * 7.3.2.1.1 Sequence parameter set data syntax
  1279.  *
  1280.  * @const {!Array.<number>}
  1281.  * @private
  1282.  */
  1283. shaka.util.TsParser.PROFILES_WITH_OPTIONAL_SPS_DATA_ =
  1284.     [100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134];
  1287. /**
  1288.  * @typedef {{
  1289.  *   audio: number,
  1290.  *   video: number,
  1291.  *   id3: number,
  1292.  *   audioCodec: string,
  1293.  *   videoCodec: string
  1294.  * }}
  1295.  *
  1296.  * @summary PMT.
  1297.  * @property {number} audio
  1298.  *   Audio PID
  1299.  * @property {number} video
  1300.  *   Video PID
  1301.  * @property {number} id3
  1302.  *   ID3 PID
  1303.  * @property {string} audioCodec
  1304.  *   Audio codec
  1305.  * @property {string} videoCodec
  1306.  *   Video codec
  1307.  */
  1308. shaka.util.TsParser.PMT;
  1311. /**
  1312.  * @typedef {{
  1313.  *   channelCount: number,
  1314.  *   channelConfigCode: number,
  1315.  *   sampleRate: number
  1316.  * }}
  1317.  *
  1318.  * @summary PMT.
  1319.  * @property {number} channelCount
  1320.  * @property {number} channelConfigCode
  1321.  * @property {number} sampleRate
  1322.  */
  1323. shaka.util.TsParser.OpusMetadata;