@remotion/media-parser 4.0.199 → 4.0.201

package/dist/av1-codec-string.d.ts

@@ -1,3 +1,8 @@
 import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
 import type { Av1BitstreamHeaderSegment } from './boxes/webm/bitstream/av1/header-segment';
+import type { ClusterSegment, TrackEntrySegment } from './boxes/webm/segments/track-entry';
 export declare const constructAv1CodecString: (av1BitstreamHeader: Av1BitstreamHeaderSegment, colrAtom: ColorParameterBox | null) => string;
+export declare const av1CodecStringToString: ({ track, clusterSegment, }: {
+    track: TrackEntrySegment;
+    clusterSegment: ClusterSegment;
+}) => string | null;

package/dist/av1-codec-string.js

@@ -1,7 +1,9 @@
 "use strict";
 // https://aomediacodec.github.io/av1-isobmff/#codecsparam
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.constructAv1CodecString = void 0;
+exports.av1CodecStringToString = exports.constructAv1CodecString = void 0;
+const traversal_1 = require("./boxes/webm/traversal");
+const traversal_2 = require("./traversal");
 const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
     let str = 'av01.';
     // Profile
@@ -89,3 +91,18 @@ const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
     return str;
 };
 exports.constructAv1CodecString = constructAv1CodecString;
+const av1CodecStringToString = ({ track, clusterSegment, }) => {
+    const codecSegment = (0, traversal_2.getCodecSegment)(track);
+    if (!codecSegment) {
+        throw new Error('Expected codec segment');
+    }
+    if (codecSegment.codec !== 'V_AV1') {
+        throw new Error(`Should not call this function if it is not AV1: ${codecSegment.codec}`);
+    }
+    const av1BitstreamHeader = (0, traversal_1.getAv1BitstreamHeader)(clusterSegment);
+    if (!av1BitstreamHeader) {
+        return null;
+    }
+    return (0, exports.constructAv1CodecString)(av1BitstreamHeader, null);
+};
+exports.av1CodecStringToString = av1CodecStringToString;

package/dist/bitstream/av1.d.ts

@@ -0,0 +1,2 @@
+import type { BufferIterator } from '../buffer-iterator';
+export declare const expectBitstream: (iterator: BufferIterator, size: number) => null;

package/dist/bitstream/av1.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectBitstream = void 0;
+const expectBitstream = (iterator, size) => {
+    const offset = iterator.counter.getOffset();
+    const firstByte = iterator.getUint8();
+    console.log({ firstByte, size });
+    const remaining = size - (iterator.counter.getOffset() - offset);
+    iterator.discard(remaining);
+    return null;
+};
+exports.expectBitstream = expectBitstream;

package/dist/boxes/iso-base-media/avcc-hvcc.d.ts

@@ -0,0 +1,20 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface AvccBox {
+    type: 'avcc-box';
+    data: Uint8Array;
+    configurationString: string;
+}
+export declare const parseAvcc: ({ data, size, }: {
+    data: BufferIterator;
+    size: number;
+}) => AvccBox;
+export interface HvccBox {
+    type: 'hvcc-box';
+    data: Uint8Array;
+    configurationString: string;
+}
+export declare const parseHvcc: ({ data, size, offset, }: {
+    data: BufferIterator;
+    size: number;
+    offset: number;
+}) => HvccBox;

