@remotion/renderer 4.0.22 → 4.0.24

package/.prettierignore

@@ -0,0 +1,2 @@
+# Has error in CI even though is formatted
+src/compositor/compositor.ts

package/dist/assets/get-video-stream-duration.d.ts

@@ -0,0 +1,9 @@
+import type { FfmpegExecutable } from '../ffmpeg-executable';
+import type { DownloadMap, VideoDurationResult } from './download-map';
+export declare const parseVideoStreamDuration: (stdout: string) => VideoDurationResult;
+export declare function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<VideoDurationResult>;
+export declare const getVideoStreamDuration: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<VideoDurationResult>;

package/dist/assets/get-video-stream-duration.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoStreamDuration = exports.getVideoStreamDurationwithoutCache = exports.parseVideoStreamDuration = void 0;
+const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("../ffmpeg-flags");
+const p_limit_1 = require("../p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+const parseAlternativeDuration = (stdout) => {
+    const webmDuration = stdout.match(/TAG:DURATION=([0-9.]+):([0-9.]+):([0-9.]+)/);
+    if (!webmDuration) {
+        return null;
+    }
+    const [, hours, minutes, seconds] = webmDuration;
+    const hoursAsNumber = Number(hours);
+    if (Number.isNaN(hoursAsNumber)) {
+        return null;
+    }
+    const minutesAsNumber = Number(minutes);
+    if (Number.isNaN(minutesAsNumber)) {
+        return null;
+    }
+    const secondsAsNumber = Number(seconds);
+    if (Number.isNaN(secondsAsNumber)) {
+        return null;
+    }
+    return secondsAsNumber + minutesAsNumber * 60 + hoursAsNumber * 3600;
+};
+const parseVideoStreamDuration = (stdout) => {
+    const duration = stdout.match(/duration=([0-9.]+)/);
+    const alternativeDuration = parseAlternativeDuration(stdout);
+    const fps = stdout.match(/r_frame_rate=([0-9.]+)\/([0-9.]+)/);
+    const result = {
+        duration: duration ? parseFloat(duration[1]) : alternativeDuration,
+        fps: fps ? parseInt(fps[1], 10) / parseInt(fps[2], 10) : null,
+    };
+    return result;
+};
+exports.parseVideoStreamDuration = parseVideoStreamDuration;
+async function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }) {
+    const args = [
+        ['-v', 'error'],
+        ['-select_streams', 'v:0'],
+        ['-show_entries', 'stream'],
+        [src],
+    ]
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter(Boolean);
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), args);
+    const result = (0, exports.parseVideoStreamDuration)(task.stdout);
+    return result;
+}
+exports.getVideoStreamDurationwithoutCache = getVideoStreamDurationwithoutCache;
+async function getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (downloadMap.videoDurationResultCache[src]) {
+        return downloadMap.videoDurationResultCache[src];
+    }
+    const result = await getVideoStreamDurationwithoutCache({
+        src,
+        ffprobeExecutable,
+        remotionRoot,
+    });
+    downloadMap.videoDurationResultCache[src] = result;
+    return result;
+}
+const getVideoStreamDuration = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
+};
+exports.getVideoStreamDuration = getVideoStreamDuration;

package/dist/audio-codec.d.ts

@@ -1,6 +1,6 @@
 import type { Codec } from './codec';
 export declare const validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
