@remotion/renderer 4.0.21 → 4.0.23

package/.prettierignore

@@ -0,0 +1,2 @@
+# Has error in CI even though is formatted
+src/compositor/compositor.ts

package/dist/assets/get-video-stream-duration.d.ts

@@ -0,0 +1,9 @@
+import type { FfmpegExecutable } from '../ffmpeg-executable';
+import type { DownloadMap, VideoDurationResult } from './download-map';
+export declare const parseVideoStreamDuration: (stdout: string) => VideoDurationResult;
+export declare function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<VideoDurationResult>;
+export declare const getVideoStreamDuration: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<VideoDurationResult>;

package/dist/assets/get-video-stream-duration.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoStreamDuration = exports.getVideoStreamDurationwithoutCache = exports.parseVideoStreamDuration = void 0;
+const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("../ffmpeg-flags");
+const p_limit_1 = require("../p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+const parseAlternativeDuration = (stdout) => {
+    const webmDuration = stdout.match(/TAG:DURATION=([0-9.]+):([0-9.]+):([0-9.]+)/);
+    if (!webmDuration) {
+        return null;
+    }
+    const [, hours, minutes, seconds] = webmDuration;
+    const hoursAsNumber = Number(hours);
+    if (Number.isNaN(hoursAsNumber)) {
+        return null;
+    }
+    const minutesAsNumber = Number(minutes);
+    if (Number.isNaN(minutesAsNumber)) {
+        return null;
+    }
+    const secondsAsNumber = Number(seconds);
+    if (Number.isNaN(secondsAsNumber)) {
+        return null;
+    }
+    return secondsAsNumber + minutesAsNumber * 60 + hoursAsNumber * 3600;
+};
+const parseVideoStreamDuration = (stdout) => {
+    const duration = stdout.match(/duration=([0-9.]+)/);
+    const alternativeDuration = parseAlternativeDuration(stdout);
+    const fps = stdout.match(/r_frame_rate=([0-9.]+)\/([0-9.]+)/);
+    const result = {
+        duration: duration ? parseFloat(duration[1]) : alternativeDuration,
+        fps: fps ? parseInt(fps[1], 10) / parseInt(fps[2], 10) : null,
+    };
+    return result;
+};
+exports.parseVideoStreamDuration = parseVideoStreamDuration;
+async function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }) {
+    const args = [
+        ['-v', 'error'],
+        ['-select_streams', 'v:0'],
+        ['-show_entries', 'stream'],
+        [src],
+    ]
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter(Boolean);
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), args);
+    const result = (0, exports.parseVideoStreamDuration)(task.stdout);
+    return result;
+}
+exports.getVideoStreamDurationwithoutCache = getVideoStreamDurationwithoutCache;
+async function getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (downloadMap.videoDurationResultCache[src]) {
+        return downloadMap.videoDurationResultCache[src];
+    }
+    const result = await getVideoStreamDurationwithoutCache({
+        src,
+        ffprobeExecutable,
+        remotionRoot,
+    });
+    downloadMap.videoDurationResultCache[src] = result;
+    return result;
+}
+const getVideoStreamDuration = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
+};
+exports.getVideoStreamDuration = getVideoStreamDuration;

package/dist/audio-codec.d.ts

@@ -1,6 +1,6 @@
 import type { Codec } from './codec';
 export declare const validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
