@remotion/renderer 4.0.0-fastlambda.8 → 4.0.0-lambda.3

package/dist/browser/revisions.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+declare type Revisions = Readonly<{
+    readonly chromium: string;
+    readonly firefox: string;
+}>;
+export declare const PUPPETEER_REVISIONS: Revisions;
+export {};

package/dist/browser/revisions.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUPPETEER_REVISIONS = void 0;
+exports.PUPPETEER_REVISIONS = {
+    chromium: '1002410',
+    firefox: 'latest',
+};

package/dist/browser/util.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/// <reference types="node" />
+import { Protocol } from 'devtools-protocol';
+import { CDPSession } from './Connection';
+import { CommonEventEmitter } from './EventEmitter';
+export declare function getExceptionMessage(exceptionDetails: Protocol.Runtime.ExceptionDetails): string;
+export declare function valueFromRemoteObject(remoteObject: Protocol.Runtime.RemoteObject): any;
+export declare function releaseObject(client: CDPSession, remoteObject: Protocol.Runtime.RemoteObject): Promise<void>;
+export interface PuppeteerEventListener {
+    emitter: CommonEventEmitter;
+    eventName: string | symbol;
+    handler: (...args: any[]) => void;
+}
+export declare function addEventListener(emitter: CommonEventEmitter, eventName: string | symbol, handler: (...args: any[]) => void): PuppeteerEventListener;
+export declare function removeEventListeners(listeners: Array<{
+    emitter: CommonEventEmitter;
+    eventName: string | symbol;
+    handler: (...args: any[]) => void;
+}>): void;
+export declare const isString: (obj: unknown) => obj is string;
+export declare function evaluationString(fun: Function | string, ...args: unknown[]): string;
+export declare function pageBindingDeliverResultString(name: string, seq: number, result: unknown): string;
+export declare function pageBindingDeliverErrorString(name: string, seq: number, message: string, stack?: string): string;
+export declare function pageBindingDeliverErrorValueString(name: string, seq: number, value: unknown): string;
+export declare function waitWithTimeout<T>(promise: Promise<T>, taskName: string, timeout: number): Promise<T>;
+interface ErrorLike extends Error {
+    name: string;
+    message: string;
+}
+export declare function isErrorLike(obj: unknown): obj is ErrorLike;
+export declare function isErrnoException(obj: unknown): obj is NodeJS.ErrnoException;
+export {};