-export type AudioCodec = typeof validAudioCodecs[number];
+export type AudioCodec = (typeof validAudioCodecs)[number];
 export declare const supportedAudioCodecs: {
     readonly h264: readonly ["aac", "pcm-16", "mp3"];
     readonly 'h264-mkv': readonly ["pcm-16", "mp3"];
@@ -14,11 +14,11 @@ export declare const supportedAudioCodecs: {
     readonly wav: readonly ["pcm-16"];
 };
 declare const audioCodecNames: readonly ["pcm_s16le", "aac", "libmp3lame", "libopus"];
-type FfmpegAudioCodecName = typeof audioCodecNames[number];
+type FfmpegAudioCodecName = (typeof audioCodecNames)[number];
 export declare const mapAudioCodecToFfmpegAudioCodecName: (audioCodec: AudioCodec) => FfmpegAudioCodecName;
 export declare const defaultAudioCodecs: {
     [key in Codec]: {
-        [k in 'compressed' | 'lossless']: typeof supportedAudioCodecs[key][number] | null;
+        [k in 'compressed' | 'lossless']: (typeof supportedAudioCodecs)[key][number] | null;
     };
 };
 export declare const getDefaultAudioCodec: ({ codec, preferLossless, }: {

package/dist/calculate-sar-dar-pixels.d.ts

@@ -0,0 +1,9 @@
+export declare const calculateDisplayVideoSize: ({ darX, darY, x, y, }: {
+    x: number;
+    y: number;
+    darX: number;
+    darY: number;
+}) => {
+    width: number;
+    height: number;
+};

package/dist/calculate-sar-dar-pixels.js

@@ -0,0 +1,19 @@
+"use strict";
+// https://superuser.com/questions/907933/correct-aspect-ratio-without-re-encoding-video-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDisplayVideoSize = void 0;
+const calculateDisplayVideoSize = ({ darX, darY, x, y, }) => {
+    // We know two equations:
+    //   newWidth / newHeight = darX / darY
+    // and:
+    //   x * y = (newWidth * newHeight)
+    // I solved it then on pen and paper and simplified the formula:
+    const dimensions = x * y;
+    const newWidth = Math.sqrt(dimensions * (darX / darY));
+    const newHeight = dimensions / newWidth;
+    return {
+        height: Math.round(newHeight),
+        width: Math.round(newWidth),
+    };
+};
+exports.calculateDisplayVideoSize = calculateDisplayVideoSize;

package/dist/client.d.ts

@@ -194,14 +194,160 @@ export declare const BrowserSafeApis: {
         preferLossless: boolean;
     }) => void;
     options: {
-        scaleOption: import(".").RemotionOption;
-        crfOption: import(".").RemotionOption;
-        jpegQualityOption: import(".").RemotionOption;
-        videoBitrate: import(".").RemotionOption;
-        audioBitrateOption: import(".").RemotionOption;
-        enforceAudioOption: import(".").RemotionOption;
-        muteOption: import(".").RemotionOption;
-        videoCodecOption: import(".").RemotionOption;
+        scaleOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: number;
+        };
+        crfOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: number;
+        };
+        jpegQualityOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: number;
+        };
+        videoBitrate: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: string;
+        };
+        audioBitrateOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: string;
+        };
+        enforceAudioOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: boolean;
+        };
+        muteOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: boolean;
+        };
+        videoCodecOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: string;
+        };
+        offthreadVideoCacheSizeInBytesOption: {
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        };
+    };
+    optionsMap: {
+        readonly renderMedia: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderStill: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly getCompositions: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly selectComposition: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderFrames: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderMediaOnLambda: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderStillOnLambda: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly getCompositionsOnLambda: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderMediaOnCloudRun: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderStillOnCloudRun: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
     };
     codecSupportsCrf: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
     codecSupportsVideoBitrate: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;

package/dist/client.js

@@ -13,6 +13,8 @@ const crf_2 = require("./options/crf");
 const enforce_audio_1 = require("./options/enforce-audio");
 const jpeg_quality_1 = require("./options/jpeg-quality");
 const mute_1 = require("./options/mute");
+const offthreadvideo_cache_size_1 = require("./options/offthreadvideo-cache-size");
+const options_map_1 = require("./options/options-map");
 const scale_1 = require("./options/scale");
 const video_bitrate_1 = require("./options/video-bitrate");
 const video_codec_1 = require("./options/video-codec");
@@ -45,7 +47,9 @@ exports.BrowserSafeApis = {
         enforceAudioOption: enforce_audio_1.enforceAudioOption,
         muteOption: mute_1.muteOption,
         videoCodecOption: video_codec_1.videoCodecOption,
+        offthreadVideoCacheSizeInBytesOption: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
     },
+    optionsMap: options_map_1.optionsMap,
     codecSupportsCrf: codec_supports_media_1.codecSupportsCrf,
     codecSupportsVideoBitrate: codec_supports_media_1.codecSupportsVideoBitrate,
 };

