@remotion/media-parser 4.0.280 → 4.0.284

package/dist/check-if-done.js

@@ -15,7 +15,7 @@ const checkIfDone = async (state) => {
         return true;
     }
     if (state.iterator.counter.getOffset() === state.contentLength) {
-        if (state.getStructure().type === 'm3u' &&
+        if (state.structure.getStructure().type === 'm3u' &&
             !state.m3u.getAllChunksProcessedOverall()) {
             return false;
         }

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

@@ -5,6 +5,7 @@ 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 work_on_seek_request_1 = require("../../work-on-seek-request");
 const parseAac = async (state) => {
     const { iterator } = state;
     const startOffset = iterator.counter.getOffset();
@@ -48,7 +49,7 @@ const parseAac = async (state) => {
     const data = iterator.getSlice(frameLength);
     if (state.callbacks.tracks.getTracks().length === 0) {
         await (0, register_track_1.registerAudioTrack)({
-            state,
+            workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
             container: 'aac',
             track: {
                 codec: (0, aac_codecprivate_1.mapAudioObjectTypeToCodecString)(audioObjectType),
@@ -62,6 +63,10 @@ const parseAac = async (state) => {
                 trakBox: null,
                 type: 'audio',
             },
+            registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
+            tracks: state.callbacks.tracks,
+            logLevel: state.logLevel,
+            onAudioTrack: state.onAudioTrack,
         });
         state.callbacks.tracks.setIsDone(state.logLevel);
     }
@@ -72,17 +77,21 @@ const parseAac = async (state) => {
     await (0, emit_audio_sample_1.emitAudioSample)({
         trackId: 0,
         audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            duration,
-            type: 'key',
-            data,
-            offset: startOffset,
-            timescale: 1000000,
-            trackId: 0,
-            cts: timestamp,
-            dts: timestamp,
-            timestamp,
-        }, 1),
-        state,
+            sample: {
+                duration,
+                type: 'key',
+                data,
+                offset: startOffset,
+                timescale: 1000000,
+                trackId: 0,
+                cts: timestamp,
+                dts: timestamp,
+                timestamp,
+            },
+            timescale: 1,
+        }),
+        workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
+        callbacks: state.callbacks,
     });
     return Promise.resolve(null);
 };

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) => 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export declare const getChannelCount: (iterator: BufferIterator) => 5 | 1 | 2 | 3 | 4 | 6 | 7 | 8;

