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

package/dist/merge-audio-track.js

@@ -7,70 +7,83 @@ exports.mergeAudioTrack = void 0;
 const execa_1 = __importDefault(require("execa"));
 const path_1 = __importDefault(require("path"));
 const chunk_1 = require("./chunk");
-const convert_to_pcm_1 = require("./convert-to-pcm");
 const create_ffmpeg_complex_filter_1 = require("./create-ffmpeg-complex-filter");
+const create_ffmpeg_merge_filter_1 = require("./create-ffmpeg-merge-filter");
 const create_silent_audio_1 = require("./create-silent-audio");
 const delete_directory_1 = require("./delete-directory");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const p_limit_1 = require("./p-limit");
 const tmp_dir_1 = require("./tmp-dir");
 const truthy_1 = require("./truthy");
-const mergeAudioTrackUnlimited = async ({ ffmpegExecutable, outName, files, numberOfSeconds, downloadMap, }) => {
+const mergeAudioTrackUnlimited = async ({ ffmpegExecutable, outName, files, numberOfSeconds, downloadMap, remotionRoot, }) => {
     if (files.length === 0) {
         await (0, create_silent_audio_1.createSilentAudio)({
             outName,
             ffmpegExecutable,
             numberOfSeconds,
+            remotionRoot,
         });
         return;
     }
-    if (files.length === 1) {
-        await (0, convert_to_pcm_1.convertToPcm)({
-            outName,
-            ffmpegExecutable,
-            input: files[0],
-        });
-        return;
-    }
+    // Previously a bug: We cannot optimize for files.length === 1 because we need to pad the audio
     // In FFMPEG, the total number of left and right tracks that can be merged at one time is limited to 64
     if (files.length >= 32) {
         const chunked = (0, chunk_1.chunk)(files, 10);
         const tempPath = (0, tmp_dir_1.tmpDir)('remotion-large-audio-mixing');
-        const chunkNames = await Promise.all(chunked.map(async (chunkFiles, i) => {
-            const chunkOutname = path_1.default.join(tempPath, `chunk-${i}.wav`);
+        try {
+            const chunkNames = await Promise.all(chunked.map(async (chunkFiles, i) => {
+                const chunkOutname = path_1.default.join(tempPath, `chunk-${i}.wav`);
+                await (0, exports.mergeAudioTrack)({
+                    ffmpegExecutable,
+                    files: chunkFiles,
+                    numberOfSeconds,
+                    outName: chunkOutname,
+                    downloadMap,
+                    remotionRoot,
+                });
+                return chunkOutname;
+            }));
             await (0, exports.mergeAudioTrack)({
                 ffmpegExecutable,
-                files: chunkFiles,
+                files: chunkNames.map((c) => ({
+                    filter: {
+                        pad_end: null,
+                        pad_start: null,
+                    },
+                    outName: c,
+                })),
                 numberOfSeconds,
-                outName: chunkOutname,
+                outName,
                 downloadMap,
+                remotionRoot,
             });
-            return chunkOutname;
-        }));
-        await (0, exports.mergeAudioTrack)({
-            ffmpegExecutable,
-            files: chunkNames,
-            numberOfSeconds,
-            outName,
-            downloadMap,
-        });
-        await (0, delete_directory_1.deleteDirectory)(tempPath);
-        return;
+            return;
+        }
+        finally {
+            (0, delete_directory_1.deleteDirectory)(tempPath);
+        }
     }
-    const { complexFilterFlag: mergeFilter, cleanup } = await (0, create_ffmpeg_complex_filter_1.createFfmpegComplexFilter)(files.length, downloadMap);
+    const { complexFilterFlag: mergeFilter, cleanup } = await (0, create_ffmpeg_complex_filter_1.createFfmpegComplexFilter)({
+        filters: files,
+        downloadMap,
+        ffmpegExecutable,
+        remotionRoot,
+    });
     const args = [
-        ...files.map((f) => ['-i', f]),
+        ...files.map((f) => ['-i', f.outName]),
         mergeFilter,
         ['-c:a', 'pcm_s16le'],
-        ['-map', '[a]'],
+        ['-map', `[${create_ffmpeg_merge_filter_1.OUTPUT_FILTER_NAME}]`],
         ['-y', outName],
     ]
         .filter(truthy_1.truthy)
         .flat(2);
-    const task = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', args);
+    const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), args);
     await task;
     cleanup();
 };
