🎥 Make videos programmatically with React
import type {VideoConfig} from 'remotion/no-react';
import {NoReactInternals} from 'remotion/no-react';
import {RenderInternals} from '.';
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 {Page} from './browser/BrowserPage';
import {DEFAULT_TIMEOUT} from './browser/TimeoutSettings';
import {handleJavascriptException} from './error-handling/handle-javascript-exception';
import {findRemotionRoot} from './find-closest-package-json';
import {getPageAndCleanupFn} from './get-browser-instance';
import {Log} from './logger';
import {getAvailableMemory} from './memory/get-available-memory';
import type {ChromiumOptions} from './open-browser';
import type {ToOptions} from './options/option';
import type {optionsMap} from './options/options-map';
import type {RemotionServer} from './prepare-server';
import {makeOrReuseServer} from './prepare-server';
import {puppeteerEvaluateWithCatch} from './puppeteer-evaluate';
import {waitForReady} from './seek-to-frame';
import {setPropsAndEnv} from './set-props-and-env';
import type {RequiredInputPropsInV5} from './v5-required-input-props';
import {validatePuppeteerTimeout} from './validate-puppeteer-timeout';
import {wrapWithErrorHandling} from './wrap-with-error-handling';
type InternalSelectCompositionsConfig = {
serializedInputPropsWithCustomSchema: string;
envVariables: Record<string, string>;
puppeteerInstance: HeadlessBrowser | undefined;
onBrowserLog: null | ((log: BrowserLog) => void);
browserExecutable: BrowserExecutable | null;
chromiumOptions: ChromiumOptions;
port: number | null;
indent: boolean;
server: RemotionServer | undefined;
serveUrl: string;
id: string;
onServeUrlVisited: () => void;
} & ToOptions<typeof optionsMap.selectComposition>;
type Prettify<T> = {
[K in keyof T]: T[K];
} & {};
export type SelectCompositionOptions = Prettify<
RequiredInputPropsInV5 & {
envVariables?: Record<string, string>;
puppeteerInstance?: HeadlessBrowser;
onBrowserLog?: (log: BrowserLog) => void;
browserExecutable?: BrowserExecutable;
chromiumOptions?: ChromiumOptions;
port?: number | null;
/**
* @deprecated Use `logLevel` instead.
*/
verbose?: boolean;
serveUrl: string;
id: string;
} & Partial<ToOptions<typeof optionsMap.selectComposition>>
>;
type CleanupFn = () => Promise<unknown>;
type InnerSelectCompositionConfig = Omit<
InternalSelectCompositionsConfig,
'port' | 'offthreadVideoThreads' | 'onBrowserLog'
> & {
page: Page;
port: number;
};
const innerSelectComposition = async ({
page,
serializedInputPropsWithCustomSchema,
envVariables,
serveUrl,
timeoutInMilliseconds,
port,
id,
indent,
logLevel,
onServeUrlVisited,
mediaCacheSizeInBytes,
chromiumOptions,
}: InnerSelectCompositionConfig): Promise<InternalReturnType> => {
validatePuppeteerTimeout(timeoutInMilliseconds);
await setPropsAndEnv({
serializedInputPropsWithCustomSchema,
envVariables,
page,
serveUrl,
initialFrame: 0,
timeoutInMilliseconds,
proxyPort: port,
retriesRemaining: 2,
audioEnabled: false,
videoEnabled: false,
indent,
logLevel,
onServeUrlVisited,
isMainTab: true,
mediaCacheSizeInBytes,
initialMemoryAvailable: getAvailableMemory(logLevel),
darkMode: chromiumOptions.darkMode ?? false,
sampleRate: 48000,
});
await puppeteerEvaluateWithCatch({
page,
pageFunction: () => {
window.remotion_setBundleMode({
type: 'evaluation',
});
},
frame: null,
args: [],
timeoutInMilliseconds,
});
await waitForReady({
page,
timeoutInMilliseconds,
frame: null,
logLevel,
indent,
});
Log.verbose(
{
indent,
tag: 'selectComposition()',
logLevel,
},
'Running calculateMetadata()...',
);
const time = Date.now();
const {value: result, size} = await puppeteerEvaluateWithCatch({
pageFunction: (_id: string) => {
return window.remotion_calculateComposition(_id);
},
frame: null,
page,
args: [id],
timeoutInMilliseconds,
});
Log.verbose(
{
indent,
tag: 'selectComposition()',
logLevel,
},
`calculateMetadata() took ${Date.now() - time}ms`,
);
const res = result as Awaited<
ReturnType<typeof window.remotion_calculateComposition>
>;
const {
width,
durationInFrames,
fps,
height,
defaultCodec,
defaultOutName,
defaultVideoImageFormat,
defaultPixelFormat,
defaultProResProfile,
defaultSampleRate,
} = res;
return {
metadata: {
id,
width,
height,
fps,
durationInFrames,
props: NoReactInternals.deserializeJSONWithSpecialTypes(
res.serializedResolvedPropsWithCustomSchema,
),
defaultProps: NoReactInternals.deserializeJSONWithSpecialTypes(
res.serializedDefaultPropsWithCustomSchema,
),
defaultCodec,
defaultOutName,
defaultVideoImageFormat,
defaultPixelFormat,
defaultProResProfile,
defaultSampleRate,
},
propsSize: size,
};
};
type InternalReturnType = {
metadata: VideoConfig;
propsSize: number;
};
export const internalSelectCompositionRaw = async (
options: InternalSelectCompositionsConfig,
): Promise<InternalReturnType> => {
const cleanup: CleanupFn[] = [];
const {
puppeteerInstance,
browserExecutable,
chromiumOptions,
serveUrl: serveUrlOrWebpackUrl,
logLevel,
indent,
port,
envVariables,
id,
serializedInputPropsWithCustomSchema,
onBrowserLog,
server,
timeoutInMilliseconds,
offthreadVideoCacheSizeInBytes,
binariesDirectory,
onBrowserDownload,
onServeUrlVisited,
chromeMode,
mediaCacheSizeInBytes,
} = options;
const [{page, cleanupPage}, serverUsed] = await Promise.all([
getPageAndCleanupFn({
passedInInstance: puppeteerInstance,
browserExecutable,
chromiumOptions,
forceDeviceScaleFactor: undefined,
indent,
logLevel,
onBrowserDownload,
chromeMode,
pageIndex: 0,
onBrowserLog,
onLog: RenderInternals.defaultOnLog,
}),
makeOrReuseServer(
options.server,
{
webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
port,
remotionRoot: findRemotionRoot(),
offthreadVideoThreads: 0,
logLevel,
indent,
offthreadVideoCacheSizeInBytes,
binariesDirectory,
forceIPv4: false,
sampleRate: 48000,
},
{
onDownload: () => undefined,
},
).then((result) => {
cleanup.push(() => result.cleanupServer(true));
return result;
}),
]);
cleanup.push(() => cleanupPage());
return new Promise<InternalReturnType>((resolve, reject) => {
const onError = (err: Error) => reject(err);
cleanup.push(
handleJavascriptException({
page,
frame: null,
onError,
}),
);
page.setBrowserSourceMapGetter(serverUsed.server.sourceMap);
innerSelectComposition({
serveUrl: serverUsed.server.serveUrl,
page,
port: serverUsed.server.offthreadPort,
browserExecutable,
chromiumOptions,
envVariables,
id,
serializedInputPropsWithCustomSchema,
timeoutInMilliseconds,
logLevel,
indent,
puppeteerInstance,
server,
offthreadVideoCacheSizeInBytes,
binariesDirectory,
onBrowserDownload,
onServeUrlVisited,
chromeMode,
mediaCacheSizeInBytes,
})
.then((data) => {
return resolve(data);
})
.catch((err) => {
reject(err);
})
.finally(() => {
cleanup.forEach((c) => {
// Must prevent unhandled exception in cleanup function.
// Promise has already been resolved, so we can't reject it.
c().catch((err) => {
Log.error({indent, logLevel}, 'Cleanup error:', err);
});
});
});
});
};
export const internalSelectComposition = wrapWithErrorHandling(
internalSelectCompositionRaw,
);
/*
* @description Evaluates the list of compositions from a Remotion Bundle by evaluating the Remotion Root and evaluating `calculateMetadata()` on the specified composition.
* @see [Documentation](https://www.remotion.dev/docs/renderer/select-composition)
*/
export const selectComposition = async (
options: SelectCompositionOptions,
): Promise<VideoConfig> => {
const {
id,
serveUrl,
browserExecutable,
chromiumOptions,
envVariables,
inputProps,
onBrowserLog,
port,
puppeteerInstance,
timeoutInMilliseconds,
verbose,
logLevel: passedLogLevel,
offthreadVideoCacheSizeInBytes,
binariesDirectory,
onBrowserDownload,
chromeMode,
offthreadVideoThreads,
mediaCacheSizeInBytes,
} = options;
const indent = false;
const logLevel = passedLogLevel ?? (verbose ? 'verbose' : 'info');
const data = await internalSelectComposition({
id,
serveUrl,
browserExecutable: browserExecutable ?? null,
chromiumOptions: chromiumOptions ?? {},
envVariables: envVariables ?? {},
serializedInputPropsWithCustomSchema:
NoReactInternals.serializeJSONWithSpecialTypes({
indent: undefined,
staticBase: null,
data: inputProps ?? {},
}).serializedString,
onBrowserLog: onBrowserLog ?? null,
port: port ?? null,
puppeteerInstance,
timeoutInMilliseconds: timeoutInMilliseconds ?? DEFAULT_TIMEOUT,
logLevel,
indent,
server: undefined,
offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes ?? null,
binariesDirectory: binariesDirectory ?? null,
onBrowserDownload:
onBrowserDownload ??
defaultBrowserDownloadProgress({
indent,
logLevel,
api: 'selectComposition()',
}),
onServeUrlVisited: () => undefined,
chromeMode: chromeMode ?? 'headless-shell',
offthreadVideoThreads: offthreadVideoThreads ?? null,
mediaCacheSizeInBytes: mediaCacheSizeInBytes ?? null,
});
return data.metadata;
};