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

package/dist/ensure-presentation-timestamp.js

@@ -4,12 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensurePresentationTimestamps = exports.ensurePresentationTimestampWithoutCache = void 0;
+const execa_1 = __importDefault(require("execa"));
 const path_1 = __importDefault(require("path"));
-const call_ffmpeg_1 = require("./call-ffmpeg");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const guess_extension_for_media_1 = require("./guess-extension-for-media");
 const truthy_1 = require("./truthy");
 let callbacks = [];
-const getTemporaryOutputName = async ({ src }) => {
+const getTemporaryOutputName = async ({ src, remotionRoot, ffprobeBinary, }) => {
     const parts = src.split(path_1.default.sep);
     // If there is no file extension for the video, then we need to temporarily add an extension
     const lastPart = parts[parts.length - 1];
@@ -17,6 +18,8 @@ const getTemporaryOutputName = async ({ src }) => {
         ? null
         : await (0, guess_extension_for_media_1.guessExtensionForVideo)({
             src,
+            remotionRoot,
+            ffprobeBinary,
         });
     return parts
         .map((p, i) => {
@@ -27,12 +30,14 @@ const getTemporaryOutputName = async ({ src }) => {
     })
         .join(path_1.default.sep);
 };
-const ensurePresentationTimestampWithoutCache = async ({ src, }) => {
+const ensurePresentationTimestampWithoutCache = async ({ src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }) => {
     // If there is no file extension for the video, then we need to tempoa
     const output = await getTemporaryOutputName({
         src,
+        remotionRoot,
+        ffprobeBinary: ffprobeExecutable,
     });
-    await (0, call_ffmpeg_1.callFf)('ffmpeg', [
+    await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-i',
         src,
         '-fflags',
@@ -47,7 +52,7 @@ const ensurePresentationTimestampWithoutCache = async ({ src, }) => {
     return output;
 };
 exports.ensurePresentationTimestampWithoutCache = ensurePresentationTimestampWithoutCache;
-const ensurePresentationTimestamps = async ({ downloadMap, src, }) => {
+const ensurePresentationTimestamps = async ({ downloadMap, src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }) => {
     const elem = downloadMap.ensureFileHasPresentationTimestamp[src];
     if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'encoding') {
         return new Promise((resolve) => {
@@ -62,6 +67,9 @@ const ensurePresentationTimestamps = async ({ downloadMap, src, }) => {
     }
     downloadMap.ensureFileHasPresentationTimestamp[src] = { type: 'encoding' };
     const output = await (0, exports.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable,
+        ffprobeExecutable,
+        remotionRoot,
         src,
     });
     callbacks = callbacks.filter((c) => {

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

@@ -1,11 +1,14 @@
 /// <reference types="node" />
 import type { OffthreadVideoImageFormat } from 'remotion';
 import type { DownloadMap } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 import type { LastFrameOptions } from './last-frame-from-video-cache';
 export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;
 declare type Options = {
     time: number;
     src: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
     imageFormat: OffthreadVideoImageFormat;
     downloadMap: DownloadMap;
     remotionRoot: string;

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/file-extensions.d.ts

@@ -1,5 +1,16 @@
-import type { supportedAudioCodecs } from './audio-codec';
 import type { Codec } from './codec';
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16"];
+    readonly 'h264-mkv': readonly ["pcm-16"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly gif: readonly [];
+    readonly h265: readonly ["aac", "pcm-16"];
+    readonly mp3: readonly ["mp3", "pcm-16"];
+    readonly prores: readonly ["pcm-16", "aac"];
+    readonly vp8: readonly ["opus", "pcm-16"];
+    readonly vp9: readonly ["opus", "pcm-16"];
+    readonly wav: readonly ["pcm-16"];
+};
 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]: {

package/dist/file-extensions.js

@@ -1,6 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultFileExtensionMap = void 0;
+exports.defaultFileExtensionMap = exports.supportedAudioCodecs = void 0;
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16'],
+    'h264-mkv': ['pcm-16'],
+    aac: ['aac', 'pcm-16'],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['pcm-16', 'aac'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
 exports.defaultFileExtensionMap = {
     'h264-mkv': {
         default: 'mkv',

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

@@ -1,8 +1,9 @@
-import type { AnyCompMetadata } from 'remotion';
+import type { TCompMetadata } 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 { FfmpegExecutable } from './ffmpeg-executable';
 import type { ChromiumOptions } from './open-browser';
 declare type GetCompositionsConfig = {
     inputProps?: object | null;
@@ -12,6 +13,8 @@ declare type GetCompositionsConfig = {
     browserExecutable?: BrowserExecutable;
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
+    ffmpegExecutable?: FfmpegExecutable;
+    ffprobeExecutable?: FfmpegExecutable;
     port?: number | null;
     /**
      * @deprecated Only for Remotion internal usage
@@ -22,5 +25,5 @@ declare type GetCompositionsConfig = {
  * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
  */
-export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<AnyCompMetadata[]>;
+export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<TCompMetadata[]>;
 export {};

package/dist/get-compositions.js

@@ -9,6 +9,7 @@ const prepare_server_1 = require("./prepare-server");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
 const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
+const validate_ffmpeg_1 = require("./validate-ffmpeg");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     if (config === null || config === void 0 ? void 0 : config.onBrowserLog) {
@@ -60,15 +61,17 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
  */
 const getCompositions = async (serveUrlOrWebpackUrl, config) => {
-    var _a, _b, _c;
-    const downloadMap = (_a = config === null || config === void 0 ? void 0 : config.downloadMap) !== null && _a !== void 0 ? _a : (0, download_map_1.makeDownloadMap)();
+    var _a, _b, _c, _d, _e;
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_a = config === null || config === void 0 ? void 0 : config.ffmpegExecutable) !== null && _a !== void 0 ? _a : null, (0, find_closest_package_json_1.findRemotionRoot)(), 'ffmpeg');
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_b = config === null || config === void 0 ? void 0 : config.ffprobeExecutable) !== null && _b !== void 0 ? _b : null, (0, find_closest_package_json_1.findRemotionRoot)(), 'ffprobe');
+    const downloadMap = (_c = config === null || config === void 0 ? void 0 : config.downloadMap) !== null && _c !== void 0 ? _c : (0, download_map_1.makeDownloadMap)();
     const { page, cleanup } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
         passedInInstance: config === null || config === void 0 ? void 0 : config.puppeteerInstance,
-        browserExecutable: (_b = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _b !== void 0 ? _b : null,
-        chromiumOptions: (_c = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _c !== void 0 ? _c : {},
+        browserExecutable: (_d = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _d !== void 0 ? _d : null,
+        chromiumOptions: (_e = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _e !== void 0 ? _e : {},
     });
     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,
@@ -80,7 +83,9 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
             webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
             onDownload: () => undefined,
             onError,
-            port: (_a = config === null || config === void 0 ? void 0 : config.port) !== null && _a !== void 0 ? _a : null,
+            ffmpegExecutable: (_a = config === null || config === void 0 ? void 0 : config.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
+            ffprobeExecutable: (_b = config === null || config === void 0 ? void 0 : config.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
+            port: (_c = config === null || config === void 0 ? void 0 : config.port) !== null && _c !== void 0 ? _c : null,
             downloadMap,
             remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
         })

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

@@ -1,7 +1,9 @@
 /// <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;
@@ -9,4 +11,5 @@ export declare const getFrameOfVideoSlow: ({ src, duration, imageFormat, special
     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-frame-padded-index.d.ts

@@ -1,9 +1,8 @@
-import type { VideoImageFormat } from './image-format';
 export declare type CountType = 'from-zero' | 'actual-frames';
 export declare const getFrameOutputFileName: ({ index, frame, imageFormat, countType, lastFrame, totalFrames, }: {
     index: number;
     frame: number;
-    imageFormat: VideoImageFormat;
+    imageFormat: 'png' | 'jpeg' | 'none';
     countType: CountType;
     lastFrame: number;
     totalFrames: number;

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

@@ -5,8 +5,8 @@ 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 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;
@@ -44,15 +44,6 @@ const getLocalBrowser = (product) => {
     }
     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)) {
@@ -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 && 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/guess-extension-for-media.d.ts

@@ -1,3 +1,5 @@
-export declare const guessExtensionForVideo: ({ src }: {
+export declare const guessExtensionForVideo: ({ src, remotionRoot, ffprobeBinary, }: {
     src: string;
+    remotionRoot: string;
+    ffprobeBinary: string | null;
 }) => Promise<"mp3" | "wav" | "mp4" | "webm">;

package/dist/guess-extension-for-media.js

@@ -1,10 +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.guessExtensionForVideo = void 0;
-const call_ffmpeg_1 = require("./call-ffmpeg");
-const guessExtensionForVideo = async ({ src }) => {
-    const { stderr } = await (0, call_ffmpeg_1.callFf)('ffprobe', [src]);
-    if (stderr.includes('Audio: mp3,')) {
+const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const guessExtensionForVideo = async ({ src, remotionRoot, ffprobeBinary, }) => {
+    const { stderr } = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeBinary, remotionRoot, 'ffprobe'), [src]);
+    if (stderr.includes('mp3,')) {
         return 'mp3';
     }
     if (stderr.includes('Video: vp9')) {

package/dist/image-format.d.ts

@@ -1,13 +1,7 @@
 import type { PixelFormat } from './pixel-format';
-export declare const validVideoImageFormats: readonly ["png", "jpeg", "none"];
-export declare const validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
-export declare type VideoImageFormat = typeof validVideoImageFormats[number];
-export declare type StillImageFormat = typeof validStillImageFormats[number];
-/**
- * @deprecated Use VideoImageFormat or StillImageFormat instead
- */
-export declare type ImageFormat = 'This type is deprecated, use VideoImageFormat or StillImageFormat instead';
-export declare const DEFAULT_VIDEO_IMAGE_FORMAT: VideoImageFormat;
-export declare const DEFAULT_STILL_IMAGE_FORMAT: StillImageFormat;
-export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat | undefined, videoImageFormat: VideoImageFormat) => 'none' | 'valid';
-export declare const validateStillImageFormat: (imageFormat: StillImageFormat) => void;
+export declare const validImageFormats: readonly ["png", "jpeg", "none"];
+export declare type ImageFormat = typeof validImageFormats[number];
+export declare type StillImageFormat = 'png' | 'jpeg';
+export declare const DEFAULT_IMAGE_FORMAT: ImageFormat;
+export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat | undefined, imageFormat: ImageFormat) => 'none' | 'valid';
+export declare const validateNonNullImageFormat: (imageFormat: ImageFormat) => void;