@remotion/renderer 4.0.22 → 4.0.23

package/dist/get-can-extract-frames-fast.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.getCanExtractFramesFast = exports.ACCEPTABLE_OFFSET_THRESHOLD = void 0;
+const fs_1 = __importDefault(require("fs"));
+const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
+const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
+const find_closest_package_json_1 = require("./find-closest-package-json");
+const get_video_info_1 = require("./get-video-info");
+const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-video-fast");
+exports.ACCEPTABLE_OFFSET_THRESHOLD = 50;
+/**
+ * @description Probes whether frames of a video can be efficiently extracted when using <OffthreadVideo>.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-can-extract-frames-fast)
+ */
+const getCanExtractFramesFast = async ({ src, ffmpegExecutable, ffprobeExecutable, }) => {
+    const remotionRoot = (0, find_closest_package_json_1.findRemotionRoot)();
+    const out = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+        src,
+    });
+    const { specialVcodecForTransparency: specialVcodec } = await (0, get_video_info_1.getVideoInfoUncached)({
+        src: out,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+    });
+    if (specialVcodec === 'vp8') {
+        fs_1.default.unlinkSync(out);
+        return {
+            canExtractFramesFast: false,
+            shouldReencode: false,
+        };
+    }
+    const { duration } = await (0, get_video_stream_duration_1.getVideoStreamDurationwithoutCache)({
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+        src: out,
+    });
+    if (duration === null) {
+        fs_1.default.unlinkSync(out);
+        throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
+    }
+    const actualOffset = `${duration * 1000 - exports.ACCEPTABLE_OFFSET_THRESHOLD}ms`;
+    const [stdErr] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
+        actualOffset,
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
+        imageFormat: 'jpeg',
+        // Intentionally leaving needsResize as null, because we don't need to resize
+        needsResize: null,
+        remotionRoot,
+        specialVCodecForTransparency: specialVcodec,
+        src: out,
+    });
+    fs_1.default.unlinkSync(out);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        return {
+            canExtractFramesFast: false,
+            shouldReencode: true,
+        };
+    }
+    return {
+        canExtractFramesFast: true,
+        shouldReencode: false,
+    };
+};
+exports.getCanExtractFramesFast = getCanExtractFramesFast;

package/dist/get-compositions.d.ts

@@ -4,6 +4,8 @@ import type { BrowserLog } from './browser-log';
 import type { HeadlessBrowser } from './browser/Browser';
 import { type LogLevel } from './log-level';
 import type { ChromiumOptions } from './open-browser';
