🎥 Make videos programmatically with React
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;
};