@remotion/media-parser 4.0.282 → 4.0.284

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

@@ -0,0 +1,252 @@
+import type { AvcPPs, AvcProfileInfo } from '../containers/avc/parse-avc';
+import type { SelectM3uAssociatedPlaylistsFn, SelectM3uStreamFn } from '../containers/m3u/select-stream';
+import type { MediaParserController } from '../controller/media-parser-controller';
+import type { Options, ParseMediaFields } from '../fields';
+import { type LogLevel } from '../log';
+import type { OnDiscardedData, ParseMediaCallbacks, ParseMediaMode, ParseMediaSrc } from '../options';
+import type { IsoBaseMediaStructure } from '../parse-result';
+import type { Reader, ReaderInterface } from '../readers/reader';
+import type { OnAudioTrack, OnVideoTrack } from '../webcodec-sample-types';
+export type InternalStats = {
+    skippedBytes: number;
+    finalCursorOffset: number;
+};
+export type SpsAndPps = {
+    sps: AvcProfileInfo;
+    pps: AvcPPs;
+};
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, }: {
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
+    controller: MediaParserController;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    contentLength: number;
+    logLevel: LogLevel;
+    mode: ParseMediaMode;
+    src: ParseMediaSrc;
+    readerInterface: ReaderInterface;
+    onDiscardedData: OnDiscardedData | null;
+    selectM3uStreamFn: SelectM3uStreamFn;
+    selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
+    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    contentType: string | null;
+    name: string;
+    callbacks: ParseMediaCallbacks;
+    fieldsInReturnValue: Options<ParseMediaFields>;
+    mimeType: string | null;
+    initialReaderInstance: Reader;
+}) => {
+    riff: {
+        getAvcProfile: () => SpsAndPps | null;
+        onProfile: (profile: SpsAndPps) => Promise<void>;
+        registerOnAvcProfileCallback: (callback: (profile: SpsAndPps) => Promise<void>) => void;
+        getNextTrackIndex: () => number;
+        incrementNextTrackIndex: () => void;
+    };
+    transportStream: {
+        nextPesHeaderStore: {
+            setNextPesHeader: (pesHeader: AvcPPs) => void;
+            getNextPesHeader: () => any;
+        };
+        streamBuffers: Map<number, TransportStreamPacketBuffer>;
+        startOffset: {
+            getOffset: () => number;
+            setOffset: (newOffset: number) => void;
+        };
+        resetBeforeSeek: () => void;
+        lastEmittedSample: {
+            setLastEmittedSample: (sample: AvcPPs) => void;
+            getLastEmittedSample: () => any;
+            resetLastEmittedSample: () => void;
+        };
+    };
+    webm: {
+        onTrackEntrySegment: OnTrackEntrySegment;
+        getTrackInfoByNumber: (id: number) => TrackInfo;
+        setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+        getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+        timescale: null;
+        getTimescale: () => number;
+        setTimescale: (newTimescale: number) => void;
+        addSegment: (seg: Omit<import("./webm").SegmentSection, "index">) => void;
+        addCluster: (cluster: import("./webm").ClusterSection) => void;
+        isInsideSegment: (iterator: AvcPPs) => import("./webm").SegmentSection | null;
+        isInsideCluster: (iterator: AvcPPs) => import("./webm").ClusterSection | null;
+        setAvcProfileForTrackNumber: (trackNumber: number, avcProfile: AvcPPs) => void;
+        getAvcProfileForTrackNumber: (trackNumber: number) => AvcPPs | null;
+    };
+    iso: {
+        flatSamples: {
+            getSamples: (mdatStart: number) => import("./iso-base-media/cached-sample-positions").FlatSample[] | null;
+            setSamples: (mdatStart: number, samples: import("./iso-base-media/cached-sample-positions").FlatSample[]) => void;
+        };
+        moov: {
+            setMoovBox: (moov: AvcPPs) => void;
+            getMoovBox: () => any;
+        };
+        mfra: {
+            triggerLoad: () => Promise<IsoBaseMediaBox[] | null> | null;
+        };
+    };
+    mp3Info: {
+        getMp3Info: () => import("./mp3").Mp3Info | null;
+        setMp3Info: (info: import("./mp3").Mp3Info) => void;
+        getCbrMp3Info: () => import("./mp3").Mp3CbrInfo | null;
+        setCbrMp3Info: (info: import("./mp3").Mp3CbrInfo) => void;
+    };
+    aac: {
+        addSample: ({ offset, size }: {
+            offset: number;
+            size: number;
+        }) => {
+            offset: number;
+            index: number;
+            size: number;
+        };
+        getSamples: () => {
+            offset: number;
+            index: number;
+            size: number;
+        }[];
+    };
+    flac: {
+        setBlockingBitStrategy: (strategy: number) => void;
+        getBlockingBitStrategy: () => number | undefined;
+    };
+    m3u: {
+        setSelectedMainPlaylist: (stream: import("./m3u-state").M3uStreamOrInitialUrl) => void;
+        getSelectedMainPlaylist: () => import("./m3u-state").M3uStreamOrInitialUrl | null;
+        setHasEmittedVideoTrack: (src: string, callback: AvcPPs | null) => void;
+        hasEmittedVideoTrack: (src: string) => any;
+        setHasEmittedAudioTrack: (src: string, callback: AvcPPs | null) => void;
+        hasEmittedAudioTrack: (src: string) => any;
+        setHasEmittedDoneWithTracks: (src: string) => void;
+        hasEmittedDoneWithTracks: (src: string) => boolean;
+        setReadyToIterateOverM3u: () => void;
+        isReadyToIterateOverM3u: () => boolean;
+        setAllChunksProcessed: (src: string) => void;
+        getAllChunksProcessedForPlaylist: (src: string) => boolean;
+        getAllChunksProcessedOverall: () => boolean;
+        setHasFinishedManifest: () => void;
+        hasFinishedManifest: () => boolean;
+        setM3uStreamRun: (playlistUrl: string, run: import("./m3u-state").ExistingM3uRun | null) => void;
+        setTracksDone: (playlistUrl: string) => boolean;
+        getTrackDone: (playlistUrl: string) => boolean;
+        getM3uStreamRun: (playlistUrl: string) => import("./m3u-state").ExistingM3uRun;
+        abortM3UStreamRuns: () => void;
+        setAssociatedPlaylists: (playlists: AvcPPs[]) => void;
+        getAssociatedPlaylists: () => M3uAssociatedPlaylist[] | null;
+        getSelectedPlaylists: () => any[];
+        sampleSorter: any;
+        setMp4HeaderSegment: (playlistUrl: string, structure: AvcPPs) => void;
+        getMp4HeaderSegment: (playlistUrl: string) => IsoBaseMediaStructure;
+    };
+    timings: {
+        timeIterating: number;
+        timeReadingData: number;
+        timeSeeking: number;
+        timeCheckingIfDone: number;
+        timeFreeingData: number;
+    };
+    callbacks: {
+        registerVideoSampleCallback: (id: number, callback: AvcPPs | null) => Promise<void>;
+        onAudioSample: (trackId: number, audioSample: AvcPPs) => Promise<void>;
+        getSamplesForTrack: (trackId: number) => number;
+        onVideoSample: (trackId: number, videoSample: AvcPPs) => Promise<void>;
+        canSkipTracksState: {
+            canSkipTracks: () => boolean;
+        };
+        registerAudioSampleCallback: (id: number, callback: AvcPPs | null) => Promise<void>;
+        tracks: {
+            hasAllTracks: () => boolean;
+            getIsDone: () => boolean;
+            setIsDone: (logLevel: AvcPPs) => void;
+            addTrack: (track: AvcPPs) => void;
+            getTracks: () => Track[];
+            ensureHasTracksAtEnd: (fields: AvcPPs<AvcPPs>) => void;
+        };
+        audioSampleCallbacks: Record<number, OnAudioSample>;
+        videoSampleCallbacks: Record<number, OnVideoSample>;
+        hasAudioTrackHandlers: boolean;
+        hasVideoTrackHandlers: boolean;
+    };
+    getInternalStats: () => InternalStats;
+    getSkipBytes: () => number;
+    increaseSkippedBytes: (bytes: number) => void;
+    keyframes: {
+        addKeyframe: (keyframe: AvcPPs) => void;
+        getKeyframes: () => AvcPPs[];
+    };
+    structure: {
+        getStructureOrNull: () => any;
+        getStructure: () => any;
+        setStructure: (value: AvcPPs) => void;
+        getFlacStructure: () => any;
+        getIsoStructure: () => any;
+        getMp3Structure: () => any;
+        getM3uStructure: () => any;
+        getRiffStructure: () => any;
+        getTsStructure: () => any;
+        getWavStructure: () => any;
+        getMatroskaStructure: () => any;
+    };
+    onAudioTrack: any;
+    onVideoTrack: any;
+    emittedFields: AllOptions<ParseMediaFields>;
+    fields: any;
+    slowDurationAndFps: {
+        addVideoSample: (videoSample: AvcPPs) => void;
+        addAudioSample: (audioSample: AvcPPs) => void;
+        getSlowDurationInSeconds: () => number;
+        getFps: () => number;
+        getSlowNumberOfFrames: () => number;
+        getAudioBitrate: () => number | null;
+        getVideoBitrate: () => number | null;
+    };
+    contentLength: number;
+    images: {
+        images: import("./images").MediaParserEmbeddedImage[];
+        addImage: (image: import("./images").MediaParserEmbeddedImage) => void;
+    };
+    mediaSection: {
+        addMediaSection: (section: import("./video-section").MediaSection) => void;
+        getMediaSections: () => import("./video-section").MediaSection[];
+        isCurrentByteInMediaSection: (iterator: AvcPPs) => "no-section-defined" | "in-section" | "outside-section";
+        isByteInMediaSection: ({ position, mediaSections, }: {
+            position: number;
+            mediaSections: import("./video-section").MediaSection[];
+        }) => "no-section-defined" | "in-section" | "outside-section";
+        getCurrentMediaSection: ({ offset, mediaSections, }: {
+            offset: number;
+            mediaSections: import("./video-section").MediaSection[];
+        }) => import("./video-section").MediaSection | null;
+        getMediaSectionAssertOnlyOne: () => import("./video-section").MediaSection;
+    };
+    logLevel: LogLevel;
+    iterator: BufferIterator;
+    controller: MediaParserController;
+    mode: ParseMediaMode;
+    src: ParseMediaSrc;
+    readerInterface: ReaderInterface;
+    discardReadBytes: (force: boolean) => Promise<void>;
+    selectM3uStreamFn: SelectM3uStreamFn;
+    selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
+    mp4HeaderSegment: any;
+    contentType: string | null;
+    name: string;
+    returnValue: ParseMediaResult<AllParseMediaFields>;
+    callbackFunctions: ParseMediaCallbacks;
+    fieldsInReturnValue: Options<ParseMediaFields>;
+    mimeType: string | null;
+    errored: Error | null;
+    currentReader: {
+        getCurrent: () => Reader;
+        setCurrent: (newReader: AvcPPs) => void;
+    };
+    seekInfiniteLoop: {
+        registerSeek: (byte: number) => void;
+        reset: () => void;
+    };
+};
+export type ParserState = ReturnType<typeof makeParserState>;

