Skip to content

🎥 Make videos programmatically with React

`@remotion/renderer`: Don't deadlock when concurrent renders merge 32+ audio tracks

parbhatkapila4eb4ccee16717
diff --git a/packages/renderer/src/merge-audio-track.ts b/packages/renderer/src/merge-audio-track.ts
index e66d0c02b7..71f3c4eb7d 100644
--- a/packages/renderer/src/merge-audio-track.ts
+++ b/packages/renderer/src/merge-audio-track.ts
@@ -30,7 +30,12 @@ type Options = {
sampleRate: number;
};
-const mergeAudioTrackUnlimited = async ({
+// Limits how many FFmpeg processes mix audio at once. Only the FFmpeg calls
+// take a slot: a merge that waits for its chunks to be merged first holds none,
+// so concurrent renders with many audio tracks can't block each other.
+const limit = pLimit(3);
+
+export const mergeAudioTrack = async ({
outName,
files,
downloadMap,
@@ -45,7 +50,7 @@ const mergeAudioTrackUnlimited = async ({
sampleRate,
}: Options): Promise<void> => {
if (files.length === 0) {
- await createSilentAudio({
+ await limit(createSilentAudio, {
outName,
chunkLengthInSeconds,
indent,
@@ -159,32 +164,27 @@ const mergeAudioTrackUnlimited = async ({
complexFilter,
);
- const task = callFf({
- bin: 'ffmpeg',
- args,
- indent,
- logLevel,
- binariesDirectory,
- cancelSignal,
- });
+ await limit(async () => {
+ const task = callFf({
+ bin: 'ffmpeg',
+ args,
+ indent,
+ logLevel,
+ binariesDirectory,
+ cancelSignal,
+ });
- task.stderr?.on('data', (data: Buffer) => {
- const utf8 = data.toString('utf8');
- const parsed = parseFfmpegProgress(utf8, fps);
- if (parsed !== undefined) {
- onProgress(parsed / (chunkLengthInSeconds * fps));
- }
- });
+ task.stderr?.on('data', (data: Buffer) => {
+ const utf8 = data.toString('utf8');
+ const parsed = parseFfmpegProgress(utf8, fps);
+ if (parsed !== undefined) {
+ onProgress(parsed / (chunkLengthInSeconds * fps));
+ }
+ });
- await task;
+ await task;
+ });
onProgress(1);
cleanup();
};
-
-// Must be at least 3 because recursively called twice in mergeAudioTrack
-const limit = pLimit(3);
-
-export const mergeAudioTrack = (options: Options) => {
- return limit(mergeAudioTrackUnlimited, options);
-};
diff --git a/packages/renderer/src/test/merge-audio-track.test.ts b/packages/renderer/src/test/merge-audio-track.test.ts
new file mode 100644
index 0000000000..2b0564ca60
--- /dev/null
+++ b/packages/renderer/src/test/merge-audio-track.test.ts
@@ -0,0 +1,68 @@
+import {afterEach, expect, spyOn, test} from 'bun:test';
+import {cleanDownloadMap, makeDownloadMap} from '../assets/download-map';
+import * as callFfmpeg from '../call-ffmpeg';
+import {mergeAudioTrack} from '../merge-audio-track';
+
+const spies: {mockRestore: () => void}[] = [];
+
+afterEach(() => {
+ spies.splice(0).forEach((spy) => spy.mockRestore());
+});
+
+test('concurrent merges of 32 or more tracks do not deadlock', async () => {
+ let running = 0;
+ let maxRunning = 0;
+ spies.push(
+ spyOn(callFfmpeg, 'callFf').mockImplementation((() => {
+ running++;
+ maxRunning = Math.max(maxRunning, running);
+ return Object.assign(
+ new Promise<void>((resolve) => {
+ setTimeout(() => {
+ running--;
+ resolve();
+ }, 5);
+ }),
+ {stderr: null},
+ );
+ }) as never),
+ );
+ const downloadMap = makeDownloadMap(48000);
+
+ try {
+ // Like three renders in one process mixing audio at the same time. Each
+ // one splits its 32 tracks into chunks and has to merge those first.
+ const merges = Promise.all(
+ [0, 1, 2].map((render) =>
+ mergeAudioTrack({
+ files: new Array(32).fill(true).map((_, track) => ({
+ outName: `render-${render}-track-${track}.wav`,
+ filter: {pad_start: null, pad_end: null},
+ })),
+ outName: `render-${render}-merged.wav`,
+ downloadMap,
+ remotionRoot: process.cwd(),
+ indent: false,
+ logLevel: 'error',
+ binariesDirectory: null,
+ cancelSignal: undefined,
+ onProgress: () => undefined,
+ fps: 30,
+ chunkLengthInSeconds: 1,
+ sampleRate: 48000,
+ }),
+ ),
+ );
+
+ const result = await Promise.race([
+ merges.then(() => 'done'),
+ new Promise((resolve) => {
+ setTimeout(() => resolve('stuck'), 2000);
+ }),
+ ]);
+ expect(result).toBe('done');
+ expect(maxRunning).toBeLessThanOrEqual(3);
+ } finally {
+ cleanDownloadMap(downloadMap);
+ }
+});