@remotion/renderer 4.0.0-defer.6 → 4.0.0-esm.17

package/dist/codec-supports-media.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codecSupportsCrf = exports.codecSupportsMedia = void 0;
+const get_codec_name_1 = require("./get-codec-name");
+const support = {
+    'h264-mkv': {
+        audio: true,
+        video: true,
+    },
+    aac: {
+        audio: true,
+        video: false,
+    },
+    gif: {
+        video: true,
+        audio: false,
+    },
+    h264: {
+        video: true,
+        audio: true,
+    },
+    h265: {
+        video: true,
+        audio: true,
+    },
+    mp3: {
+        audio: true,
+        video: false,
+    },
+    prores: {
+        audio: true,
+        video: true,
+    },
+    vp8: {
+        audio: true,
+        video: true,
+    },
+    vp9: {
+        audio: true,
+        video: true,
+    },
+    wav: {
+        audio: true,
+        video: false,
+    },
+};
+const codecSupportsMedia = (codec) => {
+    return support[codec];
+};
+exports.codecSupportsMedia = codecSupportsMedia;
+const codecSupportsCrf = (codec) => {
+    const encoderName = (0, get_codec_name_1.getCodecName)(codec);
+    const supportsCrf = encoderName && codec !== 'prores';
+    return supportsCrf;
+};
+exports.codecSupportsCrf = codecSupportsCrf;

package/dist/codec.d.ts

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

package/dist/codec.js

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

package/dist/combine-videos.d.ts