-const limit = (0, p_limit_1.pLimit)(2);
+// Must be at least 3 because recursively called twice in mergeAudioTrack
+const limit = (0, p_limit_1.pLimit)(3);
 const mergeAudioTrack = (options) => {
     return limit(mergeAudioTrackUnlimited, options);
 };

package/dist/mime-types.d.ts

@@ -1,2 +1,3 @@
+export declare const getExt: (contentType: string) => string | null;
 export declare function mimeLookup(path: string): string | false;
 export declare function mimeContentType(str: string): false | string;

package/dist/mime-types.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mimeContentType = exports.mimeLookup = void 0;
+exports.mimeContentType = exports.mimeLookup = exports.getExt = void 0;
 const path_1 = require("path");
 const mime_db_1 = require("./mime-db");
 const extensions = {};
 const types = {};
 // Populate the extensions/types maps
 populateMaps(extensions, {});
+const getExt = (contentType) => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = mime_db_1.mimeDb[contentType.toLowerCase()]) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : null;
+};
+exports.getExt = getExt;
 function mimeLookup(path) {
     if (!path || typeof path !== 'string') {
         return false;

package/dist/offthread-video-server.d.ts

@@ -8,10 +8,11 @@ export declare const extractUrlAndSourceFromUrl: (url: string) => {
     time: number;
     imageFormat: OffthreadVideoImageFormat;
 };
-export declare const startOffthreadVideoServer: ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, downloadMap, }: {
+export declare const startOffthreadVideoServer: ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, downloadMap, remotionRoot, }: {
     ffmpegExecutable: FfmpegExecutable;
     ffprobeExecutable: FfmpegExecutable;
     onDownload: RenderMediaOnDownload;
     onError: (err: Error) => void;
     downloadMap: DownloadMap;
+    remotionRoot: string;
 }) => RequestListener;

package/dist/offthread-video-server.js

@@ -32,7 +32,7 @@ const extractUrlAndSourceFromUrl = (url) => {
     };
 };
 exports.extractUrlAndSourceFromUrl = extractUrlAndSourceFromUrl;
