@remotion/media-parser 4.0.229 → 4.0.230

package/dist/boxes/iso-base-media/esds/decoder-specific-config.d.ts

@@ -1,14 +1,15 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
 type UnknownDecoderSpecificConfig = {
     type: 'unknown-decoder-specific-config';
 };
 type AudioSpecificConfig = {
-    type: 'audio-specific-config';
+    type: 'mp4a-specific-config';
     audioObjectType: number;
     samplingFrequencyIndex: number;
     channelConfiguration: number;
     asBytes: Uint8Array;
 };
 export type DecoderSpecificConfig = UnknownDecoderSpecificConfig | AudioSpecificConfig;
-export declare const parseDecoderSpecificConfig: (iterator: BufferIterator) => DecoderSpecificConfig;
+export declare const parseDecoderSpecificConfig: (iterator: BufferIterator, logLevel: LogLevel) => DecoderSpecificConfig;
 export {};

package/dist/boxes/iso-base-media/esds/decoder-specific-config.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDecoderSpecificConfig = void 0;
-const parseDecoderSpecificConfig = (iterator) => {
+const log_1 = require("../../../log");
+const parseDecoderSpecificConfig = (iterator, logLevel) => {
     const layerTag = iterator.getUint8();
     const layerSize = iterator.getPaddedFourByteNumber();
     const start = iterator.counter.getOffset();
@@ -27,17 +28,15 @@ const parseDecoderSpecificConfig = (iterator) => {
     if (read < layerSize) {
         iterator.discard(layerSize - read);
     }
-    // Working around Chrome bug
-    // https://issues.chromium.org/issues/360083330#comment5
-    const patchedAsBytes = bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136
-        ? new Uint8Array([17, 144])
-        : bytes;
+    if (bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136) {
+        log_1.Log.warn(logLevel, 'Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330');
+    }
     return {
-        type: 'audio-specific-config',
+        type: 'mp4a-specific-config',
         audioObjectType,
         samplingFrequencyIndex,
         channelConfiguration,
-        asBytes: patchedAsBytes,
+        asBytes: bytes,
     };
 };
 exports.parseDecoderSpecificConfig = parseDecoderSpecificConfig;

package/dist/boxes/iso-base-media/esds/esds-descriptors.d.ts

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
 import type { DecoderSpecificConfig } from './decoder-specific-config';
 type AudioObjectType = 'aac' | 'mp3' | 'unknown';
 type DecoderConfigDescriptor = {
@@ -22,8 +23,9 @@ export type Descriptor = DecoderConfigDescriptor | SlConfigDescriptor | UnknownD
 type DescriptorAndNext = {
     descriptor: Descriptor | null;
 };
-export declare const processDescriptor: ({ iterator, }: {
+export declare const processDescriptor: ({ iterator, logLevel, }: {
     iterator: BufferIterator;
+    logLevel: LogLevel;
 }) => DescriptorAndNext;
-export declare const parseDescriptors: (iterator: BufferIterator, maxBytes: number) => Descriptor[];
+export declare const parseDescriptors: (iterator: BufferIterator, maxBytes: number, logLevel: LogLevel) => Descriptor[];
 export {};

package/dist/boxes/iso-base-media/esds/esds-descriptors.js

@@ -14,7 +14,7 @@ const mapToObjectAudioIndicator = (num) => {
     }
     return 'unknown';
 };
-const processDescriptor = ({ iterator, }) => {
+const processDescriptor = ({ iterator, logLevel, }) => {
     const tag = iterator.getUint8();
     if (tag === 4) {
         const size = iterator.getPaddedFourByteNumber();
@@ -30,8 +30,8 @@ const processDescriptor = ({ iterator, }) => {
         const maxBitrate = iterator.getUint32();
         const avgBitrate = iterator.getUint32();
         const decoderSpecificConfigs = [];
-        while (size - (iterator.counter.getOffset() - initialOffset) >= 0) {
-            const decoderSpecificConfig = (0, decoder_specific_config_1.parseDecoderSpecificConfig)(iterator);
+        while (size - (iterator.counter.getOffset() - initialOffset) > 0) {
+            const decoderSpecificConfig = (0, decoder_specific_config_1.parseDecoderSpecificConfig)(iterator, logLevel);
             decoderSpecificConfigs.push(decoderSpecificConfig);
         }
         return {
@@ -62,13 +62,14 @@ const processDescriptor = ({ iterator, }) => {
     };
 };
 exports.processDescriptor = processDescriptor;
-const parseDescriptors = (iterator, maxBytes) => {
+const parseDescriptors = (iterator, maxBytes, logLevel) => {
     const descriptors = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
         const { descriptor } = (0, exports.processDescriptor)({
             iterator,
+            logLevel,
         });
         if (descriptor) {
             descriptors.push(descriptor);

package/dist/boxes/iso-base-media/esds/esds.d.ts

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
 import type { Descriptor } from './esds-descriptors';
 export interface EsdsBox {
     type: 'esds-box';
@@ -8,8 +9,9 @@ export interface EsdsBox {
     esId: number;
     descriptors: Descriptor[];
 }
-export declare const parseEsds: ({ data, size, fileOffset, }: {
+export declare const parseEsds: ({ data, size, fileOffset, logLevel, }: {
     data: BufferIterator;
     size: number;
     fileOffset: number;
+    logLevel: LogLevel;
 }) => EsdsBox;

package/dist/boxes/iso-base-media/esds/esds.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseEsds = void 0;
 const esds_descriptors_1 = require("./esds-descriptors");
-const parseEsds = ({ data, size, fileOffset, }) => {
+const parseEsds = ({ data, size, fileOffset, logLevel, }) => {
     const version = data.getUint8();
     // Flags, we discard them
     data.discard(3);
@@ -12,7 +12,7 @@ const parseEsds = ({ data, size, fileOffset, }) => {
     // disard 1 byte, currently unknown
     data.discard(1);
     const remaining = size - (data.counter.getOffset() - fileOffset);
-    const descriptors = (0, esds_descriptors_1.parseDescriptors)(data, remaining);
+    const descriptors = (0, esds_descriptors_1.parseDescriptors)(data, remaining, logLevel);
     const remainingNow = size - (data.counter.getOffset() - fileOffset);
     data.discard(remainingNow);
     return {

package/dist/boxes/iso-base-media/make-track.js

@@ -36,7 +36,7 @@ const makeBaseMediaTrack = (trakBox) => {
             sampleRate,
             description,
             trakBox,
-            codecPrivate: null,
+            codecPrivate: (0, get_audio_codec_1.getCodecPrivateFromTrak)(trakBox),
             codecWithoutConfig: (0, get_audio_codec_1.getAudioCodecFromTrack)(trakBox),
         };
     }
@@ -91,6 +91,7 @@ const makeBaseMediaTrack = (trakBox) => {
             transferCharacteristics: null,
         },
         codecWithoutConfig: (0, get_video_codec_1.getVideoCodecFromIsoTrak)(trakBox),
+        fps: (0, get_fps_1.getFpsFromMp4TrakBox)(trakBox),
     };
     return track;
 };

package/dist/boxes/iso-base-media/mdat/mdat.js

@@ -73,17 +73,23 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signa
             break;
         }
         const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
-        const timestamp = Math.floor((samplesWithIndex.samplePosition.cts * 1000000) /
-            samplesWithIndex.track.timescale);
-        const duration = Math.floor((samplesWithIndex.samplePosition.duration * 1000000) /
-            samplesWithIndex.track.timescale);
+        const timestamp = (samplesWithIndex.samplePosition.cts * 1000000) /
+            samplesWithIndex.track.timescale;
+        const duration = (samplesWithIndex.samplePosition.duration * 1000000) /
+            samplesWithIndex.track.timescale;
+        const cts = (samplesWithIndex.samplePosition.cts * 1000000) /
+            samplesWithIndex.track.timescale;
+        const dts = (samplesWithIndex.samplePosition.dts * 1000000) /
+            samplesWithIndex.track.timescale;
         if (samplesWithIndex.track.type === 'audio') {
             await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
                 data: bytes,
                 timestamp,
+                duration,
+                cts,
+                dts,
                 trackId: samplesWithIndex.track.trackId,
                 type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
-                duration,
             });
         }
         if (samplesWithIndex.track.type === 'video') {
@@ -91,8 +97,8 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signa
                 data: bytes,
                 timestamp,
                 duration,
-                cts: samplesWithIndex.samplePosition.cts,
-                dts: samplesWithIndex.samplePosition.dts,
+                cts,
+                dts,
                 trackId: samplesWithIndex.track.trackId,
                 type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
             });

package/dist/boxes/iso-base-media/moov/moov.d.ts

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
@@ -6,10 +7,11 @@ export interface MoovBox extends BaseBox {
     type: 'moov-box';
     children: AnySegment[];
 }
-export declare const parseMoov: ({ iterator, offset, size, options, signal, }: {
+export declare const parseMoov: ({ iterator, offset, size, options, signal, logLevel, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
     options: ParserContext;
     signal: AbortSignal | null;
+    logLevel: LogLevel;
 }) => Promise<MoovBox>;

package/dist/boxes/iso-base-media/moov/moov.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMoov = void 0;
 const process_box_1 = require("../process-box");
-const parseMoov = async ({ iterator, offset, size, options, signal, }) => {
+const parseMoov = async ({ iterator, offset, size, options, signal, logLevel, }) => {
     const children = await (0, process_box_1.parseBoxes)({
         iterator,
         maxBytes: size - (iterator.counter.getOffset() - offset),
@@ -10,8 +10,8 @@ const parseMoov = async ({ iterator, offset, size, options, signal, }) => {
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian: false,
         signal,
+        logLevel,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/iso-base-media/mvhd.js

@@ -27,15 +27,17 @@ const parseMvhd = ({ iterator, offset, size, }) => {
     iterator.discard(4);
     iterator.discard(4);
     // matrix
-    const matrix = [];
-    for (let i = 0; i < 9; i++) {
-        if (i % 3 === 2) {
-            matrix.push(iterator.getFixedPointSigned230Number());
-        }
-        else {
-            matrix.push(iterator.getFixedPointSigned1616Number());
-        }
-    }
+    const matrix = [
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+    ];
     // pre-defined
     iterator.discard(4 * 6);
     // next track id

package/dist/boxes/iso-base-media/parse-icc-profile.d.ts

@@ -0,0 +1,36 @@
+type Point = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type IccProfile = {
+    size: number;
+    preferredCMMType: string;
+    profileVersion: string;
+    profileDeviceClass: string;
+    colorSpace: string;
+    pcs: string;
+    dateTime: Uint8Array;
+    signature: string;
+    primaryPlatform: string;
+    profileFlags: number;
+    deviceManufacturer: string;
+    deviceModel: string;
+    deviceAttributes: bigint;
+    renderingIntent: number;
+    pcsIlluminant: [number, number, number];
+    profileCreator: string;
+    profileId: string;
+    entries: Entry[];
+    rXYZ: Point | null;
+    gXYZ: Point | null;
+    bXYZ: Point | null;
+    whitePoint: Point | null;
+};
+type Entry = {
+    tag: string;
+    size: number;
+    offset: number;
+};
+export declare const parseIccProfile: (data: Uint8Array) => IccProfile;
+export {};

package/dist/boxes/iso-base-media/parse-icc-profile.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIccProfile = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const parseIccProfile = (data) => {
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, Infinity);
+    const size = iterator.getUint32();
+    if (size !== data.length) {
+        throw new Error('Invalid ICC profile size');
+    }
+    const preferredCMMType = iterator.getByteString(4);
+    const profileVersion = iterator.getByteString(4);
+    const profileDeviceClass = iterator.getByteString(4);
+    const colorSpace = iterator.getByteString(4);
+    const pcs = iterator.getByteString(4);
+    const dateTime = iterator.getSlice(12);
+    const signature = iterator.getByteString(4);
+    if (signature !== 'acsp') {
+        throw new Error('Invalid ICC profile signature');
+    }
+    const primaryPlatform = iterator.getByteString(4);
+    const profileFlags = iterator.getUint32();
+    const deviceManufacturer = iterator.getByteString(4);
+    const deviceModel = iterator.getByteString(4);
+    const deviceAttributes = iterator.getUint64();
+    const renderingIntent = iterator.getUint32();
+    const pcsIlluminant1 = iterator.getUint32();
+    const pcsIlluminant2 = iterator.getUint32();
+    const pcsIlluminant3 = iterator.getUint32();
+    const profileCreator = iterator.getByteString(4);
+    const profileId = iterator.getByteString(16);
+    // reserved
+    iterator.discard(28);
+    const tagCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < tagCount; i++) {
+        const entry = {
+            tag: iterator.getByteString(4),
+            offset: iterator.getUint32(),
+            size: iterator.getUint32(),
+        };
+        entries.push(entry);
+    }
+    let lastOffset = -1;
+    let rXYZ = null;
+    let gXYZ = null;
+    let bXYZ = null;
+    let whitePoint = null;
+    for (const entry of entries) {
+        const found = data.slice(entry.offset, entry.offset + entry.size);
+        if (entry.tag === 'rXYZ' ||
+            entry.tag === 'gXYZ' ||
+            entry.tag === 'bXYZ' ||
+            entry.tag === 'wtpt') {
+            const it = (0, buffer_iterator_1.getArrayBufferIterator)(found, Infinity);
+            it.discard(4);
+            const x = it.getInt32() / 65536;
+            const y = it.getInt32() / 65536;
+            const z = it.getInt32() / 65536;
+            it.destroy();
+            const point = { x, y, z };
+            if (entry.tag === 'rXYZ') {
+                rXYZ = point;
+            }
+            else if (entry.tag === 'gXYZ') {
+                gXYZ = point;
+            }
+            else if (entry.tag === 'bXYZ') {
+                bXYZ = point;
+            }
+            else if (entry.tag === 'wtpt') {
+                whitePoint = point;
+            }
+        }
+        if (lastOffset !== -1) {
+            const bytesToAdvance = entry.offset - lastOffset;
+            const bytesToGoBackwards = entry.size - bytesToAdvance;
+            if (bytesToGoBackwards > 0) {
+                iterator.counter.decrement(bytesToGoBackwards);
+            }
+        }
+        lastOffset = entry.offset;
+    }
+    const profile = {
+        size,
+        preferredCMMType,
+        profileVersion,
+        profileDeviceClass,
+        colorSpace,
+        pcs,
+        dateTime,
+        signature,
+        primaryPlatform,
+        profileFlags,
+        deviceManufacturer,
+        deviceModel,
+        deviceAttributes,
+        renderingIntent,
+        pcsIlluminant: [
+            pcsIlluminant1 / 65536,
+            pcsIlluminant2 / 65536,
+            pcsIlluminant3 / 65536,
+        ],
+        profileCreator,
+        profileId,
+        entries,
+        bXYZ,
+        gXYZ,
+        rXYZ,
+        whitePoint,
+    };
+    iterator.destroy();
+    return profile;
+};
+exports.parseIccProfile = parseIccProfile;

package/dist/boxes/iso-base-media/process-box.d.ts

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../buffer-iterator';
+import type { LogLevel } from '../../log';
 import type { AnySegment, IsoBaseMediaBox, ParseResult } from '../../parse-result';
 import type { BoxAndNext, PartialMdatBox } from '../../parse-video';
 import type { ParserContext } from '../../parser-context';
@@ -10,21 +11,21 @@ export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parse
     options: ParserContext;
     signal: AbortSignal | null;
 }) => Promise<BoxAndNext>;
-export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, littleEndian, signal, }: {
+export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, signal, logLevel, }: {
     iterator: BufferIterator;
     allowIncompleteBoxes: boolean;
     parsedBoxes: AnySegment[];
     options: ParserContext;
-    littleEndian: boolean;
     signal: AbortSignal | null;
+    logLevel: LogLevel;
 }) => Promise<BoxAndNext>;
-export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, littleEndian, signal, }: {
+export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, }: {
     iterator: BufferIterator;
     maxBytes: number;
     allowIncompleteBoxes: boolean;
     initialBoxes: IsoBaseMediaBox[];
     options: ParserContext;
     continueMdat: false | PartialMdatBox;
-    littleEndian: boolean;
     signal: AbortSignal | null;
+    logLevel: LogLevel;
 }) => Promise<ParseResult>;

package/dist/boxes/iso-base-media/process-box.js

@@ -28,7 +28,7 @@ const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
 const traversal_1 = require("./traversal");
 const trun_1 = require("./trun");
-const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, littleEndian, signal, }) => {
+const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, signal, logLevel, }) => {
     const parseChildren = boxType === 'mdia' ||
         boxType === 'minf' ||
         boxType === 'stbl' ||
@@ -46,8 +46,8 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, li
             initialBoxes: [],
             options,
             continueMdat: false,
-            littleEndian,
             signal,
+            logLevel,
         });
         if (parsed.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
@@ -86,11 +86,11 @@ const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes,
     };
 };
 exports.parseMdatPartially = parseMdatPartially;
-const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, littleEndian, signal, }) => {
+const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, signal, logLevel, }) => {
     var _a, _b;
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
-    const boxSizeRaw = iterator.getFourByteNumber(littleEndian);
+    const boxSizeRaw = iterator.getFourByteNumber();
     // If `boxSize === 1`, the 8 bytes after the box type are the size of the box.
     if ((boxSizeRaw === 1 && iterator.bytesRemaining() < 12) ||
         iterator.bytesRemaining() < 4) {
@@ -114,7 +114,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         };
     }
     const boxType = iterator.getByteString(4);
-    const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber(littleEndian) : boxSizeRaw;
+    const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
     if (bytesRemaining < boxSize) {
         if (boxType === 'mdat') {
             const shouldSkip = (options.canSkipVideoData || !(0, get_tracks_1.hasTracks)(parsedBoxes)) &&
@@ -168,6 +168,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     if (boxType === 'colr') {
         const box = (0, colr_1.parseColorParameterBox)({
             iterator,
+            size: boxSize,
         });
         return {
             type: 'complete',
@@ -312,7 +313,6 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             offset: fileOffset,
             size: boxSize,
             options,
-            littleEndian,
             signal,
         });
         return {
@@ -329,6 +329,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             size: boxSize,
             options,
             signal,
+            logLevel,
         });
         return {
             type: 'complete',
@@ -344,6 +345,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             offsetAtStart: fileOffset,
             options,
             signal,
+            logLevel,
         });
         const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
         if (transformedTrack) {
@@ -444,6 +446,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             data: iterator,
             size: boxSize,
             fileOffset,
+            logLevel,
         });
         return {
             type: 'complete',
@@ -478,8 +481,8 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         iterator,
         bytesRemainingInBox,
         options,
-        littleEndian,
         signal,
+        logLevel,
     });
     return {
         type: 'complete',
@@ -495,7 +498,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     };
 };
 exports.processBox = processBox;
-const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, littleEndian, signal, }) => {
+const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, }) => {
     let boxes = initialBoxes;
     const initialOffset = iterator.counter.getOffset();
     const alreadyHasMdat = boxes.find((b) => b.type === 'mdat-box');
@@ -515,8 +518,8 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                 allowIncompleteBoxes,
                 parsedBoxes: initialBoxes,
                 options,
-                littleEndian,
                 signal,
+                logLevel,
             });
         if (result.type === 'incomplete') {
             if (Number.isFinite(maxBytes)) {
@@ -533,8 +536,8 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         initialBoxes: boxes,
                         options,
                         continueMdat: false,
-                        littleEndian,
                         signal,
+                        logLevel,
                     });
                 },
                 skipTo: null,
