@remotion/media-parser 4.0.285 → 4.0.286

package/dist/readers/from-web-file.js

@@ -36,7 +36,7 @@ const webFileReadContent = ({ src, range, controller }) => {
                     },
                 },
                 contentLength: src.size,
-                name: src.name,
+                name: src instanceof File ? src.name : src.toString(),
                 supportsContentRange: true,
                 contentType: src.type,
                 needsContentRange: true,

package/dist/register-track.d.ts

@@ -5,18 +5,15 @@ import type { TracksState } from './state/has-tracks-section';
 import type { ParserState } from './state/parser-state';
 import type { SampleCallbacks } from './state/sample-callbacks';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
-import type { WorkOnSeekRequestOptions } from './work-on-seek-request';
-export declare const registerVideoTrack: ({ track, container, logLevel, workOnSeekRequestOptions, onVideoTrack, registerVideoSampleCallback, tracks, }: {
+export declare const registerVideoTrack: ({ track, container, logLevel, onVideoTrack, registerVideoSampleCallback, tracks, }: {
     track: Track;
     container: MediaParserContainer;
     logLevel: LogLevel;
-    workOnSeekRequestOptions: WorkOnSeekRequestOptions | null;
     onVideoTrack: OnVideoTrack | null;
     registerVideoSampleCallback: SampleCallbacks["registerVideoSampleCallback"];
     tracks: TracksState;
 }) => Promise<import("./webcodec-sample-types").OnVideoSample | null>;
-export declare const registerAudioTrack: ({ workOnSeekRequestOptions, track, container, tracks, logLevel, onAudioTrack, registerAudioSampleCallback, }: {
-    workOnSeekRequestOptions: WorkOnSeekRequestOptions | null;
+export declare const registerAudioTrack: ({ track, container, tracks, logLevel, onAudioTrack, registerAudioSampleCallback, }: {
     track: AudioTrack;
     container: MediaParserContainer;
     tracks: TracksState;

package/dist/register-track.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerVideoTrackWhenProfileIsAvailable = exports.registerAudioTrack = exports.registerVideoTrack = void 0;
 const add_avc_profile_to_track_1 = require("./add-avc-profile-to-track");
 const log_1 = require("./log");
-const work_on_seek_request_1 = require("./work-on-seek-request");
-const registerVideoTrack = async ({ track, container, logLevel, workOnSeekRequestOptions, onVideoTrack, registerVideoSampleCallback, tracks, }) => {
+const registerVideoTrack = async ({ track, container, logLevel, onVideoTrack, registerVideoSampleCallback, tracks, }) => {
     if (tracks.getTracks().find((t) => t.trackId === track.trackId)) {
         log_1.Log.trace(logLevel, `Track ${track.trackId} already registered, skipping`);
         return null;
@@ -21,13 +20,10 @@ const registerVideoTrack = async ({ track, container, logLevel, workOnSeekReques
         container,
     });
     await registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
-    if (workOnSeekRequestOptions) {
-        await (0, work_on_seek_request_1.workOnSeekRequest)(workOnSeekRequestOptions);
-    }
     return callback;
 };
 exports.registerVideoTrack = registerVideoTrack;
-const registerAudioTrack = async ({ workOnSeekRequestOptions, track, container, tracks, logLevel, onAudioTrack, registerAudioSampleCallback, }) => {
+const registerAudioTrack = async ({ track, container, tracks, logLevel, onAudioTrack, registerAudioSampleCallback, }) => {
     if (tracks.getTracks().find((t) => t.trackId === track.trackId)) {
         log_1.Log.trace(logLevel, `Track ${track.trackId} already registered, skipping`);
         return null;
@@ -44,16 +40,12 @@ const registerAudioTrack = async ({ workOnSeekRequestOptions, track, container,
         container,
     });
     await registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
-    if (workOnSeekRequestOptions) {
-        await (0, work_on_seek_request_1.workOnSeekRequest)(workOnSeekRequestOptions);
-    }
     return callback;
 };
 exports.registerAudioTrack = registerAudioTrack;
 const registerVideoTrackWhenProfileIsAvailable = ({ state, track, container, }) => {
     state.riff.registerOnAvcProfileCallback(async (profile) => {
         await (0, exports.registerVideoTrack)({
-            workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
             track: (0, add_avc_profile_to_track_1.addAvcProfileToTrack)(track, profile),
             container,
             logLevel: state.logLevel,

package/dist/seek-backwards.js

@@ -4,15 +4,14 @@ exports.seekBackwards = void 0;
 const log_1 = require("./log");
 const seekBackwards = async ({ iterator, seekTo, readerInterface, src, controller, logLevel, currentReader, }) => {
     // (a) data has not been discarded yet
-    const howManyBytesNotYetDiscarded = iterator.counter.getDiscardedOffset();
-    const howManyBytesWeCanGoBack = iterator.counter.getOffset() - howManyBytesNotYetDiscarded;
+    const howManyBytesWeCanGoBack = iterator.counter.getDiscardedOffset();
     if (iterator.counter.getOffset() - howManyBytesWeCanGoBack <= seekTo) {
         iterator.skipTo(seekTo);
         return;
     }
     // (b) data has been discarded, making new reader
     const time = Date.now();
-    log_1.Log.verbose(logLevel, `Seeking in video from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
+    log_1.Log.verbose(logLevel, `Seeking in video from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available.`);
     const { reader: newReader } = await readerInterface.read({
         src,
         range: seekTo,

package/dist/seeking-info.d.ts

@@ -1,6 +1,7 @@
 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 { PacketPes } from './containers/transport-stream/parse-pes';
 import type { MediaSection } from './state/video-section';
 export type IsoBaseMediaSeekingInfo = {
     type: 'iso-base-media-seeking-info';
@@ -15,4 +16,16 @@ export type WavSeekingInfo = {
     blockAlign: number;
     mediaSections: MediaSection;
 };
-export type SeekingInfo = IsoBaseMediaSeekingInfo | WavSeekingInfo;
+export type TransportStreamSeekingInfo = {
+    type: 'transport-stream-seeking-info';
+    observedPesHeaders: PacketPes[];
+    ptsStartOffset: number;
+};
+export type WebmSeekingInfo = {
+    type: 'webm-seeking-info';
+    track: null | {
+        timescale: number;
+        trackId: number;
+    };
+};
+export type SeekingInfo = IsoBaseMediaSeekingInfo | WavSeekingInfo | TransportStreamSeekingInfo | WebmSeekingInfo;

package/dist/state/iso-base-media/cached-sample-positions.d.ts

@@ -6,7 +6,7 @@ export type FlatSample = {
     samplePosition: SamplePosition;
 };
 export declare const calculateFlatSamples: (state: ParserState) => {
-    track: AudioTrack | VideoTrack | OtherTrack;
+    track: VideoTrack | AudioTrack | OtherTrack;
     samplePosition: SamplePosition;
 }[];
 export declare const cachedSamplePositionsState: () => {

package/dist/state/keyframes.js

@@ -5,6 +5,9 @@ const keyframesState = () => {
     const keyframes = [];
     return {
         addKeyframe: (keyframe) => {
+            if (keyframes.find((k) => k.positionInBytes === keyframe.positionInBytes)) {
+                return;
+            }
             keyframes.push(keyframe);
         },
         getKeyframes: () => {

package/dist/state/matroska/lazy-cues-fetch.d.ts

@@ -0,0 +1,19 @@
+import type { MatroskaCue } from '../../containers/webm/seek/format-cues';
+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 lazyCuesFetch: ({ controller, logLevel, readerInterface, src, }: {
+    controller: MediaParserController;
+    logLevel: LogLevel;
+    readerInterface: ReaderInterface;
+    src: ParseMediaSrc;
+}) => {
+    triggerLoad: (position: number, segmentOffset: number) => Promise<MatroskaCue[] | null>;
+    getLoadedCues: () => Promise<{
+        cues: MatroskaCue[];
+        segmentOffset: number;
+    } | null>;
+};
+export type LazyCuesFetch = ReturnType<typeof lazyCuesFetch>;
+export type LazyCuesLoaded = Awaited<ReturnType<LazyCuesFetch['getLoadedCues']>>;

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyCuesFetch = void 0;
+const fetch_web_cues_1 = require("../../containers/webm/seek/fetch-web-cues");
+const log_1 = require("../../log");
+const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, }) => {
+    let prom = null;
+    let sOffset = null;
+    const triggerLoad = (position, segmentOffset) => {
+        if (prom) {
+            return prom;
+        }
+        if (sOffset && sOffset !== segmentOffset) {
+            throw new Error('Segment offset mismatch');
+        }
+        sOffset = segmentOffset;
+        log_1.Log.verbose(logLevel, 'Cues box found, trying to lazy load cues');
+        prom = (0, fetch_web_cues_1.fetchWebmCues)({
+            controller,
+            logLevel,
+            position,
+            readerInterface,
+            src,
+        }).then((cues) => {
+            log_1.Log.verbose(logLevel, 'Cues loaded');
+            return cues;
+        });
+        return prom;
+    };
+    const getLoadedCues = async () => {
+        if (!prom) {
+            return null;
+        }
+        const cues = await prom;
+        if (!cues) {
+            return null;
+        }
+        if (!sOffset) {
+            throw new Error('Segment offset not set');
+        }
+        return {
+            cues,
+            segmentOffset: sOffset,
+        };
+    };
+    return {
+        triggerLoad,
+        getLoadedCues,
+    };
+};
+exports.lazyCuesFetch = lazyCuesFetch;

package/dist/state/matroska/lazy-seek-fetch.d.ts

@@ -0,0 +1 @@
+export declare const lazySeekFetch: () => void;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazySeekFetch = void 0;
+const lazySeekFetch = () => { };
+exports.lazySeekFetch = lazySeekFetch;

package/dist/state/matroska/webm.d.ts

@@ -0,0 +1,46 @@
+import type { AvcProfileInfo } from '../../containers/avc/parse-avc';
+import type { OnTrackEntrySegment } from '../../containers/webm/segments';
+import type { TrackInfo } from '../../containers/webm/segments/track-entry';
+import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { BufferIterator } from '../../iterator/buffer-iterator';
+import type { LogLevel } from '../../log';
+import type { ParseMediaSrc } from '../../options';
+import type { ReaderInterface } from '../../readers/reader';
+export type SegmentSection = {
+    start: number;
+    size: number;
+    index: number;
+};
+export type ClusterSection = {
+    start: number;
+    size: number;
+    segment: number;
+};
+export declare const webmState: ({ controller, logLevel, readerInterface, src, }: {
+    controller: MediaParserController;
+    logLevel: LogLevel;
+    readerInterface: ReaderInterface;
+    src: ParseMediaSrc;
+}) => {
+    cues: {
+        triggerLoad: (position: number, segmentOffset: number) => Promise<import("../../containers/webm/seek/format-cues").MatroskaCue[] | null>;
+        getLoadedCues: () => Promise<{
+            cues: import("../../containers/webm/seek/format-cues").MatroskaCue[];
+            segmentOffset: number;
+        } | null>;
+    };
+    onTrackEntrySegment: OnTrackEntrySegment;
+    getTrackInfoByNumber: (id: number) => TrackInfo;
+    setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+    getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+    getTimescale: () => number;
+    setTimescale: (newTimescale: number) => void;
+    addSegment: (seg: Omit<SegmentSection, "index">) => void;
+    addCluster: (cluster: ClusterSection) => void;
+    getFirstCluster: () => ClusterSection | undefined;
+    isInsideSegment: (iterator: BufferIterator) => SegmentSection | null;
+    isInsideCluster: (offset: number) => ClusterSection | null;
+    setAvcProfileForTrackNumber: (trackNumber: number, avcProfile: AvcProfileInfo) => void;
+    getAvcProfileForTrackNumber: (trackNumber: number) => AvcProfileInfo | null;
+};
+export type WebmState = ReturnType<typeof webmState>;

package/dist/state/matroska/webm.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webmState = void 0;
+const traversal_1 = require("../../containers/webm/traversal");
+const lazy_cues_fetch_1 = require("./lazy-cues-fetch");
+const webmState = ({ controller, logLevel, readerInterface, src, }) => {
+    const trackEntries = {};
+    const onTrackEntrySegment = (trackEntry) => {
+        var _a;
+        const trackId = (0, traversal_1.getTrackId)(trackEntry);
+        if (!trackId) {
+            throw new Error('Expected track id');
+        }
+        if (trackEntries[trackId]) {
+            return;
+        }
+        const codec = (0, traversal_1.getTrackCodec)(trackEntry);
+        if (!codec) {
+            throw new Error('Expected codec');
+        }
+        const trackTimescale = (0, traversal_1.getTrackTimestampScale)(trackEntry);
+        trackEntries[trackId] = {
+            codec: codec.value,
+            trackTimescale: (_a = trackTimescale === null || trackTimescale === void 0 ? void 0 : trackTimescale.value) !== null && _a !== void 0 ? _a : null,
+        };
+    };
+    const timestampMap = new Map();
+    const getTimestampOffsetForByteOffset = (byteOffset) => {
+        const entries = Array.from(timestampMap.entries());
+        const sortedByByteOffset = entries
+            .sort((a, b) => {
+            return a[0] - b[0];
+        })
+            .reverse();
+        for (const [offset, timestamp] of sortedByByteOffset) {
+            if (offset >= byteOffset) {
+                continue;
+            }
+            return timestamp;
+        }
+        return timestampMap.get(byteOffset);
+    };
+    const setTimestampOffset = (byteOffset, timestamp) => {
+        timestampMap.set(byteOffset, timestamp);
+    };
+    let timescale = null;
+    const setTimescale = (newTimescale) => {
+        timescale = newTimescale;
+    };
+    const getTimescale = () => {
+        // https://www.matroska.org/technical/notes.html
+        // When using the default value of TimestampScale of “1,000,000”, one Segment Tick represents one millisecond.
+        if (timescale === null) {
+            return 1000000;
+        }
+        return timescale;
+    };
+    const segments = [];
+    const clusters = [];
+    const avcProfilesMap = {};
+    const setAvcProfileForTrackNumber = (trackNumber, avcProfile) => {
+        avcProfilesMap[trackNumber] = avcProfile;
+    };
+    const getAvcProfileForTrackNumber = (trackNumber) => {
+        var _a;
+        return (_a = avcProfilesMap[trackNumber]) !== null && _a !== void 0 ? _a : null;
+    };
+    const cues = (0, lazy_cues_fetch_1.lazyCuesFetch)({
+        controller,
+        logLevel,
+        readerInterface,
+        src,
+    });
+    return {
+        cues,
+        onTrackEntrySegment,
+        getTrackInfoByNumber: (id) => trackEntries[id],
+        setTimestampOffset,
+        getTimestampOffsetForByteOffset,
+        getTimescale,
+        setTimescale,
+        addSegment: (seg) => {
+            const segment = {
+                ...seg,
+                index: segments.length,
+            };
+            segments.push(segment);
+        },
+        addCluster: (cluster) => {
+            const exists = clusters.some((existingCluster) => existingCluster.start === cluster.start);
+            if (!exists) {
+                clusters.push(cluster);
+            }
+        },
+        getFirstCluster: () => {
+            return clusters.find((cluster) => cluster.segment === 0);
+        },
+        isInsideSegment: (iterator) => {
+            var _a;
+            const offset = iterator.counter.getOffset();
+            const insideClusters = segments.filter((cluster) => {
+                return (offset >= cluster.start && offset <= cluster.start + cluster.size);
+            });
+            if (insideClusters.length > 1) {
+                throw new Error('Expected to only be inside 1 cluster');
+            }
+            return (_a = insideClusters[0]) !== null && _a !== void 0 ? _a : null;
+        },
+        isInsideCluster: (offset) => {
+            for (const cluster of clusters) {
+                if (offset >= cluster.start && offset <= cluster.start + cluster.size) {
+                    return cluster;
+                }
+            }
+            return null;
+        },
+        setAvcProfileForTrackNumber,
+        getAvcProfileForTrackNumber,
+    };
+};
+exports.webmState = webmState;

package/dist/state/matroska.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -16,7 +16,7 @@ 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, }: {
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     controller: MediaParserController;
@@ -37,6 +37,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     fieldsInReturnValue: Options<ParseMediaFields>;
     mimeType: string | null;
     initialReaderInstance: Reader;
+    makeSamplesStartAtZero: boolean;
 }) => {
     riff: {
         getAvcProfile: () => SpsAndPps | null;
@@ -50,20 +51,43 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
             setNextPesHeader: (pesHeader: import("../containers/transport-stream/parse-pes").PacketPes) => void;
             getNextPesHeader: () => import("../containers/transport-stream/parse-pes").PacketPes;
         };
+        observedPesHeaders: {
+            pesHeaders: import("../containers/transport-stream/parse-pes").PacketPes[];
+            addPesHeader: (pesHeader: import("../containers/transport-stream/parse-pes").PacketPes) => void;
+            markPtsAsKeyframe: (pts: number) => void;
+            getPesKeyframeHeaders: () => import("../containers/transport-stream/parse-pes").PacketPes[];
+        };
         streamBuffers: Map<number, import("../containers/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
+        startOffset: {
+            getOffset: (trackId: number) => number;
+            setOffset: (trackId: number, newOffset: number) => void;
+        };
+        resetBeforeSeek: () => void;
+        lastEmittedSample: {
+            setLastEmittedSample: (sample: import("../webcodec-sample-types").AudioOrVideoSample) => void;
+            getLastEmittedSample: () => import("../webcodec-sample-types").AudioOrVideoSample | null;
+            resetLastEmittedSample: () => void;
+        };
     };
     webm: {
+        cues: {
+            triggerLoad: (position: number, segmentOffset: number) => Promise<import("../containers/webm/seek/format-cues").MatroskaCue[] | null>;
+            getLoadedCues: () => Promise<{
+                cues: import("../containers/webm/seek/format-cues").MatroskaCue[];
+                segmentOffset: number;
+            } | null>;
+        };
         onTrackEntrySegment: import("../containers/webm/segments").OnTrackEntrySegment;
         getTrackInfoByNumber: (id: number) => import("../containers/webm/segments/track-entry").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: BufferIterator) => import("./webm").SegmentSection | null;
-        isInsideCluster: (iterator: BufferIterator) => import("./webm").ClusterSection | null;
+        addSegment: (seg: Omit<import("./matroska/webm").SegmentSection, "index">) => void;
+        addCluster: (cluster: import("./matroska/webm").ClusterSection) => void;
+        getFirstCluster: () => import("./matroska/webm").ClusterSection | undefined;
+        isInsideSegment: (iterator: BufferIterator) => import("./matroska/webm").SegmentSection | null;
+        isInsideCluster: (offset: number) => import("./matroska/webm").ClusterSection | null;
         setAvcProfileForTrackNumber: (trackNumber: number, avcProfile: AvcProfileInfo) => void;
         getAvcProfileForTrackNumber: (trackNumber: number) => AvcProfileInfo | null;
     };
@@ -246,12 +270,12 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         leb128: () => number;
         removeBytesRead: (force: boolean, mode: ParseMediaMode) => {
             bytesRemoved: number;
-            removedData: Uint8Array | null;
+            removedData: Uint8Array<ArrayBuffer> | null;
         };
         discard: (length: number) => void;
         getEightByteNumber: (littleEndian?: boolean) => number;
         getFourByteNumber: () => number;
-        getSlice: (amount: number) => Uint8Array;
+        getSlice: (amount: number) => Uint8Array<ArrayBuffer>;
         getAtom: () => string;
         detectFileType: () => import("../file-types/detect-file-type").FileType;
         getPaddedFourByteNumber: () => number;
@@ -275,7 +299,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getUint(length: number): number;
         getByteString(length: number, trimTrailingZeroes: boolean): string;
         planBytes: (size: number) => {
-            discardRest: () => Uint8Array;
+            discardRest: () => Uint8Array<ArrayBuffer>;
         };
         getFloat64: () => number;
         readUntilNullTerminator: () => string;
@@ -320,5 +344,6 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         registerSeek: (byte: number) => void;
         reset: () => void;
     };
+    makeSamplesStartAtZero: boolean;
 };
 export type ParserState = ReturnType<typeof makeParserState>;

package/dist/state/parser-state.js

@@ -12,17 +12,17 @@ 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 webm_1 = require("./matroska/webm");
 const mp3_1 = require("./mp3");
 const riff_1 = require("./riff");
 const sample_callbacks_1 = require("./sample-callbacks");
+const slow_duration_fps_1 = require("./samples-observed/slow-duration-fps");
 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");
+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, }) => {
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, }) => {
     let skippedBytes = 0;
     const returnValue = {};
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), contentLength);
@@ -32,7 +32,7 @@ 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.slowDurationAndFpsState)();
+    const slowDurationAndFps = (0, slow_duration_fps_1.samplesObservedState)();
     const mp3Info = (0, mp3_1.makeMp3State)();
     const images = (0, images_1.imagesState)();
     const timings = (0, timings_1.timingsState)();
@@ -55,7 +55,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
     return {
         riff: (0, riff_1.riffSpecificState)(),
         transportStream: (0, transport_stream_1.transportStreamState)(),
-        webm: (0, webm_1.webmState)(),
+        webm: (0, webm_1.webmState)({ controller, logLevel, readerInterface, src }),
         iso: (0, iso_state_1.isoBaseMediaState)({
             contentLength,
             controller,
@@ -119,6 +119,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         errored: errored,
         currentReader: currentReaderState,
         seekInfiniteLoop,
+        makeSamplesStartAtZero,
     };
 };
 exports.makeParserState = makeParserState;

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

@@ -5,7 +5,7 @@ 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 { SlowDurationAndFpsState } 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, }: {
     controller: MediaParserController;

package/dist/state/sample-callbacks.js

@@ -79,19 +79,19 @@ const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
                     }
                 }
             }
+            if (videoSample.type === 'key') {
+                keyframes.addKeyframe({
+                    trackId,
+                    decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+                    positionInBytes: videoSample.offset,
+                    presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+                    sizeInBytes: videoSample.data.length,
+                });
+            }
             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);
             }
         },

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

@@ -0,0 +1,11 @@
+import type { AudioOrVideoSample } from '../../webcodec-sample-types';
+export declare const samplesObservedState: () => {
+    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 samplesObservedState>;