@remotion/renderer 4.0.0-alpha.4 → 4.0.0-alpha5

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { OffthreadVideoImageFormat } from 'remotion';
 import type { DownloadMap } from './assets/download-map';
 import type { FfmpegExecutable } from './ffmpeg-executable';
@@ -10,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

@@ -6,150 +6,70 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmpeg_flags_1 = require("./determine-vcodec-ffmpeg-flags");
 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_can_extract_frames_fast_1 = require("./get-can-extract-frames-fast");
+const get_frame_of_video_slow_1 = require("./get-frame-of-video-slow");
 const get_video_info_1 = require("./get-video-info");
 const is_beyond_last_frame_1 = require("./is-beyond-last-frame");
 const last_frame_from_video_cache_1 = require("./last-frame-from-video-cache");
 const p_limit_1 = require("./p-limit");
 const perf_1 = require("./perf");
 const truthy_1 = require("./truthy");
+const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-video-fast");
 const lastFrameLimit = (0, p_limit_1.pLimit)(1);
 const mainLimit = (0, p_limit_1.pLimit)(5);
-const determineVcodecFfmepgFlags = (vcodecFlag) => {
-    return [
-        vcodecFlag === 'vp9' ? '-vcodec' : null,
-        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
-        vcodecFlag === 'vp8' ? '-vcodec' : null,
-        vcodecFlag === 'vp8' ? 'libvpx' : null,
-    ].filter(truthy_1.truthy);
-};
-const determineResizeParams = (needsResize) => {
-    if (needsResize === null) {
-        return [];
-    }
-    return ['-s', `${needsResize[0]}x${needsResize[1]}`];
-};
-// 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, timestamp, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, }) => {
-    console.warn(`\nUsing a slow method to extract the frame at ${timestamp}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
-    const actualOffset = `-${timestamp * 1000}ms`;
-    const command = [
-        '-itsoffset',
-        actualOffset,
-        ...determineVcodecFfmepgFlags(specialVCodecForTransparency),
-        '-i',
-        src,
-        '-frames:v',
-        '1',
-        '-c:v',
-        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
-        '-f',
-        'image2pipe',
-        ...determineResizeParams(needsResize),
-        '-',
-    ].filter(truthy_1.truthy);
-    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', command);
-    if (!stderr) {
-        throw new Error('unexpectedly did not get stderr');
-    }
-    if (!stdout) {
-        throw new Error('unexpectedly did not get stdout');
-    }
-    const stderrChunks = [];
-    const stdoutChunks = [];
-    const stdErrString = new Promise((resolve, reject) => {
-        stderr.on('data', (d) => stderrChunks.push(d));
-        stderr.on('error', (err) => reject(err));
-        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
-    });
-    const stdoutChunk = new Promise((resolve, reject) => {
-        stdout.on('data', (d) => stdoutChunks.push(d));
-        stdout.on('error', (err) => reject(err));
-        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
-    });
-    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
-    const isEmpty = stdErr.includes('Output file is empty');
-    if (isEmpty) {
-        throw new Error(`Could not get last frame of ${src}. Tried to seek to the end using the command "ffmpeg ${command.join(' ')}" but got no frame. Most likely this video is corrupted.`);
-    }
-    return stdoutBuffer;
-};
 const getLastFrameOfVideoFastUnlimited = async (options) => {
     const { ffmpegExecutable, ffprobeExecutable, offset, src, downloadMap } = options;
     const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)({ ...options, offset: 0 });
     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.`);
     }
