@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/mime-types.d.ts

@@ -0,0 +1,3 @@
+export declare const getExt: (contentType: string) => string | null;
+export declare function mimeLookup(path: string): string | false;
+export declare function mimeContentType(str: string): false | string;

package/package/dist/mime-types.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExt = void 0;
+exports.mimeLookup = mimeLookup;
+exports.mimeContentType = mimeContentType;
+const node_path_1 = require("node:path");
+const mime_db_1 = require("./mime-db");
+const extensions = {};
+const types = {};
+// Populate the extensions/types maps
+populateMaps(extensions, {});
+const getExt = (contentType) => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = mime_db_1.mimeDb[contentType.toLowerCase()]) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : null;
+};
+exports.getExt = getExt;
+function mimeLookup(path) {
+    if (!path || typeof path !== 'string') {
+        return false;
+    }
+    // get the extension ("ext" or ".ext" or full path)
+    const ext = (0, node_path_1.extname)('.' + path)
+        .toLowerCase()
+        .substr(1);
+    if (!ext) {
+        return false;
+    }
+    return types[ext] || false;
+}
+/**
+ * Populate the extensions and types maps.
+ * @private
+ */
+function populateMaps(exts, _types) {
+    // source preference (least -> most)
+    const preference = ['nginx', 'apache', undefined, 'iana'];
+    Object.keys(mime_db_1.mimeDb).forEach((type) => {
+        const mime = mime_db_1.mimeDb[type];
+        const _exts = mime.extensions;
+        if (!(_exts === null || _exts === void 0 ? void 0 : _exts.length)) {
+            return;
+        }
+        // mime -> extensions
+        exts[type] = _exts;
+        // extension -> mime
+        for (let i = 0; i < _exts.length; i++) {
+            const _ext = _exts[i];
+            if (_types[_ext]) {
+                const from = preference.indexOf(mime_db_1.mimeDb[_types[_ext]].source);
+                const to = preference.indexOf(mime.source);
+                if (_types[_ext] !== 'application/octet-stream' &&
+                    (from > to ||
+                        (from === to && _types[_ext].substr(0, 12) === 'application/'))) {
+                    // skip the remapping
+                    continue;
+                }
+            }
+            // set the extension -> mime
+            types[_ext] = type;
+        }
+    });
+}
+function mimeContentType(str) {
+    if (!str || typeof str !== 'string') {
+        return false;
+    }
+    let mime = str.indexOf('/') === -1 ? mimeLookup(str) : str;
+    if (!mime) {
+        return false;
+    }
+    if (mime.indexOf('charset') === -1) {
+        const _charset = charset(mime);
+        if (_charset)
+            mime += '; charset=' + _charset.toLowerCase();
+    }
+    return mime;
+}
+const EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+const TEXT_TYPE_REGEXP = /^text\//i;
+function charset(type) {
+    if (!type || typeof type !== 'string') {
+        return false;
+    }
+    const match = EXTRACT_TYPE_REGEXP.exec(type);
+    const mime = match && mime_db_1.mimeDb[match[1].toLowerCase()];
+    if (mime === null || mime === void 0 ? void 0 : mime.charset) {
+        return mime.charset;
+    }
+    // default text/* to utf-8
+    if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+        return 'UTF-8';
+    }
+    return false;
+}

package/package/dist/mux-video-and-audio.d.ts

@@ -0,0 +1,15 @@
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+export declare const muxVideoAndAudio: ({ videoOutput, audioOutput, output, indent, logLevel, onProgress, binariesDirectory, fps, cancelSignal, addFaststart, metadata, }: {
+    videoOutput: string | null;
+    audioOutput: string | null;
+    output: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    fps: number;
+    onProgress: (p: number) => void;
+    cancelSignal: CancelSignal | undefined;
+    addFaststart: boolean;
+    metadata?: Record<string, string> | null;
+}) => Promise<void>;

