@remotion/renderer 4.0.0-fastlambda.8 → 4.0.0-forcepublish.7

package/dist/compress-assets.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Since audio or video can be base64-encoded, those can be really long strings.
+ * Since we track the `src` property for every frame, Node.JS can run out of memory easily. Instead of duplicating the src for every frame, we save memory by replacing the full base 64 encoded data with a string `same-as-[asset-id]-[frame]` referencing a previous asset with the same src.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssetCompressed = exports.compressAsset = void 0;
+const compressAsset = (previousAssets, newAsset) => {
+    if (newAsset.src.length < 400) {
+        return newAsset;
+    }
+    const assetWithSameSrc = previousAssets.find((a) => a.src === newAsset.src);
+    if (!assetWithSameSrc) {
+        return newAsset;
+    }
+    return {
+        ...newAsset,
+        src: `same-as-${assetWithSameSrc.id}-${assetWithSameSrc.frame}`,
+    };
+};
+exports.compressAsset = compressAsset;
+const isAssetCompressed = (src) => {
+    return src.startsWith('same-as');
+};
+exports.isAssetCompressed = isAssetCompressed;

package/dist/convert-number-of-gif-loops-to-ffmpeg.d.ts

@@ -0,0 +1 @@
+export declare const convertNumberOfGifLoopsToFfmpegSyntax: (loops: number | null) => string;

package/dist/convert-number-of-gif-loops-to-ffmpeg.js

@@ -0,0 +1,17 @@
+"use strict";
+// https://superuser.com/questions/1607099/how-to-control-gif-loop-settings-in-ffmpeg
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertNumberOfGifLoopsToFfmpegSyntax = void 0;
+const convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
+    // Infinite loop
+    if (loops === null) {
+        return '0';
+    }
+    // No loops
+    if (loops === 0) {
+        return '-1';
+    }
+    // N amount of loops
+    return String(loops);
+};
+exports.convertNumberOfGifLoopsToFfmpegSyntax = convertNumberOfGifLoopsToFfmpegSyntax;

package/dist/convert-to-pcm.d.ts

