@remotion/media-parser 4.0.298 → 4.0.300

package/dist/get-tracks.js

@@ -60,55 +60,23 @@ const getHasTracks = (state, mayUsePrecomputed) => {
 };
 exports.getHasTracks = getHasTracks;
 const getCategorizedTracksFromMatroska = (state) => {
-    const videoTracks = [];
-    const audioTracks = [];
-    const otherTracks = [];
     const { resolved } = (0, get_ready_tracks_1.getTracksFromMatroska)({
         structureState: state.structure,
         webmState: state.webm,
     });
-    for (const track of resolved) {
-        if (track.type === 'video') {
-            videoTracks.push(track);
-        }
-        else if (track.type === 'audio') {
-            audioTracks.push(track);
-        }
-        else if (track.type === 'other') {
-            otherTracks.push(track);
-        }
-    }
-    return {
-        videoTracks,
-        audioTracks,
-        otherTracks,
-    };
+    return resolved;
 };
 const getTracksFromMoovBox = (moovBox) => {
-    const videoTracks = [];
-    const audioTracks = [];
-    const otherTracks = [];
+    const mediaParserTracks = [];
     const tracks = (0, traversal_1.getTraks)(moovBox);
     for (const trakBox of tracks) {
         const track = (0, make_track_1.makeBaseMediaTrack)(trakBox);
         if (!track) {
             continue;
         }
-        if (track.type === 'video') {
-            videoTracks.push(track);
-        }
-        else if (track.type === 'audio') {
-            audioTracks.push(track);
-        }
-        else if (track.type === 'other') {
-            otherTracks.push(track);
-        }
+        mediaParserTracks.push(track);
     }
-    return {
-        videoTracks,
-        audioTracks,
-        otherTracks,
-    };
+    return mediaParserTracks;
 };
 exports.getTracksFromMoovBox = getTracksFromMoovBox;
 const getTracksFromIsoBaseMedia = ({ mayUsePrecomputed, structure, isoState, m3uPlaylistContext, }) => {
@@ -120,11 +88,7 @@ const getTracksFromIsoBaseMedia = ({ mayUsePrecomputed, structure, isoState, m3u
         mayUsePrecomputed,
     });
     if (!moovBox) {
-        return {
-            videoTracks: [],
-            audioTracks: [],
-            otherTracks: [],
-        };
+        return [];
     }
     return (0, exports.getTracksFromMoovBox)(moovBox);
 };
