@remotion/renderer 3.0.21 → 3.0.24

package/dist/render-gif.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderGif = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const remotion_1 = require("remotion");
+const can_use_parallel_encoding_1 = require("./can-use-parallel-encoding");
+const ensure_frames_in_order_1 = require("./ensure-frames-in-order");
+const ensure_output_directory_1 = require("./ensure-output-directory");
+const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
+const get_extension_from_codec_1 = require("./get-extension-from-codec");
+const get_extension_of_filename_1 = require("./get-extension-of-filename");
+const get_frame_to_render_1 = require("./get-frame-to-render");
+const legacy_webpack_config_1 = require("./legacy-webpack-config");
+const make_cancel_signal_1 = require("./make-cancel-signal");
+const prespawn_ffmpeg_1 = require("./prespawn-ffmpeg");
+const render_frames_1 = require("./render-frames");
+const stitch_frames_to_gif_1 = require("./stitch-frames-to-gif");
+const tmp_dir_1 = require("./tmp-dir");
+const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
+const validate_output_filename_1 = require("./validate-output-filename");
+const validate_scale_1 = require("./validate-scale");
+const renderGif = ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, loop, skipNFrames, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }) => {
+    remotion_1.Internals.validateQuality(quality);
+    if (typeof crf !== 'undefined' && crf !== null) {
+        remotion_1.Internals.validateSelectedCrfAndCodecCombination(crf, codec);
+    }
+    (0, validate_output_filename_1.validateOutputFilename)(codec, (0, get_extension_of_filename_1.getExtensionOfFilename)(outputLocation));
+    (0, validate_scale_1.validateScale)(scale);
+    const serveUrl = (0, legacy_webpack_config_1.getServeUrlWithFallback)(options);
+    let stitchStage = 'encoding';
+    let stitcherFfmpeg;
+    let preStitcher = null;
+    let encodedFrames = 0;
+    let renderedFrames = 0;
+    let renderedDoneIn = null;
+    let encodedDoneIn = null;
+    let cancelled = false;
+    const renderStart = Date.now();
+    const tmpdir = (0, tmp_dir_1.tmpDir)('pre-encode');
+    const parallelEncoding = (0, can_use_parallel_encoding_1.canUseParallelEncoding)(codec);
+    const actualImageFormat = imageFormat !== null && imageFormat !== void 0 ? imageFormat : 'jpeg';
+    const preEncodedFileLocation = parallelEncoding
+        ? path_1.default.join(tmpdir, 'pre-encode.' + (0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, 'chunk'))
+        : null;
+    const outputDir = parallelEncoding
+        ? null
+        : fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'react-motion-render'));
+    (0, validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec)({
+        codec,
+        height: composition.height,
+        scale: scale !== null && scale !== void 0 ? scale : 1,
+        width: composition.width,
+    });
+    const callUpdate = () => {
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+            encodedDoneIn,
+            encodedFrames,
+            renderedDoneIn,
+            renderedFrames,
+            stitchStage,
+        });
+    };
+    const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(composition.durationInFrames, frameRange !== null && frameRange !== void 0 ? frameRange : null);
+    const cancelRenderFrames = (0, make_cancel_signal_1.makeCancelSignal)();
+    const cancelPrestitcher = (0, make_cancel_signal_1.makeCancelSignal)();
+    const cancelStitcher = (0, make_cancel_signal_1.makeCancelSignal)();
+    cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+        cancelRenderFrames.cancel();
+    });
+    const { waitForRightTimeOfFrameToBeInserted, setFrameToStitch, waitForFinish } = (0, ensure_frames_in_order_1.ensureFramesInOrder)(realFrameRange);
+    const actualGifFps = Math.floor(composition.fps / (skipNFrames + 1));
+    const createPrestitcherIfNecessary = async () => {
+        if (preEncodedFileLocation) {
+            preStitcher = await (0, prespawn_ffmpeg_1.prespawnFfmpeg)({
+                width: composition.width * (scale !== null && scale !== void 0 ? scale : 1),
+                height: composition.height * (scale !== null && scale !== void 0 ? scale : 1),
+                fps: actualGifFps,
+                outputLocation: preEncodedFileLocation,
+                pixelFormat,
+                codec,
+                proResProfile,
+                crf,
+                onProgress: (frame) => {
+                    encodedFrames = frame;
+                    callUpdate();
+                },
+                verbose: remotion_1.Internals.Logging.isEqualOrBelowLogLevel(remotion_1.Internals.Logging.getLogLevel(), 'verbose'),
+                ffmpegExecutable,
+                imageFormat: actualImageFormat,
+                signal: cancelPrestitcher.cancelSignal,
+            });
+            stitcherFfmpeg = preStitcher.task;
+        }
+    };
+    const waitForPrestitcherIfNecessary = async () => {
+        var _a;
+        if (stitcherFfmpeg) {
+            await waitForFinish();
+            (_a = stitcherFfmpeg === null || stitcherFfmpeg === void 0 ? void 0 : stitcherFfmpeg.stdin) === null || _a === void 0 ? void 0 : _a.end();
+            try {
+                await stitcherFfmpeg;
+            }
+            catch (err) {
+                throw new Error(preStitcher === null || preStitcher === void 0 ? void 0 : preStitcher.getLogs());
+            }
+        }
+    };
+    const happyPath = createPrestitcherIfNecessary()
+        .then(() => {
+        const renderFramesProc = (0, render_frames_1.renderFrames)({
+            config: composition,
+            onFrameUpdate: (frame) => {
+                stitchStage = 'gif';
+                renderedFrames = frame;
+                callUpdate();
+            },
+            parallelism,
+            outputDir,
+            skipNFrames,
+            onStart: (data) => {
+                renderedFrames = 0;
+                callUpdate();
+                onStart === null || onStart === void 0 ? void 0 : onStart(data);
+            },
+            inputProps,
+            envVariables,
+            imageFormat: actualImageFormat,
+            quality,
+            frameRange: frameRange !== null && frameRange !== void 0 ? frameRange : null,
+            puppeteerInstance,
+            onFrameBuffer: parallelEncoding
+                ? async (buffer, frame) => {
+                    var _a;
+                    await waitForRightTimeOfFrameToBeInserted(frame);
+                    if (cancelled) {
+                        return;
+                    }
+                    (_a = stitcherFfmpeg === null || stitcherFfmpeg === void 0 ? void 0 : stitcherFfmpeg.stdin) === null || _a === void 0 ? void 0 : _a.write(buffer);
+                    setFrameToStitch(frame + 1);
+                }
+                : undefined,
+            serveUrl,
+            dumpBrowserLogs,
+            onBrowserLog,
+            onDownload,
+            timeoutInMilliseconds,
+            chromiumOptions,
+            scale,
+            ffmpegExecutable,
+            browserExecutable,
+            port,
+            cancelSignal: cancelRenderFrames.cancelSignal,
+        });
+        return renderFramesProc;
+    })
+        .then((renderFramesReturn) => {
+        return Promise.all([renderFramesReturn, waitForPrestitcherIfNecessary()]);
+    })
+        .then(([{ assetsInfo }]) => {
+        renderedDoneIn = Date.now() - renderStart;
+        callUpdate();
+        (0, ensure_output_directory_1.ensureOutputDirectory)(outputLocation);
+        const stitchStart = Date.now();
+        return Promise.all([
+            (0, stitch_frames_to_gif_1.stitchFramesToGif)({
+                width: composition.width * (scale !== null && scale !== void 0 ? scale : 1),
+                height: composition.height * (scale !== null && scale !== void 0 ? scale : 1),
+                fps: actualGifFps,
+                outputLocation,
+                internalOptions: {
+                    preEncodedFileLocation,
+                    imageFormat: actualImageFormat,
+                },
+                force: overwrite !== null && overwrite !== void 0 ? overwrite : remotion_1.Internals.DEFAULT_OVERWRITE,
+                pixelFormat,
+                codec,
+                proResProfile,
+                crf,
+                loop,
+                assetsInfo,
+                ffmpegExecutable,
+                onProgress: (frame) => {
+                    stitchStage = 'gif';
+                    encodedFrames = frame;
+                    callUpdate();
+                },
+                verbose: remotion_1.Internals.Logging.isEqualOrBelowLogLevel(remotion_1.Internals.Logging.getLogLevel(), 'verbose'),
+                dir: outputDir !== null && outputDir !== void 0 ? outputDir : undefined,
+                cancelSignal: cancelStitcher.cancelSignal,
+            }),
+            stitchStart,
+        ]);
+    })
+        .then(([, stitchStart]) => {
+        encodedFrames = (0, get_duration_from_frame_range_1.getDurationFromFrameRange)(frameRange !== null && frameRange !== void 0 ? frameRange : null, composition.durationInFrames, skipNFrames);
+        encodedDoneIn = Date.now() - stitchStart;
+        callUpdate();
+    })
+        .catch((err) => {
+        /**
+         * When an error is thrown in renderFrames(...) (e.g., when delayRender() is used incorrectly), fs.unlinkSync(...) throws an error that the file is locked because ffmpeg is still running, and renderMedia returns it.
+         * Therefore we first kill the FFMPEG process before deleting the file
+         */
+        cancelled = true;
+        cancelRenderFrames.cancel();
+        cancelStitcher.cancel();
+        cancelPrestitcher.cancel();
+        if (stitcherFfmpeg !== undefined && stitcherFfmpeg.exitCode === null) {
+            const promise = new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve();
+                }, 2000);
+                stitcherFfmpeg.on('close', resolve);
+            });
+            stitcherFfmpeg.kill();
+            return promise.then(() => {
+                throw err;
+            });
+        }
+        throw err;
+    })
+        .finally(() => {
+        if (preEncodedFileLocation !== null &&
+            fs_1.default.existsSync(preEncodedFileLocation)) {
+            fs_1.default.unlinkSync(preEncodedFileLocation);
+        }
+    });
+    return Promise.race([
+        happyPath,
+        new Promise((_resolve, reject) => {
+            cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+                reject(new Error('renderMedia() got cancelled'));
+            });
+        }),
+    ]);
+};
+exports.renderGif = renderGif;

