@remotion/media-parser 4.0.249 → 4.0.251

package/dist/parse-result.d.ts

@@ -1,44 +1,11 @@
-import type { BaseBox } from './boxes/iso-base-media/base-type';
-import type { EsdsBox } from './boxes/iso-base-media/esds/esds';
-import type { FtypBox } from './boxes/iso-base-media/ftyp';
-import type { MdatBox } from './boxes/iso-base-media/mdat/mdat';
-import type { MdhdBox } from './boxes/iso-base-media/mdhd';
-import type { HdlrBox } from './boxes/iso-base-media/meta/hdlr';
-import type { IlstBox } from './boxes/iso-base-media/meta/ilst';
-import type { MoovBox } from './boxes/iso-base-media/moov/moov';
-import type { MvhdBox } from './boxes/iso-base-media/mvhd';
-import type { Av1CBox } from './boxes/iso-base-media/stsd/av1c';
-import type { AvccBox } from './boxes/iso-base-media/stsd/avcc';
-import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
-import type { CttsBox } from './boxes/iso-base-media/stsd/ctts';
-import type { HvccBox } from './boxes/iso-base-media/stsd/hvcc';
-import type { KeysBox } from './boxes/iso-base-media/stsd/keys';
-import type { MebxBox } from './boxes/iso-base-media/stsd/mebx';
-import type { PaspBox } from './boxes/iso-base-media/stsd/pasp';
-import type { StcoBox } from './boxes/iso-base-media/stsd/stco';
-import type { StscBox } from './boxes/iso-base-media/stsd/stsc';
-import type { StsdBox } from './boxes/iso-base-media/stsd/stsd';
-import type { StssBox } from './boxes/iso-base-media/stsd/stss';
-import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
-import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
-import type { TfdtBox } from './boxes/iso-base-media/tfdt';
-import type { TfhdBox } from './boxes/iso-base-media/tfhd';
-import type { TkhdBox } from './boxes/iso-base-media/tkhd';
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
-import type { TrunBox } from './boxes/iso-base-media/trun';
-import type { VoidBox } from './boxes/iso-base-media/void-box';
-import type { RiffBox } from './boxes/riff/riff-box';
-import type { TransportStreamBox } from './boxes/transport-stream/boxes';
-import type { MatroskaSegment } from './boxes/webm/segments';
+import type { AacStructure } from './containers/aac/types';
+import type { FlacStructure } from './containers/flac/types';
+import type { IsoBaseMediaBox } from './containers/iso-base-media/base-media-box';
+import type { RiffBox, RiffStructure } from './containers/riff/riff-box';
+import type { TransportStreamBox } from './containers/transport-stream/boxes';
+import type { WavStructure } from './containers/wav/types';
+import type { MatroskaSegment } from './containers/webm/segments';
 import type { MetadataEntry } from './metadata/get-metadata';
