@remotion/media-parser 4.0.288 → 4.0.290

package/dist/containers/riff/parse-idx1.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIdx1 = void 0;
+const AVIIF_KEYFRAME = 0x00000010;
+const parseIdx1 = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const offset = iterator.counter.getOffset();
+    const entries = [];
+    const sampleCounts = {};
+    let videoTrackIndex = null;
+    while (iterator.counter.getOffset() < offset + size) {
+        const chunkId = iterator.getByteString(4, false);
+        const flags = iterator.getUint32Le();
+        const moffset = iterator.getUint32Le();
+        const msize = iterator.getUint32Le();
+        const chunk = chunkId.match(/^([0-9]{2})(wb|dc)$/);
+        const isVideo = chunkId.endsWith('dc');
+        if (isVideo) {
+            videoTrackIndex = chunk ? parseInt(chunk[1], 10) : null;
+        }
+        const trackId = chunk ? parseInt(chunk[1], 10) : null;
+        if (trackId === null) {
+            continue;
+        }
+        if (!sampleCounts[trackId]) {
+            sampleCounts[trackId] = 0;
+        }
+        const isKeyFrame = (flags & AVIIF_KEYFRAME) !== 0;
+        if (isKeyFrame) {
+            entries.push({
+                flags,
+                id: chunkId,
+                offset: moffset,
+                size: msize,
+                sampleCounts: { ...sampleCounts },
+            });
+        }
+        sampleCounts[trackId]++;
+    }
+    box.expectNoMoreBytes();
+    return {
+        type: 'idx1-box',
+        entries,
+        videoTrackIndex,
+    };
+};
+exports.parseIdx1 = parseIdx1;

package/dist/containers/riff/parse-list-box.d.ts