-export type AudioCodec = typeof validAudioCodecs[number];
+export type AudioCodec = (typeof validAudioCodecs)[number];
 export declare const supportedAudioCodecs: {
     readonly h264: readonly ["aac", "pcm-16", "mp3"];
     readonly 'h264-mkv': readonly ["pcm-16", "mp3"];
@@ -14,11 +14,11 @@ export declare const supportedAudioCodecs: {
     readonly wav: readonly ["pcm-16"];
 };
 declare const audioCodecNames: readonly ["pcm_s16le", "aac", "libmp3lame", "libopus"];
-type FfmpegAudioCodecName = typeof audioCodecNames[number];
+type FfmpegAudioCodecName = (typeof audioCodecNames)[number];
 export declare const mapAudioCodecToFfmpegAudioCodecName: (audioCodec: AudioCodec) => FfmpegAudioCodecName;
 export declare const defaultAudioCodecs: {
     [key in Codec]: {
-        [k in 'compressed' | 'lossless']: typeof supportedAudioCodecs[key][number] | null;
+        [k in 'compressed' | 'lossless']: (typeof supportedAudioCodecs)[key][number] | null;
     };
 };
 export declare const getDefaultAudioCodec: ({ codec, preferLossless, }: {

package/dist/browser/Product.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export type Product = 'chrome' | 'firefox';

package/dist/browser/Product.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/browser/create-browser-fetcher.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { Product } from './Product';
+export declare function downloadBrowser(product: Product): Promise<void>;

package/dist/browser/create-browser-fetcher.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadBrowser = void 0;
+const BrowserFetcher_1 = require("./BrowserFetcher");
+const revisions_1 = require("./revisions");
+const supportedProducts = {
+    chrome: 'Chromium',
+    firefox: 'Firefox Nightly',
+};
+function getRevision(product) {
+    if (product === 'chrome') {
+        return revisions_1.PUPPETEER_REVISIONS.chromium;
+    }
+    throw new Error(`Unsupported product ${product}`);
+}
+async function downloadBrowser(product) {
+    const revision = getRevision(product);
+    const revisionInfo = (0, BrowserFetcher_1.getRevisionInfo)(revision, product);
+    await (0, BrowserFetcher_1.download)({
+        revision: revisionInfo.revision,
+        progressCallback: (downloadedBytes, totalBytes) => {
+            console.log('Downloading', supportedProducts[product], toMegabytes(downloadedBytes) + '/' + toMegabytes(totalBytes));
+        },
+        product,
+        platform: (0, BrowserFetcher_1.getPlatform)(product),
+        downloadHost: (0, BrowserFetcher_1.getDownloadHost)(product),
+        downloadsFolder: (0, BrowserFetcher_1.getDownloadsFolder)(product),
+    });
+    const _localRevisions = await (0, BrowserFetcher_1.localRevisions)((0, BrowserFetcher_1.getDownloadsFolder)(product), product, (0, BrowserFetcher_1.getPlatform)(product));
+    console.log(`${supportedProducts[product]} (${revisionInfo.revision}) downloaded to ${revisionInfo.folderPath}`);
+    await Promise.all(_localRevisions
+        .filter((__revision) => {
+        return __revision !== revisionInfo.revision;
+    })
+        .map((__revision) => {
+        return (0, BrowserFetcher_1.removeBrowser)(__revision, (0, BrowserFetcher_1.getFolderPath)(revision, (0, BrowserFetcher_1.getDownloadsFolder)(product), (0, BrowserFetcher_1.getPlatform)(product)));
+    }));
+}
+exports.downloadBrowser = downloadBrowser;
+function toMegabytes(bytes) {
+    const mb = bytes / 1024 / 1024;
+    return `${Math.round(mb * 10) / 10} Mb`;
+}

package/dist/browser/revisions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+type Revisions = Readonly<{
+    readonly chromium: string;
+}>;
+export declare const PUPPETEER_REVISIONS: Revisions;
+export {};

package/dist/browser/revisions.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUPPETEER_REVISIONS = void 0;
+exports.PUPPETEER_REVISIONS = {
+    chromium: '1002410',
+};

package/dist/calculate-sar-dar-pixels.d.ts

@@ -0,0 +1,9 @@
+export declare const calculateDisplayVideoSize: ({ darX, darY, x, y, }: {
+    x: number;
+    y: number;
+    darX: number;
+    darY: number;
+}) => {
+    width: number;
+    height: number;
+};

package/dist/calculate-sar-dar-pixels.js

@@ -0,0 +1,19 @@
+"use strict";
+// https://superuser.com/questions/907933/correct-aspect-ratio-without-re-encoding-video-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDisplayVideoSize = void 0;
+const calculateDisplayVideoSize = ({ darX, darY, x, y, }) => {
+    // We know two equations:
+    //   newWidth / newHeight = darX / darY
+    // and:
+    //   x * y = (newWidth * newHeight)
+    // I solved it then on pen and paper and simplified the formula:
+    const dimensions = x * y;
+    const newWidth = Math.sqrt(dimensions * (darX / darY));
+    const newHeight = dimensions / newWidth;
+    return {
+        height: Math.round(newHeight),
+        width: Math.round(newWidth),
+    };
+};
+exports.calculateDisplayVideoSize = calculateDisplayVideoSize;

package/dist/client.d.ts

@@ -6,6 +6,7 @@ export declare const BrowserSafeApis: {
     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"];
+    x264PresetOptions: readonly ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo"];
     validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
     supportedAudioCodecs: {
@@ -193,14 +194,160 @@ export declare const BrowserSafeApis: {
         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;
+        scaleOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: number;
+        };
+        crfOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: number;
+        };
+        jpegQualityOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: number;
+        };
+        videoBitrate: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: string;
+        };
+        audioBitrateOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: string;
+        };
+        enforceAudioOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: boolean;
+        };
+        muteOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: boolean;
+        };
+        videoCodecOption: {
+            name: string;
+            cliFlag: string;
+            description: JSX.Element;
+            ssrName: string;
+            docLink: string;
+            type: string;
+        };
+        offthreadVideoCacheSizeInBytesOption: {
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        };
+    };
+    optionsMap: {
+        readonly renderMedia: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderStill: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly getCompositions: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly selectComposition: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderFrames: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderMediaOnLambda: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderStillOnLambda: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly getCompositionsOnLambda: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderMediaOnCloudRun: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
+        readonly renderStillOnCloudRun: readonly [{
+            name: string;
+            cliFlag: "offthreadvideo-cache-size-in-bytes";
+            description: JSX.Element;
+            ssrName: "offthreadVideoCacheSizeInBytes";
+            docLink: string;
+            type: number | null;
+        }];
     };
     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

