@remotion/media-parser 4.0.249 → 4.0.251

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

@@ -0,0 +1,29 @@
+"use strict";
+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 counter = iterator.counter.getOffset();
+    const listType = iterator.getByteString(4, false);
+    if (listType === 'movi') {
+        throw new Error('should not be handled here');
+    }
+    const boxes = [];
+    const maxOffset = counter + size;
+    while (iterator.counter.getOffset() < maxOffset) {
+        const result = await (0, expect_riff_box_1.expectRiffBox)(state);
+        if (result.box !== null) {
+            boxes.push(result.box);
+        }
+        else {
+            throw new Error('Unexpected result');
+        }
+    }
+    return {
+        type: 'list-box',
+        listType,
+        children: boxes,
+    };
+};
+exports.parseListBox = parseListBox;

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

@@ -0,0 +1,11 @@
+import type { ParserState } from '../../state/parser-state';
+import type { RiffResult } from './expect-riff-box';
+export declare const handleChunk: ({ state, ckId, ckSize, }: {
+    state: ParserState;
+    ckId: string;
+    ckSize: number;
+}) => Promise<void>;
+export declare const parseMovi: ({ maxOffset, state, }: {
+    maxOffset: number;
+    state: ParserState;
+}) => Promise<RiffResult>;

package/dist/{boxes → containers}/riff/parse-movi.js

@@ -2,7 +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 may_skip_video_data_1 = require("../../state/may-skip-video-data");
 const key_1 = require("../avc/key");
 const parse_avc_1 = require("../avc/parse-avc");
 const traversal_1 = require("./traversal");
@@ -18,12 +18,13 @@ const getStrhForIndex = (structure, trackId) => {
     }
     return strh;
 };
