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

package/dist/compositor/compose.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const get_executable_path_1 = require("./get-executable-path");
+const getCompositorHash = ({ ...input }) => {
+    return (0, crypto_1.createHash)('sha256').update(JSON.stringify(input)).digest('base64');
+};
+const compose = async ({ height, width, layers, output, downloadMap, imageFormat, }) => {
+    const bin = (0, get_executable_path_1.getExecutablePath)();
+    const hash = getCompositorHash({ height, width, layers, imageFormat });
+    if (downloadMap.compositorCache[hash]) {
+        await (0, promises_1.copyFile)(downloadMap.compositorCache[hash], output);
+        return;
+    }
+    const payload = {
+        v: 1,
+        height,
+        width,
+        layers,
+        output,
+        output_format: imageFormat,
+    };
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(bin);
+        child.stdin.write(JSON.stringify(payload));
+        child.stdin.end();
+        const stderrChunks = [];
+        child.stderr.on('data', (d) => stderrChunks.push(d));
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                const message = Buffer.concat(stderrChunks).toString('utf-8');
+                const parsed = JSON.parse(message);
+                const err = new Error(parsed.error);
+                err.stack = parsed.error + '\n' + parsed.backtrace;
+                reject(err);
+            }
+        });
+    });
+    downloadMap.compositorCache[hash] = output;
+};
+exports.compose = compose;

package/dist/compositor/get-executable-path.d.ts

@@ -0,0 +1 @@
+export declare const getExecutablePath: () => any;

package/dist/compositor/get-executable-path.js

