@remotion/renderer 4.0.532 → 4.0.534

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;