@remotion/media-parser 4.0.251 → 4.0.252

package/dist/index.d.ts

@@ -4,15 +4,17 @@ export { MatroskaElement } from './containers/webm/segments/all-segments';
 export { IsAGifError, IsAnImageError, IsAnUnsupportedAudioTypeError, IsAnUnsupportedFileTypeError, IsAPdfError, } from './errors';
 export type { SamplePosition } from './get-sample-positions';
 export { MetadataEntry } from './metadata/get-metadata';
-export { MediaParserKeyframe } from './options';
+export { MediaParserKeyframe, ParseMediaSrc } from './options';
 export type { MediaParserEmbeddedImage } from './state/images';
 export { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
+export { downloadAndParseMedia } from './download-and-parse-media';
 export type { MediaParserContainer, Options, ParseMediaCallbacks, ParseMediaFields, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, TracksField, } from './options';
 export { parseMedia } from './parse-media';
 export { AudioOrVideoSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, } from './webcodec-sample-types';
 export { Dimensions } from './get-dimensions';
 export { MediaParserLocation } from './get-location';
 export type { ReaderInterface } from './readers/reader';
+export type { CreateContent, Writer, WriterInterface } from './writers/writer';
 export declare const MediaParserInternals: {
     Log: {
         trace: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
@@ -21,10 +23,11 @@ export declare const MediaParserInternals: {
         warn: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
         error: (...args: Parameters<typeof console.log>) => void;
     };
-    createAacCodecPrivate: ({ audioObjectType, sampleRate, channelConfiguration, }: {
+    createAacCodecPrivate: ({ audioObjectType, sampleRate, channelConfiguration, codecPrivate, }: {
         audioObjectType: number;
         sampleRate: number;
         channelConfiguration: number;
+        codecPrivate: Uint8Array | null;
     }) => Uint8Array;
     matroskaElements: {
         readonly Header: "0x1a45dfa3";
@@ -667,7 +670,10 @@ export declare const MediaParserInternals: {
         getBits: (bits: number) => number;
         bytesRemaining: () => number;
         leb128: () => number;
-        removeBytesRead: (force: boolean) => number | undefined;
+        removeBytesRead: (force: boolean, mode: import("./options").ParseMediaMode) => {
+            bytesRemoved: number;
+            removedData: Uint8Array | null;
+        };
         discard: (length: number) => void;
         getEightByteNumber: (littleEndian?: boolean) => number;
         getFourByteNumber: () => number;
@@ -719,112 +725,22 @@ export declare const MediaParserInternals: {
         size: number;
         state: import("./state/parser-state").ParserState;
     }) => Promise<import("./containers/iso-base-media/stsd/stsd").StsdBox>;
-    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, iterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }: {
+    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, }: {
         hasAudioTrackHandlers: boolean;
         hasVideoTrackHandlers: boolean;
         signal: AbortSignal | undefined;
-        iterator: import("./buffer-iterator").BufferIterator;
         fields: import("./options").Options<import("./options").ParseMediaFields>;
-        supportsContentRange: boolean;
         onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
         onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
-        contentLength: number | null;
+        contentLength: number;
         logLevel: LogLevel;
+        mode: import("./options").ParseMediaMode;
+        src: import("./options").ParseMediaSrc;
+        readerInterface: import("./readers/reader").ReaderInterface;
+        onDiscardedData: import("./options").OnDiscardedData | null;
     }) => {
-        riff: {
-            getAvcProfile: () => import("./state/parser-state").SpsAndPps | null;
-            onProfile: (profile: import("./state/parser-state").SpsAndPps) => Promise<void>;
-            registerOnAvcProfileCallback: (callback: (profile: import("./state/parser-state").SpsAndPps) => Promise<void>) => void;
-            getNextTrackIndex: () => number;
-            incrementNextTrackIndex: () => void;
-        };
-        transportStream: {
-            nextPesHeaderStore: {
-                setNextPesHeader: (pesHeader: import("./containers/transport-stream/parse-pes").PacketPes) => void;
-                getNextPesHeader: () => import("./containers/transport-stream/parse-pes").PacketPes;
-            };
-            streamBuffers: Map<number, import("./containers/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
-        };
-        webm: {
-            onTrackEntrySegment: import("./containers/webm/segments").OnTrackEntrySegment;
-            getTrackInfoByNumber: (id: number) => import("./containers/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("./state/webm").SegmentSection, "index">) => void;
-            addCluster: (cluster: import("./state/webm").ClusterSection) => void;
-            isInsideSegment: (iterator: import("./buffer-iterator").BufferIterator) => import("./state/webm").SegmentSection | null;
-            isInsideCluster: (iterator: import("./buffer-iterator").BufferIterator) => import("./state/webm").ClusterSection | null;
-        };
-        iso: {
-            getShouldReturnToVideoSectionAfterEnd: () => boolean;
-            setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
-            flatSamples: {
-                getSamples: () => import("./state/iso-base-media/cached-sample-positions").FlatSample[] | null;
-                setSamples: (samples: import("./state/iso-base-media/cached-sample-positions").FlatSample[]) => void;
-            };
-        };
-        mp3Info: {
-            getMp3Info: () => import("./state/mp3").Mp3Info | null;
-            setMp3Info: (info: import("./state/mp3").Mp3Info) => void;
-        };
-        aac: {
-            addSample: ({ offset, size }: {
-                offset: number;
-                size: number;
-            }) => {
-                offset: number;
-                index: number;
-                size: number;
-            };
-            getSamples: () => {
-                offset: number;
-                index: number;
-                size: number;
-            }[];
-        };
-        flac: {
-            setBlockingBitStrategy: (strategy: number) => void;
-            getBlockingBitStrategy: () => number | undefined;
-        };
-        callbacks: {
-            registerVideoSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnVideoSample | null) => Promise<void>;
-            onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
-            getSamplesForTrack: (trackId: number) => number;
-            onVideoSample: (trackId: number, videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
-            canSkipTracksState: {
-                canSkipTracks: () => boolean;
-            };
-            registerAudioSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnAudioSample | null) => Promise<void>;
-            tracks: {
-                hasAllTracks: () => boolean;
-                setIsDone: () => void;
-                addTrack: (track: import("./get-tracks").Track) => void;
-                getTracks: () => import("./get-tracks").Track[];
-                ensureHasTracksAtEnd: (fields: import("./options").Options<import("./options").ParseMediaFields>) => void;
-            };
-            audioSampleCallbacks: Record<number, import("./webcodec-sample-types").OnAudioSample>;
-            videoSampleCallbacks: Record<number, import("./webcodec-sample-types").OnVideoSample>;
-            hasAudioTrackHandlers: boolean;
-            hasVideoTrackHandlers: boolean;
-        };
-        getInternalStats: () => import("./state/parser-state").InternalStats;
-        getSkipBytes: () => number;
-        increaseSkippedBytes: (bytes: number) => void;
-        keyframes: {
-            addKeyframe: (keyframe: import("./options").MediaParserKeyframe) => void;
-            getKeyframes: () => import("./options").MediaParserKeyframe[];
-        };
-        structure: {
-            getStructureOrNull: () => import("./parse-result").Structure | null;
-            getStructure: () => import("./parse-result").Structure;
-            setStructure: (value: import("./parse-result").Structure) => void;
-        };
         onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
         onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
-        supportsContentRange: boolean;
         emittedFields: import("./options").AllOptions<import("./options").ParseMediaFields>;
         fields: Partial<import("./options").AllOptions<import("./options").ParseMediaFields>>;
         slowDurationAndFps: {
@@ -836,7 +752,7 @@ export declare const MediaParserInternals: {
             getAudioBitrate: () => number | null;
             getVideoBitrate: () => number | null;
         };
-        contentLength: number | null;
+        contentLength: number;
         images: {
             images: import("./state/images").MediaParserEmbeddedImage[];
             addImage: (image: import("./state/images").MediaParserEmbeddedImage) => void;
@@ -864,7 +780,10 @@ export declare const MediaParserInternals: {
             getBits: (bits: number) => number;
             bytesRemaining: () => number;
             leb128: () => number;
-            removeBytesRead: (force: boolean) => number | undefined;
+            removeBytesRead: (force: boolean, mode: import("./options").ParseMediaMode) => {
+                bytesRemoved: number;
+                removedData: Uint8Array | null;
+            };
             discard: (length: number) => void;
             getEightByteNumber: (littleEndian?: boolean) => number;
             getFourByteNumber: () => number;
@@ -911,6 +830,113 @@ export declare const MediaParserInternals: {
             };
             getFlacCodecNumber: () => number;
         };
+        signal: AbortSignal | undefined;
+        mode: import("./options").ParseMediaMode;
+        eventLoop: {
+            eventLoopBreakIfNeeded: () => Promise<void>;
+        };
+        src: import("./options").ParseMediaSrc;
+        readerInterface: import("./readers/reader").ReaderInterface;
+        discardReadBytes: (force: boolean) => Promise<void>;
+        getStructureOrNull: () => import("./parse-result").Structure | null;
+        getStructure: () => import("./parse-result").Structure;
+        setStructure: (value: import("./parse-result").Structure) => void;
+        getFlacStructure: () => import("./containers/flac/types").FlacStructure;
+        getIsoStructure: () => import("./parse-result").IsoBaseMediaStructure;
+        getMp3Structure: () => import("./parse-result").Mp3Structure;
+        getRiffStructure: () => import("./containers/riff/riff-box").RiffStructure;
+        getTsStructure: () => import("./parse-result").TransportStreamStructure;
+        getWavStructure: () => import("./containers/wav/types").WavStructure;
+        getMatroskaStructure: () => import("./parse-result").MatroskaStructure;
+        riff: {
+            getAvcProfile: () => import("./state/parser-state").SpsAndPps | null;
+            onProfile: (profile: import("./state/parser-state").SpsAndPps) => Promise<void>;
+            registerOnAvcProfileCallback: (callback: (profile: import("./state/parser-state").SpsAndPps) => Promise<void>) => void;
+            getNextTrackIndex: () => number;
+            incrementNextTrackIndex: () => void;
+        };
+        transportStream: {
+            nextPesHeaderStore: {
+                setNextPesHeader: (pesHeader: import("./containers/transport-stream/parse-pes").PacketPes) => void;
+                getNextPesHeader: () => import("./containers/transport-stream/parse-pes").PacketPes;
+            };
+            streamBuffers: Map<number, import("./containers/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
+        };
+        webm: {
+            onTrackEntrySegment: import("./containers/webm/segments").OnTrackEntrySegment;
+            getTrackInfoByNumber: (id: number) => import("./containers/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("./state/webm").SegmentSection, "index">) => void;
+            addCluster: (cluster: import("./state/webm").ClusterSection) => void;
+            isInsideSegment: (iterator: import("./buffer-iterator").BufferIterator) => import("./state/webm").SegmentSection | null;
+            isInsideCluster: (iterator: import("./buffer-iterator").BufferIterator) => import("./state/webm").ClusterSection | null;
+        };
+        iso: {
+            flatSamples: {
+                getSamples: () => import("./state/iso-base-media/cached-sample-positions").FlatSample[] | null;
+                setSamples: (samples: import("./state/iso-base-media/cached-sample-positions").FlatSample[]) => void;
+            };
+            moov: {
+                setMoovBox: (moov: import("./containers/iso-base-media/moov/moov").MoovBox) => void;
+                getMoovBox: () => import("./containers/iso-base-media/moov/moov").MoovBox | null;
+            };
+        };
+        mp3Info: {
+            getMp3Info: () => import("./state/mp3").Mp3Info | null;
+            setMp3Info: (info: import("./state/mp3").Mp3Info) => void;
+        };
+        aac: {
+            addSample: ({ offset, size }: {
+                offset: number;
+                size: number;
+            }) => {
+                offset: number;
+                index: number;
+                size: number;
+            };
+            getSamples: () => {
+                offset: number;
+                index: number;
+                size: number;
+            }[];
+        };
+        flac: {
+            setBlockingBitStrategy: (strategy: number) => void;
+            getBlockingBitStrategy: () => number | undefined;
+        };
+        callbacks: {
+            registerVideoSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnVideoSample | null) => Promise<void>;
+            onAudioSample: (trackId: number, audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
+            getSamplesForTrack: (trackId: number) => number;
+            onVideoSample: (trackId: number, videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
+            canSkipTracksState: {
+                canSkipTracks: () => boolean;
+            };
+            registerAudioSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnAudioSample | null) => Promise<void>;
+            tracks: {
+                hasAllTracks: () => boolean;
+                getIsDone: () => boolean;
+                setIsDone: (logLevel: LogLevel) => void;
+                addTrack: (track: import("./get-tracks").Track) => void;
+                getTracks: () => import("./get-tracks").Track[];
+                ensureHasTracksAtEnd: (fields: import("./options").Options<import("./options").ParseMediaFields>) => void;
+            };
+            audioSampleCallbacks: Record<number, import("./webcodec-sample-types").OnAudioSample>;
+            videoSampleCallbacks: Record<number, import("./webcodec-sample-types").OnVideoSample>;
+            hasAudioTrackHandlers: boolean;
+            hasVideoTrackHandlers: boolean;
+        };
+        getInternalStats: () => import("./state/parser-state").InternalStats;
+        getSkipBytes: () => number;
+        increaseSkippedBytes: (bytes: number) => void;
+        keyframes: {
+            addKeyframe: (keyframe: import("./options").MediaParserKeyframe) => void;
+            getKeyframes: () => import("./options").MediaParserKeyframe[];
+        };
     };
     processSample: ({ state, }: {
         state: import("./state/parser-state").ParserState;

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = exports.MediaParserInternals = exports.parseMedia = exports.IsAPdfError = exports.IsAnUnsupportedFileTypeError = exports.IsAnUnsupportedAudioTypeError = exports.IsAnImageError = exports.IsAGifError = void 0;
+exports.VERSION = exports.MediaParserInternals = exports.parseMedia = exports.downloadAndParseMedia = exports.IsAPdfError = exports.IsAnUnsupportedFileTypeError = exports.IsAnUnsupportedAudioTypeError = exports.IsAnImageError = exports.IsAGifError = void 0;
 const aac_codecprivate_1 = require("./aac-codecprivate");
 const buffer_iterator_1 = require("./buffer-iterator");
 const ftyp_1 = require("./containers/iso-base-media/ftyp");
@@ -18,6 +18,8 @@ Object.defineProperty(exports, "IsAnImageError", { enumerable: true, get: functi
 Object.defineProperty(exports, "IsAnUnsupportedAudioTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedAudioTypeError; } });
 Object.defineProperty(exports, "IsAnUnsupportedFileTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedFileTypeError; } });
 Object.defineProperty(exports, "IsAPdfError", { enumerable: true, get: function () { return errors_1.IsAPdfError; } });
+var download_and_parse_media_1 = require("./download-and-parse-media");
+Object.defineProperty(exports, "downloadAndParseMedia", { enumerable: true, get: function () { return download_and_parse_media_1.downloadAndParseMedia; } });
 var parse_media_1 = require("./parse-media");
 Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
 exports.MediaParserInternals = {

package/dist/init-video.d.ts

@@ -3,5 +3,5 @@ export declare const initVideo: ({ state, mimeType, name, contentLength, }: {
     state: ParserState;
     mimeType: string | null;
     name: string | null;
-    contentLength: number | null;
+    contentLength: number;
 }) => Promise<never> | undefined;

package/dist/init-video.js

@@ -7,7 +7,7 @@ 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({
+        state.setStructure({
             type: 'riff',
             boxes: [],
         });
@@ -15,7 +15,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
     }
     if (fileType.type === 'iso-base-media') {
         log_1.Log.verbose(state.logLevel, 'Detected ISO Base Media container');
-        state.structure.setStructure({
+        state.setStructure({
             type: 'iso-base-media',
             boxes: [],
         });
@@ -23,7 +23,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
     }
     if (fileType.type === 'webm') {
         log_1.Log.verbose(state.logLevel, 'Detected Matroska container');
-        state.structure.setStructure({
+        state.setStructure({
             boxes: [],
             type: 'matroska',
         });
@@ -31,7 +31,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
     }
     if (fileType.type === 'transport-stream') {
         log_1.Log.verbose(state.logLevel, 'Detected MPEG-2 Transport Stream');
-        state.structure.setStructure({
+        state.setStructure({
             boxes: [],
             type: 'transport-stream',
         });
@@ -43,7 +43,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
             boxes: [],
             type: 'mp3',
         };
-        state.structure.setStructure(structure);
+        state.setStructure(structure);
         return;
     }
     if (fileType.type === 'wav') {
@@ -52,7 +52,7 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
             boxes: [],
             type: 'wav',
         };
-        state.structure.setStructure(structure);
+        state.setStructure(structure);
         return;
     }
     if (fileType.type === 'flac') {
@@ -61,12 +61,12 @@ const initVideo = ({ state, mimeType, name, contentLength, }) => {
             boxes: [],
             type: 'flac',
         };
-        state.structure.setStructure(structure);
+        state.setStructure(structure);
         return;
     }
     if (fileType.type === 'aac') {
         log_1.Log.verbose(state.logLevel, 'Detected AAC');
-        state.structure.setStructure({
+        state.setStructure({
             type: 'aac',
             boxes: [],
         });

package/dist/internal-parse-media.d.ts

@@ -0,0 +1,2 @@
+import type { InternalParseMedia } from './options';
+export declare const internalParseMedia: InternalParseMedia;

package/dist/internal-parse-media.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalParseMedia = void 0;
+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 perform_seek_1 = require("./perform-seek");
+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 internalParseMedia = async function ({ src, fields: _fieldsInReturnValue, reader: readerInterface, onAudioTrack, onVideoTrack, signal, logLevel, onParseProgress: onParseProgressDoNotCallDirectly, progressIntervalInMs, mode, onDiscardedData, onError, ...more }) {
+    var _a;
+    const fieldsInReturnValue = _fieldsInReturnValue !== null && _fieldsInReturnValue !== void 0 ? _fieldsInReturnValue : {};
+    const fields = (0, get_fields_from_callbacks_1.getFieldsFromCallback)({
+        fields: fieldsInReturnValue,
+        callbacks: more,
+    });
+    const { reader: readerInstance, contentLength, name, contentType, supportsContentRange, } = await readerInterface.read({ src, range: null, signal });
+    if (contentLength === null) {
+        throw new Error('Cannot read media without a content length. This is currently not supported. Ensure the media has a "Content-Length" HTTP header.');
+    }
+    if (!supportsContentRange) {
+        throw new Error('Cannot read media without it supporting the "Content-Range" header. This is currently not supported. Ensure the media supports the "Content-Range" HTTP header.');
+    }
+    const hasAudioTrackHandlers = Boolean(onAudioTrack);
+    const hasVideoTrackHandlers = Boolean(onVideoTrack);
+    if (!hasAudioTrackHandlers &&
+        !hasVideoTrackHandlers &&
+        Object.values(fields).every((v) => !v) &&
+        mode === 'query') {
+        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;
+    let errored = null;
+    const state = (0, parser_state_1.makeParserState)({
+        hasAudioTrackHandlers,
+        hasVideoTrackHandlers,
+        signal,
+        fields,
+        onAudioTrack: onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : null,
+        onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
+        contentLength,
+        logLevel,
+        mode,
+        readerInterface,
+        src,
+        onDiscardedData,
+    });
+    const { iterator } = state;
+    let currentReader = readerInstance;
+    const returnValue = {};
+    const moreFields = more;
+    const throttledState = (0, throttled_progress_1.throttledStateUpdate)({
+        updateFn: onParseProgressDoNotCallDirectly !== null && onParseProgressDoNotCallDirectly !== void 0 ? onParseProgressDoNotCallDirectly : null,
+        everyMilliseconds: progressIntervalInMs !== null && progressIntervalInMs !== void 0 ? progressIntervalInMs : 100,
+        signal,
+        totalBytes: contentLength,
+    });
+    const triggerInfoEmit = async () => {
+        const availableInfo = (0, has_all_info_1.getAvailableInfo)({
+            fieldsToFetch: fields,
+            state,
+        });
+        await (0, emit_available_info_1.emitAvailableInfo)({
+            hasInfo: availableInfo,
+            callbacks: moreFields,
+            fieldsInReturnValue,
+            state,
+            returnValue,
+            name,
+            mimeType: contentType,
+        });
+    };
+    const checkIfDone = async () => {
+        const startCheck = Date.now();
+        const hasAll = (0, has_all_info_1.hasAllInfo)({
+            fields,
+            state,
+        });
+        timeCheckingIfDone += Date.now() - startCheck;
+        if (hasAll && mode === 'query') {
+            log_1.Log.verbose(logLevel, 'Got all info, skipping to the end.');
+            state.increaseSkippedBytes(contentLength - state.iterator.counter.getOffset());
+            return true;
+        }
+        if (state.iterator.counter.getOffset() === contentLength) {
+            log_1.Log.verbose(logLevel, 'Reached end of file');
+            await state.discardReadBytes(true);
+            return true;
+        }
+        if (state.iterator.counter.getOffset() + state.iterator.bytesRemaining() ===
+            contentLength &&
+            errored) {
+            log_1.Log.verbose(logLevel, 'Reached end of file and errorred');
+            return true;
+        }
+        return false;
+    };
+    await triggerInfoEmit();
+    let iterationWithThisOffset = 0;
+    while (!(await checkIfDone())) {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw new Error('Aborted');
+        }
+        const offsetBefore = iterator.counter.getOffset();
+        const fetchMoreData = async () => {
+            const result = await currentReader.reader.read();
+            if (result.value) {
+                iterator.addData(result.value);
+            }
+            return result.done;
+        };
+        const readStart = Date.now();
+        while (iterator.bytesRemaining() < 0) {
+            const done = await fetchMoreData();
+            if (done) {
+                break;
+            }
+        }
+        const hasBigBuffer = iterator.bytesRemaining() > 100000;
+        if (iterationWithThisOffset > 0 || !hasBigBuffer) {
+            await fetchMoreData();
+        }
+        await state.eventLoop.eventLoopBreakIfNeeded();
+        timeReadingData += Date.now() - readStart;
+        (_a = throttledState.update) === null || _a === void 0 ? void 0 : _a.call(throttledState, () => ({
+            bytes: iterator.counter.getOffset(),
+            percentage: contentLength
+                ? iterator.counter.getOffset() / contentLength
+                : null,
+            totalBytes: contentLength,
+        }));
+        if (!errored) {
+            log_1.Log.trace(logLevel, `Continuing parsing of file, currently at position ${iterator.counter.getOffset()}/${contentLength} (0x${iterator.counter.getOffset().toString(16)})`);
+            if (iterationWithThisOffset > 300) {
+                throw new Error('Infinite loop detected. The parser is not progressing. This is likely a bug in the parser.');
+            }
+            try {
+                await triggerInfoEmit();
+                const start = Date.now();
+                const skip = await (0, run_parse_iteration_1.runParseIteration)({
+                    state,
+                    mimeType: contentType,
+                    contentLength,
+                    name,
+                });
+                timeIterating += Date.now() - start;
+                if (skip !== null) {
+                    state.increaseSkippedBytes(skip.skipTo - iterator.counter.getOffset());
+                    if (skip.skipTo === contentLength) {
+                        log_1.Log.verbose(logLevel, 'Skipped to end of file, not fetching.');
+                        break;
+                    }
+                    const seekStart = Date.now();
+                    currentReader = await (0, perform_seek_1.performSeek)({
+                        seekTo: skip.skipTo,
+                        currentReader,
+                        readerInterface,
+                        src,
+                        state,
+                    });
+                    timeSeeking += Date.now() - seekStart;
+                }
+            }
+            catch (e) {
+                const err = await onError(e);
+                if (!err.action) {
+                    throw new Error('onError was used but did not return an "action" field. See docs for this API on how to use onError.');
+                }
+                if (err.action === 'fail') {
+                    throw e;
+                }
+                if (err.action === 'download') {
+                    errored = e;
+                    log_1.Log.verbose(logLevel, 'Error was handled by onError and deciding to continue.');
+                }
+            }
+            const didProgress = iterator.counter.getOffset() > offsetBefore;
+            if (!didProgress) {
+                iterationWithThisOffset++;
+            }
+        }
+        const timeFreeStart = Date.now();
+        await state.discardReadBytes(false);
+        timeFreeingData += Date.now() - timeFreeStart;
+    }
+    log_1.Log.verbose(logLevel, 'Finished parsing file');
+    // Force assign
+    await (0, emit_available_info_1.emitAvailableInfo)({
+        hasInfo: Object.keys(fields).reduce((acc, key) => {
+            if (fields === null || fields === void 0 ? void 0 : fields[key]) {
+                acc[key] = true;
+            }
+            return acc;
+        }, {}),
+        callbacks: moreFields,
+        fieldsInReturnValue,
+        state,
+        returnValue,
+        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(fields);
+    if (errored) {
+        throw errored;
+    }
+    return returnValue;
+};
+exports.internalParseMedia = internalParseMedia;

package/dist/make-hvc1-codec-strings.js

@@ -17,12 +17,12 @@ const getHvc1CodecString = (data) => {
     // general_constraint_indicator_flags(48)
     const generalConstraintIndicator = data.getSlice(6);
     const generalLevelIdc = data.getUint8();
-    let reversedGeneralProfileSpace = 0;
+    let profileId = 0;
     for (let i = 0; i < 32; i++) {
-        reversedGeneralProfileSpace |= generalProfileCompatibility & 1;
+        profileId |= generalProfileCompatibility & 1;
         if (i === 31)
             break;
-        reversedGeneralProfileSpace <<= 1;
+        profileId <<= 1;
         generalProfileCompatibility >>= 1;
     }
     const profileSpaceChar = generalProfileSpace === 0
@@ -42,6 +42,6 @@ const getHvc1CodecString = (data) => {
             hasByte = true;
         }
     }
-    return `${profileSpaceChar}${generalProfileIdc.toString(16)}.${reversedGeneralProfileSpace.toString(16)}.${generalTierChar}${generalLevelIdc}.${generalConstraintString}`;
+    return `${profileSpaceChar}${generalProfileIdc.toString(16)}.${profileId.toString(16)}.${generalTierChar}${generalLevelIdc}.${generalConstraintString}`;
 };
 exports.getHvc1CodecString = getHvc1CodecString;

package/dist/metadata/get-metadata.d.ts

@@ -1,8 +1,9 @@
 import type { Structure } from '../parse-result';
+import type { ParserState } from '../state/parser-state';
 export type MetadataEntry = {
     key: string;
     value: string | number;
     trackId: number | null;
 };
-export declare const getMetadata: (structure: Structure) => MetadataEntry[];
+export declare const getMetadata: (state: ParserState) => MetadataEntry[];
 export declare const hasMetadata: (structure: Structure) => boolean;