🎥 Make videos programmatically with React
// Combine multiple video chunks, useful for decentralized rendering
import {copyFileSync, rmSync} from 'node:fs';
import {join} from 'node:path';
import {
canConcatAudioSeamlessly,
canConcatVideoSeamlessly,
} from './can-concat-seamlessly';
import type {Codec} from './codec';
import {createCombinedAudio} from './combine-audio';
import {combineVideoStreams} from './combine-video-streams';
import {combineVideoStreamsSeamlessly} from './combine-video-streams-seamlessly';
import type {SingleFrameRange} from './frame-range';
import {getFramesToRender} from './get-duration-from-frame-range';
import {getFileExtensionFromCodec} from './get-extension-from-codec';
import {getExtensionOfFilename} from './get-extension-of-filename';
import {getRealFrameRange} from './get-frame-to-render';
import {getMp4BrandForExtension} from './get-mp4-brand';
import {isAudioCodec} from './is-audio-codec';
import type {LogLevel} from './log-level';
import {Log} from './logger';
import type {CancelSignal} from './make-cancel-signal';
import {muxVideoAndAudio} from './mux-video-and-audio';
import type {AudioCodec} from './options/audio-codec';
import {
getExtensionFromAudioCodec,
resolveAudioCodec,
} from './options/audio-codec';
import {tmpDir} from './tmp-dir';
import {truthy} from './truthy';
import {validateNumberOfGifLoops} from './validate-number-of-gif-loops';
type MandatoryCombineChunksOptions = {
outputLocation: string;
audioFiles: string[];
codec: Codec;
videoFiles: string[];
fps: number;
framesPerChunk: number;
preferLossless: boolean;
compositionDurationInFrames: number;
};
type CombineChunksProgress = {
totalProgress: number;
frames: number;
};
export type CombineChunksOnProgress = (options: CombineChunksProgress) => void;
type OptionalCombineChunksOptions = {
onProgress: CombineChunksOnProgress;
audioBitrate: string | null;
numberOfGifLoops: number | null;
logLevel: LogLevel;
binariesDirectory: string | null;
audioCodec: AudioCodec | null;
cancelSignal: CancelSignal | undefined;
metadata: Record<string, string> | null;
frameRange: SingleFrameRange | null;
everyNthFrame: number;
sampleRate: number;
};
type AllCombineChunksOptions = MandatoryCombineChunksOptions &
OptionalCombineChunksOptions;
export type CombineChunksOptions = MandatoryCombineChunksOptions &
Partial<OptionalCombineChunksOptions>;
const REMOTION_FILELIST_TOKEN = 'remotion-filelist';
export const internalCombineChunks = async ({
outputLocation: output,
onProgress,
codec,
fps,
numberOfGifLoops,
audioBitrate,
indent,
logLevel,
binariesDirectory,
cancelSignal,
metadata,
audioFiles,
videoFiles,
framesPerChunk,
audioCodec,
preferLossless,
everyNthFrame,
frameRange,
compositionDurationInFrames,
sampleRate,
separateAudioTo,
}: AllCombineChunksOptions & {
indent: boolean;
separateAudioTo: string | null;
}) => {
validateNumberOfGifLoops(numberOfGifLoops, codec);
const shouldCreateVideo = !isAudioCodec(codec);
const resolvedAudioCodec = resolveAudioCodec({
setting: audioCodec,
codec,
preferLossless,
separateAudioTo,
});
const shouldCreateAudio =
resolvedAudioCodec !== null && audioFiles.length > 0;
if (separateAudioTo !== null && (!shouldCreateAudio || !shouldCreateVideo)) {
throw new Error(
'Separate audio requires a video render with audio chunks.',
);
}
const seamlessVideo = canConcatVideoSeamlessly(codec);
const realFrameRange = getRealFrameRange(
compositionDurationInFrames,
frameRange,
);
const seamlessAudio = canConcatAudioSeamlessly(
resolvedAudioCodec,
framesPerChunk,
);
const numberOfFrames = getFramesToRender(
realFrameRange,
everyNthFrame,
).length;
const filelistDir = tmpDir(REMOTION_FILELIST_TOKEN);
const videoOutput = shouldCreateVideo
? join(
filelistDir,
`video.${getFileExtensionFromCodec(codec, separateAudioTo === null ? resolvedAudioCodec : null)}`,
)
: null;
const audioOutput = shouldCreateAudio
? join(
filelistDir,
`audio.${getExtensionFromAudioCodec(resolvedAudioCodec)}`,
)
: null;
const chunkDurationInSeconds = framesPerChunk / fps;
let concatenatedAudio = 0;
let concatenatedVideo = 0;
let muxing = 0;
const updateProgress = () => {
const totalFrames =
(shouldCreateAudio ? numberOfFrames : 0) +
(shouldCreateVideo ? numberOfFrames : 0) +
numberOfFrames;
const actualProgress = concatenatedAudio + concatenatedVideo + muxing;
onProgress({
frames: (actualProgress / totalFrames) * numberOfFrames,
totalProgress: actualProgress / totalFrames,
});
};
Log.verbose(
{indent, logLevel},
`Combining chunks, audio = ${
shouldCreateAudio === false
? 'no'
: seamlessAudio
? 'seamlessly'
: 'normally'
}, video = ${
shouldCreateVideo === false
? 'no'
: seamlessVideo
? 'seamlessly'
: 'normally'
}`,
);
try {
await Promise.all(
[
shouldCreateAudio && audioOutput
? createCombinedAudio({
audioBitrate,
filelistDir,
files: audioFiles,
indent,
logLevel,
output: audioOutput,
resolvedAudioCodec,
seamless: seamlessAudio,
chunkDurationInSeconds,
addRemotionMetadata: !shouldCreateVideo,
binariesDirectory,
fps,
cancelSignal,
onProgress: (frames) => {
concatenatedAudio = frames;
updateProgress();
},
sampleRate,
})
: null,
shouldCreateVideo && !seamlessVideo && videoOutput
? combineVideoStreams({
codec,
filelistDir,
fps,
indent,
logLevel,
numberOfGifLoops,
output: videoOutput,
files: videoFiles,
addRemotionMetadata: !shouldCreateAudio,
binariesDirectory,
cancelSignal,
onProgress: (frames) => {
concatenatedVideo = frames;
updateProgress();
},
})
: null,
].filter(truthy),
);
await muxVideoAndAudio({
audioOutput: separateAudioTo === null ? audioOutput : null,
indent,
logLevel,
onProgress: (frames) => {
muxing = frames;
updateProgress();
},
output,
videoOutput: seamlessVideo
? combineVideoStreamsSeamlessly({files: videoFiles})
: videoOutput,
binariesDirectory,
fps,
cancelSignal,
metadata,
numberOfGifLoops,
audioCodec: resolvedAudioCodec,
sampleRate,
});
if (separateAudioTo !== null && audioOutput !== null) {
const extension =
getExtensionOfFilename(separateAudioTo)?.toLowerCase() ?? null;
if (getMp4BrandForExtension(extension)) {
await muxVideoAndAudio({
videoOutput: null,
audioOutput,
output: separateAudioTo,
indent,
logLevel,
onProgress: () => undefined,
binariesDirectory,
fps,
cancelSignal,
metadata: null,
numberOfGifLoops: null,
audioCodec: resolvedAudioCodec,
sampleRate,
});
} else {
copyFileSync(audioOutput, separateAudioTo);
}
}
onProgress({totalProgress: 1, frames: numberOfFrames});
} finally {
rmSync(filelistDir, {recursive: true, force: true});
}
};
export const combineChunks = (options: CombineChunksOptions) => {
return internalCombineChunks({
audioBitrate: options.audioBitrate ?? null,
numberOfGifLoops: options.numberOfGifLoops ?? null,
indent: false,
logLevel: options.logLevel ?? 'info',
binariesDirectory: options.binariesDirectory ?? null,
cancelSignal: options.cancelSignal,
metadata: options.metadata ?? null,
audioCodec: options.audioCodec ?? null,
preferLossless: options.preferLossless,
audioFiles: options.audioFiles,
codec: options.codec,
fps: options.fps,
framesPerChunk: options.framesPerChunk,
outputLocation: options.outputLocation,
onProgress: options.onProgress ?? (() => {}),
videoFiles: options.videoFiles,
everyNthFrame: options.everyNthFrame ?? 1,
frameRange: options.frameRange ?? null,
compositionDurationInFrames: options.compositionDurationInFrames,
sampleRate: options.sampleRate ?? 48000,
separateAudioTo: null,
});
};