@remotion/renderer 4.1.0-alpha2 → 4.1.0-alpha4

package/dist/format-logs.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatObjectPreview = exports.formatRemoteObject = void 0;
+const chalk_1 = require("./chalk");
+const formatRemoteObject = (remoteObject) => {
+    if (remoteObject.preview) {
+        return (0, exports.formatObjectPreview)(remoteObject.preview);
+    }
+    if (remoteObject.type === 'string') {
+        return chalk_1.chalk.reset(`${remoteObject.value}`);
+    }
+    if (remoteObject.type === 'number') {
+        return chalk_1.chalk.yellow(`${remoteObject.value}`);
+    }
+    if (remoteObject.type === 'bigint') {
+        return chalk_1.chalk.yellow(`${remoteObject.description}`);
+    }
+    if (remoteObject.type === 'boolean') {
+        return chalk_1.chalk.yellow(`${remoteObject.value}`);
+    }
+    if (remoteObject.type === 'function') {
+        return chalk_1.chalk.cyan(String(remoteObject.description));
+    }
+    if (remoteObject.type === 'object') {
+        if (remoteObject.subtype === 'null') {
+            return chalk_1.chalk.white(`null`);
+        }
+        return chalk_1.chalk.reset(`Object`);
+    }
+    if (remoteObject.type === 'symbol') {
+        return chalk_1.chalk.green(`${remoteObject.description}`);
+    }
+    if (remoteObject.type === 'undefined') {
+        return chalk_1.chalk.gray(`undefined`);
+    }
+    throw new Error('unhandled remote object');
+};
+exports.formatRemoteObject = formatRemoteObject;
+const formatObjectPreview = (preview) => {
+    if (typeof preview === 'undefined') {
+        return '';
+    }
+    if (preview.type === 'object') {
+        if (preview.subtype === 'date') {
+            return chalk_1.chalk.reset(`Date { ${chalk_1.chalk.magenta(String(preview.description))} }`);
+        }
+        const properties = preview.properties.map((property) => {
+            return `${property.name}: ${formatProperty(property)}`;
+        });
+        if (preview.subtype === 'array') {
+            return chalk_1.chalk.reset(`[ ${preview.properties.map((p) => formatProperty(p)).join(', ')} ]`);
+        }
+        if (preview.subtype === 'arraybuffer') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'dataview') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'generator') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'iterator') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'map') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'node') {
+            return chalk_1.chalk.magenta(`<${preview.description}>`);
+        }
+        if (preview.subtype === 'null') {
+            return chalk_1.chalk.white(String(preview.description));
+        }
+        if (preview.subtype === 'promise') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'proxy') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'regexp') {
+            return chalk_1.chalk.red(String(preview.description));
+        }
+        if (preview.subtype === 'set') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'typedarray') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'error') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'wasmvalue') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'weakmap') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'weakset') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'webassemblymemory') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (properties.length === 0) {
+            return chalk_1.chalk.reset('{}');
+        }
+        return chalk_1.chalk.reset(`{ ${properties.join(', ')} }`);
+    }
+    return '';
+};
+exports.formatObjectPreview = formatObjectPreview;
+const formatProperty = (property) => {
+    if (property.type === 'string') {
+        return chalk_1.chalk.green(`"${property.value}"`);
+    }
+    if (property.type === 'object') {
+        if (!property.subtype && property.value === 'Object') {
+            return chalk_1.chalk.reset(`{…}`);
+        }
+        if (property.subtype === 'date') {
+            return chalk_1.chalk.reset(`Date { ${chalk_1.chalk.magenta(String(property.value))} }`);
+        }
+        if (property.subtype === 'arraybuffer') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'array') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'dataview') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'error') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'generator') {
+            return chalk_1.chalk.reset(`[generator ${property.value}]`);
+        }
+        if (property.subtype === 'iterator') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'map') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'node') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'null') {
+            return chalk_1.chalk.white(`${property.value}`);
+        }
+        if (property.subtype === 'promise') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'proxy') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'regexp') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'set') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'typedarray') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'wasmvalue') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'webassemblymemory') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'weakmap') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'weakset') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        return chalk_1.chalk.reset(`${property.value}`);
+    }
+    if (property.type === 'accessor') {
+        return chalk_1.chalk.gray(`get()`);
+    }
+    if (property.type === 'bigint') {
+        return chalk_1.chalk.yellow(`${property.value}`);
+    }
+    if (property.type === 'boolean') {
+        return chalk_1.chalk.yellow(`${property.value}`);
+    }
+    if (property.type === 'function') {
+        return chalk_1.chalk.cyan(`Function`);
+    }
+    if (property.type === 'number') {
+        return chalk_1.chalk.yellow(`${property.value}`);
+    }
+    if (property.type === 'symbol') {
+        return chalk_1.chalk.green(`${property.value}`);
+    }
+    if (property.type === 'undefined') {
+        return chalk_1.chalk.gray(`undefined`);
+    }
+    throw new Error('unexpected property type ' + JSON.stringify(property));
+};

