@remotion/renderer 4.0.357 → 4.0.358

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

@@ -0,0 +1,2 @@
+import type { FrameRange } from './frame-range';
+export declare const getRealFrameRange: (durationInFrames: number, frameRange: FrameRange | null) => [number, number];

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRealFrameRange = void 0;
+const getRealFrameRange = (durationInFrames, frameRange) => {
+    if (frameRange === null) {
+        return [0, durationInFrames - 1];
+    }
+    if (typeof frameRange === 'number') {
+        if (frameRange < 0 || frameRange >= durationInFrames) {
+            throw new Error(`Frame number is out of range, must be between 0 and ${durationInFrames - 1} but got ${frameRange}`);
+        }
+        return [frameRange, frameRange];
+    }
+    if (frameRange[1] >= durationInFrames || frameRange[0] < 0) {
+        throw new Error(`The "durationInFrames" of the <Composition /> was evaluated to be ${durationInFrames}, but frame range ${frameRange.join('-')} is not inbetween 0-${durationInFrames - 1}`);
+    }
+    return frameRange;
+};
+exports.getRealFrameRange = getRealFrameRange;

package/package/dist/get-local-browser-executable.d.ts

@@ -0,0 +1,9 @@
+import type { BrowserExecutable } from './browser-executable';
+import type { LogLevel } from './log-level';
+import type { ChromeMode } from './options/chrome-mode';
+export declare const getLocalBrowserExecutable: ({ preferredBrowserExecutable, logLevel, indent, chromeMode, }: {
+    preferredBrowserExecutable: BrowserExecutable;
+    logLevel: LogLevel;
+    indent: boolean;
+    chromeMode: ChromeMode;
+}) => string;

package/package/dist/get-local-browser-executable.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.getLocalBrowserExecutable = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const BrowserFetcher_1 = require("./browser/BrowserFetcher");
+const logger_1 = require("./logger");
+const getBrowserStatus = ({ browserExecutablePath, indent, logLevel, chromeMode, }) => {
+    if (browserExecutablePath) {
+        if (!node_fs_1.default.existsSync(browserExecutablePath)) {
+            logger_1.Log.warn({ indent, logLevel }, `Browser executable was specified as '${browserExecutablePath}' but the path doesn't exist.`);
+        }
+        return { path: browserExecutablePath, type: 'user-defined-path' };
+    }
+    const revision = (0, BrowserFetcher_1.getRevisionInfo)(chromeMode);
+    if (revision.local && node_fs_1.default.existsSync(revision.executablePath)) {
+        return { path: revision.executablePath, type: 'local-puppeteer-browser' };
+    }
+    return { type: 'no-browser' };
+};
+const getLocalBrowserExecutable = ({ preferredBrowserExecutable, logLevel, indent, chromeMode, }) => {
+    const status = getBrowserStatus({
+        browserExecutablePath: preferredBrowserExecutable,
+        indent,
+        logLevel,
+        chromeMode,
+    });
+    if (status.type === 'no-browser') {
+        throw new TypeError('No browser found for rendering frames! Please open a GitHub issue and describe ' +
+            'how you reached this error: https://remotion.dev/issue');
+    }
+    return status.path;
+};
+exports.getLocalBrowserExecutable = getLocalBrowserExecutable;

package/package/dist/get-port.d.ts

@@ -0,0 +1,15 @@
+type PortStatus = 'available' | 'unavailable';
+export declare const testPortAvailableOnMultipleHosts: ({ hosts, port, }: {
+    port: number;
+    hosts: string[];
+}) => Promise<PortStatus>;
+export declare const getDesiredPort: ({ desiredPort, from, hostsToTry, to, }: {
+    desiredPort: number | undefined;
+    from: number;
+    to: number;
+    hostsToTry: string[];
+}) => Promise<{
+    port: number;
+    unlockPort: () => void;
+}>;
+export {};