package/dist/readers/state/parser-state.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeParserState = void 0;
+const get_fields_from_callbacks_1 = require("../get-fields-from-callbacks");
+const buffer_iterator_1 = require("../iterator/buffer-iterator");
+const log_1 = require("../log");
+const aac_state_1 = require("./aac-state");
+const current_reader_1 = require("./current-reader");
+const emitted_fields_1 = require("./emitted-fields");
+const flac_state_1 = require("./flac-state");
+const images_1 = require("./images");
+const iso_state_1 = require("./iso-base-media/iso-state");
+const keyframes_1 = require("./keyframes");
+const m3u_state_1 = require("./m3u-state");
+const mp3_1 = require("./mp3");
+const riff_1 = require("./riff");
+const sample_callbacks_1 = require("./sample-callbacks");
+const seek_infinite_loop_1 = require("./seek-infinite-loop");
+const slow_duration_fps_1 = require("./slow-duration-fps");
+const structure_1 = require("./structure");
+const timings_1 = require("./timings");
+const transport_stream_1 = require("./transport-stream/transport-stream");
+const video_section_1 = require("./video-section");
+const webm_1 = require("./webm");
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, }) => {
+    let skippedBytes = 0;
+    const returnValue = {};
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), contentLength);
+    const increaseSkippedBytes = (bytes) => {
+        skippedBytes += bytes;
+    };
+    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.slowDurationAndFpsState)();
+    const mp3Info = (0, mp3_1.makeMp3State)();
+    const images = (0, images_1.imagesState)();
+    const timings = (0, timings_1.timingsState)();
+    const seekInfiniteLoop = (0, seek_infinite_loop_1.seekInfiniteLoopDetectionState)();
+    const currentReaderState = (0, current_reader_1.currentReader)(initialReaderInstance);
+    const errored = null;
+    const discardReadBytes = async (force) => {
+        const { bytesRemoved, removedData } = iterator.removeBytesRead(force, mode);
+        if (bytesRemoved) {
+            log_1.Log.verbose(logLevel, `Freed ${bytesRemoved} bytes`);
+        }
+        if (removedData && onDiscardedData) {
+            await onDiscardedData(removedData);
+        }
+    };
+    const fields = (0, get_fields_from_callbacks_1.getFieldsFromCallback)({
+        fields: fieldsInReturnValue,
+        callbacks,
+    });
+    return {
+        riff: (0, riff_1.riffSpecificState)(),
+        transportStream: (0, transport_stream_1.transportStreamState)(),
+        webm: (0, webm_1.webmState)(),
+        iso: (0, iso_state_1.isoBaseMediaState)({
+            contentLength,
+            controller,
+            readerInterface,
+            src,
+            logLevel,
+        }),
+        mp3Info,
+        aac: (0, aac_state_1.aacState)(),
+        flac: (0, flac_state_1.flacState)(),
+        m3u: (0, m3u_state_1.m3uState)(logLevel),
+        timings,
+        callbacks: (0, sample_callbacks_1.sampleCallback)({
+            controller,
+            hasAudioTrackHandlers,
+            hasVideoTrackHandlers,
+            fields,
+            keyframes,
+            emittedFields,
+            slowDurationAndFpsState: slowDurationAndFps,
+            structure,
+            src,
+            seekSignal: controller._internals.seekSignal,
+            logLevel,
+        }),
+        getInternalStats: () => {
+            var _a;
+            return ({
+                skippedBytes,
+                finalCursorOffset: (_a = iterator.counter.getOffset()) !== null && _a !== void 0 ? _a : 0,
+            });
+        },
+        getSkipBytes: () => skippedBytes,
+        increaseSkippedBytes,
+        keyframes,
+        structure,
+        onAudioTrack,
+        onVideoTrack,
+        emittedFields,
+        fields,
+        slowDurationAndFps,
+        contentLength,
+        images,
+        mediaSection: (0, video_section_1.mediaSectionState)(),
+        logLevel,
+        iterator,
+        controller,
+        mode,
+        src,
+        readerInterface,
+        discardReadBytes,
+        selectM3uStreamFn,
+        selectM3uAssociatedPlaylistsFn,
+        mp4HeaderSegment,
+        contentType,
+        name,
+        returnValue,
+        callbackFunctions: callbacks,
+        fieldsInReturnValue,
+        mimeType,
+        errored: errored,
+        currentReader: currentReaderState,
+        seekInfiniteLoop,
+    };
+};
+exports.makeParserState = makeParserState;

