@remotion/renderer 3.0.30 → 3.0.31

package/dist/faststart/options.d.ts

@@ -0,0 +1,6 @@
+export interface FaststartOptions {
+    /**
+     * Forces all `stco` atoms to be upgraded to `co64` atoms
+     */
+    forceUpgradeToCo64?: boolean;
+}

package/dist/faststart/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/faststart/qt-faststart.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { QtAtom } from './atom';
+import { FaststartOptions } from './options';
+export declare function supportStreaming(infile: Buffer): boolean;
+/**
+ * Enables "faststart" for QuickTime files so that they can be streamed.
+ *
+ * @param infile QT/mp4 to faststart
+ * @returns Faststarted QT/mp4
+ */
+export default function faststart(infile: Buffer, options?: FaststartOptions): Buffer;
+/**
+ * Sorts an array of QT atoms so that the first two atoms are `ftyp`, then `moov`.
+ * Additionally updates all chunk offsets (`stco`/`co64` atoms) in `moov`.
+ *
+ * @param atoms QT atoms to sort
+ */
+export declare function sortFaststartAtoms(atoms: QtAtom[], options: FaststartOptions): QtAtom[];

package/dist/faststart/qt-faststart.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortFaststartAtoms = exports.supportStreaming = void 0;
+const atom_1 = require("./atom");
+const update_chunk_offsets_1 = __importDefault(require("./update-chunk-offsets"));
+function supportStreaming(infile) {
+    const file = Buffer.from(infile);
+    const atoms = (0, atom_1.parseAtoms)(file, 0, true);
+    const mdatIndex = atoms.findIndex((atom) => atom.kind === 'mdat');
+    const moovIndex = atoms.findIndex((atom) => atom.kind === 'moov');
+    if (moovIndex === -1 || mdatIndex === -1) {
+        return false;
+    }
+    return moovIndex < mdatIndex;
+}
+exports.supportStreaming = supportStreaming;
+/**
+ * Enables "faststart" for QuickTime files so that they can be streamed.
+ *
+ * @param infile QT/mp4 to faststart
+ * @returns Faststarted QT/mp4
+ */
+function faststart(infile, options = {}) {
+    const file = Buffer.from(infile);
+    const atoms = (0, atom_1.parseAtoms)(file);
+    console.log({ atoms });
+    const mdatIndex = atoms.findIndex((atom) => atom.kind === 'mdat');
+    if (mdatIndex === -1) {
+        throw new Error(`No mdat atom found!`);
+    }
+    const moovIndex = atoms.findIndex((atom) => atom.kind === 'moov');
+    if (moovIndex === -1) {
+        throw new Error(`No moov atom found!`);
+    }
+    const faststarted = sortFaststartAtoms(atoms, options);
+    return (0, atom_1.recurseFlattenAtoms)(faststarted);
+}
+exports.default = faststart;
+/**
+ * Sorts an array of QT atoms so that the first two atoms are `ftyp`, then `moov`.
+ * Additionally updates all chunk offsets (`stco`/`co64` atoms) in `moov`.
+ *
+ * @param atoms QT atoms to sort
+ */
+function sortFaststartAtoms(atoms, options) {
+    const faststarted = [];
+    const ftyp = atoms.find((atom) => atom.kind === 'ftyp');
+    if (!ftyp) {
+        throw new Error('Missing ftyp atom!');
+    }
+    if (ftyp.size > atom_1.MAX_FTYP_ATOM_SIZE) {
+        throw new Error(`ftyp atom is greater than ${atom_1.MAX_FTYP_ATOM_SIZE}`);
+    }
+    console.log('before', { atoms });
+    const moov = atoms.find((atom) => atom.kind === 'moov');
+    (0, update_chunk_offsets_1.default)(moov, options);
+    faststarted.push(ftyp, moov);
+    const rest = atoms.filter((atom) => !['ftyp', 'moov'].includes(atom.kind));
+    faststarted.push(...rest);
+    console.log('after', { faststarted });
+    return faststarted;
+}
+exports.sortFaststartAtoms = sortFaststartAtoms;

package/dist/faststart/update-chunk-offsets.d.ts

@@ -0,0 +1,10 @@
+import { QtAtom } from './atom';
+import { FaststartOptions } from './options';
+/**
+ * Adds the specified offset to each entry in stco/co64 atoms
+ *
+ * @param atoms QT atoms to traverse
+ * @param offset offset to add
+ * @param forceUpgrade always upgrade stco atoms to co64
+ */
+export default function updateChunkOffsets(moov: QtAtom, options: FaststartOptions): void;

