@remotion/renderer 4.0.533 → 4.0.534

package/dist/remotion-shared-memory.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRemotionRawFrame = exports.RemotionSharedMemoryCapture = exports.getPreferredRemotionSharedMemoryBackend = void 0;
+const flaky_errors_1 = require("./browser/flaky-errors");
+const image_format_1 = require("./image-format");
+const logger_1 = require("./logger");
+const screenshot_background_1 = require("./screenshot-background");
+const encoderPadding = 64;
+const slotsPerPage = 1;
+// Escape hatch for testing a specific backend, for example the file backend on
+// a host that also has POSIX shared memory. Unset means "auto".
+const getPreferredRemotionSharedMemoryBackend = () => {
+    const value = process.env.REMOTION_SHARED_MEMORY_BACKEND;
+    if (value === 'posix-shm' || value === 'file') {
+        return value;
+    }
+    return 'auto';
+};
+exports.getPreferredRemotionSharedMemoryBackend = getPreferredRemotionSharedMemoryBackend;
+const isExpectedCapabilityError = (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    return (message.includes("'Page.remotionCreateFramePool' wasn't found") ||
+        message.includes('Method not found') ||
+        message.includes('Raw frames require') ||
+        message.includes('Raw frames are only supported') ||
+        message.includes('Could not create Remotion shared memory') ||
+        message.includes('Could not size Remotion shared memory') ||
+        message.includes('Could not map Remotion shared memory') ||
+        message.includes('Invalid Remotion frame pool dimensions'));
+};
+class RemotionSharedMemoryCapture {
+    #pools = new Map();
+    #nextPoolId = 1;
+    #nextFrameId = 1;
+    #supported = null;
+    #initialization = null;
+    #pixelFormat = null;
+    #options;
+    constructor(options) {
+        this.#options = options;
+    }
+    isSupported() {
+        return this.#supported === true;
+    }
+    getImageFormat(imageFormat) {
+        if (!this.isSupported() || this.#pixelFormat === null) {
+            if (this.#pixelFormat !== null && imageFormat === 'jpeg') {
+                (0, image_format_1.validateSelectedPixelFormatAndImageFormatCombination)(this.#pixelFormat, imageFormat);
+            }
+            return imageFormat;
+        }
+        return this.#pixelFormat === 'yuva420p' ||
+            this.#pixelFormat === 'yuva444p10le'
+            ? 'png'
+            : 'jpeg';
+    }
+    setPixelFormat(pixelFormat) {
+        this.#pixelFormat = pixelFormat;
+    }
+    async initializePages(pages) {
+        if (this.#initialization) {
+            await this.#initialization;
+            if (this.#supported) {
+                for (const page of pages) {
+                    await this.ensurePage(page);
+                }
+            }
+            return;
+        }
+        this.#initialization = (async () => {
+            try {
+                for (const page of pages) {
+                    await this.#createPool(page);
+                }
+                this.#supported = true;
+            }
+            catch (error) {
+                await this.#destroyPools();
+                if (!isExpectedCapabilityError(error)) {
+                    throw error;
+                }
+                this.#supported = false;
+                logger_1.Log.verbose({ indent: this.#options.indent, logLevel: this.#options.logLevel }, `Remotion shared-memory capture is unavailable. Falling back to encoded screenshots. Reason: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        })();
+        await this.#initialization;
+    }
+    async ensurePage(page) {
+        if (this.#pools.has(page) || this.#supported === false) {
+            return;
+        }
+        if (this.#supported === null) {
+            await this.initializePages([page]);
+            return;
+        }
+        await this.#createPool(page);
+    }
+    async acquire(page) {
+        if (!this.#supported) {
+            return null;
+        }
+        const pool = this.#pools.get(page);
+        if (!pool) {
+            throw new Error('No Remotion shared-memory pool exists for this page.');
+        }
+        while (pool.availableSlots.length === 0) {
+            if (pool.forgotten) {
+                throw new Error('The page owning this shared-memory pool was closed.');
+            }
+            await new Promise((resolve) => pool.waiters.push(resolve));
+        }
+        const slot = pool.availableSlots.shift();
+        if (slot === undefined) {
+            throw new Error('Expected an available Remotion shared-memory slot.');
+        }
+        if (!Number.isSafeInteger(this.#nextFrameId)) {
+            throw new Error('Remotion shared-memory frame ID exceeded the safe range.');
+        }
+        const frameId = String(this.#nextFrameId++);
+        pool.ownedSlots.set(slot, frameId);
+        let published = false;
+        let releasePromise = null;
+        const releasePublished = () => {
+            releasePromise !== null && releasePromise !== void 0 ? releasePromise : (releasePromise = (async () => {
+                try {
+                    await page._client().send('Page.remotionReleaseFrame', {
+                        slot,
+                        frameId,
+                    });
+                }
+                catch (error) {
+                    if (!(0, flaky_errors_1.isTargetClosedErr)(error)) {
+                        throw error;
+                    }
+                }
+                finally {
+                    this.#returnSlot(pool, slot, frameId);
+                }
+            })());
+            return releasePromise;
+        };
+        return {
+            slot,
+            frameId,
+            fail: () => {
+                if (!published) {
+                    this.#returnSlot(pool, slot, frameId);
+                }
+            },
+            discardPublished: async () => {
+                published = true;
+                await releasePublished();
+            },
+            publish: async (metadata) => {
+                published = true;
+                if (metadata.slot !== slot ||
+                    metadata.frameId !== frameId ||
+                    metadata.width !== this.#options.width ||
+                    metadata.height !== this.#options.height ||
+                    metadata.stride < metadata.width * 4 ||
+                    metadata.byteLength > pool.slotCapacity - encoderPadding ||
+                    metadata.pixelFormat !== 'bgra' ||
+                    metadata.colorSpace !== 'srgb') {
+                    await releasePublished();
+                    throw new Error(`Chromium returned invalid Remotion shared-memory metadata: ${JSON.stringify(metadata)}`);
+                }
+                return {
+                    ...metadata,
+                    type: 'remotion-shared-memory',
+                    poolId: pool.poolId,
+                    sharedMemoryName: pool.sharedMemoryName,
+                    backend: pool.backend,
+                    slotCount: pool.slotCount,
+                    slotCapacity: pool.slotCapacity,
+                    poolLifetime: pool.poolLifetime,
+                    release: releasePublished,
+                };
+            },
+        };
+    }
+    async destroy() {
+        await this.#destroyPools();
+    }
+    async forgetPage(page) {
+        await this.#forgetPage(page, false);
+    }
+    async forgetAllPages() {
+        await Promise.all([...this.#pools.keys()].map((page) => this.#forgetPage(page, false)));
+    }
+    async dispose() {
+        await Promise.all([...this.#pools.keys()].map((page) => this.#forgetPage(page, true)));
+        this.#supported = false;
+    }
+    async #forgetPage(page, bestEffort) {
+        const pool = this.#pools.get(page);
+        if (!pool) {
+            return;
+        }
+        this.#pools.delete(page);
+        pool.forgotten = true;
+        pool.waiters.splice(0).forEach((waiter) => waiter());
+        let cleanupError = null;
+        try {
+            await pool.poolLifetime.retire();
+        }
+        catch (error) {
+            cleanupError = error;
+        }
+        if (pool.ownedSlots.size > 0) {
+            await new Promise((resolve) => pool.drainWaiters.push(resolve));
+        }
+        try {
+            await (0, screenshot_background_1.setScreenshotBackground)(page, false);
+        }
+        catch (error) {
+            if (!bestEffort && !(0, flaky_errors_1.isTargetClosedErr)(error) && !cleanupError) {
+                cleanupError = error;
+            }
+        }
+        try {
+            await page._client().send('Page.remotionDestroyFramePool');
+        }
+        catch (error) {
+            if (!bestEffort && !(0, flaky_errors_1.isTargetClosedErr)(error) && !cleanupError) {
+                cleanupError = error;
+            }
+        }
+        if (cleanupError && !bestEffort) {
+            throw cleanupError;
+        }
+    }
+    async #createPool(page) {
+        var _a;
+        if (this.#pools.has(page)) {
+            return;
+        }
+        const slotCapacity = this.#options.width * this.#options.height * 4 + encoderPadding;
+        if (!Number.isSafeInteger(slotCapacity)) {
+            throw new Error('Remotion shared-memory frame pool size is not a safe integer.');
+        }
+        const preferredBackend = (0, exports.getPreferredRemotionSharedMemoryBackend)();
+        const { backingDirectory } = this.#options;
+        if (preferredBackend === 'file' && backingDirectory === null) {
+            throw new Error('REMOTION_SHARED_MEMORY_BACKEND=file requires an FFmpeg binary that supports file-backed pools (-pool_dir).');
+        }
+        const { value } = await page._client().send('Page.remotionCreateFramePool', {
+            slotCount: slotsPerPage,
+            slotCapacity,
+            ...(backingDirectory === null ? {} : { backingDirectory }),
+            ...(preferredBackend === 'auto' ? {} : { preferredBackend }),
+        });
+        // Chromium builds before v3 of the patch only know POSIX shared memory and
+        // omit the backend field.
+        const backend = (_a = value.backend) !== null && _a !== void 0 ? _a : 'posix-shm';
+        if (!value.sharedMemoryName ||
+            value.slotCount !== slotsPerPage ||
+            value.slotCapacity !== slotCapacity ||
+            (backend !== 'posix-shm' && backend !== 'file') ||
+            (backend === 'posix-shm' &&
+                !/^\/rmshm-[A-Za-z0-9._-]+$/.test(value.sharedMemoryName)) ||
+            (backend === 'file' &&
+                (backingDirectory === null ||
+                    !value.sharedMemoryName.startsWith(`${backingDirectory}/rmshm-`)))) {
+            throw new Error(`Chromium returned invalid Remotion frame pool metadata: ${JSON.stringify(value)}`);
+        }
+        if (this.#pools.size === 0) {
+            logger_1.Log.verbose({ indent: this.#options.indent, logLevel: this.#options.logLevel }, `Remotion shared-memory capture uses the ${backend === 'file' ? `file backend in ${backingDirectory}` : 'POSIX shared-memory backend'}.`);
+        }
+        let retired = false;
+        let retirement = null;
+        let notifyRetirement;
+        const retirementSignal = new Promise((resolve) => {
+            notifyRetirement = resolve;
+        });
+        const retirementListeners = new Set();
+        const poolLifetime = {
+            isRetired: () => retired,
+            waitForRetirement: () => retirementSignal,
+            onRetired: (listener) => {
+                if (retired) {
+                    return null;
+                }
+                retirementListeners.add(listener);
+                return () => retirementListeners.delete(listener);
+            },
+            retire: () => {
+                if (!retirement) {
+                    retired = true;
+                    notifyRetirement();
+                    retirement = (async () => {
+                        await Promise.all([...retirementListeners].map((listener) => listener()));
+                    })();
+                }
+                return retirement;
+            },
+        };
+        this.#pools.set(page, {
+            page,
+            poolId: this.#nextPoolId++,
+            sharedMemoryName: value.sharedMemoryName,
+            backend,
+            slotCount: value.slotCount,
+            slotCapacity: value.slotCapacity,
+            availableSlots: Array.from({ length: value.slotCount }, (_, index) => index),
+            waiters: [],
+            drainWaiters: [],
+            ownedSlots: new Map(),
+            forgotten: false,
+            poolLifetime,
+        });
+    }
+    #returnSlot(pool, slot, frameId) {
+        var _a;
+        if (pool.ownedSlots.get(slot) !== frameId) {
+            throw new Error(`Remotion shared-memory slot ${pool.poolId}:${slot} is not owned by frame ${frameId}.`);
+        }
+        pool.ownedSlots.delete(slot);
+        if (pool.forgotten) {
+            if (pool.ownedSlots.size === 0) {
+                pool.drainWaiters.splice(0).forEach((waiter) => waiter());
+            }
+        }
+        else {
+            pool.availableSlots.push(slot);
+            (_a = pool.waiters.shift()) === null || _a === void 0 ? void 0 : _a();
+        }
+    }
+    async #destroyPools() {
+        let cleanupError = null;
+        for (const pool of this.#pools.values()) {
+            if (pool.ownedSlots.size > 0) {
+                throw new Error(`Cannot destroy Remotion shared-memory pool ${pool.poolId} while it owns ${pool.ownedSlots.size} frame(s).`);
+            }
+            try {
+                await (0, screenshot_background_1.setScreenshotBackground)(pool.page, false);
+            }
+            catch (error) {
+                if (!(0, flaky_errors_1.isTargetClosedErr)(error) && !cleanupError) {
+                    cleanupError = error;
+                }
+            }
+            try {
+                await pool.page._client().send('Page.remotionDestroyFramePool');
+            }
+            catch (error) {
+                if (!(0, flaky_errors_1.isTargetClosedErr)(error) && !cleanupError) {
+                    cleanupError = error;
+                }
+            }
+        }
+        this.#pools.clear();
+        if (cleanupError) {
+            throw cleanupError;
+        }
+    }
+}
+exports.RemotionSharedMemoryCapture = RemotionSharedMemoryCapture;
+const isRemotionRawFrame = (frame) => !Buffer.isBuffer(frame);
+exports.isRemotionRawFrame = isRemotionRawFrame;

package/dist/render-frame-and-retry-target-close.d.ts

@@ -6,9 +6,10 @@ import type { Page } from './browser/BrowserPage';
 import type { CountType } from './get-frame-padded-index';
 import type { CancelSignal } from './make-cancel-signal';
 import type { Pool } from './pool';
+import type { CapturedFrame, RemotionSharedMemoryCapture } from './remotion-shared-memory';
 import type { AssetIndex, FrameAndAssets, OnArtifact } from './render-frames';
 import type { BrowserReplacer } from './replace-browser';
-export declare const renderFrameAndRetryTargetClose: ({ retriesLeft, attempt, assets, assetIndex, imageFormat, binariesDirectory, cancelSignal, composition, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, onError, outputDir, poolPromise, scale, stoppedSignal, timeoutInMilliseconds, indent, logLevel, makeBrowser, makeNewPage, browserReplacer, concurrencyOrFramesToRender, framesRenderedObj, lastFrame, onFrameBuffer, onFrameUpdate, nextFrameToRender, imageSequencePattern, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }: {
+export declare const renderFrameAndRetryTargetClose: ({ retriesLeft, attempt, assets, assetIndex, imageFormat, binariesDirectory, cancelSignal, composition, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, onError, outputDir, poolPromise, scale, stoppedSignal, timeoutInMilliseconds, indent, logLevel, makeBrowser, makeNewPage, browserReplacer, concurrencyOrFramesToRender, framesRenderedObj, lastFrame, onFrameBuffer, onFrame, remotionSharedMemory, onFrameUpdate, nextFrameToRender, imageSequencePattern, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }: {
     retriesLeft: number;
     attempt: number;
     imageFormat: "jpeg" | "none" | "png";
@@ -43,9 +44,11 @@ export declare const renderFrameAndRetryTargetClose: ({ retriesLeft, attempt, as
         count: number;
     };
     onFrameBuffer: ((buffer: Buffer, frame: number) => void | Promise<void>) | null | undefined;
+    onFrame: ((frame: CapturedFrame, frameNumber: number) => void | Promise<void>) | null;
+    remotionSharedMemory: RemotionSharedMemoryCapture | null;
     onFrameUpdate: ((framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void) | null;
     nextFrameToRender: {
-        getNextFrame: (_pageIndex: number) => number;
+        getNextFrame: () => number;
         returnFrame: (frame: number) => void;
     };
     imageSequencePattern: string | null;

package/dist/render-frame-and-retry-target-close.js

@@ -7,14 +7,14 @@ const is_delay_render_error_with_retry_1 = require("./is-delay-render-error-with
 const logger_1 = require("./logger");
 const make_cancel_signal_1 = require("./make-cancel-signal");
 const render_frame_1 = require("./render-frame");
-const renderFrameAndRetryTargetClose = async ({ retriesLeft, attempt, assets, assetIndex, imageFormat, binariesDirectory, cancelSignal, composition, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, onError, outputDir, poolPromise, scale, stoppedSignal, timeoutInMilliseconds, indent, logLevel, makeBrowser, makeNewPage, browserReplacer, concurrencyOrFramesToRender, framesRenderedObj, lastFrame, onFrameBuffer, onFrameUpdate, nextFrameToRender, imageSequencePattern, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }) => {
+const renderFrameAndRetryTargetClose = async ({ retriesLeft, attempt, assets, assetIndex, imageFormat, binariesDirectory, cancelSignal, composition, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, onError, outputDir, poolPromise, scale, stoppedSignal, timeoutInMilliseconds, indent, logLevel, makeBrowser, makeNewPage, browserReplacer, concurrencyOrFramesToRender, framesRenderedObj, lastFrame, onFrameBuffer, onFrame, remotionSharedMemory, onFrameUpdate, nextFrameToRender, imageSequencePattern, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }) => {
     var _a;
     const currentPool = await poolPromise;
     if (stoppedSignal.stopped) {
         return;
     }
     const freePage = await currentPool.acquire();
-    const frame = nextFrameToRender.getNextFrame(freePage.pageIndex);
+    const frame = nextFrameToRender.getNextFrame();
     try {
         await Promise.race([
             (0, render_frame_1.renderFrame)({
@@ -42,11 +42,12 @@ const renderFrameAndRetryTargetClose = async ({ retriesLeft, attempt, assets, as
                 lastFrame,
                 onError,
                 onFrameBuffer,
+                onFrame,
+                remotionSharedMemory,
                 onFrameUpdate,
                 outputDir,
                 stoppedSignal,
                 timeoutInMilliseconds,
-                nextFrameToRender,
                 frame,
                 page: freePage,
                 imageSequencePattern,
@@ -81,7 +82,17 @@ const renderFrameAndRetryTargetClose = async ({ retriesLeft, attempt, assets, as
         }
         if (shouldRetryError) {
             const pool = await poolPromise;
-            // Replace the closed page
+            // Retire shared-memory pools before closing the timed-out page.
+            await (remotionSharedMemory === null || remotionSharedMemory === void 0 ? void 0 : remotionSharedMemory.forgetPage(freePage));
+            // Close the timed-out page before creating another main tab at index 0.
+            try {
+                await freePage.close();
+            }
+            catch (closeError) {
+                if (!(closeError instanceof Error) || !(0, flaky_errors_1.isTargetClosedErr)(closeError)) {
+                    throw closeError;
+                }
+            }
             const newPage = await makeNewPage(frame, freePage.pageIndex);
             pool.release(newPage);
             logger_1.Log.warn({ indent, logLevel }, `delayRender() timed out while rendering frame ${frame}: ${err.message}`);
@@ -118,6 +129,8 @@ const renderFrameAndRetryTargetClose = async ({ retriesLeft, attempt, assets, as
                 framesRenderedObj,
                 lastFrame,
                 onFrameBuffer,
+                onFrame,
+                remotionSharedMemory,
                 onFrameUpdate,
                 nextFrameToRender,
                 imageSequencePattern,
@@ -128,6 +141,7 @@ const renderFrameAndRetryTargetClose = async ({ retriesLeft, attempt, assets, as
         }
         logger_1.Log.warn({ indent, logLevel }, `The browser crashed while rendering frame ${frame}, retrying ${retriesLeft} more times. Learn more about this error under https://www.remotion.dev/docs/target-closed`);
         // Replace the entire browser
+        await (remotionSharedMemory === null || remotionSharedMemory === void 0 ? void 0 : remotionSharedMemory.forgetAllPages());
         await browserReplacer.replaceBrowser(makeBrowser, async () => {
             const pages = new Array(concurrencyOrFramesToRender)
                 .fill(true)
@@ -170,6 +184,8 @@ const renderFrameAndRetryTargetClose = async ({ retriesLeft, attempt, assets, as
             framesRenderedObj,
             lastFrame,
             onFrameBuffer,
+            onFrame,
+            remotionSharedMemory,
             onFrameUpdate,
             nextFrameToRender,
             imageSequencePattern,

package/dist/render-frame-with-option-to-reject.d.ts

@@ -3,8 +3,9 @@ import type { DownloadMap } from './assets/download-map';
 import type { Page } from './browser/BrowserPage';
 import type { CountType } from './get-frame-padded-index';
 import type { CancelSignal } from './make-cancel-signal';
+import type { CapturedFrame, RemotionSharedMemoryCapture } from './remotion-shared-memory';
 import type { AssetIndex, FrameAndAssets, OnArtifact } from './render-frames';
-export declare const renderFrameWithOptionToReject: ({ reject, width, height, compId, attempt, stoppedSignal, indent, logLevel, timeoutInMilliseconds, outputDir, onFrameBuffer, imageFormat, onError, lastFrame, jpegQuality, frameDir, scale, countType, assets, assetIndex, framesToRender, onArtifact, onDownload, downloadMap, binariesDirectory, cancelSignal, framesRenderedObj, onFrameUpdate, frame, page, imageSequencePattern, fps, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }: {
+export declare const renderFrameWithOptionToReject: ({ reject, width, height, compId, attempt, stoppedSignal, indent, logLevel, timeoutInMilliseconds, outputDir, onFrameBuffer, onFrame, remotionSharedMemory, imageFormat, onError, lastFrame, jpegQuality, frameDir, scale, countType, assets, assetIndex, framesToRender, onArtifact, onDownload, downloadMap, binariesDirectory, cancelSignal, framesRenderedObj, onFrameUpdate, frame, page, imageSequencePattern, fps, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }: {
     reject: (err: Error) => void;
     width: number;
     height: number;
@@ -18,6 +19,8 @@ export declare const renderFrameWithOptionToReject: ({ reject, width, height, co
     logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     outputDir: string | null;
     onFrameBuffer: ((buffer: Buffer, frame: number) => void | Promise<void>) | null | undefined;
+    onFrame: ((frame: CapturedFrame, frameNumber: number) => void | Promise<void>) | null;
+    remotionSharedMemory: RemotionSharedMemoryCapture | null;
     imageFormat: "jpeg" | "none" | "png";
     onError: (err: Error) => void;
     lastFrame: number;