🎥 Make videos programmatically with React
import {execSync} from 'node:child_process';
import {
copyFileSync,
existsSync,
lstatSync,
mkdirSync,
readdirSync,
renameSync,
rmdirSync,
rmSync,
statSync,
symlinkSync,
unlinkSync,
} from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import {toolchains} from './toolchains';
const isWin = os.platform() === 'win32';
const where = isWin ? 'where' : 'which';
if (os.platform() === 'win32') {
console.log('Windows CI is broken - needs to be cross-compiled');
process.exit(0);
}
function isMusl() {
// @ts-expect-error
const {glibcVersionRuntime} = process.report.getReport().header;
return !glibcVersionRuntime;
}
const targets = [
'x86_64-pc-windows-gnu',
'x86_64-unknown-linux-musl',
'aarch64-unknown-linux-gnu',
'x86_64-unknown-linux-gnu',
'aarch64-apple-darwin',
'x86_64-apple-darwin',
'aarch64-unknown-linux-musl',
];
export const getTarget = () => {
switch (process.platform) {
case 'win32':
switch (process.arch) {
case 'x64':
return 'x86_64-pc-windows-gnu';
default:
throw new Error(
`Unsupported architecture on Windows: ${process.arch}`,
);
}
case 'darwin':
switch (process.arch) {
case 'x64':
return 'x86_64-apple-darwin';
case 'arm64':
return 'aarch64-apple-darwin';
default:
throw new Error(`Unsupported architecture on macOS: ${process.arch}`);
}
case 'linux':
switch (process.arch) {
case 'x64':
if (isMusl()) {
return 'x86_64-unknown-linux-musl';
}
return 'x86_64-unknown-linux-gnu';
case 'arm64':
if (isMusl()) {
return 'aarch64-unknown-linux-musl';
}
return 'aarch64-unknown-linux-gnu';
default:
throw new Error(`Unsupported architecture on Linux: ${process.arch}`);
}
default:
throw new Error(
`Unsupported OS: ${process.platform}, architecture: ${process.arch}`,
);
}
};
const hasCargo = () => {
try {
execSync(`${where} cargo`);
return true;
} catch (err) {
return false;
}
};
const debug = process.argv.includes('--debug');
const mode = debug ? 'debug' : 'release';
const copyDestinations = {
'aarch64-unknown-linux-gnu': {
from: `target/aarch64-unknown-linux-gnu/${mode}/remotion`,
to: '../compositor-linux-arm64-gnu/remotion',
dir: '../compositor-linux-arm64-gnu',
},
'aarch64-unknown-linux-musl': {
from: `target/aarch64-unknown-linux-musl/${mode}/remotion`,
to: '../compositor-linux-arm64-musl/remotion',
dir: '../compositor-linux-arm64-musl',
},
'x86_64-unknown-linux-gnu': {
from: `target/x86_64-unknown-linux-gnu/${mode}/remotion`,
to: '../compositor-linux-x64-gnu/remotion',
dir: '../compositor-linux-x64-gnu',
},
'x86_64-unknown-linux-musl': {
from: `target/x86_64-unknown-linux-musl/${mode}/remotion`,
to: '../compositor-linux-x64-musl/remotion',
dir: '../compositor-linux-x64-musl',
},
'x86_64-apple-darwin': {
from: `target/x86_64-apple-darwin/${mode}/remotion`,
to: '../compositor-darwin-x64/remotion',
dir: '../compositor-darwin-x64',
},
'aarch64-apple-darwin': {
from: `target/aarch64-apple-darwin/${mode}/remotion`,
to: '../compositor-darwin-arm64/remotion',
dir: '../compositor-darwin-arm64',
},
'x86_64-pc-windows-gnu': {
from: `target/x86_64-pc-windows-gnu/${mode}/remotion.exe`,
to: '../compositor-win32-x64-msvc/remotion.exe',
dir: '../compositor-win32-x64-msvc',
},
};
if (!hasCargo()) {
console.log('Environment has no cargo. Skipping Rust builds.');
process.exit(0);
}
const nativeArch = getTarget();
const all = process.argv.includes('--all');
const cloudrun = process.argv.includes('--cloudrun');
const lambda = process.argv.includes('--lambda');
if (!existsSync('toolchains') && all) {
throw new Error(
'Run "bun install-toolchain.ts" if you want to build all platforms',
);
}
for (const toolchain of toolchains) {
if (!existsSync(path.join('toolchains', toolchain)) && all) {
throw new Error(
`Toolchain for ${toolchain} not found. Run "node install-toolchain.mjs" if you want to build all platforms`,
);
}
}
const stdout = execSync('cargo metadata --format-version=1');
const {packages} = JSON.parse(stdout as unknown as string);
const rustFfmpegSys = packages.find((p) => p.name === 'ffmpeg-sys-next');
if (!rustFfmpegSys) {
console.error(
'Could not find ffmpeg-sys-next when running cargo metadata --format-version=1',
);
process.exit(1);
}
const manifest = rustFfmpegSys.manifest_path;
const binariesDirectory = path.join(path.dirname(manifest), 'zips');
const archs = all
? targets
: lambda
? ['aarch64-unknown-linux-gnu']
: cloudrun
? ['x86_64-unknown-linux-gnu']
: [nativeArch];
for (const arch of archs) {
const ffmpegFolder = path.join(copyDestinations[arch].dir, 'ffmpeg');
if (existsSync(ffmpegFolder)) {
rmSync(ffmpegFolder, {recursive: true});
}
mkdirSync(ffmpegFolder);
// strip-components: extract in a flat folder structure
execSync(
`tar xf ${binariesDirectory}/${arch}.gz -C ${ffmpegFolder} --strip-components 2`,
{
stdio: 'inherit',
},
);
const filesInFfmpegFolder = readdirSync(ffmpegFolder);
const filesToDelete = filesInFfmpegFolder.filter((file) => {
return (
file.endsWith('.h') ||
file.endsWith('.a') ||
file.endsWith('.la') ||
file.endsWith('.hpp') ||
statSync(path.join(ffmpegFolder, file)).isDirectory()
);
});
for (const file of filesToDelete) {
rmSync(path.join(ffmpegFolder, file), {recursive: true});
}
const filesInFfmpegFolder2 = readdirSync(ffmpegFolder);
if (arch === 'x86_64-pc-windows-gnu') {
for (const file of readdirSync(copyDestinations[arch].dir)) {
if (
file.endsWith('.dll') ||
file === 'ffmpeg.exe' ||
file === 'ffprobe.exe'
) {
rmSync(path.join(copyDestinations[arch].dir, file));
}
}
}
for (const file of filesInFfmpegFolder2) {
if (file === 'ffmpeg') {
renameSync(
path.join(ffmpegFolder, file),
path.join(ffmpegFolder, '..', 'ffmpeg_'),
);
continue;
}
renameSync(
path.join(ffmpegFolder, file),
path.join(ffmpegFolder, '..', file),
);
}
rmdirSync(path.join(ffmpegFolder, '..', 'ffmpeg'));
if (existsSync(path.join(ffmpegFolder, '..', 'bin'))) {
rmSync(path.join(ffmpegFolder, '..', 'bin'), {recursive: true});
}
if (existsSync(path.join(ffmpegFolder, '..', 'ffmpeg_'))) {
renameSync(
path.join(ffmpegFolder, '..', 'ffmpeg_'),
path.join(ffmpegFolder, '..', 'ffmpeg'),
);
}
let windowsLinkerDirectory: string | null = null;
if (arch === 'x86_64-pc-windows-gnu') {
// GNU ld looks for unversioned lib*.dll names, while the FFmpeg
// archive contains versioned DLLs such as avcodec-61.dll.
windowsLinkerDirectory = path.join(
process.cwd(),
'target',
'windows-ffmpeg-linker',
);
rmSync(windowsLinkerDirectory, {force: true, recursive: true});
mkdirSync(windowsLinkerDirectory, {recursive: true});
for (const library of [
'avcodec',
'avdevice',
'avfilter',
'avformat',
'avutil',
'swresample',
'swscale',
]) {
const dll = filesInFfmpegFolder2.find(
(file) => file.startsWith(`${library}-`) && file.endsWith('.dll'),
);
if (!dll) {
throw new Error(`Could not find ${library} DLL for ${arch}`);
}
symlinkSync(
path.resolve(copyDestinations[arch].dir, dll),
path.join(windowsLinkerDirectory, `lib${library}.dll`),
);
}
}
const command = `cargo build ${debug ? '' : '--release'} --target=${arch}`;
console.log(command);
// debuginfo will keep symbols, which are used for backtrace.
// symbols makes it a tiny bit smaller, but error messages will be hard to debug.
const rPathOrigin = arch.includes('linux')
? `-C link-args=-Wl,-rpath,'$ORIGIN'`
: '';
const macOSHeaderPad = arch.includes('darwin')
? `-C link-args=-Wl,-headerpad_max_install_names`
: '';
// mingw-w64 14 split the CRT: plain vsnprintf_s (and other secure CRT
// functions) now live in libmsvcrt-os.a rather than libmsvcrt.a. Rust's
// windows-gnu link passes -nodefaultlibs with -lmsvcrt but not
// -lmsvcrt-os, so link -lmsvcrt-os explicitly to resolve them.
const windowsCrtFix =
arch === 'x86_64-pc-windows-gnu' ? `-C link-arg=-lmsvcrt-os` : '';
const optimizations = all
? `-C opt-level=3 -C lto=fat -C strip=debuginfo -C embed-bitcode=yes ${rPathOrigin} ${macOSHeaderPad} ${windowsCrtFix} ${windowsLinkerDirectory ? `-Lnative=${windowsLinkerDirectory}` : ''}`
: macOSHeaderPad;
execSync(command, {
stdio: 'inherit',
env: {
...process.env,
RUSTFLAGS: optimizations,
CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER:
nativeArch === 'aarch64-unknown-linux-gnu'
? undefined
: 'toolchains/aarch64_gnu_toolchain/bin/aarch64-unknown-linux-gnu-gcc',
CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER:
nativeArch === 'aarch64-unknown-linux-musl'
? undefined
: 'toolchains/aarch64_musl_toolchain/bin/aarch64-unknown-linux-musl-gcc',
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER:
nativeArch === 'x86_64-unknown-linux-gnu'
? undefined
: path.join(
process.cwd(),
'toolchains/x86_64_gnu_toolchain/bin/x86_64-unknown-linux-gnu-gcc',
),
CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER:
nativeArch === 'x86_64-unknown-linux-musl'
? undefined
: 'toolchains/x86_64_musl_toolchain/bin/x86_64-unknown-linux-musl-gcc',
},
});
const copyInstructions = copyDestinations[arch];
copyFileSync(copyInstructions.from, copyInstructions.to);
if (windowsLinkerDirectory) {
rmSync(windowsLinkerDirectory, {recursive: true});
}
const output = execSync('npm pack --json', {
cwd: copyDestinations[arch].dir,
stdio: 'pipe',
});
const filename = JSON.parse(output.toString('utf-8'))[0].filename.replace(
/^@remotion\//,
'remotion-',
);
const tgzPath = path.join(
process.cwd(),
copyDestinations[arch].dir,
filename,
);
if (arch.includes('linux')) {
execSync(
`patchelf --force-rpath --set-rpath '$ORIGIN' ${copyDestinations[arch].dir}/remotion`,
);
}
const filesize = lstatSync(tgzPath).size;
console.log('Zipped size:', (filesize / 1000000).toFixed(2) + 'MB');
unlinkSync(tgzPath);
}