@remotion/renderer 4.0.22 → 4.0.24

package/dist/screenshot-dom-element.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
 import type { StillImageFormat } from './image-format';

package/dist/screenshot-task.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
 import type { StillImageFormat } from './image-format';

package/dist/select-composition.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 InternalSelectCompositionsConfig = {
     serializedInputPropsWithCustomSchema: string;
@@ -19,7 +21,7 @@ type InternalSelectCompositionsConfig = {
     logLevel: LogLevel;
     serveUrl: string;
     id: string;
-};
+} & ToOptions<typeof optionsMap.renderStill>;
 export type SelectCompositionOptions = {
     inputProps?: Record<string, unknown> | null;
     envVariables?: Record<string, string>;
@@ -30,6 +32,7 @@ export type SelectCompositionOptions = {
     chromiumOptions?: ChromiumOptions;
     port?: number | null;
     verbose?: boolean;
+    offthreadVideoCacheSizeInBytes?: number | null;
     serveUrl: string;
     id: string;
 };

package/dist/select-composition.js

@@ -84,7 +84,7 @@ const innerSelectComposition = async ({ page, onBrowserLog, serializedInputProps
 };
 const internalSelectComposition = async (options) => {
     const cleanup = [];
-    const { puppeteerInstance, browserExecutable, chromiumOptions, serveUrl: serveUrlOrWebpackUrl, logLevel, indent, port, envVariables, id, serializedInputPropsWithCustomSchema, onBrowserLog, server, timeoutInMilliseconds, } = options;
+    const { puppeteerInstance, browserExecutable, chromiumOptions, serveUrl: serveUrlOrWebpackUrl, logLevel, indent, port, envVariables, id, serializedInputPropsWithCustomSchema, onBrowserLog, server, timeoutInMilliseconds, offthreadVideoCacheSizeInBytes, } = options;
     const { page, cleanup: cleanupPage } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
         passedInInstance: puppeteerInstance,
         browserExecutable,
@@ -109,6 +109,7 @@ const internalSelectComposition = async (options) => {
             concurrency: 1,
             logLevel,
             indent,
+            offthreadVideoCacheSizeInBytes,
         }, {
             onDownload: () => undefined,
             onError,
@@ -131,6 +132,7 @@ const internalSelectComposition = async (options) => {
                 indent,
                 puppeteerInstance,
                 server,
+                offthreadVideoCacheSizeInBytes,
             });
         })
             .then((data) => {
@@ -152,6 +154,7 @@ exports.internalSelectComposition = internalSelectComposition;
  * @see [Documentation](https://www.remotion.dev/docs/renderer/select-composition)
  */
 const selectComposition = async (options) => {
+    var _a;
     const { id, serveUrl, browserExecutable, chromiumOptions, envVariables, inputProps, onBrowserLog, port, puppeteerInstance, timeoutInMilliseconds, verbose, } = options;
     const data = await (0, exports.internalSelectComposition)({
         id,
@@ -171,6 +174,7 @@ const selectComposition = async (options) => {
         logLevel: verbose ? 'verbose' : 'info',
         indent: false,
         server: undefined,
+        offthreadVideoCacheSizeInBytes: (_a = options.offthreadVideoCacheSizeInBytes) !== null && _a !== void 0 ? _a : null,
     });
     return data.metadata;
 };

package/dist/serve-static.d.ts

@@ -8,6 +8,7 @@ export declare const serveStatic: (path: string | null, options: {
     concurrency: number;
     logLevel: LogLevel;
     indent: boolean;
+    offthreadVideoCacheSizeInBytes: number | null;
 }) => Promise<{
     port: number;
     close: () => Promise<void>;

package/dist/serve-static.js

@@ -14,6 +14,7 @@ const serveStatic = async (path, options) => {
         concurrency: options.concurrency,
         logLevel: options.logLevel,
         indent: options.indent,
+        offthreadVideoCacheSizeInBytes: options.offthreadVideoCacheSizeInBytes,
     });
     const connections = {};
     const server = node_http_1.default.createServer((request, response) => {

package/dist/stitch-frames-to-video.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { RenderAssetInfo } from './assets/download-map';
 import type { AudioCodec } from './audio-codec';

package/dist/take-frame-and-compose.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { TRenderAsset } from 'remotion';
 import type { DownloadMap } from './assets/download-map';
 import type { Page } from './browser/BrowserPage';

package/dist/try-to-extract-frame-of-video-fast.d.ts

@@ -0,0 +1,12 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { NeedsResize, SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const tryToExtractFrameOfVideoFast: ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }: {
+    ffmpegExecutable: FfmpegExecutable;
+    remotionRoot: string;
+    imageFormat: OffthreadVideoImageFormat;
+    needsResize: NeedsResize;
+    src: string;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    actualOffset: string;
+}) => Promise<readonly [string, Buffer]>;

package/dist/try-to-extract-frame-of-video-fast.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryToExtractFrameOfVideoFast = void 0;
+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 tryToExtractFrameOfVideoFast = async ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }) => {
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+        '-ss',
+        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));
+    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]);
+    return [stdErr, stdoutBuffer];
+};
+exports.tryToExtractFrameOfVideoFast = tryToExtractFrameOfVideoFast;

