mediabunny 1.30.0 → 1.30.1

package/dist/bundles/mediabunny.cjs

@@ -1967,9 +1967,6 @@ var Mediabunny = (() => {
       return iterateNalUnitsInAnnexB(packetData);
     }
   };
-  var iterateAvcNalUnitsAnnexB = function* (packetData) {
-    yield* iterateNalUnitsInAnnexB(packetData);
-  };
   var extractNalUnitTypeForAvc = (byte) => {
     return byte & 31;
   };
@@ -2040,7 +2037,7 @@ var Mediabunny = (() => {
       const spsUnits = [];
       const ppsUnits = [];
       const spsExtUnits = [];
-      for (const loc of iterateAvcNalUnitsAnnexB(packetData)) {
+      for (const loc of iterateNalUnitsInAnnexB(packetData)) {
         const nalUnit = packetData.subarray(loc.offset, loc.offset + loc.length);
         const type = extractNalUnitTypeForAvc(nalUnit[0]);
         if (type === 7 /* SPS */) {
@@ -2412,9 +2409,6 @@ var Mediabunny = (() => {
       return iterateNalUnitsInAnnexB(packetData);
     }
   };
-  var iterateHevcNalUnitsAnnexB = function* (packetData) {
-    yield* iterateNalUnitsInAnnexB(packetData);
-  };
   var extractNalUnitTypeForHevc = (byte) => {
     return byte >> 1 & 63;
   };
@@ -2548,7 +2542,7 @@ var Mediabunny = (() => {
       const spsUnits = [];
       const ppsUnits = [];
       const seiUnits = [];
-      for (const loc of iterateHevcNalUnitsAnnexB(packetData)) {
+      for (const loc of iterateNalUnitsInAnnexB(packetData)) {
         const nalUnit = packetData.subarray(loc.offset, loc.offset + loc.length);
         const type = extractNalUnitTypeForHevc(nalUnit[0]);
         if (type === 32 /* VPS_NUT */) {
@@ -15883,6 +15877,14 @@ var Mediabunny = (() => {
         let hasProgramAssociationTable = false;
         let hasProgramMap = false;
         while (true) {
+          const packetHeader = await this.readPacketHeader(currentPos);
+          if (!packetHeader) {
+            break;
+          }
+          if (packetHeader.payloadUnitStartIndicator === 0) {
+            currentPos += this.packetStride;
+            continue;
+          }
           const section = await this.readSection(
             currentPos,
             true,
@@ -15983,7 +15985,8 @@ var Mediabunny = (() => {
                   streamType,
                   initialized: false,
                   firstSection: null,
-                  info
+                  info,
+                  referencePesPackets: []
                 });
               }
             }
@@ -16082,8 +16085,13 @@ var Mediabunny = (() => {
           if (isDone) {
             break;
           }
-          assert(section.endPos !== null);
-          currentPos = section.endPos;
+          currentPos += this.packetStride;
+        }
+        if (!hasProgramAssociationTable) {
+          throw new Error("No Program Association Table found in the file.");
+        }
+        if (!hasProgramMap) {
+          throw new Error("No Program Map Table found in the file.");
         }
         for (const stream of this.elementaryStreams) {
           if (stream.info.type === "video") {
@@ -16327,12 +16335,6 @@ var Mediabunny = (() => {
   var MpegTsTrackBacking = class _MpegTsTrackBacking {
     constructor(elementaryStream) {
       this.elementaryStream = elementaryStream;
-      /**
-       * 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();
@@ -16397,40 +16399,12 @@ var Mediabunny = (() => {
         suppliedPacket.data.byteLength
       );
     }
-    maybeInsertReferencePacket(pesPacketHeader) {
-      const index = binarySearchLessOrEqual(
-        this.referencePesPackets,
-        pesPacketHeader.sectionStartPos,
-        (x) => x.sectionStartPos
-      );
-      if (index >= 0) {
-        const entry = this.referencePesPackets[index];
-        if (pesPacketHeader.pts <= entry.pts) {
-          return false;
-        }
-        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.pts < pesPacketHeader.pts) {
-            return false;
-          }
-          if (nextEntry.sectionStartPos - pesPacketHeader.sectionStartPos < minByteDistance) {
-            return false;
-          }
-        }
-      }
-      this.referencePesPackets.splice(index + 1, 0, pesPacketHeader);
-      return true;
-    }
     async getFirstPacket(options) {
       const section = this.elementaryStream.firstSection;
       assert(section);
       const pesPacket = readPesPacket(section);
       assert(pesPacket);
-      const context = new PacketReadingContext(this, pesPacket, true);
+      const context = new PacketReadingContext(this.elementaryStream, pesPacket);
       const buffer = new PacketBuffer(this, context);
       const result = await buffer.readNext();
       if (!result) {
@@ -16463,7 +16437,7 @@ var Mediabunny = (() => {
       assert(section);
       const pesPacket = readPesPacket(section);
       assert(pesPacket);
-      const context = new PacketReadingContext(this, pesPacket, true);
+      const context = new PacketReadingContext(this.elementaryStream, pesPacket);
       buffer = new PacketBuffer(this, context);
       const targetSequenceNumber = packet.sequenceNumber;
       while (true) {
@@ -16534,8 +16508,9 @@ var Mediabunny = (() => {
         return null;
       }
       let scanStartPos;
-      const referencePointIndex = binarySearchLessOrEqual(this.referencePesPackets, searchPts, (x) => x.pts);
-      const referencePoint = referencePointIndex !== -1 ? this.referencePesPackets[referencePointIndex] : null;
+      const referencePesPackets = this.elementaryStream.referencePesPackets;
+      const referencePointIndex = binarySearchLessOrEqual(referencePesPackets, searchPts, (x) => x.pts);
+      const referencePoint = referencePointIndex !== -1 ? referencePesPackets[referencePointIndex] : null;
       if (referencePoint && searchPts - referencePoint.pts < TIMESCALE / 2) {
         scanStartPos = referencePoint.sectionStartPos;
       } else {
@@ -16582,7 +16557,7 @@ var Mediabunny = (() => {
         assert(section);
         const pesPacket = readPesPacket(section);
         assert(pesPacket);
-        const context = new PacketReadingContext(this, pesPacket, true);
+        const context = new PacketReadingContext(this.elementaryStream, pesPacket);
         const buffer = new PacketBuffer(this, context);
         while (true) {
           const topPts = last(buffer.presentationOrderPackets)?.pts ?? -Infinity;
@@ -16631,7 +16606,7 @@ var Mediabunny = (() => {
                     break outer;
                   }
                   currentPesHeader = nextPesHeader;
-                  this.maybeInsertReferencePacket(nextPesHeader);
+                  maybeInsertReferencePacket(this.elementaryStream, nextPesHeader);
                   break;
                 }
               }
@@ -16710,7 +16685,7 @@ var Mediabunny = (() => {
                     if (!pesHeader) {
                       throw new Error(MISSING_PES_PACKET_ERROR);
                     }
-                    this.maybeInsertReferencePacket(pesHeader);
+                    maybeInsertReferencePacket(this.elementaryStream, pesHeader);
                     break;
                   }
                 }
@@ -16812,9 +16787,73 @@ var Mediabunny = (() => {
     getReorderSize() {
       return this.elementaryStream.info.reorderSize;
     }
-    async markNextPacket(context) {
-      assert(!context.suppliedPacket);
-      const codec = this.elementaryStream.info.codec;
+  };
+  var MpegTsAudioTrackBacking = class extends MpegTsTrackBacking {
+    constructor(elementaryStream) {
+      super(elementaryStream);
+      this.elementaryStream = elementaryStream;
+    }
+    getCodec() {
+      return this.elementaryStream.info.codec;
+    }
+    getNumberOfChannels() {
+      return this.elementaryStream.info.numberOfChannels;
+    }
+    getSampleRate() {
+      return this.elementaryStream.info.sampleRate;
+    }
+    async getDecoderConfig() {
+      return {
+        codec: extractAudioCodecString({
+          codec: this.elementaryStream.info.codec,
+          codecDescription: null,
+          aacCodecInfo: this.elementaryStream.info.aacCodecInfo
+        }),
+        numberOfChannels: this.elementaryStream.info.numberOfChannels,
+        sampleRate: this.elementaryStream.info.sampleRate
+      };
+    }
+    allPacketsAreKeyPackets() {
+      return true;
+    }
+    getReorderSize() {
+      return 1;
+    }
+  };
+  var maybeInsertReferencePacket = (elementaryStream, pesPacketHeader) => {
+    const referencePesPackets = elementaryStream.referencePesPackets;
+    const index = binarySearchLessOrEqual(
+      referencePesPackets,
+      pesPacketHeader.sectionStartPos,
+      (x) => x.sectionStartPos
+    );
+    if (index >= 0) {
+      const entry = referencePesPackets[index];
+      if (pesPacketHeader.pts <= entry.pts) {
+        return false;
+      }
+      const minByteDistance = elementaryStream.demuxer.minReferencePointByteDistance;
+      if (pesPacketHeader.sectionStartPos - entry.sectionStartPos < minByteDistance) {
+        return false;
+      }
+      if (index < referencePesPackets.length - 1) {
+        const nextEntry = referencePesPackets[index + 1];
+        if (nextEntry.pts < pesPacketHeader.pts) {
+          return false;
+        }
+        if (nextEntry.sectionStartPos - pesPacketHeader.sectionStartPos < minByteDistance) {
+          return false;
+        }
+      }
+    }
+    referencePesPackets.splice(index + 1, 0, pesPacketHeader);
+    return true;
+  };
+  var markNextPacket = async (context) => {
+    assert(!context.suppliedPacket);
+    const elementaryStream = context.elementaryStream;
+    if (elementaryStream.info.type === "video") {
+      const codec = elementaryStream.info.codec;
       const CHUNK_SIZE = 1024;
       if (codec !== "avc" && codec !== "hevc") {
         throw new Error("Unhandled.");
@@ -16883,42 +16922,8 @@ var Mediabunny = (() => {
         context.seekTo(packetStartPos);
         return context.supplyPacket(packetLength, 0);
       }
-    }
-  };
-  var MpegTsAudioTrackBacking = class extends MpegTsTrackBacking {
-    constructor(elementaryStream) {
-      super(elementaryStream);
-      this.elementaryStream = elementaryStream;
-    }
-    getCodec() {
-      return this.elementaryStream.info.codec;
-    }
-    getNumberOfChannels() {
-      return this.elementaryStream.info.numberOfChannels;
-    }
-    getSampleRate() {
-      return this.elementaryStream.info.sampleRate;
-    }
-    async getDecoderConfig() {
-      return {
-        codec: extractAudioCodecString({
-          codec: this.elementaryStream.info.codec,
-          codecDescription: null,
-          aacCodecInfo: this.elementaryStream.info.aacCodecInfo
-        }),
-        numberOfChannels: this.elementaryStream.info.numberOfChannels,
-        sampleRate: this.elementaryStream.info.sampleRate
-      };
-    }
-    allPacketsAreKeyPackets() {
-      return true;
-    }
-    getReorderSize() {
-      return 1;
-    }
-    async markNextPacket(context) {
-      assert(!context.suppliedPacket);
-      const codec = this.elementaryStream.info.codec;
+    } else {
+      const codec = elementaryStream.info.codec;
       const CHUNK_SIZE = 128;
       while (true) {
         let remaining = context.ensureBuffered(CHUNK_SIZE);
@@ -16945,7 +16950,7 @@ var Mediabunny = (() => {
               if (remaining3 instanceof Promise) remaining3 = await remaining3;
               return context.supplyPacket(
                 remaining3,
-                Math.round(SAMPLES_PER_AAC_FRAME * TIMESCALE / this.elementaryStream.info.sampleRate)
+                Math.round(SAMPLES_PER_AAC_FRAME * TIMESCALE / elementaryStream.info.sampleRate)
               );
             } else {
               context.seekTo(possibleHeaderStartPos + 1);
@@ -16968,7 +16973,7 @@ var Mediabunny = (() => {
               context.seekTo(possibleHeaderStartPos);
               let remaining3 = context.ensureBuffered(result.header.totalSize);
               if (remaining3 instanceof Promise) remaining3 = await remaining3;
-              const duration = result.header.audioSamplesInFrame * TIMESCALE / this.elementaryStream.info.sampleRate;
+              const duration = result.header.audioSamplesInFrame * TIMESCALE / elementaryStream.info.sampleRate;
               return context.supplyPacket(remaining3, Math.round(duration));
             } else {
               context.seekTo(possibleHeaderStartPos + 1);
@@ -16984,7 +16989,7 @@ var Mediabunny = (() => {
     }
   };
   var PacketReadingContext = class _PacketReadingContext {
-    constructor(backing, startingPesPacket, uncapped) {
+    constructor(elementaryStream, startingPesPacket) {
       this.currentPos = 0;
       // Relative to the data in startingPesPacket
       this.pesPackets = [];
@@ -16993,14 +16998,13 @@ var Mediabunny = (() => {
       this.endPos = 0;
       this.nextPts = 0;
       this.suppliedPacket = null;
-      this.backing = backing;
-      this.pid = backing.elementaryStream.pid;
-      this.demuxer = backing.elementaryStream.demuxer;
+      this.elementaryStream = elementaryStream;
+      this.pid = elementaryStream.pid;
+      this.demuxer = elementaryStream.demuxer;
       this.startingPesPacket = startingPesPacket;
-      this.uncapped = uncapped;
     }
     clone() {
-      const clone = new _PacketReadingContext(this.backing, this.startingPesPacket, true);
+      const clone = new _PacketReadingContext(this.elementaryStream, this.startingPesPacket);
       clone.currentPos = this.currentPos;
       clone.pesPackets = [...this.pesPackets];
       clone.currentPesPacketIndex = this.currentPesPacketIndex;
@@ -17128,19 +17132,15 @@ var Mediabunny = (() => {
     /** Supplies the context with a new encoded packet, beginning at the current position. */
     supplyPacket(packetLength, intrinsicDuration) {
       const currentPesPacket = this.getCurrentPesPacket();
-      if (!this.uncapped && currentPesPacket !== this.startingPesPacket) {
-        this.suppliedPacket = null;
-        return;
-      }
-      this.backing.maybeInsertReferencePacket(currentPesPacket);
+      maybeInsertReferencePacket(this.elementaryStream, 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) {
+      assert(this.elementaryStream.firstSection);
+      if (currentPesPacket.sectionStartPos === this.elementaryStream.firstSection.startPos) {
         randomAccessIndicator = 1;
       }
       this.suppliedPacket = {
@@ -17203,7 +17203,7 @@ var Mediabunny = (() => {
       if (this.context.suppliedPacket) {
         suppliedPacket = this.context.suppliedPacket;
       } else {
-        await this.backing.markNextPacket(this.context);
+        await markNextPacket(this.context);
         suppliedPacket = this.context.suppliedPacket;
       }
       this.context.suppliedPacket = null;