@remotion/renderer 4.0.0-defer.6 → 4.0.0-esm.17

package/dist/mime-types.d.ts

@@ -0,0 +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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+    }
+    // get the extension ("ext" or ".ext" or full path)
+    const ext = (0, path_1.extname)('.' + path)
+        .toLowerCase()
+        .substr(1);
+    if (!ext) {
+        return false;
+    }
+    return types[ext] || false;
+}
+exports.mimeLookup = mimeLookup;
+/**
+ * Populate the extensions and types maps.
+ * @private
+ */
+function populateMaps(exts, _types) {
+    // source preference (least -> most)
+    const preference = ['nginx', 'apache', undefined, 'iana'];
+    Object.keys(mime_db_1.mimeDb).forEach((type) => {
+        const mime = mime_db_1.mimeDb[type];
+        const _exts = mime.extensions;
+        if (!_exts || !_exts.length) {
+            return;
+        }
+        // mime -> extensions
+        exts[type] = _exts;
+        // extension -> mime
+        for (let i = 0; i < _exts.length; i++) {
+            const _ext = _exts[i];
+            if (_types[_ext]) {
+                const from = preference.indexOf(mime_db_1.mimeDb[_types[_ext]].source);
+                const to = preference.indexOf(mime.source);
+                if (_types[_ext] !== 'application/octet-stream' &&
+                    (from > to ||
+                        (from === to && _types[_ext].substr(0, 12) === 'application/'))) {
+                    // skip the remapping
+                    continue;
+                }
+            }
+            // set the extension -> mime
+            types[_ext] = type;
+        }
+    });
+}
+function mimeContentType(str) {
+    if (!str || typeof str !== 'string') {
+        return false;
+    }
+    let mime = str.indexOf('/') === -1 ? mimeLookup(str) : str;
+    if (!mime) {
+        return false;
+    }
+    if (mime.indexOf('charset') === -1) {
+        const _charset = charset(mime);
+        if (_charset)
+            mime += '; charset=' + _charset.toLowerCase();
+    }
+    return mime;
+}
+exports.mimeContentType = mimeContentType;
+const EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+const TEXT_TYPE_REGEXP = /^text\//i;
+function charset(type) {
+    if (!type || typeof type !== 'string') {
+        return false;
+    }
+    const match = EXTRACT_TYPE_REGEXP.exec(type);
+    const mime = match && mime_db_1.mimeDb[match[1].toLowerCase()];
+    if (mime === null || mime === void 0 ? void 0 : mime.charset) {
+        return mime.charset;
+    }
+    // default text/* to utf-8
+    if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+        return 'UTF-8';
+    }
+    return false;
+}

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