package/dist/browser/util.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isErrnoException = exports.isErrorLike = exports.waitWithTimeout = exports.pageBindingDeliverErrorValueString = exports.pageBindingDeliverErrorString = exports.pageBindingDeliverResultString = exports.evaluationString = exports.isString = exports.removeEventListeners = exports.addEventListener = exports.releaseObject = exports.valueFromRemoteObject = exports.getExceptionMessage = void 0;
+const assert_1 = require("./assert");
+const Errors_1 = require("./Errors");
+function getExceptionMessage(exceptionDetails) {
+    if (exceptionDetails.exception) {
+        return (exceptionDetails.exception.description || exceptionDetails.exception.value);
+    }
+    let message = exceptionDetails.text;
+    if (exceptionDetails.stackTrace) {
+        for (const callframe of exceptionDetails.stackTrace.callFrames) {
+            const location = callframe.url +
+                ':' +
+                callframe.lineNumber +
+                ':' +
+                callframe.columnNumber;
+            const functionName = callframe.functionName || '<anonymous>';
+            message += `\n    at ${functionName} (${location})`;
+        }
+    }
+    return message;
+}
+exports.getExceptionMessage = getExceptionMessage;
+function valueFromRemoteObject(remoteObject) {
+    (0, assert_1.assert)(!remoteObject.objectId, 'Cannot extract value when objectId is given');
+    if (remoteObject.unserializableValue) {
+        if (remoteObject.type === 'bigint' && typeof BigInt !== 'undefined') {
+            return BigInt(remoteObject.unserializableValue.replace('n', ''));
+        }
+        switch (remoteObject.unserializableValue) {
+            case '-0':
+                return -0;
+            case 'NaN':
+                return NaN;
+            case 'Infinity':
+                return Infinity;
+            case '-Infinity':
+                return -Infinity;
+            default:
+                throw new Error('Unsupported unserializable value: ' +
+                    remoteObject.unserializableValue);
+        }
+    }
+    return remoteObject.value;
+}
+exports.valueFromRemoteObject = valueFromRemoteObject;
+async function releaseObject(client, remoteObject) {
+    if (!remoteObject.objectId) {
+        return;
+    }
+    await client
+        .send('Runtime.releaseObject', { objectId: remoteObject.objectId })
+        .catch(() => {
+        // Exceptions might happen in case of a page been navigated or closed.
+        // Swallow these since they are harmless and we don't leak anything in this case.
+    });
+}
+exports.releaseObject = releaseObject;
+function addEventListener(emitter, eventName, handler) {
+    emitter.on(eventName, handler);
+    return { emitter, eventName, handler };
+}
+exports.addEventListener = addEventListener;
+function removeEventListeners(listeners) {
+    for (const listener of listeners) {
+        listener.emitter.removeListener(listener.eventName, listener.handler);
+    }
+    listeners.length = 0;
+}
+exports.removeEventListeners = removeEventListeners;
+const isString = (obj) => {
+    return typeof obj === 'string' || obj instanceof String;
+};
+exports.isString = isString;
+function evaluationString(fun, ...args) {
+    if ((0, exports.isString)(fun)) {
+        (0, assert_1.assert)(args.length === 0, 'Cannot evaluate a string with arguments');
+        return fun;
+    }
+    function serializeArgument(arg) {
+        if (Object.is(arg, undefined)) {
+            return 'undefined';
+        }
+        return JSON.stringify(arg);
+    }
+    return `(${fun})(${args.map(serializeArgument).join(',')})`;
+}
+exports.evaluationString = evaluationString;
+function pageBindingDeliverResultString(name, seq, result) {
+    function deliverResult(_name, _seq, _result) {
+        window[_name].callbacks.get(_seq).resolve(_result);
+        window[_name].callbacks.delete(_seq);
+    }
+    return evaluationString(deliverResult, name, seq, result);
+}
+exports.pageBindingDeliverResultString = pageBindingDeliverResultString;
+function pageBindingDeliverErrorString(name, seq, message, stack) {
+    function deliverError(_name, _seq, _message, _stack) {
+        const error = new Error(_message);
+        error.stack = _stack;
+        window[_name].callbacks.get(_seq).reject(error);
+        window[_name].callbacks.delete(_seq);
+    }
+    return evaluationString(deliverError, name, seq, message, stack);
+}
+exports.pageBindingDeliverErrorString = pageBindingDeliverErrorString;
+function pageBindingDeliverErrorValueString(name, seq, value) {
+    function deliverErrorValue(_name, _seq, _value) {
+        window[_name].callbacks.get(_seq).reject(_value);
+        window[_name].callbacks.delete(_seq);
+    }
+    return evaluationString(deliverErrorValue, name, seq, value);
+}
+exports.pageBindingDeliverErrorValueString = pageBindingDeliverErrorValueString;
+async function waitWithTimeout(promise, taskName, timeout) {
+    let reject;
+    const timeoutError = new Errors_1.TimeoutError(`waiting for ${taskName} failed: timeout ${timeout}ms exceeded`);
+    const timeoutPromise = new Promise((_res, rej) => {
+        reject = rej;
+    });
+    let timeoutTimer = null;
+    if (timeout) {
+        timeoutTimer = setTimeout(() => {
+            return reject(timeoutError);
+        }, timeout);
+    }
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        if (timeoutTimer) {
+            clearTimeout(timeoutTimer);
+        }
+    }
+}
+exports.waitWithTimeout = waitWithTimeout;
+function isErrorLike(obj) {
+    return (typeof obj === 'object' && obj !== null && 'name' in obj && 'message' in obj);
+}
+exports.isErrorLike = isErrorLike;
+function isErrnoException(obj) {
+    return (isErrorLike(obj) &&
+        ('errno' in obj || 'code' in obj || 'path' in obj || 'syscall' in obj));
+}
+exports.isErrnoException = isErrnoException;

