@remotion/renderer 3.0.16 → 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/assets/get-audio-channels.d.ts

@@ -1,4 +1,5 @@
-export declare function getAudioChannelsAndDuration(path: string): Promise<{
+import { FfmpegExecutable } from 'remotion';
+export declare function getAudioChannelsAndDuration(path: string, ffprobeExecutable: FfmpegExecutable): Promise<{
     channels: number;
     duration: number | null;
 }>;

package/dist/assets/get-audio-channels.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioChannelsAndDuration = void 0;
 const execa_1 = __importDefault(require("execa"));
-async function getAudioChannelsAndDuration(path) {
+async function getAudioChannelsAndDuration(path, ffprobeExecutable) {
     const args = [
         ['-v', 'error'],
         ['-show_entries', 'stream=channels:format=duration'],
@@ -14,7 +14,7 @@ async function getAudioChannelsAndDuration(path) {
     ]
         .reduce((acc, val) => acc.concat(val), [])
         .filter(Boolean);
-    const task = await (0, execa_1.default)('ffprobe', args);
+    const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', args);
     const channels = task.stdout.match(/channels=([0-9]+)/);
     const duration = task.stdout.match(/duration=([0-9.]+)/);
     return {

package/dist/calculate-ffmpeg-filters.js

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

package/dist/combine-videos.js

@@ -30,6 +30,9 @@ const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfF
             remotion_1.Internals.isAudioCodec(codec) ? null : 'copy',
             '-c:a',
             (0, get_audio_codec_name_1.getAudioCodecName)(codec),
+            // Set max bitrate up to 1024kbps, will choose lower if that's too much
+            '-b:a',
+            '512K',
             codec === 'h264' ? '-movflags' : null,
             codec === 'h264' ? 'faststart' : null,
             '-shortest',

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

@@ -2,17 +2,15 @@
 /// <reference types="node" />
 import { FfmpegExecutable } from 'remotion';
 import { Readable } from 'stream';
+import { LastFrameOptions } from './last-frame-from-video-cache';
 export declare function streamToString(stream: Readable): Promise<string>;
-export declare const getLastFrameOfVideo: ({ ffmpegExecutable, offset, src, }: {
-    ffmpegExecutable: FfmpegExecutable;
-    offset: number;
-    src: string;
-}) => Promise<Buffer>;
+export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;
 declare type Options = {
     time: number;
     src: string;
     ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
 };
-export declare const extractFrameFromVideoFn: ({ time, src, ffmpegExecutable, }: Options) => Promise<Buffer>;
+export declare const extractFrameFromVideoFn: ({ time, src, ffmpegExecutable, ffprobeExecutable, }: Options) => Promise<Buffer>;
 export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
 export {};

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

@@ -5,7 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractFrameFromVideo = exports.extractFrameFromVideoFn = exports.getLastFrameOfVideo = exports.streamToString = void 0;
 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");
 function streamToString(stream) {
     const chunks = [];
@@ -16,15 +20,71 @@ function streamToString(stream) {
     });
 }
 exports.streamToString = streamToString;
-const getLastFrameOfVideo = async ({ ffmpegExecutable, 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.');
+const lastFrameLimit = (0, p_limit_1.pLimit)(1);
+const mainLimit = (0, p_limit_1.pLimit)(5);
+// Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
+// if the video is corrupted
+const getLastFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, }) => {
+    console.warn(`\nUsing a slow method to determine the last frame of ${src}. The render can be sped up by re-encoding the video properly.`);
+    const actualOffset = `-${duration * 1000}ms`;
+    const command = [
+        '-itsoffset',
+        actualOffset,
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-f',
+        'image2pipe',
+        '-',
+    ];
+    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', command);
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => stdoutChunks.push(d));
+        stdout.on('error', (err) => reject(err));
+        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
+    });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        throw new Error(`Could not get last frame of ${src}. Tried to seek to the end using the command "ffmpeg ${command.join(' ')}" but got no frame. Most likely this video is corrupted.`);
+    }
+    return stdoutBuffer;
+};
+const getLastFrameOfVideoFastUnlimited = async (options) => {
+    const { ffmpegExecutable, ffprobeExecutable, offset, src } = options;
+    const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)({ ...options, offset: 0 });
+    if (fromCache) {
+        return fromCache;
+    }
+    const duration = await (0, get_duration_of_asset_1.getDurationOfAsset)({
+        src,
+        ffprobeExecutable,
+    });
+    if (offset > 40) {
+        const last = await getLastFrameOfVideoSlow({
+            duration,
+            ffmpegExecutable,
+            src,
+        });
+        return last;
     }
-    const actualOffset = `-${offset + 10}ms`;
+    const actualOffset = `${duration * 1000 - offset - 10}ms`;
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
-        '-sseof',
+        '-ss',
         actualOffset,
         '-i',
         src,
@@ -61,13 +121,32 @@ const getLastFrameOfVideo = async ({ ffmpegExecutable, offset, src, }) => {
     const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
     const isEmpty = stdErr.includes('Output file is empty');
     if (isEmpty) {
-        return (0, exports.getLastFrameOfVideo)({ ffmpegExecutable, offset: offset + 10, src });
+        const unlimited = await getLastFrameOfVideoFastUnlimited({
+            ffmpegExecutable,
+            offset: offset + 10,
+            src,
+            ffprobeExecutable,
+        });
+        return unlimited;
     }
     return stdoutBuffer;
 };
+const getLastFrameOfVideo = async (options) => {
+    const result = await lastFrameLimit(getLastFrameOfVideoFastUnlimited, options);
+    (0, last_frame_from_video_cache_1.setLastFrameInCache)(options, result);
+    return result;
+};
 exports.getLastFrameOfVideo = getLastFrameOfVideo;
-const limit = (0, p_limit_1.pLimit)(5);
-const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, }) => {
+const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExecutable, }) => {
+    if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(src, time)) {
+        const lastFrame = await (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
+            offset: 0,
+            src,
+        });
+        return lastFrame;
+    }
     const ffmpegTimestamp = (0, frame_to_ffmpeg_timestamp_1.frameToFfmpegTimestamp)(time);
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
         '-ss',
@@ -91,42 +170,36 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, }) => {
     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,
         stdoutBuffer,
     ]);
     if (stderrStr.includes('Output file is empty')) {
-        return (0, exports.getLastFrameOfVideo)({
+        (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(src, time);
+        const last = await (0, exports.getLastFrameOfVideo)({
             ffmpegExecutable,
+            ffprobeExecutable,
             offset: 0,
             src,
         });
+        return last;
     }
     return stdOut;
 };
 exports.extractFrameFromVideoFn = extractFrameFromVideoFn;
-const extractFrameFromVideo = (options) => {
-    return limit(exports.extractFrameFromVideoFn, options);
+const extractFrameFromVideo = async (options) => {
+    const perf = remotion_1.Internals.perf.startPerfMeasure('extract-frame');
+    const res = await mainLimit(exports.extractFrameFromVideoFn, options);
+    remotion_1.Internals.perf.stopPerfMeasure(perf);
+    return res;
 };
 exports.extractFrameFromVideo = extractFrameFromVideo;

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;