@remotion/media 4.0.486 → 4.0.487

package/dist/esm/index.mjs

@@ -1203,6 +1203,7 @@ var makePrewarmedVideoIteratorCache = (videoSink) => {
 };
 
 // src/video/video-preview-iterator.ts
+var MAXIMUM_AWAITED_PEEK_DISTANCE_SECONDS = 0.05;
 var createVideoIterator = async (timeToSeek, cache) => {
   let destroyed = false;
   const iterator = cache.makeIteratorOrUsePrewarmed(timeToSeek);
@@ -1217,17 +1218,61 @@ var createVideoIterator = async (timeToSeek, cache) => {
     }
     lastReturnedFrame = frame;
   };
-  const peek = async () => {
+  const setPeekedFrame = (frame) => {
+    peekedFrame = frame;
+    if (peekedFrame === null) {
+      iteratorEnded = true;
+    }
+    return peekedFrame;
+  };
+  const peekIfReady = () => {
     if (peekedFrame) {
-      return peekedFrame;
+      return { type: "ready", frame: peekedFrame };
+    }
+    if (iteratorEnded) {
+      return { type: "ready", frame: null };
     }
     const next = iterator.next();
     if (next.type === "ready") {
-      peekedFrame = next.frame;
-    } else {
-      peekedFrame = await next.wait();
+      return { type: "ready", frame: setPeekedFrame(next.frame) };
     }
-    return peekedFrame;
+    return {
+      type: "pending",
+      wait: next.wait
+    };
+  };
+  const peek = async () => {
+    const peeked = peekIfReady();
+    if (peeked.type === "ready") {
+      return peeked.frame;
+    }
+    return setPeekedFrame(await peeked.wait());
+  };
+  const getFrameEndTimestampFromPeek = (frame) => {
+    return frame ? roundTo4Digits(frame.timestamp) : Infinity;
+  };
+  const getFrameEndTimestamp = async () => {
+    return getFrameEndTimestampFromPeek(await peek());
+  };
+  const getFrameEndTimestampIfCloseEnough = async ({
+    timestamp,
+    frameTimestamp
+  }) => {
+    const peeked = peekIfReady();
+    if (peeked.type === "ready") {
+      return {
+        type: "ready",
+        timestamp: getFrameEndTimestampFromPeek(peeked.frame)
+      };
+    }
+    if (timestamp - frameTimestamp > MAXIMUM_AWAITED_PEEK_DISTANCE_SECONDS) {
+      return { type: "pending" };
+    }
+    const awaitedPeeked = setPeekedFrame(await peeked.wait());
+    return {
+      type: "ready",
+      timestamp: getFrameEndTimestampFromPeek(awaitedPeeked)
+    };
   };
   const getNextOrNullIfNotAvailable = () => {
     if (peekedFrame) {
@@ -1295,14 +1340,7 @@ var createVideoIterator = async (timeToSeek, cache) => {
           reason: `iterator is too far, most recently returned ${frameTimestamp}`
         };
       }
-      let lastFrameDuration = lastReturnedFrame.duration;
-      if (lastFrameDuration === 0) {
-        const peeked = await peek();
-        if (peeked) {
-          lastFrameDuration = peeked.timestamp - lastReturnedFrame.timestamp;
-        }
-      }
-      const frameEndTimestamp = roundTo4Digits(lastReturnedFrame.timestamp + lastFrameDuration);
+      const frameEndTimestamp = await getFrameEndTimestamp();
       if (frameTimestamp <= timestamp && frameEndTimestamp > timestamp) {
         return {
           type: "satisfied",
@@ -1345,8 +1383,17 @@ var createVideoIterator = async (timeToSeek, cache) => {
           };
         }
         const frameTimestamp = roundTo4Digits(frame.frame.timestamp);
-        const frameEndTimestamp = roundTo4Digits(frame.frame.timestamp + frame.frame.duration);
-        if (frameTimestamp <= timestamp && frameEndTimestamp > timestamp) {
+        const frameEndTimestamp = await getFrameEndTimestampIfCloseEnough({
+          frameTimestamp,
+          timestamp
+        });
+        if (frameEndTimestamp.type === "pending") {
+          return {
+            type: "not-satisfied",
+            reason: "iterator did not have next frame ready"
+          };
+        }
+        if (frameTimestamp <= timestamp && frameEndTimestamp.timestamp > timestamp) {
           return {
             type: "satisfied",
             frame: frame.frame
@@ -2961,17 +3008,30 @@ var makeKeyframeBank = async ({
   let hasReachedEndOfVideo = false;
   let lastUsed = Date.now();
   let allocationSize = 0;
-  const getDurationOfFrame = (timestamp) => {
+  const getMeasuredDurationOfFrame = (timestamp) => {
     const index = frameTimestamps.indexOf(timestamp);
     if (index === -1) {
       throw new Error(`Frame ${timestamp} not found`);
     }
     const nextTimestamp = frameTimestamps[index + 1];
-    if (!nextTimestamp) {
+    if (nextTimestamp === undefined) {
       return null;
     }
     return nextTimestamp - timestamp;
   };
+  const getKnownDurationOfFrame = (timestamp) => {
+    const measuredDuration = getMeasuredDurationOfFrame(timestamp);
+    if (measuredDuration !== null) {
+      return measuredDuration;
+    }
+    if (!hasReachedEndOfVideo) {
+      return null;
+    }
+    return frames[timestamp].duration ?? 0;
+  };
+  const getEstimatedDurationOfFrame = (timestamp) => {
+    return getMeasuredDurationOfFrame(timestamp) ?? frames[timestamp].duration ?? 0;
+  };
   const deleteFrameAtTimestamp = (timestamp) => {
     allocationSize -= getAllocationSize(frames[timestamp]);
     frameTimestamps.splice(frameTimestamps.indexOf(timestamp), 1);
@@ -2993,7 +3053,10 @@ var makeKeyframeBank = async ({
       if (!frames[frameTimestamp]) {
         continue;
       }
-      const duration = getDurationOfFrame(frameTimestamp) ?? frames[frameTimestamp].duration;
+      const duration = getKnownDurationOfFrame(frameTimestamp);
+      if (duration === null) {
+        continue;
+      }
       if (frameTimestamp + duration < timestampInSeconds) {
         deleteFrameAtTimestamp(frameTimestamp);
         deletedTimestamps.push(frameTimestamp);
@@ -3005,14 +3068,20 @@ var makeKeyframeBank = async ({
   };
   const hasDecodedEnoughForTimestamp = (timestamp) => {
     const lastFrameTimestamp = frameTimestamps[frameTimestamps.length - 1];
-    if (!lastFrameTimestamp) {
+    if (lastFrameTimestamp === undefined) {
       return false;
     }
     const lastFrame = frames[lastFrameTimestamp];
     if (!lastFrame) {
       return true;
     }
-    const duration = getDurationOfFrame(lastFrameTimestamp) ?? lastFrame.duration;
+    if (roundTo4Digits(lastFrameTimestamp) >= roundTo4Digits(timestamp)) {
+      return true;
+    }
+    const duration = getKnownDurationOfFrame(lastFrameTimestamp);
+    if (duration === null) {
+      return false;
+    }
     return roundTo4Digits(lastFrameTimestamp + duration) > roundTo4Digits(timestamp);
   };
   const addFrame = (frame, logLevel) => {
@@ -3086,8 +3155,7 @@ var makeKeyframeBank = async ({
     }
     const firstTimestamp = frameTimestamps[0];
     const lastTimestamp = frameTimestamps[frameTimestamps.length - 1];
-    const lastFrame = frames[lastTimestamp];
-    const lastFrameDuration = getDurationOfFrame(lastTimestamp) ?? lastFrame.duration ?? 0;
+    const lastFrameDuration = getEstimatedDurationOfFrame(lastTimestamp);
     return {
       firstTimestamp,
       lastTimestamp: lastTimestamp + lastFrameDuration

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.486",
+	"version": "4.0.487",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -22,8 +22,8 @@
 		"make": "tsgo && bun --env-file=../.env.bundle bundle.ts"
 	},
 	"dependencies": {
-		"mediabunny": "1.50.3",
-		"remotion": "4.0.486",
+		"mediabunny": "1.50.7",
+		"remotion": "4.0.487",
 		"zod": "4.3.6"
 	},
 	"peerDependencies": {
@@ -31,8 +31,8 @@
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.486",
-		"@remotion/player": "4.0.486",
+		"@remotion/eslint-config-internal": "4.0.487",
+		"@remotion/player": "4.0.487",
 		"@vitest/browser-webdriverio": "4.0.9",
 		"eslint": "9.19.0",
 		"react": "19.2.3",