@remotion/media-parser 4.0.286 → 4.0.287

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/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/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

@@ -22,13 +22,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);

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,52 @@
+"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;
+const setSeekingHintsForMp4 = ({ hints, state, }) => {
+    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/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;

package/dist/containers/transport-stream/seeking-hints.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForTransportStream = exports.getSeekingHintsFromTransportStream = void 0;
+const getSeekingHintsFromTransportStream = (transportStream, tracksState) => {
+    const firstVideoTrack = tracksState
+        .getTracks()
+        .find((t) => t.type === 'video');
+    if (!firstVideoTrack) {
+        return null;
+    }
+    return {
+        type: 'transport-stream-seeking-hints',
+        observedPesHeaders: transportStream.observedPesHeaders.getPesKeyframeHeaders(),
+        ptsStartOffset: transportStream.startOffset.getOffset(firstVideoTrack.trackId),
+        firstVideoTrackId: firstVideoTrack.trackId,
+    };
+};
+exports.getSeekingHintsFromTransportStream = getSeekingHintsFromTransportStream;
+const setSeekingHintsForTransportStream = ({ hints, state, }) => {
+    state.transportStream.observedPesHeaders.setPesKeyframesFromSeekingHints(hints);
+    state.transportStream.startOffset.setOffset({
+        trackId: hints.firstVideoTrackId,
+        newOffset: hints.ptsStartOffset,
+    });
+};
+exports.setSeekingHintsForTransportStream = setSeekingHintsForTransportStream;

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

@@ -1,7 +1,7 @@
-import type { WavSeekingInfo } from '../../seeking-info';
+import type { WavSeekingHints } from '../../seeking-hints';
 import type { SeekResolution } from '../../work-on-seek-request';
 export declare const WAVE_SAMPLES_PER_SECOND = 25;
 export declare const getSeekingByteFromWav: ({ info, time, }: {
-    info: WavSeekingInfo;
+    info: WavSeekingHints;
     time: number;
 }) => Promise<SeekResolution>;

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

@@ -4,12 +4,12 @@ exports.getSeekingByteFromWav = exports.WAVE_SAMPLES_PER_SECOND = void 0;
 exports.WAVE_SAMPLES_PER_SECOND = 25;
 const getSeekingByteFromWav = ({ info, time, }) => {
     const bytesPerSecond = info.sampleRate * info.blockAlign;
-    const durationInSeconds = info.mediaSections.size / bytesPerSecond;
+    const durationInSeconds = info.mediaSection.size / bytesPerSecond;
     const timeRoundedDown = Math.floor(Math.min(time, durationInSeconds - 0.0000001) * exports.WAVE_SAMPLES_PER_SECOND) / exports.WAVE_SAMPLES_PER_SECOND;
     const byteOffset = bytesPerSecond * timeRoundedDown;
     return Promise.resolve({
         type: 'do-seek',
-        byte: byteOffset + info.mediaSections.start,
+        byte: byteOffset + info.mediaSection.start,
     });
 };
 exports.getSeekingByteFromWav = getSeekingByteFromWav;

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

@@ -0,0 +1,12 @@
+import type { WavSeekingHints } from '../../seeking-hints';
+import type { ParserState } from '../../state/parser-state';
+import type { MediaSectionState } from '../../state/video-section';
+import type { WavStructure } from './types';
+export declare const getSeekingHintsFromWav: ({ structure, mediaSectionState, }: {
+    structure: WavStructure;
+    mediaSectionState: MediaSectionState;
+}) => WavSeekingHints | null;
+export declare const setSeekingHintsForWav: ({ hints, state, }: {
+    hints: WavSeekingHints;
+    state: ParserState;
+}) => void;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForWav = exports.getSeekingHintsFromWav = void 0;
+const getSeekingHintsFromWav = ({ structure, mediaSectionState, }) => {
+    const fmtBox = structure.boxes.find((box) => box.type === 'wav-fmt');
+    if (!fmtBox) {
+        return null;
+    }
+    const mediaSection = mediaSectionState.getMediaSections();
+    if (mediaSection.length !== 1) {
+        return null;
+    }
+    return {
+        type: 'wav-seeking-hints',
+        sampleRate: fmtBox.sampleRate,
+        blockAlign: fmtBox.blockAlign,
+        mediaSection: mediaSection[0],
+    };
+};
+exports.getSeekingHintsFromWav = getSeekingHintsFromWav;
+const setSeekingHintsForWav = ({ hints, state, }) => {
+    // abstaining from setting fmt box, usually it is at the very beginning
+    state.mediaSection.addMediaSection(hints.mediaSection);
+};
+exports.setSeekingHintsForWav = setSeekingHintsForWav;

package/dist/containers/webm/seek/get-seeking-byte.d.ts

@@ -1,14 +1,12 @@
 import type { LogLevel } from '../../../log';
-import type { WebmSeekingInfo } from '../../../seeking-info';
-import type { KeyframesState } from '../../../state/keyframes';
+import type { WebmSeekingHints } from '../../../seeking-hints';
 import type { WebmState } from '../../../state/matroska/webm';
 import type { MediaSectionState } from '../../../state/video-section';
 import type { SeekResolution } from '../../../work-on-seek-request';
-export declare const getSeekingByteFromMatroska: ({ time, webmState, info, logLevel, mediaSection, keyframes, }: {
+export declare const getSeekingByteFromMatroska: ({ time, webmState, info, logLevel, mediaSection, }: {
     time: number;
     webmState: WebmState;
-    info: WebmSeekingInfo;
+    info: WebmSeekingHints;
     logLevel: LogLevel;
     mediaSection: MediaSectionState;
-    keyframes: KeyframesState;
 }) => Promise<SeekResolution>;

package/dist/containers/webm/seek/get-seeking-byte.js

@@ -48,18 +48,18 @@ const getByteFromCues = ({ cuesResponse, time, info, logLevel, }) => {
     }
     return biggestCueBeforeTime.clusterPositionInSegment + segmentOffset;
 };
-const getSeekingByteFromMatroska = async ({ time, webmState, info, logLevel, mediaSection, keyframes, }) => {
-    var _a, _b;
+const getSeekingByteFromMatroska = async ({ time, webmState, info, logLevel, mediaSection, }) => {
+    var _a, _b, _c;
     if (!info.track) {
         log_1.Log.trace(logLevel, 'No video track found, cannot seek yet');
         return {
             type: 'valid-but-must-wait',
         };
     }
-    const cuesResponse = (await webmState.cues.getLoadedCues());
+    const cuesResponse = (_a = info.loadedCues) !== null && _a !== void 0 ? _a : (await webmState.cues.getLoadedCues());
     // Check if we have already read keyframes
     const byteFromObservedKeyframe = findKeyframeBeforeTime({
-        keyframes: keyframes.getKeyframes(),
+        keyframes: info.keyframes,
         time,
     });
     // Check if we have `Cues`
@@ -70,7 +70,7 @@ const getSeekingByteFromMatroska = async ({ time, webmState, info, logLevel, med
         logLevel,
     });
     // Fallback: back to the beginning
-    const byteFromFirstMediaSection = (_b = (_a = webmState.getFirstCluster()) === null || _a === void 0 ? void 0 : _a.start) !== null && _b !== void 0 ? _b : null;
+    const byteFromFirstMediaSection = (_c = (_b = webmState.getFirstCluster()) === null || _b === void 0 ? void 0 : _b.start) !== null && _c !== void 0 ? _c : null;
     // Optimization possibility for later:
     // Don't seek back, if the last seen time is smaller than the time we want to seek to
     const seekPossibilities = [

package/dist/containers/webm/seek/seeking-hints.d.ts

@@ -0,0 +1,10 @@
+import type { WebmSeekingHints } from '../../../seeking-hints';
+import type { TracksState } from '../../../state/has-tracks-section';
+import type { KeyframesState } from '../../../state/keyframes';
+import type { WebmState } from '../../../state/matroska/webm';
+import type { ParserState } from '../../../state/parser-state';
+export declare const getSeekingHintsFromMatroska: (tracksState: TracksState, keyframesState: KeyframesState, webmState: WebmState) => WebmSeekingHints;
+export declare const setSeekingHintsForWebm: ({ hints, state, }: {
+    hints: WebmSeekingHints;
+    state: ParserState;
+}) => void;

package/dist/containers/webm/seek/seeking-hints.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForWebm = exports.getSeekingHintsFromMatroska = void 0;
+const getSeekingHintsFromMatroska = (tracksState, keyframesState, webmState) => {
+    const tracks = tracksState.getTracks();
+    const firstVideoTrack = tracks.find((track) => track.type === 'video');
+    const keyframes = keyframesState.getKeyframes();
+    const loadedCues = webmState.cues.getIfAlreadyLoaded();
+    return {
+        type: 'webm-seeking-hints',
+        track: firstVideoTrack
+            ? {
+                timescale: firstVideoTrack.timescale,
+                trackId: firstVideoTrack.trackId,
+            }
+            : null,
+        keyframes,
+        loadedCues,
+        timestampMap: webmState.getTimeStampMapForSeekingHints(),
+    };
+};
+exports.getSeekingHintsFromMatroska = getSeekingHintsFromMatroska;
+const setSeekingHintsForWebm = ({ hints, state, }) => {
+    state.webm.cues.setFromSeekingHints(hints);
+    state.keyframes.setFromSeekingHints(hints);
+    state.webm.setTimeStampMapForSeekingHints(hints.timestampMap);
+};
+exports.setSeekingHintsForWebm = setSeekingHintsForWebm;

package/dist/controller/media-parser-controller.d.ts

@@ -1,3 +1,4 @@
+import type { SeekingHints } from '../seeking-hints';
 import { MediaParserEmitter } from './emitter';
 import type { PauseSignal } from './pause-signal';
 import type { PerformedSeeksSignal } from './performed-seeks-stats';
@@ -9,6 +10,7 @@ export type MediaParserController = {
     _experimentalSeek: SeekSignal['seek'];
     addEventListener: MediaParserEmitter['addEventListener'];
     removeEventListener: MediaParserEmitter['removeEventListener'];
+    getSeekingHints: () => Promise<SeekingHints | null>;
     /**
      * @deprecated Not public API
      */
@@ -18,6 +20,7 @@ export type MediaParserController = {
         seekSignal: SeekSignal;
         markAsReadyToEmitEvents: () => void;
         performedSeeksSignal: PerformedSeeksSignal;
+        attachSeekingHintResolution: (callback: () => Promise<SeekingHints | null>) => void;
     };
 };
 export declare const mediaParserController: () => MediaParserController;