@remotion/renderer 4.1.0-alpha3 → 4.1.0-alpha4

package/dist/assets/get-video-stream-duration.d.ts

@@ -0,0 +1,9 @@
+import type { FfmpegExecutable } from '../ffmpeg-executable';
+import type { DownloadMap, VideoDurationResult } from './download-map';
+export declare const parseVideoStreamDuration: (stdout: string) => VideoDurationResult;
+export declare function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<VideoDurationResult>;
+export declare const getVideoStreamDuration: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<VideoDurationResult>;

package/dist/assets/get-video-stream-duration.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoStreamDuration = exports.getVideoStreamDurationwithoutCache = exports.parseVideoStreamDuration = void 0;
+const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("../ffmpeg-flags");
+const p_limit_1 = require("../p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+const parseAlternativeDuration = (stdout) => {
+    const webmDuration = stdout.match(/TAG:DURATION=([0-9.]+):([0-9.]+):([0-9.]+)/);
+    if (!webmDuration) {
+        return null;
+    }
+    const [, hours, minutes, seconds] = webmDuration;
+    const hoursAsNumber = Number(hours);
+    if (Number.isNaN(hoursAsNumber)) {
+        return null;
+    }
+    const minutesAsNumber = Number(minutes);
+    if (Number.isNaN(minutesAsNumber)) {
+        return null;
+    }
+    const secondsAsNumber = Number(seconds);
+    if (Number.isNaN(secondsAsNumber)) {
+        return null;
+    }
+    return secondsAsNumber + minutesAsNumber * 60 + hoursAsNumber * 3600;
+};
+const parseVideoStreamDuration = (stdout) => {
+    const duration = stdout.match(/duration=([0-9.]+)/);
+    const alternativeDuration = parseAlternativeDuration(stdout);
+    const fps = stdout.match(/r_frame_rate=([0-9.]+)\/([0-9.]+)/);
+    const result = {
+        duration: duration ? parseFloat(duration[1]) : alternativeDuration,
+        fps: fps ? parseInt(fps[1], 10) / parseInt(fps[2], 10) : null,
+    };
+    return result;
+};
+exports.parseVideoStreamDuration = parseVideoStreamDuration;
+async function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }) {
+    const args = [
+        ['-v', 'error'],
+        ['-select_streams', 'v:0'],
+        ['-show_entries', 'stream'],
+        [src],
+    ]
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter(Boolean);
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), args);
+    const result = (0, exports.parseVideoStreamDuration)(task.stdout);
+    return result;
+}
+exports.getVideoStreamDurationwithoutCache = getVideoStreamDurationwithoutCache;
+async function getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (downloadMap.videoDurationResultCache[src]) {
+        return downloadMap.videoDurationResultCache[src];
+    }
+    const result = await getVideoStreamDurationwithoutCache({
+        src,
+        ffprobeExecutable,
+        remotionRoot,
+    });
+    downloadMap.videoDurationResultCache[src] = result;
+    return result;
+}
+const getVideoStreamDuration = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
+};
+exports.getVideoStreamDuration = getVideoStreamDuration;

package/dist/browser/Browser.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { LogLevel } from '../log-level';
 import type { AnySourceMapConsumer } from '../symbolicate-stacktrace';
 import type { Page } from './BrowserPage';
 import type { Connection } from './Connection';
@@ -40,12 +41,12 @@ export declare class HeadlessBrowser extends EventEmitter {
     get _targets(): Map<string, Target>;
     constructor(connection: Connection, defaultViewport: Viewport, closeCallback?: BrowserCloseCallback);
     browserContexts(): BrowserContext[];
-    newPage(context: AnySourceMapConsumer | null): Promise<Page>;
-    _createPageInContext(context: AnySourceMapConsumer | null): Promise<Page>;
+    newPage(context: AnySourceMapConsumer | null, logLevel: LogLevel, indent: boolean): Promise<Page>;
+    _createPageInContext(context: AnySourceMapConsumer | null, logLevel: LogLevel, indent: boolean): Promise<Page>;
     targets(): Target[];
     waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: WaitForTargetOptions): Promise<Target>;