-    if (options.specialVCodecForTransparency === 'vp8' || offset > 40) {
-        const last = await getFrameOfVideoSlow({
-            timestamp: duration,
+    if (options.specialVCodecForTransparency === 'vp8' ||
+        offset > get_can_extract_frames_fast_1.ACCEPTABLE_OFFSET_THRESHOLD) {
+        const last = await (0, get_frame_of_video_slow_1.getFrameOfVideoSlow)({
+            duration,
             ffmpegExecutable,
             src,
             imageFormat: options.imageFormat,
             specialVCodecForTransparency: options.specialVCodecForTransparency,
             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', [
-        '-ss',
+    const [stdErr, stdoutBuffer] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
         actualOffset,
-        ...determineVcodecFfmepgFlags(options.specialVCodecForTransparency),
-        '-i',
+        ffmpegExecutable,
+        imageFormat: options.imageFormat,
+        needsResize: options.needsResize,
+        remotionRoot: options.remotionRoot,
+        specialVCodecForTransparency: options.specialVCodecForTransparency,
         src,
-        '-frames:v',
-        '1',
-        '-c:v',
-        options.imageFormat === 'jpeg' ? 'mjpeg' : 'png',
-        '-f',
-        'image2pipe',
-        ...determineResizeParams(options.needsResize),
-        '-',
-    ].filter(truthy_1.truthy));
-    if (!stderr) {
-        throw new Error('unexpectedly did not get stderr');
-    }
-    if (!stdout) {
-        throw new Error('unexpectedly did not get stdout');
-    }
-    const stderrChunks = [];
-    const stdoutChunks = [];
-    const stdErrString = new Promise((resolve, reject) => {
-        stderr.on('data', (d) => stderrChunks.push(d));
-        stderr.on('error', (err) => reject(err));
-        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
     });
-    const stdoutChunk = new Promise((resolve, reject) => {
-        stdout.on('data', (d) => {
-            stdoutChunks.push(d);
-        });
-        stdout.on('error', (err) => {
-            reject(err);
-        });
-        stdout.on('end', () => {
-            resolve(Buffer.concat(stdoutChunks));
-        });
-    });
-    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
     const isEmpty = stdErr.includes('Output file is empty');
     if (isEmpty) {
         const unlimited = await getLastFrameOfVideoFastUnlimited({
             ffmpegExecutable,
             // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
-            offset: offset + 1000 / (fps === null ? 10 : fps),
+            offset: offset + (fps === null ? 10 : 1000 / fps),
             src,
             ffprobeExecutable,
             imageFormat: options.imageFormat,
             specialVCodecForTransparency: options.specialVCodecForTransparency,
             needsResize: options.needsResize,
             downloadMap: options.downloadMap,
+            remotionRoot: options.remotionRoot,
         });
         return unlimited;
     }
@@ -161,19 +81,29 @@ 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 { specialVcodecForTransparency: specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src, ffprobeExecutable, remotionRoot);
     if (specialVcodec === 'vp8') {
-        return getFrameOfVideoSlow({
+        const { fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable, remotionRoot);
+        return (0, get_frame_of_video_slow_1.getFrameOfVideoSlow)({
             ffmpegExecutable,
             imageFormat,
             specialVCodecForTransparency: specialVcodec,
             src,
-            timestamp: time,
+            duration: time,
             needsResize,
+            offset: 0,
+            fps,
+            remotionRoot,
         });
     }
     if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(downloadMap, src, time)) {
@@ -186,14 +116,15 @@ 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),
+        ...(0, determine_vcodec_ffmpeg_flags_1.determineVcodecFfmpegFlags)(specialVcodec),
         '-i',
         src,
         '-frames:v',
@@ -202,7 +133,7 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
         'image2pipe',
         '-vcodec',
         imageFormat === 'jpeg' ? 'mjpeg' : 'png',
-        ...determineResizeParams(needsResize),
+        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
         '-',
     ].filter(truthy_1.truthy), {
         buffer: false,
@@ -240,9 +171,15 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
             specialVCodecForTransparency: specialVcodec,
             needsResize,
             downloadMap,
+            remotionRoot,
         });
         return last;
     }
+    if (stdOut.length === 0) {
+        console.log('FFMPEG Logs:');
+        console.log(stderrStr);
+        throw new Error("Couldn't extract frame from video - FFMPEG did not return any data. Check logs to see more information");
+    }
     return stdOut;
 };
 const extractFrameFromVideo = async (options) => {

package/dist/ffmpeg-filter-file.d.ts

@@ -1,5 +1,10 @@
 import type { DownloadMap } from './assets/download-map';
-export declare const makeFfmpegFilterFile: (complexFilter: string, downloadMap: DownloadMap) => Promise<{
+import type { FilterWithoutPaddingApplied } from './stringify-ffmpeg-filter';
+export declare const makeFfmpegFilterFile: (complexFilter: FilterWithoutPaddingApplied, downloadMap: DownloadMap) => Promise<{
+    file: string;
+    cleanup: () => void;
+}>;
+export declare const makeFfmpegFilterFileStr: (complexFilter: string, downloadMap: DownloadMap) => Promise<{
     file: string;
     cleanup: () => void;
 }>;

package/dist/ffmpeg-filter-file.js

@@ -1,16 +1,48 @@
 "use strict";
 // While an FFMPEG filter can be passed directly, if it's too long
 // we run into Windows command length limits.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeFfmpegFilterFile = void 0;
-const fs_1 = __importDefault(require("fs"));
+exports.makeFfmpegFilterFileStr = exports.makeFfmpegFilterFile = void 0;
+const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
-const makeFfmpegFilterFile = async (complexFilter, downloadMap) => {
+const makeFfmpegFilterFile = (complexFilter, downloadMap) => {
+    return (0, exports.makeFfmpegFilterFileStr)(complexFilter.filter, downloadMap);
+};
+exports.makeFfmpegFilterFile = makeFfmpegFilterFile;
+const makeFfmpegFilterFileStr = async (complexFilter, downloadMap) => {
     const random = Math.random().toString().replace('.', '');
     const filterFile = path_1.default.join(downloadMap.complexFilter, 'complex-filter-' + random + '.txt');
+    // Race condition: Sometimes the download map is deleted before the file is written.
+    // Can remove this once the original bug has been fixed
+    if (!(0, fs_1.existsSync)(downloadMap.complexFilter)) {
+        fs_1.default.mkdirSync(downloadMap.complexFilter, { recursive: true });
+    }
     await fs_1.default.promises.writeFile(filterFile, complexFilter);
     return {
         file: filterFile,
@@ -19,4 +51,4 @@ const makeFfmpegFilterFile = async (complexFilter, downloadMap) => {
         },
     };
 };
-exports.makeFfmpegFilterFile = makeFfmpegFilterFile;
+exports.makeFfmpegFilterFileStr = makeFfmpegFilterFileStr;

package/dist/ffmpeg-flags.d.ts

@@ -1,13 +1,31 @@
+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, isLambda, }: {
+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';
-    isLambda: boolean;
+    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;
+}) => null | undefined;

package/dist/ffmpeg-flags.js

@@ -3,31 +3,81 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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, isLambda, }) => {
-    if (isLambda) {
-        // When rendering in the cloud, we don't need a local binary
-        return true;
+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, {
+            recursive: true,
+        });
+    }
+    // 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);
+    }
+    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 (!(await (0, validate_ffmpeg_1.binaryExists)('ffmpeg', ffmpegExecutable))) {
+    if (!(0, validate_ffmpeg_1.binaryExists)('ffmpeg')) {
         return false;
     }
-    const config = await (0, exports.getFfmpegBuildInfo)({ ffmpegExecutable });
+    const config = await (0, exports.getFfmpegBuildInfo)({ ffmpegExecutable, remotionRoot });
     return config.includes(feature);
 };
 exports.ffmpegHasFeature = ffmpegHasFeature;
