Skip to content

🎥 Make videos programmatically with React

7.8 KB
Raw Blame
// 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,
	});
};