@remotion/renderer 3.0.14 → 3.0.17

package/dist/abort.d.ts

@@ -0,0 +1,7 @@
+declare type Callback = () => void;
+export declare type CancelSignal = (callback: Callback) => void;
+export declare const getCancelSignal: () => {
+    cancelSignal: CancelSignal;
+    cancel: () => void;
+};
+export {};

package/dist/abort.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCancelSignal = void 0;
+const getCancelSignal = () => {
+    const callbacks = [];
+    let cancelled = false;
+    return {
+        cancelSignal: (callback) => callbacks.push(callback),
+        cancel: () => {
+            if (cancelled) {
+                return;
+            }
+            callbacks.forEach((cb) => {
+                cb();
+            });
+            cancelled = true;
+        },
+    };
+};
+exports.getCancelSignal = getCancelSignal;

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/cancel.d.ts

@@ -0,0 +1,7 @@
+declare type Callback = () => void;
+export declare type CancelSignal = (callback: Callback) => void;
+export declare const makeCancelSignal: () => {
+    cancelSignal: CancelSignal;
+    cancel: () => void;
+};
+export {};

package/dist/cancel.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCancelSignal = void 0;
+const makeCancelSignal = () => {
+    const callbacks = [];
+    let cancelled = false;
+    return {
+        cancelSignal: (callback) => {
+            callbacks.push(callback);
+            if (cancelled) {
+                callback();
+            }
+        },
+        cancel: () => {
+            if (cancelled) {
+                return;
+            }
+            callbacks.forEach((cb) => {
+                cb();
+            });
+            cancelled = true;
+        },
+    };
+};
+exports.makeCancelSignal = makeCancelSignal;

package/dist/combine-videos.d.ts

@@ -1,9 +1,10 @@
 import { Codec } from 'remotion';
-export declare const combineVideos: ({ files, filelistDir, output, onProgress, numberOfFrames, codec, }: {
+export declare const combineVideos: ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, }: {
     files: string[];
     filelistDir: string;
     output: string;
     onProgress: (p: number) => void;
     numberOfFrames: number;
     codec: Codec;
+    fps: number;
 }) => Promise<void>;

package/dist/combine-videos.js

@@ -11,13 +11,15 @@ const path_1 = require("path");
 const remotion_1 = require("remotion");
 const get_audio_codec_name_1 = require("./get-audio-codec-name");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
