🎥 Make videos programmatically with React
import {
type CancelSignal,
type DownloadBrowserProgressFn,
type RenderMediaProgress,
ensureBrowser,
renderMedia,
selectComposition,
} from "@remotion/renderer";
import {rm} from "node:fs/promises";
import path from "node:path";
import {
RENDER_CANCELLED_MESSAGE,
type RenderResult,
type RenderUpdate,
} from "./electron-api";
import {getCompositorPackage} from "./compositor-package";
import {
bundleRemotionProject,
getPrebuiltRemotionBundlePath,
hasPrebuiltRemotionBundle,
} from "./remotion-bundle";
import {getPackagedBrowserPaths} from "./packaged-browser";
import type {HelloWorldProps} from "../remotion/types";
const compositionId = "HelloWorld";
function isRenderCancelledError(error: unknown): boolean {
return error instanceof Error && error.message === RENDER_CANCELLED_MESSAGE;
}
function getBinariesDirectory({
isPackaged,
projectRoot,
}: {
isPackaged: boolean;
projectRoot: string;
}): string | null {
if (!isPackaged) {
return null;
}
const compositorPackage = getCompositorPackage({
arch: process.arch,
platform: process.platform,
});
return path.join(
path.dirname(projectRoot),
"app.asar.unpacked",
"node_modules",
compositorPackage,
);
}
async function getServeUrl({
isPackaged,
projectRoot,
onUpdate,
}: {
isPackaged: boolean;
projectRoot: string;
onUpdate?: (update: RenderUpdate) => void;
}): Promise<string> {
if (isPackaged) {
if (!hasPrebuiltRemotionBundle(projectRoot)) {
throw new Error(
"The packaged app is missing its prebuilt Remotion bundle. Rebuild the Electron app.",
);
}
onUpdate?.({
type: "status",
message: "Using the prebuilt Remotion bundle from the packaged app...",
});
return getPrebuiltRemotionBundlePath(projectRoot);
}
onUpdate?.({
type: "status",
message: "Bundling the Remotion project for development...",
});
return bundleRemotionProject({
projectRoot,
onUpdate,
});
}
export const renderVideo = async ({
isPackaged,
outputPath,
projectRoot,
titleText,
onUpdate,
cancelSignal,
}: {
isPackaged: boolean;
outputPath: string;
projectRoot: string;
titleText: string;
onUpdate?: (update: RenderUpdate) => void;
cancelSignal?: CancelSignal;
}): Promise<RenderResult> => {
let wasCancelled = false;
const browserExecutable = isPackaged
? getPackagedBrowserPaths({
arch: process.arch,
platform: process.platform,
projectRoot,
})?.packagedBrowserExecutablePath ?? null
: null;
async function finishCancelledRender(): Promise<RenderResult> {
await rm(outputPath, {force: true});
return {
cancelled: true as const,
outputPath: null,
};
}
cancelSignal?.(() => {
wasCancelled = true;
});
const inputProps: HelloWorldProps = {
titleText: titleText.trim() || "Hello from Electron",
};
try {
onUpdate?.({
type: "status",
message: "Checking browser installation...",
});
await ensureBrowser({
browserExecutable,
onBrowserDownload: ({chromeMode}) => {
const browserName =
chromeMode === "chrome-for-testing" ? "Chrome" : "Chrome Headless Shell";
const onProgress: DownloadBrowserProgressFn = (progress) => {
onUpdate?.({
type: "progress",
stage: "browser-download",
progress: progress.percent,
});
};
onUpdate?.({
type: "status",
message: `Downloading ${browserName}...`,
});
return {
version: null,
onProgress,
};
},
});
if (wasCancelled) {
return finishCancelledRender();
}
const serveUrl = await getServeUrl({
isPackaged,
projectRoot,
onUpdate,
});
if (wasCancelled) {
return finishCancelledRender();
}
const binariesDirectory = getBinariesDirectory({
isPackaged,
projectRoot,
});
const composition = await selectComposition({
serveUrl,
id: compositionId,
inputProps,
binariesDirectory,
browserExecutable,
});
if (wasCancelled) {
return finishCancelledRender();
}
onUpdate?.({
type: "status",
message: "Rendering video...",
});
await renderMedia({
composition,
serveUrl,
codec: "h264",
outputLocation: outputPath,
inputProps,
binariesDirectory,
browserExecutable,
cancelSignal,
onProgress(progress: RenderMediaProgress) {
onUpdate?.({
type: "progress",
stage: "rendering",
progress: progress.progress * 100,
});
},
});
if (wasCancelled) {
return finishCancelledRender();
}
return {
cancelled: false,
outputPath,
}
} catch (error) {
if (wasCancelled || isRenderCancelledError(error)) {
return finishCancelledRender();
}
throw error;
}
};