package/dist/frame-to-ffmpeg-timestamp.d.ts

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

package/dist/frame-to-ffmpeg-timestamp.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frameToFfmpegTimestamp = void 0;
+const frameToFfmpegTimestamp = (time) => {
+    // We ceil because FFMPEG seeks to the closest frame BEFORE the position
+    return (Math.ceil(time * 1000000) / 1000).toFixed(3) + 'ms';
+};
+exports.frameToFfmpegTimestamp = frameToFfmpegTimestamp;

package/dist/get-browser-instance.d.ts

@@ -1,16 +1,17 @@
 import type { BrowserExecutable } from './browser-executable';
 import type { HeadlessBrowser } from './browser/Browser';
 import type { Page } from './browser/BrowserPage';
+import type { LogLevel } from './log-level';
 import type { ChromiumOptions } from './open-browser';
 import type { AnySourceMapConsumer } from './symbolicate-stacktrace';
-export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, context, forceDeviceScaleFactor, indent, shouldDumpIo, }: {
+export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, context, forceDeviceScaleFactor, indent, logLevel, }: {
     passedInInstance: HeadlessBrowser | undefined;
     browserExecutable: BrowserExecutable | null;
     chromiumOptions: ChromiumOptions;
     context: AnySourceMapConsumer | null;
     indent: boolean;
     forceDeviceScaleFactor: number | undefined;
-    shouldDumpIo: boolean;
+    logLevel: LogLevel;
 }) => Promise<{
     cleanup: () => void;
     page: Page;

package/dist/get-browser-instance.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageAndCleanupFn = void 0;
 const browser_1 = require("./browser");
 const open_browser_1 = require("./open-browser");
-const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, context, forceDeviceScaleFactor, indent, shouldDumpIo, }) => {
+const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, context, forceDeviceScaleFactor, indent, logLevel, }) => {
     if (passedInInstance) {
-        const page = await passedInInstance.newPage(context);
+        const page = await passedInInstance.newPage(context, logLevel, indent);
         return {
             page,
             cleanup: () => {
@@ -23,15 +23,15 @@ const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromi
         chromiumOptions,
         forceDeviceScaleFactor,
         indent,
-        shouldDumpIo,
         viewport: null,
+        logLevel,
     });
-    const browserPage = await browserInstance.newPage(context);
+    const browserPage = await browserInstance.newPage(context, logLevel, indent);
     return {
         page: browserPage,
         cleanup: () => {
             // Close whole browser that was just created and don't wait for it to finish.
-            browserInstance.close(true).catch((err) => {
+            browserInstance.close(true, logLevel, indent).catch((err) => {
                 console.error('Was not able to close puppeteer page', err);
             });
         },

package/dist/get-can-extract-frames-fast.d.ts

@@ -0,0 +1,14 @@
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const ACCEPTABLE_OFFSET_THRESHOLD = 50;
+/**
+ * @description Probes whether frames of a video can be efficiently extracted when using <OffthreadVideo>.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-can-extract-frames-fast)
+ */
+export declare const getCanExtractFramesFast: ({ src, ffmpegExecutable, ffprobeExecutable, }: {
+    src: string;
+    ffmpegExecutable?: FfmpegExecutable | undefined;
+    ffprobeExecutable?: FfmpegExecutable | undefined;
+}) => Promise<{
+    canExtractFramesFast: boolean;
+    shouldReencode: boolean;
+}>;

package/dist/get-can-extract-frames-fast.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.getCanExtractFramesFast = exports.ACCEPTABLE_OFFSET_THRESHOLD = void 0;
+const fs_1 = __importDefault(require("fs"));
+const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
+const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
+const find_closest_package_json_1 = require("./find-closest-package-json");
+const get_video_info_1 = require("./get-video-info");
+const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-video-fast");
+exports.ACCEPTABLE_OFFSET_THRESHOLD = 50;
+/**
+ * @description Probes whether frames of a video can be efficiently extracted when using <OffthreadVideo>.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-can-extract-frames-fast)
+ */
+const getCanExtractFramesFast = async ({ src, ffmpegExecutable, ffprobeExecutable, }) => {
+    const remotionRoot = (0, find_closest_package_json_1.findRemotionRoot)();
+    const out = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+        src,
+    });
+    const { specialVcodecForTransparency: specialVcodec } = await (0, get_video_info_1.getVideoInfoUncached)({
+        src: out,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+    });
+    if (specialVcodec === 'vp8') {
+        fs_1.default.unlinkSync(out);
+        return {
+            canExtractFramesFast: false,
+            shouldReencode: false,
+        };
+    }
+    const { duration } = await (0, get_video_stream_duration_1.getVideoStreamDurationwithoutCache)({
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+        src: out,
+    });
+    if (duration === null) {
+        fs_1.default.unlinkSync(out);
+        throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
+    }
+    const actualOffset = `${duration * 1000 - exports.ACCEPTABLE_OFFSET_THRESHOLD}ms`;
+    const [stdErr] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
+        actualOffset,
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
+        imageFormat: 'jpeg',
+        // Intentionally leaving needsResize as null, because we don't need to resize
+        needsResize: null,
+        remotionRoot,
+        specialVCodecForTransparency: specialVcodec,
+        src: out,
+    });
+    fs_1.default.unlinkSync(out);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        return {
+            canExtractFramesFast: false,
+            shouldReencode: true,
+        };
+    }
+    return {
+        canExtractFramesFast: true,
+        shouldReencode: false,
+    };
+};
+exports.getCanExtractFramesFast = getCanExtractFramesFast;