package/dist/codec.d.ts

@@ -1,4 +1,4 @@
 export declare const validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
-export type Codec = typeof validCodecs[number];
+export type Codec = (typeof validCodecs)[number];
 export type CodecOrUndefined = Codec | undefined;
 export declare const DEFAULT_CODEC: Codec;

package/dist/compositor/compositor.d.ts

@@ -7,6 +7,6 @@ export type Compositor = {
     waitForDone: () => Promise<void>;
     pid: number | null;
 };
-export declare const getIdealMaximumFrameCacheItems: () => number;
-export declare const startLongRunningCompositor: (maximumFrameCacheItems: number, logLevel: LogLevel, indent: boolean) => Compositor;
+export declare const getIdealMaximumFrameCacheSizeInBytes: () => number;
+export declare const startLongRunningCompositor: (maximumFrameCacheItemsInBytes: number, logLevel: LogLevel, indent: boolean) => Compositor;
 export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T], logLevel: LogLevel, indent: boolean) => Compositor;

package/dist/compositor/compositor.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startCompositor = exports.startLongRunningCompositor = exports.getIdealMaximumFrameCacheItems = void 0;
+exports.startCompositor = exports.startLongRunningCompositor = exports.getIdealMaximumFrameCacheSizeInBytes = void 0;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_os_1 = __importDefault(require("node:os"));
@@ -14,21 +14,20 @@ const logger_1 = require("../logger");
 const compose_1 = require("./compose");
 const get_executable_path_1 = require("./get-executable-path");
 const make_nonce_1 = require("./make-nonce");