@@ -1,6 +1,8 @@
+import type { BufferIterator } from '../../iterator/buffer-iterator';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseListBox: ({ size, state, }: {
+export declare const parseListBox: ({ size, iterator, stateIfExpectingSideEffects, }: {
     size: number;
-    state: ParserState;
+    iterator: BufferIterator;
+    stateIfExpectingSideEffects: ParserState | null;
 }) => Promise<RiffBox>;

package/dist/containers/riff/parse-list-box.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseListBox = void 0;
 const expect_riff_box_1 = require("./expect-riff-box");
-const parseListBox = async ({ size, state, }) => {
-    const { iterator } = state;
+const parseListBox = async ({ size, iterator, stateIfExpectingSideEffects, }) => {
     const counter = iterator.counter.getOffset();
     const listType = iterator.getByteString(4, false);
     if (listType === 'movi') {
@@ -12,10 +11,16 @@ const parseListBox = async ({ size, state, }) => {
     const boxes = [];
     const maxOffset = counter + size;
     while (iterator.counter.getOffset() < maxOffset) {
-        const box = await (0, expect_riff_box_1.expectRiffBox)(state);
+        const box = await (0, expect_riff_box_1.expectRiffBox)({
+            iterator,
+            stateIfExpectingSideEffects,
+        });
         if (box === null) {
             throw new Error('Unexpected result');
         }
+        if (stateIfExpectingSideEffects) {
+            await (0, expect_riff_box_1.postProcessRiffBox)(stateIfExpectingSideEffects, box);
+        }
         boxes.push(box);
     }
     return {

package/dist/containers/riff/parse-movi.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMovi = exports.handleChunk = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const key_1 = require("../avc/key");
 const parse_avc_1 = require("../avc/parse-avc");
 const traversal_1 = require("./traversal");
@@ -20,13 +19,13 @@ const getStrhForIndex = (structure, trackId) => {
 };
 const handleChunk = async ({ state, ckId, ckSize, }) => {
     const { iterator } = state;
-    const offset = iterator.counter.getOffset();
+    const offset = iterator.counter.getOffset() - 8;
     const videoChunk = ckId.match(/^([0-9]{2})dc$/);
     if (videoChunk) {
         const trackId = parseInt(videoChunk[1], 10);
         const strh = getStrhForIndex(state.structure.getRiffStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
-        const nthSample = state.callbacks.getSamplesForTrack(trackId);
+        const nthSample = state.riff.sampleCounter.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
         const timestamp = timeInSec;
         const data = iterator.getSlice(ckSize);
@@ -38,27 +37,25 @@ const handleChunk = async ({ state, ckId, ckSize, }) => {
             await state.riff.onProfile({ pps: ppsProfile, sps: avcProfile });
             state.callbacks.tracks.setIsDone(state.logLevel);
         }
+        const videoSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            sample: {
+                cts: timestamp,
+                dts: timestamp,
+                data,
+                duration: undefined,
+                timestamp,
+                trackId,
+                type: keyOrDelta,
+                offset,
+                timescale: samplesPerSecond,
+            },
+            timescale: 1,
+        });
+        state.riff.sampleCounter.onVideoSample(trackId, videoSample);
         // We must also NOT pass a duration because if the the next sample is 0,
         // this sample would be longer. Chrome will pad it with silence.
         // If we'd pass a duration instead, it would shift the audio and we think that audio is not finished
-        await (0, emit_audio_sample_1.emitVideoSample)({
-            trackId,
-            videoSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-                sample: {
-                    cts: timestamp,
-                    dts: timestamp,
-                    data,
-                    duration: undefined,
-                    timestamp,
-                    trackId,
-                    type: keyOrDelta,
-                    offset,
-                    timescale: samplesPerSecond,
-                },
-                timescale: 1,
-            }),
-            callbacks: state.callbacks,
-        });
+        await state.callbacks.onVideoSample(trackId, videoSample);
         return;
     }
     const audioChunk = ckId.match(/^([0-9]{2})wb$/);
@@ -66,33 +63,31 @@ const handleChunk = async ({ state, ckId, ckSize, }) => {
         const trackId = parseInt(audioChunk[1], 10);
         const strh = getStrhForIndex(state.structure.getRiffStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
-        const nthSample = state.callbacks.getSamplesForTrack(trackId);
+        const nthSample = state.riff.sampleCounter.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
         const timestamp = timeInSec;
         const data = iterator.getSlice(ckSize);
+        const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            sample: {
+                cts: timestamp,
+                dts: timestamp,
+                data,
+                duration: undefined,
+                timestamp,
+                trackId,
+                type: 'key',
+                offset,
+                timescale: samplesPerSecond,
+            },
+            timescale: 1,
+        });
+        state.riff.sampleCounter.onAudioSample(trackId, audioSample);
         // In example.avi, we have samples with 0 data
         // Chrome fails on these
         // We must also NOT pass a duration because if the the next sample is 0,
         // this sample would be longer. Chrome will pad it with silence.
         // If we'd pass a duration instead, it would shift the audio and we think that audio is not finished
-        await (0, emit_audio_sample_1.emitAudioSample)({
-            trackId,
-            audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-                sample: {
-                    cts: timestamp,
-                    dts: timestamp,
-                    data,
-                    duration: undefined,
-                    timestamp,
-                    trackId,
-                    type: 'key',
-                    offset,
-                    timescale: samplesPerSecond,
-                },
-                timescale: 1,
-            }),
-            callbacks: state.callbacks,
-        });
+        await state.callbacks.onAudioSample(trackId, audioSample);
     }
 };
 exports.handleChunk = handleChunk;

package/dist/containers/riff/parse-riff-body.js

@@ -26,8 +26,12 @@ const parseRiffBody = async (state) => {
         await (0, parse_video_section_1.parseMediaSection)(state);
         return null;
     }
-    const box = await (0, expect_riff_box_1.expectRiffBox)(state);
+    const box = await (0, expect_riff_box_1.expectRiffBox)({
+        iterator: state.iterator,
+        stateIfExpectingSideEffects: state,
+    });
     if (box !== null) {
+        await (0, expect_riff_box_1.postProcessRiffBox)(state, box);
         const structure = state.structure.getRiffStructure();
         structure.boxes.push(box);
     }

package/dist/containers/riff/parse-riff-box.d.ts

@@ -1,7 +1,9 @@
+import type { BufferIterator } from '../../iterator/buffer-iterator';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseRiffBox: ({ size, id, state, }: {
+export declare const parseRiffBox: ({ size, id, iterator, stateIfExpectingSideEffects, }: {
     size: number;
     id: string;
-    state: ParserState;
+    iterator: BufferIterator;
+    stateIfExpectingSideEffects: ParserState | null;
 }) => Promise<RiffBox>;

package/dist/containers/riff/parse-riff-box.js

@@ -2,13 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRiffBox = void 0;
 const parse_avih_1 = require("./parse-avih");
+const parse_idx1_1 = require("./parse-idx1");
 const parse_isft_1 = require("./parse-isft");
 const parse_list_box_1 = require("./parse-list-box");
 const parse_strh_1 = require("./parse-strh");
-const parseRiffBox = ({ size, id, state, }) => {
-    const { iterator } = state;
+const parseRiffBox = ({ size, id, iterator, stateIfExpectingSideEffects, }) => {
     if (id === 'LIST') {
-        return (0, parse_list_box_1.parseListBox)({ size, state });
+        return (0, parse_list_box_1.parseListBox)({
+            size,
+            iterator,
+            stateIfExpectingSideEffects,
+        });
     }
     if (id === 'ISFT') {
         return Promise.resolve((0, parse_isft_1.parseIsft)({ iterator, size }));
@@ -19,6 +23,9 @@ const parseRiffBox = ({ size, id, state, }) => {
     if (id === 'strh') {
         return Promise.resolve((0, parse_strh_1.parseStrh)({ iterator, size }));
     }
+    if (id === 'idx1') {
+        return Promise.resolve((0, parse_idx1_1.parseIdx1)({ iterator, size }));
+    }
     iterator.discard(size);
     const box = {
         type: 'riff-box',

package/dist/containers/riff/riff-box.d.ts

@@ -20,6 +20,7 @@ export type AvihBox = {
     suggestedBufferSize: number;
     width: number;
     height: number;
+    hasIndex: boolean;
 };
 export type FccType = 'vids' | 'auds';
 export type StrhBox = {
@@ -72,7 +73,19 @@ export type IsftBox = {
     type: 'isft-box';
     software: string;
 };
-export type RiffBox = RiffRegularBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | IsftBox;
+export type Idx1Box = {
+    type: 'idx1-box';
+    entries: Idx1Entry[];
+    videoTrackIndex: number | null;
+};
+export type Idx1Entry = {
+    id: string;
+    flags: number;
+    offset: number;
+    size: number;
+    sampleCounts: Record<number, number>;
+};
+export type RiffBox = RiffRegularBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | Idx1Box | IsftBox;
 export type RiffStructure = {
     type: 'riff';
     boxes: RiffBox[];

package/dist/containers/riff/seek/fetch-idx1.d.ts

@@ -0,0 +1,15 @@
+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 fetchIdx1: ({ src, readerInterface, controller, position, logLevel, }: {
+    src: ParseMediaSrc;
+    readerInterface: ReaderInterface;
+    controller: MediaParserController;
+    position: number;
+    logLevel: LogLevel;
+}) => Promise<{
+    entries: import("../riff-box").Idx1Entry[];
+    videoTrackIndex: number | null;
+}>;
+export type FetchIdx1Result = Awaited<ReturnType<typeof fetchIdx1>>;

package/dist/containers/riff/seek/fetch-idx1.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchIdx1 = void 0;
+const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
+const log_1 = require("../../../log");
+const expect_riff_box_1 = require("../expect-riff-box");
+const fetchIdx1 = async ({ src, readerInterface, controller, position, logLevel, }) => {
+    log_1.Log.verbose(logLevel, 'Making request to fetch idx1 from ', src, 'position', position);
+    const result = await readerInterface.read({
+        controller,
+        range: position,
+        src,
+    });
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array(), Infinity);
+    while (true) {
+        const res = await result.reader.reader.read();
+        if (res.value) {
+            iterator.addData(res.value);
+        }
+        if (res.done) {
+            break;
+        }
+    }
+    const box = await (0, expect_riff_box_1.expectRiffBox)({
+        iterator,
+        stateIfExpectingSideEffects: null,
+    });
+    iterator.destroy();
+    if (box === null || box.type !== 'idx1-box') {
+        throw new Error('Expected idx1-box');
+    }
+    // only store video chunks, those end with "dc", e.g. "01dc"
+    return {
+        entries: box.entries.filter((entry) => entry.id.endsWith('dc')),
+        videoTrackIndex: box.videoTrackIndex,
+    };
+};
+exports.fetchIdx1 = fetchIdx1;

package/dist/containers/riff/seeking-hints.d.ts

@@ -0,0 +1,23 @@
+import type { ParserState } from '../../state/parser-state';
+import type { RiffState } from '../../state/riff';
+import type { RiffKeyframe } from '../../state/riff/riff-keyframes';
+import type { StructureState } from '../../state/structure';
+import type { MediaSectionState } from '../../state/video-section';
+import type { FetchIdx1Result } from './seek/fetch-idx1';
+export type RiffSeekingHints = {
+    type: 'riff-seeking-hints';
+    hasIndex: boolean;
+    idx1Entries: FetchIdx1Result | null;
+    samplesPerSecond: number | null;
+    moviOffset: number | null;
+    observedKeyframes: RiffKeyframe[];
+};
+export declare const getSeekingHintsForRiff: ({ structureState, riffState, mediaSectionState, }: {
+    structureState: StructureState;
+    riffState: RiffState;
+    mediaSectionState: MediaSectionState;
+}) => RiffSeekingHints;
+export declare const setSeekingHintsForRiff: ({ hints, state, }: {
+    hints: RiffSeekingHints;
+    state: ParserState;
+}) => void;

package/dist/containers/riff/seeking-hints.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForRiff = exports.getSeekingHintsForRiff = void 0;
+const has_index_1 = require("./has-index");
+const traversal_1 = require("./traversal");
+const getSeekingHintsForRiff = ({ structureState, riffState, mediaSectionState, }) => {
+    var _a, _b;
+    const structure = structureState.getRiffStructure();
+    const strl = (0, traversal_1.getStrlBoxes)(structure);
+    let samplesPerSecond = null;
+    for (const s of strl) {
+        const strh = (0, traversal_1.getStrhBox)(s.children);
+        if (!strh) {
+            throw new Error('No strh box');
+        }
+        if (strh.strf.type !== 'strf-box-video') {
+            continue;
+        }
+        samplesPerSecond = strh.rate / strh.scale;
+        break;
+    }
+    return {
+        type: 'riff-seeking-hints',
+        hasIndex: (0, has_index_1.riffHasIndex)(structure),
+        idx1Entries: riffState.lazyIdx1.getIfAlreadyLoaded(),
+        samplesPerSecond,
+        moviOffset: (_b = (_a = mediaSectionState.getMediaSections()[0]) === null || _a === void 0 ? void 0 : _a.start) !== null && _b !== void 0 ? _b : null,
+        observedKeyframes: riffState.sampleCounter.riffKeys.getKeyframes(),
+    };
+};
+exports.getSeekingHintsForRiff = getSeekingHintsForRiff;
+const setSeekingHintsForRiff = ({ hints, state, }) => {
+    state.riff.lazyIdx1.setFromSeekingHints(hints);
+    state.riff.sampleCounter.riffKeys.setFromSeekingHints(hints.observedKeyframes);
+};
+exports.setSeekingHintsForRiff = setSeekingHintsForRiff;

package/dist/containers/transport-stream/handle-aac-packet.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleAacPacket = void 0;
 const aac_codecprivate_1 = require("../../aac-codecprivate");
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const register_track_1 = require("../../register-track");
 const adts_header_1 = require("./adts-header");
 const handle_avc_packet_1 = require("./handle-avc-packet");
@@ -61,14 +60,11 @@ const handleAacPacket = async ({ streamBuffer, programId, offset, sampleCallback
         offset,
         timescale: handle_avc_packet_1.MPEG_TIMESCALE,
     };
-    await (0, emit_audio_sample_1.emitAudioSample)({
-        trackId: programId,
-        audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            sample,
-            timescale: handle_avc_packet_1.MPEG_TIMESCALE,
-        }),
-        callbacks: sampleCallbacks,
+    const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        sample,
+        timescale: handle_avc_packet_1.MPEG_TIMESCALE,
     });
+    await sampleCallbacks.onAudioSample(programId, audioSample);
     transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 exports.handleAacPacket = handleAacPacket;

package/dist/containers/transport-stream/handle-avc-packet.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleAvcPacket = exports.MPEG_TIMESCALE = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const register_track_1 = require("../../register-track");
 const codec_string_1 = require("../avc/codec-string");
 const create_sps_pps_data_1 = require("../avc/create-sps-pps-data");
@@ -80,14 +79,11 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
     if (type === 'key') {
         transportStream.observedPesHeaders.markPtsAsKeyframe(streamBuffer.pesHeader.pts);
     }
-    await (0, emit_audio_sample_1.emitVideoSample)({
-        trackId: programId,
-        videoSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            sample,
-            timescale: exports.MPEG_TIMESCALE,
-        }),
-        callbacks: sampleCallbacks,
+    const videoSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        sample,
+        timescale: exports.MPEG_TIMESCALE,
     });
+    await sampleCallbacks.onVideoSample(programId, videoSample);
     transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 exports.handleAvcPacket = handleAvcPacket;

package/dist/containers/wav/get-duration-from-wav.d.ts

@@ -1,3 +1,2 @@
 import type { ParserState } from '../../state/parser-state';
 export declare const getDurationFromWav: (state: ParserState) => number;
-export declare const hasDurationFromWav: (state: ParserState) => number | false;

package/dist/containers/wav/get-duration-from-wav.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasDurationFromWav = exports.getDurationFromWav = void 0;
+exports.getDurationFromWav = void 0;
 const getDurationFromWav = (state) => {
     const structure = state.structure.getWavStructure();
     const fmt = structure.boxes.find((b) => b.type === 'wav-fmt');
@@ -15,12 +15,3 @@ const getDurationFromWav = (state) => {
     return durationInSeconds;
 };
 exports.getDurationFromWav = getDurationFromWav;
-const hasDurationFromWav = (state) => {
-    try {
-        return (0, exports.getDurationFromWav)(state);
-    }
-    catch (_a) {
-        return false;
-    }
-};
-exports.hasDurationFromWav = hasDurationFromWav;

package/dist/containers/wav/parse-media-section.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMediaSection = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const get_seeking_byte_1 = require("./get-seeking-byte");
 const parseMediaSection = async ({ state, }) => {
     const { iterator } = state;
@@ -19,24 +18,21 @@ const parseMediaSection = async ({ state, }) => {
     const duration = toRead / (fmtBox.sampleRate * fmtBox.blockAlign);
     const timestamp = (offset - videoSection.start) / (fmtBox.sampleRate * fmtBox.blockAlign);
     const data = iterator.getSlice(toRead);
-    await (0, emit_audio_sample_1.emitAudioSample)({
-        trackId: 0,
-        audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            sample: {
-                cts: timestamp,
-                dts: timestamp,
-                data,
-                duration,
-                timestamp,
-                trackId: 0,
-                type: 'key',
-                offset,
-                timescale: 1000000,
-            },
-            timescale: 1,
-        }),
-        callbacks: state.callbacks,
+    const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        sample: {
+            cts: timestamp,
+            dts: timestamp,
+            data,
+            duration,
+            timestamp,
+            trackId: 0,
+            type: 'key',
+            offset,
+            timescale: 1000000,
+        },
+        timescale: 1,
     });
+    await state.callbacks.onAudioSample(0, audioSample);
     return null;
 };
 exports.parseMediaSection = parseMediaSection;

package/dist/containers/webm/parse-ebml.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.postprocessEbml = exports.parseEbml = void 0;
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const register_track_1 = require("../../register-track");
 const get_sample_from_block_1 = require("./get-sample-from-block");
 const make_track_1 = require("./make-track");
@@ -148,11 +147,7 @@ const postprocessEbml = async ({ offset, ebml, statesForProcessing: { webmState,
     if (ebml.type === 'Block' || ebml.type === 'SimpleBlock') {
         const sample = (0, get_sample_from_block_1.getSampleFromBlock)(ebml, webmState, offset, structureState);
         if (sample.type === 'video-sample') {
-            await (0, emit_audio_sample_1.emitVideoSample)({
-                trackId: sample.videoSample.trackId,
-                videoSample: sample.videoSample,
-                callbacks,
-            });
+            await callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
@@ -160,11 +155,7 @@ const postprocessEbml = async ({ offset, ebml, statesForProcessing: { webmState,
             };
         }
         if (sample.type === 'audio-sample') {
-            await (0, emit_audio_sample_1.emitAudioSample)({
-                trackId: sample.audioSample.trackId,
-                audioSample: sample.audioSample,
-                callbacks,
-            });
+            await callbacks.onAudioSample(sample.audioSample.trackId, sample.audioSample);
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
@@ -197,11 +188,7 @@ const postprocessEbml = async ({ offset, ebml, statesForProcessing: { webmState,
                 ...sample.partialVideoSample,
                 type: hasReferenceBlock ? 'delta' : 'key',
             };
-            await (0, emit_audio_sample_1.emitVideoSample)({
-                trackId: sample.partialVideoSample.trackId,
-                videoSample: completeFrame,
-                callbacks,
-            });
+            await callbacks.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
         }
         return {
             type: 'BlockGroup',

package/dist/containers/webm/seek/seeking-hints.js

@@ -22,7 +22,7 @@ const getSeekingHintsFromMatroska = (tracksState, keyframesState, webmState) =>
 exports.getSeekingHintsFromMatroska = getSeekingHintsFromMatroska;
 const setSeekingHintsForWebm = ({ hints, state, }) => {
     state.webm.cues.setFromSeekingHints(hints);
-    state.keyframes.setFromSeekingHints(hints);
+    state.keyframes.setFromSeekingHints(hints.keyframes);
     state.webm.setTimeStampMapForSeekingHints(hints.timestampMap);
 };
 exports.setSeekingHintsForWebm = setSeekingHintsForWebm;

package/dist/emit-available-info.js

@@ -48,7 +48,7 @@ const emitAvailableInfo = async ({ hasInfo, state, }) => {
         if (key === 'slowDurationInSeconds') {
             if (hasInfo.slowDurationInSeconds &&
                 !emittedFields.slowDurationInSeconds) {
-                const slowDurationInSeconds = (_c = (0, get_duration_1.getDuration)(state)) !== null && _c !== void 0 ? _c : state.slowDurationAndFps.getSlowDurationInSeconds();
+                const slowDurationInSeconds = (_c = (0, get_duration_1.getDuration)(state)) !== null && _c !== void 0 ? _c : state.samplesObserved.getSlowDurationInSeconds();
                 await ((_d = callbackFunctions.onSlowDurationInSeconds) === null || _d === void 0 ? void 0 : _d.call(callbackFunctions, slowDurationInSeconds));
                 if (fieldsInReturnValue.slowDurationInSeconds) {
                     returnValue.slowDurationInSeconds = slowDurationInSeconds;
@@ -83,7 +83,7 @@ const emitAvailableInfo = async ({ hasInfo, state, }) => {
         // must be handled after fps
         if (key === 'slowFps') {
             if (hasInfo.slowFps && !emittedFields.slowFps) {
-                const slowFps = state.slowDurationAndFps.getFps();
+                const slowFps = state.samplesObserved.getFps();
                 await ((_g = callbackFunctions.onSlowFps) === null || _g === void 0 ? void 0 : _g.call(callbackFunctions, slowFps));
                 if (fieldsInReturnValue.slowFps) {
                     returnValue.slowFps = slowFps;
@@ -268,10 +268,10 @@ const emitAvailableInfo = async ({ hasInfo, state, }) => {
         }
         if (key === 'slowNumberOfFrames') {
             if (!emittedFields.slowNumberOfFrames && hasInfo.slowNumberOfFrames) {
-                await ((_y = callbackFunctions.onSlowNumberOfFrames) === null || _y === void 0 ? void 0 : _y.call(callbackFunctions, state.slowDurationAndFps.getSlowNumberOfFrames()));
+                await ((_y = callbackFunctions.onSlowNumberOfFrames) === null || _y === void 0 ? void 0 : _y.call(callbackFunctions, state.samplesObserved.getSlowNumberOfFrames()));
                 if (fieldsInReturnValue.slowNumberOfFrames) {
                     returnValue.slowNumberOfFrames =
-                        state.slowDurationAndFps.getSlowNumberOfFrames();
+                        state.samplesObserved.getSlowNumberOfFrames();
                 }
                 emittedFields.slowNumberOfFrames = true;
             }
@@ -279,10 +279,10 @@ const emitAvailableInfo = async ({ hasInfo, state, }) => {
         }
         if (key === 'slowAudioBitrate') {
             if (!emittedFields.slowAudioBitrate && hasInfo.slowAudioBitrate) {
-                await ((_z = callbackFunctions.onSlowAudioBitrate) === null || _z === void 0 ? void 0 : _z.call(callbackFunctions, state.slowDurationAndFps.getAudioBitrate()));
+                await ((_z = callbackFunctions.onSlowAudioBitrate) === null || _z === void 0 ? void 0 : _z.call(callbackFunctions, state.samplesObserved.getAudioBitrate()));
                 if (fieldsInReturnValue.slowAudioBitrate) {
                     returnValue.slowAudioBitrate =
-                        state.slowDurationAndFps.getAudioBitrate();
+                        state.samplesObserved.getAudioBitrate();
                 }
                 emittedFields.slowAudioBitrate = true;
             }
@@ -290,10 +290,10 @@ const emitAvailableInfo = async ({ hasInfo, state, }) => {
         }
         if (key === 'slowVideoBitrate') {
             if (!emittedFields.slowVideoBitrate && hasInfo.slowVideoBitrate) {
-                await ((_0 = callbackFunctions.onSlowVideoBitrate) === null || _0 === void 0 ? void 0 : _0.call(callbackFunctions, state.slowDurationAndFps.getVideoBitrate()));
+                await ((_0 = callbackFunctions.onSlowVideoBitrate) === null || _0 === void 0 ? void 0 : _0.call(callbackFunctions, state.samplesObserved.getVideoBitrate()));
                 if (fieldsInReturnValue.slowVideoBitrate) {
                     returnValue.slowVideoBitrate =
-                        state.slowDurationAndFps.getVideoBitrate();
+                        state.samplesObserved.getVideoBitrate();
                 }
                 emittedFields.slowVideoBitrate = true;
             }