-const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfFrames, codec, }) => {
+const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, }) => {
     var _a;
     const fileList = files.map((p) => `file '${p}'`).join('\n');
     const fileListTxt = (0, path_1.join)(filelistDir, 'files.txt');
     (0, fs_1.writeFileSync)(fileListTxt, fileList);
     try {
         const task = (0, execa_1.default)('ffmpeg', [
+            remotion_1.Internals.isAudioCodec(codec) ? null : '-r',
+            remotion_1.Internals.isAudioCodec(codec) ? null : String(fps),
             '-f',
             'concat',
             '-safe',

package/dist/cycle-browser-tabs.d.ts

@@ -1,6 +1,7 @@
 import { openBrowser } from './open-browser';
 declare type Await<T> = T extends PromiseLike<infer U> ? U : T;
-export declare const cycleBrowserTabs: (puppeteerInstance: Await<ReturnType<typeof openBrowser>>, concurrency: number) => {
+declare type Browser = Await<ReturnType<typeof openBrowser>>;
+export declare const cycleBrowserTabs: (puppeteerInstance: Browser, concurrency: number) => {
     stopCycling: () => void;
 };
 export {};

package/dist/cycle-browser-tabs.js

@@ -9,15 +9,21 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
     }
     let interval = null;
     let i = 0;
+    let stopped = false;
     const set = () => {
         interval = setTimeout(() => {
             puppeteerInstance
                 .pages()
                 .then((pages) => {
-                var _a, _b;
+                var _a;
+                if (pages.length === 0) {
+                    return;
+                }
                 const currentPage = pages[i % pages.length];
                 i++;
-                if (!((_b = (_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) !== null && _b !== void 0 ? _b : true)) {
+                if (!((_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) &&
+                    !stopped &&
+                    (currentPage === null || currentPage === void 0 ? void 0 : currentPage.url()) !== 'about:blank') {
                     return currentPage.bringToFront();
                 }
             })
@@ -33,6 +39,7 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
             if (!interval) {
                 return;
             }
+            stopped = true;
             return clearInterval(interval);
         },
     };

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

@@ -2,17 +2,15 @@
 /// <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

@@ -28,6 +28,7 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
         initialFrame: 0,
         timeoutInMilliseconds: config === null || config === void 0 ? void 0 : config.timeoutInMilliseconds,
         proxyPort,
+        retriesRemaining: 2,
     });
     await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         page,
@@ -59,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,
@@ -73,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/index.d.ts

@@ -5,6 +5,7 @@ export { combineVideos } from './combine-videos';
 export { ErrorWithStackFrame } from './error-handling/handle-javascript-exception';
 export { FfmpegVersion } from './ffmpeg-flags';
 export { getCompositions } from './get-compositions';
+export { CancelSignal, makeCancelSignal } from './make-cancel-signal';
 export { openBrowser } from './open-browser';
 export type { ChromiumOptions } from './open-browser';
 export { renderFrames } from './render-frames';
@@ -32,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;
@@ -47,7 +49,7 @@ export declare const RenderInternals: {
     }) => void;
     normalizeServeUrl: (unnormalized: string) => string;
     spawnFfmpeg: (options: import("./stitch-frames-to-video").StitcherOptions) => Promise<{
-        task: Promise<unknown>;
+        task: Promise<void>;
         getLogs: () => string;
     }>;
     getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "mp4" | "mkv" | "mov" | "webm";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenderInternals = exports.stitchFramesToVideo = exports.renderStill = exports.renderMedia = exports.renderFrames = exports.openBrowser = exports.getCompositions = exports.ErrorWithStackFrame = exports.combineVideos = void 0;
+exports.RenderInternals = exports.stitchFramesToVideo = exports.renderStill = exports.renderMedia = exports.renderFrames = exports.openBrowser = exports.makeCancelSignal = exports.getCompositions = exports.ErrorWithStackFrame = exports.combineVideos = void 0;
 const download_file_1 = require("./assets/download-file");
 const delete_directory_1 = require("./delete-directory");
 const ensure_output_directory_1 = require("./ensure-output-directory");
@@ -30,6 +30,8 @@ var handle_javascript_exception_1 = require("./error-handling/handle-javascript-
 Object.defineProperty(exports, "ErrorWithStackFrame", { enumerable: true, get: function () { return handle_javascript_exception_1.ErrorWithStackFrame; } });
 var get_compositions_1 = require("./get-compositions");
 Object.defineProperty(exports, "getCompositions", { enumerable: true, get: function () { return get_compositions_1.getCompositions; } });
+var make_cancel_signal_1 = require("./make-cancel-signal");
+Object.defineProperty(exports, "makeCancelSignal", { enumerable: true, get: function () { return make_cancel_signal_1.makeCancelSignal; } });
 var open_browser_2 = require("./open-browser");
 Object.defineProperty(exports, "openBrowser", { enumerable: true, get: function () { return open_browser_2.openBrowser; } });
 var render_frames_1 = require("./render-frames");

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-cancel-signal.d.ts

@@ -0,0 +1,7 @@
+declare type Callback = () => void;
+export declare type CancelSignal = (callback: Callback) => void;
+export declare const makeCancelSignal: () => {
+    cancelSignal: CancelSignal;
+    cancel: () => void;
+};
+export {};

package/dist/make-cancel-signal.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCancelSignal = void 0;
+const makeCancelSignal = () => {
+    const callbacks = [];
+    let cancelled = false;
+    return {
+        cancelSignal: (callback) => {
+            callbacks.push(callback);
+            if (cancelled) {
+                callback();
+            }
+        },
+        cancel: () => {
+            if (cancelled) {
+                return;
+            }
+            callbacks.forEach((cb) => {
+                cb();
+            });
+            cancelled = true;
+        },
+    };
+};
+exports.makeCancelSignal = makeCancelSignal;

package/dist/merge-audio-track.js

@@ -30,8 +30,8 @@ const mergeAudioTrackUnlimited = async ({ ffmpegExecutable, outName, files, numb
         });
         return;
     }
-    // FFMPEG has a limit of 64 tracks that can be merged at once
-    if (files.length > 64) {
+    // In FFMPEG, the total number of left and right tracks that can be merged at one time is limited to 64
+    if (files.length >= 32) {
         const chunked = (0, chunk_1.chunk)(files, 10);
         const tempPath = (0, tmp_dir_1.tmpDir)('remotion-large-audio-mixing');
         const chunkNames = await Promise.all(chunked.map(async (chunkFiles, i) => {

package/dist/offthread/index.js

@@ -0,0 +1 @@
+"use strict";

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}`
@@ -115,7 +116,7 @@ const openBrowser = async (browser, options) => {
         ].filter(Boolean),
     });
     const pages = await browserInstance.pages();
-    pages.forEach((p) => p.close());
+    await pages[0].close();
     browserInstances.push(browserInstance);
     return browserInstance;
 };

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/prespawn-ffmpeg.d.ts

@@ -1,5 +1,6 @@
 import execa from 'execa';
 import { Codec, FfmpegExecutable, ImageFormat, PixelFormat, ProResProfile } from 'remotion';
+import { CancelSignal } from './make-cancel-signal';
 declare type PreSticherOptions = {
     fps: number;
     width: number;
@@ -13,6 +14,7 @@ declare type PreSticherOptions = {
     verbose: boolean;
     ffmpegExecutable: FfmpegExecutable | undefined;
     imageFormat: ImageFormat;
+    signal: CancelSignal;
 };
 export declare const prespawnFfmpeg: (options: PreSticherOptions) => Promise<{
     task: execa.ExecaChildProcess<string>;