package/package/dist/mux-video-and-audio.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.muxVideoAndAudio = void 0;
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const logger_1 = require("./logger");
+const make_metadata_args_1 = require("./make-metadata-args");
+const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
+const truthy_1 = require("./truthy");
+const muxVideoAndAudio = async ({ videoOutput, audioOutput, output, indent, logLevel, onProgress, binariesDirectory, fps, cancelSignal, addFaststart, metadata, }) => {
+    var _a;
+    const startTime = Date.now();
+    logger_1.Log.verbose({ indent, logLevel }, 'Muxing video and audio together');
+    const command = [
+        '-hide_banner',
+        videoOutput ? '-i' : null,
+        videoOutput,
+        audioOutput ? '-i' : null,
+        audioOutput,
+        videoOutput ? '-c:v' : null,
+        videoOutput ? 'copy' : null,
+        audioOutput ? '-c:a' : null,
+        audioOutput ? 'copy' : null,
+        addFaststart ? '-movflags' : null,
+        addFaststart ? 'faststart' : null,
+        ...(0, make_metadata_args_1.makeMetadataArgs)(metadata !== null && metadata !== void 0 ? metadata : {}),
+        '-y',
+        output,
+    ].filter(truthy_1.truthy);
+    logger_1.Log.verbose({ indent, logLevel }, 'Combining command: ', command);
+    const task = (0, call_ffmpeg_1.callFf)({
+        bin: 'ffmpeg',
+        args: command,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+    });
+    (_a = task.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+        const utf8 = data.toString('utf8');
+        const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(utf8, fps);
+        if (parsed === undefined) {
+            if (!utf8.includes('Estimating duration from bitrate, this may be inaccurate')) {
+                logger_1.Log.verbose({ indent, logLevel }, utf8);
+            }
+        }
+        else {
+            logger_1.Log.verbose({ indent, logLevel }, `Combined ${parsed} frames`);
+            onProgress(parsed);
+        }
+    });
+    await task;
+    logger_1.Log.verbose({ indent, logLevel }, `Muxing done in ${Date.now() - startTime}ms`);
+};
+exports.muxVideoAndAudio = muxVideoAndAudio;

package/package/dist/next-frame-to-render.d.ts

@@ -0,0 +1,11 @@
+export declare const nextFrameToRenderState: ({ allFramesAndExtraFrames, concurrencyOrFramesToRender: _concurrency, }: {
+    allFramesAndExtraFrames: number[];
+    concurrencyOrFramesToRender: number;
+}) => {
+    getNextFrame: (_pageIndex: number) => number;
+    returnFrame: (frame: number) => void;
+};
+type Fn = typeof nextFrameToRenderState;
+export type NextFrameToRender = ReturnType<Fn>;
+export declare const partitionedNextFrameToRenderState: Fn;
+export {};

package/package/dist/next-frame-to-render.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partitionedNextFrameToRenderState = exports.nextFrameToRenderState = void 0;
+const render_partitions_1 = require("./render-partitions");
+const nextFrameToRenderState = ({ allFramesAndExtraFrames, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+concurrencyOrFramesToRender: _concurrency, }) => {
+    const rendered = new Map();
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        getNextFrame: (_pageIndex) => {
+            const nextFrame = allFramesAndExtraFrames.find((frame) => {
+                return !rendered.has(frame);
+            });
+            if (nextFrame === undefined) {
+                throw new Error('No more frames to render');
+            }
+            rendered.set(nextFrame, true);
+            return nextFrame;
+        },
+        returnFrame: (frame) => {
+            rendered.delete(frame);
+        },
+    };
+};
+exports.nextFrameToRenderState = nextFrameToRenderState;
+const partitionedNextFrameToRenderState = ({ allFramesAndExtraFrames, concurrencyOrFramesToRender: concurrency, }) => {
+    const partitions = (0, render_partitions_1.renderPartitions)({
+        frames: allFramesAndExtraFrames,
+        concurrency,
+    });
+    return {
+        getNextFrame: (pageIndex) => {
+            return partitions.getNextFrame(pageIndex);
+        },
+        returnFrame: () => {
+            throw new Error('retrying failed frames for partitioned rendering is not supported. Disable partitioned rendering.');
+        },
+    };
+};
+exports.partitionedNextFrameToRenderState = partitionedNextFrameToRenderState;

package/package/dist/normalize-serve-url.d.ts

@@ -0,0 +1 @@
+export declare const normalizeServeUrl: (unnormalized: string) => string;

