@remotion/renderer 3.0.16 → 3.0.19

package/dist/faststart/update-chunk-offsets.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-bitwise */
+const atom_1 = require("./atom");
+/**
+ * Adds the specified offset to each entry in stco/co64 atoms
+ *
+ * @param atoms QT atoms to traverse
+ * @param offset offset to add
+ * @param forceUpgrade always upgrade stco atoms to co64
+ */
+function updateChunkOffsets(moov, options) {
+    const atoms = moov.data;
+    const originalMoovSize = Number(moov.size);
+    let newChunksSize = 0;
+    let originalChunksSize = 0;
+    // First pass to count total entries, which is needed for co64 upgrades.
+    (0, atom_1.traverseAtoms)(atoms, (atom) => {
+        if (!['stco', 'co64'].includes(atom.kind) || !Buffer.isBuffer(atom.data)) {
+            return;
+        }
+        const entries = atom.data.readUInt32BE(4);
+        const originalEntrySize = isCo64(atom.kind) ? 8 : 4;
+        originalChunksSize += entries * originalEntrySize;
+        const newEntrySize = isCo64(atom.kind) || options.forceUpgradeToCo64 ? 8 : 4;
+        newChunksSize += entries * newEntrySize;
+    });
+    // Calculate new mdat offsets to add to stco/co64 chunk offset values
+    const totalOffset = originalMoovSize - originalChunksSize + newChunksSize;
+    // Second pass to actually update offsets.
+    (0, atom_1.traverseAtoms)(atoms, (atom) => {
+        if (!['stco', 'co64'].includes(atom.kind) || !Buffer.isBuffer(atom.data)) {
+            return;
+        }
+        const overflow = updateChunkAtom(atom, totalOffset, options);
+        if (!overflow) {
+            return;
+        }
+        upgradeStcoToCo64(atom, totalOffset);
+    });
+}
+exports.default = updateChunkOffsets;
+/**
+ * Updates `stco` or `co64` atoms' chunk offsets.
+ *
+ * @param atom `stco` or `co64` to update chunk offsets of
+ * @param totalOffset the total offset value to add to the existing chunk offsets
+ * @param options
+ * @returns {boolean} `true` if overflowed (did not finish updating chunks), `false` if succeeded
+ */
+function updateChunkAtom(atom, totalOffset, options) {
+    if (!Buffer.isBuffer(atom.data)) {
+        throw new Error(`${atom.kind} data is not a Buffer!`);
+    }
+    let overflow = false;
+    const entrySize = isCo64(atom.kind) ? 8 : 4;
+    const entries = atom.data.readUInt32BE(4);
+    const newData = Buffer.alloc(8 + entries * entrySize); // 8 byte header
+    atom.data.copy(newData, 0, 0, 8); // copy header
+    for (let i = 0; i < entries; i++) {
+        const cur = 8 + i * entrySize; // 8 byte header
+        if (isCo64(atom.kind)) {
+            const newVal64 = Number((BigInt(atom.data.readUInt32BE(cur)) << BigInt(32)) |
+                BigInt(atom.data.readUInt32BE(cur + 4))) + totalOffset;
+            newData.writeUInt32BE(Number((BigInt(newVal64) >> BigInt(32)) & BigInt(0xffffffff)), cur);
+            newData.writeUInt32BE(Number(BigInt(newVal64) & BigInt(0xffffffff)), cur + 4);
+            continue;
+        }
+        if (options.forceUpgradeToCo64) {
+            overflow = true;
+            break;
+        }
+        const newVal32 = atom.data.readUInt32BE(cur) + totalOffset;
+        if (newVal32 > 2 ** 32 - 1) {
+            overflow = true;
+            break;
+        }
+        newData.writeUInt32BE(newVal32, cur);
+    }
+    if (!overflow) {
+        atom.data = newData;
+    }
+    return overflow;
+}
+/**
+ * **Upgrades** `stco` atom to a `co64` atom and also updates the chunk offsets.
+ *
+ * @param atom `stco` or `co64` to update chunk offsets of
+ * @param totalOffset the total offset value to add to the existing chunk offsets
+ */
+function upgradeStcoToCo64(atom, totalOffset) {
+    if (!Buffer.isBuffer(atom.data)) {
+        throw new Error(`${atom.kind} data is not a Buffer!`);
+    }
+    // Upgrade to stco atoms to co64 atoms
+    const entries = atom.data.readUInt32BE(4);
+    const upgradedData = Buffer.alloc(8 + entries * 8); // 8-byte header, 8-byte entry size
+    atom.data.copy(upgradedData, 0, 0, 8);
+    upgradedData.writeUInt32BE((entries >> 32) & 0xffffffff, 8); // MSB 64-bit size
+    upgradedData.writeUInt32BE(entries & 0xffffffff, 12); // LSB 64-bit size
+    for (let i = 0; i < entries; i++) {
+        const cur32 = 8 + i * 4; // 8-byte header, 4-byte entry size for READS (stco)
+        const newVal = atom.data.readUInt32BE(cur32) + totalOffset;
+        const cur64 = 8 + i * 8; // 8-byte header, 8-byte entry size for WRITES (co64)
+        upgradedData.writeUInt32BE(Number((BigInt(newVal) >> BigInt(32)) & BigInt(0xffffffff)), cur64);
+        upgradedData.writeUInt32BE(Number(BigInt(newVal) & BigInt(0xffffffff)), cur64 + 4);
+    }
+    atom.kind = 'co64';
+    atom.data = upgradedData;
+    atom.size = atom_1.ATOM_PREAMBLE_SIZE * BigInt(2) + BigInt(upgradedData.byteLength);
+}
+function isCo64(atomKind) {
+    return atomKind === 'co64';
+}

