@remotion/media-parser 4.0.241 → 4.0.243

package/dist/add-avc-profile-to-track.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addAvcProfileToTrack = void 0;
-const codec_private_1 = require("./boxes/avc/codec-private");
 const codec_string_1 = require("./boxes/avc/codec-string");
+const create_sps_pps_data_1 = require("./boxes/avc/create-sps-pps-data");
 const addAvcProfileToTrack = (track, avc1Profile) => {
     if (avc1Profile === null) {
         return track;
@@ -10,7 +10,7 @@ const addAvcProfileToTrack = (track, avc1Profile) => {
     return {
         ...track,
         codec: (0, codec_string_1.getCodecStringFromSpsAndPps)(avc1Profile.sps),
-        codecPrivate: (0, codec_private_1.getAvccBoxContent)(avc1Profile),
+        codecPrivate: (0, create_sps_pps_data_1.createSpsPpsData)(avc1Profile),
     };
 };
 exports.addAvcProfileToTrack = addAvcProfileToTrack;

package/dist/boxes/avc/codec-private.js

@@ -7,9 +7,9 @@ const getAvccBoxContent = (avc1Profile) => {
         new Uint8Array([
             // https://gist.github.com/uupaa/8493378ec15f644a3d2b
             1, // version
-            avc1Profile.sps.spsData.level,
-            avc1Profile.sps.spsData.compatibility,
             avc1Profile.sps.spsData.profile,
+            avc1Profile.sps.spsData.compatibility,
+            avc1Profile.sps.spsData.level,
             0xff,
             0xe1,
         ]),

package/dist/boxes/avc/create-sps-pps-data.d.ts

@@ -0,0 +1,2 @@
+import type { SpsAndPps } from '../../state/parser-state';
+export declare const createSpsPpsData: (avc1Profile: SpsAndPps) => Uint8Array;

package/dist/boxes/avc/create-sps-pps-data.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpsPpsData = void 0;
+const make_header_1 = require("../webm/make-header");
+const createSpsPpsData = (avc1Profile) => {
+    return (0, make_header_1.combineUint8Arrays)([
+        new Uint8Array([
+            // https://gist.github.com/uupaa/8493378ec15f644a3d2b
+            1, // version
+            avc1Profile.sps.spsData.profile,
+            avc1Profile.sps.spsData.compatibility,
+            avc1Profile.sps.spsData.level,
+            0xff,
+            0xe1,
+        ]),
+        // sequence parameter set length
+        (0, make_header_1.serializeUint16)(avc1Profile.sps.sps.length),
+        // sequence parameter set
+        avc1Profile.sps.sps,
+        // num of PPS
+        new Uint8Array([0x01]),
+        // picture parameter set length
+        (0, make_header_1.serializeUint16)(avc1Profile.pps.pps.length),
+        // PPS
+        avc1Profile.pps.pps,
+    ]);
+};
+exports.createSpsPpsData = createSpsPpsData;

package/dist/boxes/iso-base-media/get-keyframes.d.ts

@@ -0,0 +1,3 @@
+import type { MediaParserKeyframe } from '../../options';
+import type { IsoBaseMediaStructure } from '../../parse-result';
+export declare const getKeyframesFromIsoBaseMedia: (structure: IsoBaseMediaStructure) => MediaParserKeyframe[];

package/dist/boxes/iso-base-media/get-keyframes.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeyframesFromIsoBaseMedia = void 0;
+const get_tracks_1 = require("../../get-tracks");
+const get_sample_positions_from_track_1 = require("./get-sample-positions-from-track");
+const traversal_1 = require("./traversal");
+const getKeyframesFromIsoBaseMedia = (structure) => {
+    const { videoTracks } = (0, get_tracks_1.getTracksFromIsoBaseMedia)(structure.boxes);
+    const moofBox = (0, traversal_1.getMoofBox)(structure.boxes);
+    const allSamples = videoTracks.map((t) => {
+        const { timescale: ts } = t;
+        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)(t.trakBox, moofBox);
+        const keyframes = samplePositions
+            .filter((k) => {
+            return k.isKeyframe;
+        })
+            .map((k) => {
+            return {
+                trackId: t.trackId,
+                presentationTimeInSeconds: k.cts / ts,
+                decodingTimeInSeconds: k.dts / ts,
+                positionInBytes: k.offset,
+                sizeInBytes: k.size,
+            };
+        });
+        return keyframes;
+    });
+    return allSamples.flat();
+};
+exports.getKeyframesFromIsoBaseMedia = getKeyframesFromIsoBaseMedia;

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

@@ -1,6 +1,6 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { IsoBaseMediaBox } from '../../../parse-result';
-import type { ParserContext } from '../../../parser-context';
+import type { ParserState } from '../../../state/parser-state';
 type MdatStatus = {
     status: 'samples-buffered';
 } | {
@@ -13,12 +13,12 @@ export type MdatBox = {
     boxSize: number;
     fileOffset: number;
 } & MdatStatus;
-export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, options, signal, maySkipSampleProcessing, }: {
+export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, state, signal, maySkipSampleProcessing, }: {
     data: BufferIterator;
     size: number;
     fileOffset: number;
     existingBoxes: IsoBaseMediaBox[];
-    options: ParserContext;
+    state: ParserState;
     signal: AbortSignal | null;
     maySkipSampleProcessing: boolean;
 }) => Promise<MdatBox>;

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

@@ -5,11 +5,11 @@ const convert_audio_or_video_sample_1 = require("../../../convert-audio-or-video
 const get_tracks_1 = require("../../../get-tracks");
 const get_sample_positions_from_track_1 = require("../get-sample-positions-from-track");
 const traversal_1 = require("../traversal");
-const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signal, maySkipSampleProcessing, }) => {
+const parseMdat = async ({ data, size, fileOffset, existingBoxes, state, signal, maySkipSampleProcessing, }) => {
     const alreadyHas = (0, get_tracks_1.hasTracks)({
         type: 'iso-base-media',
         boxes: existingBoxes,
-    }, options.parserState);
+    }, state);
     if (!alreadyHas) {
         if (maySkipSampleProcessing) {
             data.discard(size - (data.counter.getOffset() - fileOffset));
@@ -29,7 +29,7 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signa
             fileOffset,
         });
     }
