@remotion/renderer 4.0.0-alpha.217 → 4.0.0-alpha10

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

@@ -1,11 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 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 call_ffmpeg_1 = require("./call-ffmpeg");
 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");
@@ -19,12 +23,12 @@ const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-
 const lastFrameLimit = (0, p_limit_1.pLimit)(1);
 const mainLimit = (0, p_limit_1.pLimit)(5);
 const getLastFrameOfVideoFastUnlimited = async (options) => {
-    const { offset, src, downloadMap } = 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);
+    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.`);
     }
@@ -32,33 +36,40 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
         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 [stdErr, stdoutBuffer] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
         actualOffset,
+        ffmpegExecutable,
         imageFormat: options.imageFormat,
         needsResize: options.needsResize,
+        remotionRoot: options.remotionRoot,
         specialVCodecForTransparency: options.specialVCodecForTransparency,
         src,
     });
     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 + (fps === null ? 10 : 1000 / fps),
             src,
+            ffprobeExecutable,
             imageFormat: options.imageFormat,
             specialVCodecForTransparency: options.specialVCodecForTransparency,
             needsResize: options.needsResize,
             downloadMap: options.downloadMap,
+            remotionRoot: options.remotionRoot,
         });
         return unlimited;
     }
@@ -70,17 +81,21 @@ const getLastFrameOfVideo = async (options) => {
     return result;
 };
 exports.getLastFrameOfVideo = getLastFrameOfVideo;
-const extractFrameFromVideoFn = async ({ time, imageFormat, downloadMap, remotionRoot, ...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,
         src: options.src,
+        remotionRoot,
+        ffmpegExecutable,
+        ffprobeExecutable,
     });
-    const { specialVcodecForTransparency: specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src);
+    const { specialVcodecForTransparency: 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);
+        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,
@@ -88,21 +103,25 @@ const extractFrameFromVideoFn = async ({ time, imageFormat, downloadMap, remotio
             needsResize,
             offset: 0,
             fps,
+            remotionRoot,
         });
     }
     if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(downloadMap, src, time)) {
         const lastFrame = await (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
             offset: 0,
             src,
             imageFormat,
             specialVCodecForTransparency: specialVcodec,
             needsResize,
             downloadMap,
+            remotionRoot,
         });
         return lastFrame;
     }
     const ffmpegTimestamp = (0, frame_to_ffmpeg_timestamp_1.frameToFfmpegTimestamp)(time);
-    const { stdout, stderr } = (0, call_ffmpeg_1.callFf)('ffmpeg', [
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-ss',
         ffmpegTimestamp,
         ...(0, determine_vcodec_ffmpeg_flags_1.determineVcodecFfmpegFlags)(specialVcodec),
@@ -144,12 +163,15 @@ const extractFrameFromVideoFn = async ({ time, imageFormat, downloadMap, remotio
     if (stderrStr.includes('Output file is empty')) {
         (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(downloadMap, src, time);
         const last = await (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
             offset: 0,
             src,
             imageFormat,
             specialVCodecForTransparency: specialVcodec,
             needsResize,
             downloadMap,
+            remotionRoot,
         });
         return last;
     }

package/dist/ffmpeg-filter-file.js

@@ -29,25 +29,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeFfmpegFilterFileStr = exports.makeFfmpegFilterFile = void 0;
-const fs_1 = __importStar(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importStar(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 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');
+    const filterFile = node_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 });
+    if (!(0, node_fs_1.existsSync)(downloadMap.complexFilter)) {
+        node_fs_1.default.mkdirSync(downloadMap.complexFilter, { recursive: true });
     }
-    await fs_1.default.promises.writeFile(filterFile, complexFilter);
+    await node_fs_1.default.promises.writeFile(filterFile, complexFilter);
     return {
         file: filterFile,
         cleanup: () => {
-            fs_1.default.unlinkSync(filterFile);
+            node_fs_1.default.unlinkSync(filterFile);
         },
     };
 };

package/dist/find-closest-package-json.js

@@ -4,19 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findRemotionRoot = exports.findClosestPackageJson = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const recursionLimit = 5;
 const findClosestPackageJson = () => {
     let currentDir = process.cwd();
     let possiblePackageJson = '';
     for (let i = 0; i < recursionLimit; i++) {
-        possiblePackageJson = path_1.default.join(currentDir, 'package.json');
-        const exists = fs_1.default.existsSync(possiblePackageJson);
+        possiblePackageJson = node_path_1.default.join(currentDir, 'package.json');
+        const exists = node_fs_1.default.existsSync(possiblePackageJson);
         if (exists) {
             return possiblePackageJson;
         }
-        currentDir = path_1.default.dirname(currentDir);
+        currentDir = node_path_1.default.dirname(currentDir);
     }
     return null;
 };
@@ -26,6 +26,6 @@ const findRemotionRoot = () => {
     if (closestPackageJson === null) {
         return process.cwd();
     }
-    return path_1.default.dirname(closestPackageJson);
+    return node_path_1.default.dirname(closestPackageJson);
 };
 exports.findRemotionRoot = findRemotionRoot;

package/dist/get-browser-instance.d.ts

@@ -1,9 +1,9 @@
 import type { BrowserExecutable } from './browser-executable';
-import type { Browser } from './browser/Browser';
+import type { HeadlessBrowser } from './browser/Browser';
 import type { Page } from './browser/BrowserPage';
 import type { ChromiumOptions } from './open-browser';
 export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, }: {
-    passedInInstance: Browser | undefined;
+    passedInInstance: HeadlessBrowser | undefined;
     browserExecutable: BrowserExecutable | null;
     chromiumOptions: ChromiumOptions;
 }) => Promise<{

package/dist/get-can-extract-frames-fast.d.ts

@@ -1,10 +1,13 @@
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare const ACCEPTABLE_OFFSET_THRESHOLD = 50;
 /**
  * @description Probes whether frames of a video can be efficiently extracted when using <OffthreadVideo>.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-can-extract-frames-fast)
  */
-export declare const getCanExtractFramesFast: ({ src, }: {
+export declare const getCanExtractFramesFast: ({ src, ffmpegExecutable, ffprobeExecutable, }: {
     src: string;
+    ffmpegExecutable?: FfmpegExecutable | undefined;
+    ffprobeExecutable?: FfmpegExecutable | undefined;
 }) => Promise<{
     canExtractFramesFast: boolean;
     shouldReencode: boolean;

package/dist/get-can-extract-frames-fast.js

@@ -7,6 +7,7 @@ exports.getCanExtractFramesFast = exports.ACCEPTABLE_OFFSET_THRESHOLD = void 0;
 const fs_1 = __importDefault(require("fs"));
 const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
 const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
+const find_closest_package_json_1 = require("./find-closest-package-json");
 const get_video_info_1 = require("./get-video-info");
 const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-video-fast");
 exports.ACCEPTABLE_OFFSET_THRESHOLD = 50;
@@ -14,12 +15,18 @@ exports.ACCEPTABLE_OFFSET_THRESHOLD = 50;
  * @description Probes whether frames of a video can be efficiently extracted when using <OffthreadVideo>.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-can-extract-frames-fast)
  */
-const getCanExtractFramesFast = async ({ src, }) => {
+const getCanExtractFramesFast = async ({ src, ffmpegExecutable, ffprobeExecutable, }) => {
+    const remotionRoot = (0, find_closest_package_json_1.findRemotionRoot)();
     const out = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
         src,
     });
     const { specialVcodecForTransparency: specialVcodec } = await (0, get_video_info_1.getVideoInfoUncached)({
         src: out,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
     });
     if (specialVcodec === 'vp8') {
         fs_1.default.unlinkSync(out);
@@ -29,6 +36,8 @@ const getCanExtractFramesFast = async ({ src, }) => {
         };
     }
     const { duration } = await (0, get_video_stream_duration_1.getVideoStreamDurationwithoutCache)({
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
         src: out,
     });
     if (duration === null) {
@@ -38,9 +47,11 @@ const getCanExtractFramesFast = async ({ src, }) => {
     const actualOffset = `${duration * 1000 - exports.ACCEPTABLE_OFFSET_THRESHOLD}ms`;
     const [stdErr] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
         actualOffset,
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
         imageFormat: 'jpeg',
         // Intentionally leaving needsResize as null, because we don't need to resize
         needsResize: null,
+        remotionRoot,
         specialVCodecForTransparency: specialVcodec,
         src: out,
     });

package/dist/get-compositions.d.ts

@@ -2,12 +2,12 @@ import type { AnyCompMetadata } from 'remotion';
 import type { DownloadMap } from './assets/download-map';
 import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
-import type { Browser } from './browser/Browser';
+import type { HeadlessBrowser } from './browser/Browser';
 import type { ChromiumOptions } from './open-browser';
 declare type GetCompositionsConfig = {
-    inputProps?: object | null;
+    inputProps?: Record<string, unknown> | null;
     envVariables?: Record<string, string>;
-    puppeteerInstance?: Browser;
+    puppeteerInstance?: HeadlessBrowser;
     onBrowserLog?: (log: BrowserLog) => void;
     browserExecutable?: BrowserExecutable;
     timeoutInMilliseconds?: number;
@@ -17,6 +17,11 @@ declare type GetCompositionsConfig = {
      * @deprecated Only for Remotion internal usage
      */
     downloadMap?: DownloadMap;
+    /**
+     * @deprecated Only for Remotion internal usage
+     */
+    indent?: boolean;
+    verbose?: boolean;
 };
 /**
  * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.

package/dist/get-compositions.js

@@ -11,6 +11,7 @@ const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
+    var _a;
     if (config === null || config === void 0 ? void 0 : config.onBrowserLog) {
         page.on('console', (log) => {
             var _a;
@@ -23,7 +24,7 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     }
     (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(config === null || config === void 0 ? void 0 : config.timeoutInMilliseconds);
     await (0, set_props_and_env_1.setPropsAndEnv)({
-        inputProps: config === null || config === void 0 ? void 0 : config.inputProps,
+        inputProps: (_a = config === null || config === void 0 ? void 0 : config.inputProps) !== null && _a !== void 0 ? _a : {},
         envVariables: config === null || config === void 0 ? void 0 : config.envVariables,
         page,
         serveUrl,
@@ -68,7 +69,7 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
         chromiumOptions: (_c = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _c !== void 0 ? _c : {},
     });
     return new Promise((resolve, reject) => {
-        var _a;
+        var _a, _b, _c;
         const onError = (err) => reject(err);
         const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
             page,
@@ -83,6 +84,9 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
             port: (_a = config === null || config === void 0 ? void 0 : config.port) !== null && _a !== void 0 ? _a : null,
             downloadMap,
             remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
+            concurrency: 1,
+            verbose: (_b = config === null || config === void 0 ? void 0 : config.verbose) !== null && _b !== void 0 ? _b : false,
+            indent: (_c = config === null || config === void 0 ? void 0 : config.indent) !== null && _c !== void 0 ? _c : false,
         })
             .then(({ serveUrl, closeServer, offthreadPort }) => {
             close = closeServer;

package/dist/get-concurrency.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getActualConcurrency = void 0;
-const os_1 = __importDefault(require("os"));
+const node_os_1 = __importDefault(require("node:os"));
 const getActualConcurrency = (userPreference) => {
     if (userPreference === null) {
-        return Math.round(Math.min(8, Math.max(1, os_1.default.cpus().length / 2)));
+        return Math.round(Math.min(8, Math.max(1, node_os_1.default.cpus().length / 2)));
     }
-    const max = os_1.default.cpus().length;
+    const max = node_os_1.default.cpus().length;
     const min = 1;
     let rounded;
     if (typeof userPreference === 'string') {

package/dist/get-extension-of-filename.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExtensionOfFilename = void 0;
-const path_1 = __importDefault(require("path"));
+const node_path_1 = __importDefault(require("node:path"));
 const getExtensionOfFilename = (filename) => {
     if (filename === null) {
         return null;
     }
-    const filenameArr = path_1.default.normalize(filename).split('.');
+    const filenameArr = node_path_1.default.normalize(filename).split('.');
     const hasExtension = filenameArr.length >= 2;
     const filenameArrLength = filenameArr.length;
     const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;

package/dist/get-frame-of-video-slow.d.ts

@@ -1,12 +1,17 @@
-/// <reference types="node" />
 import type { OffthreadVideoImageFormat } from 'remotion';
 import type { SpecialVCodecForTransparency } from './assets/download-map';
-export declare const getFrameOfVideoSlow: ({ src, duration, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, }: {
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const getFrameOfVideoSlow: ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }: {
+    ffmpegExecutable: FfmpegExecutable;
     src: string;
     duration: number;
     imageFormat: OffthreadVideoImageFormat;
     specialVCodecForTransparency: SpecialVCodecForTransparency;
-    needsResize: [number, number] | null;
+    needsResize: [
+        number,
+        number
+    ] | null;
     offset: number;
     fps: number | null;
+    remotionRoot: string;
 }) => Promise<Buffer>;

package/dist/get-frame-of-video-slow.js

@@ -1,11 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFrameOfVideoSlow = void 0;
-const call_ffmpeg_1 = require("./call-ffmpeg");
+// 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 execa_1 = __importDefault(require("execa"));
 const determine_resize_params_1 = require("./determine-resize-params");
 const determine_vcodec_ffmpeg_flags_1 = require("./determine-vcodec-ffmpeg-flags");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const truthy_1 = require("./truthy");
-const getFrameOfVideoSlow = async ({ src, duration, 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 = [
@@ -23,7 +29,7 @@ const getFrameOfVideoSlow = async ({ src, duration, imageFormat, specialVCodecFo
         ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
         '-',
     ].filter(truthy_1.truthy);
-    const { stdout, stderr } = (0, call_ffmpeg_1.callFf)('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');
     }
@@ -49,6 +55,7 @@ const getFrameOfVideoSlow = async ({ src, duration, imageFormat, specialVCodecFo
             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 (0, exports.getFrameOfVideoSlow)({
+            ffmpegExecutable,
             duration,
             // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
             offset: offset + (fps === null ? 10 : 1000 / fps),
@@ -57,6 +64,7 @@ const getFrameOfVideoSlow = async ({ src, duration, imageFormat, specialVCodecFo
             specialVCodecForTransparency,
             needsResize,
             fps,
+            remotionRoot,
         });
     }
     return stdoutBuffer;

package/dist/get-local-browser-executable.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalBrowserExecutable = exports.ensureLocalBrowser = void 0;
-const fs_1 = __importDefault(require("fs"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const BrowserFetcher_1 = require("./browser/BrowserFetcher");
 const create_browser_fetcher_1 = require("./browser/create-browser-fetcher");
-const node_1 = require("./browser/node");
 const revisions_1 = require("./browser/revisions");
 const getSearchPathsForProduct = (product) => {
     var _a;
@@ -38,24 +38,15 @@ const getSearchPathsForProduct = (product) => {
 const mapBrowserToProduct = (browser) => browser;
 const getLocalBrowser = (product) => {
     for (const p of getSearchPathsForProduct(product)) {
-        if (fs_1.default.existsSync(p)) {
+        if (node_fs_1.default.existsSync(p)) {
             return p;
         }
     }
     return null;
 };
-const getBrowserRevision = (product) => {
-    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
-        product,
-        path: null,
-        platform: null,
-    });
-    const revisionInfo = browserFetcher.revisionInfo(revisions_1.PUPPETEER_REVISIONS.chromium);
-    return revisionInfo;
-};
 const getBrowserStatus = (product, browserExecutablePath) => {
     if (browserExecutablePath) {
-        if (!fs_1.default.existsSync(browserExecutablePath)) {
+        if (!node_fs_1.default.existsSync(browserExecutablePath)) {
             console.warn(`Browser executable was specified as '${browserExecutablePath}' but the path doesn't exist.`);
         }
         return { path: browserExecutablePath, type: 'user-defined-path' };
