@remotion/media-parser 4.0.288 → 4.0.289

package/dist/find-last-keyframe.d.ts

@@ -0,0 +1,5 @@
+import type { MediaParserKeyframe } from './options';
+export declare function findLastKeyframe<T extends MediaParserKeyframe>({ keyframes, timeInSeconds, }: {
+    keyframes: T[];
+    timeInSeconds: number;
+}): T | null;

package/dist/find-last-keyframe.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLastKeyframe = findLastKeyframe;
+function findLastKeyframe({ keyframes, timeInSeconds, }) {
+    let bestKeyframe = null;
+    for (const keyframe of keyframes) {
+        if (keyframe.presentationTimeInSeconds > timeInSeconds &&
+            keyframe.decodingTimeInSeconds > timeInSeconds) {
+            break;
+        }
+        if (bestKeyframe === null ||
+            keyframe.presentationTimeInSeconds >
+                bestKeyframe.presentationTimeInSeconds) {
+            bestKeyframe = keyframe;
+        }
+    }
+    return bestKeyframe;
+}

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

@@ -3,11 +3,12 @@ import type { IsoBaseMediaStructure } from './parse-result';
 import type { SeekingHints } from './seeking-hints';
 import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
 import type { WebmState } from './state/matroska/webm';
+import type { RiffState } from './state/riff';
 import type { StructureState } from './state/structure';
 import type { TransportStreamState } from './state/transport-stream/transport-stream';
 import type { MediaSectionState } from './state/video-section';
 import type { SeekResolution } from './work-on-seek-request';
-export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, mp4HeaderSegment, structure, }: {
+export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, mp4HeaderSegment, structure, riffState, }: {
     info: SeekingHints;
     time: number;
     logLevel: LogLevel;
@@ -18,4 +19,5 @@ export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, i
     mediaSection: MediaSectionState;
     structure: StructureState;
     mp4HeaderSegment: IsoBaseMediaStructure | null;
+    riffState: RiffState;
 }) => Promise<SeekResolution>;

package/dist/get-seeking-byte.js

@@ -1,14 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSeekingByte = void 0;
-const get_seeking_byte_1 = require("./containers/iso-base-media/get-seeking-byte");
-const get_seeking_byte_2 = require("./containers/wav/get-seeking-byte");
-const get_seeking_byte_3 = require("./containers/webm/seek/get-seeking-byte");
+const get_seeking_byte_1 = require("./containers/aac/get-seeking-byte");
+const get_seeking_byte_2 = require("./containers/flac/get-seeking-byte");
+const get_seeking_byte_3 = require("./containers/iso-base-media/get-seeking-byte");
+const get_seeking_byte_4 = require("./containers/mp3/get-seeking-byte");
+const get_seeking_byte_5 = require("./containers/riff/get-seeking-byte");
+const get_seeking_byte_6 = require("./containers/wav/get-seeking-byte");
+const get_seeking_byte_7 = require("./containers/webm/seek/get-seeking-byte");
 const observed_pes_header_1 = require("./state/transport-stream/observed-pes-header");
