@remotion/media-parser 4.0.241 → 4.0.243

package/dist/parse-video.d.ts

@@ -1,8 +1,8 @@
 import type { BufferIterator } from './buffer-iterator';
 import { type LogLevel } from './log';
 import type { Options, ParseMediaFields } from './options';
-import type { IsoBaseMediaBox, ParseResult, Structure } from './parse-result';
-import type { ParserContext } from './parser-context';
+import type { IsoBaseMediaBox, ParseResult } from './parse-result';
+import type { ParserState } from './state/parser-state';
 export type PartialMdatBox = {
     type: 'partial-mdat-box';
     boxSize: number;
@@ -16,13 +16,13 @@ export type BoxAndNext = {
 } | {
     type: 'incomplete';
 } | PartialMdatBox;
-export declare const parseVideo: ({ iterator, options, signal, logLevel, fields, mimeType, contentLength, name, }: {
+export declare const parseVideo: ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }: {
     iterator: BufferIterator;
-    options: ParserContext;
+    state: ParserState;
     signal: AbortSignal | null;
     logLevel: LogLevel;
     fields: Options<ParseMediaFields>;
     mimeType: string | null;
     contentLength: number | null;
     name: string | null;
-}) => Promise<ParseResult<Structure>>;
+}) => Promise<ParseResult>;

package/dist/parse-video.js

