@remotion/renderer 3.2.44 → 3.3.1

package/dist/combine-videos.js

@@ -8,17 +8,19 @@ exports.combineVideos = void 0;
 const execa_1 = __importDefault(require("execa"));
 const fs_1 = require("fs");
 const path_1 = require("path");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const get_audio_codec_name_1 = require("./get-audio-codec-name");
 const is_audio_codec_1 = require("./is-audio-codec");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const truthy_1 = require("./truthy");
-const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, }) => {
+const combineVideos = async (options) => {
     var _a;
+    const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, ffmpegExecutable, remotionRoot, } = options;
     const fileList = files.map((p) => `file '${p}'`).join('\n');
     const fileListTxt = (0, path_1.join)(filelistDir, 'files.txt');
     (0, fs_1.writeFileSync)(fileListTxt, fileList);
     try {
-        const task = (0, execa_1.default)('ffmpeg', [
+        const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-r',
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : String(fps),
             '-f',

package/dist/convert-to-pcm.d.ts

@@ -1,6 +1,7 @@
 import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare const convertToPcm: ({ ffmpegExecutable, input, outName, }: {
+export declare const convertToPcm: ({ ffmpegExecutable, input, outName, remotionRoot, }: {
     ffmpegExecutable: FfmpegExecutable;
     input: string;
     outName: string;
+    remotionRoot: string;
 }) => Promise<void>;

package/dist/convert-to-pcm.js

@@ -5,9 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToPcm = void 0;
 const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const sample_rate_1 = require("./sample-rate");
-const convertToPcm = async ({ ffmpegExecutable, input, outName, }) => {
-    await (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+const convertToPcm = async ({ ffmpegExecutable, input, outName, remotionRoot, }) => {
+    await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-i',
         input,
         '-c:a',

package/dist/create-silent-audio.d.ts

@@ -1,6 +1,7 @@
 import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, }: {
+export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, remotionRoot, }: {
     ffmpegExecutable: FfmpegExecutable;
     numberOfSeconds: number;
     outName: string;
+    remotionRoot: string;
 }) => Promise<void>;

package/dist/create-silent-audio.js

@@ -5,9 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSilentAudio = void 0;
 const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const sample_rate_1 = require("./sample-rate");
-const createSilentAudio = async ({ ffmpegExecutable, numberOfSeconds, outName, }) => {
-    await (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+const createSilentAudio = async ({ ffmpegExecutable, numberOfSeconds, outName, remotionRoot, }) => {
+    await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-f',
         'lavfi',
         '-i',

package/dist/cycle-browser-tabs.d.ts

@@ -1,7 +1,4 @@
-import type { openBrowser } from './open-browser';
-declare type Await<T> = T extends PromiseLike<infer U> ? U : T;
-declare type Browser = Await<ReturnType<typeof openBrowser>>;
-export declare const cycleBrowserTabs: (puppeteerInstance: Browser, concurrency: number) => {
+import type { BrowserReplacer } from './replace-browser';
+export declare const cycleBrowserTabs: (puppeteerInstance: BrowserReplacer, concurrency: number) => {
     stopCycling: () => void;
 };
-export {};

package/dist/cycle-browser-tabs.js

@@ -13,24 +13,24 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
     const set = () => {
         interval = setTimeout(() => {
             puppeteerInstance
+                .getBrowser()
                 .pages()
                 .then((pages) => {
-                var _a;
                 if (pages.length === 0) {
                     return;
                 }
                 const currentPage = pages[i % pages.length];
                 i++;
-                if (!((_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) &&
+                if (!(currentPage === null || currentPage === void 0 ? void 0 : currentPage.closed) &&
                     !stopped &&
                     (currentPage === null || currentPage === void 0 ? void 0 : currentPage.url()) !== 'about:blank') {
                     return currentPage.bringToFront();
                 }
             })
-                .then(() => {
+                .catch((err) => console.log(err))
+                .finally(() => {
                 set();
-            })
-                .catch((err) => console.log(err));
+            });
         }, 200);
     };
     set();

package/dist/ensure-ffmpeg.d.ts

@@ -0,0 +1,10 @@
+export declare type EnsureFfmpegOptions = {
+    remotionRoot?: string;
+};
+declare type Result = {
+    result: 'found-in-path' | 'found-in-node-modules' | 'installed';
+    wasAlreadyInstalled: boolean;
+};
+export declare const ensureFfmpeg: (options?: EnsureFfmpegOptions) => Promise<Result>;
+export declare const ensureFfprobe: (options?: EnsureFfmpegOptions) => Promise<Result>;
+export {};

package/dist/ensure-ffmpeg.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFfprobe = exports.ensureFfmpeg = void 0;
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const validate_ffmpeg_1 = require("./validate-ffmpeg");
+const ensureFfmpegOrFfprobe = async (binary, options) => {
+    var _a;
+    const exists = (0, validate_ffmpeg_1.binaryExists)(binary);
+    const remotionRoot = (_a = options === null || options === void 0 ? void 0 : options.remotionRoot) !== null && _a !== void 0 ? _a : process.cwd();
+    if (exists) {
+        return {
+            wasAlreadyInstalled: true,
+            result: 'found-in-path',
+        };
+    }
+    if (process.platform === 'linux' && (0, fs_1.existsSync)(ffmpeg_flags_1.lambdaFfmpegPaths[binary])) {
+        return {
+            wasAlreadyInstalled: true,
+            result: 'found-in-path',
+        };
+    }
+    if ((0, ffmpeg_flags_1.ffmpegInNodeModules)(remotionRoot, binary)) {
+        return {
+            result: 'found-in-node-modules',
+            wasAlreadyInstalled: true,
+        };
+    }
+    const binaryUrl = (0, ffmpeg_flags_1.getBinaryDownloadUrl)(binary);
+    if (binaryUrl) {
+        await (0, ffmpeg_flags_1.downloadBinary)(remotionRoot, binaryUrl.url, binary);
+        return {
+            result: 'installed',
+            wasAlreadyInstalled: false,
+        };
+    }
+    throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);
+};
+const ensureFfmpeg = (options) => {
+    return ensureFfmpegOrFfprobe('ffmpeg', options);
+};
+exports.ensureFfmpeg = ensureFfmpeg;
+const ensureFfprobe = (options) => {
+    return ensureFfmpegOrFfprobe('ffprobe', options);
+};
+exports.ensureFfprobe = ensureFfprobe;

package/dist/ensure-presentation-timestamp.d.ts

@@ -1,2 +1,9 @@
 import type { DownloadMap } from './assets/download-map';
-export declare const ensurePresentationTimestamps: (downloadMap: DownloadMap, src: string) => Promise<string>;
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const ensurePresentationTimestamps: ({ downloadMap, src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }: {
+    downloadMap: DownloadMap;
+    src: string;
+    remotionRoot: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+}) => Promise<string>;

package/dist/ensure-presentation-timestamp.js

@@ -6,16 +6,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensurePresentationTimestamps = void 0;
 const execa_1 = __importDefault(require("execa"));
 const path_1 = __importDefault(require("path"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const guess_extension_for_media_1 = require("./guess-extension-for-media");
 const truthy_1 = require("./truthy");
 let callbacks = [];
-const getTemporaryOutputName = async (src) => {
+const getTemporaryOutputName = async ({ src, remotionRoot, ffprobeBinary, }) => {
     const parts = src.split(path_1.default.sep);
     // If there is no file extension for the video, then we need to temporarily add an extension
     const lastPart = parts[parts.length - 1];
     const extraExtension = lastPart.includes('.')
         ? null
-        : await (0, guess_extension_for_media_1.guessExtensionForVideo)(src);
+        : await (0, guess_extension_for_media_1.guessExtensionForVideo)({
+            src,
+            remotionRoot,
+            ffprobeBinary,
+        });
     return parts
         .map((p, i) => {
         if (i === parts.length - 1) {
@@ -25,7 +30,7 @@ const getTemporaryOutputName = async (src) => {
     })
         .join(path_1.default.sep);
 };
-const ensurePresentationTimestamps = async (downloadMap, src) => {
+const ensurePresentationTimestamps = async ({ downloadMap, src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }) => {
     const elem = downloadMap.ensureFileHasPresentationTimestamp[src];
     if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'encoding') {
         return new Promise((resolve) => {
@@ -40,8 +45,12 @@ const ensurePresentationTimestamps = async (downloadMap, src) => {
     }
     downloadMap.ensureFileHasPresentationTimestamp[src] = { type: 'encoding' };
     // If there is no file extension for the video, then we need to tempoa
-    const output = await getTemporaryOutputName(src);
-    await (0, execa_1.default)('ffmpeg', [
+    const output = await getTemporaryOutputName({
+        src,
+        remotionRoot,
+        ffprobeBinary: ffprobeExecutable,
+    });
+    await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-i',
         src,
         '-fflags',

package/dist/extract-frame-from-video.d.ts

@@ -11,6 +11,7 @@ declare type Options = {
     ffprobeExecutable: FfmpegExecutable;
     imageFormat: OffthreadVideoImageFormat;
     downloadMap: DownloadMap;
+    remotionRoot: string;
 };
 export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
 export {};

package/dist/extract-frame-from-video.js

@@ -7,6 +7,7 @@ exports.extractFrameFromVideo = exports.getLastFrameOfVideo = void 0;
 const execa_1 = __importDefault(require("execa"));
 const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
 const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
 const get_video_info_1 = require("./get-video-info");
 const is_beyond_last_frame_1 = require("./is-beyond-last-frame");
@@ -32,7 +33,7 @@ const determineResizeParams = (needsResize) => {
 };
 // Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
 // if the video is corrupted
-const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, }) => {
+const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }) => {
     console.warn(`\nUsing a slow method to extract the frame at ${duration}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
     const actualOffset = `-${duration * 1000 - offset}ms`;
     const command = [
@@ -50,7 +51,7 @@ const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageForma
         ...determineResizeParams(needsResize),
         '-',
     ].filter(truthy_1.truthy);
-    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', command);
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), command);
     if (!stderr) {
         throw new Error('unexpectedly did not get stderr');
     }
@@ -85,6 +86,7 @@ const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageForma
             specialVCodecForTransparency,
             needsResize,
             fps,
+            remotionRoot,
         });
     }
     return stdoutBuffer;
@@ -95,7 +97,7 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
     if (fromCache) {
         return fromCache;
     }
-    const { duration, fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable);
+    const { duration, fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable, options.remotionRoot);
     if (duration === null) {
         throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
     }
@@ -109,11 +111,12 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
             needsResize: options.needsResize,
             offset: offset - 1000 / (fps === null ? 10 : fps),
             fps,
+            remotionRoot: options.remotionRoot,
         });
         return last;
     }
     const actualOffset = `${duration * 1000 - offset}ms`;
-    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, options.remotionRoot, 'ffmpeg'), [
         '-ss',
         actualOffset,
         ...determineVcodecFfmepgFlags(options.specialVCodecForTransparency),
@@ -165,6 +168,7 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
             specialVCodecForTransparency: options.specialVCodecForTransparency,
             needsResize: options.needsResize,
             downloadMap: options.downloadMap,
+            remotionRoot: options.remotionRoot,
         });
         return unlimited;
     }
@@ -176,13 +180,19 @@ const getLastFrameOfVideo = async (options) => {
     return result;
 };
 exports.getLastFrameOfVideo = getLastFrameOfVideo;
-const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutable, imageFormat, downloadMap, ...options }) => {
+const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutable, imageFormat, downloadMap, remotionRoot, ...options }) => {
     // We make a new copy of the video only for video because the conversion may affect
     // audio rendering, so we work with 2 different files
-    const src = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)(downloadMap, options.src);
-    const { specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src, ffprobeExecutable);
+    const src = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)({
+        downloadMap,
+        src: options.src,
+        remotionRoot,
+        ffmpegExecutable,
+        ffprobeExecutable,
+    });
+    const { specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src, ffprobeExecutable, remotionRoot);
     if (specialVcodec === 'vp8') {
-        const { fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable);
+        const { fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable, remotionRoot);
         return getFrameOfVideoSlow({
             ffmpegExecutable,
             imageFormat,
@@ -192,6 +202,7 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
             needsResize,
             offset: 0,
             fps,
+            remotionRoot,
         });
     }
     if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(downloadMap, src, time)) {
@@ -204,11 +215,12 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
             specialVCodecForTransparency: specialVcodec,
             needsResize,
             downloadMap,
+            remotionRoot,
         });
         return lastFrame;
     }
     const ffmpegTimestamp = (0, frame_to_ffmpeg_timestamp_1.frameToFfmpegTimestamp)(time);
-    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-ss',
         ffmpegTimestamp,
         ...determineVcodecFfmepgFlags(specialVcodec),
@@ -258,6 +270,7 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
             specialVCodecForTransparency: specialVcodec,
             needsResize,
             downloadMap,
+            remotionRoot,
         });
         return last;
     }

package/dist/ffmpeg-flags.d.ts

@@ -1,15 +1,30 @@
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare type FfmpegVersion = [number, number, number] | null;
 export declare const getFfmpegBuildInfo: (options: {
     ffmpegExecutable: string | null;
+    remotionRoot: string;
 }) => Promise<string>;
-export declare const ffmpegHasFeature: ({ ffmpegExecutable, feature, }: {
+export declare const ffmpegInNodeModules: (remotionRoot: string, binary: 'ffmpeg' | 'ffprobe') => string | null;
+export declare const ffmpegHasFeature: ({ ffmpegExecutable, feature, remotionRoot, }: {
     ffmpegExecutable: string | null;
     feature: 'enable-gpl' | 'enable-libx265' | 'enable-libvpx';
+    remotionRoot: string;
 }) => Promise<boolean>;
 export declare const parseFfmpegVersion: (buildconf: string) => FfmpegVersion;
 export declare const getFfmpegVersion: (options: {
     ffmpegExecutable: string | null;
+    remotionRoot: string;
 }) => Promise<FfmpegVersion>;
+export declare const downloadBinary: (remotionRoot: string, url: string, binary: 'ffmpeg' | 'ffprobe') => Promise<string>;
+export declare const lambdaFfmpegPaths: {
+    readonly ffmpeg: "/opt/bin/ffmpeg";
+    readonly ffprobe: "/opt/bin/ffprobe";
+};
+export declare const getExecutableBinary: (ffmpegExecutable: FfmpegExecutable, remotionRoot: string, binary: 'ffmpeg' | 'ffprobe') => string | Promise<string>;
+export declare const getBinaryDownloadUrl: (binary: 'ffmpeg' | 'ffprobe') => {
+    url: string;
+    contentLength: number;
+} | null;
 export declare const warnAboutFfmpegVersion: ({ ffmpegVersion, buildConf, }: {
     ffmpegVersion: FfmpegVersion;
     buildConf: string | null;

package/dist/ffmpeg-flags.js

@@ -3,27 +3,79 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warnAboutFfmpegVersion = exports.getFfmpegVersion = exports.parseFfmpegVersion = exports.ffmpegHasFeature = exports.getFfmpegBuildInfo = void 0;
+exports.warnAboutFfmpegVersion = exports.getBinaryDownloadUrl = exports.getExecutableBinary = exports.lambdaFfmpegPaths = exports.downloadBinary = exports.getFfmpegVersion = exports.parseFfmpegVersion = exports.ffmpegHasFeature = exports.ffmpegInNodeModules = exports.getFfmpegBuildInfo = void 0;
 const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const BrowserFetcher_1 = require("./browser/BrowserFetcher");
 const validate_ffmpeg_1 = require("./validate-ffmpeg");
 let buildConfig = null;
+const listeners = {};
+const isDownloading = {};
 const getFfmpegBuildInfo = async (options) => {
-    var _a;
     if (buildConfig !== null) {
         return buildConfig;
     }
-    const data = await (0, execa_1.default)((_a = options.ffmpegExecutable) !== null && _a !== void 0 ? _a : 'ffmpeg', ['-buildconf'], {
+    const data = await (0, execa_1.default)(await (0, exports.getExecutableBinary)(options.ffmpegExecutable, options.remotionRoot, 'ffmpeg'), ['-buildconf'], {
         reject: false,
     });
     buildConfig = data.stderr;
     return buildConfig;
 };
 exports.getFfmpegBuildInfo = getFfmpegBuildInfo;
-const ffmpegHasFeature = async ({ ffmpegExecutable, feature, }) => {
-    if (!(0, validate_ffmpeg_1.binaryExists)('ffmpeg', ffmpegExecutable)) {
+const getFfmpegFolderName = (remotionRoot) => {
+    return path_1.default.resolve(remotionRoot, 'node_modules/.ffmpeg');
+};
+const binaryPrefix = { ffmpeg: 'ffmpeg-', ffprobe: 'ffprobe-' };
+const randomFfmpegRuntimeId = String(Math.random()).replace('0.', '');
+const ffmpegInNodeModules = (remotionRoot, binary) => {
+    const folderName = getFfmpegFolderName(remotionRoot);
+    if (!fs_1.default.existsSync(folderName)) {
+        fs_1.default.mkdirSync(folderName);
+    }
+    // Check if a version of FFMPEG is already installed.
+    // To qualify, it must have the expected file size
+    // to avoid finding binaries that are still being downloaded
+    // A random ID is being assigned to the download to avoid conflicts when multiple Remotion processes are running
+    const ffmpegInstalled = fs_1.default.readdirSync(folderName).find((filename) => {
+        if (!filename.startsWith(binaryPrefix[binary])) {
+            return false;
+        }
+        const dlUrl = (0, exports.getBinaryDownloadUrl)(binary);
+        if (!dlUrl) {
+            return false;
+        }
+        const expectedLength = dlUrl.contentLength;
+        if (fs_1.default.statSync(path_1.default.join(folderName, filename)).size === expectedLength) {
+            return true;
+        }
         return false;
+    });
+    if (ffmpegInstalled) {
+        return path_1.default.join(folderName, ffmpegInstalled);
     }
-    const config = await (0, exports.getFfmpegBuildInfo)({ ffmpegExecutable });
+    return null;
+};
+exports.ffmpegInNodeModules = ffmpegInNodeModules;
+const getFfmpegAbsolutePath = (remotionRoot, binary) => {
+    const folderName = getFfmpegFolderName(remotionRoot);
+    if (!fs_1.default.existsSync(folderName)) {
+        fs_1.default.mkdirSync(folderName);
+    }
+    if (os_1.default.platform() === 'win32') {
+        return path_1.default.resolve(folderName, `${binaryPrefix[binary]}${randomFfmpegRuntimeId}.exe`);
+    }
+    return path_1.default.resolve(folderName, `${binaryPrefix[binary]}${randomFfmpegRuntimeId}`);
+};
+const ffmpegHasFeature = async ({ ffmpegExecutable, feature, remotionRoot, }) => {
+    if (ffmpegExecutable && !(0, validate_ffmpeg_1.customExecutableExists)(ffmpegExecutable)) {
+        return false;
+    }
+    if (!(0, validate_ffmpeg_1.binaryExists)('ffmpeg')) {
+        return false;
+    }
+    const config = await (0, exports.getFfmpegBuildInfo)({ ffmpegExecutable, remotionRoot });
     return config.includes(feature);
 };
 exports.ffmpegHasFeature = ffmpegHasFeature;
@@ -39,13 +91,122 @@ exports.parseFfmpegVersion = parseFfmpegVersion;
 const getFfmpegVersion = async (options) => {
     const buildInfo = await (0, exports.getFfmpegBuildInfo)({
         ffmpegExecutable: options.ffmpegExecutable,
+        remotionRoot: options.remotionRoot,
     });
     return (0, exports.parseFfmpegVersion)(buildInfo);
 };
 exports.getFfmpegVersion = getFfmpegVersion;
+const waitForFfmpegToBeDownloaded = (url) => {
+    return new Promise((resolve) => {
+        if (!listeners[url]) {
+            listeners[url] = [];
+        }
+        listeners[url].push((src) => resolve(src));
+    });
+};
+const onProgress = (downloadedBytes, totalBytesToDownload, binary) => {
+    console.log('Downloading ', binary, `${toMegabytes(downloadedBytes)}/${toMegabytes(totalBytesToDownload)}`);
+};
+const downloadBinary = async (remotionRoot, url, binary) => {
+    const destinationPath = getFfmpegAbsolutePath(remotionRoot, binary);
+    const onProgressCallback = (downloadedBytes, _totalBytes) => {
+        onProgress(downloadedBytes, _totalBytes, binary);
+    };
+    isDownloading[url] = true;
+    const totalBytes = await (0, BrowserFetcher_1._downloadFile)(url, destinationPath, onProgressCallback);
+    onProgress(totalBytes, totalBytes, binary);
+    if (os_1.default.platform() !== 'win32') {
+        fs_1.default.chmodSync(destinationPath, '777');
+    }
+    isDownloading[url] = false;
+    if (!listeners[url]) {
+        listeners[url] = [];
+    }
+    listeners[url].forEach((listener) => listener(destinationPath));
+    listeners[url] = [];
+    return destinationPath;
+};
+exports.downloadBinary = downloadBinary;
+exports.lambdaFfmpegPaths = {
+    ffmpeg: '/opt/bin/ffmpeg',
+    ffprobe: '/opt/bin/ffprobe',
+};
+const getExecutableBinary = (ffmpegExecutable, remotionRoot, binary) => {
+    if (fs_1.default.existsSync(exports.lambdaFfmpegPaths[binary])) {
+        return exports.lambdaFfmpegPaths[binary];
+    }
+    if (ffmpegExecutable && (0, validate_ffmpeg_1.customExecutableExists)(ffmpegExecutable)) {
+        return ffmpegExecutable;
+    }
+    if ((0, validate_ffmpeg_1.binaryExists)(binary)) {
+        return binary;
+    }
+    const dlUrl = (0, exports.getBinaryDownloadUrl)(binary);
+    if (dlUrl && isDownloading[dlUrl.url]) {
+        return waitForFfmpegToBeDownloaded(dlUrl.url);
+    }
+    const inNodeMod = (0, exports.ffmpegInNodeModules)(remotionRoot, binary);
+    if (inNodeMod) {
+        return inNodeMod;
+    }
+    if (!dlUrl) {
+        throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);
+    }
+    return (0, exports.downloadBinary)(remotionRoot, dlUrl.url, binary);
+};
+exports.getExecutableBinary = getExecutableBinary;
+function toMegabytes(bytes) {
+    const mb = bytes / 1024 / 1024;
+    return `${Math.round(mb * 10) / 10} Mb`;
+}
+const getBinaryDownloadUrl = (binary) => {
+    if (os_1.default.platform() === 'win32') {
+        return binary === 'ffmpeg'
+            ? {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-win-x86.exe',
+                contentLength: 127531008,
+            }
+            : {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-win-x86.exe',
+                contentLength: 127425536,
+            };
+    }
+    if (os_1.default.platform() === 'darwin') {
+        if (process.arch === 'arm64') {
+            return binary === 'ffmpeg'
+                ? {
+                    url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-macos-arm64',
+                    contentLength: 42093320,
+                }
+                : {
+                    url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-macos-arm64',
+                    contentLength: 46192536,
+                };
+        }
+        return binary === 'ffmpeg'
+            ? {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-macos-x86',
+                contentLength: 78380700,
+            }
+            : {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-macos-x86',
+                contentLength: 77364284,
+            };
+    }
+    return binary === 'ffmpeg'
+        ? {
+            url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-linux-amd64',
+            contentLength: 78502560,
+        }
+        : {
+            url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-linux-amd64',
+            contentLength: 78400704,
+        };
+};
+exports.getBinaryDownloadUrl = getBinaryDownloadUrl;
 const printMessage = (ffmpegVersion) => {
     console.warn('⚠️Old FFMPEG version detected: ' + ffmpegVersion.join('.'));
-    console.warn('   For audio support, you need at least version 4.1.0.');
+    console.warn('   You need at least version 4.1.0.');
     console.warn('   Upgrade FFMPEG to get rid of this warning.');
 };
 const printBuildConfMessage = () => {

package/dist/get-browser-instance.js

@@ -26,7 +26,7 @@ const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromi
         page: browserPage,
         cleanup: () => {
             // Close whole browser that was just created and don't wait for it to finish.
-            browserInstance.close().catch((err) => {
+            browserInstance.close(true).catch((err) => {
                 console.error('Was not able to close puppeteer page', err);
             });
         },