@remotion/media-parser 4.0.240 → 4.0.242

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>;
+};

package/dist/state/sample-callbacks.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sampleCallback = void 0;
+const need_samples_for_fields_1 = require("../may-skip-video-data/need-samples-for-fields");
+const can_skip_tracks_1 = require("./can-skip-tracks");
+const has_tracks_section_1 = require("./has-tracks-section");
+const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, }) => {
+    const videoSampleCallbacks = {};
+    const audioSampleCallbacks = {};
+    const queuedAudioSamples = {};
+    const queuedVideoSamples = {};
+    const canSkipTracksState = (0, can_skip_tracks_1.makeCanSkipTracksState)({
+        hasAudioTrackHandlers,
+        fields,
+        hasVideoTrackHandlers,
+    });
+    const tracksState = (0, has_tracks_section_1.makeTracksSectionState)(canSkipTracksState);
+    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 (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);
+            }
+        },
+        getSamplesForTrack: (trackId) => {
+            var _a;
+            return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
+        },
+        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 we emit samples with data 0, Chrome will fail
+            if (callback && videoSample.data.length > 0) {
+                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.addSample(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,
+    };
+};
+exports.sampleCallback = sampleCallback;

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

@@ -0,0 +1,8 @@
+import type { AudioOrVideoSample } from '../webcodec-sample-types';
+export declare const slowDurationAndFpsState: () => {
+    addSample: (videoSample: AudioOrVideoSample) => void;
+    getSlowDurationInSeconds: () => number;
+    getFps: () => number;
+    getSlowNumberOfFrames: () => number;
+};
+export type SlowDurationAndFpsState = ReturnType<typeof slowDurationAndFpsState>;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slowDurationAndFpsState = void 0;
+const slowDurationAndFpsState = () => {
+    let smallestSample;
+    let largestSample;
+    let samples = 0;
+    const getSlowDurationInSeconds = () => {
+        if (smallestSample !== undefined && largestSample !== undefined) {
+            const startingTimestampDifference = largestSample - smallestSample;
+            const timeBetweenSamples = startingTimestampDifference / (samples - 1);
+            return timeBetweenSamples * samples;
+        }
+        throw new Error('No samples');
+    };
+    return {
+        addSample: (videoSample) => {
+            samples++;
+            const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
+            if (largestSample === undefined ||
+                presentationTimeInSeconds > largestSample) {
+                largestSample = presentationTimeInSeconds;
+            }
+            if (smallestSample === undefined ||
+                presentationTimeInSeconds < smallestSample) {
+                smallestSample = presentationTimeInSeconds;
+            }
+        },
+        getSlowDurationInSeconds,
+        getFps: () => {
+            return samples / getSlowDurationInSeconds();
+        },
+        getSlowNumberOfFrames: () => samples,
+    };
+};
+exports.slowDurationAndFpsState = slowDurationAndFpsState;

package/dist/state/structure.d.ts

@@ -0,0 +1,7 @@
+import type { Structure } from '../parse-result';
+export declare const structureState: () => {
+    getStructureOrNull: () => Structure | null;
+    getStructure: () => Structure;
+    setStructure: (value: Structure) => void;
+};
+export type StructureState = ReturnType<typeof structureState>;

package/dist/state/structure.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.structureState = void 0;
+const structureState = () => {
+    let structure = null;
+    return {
+        getStructureOrNull: () => {
+            return structure;
+        },
+        getStructure: () => {
+            if (structure === null) {
+                throw new Error('Expected structure');
+            }
+            return structure;
+        },
+        setStructure: (value) => {
+            structure = value;
+        },
+    };
+};
+exports.structureState = structureState;

package/dist/state/tracks-and-samples.js

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

package/dist/state/webm.d.ts

@@ -0,0 +1,11 @@
+import type { OnTrackEntrySegment } from '../boxes/webm/segments';
+import type { TrackInfo } from '../boxes/webm/segments/track-entry';
+export declare const webmState: () => {
+    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;
+};

package/dist/state/webm.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webmState = void 0;
+const traversal_1 = require("../boxes/webm/traversal");
+const webmState = () => {
+    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;
+    };
+    return {
+        onTrackEntrySegment,
+        getTrackInfoByNumber: (id) => trackEntries[id],
+        setTimestampOffset,
+        getTimestampOffsetForByteOffset,
+        timescale,
+        getTimescale,
+        setTimescale,
+    };
+};
+exports.webmState = webmState;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.240";
+export declare const VERSION = "4.0.242";

package/dist/version.js

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