@@ -13,12 +13,15 @@ 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 offthreadvideo_cache_size_1 = require("./options/offthreadvideo-cache-size");
+const options_map_1 = require("./options/options-map");
 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");
+const x264_preset_1 = require("./x264-preset");
 exports.BrowserSafeApis = {
     getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
     validCodecs: codec_1.validCodecs,
@@ -27,6 +30,7 @@ exports.BrowserSafeApis = {
     getValidCrfRanges: crf_1.getValidCrfRanges,
     isAudioCodec: is_audio_codec_1.isAudioCodec,
     proResProfileOptions: prores_profile_1.proResProfileOptions,
+    x264PresetOptions: x264_preset_1.x264PresetOptions,
     validPixelFormats: pixel_format_1.validPixelFormats,
     DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
     supportedAudioCodecs: audio_codec_1.supportedAudioCodecs,
@@ -43,7 +47,9 @@ exports.BrowserSafeApis = {
         enforceAudioOption: enforce_audio_1.enforceAudioOption,
         muteOption: mute_1.muteOption,
         videoCodecOption: video_codec_1.videoCodecOption,
+        offthreadVideoCacheSizeInBytesOption: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
     },
+    optionsMap: options_map_1.optionsMap,
     codecSupportsCrf: codec_supports_media_1.codecSupportsCrf,
     codecSupportsVideoBitrate: codec_supports_media_1.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 type Codec = typeof validCodecs[number];
+export type Codec = (typeof validCodecs)[number];
 export type CodecOrUndefined = Codec | undefined;
 export declare const DEFAULT_CODEC: Codec;

package/dist/compositor/compositor.d.ts

@@ -7,6 +7,6 @@ export type Compositor = {
     waitForDone: () => Promise<void>;
     pid: number | null;
 };
-export declare const getIdealMaximumFrameCacheItems: () => number;
-export declare const startLongRunningCompositor: (maximumFrameCacheItems: number, logLevel: LogLevel, indent: boolean) => Compositor;
+export declare const getIdealMaximumFrameCacheSizeInBytes: () => number;
+export declare const startLongRunningCompositor: (maximumFrameCacheItemsInBytes: number, logLevel: LogLevel, indent: boolean) => Compositor;
 export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T], logLevel: LogLevel, indent: boolean) => Compositor;

package/dist/compositor/compositor.js

@@ -3,7 +3,7 @@ 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;
+exports.startCompositor = exports.startLongRunningCompositor = exports.getIdealMaximumFrameCacheSizeInBytes = void 0;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_os_1 = __importDefault(require("node:os"));
@@ -14,21 +14,20 @@ const logger_1 = require("../logger");
 const compose_1 = require("./compose");
 const get_executable_path_1 = require("./get-executable-path");
 const make_nonce_1 = require("./make-nonce");
