🎥 Make videos programmatically with React
import {createInterface} from 'node:readline';
import type {Readable, Writable} from 'node:stream';
import type {
RemotionRawFrame,
RemotionSharedMemoryPoolLifetime,
} from './remotion-shared-memory';
import {writeWithBackpressure} from './write-with-backpressure';
type RegisteredPool = {
poolId: number;
sharedMemoryName: string;
poolLifetime: RemotionSharedMemoryPoolLifetime;
registered: boolean;
registrationStarted: boolean;
registrationSettled: boolean;
registration: Promise<boolean>;
resolveRegistration: (registered: boolean) => void;
retired: boolean;
pendingCount: number;
drainWaiters: Array<() => void>;
unregistering: Promise<void> | null;
unsubscribe: (() => void) | null;
};
type PendingFrame = {
frame: RemotionRawFrame;
pool: RegisteredPool;
acknowledged: boolean;
resolve: () => void;
reject: (error: Error) => void;
};
const pendingKey = (poolId: number, slot: number) => `${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.
export const serializeRemotionSharedMemoryPool = (frame: RemotionRawFrame) =>
`P\t${frame.poolId}\t${frame.sharedMemoryName}\t${frame.slotCount}\t${frame.slotCapacity}${frame.backend === 'file' ? '\tfile' : ''}\n`;
export const serializeRemotionSharedMemoryFrame = ({
frame,
pts,
}: {
frame: RemotionRawFrame;
pts: number;
}) =>
`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`;
export const serializeRemotionSharedMemoryPoolRetirement = (poolId: number) =>
`U\t${poolId}\n`;
export const parseRemotionSharedMemoryAck = (line: string) => {
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]};
};
export const createRemotionSharedMemoryFfmpegBridge = ({
control,
acknowledgements,
}: {
control: Writable;
acknowledgements: Readable;
}) => {
const registeredPools = new Map<number, RegisteredPool>();
const pending = new Map<string, PendingFrame>();
let fatalError: Error | null = null;
let finishing = false;
let controlEnded = false;
let controlWrites = Promise.resolve();
let finishPromise: Promise<void> | null = null;
const toError = (error: unknown) =>
error instanceof Error ? error : new Error(String(error));
const releaseIgnoringErrors = async (frame: RemotionRawFrame) => {
try {
await frame.release();
} catch {
// 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: RegisteredPool, registered: boolean) => {
if (pool.registrationSettled) {
return;
}
pool.registrationSettled = true;
pool.registered = registered;
pool.resolveRegistration(registered);
};
const signalPoolDrained = (pool: RegisteredPool) => {
if (pool.pendingCount === 0) {
pool.drainWaiters.splice(0).forEach((waiter) => waiter());
}
};
const removePending = (key: string, value: PendingFrame) => {
if (pending.get(key) !== value) {
return false;
}
pending.delete(key);
value.pool.pendingCount--;
signalPoolDrained(value.pool);
return true;
};
const fail = (error: 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: string) => {
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 writeWithBackpressure({
data: Buffer.from(data),
writable: control,
});
});
controlWrites = operation;
return operation;
};
const unregisterPool = (pool: RegisteredPool) => {
pool.retired = true;
if (pool.unregistering) {
return pool.unregistering;
}
pool.unregistering = (async () => {
try {
const wasRegistered = await pool.registration;
if (!wasRegistered || fatalError || finishing || controlEnded) {
return;
}
if (pool.pendingCount > 0) {
await new Promise<void>((resolve) => pool.drainWaiters.push(resolve));
}
if (fatalError || finishing || controlEnded) {
return;
}
try {
await enqueueControlWrite(
serializeRemotionSharedMemoryPoolRetirement(pool.poolId),
);
} catch (error) {
const normalizedError = toError(error);
fail(normalizedError);
throw normalizedError;
}
} finally {
pool.unsubscribe?.();
pool.unsubscribe = null;
if (registeredPools.get(pool.poolId) === pool) {
registeredPools.delete(pool.poolId);
}
}
})();
return pool.unregistering;
};
const createRegisteredPool = (frame: RemotionRawFrame) => {
let resolveRegistration!: (registered: boolean) => void;
const registration = new Promise<boolean>((resolve) => {
resolveRegistration = resolve;
});
const pool: RegisteredPool = {
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 = createInterface({input: acknowledgements});
lines.on('line', (line) => {
(async () => {
const ack = 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,
}: {
frame: RemotionRawFrame;
pts: number;
}) => {
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!: () => void;
let rejectAck!: (error: Error) => void;
const ack = new Promise<void>((resolve, reject) => {
resolveAck = resolve;
rejectAck = reject;
});
ack.catch(() => undefined);
const pendingFrame: 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 ? serializeRemotionSharedMemoryPool(frame) : '') +
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<void>((resolve, reject) => {
control.end((error?: Error | null) => {
if (error) {
reject(error);
} else {
resolve();
}
});
});
controlEnded = true;
} catch (error) {
const normalizedError = toError(error);
fail(normalizedError);
throw normalizedError;
}
})();
return finishPromise;
},
fail,
};
};