@remotion/renderer 3.0.21 → 3.0.24

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

@@ -3,33 +3,53 @@ 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;
+exports.extractFrameFromVideo = exports.getLastFrameOfVideo = exports.determineResizeParams = 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 get_video_info_1 = require("./get-video-info");
 const is_beyond_last_frame_1 = require("./is-beyond-last-frame");
 const last_frame_from_video_cache_1 = require("./last-frame-from-video-cache");
 const p_limit_1 = require("./p-limit");
 const lastFrameLimit = (0, p_limit_1.pLimit)(1);
 const mainLimit = (0, p_limit_1.pLimit)(5);
+const determineVcodecFfmepgFlags = (vcodecFlag) => {
+    return [
+        vcodecFlag === 'vp9' ? '-vcodec' : null,
+        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
+        vcodecFlag === 'vp8' ? '-vcodec' : null,
+        vcodecFlag === 'vp8' ? 'libvpx' : null,
+    ].filter(remotion_1.Internals.truthy);
+};
+const determineResizeParams = (needsResize) => {
+    if (needsResize === null) {
+        return [];
+    }
+    return ['-s', `${needsResize[0]}x${needsResize[1]}`];
+};
+exports.determineResizeParams = determineResizeParams;
 // 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 getFrameOfVideoSlow = async ({ src, timestamp, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, }) => {
+    console.warn(`\nUsing a slow method to extract the frame at ${timestamp}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
+    const actualOffset = `-${timestamp * 1000}ms`;
     const command = [
         '-itsoffset',
         actualOffset,
+        ...determineVcodecFfmepgFlags(specialVCodecForTransparency),
         '-i',
         src,
         '-frames:v',
         '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
         '-f',
         'image2pipe',
+        ...(0, exports.determineResizeParams)(needsResize),
         '-',
-    ];
+    ].filter(remotion_1.Internals.truthy);
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', command);
     if (!stderr) {
         throw new Error('unexpectedly did not get stderr');
@@ -66,11 +86,14 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
     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,
+    if (options.specialVCodecForTransparency === 'vp8' || offset > 40) {
+        const last = await getFrameOfVideoSlow({
+            timestamp: duration,
             ffmpegExecutable,
             src,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
+            needsResize: options.needsResize,
         });
         return last;
     }
@@ -78,14 +101,18 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
         '-ss',
         actualOffset,
+        ...determineVcodecFfmepgFlags(options.specialVCodecForTransparency),
         '-i',
         src,
         '-frames:v',
         '1',
+        '-c:v',
+        options.imageFormat === 'jpeg' ? 'mjpeg' : 'png',
         '-f',
         'image2pipe',
+        ...(0, exports.determineResizeParams)(options.needsResize),
         '-',
-    ]);
+    ].filter(remotion_1.Internals.truthy));
     if (!stderr) {
         throw new Error('unexpectedly did not get stderr');
     }
@@ -118,6 +145,9 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
             offset: offset + 10,
             src,
             ffprobeExecutable,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
+            needsResize: options.needsResize,
         });
         return unlimited;
     }
@@ -129,14 +159,28 @@ const getLastFrameOfVideo = async (options) => {
     return result;
 };
 exports.getLastFrameOfVideo = getLastFrameOfVideo;
-const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExecutable, }) => {
+const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExecutable, imageFormat, }) => {
     await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)(src);
+    const { specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(src, ffprobeExecutable);
+    if (specialVcodec === 'vp8') {
+        return getFrameOfVideoSlow({
+            ffmpegExecutable,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            src,
+            timestamp: time,
+            needsResize,
+        });
+    }
     if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(src, time)) {
         const lastFrame = await (0, exports.getLastFrameOfVideo)({
             ffmpegExecutable,
             ffprobeExecutable,
             offset: 0,
             src,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            needsResize,
         });
         return lastFrame;
     }
@@ -144,14 +188,18 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExe
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
         '-ss',
         ffmpegTimestamp,
+        ...determineVcodecFfmepgFlags(specialVcodec),
         '-i',
         src,
         '-frames:v',
         '1',
         '-f',
         'image2pipe',
+        '-vcodec',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        ...(0, exports.determineResizeParams)(needsResize),
         '-',
-    ], {
+    ].filter(remotion_1.Internals.truthy), {
         buffer: false,
     });
     if (!stderr) {
@@ -183,6 +231,9 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExe
             ffprobeExecutable,
             offset: 0,
             src,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            needsResize,
         });
         return last;
     }

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-audio-codec-name.d.ts

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

package/dist/get-browser-instance.d.ts

@@ -1,6 +1,7 @@
-import { Browser, Page } from 'puppeteer-core';
-import { BrowserExecutable } from 'remotion';
-import { ChromiumOptions } from './open-browser';
+import type { BrowserExecutable } from 'remotion';
+import type { Browser } from './browser/Browser';
+import type { Page } from './browser/Page';
+import type { ChromiumOptions } from './open-browser';
 export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, }: {
     passedInInstance: Browser | undefined;
     browserExecutable: BrowserExecutable | null;

package/dist/get-codec-name.d.ts

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

package/dist/get-compositions.d.ts

@@ -1,7 +1,7 @@
-import { Browser } from 'puppeteer-core';
-import { BrowserExecutable, FfmpegExecutable, TCompMetadata } from 'remotion';
-import { BrowserLog } from './browser-log';
-import { ChromiumOptions } from './open-browser';
+import type { BrowserExecutable, FfmpegExecutable, TCompMetadata } from 'remotion';
+import type { BrowserLog } from './browser-log';
+import type { Browser } from './browser/Browser';
+import type { ChromiumOptions } from './open-browser';
 declare type GetCompositionsConfig = {
     inputProps?: object | null;
     envVariables?: Record<string, string>;

package/dist/get-compositions.js

@@ -14,8 +14,8 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
             var _a;
             (_a = config.onBrowserLog) === null || _a === void 0 ? void 0 : _a.call(config, {
                 stackTrace: log.stackTrace(),
-                text: log.text(),
-                type: log.type(),
+                text: log.text,
+                type: log.type,
             });
         });
     }

package/dist/get-duration-from-frame-range.d.ts

@@ -1,2 +1,2 @@
-import { FrameRange } from 'remotion';
+import type { FrameRange } from 'remotion';
 export declare const getDurationFromFrameRange: (frameRange: FrameRange | null, durationInFrames: number) => number;