@remotion/renderer 4.0.0-alpha4 → 4.0.0-alpha6

package/dist/combine-videos.js

@@ -1,27 +1,23 @@
 "use strict";
 // Combine multiple video chunks, useful for decentralized rendering
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.combineVideos = void 0;
-const execa_1 = __importDefault(require("execa"));
-const fs_1 = require("fs");
-const path_1 = require("path");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const audio_codec_1 = require("./audio-codec");
-const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const call_ffmpeg_1 = require("./call-ffmpeg");
 const is_audio_codec_1 = require("./is-audio-codec");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const truthy_1 = require("./truthy");
 const combineVideos = async (options) => {
     var _a;
-    const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, ffmpegExecutable, remotionRoot, audioCodec, } = options;
+    const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, audioCodec, } = options;
     const fileList = files.map((p) => `file '${p}'`).join('\n');
-    const fileListTxt = (0, path_1.join)(filelistDir, 'files.txt');
-    (0, fs_1.writeFileSync)(fileListTxt, fileList);
+    const fileListTxt = (0, node_path_1.join)(filelistDir, 'files.txt');
+    (0, node_fs_1.writeFileSync)(fileListTxt, fileList);
     const resolvedAudioCodec = audioCodec !== null && audioCodec !== void 0 ? audioCodec : (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless: false });
     try {
-        const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+        const task = (0, call_ffmpeg_1.callFf)('ffmpeg', [
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-r',
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : String(fps),
             '-f',
@@ -60,10 +56,10 @@ const combineVideos = async (options) => {
         });
         await task;
         onProgress(numberOfFrames);
-        (fs_1.rmSync !== null && fs_1.rmSync !== void 0 ? fs_1.rmSync : fs_1.rmdirSync)(filelistDir, { recursive: true });
+        (0, node_fs_1.rmSync)(filelistDir, { recursive: true });
     }
     catch (err) {
-        (fs_1.rmSync !== null && fs_1.rmSync !== void 0 ? fs_1.rmSync : fs_1.rmdirSync)(filelistDir, { recursive: true });
+        (0, node_fs_1.rmSync)(filelistDir, { recursive: true });
         throw err;
     }
 };

package/dist/compositor/compose.d.ts

@@ -1,13 +1,15 @@
 import type { DownloadMap } from '../assets/download-map';
-import type { CompositorImageFormat, Layer } from './payloads';
+import type { CompositorCommand, CompositorCommandSerialized, CompositorImageFormat, Layer } from './payloads';
 declare type CompositorInput = {
     height: number;
     width: number;
     layers: Layer[];
     imageFormat: CompositorImageFormat;
 };
+export declare const serializeCommand: <Type extends keyof CompositorCommand>(command: Type, params: CompositorCommand[Type]) => CompositorCommandSerialized<Type>;
 export declare const compose: ({ height, width, layers, output, downloadMap, imageFormat, }: CompositorInput & {
     downloadMap: DownloadMap;
     output: string;
 }) => Promise<void>;
+export declare const callCompositor: (payload: string) => Promise<void>;
 export {};

package/dist/compositor/compose.js

@@ -1,31 +1,49 @@
 "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");
+exports.callCompositor = exports.compose = exports.serializeCommand = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const call_ffmpeg_1 = require("../call-ffmpeg");
 const get_executable_path_1 = require("./get-executable-path");
+const make_nonce_1 = require("./make-nonce");
 const getCompositorHash = ({ ...input }) => {
-    return (0, crypto_1.createHash)('sha256').update(JSON.stringify(input)).digest('base64');
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(input)).digest('base64');
 };
+const serializeCommand = (command, params) => {
+    return {
+        nonce: (0, make_nonce_1.makeNonce)(),
+        payload: {
+            type: command,
+            params,
+        },
+    };
+};
+exports.serializeCommand = serializeCommand;
 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,
+    const payload = (0, exports.serializeCommand)('Compose', {
         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));
