@remotion/media-parser 4.0.248 → 4.0.250

package/dist/state/can-skip-tracks.js

@@ -1,31 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeCanSkipTracksState = void 0;
-const needsTracksField = {
-    audioCodec: true,
-    container: false,
-    dimensions: true,
-    durationInSeconds: true,
-    slowDurationInSeconds: true,
-    slowFps: true,
-    fps: true,
-    internalStats: false,
-    isHdr: true,
-    name: false,
-    rotation: true,
-    size: false,
-    structure: true,
-    tracks: true,
-    unrotatedDimensions: true,
-    videoCodec: true,
-    metadata: true,
-    location: true,
-    mimeType: false,
-    slowKeyframes: true,
-    slowNumberOfFrames: true,
-    keyframes: true,
+exports.makeCanSkipTracksState = exports.needsTracksForField = void 0;
+const needsTracksForField = ({ field, structure, }) => {
+    if (field === 'dimensions') {
+        if (structure.type === 'riff') {
+            return false;
+        }
+        return true;
+    }
+    if (field === 'audioCodec' ||
+        field === 'durationInSeconds' ||
+        field === 'slowDurationInSeconds' ||
+        field === 'slowFps' ||
+        field === 'fps' ||
+        field === 'isHdr' ||
+        field === 'rotation' ||
+        field === 'structure' ||
+        field === 'tracks' ||
+        field === 'unrotatedDimensions' ||
+        field === 'videoCodec' ||
+        field === 'metadata' ||
+        field === 'location' ||
+        field === 'slowKeyframes' ||
+        field === 'slowNumberOfFrames' ||
+        field === 'keyframes' ||
+        field === 'images') {
+        return true;
+    }
+    if (field === 'container' ||
+        field === 'internalStats' ||
+        field === 'mimeType' ||
+        field === 'name' ||
+        field === 'size') {
+        return false;
+    }
+    throw new Error(`field not implemeted ${field}`);
 };
-const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, }) => {
+exports.needsTracksForField = needsTracksForField;
+const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }) => {
     return {
         canSkipTracks: () => {
             if (hasAudioTrackHandlers || hasVideoTrackHandlers) {
@@ -33,7 +45,7 @@ const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHa
             }
             const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
             const selectedKeys = keys.filter((k) => fields[k]);
-            return !selectedKeys.some((k) => needsTracksField[k]);
+            return !selectedKeys.some((k) => (0, exports.needsTracksForField)({ field: k, structure: structure.getStructure() }));
         },
     };
 };

package/dist/state/emitted-fields.js

@@ -25,6 +25,7 @@ const emittedState = () => {
         slowKeyframes: false,
         slowNumberOfFrames: false,
         keyframes: false,
+        images: false,
     };
     return emittedFields;
 };

package/dist/state/images.d.ts

@@ -0,0 +1,9 @@
+export type MediaParserEmbeddedImage = {
+    description: string | null;
+    mimeType: string | null;
+    data: Uint8Array;
+};
+export declare const imagesState: () => {
+    images: MediaParserEmbeddedImage[];
+    addImage: (image: MediaParserEmbeddedImage) => void;
+};

package/dist/state/images.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imagesState = void 0;
+const imagesState = () => {
+    const images = [];
+    const addImage = (image) => {
+        images.push(image);
+    };
+    return {
+        images,
+        addImage,
+    };
+};
+exports.imagesState = imagesState;

package/dist/state/iso-base-media/cached-sample-positions.d.ts

@@ -0,0 +1,15 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { ParserState } from '../parser-state';
+export type FlatSample = {
+    track: VideoTrack | AudioTrack | OtherTrack;
+    samplePosition: SamplePosition;
+};
+export declare const calculateFlatSamples: (state: ParserState) => {
+    track: VideoTrack | AudioTrack | OtherTrack;
+    samplePosition: SamplePosition;
+}[];
+export declare const cachedSamplePositionsState: () => {
+    getSamples: () => FlatSample[] | null;
+    setSamples: (samples: FlatSample[]) => void;
+};

