@remotion/media-parser 4.0.288 → 4.0.289

package/dist/containers/aac/get-seeking-byte.d.ts

@@ -0,0 +1,6 @@
+import type { SeekResolution } from '../../work-on-seek-request';
+import type { AacSeekingHints } from './seeking-hints';
+export declare const getSeekingByteForAac: ({ time, seekingHints, }: {
+    time: number;
+    seekingHints: AacSeekingHints;
+}) => SeekResolution;

package/dist/containers/aac/get-seeking-byte.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteForAac = void 0;
+const getSeekingByteForAac = ({ time, seekingHints, }) => {
+    let bestAudioSample;
+    for (const hint of seekingHints.audioSampleMap) {
+        if (hint.timeInSeconds > time) {
+            continue;
+        }
+        // Everything is a keyframe in flac, so if this sample does not cover the time, it's not a good candidate.
+        // Let's go to the next one. Exception: If we already saw the last sample, we use it so we find can at least
+        // find the closest one.
+        if (hint.timeInSeconds + hint.durationInSeconds < time &&
+            !seekingHints.lastSampleObserved) {
+            continue;
+        }
+        if (!bestAudioSample) {
+            bestAudioSample = hint;
+            continue;
+        }
+        if (bestAudioSample.timeInSeconds < hint.timeInSeconds) {
+            bestAudioSample = hint;
+        }
+    }
+    if (bestAudioSample) {
+        return { type: 'do-seek', byte: bestAudioSample.offset };
+    }
+    return { type: 'valid-but-must-wait' };
+};
+exports.getSeekingByteForAac = getSeekingByteForAac;

