@remotion/media-parser 4.0.302 → 4.0.303

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

@@ -1,6 +1,7 @@
 import type { MediaParserLogLevel } from './log';
 import type { M3uPlaylistContext } from './options';
 import type { SeekingHints } from './seeking-hints';
+import type { AvcState } from './state/avc/avc-state';
 import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
 import type { M3uState } from './state/m3u-state';
 import type { WebmState } from './state/matroska/webm';
@@ -9,7 +10,7 @@ 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, m3uPlaylistContext, structure, riffState, m3uState, }: {
+export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, m3uPlaylistContext, structure, riffState, m3uState, avcState, }: {
     info: SeekingHints;
     time: number;
     logLevel: MediaParserLogLevel;
@@ -22,4 +23,5 @@ export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, i
     m3uPlaylistContext: M3uPlaylistContext | null;
     riffState: RiffState;
     m3uState: M3uState;
+    avcState: AvcState;
 }) => Promise<SeekResolution>;

package/dist/get-seeking-byte.js

@@ -10,7 +10,7 @@ const get_seeking_byte_6 = require("./containers/riff/get-seeking-byte");
 const get_seeking_byte_7 = require("./containers/wav/get-seeking-byte");
 const get_seeking_byte_8 = 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, m3uPlaylistContext, structure, riffState, m3uState, }) => {
+const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, m3uPlaylistContext, structure, riffState, m3uState, avcState, }) => {
     var _a;
     if (info.type === 'iso-base-media-seeking-hints') {
         return (0, get_seeking_byte_3.getSeekingByteFromIsoBaseMedia)({
@@ -71,6 +71,7 @@ const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, trans
             info,
             time,
             riffState,
+            avcState,
         });
     }
     if (info.type === 'mp3-seeking-hints') {

package/dist/get-tracks.d.ts

@@ -38,6 +38,7 @@ export type MediaParserVideoTrack = {
     timescale: number;
     advancedColor: MediaParserAdvancedColor;
     m3uStreamFormat: 'ts' | 'mp4' | null;
+    startInSeconds: number;
 };
 export type MediaParserAudioTrack = {
     codec: string;
@@ -49,12 +50,14 @@ export type MediaParserAudioTrack = {
     codecEnum: MediaParserAudioCodec;
     timescale: number;
     codecData: MediaParserCodecData | null;
+    startInSeconds: number;
 };
 export type MediaParserOtherTrack = {
     type: 'other';
     trackId: number;
     timescale: number;
     trakBox: TrakBox | null;
+    startInSeconds: number;
 };
 export type MediaParserTrack = MediaParserVideoTrack | MediaParserAudioTrack | MediaParserOtherTrack;
 export declare const getNumberOfTracks: (moovBox: MoovBox) => number;

package/dist/get-tracks.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTracks = exports.defaultHasallTracks = exports.defaultGetTracks = exports.getTracksFromIsoBaseMedia = exports.getTracksFromMoovBox = exports.getHasTracks = exports.isoBaseMediaHasTracks = exports.getNumberOfTracks = void 0;
 const make_track_1 = require("./containers/iso-base-media/make-track");
+const get_editlist_1 = require("./containers/iso-base-media/mdat/get-editlist");
 const traversal_1 = require("./containers/iso-base-media/traversal");
 const get_tracks_from_avi_1 = require("./containers/riff/get-tracks-from-avi");
 const get_tracks_1 = require("./containers/transport-stream/get-tracks");
@@ -70,7 +71,15 @@ const getTracksFromMoovBox = (moovBox) => {
     const mediaParserTracks = [];
     const tracks = (0, traversal_1.getTraks)(moovBox);
     for (const trakBox of tracks) {
-        const track = (0, make_track_1.makeBaseMediaTrack)(trakBox);
+        const mvhdBox = (0, traversal_1.getMvhdBox)(moovBox);
+        if (!mvhdBox) {
+            throw new Error('Mvhd box is not found');
+        }
+        const startTime = (0, get_editlist_1.findTrackStartTimeInSeconds)({
+            movieTimeScale: mvhdBox.timeScale,
+            trakBox,
+        });
+        const track = (0, make_track_1.makeBaseMediaTrack)(trakBox, startTime);
         if (!track) {
             continue;
         }

package/dist/index.d.ts

@@ -777,6 +777,13 @@ export declare const MediaParserInternals: {
             onProfile: (profile: import("./state/parser-state").SpsAndPps) => Promise<void>;
             registerOnAvcProfileCallback: (callback: (profile: import("./state/parser-state").SpsAndPps) => Promise<void>) => void;
             getNextTrackIndex: () => number;
+            queuedBFrames: {
+                addFrame: (frame: import("./state/riff/queued-frames").QueuedVideoSample, maxFramesInBuffer: number) => void;
+                flush: () => void;
+                getReleasedFrame: () => import("./state/riff/queued-frames").QueuedVideoSample | null;
+                hasReleasedFrames: () => boolean;
+                clear: () => void;
+            };
             incrementNextTrackIndex: () => void;
             lazyIdx1: {
                 triggerLoad: (position: number) => Promise<{
@@ -799,14 +806,24 @@ export declare const MediaParserInternals: {
             };
             sampleCounter: {
                 onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").MediaParserAudioSample) => void;
-                onVideoSample: (trackId: number, videoSample: import("./webcodec-sample-types").MediaParserVideoSample) => void;
-                getSamplesForTrack: (trackId: number) => number;
+                onVideoSample: (videoSample: import("./webcodec-sample-types").MediaParserVideoSample) => void;
+                getSampleCountForTrack: ({ trackId }: {
+                    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;
                 };
+                setPocAtKeyframeOffset: ({ keyframeOffset, poc, }: {
+                    keyframeOffset: number;
+                    poc: number;
+                }) => void;
+                getPocAtKeyframeOffset: ({ keyframeOffset, }: {
+                    keyframeOffset: number;
+                }) => number[];
+                getKeyframeAtOffset: (sample: import("./state/riff/queued-frames").QueuedVideoSample) => number | null;
             };
         };
         transportStream: {
@@ -832,7 +849,7 @@ export declare const MediaParserInternals: {
             resetBeforeSeek: () => void;
             lastEmittedSample: {
                 setLastEmittedSample: (sample: import("./webcodec-sample-types").MediaParserAudioSample | import("./webcodec-sample-types").MediaParserVideoSample) => void;
-                getLastEmittedSample: () => import("./webcodec-sample-types").MediaParserAudioSample | import("./webcodec-sample-types").MediaParserVideoSample | null;
+                getLastEmittedSample: () => import("./webcodec-sample-types").MediaParserVideoSample | import("./webcodec-sample-types").MediaParserAudioSample | null;
                 resetLastEmittedSample: () => void;
             };
         };
@@ -895,6 +912,10 @@ export declare const MediaParserInternals: {
                 getTfraBoxes: () => import("./containers/iso-base-media/mfra/tfra").TfraBox[];
                 setTfraBoxes: (boxes: import("./containers/iso-base-media/mfra/tfra").TfraBox[]) => void;
             };
+            movieTimeScale: {
+                getTrackTimescale: () => number | null;
+                setTrackTimescale: (timescale: number) => void;
+            };
         };
         mp3: {
             getMp3Info: () => import("./state/mp3").Mp3Info | null;
@@ -1197,6 +1218,16 @@ export declare const MediaParserInternals: {
         };
         makeSamplesStartAtZero: boolean;
         prefetchCache: import("./fetch").PrefetchCache;
+        avc: {
+            getPrevPicOrderCntLsb(): number;
+            getPrevPicOrderCntMsb(): number;
+            setPrevPicOrderCntLsb(value: number): void;
+            setPrevPicOrderCntMsb(value: number): void;
+            setSps(value: import("./containers/avc/parse-avc").SpsInfo): void;
+            getSps(): import("./containers/avc/parse-avc").SpsInfo | null;
+            getMaxFramesInBuffer(): number | null;
+            clear(): void;
+        };
     };
     processSample: ({ iterator, logLevel, contentLength, }: {
         iterator: import("./iterator/buffer-iterator").BufferIterator;

package/dist/readers/from-fetch.js

@@ -135,7 +135,7 @@ const fetchReadContent = async ({ src, range, controller, logLevel, prefetchCach
         throw new Error('src must be a string when using `fetchReader`');
     }
     const fallbackName = src.toString().split('/').pop();
-    const { reader, contentLength, needsContentRange, name, supportsContentRange, contentType, } = await makeFetchRequestOrGetCached({
+    const res = makeFetchRequestOrGetCached({
         range,
         src,
         controller,
@@ -144,6 +144,7 @@ const fetchReadContent = async ({ src, range, controller, logLevel, prefetchCach
     });
     const key = cacheKey({ src, range });
     prefetchCache.delete(key);
+    const { reader, contentLength, needsContentRange, name, supportsContentRange, contentType, } = await res;
     if (controller) {
         controller._internals.signal.addEventListener('abort', () => {
             reader.reader.cancel().catch(() => {

package/dist/run-parse-iteration.js

@@ -17,9 +17,6 @@ const runParseIteration = async ({ state, }) => {
     if (structure && structure.type === 'm3u') {
         return (0, parse_m3u_1.parseM3u)({ state });
     }
-    if (state.iterator.bytesRemaining() === 0) {
-        return Promise.reject(new Error('no bytes'));
-    }
     if (structure === null) {
         await (0, init_video_1.initVideo)({
             state,

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

@@ -0,0 +1,12 @@
+import type { SpsInfo } from '../../containers/avc/parse-avc';
+export declare const avcState: () => {
+    getPrevPicOrderCntLsb(): number;
+    getPrevPicOrderCntMsb(): number;
+    setPrevPicOrderCntLsb(value: number): void;
+    setPrevPicOrderCntMsb(value: number): void;
+    setSps(value: SpsInfo): void;
+    getSps(): SpsInfo | null;
+    getMaxFramesInBuffer(): number | null;
+    clear(): void;
+};
+export type AvcState = ReturnType<typeof avcState>;

package/dist/state/avc/avc-state.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.avcState = void 0;
+const max_buffer_size_1 = require("../../containers/avc/max-buffer-size");
+const avcState = () => {
+    let prevPicOrderCntLsb = 0;
+    let prevPicOrderCntMsb = 0;
+    let sps = null;
+    let maxFramesInBuffer = null;
+    return {
+        getPrevPicOrderCntLsb() {
+            return prevPicOrderCntLsb;
+        },
+        getPrevPicOrderCntMsb() {
+            return prevPicOrderCntMsb;
+        },
+        setPrevPicOrderCntLsb(value) {
+            prevPicOrderCntLsb = value;
+        },
+        setPrevPicOrderCntMsb(value) {
+            prevPicOrderCntMsb = value;
+        },
+        setSps(value) {
+            const macroblockBufferSize = (0, max_buffer_size_1.macroBlocksPerFrame)(value);
+            const maxBufferSize = (0, max_buffer_size_1.maxMacroblockBufferSize)(value);
+            const maxFrames = Math.min(16, Math.floor(maxBufferSize / macroblockBufferSize));
+            maxFramesInBuffer = maxFrames;
+            sps = value;
+        },
+        getSps() {
+            return sps;
+        },
+        getMaxFramesInBuffer() {
+            return maxFramesInBuffer;
+        },
+        clear() {
+            maxFramesInBuffer = null;
+            sps = null;
+            prevPicOrderCntLsb = 0;
+            prevPicOrderCntMsb = 0;
+        },
+    };
+};
+exports.avcState = avcState;

package/dist/state/iso-base-media/iso-state.d.ts

@@ -40,5 +40,9 @@ export declare const isoBaseMediaState: ({ contentLength, controller, readerInte
         getTfraBoxes: () => import("../../containers/iso-base-media/mfra/tfra").TfraBox[];
         setTfraBoxes: (boxes: import("../../containers/iso-base-media/mfra/tfra").TfraBox[]) => void;
     };
+    movieTimeScale: {
+        getTrackTimescale: () => number | null;
+        setTrackTimescale: (timescale: number) => void;
+    };
 };
 export type IsoBaseMediaState = ReturnType<typeof isoBaseMediaState>;

package/dist/state/iso-base-media/iso-state.js

@@ -6,6 +6,7 @@ const lazy_mfra_load_1 = require("./lazy-mfra-load");
 const moov_box_1 = require("./moov-box");
 const precomputed_moof_1 = require("./precomputed-moof");
 const precomputed_tfra_1 = require("./precomputed-tfra");
+const timescale_state_1 = require("./timescale-state");
 const isoBaseMediaState = ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }) => {
     return {
         flatSamples: (0, cached_sample_positions_1.cachedSamplePositionsState)(),
@@ -20,6 +21,7 @@ const isoBaseMediaState = ({ contentLength, controller, readerInterface, src, lo
         }),
         moof: (0, precomputed_moof_1.precomputedMoofState)(),
         tfra: (0, precomputed_tfra_1.precomputedTfraState)(),
+        movieTimeScale: (0, timescale_state_1.movieTimeScaleState)(),
     };
 };
 exports.isoBaseMediaState = isoBaseMediaState;

package/dist/state/iso-base-media/timescale-state.d.ts

@@ -0,0 +1,5 @@
+export declare const movieTimeScaleState: () => {
+    getTrackTimescale: () => number | null;
+    setTrackTimescale: (timescale: number) => void;
+};
+export type MovieTimeScaleState = ReturnType<typeof movieTimeScaleState>;

package/dist/state/iso-base-media/timescale-state.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.movieTimeScaleState = void 0;
+const movieTimeScaleState = () => {
+    let trackTimescale = null;
+    return {
+        getTrackTimescale: () => trackTimescale,
+        setTrackTimescale: (timescale) => {
+            trackTimescale = timescale;
+        },
+    };
+};
+exports.movieTimeScaleState = movieTimeScaleState;

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

@@ -45,6 +45,13 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         onProfile: (profile: SpsAndPps) => Promise<void>;
         registerOnAvcProfileCallback: (callback: (profile: SpsAndPps) => Promise<void>) => void;
         getNextTrackIndex: () => number;
+        queuedBFrames: {
+            addFrame: (frame: import("./riff/queued-frames").QueuedVideoSample, maxFramesInBuffer: number) => void;
+            flush: () => void;
+            getReleasedFrame: () => import("./riff/queued-frames").QueuedVideoSample | null;
+            hasReleasedFrames: () => boolean;
+            clear: () => void;
+        };
         incrementNextTrackIndex: () => void;
         lazyIdx1: {
             triggerLoad: (position: number) => Promise<{
@@ -67,14 +74,24 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         };
         sampleCounter: {
             onAudioSample: (trackId: number, audioSample: import("../webcodec-sample-types").MediaParserAudioSample) => void;
-            onVideoSample: (trackId: number, videoSample: import("../webcodec-sample-types").MediaParserVideoSample) => void;
-            getSamplesForTrack: (trackId: number) => number;
+            onVideoSample: (videoSample: import("../webcodec-sample-types").MediaParserVideoSample) => void;
+            getSampleCountForTrack: ({ trackId }: {
+                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;
             };
+            setPocAtKeyframeOffset: ({ keyframeOffset, poc, }: {
+                keyframeOffset: number;
+                poc: number;
+            }) => void;
+            getPocAtKeyframeOffset: ({ keyframeOffset, }: {
+                keyframeOffset: number;
+            }) => number[];
+            getKeyframeAtOffset: (sample: import("./riff/queued-frames").QueuedVideoSample) => number | null;
         };
     };
     transportStream: {
@@ -100,7 +117,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         resetBeforeSeek: () => void;
         lastEmittedSample: {
             setLastEmittedSample: (sample: import("../webcodec-sample-types").MediaParserAudioSample | import("../webcodec-sample-types").MediaParserVideoSample) => void;
-            getLastEmittedSample: () => import("../webcodec-sample-types").MediaParserAudioSample | import("../webcodec-sample-types").MediaParserVideoSample | null;
+            getLastEmittedSample: () => import("../webcodec-sample-types").MediaParserVideoSample | import("../webcodec-sample-types").MediaParserAudioSample | null;
             resetLastEmittedSample: () => void;
         };
     };
@@ -163,6 +180,10 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
             getTfraBoxes: () => import("../containers/iso-base-media/mfra/tfra").TfraBox[];
             setTfraBoxes: (boxes: import("../containers/iso-base-media/mfra/tfra").TfraBox[]) => void;
         };
+        movieTimeScale: {
+            getTrackTimescale: () => number | null;
+            setTrackTimescale: (timescale: number) => void;
+        };
     };
     mp3: {
         getMp3Info: () => import("./mp3").Mp3Info | null;
@@ -465,5 +486,15 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     };
     makeSamplesStartAtZero: boolean;
     prefetchCache: PrefetchCache;
+    avc: {
+        getPrevPicOrderCntLsb(): number;
+        getPrevPicOrderCntMsb(): number;
+        setPrevPicOrderCntLsb(value: number): void;
+        setPrevPicOrderCntMsb(value: number): void;
+        setSps(value: import("../containers/avc/parse-avc").SpsInfo): void;
+        getSps(): import("../containers/avc/parse-avc").SpsInfo | null;
+        getMaxFramesInBuffer(): number | null;
+        clear(): void;
+    };
 };
 export type ParserState = ReturnType<typeof makeParserState>;

package/dist/state/parser-state.js

@@ -5,6 +5,7 @@ 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 avc_state_1 = require("./avc/avc-state");
 const current_reader_1 = require("./current-reader");
 const emitted_fields_1 = require("./emitted-fields");
 const flac_state_1 = require("./flac-state");
@@ -38,6 +39,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
     const timings = (0, timings_1.timingsState)();
     const seekInfiniteLoop = (0, seek_infinite_loop_1.seekInfiniteLoopDetectionState)();
     const currentReaderState = (0, current_reader_1.currentReader)(initialReaderInstance);
+    const avc = (0, avc_state_1.avcState)();
     const errored = null;
     const discardReadBytes = async (force) => {
         const { bytesRemoved, removedData } = iterator.removeBytesRead(force, mode);
@@ -135,6 +137,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         seekInfiniteLoop,
         makeSamplesStartAtZero,
         prefetchCache,
+        avc,
     };
 };
 exports.makeParserState = makeParserState;

package/dist/state/riff/queued-b-frames.d.ts

@@ -0,0 +1,9 @@
+import type { MediaParserVideoSample } from '../../webcodec-sample-types';
+export type QueuedVideoSample = Omit<MediaParserVideoSample, 'cts' | 'dts' | 'timestamp'>;
+export declare const queuedBFramesState: () => {
+    addFrame: (frame: QueuedVideoSample, maxFramesInBuffer: number) => void;
+    flush: () => void;
+    getReleasedFrame: () => QueuedVideoSample | null;
+    hasReleasedFrames: () => boolean;
+    clear: () => void;
+};

package/dist/state/riff/queued-b-frames.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queuedBFramesState = void 0;
+const queuedBFramesState = () => {
+    const queuedFrames = [];
+    const releasedFrames = [];
+    const sortFrames = () => {
+        queuedFrames.sort((a, b) => {
+            if (!a.avc || !b.avc || a.avc.poc === null || b.avc.poc === null) {
+                throw new Error('Invalid frame');
+            }
+            return a.avc.poc - b.avc.poc;
+        });
+    };
+    const flush = () => {
+        sortFrames();
+        releasedFrames.push(...queuedFrames);
+        queuedFrames.length = 0;
+    };
+    return {
+        addFrame: (frame, maxFramesInBuffer) => {
+            if (frame.type === 'key') {
+                flush();
+            }
+            queuedFrames.push(frame);
+            if (queuedFrames.length > maxFramesInBuffer) {
+                sortFrames();
+                releasedFrames.push(queuedFrames.shift());
+            }
+        },
+        flush,
+        getReleasedFrame: () => {
+            if (releasedFrames.length === 0) {
+                return null;
+            }
+            return releasedFrames.shift();
+        },
+        hasReleasedFrames: () => {
+            return releasedFrames.length > 0;
+        },
+        clear: () => {
+            releasedFrames.length = 0;
+            queuedFrames.length = 0;
+        },
+    };
+};
+exports.queuedBFramesState = queuedBFramesState;

package/dist/state/riff/queued-frames.d.ts

@@ -0,0 +1,9 @@
+import type { MediaParserVideoSample } from '../../webcodec-sample-types';
+export type QueuedVideoSample = Omit<MediaParserVideoSample, 'cts' | 'dts' | 'timestamp'>;
+export declare const queuedBFramesState: () => {
+    addFrame: (frame: QueuedVideoSample, maxFramesInBuffer: number) => void;
+    flush: () => void;
+    getReleasedFrame: () => QueuedVideoSample | null;
+    hasReleasedFrames: () => boolean;
+    clear: () => void;
+};

package/dist/state/riff/queued-frames.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queuedBFramesState = void 0;
+const queuedBFramesState = () => {
+    const queuedFrames = [];
+    const releasedFrames = [];
+    const flush = () => {
+        releasedFrames.push(...queuedFrames);
+        queuedFrames.length = 0;
+    };
+    return {
+        addFrame: (frame, maxFramesInBuffer) => {
+            if (frame.type === 'key') {
+                flush();
+                releasedFrames.push(frame);
+                return;
+            }
+            queuedFrames.push(frame);
+            if (queuedFrames.length > maxFramesInBuffer) {
+                releasedFrames.push(queuedFrames.shift());
+            }
+        },
+        flush,
+        getReleasedFrame: () => {
+            if (releasedFrames.length === 0) {
+                return null;
+            }
+            return releasedFrames.shift();
+        },
+        hasReleasedFrames: () => {
+            return releasedFrames.length > 0;
+        },
+        clear: () => {
+            releasedFrames.length = 0;
+            queuedFrames.length = 0;
+        },
+    };
+};
+exports.queuedBFramesState = queuedBFramesState;

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

@@ -8,6 +8,7 @@ const riffKeyframesState = () => {
             return;
         }
         keyframes.push(keyframe);
+        keyframes.sort((a, b) => a.positionInBytes - b.positionInBytes);
     };
     const getKeyframes = () => {
         return keyframes;

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

@@ -1,12 +1,23 @@
 import type { MediaParserAudioSample, MediaParserVideoSample } from '../../webcodec-sample-types';
+import type { QueuedVideoSample } from './queued-frames';
 export declare const riffSampleCounter: () => {
     onAudioSample: (trackId: number, audioSample: MediaParserAudioSample) => void;
-    onVideoSample: (trackId: number, videoSample: MediaParserVideoSample) => void;
-    getSamplesForTrack: (trackId: number) => number;
+    onVideoSample: (videoSample: MediaParserVideoSample) => void;
+    getSampleCountForTrack: ({ trackId }: {
+        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;
     };
+    setPocAtKeyframeOffset: ({ keyframeOffset, poc, }: {
+        keyframeOffset: number;
+        poc: number;
+    }) => void;
+    getPocAtKeyframeOffset: ({ keyframeOffset, }: {
+        keyframeOffset: number;
+    }) => number[];
+    getKeyframeAtOffset: (sample: QueuedVideoSample) => number | null;
 };

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

@@ -4,6 +4,8 @@ exports.riffSampleCounter = void 0;
 const riff_keyframes_1 = require("./riff-keyframes");
 const riffSampleCounter = () => {
     const samplesForTrack = {};
+    // keyframe offset -> poc[]
+    const pocsAtKeyframeOffset = {};
     const riffKeys = (0, riff_keyframes_1.riffKeyframesState)();
     const onAudioSample = (trackId, audioSample) => {
         if (typeof samplesForTrack[trackId] === 'undefined') {
@@ -14,13 +16,13 @@ const riffSampleCounter = () => {
         }
         samplesForTrack[trackId]++;
     };
-    const onVideoSample = (trackId, videoSample) => {
-        if (typeof samplesForTrack[trackId] === 'undefined') {
-            samplesForTrack[trackId] = 0;
+    const onVideoSample = (videoSample) => {
+        if (typeof samplesForTrack[videoSample.trackId] === 'undefined') {
+            samplesForTrack[videoSample.trackId] = 0;
         }
         if (videoSample.type === 'key') {
             riffKeys.addKeyframe({
-                trackId,
+                trackId: videoSample.trackId,
                 decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
                 positionInBytes: videoSample.offset,
                 presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
@@ -29,10 +31,10 @@ const riffSampleCounter = () => {
             });
         }
         if (videoSample.data.length > 0) {
-            samplesForTrack[trackId]++;
+            samplesForTrack[videoSample.trackId]++;
         }
     };
-    const getSamplesForTrack = (trackId) => {
+    const getSampleCountForTrack = ({ trackId }) => {
         var _a;
         return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
     };
@@ -41,12 +43,37 @@ const riffSampleCounter = () => {
             samplesForTrack[trackId] = samples[trackId];
         }
     };
+    const setPocAtKeyframeOffset = ({ keyframeOffset, poc, }) => {
+        if (typeof pocsAtKeyframeOffset[keyframeOffset] === 'undefined') {
+            pocsAtKeyframeOffset[keyframeOffset] = [];
+        }
+        if (pocsAtKeyframeOffset[keyframeOffset].includes(poc)) {
+            return;
+        }
+        pocsAtKeyframeOffset[keyframeOffset].push(poc);
+        pocsAtKeyframeOffset[keyframeOffset].sort((a, b) => a - b);
+    };
+    const getPocAtKeyframeOffset = ({ keyframeOffset, }) => {
+        return pocsAtKeyframeOffset[keyframeOffset];
+    };
+    const getKeyframeAtOffset = (sample) => {
+        var _a, _b;
+        if (sample.type === 'key') {
+            return sample.offset;
+        }
+        return ((_b = (_a = riffKeys
+            .getKeyframes()
+            .findLast((k) => k.positionInBytes <= sample.offset)) === null || _a === void 0 ? void 0 : _a.positionInBytes) !== null && _b !== void 0 ? _b : null);
+    };
     return {
         onAudioSample,
         onVideoSample,
-        getSamplesForTrack,
+        getSampleCountForTrack,
         setSamplesFromSeek,
         riffKeys,
+        setPocAtKeyframeOffset,
+        getPocAtKeyframeOffset,
+        getKeyframeAtOffset,
     };
 };
 exports.riffSampleCounter = riffSampleCounter;