@@ -1,5 +1,6 @@
-import { Codec } from 'remotion';
-export declare const combineVideos: ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, }: {
+import type { Codec } from './codec';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+declare type Options = {
     files: string[];
     filelistDir: string;
     output: string;
@@ -7,4 +8,9 @@ export declare const combineVideos: ({ files, filelistDir, output, onProgress, n
     numberOfFrames: number;
     codec: Codec;
     fps: number;
-}) => Promise<void>;
+    numberOfGifLoops: number | null;
+    remotionRoot: string;
+    ffmpegExecutable: FfmpegExecutable;
+};
+export declare const combineVideos: (options: Options) => Promise<void>;
+export {};

package/dist/combine-videos.js

@@ -8,37 +8,45 @@ exports.combineVideos = void 0;
 const execa_1 = __importDefault(require("execa"));
 const fs_1 = require("fs");
 const path_1 = require("path");
-const remotion_1 = require("remotion");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const get_audio_codec_name_1 = require("./get-audio-codec-name");
+const is_audio_codec_1 = require("./is-audio-codec");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
-const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, }) => {
+const truthy_1 = require("./truthy");
+const combineVideos = async (options) => {
     var _a;
+    const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, ffmpegExecutable, remotionRoot, } = 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);
     try {
-        const task = (0, execa_1.default)('ffmpeg', [
-            remotion_1.Internals.isAudioCodec(codec) ? null : '-r',
-            remotion_1.Internals.isAudioCodec(codec) ? null : String(fps),
+        const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+            (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-r',
+            (0, is_audio_codec_1.isAudioCodec)(codec) ? null : String(fps),
             '-f',
             'concat',
             '-safe',
             '0',
             '-i',
             fileListTxt,
-            remotion_1.Internals.isAudioCodec(codec) ? null : '-c:v',
-            remotion_1.Internals.isAudioCodec(codec) ? null : 'copy',
+            numberOfGifLoops === null ? null : '-loop',
+            numberOfGifLoops === null
+                ? null
+                : typeof numberOfGifLoops === 'number'
+                    ? String(numberOfGifLoops)
+                    : '-1',
+            (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-c:v',
+            (0, is_audio_codec_1.isAudioCodec)(codec) ? null : codec === 'gif' ? 'gif' : 'copy',
             '-c:a',
             (0, get_audio_codec_name_1.getAudioCodecName)(codec),
-            // Set max bitrate up to 1024kbps, will choose lower if that's too much
+            // Set max bitrate up to 512kbps, will choose lower if that's too much
             '-b:a',
             '512K',
             codec === 'h264' ? '-movflags' : null,
             codec === 'h264' ? 'faststart' : null,
-            '-shortest',
             '-y',
             output,
-        ].filter(remotion_1.Internals.truthy));
+        ].filter(truthy_1.truthy));
         (_a = task.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
             if (onProgress) {
                 const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(data.toString());

package/dist/compositor/compose.d.ts

@@ -0,0 +1,13 @@
+import type { DownloadMap } from '../assets/download-map';
+import type { CompositorImageFormat, Layer } from './payloads';
+declare type CompositorInput = {
+    height: number;
+    width: number;
+    layers: Layer[];
+    imageFormat: CompositorImageFormat;
+};
+export declare const compose: ({ height, width, layers, output, downloadMap, imageFormat, }: CompositorInput & {
+    downloadMap: DownloadMap;
+    output: string;
+}) => Promise<void>;
+export {};

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

@@ -0,0 +1,12 @@
+import type { CompositorCommand, CompositorInitiatePayload } from './payloads';
+export declare type Compositor = {
+    finishCommands: () => void;
+    executeCommand: (payload: Omit<CompositorCommand, 'nonce'>) => Promise<void>;
+    waitForDone: () => Promise<void>;
+};
+export declare const spawnCompositorOrReuse: ({ initiatePayload, renderId, }: {
+    initiatePayload: CompositorInitiatePayload;
+    renderId: string;
+}) => Compositor;
+export declare const releaseCompositorWithId: (renderId: string) => void;
+export declare const waitForCompositorWithIdToQuit: (renderId: string) => Promise<void>;

package/dist/compositor/compositor.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForCompositorWithIdToQuit = exports.releaseCompositorWithId = exports.spawnCompositorOrReuse = void 0;
+const child_process_1 = require("child_process");
+const truthy_1 = require("../truthy");
+const get_executable_path_1 = require("./get-executable-path");
+const compositorMap = {};
+const spawnCompositorOrReuse = ({ initiatePayload, renderId, }) => {
+    if (!compositorMap[renderId]) {
+        compositorMap[renderId] = startCompositor(initiatePayload);
+    }
+    return compositorMap[renderId];
+};
+exports.spawnCompositorOrReuse = spawnCompositorOrReuse;
+const releaseCompositorWithId = (renderId) => {
+    if (compositorMap[renderId]) {
+        compositorMap[renderId].finishCommands();
+    }
+};
+exports.releaseCompositorWithId = releaseCompositorWithId;
+const waitForCompositorWithIdToQuit = (renderId) => {
+    if (!compositorMap[renderId]) {
+        throw new TypeError('No compositor with that id');
+    }
+    return compositorMap[renderId].waitForDone();
+};
+exports.waitForCompositorWithIdToQuit = waitForCompositorWithIdToQuit;
+const startCompositor = (compositorInitiatePayload) => {
+    const bin = (0, get_executable_path_1.getExecutablePath)();
+    const child = (0, child_process_1.spawn)(`${bin}`, [JSON.stringify(compositorInitiatePayload)]);
+    const stderrChunks = [];
+    let stdoutListeners = [];
+    let stderrListeners = [];
+    child.stderr.on('data', (d) => {
+        stderrChunks.push(d);
+        const str = d.toString('utf-8');
+        stderrListeners.forEach((s) => s(str));
+    });
+    child.stdout.on('data', (d) => {
+        const str = d.toString('utf-8');
+        stdoutListeners.forEach((s) => s(str));
+    });
+    let nonce = 0;
+    return {
+        waitForDone: () => {
+            return new Promise((resolve, reject) => {
+                child.on('exit', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(Buffer.concat(stderrChunks).toString('utf-8'));
+                    }
+                });
+            });
+        },
+        finishCommands: () => {
+            child.stdin.write('EOF\n');
+        },
+        executeCommand: (payload) => {
+            const actualPayload = {
+                ...payload,
+                nonce,
+            };
+            nonce++;
+            return new Promise((resolve, reject) => {
+                child.stdin.write(JSON.stringify(actualPayload) + '\n');
+                const onStderr = (message) => {
+                    let parsed = null;
+                    try {
+                        const content = JSON.parse(message);
+                        if (content.msg_type === 'error') {
+                            parsed = content;
+                        }
+                    }
+                    catch (error) {
+                        // TODO: Obviously bad, does not handle panics
+                        console.log('Rust debug err:', message);
+                    }
+                    if (parsed) {
+                        const err = new Error(parsed.error);
+                        err.stack = parsed.error + '\n' + parsed.backtrace;
+                        reject(err);
+                        stdoutListeners = stdoutListeners.filter((s) => s !== onStdout);
+                        stderrListeners = stderrListeners.filter((s) => s !== onStderr);
+                    }
+                };
+                const onStdout = (str) => {
+                    const lineSplit = str.split('\n');
+                    for (const line of lineSplit.filter(truthy_1.truthy)) {
+                        let parsed = null;
+                        try {
+                            const p = JSON.parse(line);
+                            if (p.msg_type === 'finish') {
+                                parsed = p;
+                            }
+                        }
+                        catch (e) { }
+                        if (parsed && parsed.nonce === actualPayload.nonce) {
+                            resolve();
+                            stdoutListeners = stdoutListeners.filter((s) => s !== onStdout);
+                            stderrListeners = stderrListeners.filter((s) => s !== onStderr);
+                        }
+                    }
+                };
+                stdoutListeners.push(onStdout);
+                stderrListeners.push(onStderr);
+            });
+        },
+    };
+};

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/compress-assets.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Since audio or video can be base64-encoded, those can be really long strings.
+ * Since we track the `src` property for every frame, Node.JS can run out of memory easily. Instead of duplicating the src for every frame, we save memory by replacing the full base 64 encoded data with a string `same-as-[asset-id]-[frame]` referencing a previous asset with the same src.
+ */
+import type { TAsset } from 'remotion';
+export declare const compressAsset: (previousAssets: TAsset[], newAsset: TAsset) => TAsset;
+export declare const isAssetCompressed: (src: string) => boolean;

package/dist/compress-assets.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Since audio or video can be base64-encoded, those can be really long strings.
+ * Since we track the `src` property for every frame, Node.JS can run out of memory easily. Instead of duplicating the src for every frame, we save memory by replacing the full base 64 encoded data with a string `same-as-[asset-id]-[frame]` referencing a previous asset with the same src.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssetCompressed = exports.compressAsset = void 0;
+const compressAsset = (previousAssets, newAsset) => {
+    if (newAsset.src.length < 400) {
+        return newAsset;
+    }
+    const assetWithSameSrc = previousAssets.find((a) => a.src === newAsset.src);
+    if (!assetWithSameSrc) {
+        return newAsset;
+    }
+    return {
+        ...newAsset,
+        src: `same-as-${assetWithSameSrc.id}-${assetWithSameSrc.frame}`,
+    };
+};
+exports.compressAsset = compressAsset;
+const isAssetCompressed = (src) => {
+    return src.startsWith('same-as');
+};
+exports.isAssetCompressed = isAssetCompressed;

package/dist/convert-number-of-gif-loops-to-ffmpeg.d.ts

@@ -0,0 +1 @@
+export declare const convertNumberOfGifLoopsToFfmpegSyntax: (loops: number | null) => string;

package/dist/convert-number-of-gif-loops-to-ffmpeg.js

@@ -0,0 +1,17 @@
+"use strict";
+// https://superuser.com/questions/1607099/how-to-control-gif-loop-settings-in-ffmpeg
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertNumberOfGifLoopsToFfmpegSyntax = void 0;
+const convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
+    // Infinite loop
+    if (loops === null) {
+        return '0';
+    }
+    // No loops
+    if (loops === 0) {
+        return '-1';
+    }
+    // N amount of loops
+    return String(loops);
+};
+exports.convertNumberOfGifLoopsToFfmpegSyntax = convertNumberOfGifLoopsToFfmpegSyntax;