package/dist/faststart/util.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export interface Cursor {
+    pos: bigint;
+}
+export declare function numToHex(val: number): string;
+export declare function asciiToU32Be(chars: string): number;
+export declare function u32BeToAscii(u32: number): string;
+export declare function readU32(cur: Cursor, buf: Buffer): number;
+export declare function readU64(cur: Cursor, buf: Buffer): bigint;

package/dist/faststart/util.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readU64 = exports.readU32 = exports.u32BeToAscii = exports.asciiToU32Be = exports.numToHex = void 0;
+function numToHex(val) {
+    return val.toString(16);
+}
+exports.numToHex = numToHex;
+function asciiToU32Be(chars) {
+    return Buffer.from(chars.split('').map((char) => char.charCodeAt(0))).readUInt32BE(0);
+}
+exports.asciiToU32Be = asciiToU32Be;
+function u32BeToAscii(u32) {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(u32, 0);
+    return buf.toString('ascii');
+}
+exports.u32BeToAscii = u32BeToAscii;
+function readU32(cur, buf) {
+    const u32 = buf.readUInt32BE(Number(cur.pos));
+    cur.pos += BigInt(4);
+    return u32;
+}
+exports.readU32 = readU32;
+function readU64(cur, buf) {
+    const long = buf.slice(Number(cur.pos), Number(cur.pos + BigInt(8)));
+    const u64 = 
+    // eslint-disable-next-line no-bitwise
+    (BigInt(long.readUInt32BE(0)) << BigInt(32)) |
+        // eslint-disable-next-line no-bitwise
+        (BigInt(long.readUInt32BE(4)) & BigInt(0xffffffff));
+    cur.pos += BigInt(8);
+    return u64;
+}
+exports.readU64 = readU64;

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-duration-of-asset.d.ts

@@ -0,0 +1,7 @@
+import { FfmpegExecutable } from 'remotion';
+declare type Options = {
+    ffprobeExecutable: FfmpegExecutable;
+    src: string;
+};
+export declare const getDurationOfAsset: (options: Options) => Promise<number>;
+export {};

package/dist/get-duration-of-asset.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDurationOfAsset = void 0;
+const execa_1 = __importDefault(require("execa"));
+const p_limit_1 = require("./p-limit");
+const durationOfAssetCache = {};
+const limit = (0, p_limit_1.pLimit)(1);
+const getDurationOfAssetUnlimited = async ({ ffprobeExecutable, src, }) => {
+    if (durationOfAssetCache[src]) {
+        return durationOfAssetCache[src];
+    }
+    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}`);
+    }
+    durationOfAssetCache[src] = duration;
+    return duration;
+};
+const getDurationOfAsset = (options) => {
+    return limit(getDurationOfAssetUnlimited, options);
+};
+exports.getDurationOfAsset = getDurationOfAsset;

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,13 @@
+/// <reference types="node" />
+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/make-assets-download-dir.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeAssetsDownloadTmpDir = void 0;
 const tmp_dir_1 = require("./tmp-dir");
+let dir = null;
 const makeAssetsDownloadTmpDir = () => {
-    return (0, tmp_dir_1.tmpDir)('remotion-assets-dir');
+    if (dir) {
+        return dir;
+    }
+    dir = (0, tmp_dir_1.tmpDir)('remotion-assets-dir');
+    return dir;
 };
 exports.makeAssetsDownloadTmpDir = makeAssetsDownloadTmpDir;

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) => {
@@ -58,6 +59,7 @@ const startOffthreadVideoServer = ({ ffmpegExecutable, downloadDir, onDownload,
             .catch((err) => {
             res.writeHead(500);
             res.end();
+            onError(err);
             console.log('Error occurred', err);
         });
     };

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.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/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>;