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