@remotion/renderer 4.0.0-offthread.32 → 4.0.0-offthread.5

package/dist/assets/download-and-map-assets-to-file.d.ts

@@ -2,7 +2,7 @@ import { TAsset } from 'remotion';
 export declare type RenderMediaOnDownload = (src: string) => ((progress: {
     percent: number;
 }) => void) | undefined | void;
-export declare const waitForAssetToBeDownloaded: (src: string) => Promise<string>;
+export declare const waitForAssetToBeDownloaded: (src: string, to: string) => Promise<void>;
 export declare const markAllAssetsAsDownloaded: () => void;
 export declare const getSanitizedFilenameForAssetUrl: ({ src, downloadDir, }: {
     src: string;

package/dist/assets/download-and-map-assets-to-file.js

@@ -13,25 +13,38 @@ const sanitize_filepath_1 = require("./sanitize-filepath");
 const isDownloadingMap = {};
 const hasBeenDownloadedMap = {};
 const listeners = {};
-const waitForAssetToBeDownloaded = (src) => {
-    if (hasBeenDownloadedMap[src]) {
-        return Promise.resolve(hasBeenDownloadedMap[src]);
+const waitForAssetToBeDownloaded = (src, to) => {
+    var _a;
+    if ((_a = hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[to]) {
+        return Promise.resolve();
     }
     if (!listeners[src]) {
-        listeners[src] = [];
+        listeners[src] = {};
+    }
+    if (!listeners[src][to]) {
+        listeners[src][to] = [];
     }
     return new Promise((resolve) => {
-        listeners[src].push((to) => resolve(to));
+        listeners[src][to].push(() => resolve());
     });
 };
 exports.waitForAssetToBeDownloaded = waitForAssetToBeDownloaded;
 const notifyAssetIsDownloaded = (src, to) => {
     if (!listeners[src]) {
-        listeners[src] = [];
+        listeners[src] = {};
+    }
+    if (!listeners[src][to]) {
+        listeners[src][to] = [];
+    }
+    listeners[src][to].forEach((fn) => fn());
+    if (!isDownloadingMap[src]) {
+        isDownloadingMap[src] = {};
     }
-    listeners[src].forEach((fn) => fn(to));
-    isDownloadingMap[src] = false;
-    hasBeenDownloadedMap[src] = to;
+    isDownloadingMap[src][to] = false;
+    if (!hasBeenDownloadedMap[src]) {
+        hasBeenDownloadedMap[src] = {};
+    }
+    hasBeenDownloadedMap[src][to] = true;
 };
 const validateMimeType = (mimeType, src) => {
     if (!mimeType.includes('/')) {
@@ -73,13 +86,17 @@ function validateBufferEncoding(potentialEncoding, dataUrl) {
     }
 }
 const downloadAsset = async (src, to, onDownload) => {
-    if (hasBeenDownloadedMap[src]) {
+    var _a, _b;
+    if ((_a = hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[to]) {
         return;
     }
-    if (isDownloadingMap[src]) {
-        return (0, exports.waitForAssetToBeDownloaded)(src);
+    if ((_b = isDownloadingMap[src]) === null || _b === void 0 ? void 0 : _b[to]) {
+        return (0, exports.waitForAssetToBeDownloaded)(src, to);
+    }
+    if (!isDownloadingMap[src]) {
+        isDownloadingMap[src] = {};
     }
-    isDownloadingMap[src] = true;
+    isDownloadingMap[src][to] = true;
     const onProgress = onDownload(src);
     (0, ensure_output_directory_1.ensureOutputDirectory)(to);
     if (src.startsWith('data:')) {

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/create-ffmpeg-complex-filter.d.ts

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

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,11 +2,6 @@
 import { FfmpegExecutable } from 'remotion';
 import { Readable } from 'stream';
 export declare function streamToString(stream: Readable): Promise<string>;
-export declare const getLastFrameOfVideo: ({ ffmpegExecutable, offset, src, }: {
-    ffmpegExecutable: FfmpegExecutable;
-    offset: number;
-    src: string;
-}) => Promise<Buffer>;
 declare type Options = {
     time: number;
     src: string;

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

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFrameFromVideo = exports.extractFrameFromVideoFn = exports.getLastFrameOfVideo = exports.streamToString = void 0;
+exports.extractFrameFromVideo = exports.extractFrameFromVideoFn = exports.streamToString = void 0;
 const execa_1 = __importDefault(require("execa"));
 const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
+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,7 +17,8 @@ function streamToString(stream) {
     });
 }
 exports.streamToString = streamToString;
-const getLastFrameOfVideo = ({ ffmpegExecutable, offset, src, }) => {
+const limit = (0, p_limit_1.pLimit)(5);
+const getLastFrameOfVideoUnlimited = async ({ ffmpegExecutable, offset, src, }) => {
     if (offset > 100) {
         throw new Error('could not get last frame of ' +
             src +
@@ -40,33 +42,41 @@ const getLastFrameOfVideo = ({ ffmpegExecutable, offset, src, }) => {
     if (!stdout) {
         throw new Error('unexpectedly did not get stdout');
     }
-    const chunks = [];
-    return new Promise((resolve, reject) => {
-        let isEmpty = false;
-        stderr.on('data', (d) => {
-            if (d.toString().includes('Output file is empty')) {
-                isEmpty = true;
-                (0, exports.getLastFrameOfVideo)({ ffmpegExecutable, offset: offset + 10, src })
-                    .then((frame) => resolve(frame))
-                    .catch((err) => reject(err));
-            }
-        });
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
         stdout.on('data', (d) => {
-            chunks.push(d);
+            stdoutChunks.push(d);
         });
         stdout.on('error', (err) => {
             reject(err);
         });
         stdout.on('end', () => {
-            if (!isEmpty) {
-                resolve(Buffer.concat(chunks));
-            }
+            resolve(Buffer.concat(stdoutChunks));
         });
     });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        return getLastFrameOfVideo({ ffmpegExecutable, offset: offset + 10, src });
+    }
+    return stdoutBuffer;
 };
-exports.getLastFrameOfVideo = getLastFrameOfVideo;
-const limit = (0, p_limit_1.pLimit)(5);
-const extractFrameFromVideoFn = ({ time, src, ffmpegExecutable, }) => {
+const getLastFrameOfVideo = async (options) => {
+    const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)(options);
+    if (fromCache) {
+        return fromCache;
+    }
+    const result = await limit(getLastFrameOfVideoUnlimited, options);
+    (0, last_frame_from_video_cache_1.setLastFrameInCache)(options, result);
+    return result;
+};
+const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, }) => {
     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',
@@ -87,29 +97,42 @@ const extractFrameFromVideoFn = ({ time, src, ffmpegExecutable, }) => {
     if (!stdout) {
         throw new Error('unexpectedly did not get stdout');
     }
-    const chunks = [];
-    return new Promise((resolve, reject) => {
-        let isEmpty = false;
-        stderr === null || stderr === void 0 ? void 0 : stderr.on('data', (d) => {
-            if (d.toString().includes('Output file is empty')) {
-                isEmpty = true;
-                (0, exports.getLastFrameOfVideo)({ ffmpegExecutable, offset: 0, src })
-                    .then((frame) => resolve(frame))
-                    .catch((err) => reject(err));
-            }
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const stderrStringProm = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => {
+            stderrChunks.push(d);
+        });
+        stderr.on('error', (err) => {
+            reject(err);
         });
-        stdout === null || stdout === void 0 ? void 0 : stdout.on('data', (d) => {
-            chunks.push(d);
+        stderr.on('end', () => {
+            resolve(Buffer.concat(stderrChunks).toString('utf8'));
+        });
+    });
+    const stdoutBuffer = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => {
+            stdoutChunks.push(d);
         });
-        stdout === null || stdout === void 0 ? void 0 : stdout.on('error', (err) => {
+        stdout.on('error', (err) => {
             reject(err);
         });
-        stdout === null || stdout === void 0 ? void 0 : stdout.on('end', () => {
-            if (!isEmpty) {
-                resolve(Buffer.concat(chunks));
-            }
+        stdout.on('end', () => {
+            resolve(Buffer.concat(stdoutChunks));
         });
     });
+    const [stderrStr, stdOut] = await Promise.all([
+        stderrStringProm,
+        stdoutBuffer,
+    ]);
+    if (stderrStr.includes('Output file is empty')) {
+        return getLastFrameOfVideo({
+            ffmpegExecutable,
+            offset: 0,
+            src,
+        });
+    }
+    return stdOut;
 };
 exports.extractFrameFromVideoFn = extractFrameFromVideoFn;
 const extractFrameFromVideo = (options) => {

package/dist/get-compositions.d.ts

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

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;
+        var _a, _b;
         const onError = (err) => reject(err);
         const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
             page,
@@ -73,6 +74,7 @@ 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,
         })
             .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';
@@ -47,24 +48,12 @@ 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";
-    makeAssetsDownloadTmpDir: () => string;
     tmpDir: (str: string) => string;
     deleteDirectory: (directory: string) => Promise<void>;
-    prepareServer: ({ downloadDir, ffmpegExecutable, onDownload, onError, webpackConfigOrServeUrl, }: {
-        webpackConfigOrServeUrl: string;
-        downloadDir: string;
-        onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload;
-        onError: (err: Error) => void;
-        ffmpegExecutable: import("remotion").FfmpegExecutable;
-    }) => Promise<{
-        serveUrl: string;
-        closeServer: () => Promise<unknown>;
-        offthreadPort: number;
-    }>;
     isServeUrl: (potentialUrl: string) => boolean;
     ensureOutputDirectory: (outputLocation: string) => void;
     getRealFrameRange: (durationInFrames: number, frameRange: import("remotion").FrameRange | null) => [number, number];

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");
@@ -14,11 +14,9 @@ const get_extension_of_filename_1 = require("./get-extension-of-filename");
 const get_frame_to_render_1 = require("./get-frame-to-render");
 const get_local_browser_executable_1 = require("./get-local-browser-executable");
 const is_serve_url_1 = require("./is-serve-url");
-const make_assets_download_dir_1 = require("./make-assets-download-dir");
 const normalize_serve_url_1 = require("./normalize-serve-url");
 const open_browser_1 = require("./open-browser");
 const parse_browser_error_stack_1 = require("./parse-browser-error-stack");
-const prepare_server_1 = require("./prepare-server");
 const serve_static_1 = require("./serve-static");
 const stitch_frames_to_video_1 = require("./stitch-frames-to-video");
 const tmp_dir_1 = require("./tmp-dir");
@@ -32,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");
@@ -55,10 +55,8 @@ exports.RenderInternals = {
     normalizeServeUrl: normalize_serve_url_1.normalizeServeUrl,
     spawnFfmpeg: stitch_frames_to_video_1.spawnFfmpeg,
     getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
-    makeAssetsDownloadTmpDir: make_assets_download_dir_1.makeAssetsDownloadTmpDir,
     tmpDir: tmp_dir_1.tmpDir,
     deleteDirectory: delete_directory_1.deleteDirectory,
-    prepareServer: prepare_server_1.prepareServer,
     isServeUrl: is_serve_url_1.isServeUrl,
     ensureOutputDirectory: ensure_output_directory_1.ensureOutputDirectory,
     getRealFrameRange: get_frame_to_render_1.getRealFrameRange,

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

@@ -0,0 +1,11 @@
+import { FfmpegExecutable } from 'remotion';
+export declare type LastFrameOptions = {
+    ffmpegExecutable: 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-video-server.d.ts

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

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, downloadDir, onDownload, onError, }) => {
     return (req, res) => {
         if (!req.url) {
             throw new Error('Request came in without URL');
@@ -35,14 +35,15 @@ const startOffthreadVideoServer = (ffmpegExecutable, downloadDir, onDownload, on
         res.setHeader('access-control-allow-origin', '*');
         res.setHeader('content-type', 'image/jpg');
         const { src, time } = (0, exports.extractUrlAndSourceFromUrl)(req.url);
+        const to = (0, download_and_map_assets_to_file_1.getSanitizedFilenameForAssetUrl)({ downloadDir, src });
         (0, download_and_map_assets_to_file_1.startDownloadForSrc)({ src, downloadDir, onDownload }).catch((err) => {
             onError(new Error(`Error while downloading asset: ${err.stack}`));
         });
-        (0, download_and_map_assets_to_file_1.waitForAssetToBeDownloaded)(src)
-            .then((newSrc) => {
+        (0, download_and_map_assets_to_file_1.waitForAssetToBeDownloaded)(src, to)
+            .then(() => {
             return (0, extract_frame_from_video_1.extractFrameFromVideo)({
                 time,
-                src: newSrc,
+                src: to,
                 ffmpegExecutable,
             });
         })

package/dist/open-browser.d.ts

@@ -10,9 +10,9 @@ export declare type ChromiumOptions = {
 };
 export declare const killAllBrowsers: () => Promise<void>;
 export declare const openBrowser: (browser: Browser, options?: {
-    shouldDumpIo?: boolean | undefined;
-    browserExecutable?: string | null | undefined;
-    chromiumOptions?: ChromiumOptions | undefined;
-    forceDeviceScaleFactor?: number | undefined;
-} | undefined) => Promise<puppeteer.Browser>;
+    shouldDumpIo?: boolean;
+    browserExecutable?: string | null;
+    chromiumOptions?: ChromiumOptions;
+    forceDeviceScaleFactor?: number;
+}) => Promise<puppeteer.Browser>;
 export {};

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, }: {
+export declare const prepareServer: ({ downloadDir, ffmpegExecutable, onDownload, onError, webpackConfigOrServeUrl, port, }: {
     webpackConfigOrServeUrl: string;
     downloadDir: string;
     onDownload: RenderMediaOnDownload;
     onError: (err: Error) => void;
     ffmpegExecutable: FfmpegExecutable;
+    port: number | null;
 }) => Promise<{
     serveUrl: string;
     closeServer: () => Promise<unknown>;