-const getIdealMaximumFrameCacheItems = () => {
+const getIdealMaximumFrameCacheSizeInBytes = () => {
     const freeMemory = node_os_1.default.freemem();
-    // Assuming 1 frame is approximately 24MB
-    // (4K video)
     // Assuming only half the available memory should be used
-    const max = Math.floor(freeMemory / (1024 * 1024 * 24));
-    // Never store more than 2000 frames
-    // But 60 is needed even if it's going to swap
-    return Math.max(60, Math.min(max, 2000));
+    const max = freeMemory / 2;
+    // Never store more than 2000 MB
+    // But 240MB is needed even if it's going to swap
+    return Math.max(mbToBytes(240), Math.min(max, mbToBytes(2000)));
 };
-exports.getIdealMaximumFrameCacheItems = getIdealMaximumFrameCacheItems;
-const startLongRunningCompositor = (maximumFrameCacheItems, logLevel, indent) => {
+exports.getIdealMaximumFrameCacheSizeInBytes = getIdealMaximumFrameCacheSizeInBytes;
+const mbToBytes = (mb) => mb * 1024 * 1024;
+const startLongRunningCompositor = (maximumFrameCacheItemsInBytes, logLevel, indent) => {
     return (0, exports.startCompositor)('StartLongRunningProcess', {
         concurrency: (0, get_concurrency_1.getActualConcurrency)(null),
-        maximum_frame_cache_items: maximumFrameCacheItems,
+        maximum_frame_cache_size_in_bytes: maximumFrameCacheItemsInBytes,
         verbose: (0, log_level_1.isEqualOrBelowLogLevel)(logLevel, 'verbose'),
     }, logLevel, indent);
 };
@@ -149,17 +148,17 @@ const startCompositor = (type, payload, logLevel, indent) => {
     child.on('close', (code, signal) => {
         const waitersToKill = Array.from(waiters.values());
         if (code === 0) {
-            runningStatus = { type: 'quit-without-error' };
+            runningStatus = { type: 'quit-without-error', signal };
             resolve === null || resolve === void 0 ? void 0 : resolve();
             for (const waiter of waitersToKill) {
-                waiter.reject(new Error(`Compositor already quit`));
+                waiter.reject(new Error(`Compositor quit${signal ? ` with signal ${signal}` : ''}`));
             }
             waiters.clear();
         }
         else {
             const errorMessage = Buffer.concat(stderrChunks).toString('utf-8') +
                 outputBuffer.toString('utf-8');
-            runningStatus = { type: 'quit-with-error', error: errorMessage };
+            runningStatus = { type: 'quit-with-error', error: errorMessage, signal };
             const error = code === null
                 ? new Error(`Compositor exited with signal ${signal}`)
                 : new Error(`Compositor panicked with code ${code}: ${errorMessage}`);
@@ -174,11 +173,15 @@ const startCompositor = (type, payload, logLevel, indent) => {
         waitForDone: () => {
             return new Promise((res, rej) => {
                 if (runningStatus.type === 'quit-without-error') {
-                    rej(new Error('Compositor already quit'));
+                    rej(new Error(`Compositor quit${runningStatus.signal
+                        ? ` with signal ${runningStatus.signal}`
+                        : ''}`));
                     return;
                 }
                 if (runningStatus.type === 'quit-with-error') {
-                    rej(new Error(`Compositor already quit: ${runningStatus.error}`));
+                    rej(new Error(`Compositor quit${runningStatus.signal
+                        ? ` with signal ${runningStatus.signal}`
+                        : ''}: ${runningStatus.error}`));
                     return;
                 }
                 resolve = res;
@@ -187,16 +190,16 @@ const startCompositor = (type, payload, logLevel, indent) => {
         },
         finishCommands: () => {
             if (runningStatus.type === 'quit-with-error') {
-                throw new Error(`Compositor already quit: ${runningStatus.error}`);
+                throw new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}: ${runningStatus.error}`);
             }
             if (runningStatus.type === 'quit-without-error') {
-                throw new Error('Compositor already quit');
+                throw new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}`);
             }
             child.stdin.write('EOF\n');
         },
         executeCommand: (command, params) => {
             if (runningStatus.type === 'quit-without-error') {
-                throw new Error('Compositor already quit');
+                throw new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}`);
             }
             if (runningStatus.type === 'quit-with-error') {
                 throw new Error(`Compositor quit: ${runningStatus.error}`);

package/dist/compositor/payloads.d.ts

@@ -72,7 +72,7 @@ export type CompositorCommand = {
     };
     StartLongRunningProcess: {
         concurrency: number;
-        maximum_frame_cache_items: number;
+        maximum_frame_cache_size_in_bytes: number;
         verbose: boolean;
     };
     CopyImageToClipboard: {
@@ -82,7 +82,7 @@ export type CompositorCommand = {
     DeliberatePanic: {};
     CloseAllVideos: {};
     FreeUpMemory: {
-        percent_of_memory: number;
+        remaining_bytes: number;
     };
     GetVideoMetadata: {
         src: string;

package/dist/copy-to-clipboard.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.copyImageToClipboard = void 0;
 const compositor_1 = require("./compositor/compositor");
 const copyImageToClipboard = async (src, logLevel) => {
-    const compositor = (0, compositor_1.startLongRunningCompositor)((0, compositor_1.getIdealMaximumFrameCacheItems)(), logLevel, false);
+    const compositor = (0, compositor_1.startLongRunningCompositor)((0, compositor_1.getIdealMaximumFrameCacheSizeInBytes)(), logLevel, false);
     await compositor.executeCommand('CopyImageToClipboard', {
         src,
     });