@remotion/media-parser 4.0.249 → 4.0.251

package/dist/init-video.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initVideo = void 0;
+const errors_1 = require("./errors");
+const log_1 = require("./log");
+const initVideo = ({ state, mimeType, name, contentLength, }) => {
+    const fileType = state.iterator.detectFileType();
+    if (fileType.type === 'riff') {
+        log_1.Log.verbose(state.logLevel, 'Detected RIFF container');
+        state.structure.setStructure({
+            type: 'riff',
+            boxes: [],
+        });
+        return;
+    }
+    if (fileType.type === 'iso-base-media') {
+        log_1.Log.verbose(state.logLevel, 'Detected ISO Base Media container');
+        state.structure.setStructure({
+            type: 'iso-base-media',
+            boxes: [],
+        });
+        return;
+    }
+    if (fileType.type === 'webm') {
+        log_1.Log.verbose(state.logLevel, 'Detected Matroska container');
+        state.structure.setStructure({
+            boxes: [],
+            type: 'matroska',
+        });
+        return;
+    }
+    if (fileType.type === 'transport-stream') {
+        log_1.Log.verbose(state.logLevel, 'Detected MPEG-2 Transport Stream');
+        state.structure.setStructure({
+            boxes: [],
+            type: 'transport-stream',
+        });
+        return;
+    }
+    if (fileType.type === 'mp3') {
+        log_1.Log.verbose(state.logLevel, 'Detected MP3');
+        const structure = {
+            boxes: [],
+            type: 'mp3',
+        };
+        state.structure.setStructure(structure);
+        return;
+    }
+    if (fileType.type === 'wav') {
+        log_1.Log.verbose(state.logLevel, 'Detected WAV');
+        const structure = {
+            boxes: [],
+            type: 'wav',
+        };
+        state.structure.setStructure(structure);
+        return;
+    }
+    if (fileType.type === 'flac') {
+        log_1.Log.verbose(state.logLevel, 'Detected FLAC');
+        const structure = {
+            boxes: [],
+            type: 'flac',
+        };
+        state.structure.setStructure(structure);
+        return;
+    }
+    if (fileType.type === 'aac') {
+        log_1.Log.verbose(state.logLevel, 'Detected AAC');
+        state.structure.setStructure({
+            type: 'aac',
+            boxes: [],
+        });
+        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',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    if (fileType.type === 'bmp' ||
+        fileType.type === 'jpeg' ||
+        fileType.type === 'png' ||
+        fileType.type === 'webp') {
+        return Promise.reject(new errors_1.IsAnImageError({
+            message: 'Image files are not supported',
+            imageType: fileType.type,
+            dimensions: fileType.dimensions,
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    if (fileType.type === 'unknown') {
+        return Promise.reject(new errors_1.IsAnUnsupportedFileTypeError({
+            message: 'Unknown file format',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    return Promise.reject(new Error('Unknown video format ' + fileType));
+};
+exports.initVideo = initVideo;

package/dist/is-audio-structure.d.ts

@@ -0,0 +1,2 @@
+import type { Structure } from './parse-result';
+export declare const isAudioStructure: (structure: Structure) => boolean;

package/dist/is-audio-structure.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAudioStructure = void 0;
+const isAudioStructure = (structure) => {
+    if (structure.type === 'mp3') {
+        return true;
+    }
+    if (structure.type === 'wav') {
+        return true;
+    }
+    if (structure.type === 'aac') {
+        return true;
+    }
+    if (structure.type === 'flac') {
+        return true;
+    }
+    if (structure.type === 'iso-base-media') {
+        return false;
+    }
+    if (structure.type === 'matroska') {
+        return false;
+    }
+    if (structure.type === 'transport-stream') {
+        return false;
+    }
+    if (structure.type === 'riff') {
+        return false;
+    }
+    throw new Error(`Unhandled structure type: ${structure}`);
+};
+exports.isAudioStructure = isAudioStructure;

package/dist/metadata/get-metadata.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasMetadata = exports.getMetadata = void 0;
-const get_metadata_from_mp3_1 = require("../boxes/mp3/get-metadata-from-mp3");
+const get_metadata_from_flac_1 = require("../containers/flac/get-metadata-from-flac");
+const get_metadata_from_mp3_1 = require("../containers/mp3/get-metadata-from-mp3");
+const get_metadata_from_wav_1 = require("../containers/wav/get-metadata-from-wav");
 const metadata_from_iso_1 = require("./metadata-from-iso");
 const metadata_from_matroska_1 = require("./metadata-from-matroska");
 const metadata_from_riff_1 = require("./metadata-from-riff");
 const getMetadata = (structure) => {
+    var _a, _b;
     if (structure.type === 'matroska') {
         return (0, metadata_from_matroska_1.getMetadataFromMatroska)(structure);
     }
@@ -22,6 +25,15 @@ const getMetadata = (structure) => {
         }
         return tags;
     }
+    if (structure.type === 'wav') {
+        return (_a = (0, get_metadata_from_wav_1.getMetadataFromWav)(structure)) !== null && _a !== void 0 ? _a : [];
+    }
+    if (structure.type === 'aac') {
+        return [];
+    }
+    if (structure.type === 'flac') {
+        return (_b = (0, get_metadata_from_flac_1.getMetadataFromFlac)(structure)) !== null && _b !== void 0 ? _b : [];
+    }
     return (0, metadata_from_iso_1.getMetadataFromIsoBase)(structure);
 };
 exports.getMetadata = getMetadata;
@@ -29,6 +41,9 @@ const hasMetadata = (structure) => {
     if (structure.type === 'mp3') {
         return (0, get_metadata_from_mp3_1.getMetadataFromMp3)(structure) !== null;
     }
+    if (structure.type === 'wav') {
+        return (0, get_metadata_from_wav_1.getMetadataFromWav)(structure) !== null;
+    }
     return false;
 };
 exports.hasMetadata = hasMetadata;

package/dist/metadata/metadata-from-iso.d.ts

@@ -1,4 +1,5 @@
-import type { IsoBaseMediaStructure, RegularBox } from '../parse-result';
+import type { RegularBox } from '../containers/iso-base-media/base-media-box';
+import type { IsoBaseMediaStructure } from '../parse-result';
 import type { MetadataEntry } from './get-metadata';
 export declare const parseIsoMetaBox: (meta: RegularBox, trackId: number | null) => MetadataEntry[];
 export declare const getMetadataFromIsoBase: (isoBase: IsoBaseMediaStructure) => MetadataEntry[];

package/dist/metadata/metadata-from-iso.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMetadataFromIsoBase = exports.parseIsoMetaBox = void 0;
-const traversal_1 = require("../boxes/iso-base-media/traversal");
+const traversal_1 = require("../containers/iso-base-media/traversal");
 const truthy_1 = require("../truthy");
 /**
  *

package/dist/metadata/metadata-from-matroska.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMetadataFromMatroska = void 0;
-const traversal_1 = require("../boxes/webm/traversal");
+const traversal_1 = require("../containers/webm/traversal");
 const removeEndZeroes = (value) => {
     return value.endsWith('\u0000') ? removeEndZeroes(value.slice(0, -1)) : value;
 };

package/dist/metadata/metadata-from-riff.d.ts

@@ -1,3 +1,3 @@
-import type { RiffStructure } from '../parse-result';
+import type { RiffStructure } from '../containers/riff/riff-box';
 import type { MetadataEntry } from './get-metadata';
 export declare const getMetadataFromRiff: (structure: RiffStructure) => MetadataEntry[];

package/dist/options.d.ts

@@ -32,7 +32,11 @@ export type ParseMediaFields = {
     keyframes: boolean;
     slowKeyframes: boolean;
     slowNumberOfFrames: boolean;
+    slowVideoBitrate: boolean;
+    slowAudioBitrate: boolean;
     images: boolean;
+    sampleRate: boolean;
+    numberOfAudioChannels: boolean;
 };
 export type AllParseMediaFields = {
     dimensions: true;
@@ -58,6 +62,10 @@ export type AllParseMediaFields = {
     keyframes: true;
     slowKeyframes: true;
     images: true;
+    sampleRate: true;
+    numberOfAudioChannels: true;
+    slowVideoBitrate: true;
+    slowAudioBitrate: true;
 };
 export type AllOptions<Fields extends ParseMediaFields> = {
     dimensions: Fields['dimensions'];
@@ -83,13 +91,17 @@ export type AllOptions<Fields extends ParseMediaFields> = {
     slowKeyframes: Fields['slowKeyframes'];
     slowNumberOfFrames: Fields['slowNumberOfFrames'];
     images: Fields['images'];
+    sampleRate: Fields['sampleRate'];
+    numberOfAudioChannels: Fields['numberOfAudioChannels'];
+    slowVideoBitrate: Fields['slowVideoBitrate'];
+    slowAudioBitrate: Fields['slowAudioBitrate'];
 };
 export type Options<Fields extends ParseMediaFields> = Partial<AllOptions<Fields>>;
 export type TracksField = {
     videoTracks: VideoTrack[];
     audioTracks: AudioTrack[];
 };
-export type ParseMediaContainer = 'mp4' | 'webm' | 'avi' | 'transport-stream' | 'mp3';
+export type MediaParserContainer = 'mp4' | 'webm' | 'avi' | 'transport-stream' | 'mp3' | 'aac' | 'flac' | 'wav';
 export type MediaParserKeyframe = {
     positionInBytes: number;
     sizeInBytes: number;
@@ -97,31 +109,36 @@ export type MediaParserKeyframe = {
     decodingTimeInSeconds: number;
     trackId: number;
 };
-export interface ParseMediaCallbacks {
-    onDimensions?: (dimensions: Dimensions | null) => void;
-    onDurationInSeconds?: (durationInSeconds: number | null) => void;
-    onSlowDurationInSeconds?: (durationInSeconds: number) => void;
-    onSlowFps?: (fps: number) => void;
-    onStructure?: (structure: Structure) => void;
-    onFps?: (fps: number | null) => void;
-    onVideoCodec?: (codec: MediaParserVideoCodec | null) => void;
-    onAudioCodec?: (codec: MediaParserAudioCodec | null) => void;
-    onTracks?: (tracks: TracksField) => void;
-    onRotation?: (rotation: number | null) => void;
-    onUnrotatedDimensions?: (dimensions: Dimensions | null) => void;
-    onInternalStats?: (internalStats: InternalStats) => void;
-    onSize?: (size: number | null) => void;
-    onName?: (name: string) => void;
-    onContainer?: (container: ParseMediaContainer) => void;
-    onIsHdr?: (isHdr: boolean) => void;
-    onMetadata?: (metadata: MetadataEntry[]) => void;
-    onLocation?: (location: MediaParserLocation | null) => void;
-    onMimeType?: (mimeType: string | null) => void;
-    onKeyframes?: (keyframes: MediaParserKeyframe[] | null) => void;
-    onSlowKeyframes?: (keyframes: MediaParserKeyframe[]) => void;
-    onSlowNumberOfFrames?: (samples: number) => void;
-    onImages?: (images: MediaParserEmbeddedImage[]) => void;
-}
+export type MandatoryParseMediaCallbacks = {
+    onDimensions: null | ((dimensions: Dimensions | null) => void);
+    onDurationInSeconds: null | ((durationInSeconds: number | null) => void);
+    onSlowDurationInSeconds: null | ((durationInSeconds: number) => void);
+    onSlowFps: null | ((fps: number) => void);
+    onStructure: null | ((structure: Structure) => void);
+    onFps: null | ((fps: number | null) => void);
+    onVideoCodec: null | ((codec: MediaParserVideoCodec | null) => void);
+    onAudioCodec: null | ((codec: MediaParserAudioCodec | null) => void);
+    onTracks: null | ((tracks: TracksField) => void);
+    onRotation: null | ((rotation: number | null) => void);
+    onUnrotatedDimensions: null | ((dimensions: Dimensions | null) => void);
+    onInternalStats: null | ((internalStats: InternalStats) => void);
+    onSize: null | ((size: number | null) => void);
+    onName: null | ((name: string) => void);
+    onContainer: null | ((container: MediaParserContainer) => void);
+    onIsHdr: null | ((isHdr: boolean) => void);
+    onMetadata: null | ((metadata: MetadataEntry[]) => void);
+    onLocation: null | ((location: MediaParserLocation | null) => void);
+    onMimeType: null | ((mimeType: string | null) => void);
+    onKeyframes: null | ((keyframes: MediaParserKeyframe[] | null) => void);
+    onSlowKeyframes: null | ((keyframes: MediaParserKeyframe[]) => void);
+    onSlowNumberOfFrames: null | ((samples: number) => void);
+    onImages: null | ((images: MediaParserEmbeddedImage[]) => void);
+    onSampleRate: null | ((sampleRate: number | null) => void);
+    onNumberOfAudioChannels: null | ((numberOfChannels: number | null) => void);
+    onSlowVideoBitrate: null | ((videoBitrate: number | null) => void);
+    onSlowAudioBitrate: null | ((audioBitrate: number | null) => void);
+};
+export type ParseMediaCallbacks = Partial<MandatoryParseMediaCallbacks>;
 export interface ParseMediaData {
     dimensions: Dimensions | null;
     durationInSeconds: number | null;
@@ -140,33 +157,42 @@ export interface ParseMediaData {
     name: string;
     metadata: MetadataEntry[];
     location: MediaParserLocation | null;
-    container: ParseMediaContainer;
+    container: MediaParserContainer;
     mimeType: string | null;
     keyframes: MediaParserKeyframe[] | null;
     slowKeyframes: MediaParserKeyframe[];
     slowNumberOfFrames: number;
     images: MediaParserEmbeddedImage[];
+    sampleRate: number | null;
+    numberOfAudioChannels: number | null;
+    slowVideoBitrate: number | null;
+    slowAudioBitrate: number | null;
 }
 export type ParseMediaResult<T extends Partial<ParseMediaFields>> = {
     [K in keyof T]: T[K] extends true ? K extends keyof ParseMediaData ? ParseMediaData[K] : never : never;
 };
-export type ParseMediaDynamicOptions<F extends Options<ParseMediaFields>> = {
-    fields?: F;
-} & ParseMediaCallbacks;
 export type ParseMediaProgress = {
     bytes: number;
     percentage: number | null;
     totalBytes: number | null;
 };
 export type ParseMediaOnProgress = (progress: ParseMediaProgress) => void | Promise<void>;
+type OptionalParseMediaParams<F extends Options<ParseMediaFields>> = {
+    reader: ReaderInterface;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    signal: AbortSignal | undefined;
+    logLevel: LogLevel;
+    onParseProgress: ParseMediaOnProgress | null;
+    progressIntervalInMs: number | null;
+    fields: F | null;
+} & MandatoryParseMediaCallbacks;
+export type InternalParseMediaOptions<F extends Options<ParseMediaFields>> = {
+    src: string | Blob;
+} & OptionalParseMediaParams<F>;
 export type ParseMediaOptions<F extends Options<ParseMediaFields>> = {
     src: string | Blob;
-    reader?: ReaderInterface;
-    onAudioTrack?: OnAudioTrack;
-    onVideoTrack?: OnVideoTrack;
-    signal?: AbortSignal;
-    logLevel?: LogLevel;
-    onParseProgress?: ParseMediaOnProgress;
-    progressIntervalInMs?: number;
-} & ParseMediaDynamicOptions<F>;
+} & Partial<OptionalParseMediaParams<F>>;
+export type InternalParseMedia = <F extends Options<ParseMediaFields>>(options: InternalParseMediaOptions<F>) => Promise<ParseMediaResult<F>>;
 export type ParseMedia = <F extends Options<ParseMediaFields>>(options: ParseMediaOptions<F>) => Promise<ParseMediaResult<F>>;
+export {};

package/dist/parse-media.js

@@ -6,11 +6,12 @@ const emit_available_info_1 = require("./emit-available-info");
 const get_fields_from_callbacks_1 = require("./get-fields-from-callbacks");
 const has_all_info_1 = require("./has-all-info");
 const log_1 = require("./log");
-const parse_video_1 = require("./parse-video");
+const perform_seek_1 = require("./perform-seek");
 const from_fetch_1 = require("./readers/from-fetch");
+const run_parse_iteration_1 = require("./run-parse-iteration");
 const parser_state_1 = require("./state/parser-state");
 const throttled_progress_1 = require("./throttled-progress");
-const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', onParseProgress: onParseProgressDoNotCallDirectly, progressIntervalInMs, ...more }) {
+const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue, reader, onAudioTrack, onVideoTrack, signal, logLevel, onParseProgress: onParseProgressDoNotCallDirectly, progressIntervalInMs, ...more }) {
     var _a;
     let parseResult = null;
     const fieldsInReturnValue = _fieldsInReturnValue !== null && _fieldsInReturnValue !== void 0 ? _fieldsInReturnValue : {};
@@ -18,24 +19,40 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         fields: fieldsInReturnValue,
         callbacks: more,
     });
-    const { reader, contentLength, name, contentType, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
+    const { reader: readerInstance, contentLength, name, contentType, supportsContentRange: readerSupportsContentRange, } = await reader.read(src, null, signal);
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), contentLength !== null && contentLength !== void 0 ? contentLength : 1000000000);
+    if (contentLength === null) {
+        throw new Error('Media was passed with no content length. This is currently not supported. Ensure the media has a "Content-Length" HTTP header.');
+    }
     const supportsContentRange = readerSupportsContentRange &&
         !(typeof process !== 'undefined' &&
             typeof process.env !== 'undefined' &&
             process.env.DISABLE_CONTENT_RANGE === 'true');
+    const hasAudioTrackHandlers = Boolean(onAudioTrack);
+    const hasVideoTrackHandlers = Boolean(onVideoTrack);
+    if (!hasAudioTrackHandlers &&
+        !hasVideoTrackHandlers &&
+        Object.values(fields).every((v) => !v)) {
+        log_1.Log.warn(logLevel, new Error('Warning - No `fields` and no `on*` callbacks were passed to `parseMedia()`. Specify the data you would like to retrieve.'));
+    }
+    let timeIterating = 0;
+    let timeReadingData = 0;
+    let timeSeeking = 0;
+    let timeCheckingIfDone = 0;
+    let timeFreeingData = 0;
     const state = (0, parser_state_1.makeParserState)({
-        hasAudioTrackHandlers: Boolean(onAudioTrack),
-        hasVideoTrackHandlers: Boolean(onVideoTrack),
+        hasAudioTrackHandlers,
+        hasVideoTrackHandlers,
         signal,
-        getIterator: () => iterator,
+        iterator,
         fields,
         onAudioTrack: onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : null,
         onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
         supportsContentRange,
         contentLength,
+        logLevel,
     });
-    let currentReader = reader;
+    let currentReader = readerInstance;
     const returnValue = {};
     const moreFields = more;
     const throttledState = (0, throttled_progress_1.throttledStateUpdate)({
@@ -53,7 +70,6 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
             hasInfo: availableInfo,
             callbacks: moreFields,
             fieldsInReturnValue,
-            parseResult,
             state,
             returnValue,
             contentLength,
@@ -62,22 +78,28 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         });
     };
     const checkIfDone = () => {
-        if ((0, has_all_info_1.hasAllInfo)({
+        const startCheck = Date.now();
+        const hasAll = (0, has_all_info_1.hasAllInfo)({
             fields,
             state,
-        })) {
+        });
+        timeCheckingIfDone += Date.now() - startCheck;
+        if (hasAll) {
             log_1.Log.verbose(logLevel, 'Got all info, skipping to the end.');
             if (contentLength !== null) {
                 state.increaseSkippedBytes(contentLength - iterator.counter.getOffset());
             }
             return true;
         }
+        if (iterator.counter.getOffset() === contentLength) {
+            log_1.Log.verbose(logLevel, 'Reached end of file');
+            return true;
+        }
         return false;
     };
     triggerInfoEmit();
-    let didProgress = false;
-    while (!checkIfDone() &&
-        (parseResult === null || parseResult.status === 'incomplete')) {
+    let iterationWithThisOffset = 0;
+    while (!checkIfDone()) {
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             throw new Error('Aborted');
         }
@@ -87,14 +109,20 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
             if (result.value) {
                 iterator.addData(result.value);
             }
+            return result.done;
         };
+        const readStart = Date.now();
         while (iterator.bytesRemaining() < 0) {
-            await fetchMoreData();
+            const done = await fetchMoreData();
+            if (done) {
+                break;
+            }
         }
         const hasBigBuffer = iterator.bytesRemaining() > 100000;
-        if (!didProgress || !hasBigBuffer) {
+        if (iterationWithThisOffset > 0 || !hasBigBuffer) {
             await fetchMoreData();
         }
+        timeReadingData += Date.now() - readStart;
         (_a = throttledState.update) === null || _a === void 0 ? void 0 : _a.call(throttledState, () => ({
             bytes: iterator.counter.getOffset(),
             percentage: contentLength
@@ -103,40 +131,49 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
             totalBytes: contentLength,
         }));
         triggerInfoEmit();
-        if (parseResult && parseResult.status === 'incomplete') {
-            log_1.Log.trace(logLevel, 'Continuing parsing of file, currently at position', iterator.counter.getOffset());
-            parseResult = await parseResult.continueParsing();
-        }
-        else {
-            parseResult = await (0, parse_video_1.parseVideo)({
-                iterator,
-                state,
-                signal: signal !== null && signal !== void 0 ? signal : null,
-                logLevel,
-                fields,
-                mimeType: contentType,
-                contentLength,
-                name,
-            });
+        if (iterationWithThisOffset > 300) {
+            throw new Error('Infinite loop detected. The parser is not progressing. This is likely a bug in the parser.');
         }
-        if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
+        log_1.Log.trace(logLevel, `Continuing parsing of file, currently at position ${iterator.counter.getOffset()}/${contentLength} (0x${iterator.counter.getOffset().toString(16)})`);
+        const start = Date.now();
+        parseResult = await (0, run_parse_iteration_1.runParseIteration)({
+            state,
+            mimeType: contentType,
+            contentLength,
+            name,
+        });
+        timeIterating += Date.now() - start;
+        if (parseResult.skipTo !== null) {
             state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
         }
-        if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
-            if (!supportsContentRange) {
-                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-            }
+        if (parseResult.skipTo !== null) {
             if (parseResult.skipTo === contentLength) {
                 log_1.Log.verbose(logLevel, 'Skipped to end of file, not fetching.');
                 break;
             }
-            log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${parseResult.skipTo}`);
-            currentReader.abort();
-            const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
-            currentReader = newReader;
-            iterator.skipTo(parseResult.skipTo, true);
+            const seekStart = Date.now();
+            currentReader = await (0, perform_seek_1.performSeek)({
+                iterator,
+                seekTo: parseResult.skipTo,
+                supportsContentRange,
+                currentReader,
+                logLevel,
+                readerInterface: reader,
+                signal,
+                src,
+            });
+            timeSeeking += Date.now() - seekStart;
+        }
+        const didProgress = iterator.counter.getOffset() > offsetBefore;
+        if (!didProgress) {
+            iterationWithThisOffset++;
         }
-        didProgress = iterator.counter.getOffset() > offsetBefore;
+        const timeFreeStart = Date.now();
+        const bytesRemoved = iterator.removeBytesRead(false);
+        if (bytesRemoved) {
+            log_1.Log.verbose(logLevel, `Freed ${bytesRemoved} bytes`);
+        }
+        timeFreeingData += Date.now() - timeFreeStart;
     }
     log_1.Log.verbose(logLevel, 'Finished parsing file');
     // Force assign
@@ -149,16 +186,61 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         }, {}),
         callbacks: moreFields,
         fieldsInReturnValue,
-        parseResult,
         state,
         returnValue,
         contentLength,
         mimeType: contentType,
         name,
     });
+    log_1.Log.verbose(logLevel, `Time iterating over file: ${timeIterating}ms`);
+    log_1.Log.verbose(logLevel, `Time fetching data: ${timeReadingData}ms`);
+    log_1.Log.verbose(logLevel, `Time seeking: ${timeSeeking}ms`);
+    log_1.Log.verbose(logLevel, `Time checking if done: ${timeCheckingIfDone}ms`);
+    log_1.Log.verbose(logLevel, `Time freeing data: ${timeFreeingData}ms`);
     currentReader.abort();
     iterator === null || iterator === void 0 ? void 0 : iterator.destroy();
-    state.callbacks.tracks.ensureHasTracksAtEnd();
+    state.callbacks.tracks.ensureHasTracksAtEnd(fields);
     return returnValue;
 };
+const parseMedia = (options) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10;
+    return internalParseMedia({
+        fields: (_a = options.fields) !== null && _a !== void 0 ? _a : null,
+        logLevel: (_b = options.logLevel) !== null && _b !== void 0 ? _b : 'info',
+        onAudioCodec: (_c = options.onAudioCodec) !== null && _c !== void 0 ? _c : null,
+        onAudioTrack: (_d = options.onAudioTrack) !== null && _d !== void 0 ? _d : null,
+        onContainer: (_e = options.onContainer) !== null && _e !== void 0 ? _e : null,
+        onDimensions: (_f = options.onDimensions) !== null && _f !== void 0 ? _f : null,
+        onDurationInSeconds: (_g = options.onDurationInSeconds) !== null && _g !== void 0 ? _g : null,
+        onFps: (_h = options.onFps) !== null && _h !== void 0 ? _h : null,
+        onImages: (_j = options.onImages) !== null && _j !== void 0 ? _j : null,
+        onInternalStats: (_k = options.onInternalStats) !== null && _k !== void 0 ? _k : null,
+        onIsHdr: (_l = options.onIsHdr) !== null && _l !== void 0 ? _l : null,
+        onKeyframes: (_m = options.onKeyframes) !== null && _m !== void 0 ? _m : null,
+        onLocation: (_o = options.onLocation) !== null && _o !== void 0 ? _o : null,
+        onMetadata: (_p = options.onMetadata) !== null && _p !== void 0 ? _p : null,
+        onMimeType: (_q = options.onMimeType) !== null && _q !== void 0 ? _q : null,
+        onName: (_r = options.onName) !== null && _r !== void 0 ? _r : null,
+        onNumberOfAudioChannels: (_s = options.onNumberOfAudioChannels) !== null && _s !== void 0 ? _s : null,
+        onParseProgress: (_t = options.onParseProgress) !== null && _t !== void 0 ? _t : null,
+        onRotation: (_u = options.onRotation) !== null && _u !== void 0 ? _u : null,
+        onSampleRate: (_v = options.onSampleRate) !== null && _v !== void 0 ? _v : null,
+        onSize: (_w = options.onSize) !== null && _w !== void 0 ? _w : null,
+        onSlowAudioBitrate: (_x = options.onSlowAudioBitrate) !== null && _x !== void 0 ? _x : null,
+        onSlowDurationInSeconds: (_y = options.onSlowDurationInSeconds) !== null && _y !== void 0 ? _y : null,
+        onSlowFps: (_z = options.onSlowFps) !== null && _z !== void 0 ? _z : null,
+        onSlowKeyframes: (_0 = options.onSlowKeyframes) !== null && _0 !== void 0 ? _0 : null,
+        onSlowNumberOfFrames: (_1 = options.onSlowNumberOfFrames) !== null && _1 !== void 0 ? _1 : null,
+        onSlowVideoBitrate: (_2 = options.onSlowVideoBitrate) !== null && _2 !== void 0 ? _2 : null,
+        onStructure: (_3 = options.onStructure) !== null && _3 !== void 0 ? _3 : null,
+        onTracks: (_4 = options.onTracks) !== null && _4 !== void 0 ? _4 : null,
+        onUnrotatedDimensions: (_5 = options.onUnrotatedDimensions) !== null && _5 !== void 0 ? _5 : null,
+        onVideoCodec: (_6 = options.onVideoCodec) !== null && _6 !== void 0 ? _6 : null,
+        onVideoTrack: (_7 = options.onVideoTrack) !== null && _7 !== void 0 ? _7 : null,
+        progressIntervalInMs: (_8 = options.progressIntervalInMs) !== null && _8 !== void 0 ? _8 : null,
+        reader: (_9 = options.reader) !== null && _9 !== void 0 ? _9 : from_fetch_1.fetchReader,
+        signal: (_10 = options.signal) !== null && _10 !== void 0 ? _10 : undefined,
+        src: options.src,
+    });
+};
 exports.parseMedia = parseMedia;