@remotion/renderer 4.0.356 → 4.0.358

package/package/dist/assets/download-file.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = void 0;
+const node_fs_1 = require("node:fs");
+const ensure_output_directory_1 = require("../ensure-output-directory");
+const logger_1 = require("../logger");
+const read_file_1 = require("./read-file");
+const incorrectContentLengthToken = 'Download finished with';
+const downloadFileWithoutRetries = ({ onProgress, url, to: toFn }) => {
+    return new Promise((resolve, reject) => {
+        let rejected = false;
+        let resolved = false;
+        let timeout;
+        const resolveAndFlag = (val) => {
+            resolved = true;
+            resolve(val);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        };
+        const rejectAndFlag = (err) => {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            reject(err);
+            rejected = true;
+        };
+        const refreshTimeout = () => {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            timeout = setTimeout(() => {
+                if (resolved) {
+                    return;
+                }
+                rejectAndFlag(new Error(`Tried to download file ${url}, but the server sent no data for 20 seconds`));
+            }, 20000);
+        };
+        refreshTimeout();
+        let finishEventSent = false;
+        let closeConnection = () => undefined;
+        (0, read_file_1.readFile)(url)
+            .then(({ response, request }) => {
+            var _a, _b;
+            closeConnection = () => {
+                request.destroy();
+                response.destroy();
+            };
+            const contentDisposition = (_a = response.headers['content-disposition']) !== null && _a !== void 0 ? _a : null;
+            const contentType = (_b = response.headers['content-type']) !== null && _b !== void 0 ? _b : null;
+            const to = toFn(contentDisposition, contentType);
+            (0, ensure_output_directory_1.ensureOutputDirectory)(to);
+            const sizeHeader = response.headers['content-length'];
+            const totalSize = typeof sizeHeader === 'undefined' ? null : Number(sizeHeader);
+            const writeStream = (0, node_fs_1.createWriteStream)(to);
+            let downloaded = 0;
+            // Listen to 'close' event instead of more
+            // concise method to avoid this problem
+            // https://github.com/remotion-dev/remotion/issues/384#issuecomment-844398183
+            writeStream.on('close', () => {
+                if (rejected) {
+                    return;
+                }
+                if (!finishEventSent) {
+                    onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                        downloaded,
+                        percent: 1,
+                        totalSize: downloaded,
+                    });
+                }
+                refreshTimeout();
+                return resolveAndFlag({ sizeInBytes: downloaded, to });
+            });
+            writeStream.on('error', (err) => rejectAndFlag(err));
+            response.on('error', (err) => {
+                closeConnection();
+                rejectAndFlag(err);
+            });
+            response.pipe(writeStream).on('error', (err) => rejectAndFlag(err));
+            response.on('data', (d) => {
+                refreshTimeout();
+                downloaded += d.length;
+                refreshTimeout();
+                const percent = totalSize === null ? null : downloaded / totalSize;
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    downloaded,
+                    percent,
+                    totalSize,
+                });
+                if (percent === 1) {
+                    finishEventSent = true;
+                }
+            });
+            response.on('close', () => {
+                if (totalSize !== null && downloaded !== totalSize) {
+                    rejectAndFlag(new Error(`${incorrectContentLengthToken} ${downloaded} bytes, but expected ${totalSize} bytes from 'Content-Length'.`));
+                }
+                writeStream.close();
+                closeConnection();
+            });
+        })
+            .catch((err) => {
+            rejectAndFlag(err);
+        });
+    });
+};
+const downloadFile = async (options, retries = 2, attempt = 1) => {
+    try {
+        const res = await downloadFileWithoutRetries(options);
+        return res;
+    }
+    catch (err) {
+        const { message } = err;
+        if (message === 'aborted' ||
+            message.includes('ECONNRESET') ||
+            message.includes(incorrectContentLengthToken) ||
+            // Try again if hitting internal errors
+            message.includes('503') ||
+            message.includes('502') ||
+            message.includes('504') ||
+            message.includes('500')) {
+            if (retries === 0) {
+                throw err;
+            }
+            logger_1.Log.warn({ indent: options.indent, logLevel: options.logLevel }, `Downloading ${options.url} failed (will retry): ${message}`);
+            const backoffInSeconds = (attempt + 1) ** 2;
+            await new Promise((resolve) => {
+                setTimeout(() => resolve(), backoffInSeconds * 1000);
+            });
+            return (0, exports.downloadFile)(options, retries - 1, attempt + 1);
+        }
+        throw err;
+    }
+};
+exports.downloadFile = downloadFile;

