@remotion/renderer 4.0.0-lambda.3 → 4.0.0-newpathfunctions.13

package/dist/get-compositions.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCompositions = void 0;
+const download_map_1 = require("./assets/download-map");
 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 make_assets_download_dir_1 = require("./make-assets-download-dir");
 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_ffmpeg_1 = require("./validate-ffmpeg");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     if (config === null || config === void 0 ? void 0 : config.onBrowserLog) {
@@ -14,8 +17,8 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
             var _a;
             (_a = config.onBrowserLog) === null || _a === void 0 ? void 0 : _a.call(config, {
                 stackTrace: log.stackTrace(),
-                text: log.text(),
-                type: log.type(),
+                text: log.text,
+                type: log.type,
             });
         });
     }
@@ -29,6 +32,8 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
         timeoutInMilliseconds: config === null || config === void 0 ? void 0 : config.timeoutInMilliseconds,
         proxyPort,
         retriesRemaining: 2,
+        audioEnabled: false,
+        videoEnabled: false,
     });
     await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         page,
@@ -40,7 +45,7 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
         frame: null,
         args: [],
     });
-    await page.waitForFunction('window.ready === true');
+    await (0, seek_to_frame_1.waitForReady)(page);
     const result = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         pageFunction: () => {
             return window.getStaticCompositions();
@@ -52,12 +57,14 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     return result;
 };
 const getCompositions = async (serveUrlOrWebpackUrl, config) => {
-    var _a, _b;
-    const downloadDir = (0, make_assets_download_dir_1.makeAssetsDownloadTmpDir)();
+    var _a, _b, _c, _d, _e;
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_a = config === null || config === void 0 ? void 0 : config.ffmpegExecutable) !== null && _a !== void 0 ? _a : null, (0, find_closest_package_json_1.findRemotionRoot)(), 'ffmpeg');
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_b = config === null || config === void 0 ? void 0 : config.ffprobeExecutable) !== null && _b !== void 0 ? _b : null, (0, find_closest_package_json_1.findRemotionRoot)(), 'ffprobe');
+    const downloadMap = (_c = config === null || config === void 0 ? void 0 : config.downloadMap) !== null && _c !== void 0 ? _c : (0, download_map_1.makeDownloadMap)();
     const { page, cleanup } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
         passedInInstance: config === null || config === void 0 ? void 0 : config.puppeteerInstance,