@@ -552,8 +555,8 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         initialBoxes: boxes,
                         options,
                         continueMdat: result,
-                        littleEndian,
                         signal,
+                        logLevel,
                     }));
                 },
                 skipTo: null,
@@ -586,8 +589,8 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         initialBoxes: boxes,
                         options,
                         continueMdat: false,
-                        littleEndian,
                         signal,
+                        logLevel,
                     });
                 },
                 skipTo: result.skipTo,
@@ -605,8 +608,8 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         initialBoxes: boxes,
                         options,
                         continueMdat: false,
-                        littleEndian,
                         signal,
+                        logLevel,
                     });
                 },
                 skipTo: null,
@@ -634,8 +637,8 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                     initialBoxes: boxes,
                     options,
                     continueMdat: false,
-                    littleEndian,
                     signal,
+                    logLevel,
                 });
             },
             skipTo: skipped ? mdatState.fileOffset : null,

package/dist/boxes/iso-base-media/stsd/colr.d.ts

@@ -1,11 +1,21 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-export interface ColorParameterBox {
-    type: 'colr-box';
+import type { IccProfile } from '../parse-icc-profile';
+type ExtraData = {
+    colorType: 'transfer-characteristics';
     primaries: number;
     transfer: number;
     matrixIndex: number;
     fullRangeFlag: boolean;
-}
-export declare const parseColorParameterBox: ({ iterator, }: {
+} | {
+    colorType: 'icc-profile';
+    profile: Uint8Array;
+    parsed: IccProfile;
+};
+export type ColorParameterBox = {
+    type: 'colr-box';
+} & ExtraData;
+export declare const parseColorParameterBox: ({ iterator, size, }: {
     iterator: BufferIterator;
+    size: number;
 }) => ColorParameterBox;
+export {};