package/package/dist/assets/download-map.d.ts

@@ -0,0 +1,55 @@
+import { OffthreadVideoServerEmitter } from '../offthread-video-server';
+import type { FrameAndAssets } from '../render-frames';
+import type { RenderMediaOnDownload } from './download-and-map-assets-to-file';
+import { type InlineAudioMixing } from './inline-audio-mixing';
+export type AudioChannelsAndDurationResultCache = {
+    channels: number;
+    duration: number | null;
+    startTime: number | null;
+};
+export type DownloadMap = {
+    id: string;
+    emitter: OffthreadVideoServerEmitter;
+    downloadListeners: RenderMediaOnDownload[];
+    isDownloadingMap: {
+        [src: string]: {
+            [downloadDir: string]: boolean;
+        } | undefined;
+    };
+    hasBeenDownloadedMap: {
+        [src: string]: {
+            [downloadDir: string]: string | null;
+        } | undefined;
+    };
+    listeners: {
+        [key: string]: {
+            [downloadDir: string]: (() => void)[];
+        };
+    };
+    durationOfAssetCache: Record<string, AudioChannelsAndDurationResultCache>;
+    downloadDir: string;
+    preEncode: string;
+    audioMixing: string;
+    complexFilter: string;
+    audioPreprocessing: string;
+    stitchFrames: string;
+    assetDir: string;
+    compositingDir: string;
+    preventCleanup: () => void;
+    allowCleanup: () => void;
+    isPreventedFromCleanup: () => boolean;
+    inlineAudioMixing: InlineAudioMixing;
+};
+export type RenderAssetInfo = {
+    assets: FrameAndAssets[];
+    imageSequenceName: string;
+    firstFrameIndex: number;
+    downloadMap: DownloadMap;
+    chunkLengthInSeconds: number;
+    trimLeftOffset: number;
+    trimRightOffset: number;
+    forSeamlessAacConcatenation: boolean;
+};
+export declare const makeAndReturn: (dir: string, name: string) => string;
+export declare const makeDownloadMap: () => DownloadMap;
+export declare const cleanDownloadMap: (downloadMap: DownloadMap) => void;

package/package/dist/assets/download-map.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanDownloadMap = exports.makeDownloadMap = exports.makeAndReturn = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const version_1 = require("remotion/version");
+const delete_directory_1 = require("../delete-directory");
+const offthread_video_server_1 = require("../offthread-video-server");
+const tmp_dir_1 = require("../tmp-dir");
+const inline_audio_mixing_1 = require("./inline-audio-mixing");
+const makeAndReturn = (dir, name) => {
+    const p = node_path_1.default.join(dir, name);
+    (0, node_fs_1.mkdirSync)(p);
+    return p;
+};
+exports.makeAndReturn = makeAndReturn;
+const makeDownloadMap = () => {
+    const dir = (0, tmp_dir_1.tmpDir)(`remotion-v${version_1.VERSION}-assets`);
+    let prevented = false;
+    return {
+        isDownloadingMap: {},
+        hasBeenDownloadedMap: {},
+        listeners: {},
+        durationOfAssetCache: {},
+        id: String(Math.random()),
+        assetDir: dir,
+        downloadListeners: [],
+        downloadDir: (0, exports.makeAndReturn)(dir, 'remotion-assets-dir'),
+        complexFilter: (0, exports.makeAndReturn)(dir, 'remotion-complex-filter'),
+        preEncode: (0, exports.makeAndReturn)(dir, 'pre-encode'),
+        audioMixing: (0, exports.makeAndReturn)(dir, 'remotion-audio-mixing'),
+        audioPreprocessing: (0, exports.makeAndReturn)(dir, 'remotion-audio-preprocessing'),
+        stitchFrames: (0, exports.makeAndReturn)(dir, 'remotion-stitch-temp-dir'),
+        compositingDir: (0, exports.makeAndReturn)(dir, 'remotion-compositing-temp-dir'),
+        emitter: new offthread_video_server_1.OffthreadVideoServerEmitter(),
+        preventCleanup: () => {
+            prevented = true;
+        },
+        allowCleanup: () => {
+            prevented = false;
+        },
+        isPreventedFromCleanup: () => {
+            return prevented;
+        },
+        inlineAudioMixing: (0, inline_audio_mixing_1.makeInlineAudioMixing)(dir),
+    };
+};
+exports.makeDownloadMap = makeDownloadMap;
+const cleanDownloadMap = (downloadMap) => {
+    if (downloadMap.isPreventedFromCleanup()) {
+        return;
+    }
+    (0, delete_directory_1.deleteDirectory)(downloadMap.downloadDir);
+    (0, delete_directory_1.deleteDirectory)(downloadMap.complexFilter);
+    (0, delete_directory_1.deleteDirectory)(downloadMap.compositingDir);
+    downloadMap.inlineAudioMixing.cleanup();
+    // Assets dir must be last since the others are contained
+    (0, delete_directory_1.deleteDirectory)(downloadMap.assetDir);
+};
+exports.cleanDownloadMap = cleanDownloadMap;

