@remotion/media 4.0.497 → 4.0.499

package/dist/debug-overlay/preview-overlay.d.ts

@@ -68,16 +68,22 @@ export declare const drawPreviewOverlay: ({ context, audioTime, audioContextStat
     videoIteratorManager: {
         startVideoIterator: (timeToSeek: number, nonce: import("../nonce-manager").Nonce) => Promise<void>;
         getVideoIteratorsCreated: () => number;
-        seek: ({ newTime, nonce }: {
+        seek: ({ newTime, nonce, fps, playbackRate, isPlaying, }: {
             newTime: number;
             nonce: import("../nonce-manager").Nonce;
+            fps: number;
+            playbackRate: number;
+            isPlaying: boolean;
         }) => Promise<void>;
         destroy: () => void;
         getVideoFrameIterator: () => {
             destroy: () => void;
             initialFrame: import("mediabunny").WrappedCanvas | null;
             isDestroyed: () => boolean;
-            tryToSatisfySeek: (time: number) => Promise<{
+            tryToSatisfySeek: (time: number, options: {
+                pendingFrameBehavior: "restart-iterator" | "wait";
+                shouldContinue: () => boolean;
+            }) => Promise<{
                 type: "not-satisfied";
                 reason: string;
             } | {

package/dist/esm/index.mjs

@@ -1277,7 +1277,6 @@ 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);
@@ -1315,22 +1314,12 @@ var createVideoIterator = async (timeToSeek, cache) => {
       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 getFrameEndTimestamp = async ({
+    pendingFrameBehavior,
+    shouldContinue
   }) => {
     const peeked = peekIfReady();
     if (peeked.type === "ready") {
@@ -1339,10 +1328,16 @@ var createVideoIterator = async (timeToSeek, cache) => {
         timestamp: getFrameEndTimestampFromPeek(peeked.frame)
       };
     }
-    if (timestamp - frameTimestamp > MAXIMUM_AWAITED_PEEK_DISTANCE_SECONDS) {
+    if (pendingFrameBehavior === "restart-iterator") {
       return { type: "pending" };
     }
+    if (!shouldContinue()) {
+      return { type: "cancelled" };
+    }
     const awaitedPeeked = setPeekedFrame(await peeked.wait());
+    if (!shouldContinue()) {
+      return { type: "cancelled" };
+    }
     return {
       type: "ready",
       timestamp: getFrameEndTimestampFromPeek(awaitedPeeked)
@@ -1396,7 +1391,13 @@ var createVideoIterator = async (timeToSeek, cache) => {
       return;
     });
   };
-  const tryToSatisfySeek = async (time) => {
+  const tryToSatisfySeek = async (time, options) => {
+    if (!options.shouldContinue()) {
+      return {
+        type: "not-satisfied",
+        reason: "seek was superseded"
+      };
+    }
     const timestamp = roundTo4Digits(time);
     if (lastReturnedFrame) {
       const frameTimestamp = roundTo4Digits(lastReturnedFrame.timestamp);
@@ -1414,8 +1415,23 @@ var createVideoIterator = async (timeToSeek, cache) => {
           reason: `iterator is too far, most recently returned ${frameTimestamp}`
         };
       }
-      const frameEndTimestamp = await getFrameEndTimestamp();
-      if (frameTimestamp <= timestamp && frameEndTimestamp > timestamp) {
+      const frameEndTimestamp = await getFrameEndTimestamp({
+        pendingFrameBehavior: options.pendingFrameBehavior,
+        shouldContinue: options.shouldContinue
+      });
+      if (frameEndTimestamp.type === "cancelled") {
+        return {
+          type: "not-satisfied",
+          reason: "seek was superseded"
+        };
+      }
+      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: lastReturnedFrame
@@ -1435,6 +1451,12 @@ var createVideoIterator = async (timeToSeek, cache) => {
       };
     }
     while (true) {
+      if (!options.shouldContinue()) {
+        return {
+          type: "not-satisfied",
+          reason: "seek was superseded"
+        };
+      }
       const frame = getNextOrNullIfNotAvailable();
       if (frame.type === "need-to-wait-for-it") {
         return {
@@ -1457,10 +1479,16 @@ var createVideoIterator = async (timeToSeek, cache) => {
           };
         }
         const frameTimestamp = roundTo4Digits(frame.frame.timestamp);
-        const frameEndTimestamp = await getFrameEndTimestampIfCloseEnough({
-          frameTimestamp,
-          timestamp
+        const frameEndTimestamp = await getFrameEndTimestamp({
+          pendingFrameBehavior: options.pendingFrameBehavior,
+          shouldContinue: options.shouldContinue
         });
+        if (frameEndTimestamp.type === "cancelled") {
+          return {
+            type: "not-satisfied",
+            reason: "seek was superseded"
+          };
+        }
         if (frameEndTimestamp.type === "pending") {
           return {
             type: "not-satisfied",
@@ -1490,6 +1518,19 @@ var createVideoIterator = async (timeToSeek, cache) => {
 
 // src/video-iterator-manager.ts
 var { runEffectChain } = Internals4;
+var isSequentialMediaTimeAdvance = ({
+  previousTime,
+  newTime,
+  fps,
+  playbackRate,
+  isPlaying
+}) => {
+  if (!isPlaying || newTime < previousTime) {
+    return false;
+  }
+  const maximumSequentialAdvance = Math.abs(playbackRate) / fps;
+  return roundTo4Digits(newTime - previousTime) <= roundTo4Digits(maximumSequentialAdvance);
+};
 var videoIteratorManager = async ({
   delayPlaybackHandleIfNotPremounting,
   canvas,
@@ -1599,13 +1640,20 @@ var videoIteratorManager = async ({
       __callDispose(__stack, _err, _hasErr);
     }
   };
-  const seek = async ({ newTime, nonce }) => {
+  const seek = async ({
+    newTime,
+    nonce,
+    fps,
+    playbackRate,
+    isPlaying
+  }) => {
     if (!videoFrameIterator) {
       return;
     }
     if (currentSeek !== null && roundTo4Digits(currentSeek) === roundTo4Digits(newTime)) {
       return;
     }
+    const previousTime = currentSeek;
     currentSeek = newTime;
     if (getIsLooping()) {
       if (getLoopSegmentMediaEndTimestamp() - newTime < 1) {
@@ -1614,7 +1662,17 @@ var videoIteratorManager = async ({
         });
       }
     }
-    const videoSatisfyResult = await videoFrameIterator.tryToSatisfySeek(newTime);
+    const pendingFrameBehavior = previousTime !== null && isSequentialMediaTimeAdvance({
+      previousTime,
+      newTime,
+      fps,
+      playbackRate,
+      isPlaying
+    }) ? "wait" : "restart-iterator";
+    const videoSatisfyResult = await videoFrameIterator.tryToSatisfySeek(newTime, {
+      pendingFrameBehavior,
+      shouldContinue: () => !nonce.isStale()
+    });
     if (videoSatisfyResult.type === "satisfied") {
       await drawFrame(videoSatisfyResult.frame);
       return;
@@ -1949,7 +2007,10 @@ class MediaPlayer {
       await Promise.all([
         this.videoIteratorManager?.seek({
           newTime,
-          nonce
+          nonce,
+          fps: this.fps,
+          playbackRate: this.playbackRate,
+          isPlaying: this.playing
         }),
         this.audioIteratorManager?.seek({
           newTime,

package/dist/video/video-preview-iterator.d.ts

@@ -12,7 +12,10 @@ export declare const createVideoIterator: (timeToSeek: number, cache: {
     destroy: () => void;
     initialFrame: WrappedCanvas | null;
     isDestroyed: () => boolean;
-    tryToSatisfySeek: (time: number) => Promise<{
+    tryToSatisfySeek: (time: number, options: {
+        pendingFrameBehavior: "restart-iterator" | "wait";
+        shouldContinue: () => boolean;
+    }) => Promise<{
         type: "not-satisfied";
         reason: string;
     } | {

package/dist/video-iterator-manager.d.ts

@@ -2,6 +2,13 @@ import type { InputVideoTrack, WrappedCanvas } from 'mediabunny';
 import type { EffectChainState, EffectDefinitionAndStack } from 'remotion';
 import type { DelayPlaybackIfNotPremounting } from './delay-playback-if-not-premounting';
 import type { Nonce } from './nonce-manager';
+export declare const isSequentialMediaTimeAdvance: ({ previousTime, newTime, fps, playbackRate, isPlaying, }: {
+    previousTime: number;
+    newTime: number;
+    fps: number;
+    playbackRate: number;
+    isPlaying: boolean;
+}) => boolean;
 export declare const videoIteratorManager: ({ delayPlaybackHandleIfNotPremounting, canvas, context, drawDebugOverlay, logLevel, getOnVideoFrameCallback, videoTrack, getLoopSegmentMediaEndTimestamp, getStartTime, getIsLooping, getEffects, getEffectChainState, }: {
     videoTrack: InputVideoTrack;
     delayPlaybackHandleIfNotPremounting: () => DelayPlaybackIfNotPremounting;
@@ -18,16 +25,22 @@ export declare const videoIteratorManager: ({ delayPlaybackHandleIfNotPremountin
 }) => Promise<{
     startVideoIterator: (timeToSeek: number, nonce: Nonce) => Promise<void>;
     getVideoIteratorsCreated: () => number;
-    seek: ({ newTime, nonce }: {
+    seek: ({ newTime, nonce, fps, playbackRate, isPlaying, }: {
         newTime: number;
         nonce: Nonce;
+        fps: number;
+        playbackRate: number;
+        isPlaying: boolean;
     }) => Promise<void>;
     destroy: () => void;
     getVideoFrameIterator: () => {
         destroy: () => void;
         initialFrame: WrappedCanvas | null;
         isDestroyed: () => boolean;
-        tryToSatisfySeek: (time: number) => Promise<{
+        tryToSatisfySeek: (time: number, options: {
+            pendingFrameBehavior: "restart-iterator" | "wait";
+            shouldContinue: () => boolean;
+        }) => Promise<{
             type: "not-satisfied";
             reason: string;
         } | {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.497",
+	"version": "4.0.499",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -23,16 +23,16 @@
 	},
 	"dependencies": {
 		"mediabunny": "1.50.8",
-		"remotion": "4.0.497",
-		"zod": "4.3.6"
+		"remotion": "4.0.499",
+		"zod": "4.4.3"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.497",
-		"@remotion/player": "4.0.497",
+		"@remotion/eslint-config-internal": "4.0.499",
+		"@remotion/player": "4.0.499",
 		"@vitest/browser-webdriverio": "4.0.9",
 		"eslint": "9.19.0",
 		"react": "19.2.3",