@remotion/media-parser 4.0.248 → 4.0.250

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

@@ -43,10 +43,14 @@ const isTransportStream = (data) => {
 exports.isTransportStream = isTransportStream;
 const isMp3 = (data) => {
     const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
-    const id3Pattern = new Uint8Array([73, 68, 51, 3]);
+    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)(id3Pattern)(subarray));
+        (0, exports.matchesPattern)(id3v4Pattern)(subarray) ||
+        (0, exports.matchesPattern)(id3v3Pattern)(subarray) ||
+        (0, exports.matchesPattern)(id3v2Pattern)(subarray));
 };
 exports.isMp3 = isMp3;
 const isGif = (data) => {

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;
@@ -23,7 +23,7 @@ const getAudioCodec = (boxes, parserState) => {
 };
 exports.getAudioCodec = getAudioCodec;
 const hasAudioCodec = (boxes, state) => {
-    return (0, get_tracks_1.hasTracks)(boxes, state);
+    return (0, get_tracks_1.getHasTracks)(boxes, state);
 };
 exports.hasAudioCodec = hasAudioCodec;
 const getCodecSpecificatorFromEsdsBox = ({ child, }) => {

package/dist/get-container.js

@@ -12,12 +12,16 @@ const getContainer = (segments) => {
     if (segments.type === 'transport-stream') {
         return 'transport-stream';
     }
+    if (segments.type === 'mp3') {
+        return 'mp3';
+    }
     if (segments.type === 'riff') {
         if ((0, traversal_1.isRiffAvi)(segments)) {
             return 'avi';
         }
+        throw new Error('Unknown RIFF container ' + segments.type);
     }
-    throw new Error('Unknown container');
+    throw new Error('Unknown container ' + segments);
 };
 exports.getContainer = getContainer;
 const hasContainer = (boxes) => {

package/dist/get-dimensions.d.ts

@@ -9,5 +9,5 @@ export type ExpandedDimensions = Dimensions & {
     unrotatedWidth: number;
     unrotatedHeight: number;
 };
-export declare const getDimensions: (boxes: Structure, state: ParserState) => ExpandedDimensions;
+export declare const getDimensions: (boxes: Structure, state: ParserState) => ExpandedDimensions | null;
 export declare const hasDimensions: (boxes: Structure, state: ParserState) => boolean;

package/dist/get-dimensions.js

@@ -3,8 +3,11 @@ 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;
+        }
         throw new Error('Expected video track');
     }
     const firstVideoTrack = videoTracks[0];

package/dist/get-duration.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 get_duration_1 = require("./boxes/mp3/get-duration");
 const traversal_2 = require("./boxes/riff/traversal");
 const get_tracks_1 = require("./get-tracks");
 const getDurationFromMatroska = (segments) => {
@@ -50,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,
@@ -92,13 +93,16 @@ const getDuration = (structure, parserState) => {
     if (structure.type === 'transport-stream') {
         return null;
     }
+    if (structure.type === 'mp3') {
+        return (0, get_duration_1.getDurationFromMp3)(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);
+    return (0, get_tracks_1.getHasTracks)(structure, parserState);
 };
 exports.hasDuration = hasDuration;
 // `slowDuration` does through everything, and therefore is false

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

@@ -25,6 +25,7 @@ const getFieldsFromCallback = ({ fields, callbacks, }) => {
         slowFps: Boolean(callbacks.onSlowFps),
         slowNumberOfFrames: Boolean(callbacks.onSlowNumberOfFrames),
         keyframes: Boolean(callbacks.onKeyframes),
+        images: Boolean(callbacks.onImages),
         ...fields,
     };
     return newFields;

package/dist/get-fps.js

@@ -101,6 +101,9 @@ const getFps = (segments) => {
     if (segments.type === 'transport-stream') {
         return null;
     }
+    if (segments.type === 'mp3') {
+        return null;
+    }
     throw new Error('Cannot get fps, not implemented');
 };
 exports.getFps = getFps;

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,12 +7,12 @@ 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;
 const hasHdr = (boxes, state) => {
-    return (0, get_tracks_1.hasTracks)(boxes, state);
+    return (0, get_tracks_1.getHasTracks)(boxes, state);
 };
 exports.hasHdr = hasHdr;

package/dist/get-keyframes.js

@@ -12,7 +12,7 @@ const getKeyframes = (structure) => {
 exports.getKeyframes = getKeyframes;
 const hasKeyframes = (structure, parserState) => {
     if (structure.type === 'iso-base-media') {
-        return (0, get_tracks_1.hasTracks)(structure, parserState);
+        return (0, get_tracks_1.getHasTracks)(structure, parserState);
     }
     // Has, but will be null
     return true;

package/dist/get-tracks.d.ts

@@ -57,11 +57,11 @@ 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 getHasTracks: (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 declare const getTracks: (state: ParserState) => AllTracks;
 export {};

package/dist/get-tracks.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTracks = exports.getTracksFromIsoBaseMedia = exports.hasTracks = exports.isoBaseMediaHasTracks = exports.getNumberOfTracks = void 0;
+exports.getTracks = exports.getTracksFromIsoBaseMedia = exports.getHasTracks = 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_mp3_1 = require("./boxes/mp3/get-tracks-from-mp3");
 const get_tracks_from_avi_1 = require("./boxes/riff/get-tracks-from-avi");
 const get_tracks_1 = require("./boxes/transport-stream/get-tracks");
 const get_ready_tracks_1 = require("./boxes/webm/get-ready-tracks");
@@ -25,7 +26,7 @@ const isoBaseMediaHasTracks = (structure) => {
     return tracks.length === numberOfTracks;
 };
 exports.isoBaseMediaHasTracks = isoBaseMediaHasTracks;
-const hasTracks = (structure, state) => {
+const getHasTracks = (structure, state) => {
     if (structure.type === 'matroska') {
         const mainSegment = (0, traversal_2.getMainSegment)(structure.boxes);
         if (!mainSegment) {
@@ -37,14 +38,17 @@ const hasTracks = (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;
     }
     throw new Error('Unknown container ' + structure);
 };
-exports.hasTracks = hasTracks;
+exports.getHasTracks = getHasTracks;
 const getTracksFromMa = (segments, state) => {
     const videoTracks = [];
     const audioTracks = [];
@@ -106,19 +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 (structure.type === 'iso-base-media') {
+        return (0, exports.getTracksFromIsoBaseMedia)(structure.boxes);
     }
-    if (segments.type === 'iso-base-media') {
-        return (0, exports.getTracksFromIsoBaseMedia)(segments.boxes);
+    if (structure.type === 'riff') {
+        return (0, get_tracks_from_avi_1.getTracksFromAvi)(structure, state);
     }
-    if (segments.type === 'riff') {
-        return (0, get_tracks_from_avi_1.getTracksFromAvi)(segments, state);
+    if (structure.type === 'transport-stream') {
+        return (0, get_tracks_1.getTracksFromTransportStream)(state);
     }
-    if (segments.type === 'transport-stream') {
-        return (0, get_tracks_1.getTracksFromTransportStream)(segments, state);
+    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,14 +5,14 @@ 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;
 const hasVideoCodec = (boxes, state) => {
-    return (0, get_tracks_1.hasTracks)(boxes, state);
+    return (0, get_tracks_1.getHasTracks)(boxes, state);
 };
 exports.hasVideoCodec = hasVideoCodec;
 const getVideoPrivateData = (trakBox) => {

package/dist/has-all-info.js

@@ -11,6 +11,7 @@ const get_keyframes_1 = require("./get-keyframes");
 const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
 const may_skip_video_data_1 = require("./may-skip-video-data/may-skip-video-data");
+const get_metadata_1 = require("./metadata/get-metadata");
 const getAvailableInfo = ({ fieldsToFetch, state, }) => {
     const keys = Object.entries(fieldsToFetch).filter(([, value]) => value);
     const structure = state.structure.getStructureOrNull();
@@ -47,7 +48,7 @@ const getAvailableInfo = ({ fieldsToFetch, state, }) => {
             return Boolean(structure && (0, get_audio_codec_1.hasAudioCodec)(structure, state));
         }
         if (key === 'tracks') {
-            return Boolean(structure && (0, get_tracks_1.hasTracks)(structure, state));
+            return Boolean(structure && (0, get_tracks_1.getHasTracks)(structure, state));
         }
         if (key === 'keyframes') {
             return Boolean(structure && (0, get_keyframes_1.hasKeyframes)(structure, state));
@@ -67,8 +68,8 @@ const getAvailableInfo = ({ fieldsToFetch, state, }) => {
         if (key === 'container') {
             return Boolean(structure && (0, get_container_1.hasContainer)(structure));
         }
-        if (key === 'metadata' || key === 'location') {
-            return false;
+        if (key === 'metadata' || key === 'location' || key === 'images') {
+            return Boolean(structure && (0, get_metadata_1.hasMetadata)(structure));
         }
         if (key === 'slowKeyframes') {
             return false;

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export { IsAGifError, IsAnImageError, IsAnUnsupportedAudioTypeError, IsAnUnsuppo
 export type { SamplePosition } from './get-sample-positions';
 export { MetadataEntry } from './metadata/get-metadata';
 export { MediaParserKeyframe } from './options';
+export type { MediaParserEmbeddedImage } from './state/images';
 export { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
 export type { Options, ParseMediaContainer, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, TracksField, } from './options';
 export { parseMedia } from './parse-media';
@@ -664,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;
@@ -694,6 +694,9 @@ export declare const MediaParserInternals: {
         getPascalString: () => number[];
         getUint(length: number): number;
         getByteString(length: number, trimTrailingZeroes: boolean): string;
+        planBytes: (size: number) => {
+            discardRest: () => Uint8Array;
+        };
         getFloat64: () => number;
         readUntilNullTerminator: () => string;
         getFloat32: () => number;
@@ -701,23 +704,22 @@ export declare const MediaParserInternals: {
         getInt32Le: () => number;
         getInt32: () => number;
         destroy: () => void;
-        disallowDiscard: () => void;
-        allowDiscard: () => void;
         startBox: (size: number) => {
             discardRest: () => void;
             expectNoMoreBytes: () => void;
         };
         readExpGolomb: () => number;
+        startCheckpoint: () => {
+            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, }: {
+    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }: {
         hasAudioTrackHandlers: boolean;
         hasVideoTrackHandlers: boolean;
         signal: AbortSignal | undefined;
@@ -726,6 +728,8 @@ export declare const MediaParserInternals: {
         supportsContentRange: boolean;
         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;
@@ -734,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>;
@@ -752,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;
@@ -768,30 +806,36 @@ 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: {
-            addSample: (videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
+            addVideoSample: (videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
+            addAudioSample: (audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
             getSlowDurationInSeconds: () => number;
             getFps: () => number;
             getSlowNumberOfFrames: () => number;
         };
+        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/may-skip-video-data/need-samples-for-fields.js

@@ -24,6 +24,7 @@ const needsSamples = {
     location: false,
     mimeType: false,
     keyframes: false,
+    images: false,
 };
 const needsToIterateOverSamples = ({ fields, emittedFields, }) => {
     const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});

package/dist/metadata/get-metadata.d.ts

@@ -5,3 +5,4 @@ export type MetadataEntry = {
     trackId: number | null;
 };
 export declare const getMetadata: (structure: Structure) => MetadataEntry[];
+export declare const hasMetadata: (structure: Structure) => boolean;

package/dist/metadata/get-metadata.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMetadata = void 0;
+exports.hasMetadata = exports.getMetadata = void 0;
+const get_metadata_from_mp3_1 = require("../boxes/mp3/get-metadata-from-mp3");
 const metadata_from_iso_1 = require("./metadata-from-iso");
 const metadata_from_matroska_1 = require("./metadata-from-matroska");
 const metadata_from_riff_1 = require("./metadata-from-riff");
@@ -14,6 +15,20 @@ const getMetadata = (structure) => {
     if (structure.type === 'transport-stream') {
         return [];
     }
+    if (structure.type === 'mp3') {
+        const tags = (0, get_metadata_from_mp3_1.getMetadataFromMp3)(structure);
+        if (tags === null) {
+            throw new Error('Failed to get metadata from mp3');
+        }
+        return tags;
+    }
     return (0, metadata_from_iso_1.getMetadataFromIsoBase)(structure);
 };
 exports.getMetadata = getMetadata;
+const hasMetadata = (structure) => {
+    if (structure.type === 'mp3') {
+        return (0, get_metadata_from_mp3_1.getMetadataFromMp3)(structure) !== null;
+    }
+    return false;
+};
+exports.hasMetadata = hasMetadata;