-const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
+const handleChunk = async ({ state, ckId, ckSize, }) => {
+    const { iterator } = state;
     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 strh = getStrhForIndex(state.structure.getStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
@@ -56,7 +57,7 @@ const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
     const audioChunk = ckId.match(/^([0-9]{2})wb$/);
     if (audioChunk) {
         const trackId = parseInt(audioChunk[1], 10);
-        const strh = getStrhForIndex(structure, trackId);
+        const strh = getStrhForIndex(state.structure.getStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
@@ -81,66 +82,45 @@ const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
     }
 };
 exports.handleChunk = handleChunk;
-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, state, structure }));
-                },
-            };
-        }
-        const ckId = iterator.getByteString(4, false);
-        const ckSize = iterator.getUint32Le();
-        if ((0, may_skip_video_data_1.maySkipVideoData)({
-            state,
-        }) &&
-            state.riff.getAvcProfile()) {
-            return {
-                type: 'complete',
-                box: {
-                    type: 'movi-box',
-                },
-                skipTo: maxOffset,
-            };
-        }
-        if (iterator.bytesRemaining() < ckSize) {
-            iterator.counter.decrement(8);
-            return {
-                type: 'incomplete',
-                continueParsing: () => {
-                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
-                },
-            };
-        }
-        await (0, exports.handleChunk)({ iterator, state, structure, ckId, ckSize });
-        // Discard added zeroes
-        while (iterator.counter.getOffset() < maxOffset &&
-            iterator.bytesRemaining() > 0) {
-            if (iterator.getUint8() !== 0) {
-                iterator.counter.decrement(1);
-                break;
-            }
-        }
+const parseMovi = async ({ maxOffset, state, }) => {
+    if ((0, may_skip_video_data_1.maySkipVideoData)({
+        state,
+    }) &&
+        state.riff.getAvcProfile()) {
+        return {
+            box: null,
+            skipTo: maxOffset,
+        };
     }
-    if (iterator.counter.getOffset() === maxOffset) {
+    const { iterator } = state;
+    if (iterator.bytesRemaining() < 8) {
         return {
-            type: 'complete',
-            box: {
-                type: 'movi-box',
-            },
+            box: null,
             skipTo: null,
         };
     }
-    if (iterator.counter.getOffset() > maxOffset) {
-        throw new Error('Oops, this should not happen!');
+    const checkpoint = iterator.startCheckpoint();
+    const ckId = iterator.getByteString(4, false);
+    const ckSize = iterator.getUint32Le();
+    if (iterator.bytesRemaining() < ckSize) {
+        checkpoint.returnToCheckpoint();
+        return {
+            box: null,
+            skipTo: null,
+        };
+    }
+    await (0, exports.handleChunk)({ state, ckId, ckSize });
+    // Discard added zeroes
+    while (iterator.counter.getOffset() < maxOffset &&
+        iterator.bytesRemaining() > 0) {
+        if (iterator.getUint8() !== 0) {
+            iterator.counter.decrement(1);
+            break;
+        }
     }
     return {
-        type: 'incomplete',
-        continueParsing: () => {
-            return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
-        },
+        box: null,
+        skipTo: null,
     };
 };
 exports.parseMovi = parseMovi;

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

@@ -0,0 +1,3 @@
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseRiffBody: (state: ParserState) => Promise<ParseResult>;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiffBody = void 0;
+const expect_riff_box_1 = require("./expect-riff-box");
+const parse_video_section_1 = require("./parse-video-section");
+const parseRiffBody = async (state) => {
+    if (state.videoSection.isInVideoSectionState(state.iterator) === 'in-section') {
+        const videoSec = await (0, parse_video_section_1.parseVideoSection)(state);
+        return {
+            skipTo: videoSec.skipTo,
+        };
+    }
+    const result = await (0, expect_riff_box_1.expectRiffBox)(state);
+    if (result.box !== null) {
+        const structure = state.structure.getStructure();
+        structure.boxes.push(result.box);
+    }
+    return {
+        skipTo: result.skipTo,
+    };
+};
+exports.parseRiffBody = parseRiffBody;

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

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

package/dist/{boxes → containers}/riff/parse-riff-box.js

@@ -2,17 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRiffBox = void 0;
 const parse_avih_1 = require("./parse-avih");
-const parse_fmt_box_1 = require("./parse-fmt-box");
 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, state, fields, }) => {
-    if (id === 'fmt') {
-        return Promise.resolve((0, parse_fmt_box_1.parseFmtBox)({ iterator, boxes, size }));
-    }
+const parseRiffBox = ({ size, id, state, }) => {
+    const { iterator } = state;
     if (id === 'LIST') {
-        return (0, parse_list_box_1.parseListBox)({ iterator, size, state, fields });
+        return (0, parse_list_box_1.parseListBox)({ size, state });
     }
     if (id === 'ISFT') {
         return Promise.resolve((0, parse_isft_1.parseIsft)({ iterator, size }));
@@ -23,9 +19,6 @@ const parseRiffBox = ({ iterator, size, id, boxes, state, fields, }) => {
     if (id === 'strh') {
         return Promise.resolve((0, parse_strh_1.parseStrh)({ iterator, size }));
     }
-    if (id === 'strf') {
-        return Promise.resolve((0, parse_strf_1.parseStrf)({ iterator, size, boxes }));
-    }
     iterator.discard(size);
     const box = {
         type: 'riff-box',

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

@@ -0,0 +1,3 @@
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseRiffHeader: (state: ParserState) => ParseResult;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiffHeader = void 0;
+const parseRiffHeader = (state) => {
+    const riff = state.iterator.getByteString(4, false);
+    if (riff !== 'RIFF') {
+        throw new Error('Not a RIFF file');
+    }
+    const structure = state.structure.getStructure();
+    if (structure.type !== 'riff') {
+        throw new Error('Structure is not a RIFF structure');
+    }
+    const size = state.iterator.getUint32Le();
+    const fileType = state.iterator.getByteString(4, false);
+    if (fileType !== 'WAVE' && fileType !== 'AVI') {
+        throw new Error(`File type ${fileType} not supported`);
+    }
+    structure.boxes.push({ type: 'riff-header', fileSize: size, fileType });
+    return {
+        skipTo: null,
+    };
+};
+exports.parseRiffHeader = parseRiffHeader;

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

@@ -0,0 +1,3 @@
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseRiff: (state: ParserState) => Promise<ParseResult>;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiff = void 0;
+const parse_riff_body_1 = require("./parse-riff-body");
+const parse_riff_header_1 = require("./parse-riff-header");
+const parseRiff = (state) => {
+    if (state.iterator.counter.getOffset() === 0) {
+        return Promise.resolve((0, parse_riff_header_1.parseRiffHeader)(state));
+    }
+    return (0, parse_riff_body_1.parseRiffBody)(state);
+};
+exports.parseRiff = parseRiff;

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

@@ -0,0 +1,7 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { FccType, StrfBoxAudio, StrfBoxVideo } from './riff-box';
+export declare const parseStrf: ({ iterator, size, fccType, }: {
+    iterator: BufferIterator;
+    size: number;
+    fccType: FccType;
+}) => StrfBoxAudio | StrfBoxVideo;

package/dist/{boxes → containers}/riff/parse-strf.js

@@ -51,17 +51,13 @@ const parseStrfVideo = ({ iterator, size, }) => {
         yPelsPerMeter,
     };
 };
-const parseStrf = ({ iterator, size, boxes, }) => {
-    const strh = boxes.find((b) => b.type === 'strh-box');
-    if (!strh) {
-        throw new Error('strh box not found');
-    }
-    if (strh.fccType === 'vids') {
+const parseStrf = ({ iterator, size, fccType, }) => {
+    if (fccType === 'vids') {
         return parseStrfVideo({ iterator, size });
     }
-    if (strh.fccType === 'auds') {
+    if (fccType === 'auds') {
         return parseStrfAudio({ iterator, size });
     }
-    throw new Error(`Unsupported fccType: ${strh.fccType}`);
+    throw new Error(`Unsupported fccType: ${fccType}`);
 };
 exports.parseStrf = parseStrf;

package/dist/{boxes → containers}/riff/parse-strh.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStrh = void 0;
+const parse_strf_1 = require("./parse-strf");
 const parseStrh = ({ iterator, size, }) => {
     const box = iterator.startBox(size);
     const fccType = iterator.getByteString(4, false);
@@ -28,6 +29,15 @@ const parseStrh = ({ iterator, size, }) => {
     const quality = iterator.getUint32Le();
     const sampleSize = iterator.getUint32Le();
     box.discardRest();
+    const ckId = iterator.getByteString(4, false);
+    const ckSize = iterator.getUint32Le();
+    if (ckId !== 'strf') {
+        throw new Error(`Expected strf, got ${JSON.stringify(ckId)}`);
+    }
+    if (iterator.bytesRemaining() < ckSize) {
+        throw new Error('Expected strf to be complete');
+    }
+    const strf = (0, parse_strf_1.parseStrf)({ iterator, size: ckSize, fccType });
     return {
         type: 'strh-box',
         fccType,
@@ -43,6 +53,7 @@ const parseStrh = ({ iterator, size, }) => {
         start,
         suggestedBufferSize,
         language,
+        strf,
     };
 };
 exports.parseStrh = parseStrh;

package/dist/containers/riff/parse-video-section.d.ts

@@ -0,0 +1,2 @@
+import type { ParserState } from '../../state/parser-state';
+export declare const parseVideoSection: (state: ParserState) => Promise<import("./expect-riff-box").RiffResult>;

package/dist/containers/riff/parse-video-section.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVideoSection = void 0;
+const get_tracks_1 = require("../../get-tracks");
+const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
+const parse_movi_1 = require("./parse-movi");
+const parseVideoSection = (state) => {
+    const videoSection = state.videoSection.getVideoSection();
+    const movi = (0, parse_movi_1.parseMovi)({
+        maxOffset: videoSection.start + videoSection.size,
+        state,
+    });
+    const tracks = (0, get_tracks_1.getTracks)(state);
+    if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
+        state.callbacks.tracks.setIsDone();
+    }
+    return movi;
+};
+exports.parseVideoSection = parseVideoSection;

package/dist/{boxes → containers}/riff/riff-box.d.ts

@@ -1,12 +1,3 @@
-export type WaveFormatBox = {
-    type: 'wave-format-box';
-    formatTag: 1;
-    numberOfChannels: number;
-    sampleRate: number;
-    blockAlign: number;
-    byteRate: number;
-    bitsPerSample: number;
-};
 export type ListBox = {
     type: 'list-box';
     listType: string;
@@ -30,9 +21,10 @@ export type AvihBox = {
     width: number;
     height: number;
 };
+export type FccType = 'vids' | 'auds';
 export type StrhBox = {
     type: 'strh-box';
-    fccType: 'vids' | 'auds';
+    fccType: FccType;
     handler: 'H264' | number;
     flags: number;
     priority: number;
@@ -45,6 +37,7 @@ export type StrhBox = {
     quality: number;
     sampleSize: number;
     language: number;
+    strf: StrfBoxVideo | StrfBoxAudio;
 };
 export type StrfBoxVideo = {
     type: 'strf-box-video';
@@ -75,11 +68,12 @@ export type RiffHeader = {
     fileSize: number;
     fileType: string;
 };
-export type MoviBox = {
-    type: 'movi-box';
-};
 export type IsftBox = {
     type: 'isft-box';
     software: string;
 };
-export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | MoviBox | IsftBox;
+export type RiffBox = RiffRegularBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | IsftBox;
+export type RiffStructure = {
+    type: 'riff';
+    boxes: RiffBox[];
+};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{boxes → containers}/riff/traversal.d.ts

@@ -1,8 +1,6 @@
-import type { RiffStructure } from '../../parse-result';
-import type { AvihBox, ListBox, RiffBox, StrfBoxAudio, StrfBoxVideo, StrhBox } from './riff-box';
+import type { AvihBox, ListBox, RiffBox, RiffStructure, StrhBox } from './riff-box';
 export declare const isRiffAvi: (structure: RiffStructure) => boolean;
 export declare const getHdlrBox: (structure: RiffStructure) => ListBox | null;
 export declare const getAvihBox: (structure: RiffStructure) => AvihBox | null;
 export declare const getStrlBoxes: (structure: RiffStructure) => ListBox[];
 export declare const getStrhBox: (strlBoxChildren: RiffBox[]) => StrhBox | null;
-export declare const getStrfBox: (strlBoxChildren: RiffBox[]) => StrfBoxAudio | StrfBoxVideo | null;

package/dist/{boxes → containers}/riff/traversal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStrfBox = exports.getStrhBox = exports.getStrlBoxes = exports.getAvihBox = exports.getHdlrBox = exports.isRiffAvi = void 0;
+exports.getStrhBox = exports.getStrlBoxes = exports.getAvihBox = exports.getHdlrBox = exports.isRiffAvi = void 0;
 const isRiffAvi = (structure) => {
     return structure.boxes.some((box) => box.type === 'riff-header' && box.fileType === 'AVI');
 };
@@ -29,8 +29,3 @@ const getStrhBox = (strlBoxChildren) => {
     return strlBoxChildren.find((box) => box.type === 'strh-box');
 };
 exports.getStrhBox = getStrhBox;
-const getStrfBox = (strlBoxChildren) => {
-    var _a;
-    return ((_a = strlBoxChildren.find((box) => box.type === 'strf-box-audio' || box.type === 'strf-box-video')) !== null && _a !== void 0 ? _a : null);
-};
-exports.getStrfBox = getStrfBox;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/containers/transport-stream/get-tracks.d.ts

@@ -0,0 +1,4 @@
+import type { ParserState } from '../../state/parser-state';
+import type { AllTracks } from '../riff/get-tracks-from-avi';
+export declare const getTracksFromTransportStream: (parserState: ParserState) => AllTracks;
+export declare const hasAllTracksFromTransportStream: (parserState: ParserState) => boolean;

package/dist/{boxes → containers}/transport-stream/get-tracks.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasAllTracksFromTransportStream = exports.getTracksFromTransportStream = void 0;
 const truthy_1 = require("../../truthy");
 const traversal_1 = require("./traversal");
-const getTracksFromTransportStream = (structure, parserState) => {
+const getTracksFromTransportStream = (parserState) => {
+    const structure = parserState.structure.getStructure();
     const programMapTable = (0, traversal_1.findProgramMapTableOrThrow)(structure);
     const parserTracks = parserState.callbacks.tracks.getTracks();
     const mapped = programMapTable.streams
@@ -21,9 +22,9 @@ const getTracksFromTransportStream = (structure, parserState) => {
     };
 };
 exports.getTracksFromTransportStream = getTracksFromTransportStream;
-const hasAllTracksFromTransportStream = (structure, parserState) => {
+const hasAllTracksFromTransportStream = (parserState) => {
     try {
-        (0, exports.getTracksFromTransportStream)(structure, parserState);
+        (0, exports.getTracksFromTransportStream)(parserState);
         return true;
     }
     catch (_a) {

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

@@ -0,0 +1,5 @@
+import type { ParserState } from '../../state/parser-state';
+import type { TransportStreamBox } from './boxes';
+export declare const parsePacket: ({ parserState, }: {
+    parserState: ParserState;
+}) => Promise<TransportStreamBox | null>;

package/dist/{boxes → containers}/transport-stream/parse-packet.js

@@ -6,7 +6,8 @@ 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, parserState, nextPesHeaderStore, }) => {
+const parsePacket = async ({ parserState, }) => {
+    const { iterator } = parserState;
     const offset = iterator.counter.getOffset();
     const syncByte = iterator.getUint8();
     if (syncByte !== 0x47) {
@@ -45,11 +46,12 @@ const parsePacket = async ({ iterator, structure, streamBuffers, parserState, ne
     if (read === 188) {
         return Promise.resolve(null);
     }
+    const structure = parserState.structure.getStructure();
     const pat = structure.boxes.find((b) => b.type === 'transport-stream-pmt-box');
     const isPes = payloadUnitStartIndicator && (pat === null || pat === void 0 ? void 0 : pat.streams.find((e) => e.pid === programId));
     if (isPes) {
         const packetPes = (0, parse_pes_1.parsePes)(iterator);
-        nextPesHeaderStore.setNextPesHeader(packetPes);
+        parserState.transportStream.nextPesHeaderStore.setNextPesHeader(packetPes);
     }
     else if (payloadUnitStartIndicator === 1) {
         iterator.getUint8(); // pointerField
@@ -65,10 +67,7 @@ const parsePacket = async ({ iterator, structure, streamBuffers, parserState, ne
     const stream = (0, traversal_1.getStreamForId)(structure, programId);
     if (stream) {
         await (0, parse_stream_packet_1.parseStream)({
-            iterator,
             transportStreamEntry: stream,
-            streamBuffers,
-            nextPesHeader: nextPesHeaderStore.getNextPesHeader(),
             state: parserState,
             programId,
             structure,

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

@@ -0,0 +1,9 @@
+import type { TransportStreamStructure } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+import type { TransportStreamEntry } from './parse-pmt';
+export declare const parseStream: ({ transportStreamEntry, state, programId, structure, }: {
+    transportStreamEntry: TransportStreamEntry;
+    state: ParserState;
+    programId: number;
+    structure: TransportStreamStructure;
+}) => Promise<void>;

package/dist/{boxes → containers}/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, state, structure, offset, }) => {
+const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, state, structure, offset, }) => {
     var _a, _b;
+    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
     const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
     if (!streamBuffer) {
         streamBuffers.set(transportStreamEntry.pid, {
             buffer: restOfPacket,
-            pesHeader: nextPesHeader,
+            pesHeader: nextPesHeader.getNextPesHeader(),
             offset,
         });
         return;
@@ -35,13 +36,14 @@ const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, streamBuffe
         const rest = restOfPacket.slice(bytesToTake);
         streamBuffers.set(transportStreamEntry.pid, {
             buffer: rest,
-            pesHeader: nextPesHeader,
+            pesHeader: nextPesHeader.getNextPesHeader(),
             offset,
         });
     }
 };
-const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffers, nextPesHeader, programId, state, structure, offset, }) => {
+const parseAvcStream = async ({ restOfPacket, transportStreamEntry, programId, state, structure, offset, }) => {
     const indexOfSeparator = (0, find_separator_1.findNextSeparator)(restOfPacket, transportStreamEntry);
+    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
     const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
     if (indexOfSeparator === -1) {
         if (streamBuffer) {
@@ -52,7 +54,7 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
             return;
         }
         streamBuffers.set(programId, {
-            pesHeader: nextPesHeader,
+            pesHeader: nextPesHeader.getNextPesHeader(),
             buffer: restOfPacket,
             offset,
         });
@@ -69,7 +71,7 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
         });
         const rest = restOfPacket.slice(indexOfSeparator);
         streamBuffers.set(programId, {
-            pesHeader: nextPesHeader,
+            pesHeader: nextPesHeader.getNextPesHeader(),
             buffer: rest,
             offset,
         });
@@ -79,19 +81,18 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
         throw new Error('No stream buffer found but new separator is not at the beginning');
     }
     streamBuffers.set(programId, {
-        pesHeader: nextPesHeader,
+        pesHeader: nextPesHeader.getNextPesHeader(),
         buffer: restOfPacket.slice(indexOfSeparator),
         offset,
     });
 };
-const parseStream = ({ iterator, transportStreamEntry, streamBuffers, state, programId, structure, nextPesHeader, }) => {
+const parseStream = ({ transportStreamEntry, state, programId, structure, }) => {
+    const { iterator } = state;
     const restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
     if (transportStreamEntry.streamType === 27) {
         return parseAvcStream({
             restOfPacket,
             transportStreamEntry,
-            streamBuffers,
-            nextPesHeader,
             state,
             programId,
             structure,
@@ -102,8 +103,6 @@ const parseStream = ({ iterator, transportStreamEntry, streamBuffers, state, pro
         return parseAdtsStream({
             restOfPacket,
             transportStreamEntry,
-            streamBuffers,
-            nextPesHeader,
             state,
             structure,
             offset: iterator.counter.getOffset(),

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

@@ -0,0 +1,3 @@
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseTransportStream: (state: ParserState) => Promise<ParseResult>;