+import type { ToOptions } from './options/option';
+import type { optionsMap } from './options/options-map';
 import type { RemotionServer } from './prepare-server';
 type InternalGetCompositionsOptions = {
     serializedInputPropsWithCustomSchema: string;
@@ -18,7 +20,7 @@ type InternalGetCompositionsOptions = {
     indent: boolean;
     logLevel: LogLevel;
     serveUrlOrWebpackUrl: string;
-};
+} & ToOptions<typeof optionsMap.getCompositions>;
 export type GetCompositionsOptions = {
     inputProps?: Record<string, unknown> | null;
     envVariables?: Record<string, string>;
@@ -29,8 +31,9 @@ export type GetCompositionsOptions = {
     chromiumOptions?: ChromiumOptions;
     port?: number | null;
     logLevel?: LogLevel;
+    offthreadVideoCacheSizeInBytes?: number | null;
 };
-export declare const internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, serializedInputPropsWithCustomSchema, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, }: InternalGetCompositionsOptions) => Promise<VideoConfig[]>;
+export declare const internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, serializedInputPropsWithCustomSchema, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, offthreadVideoCacheSizeInBytes, }: InternalGetCompositionsOptions) => Promise<VideoConfig[]>;
 /**
  * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)

package/dist/get-compositions.js

@@ -70,7 +70,7 @@ const innerGetCompositions = async ({ envVariables, serializedInputPropsWithCust
         };
     });
 };
-const internalGetCompositions = async ({ browserExecutable, chromiumOptions, envVariables, indent, serializedInputPropsWithCustomSchema, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, }) => {
+const internalGetCompositions = async ({ browserExecutable, chromiumOptions, envVariables, indent, serializedInputPropsWithCustomSchema, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, offthreadVideoCacheSizeInBytes, }) => {
     const { page, cleanup: cleanupPage } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
         passedInInstance: puppeteerInstance,
         browserExecutable,
@@ -95,6 +95,7 @@ const internalGetCompositions = async ({ browserExecutable, chromiumOptions, env
             concurrency: 1,
             logLevel,
             indent,
+            offthreadVideoCacheSizeInBytes,
         }, {
             onDownload: () => undefined,
             onError,
@@ -133,6 +134,7 @@ exports.internalGetCompositions = internalGetCompositions;
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
  */
 const getCompositions = (serveUrlOrWebpackUrl, config) => {
+    var _a;
     const { browserExecutable, chromiumOptions, envVariables, inputProps, onBrowserLog, port, puppeteerInstance, timeoutInMilliseconds, logLevel, } = config !== null && config !== void 0 ? config : {};
     return (0, exports.internalGetCompositions)({
         browserExecutable: browserExecutable !== null && browserExecutable !== void 0 ? browserExecutable : null,
@@ -151,6 +153,7 @@ const getCompositions = (serveUrlOrWebpackUrl, config) => {
         server: undefined,
         timeoutInMilliseconds: timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : TimeoutSettings_1.DEFAULT_TIMEOUT,
         logLevel: logLevel !== null && logLevel !== void 0 ? logLevel : (0, logger_1.getLogLevel)(),
+        offthreadVideoCacheSizeInBytes: (_a = config === null || config === void 0 ? void 0 : config.offthreadVideoCacheSizeInBytes) !== null && _a !== void 0 ? _a : null,
     });
 };
 exports.getCompositions = getCompositions;

package/dist/get-extension-from-codec.js

@@ -15,8 +15,7 @@ const getFileExtensionFromCodec = (codec, audioCodec) => {
     if (!(typedAudioCodec in map.forAudioCodec)) {
         throw new Error(`Audio codec ${typedAudioCodec} is not supported for codec ${codec}`);
     }
-    return map.forAudioCodec[audioCodec]
-        .default;
+    return map.forAudioCodec[audioCodec].default;
 };
 exports.getFileExtensionFromCodec = getFileExtensionFromCodec;
 const makeFileExtensionMap = () => {

package/dist/get-frame-of-video-slow.d.ts

@@ -0,0 +1,17 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const getFrameOfVideoSlow: ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }: {
+    ffmpegExecutable: FfmpegExecutable;
+    src: string;
+    duration: number;
+    imageFormat: OffthreadVideoImageFormat;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    needsResize: [
+        number,
+        number
+    ] | null;
+    offset: number;
+    fps: number | null;
+    remotionRoot: string;
+}) => Promise<Buffer>;