package/dist/get-compositions.d.ts

@@ -4,6 +4,7 @@ import type { BrowserLog } from './browser-log';
 import type { HeadlessBrowser } from './browser/Browser';
 import type { ChromiumOptions } from './open-browser';
 import type { RemotionServer } from './prepare-server';
+import { type LogLevel } from './log-level';
 type InternalGetCompositionsOptions = {
     inputProps: Record<string, unknown>;
     envVariables: Record<string, string>;
@@ -15,7 +16,7 @@ type InternalGetCompositionsOptions = {
     port: number | null;
     server: RemotionServer | undefined;
     indent: boolean;
-    verbose: boolean;
+    logLevel: LogLevel;
     serveUrlOrWebpackUrl: string;
 };
 export type GetCompositionsOptions = {
@@ -27,9 +28,9 @@ export type GetCompositionsOptions = {
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
     port?: number | null;
-    verbose?: boolean;
+    logLevel?: LogLevel;
 };
-export declare const internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, verbose, }: InternalGetCompositionsOptions) => Promise<AnyCompMetadata[]>;
+export declare const internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, }: InternalGetCompositionsOptions) => Promise<AnyCompMetadata[]>;
 /**
  * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)

package/dist/get-compositions.js

@@ -10,6 +10,7 @@ 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 logger_1 = require("./logger");
 const innerGetCompositions = async ({ envVariables, inputProps, onBrowserLog, page, proxyPort, serveUrl, timeoutInMilliseconds, }) => {
     if (onBrowserLog) {
         page.on('console', (log) => {
@@ -54,7 +55,7 @@ const innerGetCompositions = async ({ envVariables, inputProps, onBrowserLog, pa
     });
     return result;
 };
-const internalGetCompositions = async ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, verbose, }) => {
+const internalGetCompositions = async ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, }) => {
     const { page, cleanup: cleanupPage } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
         passedInInstance: puppeteerInstance,
         browserExecutable,
@@ -62,7 +63,7 @@ const internalGetCompositions = async ({ browserExecutable, chromiumOptions, env
         context: null,
         forceDeviceScaleFactor: undefined,
         indent,
-        shouldDumpIo: verbose,
+        logLevel,
     });
     const cleanup = [cleanupPage];
     return new Promise((resolve, reject) => {
@@ -77,7 +78,7 @@ const internalGetCompositions = async ({ browserExecutable, chromiumOptions, env
             port,
             remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
             concurrency: 1,
-            verbose,
+            logLevel,
             indent,
         }, {
             onDownload: () => undefined,
@@ -115,7 +116,7 @@ exports.internalGetCompositions = internalGetCompositions;
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
  */
 const getCompositions = (serveUrlOrWebpackUrl, config) => {
-    const { browserExecutable, chromiumOptions, envVariables, inputProps, onBrowserLog, port, puppeteerInstance, timeoutInMilliseconds, verbose, } = config !== null && config !== void 0 ? config : {};
+    const { browserExecutable, chromiumOptions, envVariables, inputProps, onBrowserLog, port, puppeteerInstance, timeoutInMilliseconds, logLevel, } = config !== null && config !== void 0 ? config : {};
     return (0, exports.internalGetCompositions)({
         browserExecutable: browserExecutable !== null && browserExecutable !== void 0 ? browserExecutable : null,
         chromiumOptions: chromiumOptions !== null && chromiumOptions !== void 0 ? chromiumOptions : {},
@@ -128,7 +129,7 @@ const getCompositions = (serveUrlOrWebpackUrl, config) => {
         serveUrlOrWebpackUrl,
         server: undefined,
         timeoutInMilliseconds: timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : TimeoutSettings_1.DEFAULT_TIMEOUT,
-        verbose: verbose !== null && verbose !== void 0 ? verbose : false,
+        logLevel: logLevel !== null && logLevel !== void 0 ? logLevel : (0, logger_1.getLogLevel)(),
     });
 };
 exports.getCompositions = getCompositions;

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-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;