@remotion/media-parser 4.0.285 → 4.0.286

package/dist/containers/webm/cues/format-cues.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCues = void 0;
+const formatCues = (cues) => {
+    const matroskaCues = [];
+    for (const cue of cues) {
+        if (cue.type !== 'CuePoint') {
+            throw new Error('Expected CuePoint');
+        }
+        const cueTime = cue.value.find((cue) => cue.type === 'CueTime');
+        if (!cueTime) {
+            throw new Error('Expected CueTime');
+        }
+        const cueTrackPositions = cue.value.find((c) => c.type === 'CueTrackPositions');
+        if (!cueTrackPositions) {
+            throw new Error('Expected CueTrackPositions');
+        }
+        const cueTimeValue = cueTime.value.value;
+        const cueTrack = cueTrackPositions.value.find((_c) => _c.type === 'CueTrack');
+        if (!cueTrack) {
+            throw new Error('Expected CueTrack');
+        }
+        const cueClusterPosition = cueTrackPositions.value.find((_c) => _c.type === 'CueClusterPosition');
+        if (!cueClusterPosition) {
+            throw new Error('Expected CueClusterPosition');
+        }
+        const cueRelativePosition = cueTrackPositions.value.find((_c) => _c.type === 'CueRelativePosition');
+        if (!cueRelativePosition) {
+            throw new Error('Expected CueRelativePosition');
+        }
+        const matroskaCue = {
+            trackId: cueTrack.value.value,
+            timeInTimescale: cueTimeValue,
+            clusterPositionInSegment: cueClusterPosition.value.value,
+            relativePosition: cueRelativePosition.value.value,
+        };
+        matroskaCues.push(matroskaCue);
+    }
+    return matroskaCues;
+};
+exports.formatCues = formatCues;

package/dist/containers/webm/cues/get-seeking-byte.d.ts

@@ -0,0 +1,14 @@
+import type { LogLevel } from '../../../log';
+import type { WebmSeekingInfo } from '../../../seeking-info';
+import type { KeyframesState } from '../../../state/keyframes';
+import type { WebmState } from '../../../state/matroska/webm';
+import type { MediaSectionState } from '../../../state/video-section';
+import type { SeekResolution } from '../../../work-on-seek-request';
+export declare const getSeekingByteFromMatroska: ({ time, webmState, info, logLevel, mediaSection, keyframes, }: {
+    time: number;
+    webmState: WebmState;
+    info: WebmSeekingInfo;
+    logLevel: LogLevel;
+    mediaSection: MediaSectionState;
+    keyframes: KeyframesState;
+}) => Promise<SeekResolution>;