package/dist/calculate-ffmpeg-filters.js

@@ -7,8 +7,8 @@ const calculateFfmpegFilter = ({ asset, fps, durationInFrames, channels, assetDu
     if (channels === 0) {
         return null;
     }
-    const assetTrimLeft = asset.trimLeft / fps;
-    const assetTrimRight = (asset.trimLeft + asset.duration * asset.playbackRate) / fps;
+    const assetTrimLeft = (asset.trimLeft * asset.playbackRate) / fps;
+    const assetTrimRight = assetTrimLeft + (asset.duration * asset.playbackRate) / fps;
     return (0, stringify_ffmpeg_filter_1.stringifyFfmpegFilter)({
         channels,
         startInVideo: asset.startInVideo,

package/dist/combine-videos.d.ts

@@ -1,9 +1,10 @@
 import { Codec } from 'remotion';
-export declare const combineVideos: ({ files, filelistDir, output, onProgress, numberOfFrames, codec, }: {
+export declare const combineVideos: ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, }: {
     files: string[];
     filelistDir: string;
     output: string;
     onProgress: (p: number) => void;
     numberOfFrames: number;
     codec: Codec;
+    fps: number;
 }) => Promise<void>;

package/dist/combine-videos.js

@@ -11,13 +11,15 @@ const path_1 = require("path");
 const remotion_1 = require("remotion");
 const get_audio_codec_name_1 = require("./get-audio-codec-name");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
-const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfFrames, codec, }) => {
+const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, }) => {
     var _a;
     const fileList = files.map((p) => `file '${p}'`).join('\n');
     const fileListTxt = (0, path_1.join)(filelistDir, 'files.txt');
     (0, fs_1.writeFileSync)(fileListTxt, fileList);
     try {
         const task = (0, execa_1.default)('ffmpeg', [
+            remotion_1.Internals.isAudioCodec(codec) ? null : '-r',
+            remotion_1.Internals.isAudioCodec(codec) ? null : String(fps),
             '-f',
             'concat',
             '-safe',
@@ -28,6 +30,11 @@ const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfF
             remotion_1.Internals.isAudioCodec(codec) ? null : 'copy',
             '-c:a',
             (0, get_audio_codec_name_1.getAudioCodecName)(codec),
+            // Set max bitrate up to 1024kbps, will choose lower if that's too much
+            '-b:a',
+            '512K',
+            codec === 'h264' ? '-movflags' : null,
+            codec === 'h264' ? 'faststart' : null,
             '-shortest',
             '-y',
             output,

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

@@ -1,6 +1,7 @@
 import { 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/ensure-presentation-timestamp.d.ts

@@ -0,0 +1 @@
+export declare const ensurePresentationTimestamps: (src: string) => Promise<unknown>;

package/dist/ensure-presentation-timestamp.js

@@ -0,0 +1,57 @@
+"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 promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const ensureFileHasPresentationTimestamp = {};
+let callbacks = [];
+const ensurePresentationTimestamps = async (src) => {
+    if (ensureFileHasPresentationTimestamp[src] === 'encoding') {
+        return new Promise((resolve) => {
+            callbacks.push({
+                src,
+                fn: () => resolve,
+            });
+        });
+    }
+    if (ensureFileHasPresentationTimestamp[src] === 'done') {
+        return;
+    }
+    ensureFileHasPresentationTimestamp[src] = 'encoding';
+    const parts = src.split(path_1.default.sep);
+    const output = parts
+        .map((p, i) => {
+        if (i === parts.length - 1) {
+            return `pts-${p}`;
+        }
+        return p;
+    })
+        .join(path_1.default.sep);
+    await (0, execa_1.default)('ffmpeg', [
+        '-i',
+        src,
+        '-fflags',
+        '+genpts+igndts',
+        '-vcodec',
+        'copy',
+        '-acodec',
+        'copy',
+        output,
+        '-y',
+    ]);
+    await (0, promises_1.unlink)(src);
+    await (0, promises_1.rename)(output, src);
+    callbacks = callbacks.filter((c) => {
+        if (c.src === src) {
+            c.fn();
+            return false;
+        }
+        return true;
+    });
+    ensureFileHasPresentationTimestamp[src] = 'done';
+};
+exports.ensurePresentationTimestamps = ensurePresentationTimestamps;

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

@@ -0,0 +1,11 @@
+import { FfmpegExecutable } from 'remotion';
+import { 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;
+};
+export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
+export {};

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

@@ -0,0 +1,197 @@
+"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 remotion_1 = require("remotion");
+const get_audio_channels_1 = require("./assets/get-audio-channels");
+const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
+const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
+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 lastFrameLimit = (0, p_limit_1.pLimit)(1);
+const mainLimit = (0, p_limit_1.pLimit)(5);
+// 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 getLastFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, }) => {
+    console.warn(`\nUsing a slow method to determine the last frame of ${src}. The render can be sped up by re-encoding the video properly.`);
+    const actualOffset = `-${duration * 1000}ms`;
+    const command = [
+        '-itsoffset',
+        actualOffset,
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-f',
+        'image2pipe',
+        '-',
+    ];
+    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 } = options;
+    const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)({ ...options, offset: 0 });
+    if (fromCache) {
+        return fromCache;
+    }
+    const { duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)(src, ffprobeExecutable);
+    if (duration === null) {
+        throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
+    }
+    if (offset > 40) {
+        const last = await getLastFrameOfVideoSlow({
+            duration,
+            ffmpegExecutable,
+            src,
+        });
+        return last;
+    }
+    const actualOffset = `${duration * 1000 - offset - 10}ms`;
+    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+        '-ss',
+        actualOffset,
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-f',
+        'image2pipe',
+        '-',
+    ]);
+    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,
+            offset: offset + 10,
+            src,
+            ffprobeExecutable,
+        });
+        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, src, ffmpegExecutable, ffprobeExecutable, }) => {
+    await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)(src);
+    if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(src, time)) {
+        const lastFrame = await (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
+            offset: 0,
+            src,
+        });
+        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,
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-f',
+        'image2pipe',
+        '-',
+    ], {
+        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)(src, time);
+        const last = await (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
+            offset: 0,
+            src,
+        });
+        return last;
+    }
+    return stdOut;
+};
+const extractFrameFromVideo = async (options) => {
+    const perf = remotion_1.Internals.perf.startPerfMeasure('extract-frame');
+    const res = await mainLimit(extractFrameFromVideoFn, options);
+    remotion_1.Internals.perf.stopPerfMeasure(perf);
+    return res;
+};
+exports.extractFrameFromVideo = extractFrameFromVideo;

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-compositions.d.ts

@@ -1,5 +1,5 @@
 import { Browser } from 'puppeteer-core';
-import { BrowserExecutable, TCompMetadata } from 'remotion';
+import { BrowserExecutable, FfmpegExecutable, TCompMetadata } from 'remotion';
 import { BrowserLog } from './browser-log';
 import { ChromiumOptions } from './open-browser';
 declare type GetCompositionsConfig = {
@@ -10,6 +10,9 @@ declare type GetCompositionsConfig = {
     browserExecutable?: BrowserExecutable;
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
+    ffmpegExecutable?: FfmpegExecutable;
+    ffprobeExecutable?: FfmpegExecutable;
+    port?: number | null;
 };
-export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig | undefined) => Promise<TCompMetadata[]>;
+export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<TCompMetadata[]>;
 export {};