mediabunny 1.4.3 → 1.4.4

package/dist/bundles/mediabunny.cjs

@@ -13571,199 +13571,195 @@ ${cue.notes ?? ""}`;
       return firstPacket?.timestamp ?? 0;
     }
     async getFirstPacket(options) {
-      if (this.internalTrack.demuxer.isFragmented) {
-        return this.performFragmentedLookup(
-          () => {
-            const startFragment = this.internalTrack.demuxer.fragments[0] ?? null;
-            if (startFragment?.isKnownToBeFirstFragment) {
-              let currentFragment = startFragment;
-              while (currentFragment) {
-                const trackData = currentFragment.trackData.get(this.internalTrack.id);
-                if (trackData) {
-                  return {
-                    fragmentIndex: binarySearchExact(
-                      this.internalTrack.fragments,
-                      currentFragment.moofOffset,
-                      (x) => x.moofOffset
-                    ),
-                    sampleIndex: 0,
-                    correctSampleFound: true
-                  };
-                }
-                currentFragment = currentFragment.nextFragment;
+      const regularPacket = await this.fetchPacketForSampleIndex(0, options);
+      if (regularPacket || !this.internalTrack.demuxer.isFragmented) {
+        return regularPacket;
+      }
+      return this.performFragmentedLookup(
+        () => {
+          const startFragment = this.internalTrack.demuxer.fragments[0] ?? null;
+          if (startFragment?.isKnownToBeFirstFragment) {
+            let currentFragment = startFragment;
+            while (currentFragment) {
+              const trackData = currentFragment.trackData.get(this.internalTrack.id);
+              if (trackData) {
+                return {
+                  fragmentIndex: binarySearchExact(
+                    this.internalTrack.fragments,
+                    currentFragment.moofOffset,
+                    (x) => x.moofOffset
+                  ),
+                  sampleIndex: 0,
+                  correctSampleFound: true
+                };
               }
+              currentFragment = currentFragment.nextFragment;
             }
-            return {
-              fragmentIndex: -1,
-              sampleIndex: -1,
-              correctSampleFound: false
-            };
-          },
-          -Infinity,
-          // Use -Infinity as a search timestamp to avoid using the lookup entries
-          Infinity,
-          options
-        );
-      }
-      return this.fetchPacketForSampleIndex(0, options);
+          }
+          return {
+            fragmentIndex: -1,
+            sampleIndex: -1,
+            correctSampleFound: false
+          };
+        },
+        -Infinity,
+        // Use -Infinity as a search timestamp to avoid using the lookup entries
+        Infinity,
+        options
+      );
     }
     mapTimestampIntoTimescale(timestamp) {
       return roundToPrecision(timestamp * this.internalTrack.timescale, 14) + this.internalTrack.editListOffset;
     }
     async getPacket(timestamp, options) {
       const timestampInTimescale = this.mapTimestampIntoTimescale(timestamp);
-      if (this.internalTrack.demuxer.isFragmented) {
-        return this.performFragmentedLookup(
-          () => this.findSampleInFragmentsForTimestamp(timestampInTimescale),
-          timestampInTimescale,
-          timestampInTimescale,
-          options
-        );
-      } else {
-        const sampleTable = this.internalTrack.demuxer.getSampleTableForTrack(this.internalTrack);
-        const sampleIndex = getSampleIndexForTimestamp(sampleTable, timestampInTimescale);
-        return this.fetchPacketForSampleIndex(sampleIndex, options);
+      const sampleTable = this.internalTrack.demuxer.getSampleTableForTrack(this.internalTrack);
+      const sampleIndex = getSampleIndexForTimestamp(sampleTable, timestampInTimescale);
+      const regularPacket = await this.fetchPacketForSampleIndex(sampleIndex, options);
+      if (!sampleTableIsEmpty(sampleTable) || !this.internalTrack.demuxer.isFragmented) {
+        return regularPacket;
       }
+      return this.performFragmentedLookup(
+        () => this.findSampleInFragmentsForTimestamp(timestampInTimescale),
+        timestampInTimescale,
+        timestampInTimescale,
+        options
+      );
     }
     async getNextPacket(packet, options) {
-      if (this.internalTrack.demuxer.isFragmented) {
-        const locationInFragment = this.packetToFragmentLocation.get(packet);
-        if (locationInFragment === void 0) {
-          throw new Error("Packet was not created from this track.");
-        }
-        const trackData = locationInFragment.fragment.trackData.get(this.internalTrack.id);
-        const fragmentSample = trackData.samples[locationInFragment.sampleIndex];
-        const fragmentIndex = binarySearchExact(
-          this.internalTrack.fragments,
-          locationInFragment.fragment.moofOffset,
-          (x) => x.moofOffset
-        );
-        assert(fragmentIndex !== -1);
-        return this.performFragmentedLookup(
-          () => {
-            if (locationInFragment.sampleIndex + 1 < trackData.samples.length) {
-              return {
-                fragmentIndex,
-                sampleIndex: locationInFragment.sampleIndex + 1,
-                correctSampleFound: true
-              };
-            } else {
-              let currentFragment = locationInFragment.fragment;
-              while (currentFragment.nextFragment) {
-                currentFragment = currentFragment.nextFragment;
-                const trackData2 = currentFragment.trackData.get(this.internalTrack.id);
-                if (trackData2) {
-                  const fragmentIndex2 = binarySearchExact(
-                    this.internalTrack.fragments,
-                    currentFragment.moofOffset,
-                    (x) => x.moofOffset
-                  );
-                  assert(fragmentIndex2 !== -1);
-                  return {
-                    fragmentIndex: fragmentIndex2,
-                    sampleIndex: 0,
-                    correctSampleFound: true
-                  };
-                }
-              }
-              return {
-                fragmentIndex,
-                sampleIndex: -1,
-                correctSampleFound: false
-              };
-            }
-          },
-          fragmentSample.presentationTimestamp,
-          Infinity,
-          options
-        );
+      const regularSampleIndex = this.packetToSampleIndex.get(packet);
+      if (regularSampleIndex !== void 0) {
+        return this.fetchPacketForSampleIndex(regularSampleIndex + 1, options);
       }
-      const sampleIndex = this.packetToSampleIndex.get(packet);
-      if (sampleIndex === void 0) {
+      const locationInFragment = this.packetToFragmentLocation.get(packet);
+      if (locationInFragment === void 0) {
         throw new Error("Packet was not created from this track.");
       }
-      return this.fetchPacketForSampleIndex(sampleIndex + 1, options);
+      const trackData = locationInFragment.fragment.trackData.get(this.internalTrack.id);
+      const fragmentSample = trackData.samples[locationInFragment.sampleIndex];
+      const fragmentIndex = binarySearchExact(
+        this.internalTrack.fragments,
+        locationInFragment.fragment.moofOffset,
+        (x) => x.moofOffset
+      );
+      assert(fragmentIndex !== -1);
+      return this.performFragmentedLookup(
+        () => {
+          if (locationInFragment.sampleIndex + 1 < trackData.samples.length) {
+            return {
+              fragmentIndex,
+              sampleIndex: locationInFragment.sampleIndex + 1,
+              correctSampleFound: true
+            };
+          } else {
+            let currentFragment = locationInFragment.fragment;
+            while (currentFragment.nextFragment) {
+              currentFragment = currentFragment.nextFragment;
+              const trackData2 = currentFragment.trackData.get(this.internalTrack.id);
+              if (trackData2) {
+                const fragmentIndex2 = binarySearchExact(
+                  this.internalTrack.fragments,
+                  currentFragment.moofOffset,
+                  (x) => x.moofOffset
+                );
+                assert(fragmentIndex2 !== -1);
+                return {
+                  fragmentIndex: fragmentIndex2,
+                  sampleIndex: 0,
+                  correctSampleFound: true
+                };
+              }
+            }
+            return {
+              fragmentIndex,
+              sampleIndex: -1,
+              correctSampleFound: false
+            };
+          }
+        },
+        fragmentSample.presentationTimestamp,
+        Infinity,
+        options
+      );
     }
     async getKeyPacket(timestamp, options) {
       const timestampInTimescale = this.mapTimestampIntoTimescale(timestamp);
-      if (this.internalTrack.demuxer.isFragmented) {
-        return this.performFragmentedLookup(
-          () => this.findKeySampleInFragmentsForTimestamp(timestampInTimescale),
-          timestampInTimescale,
-          timestampInTimescale,
-          options
-        );
-      }
       const sampleTable = this.internalTrack.demuxer.getSampleTableForTrack(this.internalTrack);
       const sampleIndex = getSampleIndexForTimestamp(sampleTable, timestampInTimescale);
       const keyFrameSampleIndex = sampleIndex === -1 ? -1 : getRelevantKeyframeIndexForSample(sampleTable, sampleIndex);
-      return this.fetchPacketForSampleIndex(keyFrameSampleIndex, options);
+      const regularPacket = await this.fetchPacketForSampleIndex(keyFrameSampleIndex, options);
+      if (!sampleTableIsEmpty(sampleTable) || !this.internalTrack.demuxer.isFragmented) {
+        return regularPacket;
+      }
+      return this.performFragmentedLookup(
+        () => this.findKeySampleInFragmentsForTimestamp(timestampInTimescale),
+        timestampInTimescale,
+        timestampInTimescale,
+        options
+      );
     }
     async getNextKeyPacket(packet, options) {
-      if (this.internalTrack.demuxer.isFragmented) {
-        const locationInFragment = this.packetToFragmentLocation.get(packet);
-        if (locationInFragment === void 0) {
-          throw new Error("Packet was not created from this track.");
-        }
-        const trackData = locationInFragment.fragment.trackData.get(this.internalTrack.id);
-        const fragmentSample = trackData.samples[locationInFragment.sampleIndex];
-        const fragmentIndex = binarySearchExact(
-          this.internalTrack.fragments,
-          locationInFragment.fragment.moofOffset,
-          (x) => x.moofOffset
-        );
-        assert(fragmentIndex !== -1);
-        return this.performFragmentedLookup(
-          () => {
-            const nextKeyFrameIndex = trackData.samples.findIndex(
-              (x, i) => x.isKeyFrame && i > locationInFragment.sampleIndex
-            );
-            if (nextKeyFrameIndex !== -1) {
-              return {
-                fragmentIndex,
-                sampleIndex: nextKeyFrameIndex,
-                correctSampleFound: true
-              };
-            } else {
-              let currentFragment = locationInFragment.fragment;
-              while (currentFragment.nextFragment) {
-                currentFragment = currentFragment.nextFragment;
-                const trackData2 = currentFragment.trackData.get(this.internalTrack.id);
-                if (trackData2 && trackData2.firstKeyFrameTimestamp !== null) {
-                  const fragmentIndex2 = binarySearchExact(
-                    this.internalTrack.fragments,
-                    currentFragment.moofOffset,
-                    (x) => x.moofOffset
-                  );
-                  assert(fragmentIndex2 !== -1);
-                  const keyFrameIndex = trackData2.samples.findIndex((x) => x.isKeyFrame);
-                  assert(keyFrameIndex !== -1);
-                  return {
-                    fragmentIndex: fragmentIndex2,
-                    sampleIndex: keyFrameIndex,
-                    correctSampleFound: true
-                  };
-                }
-              }
-              return {
-                fragmentIndex,
-                sampleIndex: -1,
-                correctSampleFound: false
-              };
-            }
-          },
-          fragmentSample.presentationTimestamp,
-          Infinity,
-          options
-        );
+      const regularSampleIndex = this.packetToSampleIndex.get(packet);
+      if (regularSampleIndex !== void 0) {
+        const sampleTable = this.internalTrack.demuxer.getSampleTableForTrack(this.internalTrack);
+        const nextKeyFrameSampleIndex = getNextKeyframeIndexForSample(sampleTable, regularSampleIndex);
+        return this.fetchPacketForSampleIndex(nextKeyFrameSampleIndex, options);
       }
-      const sampleIndex = this.packetToSampleIndex.get(packet);
-      if (sampleIndex === void 0) {
+      const locationInFragment = this.packetToFragmentLocation.get(packet);
+      if (locationInFragment === void 0) {
         throw new Error("Packet was not created from this track.");
       }
-      const sampleTable = this.internalTrack.demuxer.getSampleTableForTrack(this.internalTrack);
-      const nextKeyFrameSampleIndex = getNextKeyframeIndexForSample(sampleTable, sampleIndex);
-      return this.fetchPacketForSampleIndex(nextKeyFrameSampleIndex, options);
+      const trackData = locationInFragment.fragment.trackData.get(this.internalTrack.id);
+      const fragmentSample = trackData.samples[locationInFragment.sampleIndex];
+      const fragmentIndex = binarySearchExact(
+        this.internalTrack.fragments,
+        locationInFragment.fragment.moofOffset,
+        (x) => x.moofOffset
+      );
+      assert(fragmentIndex !== -1);
+      return this.performFragmentedLookup(
+        () => {
+          const nextKeyFrameIndex = trackData.samples.findIndex(
+            (x, i) => x.isKeyFrame && i > locationInFragment.sampleIndex
+          );
+          if (nextKeyFrameIndex !== -1) {
+            return {
+              fragmentIndex,
+              sampleIndex: nextKeyFrameIndex,
+              correctSampleFound: true
+            };
+          } else {
+            let currentFragment = locationInFragment.fragment;
+            while (currentFragment.nextFragment) {
+              currentFragment = currentFragment.nextFragment;
+              const trackData2 = currentFragment.trackData.get(this.internalTrack.id);
+              if (trackData2 && trackData2.firstKeyFrameTimestamp !== null) {
+                const fragmentIndex2 = binarySearchExact(
+                  this.internalTrack.fragments,
+                  currentFragment.moofOffset,
+                  (x) => x.moofOffset
+                );
+                assert(fragmentIndex2 !== -1);
+                const keyFrameIndex = trackData2.samples.findIndex((x) => x.isKeyFrame);
+                assert(keyFrameIndex !== -1);
+                return {
+                  fragmentIndex: fragmentIndex2,
+                  sampleIndex: keyFrameIndex,
+                  correctSampleFound: true
+                };
+              }
+            }
+            return {
+              fragmentIndex,
+              sampleIndex: -1,
+              correctSampleFound: false
+            };
+          }
+        },
+        fragmentSample.presentationTimestamp,
+        Infinity,
+        options
+      );
     }
     async fetchPacketForSampleIndex(sampleIndex, options) {
       if (sampleIndex === -1) {
@@ -14159,6 +14155,9 @@ ${cue.notes ?? ""}`;
     const sinTheta = m21 / scaleX;
     return -Math.atan2(sinTheta, cosTheta) * (180 / Math.PI);
   };
+  var sampleTableIsEmpty = (sampleTable) => {
+    return sampleTable.sampleSizes.length === 0;
+  };
 
   // src/matroska/matroska-demuxer.ts
   var METADATA_ELEMENTS = [