@remotion/media-parser 4.0.288 → 4.0.289

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

@@ -45,6 +45,36 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         registerOnAvcProfileCallback: (callback: (profile: 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<null> | Promise<{
+                entries: import("../containers/riff/riff-box").Idx1Entry[];
+                videoTrackIndex: number | 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("./riff/riff-keyframes").RiffKeyframe) => void;
+                getKeyframes: () => import("./riff/riff-keyframes").RiffKeyframe[];
+                setFromSeekingHints: (keyframesFromHints: import("./riff/riff-keyframes").RiffKeyframe[]) => void;
+            };
+        };
     };
     transportStream: {
         nextPesHeaderStore: {
@@ -131,11 +161,16 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
             setTfraBoxes: (boxes: import("../containers/iso-base-media/mfra/tfra").TfraBox[]) => void;
         };
     };
-    mp3Info: {
+    mp3: {
         getMp3Info: () => import("./mp3").Mp3Info | null;
         setMp3Info: (info: import("./mp3").Mp3Info) => void;
-        getCbrMp3Info: () => import("./mp3").Mp3CbrInfo | null;
-        setCbrMp3Info: (info: import("./mp3").Mp3CbrInfo) => void;
+        getMp3BitrateInfo: () => import("./mp3").Mp3BitrateInfo | null;
+        setMp3BitrateInfo: (info: import("./mp3").Mp3BitrateInfo) => void;
+        audioSamples: {
+            addSample: (audioSampleOffset: import("./audio-sample-map").AudioSampleOffset) => void;
+            getSamples: () => import("./audio-sample-map").AudioSampleOffset[];
+            setFromSeekingHints: (newMap: import("./audio-sample-map").AudioSampleOffset[]) => void;
+        };
     };
     aac: {
         addSample: ({ offset, size }: {
@@ -151,10 +186,20 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
             index: number;
             size: number;
         }[];
+        audioSamples: {
+            addSample: (audioSampleOffset: import("./audio-sample-map").AudioSampleOffset) => void;
+            getSamples: () => import("./audio-sample-map").AudioSampleOffset[];
+            setFromSeekingHints: (newMap: import("./audio-sample-map").AudioSampleOffset[]) => void;
+        };
     };
     flac: {
         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;
+        };
     };
     m3u: {
         setSelectedMainPlaylist: (stream: import("./m3u-state").M3uStreamOrInitialUrl) => void;
@@ -203,7 +248,6 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     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;
@@ -228,7 +272,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     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;
@@ -247,7 +291,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     onVideoTrack: OnVideoTrack | null;
     emittedFields: import("../fields").AllOptions<ParseMediaFields>;
     fields: Partial<import("../fields").AllOptions<ParseMediaFields>>;
-    slowDurationAndFps: {
+    samplesObserved: {
         addVideoSample: (videoSample: import("../webcodec-sample-types").AudioOrVideoSample) => void;
         addAudioSample: (audioSample: import("../webcodec-sample-types").AudioOrVideoSample) => void;
         getSlowDurationInSeconds: () => number;
@@ -255,6 +299,8 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getSlowNumberOfFrames: () => number;
         getAudioBitrate: () => number | null;
         getVideoBitrate: () => number | null;
+        getLastSampleObserved: () => boolean;
+        setLastSampleObserved: () => void;
     };
     contentLength: number;
     images: {

package/dist/state/parser-state.js

@@ -32,8 +32,8 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
     const structure = (0, structure_1.structureState)();
     const keyframes = (0, keyframes_1.keyframesState)();
     const emittedFields = (0, emitted_fields_1.emittedState)();
-    const slowDurationAndFps = (0, slow_duration_fps_1.samplesObservedState)();
-    const mp3Info = (0, mp3_1.makeMp3State)();
+    const samplesObserved = (0, slow_duration_fps_1.samplesObservedState)();
+    const mp3 = (0, mp3_1.makeMp3State)();
     const images = (0, images_1.imagesState)();
     const timings = (0, timings_1.timingsState)();
     const seekInfiniteLoop = (0, seek_infinite_loop_1.seekInfiniteLoopDetectionState)();
@@ -53,7 +53,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         callbacks,
     });
     return {
-        riff: (0, riff_1.riffSpecificState)(),
+        riff: (0, riff_1.riffSpecificState)({ controller, logLevel, readerInterface, src }),
         transportStream: (0, transport_stream_1.transportStreamState)(),
         webm: (0, webm_1.webmState)({ controller, logLevel, readerInterface, src }),
         iso: (0, iso_state_1.isoBaseMediaState)({
@@ -63,7 +63,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
             src,
             logLevel,
         }),
-        mp3Info,
+        mp3,
         aac: (0, aac_state_1.aacState)(),
         flac: (0, flac_state_1.flacState)(),
         m3u: (0, m3u_state_1.m3uState)(logLevel),
@@ -75,7 +75,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
             fields,
             keyframes,
             emittedFields,
-            slowDurationAndFpsState: slowDurationAndFps,
+            samplesObserved,
             structure,
             src,
             seekSignal: controller._internals.seekSignal,
@@ -96,7 +96,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         onVideoTrack,
         emittedFields,
         fields,
-        slowDurationAndFps,
+        samplesObserved,
         contentLength,
         images,
         mediaSection: (0, video_section_1.mediaSectionState)(),

package/dist/state/riff/lazy-idx1-fetch.d.ts

@@ -0,0 +1,30 @@
+import type { RiffSeekingHints } from '../../containers/riff/seeking-hints';
+import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { LogLevel } from '../../log';
+import type { ParseMediaSrc } from '../../options';
+import type { ReaderInterface } from '../../readers/reader';
+export declare const lazyIdx1Fetch: ({ controller, logLevel, readerInterface, src, }: {
+    controller: MediaParserController;
+    logLevel: LogLevel;
+    readerInterface: ReaderInterface;
+    src: ParseMediaSrc;
+}) => {
+    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: RiffSeekingHints) => void;
+    waitForLoaded: () => Promise<null> | Promise<{
+        entries: import("../../containers/riff/riff-box").Idx1Entry[];
+        videoTrackIndex: number | null;
+    }>;
+};
+export type LazyIdx1Fetch = ReturnType<typeof lazyIdx1Fetch>;

package/dist/state/riff/lazy-idx1-fetch.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyIdx1Fetch = void 0;
+const fetch_idx1_1 = require("../../containers/riff/seek/fetch-idx1");
+const lazyIdx1Fetch = ({ controller, logLevel, readerInterface, src, }) => {
+    let prom = null;
+    let result = null;
+    const triggerLoad = (position) => {
+        if (result) {
+            return Promise.resolve(result);
+        }
+        if (prom) {
+            return prom;
+        }
+        prom = (0, fetch_idx1_1.fetchIdx1)({
+            controller,
+            logLevel,
+            position,
+            readerInterface,
+            src,
+        }).then((entries) => {
+            prom = null;
+            result = entries;
+            return entries;
+        });
+        return prom;
+    };
+    const getLoadedIdx1 = async () => {
+        if (!prom) {
+            return null;
+        }
+        const entries = await prom;
+        return entries;
+    };
+    const getIfAlreadyLoaded = () => {
+        if (result) {
+            return result;
+        }
+        return null;
+    };
+    const setFromSeekingHints = (hints) => {
+        if (hints.idx1Entries) {
+            result = hints.idx1Entries;
+        }
+    };
+    const waitForLoaded = () => {
+        if (result) {
+            return Promise.resolve(result);
+        }
+        if (prom) {
+            return prom;
+        }
+        return Promise.resolve(null);
+    };
+    return {
+        triggerLoad,
+        getLoadedIdx1,
+        getIfAlreadyLoaded,
+        setFromSeekingHints,
+        waitForLoaded,
+    };
+};
+exports.lazyIdx1Fetch = lazyIdx1Fetch;

package/dist/state/riff/riff-keyframes.d.ts

@@ -0,0 +1,10 @@
+import type { MediaParserKeyframe } from '../../options';
+export type RiffKeyframe = MediaParserKeyframe & {
+    sampleCounts: Record<number, number>;
+};
+export declare const riffKeyframesState: () => {
+    addKeyframe: (keyframe: RiffKeyframe) => void;
+    getKeyframes: () => RiffKeyframe[];
+    setFromSeekingHints: (keyframesFromHints: RiffKeyframe[]) => void;
+};
+export type RiffKeyframesState = ReturnType<typeof riffKeyframesState>;

package/dist/state/riff/riff-keyframes.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.riffKeyframesState = void 0;
+const riffKeyframesState = () => {
+    const keyframes = [];
+    const addKeyframe = (keyframe) => {
+        if (keyframes.find((k) => k.positionInBytes === keyframe.positionInBytes)) {
+            return;
+        }
+        keyframes.push(keyframe);
+    };
+    const getKeyframes = () => {
+        return keyframes;
+    };
+    const setFromSeekingHints = (keyframesFromHints) => {
+        for (const keyframe of keyframesFromHints) {
+            addKeyframe(keyframe);
+        }
+    };
+    return {
+        addKeyframe,
+        getKeyframes,
+        setFromSeekingHints,
+    };
+};
+exports.riffKeyframesState = riffKeyframesState;

package/dist/state/riff/sample-counter.d.ts

@@ -0,0 +1,12 @@
+import type { AudioOrVideoSample } from '../../webcodec-sample-types';
+export declare const riffSampleCounter: () => {
+    onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => void;
+    onVideoSample: (trackId: number, videoSample: AudioOrVideoSample) => void;
+    getSamplesForTrack: (trackId: number) => number;
+    setSamplesFromSeek: (samples: Record<number, number>) => void;
+    riffKeys: {
+        addKeyframe: (keyframe: import("./riff-keyframes").RiffKeyframe) => void;
+        getKeyframes: () => import("./riff-keyframes").RiffKeyframe[];
+        setFromSeekingHints: (keyframesFromHints: import("./riff-keyframes").RiffKeyframe[]) => void;
+    };
+};

package/dist/state/riff/sample-counter.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.riffSampleCounter = void 0;
+const riff_keyframes_1 = require("./riff-keyframes");
+const riffSampleCounter = () => {
+    const samplesForTrack = {};
+    const riffKeys = (0, riff_keyframes_1.riffKeyframesState)();
+    const onAudioSample = (trackId, audioSample) => {
+        if (typeof samplesForTrack[trackId] === 'undefined') {
+            samplesForTrack[trackId] = 0;
+        }
+        if (audioSample.data.length > 0) {
+            samplesForTrack[trackId]++;
+        }
+        samplesForTrack[trackId]++;
+    };
+    const onVideoSample = (trackId, videoSample) => {
+        if (typeof samplesForTrack[trackId] === 'undefined') {
+            samplesForTrack[trackId] = 0;
+        }
+        if (videoSample.type === 'key') {
+            riffKeys.addKeyframe({
+                trackId,
+                decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+                positionInBytes: videoSample.offset,
+                presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+                sizeInBytes: videoSample.data.length,
+                sampleCounts: { ...samplesForTrack },
+            });
+        }
+        if (videoSample.data.length > 0) {
+            samplesForTrack[trackId]++;
+        }
+    };
+    const getSamplesForTrack = (trackId) => {
+        var _a;
+        return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
+    };
+    const setSamplesFromSeek = (samples) => {
+        for (const trackId in samples) {
+            samplesForTrack[trackId] = samples[trackId];
+        }
+    };
+    return {
+        onAudioSample,
+        onVideoSample,
+        getSamplesForTrack,
+        setSamplesFromSeek,
+        riffKeys,
+    };
+};
+exports.riffSampleCounter = riffSampleCounter;

package/dist/state/riff.d.ts

@@ -1,10 +1,50 @@
+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 { SpsAndPps } from './parser-state';
 type AvcProfileInfoCallback = (profile: SpsAndPps) => Promise<void>;
-export declare const riffSpecificState: () => {
+export declare const riffSpecificState: ({ controller, logLevel, readerInterface, src, }: {
+    controller: MediaParserController;
+    logLevel: LogLevel;
+    readerInterface: ReaderInterface;
+    src: ParseMediaSrc;
+}) => {
     getAvcProfile: () => SpsAndPps | null;
     onProfile: (profile: SpsAndPps) => Promise<void>;
     registerOnAvcProfileCallback: (callback: AvcProfileInfoCallback) => 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<null> | Promise<{
+            entries: import("../containers/riff/riff-box").Idx1Entry[];
+            videoTrackIndex: number | null;
+        }>;
+    };
+    sampleCounter: {
+        onAudioSample: (trackId: number, audioSample: import("..").AudioOrVideoSample) => void;
+        onVideoSample: (trackId: number, videoSample: import("..").AudioOrVideoSample) => void;
+        getSamplesForTrack: (trackId: number) => number;
+        setSamplesFromSeek: (samples: Record<number, number>) => void;
+        riffKeys: {
+            addKeyframe: (keyframe: import("./riff/riff-keyframes").RiffKeyframe) => void;
+            getKeyframes: () => import("./riff/riff-keyframes").RiffKeyframe[];
+            setFromSeekingHints: (keyframesFromHints: import("./riff/riff-keyframes").RiffKeyframe[]) => void;
+        };
+    };
 };
+export type RiffState = ReturnType<typeof riffSpecificState>;
 export {};

package/dist/state/riff.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.riffSpecificState = void 0;
-const riffSpecificState = () => {
+const lazy_idx1_fetch_1 = require("./riff/lazy-idx1-fetch");
+const sample_counter_1 = require("./riff/sample-counter");
+const riffSpecificState = ({ controller, logLevel, readerInterface, src, }) => {
     let avcProfile = null;
     let nextTrackIndex = 0;
     const profileCallbacks = [];
@@ -15,6 +17,13 @@ const riffSpecificState = () => {
         }
         profileCallbacks.length = 0;
     };
+    const lazyIdx1 = (0, lazy_idx1_fetch_1.lazyIdx1Fetch)({
+        controller,
+        logLevel,
+        readerInterface,
+        src,
+    });
+    const sampleCounter = (0, sample_counter_1.riffSampleCounter)();
     return {
         getAvcProfile: () => {
             return avcProfile;
@@ -27,6 +36,8 @@ const riffSpecificState = () => {
         incrementNextTrackIndex: () => {
             nextTrackIndex++;
         },
+        lazyIdx1,
+        sampleCounter,
     };
 };
 exports.riffSpecificState = riffSpecificState;

package/dist/state/sample-callbacks.d.ts

@@ -5,16 +5,16 @@ import type { LogLevel } from '../log';
 import type { ParseMediaSrc } from '../options';
 import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
 import { type KeyframesState } from './keyframes';
-import type { SlowDurationAndFpsState } from './samples-observed/slow-duration-fps';
+import type { SamplesObservedState } from './samples-observed/slow-duration-fps';
 import type { StructureState } from './structure';
-export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, src, seekSignal, logLevel, }: {
+export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, samplesObserved, structure, src, seekSignal, logLevel, }: {
     controller: MediaParserController;
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     fields: Options<ParseMediaFields>;
     keyframes: KeyframesState;
     emittedFields: AllOptions<ParseMediaFields>;
-    slowDurationAndFpsState: SlowDurationAndFpsState;
+    samplesObserved: SamplesObservedState;
     structure: StructureState;
     src: ParseMediaSrc;
     seekSignal: SeekSignal;
@@ -22,7 +22,6 @@ export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVi
 }) => {
     registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
     onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => Promise<void>;
-    getSamplesForTrack: (trackId: number) => number;
     onVideoSample: (trackId: number, videoSample: AudioOrVideoSample) => Promise<void>;
     canSkipTracksState: {
         canSkipTracks: () => boolean;

package/dist/state/sample-callbacks.js

@@ -5,7 +5,7 @@ const log_1 = require("../log");
 const can_skip_tracks_1 = require("./can-skip-tracks");
 const has_tracks_section_1 = require("./has-tracks-section");
 const need_samples_for_fields_1 = require("./need-samples-for-fields");
-const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, src, seekSignal, logLevel, }) => {
+const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, samplesObserved, structure, src, seekSignal, logLevel, }) => {
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
     const queuedAudioSamples = {};
@@ -17,7 +17,6 @@ const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
         structure,
     });
     const tracksState = (0, has_tracks_section_1.makeTracksSectionState)(canSkipTracksState, src);