package/dist/validate-ffmpeg.d.ts

@@ -0,0 +1,7 @@
+export declare const customExecutableExists: (localExecutable: string) => boolean;
+export declare const binaryExists: (name: 'ffmpeg' | 'ffprobe') => boolean;
+export declare const checkAndValidateFfmpegVersion: (options: {
+    ffmpegExecutable: string | null;
+    remotionRoot: string;
+}) => Promise<void>;
+export declare const validateFfmpeg: (customFfmpegBinary: string | null, remotionRoot: string, binary: 'ffmpeg' | 'ffprobe') => Promise<void>;

package/dist/validate-ffmpeg.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFfmpeg = exports.checkAndValidateFfmpegVersion = exports.binaryExists = exports.customExecutableExists = void 0;
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const warn_about_ffmpeg_version_1 = require("./warn-about-ffmpeg-version");
+const existsMap = {};
+const customExecutableExists = (localExecutable) => {
+    try {
+        (0, fs_1.statSync)(localExecutable);
+        existsMap[localExecutable] = true;
+    }
+    catch (err) {
+        existsMap[localExecutable] = false;
+    }
+    return existsMap[localExecutable];
+};
+exports.customExecutableExists = customExecutableExists;
+const binaryExists = (name) => {
+    if (typeof existsMap[name] !== 'undefined') {
+        return existsMap[name];
+    }
+    const isWin = os_1.default.platform() === 'win32';
+    const where = isWin ? 'where' : 'which';
+    try {
+        execa_1.default.sync(where, [name]);
+        existsMap[name] = true;
+        return true;
+    }
+    catch (err) {
+        existsMap[name] = false;
+        return false;
+    }
+};
+exports.binaryExists = binaryExists;
+const checkAndValidateFfmpegVersion = async (options) => {
+    const ffmpegVersion = await (0, ffmpeg_flags_1.getFfmpegVersion)({
+        ffmpegExecutable: options.ffmpegExecutable,
+        remotionRoot: options.remotionRoot,
+    });
+    const buildConf = await (0, ffmpeg_flags_1.getFfmpegBuildInfo)({
+        ffmpegExecutable: options.ffmpegExecutable,
+        remotionRoot: options.remotionRoot,
+    });
+    (0, warn_about_ffmpeg_version_1.warnAboutFfmpegVersion)({ ffmpegVersion, buildConf });
+};
+exports.checkAndValidateFfmpegVersion = checkAndValidateFfmpegVersion;
+const validateFfmpeg = async (customFfmpegBinary, remotionRoot, binary) => {
+    const ffmpegExists = (0, exports.binaryExists)(binary);
+    if (ffmpegExists) {
+        return;
+    }
+    if (customFfmpegBinary) {
+        if (!(0, exports.customExecutableExists)(customFfmpegBinary)) {
+            throw new Error('Custom FFmpeg executable not found: ' + customFfmpegBinary);
+        }
+        return;
+    }
+    if (process.platform === 'linux' && (0, fs_1.existsSync)(ffmpeg_flags_1.lambdaFfmpegPaths[binary])) {
+        return;
+    }
+    if ((0, ffmpeg_flags_1.ffmpegInNodeModules)(remotionRoot, binary)) {
+        return;
+    }
+    const binaryUrl = (0, ffmpeg_flags_1.getBinaryDownloadUrl)(binary);
+    if (binaryUrl) {
+        await (0, ffmpeg_flags_1.downloadBinary)(remotionRoot, binaryUrl.url, binary);
+        return (0, exports.validateFfmpeg)(customFfmpegBinary, remotionRoot, binary);
+    }
+    throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);
+};
+exports.validateFfmpeg = validateFfmpeg;

package/dist/validate-opengl-renderer.d.ts

@@ -1,4 +1,4 @@
 export declare const validOpenGlRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
-export type OpenGlRenderer = typeof validOpenGlRenderers[number];
+export type OpenGlRenderer = (typeof validOpenGlRenderers)[number];
 export declare const DEFAULT_OPENGL_RENDERER: OpenGlRenderer | null;
 export declare const validateOpenGlRenderer: (option: OpenGlRenderer | null) => OpenGlRenderer | null;

package/dist/warn-about-ffmpeg-version.d.ts

@@ -0,0 +1,5 @@
+import type { FfmpegVersion } from './ffmpeg-flags';
+export declare const warnAboutFfmpegVersion: ({ ffmpegVersion, buildConf, }: {
+    ffmpegVersion: FfmpegVersion;
+    buildConf: string | null;
+}) => null | undefined;