package/dist/containers/webm/cues/get-seeking-byte.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteFromMatroska = void 0;
+const log_1 = require("../../../log");
+const toSeconds = (timeInTimescale, track) => {
+    return (timeInTimescale / track.timescale) * 1000;
+};
+const findBiggestCueBeforeTime = ({ cues, time, track, }) => {
+    let biggestCueBeforeTime;
+    for (const cue of cues) {
+        const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
+        if (cueTimeInSeconds < time &&
+            (!biggestCueBeforeTime ||
+                cueTimeInSeconds >
+                    toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
+            biggestCueBeforeTime = cue;
+        }
+    }
+    return biggestCueBeforeTime;
+};
+const getStartOfClusterToSeekTo = ({ biggestCueBeforeTime, webmState, segmentOffset, }) => {
+    if (biggestCueBeforeTime) {
+        return biggestCueBeforeTime.clusterPositionInSegment + segmentOffset;
+    }
+    const hasMediaSectionWithIndex = webmState.getFirstCluster();
+    if (hasMediaSectionWithIndex) {
+        return hasMediaSectionWithIndex.start;
+    }
+    return null;
+};
+const findKeyframeBeforeTime = ({ keyframes, time, }) => {
+    let keyframeBeforeTime;
+    for (const keyframe of keyframes) {
+        if (keyframe.decodingTimeInSeconds < time &&
+            (!keyframeBeforeTime ||
+                keyframe.decodingTimeInSeconds >
+                    keyframeBeforeTime.decodingTimeInSeconds)) {
+            keyframeBeforeTime = keyframe;
+        }
+    }
+    return keyframeBeforeTime;
+};
+const getSeekingByteFromMatroska = async ({ time, webmState, info, logLevel, mediaSection, keyframes, }) => {
+    if (!info.track) {
+        log_1.Log.trace(logLevel, 'No video track found, cannot seek yet');
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
+    const cuesResponse = await webmState.cues.getLoadedCues();
+    if (!cuesResponse) {
+        log_1.Log.trace(logLevel, 'Has no Matroska Cues at the moment, continuing...');
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
+    const { cues, segmentOffset } = cuesResponse;
+    log_1.Log.trace(logLevel, 'Has Matroska cues. Will use them to perform a seek.');
+    const biggestCueBeforeTime = findBiggestCueBeforeTime({
+        cues,
+        time,
+        track: info.track,
+    });
+    const keyframeBeforeTime = findKeyframeBeforeTime({
+        keyframes: keyframes.getKeyframes(),
+        time,
+    });
+    const startOfClusterToSeekTo = getStartOfClusterToSeekTo({
+        biggestCueBeforeTime,
+        webmState,
+        segmentOffset,
+    });
+    if (!startOfClusterToSeekTo) {
+        // dont know what to do
+        return {
+            type: 'invalid',
+        };
+    }
+    // we have assured this is in a media section, but it might not be marked yet
+    // setting size because there is deduplication and media sections which are encompassed
+    // by others will get deleted
+    mediaSection.addMediaSection({
+        start: startOfClusterToSeekTo,
+        size: 1,
+    });
+    return {
+        type: 'do-seek',
+        byte: startOfClusterToSeekTo,
+    };
+};
+exports.getSeekingByteFromMatroska = getSeekingByteFromMatroska;

package/dist/containers/webm/fetch-web-cues.d.ts

@@ -0,0 +1,12 @@
+import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { LogLevel } from '../../log';
+import type { ParseMediaSrc } from '../../options';
+import type { ReaderInterface } from '../../readers/reader';
+import type { PossibleEbml } from './segments/all-segments';
+export declare const fetchWebmCues: ({ src, readerInterface, controller, position, logLevel, }: {
+    src: ParseMediaSrc;
+    readerInterface: ReaderInterface;
+    controller: MediaParserController;
+    position: number;
+    logLevel: LogLevel;
+}) => Promise<PossibleEbml[] | null>;

package/dist/containers/webm/fetch-web-cues.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWebmCues = void 0;
+const buffer_iterator_1 = require("../../iterator/buffer-iterator");
+const segments_1 = require("./segments");
+const fetchWebmCues = async ({ src, readerInterface, controller, position, logLevel, }) => {
+    var _a;
+    const result = await readerInterface.read({
+        controller,
+        range: position,
+        src,
+    });
+    const { value } = await result.reader.reader.read();
+    if (!value) {
+        return null;
+    }
+    result.reader.abort();
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(value, value.length);
+    const segment = await (0, segments_1.expectSegment)({
+        iterator,
+        logLevel,
+        statesForProcessing: null,
+        isInsideSegment: null,
+        mediaSectionState: null,
+    });
+    iterator.destroy();
+    return ((_a = segment === null || segment === void 0 ? void 0 : segment.value) !== null && _a !== void 0 ? _a : null);
+};
+exports.fetchWebmCues = fetchWebmCues;

package/dist/containers/webm/get-byte-for-cues.d.ts

@@ -0,0 +1,5 @@
+import { type SeekHeadSegment } from './segments/all-segments';
+export declare const getByteForSeek: ({ seekHeadSegment, offset, }: {
+    seekHeadSegment: SeekHeadSegment;
+    offset: number;
+}) => number | null;

package/dist/containers/webm/get-byte-for-cues.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getByteForSeek = void 0;
+const truthy_1 = require("../../truthy");
+const all_segments_1 = require("./segments/all-segments");
+const getByteForSeek = ({ seekHeadSegment, offset, }) => {
+    const value = seekHeadSegment.value
+        .map((v) => {
+        if (v.type !== 'Seek') {
+            return null;
+        }
+        const seekId = v.value.find((_v) => {
+            // cues
+            return _v.type === 'SeekID' && _v.value === all_segments_1.matroskaElements.Cues;
+        });
+        if (!seekId) {
+            return null;
+        }
+        const seekPosition = v.value.find((_v) => {
+            return _v.type === 'SeekPosition';
+        });
+        if (!seekPosition) {
+            return false;
+        }
+        return seekPosition.value;
+    })
+        .filter(truthy_1.truthy);
+    if (value.length === 0) {
+        return null;
+    }
+    return value[0].value + offset;
+};
+exports.getByteForSeek = getByteForSeek;

package/dist/containers/webm/get-ready-tracks.d.ts

@@ -1,10 +1,15 @@
 import type { Track } from '../../get-tracks';
-import type { ParserState } from '../../state/parser-state';
+import type { WebmState } from '../../state/matroska/webm';
+import type { StructureState } from '../../state/structure';
 export type ResolvedAndUnresolvedTracks = {
     resolved: Track[];
     missingInfo: Track[];
 };
-export declare const getTracksFromMatroska: ({ state, }: {
-    state: ParserState;
+export declare const getTracksFromMatroska: ({ structureState, webmState, }: {
+    structureState: StructureState;
+    webmState: WebmState;
 }) => ResolvedAndUnresolvedTracks;
-export declare const matroskaHasTracks: (state: ParserState) => boolean;
+export declare const matroskaHasTracks: ({ structureState, webmState, }: {
+    structureState: StructureState;
+    webmState: WebmState;
+}) => boolean;

package/dist/containers/webm/get-ready-tracks.js

@@ -4,9 +4,8 @@ exports.matroskaHasTracks = exports.getTracksFromMatroska = void 0;
 const codec_string_1 = require("../avc/codec-string");
 const make_track_1 = require("./make-track");
 const traversal_1 = require("./traversal");
-const getTracksFromMatroska = ({ state, }) => {
-    const webmState = state.webm;
-    const structure = state.structure.getMatroskaStructure();
+const getTracksFromMatroska = ({ structureState, webmState, }) => {
+    const structure = structureState.getMatroskaStructure();
     const mainSegment = (0, traversal_1.getMainSegment)(structure.boxes);
     if (!mainSegment) {
         throw new Error('No main segment');
@@ -50,15 +49,16 @@ const getTracksFromMatroska = ({ state, }) => {
     return { missingInfo, resolved: resolvedTracks };
 };
 exports.getTracksFromMatroska = getTracksFromMatroska;
-const matroskaHasTracks = (state) => {
-    const structure = state.structure.getMatroskaStructure();
+const matroskaHasTracks = ({ structureState, webmState, }) => {
+    const structure = structureState.getMatroskaStructure();
     const mainSegment = (0, traversal_1.getMainSegment)(structure.boxes);
     if (!mainSegment) {
         return false;
     }
     return ((0, traversal_1.getTracksSegment)(mainSegment) !== null &&
         (0, exports.getTracksFromMatroska)({
-            state,
+            structureState,
+            webmState,
         }).missingInfo.length === 0);
 };
 exports.matroskaHasTracks = matroskaHasTracks;

package/dist/containers/webm/get-sample-from-block.d.ts

@@ -1,4 +1,5 @@
-import type { ParserState } from '../../state/parser-state';
+import type { WebmState } from '../../state/matroska/webm';
+import type { StructureState } from '../../state/structure';
 import type { AudioOrVideoSample } from '../../webcodec-sample-types';
 import type { BlockSegment, SimpleBlockSegment } from './segments/all-segments';
 type SampleResult = {
@@ -13,5 +14,5 @@ type SampleResult = {
 } | {
     type: 'no-sample';
 };
-export declare const getSampleFromBlock: (ebml: BlockSegment | SimpleBlockSegment, state: ParserState, offset: number) => SampleResult;
+export declare const getSampleFromBlock: (ebml: BlockSegment | SimpleBlockSegment, webmState: WebmState, offset: number, structureState: StructureState) => SampleResult;
 export {};

package/dist/containers/webm/get-sample-from-block.js

@@ -6,18 +6,18 @@ const parse_avc_1 = require("../avc/parse-avc");
 const get_ready_tracks_1 = require("./get-ready-tracks");
 const all_segments_1 = require("./segments/all-segments");
 const block_simple_block_flags_1 = require("./segments/block-simple-block-flags");
-const addAvcToTrackIfNecessary = ({ partialVideoSample, codec, state, trackNumber, }) => {
+const addAvcToTrackIfNecessary = ({ partialVideoSample, codec, structureState, webmState, trackNumber, }) => {
     if (codec === 'V_MPEG4/ISO/AVC' &&
-        (0, get_ready_tracks_1.getTracksFromMatroska)({ state }).missingInfo.length > 0) {
+        (0, get_ready_tracks_1.getTracksFromMatroska)({ structureState, webmState }).missingInfo.length > 0) {
         const parsed = (0, parse_avc_1.parseAvc)(partialVideoSample.data);
         for (const parse of parsed) {
             if (parse.type === 'avc-profile') {
-                state.webm.setAvcProfileForTrackNumber(trackNumber, parse);
+                webmState.setAvcProfileForTrackNumber(trackNumber, parse);
             }
         }
     }
 };
-const getSampleFromBlock = (ebml, state, offset) => {
+const getSampleFromBlock = (ebml, webmState, offset, structureState) => {
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(ebml.value, ebml.value.length);
     const trackNumber = iterator.getVint();
     if (trackNumber === null) {
@@ -27,9 +27,9 @@ const getSampleFromBlock = (ebml, state, offset) => {
     const { keyframe } = (0, block_simple_block_flags_1.parseBlockFlags)(iterator, ebml.type === 'SimpleBlock'
         ? all_segments_1.matroskaElements.SimpleBlock
         : all_segments_1.matroskaElements.Block);
-    const { codec, trackTimescale } = state.webm.getTrackInfoByNumber(trackNumber);
-    const clusterOffset = state.webm.getTimestampOffsetForByteOffset(offset);
-    const timescale = state.webm.getTimescale();
+    const { codec, trackTimescale } = webmState.getTrackInfoByNumber(trackNumber);
+    const clusterOffset = webmState.getTimestampOffsetForByteOffset(offset);
+    const timescale = webmState.getTimescale();
     if (clusterOffset === undefined) {
         throw new Error('Could not find offset for byte offset ' + offset);
     }
@@ -65,7 +65,8 @@ const getSampleFromBlock = (ebml, state, offset) => {
         addAvcToTrackIfNecessary({
             codec,
             partialVideoSample,
-            state,
+            structureState,
+            webmState,
             trackNumber,
         });
         const sample = {

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

@@ -0,0 +1,14 @@
+import type { LogLevel } from '../../log';
+import type { WebmSeekingInfo } from '../../seeking-info';
+import type { KeyframesState } from '../../state/keyframes';
+import type { WebmState } from '../../state/matroska/webm';
+import type { MediaSectionState } from '../../state/video-section';
+import type { SeekResolution } from '../../work-on-seek-request';
+export declare const getSeekingByteFromMatroska: ({ time, webmState, info, logLevel, mediaSection, keyframes, }: {
+    time: number;
+    webmState: WebmState;
+    info: WebmSeekingInfo;
+    logLevel: LogLevel;
+    mediaSection: MediaSectionState;
+    keyframes: KeyframesState;
+}) => Promise<SeekResolution>;

package/dist/containers/webm/get-seeking-byte.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteFromMatroska = void 0;
+const log_1 = require("../../log");
+const toSeconds = (timeInTimescale, track) => {
+    return (timeInTimescale / track.timescale) * 1000;
+};
+const findBiggestCueBeforeTime = ({ cues, time, track, }) => {
+    let biggestCueBeforeTime;
+    for (const cue of cues) {
+        const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
+        if (cueTimeInSeconds < time &&
+            (!biggestCueBeforeTime ||
+                cueTimeInSeconds >
+                    toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
+            biggestCueBeforeTime = cue;
+        }
+    }
+    return biggestCueBeforeTime;
+};
+const getStartOfClusterToSeekTo = ({ biggestCueBeforeTime, webmState, segmentOffset, }) => {
+    if (biggestCueBeforeTime) {
+        return biggestCueBeforeTime.clusterPositionInSegment + segmentOffset;
+    }
+    const hasMediaSectionWithIndex = webmState.getFirstCluster();
+    if (hasMediaSectionWithIndex) {
+        return hasMediaSectionWithIndex.start;
+    }
+    return null;
+};
+const findKeyframeBeforeTime = ({ keyframes, time, }) => {
+    let keyframeBeforeTime;
+    for (const keyframe of keyframes) {
+        if (keyframe.decodingTimeInSeconds < time &&
+            (!keyframeBeforeTime ||
+                keyframe.decodingTimeInSeconds >
+                    keyframeBeforeTime.decodingTimeInSeconds)) {
+            keyframeBeforeTime = keyframe;
+        }
+    }
+    return keyframeBeforeTime;
+};
+const getSeekingByteFromMatroska = async ({ time, webmState, info, logLevel, mediaSection, keyframes, }) => {
+    if (!info.track) {
+        log_1.Log.trace(logLevel, 'No video track found, cannot seek yet');
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
+    const cuesResponse = await webmState.cues.getLoadedCues();
+    if (!cuesResponse) {
+        log_1.Log.trace(logLevel, 'Has no Matroska Cues at the moment, continuing...');
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
+    const { cues, segmentOffset } = cuesResponse;
+    log_1.Log.trace(logLevel, 'Has Matroska cues. Will use them to perform a seek.');
+    const biggestCueBeforeTime = findBiggestCueBeforeTime({
+        cues,
+        time,
+        track: info.track,
+    });
+    const keyframeBeforeTime = findKeyframeBeforeTime({
+        keyframes: keyframes.getKeyframes(),
+        time,
+    });
+    const startOfClusterToSeekTo = getStartOfClusterToSeekTo({
+        biggestCueBeforeTime,
+        webmState,
+        segmentOffset,
+    });
+    if (!startOfClusterToSeekTo) {
+        // dont know what to do
+        return {
+            type: 'invalid',
+        };
+    }
+    // we have assured this is in a media section, but it might not be marked yet
+    // setting size because there is deduplication and media sections which are encompassed
+    // by others will get deleted
+    mediaSection.addMediaSection({
+        start: startOfClusterToSeekTo,
+        size: 1,
+    });
+    return {
+        type: 'do-seek',
+        byte: startOfClusterToSeekTo,
+    };
+};
+exports.getSeekingByteFromMatroska = getSeekingByteFromMatroska;

package/dist/containers/webm/get-seeking-info.d.ts

@@ -0,0 +1,3 @@
+import type { WebmSeekingInfo } from '../../seeking-info';
+import type { TracksState } from '../../state/has-tracks-section';
+export declare const getSeekingInfoFromMatroska: (tracksState: TracksState) => WebmSeekingInfo;

package/dist/containers/webm/get-seeking-info.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingInfoFromMatroska = void 0;
+const getSeekingInfoFromMatroska = (tracksState) => {
+    const tracks = tracksState.getTracks();
+    const firstVideoTrack = tracks.find((track) => track.type === 'video');
+    return {
+        type: 'webm-seeking-info',
+        track: firstVideoTrack
+            ? {
+                timescale: firstVideoTrack.timescale,
+                trackId: firstVideoTrack.trackId,
+            }
+            : null,
+    };
+};
+exports.getSeekingInfoFromMatroska = getSeekingInfoFromMatroska;

package/dist/containers/webm/parse-ebml.d.ts

@@ -1,11 +1,12 @@
-import type { ParserState } from '../../state/parser-state';
+import type { BufferIterator } from '../../iterator/buffer-iterator';
 import type { PossibleEbml } from './segments/all-segments';
+import type { WebmRequiredStatesForProcessing } from './state-for-processing';
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
-export declare const parseEbml: (state: ParserState) => Promise<Prettify<PossibleEbml>>;
-export declare const postprocessEbml: ({ offset, ebml, state, }: {
+export declare const parseEbml: (iterator: BufferIterator, statesForProcessing: WebmRequiredStatesForProcessing | null) => Promise<Prettify<PossibleEbml>>;
+export declare const postprocessEbml: ({ offset, ebml, statesForProcessing: { webmState, callbacks, logLevel, onAudioTrack, onVideoTrack, structureState, }, }: {
     offset: number;
     ebml: Prettify<PossibleEbml>;
-    state: ParserState;
+    statesForProcessing: WebmRequiredStatesForProcessing;
 }) => Promise<Prettify<PossibleEbml>>;

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

@@ -3,12 +3,10 @@ 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 work_on_seek_request_1 = require("../../work-on-seek-request");
 const get_sample_from_block_1 = require("./get-sample-from-block");
 const make_track_1 = require("./make-track");
 const all_segments_1 = require("./segments/all-segments");
-const parseEbml = async (state) => {
-    const { iterator } = state;
+const parseEbml = async (iterator, statesForProcessing) => {
     const hex = iterator.getMatroskaSegmentId();
     if (hex === null) {
         throw new Error('Not enough bytes left to parse EBML - this should not happen');
@@ -86,13 +84,15 @@ const parseEbml = async (state) => {
                 break;
             }
             const offset = iterator.counter.getOffset();
-            const value = await (0, exports.parseEbml)(state);
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            const remapped = await (0, exports.postprocessEbml)({
-                offset,
-                ebml: value,
-                state,
-            });
+            const value = await (0, exports.parseEbml)(iterator, statesForProcessing);
+            const remapped = statesForProcessing
+                ? // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    await (0, exports.postprocessEbml)({
+                        offset,
+                        ebml: value,
+                        statesForProcessing,
+                    })
+                : value;
             children.push(remapped);
             const offsetNow = iterator.counter.getOffset();
             if (offsetNow - startOffset > size) {
@@ -108,53 +108,50 @@ const parseEbml = async (state) => {
     throw new Error(`Unknown segment type ${hasInMap.type}`);
 };
 exports.parseEbml = parseEbml;
-const postprocessEbml = async ({ offset, ebml, state, }) => {
+const postprocessEbml = async ({ offset, ebml, statesForProcessing: { webmState, callbacks, logLevel, onAudioTrack, onVideoTrack, structureState, }, }) => {
     if (ebml.type === 'TimestampScale') {
-        state.webm.setTimescale(ebml.value.value);
+        webmState.setTimescale(ebml.value.value);
     }
     if (ebml.type === 'Tracks') {
-        state.callbacks.tracks.setIsDone(state.logLevel);
+        callbacks.tracks.setIsDone(logLevel);
     }
     if (ebml.type === 'TrackEntry') {
-        state.webm.onTrackEntrySegment(ebml);
+        webmState.onTrackEntrySegment(ebml);
         const track = (0, make_track_1.getTrack)({
             track: ebml,
-            timescale: state.webm.getTimescale(),
+            timescale: webmState.getTimescale(),
         });
         if (track && track.type === 'audio') {
             await (0, register_track_1.registerAudioTrack)({
-                workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
                 track,
                 container: 'webm',
-                registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
-                tracks: state.callbacks.tracks,
-                logLevel: state.logLevel,
-                onAudioTrack: state.onAudioTrack,
+                registerAudioSampleCallback: callbacks.registerAudioSampleCallback,
+                tracks: callbacks.tracks,
+                logLevel,
+                onAudioTrack,
             });
         }
         if (track && track.type === 'video') {
             await (0, register_track_1.registerVideoTrack)({
-                workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
                 track,
                 container: 'webm',
-                logLevel: state.logLevel,
-                onVideoTrack: state.onVideoTrack,
-                registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
-                tracks: state.callbacks.tracks,
+                logLevel,
+                onVideoTrack,
+                registerVideoSampleCallback: callbacks.registerVideoSampleCallback,
+                tracks: callbacks.tracks,
             });
         }
     }
     if (ebml.type === 'Timestamp') {
-        state.webm.setTimestampOffset(offset, ebml.value.value);
+        webmState.setTimestampOffset(offset, ebml.value.value);
     }
     if (ebml.type === 'Block' || ebml.type === 'SimpleBlock') {
-        const sample = (0, get_sample_from_block_1.getSampleFromBlock)(ebml, state, offset);
+        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,
-                workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
-                callbacks: state.callbacks,
+                callbacks,
             });
             return {
                 type: 'Block',
@@ -166,8 +163,7 @@ const postprocessEbml = async ({ offset, ebml, state, }) => {
             await (0, emit_audio_sample_1.emitAudioSample)({
                 trackId: sample.audioSample.trackId,
                 audioSample: sample.audioSample,
-                workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
-                callbacks: state.callbacks,
+                callbacks,
             });
             return {
                 type: 'Block',
@@ -195,7 +191,7 @@ const postprocessEbml = async ({ offset, ebml, state, }) => {
         const hasReferenceBlock = ebml.value.find((c) => c.type === 'ReferenceBlock');
         const sample = block.value.length === 0
             ? null
-            : (0, get_sample_from_block_1.getSampleFromBlock)(block, state, offset);
+            : (0, get_sample_from_block_1.getSampleFromBlock)(block, webmState, offset, structureState);
         if (sample && sample.type === 'partial-video-sample') {
             const completeFrame = {
                 ...sample.partialVideoSample,
@@ -204,8 +200,7 @@ const postprocessEbml = async ({ offset, ebml, state, }) => {
             await (0, emit_audio_sample_1.emitVideoSample)({
                 trackId: sample.partialVideoSample.trackId,
                 videoSample: completeFrame,
-                workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
-                callbacks: state.callbacks,
+                callbacks,
             });
         }
         return {