@@ -8,23 +8,32 @@ const parse_transport_stream_1 = require("./boxes/transport-stream/parse-transpo
 const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
 const errors_1 = require("./errors");
 const log_1 = require("./log");
-const parseVideo = ({ iterator, options, signal, logLevel, fields, mimeType, contentLength, name, }) => {
+const parseVideo = ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }) => {
     if (iterator.bytesRemaining() === 0) {
         return Promise.reject(new Error('no bytes'));
     }
     const fileType = iterator.detectFileType();
     if (fileType.type === 'riff') {
         log_1.Log.verbose(logLevel, 'Detected RIFF container');
-        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, options, fields }));
+        state.structure.setStructure({
+            type: 'riff',
+            boxes: [],
+        });
+        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, state, fields }));
     }
     if (fileType.type === 'iso-base-media') {
         log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
+        const initialBoxes = [];
+        state.structure.setStructure({
+            type: 'iso-base-media',
+            boxes: initialBoxes,
+        });
         return (0, process_box_1.parseIsoBaseMediaBoxes)({
             iterator,
             maxBytes: Infinity,
             allowIncompleteBoxes: true,
-            initialBoxes: [],
-            options,
+            initialBoxes,
+            state,
             continueMdat: false,
             signal,
             logLevel,
@@ -33,16 +42,21 @@ const parseVideo = ({ iterator, options, signal, logLevel, fields, mimeType, con
     }
     if (fileType.type === 'webm') {
         log_1.Log.verbose(logLevel, 'Detected Matroska container');
-        return (0, parse_webm_header_1.parseWebm)({ counter: iterator, parserContext: options, fields });
+        state.structure.setStructure({
+            boxes: [],
+            type: 'matroska',
+        });
+        return (0, parse_webm_header_1.parseWebm)({ counter: iterator, state, fields });
     }
     if (fileType.type === 'transport-stream') {
+        log_1.Log.verbose(logLevel, 'Detected MPEG-2 Transport Stream');
+        state.structure.setStructure({
+            boxes: [],
+            type: 'transport-stream',
+        });
         return (0, parse_transport_stream_1.parseTransportStream)({
             iterator,
-            parserContext: options,
-            structure: {
-                type: 'transport-stream',
-                boxes: [],
-            },
+            state,
             streamBuffers: new Map(),
             fields,
             nextPesHeaderStore: (0, next_pes_header_store_1.makeNextPesHeaderStore)(),

package/dist/register-track.d.ts

@@ -1,13 +1,13 @@
 import type { Track, VideoTrack } from './get-tracks';
 import type { ParseMediaContainer } from './options';
-import type { ParserContext } from './parser-context';
-export declare const registerTrack: ({ options, track, container, }: {
-    options: ParserContext;
+import type { ParserState } from './state/parser-state';
+export declare const registerTrack: ({ state, track, container, }: {
+    state: ParserState;
     track: Track;
     container: ParseMediaContainer;
 }) => Promise<void>;
-export declare const registerVideoTrackWhenProfileIsAvailable: ({ options, track, container, }: {
-    options: ParserContext;
+export declare const registerVideoTrackWhenProfileIsAvailable: ({ state, track, container, }: {
+    state: ParserState;
     track: VideoTrack;
     container: ParseMediaContainer;
 }) => void;

package/dist/register-track.js

@@ -2,27 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerVideoTrackWhenProfileIsAvailable = exports.registerTrack = void 0;
 const add_avc_profile_to_track_1 = require("./add-avc-profile-to-track");
-const registerTrack = async ({ options, track, container, }) => {
+const registerTrack = async ({ state, track, container, }) => {
     if (track.type === 'video') {
-        options.parserState.tracks.addTrack(track);
-        if (options.onVideoTrack) {
-            const callback = await options.onVideoTrack({ track, container });
-            await options.parserState.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+        state.callbacks.tracks.addTrack(track);
+        if (state.onVideoTrack) {
+            const callback = await state.onVideoTrack({ track, container });
+            await state.callbacks.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
         }
     }
     if (track.type === 'audio') {
-        options.parserState.tracks.addTrack(track);
-        if (options.onAudioTrack) {
-            const callback = await options.onAudioTrack({ track, container });
-            await options.parserState.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+        state.callbacks.tracks.addTrack(track);
+        if (state.onAudioTrack) {
+            const callback = await state.onAudioTrack({ track, container });
+            await state.callbacks.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
         }
     }
 };
 exports.registerTrack = registerTrack;
-const registerVideoTrackWhenProfileIsAvailable = ({ options, track, container, }) => {
-    options.parserState.registerOnAvcProfileCallback(async (profile) => {
+const registerVideoTrackWhenProfileIsAvailable = ({ state, track, container, }) => {
+    state.riff.registerOnAvcProfileCallback(async (profile) => {
         await (0, exports.registerTrack)({
-            options,
+            state,
             track: (0, add_avc_profile_to_track_1.addAvcProfileToTrack)(track, profile),
             container,
         });

package/dist/state/can-skip-tracks.js

@@ -6,6 +6,8 @@ const needsTracksField = {
     container: false,
     dimensions: true,
     durationInSeconds: true,
+    slowDurationInSeconds: true,
+    slowFps: true,
     fps: true,
     internalStats: false,
     isHdr: true,
@@ -19,6 +21,9 @@ const needsTracksField = {
     metadata: true,
     location: true,
     mimeType: false,
+    slowKeyframes: true,
+    slowNumberOfFrames: true,
+    keyframes: true,
 };
 const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, }) => {
     return {

package/dist/state/emitted-fields.d.ts

@@ -0,0 +1,2 @@
+import type { AllOptions, ParseMediaFields } from '../options';
+export declare const emittedState: () => AllOptions<ParseMediaFields>;

package/dist/state/emitted-fields.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emittedState = void 0;
+const emittedState = () => {
+    const emittedFields = {
+        audioCodec: false,
+        container: false,
+        dimensions: false,
+        durationInSeconds: false,
+        fps: false,
+        internalStats: false,
+        isHdr: false,
+        location: false,
+        metadata: false,
+        mimeType: false,
+        name: false,
+        rotation: false,
+        size: false,
+        structure: false,
+        tracks: false,
+        videoCodec: false,
+        unrotatedDimensions: false,
+        slowDurationInSeconds: false,
+        slowFps: false,
+        slowKeyframes: false,
+        slowNumberOfFrames: false,
+        keyframes: false,
+    };
+    return emittedFields;
+};
+exports.emittedState = emittedState;

package/dist/state/has-tracks-section.d.ts

@@ -7,3 +7,4 @@ export declare const makeTracksSectionState: (canSkipTracksState: CanSkipTracksS
     getTracks: () => Track[];
     ensureHasTracksAtEnd: () => void;
 };
+export type TracksState = ReturnType<typeof makeTracksSectionState>;

package/dist/state/keyframes.d.ts

@@ -0,0 +1,6 @@
+import type { MediaParserKeyframe } from '../options';
+export declare const keyframesState: () => {
+    addKeyframe: (keyframe: MediaParserKeyframe) => void;
+    getKeyframes: () => MediaParserKeyframe[];
+};
+export type KeyframesState = ReturnType<typeof keyframesState>;

package/dist/state/keyframes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyframesState = void 0;
+const keyframesState = () => {
+    const keyframes = [];
+    return {
+        addKeyframe: (keyframe) => {
+            keyframes.push(keyframe);
+        },
+        getKeyframes: () => {
+            return keyframes;
+        },
+    };
+};
+exports.keyframesState = keyframesState;

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

@@ -1,9 +1,7 @@
 import type { AvcPPs, AvcProfileInfo } from '../boxes/avc/parse-avc';
-import type { OnTrackEntrySegment } from '../boxes/webm/segments';
-import type { TrackInfo } from '../boxes/webm/segments/track-entry';
 import type { BufferIterator } from '../buffer-iterator';
 import type { Options, ParseMediaFields } from '../options';
-import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
+import type { OnAudioTrack, OnVideoTrack } from '../webcodec-sample-types';
 export type InternalStats = {
     skippedBytes: number;
     finalCursorOffset: number;
@@ -12,42 +10,75 @@ export type SpsAndPps = {
     sps: AvcProfileInfo;
     pps: AvcPPs;
 };
-type AvcProfileInfoCallback = (profile: SpsAndPps) => Promise<void>;
-export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, }: {
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, nullifySamples, onAudioTrack, onVideoTrack, supportsContentRange, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     signal: AbortSignal | undefined;
     getIterator: () => BufferIterator | null;
     fields: Options<ParseMediaFields>;
+    nullifySamples: boolean;
+    supportsContentRange: boolean;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
 }) => {
-    onTrackEntrySegment: OnTrackEntrySegment;
-    onProfile: (profile: SpsAndPps) => Promise<void>;
-    registerOnAvcProfileCallback: (callback: AvcProfileInfoCallback) => void;
-    getTrackInfoByNumber: (id: number) => TrackInfo;
-    registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
-    setTimestampOffset: (byteOffset: number, timestamp: number) => void;
-    getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
-    registerAudioSampleCallback: (id: number, callback: OnAudioSample | null) => Promise<void>;
-    onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => Promise<void>;
-    onVideoSample: (trackId: number, videoSample: AudioOrVideoSample) => Promise<void>;
-    getTimescale: () => number;
-    setTimescale: (newTimescale: number) => void;
-    getSamplesForTrack: (trackId: number) => number;
-    getAvcProfile: () => SpsAndPps | null;
+    riff: {
+        getAvcProfile: () => SpsAndPps | null;
+        onProfile: (profile: SpsAndPps) => Promise<void>;
+        registerOnAvcProfileCallback: (callback: (profile: SpsAndPps) => Promise<void>) => void;
+        getNextTrackIndex: () => number;
+        incrementNextTrackIndex: () => void;
+    };
+    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;
+        };
+        registerAudioSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnAudioSample | null) => Promise<void>;
+        tracks: {
+            hasAllTracks: () => boolean;
+            setIsDone: () => void;
+            addTrack: (track: import("..").Track) => void;
+            getTracks: () => import("..").Track[];
+            ensureHasTracksAtEnd: () => void;
+        };
+        audioSampleCallbacks: Record<number, import("../webcodec-sample-types").OnAudioSample>;
+        videoSampleCallbacks: Record<number, import("../webcodec-sample-types").OnVideoSample>;
+    };
     getInternalStats: () => InternalStats;
     getSkipBytes: () => number;
     increaseSkippedBytes: (bytes: number) => void;
-    maySkipVideoData: () => boolean;
-    tracks: {
-        hasAllTracks: () => boolean;
-        setIsDone: () => void;
-        addTrack: (track: import("..").Track) => void;
-        getTracks: () => import("..").Track[];
-        ensureHasTracksAtEnd: () => void;
+    keyframes: {
+        addKeyframe: (keyframe: import("../options").MediaParserKeyframe) => void;
+        getKeyframes: () => import("../options").MediaParserKeyframe[];
+    };
+    structure: {
+        getStructureOrNull: () => import("../parse-result").Structure | null;
+        getStructure: () => import("../parse-result").Structure;
+        setStructure: (value: import("../parse-result").Structure) => void;
+    };
+    nullifySamples: boolean;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    supportsContentRange: boolean;
+    webm: {
+        onTrackEntrySegment: import("../boxes/webm/segments").OnTrackEntrySegment;
+        getTrackInfoByNumber: (id: number) => import("../boxes/webm/segments/track-entry").TrackInfo;
+        setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+        getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+        timescale: null;
+        getTimescale: () => number;
+        setTimescale: (newTimescale: number) => void;
     };
-    canSkipTracksState: {
-        canSkipTracks: () => boolean;
+    emittedFields: import("../options").AllOptions<ParseMediaFields>;
+    fields: Partial<import("../options").AllOptions<ParseMediaFields>>;
+    slowDurationAndFps: {
+        addSample: (videoSample: import("../webcodec-sample-types").AudioOrVideoSample) => void;
+        getSlowDurationInSeconds: () => number;
+        getFps: () => number;
+        getSlowNumberOfFrames: () => number;
     };
 };
 export type ParserState = ReturnType<typeof makeParserState>;
-export {};

package/dist/state/parser-state.js

@@ -1,154 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeParserState = void 0;
-const traversal_1 = require("../boxes/webm/traversal");
-const can_skip_tracks_1 = require("./can-skip-tracks");
-const has_tracks_section_1 = require("./has-tracks-section");
-const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, }) => {
-    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 videoSampleCallbacks = {};
-    const audioSampleCallbacks = {};
-    const queuedAudioSamples = {};
-    const queuedVideoSamples = {};
-    let timescale = null;
+const emitted_fields_1 = require("./emitted-fields");
+const keyframes_1 = require("./keyframes");
+const riff_1 = require("./riff");
+const sample_callbacks_1 = require("./sample-callbacks");
+const slow_duration_fps_1 = require("./slow-duration-fps");
+const structure_1 = require("./structure");
+const webm_1 = require("./webm");
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, nullifySamples, onAudioTrack, onVideoTrack, supportsContentRange, }) => {
     let skippedBytes = 0;
-    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 increaseSkippedBytes = (bytes) => {
         skippedBytes += bytes;
     };
-    const setTimescale = (newTimescale) => {
-        timescale = newTimescale;
-    };
-    const timestampMap = new Map();
-    const setTimestampOffset = (byteOffset, timestamp) => {
-        timestampMap.set(byteOffset, timestamp);
-    };
-    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 samplesForTrack = {};
-    const profileCallbacks = [];
-    const registerOnAvcProfileCallback = (callback) => {
-        profileCallbacks.push(callback);
-    };
-    let avcProfile = null;
-    const onProfile = async (profile) => {
-        avcProfile = profile;
-        for (const callback of profileCallbacks) {
-            await callback(profile);
-        }
-        profileCallbacks.length = 0;
-    };
-    const canSkipTracksState = (0, can_skip_tracks_1.makeCanSkipTracksState)({
-        hasAudioTrackHandlers,
-        fields,
-        hasVideoTrackHandlers,
-    });
-    const tracksState = (0, has_tracks_section_1.makeTracksSectionState)(canSkipTracksState);
+    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)();
     return {
-        onTrackEntrySegment,
-        onProfile,
-        registerOnAvcProfileCallback,
-        getTrackInfoByNumber: (id) => trackEntries[id],
-        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] = [];
-        },
-        setTimestampOffset,
-        getTimestampOffsetForByteOffset,
-        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] = [];
-        },
-        onAudioSample: async (trackId, audioSample) => {
-            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                throw new Error('Aborted');
-            }
-            if (typeof samplesForTrack[trackId] === 'undefined') {
-                samplesForTrack[trackId] = 0;
-            }
-            samplesForTrack[trackId]++;
-            const callback = audioSampleCallbacks[trackId];
-            if (callback) {
-                await callback(audioSample);
-            }
-        },
-        onVideoSample: async (trackId, videoSample) => {
-            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                throw new Error('Aborted');
-            }
-            if (typeof samplesForTrack[trackId] === 'undefined') {
-                samplesForTrack[trackId] = 0;
-            }
-            samplesForTrack[trackId]++;
-            const callback = videoSampleCallbacks[trackId];
-            if (callback) {
-                await callback(videoSample);
-            }
-        },
-        getTimescale,
-        setTimescale,
-        getSamplesForTrack: (trackId) => {
-            var _a;
-            return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
-        },
-        getAvcProfile: () => {
-            return avcProfile;
-        },
+        riff: (0, riff_1.riffSpecificState)(),
+        callbacks: (0, sample_callbacks_1.sampleCallback)({
+            signal,
+            hasAudioTrackHandlers,
+            hasVideoTrackHandlers,
+            fields,
+            keyframes,
+            emittedFields,
+            slowDurationAndFpsState: slowDurationAndFps,
+        }),
         getInternalStats: () => {
             var _a, _b;
             return ({
@@ -158,13 +37,16 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
         },
         getSkipBytes: () => skippedBytes,
         increaseSkippedBytes,
-        maySkipVideoData: () => {
-            return (tracksState.hasAllTracks() &&
-                Object.values(videoSampleCallbacks).length === 0 &&
-                Object.values(audioSampleCallbacks).length === 0);
-        },
-        tracks: tracksState,
-        canSkipTracksState,
+        keyframes,
+        structure,
+        nullifySamples,
+        onAudioTrack,
+        onVideoTrack,
+        supportsContentRange,
+        webm: (0, webm_1.webmState)(),
+        emittedFields,
+        fields,
+        slowDurationAndFps,
     };
 };
 exports.makeParserState = makeParserState;

package/dist/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/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/state/sample-callbacks.d.ts

@@ -0,0 +1,31 @@
+import type { AllOptions, Options, ParseMediaFields } from '../options';
+import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
+import { type KeyframesState } from './keyframes';
+import type { SlowDurationAndFpsState } from './slow-duration-fps';
+export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, }: {
+    signal: AbortSignal | undefined;
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
+    fields: Options<ParseMediaFields>;
+    keyframes: KeyframesState;
+    emittedFields: AllOptions<ParseMediaFields>;
+    slowDurationAndFpsState: SlowDurationAndFpsState;
+}) => {
+    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;
+        setIsDone: () => void;
+        addTrack: (track: import("..").Track) => void;
+        getTracks: () => import("..").Track[];
+        ensureHasTracksAtEnd: () => void;
+    };
+    audioSampleCallbacks: Record<number, OnAudioSample>;
+    videoSampleCallbacks: Record<number, OnVideoSample>;
+};