@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/make-page.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePage = void 0;
+const get_available_memory_1 = require("./memory/get-available-memory");
+const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const set_props_and_env_1 = require("./set-props-and-env");
+const makePage = async ({ context, initialFrame, browserReplacer, logLevel, indent, pagesArray, onBrowserLog, scale, timeoutInMilliseconds, composition, proxyPort, serveUrl, muted, envVariables, serializedInputPropsWithCustomSchema, imageFormat, serializedResolvedPropsWithCustomSchema, pageIndex, isMainTab, mediaCacheSizeInBytes, onLog, }) => {
+    const page = await browserReplacer
+        .getBrowser()
+        .newPage({ context, logLevel, indent, pageIndex, onBrowserLog, onLog });
+    pagesArray.push(page);
+    await page.setViewport({
+        width: composition.width,
+        height: composition.height,
+        deviceScaleFactor: scale,
+    });
+    await (0, set_props_and_env_1.setPropsAndEnv)({
+        serializedInputPropsWithCustomSchema,
+        envVariables,
+        page,
+        serveUrl,
+        initialFrame,
+        timeoutInMilliseconds,
+        proxyPort,
+        retriesRemaining: 2,
+        audioEnabled: !muted,
+        videoEnabled: imageFormat !== 'none',
+        indent,
+        logLevel,
+        onServeUrlVisited: () => undefined,
+        isMainTab,
+        mediaCacheSizeInBytes,
+        initialMemoryAvailable: (0, get_available_memory_1.getAvailableMemory)(logLevel),
+    });
+    await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        // eslint-disable-next-line max-params
+        pageFunction: (id, props, durationInFrames, fps, height, width, defaultCodec, defaultOutName, defaultVideoImageFormat, defaultPixelFormat) => {
+            window.remotion_setBundleMode({
+                type: 'composition',
+                compositionName: id,
+                serializedResolvedPropsWithSchema: props,
+                compositionDurationInFrames: durationInFrames,
+                compositionFps: fps,
+                compositionHeight: height,
+                compositionWidth: width,
+                compositionDefaultCodec: defaultCodec,
+                compositionDefaultOutName: defaultOutName,
+                compositionDefaultVideoImageFormat: defaultVideoImageFormat,
+                compositionDefaultPixelFormat: defaultPixelFormat,
+            });
+        },
+        args: [
+            composition.id,
+            serializedResolvedPropsWithCustomSchema,
+            composition.durationInFrames,
+            composition.fps,
+            composition.height,
+            composition.width,
+            composition.defaultCodec,
+            composition.defaultOutName,
+            composition.defaultVideoImageFormat,
+            composition.defaultPixelFormat,
+        ],
+        frame: null,
+        page,
+        timeoutInMilliseconds,
+    });
+    return page;
+};
+exports.makePage = makePage;

package/package/dist/memory/from-docker-cgroup.d.ts

@@ -0,0 +1 @@
+export declare const getAvailableMemoryFromCgroup: () => number | null;