package/dist/faststart/update-chunk-offsets.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-bitwise */
+const atom_1 = require("./atom");
+/**
+ * Adds the specified offset to each entry in stco/co64 atoms
+ *
+ * @param atoms QT atoms to traverse
+ * @param offset offset to add
+ * @param forceUpgrade always upgrade stco atoms to co64
+ */
+function updateChunkOffsets(moov, options) {
+    const atoms = moov.data;
+    const originalMoovSize = Number(moov.size);
+    let newChunksSize = 0;
+    let originalChunksSize = 0;
+    // First pass to count total entries, which is needed for co64 upgrades.
+    (0, atom_1.traverseAtoms)(atoms, (atom) => {
+        if (!['stco', 'co64'].includes(atom.kind) || !Buffer.isBuffer(atom.data)) {
+            return;
+        }
+        const entries = atom.data.readUInt32BE(4);
+        const originalEntrySize = isCo64(atom.kind) ? 8 : 4;
+        originalChunksSize += entries * originalEntrySize;
+        const newEntrySize = isCo64(atom.kind) || options.forceUpgradeToCo64 ? 8 : 4;
+        newChunksSize += entries * newEntrySize;
+    });
+    // Calculate new mdat offsets to add to stco/co64 chunk offset values
+    const totalOffset = originalMoovSize - originalChunksSize + newChunksSize;
+    // Second pass to actually update offsets.
+    (0, atom_1.traverseAtoms)(atoms, (atom) => {
+        if (!['stco', 'co64'].includes(atom.kind) || !Buffer.isBuffer(atom.data)) {
+            return;
+        }
+        const overflow = updateChunkAtom(atom, totalOffset, options);
+        if (!overflow) {
+            return;
+        }
+        upgradeStcoToCo64(atom, totalOffset);
+    });
+}
+exports.default = updateChunkOffsets;
+/**
+ * Updates `stco` or `co64` atoms' chunk offsets.
+ *
+ * @param atom `stco` or `co64` to update chunk offsets of
+ * @param totalOffset the total offset value to add to the existing chunk offsets
+ * @param options
+ * @returns {boolean} `true` if overflowed (did not finish updating chunks), `false` if succeeded
+ */
+function updateChunkAtom(atom, totalOffset, options) {
+    if (!Buffer.isBuffer(atom.data)) {
+        throw new Error(`${atom.kind} data is not a Buffer!`);
+    }
+    let overflow = false;
+    const entrySize = isCo64(atom.kind) ? 8 : 4;
+    const entries = atom.data.readUInt32BE(4);
+    const newData = Buffer.alloc(8 + entries * entrySize); // 8 byte header
+    atom.data.copy(newData, 0, 0, 8); // copy header
+    for (let i = 0; i < entries; i++) {
+        const cur = 8 + i * entrySize; // 8 byte header
+        if (isCo64(atom.kind)) {
+            const newVal64 = Number((BigInt(atom.data.readUInt32BE(cur)) << BigInt(32)) |
+                BigInt(atom.data.readUInt32BE(cur + 4))) + totalOffset;
+            newData.writeUInt32BE(Number((BigInt(newVal64) >> BigInt(32)) & BigInt(0xffffffff)), cur);
+            newData.writeUInt32BE(Number(BigInt(newVal64) & BigInt(0xffffffff)), cur + 4);
+            continue;
+        }
+        if (options.forceUpgradeToCo64) {
+            overflow = true;
+            break;
+        }
+        const newVal32 = atom.data.readUInt32BE(cur) + totalOffset;
+        if (newVal32 > 2 ** 32 - 1) {
+            overflow = true;
+            break;
+        }
+        newData.writeUInt32BE(newVal32, cur);
+    }
+    if (!overflow) {
+        atom.data = newData;
+    }
+    return overflow;
+}
+/**
+ * **Upgrades** `stco` atom to a `co64` atom and also updates the chunk offsets.
+ *
+ * @param atom `stco` or `co64` to update chunk offsets of
+ * @param totalOffset the total offset value to add to the existing chunk offsets
+ */
+function upgradeStcoToCo64(atom, totalOffset) {
+    if (!Buffer.isBuffer(atom.data)) {
+        throw new Error(`${atom.kind} data is not a Buffer!`);
+    }
+    // Upgrade to stco atoms to co64 atoms
+    const entries = atom.data.readUInt32BE(4);
+    const upgradedData = Buffer.alloc(8 + entries * 8); // 8-byte header, 8-byte entry size
+    atom.data.copy(upgradedData, 0, 0, 8);
+    upgradedData.writeUInt32BE((entries >> 32) & 0xffffffff, 8); // MSB 64-bit size
+    upgradedData.writeUInt32BE(entries & 0xffffffff, 12); // LSB 64-bit size
+    for (let i = 0; i < entries; i++) {
+        const cur32 = 8 + i * 4; // 8-byte header, 4-byte entry size for READS (stco)
+        const newVal = atom.data.readUInt32BE(cur32) + totalOffset;
+        const cur64 = 8 + i * 8; // 8-byte header, 8-byte entry size for WRITES (co64)
+        upgradedData.writeUInt32BE(Number((BigInt(newVal) >> BigInt(32)) & BigInt(0xffffffff)), cur64);
+        upgradedData.writeUInt32BE(Number(BigInt(newVal) & BigInt(0xffffffff)), cur64 + 4);
+    }
+    atom.kind = 'co64';
+    atom.data = upgradedData;
+    atom.size = atom_1.ATOM_PREAMBLE_SIZE * BigInt(2) + BigInt(upgradedData.byteLength);
+}
+function isCo64(atomKind) {
+    return atomKind === 'co64';
+}