-export interface RegularBox extends BaseBox {
-    boxType: string;
-    boxSize: number;
-    children: IsoBaseMediaBox[];
-    offset: number;
-    type: 'regular-box';
-}
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox;
 type Mp3Id3Header = {
     type: 'id3-header';
     versionMajor: number;
@@ -53,10 +20,6 @@ export type IsoBaseMediaStructure = {
     type: 'iso-base-media';
     boxes: IsoBaseMediaBox[];
 };
-export type RiffStructure = {
-    type: 'riff';
-    boxes: RiffBox[];
-};
 export type MatroskaStructure = {
     type: 'matroska';
     boxes: MatroskaSegment[];
@@ -69,27 +32,11 @@ export type Mp3Structure = {
     type: 'mp3';
     boxes: Mp3Box[];
 };
-export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure | Mp3Structure;
+export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure | Mp3Structure | AacStructure | WavStructure | FlacStructure;
 export type ParseResult = {
-    status: 'done';
-} | {
-    status: 'incomplete';
     skipTo: number | null;
-    continueParsing: () => Promise<ParseResult>;
 };
 export type MatroskaParseResult = {
-    status: 'done';
-} | {
-    status: 'incomplete';
     skipTo: number | null;
-    continueParsing: () => Promise<MatroskaParseResult>;
-};
-export type ExpectSegmentParseResult = {
-    status: 'done';
-    segment: MatroskaSegment;
-} | {
-    status: 'incomplete';
-    segment: MatroskaSegment | null;
-    continueParsing: () => Promise<ExpectSegmentParseResult>;
 };
 export {};

package/dist/perform-seek.d.ts

@@ -0,0 +1,13 @@
+import type { BufferIterator } from './buffer-iterator';
+import type { LogLevel } from './log';
+import type { Reader, ReaderInterface } from './readers/reader';
+export declare const performSeek: ({ seekTo, iterator, supportsContentRange, logLevel, currentReader, readerInterface, src, signal, }: {
+    seekTo: number;
+    iterator: BufferIterator;
+    supportsContentRange: boolean;
+    logLevel: LogLevel;
+    currentReader: Reader;
+    readerInterface: ReaderInterface;
+    src: string | Blob;
+    signal: AbortSignal | undefined;
+}) => Promise<Reader>;

package/dist/perform-seek.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performSeek = void 0;
+const log_1 = require("./log");
+const performSeek = async ({ seekTo, iterator, supportsContentRange, logLevel, currentReader, readerInterface, src, signal, }) => {
+    const skippingAhead = seekTo > iterator.counter.getOffset();
+    if (!skippingAhead && !supportsContentRange) {
+        throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
+    }
+    if (skippingAhead &&
+        iterator.counter.getOffset() + iterator.bytesRemaining() >= seekTo) {
+        log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Data already fetched`);
+        iterator.discard(seekTo - iterator.counter.getOffset());
+        return currentReader;
+    }
+    if (skippingAhead && !supportsContentRange) {
+        log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Fetching but not reading all the data inbetween because Content-Range is not supported`);
+        iterator.discard(seekTo - iterator.counter.getOffset());
+        return currentReader;
+    }
+    const time = Date.now();
+    log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
+    currentReader.abort();
+    const { reader: newReader } = await readerInterface.read(src, seekTo, signal);
+    iterator.skipTo(seekTo);
+    log_1.Log.verbose(logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
+    return newReader;
+};
+exports.performSeek = performSeek;

package/dist/readers/from-node.js

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeReader = void 0;
 const fs_1 = require("fs");
-const promises_1 = require("node:fs/promises");
 const path_1 = require("path");
 const stream_1 = require("stream");
 exports.nodeReader = {
-    read: async (src, range, signal) => {
+    read: (src, range, signal) => {
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `nodeReader`');
         }
@@ -23,14 +22,14 @@ exports.nodeReader = {
         signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
             controller.abort();
         }, { once: true });
-        const stats = await (0, promises_1.stat)(src);
+        const stats = (0, fs_1.statSync)(src);
         const reader = stream_1.Readable.toWeb(stream).getReader();
         if (signal) {
             signal.addEventListener('abort', () => {
                 reader.cancel().catch(() => { });
             }, { once: true });
         }
-        return {
+        return Promise.resolve({
             reader: {
                 reader,
                 abort: () => {
@@ -41,13 +40,13 @@ exports.nodeReader = {
             contentType: null,
             name: src.split(path_1.sep).pop(),
             supportsContentRange: true,
-        };
+        });
     },
-    getLength: async (src) => {
+    getLength: (src) => {
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `nodeReader`');
         }
-        const stats = await (0, promises_1.stat)(src);
-        return stats.size;
+        const stats = (0, fs_1.statSync)(src);
+        return Promise.resolve(stats.size);
     },
 };

package/dist/readers/reader.d.ts

@@ -1,4 +1,4 @@
-type Reader = {
+export type Reader = {
     reader: ReadableStreamDefaultReader<Uint8Array>;
     abort: () => void;
 };

package/dist/register-track.d.ts

@@ -1,13 +1,13 @@
 import type { Track, VideoTrack } from './get-tracks';
-import type { ParseMediaContainer } from './options';
+import type { MediaParserContainer } from './options';
 import type { ParserState } from './state/parser-state';
 export declare const registerTrack: ({ state, track, container, }: {
     state: ParserState;
     track: Track;
-    container: ParseMediaContainer;
+    container: MediaParserContainer;
 }) => Promise<void>;
 export declare const registerVideoTrackWhenProfileIsAvailable: ({ state, track, container, }: {
     state: ParserState;
     track: VideoTrack;
-    container: ParseMediaContainer;
+    container: MediaParserContainer;
 }) => void;

package/dist/run-parse-iteration.d.ts

@@ -0,0 +1,8 @@
+import type { ParseResult } from './parse-result';
+import type { ParserState } from './state/parser-state';
+export declare const runParseIteration: ({ state, mimeType, contentLength, name, }: {
+    state: ParserState;
+    mimeType: string | null;
+    contentLength: number | null;
+    name: string | null;
+}) => Promise<ParseResult>;

package/dist/run-parse-iteration.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runParseIteration = void 0;
+const parse_aac_1 = require("./containers/aac/parse-aac");
+const parse_flac_1 = require("./containers/flac/parse-flac");
+const parse_boxes_1 = require("./containers/iso-base-media/parse-boxes");
+const parse_mp3_1 = require("./containers/mp3/parse-mp3");
+const parse_riff_1 = require("./containers/riff/parse-riff");
+const parse_transport_stream_1 = require("./containers/transport-stream/parse-transport-stream");
+const parse_wav_1 = require("./containers/wav/parse-wav");
+const parse_webm_header_1 = require("./containers/webm/parse-webm-header");
+const init_video_1 = require("./init-video");
+const runParseIteration = async ({ state, mimeType, contentLength, name, }) => {
+    if (state.iterator.bytesRemaining() === 0) {
+        return Promise.reject(new Error('no bytes'));
+    }
+    const structure = state.structure.getStructureOrNull();
+    if (structure === null) {
+        await (0, init_video_1.initVideo)({ state, mimeType, name, contentLength });
+        return { skipTo: null };
+    }
+    if (structure.type === 'riff') {
+        return (0, parse_riff_1.parseRiff)(state);
+    }
+    if (structure.type === 'mp3') {
+        return (0, parse_mp3_1.parseMp3)(state);
+    }
+    if (structure.type === 'iso-base-media') {
+        return (0, parse_boxes_1.parseIsoBaseMedia)(state);
+    }
+    if (structure.type === 'matroska') {
+        return (0, parse_webm_header_1.parseWebm)(state);
+    }
+    if (structure.type === 'transport-stream') {
+        return (0, parse_transport_stream_1.parseTransportStream)(state);
+    }
+    if (structure.type === 'wav') {
+        return (0, parse_wav_1.parseWav)(state);
+    }
+    if (structure.type === 'aac') {
+        return (0, parse_aac_1.parseAac)(state);
+    }
+    if (structure.type === 'flac') {
+        return (0, parse_flac_1.parseFlac)({ state, iterator: state.iterator });
+    }
+    return Promise.reject(new Error('Unknown video format ' + structure));
+};
+exports.runParseIteration = runParseIteration;

package/dist/samples-from-moof.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSamplesFromMoof = void 0;
-const traversal_1 = require("./boxes/iso-base-media/traversal");
+const traversal_1 = require("./containers/iso-base-media/traversal");
 const getSamplesFromTraf = (trafSegment, moofOffset) => {
     var _a, _b, _c, _d, _e, _f;
     if (trafSegment.type !== 'regular-box' || trafSegment.boxType !== 'traf') {

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

@@ -0,0 +1,13 @@
+type AacSamplePosition = {
+    offset: number;
+    index: number;
+    size: number;
+};
+export declare const aacState: () => {
+    addSample: ({ offset, size }: {
+        offset: number;
+        size: number;
+    }) => AacSamplePosition;
+    getSamples: () => AacSamplePosition[];
+};
+export {};

package/dist/state/aac-state.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aacState = void 0;
+const aacState = () => {
+    const samples = [];
+    return {
+        addSample: ({ offset, size }) => {
+            if (samples.find((s) => s.offset === offset)) {
+                throw new Error('Duplicate sample');
+            }
+            samples.push({ offset, index: samples.length, size });
+            return samples[samples.length - 1];
+        },
+        getSamples: () => samples,
+    };
+};
+exports.aacState = aacState;

package/dist/state/can-skip-tracks.d.ts

@@ -1,8 +1,15 @@
 import type { Options, ParseMediaFields } from '../options';
-export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, }: {
+import type { Structure } from '../parse-result';
+import type { StructureState } from './structure';
+export declare const needsTracksForField: ({ field, structure, }: {
+    field: keyof Options<ParseMediaFields>;
+    structure: Structure;
+}) => boolean;
+export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     fields: Options<ParseMediaFields>;
+    structure: StructureState;
 }) => {
     canSkipTracks: () => boolean;
 };

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

@@ -1,32 +1,47 @@
 "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,
-    images: 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' ||
+        field === 'sampleRate' ||
+        field === 'numberOfAudioChannels' ||
+        field === 'slowAudioBitrate' ||
+        field === 'slowVideoBitrate') {
+        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) {
@@ -34,7 +49,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

@@ -26,6 +26,10 @@ const emittedState = () => {
         slowNumberOfFrames: false,
         keyframes: false,
         images: false,
+        numberOfAudioChannels: false,
+        sampleRate: false,
+        slowAudioBitrate: false,
+        slowVideoBitrate: false,
     };
     return emittedFields;
 };

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

@@ -0,0 +1,4 @@
+export declare const flacState: () => {
+    setBlockingBitStrategy: (strategy: number) => void;
+    getBlockingBitStrategy: () => number | undefined;
+};

package/dist/state/flac-state.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flacState = void 0;
+const flacState = () => {
+    let blockingBitStrategy;
+    return {
+        setBlockingBitStrategy: (strategy) => {
+            blockingBitStrategy = strategy;
+        },
+        getBlockingBitStrategy: () => blockingBitStrategy,
+    };
+};
+exports.flacState = flacState;

package/dist/state/has-tracks-section.d.ts

@@ -1,10 +1,11 @@
 import type { Track } from '../get-tracks';
+import type { Options, ParseMediaFields } from '../options';
 import type { CanSkipTracksState } from './can-skip-tracks';
 export declare const makeTracksSectionState: (canSkipTracksState: CanSkipTracksState) => {
     hasAllTracks: () => boolean;
     setIsDone: () => void;
     addTrack: (track: Track) => void;
     getTracks: () => Track[];
-    ensureHasTracksAtEnd: () => void;
+    ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
 };
 export type TracksState = ReturnType<typeof makeTracksSectionState>;

package/dist/state/has-tracks-section.js

@@ -13,10 +13,13 @@ const makeTracksSectionState = (canSkipTracksState) => {
             tracks.push(track);
         },
         getTracks: () => tracks,
-        ensureHasTracksAtEnd: () => {
+        ensureHasTracksAtEnd: (fields) => {
             if (canSkipTracksState.canSkipTracks()) {
                 return;
             }
+            if (!fields.tracks) {
+                return;
+            }
             if (!doneWithTracks) {
                 throw new Error('Error in Media Parser: End of parsing has been reached, but no tracks have been found');
             }

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("../../containers/iso-base-media/get-sample-positions-from-track");
+const traversal_1 = require("../../containers/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/{may-skip-video-data → state}/may-skip-video-data.d.ts

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

package/dist/{may-skip-video-data → state}/may-skip-video-data.js

@@ -3,9 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.maySkipVideoData = void 0;
 const need_samples_for_fields_1 = require("./need-samples-for-fields");
 const maySkipVideoData = ({ state }) => {
-    return (state.callbacks.tracks.hasAllTracks() &&
+    const hasAllTracksAndNoCallbacks = state.callbacks.tracks.hasAllTracks() &&
         Object.values(state.callbacks.videoSampleCallbacks).length === 0 &&
-        Object.values(state.callbacks.audioSampleCallbacks).length === 0 &&
+        Object.values(state.callbacks.audioSampleCallbacks).length === 0;
+    const hasNoTrackHandlers = !state.callbacks.hasAudioTrackHandlers &&
+        !state.callbacks.hasVideoTrackHandlers;
+    const noCallbacksNeeded = hasNoTrackHandlers || hasAllTracksAndNoCallbacks;
+    return (noCallbacksNeeded &&
         !(0, need_samples_for_fields_1.needsToIterateOverSamples)({
             emittedFields: state.emittedFields,
             fields: state.fields,

package/dist/{may-skip-video-data → state}/need-samples-for-fields.js

@@ -25,6 +25,10 @@ const needsSamples = {
     mimeType: false,
     keyframes: false,
     images: false,
+    numberOfAudioChannels: false,
+    sampleRate: false,
+    slowAudioBitrate: true,
+    slowVideoBitrate: true,
 };
 const needsToIterateOverSamples = ({ fields, emittedFields, }) => {
     const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});