package/dist/boxes/iso-base-media/avcc-hvcc.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHvcc = exports.parseAvcc = void 0;
+const parseAvcc = ({ data, size, }) => {
+    const confVersion = data.getUint8();
+    if (confVersion !== 1) {
+        throw new Error(`Unsupported AVCC version ${confVersion}`);
+    }
+    const profile = data.getUint8();
+    const profileCompatibility = data.getUint8();
+    const level = data.getUint8();
+    const str = `${profile.toString(16).padStart(2, '0')}${profileCompatibility.toString(16).padStart(2, '0')}${level.toString(16).padStart(2, '0')}`;
+    data.counter.decrement(4);
+    return {
+        type: 'avcc-box',
+        data: data.getSlice(size - 8),
+        configurationString: str,
+    };
+};
+exports.parseAvcc = parseAvcc;
+const parseHvcc = ({ data, size, offset, }) => {
+    const raw = data.getSlice(size - 8);
+    data.counter.decrement(size - 8);
+    const configurationVersion = data.getUint8();
+    if (configurationVersion !== 1) {
+        throw new Error(`Unsupported HVCC version ${configurationVersion}`);
+    }
+    const generalProfileSpaceTierFlagAndIdc = data.getUint8();
+    let generalProfileCompatibility = data.getUint32();
+    //  unsigned int(2) general_profile_space;
+    // 	unsigned int(1) general_tier_flag;
+    //	unsigned int(5) general_profile_idc;
+    const generalProfileSpace = generalProfileSpaceTierFlagAndIdc >> 6;
+    const generalTierFlag = generalProfileSpaceTierFlagAndIdc >> 5;
+    const generalProfileIdc = generalProfileSpaceTierFlagAndIdc >> 0;
+    // general_constraint_indicator_flags(48)
+    const generalConstraintIndicator = data.getSlice(6);
+    const generalLevelIdc = data.getUint8();
+    let reversedGeneralProfileSpace = 0;
+    for (let i = 0; i < 32; i++) {
+        reversedGeneralProfileSpace |= generalProfileCompatibility & 1;
+        if (i === 31)
+            break;
+        reversedGeneralProfileSpace <<= 1;
+        generalProfileCompatibility >>= 1;
+    }
+    const profileSpaceChar = generalProfileSpace === 0
+        ? ''
+        : generalProfileSpace === 1
+            ? 'A'
+            : generalProfileSpace === 2
+                ? 'B'
+                : 'C';
+    const generalTierChar = generalTierFlag === 0 ? 'L' : 'H';
+    let hasByte = false;
+    let generalConstraintString = '';
+    for (let i = 5; i >= 0; i--) {
+        if (generalConstraintIndicator[i] || hasByte) {
+            generalConstraintString =
+                generalConstraintIndicator[i].toString(16) + generalConstraintString;
+            hasByte = true;
+        }
+    }
+    const constraintString = `${profileSpaceChar}${generalProfileIdc.toString(16)}.${reversedGeneralProfileSpace.toString(16)}.${generalTierChar}${generalLevelIdc}.${generalConstraintString}`;
+    const remaining = size - (data.counter.getOffset() - offset);
+    data.discard(remaining);
+    return {
+        type: 'hvcc-box',
+        data: raw,
+        configurationString: constraintString,
+    };
+};
+exports.parseHvcc = parseHvcc;

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

@@ -0,0 +1,18 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface AvccBox {
+    type: 'avcc-box';
+    data: Uint8Array;
+    configurationString: string;
+}
+export declare const parseAvcc: ({ data, size, }: {
+    data: BufferIterator;
+    size: number;
+}) => AvccBox;
+export interface HvccBox {
+    type: 'hvcc-box';
+    data: Uint8Array;
+}
+export declare const parseHvcc: ({ data, size, }: {
+    data: BufferIterator;
+    size: number;
+}) => HvccBox;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHvcc = exports.parseAvcc = void 0;
+const parseAvcc = ({ data, size, }) => {
+    const confVersion = data.getUint8();
+    if (confVersion !== 1) {
+        throw new Error(`Unsupported AVCC version ${confVersion}`);
+    }
+    const profile = data.getUint8();
+    const profileCompatibility = data.getUint8();
+    const level = data.getUint8();
+    const str = `${profile.toString(16).padStart(2, '0')}${profileCompatibility.toString(16).padStart(2, '0')}${level.toString(16).padStart(2, '0')}`;
+    data.counter.decrement(4);
+    return {
+        type: 'avcc-box',
+        data: data.getSlice(size - 8),
+        configurationString: str,
+    };
+};
+exports.parseAvcc = parseAvcc;
+const parseHvcc = ({ data, size, }) => {
+    return {
+        type: 'hvcc-box',
+        data: data.getSlice(size - 8),
+    };
+};
+exports.parseHvcc = parseHvcc;

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

