@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/path-normalize.js

@@ -0,0 +1,132 @@
+"use strict";
+// https://github.com/zacanger/path-normalize/blob/master/src/index.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathNormalize = void 0;
+/**
+ * Copyright © 2022 Zac Anger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+const SLASH = 47;
+const DOT = 46;
+const assertPath = (path) => {
+    const t = typeof path;
+    if (t !== 'string') {
+        throw new TypeError(`Expected a string, got a ${t}`);
+    }
+};
+// this function is directly from node source
+const posixNormalize = (path, allowAboveRoot) => {
+    let res = '';
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length) {
+            code = path.charCodeAt(i);
+        }
+        else if (code === SLASH) {
+            break;
+        }
+        else {
+            code = SLASH;
+        }
+        if (code === SLASH) {
+            if (lastSlash === i - 1 || dots === 1) {
+                // NOOP
+            }
+            else if (lastSlash !== i - 1 && dots === 2) {
+                if (res.length < 2 ||
+                    lastSegmentLength !== 2 ||
+                    res.charCodeAt(res.length - 1) !== DOT ||
+                    res.charCodeAt(res.length - 2) !== DOT) {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf('/');
+                        if (lastSlashIndex !== res.length - 1) {
+                            if (lastSlashIndex === -1) {
+                                res = '';
+                                lastSegmentLength = 0;
+                            }
+                            else {
+                                res = res.slice(0, lastSlashIndex);
+                                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+                            }
+                            lastSlash = i;
+                            dots = 0;
+                            continue;
+                        }
+                    }
+                    else if (res.length === 2 || res.length === 1) {
+                        res = '';
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    if (res.length > 0) {
+                        res += '/..';
+                    }
+                    else {
+                        res = '..';
+                    }
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0) {
+                    res += '/' + path.slice(lastSlash + 1, i);
+                }
+                else {
+                    res = path.slice(lastSlash + 1, i);
+                }
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (code === DOT && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+};
+const decode = (s) => {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch (_a) {
+        return s;
+    }
+};
+const pathNormalize = (p) => {
+    assertPath(p);
+    let path = p;
+    if (path.length === 0) {
+        return '.';
+    }
+    const isAbsolute = path.charCodeAt(0) === SLASH;
+    const trailingSeparator = path.charCodeAt(path.length - 1) === SLASH;
+    path = decode(path);
+    path = posixNormalize(path, !isAbsolute);
+    if (path.length === 0 && !isAbsolute) {
+        path = '.';
+    }
+    if (path.length > 0 && trailingSeparator) {
+        path += '/';
+    }
+    if (isAbsolute) {
+        return '/' + path;
+    }
+    return path;
+};
+exports.pathNormalize = pathNormalize;

package/package/dist/perf.d.ts

@@ -0,0 +1,5 @@
+type PerfId = 'capture' | 'extract-frame' | 'piping';
+export declare const startPerfMeasure: (marker: PerfId) => number;
+export declare const stopPerfMeasure: (id: number) => void;
+export declare const getPerf: () => string[];
+export {};

package/package/dist/perf.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPerf = exports.stopPerfMeasure = exports.startPerfMeasure = void 0;
+const perf = {
+    capture: [],
+    'extract-frame': [],
+    piping: [],
+};
+const map = {};
+const startPerfMeasure = (marker) => {
+    const id = Math.random();
+    map[id] = {
+        id,
+        marker,
+        start: Date.now(),
+    };
+    return id;
+};
+exports.startPerfMeasure = startPerfMeasure;
+const stopPerfMeasure = (id) => {
+    const now = Date.now();
+    const diff = now - map[id].start;
+    perf[map[id].marker].push(diff);
+    delete map[id];
+};
+exports.stopPerfMeasure = stopPerfMeasure;
+const getPerf = () => {
+    return [
+        'Render performance:',
+        ...Object.keys(perf)
+            .filter((p) => perf[p].length)
+            .map((p) => {
+            return `  ${p} => ${Math.round(perf[p].reduce((a, b) => a + b, 0) / perf[p].length)}ms (n = ${perf[p].length})`;
+        }),
+    ];
+};
+exports.getPerf = getPerf;

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

@@ -0,0 +1,6 @@
+import type { Codec } from './codec';
+export declare const validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
+export type PixelFormat = (typeof validPixelFormats)[number];
+export declare const DEFAULT_PIXEL_FORMAT: PixelFormat;
+export declare const validPixelFormatsForCodec: (codec: Codec) => readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"] | ("yuv420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le")[];
+export declare const validateSelectedPixelFormatAndCodecCombination: (pixelFormat: PixelFormat | undefined, codec: Codec) => undefined;

package/package/dist/pixel-format.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSelectedPixelFormatAndCodecCombination = exports.validPixelFormatsForCodec = exports.DEFAULT_PIXEL_FORMAT = exports.validPixelFormats = void 0;
+exports.validPixelFormats = [
+    'yuv420p',
+    'yuva420p',
+    'yuv422p',
+    'yuv444p',
+    'yuv420p10le',
+    'yuv422p10le',
+    'yuv444p10le',
+    'yuva444p10le',
+];
+exports.DEFAULT_PIXEL_FORMAT = 'yuv420p';
+const validPixelFormatsForCodec = (codec) => {
+    if (codec === 'vp8' || codec === 'vp9') {
+        return exports.validPixelFormats;
+    }
+    return exports.validPixelFormats.filter((format) => format !== 'yuva420p');
+};
+exports.validPixelFormatsForCodec = validPixelFormatsForCodec;
+const validateSelectedPixelFormatAndCodecCombination = (pixelFormat, codec) => {
+    if (typeof pixelFormat === 'undefined') {
+        return pixelFormat;
+    }
+    if (!exports.validPixelFormats.includes(pixelFormat)) {
+        throw new TypeError(`Value ${pixelFormat} is not valid as a pixel format.`);
+    }
+    if (pixelFormat !== 'yuva420p') {
+        return;
+    }
+    const validFormats = (0, exports.validPixelFormatsForCodec)(codec);
+    if (!validFormats.includes(pixelFormat)) {
+        throw new TypeError(`Pixel format was set to 'yuva420p' but codec ${codec} does not support it. Valid pixel formats for codec ${codec} are: ${validFormats.join(', ')}.`);
+    }
+};
+exports.validateSelectedPixelFormatAndCodecCombination = validateSelectedPixelFormatAndCodecCombination;

package/package/dist/pool.d.ts

@@ -0,0 +1,8 @@
+import type { Page } from './browser/BrowserPage';
+export declare class Pool {
+    resources: Page[];
+    waiters: ((r: Page) => void)[];
+    constructor(resources: Page[]);
+    acquire(): Promise<Page>;
+    release(resource: Page): void;
+}

package/package/dist/pool.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pool = void 0;
+class Pool {
+    constructor(resources) {
+        this.resources = resources;
+        this.waiters = [];
+    }
+    acquire() {
+        const resource = this.resources.shift();
+        if (resource !== undefined) {
+            return Promise.resolve(resource);
+        }
+        return new Promise((resolve) => {
+            this.waiters.push((freeResource) => {
+                resolve(freeResource);
+            });
+        });
+    }
+    release(resource) {
+        const waiter = this.waiters.shift();
+        if (waiter === undefined) {
+            this.resources.push(resource);
+        }
+        else {
+            waiter(resource);
+        }
+    }
+}
+exports.Pool = Pool;

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

@@ -0,0 +1,14 @@
+import type { NetworkInterfaceInfo } from 'os';
+import os from 'os';
+type PortConfig = {
+    host: string;
+    hostsToTry: string[];
+};
+export declare const getPortConfig: (preferIpv4: boolean) => PortConfig;
+export declare const getHostToBind: (flattened: os.NetworkInterfaceInfo[], preferIpv4: boolean) => "0.0.0.0" | "::";
+export declare const getHostsToTry: (flattened: os.NetworkInterfaceInfo[]) => string[];
+export declare const flattenNetworkInterfaces: (networkInterfaces: NodeJS.Dict<NetworkInterfaceInfo[]>) => NetworkInterfaceInfo[];
+export declare const isIpV6Supported: (flattened: os.NetworkInterfaceInfo[]) => boolean;
+export declare const hasIPv6LoopbackAddress: (flattened: os.NetworkInterfaceInfo[]) => boolean;
+export declare const hasIpv4LoopbackAddress: (flattened: os.NetworkInterfaceInfo[]) => boolean;
+export {};

package/package/dist/port-config.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasIpv4LoopbackAddress = exports.hasIPv6LoopbackAddress = exports.isIpV6Supported = exports.flattenNetworkInterfaces = exports.getHostsToTry = exports.getHostToBind = exports.getPortConfig = void 0;
+const os_1 = __importDefault(require("os"));
+const truthy_1 = require("./truthy");
+let cached = null;
+const getPortConfig = (preferIpv4) => {
+    if (cached) {
+        return cached;
+    }
+    const networkInterfaces = os_1.default.networkInterfaces();
+    const flattened = (0, exports.flattenNetworkInterfaces)(networkInterfaces);
+    const host = (0, exports.getHostToBind)(flattened, preferIpv4);
+    const hostsToTry = (0, exports.getHostsToTry)(flattened);
+    const response = { host, hostsToTry };
+    cached = response;
+    return response;
+};
+exports.getPortConfig = getPortConfig;
+const getHostToBind = (flattened, preferIpv4) => {
+    if (preferIpv4 || !(0, exports.isIpV6Supported)(flattened)) {
+        return '0.0.0.0';
+    }
+    return '::';
+};
+exports.getHostToBind = getHostToBind;
+const getHostsToTry = (flattened) => {
+    return [
+        (0, exports.hasIPv6LoopbackAddress)(flattened) ? '::1' : null,
+        (0, exports.hasIpv4LoopbackAddress)(flattened) ? '127.0.0.1' : null,
+        (0, exports.isIpV6Supported)(flattened) ? '::' : null,
+        '0.0.0.0',
+    ].filter(truthy_1.truthy);
+};
+exports.getHostsToTry = getHostsToTry;
+const flattenNetworkInterfaces = (networkInterfaces) => {
+    const result = [];
+    for (const iface in networkInterfaces) {
+        for (const configuration of networkInterfaces[iface]) {
+            result.push(configuration);
+        }
+    }
+    return result;
+};
+exports.flattenNetworkInterfaces = flattenNetworkInterfaces;
+const isIpV6Supported = (flattened) => {
+    for (const configuration of flattened) {
+        if (configuration.family === 'IPv6' && !configuration.internal) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.isIpV6Supported = isIpV6Supported;
+const hasIPv6LoopbackAddress = (flattened) => {
+    for (const configuration of flattened) {
+        if (configuration.family === 'IPv6' &&
+            configuration.internal &&
+            configuration.address === '::1') {
+            return true;
+        }
+    }
+    return false;
+};
+exports.hasIPv6LoopbackAddress = hasIPv6LoopbackAddress;
+const hasIpv4LoopbackAddress = (flattened) => {
+    for (const configuration of flattened) {
+        if (configuration.family === 'IPv4' &&
+            configuration.internal &&
+            configuration.address === '127.0.0.1') {
+            return true;
+        }
+    }
+    return false;
+};
+exports.hasIpv4LoopbackAddress = hasIpv4LoopbackAddress;

package/package/dist/prepare-server.d.ts

@@ -0,0 +1,32 @@
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { DownloadMap } from './assets/download-map';
+import type { SourceMapGetter } from './browser/source-map-getter';
+import type { Compositor } from './compositor/compositor';
+import type { LogLevel } from './log-level';
+export type RemotionServer = {
+    serveUrl: string;
+    closeServer: (force: boolean) => Promise<unknown>;
+    offthreadPort: number;
+    compositor: Compositor;
+    sourceMap: SourceMapGetter;
+    downloadMap: DownloadMap;
+};
+type PrepareServerOptions = {
+    webpackConfigOrServeUrl: string;
+    port: number | null;
+    remotionRoot: string;
+    offthreadVideoThreads: number;
+    logLevel: LogLevel;
+    indent: boolean;
+    offthreadVideoCacheSizeInBytes: number | null;
+    binariesDirectory: string | null;
+    forceIPv4: boolean;
+};
+export declare const prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, offthreadVideoThreads, logLevel, indent, offthreadVideoCacheSizeInBytes, binariesDirectory, forceIPv4, }: PrepareServerOptions) => Promise<RemotionServer>;
+export declare const makeOrReuseServer: (server: RemotionServer | undefined, config: PrepareServerOptions, { onDownload, }: {
+    onDownload: RenderMediaOnDownload | null;
+}) => Promise<{
+    server: RemotionServer;
+    cleanupServer: (force: boolean) => Promise<unknown>;
+}>;
+export {};

package/package/dist/prepare-server.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOrReuseServer = exports.prepareServer = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const no_react_1 = require("remotion/no-react");
+const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
+const download_map_1 = require("./assets/download-map");
+const get_bundle_url_from_serve_url_1 = require("./get-bundle-url-from-serve-url");
+const is_serve_url_1 = require("./is-serve-url");
+const logger_1 = require("./logger");
+const normalize_serve_url_1 = require("./normalize-serve-url");
+const serve_static_1 = require("./serve-static");
+const symbolicate_stacktrace_1 = require("./symbolicate-stacktrace");
+const wait_for_symbolication_error_to_be_done_1 = require("./wait-for-symbolication-error-to-be-done");
+const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, offthreadVideoThreads, logLevel, indent, offthreadVideoCacheSizeInBytes, binariesDirectory, forceIPv4, }) => {
+    const downloadMap = (0, download_map_1.makeDownloadMap)();
+    logger_1.Log.verbose({ indent, logLevel }, 'Created directory for temporary files', downloadMap.assetDir);
+    if ((0, is_serve_url_1.isServeUrl)(webpackConfigOrServeUrl)) {
+        const { port: offthreadPort, close: closeProxy, compositor: comp, } = await (0, serve_static_1.serveStatic)(null, {
+            port,
+            downloadMap,
+            remotionRoot,
+            offthreadVideoThreads,
+            logLevel,
+            indent,
+            offthreadVideoCacheSizeInBytes,
+            binariesDirectory,
+            forceIPv4,
+        });
+        const normalized = (0, normalize_serve_url_1.normalizeServeUrl)(webpackConfigOrServeUrl);
+        let remoteSourceMap = null;
+        (0, symbolicate_stacktrace_1.getSourceMapFromRemoteUrl)((0, get_bundle_url_from_serve_url_1.getBundleMapUrlFromServeUrl)(normalized))
+            .then((s) => {
+            remoteSourceMap = s;
+        })
+            .catch((err) => {
+            logger_1.Log.verbose({ indent, logLevel }, 'Could not fetch sourcemap for ', normalized, err);
+        });
+        return Promise.resolve({
+            serveUrl: normalized,
+            closeServer: () => {
+                (0, download_map_1.cleanDownloadMap)(downloadMap);
+                remoteSourceMap === null || remoteSourceMap === void 0 ? void 0 : remoteSourceMap.destroy();
+                remoteSourceMap = null;
+                return closeProxy();
+            },
+            offthreadPort,
+            compositor: comp,
+            sourceMap: () => remoteSourceMap,
+            downloadMap,
+        });
+    }
+    // Check if the path has a `index.html` file
+    const indexFile = node_path_1.default.join(webpackConfigOrServeUrl, 'index.html');
+    const exists = (0, node_fs_1.existsSync)(indexFile);
+    if (!exists) {
+        throw new Error(`Tried to serve the Webpack bundle on a HTTP server, but the file ${indexFile} does not exist. Is this a valid path to a Webpack bundle?`);
+    }
+    let localSourceMap = null;
+    (0, symbolicate_stacktrace_1.getSourceMapFromLocalFile)(node_path_1.default.join(webpackConfigOrServeUrl, no_react_1.NoReactInternals.bundleName))
+        .then((s) => {
+        localSourceMap = s;
+    })
+        .catch((err) => {
+        logger_1.Log.verbose({ indent, logLevel }, 'Could not fetch sourcemap for ', webpackConfigOrServeUrl, err);
+    });
+    const { port: serverPort, close, compositor, } = await (0, serve_static_1.serveStatic)(webpackConfigOrServeUrl, {
+        port,
+        downloadMap,
+        remotionRoot,
+        offthreadVideoThreads,
+        logLevel,
+        indent,
+        offthreadVideoCacheSizeInBytes,
+        binariesDirectory,
+        forceIPv4,
+    });
+    return Promise.resolve({
+        closeServer: async (force) => {
+            localSourceMap === null || localSourceMap === void 0 ? void 0 : localSourceMap.destroy();
+            localSourceMap = null;
+            (0, download_map_1.cleanDownloadMap)(downloadMap);
+            if (!force) {
+                await (0, wait_for_symbolication_error_to_be_done_1.waitForSymbolicationToBeDone)();
+            }
+            return close();
+        },
+        // This should be kept localhost, even if the server is bound to ::1,
+        // to prevent "Failed to load resource: net::ERR_FAILED  Access to image at 'http://localhost:3000/proxy?src=http%3A%2F%2F%5B%3A%3A%5D%3A3000%2Fpublic%2Fframer.webm&time=0&transparent=false' from origin 'http://[::]:3000' has been blocked by CORS policy: The request client is not a secure context and the resource is in more-private address space `local`".
+        serveUrl: `http://localhost:${serverPort}`,
+        offthreadPort: serverPort,
+        compositor,
+        sourceMap: () => localSourceMap,
+        downloadMap,
+    });
+};
+exports.prepareServer = prepareServer;
+const makeOrReuseServer = async (server, config, { onDownload, }) => {
+    if (server) {
+        const cleanupOnDownload = (0, download_and_map_assets_to_file_1.attachDownloadListenerToEmitter)(server.downloadMap, onDownload);
+        return {
+            server,
+            cleanupServer: () => {
+                cleanupOnDownload();
+                return Promise.resolve();
+            },
+        };
+    }
+    const newServer = await (0, exports.prepareServer)(config);
+    const cleanupOnDownloadNew = (0, download_and_map_assets_to_file_1.attachDownloadListenerToEmitter)(newServer.downloadMap, onDownload);
+    return {
+        server: newServer,
+        cleanupServer: (force) => {
+            cleanupOnDownloadNew();
+            return Promise.all([newServer.closeServer(force)]);
+        },
+    };
+};
+exports.makeOrReuseServer = makeOrReuseServer;

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

@@ -0,0 +1,27 @@
+import type { DownloadMap } from './assets/download-map';
+import type { MediaAsset } from './assets/types';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { ProcessedTrack } from './stringify-ffmpeg-filter';
+type Options = {
+    outName: string;
+    asset: MediaAsset;
+    fps: number;
+    downloadMap: DownloadMap;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    chunkLengthInSeconds: number;
+    trimLeftOffset: number;
+    trimRightOffset: number;
+    forSeamlessAacConcatenation: boolean;
+    onProgress: (progress: number) => void;
+    audioStreamIndex: number;
+};
+export type PreprocessedAudioTrack = {
+    outName: string;
+    filter: ProcessedTrack;
+};
+export declare const preprocessAudioTrack: (options: Options) => Promise<PreprocessedAudioTrack | null>;
+export {};

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessAudioTrack = void 0;
+const flatten_volume_array_1 = require("./assets/flatten-volume-array");
+const get_audio_channels_1 = require("./assets/get-audio-channels");
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
+const logger_1 = require("./logger");
+const p_limit_1 = require("./p-limit");
+const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
+const resolve_asset_src_1 = require("./resolve-asset-src");
+const sample_rate_1 = require("./sample-rate");
+const stringify_ffmpeg_filter_1 = require("./stringify-ffmpeg-filter");
+const truthy_1 = require("./truthy");
+const preprocessAudioTrackUnlimited = async ({ outName, asset, fps, downloadMap, indent, logLevel, binariesDirectory, cancelSignal, onProgress, chunkLengthInSeconds, trimLeftOffset, trimRightOffset, forSeamlessAacConcatenation, audioStreamIndex, }) => {
+    var _a;
+    const { channels, duration, startTime } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)({
+        downloadMap,
+        src: (0, resolve_asset_src_1.resolveAssetSrc)(asset.src),
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+        audioStreamIndex,
+    });
+    const filter = (0, stringify_ffmpeg_filter_1.stringifyFfmpegFilter)({
+        asset,
+        fps,
+        channels,
+        assetDuration: duration,
+        chunkLengthInSeconds,
+        trimLeftOffset,
+        trimRightOffset,
+        forSeamlessAacConcatenation,
+        volume: (0, flatten_volume_array_1.flattenVolumeArray)(asset.volume),
+        indent,
+        logLevel,
+        presentationTimeOffsetInSeconds: startTime !== null && startTime !== void 0 ? startTime : 0,
+    });
+    if (filter === null) {
+        return null;
+    }
+    const { cleanup, file } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(filter, downloadMap);
+    const args = [
+        ['-hide_banner'],
+        ['-i', (0, resolve_asset_src_1.resolveAssetSrc)(asset.src)],
+        audioStreamIndex ? ['-map', `0:a:${audioStreamIndex}`] : [],
+        ['-ac', '2'],
+        file ? ['-filter_script:a', file] : null,
+        ['-c:a', 'pcm_s16le'],
+        ['-ar', String(sample_rate_1.DEFAULT_SAMPLE_RATE)],
+        ['-y', outName],
+    ]
+        .flat(2)
+        .filter(truthy_1.truthy);
+    logger_1.Log.verbose({ indent, logLevel }, 'Preprocessing audio track:', JSON.stringify(args.join(' ')), 'Filter:', filter.filter);
+    const startTimestamp = Date.now();
+    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 - filter.actualTrimLeft * fps) / (chunkLengthInSeconds * fps));
+        }
+    });
+    await task;
+    logger_1.Log.verbose({ indent, logLevel }, 'Preprocessed audio track', `${Date.now() - startTimestamp}ms`);
+    cleanup();
+    return { outName, filter };
+};
+const limit = (0, p_limit_1.pLimit)(2);
+const preprocessAudioTrack = (options) => {
+    return limit(preprocessAudioTrackUnlimited, options);
+};
+exports.preprocessAudioTrack = preprocessAudioTrack;

package/package/dist/prespawn-ffmpeg.d.ts

@@ -0,0 +1,49 @@
+import type { HardwareAccelerationOption } from './client';
+import type { Codec } from './codec';
+import type { FfmpegOverrideFn } from './ffmpeg-override';
+import type { VideoImageFormat } from './image-format';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { ColorSpace } from './options/color-space';
+import type { X264Preset } from './options/x264-preset';
+import type { PixelFormat } from './pixel-format';
+import type { ProResProfile } from './prores-profile';
+type RunningStatus = {
+    type: 'running';
+} | {
+    type: 'quit-successfully';
+    stderr: string;
+} | {
+    type: 'quit-with-error';
+    exitCode: number;
+    stderr: string;
+};
+type PreStitcherOptions = {
+    fps: number;
+    width: number;
+    height: number;
+    outputLocation: string;
+    pixelFormat: PixelFormat | undefined;
+    codec: Codec | undefined;
+    crf: number | null | undefined;
+    x264Preset: X264Preset | null;
+    onProgress: (progress: number) => void;
+    proResProfile: ProResProfile | undefined;
+    logLevel: LogLevel;
+    imageFormat: VideoImageFormat;
+    ffmpegOverride: FfmpegOverrideFn;
+    signal: CancelSignal;
+    videoBitrate: string | null;
+    encodingMaxRate: string | null;
+    encodingBufferSize: string | null;
+    indent: boolean;
+    colorSpace: ColorSpace | null;
+    binariesDirectory: string | null;
+    hardwareAcceleration: HardwareAccelerationOption;
+};
+export declare const prespawnFfmpeg: (options: PreStitcherOptions) => {
+    task: import("execa").ExecaChildProcess<string>;
+    getLogs: () => string;
+    getExitStatus: () => RunningStatus;
+};
+export {};