@remotion/renderer 4.0.0-webhook.26 → 4.1.0-alpha1

package/dist/client.d.ts

@@ -0,0 +1,204 @@
+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;
+    validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
+    validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+    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;
+    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: const[];
+        readonly h265: readonly ["aac", "pcm-16"];
+        readonly mp3: readonly ["mp3", "pcm-16"];
+        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: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        h265: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp8: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp9: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        mp3: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                mp3: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        aac: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        wav: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        prores: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        "h264-mkv": {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        gif: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                [x: string]: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+    };
+    defaultAudioCodecs: {
+        h264: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        h265: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        vp8: {
+            compressed: "pcm-16" | "opus" | null;
+            lossless: "pcm-16" | "opus" | null;
+        };
+        vp9: {
+            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;
+        };
+        "h264-mkv": {
+            compressed: "pcm-16" | null;
+            lossless: "pcm-16" | null;
+        };
+        gif: {
+            compressed: any;
+            lossless: any;
+        };
+    };
+    defaultCodecsForFileExtension: Record<import("./file-extensions").FileExtension, "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">;
+    validateOutputFilename: <T_1 extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">({ codec, audioCodec, extension, preferLossless, }: {
+        codec: T_1;
+        audioCodec: "mp3" | "aac" | "pcm-16" | "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: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
+    codecSupportsVideoBitrate: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
+};

package/dist/client.js

@@ -0,0 +1,49 @@
+"use strict";
+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: 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

@@ -1,8 +1,9 @@
 import type { Codec } from './codec';
-declare type MediaSupport = {
+type MediaSupport = {
     video: boolean;
     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/codec.d.ts

@@ -1,4 +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 type Codec = typeof validCodecs[number];
+export type CodecOrUndefined = Codec | undefined;
 export declare const DEFAULT_CODEC: Codec;

package/dist/combine-videos.d.ts

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

package/dist/combine-videos.js

@@ -1,24 +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 get_audio_codec_name_1 = require("./get-audio-codec-name");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const audio_codec_1 = require("./audio-codec");
+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 ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, }) => {
+const combineVideos = async (options) => {
     var _a;
+    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)('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',
@@ -35,20 +34,21 @@ const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfF
                     : '-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),
+            resolvedAudioCodec ? '-c:a' : null,
+            resolvedAudioCodec
+                ? (0, audio_codec_1.mapAudioCodecToFfmpegAudioCodecName)(resolvedAudioCodec)
+                : null,
             // 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(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());
+                const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(data.toString('utf8'));
                 if (parsed !== undefined) {
                     onProgress(parsed);
                 }
@@ -56,10 +56,10 @@ const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfF
         });
         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

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

package/dist/compositor/compose.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callCompositor = exports.compose = exports.composeWithoutCache = 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, 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 composeWithoutCache = async ({ height, width, layers, output, imageFormat, compositor, }) => {
+    await compositor.executeCommand('Compose', {
+        height,
+        width,
+        layers,
+        output,
+        output_format: imageFormat,
+    });
+};
+exports.composeWithoutCache = composeWithoutCache;
+const compose = async ({ height, width, layers, output, downloadMap, imageFormat, compositor, }) => {
+    const hash = getCompositorHash({ height, width, layers, imageFormat });
+    if (downloadMap.compositorCache[hash]) {
+        await (0, promises_1.copyFile)(downloadMap.compositorCache[hash], output);
+        return;
+    }
+    await (0, exports.composeWithoutCache)({
+        compositor,
+        height,
+        imageFormat,
+        layers,
+        output,
+        width,
+    });
+    downloadMap.compositorCache[hash] = output;
+};
+exports.compose = compose;
+const callCompositor = (payload) => {
+    return new Promise((resolve, reject) => {
+        const execPath = (0, get_executable_path_1.getExecutablePath)('compositor');
+        if (!process.env.READ_ONLY_FS) {
+            (0, node_fs_1.chmodSync)(execPath, 0o755);
+        }
+        const child = (0, node_child_process_1.spawn)(execPath, [payload], (0, call_ffmpeg_1.dynamicLibraryPathOptions)());
+        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');
+                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}`));
+                }
+            }
+        });
+        child.stdin.write(payload);
+        child.stdin.end();
+    });
+};
+exports.callCompositor = callCompositor;

package/dist/compositor/compositor.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type { CompositorCommand } from './payloads';
+export 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, indent: boolean) => Compositor;
+export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T], indent: boolean) => Compositor;