@ahmedrowaihi/mediabunny 1.65.2-beta.320 → 1.65.2-beta.321

package/dist/bundles/mediabunny.cjs

@@ -2823,7 +2823,7 @@ var Mediabunny = (() => {
   var TRUEHD_MAJOR_SYNC_WORD = 4168249274;
 
   // src/version.ts
-  var VERSION = "1.65.1";
+  var VERSION = "1.65.2";
   var VERSIONED_NAME = `Mediabunny v${VERSION}`;
 
   // src/codec-data.ts
@@ -7303,50 +7303,62 @@ var Mediabunny = (() => {
   };
   var createAes128CbcDecryptStream = (reader, getInit, close) => {
     let initted = false;
+    let closed = false;
     let pos = 0;
     const CHUNK_SIZE = 2 ** 16;
     const BLOCK_SIZE = 16;
     const aesContext = new Aes128CbcContext();
+    const closeOnce = () => {
+      if (!closed) {
+        closed = true;
+        close();
+      }
+    };
     return new ReadableStream({
       pull: async (controller) => {
-        if (!initted) {
-          aesContext.init(await getInit());
-          initted = true;
-        }
-        const requestedLength = CHUNK_SIZE + BLOCK_SIZE;
-        let nextSlice = reader.requestSliceRange(pos, 0, requestedLength);
-        if (isThenable(nextSlice)) nextSlice = await nextSlice;
-        if (!nextSlice || nextSlice.length === 0) {
-          throw new Error("Invalid ciphertext.");
-        }
-        const sliceLength = nextSlice.length;
-        if (sliceLength % 16 !== 0) {
-          throw new Error("Invalid ciphertext.");
-        }
-        const bytesToRead = sliceLength === requestedLength ? sliceLength - BLOCK_SIZE : sliceLength;
-        const input = readBytes(nextSlice, bytesToRead);
-        const output = new Uint8Array(bytesToRead);
-        for (let i = 0; i < bytesToRead; i += 16) {
-          aesContext.in.set(input.subarray(i, i + 16));
-          aesContext.decrypt();
-          output.set(aesContext.out, i);
-        }
-        if (bytesToRead < sliceLength) {
-          controller.enqueue(output);
-          pos += bytesToRead;
-        } else {
-          const paddingLength = output[bytesToRead - 1];
-          if (paddingLength === 0 || paddingLength > 16) {
-            throw new Error("Invalid PKCS#7 padding. Incorrect key or corrupted data.");
+        try {
+          if (!initted) {
+            aesContext.init(await getInit());
+            initted = true;
+          }
+          const requestedLength = CHUNK_SIZE + BLOCK_SIZE;
+          let nextSlice = reader.requestSliceRange(pos, 0, requestedLength);
+          if (isThenable(nextSlice)) nextSlice = await nextSlice;
+          if (!nextSlice || nextSlice.length === 0) {
+            throw new Error("Invalid ciphertext.");
+          }
+          const sliceLength = nextSlice.length;
+          if (sliceLength % 16 !== 0) {
+            throw new Error("Invalid ciphertext.");
+          }
+          const bytesToRead = sliceLength === requestedLength ? sliceLength - BLOCK_SIZE : sliceLength;
+          const input = readBytes(nextSlice, bytesToRead);
+          const output = new Uint8Array(bytesToRead);
+          for (let i = 0; i < bytesToRead; i += 16) {
+            aesContext.in.set(input.subarray(i, i + 16));
+            aesContext.decrypt();
+            output.set(aesContext.out, i);
+          }
+          if (bytesToRead < sliceLength) {
+            controller.enqueue(output);
+            pos += bytesToRead;
+          } else {
+            const paddingLength = output[bytesToRead - 1];
+            if (paddingLength === 0 || paddingLength > 16) {
+              throw new Error("Invalid PKCS#7 padding. Incorrect key or corrupted data.");
+            }
+            const trimmedOutput = output.subarray(0, bytesToRead - paddingLength);
+            controller.enqueue(trimmedOutput);
+            controller.close();
+            closeOnce();
           }
-          const trimmedOutput = output.subarray(0, bytesToRead - paddingLength);
-          controller.enqueue(trimmedOutput);
-          controller.close();
-          close();
+        } catch (error) {
+          closeOnce();
+          throw error;
         }
       },
       cancel: () => {
-        close();
+        closeOnce();
       }
     });
   };
@@ -8059,7 +8071,8 @@ var Mediabunny = (() => {
           fragmentPositionCache.splice(insertionIndex + 1, 0, {
             moofOffset: fragment.moofOffset,
             startTimestamp: trackData.startTimestamp,
-            endTimestamp: trackData.endTimestamp
+            endTimestamp: trackData.endTimestamp,
+            hasKeyFrame: trackData.firstKeyFrameTimestamp !== null
           });
         }
         if (trackData.encryptionAuxInfo && track.encryptionInfo) {
@@ -10374,7 +10387,8 @@ var Mediabunny = (() => {
         },
         timestampInTimescale,
         timestampInTimescale,
-        options
+        options,
+        true
       );
     }
     async getNextKeyPacket(packet, options) {
@@ -10521,10 +10535,8 @@ var Mediabunny = (() => {
       return packet;
     }
     /** Looks for a packet in the fragments while trying to load as few fragments as possible to retrieve it. */
-    async performFragmentedLookup(startFragment, getMatchInFragment, searchTimestamp, latestTimestamp, options, stopPos = Infinity, lookupRetryCount = 0) {
-      const demuxer = this.internalTrack.demuxer;
-      let currentFragment = null;
-      let precedingFragment = null;
+    async performFragmentedLookup(startFragment, getMatchInFragment, searchTimestamp, latestTimestamp, options, requireKeyFrame = false) {
+      const { demuxer, fragmentLookupTable, fragmentPositionCache } = this.internalTrack;
       let bestFragment = null;
       let bestSampleIndex = -1;
       if (startFragment) {
@@ -10537,89 +10549,88 @@ var Mediabunny = (() => {
           bestSampleIndex = sampleIndex;
         }
       }
-      const lookupEntryIndex = binarySearchLessOrEqual(
-        this.internalTrack.fragmentLookupTable,
-        searchTimestamp,
-        (x) => x.timestamp
-      );
-      const lookupEntry = lookupEntryIndex !== -1 ? this.internalTrack.fragmentLookupTable[lookupEntryIndex] : null;
-      const positionCacheIndex = binarySearchLessOrEqual(
-        this.internalTrack.fragmentPositionCache,
-        searchTimestamp,
-        (x) => x.startTimestamp
-      );
-      const positionCacheEntry = positionCacheIndex !== -1 ? this.internalTrack.fragmentPositionCache[positionCacheIndex] : null;
-      const lookupEntryPosition = Math.max(
-        lookupEntry?.moofOffset ?? 0,
-        positionCacheEntry?.moofOffset ?? 0
-      ) || null;
-      const lookupTableWins = !!lookupEntry && lookupEntry.moofOffset >= (positionCacheEntry?.moofOffset ?? 0);
-      let currentPos;
-      if (!startFragment) {
-        currentPos = lookupEntryPosition ?? 0;
-      } else {
-        if (lookupEntryPosition === null || startFragment.moofOffset >= lookupEntryPosition) {
-          currentPos = startFragment.moofOffset + startFragment.moofSize;
-          currentFragment = startFragment;
+      let lookupEntryIndex = binarySearchLessOrEqual(fragmentLookupTable, searchTimestamp, (x) => x.timestamp);
+      let positionCacheIndex = binarySearchLessOrEqual(fragmentPositionCache, searchTimestamp, (x) => x.startTimestamp);
+      let stopPos = Infinity;
+      while (true) {
+        while (lookupEntryIndex !== -1 && fragmentLookupTable[lookupEntryIndex].moofOffset >= stopPos) {
+          lookupEntryIndex--;
+        }
+        while (positionCacheIndex !== -1 && (fragmentPositionCache[positionCacheIndex].moofOffset >= stopPos || requireKeyFrame && !fragmentPositionCache[positionCacheIndex].hasKeyFrame)) {
+          positionCacheIndex--;
+        }
+        const lookupEntryPosition = Math.max(
+          fragmentLookupTable[lookupEntryIndex]?.moofOffset ?? 0,
+          fragmentPositionCache[positionCacheIndex]?.moofOffset ?? 0
+        ) || null;
+        let currentPos;
+        let currentFragment = null;
+        let precedingFragment = null;
+        let scanReachedFragment = false;
+        if (!startFragment) {
+          currentPos = lookupEntryPosition ?? 0;
         } else {
-          currentPos = lookupEntryPosition;
+          if (lookupEntryPosition === null || startFragment.moofOffset >= lookupEntryPosition) {
+            currentPos = startFragment.moofOffset + startFragment.moofSize;
+            currentFragment = startFragment;
+          } else {
+            currentPos = lookupEntryPosition;
+          }
         }
-      }
-      const scanStartPos = currentFragment ? currentFragment.moofOffset : currentPos;
-      let scanReachedFragment = false;
-      while (currentPos < stopPos) {
-        if (currentFragment) {
-          const trackData = currentFragment.trackData.get(this.internalTrack.id);
-          if (trackData && trackData.startTimestamp > latestTimestamp) {
+        const scanStartPos = currentFragment ? currentFragment.moofOffset : currentPos;
+        while (currentPos < stopPos) {
+          if (currentFragment) {
+            const trackData = currentFragment.trackData.get(this.internalTrack.id);
+            if (trackData && trackData.startTimestamp > latestTimestamp) {
+              break;
+            }
+            precedingFragment = currentFragment;
+            currentFragment = null;
+          }
+          const summary = demuxer.fragmentSummaries.get(currentPos);
+          if (summary && !summary.trackIds.has(this.internalTrack.id)) {
+            currentPos += summary.moofSize;
+            continue;
+          }
+          let slice = demuxer.reader.requestSliceRange(currentPos, MIN_BOX_HEADER_SIZE, MAX_BOX_HEADER_SIZE);
+          if (isThenable(slice)) slice = await slice;
+          if (!slice) break;
+          const boxStartPos = currentPos;
+          const boxInfo = readBoxHeader(slice);
+          if (!boxInfo) {
             break;
           }
-          precedingFragment = currentFragment;
-          currentFragment = null;
-        }
-        const summary = demuxer.fragmentSummaries.get(currentPos);
-        if (summary && !summary.trackIds.has(this.internalTrack.id)) {
-          currentPos += summary.moofSize;
-          continue;
+          if (boxInfo.name === "moof") {
+            scanReachedFragment = true;
+            currentFragment = await demuxer.readFragment(boxStartPos, precedingFragment);
+            if (!currentFragment) {
+              break;
+            }
+            const { sampleIndex, correctSampleFound } = getMatchInFragment(currentFragment);
+            if (correctSampleFound) {
+              return this.fetchPacketInFragment(currentFragment, sampleIndex, options);
+            }
+            if (sampleIndex !== -1) {
+              bestFragment = currentFragment;
+              bestSampleIndex = sampleIndex;
+            }
+          }
+          currentPos = boxStartPos + boxInfo.totalSize;
         }
-        let slice = demuxer.reader.requestSliceRange(currentPos, MIN_BOX_HEADER_SIZE, MAX_BOX_HEADER_SIZE);
-        if (isThenable(slice)) slice = await slice;
-        if (!slice) break;
-        const boxStartPos = currentPos;
-        const boxInfo = readBoxHeader(slice);
-        if (!boxInfo) {
+        if (lookupEntryPosition === null || bestFragment && bestFragment.moofOffset >= lookupEntryPosition) {
           break;
         }
-        if (boxInfo.name === "moof") {
-          scanReachedFragment = true;
-          currentFragment = await demuxer.readFragment(boxStartPos, precedingFragment);
-          if (!currentFragment) {
-            break;
+        if (scanReachedFragment) {
+          stopPos = scanStartPos;
+        } else {
+          if (fragmentLookupTable[lookupEntryIndex]?.moofOffset === lookupEntryPosition) {
+            lookupEntryIndex--;
           }
-          const { sampleIndex, correctSampleFound } = getMatchInFragment(currentFragment);
-          if (correctSampleFound) {
-            return this.fetchPacketInFragment(currentFragment, sampleIndex, options);
-          }
-          if (sampleIndex !== -1) {
-            bestFragment = currentFragment;
-            bestSampleIndex = sampleIndex;
-          }
-        }
-        currentPos = boxStartPos + boxInfo.totalSize;
-      }
-      if (lookupEntryPosition !== null && (!bestFragment || bestFragment.moofOffset < lookupEntryPosition)) {
-        const step = 1 << lookupRetryCount;
-        const previousEntryTimestamp = lookupTableWins ? this.internalTrack.fragmentLookupTable[lookupEntryIndex - step]?.timestamp : this.internalTrack.fragmentPositionCache[positionCacheIndex - step]?.startTimestamp;
-        const newSearchTimestamp = previousEntryTimestamp ?? -Infinity;
-        return this.performFragmentedLookup(
-          null,
-          getMatchInFragment,
-          newSearchTimestamp,
-          latestTimestamp,
-          options,
-          // Only cap when the scan reached a fragment; capping a bogus offset hides the rest of the file
-          scanReachedFragment ? scanStartPos : stopPos,
-          lookupRetryCount + 1
-        );
+          if (fragmentPositionCache[positionCacheIndex]?.moofOffset === lookupEntryPosition) {
+            positionCacheIndex--;
+          }
+        }
+        startFragment = null;
       }
       if (bestFragment) {
         return this.fetchPacketInFragment(bestFragment, bestSampleIndex, options);
@@ -12253,7 +12264,8 @@ var Mediabunny = (() => {
         if ((!previousEntry || previousEntry.elementStartPos < elementStartPos) && (!nextEntry || nextEntry.elementStartPos > elementStartPos)) {
           track.clusterPositionCache.splice(insertionIndex + 1, 0, {
             elementStartPos: cluster.elementStartPos,
-            startTimestamp: trackData.startTimestamp
+            startTimestamp: trackData.startTimestamp,
+            hasKeyFrame: trackData.firstKeyFrameTimestamp !== null
           });
         }
       }
@@ -13747,7 +13759,8 @@ var Mediabunny = (() => {
         },
         timestampInTimescale,
         timestampInTimescale,
-        options
+        options,
+        true
       );
     }
     async getNextKeyPacket(packet, options) {
@@ -13840,9 +13853,8 @@ var Mediabunny = (() => {
       return packet;
     }
     /** Looks for a packet in the clusters while trying to load as few clusters as possible to retrieve it. */
-    async performClusterLookup(startCluster, getMatchInCluster, searchTimestamp, latestTimestamp, options, stopPos = Infinity, lookupRetryCount = 0) {
-      const { demuxer, segment } = this.internalTrack;
-      let currentCluster = null;
+    async performClusterLookup(startCluster, getMatchInCluster, searchTimestamp, latestTimestamp, options, requireKeyFrame = false) {
+      const { demuxer, segment, cuePoints, clusterPositionCache } = this.internalTrack;
       let bestCluster = null;
       let bestBlockIndex = -1;
       if (startCluster) {
@@ -13855,119 +13867,108 @@ var Mediabunny = (() => {
           bestBlockIndex = blockIndex;
         }
       }
-      const cuePointIndex = binarySearchLessOrEqual(
-        this.internalTrack.cuePoints,
-        searchTimestamp,
-        (x) => x.time
-      );
-      const cuePoint = cuePointIndex !== -1 ? this.internalTrack.cuePoints[cuePointIndex] : null;
-      const positionCacheIndex = binarySearchLessOrEqual(
-        this.internalTrack.clusterPositionCache,
-        searchTimestamp,
-        (x) => x.startTimestamp
-      );
-      const positionCacheEntry = positionCacheIndex !== -1 ? this.internalTrack.clusterPositionCache[positionCacheIndex] : null;
-      const lookupEntryPosition = Math.max(
-        cuePoint?.clusterPosition ?? 0,
-        positionCacheEntry?.elementStartPos ?? 0
-      ) || null;
-      const cuePointWins = !!cuePoint && cuePoint.clusterPosition >= (positionCacheEntry?.elementStartPos ?? 0);
-      let currentPos;
-      if (!startCluster) {
-        currentPos = lookupEntryPosition ?? segment.clusterSeekStartPos;
-      } else {
-        if (lookupEntryPosition === null || startCluster.elementStartPos >= lookupEntryPosition) {
-          currentPos = startCluster.elementEndPos;
-          currentCluster = startCluster;
+      let cuePointIndex = binarySearchLessOrEqual(cuePoints, searchTimestamp, (x) => x.time);
+      let positionCacheIndex = binarySearchLessOrEqual(clusterPositionCache, searchTimestamp, (x) => x.startTimestamp);
+      let stopPos = Infinity;
+      while (true) {
+        while (cuePointIndex !== -1 && cuePoints[cuePointIndex].clusterPosition >= stopPos) {
+          cuePointIndex--;
+        }
+        while (positionCacheIndex !== -1 && (clusterPositionCache[positionCacheIndex].elementStartPos >= stopPos || requireKeyFrame && !clusterPositionCache[positionCacheIndex].hasKeyFrame)) {
+          positionCacheIndex--;
+        }
+        const lookupEntryPosition = Math.max(
+          cuePoints[cuePointIndex]?.clusterPosition ?? 0,
+          clusterPositionCache[positionCacheIndex]?.elementStartPos ?? 0
+        ) || null;
+        let currentPos;
+        let currentCluster = null;
+        if (!startCluster) {
+          currentPos = lookupEntryPosition ?? segment.clusterSeekStartPos;
         } else {
-          currentPos = lookupEntryPosition;
-        }
-      }
-      const scanStartPos = currentCluster ? currentCluster.elementStartPos : currentPos;
-      while ((segment.elementEndPos === null || currentPos <= segment.elementEndPos - MIN_HEADER_SIZE) && currentPos < stopPos) {
-        if (currentCluster) {
-          const trackData = currentCluster.trackData.get(this.internalTrack.id);
-          if (trackData && trackData.startTimestamp > latestTimestamp) {
-            break;
+          if (lookupEntryPosition === null || startCluster.elementStartPos >= lookupEntryPosition) {
+            currentPos = startCluster.elementEndPos;
+            currentCluster = startCluster;
+          } else {
+            currentPos = lookupEntryPosition;
           }
-          currentCluster = null;
         }
-        const summary = segment.clusterSummaries.get(currentPos);
-        if (summary && !summary.trackIds.has(this.internalTrack.id)) {
-          currentPos = summary.elementEndPos;
-          continue;
-        }
-        let slice = demuxer.reader.requestSliceRange(currentPos, MIN_HEADER_SIZE, MAX_HEADER_SIZE);
-        if (isThenable(slice)) slice = await slice;
-        if (!slice) break;
-        const elementStartPos = currentPos;
-        const elementHeader = readElementHeader(slice);
-        if (!elementHeader || !LEVEL_1_EBML_IDS.includes(elementHeader.id) && elementHeader.id !== 236 /* Void */) {
-          const nextPos = await resync(
-            demuxer.reader,
-            elementStartPos + 1,
-            LEVEL_1_EBML_IDS,
-            Math.min(segment.elementEndPos ?? Infinity, elementStartPos + MAX_RESYNC_LENGTH)
-          );
-          if (nextPos) {
-            currentPos = nextPos;
+        const scanStartPos = currentCluster ? currentCluster.elementStartPos : currentPos;
+        while ((segment.elementEndPos === null || currentPos <= segment.elementEndPos - MIN_HEADER_SIZE) && currentPos < stopPos) {
+          if (currentCluster) {
+            const trackData = currentCluster.trackData.get(this.internalTrack.id);
+            if (trackData && trackData.startTimestamp > latestTimestamp) {
+              break;
+            }
+            currentCluster = null;
+          }
+          const summary = segment.clusterSummaries.get(currentPos);
+          if (summary && !summary.trackIds.has(this.internalTrack.id)) {
+            currentPos = summary.elementEndPos;
             continue;
-          } else {
-            break;
           }
-        }
-        const id = elementHeader.id;
-        let size = elementHeader.size;
-        const dataStartPos = slice.filePos;
-        if (id === 524531317 /* Cluster */) {
-          currentCluster = await demuxer.readCluster(elementStartPos, segment);
-          size = currentCluster.elementEndPos - dataStartPos;
-          const { blockIndex, correctBlockFound } = getMatchInCluster(currentCluster);
-          if (correctBlockFound) {
-            return this.fetchPacketInCluster(currentCluster, blockIndex, options);
+          let slice = demuxer.reader.requestSliceRange(currentPos, MIN_HEADER_SIZE, MAX_HEADER_SIZE);
+          if (isThenable(slice)) slice = await slice;
+          if (!slice) break;
+          const elementStartPos = currentPos;
+          const elementHeader = readElementHeader(slice);
+          if (!elementHeader || !LEVEL_1_EBML_IDS.includes(elementHeader.id) && elementHeader.id !== 236 /* Void */) {
+            const nextPos = await resync(
+              demuxer.reader,
+              elementStartPos + 1,
+              LEVEL_1_EBML_IDS,
+              Math.min(segment.elementEndPos ?? Infinity, elementStartPos + MAX_RESYNC_LENGTH)
+            );
+            if (nextPos) {
+              currentPos = nextPos;
+              continue;
+            } else {
+              break;
+            }
           }
-          if (blockIndex !== -1) {
-            bestCluster = currentCluster;
-            bestBlockIndex = blockIndex;
+          const id = elementHeader.id;
+          let size = elementHeader.size;
+          const dataStartPos = slice.filePos;
+          if (id === 524531317 /* Cluster */) {
+            currentCluster = await demuxer.readCluster(elementStartPos, segment);
+            size = currentCluster.elementEndPos - dataStartPos;
+            const { blockIndex, correctBlockFound } = getMatchInCluster(currentCluster);
+            if (correctBlockFound) {
+              return this.fetchPacketInCluster(currentCluster, blockIndex, options);
+            }
+            if (blockIndex !== -1) {
+              bestCluster = currentCluster;
+              bestBlockIndex = blockIndex;
+            }
+          }
+          if (size === void 0) {
+            assert(id !== 524531317 /* Cluster */);
+            const nextElementPos = await searchForNextElementId(
+              demuxer.reader,
+              dataStartPos,
+              LEVEL_0_AND_1_EBML_IDS,
+              segment.elementEndPos
+            );
+            size = nextElementPos.pos - dataStartPos;
           }
-        }
-        if (size === void 0) {
-          assert(id !== 524531317 /* Cluster */);
-          const nextElementPos = await searchForNextElementId(
-            demuxer.reader,
-            dataStartPos,
-            LEVEL_0_AND_1_EBML_IDS,
-            segment.elementEndPos
-          );
-          size = nextElementPos.pos - dataStartPos;
-        }
-        const endPos = dataStartPos + size;
-        if (segment.elementEndPos === null) {
-          let slice2 = demuxer.reader.requestSliceRange(endPos, MIN_HEADER_SIZE, MAX_HEADER_SIZE);
-          if (isThenable(slice2)) slice2 = await slice2;
-          if (!slice2) break;
-          const elementId = readElementId(slice2);
-          if (elementId === 408125543 /* Segment */) {
-            segment.elementEndPos = endPos;
-            break;
+          const endPos = dataStartPos + size;
+          if (segment.elementEndPos === null) {
+            let slice2 = demuxer.reader.requestSliceRange(endPos, MIN_HEADER_SIZE, MAX_HEADER_SIZE);
+            if (isThenable(slice2)) slice2 = await slice2;
+            if (!slice2) break;
+            const elementId = readElementId(slice2);
+            if (elementId === 408125543 /* Segment */) {
+              segment.elementEndPos = endPos;
+              break;
+            }
           }
+          currentPos = endPos;
         }
-        currentPos = endPos;
-      }
-      if (lookupEntryPosition !== null && (!bestCluster || bestCluster.elementStartPos < lookupEntryPosition)) {
-        const step = 1 << lookupRetryCount;
-        const previousEntryTimestamp = cuePointWins ? this.internalTrack.cuePoints[cuePointIndex - step]?.time : this.internalTrack.clusterPositionCache[positionCacheIndex - step]?.startTimestamp;
-        const newSearchTimestamp = previousEntryTimestamp ?? -Infinity;
-        return this.performClusterLookup(
-          null,
-          getMatchInCluster,
-          newSearchTimestamp,
-          latestTimestamp,
-          options,
-          scanStartPos,
-          // So we don't read the same clusters again
-          lookupRetryCount + 1
-        );
+        if (lookupEntryPosition === null || bestCluster && bestCluster.elementStartPos >= lookupEntryPosition) {
+          break;
+        }
+        stopPos = scanStartPos;
+        startCluster = null;
       }
       if (bestCluster) {
         return this.fetchPacketInCluster(bestCluster, bestBlockIndex, options);
@@ -40726,7 +40727,7 @@ var Mediabunny = (() => {
     const uniqueSampleSizes = new Set(allSampleSizes);
     const uniqueSampleFlags = new Set(allSampleFlags);
     const uniqueSampleCompositionTimeOffsets = new Set(allSampleCompositionTimeOffsets);
-    const firstSampleFlagsPresent = uniqueSampleFlags.size === 2 && allSampleFlags[0] !== allSampleFlags[1];
+    const firstSampleFlagsPresent = uniqueSampleFlags.size === 2 && findLastIndex(allSampleFlags, (x) => x === allSampleFlags[0]) === 0;
     const sampleDurationPresent = uniqueSampleDurations.size > 1;
     const sampleSizePresent = uniqueSampleSizes.size > 1;
     const sampleFlagsPresent = !firstSampleFlagsPresent && uniqueSampleFlags.size > 1;