shaka-player 4.3.11 → 4.4.1

package/lib/util/ts_parser.js

@@ -6,8 +6,8 @@
 
 goog.provide('shaka.util.TsParser');
 
-goog.require('goog.asserts');
 goog.require('shaka.log');
+goog.require('shaka.util.ExpGolomb');
 goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.Uint8ArrayUtils');
 
@@ -25,9 +25,6 @@ shaka.util.TsParser = class {
     /** @private {boolean} */
     this.pmtParsed_ = false;
 
-    /** @private {?number} */
-    this.videoStartTime_ = null;
-
     /** @private {?number} */
     this.videoPid_ = null;
 
@@ -37,9 +34,6 @@ shaka.util.TsParser = class {
     /** @private {!Array.<Uint8Array>} */
     this.videoData_ = [];
 
-    /** @private {?number} */
-    this.audioStartTime_ = null;
-
     /** @private {?number} */
     this.audioPid_ = null;
 
@@ -56,15 +50,27 @@ shaka.util.TsParser = class {
     this.id3Data_ = [];
   }
 
+  /**
+   * Clear previous data
+   *
+   * @export
+   */
+  clearData() {
+    this.videoData_ = [];
+    this.audioData_ = [];
+    this.id3Data_ = [];
+  }
+
   /**
    * Parse the given data
    *
    * @param {Uint8Array} data
    * @return {!shaka.util.TsParser}
+   * @export
    */
   parse(data) {
-    const timescale = shaka.util.TsParser.Timescale_;
     const packetLength = shaka.util.TsParser.PacketLength_;
+    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
 
     // A TS fragment should contain at least 3 TS packets, a PAT, a PMT, and
     // one PID.
@@ -79,7 +85,7 @@ shaka.util.TsParser = class {
 
     // loop through TS packets
     for (let start = syncOffset; start < length; start += packetLength) {
-      if (data[start] === 0x47) {
+      if (data[start] == 0x47) {
         const payloadUnitStartIndicator = !!(data[start + 1] & 0x40);
         // pid is a 13-bit field starting at the last 5 bits of TS[1]
         const pid = ((data[start + 1] & 0x1f) << 8) + data[start + 2];
@@ -91,7 +97,7 @@ shaka.util.TsParser = class {
         if (adaptationFieldControl > 1) {
           offset = start + 5 + data[start + 4];
           // continue if there is only adaptation field
-          if (offset === start + packetLength) {
+          if (offset == start + packetLength) {
             continue;
           }
         } else {
@@ -113,7 +119,7 @@ shaka.util.TsParser = class {
               offset += data[offset] + 1;
             }
 
-            const parsedPIDs = this.parsePMT(data, offset);
+            const parsedPIDs = this.parsePMT_(data, offset);
 
             // only update track id if track PID found while parsing PMT
             // this is to avoid resetting the PID to -1 in case
@@ -146,29 +152,43 @@ shaka.util.TsParser = class {
           }
           case this.videoPid_: {
             const videoData = data.subarray(offset, start + packetLength);
-            if (this.videoStartTime_ == null) {
-              const pes = this.parsePES(videoData);
-              if (pes && pes.pts != null) {
-                this.videoStartTime_ = pes.pts / timescale;
+            if (payloadUnitStartIndicator) {
+              this.videoData_.push(videoData);
+            } else if (this.videoData_.length) {
+              const prevVideoData = this.videoData_[this.videoData_.length - 1];
+              if (prevVideoData) {
+                this.videoData_[this.videoData_.length - 1] =
+                    Uint8ArrayUtils.concat(prevVideoData, videoData);
               }
             }
-            this.videoData_.push(videoData);
             break;
           }
           case this.audioPid_: {
             const audioData = data.subarray(offset, start + packetLength);
-            if (this.audioStartTime_ == null) {
-              const pes = this.parsePES(audioData);
-              if (pes && pes.pts != null) {
-                this.audioStartTime_ = pes.pts / timescale;
+            if (payloadUnitStartIndicator) {
+              this.audioData_.push(audioData);
+            } else if (this.audioData_.length) {
+              const prevAudioData = this.audioData_[this.audioData_.length - 1];
+              if (prevAudioData) {
+                this.audioData_[this.audioData_.length - 1] =
+                    Uint8ArrayUtils.concat(prevAudioData, audioData);
               }
             }
-            this.audioData_.push(audioData);
             break;
           }
-          case this.id3Pid_:
-            this.id3Data_.push(data.subarray(offset, start + packetLength));
+          case this.id3Pid_: {
+            const id3Data = data.subarray(offset, start + packetLength);
+            if (payloadUnitStartIndicator) {
+              this.id3Data_.push(id3Data);
+            } else if (this.id3Data_.length) {
+              const prevId3Data = this.id3Data_[this.id3Data_.length - 1];
+              if (prevId3Data) {
+                this.id3Data_[this.id3Data_.length - 1] =
+                    Uint8ArrayUtils.concat(prevId3Data, id3Data);
+              }
+            }
             break;
+          }
           default:
             unknownPIDs = true;
             break;
@@ -199,8 +219,9 @@ shaka.util.TsParser = class {
    * @param {Uint8Array} data
    * @param {number} offset
    * @return {!shaka.util.TsParser.PMT}
+   * @private
    */
-  parsePMT(data, offset) {
+  parsePMT_(data, offset) {
     const result = {
       audio: -1,
       video: -1,
@@ -218,20 +239,49 @@ shaka.util.TsParser = class {
     offset += 12 + programInfoLength;
     while (offset < tableEnd) {
       const pid = ((data[offset + 1] & 0x1f) << 8) | data[offset + 2];
+      const esInfoLength = ((data[offset + 3] & 0x0f) << 8) | data[offset + 4];
       switch (data[offset]) {
+        case 0x06:
+          // stream_type 6 can mean a lot of different things in case of DVB.
+          // We need to look at the descriptors. Right now, we're only
+          // interested in AC-3 and EC-3 audio, so we do the descriptor parsing
+          // only when we don't have an audio PID yet.
+          if (result.audio == -1 && esInfoLength > 0) {
+            let parsePos = offset + 5;
+            let remaining = esInfoLength;
+            while (remaining > 2) {
+              const descriptorId = data[parsePos];
+              switch (descriptorId) {
+                // DVB Descriptor for AC-3
+                case 0x6a:
+                  result.audio = pid;
+                  result.audioCodec = 'ac3';
+                  break;
+                // DVB Descriptor for EC-3
+                case 0x7a:
+                  result.audio = pid;
+                  result.audioCodec = 'ec3';
+                  break;
+              }
+              const descriptorLen = data[parsePos + 1] + 2;
+              parsePos += descriptorLen;
+              remaining -= descriptorLen;
+            }
+          }
+          break;
         // SAMPLE-AES AAC
         case 0xcf:
           break;
         // ISO/IEC 13818-7 ADTS AAC (MPEG-2 lower bit-rate audio)
         case 0x0f:
-          if (result.audio === -1) {
+          if (result.audio == -1) {
             result.audio = pid;
             result.audioCodec = 'aac';
           }
           break;
         // Packetized metadata (ID3)
         case 0x15:
-          if (result.id3 === -1) {
+          if (result.id3 == -1) {
             result.id3 = pid;
           }
           break;
@@ -240,7 +290,7 @@ shaka.util.TsParser = class {
           break;
         // ITU-T Rec. H.264 and ISO/IEC 14496-10 (lower bit-rate video)
         case 0x1b:
-          if (result.video === -1) {
+          if (result.video == -1) {
             result.video = pid;
             result.videoCodec = 'avc';
           }
@@ -249,25 +299,40 @@ shaka.util.TsParser = class {
         // or ISO/IEC 13818-3 (MPEG-2 halved sample rate audio)
         case 0x03:
         case 0x04:
-          if (result.audio === -1) {
+          if (result.audio == -1) {
             result.audio = pid;
             result.audioCodec = 'mp3';
           }
           break;
         // HEVC
         case 0x24:
-          if (result.video === -1) {
+          if (result.video == -1) {
             result.video = pid;
             result.videoCodec = 'hvc';
           }
           break;
+        // AC-3
+        case 0x81:
+          if (result.audio == -1) {
+            result.audio = pid;
+            result.audioCodec = 'ac3';
+          }
+          break;
+        // EC-3
+        case 0x84:
+        case 0x87:
+          if (result.audio == -1) {
+            result.audio = pid;
+            result.audioCodec = 'ec3';
+          }
+          break;
         default:
           // shaka.log.warning('Unknown stream type:', data[offset]);
           break;
       }
       // move to the next table entry
       // skip past the elementary stream descriptors, if present
-      offset += (((data[offset + 3] & 0x0f) << 8) | data[offset + 4]) + 5;
+      offset += esInfoLength + 5;
     }
     return result;
   }
@@ -276,9 +341,10 @@ shaka.util.TsParser = class {
    * Parse PES
    *
    * @param {Uint8Array} data
-   * @return {?shaka.util.TsParser.PES}
+   * @return {?shaka.extern.MPEG_PES}
+   * @private
    */
-  parsePES(data) {
+  parsePES_(data) {
     const startPrefix = (data[0] << 16) | (data[1] << 8) | data[2];
     // In certain live streams, the start of a TS fragment has ts packets
     // that are frame data that is continuing from the previous fragment. This
@@ -286,11 +352,11 @@ shaka.util.TsParser = class {
     if (startPrefix !== 1) {
       return null;
     }
-    /** @type {shaka.util.TsParser.PES} */
+    /** @type {shaka.extern.MPEG_PES} */
     const pes = {
       data: new Uint8Array(0),
       // get the packet length, this will be 0 for video
-      packetLength: 6 + ((data[4] << 8) | data[5]),
+      packetLength: ((data[4] << 8) | data[5]),
       pts: null,
       dts: null,
     };
@@ -337,51 +403,217 @@ shaka.util.TsParser = class {
     return pes;
   }
 
+  /**
+   * Parse AVC Nalus
+   *
+   * The code is based on hls.js
+   * Credit to https://github.com/video-dev/hls.js/blob/master/src/demux/tsdemuxer.ts
+   *
+   * @param {shaka.extern.MPEG_PES} pes
+   * @param {?shaka.extern.MPEG_PES=} nextPes
+   * @return {!Array.<shaka.extern.VideoNalu>}
+   * @export
+   */
+  parseAvcNalus(pes, nextPes) {
+    const timescale = shaka.util.TsParser.Timescale;
+    const time = pes.pts ? pes.pts / timescale : null;
+    let data = pes.data;
+    let len = data.byteLength;
+
+    // A NALU does not contain is its size.
+    // The Annex B specification solves this by requiring ‘Start Codes’ to
+    // precede each NALU. A start code is 2 or 3 0x00 bytes followed with a
+    // 0x01 byte. e.g. 0x000001 or 0x00000001.
+    // More info in: https://stackoverflow.com/questions/24884827/possible-locations-for-sequence-picture-parameter-sets-for-h-264-stream/24890903#24890903
+    let numZeros = 0;
+
+    /** @type {!Array.<shaka.extern.VideoNalu>} */
+    const nalus = [];
+
+    // Start position includes the first byte where we read the type.
+    // The data we extract begins at the next byte.
+    let lastNaluStart = -1;
+    // Extracted from the first byte.
+    let lastNaluType = 0;
+
+    let tryToFinishLastNalu = false;
+
+    /** @type {?shaka.extern.VideoNalu} */
+    let infoOfLastNalu;
+
+    for (let i = 0; i < len; ++i) {
+      const value = data[i];
+      if (!value) {
+        numZeros++;
+      } else if (numZeros >= 2 && value == 1 && tryToFinishLastNalu) {
+        // If we are scanning the next PES, we need append the data to the
+        // previous Nalu and don't scan for more nalus.
+        const startCodeSize = numZeros > 3 ? 3 : numZeros;
+        const lastByteToKeep = i - startCodeSize;
+        infoOfLastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+            infoOfLastNalu.data, data.subarray(0, lastByteToKeep));
+        infoOfLastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+            infoOfLastNalu.fullData, data.subarray(0, lastByteToKeep));
+        break;
+      } else if (numZeros >= 2 && value == 1) {
+        // We just read a start code.  Consume the NALU we passed, if any.
+        if (lastNaluStart >= 0) {
+          // Because the start position includes the type, skip the first byte.
+          const firstByteToKeep = lastNaluStart + 1;
+
+          // Compute the last byte to keep.  The start code is at most 3 zeros.
+          // Any earlier zeros are not part of the start code.
+          const startCodeSize = (numZeros > 3 ? 3 : numZeros) + 1;
+          const lastByteToKeep = i - startCodeSize;
+
+          /** @type {shaka.extern.VideoNalu} */
+          const nalu = {
+            // subarray's end position is exclusive, so add one.
+            data: data.subarray(firstByteToKeep, lastByteToKeep + 1),
+            fullData: data.subarray(lastNaluStart, lastByteToKeep + 1),
+            type: lastNaluType,
+            time: time,
+          };
+          nalus.push(nalu);
+        }
+
+        // We just read a start code, so there should be another byte here, at
+        // least, for the NALU type.  Check just in case.
+        if (i >= len - 1) {
+          shaka.log.warning('Malformed TS, incomplete NALU, ignoring.');
+          return nalus;
+        }
+
+        // Advance and read the type of the next NALU.
+        i++;
+        lastNaluStart = i;
+        lastNaluType = data[i] & 0x1f;
+        numZeros = 0;
+      } else {
+        numZeros = 0;
+      }
+      // If we have gone through all the data from the PES and we have an
+      // unfinished Nalu, we will try to use the next PES to complete the
+      // unfinished Nalu.
+      if (i >= (len - 1) && lastNaluStart >= 0 && numZeros >= 0) {
+        if (tryToFinishLastNalu) {
+          infoOfLastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+              infoOfLastNalu.data, data);
+          infoOfLastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+              infoOfLastNalu.fullData, data);
+        } else {
+          tryToFinishLastNalu = true;
+          // The rest of the buffer was a NALU.
+          // Because the start position includes the type, skip the first byte.
+          const firstByteToKeep = lastNaluStart + 1;
+          infoOfLastNalu = {
+            data: data.subarray(firstByteToKeep, len),
+            fullData: data.subarray(lastNaluStart, len),
+            type: lastNaluType,
+            time: time,
+          };
+          if (nextPes && pes.packetLength == 0) {
+            data = nextPes.data;
+            len = data.byteLength;
+            i = -1;
+          }
+        }
+      }
+    }
+
+    if (infoOfLastNalu) {
+      nalus.push(infoOfLastNalu);
+    }
+    return nalus;
+  }
+
   /**
    * Return the ID3 metadata
    *
    * @return {!Array.<shaka.extern.ID3Metadata>}
+   * @export
    */
   getMetadata() {
-    const timescale = shaka.util.TsParser.Timescale_;
-    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
+    const timescale = shaka.util.TsParser.Timescale;
     const metadata = [];
-    let prevId3Data = new Uint8Array(0);
-    // parsePES() only works if the data begins on a PES boundary.
-    // Try the last data blob first, and if it doesn't begin on a
-    // PES boundary, prepend the previous blob and try again.
-    // This way, a successful parse will always begin and end on
-    // the correct boundary, and no data will be skipped.
-    for (let i = this.id3Data_.length - 1; i >= 0; i--) {
-      const data = this.id3Data_[i];
-      goog.asserts.assert(data, 'We should have a data');
-      const id3Data = Uint8ArrayUtils.concat(data, prevId3Data);
-      const pes = this.parsePES(id3Data);
+    for (const id3Data of this.id3Data_) {
+      const pes = this.parsePES_(id3Data);
       if (pes) {
-        metadata.unshift({
+        metadata.push({
           cueTime: pes.pts ? pes.pts / timescale : null,
           data: pes.data,
           frames: shaka.util.Id3Utils.getID3Frames(pes.data),
           dts: pes.dts,
           pts: pes.pts,
         });
-        prevId3Data = new Uint8Array(0);
-      } else {
-        prevId3Data = id3Data;
       }
     }
     return metadata;
   }
 
+  /**
+   * Return the audio data
+   *
+   * @return {!Array.<shaka.extern.MPEG_PES>}
+   * @export
+   */
+  getAudioData() {
+    const audio = [];
+    for (const audioData of this.audioData_) {
+      const pes = this.parsePES_(audioData);
+      if (pes) {
+        audio.push(pes);
+      }
+    }
+    return audio;
+  }
+
+  /**
+   * Return the audio data
+   *
+   * @return {!Array.<shaka.extern.MPEG_PES>}
+   * @export
+   */
+  getVideoData() {
+    const video = [];
+    for (const videoData of this.videoData_) {
+      const pes = this.parsePES_(videoData);
+      if (pes) {
+        video.push(pes);
+      }
+    }
+    return video;
+  }
+
   /**
    * Return the start time for the audio and video
    *
    * @return {{audio: ?number, video: ?number}}
+   * @export
    */
   getStartTime() {
+    const timescale = shaka.util.TsParser.Timescale;
+    let audioStartTime = null;
+    for (const pes of this.getAudioData()) {
+      if (pes && pes.pts != null) {
+        const startTime = Math.min(pes.dts, pes.pts) / timescale;
+        if (audioStartTime == null || audioStartTime > startTime) {
+          audioStartTime = startTime;
+        }
+      }
+    }
+    let videoStartTime = null;
+    for (const pes of this.getVideoData()) {
+      if (pes && pes.pts != null) {
+        const startTime = Math.min(pes.dts, pes.pts) / timescale;
+        if (videoStartTime == null || videoStartTime > startTime) {
+          videoStartTime = startTime;
+        }
+      }
+    }
     return {
-      audio: this.audioStartTime_,
-      video: this.videoStartTime_,
+      audio: audioStartTime,
+      video: videoStartTime,
     };
   }
 
@@ -389,6 +621,7 @@ shaka.util.TsParser = class {
    * Return the audio and video codecs
    *
    * @return {{audio: ?string, video: ?string}}
+   * @export
    */
   getCodecs() {
     return {
@@ -397,11 +630,159 @@ shaka.util.TsParser = class {
     };
   }
 
+  /**
+   * Return the video data
+   *
+   * @return {!Array.<shaka.extern.VideoNalu>}
+   * @export
+   */
+  getVideoNalus() {
+    const nalus = [];
+    if (this.videoCodec_ != 'avc') {
+      return nalus;
+    }
+    const videoData = this.getVideoData();
+    for (let i = 0; i < videoData.length; i++) {
+      const pes = videoData[i];
+      let nextPes;
+      if (i + 1 < videoData.length) {
+        nextPes = videoData[i + 1];
+      }
+      nalus.push(...this.parseAvcNalus(pes, nextPes));
+    }
+    return nalus;
+  }
+
+  /**
+   * Return the video resolution
+   *
+   * @return {{height: ?string, width: ?string}}
+   * @export
+   */
+  getVideoResolution() {
+    const TsParser = shaka.util.TsParser;
+    const resolution = {
+      height: null,
+      width: null,
+    };
+    const videoNalus = this.getVideoNalus();
+    if (!videoNalus.length) {
+      return resolution;
+    }
+    const spsNalu = videoNalus.find((nalu) => {
+      return nalu.type == TsParser.H264_NALU_TYPE_SPS_;
+    });
+    if (!spsNalu) {
+      return resolution;
+    }
+
+    const expGolombDecoder = new shaka.util.ExpGolomb(spsNalu.data);
+    // profile_idc
+    const profileIdc = expGolombDecoder.readUnsignedByte();
+    // constraint_set[0-5]_flag
+    expGolombDecoder.readUnsignedByte();
+    // level_idc u(8)
+    expGolombDecoder.readUnsignedByte();
+    // seq_parameter_set_id
+    expGolombDecoder.skipExpGolomb();
+
+    // some profiles have more optional data we don't need
+    if (TsParser.PROFILES_WITH_OPTIONAL_SPS_DATA_.includes(profileIdc)) {
+      const chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();
+      if (chromaFormatIdc === 3) {
+        // separate_colour_plane_flag
+        expGolombDecoder.skipBits(1);
+      }
+      // bit_depth_luma_minus8
+      expGolombDecoder.skipExpGolomb();
+      // bit_depth_chroma_minus8
+      expGolombDecoder.skipExpGolomb();
+      // qpprime_y_zero_transform_bypass_flag
+      expGolombDecoder.skipBits(1);
+      // seq_scaling_matrix_present_flag
+      if (expGolombDecoder.readBoolean()) {
+        const scalingListCount = (chromaFormatIdc !== 3) ? 8 : 12;
+        for (let i = 0; i < scalingListCount; i++) {
+          // seq_scaling_list_present_flag[ i ]
+          if (expGolombDecoder.readBoolean()) {
+            if (i < 6) {
+              expGolombDecoder.skipScalingList(16);
+            } else {
+              expGolombDecoder.skipScalingList(64);
+            }
+          }
+        }
+      }
+    }
+
+    // log2_max_frame_num_minus4
+    expGolombDecoder.skipExpGolomb();
+    const picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();
+
+    if (picOrderCntType === 0) {
+      // log2_max_pic_order_cnt_lsb_minus4
+      expGolombDecoder.readUnsignedExpGolomb();
+    } else if (picOrderCntType === 1) {
+      // delta_pic_order_always_zero_flag
+      expGolombDecoder.skipBits(1);
+      // offset_for_non_ref_pic
+      expGolombDecoder.skipExpGolomb();
+      // offset_for_top_to_bottom_field
+      expGolombDecoder.skipExpGolomb();
+      const numRefFramesInPicOrderCntCycle =
+          expGolombDecoder.readUnsignedExpGolomb();
+      for (let i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+        // offset_for_ref_frame[ i ]
+        expGolombDecoder.skipExpGolomb();
+      }
+    }
+
+    // max_num_ref_frames
+    expGolombDecoder.skipExpGolomb();
+    // gaps_in_frame_num_value_allowed_flag
+    expGolombDecoder.skipBits(1);
+
+    const picWidthInMbsMinus1 =
+        expGolombDecoder.readUnsignedExpGolomb();
+    const picHeightInMapUnitsMinus1 =
+        expGolombDecoder.readUnsignedExpGolomb();
+
+    const frameMbsOnlyFlag = expGolombDecoder.readBits(1);
+    if (frameMbsOnlyFlag === 0) {
+      // mb_adaptive_frame_field_flag
+      expGolombDecoder.skipBits(1);
+    }
+    // direct_8x8_inference_flag
+    expGolombDecoder.skipBits(1);
+
+    let frameCropLeftOffset = 0;
+    let frameCropRightOffset = 0;
+    let frameCropTopOffset = 0;
+    let frameCropBottomOffset = 0;
+
+    // frame_cropping_flag
+    if (expGolombDecoder.readBoolean()) {
+      frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();
+      frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();
+      frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();
+      frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();
+    }
+
+    resolution.height = String(((2 - frameMbsOnlyFlag) *
+        (picHeightInMapUnitsMinus1 + 1) * 16) - (frameCropTopOffset * 2) -
+        (frameCropBottomOffset * 2));
+    resolution.width = String(((picWidthInMbsMinus1 + 1) * 16) -
+        frameCropLeftOffset * 2 - frameCropRightOffset * 2);
+
+    return resolution;
+  }
+
   /**
    * Check if the passed data corresponds to an MPEG2-TS
    *
    * @param {Uint8Array} data
    * @return {boolean}
+   * @export
    */
   static probe(data) {
     const syncOffset = shaka.util.TsParser.syncOffset(data);
@@ -421,6 +802,7 @@ shaka.util.TsParser = class {
    *
    * @param {Uint8Array} data
    * @return {number}
+   * @export
    */
   static syncOffset(data) {
     const packetLength = shaka.util.TsParser.PacketLength_;
@@ -430,9 +812,9 @@ shaka.util.TsParser = class {
     while (i < scanwindow) {
       // a TS fragment should contain at least 3 TS packets, a PAT, a PMT, and
       // one PID, each starting with 0x47
-      if (data[i] === 0x47 &&
-          data[i + packetLength] === 0x47 &&
-          data[i + 2 * packetLength] === 0x47) {
+      if (data[i] == 0x47 &&
+          data[i + packetLength] == 0x47 &&
+          data[i + 2 * packetLength] == 0x47) {
         return i;
       } else {
         i++;
@@ -443,6 +825,13 @@ shaka.util.TsParser = class {
 };
 
 
+/**
+ * @const {number}
+ * @export
+ */
+shaka.util.TsParser.Timescale = 90000;
+
+
 /**
  * @const {number}
  * @private
@@ -451,10 +840,24 @@ shaka.util.TsParser.PacketLength_ = 188;
 
 
 /**
+ * NALU type for Sequence Parameter Set (SPS) for H.264.
  * @const {number}
  * @private
  */
-shaka.util.TsParser.Timescale_ = 90000;
+shaka.util.TsParser.H264_NALU_TYPE_SPS_ = 0x07;
+
+
+/**
+ * Values of profile_idc that indicate additional fields are included in the
+ * SPS.
+ * see Recommendation ITU-T H.264 (4/2013)
+ * 7.3.2.1.1 Sequence parameter set data syntax
+ *
+ * @const {!Array.<number>}
+ * @private
+ */
+shaka.util.TsParser.PROFILES_WITH_OPTIONAL_SPS_DATA_ =
+    [100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134];
 
 
 /**
@@ -480,20 +883,3 @@ shaka.util.TsParser.Timescale_ = 90000;
  */
 shaka.util.TsParser.PMT;
 
-
-/**
- * @typedef {{
- *   data: Uint8Array,
- *   packetLength: number,
- *   pts: ?number,
- *   dts: ?number
- * }}
- *
- * @summary PES.
- * @property {Uint8Array} data
- * @property {number} packetLength
- * @property {?number} pts
- * @property {?number} dts
- */
-shaka.util.TsParser.PES;
-