@remotion/media-parser 4.0.240 → 4.0.242

package/dist/file-types/bmp.d.ts

@@ -0,0 +1,6 @@
+import type { Dimensions } from '../get-dimensions';
+export declare const isBmp: (data: Uint8Array) => BmpType | null;
+export type BmpType = {
+    type: 'bmp';
+    dimensions: Dimensions | null;
+};

package/dist/file-types/bmp.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBmp = void 0;
+const detect_file_type_1 = require("./detect-file-type");
+function getBmpDimensions(bmpData) {
+    if (bmpData.length < 26) {
+        return null;
+    }
+    const view = new DataView(bmpData.buffer, bmpData.byteOffset);
+    return {
+        width: view.getUint32(18, true),
+        height: Math.abs(view.getInt32(22, true)),
+    };
+}
+const isBmp = (data) => {
+    const bmpPattern = new Uint8Array([0x42, 0x4d]);
+    if ((0, detect_file_type_1.matchesPattern)(bmpPattern)(data.subarray(0, 2))) {
+        const bmp = getBmpDimensions(data);
+        return { dimensions: bmp, type: 'bmp' };
+    }
+    return null;
+};
+exports.isBmp = isBmp;

package/dist/file-types/detect-file-type.d.ts

@@ -0,0 +1,42 @@
+import type { BmpType } from './bmp';
+import type { JpegType } from './jpeg';
+import type { PdfType } from './pdf';
+import type { PngType } from './png';
+import type { WebpType } from './webp';
+export declare const matchesPattern: (pattern: Uint8Array) => (data: Uint8Array) => boolean;
+export declare const isRiffAvi: (data: Uint8Array) => boolean;
+export declare const isRiffWave: (data: Uint8Array) => boolean;
+export declare const isWebm: (data: Uint8Array) => boolean;
+export declare const isIsoBaseMedia: (data: Uint8Array) => boolean;
+export declare const isTransportStream: (data: Uint8Array) => boolean;
+export declare const isMp3: (data: Uint8Array) => boolean;
+export declare const isGif: (data: Uint8Array) => boolean;
+export declare const isAac: (data: Uint8Array) => boolean;
+export type RiffType = {
+    type: 'riff';
+};
+export type WebmType = {
+    type: 'webm';
+};
+export type IsoBaseMediaType = {
+    type: 'iso-base-media';
+};
+export type TransportStreamType = {
+    type: 'transport-stream';
+};
+export type Mp3Type = {
+    type: 'mp3';
+};
+export type AacType = {
+    type: 'aac';
+};
+export type WavType = {
+    type: 'wav';
+};
+export type GifType = {
+    type: 'gif';
+};
+export type UnknownType = {
+    type: 'unknown';
+};
+export type FileType = JpegType | WebpType | RiffType | WebmType | WavType | PdfType | AacType | IsoBaseMediaType | TransportStreamType | Mp3Type | GifType | PngType | BmpType | AacType | UnknownType;

