@remotion/renderer 4.0.0-alpha.4 → 4.0.0-alpha5

package/dist/file-extensions.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFileExtensionMap = void 0;
+exports.defaultFileExtensionMap = {
+    'h264-mkv': {
+        default: 'mkv',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    aac: {
+        default: 'aac',
+        forAudioCodec: {
+            aac: {
+                possible: ['aac', '3gp', 'm4a', 'm4b', 'mpg', 'mpeg'],
+                default: 'aac',
+            },
+            'pcm-16': {
+                possible: ['wav'],
+                default: 'wav',
+            },
+        },
+    },
+    gif: {
+        default: 'gif',
+        forAudioCodec: {},
+    },
+    h264: {
+        default: 'mp4',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv', 'mov'], default: 'mkv' },
+            aac: { possible: ['mp4', 'mkv', 'mov'], default: 'mp4' },
+        },
+    },
+    h265: {
+        default: 'mp4',
+        forAudioCodec: {
+            aac: { possible: ['mp4', 'mkv', 'hevc'], default: 'mp4' },
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    mp3: {
+        default: 'mp3',
+        forAudioCodec: {
+            mp3: { possible: ['mp3'], default: 'mp3' },
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+    prores: {
+        default: 'mov',
+        forAudioCodec: {
+            aac: { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+            'pcm-16': { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+        },
+    },
+    vp8: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    vp9: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    wav: {
+        default: 'wav',
+        forAudioCodec: {
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+};

package/dist/find-closest-package-json.d.ts

@@ -0,0 +1,2 @@
+export declare const findClosestPackageJson: () => string | null;
+export declare const findRemotionRoot: () => string;

package/dist/find-closest-package-json.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRemotionRoot = exports.findClosestPackageJson = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const recursionLimit = 5;
+const findClosestPackageJson = () => {
+    let currentDir = process.cwd();
+    let possiblePackageJson = '';
+    for (let i = 0; i < recursionLimit; i++) {
+        possiblePackageJson = path_1.default.join(currentDir, 'package.json');
+        const exists = fs_1.default.existsSync(possiblePackageJson);
+        if (exists) {
+            return possiblePackageJson;
+        }
+        currentDir = path_1.default.dirname(currentDir);
+    }
+    return null;
+};
+exports.findClosestPackageJson = findClosestPackageJson;
+const findRemotionRoot = () => {
+    const closestPackageJson = (0, exports.findClosestPackageJson)();
+    if (closestPackageJson === null) {
+        return process.cwd();
+    }
+    return path_1.default.dirname(closestPackageJson);
+};
+exports.findRemotionRoot = findRemotionRoot;

package/dist/get-browser-instance.js

@@ -26,7 +26,7 @@ const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromi
         page: browserPage,
         cleanup: () => {
             // Close whole browser that was just created and don't wait for it to finish.
-            browserInstance.close().catch((err) => {
+            browserInstance.close(true).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

@@ -1,9 +1,8 @@
-import type { TCompMetadata } from 'remotion';
+import type { AnyCompMetadata } from 'remotion';
 import type { DownloadMap } from './assets/download-map';
 import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
 import type { Browser } from './browser/Browser';
-import type { FfmpegExecutable } from './ffmpeg-executable';
 import type { ChromiumOptions } from './open-browser';
 declare type GetCompositionsConfig = {
     inputProps?: object | null;
@@ -13,13 +12,16 @@ declare type GetCompositionsConfig = {
     browserExecutable?: BrowserExecutable;
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
-    ffmpegExecutable?: FfmpegExecutable;
-    ffprobeExecutable?: FfmpegExecutable;
     port?: number | null;
     /**
      * @deprecated Only for Remotion internal usage
      */
     downloadMap?: DownloadMap;
+    verbose?: boolean;
 };
-export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<TCompMetadata[]>;
+/**
+ * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
+ */
+export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<AnyCompMetadata[]>;
 export {};

package/dist/get-compositions.js

@@ -3,9 +3,11 @@ 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 prepare_server_1 = require("./prepare-server");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
@@ -29,6 +31,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 +44,7 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
         frame: null,
         args: [],
     });
-    await page.waitForFunction(page.browser, 'window.ready === true');
+    await (0, seek_to_frame_1.waitForReady)(page);
     const result = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         pageFunction: () => {
             return window.getStaticCompositions();
@@ -51,6 +55,10 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     });
     return result;
 };
+/**
+ * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
+ */
 const getCompositions = async (serveUrlOrWebpackUrl, config) => {
     var _a, _b, _c;
     const downloadMap = (_a = config === null || config === void 0 ? void 0 : config.downloadMap) !== null && _a !== void 0 ? _a : (0, download_map_1.makeDownloadMap)();
@@ -60,7 +68,7 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
         chromiumOptions: (_c = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _c !== void 0 ? _c : {},
     });
     return new Promise((resolve, reject) => {
-        var _a, _b, _c;
+        var _a, _b;
         const onError = (err) => reject(err);
         const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
             page,
@@ -72,22 +80,30 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
             webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
             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,
+            port: (_a = config === null || config === void 0 ? void 0 : config.port) !== null && _a !== void 0 ? _a : null,
             downloadMap,
+            remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
+            concurrency: 1,
+            verbose: (_b = config === null || config === void 0 ? void 0 : config.verbose) !== null && _b !== void 0 ? _b : false,
         })
             .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)) {

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-extension-from-codec.d.ts

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

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

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

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

@@ -1,11 +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) => {
     if (filename === null) {
         return null;
     }
-    const filenameArr = filename.split('.');
+    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,15 @@
+/// <reference types="node" />
+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

@@ -1,8 +1,9 @@
+import type { VideoImageFormat } from './image-format';
 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';
+    imageFormat: VideoImageFormat;
     countType: CountType;
     lastFrame: number;
     totalFrames: number;

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

@@ -10,13 +10,14 @@ const padIndex = ({ num, filePadLength, }) => {
 };
 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 `element-${paddedIndex}.${imageFormat}`;
+        return `${prefix}-${paddedIndex}.${imageFormat}`;
     }
     if (countType === 'from-zero') {
         const paddedIndex = padIndex({ filePadLength, num: index });
-        return `element-${paddedIndex}.${imageFormat}`;
+        return `${prefix}-${paddedIndex}.${imageFormat}`;
     }
     throw new TypeError('Unknown count type');
 };

package/dist/get-frame-to-render.js

@@ -12,7 +12,7 @@ const getRealFrameRange = (durationInFrames, frameRange) => {
         return [frameRange, frameRange];
     }
     if (frameRange[1] >= durationInFrames || frameRange[0] < 0) {
-        throw new Error(`Frame range ${frameRange.join('-')} is not in between 0-${durationInFrames - 1}`);
+        throw new Error(`Frame range ${frameRange.join('-')} is not inbetween 0-${durationInFrames - 1}`);
     }
     return frameRange;
 };