@remotion/renderer 4.0.0-alpha4 → 4.0.0-alpha5

package/dist/compositor/compositor.js

@@ -0,0 +1,202 @@
+"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 child_process_1 = require("child_process");
+const os_1 = __importDefault(require("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 = 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');
+    const fullCommand = (0, compose_1.serializeCommand)(type, payload);
+    const child = (0, 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') {

package/dist/delete-directory.js

@@ -22,37 +22,37 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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 = __importStar(require("fs"));
 const is_serve_url_1 = require("./is-serve-url");
 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.
-        execa_1.default.sync('cmd', ['/c', 'del', '/f', '/s', '/q', directory]);
+    // Working around a bug with NodeJS 16 on Windows:
+    // If a subdirectory is already deleted, it will fail with EPERM
+    // even with force: true and recursive and maxRetries set higher.
+    // This is even with the fixWinEPERMSync function being called by Node.JS.
+    // This is a workaround for this issue.
+    let retries = 2;
+    while (retries >= 0) {
         try {
-            execa_1.default.sync('cmd', ['/c', 'rmdir', '/s', '/q', directory]);
+            fs_1.default.rmSync(directory, {
+                maxRetries: 2,
+                recursive: true,
+                force: true,
+                retryDelay: 100,
+            });
         }
         catch (err) {
-            // Is not a directory
+            retries--;
+            continue;
         }
-    }
-    else {
-        ((_a = fs_1.default.rmSync) !== null && _a !== void 0 ? _a : fs_1.default.rmdirSync)(directory, {
-            recursive: true,
-        });
+        break;
     }
 };
 exports.deleteDirectory = deleteDirectory;

package/dist/file-extensions.d.ts

@@ -1,16 +1,5 @@
+import type { supportedAudioCodecs } from './audio-codec';
 import type { Codec } from './codec';
-export declare const supportedAudioCodecs: {
-    readonly h264: readonly ["aac", "pcm-16"];
-    readonly 'h264-mkv': readonly ["pcm-16"];
-    readonly aac: readonly ["aac", "pcm-16"];
-    readonly gif: readonly [];
-    readonly h265: readonly ["aac", "pcm-16"];
-    readonly mp3: readonly ["mp3", "pcm-16"];
-    readonly prores: readonly ["pcm-16", "aac"];
-    readonly vp8: readonly ["opus", "pcm-16"];
-    readonly vp9: readonly ["opus", "pcm-16"];
-    readonly wav: readonly ["pcm-16"];
-};
 export declare type FileExtension = 'aac' | '3gp' | 'm4a' | 'm4b' | 'mpg' | 'mpeg' | 'mkv' | 'mp4' | 'gif' | 'hevc' | 'mp3' | 'mov' | 'mxf' | 'wav' | 'webm';
 export declare const defaultFileExtensionMap: {
     [key in Codec]: {

package/dist/file-extensions.js

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

package/dist/get-compositions.d.ts

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

package/dist/get-compositions.js

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

package/dist/get-extension-from-codec.d.ts

@@ -1,6 +1,6 @@
 import type { AudioCodec } from './audio-codec';
 import type { Codec } from './codec';
 import type { FileExtension } from './file-extensions';
-export declare const getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: AudioCodec | null) => FileExtension;
-export declare const makeFileExtensionMap: () => Record<string, ("h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
+export declare const getFileExtensionFromCodec: <T extends "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: AudioCodec | null) => FileExtension;
+export declare const makeFileExtensionMap: () => Record<string, ("aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
 export declare const defaultCodecsForFileExtension: Record<FileExtension, Codec>;