@remotion/renderer 3.0.15 → 3.0.18

package/dist/assets/get-audio-channels.d.ts

@@ -1,4 +1,5 @@
-export declare function getAudioChannelsAndDuration(path: string): Promise<{
+import { FfmpegExecutable } from 'remotion';
+export declare function getAudioChannelsAndDuration(path: string, ffprobeExecutable: FfmpegExecutable): Promise<{
     channels: number;
     duration: number | null;
 }>;

package/dist/assets/get-audio-channels.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioChannelsAndDuration = void 0;
 const execa_1 = __importDefault(require("execa"));
-async function getAudioChannelsAndDuration(path) {
+async function getAudioChannelsAndDuration(path, ffprobeExecutable) {
     const args = [
         ['-v', 'error'],
         ['-show_entries', 'stream=channels:format=duration'],
@@ -14,7 +14,7 @@ async function getAudioChannelsAndDuration(path) {
     ]
         .reduce((acc, val) => acc.concat(val), [])
         .filter(Boolean);
-    const task = await (0, execa_1.default)('ffprobe', args);
+    const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', args);
     const channels = task.stdout.match(/channels=([0-9]+)/);
     const duration = task.stdout.match(/duration=([0-9.]+)/);
     return {

package/dist/combine-videos.js

@@ -30,6 +30,9 @@ const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfF
             remotion_1.Internals.isAudioCodec(codec) ? null : 'copy',
             '-c:a',
             (0, get_audio_codec_name_1.getAudioCodecName)(codec),
+            // Set max bitrate up to 1024kbps, will choose lower if that's too much
+            '-b:a',
+            '512K',
             codec === 'h264' ? '-movflags' : null,
             codec === 'h264' ? 'faststart' : null,
             '-shortest',

package/dist/create-ffmpeg-complex-filter.d.ts

@@ -1,4 +1,7 @@
 export declare const createFfmpegComplexFilter: (filters: number) => Promise<{
-    complexFilterFlag: [string, string] | null;
+    complexFilterFlag: [
+        string,
+        string
+    ] | null;
     cleanup: () => void;
 }>;

package/dist/extract-frame-from-video.d.ts

@@ -1,18 +1,15 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { FfmpegExecutable } from 'remotion';
 import { Readable } from 'stream';
+import { LastFrameOptions } from './last-frame-from-video-cache';
 export declare function streamToString(stream: Readable): Promise<string>;
-export declare const getLastFrameOfVideo: ({ ffmpegExecutable, offset, src, }: {
-    ffmpegExecutable: FfmpegExecutable;
-    offset: number;
-    src: string;
-}) => Promise<Buffer>;
+export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;
 declare type Options = {
     time: number;
     src: string;
     ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
 };
-export declare const extractFrameFromVideoFn: ({ time, src, ffmpegExecutable, }: Options) => Promise<Buffer>;
+export declare const extractFrameFromVideoFn: ({ time, src, ffmpegExecutable, ffprobeExecutable, }: Options) => Promise<Buffer>;
 export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
 export {};

package/dist/extract-frame-from-video.js

@@ -5,7 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractFrameFromVideo = exports.extractFrameFromVideoFn = exports.getLastFrameOfVideo = exports.streamToString = void 0;
 const execa_1 = __importDefault(require("execa"));
+const remotion_1 = require("remotion");
 const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
+const is_beyond_last_frame_1 = require("./is-beyond-last-frame");
+const last_frame_from_video_cache_1 = require("./last-frame-from-video-cache");
 const p_limit_1 = require("./p-limit");
 function streamToString(stream) {
     const chunks = [];
@@ -16,15 +19,32 @@ function streamToString(stream) {
     });
 }
 exports.streamToString = streamToString;
-const getLastFrameOfVideo = async ({ ffmpegExecutable, offset, src, }) => {
+const lastFrameLimit = (0, p_limit_1.pLimit)(5);
+const mainLimit = (0, p_limit_1.pLimit)(5);
+const getLastFrameOfVideoUnlimited = async ({ ffmpegExecutable, ffprobeExecutable, offset, src, }) => {
     if (offset > 100) {
         throw new Error('could not get last frame of ' +
             src +
             '. Tried to seek 100ms before the end of the video and no frame was found. The video container has a duration that is longer than it contains video.');
     }
-    const actualOffset = `-${offset + 10}ms`;
+    const durationCmd = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', [
+        '-v',
+        'error',
+        '-select_streams',
+        'v:0',
+        '-show_entries',
+        'stream=duration',
+        '-of',
+        'default=noprint_wrappers=1:nokey=1',
+        src,
+    ]);
+    const duration = parseFloat(durationCmd.stdout);
+    if (Number.isNaN(duration)) {
+        throw new TypeError(`Could not get duration of ${src}: ${durationCmd.stdout}`);
+    }
+    const actualOffset = `${duration * 1000 - offset - 10}ms`;
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
-        '-sseof',
+        '-ss',
         actualOffset,
         '-i',
         src,
@@ -61,13 +81,34 @@ const getLastFrameOfVideo = async ({ ffmpegExecutable, offset, src, }) => {
     const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
     const isEmpty = stdErr.includes('Output file is empty');
     if (isEmpty) {
-        return (0, exports.getLastFrameOfVideo)({ ffmpegExecutable, offset: offset + 10, src });
+        return getLastFrameOfVideoUnlimited({
+            ffmpegExecutable,
+            offset: offset + 10,
+            src,
+            ffprobeExecutable,
+        });
     }
     return stdoutBuffer;
 };
+const getLastFrameOfVideo = async (options) => {
+    const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)(options);
+    if (fromCache) {
+        return fromCache;
+    }
+    const result = await lastFrameLimit(getLastFrameOfVideoUnlimited, options);
+    (0, last_frame_from_video_cache_1.setLastFrameInCache)(options, result);
+    return result;
+};
 exports.getLastFrameOfVideo = getLastFrameOfVideo;
-const limit = (0, p_limit_1.pLimit)(5);
-const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, }) => {
+const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExecutable, }) => {
+    if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(src, time)) {
+        return (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
+            offset: 0,
+            src,
+        });
+    }
     const ffmpegTimestamp = (0, frame_to_ffmpeg_timestamp_1.frameToFfmpegTimestamp)(time);
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
         '-ss',
