@remotion/renderer 4.0.357 → 4.0.360

package/package/dist/get-codec-name.d.ts

@@ -0,0 +1,21 @@
+import type { Codec } from './codec';
+import type { LogLevel } from './log-level';
+import type { HardwareAccelerationOption } from './options/hardware-acceleration';
+export type CodecSettings = {
+    encoderName: string;
+    hardwareAccelerated: boolean;
+};
+export declare const hasSpecifiedUnsupportedHardwareQualifySettings: ({ encodingMaxRate, encodingBufferSize, crf, }: {
+    encodingMaxRate: string | null;
+    encodingBufferSize: string | null;
+    crf: unknown;
+}) => "crf" | "encodingBufferSize" | "encodingMaxRate" | null;
+export declare const getCodecName: ({ codec, encodingMaxRate, encodingBufferSize, crf, hardwareAcceleration, logLevel, indent, }: {
+    codec: Codec;
+    hardwareAcceleration: HardwareAccelerationOption;
+    encodingMaxRate: string | null;
+    encodingBufferSize: string | null;
+    crf: unknown;
+    logLevel: LogLevel;
+    indent: boolean;
+}) => CodecSettings | null;

package/package/dist/get-codec-name.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodecName = exports.hasSpecifiedUnsupportedHardwareQualifySettings = void 0;
+const logger_1 = require("./logger");
+const hasSpecifiedUnsupportedHardwareQualifySettings = ({ encodingMaxRate, encodingBufferSize, crf, }) => {
+    if (encodingBufferSize !== null) {
+        return 'encodingBufferSize';
+    }
+    if (encodingMaxRate !== null) {
+        return 'encodingMaxRate';
+    }
+    if (crf !== null && typeof crf !== 'undefined') {
+        return 'crf';
+    }
+    return null;
+};
+exports.hasSpecifiedUnsupportedHardwareQualifySettings = hasSpecifiedUnsupportedHardwareQualifySettings;
+const getCodecName = ({ codec, encodingMaxRate, encodingBufferSize, crf, hardwareAcceleration, logLevel, indent, }) => {
+    const preferredHwAcceleration = hardwareAcceleration === 'required' ||
+        hardwareAcceleration === 'if-possible';
+    const unsupportedQualityOption = (0, exports.hasSpecifiedUnsupportedHardwareQualifySettings)({
+        encodingMaxRate,
+        encodingBufferSize,
+        crf,
+    });
+    if (hardwareAcceleration === 'required' && unsupportedQualityOption) {
+        throw new Error(`When using hardware accelerated encoding, the option "${unsupportedQualityOption}" with hardware acceleration is not supported. Disable hardware accelerated encoding or use "if-possible" instead.`);
+    }
+    const warnAboutDisabledHardwareAcceleration = () => {
+        if (hardwareAcceleration === 'if-possible' && unsupportedQualityOption) {
+            logger_1.Log.warn({ indent, logLevel }, `${indent ? '' : '\n'}Hardware accelerated encoding disabled - "${unsupportedQualityOption}" option is not supported with hardware acceleration`);
+        }
+    };
+    if (codec === 'prores') {
+        if (preferredHwAcceleration &&
+            process.platform === 'darwin' &&
+            !unsupportedQualityOption) {
+            return { encoderName: 'prores_videotoolbox', hardwareAccelerated: true };
+        }
+        warnAboutDisabledHardwareAcceleration();
+        return { encoderName: 'prores_ks', hardwareAccelerated: false };
+    }
+    if (codec === 'h264') {
+        if (preferredHwAcceleration &&
+            process.platform === 'darwin' &&
+            !unsupportedQualityOption) {
+            return { encoderName: 'h264_videotoolbox', hardwareAccelerated: true };
+        }
+        warnAboutDisabledHardwareAcceleration();
+        return { encoderName: 'libx264', hardwareAccelerated: false };
+    }
+    if (codec === 'h265') {
+        if (preferredHwAcceleration &&
+            process.platform === 'darwin' &&
+            !unsupportedQualityOption) {
+            return { encoderName: 'hevc_videotoolbox', hardwareAccelerated: true };
+        }
+        warnAboutDisabledHardwareAcceleration();
+        return { encoderName: 'libx265', hardwareAccelerated: false };
+    }
+    if (codec === 'vp8') {
+        return { encoderName: 'libvpx', hardwareAccelerated: false };
+    }
+    if (codec === 'vp9') {
+        return { encoderName: 'libvpx-vp9', hardwareAccelerated: false };
+    }
+    if (codec === 'gif') {
+        return { encoderName: 'gif', hardwareAccelerated: false };
+    }
+    if (codec === 'mp3') {
+        return null;
+    }
+    if (codec === 'aac') {
+        return null;
+    }
+    if (codec === 'wav') {
+        return null;
+    }
+    if (codec === 'h264-mkv') {
+        return { encoderName: 'libx264', hardwareAccelerated: false };
+    }
+    if (codec === 'h264-ts') {
+        return { encoderName: 'libx264', hardwareAccelerated: false };
+    }
+    throw new Error(`Could not get codec for ${codec}`);
+};
+exports.getCodecName = getCodecName;

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