package/dist/faststart/util.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export interface Cursor {
+    pos: bigint;
+}
+export declare function numToHex(val: number): string;
+export declare function asciiToU32Be(chars: string): number;
+export declare function u32BeToAscii(u32: number): string;
+export declare function readU32(cur: Cursor, buf: Buffer): number;
+export declare function readU64(cur: Cursor, buf: Buffer): bigint;

package/dist/faststart/util.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readU64 = exports.readU32 = exports.u32BeToAscii = exports.asciiToU32Be = exports.numToHex = void 0;
+function numToHex(val) {
+    return val.toString(16);
+}
+exports.numToHex = numToHex;
+function asciiToU32Be(chars) {
+    return Buffer.from(chars.split('').map((char) => char.charCodeAt(0))).readUInt32BE(0);
+}
+exports.asciiToU32Be = asciiToU32Be;
+function u32BeToAscii(u32) {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(u32, 0);
+    return buf.toString('ascii');
+}
+exports.u32BeToAscii = u32BeToAscii;
+function readU32(cur, buf) {
+    const u32 = buf.readUInt32BE(Number(cur.pos));
+    cur.pos += BigInt(4);
+    return u32;
+}
+exports.readU32 = readU32;
+function readU64(cur, buf) {
+    const long = buf.slice(Number(cur.pos), Number(cur.pos + BigInt(8)));
+    const u64 = 
+    // eslint-disable-next-line no-bitwise
+    (BigInt(long.readUInt32BE(0)) << BigInt(32)) |
+        // eslint-disable-next-line no-bitwise
+        (BigInt(long.readUInt32BE(4)) & BigInt(0xffffffff));
+    cur.pos += BigInt(8);
+    return u64;
+}
+exports.readU64 = readU64;

package/dist/guess-extension-for-media.d.ts

@@ -1 +1 @@
-export declare const guessExtensionForVideo: (src: string) => Promise<"mp3" | "webm" | "wav" | "mp4">;
+export declare const guessExtensionForVideo: (src: string) => Promise<"mp3" | "wav" | "webm" | "mp4">;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import execa from 'execa';
 import { SymbolicateableError } from './error-handling/symbolicateable-error';
 import { mimeContentType, mimeLookup } from './mime-types';
@@ -54,7 +55,7 @@ export declare const RenderInternals: {
         task: Promise<Buffer | null>;
         getLogs: () => string;
     }>;
-    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "mp4" | "mkv" | "mov" | "webm";
+    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "webm" | "mp4" | "mov" | "mkv";
     tmpDir: (str: string) => string;
     deleteDirectory: (directory: string) => Promise<void>;
     isServeUrl: (potentialUrl: string) => boolean;

package/dist/offthread/index.js

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

package/dist/render-gif.d.ts

@@ -0,0 +1,2 @@
+import { RenderMediaOptions } from './render-media';
+export declare 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 }: RenderMediaOptions) => Promise<void>;

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,3 +1,4 @@
+/// <reference types="node" />
 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';

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