@remotion/renderer 3.0.18 → 3.0.19

package/dist/assets/cleanup-assets.d.ts

@@ -0,0 +1,2 @@
+export declare type RenderCleanupFn = () => Promise<void>;
+export declare type AddRenderCleanupFunction = (cleanup: RenderCleanupFn) => void;

package/dist/assets/cleanup-assets.js

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

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/create-ffmpeg-complex-filter.d.ts

@@ -1,7 +1,4 @@
 export declare const createFfmpegComplexFilter: (filters: number) => Promise<{
-    complexFilterFlag: [
-        string,
-        string
-    ] | null;
+    complexFilterFlag: [string, string] | null;
     cleanup: () => void;
 }>;

package/dist/ensure-faststart.d.ts

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

package/dist/ensure-faststart.js

@@ -0,0 +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.ensureFastStart = void 0;
+const fs_1 = require("fs");
+const qt_faststart_1 = __importDefault(require("./faststart/qt-faststart"));
+const ensureFastStart = () => {
+    const buffer = (0, fs_1.readFileSync)('/Users/jonathanburger/remotion/packages/example/public/offthread2.mp4');
+    const newBuffer = (0, qt_faststart_1.default)(buffer);
+    (0, fs_1.writeFileSync)('/Users/jonathanburger/remotion/packages/example/public/offthread-faststart.mp4', newBuffer);
+};
+exports.ensureFastStart = ensureFastStart;

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { FfmpegExecutable } from 'remotion';
 import { Readable } from 'stream';
 import { LastFrameOptions } from './last-frame-from-video-cache';

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

@@ -7,6 +7,7 @@ exports.extractFrameFromVideo = exports.extractFrameFromVideoFn = exports.getLas
 const execa_1 = __importDefault(require("execa"));
 const remotion_1 = require("remotion");
 const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
+const get_duration_of_asset_1 = require("./get-duration-of-asset");
 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");
@@ -19,28 +20,67 @@ function streamToString(stream) {
     });
 }
 exports.streamToString = streamToString;
-const lastFrameLimit = (0, p_limit_1.pLimit)(5);
+const lastFrameLimit = (0, p_limit_1.pLimit)(1);
 const mainLimit = (0, p_limit_1.pLimit)(5);