-    const tracks = (0, get_tracks_1.getTracks)({ type: 'iso-base-media', boxes: existingBoxes }, options.parserState);
+    const tracks = (0, get_tracks_1.getTracks)({ type: 'iso-base-media', boxes: existingBoxes }, state);
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,
@@ -79,7 +79,7 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signa
         const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
         const { cts, dts, duration } = samplesWithIndex.samplePosition;
         if (samplesWithIndex.track.type === 'audio') {
-            await options.parserState.onAudioSample(samplesWithIndex.track.trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
                 data: bytes,
                 timestamp: cts,
                 duration,
@@ -87,10 +87,12 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signa
                 dts,
                 trackId: samplesWithIndex.track.trackId,
                 type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
+                offset: samplesWithIndex.samplePosition.offset,
+                timescale: samplesWithIndex.track.timescale,
             }, samplesWithIndex.track.timescale));
         }
         if (samplesWithIndex.track.type === 'video') {
-            await options.parserState.onVideoSample(samplesWithIndex.track.trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
                 data: bytes,
                 timestamp: cts,
                 duration,
@@ -98,6 +100,8 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signa
                 dts,
                 trackId: samplesWithIndex.track.trackId,
                 type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
+                offset: samplesWithIndex.samplePosition.offset,
+                timescale: samplesWithIndex.track.timescale,
             }, samplesWithIndex.track.timescale));
         }
         const remaining = size - (data.counter.getOffset() - fileOffset);

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

@@ -2,17 +2,17 @@ import type { BufferIterator } from '../../../buffer-iterator';
 import type { LogLevel } from '../../../log';
 import type { Options, ParseMediaFields } from '../../../options';
 import type { AnySegment } from '../../../parse-result';
-import type { ParserContext } from '../../../parser-context';
+import type { ParserState } from '../../../state/parser-state';
 import type { BaseBox } from '../base-type';
 export interface MoovBox extends BaseBox {
     type: 'moov-box';
     children: AnySegment[];
 }