@@ -64,8 +55,8 @@ const getBrowserStatus = (product, browserExecutablePath) => {
     if (localBrowser !== null) {
         return { path: localBrowser, type: 'local-browser' };
     }
-    const revision = getBrowserRevision(product);
-    if (revision.local !== null && fs_1.default.existsSync(revision.executablePath)) {
+    const revision = (0, BrowserFetcher_1.getRevisionInfo)(revisions_1.PUPPETEER_REVISIONS.chromium, product);
+    if (revision.local && node_fs_1.default.existsSync(revision.executablePath)) {
         return { path: revision.executablePath, type: 'local-puppeteer-browser' };
     }
     return { type: 'no-browser' };

package/dist/get-video-info.d.ts

@@ -1,5 +1,8 @@
 import type { DownloadMap, Vp9Result } from './assets/download-map';
-export declare function getVideoInfoUncached({ src, }: {
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }: {
     src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
 }): Promise<Vp9Result>;
-export declare const getVideoInfo: (downloadMap: DownloadMap, src: string) => Promise<Vp9Result>;
+export declare const getVideoInfo: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<Vp9Result>;

package/dist/get-video-info.js

@@ -1,13 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVideoInfo = exports.getVideoInfoUncached = void 0;
+const execa_1 = __importDefault(require("execa"));
 const calculate_sar_dar_pixels_1 = require("./calculate-sar-dar-pixels");
-const call_ffmpeg_1 = require("./call-ffmpeg");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const p_limit_1 = require("./p-limit");
 const limit = (0, p_limit_1.pLimit)(1);
-async function getVideoInfoUncached({ src, }) {
+async function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }) {
     var _a;
-    const task = await (0, call_ffmpeg_1.callFf)('ffprobe', [src]);
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), [src]);
     const isVp9 = task.stderr.includes('Video: vp9');
     const isVp8 = task.stderr.includes('Video: vp8');
     const dimensions = (_a = task.stderr
@@ -37,17 +41,19 @@ async function getVideoInfoUncached({ src, }) {
     return result;
 }
 exports.getVideoInfoUncached = getVideoInfoUncached;
-async function getVideoInfoUnlimited(downloadMap, src) {
+async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
     if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
         return downloadMap.isVp9VideoCache[src];
     }
     const result = await getVideoInfoUncached({
+        ffprobeExecutable,
+        remotionRoot,
         src,
     });
     downloadMap.isVp9VideoCache[src] = result;
     return downloadMap.isVp9VideoCache[src];
 }
-const getVideoInfo = (downloadMap, src) => {
-    return limit(() => getVideoInfoUnlimited(downloadMap, src));
+const getVideoInfo = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
 };
 exports.getVideoInfo = getVideoInfo;

package/dist/get-video-threads-flag.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIdealVideoThreadsFlag = void 0;
-const os_1 = __importDefault(require("os"));
+const node_os_1 = __importDefault(require("node:os"));
 const MEMORY_USAGE_PER_THREAD = 400000000; // 400MB
 const RESERVED_MEMORY = 2000000000;
 const getIdealVideoThreadsFlag = () => {
-    const freeMemory = os_1.default.freemem();
-    const cpus = os_1.default.cpus().length;
+    const freeMemory = node_os_1.default.freemem();
+    const cpus = node_os_1.default.cpus().length;
     const maxRecommendedBasedOnCpus = (cpus * 2) / 3;
     const maxRecommendedBasedOnMemory = (freeMemory - RESERVED_MEMORY) / MEMORY_USAGE_PER_THREAD;
     const maxRecommended = Math.min(maxRecommendedBasedOnCpus, maxRecommendedBasedOnMemory);