@remotion/renderer 4.0.533 → 4.0.535

package/dist/probe-shared-memory-capture.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeSharedMemoryCapture = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const get_local_browser_executable_1 = require("./get-local-browser-executable");
+const open_browser_1 = require("./open-browser");
+const prespawn_ffmpeg_1 = require("./prespawn-ffmpeg");
+const remotion_shared_memory_1 = require("./remotion-shared-memory");
+const probes = new Map();
+const probeSharedMemoryCapture = async ({ browserExecutable, chromeMode, chromiumOptions, binariesDirectory, logLevel, }) => {
+    // Opening the render modal should not download a browser.
+    let executablePath;
+    let executableStat;
+    try {
+        executablePath = (0, get_local_browser_executable_1.getLocalBrowserExecutable)({
+            preferredBrowserExecutable: browserExecutable,
+            chromeMode,
+            indent: false,
+            logLevel,
+        });
+        executableStat = node_fs_1.default.statSync(executablePath);
+    }
+    catch (_a) {
+        return false;
+    }
+    const key = JSON.stringify({
+        executablePath,
+        mtime: executableStat.mtimeMs,
+        ctime: executableStat.ctimeMs,
+        size: executableStat.size,
+        chromeMode,
+        chromiumOptions,
+        binariesDirectory,
+        backend: (0, remotion_shared_memory_1.getPreferredRemotionSharedMemoryBackend)(),
+    });
+    const cached = probes.get(key);
+    if (cached) {
+        return cached;
+    }
+    const probe = (async () => {
+        const support = await (0, prespawn_ffmpeg_1.probeRemotionSharedMemoryFfmpegSupport)({
+            binariesDirectory,
+            indent: false,
+            logLevel,
+        });
+        if (!support.sharedMemory) {
+            return false;
+        }
+        const browser = await (0, open_browser_1.openBrowser)('chrome', {
+            browserExecutable: executablePath,
+            chromeMode,
+            chromiumOptions: { ...chromiumOptions, headless: true },
+            forceDeviceScaleFactor: 1,
+            logLevel,
+        });
+        let backingDirectory = null;
+        let capture = null;
+        try {
+            backingDirectory = support.filePools
+                ? node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'remotion-shm-probe-'))
+                : null;
+            capture = new remotion_shared_memory_1.RemotionSharedMemoryCapture({
+                width: 16,
+                height: 16,
+                indent: false,
+                logLevel,
+                backingDirectory,
+            });
+            const page = await browser.newPage({
+                context: () => null,
+                logLevel,
+                indent: false,
+                pageIndex: 0,
+                onBrowserLog: null,
+                onLog: () => undefined,
+            });
+            await capture.initializePages([page]);
+            return capture.isSupported();
+        }
+        finally {
+            try {
+                await (capture === null || capture === void 0 ? void 0 : capture.dispose());
+            }
+            finally {
+                try {
+                    await browser.close({ silent: true });
+                }
+                finally {
+                    if (backingDirectory !== null) {
+                        node_fs_1.default.rmSync(backingDirectory, { recursive: true, force: true });
+                    }
+                }
+            }
+        }
+    })();
+    probes.set(key, probe);
+    try {
+        return await probe;
+    }
+    catch (_b) {
+        // Keep the screenshot controls if probing fails, and retry next time.
+        probes.delete(key);
+        return false;
+    }
+};
+exports.probeSharedMemoryCapture = probeSharedMemoryCapture;

package/dist/puppeteer-screenshot.d.ts

@@ -1,4 +1,5 @@
 import type { Page } from './browser/BrowserPage';
+import type { CapturedFrame, RemotionSharedMemoryCapture } from './remotion-shared-memory';
 export declare const screenshot: (options: {
     page: Page;
     type: "jpeg" | "pdf" | "png" | "webp";
@@ -8,4 +9,5 @@ export declare const screenshot: (options: {
     width: number;
     height: number;
     scale: number;
-}) => Promise<Buffer>;
+    remotionSharedMemory: RemotionSharedMemoryCapture | null;
+}) => Promise<CapturedFrame>;

package/dist/puppeteer-screenshot.js

