@remotion/media-parser 4.0.285 → 4.0.287

package/dist/containers/transport-stream/process-stream-buffers.d.ts

@@ -1,19 +1,39 @@
+import type { LogLevel } from '../../log';
 import type { TransportStreamStructure } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
+import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
+import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
 import type { PacketPes } from './parse-pes';
 export type TransportStreamPacketBuffer = {
-    buffer: Uint8Array;
     pesHeader: PacketPes;
     offset: number;
+    getBuffer: () => Uint8Array;
+    addBuffer: (buffer: Uint8Array) => void;
+    get2ndSubArrayIndex: () => number;
 };
+export declare const makeTransportStreamPacketBuffer: ({ buffers, pesHeader, offset, }: {
+    buffers: Uint8Array | null;
+    pesHeader: PacketPes;
+    offset: number;
+}) => TransportStreamPacketBuffer;
 export type StreamBufferMap = Map<number, TransportStreamPacketBuffer>;
-export declare const processStreamBuffer: ({ streamBuffer, state, programId, structure, }: {
+export declare const processStreamBuffer: ({ streamBuffer, programId, structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
     streamBuffer: TransportStreamPacketBuffer;
-    state: ParserState;
     programId: number;
     structure: TransportStreamStructure;
+    sampleCallbacks: SampleCallbacks;
+    logLevel: LogLevel;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    transportStream: TransportStreamState;
+    makeSamplesStartAtZero: boolean;
 }) => Promise<void>;
-export declare const processFinalStreamBuffers: ({ state, structure, }: {
-    state: ParserState;
+export declare const processFinalStreamBuffers: ({ structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
     structure: TransportStreamStructure;
+    sampleCallbacks: SampleCallbacks;
+    logLevel: LogLevel;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    transportStream: TransportStreamState;
+    makeSamplesStartAtZero: boolean;
 }) => Promise<void>;

package/dist/containers/transport-stream/process-stream-buffers.js

@@ -1,52 +1,117 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processFinalStreamBuffers = exports.processStreamBuffer = void 0;
+exports.processFinalStreamBuffers = exports.processStreamBuffer = exports.makeTransportStreamPacketBuffer = void 0;
+const combine_uint8_arrays_1 = require("../../combine-uint8-arrays");
+const find_separator_1 = require("./find-separator");
 const get_tracks_1 = require("./get-tracks");
 const handle_aac_packet_1 = require("./handle-aac-packet");
 const handle_avc_packet_1 = require("./handle-avc-packet");
 const traversal_1 = require("./traversal");
-const processStreamBuffer = async ({ streamBuffer, state, programId, structure, }) => {
+const makeTransportStreamPacketBuffer = ({ buffers, pesHeader, offset, }) => {
+    let currentBuf = buffers ? [buffers] : [];
+    let subarrayIndex = null;
+    const getBuffer = () => {
+        if (currentBuf.length === 0) {
+            return new Uint8Array();
+        }
+        if (currentBuf.length === 1) {
+            return currentBuf[0];
+        }
+        currentBuf = [(0, combine_uint8_arrays_1.combineUint8Arrays)(currentBuf)];
+        return currentBuf[0];
+    };
+    let fastFind = null;
+    return {
+        pesHeader,
+        offset,
+        getBuffer,
+        addBuffer: (buffer) => {
+            currentBuf.push(buffer);
+            subarrayIndex = null;
+        },
+        get2ndSubArrayIndex: () => {
+            var _a, _b;
+            if (subarrayIndex === null) {
+                const result = (0, find_separator_1.findNthSubarrayIndex)({
+                    array: getBuffer(),
+                    subarray: new Uint8Array([0, 0, 1, 9]),
+                    n: 2,
+                    startIndex: (_a = fastFind === null || fastFind === void 0 ? void 0 : fastFind.index) !== null && _a !== void 0 ? _a : 0,
+                    startCount: (_b = fastFind === null || fastFind === void 0 ? void 0 : fastFind.count) !== null && _b !== void 0 ? _b : 0,
+                });
+                if (result.type === 'found') {
+                    subarrayIndex = result.index;
+                    fastFind = null;
+                }
+                else {
+                    fastFind = result;
+                    return -1;
+                }
+            }
+            return subarrayIndex;
+        },
+    };
+};
+exports.makeTransportStreamPacketBuffer = makeTransportStreamPacketBuffer;
+const processStreamBuffer = async ({ streamBuffer, programId, structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }) => {
     const stream = (0, traversal_1.getStreamForId)(structure, programId);
     if (!stream) {
         throw new Error('No stream found');
     }
+    // 2 = ITU-T Rec. H.262 | ISO/IEC 13818-2 Video or ISO/IEC 11172-2 constrained parameter video stream
+    if (stream.streamType === 2) {
+        throw new Error('H.262 video stream not supported');
+    }
     // 27 = AVC / H.264 Video
     if (stream.streamType === 27) {
         await (0, handle_avc_packet_1.handleAvcPacket)({
             programId,
             streamBuffer,
-            state,
+            sampleCallbacks,
+            logLevel,
+            onVideoTrack,
             offset: streamBuffer.offset,
+            transportStream,
+            makeSamplesStartAtZero,
         });
     }
     // 15 = AAC / ADTS
     else if (stream.streamType === 15) {
         await (0, handle_aac_packet_1.handleAacPacket)({
             streamBuffer,
-            state,
             programId,
             offset: streamBuffer.offset,
+            sampleCallbacks,
+            logLevel,
+            onAudioTrack,
+            transportStream,
+            makeSamplesStartAtZero,
         });
     }
-    if (!state.callbacks.tracks.hasAllTracks()) {
-        const tracksRegistered = state.callbacks.tracks.getTracks().length;
+    if (!sampleCallbacks.tracks.hasAllTracks()) {
+        const tracksRegistered = sampleCallbacks.tracks.getTracks().length;
         const { streams } = (0, traversal_1.findProgramMapTableOrThrow)(structure);
         if ((0, get_tracks_1.filterStreamsBySupportedTypes)(streams).length === tracksRegistered) {
-            state.callbacks.tracks.setIsDone(state.logLevel);
+            sampleCallbacks.tracks.setIsDone(logLevel);
         }
     }
 };
 exports.processStreamBuffer = processStreamBuffer;
-const processFinalStreamBuffers = async ({ state, structure, }) => {
-    for (const [programId, buffer] of state.transportStream.streamBuffers) {
-        if (buffer.buffer.byteLength > 0) {
+const processFinalStreamBuffers = async ({ structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }) => {
+    for (const [programId, buffer] of transportStream.streamBuffers) {
+        if (buffer.getBuffer().byteLength > 0) {
             await (0, exports.processStreamBuffer)({
                 streamBuffer: buffer,
-                state,
                 programId,
                 structure,
+                sampleCallbacks,
+                logLevel,
+                onAudioTrack,
+                onVideoTrack,
+                transportStream,
+                makeSamplesStartAtZero,
             });
-            state.transportStream.streamBuffers.delete(programId);
+            transportStream.streamBuffers.delete(programId);
         }
     }
 };

package/dist/containers/transport-stream/seeking-hints.d.ts

@@ -0,0 +1,9 @@
+import type { TransportStreamSeekingHints } from '../../seeking-hints';
+import type { TracksState } from '../../state/has-tracks-section';
+import type { ParserState } from '../../state/parser-state';
+import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
+export declare const getSeekingHintsFromTransportStream: (transportStream: TransportStreamState, tracksState: TracksState) => TransportStreamSeekingHints | null;
+export declare const setSeekingHintsForTransportStream: ({ hints, state, }: {
+    hints: TransportStreamSeekingHints;
+    state: ParserState;
+}) => void;

package/dist/containers/transport-stream/seeking-hints.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForTransportStream = exports.getSeekingHintsFromTransportStream = void 0;
+const getSeekingHintsFromTransportStream = (transportStream, tracksState) => {
+    const firstVideoTrack = tracksState
+        .getTracks()
+        .find((t) => t.type === 'video');
+    if (!firstVideoTrack) {
+        return null;
+    }
+    return {
+        type: 'transport-stream-seeking-hints',
+        observedPesHeaders: transportStream.observedPesHeaders.getPesKeyframeHeaders(),
+        ptsStartOffset: transportStream.startOffset.getOffset(firstVideoTrack.trackId),
+        firstVideoTrackId: firstVideoTrack.trackId,
+    };
+};
+exports.getSeekingHintsFromTransportStream = getSeekingHintsFromTransportStream;
+const setSeekingHintsForTransportStream = ({ hints, state, }) => {
+    state.transportStream.observedPesHeaders.setPesKeyframesFromSeekingHints(hints);
+    state.transportStream.startOffset.setOffset({
+        trackId: hints.firstVideoTrackId,
+        newOffset: hints.ptsStartOffset,
+    });
+};
+exports.setSeekingHintsForTransportStream = setSeekingHintsForTransportStream;

package/dist/containers/transport-stream/traversal.d.ts

@@ -1,6 +1,8 @@
 import type { TransportStreamStructure } from '../../parse-result';
+import type { TransportStreamPMTBox } from './boxes';
 import type { TransportStreamProgramAssociationTableEntry } from './parse-pat';
 import type { TransportStreamEntry } from './parse-pmt';
-export declare const findProgramMapTableOrThrow: (structure: TransportStreamStructure) => import("./boxes").TransportStreamPMTBox;
+export declare const findProgramMapOrNull: (structure: TransportStreamStructure) => TransportStreamPMTBox | null;
+export declare const findProgramMapTableOrThrow: (structure: TransportStreamStructure) => TransportStreamPMTBox;
 export declare const getProgramForId: (structure: TransportStreamStructure, packetIdentifier: number) => TransportStreamProgramAssociationTableEntry | null;
 export declare const getStreamForId: (structure: TransportStreamStructure, packetIdentifier: number) => TransportStreamEntry | null;

package/dist/containers/transport-stream/traversal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStreamForId = exports.getProgramForId = exports.findProgramMapTableOrThrow = void 0;
+exports.getStreamForId = exports.getProgramForId = exports.findProgramMapTableOrThrow = exports.findProgramMapOrNull = void 0;
 const findProgramAssociationTableOrThrow = (structure) => {
     const box = structure.boxes.find((b) => b.type === 'transport-stream-pat-box');
     if (!box) {
@@ -8,8 +8,16 @@ const findProgramAssociationTableOrThrow = (structure) => {
     }
     return box;
 };
-const findProgramMapTableOrThrow = (structure) => {
+const findProgramMapOrNull = (structure) => {
     const box = structure.boxes.find((b) => b.type === 'transport-stream-pmt-box');
+    if (!box) {
+        return null;
+    }
+    return box;
+};
+exports.findProgramMapOrNull = findProgramMapOrNull;
+const findProgramMapTableOrThrow = (structure) => {
+    const box = (0, exports.findProgramMapOrNull)(structure);
     if (!box) {
         throw new Error('No PMT box found');
     }

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

@@ -1,7 +1,7 @@
-import type { WavSeekingInfo } from '../../seeking-info';
+import type { WavSeekingHints } from '../../seeking-hints';
 import type { SeekResolution } from '../../work-on-seek-request';
 export declare const WAVE_SAMPLES_PER_SECOND = 25;
 export declare const getSeekingByteFromWav: ({ info, time, }: {
-    info: WavSeekingInfo;
+    info: WavSeekingHints;
     time: number;
 }) => Promise<SeekResolution>;

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

@@ -4,12 +4,12 @@ exports.getSeekingByteFromWav = exports.WAVE_SAMPLES_PER_SECOND = void 0;
 exports.WAVE_SAMPLES_PER_SECOND = 25;
 const getSeekingByteFromWav = ({ info, time, }) => {
     const bytesPerSecond = info.sampleRate * info.blockAlign;
-    const durationInSeconds = info.mediaSections.size / bytesPerSecond;
+    const durationInSeconds = info.mediaSection.size / bytesPerSecond;
     const timeRoundedDown = Math.floor(Math.min(time, durationInSeconds - 0.0000001) * exports.WAVE_SAMPLES_PER_SECOND) / exports.WAVE_SAMPLES_PER_SECOND;
     const byteOffset = bytesPerSecond * timeRoundedDown;
     return Promise.resolve({
         type: 'do-seek',
-        byte: byteOffset + info.mediaSections.start,
+        byte: byteOffset + info.mediaSection.start,
     });
 };
 exports.getSeekingByteFromWav = getSeekingByteFromWav;

package/dist/containers/wav/parse-fmt.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFmt = void 0;
 const register_track_1 = require("../../register-track");
-const work_on_seek_request_1 = require("../../work-on-seek-request");
 const parseFmt = async ({ state, }) => {
     const { iterator } = state;
     const ckSize = iterator.getUint32Le(); // chunkSize
@@ -36,7 +35,6 @@ const parseFmt = async ({ state, }) => {
     };
     state.structure.getWavStructure().boxes.push(wavHeader);
     await (0, register_track_1.registerAudioTrack)({
-        workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
         track: {
             type: 'audio',
             codec: format,

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

@@ -3,7 +3,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 work_on_seek_request_1 = require("../../work-on-seek-request");
 const get_seeking_byte_1 = require("./get-seeking-byte");
 const parseMediaSection = async ({ state, }) => {
     const { iterator } = state;
@@ -36,7 +35,6 @@ const parseMediaSection = async ({ state, }) => {
             },
             timescale: 1,
         }),
-        workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
         callbacks: state.callbacks,
     });
     return null;

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

@@ -0,0 +1,12 @@
+import type { WavSeekingHints } from '../../seeking-hints';
+import type { ParserState } from '../../state/parser-state';
+import type { MediaSectionState } from '../../state/video-section';
+import type { WavStructure } from './types';
+export declare const getSeekingHintsFromWav: ({ structure, mediaSectionState, }: {
+    structure: WavStructure;
+    mediaSectionState: MediaSectionState;
+}) => WavSeekingHints | null;
+export declare const setSeekingHintsForWav: ({ hints, state, }: {
+    hints: WavSeekingHints;
+    state: ParserState;
+}) => void;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForWav = exports.getSeekingHintsFromWav = void 0;
+const getSeekingHintsFromWav = ({ structure, mediaSectionState, }) => {
+    const fmtBox = structure.boxes.find((box) => box.type === 'wav-fmt');
+    if (!fmtBox) {
+        return null;
+    }
+    const mediaSection = mediaSectionState.getMediaSections();
+    if (mediaSection.length !== 1) {
+        return null;
+    }
+    return {
+        type: 'wav-seeking-hints',
+        sampleRate: fmtBox.sampleRate,
+        blockAlign: fmtBox.blockAlign,
+        mediaSection: mediaSection[0],
+    };
+};
+exports.getSeekingHintsFromWav = getSeekingHintsFromWav;
+const setSeekingHintsForWav = ({ hints, state, }) => {
+    // abstaining from setting fmt box, usually it is at the very beginning
+    state.mediaSection.addMediaSection(hints.mediaSection);
+};
+exports.setSeekingHintsForWav = setSeekingHintsForWav;

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/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>>;