🎥 Make videos programmatically with React
import fs from 'node:fs';
import path from 'node:path';
import type {
AudioOrVideoAsset,
InlineAudioAsset,
VideoConfig,
} from 'remotion/no-react';
import {NoReactInternals} from 'remotion/no-react';
import type {RenderMediaOnDownload} from './assets/download-and-map-assets-to-file';
import type {DownloadMap} from './assets/download-map';
import {DEFAULT_BROWSER} from './browser';
import type {BrowserExecutable} from './browser-executable';
import type {BrowserLog} from './browser-log';
import type {HeadlessBrowser} from './browser/Browser';
import {defaultBrowserDownloadProgress} from './browser/browser-download-progress-bar';
import type {OnLog, Page} from './browser/BrowserPage';
import {isTargetClosedErr} from './browser/flaky-errors';
import type {SourceMapGetter} from './browser/source-map-getter';
import {DEFAULT_TIMEOUT} from './browser/TimeoutSettings';
import {cycleBrowserTabs} from './cycle-browser-tabs';
import {defaultOnLog} from './default-on-log';
import {findRemotionRoot} from './find-closest-package-json';
import {isMultipleFrameRanges, type FrameRange} from './frame-range';
import {resolveConcurrency} from './get-concurrency';
import {getFramesToRender} from './get-duration-from-frame-range';
import {getExtraFramesToCapture} from './get-extra-frames-to-capture';
import type {CountType} from './get-frame-padded-index';
import {getFilePadLength} from './get-frame-padded-index';
import {getRealFrameRanges} from './get-frame-to-render';
import type {VideoImageFormat} from './image-format';
import {DEFAULT_JPEG_QUALITY, validateJpegQuality} from './jpeg-quality';
import type {LogLevel} from './log-level';
import {Log} from './logger';
import type {CancelSignal} from './make-cancel-signal';
import {cancelErrorMessages} from './make-cancel-signal';
import {makePage} from './make-page';
import {nextFrameToRenderState} from './next-frame-to-render';
import type {ChromiumOptions} from './open-browser';
import {internalOpenBrowser} from './open-browser';
import {DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS} from './options/offthreadvideo-threads';
import type {ToOptions} from './options/option';
import type {optionsMap} from './options/options-map';
import {Pool} from './pool';
import type {RemotionServer} from './prepare-server';
import {makeOrReuseServer} from './prepare-server';
import type {
CapturedFrame,
RemotionSharedMemoryCapture,
} from './remotion-shared-memory';
import {renderFrameAndRetryTargetClose} from './render-frame-and-retry-target-close';
import type {BrowserReplacer} from './replace-browser';
import {handleBrowserCrash} from './replace-browser';
import type {EmittedArtifact} from './serialize-artifact';
import type {OnStartData, RenderFramesOutput} from './types';
import {
validateDimension,
validateDurationInFrames,
validateFps,
} from './validate';
import {validateScale} from './validate-scale';
import {validateSelectedFrames} from './validate-selected-frames';
import {wrapWithErrorHandling} from './wrap-with-error-handling';
const MAX_RETRIES_PER_FRAME = 1;
export type OnArtifact = (asset: EmittedArtifact) => void;
type InternalRenderFramesOptions = {
onStart: null | ((data: OnStartData) => void);
onFrameUpdate:
| null
| ((
framesRendered: number,
frameIndex: number,
timeToRenderInMilliseconds: number,
) => void);
outputDir: string | null;
envVariables: Record<string, string>;
imageFormat: VideoImageFormat;
jpegQuality: number;
frameRange: FrameRange | null;
frames: number[] | null;
outputFramesInSequence: boolean;
everyNthFrame: number;
puppeteerInstance: HeadlessBrowser | undefined;
browserExecutable: BrowserExecutable | null;
onBrowserLog: null | ((log: BrowserLog) => void);
onFrameBuffer:
| null
| ((buffer: Buffer, frame: number) => void | Promise<void>);
onFrame:
| null
| ((frame: CapturedFrame, frameNumber: number) => void | Promise<void>);
remotionSharedMemory: RemotionSharedMemoryCapture | null;
onDownload: RenderMediaOnDownload | null;
chromiumOptions: ChromiumOptions;
scale: number;
port: number | null;
cancelSignal: CancelSignal | undefined;
composition: Omit<VideoConfig, 'props' | 'defaultProps'>;
indent: boolean;
server: RemotionServer | undefined;
muted: boolean;
concurrency: number | string | null;
webpackBundleOrServeUrl: string;
serializedInputPropsWithCustomSchema: string;
serializedResolvedPropsWithCustomSchema: string;
parallelEncodingEnabled: boolean;
compositionStart: number;
onArtifact: OnArtifact | null;
onLog: OnLog;
} & ToOptions<typeof optionsMap.renderFrames>;
type InnerRenderFramesOptions = {
onStart: null | ((data: OnStartData) => void);
onFrameUpdate:
| null
| ((
framesRendered: number,
frameIndex: number,
timeToRenderInMilliseconds: number,
) => void);
outputDir: string | null;
envVariables: Record<string, string>;
imageFormat: VideoImageFormat;
frameRange: FrameRange | null;
frames: number[] | null;
outputFramesInSequence: boolean;
everyNthFrame: number;
onBrowserLog: null | ((log: BrowserLog) => void);
onFrameBuffer:
| null
| ((buffer: Buffer, frame: number) => void | Promise<void>);
onFrame:
| null
| ((frame: CapturedFrame, frameNumber: number) => void | Promise<void>);
remotionSharedMemory: RemotionSharedMemoryCapture | null;
onArtifact: OnArtifact | null;
onDownload: RenderMediaOnDownload | null;
timeoutInMilliseconds: number;
scale: number;
cancelSignal: CancelSignal | undefined;
composition: Omit<VideoConfig, 'props' | 'defaultProps'>;
muted: boolean;
onError: (err: Error) => void;
pagesArray: Page[];
resolvedConcurrency: number;
proxyPort: number;
downloadMap: DownloadMap;
makeBrowser: () => Promise<HeadlessBrowser>;
browserReplacer: BrowserReplacer;
sourceMapGetter: SourceMapGetter;
serveUrl: string;
indent: boolean;
serializedInputPropsWithCustomSchema: string;
serializedResolvedPropsWithCustomSchema: string;
parallelEncodingEnabled: boolean;
compositionStart: number;
binariesDirectory: string | null;
onLog: OnLog;
darkMode: boolean;
} & ToOptions<typeof optionsMap.renderFrames>;
type ArtifactWithoutContent = {
frame: number;
filename: string;
};
export type FrameAndAssets = {
frame: number;
audioAndVideoAssets: AudioOrVideoAsset[];
artifactAssets: ArtifactWithoutContent[];
inlineAudioAssets: InlineAudioAsset[];
};
export type AssetIndex = {
firstAssetBySrc: Map<string, AudioOrVideoAsset>;
firstArtifactFrameByFilename: Map<string, number>;
};
type Prettify<T> = {
[K in keyof T]: T[K];
} & {};
export type RenderFramesOptions = Prettify<
{
onStart: (data: OnStartData) => void;
onFrameUpdate: (
framesRendered: number,
frameIndex: number,
timeToRenderInMilliseconds: number,
) => void;
outputDir: string | null;
inputProps: Record<string, unknown>;
envVariables?: Record<string, string>;
imageFormat?: VideoImageFormat;
/**
* @deprecated Renamed to "jpegQuality"
*/
quality?: never;
frameRange?: FrameRange | null;
frames?: number[];
everyNthFrame?: number;
/**
* @deprecated Use "logLevel": "verbose" instead
*/
dumpBrowserLogs?: boolean;
/**
* @deprecated Use "logLevel" instead
*/
verbose?: boolean;
puppeteerInstance?: HeadlessBrowser;
browserExecutable?: BrowserExecutable;
onBrowserLog?: (log: BrowserLog) => void;
onFrameBuffer?: (buffer: Buffer, frame: number) => void | Promise<void>;
onDownload?: RenderMediaOnDownload;
timeoutInMilliseconds?: number;
chromiumOptions?: ChromiumOptions;
scale?: number;
port?: number | null;
cancelSignal?: CancelSignal;
composition: VideoConfig;
muted?: boolean;
concurrency?: number | string | null;
onArtifact?: OnArtifact | null;
serveUrl: string;
} & Partial<ToOptions<typeof optionsMap.renderFrames>>
>;
const innerRenderFrames = async ({
onFrameUpdate,
outputDir,
onStart,
serializedInputPropsWithCustomSchema,
serializedResolvedPropsWithCustomSchema,
jpegQuality,
imageFormat,
frameRange,
frames,
outputFramesInSequence,
onError,
envVariables,
onBrowserLog,
onFrameBuffer,
onFrame,
remotionSharedMemory,
onDownload,
pagesArray,
serveUrl,
composition,
timeoutInMilliseconds,
scale,
resolvedConcurrency,
everyNthFrame,
proxyPort,
cancelSignal,
downloadMap,
muted,
makeBrowser,
browserReplacer,
sourceMapGetter,
logLevel,
indent,
parallelEncodingEnabled,
compositionStart,
forSeamlessAacConcatenation,
onArtifact,
binariesDirectory,
imageSequencePattern,
mediaCacheSizeInBytes,
onLog,
darkMode,
sampleRate,
}: Omit<
InnerRenderFramesOptions,
'offthreadVideoCacheSizeInBytes'
>): Promise<RenderFramesOutput> => {
if (outputDir) {
if (!fs.existsSync(outputDir)) {
fs.mkdirSync(outputDir, {
recursive: true,
});
}
}
const downloadPromises: Promise<unknown>[] = [];
const framesToRender = frames
? validateSelectedFrames({
frames,
durationInFrames: composition.durationInFrames,
})
: getFramesToRender(
getRealFrameRanges(composition.durationInFrames, frameRange),
everyNthFrame,
);
const realFrameRange: [number, number] = [
framesToRender[0],
framesToRender[framesToRender.length - 1],
];
const {
extraFramesToCaptureAssetsBackend,
extraFramesToCaptureAssetsFrontend,
chunkLengthInSeconds: seamlessChunkLengthInSeconds,
trimLeftOffset,
trimRightOffset,
} = getExtraFramesToCapture({
fps: composition.fps,
compositionStart,
realFrameRange,
forSeamlessAacConcatenation,
sampleRate,
});
const chunkLengthInSeconds = forSeamlessAacConcatenation
? seamlessChunkLengthInSeconds
: framesToRender.length / composition.fps;
const lastFrame = framesToRender[framesToRender.length - 1];
const concurrencyOrFramesToRender = Math.min(
framesToRender.length,
resolvedConcurrency,
);
const makeNewPage = async (frame: number, pageIndex: number) => {
const page = await makePage({
context: sourceMapGetter,
initialFrame: frame,
browserReplacer,
indent,
logLevel,
onBrowserLog,
pagesArray,
scale,
composition,
envVariables,
imageFormat,
muted,
proxyPort,
serializedInputPropsWithCustomSchema,
serializedResolvedPropsWithCustomSchema,
serveUrl,
timeoutInMilliseconds,
pageIndex,
isMainTab: pageIndex === 0,
mediaCacheSizeInBytes,
onLog,
darkMode,
sampleRate,
});
await remotionSharedMemory?.ensurePage(page);
return page;
};
const getPool = async () => {
const pages = new Array(concurrencyOrFramesToRender)
.fill(true)
// TODO: Change different initial frame
.map((_, i) => makeNewPage(framesToRender[i], i));
const puppeteerPages = await Promise.all(pages);
const pool = new Pool(puppeteerPages);
return pool;
};
// If rendering a GIF and skipping frames, we must ensure it starts from 0
// and then is consecutive so FFMPEG recognizes the sequence
const countType: CountType = outputFramesInSequence
? 'from-zero'
: everyNthFrame === 1
? 'actual-frames'
: 'from-zero';
const filePadLength = getFilePadLength({
lastFrame,
totalFrames: framesToRender.length,
countType,
});
const framesRenderedObj = {
count: 0,
};
const poolPromise = getPool();
onStart?.({
frameCount: framesToRender.length,
parallelEncoding: parallelEncodingEnabled,
resolvedConcurrency,
});
const assets: FrameAndAssets[] = [];
const assetIndex: AssetIndex = {
firstAssetBySrc: new Map(),
firstArtifactFrameByFilename: new Map(),
};
const stoppedSignal = {stopped: false};
cancelSignal?.(() => {
stoppedSignal.stopped = true;
});
const frameDir = outputDir ?? downloadMap.compositingDir;
// Render the extra frames at the beginning of the video first,
// then the regular frames, then the extra frames at the end of the video.
// While the order technically doesn't matter, components such as <Html5Video> are
// not always frame perfect and give a flicker.
// We reduce the chance of flicker by rendering the frames in order.
const allFramesAndExtraFrames = [
...extraFramesToCaptureAssetsFrontend,
...framesToRender,
...extraFramesToCaptureAssetsBackend,
];
const nextFrameToRender = nextFrameToRenderState({
allFramesAndExtraFrames,
});
const pattern = imageSequencePattern || `element-[frame].[ext]`;
const imageSequenceName = pattern
.replace(/\[frame\]/g, `%0${filePadLength}d`)
.replace(/\[ext\]/g, imageFormat);
await Promise.all(
allFramesAndExtraFrames.map(() => {
return renderFrameAndRetryTargetClose({
retriesLeft: MAX_RETRIES_PER_FRAME,
attempt: 1,
assets,
assetIndex,
binariesDirectory,
cancelSignal,
composition,
countType,
downloadMap,
frameDir,
framesToRender,
imageFormat,
indent,
jpegQuality,
logLevel,
onArtifact,
onDownload,
onError,
outputDir,
poolPromise,
scale,
stoppedSignal,
timeoutInMilliseconds,
makeBrowser,
browserReplacer,
concurrencyOrFramesToRender,
framesRenderedObj,
lastFrame,
makeNewPage,
onFrameBuffer,
onFrame,
remotionSharedMemory,
onFrameUpdate,
nextFrameToRender,
imageSequencePattern: pattern,
trimLeftOffset,
trimRightOffset,
allFramesAndExtraFrames,
});
}),
);
const firstFrameIndex = countType === 'from-zero' ? 0 : framesToRender[0];
await Promise.all(downloadPromises);
return {
assetsInfo: {
assets: assets.sort((a, b) => {
return a.frame - b.frame;
}),
imageSequenceName: path.join(frameDir, imageSequenceName),
firstFrameIndex,
downloadMap,
trimLeftOffset,
trimRightOffset,
chunkLengthInSeconds,
forSeamlessAacConcatenation,
},
frameCount: framesToRender.length,
};
};
type CleanupFn = () => Promise<unknown>;
const internalRenderFramesRaw = ({
browserExecutable,
cancelSignal,
chromiumOptions,
composition,
concurrency,
envVariables,
everyNthFrame,
frameRange,
frames,
outputFramesInSequence,
imageFormat,
indent,
jpegQuality,
muted,
onBrowserLog,
onDownload,
onFrameBuffer,
onFrame,
remotionSharedMemory,
onFrameUpdate,
onStart,
outputDir,
port,
puppeteerInstance,
scale,
server,
timeoutInMilliseconds,
logLevel,
webpackBundleOrServeUrl,
serializedInputPropsWithCustomSchema,
serializedResolvedPropsWithCustomSchema,
offthreadVideoCacheSizeInBytes,
parallelEncodingEnabled,
binariesDirectory,
forSeamlessAacConcatenation,
compositionStart,
onBrowserDownload,
onArtifact,
chromeMode,
offthreadVideoThreads,
imageSequencePattern,
mediaCacheSizeInBytes,
onLog,
sampleRate,
}: InternalRenderFramesOptions): Promise<RenderFramesOutput> => {
validateDimension(
composition.height,
'height',
'in the `config` object passed to `renderFrames()`',
);
validateDimension(
composition.width,
'width',
'in the `config` object passed to `renderFrames()`',
);
validateFps(
composition.fps,
'in the `config` object of `renderFrames()`',
false,
);
validateDurationInFrames(composition.durationInFrames, {
component: 'in the `config` object passed to `renderFrames()`',
allowFloats: false,
});
validateJpegQuality(jpegQuality);
validateScale(scale);
const makeBrowser = () =>
internalOpenBrowser({
browser: DEFAULT_BROWSER,
browserExecutable,
chromiumOptions,
forceDeviceScaleFactor: scale,
indent,
viewport: null,
logLevel,
onBrowserDownload,
chromeMode,
});
const browserInstance = puppeteerInstance ?? makeBrowser();
const resolvedConcurrency = resolveConcurrency(concurrency);
const openedPages: Page[] = [];
return new Promise<RenderFramesOutput>((resolve, reject) => {
const cleanup: CleanupFn[] = [];
const onError = (err: Error) => {
reject(err);
};
Promise.race([
new Promise<RenderFramesOutput>((_, rej) => {
cancelSignal?.(() => {
rej(new Error(cancelErrorMessages.renderFrames));
});
}),
Promise.all([
makeOrReuseServer(
server,
{
webpackConfigOrServeUrl: webpackBundleOrServeUrl,
port,
remotionRoot: findRemotionRoot(),
offthreadVideoThreads:
offthreadVideoThreads ??
DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS,
logLevel,
indent,
offthreadVideoCacheSizeInBytes,
binariesDirectory,
forceIPv4: false,
sampleRate,
},
{
onDownload,
},
),
browserInstance,
]).then(([{server: openedServer, cleanupServer}, pInstance]) => {
const {serveUrl, offthreadPort, sourceMap, downloadMap} = openedServer;
const browserReplacer = handleBrowserCrash(pInstance, logLevel, indent);
const cycle = cycleBrowserTabs({
puppeteerInstance: browserReplacer,
concurrency: resolvedConcurrency,
logLevel,
indent,
});
cleanup.push(() => {
cycle.stopCycling();
return Promise.resolve();
});
cleanup.push(() => cleanupServer(false));
return innerRenderFrames({
onError,
pagesArray: openedPages,
serveUrl,
composition,
resolvedConcurrency,
onDownload,
proxyPort: offthreadPort,
makeBrowser,
browserReplacer,
sourceMapGetter: sourceMap,
downloadMap,
cancelSignal,
envVariables,
everyNthFrame,
frameRange,
frames,
outputFramesInSequence,
imageFormat,
jpegQuality,
muted,
onBrowserLog,
onFrameBuffer,
onFrame,
remotionSharedMemory,
onFrameUpdate,
onStart,
outputDir,
scale,
timeoutInMilliseconds,
logLevel,
indent,
serializedInputPropsWithCustomSchema,
serializedResolvedPropsWithCustomSchema,
parallelEncodingEnabled,
binariesDirectory,
forSeamlessAacConcatenation,
compositionStart,
onBrowserDownload,
onArtifact,
chromeMode,
offthreadVideoThreads,
imageSequencePattern,
mediaCacheSizeInBytes,
onLog,
darkMode: chromiumOptions.darkMode ?? false,
sampleRate,
});
}),
])
.then((res) => {
if (!server || server.compositor.pid === null) {
return resolve(res);
}
server.compositor
.executeCommand('CloseAllVideos', {})
.then(() => {
Log.verbose(
{indent, logLevel, tag: 'compositor'},
'Freed memory from compositor',
);
})
.catch((err) => {
Log.verbose({indent, logLevel}, 'Could not close compositor', err);
});
return resolve(res);
})
.catch((err) => reject(err))
.finally(() => {
// If browser instance was passed in, we close all the pages
// we opened.
// If new browser was opened, then closing the browser as a cleanup.
if (puppeteerInstance) {
Promise.all(openedPages.map((p) => p.close())).catch((err) => {
if (isTargetClosedErr(err)) {
return;
}
Log.error({indent, logLevel}, 'Unable to close browser tab', err);
});
} else {
Promise.resolve(browserInstance)
.then((instance) => {
return instance.close({silent: true});
})
.catch((err) => {
if (
!(err as Error | undefined)?.message.includes('Target closed')
) {
Log.error({indent, logLevel}, 'Unable to close browser', err);
}
});
}
cleanup.forEach((c) => {
c();
});
// Don't clear download dir because it might be used by stitchFramesToVideo
});
});
};
export const internalRenderFrames = wrapWithErrorHandling(
internalRenderFramesRaw,
);
/*
* @description Renders a series of images using Puppeteer and computes information for mixing audio.
* @see [Documentation](https://www.remotion.dev/docs/renderer/render-frames)
*/
export const renderFrames = (
options: RenderFramesOptions,
): Promise<RenderFramesOutput> => {
const {
composition,
inputProps,
onFrameUpdate,
onStart,
outputDir,
serveUrl,
browserExecutable,
cancelSignal,
chromiumOptions,
concurrency,
dumpBrowserLogs,
envVariables,
everyNthFrame,
frameRange,
frames,
imageFormat,
jpegQuality,
muted,
onBrowserLog,
onDownload,
onFrameBuffer,
port,
puppeteerInstance,
scale,
timeoutInMilliseconds,
verbose,
quality,
logLevel: passedLogLevel,
offthreadVideoCacheSizeInBytes,
binariesDirectory,
onBrowserDownload,
onArtifact,
chromeMode,
offthreadVideoThreads,
imageSequencePattern,
mediaCacheSizeInBytes,
sampleRate,
} = options;
if (!composition) {
throw new Error(
'No `composition` option has been specified for renderFrames()',
);
}
if (frames !== undefined && frameRange !== undefined && frameRange !== null) {
throw new Error(
'The `frames` and `frameRange` options are mutually exclusive.',
);
}
if (frames !== undefined && everyNthFrame !== undefined) {
throw new Error(
'The `frames` and `everyNthFrame` options are mutually exclusive.',
);
}
const validatedFrames =
frames === undefined
? null
: validateSelectedFrames({
frames,
durationInFrames: composition.durationInFrames,
});
if (typeof jpegQuality !== 'undefined' && imageFormat !== 'jpeg') {
throw new Error(
"You can only pass the `quality` option if `imageFormat` is 'jpeg'.",
);
}
const logLevel: LogLevel =
verbose || dumpBrowserLogs ? 'verbose' : (passedLogLevel ?? 'info');
const indent = false;
if (quality) {
Log.warn(
{indent, logLevel},
'Passing `quality()` to `renderStill` is deprecated. Use `jpegQuality` instead.',
);
}
return internalRenderFrames({
browserExecutable: browserExecutable ?? null,
cancelSignal,
chromiumOptions: chromiumOptions ?? {},
composition,
concurrency: concurrency ?? null,
envVariables: envVariables ?? {},
everyNthFrame: everyNthFrame ?? 1,
frameRange: frameRange ?? null,
frames: validatedFrames,
outputFramesInSequence:
frameRange !== undefined &&
frameRange !== null &&
isMultipleFrameRanges(frameRange),
imageFormat: imageFormat ?? 'jpeg',
indent,
jpegQuality: jpegQuality ?? DEFAULT_JPEG_QUALITY,
onDownload: onDownload ?? null,
serializedInputPropsWithCustomSchema:
NoReactInternals.serializeJSONWithSpecialTypes({
indent: undefined,
staticBase: null,
data: inputProps ?? {},
}).serializedString,
serializedResolvedPropsWithCustomSchema:
NoReactInternals.serializeJSONWithSpecialTypes({
indent: undefined,
staticBase: null,
data: composition.props,
}).serializedString,
puppeteerInstance,
muted: muted ?? false,
onBrowserLog: onBrowserLog ?? null,
onFrameBuffer: onFrameBuffer ?? null,
onFrame: null,
remotionSharedMemory: null,
onFrameUpdate,
onStart,
outputDir,
port: port ?? null,
scale: scale ?? 1,
logLevel,
timeoutInMilliseconds: timeoutInMilliseconds ?? DEFAULT_TIMEOUT,
webpackBundleOrServeUrl: serveUrl,
server: undefined,
offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes ?? null,
parallelEncodingEnabled: false,
binariesDirectory: binariesDirectory ?? null,
compositionStart: 0,
forSeamlessAacConcatenation: false,
onBrowserDownload:
onBrowserDownload ??
defaultBrowserDownloadProgress({indent, logLevel, api: 'renderFrames()'}),
onArtifact: onArtifact ?? null,
chromeMode: chromeMode ?? 'headless-shell',
offthreadVideoThreads: offthreadVideoThreads ?? null,
imageSequencePattern: imageSequencePattern ?? null,
mediaCacheSizeInBytes: mediaCacheSizeInBytes ?? null,
onLog: defaultOnLog,
sampleRate: sampleRate ?? composition.defaultSampleRate ?? 48000,
});
};