-        browserExecutable: (_a = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _a !== void 0 ? _a : null,
-        chromiumOptions: (_b = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _b !== void 0 ? _b : {},
+        browserExecutable: (_d = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _d !== void 0 ? _d : null,
+        chromiumOptions: (_e = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _e !== void 0 ? _e : {},
     });
     return new Promise((resolve, reject) => {
         var _a, _b, _c;
@@ -70,25 +77,37 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
         let close = null;
         (0, prepare_server_1.prepareServer)({
             webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
-            downloadDir,
             onDownload: () => undefined,
             onError,
             ffmpegExecutable: (_a = config === null || config === void 0 ? void 0 : config.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
             ffprobeExecutable: (_b = config === null || config === void 0 ? void 0 : config.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
             port: (_c = config === null || config === void 0 ? void 0 : config.port) !== null && _c !== void 0 ? _c : null,
+            downloadMap,
+            remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
         })
             .then(({ serveUrl, closeServer, offthreadPort }) => {
             close = closeServer;
             return innerGetCompositions(serveUrl, page, config !== null && config !== void 0 ? config : {}, offthreadPort);
         })
-            .then((comp) => resolve(comp))
+            .then((comp) => {
+            if (close) {
+                return Promise.all([comp, close(true)]);
+            }
+            return Promise.resolve([comp, null]);
+        })
+            .then(([comp]) => {
+            return resolve(comp);
+        })
             .catch((err) => {
             reject(err);
         })
             .finally(() => {
             cleanup();
-            close === null || close === void 0 ? void 0 : close();
             cleanupPageError();
+            // Clean download map if it was not passed in
+            if (!(config === null || config === void 0 ? void 0 : config.downloadMap)) {
+                (0, download_map_1.cleanDownloadMap)(downloadMap);
+            }
         });
     });
 };

package/dist/get-concurrency.d.ts

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

package/dist/get-concurrency.js

@@ -9,9 +9,16 @@ const getActualConcurrency = (userPreference) => {
     if (userPreference === null) {
         return Math.round(Math.min(8, Math.max(1, os_1.default.cpus().length / 2)));
     }
-    const rounded = Math.floor(userPreference);
     const max = os_1.default.cpus().length;
     const min = 1;
+    let rounded;
+    if (typeof userPreference === 'string') {
+        const percentage = parseInt(userPreference.slice(0, -1), 10);
+        rounded = Math.floor((percentage / 100) * max);
+    }
+    else {
+        rounded = Math.floor(userPreference);
+    }
     if (rounded > max) {
         throw new Error(`Maximum for --concurrency is ${max} (number of cores on this system)`);
     }

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

@@ -1,2 +1 @@
-import { FrameRange } from 'remotion';
-export declare const getDurationFromFrameRange: (frameRange: FrameRange | null, durationInFrames: number) => number;
+export declare const getFramesToRender: (frameRange: [number, number], everyNthFrame: number) => number[];

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

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

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

@@ -1,2 +1,2 @@
-import { Codec } from 'remotion';
-export declare const getFileExtensionFromCodec: (codec: Codec, type: 'chunk' | 'final') => "mp3" | "aac" | "wav" | "mp4" | "mkv" | "mov" | "webm";
+import type { Codec } from './codec';
+export declare const getFileExtensionFromCodec: (codec: Codec) => "mp3" | "aac" | "wav" | "gif" | "mp4" | "mkv" | "mov" | "webm";

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

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFileExtensionFromCodec = void 0;
-const getFileExtensionFromCodec = (codec, type) => {
+const codec_1 = require("./codec");
+const getFileExtensionFromCodec = (codec) => {
+    if (!codec_1.validCodecs.includes(codec)) {
+        throw new Error(`Codec must be one of the following: ${codec_1.validCodecs.join(', ')}, but got ${codec}`);
+    }
     switch (codec) {
         case 'aac':
             return 'aac';
@@ -9,10 +13,7 @@ const getFileExtensionFromCodec = (codec, type) => {
             return 'mp4';
         // The chunks will be rendered as mkv, but the final output will still be MP4
         case 'h264-mkv':
-            if (type === 'chunk') {
-                return 'mkv';
-            }
-            return 'mp4';
+            return 'mkv';
         case 'h265':
             return 'mp4';
         case 'mp3':
@@ -23,6 +24,8 @@ const getFileExtensionFromCodec = (codec, type) => {
             return 'webm';
         case 'vp9':
             return 'webm';
+        case 'gif':
+            return 'gif';
         case 'wav':
             return 'wav';
         default:

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

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

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

@@ -1,8 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExtensionOfFilename = void 0;
+const path_1 = __importDefault(require("path"));
 const getExtensionOfFilename = (filename) => {
-    const filenameArr = filename.split('.');
+    if (filename === null) {
+        return null;
+    }
+    const filenameArr = path_1.default.normalize(filename).split('.');
     const hasExtension = filenameArr.length >= 2;
     const filenameArrLength = filenameArr.length;
     const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;

package/dist/get-frame-of-video-slow.d.ts

@@ -0,0 +1,17 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const getFrameOfVideoSlow: ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }: {
+    ffmpegExecutable: FfmpegExecutable;
+    src: string;
+    duration: number;
+    imageFormat: OffthreadVideoImageFormat;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    needsResize: [
+        number,
+        number
+    ] | null;
+    offset: number;
+    fps: number | null;
+    remotionRoot: string;
+}) => Promise<Buffer>;

package/dist/get-frame-of-video-slow.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFrameOfVideoSlow = void 0;
+// Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
+// if the video is corrupted
+const execa_1 = __importDefault(require("execa"));
+const determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmpeg_flags_1 = require("./determine-vcodec-ffmpeg-flags");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const truthy_1 = require("./truthy");
+const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }) => {
+    console.warn(`\nUsing a slow method to extract the frame at ${duration}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
+    const actualOffset = `-${duration * 1000 - offset}ms`;
+    const command = [
+        '-itsoffset',
+        actualOffset,
+        ...(0, determine_vcodec_ffmpeg_flags_1.determineVcodecFfmpegFlags)(specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
+        '-',
+    ].filter(truthy_1.truthy);
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), command);
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => stdoutChunks.push(d));
+        stdout.on('error', (err) => reject(err));
+        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
+    });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        if (offset > 70) {
+            throw new Error(`Could not get last frame of ${src}. Tried to seek to the end using the command "ffmpeg ${command.join(' ')}" but got no frame. Most likely this video is corrupted.`);
+        }
+        return (0, exports.getFrameOfVideoSlow)({
+            ffmpegExecutable,
+            duration,
+            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
+            offset: offset + (fps === null ? 10 : 1000 / fps),
+            src,
+            imageFormat,
+            specialVCodecForTransparency,
+            needsResize,
+            fps,
+            remotionRoot,
+        });
+    }
+    return stdoutBuffer;
+};
+exports.getFrameOfVideoSlow = getFrameOfVideoSlow;

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

@@ -0,0 +1,14 @@
+export declare type CountType = 'from-zero' | 'actual-frames';
+export declare const getFrameOutputFileName: ({ index, frame, imageFormat, countType, lastFrame, totalFrames, }: {
+    index: number;
+    frame: number;
+    imageFormat: 'png' | 'jpeg' | 'none';
+    countType: CountType;
+    lastFrame: number;
+    totalFrames: number;
+}) => string;
+export declare const getFilePadLength: ({ lastFrame, totalFrames, countType, }: {
+    lastFrame: number;
+    totalFrames: number;
+    countType: CountType;
+}) => number;

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

@@ -0,0 +1,34 @@
+"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 = void 0;
+const padIndex = ({ num, filePadLength, }) => {
+    return String(num).padStart(filePadLength, '0');
+};
+const getFrameOutputFileName = ({ index, frame, imageFormat, countType, lastFrame, totalFrames, }) => {
+    const filePadLength = (0, exports.getFilePadLength)({ lastFrame, countType, totalFrames });
+    const prefix = 'element';
+    if (countType === 'actual-frames') {
+        const paddedIndex = padIndex({ filePadLength, num: frame });
+        return `${prefix}-${paddedIndex}.${imageFormat}`;
+    }
+    if (countType === 'from-zero') {
+        const paddedIndex = padIndex({ filePadLength, num: index });
+        return `${prefix}-${paddedIndex}.${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;

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

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

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

@@ -1,3 +1,4 @@
-import { Browser, BrowserExecutable } from 'remotion';
+import type { Browser } from './browser';
+import type { BrowserExecutable } from './browser-executable';
 export declare const ensureLocalBrowser: (browser: Browser, preferredBrowserExecutable: BrowserExecutable) => Promise<void>;
 export declare const getLocalBrowserExecutable: (browser: Browser, preferredBrowserExecutable: BrowserExecutable) => string;

package/dist/get-local-browser-executable.js

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalBrowserExecutable = exports.ensureLocalBrowser = void 0;
 const fs_1 = __importDefault(require("fs"));
-const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
-const install_1 = require("puppeteer-core/lib/cjs/puppeteer/node/install");
-const revisions_1 = require("puppeteer-core/lib/cjs/puppeteer/revisions");
+const create_browser_fetcher_1 = require("./browser/create-browser-fetcher");
+const node_1 = require("./browser/node");
+const revisions_1 = require("./browser/revisions");
 const getSearchPathsForProduct = (product) => {
     var _a;
     if (product === 'chrome') {
@@ -44,12 +44,12 @@ const getLocalBrowser = (product) => {
     return null;
 };
 const getBrowserRevision = (product) => {
-    const browserFetcher = puppeteer_core_1.default.createBrowserFetcher({
+    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
         product,
+        path: null,
+        platform: null,
     });
-    const revisionInfo = browserFetcher.revisionInfo(product === 'firefox'
-        ? revisions_1.PUPPETEER_REVISIONS.firefox
-        : revisions_1.PUPPETEER_REVISIONS.chromium);
+    const revisionInfo = browserFetcher.revisionInfo(revisions_1.PUPPETEER_REVISIONS.chromium);
     return revisionInfo;
 };
 const getBrowserStatus = (product, browserExecutablePath) => {
@@ -73,7 +73,7 @@ const ensureLocalBrowser = async (browser, preferredBrowserExecutable) => {
     const status = getBrowserStatus(mapBrowserToProduct(browser), preferredBrowserExecutable);
     if (status.type === 'no-browser') {
         console.log('No local browser could be found. Downloading one from the internet...');
-        await (0, install_1.downloadBrowser)();
+        await (0, create_browser_fetcher_1.downloadBrowser)(browser);
     }
 };
 exports.ensureLocalBrowser = ensureLocalBrowser;

package/dist/get-port.d.ts

@@ -1 +1,4 @@
-export declare const getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<number>;
+export declare const getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<{
+    port: number;
+    didUsePort: () => void;
+}>;

package/dist/get-port.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDesiredPort = void 0;
 const net_1 = __importDefault(require("net"));
-const p_limit_1 = require("./p-limit");
+const locks_1 = require("./locks");
 const getAvailablePort = (portToTry) => new Promise((resolve) => {
     let status = 'unavailable';
     const host = '127.0.0.1';
@@ -14,7 +14,7 @@ const getAvailablePort = (portToTry) => new Promise((resolve) => {
         status = 'unavailable';
         socket.destroy();
     });
-    socket.setTimeout(1000);
+    socket.setTimeout(3000);
     socket.on('timeout', () => {
         status = 'unavailable';
         socket.destroy();
@@ -26,36 +26,30 @@ const getAvailablePort = (portToTry) => new Promise((resolve) => {
     socket.on('close', () => resolve(status));
     socket.connect(portToTry, host);
 });
-const portCheckSequence = function* (ports) {
-    if (ports) {
-        yield* ports;
-    }
-    yield 0; // Fall back to 0 if anything else failed
-};
 const getPort = async (from, to) => {
     const ports = makeRange(from, to);
-    for (const port of portCheckSequence(ports)) {
+    for (const port of ports) {
         if ((await getAvailablePort(port)) === 'available') {
             return port;
         }
     }
     throw new Error('No available ports found');
 };
-const getDesiredPortUnlimited = async (desiredPort, from, to) => {
+const portLocks = (0, locks_1.createLock)({ timeout: 10000 });
+const getDesiredPort = async (desiredPort, from, to) => {
+    await portLocks.waitForAllToBeDone();
+    const lockPortSelection = portLocks.lock();
+    const didUsePort = () => portLocks.unlock(lockPortSelection);
     if (typeof desiredPort !== 'undefined' &&
         (await getAvailablePort(desiredPort)) === 'available') {
-        return desiredPort;
+        return { port: desiredPort, didUsePort };
     }
     const actualPort = await getPort(from, to);
     // If did specify a port but did not get that one, fail hard.
     if (desiredPort && desiredPort !== actualPort) {
         throw new Error(`You specified port ${desiredPort} to be used for the HTTP server, but it is not available. Choose a different port or remove the setting to let Remotion automatically select a free port.`);
     }
-    return actualPort;
-};
-const limit = (0, p_limit_1.pLimit)(1);
-const getDesiredPort = (desiredPort, from, to) => {
-    return limit(() => getDesiredPortUnlimited(desiredPort, from, to));
+    return { port: actualPort, didUsePort };
 };
 exports.getDesiredPort = getDesiredPort;
 const makeRange = (from, to) => {
@@ -71,10 +65,7 @@ const makeRange = (from, to) => {
     if (to < from) {
         throw new RangeError('`to` must be greater than or equal to `from`');
     }
-    const generator = function* (f, t) {
-        for (let port = f; port <= t; port++) {
-            yield port;
-        }
-    };
-    return generator(from, to);
+    return new Array(to - from + 1).fill(true).map((_, i) => {
+        return i + from;
+    });
 };

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

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

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

@@ -0,0 +1,8 @@
+import type { DownloadMap, Vp9Result } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<Vp9Result>;
+export declare const getVideoInfo: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<Vp9Result>;

package/dist/get-video-info.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoInfo = exports.getVideoInfoUncached = void 0;
+const execa_1 = __importDefault(require("execa"));
+const calculate_sar_dar_pixels_1 = require("./calculate-sar-dar-pixels");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const p_limit_1 = require("./p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+async function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }) {
+    var _a;
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), [src]);
+    const isVp9 = task.stderr.includes('Video: vp9');
+    const isVp8 = task.stderr.includes('Video: vp8');
+    const dimensions = (_a = task.stderr
+        .split('\n')
+        .find((n) => n.trim().startsWith('Stream #'))) === null || _a === void 0 ? void 0 : _a.match(/([0-9]{2,6})x([0-9]{2,6})/);
+    const dar = task.stderr.match(/DAR\s([0-9]+):([0-9]+)/);
+    let needsResize = null;
+    if (dimensions && dar) {
+        const width = parseInt(dimensions[1], 10);
+        const height = parseInt(dimensions[2], 10);
+        const darWidth = parseInt(dar[1], 10);
+        const darHeight = parseInt(dar[2], 10);
+        const { width: actualWidth, height: actualHeight } = (0, calculate_sar_dar_pixels_1.calculateDisplayVideoSize)({
+            darX: darWidth,
+            darY: darHeight,
+            x: width,
+            y: height,
+        });
+        if (actualWidth !== width || actualHeight !== height) {
+            needsResize = [actualWidth, actualHeight];
+        }
+    }
+    const result = {
+        specialVcodecForTransparency: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
+        needsResize,
+    };
+    return result;
+}
+exports.getVideoInfoUncached = getVideoInfoUncached;
+async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
+        return downloadMap.isVp9VideoCache[src];
+    }
+    const result = await getVideoInfoUncached({
+        ffprobeExecutable,
+        remotionRoot,
+        src,
+    });
+    downloadMap.isVp9VideoCache[src] = result;
+    return downloadMap.isVp9VideoCache[src];
+}
+const getVideoInfo = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
+};
+exports.getVideoInfo = getVideoInfo;

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

@@ -0,0 +1,2 @@
+import type { CompositorLayer } from './compositor/payloads';
+export declare const getNativeVideoSignals: (layers: CompositorLayer[]) => Record<string, Record<number, number>>;

package/dist/get-video-signals.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNativeVideoSignals = void 0;
+const getNativeVideoSignals = (layers) => {
+    const videoSignals = layers
+        .filter((l) => {
+        return l.type === 'VideoFrame';
+    })
+        .map((l) => {
+        if (l.type !== 'VideoFrame') {
+            throw new Error('Expected VideoFrame');
+        }
+        return { frame: l.params.frame, src: l.params.src };
+    });
+    const map = {};
+    // Return a map for each video source and the number of times each frame is expected to be used
+    for (const { src, frame } of videoSignals) {
+        if (!map[src]) {
+            map[src] = {};
+        }
+        if (!map[src][frame]) {
+            map[src][frame] = 0;
+        }
+        map[src][frame]++;
+    }
+    return map;
+};
+exports.getNativeVideoSignals = getNativeVideoSignals;

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdealVideoThreadsFlag = void 0;
+const os_1 = __importDefault(require("os"));
+const MEMORY_USAGE_PER_THREAD = 400000000; // 400MB
+const RESERVED_MEMORY = 2000000000;
+const getIdealVideoThreadsFlag = () => {
+    const freeMemory = os_1.default.freemem();
+    const cpus = os_1.default.cpus().length;
+    const maxRecommendedBasedOnCpus = (cpus * 2) / 3;
+    const maxRecommendedBasedOnMemory = (freeMemory - RESERVED_MEMORY) / MEMORY_USAGE_PER_THREAD;
+    const maxRecommended = Math.min(maxRecommendedBasedOnCpus, maxRecommendedBasedOnMemory);
+    return Math.max(1, Math.round(maxRecommended));
+};
+exports.getIdealVideoThreadsFlag = getIdealVideoThreadsFlag;

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

@@ -0,0 +1,5 @@
+export declare const guessExtensionForVideo: ({ src, remotionRoot, ffprobeBinary, }: {
+    src: string;
+    remotionRoot: string;
+    ffprobeBinary: string | null;
+}) => Promise<"mp3" | "wav" | "mp4" | "webm">;