package/dist/state/iso-base-media/cached-sample-positions.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedSamplePositionsState = exports.calculateFlatSamples = 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_tracks_1 = require("../../get-tracks");
+const calculateFlatSamples = (state) => {
+    const tracks = (0, get_tracks_1.getTracks)(state);
+    const allTracks = [
+        ...tracks.videoTracks,
+        ...tracks.audioTracks,
+        ...tracks.otherTracks,
+    ];
+    const flatSamples = allTracks
+        .map((track) => {
+        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)(track.trakBox, (0, traversal_1.getMoofBox)(state.structure.getStructure().boxes));
+        if (!samplePositions) {
+            throw new Error('No sample positions');
+        }
+        return samplePositions.map((samplePosition) => {
+            return {
+                track,
+                samplePosition,
+            };
+        });
+    })
+        .flat(1);
+    return flatSamples;
+};
+exports.calculateFlatSamples = calculateFlatSamples;
+const cachedSamplePositionsState = () => {
+    let cached = null;
+    return {
+        getSamples: () => {
+            return cached;
+        },
+        setSamples: (samples) => {
+            cached = samples;
+        },
+    };
+};
+exports.cachedSamplePositionsState = cachedSamplePositionsState;

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

@@ -0,0 +1,8 @@
+export declare const isoBaseMediaState: () => {
+    getShouldReturnToVideoSectionAfterEnd: () => boolean;
+    setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
+    flatSamples: {
+        getSamples: () => import("./cached-sample-positions").FlatSample[] | null;
+        setSamples: (samples: import("./cached-sample-positions").FlatSample[]) => void;
+    };
+};

package/dist/state/iso-base-media/iso-state.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isoBaseMediaState = void 0;
+const cached_sample_positions_1 = require("./cached-sample-positions");
+const isoBaseMediaState = () => {
+    let shouldReturnToVideoSectionAfterEnd = false;
+    return {
+        getShouldReturnToVideoSectionAfterEnd: () => shouldReturnToVideoSectionAfterEnd,
+        setShouldReturnToVideoSectionAfterEnd: (value) => {
+            shouldReturnToVideoSectionAfterEnd = value;
+        },
+        flatSamples: (0, cached_sample_positions_1.cachedSamplePositionsState)(),
+    };
+};
+exports.isoBaseMediaState = isoBaseMediaState;

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

@@ -0,0 +1,4 @@
+export declare const isoBaseMediaState: () => {
+    getShouldReturnToVideoSectionAfterEnd: () => boolean;
+    setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
+};

package/dist/state/iso-state.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isoBaseMediaState = void 0;
+const isoBaseMediaState = () => {
+    let shouldReturnToVideoSectionAfterEnd = false;
+    return {
+        getShouldReturnToVideoSectionAfterEnd: () => shouldReturnToVideoSectionAfterEnd,
+        setShouldReturnToVideoSectionAfterEnd: (value) => {
+            shouldReturnToVideoSectionAfterEnd = value;
+        },
+    };
+};
+exports.isoBaseMediaState = isoBaseMediaState;

package/dist/state/mp3.d.ts

@@ -0,0 +1,11 @@
+export type Mp3Info = {
+    sampleRate: number;
+    mpegVersion: 1 | 2;
+    layer: number;
+    bitrateKbit: number;
+    startOfMpegStream: number;
+};
+export declare const makeMp3State: () => {
+    getMp3Info: () => Mp3Info | null;
+    setMp3Info: (info: Mp3Info) => void;
+};

package/dist/state/mp3.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMp3State = void 0;
+const makeMp3State = () => {
+    let mp3Info = null;
+    return {
+        getMp3Info: () => mp3Info,
+        setMp3Info: (info) => {
+            mp3Info = info;
+        },
+    };
+};
+exports.makeMp3State = makeMp3State;

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

@@ -1,5 +1,6 @@
 import type { AvcPPs, AvcProfileInfo } from '../boxes/avc/parse-avc';
 import type { BufferIterator } from '../buffer-iterator';
