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.Uint8ArrayUtils');
  16. /**
  17.  * @see https://en.wikipedia.org/wiki/MPEG_transport_stream
  18.  * @export
  19.  */
  20. shaka.util.TsParser = class {
  21.   /** */
  22.   constructor() {
  23.     /** @private {?number} */
  24.     this.pmtId_ = null;
  26.     /** @private {boolean} */
  27.     this.pmtParsed_ = false;
  29.     /** @private {?number} */
  30.     this.videoPid_ = null;
  32.     /** @private {?string} */
  33.     this.videoCodec_ = null;
  35.     /** @private {!Array.<Uint8Array>} */
  36.     this.videoData_ = [];
  38.     /** @private {?number} */
  39.     this.audioPid_ = null;
  41.     /** @private {?string} */
  42.     this.audioCodec_ = null;
  44.     /** @private {!Array.<Uint8Array>} */
  45.     this.audioData_ = [];
  47.     /** @private {?number} */
  48.     this.id3Pid_ = null;
  50.     /** @private {!Array.<Uint8Array>} */
  51.     this.id3Data_ = [];
  52.   }
  54.   /**
  55.    * Clear previous data
  56.    *
  57.    * @export
  58.    */
  59.   clearData() {
  60.     this.videoData_ = [];
  61.     this.audioData_ = [];
  62.     this.id3Data_ = [];
  63.   }
  65.   /**
  66.    * Parse the given data
  67.    *
  68.    * @param {Uint8Array} data
  69.    * @return {!shaka.util.TsParser}
  70.    * @export
  71.    */
  72.   parse(data) {
  73.     const packetLength = shaka.util.TsParser.PacketLength_;
  74.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  76.     // A TS fragment should contain at least 3 TS packets, a PAT, a PMT, and
  77.     // one PID.
  78.     if (data.length < 3 * packetLength) {
  79.       return this;
  80.     }
  81.     const syncOffset = Math.max(0, shaka.util.TsParser.syncOffset(data));
  83.     const length = data.length - (data.length + syncOffset) % packetLength;
  85.     let unknownPIDs = false;
  87.     // loop through TS packets
  88.     for (let start = syncOffset; start < length; start += packetLength) {
  89.       if (data[start] == 0x47) {
  90.         const payloadUnitStartIndicator = !!(data[start + 1] & 0x40);
  91.         // pid is a 13-bit field starting at the last 5 bits of TS[1]
  92.         const pid = ((data[start + 1] & 0x1f) << 8) + data[start + 2];
  93.         const adaptationFieldControl = (data[start + 3] & 0x30) >> 4;
  95.         // if an adaption field is present, its length is specified by the
  96.         // fifth byte of the TS packet header.
  97.         let offset;
  98.         if (adaptationFieldControl > 1) {
  99.           offset = start + 5 + data[start + 4];
  100.           // continue if there is only adaptation field
  101.           if (offset == start + packetLength) {
  102.             continue;
  103.           }
  104.         } else {
  105.           offset = start + 4;
  106.         }
  107.         switch (pid) {
  108.           case 0:
  109.             if (payloadUnitStartIndicator) {
  110.               offset += data[offset] + 1;
  111.             }
  113.             this.pmtId_ = this.getPmtId_(data, offset);
  114.             break;
  115.           case 17:
  116.           case 0x1fff:
  117.             break;
  118.           case this.pmtId_: {
  119.             if (payloadUnitStartIndicator) {
  120.               offset += data[offset] + 1;
  121.             }
  123.             const parsedPIDs = this.parsePMT_(data, offset);
  125.             // only update track id if track PID found while parsing PMT
  126.             // this is to avoid resetting the PID to -1 in case
  127.             // track PID transiently disappears from the stream
  128.             // this could happen in case of transient missing audio samples
  129.             // for example
  130.             // NOTE this is only the PID of the track as found in TS,
  131.             // but we are not using this for MP4 track IDs.
  132.             if (parsedPIDs.video != -1) {
  133.               this.videoPid_ = parsedPIDs.video;
  134.               this.videoCodec_ = parsedPIDs.videoCodec;
  135.             }
  136.             if (parsedPIDs.audio != -1) {
  137.               this.audioPid_ = parsedPIDs.audio;
  138.               this.audioCodec_ = parsedPIDs.audioCodec;
  139.             }
  140.             if (parsedPIDs.id3 != -1) {
  141.               this.id3Pid_ = parsedPIDs.id3;
  142.             }
  144.             if (unknownPIDs && !this.pmtParsed_) {
  145.               shaka.log.debug('reparse from beginning');
  146.               unknownPIDs = false;
  147.               // we set it to -188, the += 188 in the for loop will reset
  148.               // start to 0
  149.               start = syncOffset - packetLength;
  150.             }
  151.             this.pmtParsed_ = true;
  152.             break;
  153.           }
  154.           case this.videoPid_: {
  155.             const videoData = data.subarray(offset, start + packetLength);
  156.             if (payloadUnitStartIndicator) {
  157.               this.videoData_.push(videoData);
  158.             } else if (this.videoData_.length) {
  159.               const prevVideoData = this.videoData_[this.videoData_.length - 1];
  160.               if (prevVideoData) {
  161.                 this.videoData_[this.videoData_.length - 1] =
  162.                     Uint8ArrayUtils.concat(prevVideoData, videoData);
  163.               }
  164.             }
  165.             break;
  166.           }
  167.           case this.audioPid_: {
  168.             const audioData = data.subarray(offset, start + packetLength);
  169.             if (payloadUnitStartIndicator) {
  170.               this.audioData_.push(audioData);
  171.             } else if (this.audioData_.length) {
  172.               const prevAudioData = this.audioData_[this.audioData_.length - 1];
  173.               if (prevAudioData) {
  174.                 this.audioData_[this.audioData_.length - 1] =
  175.                     Uint8ArrayUtils.concat(prevAudioData, audioData);
  176.               }
  177.             }
  178.             break;
  179.           }
  180.           case this.id3Pid_: {
  181.             const id3Data = data.subarray(offset, start + packetLength);
  182.             if (payloadUnitStartIndicator) {
  183.               this.id3Data_.push(id3Data);
  184.             } else if (this.id3Data_.length) {
  185.               const prevId3Data = this.id3Data_[this.id3Data_.length - 1];
  186.               if (prevId3Data) {
  187.                 this.id3Data_[this.id3Data_.length - 1] =
  188.                     Uint8ArrayUtils.concat(prevId3Data, id3Data);
  189.               }
  190.             }
  191.             break;
  192.           }
  193.           default:
  194.             unknownPIDs = true;
  195.             break;
  196.         }
  197.       } else {
  198.         shaka.log.warning('Found TS packet that do not start with 0x47');
  199.       }
  200.     }
  201.     return this;
  202.   }
  204.   /**
  205.    * Get the PMT ID from the PAT
  206.    *
  207.    * @param {Uint8Array} data
  208.    * @param {number} offset
  209.    * @return {number}
  210.    * @private
  211.    */
  212.   getPmtId_(data, offset) {
  213.     // skip the PSI header and parse the first PMT entry
  214.     return ((data[offset + 10] & 0x1f) << 8) | data[offset + 11];
  215.   }
  217.   /**
  218.    * Parse PMT
  219.    *
  220.    * @param {Uint8Array} data
  221.    * @param {number} offset
  222.    * @return {!shaka.util.TsParser.PMT}
  223.    * @private
  224.    */
  225.   parsePMT_(data, offset) {
  226.     const result = {
  227.       audio: -1,
  228.       video: -1,
  229.       id3: -1,
  230.       audioCodec: '',
  231.       videoCodec: '',
  232.     };
  233.     const sectionLength = ((data[offset + 1] & 0x0f) << 8) | data[offset + 2];
  234.     const tableEnd = offset + 3 + sectionLength - 4;
  235.     // to determine where the table is, we have to figure out how
  236.     // long the program info descriptors are
  237.     const programInfoLength =
  238.       ((data[offset + 10] & 0x0f) << 8) | data[offset + 11];
  239.     // advance the offset to the first entry in the mapping table
  240.     offset += 12 + programInfoLength;
  241.     while (offset < tableEnd) {
  242.       const pid = ((data[offset + 1] & 0x1f) << 8) | data[offset + 2];
  243.       const esInfoLength = ((data[offset + 3] & 0x0f) << 8) | data[offset + 4];
  244.       switch (data[offset]) {
  245.         case 0x06:
  246.           // stream_type 6 can mean a lot of different things in case of DVB.
  247.           // We need to look at the descriptors. Right now, we're only
  248.           // interested in AC-3 and EC-3 audio, so we do the descriptor parsing
  249.           // only when we don't have an audio PID yet.
  250.           if (result.audio == -1 && esInfoLength > 0) {
  251.             let parsePos = offset + 5;
  252.             let remaining = esInfoLength;
  253.             while (remaining > 2) {
  254.               const descriptorId = data[parsePos];
  255.               switch (descriptorId) {
  256.                 // DVB Descriptor for AC-3
  257.                 case 0x6a:
  258.                   result.audio = pid;
  259.                   result.audioCodec = 'ac3';
  260.                   break;
  261.                 // DVB Descriptor for EC-3
  262.                 case 0x7a:
  263.                   result.audio = pid;
  264.                   result.audioCodec = 'ec3';
  265.                   break;
  266.               }
  267.               const descriptorLen = data[parsePos + 1] + 2;
  268.               parsePos += descriptorLen;
  269.               remaining -= descriptorLen;
  270.             }
  271.           }
  272.           break;
  273.         // SAMPLE-AES AAC
  274.         case 0xcf:
  275.           break;
  276.         // ISO/IEC 13818-7 ADTS AAC (MPEG-2 lower bit-rate audio)
  277.         case 0x0f:
  278.           if (result.audio == -1) {
  279.             result.audio = pid;
  280.             result.audioCodec = 'aac';
  281.           }
  282.           break;
  283.         // Packetized metadata (ID3)
  284.         case 0x15:
  285.           if (result.id3 == -1) {
  286.             result.id3 = pid;
  287.           }
  288.           break;
  289.         // SAMPLE-AES AVC
  290.         case 0xdb:
  291.           break;
  292.         // ITU-T Rec. H.264 and ISO/IEC 14496-10 (lower bit-rate video)
  293.         case 0x1b:
  294.           if (result.video == -1) {
  295.             result.video = pid;
  296.             result.videoCodec = 'avc';
  297.           }
  298.           break;
  299.         // ISO/IEC 11172-3 (MPEG-1 audio)
  300.         // or ISO/IEC 13818-3 (MPEG-2 halved sample rate audio)
  301.         case 0x03:
  302.         case 0x04:
  303.           if (result.audio == -1) {
  304.             result.audio = pid;
  305.             result.audioCodec = 'mp3';
  306.           }
  307.           break;
  308.         // HEVC
  309.         case 0x24:
  310.           if (result.video == -1) {
  311.             result.video = pid;
  312.             result.videoCodec = 'hvc';
  313.           }
  314.           break;
  315.         // AC-3
  316.         case 0x81:
  317.           if (result.audio == -1) {
  318.             result.audio = pid;
  319.             result.audioCodec = 'ac3';
  320.           }
  321.           break;
  322.         // EC-3
  323.         case 0x84:
  324.         case 0x87:
  325.           if (result.audio == -1) {
  326.             result.audio = pid;
  327.             result.audioCodec = 'ec3';
  328.           }
  329.           break;
  330.         default:
  331.           // shaka.log.warning('Unknown stream type:', data[offset]);
  332.           break;
  333.       }
  334.       // move to the next table entry
  335.       // skip past the elementary stream descriptors, if present
  336.       offset += esInfoLength + 5;
  337.     }
  338.     return result;
  339.   }
  341.   /**
  342.    * Parse PES
  343.    *
  344.    * @param {Uint8Array} data
  345.    * @return {?shaka.extern.MPEG_PES}
  346.    * @private
  347.    */
  348.   parsePES_(data) {
  349.     const startPrefix = (data[0] << 16) | (data[1] << 8) | data[2];
  350.     // In certain live streams, the start of a TS fragment has ts packets
  351.     // that are frame data that is continuing from the previous fragment. This
  352.     // is to check that the pes data is the start of a new pes data
  353.     if (startPrefix !== 1) {
  354.       return null;
  355.     }
  356.     /** @type {shaka.extern.MPEG_PES} */
  357.     const pes = {
  358.       data: new Uint8Array(0),
  359.       // get the packet length, this will be 0 for video
  360.       packetLength: ((data[4] << 8) | data[5]),
  361.       pts: null,
  362.       dts: null,
  363.     };
  365.     // if PES parsed length is not zero and greater than total received length,
  366.     // stop parsing. PES might be truncated. minus 6 : PES header size
  367.     if (pes.packetLength && pes.packetLength > data.byteLength - 6) {
  368.       return null;
  369.     }
  371.     // PES packets may be annotated with a PTS value, or a PTS value
  372.     // and a DTS value. Determine what combination of values is
  373.     // available to work with.
  374.     const ptsDtsFlags = data[7];
  376.     // PTS and DTS are normally stored as a 33-bit number.  Javascript
  377.     // performs all bitwise operations on 32-bit integers but javascript
  378.     // supports a much greater range (52-bits) of integer using standard
  379.     // mathematical operations.
  380.     // We construct a 31-bit value using bitwise operators over the 31
  381.     // most significant bits and then multiply by 4 (equal to a left-shift
  382.     // of 2) before we add the final 2 least significant bits of the
  383.     // timestamp (equal to an OR.)
  384.     if (ptsDtsFlags & 0xC0) {
  385.       // the PTS and DTS are not written out directly. For information
  386.       // on how they are encoded, see
  387.       // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
  388.       pes.pts =
  389.         (data[9] & 0x0e) * 536870912 + // 1 << 29
  390.         (data[10] & 0xff) * 4194304 + // 1 << 22
  391.         (data[11] & 0xfe) * 16384 + // 1 << 14
  392.         (data[12] & 0xff) * 128 + // 1 << 7
  393.         (data[13] & 0xfe) / 2;
  395.       pes.dts = pes.pts;
  396.       if (ptsDtsFlags & 0x40) {
  397.         pes.dts =
  398.           (data[14] & 0x0e) * 536870912 + // 1 << 29
  399.           (data[15] & 0xff) * 4194304 + // 1 << 22
  400.           (data[16] & 0xfe) * 16384 + // 1 << 14
  401.           (data[17] & 0xff) * 128 + // 1 << 7
  402.           (data[18] & 0xfe) / 2;
  403.       }
  404.     }
  406.     const pesHdrLen = data[8];
  407.     // 9 bytes : 6 bytes for PES header + 3 bytes for PES extension
  408.     const payloadStartOffset = pesHdrLen + 9;
  409.     if (data.byteLength <= payloadStartOffset) {
  410.       return null;
  411.     }
  413.     pes.data = data.subarray(payloadStartOffset);
  415.     return pes;
  416.   }
  418.   /**
  419.    * Parse AVC Nalus
  420.    *
  421.    * The code is based on hls.js
  422.    * Credit to https://github.com/video-dev/hls.js/blob/master/src/demux/tsdemuxer.ts
  423.    *
  424.    * @param {shaka.extern.MPEG_PES} pes
  425.    * @param {?shaka.extern.MPEG_PES=} nextPes
  426.    * @return {!Array.<shaka.extern.VideoNalu>}
  427.    * @export
  428.    */
  429.   parseAvcNalus(pes, nextPes) {
  430.     const timescale = shaka.util.TsParser.Timescale;
  431.     const time = pes.pts ? pes.pts / timescale : null;
  432.     let data = pes.data;
  433.     let len = data.byteLength;
  435.     // A NALU does not contain is its size.
  436.     // The Annex B specification solves this by requiring ‘Start Codes’ to
  437.     // precede each NALU. A start code is 2 or 3 0x00 bytes followed with a
  438.     // 0x01 byte. e.g. 0x000001 or 0x00000001.
  439.     // More info in: https://stackoverflow.com/questions/24884827/possible-locations-for-sequence-picture-parameter-sets-for-h-264-stream/24890903#24890903
  440.     let numZeros = 0;
  442.     /** @type {!Array.<shaka.extern.VideoNalu>} */
  443.     const nalus = [];
  445.     // Start position includes the first byte where we read the type.
  446.     // The data we extract begins at the next byte.
  447.     let lastNaluStart = -1;
  448.     // Extracted from the first byte.
  449.     let lastNaluType = 0;
  451.     let tryToFinishLastNalu = false;
  453.     /** @type {?shaka.extern.VideoNalu} */
  454.     let infoOfLastNalu;
  456.     for (let i = 0; i < len; ++i) {
  457.       const value = data[i];
  458.       if (!value) {
  459.         numZeros++;
  460.       } else if (numZeros >= 2 && value == 1 && tryToFinishLastNalu) {
  461.         // If we are scanning the next PES, we need append the data to the
  462.         // previous Nalu and don't scan for more nalus.
  463.         const startCodeSize = numZeros > 3 ? 3 : numZeros;
  464.         const lastByteToKeep = i - startCodeSize;
  465.         // Optimization
  466.         if (lastByteToKeep == 0) {
  467.           break;
  468.         }
  469.         infoOfLastNalu.data = shaka.util.Uint8ArrayUtils.concat(
  470.             infoOfLastNalu.data, data.subarray(0, lastByteToKeep));
  471.         infoOfLastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
  472.             infoOfLastNalu.fullData, data.subarray(0, lastByteToKeep));
  473.         break;
  474.       } else if (numZeros >= 2 && value == 1) {
  475.         // We just read a start code.  Consume the NALU we passed, if any.
  476.         if (lastNaluStart >= 0) {
  477.           // Because the start position includes the type, skip the first byte.
  478.           const firstByteToKeep = lastNaluStart + 1;
  480.           // Compute the last byte to keep.  The start code is at most 3 zeros.
  481.           // Any earlier zeros are not part of the start code.
  482.           const startCodeSize = (numZeros > 3 ? 3 : numZeros) + 1;
  483.           const lastByteToKeep = i - startCodeSize;
  485.           /** @type {shaka.extern.VideoNalu} */
  486.           const nalu = {
  487.             // subarray's end position is exclusive, so add one.
  488.             data: data.subarray(firstByteToKeep, lastByteToKeep + 1),
  489.             fullData: data.subarray(lastNaluStart, lastByteToKeep + 1),
  490.             type: lastNaluType,
  491.             time: time,
  492.           };
  493.           nalus.push(nalu);
  494.         }
  496.         // We just read a start code, so there should be another byte here, at
  497.         // least, for the NALU type.  Check just in case.
  498.         if (i >= len - 1) {
  499.           shaka.log.warning('Malformed TS, incomplete NALU, ignoring.');
  500.           return nalus;
  501.         }
  503.         // Advance and read the type of the next NALU.
  504.         i++;
  505.         lastNaluStart = i;
  506.         lastNaluType = data[i] & 0x1f;
  507.         numZeros = 0;
  508.       } else {
  509.         numZeros = 0;
  510.       }
  511.       // If we have gone through all the data from the PES and we have an
  512.       // unfinished Nalu, we will try to use the next PES to complete the
  513.       // unfinished Nalu.
  514.       if (i >= (len - 1) && lastNaluStart >= 0 && numZeros >= 0) {
  515.         if (tryToFinishLastNalu) {
  516.           infoOfLastNalu.data = shaka.util.Uint8ArrayUtils.concat(
  517.               infoOfLastNalu.data, data);
  518.           infoOfLastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
  519.               infoOfLastNalu.fullData, data);
  520.         } else {
  521.           tryToFinishLastNalu = true;
  522.           // The rest of the buffer was a NALU.
  523.           // Because the start position includes the type, skip the first byte.
  524.           const firstByteToKeep = lastNaluStart + 1;
  525.           infoOfLastNalu = {
  526.             data: data.subarray(firstByteToKeep, len),
  527.             fullData: data.subarray(lastNaluStart, len),
  528.             type: lastNaluType,
  529.             time: time,
  530.           };
  531.           if (nextPes && pes.packetLength == 0) {
  532.             data = nextPes.data;
  533.             len = data.byteLength;
  534.             i = -1;
  535.           }
  536.         }
  537.       }
  538.     }
  540.     if (infoOfLastNalu) {
  541.       nalus.push(infoOfLastNalu);
  542.     }
  543.     return nalus;
  544.   }
  546.   /**
  547.    * Return the ID3 metadata
  548.    *
  549.    * @return {!Array.<shaka.extern.ID3Metadata>}
  550.    * @export
  551.    */
  552.   getMetadata() {
  553.     const timescale = shaka.util.TsParser.Timescale;
  554.     const metadata = [];
  555.     for (const id3Data of this.id3Data_) {
  556.       const pes = this.parsePES_(id3Data);
  557.       if (pes) {
  558.         metadata.push({
  559.           cueTime: pes.pts ? pes.pts / timescale : null,
  560.           data: pes.data,
  561.           frames: shaka.util.Id3Utils.getID3Frames(pes.data),
  562.           dts: pes.dts,
  563.           pts: pes.pts,
  564.         });
  565.       }
  566.     }
  567.     return metadata;
  568.   }
  570.   /**
  571.    * Return the audio data
  572.    *
  573.    * @return {!Array.<shaka.extern.MPEG_PES>}
  574.    * @export
  575.    */
  576.   getAudioData() {
  577.     const audio = [];
  578.     for (const audioData of this.audioData_) {
  579.       const pes = this.parsePES_(audioData);
  580.       if (pes) {
  581.         audio.push(pes);
  582.       }
  583.     }
  584.     return audio;
  585.   }
  587.   /**
  588.    * Return the audio data
  589.    *
  590.    * @return {!Array.<shaka.extern.MPEG_PES>}
  591.    * @export
  592.    */
  593.   getVideoData() {
  594.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  595.     const video = [];
  596.     for (const videoData of this.videoData_) {
  597.       const pes = this.parsePES_(videoData);
  598.       if (pes && pes.pts != null && pes.dts != null) {
  599.         video.push(pes);
  600.       } else if (video.length) {
  601.         const data = pes ? pes.data : videoData;
  602.         if (!data) {
  603.           continue;
  604.         }
  605.         const previousPes = video.pop();
  606.         previousPes.data =
  607.             Uint8ArrayUtils.concat(previousPes.data, data);
  608.         video.push(previousPes);
  609.       }
  610.     }
  611.     return video;
  612.   }
  614.   /**
  615.    * Return the start time for the audio and video
  616.    *
  617.    * @return {{audio: ?number, video: ?number}}
  618.    * @export
  619.    */
  620.   getStartTime() {
  621.     const timescale = shaka.util.TsParser.Timescale;
  622.     let audioStartTime = null;
  623.     for (const pes of this.getAudioData()) {
  624.       if (pes && pes.pts != null) {
  625.         const startTime = Math.min(pes.dts, pes.pts) / timescale;
  626.         if (audioStartTime == null || audioStartTime > startTime) {
  627.           audioStartTime = startTime;
  628.         }
  629.       }
  630.     }
  631.     let videoStartTime = null;
  632.     for (const pes of this.getVideoData()) {
  633.       if (pes && pes.pts != null) {
  634.         const startTime = Math.min(pes.dts, pes.pts) / timescale;
  635.         if (videoStartTime == null || videoStartTime > startTime) {
  636.           videoStartTime = startTime;
  637.         }
  638.       }
  639.     }
  640.     return {
  641.       audio: audioStartTime,
  642.       video: videoStartTime,
  643.     };
  644.   }
  646.   /**
  647.    * Return the audio and video codecs
  648.    *
  649.    * @return {{audio: ?string, video: ?string}}
  650.    * @export
  651.    */
  652.   getCodecs() {
  653.     return {
  654.       audio: this.audioCodec_,
  655.       video: this.videoCodec_,
  656.     };
  657.   }
  659.   /**
  660.    * Return the video data
  661.    *
  662.    * @return {!Array.<shaka.extern.VideoNalu>}
  663.    * @export
  664.    */
  665.   getVideoNalus() {
  666.     const nalus = [];
  667.     if (this.videoCodec_ != 'avc') {
  668.       return nalus;
  669.     }
  670.     const videoData = this.getVideoData();
  671.     for (let i = 0; i < videoData.length; i++) {
  672.       const pes = videoData[i];
  673.       let nextPes;
  674.       if (i + 1 < videoData.length) {
  675.         nextPes = videoData[i + 1];
  676.       }
  677.       nalus.push(...this.parseAvcNalus(pes, nextPes));
  678.     }
  679.     return nalus;
  680.   }
  682.   /**
  683.    * Return the video resolution
  684.    *
  685.    * @return {{height: ?string, width: ?string}}
  686.    * @export
  687.    */
  688.   getVideoResolution() {
  689.     shaka.Deprecate.deprecateFeature(5,
  690.         'TsParser',
  691.         'Please use getVideoInfo function instead.');
  692.     const videoInfo = this.getVideoInfo();
  693.     return {
  694.       height: videoInfo.height,
  695.       width: videoInfo.width,
  696.     };
  697.   }
  699.   /**
  700.    * Return the video information
  701.    *
  702.    * @return {{height: ?string, width: ?string, codec: ?string}}
  703.    * @export
  704.    */
  705.   getVideoInfo() {
  706.     const TsParser = shaka.util.TsParser;
  707.     const videoInfo = {
  708.       height: null,
  709.       width: null,
  710.       codec: null,
  711.     };
  712.     const videoNalus = this.getVideoNalus();
  713.     if (!videoNalus.length) {
  714.       return videoInfo;
  715.     }
  716.     const spsNalu = videoNalus.find((nalu) => {
  717.       return nalu.type == TsParser.H264_NALU_TYPE_SPS_;
  718.     });
  719.     if (!spsNalu) {
  720.       return videoInfo;
  721.     }
  723.     const expGolombDecoder = new shaka.util.ExpGolomb(spsNalu.data);
  724.     // profile_idc
  725.     const profileIdc = expGolombDecoder.readUnsignedByte();
  726.     // constraint_set[0-5]_flag
  727.     const profileCompatibility = expGolombDecoder.readUnsignedByte();
  728.     // level_idc u(8)
  729.     const levelIdc = expGolombDecoder.readUnsignedByte();
  730.     // seq_parameter_set_id
  731.     expGolombDecoder.skipExpGolomb();
  733.     // some profiles have more optional data we don't need
  734.     if (TsParser.PROFILES_WITH_OPTIONAL_SPS_DATA_.includes(profileIdc)) {
  735.       const chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();
  736.       if (chromaFormatIdc === 3) {
  737.         // separate_colour_plane_flag
  738.         expGolombDecoder.skipBits(1);
  739.       }
  740.       // bit_depth_luma_minus8
  741.       expGolombDecoder.skipExpGolomb();
  742.       // bit_depth_chroma_minus8
  743.       expGolombDecoder.skipExpGolomb();
  744.       // qpprime_y_zero_transform_bypass_flag
  745.       expGolombDecoder.skipBits(1);
  746.       // seq_scaling_matrix_present_flag
  747.       if (expGolombDecoder.readBoolean()) {
  748.         const scalingListCount = (chromaFormatIdc !== 3) ? 8 : 12;
  749.         for (let i = 0; i < scalingListCount; i++) {
  750.           // seq_scaling_list_present_flag[ i ]
  751.           if (expGolombDecoder.readBoolean()) {
  752.             if (i < 6) {
  753.               expGolombDecoder.skipScalingList(16);
  754.             } else {
  755.               expGolombDecoder.skipScalingList(64);
  756.             }
  757.           }
  758.         }
  759.       }
  760.     }
  762.     // log2_max_frame_num_minus4
  763.     expGolombDecoder.skipExpGolomb();
  764.     const picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();
  766.     if (picOrderCntType === 0) {
  767.       // log2_max_pic_order_cnt_lsb_minus4
  768.       expGolombDecoder.readUnsignedExpGolomb();
  769.     } else if (picOrderCntType === 1) {
  770.       // delta_pic_order_always_zero_flag
  771.       expGolombDecoder.skipBits(1);
  772.       // offset_for_non_ref_pic
  773.       expGolombDecoder.skipExpGolomb();
  774.       // offset_for_top_to_bottom_field
  775.       expGolombDecoder.skipExpGolomb();
  776.       const numRefFramesInPicOrderCntCycle =
  777.           expGolombDecoder.readUnsignedExpGolomb();
  778.       for (let i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
  779.         // offset_for_ref_frame[ i ]
  780.         expGolombDecoder.skipExpGolomb();
  781.       }
  782.     }
  784.     // max_num_ref_frames
  785.     expGolombDecoder.skipExpGolomb();
  786.     // gaps_in_frame_num_value_allowed_flag
  787.     expGolombDecoder.skipBits(1);
  789.     const picWidthInMbsMinus1 =
  790.         expGolombDecoder.readUnsignedExpGolomb();
  791.     const picHeightInMapUnitsMinus1 =
  792.         expGolombDecoder.readUnsignedExpGolomb();
  794.     const frameMbsOnlyFlag = expGolombDecoder.readBits(1);
  795.     if (frameMbsOnlyFlag === 0) {
  796.       // mb_adaptive_frame_field_flag
  797.       expGolombDecoder.skipBits(1);
  798.     }
  799.     // direct_8x8_inference_flag
  800.     expGolombDecoder.skipBits(1);
  802.     let frameCropLeftOffset = 0;
  803.     let frameCropRightOffset = 0;
  804.     let frameCropTopOffset = 0;
  805.     let frameCropBottomOffset = 0;
  807.     // frame_cropping_flag
  808.     if (expGolombDecoder.readBoolean()) {
  809.       frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();
  810.       frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();
  811.       frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();
  812.       frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();
  813.     }
  815.     videoInfo.height = String(((2 - frameMbsOnlyFlag) *
  816.         (picHeightInMapUnitsMinus1 + 1) * 16) - (frameCropTopOffset * 2) -
  817.         (frameCropBottomOffset * 2));
  818.     videoInfo.width = String(((picWidthInMbsMinus1 + 1) * 16) -
  819.         frameCropLeftOffset * 2 - frameCropRightOffset * 2);
  820.     videoInfo.codec = 'avc1.' + this.byteToHex_(profileIdc) +
  821.         this.byteToHex_(profileCompatibility) + this.byteToHex_(levelIdc);
  823.     return videoInfo;
  824.   }
  826.   /**
  827.    * Convert a byte to 2 digits of hex.  (Only handles values 0-255.)
  828.    *
  829.    * @param {number} x
  830.    * @return {string}
  831.    * @private
  832.    */
  833.   byteToHex_(x) {
  834.     return ('0' + x.toString(16).toUpperCase()).slice(-2);
  835.   }
  837.   /**
  838.    * Check if the passed data corresponds to an MPEG2-TS
  839.    *
  840.    * @param {Uint8Array} data
  841.    * @return {boolean}
  842.    * @export
  843.    */
  844.   static probe(data) {
  845.     const syncOffset = shaka.util.TsParser.syncOffset(data);
  846.     if (syncOffset < 0) {
  847.       return false;
  848.     } else {
  849.       if (syncOffset > 0) {
  850.         shaka.log.warning('MPEG2-TS detected but first sync word found @ ' +
  851.             'offset ' + syncOffset + ', junk ahead ?');
  852.       }
  853.       return true;
  854.     }
  855.   }
  857.   /**
  858.    * Returns the synchronization offset
  859.    *
  860.    * @param {Uint8Array} data
  861.    * @return {number}
  862.    * @export
  863.    */
  864.   static syncOffset(data) {
  865.     const packetLength = shaka.util.TsParser.PacketLength_;
  866.     // scan 1000 first bytes
  867.     const scanwindow = Math.min(1000, data.length - 3 * packetLength);
  868.     let i = 0;
  869.     while (i < scanwindow) {
  870.       // a TS fragment should contain at least 3 TS packets, a PAT, a PMT, and
  871.       // one PID, each starting with 0x47
  872.       if (data[i] == 0x47 &&
  873.           data[i + packetLength] == 0x47 &&
  874.           data[i + 2 * packetLength] == 0x47) {
  875.         return i;
  876.       } else {
  877.         i++;
  878.       }
  879.     }
  880.     return -1;
  881.   }
  882. };
  885. /**
  886.  * @const {number}
  887.  * @export
  888.  */
  889. shaka.util.TsParser.Timescale = 90000;
  892. /**
  893.  * @const {number}
  894.  * @private
  895.  */
  896. shaka.util.TsParser.PacketLength_ = 188;
  899. /**
  900.  * NALU type for Sequence Parameter Set (SPS) for H.264.
  901.  * @const {number}
  902.  * @private
  903.  */
  904. shaka.util.TsParser.H264_NALU_TYPE_SPS_ = 0x07;
  907. /**
  908.  * Values of profile_idc that indicate additional fields are included in the
  909.  * SPS.
  910.  * see Recommendation ITU-T H.264 (4/2013)
  911.  * 7.3.2.1.1 Sequence parameter set data syntax
  912.  *
  913.  * @const {!Array.<number>}
  914.  * @private
  915.  */
  916. shaka.util.TsParser.PROFILES_WITH_OPTIONAL_SPS_DATA_ =
  917.     [100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134];
  920. /**
  921.  * @typedef {{
  922.  *   audio: number,
  923.  *   video: number,
  924.  *   id3: number,
  925.  *   audioCodec: string,
  926.  *   videoCodec: string
  927.  * }}
  928.  *
  929.  * @summary PMT.
  930.  * @property {number} audio
  931.  *   Audio PID
  932.  * @property {number} video
  933.  *   Video PID
  934.  * @property {number} id3
  935.  *   ID3 PID
  936.  * @property {string} audioCodec
  937.  *   Audio codec
  938.  * @property {string} videoCodec
  939.  *   Video codec
  940.  */
  941. shaka.util.TsParser.PMT;