mediabunny 1.4.3 → 1.5.0

package/dist/bundles/mediabunny.cjs

@@ -5660,7 +5660,11 @@ var Mediabunny = (() => {
     readString(length) {
       const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
       this.pos += length;
-      return String.fromCharCode(...new Uint8Array(view2.buffer, offset, length));
+      let strLength = 0;
+      while (strLength < length && view2.getUint8(offset + strLength) !== 0) {
+        strLength += 1;
+      }
+      return String.fromCharCode(...new Uint8Array(view2.buffer, offset, strLength));
     }
     readElementId() {
       const size = this.readVarIntSize();
@@ -5726,6 +5730,27 @@ var Mediabunny = (() => {
     "pcm-f64": "A_PCM/FLOAT/IEEE",
     "webvtt": "S_TEXT/WEBVTT"
   };
+  var readVarInt = (data, offset) => {
+    if (offset >= data.length) {
+      throw new Error("Offset out of bounds.");
+    }
+    const firstByte = data[offset];
+    let width = 1;
+    let mask = 1 << 7;
+    while ((firstByte & mask) === 0 && width < 8) {
+      width++;
+      mask >>= 1;
+    }
+    if (offset + width > data.length) {
+      throw new Error("VarInt extends beyond data bounds.");
+    }
+    let value = firstByte & mask - 1;
+    for (let i = 1; i < width; i++) {
+      value *= 1 << 8;
+      value += data[offset + i];
+    }
+    return { value, width };
+  };
   function assertDefinedSize(size) {
     if (size === null) {
       throw new Error("Undefined element size is used in a place where it is not supported.");
@@ -13571,199 +13596,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 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
+            };
+          }
+        },
+        -Infinity,
+        // Use -Infinity as a search timestamp to avoid using the lookup entries
+        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 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
+            };
+          }
+        },
+        -Infinity,
+        // Use -Infinity as a search timestamp to avoid using the lookup entries
+        Infinity,
+        options
+      );
     }
     async fetchPacketForSampleIndex(sampleIndex, options) {
       if (sampleIndex === -1) {
@@ -14159,6 +14180,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 = [
@@ -14402,12 +14426,15 @@ ${cue.notes ?? ""}`;
       this.currentCluster = cluster;
       this.readContiguousElements(this.clusterReader, size);
       for (const [trackId, trackData] of cluster.trackData) {
-        let blockReferencesExist = false;
+        const track = segment.tracks.find((x) => x.id === trackId) ?? null;
         assert(trackData.blocks.length > 0);
+        let blockReferencesExist = false;
+        let hasLacedBlocks = false;
         for (let i = 0; i < trackData.blocks.length; i++) {
           const block = trackData.blocks[i];
           block.timestamp += cluster.timestamp;
           blockReferencesExist ||= block.referencedTimestamps.length > 0;
+          hasLacedBlocks ||= block.lacing !== 0 /* None */;
         }
         if (blockReferencesExist) {
           trackData.blocks = sortBlocksByReferences(trackData.blocks);
@@ -14422,13 +14449,23 @@ ${cue.notes ?? ""}`;
           if (i < trackData.presentationTimestamps.length - 1) {
             const nextEntry = trackData.presentationTimestamps[i + 1];
             currentBlock.duration = nextEntry.timestamp - currentBlock.timestamp;
+          } else if (currentBlock.duration === 0) {
+            if (track?.defaultDuration != null) {
+              if (currentBlock.lacing === 0 /* None */) {
+                currentBlock.duration = track.defaultDuration;
+              } else {
+              }
+            }
           }
         }
+        if (hasLacedBlocks) {
+          this.expandLacedBlocks(trackData.blocks, track);
+          trackData.presentationTimestamps = trackData.blocks.map((block, i) => ({ timestamp: block.timestamp, blockIndex: i })).sort((a, b) => a.timestamp - b.timestamp);
+        }
         const firstBlock = trackData.blocks[trackData.presentationTimestamps[0].blockIndex];
         const lastBlock = trackData.blocks[last(trackData.presentationTimestamps).blockIndex];
         trackData.startTimestamp = firstBlock.timestamp;
         trackData.endTimestamp = lastBlock.timestamp + lastBlock.duration;
-        const track = segment.tracks.find((x) => x.id === trackId);
         if (track) {
           const insertionIndex2 = binarySearchLessOrEqual(
             track.clusters,
@@ -14470,6 +14507,95 @@ ${cue.notes ?? ""}`;
       }
       return trackData;
     }
+    expandLacedBlocks(blocks, track) {
+      for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+        const originalBlock = blocks[blockIndex];
+        if (originalBlock.lacing === 0 /* None */) {
+          continue;
+        }
+        const data = originalBlock.data;
+        let pos = 0;
+        const frameSizes = [];
+        const frameCount = data[pos] + 1;
+        pos++;
+        switch (originalBlock.lacing) {
+          case 1 /* Xiph */:
+            {
+              let totalUsedSize = 0;
+              for (let i = 0; i < frameCount - 1; i++) {
+                let frameSize = 0;
+                while (pos < data.length) {
+                  const value = data[pos];
+                  frameSize += value;
+                  pos++;
+                  if (value < 255) {
+                    frameSizes.push(frameSize);
+                    totalUsedSize += frameSize;
+                    break;
+                  }
+                }
+              }
+              frameSizes.push(data.length - (pos + totalUsedSize));
+            }
+            ;
+            break;
+          case 2 /* FixedSize */:
+            {
+              const totalDataSize = data.length - 1;
+              const frameSize = Math.floor(totalDataSize / frameCount);
+              for (let i = 0; i < frameCount; i++) {
+                frameSizes.push(frameSize);
+              }
+            }
+            ;
+            break;
+          case 3 /* Ebml */:
+            {
+              const firstResult = readVarInt(data, pos);
+              let currentSize = firstResult.value;
+              frameSizes.push(currentSize);
+              pos += firstResult.width;
+              let totalUsedSize = currentSize;
+              for (let i = 1; i < frameCount - 1; i++) {
+                const diffResult = readVarInt(data, pos);
+                const unsignedDiff = diffResult.value;
+                const bias = (1 << diffResult.width * 7 - 1) - 1;
+                const diff = unsignedDiff - bias;
+                currentSize += diff;
+                frameSizes.push(currentSize);
+                pos += diffResult.width;
+                totalUsedSize += currentSize;
+              }
+              frameSizes.push(data.length - (pos + totalUsedSize));
+            }
+            ;
+            break;
+          default:
+            assert(false);
+        }
+        assert(frameSizes.length === frameCount);
+        blocks.splice(blockIndex, 1);
+        let dataOffset = pos;
+        for (let i = 0; i < frameCount; i++) {
+          const frameSize = frameSizes[i];
+          const frameData = data.subarray(dataOffset, dataOffset + frameSize);
+          const blockDuration = originalBlock.duration || frameCount * (track?.defaultDuration ?? 0);
+          const frameTimestamp = originalBlock.timestamp + blockDuration * i / frameCount;
+          const frameDuration = blockDuration / frameCount;
+          blocks.splice(blockIndex + i, 0, {
+            timestamp: frameTimestamp,
+            duration: frameDuration,
+            isKeyFrame: originalBlock.isKeyFrame,
+            referencedTimestamps: originalBlock.referencedTimestamps,
+            data: frameData,
+            lacing: 0 /* None */
+          });
+          dataOffset += frameSize;
+        }
+        blockIndex += frameCount;
+        blockIndex--;
+      }
+    }
     readContiguousElements(reader, totalSize) {
       const startIndex = reader.pos;
       while (reader.pos - startIndex <= totalSize - MIN_HEADER_SIZE) {
@@ -14544,6 +14670,7 @@ ${cue.notes ?? ""}`;
               inputTrack: null,
               codecId: null,
               codecPrivate: null,
+              defaultDuration: null,
               languageCode: UNDETERMINED_LANGUAGE,
               info: null
             };
@@ -14691,6 +14818,13 @@ ${cue.notes ?? ""}`;
           }
           ;
           break;
+        case 2352003 /* DefaultDuration */:
+          {
+            if (!this.currentTrack) break;
+            this.currentTrack.defaultDuration = this.currentTrack.segment.timestampFactor * reader.readUnsignedInt(size) / 1e9;
+          }
+          ;
+          break;
         case 2274716 /* Language */:
           {
             if (!this.currentTrack) break;
@@ -14869,14 +15003,17 @@ ${cue.notes ?? ""}`;
             const relativeTimestamp = reader.readS16();
             const flags = reader.readU8();
             const isKeyFrame = !!(flags & 128);
+            const lacing = flags >> 1 & 3;
             const trackData = this.getTrackDataInCluster(this.currentCluster, trackNumber);
             trackData.blocks.push({
               timestamp: relativeTimestamp,
               // We'll add the cluster's timestamp to this later
               duration: 0,
+              // Will set later
               isKeyFrame,
               referencedTimestamps: [],
-              data: reader.readBytes(size - (reader.pos - dataStartPos))
+              data: reader.readBytes(size - (reader.pos - dataStartPos)),
+              lacing
             });
           }
           ;
@@ -14900,14 +15037,17 @@ ${cue.notes ?? ""}`;
             const trackNumber = reader.readVarInt();
             const relativeTimestamp = reader.readS16();
             const flags = reader.readU8();
+            const lacing = flags >> 1 & 3;
             const trackData = this.getTrackDataInCluster(this.currentCluster, trackNumber);
             this.currentBlock = {
               timestamp: relativeTimestamp,
               // We'll add the cluster's timestamp to this later
               duration: 0,
+              // Will set later
               isKeyFrame: true,
               referencedTimestamps: [],
-              data: reader.readBytes(size - (reader.pos - dataStartPos))
+              data: reader.readBytes(size - (reader.pos - dataStartPos)),
+              lacing
             };
             trackData.blocks.push(this.currentBlock);
           }
@@ -15010,7 +15150,6 @@ ${cue.notes ?? ""}`;
         throw new Error("Packet was not created from this track.");
       }
       const trackData = locationInCluster.cluster.trackData.get(this.internalTrack.id);
-      const block = trackData.blocks[locationInCluster.blockIndex];
       const clusterIndex = binarySearchExact(
         this.internalTrack.clusters,
         locationInCluster.cluster.elementStartPos,
@@ -15051,7 +15190,8 @@ ${cue.notes ?? ""}`;
             };
           }
         },
-        block.timestamp,
+        -Infinity,
+        // Use -Infinity as a search timestamp to avoid using the cues
         Infinity,
         options
       );
@@ -15071,7 +15211,6 @@ ${cue.notes ?? ""}`;
         throw new Error("Packet was not created from this track.");
       }
       const trackData = locationInCluster.cluster.trackData.get(this.internalTrack.id);
-      const block = trackData.blocks[locationInCluster.blockIndex];
       const clusterIndex = binarySearchExact(
         this.internalTrack.clusters,
         locationInCluster.cluster.elementStartPos,
@@ -15117,7 +15256,8 @@ ${cue.notes ?? ""}`;
             };
           }
         },
-        block.timestamp,
+        -Infinity,
+        // Use -Infinity as a search timestamp to avoid using the cues
         Infinity,
         options
       );
@@ -16774,8 +16914,11 @@ ${cue.notes ?? ""}`;
       if (options.video?.rotate !== void 0 && ![0, 90, 180, 270].includes(options.video.rotate)) {
         throw new TypeError("options.video.rotate, when provided, must be 0, 90, 180 or 270.");
       }
+      if (options.video?.frameRate !== void 0 && (!Number.isFinite(options.video.frameRate) || options.video.frameRate <= 0)) {
+        throw new TypeError("options.video.frameRate, when provided, must be a finite positive number.");
+      }
       if (options.audio !== void 0 && (!options.audio || typeof options.audio !== "object")) {
-        throw new TypeError("options.video, when provided, must be an object.");
+        throw new TypeError("options.audio, when provided, must be an object.");
       }
       if (options.audio?.discard !== void 0 && typeof options.audio.discard !== "boolean") {
         throw new TypeError("options.audio.discard, when provided, must be a boolean.");
@@ -16942,7 +17085,7 @@ ${cue.notes ?? ""}`;
         height = ceilToMultipleOfTwo(this._options.video.height);
       }
       const firstTimestamp = await track.getFirstTimestamp();
-      const needsTranscode = !!this._options.video?.forceTranscode || this._startTimestamp > 0 || firstTimestamp < 0;
+      const needsTranscode = !!this._options.video?.forceTranscode || this._startTimestamp > 0 || firstTimestamp < 0 || !!this._options.video?.frameRate;
       const needsRerender = width !== originalWidth || height !== originalHeight || totalRotation !== 0 && !outputSupportsRotation;
       let videoCodecs = this.output.format.getSupportedVideoCodecs();
       if (!needsTranscode && !this._options.video?.bitrate && !needsRerender && videoCodecs.includes(sourceCodec) && (!this._options.video?.codec || this._options.video?.codec === sourceCodec)) {
@@ -16993,9 +17136,9 @@ ${cue.notes ?? ""}`;
           bitrate,
           onEncodedPacket: (sample) => this._reportProgress(track.id, sample.timestamp + sample.duration)
         };
+        const source = new VideoSampleSource(encodingConfig);
+        videoSource = source;
         if (needsRerender) {
-          const source = new VideoSampleSource(encodingConfig);
-          videoSource = source;
           this._trackPromises.push((async () => {
             await this._started;
             const sink = new CanvasSink(track, {
@@ -17007,6 +17150,22 @@ ${cue.notes ?? ""}`;
               poolSize: 1
             });
             const iterator = sink.canvases(this._startTimestamp, this._endTimestamp);
+            const frameRate = this._options.video?.frameRate;
+            let lastCanvas = null;
+            let lastCanvasTimestamp = null;
+            let lastCanvasEndTimestamp = null;
+            const padFrames = async (until) => {
+              assert(lastCanvas);
+              assert(frameRate !== void 0);
+              const frameDifference = Math.round((until - lastCanvasTimestamp) * frameRate);
+              for (let i = 1; i < frameDifference; i++) {
+                const sample = new VideoSample(lastCanvas, {
+                  timestamp: lastCanvasTimestamp + i / frameRate,
+                  duration: 1 / frameRate
+                });
+                await source.add(sample);
+              }
+            };
             for await (const { canvas, timestamp, duration } of iterator) {
               if (this._synchronizer.shouldWait(track.id, timestamp)) {
                 await this._synchronizer.wait(timestamp);
@@ -17014,30 +17173,98 @@ ${cue.notes ?? ""}`;
               if (this._canceled) {
                 return;
               }
+              let adjustedSampleTimestamp = Math.max(timestamp - this._startTimestamp, 0);
+              lastCanvasEndTimestamp = timestamp + duration;
+              if (frameRate !== void 0) {
+                const alignedTimestamp = Math.floor(adjustedSampleTimestamp * frameRate) / frameRate;
+                if (lastCanvas !== null) {
+                  if (alignedTimestamp <= lastCanvasTimestamp) {
+                    lastCanvas = canvas;
+                    lastCanvasTimestamp = alignedTimestamp;
+                    continue;
+                  } else {
+                    await padFrames(alignedTimestamp);
+                  }
+                }
+                adjustedSampleTimestamp = alignedTimestamp;
+              }
               const sample = new VideoSample(canvas, {
-                timestamp: Math.max(timestamp - this._startTimestamp, 0),
-                duration
+                timestamp: adjustedSampleTimestamp,
+                duration: frameRate !== void 0 ? 1 / frameRate : duration
               });
               await source.add(sample);
-              sample.close();
+              if (frameRate !== void 0) {
+                lastCanvas = canvas;
+                lastCanvasTimestamp = adjustedSampleTimestamp;
+              } else {
+                sample.close();
+              }
+            }
+            if (lastCanvas) {
+              assert(lastCanvasEndTimestamp !== null);
+              assert(frameRate !== void 0);
+              await padFrames(Math.floor(lastCanvasEndTimestamp * frameRate) / frameRate);
             }
+            source.close();
+            this._synchronizer.closeTrack(track.id);
           })());
         } else {
-          const source = new VideoSampleSource(encodingConfig);
-          videoSource = source;
           this._trackPromises.push((async () => {
             await this._started;
             const sink = new VideoSampleSink(track);
+            const frameRate = this._options.video?.frameRate;
+            let lastSample = null;
+            let lastSampleTimestamp = null;
+            let lastSampleEndTimestamp = null;
+            const padFrames = async (until) => {
+              assert(lastSample);
+              assert(frameRate !== void 0);
+              const frameDifference = Math.round((until - lastSampleTimestamp) * frameRate);
+              for (let i = 1; i < frameDifference; i++) {
+                lastSample.setTimestamp(lastSampleTimestamp + i / frameRate);
+                lastSample.setDuration(1 / frameRate);
+                await source.add(lastSample);
+              }
+              lastSample.close();
+            };
             for await (const sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
               if (this._synchronizer.shouldWait(track.id, sample.timestamp)) {
                 await this._synchronizer.wait(sample.timestamp);
               }
-              sample.setTimestamp(Math.max(sample.timestamp - this._startTimestamp, 0));
               if (this._canceled) {
+                lastSample?.close();
                 return;
               }
+              let adjustedSampleTimestamp = Math.max(sample.timestamp - this._startTimestamp, 0);
+              lastSampleEndTimestamp = sample.timestamp + sample.duration;
+              if (frameRate !== void 0) {
+                const alignedTimestamp = Math.floor(adjustedSampleTimestamp * frameRate) / frameRate;
+                if (lastSample !== null) {
+                  if (alignedTimestamp <= lastSampleTimestamp) {
+                    lastSample.close();
+                    lastSample = sample;
+                    lastSampleTimestamp = alignedTimestamp;
+                    continue;
+                  } else {
+                    await padFrames(alignedTimestamp);
+                  }
+                }
+                adjustedSampleTimestamp = alignedTimestamp;
+                sample.setDuration(1 / frameRate);
+              }
+              sample.setTimestamp(adjustedSampleTimestamp);
               await source.add(sample);
-              sample.close();
+              if (frameRate !== void 0) {
+                lastSample = sample;
+                lastSampleTimestamp = adjustedSampleTimestamp;
+              } else {
+                sample.close();
+              }
+            }
+            if (lastSample) {
+              assert(lastSampleEndTimestamp !== null);
+              assert(frameRate !== void 0);
+              await padFrames(Math.floor(lastSampleEndTimestamp * frameRate) / frameRate);
             }
             source.close();
             this._synchronizer.closeTrack(track.id);
@@ -17045,6 +17272,7 @@ ${cue.notes ?? ""}`;
         }
       }
       this.output.addVideoTrack(videoSource, {
+        frameRate: this._options.video?.frameRate,
         languageCode: track.languageCode,
         rotation: needsRerender ? 0 : totalRotation
         // Rerendering will bake the rotation into the output