package/dist/containers/aac/parse-aac.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAac = void 0;
 const aac_codecprivate_1 = require("../../aac-codecprivate");
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const register_track_1 = require("../../register-track");
 const parseAac = async (state) => {
     const { iterator } = state;
@@ -47,6 +46,10 @@ const parseAac = async (state) => {
     iterator.counter.decrement(iterator.counter.getOffset() - startOffset);
     const data = iterator.getSlice(frameLength);
     if (state.callbacks.tracks.getTracks().length === 0) {
+        state.mediaSection.addMediaSection({
+            start: startOffset,
+            size: state.contentLength - startOffset,
+        });
         await (0, register_track_1.registerAudioTrack)({
             container: 'aac',
             track: {
@@ -71,25 +74,27 @@ const parseAac = async (state) => {
     const duration = 1024 / sampleRate;
     const { index } = state.aac.addSample({ offset: startOffset, size: frameLength });
     const timestamp = (1024 / sampleRate) * index;
+    state.aac.audioSamples.addSample({
+        timeInSeconds: timestamp,
+        offset: startOffset,
+        durationInSeconds: duration,
+    });
     // One ADTS frame contains 1024 samples
-    await (0, emit_audio_sample_1.emitAudioSample)({
-        trackId: 0,
-        audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            sample: {
-                duration,
-                type: 'key',
-                data,
-                offset: startOffset,
-                timescale: 1000000,
-                trackId: 0,
-                cts: timestamp,
-                dts: timestamp,
-                timestamp,
-            },
-            timescale: 1,
-        }),
-        callbacks: state.callbacks,
+    const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        sample: {
+            duration,
+            type: 'key',
+            data,
+            offset: startOffset,
+            timescale: 1000000,
+            trackId: 0,
+            cts: timestamp,
+            dts: timestamp,
+            timestamp,
+        },
+        timescale: 1,
     });
+    await state.callbacks.onAudioSample(0, audioSample);
     return Promise.resolve(null);
 };
 exports.parseAac = parseAac;

package/dist/containers/aac/seeking-hints.d.ts

@@ -0,0 +1,13 @@
+import type { AacState } from '../../state/aac-state';
+import type { AudioSampleOffset } from '../../state/audio-sample-map';
+import type { SamplesObservedState } from '../../state/samples-observed/slow-duration-fps';
+export type AacSeekingHints = {
+    type: 'aac-seeking-hints';
+    audioSampleMap: AudioSampleOffset[];
+    lastSampleObserved: boolean;
+};
+export declare const getSeekingHintsForAac: ({ aacState, samplesObserved, }: {
+    aacState: AacState;
+    samplesObserved: SamplesObservedState;
+}) => AacSeekingHints;
+export declare const setSeekingHintsForAac: () => void;

package/dist/containers/aac/seeking-hints.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForAac = exports.getSeekingHintsForAac = void 0;
+const getSeekingHintsForAac = ({ aacState, samplesObserved, }) => {
+    return {
+        type: 'aac-seeking-hints',
+        audioSampleMap: aacState.audioSamples.getSamples(),
+        lastSampleObserved: samplesObserved.getLastSampleObserved(),
+    };
+};
+exports.getSeekingHintsForAac = getSeekingHintsForAac;
+// TODO: Implement this and maintain index
+const setSeekingHintsForAac = () => { };
+exports.setSeekingHintsForAac = setSeekingHintsForAac;

package/dist/containers/flac/get-channel-count.d.ts

@@ -1,2 +1,2 @@
 import type { BufferIterator } from '../../iterator/buffer-iterator';
-export declare const getChannelCount: (iterator: BufferIterator) => 2 | 8 | 1 | 7 | 3 | 4 | 5 | 6;
+export declare const getChannelCount: (iterator: BufferIterator) => 2 | 1 | 4 | 3 | 5 | 6 | 8 | 7;

package/dist/containers/flac/get-seeking-byte.d.ts

@@ -1,6 +1,5 @@
 import type { FlacSeekingHints } from './seeking-hints';
-export declare const getSeekingByteForFlac: ({ time, seekingHints, endOfFile, }: {
+export declare const getSeekingByteForFlac: ({ time, seekingHints, }: {
     time: number;
     seekingHints: FlacSeekingHints;
-    endOfFile: boolean;
 }) => number | null;

package/dist/containers/flac/get-seeking-byte.js

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSeekingByteForFlac = void 0;
-const getSeekingByteForFlac = ({ time, seekingHints, endOfFile, }) => {
+const getSeekingByteForFlac = ({ time, seekingHints, }) => {
     let bestAudioSample;
     for (const hint of seekingHints.audioSampleMap) {
         if (hint.timeInSeconds > time) {
             continue;
         }
-        if (hint.timeInSeconds + hint.durationInSeconds < time && !endOfFile) {
+        // Everything is a keyframe in flac, so if this sample does not cover the time, it's not a good candidate.
+        // Let's go to the next one. Exception: If we already saw the last sample, we use it so we find can at least
+        // find the closest one.
+        if (hint.timeInSeconds + hint.durationInSeconds < time &&
+            !seekingHints.lastSampleObserved) {
             continue;
         }
         if (!bestAudioSample) {

package/dist/containers/flac/parse-flac-frame.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFlacFrame = exports.parseFrameHeader = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const buffer_iterator_1 = require("../../iterator/buffer-iterator");
 const get_block_size_1 = require("./get-block-size");
 const get_channel_count_1 = require("./get-channel-count");
@@ -81,24 +80,26 @@ const emitSample = async ({ state, data, offset, }) => {
         throw new Error('Cannot determine timestamp');
     }
     const timestamp = (num * streamInfo.maximumBlockSize) / streamInfo.sampleRate;
-    await (0, emit_audio_sample_1.emitAudioSample)({
-        trackId: 0,
-        audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            sample: {
-                data,
-                duration,
-                cts: timestamp,
-                dts: timestamp,
-                timestamp,
-                type: 'key',
-                offset,
-                timescale: 1000000,
-                trackId: 0,
-            },
+    state.flac.audioSamples.addSample({
+        timeInSeconds: timestamp,
+        offset,
+        durationInSeconds: duration,
+    });
+    const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        sample: {
+            data,
+            duration,
+            cts: timestamp,
+            dts: timestamp,
+            timestamp,
+            type: 'key',
+            offset,
             timescale: 1,
-        }),
-        callbacks: state.callbacks,
+            trackId: 0,
+        },
+        timescale: 1,
     });
+    await state.callbacks.onAudioSample(0, audioSample);
     iterator.destroy();
 };
 const parseFlacFrame = async ({ state, iterator, }) => {

package/dist/containers/flac/parse-flac.js

@@ -5,13 +5,7 @@ const skip_1 = require("../../skip");
 const may_skip_video_data_1 = require("../../state/may-skip-video-data");
 const parse_flac_frame_1 = require("./parse-flac-frame");
 const parse_header_1 = require("./parse-header");
-const parse_metadata_1 = require("./parse-metadata");
-const parse_streaminfo_1 = require("./parse-streaminfo");
-const parse_unknown_block_1 = require("./parse-unknown-block");
-const flacTypes = {
-    streaminfo: 0,
-    vorbisComment: 4,
-};
+const parse_meta_1 = require("./parse-meta");
 const parseFlac = ({ iterator, state, }) => {
     const mediaSectionState = state.mediaSection.isCurrentByteInMediaSection(iterator);
     if (mediaSectionState === 'in-section') {
@@ -27,23 +21,9 @@ const parseFlac = ({ iterator, state, }) => {
     iterator.counter.decrement(4);
     // https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
     // section 8.1
-    iterator.startReadingBits();
-    const isLastMetadata = iterator.getBits(1);
-    const metaBlockType = iterator.getBits(7);
-    iterator.stopReadingBits();
-    const size = iterator.getUint24();
-    if (isLastMetadata) {
-        state.mediaSection.addMediaSection({
-            start: iterator.counter.getOffset() + size,
-            size: state.contentLength - iterator.counter.getOffset() - size,
-        });
-    }
-    if (metaBlockType === flacTypes.streaminfo) {
-        return (0, parse_streaminfo_1.parseStreamInfo)({ iterator, state });
-    }
-    if (metaBlockType === flacTypes.vorbisComment) {
-        return (0, parse_metadata_1.parseVorbisComment)({ iterator, state, size });
-    }
-    return (0, parse_unknown_block_1.parseFlacUnkownBlock)({ iterator, state, size });
+    return (0, parse_meta_1.parseMetaBlock)({
+        iterator,
+        state,
+    });
 };
 exports.parseFlac = parseFlac;

package/dist/containers/flac/seeking-hints.d.ts

@@ -1,13 +1,16 @@
 import type { AudioSampleOffset } from '../../state/audio-sample-map';
 import type { FlacState } from '../../state/flac-state';
 import type { ParserState } from '../../state/parser-state';
+import type { SamplesObservedState } from '../../state/samples-observed/slow-duration-fps';
 export type FlacSeekingHints = {
     type: 'flac-seeking-hints';
     audioSampleMap: AudioSampleOffset[];
     blockingBitStrategy: number | null;
+    lastSampleObserved: boolean;
 };
-export declare const getSeekingHintsForFlac: ({ flacState, }: {
+export declare const getSeekingHintsForFlac: ({ flacState, samplesObserved, }: {
     flacState: FlacState;
+    samplesObserved: SamplesObservedState;
 }) => FlacSeekingHints;
 export declare const setSeekingHintsForFlac: ({ hints, state, }: {
     hints: FlacSeekingHints;

package/dist/containers/flac/seeking-hints.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSeekingHintsForFlac = exports.getSeekingHintsForFlac = void 0;
-const getSeekingHintsForFlac = ({ flacState, }) => {
+const getSeekingHintsForFlac = ({ flacState, samplesObserved, }) => {
     var _a;
     return {
         type: 'flac-seeking-hints',
         audioSampleMap: flacState.audioSamples.getSamples(),
         blockingBitStrategy: (_a = flacState.getBlockingBitStrategy()) !== null && _a !== void 0 ? _a : null,
+        lastSampleObserved: samplesObserved.getLastSampleObserved(),
     };
 };
 exports.getSeekingHintsForFlac = getSeekingHintsForFlac;

package/dist/containers/iso-base-media/get-children.d.ts

@@ -2,9 +2,10 @@ import type { BufferIterator } from '../../iterator/buffer-iterator';
 import type { LogLevel } from '../../log';
 import type { IsoBaseMediaBox } from './base-media-box';
 import type { OnlyIfMoovAtomExpected } from './process-box';
-export declare const getIsoBaseMediaChildren: ({ size, iterator, logLevel, onlyIfMoovAtomExpected, }: {
+export declare const getIsoBaseMediaChildren: ({ size, iterator, logLevel, onlyIfMoovAtomExpected, contentLength, }: {
     size: number;
     iterator: BufferIterator;
     logLevel: LogLevel;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected | null;
+    contentLength: number;
 }) => Promise<IsoBaseMediaBox[]>;

package/dist/containers/iso-base-media/get-children.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIsoBaseMediaChildren = void 0;
 const process_box_1 = require("./process-box");
-const getIsoBaseMediaChildren = async ({ size, iterator, logLevel, onlyIfMoovAtomExpected, }) => {
+const getIsoBaseMediaChildren = async ({ size, iterator, logLevel, onlyIfMoovAtomExpected, contentLength, }) => {
     const boxes = [];
     const initial = iterator.counter.getOffset();
     while (iterator.counter.getOffset() < size + initial) {
@@ -11,6 +11,7 @@ const getIsoBaseMediaChildren = async ({ size, iterator, logLevel, onlyIfMoovAto
             logLevel,
             onlyIfMoovAtomExpected,
             onlyIfMdatAtomExpected: null,
+            contentLength,
         });
         if (!parsed) {
             throw new Error('Expected box');

package/dist/containers/iso-base-media/get-mfra-seeking-box.js

@@ -27,6 +27,7 @@ const getMfraSeekingBox = async ({ contentLength, controller, readerInterface, s
         logLevel,
         size: parentSize - 8,
         onlyIfMoovAtomExpected: null,
+        contentLength,
     });
 };
 exports.getMfraSeekingBox = getMfraSeekingBox;

package/dist/containers/iso-base-media/get-moov-atom.js

@@ -51,7 +51,7 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
             return null;
         }
         : null;
-    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), state.contentLength);
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), state.contentLength - endOfMdat);
     while (true) {
         const result = await reader.reader.read();
         if (result.value) {
@@ -82,6 +82,7 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
                 registerAudioSampleCallback: () => Promise.resolve(),
             },
             onlyIfMdatAtomExpected: null,
+            contentLength: state.contentLength - endOfMdat,
         });
         if (box) {
             boxes.push(box);

package/dist/containers/iso-base-media/get-video-codec-from-iso-track.d.ts

@@ -1,2 +1,2 @@
 import type { TrakBox } from './trak/trak';
-export declare const getVideoCodecFromIsoTrak: (trakBox: TrakBox) => "h264" | "av1" | "h265" | "prores";
+export declare const getVideoCodecFromIsoTrak: (trakBox: TrakBox) => "h265" | "h264" | "av1" | "prores";

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMdatSection = void 0;
 const convert_audio_or_video_sample_1 = require("../../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../../emit-audio-sample");
 const get_tracks_1 = require("../../../get-tracks");
 const skip_1 = require("../../../skip");
 const cached_sample_positions_1 = require("../../../state/iso-base-media/cached-sample-positions");
@@ -70,24 +69,21 @@ const parseMdatSection = async (state) => {
         chunkSize,
     });
     if (samplesWithIndex.track.type === 'audio') {
-        await (0, emit_audio_sample_1.emitAudioSample)({
-            trackId: samplesWithIndex.track.trackId,
-            audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-                sample: {
-                    data: bytes,
-                    timestamp: cts,
-                    duration,
-                    cts,
-                    dts,
-                    trackId: samplesWithIndex.track.trackId,
-                    type: isKeyframe ? 'key' : 'delta',
-                    offset,
-                    timescale: samplesWithIndex.track.timescale,
-                },
+        const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            sample: {
+                data: bytes,
+                timestamp: cts,
+                duration,
+                cts,
+                dts,
+                trackId: samplesWithIndex.track.trackId,
+                type: isKeyframe ? 'key' : 'delta',
+                offset,
                 timescale: samplesWithIndex.track.timescale,
-            }),
-            callbacks: state.callbacks,
+            },
+            timescale: samplesWithIndex.track.timescale,
         });
+        await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, audioSample);
     }
     if (samplesWithIndex.track.type === 'video') {
         // https://remotion-assets.s3.eu-central-1.amazonaws.com/example-videos/sei_checkpoint.mp4
@@ -102,24 +98,21 @@ const parseMdatSection = async (state) => {
             const seiType = bytes[5];
             isRecoveryPoint = seiType === 6;
         }
-        await (0, emit_audio_sample_1.emitVideoSample)({
-            trackId: samplesWithIndex.track.trackId,
-            videoSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-                sample: {
-                    data: bytes,
-                    timestamp: cts,
-                    duration,
-                    cts,
-                    dts,
-                    trackId: samplesWithIndex.track.trackId,
-                    type: isKeyframe && !isRecoveryPoint ? 'key' : 'delta',
-                    offset,
-                    timescale: samplesWithIndex.track.timescale,
-                },
+        const videoSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            sample: {
+                data: bytes,
+                timestamp: cts,
+                duration,
+                cts,
+                dts,
+                trackId: samplesWithIndex.track.trackId,
+                type: isKeyframe && !isRecoveryPoint ? 'key' : 'delta',
+                offset,
                 timescale: samplesWithIndex.track.timescale,
-            }),
-            callbacks: state.callbacks,
+            },
+            timescale: samplesWithIndex.track.timescale,
         });
+        await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, videoSample);
     }
     return null;
 };

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

@@ -7,10 +7,11 @@ export interface MoovBox extends BaseBox {
     type: 'moov-box';
     children: AnySegment[];
 }
-export declare const parseMoov: ({ offset, size, onlyIfMoovAtomExpected, iterator, logLevel, }: {
+export declare const parseMoov: ({ offset, size, onlyIfMoovAtomExpected, iterator, logLevel, contentLength, }: {
     offset: number;
     size: number;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected;
     iterator: BufferIterator;
     logLevel: LogLevel;
+    contentLength: number;
 }) => Promise<MoovBox>;

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

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMoov = void 0;
 const get_children_1 = require("../get-children");
-const parseMoov = async ({ offset, size, onlyIfMoovAtomExpected, iterator, logLevel, }) => {
+const parseMoov = async ({ offset, size, onlyIfMoovAtomExpected, iterator, logLevel, contentLength, }) => {
     const children = await (0, get_children_1.getIsoBaseMediaChildren)({
         onlyIfMoovAtomExpected,
         size: size - 8,
         iterator,
         logLevel,
+        contentLength,
     });
     return {
         offset,

package/dist/containers/iso-base-media/parse-boxes.js

@@ -23,6 +23,7 @@ const parseIsoBaseMedia = async (state) => {
         onlyIfMdatAtomExpected: {
             mediaSectionState: state.mediaSection,
         },
+        contentLength: state.contentLength,
     });
     if (result) {
         state.structure.getIsoStructure().boxes.push(result);

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

@@ -17,9 +17,10 @@ export type OnlyIfMoovAtomExpected = {
 export type OnlyIfMdatAtomExpected = {
     mediaSectionState: MediaSectionState;
 };
-export declare const processBox: ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMdatAtomExpected, }: {
+export declare const processBox: ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMdatAtomExpected, contentLength, }: {
     iterator: BufferIterator;
     logLevel: LogLevel;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected | null;
     onlyIfMdatAtomExpected: OnlyIfMdatAtomExpected | null;
+    contentLength: number;
 }) => Promise<BoxAndNext>;

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

@@ -32,7 +32,7 @@ const tfhd_1 = require("./tfhd");
 const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
 const trun_1 = require("./trun");
-const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMdatAtomExpected, }) => {
+const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMdatAtomExpected, contentLength, }) => {
     var _a, _b;
     const fileOffset = iterator.counter.getOffset();
     const { returnToCheckpoint } = iterator.startCheckpoint();
@@ -51,13 +51,14 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
         iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
         throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`);
     }
+    const maxSize = contentLength - startOff;
     const boxType = iterator.getByteString(4, false);
-    const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
-    log_1.Log.trace(logLevel, 'Found box', boxType, boxSize);
+    const boxSizeUnlimited = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
+    const boxSize = Math.min(boxSizeUnlimited, maxSize);
     const headerLength = iterator.counter.getOffset() - startOff;
     if (boxType === 'mdat') {
         if (!onlyIfMdatAtomExpected) {
-            throw new Error('State is required');
+            return null;
         }
         const { mediaSectionState } = onlyIfMdatAtomExpected;
         mediaSectionState.addMediaSection({
@@ -97,6 +98,7 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             size: boxSize,
             iterator,
             logLevel,
+            contentLength,
         });
     }
     if (boxType === 'stsz') {
@@ -148,6 +150,7 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             size: boxSize,
             iterator,
             logLevel,
+            contentLength,
         });
     }
     if (boxType === 'hdlr') {
@@ -192,6 +195,7 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             onlyIfMoovAtomExpected,
             iterator,
             logLevel,
+            contentLength,
         });
         tracks.setIsDone(logLevel);
         return box;
@@ -206,6 +210,7 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             offsetAtStart: fileOffset,
             iterator,
             logLevel,
+            contentLength,
         });
         const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
         if (transformedTrack && transformedTrack.type === 'video') {
@@ -296,6 +301,7 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             size: boxSize - 8,
             logLevel,
             onlyIfMoovAtomExpected,
+            contentLength,
         });
         return {
             type: 'regular-box',

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

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

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
 const get_children_1 = require("../get-children");
-const parseMebx = async ({ offset, size, iterator, logLevel, }) => {
+const parseMebx = async ({ offset, size, iterator, logLevel, contentLength, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
@@ -11,6 +11,7 @@ const parseMebx = async ({ offset, size, iterator, logLevel, }) => {
         size: size - 8,
         logLevel,
         onlyIfMoovAtomExpected: null,
+        contentLength,
     });
     return {
         type: 'mebx-box',

package/dist/containers/iso-base-media/stsd/samples.d.ts

@@ -49,13 +49,15 @@ export type Sample = AudioSample | VideoSample | UnknownSample;
 type FormatBoxAndNext = {
     sample: Sample | null;
 };
-export declare const processIsoFormatBox: ({ iterator, logLevel, }: {
+export declare const processIsoFormatBox: ({ iterator, logLevel, contentLength, }: {
     iterator: BufferIterator;
     logLevel: LogLevel;
+    contentLength: number;
 }) => Promise<FormatBoxAndNext>;
-export declare const parseIsoFormatBoxes: ({ maxBytes, logLevel, iterator, }: {
+export declare const parseIsoFormatBoxes: ({ maxBytes, logLevel, iterator, contentLength, }: {
     maxBytes: number;
     logLevel: LogLevel;
     iterator: BufferIterator;
+    contentLength: number;
 }) => Promise<Sample[]>;
 export {};