@@ -0,0 +1,21 @@
+import type { BufferIterator } from '../../buffer-iterator';
+type AudioObjectType = 'aac' | 'mp3' | 'unknown';
+type DecoderConfigDescriptor = {
+    type: 'decoder-config-descriptor';
+    objectTypeIndication: AudioObjectType;
+};
+type SlConfigDescriptor = {
+    type: 'sl-config-descriptor';
+};
+type UnknownDescriptor = {
+    type: 'unknown-descriptor';
+};
+export type Descriptor = DecoderConfigDescriptor | SlConfigDescriptor | UnknownDescriptor;
+type DescriptorAndNext = {
+    descriptor: Descriptor | null;
+};
+export declare const processDescriptor: ({ iterator, }: {
+    iterator: BufferIterator;
+}) => DescriptorAndNext;
+export declare const parseDescriptors: (iterator: BufferIterator, maxBytes: number) => Descriptor[];
+export {};

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDescriptors = exports.processDescriptor = void 0;
+const mapToObjectAudioIndicator = (num) => {
+    // https://chromium.googlesource.com/chromium/src/media/+/master/formats/mp4/es_descriptor.h
+    // http://netmedia.zju.edu.cn/multimedia2013/mpeg-4/ISO%20IEC%2014496-1%20MPEG-4%20System%20Standard.pdf
+    // Page 42, table 8
+    if (num === 0x40) {
+        return 'aac';
+    }
+    if (num === 0x6b) {
+        return 'mp3';
+    }
+    return 'unknown';
+};
+const processDescriptor = ({ iterator, }) => {
+    const tag = iterator.getUint8();
+    if (tag === 4) {
+        const size = iterator.getPaddedFourByteNumber();
+        const initialOffset = iterator.counter.getOffset();
+        const objectTypeIndication = iterator.getUint8();
+        const remaining = size - (iterator.counter.getOffset() - initialOffset);
+        iterator.discard(remaining);
+        return {
+            descriptor: {
+                type: 'decoder-config-descriptor',
+                objectTypeIndication: mapToObjectAudioIndicator(objectTypeIndication),
+            },
+        };
+    }
+    if (tag === 6) {
+        const size = iterator.getPaddedFourByteNumber();
+        iterator.discard(size);
+        return {
+            descriptor: {
+                type: 'sl-config-descriptor',
+            },
+        };
+    }
+    return {
+        descriptor: null,
+    };
+};
+exports.processDescriptor = processDescriptor;
+const parseDescriptors = (iterator, maxBytes) => {
+    const descriptors = [];
+    const initialOffset = iterator.counter.getOffset();
+    while (iterator.bytesRemaining() > 0 &&
+        iterator.counter.getOffset() - initialOffset < maxBytes) {
+        const { descriptor } = (0, exports.processDescriptor)({
+            iterator,
+        });
+        if (descriptor) {
+            descriptors.push(descriptor);
+        }
+        else {
+            break;
+        }
+    }
+    return descriptors;
+};
+exports.parseDescriptors = parseDescriptors;

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

@@ -0,0 +1,15 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { Descriptor } from './esds-descriptors';
+export interface EsdsBox {
+    type: 'esds-box';
+    version: number;
+    tag: number;
+    sizeOfInstance: number;
+    esId: number;
+    descriptors: Descriptor[];
+}
+export declare const parseEsds: ({ data, size, fileOffset, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+}) => EsdsBox;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEsds = void 0;
+const esds_descriptors_1 = require("./esds-descriptors");
+const parseEsds = ({ data, size, fileOffset, }) => {
+    const version = data.getUint8();
+    // Flags, we discard them
+    data.discard(3);
+    const tag = data.getUint8();
+    const sizeOfInstance = data.getPaddedFourByteNumber();
+    const esId = data.getUint16();
+    // 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 remainingNow = size - (data.counter.getOffset() - fileOffset);
+    data.discard(remainingNow);
+    return {
+        type: 'esds-box',
+        version,
+        tag,
+        sizeOfInstance,
+        esId,
+        descriptors,
+    };
+};
+exports.parseEsds = parseEsds;

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

@@ -5,7 +5,7 @@ const get_tracks_1 = require("../../../get-tracks");
 const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) => {
     const alreadyHas = (0, get_tracks_1.hasTracks)(existingBoxes);
     if (!alreadyHas) {
-        data.discard(size - 8);
+        data.discard(size - (data.counter.getOffset() - fileOffset));
         return Promise.resolve({
             type: 'mdat-box',
             boxSize: size,
@@ -62,7 +62,6 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) =>
             await options.parserState.onAudioSample(sampleWithIndex.track.trackId, {
                 data: bytes,
                 timestamp: sampleWithIndex.samplePosition.offset,
-                offset: data.counter.getOffset(),
                 trackId: sampleWithIndex.track.trackId,
                 type: sampleWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
             });
@@ -83,6 +82,7 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) =>
             });
         }
         const remaining = size - (data.counter.getOffset() - fileOffset);