package/package/dist/assets/ffmpeg-volume-expression.d.ts

@@ -0,0 +1,12 @@
+import type { AssetVolume } from './types';
+type FfmpegEval = 'once' | 'frame';
+type FfmpegVolumeExpression = {
+    eval: FfmpegEval;
+    value: string;
+};
+export declare const ffmpegVolumeExpression: ({ volume, fps, trimLeft, }: {
+    volume: AssetVolume;
+    trimLeft: number;
+    fps: number;
+}) => FfmpegVolumeExpression;
+export {};

package/package/dist/assets/ffmpeg-volume-expression.js

@@ -0,0 +1,96 @@
+"use strict";
+// Example is here https://ffmpeg.org/ffmpeg-filters.html#volume
+// Allowed syntax is here: https://ffmpeg.org/ffmpeg-utils.html#Expression-Evaluation
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ffmpegVolumeExpression = void 0;
+// If once, ffmpeg evaluates volume expression once.
+// If frame, it evaluates it for each frame
+const round_volume_to_avoid_stack_overflow_1 = require("./round-volume-to-avoid-stack-overflow");
+// In FFMPEG expressions, the current time is represented by 't'
+// the `n` for the timestamp variable is buggy
+const FFMPEG_TIME_VARIABLE = 't';
+const ffmpegIfOrElse = (condition, then, elseDo) => {
+    return `if(${condition},${then},${elseDo})`;
+};
+const ffmpegIsOneOfFrames = ({ frames, trimLeft, fps, }) => {
+    const consecutiveArrays = [];
+    for (let i = 0; i < frames.length; i++) {
+        const previousFrame = frames[i - 1];
+        const frame = frames[i];
+        if (previousFrame === undefined || frame !== previousFrame + 1) {
+            consecutiveArrays.push([]);
+        }
+        consecutiveArrays[consecutiveArrays.length - 1].push(frame);
+    }
+    return consecutiveArrays
+        .map((f) => {
+        const firstFrame = f[0];
+        const lastFrame = f[f.length - 1];
+        const before = (firstFrame - 0.5) / fps;
+        const after = (lastFrame + 0.5) / fps;
+        return `between(${FFMPEG_TIME_VARIABLE},${(before + trimLeft).toFixed(4)},${(after + trimLeft).toFixed(4)})`;
+    })
+        .join('+');
+};
+const ffmpegBuildVolumeExpression = ({ arr, delay, fps, }) => {
+    if (arr.length === 0) {
+        throw new Error('Volume array expression should never have length 0');
+    }
+    if (arr.length === 1) {
+        return String(arr[0][0]);
+    }
+    const [first, ...rest] = arr;
+    const [volume, frames] = first;
+    return ffmpegIfOrElse(ffmpegIsOneOfFrames({ frames, trimLeft: delay, fps }), String(volume), ffmpegBuildVolumeExpression({ arr: rest, delay, fps }));
+};
+const ffmpegVolumeExpression = ({ volume, fps, trimLeft, }) => {
+    // If it's a static volume, we return it and tell
+    // FFMPEG it only has to evaluate it once
+    if (typeof volume === 'number') {
+        return {
+            eval: 'once',
+            value: String(volume),
+        };
+    }
+    if ([...new Set(volume)].length === 1) {
+        return (0, exports.ffmpegVolumeExpression)({
+            volume: volume[0],
+            fps,
+            trimLeft,
+        });
+    }
+    // A 1 sec video with frames 0-29 would mean that
+    // frame 29 corresponds to timestamp 0.966666...
+    // but the audio is actually 1 sec long. For that reason we pad the last
+    // timestamp.
+    const paddedVolume = [...volume, volume[volume.length - 1]];
+    // Otherwise, we construct an FFMPEG expression. First step:
+    // Make a map of all possible volumes
+    // {possibleVolume1} => [frame1, frame2]
+    // {possibleVolume2} => [frame3, frame4]
+    const volumeMap = {};
+    paddedVolume.forEach((baseVolume, frame) => {
+        // Adjust volume based on how many other tracks have not yet finished
+        const actualVolume = (0, round_volume_to_avoid_stack_overflow_1.roundVolumeToAvoidStackOverflow)(baseVolume);
+        if (!volumeMap[actualVolume]) {
+            volumeMap[actualVolume] = [];
+        }
+        volumeMap[actualVolume].push(frame);
+    });
+    // Sort the map so that the most common volume is last
+    // this is going to be the else statement so the expression is short
+    const volumeArray = Object.keys(volumeMap)
+        .map((key) => [Number(key), volumeMap[key]])
+        .sort((a, b) => a[1].length - b[1].length);
+    // Construct and tell FFMPEG it has to evaluate expression on each frame
+    const expression = ffmpegBuildVolumeExpression({
+        arr: volumeArray,
+        delay: trimLeft,
+        fps,
+    });
+    return {
+        eval: 'frame',
+        value: `'${expression}'`,
+    };
+};
+exports.ffmpegVolumeExpression = ffmpegVolumeExpression;

