@remotion/media-parser 4.0.241 → 4.0.242

package/dist/get-duration.d.ts

@@ -7,3 +7,4 @@ export declare const isMatroska: (boxes: AnySegment[]) => {
 } | undefined;
 export declare const getDuration: (structure: Structure, parserState: ParserState) => number | null;
 export declare const hasDuration: (structure: Structure, parserState: ParserState) => boolean;
+export declare const hasSlowDuration: (structure: Structure, parserState: ParserState) => boolean;

package/dist/get-duration.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasDuration = exports.getDuration = exports.isMatroska = void 0;
+exports.hasSlowDuration = exports.hasDuration = exports.getDuration = exports.isMatroska = void 0;
 const get_sample_positions_from_track_1 = require("./boxes/iso-base-media/get-sample-positions-from-track");
 const traversal_1 = require("./boxes/iso-base-media/traversal");
 const traversal_2 = require("./boxes/riff/traversal");
@@ -95,7 +95,20 @@ const getDuration = (structure, parserState) => {
     throw new Error('Has no duration ' + structure);
 };
 exports.getDuration = getDuration;
+// `duration` just grabs from metadata, and otherwise returns null
+// Therefore just checking if we have tracks
 const hasDuration = (structure, parserState) => {
     return (0, get_tracks_1.hasTracks)(structure, parserState);
 };
 exports.hasDuration = hasDuration;