+import type { LogLevel } from '../log';
 import type { Options, ParseMediaFields } from '../options';
 import type { OnAudioTrack, OnVideoTrack } from '../webcodec-sample-types';
 export type InternalStats = {
@@ -10,7 +11,7 @@ export type SpsAndPps = {
     sps: AvcProfileInfo;
     pps: AvcPPs;
 };
-export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, }: {
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     signal: AbortSignal | undefined;
@@ -19,6 +20,8 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     supportsContentRange: boolean;
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
+    contentLength: number | null;
+    logLevel: LogLevel;
 }) => {
     riff: {
         getAvcProfile: () => SpsAndPps | null;
@@ -27,6 +30,38 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         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("./webm").SegmentSection, "index">) => void;
+        addCluster: (cluster: import("./webm").ClusterSection) => void;
+        isInsideSegment: (iterator: BufferIterator) => import("./webm").SegmentSection | null;
+        isInsideCluster: (iterator: BufferIterator) => import("./webm").ClusterSection | null;
+    };
+    iso: {
+        getShouldReturnToVideoSectionAfterEnd: () => boolean;
+        setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
+        flatSamples: {
+            getSamples: () => import("./iso-base-media/cached-sample-positions").FlatSample[] | null;
+            setSamples: (samples: import("./iso-base-media/cached-sample-positions").FlatSample[]) => void;
+        };
+    };
+    mp3Info: {
+        getMp3Info: () => import("./mp3").Mp3Info | null;
+        setMp3Info: (info: import("./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>;
@@ -45,6 +80,8 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         };
         audioSampleCallbacks: Record<number, import("../webcodec-sample-types").OnAudioSample>;
         videoSampleCallbacks: Record<number, import("../webcodec-sample-types").OnVideoSample>;
+        hasAudioTrackHandlers: boolean;
+        hasVideoTrackHandlers: boolean;
     };
     getInternalStats: () => InternalStats;
     getSkipBytes: () => number;
@@ -61,22 +98,31 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: 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<ParseMediaFields>;
     fields: Partial<import("../options").AllOptions<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("./images").MediaParserEmbeddedImage[];
+        addImage: (image: import("./images").MediaParserEmbeddedImage) => void;
+    };
+    videoSection: {
+        setVideoSection: (section: {
+            start: number;
+            size: number;
+        }) => void;
+        getVideoSection: () => {
+            start: number;
+            size: number;
+        };
+        isInVideoSectionState: (iterator: BufferIterator) => "no-section-defined" | "in-section" | "outside-section";
+    };
+    logLevel: "trace" | "verbose" | "info" | "warn" | "error";
 };
 export type ParserState = ReturnType<typeof makeParserState>;

package/dist/state/parser-state.js

@@ -2,13 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeParserState = void 0;
 const emitted_fields_1 = require("./emitted-fields");
+const images_1 = require("./images");
+const iso_state_1 = require("./iso-base-media/iso-state");
 const keyframes_1 = require("./keyframes");
+const mp3_1 = require("./mp3");
 const riff_1 = require("./riff");
 const sample_callbacks_1 = require("./sample-callbacks");
 const slow_duration_fps_1 = require("./slow-duration-fps");
 const structure_1 = require("./structure");
+const transport_stream_1 = require("./transport-stream");
+const video_section_1 = require("./video-section");
 const webm_1 = require("./webm");