@@ -1,4 +1,4 @@
-import { FfmpegExecutable } from 'remotion';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare const convertToPcm: ({ ffmpegExecutable, input, outName, }: {
     ffmpegExecutable: FfmpegExecutable;
     input: string;

package/dist/create-ffmpeg-complex-filter.d.ts

@@ -1,7 +1,5 @@
-export declare const createFfmpegComplexFilter: (filters: number) => Promise<{
-    complexFilterFlag: [
-        string,
-        string
-    ] | null;
+import type { DownloadMap } from './assets/download-map';
+export declare const createFfmpegComplexFilter: (filters: number, downloadMap: DownloadMap) => Promise<{
+    complexFilterFlag: [string, string] | null;
     cleanup: () => void;
 }>;

package/dist/create-ffmpeg-complex-filter.js

@@ -1,23 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFfmpegComplexFilter = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const create_ffmpeg_merge_filter_1 = require("./create-ffmpeg-merge-filter");
 const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
-const tmp_dir_1 = require("./tmp-dir");
-const createFfmpegComplexFilter = async (filters) => {
+const createFfmpegComplexFilter = async (filters, downloadMap) => {
     if (filters === 0) {
         return { complexFilterFlag: null, cleanup: () => undefined };
     }
     const complexFilter = (0, create_ffmpeg_merge_filter_1.createFfmpegMergeFilter)(filters);
-    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(complexFilter);
-    const tempPath = (0, tmp_dir_1.tmpDir)('remotion-complex-filter-script');
-    const filterFile = path_1.default.join(tempPath, 'complex-filter.txt');
-    await fs_1.default.promises.writeFile(filterFile, complexFilter);
+    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(complexFilter, downloadMap);
     return {
         complexFilterFlag: ['-filter_complex_script', file],
         cleanup,

package/dist/create-ffmpeg-merge-filter.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFfmpegMergeFilter = void 0;
-const remotion_1 = require("remotion");
+const truthy_1 = require("./truthy");
 const createFfmpegMergeFilter = (inputs) => {
     const leftChannel = new Array(inputs * 2)
         .fill(true)
         .map((_, i) => (i % 2 === 0 ? `c${i}` : null))
-        .filter(remotion_1.Internals.truthy)
+        .filter(truthy_1.truthy)
         .join('+');
     const rightChannel = new Array(inputs * 2)
         .fill(true)
         .map((_, i) => (i % 2 === 1 ? `c${i}` : null))
-        .filter(remotion_1.Internals.truthy)
+        .filter(truthy_1.truthy)
         .join('+');
     return `[0:a][1:a]amerge=inputs=${inputs},pan=stereo|c0=${leftChannel}|c1=${rightChannel}[a]`;
 };

package/dist/create-silent-audio.d.ts

@@ -1,4 +1,4 @@
-import { FfmpegExecutable } from 'remotion';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, }: {
     ffmpegExecutable: FfmpegExecutable;
     numberOfSeconds: number;

package/dist/crf.d.ts

@@ -0,0 +1,5 @@
+import type { Codec } from './codec';
+export declare type Crf = number | undefined;
+export declare const getDefaultCrfForCodec: (codec: Codec) => number;
+export declare const getValidCrfRanges: (codec: Codec) => [number, number];
+export declare const validateSelectedCrfAndCodecCombination: (crf: unknown, codec: Codec) => void;

package/dist/crf.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSelectedCrfAndCodecCombination = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = void 0;
+const is_audio_codec_1 = require("./is-audio-codec");
+const getDefaultCrfForCodec = (codec) => {
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        return 0;
+    }
+    if (codec === 'h264' || codec === 'h264-mkv') {
+        return 18; // FFMPEG default 23
+    }
+    if (codec === 'h265' || codec === 'gif') {
+        return 23; // FFMPEG default 28
+    }
+    if (codec === 'vp8') {
+        return 9; // FFMPEG default 10
+    }
+    if (codec === 'vp9') {
+        return 28; // FFMPEG recommendation 31
+    }
+    if (codec === 'prores') {
+        return 0;
+    }
+    throw new TypeError(`Got unexpected codec "${codec}"`);
+};
+exports.getDefaultCrfForCodec = getDefaultCrfForCodec;
+const getValidCrfRanges = (codec) => {
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        return [0, 0];
+    }
+    if (codec === 'prores') {
+        return [0, 0];
+    }
+    if (codec === 'h264' || codec === 'h264-mkv') {
+        return [1, 51];
+    }
+    if (codec === 'h265' || codec === 'gif') {
+        return [0, 51];
+    }
+    if (codec === 'vp8') {
+        return [4, 63];
+    }
+    if (codec === 'vp9') {
+        return [0, 63];
+    }
+    throw new TypeError(`Got unexpected codec "${codec}"`);
+};
+exports.getValidCrfRanges = getValidCrfRanges;
+const validateSelectedCrfAndCodecCombination = (crf, codec) => {
+    if (crf === null) {
+        return;
+    }
+    if (typeof crf !== 'number') {
+        throw new TypeError('Expected CRF to be a number, but is ' + JSON.stringify(crf));
+    }
+    const range = (0, exports.getValidCrfRanges)(codec);
+    if (crf === 0 && (codec === 'h264' || codec === 'h264-mkv')) {
+        throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably want. Set CRF to a higher value to fix this error.");
+    }
+    if (crf < range[0] || crf > range[1]) {
+        throw new TypeError(`CRF must be between ${range[0]} and ${range[1]} for codec ${codec}. Passed: ${crf}`);
+    }
+};
+exports.validateSelectedCrfAndCodecCombination = validateSelectedCrfAndCodecCombination;

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

@@ -1,6 +1,7 @@
-import { openBrowser } from './open-browser';
+import type { openBrowser } from './open-browser';
 declare type Await<T> = T extends PromiseLike<infer U> ? U : T;
-export declare const cycleBrowserTabs: (puppeteerInstance: Await<ReturnType<typeof openBrowser>>, concurrency: number) => {
+declare type Browser = Await<ReturnType<typeof openBrowser>>;
+export declare const cycleBrowserTabs: (puppeteerInstance: Browser, concurrency: number) => {
     stopCycling: () => void;
 };
 export {};

package/dist/cycle-browser-tabs.js

@@ -9,15 +9,21 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
     }
     let interval = null;
     let i = 0;
+    let stopped = false;
     const set = () => {
         interval = setTimeout(() => {
             puppeteerInstance
                 .pages()
                 .then((pages) => {
-                var _a, _b;
+                var _a;
+                if (pages.length === 0) {
+                    return;
+                }
                 const currentPage = pages[i % pages.length];
                 i++;
-                if (!((_b = (_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) !== null && _b !== void 0 ? _b : true)) {
+                if (!((_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) &&
+                    !stopped &&
+                    (currentPage === null || currentPage === void 0 ? void 0 : currentPage.url()) !== 'about:blank') {
                     return currentPage.bringToFront();
                 }
             })
@@ -33,6 +39,7 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
             if (!interval) {
                 return;
             }
+            stopped = true;
             return clearInterval(interval);
         },
     };

package/dist/delay-render-embedded-stack.d.ts

@@ -1,2 +1,2 @@
-import { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
+import type { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
 export declare const parseDelayRenderEmbeddedStack: (message: string) => UnsymbolicatedStackFrame[] | null;

package/dist/ensure-frames-in-order.d.ts

@@ -1,4 +1,4 @@
-export declare const ensureFramesInOrder: (frameRange: [number, number]) => {
+export declare const ensureFramesInOrder: (framesToRender: number[]) => {
     waitForRightTimeOfFrameToBeInserted: (frameToBe: number) => Promise<void>;
     setFrameToStitch: (f: number) => void;
     waitForFinish: () => Promise<void>;

package/dist/ensure-frames-in-order.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureFramesInOrder = void 0;
-const ensureFramesInOrder = (frameRange) => {
-    let [frameToStitch, finalFrame] = frameRange;
+const ensureFramesInOrder = (framesToRender) => {
+    let [frameToStitch] = framesToRender;
+    const finalFrame = framesToRender[framesToRender.length - 1];
     let waiters = [];
     const resolveWaiters = () => {
         for (const waiter of waiters.slice(0)) {

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

@@ -0,0 +1,2 @@
+import type { DownloadMap } from './assets/download-map';
+export declare const ensurePresentationTimestamps: (downloadMap: DownloadMap, src: string) => Promise<string>;

package/dist/ensure-presentation-timestamp.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePresentationTimestamps = void 0;
+const execa_1 = __importDefault(require("execa"));
+const path_1 = __importDefault(require("path"));
+const guess_extension_for_media_1 = require("./guess-extension-for-media");
+const truthy_1 = require("./truthy");
+let callbacks = [];
+const getTemporaryOutputName = async (src) => {
+    const parts = src.split(path_1.default.sep);
+    // If there is no file extension for the video, then we need to temporarily add an extension
+    const lastPart = parts[parts.length - 1];
+    const extraExtension = lastPart.includes('.')
+        ? null
+        : await (0, guess_extension_for_media_1.guessExtensionForVideo)(src);
+    return parts
+        .map((p, i) => {
+        if (i === parts.length - 1) {
+            return [`pts-${p}`, extraExtension].filter(truthy_1.truthy).join('.');
+        }
+        return p;
+    })
+        .join(path_1.default.sep);
+};
+const ensurePresentationTimestamps = async (downloadMap, src) => {
+    const elem = downloadMap.ensureFileHasPresentationTimestamp[src];
+    if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'encoding') {
+        return new Promise((resolve) => {
+            callbacks.push({
+                src,
+                fn: (newSrc) => resolve(newSrc),
+            });
+        });
+    }
+    if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'done') {
+        return elem.src;
+    }
+    downloadMap.ensureFileHasPresentationTimestamp[src] = { type: 'encoding' };
+    // If there is no file extension for the video, then we need to tempoa
+    const output = await getTemporaryOutputName(src);
+    await (0, execa_1.default)('ffmpeg', [
+        '-i',
+        src,
+        '-fflags',
+        '+genpts+igndts',
+        '-vcodec',
+        'copy',
+        '-acodec',
+        'copy',
+        output,
+        '-y',
+    ]);
+    callbacks = callbacks.filter((c) => {
+        if (c.src === src) {
+            c.fn(output);
+            return false;
+        }
+        return true;
+    });
+    downloadMap.ensureFileHasPresentationTimestamp[src] = {
+        type: 'done',
+        src: output,
+    };
+    return output;
+};
+exports.ensurePresentationTimestamps = ensurePresentationTimestamps;

package/dist/error-handling/handle-javascript-exception.d.ts

@@ -1,5 +1,5 @@
-import { Page } from 'puppeteer-core';
-import { SymbolicatedStackFrame } from '../symbolicate-stacktrace';
+import type { Page } from '../browser/BrowserPage';
+import type { SymbolicatedStackFrame } from '../symbolicate-stacktrace';
 export declare class ErrorWithStackFrame extends Error {
     symbolicatedStackFrames: SymbolicatedStackFrame[] | null;
     frame: number | null;

package/dist/error-handling/handle-javascript-exception.js

@@ -41,8 +41,8 @@ const callFrameToStackFrame = (callFrame) => {
     };
 };
 const handleJavascriptException = ({ page, onError, frame, }) => {
-    const client = page._client;
-    const handler = async (exception) => {
+    const client = page._client();
+    const handler = (exception) => {
         var _a, _b, _c;
         const rawErrorMessage = (_a = exception.exceptionDetails.exception) === null || _a === void 0 ? void 0 : _a.description;
         const cleanErrorMessage = cleanUpErrorMessage(exception);
@@ -55,8 +55,7 @@ const handleJavascriptException = ({ page, onError, frame, }) => {
         const errorType = (_b = exception.exceptionDetails.exception) === null || _b === void 0 ? void 0 : _b.className;
         const symbolicatedErr = new symbolicateable_error_1.SymbolicateableError({
             message: removeDelayRenderStack(cleanErrorMessage),
-            stackFrame: exception.exceptionDetails.stackTrace
-                .callFrames.map((f) => callFrameToStackFrame(f)),
+            stackFrame: exception.exceptionDetails.stackTrace.callFrames.map((f) => callFrameToStackFrame(f)),
             frame,
             name: errorType,
             stack: (_c = exception.exceptionDetails.exception) === null || _c === void 0 ? void 0 : _c.description,

package/dist/error-handling/symbolicate-error.d.ts

@@ -1,3 +1,3 @@
 import { ErrorWithStackFrame } from './handle-javascript-exception';
-import { SymbolicateableError } from './symbolicateable-error';
+import type { SymbolicateableError } from './symbolicateable-error';
 export declare const symbolicateError: (symbolicateableError: SymbolicateableError) => Promise<ErrorWithStackFrame>;

package/dist/error-handling/symbolicateable-error.d.ts

@@ -1,7 +1,7 @@
 /**
  * A symbolicateable error is an error that can be symolicated by fetching the original sources. By throwing a symbolicateable error, Remotion CLI will attempt to symplicate it
  */
-import { UnsymbolicatedStackFrame } from '../parse-browser-error-stack';
+import type { UnsymbolicatedStackFrame } from '../parse-browser-error-stack';
 export declare class SymbolicateableError extends Error {
     stackFrame: UnsymbolicatedStackFrame[] | null;
     delayRenderCall: UnsymbolicatedStackFrame[] | null;

package/dist/extract-frame-from-video.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { DownloadMap } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { LastFrameOptions } from './last-frame-from-video-cache';
+export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;
+declare type Options = {
+    time: number;
+    src: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+    imageFormat: OffthreadVideoImageFormat;
+    downloadMap: DownloadMap;
+};
+export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
+export {};

package/dist/extract-frame-from-video.js

@@ -0,0 +1,254 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFrameFromVideo = exports.getLastFrameOfVideo = void 0;
+const execa_1 = __importDefault(require("execa"));
+const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
+const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
+const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
+const get_video_info_1 = require("./get-video-info");
+const is_beyond_last_frame_1 = require("./is-beyond-last-frame");
+const last_frame_from_video_cache_1 = require("./last-frame-from-video-cache");
+const p_limit_1 = require("./p-limit");
+const perf_1 = require("./perf");
+const truthy_1 = require("./truthy");
+const lastFrameLimit = (0, p_limit_1.pLimit)(1);
+const mainLimit = (0, p_limit_1.pLimit)(5);
+const determineVcodecFfmepgFlags = (vcodecFlag) => {
+    return [
+        vcodecFlag === 'vp9' ? '-vcodec' : null,
+        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
+        vcodecFlag === 'vp8' ? '-vcodec' : null,
+        vcodecFlag === 'vp8' ? 'libvpx' : null,
+    ].filter(truthy_1.truthy);
+};
+const determineResizeParams = (needsResize) => {
+    if (needsResize === null) {
+        return [];
+    }
+    return ['-s', `${needsResize[0]}x${needsResize[1]}`];
+};
+// 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 getFrameOfVideoSlow = async ({ src, timestamp, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, }) => {
+    console.warn(`\nUsing a slow method to extract the frame at ${timestamp}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
+    const actualOffset = `-${timestamp * 1000}ms`;
+    const command = [
+        '-itsoffset',
+        actualOffset,
+        ...determineVcodecFfmepgFlags(specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...determineResizeParams(needsResize),
+        '-',
+    ].filter(truthy_1.truthy);
+    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : '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) {
+        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 stdoutBuffer;
+};
+const getLastFrameOfVideoFastUnlimited = async (options) => {
+    const { ffmpegExecutable, ffprobeExecutable, offset, src, downloadMap } = options;
+    const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)({ ...options, offset: 0 });
+    if (fromCache) {
+        return fromCache;
+    }
+    const { duration, fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable);
+    if (duration === null) {
+        throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
+    }
+    if (options.specialVCodecForTransparency === 'vp8' || offset > 40) {
+        const last = await getFrameOfVideoSlow({
+            timestamp: duration,
+            ffmpegExecutable,
+            src,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
+            needsResize: options.needsResize,
+        });
+        return last;
+    }
+    const actualOffset = `${duration * 1000 - offset}ms`;
+    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+        '-ss',
+        actualOffset,
+        ...determineVcodecFfmepgFlags(options.specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        options.imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...determineResizeParams(options.needsResize),
+        '-',
+    ].filter(truthy_1.truthy));
+    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) {
+        const unlimited = await getLastFrameOfVideoFastUnlimited({
+            ffmpegExecutable,
+            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
+            offset: offset + 1000 / (fps === null ? 10 : fps),
+            src,
+            ffprobeExecutable,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
+            needsResize: options.needsResize,
+            downloadMap: options.downloadMap,
+        });
+        return unlimited;
+    }
+    return stdoutBuffer;
+};
+const getLastFrameOfVideo = async (options) => {
+    const result = await lastFrameLimit(getLastFrameOfVideoFastUnlimited, options);
+    (0, last_frame_from_video_cache_1.setLastFrameInCache)(options, result);
+    return result;
+};
+exports.getLastFrameOfVideo = getLastFrameOfVideo;
+const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutable, imageFormat, downloadMap, ...options }) => {
+    // We make a new copy of the video only for video because the conversion may affect
+    // audio rendering, so we work with 2 different files
+    const src = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)(downloadMap, options.src);
+    const { specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src, ffprobeExecutable);
+    if (specialVcodec === 'vp8') {
+        return getFrameOfVideoSlow({
+            ffmpegExecutable,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            src,
+            timestamp: time,
+            needsResize,
+        });
+    }
+    if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(downloadMap, src, time)) {
+        const lastFrame = await (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
+            offset: 0,
+            src,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            needsResize,
+            downloadMap,
+        });
+        return lastFrame;
+    }
+    const ffmpegTimestamp = (0, frame_to_ffmpeg_timestamp_1.frameToFfmpegTimestamp)(time);
+    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+        '-ss',
+        ffmpegTimestamp,
+        ...determineVcodecFfmepgFlags(specialVcodec),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-f',
+        'image2pipe',
+        '-vcodec',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        ...determineResizeParams(needsResize),
+        '-',
+    ].filter(truthy_1.truthy), {
+        buffer: false,
+    });
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const stderrStringProm = 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('utf8')));
+    });
+    const stdoutBuffer = 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 [stderrStr, stdOut] = await Promise.all([
+        stderrStringProm,
+        stdoutBuffer,
+    ]);
+    if (stderrStr.includes('Output file is empty')) {
+        (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(downloadMap, src, time);
+        const last = await (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
+            offset: 0,
+            src,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            needsResize,
+            downloadMap,
+        });
+        return last;
+    }
+    return stdOut;
+};
+const extractFrameFromVideo = async (options) => {
+    const perf = (0, perf_1.startPerfMeasure)('extract-frame');
+    const res = await mainLimit(extractFrameFromVideoFn, options);
+    (0, perf_1.stopPerfMeasure)(perf);
+    return res;
+};
+exports.extractFrameFromVideo = extractFrameFromVideo;

package/dist/ffmpeg-executable.d.ts

@@ -0,0 +1 @@
+export declare type FfmpegExecutable = string | null;