-const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, downloadMap, }) => {
+const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, downloadMap, remotionRoot, }) => {
     return (req, res) => {
         if (!req.url) {
             throw new Error('Request came in without URL');
@@ -45,6 +45,17 @@ const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, onDown
         const { src, time, imageFormat } = (0, exports.extractUrlAndSourceFromUrl)(req.url);
         res.setHeader('access-control-allow-origin', '*');
         res.setHeader('content-type', `image/${imageFormat === 'jpeg' ? 'jpg' : 'png'}`);
+        // Handling this case on Lambda:
+        // https://support.google.com/chrome/a/answer/7679408?hl=en
+        // Chrome sends Private Network Access preflights for subresources
+        if (req.method === 'OPTIONS') {
+            res.statusCode = 200;
+            if (req.headers['access-control-request-private-network']) {
+                res.setHeader('Access-Control-Allow-Private-Network', 'true');
+            }
+            res.end();
+            return;
+        }
         (0, download_and_map_assets_to_file_1.downloadAsset)({ src, onDownload, downloadMap })
             .then((to) => {
             return (0, extract_frame_from_video_1.extractFrameFromVideo)({
@@ -54,6 +65,7 @@ const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, onDown
                 ffprobeExecutable,
                 imageFormat,
                 downloadMap,
+                remotionRoot,
             });
         })
             .then((readable) => {

package/dist/open-browser.d.ts

@@ -8,8 +8,13 @@ export declare type ChromiumOptions = {
     disableWebSecurity?: boolean;
     gl?: OpenGlRenderer | null;
     headless?: boolean;
+    userAgent?: string | null;
 };
 export declare const killAllBrowsers: () => Promise<void>;
+/**
+ * @description Opens a Chrome or Chromium browser instance.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/open-browser)
+ */
 export declare const openBrowser: (browser: Browser, options?: {
     shouldDumpIo?: boolean;
     browserExecutable?: string | null;

package/dist/open-browser.js

@@ -1,12 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.openBrowser = exports.killAllBrowsers = void 0;
-const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
 const node_1 = require("./browser/node");
 const get_local_browser_executable_1 = require("./get-local-browser-executable");
 const get_video_threads_flag_1 = require("./get-video-threads-flag");
@@ -27,14 +21,18 @@ const browserInstances = [];
 const killAllBrowsers = async () => {
     for (const browser of browserInstances) {
         try {
-            await browser.close();
+            await browser.close(true);
         }
         catch (err) { }
     }
 };
 exports.killAllBrowsers = killAllBrowsers;
+/**
+ * @description Opens a Chrome or Chromium browser instance.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/open-browser)
+ */
 const openBrowser = async (browser, options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     if (browser === 'firefox') {
         throw new TypeError('Firefox supported is not yet turned on. Stay tuned for the future.');
     }
@@ -57,11 +55,11 @@ const openBrowser = async (browser, options) => {
             '--disable-component-extensions-with-background-pages',
             '--disable-default-apps',
             '--disable-dev-shm-usage',
-            '--disable-extensions',
             '--no-proxy-server',
             "--proxy-server='direct://'",
             '--proxy-bypass-list=*',
             '--disable-hang-monitor',
+            '--disable-extensions',
             '--disable-ipc-flooding-protection',
             '--disable-popup-blocking',
             '--disable-prompt-on-repost',
@@ -102,14 +100,13 @@ const openBrowser = async (browser, options) => {
                 ? '--ignore-certificate-errors'
                 : null,
             ...(((_j = options === null || options === void 0 ? void 0 : options.chromiumOptions) === null || _j === void 0 ? void 0 : _j.disableWebSecurity)
-                ? [
-                    '--disable-web-security',
-                    '--user-data-dir=' +
-                        (await fs_1.default.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'chrome-user-dir'))),
-                ]
+                ? ['--disable-web-security']
                 : []),
+            ((_k = options === null || options === void 0 ? void 0 : options.chromiumOptions) === null || _k === void 0 ? void 0 : _k.userAgent)
+                ? `--user-agent="${options.chromiumOptions.userAgent}"`
+                : null,
         ].filter(Boolean),
-        defaultViewport: (_k = options === null || options === void 0 ? void 0 : options.viewport) !== null && _k !== void 0 ? _k : {
+        defaultViewport: (_l = options === null || options === void 0 ? void 0 : options.viewport) !== null && _l !== void 0 ? _l : {
             height: 720,
             width: 1280,
             deviceScaleFactor: 1,

package/dist/pixel-format.d.ts

@@ -2,4 +2,4 @@ import type { Codec } from './codec';
 export declare const validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
 export declare type PixelFormat = typeof validPixelFormats[number];
 export declare const DEFAULT_PIXEL_FORMAT: PixelFormat;
-export declare const validateSelectedPixelFormatAndCodecCombination: (pixelFormat: PixelFormat, codec: Codec) => void;
+export declare const validateSelectedPixelFormatAndCodecCombination: (pixelFormat: PixelFormat | undefined, codec: Codec) => undefined;

package/dist/pixel-format.js

@@ -13,6 +13,9 @@ exports.validPixelFormats = [
 ];
 exports.DEFAULT_PIXEL_FORMAT = 'yuv420p';
 const validateSelectedPixelFormatAndCodecCombination = (pixelFormat, codec) => {
+    if (typeof pixelFormat === 'undefined') {
+        return pixelFormat;
+    }
     if (!exports.validPixelFormats.includes(pixelFormat)) {
         throw new TypeError(`Value ${pixelFormat} is not valid as a pixel format.`);
     }

package/dist/prepare-server.d.ts

@@ -1,7 +1,7 @@
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { DownloadMap } from './assets/download-map';
 import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare const prepareServer: ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, downloadMap, }: {
+export declare const prepareServer: ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, downloadMap, remotionRoot, }: {
     webpackConfigOrServeUrl: string;
     onDownload: RenderMediaOnDownload;
     onError: (err: Error) => void;
@@ -9,8 +9,9 @@ export declare const prepareServer: ({ ffmpegExecutable, ffprobeExecutable, onDo
     ffprobeExecutable: FfmpegExecutable;
     port: number | null;
     downloadMap: DownloadMap;
+    remotionRoot: string;
 }) => Promise<{
     serveUrl: string;
-    closeServer: () => Promise<unknown>;
+    closeServer: (force: boolean) => Promise<unknown>;
     offthreadPort: number;
 }>;

package/dist/prepare-server.js

@@ -9,7 +9,7 @@ const path_1 = __importDefault(require("path"));
 const is_serve_url_1 = require("./is-serve-url");
 const serve_static_1 = require("./serve-static");
 const wait_for_symbolication_error_to_be_done_1 = require("./wait-for-symbolication-error-to-be-done");
-const prepareServer = async ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, downloadMap, }) => {
+const prepareServer = async ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, downloadMap, remotionRoot, }) => {
     if ((0, is_serve_url_1.isServeUrl)(webpackConfigOrServeUrl)) {
         const { port: offthreadPort, close: closeProxy } = await (0, serve_static_1.serveStatic)(null, {
             onDownload,
@@ -18,6 +18,7 @@ const prepareServer = async ({ ffmpegExecutable, ffprobeExecutable, onDownload,
             ffprobeExecutable,
             port,
             downloadMap,
+            remotionRoot,
         });
         return Promise.resolve({
             serveUrl: webpackConfigOrServeUrl,
@@ -40,10 +41,14 @@ const prepareServer = async ({ ffmpegExecutable, ffprobeExecutable, onDownload,
         ffprobeExecutable,
         port,
         downloadMap,
+        remotionRoot,
     });
     return Promise.resolve({
-        closeServer: () => {
-            return (0, wait_for_symbolication_error_to_be_done_1.waitForSymbolicationToBeDone)().then(() => close());
+        closeServer: async (force) => {
+            if (!force) {
+                await (0, wait_for_symbolication_error_to_be_done_1.waitForSymbolicationToBeDone)();
+            }
+            return close();
         },
         serveUrl: `http://localhost:${serverPort}`,
         offthreadPort: serverPort,

package/dist/preprocess-audio-track.d.ts

@@ -1,6 +1,7 @@
 import type { DownloadMap } from './assets/download-map';
 import type { MediaAsset } from './assets/types';
 import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { ProcessedTrack } from './stringify-ffmpeg-filter';
 declare type Options = {
     ffmpegExecutable: FfmpegExecutable;
     ffprobeExecutable: FfmpegExecutable;
@@ -9,6 +10,11 @@ declare type Options = {
     expectedFrames: number;
     fps: number;
     downloadMap: DownloadMap;
+    remotionRoot: string;
 };
-export declare const preprocessAudioTrack: (options: Options) => Promise<string | null>;
+export declare type PreprocessedAudioTrack = {
+    outName: string;
+    filter: ProcessedTrack;
+};
+export declare const preprocessAudioTrack: (options: Options) => Promise<PreprocessedAudioTrack | null>;
 export {};

package/dist/preprocess-audio-track.js

@@ -8,10 +8,12 @@ const execa_1 = __importDefault(require("execa"));
 const get_audio_channels_1 = require("./assets/get-audio-channels");
 const calculate_ffmpeg_filters_1 = require("./calculate-ffmpeg-filters");
 const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const p_limit_1 = require("./p-limit");
 const resolve_asset_src_1 = require("./resolve-asset-src");
-const preprocessAudioTrackUnlimited = async ({ ffmpegExecutable, ffprobeExecutable, outName, asset, expectedFrames, fps, downloadMap, }) => {
-    const { channels, duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)(downloadMap, (0, resolve_asset_src_1.resolveAssetSrc)(asset.src), ffprobeExecutable);
+const sample_rate_1 = require("./sample-rate");
+const preprocessAudioTrackUnlimited = async ({ ffmpegExecutable, ffprobeExecutable, outName, asset, expectedFrames, fps, downloadMap, remotionRoot, }) => {
+    const { channels, duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)(downloadMap, (0, resolve_asset_src_1.resolveAssetSrc)(asset.src), ffprobeExecutable, remotionRoot);
     const filter = (0, calculate_ffmpeg_filters_1.calculateFfmpegFilter)({
         asset,
         durationInFrames: expectedFrames,
@@ -28,11 +30,12 @@ const preprocessAudioTrackUnlimited = async ({ ffmpegExecutable, ffprobeExecutab
         ['-ac', '2'],
         ['-filter_script:a', file],
         ['-c:a', 'pcm_s16le'],
+        ['-ar', String(sample_rate_1.DEFAULT_SAMPLE_RATE)],
         ['-y', outName],
     ].flat(2);
-    await (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', args);
+    await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), args);
     cleanup();
-    return outName;
+    return { outName, filter };
 };
 const limit = (0, p_limit_1.pLimit)(2);
 const preprocessAudioTrack = (options) => {

package/dist/prespawn-ffmpeg.d.ts

@@ -1,6 +1,7 @@
 import execa from 'execa';
 import type { Codec } from './codec';
 import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { FfmpegOverrideFn } from './ffmpeg-override';
 import type { ImageFormat } from './image-format';
 import type { CancelSignal } from './make-cancel-signal';
 import type { PixelFormat } from './pixel-format';
@@ -18,9 +19,11 @@ declare type PreSticherOptions = {
     verbose: boolean;
     ffmpegExecutable: FfmpegExecutable | undefined;
     imageFormat: ImageFormat;
+    ffmpegOverride: FfmpegOverrideFn;
     signal: CancelSignal;
+    videoBitrate: string | null;
 };
-export declare const prespawnFfmpeg: (options: PreSticherOptions) => Promise<{
+export declare const prespawnFfmpeg: (options: PreSticherOptions, remotionRoot: string) => Promise<{
     task: execa.ExecaChildProcess<string>;
     getLogs: () => string;
 }>;

package/dist/prespawn-ffmpeg.js

@@ -8,14 +8,15 @@ const execa_1 = __importDefault(require("execa"));
 const remotion_1 = require("remotion");
 const codec_1 = require("./codec");
 const crf_1 = require("./crf");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const get_codec_name_1 = require("./get-codec-name");
 const get_prores_profile_name_1 = require("./get-prores-profile-name");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const pixel_format_1 = require("./pixel-format");
 const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
 const validate_ffmpeg_1 = require("./validate-ffmpeg");
-const prespawnFfmpeg = async (options) => {
-    var _a, _b, _c, _d, _e, _f, _g;
+const prespawnFfmpeg = async (options, remotionRoot) => {
+    var _a, _b, _c, _d, _e, _f;
     remotion_1.Internals.validateDimension(options.height, 'height', 'passed to `stitchFramesToVideo()`');
     remotion_1.Internals.validateDimension(options.width, 'width', 'passed to `stitchFramesToVideo()`');
     const codec = (_a = options.codec) !== null && _a !== void 0 ? _a : codec_1.DEFAULT_CODEC;
@@ -26,9 +27,8 @@ const prespawnFfmpeg = async (options) => {
         codec,
         scale: 1,
     });
-    const crf = (_b = options.crf) !== null && _b !== void 0 ? _b : (0, crf_1.getDefaultCrfForCodec)(codec);
-    const pixelFormat = (_c = options.pixelFormat) !== null && _c !== void 0 ? _c : pixel_format_1.DEFAULT_PIXEL_FORMAT;
-    await (0, validate_ffmpeg_1.validateFfmpeg)((_d = options.ffmpegExecutable) !== null && _d !== void 0 ? _d : null);
+    const pixelFormat = (_b = options.pixelFormat) !== null && _b !== void 0 ? _b : pixel_format_1.DEFAULT_PIXEL_FORMAT;
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_c = options.ffmpegExecutable) !== null && _c !== void 0 ? _c : null, remotionRoot, 'ffmpeg');
     const encoderName = (0, get_codec_name_1.getCodecName)(codec);
     const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
     if (encoderName === null) {
@@ -36,16 +36,15 @@ const prespawnFfmpeg = async (options) => {
     }
     const supportsCrf = codec !== 'prores';
     if (options.verbose) {
-        console.log('[verbose] ffmpeg', (_e = options.ffmpegExecutable) !== null && _e !== void 0 ? _e : 'ffmpeg in PATH');
+        console.log('[verbose] ffmpeg', (_d = options.ffmpegExecutable) !== null && _d !== void 0 ? _d : 'ffmpeg in PATH');
         console.log('[verbose] encoder', encoderName);
         console.log('[verbose] pixelFormat', pixelFormat);
         if (supportsCrf) {
-            console.log('[verbose] crf', crf);
+            console.log('[verbose] crf', options.crf);
         }
         console.log('[verbose] codec', codec);
         console.log('[verbose] proResProfileName', proResProfileName);
     }
-    (0, crf_1.validateSelectedCrfAndCodecCombination)(crf, codec);
     (0, pixel_format_1.validateSelectedPixelFormatAndCodecCombination)(pixelFormat, codec);
     const ffmpegArgs = [
         ['-r', options.fps.toFixed(2)],
@@ -61,12 +60,15 @@ const prespawnFfmpeg = async (options) => {
         // and specified the video codec.
         ['-c:v', encoderName],
         proResProfileName ? ['-profile:v', proResProfileName] : null,
-        supportsCrf ? ['-crf', String(crf)] : null,
         ['-pix_fmt', pixelFormat],
         // Without explicitly disabling auto-alt-ref,
         // transparent WebM generation doesn't work
         pixelFormat === 'yuva420p' ? ['-auto-alt-ref', '0'] : null,
-        ['-b:v', '1M'],
+        ...(0, crf_1.validateQualitySettings)({
+            crf: options.crf,
+            videoBitrate: options.videoBitrate,
+            codec,
+        }),
         '-y',
         options.outputLocation,
     ];
@@ -75,12 +77,15 @@ const prespawnFfmpeg = async (options) => {
         console.log(ffmpegArgs);
     }
     const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
-    const task = (0, execa_1.default)((_f = options.ffmpegExecutable) !== null && _f !== void 0 ? _f : 'ffmpeg', ffmpegString);
+    const finalFfmpegString = options.ffmpegOverride
+        ? options.ffmpegOverride({ type: 'pre-stitcher', args: ffmpegString })
+        : ffmpegString;
+    const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)((_e = options.ffmpegExecutable) !== null && _e !== void 0 ? _e : null, remotionRoot, 'ffmpeg'), finalFfmpegString);
     options.signal(() => {
         task.kill();
     });
     let ffmpegOutput = '';
-    (_g = task.stderr) === null || _g === void 0 ? void 0 : _g.on('data', (data) => {
+    (_f = task.stderr) === null || _f === void 0 ? void 0 : _f.on('data', (data) => {
         const str = data.toString();
         ffmpegOutput += str;
         if (options.onProgress) {

package/dist/prores-profile.d.ts

@@ -1,5 +1,8 @@
 import type { Codec } from './codec';
 declare const proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
 export declare type ProResProfile = typeof proResProfileOptions[number];
-export declare const validateSelectedCodecAndProResCombination: (actualCodec: Codec, actualProResProfile: ProResProfile | undefined) => void;
+export declare const validateSelectedCodecAndProResCombination: ({ codec, proResProfile, }: {
+    codec: Codec;
+    proResProfile: ProResProfile | undefined;
+}) => void;
 export {};

package/dist/prores-profile.js

@@ -9,13 +9,13 @@ const proResProfileOptions = [
     'light',
     'proxy',
 ];
-const validateSelectedCodecAndProResCombination = (actualCodec, actualProResProfile) => {
-    if (typeof actualProResProfile !== 'undefined' && actualCodec !== 'prores') {
-        throw new TypeError('You have set a ProRes profile but the codec is not "prores". Set the codec to "prores" or remove the ProRes profile.');
+const validateSelectedCodecAndProResCombination = ({ codec, proResProfile, }) => {
+    if (typeof proResProfile !== 'undefined' && codec !== 'prores') {
+        throw new TypeError(`You have set a ProRes profile but the codec is "${codec}". Set the codec to "prores" or remove the ProRes profile.`);
     }
-    if (actualProResProfile !== undefined &&
-        !proResProfileOptions.includes(actualProResProfile)) {
-        throw new TypeError(`The ProRes profile "${actualProResProfile}" is not valid. Valid options are ${proResProfileOptions
+    if (proResProfile !== undefined &&
+        !proResProfileOptions.includes(proResProfile)) {
+        throw new TypeError(`The ProRes profile "${proResProfile}" is not valid. Valid options are ${proResProfileOptions
             .map((p) => `"${p}"`)
             .join(', ')}`);
     }

package/dist/provide-screenshot.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
+import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
 import type { ImageFormat } from './image-format';
-export declare const provideScreenshot: ({ page, imageFormat, options, quality, }: {
+export declare const provideScreenshot: ({ page, imageFormat, options, quality, height, width, clipRegion, }: {
     page: Page;
     imageFormat: ImageFormat;
     quality: number | undefined;
@@ -9,4 +10,7 @@ export declare const provideScreenshot: ({ page, imageFormat, options, quality,
         frame: number;
         output: string | null;
     };
+    height: number;
+    width: number;
+    clipRegion: ClipRegion | null;
 }) => Promise<Buffer>;

package/dist/provide-screenshot.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.provideScreenshot = void 0;
 const screenshot_dom_element_1 = require("./screenshot-dom-element");
-const provideScreenshot = ({ page, imageFormat, options, quality, }) => {
+const provideScreenshot = ({ page, imageFormat, options, quality, height, width, clipRegion, }) => {
     return (0, screenshot_dom_element_1.screenshotDOMElement)({
         page,
         opts: {
@@ -10,6 +10,9 @@ const provideScreenshot = ({ page, imageFormat, options, quality, }) => {
         },
         imageFormat,
         quality,
+        height,
+        width,
+        clipRegion,
     });
 };
 exports.provideScreenshot = provideScreenshot;