-export declare const parseMoov: ({ iterator, offset, size, options, signal, logLevel, fields, }: {
+export declare const parseMoov: ({ iterator, offset, size, state, signal, logLevel, fields, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
-    options: ParserContext;
+    state: ParserState;
     signal: AbortSignal | null;
     logLevel: LogLevel;
     fields: Options<ParseMediaFields>;

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

@@ -2,13 +2,14 @@
 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, logLevel, fields, }) => {
+const parseMoov = async ({ iterator, offset, size, state, signal, logLevel, fields, }) => {
+    const boxes = [];
     const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
         iterator,
         maxBytes: size - (iterator.counter.getOffset() - offset),
         allowIncompleteBoxes: false,
-        initialBoxes: [],
-        options,
+        initialBoxes: boxes,
+        state,
         continueMdat: false,
         signal,
         logLevel,
@@ -21,7 +22,7 @@ const parseMoov = async ({ iterator, offset, size, options, signal, logLevel, fi
         offset,
         boxSize: size,
         type: 'moov-box',
-        children: children.segments.boxes,
+        children: boxes,
     };
 };
 exports.parseMoov = parseMoov;

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

@@ -1,34 +1,34 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { LogLevel } from '../../log';
 import type { Options, ParseMediaFields } from '../../options';
-import type { IsoBaseMediaBox, IsoBaseMediaStructure, ParseResult } from '../../parse-result';
+import type { IsoBaseMediaBox, ParseResult } from '../../parse-result';
 import type { BoxAndNext, PartialMdatBox } from '../../parse-video';
-import type { ParserContext } from '../../parser-context';
-export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parsedBoxes, options, signal, }: {
+import type { ParserState } from '../../state/parser-state';
+export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parsedBoxes, state, signal, }: {
     iterator: BufferIterator;
     boxSize: number;
     fileOffset: number;
     parsedBoxes: IsoBaseMediaBox[];
-    options: ParserContext;
+    state: ParserState;
     signal: AbortSignal | null;
 }) => Promise<BoxAndNext>;
-export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, signal, logLevel, fields, }: {
+export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, state, signal, logLevel, fields, }: {
     iterator: BufferIterator;
     allowIncompleteBoxes: boolean;
     parsedBoxes: IsoBaseMediaBox[];
-    options: ParserContext;
+    state: ParserState;
     signal: AbortSignal | null;
     logLevel: LogLevel;
     fields: Options<ParseMediaFields>;
 }) => Promise<BoxAndNext>;
-export declare const parseIsoBaseMediaBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, fields, }: {
+export declare const parseIsoBaseMediaBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }: {
     iterator: BufferIterator;
     maxBytes: number;
     allowIncompleteBoxes: boolean;
     initialBoxes: IsoBaseMediaBox[];
-    options: ParserContext;
+    state: ParserState;
     continueMdat: false | PartialMdatBox;
     signal: AbortSignal | null;
     logLevel: LogLevel;
     fields: Options<ParseMediaFields>;
-}) => Promise<ParseResult<IsoBaseMediaStructure>>;
+}) => Promise<ParseResult>;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseIsoBaseMediaBoxes = exports.processBox = exports.parseMdatPartially = void 0;
 const get_tracks_1 = require("../../get-tracks");
 const has_all_info_1 = require("../../has-all-info");
+const may_skip_video_data_1 = require("../../may-skip-video-data/may-skip-video-data");
 const register_track_1 = require("../../register-track");
 const esds_1 = require("./esds/esds");
 const ftyp_1 = require("./ftyp");
@@ -33,7 +34,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, signal, logLevel, fields, }) => {
+const getChildren = async ({ boxType, iterator, bytesRemainingInBox, state, signal, logLevel, fields, }) => {
     const parseChildren = boxType === 'mdia' ||
         boxType === 'minf' ||
         boxType === 'stbl' ||
@@ -45,13 +46,14 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, si
         boxType === 'traf' ||
         boxType === 'stsb';
     if (parseChildren) {
+        const boxes = [];
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         const parsed = await (0, exports.parseIsoBaseMediaBoxes)({
             iterator,
             maxBytes: bytesRemainingInBox,
             allowIncompleteBoxes: false,
-            initialBoxes: [],
-            options,
+            initialBoxes: boxes,
+            state,
             continueMdat: false,
             signal,
             logLevel,
@@ -60,7 +62,7 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, si
         if (parsed.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
         }
-        return parsed.segments.boxes;
+        return boxes;
     }
     if (bytesRemainingInBox < 0) {
         throw new Error('Box size is too big ' + JSON.stringify({ boxType }));
@@ -68,15 +70,15 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, si
     iterator.discard(bytesRemainingInBox);
     return [];
 };
-const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes, options, signal, }) => {
+const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes, state, signal, }) => {
     const box = await (0, mdat_1.parseMdat)({
         data: iterator,
         size: boxSize,
         fileOffset,
         existingBoxes: parsedBoxes,
-        options,
+        state,
         signal,
-        maySkipSampleProcessing: options.supportsContentRange,
+        maySkipSampleProcessing: state.supportsContentRange,
     });
     if ((box.status === 'samples-processed' || box.status === 'samples-buffered') &&
         box.fileOffset + boxSize === iterator.counter.getOffset()) {
@@ -94,7 +96,7 @@ const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes,
     };
 };
 exports.parseMdatPartially = parseMdatPartially;
-const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, signal, logLevel, fields, }) => {
+const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state, signal, logLevel, fields, }) => {
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSizeRaw = iterator.getFourByteNumber();
@@ -125,9 +127,9 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     if (bytesRemaining < boxSize) {
         if (boxType === 'mdat') {
             // Check if the moov atom is at the end
-            const shouldSkip = options.parserState.maySkipVideoData() ||
-                (!(0, get_tracks_1.hasTracks)({ type: 'iso-base-media', boxes: parsedBoxes }, options.parserState) &&
-                    options.supportsContentRange);
+            const shouldSkip = (0, may_skip_video_data_1.maySkipVideoData)({ state }) ||
+                (!(0, get_tracks_1.hasTracks)({ type: 'iso-base-media', boxes: parsedBoxes }, state) &&
+                    state.supportsContentRange);
             if (shouldSkip) {
                 const skipTo = fileOffset + boxSize;
                 const bytesToSkip = skipTo - iterator.counter.getOffset();
@@ -152,7 +154,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
                     boxSize,
                     fileOffset,
                     parsedBoxes,
-                    options,
+                    state,
                     signal,
                 });
             }
@@ -227,7 +229,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             iterator,
             offset: fileOffset,
             size: boxSize,
-            options,
+            state,
             signal,
             fields,
         });