-const getLastFrameOfVideoUnlimited = async ({ ffmpegExecutable, ffprobeExecutable, offset, src, }) => {
-    if (offset > 100) {
-        throw new Error('could not get last frame of ' +
-            src +
-            '. Tried to seek 100ms before the end of the video and no frame was found. The video container has a duration that is longer than it contains video.');
+// 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 durationCmd = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', [
-        '-v',
-        'error',
-        '-select_streams',
-        'v:0',
-        '-show_entries',
-        'stream=duration',
-        '-of',
-        'default=noprint_wrappers=1:nokey=1',
+    const duration = await (0, get_duration_of_asset_1.getDurationOfAsset)({
         src,
-    ]);
-    const duration = parseFloat(durationCmd.stdout);
-    if (Number.isNaN(duration)) {
-        throw new TypeError(`Could not get duration of ${src}: ${durationCmd.stdout}`);
+        ffprobeExecutable,
+    });
+    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', [
@@ -81,33 +121,31 @@ const getLastFrameOfVideoUnlimited = async ({ ffmpegExecutable, ffprobeExecutabl
     const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
     const isEmpty = stdErr.includes('Output file is empty');
     if (isEmpty) {
-        return getLastFrameOfVideoUnlimited({
+        const unlimited = await getLastFrameOfVideoFastUnlimited({
             ffmpegExecutable,
             offset: offset + 10,
             src,
             ffprobeExecutable,
         });
+        return unlimited;
     }
     return stdoutBuffer;
 };
 const getLastFrameOfVideo = async (options) => {
-    const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)(options);
-    if (fromCache) {
-        return fromCache;
-    }
-    const result = await lastFrameLimit(getLastFrameOfVideoUnlimited, 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, }) => {
     if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(src, time)) {
-        return (0, exports.getLastFrameOfVideo)({
+        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', [
@@ -132,26 +170,14 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExe
     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'));
-        });
+        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));
-        });
+        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,
@@ -159,12 +185,13 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExe
     ]);
     if (stderrStr.includes('Output file is empty')) {
         (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(src, time);
-        return (0, exports.getLastFrameOfVideo)({
+        const last = await (0, exports.getLastFrameOfVideo)({
             ffmpegExecutable,
             ffprobeExecutable,
             offset: 0,
             src,
         });
+        return last;
     }
     return stdOut;
 };

package/dist/faststart/atom.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+export declare const FREE_ATOM: number;
+export declare const JUNK_ATOM: number;
+export declare const MDAT_ATOM: number;
+export declare const MOOV_ATOM: number;
+export declare const PNOT_ATOM: number;
+export declare const SKIP_ATOM: number;
+export declare const WIDE_ATOM: number;
+export declare const PICT_ATOM: number;
+export declare const FTYP_ATOM: number;
+export declare const UUID_ATOM: number;
+export declare const CMOV_ATOM: number;
+export declare const TRAK_ATOM: number;
+export declare const MDIA_ATOM: number;
+export declare const MINF_ATOM: number;
+export declare const STBL_ATOM: number;
+export declare const STCO_ATOM: number;
+export declare const CO64_ATOM: number;
+export declare const ATOM_PREAMBLE_SIZE: bigint;
+export declare const MAX_FTYP_ATOM_SIZE: bigint;
+export declare enum SizeKind {
+    U32 = 0,
+    U64 = 1
+}
+export interface QtAtom {
+    kind: string;
+    size: BigInt;
+    sizeKind: SizeKind;
+    data: QtAtom[] | Buffer;
+}
+export declare function parseAtoms(infile: Buffer, depth?: number, shallow?: boolean): QtAtom[];
+export declare function recurseFlattenAtoms(atoms: QtAtom[], depth?: number): Buffer;
+export declare function traverseAtoms(atoms: QtAtom[], callback: (atom: QtAtom) => void): void;
+export declare function isQtAtom(atomType: number): boolean;
+export declare function hasSubatoms(atomType: number): boolean;

package/dist/faststart/atom.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasSubatoms = exports.isQtAtom = exports.traverseAtoms = exports.recurseFlattenAtoms = exports.parseAtoms = exports.SizeKind = exports.MAX_FTYP_ATOM_SIZE = exports.ATOM_PREAMBLE_SIZE = exports.CO64_ATOM = exports.STCO_ATOM = exports.STBL_ATOM = exports.MINF_ATOM = exports.MDIA_ATOM = exports.TRAK_ATOM = exports.CMOV_ATOM = exports.UUID_ATOM = exports.FTYP_ATOM = exports.PICT_ATOM = exports.WIDE_ATOM = exports.SKIP_ATOM = exports.PNOT_ATOM = exports.MOOV_ATOM = exports.MDAT_ATOM = exports.JUNK_ATOM = exports.FREE_ATOM = void 0;
+/* eslint-disable no-bitwise */
+const util_1 = require("./util");
+exports.FREE_ATOM = (0, util_1.asciiToU32Be)('free');
+exports.JUNK_ATOM = (0, util_1.asciiToU32Be)('junk');
+exports.MDAT_ATOM = (0, util_1.asciiToU32Be)('mdat');
+exports.MOOV_ATOM = (0, util_1.asciiToU32Be)('moov');
+exports.PNOT_ATOM = (0, util_1.asciiToU32Be)('pnot');
+exports.SKIP_ATOM = (0, util_1.asciiToU32Be)('skip');
+exports.WIDE_ATOM = (0, util_1.asciiToU32Be)('wide');
+exports.PICT_ATOM = (0, util_1.asciiToU32Be)('PICT');
+exports.FTYP_ATOM = (0, util_1.asciiToU32Be)('ftyp');
+exports.UUID_ATOM = (0, util_1.asciiToU32Be)('uuid');
+exports.CMOV_ATOM = (0, util_1.asciiToU32Be)('cmov');
+exports.TRAK_ATOM = (0, util_1.asciiToU32Be)('trak');
+exports.MDIA_ATOM = (0, util_1.asciiToU32Be)('mdia');
+exports.MINF_ATOM = (0, util_1.asciiToU32Be)('minf');
+exports.STBL_ATOM = (0, util_1.asciiToU32Be)('stbl');
+exports.STCO_ATOM = (0, util_1.asciiToU32Be)('stco');
+exports.CO64_ATOM = (0, util_1.asciiToU32Be)('co64');
+exports.ATOM_PREAMBLE_SIZE = BigInt(8);
+exports.MAX_FTYP_ATOM_SIZE = BigInt(1048576);
+var SizeKind;
+(function (SizeKind) {
+    SizeKind[SizeKind["U32"] = 0] = "U32";
+    SizeKind[SizeKind["U64"] = 1] = "U64";
+})(SizeKind = exports.SizeKind || (exports.SizeKind = {}));
+function parseAtoms(infile, depth = 0, shallow = false) {
+    const atoms = [];
+    const cur = {
+        pos: BigInt(0),
+    };
+    const len = BigInt(infile.byteLength);
+    while (cur.pos < len) {
+        if (len - cur.pos < 8) {
+            break;
+        }
+        let fwd; // forward-seek counter
+        let atomSize = BigInt((0, util_1.readU32)(cur, infile));
+        const atomType = (0, util_1.readU32)(cur, infile);
+        let sizeKind = SizeKind.U32;
+        if (atomSize === BigInt(1)) {
+            // 64-bit atom size
+            atomSize = (0, util_1.readU64)(cur, infile);
+            if (atomSize > BigInt(Number.MAX_SAFE_INTEGER)) {
+                throw new Error(`"${atomType}" atom size is larger than MAX_SAFE_INTEGER!`);
+            }
+            fwd = atomSize - exports.ATOM_PREAMBLE_SIZE * BigInt(2);
+            sizeKind = SizeKind.U64;
+        }
+        else {
+            fwd = atomSize - exports.ATOM_PREAMBLE_SIZE;
+        }
+        const endOfAtom = cur.pos + fwd;
+        const subatoms = Buffer.from(infile.slice(Number(cur.pos), Number(endOfAtom)));
+        const data = hasSubatoms(atomType) && depth < 10 && !shallow
+            ? parseAtoms(subatoms, depth + 1)
+            : subatoms;
+        cur.pos = endOfAtom;
+        if (depth === 0 && !isQtAtom(atomType)) {
+            throw new Error(`Non-QT top-level atom found: ${(0, util_1.u32BeToAscii)(atomType)}`);
+        }
+        atoms.push({
+            kind: (0, util_1.u32BeToAscii)(atomType),
+            size: atomSize,
+            sizeKind,
+            data,
+        });
+    }
+    return atoms;
+}
+exports.parseAtoms = parseAtoms;
+function recurseFlattenAtoms(atoms, depth = 0) {
+    const buffers = [];
+    for (const atom of atoms) {
+        if (!Buffer.isBuffer(atom.data)) {
+            atom.data = recurseFlattenAtoms(atom.data, depth + 1);
+        }
+        let header;
+        const u64Size = Number(exports.ATOM_PREAMBLE_SIZE) + atom.data.byteLength > 2 ** 32 - 1;
+        if (u64Size) {
+            const u64Preamble = Number(exports.ATOM_PREAMBLE_SIZE) * 2;
+            header = Buffer.alloc(u64Preamble);
+            header.writeUInt32BE(1, 0);
+            header.writeUInt32BE((0, util_1.asciiToU32Be)(atom.kind), 4);
+            const newSize = u64Preamble + atom.data.byteLength;
+            header.writeUInt32BE((newSize >> 32) & 0xffffffff, 8);
+            header.writeUInt32BE(newSize & 0xffffffff, 12);
+        }
+        else {
+            header = Buffer.alloc(Number(exports.ATOM_PREAMBLE_SIZE));
+            const newSize = Number(exports.ATOM_PREAMBLE_SIZE) + atom.data.byteLength;
+            header.writeUInt32BE(newSize, 0);
+            header.writeUInt32BE((0, util_1.asciiToU32Be)(atom.kind), 4);
+        }
+        const buf = Buffer.concat([header, atom.data]);
+        buffers.push(buf);
+    }
+    return Buffer.concat(buffers);
+}
+exports.recurseFlattenAtoms = recurseFlattenAtoms;
+function traverseAtoms(atoms, callback) {
+    for (const atom of atoms) {
+        if (!Buffer.isBuffer(atom.data)) {
+            traverseAtoms(atom.data, callback);
+        }
+        callback(atom);
+    }
+}
+exports.traverseAtoms = traverseAtoms;
+function isQtAtom(atomType) {
+    return [
+        exports.FREE_ATOM,
+        exports.JUNK_ATOM,
+        exports.MDAT_ATOM,
+        exports.MOOV_ATOM,
+        exports.PNOT_ATOM,
+        exports.SKIP_ATOM,
+        exports.WIDE_ATOM,
+        exports.PICT_ATOM,
+        exports.FTYP_ATOM,
+        exports.UUID_ATOM,
+        exports.CMOV_ATOM,
+        exports.TRAK_ATOM,
+        exports.MDIA_ATOM,
+        exports.MINF_ATOM,
+        exports.STBL_ATOM,
+        exports.STCO_ATOM,
+        exports.CO64_ATOM,
+    ].includes(atomType);
+}
+exports.isQtAtom = isQtAtom;
+function hasSubatoms(atomType) {
+    return [exports.MOOV_ATOM, exports.TRAK_ATOM, exports.MDIA_ATOM, exports.MINF_ATOM, exports.STBL_ATOM].includes(atomType);
+}
+exports.hasSubatoms = hasSubatoms;

package/dist/faststart/index.js

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

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/get-duration-of-asset.d.ts

@@ -0,0 +1,7 @@
+import { FfmpegExecutable } from 'remotion';
+declare type Options = {
+    ffprobeExecutable: FfmpegExecutable;
+    src: string;
+};
+export declare const getDurationOfAsset: (options: Options) => Promise<number>;
+export {};

package/dist/get-duration-of-asset.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDurationOfAsset = void 0;
+const execa_1 = __importDefault(require("execa"));
+const p_limit_1 = require("./p-limit");
+const durationOfAssetCache = {};
+const limit = (0, p_limit_1.pLimit)(1);
+const getDurationOfAssetUnlimited = async ({ ffprobeExecutable, src, }) => {
+    if (durationOfAssetCache[src]) {
+        return durationOfAssetCache[src];
+    }
+    const durationCmd = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', [
+        '-v',
+        'error',
+        '-select_streams',
+        'v:0',
+        '-show_entries',
+        'stream=duration',
+        '-of',
+        'default=noprint_wrappers=1:nokey=1',
+        src,
+    ]);
+    const duration = parseFloat(durationCmd.stdout);
+    if (Number.isNaN(duration)) {
+        throw new TypeError(`Could not get duration of ${src}: ${durationCmd.stdout}`);
+    }
+    durationOfAssetCache[src] = duration;
+    return duration;
+};
+const getDurationOfAsset = (options) => {
+    return limit(getDurationOfAssetUnlimited, options);
+};
+exports.getDurationOfAsset = getDurationOfAsset;