-    pages(): Promise<Page[]>;
-    close(silent: boolean): Promise<void>;
+    pages(logLevel: LogLevel, indent: boolean): Promise<Page[]>;
+    close(silent: boolean, logLevel: LogLevel, indent: boolean): Promise<void>;
     disconnect(): void;
 }
 export declare class BrowserContext extends EventEmitter {
@@ -55,8 +56,8 @@ export declare class BrowserContext extends EventEmitter {
     waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: {
         timeout?: number;
     }): Promise<Target>;
-    pages(): Promise<Page[]>;
-    newPage(context: AnySourceMapConsumer | null): Promise<Page>;
+    pages(logLevel: LogLevel, indent: boolean): Promise<Page[]>;
+    newPage(context: AnySourceMapConsumer | null, logLevel: LogLevel, indent: boolean): Promise<Page>;
     browser(): HeadlessBrowser;
 }
 export {};

package/dist/browser/Browser.js

@@ -65,10 +65,10 @@ class HeadlessBrowser extends EventEmitter_1.EventEmitter {
     browserContexts() {
         return [__classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f"), ...Array.from(__classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").values())];
     }
-    newPage(context) {
-        return __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f").newPage(context);
+    newPage(context, logLevel, indent) {
+        return __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f").newPage(context, logLevel, indent);
     }
-    async _createPageInContext(context) {
+    async _createPageInContext(context, logLevel, indent) {
         const { targetId } = await this.connection.send('Target.createTarget', {
             url: 'about:blank',
             browserContextId: undefined,
@@ -81,7 +81,7 @@ class HeadlessBrowser extends EventEmitter_1.EventEmitter {
         if (!initialized) {
             throw new Error(`Failed to create target for page (id = ${targetId})`);
         }
-        const page = await target.page(context);
+        const page = await target.page(context, logLevel, indent);
         if (!page) {
             throw new Error(`Failed to create a page for context`);
         }
@@ -119,18 +119,18 @@ class HeadlessBrowser extends EventEmitter_1.EventEmitter {
             }
         }
     }
-    async pages() {
+    async pages(logLevel, indent) {
         const contextPages = await Promise.all(this.browserContexts().map((context) => {
-            return context.pages();
+            return context.pages(logLevel, indent);
         }));
         // Flatten array.
         return contextPages.reduce((acc, x) => {
             return acc.concat(x);
         }, []);
     }
-    async close(silent) {
+    async close(silent, logLevel, indent) {
         await __classPrivateFieldGet(this, _HeadlessBrowser_closeCallback, "f").call(null);
-        (await this.pages()).forEach((page) => {
+        (await this.pages(logLevel, indent)).forEach((page) => {
             page.emit("disposed" /* PageEmittedEvents.Disposed */);
             page.closed = true;
         });
@@ -196,16 +196,16 @@ class BrowserContext extends EventEmitter_1.EventEmitter {
             return target.browserContext() === this && predicate(target);
         }, options);
     }
-    async pages() {
+    async pages(logLevel, indent) {
         const pages = await Promise.all(this.targets()
             .filter((target) => target.type() === 'page')
-            .map((target) => target.page(null)));
+            .map((target) => target.page(null, logLevel, indent)));
         return pages.filter((page) => {
             return Boolean(page);
         });
     }
-    newPage(context) {
-        return __classPrivateFieldGet(this, _BrowserContext_browser, "f")._createPageInContext(context);
+    newPage(context, logLevel, indent) {
+        return __classPrivateFieldGet(this, _BrowserContext_browser, "f")._createPageInContext(context, logLevel, indent);
     }
     browser() {
         return __classPrivateFieldGet(this, _BrowserContext_browser, "f");

package/dist/browser/BrowserPage.d.ts

@@ -25,6 +25,7 @@ import type { JSHandle } from './JSHandle';
 import type { Viewport } from './PuppeteerViewport';
 import type { Target } from './Target';
 import { TaskQueue } from './TaskQueue';
+import type { LogLevel } from '../log-level';
 interface WaitForOptions {
     timeout?: number;
 }
@@ -41,18 +42,28 @@ interface PageEventObject {
 export declare class Page extends EventEmitter {
     #private;
     id: string;
-    static _create({ client, target, defaultViewport, browser, sourcemapContext, }: {
+    static _create({ client, target, defaultViewport, browser, sourcemapContext, logLevel, indent, }: {
         client: CDPSession;
         target: Target;
         defaultViewport: Viewport;
         browser: HeadlessBrowser;
         sourcemapContext: AnySourceMapConsumer | null;
+        logLevel: LogLevel;
+        indent: boolean;
     }): Promise<Page>;
     closed: boolean;
     browser: HeadlessBrowser;
     screenshotTaskQueue: TaskQueue;
     sourcemapContext: AnySourceMapConsumer | null;
-    constructor(client: CDPSession, target: Target, browser: HeadlessBrowser, sourcemapContext: AnySourceMapConsumer | null);
+    logLevel: LogLevel;
+    constructor({ client, target, browser, sourcemapContext, logLevel, indent, }: {
+        client: CDPSession;
+        target: Target;
+        browser: HeadlessBrowser;
+        sourcemapContext: AnySourceMapConsumer | null;
+        logLevel: LogLevel;
+        indent: boolean;
+    });
     /**
      * Listen to page events.
      */

package/dist/browser/BrowserPage.js

@@ -40,13 +40,20 @@ const TaskQueue_1 = require("./TaskQueue");
 const TimeoutSettings_1 = require("./TimeoutSettings");
 const util_1 = require("./util");
 class Page extends EventEmitter_1.EventEmitter {
-    static async _create({ client, target, defaultViewport, browser, sourcemapContext, }) {
-        const page = new Page(client, target, browser, sourcemapContext);
+    static async _create({ client, target, defaultViewport, browser, sourcemapContext, logLevel, indent, }) {
+        const page = new Page({
+            client,
+            target,
+            browser,
+            sourcemapContext,
+            logLevel,
+            indent,
+        });
         await __classPrivateFieldGet(page, _Page_instances, "m", _Page_initialize).call(page);
         await page.setViewport(defaultViewport);
         return page;
     }
-    constructor(client, target, browser, sourcemapContext) {
+    constructor({ client, target, browser, sourcemapContext, logLevel, indent, }) {
         super();
         _Page_instances.add(this);
         this.closed = false;
@@ -62,6 +69,7 @@ class Page extends EventEmitter_1.EventEmitter {
         this.browser = browser;
         this.id = String(Math.random());
         this.sourcemapContext = sourcemapContext;
+        this.logLevel = logLevel;
         client.on('Target.attachedToTarget', (event) => {
             switch (event.targetInfo.type) {
                 case 'iframe':
@@ -112,14 +120,13 @@ class Page extends EventEmitter_1.EventEmitter {
                     .filter(truthy_1.truthy)
                     .join(':');
                 logger_1.Log.verboseAdvanced({
-                    logLevel: (0, logger_1.getLogLevel)(),
-                    tag: `console.${log.type}()`,
-                    secondTag: [origPosition.name, file].filter(truthy_1.truthy).join('@'),
-                    indent: false,
+                    logLevel,
+                    tag: [origPosition.name, file].filter(truthy_1.truthy).join('@'),
+                    indent,
                 }, log.text);
             }
             else {
-                logger_1.Log.verboseAdvanced({ logLevel: (0, logger_1.getLogLevel)(), tag: `console.${log.type}`, indent: false }, log.text);
+                logger_1.Log.verboseAdvanced({ logLevel, tag: `console.${log.type}`, indent }, log.text);
             }
         });
     }

package/dist/browser/BrowserRunner.js

@@ -103,7 +103,7 @@ class BrowserRunner {
                         return;
                     }
                     const { output, tag } = formatted;
-                    logger_1.Log.verboseAdvanced({ indent: options.indent, logLevel: (0, logger_1.getLogLevel)(), tag }, output);
+                    logger_1.Log.verboseAdvanced({ indent: options.indent, logLevel: options.logLevel, tag }, output);
                 }
             });
             (_b = this.proc.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (d) => {
@@ -114,7 +114,7 @@ class BrowserRunner {
                         return;
                     }
                     const { output, tag } = formatted;
-                    logger_1.Log.verboseAdvanced({ indent: options.indent, logLevel: (0, logger_1.getLogLevel)(), tag }, output);
+                    logger_1.Log.verboseAdvanced({ indent: options.indent, logLevel: options.logLevel, tag }, output);
                 }
             });
         }

package/dist/browser/LaunchOptions.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { LogLevel } from '../log-level';
 import type { BrowserConnectOptions } from './BrowserConnector';
 import type { Product } from './Product';
 export interface BrowserLaunchArgumentOptions {
@@ -26,6 +27,7 @@ export interface LaunchOptions {
     executablePath?: string;
     timeout?: number;
     dumpio?: boolean;
+    logLevel: LogLevel;
     env?: Record<string, string | undefined>;
     product?: Product;
     indent: boolean;

package/dist/browser/Launcher.js

@@ -84,6 +84,7 @@ class ChromeLauncher {
             dumpio,
             env,
             indent,
+            logLevel: options.logLevel,
         });
         let browser;
         try {
@@ -107,7 +108,7 @@ class ChromeLauncher {
             }, { timeout });
         }
         catch (error) {
-            await browser.close(false);
+            await browser.close(false, options.logLevel, options.indent);
             throw error;
         }
         return browser;

package/dist/browser/Target.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { LogLevel } from '../log-level';
 import type { AnySourceMapConsumer } from '../symbolicate-stacktrace';
 import type { BrowserContext, HeadlessBrowser } from './Browser';
 import { Page } from './BrowserPage';
@@ -36,7 +37,7 @@ export declare class Target {
     /**
      * If the target is not of type `"page"` or `"background_page"`, returns `null`.
      */
-    page(sourcemapContext: AnySourceMapConsumer | null): Promise<Page | null>;
+    page(sourcemapContext: AnySourceMapConsumer | null, logLevel: LogLevel, indent: boolean): Promise<Page | null>;
     url(): string;
     /**
      * Identifies what kind of target this is.

package/dist/browser/Target.js

@@ -79,7 +79,7 @@ class Target {
     /**
      * If the target is not of type `"page"` or `"background_page"`, returns `null`.
      */
-    async page(sourcemapContext) {
+    async page(sourcemapContext, logLevel, indent) {
         var _a;
         if (isPagetTarget(__classPrivateFieldGet(this, _Target_targetInfo, "f")) && !__classPrivateFieldGet(this, _Target_pagePromise, "f")) {
             __classPrivateFieldSet(this, _Target_pagePromise, __classPrivateFieldGet(this, _Target_sessionFactory, "f").call(this).then((client) => {
@@ -90,6 +90,8 @@ class Target {
                     defaultViewport: (_a = __classPrivateFieldGet(this, _Target_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null,
                     browser: this.browser(),
                     sourcemapContext,
+                    logLevel,
+                    indent,
                 });
             }), "f");
         }

package/dist/browser/should-log-message.js

@@ -6,6 +6,14 @@ const shouldLogBrowserMessage = (message) => {
     if (message.startsWith('DevTools listening on')) {
         return false;
     }
+    // In Ubuntu GitHub Action
+    if (message.includes('Falling back to ALSA for audio output')) {
+        return false;
+    }
+    // In Ubuntu GitHub Action
+    if (message.includes('Floss manager not present, cannot set Floss enable/disable')) {
+        return false;
+    }
     // Noisy but harmless warning
     if (message.includes('Failed to send GpuControl.CreateCommandBuffer')) {
         return false;

package/dist/calculate-sar-dar-pixels.d.ts

@@ -0,0 +1,9 @@
+export declare const calculateDisplayVideoSize: ({ darX, darY, x, y, }: {
+    x: number;
+    y: number;
+    darX: number;
+    darY: number;
+}) => {
+    width: number;
+    height: number;
+};

package/dist/calculate-sar-dar-pixels.js

@@ -0,0 +1,19 @@
+"use strict";
+// https://superuser.com/questions/907933/correct-aspect-ratio-without-re-encoding-video-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDisplayVideoSize = void 0;
+const calculateDisplayVideoSize = ({ darX, darY, x, y, }) => {
+    // We know two equations:
+    //   newWidth / newHeight = darX / darY
+    // and:
+    //   x * y = (newWidth * newHeight)
+    // I solved it then on pen and paper and simplified the formula:
+    const dimensions = x * y;
+    const newWidth = Math.sqrt(dimensions * (darX / darY));
+    const newHeight = dimensions / newWidth;
+    return {
+        height: Math.round(newHeight),
+        width: Math.round(newWidth),
+    };
+};
+exports.calculateDisplayVideoSize = calculateDisplayVideoSize;

package/dist/compositor/compositor.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import type { CompositorCommand } from './payloads';
+import type { LogLevel } from '../log-level';
 export type Compositor = {
     finishCommands: () => void;
     executeCommand: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T]) => Promise<Buffer>;
@@ -7,5 +8,5 @@ export type Compositor = {
     pid: number | null;
 };
 export declare const getIdealMaximumFrameCacheItems: () => number;
-export declare const startLongRunningCompositor: (maximumFrameCacheItems: number, verbose: boolean, indent: boolean) => Compositor;
-export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T], indent: boolean) => Compositor;
+export declare const startLongRunningCompositor: (maximumFrameCacheItems: number, logLevel: LogLevel, indent: boolean) => Compositor;
+export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T], logLevel: LogLevel, indent: boolean) => Compositor;

package/dist/compositor/compositor.js

@@ -13,6 +13,7 @@ const logger_1 = require("../logger");
 const compose_1 = require("./compose");
 const get_executable_path_1 = require("./get-executable-path");
 const make_nonce_1 = require("./make-nonce");
+const log_level_1 = require("../log-level");
 const getIdealMaximumFrameCacheItems = () => {
     const freeMemory = node_os_1.default.freemem();
     // Assuming 1 frame is approximately 6MB
@@ -23,15 +24,15 @@ const getIdealMaximumFrameCacheItems = () => {
     return Math.max(100, Math.min(max, 1000));
 };
 exports.getIdealMaximumFrameCacheItems = getIdealMaximumFrameCacheItems;
-const startLongRunningCompositor = (maximumFrameCacheItems, verbose, indent) => {
+const startLongRunningCompositor = (maximumFrameCacheItems, logLevel, indent) => {
     return (0, exports.startCompositor)('StartLongRunningProcess', {
         concurrency: (0, get_concurrency_1.getActualConcurrency)(null),
         maximum_frame_cache_items: maximumFrameCacheItems,
-        verbose,
-    }, indent);
+        verbose: (0, log_level_1.isEqualOrBelowLogLevel)(logLevel, 'verbose'),
+    }, logLevel, indent);
 };
 exports.startLongRunningCompositor = startLongRunningCompositor;
-const startCompositor = (type, payload, indent) => {
+const startCompositor = (type, payload, logLevel, indent) => {
     var _a;
     const bin = (0, get_executable_path_1.getExecutablePath)('compositor');
     if (!process.env.READ_ONLY_FS) {
@@ -45,7 +46,7 @@ const startCompositor = (type, payload, indent) => {
     const waiters = new Map();
     const onMessage = (statusType, nonce, data) => {
         if (nonce === '0') {
-            logger_1.Log.verboseAdvanced({ indent, logLevel: (0, logger_1.getLogLevel)(), tag: 'compositor' }, data.toString('utf8'));
+            logger_1.Log.verboseAdvanced({ indent, logLevel, tag: 'compositor' }, data.toString('utf8'));
         }
         if (waiters.has(nonce)) {
             if (statusType === 'error') {

package/dist/cycle-browser-tabs.d.ts

@@ -1,4 +1,5 @@
+import type { LogLevel } from './log-level';
 import type { BrowserReplacer } from './replace-browser';
-export declare const cycleBrowserTabs: (puppeteerInstance: BrowserReplacer, concurrency: number) => {
+export declare const cycleBrowserTabs: (puppeteerInstance: BrowserReplacer, concurrency: number, logLevel: LogLevel, indent: boolean) => {
     stopCycling: () => void;
 };

package/dist/cycle-browser-tabs.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cycleBrowserTabs = void 0;
-const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
+const cycleBrowserTabs = (puppeteerInstance, concurrency, logLevel, indent) => {
     if (concurrency <= 1) {
         return {
             stopCycling: () => undefined,
@@ -14,7 +14,7 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
         interval = setTimeout(() => {
             puppeteerInstance
                 .getBrowser()
-                .pages()
+                .pages(logLevel, indent)
                 .then((pages) => {
                 if (pages.length === 0) {
                     return;

package/dist/determine-resize-params.d.ts

@@ -0,0 +1,4 @@
+export declare const determineResizeParams: (needsResize: [
+    number,
+    number
+] | null) => string[];

package/dist/determine-resize-params.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineResizeParams = void 0;
+const determineResizeParams = (needsResize) => {
+    if (needsResize === null) {
+        return [];
+    }
+    return ['-s', `${needsResize[0]}x${needsResize[1]}`];
+};
+exports.determineResizeParams = determineResizeParams;

package/dist/determine-vcodec-ffmpeg-flags.d.ts

@@ -0,0 +1,2 @@
+import type { SpecialVCodecForTransparency } from './assets/download-map';
+export declare const determineVcodecFfmpegFlags: (vcodecFlag: SpecialVCodecForTransparency) => string[];

package/dist/determine-vcodec-ffmpeg-flags.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineVcodecFfmpegFlags = void 0;
+const truthy_1 = require("./truthy");
+const determineVcodecFfmpegFlags = (vcodecFlag) => {
+    return [
+        vcodecFlag === 'vp9' ? '-vcodec' : null,
+        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
+        vcodecFlag === 'vp8' ? '-vcodec' : null,
+        vcodecFlag === 'vp8' ? 'libvpx' : null,
+    ].filter(truthy_1.truthy);
+};
+exports.determineVcodecFfmpegFlags = determineVcodecFfmpegFlags;

package/dist/ensure-ffmpeg.d.ts

@@ -0,0 +1,18 @@
+export type EnsureFfmpegOptions = {
+    remotionRoot?: string;
+};
+type Result = {
+    result: 'found-in-path' | 'found-in-node-modules' | 'installed';
+    wasAlreadyInstalled: boolean;
+};
+/**
+ * @description Checks if the ffmpeg binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffmpeg)
+ */
+export declare const ensureFfmpeg: (options?: EnsureFfmpegOptions) => Promise<Result>;
+/**
+ * @description Checks if the ffprobe binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffprobe)
+ */
+export declare const ensureFfprobe: (options?: EnsureFfmpegOptions) => Promise<Result>;
+export {};

package/dist/ensure-ffmpeg.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFfprobe = exports.ensureFfmpeg = void 0;
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const validate_ffmpeg_1 = require("./validate-ffmpeg");
+const ensureFfmpegOrFfprobe = async (binary, options) => {
+    var _a;
+    const exists = (0, validate_ffmpeg_1.binaryExists)(binary);
+    const remotionRoot = (_a = options === null || options === void 0 ? void 0 : options.remotionRoot) !== null && _a !== void 0 ? _a : process.cwd();
+    if (exists) {
+        return {
+            wasAlreadyInstalled: true,
+            result: 'found-in-path',
+        };
+    }
+    if (process.platform === 'linux' && (0, fs_1.existsSync)(ffmpeg_flags_1.lambdaFfmpegPaths[binary])) {
+        return {
+            wasAlreadyInstalled: true,
+            result: 'found-in-path',
+        };
+    }
+    if ((0, ffmpeg_flags_1.ffmpegInNodeModules)(remotionRoot, binary)) {
+        return {
+            result: 'found-in-node-modules',
+            wasAlreadyInstalled: true,
+        };
+    }
+    const binaryUrl = (0, ffmpeg_flags_1.getBinaryDownloadUrl)(binary);
+    if (binaryUrl) {
+        await (0, ffmpeg_flags_1.downloadBinary)(remotionRoot, binaryUrl.url, binary);
+        return {
+            result: 'installed',
+            wasAlreadyInstalled: false,
+        };
+    }
+    throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);
+};
+/**
+ * @description Checks if the ffmpeg binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffmpeg)
+ */
+const ensureFfmpeg = (options) => {
+    return ensureFfmpegOrFfprobe('ffmpeg', options);
+};
+exports.ensureFfmpeg = ensureFfmpeg;
+/**
+ * @description Checks if the ffprobe binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffprobe)
+ */
+const ensureFfprobe = (options) => {
+    return ensureFfmpegOrFfprobe('ffprobe', options);
+};
+exports.ensureFfprobe = ensureFfprobe;

package/dist/ensure-presentation-timestamp.d.ts

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