package/package/dist/get-port.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDesiredPort = exports.testPortAvailableOnMultipleHosts = void 0;
+const net_1 = __importDefault(require("net"));
+const locks_1 = require("./locks");
+const isPortAvailableOnHost = ({ portToTry, host, }) => {
+    return new Promise((resolve) => {
+        let status = 'unavailable';
+        const socket = new net_1.default.Socket();
+        socket.on('connect', () => {
+            status = 'unavailable';
+            socket.destroy();
+        });
+        socket.setTimeout(3000);
+        socket.on('timeout', () => {
+            status = 'unavailable';
+            socket.destroy();
+            resolve(status);
+        });
+        socket.on('error', () => {
+            status = 'available';
+        });
+        socket.on('close', () => resolve(status));
+        socket.connect(portToTry, host);
+    });
+};
+const testPortAvailableOnMultipleHosts = async ({ hosts, port, }) => {
+    const results = await Promise.all(hosts.map((host) => {
+        return isPortAvailableOnHost({ portToTry: port, host });
+    }));
+    return results.every((r) => r === 'available') ? 'available' : 'unavailable';
+};
+exports.testPortAvailableOnMultipleHosts = testPortAvailableOnMultipleHosts;
+const getPort = async ({ from, to, hostsToTest, }) => {
+    const ports = makeRange(from, to);
+    for (const port of ports) {
+        if ((await (0, exports.testPortAvailableOnMultipleHosts)({
+            port,
+            hosts: hostsToTest,
+        })) === 'available') {
+            return port;
+        }
+    }
+    throw new Error('No available ports found');
+};
+const portLocks = (0, locks_1.createLock)({ timeout: 10000 });
+const getDesiredPort = async ({ desiredPort, from, hostsToTry, to, }) => {
+    await portLocks.waitForAllToBeDone();
+    const lockPortSelection = portLocks.lock();
+    const unlockPort = () => portLocks.unlock(lockPortSelection);
+    if (typeof desiredPort !== 'undefined' &&
+        (await (0, exports.testPortAvailableOnMultipleHosts)({
+            port: desiredPort,
+            hosts: hostsToTry,
+        })) === 'available') {
+        return { port: desiredPort, unlockPort };
+    }
+    const actualPort = await getPort({ from, to, hostsToTest: hostsToTry });
+    // If did specify a port but did not get that one, fail hard.
+    if (desiredPort && desiredPort !== actualPort) {
+        unlockPort();
+        throw new Error(`You specified port ${desiredPort} to be used for the HTTP server, but it is not available. Choose a different port or remove the setting to let Remotion automatically select a free port.`);
+    }
+    return { port: actualPort, unlockPort };
+};
+exports.getDesiredPort = getDesiredPort;
+const makeRange = (from, to) => {
+    if (!Number.isInteger(from) || !Number.isInteger(to)) {
+        throw new TypeError('`from` and `to` must be integer numbers');
+    }
+    if (from < 1024 || from > 65535) {
+        throw new RangeError('`from` must be between 1024 and 65535');
+    }
+    if (to < 1024 || to > 65536) {
+        throw new RangeError('`to` must be between 1024 and 65536');
+    }
+    if (to < from) {
+        throw new RangeError('`to` must be greater than or equal to `from`');
+    }
+    return new Array(to - from + 1).fill(true).map((_, i) => {
+        return i + from;
+    });
+};

package/package/dist/get-prores-profile-name.d.ts

@@ -0,0 +1,3 @@
+import type { Codec } from './codec';
+import type { ProResProfile } from './prores-profile';
+export declare const getProResProfileName: (codec: Codec, proResProfile: ProResProfile | undefined) => string | null;

package/package/dist/get-prores-profile-name.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProResProfileName = void 0;
+const getProResProfileName = (codec, proResProfile) => {
+    if (codec !== 'prores') {
+        return null;
+    }
+    switch (proResProfile) {
+        case '4444-xq':
+            return '5';
+        case '4444':
+            return '4';
+        case 'hq':
+            return '3';
+        case 'standard':
+            return '2';
+        case 'light':
+            return '1';
+        case 'proxy':
+            return '0';
+        default:
+            return '3';
+    }
+};
+exports.getProResProfileName = getProResProfileName;

package/package/dist/get-silent-parts.d.ts

