@remotion/media-parser 4.0.249 → 4.0.250

package/dist/file-types/detect-file-type.js

@@ -43,10 +43,12 @@ const isTransportStream = (data) => {
 exports.isTransportStream = isTransportStream;
 const isMp3 = (data) => {
     const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
-    const id3v3Pattern = new Uint8Array([73, 68, 51, 3]);
-    const id3v2Pattern = new Uint8Array([73, 68, 51, 2]);
+    const id3v4Pattern = new Uint8Array([0x49, 0x44, 0x33, 4]);
+    const id3v3Pattern = new Uint8Array([0x49, 0x44, 0x33, 3]);
+    const id3v2Pattern = new Uint8Array([0x49, 0x44, 0x33, 2]);
     const subarray = data.subarray(0, 4);
     return ((0, exports.matchesPattern)(mpegPattern)(subarray) ||
+        (0, exports.matchesPattern)(id3v4Pattern)(subarray) ||
         (0, exports.matchesPattern)(id3v3Pattern)(subarray) ||
         (0, exports.matchesPattern)(id3v2Pattern)(subarray));
 };

package/dist/get-audio-codec.d.ts

@@ -3,7 +3,7 @@ import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import { type MediaParserAudioCodec } from './get-tracks';
 import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const getAudioCodec: (boxes: Structure, parserState: ParserState) => MediaParserAudioCodec | null;
+export declare const getAudioCodec: (parserState: ParserState) => MediaParserAudioCodec | null;
 export declare const hasAudioCodec: (boxes: Structure, state: ParserState) => boolean;
 type AudioCodecInfo = {
     format: string;

package/dist/get-audio-codec.js

@@ -4,8 +4,8 @@ exports.getAudioCodecFromTrack = exports.getAudioCodecStringFromTrak = exports.g
 const traversal_1 = require("./boxes/iso-base-media/traversal");
 const get_fps_1 = require("./get-fps");
 const get_tracks_1 = require("./get-tracks");
-const getAudioCodec = (boxes, parserState) => {
-    const tracks = (0, get_tracks_1.getTracks)(boxes, parserState);
+const getAudioCodec = (parserState) => {
+    const tracks = (0, get_tracks_1.getTracks)(parserState);
     const allTracks = tracks.audioTracks.length +
         tracks.otherTracks.length +
         tracks.videoTracks.length;

package/dist/get-dimensions.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDimensions = exports.getDimensions = void 0;
 const get_tracks_1 = require("./get-tracks");
 const getDimensions = (boxes, state) => {
-    const { videoTracks } = (0, get_tracks_1.getTracks)(boxes, state);
+    const { videoTracks } = (0, get_tracks_1.getTracks)(state);
     if (!videoTracks.length) {
         if (boxes.type === 'mp3') {
             return null;

package/dist/get-duration.js

@@ -51,7 +51,7 @@ const getDurationFromIsoBaseMedia = (structure, parserState) => {
     if (mvhdBox.durationInSeconds > 0) {
         return mvhdBox.durationInSeconds;
     }
-    const tracks = (0, get_tracks_1.getTracks)(structure, parserState);
+    const tracks = (0, get_tracks_1.getTracks)(parserState);
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,

package/dist/get-is-hdr.d.ts

@@ -1,4 +1,4 @@
 import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const getIsHdr: (boxes: Structure, state: ParserState) => boolean;
+export declare const getIsHdr: (state: ParserState) => boolean;
 export declare const hasHdr: (boxes: Structure, state: ParserState) => boolean;

package/dist/get-is-hdr.js

@@ -7,8 +7,8 @@ const isVideoTrackHdr = (track) => {
         track.color.transferCharacteristics === 'arib-std-b67' &&
         track.color.primaries === 'bt2020');
 };
-const getIsHdr = (boxes, state) => {
-    const { videoTracks } = (0, get_tracks_1.getTracks)(boxes, state);
+const getIsHdr = (state) => {
+    const { videoTracks } = (0, get_tracks_1.getTracks)(state);
     return videoTracks.some((track) => isVideoTrackHdr(track));
 };
 exports.getIsHdr = getIsHdr;

package/dist/get-tracks.d.ts

@@ -63,5 +63,5 @@ export declare const getTracksFromIsoBaseMedia: (segments: IsoBaseMediaBox[]) =>
     audioTracks: AudioTrack[];
     otherTracks: OtherTrack[];
 };
-export declare const getTracks: (segments: Structure, state: ParserState) => AllTracks;
+export declare const getTracks: (state: ParserState) => AllTracks;
 export {};

package/dist/get-tracks.js

@@ -38,10 +38,10 @@ const getHasTracks = (structure, state) => {
         return (0, exports.isoBaseMediaHasTracks)(structure);
     }
     if (structure.type === 'riff') {
-        return (0, get_tracks_from_avi_1.hasAllTracksFromAvi)(structure, state);
+        return (0, get_tracks_from_avi_1.hasAllTracksFromAvi)(state);
     }
     if (structure.type === 'transport-stream') {
-        return (0, get_tracks_1.hasAllTracksFromTransportStream)(structure, state);
+        return (0, get_tracks_1.hasAllTracksFromTransportStream)(state);
     }
     if (structure.type === 'mp3') {
         return state.callbacks.tracks.getTracks().length > 0;
@@ -110,22 +110,23 @@ const getTracksFromIsoBaseMedia = (segments) => {
     };
 };
 exports.getTracksFromIsoBaseMedia = getTracksFromIsoBaseMedia;
-const getTracks = (segments, state) => {
-    if (segments.type === 'matroska') {
-        return getTracksFromMa(segments.boxes, state);
+const getTracks = (state) => {
+    const structure = state.structure.getStructure();
+    if (structure.type === 'matroska') {
+        return getTracksFromMa(structure.boxes, state);
     }
-    if (segments.type === 'iso-base-media') {
-        return (0, exports.getTracksFromIsoBaseMedia)(segments.boxes);
+    if (structure.type === 'iso-base-media') {
+        return (0, exports.getTracksFromIsoBaseMedia)(structure.boxes);
     }
-    if (segments.type === 'riff') {
-        return (0, get_tracks_from_avi_1.getTracksFromAvi)(segments, state);
+    if (structure.type === 'riff') {
+        return (0, get_tracks_from_avi_1.getTracksFromAvi)(structure, state);
     }
-    if (segments.type === 'transport-stream') {
-        return (0, get_tracks_1.getTracksFromTransportStream)(segments, state);
+    if (structure.type === 'transport-stream') {
+        return (0, get_tracks_1.getTracksFromTransportStream)(state);
     }
-    if (segments.type === 'mp3') {
+    if (structure.type === 'mp3') {
         return (0, get_tracks_from_mp3_1.getTracksFromMp3)(state);
     }
-    throw new Error(`Unknown container${segments}`);
+    throw new Error(`Unknown container${structure}`);
 };
 exports.getTracks = getTracks;

package/dist/get-video-codec.d.ts

@@ -2,7 +2,7 @@ import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import { type MediaParserVideoCodec, type VideoTrackColorParams } from './get-tracks';
 import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const getVideoCodec: (boxes: Structure, state: ParserState) => MediaParserVideoCodec | null;
+export declare const getVideoCodec: (state: ParserState) => MediaParserVideoCodec | null;
 export declare const hasVideoCodec: (boxes: Structure, state: ParserState) => boolean;
 export declare const getVideoPrivateData: (trakBox: TrakBox) => Uint8Array | null;
 export declare const getIsoBmColrConfig: (trakBox: TrakBox) => VideoTrackColorParams | null;

package/dist/get-video-codec.js

@@ -5,9 +5,9 @@ const color_1 = require("./boxes/avc/color");
 const av1_codec_private_1 = require("./boxes/webm/av1-codec-private");
 const get_sample_aspect_ratio_1 = require("./get-sample-aspect-ratio");
 const get_tracks_1 = require("./get-tracks");
-const getVideoCodec = (boxes, state) => {
+const getVideoCodec = (state) => {
     var _a, _b;
-    const track = (0, get_tracks_1.getTracks)(boxes, state);
+    const track = (0, get_tracks_1.getTracks)(state);
     return (_b = (_a = track.videoTracks[0]) === null || _a === void 0 ? void 0 : _a.codecWithoutConfig) !== null && _b !== void 0 ? _b : null;
 };
 exports.getVideoCodec = getVideoCodec;

package/dist/index.d.ts

@@ -665,7 +665,6 @@ export declare const MediaParserInternals: {
         peekB: (length: number) => void;
         peekD: (length: number) => void;
         getBits: (bits: number) => number;
-        byteLength: () => number;
         bytesRemaining: () => number;
         leb128: () => number;
         removeBytesRead: () => void;
@@ -705,8 +704,6 @@ export declare const MediaParserInternals: {
         getInt32Le: () => number;
         getInt32: () => number;
         destroy: () => void;
-        disallowDiscard: () => void;
-        allowDiscard: () => void;
         startBox: (size: number) => {
             discardRest: () => void;
             expectNoMoreBytes: () => void;
@@ -716,15 +713,13 @@ export declare const MediaParserInternals: {
             returnToCheckpoint: () => void;
         };
     };
-    parseStsd: ({ iterator, offset, size, state, signal, fields, }: {
+    parseStsd: ({ iterator, offset, size, state, }: {
         iterator: import("./buffer-iterator").BufferIterator;
         offset: number;
         size: number;
         state: import("./state/parser-state").ParserState;
-        signal: AbortSignal | null;
-        fields: import("./options").Options<import("./options").ParseMediaFields>;
     }) => Promise<import("./boxes/iso-base-media/stsd/stsd").StsdBox>;
-    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, }: {
+    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }: {
         hasAudioTrackHandlers: boolean;
         hasVideoTrackHandlers: boolean;
         signal: AbortSignal | undefined;
@@ -734,6 +729,7 @@ export declare const MediaParserInternals: {
         onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
         onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
         contentLength: number | null;
+        logLevel: LogLevel;
     }) => {
         riff: {
             getAvcProfile: () => import("./state/parser-state").SpsAndPps | null;
@@ -742,6 +738,38 @@ export declare const MediaParserInternals: {
             getNextTrackIndex: () => number;
             incrementNextTrackIndex: () => void;
         };
+        transportStream: {
+            nextPesHeaderStore: {
+                setNextPesHeader: (pesHeader: import("./boxes/transport-stream/parse-pes").PacketPes) => void;
+                getNextPesHeader: () => import("./boxes/transport-stream/parse-pes").PacketPes;
+            };
+            streamBuffers: Map<number, import("./boxes/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
+        };
+        webm: {
+            onTrackEntrySegment: import("./boxes/webm/segments").OnTrackEntrySegment;
+            getTrackInfoByNumber: (id: number) => import("./boxes/webm/segments/track-entry").TrackInfo;
+            setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+            getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+            timescale: null;
+            getTimescale: () => number;
+            setTimescale: (newTimescale: number) => void;
+            addSegment: (seg: Omit<import("./state/webm").SegmentSection, "index">) => void;
+            addCluster: (cluster: import("./state/webm").ClusterSection) => void;
+            isInsideSegment: (iterator: import("./buffer-iterator").BufferIterator) => import("./state/webm").SegmentSection | null;
+            isInsideCluster: (iterator: import("./buffer-iterator").BufferIterator) => import("./state/webm").ClusterSection | null;
+        };
+        iso: {
+            getShouldReturnToVideoSectionAfterEnd: () => boolean;
+            setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
+            flatSamples: {
+                getSamples: () => import("./state/iso-base-media/cached-sample-positions").FlatSample[] | null;
+                setSamples: (samples: import("./state/iso-base-media/cached-sample-positions").FlatSample[]) => void;
+            };
+        };
+        mp3Info: {
+            getMp3Info: () => import("./state/mp3").Mp3Info | null;
+            setMp3Info: (info: import("./state/mp3").Mp3Info) => void;
+        };
         callbacks: {
             registerVideoSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnVideoSample | null) => Promise<void>;
             onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
@@ -760,6 +788,8 @@ export declare const MediaParserInternals: {
             };
             audioSampleCallbacks: Record<number, import("./webcodec-sample-types").OnAudioSample>;
             videoSampleCallbacks: Record<number, import("./webcodec-sample-types").OnVideoSample>;
+            hasAudioTrackHandlers: boolean;
+            hasVideoTrackHandlers: boolean;
         };
         getInternalStats: () => import("./state/parser-state").InternalStats;
         getSkipBytes: () => number;
@@ -776,15 +806,6 @@ export declare const MediaParserInternals: {
         onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
         onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
         supportsContentRange: boolean;
-        webm: {
-            onTrackEntrySegment: import("./boxes/webm/segments").OnTrackEntrySegment;
-            getTrackInfoByNumber: (id: number) => import("./boxes/webm/segments/track-entry").TrackInfo;
-            setTimestampOffset: (byteOffset: number, timestamp: number) => void;
-            getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
-            timescale: null;
-            getTimescale: () => number;
-            setTimescale: (newTimescale: number) => void;
-        };
         emittedFields: import("./options").AllOptions<import("./options").ParseMediaFields>;
         fields: Partial<import("./options").AllOptions<import("./options").ParseMediaFields>>;
         slowDurationAndFps: {
@@ -794,22 +815,27 @@ export declare const MediaParserInternals: {
             getFps: () => number;
             getSlowNumberOfFrames: () => number;
         };
-        mp3Info: {
-            getMp3Info: () => import("./state/mp3").Mp3Info | null;
-            setMp3Info: (info: import("./state/mp3").Mp3Info) => void;
-        };
         contentLength: number | null;
         images: {
             images: import("./state/images").MediaParserEmbeddedImage[];
             addImage: (image: import("./state/images").MediaParserEmbeddedImage) => void;
         };
+        videoSection: {
+            setVideoSection: (section: {
+                start: number;
+                size: number;
+            }) => void;
+            getVideoSection: () => {
+                start: number;
+                size: number;
+            };
+            isInVideoSectionState: (iterator: import("./buffer-iterator").BufferIterator) => "no-section-defined" | "in-section" | "outside-section";
+        };
+        logLevel: "trace" | "verbose" | "info" | "warn" | "error";
     };
-    processSample: ({ iterator, state: options, signal, logLevel, fields, }: {
+    processSample: ({ iterator, state, }: {
         iterator: import("./buffer-iterator").BufferIterator;
         state: import("./state/parser-state").ParserState;
-        signal: AbortSignal | null;
-        logLevel: LogLevel;
-        fields: import("./options").Options<import("./options").ParseMediaFields>;
     }) => Promise<{
         sample: import("./boxes/iso-base-media/stsd/samples").Sample | null;
     }>;

package/dist/index.js

@@ -29,7 +29,7 @@ exports.MediaParserInternals = {
     getArrayBufferIterator: buffer_iterator_1.getArrayBufferIterator,
     parseStsd: stsd_1.parseStsd,
     makeParserState: parser_state_1.makeParserState,
-    processSample: samples_1.processSample,
+    processSample: samples_1.processIsoFormatBox,
     parseFtyp: ftyp_1.parseFtyp,
     parseEbml: parse_ebml_1.parseEbml,
     parseMvhd: mvhd_1.parseMvhd,

package/dist/may-skip-video-data/may-skip-video-data.js

@@ -3,9 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.maySkipVideoData = void 0;
 const need_samples_for_fields_1 = require("./need-samples-for-fields");
 const maySkipVideoData = ({ state }) => {
-    return (state.callbacks.tracks.hasAllTracks() &&
+    const hasAllTracksAndNoCallbacks = state.callbacks.tracks.hasAllTracks() &&
         Object.values(state.callbacks.videoSampleCallbacks).length === 0 &&
-        Object.values(state.callbacks.audioSampleCallbacks).length === 0 &&
+        Object.values(state.callbacks.audioSampleCallbacks).length === 0;
+    const hasNoTrackHandlers = !state.callbacks.hasAudioTrackHandlers &&
+        !state.callbacks.hasVideoTrackHandlers;
+    const noCallbacksNeeded = hasNoTrackHandlers || hasAllTracksAndNoCallbacks;
+    return (noCallbacksNeeded &&
         !(0, need_samples_for_fields_1.needsToIterateOverSamples)({
             emittedFields: state.emittedFields,
             fields: state.fields,

package/dist/parse-media.js

@@ -20,6 +20,9 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
     });
     const { reader, contentLength, name, contentType, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), contentLength !== null && contentLength !== void 0 ? contentLength : 1000000000);
+    if (contentLength === null) {
+        throw new Error('Media was passed with no content length. This is currently not supported. Ensure the media has a "Content-Length" HTTP header.');
+    }
     const supportsContentRange = readerSupportsContentRange &&
         !(typeof process !== 'undefined' &&
             typeof process.env !== 'undefined' &&
@@ -34,6 +37,7 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
         supportsContentRange,
         contentLength,
+        logLevel,
     });
     let currentReader = reader;
     const returnValue = {};
@@ -72,12 +76,15 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
             }
             return true;
         }
+        if (iterator.counter.getOffset() === contentLength) {
+            log_1.Log.verbose(logLevel, 'Reached end of file');
+            return true;
+        }
         return false;
     };
     triggerInfoEmit();
-    let didProgress = false;
-    while (!checkIfDone() &&
-        (parseResult === null || parseResult.status === 'incomplete')) {
+    let iterationWithThisOffset = 0;
+    while (!checkIfDone()) {
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             throw new Error('Aborted');
         }
@@ -92,7 +99,7 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
             await fetchMoreData();
         }
         const hasBigBuffer = iterator.bytesRemaining() > 100000;
-        if (!didProgress || !hasBigBuffer) {
+        if (iterationWithThisOffset > 0 || !hasBigBuffer) {
             await fetchMoreData();
         }
         (_a = throttledState.update) === null || _a === void 0 ? void 0 : _a.call(throttledState, () => ({
@@ -103,40 +110,48 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
             totalBytes: contentLength,
         }));
         triggerInfoEmit();
-        if (parseResult && parseResult.status === 'incomplete') {
-            log_1.Log.trace(logLevel, 'Continuing parsing of file, currently at position', iterator.counter.getOffset());
-            parseResult = await parseResult.continueParsing();
-        }
-        else {
-            parseResult = await (0, parse_video_1.parseVideo)({
-                iterator,
-                state,
-                signal: signal !== null && signal !== void 0 ? signal : null,
-                logLevel,
-                fields,
-                mimeType: contentType,
-                contentLength,
-                name,
-            });
+        if (iterationWithThisOffset > 300) {
+            throw new Error('Infinite loop detected. The parser is not progressing. This is likely a bug in the parser.');
         }
-        if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
+        log_1.Log.trace(logLevel, `Continuing parsing of file, currently at position ${iterator.counter.getOffset()}/${contentLength}`);
+        parseResult = await (0, parse_video_1.parseVideo)({
+            iterator,
+            state,
+            mimeType: contentType,
+            contentLength,
+            name,
+        });
+        if (parseResult.skipTo !== null) {
             state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
         }
-        if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
-            if (!supportsContentRange) {
-                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-            }
+        if (parseResult.skipTo !== null) {
             if (parseResult.skipTo === contentLength) {
                 log_1.Log.verbose(logLevel, 'Skipped to end of file, not fetching.');
                 break;
             }
-            log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${parseResult.skipTo}`);
-            currentReader.abort();
-            const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
-            currentReader = newReader;
-            iterator.skipTo(parseResult.skipTo, true);
+            const skippingAhead = parseResult.skipTo > iterator.counter.getOffset();
+            if (!skippingAhead && !supportsContentRange) {
+                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
+            }
+            if (skippingAhead &&
+                iterator.counter.getOffset() + iterator.bytesRemaining() >=
+                    parseResult.skipTo) {
+                log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${parseResult.skipTo}. Data already fetched`);
+                iterator.discard(parseResult.skipTo - iterator.counter.getOffset());
+            }
+            else {
+                log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${parseResult.skipTo}. Re-reading because this portion is not available`);
+                currentReader.abort();
+                const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
+                currentReader = newReader;
+                iterator.skipTo(parseResult.skipTo, true);
+            }
+        }
+        const didProgress = iterator.counter.getOffset() > offsetBefore;
+        if (!didProgress) {
+            iterationWithThisOffset++;
         }
-        didProgress = iterator.counter.getOffset() > offsetBefore;
+        iterator.removeBytesRead();
     }
     log_1.Log.verbose(logLevel, 'Finished parsing file');
     // Force assign

package/dist/parse-result.d.ts

@@ -1,7 +1,6 @@
 import type { BaseBox } from './boxes/iso-base-media/base-type';
 import type { EsdsBox } from './boxes/iso-base-media/esds/esds';
 import type { FtypBox } from './boxes/iso-base-media/ftyp';
-import type { MdatBox } from './boxes/iso-base-media/mdat/mdat';
 import type { MdhdBox } from './boxes/iso-base-media/mdhd';
 import type { HdlrBox } from './boxes/iso-base-media/meta/hdlr';
 import type { IlstBox } from './boxes/iso-base-media/meta/ilst';
@@ -38,7 +37,7 @@ export interface RegularBox extends BaseBox {
     offset: number;
     type: 'regular-box';
 }
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox;
 type Mp3Id3Header = {
     type: 'id3-header';
     versionMajor: number;
@@ -71,25 +70,9 @@ export type Mp3Structure = {
 };
 export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure | Mp3Structure;
 export type ParseResult = {
-    status: 'done';
-} | {
-    status: 'incomplete';
     skipTo: number | null;
-    continueParsing: () => Promise<ParseResult>;
 };
 export type MatroskaParseResult = {
-    status: 'done';
-} | {
-    status: 'incomplete';
     skipTo: number | null;
-    continueParsing: () => Promise<MatroskaParseResult>;
-};
-export type ExpectSegmentParseResult = {
-    status: 'done';
-    segment: MatroskaSegment;
-} | {
-    status: 'incomplete';
-    segment: MatroskaSegment | null;
-    continueParsing: () => Promise<ExpectSegmentParseResult>;
 };
 export {};

package/dist/parse-video.d.ts

@@ -1,27 +1,13 @@
 import type { BufferIterator } from './buffer-iterator';
-import { type LogLevel } from './log';
-import type { Options, ParseMediaFields } from './options';
 import type { IsoBaseMediaBox, ParseResult } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export type PartialMdatBox = {
-    type: 'partial-mdat-box';
-    boxSize: number;
-    fileOffset: number;
-};
 export type BoxAndNext = {
-    type: 'complete';
-    box: IsoBaseMediaBox;
-    size: number;
+    box: IsoBaseMediaBox | null;
     skipTo: number | null;
-} | {
-    type: 'incomplete';
-} | PartialMdatBox;
-export declare const parseVideo: ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }: {
+};
+export declare const parseVideo: ({ iterator, state, mimeType, contentLength, name, }: {
     iterator: BufferIterator;
     state: ParserState;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
     mimeType: string | null;
     contentLength: number | null;
     name: string | null;

package/dist/parse-video.js

@@ -3,72 +3,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVideo = void 0;
 const parse_boxes_1 = require("./boxes/iso-base-media/parse-boxes");
 const parse_mp3_1 = require("./boxes/mp3/parse-mp3");
-const parse_box_1 = require("./boxes/riff/parse-box");
-const next_pes_header_store_1 = require("./boxes/transport-stream/next-pes-header-store");
+const parse_riff_1 = require("./boxes/riff/parse-riff");
 const parse_transport_stream_1 = require("./boxes/transport-stream/parse-transport-stream");
 const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
 const errors_1 = require("./errors");
 const log_1 = require("./log");
-const parseVideo = ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }) => {
-    if (iterator.bytesRemaining() === 0) {
-        return Promise.reject(new Error('no bytes'));
-    }
+const initVideo = ({ iterator, state, mimeType, name, contentLength, }) => {
     const fileType = iterator.detectFileType();
     if (fileType.type === 'riff') {
-        log_1.Log.verbose(logLevel, 'Detected RIFF container');
+        log_1.Log.verbose(state.logLevel, 'Detected RIFF container');
         state.structure.setStructure({
             type: 'riff',
             boxes: [],
         });
-        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, state, fields }));
+        return;
     }
     if (fileType.type === 'iso-base-media') {
-        log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
-        const initialBoxes = [];
+        log_1.Log.verbose(state.logLevel, 'Detected ISO Base Media container');
         state.structure.setStructure({
             type: 'iso-base-media',
-            boxes: initialBoxes,
-        });
-        return (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
-            iterator,
-            maxBytes: Infinity,
-            allowIncompleteBoxes: true,
-            initialBoxes,
-            state,
-            signal,
-            logLevel,
-            fields,
+            boxes: [],
         });
+        return;
     }
     if (fileType.type === 'webm') {
-        log_1.Log.verbose(logLevel, 'Detected Matroska container');
+        log_1.Log.verbose(state.logLevel, 'Detected Matroska container');
         state.structure.setStructure({
             boxes: [],
             type: 'matroska',
         });
-        return (0, parse_webm_header_1.parseWebm)({ counter: iterator, state, fields });
+        return;
     }
     if (fileType.type === 'transport-stream') {
-        log_1.Log.verbose(logLevel, 'Detected MPEG-2 Transport Stream');
+        log_1.Log.verbose(state.logLevel, 'Detected MPEG-2 Transport Stream');
         state.structure.setStructure({
             boxes: [],
             type: 'transport-stream',
         });
-        return (0, parse_transport_stream_1.parseTransportStream)({
-            iterator,
-            state,
-            streamBuffers: new Map(),
-            fields,
-            nextPesHeaderStore: (0, next_pes_header_store_1.makeNextPesHeaderStore)(),
-        });
+        return;
     }
     if (fileType.type === 'mp3') {
+        log_1.Log.verbose(state.logLevel, 'Detected MP3');
         const structure = {
             boxes: [],
             type: 'mp3',
         };
         state.structure.setStructure(structure);
-        return (0, parse_mp3_1.parseMp3)({ iterator, structure, state });
+        return;
     }
     if (fileType.type === 'wav') {
         return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
@@ -127,4 +108,36 @@ const parseVideo = ({ iterator, state, signal, logLevel, fields, mimeType, conte
     }
     return Promise.reject(new Error('Unknown video format ' + fileType));
 };
+const parseVideo = async ({ iterator, state, mimeType, contentLength, name, }) => {
+    if (iterator.bytesRemaining() === 0) {
+        return Promise.reject(new Error('no bytes'));
+    }
+    const structure = state.structure.getStructureOrNull();
+    if (structure === null) {
+        await initVideo({ iterator, state, mimeType, name, contentLength });
+        return { skipTo: null };
+    }
+    if (structure.type === 'riff') {
+        return (0, parse_riff_1.parseRiff)({ iterator, state });
+    }
+    if (structure.type === 'mp3') {
+        return (0, parse_mp3_1.parseMp3)({ iterator, state });
+    }
+    if (structure.type === 'iso-base-media') {
+        return (0, parse_boxes_1.parseIsoBaseMedia)({
+            iterator,
+            state,
+        });
+    }
+    if (structure.type === 'matroska') {
+        return (0, parse_webm_header_1.parseWebm)({ iterator, state });
+    }
+    if (structure.type === 'transport-stream') {
+        return (0, parse_transport_stream_1.parseTransportStream)({
+            iterator,
+            state,
+        });
+    }
+    return Promise.reject(new Error('Unknown video format ' + structure));
+};
 exports.parseVideo = parseVideo;