-const getIdealMaximumFrameCacheItems = () => {
+const getIdealMaximumFrameCacheSizeInBytes = () => {
     const freeMemory = node_os_1.default.freemem();
-    // Assuming 1 frame is approximately 24MB
-    // (4K video)
     // Assuming only half the available memory should be used
-    const max = Math.floor(freeMemory / (1024 * 1024 * 24));
-    // Never store more than 2000 frames
-    // But 60 is needed even if it's going to swap
-    return Math.max(60, Math.min(max, 2000));
+    const max = freeMemory / 2;
+    // Never store more than 2000 MB
+    // But 240MB is needed even if it's going to swap
+    return Math.max(mbToBytes(240), Math.min(max, mbToBytes(2000)));
 };
-exports.getIdealMaximumFrameCacheItems = getIdealMaximumFrameCacheItems;
-const startLongRunningCompositor = (maximumFrameCacheItems, logLevel, indent) => {
+exports.getIdealMaximumFrameCacheSizeInBytes = getIdealMaximumFrameCacheSizeInBytes;
+const mbToBytes = (mb) => mb * 1024 * 1024;
+const startLongRunningCompositor = (maximumFrameCacheItemsInBytes, logLevel, indent) => {
     return (0, exports.startCompositor)('StartLongRunningProcess', {
         concurrency: (0, get_concurrency_1.getActualConcurrency)(null),
-        maximum_frame_cache_items: maximumFrameCacheItems,
+        maximum_frame_cache_size_in_bytes: maximumFrameCacheItemsInBytes,
         verbose: (0, log_level_1.isEqualOrBelowLogLevel)(logLevel, 'verbose'),
     }, logLevel, indent);
 };
@@ -149,17 +148,17 @@ const startCompositor = (type, payload, logLevel, indent) => {
     child.on('close', (code, signal) => {
         const waitersToKill = Array.from(waiters.values());
         if (code === 0) {
-            runningStatus = { type: 'quit-without-error' };
+            runningStatus = { type: 'quit-without-error', signal };
             resolve === null || resolve === void 0 ? void 0 : resolve();
             for (const waiter of waitersToKill) {
-                waiter.reject(new Error(`Compositor already quit`));
+                waiter.reject(new Error(`Compositor quit${signal ? ` with signal ${signal}` : ''}`));
             }
             waiters.clear();
         }
         else {
             const errorMessage = Buffer.concat(stderrChunks).toString('utf-8') +
                 outputBuffer.toString('utf-8');
-            runningStatus = { type: 'quit-with-error', error: errorMessage };
+            runningStatus = { type: 'quit-with-error', error: errorMessage, signal };
             const error = code === null
                 ? new Error(`Compositor exited with signal ${signal}`)
                 : new Error(`Compositor panicked with code ${code}: ${errorMessage}`);
@@ -174,11 +173,15 @@ const startCompositor = (type, payload, logLevel, indent) => {
         waitForDone: () => {
             return new Promise((res, rej) => {
                 if (runningStatus.type === 'quit-without-error') {
-                    rej(new Error('Compositor already quit'));
+                    rej(new Error(`Compositor quit${runningStatus.signal
+                        ? ` with signal ${runningStatus.signal}`
+                        : ''}`));
                     return;
                 }
                 if (runningStatus.type === 'quit-with-error') {
-                    rej(new Error(`Compositor already quit: ${runningStatus.error}`));
+                    rej(new Error(`Compositor quit${runningStatus.signal
+                        ? ` with signal ${runningStatus.signal}`
+                        : ''}: ${runningStatus.error}`));
                     return;
                 }
                 resolve = res;
@@ -187,16 +190,16 @@ const startCompositor = (type, payload, logLevel, indent) => {
         },
         finishCommands: () => {
             if (runningStatus.type === 'quit-with-error') {
-                throw new Error(`Compositor already quit: ${runningStatus.error}`);
+                throw new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}: ${runningStatus.error}`);
             }
             if (runningStatus.type === 'quit-without-error') {
-                throw new Error('Compositor already quit');
+                throw new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}`);
             }
             child.stdin.write('EOF\n');
         },
         executeCommand: (command, params) => {
             if (runningStatus.type === 'quit-without-error') {
-                throw new Error('Compositor already quit');
+                throw new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}`);
             }
             if (runningStatus.type === 'quit-with-error') {
                 throw new Error(`Compositor quit: ${runningStatus.error}`);

package/dist/compositor/payloads.d.ts

@@ -72,7 +72,7 @@ export type CompositorCommand = {
     };
     StartLongRunningProcess: {
         concurrency: number;
-        maximum_frame_cache_items: number;
+        maximum_frame_cache_size_in_bytes: number;
         verbose: boolean;
     };
     CopyImageToClipboard: {
@@ -82,7 +82,7 @@ export type CompositorCommand = {
     DeliberatePanic: {};
     CloseAllVideos: {};
     FreeUpMemory: {
-        percent_of_memory: number;
+        remaining_bytes: number;
     };
     GetVideoMetadata: {
         src: string;

package/dist/copy-to-clipboard.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.copyImageToClipboard = void 0;
 const compositor_1 = require("./compositor/compositor");
 const copyImageToClipboard = async (src, logLevel) => {
-    const compositor = (0, compositor_1.startLongRunningCompositor)((0, compositor_1.getIdealMaximumFrameCacheItems)(), logLevel, false);
+    const compositor = (0, compositor_1.startLongRunningCompositor)((0, compositor_1.getIdealMaximumFrameCacheSizeInBytes)(), logLevel, false);
     await compositor.executeCommand('CopyImageToClipboard', {
         src,
     });

package/dist/create-ffmpeg-complex-filter.d.ts

@@ -4,6 +4,9 @@ export declare const createFfmpegComplexFilter: ({ filters, downloadMap, }: {
     filters: PreprocessedAudioTrack[];
     downloadMap: DownloadMap;
 }) => Promise<{
-    complexFilterFlag: [string, string] | null;
+    complexFilterFlag: [
+        string,
+        string
+    ] | null;
     cleanup: () => void;
 }>;

package/dist/determine-resize-params.d.ts

@@ -0,0 +1,4 @@
+export declare const determineResizeParams: (needsResize: [
+    number,
+    number
+] | null) => string[];

package/dist/determine-resize-params.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineResizeParams = void 0;
+const determineResizeParams = (needsResize) => {
+    if (needsResize === null) {
+        return [];
+    }
+    return ['-s', `${needsResize[0]}x${needsResize[1]}`];
+};
+exports.determineResizeParams = determineResizeParams;

package/dist/determine-vcodec-ffmpeg-flags.d.ts

@@ -0,0 +1,2 @@
+import type { SpecialVCodecForTransparency } from './assets/download-map';
+export declare const determineVcodecFfmpegFlags: (vcodecFlag: SpecialVCodecForTransparency) => string[];

package/dist/determine-vcodec-ffmpeg-flags.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineVcodecFfmpegFlags = void 0;
+const truthy_1 = require("./truthy");
+const determineVcodecFfmpegFlags = (vcodecFlag) => {
+    return [
+        vcodecFlag === 'vp9' ? '-vcodec' : null,
+        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
+        vcodecFlag === 'vp8' ? '-vcodec' : null,
+        vcodecFlag === 'vp8' ? 'libvpx' : null,
+    ].filter(truthy_1.truthy);
+};
+exports.determineVcodecFfmpegFlags = determineVcodecFfmpegFlags;

package/dist/ensure-ffmpeg.d.ts

@@ -0,0 +1,18 @@
+export type EnsureFfmpegOptions = {
+    remotionRoot?: string;
+};
+type Result = {
+    result: 'found-in-path' | 'found-in-node-modules' | 'installed';
+    wasAlreadyInstalled: boolean;
+};
+/**
+ * @description Checks if the ffmpeg binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffmpeg)
+ */
+export declare const ensureFfmpeg: (options?: EnsureFfmpegOptions) => Promise<Result>;
+/**
+ * @description Checks if the ffprobe binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffprobe)
+ */
+export declare const ensureFfprobe: (options?: EnsureFfmpegOptions) => Promise<Result>;
+export {};

package/dist/ensure-ffmpeg.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFfprobe = exports.ensureFfmpeg = void 0;
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const validate_ffmpeg_1 = require("./validate-ffmpeg");
+const ensureFfmpegOrFfprobe = async (binary, options) => {
+    var _a;
+    const exists = (0, validate_ffmpeg_1.binaryExists)(binary);
+    const remotionRoot = (_a = options === null || options === void 0 ? void 0 : options.remotionRoot) !== null && _a !== void 0 ? _a : process.cwd();
+    if (exists) {
+        return {
+            wasAlreadyInstalled: true,
+            result: 'found-in-path',
+        };
+    }
+    if (process.platform === 'linux' && (0, fs_1.existsSync)(ffmpeg_flags_1.lambdaFfmpegPaths[binary])) {
+        return {
+            wasAlreadyInstalled: true,
+            result: 'found-in-path',
+        };
+    }
+    if ((0, ffmpeg_flags_1.ffmpegInNodeModules)(remotionRoot, binary)) {
+        return {
+            result: 'found-in-node-modules',
+            wasAlreadyInstalled: true,
+        };
+    }
+    const binaryUrl = (0, ffmpeg_flags_1.getBinaryDownloadUrl)(binary);
+    if (binaryUrl) {
+        await (0, ffmpeg_flags_1.downloadBinary)(remotionRoot, binaryUrl.url, binary);
+        return {
+            result: 'installed',
+            wasAlreadyInstalled: false,
+        };
+    }
+    throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);
+};
+/**
+ * @description Checks if the ffmpeg binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffmpeg)
+ */
+const ensureFfmpeg = (options) => {
+    return ensureFfmpegOrFfprobe('ffmpeg', options);
+};
+exports.ensureFfmpeg = ensureFfmpeg;
+/**
+ * @description Checks if the ffprobe binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffprobe)
+ */
+const ensureFfprobe = (options) => {
+    return ensureFfmpegOrFfprobe('ffprobe', options);
+};
+exports.ensureFfprobe = ensureFfprobe;

package/dist/ensure-presentation-timestamp.d.ts

@@ -0,0 +1,15 @@
+import type { DownloadMap } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const ensurePresentationTimestampWithoutCache: ({ src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }: {
+    src: string;
+    remotionRoot: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+}) => Promise<string>;
+export declare const ensurePresentationTimestamps: ({ downloadMap, src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }: {
+    downloadMap: DownloadMap;
+    src: string;
+    remotionRoot: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+}) => Promise<string>;