package/dist/last-frame-from-video-cache.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { FfmpegExecutable } from 'remotion';
 export declare type LastFrameOptions = {
     ffmpegExecutable: FfmpegExecutable;

package/dist/make-assets-download-dir.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeAssetsDownloadTmpDir = void 0;
 const tmp_dir_1 = require("./tmp-dir");
+let dir = null;
 const makeAssetsDownloadTmpDir = () => {
-    return (0, tmp_dir_1.tmpDir)('remotion-assets-dir');
+    if (dir) {
+        return dir;
+    }
+    dir = (0, tmp_dir_1.tmpDir)('remotion-assets-dir');
+    return dir;
 };
 exports.makeAssetsDownloadTmpDir = makeAssetsDownloadTmpDir;

package/dist/offthread-video-server.js

@@ -59,6 +59,7 @@ const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, downlo
             .catch((err) => {
             res.writeHead(500);
             res.end();
+            onError(err);
             console.log('Error occurred', err);
         });
     };

package/dist/provide-screenshot.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import puppeteer from 'puppeteer-core';
 import { ImageFormat } from 'remotion';
 export declare const provideScreenshot: ({ page, imageFormat, options, quality, }: {

package/dist/puppeteer-screenshot.d.ts

@@ -1,2 +1,3 @@
+/// <reference types="node" />
 import { Page, ScreenshotOptions } from 'puppeteer-core';
 export declare const screenshot: (page: Page, options?: ScreenshotOptions) => Promise<Buffer | string | void>;

package/dist/render-media.d.ts

@@ -43,4 +43,9 @@ export declare type RenderMediaOptions = {
     cancelSignal?: CancelSignal;
     browserExecutable?: BrowserExecutable;
 } & ServeUrlOrWebpackBundle;
+/**
+ *
+ * @description Render a video from a composition
+ * @link https://www.remotion.dev/docs/renderer/render-media
+ */
 export declare const renderMedia: ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }: RenderMediaOptions) => Promise<void>;