package/dist/readers/state/riff.d.ts

@@ -0,0 +1,10 @@
+import type { SpsAndPps } from './parser-state';
+type AvcProfileInfoCallback = (profile: SpsAndPps) => Promise<void>;
+export declare const riffSpecificState: () => {
+    getAvcProfile: () => SpsAndPps | null;
+    onProfile: (profile: SpsAndPps) => Promise<void>;
+    registerOnAvcProfileCallback: (callback: AvcProfileInfoCallback) => void;
+    getNextTrackIndex: () => number;
+    incrementNextTrackIndex: () => void;
+};
+export {};

package/dist/readers/state/riff.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.riffSpecificState = void 0;
+const riffSpecificState = () => {
+    let avcProfile = null;
+    let nextTrackIndex = 0;
+    const profileCallbacks = [];
+    const registerOnAvcProfileCallback = (callback) => {
+        profileCallbacks.push(callback);
+    };
+    const onProfile = async (profile) => {
+        avcProfile = profile;
+        for (const callback of profileCallbacks) {
+            await callback(profile);
+        }
+        profileCallbacks.length = 0;
+    };
+    return {
+        getAvcProfile: () => {
+            return avcProfile;
+        },
+        onProfile,
+        registerOnAvcProfileCallback,
+        getNextTrackIndex: () => {
+            return nextTrackIndex;
+        },
+        incrementNextTrackIndex: () => {
+            nextTrackIndex++;
+        },
+    };
+};
+exports.riffSpecificState = riffSpecificState;

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