package/dist/get-frame-of-video-slow.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFrameOfVideoSlow = void 0;
+// Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
+// if the video is corrupted
+const execa_1 = __importDefault(require("execa"));
+const determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmpeg_flags_1 = require("./determine-vcodec-ffmpeg-flags");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const truthy_1 = require("./truthy");
+const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }) => {
+    console.warn(`\nUsing a slow method to extract the frame at ${duration}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
+    const actualOffset = `-${duration * 1000 - offset}ms`;
+    const command = [
+        '-itsoffset',
+        actualOffset,
+        ...(0, determine_vcodec_ffmpeg_flags_1.determineVcodecFfmpegFlags)(specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
+        '-',
+    ].filter(truthy_1.truthy);
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), command);
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => stdoutChunks.push(d));
+        stdout.on('error', (err) => reject(err));
+        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
+    });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        if (offset > 70) {
+            throw new Error(`Could not get last frame of ${src}. Tried to seek to the end using the command "ffmpeg ${command.join(' ')}" but got no frame. Most likely this video is corrupted.`);
+        }
+        return (0, exports.getFrameOfVideoSlow)({
+            ffmpegExecutable,
+            duration,
+            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
+            offset: offset + (fps === null ? 10 : 1000 / fps),
+            src,
+            imageFormat,
+            specialVCodecForTransparency,
+            needsResize,
+            fps,
+            remotionRoot,
+        });
+    }
+    return stdoutBuffer;
+};
+exports.getFrameOfVideoSlow = getFrameOfVideoSlow;

package/dist/get-silent-parts.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSilentParts = void 0;
 const compositor_1 = require("./compositor/compositor");
 const getSilentParts = async ({ src, noiseThresholdInDecibels: passedNoiseThresholdInDecibels, minDurationInSeconds: passedMinDuration, logLevel, }) => {
-    const compositor = (0, compositor_1.startLongRunningCompositor)((0, compositor_1.getIdealMaximumFrameCacheItems)(), logLevel !== null && logLevel !== void 0 ? logLevel : 'info', false);
+    const compositor = (0, compositor_1.startLongRunningCompositor)((0, compositor_1.getIdealMaximumFrameCacheSizeInBytes)(), logLevel !== null && logLevel !== void 0 ? logLevel : 'info', false);
     const minDurationInSeconds = passedMinDuration !== null && passedMinDuration !== void 0 ? passedMinDuration : 1;
     if (typeof minDurationInSeconds !== 'number') {
         throw new Error(`minDurationInSeconds must be a number, but was ${minDurationInSeconds}`);

package/dist/get-video-info.d.ts

@@ -0,0 +1,8 @@
+import type { DownloadMap, Vp9Result } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<Vp9Result>;
+export declare const getVideoInfo: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<Vp9Result>;

package/dist/get-video-info.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoInfo = exports.getVideoInfoUncached = void 0;
+const execa_1 = __importDefault(require("execa"));
+const calculate_sar_dar_pixels_1 = require("./calculate-sar-dar-pixels");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const p_limit_1 = require("./p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+async function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }) {
+    var _a;
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), [src]);
+    const isVp9 = task.stderr.includes('Video: vp9');
+    const isVp8 = task.stderr.includes('Video: vp8');
+    const dimensions = (_a = task.stderr
+        .split('\n')
+        .find((n) => n.trim().startsWith('Stream #'))) === null || _a === void 0 ? void 0 : _a.match(/([0-9]{2,6})x([0-9]{2,6})/);
+    const dar = task.stderr.match(/DAR\s([0-9]+):([0-9]+)/);
+    let needsResize = null;
+    if (dimensions && dar) {
+        const width = parseInt(dimensions[1], 10);
+        const height = parseInt(dimensions[2], 10);
+        const darWidth = parseInt(dar[1], 10);
+        const darHeight = parseInt(dar[2], 10);
+        const { width: actualWidth, height: actualHeight } = (0, calculate_sar_dar_pixels_1.calculateDisplayVideoSize)({
+            darX: darWidth,
+            darY: darHeight,
+            x: width,
+            y: height,
+        });
+        if (actualWidth !== width || actualHeight !== height) {
+            needsResize = [actualWidth, actualHeight];
+        }
+    }
+    const result = {
+        specialVcodecForTransparency: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
+        needsResize,
+    };
+    return result;
+}
+exports.getVideoInfoUncached = getVideoInfoUncached;
+async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
+        return downloadMap.isVp9VideoCache[src];
+    }
+    const result = await getVideoInfoUncached({
+        ffprobeExecutable,
+        remotionRoot,
+        src,
+    });
+    downloadMap.isVp9VideoCache[src] = result;
+    return downloadMap.isVp9VideoCache[src];
+}
+const getVideoInfo = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
+};
+exports.getVideoInfo = getVideoInfo;

package/dist/get-video-metadata.js

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

package/dist/image-format.d.ts

@@ -1,8 +1,8 @@
 import type { PixelFormat } from './pixel-format';
 export declare const validVideoImageFormats: readonly ["png", "jpeg", "none"];
 export declare const validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
-export type VideoImageFormat = typeof validVideoImageFormats[number];
-export type StillImageFormat = typeof validStillImageFormats[number];
+export type VideoImageFormat = (typeof validVideoImageFormats)[number];
+export type StillImageFormat = (typeof validStillImageFormats)[number];
 /**
  * @deprecated Use VideoImageFormat or StillImageFormat instead
  */

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import execa from 'execa';
 import { HeadlessBrowser } from './browser/Browser';
 import { SymbolicateableError } from './error-handling/symbolicateable-error';
@@ -24,7 +23,7 @@ export type { LogLevel } from './log-level';
 export { CancelSignal, makeCancelSignal } from './make-cancel-signal';
 export { openBrowser } from './open-browser';
 export type { ChromiumOptions } from './open-browser';
-export { RemotionOption } from './options/option';
+export { AnyRemotionOption, RemotionOption, ToOptions } from './options/option';
 export { PixelFormat } from './pixel-format';
 export { RemotionServer } from './prepare-server';
 export { ProResProfile } from './prores-profile';
@@ -48,6 +47,7 @@ export declare const RenderInternals: {
         concurrency: number;
         logLevel: "verbose" | "info" | "warn" | "error";
         indent: boolean;
+        offthreadVideoCacheSizeInBytes: number | null;
     }) => Promise<{
         port: number;
         close: () => Promise<void>;
@@ -116,8 +116,8 @@ export declare const RenderInternals: {
     validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
     DEFAULT_BROWSER: "chrome";
     validateFrameRange: (frameRange: import("./frame-range").FrameRange | null) => void;
-    DEFAULT_OPENGL_RENDERER: "angle" | "swangle" | "egl" | "swiftshader" | null;
-    validateOpenGlRenderer: (option: "angle" | "swangle" | "egl" | "swiftshader" | null) => "angle" | "swangle" | "egl" | "swiftshader" | null;
+    DEFAULT_OPENGL_RENDERER: "swangle" | "angle" | "egl" | "swiftshader" | null;
+    validateOpenGlRenderer: (option: "swangle" | "angle" | "egl" | "swiftshader" | null) => "swangle" | "angle" | "egl" | "swiftshader" | null;
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
     validateJpegQuality: (q: number | undefined) => void;
@@ -305,8 +305,8 @@ export declare const RenderInternals: {
     };
     validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
     validVideoImageFormats: readonly ["png", "jpeg", "none"];
-    DEFAULT_STILL_IMAGE_FORMAT: "jpeg" | "png" | "webp" | "pdf";
-    DEFAULT_VIDEO_IMAGE_FORMAT: "jpeg" | "png" | "none";
+    DEFAULT_STILL_IMAGE_FORMAT: "png" | "jpeg" | "pdf" | "webp";
+    DEFAULT_VIDEO_IMAGE_FORMAT: "png" | "jpeg" | "none";
     DEFAULT_JPEG_QUALITY: number;
     chalk: {
         enabled: () => boolean;
@@ -389,13 +389,14 @@ export declare const RenderInternals: {
     INDENT_TOKEN: string;
     isColorSupported: () => boolean;
     HeadlessBrowser: typeof HeadlessBrowser;
-    prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, logLevel, indent, }: {
+    prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, logLevel, indent, offthreadVideoCacheSizeInBytes, }: {
         webpackConfigOrServeUrl: string;
         port: number | null;
         remotionRoot: string;
         concurrency: number;
         logLevel: "verbose" | "info" | "warn" | "error";
         indent: boolean;
+        offthreadVideoCacheSizeInBytes: number | null;
     }) => Promise<import("./prepare-server").RemotionServer>;
     makeOrReuseServer: (server: import("./prepare-server").RemotionServer | undefined, config: {
         webpackConfigOrServeUrl: string;
@@ -404,6 +405,7 @@ export declare const RenderInternals: {
         concurrency: number;
         logLevel: "verbose" | "info" | "warn" | "error";
         indent: boolean;
+        offthreadVideoCacheSizeInBytes: number | null;
     }, { onDownload, onError, }: {
         onError: (err: Error) => void;
         onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload | null;
@@ -417,7 +419,7 @@ export declare const RenderInternals: {
         frame: number;
         serializedInputPropsWithCustomSchema: string;
         serializedResolvedPropsWithCustomSchema: string;
-        imageFormat: "jpeg" | "png" | "webp" | "pdf";
+        imageFormat: "png" | "jpeg" | "pdf" | "webp";
         jpegQuality: number;
         puppeteerInstance: HeadlessBrowser | null;
         envVariables: Record<string, string>;
@@ -434,7 +436,15 @@ export declare const RenderInternals: {
         logLevel: "verbose" | "info" | "warn" | "error";
         serveUrl: string;
         port: number | null;
-    }) => Promise<{
+        offthreadVideoCacheSizeInBytes: number | null;
+    } & import("./options/option").ToOptions<readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }]>) => Promise<{
         buffer: Buffer | null;
     }>;
     internalOpenBrowser: ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, viewport, logLevel, }: {
@@ -460,11 +470,18 @@ export declare const RenderInternals: {
         logLevel: "verbose" | "info" | "warn" | "error";
         serveUrl: string;
         id: string;
-    }) => Promise<{
+    } & import("./options/option").ToOptions<readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }]>) => Promise<{
         metadata: import("remotion").VideoConfig;
         propsSize: number;
     }>;
-    internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, serializedInputPropsWithCustomSchema, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, }: {
+    internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, serializedInputPropsWithCustomSchema, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, offthreadVideoCacheSizeInBytes, }: {
         serializedInputPropsWithCustomSchema: string;
         envVariables: Record<string, string>;
         puppeteerInstance: HeadlessBrowser | undefined;
@@ -477,9 +494,16 @@ export declare const RenderInternals: {
         indent: boolean;
         logLevel: "verbose" | "info" | "warn" | "error";
         serveUrlOrWebpackUrl: string;
-    }) => Promise<import("remotion").VideoConfig[]>;
-    internalRenderFrames: ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, envVariables, everyNthFrame, frameRange, imageFormat, indent, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, logLevel, webpackBundleOrServeUrl, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema, }: import("./render-frames").InternalRenderFramesOptions) => Promise<import("./types").RenderFramesOutput>;
-    internalRenderMedia: ({ proResProfile, x264Preset, crf, composition, serializedInputPropsWithCustomSchema, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, concurrency, disallowParallelEncoding, everyNthFrame, imageFormat: provisionalImageFormat, indent, jpegQuality, numberOfGifLoops, onCtrlCExit, preferLossless, serveUrl, server: reusedServer, logLevel, serializedResolvedPropsWithCustomSchema, }: import("./render-media").InternalRenderMediaOptions) => Promise<{
+    } & import("./options/option").ToOptions<readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }]>) => Promise<import("remotion").VideoConfig[]>;
+    internalRenderFrames: ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, envVariables, everyNthFrame, frameRange, imageFormat, indent, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, logLevel, webpackBundleOrServeUrl, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema, offthreadVideoCacheSizeInBytes, }: import("./render-frames").InternalRenderFramesOptions) => Promise<import("./types").RenderFramesOutput>;
+    internalRenderMedia: ({ proResProfile, x264Preset, crf, composition, serializedInputPropsWithCustomSchema, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, concurrency, disallowParallelEncoding, everyNthFrame, imageFormat: provisionalImageFormat, indent, jpegQuality, numberOfGifLoops, onCtrlCExit, preferLossless, serveUrl, server: reusedServer, logLevel, serializedResolvedPropsWithCustomSchema, offthreadVideoCacheSizeInBytes, }: import("./render-media").InternalRenderMediaOptions) => Promise<{
         buffer: Buffer | null;
         slowestFrames: import("./render-media").SlowFrame[];
     }>;

package/dist/is-beyond-last-frame.d.ts

@@ -0,0 +1,3 @@
+import type { DownloadMap } from './assets/download-map';
+export declare const isBeyondLastFrame: (downloadMap: DownloadMap, src: string, time: number) => boolean | 0;
+export declare const markAsBeyondLastFrame: (downloadMap: DownloadMap, src: string, time: number) => void;

package/dist/is-beyond-last-frame.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markAsBeyondLastFrame = exports.isBeyondLastFrame = void 0;
+const isBeyondLastFrame = (downloadMap, src, time) => {
+    return (downloadMap.isBeyondLastFrameMap[src] &&
+        time >= downloadMap.isBeyondLastFrameMap[src]);
+};
+exports.isBeyondLastFrame = isBeyondLastFrame;
+const markAsBeyondLastFrame = (downloadMap, src, time) => {
+    downloadMap.isBeyondLastFrameMap[src] = time;
+};
+exports.markAsBeyondLastFrame = markAsBeyondLastFrame;

package/dist/last-frame-from-video-cache.d.ts

@@ -0,0 +1,17 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { DownloadMap, SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export type LastFrameOptions = {
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+    offset: number;
+    src: string;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    imageFormat: OffthreadVideoImageFormat;
+    needsResize: [number, number] | null;
+    downloadMap: DownloadMap;
+    remotionRoot: string;
+};
+export declare const setLastFrameInCache: (options: LastFrameOptions, data: Buffer) => void;
+export declare const getLastFrameFromCache: (options: LastFrameOptions) => Buffer | null;
+export declare const clearLastFileCache: (downloadMap: DownloadMap) => void;

package/dist/last-frame-from-video-cache.js

@@ -0,0 +1,55 @@
+"use strict";
+// OffthreadVideo requires sometimes that the last frame of a video gets extracted, however, this can be slow. We allocate a cache for it but that can be garbage collected
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearLastFileCache = exports.getLastFrameFromCache = exports.setLastFrameInCache = void 0;
+const MAX_CACHE_SIZE = 50 * 1024 * 1024; // 50MB
+let bufferSize = 0;
+const makeLastFrameCacheKey = (options) => {
+    return [
+        options.ffmpegExecutable,
+        options.offset,
+        options.src,
+        options.imageFormat,
+        options.downloadMap.id,
+    ].join('-');
+};
+const setLastFrameInCache = (options, data) => {
+    const key = makeLastFrameCacheKey(options);
+    if (options.downloadMap.lastFrameMap[key]) {
+        bufferSize -= options.downloadMap.lastFrameMap[key].data.byteLength;
+    }
+    options.downloadMap.lastFrameMap[key] = { data, lastAccessed: Date.now() };
+    bufferSize += data.byteLength;
+    ensureMaxSize(options.downloadMap);
+};
+exports.setLastFrameInCache = setLastFrameInCache;
+const getLastFrameFromCache = (options) => {
+    var _a;
+    const key = makeLastFrameCacheKey(options);
+    if (!options.downloadMap.lastFrameMap[key]) {
+        return null;
+    }
+    options.downloadMap.lastFrameMap[key].lastAccessed = Date.now();
+    return (_a = options.downloadMap.lastFrameMap[key].data) !== null && _a !== void 0 ? _a : null;
+};
+exports.getLastFrameFromCache = getLastFrameFromCache;
+const removedLastFrameFromCache = (key, downloadMap) => {
+    if (!downloadMap.lastFrameMap[key]) {
+        return;
+    }
+    bufferSize -= downloadMap.lastFrameMap[key].data.byteLength;
+    delete downloadMap.lastFrameMap[key];
+};
+const ensureMaxSize = (downloadMap) => {
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (bufferSize > MAX_CACHE_SIZE) {
+        const earliest = Object.entries(downloadMap.lastFrameMap).sort((a, b) => {
+            return a[1].lastAccessed - b[1].lastAccessed;
+        })[0];
+        removedLastFrameFromCache(earliest[0], downloadMap);
+    }
+};
+const clearLastFileCache = (downloadMap) => {
+    downloadMap.lastFrameMap = {};
+};
+exports.clearLastFileCache = clearLastFileCache;

package/dist/legacy-webpack-config.d.ts

@@ -0,0 +1,9 @@
+export type ServeUrlOrWebpackBundle = {
+    serveUrl: string;
+} | {
+    /**
+     * @deprecated Renamed to `serveUrl`
+     */
+    webpackBundle: string;
+};
+export declare const getServeUrlWithFallback: (serve: ServeUrlOrWebpackBundle) => string;

package/dist/legacy-webpack-config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServeUrlWithFallback = void 0;
+const getServeUrlWithFallback = (serve) => {
+    if ('webpackBundle' in serve) {
+        return serve.webpackBundle;
+    }
+    if ('serveUrl' in serve) {
+        return serve.serveUrl;
+    }
+    throw new Error('You must pass the `serveUrl` parameter');
+};
+exports.getServeUrlWithFallback = getServeUrlWithFallback;

package/dist/log-level.d.ts

@@ -1,4 +1,4 @@
 export declare const logLevels: readonly ["verbose", "info", "warn", "error"];
-export type LogLevel = typeof logLevels[number];
+export type LogLevel = (typeof logLevels)[number];
 export declare const isValidLogLevel: (level: string) => boolean;
 export declare const isEqualOrBelowLogLevel: (currentLevel: LogLevel, level: LogLevel) => boolean;

package/dist/offthread-video-server.d.ts

@@ -7,8 +7,9 @@ export declare const extractUrlAndSourceFromUrl: (url: string) => {
     time: number;
     transparent: boolean;
 };
-export declare const startOffthreadVideoServer: ({ downloadMap, concurrency, logLevel, indent, }: {
+export declare const startOffthreadVideoServer: ({ downloadMap, concurrency, logLevel, indent, offthreadVideoCacheSizeInBytes, }: {
     downloadMap: DownloadMap;
+    offthreadVideoCacheSizeInBytes: number | null;
     concurrency: number;
     logLevel: LogLevel;
     indent: boolean;

package/dist/offthread-video-server.js

@@ -6,6 +6,7 @@ const download_and_map_assets_to_file_1 = require("./assets/download-and-map-ass
 const compositor_1 = require("./compositor/compositor");
 const log_level_1 = require("./log-level");
 const logger_1 = require("./logger");
+const offthreadvideo_cache_size_1 = require("./options/offthreadvideo-cache-size");
 const extractUrlAndSourceFromUrl = (url) => {
     const parsed = new URL(url, 'http://localhost');
     const query = parsed.search;
@@ -30,10 +31,11 @@ const extractUrlAndSourceFromUrl = (url) => {
 };
 exports.extractUrlAndSourceFromUrl = extractUrlAndSourceFromUrl;
 const REQUEST_CLOSED_TOKEN = 'Request closed';
-const startOffthreadVideoServer = ({ downloadMap, concurrency, logLevel, indent, }) => {
+const startOffthreadVideoServer = ({ downloadMap, concurrency, logLevel, indent, offthreadVideoCacheSizeInBytes, }) => {
+    (0, offthreadvideo_cache_size_1.validateOffthreadVideoCacheSizeInBytes)(offthreadVideoCacheSizeInBytes);
     const compositor = (0, compositor_1.startCompositor)('StartLongRunningProcess', {
         concurrency,
-        maximum_frame_cache_items: (0, compositor_1.getIdealMaximumFrameCacheItems)(),
+        maximum_frame_cache_size_in_bytes: offthreadVideoCacheSizeInBytes !== null && offthreadVideoCacheSizeInBytes !== void 0 ? offthreadVideoCacheSizeInBytes : (0, compositor_1.getIdealMaximumFrameCacheSizeInBytes)(),
         verbose: (0, log_level_1.isEqualOrBelowLogLevel)(logLevel, 'verbose'),
     }, logLevel, indent);
     return {