@@ -322,7 +324,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             iterator,
             offset: fileOffset,
             size: boxSize,
-            options,
+            state,
             signal,
             fields,
         });
@@ -369,12 +371,12 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             iterator,
             offset: fileOffset,
             size: boxSize,
-            options,
+            state,
             signal,
             logLevel,
             fields,
         });
-        options.parserState.tracks.setIsDone();
+        state.callbacks.tracks.setIsDone();
         return {
             type: 'complete',
             box,
@@ -387,7 +389,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             data: iterator,
             size: boxSize,
             offsetAtStart: fileOffset,
-            options,
+            state,
             signal,
             logLevel,
             fields,
@@ -395,7 +397,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
         if (transformedTrack) {
             await (0, register_track_1.registerTrack)({
-                options,
+                state,
                 track: transformedTrack,
                 container: 'mp4',
             });
@@ -502,9 +504,9 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             size: boxSize,
             fileOffset,
             existingBoxes: parsedBoxes,
-            options,
+            state,
             signal,
-            maySkipSampleProcessing: options.supportsContentRange,
+            maySkipSampleProcessing: state.supportsContentRange,
         });
         if (box === null) {
             throw new Error('Unexpected null');
@@ -521,7 +523,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         boxType,
         iterator,
         bytesRemainingInBox,
-        options,
+        state,
         signal,
         logLevel,
         fields,
@@ -540,13 +542,11 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     };
 };
 exports.processBox = processBox;