@@ -0,0 +1,44 @@
+import type { MediaParserController } from '../controller/media-parser-controller';
+import type { SeekSignal } from '../controller/seek-signal';
+import type { AllOptions, Options, ParseMediaFields } from '../fields';
+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 './slow-duration-fps';
+import type { StructureState } from './structure';
+export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, src, seekSignal, logLevel, }: {
+    controller: MediaParserController;
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
+    fields: Options<ParseMediaFields>;
+    keyframes: KeyframesState;
+    emittedFields: AllOptions<ParseMediaFields>;
+    slowDurationAndFpsState: SlowDurationAndFpsState;
+    structure: StructureState;
+    src: ParseMediaSrc;
+    seekSignal: SeekSignal;
+    logLevel: LogLevel;
+}) => {
+    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;
+    };
+    registerAudioSampleCallback: (id: number, callback: OnAudioSample | null) => Promise<void>;
+    tracks: {
+        hasAllTracks: () => boolean;
+        getIsDone: () => boolean;
+        setIsDone: (logLevel: MediaParserController) => void;
+        addTrack: (track: MediaParserController) => void;
+        getTracks: () => Track[];
+        ensureHasTracksAtEnd: (fields: MediaParserController<MediaParserController>) => void;
+    };
+    audioSampleCallbacks: Record<number, OnAudioSample>;
+    videoSampleCallbacks: Record<number, OnVideoSample>;
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
+};
+export type SampleCallbacks = ReturnType<typeof sampleCallback>;

