@remotion/media-parser 4.0.286 → 4.0.288

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

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteForFlac = void 0;
+const getSeekingByteForFlac = ({ time, seekingHints, endOfFile, }) => {
+    let bestAudioSample;
+    for (const hint of seekingHints.audioSampleMap) {
+        if (hint.timeInSeconds > time) {
+            continue;
+        }
+        if (hint.timeInSeconds + hint.durationInSeconds < time && !endOfFile) {
+            continue;
+        }
+        if (!bestAudioSample) {
+            bestAudioSample = hint;
+            continue;
+        }
+        if (bestAudioSample.timeInSeconds < hint.timeInSeconds) {
+            bestAudioSample = hint;
+        }
+    }
+    if (bestAudioSample) {
+        return bestAudioSample.offset;
+    }
+    return null;
+};
+exports.getSeekingByteForFlac = getSeekingByteForFlac;

package/dist/containers/flac/parse-meta.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../iterator/buffer-iterator';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseMetaBlock: ({ iterator, state, }: {
+    iterator: BufferIterator;
+    state: ParserState;
+}) => Promise<import("../../parse-result").ParseResult>;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMetaBlock = void 0;
+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 parseMetaBlock = ({ iterator, state, }) => {
+    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 });
+};
+exports.parseMetaBlock = parseMetaBlock;

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

@@ -0,0 +1,15 @@
+import type { AudioSampleOffset } from '../../state/audio-sample-map';
+import type { FlacState } from '../../state/flac-state';
+import type { ParserState } from '../../state/parser-state';
+export type FlacSeekingHints = {
+    type: 'flac-seeking-hints';
+    audioSampleMap: AudioSampleOffset[];
+    blockingBitStrategy: number | null;
+};
+export declare const getSeekingHintsForFlac: ({ flacState, }: {
+    flacState: FlacState;
+}) => FlacSeekingHints;
+export declare const setSeekingHintsForFlac: ({ hints, state, }: {
+    hints: FlacSeekingHints;
+    state: ParserState;
+}) => void;

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

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

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

@@ -1,8 +1,8 @@
-import type { IsoBaseMediaBox } from './base-media-box';
+import type { MoofBox } from '../../state/iso-base-media/precomputed-moof';
 import type { TfraBox } from './mfra/tfra';
 import type { TkhdBox } from './tkhd';
 export declare const collectSamplePositionsFromMoofBoxes: ({ moofBoxes, tfraBoxes, tkhdBox, }: {
-    moofBoxes: IsoBaseMediaBox[];
+    moofBoxes: MoofBox[];
     tfraBoxes: TfraBox[];
     tkhdBox: TkhdBox;
 }) => {

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

@@ -5,9 +5,12 @@ 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 });
+    const samplePositions = moofBoxes.map((m) => {
+        return (0, samples_from_moof_1.getSamplesFromMoof)({
+            moofBox: m,
+            trackId: tkhdBox.trackId,
+        });
     });
-    return { samplePositions: samplePositions_, isComplete };
+    return { samplePositions, isComplete };
 };
 exports.collectSamplePositionsFromMoofBoxes = collectSamplePositionsFromMoofBoxes;

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

@@ -1,17 +1,19 @@
 "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_mp4_1 = require("../../get-sample-positions-from-mp4");