@@ -53,6 +53,7 @@ const screenshot = (options) => {
         path: options.path,
         jpegQuality: options.type === 'jpeg' ? options.jpegQuality : undefined,
         scale: options.scale,
+        remotionSharedMemory: options.remotionSharedMemory,
     }));
 };
 exports.screenshot = screenshot;

package/dist/pure.d.ts

@@ -4,7 +4,7 @@ export declare const NoReactAPIs: {
     validateOutputFilename: <T extends "aac" | "av1" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav">({ codec, audioCodecSetting, extension, preferLossless, separateAudioTo, }: {
         codec: T;
         audioCodecSetting: "aac" | "mp3" | "opus" | "pcm-16" | null;
-        extension: string;
+        extension: string | null;
         preferLossless: boolean;
         separateAudioTo: string | null;
     }) => void;

package/dist/remotion-shared-memory-ffmpeg.d.ts

@@ -0,0 +1,26 @@
+import type { Readable, Writable } from 'node:stream';
+import type { RemotionRawFrame } from './remotion-shared-memory';
+export declare const serializeRemotionSharedMemoryPool: (frame: RemotionRawFrame) => string;
+export declare const serializeRemotionSharedMemoryFrame: ({ frame, pts, }: {
+    frame: RemotionRawFrame;
+    pts: number;
+}) => string;
+export declare const serializeRemotionSharedMemoryPoolRetirement: (poolId: number) => string;
+export declare const parseRemotionSharedMemoryAck: (line: string) => {
+    poolId: number;
+    slot: number;
+    frameId: string;
+};
+export declare const createRemotionSharedMemoryFfmpegBridge: ({ control, acknowledgements, }: {
+    control: Writable;
+    acknowledgements: Readable;
+}) => {
+    writeFrame: ({ frame, pts, }: {
+        frame: RemotionRawFrame;
+        pts: number;
+    }) => Promise<{
+        waitForAck: Promise<void>;
+    }>;
+    finish: () => Promise<void>;
+    fail: (error: Error) => void;
+};