-const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, }) => {
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }) => {
     let skippedBytes = 0;
     const increaseSkippedBytes = (bytes) => {
         skippedBytes += bytes;
@@ -17,8 +22,14 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
     const keyframes = (0, keyframes_1.keyframesState)();
     const emittedFields = (0, emitted_fields_1.emittedState)();
     const slowDurationAndFps = (0, slow_duration_fps_1.slowDurationAndFpsState)();
+    const mp3Info = (0, mp3_1.makeMp3State)();
+    const images = (0, images_1.imagesState)();
     return {
         riff: (0, riff_1.riffSpecificState)(),
+        transportStream: (0, transport_stream_1.transportStreamState)(),
+        webm: (0, webm_1.webmState)(),
+        iso: (0, iso_state_1.isoBaseMediaState)(),
+        mp3Info,
         callbacks: (0, sample_callbacks_1.sampleCallback)({
             signal,
             hasAudioTrackHandlers,
@@ -27,6 +38,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
             keyframes,
             emittedFields,
             slowDurationAndFpsState: slowDurationAndFps,
+            structure,
         }),
         getInternalStats: () => {
             var _a, _b;
@@ -42,10 +54,13 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
         onAudioTrack,
         onVideoTrack,
         supportsContentRange,
-        webm: (0, webm_1.webmState)(),
         emittedFields,
         fields,
         slowDurationAndFps,
+        contentLength,
+        images,
+        videoSection: (0, video_section_1.videoSectionState)(),
+        logLevel,
     };
 };
 exports.makeParserState = makeParserState;

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

@@ -2,7 +2,8 @@ import type { AllOptions, Options, ParseMediaFields } from '../options';
 import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
 import { type KeyframesState } from './keyframes';
 import type { SlowDurationAndFpsState } from './slow-duration-fps';
-export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, }: {
+import type { StructureState } from './structure';
+export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }: {
     signal: AbortSignal | undefined;
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
@@ -10,6 +11,7 @@ export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoT
     keyframes: KeyframesState;
     emittedFields: AllOptions<ParseMediaFields>;
     slowDurationAndFpsState: SlowDurationAndFpsState;
+    structure: StructureState;
 }) => {
     registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
     onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => Promise<void>;
@@ -28,4 +30,6 @@ export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoT
     };
     audioSampleCallbacks: Record<number, OnAudioSample>;
     videoSampleCallbacks: Record<number, OnVideoSample>;
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
 };

package/dist/state/sample-callbacks.js

@@ -4,7 +4,7 @@ exports.sampleCallback = void 0;
 const need_samples_for_fields_1 = require("../may-skip-video-data/need-samples-for-fields");
 const can_skip_tracks_1 = require("./can-skip-tracks");
 const has_tracks_section_1 = require("./has-tracks-section");
-const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, }) => {
+const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }) => {
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
     const queuedAudioSamples = {};
@@ -13,6 +13,7 @@ const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers,
         hasAudioTrackHandlers,
         fields,
         hasVideoTrackHandlers,
+        structure,
     });
     const tracksState = (0, has_tracks_section_1.makeTracksSectionState)(canSkipTracksState);
     const samplesForTrack = {};
@@ -44,6 +45,9 @@ const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers,
                     await callback(audioSample);
                 }
             }
+            if ((0, need_samples_for_fields_1.needsToIterateOverSamples)({ emittedFields, fields })) {
+                slowDurationAndFpsState.addAudioSample(audioSample);
+            }
         },
         getSamplesForTrack: (trackId) => {
             var _a;
@@ -77,7 +81,7 @@ const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers,
                         sizeInBytes: videoSample.data.length,
                     });
                 }
-                slowDurationAndFpsState.addSample(videoSample);
+                slowDurationAndFpsState.addVideoSample(videoSample);
             }
         },
         canSkipTracksState,
@@ -96,6 +100,8 @@ const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers,
         tracks: tracksState,
         audioSampleCallbacks,
         videoSampleCallbacks,
+        hasAudioTrackHandlers,
+        hasVideoTrackHandlers,
     };
 };
 exports.sampleCallback = sampleCallback;

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

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

package/dist/state/slow-duration-fps.js