package/dist/convert-to-pcm.d.ts

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

package/dist/convert-to-pcm.js

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

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,4 +1,5 @@
-export declare const createFfmpegComplexFilter: (filters: number) => Promise<{
+import type { DownloadMap } from './assets/download-map';
+export declare const createFfmpegComplexFilter: (filters: number, downloadMap: DownloadMap) => Promise<{
     complexFilterFlag: [string, string] | null;
     cleanup: () => void;
 }>;

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

@@ -1,23 +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.createFfmpegComplexFilter = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const create_ffmpeg_merge_filter_1 = require("./create-ffmpeg-merge-filter");
 const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
-const tmp_dir_1 = require("./tmp-dir");
-const createFfmpegComplexFilter = async (filters) => {
+const createFfmpegComplexFilter = async (filters, downloadMap) => {
     if (filters === 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);
-    const tempPath = (0, tmp_dir_1.tmpDir)('remotion-complex-filter-script');
-    const filterFile = path_1.default.join(tempPath, 'complex-filter.txt');
-    await fs_1.default.promises.writeFile(filterFile, complexFilter);
+    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(complexFilter, downloadMap);
     return {
         complexFilterFlag: ['-filter_complex_script', file],
         cleanup,

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

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFfmpegMergeFilter = void 0;
-const remotion_1 = require("remotion");
+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(remotion_1.Internals.truthy)
+        .filter(truthy_1.truthy)
         .join('+');
     const rightChannel = new Array(inputs * 2)
         .fill(true)
         .map((_, i) => (i % 2 === 1 ? `c${i}` : null))
-        .filter(remotion_1.Internals.truthy)
+        .filter(truthy_1.truthy)
         .join('+');
     return `[0:a][1:a]amerge=inputs=${inputs},pan=stereo|c0=${leftChannel}|c1=${rightChannel}[a]`;
 };

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

@@ -1,6 +1,7 @@
-import { FfmpegExecutable } from 'remotion';
-export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, }: {
+import type { FfmpegExecutable } from './ffmpeg-executable';
+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

@@ -0,0 +1,9 @@
+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 validateQualitySettings: ({ codec, crf, videoBitrate, }: {
+    crf: unknown;
+    codec: Codec;
+    videoBitrate: string | null | undefined;
+}) => string[];