-const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, fields, }) => {
-    const structure = {
-        type: 'iso-base-media',
-        boxes: initialBoxes,
-    };
+const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }) => {
+    var _a;
     const initialOffset = iterator.counter.getOffset();
-    const alreadyHasMdat = structure.boxes.find((b) => b.type === 'mdat-box');
+    const alreadyHasMdat = (_a = state.structure
+        .getStructureOrNull()) === null || _a === void 0 ? void 0 : _a.boxes.find((b) => b.type === 'mdat-box');
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
         const result = continueMdat
@@ -555,14 +555,14 @@ const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes
                 boxSize: continueMdat.boxSize,
                 fileOffset: continueMdat.fileOffset,
                 parsedBoxes: initialBoxes,
-                options,
+                state,
                 signal,
             })
             : await (0, exports.processBox)({
                 iterator,
                 allowIncompleteBoxes,
                 parsedBoxes: initialBoxes,
-                options,
+                state,
                 signal,
                 logLevel,
                 fields,
@@ -573,14 +573,13 @@ const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes
             }
             return {
                 status: 'incomplete',
-                segments: structure,
                 continueParsing: () => {
                     return (0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: structure.boxes,
-                        options,
+                        initialBoxes,
+                        state,
                         continueMdat: false,
                         signal,
                         logLevel,
@@ -593,14 +592,13 @@ const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes
         if (result.type === 'partial-mdat-box') {
             return {
                 status: 'incomplete',
-                segments: structure,
                 continueParsing: () => {
                     return Promise.resolve((0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: structure.boxes,
-                        options,
+                        initialBoxes,
+                        state,
                         continueMdat: result,
                         signal,
                         logLevel,
@@ -611,8 +609,8 @@ const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes
             };
         }
         if (result.box.type === 'mdat-box' && alreadyHasMdat) {
-            structure.boxes = structure.boxes.filter((b) => b.type !== 'mdat-box');
-            structure.boxes.push(result.box);
+            initialBoxes = initialBoxes.filter((b) => b.type !== 'mdat-box');
+            initialBoxes.push(result.box);
             iterator.allowDiscard();
             if (result.box.status !== 'samples-processed') {
                 throw new Error('unexpected');
@@ -620,28 +618,26 @@ const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes
             break;
         }
         else {
-            structure.boxes.push(result.box);
-            if ((0, has_all_info_1.hasAllInfo)({ fields, state: options.parserState, structure })) {
+            initialBoxes.push(result.box);
+            if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
                 return {
                     status: 'done',
-                    segments: structure,
                 };
             }
         }
         if (result.skipTo !== null) {
-            if (!options.supportsContentRange) {
+            if (!state.supportsContentRange) {
                 throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
             }
             return {
                 status: 'incomplete',
-                segments: structure,
                 continueParsing: () => {
                     return (0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: structure.boxes,
-                        options,
+                        initialBoxes,
+                        state,
                         continueMdat: false,
                         signal,
                         logLevel,
@@ -654,14 +650,13 @@ const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes
         if (iterator.bytesRemaining() < 0) {
             return {
                 status: 'incomplete',
-                segments: structure,
                 continueParsing: () => {
                     return (0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: structure.boxes,
-                        options,
+                        initialBoxes,
+                        state,
                         continueMdat: false,
                         signal,
                         logLevel,
@@ -673,16 +668,14 @@ const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes
         }
         iterator.removeBytesRead();
     }
-    const mdatState = (0, traversal_1.getMdatBox)(structure.boxes);
+    const mdatState = (0, traversal_1.getMdatBox)(initialBoxes);
     const skipped = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-skipped' &&
-        !options.parserState.maySkipVideoData() &&
-        options.supportsContentRange;
-    const buffered = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-buffered' &&
-        !options.parserState.maySkipVideoData();
+        !(0, may_skip_video_data_1.maySkipVideoData)({ state }) &&
+        state.supportsContentRange;
+    const buffered = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-buffered' && !(0, may_skip_video_data_1.maySkipVideoData)({ state });
     if (skipped || buffered) {
         return {
             status: 'incomplete',
-            segments: structure,
             continueParsing: () => {
                 if (buffered) {
                     iterator.skipTo(mdatState.fileOffset, false);
@@ -691,8 +684,8 @@ const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes
                     iterator,
                     maxBytes,
                     allowIncompleteBoxes: false,
-                    initialBoxes: structure.boxes,
-                    options,
+                    initialBoxes,
+                    state,
                     continueMdat: false,
                     signal,
                     logLevel,
@@ -704,7 +697,6 @@ const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes
     }
     return {
         status: 'done',
-        segments: structure,
     };
 };
 exports.parseIsoBaseMediaBoxes = parseIsoBaseMediaBoxes;

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

@@ -1,7 +1,7 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { Options, ParseMediaFields } from '../../../options';
 import type { AnySegment } from '../../../parse-result';
-import type { ParserContext } from '../../../parser-context';
+import type { ParserState } from '../../../state/parser-state';
 import type { BaseBox } from '../base-type';
 export interface MebxBox extends BaseBox {
     type: 'mebx-box';
@@ -9,11 +9,11 @@ export interface MebxBox extends BaseBox {
     format: string;
     children: AnySegment[];
 }
-export declare const parseMebx: ({ iterator, offset, size, options, signal, fields, }: {
+export declare const parseMebx: ({ iterator, offset, size, state, signal, fields, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
-    options: ParserContext;
+    state: ParserState;
     signal: AbortSignal | null;
     fields: Options<ParseMediaFields>;
 }) => Promise<MebxBox>;

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

@@ -2,16 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
 const process_box_1 = require("../process-box");
-const parseMebx = async ({ iterator, offset, size, options, signal, fields, }) => {
+const parseMebx = async ({ iterator, offset, size, state, signal, fields, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
+    const boxes = [];
     const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
         iterator,
         maxBytes: iterator.counter.getOffset() - offset,
         allowIncompleteBoxes: false,
-        initialBoxes: [],
-        options,
+        initialBoxes: boxes,
+        state,
         continueMdat: false,
         signal,
         logLevel: 'info',
@@ -26,7 +27,7 @@ const parseMebx = async ({ iterator, offset, size, options, signal, fields, }) =
         offset,
         dataReferenceIndex,
         format: 'mebx',
-        children: children.segments.boxes,
+        children: boxes,
     };
 };
 exports.parseMebx = parseMebx;