@@ -0,0 +1,10 @@
+import type { GetSilentPartsResponse, SilentPart } from './compositor/payloads';
+import type { LogLevel } from './log-level';
+export type { SilentPart };
+export declare const getSilentParts: ({ src, noiseThresholdInDecibels: passedNoiseThresholdInDecibels, minDurationInSeconds: passedMinDuration, logLevel, binariesDirectory, }: {
+    src: string;
+    minDurationInSeconds?: number;
+    logLevel?: LogLevel;
+    noiseThresholdInDecibels?: number;
+    binariesDirectory?: string | null;
+}) => Promise<GetSilentPartsResponse>;

package/package/dist/get-silent-parts.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSilentParts = void 0;
+const compositor_1 = require("./compositor/compositor");
+/*
+ * @description Gets the silent parts of a video or audio in Node.js. Useful for cutting out silence from a video.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-silent-parts)
+ */
+const getSilentParts = async ({ src, noiseThresholdInDecibels: passedNoiseThresholdInDecibels, minDurationInSeconds: passedMinDuration, logLevel, binariesDirectory, }) => {
+    const compositor = (0, compositor_1.startLongRunningCompositor)({
+        maximumFrameCacheItemsInBytes: null,
+        logLevel: logLevel !== null && logLevel !== void 0 ? logLevel : 'info',
+        indent: false,
+        binariesDirectory: binariesDirectory !== null && binariesDirectory !== void 0 ? binariesDirectory : null,
+        extraThreads: 0,
+    });
+    const minDurationInSeconds = passedMinDuration !== null && passedMinDuration !== void 0 ? passedMinDuration : 1;
+    if (typeof minDurationInSeconds !== 'number') {
+        throw new Error(`minDurationInSeconds must be a number, but was ${minDurationInSeconds}`);
+    }
+    if (minDurationInSeconds <= 0) {
+        throw new Error(`minDurationInSeconds must be greater than 0, but was ${minDurationInSeconds}`);
+    }
+    const noiseThresholdInDecibels = passedNoiseThresholdInDecibels !== null && passedNoiseThresholdInDecibels !== void 0 ? passedNoiseThresholdInDecibels : -20;
+    if (typeof noiseThresholdInDecibels !== 'number') {
+        throw new Error(`noiseThresholdInDecibels must be a number, but was ${noiseThresholdInDecibels}`);
+    }
+    if (noiseThresholdInDecibels >= 30) {
+        throw new Error(`noiseThresholdInDecibels must be less than 30, but was ${noiseThresholdInDecibels}`);
+    }
+    const res = await compositor.executeCommand('GetSilences', {
+        src,
+        minDurationInSeconds,
+        noiseThresholdInDecibels,
+    });
+    const response = JSON.parse(new TextDecoder('utf-8').decode(res));
+    await compositor.finishCommands();
+    await compositor.waitForDone();
+    const { silentParts, durationInSeconds } = response;
+    return {
+        silentParts,
+        audibleParts: getAudibleParts({ silentParts, durationInSeconds }),
+        durationInSeconds,
+    };
+};
+exports.getSilentParts = getSilentParts;
+const getAudibleParts = ({ silentParts, durationInSeconds, }) => {
+    const audibleParts = [];
+    let lastEnd = 0;
+    for (const silentPart of silentParts) {
+        if (silentPart.startInSeconds - lastEnd > 0) {
+            audibleParts.push({
+                startInSeconds: lastEnd,
+                endInSeconds: silentPart.startInSeconds,
+            });
+        }
+        lastEnd = silentPart.endInSeconds;
+    }
+    if (durationInSeconds - lastEnd > 0) {
+        audibleParts.push({
+            startInSeconds: lastEnd,
+            endInSeconds: durationInSeconds,
+        });
+    }
+    return audibleParts;
+};

package/package/dist/get-video-metadata.d.ts

@@ -0,0 +1,10 @@
+import type { VideoMetadata } from './compositor/payloads';
+import type { LogLevel } from './log-level';
+export { VideoMetadata } from './compositor/payloads';
+/**
+ * @deprecated Use `parseMedia()` instead: https://www.remotion.dev/docs/media-parser/parse-media
+ */
+export declare const getVideoMetadata: (videoSource: string, options?: {
+    logLevel?: LogLevel;
+    binariesDirectory?: string | null;
+}) => Promise<VideoMetadata>;