+const should_group_audio_samples_1 = require("./should-group-audio-samples");
 const traversal_1 = require("./traversal");
 const collectSamplePositionsFromTrak = (trakBox) => {
-    const isLpcm = (0, get_audio_codec_1.isLpcmAudioCodec)(trakBox);
+    const shouldGroupSamples = (0, should_group_audio_samples_1.shouldGroupAudioSamples)(trakBox);
     const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
-    const isIn24 = (0, get_audio_codec_1.isIn24AudioCodec)(trakBox);
-    if (isLpcm || isIn24) {
-        return (0, get_sample_positions_from_mp4_1.getGroupedSamplesPositionsFromMp4)(trakBox);
+    if (shouldGroupSamples) {
+        return (0, get_sample_positions_from_mp4_1.getGroupedSamplesPositionsFromMp4)({
+            trakBox,
+            bigEndian: shouldGroupSamples.bigEndian,
+        });
     }
     const stszBox = (0, traversal_1.getStszBox)(trakBox);
     const stcoBox = (0, traversal_1.getStcoBox)(trakBox);

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

@@ -5,7 +5,7 @@ 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 = (state) => {
-    const { videoTracks } = (0, get_tracks_1.getTracksFromIsoBaseMedia)(state);
+    const { videoTracks } = (0, get_tracks_1.getTracksFromIsoBaseMedia)(state, true);
     const structure = state.structure.getIsoStructure();
     const moofBoxes = (0, traversal_1.getMoofBoxes)(structure.boxes);
     const tfraBoxes = (0, traversal_1.getTfraBoxes)(structure);

package/dist/containers/iso-base-media/get-sample-positions-from-track.d.ts

@@ -1,10 +1,10 @@
 import type { SamplePosition } from '../../get-sample-positions';
-import type { IsoBaseMediaBox } from './base-media-box';
+import type { MoofBox } from '../../state/iso-base-media/precomputed-moof';
 import type { TfraBox } from './mfra/tfra';
 import type { TrakBox } from './trak/trak';
 export declare const getSamplePositionsFromTrack: ({ trakBox, moofBoxes, tfraBoxes, }: {
     trakBox: TrakBox;
-    moofBoxes: IsoBaseMediaBox[];
+    moofBoxes: MoofBox[];
     tfraBoxes: TfraBox[];
 }) => {
     samplePositions: SamplePosition[];

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

@@ -0,0 +1,15 @@
+import type { LogLevel } from '../../log';
+import type { IsoBaseMediaStructure } from '../../parse-result';
+import type { IsoBaseMediaSeekingHints } from '../../seeking-hints';
+import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
+import type { StructureState } from '../../state/structure';
+import type { SeekResolution } from '../../work-on-seek-request';
+export declare const getSeekingByteFromIsoBaseMedia: ({ info, time, logLevel, currentPosition, isoState, mp4HeaderSegment, structure, }: {
+    info: IsoBaseMediaSeekingHints;
+    time: number;
+    logLevel: LogLevel;
+    currentPosition: number;
+    isoState: IsoBaseMediaState;
+    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    structure: StructureState;
+}) => Promise<SeekResolution>;

package/dist/containers/iso-base-media/{get-seeking-from-mp4.js → get-seeking-byte.js}

@@ -10,13 +10,25 @@ const get_sample_position_bounds_1 = require("./get-sample-position-bounds");
 const get_sample_positions_from_track_1 = require("./get-sample-positions-from-track");
 const find_best_segment_from_tfra_1 = require("./mfra/find-best-segment-from-tfra");
 const traversal_1 = require("./traversal");
-const getSeekingByteFromIsoBaseMedia = async ({ info, time, logLevel, currentPosition, isoState, }) => {
+const getSeekingByteFromIsoBaseMedia = async ({ info, time, logLevel, currentPosition, isoState, mp4HeaderSegment, structure, }) => {
     const tracks = (0, get_tracks_1.getTracksFromMoovBox)(info.moovBox);
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,
         ...tracks.otherTracks,
     ];
+    const hasMoov = Boolean((0, traversal_1.getMoovBoxFromState)({
+        mp4HeaderSegment,
+        structureState: structure,
+        isoState,
+        mayUsePrecomputed: false,
+    }));
+    if (!hasMoov) {
+        log_1.Log.trace(logLevel, 'No moov box found, must wait');
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
     const firstVideoTrack = allTracks.find((t) => t.type === 'video');
     if (!firstVideoTrack) {
         throw new Error('No video track found');
@@ -52,7 +64,9 @@ const getSeekingByteFromIsoBaseMedia = async ({ info, time, logLevel, currentPos
                 }
             }
         }
-        const atom = await isoState.mfra.triggerLoad();
+        const atom = await (info.mfraAlreadyLoaded
+            ? Promise.resolve(info.mfraAlreadyLoaded)
+            : isoState.mfra.triggerLoad());
         if (atom) {
             const moofOffset = (0, find_best_segment_from_tfra_1.findBestSegmentFromTfra)({
                 mfra: atom,

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

@@ -9,6 +9,7 @@ const cached_sample_positions_1 = require("../../../state/iso-base-media/cached-
 const may_skip_video_data_1 = require("../../../state/may-skip-video-data");
 const video_section_1 = require("../../../state/video-section");
 const get_moov_atom_1 = require("../get-moov-atom");
+const postprocess_bytes_1 = require("./postprocess-bytes");
 const parseMdatSection = async (state) => {
     const mediaSection = (0, video_section_1.getCurrentMediaSection)({
         offset: state.iterator.counter.getOffset(),
@@ -22,13 +23,16 @@ const parseMdatSection = async (state) => {
     if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
         return (0, skip_1.makeSkip)(endOfMdat);
     }
-    const alreadyHas = (0, get_tracks_1.getHasTracks)(state);
-    if (!alreadyHas) {
+    const alreadyHasMoov = (0, get_tracks_1.getHasTracks)(state, true);
+    if (!alreadyHasMoov) {
         const moov = await (0, get_moov_atom_1.getMoovAtom)({
             endOfMdat,
             state,
         });
-        state.iso.moov.setMoovBox(moov);
+        state.iso.moov.setMoovBox({
+            moovBox: moov,
+            precomputed: false,
+        });
         state.callbacks.tracks.setIsDone(state.logLevel);
         state.structure.getIsoStructure().boxes.push(moov);
         return (0, exports.parseMdatSection)(state);
@@ -59,8 +63,12 @@ const parseMdatSection = async (state) => {
     if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
         return null;
     }
-    const bytes = iterator.getSlice(samplesWithIndex.samplePosition.size);
-    const { cts, dts, duration, isKeyframe, offset } = samplesWithIndex.samplePosition;
+    const { cts, dts, duration, isKeyframe, offset, bigEndian, chunkSize } = samplesWithIndex.samplePosition;
+    const bytes = (0, postprocess_bytes_1.postprocessBytes)({
+        bytes: iterator.getSlice(samplesWithIndex.samplePosition.size),
+        bigEndian,
+        chunkSize,
+    });
     if (samplesWithIndex.track.type === 'audio') {
         await (0, emit_audio_sample_1.emitAudioSample)({
             trackId: samplesWithIndex.track.trackId,

package/dist/containers/iso-base-media/mdat/postprocess-bytes.d.ts

@@ -0,0 +1,5 @@
+export declare const postprocessBytes: ({ bytes, bigEndian, chunkSize, }: {
+    bytes: Uint8Array;
+    bigEndian: boolean;
+    chunkSize: number | null;
+}) => Uint8Array<ArrayBufferLike>;

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

@@ -0,0 +1,25 @@
+"use strict";
+// Addressing the issue of audio that is stored in big-endian format!
+// If a "twos" atom is present, that is the case.
+// The samples are stored internally in small chunks, like 4 bytes
+// but WebCodecs does not accept such small chunks.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postprocessBytes = void 0;
+// When entering this function, they are already concatenated, but in litte endian order.
+// This function reverses the bytes in each chunk, so that they are in big-endian order.
+const postprocessBytes = ({ bytes, bigEndian, chunkSize, }) => {
+    if (!bigEndian) {
+        return bytes;
+    }
+    if (chunkSize === null) {
+        return bytes;
+    }
+    const newBuffer = new Uint8Array(bytes);
+    for (let i = 0; i < newBuffer.length; i += chunkSize) {
+        const slice = newBuffer.slice(i, i + chunkSize);
+        slice.reverse();
+        newBuffer.set(slice, i);
+    }
+    return newBuffer;
+};
+exports.postprocessBytes = postprocessBytes;

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

@@ -33,7 +33,7 @@ const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
 const trun_1 = require("./trun");
 const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMdatAtomExpected, }) => {
-    var _a;
+    var _a, _b;
     const fileOffset = iterator.counter.getOffset();
     const { returnToCheckpoint } = iterator.startCheckpoint();
     const bytesRemaining = iterator.bytesRemaining();
@@ -179,7 +179,9 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             iterator.discard(boxSize - 8);
             return null;
         }
-        if (isoState && isoState.moov.getMoovBox()) {
+        if (isoState &&
+            isoState.moov.getMoovBoxAndPrecomputed() &&
+            !((_a = isoState.moov.getMoovBoxAndPrecomputed()) === null || _a === void 0 ? void 0 : _a.precomputed)) {
             log_1.Log.verbose(logLevel, 'Moov box already parsed, skipping');
             iterator.discard(boxSize - 8);
             return null;
@@ -276,7 +278,7 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
         });
     }
     if (boxType === 'moof') {
-        (_a = onlyIfMoovAtomExpected === null || onlyIfMoovAtomExpected === void 0 ? void 0 : onlyIfMoovAtomExpected.isoState) === null || _a === void 0 ? void 0 : _a.mfra.triggerLoad();
+        (_b = onlyIfMoovAtomExpected === null || onlyIfMoovAtomExpected === void 0 ? void 0 : onlyIfMoovAtomExpected.isoState) === null || _b === void 0 ? void 0 : _b.mfra.triggerLoad();
     }
     if (boxType === 'mdia' ||
         boxType === 'minf' ||

package/dist/containers/iso-base-media/{get-seeking-info-from-mp4.d.ts → seeking-hints.d.ts}

@@ -1,11 +1,16 @@
 import type { IsoBaseMediaStructure } from '../../parse-result';
-import type { IsoBaseMediaSeekingInfo } from '../../seeking-info';
+import type { IsoBaseMediaSeekingHints } from '../../seeking-hints';
 import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
+import type { ParserState } from '../../state/parser-state';
 import type { StructureState } from '../../state/structure';
 import type { MediaSectionState } from '../../state/video-section';
-export declare const getSeekingInfoFromMp4: ({ structureState, isoState, mp4HeaderSegment, mediaSectionState, }: {
+export declare const getSeekingHintsFromMp4: ({ structureState, isoState, mp4HeaderSegment, mediaSectionState, }: {
     structureState: StructureState;
     isoState: IsoBaseMediaState;
     mp4HeaderSegment: IsoBaseMediaStructure | null;
     mediaSectionState: MediaSectionState;
-}) => IsoBaseMediaSeekingInfo | null;
+}) => IsoBaseMediaSeekingHints | null;
+export declare const setSeekingHintsForMp4: ({ hints, state, }: {
+    hints: IsoBaseMediaSeekingHints;
+    state: ParserState;
+}) => void;

package/dist/containers/iso-base-media/seeking-hints.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForMp4 = exports.getSeekingHintsFromMp4 = void 0;
+const precomputed_moof_1 = require("../../state/iso-base-media/precomputed-moof");
+const precomputed_tfra_1 = require("../../state/iso-base-media/precomputed-tfra");
+const traversal_1 = require("./traversal");
+const getSeekingHintsFromMp4 = ({ structureState, isoState, mp4HeaderSegment, mediaSectionState, }) => {
+    const structure = structureState.getIsoStructure();
+    const moovAtom = (0, traversal_1.getMoovBoxFromState)({
+        isoState,
+        mp4HeaderSegment,
+        structureState,
+        mayUsePrecomputed: true,
+    });
+    const moofBoxes = (0, precomputed_moof_1.deduplicateMoofBoxesByOffset)([
+        ...isoState.moof.getMoofBoxes(),
+        ...(0, traversal_1.getMoofBoxes)(structure.boxes),
+    ]);
+    const tfraBoxes = (0, precomputed_tfra_1.deduplicateTfraBoxesByOffset)([
+        ...isoState.tfra.getTfraBoxes(),
+        ...(0, traversal_1.getTfraBoxes)(structure),
+    ]);
+    if (!moovAtom) {
+        return null;
+    }
+    return {
+        type: 'iso-base-media-seeking-hints',
+        moovBox: moovAtom,
+        moofBoxes,
+        tfraBoxes,
+        mediaSections: mediaSectionState.getMediaSections(),
+        mfraAlreadyLoaded: isoState.mfra.getIfAlreadyLoaded(),
+    };
+};
+exports.getSeekingHintsFromMp4 = getSeekingHintsFromMp4;
+// eslint-disable-next-line no-empty-pattern
+const setSeekingHintsForMp4 = ({}) => {
+    // state.iso.moov.setMoovBox({
+    //	moovBox: hints.moovBox,
+    //	precomputed: true,
+    // });
+    // 	state.iso.mfra.setFromSeekingHints(hints);
+    // state.iso.moof.setMoofBoxes(hints.moofBoxes);
+    // TODO: Make use of these seeking hints and make tests pass
+    /*
+    //	state.iso.tfra.setTfraBoxes(hints.tfraBoxes);
+
+    for (const mediaSection of hints.mediaSections) {
+        // state.mediaSection.addMediaSection(mediaSection);
+    }
+    */
+};
+exports.setSeekingHintsForMp4 = setSeekingHintsForMp4;

package/dist/containers/iso-base-media/should-group-audio-samples.d.ts

@@ -0,0 +1,6 @@
+import type { TrakBox } from './trak/trak';
+type ShouldGroup = {
+    bigEndian: boolean;
+};
+export declare const shouldGroupAudioSamples: (trakBox: TrakBox) => ShouldGroup | null;
+export {};

package/dist/containers/iso-base-media/should-group-audio-samples.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldGroupAudioSamples = void 0;
+const get_audio_codec_1 = require("../../get-audio-codec");
+const shouldGroupAudioSamples = (trakBox) => {
+    const isLpcm = (0, get_audio_codec_1.isLpcmAudioCodec)(trakBox);
+    const isIn24 = (0, get_audio_codec_1.isIn24AudioCodec)(trakBox);
+    const isTwos = (0, get_audio_codec_1.isTwosAudioCodec)(trakBox);
+    if (isLpcm || isIn24 || isTwos) {
+        return {
+            bigEndian: isTwos || isIn24,
+        };
+    }
+    return null;
+};
+exports.shouldGroupAudioSamples = shouldGroupAudioSamples;

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

@@ -1,5 +1,6 @@
 import type { AnySegment, IsoBaseMediaStructure } from '../../parse-result';
 import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
+import type { MoofBox } from '../../state/iso-base-media/precomputed-moof';
 import type { StructureState } from '../../state/structure';
 import type { IsoBaseMediaBox, RegularBox } from './base-media-box';
 import type { FtypBox } from './ftyp';
@@ -21,12 +22,13 @@ import type { TrakBox } from './trak/trak';
 import type { TrunBox } from './trun';
 export declare const getFtypBox: (segments: AnySegment[]) => FtypBox | null;
 export declare const getMoovFromFromIsoStructure: (structure: IsoBaseMediaStructure) => MoovBox | null;
-export declare const getMoovBoxFromState: ({ structureState, isoState, mp4HeaderSegment, }: {
+export declare const getMoovBoxFromState: ({ structureState, isoState, mp4HeaderSegment, mayUsePrecomputed, }: {
     structureState: StructureState;
     isoState: IsoBaseMediaState;
     mp4HeaderSegment: IsoBaseMediaStructure | null;
+    mayUsePrecomputed: boolean;
 }) => MoovBox | null;
-export declare const getMoofBoxes: (main: AnySegment[]) => IsoBaseMediaBox[];
+export declare const getMoofBoxes: (main: AnySegment[]) => MoofBox[];
 export declare const getMvhdBox: (moovBox: MoovBox) => MvhdBox | null;
 export declare const getTraks: (moovBox: MoovBox) => TrakBox[];
 export declare const getTkhdBox: (trakBox: TrakBox) => TkhdBox | null;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTfraBoxes = exports.getTrunBoxes = exports.getTfhdBox = exports.getTfdtBox = exports.getStssBox = exports.getStscBox = exports.getStszBox = exports.getCttsBox = exports.getSttsBox = exports.getStcoBox = exports.getVideoDescriptors = exports.getStsdBox = exports.getStblBox = exports.getMdhdBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoofBoxes = exports.getMoovBoxFromState = exports.getMoovFromFromIsoStructure = exports.getFtypBox = void 0;
+const precomputed_moof_1 = require("../../state/iso-base-media/precomputed-moof");
 const getFtypBox = (segments) => {
     const ftypBox = segments.find((s) => s.type === 'ftyp-box');
     if (!ftypBox || ftypBox.type !== 'ftyp-box') {
@@ -17,10 +18,10 @@ const getMoovFromFromIsoStructure = (structure) => {
     return moovBox;
 };
 exports.getMoovFromFromIsoStructure = getMoovFromFromIsoStructure;
-const getMoovBoxFromState = ({ structureState, isoState, mp4HeaderSegment, }) => {
-    const got = isoState.moov.getMoovBox();
-    if (got) {
-        return got;
+const getMoovBoxFromState = ({ structureState, isoState, mp4HeaderSegment, mayUsePrecomputed, }) => {
+    const got = isoState.moov.getMoovBoxAndPrecomputed();
+    if (got && (mayUsePrecomputed || !got.precomputed)) {
+        return got.moovBox;
     }
     if (mp4HeaderSegment) {
         return (0, exports.getMoovFromFromIsoStructure)(mp4HeaderSegment);
@@ -31,7 +32,7 @@ const getMoovBoxFromState = ({ structureState, isoState, mp4HeaderSegment, }) =>
 exports.getMoovBoxFromState = getMoovBoxFromState;
 const getMoofBoxes = (main) => {
     const moofBoxes = main.filter((s) => s.type === 'regular-box' && s.boxType === 'moof');
-    return moofBoxes;
+    return moofBoxes.map((m) => (0, precomputed_moof_1.toMoofBox)(m));
 };
 exports.getMoofBoxes = getMoofBoxes;
 const getMvhdBox = (moovBox) => {

package/dist/containers/m3u/iterate-over-segment-files.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.iteratorOverSegmentFiles = void 0;
 const media_parser_controller_1 = require("../../controller/media-parser-controller");
-const forward_controller_1 = require("../../forward-controller");
+const forward_controller_pause_resume_abort_1 = require("../../forward-controller-pause-resume-abort");
 const parse_media_1 = require("../../parse-media");
 const with_resolvers_1 = require("../../with-resolvers");
 const get_chunks_1 = require("./get-chunks");
@@ -13,26 +13,29 @@ const iteratorOverSegmentFiles = async ({ structure, onVideoTrack, m3uState, onA
     let resolver = onInitialProgress;
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     let rejector = (_e) => { };
-    const childController = (0, media_parser_controller_1.mediaParserController)();
-    const forwarded = (0, forward_controller_1.forwardMediaParserController)({
-        childController,
-        parentController,
-    });
-    const makeContinuationFn = () => {
-        return {
-            continue() {
-                const { promise, reject, resolve } = (0, with_resolvers_1.withResolvers)();
-                resolver = resolve;
-                rejector = reject;
-                childController.resume();
-                return promise;
-            },
-            abort() {
-                childController.abort();
-            },
-        };
-    };
     for (const chunk of chunks) {
+        resolver = onInitialProgress;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        rejector = (_e) => { };
+        const childController = (0, media_parser_controller_1.mediaParserController)();
+        const forwarded = (0, forward_controller_pause_resume_abort_1.forwardMediaParserControllerPauseResume)({
+            childController,
+            parentController,
+        });
+        const makeContinuationFn = () => {
+            return {
+                continue() {
+                    const { promise, reject, resolve } = (0, with_resolvers_1.withResolvers)();
+                    resolver = resolve;
+                    rejector = reject;
+                    childController.resume();
+                    return promise;
+                },
+                abort() {
+                    childController.abort();
+                },
+            };
+        };
         const isLastChunk = chunk === chunks[chunks.length - 1];
         await childController._internals.checkForAbortAndPause();
         const src = readerInterface.createAdjacentFileSource(chunk.url, playlistUrl);

package/dist/containers/riff/parse-video-section.js

@@ -8,7 +8,7 @@ const parseMediaSection = async (state) => {
     await (0, parse_movi_1.parseMovi)({
         state,
     });
-    const tracks = (0, get_tracks_1.getTracks)(state);
+    const tracks = (0, get_tracks_1.getTracks)(state, false);
     if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER) &&
         !state.callbacks.tracks.getIsDone()) {
         state.callbacks.tracks.setIsDone(state.logLevel);

package/dist/containers/transport-stream/handle-aac-packet.js

@@ -21,7 +21,10 @@ const handleAacPacket = async ({ streamBuffer, programId, offset, sampleCallback
         const startOffset = makeSamplesStartAtZero
             ? Math.min(streamBuffer.pesHeader.pts, (_a = streamBuffer.pesHeader.dts) !== null && _a !== void 0 ? _a : Infinity)
             : 0;
-        transportStream.startOffset.setOffset(programId, startOffset);
+        transportStream.startOffset.setOffset({
+            trackId: programId,
+            newOffset: startOffset,
+        });
         const track = {
             type: 'audio',
             codecPrivate,

package/dist/containers/transport-stream/handle-avc-packet.js

@@ -24,7 +24,10 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
         const startOffset = makeSamplesStartAtZero
             ? Math.min(streamBuffer.pesHeader.pts, (_a = streamBuffer.pesHeader.dts) !== null && _a !== void 0 ? _a : Infinity)
             : 0;
-        transportStream.startOffset.setOffset(programId, startOffset);
+        transportStream.startOffset.setOffset({
+            trackId: programId,
+            newOffset: startOffset,
+        });
         const track = {
             m3uStreamFormat: null,
             rotation: 0,

package/dist/containers/transport-stream/seeking-hints.d.ts

@@ -0,0 +1,9 @@
+import type { TransportStreamSeekingHints } from '../../seeking-hints';
+import type { TracksState } from '../../state/has-tracks-section';
+import type { ParserState } from '../../state/parser-state';
+import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
+export declare const getSeekingHintsFromTransportStream: (transportStream: TransportStreamState, tracksState: TracksState) => TransportStreamSeekingHints | null;
+export declare const setSeekingHintsForTransportStream: ({ hints, state, }: {
+    hints: TransportStreamSeekingHints;
+    state: ParserState;
+}) => void;