@remotion/media 4.0.422 → 4.0.423

package/dist/video-iterator-manager.js

@@ -0,0 +1,109 @@
+import { CanvasSink } from 'mediabunny';
+import { Internals } from 'remotion';
+import { makePrewarmedVideoIteratorCache } from './prewarm-iterator-for-looping';
+import { createVideoIterator, } from './video/video-preview-iterator';
+export const videoIteratorManager = ({ delayPlaybackHandleIfNotPremounting, canvas, context, drawDebugOverlay, logLevel, getOnVideoFrameCallback, videoTrack, getEndTime, getStartTime, getIsLooping, }) => {
+    let videoIteratorsCreated = 0;
+    let videoFrameIterator = null;
+    let framesRendered = 0;
+    let currentDelayHandle = null;
+    if (canvas) {
+        canvas.width = videoTrack.displayWidth;
+        canvas.height = videoTrack.displayHeight;
+    }
+    const canvasSink = new CanvasSink(videoTrack, {
+        poolSize: 2,
+        fit: 'contain',
+        alpha: true,
+    });
+    const prewarmedVideoIteratorCache = makePrewarmedVideoIteratorCache(canvasSink);
+    const drawFrame = (frame) => {
+        if (context && canvas) {
+            context.clearRect(0, 0, canvas.width, canvas.height);
+            context.drawImage(frame.canvas, 0, 0);
+        }
+        framesRendered++;
+        drawDebugOverlay();
+        const callback = getOnVideoFrameCallback();
+        if (callback) {
+            callback(frame.canvas);
+        }
+        Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[MediaPlayer] Drew frame ${frame.timestamp.toFixed(3)}s`);
+    };
+    const startVideoIterator = async (timeToSeek, nonce) => {
+        videoFrameIterator?.destroy();
+        const iterator = createVideoIterator(timeToSeek, prewarmedVideoIteratorCache);
+        videoIteratorsCreated++;
+        videoFrameIterator = iterator;
+        const delayHandle = delayPlaybackHandleIfNotPremounting();
+        currentDelayHandle = delayHandle;
+        let frameResult;
+        try {
+            frameResult = await iterator.getNext();
+        }
+        finally {
+            delayHandle.unblock();
+            currentDelayHandle = null;
+        }
+        if (iterator.isDestroyed()) {
+            return;
+        }
+        if (nonce.isStale()) {
+            return;
+        }
+        if (videoFrameIterator.isDestroyed()) {
+            return;
+        }
+        if (!frameResult.value) {
+            // media ended
+            return;
+        }
+        drawFrame(frameResult.value);
+    };
+    const seek = async ({ newTime, nonce }) => {
+        if (!videoFrameIterator) {
+            return;
+        }
+        if (getIsLooping()) {
+            // If less than 1 second from the end away, we pre-warm a new iterator
+            if (getEndTime() - newTime < 1) {
+                prewarmedVideoIteratorCache.prewarmIteratorForLooping({
+                    timeToSeek: getStartTime(),
+                });
+            }
+        }
+        // Should return immediately, so it's okay to not use Promise.all here
+        const videoSatisfyResult = await videoFrameIterator.tryToSatisfySeek(newTime);
+        // Doing this before the staleness check, because
+        // frame might be better than what we currently have
+        // TODO: check if this is actually true
+        if (videoSatisfyResult.type === 'satisfied') {
+            drawFrame(videoSatisfyResult.frame);
+            return;
+        }
+        if (nonce.isStale()) {
+            return;
+        }
+        await startVideoIterator(newTime, nonce);
+    };
+    return {
+        startVideoIterator,
+        getVideoIteratorsCreated: () => videoIteratorsCreated,
+        seek,
+        destroy: () => {
+            prewarmedVideoIteratorCache.destroy();
+            videoFrameIterator?.destroy();
+            if (context && canvas) {
+                context.clearRect(0, 0, canvas.width, canvas.height);
+            }
+            if (currentDelayHandle) {
+                currentDelayHandle.unblock();
+                currentDelayHandle = null;
+            }
+            videoFrameIterator = null;
+        },
+        getVideoFrameIterator: () => videoFrameIterator,
+        drawFrame,
+        getFramesRendered: () => framesRendered,
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.422",
+	"version": "4.0.423",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -22,15 +22,16 @@
 		"make": "tsgo && bun --env-file=../.env.bundle bundle.ts"
 	},
 	"dependencies": {
-		"mediabunny": "1.29.0",
-		"remotion": "4.0.422"
+		"mediabunny": "1.34.2",
+		"@mediabunny/ac3": "1.34.2",
+		"remotion": "4.0.423"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.422",
+		"@remotion/eslint-config-internal": "4.0.423",
 		"@vitest/browser-webdriverio": "4.0.9",
 		"eslint": "9.19.0",
 		"react": "19.2.3",