@@ -0,0 +1,34 @@
+import type { VideoConfig } from 'remotion/no-react';
+import type { BrowserExecutable } from './browser-executable';
+import type { BrowserLog } from './browser-log';
+import type { HeadlessBrowser } from './browser/Browser';
+import type { OnLog } from './browser/BrowserPage';
+import type { ChromiumOptions } from './open-browser';
+import type { ToOptions } from './options/option';
+import type { optionsMap } from './options/options-map';
+import type { RemotionServer } from './prepare-server';
+import type { RequiredInputPropsInV5 } from './v5-required-input-props';
+type InternalGetCompositionsOptions = {
+    serializedInputPropsWithCustomSchema: string;
+    envVariables: Record<string, string>;
+    puppeteerInstance: HeadlessBrowser | undefined;
+    onBrowserLog: null | ((log: BrowserLog) => void);
+    browserExecutable: BrowserExecutable | null;
+    chromiumOptions: ChromiumOptions;
+    port: number | null;
+    server: RemotionServer | undefined;
+    indent: boolean;
+    serveUrlOrWebpackUrl: string;
+    onLog: OnLog;
+} & ToOptions<typeof optionsMap.getCompositions>;
+export type GetCompositionsOptions = RequiredInputPropsInV5 & {
+    envVariables?: Record<string, string>;
+    puppeteerInstance?: HeadlessBrowser;
+    onBrowserLog?: (log: BrowserLog) => void;
+    browserExecutable?: BrowserExecutable;
+    chromiumOptions?: ChromiumOptions;
+    port?: number | null;
+} & Partial<ToOptions<typeof optionsMap.getCompositions>>;
+export declare const internalGetCompositions: (args_0: InternalGetCompositionsOptions) => Promise<VideoConfig[]>;
+export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsOptions) => Promise<VideoConfig[]>;
+export {};

