@remotion/renderer 4.0.0-alpha.4 → 4.0.0-alpha10

package/dist/prespawn-ffmpeg.js

@@ -1,21 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prespawnFfmpeg = void 0;
-const execa_1 = __importDefault(require("execa"));
 const remotion_1 = require("remotion");
+const call_ffmpeg_1 = require("./call-ffmpeg");
 const codec_1 = require("./codec");
 const crf_1 = require("./crf");
 const get_codec_name_1 = require("./get-codec-name");
 const get_prores_profile_name_1 = require("./get-prores-profile-name");
+const logger_1 = require("./logger");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const pixel_format_1 = require("./pixel-format");
 const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
-const validate_ffmpeg_1 = require("./validate-ffmpeg");
-const prespawnFfmpeg = async (options) => {
-    var _a, _b, _c, _d, _e, _f, _g;
+const prespawnFfmpeg = (options) => {
+    var _a, _b, _c;
     remotion_1.Internals.validateDimension(options.height, 'height', 'passed to `stitchFramesToVideo()`');
     remotion_1.Internals.validateDimension(options.width, 'width', 'passed to `stitchFramesToVideo()`');
     const codec = (_a = options.codec) !== null && _a !== void 0 ? _a : codec_1.DEFAULT_CODEC;
@@ -26,26 +23,40 @@ const prespawnFfmpeg = async (options) => {
         codec,
         scale: 1,
     });
-    const crf = (_b = options.crf) !== null && _b !== void 0 ? _b : (0, crf_1.getDefaultCrfForCodec)(codec);
-    const pixelFormat = (_c = options.pixelFormat) !== null && _c !== void 0 ? _c : pixel_format_1.DEFAULT_PIXEL_FORMAT;
-    await (0, validate_ffmpeg_1.validateFfmpeg)((_d = options.ffmpegExecutable) !== null && _d !== void 0 ? _d : null);
+    const pixelFormat = (_b = options.pixelFormat) !== null && _b !== void 0 ? _b : pixel_format_1.DEFAULT_PIXEL_FORMAT;
     const encoderName = (0, get_codec_name_1.getCodecName)(codec);
     const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
     if (encoderName === null) {
         throw new TypeError('encoderName is null: ' + JSON.stringify(options));
     }
     const supportsCrf = codec !== 'prores';
-    if (options.verbose) {
-        console.log('[verbose] ffmpeg', (_e = options.ffmpegExecutable) !== null && _e !== void 0 ? _e : 'ffmpeg in PATH');
-        console.log('[verbose] encoder', encoderName);
-        console.log('[verbose] pixelFormat', pixelFormat);
-        if (supportsCrf) {
-            console.log('[verbose] crf', crf);
-        }
-        console.log('[verbose] codec', codec);
-        console.log('[verbose] proResProfileName', proResProfileName);
+    logger_1.Log.verboseAdvanced({
+        indent: options.indent,
+        logLevel: options.verbose ? 'verbose' : 'info',
+        tag: 'encoder',
+    }, 'encoder', encoderName);
+    logger_1.Log.verboseAdvanced({
+        indent: options.indent,
+        logLevel: options.verbose ? 'verbose' : 'info',
+        tag: 'encoder',
+    }, 'pixelFormat', pixelFormat);
+    if (supportsCrf) {
+        logger_1.Log.verboseAdvanced({
+            indent: options.indent,
+            logLevel: options.verbose ? 'verbose' : 'info',
+            tag: 'encoder',
+        }, 'pixelFormat', options.crf);
     }
-    (0, crf_1.validateSelectedCrfAndCodecCombination)(crf, codec);
+    logger_1.Log.verboseAdvanced({
+        indent: options.indent,
+        logLevel: options.verbose ? 'verbose' : 'info',
+        tag: 'encoder',
+    }, 'codec', codec);
+    logger_1.Log.verboseAdvanced({
+        indent: options.indent,
+        logLevel: options.verbose ? 'verbose' : 'info',
+        tag: 'encoder',
+    }, 'proResProfileName', proResProfileName);
     (0, pixel_format_1.validateSelectedPixelFormatAndCodecCombination)(pixelFormat, codec);
     const ffmpegArgs = [
         ['-r', options.fps.toFixed(2)],
@@ -61,26 +72,38 @@ const prespawnFfmpeg = async (options) => {
         // and specified the video codec.
         ['-c:v', encoderName],
         proResProfileName ? ['-profile:v', proResProfileName] : null,
-        supportsCrf ? ['-crf', String(crf)] : null,
         ['-pix_fmt', pixelFormat],
         // Without explicitly disabling auto-alt-ref,
         // transparent WebM generation doesn't work
         pixelFormat === 'yuva420p' ? ['-auto-alt-ref', '0'] : null,
-        ['-b:v', '1M'],
+        ...(0, crf_1.validateQualitySettings)({
+            crf: options.crf,
+            videoBitrate: options.videoBitrate,
+            codec,
+        }),
         '-y',
         options.outputLocation,
     ];
-    if (options.verbose) {
-        console.log('Generated FFMPEG command:');
-        console.log(ffmpegArgs);
-    }
+    logger_1.Log.verboseAdvanced({
+        indent: options.indent,
+        logLevel: options.verbose ? 'verbose' : 'info',
+        tag: 'encoder',
+    }, 'Generated FFMPEG command:');
+    logger_1.Log.verboseAdvanced({
+        indent: options.indent,
+        logLevel: options.verbose ? 'verbose' : 'info',
+        tag: 'encoder',
+    }, ffmpegArgs.join(' '));
     const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
-    const task = (0, execa_1.default)((_f = options.ffmpegExecutable) !== null && _f !== void 0 ? _f : 'ffmpeg', ffmpegString);
+    const finalFfmpegString = options.ffmpegOverride
+        ? options.ffmpegOverride({ type: 'pre-stitcher', args: ffmpegString })
+        : ffmpegString;
+    const task = (0, call_ffmpeg_1.callFf)('ffmpeg', finalFfmpegString);
     options.signal(() => {
         task.kill();
     });
     let ffmpegOutput = '';
-    (_g = task.stderr) === null || _g === void 0 ? void 0 : _g.on('data', (data) => {
+    (_c = task.stderr) === null || _c === void 0 ? void 0 : _c.on('data', (data) => {
         const str = data.toString();
         ffmpegOutput += str;
         if (options.onProgress) {

package/dist/prestitcher-memory-usage.d.ts

@@ -1,7 +1,3 @@
-export declare const estimateMemoryUsageForPrestitcher: ({ width, height, }: {
-    width: number;
-    height: number;
-}) => number;
 export declare const shouldUseParallelEncoding: ({ width, height, }: {
     width: number;
     height: number;

package/dist/prestitcher-memory-usage.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldUseParallelEncoding = exports.estimateMemoryUsageForPrestitcher = void 0;
-const os_1 = __importDefault(require("os"));
+exports.shouldUseParallelEncoding = void 0;
+const node_os_1 = __importDefault(require("node:os"));
 const estimateMemoryUsageForPrestitcher = ({ width, height, }) => {
     // Empirically we detected that per 1 million pixels, FFMPEG uses around 1GB of memory, relatively independent of
     // the duration of the video.
@@ -12,10 +12,9 @@ const estimateMemoryUsageForPrestitcher = ({ width, height, }) => {
     const memoryUsageOfPixel = memoryUsageFor4K / 1000000;
     return memoryUsageOfPixel * width * height;
 };
-exports.estimateMemoryUsageForPrestitcher = estimateMemoryUsageForPrestitcher;
 const shouldUseParallelEncoding = ({ width, height, }) => {
-    const freeMemory = os_1.default.freemem();
-    const estimatedUsage = (0, exports.estimateMemoryUsageForPrestitcher)({
+    const freeMemory = node_os_1.default.freemem();
+    const estimatedUsage = estimateMemoryUsageForPrestitcher({
         height,
         width,
     });

package/dist/prores-profile.d.ts

@@ -1,5 +1,7 @@
 import type { Codec } from './codec';
-declare const proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
+export declare const proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
 export declare type ProResProfile = typeof proResProfileOptions[number];
-export declare const validateSelectedCodecAndProResCombination: (actualCodec: Codec, actualProResProfile: ProResProfile | undefined) => void;
-export {};
+export declare const validateSelectedCodecAndProResCombination: ({ codec, proResProfile, }: {
+    codec: Codec;
+    proResProfile: ProResProfile | undefined;
+}) => void;

package/dist/prores-profile.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSelectedCodecAndProResCombination = void 0;
-const proResProfileOptions = [
+exports.validateSelectedCodecAndProResCombination = exports.proResProfileOptions = void 0;
+exports.proResProfileOptions = [
     '4444-xq',
     '4444',
     'hq',
@@ -9,13 +9,13 @@ const proResProfileOptions = [
     'light',
     'proxy',
 ];
-const validateSelectedCodecAndProResCombination = (actualCodec, actualProResProfile) => {
-    if (typeof actualProResProfile !== 'undefined' && actualCodec !== 'prores') {
-        throw new TypeError('You have set a ProRes profile but the codec is not "prores". Set the codec to "prores" or remove the ProRes profile.');
+const validateSelectedCodecAndProResCombination = ({ codec, proResProfile, }) => {
+    if (typeof proResProfile !== 'undefined' && codec !== 'prores') {
+        throw new TypeError(`You have set a ProRes profile but the codec is "${codec}". Set the codec to "prores" or remove the ProRes profile.`);
     }
-    if (actualProResProfile !== undefined &&
-        !proResProfileOptions.includes(actualProResProfile)) {
-        throw new TypeError(`The ProRes profile "${actualProResProfile}" is not valid. Valid options are ${proResProfileOptions
+    if (proResProfile !== undefined &&
+        !exports.proResProfileOptions.includes(proResProfile)) {
+        throw new TypeError(`The ProRes profile "${proResProfile}" is not valid. Valid options are ${exports.proResProfileOptions
             .map((p) => `"${p}"`)
             .join(', ')}`);
     }

package/dist/provide-screenshot.d.ts

@@ -1,12 +1,16 @@
 /// <reference types="node" />
+import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
-import type { ImageFormat } from './image-format';
-export declare const provideScreenshot: ({ page, imageFormat, options, quality, }: {
+import type { StillImageFormat } from './image-format';
+export declare const provideScreenshot: ({ page, imageFormat, options, jpegQuality, height, width, clipRegion, }: {
     page: Page;
-    imageFormat: ImageFormat;
-    quality: number | undefined;
+    imageFormat: StillImageFormat;
+    jpegQuality: number | undefined;
     options: {
         frame: number;
         output: string | null;
     };
+    height: number;
+    width: number;
+    clipRegion: ClipRegion | null;
 }) => Promise<Buffer>;

package/dist/provide-screenshot.js

@@ -2,14 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.provideScreenshot = void 0;
 const screenshot_dom_element_1 = require("./screenshot-dom-element");
-const provideScreenshot = ({ page, imageFormat, options, quality, }) => {
+const provideScreenshot = ({ page, imageFormat, options, jpegQuality, height, width, clipRegion, }) => {
     return (0, screenshot_dom_element_1.screenshotDOMElement)({
         page,
         opts: {
             path: options.output,
         },
         imageFormat,
-        quality,
+        jpegQuality,
+        height,
+        width,
+        clipRegion,
     });
 };
 exports.provideScreenshot = provideScreenshot;

package/dist/puppeteer-evaluate.js

@@ -30,7 +30,7 @@ function isString(obj) {
     return typeof obj === 'string' || obj instanceof String;
 }
 async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, }) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const contextId = (await page.mainFrame().executionContext())._contextId;
     const client = page._client();
     const suffix = `//# sourceURL=${EVALUATION_SCRIPT_URL}`;
@@ -99,18 +99,26 @@ async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, })
             error.message += ' Are you passing a nested JSHandle?';
         throw error;
     }
-    const { exceptionDetails, result: remoteObject } = await callFunctionOnPromise;
-    if (exceptionDetails) {
-        const err = new symbolicateable_error_1.SymbolicateableError({
-            stack: (_c = exceptionDetails.exception) === null || _c === void 0 ? void 0 : _c.description,
-            name: (_d = exceptionDetails.exception) === null || _d === void 0 ? void 0 : _d.className,
-            message: (_f = (_e = exceptionDetails.exception) === null || _e === void 0 ? void 0 : _e.description) === null || _f === void 0 ? void 0 : _f.split('\n')[0],
-            frame,
-            stackFrame: (0, parse_browser_error_stack_1.parseStack)(((_g = exceptionDetails.exception) === null || _g === void 0 ? void 0 : _g.description).split('\n')),
-        });
-        throw err;
+    try {
+        const { exceptionDetails, result: remoteObject } = await callFunctionOnPromise;
+        if (exceptionDetails) {
+            const err = new symbolicateable_error_1.SymbolicateableError({
+                stack: (_c = exceptionDetails.exception) === null || _c === void 0 ? void 0 : _c.description,
+                name: (_d = exceptionDetails.exception) === null || _d === void 0 ? void 0 : _d.className,
+                message: (_f = (_e = exceptionDetails.exception) === null || _e === void 0 ? void 0 : _e.description) === null || _f === void 0 ? void 0 : _f.split('\n')[0],
+                frame,
+                stackFrame: (0, parse_browser_error_stack_1.parseStack)(((_g = exceptionDetails.exception) === null || _g === void 0 ? void 0 : _g.description).split('\n')),
+            });
+            throw err;
+        }
+        return valueFromRemoteObject(remoteObject);
+    }
+    catch (error) {
+        if ((_h = error === null || error === void 0 ? void 0 : error.originalMessage) === null || _h === void 0 ? void 0 : _h.startsWith("Object couldn't be returned by value")) {
+            throw new Error('Could not serialize the return value of the function. Did you pass non-serializable values to defaultProps?');
+        }
+        throw error;
     }
-    return valueFromRemoteObject(remoteObject);
 }
 exports.puppeteerEvaluateWithCatch = puppeteerEvaluateWithCatch;
 /**

package/dist/puppeteer-screenshot.d.ts

@@ -1,4 +1,14 @@
 /// <reference types="node" />
+import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
-import type { ScreenshotOptions } from './browser/ScreenshotOptions';
-export declare const screenshot: (page: Page, options: ScreenshotOptions) => Promise<Buffer | string | void>;
+import type { StillImageFormat } from './image-format';
+export declare const screenshot: (options: {
+    page: Page;
+    type: StillImageFormat;
+    path?: string;
+    jpegQuality?: number;
+    omitBackground: boolean;
+    width: number;
+    height: number;
+    clipRegion: ClipRegion | null;
+}) => Promise<Buffer | string>;

package/dist/puppeteer-screenshot.js

@@ -24,52 +24,26 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.screenshot = void 0;
-const assert = __importStar(require("assert"));
+const assert = __importStar(require("node:assert"));
 const screenshot_task_1 = require("./screenshot-task");
-const screenshot = (page, options) => {
-    let screenshotType = null;
-    // options.type takes precedence over inferring the type from options.path
-    // because it may be a 0-length file with no extension created beforehand
-    // (i.e. as a temp file).
-    if (options.type) {
-        assert.ok(options.type === 'png' || options.type === 'jpeg', 'Unknown options.type value: ' + options.type);
-        screenshotType = options.type;
+const screenshot = (options) => {
+    if (options.jpegQuality) {
+        assert.ok(options.type === 'jpeg', `options.quality is unsupported for the ${options.type} screenshots`);
+        assert.ok(typeof options.jpegQuality === 'number', 'Expected options.quality to be a number but found ' +
+            typeof options.jpegQuality);
+        assert.ok(Number.isInteger(options.jpegQuality), 'Expected options.quality to be an integer');
+        assert.ok(options.jpegQuality >= 0 && options.jpegQuality <= 100, 'Expected options.quality to be between 0 and 100 (inclusive), got ' +
+            options.jpegQuality);
     }
-    else if (options.path) {
-        const filePath = options.path;
-        const extension = filePath
-            .slice(filePath.lastIndexOf('.') + 1)
-            .toLowerCase();
-        if (extension === 'png')
-            screenshotType = 'png';
-        else if (extension === 'jpg' || extension === 'jpeg')
-            screenshotType = 'jpeg';
-        assert.ok(screenshotType, `Unsupported screenshot type for extension \`.${extension}\``);
-    }
-    if (!screenshotType)
-        screenshotType = 'png';
-    if (options.quality) {
-        assert.ok(screenshotType === 'jpeg', 'options.quality is unsupported for the ' +
-            screenshotType +
-            ' screenshots');
-        assert.ok(typeof options.quality === 'number', 'Expected options.quality to be a number but found ' +
-            typeof options.quality);
-        assert.ok(Number.isInteger(options.quality), 'Expected options.quality to be an integer');
-        assert.ok(options.quality >= 0 && options.quality <= 100, 'Expected options.quality to be between 0 and 100 (inclusive), got ' +
-            options.quality);
-    }
-    if (options.clip) {
-        assert.ok(typeof options.clip.x === 'number', 'Expected options.clip.x to be a number but found ' +
-            typeof options.clip.x);
-        assert.ok(typeof options.clip.y === 'number', 'Expected options.clip.y to be a number but found ' +
-            typeof options.clip.y);
-        assert.ok(typeof options.clip.width === 'number', 'Expected options.clip.width to be a number but found ' +
-            typeof options.clip.width);
-        assert.ok(typeof options.clip.height === 'number', 'Expected options.clip.height to be a number but found ' +
-            typeof options.clip.height);
-        assert.ok(options.clip.width !== 0, 'Expected options.clip.width not to be 0.');
-        assert.ok(options.clip.height !== 0, 'Expected options.clip.height not to be 0.');
-    }
-    return page.screenshotTaskQueue.postTask(() => (0, screenshot_task_1._screenshotTask)(page, screenshotType, options));
+    return options.page.screenshotTaskQueue.postTask(() => (0, screenshot_task_1.screenshotTask)({
+        page: options.page,
+        format: options.type,
+        height: options.height,
+        width: options.width,
+        omitBackground: options.omitBackground,
+        path: options.path,
+        jpegQuality: options.jpegQuality,
+        clipRegion: options.clipRegion,
+    }));
 };
 exports.screenshot = screenshot;

package/dist/redirect-status-codes.d.ts

@@ -0,0 +1 @@
+export declare const redirectStatusCodes: number[];

package/dist/redirect-status-codes.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redirectStatusCodes = void 0;
+// Don't handle 304 status code (Not Modified) as a redirect,
+// since the browser will display the right page.
+exports.redirectStatusCodes = [301, 302, 303, 307, 308];

package/dist/render-frames.d.ts

@@ -1,38 +1,31 @@
 /// <reference types="node" />
-import type { SmallTCompMetadata } from 'remotion';
+import type { AnySmallCompMetadata } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { DownloadMap } from './assets/download-map';
 import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
-import type { Browser } from './browser/Browser';
-import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { HeadlessBrowser } from './browser/Browser';
 import type { FrameRange } from './frame-range';
-import type { ImageFormat } from './image-format';
-import type { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
+import type { VideoImageFormat } from './image-format';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';
 import type { OnStartData, RenderFramesOutput } from './types';
-declare type ConfigOrComposition = {
-    /**
-     * @deprecated This field has been renamed to `composition`
-     */
-    config: SmallTCompMetadata;
-} | {
-    composition: SmallTCompMetadata;
-};
 declare type RenderFramesOptions = {
     onStart: (data: OnStartData) => void;
-    onFrameUpdate: (framesRendered: number, frameIndex: number) => void;
+    onFrameUpdate: (framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void;
     outputDir: string | null;
-    inputProps: unknown;
+    inputProps: Record<string, unknown>;
     envVariables?: Record<string, string>;
-    imageFormat: ImageFormat;
-    parallelism?: number | null;
-    quality?: number;
+    imageFormat?: VideoImageFormat;
+    /**
+     * @deprecated Renamed to "jpegQuality"
+     */
+    quality?: never;
+    jpegQuality?: number;
     frameRange?: FrameRange | null;
     everyNthFrame?: number;
     dumpBrowserLogs?: boolean;
-    puppeteerInstance?: Browser;
+    puppeteerInstance?: HeadlessBrowser;
     browserExecutable?: BrowserExecutable;
     onBrowserLog?: (log: BrowserLog) => void;
     onFrameBuffer?: (buffer: Buffer, frame: number) => void;
@@ -40,14 +33,25 @@ declare type RenderFramesOptions = {
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
     scale?: number;
-    ffmpegExecutable?: FfmpegExecutable;
-    ffprobeExecutable?: FfmpegExecutable;
     port?: number | null;
     cancelSignal?: CancelSignal;
+    composition: AnySmallCompMetadata;
     /**
      * @deprecated Only for Remotion internal usage
      */
     downloadMap?: DownloadMap;
-} & ConfigOrComposition & ServeUrlOrWebpackBundle;
+    /**
+     * @deprecated Only for Remotion internal usage
+     */
+    indent?: boolean;
+    muted?: boolean;
+    concurrency?: number | string | null;
+    serveUrl: string;
+    verbose?: boolean;
+};
+/**
+ * @description Renders a series of images using Puppeteer and computes information for mixing audio.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/render-frames)
+ */
 export declare const renderFrames: (options: RenderFramesOptions) => Promise<RenderFramesOutput>;
 export {};