package/package/dist/get-video-metadata.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoMetadata = void 0;
+const node_path_1 = require("node:path");
+const compositor_1 = require("./compositor/compositor");
+/**
+ * @deprecated Use `parseMedia()` instead: https://www.remotion.dev/docs/media-parser/parse-media
+ */
+const getVideoMetadata = async (videoSource, options) => {
+    var _a, _b;
+    const compositor = (0, compositor_1.startLongRunningCompositor)({
+        maximumFrameCacheItemsInBytes: null,
+        logLevel: (_a = options === null || options === void 0 ? void 0 : options.logLevel) !== null && _a !== void 0 ? _a : 'info',
+        indent: false,
+        binariesDirectory: (_b = options === null || options === void 0 ? void 0 : options.binariesDirectory) !== null && _b !== void 0 ? _b : null,
+        extraThreads: 0,
+    });
+    const metadataResponse = await compositor.executeCommand('GetVideoMetadata', {
+        src: (0, node_path_1.resolve)(process.cwd(), videoSource),
+    });
+    await compositor.finishCommands();
+    await compositor.waitForDone();
+    return JSON.parse(new TextDecoder('utf-8').decode(metadataResponse));
+};
+exports.getVideoMetadata = getVideoMetadata;

package/package/dist/get-video-threads-flag.d.ts

@@ -0,0 +1,2 @@
+import type { LogLevel } from './log-level';
+export declare const getIdealVideoThreadsFlag: (logLevel: LogLevel) => number;

package/package/dist/get-video-threads-flag.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdealVideoThreadsFlag = void 0;
+const get_cpu_count_1 = require("./get-cpu-count");
+const get_available_memory_1 = require("./memory/get-available-memory");
+const MEMORY_USAGE_PER_THREAD = 400000000; // 400MB
+const RESERVED_MEMORY = 2000000000;
+const getIdealVideoThreadsFlag = (logLevel) => {
+    const freeMemory = (0, get_available_memory_1.getAvailableMemory)(logLevel);
+    const cpus = (0, get_cpu_count_1.getCpuCount)();
+    const maxRecommendedBasedOnCpus = (cpus * 2) / 3;
+    const maxRecommendedBasedOnMemory = (freeMemory - RESERVED_MEMORY) / MEMORY_USAGE_PER_THREAD;
+    const maxRecommended = Math.min(maxRecommendedBasedOnCpus, maxRecommendedBasedOnMemory);
+    return Math.max(1, Math.round(maxRecommended));
+};
+exports.getIdealVideoThreadsFlag = getIdealVideoThreadsFlag;

package/package/dist/goto-page-or-throw.d.ts

@@ -0,0 +1,3 @@
+import type { Page } from './browser/BrowserPage';
+import type { HTTPResponse } from './browser/HTTPResponse';
+export declare const gotoPageOrThrow: (page: Page, urlToVisit: string, actualTimeout: number) => Promise<[HTTPResponse, null] | [null, Error]>;

package/package/dist/goto-page-or-throw.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gotoPageOrThrow = void 0;
+const gotoPageOrThrow = async (page, urlToVisit, actualTimeout) => {
+    try {
+        const pageRes = await page.goto({ url: urlToVisit, timeout: actualTimeout });
+        if (pageRes === null) {
+            return [null, new Error(`Visited "${urlToVisit}" but got no response.`)];
+        }
+        return [pageRes, null];
+    }
+    catch (err) {
+        return [null, err];
+    }
+};
+exports.gotoPageOrThrow = gotoPageOrThrow;

package/package/dist/guess-extension-for-media.d.ts

@@ -0,0 +1,9 @@
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+export declare const guessExtensionForVideo: ({ src, indent, logLevel, binariesDirectory, cancelSignal, }: {
+    src: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+}) => Promise<"mp3" | "wav" | "mp4" | "webm">;