@@ -43,7 +93,153 @@ 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' && process.arch === 'x64') {
+        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' && 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-v2',
+                contentLength: 46690008,
+            };
+    }
+    if (os_1.default.platform() === 'darwin' && process.arch === 'x64') {
+        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,
+            };
+    }
+    if (os_1.default.platform() === 'linux' && process.arch === 'x64') {
+        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,
+            };
+    }
+    return null;
+};
+exports.getBinaryDownloadUrl = getBinaryDownloadUrl;
+const printMessage = (ffmpegVersion) => {
+    console.warn('⚠️Old FFMPEG version detected: ' + ffmpegVersion.join('.'));
+    console.warn('   You need at least version 4.1.0.');
+    console.warn('   Upgrade FFMPEG to get rid of this warning.');
+};
+const printBuildConfMessage = () => {
+    console.error('⚠️  Unsupported FFMPEG version detected.');
+    console.error("   Your version doesn't support the -buildconf flag");
+    console.error('   Audio will not be supported and you may experience other issues.');
+    console.error('   Upgrade FFMPEG to at least v4.1.0 to get rid of this warning.');
+};
+const warnAboutFfmpegVersion = ({ ffmpegVersion, buildConf, }) => {
+    if (buildConf === null) {
+        printBuildConfMessage();
+        return;
+    }
+    if (ffmpegVersion === null) {
+        return null;
+    }
+    const [major, minor] = ffmpegVersion;
+    // 3.x and below definitely is too old
+    if (major < 4) {
+        printMessage(ffmpegVersion);
+        return;
+    }
+    // 5.x will be all good
+    if (major > 4) {
+        return;
+    }
+    if (minor < 1) {
+        printMessage(ffmpegVersion);
+    }
+};
+exports.warnAboutFfmpegVersion = warnAboutFfmpegVersion;

package/dist/ffmpeg-override.d.ts

@@ -0,0 +1,4 @@
+export declare type FfmpegOverrideFn = (info: {
+    type: 'pre-stitcher' | 'stitcher';
+    args: string[];
+}) => string[];

package/dist/ffmpeg-override.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/file-extensions.d.ts

@@ -0,0 +1,14 @@
+import type { supportedAudioCodecs } from './audio-codec';
+import type { Codec } from './codec';
+export declare type FileExtension = 'aac' | '3gp' | 'm4a' | 'm4b' | 'mpg' | 'mpeg' | 'mkv' | 'mp4' | 'gif' | 'hevc' | 'mp3' | 'mov' | 'mxf' | 'wav' | 'webm';
+export declare const defaultFileExtensionMap: {
+    [key in Codec]: {
+        default: FileExtension;
+        forAudioCodec: {
+            [k in typeof supportedAudioCodecs[key][number]]: {
+                possible: FileExtension[];
+                default: FileExtension;
+            };
+        };
+    };
+};