package/dist/warn-about-ffmpeg-version.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnAboutFfmpegVersion = void 0;
+const printMessage = (ffmpegVersion) => {
+    console.warn('⚠️Old FFMPEG version detected: ' + ffmpegVersion.join('.'));
+    console.warn('   For audio support, you need at least version 4.1.0.');
+    console.warn('   Upgrade FFMPEG to get rid of this warning.');
+};
+const printBuildConfMessage = () => {
+    console.error('⚠️  Unsupported FFMPEG version detected.');
+    console.error("   Your version doesn't support the -buildconf flag");
+    console.error('   Audio will not be supported and you may experience other issues.');
+    console.error('   Upgrade FFMPEG to at least v4.1.0 to get rid of this warning.');
+};
+const warnAboutFfmpegVersion = ({ ffmpegVersion, buildConf, }) => {
+    if (buildConf === null) {
+        printBuildConfMessage();
+        return;
+    }
+    if (ffmpegVersion === null) {
+        return null;
+    }
+    const [major, minor] = ffmpegVersion;
+    // 3.x and below definitely is too old
+    if (major < 4) {
+        printMessage(ffmpegVersion);
+        return;
+    }
+    // 5.x will be all good
+    if (major > 4) {
+        return;
+    }
+    if (minor < 1) {
+        printMessage(ffmpegVersion);
+    }
+};
+exports.warnAboutFfmpegVersion = warnAboutFfmpegVersion;

package/dist/x264-preset.d.ts

@@ -1,6 +1,6 @@
 import type { Codec } from './codec';
 export declare const x264PresetOptions: readonly ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo"];
-export type X264Preset = typeof x264PresetOptions[number];
+export type X264Preset = (typeof x264PresetOptions)[number];
 export declare const validateSelectedCodecAndPresetCombination: ({ codec, x264Preset, }: {
     codec: Codec;
     x264Preset: X264Preset | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/renderer",
-  "version": "4.0.22",
+  "version": "4.0.24",
   "description": "Renderer for Remotion",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
     "extract-zip": "2.0.1",
     "source-map": "^0.8.0-beta.0",
     "ws": "8.7.0",
-    "remotion": "4.0.22"
+    "remotion": "4.0.24"
   },
   "peerDependencies": {
     "react": ">=16.8.0",
@@ -33,21 +33,20 @@
     "@types/react": "18.0.26",
     "@types/react-dom": "18.0.10",
     "eslint": "8.42.0",
-    "prettier": "^2.7.1",
+    "prettier": "3.0.2",
     "prettier-plugin-organize-imports": "^3.2.2",
     "react": "18.0.0",
     "react-dom": "18.0.0",
-    "vitest": "0.31.1",
-    "zod": "^3.21.4"
+    "vitest": "0.31.1"
   },
   "optionalDependencies": {
-    "@remotion/compositor-darwin-x64": "4.0.22",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.22",
-    "@remotion/compositor-darwin-arm64": "4.0.22",
-    "@remotion/compositor-linux-arm64-musl": "4.0.22",
-    "@remotion/compositor-linux-x64-gnu": "4.0.22",
-    "@remotion/compositor-linux-x64-musl": "4.0.22",
-    "@remotion/compositor-win32-x64-msvc": "4.0.22"
+    "@remotion/compositor-darwin-arm64": "4.0.24",
+    "@remotion/compositor-darwin-x64": "4.0.24",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.24",
+    "@remotion/compositor-linux-arm64-musl": "4.0.24",
+    "@remotion/compositor-linux-x64-gnu": "4.0.24",
+    "@remotion/compositor-linux-x64-musl": "4.0.24",
+    "@remotion/compositor-win32-x64-msvc": "4.0.24"
   },
   "keywords": [
     "remotion",

package/dist/presets-profile.d.ts

@@ -1,7 +0,0 @@
-import type { Codec } from './codec';
-export declare const presetsProfileOptions: readonly ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo"];
-export type PresetsProfile = typeof presetsProfileOptions[number];
-export declare const validateSelectedCodecAndPresetCombination: ({ codec, presetsProfile, }: {
-    codec: Codec;
-    presetsProfile: PresetsProfile | undefined;
-}) => void;

package/dist/presets-profile.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSelectedCodecAndPresetCombination = exports.presetsProfileOptions = void 0;
-exports.presetsProfileOptions = [
-    'ultrafast',
-    'superfast',
-    'veryfast',
-    'faster',
-    'fast',
-    'medium',
-    'slow',
-    'slower',
-    'veryslow',
-    'placebo',
-];
-const validateSelectedCodecAndPresetCombination = ({ codec, presetsProfile, }) => {
-    if (typeof presetsProfile !== 'undefined' && codec !== 'h264') {
-        throw new TypeError(`You have set a Preset profile but the codec is "${codec}". Set the codec to "h264" or remove the Preset profile.`);
-    }
-    if (presetsProfile !== undefined &&
-        !exports.presetsProfileOptions.includes(presetsProfile)) {
-        throw new TypeError(`The Preset profile "${presetsProfile}" is not valid. Valid options are ${exports.presetsProfileOptions
-            .map((p) => `"${p}"`)
-            .join(', ')}`);
-    }
-};
-exports.validateSelectedCodecAndPresetCombination = validateSelectedCodecAndPresetCombination;