package/package/dist/assets/flatten-volume-array.d.ts

@@ -0,0 +1,3 @@
+import type { AssetVolume, MediaAsset } from './types';
+export declare const flattenVolumeArray: (volume: AssetVolume) => AssetVolume;
+export declare const convertAssetToFlattenedVolume: (asset: MediaAsset) => MediaAsset;

package/package/dist/assets/flatten-volume-array.js

@@ -0,0 +1,26 @@
+"use strict";
+// An input is an array with volume levels for each frame, like
+// [1, 1, 1, 1, 1, ...].
+// If all elements are the same, we flatten it to `1`, otherwise we leave it as an array.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAssetToFlattenedVolume = exports.flattenVolumeArray = void 0;
+const flattenVolumeArray = (volume) => {
+    if (typeof volume === 'number') {
+        return volume;
+    }
+    if (volume.length === 0) {
+        throw new TypeError('Volume array must have at least 1 number');
+    }
+    if (new Set(volume).size === 1) {
+        return volume[0];
+    }
+    return volume;
+};
+exports.flattenVolumeArray = flattenVolumeArray;
+const convertAssetToFlattenedVolume = (asset) => {
+    return {
+        ...asset,
+        volume: (0, exports.flattenVolumeArray)(asset.volume),
+    };
+};
+exports.convertAssetToFlattenedVolume = convertAssetToFlattenedVolume;

package/package/dist/assets/get-audio-channels.d.ts

@@ -0,0 +1,20 @@
+import type { LogLevel } from '../log-level';
+import type { CancelSignal } from '../make-cancel-signal';
+import type { AudioChannelsAndDurationResultCache, DownloadMap } from './download-map';
+export declare const getAudioChannelsAndDurationWithoutCache: ({ src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }: {
+    src: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    audioStreamIndex: number | undefined;
+}) => Promise<AudioChannelsAndDurationResultCache>;
+export declare const getAudioChannelsAndDuration: ({ downloadMap, src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }: {
+    downloadMap: DownloadMap;
+    src: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    audioStreamIndex: number | undefined;
+}) => Promise<AudioChannelsAndDurationResultCache>;