@@ -117,8 +158,10 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, }) => {
         stdoutBuffer,
     ]);
     if (stderrStr.includes('Output file is empty')) {
+        (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(src, time);
         return (0, exports.getLastFrameOfVideo)({
             ffmpegExecutable,
+            ffprobeExecutable,
             offset: 0,
             src,
         });
@@ -126,7 +169,10 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, }) => {
     return stdOut;
 };
 exports.extractFrameFromVideoFn = extractFrameFromVideoFn;
-const extractFrameFromVideo = (options) => {
-    return limit(exports.extractFrameFromVideoFn, options);
+const extractFrameFromVideo = async (options) => {
+    const perf = remotion_1.Internals.perf.startPerfMeasure('extract-frame');
+    const res = await mainLimit(exports.extractFrameFromVideoFn, options);
+    remotion_1.Internals.perf.stopPerfMeasure(perf);
+    return res;
 };
 exports.extractFrameFromVideo = extractFrameFromVideo;

package/dist/get-compositions.d.ts

@@ -11,6 +11,7 @@ declare type GetCompositionsConfig = {
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
     ffmpegExecutable?: FfmpegExecutable;
+    ffprobeExecutable?: FfmpegExecutable;
     port?: number | null;
 };
 export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<TCompMetadata[]>;

package/dist/get-compositions.js

@@ -60,7 +60,7 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
         chromiumOptions: (_b = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _b !== void 0 ? _b : {},
     });
     return new Promise((resolve, reject) => {
-        var _a, _b;
+        var _a, _b, _c;
         const onError = (err) => reject(err);
         const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
             page,
@@ -74,7 +74,8 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
             onDownload: () => undefined,
             onError,
             ffmpegExecutable: (_a = config === null || config === void 0 ? void 0 : config.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
-            port: (_b = config === null || config === void 0 ? void 0 : config.port) !== null && _b !== void 0 ? _b : null,
+            ffprobeExecutable: (_b = config === null || config === void 0 ? void 0 : config.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
+            port: (_c = config === null || config === void 0 ? void 0 : config.port) !== null && _c !== void 0 ? _c : null,
         })
             .then(({ serveUrl, closeServer, offthreadPort }) => {
             close = closeServer;

package/dist/get-port.js

@@ -5,16 +5,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDesiredPort = void 0;
 const net_1 = __importDefault(require("net"));
-const getAvailablePort = (portToTry) => new Promise((resolve, reject) => {
-    const server = net_1.default.createServer();
-    server.unref();
-    server.on('error', reject);
-    server.listen({ port: portToTry }, () => {
-        const { port } = server.address();
-        server.close(() => {
-            resolve(port);
-        });
+const p_limit_1 = require("./p-limit");
+const getAvailablePort = (portToTry) => new Promise((resolve) => {
+    let status = 'unavailable';
+    const host = '127.0.0.1';
+    const socket = new net_1.default.Socket();
+    socket.on('connect', () => {
+        status = 'unavailable';
+        socket.destroy();
     });
+    socket.setTimeout(1000);
+    socket.on('timeout', () => {
+        status = 'unavailable';
+        socket.destroy();
+        resolve(status);
+    });
+    socket.on('error', () => {
+        status = 'available';
+    });
+    socket.on('close', () => resolve(status));
+    socket.connect(portToTry, host);
 });
 const portCheckSequence = function* (ports) {
     if (ports) {
@@ -22,30 +32,18 @@ const portCheckSequence = function* (ports) {
     }
     yield 0; // Fall back to 0 if anything else failed
 };
-const isPortAvailable = async (port) => {
-    try {
-        await getAvailablePort(port);
-        return true;
-    }
-    catch (error) {
-        if (!['EADDRINUSE', 'EACCES'].includes(error.code)) {
-            throw error;
-        }
-        return false;
-    }
-};
 const getPort = async (from, to) => {
     const ports = makeRange(from, to);
     for (const port of portCheckSequence(ports)) {
-        if (await isPortAvailable(port)) {
+        if ((await getAvailablePort(port)) === 'available') {
             return port;
         }
     }
     throw new Error('No available ports found');
 };
-const getDesiredPort = async (desiredPort, from, to) => {
+const getDesiredPortUnlimited = async (desiredPort, from, to) => {
     if (typeof desiredPort !== 'undefined' &&
-        (await isPortAvailable(desiredPort))) {
+        (await getAvailablePort(desiredPort)) === 'available') {
         return desiredPort;
     }
     const actualPort = await getPort(from, to);
@@ -55,6 +53,10 @@ const getDesiredPort = async (desiredPort, from, to) => {
     }
     return actualPort;
 };
+const limit = (0, p_limit_1.pLimit)(1);
+const getDesiredPort = (desiredPort, from, to) => {
+    return limit(() => getDesiredPortUnlimited(desiredPort, from, to));
+};
 exports.getDesiredPort = getDesiredPort;
 const makeRange = (from, to) => {
     if (!Number.isInteger(from) || !Number.isInteger(to)) {

package/dist/index.d.ts

@@ -33,6 +33,7 @@ export declare const RenderInternals: {
     serveStatic: (path: string | null, options: {
         port: number | null;
         ffmpegExecutable: import("remotion").FfmpegExecutable;
+        ffprobeExecutable: import("remotion").FfmpegExecutable;
         downloadDir: string;
         onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload;
         onError: (err: Error) => void;

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

@@ -0,0 +1,2 @@
+export declare const isBeyondLastFrame: (src: string, time: number) => boolean | 0;
+export declare const markAsBeyondLastFrame: (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 map = {};
+const isBeyondLastFrame = (src, time) => {
+    return map[src] && time >= map[src];
+};
+exports.isBeyondLastFrame = isBeyondLastFrame;
+const markAsBeyondLastFrame = (src, time) => {
+    map[src] = time;
+};
+exports.markAsBeyondLastFrame = markAsBeyondLastFrame;

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

@@ -0,0 +1,12 @@
+import { FfmpegExecutable } from 'remotion';
+export declare type LastFrameOptions = {
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+    offset: number;
+    src: string;
+};
+export declare const setLastFrameInCache: (options: LastFrameOptions, data: Buffer) => void;
+export declare const getLastFrameFromCache: (options: LastFrameOptions) => Buffer | null;
+export declare const removedLastFrameFromCache: (key: string) => void;
+export declare const ensureMaxSize: () => void;
+export declare const clearLastFileCache: () => void;

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

@@ -0,0 +1,52 @@
+"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.ensureMaxSize = exports.removedLastFrameFromCache = exports.getLastFrameFromCache = exports.setLastFrameInCache = void 0;
+let map = {};
+const MAX_CACHE_SIZE = 50 * 1024 * 1024; // 50MB
+let bufferSize = 0;
+const makeLastFrameCacheKey = (options) => {
+    return [options.ffmpegExecutable, options.offset, options.src].join('-');
+};
+const setLastFrameInCache = (options, data) => {
+    const key = makeLastFrameCacheKey(options);
+    if (map[key]) {
+        bufferSize -= map[key].data.byteLength;
+    }
+    map[key] = { data, lastAccessed: Date.now() };
+    bufferSize += data.byteLength;
+    (0, exports.ensureMaxSize)();
+};
+exports.setLastFrameInCache = setLastFrameInCache;
+const getLastFrameFromCache = (options) => {
+    var _a;
+    const key = makeLastFrameCacheKey(options);
+    if (!map[key]) {
+        return null;
+    }
+    map[key].lastAccessed = Date.now();
+    return (_a = map[key].data) !== null && _a !== void 0 ? _a : null;
+};
+exports.getLastFrameFromCache = getLastFrameFromCache;
+const removedLastFrameFromCache = (key) => {
+    if (!map[key]) {
+        return;
+    }
+    bufferSize -= map[key].data.byteLength;
+    delete map[key];
+};
+exports.removedLastFrameFromCache = removedLastFrameFromCache;
+const ensureMaxSize = () => {
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (bufferSize > MAX_CACHE_SIZE) {
+        const earliest = Object.entries(map).sort((a, b) => {
+            return a[1].lastAccessed - b[1].lastAccessed;
+        })[0];
+        (0, exports.removedLastFrameFromCache)(earliest[0]);
+    }
+};
+exports.ensureMaxSize = ensureMaxSize;
+const clearLastFileCache = () => {
+    map = {};
+};
+exports.clearLastFileCache = clearLastFileCache;

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

@@ -5,8 +5,9 @@ export declare const extractUrlAndSourceFromUrl: (url: string) => {
     src: string;
     time: number;
 };
-export declare const startOffthreadVideoServer: ({ ffmpegExecutable, downloadDir, onDownload, onError, }: {
+export declare const startOffthreadVideoServer: ({ ffmpegExecutable, ffprobeExecutable, downloadDir, onDownload, onError, }: {
     ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
     downloadDir: string;
     onDownload: RenderMediaOnDownload;
     onError: (err: Error) => void;

package/dist/offthread-video-server.js

@@ -22,7 +22,7 @@ const extractUrlAndSourceFromUrl = (url) => {
     return { src, time: parseFloat(time) };
 };
 exports.extractUrlAndSourceFromUrl = extractUrlAndSourceFromUrl;
-const startOffthreadVideoServer = ({ ffmpegExecutable, downloadDir, onDownload, onError, }) => {
+const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, downloadDir, onDownload, onError, }) => {
     return (req, res) => {
         if (!req.url) {
             throw new Error('Request came in without URL');
@@ -45,6 +45,7 @@ const startOffthreadVideoServer = ({ ffmpegExecutable, downloadDir, onDownload,
                 time,
                 src: to,
                 ffmpegExecutable,
+                ffprobeExecutable,
             });
         })
             .then((readable) => {

package/dist/open-browser.js

@@ -98,6 +98,7 @@ const openBrowser = async (browser, options) => {
             '--hide-scrollbars',
             '--no-default-browser-check',
             '--no-pings',
+            '--font-render-hinting=none',
             '--no-zygote',
             (options === null || options === void 0 ? void 0 : options.forceDeviceScaleFactor)
                 ? `--force-device-scale-factor=${options.forceDeviceScaleFactor}`

package/dist/prepare-server.d.ts

@@ -1,11 +1,12 @@
 import { FfmpegExecutable } from 'remotion';
 import { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
-export declare const prepareServer: ({ downloadDir, ffmpegExecutable, onDownload, onError, webpackConfigOrServeUrl, port, }: {
+export declare const prepareServer: ({ downloadDir, ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, }: {
     webpackConfigOrServeUrl: string;
     downloadDir: string;
     onDownload: RenderMediaOnDownload;
     onError: (err: Error) => void;
     ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
     port: number | null;
 }) => Promise<{
     serveUrl: string;

package/dist/prepare-server.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareServer = void 0;
 const is_serve_url_1 = require("./is-serve-url");
 const serve_static_1 = require("./serve-static");
-const prepareServer = async ({ downloadDir, ffmpegExecutable, onDownload, onError, webpackConfigOrServeUrl, port, }) => {
+const prepareServer = async ({ downloadDir, ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, }) => {
     if ((0, is_serve_url_1.isServeUrl)(webpackConfigOrServeUrl)) {
         const { port: offthreadPort, close: closeProxy } = await (0, serve_static_1.serveStatic)(null, {
             downloadDir,
             onDownload,
             onError,
             ffmpegExecutable,
+            ffprobeExecutable,
             port,
         });
         return Promise.resolve({
@@ -23,6 +24,7 @@ const prepareServer = async ({ downloadDir, ffmpegExecutable, onDownload, onErro
         onDownload,
         onError,
         ffmpegExecutable,
+        ffprobeExecutable,
         port,
     });
     return Promise.resolve({

package/dist/preprocess-audio-track.d.ts

@@ -2,6 +2,7 @@ import { FfmpegExecutable } from 'remotion';
 import { MediaAsset } from './assets/types';
 declare type Options = {
     ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
     outName: string;
     asset: MediaAsset;
     expectedFrames: number;

package/dist/preprocess-audio-track.js

@@ -10,8 +10,8 @@ const calculate_ffmpeg_filters_1 = require("./calculate-ffmpeg-filters");
 const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
 const p_limit_1 = require("./p-limit");
 const resolve_asset_src_1 = require("./resolve-asset-src");
-const preprocessAudioTrackUnlimited = async ({ ffmpegExecutable, outName, asset, expectedFrames, fps, }) => {
-    const { channels, duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)((0, resolve_asset_src_1.resolveAssetSrc)(asset.src));
+const preprocessAudioTrackUnlimited = async ({ ffmpegExecutable, ffprobeExecutable, outName, asset, expectedFrames, fps, }) => {
+    const { channels, duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)((0, resolve_asset_src_1.resolveAssetSrc)(asset.src), ffprobeExecutable);
     const filter = (0, calculate_ffmpeg_filters_1.calculateFfmpegFilter)({
         asset,
         durationInFrames: expectedFrames,

package/dist/provide-screenshot.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import puppeteer from 'puppeteer-core';
 import { ImageFormat } from 'remotion';
 export declare const provideScreenshot: ({ page, imageFormat, options, quality, }: {

package/dist/provide-screenshot.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.provideScreenshot = void 0;
 const screenshot_dom_element_1 = require("./screenshot-dom-element");
-const provideScreenshot = async ({ page, imageFormat, options, quality, }) => {
+const provideScreenshot = ({ page, imageFormat, options, quality, }) => {
     return (0, screenshot_dom_element_1.screenshotDOMElement)({
         page,
         opts: {

package/dist/puppeteer-screenshot.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" />
 import { Page, ScreenshotOptions } from 'puppeteer-core';
 export declare const screenshot: (page: Page, options?: ScreenshotOptions) => Promise<Buffer | string | void>;

package/dist/render-frames.d.ts

@@ -35,6 +35,7 @@ declare type RenderFramesOptions = {
     chromiumOptions?: ChromiumOptions;
     scale?: number;
     ffmpegExecutable?: FfmpegExecutable;
+    ffprobeExecutable?: FfmpegExecutable;
     port?: number | null;
     cancelSignal?: CancelSignal;
 } & ConfigOrComposition & ServeUrlOrWebpackBundle;

package/dist/render-frames.js

@@ -54,7 +54,7 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
     const pages = new Array(actualParallelism).fill(true).map(async () => {
         const page = await puppeteerInstance.newPage();
         pagesArray.push(page);
-        page.setViewport({
+        await page.setViewport({
             width: composition.width,
             height: composition.height,
             deviceScaleFactor: scale !== null && scale !== void 0 ? scale : 1,
@@ -135,6 +135,7 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
         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,
@@ -144,6 +145,7 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
                         output: undefined,
                     },
                 });
+                remotion_1.Internals.perf.stopPerfMeasure(id);
                 onFrameBuffer(buffer, frame);
             }
             else {
@@ -236,7 +238,7 @@ const renderFrames = (options) => {
     const actualParallelism = (0, get_concurrency_1.getActualConcurrency)((_d = options.parallelism) !== null && _d !== void 0 ? _d : null);
     const openedPages = [];
     return new Promise((resolve, reject) => {
-        var _a, _b;
+        var _a, _b, _c;
         const cleanup = [];
         const onError = (err) => reject(err);
         Promise.all([
@@ -246,7 +248,8 @@ const renderFrames = (options) => {
                 onDownload,
                 onError,
                 ffmpegExecutable: (_a = options.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
-                port: (_b = options.port) !== null && _b !== void 0 ? _b : null,
+                ffprobeExecutable: (_b = options.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
+                port: (_c = options.port) !== null && _c !== void 0 ? _c : null,
             }),
             browserInstance,
         ])

package/dist/render-gif.d.ts

@@ -0,0 +1,2 @@
+import { RenderMediaOptions } from './render-media';
+export declare const renderGif: ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, loop, skipNFrames, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }: RenderMediaOptions) => Promise<void>;