package/dist/remotion-shared-memory-ffmpeg.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRemotionSharedMemoryFfmpegBridge = exports.parseRemotionSharedMemoryAck = exports.serializeRemotionSharedMemoryPoolRetirement = exports.serializeRemotionSharedMemoryFrame = exports.serializeRemotionSharedMemoryPool = void 0;
+const node_readline_1 = require("node:readline");
+const write_with_backpressure_1 = require("./write-with-backpressure");
+const pendingKey = (poolId, slot) => `${poolId}:${slot}`;
+// The optional sixth field names the backend. It is omitted for POSIX shared
+// memory so FFmpeg binaries that predate file-backed pools keep working.
+const serializeRemotionSharedMemoryPool = (frame) => `P\t${frame.poolId}\t${frame.sharedMemoryName}\t${frame.slotCount}\t${frame.slotCapacity}${frame.backend === 'file' ? '\tfile' : ''}\n`;
+exports.serializeRemotionSharedMemoryPool = serializeRemotionSharedMemoryPool;
+const serializeRemotionSharedMemoryFrame = ({ frame, pts, }) => `F\t${frame.poolId}\t${frame.slot}\t${frame.frameId}\t${frame.width}\t${frame.height}\t${frame.stride}\t${frame.byteLength}\t${pts}\n`;
+exports.serializeRemotionSharedMemoryFrame = serializeRemotionSharedMemoryFrame;
+const serializeRemotionSharedMemoryPoolRetirement = (poolId) => `U\t${poolId}\n`;
+exports.serializeRemotionSharedMemoryPoolRetirement = serializeRemotionSharedMemoryPoolRetirement;
+const parseRemotionSharedMemoryAck = (line) => {
+    const match = /^(\d+)\t(\d+)\t(\d+)$/.exec(line);
+    if (!match) {
+        throw new Error(`Invalid Remotion shared-memory ACK: ${line}`);
+    }
+    const poolId = Number(match[1]);
+    const slot = Number(match[2]);
+    if (!Number.isSafeInteger(poolId) ||
+        poolId < 1 ||
+        !Number.isSafeInteger(slot) ||
+        slot < 0) {
+        throw new Error(`Invalid Remotion shared-memory ACK: ${line}`);
+    }
+    return { poolId, slot, frameId: match[3] };
+};
+exports.parseRemotionSharedMemoryAck = parseRemotionSharedMemoryAck;
+const createRemotionSharedMemoryFfmpegBridge = ({ control, acknowledgements, }) => {
+    const registeredPools = new Map();
+    const pending = new Map();
+    let fatalError = null;
+    let finishing = false;
+    let controlEnded = false;
+    let controlWrites = Promise.resolve();
+    let finishPromise = null;
+    const toError = (error) => error instanceof Error ? error : new Error(String(error));
+    const releaseIgnoringErrors = async (frame) => {
+        try {
+            await frame.release();
+        }
+        catch (_a) {
+            // The original bridge error is more useful. release() still abandons the
+            // local slot in a finally block if the CDP session is unavailable.
+        }
+    };
+    const settleRegistration = (pool, registered) => {
+        if (pool.registrationSettled) {
+            return;
+        }
+        pool.registrationSettled = true;
+        pool.registered = registered;
+        pool.resolveRegistration(registered);
+    };
+    const signalPoolDrained = (pool) => {
+        if (pool.pendingCount === 0) {
+            pool.drainWaiters.splice(0).forEach((waiter) => waiter());
+        }
+    };
+    const removePending = (key, value) => {
+        if (pending.get(key) !== value) {
+            return false;
+        }
+        pending.delete(key);
+        value.pool.pendingCount--;
+        signalPoolDrained(value.pool);
+        return true;
+    };
+    const fail = (error) => {
+        if (fatalError) {
+            return;
+        }
+        fatalError = error;
+        for (const pool of registeredPools.values()) {
+            settleRegistration(pool, false);
+        }
+        for (const [key, value] of [...pending.entries()]) {
+            if (removePending(key, value)) {
+                value.reject(error);
+                releaseIgnoringErrors(value.frame).catch(() => undefined);
+            }
+        }
+    };
+    const enqueueControlWrite = (data) => {
+        if (finishing || controlEnded) {
+            return Promise.reject(new Error('FFmpeg shared-memory input has already been finished.'));
+        }
+        const operation = controlWrites.then(async () => {
+            if (fatalError) {
+                throw fatalError;
+            }
+            await (0, write_with_backpressure_1.writeWithBackpressure)({
+                data: Buffer.from(data),
+                writable: control,
+            });
+        });
+        controlWrites = operation;
+        return operation;
+    };
+    const unregisterPool = (pool) => {
+        pool.retired = true;
+        if (pool.unregistering) {
+            return pool.unregistering;
+        }
+        pool.unregistering = (async () => {
+            var _a;
+            try {
+                const wasRegistered = await pool.registration;
+                if (!wasRegistered || fatalError || finishing || controlEnded) {
+                    return;
+                }
+                if (pool.pendingCount > 0) {
+                    await new Promise((resolve) => pool.drainWaiters.push(resolve));
+                }
+                if (fatalError || finishing || controlEnded) {
+                    return;
+                }
+                try {
+                    await enqueueControlWrite((0, exports.serializeRemotionSharedMemoryPoolRetirement)(pool.poolId));
+                }
+                catch (error) {
+                    const normalizedError = toError(error);
+                    fail(normalizedError);
+                    throw normalizedError;
+                }
+            }
+            finally {
+                (_a = pool.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(pool);
+                pool.unsubscribe = null;
+                if (registeredPools.get(pool.poolId) === pool) {
+                    registeredPools.delete(pool.poolId);
+                }
+            }
+        })();
+        return pool.unregistering;
+    };
+    const createRegisteredPool = (frame) => {
+        let resolveRegistration;
+        const registration = new Promise((resolve) => {
+            resolveRegistration = resolve;
+        });
+        const pool = {
+            poolId: frame.poolId,
+            sharedMemoryName: frame.sharedMemoryName,
+            poolLifetime: frame.poolLifetime,
+            registered: false,
+            registrationStarted: false,
+            registrationSettled: false,
+            registration,
+            resolveRegistration,
+            retired: false,
+            pendingCount: 0,
+            drainWaiters: [],
+            unregistering: null,
+            unsubscribe: null,
+        };
+        const unsubscribe = frame.poolLifetime.onRetired(() => unregisterPool(pool));
+        if (!unsubscribe) {
+            return null;
+        }
+        pool.unsubscribe = unsubscribe;
+        registeredPools.set(frame.poolId, pool);
+        return pool;
+    };
+    const lines = (0, node_readline_1.createInterface)({ input: acknowledgements });
+    lines.on('line', (line) => {
+        (async () => {
+            const ack = (0, exports.parseRemotionSharedMemoryAck)(line);
+            const key = pendingKey(ack.poolId, ack.slot);
+            const value = pending.get(key);
+            if (!value || value.acknowledged || value.frame.frameId !== ack.frameId) {
+                throw new Error(`Unexpected Remotion shared-memory ACK for ${ack.poolId}:${ack.slot}:${ack.frameId}.`);
+            }
+            // Keep the frame pending until Chromium releases its slot, but stop
+            // counting it as a missing ACK if FFmpeg exits during that release.
+            value.acknowledged = true;
+            try {
+                await value.frame.release();
+            }
+            catch (error) {
+                const normalizedError = toError(error);
+                if (removePending(key, value)) {
+                    value.reject(normalizedError);
+                    fail(normalizedError);
+                }
+                return;
+            }
+            if (removePending(key, value)) {
+                value.resolve();
+            }
+        })().catch((error) => fail(toError(error)));
+    });
+    lines.on('error', (error) => fail(toError(error)));
+    const onAcknowledgementsClosed = () => {
+        const unacknowledgedFrames = [...pending.values()].filter((frame) => !frame.acknowledged).length;
+        if (unacknowledgedFrames > 0 || !finishing) {
+            fail(new Error(`FFmpeg closed its Remotion shared-memory ACK pipe${unacknowledgedFrames > 0 ? ` with ${unacknowledgedFrames} frame(s) pending` : ' before input finished'}.`));
+        }
+    };
+    lines.on('close', onAcknowledgementsClosed);
+    acknowledgements.on('error', (error) => fail(toError(error)));
+    acknowledgements.on('close', onAcknowledgementsClosed);
+    control.on('error', (error) => fail(toError(error)));
+    return {
+        writeFrame: async ({ frame, pts, }) => {
+            if (fatalError) {
+                await releaseIgnoringErrors(frame);
+                throw fatalError;
+            }
+            if (finishing || controlEnded || frame.poolLifetime.isRetired()) {
+                await releaseIgnoringErrors(frame);
+                throw new Error(`Target closed: Remotion shared-memory pool ${frame.poolId} has already been retired.`);
+            }
+            let pool = registeredPools.get(frame.poolId);
+            if (!pool) {
+                const createdPool = createRegisteredPool(frame);
+                if (!createdPool) {
+                    await releaseIgnoringErrors(frame);
+                    throw new Error(`Target closed: Remotion shared-memory pool ${frame.poolId} has already been retired.`);
+                }
+                pool = createdPool;
+            }
+            else if (pool.sharedMemoryName !== frame.sharedMemoryName ||
+                pool.poolLifetime !== frame.poolLifetime) {
+                const error = new Error(`Remotion shared-memory pool ${frame.poolId} changed its identity.`);
+                await releaseIgnoringErrors(frame);
+                fail(error);
+                throw error;
+            }
+            if (pool.retired || frame.poolLifetime.isRetired()) {
+                await releaseIgnoringErrors(frame);
+                throw new Error(`Target closed: Remotion shared-memory pool ${frame.poolId} has already been retired.`);
+            }
+            const key = pendingKey(frame.poolId, frame.slot);
+            if (pending.has(key)) {
+                const error = new Error(`Remotion shared-memory slot ${frame.poolId}:${frame.slot} was reused before its ACK.`);
+                await releaseIgnoringErrors(frame);
+                fail(error);
+                throw error;
+            }
+            let resolveAck;
+            let rejectAck;
+            const ack = new Promise((resolve, reject) => {
+                resolveAck = resolve;
+                rejectAck = reject;
+            });
+            ack.catch(() => undefined);
+            const pendingFrame = {
+                frame,
+                pool,
+                acknowledged: false,
+                resolve: resolveAck,
+                reject: rejectAck,
+            };
+            pending.set(key, pendingFrame);
+            pool.pendingCount++;
+            const registersPool = !pool.registrationStarted;
+            if (registersPool) {
+                pool.registrationStarted = true;
+            }
+            const operation = enqueueControlWrite((registersPool ? (0, exports.serializeRemotionSharedMemoryPool)(frame) : '') +
+                (0, exports.serializeRemotionSharedMemoryFrame)({ frame, pts }));
+            if (registersPool) {
+                operation.then(() => settleRegistration(pool, true), () => settleRegistration(pool, false));
+            }
+            try {
+                await operation;
+            }
+            catch (error) {
+                const normalizedError = toError(error);
+                fail(normalizedError);
+                throw normalizedError;
+            }
+            return { waitForAck: ack };
+        },
+        finish: () => {
+            if (finishPromise) {
+                return finishPromise;
+            }
+            finishing = true;
+            finishPromise = (async () => {
+                try {
+                    await controlWrites;
+                    if (fatalError) {
+                        throw fatalError;
+                    }
+                    await new Promise((resolve, reject) => {
+                        control.end((error) => {
+                            if (error) {
+                                reject(error);
+                            }
+                            else {
+                                resolve();
+                            }
+                        });
+                    });
+                    controlEnded = true;
+                }
+                catch (error) {
+                    const normalizedError = toError(error);
+                    fail(normalizedError);
+                    throw normalizedError;
+                }
+            })();
+            return finishPromise;
+        },
+        fail,
+    };
+};
+exports.createRemotionSharedMemoryFfmpegBridge = createRemotionSharedMemoryFfmpegBridge;

package/dist/remotion-shared-memory.d.ts

@@ -0,0 +1,49 @@
+import type { Page } from './browser/BrowserPage';
+import type { RemotionRawFrame as CdpRemotionRawFrame, RemotionFramePoolBackend } from './browser/devtools-types';
+import { type StillImageFormat } from './image-format';
+import type { LogLevel } from './log-level';
+import type { PixelFormat } from './pixel-format';
+export declare const getPreferredRemotionSharedMemoryBackend: () => "auto" | RemotionFramePoolBackend;
+export type RemotionSharedMemoryPoolLifetime = {
+    isRetired: () => boolean;
+    waitForRetirement: () => Promise<void>;
+    onRetired: (listener: () => Promise<void>) => (() => void) | null;
+};
+export type RemotionRawFrame = CdpRemotionRawFrame & {
+    type: 'remotion-shared-memory';
+    poolId: number;
+    sharedMemoryName: string;
+    backend: RemotionFramePoolBackend;
+    slotCount: number;
+    slotCapacity: number;
+    poolLifetime: RemotionSharedMemoryPoolLifetime;
+    release: () => Promise<void>;
+};
+export type CapturedFrame = Buffer | RemotionRawFrame;
+export declare class RemotionSharedMemoryCapture {
+    #private;
+    constructor(options: {
+        width: number;
+        height: number;
+        indent: boolean;
+        logLevel: LogLevel;
+        backingDirectory: string | null;
+    });
+    isSupported(): boolean;
+    getImageFormat(imageFormat: StillImageFormat): StillImageFormat;
+    setPixelFormat(pixelFormat: PixelFormat): void;
+    initializePages(pages: Page[]): Promise<void>;
+    ensurePage(page: Page): Promise<void>;
+    acquire(page: Page): Promise<{
+        slot: number;
+        frameId: string;
+        fail: () => void;
+        discardPublished: () => Promise<void>;
+        publish: (metadata: CdpRemotionRawFrame) => Promise<RemotionRawFrame>;
+    } | null>;
+    destroy(): Promise<void>;
+    forgetPage(page: Page): Promise<void>;
+    forgetAllPages(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export declare const isRemotionRawFrame: (frame: CapturedFrame) => frame is RemotionRawFrame;