mediabunny 1.29.0 → 1.30.0

package/dist/bundles/mediabunny.cjs

@@ -536,6 +536,9 @@ var Mediabunny = (() => {
   var roundToMultiple = (value, multiple) => {
     return Math.round(value / multiple) * multiple;
   };
+  var floorToMultiple = (value, multiple) => {
+    return Math.floor(value / multiple) * multiple;
+  };
   var ilog = (x) => {
     let ret = 0;
     while (x) {
@@ -7075,6 +7078,14 @@ var Mediabunny = (() => {
     get id() {
       return this._backing.getId();
     }
+    /**
+     * The 1-based index of this track among all tracks of the same type in the input file. For example, the first
+     * video track has number 1, the second video track has number 2, and so on. The index refers to the order in
+     * which the tracks are returned by {@link Input.getTracks}.
+     */
+    get number() {
+      return this._backing.getNumber();
+    }
     /**
      * The identifier of the codec used internally by the container. It is not homogenized by Mediabunny
      * and depends entirely on the container format.
@@ -9222,6 +9233,21 @@ var Mediabunny = (() => {
     getId() {
       return this.internalTrack.id;
     }
+    getNumber() {
+      const demuxer = this.internalTrack.demuxer;
+      const inputTrack = this.internalTrack.inputTrack;
+      const trackType = inputTrack.type;
+      let number = 0;
+      for (const track of demuxer.tracks) {
+        if (track.inputTrack.type === trackType) {
+          number++;
+        }
+        if (track === this.internalTrack) {
+          break;
+        }
+      }
+      return number;
+    }
     getCodec() {
       throw new Error("Not implemented on base class.");
     }
@@ -11745,6 +11771,23 @@ var Mediabunny = (() => {
     getId() {
       return this.internalTrack.id;
     }
+    getNumber() {
+      const demuxer = this.internalTrack.demuxer;
+      const inputTrack = this.internalTrack.inputTrack;
+      const trackType = inputTrack.type;
+      let number = 0;
+      for (const segment of demuxer.segments) {
+        for (const track of segment.tracks) {
+          if (track.inputTrack.type === trackType) {
+            number++;
+          }
+          if (track === this.internalTrack) {
+            break;
+          }
+        }
+      }
+      return number;
+    }
     getCodec() {
       throw new Error("Not implemented on base class.");
     }
@@ -13517,6 +13560,9 @@ var Mediabunny = (() => {
     getId() {
       return 1;
     }
+    getNumber() {
+      return 1;
+    }
     async getFirstTimestamp() {
       return 0;
     }
@@ -14043,6 +14089,13 @@ var Mediabunny = (() => {
     getId() {
       return this.bitstream.serialNumber;
     }
+    getNumber() {
+      const index = this.demuxer.tracks.findIndex(
+        (t) => t._backing.bitstream === this.bitstream
+      );
+      assert(index !== -1);
+      return index + 1;
+    }
     getNumberOfChannels() {
       return this.bitstream.numberOfChannels;
     }
@@ -14777,6 +14830,9 @@ var Mediabunny = (() => {
     getId() {
       return 1;
     }
+    getNumber() {
+      return 1;
+    }
     getCodec() {
       return this.demuxer.getCodec();
     }
@@ -15045,6 +15101,9 @@ var Mediabunny = (() => {
     getId() {
       return 1;
     }
+    getNumber() {
+      return 1;
+    }
     async getFirstTimestamp() {
       return 0;
     }
@@ -15626,6 +15685,9 @@ var Mediabunny = (() => {
     getId() {
       return 1;
     }
+    getNumber() {
+      return 1;
+    }
     getCodec() {
       return "flac";
     }
@@ -15789,6 +15851,10 @@ var Mediabunny = (() => {
       this.tracks = [];
       this.packetOffset = 0;
       this.packetStride = -1;
+      this.sectionEndPositions = [];
+      this.seekChunkSize = 5 * 1024 * 1024;
+      // 5 MiB, picked because most HLS segments are below this size
+      this.minReferencePointByteDistance = -1;
       this.reader = input._reader;
     }
     async readMetadata() {
@@ -15810,12 +15876,19 @@ var Mediabunny = (() => {
         } else {
           throw new Error("Unreachable.");
         }
+        const MIN_REFERENCE_POINT_PACKET_DISTANCE = 256;
+        this.minReferencePointByteDistance = MIN_REFERENCE_POINT_PACKET_DISTANCE * this.packetStride;
         let currentPos = this.packetOffset;
         let programMapPid = null;
         let hasProgramAssociationTable = false;
         let hasProgramMap = false;
         while (true) {
-          const section = await this.readSection(currentPos, true);
+          const section = await this.readSection(
+            currentPos,
+            true,
+            !hasProgramMap
+            // Expect contiguous sections as long as we don't have the PMT
+          );
           if (!section) {
             break;
           }
@@ -16049,12 +16122,14 @@ var Mediabunny = (() => {
       const codecStrings = await Promise.all(tracks.map((x) => x.getCodecParameterString()));
       return buildMpegTsMimeType(codecStrings);
     }
-    async readSection(startPos, full) {
+    async readSection(startPos, full, contiguous = false) {
       let endPos = startPos;
       let currentPos = startPos;
       const chunks = [];
       let chunksByteLength = 0;
       let firstPacket = null;
+      let mustAddSectionEnd = true;
+      let randomAccessIndicator = 0;
       while (true) {
         const packet = await this.readPacket(currentPos);
         currentPos += this.packetStride;
@@ -16068,7 +16143,11 @@ var Mediabunny = (() => {
           firstPacket = packet;
         } else {
           if (packet.pid !== firstPacket.pid) {
-            continue;
+            if (contiguous) {
+              break;
+            } else {
+              continue;
+            }
           }
           if (packet.payloadUnitStartIndicator === 1) {
             break;
@@ -16079,6 +16158,9 @@ var Mediabunny = (() => {
         let adaptationFieldLength = 0;
         if (hasAdaptationField) {
           adaptationFieldLength = 1 + packet.body[0];
+          if (packet === firstPacket && adaptationFieldLength > 1) {
+            randomAccessIndicator = packet.body[1] >> 6 & 1;
+          }
         }
         if (hasPayload) {
           if (adaptationFieldLength === 0) {
@@ -16091,9 +16173,19 @@ var Mediabunny = (() => {
         }
         endPos = currentPos;
         if (!full && chunksByteLength >= 64) {
+          mustAddSectionEnd = false;
+          break;
+        }
+        const isKnownSectionEnd = binarySearchExact(this.sectionEndPositions, endPos, (x) => x) !== -1;
+        if (isKnownSectionEnd) {
+          mustAddSectionEnd = false;
           break;
         }
       }
+      if (mustAddSectionEnd) {
+        const index = binarySearchLessOrEqual(this.sectionEndPositions, endPos, (x) => x);
+        this.sectionEndPositions.splice(index + 1, 0, endPos);
+      }
       if (!firstPacket) {
         return null;
       }
@@ -16113,7 +16205,8 @@ var Mediabunny = (() => {
         startPos,
         endPos: full ? endPos : null,
         pid: firstPacket.pid,
-        payload: merged
+        payload: merged,
+        randomAccessIndicator
       };
     }
     async readPacketHeader(pos) {
@@ -16199,7 +16292,8 @@ var Mediabunny = (() => {
     return {
       sectionStartPos: section.startPos,
       sectionEndPos: section.endPos,
-      pts
+      pts,
+      randomAccessIndicator: section.randomAccessIndicator
     };
   };
   var readPesPacket = (section) => {
@@ -16230,23 +16324,37 @@ var Mediabunny = (() => {
       data
     };
   };
-  var MpegTsTrackBacking = class {
+  var MpegTsTrackBacking = class _MpegTsTrackBacking {
     constructor(elementaryStream) {
       this.elementaryStream = elementaryStream;
       /**
-       * Reference PES packets, spread throughout the file, to be used to speed up random access and perform
-       * binary search for packets.
+       * Reference PES packets, spread throughout the file, to be used to speed up repeated random access. Sorted by both
+       * byte offset and PTS.
        */
       this.referencePesPackets = [];
       this.endReferencePesPacketAdded = false;
       this.packetBuffers = /* @__PURE__ */ new WeakMap();
       /** Used for recreating PacketBuffers if necessary. */
       this.packetSectionStarts = /* @__PURE__ */ new WeakMap();
-      this.mutex = new AsyncMutex();
     }
     getId() {
       return this.elementaryStream.pid;
     }
+    getNumber() {
+      const demuxer = this.elementaryStream.demuxer;
+      const trackType = this.elementaryStream.info.type;
+      let number = 0;
+      for (const track of demuxer.tracks) {
+        if (track.type === trackType) {
+          number++;
+        }
+        assert(track._backing instanceof _MpegTsTrackBacking);
+        if (track._backing.elementaryStream === this.elementaryStream) {
+          break;
+        }
+      }
+      return number;
+    }
     getCodec() {
       throw new Error("Not implemented on base class.");
     }
@@ -16274,34 +16382,42 @@ var Mediabunny = (() => {
       return firstPacket?.timestamp ?? 0;
     }
     createEncodedPacket(suppliedPacket, duration, options) {
+      let packetType;
+      if (this.allPacketsAreKeyPackets()) {
+        packetType = "key";
+      } else {
+        packetType = suppliedPacket.randomAccessIndicator === 1 ? "key" : "delta";
+      }
       return new EncodedPacket(
         options.metadataOnly ? PLACEHOLDER_DATA : suppliedPacket.data,
-        this.getPacketType(suppliedPacket.data),
+        packetType,
         suppliedPacket.pts / TIMESCALE,
         Math.max(duration / TIMESCALE, 0),
         suppliedPacket.sequenceNumber,
         suppliedPacket.data.byteLength
       );
     }
-    maybeInsertReferencePacket(pesPacketHeader, force, dropIfMutexLocked) {
-      if (dropIfMutexLocked && this.mutex.pending > 0) {
-        return;
-      }
-      const index = binarySearchLessOrEqual(this.referencePesPackets, pesPacketHeader.pts, (x) => x.pts);
+    maybeInsertReferencePacket(pesPacketHeader) {
+      const index = binarySearchLessOrEqual(
+        this.referencePesPackets,
+        pesPacketHeader.sectionStartPos,
+        (x) => x.sectionStartPos
+      );
       if (index >= 0) {
         const entry = this.referencePesPackets[index];
-        if (pesPacketHeader.sectionStartPos <= entry.sectionStartPos) {
+        if (pesPacketHeader.pts <= entry.pts) {
           return false;
         }
-        if (!force && pesPacketHeader.pts - entry.pts < TIMESCALE / 2) {
+        const minByteDistance = this.elementaryStream.demuxer.minReferencePointByteDistance;
+        if (pesPacketHeader.sectionStartPos - entry.sectionStartPos < minByteDistance) {
           return false;
         }
         if (index < this.referencePesPackets.length - 1) {
           const nextEntry = this.referencePesPackets[index + 1];
-          if (nextEntry.sectionStartPos < pesPacketHeader.sectionStartPos) {
+          if (nextEntry.pts < pesPacketHeader.pts) {
             return false;
           }
-          if (!force && nextEntry.pts - pesPacketHeader.pts < TIMESCALE / 2) {
+          if (nextEntry.sectionStartPos - pesPacketHeader.sectionStartPos < minByteDistance) {
             return false;
           }
         }
@@ -16383,168 +16499,105 @@ var Mediabunny = (() => {
     }
     /**
      * Searches for the packet with the largest timestamp not larger than `timestamp` in the file, using a combination
-     * of binary search and linear refinement.
+     * of chunk-based binary search and linear refinement. The reason the coarse search is done in large chunks is to
+     * make it more performant for small files and over high-latency readers such as the network.
      */
     async doPacketLookup(timestamp, keyframesOnly, options) {
       const searchPts = roundIfAlmostInteger(timestamp * TIMESCALE);
       const demuxer = this.elementaryStream.demuxer;
-      const reader = demuxer.reader;
-      const release = await this.mutex.acquire();
-      let currentPesPacketHeader;
-      try {
-        if (this.referencePesPackets.length === 0) {
-          const section2 = this.elementaryStream.firstSection;
-          assert(section2);
-          const pesPacketHeader = readPesPacketHeader(section2);
-          assert(pesPacketHeader);
-          this.maybeInsertReferencePacket(pesPacketHeader, false, false);
-          assert(this.referencePesPackets.length === 1);
-        }
-        let currentIndex = binarySearchLessOrEqual(this.referencePesPackets, searchPts, (x) => x.pts);
-        if (currentIndex === -1) {
-          return null;
-        }
-        const needsToLookForLastPacket = reader.fileSize !== null && currentIndex === this.referencePesPackets.length - 1 && !this.endReferencePesPacketAdded;
-        if (needsToLookForLastPacket) {
-          let currentPos = reader.fileSize - demuxer.packetStride + demuxer.packetOffset;
-          let packetHeader = await demuxer.readPacketHeader(currentPos);
+      const { reader, seekChunkSize } = demuxer;
+      const pid = this.elementaryStream.pid;
+      const findFirstPesPacketHeaderInChunk = async (startPos, endPos) => {
+        let currentPos = startPos;
+        while (currentPos < endPos) {
+          const packetHeader = await demuxer.readPacketHeader(currentPos);
           if (!packetHeader) {
             return null;
           }
-          while (packetHeader.pid !== this.elementaryStream.pid || packetHeader.payloadUnitStartIndicator === 0) {
-            currentPos -= demuxer.packetStride;
-            const previousPacketHeader = await demuxer.readPacketHeader(currentPos);
-            if (!previousPacketHeader) {
-              return null;
-            }
-            packetHeader = previousPacketHeader;
-          }
-          const section2 = await demuxer.readSection(currentPos, false);
-          assert(section2);
-          const pesPacketHeader = readPesPacketHeader(section2);
-          if (!pesPacketHeader) {
-            throw new Error(MISSING_PES_PACKET_ERROR);
-          }
-          this.maybeInsertReferencePacket(pesPacketHeader, true, false);
-          this.endReferencePesPacketAdded = true;
-        }
-        currentIndex = binarySearchLessOrEqual(this.referencePesPackets, searchPts, (x) => x.pts);
-        assert(currentIndex !== -1);
-        while (reader.fileSize !== null) {
-          const currentEntry = this.referencePesPackets[currentIndex];
-          const nextEntry = this.referencePesPackets[currentIndex + 1];
-          if (searchPts - currentEntry.pts < TIMESCALE || !nextEntry) {
-            break;
-          }
-          const midpoint = roundToMultiple(
-            (currentEntry.sectionStartPos + nextEntry.sectionStartPos) / 2,
-            demuxer.packetStride
-          ) + demuxer.packetOffset;
-          let currentPos = midpoint;
-          let packetHeader = await demuxer.readPacketHeader(currentPos);
-          assert(packetHeader);
-          while (currentPos < nextEntry.sectionStartPos && (packetHeader.pid !== this.elementaryStream.pid || packetHeader.payloadUnitStartIndicator === 0)) {
-            currentPos += demuxer.packetStride;
-            const previousPacketHeader = await demuxer.readPacketHeader(currentPos);
-            if (!previousPacketHeader) {
+          if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
+            const section = await demuxer.readSection(currentPos, false);
+            if (!section) {
               return null;
             }
-            packetHeader = previousPacketHeader;
-          }
-          if (currentPos >= nextEntry.sectionStartPos) {
-            break;
-          }
-          const section2 = await demuxer.readSection(currentPos, false);
-          assert(section2);
-          const pesPacketHeader = readPesPacketHeader(section2);
-          if (!pesPacketHeader) {
-            throw new Error(MISSING_PES_PACKET_ERROR);
-          }
-          const addedPoint = this.maybeInsertReferencePacket(pesPacketHeader, false, false);
-          if (!addedPoint) {
-            break;
-          }
-          if (pesPacketHeader.pts <= searchPts) {
-            currentIndex++;
+            const pesPacketHeader = readPesPacketHeader(section);
+            return pesPacketHeader;
           }
+          currentPos += demuxer.packetStride;
         }
-        currentPesPacketHeader = this.referencePesPackets[currentIndex];
-        assert(currentPesPacketHeader.pts <= searchPts);
-      } finally {
-        release();
+        return null;
+      };
+      const firstSection = this.elementaryStream.firstSection;
+      assert(firstSection);
+      const firstPesPacketHeader = readPesPacketHeader(firstSection);
+      assert(firstPesPacketHeader);
+      if (searchPts < firstPesPacketHeader.pts) {
+        return null;
       }
-      release();
-      outer:
-        while (true) {
-          let currentPos = currentPesPacketHeader.sectionStartPos + demuxer.packetStride;
-          while (true) {
-            const packetHeader = await demuxer.readPacketHeader(currentPos);
-            if (!packetHeader) {
-              break outer;
-            }
-            if (packetHeader.pid === this.elementaryStream.pid && packetHeader.payloadUnitStartIndicator === 1) {
-              break;
+      let scanStartPos;
+      const referencePointIndex = binarySearchLessOrEqual(this.referencePesPackets, searchPts, (x) => x.pts);
+      const referencePoint = referencePointIndex !== -1 ? this.referencePesPackets[referencePointIndex] : null;
+      if (referencePoint && searchPts - referencePoint.pts < TIMESCALE / 2) {
+        scanStartPos = referencePoint.sectionStartPos;
+      } else {
+        let startChunkIndex = 0;
+        if (reader.fileSize !== null) {
+          const numChunks = Math.ceil(reader.fileSize / seekChunkSize);
+          if (numChunks > 1) {
+            let low = 0;
+            let high = numChunks - 1;
+            startChunkIndex = low;
+            while (low <= high) {
+              const mid = Math.floor((low + high) / 2);
+              const chunkStartPos = floorToMultiple(mid * seekChunkSize, demuxer.packetStride) + firstPesPacketHeader.sectionStartPos;
+              const chunkEndPos = chunkStartPos + seekChunkSize;
+              const pesHeader = await findFirstPesPacketHeaderInChunk(chunkStartPos, chunkEndPos);
+              if (!pesHeader) {
+                high = mid - 1;
+                continue;
+              }
+              if (pesHeader.pts <= searchPts) {
+                startChunkIndex = mid;
+                low = mid + 1;
+              } else {
+                high = mid - 1;
+              }
             }
-            currentPos += demuxer.packetStride;
-          }
-          const nextSection = await demuxer.readSection(currentPos, false);
-          if (!nextSection) {
-            break;
-          }
-          const nextPesPacketHeader = readPesPacketHeader(nextSection);
-          if (!nextPesPacketHeader) {
-            throw new Error(MISSING_PES_PACKET_ERROR);
-          }
-          if (nextPesPacketHeader.pts > searchPts) {
-            break;
-          }
-          currentPesPacketHeader = nextPesPacketHeader;
-          if (reader.fileSize === null) {
-            this.maybeInsertReferencePacket(nextPesPacketHeader, false, true);
           }
         }
+        scanStartPos = floorToMultiple(
+          startChunkIndex * seekChunkSize,
+          demuxer.packetStride
+        ) + firstPesPacketHeader.sectionStartPos;
+      }
+      let currentPesHeader = await findFirstPesPacketHeaderInChunk(
+        scanStartPos,
+        reader.fileSize ?? Infinity
+      );
+      if (!currentPesHeader) {
+        currentPesHeader = firstPesPacketHeader;
+      }
       const reorderSize = this.getReorderSize();
-      for (let i = 0; i < reorderSize; i++) {
-        let pos = currentPesPacketHeader.sectionStartPos - demuxer.packetStride;
+      const retrieveEncodedPacket = async (sectionStartPos, predicate) => {
+        const section = await demuxer.readSection(sectionStartPos, true);
+        assert(section);
+        const pesPacket = readPesPacket(section);
+        assert(pesPacket);
+        const context = new PacketReadingContext(this, pesPacket, true);
+        const buffer = new PacketBuffer(this, context);
         while (true) {
-          const packetHeader = await demuxer.readPacketHeader(pos);
-          if (!packetHeader) {
+          const topPts = last(buffer.presentationOrderPackets)?.pts ?? -Infinity;
+          if (topPts >= searchPts) {
             break;
           }
-          if (packetHeader.pid === this.elementaryStream.pid && packetHeader.payloadUnitStartIndicator === 1) {
-            const headerSection = await demuxer.readSection(pos, false);
-            assert(headerSection);
-            const header = readPesPacketHeader(headerSection);
-            if (!header) {
-              throw new Error(MISSING_PES_PACKET_ERROR);
-            }
-            currentPesPacketHeader = header;
+          const didRead = await buffer.readNextPacket();
+          if (!didRead) {
             break;
           }
-          pos -= demuxer.packetStride;
-        }
-      }
-      const section = await demuxer.readSection(currentPesPacketHeader.sectionStartPos, true);
-      assert(section);
-      const pesPacket = readPesPacket(section);
-      assert(pesPacket);
-      const context = new PacketReadingContext(this, pesPacket, true);
-      const buffer = new PacketBuffer(this, context);
-      while (true) {
-        const topPts = last(buffer.presentationOrderPackets)?.pts ?? -Infinity;
-        if (topPts >= searchPts) {
-          break;
         }
-        const didRead = await buffer.readNextDecodeOrderPacket();
-        if (!didRead) {
-          break;
+        const targetIndex = findLastIndex(buffer.presentationOrderPackets, predicate);
+        if (targetIndex === -1) {
+          return null;
         }
-      }
-      const targetIndex = findLastIndex(
-        buffer.presentationOrderPackets,
-        (p) => p.pts <= searchPts && (!keyframesOnly || this.getPacketType(p.data) === "key")
-      );
-      if (targetIndex !== -1) {
         const targetPacket = buffer.presentationOrderPackets[targetIndex];
         const lastDuration = targetIndex === 0 ? 0 : targetPacket.pts - buffer.presentationOrderPackets[targetIndex - 1].pts;
         while (buffer.decodeOrderPackets[0] !== targetPacket) {
@@ -16557,42 +16610,156 @@ var Mediabunny = (() => {
         this.packetBuffers.set(packet, buffer);
         this.packetSectionStarts.set(packet, result.packet.sectionStartPos);
         return packet;
-      }
-      if (!keyframesOnly) {
-        return null;
-      }
-      let searchPos = currentPesPacketHeader.sectionStartPos;
-      while (true) {
-        searchPos -= demuxer.packetStride;
-        const packetHeader = await demuxer.readPacketHeader(searchPos);
-        if (!packetHeader) {
-          return null;
-        }
-        if (packetHeader.pid !== this.elementaryStream.pid || packetHeader.payloadUnitStartIndicator !== 1) {
-          continue;
-        }
-        const section2 = await demuxer.readSection(searchPos, true);
-        assert(section2);
-        const pesPacket2 = readPesPacket(section2);
-        if (!pesPacket2) {
-          throw new Error(MISSING_PES_PACKET_ERROR);
-        }
-        const context2 = new PacketReadingContext(this, pesPacket2, false);
-        await this.markNextPacket(context2);
-        if (!context2.suppliedPacket) {
-          continue;
-        }
-        if (this.getPacketType(context2.suppliedPacket.data) !== "key") {
-          continue;
+      };
+      if (!keyframesOnly || this.allPacketsAreKeyPackets()) {
+        outer:
+          while (true) {
+            let currentPos = currentPesHeader.sectionStartPos + demuxer.packetStride;
+            while (true) {
+              const packetHeader = await demuxer.readPacketHeader(currentPos);
+              if (!packetHeader) {
+                break outer;
+              }
+              if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
+                const section = await demuxer.readSection(currentPos, false);
+                if (section) {
+                  const nextPesHeader = readPesPacketHeader(section);
+                  if (!nextPesHeader) {
+                    throw new Error(MISSING_PES_PACKET_ERROR);
+                  }
+                  if (nextPesHeader.pts > searchPts) {
+                    break outer;
+                  }
+                  currentPesHeader = nextPesHeader;
+                  this.maybeInsertReferencePacket(nextPesHeader);
+                  break;
+                }
+              }
+              currentPos += demuxer.packetStride;
+            }
+          }
+        outer:
+          for (let i = 0; i < reorderSize; i++) {
+            let pos = currentPesHeader.sectionStartPos - demuxer.packetStride;
+            while (pos >= demuxer.packetOffset) {
+              const packetHeader = await demuxer.readPacketHeader(pos);
+              if (!packetHeader) {
+                break outer;
+              }
+              if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
+                const section = await demuxer.readSection(pos, false);
+                if (section) {
+                  const header = readPesPacketHeader(section);
+                  if (!header) {
+                    throw new Error(MISSING_PES_PACKET_ERROR);
+                  }
+                  currentPesHeader = header;
+                  break;
+                }
+              }
+              pos -= demuxer.packetStride;
+            }
+          }
+        return retrieveEncodedPacket(currentPesHeader.sectionStartPos, (p) => p.pts <= searchPts);
+      } else {
+        let currentChunkStartPos = scanStartPos;
+        let nextChunkStartPos = null;
+        while (true) {
+          let bestKeyPesHeader = null;
+          const isFirstChunk = currentChunkStartPos <= firstPesPacketHeader.sectionStartPos;
+          let pesHeader;
+          if (isFirstChunk) {
+            pesHeader = firstPesPacketHeader;
+            bestKeyPesHeader = firstPesPacketHeader;
+          } else {
+            pesHeader = await findFirstPesPacketHeaderInChunk(
+              currentChunkStartPos,
+              reader.fileSize ?? Infinity
+            );
+          }
+          let passedSearchPts = false;
+          let lookaheadCount = 0;
+          outer:
+            while (pesHeader) {
+              if (nextChunkStartPos !== null && pesHeader.sectionStartPos >= nextChunkStartPos) {
+                break;
+              }
+              const isKeyCandidate = pesHeader.randomAccessIndicator === 1;
+              if (isKeyCandidate && pesHeader.pts <= searchPts) {
+                bestKeyPesHeader = pesHeader;
+              }
+              if (pesHeader.pts > searchPts) {
+                passedSearchPts = true;
+              }
+              if (passedSearchPts) {
+                lookaheadCount++;
+                if (lookaheadCount >= reorderSize) {
+                  break;
+                }
+              }
+              let currentPos = pesHeader.sectionStartPos + demuxer.packetStride;
+              while (true) {
+                const packetHeader = await demuxer.readPacketHeader(currentPos);
+                if (!packetHeader) {
+                  break outer;
+                }
+                if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
+                  const section = await demuxer.readSection(currentPos, false);
+                  if (section) {
+                    pesHeader = readPesPacketHeader(section);
+                    if (!pesHeader) {
+                      throw new Error(MISSING_PES_PACKET_ERROR);
+                    }
+                    this.maybeInsertReferencePacket(pesHeader);
+                    break;
+                  }
+                }
+                currentPos += demuxer.packetStride;
+              }
+            }
+          if (bestKeyPesHeader) {
+            let startPesHeader = bestKeyPesHeader;
+            if (lookaheadCount === 0) {
+              outer:
+                for (let i = 0; i < reorderSize - 1; i++) {
+                  let pos = startPesHeader.sectionStartPos - demuxer.packetStride;
+                  while (pos >= demuxer.packetOffset) {
+                    const packetHeader = await demuxer.readPacketHeader(pos);
+                    if (!packetHeader) {
+                      break outer;
+                    }
+                    if (packetHeader.pid === pid && packetHeader.payloadUnitStartIndicator === 1) {
+                      const section = await demuxer.readSection(pos, false);
+                      if (section) {
+                        const header = readPesPacketHeader(section);
+                        if (!header) {
+                          throw new Error(MISSING_PES_PACKET_ERROR);
+                        }
+                        startPesHeader = header;
+                        break;
+                      }
+                    }
+                    pos -= demuxer.packetStride;
+                  }
+                }
+            }
+            const encodedPacket = await retrieveEncodedPacket(
+              startPesHeader.sectionStartPos,
+              (p) => p.pts <= searchPts && p.randomAccessIndicator === 1
+            );
+            assert(encodedPacket);
+            return encodedPacket;
+          }
+          assert(!isFirstChunk);
+          nextChunkStartPos = currentChunkStartPos;
+          currentChunkStartPos = Math.max(
+            floorToMultiple(
+              currentChunkStartPos - firstPesPacketHeader.sectionStartPos - seekChunkSize,
+              demuxer.packetStride
+            ) + firstPesPacketHeader.sectionStartPos,
+            firstPesPacketHeader.sectionStartPos
+          );
         }
-        context2.uncapped = true;
-        const buffer2 = new PacketBuffer(this, context2);
-        const result = await buffer2.readNext();
-        assert(result);
-        const packet = this.createEncodedPacket(result.packet, result.duration, options);
-        this.packetBuffers.set(packet, buffer2);
-        this.packetSectionStarts.set(packet, result.packet.sectionStartPos);
-        return packet;
       }
     }
   };
@@ -16639,8 +16806,8 @@ var Mediabunny = (() => {
     async getDecoderConfig() {
       return this.decoderConfig;
     }
-    getPacketType(packetData) {
-      return determineVideoPacketType(this.elementaryStream.info.codec, this.decoderConfig, packetData) ?? "key";
+    allPacketsAreKeyPackets() {
+      return false;
     }
     getReorderSize() {
       return this.elementaryStream.info.reorderSize;
@@ -16649,6 +16816,9 @@ var Mediabunny = (() => {
       assert(!context.suppliedPacket);
       const codec = this.elementaryStream.info.codec;
       const CHUNK_SIZE = 1024;
+      if (codec !== "avc" && codec !== "hevc") {
+        throw new Error("Unhandled.");
+      }
       let packetStartPos = null;
       while (true) {
         let remaining = context.ensureBuffered(CHUNK_SIZE);
@@ -16740,9 +16910,8 @@ var Mediabunny = (() => {
         sampleRate: this.elementaryStream.info.sampleRate
       };
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getPacketType(packetData) {
-      return "key";
+    allPacketsAreKeyPackets() {
+      return true;
     }
     getReorderSize() {
       return 1;
@@ -16805,7 +16974,7 @@ var Mediabunny = (() => {
               context.seekTo(possibleHeaderStartPos + 1);
             }
           } else {
-            throw new Error("Unreachable");
+            throw new Error("Unhandled.");
           }
         }
         if (remaining < CHUNK_SIZE) {
@@ -16963,17 +17132,23 @@ var Mediabunny = (() => {
         this.suppliedPacket = null;
         return;
       }
-      this.backing.maybeInsertReferencePacket(currentPesPacket, false, true);
+      this.backing.maybeInsertReferencePacket(currentPesPacket);
       const pts = this.nextPts;
       this.nextPts += intrinsicDuration;
       const sectionStartPos = currentPesPacket.sectionStartPos;
       const sequenceNumber = sectionStartPos + (this.currentPos - this.currentPesPacketPos);
       const data = this.readBytes(packetLength);
+      let randomAccessIndicator = currentPesPacket.randomAccessIndicator;
+      assert(this.backing.elementaryStream.firstSection);
+      if (currentPesPacket.sectionStartPos === this.backing.elementaryStream.firstSection.startPos) {
+        randomAccessIndicator = 1;
+      }
       this.suppliedPacket = {
         pts,
         data,
         sequenceNumber,
-        sectionStartPos
+        sectionStartPos,
+        randomAccessIndicator
       };
       this.pesPackets.splice(0, this.currentPesPacketIndex);
       this.currentPesPacketIndex = 0;
@@ -16993,7 +17168,7 @@ var Mediabunny = (() => {
     }
     async readNext() {
       if (this.decodeOrderPackets.length === 0) {
-        const didRead = await this.readNextDecodeOrderPacket();
+        const didRead = await this.readNextPacket();
         if (!didRead) {
           return null;
         }
@@ -17020,7 +17195,7 @@ var Mediabunny = (() => {
       }
       return { packet, duration };
     }
-    async readNextDecodeOrderPacket() {
+    async readNextPacket() {
       if (this.reachedEnd) {
         return false;
       }
@@ -17049,7 +17224,7 @@ var Mediabunny = (() => {
         if (presentationIndex !== -1 && presentationIndex <= this.presentationOrderPackets.length - 2) {
           break;
         }
-        const didRead = await this.readNextDecodeOrderPacket();
+        const didRead = await this.readNextPacket();
         if (!didRead) {
           break;
         }
@@ -17589,7 +17764,12 @@ var Mediabunny = (() => {
     return Math.min(2 ** (previousAttempts - 2), 16);
   };
   var UrlSource = class extends Source {
-    /** Creates a new {@link UrlSource} backed by the resource at the specified URL. */
+    /**
+     * Creates a new {@link UrlSource} backed by the resource at the specified URL.
+     *
+     * When passing a `Request` instance, note that the `signal` and `headers.Range` options will be overridden by
+     * Mediabunny. If you want to cancel ongoing requests, use {@link Input.dispose}.
+     */
     constructor(url2, options = {}) {
       if (typeof url2 !== "string" && !(url2 instanceof URL) && !(typeof Request !== "undefined" && url2 instanceof Request)) {
         throw new TypeError("url must be a string, URL or Request.");
@@ -28288,6 +28468,15 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       return this.finalizeCurrentBuffer();
     }
   };
+
+  // src/index.ts
+  var MEDIABUNNY_LOADED_SYMBOL = Symbol.for("mediabunny loaded");
+  if (globalThis[MEDIABUNNY_LOADED_SYMBOL]) {
+    console.error(
+      "[WARNING]\nMediabunny was loaded twice. This will likely cause Mediabunny not to work correctly. Check if multiple dependencies are importing different versions of Mediabunny, or if something is being bundled incorrectly."
+    );
+  }
+  globalThis[MEDIABUNNY_LOADED_SYMBOL] = true;
   return __toCommonJS(index_exports);
 })();
 if (typeof module === "object" && typeof module.exports === "object") Object.assign(module.exports, Mediabunny)