@@ -1,14 +1,18 @@
-import { RequestListener } from 'http';
-import { FfmpegExecutable } from 'remotion';
-import { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { RequestListener } from 'http';
+import type { OffthreadVideoImageFormat } from 'remotion';
+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 extractUrlAndSourceFromUrl: (url: string) => {
     src: string;
     time: number;
+    imageFormat: OffthreadVideoImageFormat;
 };
-export declare const startOffthreadVideoServer: ({ ffmpegExecutable, ffprobeExecutable, downloadDir, onDownload, onError, }: {
+export declare const startOffthreadVideoServer: ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, downloadMap, remotionRoot, }: {
     ffmpegExecutable: FfmpegExecutable;
     ffprobeExecutable: FfmpegExecutable;
-    downloadDir: string;
     onDownload: RenderMediaOnDownload;
     onError: (err: Error) => void;
+    downloadMap: DownloadMap;
+    remotionRoot: string;
 }) => RequestListener;

package/dist/offthread-video-server.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startOffthreadVideoServer = exports.extractUrlAndSourceFromUrl = void 0;
+const remotion_1 = require("remotion");
 const url_1 = require("url");
 const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
 const extract_frame_from_video_1 = require("./extract-frame-from-video");
@@ -19,10 +20,19 @@ const extractUrlAndSourceFromUrl = (url) => {
     if (!time) {
         throw new Error('Did not get `time` parameter');
     }
-    return { src, time: parseFloat(time) };
+    const imageFormat = params.get('imageFormat');
+    if (!imageFormat) {
+        throw new TypeError('Did not get `imageFormat` parameter');
+    }
+    remotion_1.Internals.validateOffthreadVideoImageFormat(imageFormat);
+    return {
+        src,
+        time: parseFloat(time),
+        imageFormat: imageFormat,
+    };
 };
 exports.extractUrlAndSourceFromUrl = extractUrlAndSourceFromUrl;
-const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, downloadDir, onDownload, onError, }) => {
+const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, downloadMap, remotionRoot, }) => {
     return (req, res) => {
         if (!req.url) {
             throw new Error('Request came in without URL');
@@ -32,20 +42,30 @@ const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, downlo
             res.end();
             return;
         }
+        const { src, time, imageFormat } = (0, exports.extractUrlAndSourceFromUrl)(req.url);
         res.setHeader('access-control-allow-origin', '*');
-        res.setHeader('content-type', 'image/jpg');
-        const { src, time } = (0, exports.extractUrlAndSourceFromUrl)(req.url);
-        const to = (0, download_and_map_assets_to_file_1.getSanitizedFilenameForAssetUrl)({ downloadDir, src });
-        (0, download_and_map_assets_to_file_1.startDownloadForSrc)({ src, downloadDir, onDownload }).catch((err) => {
-            onError(new Error(`Error while downloading asset: ${err.stack}`));
-        });
-        (0, download_and_map_assets_to_file_1.waitForAssetToBeDownloaded)(src, to)
-            .then(() => {
+        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)({
                 time,
                 src: to,
                 ffmpegExecutable,
                 ffprobeExecutable,
+                imageFormat,
+                downloadMap,
+                remotionRoot,
             });
         })
             .then((readable) => {

package/dist/open-browser.d.ts

@@ -1,5 +1,6 @@
-import puppeteer from 'puppeteer-core';
-import { Browser } from 'remotion';
+import type { Browser } from './browser';
+import type { Browser as PuppeteerBrowser } from './browser/Browser';
+import type { Viewport } from './browser/PuppeteerViewport';
 declare const validRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
 declare type OpenGlRenderer = typeof validRenderers[number];
 export declare type ChromiumOptions = {
@@ -14,5 +15,6 @@ export declare const openBrowser: (browser: Browser, options?: {
     browserExecutable?: string | null;
     chromiumOptions?: ChromiumOptions;
     forceDeviceScaleFactor?: number;
-}) => Promise<puppeteer.Browser>;
+    viewport?: Viewport;
+}) => Promise<PuppeteerBrowser>;
 export {};

package/dist/open-browser.js

@@ -1,19 +1,14 @@
 "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 puppeteer_core_1 = __importDefault(require("puppeteer-core"));
-const remotion_1 = require("remotion");
+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");
+const validate_opengl_renderer_1 = require("./validate-opengl-renderer");
 const validRenderers = ['swangle', 'angle', 'egl', 'swiftshader'];
 const getOpenGlRenderer = (option) => {
-    const renderer = option !== null && option !== void 0 ? option : remotion_1.Internals.DEFAULT_OPENGL_RENDERER;
-    remotion_1.Internals.validateOpenGlRenderer(renderer);
+    const renderer = option !== null && option !== void 0 ? option : validate_opengl_renderer_1.DEFAULT_OPENGL_RENDERER;
+    (0, validate_opengl_renderer_1.validateOpenGlRenderer)(renderer);
     if (renderer === 'swangle') {
         return [`--use-gl=angle`, `--use-angle=swiftshader`];
     }
@@ -26,25 +21,24 @@ const browserInstances = [];
 const killAllBrowsers = async () => {
     for (const browser of browserInstances) {
         try {
-            await browser.close();
+            await browser.close(true);
         }
         catch (err) { }
     }
 };
 exports.killAllBrowsers = killAllBrowsers;
 const openBrowser = async (browser, options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    if (browser === 'firefox' && !remotion_1.Internals.FEATURE_FLAG_FIREFOX_SUPPORT) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    if (browser === 'firefox') {
         throw new TypeError('Firefox supported is not yet turned on. Stay tuned for the future.');
     }
     await (0, get_local_browser_executable_1.ensureLocalBrowser)(browser, (_a = options === null || options === void 0 ? void 0 : options.browserExecutable) !== null && _a !== void 0 ? _a : null);
     const executablePath = (0, get_local_browser_executable_1.getLocalBrowserExecutable)(browser, (_b = options === null || options === void 0 ? void 0 : options.browserExecutable) !== null && _b !== void 0 ? _b : null);
     const customGlRenderer = getOpenGlRenderer((_d = (_c = options === null || options === void 0 ? void 0 : options.chromiumOptions) === null || _c === void 0 ? void 0 : _c.gl) !== null && _d !== void 0 ? _d : null);
-    const browserInstance = await puppeteer_core_1.default.launch({
+    const browserInstance = await node_1.puppeteer.launch({
         executablePath,
         product: browser,
         dumpio: (_e = options === null || options === void 0 ? void 0 : options.shouldDumpIo) !== null && _e !== void 0 ? _e : false,
-        ignoreDefaultArgs: true,
         args: [
             'about:blank',
             '--allow-pre-commit-input',
@@ -57,14 +51,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=*',
-            // TODO: remove AvoidUnnecessaryBeforeUnloadCheckSync below
-            // once crbug.com/1324138 is fixed and released.
-            '--disable-features=Translate,BackForwardCache,AvoidUnnecessaryBeforeUnloadCheckSync',
             '--disable-hang-monitor',
+            '--disable-extensions',
             '--disable-ipc-flooding-protection',
             '--disable-popup-blocking',
             '--disable-prompt-on-repost',
@@ -73,12 +64,10 @@ const openBrowser = async (browser, options) => {
             '--force-color-profile=srgb',
             '--metrics-recording-only',
             '--no-first-run',
-            '--video-threads=16',
+            '--video-threads=' + (0, get_video_threads_flag_1.getIdealVideoThreadsFlag)(),
             '--enable-automation',
             '--password-store=basic',
             '--use-mock-keychain',
-            // TODO(sadym): remove '--enable-blink-features=IdleDetection'
-            // once IdleDetection is turned on by default.
             '--enable-blink-features=IdleDetection',
             '--export-tagged-pdf',
             '--intensive-wake-up-throttling-policy=0',
@@ -91,7 +80,7 @@ const openBrowser = async (browser, options) => {
             '--allow-running-insecure-content',
             '--disable-component-update',
             '--disable-domain-reliability',
-            '--disable-features=AudioServiceOutOfProcess,IsolateOrigins,site-per-process',
+            '--disable-features=AudioServiceOutOfProcess,IsolateOrigins,site-per-process,Translate,BackForwardCache,AvoidUnnecessaryBeforeUnloadCheckSync,IntensiveWakeUpThrottling',
             '--disable-print-preview',
             '--disable-site-isolation-trials',
             '--disk-cache-size=268435456',
@@ -107,13 +96,14 @@ 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']
                 : []),
         ].filter(Boolean),
+        defaultViewport: (_k = options === null || options === void 0 ? void 0 : options.viewport) !== null && _k !== void 0 ? _k : {
+            height: 720,
+            width: 1280,
+            deviceScaleFactor: 1,
+        },
     });
     const pages = await browserInstance.pages();
     await pages[0].close();

package/dist/overwrite.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_OVERWRITE = true;

package/dist/overwrite.js

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

package/dist/perf.d.ts

@@ -0,0 +1,5 @@
+declare type PerfId = 'activate-target' | 'capture' | 'save' | 'extract-frame' | 'piping';
+export declare const startPerfMeasure: (marker: PerfId) => number;
+export declare const stopPerfMeasure: (id: number) => void;
+export declare const logPerf: () => void;
+export {};

package/dist/perf.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logPerf = exports.stopPerfMeasure = exports.startPerfMeasure = void 0;
+const perf = {
+    'activate-target': [],
+    capture: [],
+    save: [],
+    'extract-frame': [],
+    piping: [],
+};
+const map = {};
+const startPerfMeasure = (marker) => {
+    const id = Math.random();
+    map[id] = {
+        id,
+        marker,
+        start: Date.now(),
+    };
+    return id;
+};
+exports.startPerfMeasure = startPerfMeasure;
+const stopPerfMeasure = (id) => {
+    const now = Date.now();
+    const diff = now - map[id].start;
+    perf[map[id].marker].push(diff);
+    delete map[id];
+};
+exports.stopPerfMeasure = stopPerfMeasure;
+const logPerf = () => {
+    console.log('Render performance:');
+    Object.keys(perf).forEach((p) => {
+        console.log(`  ${p} => ${perf[p].reduce((a, b) => a + b, 0) / perf[p].length} (n = ${perf[p].length})`);
+    });
+};
+exports.logPerf = logPerf;

package/dist/pixel-format.d.ts

@@ -0,0 +1,5 @@
+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 | undefined, codec: Codec) => undefined;

package/dist/pixel-format.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSelectedPixelFormatAndCodecCombination = exports.DEFAULT_PIXEL_FORMAT = exports.validPixelFormats = void 0;
+exports.validPixelFormats = [
+    'yuv420p',
+    'yuva420p',
+    'yuv422p',
+    'yuv444p',
+    'yuv420p10le',
+    'yuv422p10le',
+    'yuv444p10le',
+    'yuva444p10le',
+];
+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.`);
+    }
+    if (pixelFormat !== 'yuva420p') {
+        return;
+    }
+    if (codec !== 'vp8' && codec !== 'vp9') {
+        throw new TypeError("Pixel format was set to 'yuva420p' but codec is not 'vp8' or 'vp9'. To render videos with alpha channel, you must choose a codec that supports it.");
+    }
+};
+exports.validateSelectedPixelFormatAndCodecCombination = validateSelectedPixelFormatAndCodecCombination;

package/dist/prepare-server.d.ts

@@ -1,15 +1,17 @@
-import { FfmpegExecutable } from 'remotion';
-import { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
-export declare const prepareServer: ({ downloadDir, ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, }: {
+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, remotionRoot, }: {
     webpackConfigOrServeUrl: string;
-    downloadDir: string;
     onDownload: RenderMediaOnDownload;
     onError: (err: Error) => void;
     ffmpegExecutable: FfmpegExecutable;
     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

@@ -1,34 +1,53 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareServer = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
 const is_serve_url_1 = require("./is-serve-url");
 const serve_static_1 = require("./serve-static");
-const prepareServer = async ({ downloadDir, ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, }) => {
+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, remotionRoot, }) => {
     if ((0, is_serve_url_1.isServeUrl)(webpackConfigOrServeUrl)) {
         const { port: offthreadPort, close: closeProxy } = await (0, serve_static_1.serveStatic)(null, {
-            downloadDir,
             onDownload,
             onError,
             ffmpegExecutable,
             ffprobeExecutable,
             port,
+            downloadMap,
+            remotionRoot,
         });
         return Promise.resolve({
             serveUrl: webpackConfigOrServeUrl,
-            closeServer: () => closeProxy(),
+            closeServer: () => {
+                return closeProxy();
+            },
             offthreadPort,
         });
     }
+    // Check if the path has a `index.html` file
+    const indexFile = path_1.default.join(webpackConfigOrServeUrl, 'index.html');
+    const exists = (0, fs_1.existsSync)(indexFile);
+    if (!exists) {
+        throw new Error(`Tried to serve the Webpack bundle on a HTTP server, but the file ${indexFile} does not exist. Is this a valid path to a Webpack bundle?`);
+    }
     const { port: serverPort, close } = await (0, serve_static_1.serveStatic)(webpackConfigOrServeUrl, {
-        downloadDir,
         onDownload,
         onError,
         ffmpegExecutable,
         ffprobeExecutable,
         port,
+        downloadMap,
+        remotionRoot,
     });
     return Promise.resolve({
-        closeServer: () => {
+        closeServer: async (force) => {
+            if (!force) {
+                await (0, wait_for_symbolication_error_to_be_done_1.waitForSymbolicationToBeDone)();
+            }
             return close();
         },
         serveUrl: `http://localhost:${serverPort}`,

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

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

package/dist/preprocess-audio-track.js

@@ -8,10 +8,11 @@ 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, }) => {
-    const { channels, duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)((0, resolve_asset_src_1.resolveAssetSrc)(asset.src), ffprobeExecutable);
+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,
@@ -22,7 +23,7 @@ const preprocessAudioTrackUnlimited = async ({ ffmpegExecutable, ffprobeExecutab
     if (filter === null) {
         return null;
     }
-    const { cleanup, file } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(filter);
+    const { cleanup, file } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(filter, downloadMap);
     const args = [
         ['-i', (0, resolve_asset_src_1.resolveAssetSrc)(asset.src)],
         ['-ac', '2'],
@@ -30,7 +31,7 @@ const preprocessAudioTrackUnlimited = async ({ ffmpegExecutable, ffprobeExecutab
         ['-c:a', 'pcm_s16le'],
         ['-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;
 };

package/dist/prespawn-ffmpeg.d.ts

@@ -1,6 +1,11 @@
 import execa from 'execa';
-import { Codec, FfmpegExecutable, ImageFormat, PixelFormat, ProResProfile } from 'remotion';
-import { CancelSignal } from './make-cancel-signal';
+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';
+import type { ProResProfile } from './prores-profile';
 declare type PreSticherOptions = {
     fps: number;
     width: number;
@@ -14,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;
 }>;