Skip to content

🎥 Make videos programmatically with React

5.5 KB
Raw Blame
import path from 'path';
import {calculateAssetPositions} from './assets/calculate-asset-positions';
import {convertAssetsToFileUrls} from './assets/convert-assets-to-file-urls';
import type {RenderMediaOnDownload} from './assets/download-and-map-assets-to-file';
import {markAllAssetsAsDownloaded} from './assets/download-and-map-assets-to-file';
import type {DownloadMap} from './assets/download-map';
import type {Assets} from './assets/types';
import {compressAudio} from './compress-audio';
import {deleteDirectory} from './delete-directory';
import type {LogLevel} from './log-level';
import {Log} from './logger';
import type {CancelSignal} from './make-cancel-signal';
import {mergeAudioTrack} from './merge-audio-track';
import {
	inlineAudioTrackToPreprocessedAudioTrack,
	mergeInlineAudioTracks,
} from './merge-inline-audio-tracks';
import type {AudioCodec} from './options/audio-codec';
import {getExtensionFromAudioCodec} from './options/audio-codec';
import type {PreprocessedAudioTrack} from './preprocess-audio-track';
import {preprocessAudioTrack} from './preprocess-audio-track';
import type {FrameAndAssets} from './render-frames';
import {truthy} from './truthy';

export type SeamlessAudioInfo = {
	chunkLengthInSeconds: number;
	trimLeftOffset: number;
	trimRightOffset: number;
};

export const createAudio = async ({
	assets,
	onDownload,
	fps,
	logLevel,
	onProgress,
	downloadMap,
	remotionRoot,
	indent,
	binariesDirectory,
	audioBitrate,
	audioCodec,
	cancelSignal,
	chunkLengthInSeconds,
	trimLeftOffset,
	trimRightOffset,
	forSeamlessAacConcatenation,
	sampleRate,
	enforceAudioTrack,
}: {
	assets: FrameAndAssets[];
	onDownload: RenderMediaOnDownload | undefined;
	fps: number;
	logLevel: LogLevel;
	onProgress: (progress: number) => void;
	downloadMap: DownloadMap;
	remotionRoot: string;
	indent: boolean;
	binariesDirectory: string | null;
	audioBitrate: string | null;
	audioCodec: AudioCodec;
	cancelSignal: CancelSignal | undefined;
	chunkLengthInSeconds: number;
	trimLeftOffset: number;
	trimRightOffset: number;
	forSeamlessAacConcatenation: boolean;
	sampleRate: number;
	enforceAudioTrack: boolean;
}): Promise<string | null> => {
	const fileUrlAssets = await convertAssetsToFileUrls({
		assets,
		onDownload: onDownload ?? (() => () => undefined),
		downloadMap,
		indent,
		logLevel,
		binariesDirectory,
	});

	markAllAssetsAsDownloaded(downloadMap);
	const assetPositions: Assets = calculateAssetPositions(
		fileUrlAssets,
		assets.map((asset) => asset.frame),
	);

	Log.verbose(
		{indent, logLevel, tag: 'audio'},
		'asset positions',
		JSON.stringify(assetPositions),
	);

	const preprocessProgress = new Array(assetPositions.length).fill(0);
	let mergeProgress = 0;
	let compressProgress = 0;

	const updateProgress = () => {
		const preprocessProgressSum =
			preprocessProgress.length === 0
				? 1
				: preprocessProgress.reduce((a, b) => a + b, 0) / assetPositions.length;

		const totalProgress =
			preprocessProgressSum * 0.7 +
			mergeProgress * 0.1 +
			compressProgress * 0.2;

		onProgress(totalProgress);
	};

	const audioTracks = await Promise.all(
		assetPositions.map(async (asset, index) => {
			const filterFile = path.join(downloadMap.audioMixing, `${index}.wav`);
			const result = await preprocessAudioTrack({
				outName: filterFile,
				asset,
				fps,
				downloadMap,
				indent,
				logLevel,
				binariesDirectory,
				cancelSignal,
				onProgress: (progress) => {
					preprocessProgress[index] = progress;
					updateProgress();
				},
				chunkLengthInSeconds,
				trimLeftOffset,
				trimRightOffset,
				forSeamlessAacConcatenation,
				audioStreamIndex: asset.audioStreamIndex,
				sampleRate,
			});
			preprocessProgress[index] = 1;
			updateProgress();
			return result;
		}),
	);

	await downloadMap.inlineAudioMixing.finish({
		indent,
		logLevel,
		binariesDirectory,
		cancelSignal,
		sampleRate,
	});

	const inlinedAudio = downloadMap.inlineAudioMixing.getListOfAssets();
	const mergedInlineAudio = await mergeInlineAudioTracks({
		tracks: inlinedAudio,
		downloadMap,
		remotionRoot,
		indent,
		logLevel,
		binariesDirectory,
		cancelSignal,
		fps,
		chunkLengthInSeconds,
		sampleRate,
	});

	const preprocessed: PreprocessedAudioTrack[] = [
		...audioTracks.filter(truthy),
		...(mergedInlineAudio
			? [
					inlineAudioTrackToPreprocessedAudioTrack({
						track: mergedInlineAudio,
						relativeToInSamples: 0,
						padToDurationInSamples: Math.round(
							chunkLengthInSeconds * sampleRate,
						),
					}),
				]
			: []),
	];
	if (!enforceAudioTrack && preprocessed.length === 0) {
		deleteDirectory(downloadMap.audioMixing);
		onProgress(1);
		return null;
	}

	const merged = path.join(downloadMap.audioPreprocessing, 'merged.wav');
	const extension = getExtensionFromAudioCodec(audioCodec);
	const outName = path.join(
		downloadMap.audioPreprocessing,
		`audio.${extension}`,
	);

	await mergeAudioTrack({
		files: preprocessed,
		outName: merged,
		downloadMap,
		remotionRoot,
		indent,
		logLevel,
		binariesDirectory,
		cancelSignal,
		fps,
		onProgress: (progress) => {
			mergeProgress = progress;
			updateProgress();
		},
		chunkLengthInSeconds,
		sampleRate,
	});

	await compressAudio({
		audioBitrate,
		audioCodec,
		binariesDirectory,
		indent,
		logLevel,
		inName: merged,
		outName,
		cancelSignal,
		chunkLengthInSeconds,
		fps,
		onProgress: (progress) => {
			compressProgress = progress;
			updateProgress();
		},
	});

	deleteDirectory(merged);
	deleteDirectory(downloadMap.audioMixing);

	preprocessed.forEach((p) => {
		deleteDirectory(p.outName);
	});

	return outName;
};