@remotion/media-parser 4.0.241 → 4.0.242

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

@@ -2,6 +2,7 @@
 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 may_skip_video_data_1 = require("../../may-skip-video-data/may-skip-video-data");
 const key_1 = require("../avc/key");
 const parse_avc_1 = require("../avc/parse-avc");
 const traversal_1 = require("./traversal");
@@ -17,33 +18,38 @@ const getStrhForIndex = (structure, trackId) => {
     }
     return strh;
 };
-const handleChunk = async ({ iterator, options, structure, ckId, ckSize, }) => {
+const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
+    const offset = iterator.counter.getOffset();
     const videoChunk = ckId.match(/^([0-9]{2})dc$/);
     if (videoChunk) {
         const trackId = parseInt(videoChunk[1], 10);
         const strh = getStrhForIndex(structure, trackId);
         const samplesPerSecond = strh.rate / strh.scale;
-        const nthSample = options.parserState.getSamplesForTrack(trackId);
+        const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
-        const timestamp = Math.floor(timeInSec);
-        const duration = Math.floor(1 / samplesPerSecond);
+        const timestamp = timeInSec;
         const data = iterator.getSlice(ckSize);
         const infos = (0, parse_avc_1.parseAvc)(data);
         const keyOrDelta = (0, key_1.getKeyFrameOrDeltaFromAvcInfo)(infos);
         const avcProfile = infos.find((i) => i.type === 'avc-profile');
         const ppsProfile = infos.find((i) => i.type === 'avc-pps');
         if (avcProfile && ppsProfile) {
-            await options.parserState.onProfile({ pps: ppsProfile, sps: avcProfile });
-            options.parserState.tracks.setIsDone();
+            await state.riff.onProfile({ pps: ppsProfile, sps: avcProfile });
+            state.callbacks.tracks.setIsDone();
         }
-        await options.parserState.onVideoSample(trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        // 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 state.callbacks.onVideoSample(trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
             cts: timestamp,
             dts: timestamp,
             data,
-            duration,
+            duration: undefined,
             timestamp,
             trackId,
             type: keyOrDelta,
+            offset,
+            timescale: samplesPerSecond,
         }, 1));
         return;
     }
@@ -52,36 +58,45 @@ const handleChunk = async ({ iterator, options, structure, ckId, ckSize, }) => {
         const trackId = parseInt(audioChunk[1], 10);
         const strh = getStrhForIndex(structure, trackId);
         const samplesPerSecond = strh.rate / strh.scale;
-        const nthSample = options.parserState.getSamplesForTrack(trackId);
+        const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
         const timestamp = timeInSec;
-        const duration = 1 / samplesPerSecond;
-        await options.parserState.onAudioSample(trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        const data = iterator.getSlice(ckSize);
+        // 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 state.callbacks.onAudioSample(trackId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
             cts: timestamp,
             dts: timestamp,
-            data: iterator.getSlice(ckSize),
-            duration,
+            data,
+            duration: undefined,
             timestamp,
             trackId,
             type: 'key',
+            offset,
+            timescale: samplesPerSecond,
         }, 1));
     }
 };
 exports.handleChunk = handleChunk;
-const parseMovi = async ({ iterator, maxOffset, options, structure, }) => {
+const parseMovi = async ({ iterator, maxOffset, state, structure, }) => {
     while (iterator.counter.getOffset() < maxOffset) {
         if (iterator.bytesRemaining() < 8) {
             return {
                 type: 'incomplete',
                 continueParsing: () => {
-                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, options, structure }));
+                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
                 },
             };
         }
         const ckId = iterator.getByteString(4);
         const ckSize = iterator.getUint32Le();
-        if (options.parserState.maySkipVideoData() &&
-            options.parserState.getAvcProfile()) {
+        if ((0, may_skip_video_data_1.maySkipVideoData)({
+            state,
+        }) &&
+            state.riff.getAvcProfile()) {
             return {
                 type: 'complete',
                 box: {
@@ -95,11 +110,11 @@ const parseMovi = async ({ iterator, maxOffset, options, structure, }) => {
             return {
                 type: 'incomplete',
                 continueParsing: () => {
-                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, options, structure }));
+                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
                 },
             };
         }
-        await (0, exports.handleChunk)({ iterator, options, structure, ckId, ckSize });
+        await (0, exports.handleChunk)({ iterator, state, structure, ckId, ckSize });
         // Discard added zeroes
         while (iterator.counter.getOffset() < maxOffset &&
             iterator.bytesRemaining() > 0) {
@@ -124,7 +139,7 @@ const parseMovi = async ({ iterator, maxOffset, options, structure, }) => {
     return {
         type: 'incomplete',
         continueParsing: () => {
-            return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, options, structure }));
+            return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
         },
     };
 };

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