+        data.removeBytesRead();
         if (remaining === 0) {
             break;
         }

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

@@ -10,6 +10,7 @@ const parseMoov = async ({ iterator, offset, size, options, }) => {
         initialBoxes: [],
         options,
         continueMdat: false,
+        littleEndian: false,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

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

@@ -9,17 +9,19 @@ export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parse
     parsedBoxes: AnySegment[];
     options: ParserContext;
 }) => Promise<BoxAndNext>;
-export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, }: {
+export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, littleEndian, }: {
     iterator: BufferIterator;
     allowIncompleteBoxes: boolean;
     parsedBoxes: AnySegment[];
     options: ParserContext;
+    littleEndian: boolean;
 }) => Promise<BoxAndNext>;
-export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, }: {
+export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, littleEndian, }: {
     iterator: BufferIterator;
     maxBytes: number;
     allowIncompleteBoxes: boolean;
     initialBoxes: IsoBaseMediaBox[];
     options: ParserContext;
     continueMdat: false | PartialMdatBox;
+    littleEndian: boolean;
 }) => Promise<ParseResult>;

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

@@ -25,7 +25,7 @@ const stsz_1 = require("./stsd/stsz");
 const stts_1 = require("./stsd/stts");
 const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
-const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, }) => {
+const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, littleEndian, }) => {
     const parseChildren = boxType === 'mdia' ||
         boxType === 'minf' ||
         boxType === 'stbl' ||
@@ -40,6 +40,7 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, })
             initialBoxes: [],
             options,
             continueMdat: false,
+            littleEndian,
         });
         if (parsed.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
@@ -76,12 +77,23 @@ const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes,
     };
 };
 exports.parseMdatPartially = parseMdatPartially;
-const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, }) => {
+const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, littleEndian, }) => {
     var _a, _b;
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
-    const boxSize = iterator.getFourByteNumber();
-    if (boxSize === 0) {
+    const boxSizeRaw = iterator.getFourByteNumber(littleEndian);
+    // 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) {
+        iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
+        if (allowIncompleteBoxes) {
+            return {
+                type: 'incomplete',
+            };
+        }
+        throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`);
+    }
+    if (boxSizeRaw === 0) {
         return {
             type: 'complete',
             box: {
@@ -92,41 +104,38 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             skipTo: null,
         };
     }
+    const boxType = iterator.getByteString(4);
+    const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber(littleEndian) : boxSizeRaw;
     if (bytesRemaining < boxSize) {
-        if (bytesRemaining >= 4) {
-            const type = iterator.getByteString(4);
-            iterator.counter.decrement(4);
-            if (type === 'mdat') {
-                const shouldSkip = options.canSkipVideoData || !(0, get_tracks_1.hasTracks)(parsedBoxes);
-                if (shouldSkip) {
-                    const skipTo = fileOffset + boxSize;
-                    const bytesToSkip = skipTo - iterator.counter.getOffset();
-                    // If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
-                    if (bytesToSkip > 1000000) {
-                        return {
-                            type: 'complete',
-                            box: {
-                                type: 'mdat-box',
-                                boxSize,
-                                fileOffset,
-                                samplesProcessed: false,
-                            },
-                            size: boxSize,
-                            skipTo: fileOffset + boxSize,
-                        };
-                    }
-                }
-                else {
-                    iterator.discard(4);
-                    return (0, exports.parseMdatPartially)({
-                        iterator,
-                        boxSize,
-                        fileOffset,
-                        parsedBoxes,
-                        options,
-                    });
+        if (boxType === 'mdat') {
+            const shouldSkip = options.canSkipVideoData || !(0, get_tracks_1.hasTracks)(parsedBoxes);
+            if (shouldSkip) {
+                const skipTo = fileOffset + boxSize;
+                const bytesToSkip = skipTo - iterator.counter.getOffset();
+                // If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
+                if (bytesToSkip > 1000000) {
+                    return {
+                        type: 'complete',
+                        box: {
+                            type: 'mdat-box',
+                            boxSize,
+                            fileOffset,
+                            samplesProcessed: false,
+                        },
+                        size: boxSize,
+                        skipTo: fileOffset + boxSize,
+                    };
                 }
             }
+            else {
+                return (0, exports.parseMdatPartially)({
+                    iterator,
+                    boxSize,
+                    fileOffset,
+                    parsedBoxes,
+                    options,
+                });
+            }
         }
         iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
         if (allowIncompleteBoxes) {
@@ -136,7 +145,6 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         }
         throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSize}. Incomplete boxes are not allowed.`);
     }