+    });
+    await (0, exports.callCompositor)(JSON.stringify(payload));
+    downloadMap.compositorCache[hash] = output;
+};
+exports.compose = compose;
+const callCompositor = (payload) => {
+    return new Promise((resolve, reject) => {
+        const execPath = (0, get_executable_path_1.getExecutablePath)('compositor');
+        (0, node_fs_1.chmodSync)(execPath, 0o755);
+        const child = (0, node_child_process_1.spawn)(execPath, [payload], (0, call_ffmpeg_1.dynamicLibraryPathOptions)());
+        child.stdin.write(payload);
         child.stdin.end();
         const stderrChunks = [];
         child.stderr.on('data', (d) => stderrChunks.push(d));
@@ -35,13 +53,18 @@ const compose = async ({ height, width, layers, output, downloadMap, imageFormat
             }
             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);
+                try {
+                    // Try to see if the error is a JSON
+                    const parsed = JSON.parse(message);
+                    const msg = `Compositor error: ${parsed.error}`;
+                    const err = new Error(`${msg}\n${parsed.backtrace}`);
+                    reject(err);
+                }
+                catch (err) {
+                    reject(new Error(`Compositor panicked: ${message}`));
+                }
             }
         });
     });
-    downloadMap.compositorCache[hash] = output;
 };
-exports.compose = compose;
+exports.callCompositor = callCompositor;

package/dist/compositor/compositor.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import type { CompositorCommand } from './payloads';
+declare type Compositor = {
+    finishCommands: () => void;
+    executeCommand: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T]) => Promise<Buffer>;
+    waitForDone: () => Promise<void>;
+    pid: number | null;
+};
+export declare const getIdealMaximumFrameCacheItems: () => number;
+export declare const startLongRunningCompositor: (maximumFrameCacheItems: number, verbose: boolean) => Compositor;
+export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T]) => Compositor;
+export {};

package/dist/compositor/compositor.js