package/dist/render-media.d.ts

@@ -1,11 +1,11 @@
-import type { Browser as PuppeteerBrowser } from 'puppeteer-core';
-import { BrowserExecutable, Codec, FfmpegExecutable, FrameRange, PixelFormat, ProResProfile, SmallTCompMetadata } from 'remotion';
-import { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
-import { BrowserLog } from './browser-log';
-import { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
-import { CancelSignal } from './make-cancel-signal';
-import { ChromiumOptions } from './open-browser';
-import { OnStartData } from './types';
+import type { BrowserExecutable, Codec, FfmpegExecutable, FrameRange, PixelFormat, ProResProfile, SmallTCompMetadata } from 'remotion';
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { BrowserLog } from './browser-log';
+import type { Browser as PuppeteerBrowser } from './browser/Browser';
+import type { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
+import type { CancelSignal } from './make-cancel-signal';
+import type { ChromiumOptions } from './open-browser';
+import type { OnStartData } from './types';
 export declare type StitchingState = 'encoding' | 'muxing';
 export declare type RenderMediaOnProgress = (progress: {
     renderedFrames: number;

package/dist/render-still.d.ts

@@ -1,9 +1,9 @@
-import { Browser as PuppeteerBrowser } from 'puppeteer-core';
-import { BrowserExecutable, FfmpegExecutable, SmallTCompMetadata, StillImageFormat } from 'remotion';
-import { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
-import { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
-import { CancelSignal } from './make-cancel-signal';
-import { ChromiumOptions } from './open-browser';
+import type { BrowserExecutable, FfmpegExecutable, SmallTCompMetadata, StillImageFormat } from 'remotion';
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { Browser as PuppeteerBrowser } from './browser/Browser';
+import type { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
+import type { CancelSignal } from './make-cancel-signal';
+import type { ChromiumOptions } from './open-browser';
 declare type InnerStillOptions = {
     composition: SmallTCompMetadata;
     output: string;

package/dist/screenshot-dom-element.d.ts

@@ -1,11 +1,10 @@
-import puppeteer from 'puppeteer-core';
-import { ImageFormat } from 'remotion';
+import type { ImageFormat } from 'remotion';
+import type { Page } from './browser/Page';
 export declare const screenshotDOMElement: ({ page, imageFormat, quality, opts, }: {
-    page: puppeteer.Page;
+    page: Page;
     imageFormat: ImageFormat;
     quality: number | undefined;
-    opts?: {
-        path?: string | undefined;
-        selector?: string | undefined;
-    } | undefined;
+    opts: {
+        path: string | null;
+    };
 }) => Promise<Buffer>;

package/dist/screenshot-dom-element.js

@@ -3,11 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.screenshotDOMElement = void 0;
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
 const puppeteer_screenshot_1 = require("./puppeteer-screenshot");
-const screenshotDOMElement = async ({ page, imageFormat, quality, opts = {}, }) => {
-    const path = 'path' in opts ? opts.path : undefined;
-    const { selector } = opts;
-    if (!selector)
-        throw Error('Please provide a selector.');
+const screenshotDOMElement = async ({ page, imageFormat, quality, opts, }) => {
+    const { path } = opts;
     if (imageFormat === 'png') {
         await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
             pageFunction: () => {
@@ -33,7 +30,7 @@ const screenshotDOMElement = async ({ page, imageFormat, quality, opts = {}, })
     }
     return (0, puppeteer_screenshot_1.screenshot)(page, {
         omitBackground: imageFormat === 'png',
-        path,
+        path: path !== null && path !== void 0 ? path : undefined,
         type: imageFormat,
         quality,
     });

package/dist/screenshot-task.d.ts

@@ -1,3 +1,4 @@
-import { Page, ScreenshotOptions } from 'puppeteer-core';
-import { StillImageFormat } from 'remotion';
+import type { StillImageFormat } from 'remotion';
+import type { Page } from './browser/Page';
+import type { ScreenshotOptions } from './browser/ScreenshotOptions';
 export declare const _screenshotTask: (page: Page, format: StillImageFormat, options: ScreenshotOptions) => Promise<Buffer | string>;

package/dist/screenshot-task.js

@@ -7,8 +7,8 @@ exports._screenshotTask = void 0;
 const fs_1 = __importDefault(require("fs"));
 const remotion_1 = require("remotion");
 const _screenshotTask = async (page, format, options) => {
-    const client = page._client;
-    const target = page._target;
+    const client = page._client();
+    const target = page.target();
     const perfTarget = remotion_1.Internals.perf.startPerfMeasure('activate-target');
     await client.send('Target.activateTarget', {
         targetId: target._targetId,
@@ -30,9 +30,7 @@ const _screenshotTask = async (page, format, options) => {
     if (shouldSetDefaultBackground)
         await client.send('Emulation.setDefaultBackgroundColorOverride');
     const saveMarker = remotion_1.Internals.perf.startPerfMeasure('save');
-    const buffer = options.encoding === 'base64'
-        ? result.data
-        : Buffer.from(result.data, 'base64');
+    const buffer = Buffer.from(result.data, 'base64');
     if (options.path)
         await fs_1.default.promises.writeFile(options.path, buffer);
     remotion_1.Internals.perf.stopPerfMeasure(saveMarker);

package/dist/seek-to-frame.d.ts

@@ -1,5 +1,5 @@
-import puppeteer from 'puppeteer-core';
+import type { Page } from './browser/Page';
 export declare const seekToFrame: ({ frame, page, }: {
     frame: number;
-    page: puppeteer.Page;
+    page: Page;
 }) => Promise<void>;

package/dist/serve-handler/index.d.ts

@@ -1,4 +1,4 @@
-import { IncomingMessage, ServerResponse } from 'http';
+import type { IncomingMessage, ServerResponse } from 'http';
 export declare const serveHandler: (request: IncomingMessage, response: ServerResponse, config: {
     public: string;
 }) => Promise<void>;

package/dist/serve-handler/index.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serveHandler = void 0;
-// Native
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const url_1 = __importDefault(require("url"));

package/dist/serve-static.d.ts

@@ -1,5 +1,5 @@
-import { FfmpegExecutable } from 'remotion';
-import { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { FfmpegExecutable } from 'remotion';
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 export declare const serveStatic: (path: string | null, options: {
     port: number | null;
     ffmpegExecutable: FfmpegExecutable;

package/dist/set-props-and-env.d.ts

@@ -1,4 +1,4 @@
-import { Page } from 'puppeteer-core';
+import type { Page } from './browser/Page';
 export declare const setPropsAndEnv: ({ inputProps, envVariables, page, serveUrl, initialFrame, timeoutInMilliseconds, proxyPort, retriesRemaining, }: {
     inputProps: unknown;
     envVariables: Record<string, string> | undefined;

package/dist/set-props-and-env.js

@@ -31,6 +31,9 @@ const setPropsAndEnv = async ({ inputProps, envVariables, page, serveUrl, initia
         window.remotion_proxyPort = port;
     }, [proxyPort]);
     const pageRes = await page.goto(urlToVisit);
+    if (pageRes === null) {
+        throw new Error(`Visited "${urlToVisit}" but got no response.`);
+    }
     const status = pageRes.status();
     // S3 in rare occasions returns a 500 or 503 error code for GET operations.
     // Usually it is fixed by retrying.

package/dist/should-use-vp9-decoder.js

@@ -0,0 +1 @@
+"use strict";

package/dist/stitch-frames-to-gif.d.ts

@@ -0,0 +1,8 @@
+import { StitcherOptions } from './stitch-frames-to-video';
+declare type ReturnType = {
+    task: Promise<unknown>;
+    getLogs: () => string;
+};
+export declare const spawnFfmpeg: (options: StitcherOptions) => Promise<ReturnType>;
+export declare const stitchFramesToGif: (options: StitcherOptions) => Promise<void>;
+export {};

package/dist/stitch-frames-to-gif.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stitchFramesToGif = exports.spawnFfmpeg = void 0;
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const remotion_1 = require("remotion");
+const get_codec_name_1 = require("./get-codec-name");
+const get_prores_profile_name_1 = require("./get-prores-profile-name");
+const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
+const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
+const validate_ffmpeg_1 = require("./validate-ffmpeg");
+const packageJsonPath = path_1.default.join(__dirname, '..', 'package.json');
+const packageJson = fs_1.default.existsSync(packageJsonPath)
+    ? JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'))
+    : null;
+const spawnFfmpeg = async (options) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    remotion_1.Internals.validateDimension(options.height, 'height', 'passed to `stitchFramesToVideo()`');
+    remotion_1.Internals.validateDimension(options.width, 'width', 'passed to `stitchFramesToVideo()`');
+    remotion_1.Internals.validateFps(options.fps, 'passed to `stitchFramesToVideo()`');
+    const codec = (_a = options.codec) !== null && _a !== void 0 ? _a : remotion_1.Internals.DEFAULT_CODEC;
+    (0, validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec)({
+        width: options.width,
+        height: options.height,
+        codec,
+        scale: 1,
+    });
+    const crf = (_b = options.crf) !== null && _b !== void 0 ? _b : remotion_1.Internals.getDefaultCrfForCodec(codec);
+    const pixelFormat = (_c = options.pixelFormat) !== null && _c !== void 0 ? _c : remotion_1.Internals.DEFAULT_PIXEL_FORMAT;
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_d = options.ffmpegExecutable) !== null && _d !== void 0 ? _d : null);
+    const encoderName = (0, get_codec_name_1.getCodecName)(codec);
+    const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
+    const supportsCrf = encoderName && codec !== 'prores';
+    if (options.verbose) {
+        console.log('[verbose] ffmpeg', (_e = options.ffmpegExecutable) !== null && _e !== void 0 ? _e : 'ffmpeg in PATH');
+        console.log('[verbose] encoder', encoderName);
+        console.log('[verbose] pixelFormat', pixelFormat);
+        if (supportsCrf) {
+            console.log('[verbose] crf', crf);
+        }
+        console.log('[verbose] codec', codec);
+        console.log('[verbose] proResProfileName', proResProfileName);
+    }
+    remotion_1.Internals.validateSelectedCrfAndCodecCombination(crf, codec);
+    remotion_1.Internals.validateSelectedPixelFormatAndCodecCombination(pixelFormat, codec);
+    const expectedFrames = options.assetsInfo.assets.length;
+    const updateProgress = (preStitchProgress, muxProgress) => {
+        var _a;
+        const totalFrameProgress = 0.5 * preStitchProgress * expectedFrames + muxProgress * 0.5;
+        (_a = options.onProgress) === null || _a === void 0 ? void 0 : _a.call(options, Math.round(totalFrameProgress));
+    };
+    const ffmpegArgs = [
+        ['-r', String(options.fps)],
+        ...(((_f = options.internalOptions) === null || _f === void 0 ? void 0 : _f.preEncodedFileLocation)
+            ? [['-i', (_g = options.internalOptions) === null || _g === void 0 ? void 0 : _g.preEncodedFileLocation]]
+            : [
+                ['-f', 'image2'],
+                ['-s', `${options.width}x${options.height}`],
+                ['-start_number', String(options.assetsInfo.firstFrameIndex)],
+                ['-i', options.assetsInfo.imageSequenceName],
+            ]),
+        // -c:v is the same as -vcodec as -codec:video
+        // and specified the video codec.
+        options.loop === null
+            ? null
+            : ['-loop', typeof options.loop === 'number' ? options.loop : '-1'],
+        // Ignore metadata that may come from remote media
+        ['-map_metadata', '-1'],
+        [
+            '-metadata',
+            `comment=` +
+                [`Made with Remotion`, packageJson ? packageJson.version : null].join(' '),
+        ],
+        options.force ? '-y' : null,
+        options.outputLocation,
+    ];
+    if (options.verbose) {
+        console.log('Generated FFMPEG command:');
+        console.log(ffmpegArgs);
+    }
+    const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
+    const task = (0, execa_1.default)((_h = options.ffmpegExecutable) !== null && _h !== void 0 ? _h : 'ffmpeg', ffmpegString, {
+        cwd: options.dir,
+    });
+    (_j = options.cancelSignal) === null || _j === void 0 ? void 0 : _j.call(options, () => {
+        task.kill();
+    });
+    let ffmpegOutput = '';
+    let isFinished = false;
+    (_k = task.stderr) === null || _k === void 0 ? void 0 : _k.on('data', (data) => {
+        var _a;
+        const str = data.toString();
+        ffmpegOutput += str;
+        if (options.onProgress) {
+            const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(str);
+            // FFMPEG bug: In some cases, FFMPEG does hang after it is finished with it's job
+            // Example repo: https://github.com/JonnyBurger/ffmpeg-repro (access can be given upon request)
+            if (parsed !== undefined) {
+                // If two times in a row the finishing frame is logged, we quit the render
+                if (parsed === expectedFrames) {
+                    if (isFinished) {
+                        (_a = task.stdin) === null || _a === void 0 ? void 0 : _a.write('q');
+                    }
+                    else {
+                        isFinished = true;
+                    }
+                }
+                updateProgress(1, parsed);
+            }
+        }
+    });
+    return { task, getLogs: () => ffmpegOutput };
+};
+exports.spawnFfmpeg = spawnFfmpeg;
+const stitchFramesToGif = async (options) => {
+    const { task, getLogs } = await (0, exports.spawnFfmpeg)(options);
+    try {
+        await task;
+    }
+    catch (err) {
+        throw new Error(getLogs());
+    }
+};
+exports.stitchFramesToGif = stitchFramesToGif;

package/dist/stitch-frames-to-video.d.ts

@@ -1,6 +1,6 @@
-import { Codec, FfmpegExecutable, ImageFormat, PixelFormat, ProResProfile, RenderAssetInfo } from 'remotion';
-import { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
-import { CancelSignal } from './make-cancel-signal';
+import type { Codec, FfmpegExecutable, ImageFormat, PixelFormat, ProResProfile, RenderAssetInfo } from 'remotion';
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { CancelSignal } from './make-cancel-signal';
 export declare type StitcherOptions = {
     fps: number;
     width: number;

package/dist/stringify-ffmpeg-filter.d.ts

@@ -1,4 +1,4 @@
-import { AssetVolume } from './assets/types';
+import type { AssetVolume } from './assets/types';
 export declare const stringifyFfmpegFilter: ({ trimLeft, trimRight, channels, startInVideo, volume, fps, playbackRate, durationInFrames, assetDuration, }: {
     trimLeft: number;
     trimRight: number;
@@ -9,4 +9,4 @@ export declare const stringifyFfmpegFilter: ({ trimLeft, trimRight, channels, st
     durationInFrames: number;
     playbackRate: number;
     assetDuration: number | null;
-}) => string;
+}) => string | null;

package/dist/stringify-ffmpeg-filter.js

@@ -7,6 +7,9 @@ const ffmpeg_volume_expression_1 = require("./assets/ffmpeg-volume-expression");
 const sample_rate_1 = require("./sample-rate");
 const stringifyFfmpegFilter = ({ trimLeft, trimRight, channels, startInVideo, volume, fps, playbackRate, durationInFrames, assetDuration, }) => {
     const startInVideoSeconds = startInVideo / fps;
+    if (assetDuration && trimLeft >= assetDuration) {
+        return null;
+    }
     const volumeFilter = (0, ffmpeg_volume_expression_1.ffmpegVolumeExpression)({
         volume,
         startInVideo,

package/dist/symbolicate-stacktrace.d.ts

@@ -1,4 +1,4 @@
-import { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
+import type { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
 declare type ScriptLine = {
     lineNumber: number;
     content: string;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { RenderAssetInfo } from 'remotion';
+import type { RenderAssetInfo } from 'remotion';
 export declare type RenderFramesOutput = {
     frameCount: number;
     assetsInfo: RenderAssetInfo;

package/dist/validate-even-dimensions-with-codec.d.ts

@@ -1,4 +1,4 @@
-import { Codec } from 'remotion';
+import type { Codec } from 'remotion';
 export declare const validateEvenDimensionsWithCodec: ({ width, height, codec, scale, }: {
     width: number;
     height: number;

package/dist/validate-offthreadvideo-image-format.d.ts

@@ -0,0 +1 @@
+export declare const validateOffthreadVideoImageFormat: (input: unknown) => void;

package/dist/validate-offthreadvideo-image-format.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOffthreadVideoImageFormat = void 0;
+const validateOffthreadVideoImageFormat = (input) => {
+    if (typeof input === 'undefined') {
+        return;
+    }
+    if (typeof input !== 'string') {
+        throw new TypeError(`<OffthreadVideo imageFormat=""> must be a string, but got ${JSON.stringify(input)} instead.`);
+    }
+    if (input !== 'png' && input !== 'jpeg') {
+        throw new TypeError(`<OffthreadVideo imageFormat=""> must be either "png" or "jpeg", but got ${input}`);
+    }
+};
+exports.validateOffthreadVideoImageFormat = validateOffthreadVideoImageFormat;

package/dist/validate-output-filename.d.ts

@@ -1,2 +1,2 @@
-import { Codec } from 'remotion';
+import type { Codec } from 'remotion';
 export declare const validateOutputFilename: (codec: Codec, extension: string | null) => void;