package/package/dist/guess-extension-for-media.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessExtensionForVideo = void 0;
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const guessExtensionForVideo = async ({ src, indent, logLevel, binariesDirectory, cancelSignal, }) => {
+    const { stderr } = await (0, call_ffmpeg_1.callFf)({
+        bin: 'ffprobe',
+        args: [src],
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+    });
+    if (stderr.includes('Audio: mp3,')) {
+        return 'mp3';
+    }
+    if (stderr.includes('Video: vp9')) {
+        return 'webm';
+    }
+    if (stderr.includes('Video: vp8')) {
+        return 'webm';
+    }
+    if (stderr.includes('wav, ')) {
+        return 'wav';
+    }
+    if (stderr.includes('Video: h264')) {
+        return 'mp4';
+    }
+    throw new Error(`The media file "${src}" has no file extension and the format could not be guessed. Tips: a) Ensure this is a valid video or audio file b) Add a file extension to the URL like ".mp4" c) Set a "Content-Type" or "Content-Disposition" header if possible.`);
+};
+exports.guessExtensionForVideo = guessExtensionForVideo;

package/package/dist/image-format.d.ts

@@ -0,0 +1,13 @@
+import type { PixelFormat } from './pixel-format';
+export declare const validVideoImageFormats: readonly ["png", "jpeg", "none"];
+export declare const validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
+export type VideoImageFormat = (typeof validVideoImageFormats)[number];
+export type StillImageFormat = (typeof validStillImageFormats)[number];
+/**
+ * @deprecated Use VideoImageFormat or StillImageFormat instead
+ */
+export type ImageFormat = 'This type is deprecated, use VideoImageFormat or StillImageFormat instead';
+export declare const DEFAULT_VIDEO_IMAGE_FORMAT: VideoImageFormat;
+export declare const DEFAULT_STILL_IMAGE_FORMAT: StillImageFormat;
+export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat | undefined, videoImageFormat: VideoImageFormat) => "none" | "valid";
+export declare const validateStillImageFormat: (imageFormat: StillImageFormat) => void;

package/package/dist/image-format.js

@@ -0,0 +1,37 @@
+"use strict";
+// Keeping the default image format PNG if you don't pass a
+// value to the renderer for backwards compatibility.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStillImageFormat = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.DEFAULT_STILL_IMAGE_FORMAT = exports.DEFAULT_VIDEO_IMAGE_FORMAT = exports.validStillImageFormats = exports.validVideoImageFormats = void 0;
+exports.validVideoImageFormats = ['png', 'jpeg', 'none'];
+exports.validStillImageFormats = ['png', 'jpeg', 'pdf', 'webp'];
+exports.DEFAULT_VIDEO_IMAGE_FORMAT = 'jpeg';
+exports.DEFAULT_STILL_IMAGE_FORMAT = 'png';
+// By returning a value, we improve testability as we can specifically test certain branches
+const validateSelectedPixelFormatAndImageFormatCombination = (pixelFormat, videoImageFormat) => {
+    if (videoImageFormat === 'none') {
+        return 'none';
+    }
+    if (typeof pixelFormat === 'undefined') {
+        return 'valid';
+    }
+    if (!exports.validVideoImageFormats.includes(videoImageFormat)) {
+        throw new TypeError(`Value ${videoImageFormat} is not valid as an image format.`);
+    }
+    if (pixelFormat !== 'yuva420p' && pixelFormat !== 'yuva444p10le') {
+        return 'valid';
+    }
+    if (videoImageFormat !== 'png') {
+        throw new TypeError(`Pixel format was set to '${pixelFormat}' but the image format is not PNG. To render transparent videos, you need to set PNG as the image format.`);
+    }
+    return 'valid';
+};
+exports.validateSelectedPixelFormatAndImageFormatCombination = validateSelectedPixelFormatAndImageFormatCombination;
+const validateStillImageFormat = (imageFormat) => {
+    if (!exports.validStillImageFormats.includes(imageFormat)) {
+        throw new TypeError(String(`Image format should be one of: ${exports.validStillImageFormats
+            .map((v) => `"${v}"`)
+            .join(', ')}`));
+    }
+};
+exports.validateStillImageFormat = validateStillImageFormat;