-    const boxType = iterator.getByteString(4);
     if (boxType === 'ftyp') {
         const box = (0, ftyp_1.parseFtyp)({ iterator, size: boxSize, offset: fileOffset });
         return {
@@ -202,11 +210,12 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             skipTo: null,
         };
     }
-    if (boxType === 'stco') {
+    if (boxType === 'stco' || boxType === 'co64') {
         const box = (0, stco_1.parseStco)({
             iterator,
             offset: fileOffset,
             size: boxSize,
+            mode64Bit: boxType === 'co64',
         });
         return {
             type: 'complete',
@@ -273,6 +282,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             offset: fileOffset,
             size: boxSize,
             options,
+            littleEndian,
         });
         return {
             type: 'complete',
@@ -417,6 +427,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         iterator,
         bytesRemainingInBox,
         options,
+        littleEndian,
     });
     return {
         type: 'complete',
@@ -432,7 +443,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     };
 };
 exports.processBox = processBox;
-const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, }) => {
+const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, littleEndian, }) => {
     let boxes = initialBoxes;
     const initialOffset = iterator.counter.getOffset();
     const alreadyHasMdat = boxes.find((b) => b.type === 'mdat-box');
@@ -451,6 +462,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                 allowIncompleteBoxes,
                 parsedBoxes: initialBoxes,
                 options,
+                littleEndian,
             });
         if (result.type === 'incomplete') {
             if (Number.isFinite(maxBytes)) {
@@ -467,6 +479,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         initialBoxes: boxes,
                         options,
                         continueMdat: false,
+                        littleEndian,
                     });
                 },
                 skipTo: null,
@@ -484,6 +497,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         initialBoxes: boxes,
                         options,
                         continueMdat: result,
+                        littleEndian,
                     }));
                 },
                 skipTo: null,
@@ -509,12 +523,13 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                         initialBoxes: boxes,
                         options,
                         continueMdat: false,
+                        littleEndian,
                     });
                 },
                 skipTo: result.skipTo,
             };
         }
-        iterator.discardFirstBytes();
+        iterator.removeBytesRead();
     }
     const mdatState = (0, traversal_1.hasSkippedMdatProcessing)(boxes);
     if (mdatState.skipped && !options.canSkipVideoData) {
@@ -529,6 +544,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
                     initialBoxes: boxes,
                     options,
                     continueMdat: false,
+                    littleEndian,
                 });
             },
             skipTo: mdatState.fileOffset,

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

@@ -8,9 +8,10 @@ export interface MebxBox extends BaseBox {
     format: string;
     children: AnySegment[];
 }
-export declare const parseMebx: ({ iterator, offset, size, options, }: {
+export declare const parseMebx: ({ iterator, offset, size, options, littleEndian, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
     options: ParserContext;
+    littleEndian: boolean;
 }) => Promise<MebxBox>;

package/dist/boxes/iso-base-media/stsd/mebx.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
 const process_box_1 = require("../process-box");
-const parseMebx = async ({ iterator, offset, size, options, }) => {
+const parseMebx = async ({ iterator, offset, size, options, littleEndian, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
@@ -13,6 +13,7 @@ const parseMebx = async ({ iterator, offset, size, options, }) => {
         initialBoxes: [],
         options,
         continueMdat: false,
+        littleEndian,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/iso-base-media/stsd/samples.js

@@ -108,6 +108,7 @@ const processSample = async ({ iterator, options, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
+                littleEndian: false,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -153,6 +154,7 @@ const processSample = async ({ iterator, options, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
+                littleEndian: false,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -202,6 +204,7 @@ const processSample = async ({ iterator, options, }) => {
             initialBoxes: [],
             options,
             continueMdat: false,
+            littleEndian: false,
         });
         if (children.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');

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

@@ -5,10 +5,11 @@ export interface StcoBox extends BaseBox {
     version: number;
     flags: number[];
     entryCount: number;
-    entries: number[];
+    entries: (number | bigint)[];
 }
-export declare const parseStco: ({ iterator, offset, size, }: {
+export declare const parseStco: ({ iterator, offset, size, mode64Bit, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
+    mode64Bit: boolean;
 }) => StcoBox;