package/package/dist/memory/from-docker-cgroup.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableMemoryFromCgroup = void 0;
+const node_fs_1 = require("node:fs");
+const getMaxMemoryFromCgroupV2 = () => {
+    try {
+        const data = (0, node_fs_1.readFileSync)('/sys/fs/cgroup/memory.max', 'utf-8');
+        // If --memory=[num] flag of "docker run" is not set, the value will be "max"
+        if (data.trim() === 'max') {
+            return Infinity;
+        }
+        return parseInt(data, 10);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const getAvailableMemoryFromCgroupV2 = () => {
+    try {
+        const data = (0, node_fs_1.readFileSync)('/sys/fs/cgroup/memory.current', 'utf-8');
+        return parseInt(data, 10);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const getMaxMemoryFromCgroupV1 = () => {
+    try {
+        const data = (0, node_fs_1.readFileSync)('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'utf-8');
+        // If --memory=[num] flag of "docker run" is not set, the value will be "max"
+        if (data.trim() === 'max') {
+            return Infinity;
+        }
+        return parseInt(data, 10);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const getAvailableMemoryFromCgroupV1 = () => {
+    try {
+        const data = (0, node_fs_1.readFileSync)('/sys/fs/cgroup/memory/memory.usage_in_bytes', 'utf-8');
+        return parseInt(data, 10);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const getAvailableMemoryFromCgroup = () => {
+    const maxMemoryV2 = getMaxMemoryFromCgroupV2();
+    if (maxMemoryV2 !== null) {
+        const availableMemoryV2 = getAvailableMemoryFromCgroupV2();
+        if (availableMemoryV2 !== null) {
+            return maxMemoryV2 - availableMemoryV2;
+        }
+    }
+    const maxMemoryV1 = getMaxMemoryFromCgroupV1();
+    if (maxMemoryV1 !== null) {
+        const availableMemoryV1 = getAvailableMemoryFromCgroupV1();
+        if (availableMemoryV1 !== null) {
+            return maxMemoryV1 - availableMemoryV1;
+        }
+    }
+    return null;
+};
+exports.getAvailableMemoryFromCgroup = getAvailableMemoryFromCgroup;

package/package/dist/memory/from-lambda-env.d.ts

@@ -0,0 +1 @@
+export declare const getMaxLambdaMemory: () => number | null;

package/package/dist/memory/from-lambda-env.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxLambdaMemory = void 0;
+const getMaxLambdaMemory = () => {
+    if (process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE) {
+        return (parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE, 10) * 1024 * 1024);
+    }
+    return null;
+};
+exports.getMaxLambdaMemory = getMaxLambdaMemory;

package/package/dist/memory/from-proc-meminfo.d.ts

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

package/package/dist/memory/from-proc-meminfo.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFreeMemoryFromProcMeminfo = void 0;
+const node_fs_1 = require("node:fs");
+const logger_1 = require("../logger");
+const getFreeMemoryFromProcMeminfo = (logLevel) => {
+    if (!(0, node_fs_1.existsSync)('/proc/meminfo')) {
+        return null;
+    }
+    try {
+        const data = (0, node_fs_1.readFileSync)('/proc/meminfo', 'utf-8');
+        // Split the file by lines and find the line with MemFree
+        const lines = data.split('\n');
+        const memAvailableLine = lines.find((line) => line.startsWith('MemAvailable'));
+        // If we couldn't find MemAvailable, return an error
+        if (!memAvailableLine) {
+            throw new Error('MemAvailable not found in /proc/meminfo');
+        }
+        // Extract the value and unit from the line
+        const matches = memAvailableLine.match(/(\d+)\s+(\w+)/);
+        if (!matches || matches.length !== 3) {
+            throw new Error('Failed to parse MemAvailable value');
+        }
+        const value = parseInt(matches[1], 10);
+        const unit = matches[2].toLowerCase();
+        // Convert the value to bytes based on its unit
+        switch (unit) {
+            case 'kb':
+                return value * 1024;
+            case 'mb':
+                return value * 1024 * 1024;
+            case 'gb':
+                return value * 1024 * 1024 * 1024;
+            default:
+                throw new Error(`Unknown unit: ${unit}`);
+        }
+    }
+    catch (err) {
+        logger_1.Log.warn({ indent: false, logLevel }, '/proc/meminfo exists but failed to get memory info. Error:');
+        logger_1.Log.warn({ indent: false, logLevel }, err);
+        return null;
+    }
+};
+exports.getFreeMemoryFromProcMeminfo = getFreeMemoryFromProcMeminfo;

package/package/dist/memory/get-available-memory.d.ts

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

package/package/dist/memory/get-available-memory.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableMemory = void 0;
+const node_os_1 = require("node:os");
+const logger_1 = require("../logger");
+const from_docker_cgroup_1 = require("./from-docker-cgroup");
+const from_lambda_env_1 = require("./from-lambda-env");
+const from_proc_meminfo_1 = require("./from-proc-meminfo");
+const getAvailableMemory = (logLevel) => {
+    // If we are in Lambda, the most reliable way is to read the environment variable
+    // This is also pretty much free
+    const maxMemory = (0, from_lambda_env_1.getMaxLambdaMemory)();
+    if (maxMemory !== null) {
+        const nodeMemory = (0, node_os_1.freemem)();
+        return Math.min(nodeMemory, maxMemory);
+    }
+    // If cgroup memory data is available, we are in Docker, and we should respect it
+    const cgroupMemory = (0, from_docker_cgroup_1.getAvailableMemoryFromCgroup)();
+    if (cgroupMemory !== null) {
+        // There are 2 Docker memory configurations:
+        // 1. --memory=[num]
+        // 2. Global Docker memory limit
+        // If cgroup limit is higher than global memory, the global memory limit still applies
+        const nodeMemory = (0, node_os_1.freemem)();
+        const _procInfo = (0, from_proc_meminfo_1.getFreeMemoryFromProcMeminfo)(logLevel);
+        if (cgroupMemory > nodeMemory * 1.25 && Number.isFinite(cgroupMemory)) {
+            logger_1.Log.warn({ indent: false, logLevel }, 'Detected differing memory amounts:');
+            logger_1.Log.warn({ indent: false, logLevel }, `Memory reported by CGroup: ${(cgroupMemory / 1024 / 1024).toFixed(2)} MB`);
+            if (_procInfo !== null) {
+                logger_1.Log.warn({ indent: false, logLevel }, `Memory reported by /proc/meminfo: ${(_procInfo / 1024 / 1024).toFixed(2)} MB`);
+            }
+            logger_1.Log.warn({ indent: false, logLevel }, `Memory reported by Node: ${(nodeMemory / 1024 / 1024).toFixed(2)} MB`);
+            logger_1.Log.warn({ indent: false, logLevel }, 'You might have inadvertenly set the --memory flag of `docker run` to a value that is higher than the global Docker memory limit.');
+            logger_1.Log.warn({ indent: false, logLevel }, 'Using the lower amount of memory for calculation.');
+        }
+        return Math.min(nodeMemory, cgroupMemory);
+    }
+    const procInfo = (0, from_proc_meminfo_1.getFreeMemoryFromProcMeminfo)(logLevel);
+    if (procInfo !== null) {
+        return Math.min((0, node_os_1.freemem)(), procInfo);
+    }
+    return (0, node_os_1.freemem)();
+};
+exports.getAvailableMemory = getAvailableMemory;

package/package/dist/merge-audio-track.d.ts

@@ -0,0 +1,19 @@
+import type { DownloadMap } from './assets/download-map';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { PreprocessedAudioTrack } from './preprocess-audio-track';
+type Options = {
+    files: PreprocessedAudioTrack[];
+    outName: string;
+    downloadMap: DownloadMap;
+    remotionRoot: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    onProgress: (progress: number) => void;
+    fps: number;
+    chunkLengthInSeconds: number;
+};
+export declare const mergeAudioTrack: (options: Options) => Promise<void>;
+export {};

package/package/dist/merge-audio-track.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeAudioTrack = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const chunk_1 = require("./chunk");
+const create_ffmpeg_complex_filter_1 = require("./create-ffmpeg-complex-filter");
+const create_ffmpeg_merge_filter_1 = require("./create-ffmpeg-merge-filter");
+const create_silent_audio_1 = require("./create-silent-audio");
+const delete_directory_1 = require("./delete-directory");
+const logger_1 = require("./logger");
+const p_limit_1 = require("./p-limit");
+const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
+const tmp_dir_1 = require("./tmp-dir");
+const truthy_1 = require("./truthy");
+const mergeAudioTrackUnlimited = async ({ outName, files, downloadMap, remotionRoot, indent, logLevel, binariesDirectory, cancelSignal, onProgress, fps, chunkLengthInSeconds, }) => {
+    var _a;
+    if (files.length === 0) {
+        await (0, create_silent_audio_1.createSilentAudio)({
+            outName,
+            chunkLengthInSeconds,
+            indent,
+            logLevel,
+            binariesDirectory,
+            cancelSignal,
+        });
+        onProgress(1);
+        return;
+    }
+    // Previously a bug: We cannot optimize for files.length === 1 because we need to pad the audio
+    // 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');
+        try {
+            const partialProgress = new Array(chunked.length).fill(0);
+            let finalProgress = 0;
+            const callProgress = () => {
+                const totalProgress = partialProgress.reduce((a, b) => a + b, 0) / chunked.length;
+                const combinedProgress = totalProgress * 0.8 + finalProgress * 0.2;
+                onProgress(combinedProgress);
+            };
+            const chunkNames = await Promise.all(chunked.map(async (chunkFiles, i) => {
+                const chunkOutname = node_path_1.default.join(tempPath, `chunk-${i}.wav`);
+                await (0, exports.mergeAudioTrack)({
+                    files: chunkFiles,
+                    chunkLengthInSeconds,
+                    outName: chunkOutname,
+                    downloadMap,
+                    remotionRoot,
+                    indent,
+                    logLevel,
+                    binariesDirectory,
+                    cancelSignal,
+                    onProgress: (progress) => {
+                        partialProgress[i] = progress;
+                        callProgress();
+                    },
+                    fps,
+                });
+                return chunkOutname;
+            }));
+            await (0, exports.mergeAudioTrack)({
+                files: chunkNames.map((c) => ({
+                    filter: {
+                        pad_end: null,
+                        pad_start: null,
+                    },
+                    outName: c,
+                })),
+                outName,
+                downloadMap,
+                remotionRoot,
+                indent,
+                logLevel,
+                binariesDirectory,
+                cancelSignal,
+                onProgress: (progress) => {
+                    finalProgress = progress;
+                    callProgress();
+                },
+                fps,
+                chunkLengthInSeconds,
+            });
+            return;
+        }
+        finally {
+            (0, delete_directory_1.deleteDirectory)(tempPath);
+        }
+    }
+    const { complexFilterFlag: mergeFilter, cleanup, complexFilter, } = await (0, create_ffmpeg_complex_filter_1.createFfmpegComplexFilter)({
+        filters: files,
+        downloadMap,
+    });
+    const args = [
+        ['-hide_banner'],
+        ...files.map((f) => ['-i', f.outName]),
+        mergeFilter,
+        ['-c:a', 'pcm_s16le'],
+        ['-map', `[${create_ffmpeg_merge_filter_1.OUTPUT_FILTER_NAME}]`],
+        ['-y', outName],
+    ]
+        .filter(truthy_1.truthy)
+        .flat(2);
+    logger_1.Log.verbose({ indent, logLevel }, `Merging audio tracks`, 'Command:', `ffmpeg ${args.join(' ')}`, 'Complex filter script:', complexFilter);
+    const task = (0, call_ffmpeg_1.callFf)({
+        bin: 'ffmpeg',
+        args,
+        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) {
+            onProgress(parsed / (chunkLengthInSeconds * fps));
+        }
+    });
+    await task;
+    onProgress(1);
+    cleanup();
+};
+// Must be at least 3 because recursively called twice in mergeAudioTrack
+const limit = (0, p_limit_1.pLimit)(3);
+const mergeAudioTrack = (options) => {
+    return limit(mergeAudioTrackUnlimited, options);
+};
+exports.mergeAudioTrack = mergeAudioTrack;

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

@@ -0,0 +1,6 @@
+export declare const mimeDb: Record<string, {
+    source?: string;
+    charset?: string;
+    compressible?: boolean;
+    extensions?: string[];
+}>;