package/package/dist/get-compositions.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompositions = exports.internalGetCompositions = void 0;
+const no_react_1 = require("remotion/no-react");
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
+const browser_download_progress_bar_1 = require("./browser/browser-download-progress-bar");
+const default_on_log_1 = require("./default-on-log");
+const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
+const find_closest_package_json_1 = require("./find-closest-package-json");
+const get_browser_instance_1 = require("./get-browser-instance");
+const get_available_memory_1 = require("./memory/get-available-memory");
+const offthreadvideo_threads_1 = require("./options/offthreadvideo-threads");
+const prepare_server_1 = require("./prepare-server");
+const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const seek_to_frame_1 = require("./seek-to-frame");
+const set_props_and_env_1 = require("./set-props-and-env");
+const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
+const wrap_with_error_handling_1 = require("./wrap-with-error-handling");
+const innerGetCompositions = async ({ envVariables, serializedInputPropsWithCustomSchema, page, proxyPort, serveUrl, timeoutInMilliseconds, indent, logLevel, mediaCacheSizeInBytes, }) => {
+    (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(timeoutInMilliseconds);
+    await (0, set_props_and_env_1.setPropsAndEnv)({
+        serializedInputPropsWithCustomSchema,
+        envVariables,
+        page,
+        serveUrl,
+        initialFrame: 0,
+        timeoutInMilliseconds,
+        proxyPort,
+        retriesRemaining: 2,
+        audioEnabled: false,
+        videoEnabled: false,
+        indent,
+        logLevel,
+        onServeUrlVisited: () => undefined,
+        isMainTab: true,
+        mediaCacheSizeInBytes,
+        initialMemoryAvailable: (0, get_available_memory_1.getAvailableMemory)(logLevel),
+    });
+    await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        page,
+        pageFunction: () => {
+            window.remotion_setBundleMode({
+                type: 'evaluation',
+            });
+        },
+        frame: null,
+        args: [],
+        timeoutInMilliseconds,
+    });
+    await (0, seek_to_frame_1.waitForReady)({
+        page,
+        timeoutInMilliseconds,
+        frame: null,
+        indent,
+        logLevel,
+    });
+    const { value: result } = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        pageFunction: () => {
+            return window.getStaticCompositions();
+        },
+        frame: null,
+        page,
+        args: [],
+        timeoutInMilliseconds,
+    });
+    const res = result;
+    return res.map((r) => {
+        const { width, durationInFrames, fps, height, id, defaultCodec, defaultOutName, defaultVideoImageFormat, defaultPixelFormat, } = r;
+        return {
+            id,
+            width,
+            height,
+            fps,
+            durationInFrames,
+            props: no_react_1.NoReactInternals.deserializeJSONWithSpecialTypes(r.serializedResolvedPropsWithCustomSchema),
+            defaultProps: no_react_1.NoReactInternals.deserializeJSONWithSpecialTypes(r.serializedDefaultPropsWithCustomSchema),
+            defaultCodec,
+            defaultOutName,
+            defaultVideoImageFormat,
+            defaultPixelFormat,
+        };
+    });
+};
+const internalGetCompositionsRaw = async ({ browserExecutable, chromiumOptions, envVariables, indent, serializedInputPropsWithCustomSchema, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, offthreadVideoCacheSizeInBytes, binariesDirectory, onBrowserDownload, chromeMode, offthreadVideoThreads, mediaCacheSizeInBytes, onLog, }) => {
+    const { page, cleanupPage } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
+        passedInInstance: puppeteerInstance,
+        browserExecutable,
+        chromiumOptions,
+        forceDeviceScaleFactor: undefined,
+        indent,
+        logLevel,
+        onBrowserDownload,
+        chromeMode,
+        pageIndex: 0,
+        onBrowserLog,
+        onLog,
+    });
+    const cleanup = [cleanupPage];
+    return new Promise((resolve, reject) => {
+        const onError = (err) => reject(err);
+        cleanup.push((0, handle_javascript_exception_1.handleJavascriptException)({
+            page,
+            frame: null,
+            onError,
+        }));
+        (0, prepare_server_1.makeOrReuseServer)(server, {
+            webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
+            port,
+            remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
+            offthreadVideoThreads: offthreadVideoThreads !== null && offthreadVideoThreads !== void 0 ? offthreadVideoThreads : offthreadvideo_threads_1.DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS,
+            logLevel,
+            indent,
+            offthreadVideoCacheSizeInBytes,
+            binariesDirectory,
+            forceIPv4: false,
+        }, {
+            onDownload: () => undefined,
+        })
+            .then(({ server: { serveUrl, offthreadPort, sourceMap }, cleanupServer }) => {
+            page.setBrowserSourceMapGetter(sourceMap);
+            cleanup.push(() => {
+                return cleanupServer(true);
+            });
+            return innerGetCompositions({
+                envVariables,
+                serializedInputPropsWithCustomSchema,
+                page,
+                proxyPort: offthreadPort,
+                serveUrl,
+                timeoutInMilliseconds,
+                indent,
+                logLevel,
+                offthreadVideoCacheSizeInBytes,
+                binariesDirectory,
+                onBrowserDownload,
+                chromeMode,
+                offthreadVideoThreads,
+                mediaCacheSizeInBytes,
+            });
+        })
+            .then((comp) => {
+            return resolve(comp);
+        })
+            .catch((err) => {
+            reject(err);
+        })
+            .finally(() => {
+            cleanup.forEach((c) => {
+                c();
+            });
+        });
+    });
+};
+exports.internalGetCompositions = (0, wrap_with_error_handling_1.wrapWithErrorHandling)(internalGetCompositionsRaw);
+/*
+ * @description Gets a list of compositions defined in a Remotion project based on a Remotion Bundle by evaluating the Remotion Root.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
+ */
+const getCompositions = (serveUrlOrWebpackUrl, config) => {
+    if (!serveUrlOrWebpackUrl) {
+        throw new Error('No serve URL or webpack bundle directory was passed to getCompositions().');
+    }
+    const { browserExecutable, chromiumOptions, envVariables, inputProps, onBrowserLog, port, puppeteerInstance, timeoutInMilliseconds, logLevel: passedLogLevel, onBrowserDownload, binariesDirectory, offthreadVideoCacheSizeInBytes, chromeMode, offthreadVideoThreads, mediaCacheSizeInBytes, } = config !== null && config !== void 0 ? config : {};
+    const indent = false;
+    const logLevel = passedLogLevel !== null && passedLogLevel !== void 0 ? passedLogLevel : 'info';
+    return (0, exports.internalGetCompositions)({
+        browserExecutable: browserExecutable !== null && browserExecutable !== void 0 ? browserExecutable : null,
+        chromiumOptions: chromiumOptions !== null && chromiumOptions !== void 0 ? chromiumOptions : {},
+        envVariables: envVariables !== null && envVariables !== void 0 ? envVariables : {},
+        serializedInputPropsWithCustomSchema: no_react_1.NoReactInternals.serializeJSONWithSpecialTypes({
+            data: inputProps !== null && inputProps !== void 0 ? inputProps : {},
+            indent: undefined,
+            staticBase: null,
+        }).serializedString,
+        indent,
+        onBrowserLog: onBrowserLog !== null && onBrowserLog !== void 0 ? onBrowserLog : null,
+        port: port !== null && port !== void 0 ? port : null,
+        puppeteerInstance: puppeteerInstance !== null && puppeteerInstance !== void 0 ? puppeteerInstance : undefined,
+        serveUrlOrWebpackUrl,
+        server: undefined,
+        timeoutInMilliseconds: timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : TimeoutSettings_1.DEFAULT_TIMEOUT,
+        logLevel,
+        offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes !== null && offthreadVideoCacheSizeInBytes !== void 0 ? offthreadVideoCacheSizeInBytes : null,
+        binariesDirectory: binariesDirectory !== null && binariesDirectory !== void 0 ? binariesDirectory : null,
+        onBrowserDownload: onBrowserDownload !== null && onBrowserDownload !== void 0 ? onBrowserDownload : (0, browser_download_progress_bar_1.defaultBrowserDownloadProgress)({
+            indent,
+            logLevel,
+            api: 'getCompositions()',
+        }),
+        chromeMode: chromeMode !== null && chromeMode !== void 0 ? chromeMode : 'headless-shell',
+        offthreadVideoThreads: offthreadVideoThreads !== null && offthreadVideoThreads !== void 0 ? offthreadVideoThreads : null,
+        mediaCacheSizeInBytes: mediaCacheSizeInBytes !== null && mediaCacheSizeInBytes !== void 0 ? mediaCacheSizeInBytes : null,
+        onLog: default_on_log_1.defaultOnLog,
+    });
+};
+exports.getCompositions = getCompositions;

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

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

