@remotion/renderer 4.0.0-lambda.3 → 4.0.0-newpathfunctions.13

package/dist/render-frames.js

@@ -6,24 +6,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderFrames = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const perf_hooks_1 = require("perf_hooks");
 const remotion_1 = require("remotion");
 const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
+const download_map_1 = require("./assets/download-map");
+const browser_1 = require("./browser");
+const compress_assets_1 = require("./compress-assets");
 const cycle_browser_tabs_1 = require("./cycle-browser-tabs");
 const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
+const find_closest_package_json_1 = require("./find-closest-package-json");
 const get_concurrency_1 = require("./get-concurrency");
 const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
+const get_frame_padded_index_1 = require("./get-frame-padded-index");
 const get_frame_to_render_1 = require("./get-frame-to-render");
 const image_format_1 = require("./image-format");
 const legacy_webpack_config_1 = require("./legacy-webpack-config");
-const make_assets_download_dir_1 = require("./make-assets-download-dir");
+const make_cancel_signal_1 = require("./make-cancel-signal");
 const open_browser_1 = require("./open-browser");
+const perf_1 = require("./perf");
 const pool_1 = require("./pool");
 const prepare_server_1 = require("./prepare-server");
-const provide_screenshot_1 = require("./provide-screenshot");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const quality_1 = require("./quality");
+const replace_browser_1 = require("./replace-browser");
 const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
+const take_frame_and_compose_1 = require("./take-frame-and-compose");
+const truthy_1 = require("./truthy");
 const validate_scale_1 = require("./validate-scale");