package/dist/readers/state/sample-callbacks.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sampleCallback = void 0;
+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 videoSampleCallbacks = {};
+    const audioSampleCallbacks = {};
+    const queuedAudioSamples = {};
+    const queuedVideoSamples = {};
+    const canSkipTracksState = (0, can_skip_tracks_1.makeCanSkipTracksState)({
+        hasAudioTrackHandlers,
+        fields,
+        hasVideoTrackHandlers,
+        structure,
+    });
+    const tracksState = (0, has_tracks_section_1.makeTracksSectionState)(canSkipTracksState, src);
+    const samplesForTrack = {};
+    return {
+        registerVideoSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete videoSampleCallbacks[id];
+                return;
+            }
+            videoSampleCallbacks[id] = callback;
+            for (const queued of (_a = queuedVideoSamples[id]) !== null && _a !== void 0 ? _a : []) {
+                await callback(queued);
+            }
+            queuedVideoSamples[id] = [];
+        },
+        onAudioSample: async (trackId, audioSample) => {
+            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()) {
+                        log_1.Log.trace(logLevel, 'Not emitting sample because seek is processing');
+                    }
+                    else {
+                        await callback(audioSample);
+                    }
+                }
+            }
+            if ((0, need_samples_for_fields_1.needsToIterateOverSamples)({ emittedFields, fields })) {
+                slowDurationAndFpsState.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) {
+                    if (seekSignal.getSeek()) {
+                        log_1.Log.trace(logLevel, 'Not emitting sample because seek is processing');
+                    }
+                    else {
+                        await callback(videoSample);
+                    }
+                }
+            }
+            if ((0, need_samples_for_fields_1.needsToIterateOverSamples)({
+                fields,
+                emittedFields,
+            })) {
+                if (fields.slowKeyframes && videoSample.type === 'key') {
+                    keyframes.addKeyframe({
+                        trackId,
+                        decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+                        positionInBytes: videoSample.offset,
+                        presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+                        sizeInBytes: videoSample.data.length,
+                    });
+                }
+                slowDurationAndFpsState.addVideoSample(videoSample);
+            }
+        },
+        canSkipTracksState,
+        registerAudioSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete audioSampleCallbacks[id];
+                return;
+            }
+            audioSampleCallbacks[id] = callback;
+            for (const queued of (_a = queuedAudioSamples[id]) !== null && _a !== void 0 ? _a : []) {
+                await callback(queued);
+            }
+            queuedAudioSamples[id] = [];
+        },
+        tracks: tracksState,
+        audioSampleCallbacks,
+        videoSampleCallbacks,
+        hasAudioTrackHandlers,
+        hasVideoTrackHandlers,
+    };
+};
+exports.sampleCallback = sampleCallback;