package/dist/render-media.js

@@ -24,6 +24,11 @@ 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");
+/**
+ *
+ * @description Render a video from a composition
+ * @link https://www.remotion.dev/docs/renderer/render-media
+ */
 const renderMedia = ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }) => {
     remotion_1.Internals.validateQuality(quality);
     if (typeof crf !== 'undefined' && crf !== null) {

package/dist/render-still.d.ts

@@ -28,7 +28,9 @@ declare type RenderStillOptions = InnerStillOptions & ServeUrlOrWebpackBundle &
     port?: number | null;
 };
 /**
- * @description Render a still frame from a composition and returns an image path
+ *
+ * @description Render a still frame from a composition
+ * @link https://www.remotion.dev/docs/renderer/render-still
  */
 export declare const renderStill: (options: RenderStillOptions) => Promise<void>;
 export {};

package/dist/render-still.js

@@ -138,7 +138,9 @@ const innerRenderStill = async ({ composition, quality, imageFormat = 'png', ser
     await cleanup();
 };
 /**
- * @description Render a still frame from a composition and returns an image path
+ *
+ * @description Render a still frame from a composition
+ * @link https://www.remotion.dev/docs/renderer/render-still
  */
 const renderStill = (options) => {
     var _a;

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import puppeteer from 'puppeteer-core';
 import { ImageFormat } from 'remotion';
 export declare const screenshotDOMElement: ({ page, imageFormat, quality, opts, }: {

package/dist/screenshot-task.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/renderer",
-	"version": "3.0.18",
+	"version": "3.0.19",
 	"description": "Renderer for Remotion",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -23,7 +23,7 @@
 		"execa": "5.1.1",
 		"mime-types": "2.1.35",
 		"puppeteer-core": "13.5.1",
-		"remotion": "3.0.18",
+		"remotion": "3.0.19",
 		"source-map": "^0.8.0-beta.0"
 	},
 	"peerDependencies": {
@@ -59,5 +59,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "64eadd48b303d0f627ed5883f9200345af002ee2"
+	"gitHead": "388ef0a2eacf9dbadbc860fdb8d6b3e32acb10f3"
 }