+const MAX_RETRIES_PER_FRAME = 1;
 const getComposition = (others) => {
     if ('composition' in others) {
         return others.composition;
@@ -33,15 +44,16 @@ const getComposition = (others) => {
     }
     return undefined;
 };
-const getPool = async (pages) => {
-    const puppeteerPages = await Promise.all(pages);
-    const pool = new pool_1.Pool(puppeteerPages);
-    return pool;
-};
-const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, quality, imageFormat = image_format_1.DEFAULT_IMAGE_FORMAT, frameRange, puppeteerInstance, onError, envVariables, onBrowserLog, onFrameBuffer, onDownload, pagesArray, serveUrl, composition, timeoutInMilliseconds, scale, actualParallelism, downloadDir, proxyPort, cancelSignal, }) => {
-    if (!puppeteerInstance) {
-        throw new Error('no puppeteer instance passed to innerRenderFrames - internal error');
+const getConcurrency = (others) => {
+    if ('concurrency' in others) {
+        return others.concurrency;
+    }
+    if ('parallelism' in others) {
+        return others.parallelism;
     }
+    return undefined;
+};
+const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, quality, imageFormat = image_format_1.DEFAULT_IMAGE_FORMAT, frameRange, onError, envVariables, onBrowserLog, onFrameBuffer, onDownload, pagesArray, serveUrl, composition, timeoutInMilliseconds, scale = 1, actualConcurrency, everyNthFrame = 1, proxyPort, cancelSignal, downloadMap, muted, makeBrowser, browserReplacer, }) => {
     if (outputDir) {
         if (!fs_1.default.existsSync(outputDir)) {
             fs_1.default.mkdirSync(outputDir, {
@@ -49,10 +61,12 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
             });
         }
     }
+    const downloadPromises = [];
     const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(composition.durationInFrames, frameRange !== null && frameRange !== void 0 ? frameRange : null);
-    const frameCount = (0, get_duration_from_frame_range_1.getDurationFromFrameRange)(realFrameRange, composition.durationInFrames);
-    const pages = new Array(actualParallelism).fill(true).map(async () => {
-        const page = await puppeteerInstance.newPage();
+    const framesToRender = (0, get_duration_from_frame_range_1.getFramesToRender)(realFrameRange, everyNthFrame);
+    const lastFrame = framesToRender[framesToRender.length - 1];
+    const makePage = async () => {
+        const page = await browserReplacer.getBrowser().newPage();
         pagesArray.push(page);
         await page.setViewport({
             width: composition.width,
@@ -62,18 +76,14 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
         const logCallback = (log) => {
             onBrowserLog === null || onBrowserLog === void 0 ? void 0 : onBrowserLog({
                 stackTrace: log.stackTrace(),
-                text: log.text(),
-                type: log.type(),
+                text: log.text,
+                type: log.type,
             });
         };
         if (onBrowserLog) {
             page.on('console', logCallback);
         }
-        const initialFrame = typeof frameRange === 'number'
-            ? frameRange
-            : frameRange === null || frameRange === undefined
-                ? 0
-                : frameRange[0];
+        const initialFrame = realFrameRange[0];
         await (0, set_props_and_env_1.setPropsAndEnv)({
             inputProps,
             envVariables,
@@ -83,48 +93,69 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
             timeoutInMilliseconds,
             proxyPort,
             retriesRemaining: 2,
+            audioEnabled: !muted,
+            videoEnabled: imageFormat !== 'none',
         });
         await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
-            pageFunction: (id) => {
+            // eslint-disable-next-line max-params
+            pageFunction: (id, defaultProps, durationInFrames, fps, height, width) => {
                 window.setBundleMode({
                     type: 'composition',
                     compositionName: id,
+                    compositionDefaultProps: defaultProps,
+                    compositionDurationInFrames: durationInFrames,
+                    compositionFps: fps,
+                    compositionHeight: height,
+                    compositionWidth: width,
                 });
             },
-            args: [composition.id],
+            args: [
+                composition.id,
+                composition.defaultProps,
+                composition.durationInFrames,
+                composition.fps,
+                composition.height,
+                composition.width,
+            ],
             frame: null,
             page,
         });
         page.off('console', logCallback);
         return page;
+    };
+    const getPool = async () => {
+        const pages = new Array(actualConcurrency).fill(true).map(() => makePage());
+        const puppeteerPages = await Promise.all(pages);
+        const pool = new pool_1.Pool(puppeteerPages);
+        return pool;
+    };
+    // If rendering a GIF and skipping frames, we must ensure it starts from 0
+    // and then is consecutive so FFMPEG recognizes the sequence
+    const countType = everyNthFrame === 1 ? 'actual-frames' : 'from-zero';
+    const filePadLength = (0, get_frame_padded_index_1.getFilePadLength)({
+        lastFrame,
+        totalFrames: framesToRender.length,
+        countType,
     });
-    const [firstFrameIndex, lastFrameIndex] = realFrameRange;
-    // Substract one because 100 frames will be 00-99
-    // --> 2 digits
-    const filePadLength = String(lastFrameIndex).length;
     let framesRendered = 0;
-    const poolPromise = getPool(pages);
+    const poolPromise = getPool();
     onStart({
-        frameCount,
+        frameCount: framesToRender.length,
     });
-    const assets = new Array(frameCount).fill(undefined);
+    const assets = new Array(framesToRender.length).fill(undefined);
     let stopped = false;
     cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
         stopped = true;
     });
-    const progress = Promise.all(new Array(frameCount)
-        .fill(Boolean)
-        .map((_x, i) => i)
-        .map(async (index) => {
-        const frame = realFrameRange[0] + index;
+    const renderFrameWithOptionToReject = async ({ frame, index, reject, width, height, }) => {
         const pool = await poolPromise;
         const freePage = await pool.acquire();
         if (stopped) {
-            throw new Error('Render was stopped');
+            return reject(new Error('Render was stopped'));
         }
-        const paddedIndex = String(frame).padStart(filePadLength, '0');
+        const startTime = perf_hooks_1.performance.now();
         const errorCallbackOnFrame = (err) => {
-            onError(err);
+            reject(err);
         };
         const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
             page: freePage,
@@ -133,150 +164,208 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
         });
         freePage.on('error', errorCallbackOnFrame);
         await (0, seek_to_frame_1.seekToFrame)({ frame, page: freePage });
-        if (imageFormat !== 'none') {
-            if (onFrameBuffer) {
-                const id = remotion_1.Internals.perf.startPerfMeasure('save');
-                const buffer = await (0, provide_screenshot_1.provideScreenshot)({
-                    page: freePage,
-                    imageFormat,
-                    quality,
-                    options: {
-                        frame,
-                        output: undefined,
-                    },
-                });
-                remotion_1.Internals.perf.stopPerfMeasure(id);
-                onFrameBuffer(buffer, frame);
-            }
-            else {
-                if (!outputDir) {
-                    throw new Error('Called renderFrames() without specifying either `outputDir` or `onFrameBuffer`');
-                }
-                const output = path_1.default.join(outputDir, `element-${paddedIndex}.${imageFormat}`);
-                await (0, provide_screenshot_1.provideScreenshot)({
-                    page: freePage,
-                    imageFormat,
-                    quality,
-                    options: {
-                        frame,
-                        output,
-                    },
-                });
-            }
+        if (!outputDir && !onFrameBuffer && imageFormat !== 'none') {
+            throw new Error('Called renderFrames() without specifying either `outputDir` or `onFrameBuffer`');
         }
-        const collectedAssets = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
-            pageFunction: () => {
-                return window.remotion_collectAssets();
-            },
-            args: [],
+        if (outputDir && onFrameBuffer && imageFormat !== 'none') {
+            throw new Error('Pass either `outputDir` or `onFrameBuffer` to renderFrames(), not both.');
+        }
+        const id = (0, perf_1.startPerfMeasure)('save');
+        const frameDir = outputDir !== null && outputDir !== void 0 ? outputDir : downloadMap.compositingDir;
+        const { buffer, collectedAssets } = await (0, take_frame_and_compose_1.takeFrameAndCompose)({
             frame,
-            page: freePage,
+            freePage,
+            height,
+            imageFormat,
+            output: path_1.default.join(frameDir, (0, get_frame_padded_index_1.getFrameOutputFileName)({
+                frame,
+                imageFormat,
+                index,
+                countType,
+                lastFrame,
+                totalFrames: framesToRender.length,
+            })),
+            quality,
+            width,
+            scale,
+            downloadMap,
+            wantsBuffer: Boolean(onFrameBuffer),
         });
-        const compressedAssets = collectedAssets.map((asset) => remotion_1.Internals.AssetCompression.compressAsset(assets.filter(remotion_1.Internals.truthy).flat(1), asset));
+        if (onFrameBuffer) {
+            if (!buffer) {
+                throw new Error('unexpected null buffer');
+            }
+            onFrameBuffer(buffer, frame);
+        }
+        (0, perf_1.stopPerfMeasure)(id);
+        const compressedAssets = collectedAssets.map((asset) => (0, compress_assets_1.compressAsset)(assets.filter(truthy_1.truthy).flat(1), asset));
         assets[index] = compressedAssets;
         compressedAssets.forEach((asset) => {
             (0, download_and_map_assets_to_file_1.downloadAndMapAssetsToFileUrl)({
                 asset,
-                downloadDir,
                 onDownload,
+                downloadMap,
             }).catch((err) => {
                 onError(new Error(`Error while downloading asset: ${err.stack}`));
             });
         });
-        pool.release(freePage);
         framesRendered++;
-        onFrameUpdate(framesRendered, frame);
+        onFrameUpdate(framesRendered, frame, perf_hooks_1.performance.now() - startTime);
         cleanupPageError();
         freePage.off('error', errorCallbackOnFrame);
-        return compressedAssets;
-    }));
+        pool.release(freePage);
+    };
+    const renderFrame = (frame, index) => {
+        return new Promise((resolve, reject) => {
+            renderFrameWithOptionToReject({
+                frame,
+                index,
+                reject,
+                width: composition.width,
+                height: composition.height,
+            })
+                .then(() => {
+                resolve();
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        });
+    };
+    const renderFrameAndRetryTargetClose = async (frame, index, retriesLeft, attempt) => {
+        var _a, _b;
+        try {
+            await renderFrame(frame, index);
+        }
+        catch (err) {
+            if (!((_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.includes('Target closed')) &&
+                !((_b = err === null || err === void 0 ? void 0 : err.message) === null || _b === void 0 ? void 0 : _b.includes('Session closed'))) {
+                throw err;
+            }
+            if ((0, make_cancel_signal_1.isUserCancelledRender)(err)) {
+                throw err;
+            }
+            if (stopped) {
+                return;
+            }
+            if (retriesLeft === 0) {
+                console.warn(`The browser crashed ${attempt} times while rendering frame ${frame}. Not retrying anymore. Learn more about this error under https://www.remotion.dev/docs/target-closed`);
+                throw err;
+            }
+            console.warn(`The browser crashed while rendering frame ${frame}, retrying ${retriesLeft} more times. Learn more about this error under https://www.remotion.dev/docs/target-closed`);
+            await browserReplacer.replaceBrowser(makeBrowser, async () => {
+                const pages = new Array(actualConcurrency)
+                    .fill(true)
+                    .map(() => makePage());
+                const puppeteerPages = await Promise.all(pages);
+                const pool = await poolPromise;
+                for (const newPage of puppeteerPages) {
+                    pool.release(newPage);
+                }
+            });
+            await renderFrameAndRetryTargetClose(frame, index, retriesLeft - 1, attempt + 1);
+        }
+    };
+    const progress = Promise.all(framesToRender.map((frame, index) => renderFrameAndRetryTargetClose(frame, index, MAX_RETRIES_PER_FRAME, 1)));
     const happyPath = progress.then(() => {
+        const firstFrameIndex = countType === 'from-zero' ? 0 : framesToRender[0];
         const returnValue = {
             assetsInfo: {
                 assets,
-                downloadDir,
-                firstFrameIndex,
                 imageSequenceName: `element-%0${filePadLength}d.${imageFormat}`,
+                firstFrameIndex,
+                downloadMap,
             },
-            frameCount,
+            frameCount: framesToRender.length,
         };
         return returnValue;
     });
-    return Promise.race([
-        happyPath,
-        new Promise((_resolve, reject) => {
-            cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
-                reject(new Error('renderFrames() got cancelled'));
-            });
-        }),
-    ]);
+    return happyPath
+        .then(() => {
+        return Promise.all(downloadPromises);
+    })
+        .then(() => happyPath);
 };
 const renderFrames = (options) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     const composition = getComposition(options);
+    const concurrency = getConcurrency(options);
     if (!composition) {
         throw new Error('No `composition` option has been specified for renderFrames()');
     }
     remotion_1.Internals.validateDimension(composition.height, 'height', 'in the `config` object passed to `renderFrames()`');
     remotion_1.Internals.validateDimension(composition.width, 'width', 'in the `config` object passed to `renderFrames()`');
-    remotion_1.Internals.validateFps(composition.fps, 'in the `config` object of `renderFrames()`');
+    remotion_1.Internals.validateFps(composition.fps, 'in the `config` object of `renderFrames()`', false);
     remotion_1.Internals.validateDurationInFrames(composition.durationInFrames, 'in the `config` object passed to `renderFrames()`');
     if (options.quality !== undefined && options.imageFormat !== 'jpeg') {
         throw new Error("You can only pass the `quality` option if `imageFormat` is 'jpeg'.");
     }
     const selectedServeUrl = (0, legacy_webpack_config_1.getServeUrlWithFallback)(options);
-    remotion_1.Internals.validateQuality(options.quality);
+    (0, quality_1.validateQuality)(options.quality);
     (0, validate_scale_1.validateScale)(options.scale);
-    const browserInstance = (_a = options.puppeteerInstance) !== null && _a !== void 0 ? _a : (0, open_browser_1.openBrowser)(remotion_1.Internals.DEFAULT_BROWSER, {
-        shouldDumpIo: options.dumpBrowserLogs,
-        browserExecutable: options.browserExecutable,
-        chromiumOptions: options.chromiumOptions,
-        forceDeviceScaleFactor: (_b = options.scale) !== null && _b !== void 0 ? _b : 1,
-    });
-    const downloadDir = (0, make_assets_download_dir_1.makeAssetsDownloadTmpDir)();
+    const makeBrowser = () => {
+        var _a;
+        return (0, open_browser_1.openBrowser)(browser_1.DEFAULT_BROWSER, {
+            shouldDumpIo: options.dumpBrowserLogs,
+            browserExecutable: options.browserExecutable,
+            chromiumOptions: options.chromiumOptions,
+            forceDeviceScaleFactor: (_a = options.scale) !== null && _a !== void 0 ? _a : 1,
+        });
+    };
+    const browserInstance = (_a = options.puppeteerInstance) !== null && _a !== void 0 ? _a : makeBrowser();
+    const downloadMap = (_b = options.downloadMap) !== null && _b !== void 0 ? _b : (0, download_map_1.makeDownloadMap)();
     const onDownload = (_c = options.onDownload) !== null && _c !== void 0 ? _c : (() => () => undefined);
-    const actualParallelism = (0, get_concurrency_1.getActualConcurrency)((_d = options.parallelism) !== null && _d !== void 0 ? _d : null);
+    const actualConcurrency = (0, get_concurrency_1.getActualConcurrency)(concurrency !== null && concurrency !== void 0 ? concurrency : null);
     const openedPages = [];
     return new Promise((resolve, reject) => {
         var _a, _b, _c;
         const cleanup = [];
-        const onError = (err) => reject(err);
-        Promise.all([
-            (0, prepare_server_1.prepareServer)({
-                webpackConfigOrServeUrl: selectedServeUrl,
-                downloadDir,
-                onDownload,
-                onError,
-                ffmpegExecutable: (_a = options.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
-                ffprobeExecutable: (_b = options.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
-                port: (_c = options.port) !== null && _c !== void 0 ? _c : null,
+        const onError = (err) => {
+            reject(err);
+        };
+        Promise.race([
+            new Promise((_, rej) => {
+                var _a;
+                (_a = options.cancelSignal) === null || _a === void 0 ? void 0 : _a.call(options, () => {
+                    rej(new Error(make_cancel_signal_1.cancelErrorMessages.renderFrames));
+                });
+            }),
+            Promise.all([
+                (0, prepare_server_1.prepareServer)({
+                    webpackConfigOrServeUrl: selectedServeUrl,
+                    onDownload,
+                    onError,
+                    ffmpegExecutable: (_a = options.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
+                    ffprobeExecutable: (_b = options.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
+                    port: (_c = options.port) !== null && _c !== void 0 ? _c : null,
+                    downloadMap,
+                    remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
+                }),
+                browserInstance,
+            ]).then(([{ serveUrl, closeServer, offthreadPort }, puppeteerInstance]) => {
+                const browserReplacer = (0, replace_browser_1.handleBrowserCrash)(puppeteerInstance);
+                const { stopCycling } = (0, cycle_browser_tabs_1.cycleBrowserTabs)(browserReplacer, actualConcurrency);
+                cleanup.push(stopCycling);
+                cleanup.push(() => closeServer(false));
+                return innerRenderFrames({
+                    ...options,
+                    puppeteerInstance,
+                    onError,
+                    pagesArray: openedPages,
+                    serveUrl,
+                    composition,
+                    actualConcurrency,
+                    onDownload,
+                    proxyPort: offthreadPort,
+                    downloadMap,
+                    makeBrowser,
+                    browserReplacer,
+                });
             }),
-            browserInstance,
         ])
-            .then(([{ serveUrl, closeServer, offthreadPort }, puppeteerInstance]) => {
-            var _a;
-            const { stopCycling } = (0, cycle_browser_tabs_1.cycleBrowserTabs)(puppeteerInstance, actualParallelism);
-            cleanup.push(stopCycling);
-            (_a = options.cancelSignal) === null || _a === void 0 ? void 0 : _a.call(options, () => {
-                stopCycling();
-                closeServer();
-            });
-            cleanup.push(closeServer);
-            const renderFramesProm = innerRenderFrames({
-                ...options,
-                puppeteerInstance,
-                onError,
-                pagesArray: openedPages,
-                serveUrl,
-                composition,
-                actualParallelism,
-                onDownload,
-                downloadDir,
-                proxyPort: offthreadPort,
-            });
-            return renderFramesProm;
+            .then((res) => {
+            return resolve(res);
         })
-            .then((res) => resolve(res))
             .catch((err) => reject(err))
             .finally(() => {
             // If browser instance was passed in, we close all the pages
@@ -284,21 +373,26 @@ const renderFrames = (options) => {
             // If new browser was opened, then closing the browser as a cleanup.
             if (options.puppeteerInstance) {
                 Promise.all(openedPages.map((p) => p.close())).catch((err) => {
-                    console.log('Unable to close browser tab', err);
+                    if (!(err === null || err === void 0 ? void 0 : err.message.includes('Target closed'))) {
+                        console.log('Unable to close browser tab', err);
+                    }
                 });
             }
             else {
                 Promise.resolve(browserInstance)
                     .then((puppeteerInstance) => {
-                    return puppeteerInstance.close();
+                    return puppeteerInstance.close(true);
                 })
                     .catch((err) => {
-                    console.log('Unable to close browser', err);
+                    if (!(err === null || err === void 0 ? void 0 : err.message.includes('Target closed'))) {
+                        console.log('Unable to close browser', err);
+                    }
                 });
             }
             cleanup.forEach((c) => {
                 c();
             });
+            // Don't clear download dir because it might be used by stitchFramesToVideo
         });
     });
 };

package/dist/render-media.d.ts

@@ -1,25 +1,38 @@
-import type { Browser as PuppeteerBrowser } from 'puppeteer-core';
-import { BrowserExecutable, Codec, FfmpegExecutable, FrameRange, PixelFormat, ProResProfile, SmallTCompMetadata } from 'remotion';
-import { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
-import { BrowserLog } from './browser-log';
-import { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
-import { CancelSignal } from './make-cancel-signal';
-import { ChromiumOptions } from './open-browser';
-import { OnStartData } from './types';
+import type { SmallTCompMetadata } 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 as PuppeteerBrowser } from './browser/Browser';
+import type { Codec } from './codec';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { FfmpegOverrideFn } from './ffmpeg-override';
+import type { FrameRange } from './frame-range';
+import type { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
+import type { CancelSignal } from './make-cancel-signal';
+import type { ChromiumOptions } from './open-browser';
+import type { PixelFormat } from './pixel-format';
+import type { ProResProfile } from './prores-profile';
+import type { OnStartData } from './types';
 export declare type StitchingState = 'encoding' | 'muxing';
+export declare type SlowFrame = {
+    frame: number;
+    time: number;
+};
+export declare type OnSlowestFrames = (frames: SlowFrame[]) => void;
 export declare type RenderMediaOnProgress = (progress: {
     renderedFrames: number;
     encodedFrames: number;
     encodedDoneIn: number | null;
     renderedDoneIn: number | null;
+    progress: number;
     stitchStage: StitchingState;
 }) => void;
 export declare type RenderMediaOptions = {
-    outputLocation: string;
+    outputLocation?: string | null;
     codec: Codec;
     composition: SmallTCompMetadata;
     inputProps?: unknown;
-    parallelism?: number | null;
     crf?: number | null;
     imageFormat?: 'png' | 'jpeg' | 'none';
     ffmpegExecutable?: FfmpegExecutable;
@@ -28,6 +41,8 @@ export declare type RenderMediaOptions = {
     envVariables?: Record<string, string>;
     quality?: number;
     frameRange?: FrameRange | null;
+    everyNthFrame?: number;
+    numberOfGifLoops?: number | null;
     puppeteerInstance?: PuppeteerBrowser;
     overwrite?: boolean;
     onProgress?: RenderMediaOnProgress;
@@ -42,10 +57,31 @@ export declare type RenderMediaOptions = {
     port?: number | null;
     cancelSignal?: CancelSignal;
     browserExecutable?: BrowserExecutable;
-} & ServeUrlOrWebpackBundle;
+    verbose?: boolean;
+    /**
+     * @deprecated Only for Remotion internal usage
+     */
+    downloadMap?: DownloadMap;
+    muted?: boolean;
+    enforceAudioTrack?: boolean;
+    ffmpegOverride?: FfmpegOverrideFn;
+    audioBitrate?: string | null;
+    videoBitrate?: string | null;
+    onSlowestFrames?: OnSlowestFrames;
+    disallowParallelEncoding?: boolean;
+} & ServeUrlOrWebpackBundle & ConcurrencyOrParallelism;
+declare type ConcurrencyOrParallelism = {
+    concurrency?: number | string | null;
+} | {
+    /**
+     * @deprecated This field has been renamed to `concurrency`
+     */
+    parallelism?: number | null;
+};
 /**
  *
  * @description Render a video from a composition
  * @link https://www.remotion.dev/docs/renderer/render-media
  */
-export declare const renderMedia: ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }: RenderMediaOptions) => Promise<void>;
+export declare const renderMedia: ({ proResProfile, crf, composition, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, onSlowestFrames, ...options }: RenderMediaOptions) => Promise<Buffer | null>;
+export {};