package/dist/readers/state/seek-infinite-loop.d.ts

@@ -0,0 +1,5 @@
+export declare const seekInfiniteLoopDetectionState: () => {
+    registerSeek: (byte: number) => void;
+    reset: () => void;
+};
+export type SeekInfiniteLoop = ReturnType<typeof seekInfiniteLoopDetectionState>;

package/dist/readers/state/seek-infinite-loop.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seekInfiniteLoopDetectionState = void 0;
+const seekInfiniteLoopDetectionState = () => {
+    let lastSeek = null;
+    return {
+        registerSeek: (byte) => {
+            if (!lastSeek || lastSeek.byte !== byte) {
+                lastSeek = { byte, numberOfTimes: 1 };
+                return;
+            }
+            lastSeek.numberOfTimes++;
+            if (lastSeek.numberOfTimes >= 10) {
+                throw new Error(`Seeking infinite loop detected: Seeked to byte 0x${byte.toString(16)} ${lastSeek.numberOfTimes} times in a row with no position change in the file. Check your usage of .seek().`);
+            }
+        },
+        reset: () => {
+            lastSeek = null;
+        },
+    };
+};
+exports.seekInfiniteLoopDetectionState = seekInfiniteLoopDetectionState;

package/dist/readers/state/slow-duration-fps.d.ts

@@ -0,0 +1,11 @@
+import type { AudioOrVideoSample } from '../webcodec-sample-types';
+export declare const slowDurationAndFpsState: () => {
+    addVideoSample: (videoSample: AudioOrVideoSample) => void;
+    addAudioSample: (audioSample: AudioOrVideoSample) => void;
+    getSlowDurationInSeconds: () => number;
+    getFps: () => number;
+    getSlowNumberOfFrames: () => number;
+    getAudioBitrate: () => number | null;
+    getVideoBitrate: () => number | null;
+};
+export type SlowDurationAndFpsState = ReturnType<typeof slowDurationAndFpsState>;