@remotion/renderer 4.0.0-alpha4 → 4.0.0-alpha5

package/dist/client.d.ts

@@ -1,97 +1,99 @@
 export declare const BrowserSafeApis: {
-    getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null) => import("./file-extensions").FileExtension;
+    getFileExtensionFromCodec: <T extends "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: "pcm-16" | "aac" | "mp3" | "opus" | null) => import("./file-extensions").FileExtension;
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
-    getDefaultCrfForCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => number;
-    getValidCrfRanges: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
-    isAudioCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
+    validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+    getDefaultCrfForCodec: (codec: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif") => number;
+    getValidCrfRanges: (codec: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
+    isAudioCodec: (codec: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
+    proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
     validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
     supportedAudioCodecs: {
         readonly h264: readonly ["aac", "pcm-16"];
         readonly 'h264-mkv': readonly ["pcm-16"];
         readonly aac: readonly ["aac", "pcm-16"];
-        readonly gif: readonly [];
+        readonly gif: const[];
         readonly h265: readonly ["aac", "pcm-16"];
         readonly mp3: readonly ["mp3", "pcm-16"];
-        readonly prores: readonly ["pcm-16", "aac"];
+        readonly prores: readonly ["aac", "pcm-16"];
         readonly vp8: readonly ["opus", "pcm-16"];
         readonly vp9: readonly ["opus", "pcm-16"];
         readonly wav: readonly ["pcm-16"];
     };
     defaultFileExtensionMap: {
-        h264: {
+        aac: {
             default: import("./file-extensions").FileExtension;
             forAudioCodec: {
-                aac: {
+                "pcm-16": {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
-                "pcm-16": {
+                aac: {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
             };
         };
-        h265: {
+        mp3: {
             default: import("./file-extensions").FileExtension;
             forAudioCodec: {
-                aac: {
+                "pcm-16": {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
-                "pcm-16": {
+                mp3: {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
             };
         };
-        vp8: {
+        h264: {
             default: import("./file-extensions").FileExtension;
             forAudioCodec: {
                 "pcm-16": {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
-                opus: {
+                aac: {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
             };
         };
-        vp9: {
+        h265: {
             default: import("./file-extensions").FileExtension;
             forAudioCodec: {
                 "pcm-16": {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
-                opus: {
+                aac: {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
             };
         };
-        mp3: {
+        vp8: {
             default: import("./file-extensions").FileExtension;
             forAudioCodec: {
-                mp3: {
+                "pcm-16": {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
-                "pcm-16": {
+                opus: {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
             };
         };
-        aac: {
+        vp9: {
             default: import("./file-extensions").FileExtension;
             forAudioCodec: {
-                aac: {
+                "pcm-16": {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
-                "pcm-16": {
+                opus: {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
@@ -109,11 +111,11 @@ export declare const BrowserSafeApis: {
         prores: {
             default: import("./file-extensions").FileExtension;
             forAudioCodec: {
-                aac: {
+                "pcm-16": {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
-                "pcm-16": {
+                aac: {
                     possible: import("./file-extensions").FileExtension[];
                     default: import("./file-extensions").FileExtension;
                 };
@@ -130,17 +132,30 @@ export declare const BrowserSafeApis: {
         };
         gif: {
             default: import("./file-extensions").FileExtension;
-            forAudioCodec: {};
+            forAudioCodec: {
+                [x: string]: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
         };
     };
     defaultAudioCodecs: {
+        aac: {
+            compressed: "pcm-16" | "aac" | null;
+            lossless: "pcm-16" | "aac" | null;
+        };
+        mp3: {
+            compressed: "pcm-16" | "mp3" | null;
+            lossless: "pcm-16" | "mp3" | null;
+        };
         h264: {
-            compressed: "aac" | "pcm-16" | null;
-            lossless: "aac" | "pcm-16" | null;
+            compressed: "pcm-16" | "aac" | null;
+            lossless: "pcm-16" | "aac" | null;
         };
         h265: {
-            compressed: "aac" | "pcm-16" | null;
-            lossless: "aac" | "pcm-16" | null;
+            compressed: "pcm-16" | "aac" | null;
+            lossless: "pcm-16" | "aac" | null;
         };
         vp8: {
             compressed: "pcm-16" | "opus" | null;
@@ -150,30 +165,40 @@ export declare const BrowserSafeApis: {
             compressed: "pcm-16" | "opus" | null;
             lossless: "pcm-16" | "opus" | null;
         };
-        mp3: {
-            compressed: "mp3" | "pcm-16" | null;
-            lossless: "mp3" | "pcm-16" | null;
-        };
-        aac: {
-            compressed: "aac" | "pcm-16" | null;
-            lossless: "aac" | "pcm-16" | null;
-        };
         wav: {
             compressed: "pcm-16" | null;
             lossless: "pcm-16" | null;
         };
         prores: {
-            compressed: "aac" | "pcm-16" | null;
-            lossless: "aac" | "pcm-16" | null;
+            compressed: "pcm-16" | "aac" | null;
+            lossless: "pcm-16" | "aac" | null;
         };
         "h264-mkv": {
             compressed: "pcm-16" | null;
             lossless: "pcm-16" | null;
         };
         gif: {
-            compressed: null;
-            lossless: null;
+            compressed: any;
+            lossless: any;
         };
     };
-    defaultCodecsForFileExtension: Record<import("./file-extensions").FileExtension, "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">;
+    defaultCodecsForFileExtension: Record<import("./file-extensions").FileExtension, "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif">;
+    validateOutputFilename: <T_1 extends "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif">({ codec, audioCodec, extension, preferLossless, }: {
+        codec: T_1;
+        audioCodec: "pcm-16" | "aac" | "mp3" | "opus" | null;
+        extension: string;
+        preferLossless: boolean;
+    }) => void;
+    options: {
+        scaleOption: import(".").RemotionOption;
+        crfOption: import(".").RemotionOption;
+        jpegQualityOption: import(".").RemotionOption;
+        videoBitrate: import(".").RemotionOption;
+        audioBitrateOption: import(".").RemotionOption;
+        enforceAudioOption: import(".").RemotionOption;
+        muteOption: import(".").RemotionOption;
+        videoCodecOption: import(".").RemotionOption;
+    };
+    codecSupportsCrf: (codec: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
+    codecSupportsVideoBitrate: (codec: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
 };

package/dist/client.js

@@ -3,21 +3,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BrowserSafeApis = void 0;
 const audio_codec_1 = require("./audio-codec");
 const codec_1 = require("./codec");
+const codec_supports_media_1 = require("./codec-supports-media");
 const crf_1 = require("./crf");
 const file_extensions_1 = require("./file-extensions");
 const get_extension_from_codec_1 = require("./get-extension-from-codec");
 const is_audio_codec_1 = require("./is-audio-codec");
+const audio_bitrate_1 = require("./options/audio-bitrate");
+const crf_2 = require("./options/crf");
+const enforce_audio_1 = require("./options/enforce-audio");
+const jpeg_quality_1 = require("./options/jpeg-quality");
+const mute_1 = require("./options/mute");
+const scale_1 = require("./options/scale");
+const video_bitrate_1 = require("./options/video-bitrate");
+const video_codec_1 = require("./options/video-codec");
 const pixel_format_1 = require("./pixel-format");
+const prores_profile_1 = require("./prores-profile");
+const validate_output_filename_1 = require("./validate-output-filename");
 exports.BrowserSafeApis = {
     getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
     validCodecs: codec_1.validCodecs,
+    validAudioCodecs: audio_codec_1.validAudioCodecs,
     getDefaultCrfForCodec: crf_1.getDefaultCrfForCodec,
     getValidCrfRanges: crf_1.getValidCrfRanges,
     isAudioCodec: is_audio_codec_1.isAudioCodec,
+    proResProfileOptions: prores_profile_1.proResProfileOptions,
     validPixelFormats: pixel_format_1.validPixelFormats,
     DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
-    supportedAudioCodecs: file_extensions_1.supportedAudioCodecs,
+    supportedAudioCodecs: audio_codec_1.supportedAudioCodecs,
     defaultFileExtensionMap: file_extensions_1.defaultFileExtensionMap,
     defaultAudioCodecs: audio_codec_1.defaultAudioCodecs,
     defaultCodecsForFileExtension: get_extension_from_codec_1.defaultCodecsForFileExtension,
+    validateOutputFilename: validate_output_filename_1.validateOutputFilename,
+    options: {
+        scaleOption: scale_1.scaleOption,
+        crfOption: crf_2.crfOption,
+        jpegQualityOption: jpeg_quality_1.jpegQualityOption,
+        videoBitrate: video_bitrate_1.videoBitrate,
+        audioBitrateOption: audio_bitrate_1.audioBitrateOption,
+        enforceAudioOption: enforce_audio_1.enforceAudioOption,
+        muteOption: mute_1.muteOption,
+        videoCodecOption: video_codec_1.videoCodecOption,
+    },
+    codecSupportsCrf: codec_supports_media_1.codecSupportsCrf,
+    codecSupportsVideoBitrate: codec_supports_media_1.codecSupportsVideoBitrate,
 };

package/dist/codec-supports-media.d.ts

@@ -4,5 +4,6 @@ declare type MediaSupport = {
     audio: boolean;
 };
 export declare const codecSupportsMedia: (codec: Codec) => MediaSupport;
-export declare const codecSupportsCrf: (codec: Codec) => boolean | "" | null;
+export declare const codecSupportsCrf: (codec: Codec) => boolean;
+export declare const codecSupportsVideoBitrate: (codec: Codec) => boolean;
 export {};

package/dist/codec-supports-media.js

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

package/dist/combine-videos.d.ts

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

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 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 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, 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, 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,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compose = void 0;
+exports.callCompositor = exports.compose = exports.serializeCommand = void 0;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
 const promises_1 = require("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');
 };
+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 child = (0, child_process_1.spawn)((0, get_executable_path_1.getExecutablePath)('compositor'), [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 +50,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 {};