@@ -0,0 +1,204 @@
+"use strict";
+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;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const call_ffmpeg_1 = require("../call-ffmpeg");
+const get_concurrency_1 = require("../get-concurrency");
+const compose_1 = require("./compose");
+const get_executable_path_1 = require("./get-executable-path");
+const make_nonce_1 = require("./make-nonce");
+const getIdealMaximumFrameCacheItems = () => {
+    const freeMemory = node_os_1.default.freemem();
+    // Assuming 1 frame is approximately 6MB
+    // Assuming only half the available memory should be used
+    const max = Math.floor(freeMemory / (1024 * 1024 * 6));
+    // Never store more than 1000 frames
+    // But 100 is needed even if it's going to swap
+    return Math.max(100, Math.min(max, 1000));
+};
+exports.getIdealMaximumFrameCacheItems = getIdealMaximumFrameCacheItems;
+const startLongRunningCompositor = (maximumFrameCacheItems, verbose) => {
+    return (0, exports.startCompositor)('StartLongRunningProcess', {
+        concurrency: (0, get_concurrency_1.getActualConcurrency)(null),
+        maximum_frame_cache_items: maximumFrameCacheItems,
+        verbose,
+    });
+};
+exports.startLongRunningCompositor = startLongRunningCompositor;
+const startCompositor = (type, payload) => {
+    var _a;
+    const bin = (0, get_executable_path_1.getExecutablePath)('compositor');
+    (0, node_fs_1.chmodSync)(bin, 0o755);
+    const fullCommand = (0, compose_1.serializeCommand)(type, payload);
+    const child = (0, node_child_process_1.spawn)(bin, [JSON.stringify(fullCommand)], (0, call_ffmpeg_1.dynamicLibraryPathOptions)());
+    const stderrChunks = [];
+    let outputBuffer = Buffer.from('');
+    const separator = Buffer.from('remotion_buffer:');
+    const waiters = new Map();
+    const onMessage = (statusType, nonce, data) => {
+        if (nonce === '0') {
+            console.log(data.toString('utf8'));
+        }
+        if (waiters.has(nonce)) {
+            if (statusType === 'error') {
+                try {
+                    const parsed = JSON.parse(data.toString('utf8'));
+                    waiters.get(nonce).reject(new Error(`Compositor error: ${parsed.error}\n${parsed.backtrace}`));
+                }
+                catch (err) {
+                    waiters.get(nonce).reject(new Error(data.toString('utf8')));
+                }
+            }
+            else {
+                waiters.get(nonce).resolve(data);
+            }
+            waiters.delete(nonce);
+        }
+    };
+    let quit = false;
+    let missingData = null;
+    const processInput = () => {
+        let separatorIndex = outputBuffer.indexOf(separator);
+        if (separatorIndex === -1) {
+            return;
+        }
+        separatorIndex += separator.length;
+        let nonceString = '';
+        let lengthString = '';
+        let statusString = '';
+        // Each message from Rust is prefixed with `remotion_buffer;{[nonce]}:{[length]}`
+        // Let's read the buffer to extract the nonce, and if the full length is available,
+        // we'll extract the data and pass it to the callback.
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDigit = outputBuffer[separatorIndex];
+            // 0x3a is the character ":"
+            if (nextDigit === 0x3a) {
+                separatorIndex++;
+                break;
+            }
+            separatorIndex++;
+            nonceString += String.fromCharCode(nextDigit);
+        }
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDigit = outputBuffer[separatorIndex];
+            if (nextDigit === 0x3a) {
+                separatorIndex++;
+                break;
+            }
+            separatorIndex++;
+            lengthString += String.fromCharCode(nextDigit);
+        }
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDigit = outputBuffer[separatorIndex];
+            if (nextDigit === 0x3a) {
+                break;
+            }
+            separatorIndex++;
+            statusString += String.fromCharCode(nextDigit);
+        }
+        const length = Number(lengthString);
+        const status = Number(statusString);
+        const dataLength = outputBuffer.length - separatorIndex - 1;
+        if (dataLength < length) {
+            missingData = {
+                dataMissing: length - dataLength,
+            };
+            return;
+        }
+        const data = outputBuffer.subarray(separatorIndex + 1, separatorIndex + 1 + Number(lengthString));
+        onMessage(status === 1 ? 'error' : 'success', nonceString, data);
+        missingData = null;
+        outputBuffer = outputBuffer.subarray(separatorIndex + Number(lengthString) + 1);
+        processInput();
+    };
+    let unprocessedBuffers = [];
+    child.stdout.on('data', (data) => {
+        unprocessedBuffers.push(data);
+        const separatorIndex = data.indexOf(separator);
+        if (separatorIndex === -1) {
+            if (missingData) {
+                missingData.dataMissing -= data.length;
+            }
+            if (!missingData || missingData.dataMissing > 0) {
+                return;
+            }
+        }
+        unprocessedBuffers.unshift(outputBuffer);
+        outputBuffer = Buffer.concat(unprocessedBuffers);
+        unprocessedBuffers = [];
+        processInput();
+    });
+    child.stderr.on('data', (data) => {
+        stderrChunks.push(data);
+    });
+    let resolve = null;
+    let reject = null;
+    child.on('close', (code) => {
+        quit = true;
+        const waitersToKill = Array.from(waiters.values());
+        if (code === 0) {
+            resolve === null || resolve === void 0 ? void 0 : resolve();
+            for (const waiter of waitersToKill) {
+                waiter.reject(new Error(`Compositor already quit`));
+            }
+            waiters.clear();
+        }
+        else {
+            const error = new Error(`Compositor panicked: ${Buffer.concat(stderrChunks).toString('utf-8')}`);
+            for (const waiter of waitersToKill) {
+                waiter.reject(error);
+            }
+            waiters.clear();
+            reject === null || reject === void 0 ? void 0 : reject(error);
+        }
+    });
+    return {
+        waitForDone: () => {
+            return new Promise((res, rej) => {
+                if (quit) {
+                    rej(new Error('Compositor already quit'));
+                    return;
+                }
+                resolve = res;
+                reject = rej;
+            });
+        },
+        finishCommands: () => {
+            if (quit) {
+                throw new Error('Compositor already quit');
+            }
+            child.stdin.write('EOF\n');
+        },
+        executeCommand: (command, params) => {
+            if (quit) {
+                throw new Error('Compositor already quit');
+            }
+            return new Promise((_resolve, _reject) => {
+                const nonce = (0, make_nonce_1.makeNonce)();
+                const composed = {
+                    nonce,
+                    payload: {
+                        type: command,
+                        params,
+                    },
+                };
+                // TODO: Should have a way to error out a single task
+                child.stdin.write(JSON.stringify(composed) + '\n');
+                waiters.set(nonce, {
+                    resolve: _resolve,
+                    reject: _reject,
+                });
+            });
+        },
+        pid: (_a = child.pid) !== null && _a !== void 0 ? _a : null,
+    };
+};
+exports.startCompositor = startCompositor;

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