@@ -0,0 +1,47 @@
+"use strict";
+// Adapted from @swc/core package
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExecutablePath = void 0;
+function isMusl() {
+    // @ts-expect-error no types
+    const { glibcVersionRuntime } = process.report.getReport().header;
+    return !glibcVersionRuntime;
+}
+const getExecutablePath = () => {
+    switch (process.platform) {
+        case 'win32':
+            switch (process.arch) {
+                case 'x64':
+                    return require('@remotion/compositor-win32-x64-msvc').binaryPath;
+                default:
+                    throw new Error(`Unsupported architecture on Windows: ${process.arch}`);
+            }
+        case 'darwin':
+            switch (process.arch) {
+                case 'x64':
+                    return require('@remotion/compositor-darwin-x64').binaryPath;
+                case 'arm64':
+                    return require('@remotion/compositor-darwin-arm64').binaryPath;
+                default:
+                    throw new Error(`Unsupported architecture on macOS: ${process.arch}`);
+            }
+        case 'linux':
+            switch (process.arch) {
+                case 'x64':
+                    if (isMusl()) {
+                        return require('@remotion/compositor-linux-x64-musl').binaryPath;
+                    }
+                    return require('@remotion/compositor-linux-x64-gnu').binaryPath;
+                case 'arm64':
+                    if (isMusl()) {
+                        return require('@remotion/compositor-linux-arm64-musl').binaryPath;
+                    }
+                    return require('@remotion/compositor-linux-arm64-gnu').binaryPath;
+                default:
+                    throw new Error(`Unsupported architecture on Linux: ${process.arch}`);
+            }
+        default:
+            throw new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`);
+    }
+};
+exports.getExecutablePath = getExecutablePath;

package/dist/compositor/payloads.d.ts

@@ -0,0 +1,41 @@
+export declare type Layer = {
+    type: 'PngImage';
+    params: {
+        src: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    type: 'JpgImage';
+    params: {
+        src: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    type: 'Solid';
+    params: {
+        fill: [number, number, number, number];
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+export declare type CompositorImageFormat = 'Png' | 'Jpeg';
+export declare type CliInput = {
+    v: number;
+    output: string;
+    width: number;
+    height: number;
+    layers: Layer[];
+    output_format: CompositorImageFormat;
+};
+export declare type ErrorPayload = {
+    error: string;
+    backtrace: string;
+};

package/dist/compositor/payloads.js

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

package/dist/convert-to-positive-frame-index.d.ts

@@ -0,0 +1,4 @@
+export declare const convertToPositiveFrameIndex: ({ frame, durationInFrames, }: {
+    frame: number;
+    durationInFrames: number;
+}) => number;

package/dist/convert-to-positive-frame-index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToPositiveFrameIndex = void 0;
+// Handle negative indices (e.g. -1 being the last frame)
+const convertToPositiveFrameIndex = ({ frame, durationInFrames, }) => {
+    return frame < 0 ? durationInFrames - frame : frame;
+};
+exports.convertToPositiveFrameIndex = convertToPositiveFrameIndex;

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

@@ -1,8 +1,12 @@
 import type { DownloadMap } from './assets/download-map';
-export declare const createFfmpegComplexFilter: (filters: number, downloadMap: DownloadMap) => Promise<{
-    complexFilterFlag: [
-        string,
-        string
-    ] | null;
+import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { PreprocessedAudioTrack } from './preprocess-audio-track';
+export declare const createFfmpegComplexFilter: ({ filters, downloadMap, ffmpegExecutable, remotionRoot, }: {
+    filters: PreprocessedAudioTrack[];
+    downloadMap: DownloadMap;
+    ffmpegExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}) => Promise<{
+    complexFilterFlag: [string, string] | null;
     cleanup: () => void;
 }>;

package/dist/create-ffmpeg-complex-filter.js

@@ -3,12 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFfmpegComplexFilter = void 0;
 const create_ffmpeg_merge_filter_1 = require("./create-ffmpeg-merge-filter");
 const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
-const createFfmpegComplexFilter = async (filters, downloadMap) => {
-    if (filters === 0) {
+const createFfmpegComplexFilter = async ({ filters, downloadMap, ffmpegExecutable, remotionRoot, }) => {
+    if (filters.length === 0) {
         return { complexFilterFlag: null, cleanup: () => undefined };
     }
-    const complexFilter = (0, create_ffmpeg_merge_filter_1.createFfmpegMergeFilter)(filters);
-    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(complexFilter, downloadMap);
+    const complexFilter = await (0, create_ffmpeg_merge_filter_1.createFfmpegMergeFilter)({
+        inputs: filters,
+        ffmpegExecutable,
+        remotionRoot,
+    });
+    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFileStr)(complexFilter, downloadMap);
     return {
         complexFilterFlag: ['-filter_complex_script', file],
         cleanup,

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

@@ -1 +1,8 @@
-export declare const createFfmpegMergeFilter: (inputs: number) => string;
+import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { PreprocessedAudioTrack } from './preprocess-audio-track';
+export declare const OUTPUT_FILTER_NAME = "outputaudio";
+export declare const createFfmpegMergeFilter: ({ inputs, ffmpegExecutable, remotionRoot, }: {
+    inputs: PreprocessedAudioTrack[];
+    ffmpegExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}) => Promise<string>;

package/dist/create-ffmpeg-merge-filter.js

@@ -1,18 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFfmpegMergeFilter = void 0;
+exports.createFfmpegMergeFilter = exports.OUTPUT_FILTER_NAME = void 0;
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const truthy_1 = require("./truthy");
-const createFfmpegMergeFilter = (inputs) => {
-    const leftChannel = new Array(inputs * 2)
-        .fill(true)
-        .map((_, i) => (i % 2 === 0 ? `c${i}` : null))
-        .filter(truthy_1.truthy)
-        .join('+');
-    const rightChannel = new Array(inputs * 2)
-        .fill(true)
-        .map((_, i) => (i % 2 === 1 ? `c${i}` : null))
-        .filter(truthy_1.truthy)
-        .join('+');
-    return `[0:a][1:a]amerge=inputs=${inputs},pan=stereo|c0=${leftChannel}|c1=${rightChannel}[a]`;
+exports.OUTPUT_FILTER_NAME = 'outputaudio';
+const createFfmpegMergeFilter = async ({ inputs, ffmpegExecutable, remotionRoot, }) => {
+    const ffmpegVersion = await (0, ffmpeg_flags_1.getFfmpegVersion)({
+        ffmpegExecutable,
+        remotionRoot,
+    });
+    const supportsNormalize = ffmpegVersion === null ||
+        (ffmpegVersion[0] === 4 && ffmpegVersion[1] >= 4) ||
+        ffmpegVersion[0] >= 5;
+    const pads = inputs.map((input, index) => {
+        const filters = [
+            input.filter.pad_start ? input.filter.pad_start : null,
+            input.filter.pad_end ? input.filter.pad_end : null,
+            'acopy',
+        ];
+        return `[${index}:a]${filters.filter(truthy_1.truthy).join(',')}[padded${index}]`;
+    });
+    const normalize = supportsNormalize ? ':normalize=0' : '';
+    return [
+        ...pads,
+        `${new Array(inputs.length)
+            .fill(true)
+            .map((_, i) => {
+            return `[padded${i}]`;
+        })
+            .join('')}amix=inputs=${inputs.length}:dropout_transition=0${normalize}[${exports.OUTPUT_FILTER_NAME}]`,
+    ].join(';');
 };
 exports.createFfmpegMergeFilter = createFfmpegMergeFilter;

package/dist/create-silent-audio.d.ts

@@ -1,6 +1,7 @@
 import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, }: {
+export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, remotionRoot, }: {
     ffmpegExecutable: FfmpegExecutable;
     numberOfSeconds: number;
     outName: string;
+    remotionRoot: string;
 }) => Promise<void>;

package/dist/create-silent-audio.js

@@ -5,9 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSilentAudio = void 0;
 const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const sample_rate_1 = require("./sample-rate");
-const createSilentAudio = async ({ ffmpegExecutable, numberOfSeconds, outName, }) => {
-    await (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+const createSilentAudio = async ({ ffmpegExecutable, numberOfSeconds, outName, remotionRoot, }) => {
+    await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-f',
         'lavfi',
         '-i',

package/dist/crf.d.ts

@@ -2,4 +2,8 @@ import type { Codec } from './codec';
 export declare type Crf = number | undefined;
 export declare const getDefaultCrfForCodec: (codec: Codec) => number;
 export declare const getValidCrfRanges: (codec: Codec) => [number, number];
-export declare const validateSelectedCrfAndCodecCombination: (crf: unknown, codec: Codec) => void;
+export declare const validateQualitySettings: ({ codec, crf, videoBitrate, }: {
+    crf: unknown;
+    codec: Codec;
+    videoBitrate: string | null | undefined;
+}) => string[];

package/dist/crf.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSelectedCrfAndCodecCombination = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = void 0;
+exports.validateQualitySettings = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = void 0;
 const is_audio_codec_1 = require("./is-audio-codec");
 const getDefaultCrfForCodec = (codec) => {
     if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
@@ -46,19 +46,46 @@ const getValidCrfRanges = (codec) => {
     throw new TypeError(`Got unexpected codec "${codec}"`);
 };
 exports.getValidCrfRanges = getValidCrfRanges;
-const validateSelectedCrfAndCodecCombination = (crf, codec) => {
-    if (crf === null) {
-        return;
+const validateQualitySettings = ({ codec, crf, videoBitrate, }) => {
+    if (crf && videoBitrate) {
+        throw new Error('"crf" and "videoBitrate" can not both be set. Choose one of either.');
+    }
+    if (videoBitrate) {
+        if (codec === 'prores') {
+            console.warn('ProRes does not support videoBitrate. Ignoring.');
+            return [];
+        }
+        if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+            console.warn(`${codec} does not support videoBitrate. Ignoring.`);
+            return [];
+        }
+        return ['-b:v', videoBitrate];
+    }
+    if (crf === null || typeof crf === 'undefined') {
+        const actualCrf = (0, exports.getDefaultCrfForCodec)(codec);
+        return ['-crf', String(actualCrf)];
     }
     if (typeof crf !== 'number') {
         throw new TypeError('Expected CRF to be a number, but is ' + JSON.stringify(crf));
     }
     const range = (0, exports.getValidCrfRanges)(codec);
     if (crf === 0 && (codec === 'h264' || codec === 'h264-mkv')) {
-        throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably want. Set CRF to a higher value to fix this error.");
+        throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably do not want. Set CRF to a higher value to fix this error.");
     }
     if (crf < range[0] || crf > range[1]) {
+        if (range[0] === 0 && range[1] === 0) {
+            throw new TypeError(`The "${codec}" codec does not support the --crf option.`);
+        }
         throw new TypeError(`CRF must be between ${range[0]} and ${range[1]} for codec ${codec}. Passed: ${crf}`);
     }
+    if (codec === 'prores') {
+        console.warn('ProRes does not support the "crf" option. Ignoring.');
+        return [];
+    }
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        console.warn(`${codec} does not support the "crf" option. Ignoring.`);
+        return [];
+    }
+    return ['-crf', String(crf)];
 };
-exports.validateSelectedCrfAndCodecCombination = validateSelectedCrfAndCodecCombination;
+exports.validateQualitySettings = validateQualitySettings;

package/dist/cycle-browser-tabs.d.ts

@@ -1,7 +1,4 @@
-import type { openBrowser } from './open-browser';
-declare type Await<T> = T extends PromiseLike<infer U> ? U : T;
-declare type Browser = Await<ReturnType<typeof openBrowser>>;
-export declare const cycleBrowserTabs: (puppeteerInstance: Browser, concurrency: number) => {
+import type { BrowserReplacer } from './replace-browser';
+export declare const cycleBrowserTabs: (puppeteerInstance: BrowserReplacer, concurrency: number) => {
     stopCycling: () => void;
 };
-export {};

package/dist/cycle-browser-tabs.js

@@ -13,24 +13,24 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
     const set = () => {
         interval = setTimeout(() => {
             puppeteerInstance
+                .getBrowser()
                 .pages()
                 .then((pages) => {
-                var _a;
                 if (pages.length === 0) {
                     return;
                 }
                 const currentPage = pages[i % pages.length];
                 i++;
-                if (!((_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) &&
+                if (!(currentPage === null || currentPage === void 0 ? void 0 : currentPage.closed) &&
                     !stopped &&
                     (currentPage === null || currentPage === void 0 ? void 0 : currentPage.url()) !== 'about:blank') {
                     return currentPage.bringToFront();
                 }
             })
-                .then(() => {
+                .catch((err) => console.log(err))
+                .finally(() => {
                 set();
-            })
-                .catch((err) => console.log(err));
+            });
         }, 200);
     };
     set();

package/dist/delete-directory.d.ts

@@ -1 +1 @@
-export declare const deleteDirectory: (directory: string) => Promise<void>;
+export declare const deleteDirectory: (directory: string) => void;

package/dist/delete-directory.js

@@ -1,30 +1,56 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteDirectory = void 0;
 const execa_1 = __importDefault(require("execa"));
-const fs_1 = __importDefault(require("fs"));
+const fs_1 = __importStar(require("fs"));
 const is_serve_url_1 = require("./is-serve-url");
-const deleteDirectory = async (directory) => {
+const deleteDirectory = (directory) => {
     var _a;
     if ((0, is_serve_url_1.isServeUrl)(directory)) {
         return;
     }
+    if (!(0, fs_1.existsSync)(directory)) {
+        return;
+    }
     if (process.platform === 'win32') {
         // We use del before to remove all files inside the directories otherwise
         // rmdir will throw an error.
-        await (0, execa_1.default)('cmd', ['/c', 'del', '/f', '/s', '/q', directory]);
+        execa_1.default.sync('cmd', ['/c', 'del', '/f', '/s', '/q', directory]);
         try {
-            await (0, execa_1.default)('cmd', ['/c', 'rmdir', '/s', '/q', directory]);
+            execa_1.default.sync('cmd', ['/c', 'rmdir', '/s', '/q', directory]);
         }
         catch (err) {
             // Is not a directory
         }
     }
     else {
-        await ((_a = fs_1.default.promises.rm) !== null && _a !== void 0 ? _a : fs_1.default.promises.rmdir)(directory, {
+        ((_a = fs_1.default.rmSync) !== null && _a !== void 0 ? _a : fs_1.default.rmdirSync)(directory, {
             recursive: true,
         });
     }

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

@@ -0,0 +1 @@
+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/does-have-m2-bug.d.ts

@@ -0,0 +1,3 @@
+import type { Codec } from './codec';
+import type { PixelFormat } from './pixel-format';
+export declare const warnAboutM2Bug: (codec: Codec | null, pixelFormat: PixelFormat | null) => void;

package/dist/does-have-m2-bug.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnAboutM2Bug = void 0;
+const os_1 = require("os");
+const warnAboutM2Bug = (codec, pixelFormat) => {
+    const isM2 = (0, os_1.cpus)().find((c) => c.model.includes('Apple M2'));
+    if (codec === 'prores' && pixelFormat === 'yuv422p10le' && isM2) {
+        console.warn();
+        console.warn('⚠️ Known issue: Apple M2 CPUs currently suffer from a bug where transparent ProRes videos have flickering. https://github.com/remotion-dev/remotion/issues/1929');
+    }
+};
+exports.warnAboutM2Bug = warnAboutM2Bug;

package/dist/ensure-ffmpeg.d.ts

@@ -0,0 +1,18 @@
+export declare type EnsureFfmpegOptions = {
+    remotionRoot?: string;
+};
+declare 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

@@ -1,2 +1,15 @@
 import type { DownloadMap } from './assets/download-map';
-export declare const ensurePresentationTimestamps: (downloadMap: DownloadMap, src: string) => Promise<string>;
+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>;