package/package/dist/get-concurrency.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConcurrency = void 0;
+const get_cpu_count_1 = require("./get-cpu-count");
+const resolveConcurrency = (userPreference) => {
+    const maxCpus = (0, get_cpu_count_1.getCpuCount)();
+    if (userPreference === null) {
+        return Math.round(Math.min(8, Math.max(1, maxCpus / 2)));
+    }
+    const min = 1;
+    let rounded;
+    if (typeof userPreference === 'string') {
+        const percentage = parseInt(userPreference.slice(0, -1), 10);
+        rounded = Math.floor((percentage / 100) * maxCpus);
+    }
+    else {
+        rounded = Math.floor(userPreference);
+    }
+    if (rounded > maxCpus) {
+        throw new Error(`Maximum for --concurrency is ${maxCpus} (number of cores on this system)`);
+    }
+    if (rounded < min) {
+        throw new Error(`Minimum for concurrency is ${min}.`);
+    }
+    return rounded;
+};
+exports.resolveConcurrency = resolveConcurrency;

package/package/dist/get-cpu-count.d.ts

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

package/package/dist/get-cpu-count.js

@@ -0,0 +1,33 @@
+"use strict";
+// Kubernetes uses the following command to spawn Docker containers:
+// docker run --cpuset-cpus="0,1" to assign only 2 CPUs.
+// However, Node.js returns the core count of the host system (up to 96!)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCpuCount = exports.getConcurrencyFromNProc = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+let nprocCount;
+// We also get it from nproc and use the minimum of the two.
+const getConcurrencyFromNProc = () => {
+    if (nprocCount !== undefined) {
+        return nprocCount;
+    }
+    try {
+        const count = parseInt((0, node_child_process_1.execSync)('nproc', { stdio: 'pipe' }).toString().trim(), 10);
+        nprocCount = count;
+        return count;
+    }
+    catch (_a) {
+        return null;
+    }
+};
+exports.getConcurrencyFromNProc = getConcurrencyFromNProc;
+const getCpuCount = () => {
+    const node = (0, node_os_1.cpus)().length;
+    const nproc = (0, exports.getConcurrencyFromNProc)();
+    if (nproc === null) {
+        return node;
+    }
+    return Math.min(nproc, node);
+};
+exports.getCpuCount = getCpuCount;