package/package/dist/normalize-serve-url.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeServeUrl = void 0;
+const normalizeServeUrl = (unnormalized) => {
+    const hasQuery = unnormalized.includes('?');
+    if (hasQuery) {
+        return (0, exports.normalizeServeUrl)(unnormalized.substr(0, unnormalized.indexOf('?')));
+    }
+    const endsInIndexHtml = unnormalized.endsWith('index.html');
+    if (endsInIndexHtml) {
+        return unnormalized;
+    }
+    // Ends with slash
+    if (unnormalized.endsWith('/')) {
+        return `${unnormalized}index.html`;
+    }
+    return `${unnormalized}/index.html`;
+};
+exports.normalizeServeUrl = normalizeServeUrl;

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

@@ -0,0 +1,51 @@
+import type { RequestListener } from 'node:http';
+import type { DownloadMap } from './assets/download-map';
+import type { Compositor } from './compositor/compositor';
+import type { LogLevel } from './log-level';
+export declare const extractUrlAndSourceFromUrl: (url: string) => {
+    src: string;
+    time: number;
+    transparent: boolean;
+    toneMapped: boolean;
+};
+export declare const startOffthreadVideoServer: ({ downloadMap, logLevel, indent, offthreadVideoCacheSizeInBytes, binariesDirectory, offthreadVideoThreads, }: {
+    downloadMap: DownloadMap;
+    offthreadVideoCacheSizeInBytes: number | null;
+    offthreadVideoThreads: number;
+    logLevel: LogLevel;
+    indent: boolean;
+    binariesDirectory: string | null;
+}) => {
+    listener: RequestListener;
+    close: () => Promise<void>;
+    compositor: Compositor;
+};
+type DownloadEventPayload = {
+    src: string;
+};
+type ProgressEventPayload = {
+    percent: number | null;
+    downloaded: number;
+    totalSize: number | null;
+    src: string;
+};
+type EventMap = {
+    progress: ProgressEventPayload;
+    download: DownloadEventPayload;
+};
+export type EventTypes = keyof EventMap;
+export type CallbackListener<T extends EventTypes> = (data: {
+    detail: EventMap[T];
+}) => void;
+type Listeners = {
+    [EventType in EventTypes]: CallbackListener<EventType>[];
+};
+export declare class OffthreadVideoServerEmitter {
+    listeners: Listeners;
+    addEventListener<Q extends EventTypes>(name: Q, callback: CallbackListener<Q>): () => void;
+    removeEventListener<Q extends EventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    private dispatchEvent;
+    dispatchDownloadProgress(src: string, percent: number | null, downloaded: number, totalSize: number | null): void;
+    dispatchDownload(src: string): void;
+}
+export {};