package/dist/file-types/detect-file-type.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAac = exports.isGif = exports.isMp3 = exports.isTransportStream = exports.isIsoBaseMedia = exports.isWebm = exports.isRiffWave = exports.isRiffAvi = exports.matchesPattern = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const matchesPattern = (pattern) => {
+    return (data) => {
+        return pattern.every((value, index) => data[index] === value);
+    };
+};
+exports.matchesPattern = matchesPattern;
+const isRiffAvi = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+        return false;
+    }
+    const fileType = data.subarray(8, 12);
+    return new TextDecoder().decode(fileType) === 'AVI ';
+};
+exports.isRiffAvi = isRiffAvi;
+const isRiffWave = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+        return false;
+    }
+    const fileType = data.subarray(8, 12);
+    return new TextDecoder().decode(fileType) === 'WAVE';
+};
+exports.isRiffWave = isRiffWave;
+const isWebm = (data) => {
+    return (0, exports.matchesPattern)(make_header_1.webmPattern)(data.subarray(0, 4));
+};
+exports.isWebm = isWebm;
+const isIsoBaseMedia = (data) => {
+    const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
+    return (0, exports.matchesPattern)(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+exports.isIsoBaseMedia = isIsoBaseMedia;
+const isTransportStream = (data) => {
+    return data[0] === 0x47 && data[188] === 0x47;
+};
+exports.isTransportStream = isTransportStream;
+const isMp3 = (data) => {
+    const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
+    const id3Pattern = new Uint8Array([73, 68, 51, 3]);
+    const subarray = data.subarray(0, 4);
+    return ((0, exports.matchesPattern)(mpegPattern)(subarray) ||
+        (0, exports.matchesPattern)(id3Pattern)(subarray));
+};
+exports.isMp3 = isMp3;
+const isGif = (data) => {
+    const gifPattern = new Uint8Array([0x47, 0x49, 0x46, 0x38]);
+    return (0, exports.matchesPattern)(gifPattern)(data.subarray(0, 4));
+};
+exports.isGif = isGif;
+const isAac = (data) => {
+    const aacPattern = new Uint8Array([0xff, 0xf1]);
+    return (0, exports.matchesPattern)(aacPattern)(data.subarray(0, 2));
+};
+exports.isAac = isAac;

package/dist/file-types/get-jpeg-dimensions.d.ts

@@ -0,0 +1,4 @@
+export declare function getJpegDimensions(data: Uint8Array): {
+    width: number;
+    height: number;
+} | null;

package/dist/file-types/get-jpeg-dimensions.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJpegDimensions = getJpegDimensions;
+function getJpegDimensions(data) {
+    let offset = 0;
+    // Helper function to read a 16-bit big-endian integer
+    function readUint16BE(o) {
+        return (data[o] << 8) | data[o + 1];
+    }
+    // Skip the Start of Image (SOI) marker
+    if (readUint16BE(offset) !== 0xffd8) {
+        return null; // Not a valid JPEG file
+    }
+    offset += 2;
+    while (offset < data.length) {
+        if (data[offset] === 0xff) {
+            const marker = data[offset + 1];
+            if (marker === 0xc0 || marker === 0xc2) {
+                // SOF0 or SOF2
+                const height = readUint16BE(offset + 5);
+                const width = readUint16BE(offset + 7);
+                return { width, height };
+            }
+            const length = readUint16BE(offset + 2);
+            offset += length + 2; // Move to the next marker
+        }
+        else {
+            offset++;
+        }
+    }
+    return null; // Return null if dimensions are not found
+}

package/dist/file-types/index.d.ts

@@ -0,0 +1,2 @@
+import type { FileType } from './detect-file-type';
+export declare const detectFileType: (data: Uint8Array) => FileType;

package/dist/file-types/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFileType = void 0;
+const bmp_1 = require("./bmp");
+const detect_file_type_1 = require("./detect-file-type");
+const jpeg_1 = require("./jpeg");
+const pdf_1 = require("./pdf");
+const png_1 = require("./png");
+const webp_1 = require("./webp");
+const detectFileType = (data) => {
+    if ((0, detect_file_type_1.isRiffWave)(data)) {
+        return { type: 'wav' };
+    }
+    if ((0, detect_file_type_1.isRiffAvi)(data)) {
+        return { type: 'riff' };
+    }
+    if ((0, detect_file_type_1.isAac)(data)) {
+        return { type: 'aac' };
+    }
+    const webp = (0, webp_1.isWebp)(data);
+    if (webp) {
+        return webp;
+    }
+    if ((0, detect_file_type_1.isWebm)(data)) {
+        return { type: 'webm' };
+    }
+    if ((0, detect_file_type_1.isIsoBaseMedia)(data)) {
+        return { type: 'iso-base-media' };
+    }
+    if ((0, detect_file_type_1.isTransportStream)(data)) {
+        return { type: 'transport-stream' };
+    }
+    if ((0, detect_file_type_1.isMp3)(data)) {
+        return { type: 'mp3' };
+    }
+    if ((0, detect_file_type_1.isGif)(data)) {
+        return { type: 'gif' };
+    }
+    const png = (0, png_1.isPng)(data);
+    if (png) {
+        return png;
+    }
+    const pdf = (0, pdf_1.isPdf)(data);
+    if (pdf) {
+        return pdf;
+    }
+    const bmp = (0, bmp_1.isBmp)(data);
+    if (bmp) {
+        return bmp;
+    }
+    const jpeg = (0, jpeg_1.isJpeg)(data);
+    if (jpeg) {
+        return jpeg;
+    }
+    return { type: 'unknown' };
+};
+exports.detectFileType = detectFileType;

package/dist/file-types/jpeg.d.ts

@@ -0,0 +1,12 @@
+export declare function getJpegDimensions(data: Uint8Array): {
+    width: number;
+    height: number;
+} | null;
+export declare const isJpeg: (data: Uint8Array) => JpegType | null;
+export type JpegType = {
+    type: 'jpeg';
+    dimensions: {
+        width: number;
+        height: number;
+    } | null;
+};

package/dist/file-types/jpeg.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJpeg = void 0;
+exports.getJpegDimensions = getJpegDimensions;
+const detect_file_type_1 = require("./detect-file-type");
+function getJpegDimensions(data) {
+    let offset = 0;
+    // Helper function to read a 16-bit big-endian integer
+    function readUint16BE(o) {
+        return (data[o] << 8) | data[o + 1];
+    }
+    // Skip the Start of Image (SOI) marker
+    if (readUint16BE(offset) !== 0xffd8) {
+        return null; // Not a valid JPEG file
+    }
+    offset += 2;
+    while (offset < data.length) {
+        if (data[offset] === 0xff) {
+            const marker = data[offset + 1];
+            if (marker === 0xc0 || marker === 0xc2) {
+                // SOF0 or SOF2
+                const height = readUint16BE(offset + 5);
+                const width = readUint16BE(offset + 7);
+                return { width, height };
+            }
+            const length = readUint16BE(offset + 2);
+            offset += length + 2; // Move to the next marker
+        }
+        else {
+            offset++;
+        }
+    }
+    return null; // Return null if dimensions are not found
+}
+const isJpeg = (data) => {
+    const jpegPattern = new Uint8Array([0xff, 0xd8]);
+    const jpeg = (0, detect_file_type_1.matchesPattern)(jpegPattern)(data.subarray(0, 2));
+    if (!jpeg) {
+        return null;
+    }
+    const dim = getJpegDimensions(data);
+    return { dimensions: dim, type: 'jpeg' };
+};
+exports.isJpeg = isJpeg;

package/dist/file-types/pdf.d.ts

@@ -0,0 +1,4 @@
+export type PdfType = {
+    type: 'pdf';
+};
+export declare const isPdf: (data: Uint8Array) => PdfType | null;

package/dist/file-types/pdf.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPdf = void 0;
+const detect_file_type_1 = require("./detect-file-type");
+const isPdf = (data) => {
+    if (data.length < 4) {
+        return null;
+    }
+    const pdfPattern = new Uint8Array([0x25, 0x50, 0x44, 0x46]);
+    return (0, detect_file_type_1.matchesPattern)(pdfPattern)(data.subarray(0, 4)) ? { type: 'pdf' } : null;
+};
+exports.isPdf = isPdf;

package/dist/file-types/png.d.ts

@@ -0,0 +1,10 @@
+import type { Dimensions } from '../get-dimensions';
+export declare function getPngDimensions(pngData: Uint8Array): {
+    width: number;
+    height: number;
+} | null;
+export declare const isPng: (data: Uint8Array) => PngType | null;
+export type PngType = {
+    type: 'png';
+    dimensions: Dimensions | null;
+};

package/dist/file-types/png.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPng = void 0;
+exports.getPngDimensions = getPngDimensions;
+const detect_file_type_1 = require("./detect-file-type");
+function getPngDimensions(pngData) {
+    if (pngData.length < 24) {
+        // PNG header (8) + IHDR chunk (16) minimum
+        return null;
+    }
+    const view = new DataView(pngData.buffer, pngData.byteOffset);
+    // Check PNG signature
+    const pngSignature = [137, 80, 78, 71, 13, 10, 26, 10];
+    for (let i = 0; i < 8; i++) {
+        if (pngData[i] !== pngSignature[i]) {
+            return null;
+        }
+    }
+    return {
+        width: view.getUint32(16, false), // false = big-endian
+        height: view.getUint32(20, false), // false = big-endian
+    };
+}
+const isPng = (data) => {
+    const pngPattern = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+    if ((0, detect_file_type_1.matchesPattern)(pngPattern)(data.subarray(0, 4))) {
+        const png = getPngDimensions(data);
+        return { dimensions: png, type: 'png' };
+    }
+    return null;
+};
+exports.isPng = isPng;

package/dist/file-types/webp.d.ts

@@ -0,0 +1,6 @@
+import type { Dimensions } from '../get-dimensions';
+export declare const isWebp: (data: Uint8Array) => WebpType | null;
+export type WebpType = {
+    type: 'webp';
+    dimensions: Dimensions | null;
+};

package/dist/file-types/webp.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWebp = void 0;
+const detect_file_type_1 = require("./detect-file-type");
+function getWebPDimensions(bytes) {
+    // Check if we have enough bytes for a basic WebP header
+    if (bytes.length < 30) {
+        return null;
+    }
+    // Check WebP file signature
+    // "RIFF" signature (52 49 46 46) and "WEBP" signature (57 45 42 50)
+    if (bytes[0] !== 0x52 || // R
+        bytes[1] !== 0x49 || // I
+        bytes[2] !== 0x46 || // F
+        bytes[3] !== 0x46 || // F
+        bytes[8] !== 0x57 || // W
+        bytes[9] !== 0x45 || // E
+        bytes[10] !== 0x42 || // B
+        bytes[11] !== 0x50 // P
+    ) {
+        return null;
+    }
+    // Check for VP8 bitstream
+    if (bytes[12] === 0x56 && bytes[13] === 0x50 && bytes[14] === 0x38) {
+        // VP8 format
+        if (bytes[15] === 0x20) {
+            // Simple VP8 format
+            return {
+                width: bytes[26] | ((bytes[27] << 8) & 0x3fff),
+                height: bytes[28] | ((bytes[29] << 8) & 0x3fff),
+            };
+        }
+    }
+    // Check for VP8L (lossless) bitstream
+    if (bytes[12] === 0x56 &&
+        bytes[13] === 0x50 &&
+        bytes[14] === 0x38 &&
+        bytes[15] === 0x4c) {
+        return {
+            width: 1 + (bytes[21] | ((bytes[22] & 0x3f) << 8)),
+            height: 1 +
+                (((bytes[22] & 0xc0) >> 6) |
+                    (bytes[23] << 2) |
+                    ((bytes[24] & 0x0f) << 10)),
+        };
+    }
+    // Check for VP8X (extended) bitstream
+    if (bytes[12] === 0x56 &&
+        bytes[13] === 0x50 &&
+        bytes[14] === 0x38 &&
+        bytes[15] === 0x58) {
+        return {
+            width: 1 + (bytes[24] | (bytes[25] << 8) | (bytes[26] << 16)),
+            height: 1 + (bytes[27] | (bytes[28] << 8) | (bytes[29] << 16)),
+        };
+    }
+    return null;
+}
+const isWebp = (data) => {
+    const webpPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if ((0, detect_file_type_1.matchesPattern)(webpPattern)(data.subarray(0, 4))) {
+        return {
+            type: 'webp',
+            dimensions: getWebPDimensions(data),
+        };
+    }
+    return null;
+};
+exports.isWebp = isWebp;

package/dist/file-types.d.ts

@@ -0,0 +1 @@
+export declare const detectFileType: (data: Uint8Array) => "webp" | "riff" | "webm" | "iso-base-media" | "transport-stream" | "mp3" | "gif" | "png" | "bmp" | "jpeg" | "unknown";

package/dist/file-types.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFileType = void 0;
+const make_header_1 = require("./boxes/webm/make-header");
+const matchesPattern = (pattern) => {
+    return (data) => {
+        return pattern.every((value, index) => data[index] === value);
+    };
+};
+const isRiff = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    return matchesPattern(riffPattern)(data.subarray(0, 4));
+};
+const isWebm = (data) => {
+    return matchesPattern(make_header_1.webmPattern)(data.subarray(0, 4));
+};
+const isIsoBaseMedia = (data) => {
+    const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
+    return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+const isTransportStream = (data) => {
+    return data[0] === 0x47 && data[188] === 0x47;
+};
+const isMp3 = (data) => {
+    const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
+    return matchesPattern(mpegPattern)(data.subarray(0, 4));
+};
+const isGif = (data) => {
+    const gifPattern = new Uint8Array([0x47, 0x49, 0x46, 0x38]);
+    return matchesPattern(gifPattern)(data.subarray(0, 4));
+};
+const isPng = (data) => {
+    const pngPattern = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+    return matchesPattern(pngPattern)(data.subarray(0, 4));
+};
+const isBmp = (data) => {
+    const bmpPattern = new Uint8Array([0x42, 0x4d]);
+    return matchesPattern(bmpPattern)(data.subarray(0, 2));
+};
+const isJpeg = (data) => {
+    const jpegPattern = new Uint8Array([0xff, 0xd8]);
+    const jpeg = matchesPattern(jpegPattern)(data.subarray(0, 2));
+    if (!jpeg) {
+        return false;
+    }
+    const width = data[6] * 256 + data[7];
+    const height = data[8] * 256 + data[9];
+    console.log(width, height);
+    return true;
+};
+const isWebp = (data) => {
+    const webpPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    return matchesPattern(webpPattern)(data.subarray(0, 4));
+};
+const detectFileType = (data) => {
+    if (isWebp(data)) {
+        return 'webp';
+    }
+    if (isRiff(data)) {
+        return 'riff';
+    }
+    if (isWebm(data)) {
+        return 'webm';
+    }
+    if (isIsoBaseMedia(data)) {
+        return 'iso-base-media';
+    }
+    if (isTransportStream(data)) {
+        return 'transport-stream';
+    }
+    if (isMp3(data)) {
+        return 'mp3';
+    }
+    if (isGif(data)) {
+        return 'gif';
+    }
+    if (isPng(data)) {
+        return 'png';
+    }
+    if (isBmp(data)) {
+        return 'bmp';
+    }
+    if (isJpeg(data)) {
+        return 'jpeg';
+    }
+    return 'unknown';
+};
+exports.detectFileType = detectFileType;

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

@@ -11,7 +11,7 @@ type AudioCodecInfo = {
     secondarySpecificator: number | null;
     description: Uint8Array | undefined;
 };
-export declare const getCodecPrivateFromTrak: (trakBox: TrakBox) => Uint8Array | null;
+export declare const getCodecPrivateFromTrak: (trakBox: TrakBox) => Uint8Array<ArrayBufferLike> | null;
 export declare const getNumberOfChannelsFromTrak: (trak: TrakBox) => number | null;
 export declare const getSampleRate: (trak: TrakBox) => number | null;
 export declare const getAudioCodecFromTrak: (trak: TrakBox) => AudioCodecInfo | null;

package/dist/get-duration.d.ts

@@ -7,3 +7,4 @@ export declare const isMatroska: (boxes: AnySegment[]) => {
 } | undefined;
 export declare const getDuration: (structure: Structure, parserState: ParserState) => number | null;
 export declare const hasDuration: (structure: Structure, parserState: ParserState) => boolean;
+export declare const hasSlowDuration: (structure: Structure, parserState: ParserState) => boolean;

package/dist/get-duration.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasDuration = exports.getDuration = exports.isMatroska = void 0;
+exports.hasSlowDuration = exports.hasDuration = exports.getDuration = exports.isMatroska = void 0;
 const get_sample_positions_from_track_1 = require("./boxes/iso-base-media/get-sample-positions-from-track");
 const traversal_1 = require("./boxes/iso-base-media/traversal");
 const traversal_2 = require("./boxes/riff/traversal");
@@ -95,7 +95,20 @@ const getDuration = (structure, parserState) => {
     throw new Error('Has no duration ' + structure);
 };
 exports.getDuration = getDuration;
+// `duration` just grabs from metadata, and otherwise returns null
+// Therefore just checking if we have tracks
 const hasDuration = (structure, parserState) => {
     return (0, get_tracks_1.hasTracks)(structure, parserState);
 };
 exports.hasDuration = hasDuration;
+// `slowDuration` does through everything, and therefore is false
+// Unless it it somewhere in the metadata and is non-null
+const hasSlowDuration = (structure, parserState) => {
+    try {
+        return (0, exports.getDuration)(structure, parserState) !== null;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.hasSlowDuration = hasSlowDuration;

package/dist/get-fields-from-callbacks.d.ts

@@ -0,0 +1,5 @@
+import type { Options, ParseMediaCallbacks, ParseMediaFields } from './options';
+export declare const getFieldsFromCallback: <F extends Options<ParseMediaFields>>({ fields, callbacks, }: {
+    fields: F;
+    callbacks: ParseMediaCallbacks;
+}) => Options<ParseMediaFields>;

package/dist/get-fields-from-callbacks.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldsFromCallback = void 0;
+const getFieldsFromCallback = ({ fields, callbacks, }) => {
+    const newFields = {
+        audioCodec: Boolean(callbacks.onAudioCodec),
+        container: Boolean(callbacks.onContainer),
+        dimensions: Boolean(callbacks.onDimensions),
+        durationInSeconds: Boolean(callbacks.onDurationInSeconds),
+        fps: Boolean(callbacks.onFps),
+        internalStats: Boolean(callbacks.onInternalStats),
+        isHdr: Boolean(callbacks.onIsHdr),
+        location: Boolean(callbacks.onLocation),
+        metadata: Boolean(callbacks.onMetadata),
+        mimeType: Boolean(callbacks.onMimeType),
+        name: Boolean(callbacks.onName),
+        rotation: Boolean(callbacks.onRotation),
+        size: Boolean(callbacks.onSize),
+        structure: Boolean(callbacks.onStructure),
+        tracks: Boolean(callbacks.onTracks),
+        unrotatedDimensions: Boolean(callbacks.onUnrotatedDimensions),
+        videoCodec: Boolean(callbacks.onVideoCodec),
+        slowKeyframes: Boolean(callbacks.onSlowKeyframes),
+        slowDurationInSeconds: Boolean(callbacks.onSlowDurationInSeconds),
+        slowFps: Boolean(callbacks.onSlowFps),
+        slowNumberOfFrames: Boolean(callbacks.onSlowNumberOfFrames),
+        keyframes: Boolean(callbacks.onKeyframes),
+        ...fields,
+    };
+    return newFields;
+};
+exports.getFieldsFromCallback = getFieldsFromCallback;

package/dist/get-fps.d.ts

@@ -9,5 +9,6 @@ export declare const trakBoxContainsVideo: (trakBox: TrakBox) => boolean;
 export declare const getTimescaleAndDuration: (trakBox: TrakBox) => TimescaleAndDuration | null;
 export declare const getFpsFromMp4TrakBox: (trakBox: TrakBox) => number | null;
 export declare const getFps: (segments: Structure) => number | null;
+export declare const hasFpsSuitedForSlowFps: (boxes: Structure) => boolean;
 export declare const hasFps: (boxes: Structure) => boolean;
 export {};