-    const samplesForTrack = {};
     return {
         registerVideoSampleCallback: async (id, callback) => {
             var _a;
@@ -35,12 +34,8 @@ const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
             if (controller._internals.signal.aborted) {
                 throw new Error('Aborted');
             }
-            if (typeof samplesForTrack[trackId] === 'undefined') {
-                samplesForTrack[trackId] = 0;
-            }
             const callback = audioSampleCallbacks[trackId];
             if (audioSample.data.length > 0) {
-                samplesForTrack[trackId]++;
                 // If we emit samples with data length 0, Chrome will fail
                 if (callback) {
                     if (seekSignal.getSeek()) {
@@ -52,22 +47,14 @@ const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
                 }
             }
             if ((0, need_samples_for_fields_1.needsToIterateOverSamples)({ emittedFields, fields })) {
-                slowDurationAndFpsState.addAudioSample(audioSample);
+                samplesObserved.addAudioSample(audioSample);
             }
         },
-        getSamplesForTrack: (trackId) => {
-            var _a;
-            return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
-        },
         onVideoSample: async (trackId, videoSample) => {
             if (controller._internals.signal.aborted) {
                 throw new Error('Aborted');
             }
-            if (typeof samplesForTrack[trackId] === 'undefined') {
-                samplesForTrack[trackId] = 0;
-            }
             if (videoSample.data.length > 0) {
-                samplesForTrack[trackId]++;
                 const callback = videoSampleCallbacks[trackId];
                 // If we emit samples with data 0, Chrome will fail
                 if (callback) {
@@ -92,7 +79,7 @@ const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
                 fields,
                 emittedFields,
             })) {
-                slowDurationAndFpsState.addVideoSample(videoSample);
+                samplesObserved.addVideoSample(videoSample);
             }
         },
         canSkipTracksState,

package/dist/state/samples-observed/slow-duration-fps.d.ts

@@ -7,5 +7,7 @@ export declare const samplesObservedState: () => {
     getSlowNumberOfFrames: () => number;
     getAudioBitrate: () => number | null;
     getVideoBitrate: () => number | null;
+    getLastSampleObserved: () => boolean;
+    setLastSampleObserved: () => void;
 };
-export type SlowDurationAndFpsState = ReturnType<typeof samplesObservedState>;
+export type SamplesObservedState = ReturnType<typeof samplesObservedState>;

package/dist/state/samples-observed/slow-duration-fps.js

@@ -6,6 +6,7 @@ const samplesObservedState = () => {
     let largestVideoSample;
     let smallestAudioSample;
     let largestAudioSample;
+    let lastSampleObserved = false;
     const videoSamples = new Map();
     const audioSamples = new Map();
     const getSlowVideoDurationInSeconds = () => {
@@ -76,6 +77,10 @@ const samplesObservedState = () => {
         const videoSizesInBytes = Array.from(videoSamples.values()).reduce((acc, size) => acc + size, 0);
         return (videoSizesInBytes * 8) / videoDuration;
     };
+    const getLastSampleObserved = () => lastSampleObserved;
+    const setLastSampleObserved = () => {
+        lastSampleObserved = true;
+    };
     return {
         addVideoSample,
         addAudioSample,
@@ -84,6 +89,8 @@ const samplesObservedState = () => {
         getSlowNumberOfFrames,
         getAudioBitrate,
         getVideoBitrate,
+        getLastSampleObserved,
+        setLastSampleObserved,
     };
 };
 exports.samplesObservedState = samplesObservedState;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.288";
+export declare const VERSION = "4.0.289";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Automatically generated on publish
-exports.VERSION = '4.0.288';
+exports.VERSION = '4.0.289';

package/dist/work-on-seek-request.d.ts

@@ -5,12 +5,17 @@ import type { LogLevel } from './log';
 import type { ParseMediaMode, ParseMediaSrc } from './options';
 import type { IsoBaseMediaStructure } from './parse-result';
 import type { ReaderInterface } from './readers/reader';
+import type { AacState } from './state/aac-state';
 import type { CurrentReader } from './state/current-reader';
+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 { ParserState } from './state/parser-state';
+import type { RiffState } from './state/riff';
+import type { SamplesObservedState } from './state/samples-observed/slow-duration-fps';
 import type { SeekInfiniteLoop } from './state/seek-infinite-loop';
 import type { StructureState } from './state/structure';
 import type { TransportStreamState } from './state/transport-stream/transport-stream';
@@ -35,6 +40,11 @@ export type WorkOnSeekRequestOptions = {
     tracksState: TracksState;
     webmState: WebmState;
     keyframes: KeyframesState;
+    flacState: FlacState;
+    samplesObserved: SamplesObservedState;
+    riffState: RiffState;
+    mp3State: Mp3State;
+    aacState: AacState;
 };
 export declare const getWorkOnSeekRequestOptions: (state: ParserState) => WorkOnSeekRequestOptions;
 export declare const workOnSeekRequest: (options: WorkOnSeekRequestOptions) => Promise<void>;