+// `slowDuration` does through everything, and therefore is false
+// Unless it it somewhere in the metadata and is non-null
+const hasSlowDuration = (structure, parserState) => {
+    try {
+        return (0, exports.getDuration)(structure, parserState) !== null;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.hasSlowDuration = hasSlowDuration;

package/dist/get-fields-from-callbacks.js

@@ -20,6 +20,11 @@ const getFieldsFromCallback = ({ fields, callbacks, }) => {
         tracks: Boolean(callbacks.onTracks),
         unrotatedDimensions: Boolean(callbacks.onUnrotatedDimensions),
         videoCodec: Boolean(callbacks.onVideoCodec),
+        slowKeyframes: Boolean(callbacks.onSlowKeyframes),
+        slowDurationInSeconds: Boolean(callbacks.onSlowDurationInSeconds),
+        slowFps: Boolean(callbacks.onSlowFps),
+        slowNumberOfFrames: Boolean(callbacks.onSlowNumberOfFrames),
+        keyframes: Boolean(callbacks.onKeyframes),
         ...fields,
     };
     return newFields;

package/dist/get-fps.d.ts

@@ -9,5 +9,6 @@ export declare const trakBoxContainsVideo: (trakBox: TrakBox) => boolean;
 export declare const getTimescaleAndDuration: (trakBox: TrakBox) => TimescaleAndDuration | null;
 export declare const getFpsFromMp4TrakBox: (trakBox: TrakBox) => number | null;
 export declare const getFps: (segments: Structure) => number | null;
+export declare const hasFpsSuitedForSlowFps: (boxes: Structure) => boolean;
 export declare const hasFps: (boxes: Structure) => boolean;
 export {};

package/dist/get-fps.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasFps = exports.getFps = exports.getFpsFromMp4TrakBox = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = exports.trakBoxContainsAudio = void 0;
+exports.hasFps = exports.hasFpsSuitedForSlowFps = exports.getFps = exports.getFpsFromMp4TrakBox = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = exports.trakBoxContainsAudio = void 0;
 const traversal_1 = require("./boxes/iso-base-media/traversal");
 const traversal_2 = require("./boxes/riff/traversal");
 const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
@@ -93,31 +93,36 @@ const getFps = (segments) => {
     if (segments.type === 'riff') {
         return getFpsFromAvi(segments);
     }
-    // TODO: Matroska doesn't have fps
+    // People need to get it from slowFps
     if (segments.type === 'matroska') {
         return null;
     }
+    // People need to get it from slowFps
     if (segments.type === 'transport-stream') {
         return null;
     }
     throw new Error('Cannot get fps, not implemented');
 };
 exports.getFps = getFps;
-const hasFps = (boxes) => {
+const hasFpsSuitedForSlowFps = (boxes) => {
     try {
-        // Matroska and Transport stream has no FPS metadata
-        // Not bothering to parse
-        // Idea: `guaranteedFps` field
-        if (boxes.type === 'matroska') {
-            return true;
-        }
-        if (boxes.type === 'transport-stream') {
-            return true;
-        }
         return (0, exports.getFps)(boxes) !== null;
     }
     catch (_a) {
         return false;
     }
 };
+exports.hasFpsSuitedForSlowFps = hasFpsSuitedForSlowFps;
+const hasFps = (boxes) => {
+    // Matroska and Transport stream has no FPS metadata
+    // Not bothering to parse
+    // Users should use `slowFps` field
+    if (boxes.type === 'matroska') {
+        return true;
+    }
+    if (boxes.type === 'transport-stream') {
+        return true;
+    }
+    return (0, exports.hasFpsSuitedForSlowFps)(boxes);
+};
 exports.hasFps = hasFps;

package/dist/get-keyframes.d.ts

@@ -0,0 +1,5 @@
+import type { MediaParserKeyframe } from './options';
+import type { Structure } from './parse-result';
+import type { ParserState } from './state/parser-state';
+export declare const getKeyframes: (structure: Structure) => MediaParserKeyframe[] | null;
+export declare const hasKeyframes: (structure: Structure, parserState: ParserState) => boolean;

package/dist/get-keyframes.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasKeyframes = exports.getKeyframes = void 0;
+const get_keyframes_1 = require("./boxes/iso-base-media/get-keyframes");
+const get_tracks_1 = require("./get-tracks");
+const getKeyframes = (structure) => {
+    if (structure.type === 'iso-base-media') {
+        return (0, get_keyframes_1.getKeyframesFromIsoBaseMedia)(structure);
+    }
+    return null;
+};
+exports.getKeyframes = getKeyframes;
+const hasKeyframes = (structure, parserState) => {
+    if (structure.type === 'iso-base-media') {
+        return (0, get_tracks_1.hasTracks)(structure, parserState);
+    }
+    // Has, but will be null
+    return true;
+};
+exports.hasKeyframes = hasKeyframes;

package/dist/get-tracks.d.ts

@@ -2,7 +2,7 @@ import type { MatrixCoefficients, Primaries, TransferCharacteristics } from './b
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import type { AllTracks } from './boxes/riff/get-tracks-from-avi';
-import type { Structure } from './parse-result';
+import type { IsoBaseMediaBox, IsoBaseMediaStructure, Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
 type SampleAspectRatio = {
     numerator: number;
@@ -56,6 +56,12 @@ export type OtherTrack = {
 };
 export type Track = VideoTrack | AudioTrack | OtherTrack;
 export declare const getNumberOfTracks: (moovBox: MoovBox) => number;
+export declare const isoBaseMediaHasTracks: (structure: IsoBaseMediaStructure) => boolean;
 export declare const hasTracks: (structure: Structure, state: ParserState) => boolean;
+export declare const getTracksFromIsoBaseMedia: (segments: IsoBaseMediaBox[]) => {
+    videoTracks: VideoTrack[];
+    audioTracks: AudioTrack[];
+    otherTracks: OtherTrack[];
+};
 export declare const getTracks: (segments: Structure, state: ParserState) => AllTracks;
 export {};

package/dist/get-tracks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTracks = exports.hasTracks = exports.getNumberOfTracks = void 0;
+exports.getTracks = exports.getTracksFromIsoBaseMedia = exports.hasTracks = exports.isoBaseMediaHasTracks = exports.getNumberOfTracks = void 0;
 const make_track_1 = require("./boxes/iso-base-media/make-track");
 const traversal_1 = require("./boxes/iso-base-media/traversal");
 const get_tracks_from_avi_1 = require("./boxes/riff/get-tracks-from-avi");
@@ -15,6 +15,16 @@ const getNumberOfTracks = (moovBox) => {
     return mvHdBox.nextTrackId - 1;
 };
 exports.getNumberOfTracks = getNumberOfTracks;
+const isoBaseMediaHasTracks = (structure) => {
+    const moovBox = (0, traversal_1.getMoovBox)(structure.boxes);
+    if (!moovBox) {
+        return false;
+    }
+    const numberOfTracks = (0, exports.getNumberOfTracks)(moovBox);
+    const tracks = (0, traversal_1.getTraks)(moovBox);
+    return tracks.length === numberOfTracks;
+};
+exports.isoBaseMediaHasTracks = isoBaseMediaHasTracks;
 const hasTracks = (structure, state) => {
     if (structure.type === 'matroska') {
         const mainSegment = (0, traversal_2.getMainSegment)(structure.boxes);
@@ -24,13 +34,7 @@ const hasTracks = (structure, state) => {
         return (0, traversal_2.getTracksSegment)(mainSegment) !== null;
     }
     if (structure.type === 'iso-base-media') {
-        const moovBox = (0, traversal_1.getMoovBox)(structure.boxes);
-        if (!moovBox) {
-            return false;
-        }
-        const numberOfTracks = (0, exports.getNumberOfTracks)(moovBox);
-        const tracks = (0, traversal_1.getTraks)(moovBox);
-        return tracks.length === numberOfTracks;
+        return (0, exports.isoBaseMediaHasTracks)(structure);
     }
     if (structure.type === 'riff') {
         return (0, get_tracks_from_avi_1.hasAllTracksFromAvi)(structure, state);
@@ -49,7 +53,7 @@ const getTracksFromMa = (segments, state) => {
     if (!mainSegment) {
         throw new Error('No main segment found');
     }
-    const matroskaTracks = (0, get_ready_tracks_1.getTracksFromMatroska)(mainSegment, state.getTimescale());
+    const matroskaTracks = (0, get_ready_tracks_1.getTracksFromMatroska)(mainSegment, state.webm.getTimescale());
     for (const track of matroskaTracks) {
         if (track.type === 'video') {
             videoTracks.push(track);
@@ -101,12 +105,13 @@ const getTracksFromIsoBaseMedia = (segments) => {
         otherTracks,
     };
 };
+exports.getTracksFromIsoBaseMedia = getTracksFromIsoBaseMedia;
 const getTracks = (segments, state) => {
     if (segments.type === 'matroska') {
         return getTracksFromMa(segments.boxes, state);
     }
     if (segments.type === 'iso-base-media') {
-        return getTracksFromIsoBaseMedia(segments.boxes);
+        return (0, exports.getTracksFromIsoBaseMedia)(segments.boxes);
     }
     if (segments.type === 'riff') {
         return (0, get_tracks_from_avi_1.getTracksFromAvi)(segments, state);

package/dist/has-all-info.d.ts

@@ -1,13 +1,10 @@
 import type { Options, ParseMediaFields } from './options';
-import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const getAvailableInfo: ({ fieldsToFetch, structure, state, }: {
+export declare const getAvailableInfo: ({ fieldsToFetch, state, }: {
     fieldsToFetch: Options<ParseMediaFields>;
-    structure: Structure | null;
     state: ParserState;
 }) => Record<keyof Options<ParseMediaFields>, boolean>;
-export declare const hasAllInfo: ({ fields, state, structure, }: {
-    structure: Structure | null;
+export declare const hasAllInfo: ({ fields, state, }: {
     fields: Options<ParseMediaFields>;
     state: ParserState;
 }) => boolean;

package/dist/has-all-info.js

@@ -7,10 +7,13 @@ const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
 const get_is_hdr_1 = require("./get-is-hdr");
+const get_keyframes_1 = require("./get-keyframes");
 const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
-const getAvailableInfo = ({ fieldsToFetch, structure, state, }) => {
+const may_skip_video_data_1 = require("./may-skip-video-data/may-skip-video-data");
+const getAvailableInfo = ({ fieldsToFetch, state, }) => {
     const keys = Object.entries(fieldsToFetch).filter(([, value]) => value);
+    const structure = state.structure.getStructureOrNull();
     const infos = keys.map(([_key]) => {
         const key = _key;
         if (key === 'structure') {
@@ -19,6 +22,9 @@ const getAvailableInfo = ({ fieldsToFetch, structure, state, }) => {
         if (key === 'durationInSeconds') {
             return Boolean(structure && (0, get_duration_1.hasDuration)(structure, state));
         }
+        if (key === 'slowDurationInSeconds') {
+            return Boolean(structure && (0, get_duration_1.hasSlowDuration)(structure, state));
+        }
         if (key === 'dimensions' ||
             key === 'rotation' ||
             key === 'unrotatedDimensions') {
@@ -27,6 +33,10 @@ const getAvailableInfo = ({ fieldsToFetch, structure, state, }) => {
         if (key === 'fps') {
             return Boolean(structure && (0, get_fps_1.hasFps)(structure));
         }
+        if (key === 'slowFps') {
+            // In case FPS is available an non-null, it also works for `slowFps`
+            return Boolean(structure && (0, get_fps_1.hasFpsSuitedForSlowFps)(structure));
+        }
         if (key === 'isHdr') {
             return Boolean(structure && (0, get_is_hdr_1.hasHdr)(structure, state));
         }
@@ -39,6 +49,9 @@ const getAvailableInfo = ({ fieldsToFetch, structure, state, }) => {
         if (key === 'tracks') {
             return Boolean(structure && (0, get_tracks_1.hasTracks)(structure, state));
         }
+        if (key === 'keyframes') {
+            return Boolean(structure && (0, get_keyframes_1.hasKeyframes)(structure, state));
+        }
         if (key === 'internalStats') {
             return true;
         }
@@ -57,6 +70,12 @@ const getAvailableInfo = ({ fieldsToFetch, structure, state, }) => {
         if (key === 'metadata' || key === 'location') {
             return false;
         }
+        if (key === 'slowKeyframes') {
+            return false;
+        }
+        if (key === 'slowNumberOfFrames') {
+            return false;
+        }
         throw new Error(`Unknown key: ${key}`);
     });
     const entries = [];
@@ -67,13 +86,13 @@ const getAvailableInfo = ({ fieldsToFetch, structure, state, }) => {
     return Object.fromEntries(entries);
 };
 exports.getAvailableInfo = getAvailableInfo;
-const hasAllInfo = ({ fields, state, structure, }) => {
+const hasAllInfo = ({ fields, state, }) => {
     const availableInfo = (0, exports.getAvailableInfo)({
         fieldsToFetch: fields !== null && fields !== void 0 ? fields : {},
-        structure,
         state,
     });
     return (Object.values(availableInfo).every(Boolean) &&
-        (state.maySkipVideoData() || state.canSkipTracksState.canSkipTracks()));
+        ((0, may_skip_video_data_1.maySkipVideoData)({ state }) ||
+            state.callbacks.canSkipTracksState.canSkipTracks()));
 };
 exports.hasAllInfo = hasAllInfo;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import type { ProgressTracker } from './create/progress-tracker';
 import type { LogLevel } from './log';
 export { IsAGifError, IsAnImageError, IsAnUnsupportedAudioTypeError, IsAnUnsupportedFileTypeError, IsAPdfError, } from './errors';
 export { MetadataEntry } from './metadata/get-metadata';
+export { MediaParserKeyframe } from './options';
 export { WriterInterface } from './writers/writer';
 export { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
 export type { Options, ParseMediaContainer, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, TracksField, } from './options';
@@ -46,7 +47,7 @@ export declare const MediaParserInternals: {
         audioObjectType: number;
         sampleRate: number;
         channelConfiguration: number;
-    }) => Uint8Array<ArrayBuffer>;
+    }) => Uint8Array;
 };
 export type { IoEventEmitter, LogLevel, ProgressTracker };
 export { VERSION } from './version';

package/dist/may-skip-video-data/may-skip-video-data.d.ts

@@ -0,0 +1,4 @@
+import type { ParserState } from '../state/parser-state';
+export declare const maySkipVideoData: ({ state }: {
+    state: ParserState;
+}) => boolean;

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

@@ -0,0 +1,14 @@
+"use strict";
+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() &&
+        Object.values(state.callbacks.videoSampleCallbacks).length === 0 &&
+        Object.values(state.callbacks.audioSampleCallbacks).length === 0 &&
+        !(0, need_samples_for_fields_1.needsToIterateOverSamples)({
+            emittedFields: state.emittedFields,
+            fields: state.fields,
+        }));
+};
+exports.maySkipVideoData = maySkipVideoData;

package/dist/may-skip-video-data/need-samples-for-fields.d.ts

@@ -0,0 +1,5 @@
+import type { AllOptions, Options, ParseMediaFields } from '../options';
+export declare const needsToIterateOverSamples: ({ fields, emittedFields, }: {
+    fields: Options<ParseMediaFields>;
+    emittedFields: AllOptions<ParseMediaFields>;
+}) => boolean;

package/dist/may-skip-video-data/need-samples-for-fields.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.needsToIterateOverSamples = void 0;
+const needsSamples = {
+    slowDurationInSeconds: true,
+    slowFps: true,
+    slowKeyframes: true,
+    slowNumberOfFrames: true,
+    audioCodec: false,
+    container: false,
+    dimensions: false,
+    durationInSeconds: false,
+    fps: false,
+    internalStats: false,
+    isHdr: false,
+    name: false,
+    rotation: false,
+    size: false,
+    structure: false,
+    tracks: false,
+    unrotatedDimensions: false,
+    videoCodec: false,
+    metadata: false,
+    location: false,
+    mimeType: false,
+    keyframes: false,
+};
+const needsToIterateOverSamples = ({ fields, emittedFields, }) => {
+    const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
+    const selectedKeys = keys.filter((k) => fields[k]);
+    return selectedKeys.some((k) => needsSamples[k] && !emittedFields[k]);
+};
+exports.needsToIterateOverSamples = needsToIterateOverSamples;

package/dist/options.d.ts

@@ -11,8 +11,10 @@ export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis
 export type ParseMediaFields = {
     dimensions: boolean;
     durationInSeconds: boolean;
+    slowDurationInSeconds: boolean;
     structure: boolean;
     fps: boolean;
+    slowFps: boolean;
     videoCodec: boolean;
     audioCodec: boolean;
     tracks: boolean;
@@ -26,10 +28,16 @@ export type ParseMediaFields = {
     metadata: boolean;
     location: boolean;
     mimeType: boolean;
+    keyframes: boolean;
+    slowKeyframes: boolean;
+    slowNumberOfFrames: boolean;
 };
 export type AllParseMediaFields = {
     dimensions: true;
     durationInSeconds: true;
+    slowDurationInSeconds: true;
+    slowNumberOfFrames: true;
+    slowFps: true;
     structure: true;
     fps: true;
     videoCodec: true;
@@ -45,10 +53,14 @@ export type AllParseMediaFields = {
     metadata: true;
     location: true;
     mimeType: true;
+    keyframes: true;
+    slowKeyframes: true;
 };
 export type AllOptions<Fields extends ParseMediaFields> = {
     dimensions: Fields['dimensions'];
     durationInSeconds: Fields['durationInSeconds'];
+    slowDurationInSeconds: Fields['slowDurationInSeconds'];
+    slowFps: Fields['slowFps'];
     structure: Fields['structure'];
     fps: Fields['fps'];
     videoCodec: Fields['videoCodec'];
@@ -64,6 +76,9 @@ export type AllOptions<Fields extends ParseMediaFields> = {
     metadata: Fields['metadata'];
     location: Fields['location'];
     mimeType: Fields['mimeType'];
+    keyframes: Fields['keyframes'];
+    slowKeyframes: Fields['slowKeyframes'];
+    slowNumberOfFrames: Fields['slowNumberOfFrames'];
 };
 export type Options<Fields extends ParseMediaFields> = Partial<AllOptions<Fields>>;
 export type TracksField = {
@@ -71,9 +86,18 @@ export type TracksField = {
     audioTracks: AudioTrack[];
 };
 export type ParseMediaContainer = 'mp4' | 'webm' | 'avi' | 'transport-stream';
+export type MediaParserKeyframe = {
+    positionInBytes: number;
+    sizeInBytes: number;
+    presentationTimeInSeconds: number;
+    decodingTimeInSeconds: number;
+    trackId: number;
+};
 export interface ParseMediaCallbacks {
     onDimensions?: (dimensions: Dimensions) => void;
     onDurationInSeconds?: (durationInSeconds: number | null) => void;
+    onSlowDurationInSeconds?: (durationInSeconds: number) => void;
+    onSlowFps?: (fps: number) => void;
     onStructure?: (structure: Structure) => void;
     onFps?: (fps: number | null) => void;
     onVideoCodec?: (codec: MediaParserVideoCodec | null) => void;
@@ -89,10 +113,15 @@ export interface ParseMediaCallbacks {
     onMetadata?: (metadata: MetadataEntry[]) => void;
     onLocation?: (location: MediaParserLocation | null) => void;
     onMimeType?: (mimeType: string | null) => void;
+    onKeyframes?: (keyframes: MediaParserKeyframe[] | null) => void;
+    onSlowKeyframes?: (keyframes: MediaParserKeyframe[]) => void;
+    onSlowNumberOfFrames?: (samples: number) => void;
 }
 export interface ParseMediaData {
     dimensions: Dimensions;
     durationInSeconds: number | null;
+    slowDurationInSeconds: number;
+    slowFps: number;
     structure: Structure;
     fps: number | null;
     videoCodec: MediaParserVideoCodec | null;
@@ -108,6 +137,9 @@ export interface ParseMediaData {
     location: MediaParserLocation | null;
     container: ParseMediaContainer;
     mimeType: string | null;
+    keyframes: MediaParserKeyframe[] | null;
+    slowKeyframes: MediaParserKeyframe[];
+    slowNumberOfFrames: number;
 }
 export type ParseMediaResult<T extends Partial<ParseMediaFields>> = {
     [K in keyof T]: T[K] extends true ? K extends keyof ParseMediaData ? ParseMediaData[K] : never : never;

package/dist/parse-media.js

@@ -17,55 +17,30 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         fields: fieldsInReturnValue,
         callbacks: more,
     });
+    const { reader, contentLength, name, contentType, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
+    const supportsContentRange = readerSupportsContentRange &&
+        !(typeof process !== 'undefined' &&
+            typeof process.env !== 'undefined' &&
+            process.env.DISABLE_CONTENT_RANGE === 'true');
     const state = (0, parser_state_1.makeParserState)({
         hasAudioTrackHandlers: Boolean(onAudioTrack),
         hasVideoTrackHandlers: Boolean(onVideoTrack),
         signal,
         getIterator: () => iterator,
         fields,
-    });
-    const { reader, contentLength, name, contentType, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
-    let currentReader = reader;
-    const emittedFields = {
-        audioCodec: false,
-        container: false,
-        dimensions: false,
-        durationInSeconds: false,
-        fps: false,
-        internalStats: false,
-        isHdr: false,
-        location: false,
-        metadata: false,
-        mimeType: false,
-        name: false,
-        rotation: false,
-        size: false,
-        structure: false,
-        tracks: false,
-        videoCodec: false,
-        unrotatedDimensions: false,
-    };
-    const supportsContentRange = readerSupportsContentRange &&
-        !(typeof process !== 'undefined' &&
-            typeof process.env !== 'undefined' &&
-            process.env.DISABLE_CONTENT_RANGE === 'true');
-    const returnValue = {};
-    const moreFields = more;
-    const options = {
         onAudioTrack: onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : null,
         onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
-        parserState: state,
         nullifySamples: !(typeof process !== 'undefined' &&
             typeof process.env !== 'undefined' &&
             process.env.KEEP_SAMPLES === 'true'),
         supportsContentRange,
-        nextTrackIndex: 0,
-    };
+    });
+    let currentReader = reader;
+    const returnValue = {};
+    const moreFields = more;
     const triggerInfoEmit = () => {
-        var _a;
         const availableInfo = (0, has_all_info_1.getAvailableInfo)({
             fieldsToFetch: fields,
-            structure: (_a = parseResult === null || parseResult === void 0 ? void 0 : parseResult.segments) !== null && _a !== void 0 ? _a : null,
             state,
         });
         (0, emit_available_info_1.emitAvailableInfo)({
@@ -78,7 +53,6 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
             contentLength,
             name,
             mimeType: contentType,
-            emittedFields,
         });
     };
     triggerInfoEmit();
@@ -118,13 +92,13 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         }));
         triggerInfoEmit();
         if (parseResult && parseResult.status === 'incomplete') {
-            log_1.Log.verbose(logLevel, 'Continuing parsing of file, currently at position', iterator.counter.getOffset());
+            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,
-                options,
+                state,
                 signal: signal !== null && signal !== void 0 ? signal : null,
                 logLevel,
                 fields,
@@ -138,7 +112,6 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         }
         if ((0, has_all_info_1.hasAllInfo)({
             fields,
-            structure: parseResult.segments,
             state,
         })) {
             log_1.Log.verbose(logLevel, 'Got all info, skipping to the end.');
@@ -180,11 +153,10 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         contentLength,
         mimeType: contentType,
         name,
-        emittedFields,
     });
     currentReader.abort();
     iterator === null || iterator === void 0 ? void 0 : iterator.destroy();
-    state.tracks.ensureHasTracksAtEnd();
+    state.callbacks.tracks.ensureHasTracksAtEnd();
     return returnValue;
 };
 exports.parseMedia = parseMedia;

package/dist/parse-result.d.ts

@@ -56,14 +56,12 @@ export type TransportStreamStructure = {
     boxes: TransportStreamBox[];
 };
 export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure;
-export type ParseResult<TStructure extends Structure> = {
+export type ParseResult = {
     status: 'done';
-    segments: TStructure;
 } | {
     status: 'incomplete';
-    segments: TStructure;
     skipTo: number | null;
-    continueParsing: () => Promise<ParseResult<TStructure>>;
+    continueParsing: () => Promise<ParseResult>;
 };
 export type MatroskaParseResult = {
     status: 'done';

package/dist/parse-video.d.ts

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