package/package/dist/get-duration-from-frame-range.d.ts

@@ -0,0 +1 @@
+export declare const getFramesToRender: (frameRange: [number, number], everyNthFrame: number) => number[];

package/package/dist/get-duration-from-frame-range.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFramesToRender = void 0;
+const getFramesToRender = (frameRange, everyNthFrame) => {
+    if (everyNthFrame === 0) {
+        throw new Error('everyNthFrame cannot be 0');
+    }
+    return new Array(frameRange[1] - frameRange[0] + 1)
+        .fill(true)
+        .map((_, index) => {
+        return index + frameRange[0];
+    })
+        .filter((index) => {
+        return index % everyNthFrame === 0;
+    });
+};
+exports.getFramesToRender = getFramesToRender;

package/package/dist/get-extension-from-codec.d.ts

@@ -0,0 +1,6 @@
+import type { Codec } from './codec';
+import type { FileExtension } from './file-extensions';
+import type { AudioCodec } from './options/audio-codec';
+export declare const getFileExtensionFromCodec: <T extends Codec>(codec: T, audioCodec: AudioCodec | null) => FileExtension;
+export declare const makeFileExtensionMap: () => Record<string, ("h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "h264-ts" | "gif")[]>;
+export declare const defaultCodecsForFileExtension: Record<FileExtension, Codec>;

package/package/dist/get-extension-from-codec.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCodecsForFileExtension = exports.makeFileExtensionMap = exports.getFileExtensionFromCodec = void 0;
+const codec_1 = require("./codec");
+const file_extensions_1 = require("./file-extensions");
+const getFileExtensionFromCodec = (codec, audioCodec) => {
+    if (!codec_1.validCodecs.includes(codec)) {
+        throw new Error(`Codec must be one of the following: ${codec_1.validCodecs.join(', ')}, but got ${codec}`);
+    }
+    const map = file_extensions_1.defaultFileExtensionMap[codec];
+    if (audioCodec === null) {
+        return map.default;
+    }
+    const typedAudioCodec = audioCodec;
+    if (!(typedAudioCodec in map.forAudioCodec)) {
+        throw new Error(`Audio codec ${typedAudioCodec} is not supported for codec ${codec}`);
+    }
+    return map.forAudioCodec[audioCodec].default;
+};
+exports.getFileExtensionFromCodec = getFileExtensionFromCodec;
+const makeFileExtensionMap = () => {
+    const map = {};
+    Object.keys(file_extensions_1.defaultFileExtensionMap).forEach((_codec) => {
+        const codec = _codec;
+        const fileExtMap = file_extensions_1.defaultFileExtensionMap[codec];
+        const audioCodecs = Object.keys(fileExtMap.forAudioCodec);
+        const possibleExtensionsForAudioCodec = audioCodecs.map((audioCodec) => fileExtMap.forAudioCodec[audioCodec].possible);
+        const allPossibleExtensions = [
+            fileExtMap.default,
+            ...possibleExtensionsForAudioCodec.flat(1),
+        ];
+        for (const extension of allPossibleExtensions) {
+            if (!map[extension]) {
+                map[extension] = [];
+            }
+            if (!map[extension].includes(codec)) {
+                map[extension].push(codec);
+            }
+        }
+    });
+    return map;
+};
+exports.makeFileExtensionMap = makeFileExtensionMap;
+exports.defaultCodecsForFileExtension = {
+    '3gp': 'aac',
+    aac: 'aac',
+    gif: 'gif',
+    hevc: 'h265',
+    m4a: 'aac',
+    m4b: 'aac',
+    mkv: 'h264-mkv',
+    mov: 'prores',
+    mp3: 'mp3',
+    mp4: 'h264',
+    mpeg: 'aac',
+    mpg: 'aac',
+    mxf: 'prores',
+    wav: 'wav',
+    webm: 'vp8',
+    ts: 'h264-ts',
+};

package/package/dist/get-extension-of-filename.d.ts

@@ -0,0 +1 @@
+export declare const getExtensionOfFilename: (filename: string | null) => string | null;

package/package/dist/get-extension-of-filename.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtensionOfFilename = void 0;
+const path_normalize_1 = require("./path-normalize");
+const getExtensionOfFilename = (filename) => {
+    if (filename === null) {
+        return null;
+    }
+    const filenameArr = (0, path_normalize_1.pathNormalize)(filename).split('.');
+    const hasExtension = filenameArr.length >= 2;
+    const filenameArrLength = filenameArr.length;
+    const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;
+    return extension;
+};
+exports.getExtensionOfFilename = getExtensionOfFilename;

package/package/dist/get-extra-frames-to-capture.d.ts

@@ -0,0 +1,14 @@
+type ReturnType = {
+    extraFramesToCaptureAssetsFrontend: number[];
+    extraFramesToCaptureAssetsBackend: number[];
+    trimLeftOffset: number;
+    trimRightOffset: number;
+    chunkLengthInSeconds: number;
+};
+export declare const getExtraFramesToCapture: ({ compositionStart, realFrameRange, fps, forSeamlessAacConcatenation, }: {
+    fps: number;
+    compositionStart: number;
+    realFrameRange: [number, number];
+    forSeamlessAacConcatenation: boolean;
+}) => ReturnType;
+export {};

package/package/dist/get-extra-frames-to-capture.js

@@ -0,0 +1,62 @@
+"use strict";
+// For seamless AAC concatenation, we need to capture a bit of extra audio on both sides
+// to later align the audio correctly. This function calculates the exact frames to capture.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtraFramesToCapture = void 0;
+const combine_audio_1 = require("./combine-audio");
+const sample_rate_1 = require("./sample-rate");
+// Inspired by https://github.com/wistia/seamless-aac-split-and-stitch-demo
+// We can seamlessly concatenate AAC files if we capture a bit of extra audio on both sides in each chunk and then align the audio correctly.
+// This function calculates which extra frames should be evaluated for their audio content.
+const getExtraFramesToCapture = ({ compositionStart, realFrameRange, fps, forSeamlessAacConcatenation, }) => {
+    // If the feature is disabled, don't capture extra frames.
+    if (!forSeamlessAacConcatenation) {
+        return {
+            extraFramesToCaptureAssetsBackend: [],
+            extraFramesToCaptureAssetsFrontend: [],
+            chunkLengthInSeconds: (realFrameRange[1] - realFrameRange[0] + 1) / fps,
+            trimLeftOffset: 0,
+            trimRightOffset: 0,
+        };
+    }
+    // If this video is just a chunk as part of a larger video,
+    // We also need to know the start time of this chunk to align it correctly.
+    const chunkStart = realFrameRange[0];
+    // If we are only rendering a portion of the composition, we also need to account for that.
+    // It cannot be that the chunk start time is earlier than the composition time.
+    if (chunkStart < compositionStart) {
+        throw new Error('chunkStart may not be below compositionStart');
+    }
+    const realLeftEnd = chunkStart - compositionStart;
+    if (realLeftEnd < 0) {
+        throw new Error('chunkStat - compositionStart may not be below 0');
+    }
+    const realRightEnd = realLeftEnd + (realFrameRange[1] - realFrameRange[0] + 1);
+    // Find the closest AAC packet border and add two AAC packet padding.
+    const aacAdjustedLeftEnd = Math.max(0, (0, combine_audio_1.getClosestAlignedTime)(realLeftEnd / fps) - 2 * (1024 / sample_rate_1.DEFAULT_SAMPLE_RATE));
+    const aacAdjustedRightEnd = (0, combine_audio_1.getClosestAlignedTime)(realRightEnd / fps) +
+        2 * (1024 / sample_rate_1.DEFAULT_SAMPLE_RATE);
+    // Now find the additional frames that we need to capture to have enough audio
+    const alignedStartFrameWithoutOffset = Math.floor(aacAdjustedLeftEnd * fps);
+    const alignedStartFrame = alignedStartFrameWithoutOffset + compositionStart;
+    const alignedEndFrame = Math.ceil(aacAdjustedRightEnd * fps) + compositionStart;
+    const extraFramesToCaptureAudioOnlyFrontend = new Array(realFrameRange[0] - alignedStartFrame)
+        .fill(true)
+        .map((_, f) => f + alignedStartFrame);
+    const extraFramesToCaptureAudioOnlyBackend = new Array(alignedEndFrame - realFrameRange[1] - 1)
+        .fill(true)
+        .map((_, f) => f + realFrameRange[1] + 1);
+    // But now, we might have too much audio, since the extra frames only have a `1 / fps` step.
+    // When creating the lossless audio for a chunk, we need to shave that extra audio off.
+    const trimLeftOffset = (aacAdjustedLeftEnd * fps - alignedStartFrameWithoutOffset) / fps;
+    const trimRightOffset = (aacAdjustedRightEnd * fps - Math.ceil(aacAdjustedRightEnd * fps)) / fps;
+    const chunkLengthInSeconds = aacAdjustedRightEnd - aacAdjustedLeftEnd;
+    return {
+        extraFramesToCaptureAssetsFrontend: extraFramesToCaptureAudioOnlyFrontend,
+        extraFramesToCaptureAssetsBackend: extraFramesToCaptureAudioOnlyBackend,
+        chunkLengthInSeconds,
+        trimLeftOffset,
+        trimRightOffset,
+    };
+};
+exports.getExtraFramesToCapture = getExtraFramesToCapture;

package/package/dist/get-frame-padded-index.d.ts

@@ -0,0 +1,21 @@
+import type { VideoImageFormat } from './image-format';
+export type CountType = 'from-zero' | 'actual-frames';
+export declare const getFrameOutputFileNameFromPattern: ({ pattern, frame, ext, }: {
+    pattern: string;
+    frame: string;
+    ext: string;
+}) => string;
+export declare const getFrameOutputFileName: ({ index, frame, imageFormat, countType, lastFrame, totalFrames, imageSequencePattern, }: {
+    index: number;
+    frame: number;
+    imageFormat: VideoImageFormat;
+    countType: CountType;
+    lastFrame: number;
+    totalFrames: number;
+    imageSequencePattern: string | null;
+}) => string;
+export declare const getFilePadLength: ({ lastFrame, totalFrames, countType, }: {
+    lastFrame: number;
+    totalFrames: number;
+    countType: CountType;
+}) => number;

package/package/dist/get-frame-padded-index.js

@@ -0,0 +1,43 @@
+"use strict";
+// Determines the filenames for frames that get rendered.
+// - If passed to FFMPEG, they should be consecutive: element-000.jpg, element-001.jpg, element-002.jpg
+// - If `--every-nth-frame` is passed, only frames 0, 2, 4 are rendered
+// - If an image sequence is created, the filenames should correspond to the frame numbers: element-099.jpg, element-100.jpg
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilePadLength = exports.getFrameOutputFileName = exports.getFrameOutputFileNameFromPattern = void 0;
+const getFrameOutputFileNameFromPattern = ({ pattern, frame, ext, }) => {
+    return pattern.replace(/\[frame\]/g, frame).replace(/\[ext\]/g, ext);
+};
+exports.getFrameOutputFileNameFromPattern = getFrameOutputFileNameFromPattern;
+const getFrameOutputFileName = ({ index, frame, imageFormat, countType, lastFrame, totalFrames, imageSequencePattern, }) => {
+    const filePadLength = (0, exports.getFilePadLength)({ lastFrame, countType, totalFrames });
+    const frameStr = countType === 'actual-frames'
+        ? String(frame).padStart(filePadLength, '0')
+        : String(index).padStart(filePadLength, '0');
+    if (imageSequencePattern) {
+        return (0, exports.getFrameOutputFileNameFromPattern)({
+            pattern: imageSequencePattern,
+            frame: frameStr,
+            ext: imageFormat,
+        });
+    }
+    const prefix = 'element';
+    if (countType === 'actual-frames') {
+        return `${prefix}-${frameStr}.${imageFormat}`;
+    }
+    if (countType === 'from-zero') {
+        return `${prefix}-${frameStr}.${imageFormat}`;
+    }
+    throw new TypeError('Unknown count type');
+};
+exports.getFrameOutputFileName = getFrameOutputFileName;
+const getFilePadLength = ({ lastFrame, totalFrames, countType, }) => {
+    if (countType === 'actual-frames') {
+        return String(lastFrame).length;
+    }
+    if (countType === 'from-zero') {
+        return String(totalFrames - 1).length;
+    }
+    throw new Error('Unknown file type');
+};
+exports.getFilePadLength = getFilePadLength;