@@ -2,35 +2,69 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.slowDurationAndFpsState = void 0;
 const slowDurationAndFpsState = () => {
-    let smallestSample;
-    let largestSample;
-    let samples = 0;
+    let smallestVideoSample;
+    let largestVideoSample;
+    let smallestAudioSample;
+    let largestAudioSample;
+    let videoSamples = 0;
+    let audioSamples = 0;
+    const getSlowVideoDurationInSeconds = () => {
+        let videoDuration = null;
+        if (smallestVideoSample !== undefined && largestVideoSample !== undefined) {
+            const startingTimestampDifference = largestVideoSample - smallestVideoSample;
+            const timeBetweenSamples = startingTimestampDifference / (videoSamples - 1);
+            videoDuration = timeBetweenSamples * videoSamples;
+        }
+        return videoDuration;
+    };
     const getSlowDurationInSeconds = () => {
-        if (smallestSample !== undefined && largestSample !== undefined) {
-            const startingTimestampDifference = largestSample - smallestSample;
-            const timeBetweenSamples = startingTimestampDifference / (samples - 1);
-            return timeBetweenSamples * samples;
+        const videoDuration = getSlowVideoDurationInSeconds();
+        let audioDuration = null;
+        if (smallestAudioSample !== undefined && largestAudioSample !== undefined) {
+            const startingTimestampDifferenceAudio = largestAudioSample - smallestAudioSample;
+            const timeBetweenSamplesAudio = startingTimestampDifferenceAudio / (audioSamples - 1);
+            audioDuration = timeBetweenSamplesAudio * audioSamples;
         }
-        throw new Error('No samples');
+        if (videoDuration === null && audioDuration === null) {
+            throw new Error('No samples');
+        }
+        return Math.max(videoDuration !== null && videoDuration !== void 0 ? videoDuration : 0, audioDuration !== null && audioDuration !== void 0 ? audioDuration : 0);
     };
     return {
-        addSample: (videoSample) => {
-            samples++;
+        addVideoSample: (videoSample) => {
+            videoSamples++;
             const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
-            if (largestSample === undefined ||
-                presentationTimeInSeconds > largestSample) {
-                largestSample = presentationTimeInSeconds;
+            if (largestVideoSample === undefined ||
+                presentationTimeInSeconds > largestVideoSample) {
+                largestVideoSample = presentationTimeInSeconds;
             }
-            if (smallestSample === undefined ||
-                presentationTimeInSeconds < smallestSample) {
-                smallestSample = presentationTimeInSeconds;
+            if (smallestVideoSample === undefined ||
+                presentationTimeInSeconds < smallestVideoSample) {
+                smallestVideoSample = presentationTimeInSeconds;
+            }
+        },
+        addAudioSample: (audioSample) => {
+            audioSamples++;
+            const presentationTimeInSeconds = audioSample.cts / audioSample.timescale;
+            if (largestAudioSample === undefined ||
+                presentationTimeInSeconds > largestAudioSample) {
+                largestAudioSample = presentationTimeInSeconds;
+            }
+            if (smallestAudioSample === undefined ||
+                presentationTimeInSeconds < smallestAudioSample) {
+                smallestAudioSample = presentationTimeInSeconds;
             }
         },
         getSlowDurationInSeconds,
         getFps: () => {
-            return samples / getSlowDurationInSeconds();
+            var _a;
+            const videoDuration = (_a = getSlowVideoDurationInSeconds()) !== null && _a !== void 0 ? _a : 0;
+            if (videoDuration === 0) {
+                return 0;
+            }
+            return videoSamples / videoDuration;
         },
-        getSlowNumberOfFrames: () => samples,
+        getSlowNumberOfFrames: () => videoSamples,
     };
 };
 exports.slowDurationAndFpsState = slowDurationAndFpsState;

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

@@ -0,0 +1,8 @@
+import type { TransportStreamPacketBuffer } from '../boxes/transport-stream/process-stream-buffers';
+export declare const transportStreamState: () => {
+    nextPesHeaderStore: {
+        setNextPesHeader: (pesHeader: import("../boxes/transport-stream/parse-pes").PacketPes) => void;
+        getNextPesHeader: () => import("../boxes/transport-stream/parse-pes").PacketPes;
+    };
+    streamBuffers: Map<number, TransportStreamPacketBuffer>;
+};

package/dist/state/transport-stream.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transportStreamState = void 0;
+const next_pes_header_store_1 = require("../boxes/transport-stream/next-pes-header-store");
+const transportStreamState = () => {
+    return {
+        nextPesHeaderStore: (0, next_pes_header_store_1.makeNextPesHeaderStore)(),
+        streamBuffers: new Map(),
+    };
+};
+exports.transportStreamState = transportStreamState;

package/dist/state/video-section.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Keeps track of in which section of the file the video is playing
+ * Usually this section is in a different format and it is the only section
+ * that can be read partially
+ */
+import type { BufferIterator } from '../buffer-iterator';
+type VideoSection = {
+    start: number;
+    size: number;
+};
+export declare const videoSectionState: () => {
+    setVideoSection: (section: VideoSection) => void;
+    getVideoSection: () => VideoSection;
+    isInVideoSectionState: (iterator: BufferIterator) => "no-section-defined" | "in-section" | "outside-section";
+};
+export {};