package/package/dist/offthread-video-server.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffthreadVideoServerEmitter = exports.startOffthreadVideoServer = exports.extractUrlAndSourceFromUrl = void 0;
+const node_url_1 = require("node:url");
+const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
+const compositor_1 = require("./compositor/compositor");
+const log_level_1 = require("./log-level");
+const logger_1 = require("./logger");
+const offthreadvideo_cache_size_1 = require("./options/offthreadvideo-cache-size");
+const extractUrlAndSourceFromUrl = (url) => {
+    const parsed = new URL(url, 'http://localhost');
+    const query = parsed.search;
+    if (!query.trim()) {
+        throw new Error('Expected query from ' + url);
+    }
+    const params = new node_url_1.URLSearchParams(query);
+    const src = params.get('src');
+    if (!src) {
+        throw new Error('Did not pass `src` parameter');
+    }
+    const time = params.get('time');
+    if (!time) {
+        throw new Error('Did not get `time` parameter');
+    }
+    const transparent = params.get('transparent');
+    const toneMapped = params.get('toneMapped');
+    if (!toneMapped) {
+        throw new Error('Did not get `toneMapped` parameter');
+    }
+    return {
+        src,
+        time: parseFloat(time),
+        transparent: transparent === 'true',
+        toneMapped: toneMapped === 'true',
+    };
+};
+exports.extractUrlAndSourceFromUrl = extractUrlAndSourceFromUrl;
+const REQUEST_CLOSED_TOKEN = 'Request closed';
+const startOffthreadVideoServer = ({ downloadMap, logLevel, indent, offthreadVideoCacheSizeInBytes, binariesDirectory, offthreadVideoThreads, }) => {
+    (0, offthreadvideo_cache_size_1.validateOffthreadVideoCacheSizeInBytes)(offthreadVideoCacheSizeInBytes);
+    const compositor = (0, compositor_1.startCompositor)({
+        type: 'StartLongRunningProcess',
+        payload: {
+            concurrency: offthreadVideoThreads,
+            maximum_frame_cache_size_in_bytes: offthreadVideoCacheSizeInBytes,
+            verbose: (0, log_level_1.isEqualOrBelowLogLevel)(logLevel, 'verbose'),
+        },
+        logLevel,
+        indent,
+        binariesDirectory,
+    });
+    return {
+        close: async () => {
+            // Note: This is being used as a promise:
+            //     .close().then()
+            // but if finishCommands() fails, it acts like a sync function,
+            // therefore we have to catch an error and put a promise rejection
+            try {
+                await compositor.finishCommands();
+                return compositor.waitForDone();
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        },
+        listener: (req, response) => {
+            if (!req.url) {
+                throw new Error('Request came in without URL');
+            }
+            if (!req.url.startsWith('/proxy')) {
+                response.writeHead(404);
+                response.end();
+                return;
+            }
+            const { src, time, transparent, toneMapped } = (0, exports.extractUrlAndSourceFromUrl)(req.url);
+            response.setHeader('access-control-allow-origin', '*');
+            // Prevent caching of the response and excessive disk writes
+            // https://github.com/remotion-dev/remotion/issues/2760
+            response.setHeader('cache-control', 'no-cache, no-store, must-revalidate');
+            // Handling this case on Lambda:
+            // https://support.google.com/chrome/a/answer/7679408?hl=en
+            // Chrome sends Private Network Access preflights for subresources
+            if (req.method === 'OPTIONS') {
+                response.statusCode = 200;
+                if (req.headers['access-control-request-private-network']) {
+                    response.setHeader('Access-Control-Allow-Private-Network', 'true');
+                }
+                response.end();
+                return;
+            }
+            let closed = false;
+            req.on('close', () => {
+                closed = true;
+            });
+            let extractStart = Date.now();
+            (0, download_and_map_assets_to_file_1.downloadAsset)({
+                src,
+                downloadMap,
+                indent,
+                logLevel,
+                binariesDirectory,
+                cancelSignalForAudioAnalysis: undefined,
+                shouldAnalyzeAudioImmediately: true,
+                audioStreamIndex: undefined,
+            })
+                .then((to) => {
+                return new Promise((resolve, reject) => {
+                    if (closed) {
+                        reject(Error(REQUEST_CLOSED_TOKEN));
+                        return;
+                    }
+                    extractStart = Date.now();
+                    compositor
+                        .executeCommand('ExtractFrame', {
+                        src: to,
+                        original_src: src,
+                        time,
+                        transparent,
+                        tone_mapped: toneMapped,
+                    })
+                        .then(resolve)
+                        .catch(reject);
+                });
+            })
+                .then((readable) => {
+                return new Promise((resolve, reject) => {
+                    if (closed) {
+                        reject(Error(REQUEST_CLOSED_TOKEN));
+                        return;
+                    }
+                    if (!readable) {
+                        reject(new Error('no readable from compositor'));
+                        return;
+                    }
+                    const extractEnd = Date.now();
+                    const timeToExtract = extractEnd - extractStart;
+                    if (timeToExtract > 1000) {
+                        logger_1.Log.verbose({ indent, logLevel }, `Took ${timeToExtract}ms to extract frame from ${src} at ${time}`);
+                    }
+                    const firstByte = readable.at(0);
+                    const secondByte = readable.at(1);
+                    const thirdByte = readable.at(2);
+                    const isPng = firstByte === 0x89 && secondByte === 0x50 && thirdByte === 0x4e;
+                    const isBmp = firstByte === 0x42 && secondByte === 0x4d;
+                    if (isPng) {
+                        response.setHeader('content-type', `image/png`);
+                        response.setHeader('content-length', readable.byteLength);
+                    }
+                    else if (isBmp) {
+                        response.setHeader('content-type', `image/bmp`);
+                        response.setHeader('content-length', readable.byteLength);
+                    }
+                    else {
+                        reject(new Error(`Unknown file type: ${firstByte} ${secondByte} ${thirdByte}`));
+                        return;
+                    }
+                    response.writeHead(200);
+                    response.write(readable, (err) => {
+                        response.end();
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            })
+                .catch((err) => {
+                logger_1.Log.error({ indent, logLevel }, 'Could not extract frame from compositor', err);
+                if (!response.headersSent) {
+                    response.writeHead(500);
+                    response.write(JSON.stringify({ error: err.stack }));
+                }
+                response.end();
+            });
+        },
+        compositor,
+    };
+};
+exports.startOffthreadVideoServer = startOffthreadVideoServer;
+class OffthreadVideoServerEmitter {
+    constructor() {
+        this.listeners = {
+            progress: [],
+            download: [],
+        };
+    }
+    addEventListener(name, callback) {
+        this.listeners[name].push(callback);
+        return () => {
+            this.removeEventListener(name, callback);
+        };
+    }
+    removeEventListener(name, callback) {
+        this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
+    }
+    dispatchEvent(dispatchName, context) {
+        this.listeners[dispatchName].forEach((callback) => {
+            callback({ detail: context });
+        });
+    }
+    dispatchDownloadProgress(src, percent, downloaded, totalSize) {
+        this.dispatchEvent('progress', {
+            downloaded,
+            percent,
+            totalSize,
+            src,
+        });
+    }
+    dispatchDownload(src) {
+        this.dispatchEvent('download', {
+            src,
+        });
+    }
+}
+exports.OffthreadVideoServerEmitter = OffthreadVideoServerEmitter;

package/package/dist/open-browser.d.ts

@@ -0,0 +1,47 @@
+import type { NoReactInternals } from 'remotion/no-react';
+import type { Browser } from './browser';
+import type { HeadlessBrowser } from './browser/Browser';
+import type { Viewport } from './browser/PuppeteerViewport';
+import { type LogLevel } from './log-level';
+import type { ChromeMode } from './options/chrome-mode';
+import type { validOpenGlRenderers } from './options/gl';
+import type { ToOptions } from './options/option';
+import type { optionsMap } from './options/options-map';
+type OpenGlRenderer = (typeof validOpenGlRenderers)[number];
+type OnlyV4Options = typeof NoReactInternals.ENABLE_V5_BREAKING_CHANGES extends true ? {} : {
+    /**
+     * @deprecated - Will be removed in v5.
+     * Chrome Headless shell does not allow disabling headless mode anymore.
+     */
+    headless?: boolean;
+};
+export type ChromiumOptions = {
+    ignoreCertificateErrors?: boolean;
+    disableWebSecurity?: boolean;
+    gl?: OpenGlRenderer | null;
+    userAgent?: string | null;
+    enableMultiProcessOnLinux?: boolean;
+} & OnlyV4Options;
+type InternalOpenBrowserOptions = {
+    browserExecutable: string | null;
+    chromiumOptions: ChromiumOptions;
+    forceDeviceScaleFactor: number | undefined;
+    viewport: Viewport | null;
+    indent: boolean;
+    browser: Browser;
+} & ToOptions<typeof optionsMap.openBrowser>;
+type LogOptions = typeof NoReactInternals.ENABLE_V5_BREAKING_CHANGES extends true ? {
+    logLevel?: LogLevel;
+} : {
+    shouldDumpIo?: boolean;
+    logLevel?: LogLevel;
+};
+export type OpenBrowserOptions = {
+    browserExecutable?: string | null;
+    chromiumOptions?: ChromiumOptions;
+    chromeMode?: ChromeMode;
+    forceDeviceScaleFactor?: number;
+} & LogOptions;
+export declare const internalOpenBrowser: ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, viewport, logLevel, onBrowserDownload, chromeMode, }: InternalOpenBrowserOptions) => Promise<HeadlessBrowser>;
+export declare const openBrowser: (browser: Browser, options?: OpenBrowserOptions) => Promise<HeadlessBrowser>;
+export {};