@@ -1,10 +1,10 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseRiffBox: ({ iterator, size, id, boxes, options, }: {
+export declare const parseRiffBox: ({ iterator, size, id, boxes, state, }: {
     iterator: BufferIterator;
     size: number;
     id: string;
     boxes: RiffBox[];
-    options: ParserContext;
+    state: ParserState;
 }) => Promise<RiffBox>;

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

@@ -7,12 +7,12 @@ const parse_isft_1 = require("./parse-isft");
 const parse_list_box_1 = require("./parse-list-box");
 const parse_strf_1 = require("./parse-strf");
 const parse_strh_1 = require("./parse-strh");
-const parseRiffBox = ({ iterator, size, id, boxes, options, }) => {
+const parseRiffBox = ({ iterator, size, id, boxes, state, }) => {
     if (id === 'fmt') {
         return Promise.resolve((0, parse_fmt_box_1.parseFmtBox)({ iterator, boxes, size }));
     }
     if (id === 'LIST') {
-        return (0, parse_list_box_1.parseListBox)({ iterator, size, options });
+        return (0, parse_list_box_1.parseListBox)({ iterator, size, state });
     }
     if (id === 'ISFT') {
         return Promise.resolve((0, parse_isft_1.parseIsft)({ iterator, size }));

package/dist/boxes/transport-stream/get-tracks.js

@@ -5,7 +5,7 @@ const truthy_1 = require("../../truthy");
 const traversal_1 = require("./traversal");
 const getTracksFromTransportStream = (structure, parserState) => {
     const programMapTable = (0, traversal_1.findProgramMapTableOrThrow)(structure);
-    const parserTracks = parserState.tracks.getTracks();
+    const parserTracks = parserState.callbacks.tracks.getTracks();
     const mapped = programMapTable.streams
         .map((stream) => {
         return parserTracks.find((track) => track.trackId === stream.pid);

package/dist/boxes/transport-stream/handle-aac-packet.d.ts

@@ -1,7 +1,8 @@
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import type { TransportStreamPacketBuffer } from './process-stream-buffers';
-export declare const handleAacPacket: ({ streamBuffer, options, programId, }: {
+export declare const handleAacPacket: ({ streamBuffer, state, programId, offset, }: {
     streamBuffer: TransportStreamPacketBuffer;
-    options: ParserContext;
+    state: ParserState;
     programId: number;
+    offset: number;
 }) => Promise<void>;

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

@@ -6,14 +6,14 @@ const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sa
 const register_track_1 = require("../../register-track");
 const adts_header_1 = require("./adts-header");
 const handle_avc_packet_1 = require("./handle-avc-packet");
-const handleAacPacket = async ({ streamBuffer, options, programId, }) => {
+const handleAacPacket = async ({ streamBuffer, state, programId, offset, }) => {
     var _a;
     const adtsHeader = (0, adts_header_1.readAdtsHeader)(streamBuffer.buffer);
     if (!adtsHeader) {
         throw new Error('Invalid ADTS header - too short');
     }
     const { channelConfiguration, codecPrivate, sampleRate, audioObjectType } = adtsHeader;
-    const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+    const isTrackRegistered = state.callbacks.tracks.getTracks().find((t) => {
         return t.trackId === programId;
     });
     if (!isTrackRegistered) {
@@ -32,7 +32,7 @@ const handleAacPacket = async ({ streamBuffer, options, programId, }) => {
         };
         await (0, register_track_1.registerTrack)({
             track,
-            options,
+            state,
             container: 'transport-stream',
         });
     }
@@ -44,7 +44,9 @@ const handleAacPacket = async ({ streamBuffer, options, programId, }) => {
         data: new Uint8Array(streamBuffer.buffer),
         trackId: programId,
         type: 'key',
+        offset,
+        timescale: handle_avc_packet_1.MPEG_TIMESCALE,
     };
-    await options.parserState.onAudioSample(programId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, handle_avc_packet_1.MPEG_TIMESCALE));
+    await state.callbacks.onAudioSample(programId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, handle_avc_packet_1.MPEG_TIMESCALE));
 };
 exports.handleAacPacket = handleAacPacket;

package/dist/boxes/transport-stream/handle-avc-packet.d.ts

@@ -1,8 +1,9 @@
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import type { TransportStreamPacketBuffer } from './process-stream-buffers';
 export declare const MPEG_TIMESCALE = 90000;
-export declare const handleAvcPacket: ({ streamBuffer, programId, options, }: {
+export declare const handleAvcPacket: ({ streamBuffer, programId, state, offset, }: {
     streamBuffer: TransportStreamPacketBuffer;
     programId: number;
-    options: ParserContext;
+    state: ParserState;
+    offset: number;
 }) => Promise<void>;

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

@@ -3,17 +3,17 @@ 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 register_track_1 = require("../../register-track");
-const codec_private_1 = require("../avc/codec-private");
 const codec_string_1 = require("../avc/codec-string");
+const create_sps_pps_data_1 = require("../avc/create-sps-pps-data");
 const interpret_sps_1 = require("../avc/interpret-sps");
 const key_1 = require("../avc/key");
 const parse_avc_1 = require("../avc/parse-avc");
 const sps_and_pps_1 = require("../avc/sps-and-pps");
 exports.MPEG_TIMESCALE = 90000;
-const handleAvcPacket = async ({ streamBuffer, programId, options, }) => {
+const handleAvcPacket = async ({ streamBuffer, programId, state, offset, }) => {
     var _a;
     const avc = (0, parse_avc_1.parseAvc)(streamBuffer.buffer);
-    const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+    const isTrackRegistered = state.callbacks.tracks.getTracks().find((t) => {
         return t.trackId === programId;
     });
     if (!isTrackRegistered) {
@@ -26,7 +26,7 @@ const handleAvcPacket = async ({ streamBuffer, programId, options, }) => {
             type: 'video',
             timescale: exports.MPEG_TIMESCALE,
             codec: (0, codec_string_1.getCodecStringFromSpsAndPps)(spsAndPps.sps),
-            codecPrivate: (0, codec_private_1.getAvccBoxContent)(spsAndPps),
+            codecPrivate: (0, create_sps_pps_data_1.createSpsPpsData)(spsAndPps),
             fps: null,
             codedWidth: dimensions.width,
             codedHeight: dimensions.height,
@@ -43,7 +43,7 @@ const handleAvcPacket = async ({ streamBuffer, programId, options, }) => {
             },
             color: (0, interpret_sps_1.getVideoColorFromSps)(spsAndPps.sps.spsData),
         };
-        await (0, register_track_1.registerTrack)({ track, options, container: 'transport-stream' });
+        await (0, register_track_1.registerTrack)({ track, state, container: 'transport-stream' });
     }
     // sample for webcodecs needs to be in nano seconds
     const sample = {
@@ -54,7 +54,9 @@ const handleAvcPacket = async ({ streamBuffer, programId, options, }) => {
         data: new Uint8Array(streamBuffer.buffer),
         trackId: programId,
         type: (0, key_1.getKeyFrameOrDeltaFromAvcInfo)(avc),
+        offset,
+        timescale: exports.MPEG_TIMESCALE,
     };
-    await options.parserState.onVideoSample(programId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, exports.MPEG_TIMESCALE));
+    await state.callbacks.onVideoSample(programId, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)(sample, exports.MPEG_TIMESCALE));
 };
 exports.handleAvcPacket = handleAvcPacket;

package/dist/boxes/transport-stream/parse-packet.d.ts

@@ -1,13 +1,13 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { TransportStreamStructure } from '../../parse-result';
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import type { TransportStreamBox } from './boxes';
 import type { NextPesHeaderStore } from './next-pes-header-store';
 import { type StreamBufferMap } from './process-stream-buffers';
-export declare const parsePacket: ({ iterator, structure, streamBuffers, parserContext, nextPesHeaderStore, }: {
+export declare const parsePacket: ({ iterator, structure, streamBuffers, parserState, nextPesHeaderStore, }: {
     iterator: BufferIterator;
     structure: TransportStreamStructure;
     streamBuffers: StreamBufferMap;
-    parserContext: ParserContext;
+    parserState: ParserState;
     nextPesHeaderStore: NextPesHeaderStore;
 }) => Promise<TransportStreamBox | null>;

package/dist/boxes/transport-stream/parse-packet.js

@@ -6,7 +6,7 @@ const parse_pes_1 = require("./parse-pes");
 const parse_pmt_1 = require("./parse-pmt");
 const parse_stream_packet_1 = require("./parse-stream-packet");
 const traversal_1 = require("./traversal");
-const parsePacket = async ({ iterator, structure, streamBuffers, parserContext, nextPesHeaderStore, }) => {
+const parsePacket = async ({ iterator, structure, streamBuffers, parserState, nextPesHeaderStore, }) => {
     const offset = iterator.counter.getOffset();
     const syncByte = iterator.getUint8();
     if (syncByte !== 0x47) {
@@ -69,7 +69,7 @@ const parsePacket = async ({ iterator, structure, streamBuffers, parserContext,
             transportStreamEntry: stream,
             streamBuffers,
             nextPesHeader: nextPesHeaderStore.getNextPesHeader(),
-            parserContext,
+            state: parserState,
             programId,
             structure,
         });

package/dist/boxes/transport-stream/parse-stream-packet.d.ts

@@ -1,14 +1,14 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { TransportStreamStructure } from '../../parse-result';
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import type { PacketPes } from './parse-pes';
 import type { TransportStreamEntry } from './parse-pmt';
 import { type StreamBufferMap } from './process-stream-buffers';
-export declare const parseStream: ({ iterator, transportStreamEntry, streamBuffers, parserContext, programId, structure, nextPesHeader, }: {
+export declare const parseStream: ({ iterator, transportStreamEntry, streamBuffers, state, programId, structure, nextPesHeader, }: {
     iterator: BufferIterator;
     transportStreamEntry: TransportStreamEntry;
     streamBuffers: StreamBufferMap;
-    parserContext: ParserContext;
+    state: ParserState;
     programId: number;
     structure: TransportStreamStructure;
     nextPesHeader: PacketPes;

package/dist/boxes/transport-stream/parse-stream-packet.js

@@ -6,13 +6,14 @@ const adts_header_1 = require("./adts-header");
 const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
 const find_separator_1 = require("./find-separator");
 const process_stream_buffers_1 = require("./process-stream-buffers");
-const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, streamBuffers, nextPesHeader, options, structure, }) => {
+const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, streamBuffers, nextPesHeader, state, structure, offset, }) => {
     var _a, _b;
     const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
     if (!streamBuffer) {
         streamBuffers.set(transportStreamEntry.pid, {
             buffer: restOfPacket,
             pesHeader: nextPesHeader,
+            offset,
         });
         return;
     }
@@ -28,17 +29,18 @@ const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, streamBuffe
         await (0, process_stream_buffers_1.processStreamBuffer)({
             streamBuffer,
             programId: transportStreamEntry.pid,
-            options,
+            state,
             structure,
         });
         const rest = restOfPacket.slice(bytesToTake);
         streamBuffers.set(transportStreamEntry.pid, {
             buffer: rest,
             pesHeader: nextPesHeader,
+            offset,
         });
     }
 };
-const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffers, nextPesHeader, programId, parserContext, structure, }) => {
+const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffers, nextPesHeader, programId, state, structure, offset, }) => {
     const indexOfSeparator = (0, find_separator_1.findNextSeparator)(restOfPacket, transportStreamEntry);
     const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
     if (indexOfSeparator === -1) {
@@ -52,6 +54,7 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
         streamBuffers.set(programId, {
             pesHeader: nextPesHeader,
             buffer: restOfPacket,
+            offset,
         });
         return;
     }
@@ -59,7 +62,7 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
         const packet = restOfPacket.slice(0, indexOfSeparator);
         streamBuffer.buffer = (0, make_header_1.combineUint8Arrays)([streamBuffer.buffer, packet]);
         await (0, process_stream_buffers_1.processStreamBuffer)({
-            options: parserContext,
+            state,
             streamBuffer,
             programId,
             structure,
@@ -68,6 +71,7 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
         streamBuffers.set(programId, {
             pesHeader: nextPesHeader,
             buffer: rest,
+            offset,
         });
         return;
     }
@@ -77,9 +81,10 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
     streamBuffers.set(programId, {
         pesHeader: nextPesHeader,
         buffer: restOfPacket.slice(indexOfSeparator),
+        offset,
     });
 };
-const parseStream = ({ iterator, transportStreamEntry, streamBuffers, parserContext, programId, structure, nextPesHeader, }) => {
+const parseStream = ({ iterator, transportStreamEntry, streamBuffers, state, programId, structure, nextPesHeader, }) => {
     const restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
     if (transportStreamEntry.streamType === 27) {
         return parseAvcStream({
@@ -87,9 +92,10 @@ const parseStream = ({ iterator, transportStreamEntry, streamBuffers, parserCont
             transportStreamEntry,
             streamBuffers,
             nextPesHeader,
-            parserContext,
+            state,
             programId,
             structure,
+            offset: iterator.counter.getOffset(),
         });
     }
     if (transportStreamEntry.streamType === 15) {
@@ -98,8 +104,9 @@ const parseStream = ({ iterator, transportStreamEntry, streamBuffers, parserCont
             transportStreamEntry,
             streamBuffers,
             nextPesHeader,
-            options: parserContext,
+            state,
             structure,
+            offset: iterator.counter.getOffset(),
         });
     }
     throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);

package/dist/boxes/transport-stream/parse-transport-stream.d.ts

@@ -1,14 +1,13 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { Options, ParseMediaFields } from '../../options';
-import type { ParseResult, TransportStreamStructure } from '../../parse-result';
-import type { ParserContext } from '../../parser-context';
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
 import type { NextPesHeaderStore } from './next-pes-header-store';
 import { type StreamBufferMap } from './process-stream-buffers';
-export declare const parseTransportStream: ({ iterator, parserContext, structure, streamBuffers, fields, nextPesHeaderStore, }: {
+export declare const parseTransportStream: ({ iterator, state, streamBuffers, fields, nextPesHeaderStore, }: {
     iterator: BufferIterator;
-    parserContext: ParserContext;
-    structure: TransportStreamStructure;
+    state: ParserState;
     streamBuffers: StreamBufferMap;
     fields: Options<ParseMediaFields>;
     nextPesHeaderStore: NextPesHeaderStore;
-}) => Promise<ParseResult<TransportStreamStructure>>;
+}) => Promise<ParseResult>;

package/dist/boxes/transport-stream/parse-transport-stream.js

@@ -4,11 +4,15 @@ exports.parseTransportStream = void 0;
 const has_all_info_1 = require("../../has-all-info");
 const parse_packet_1 = require("./parse-packet");
 const process_stream_buffers_1 = require("./process-stream-buffers");
-const parseTransportStream = async ({ iterator, parserContext, structure, streamBuffers, fields, nextPesHeaderStore, }) => {
+const parseTransportStream = async ({ iterator, state, streamBuffers, fields, nextPesHeaderStore, }) => {
+    const structure = state.structure.getStructure();
+    if (structure.type !== 'transport-stream') {
+        throw new Error('Invalid structure type');
+    }
     if (iterator.bytesRemaining() === 0) {
         await (0, process_stream_buffers_1.processFinalStreamBuffers)({
             streamBufferMap: streamBuffers,
-            parserContext,
+            state,
             structure,
         });
         return Promise.resolve({
@@ -19,8 +23,7 @@ const parseTransportStream = async ({ iterator, parserContext, structure, stream
     while (true) {
         if ((0, has_all_info_1.hasAllInfo)({
             fields,
-            state: parserContext.parserState,
-            structure,
+            state,
         })) {
             break;
         }
@@ -32,8 +35,7 @@ const parseTransportStream = async ({ iterator, parserContext, structure, stream
                 continueParsing: () => {
                     return (0, exports.parseTransportStream)({
                         iterator,
-                        parserContext,
-                        structure,
+                        state,
                         streamBuffers,
                         fields,
                         nextPesHeaderStore,
@@ -45,7 +47,7 @@ const parseTransportStream = async ({ iterator, parserContext, structure, stream
             iterator,
             structure,
             streamBuffers,
-            parserContext,
+            parserState: state,
             nextPesHeaderStore,
         });
         if (packet) {
@@ -59,8 +61,7 @@ const parseTransportStream = async ({ iterator, parserContext, structure, stream
         continueParsing() {
             return (0, exports.parseTransportStream)({
                 iterator,
-                parserContext,
-                structure,
+                state,
                 streamBuffers,
                 fields,
                 nextPesHeaderStore,

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

@@ -1,19 +1,20 @@
 import type { TransportStreamStructure } from '../../parse-result';
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import type { PacketPes } from './parse-pes';
 export type TransportStreamPacketBuffer = {
     buffer: Uint8Array;
     pesHeader: PacketPes;
+    offset: number;
 };
 export type StreamBufferMap = Map<number, TransportStreamPacketBuffer>;
-export declare const processStreamBuffer: ({ streamBuffer, options, programId, structure, }: {
+export declare const processStreamBuffer: ({ streamBuffer, state, programId, structure, }: {
     streamBuffer: TransportStreamPacketBuffer;
-    options: ParserContext;
+    state: ParserState;
     programId: number;
     structure: TransportStreamStructure;
 }) => Promise<void>;
-export declare const processFinalStreamBuffers: ({ streamBufferMap, parserContext, structure, }: {
+export declare const processFinalStreamBuffers: ({ streamBufferMap, state, structure, }: {
     streamBufferMap: StreamBufferMap;
-    parserContext: ParserContext;
+    state: ParserState;
     structure: TransportStreamStructure;
 }) => Promise<void>;

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

@@ -4,34 +4,44 @@ exports.processFinalStreamBuffers = exports.processStreamBuffer = void 0;
 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, options, programId, structure, }) => {
+const processStreamBuffer = async ({ streamBuffer, state, programId, structure, }) => {
     const stream = (0, traversal_1.getStreamForId)(structure, programId);
     if (!stream) {
         throw new Error('No stream found');
     }
     // 27 = AVC / H.264 Video
     if (stream.streamType === 27) {
-        await (0, handle_avc_packet_1.handleAvcPacket)({ programId, streamBuffer, options });
+        await (0, handle_avc_packet_1.handleAvcPacket)({
+            programId,
+            streamBuffer,
+            state,
+            offset: streamBuffer.offset,
+        });
     }
     // 15 = AAC / ADTS
     else if (stream.streamType === 15) {
-        await (0, handle_aac_packet_1.handleAacPacket)({ streamBuffer, options, programId });
+        await (0, handle_aac_packet_1.handleAacPacket)({
+            streamBuffer,
+            state,
+            programId,
+            offset: streamBuffer.offset,
+        });
     }
-    if (!options.parserState.tracks.hasAllTracks()) {
-        const tracksRegistered = options.parserState.tracks.getTracks().length;
+    if (!state.callbacks.tracks.hasAllTracks()) {
+        const tracksRegistered = state.callbacks.tracks.getTracks().length;
         const { streams } = (0, traversal_1.findProgramMapTableOrThrow)(structure);
         if (streams.length === tracksRegistered) {
-            options.parserState.tracks.setIsDone();
+            state.callbacks.tracks.setIsDone();
         }
     }
 };
 exports.processStreamBuffer = processStreamBuffer;
-const processFinalStreamBuffers = async ({ streamBufferMap, parserContext, structure, }) => {
+const processFinalStreamBuffers = async ({ streamBufferMap, state, structure, }) => {
     for (const [programId, buffer] of streamBufferMap) {
         if (buffer.buffer.byteLength > 0) {
             await (0, exports.processStreamBuffer)({
                 streamBuffer: buffer,
-                options: parserContext,
+                state,
                 programId,
                 structure,
             });

package/dist/boxes/webm/ebml.d.ts

@@ -1,2 +1,2 @@
-export declare const measureEBMLVarInt: (value: number) => 2 | 1 | 4 | 3 | 5 | 6;
+export declare const measureEBMLVarInt: (value: number) => 1 | 2 | 3 | 4 | 5 | 6;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;

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

@@ -1,4 +1,4 @@
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import type { AudioOrVideoSample } from '../../webcodec-sample-types';
 import type { BlockSegment, SimpleBlockSegment } from './segments/all-segments';
 type SampleResult = {
@@ -13,5 +13,5 @@ type SampleResult = {
 } | {
     type: 'no-sample';
 };
-export declare const getSampleFromBlock: (ebml: BlockSegment | SimpleBlockSegment, parserContext: ParserContext, offset: number) => SampleResult;
+export declare const getSampleFromBlock: (ebml: BlockSegment | SimpleBlockSegment, state: ParserState, offset: number) => SampleResult;
 export {};