@@ -1 +1 @@
-export declare const getExecutablePath: () => any;
+export declare const getExecutablePath: (type: 'compositor' | 'ffmpeg' | 'ffprobe' | 'ffmpeg-cwd') => string;

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

@@ -7,21 +7,40 @@ function isMusl() {
     const { glibcVersionRuntime } = process.report.getReport().header;
     return !glibcVersionRuntime;
 }
-const getExecutablePath = () => {
+const getExecutablePath = (type) => {
+    if (type === 'ffmpeg' && process.env.FFMPEG_BIN_PATH) {
+        return '/opt/ffmpeg/remotion/bin/ffmpeg';
+    }
+    if (type === 'ffprobe' && process.env.FFPROBE_BIN_PATH) {
+        return '/opt/ffmpeg/remotion/bin/ffprobe';
+    }
+    if (type === 'ffmpeg-cwd' && process.env.FFMPEG_CWD) {
+        return '/opt/ffmpeg';
+    }
+    if (type === 'compositor' && process.env.COMPOSITOR_PATH) {
+        return './compositor';
+    }
+    const key = type === 'compositor'
+        ? 'binaryPath'
+        : type === 'ffmpeg'
+            ? 'ffmpegPath'
+            : type === 'ffprobe'
+                ? 'ffprobePath'
+                : 'ffmpegCwd';
     switch (process.platform) {
         case 'win32':
             switch (process.arch) {
                 case 'x64':
-                    return require('@remotion/compositor-win32-x64-msvc').binaryPath;
+                    return require('@remotion/compositor-win32-x64-msvc')[key];
                 default:
                     throw new Error(`Unsupported architecture on Windows: ${process.arch}`);
             }
         case 'darwin':
             switch (process.arch) {
                 case 'x64':
-                    return require('@remotion/compositor-darwin-x64').binaryPath;
+                    return require('@remotion/compositor-darwin-x64')[key];
                 case 'arm64':
-                    return require('@remotion/compositor-darwin-arm64').binaryPath;
+                    return require('@remotion/compositor-darwin-arm64')[key];
                 default:
                     throw new Error(`Unsupported architecture on macOS: ${process.arch}`);
             }
@@ -29,14 +48,14 @@ const getExecutablePath = () => {
             switch (process.arch) {
                 case 'x64':
                     if (isMusl()) {
-                        return require('@remotion/compositor-linux-x64-musl').binaryPath;
+                        return require('@remotion/compositor-linux-x64-musl')[key];
                     }
-                    return require('@remotion/compositor-linux-x64-gnu').binaryPath;
+                    return require('@remotion/compositor-linux-x64-gnu')[key];
                 case 'arm64':
                     if (isMusl()) {
-                        return require('@remotion/compositor-linux-arm64-musl').binaryPath;
+                        return require('@remotion/compositor-linux-arm64-musl')[key];
                     }
-                    return require('@remotion/compositor-linux-arm64-gnu').binaryPath;
+                    return require('@remotion/compositor-linux-arm64-gnu')[key];
                 default:
                     throw new Error(`Unsupported architecture on Linux: ${process.arch}`);
             }

package/dist/compositor/make-nonce.d.ts

@@ -0,0 +1 @@
+export declare const makeNonce: () => string;

package/dist/compositor/make-nonce.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNonce = void 0;
+const makeNonce = () => {
+    return (Math.random().toString(36).substring(2, 15) +
+        Math.random().toString(36).substring(2, 15));
+};
+exports.makeNonce = makeNonce;

package/dist/compositor/payloads.d.ts

@@ -27,13 +27,40 @@ export declare type Layer = {
     };
 };
 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 CompositorCommand = {
+    Compose: {
+        output: string;
+        width: number;
+        height: number;
+        layers: Layer[];
+        output_format: CompositorImageFormat;
+    };
+    ExtractFrame: {
+        input: string;
+        time: number;
+        transparent: boolean;
+    };
+    Echo: {
+        message: string;
+    };
+    StartLongRunningProcess: {
+        concurrency: number;
+        maximum_frame_cache_items: number;
+        verbose: boolean;
+    };
+    GetOpenVideoStats: {};
+    DeliberatePanic: {};
+    CloseAllVideos: {};
+    FreeUpMemory: {
+        percent_of_memory: number;
+    };
+};
+export declare type CompositorCommandSerialized<T extends keyof CompositorCommand> = {
+    nonce: string;
+    payload: {
+        type: T;
+        params: CompositorCommand[T];
+    };
 };
 export declare type ErrorPayload = {
     error: string;

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

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

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

@@ -3,14 +3,12 @@ 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, ffmpegExecutable, remotionRoot, }) => {
+const createFfmpegComplexFilter = async ({ filters, downloadMap, }) => {
     if (filters.length === 0) {
         return { complexFilterFlag: null, cleanup: () => undefined };
     }
-    const complexFilter = await (0, create_ffmpeg_merge_filter_1.createFfmpegMergeFilter)({
+    const complexFilter = (0, create_ffmpeg_merge_filter_1.createFfmpegMergeFilter)({
         inputs: filters,
-        ffmpegExecutable,
-        remotionRoot,
     });
     const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFileStr)(complexFilter, downloadMap);
     return {

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

@@ -1,8 +1,5 @@
-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, }: {
+export declare const createFfmpegMergeFilter: ({ inputs, }: {
     inputs: PreprocessedAudioTrack[];
-    ffmpegExecutable: FfmpegExecutable;
-    remotionRoot: string;
-}) => Promise<string>;
+}) => string;

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

@@ -1,17 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFfmpegMergeFilter = exports.OUTPUT_FILTER_NAME = void 0;
-const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const truthy_1 = require("./truthy");
 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 createFfmpegMergeFilter = ({ inputs, }) => {
     const pads = inputs.map((input, index) => {
         const filters = [
             input.filter.pad_start ? input.filter.pad_start : null,
@@ -20,7 +12,7 @@ const createFfmpegMergeFilter = async ({ inputs, ffmpegExecutable, remotionRoot,
         ];
         return `[${index}:a]${filters.filter(truthy_1.truthy).join(',')}[padded${index}]`;
     });
-    const normalize = supportsNormalize ? ':normalize=0' : '';
+    const normalize = ':normalize=0';
     return [
         ...pads,
         `${new Array(inputs.length)

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

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

package/dist/create-silent-audio.js

@@ -1,14 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": 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 call_ffmpeg_1 = require("./call-ffmpeg");
 const sample_rate_1 = require("./sample-rate");
-const createSilentAudio = async ({ ffmpegExecutable, numberOfSeconds, outName, remotionRoot, }) => {
-    await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+const createSilentAudio = async ({ numberOfSeconds, outName, }) => {
+    await (0, call_ffmpeg_1.callFf)('ffmpeg', [
         '-f',
         'lavfi',
         '-i',

package/dist/crf.js

@@ -9,7 +9,7 @@ const getDefaultCrfForCodec = (codec) => {
     if (codec === 'h264' || codec === 'h264-mkv') {
         return 18; // FFMPEG default 23
     }
-    if (codec === 'h265' || codec === 'gif') {
+    if (codec === 'h265') {
         return 23; // FFMPEG default 28
     }
     if (codec === 'vp8') {
@@ -21,6 +21,9 @@ const getDefaultCrfForCodec = (codec) => {
     if (codec === 'prores') {
         return 0;
     }
+    if (codec === 'gif') {
+        return 0;
+    }
     throw new TypeError(`Got unexpected codec "${codec}"`);
 };
 exports.getDefaultCrfForCodec = getDefaultCrfForCodec;
@@ -31,10 +34,13 @@ const getValidCrfRanges = (codec) => {
     if (codec === 'prores') {
         return [0, 0];
     }
+    if (codec === 'gif') {
+        return [0, 0];
+    }
     if (codec === 'h264' || codec === 'h264-mkv') {
         return [1, 51];
     }
-    if (codec === 'h265' || codec === 'gif') {
+    if (codec === 'h265') {
         return [0, 51];
     }
     if (codec === 'vp8') {