shaka-player 4.5.0 → 4.6.0

package/lib/util/stream_utils.js

@@ -7,7 +7,6 @@
 goog.provide('shaka.util.StreamUtils');
 
 goog.require('goog.asserts');
-goog.require('shaka.config.CodecSwitchingStrategy');
 goog.require('shaka.log');
 goog.require('shaka.media.Capabilities');
 goog.require('shaka.text.TextEngine');
@@ -32,12 +31,10 @@ shaka.util.StreamUtils = class {
    * @param {!shaka.extern.Manifest} manifest
    * @param {!Array.<string>} preferredVideoCodecs
    * @param {!Array.<string>} preferredAudioCodecs
-   * @param {number} preferredAudioChannelCount
    * @param {!Array.<string>} preferredDecodingAttributes
    */
   static chooseCodecsAndFilterManifest(manifest, preferredVideoCodecs,
-      preferredAudioCodecs, preferredAudioChannelCount,
-      preferredDecodingAttributes) {
+      preferredAudioCodecs, preferredDecodingAttributes) {
     const StreamUtils = shaka.util.StreamUtils;
     const MimeUtils = shaka.util.MimeUtils;
 
@@ -76,11 +73,6 @@ shaka.util.StreamUtils = class {
       variants = bestVariants;
     }
 
-    if (preferredAudioChannelCount) {
-      variants = StreamUtils.filterVariantsByAudioChannelCount(
-          variants, preferredAudioChannelCount);
-    }
-
     const audioStreamsSet = new Set();
     const videoStreamsSet = new Set();
     for (const variant of variants) {
@@ -95,23 +87,34 @@ shaka.util.StreamUtils = class {
     const audioStreams = Array.from(audioStreamsSet).sort((v1, v2) => {
       return v1.bandwidth - v2.bandwidth;
     });
-    const audioStreamsMap = new Map();
+    const validAudioIds = [];
+    const validAudioStreamsMap = new Map();
     const getAudioId = (stream) => {
       return stream.language + (stream.channelsCount || 0) +
-        stream.roles.join(',') + stream.label;
+        (stream.audioSamplingRate || 0) + stream.roles.join(',') +
+        stream.label + stream.groupId + stream.fastSwitching;
     };
     for (const stream of audioStreams) {
-      const id = getAudioId(stream);
-      if (!audioStreamsMap.has(id)) {
-        audioStreamsMap.set(id, stream);
+      const groupId = getAudioId(stream);
+      const validAudioStreams = validAudioStreamsMap.get(groupId) || [];
+      if (!validAudioStreams.length) {
+        validAudioStreams.push(stream);
+        validAudioIds.push(stream.id);
       } else {
-        const includedStream = audioStreamsMap.get(id);
-        if (includedStream.bandwidth > stream.bandwidth) {
-          audioStreamsMap.set(id, stream);
+        const previousStream = validAudioStreams[validAudioStreams.length - 1];
+        const previousCodec =
+          MimeUtils.getNormalizedCodec(previousStream.codecs);
+        const currentCodec =
+          MimeUtils.getNormalizedCodec(stream.codecs);
+        if (previousCodec == currentCodec) {
+          if (stream.bandwidth > previousStream.bandwidth) {
+            validAudioStreams.push(stream);
+            validAudioIds.push(stream.id);
+          }
         }
       }
+      validAudioStreamsMap.set(groupId, validAudioStreams);
     }
-    const validAudioStreams = [...audioStreamsMap.values()];
 
     const videoStreams = Array.from(videoStreamsSet)
         .sort((v1, v2) => {
@@ -124,10 +127,18 @@ shaka.util.StreamUtils = class {
     const isChangeTypeSupported =
       shaka.media.Capabilities.isChangeTypeSupported();
 
-    const validVideoStreams = [];
+    const validVideoIds = [];
+    const validVideoStreamsMap = new Map();
+    const getVideoGroupId = (stream) => {
+      return Math.round(stream.frameRate || 0) + (stream.hdr || '') +
+          stream.fastSwitching;
+    };
     for (const stream of videoStreams) {
+      const groupId = getVideoGroupId(stream);
+      const validVideoStreams = validVideoStreamsMap.get(groupId) || [];
       if (!validVideoStreams.length) {
         validVideoStreams.push(stream);
+        validVideoIds.push(stream.id);
       } else {
         const previousStream = validVideoStreams[validVideoStreams.length - 1];
         if (!isChangeTypeSupported) {
@@ -142,6 +153,7 @@ shaka.util.StreamUtils = class {
         if (stream.width > previousStream.width ||
           stream.height > previousStream.height) {
           validVideoStreams.push(stream);
+          validVideoIds.push(stream.id);
         } else if (stream.width == previousStream.width &&
           stream.height == previousStream.height) {
           const previousCodec =
@@ -151,17 +163,14 @@ shaka.util.StreamUtils = class {
           if (previousCodec == currentCodec) {
             if (stream.bandwidth < previousStream.bandwidth) {
               validVideoStreams.push(stream);
+              validVideoIds.push(stream.id);
             }
           }
         }
       }
+      validVideoStreamsMap.set(groupId, validVideoStreams);
     }
 
-    const validAudioIds =
-      validAudioStreams.map((audioStream) => audioStream.id);
-    const validVideoIds =
-      validVideoStreams.map((videoStream) => videoStream.id);
-
     // Filter out any variants that don't match, forcing AbrManager to choose
     // from a single video codec and a single audio codec possible.
     manifest.variants = manifest.variants.filter((variant) => {
@@ -319,14 +328,11 @@ shaka.util.StreamUtils = class {
    * Alters the given Manifest to filter out any unplayable streams.
    *
    * @param {shaka.media.DrmEngine} drmEngine
-   * @param {?shaka.extern.Variant} currentVariant
    * @param {shaka.extern.Manifest} manifest
-   * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
    */
-  static async filterManifest(drmEngine, currentVariant, manifest,
-      codecSwitchingStrategy=shaka.config.CodecSwitchingStrategy.RELOAD) {
-    await shaka.util.StreamUtils.filterManifestByMediaCapabilities(manifest,
-        manifest.offlineSessionIds.length > 0);
+  static async filterManifest(drmEngine, manifest) {
+    await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
+        drmEngine, manifest, manifest.offlineSessionIds.length > 0);
     shaka.util.StreamUtils.filterTextStreams_(manifest);
     await shaka.util.StreamUtils.filterImageStreams_(manifest);
   }
@@ -336,30 +342,53 @@ shaka.util.StreamUtils = class {
    * Alters the given Manifest to filter out any streams unsupported by the
    * platform via MediaCapabilities.decodingInfo() API.
    *
+   * @param {shaka.media.DrmEngine} drmEngine
    * @param {shaka.extern.Manifest} manifest
    * @param {boolean} usePersistentLicenses
    */
   static async filterManifestByMediaCapabilities(
-      manifest, usePersistentLicenses) {
+      drmEngine, manifest, usePersistentLicenses) {
     goog.asserts.assert(navigator.mediaCapabilities,
         'MediaCapabilities should be valid.');
 
     await shaka.util.StreamUtils.getDecodingInfosForVariants(
         manifest.variants, usePersistentLicenses, /* srcEquals= */ false,
         /** preferredKeySystems= */ []);
+
+    let keySystem = null;
+    if (drmEngine) {
+      const drmInfo = drmEngine.getDrmInfo();
+      if (drmInfo) {
+        keySystem = drmInfo.keySystem;
+      }
+    }
+
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const Capabilities = shaka.media.Capabilities;
+    const ManifestParserUtils = shaka.util.ManifestParserUtils;
+    const MimeUtils = shaka.util.MimeUtils;
+    const StreamUtils = shaka.util.StreamUtils;
+    const isXboxOne = shaka.util.Platform.isXboxOne();
+
     manifest.variants = manifest.variants.filter((variant) => {
       // See: https://github.com/shaka-project/shaka-player/issues/3860
       const video = variant.video;
+      const videoWidth = (video && video.width) || 0;
+      const videoHeight = (video && video.height) || 0;
 
-      const ContentType = shaka.util.ManifestParserUtils.ContentType;
-      const Capabilities = shaka.media.Capabilities;
-      const ManifestParserUtils = shaka.util.ManifestParserUtils;
-      const MimeUtils = shaka.util.MimeUtils;
-      const StreamUtils = shaka.util.StreamUtils;
+      // See: https://github.com/shaka-project/shaka-player/issues/3380
+      // Note: it makes sense to drop early
+      if (isXboxOne && video &&
+        (videoWidth > 1920 || videoHeight > 1080) &&
+        (video.codecs.includes('avc1.') || video.codecs.includes('avc3.'))
+      ) {
+        shaka.log.debug('Dropping variant - not compatible with platform',
+            StreamUtils.getVariantSummaryString_(variant));
+        return false;
+      }
 
       if (video) {
         let videoCodecs = StreamUtils.getCorrectVideoCodecs_(video.codecs);
-
         // For multiplexed streams. Here we must check the audio of the
         // stream to see if it is compatible.
         if (video.codecs.includes(',')) {
@@ -368,7 +397,6 @@ shaka.util.StreamUtils = class {
           videoCodecs = ManifestParserUtils.guessCodecs(
               ContentType.VIDEO, allCodecs);
           videoCodecs = StreamUtils.getCorrectVideoCodecs_(videoCodecs);
-
           let audioCodecs = ManifestParserUtils.guessCodecs(
               ContentType.AUDIO, allCodecs);
           audioCodecs = StreamUtils.getCorrectAudioCodecs_(audioCodecs);
@@ -410,19 +438,19 @@ shaka.util.StreamUtils = class {
         audio.codecs = codecs;
       }
 
-      // See: https://github.com/shaka-project/shaka-player/issues/3380
-      if (shaka.util.Platform.isXboxOne() && video &&
-          ((video.width && video.width > 1920) ||
-          (video.height && video.height > 1080)) &&
-          (video.codecs.includes('avc1.') ||
-          video.codecs.includes('avc3.'))) {
-        shaka.log.debug('Dropping variant - not compatible with platform',
-            StreamUtils.getVariantSummaryString_(variant));
-        return false;
-      }
-
       const supported = variant.decodingInfos.some((decodingInfo) => {
-        return decodingInfo.supported;
+        if (!decodingInfo.supported) {
+          return false;
+        }
+        if (keySystem) {
+          const keySystemAccess = decodingInfo.keySystemAccess;
+          if (keySystemAccess) {
+            if (keySystemAccess.keySystem != keySystem) {
+              return false;
+            }
+          }
+        }
+        return true;
       });
       // Filter out all unsupported variants.
       if (!supported) {
@@ -930,7 +958,10 @@ shaka.util.StreamUtils = class {
   static async filterImageStreams_(manifest) {
     const imageStreams = [];
     for (const stream of manifest.imageStreams) {
-      const mimeType = stream.mimeType;
+      let mimeType = stream.mimeType;
+      if (mimeType == 'application/mp4' && stream.codecs == 'mjpg') {
+        mimeType = 'image/jpg';
+      }
       if (!shaka.util.StreamUtils.supportedImageMimeTypes_.has(mimeType)) {
         const minImage = shaka.util.StreamUtils.minImage_.get(mimeType);
         if (minImage) {
@@ -1080,6 +1111,7 @@ shaka.util.StreamUtils = class {
       frameRate: null,
       pixelAspectRatio: null,
       hdr: null,
+      videoLayout: null,
       mimeType: mimeType,
       audioMimeType: audioMimeType,
       videoMimeType: videoMimeType,
@@ -1115,6 +1147,7 @@ shaka.util.StreamUtils = class {
       track.pixelAspectRatio = video.pixelAspectRatio || null;
       track.videoBandwidth = video.bandwidth || null;
       track.hdr = video.hdr || null;
+      track.videoLayout = video.videoLayout || null;
     }
 
     if (audio) {
@@ -1155,6 +1188,7 @@ shaka.util.StreamUtils = class {
       frameRate: null,
       pixelAspectRatio: null,
       hdr: null,
+      videoLayout: null,
       mimeType: stream.mimeType,
       audioMimeType: null,
       videoMimeType: null,
@@ -1231,10 +1265,11 @@ shaka.util.StreamUtils = class {
       frameRate: null,
       pixelAspectRatio: null,
       hdr: null,
+      videoLayout: null,
       mimeType: stream.mimeType,
       audioMimeType: null,
       videoMimeType: null,
-      codecs: null,
+      codecs: stream.codecs || null,
       audioCodec: null,
       videoCodec: null,
       primary: false,
@@ -1358,6 +1393,7 @@ shaka.util.StreamUtils = class {
       frameRate: null,
       pixelAspectRatio: null,
       hdr: null,
+      videoLayout: null,
       mimeType: null,
       audioMimeType: null,
       videoMimeType: null,
@@ -1412,52 +1448,6 @@ shaka.util.StreamUtils = class {
   }
 
 
-  /**
-   * Filters variants according to the given audio channel count config.
-   *
-   * @param {!Array.<shaka.extern.Variant>} variants
-   * @param {number} preferredAudioChannelCount
-   * @return {!Array.<!shaka.extern.Variant>}
-   */
-  static filterVariantsByAudioChannelCount(
-      variants, preferredAudioChannelCount) {
-    // Group variants by their audio channel counts.
-    const variantsWithChannelCounts =
-        variants.filter((v) => v.audio && v.audio.channelsCount);
-
-    /** @type {!Map.<number, !Array.<shaka.extern.Variant>>} */
-    const variantsByChannelCount = new Map();
-    const capableVariants = [];
-    for (const variant of variantsWithChannelCounts) {
-      const count = variant.audio.channelsCount;
-      goog.asserts.assert(count != null, 'Must have count after filtering!');
-      if (!variantsByChannelCount.has(count)) {
-        variantsByChannelCount.set(count, []);
-      }
-      variantsByChannelCount.get(count).push(variant);
-      if (count <= preferredAudioChannelCount) {
-        capableVariants.push(variant);
-      }
-    }
-
-    // return all capable channelcounts
-    if (capableVariants.length) {
-      return capableVariants;
-    }
-
-    /** @type {!Array.<number>} */
-    const channelCounts = Array.from(variantsByChannelCount.keys());
-
-    // If no variant has audio channel count info, return the original variants.
-    if (channelCounts.length == 0) {
-      return variants;
-    }
-
-    // If all variants have more audio channels than the config, choose the
-    // variants with the fewest audio channels.
-    return variantsByChannelCount.get(Math.min(...channelCounts));
-  }
-
   /**
    * Chooses streams according to the given config.
    * Works both for Stream and Track types due to their similarities.
@@ -1608,6 +1598,23 @@ shaka.util.StreamUtils = class {
   }
 
 
+  /**
+   * Indicates if some of the variant's streams are fastSwitching.
+   *
+   * @param {shaka.extern.Variant} variant
+   * @return {boolean}
+   */
+  static isFastSwitching(variant) {
+    if (variant.audio && variant.audio.fastSwitching) {
+      return true;
+    }
+    if (variant.video && variant.video.fastSwitching) {
+      return true;
+    }
+    return false;
+  }
+
+
   /**
    * Returns a string of a variant, with the attribute values of its audio
    * and/or video streams for log printing.

package/lib/util/ts_parser.js

@@ -35,6 +35,9 @@ shaka.util.TsParser = class {
     /** @private {!Array.<Uint8Array>} */
     this.videoData_ = [];
 
+    /** @private {!Array.<shaka.extern.MPEG_PES>} */
+    this.videoPes_ = [];
+
     /** @private {?number} */
     this.audioPid_ = null;
 
@@ -44,6 +47,9 @@ shaka.util.TsParser = class {
     /** @private {!Array.<Uint8Array>} */
     this.audioData_ = [];
 
+    /** @private {!Array.<shaka.extern.MPEG_PES>} */
+    this.audioPes_ = [];
+
     /** @private {?number} */
     this.id3Pid_ = null;
 
@@ -58,7 +64,9 @@ shaka.util.TsParser = class {
    */
   clearData() {
     this.videoData_ = [];
+    this.videoPes_ = [];
     this.audioData_ = [];
+    this.audioPes_ = [];
     this.id3Data_ = [];
   }
 
@@ -360,6 +368,7 @@ shaka.util.TsParser = class {
       packetLength: ((data[4] << 8) | data[5]),
       pts: null,
       dts: null,
+      nalus: [],
     };
 
     // if PES parsed length is not zero and greater than total received length,
@@ -430,7 +439,7 @@ shaka.util.TsParser = class {
     shaka.Deprecate.deprecateFeature(5,
         'TsParser',
         'Please use parseNalus function instead.');
-    return this.parseNalus(pes, nextPes);
+    return this.parseNalus(pes);
   }
 
   /**
@@ -440,12 +449,11 @@ shaka.util.TsParser = class {
    * 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
    * @param {?shaka.extern.VideoNalu=} lastNalu
    * @return {!Array.<shaka.extern.VideoNalu>}
    * @export
    */
-  parseNalus(pes, nextPes, lastNalu) {
+  parseNalus(pes, lastNalu) {
     const timescale = shaka.util.TsParser.Timescale;
     const time = pes.pts ? pes.pts / timescale : null;
     const data = pes.data;
@@ -479,21 +487,21 @@ shaka.util.TsParser = class {
       const value = data[i];
       if (!value) {
         numZeros++;
-      } else if (numZeros >= 2 && value == 1 && lastNalu) {
-        // 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;
-        // Optimization
-        if (lastByteToKeep == 0) {
-          return [];
-        }
-        lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
-            lastNalu.data, data.subarray(0, lastByteToKeep));
-        lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
-            lastNalu.fullData, data.subarray(0, lastByteToKeep));
-        return [];
       } else if (numZeros >= 2 && value == 1) {
+        if (lastNalu && !nalus.length && lastNaluStart == -1) {
+          // 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;
+          // Optimization
+          if (lastByteToKeep != 0) {
+            const prevData = data.subarray(0, lastByteToKeep);
+            lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+                lastNalu.data, prevData);
+            lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+                lastNalu.fullData, prevData);
+          }
+        }
         // We just read a start code.  Consume the NALU we passed, if any.
         if (lastNaluStart >= 0) {
           // Because the start position includes the header size.
@@ -513,11 +521,14 @@ shaka.util.TsParser = class {
             time: time,
           };
           nalus.push(nalu);
-        } else if (lastNalu) {
+        } else if (lastNalu && !nalus.length) {
           const overflow = i - numZeros;
           if (overflow > 0) {
+            const prevData = data.subarray(0, overflow);
             lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
-                lastNalu.data, data.subarray(0, overflow));
+                lastNalu.data, prevData);
+            lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+                lastNalu.fullData, prevData);
           }
         }
 
@@ -553,9 +564,6 @@ shaka.util.TsParser = class {
           type: lastNaluType,
           time: time,
         };
-        if (nextPes) {
-          this.parseNalus(nextPes, /* nextPes= */ null, infoOfLastNalu);
-        }
       }
     }
 
@@ -602,73 +610,122 @@ shaka.util.TsParser = class {
    * @export
    */
   getAudioData() {
-    const audio = [];
-    for (const audioData of this.audioData_) {
-      const pes = this.parsePES_(audioData);
-      if (pes) {
-        audio.push(pes);
+    if (this.audioData_.length && !this.audioPes_.length) {
+      let sort = false;
+      for (const audioData of this.audioData_) {
+        const pes = this.parsePES_(audioData);
+        if (pes && pes.pts != null && pes.dts != null) {
+          if (this.audioPes_.length &&
+              pes.dts < (this.audioPes_[this.audioPes_.length - 1].dts || 0)) {
+            sort = true;
+          }
+          this.audioPes_.push(pes);
+        } else if (this.audioPes_.length) {
+          const data = pes ? pes.data : audioData;
+          if (!data) {
+            continue;
+          }
+          const previousPes = this.audioPes_.pop();
+          previousPes.data =
+              shaka.util.Uint8ArrayUtils.concat(previousPes.data, data);
+          this.audioPes_.push(previousPes);
+        }
+      }
+      if (sort) {
+        this.audioPes_ = this.audioPes_.sort((a, b) => {
+          const deltadts = (a.dts || 0) - (b.dts || 0);
+          const deltapts = (a.pts || 0) - (b.pts || 0);
+          return deltadts || deltapts;
+        });
       }
     }
-    return audio;
+    return this.audioPes_;
   }
 
   /**
    * Return the audio data
    *
+   * @param {boolean=} naluProcessing
    * @return {!Array.<shaka.extern.MPEG_PES>}
    * @export
    */
-  getVideoData() {
-    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
-    const video = [];
-    for (const videoData of this.videoData_) {
-      const pes = this.parsePES_(videoData);
-      if (pes && pes.pts != null && pes.dts != null) {
-        video.push(pes);
-      } else if (video.length) {
-        const data = pes ? pes.data : videoData;
-        if (!data) {
-          continue;
+  getVideoData(naluProcessing = true) {
+    if (this.videoData_.length && !this.videoPes_.length) {
+      let sort = false;
+      for (const videoData of this.videoData_) {
+        const pes = this.parsePES_(videoData);
+        if (pes && pes.pts != null && pes.dts != null) {
+          if (this.videoPes_.length &&
+              pes.dts < (this.videoPes_[this.videoPes_.length - 1].dts || 0)) {
+            sort = true;
+          }
+          this.videoPes_.push(pes);
+        } else if (this.videoPes_.length) {
+          const data = pes ? pes.data : videoData;
+          if (!data) {
+            continue;
+          }
+          const previousPes = this.videoPes_.pop();
+          previousPes.data =
+              shaka.util.Uint8ArrayUtils.concat(previousPes.data, data);
+          this.videoPes_.push(previousPes);
         }
-        const previousPes = video.pop();
-        previousPes.data =
-            Uint8ArrayUtils.concat(previousPes.data, data);
-        video.push(previousPes);
       }
+      if (naluProcessing) {
+        let lastNalu;
+        for (const pes of this.videoPes_) {
+          pes.nalus = this.parseNalus(pes, lastNalu);
+          if (pes.nalus.length) {
+            lastNalu = pes.nalus[pes.nalus.length - 1];
+          }
+        }
+        this.videoPes_ = this.videoPes_.filter((pes) => {
+          return pes.nalus.length;
+        });
+      }
+      if (sort) {
+        this.videoPes_ = this.videoPes_.sort((a, b) => {
+          const deltadts = (a.dts || 0) - (b.dts || 0);
+          const deltapts = (a.pts || 0) - (b.pts || 0);
+          return deltadts || deltapts;
+        });
+      }
+    }
+    if (!naluProcessing) {
+      const prevVideoPes = this.videoPes_;
+      this.videoPes_ = [];
+      return prevVideoPes;
     }
-    return video;
+    return this.videoPes_;
   }
 
   /**
    * Return the start time for the audio and video
    *
-   * @return {{audio: ?number, video: ?number}}
+   * @param {string} contentType
+   * @return {?number}
    * @export
    */
-  getStartTime() {
+  getStartTime(contentType) {
     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;
-        }
+    if (contentType == 'audio') {
+      let audioStartTime = null;
+      const audioData = this.getAudioData();
+      if (audioData.length) {
+        const pes = audioData[0];
+        audioStartTime = Math.min(pes.dts, pes.pts) / timescale;
       }
-    }
-    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 audioStartTime;
+    } else if (contentType == 'video') {
+      let videoStartTime = null;
+      const videoData = this.getVideoData(/* naluProcessing= */ false);
+      if (videoData.length) {
+        const pes = videoData[0];
+        videoStartTime = Math.min(pes.dts, pes.pts) / timescale;
       }
+      return videoStartTime;
     }
-    return {
-      audio: audioStartTime,
-      video: videoStartTime,
-    };
+    return null;
   }
 
   /**
@@ -692,14 +749,8 @@ shaka.util.TsParser = class {
    */
   getVideoNalus() {
     const 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.parseNalus(pes, nextPes));
+    for (const pes of this.getVideoData()) {
+      nalus.push(...pes.nalus);
     }
     return nalus;
   }

package/lib/util/uint8array_utils.js

@@ -115,7 +115,11 @@ shaka.util.Uint8ArrayUtils = class {
     const result = new Uint8Array(totalLength);
     let offset = 0;
     for (const arr of varArgs) {
-      result.set(shaka.util.BufferUtils.toUint8(arr), offset);
+      if (arr instanceof Uint8Array) {
+        result.set(arr, offset);
+      } else {
+        result.set(shaka.util.BufferUtils.toUint8(arr), offset);
+      }
       offset += arr.byteLength;
     }
     return result;