@remotion/media-parser 4.0.298 → 4.0.301

package/dist/state/iso-base-media/iso-state.d.ts

@@ -1,14 +1,14 @@
 import type { MediaParserController } from '../../controller/media-parser-controller';
 import type { PrefetchCache } from '../../fetch';
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { ParseMediaSrc } from '../../options';
-import type { ReaderInterface } from '../../readers/reader';
+import type { MediaParserReaderInterface } from '../../readers/reader';
 export declare const isoBaseMediaState: ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }: {
     contentLength: number;
     controller: MediaParserController;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     src: ParseMediaSrc;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
 }) => {
     flatSamples: {

package/dist/state/iso-base-media/lazy-mfra-load.d.ts

@@ -1,16 +1,16 @@
 import type { IsoBaseMediaBox } from '../../containers/iso-base-media/base-media-box';
 import type { MediaParserController } from '../../controller/media-parser-controller';
 import type { PrefetchCache } from '../../fetch';
-import { type LogLevel } from '../../log';
+import { type MediaParserLogLevel } from '../../log';
 import type { ParseMediaSrc } from '../../options';
-import type { ReaderInterface } from '../../readers/reader';
+import type { MediaParserReaderInterface } from '../../readers/reader';
 import type { IsoBaseMediaSeekingHints } from '../../seeking-hints';
 export declare const lazyMfraLoad: ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }: {
     contentLength: number;
     controller: MediaParserController;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     src: ParseMediaSrc;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
 }) => {
     triggerLoad: () => Promise<IsoBaseMediaBox[] | null>;

package/dist/state/m3u-state.d.ts

@@ -1,7 +1,7 @@
 import type { M3uAssociatedPlaylist, M3uStream } from '../containers/m3u/get-streams';
-import type { LogLevel } from '../log';
+import type { MediaParserLogLevel } from '../log';
 import type { IsoBaseMediaStructure } from '../parse-result';
-import type { OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
+import type { MediaParserOnAudioSample, MediaParserOnVideoSample } from '../webcodec-sample-types';
 export type M3uStreamOrInitialUrl = {
     type: 'selected-stream';
     stream: M3uStream;
@@ -16,13 +16,13 @@ export type M3uRun = {
 type M3uSeek = {
     targetTime: number;
 };
-export declare const m3uState: (logLevel: LogLevel) => {
+export declare const m3uState: (logLevel: MediaParserLogLevel) => {
     setSelectedMainPlaylist: (stream: M3uStreamOrInitialUrl) => void;
     getSelectedMainPlaylist: () => M3uStreamOrInitialUrl | null;
-    setHasEmittedVideoTrack: (src: string, callback: OnVideoSample | null) => void;
-    hasEmittedVideoTrack: (src: string) => false | OnVideoSample | null;
-    setHasEmittedAudioTrack: (src: string, callback: OnAudioSample | null) => void;
-    hasEmittedAudioTrack: (src: string) => false | OnAudioSample | null;
+    setHasEmittedVideoTrack: (src: string, callback: MediaParserOnVideoSample | null) => void;
+    hasEmittedVideoTrack: (src: string) => false | MediaParserOnVideoSample | null;
+    setHasEmittedAudioTrack: (src: string, callback: MediaParserOnAudioSample | null) => void;
+    hasEmittedAudioTrack: (src: string) => false | MediaParserOnAudioSample | null;
     setHasEmittedDoneWithTracks: (src: string) => void;
     hasEmittedDoneWithTracks: (src: string) => boolean;
     setReadyToIterateOverM3u: () => void;
@@ -45,12 +45,12 @@ export declare const m3uState: (logLevel: LogLevel) => {
     sampleSorter: {
         clearSamples: () => void;
         addToStreamWithTrack: (src: string) => void;
-        addVideoStreamToConsider: (src: string, callback: OnVideoSample) => void;
-        addAudioStreamToConsider: (src: string, callback: OnAudioSample) => void;
+        addVideoStreamToConsider: (src: string, callback: MediaParserOnVideoSample) => void;
+        addAudioStreamToConsider: (src: string, callback: 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: IsoBaseMediaStructure) => void;

package/dist/state/matroska/lazy-cues-fetch.d.ts

@@ -1,14 +1,14 @@
 import type { MatroskaCue } from '../../containers/webm/seek/format-cues';
 import type { MediaParserController } from '../../controller/media-parser-controller';
 import type { PrefetchCache } from '../../fetch';
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { ParseMediaSrc } from '../../options';
-import type { ReaderInterface } from '../../readers/reader';
+import type { MediaParserReaderInterface } from '../../readers/reader';
 import type { WebmSeekingHints } from '../../seeking-hints';
 export declare const lazyCuesFetch: ({ controller, logLevel, readerInterface, src, prefetchCache, }: {
     controller: MediaParserController;
-    logLevel: LogLevel;
-    readerInterface: ReaderInterface;
+    logLevel: MediaParserLogLevel;
+    readerInterface: MediaParserReaderInterface;
     src: ParseMediaSrc;
     prefetchCache: PrefetchCache;
 }) => {

package/dist/state/matroska/webm.d.ts

@@ -4,9 +4,9 @@ import type { TrackInfo } from '../../containers/webm/segments/track-entry';
 import type { MediaParserController } from '../../controller/media-parser-controller';
 import type { PrefetchCache } from '../../fetch';
 import type { BufferIterator } from '../../iterator/buffer-iterator';
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { ParseMediaSrc } from '../../options';
-import type { ReaderInterface } from '../../readers/reader';
+import type { MediaParserReaderInterface } from '../../readers/reader';
 export type SegmentSection = {
     start: number;
     size: number;
@@ -19,8 +19,8 @@ export type ClusterSection = {
 };
 export declare const webmState: ({ controller, logLevel, readerInterface, src, prefetchCache, }: {
     controller: MediaParserController;
-    logLevel: LogLevel;
-    readerInterface: ReaderInterface;
+    logLevel: MediaParserLogLevel;
+    readerInterface: MediaParserReaderInterface;
     src: ParseMediaSrc;
     prefetchCache: PrefetchCache;
 }) => {

package/dist/state/matroska/webm.js

@@ -117,7 +117,7 @@ const webmState = ({ controller, logLevel, readerInterface, src, prefetchCache,
         },
         isInsideCluster: (offset) => {
             for (const cluster of clusters) {
-                if (offset >= cluster.start && offset <= cluster.start + cluster.size) {
+                if (offset >= cluster.start && offset < cluster.start + cluster.size) {
                     return cluster;
                 }
             }

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

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

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maySkipOverSamplesInTheMiddle = exports.maySkipVideoData = void 0;
+exports.maySkipOverSamplesInTheMiddle = exports.maySkipVideoData = exports.missesMatroskaTracks = void 0;
+const get_ready_tracks_1 = require("../containers/webm/get-ready-tracks");
+const traversal_1 = require("../containers/webm/traversal");
 const need_samples_for_fields_1 = require("./need-samples-for-fields");
 const getHasCallbacks = (state) => {
     const hasNoTrackHandlers = !state.callbacks.hasAudioTrackHandlers &&
@@ -13,13 +15,32 @@ const getHasCallbacks = (state) => {
         Object.values(state.callbacks.audioSampleCallbacks).length > 0;
     return hasAllTracksAndNoCallbacks;
 };
+const missesMatroskaTracks = (state) => {
+    const struct = state.structure.getStructureOrNull();
+    if (struct === null) {
+        return false;
+    }
+    if (struct.type !== 'matroska') {
+        return false;
+    }
+    const mainSegment = (0, traversal_1.getMainSegment)(struct.boxes);
+    if (mainSegment === null) {
+        return false;
+    }
+    return ((0, get_ready_tracks_1.getTracksFromMatroska)({
+        structureState: state.structure,
+        webmState: state.webm,
+    }).missingInfo.length > 0);
+};
+exports.missesMatroskaTracks = missesMatroskaTracks;
 const maySkipVideoData = ({ state }) => {
     const hasCallbacks = getHasCallbacks(state);
     return (!hasCallbacks &&
         !(0, need_samples_for_fields_1.needsToIterateOverSamples)({
             emittedFields: state.emittedFields,
             fields: state.fields,
-        }));
+        }) &&
+        !(0, exports.missesMatroskaTracks)(state));
 };
 exports.maySkipVideoData = maySkipVideoData;
 const maySkipOverSamplesInTheMiddle = ({ state, }) => {

package/dist/state/need-samples-for-fields.js

@@ -16,7 +16,7 @@ exports.fieldsNeedSamplesMap = {
     name: false,
     rotation: false,
     size: false,
-    structure: false,
+    slowStructure: false,
     tracks: false,
     unrotatedDimensions: false,
     videoCodec: false,

package/dist/state/parser-state.d.ts

@@ -4,10 +4,10 @@ import type { MediaParserController } from '../controller/media-parser-controlle
 import type { PrefetchCache } from '../fetch';
 import type { Options, ParseMediaFields } from '../fields';
 import { type BufferIterator } from '../iterator/buffer-iterator';
-import { type LogLevel } from '../log';
-import type { AllParseMediaFields, M3uPlaylistContext, OnDiscardedData, ParseMediaCallbacks, ParseMediaMode, ParseMediaResult, ParseMediaSrc } from '../options';
-import type { Reader, ReaderInterface } from '../readers/reader';
-import type { OnAudioTrack, OnVideoTrack } from '../webcodec-sample-types';
+import { type MediaParserLogLevel } from '../log';
+import type { M3uPlaylistContext, OnDiscardedData, ParseMediaCallbacks, ParseMediaMode, ParseMediaSrc } from '../options';
+import type { MediaParserReaderInterface, Reader } from '../readers/reader';
+import type { MediaParserOnAudioTrack, MediaParserOnVideoTrack } from '../webcodec-sample-types';
 export type InternalStats = {
     skippedBytes: number;
     finalCursorOffset: number;
@@ -20,13 +20,13 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     controller: MediaParserController;
-    onAudioTrack: OnAudioTrack | null;
-    onVideoTrack: OnVideoTrack | null;
+    onAudioTrack: MediaParserOnAudioTrack | null;
+    onVideoTrack: MediaParserOnVideoTrack | null;
     contentLength: number;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     mode: ParseMediaMode;
     src: ParseMediaSrc;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     onDiscardedData: OnDiscardedData | null;
     selectM3uStreamFn: SelectM3uStreamFn;
     selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
@@ -66,8 +66,8 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
             }> | 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: {
@@ -99,8 +99,8 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         };
         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;
         };
     };
@@ -207,10 +207,10 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     m3u: {
         setSelectedMainPlaylist: (stream: import("./m3u-state").M3uStreamOrInitialUrl) => void;
         getSelectedMainPlaylist: () => import("./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;
@@ -233,12 +233,12 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         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;
@@ -260,24 +260,24 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         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("..").Track) => void;
-            getTracks: () => import("..").Track[];
+            setIsDone: (logLevel: MediaParserLogLevel) => void;
+            addTrack: (track: import("..").MediaParserTrack) => void;
+            getTracks: () => import("..").MediaParserTrack[];
             ensureHasTracksAtEnd: (fields: Options<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;
     };
@@ -290,9 +290,9 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         setFromSeekingHints: (keyframesFromHints: import("../options").MediaParserKeyframe[]) => void;
     };
     structure: {
-        getStructureOrNull: () => import("..").MediaParserStructureUnstable | null;
-        getStructure: () => import("..").MediaParserStructureUnstable;
-        setStructure: (value: import("..").MediaParserStructureUnstable) => void;
+        getStructureOrNull: () => import("../parse-result").MediaParserStructureUnstable | null;
+        getStructure: () => import("../parse-result").MediaParserStructureUnstable;
+        setStructure: (value: import("../parse-result").MediaParserStructureUnstable) => void;
         getFlacStructure: () => import("../containers/flac/types").FlacStructure;
         getIsoStructure: () => import("../parse-result").IsoBaseMediaStructure;
         getMp3Structure: () => import("../parse-result").Mp3Structure;
@@ -302,13 +302,13 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getWavStructure: () => import("../containers/wav/types").WavStructure;
         getMatroskaStructure: () => import("../parse-result").MatroskaStructure;
     };
-    onAudioTrack: OnAudioTrack | null;
-    onVideoTrack: OnVideoTrack | null;
+    onAudioTrack: MediaParserOnAudioTrack | null;
+    onVideoTrack: MediaParserOnVideoTrack | null;
     emittedFields: import("../fields").AllOptions<ParseMediaFields>;
     fields: Partial<import("../fields").AllOptions<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;
@@ -414,14 +414,43 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     controller: MediaParserController;
     mode: ParseMediaMode;
     src: ParseMediaSrc;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     discardReadBytes: (force: boolean) => Promise<void>;
     selectM3uStreamFn: SelectM3uStreamFn;
     selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
     m3uPlaylistContext: M3uPlaylistContext | null;
     contentType: string | null;
     name: string;
-    returnValue: ParseMediaResult<AllParseMediaFields>;
+    returnValue: {
+        dimensions: import("..").MediaParserDimensions | null;
+        durationInSeconds: number | null;
+        slowDurationInSeconds: number;
+        slowNumberOfFrames: number;
+        slowFps: number;
+        slowStructure: import("../parse-result").MediaParserStructureUnstable;
+        fps: number | null;
+        videoCodec: import("..").MediaParserVideoCodec | null;
+        audioCodec: import("..").MediaParserAudioCodec | null;
+        tracks: import("..").MediaParserTrack[];
+        rotation: number | null;
+        unrotatedDimensions: import("..").MediaParserDimensions | null;
+        internalStats: InternalStats;
+        size: number | null;
+        name: string;
+        container: import("../options").MediaParserContainer;
+        isHdr: boolean;
+        metadata: import("..").MediaParserMetadataEntry[];
+        location: import("..").MediaParserLocation | null;
+        mimeType: string | null;
+        keyframes: import("../options").MediaParserKeyframe[] | null;
+        slowKeyframes: import("../options").MediaParserKeyframe[];
+        images: import("./images").MediaParserEmbeddedImage[];
+        sampleRate: number | null;
+        numberOfAudioChannels: number | null;
+        slowVideoBitrate: number | null;
+        slowAudioBitrate: number | null;
+        m3uStreams: import("..").M3uStream[] | null;
+    };
     callbackFunctions: Partial<import("../options").ParseMediaCallbacksMandatory>;
     fieldsInReturnValue: Partial<import("../fields").AllOptions<ParseMediaFields>>;
     mimeType: string | null;

package/dist/state/riff/lazy-idx1-fetch.d.ts

@@ -1,13 +1,13 @@
 import type { RiffSeekingHints } from '../../containers/riff/seeking-hints';
 import type { MediaParserController } from '../../controller/media-parser-controller';
 import type { PrefetchCache } from '../../fetch';
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { ParseMediaSrc } from '../../options';
-import type { ReaderInterface } from '../../readers/reader';
+import type { MediaParserReaderInterface } from '../../readers/reader';
 export declare const lazyIdx1Fetch: ({ controller, logLevel, readerInterface, src, prefetchCache, }: {
     controller: MediaParserController;
-    logLevel: LogLevel;
-    readerInterface: ReaderInterface;
+    logLevel: MediaParserLogLevel;
+    readerInterface: MediaParserReaderInterface;
     src: ParseMediaSrc;
     prefetchCache: PrefetchCache;
 }) => {

package/dist/state/riff/sample-counter.d.ts

@@ -1,7 +1,7 @@
-import type { AudioOrVideoSample } from '../../webcodec-sample-types';
+import type { MediaParserAudioSample, MediaParserVideoSample } from '../../webcodec-sample-types';
 export declare const riffSampleCounter: () => {
-    onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => void;
-    onVideoSample: (trackId: number, videoSample: AudioOrVideoSample) => void;
+    onAudioSample: (trackId: number, audioSample: MediaParserAudioSample) => void;
+    onVideoSample: (trackId: number, videoSample: MediaParserVideoSample) => void;
     getSamplesForTrack: (trackId: number) => number;
     setSamplesFromSeek: (samples: Record<number, number>) => void;
     riffKeys: {

package/dist/state/riff.d.ts

@@ -1,14 +1,14 @@
 import type { MediaParserController } from '../controller/media-parser-controller';
 import type { PrefetchCache } from '../fetch';
-import type { LogLevel } from '../log';
+import type { MediaParserLogLevel } from '../log';
 import type { ParseMediaSrc } from '../options';
-import type { ReaderInterface } from '../readers/reader';
+import type { MediaParserReaderInterface } from '../readers/reader';
 import type { SpsAndPps } from './parser-state';
 type AvcProfileInfoCallback = (profile: SpsAndPps) => Promise<void>;
 export declare const riffSpecificState: ({ controller, logLevel, readerInterface, src, prefetchCache, }: {
     controller: MediaParserController;
-    logLevel: LogLevel;
-    readerInterface: ReaderInterface;
+    logLevel: MediaParserLogLevel;
+    readerInterface: MediaParserReaderInterface;
     src: ParseMediaSrc;
     prefetchCache: PrefetchCache;
 }) => {
@@ -37,8 +37,8 @@ export declare const riffSpecificState: ({ controller, logLevel, readerInterface
         }> | Promise<null>;
     };
     sampleCounter: {
-        onAudioSample: (trackId: number, audioSample: import("..").AudioOrVideoSample) => void;
-        onVideoSample: (trackId: number, videoSample: import("..").AudioOrVideoSample) => void;
+        onAudioSample: (trackId: number, audioSample: import("..").MediaParserAudioSample) => void;
+        onVideoSample: (trackId: number, videoSample: import("..").MediaParserVideoSample) => void;
         getSamplesForTrack: (trackId: number) => number;
         setSamplesFromSeek: (samples: Record<number, number>) => void;
         riffKeys: {

package/dist/state/sample-callbacks.d.ts

@@ -1,9 +1,9 @@
 import type { MediaParserController } from '../controller/media-parser-controller';
 import type { SeekSignal } from '../controller/seek-signal';
 import type { AllOptions, Options, ParseMediaFields } from '../fields';
-import type { LogLevel } from '../log';
+import type { MediaParserLogLevel } from '../log';
 import type { ParseMediaSrc } from '../options';
-import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
+import type { MediaParserAudioSample, MediaParserOnAudioSample, MediaParserOnVideoSample, MediaParserVideoSample } from '../webcodec-sample-types';
 import { type KeyframesState } from './keyframes';
 import type { SamplesObservedState } from './samples-observed/slow-duration-fps';
 import type { StructureState } from './structure';
@@ -18,26 +18,26 @@ export declare const callbacksState: ({ controller, hasAudioTrackHandlers, hasVi
     structure: StructureState;
     src: ParseMediaSrc;
     seekSignal: SeekSignal;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
 }) => {
-    registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
-    onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => Promise<void>;
-    onVideoSample: (trackId: number, videoSample: AudioOrVideoSample) => Promise<void>;
+    registerVideoSampleCallback: (id: number, callback: MediaParserOnVideoSample | null) => Promise<void>;
+    onAudioSample: (trackId: number, audioSample: MediaParserAudioSample) => Promise<void>;
+    onVideoSample: (trackId: number, videoSample: MediaParserVideoSample) => Promise<void>;
     canSkipTracksState: {
         doFieldsNeedTracks: () => boolean;
         canSkipTracks: () => boolean;
     };
-    registerAudioSampleCallback: (id: number, callback: OnAudioSample | null) => Promise<void>;
+    registerAudioSampleCallback: (id: number, callback: MediaParserOnAudioSample | null) => Promise<void>;
     tracks: {
         hasAllTracks: () => boolean;
         getIsDone: () => boolean;
-        setIsDone: (logLevel: LogLevel) => void;
-        addTrack: (track: import("..").Track) => void;
-        getTracks: () => import("..").Track[];
+        setIsDone: (logLevel: MediaParserLogLevel) => void;
+        addTrack: (track: import("..").MediaParserTrack) => void;
+        getTracks: () => import("..").MediaParserTrack[];
         ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
     };
-    audioSampleCallbacks: Record<number, OnAudioSample>;
-    videoSampleCallbacks: Record<number, OnVideoSample>;
+    audioSampleCallbacks: Record<number, MediaParserOnAudioSample>;
+    videoSampleCallbacks: Record<number, MediaParserOnVideoSample>;
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
 };

package/dist/state/sample-callbacks.js

@@ -38,7 +38,7 @@ const callbacksState = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
             if (audioSample.data.length > 0) {
                 // If we emit samples with data length 0, Chrome will fail
                 if (callback) {
-                    if (seekSignal.getSeek()) {
+                    if (seekSignal.getSeek() !== null) {
                         log_1.Log.trace(logLevel, 'Not emitting sample because seek is processing');
                     }
                     else {
@@ -58,7 +58,7 @@ const callbacksState = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
                 const callback = videoSampleCallbacks[trackId];
                 // If we emit samples with data 0, Chrome will fail
                 if (callback) {
-                    if (seekSignal.getSeek()) {
+                    if (seekSignal.getSeek() !== null) {
                         log_1.Log.trace(logLevel, 'Not emitting sample because seek is processing');
                     }
                     else {

package/dist/state/samples-observed/slow-duration-fps.d.ts

@@ -1,7 +1,7 @@
-import type { AudioOrVideoSample } from '../../webcodec-sample-types';
+import type { MediaParserAudioSample, MediaParserVideoSample } from '../../webcodec-sample-types';
 export declare const samplesObservedState: () => {
-    addVideoSample: (videoSample: AudioOrVideoSample) => void;
-    addAudioSample: (audioSample: AudioOrVideoSample) => void;
+    addVideoSample: (videoSample: MediaParserVideoSample) => void;
+    addAudioSample: (audioSample: MediaParserAudioSample) => void;
     getSlowDurationInSeconds: () => number;
     getFps: () => number;
     getSlowNumberOfFrames: () => number;

package/dist/state/transport-stream/last-emitted-sample.d.ts

@@ -1,6 +1,6 @@
-import type { AudioOrVideoSample } from '../../webcodec-sample-types';
+import type { MediaParserAudioSample, MediaParserVideoSample } from '../../webcodec-sample-types';
 export declare const lastEmittedSampleState: () => {
-    setLastEmittedSample: (sample: AudioOrVideoSample) => void;
-    getLastEmittedSample: () => AudioOrVideoSample | null;
+    setLastEmittedSample: (sample: MediaParserAudioSample | MediaParserVideoSample) => void;
+    getLastEmittedSample: () => MediaParserAudioSample | MediaParserVideoSample | null;
     resetLastEmittedSample: () => void;
 };

package/dist/state/transport-stream/transport-stream.d.ts

@@ -21,8 +21,8 @@ export declare const transportStreamState: () => {
     };
     resetBeforeSeek: () => void;
     lastEmittedSample: {
-        setLastEmittedSample: (sample: import("../..").AudioOrVideoSample) => void;
-        getLastEmittedSample: () => import("../..").AudioOrVideoSample | null;
+        setLastEmittedSample: (sample: import("../..").MediaParserAudioSample | import("../..").MediaParserVideoSample) => void;
+        getLastEmittedSample: () => import("../..").MediaParserAudioSample | import("../..").MediaParserVideoSample | null;
         resetLastEmittedSample: () => void;
     };
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.298";
+export declare const VERSION = "4.0.301";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Automatically generated on publish
-exports.VERSION = '4.0.298';
+exports.VERSION = '4.0.301';

package/dist/webcodec-sample-types.d.ts

@@ -1,18 +1,29 @@
-import type { AudioTrack, VideoTrack } from './get-tracks';
+import type { MediaParserAudioTrack, MediaParserVideoTrack } from './get-tracks';
 import type { MediaParserContainer } from './options';
-export type OnAudioSample = (sample: AudioOrVideoSample) => void | Promise<void>;
-export type OnVideoSample = (sample: AudioOrVideoSample) => void | Promise<void>;
-export type OnAudioTrackParams = {
-    track: AudioTrack;
+export type MediaParserOnAudioSample = (sample: MediaParserAudioSample) => void | Promise<void>;
+export type MediaParserOnVideoSample = (sample: MediaParserVideoSample) => void | Promise<void>;
+export type MediaParserOnAudioTrackParams = {
+    track: MediaParserAudioTrack;
     container: MediaParserContainer;
 };
-export type OnAudioTrack = (options: OnAudioTrackParams) => OnAudioSample | Promise<OnAudioSample | null> | null;
-export type OnVideoTrackParams = {
-    track: VideoTrack;
+export type MediaParserOnAudioTrack = (options: MediaParserOnAudioTrackParams) => MediaParserOnAudioSample | Promise<MediaParserOnAudioSample | null> | null;
+export type MediaParserOnVideoTrackParams = {
+    track: MediaParserVideoTrack;
     container: MediaParserContainer;
 };
-export type OnVideoTrack = (options: OnVideoTrackParams) => OnVideoSample | Promise<OnVideoSample | null> | null;
-export type AudioOrVideoSample = {
+export type MediaParserOnVideoTrack = (options: MediaParserOnVideoTrackParams) => MediaParserOnVideoSample | Promise<MediaParserOnVideoSample | null> | null;
+export type MediaParserAudioSample = {
+    data: Uint8Array;
+    timestamp: number;
+    duration: number | undefined;
+    trackId: number;
+    type: 'key' | 'delta';
+    cts: number;
+    dts: number;
+    offset: number;
+    timescale: number;
+};
+export type MediaParserVideoSample = {
     data: Uint8Array;
     timestamp: number;
     duration: number | undefined;