-const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, mp4HeaderSegment, structure, }) => {
+const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, mp4HeaderSegment, structure, riffState, }) => {
     var _a;
     if (info.type === 'iso-base-media-seeking-hints') {
-        return (0, get_seeking_byte_1.getSeekingByteFromIsoBaseMedia)({
+        return (0, get_seeking_byte_3.getSeekingByteFromIsoBaseMedia)({
             info,
             time,
             logLevel,
@@ -19,13 +23,13 @@ const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, trans
         });
     }
     if (info.type === 'wav-seeking-hints') {
-        return (0, get_seeking_byte_2.getSeekingByteFromWav)({
+        return (0, get_seeking_byte_6.getSeekingByteFromWav)({
             info,
             time,
         });
     }
     if (info.type === 'webm-seeking-hints') {
-        return (0, get_seeking_byte_3.getSeekingByteFromMatroska)({
+        return (0, get_seeking_byte_7.getSeekingByteFromMatroska)({
             info,
             time,
             webmState,
@@ -33,6 +37,21 @@ const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, trans
             mediaSection,
         });
     }
+    if (info.type === 'flac-seeking-hints') {
+        const byte = (0, get_seeking_byte_2.getSeekingByteForFlac)({
+            seekingHints: info,
+            time,
+        });
+        if (byte) {
+            return Promise.resolve({
+                type: 'do-seek',
+                byte,
+            });
+        }
+        return Promise.resolve({
+            type: 'valid-but-must-wait',
+        });
+    }
     if (info.type === 'transport-stream-seeking-hints') {
         const lastKeyframeBeforeTimeInSeconds = (0, observed_pes_header_1.getLastKeyFrameBeforeTimeInSeconds)({
             observedPesHeaders: info.observedPesHeaders,
@@ -46,6 +65,25 @@ const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, trans
             byte,
         });
     }
+    if (info.type === 'riff-seeking-hints') {
+        return (0, get_seeking_byte_5.getSeekingByteForRiff)({
+            info,
+            time,
+            riffState,
+        });
+    }
+    if (info.type === 'mp3-seeking-hints') {
+        return Promise.resolve((0, get_seeking_byte_4.getSeekingByteForMp3)({
+            info,
+            time,
+        }));
+    }
+    if (info.type === 'aac-seeking-hints') {
+        return Promise.resolve((0, get_seeking_byte_1.getSeekingByteForAac)({
+            time,
+            seekingHints: info,
+        }));
+    }
     throw new Error(`Unknown seeking info type: ${info}`);
 };
 exports.getSeekingByte = getSeekingByte;

package/dist/get-seeking-hints.d.ts

@@ -1,13 +1,18 @@
 import type { IsoBaseMediaStructure } from './parse-result';
 import type { SeekingHints } from './seeking-hints';
+import type { AacState } from './state/aac-state';
+import type { FlacState } from './state/flac-state';
 import type { TracksState } from './state/has-tracks-section';
 import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
 import type { KeyframesState } from './state/keyframes';
 import type { WebmState } from './state/matroska/webm';
+import type { Mp3State } from './state/mp3';
+import type { RiffState } from './state/riff';
+import type { SamplesObservedState } from './state/samples-observed/slow-duration-fps';
 import type { StructureState } from './state/structure';
 import type { TransportStreamState } from './state/transport-stream/transport-stream';
 import type { MediaSectionState } from './state/video-section';
-export declare const getSeekingHints: ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, }: {
+export declare const getSeekingHints: ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, flacState, samplesObserved, riffState, mp3State, contentLength, aacState, }: {
     structureState: StructureState;
     mp4HeaderSegment: IsoBaseMediaStructure | null;
     mediaSectionState: MediaSectionState;
@@ -16,4 +21,10 @@ export declare const getSeekingHints: ({ structureState, mp4HeaderSegment, media
     tracksState: TracksState;
     keyframesState: KeyframesState;
     webmState: WebmState;
+    flacState: FlacState;
+    samplesObserved: SamplesObservedState;
+    riffState: RiffState;
+    mp3State: Mp3State;
+    aacState: AacState;
+    contentLength: number;
 }) => SeekingHints | null;

package/dist/get-seeking-hints.js

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSeekingHints = void 0;
-const seeking_hints_1 = require("./containers/iso-base-media/seeking-hints");
-const seeking_hints_2 = require("./containers/transport-stream/seeking-hints");
-const seeking_hints_3 = require("./containers/wav/seeking-hints");
-const seeking_hints_4 = require("./containers/webm/seek/seeking-hints");
-const getSeekingHints = ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, }) => {
+const seeking_hints_1 = require("./containers/aac/seeking-hints");
+const seeking_hints_2 = require("./containers/flac/seeking-hints");
+const seeking_hints_3 = require("./containers/iso-base-media/seeking-hints");
+const seeking_hints_4 = require("./containers/mp3/seeking-hints");
+const seeking_hints_5 = require("./containers/riff/seeking-hints");
+const seeking_hints_6 = require("./containers/transport-stream/seeking-hints");
+const seeking_hints_7 = require("./containers/wav/seeking-hints");
+const seeking_hints_8 = require("./containers/webm/seek/seeking-hints");
+const getSeekingHints = ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, flacState, samplesObserved, riffState, mp3State, contentLength, aacState, }) => {
     const structure = structureState.getStructureOrNull();
     if (!structure) {
         return null;
     }
     if (structure.type === 'iso-base-media') {
-        return (0, seeking_hints_1.getSeekingHintsFromMp4)({
+        return (0, seeking_hints_3.getSeekingHintsFromMp4)({
             structureState,
             isoState,
             mp4HeaderSegment,
@@ -19,16 +23,43 @@ const getSeekingHints = ({ structureState, mp4HeaderSegment, mediaSectionState,
         });
     }
     if (structure.type === 'wav') {
-        return (0, seeking_hints_3.getSeekingHintsFromWav)({
+        return (0, seeking_hints_7.getSeekingHintsFromWav)({
             structure,
             mediaSectionState,
         });
     }
     if (structure.type === 'matroska') {
-        return (0, seeking_hints_4.getSeekingHintsFromMatroska)(tracksState, keyframesState, webmState);
+        return (0, seeking_hints_8.getSeekingHintsFromMatroska)(tracksState, keyframesState, webmState);
     }
     if (structure.type === 'transport-stream') {
-        return (0, seeking_hints_2.getSeekingHintsFromTransportStream)(transportStream, tracksState);
+        return (0, seeking_hints_6.getSeekingHintsFromTransportStream)(transportStream, tracksState);
+    }
+    if (structure.type === 'flac') {
+        return (0, seeking_hints_2.getSeekingHintsForFlac)({
+            flacState,
+            samplesObserved,
+        });
+    }
+    if (structure.type === 'riff') {
+        return (0, seeking_hints_5.getSeekingHintsForRiff)({
+            structureState,
+            riffState,
+            mediaSectionState,
+        });
+    }
+    if (structure.type === 'mp3') {
+        return (0, seeking_hints_4.getSeekingHintsForMp3)({
+            mp3State,
+            samplesObserved,
+            mediaSectionState,
+            contentLength,
+        });
+    }
+    if (structure.type === 'aac') {
+        return (0, seeking_hints_1.getSeekingHintsForAac)({
+            aacState,
+            samplesObserved,
+        });
     }
     throw new Error(`Seeking is not supported for this format: ${structure.type}`);
 };

package/dist/index.d.ts

@@ -732,11 +732,12 @@ export declare const MediaParserInternals: {
         getSyncSafeInt32: () => number;
         replaceData: (newData: Uint8Array, seekTo: number) => void;
     };
-    parseStsd: ({ offset, size, iterator, logLevel, }: {
+    parseStsd: ({ offset, size, iterator, logLevel, contentLength, }: {
         offset: number;
         size: number;
         iterator: import("./iterator/buffer-iterator").BufferIterator;
         logLevel: LogLevel;
+        contentLength: number;
     }) => Promise<import("./containers/iso-base-media/stsd/stsd").StsdBox>;
     makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, }: {
         hasAudioTrackHandlers: boolean;
@@ -767,6 +768,36 @@ export declare const MediaParserInternals: {
             registerOnAvcProfileCallback: (callback: (profile: import("./state/parser-state").SpsAndPps) => Promise<void>) => void;
             getNextTrackIndex: () => number;
             incrementNextTrackIndex: () => void;
+            lazyIdx1: {
+                triggerLoad: (position: number) => Promise<{
+                    entries: import("./containers/riff/riff-box").Idx1Entry[];
+                    videoTrackIndex: number | null;
+                }>;
+                getLoadedIdx1: () => Promise<{
+                    entries: import("./containers/riff/riff-box").Idx1Entry[];
+                    videoTrackIndex: number | null;
+                } | null>;
+                getIfAlreadyLoaded: () => {
+                    entries: import("./containers/riff/riff-box").Idx1Entry[];
+                    videoTrackIndex: number | null;
+                } | null;
+                setFromSeekingHints: (hints: import("./containers/riff/seeking-hints").RiffSeekingHints) => void;
+                waitForLoaded: () => Promise<{
+                    entries: import("./containers/riff/riff-box").Idx1Entry[];
+                    videoTrackIndex: number | null;
+                }> | Promise<null>;
+            };
+            sampleCounter: {
+                onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
+                onVideoSample: (trackId: number, videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
+                getSamplesForTrack: (trackId: number) => number;
+                setSamplesFromSeek: (samples: Record<number, number>) => void;
+                riffKeys: {
+                    addKeyframe: (keyframe: import("./state/riff/riff-keyframes").RiffKeyframe) => void;
+                    getKeyframes: () => import("./state/riff/riff-keyframes").RiffKeyframe[];
+                    setFromSeekingHints: (keyframesFromHints: import("./state/riff/riff-keyframes").RiffKeyframe[]) => void;
+                };
+            };
         };
         transportStream: {
             nextPesHeaderStore: {
@@ -853,11 +884,16 @@ export declare const MediaParserInternals: {
                 setTfraBoxes: (boxes: import("./containers/iso-base-media/mfra/tfra").TfraBox[]) => void;
             };
         };
-        mp3Info: {
+        mp3: {
             getMp3Info: () => import("./state/mp3").Mp3Info | null;
             setMp3Info: (info: import("./state/mp3").Mp3Info) => void;
-            getCbrMp3Info: () => import("./state/mp3").Mp3CbrInfo | null;
-            setCbrMp3Info: (info: import("./state/mp3").Mp3CbrInfo) => void;
+            getMp3BitrateInfo: () => import("./state/mp3").Mp3BitrateInfo | null;
+            setMp3BitrateInfo: (info: import("./state/mp3").Mp3BitrateInfo) => void;
+            audioSamples: {
+                addSample: (audioSampleOffset: import("./state/audio-sample-map").AudioSampleOffset) => void;
+                getSamples: () => import("./state/audio-sample-map").AudioSampleOffset[];
+                setFromSeekingHints: (newMap: import("./state/audio-sample-map").AudioSampleOffset[]) => void;
+            };
         };
         aac: {
             addSample: ({ offset, size }: {
@@ -873,10 +909,20 @@ export declare const MediaParserInternals: {
                 index: number;
                 size: number;
             }[];
+            audioSamples: {
+                addSample: (audioSampleOffset: import("./state/audio-sample-map").AudioSampleOffset) => void;
+                getSamples: () => import("./state/audio-sample-map").AudioSampleOffset[];
+                setFromSeekingHints: (newMap: import("./state/audio-sample-map").AudioSampleOffset[]) => void;
+            };
         };
         flac: {
             setBlockingBitStrategy: (strategy: number) => void;
             getBlockingBitStrategy: () => number | undefined;
+            audioSamples: {
+                addSample: (audioSampleOffset: import("./state/audio-sample-map").AudioSampleOffset) => void;
+                getSamples: () => import("./state/audio-sample-map").AudioSampleOffset[];
+                setFromSeekingHints: (newMap: import("./state/audio-sample-map").AudioSampleOffset[]) => void;
+            };
         };
         m3u: {
             setSelectedMainPlaylist: (stream: import("./state/m3u-state").M3uStreamOrInitialUrl) => void;
@@ -925,7 +971,6 @@ export declare const MediaParserInternals: {
         callbacks: {
             registerVideoSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnVideoSample | null) => Promise<void>;
             onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
-            getSamplesForTrack: (trackId: number) => number;
             onVideoSample: (trackId: number, videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
             canSkipTracksState: {
                 canSkipTracks: () => boolean;
@@ -950,7 +995,7 @@ export declare const MediaParserInternals: {
         keyframes: {
             addKeyframe: (keyframe: import("./options").MediaParserKeyframe) => void;
             getKeyframes: () => import("./options").MediaParserKeyframe[];
-            setFromSeekingHints: (hints: import("./seeking-hints").WebmSeekingHints) => void;
+            setFromSeekingHints: (keyframesFromHints: import("./options").MediaParserKeyframe[]) => void;
         };
         structure: {
             getStructureOrNull: () => import("./parse-result").MediaParserStructureUnstable | null;
@@ -969,7 +1014,7 @@ export declare const MediaParserInternals: {
         onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
         emittedFields: import("./fields").AllOptions<import("./fields").ParseMediaFields>;
         fields: Partial<import("./fields").AllOptions<import("./fields").ParseMediaFields>>;
-        slowDurationAndFps: {
+        samplesObserved: {
             addVideoSample: (videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
             addAudioSample: (audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
             getSlowDurationInSeconds: () => number;
@@ -977,6 +1022,8 @@ export declare const MediaParserInternals: {
             getSlowNumberOfFrames: () => number;
             getAudioBitrate: () => number | null;
             getVideoBitrate: () => number | null;
+            getLastSampleObserved: () => boolean;
+            setLastSampleObserved: () => void;
         };
         contentLength: number;
         images: {
@@ -1096,9 +1143,10 @@ export declare const MediaParserInternals: {
         };
         makeSamplesStartAtZero: boolean;
     };
-    processSample: ({ iterator, logLevel, }: {
+    processSample: ({ iterator, logLevel, contentLength, }: {
         iterator: import("./iterator/buffer-iterator").BufferIterator;
         logLevel: LogLevel;
+        contentLength: number;
     }) => Promise<{
         sample: import("./containers/iso-base-media/stsd/samples").Sample | null;
     }>;

package/dist/internal-parse-media.js

@@ -64,6 +64,12 @@ const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue,
         mediaSectionState: state.mediaSection,
         isoState: state.iso,
         transportStream: state.transportStream,
+        flacState: state.flac,
+        samplesObserved: state.samplesObserved,
+        riffState: state.riff,
+        mp3State: state.mp3,
+        contentLength: state.contentLength,
+        aacState: state.aac,
     })));
     if (!hasAudioTrackHandlers &&
         !hasVideoTrackHandlers &&

package/dist/parse-loop.js

@@ -51,6 +51,7 @@ const parseLoop = async ({ state, throttledState, onError, }) => {
                 if (skip !== null) {
                     state.increaseSkippedBytes(skip.skipTo - state.iterator.counter.getOffset());
                     if (skip.skipTo === state.contentLength) {
+                        state.iterator.discard(skip.skipTo - state.iterator.counter.getOffset());
                         log_1.Log.verbose(state.logLevel, 'Skipped to end of file, not fetching.');
                         break;
                     }
@@ -99,5 +100,19 @@ const parseLoop = async ({ state, throttledState, onError, }) => {
             iterationWithThisOffset = 0;
         }
     }
+    state.samplesObserved.setLastSampleObserved();
+    // After the last sample, you might queue a last seek again.
+    if (state.controller._internals.seekSignal.getSeek()) {
+        log_1.Log.verbose(state.logLevel, 'Reached end of samples, but there is a pending seek. Trying to seek...');
+        await (0, work_on_seek_request_1.workOnSeekRequest)((0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state));
+        if (state.controller._internals.seekSignal.getSeek()) {
+            throw new Error('Reached the end of the file even though a seek was requested. This is likely a bug in the parser. You can report this at https://remotion.dev/report and we will fix it as soon as possible.');
+        }
+        await (0, exports.parseLoop)({
+            onError,
+            throttledState,
+            state,
+        });
+    }
 };
 exports.parseLoop = parseLoop;

package/dist/seeking-hints.d.ts

@@ -1,6 +1,10 @@
+import type { AacSeekingHints } from './containers/aac/seeking-hints';
+import type { FlacSeekingHints } from './containers/flac/seeking-hints';
 import type { IsoBaseMediaBox } from './containers/iso-base-media/base-media-box';
 import type { TfraBox } from './containers/iso-base-media/mfra/tfra';
 import type { MoovBox } from './containers/iso-base-media/moov/moov';
+import type { Mp3SeekingHints } from './containers/mp3/seeking-hints';
+import type { RiffSeekingHints } from './containers/riff/seeking-hints';
 import type { PacketPes } from './containers/transport-stream/parse-pes';
 import type { MediaParserKeyframe } from './options';
 import type { MoofBox } from './state/iso-base-media/precomputed-moof';
@@ -36,4 +40,4 @@ export type WebmSeekingHints = {
     loadedCues: LazyCuesLoadedOrNull;
     timestampMap: Map<number, number>;
 };
-export type SeekingHints = IsoBaseMediaSeekingHints | WavSeekingHints | TransportStreamSeekingHints | WebmSeekingHints;
+export type SeekingHints = IsoBaseMediaSeekingHints | WavSeekingHints | TransportStreamSeekingHints | WebmSeekingHints | FlacSeekingHints | RiffSeekingHints | Mp3SeekingHints | AacSeekingHints;

package/dist/set-seeking-hints.js

@@ -1,25 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSeekingHints = void 0;
-const seeking_hints_1 = require("./containers/iso-base-media/seeking-hints");
-const seeking_hints_2 = require("./containers/transport-stream/seeking-hints");
-const seeking_hints_3 = require("./containers/wav/seeking-hints");
-const seeking_hints_4 = require("./containers/webm/seek/seeking-hints");
+const seeking_hints_1 = require("./containers/aac/seeking-hints");
+const seeking_hints_2 = require("./containers/flac/seeking-hints");
+const seeking_hints_3 = require("./containers/iso-base-media/seeking-hints");
+const seeking_hints_4 = require("./containers/mp3/seeking-hints");
+const seeking_hints_5 = require("./containers/riff/seeking-hints");
+const seeking_hints_6 = require("./containers/transport-stream/seeking-hints");
+const seeking_hints_7 = require("./containers/wav/seeking-hints");
+const seeking_hints_8 = require("./containers/webm/seek/seeking-hints");
 const setSeekingHints = ({ hints, state, }) => {
     if (hints.type === 'iso-base-media-seeking-hints') {
-        (0, seeking_hints_1.setSeekingHintsForMp4)({ hints, state });
+        (0, seeking_hints_3.setSeekingHintsForMp4)({ hints, state });
         return;
     }
     if (hints.type === 'wav-seeking-hints') {
-        (0, seeking_hints_3.setSeekingHintsForWav)({ hints, state });
+        (0, seeking_hints_7.setSeekingHintsForWav)({ hints, state });
         return;
     }
     if (hints.type === 'transport-stream-seeking-hints') {
-        (0, seeking_hints_2.setSeekingHintsForTransportStream)({ hints, state });
+        (0, seeking_hints_6.setSeekingHintsForTransportStream)({ hints, state });
         return;
     }
     if (hints.type === 'webm-seeking-hints') {
-        (0, seeking_hints_4.setSeekingHintsForWebm)({ hints, state });
+        (0, seeking_hints_8.setSeekingHintsForWebm)({ hints, state });
+        return;
+    }
+    if (hints.type === 'flac-seeking-hints') {
+        (0, seeking_hints_2.setSeekingHintsForFlac)({ hints, state });
+        return;
+    }
+    if (hints.type === 'riff-seeking-hints') {
+        (0, seeking_hints_5.setSeekingHintsForRiff)({ hints, state });
+        return;
+    }
+    if (hints.type === 'mp3-seeking-hints') {
+        (0, seeking_hints_4.setSeekingHintsForMp3)({ hints, state });
+        return;
+    }
+    if (hints.type === 'aac-seeking-hints') {
+        (0, seeking_hints_1.setSeekingHintsForAac)();
         return;
     }
     throw new Error(`Unknown seeking hints type: ${hints}`);

package/dist/state/aac-state.d.ts

@@ -9,5 +9,11 @@ export declare const aacState: () => {
         size: number;
     }) => AacSamplePosition;
     getSamples: () => AacSamplePosition[];
+    audioSamples: {
+        addSample: (audioSampleOffset: import("./audio-sample-map").AudioSampleOffset) => void;
+        getSamples: () => import("./audio-sample-map").AudioSampleOffset[];
+        setFromSeekingHints: (newMap: import("./audio-sample-map").AudioSampleOffset[]) => void;
+    };
 };
+export type AacState = ReturnType<typeof aacState>;
 export {};

package/dist/state/aac-state.js

@@ -1,17 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aacState = void 0;
+const audio_sample_map_1 = require("./audio-sample-map");
 const aacState = () => {
     const samples = [];
+    // seems redunant, we could deduplicate this
+    const audioSamples = (0, audio_sample_map_1.audioSampleMapState)();
     return {
         addSample: ({ offset, size }) => {
-            if (samples.find((s) => s.offset === offset)) {
-                throw new Error('Duplicate sample');
+            const index = samples.findIndex((s) => s.offset === offset);
+            if (index !== -1) {
+                return samples[index];
             }
             samples.push({ offset, index: samples.length, size });
             return samples[samples.length - 1];
         },
         getSamples: () => samples,
+        audioSamples,
     };
 };
 exports.aacState = aacState;

package/dist/state/flac-state.d.ts

@@ -1,4 +1,10 @@
 export declare const flacState: () => {
     setBlockingBitStrategy: (strategy: number) => void;
     getBlockingBitStrategy: () => number | undefined;
+    audioSamples: {
+        addSample: (audioSampleOffset: import("./audio-sample-map").AudioSampleOffset) => void;
+        getSamples: () => import("./audio-sample-map").AudioSampleOffset[];
+        setFromSeekingHints: (newMap: import("./audio-sample-map").AudioSampleOffset[]) => void;
+    };
 };
+export type FlacState = ReturnType<typeof flacState>;

package/dist/state/flac-state.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flacState = void 0;
+const audio_sample_map_1 = require("./audio-sample-map");
 const flacState = () => {
     let blockingBitStrategy;
+    const audioSamples = (0, audio_sample_map_1.audioSampleMapState)();
     return {
         setBlockingBitStrategy: (strategy) => {
             blockingBitStrategy = strategy;
         },
         getBlockingBitStrategy: () => blockingBitStrategy,
+        audioSamples,
     };
 };
 exports.flacState = flacState;

package/dist/state/keyframes.d.ts

@@ -1,8 +1,7 @@
 import type { MediaParserKeyframe } from '../options';
-import type { WebmSeekingHints } from '../seeking-hints';
 export declare const keyframesState: () => {
     addKeyframe: (keyframe: MediaParserKeyframe) => void;
     getKeyframes: () => MediaParserKeyframe[];
-    setFromSeekingHints: (hints: WebmSeekingHints) => void;
+    setFromSeekingHints: (keyframesFromHints: MediaParserKeyframe[]) => void;
 };
 export type KeyframesState = ReturnType<typeof keyframesState>;

package/dist/state/keyframes.js

@@ -12,8 +12,8 @@ const keyframesState = () => {
     const getKeyframes = () => {
         return keyframes;
     };
-    const setFromSeekingHints = (hints) => {
-        for (const keyframe of hints.keyframes) {
+    const setFromSeekingHints = (keyframesFromHints) => {
+        for (const keyframe of keyframesFromHints) {
             addKeyframe(keyframe);
         }
     };

package/dist/state/matroska/lazy-cues-fetch.js

@@ -8,6 +8,9 @@ const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, }) => {
     let sOffset = null;
     let result = null;
     const triggerLoad = (position, segmentOffset) => {
+        if (result) {
+            return Promise.resolve(result);
+        }
         if (prom) {
             return prom;
         }
@@ -33,6 +36,15 @@ const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, }) => {
         if (!prom) {
             return null;
         }
+        if (result) {
+            if (!sOffset) {
+                throw new Error('Segment offset not set');
+            }
+            return {
+                cues: result,
+                segmentOffset: sOffset,
+            };
+        }
         const cues = await prom;
         if (!cues) {
             return null;
@@ -47,7 +59,7 @@ const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, }) => {
     };
     const getIfAlreadyLoaded = () => {
         if (result) {
-            if (!sOffset) {
+            if (sOffset === null) {
                 throw new Error('Segment offset not set');
             }
             return {