package/package/dist/assets/get-audio-channels.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioChannelsAndDuration = exports.getAudioChannelsAndDurationWithoutCache = void 0;
+const call_ffmpeg_1 = require("../call-ffmpeg");
+const p_limit_1 = require("../p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+const getAudioChannelsAndDurationWithoutCache = async ({ src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }) => {
+    const args = [
+        ['-v', 'error'],
+        ['-select_streams', audioStreamIndex ? `a:${audioStreamIndex}` : 'a:0'],
+        [
+            '-show_entries',
+            'stream=channels:stream=start_time:format=duration:format=format_name',
+        ],
+        ['-of', 'default=nw=1'],
+        [src],
+    ]
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter(Boolean);
+    try {
+        const task = await (0, call_ffmpeg_1.callFf)({
+            bin: 'ffprobe',
+            args,
+            indent,
+            logLevel,
+            binariesDirectory,
+            cancelSignal,
+        });
+        const channels = task.stdout.match(/channels=([0-9]+)/);
+        const duration = task.stdout.match(/duration=([0-9.]+)/);
+        const startTime = task.stdout.match(/start_time=([0-9.]+)/);
+        const container = task.stdout.match(/format_name=([a-zA-Z0-9.]+)/);
+        const isMP3 = container ? container[1] === 'mp3' : false;
+        const result = {
+            channels: channels ? parseInt(channels[1], 10) : 0,
+            duration: duration ? parseFloat(duration[1]) : null,
+            // We ignore the start time for MP3 because that is an inherent encoder thing
+            // not in the sense that we want
+            startTime: startTime ? (isMP3 ? 0 : parseFloat(startTime[1])) : null,
+        };
+        return result;
+    }
+    catch (err) {
+        if (err.message.includes('This file cannot be read by `ffprobe`. Is it a valid multimedia file?')) {
+            throw new Error('This file cannot be read by `ffprobe`. Is it a valid multimedia file?');
+        }
+        throw err;
+    }
+};
+exports.getAudioChannelsAndDurationWithoutCache = getAudioChannelsAndDurationWithoutCache;
+async function getAudioChannelsAndDurationUnlimited({ downloadMap, src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }) {
+    const cacheKey = audioStreamIndex ? `${src}-${audioStreamIndex}` : src;
+    if (downloadMap.durationOfAssetCache[cacheKey]) {
+        return downloadMap.durationOfAssetCache[cacheKey];
+    }
+    const result = await (0, exports.getAudioChannelsAndDurationWithoutCache)({
+        src,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+        audioStreamIndex,
+    });
+    downloadMap.durationOfAssetCache[cacheKey] = result;
+    return result;
+}
+const getAudioChannelsAndDuration = ({ downloadMap, src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }) => {
+    return limit(() => getAudioChannelsAndDurationUnlimited({
+        downloadMap,
+        src,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+        audioStreamIndex,
+    }));
+};
+exports.getAudioChannelsAndDuration = getAudioChannelsAndDuration;

package/package/dist/assets/inline-audio-mixing.d.ts

@@ -0,0 +1,22 @@
+import type { InlineAudioAsset } from 'remotion/no-react';
+import type { LogLevel } from '../log-level';
+import type { CancelSignal } from '../make-cancel-signal';
+export declare const makeInlineAudioMixing: (dir: string) => {
+    cleanup: () => void;
+    addAsset: ({ asset, fps, totalNumberOfFrames, firstFrame, trimLeftOffset, trimRightOffset, }: {
+        asset: InlineAudioAsset;
+        fps: number;
+        totalNumberOfFrames: number;
+        firstFrame: number;
+        trimLeftOffset: number;
+        trimRightOffset: number;
+    }) => void;
+    getListOfAssets: () => string[];
+    finish: ({ binariesDirectory, indent, logLevel, cancelSignal, }: {
+        indent: boolean;
+        logLevel: LogLevel;
+        binariesDirectory: string | null;
+        cancelSignal: CancelSignal | undefined;
+    }) => Promise<void>;
+};
+export type InlineAudioMixing = ReturnType<typeof makeInlineAudioMixing>;