package/dist/containers/flac/get-duration-from-flac.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDurationFromFlac = void 0;
 const getDurationFromFlac = (parserState) => {
-    const structure = parserState.getFlacStructure();
+    const structure = parserState.structure.getFlacStructure();
     const streaminfo = structure.boxes.find((b) => b.type === 'flac-streaminfo');
     if (!streaminfo) {
         throw new Error('Streaminfo not found');

package/dist/containers/flac/get-sample-rate.js

@@ -6,7 +6,7 @@ const getSampleRate = (iterator, state) => {
     var _a, _b;
     const mode = iterator.getBits(4);
     if (mode === 0b0000) {
-        const structure = state.getFlacStructure();
+        const structure = state.structure.getFlacStructure();
         const sampleRate = (_b = (_a = structure.boxes.find((box) => box.type === 'flac-streaminfo')) === null || _a === void 0 ? void 0 : _a.sampleRate) !== null && _b !== void 0 ? _b : null;
         if (sampleRate === null) {
             throw new Error('Sample rate not found');

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

@@ -4,6 +4,7 @@ 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 work_on_seek_request_1 = require("../../work-on-seek-request");
 const get_block_size_1 = require("./get-block-size");
 const get_channel_count_1 = require("./get-channel-count");
 const get_sample_rate_1 = require("./get-sample-rate");
@@ -72,7 +73,7 @@ const emitSample = async ({ state, data, offset, }) => {
     }
     const { blockSize, num, sampleRate } = parsed;
     const duration = blockSize / sampleRate;
-    const structure = state.getFlacStructure();
+    const structure = state.structure.getFlacStructure();
     const streamInfo = structure.boxes.find((box) => box.type === 'flac-streaminfo');
     if (!streamInfo) {
         throw new Error('Stream info not found');
@@ -84,17 +85,21 @@ const emitSample = async ({ state, data, offset, }) => {
     await (0, emit_audio_sample_1.emitAudioSample)({
         trackId: 0,
         audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            data,
-            duration,
-            cts: timestamp,
-            dts: timestamp,
-            timestamp,
-            type: 'key',
-            offset,
-            timescale: 1000000,
-            trackId: 0,
-        }, 1),
-        state,
+            sample: {
+                data,
+                duration,
+                cts: timestamp,
+                dts: timestamp,
+                timestamp,
+                type: 'key',
+                offset,
+                timescale: 1000000,
+                trackId: 0,
+            },
+            timescale: 1,
+        }),
+        workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
+        callbacks: state.callbacks,
     });
     iterator.destroy();
 };
@@ -128,7 +133,7 @@ const parseFlacFrame = async ({ state, iterator, }) => {
         throw new Error('Blocking bit should be set');
     }
     iterator.stopReadingBits();
-    const structure = state.getFlacStructure();
+    const structure = state.structure.getFlacStructure();
     const minimumFrameSize = (_b = (_a = structure.boxes.find((b) => b.type === 'flac-streaminfo')) === null || _a === void 0 ? void 0 : _a.minimumFrameSize) !== null && _b !== void 0 ? _b : null;
     if (minimumFrameSize === null) {
         throw new Error('Expected flac-streaminfo');

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

@@ -13,8 +13,8 @@ const flacTypes = {
     vorbisComment: 4,
 };
 const parseFlac = ({ iterator, state, }) => {
-    const videoSectionState = state.videoSection.isInVideoSectionState(iterator);
-    if (videoSectionState === 'in-section') {
+    const mediaSectionState = state.mediaSection.isCurrentByteInMediaSection(iterator);
+    if (mediaSectionState === 'in-section') {
         if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
             return Promise.resolve((0, skip_1.makeSkip)(state.contentLength));
         }
@@ -33,7 +33,7 @@ const parseFlac = ({ iterator, state, }) => {
     iterator.stopReadingBits();
     const size = iterator.getUint24();
     if (isLastMetadata) {
-        state.videoSection.setVideoSection({
+        state.mediaSection.addMediaSection({
             start: iterator.counter.getOffset() + size,
             size: state.contentLength - iterator.counter.getOffset() - size,
         });

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFlacHeader = void 0;
 const parseFlacHeader = ({ state, }) => {
-    state.getFlacStructure().boxes.push({
+    state.structure.getFlacStructure().boxes.push({
         type: 'flac-header',
     });
     return Promise.resolve(null);

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

@@ -17,7 +17,7 @@ const parseVorbisComment = ({ state, iterator, size, }) => {
         const [key, value] = field.split('=');
         box.fields.push({ key: key.toLowerCase(), value, trackId: null });
     }
-    state.getFlacStructure().boxes.push(box);
+    state.structure.getFlacStructure().boxes.push(box);
     expectNoMoreBytes();
     return Promise.resolve(null);
 };

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStreamInfo = void 0;
 const register_track_1 = require("../../register-track");
+const work_on_seek_request_1 = require("../../work-on-seek-request");
 const parseStreamInfo = async ({ iterator, state, }) => {
     const counter = iterator.counter.getOffset();
     const minimumBlockSize = iterator.getUint16();
@@ -30,10 +31,10 @@ const parseStreamInfo = async ({ iterator, state, }) => {
         sampleRate,
         totalSamples,
     };
-    state.getFlacStructure().boxes.push(flacStreamInfo);
+    state.structure.getFlacStructure().boxes.push(flacStreamInfo);
     await (0, register_track_1.registerAudioTrack)({
         container: 'flac',
-        state,
+        workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
         track: {
             codec: 'flac',
             type: 'audio',
@@ -46,6 +47,10 @@ const parseStreamInfo = async ({ iterator, state, }) => {
             trackId: 0,
             trakBox: null,
         },
+        registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
+        tracks: state.callbacks.tracks,
+        logLevel: state.logLevel,
+        onAudioTrack: state.onAudioTrack,
     });
     state.callbacks.tracks.setIsDone(state.logLevel);
     return Promise.resolve(null);

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFlacUnkownBlock = void 0;
 const parseFlacUnkownBlock = ({ iterator, state, size, }) => {
     iterator.discard(size);
-    state.getFlacStructure().boxes.push({
+    state.structure.getFlacStructure().boxes.push({
         type: 'flac-header',
     });
     return Promise.resolve(null);

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

@@ -4,6 +4,7 @@ import type { FtypBox } from './ftyp';
 import type { MdhdBox } from './mdhd';
 import type { HdlrBox } from './meta/hdlr';
 import type { IlstBox } from './meta/ilst';
+import type { TfraBox } from './mfra/tfra';
 import type { MoovBox } from './moov/moov';
 import type { MvhdBox } from './mvhd';
 import type { Av1CBox } from './stsd/av1c';
@@ -34,4 +35,4 @@ export interface RegularBox extends BaseBox {
     type: 'regular-box';
 }
 export type BoxAndNext = IsoBaseMediaBox | null;
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox | TfraBox;

package/dist/containers/iso-base-media/collect-sample-positions-from-moof-boxes.d.ts

@@ -0,0 +1,11 @@
+import type { IsoBaseMediaBox } from './base-media-box';
+import type { TfraBox } from './mfra/tfra';
+import type { TkhdBox } from './tkhd';
+export declare const collectSamplePositionsFromMoofBoxes: ({ moofBoxes, tfraBoxes, tkhdBox, }: {
+    moofBoxes: IsoBaseMediaBox[];
+    tfraBoxes: TfraBox[];
+    tkhdBox: TkhdBox;
+}) => {
+    samplePositions: import("../..").SamplePosition[][];
+    isComplete: boolean;
+};

package/dist/containers/iso-base-media/collect-sample-positions-from-moof-boxes.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSamplePositionsFromMoofBoxes = void 0;
+const samples_from_moof_1 = require("../../samples-from-moof");
+const collectSamplePositionsFromMoofBoxes = ({ moofBoxes, tfraBoxes, tkhdBox, }) => {
+    const isComplete = tfraBoxes.length > 0 &&
+        tfraBoxes.every((t) => t.entries.length === moofBoxes.length);
+    const samplePositions_ = moofBoxes.map((m) => {
+        return (0, samples_from_moof_1.getSamplesFromMoof)({ moofBox: m, trackId: tkhdBox.trackId });
+    });
+    return { samplePositions: samplePositions_, isComplete };
+};
+exports.collectSamplePositionsFromMoofBoxes = collectSamplePositionsFromMoofBoxes;

package/dist/containers/iso-base-media/collect-sample-positions-from-trak.d.ts

@@ -0,0 +1,2 @@
+import type { TrakBox } from './trak/trak';
+export declare const collectSamplePositionsFromTrak: (trakBox: TrakBox) => import("../../get-sample-positions").SamplePosition[];

package/dist/containers/iso-base-media/collect-sample-positions-from-trak.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSamplePositionsFromTrak = void 0;
+const get_audio_codec_1 = require("../../get-audio-codec");
+const get_fps_1 = require("../../get-fps");
+const get_sample_positions_1 = require("../../get-sample-positions");
+const get_sample_positions_from_lpcm_1 = require("../../get-sample-positions-from-lpcm");
+const traversal_1 = require("./traversal");
+const collectSamplePositionsFromTrak = (trakBox) => {
+    const isLpcm = (0, get_audio_codec_1.isLpcmAudioCodec)(trakBox);
+    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
+    if (isLpcm) {
+        return (0, get_sample_positions_from_lpcm_1.getSamplePositionsFromLpcm)(trakBox);
+    }
+    const stszBox = (0, traversal_1.getStszBox)(trakBox);
+    const stcoBox = (0, traversal_1.getStcoBox)(trakBox);
+    const stscBox = (0, traversal_1.getStscBox)(trakBox);
+    const stssBox = (0, traversal_1.getStssBox)(trakBox);
+    const sttsBox = (0, traversal_1.getSttsBox)(trakBox);
+    const cttsBox = (0, traversal_1.getCttsBox)(trakBox);
+    if (!stszBox) {
+        throw new Error('Expected stsz box in trak box');
+    }
+    if (!stcoBox) {
+        throw new Error('Expected stco box in trak box');
+    }
+    if (!stscBox) {
+        throw new Error('Expected stsc box in trak box');
+    }
+    if (!sttsBox) {
+        throw new Error('Expected stts box in trak box');
+    }
+    if (!timescaleAndDuration) {
+        throw new Error('Expected timescale and duration in trak box');
+    }
+    const samplePositions = (0, get_sample_positions_1.getSamplePositions)({
+        stcoBox,
+        stscBox,
+        stszBox,
+        stssBox,
+        sttsBox,
+        cttsBox,
+    });
+    return samplePositions;
+};
+exports.collectSamplePositionsFromTrak = collectSamplePositionsFromTrak;

package/dist/containers/iso-base-media/find-keyframe-before-time.d.ts

@@ -0,0 +1,10 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { LogLevel } from '../../log';
+import type { MediaSection } from '../../state/video-section';
+export declare const findKeyframeBeforeTime: ({ samplePositions, time, timescale, mediaSections, logLevel, }: {
+    samplePositions: SamplePosition[];
+    time: number;
+    timescale: number;
+    mediaSections: MediaSection[];
+    logLevel: LogLevel;
+}) => number | null;

package/dist/containers/iso-base-media/find-keyframe-before-time.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findKeyframeBeforeTime = void 0;
+const log_1 = require("../../log");
+const findKeyframeBeforeTime = ({ samplePositions, time, timescale, mediaSections, logLevel, }) => {
+    let byte = 0;
+    let sam = null;
+    for (const sample of samplePositions) {
+        const ctsInSeconds = sample.cts / timescale;
+        const dtsInSeconds = sample.dts / timescale;
+        if ((ctsInSeconds <= time || dtsInSeconds <= time) &&
+            byte <= sample.offset &&
+            sample.isKeyframe) {
+            byte = sample.offset;
+            sam = sample;
+        }
+    }
+    if (!sam) {
+        throw new Error('No sample found');
+    }
+    const mediaSection = mediaSections.find((section) => sam.offset >= section.start && sam.offset < section.start + section.size);
+    if (!mediaSection) {
+        log_1.Log.trace(logLevel, 'Found a sample, but the offset has not yet been marked as a video section yet. Not yet able to seek, but probably once we have started reading the next box.', sam);
+        return null;
+    }
+    return sam.offset;
+};
+exports.findKeyframeBeforeTime = findKeyframeBeforeTime;

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

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

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

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

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

@@ -6,14 +6,19 @@ const get_sample_positions_from_track_1 = require("./get-sample-positions-from-t
 const traversal_1 = require("./traversal");
 const getKeyframesFromIsoBaseMedia = (state) => {
     const { videoTracks } = (0, get_tracks_1.getTracksFromIsoBaseMedia)(state);
-    const structure = state.getIsoStructure();
-    const moofBox = (0, traversal_1.getMoofBoxes)(structure.boxes);
+    const structure = state.structure.getIsoStructure();
+    const moofBoxes = (0, traversal_1.getMoofBoxes)(structure.boxes);
+    const tfraBoxes = (0, traversal_1.getTfraBoxes)(structure);
     const allSamples = videoTracks.map((t) => {
         const { timescale: ts } = t;
-        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
+        const { samplePositions, isComplete } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
             trakBox: t.trakBox,
-            moofBoxes: moofBox,
+            moofBoxes,
+            tfraBoxes,
         });
+        if (!isComplete) {
+            return [];
+        }
         const keyframes = samplePositions
             .filter((k) => {
             return k.isKeyframe;

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

@@ -0,0 +1,9 @@
+import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { ParseMediaSrc } from '../../options';
+import type { ReaderInterface } from '../../readers/reader';
+export declare const getMfraAtom: ({ src, contentLength, readerInterface, controller, }: {
+    src: ParseMediaSrc;
+    contentLength: number;
+    readerInterface: ReaderInterface;
+    controller: MediaParserController;
+}) => Promise<import("../../readers/reader").Reader>;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMfraAtom = void 0;
+const getMfraAtom = async ({ src, contentLength, readerInterface, controller, }) => {
+    const result = await readerInterface.read({
+        controller,
+        range: [contentLength - 16, contentLength - 1],
+        src,
+    });
+    return result.reader;
+};
+exports.getMfraAtom = getMfraAtom;

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

@@ -0,0 +1,13 @@
+import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { LogLevel } from '../../log';
+import type { ParseMediaSrc } from '../../options';
+import type { ReaderInterface } from '../../readers/reader';
+import type { IsoBaseMediaBox } from './base-media-box';
+export type MfraSeekingBoxOptions = {
+    contentLength: number;
+    controller: MediaParserController;
+    readerInterface: ReaderInterface;
+    src: ParseMediaSrc;
+    logLevel: LogLevel;
+};
+export declare const getMfraSeekingBox: ({ contentLength, controller, readerInterface, src, logLevel, }: MfraSeekingBoxOptions) => Promise<IsoBaseMediaBox[] | null>;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMfraSeekingBox = void 0;
+const get_children_1 = require("./get-children");
+const get_mfra_atom_1 = require("./mfra/get-mfra-atom");
+const get_mfro_atom_1 = require("./mfra/get-mfro-atom");
+const getMfraSeekingBox = async ({ contentLength, controller, readerInterface, src, logLevel, }) => {
+    const parentSize = await (0, get_mfro_atom_1.getMfroAtom)({
+        contentLength,
+        controller,
+        readerInterface,
+        src,
+    });
+    if (!parentSize) {
+        return null;
+    }
+    const mfraAtom = await (0, get_mfra_atom_1.getMfraAtom)({
+        contentLength,
+        controller,
+        readerInterface,
+        src,
+        parentSize,
+    });
+    mfraAtom.discard(8);
+    return (0, get_children_1.getIsoBaseMediaChildren)({
+        iterator: mfraAtom,
+        logLevel,
+        size: parentSize - 8,
+        onlyIfMoovAtomExpected: null,
+    });
+};
+exports.getMfraSeekingBox = getMfraSeekingBox;

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

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMoovAtom = void 0;
+const buffer_iterator_1 = require("../../iterator/buffer-iterator");
 const log_1 = require("../../log");
 const register_track_1 = require("../../register-track");
-const parser_state_1 = require("../../state/parser-state");
+const can_skip_tracks_1 = require("../../state/can-skip-tracks");
+const has_tracks_section_1 = require("../../state/has-tracks-section");
+const structure_1 = require("../../state/structure");
+const work_on_seek_request_1 = require("../../work-on-seek-request");
 const process_box_1 = require("./process-box");
 const traversal_1 = require("./traversal");
-// TODO: await parseMedia({fields: {moovAtom: true}) would be a nicer API
 const getMoovAtom = async ({ endOfMdat, state, }) => {
     const headerSegment = state.mp4HeaderSegment;
     if (headerSegment) {
@@ -23,61 +26,74 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
         range: endOfMdat,
         controller: state.controller,
     });
-    const childState = (0, parser_state_1.makeParserState)({
-        hasAudioTrackHandlers: false,
-        hasVideoTrackHandlers: false,
-        controller: state.controller,
-        onAudioTrack: state.onAudioTrack
-            ? async ({ track, container }) => {
-                await (0, register_track_1.registerAudioTrack)({ state, track, container });
-                return null;
-            }
-            : null,
-        onVideoTrack: state.onVideoTrack
-            ? async ({ track, container }) => {
-                await (0, register_track_1.registerVideoTrack)({ state, track, container });
-                return null;
-            }
-            : null,
-        contentLength: state.contentLength,
-        logLevel: state.logLevel,
-        mode: 'query',
-        readerInterface: state.readerInterface,
-        src: state.src,
-        onDiscardedData: null,
-        selectM3uStreamFn: state.selectM3uStreamFn,
-        selectM3uAssociatedPlaylistsFn: state.selectM3uAssociatedPlaylistsFn,
-        mp4HeaderSegment: state.mp4HeaderSegment,
-        callbacks: {},
-        fieldsInReturnValue: {
-            structure: true,
-        },
-        contentType: null,
-        mimeType: null,
-        name: '',
-        initialReaderInstance: reader,
-    });
+    const onAudioTrack = state.onAudioTrack
+        ? async ({ track, container }) => {
+            await (0, register_track_1.registerAudioTrack)({
+                workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
+                track,
+                container,
+                logLevel: state.logLevel,
+                onAudioTrack: state.onAudioTrack,
+                registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
+                tracks: state.callbacks.tracks,
+            });
+            return null;
+        }
+        : null;
+    const onVideoTrack = state.onVideoTrack
+        ? async ({ track, container }) => {
+            await (0, register_track_1.registerVideoTrack)({
+                workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
+                track,
+                container,
+                logLevel: state.logLevel,
+                onVideoTrack: state.onVideoTrack,
+                registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
+                tracks: state.callbacks.tracks,
+            });
+            return null;
+        }
+        : null;
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), state.contentLength);
     while (true) {
         const result = await reader.reader.read();
         if (result.value) {
-            childState.iterator.addData(result.value);
+            iterator.addData(result.value);
         }
         if (result.done) {
             break;
         }
     }
     const boxes = [];
+    const canSkipTracksState = (0, can_skip_tracks_1.makeCanSkipTracksState)({
+        hasAudioTrackHandlers: false,
+        fields: { structure: true },
+        hasVideoTrackHandlers: false,
+        structure: (0, structure_1.structureState)(),
+    });
+    const tracksState = (0, has_tracks_section_1.makeTracksSectionState)(canSkipTracksState, state.src);
     while (true) {
-        const box = await (0, process_box_1.processBox)(childState);
+        const box = await (0, process_box_1.processBox)({
+            iterator,
+            logLevel: state.logLevel,
+            onlyIfMoovAtomExpected: {
+                tracks: tracksState,
+                isoState: null,
+                workOnSeekRequestOptions: null,
+                onAudioTrack,
+                onVideoTrack,
+                registerVideoSampleCallback: () => Promise.resolve(),
+                registerAudioSampleCallback: () => Promise.resolve(),
+            },
+            onlyIfMdatAtomExpected: null,
+        });
         if (box) {
             boxes.push(box);
         }
-        if (childState.iterator.counter.getOffset() + endOfMdat >
-            state.contentLength) {
+        if (iterator.counter.getOffset() + endOfMdat > state.contentLength) {
             throw new Error('Read past end of file');
         }
-        if (childState.iterator.counter.getOffset() + endOfMdat ===
-            state.contentLength) {
+        if (iterator.counter.getOffset() + endOfMdat === state.contentLength) {
             break;
         }
     }

package/dist/containers/iso-base-media/get-sample-position-bounds.d.ts

@@ -0,0 +1,5 @@
+import type { SamplePosition } from '../../get-sample-positions';
+export declare const getSamplePositionBounds: (samplePositions: SamplePosition[], timescale: number) => {
+    min: number;
+    max: number;
+};