@remotion/media-parser 4.0.250 → 4.0.252

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/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/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;

package/dist/metadata/get-metadata.js

@@ -1,11 +1,15 @@
 "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) => {
+const getMetadata = (state) => {
+    var _a, _b;
+    const structure = state.getStructure();
     if (structure.type === 'matroska') {
         return (0, metadata_from_matroska_1.getMetadataFromMatroska)(structure);
     }
@@ -22,13 +26,25 @@ const getMetadata = (structure) => {
         }
         return tags;
     }
-    return (0, metadata_from_iso_1.getMetadataFromIsoBase)(structure);
+    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)(state);
 };
 exports.getMetadata = getMetadata;
 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 { ParserState } from '../state/parser-state';
 import type { MetadataEntry } from './get-metadata';
 export declare const parseIsoMetaBox: (meta: RegularBox, trackId: number | null) => MetadataEntry[];
-export declare const getMetadataFromIsoBase: (isoBase: IsoBaseMediaStructure) => MetadataEntry[];
+export declare const getMetadataFromIsoBase: (state: ParserState) => 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");
 /**
  *
@@ -115,8 +115,8 @@ const parseIsoMetaBox = (meta, trackId) => {
     return entries;
 };
 exports.parseIsoMetaBox = parseIsoMetaBox;
-const getMetadataFromIsoBase = (isoBase) => {
-    const moov = (0, traversal_1.getMoovBox)(isoBase.boxes);
+const getMetadataFromIsoBase = (state) => {
+    const moov = (0, traversal_1.getMoovBox)(state);
     if (!moov) {
         return [];
     }

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

@@ -8,6 +8,7 @@ import type { ReaderInterface } from './readers/reader';
 import type { MediaParserEmbeddedImage } from './state/images';
 import type { InternalStats } from './state/parser-state';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
+import type { WriterInterface } from './writers/writer';
 export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis' | 'unknown';
 export type ParseMediaFields = {
     dimensions: boolean;
@@ -32,7 +33,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 +63,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 +92,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 +110,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) => unknown | Promise<unknown>);
+    onDurationInSeconds: null | ((durationInSeconds: number | null) => unknown | Promise<unknown>);
+    onSlowDurationInSeconds: null | ((durationInSeconds: number) => unknown | Promise<unknown>);
+    onSlowFps: null | ((fps: number) => unknown | Promise<unknown>);
+    onStructure: null | ((structure: Structure) => unknown | Promise<unknown>);
+    onFps: null | ((fps: number | null) => unknown | Promise<unknown>);
+    onVideoCodec: null | ((codec: MediaParserVideoCodec | null) => unknown | Promise<unknown>);
+    onAudioCodec: null | ((codec: MediaParserAudioCodec | null) => unknown | Promise<unknown>);
+    onTracks: null | ((tracks: TracksField) => unknown | Promise<unknown>);
+    onRotation: null | ((rotation: number | null) => unknown | Promise<unknown>);
+    onUnrotatedDimensions: null | ((dimensions: Dimensions | null) => unknown | Promise<unknown>);
+    onInternalStats: null | ((internalStats: InternalStats) => unknown | Promise<unknown>);
+    onSize: null | ((size: number | null) => unknown | Promise<unknown>);
+    onName: null | ((name: string) => unknown | Promise<unknown>);
+    onContainer: null | ((container: MediaParserContainer) => unknown | Promise<unknown>);
+    onIsHdr: null | ((isHdr: boolean) => unknown | Promise<unknown>);
+    onMetadata: null | ((metadata: MetadataEntry[]) => unknown | Promise<unknown>);
+    onLocation: null | ((location: MediaParserLocation | null) => unknown | Promise<unknown>);
+    onMimeType: null | ((mimeType: string | null) => unknown | Promise<unknown>);
+    onKeyframes: null | ((keyframes: MediaParserKeyframe[] | null) => unknown | Promise<unknown>);
+    onSlowKeyframes: null | ((keyframes: MediaParserKeyframe[]) => unknown | Promise<unknown>);
+    onSlowNumberOfFrames: null | ((samples: number) => unknown | Promise<unknown>);
+    onImages: null | ((images: MediaParserEmbeddedImage[]) => unknown | Promise<unknown>);
+    onSampleRate: null | ((sampleRate: number | null) => unknown | Promise<unknown>);
+    onNumberOfAudioChannels: null | ((numberOfChannels: number | null) => unknown | Promise<unknown>);
+    onSlowVideoBitrate: null | ((videoBitrate: number | null) => unknown | Promise<unknown>);
+    onSlowAudioBitrate: null | ((audioBitrate: number | null) => unknown | Promise<unknown>);
+};
+export type ParseMediaCallbacks = Partial<MandatoryParseMediaCallbacks>;
 export interface ParseMediaData {
     dimensions: Dimensions | null;
     durationInSeconds: number | null;
@@ -140,33 +158,64 @@ 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;
+    signal: AbortSignal | undefined;
+    logLevel: LogLevel;
+    onParseProgress: ParseMediaOnProgress | null;
+    progressIntervalInMs: number | null;
+    fields: F | null;
+} & MandatoryParseMediaCallbacks;
+type ParseMediaSampleCallbacks = {
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+};
+export type ParseMediaMode = 'query' | 'download';
+export type ParseMediaSrc = string | Blob;
+export type OnDiscardedData = (data: Uint8Array) => Promise<void>;
+export type ContinueAfterError = {
+    action: 'fail';
+} | {
+    action: 'download';
+};
+export type ParseMediaOnError = (error: Error) => ContinueAfterError | Promise<ContinueAfterError>;
+export type InternalParseMediaOptions<F extends Options<ParseMediaFields>> = {
+    src: ParseMediaSrc;
+} & OptionalParseMediaParams<F> & ParseMediaSampleCallbacks & {
+    onDiscardedData: OnDiscardedData | null;
+    mode: ParseMediaMode;
+    onError: ParseMediaOnError;
+};
 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>;
+    src: ParseMediaSrc;
+} & Partial<OptionalParseMediaParams<F>> & Partial<ParseMediaSampleCallbacks>;
+export type DownloadAndParseMediaOptions<F extends Options<ParseMediaFields>> = {
+    src: ParseMediaSrc;
+} & Partial<OptionalParseMediaParams<F>> & {
+    writer: WriterInterface;
+    onError?: ParseMediaOnError;
+};
+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 type DownloadAndParseMedia = <F extends Options<ParseMediaFields>>(options: DownloadAndParseMediaOptions<F>) => Promise<ParseMediaResult<F>>;
+export {};

package/dist/parse-and-download-media.d.ts

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

package/dist/parse-and-download-media.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAndDownloadMedia = void 0;
+const internal_parse_media_1 = require("./internal-parse-media");
+const from_fetch_1 = require("./readers/from-fetch");
+const parseAndDownloadMedia = async (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;
+    const content = await options.writer.createContent({
+        filename: 'hmm',
+        mimeType: 'shouldnotmatter',
+    });
+    const returnValue = await (0, internal_parse_media_1.internalParseMedia)({
+        fields: (_a = options.fields) !== null && _a !== void 0 ? _a : null,
+        logLevel: (_b = options.logLevel) !== null && _b !== void 0 ? _b : 'info',
+        mode: 'download',
+        onAudioCodec: (_c = options.onAudioCodec) !== null && _c !== void 0 ? _c : null,
+        onAudioTrack: null,
+        onContainer: (_d = options.onContainer) !== null && _d !== void 0 ? _d : null,
+        onDimensions: (_e = options.onDimensions) !== null && _e !== void 0 ? _e : null,
+        onDiscardedData: async (data) => {
+            await content.write(data);
+        },
+        onDurationInSeconds: (_f = options.onDurationInSeconds) !== null && _f !== void 0 ? _f : null,
+        onFps: (_g = options.onFps) !== null && _g !== void 0 ? _g : null,
+        onImages: (_h = options.onImages) !== null && _h !== void 0 ? _h : null,
+        onInternalStats: (_j = options.onInternalStats) !== null && _j !== void 0 ? _j : null,
+        onIsHdr: (_k = options.onIsHdr) !== null && _k !== void 0 ? _k : null,
+        onKeyframes: (_l = options.onKeyframes) !== null && _l !== void 0 ? _l : null,
+        onLocation: (_m = options.onLocation) !== null && _m !== void 0 ? _m : null,
+        onMetadata: (_o = options.onMetadata) !== null && _o !== void 0 ? _o : null,
+        onMimeType: (_p = options.onMimeType) !== null && _p !== void 0 ? _p : null,
+        onName: (_q = options.onName) !== null && _q !== void 0 ? _q : null,
+        onNumberOfAudioChannels: (_r = options.onNumberOfAudioChannels) !== null && _r !== void 0 ? _r : null,
+        onParseProgress: (_s = options.onParseProgress) !== null && _s !== void 0 ? _s : null,
+        onRotation: (_t = options.onRotation) !== null && _t !== void 0 ? _t : null,
+        onSampleRate: (_u = options.onSampleRate) !== null && _u !== void 0 ? _u : null,
+        onSize: (_v = options.onSize) !== null && _v !== void 0 ? _v : null,
+        onSlowAudioBitrate: (_w = options.onSlowAudioBitrate) !== null && _w !== void 0 ? _w : null,
+        onSlowDurationInSeconds: (_x = options.onSlowDurationInSeconds) !== null && _x !== void 0 ? _x : null,
+        onSlowFps: (_y = options.onSlowFps) !== null && _y !== void 0 ? _y : null,
+        onSlowKeyframes: (_z = options.onSlowKeyframes) !== null && _z !== void 0 ? _z : null,
+        onSlowNumberOfFrames: (_0 = options.onSlowNumberOfFrames) !== null && _0 !== void 0 ? _0 : null,
+        onSlowVideoBitrate: (_1 = options.onSlowVideoBitrate) !== null && _1 !== void 0 ? _1 : null,
+        onStructure: (_2 = options.onStructure) !== null && _2 !== void 0 ? _2 : null,
+        onTracks: (_3 = options.onTracks) !== null && _3 !== void 0 ? _3 : null,
+        onUnrotatedDimensions: (_4 = options.onUnrotatedDimensions) !== null && _4 !== void 0 ? _4 : null,
+        onVideoCodec: (_5 = options.onVideoCodec) !== null && _5 !== void 0 ? _5 : null,
+        onVideoTrack: null,
+        progressIntervalInMs: (_6 = options.progressIntervalInMs) !== null && _6 !== void 0 ? _6 : null,
+        reader: (_7 = options.reader) !== null && _7 !== void 0 ? _7 : from_fetch_1.fetchReader,
+        signal: (_8 = options.signal) !== null && _8 !== void 0 ? _8 : undefined,
+        src: options.src,
+    });
+    await content.finish();
+    return returnValue;
+};
+exports.parseAndDownloadMedia = parseAndDownloadMedia;