@@ -134,11 +98,7 @@ const defaultGetTracks = (parserState) => {
     if (tracks.length === 0) {
         throw new Error('No tracks found');
     }
-    return {
-        audioTracks: tracks.filter((t) => t.type === 'audio'),
-        otherTracks: [],
-        videoTracks: tracks.filter((t) => t.type === 'video'),
-    };
+    return tracks;
 };
 exports.defaultGetTracks = defaultGetTracks;
 const defaultHasallTracks = (parserState) => {

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

@@ -1,8 +1,9 @@
+import type { MediaParserCodecData } from './codec-data';
 import type { TrakBox } from './containers/iso-base-media/trak/trak';
-import { type MediaParserVideoCodec, type VideoTrackColorParams } from './get-tracks';
+import { type MediaParserAdvancedColor, type MediaParserVideoCodec } from './get-tracks';
 import type { ParserState } from './state/parser-state';
 export declare const getVideoCodec: (state: ParserState) => MediaParserVideoCodec | null;
 export declare const hasVideoCodec: (state: ParserState) => boolean;
-export declare const getVideoPrivateData: (trakBox: TrakBox) => Uint8Array | null;
-export declare const getIsoBmColrConfig: (trakBox: TrakBox) => VideoTrackColorParams | null;
+export declare const getVideoPrivateData: (trakBox: TrakBox) => MediaParserCodecData | null;
+export declare const getIsoBmColrConfig: (trakBox: TrakBox) => MediaParserAdvancedColor | null;
 export declare const getVideoCodecString: (trakBox: TrakBox) => string | null;

package/dist/get-video-codec.js

@@ -8,7 +8,7 @@ const get_tracks_1 = require("./get-tracks");
 const getVideoCodec = (state) => {
     var _a, _b;
     const track = (0, get_tracks_1.getTracks)(state, true);
-    return (_b = (_a = track.videoTracks[0]) === null || _a === void 0 ? void 0 : _a.codecWithoutConfig) !== null && _b !== void 0 ? _b : null;
+    return (_b = (_a = track.find((t) => t.type === 'video')) === null || _a === void 0 ? void 0 : _a.codecEnum) !== null && _b !== void 0 ? _b : null;
 };
 exports.getVideoCodec = getVideoCodec;
 const hasVideoCodec = (state) => {
@@ -24,13 +24,13 @@ const getVideoPrivateData = (trakBox) => {
         return null;
     }
     if (avccBox) {
-        return avccBox.privateData;
+        return { type: 'avc-sps-pps', data: avccBox.privateData };
     }
     if (hvccBox) {
-        return hvccBox.privateData;
+        return { type: 'hvcc-data', data: hvccBox.privateData };
     }
     if (av1cBox) {
-        return av1cBox.privateData;
+        return { type: 'av1c-data', data: av1cBox.privateData };
     }
     return null;
 };
@@ -51,9 +51,9 @@ const getIsoBmColrConfig = (trakBox) => {
     // https://github.com/bbc/qtff-parameter-editor
     return {
         fullRange: colrAtom.fullRangeFlag,
-        matrixCoefficients: (0, color_1.getMatrixCoefficientsFromIndex)(colrAtom.matrixIndex),
+        matrix: (0, color_1.getMatrixCoefficientsFromIndex)(colrAtom.matrixIndex),
         primaries: (0, color_1.getPrimariesFromIndex)(colrAtom.primaries),
-        transferCharacteristics: (0, color_1.getTransferCharacteristicsFromIndex)(colrAtom.transfer),
+        transfer: (0, color_1.getTransferCharacteristicsFromIndex)(colrAtom.transfer),
     };
 };
 exports.getIsoBmColrConfig = getIsoBmColrConfig;

package/dist/has-all-info.js

@@ -20,7 +20,7 @@ const getAvailableInfo = ({ state, }) => {
     const structure = state.structure.getStructureOrNull();
     const infos = keys.map(([_key]) => {
         const key = _key;
-        if (key === 'structure') {
+        if (key === 'slowStructure') {
             return false;
         }
         if (key === 'durationInSeconds') {

package/dist/index.d.ts

@@ -1,27 +1,36 @@
-import type { LogLevel } from './log';
-export type { MatroskaSegment } from './containers/webm/segments';
-export type { MatroskaElement } from './containers/webm/segments/all-segments';
-export { hasBeenAborted, IsAGifError, IsAnImageError, IsAnUnsupportedFileTypeError, IsAPdfError, MediaParserAbortError, } from './errors';
-export type { SamplePosition } from './get-sample-positions';
-export type { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
+import type { MatroskaSegment } from './containers/webm/segments';
+import type { Ebml, EbmlValue, FloatWithSize, MainSegment, MatroskaElement, PossibleEbml, TrackEntry, UintWithSize } from './containers/webm/segments/all-segments';
+import type { SamplePosition } from './get-sample-positions';
+import type { MediaParserLogLevel } from './log';
+import type { ParseMediaCallbacks } from './options';
+export { parseMedia } from './parse-media';
+export { hasBeenAborted, IsAnImageError, IsAnUnsupportedFileTypeError, IsAPdfError, MediaParserAbortError, } from './errors';
+export type { MediaParserAdvancedColor, MediaParserAudioCodec, MediaParserAudioTrack, MediaParserOtherTrack, MediaParserTrack, MediaParserVideoCodec, MediaParserVideoTrack, } from './get-tracks';
+export type { MediaParserMatrixCoefficients, MediaParserPrimaries, MediaParserTransferCharacteristics, } from './containers/avc/color';
 export type { MediaParserMetadataEntry } from './metadata/get-metadata';
 export type { MediaParserKeyframe, ParseMediaSrc } from './options';
 export type { MediaParserEmbeddedImage } from './state/images';
 export { downloadAndParseMedia } from './download-and-parse-media';
 export type { Options, ParseMediaFields } from './fields';
-export type { MediaParserContainer, MediaParserTracks, ParseMediaCallbacks, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, } from './options';
-export { parseMedia } from './parse-media';
-export type { AudioOrVideoSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, } from './webcodec-sample-types';
-export type { Dimensions } from './get-dimensions';
+export type { MediaParserContainer, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, } from './options';
+export type { MediaParserAudioSample, MediaParserOnAudioSample, MediaParserOnAudioTrack, MediaParserOnAudioTrackParams, MediaParserOnVideoSample, MediaParserOnVideoTrack, MediaParserOnVideoTrackParams, MediaParserVideoSample, } from './webcodec-sample-types';
+export type { MediaParserCodecData } from './codec-data';
+export type { MediaParserDimensions } from './get-dimensions';
 export type { MediaParserLocation } from './get-location';
-export type { ReaderInterface } from './readers/reader';
-export type { CreateContent, Writer, WriterInterface } from './writers/writer';
+/**
+ * @deprecated This type is not stable.
+ */
+export type { MediaParserReaderInterface } from './readers/reader';
+import type { CreateContent, Writer, WriterInterface } from './writers/writer';
+/**
+ * @deprecated Dont use these yet.
+ */
 export declare const MediaParserInternals: {
     Log: {
-        trace: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-        verbose: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-        info: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-        warn: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
+        trace: (logLevel: MediaParserLogLevel, message?: any, ...optionalParams: any[]) => void;
+        verbose: (logLevel: MediaParserLogLevel, message?: any, ...optionalParams: any[]) => void;
+        info: (logLevel: MediaParserLogLevel, message?: any, ...optionalParams: any[]) => void;
+        warn: (logLevel: MediaParserLogLevel, message?: any, ...optionalParams: any[]) => void;
         error: (message?: any, ...optionalParams: any[]) => void;
     };
     createAacCodecPrivate: ({ audioObjectType, sampleRate, channelConfiguration, codecPrivate, }: {
@@ -736,27 +745,27 @@ export declare const MediaParserInternals: {
         offset: number;
         size: number;
         iterator: import("./iterator/buffer-iterator").BufferIterator;
-        logLevel: LogLevel;
+        logLevel: MediaParserLogLevel;
         contentLength: number;
     }) => Promise<import("./containers/iso-base-media/stsd/stsd").StsdBox>;
     makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, m3uPlaylistContext, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, prefetchCache, }: {
         hasAudioTrackHandlers: boolean;
         hasVideoTrackHandlers: boolean;
         controller: import("./controller/media-parser-controller").MediaParserController;
-        onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
-        onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
+        onAudioTrack: import("./webcodec-sample-types").MediaParserOnAudioTrack | null;
+        onVideoTrack: import("./webcodec-sample-types").MediaParserOnVideoTrack | null;
         contentLength: number;
-        logLevel: LogLevel;
+        logLevel: MediaParserLogLevel;
         mode: import("./options").ParseMediaMode;
         src: import("./options").ParseMediaSrc;
-        readerInterface: import("./readers/reader").ReaderInterface;
+        readerInterface: import("./readers/reader").MediaParserReaderInterface;
         onDiscardedData: import("./options").OnDiscardedData | null;
         selectM3uStreamFn: import("./containers/m3u/select-stream").SelectM3uStreamFn;
         selectM3uAssociatedPlaylistsFn: import("./containers/m3u/select-stream").SelectM3uAssociatedPlaylistsFn;
         m3uPlaylistContext: import("./options").M3uPlaylistContext | null;
         contentType: string | null;
         name: string;
-        callbacks: import("./options").ParseMediaCallbacks;
+        callbacks: ParseMediaCallbacks;
         fieldsInReturnValue: import("./fields").Options<import("./fields").ParseMediaFields>;
         mimeType: string | null;
         initialReaderInstance: import("./readers/reader").Reader;
@@ -789,8 +798,8 @@ export declare const MediaParserInternals: {
                 }> | Promise<null>;
             };
             sampleCounter: {
-                onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
-                onVideoSample: (trackId: number, videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
+                onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").MediaParserAudioSample) => void;
+                onVideoSample: (trackId: number, videoSample: import("./webcodec-sample-types").MediaParserVideoSample) => void;
                 getSamplesForTrack: (trackId: number) => number;
                 setSamplesFromSeek: (samples: Record<number, number>) => void;
                 riffKeys: {
@@ -822,8 +831,8 @@ export declare const MediaParserInternals: {
             };
             resetBeforeSeek: () => void;
             lastEmittedSample: {
-                setLastEmittedSample: (sample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
-                getLastEmittedSample: () => import("./webcodec-sample-types").AudioOrVideoSample | null;
+                setLastEmittedSample: (sample: import("./webcodec-sample-types").MediaParserAudioSample | import("./webcodec-sample-types").MediaParserVideoSample) => void;
+                getLastEmittedSample: () => import("./webcodec-sample-types").MediaParserAudioSample | import("./webcodec-sample-types").MediaParserVideoSample | null;
                 resetLastEmittedSample: () => void;
             };
         };
@@ -930,10 +939,10 @@ export declare const MediaParserInternals: {
         m3u: {
             setSelectedMainPlaylist: (stream: import("./state/m3u-state").M3uStreamOrInitialUrl) => void;
             getSelectedMainPlaylist: () => import("./state/m3u-state").M3uStreamOrInitialUrl | null;
-            setHasEmittedVideoTrack: (src: string, callback: import("./webcodec-sample-types").OnVideoSample | null) => void;
-            hasEmittedVideoTrack: (src: string) => false | import("./webcodec-sample-types").OnVideoSample | null;
-            setHasEmittedAudioTrack: (src: string, callback: import("./webcodec-sample-types").OnAudioSample | null) => void;
-            hasEmittedAudioTrack: (src: string) => false | import("./webcodec-sample-types").OnAudioSample | null;
+            setHasEmittedVideoTrack: (src: string, callback: import("./webcodec-sample-types").MediaParserOnVideoSample | null) => void;
+            hasEmittedVideoTrack: (src: string) => false | import("./webcodec-sample-types").MediaParserOnVideoSample | null;
+            setHasEmittedAudioTrack: (src: string, callback: import("./webcodec-sample-types").MediaParserOnAudioSample | null) => void;
+            hasEmittedAudioTrack: (src: string) => false | import("./webcodec-sample-types").MediaParserOnAudioSample | null;
             setHasEmittedDoneWithTracks: (src: string) => void;
             hasEmittedDoneWithTracks: (src: string) => boolean;
             setReadyToIterateOverM3u: () => void;
@@ -956,12 +965,12 @@ export declare const MediaParserInternals: {
             sampleSorter: {
                 clearSamples: () => void;
                 addToStreamWithTrack: (src: string) => void;
-                addVideoStreamToConsider: (src: string, callback: import("./webcodec-sample-types").OnVideoSample) => void;
-                addAudioStreamToConsider: (src: string, callback: import("./webcodec-sample-types").OnAudioSample) => void;
+                addVideoStreamToConsider: (src: string, callback: import("./webcodec-sample-types").MediaParserOnVideoSample) => void;
+                addAudioStreamToConsider: (src: string, callback: import("./webcodec-sample-types").MediaParserOnAudioSample) => void;
                 hasAudioStreamToConsider: (src: string) => boolean;
                 hasVideoStreamToConsider: (src: string) => boolean;
-                addAudioSample: (src: string, sample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
-                addVideoSample: (src: string, sample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
+                addAudioSample: (src: string, sample: import("./webcodec-sample-types").MediaParserAudioSample) => Promise<void>;
+                addVideoSample: (src: string, sample: import("./webcodec-sample-types").MediaParserVideoSample) => Promise<void>;
                 getNextStreamToRun: (streams: string[]) => string;
             };
             setMp4HeaderSegment: (playlistUrl: string, structure: import("./parse-result").IsoBaseMediaStructure) => void;
@@ -983,24 +992,24 @@ export declare const MediaParserInternals: {
             timeFreeingData: number;
         };
         callbacks: {
-            registerVideoSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnVideoSample | null) => Promise<void>;
-            onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
-            onVideoSample: (trackId: number, videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
+            registerVideoSampleCallback: (id: number, callback: import("./webcodec-sample-types").MediaParserOnVideoSample | null) => Promise<void>;
+            onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").MediaParserAudioSample) => Promise<void>;
+            onVideoSample: (trackId: number, videoSample: import("./webcodec-sample-types").MediaParserVideoSample) => Promise<void>;
             canSkipTracksState: {
                 doFieldsNeedTracks: () => boolean;
                 canSkipTracks: () => boolean;
             };
-            registerAudioSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnAudioSample | null) => Promise<void>;
+            registerAudioSampleCallback: (id: number, callback: import("./webcodec-sample-types").MediaParserOnAudioSample | null) => Promise<void>;
             tracks: {
                 hasAllTracks: () => boolean;
                 getIsDone: () => boolean;
-                setIsDone: (logLevel: LogLevel) => void;
-                addTrack: (track: import("./get-tracks").Track) => void;
-                getTracks: () => import("./get-tracks").Track[];
+                setIsDone: (logLevel: MediaParserLogLevel) => void;
+                addTrack: (track: import("./get-tracks").MediaParserTrack) => void;
+                getTracks: () => import("./get-tracks").MediaParserTrack[];
                 ensureHasTracksAtEnd: (fields: import("./fields").Options<import("./fields").ParseMediaFields>) => void;
             };
-            audioSampleCallbacks: Record<number, import("./webcodec-sample-types").OnAudioSample>;
-            videoSampleCallbacks: Record<number, import("./webcodec-sample-types").OnVideoSample>;
+            audioSampleCallbacks: Record<number, import("./webcodec-sample-types").MediaParserOnAudioSample>;
+            videoSampleCallbacks: Record<number, import("./webcodec-sample-types").MediaParserOnVideoSample>;
             hasAudioTrackHandlers: boolean;
             hasVideoTrackHandlers: boolean;
         };
@@ -1025,13 +1034,13 @@ export declare const MediaParserInternals: {
             getWavStructure: () => import("./containers/wav/types").WavStructure;
             getMatroskaStructure: () => import("./parse-result").MatroskaStructure;
         };
-        onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
-        onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
+        onAudioTrack: import("./webcodec-sample-types").MediaParserOnAudioTrack | null;
+        onVideoTrack: import("./webcodec-sample-types").MediaParserOnVideoTrack | null;
         emittedFields: import("./fields").AllOptions<import("./fields").ParseMediaFields>;
         fields: Partial<import("./fields").AllOptions<import("./fields").ParseMediaFields>>;
         samplesObserved: {
-            addVideoSample: (videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
-            addAudioSample: (audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
+            addVideoSample: (videoSample: import("./webcodec-sample-types").MediaParserVideoSample) => void;
+            addAudioSample: (audioSample: import("./webcodec-sample-types").MediaParserAudioSample) => void;
             getSlowDurationInSeconds: () => number;
             getFps: () => number;
             getSlowNumberOfFrames: () => number;
@@ -1137,14 +1146,43 @@ export declare const MediaParserInternals: {
         controller: import("./controller/media-parser-controller").MediaParserController;
         mode: import("./options").ParseMediaMode;
         src: import("./options").ParseMediaSrc;
-        readerInterface: import("./readers/reader").ReaderInterface;
+        readerInterface: import("./readers/reader").MediaParserReaderInterface;
         discardReadBytes: (force: boolean) => Promise<void>;
         selectM3uStreamFn: import("./containers/m3u/select-stream").SelectM3uStreamFn;
         selectM3uAssociatedPlaylistsFn: import("./containers/m3u/select-stream").SelectM3uAssociatedPlaylistsFn;
         m3uPlaylistContext: import("./options").M3uPlaylistContext | null;
         contentType: string | null;
         name: string;
-        returnValue: import("./options").ParseMediaResult<import("./options").AllParseMediaFields>;
+        returnValue: {
+            dimensions: import("./get-dimensions").MediaParserDimensions | null;
+            durationInSeconds: number | null;
+            slowDurationInSeconds: number;
+            slowNumberOfFrames: number;
+            slowFps: number;
+            slowStructure: import("./parse-result").MediaParserStructureUnstable;
+            fps: number | null;
+            videoCodec: import("./get-tracks").MediaParserVideoCodec | null;
+            audioCodec: import("./get-tracks").MediaParserAudioCodec | null;
+            tracks: import("./get-tracks").MediaParserTrack[];
+            rotation: number | null;
+            unrotatedDimensions: import("./get-dimensions").MediaParserDimensions | null;
+            internalStats: import("./state/parser-state").InternalStats;
+            size: number | null;
+            name: string;
+            container: import("./options").MediaParserContainer;
+            isHdr: boolean;
+            metadata: import("./metadata/get-metadata").MediaParserMetadataEntry[];
+            location: import("./get-location").MediaParserLocation | null;
+            mimeType: string | null;
+            keyframes: import("./options").MediaParserKeyframe[] | null;
+            slowKeyframes: import("./options").MediaParserKeyframe[];
+            images: import("./state/images").MediaParserEmbeddedImage[];
+            sampleRate: number | null;
+            numberOfAudioChannels: number | null;
+            slowVideoBitrate: number | null;
+            slowAudioBitrate: number | null;
+            m3uStreams: import("./containers/m3u/get-streams").M3uStream[] | null;
+        };
         callbackFunctions: Partial<import("./options").ParseMediaCallbacksMandatory>;
         fieldsInReturnValue: Partial<import("./fields").AllOptions<import("./fields").ParseMediaFields>>;
         mimeType: string | null;
@@ -1162,7 +1200,7 @@ export declare const MediaParserInternals: {
     };
     processSample: ({ iterator, logLevel, contentLength, }: {
         iterator: import("./iterator/buffer-iterator").BufferIterator;
-        logLevel: LogLevel;
+        logLevel: MediaParserLogLevel;
         contentLength: number;
     }) => Promise<{
         sample: import("./containers/iso-base-media/stsd/samples").Sample | null;
@@ -1172,7 +1210,7 @@ export declare const MediaParserInternals: {
         size: number;
         offset: number;
     }) => import("./containers/iso-base-media/ftyp").FtypBox;
-    parseEbml: (iterator: import("./iterator/buffer-iterator").BufferIterator, statesForProcessing: import("./containers/webm/state-for-processing").WebmRequiredStatesForProcessing | null) => Promise<import("./containers/webm/parse-ebml").Prettify<import("./containers/webm/segments/all-segments").PossibleEbml>>;
+    parseEbml: (iterator: import("./iterator/buffer-iterator").BufferIterator, statesForProcessing: import("./containers/webm/state-for-processing").WebmRequiredStatesForProcessing | null) => Promise<import("./containers/webm/parse-ebml").Prettify<PossibleEbml>>;
     parseMvhd: ({ iterator, offset, size, }: {
         iterator: import("./iterator/buffer-iterator").BufferIterator;
         offset: number;
@@ -1181,11 +1219,32 @@ export declare const MediaParserInternals: {
     internalParseMedia: import("./options").InternalParseMedia;
     fieldsNeedSamplesMap: Record<keyof import("./fields").AllOptions<import("./fields").ParseMediaFields>, boolean>;
 };
-export type { Prettify } from './containers/webm/parse-ebml';
-export type { Ebml, EbmlValue, FloatWithSize, MainSegment, PossibleEbml, TrackEntry, UintWithSize, } from './containers/webm/segments/all-segments';
-export { MediaParserStructureUnstable } from './parse-result';
-export type { LogLevel };
+export type { MediaParserLogLevel };
 export { M3uAssociatedPlaylist, M3uStream } from './containers/m3u/get-streams';
 export { defaultSelectM3uAssociatedPlaylists, defaultSelectM3uStreamFn, SelectM3uAssociatedPlaylistsFn, SelectM3uStreamFn, SelectM3uStreamFnOptions, } from './containers/m3u/select-stream';
 export { mediaParserController, MediaParserController, } from './controller/media-parser-controller';
 export { VERSION } from './version';
+export type { MediaParserSampleAspectRatio } from './get-tracks';
+/**
+ * @deprecated Dont use these yet.
+ */
+export type MediaParserInternalTypes = {
+    SamplePosition: SamplePosition;
+    MatroskaSegment: MatroskaSegment;
+    MatroskaElement: MatroskaElement;
+    WriterInterface: WriterInterface;
+    CreateContent: CreateContent;
+    Writer: Writer;
+    Ebml: Ebml;
+    FloatWithSize: FloatWithSize;
+    MainSegment: MainSegment;
+    PossibleEbml: PossibleEbml;
+    TrackEntry: TrackEntry;
+    UintWithSize: UintWithSize;
+    ParseMediaCallbacks: ParseMediaCallbacks;
+};
+/**
+ * @deprecated Dont use this yet.
+ */
+type _InternalEbmlValue<T extends Ebml, Child = PossibleEbml> = EbmlValue<T, Child>;
+export { _InternalEbmlValue };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = exports.mediaParserController = exports.defaultSelectM3uStreamFn = exports.defaultSelectM3uAssociatedPlaylists = exports.MediaParserInternals = exports.parseMedia = exports.downloadAndParseMedia = exports.MediaParserAbortError = exports.IsAPdfError = exports.IsAnUnsupportedFileTypeError = exports.IsAnImageError = exports.IsAGifError = exports.hasBeenAborted = void 0;
+exports.VERSION = exports.mediaParserController = exports.defaultSelectM3uStreamFn = exports.defaultSelectM3uAssociatedPlaylists = exports.MediaParserInternals = exports.downloadAndParseMedia = exports.MediaParserAbortError = exports.IsAPdfError = exports.IsAnUnsupportedFileTypeError = exports.IsAnImageError = exports.hasBeenAborted = exports.parseMedia = void 0;
 const aac_codecprivate_1 = require("./aac-codecprivate");
 const ftyp_1 = require("./containers/iso-base-media/ftyp");
 const mvhd_1 = require("./containers/iso-base-media/mvhd");
@@ -14,17 +14,19 @@ const buffer_iterator_1 = require("./iterator/buffer-iterator");
 const log_1 = require("./log");
 const need_samples_for_fields_1 = require("./state/need-samples-for-fields");
 const parser_state_1 = require("./state/parser-state");
+var parse_media_1 = require("./parse-media");
+Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
 var errors_1 = require("./errors");
 Object.defineProperty(exports, "hasBeenAborted", { enumerable: true, get: function () { return errors_1.hasBeenAborted; } });
-Object.defineProperty(exports, "IsAGifError", { enumerable: true, get: function () { return errors_1.IsAGifError; } });
 Object.defineProperty(exports, "IsAnImageError", { enumerable: true, get: function () { return errors_1.IsAnImageError; } });
 Object.defineProperty(exports, "IsAnUnsupportedFileTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedFileTypeError; } });
 Object.defineProperty(exports, "IsAPdfError", { enumerable: true, get: function () { return errors_1.IsAPdfError; } });
 Object.defineProperty(exports, "MediaParserAbortError", { enumerable: true, get: function () { return errors_1.MediaParserAbortError; } });
 var download_and_parse_media_1 = require("./download-and-parse-media");
 Object.defineProperty(exports, "downloadAndParseMedia", { enumerable: true, get: function () { return download_and_parse_media_1.downloadAndParseMedia; } });
-var parse_media_1 = require("./parse-media");
-Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
+/**
+ * @deprecated Dont use these yet.
+ */
 exports.MediaParserInternals = {
     Log: log_1.Log,
     createAacCodecPrivate: aac_codecprivate_1.createAacCodecPrivate,

package/dist/init-video.js

@@ -25,7 +25,7 @@ const initVideo = async ({ state }) => {
             throw new Error('No moov box found');
         }
         const tracks = (0, get_tracks_1.getTracksFromMoovBox)(moovAtom);
-        for (const track of tracks.videoTracks) {
+        for (const track of tracks.filter((t) => t.type === 'video')) {
             await (0, register_track_1.registerVideoTrack)({
                 track,
                 container: 'mp4',
@@ -35,7 +35,7 @@ const initVideo = async ({ state }) => {
                 tracks: state.callbacks.tracks,
             });
         }
-        for (const track of tracks.audioTracks) {
+        for (const track of tracks.filter((t) => t.type === 'audio')) {
             await (0, register_track_1.registerAudioTrack)({
                 track,
                 container: 'mp4',
@@ -123,14 +123,6 @@ const initVideo = async ({ state }) => {
         });
         return;
     }
-    if (fileType.type === 'gif') {
-        return Promise.reject(new errors_1.IsAGifError({
-            message: 'GIF files are not yet supported',
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-        }));
-    }
     if (fileType.type === 'pdf') {
         return Promise.reject(new errors_1.IsAPdfError({
             message: 'GIF files are not supported',
@@ -142,7 +134,8 @@ const initVideo = async ({ state }) => {
     if (fileType.type === 'bmp' ||
         fileType.type === 'jpeg' ||
         fileType.type === 'png' ||
-        fileType.type === 'webp') {
+        fileType.type === 'webp' ||
+        fileType.type === 'gif') {
         return Promise.reject(new errors_1.IsAnImageError({
             message: 'Image files are not supported',
             imageType: fileType.type,

package/dist/internal-parse-media.js

@@ -104,7 +104,7 @@ const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue,
     if (state.errored) {
         throw state.errored;
     }
-    if (state.controller._internals.seekSignal.getSeek()) {
+    if (state.controller._internals.seekSignal.getSeek() !== null) {
         throw new Error('Should not finish while a seek is pending');
     }
     return state.returnValue;

package/dist/log.d.ts

@@ -1,10 +1,10 @@
 export declare const logLevels: readonly ["trace", "verbose", "info", "warn", "error"];
-export type LogLevel = (typeof logLevels)[number];
-export declare const isEqualOrBelowLogLevel: (currentLevel: LogLevel, level: LogLevel) => boolean;
+export type MediaParserLogLevel = (typeof logLevels)[number];
+export declare const isEqualOrBelowLogLevel: (currentLevel: MediaParserLogLevel, level: MediaParserLogLevel) => boolean;
 export declare const Log: {
-    trace: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-    verbose: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-    info: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-    warn: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
+    trace: (logLevel: MediaParserLogLevel, message?: any, ...optionalParams: any[]) => void;
+    verbose: (logLevel: MediaParserLogLevel, message?: any, ...optionalParams: any[]) => void;
+    info: (logLevel: MediaParserLogLevel, message?: any, ...optionalParams: any[]) => void;
+    warn: (logLevel: MediaParserLogLevel, message?: any, ...optionalParams: any[]) => void;
     error: (message?: any, ...optionalParams: any[]) => void;
 };

package/dist/metadata/get-metadata.js

@@ -50,12 +50,17 @@ const hasMetadata = (structure) => {
     if (structure.type === 'wav') {
         return (0, get_metadata_from_wav_1.getMetadataFromWav)(structure) !== null;
     }
-    if (structure.type === 'm3u' || structure.type === 'transport-stream') {
+    // M3U, Transport Stream, AAC cannot store any metadata
+    if (structure.type === 'm3u' ||
+        structure.type === 'transport-stream' ||
+        structure.type === 'aac') {
         return true;
     }
     if (structure.type === 'flac') {
         return (0, get_metadata_from_flac_1.getMetadataFromFlac)(structure) !== null;
     }
+    // The following containers (MP4, Matroska, AVI) all have mechanisms
+    // to skip over video sections, and tests for it in read-metadata.test.ts
     if (structure.type === 'iso-base-media') {
         return false;
     }
@@ -65,9 +70,6 @@ const hasMetadata = (structure) => {
     if (structure.type === 'riff') {
         return false;
     }
-    if (structure.type === 'aac') {
-        return true;
-    }
     throw new Error('Unknown container ' + structure);
 };
 exports.hasMetadata = hasMetadata;