@remotion/media-parser 4.0.194 → 4.0.196

package/dist/get-video-codec.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVideoCodec = exports.hasVideoCodec = void 0;
-/* eslint-disable max-depth */
+exports.getVideoCodec = exports.getVideoCodecString = exports.hasVideoCodec = void 0;
+const av1_codec_private_1 = require("./boxes/webm/av1-codec-private");
 const get_fps_1 = require("./get-fps");
+const get_sample_aspect_ratio_1 = require("./get-sample-aspect-ratio");
+const traversal_1 = require("./traversal");
 const hasVideoCodec = (boxes) => {
     try {
         return (0, exports.getVideoCodec)(boxes) !== null;
@@ -12,36 +14,47 @@ const hasVideoCodec = (boxes) => {
     }
 };
 exports.hasVideoCodec = hasVideoCodec;
+const getVideoCodecString = (trakBox) => {
+    const videoSample = (0, get_sample_aspect_ratio_1.getVideoSample)(trakBox);
+    const avccBox = (0, get_sample_aspect_ratio_1.getAvccBox)(trakBox);
+    const hvccBox = (0, get_sample_aspect_ratio_1.getHvccBox)(trakBox);
+    const av1cBox = (0, get_sample_aspect_ratio_1.getAv1CBox)(trakBox);
+    if (!videoSample) {
+        return null;
+    }
+    if (avccBox) {
+        return `${videoSample.format}.${avccBox.configurationString}`;
+    }
+    if (hvccBox) {
+        return `${videoSample.format}.${hvccBox.configurationString}`;
+    }
+    if (av1cBox) {
+        const colrAtom = (0, get_sample_aspect_ratio_1.getColrBox)(videoSample);
+        return (0, av1_codec_private_1.parseAv1PrivateData)(av1cBox.privateData, colrAtom);
+    }
+    return videoSample.format;
+};
+exports.getVideoCodecString = getVideoCodecString;
 const getVideoCodec = (boxes) => {
-    const moovBox = boxes.find((b) => b.type === 'moov-box');
-    if (moovBox && moovBox.type === 'moov-box') {
-        const trakBox = moovBox.children.find((b) => b.type === 'trak-box' && (0, get_fps_1.trakBoxContainsVideo)(b));
-        if (trakBox && trakBox.type === 'trak-box') {
-            const mdiaBox = trakBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'mdia');
-            if (mdiaBox &&
-                mdiaBox.type === 'regular-box' &&
-                mdiaBox.boxType === 'mdia') {
-                const minfBox = mdiaBox === null || mdiaBox === void 0 ? void 0 : mdiaBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'minf');
-                if (minfBox &&
-                    minfBox.type === 'regular-box' &&
-                    minfBox.boxType === 'minf') {
-                    const stblBox = minfBox === null || minfBox === void 0 ? void 0 : minfBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'stbl');
-                    if (stblBox && stblBox.type === 'regular-box') {
-                        const stsdBox = stblBox === null || stblBox === void 0 ? void 0 : stblBox.children.find((b) => b.type === 'stsd-box');
-                        if (stsdBox && stsdBox.type === 'stsd-box') {
-                            const videoSample = stsdBox.samples.find((s) => s.type === 'video');
-                            if (videoSample && videoSample.type === 'video') {
-                                if (videoSample.format === 'hvc1') {
-                                    return 'h265';
-                                }
-                                if (videoSample.format === 'avc1') {
-                                    return 'h264';
-                                }
-                                if (videoSample.format === 'ap4h') {
-                                    return 'prores';
-                                }
-                            }
-                        }
+    const moovBox = (0, traversal_1.getMoovBox)(boxes);
+    if (moovBox) {
+        const trakBox = (0, traversal_1.getTraks)(moovBox).filter((t) => (0, get_fps_1.trakBoxContainsVideo)(t))[0];
+        if (trakBox) {
+            const stsdBox = (0, traversal_1.getStsdBox)(trakBox);
+            if (stsdBox && stsdBox.type === 'stsd-box') {
+                const videoSample = stsdBox.samples.find((s) => s.type === 'video');
+                if (videoSample && videoSample.type === 'video') {
+                    if (videoSample.format === 'hvc1') {
+                        return 'h265';
+                    }
+                    if (videoSample.format === 'avc1') {
+                        return 'h264';
+                    }
+                    if (videoSample.format === 'av01') {
+                        return 'av1';
+                    }
+                    if (videoSample.format === 'ap4h') {
+                        return 'prores';
                     }
                 }
             }
@@ -71,6 +84,9 @@ const getVideoCodec = (boxes) => {
                 if (trackType.codec === 'V_MPEG4/ISO/AVC') {
                     return 'h264';
                 }
+                if (trackType.codec === 'V_MPEGH/ISO/HEVC') {
+                    return 'h265';
+                }
             }
         }
     }

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

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

package/dist/get-video-metadata.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMedia = void 0;
+const buffer_iterator_1 = require("./buffer-iterator");
+const from_web_1 = require("./from-web");
+const get_dimensions_1 = require("./get-dimensions");
+const get_duration_1 = require("./get-duration");
+const get_fps_1 = require("./get-fps");
+const has_all_info_1 = require("./has-all-info");
+const parse_video_1 = require("./parse-video");
+const parseMedia = async (src, options, readerInterface = from_web_1.webReader) => {
+    const reader = await readerInterface.read(src, null);
+    const returnValue = {};
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]));
+    let parseResult = (0, parse_video_1.parseVideo)(iterator);
+    while (parseResult.status === 'incomplete') {
+        const result = await reader.read();
+        if (result.done) {
+            break;
+        }
+        iterator.addData(result.value);
+        parseResult = parseResult.continueParsing();
+        if ((0, has_all_info_1.hasAllInfo)(options, parseResult)) {
+            if (!reader.closed) {
+                reader.cancel(new Error('has all information'));
+            }
+            break;
+        }
+    }
+    if (options.dimensions) {
+        returnValue.dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments);
+    }
+    if (options.durationInSeconds) {
+        returnValue.durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments);
+    }
+    if (options.fps) {
+        returnValue.fps = (0, get_fps_1.getFps)(parseResult.segments);
+    }
+    if (options.boxes) {
+        returnValue.boxes = parseResult.segments;
+    }
+    return returnValue;
+};
+exports.parseMedia = parseMedia;

package/dist/has-all-info.d.ts

@@ -1,3 +1,4 @@
 import type { Options } from './options';
 import type { ParseResult } from './parse-result';
-export declare const hasAllInfo: (options: Options<boolean, boolean, boolean, boolean, boolean, boolean>, parseResult: ParseResult) => boolean;
+import type { ParserState } from './parser-state';
+export declare const hasAllInfo: (options: Options<boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean>, parseResult: ParseResult, state: ParserState) => boolean;

package/dist/has-all-info.js

@@ -5,8 +5,9 @@ const get_audio_codec_1 = require("./get-audio-codec");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
+const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
-const hasAllInfo = (options, parseResult) => {
+const hasAllInfo = (options, parseResult, state) => {
     const keys = Object.entries(options)
         .filter(([, value]) => value)
         .map(([key]) => key);
@@ -17,17 +18,25 @@ const hasAllInfo = (options, parseResult) => {
         if (key === 'durationInSeconds') {
             return (0, get_duration_1.hasDuration)(parseResult.segments);
         }
-        if (key === 'dimensions') {
-            return (0, get_dimensions_1.hasDimensions)(parseResult.segments);
+        if (key === 'dimensions' ||
+            key === 'rotation' ||
+            key === 'unrotatedDimension') {
+            return (0, get_dimensions_1.hasDimensions)(parseResult.segments, state);
         }
         if (key === 'fps') {
             return (0, get_fps_1.hasFps)(parseResult.segments) !== null;
         }
         if (key === 'videoCodec') {
-            return (0, get_video_codec_1.hasVideoCodec)(parseResult.segments) !== null;
+            return (0, get_video_codec_1.hasVideoCodec)(parseResult.segments);
         }
         if (key === 'audioCodec') {
-            return (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments) !== null;
+            return (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments);
+        }
+        if (key === 'tracks') {
+            return (0, get_tracks_1.hasTracks)(parseResult.segments);
+        }
+        if (key === 'internalStats') {
+            return false;
         }
         throw new Error(`Unknown key: ${key}`);
     });

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { parseMedia } from './parse-media';
+export { AudioSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, VideoSample, } from './webcodec-sample-types';

package/dist/make-hvc1-codec-strings.d.ts

@@ -0,0 +1,2 @@
+import type { BufferIterator } from './buffer-iterator';
+export declare const getHvc1CodecString: (data: BufferIterator) => string;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHvc1CodecString = void 0;
+const getHvc1CodecString = (data) => {
+    const configurationVersion = data.getUint8();
+    if (configurationVersion !== 1) {
+        throw new Error(`Unsupported HVCC version ${configurationVersion}`);
+    }
+    const generalProfileSpaceTierFlagAndIdc = data.getUint8();
+    let generalProfileCompatibility = data.getUint32();
+    //  unsigned int(2) general_profile_space;
+    // 	unsigned int(1) general_tier_flag;
+    //	unsigned int(5) general_profile_idc;
+    const generalProfileSpace = generalProfileSpaceTierFlagAndIdc >> 6;
+    const generalTierFlag = generalProfileSpaceTierFlagAndIdc >> 5;
+    const generalProfileIdc = generalProfileSpaceTierFlagAndIdc >> 0;
+    // general_constraint_indicator_flags(48)
+    const generalConstraintIndicator = data.getSlice(6);
+    const generalLevelIdc = data.getUint8();
+    let reversedGeneralProfileSpace = 0;
+    for (let i = 0; i < 32; i++) {
+        reversedGeneralProfileSpace |= generalProfileCompatibility & 1;
+        if (i === 31)
+            break;
+        reversedGeneralProfileSpace <<= 1;
+        generalProfileCompatibility >>= 1;
+    }
+    const profileSpaceChar = generalProfileSpace === 0
+        ? ''
+        : generalProfileSpace === 1
+            ? 'A'
+            : generalProfileSpace === 2
+                ? 'B'
+                : 'C';
+    const generalTierChar = generalTierFlag === 0 ? 'L' : 'H';
+    let hasByte = false;
+    let generalConstraintString = '';
+    for (let i = 5; i >= 0; i--) {
+        if (generalConstraintIndicator[i] || hasByte) {
+            generalConstraintString =
+                generalConstraintIndicator[i].toString(16) + generalConstraintString;
+            hasByte = true;
+        }
+    }
+    return `${profileSpaceChar}${generalProfileIdc.toString(16)}.${reversedGeneralProfileSpace.toString(16)}.${generalTierChar}${generalLevelIdc}.${generalConstraintString}`;
+};
+exports.getHvc1CodecString = getHvc1CodecString;

package/dist/options.d.ts

@@ -1,17 +1,24 @@
 import type { Dimensions } from './get-dimensions';
+import type { AudioTrack, VideoTrack } from './get-tracks';
 import type { AnySegment } from './parse-result';
+import type { InternalStats } from './parser-state';
 import type { ReaderInterface } from './reader';
+import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
 export type KnownVideoCodecs = 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1' | 'prores';
-export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'unknown';
-export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean> = {
+export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis' | 'unknown';
+export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean, EnableTracks extends boolean, EnableRotation extends boolean, EnableUnrotatedDimensions extends boolean, EnableInternalStats extends boolean> = {
     dimensions?: EnableDimensions;
     durationInSeconds?: EnableDuration;
     boxes?: EnableBoxes;
     fps?: EnableFps;
     videoCodec?: EnableVideoCodec;
     audioCodec?: EnableAudioCodec;
+    tracks?: EnableTracks;
+    rotation?: EnableRotation;
+    unrotatedDimension?: EnableUnrotatedDimensions;
+    internalStats?: EnableInternalStats;
 };
-export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean> = (EnableDimensions extends true ? {
+export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean, EnableTracks extends boolean, EnableRotation extends boolean, EnableUnrotatedDimensions extends boolean, EnableInternalStats extends boolean> = (EnableDimensions extends true ? {
     dimensions: Dimensions;
 } : {}) & (EnableDuration extends true ? {
     durationInSeconds: number | null;
@@ -23,5 +30,20 @@ export type Metadata<EnableDimensions extends boolean, EnableDuration extends bo
     videoCodec: KnownVideoCodecs | null;
 } : {}) & (EnableAudioCodec extends true ? {
     audioCodec: KnownAudioCodecs | null;
+} : {}) & (EnableTracks extends true ? {
+    videoTracks: VideoTrack[];
+    audioTracks: AudioTrack[];
+} : {}) & (EnableRotation extends true ? {
+    rotation: number | null;
+} : {}) & (EnableUnrotatedDimensions extends true ? {
+    unrotatedDimension: Dimensions;
+} : {}) & (EnableInternalStats extends true ? {
+    internalStats: InternalStats;
 } : {});
-export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean>(src: string, options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec>, readerInterface?: ReaderInterface) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec>>;
+export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean, EnableTracks extends boolean, EnableRotation extends boolean, EnableUnrotatedDimensions extends boolean, EnableInternalStats extends boolean>(options: {
+    src: string | File;
+    fields?: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec, EnableTracks, EnableRotation, EnableUnrotatedDimensions, EnableInternalStats>;
+    reader?: ReaderInterface;
+    onAudioTrack?: OnAudioTrack;
+    onVideoTrack?: OnVideoTrack;
+}) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec, EnableTracks, EnableRotation, EnableUnrotatedDimensions, EnableInternalStats>>;

package/dist/parse-media.js

@@ -2,38 +2,59 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMedia = void 0;
 const buffer_iterator_1 = require("./buffer-iterator");
-const from_web_1 = require("./from-web");
+const from_fetch_1 = require("./from-fetch");
 const get_audio_codec_1 = require("./get-audio-codec");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
+const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
 const has_all_info_1 = require("./has-all-info");
 const parse_video_1 = require("./parse-video");
-const parseMedia = async (src, options, readerInterface = from_web_1.webReader) => {
+const parser_state_1 = require("./parser-state");
+const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, }) => {
     const { reader, contentLength } = await readerInterface.read(src, null);
     let currentReader = reader;
     const returnValue = {};
     let iterator = null;
     let parseResult = null;
+    const state = (0, parser_state_1.makeParserState)({
+        hasAudioCallbacks: onAudioTrack !== null,
+        hasVideoCallbacks: onVideoTrack !== null,
+    });
+    const options = {
+        canSkipVideoData: !(onAudioTrack || onVideoTrack),
+        onAudioTrack: onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : null,
+        onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
+        parserState: state,
+    };
     while (parseResult === null || parseResult.status === 'incomplete') {
         const result = await currentReader.read();
-        if (result.done) {
-            break;
-        }
         if (iterator) {
-            iterator.addData(result.value);
+            if (!result.done) {
+                iterator.addData(result.value);
+            }
         }
         else {
+            if (result.done) {
+                throw new Error('Unexpectedly reached EOF');
+            }
             iterator = (0, buffer_iterator_1.getArrayBufferIterator)(result.value, contentLength !== null && contentLength !== void 0 ? contentLength : undefined);
         }
-        if (parseResult) {
-            parseResult = parseResult.continueParsing();
+        if (parseResult && parseResult.status === 'incomplete') {
+            parseResult = await parseResult.continueParsing();
         }
         else {
-            parseResult = (0, parse_video_1.parseVideo)(iterator);
+            parseResult = await (0, parse_video_1.parseVideo)({
+                iterator,
+                options,
+            });
         }
-        if ((0, has_all_info_1.hasAllInfo)(options, parseResult)) {
+        // TODO Better: Check if no active listeners are registered
+        // Also maybe check for canSkipVideoData
+        if ((0, has_all_info_1.hasAllInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state) &&
+            !onVideoTrack &&
+            !onAudioTrack) {
             if (!currentReader.closed) {
                 currentReader.cancel(new Error('has all information'));
             }
@@ -53,24 +74,48 @@ const parseMedia = async (src, options, readerInterface = from_web_1.webReader)
     if (!parseResult) {
         throw new Error('Could not parse video');
     }
-    if (options.dimensions) {
-        returnValue.dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments);
+    if (fields === null || fields === void 0 ? void 0 : fields.dimensions) {
+        const dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
+        returnValue.dimensions = {
+            width: dimensions.width,
+            height: dimensions.height,
+        };
     }
-    if (options.durationInSeconds) {
+    if (fields === null || fields === void 0 ? void 0 : fields.unrotatedDimension) {
+        const dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
+        returnValue.unrotatedDimension = {
+            width: dimensions.unrotatedWidth,
+            height: dimensions.unrotatedHeight,
+        };
+    }
+    if (fields === null || fields === void 0 ? void 0 : fields.rotation) {
+        const dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
+        returnValue.rotation = dimensions.rotation;
+    }
+    if (fields === null || fields === void 0 ? void 0 : fields.durationInSeconds) {
         returnValue.durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments);
     }
-    if (options.fps) {
+    if (fields === null || fields === void 0 ? void 0 : fields.fps) {
         returnValue.fps = (0, get_fps_1.getFps)(parseResult.segments);
     }
-    if (options.videoCodec) {
+    if (fields === null || fields === void 0 ? void 0 : fields.videoCodec) {
         returnValue.videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments);
     }
-    if (options.audioCodec) {
+    if (fields === null || fields === void 0 ? void 0 : fields.audioCodec) {
         returnValue.audioCodec = (0, get_audio_codec_1.getAudioCodec)(parseResult.segments);
     }
-    if (options.boxes) {
+    if (fields === null || fields === void 0 ? void 0 : fields.tracks) {
+        const { audioTracks, videoTracks } = (0, get_tracks_1.getTracks)(parseResult.segments, state);
+        returnValue.audioTracks = audioTracks;
+        returnValue.videoTracks = videoTracks;
+    }
+    if (fields === null || fields === void 0 ? void 0 : fields.boxes) {
         returnValue.boxes = parseResult.segments;
     }
+    if (fields === null || fields === void 0 ? void 0 : fields.internalStats) {
+        returnValue.internalStats = state.getInternalStats();
+    }
+    iterator === null || iterator === void 0 ? void 0 : iterator.destroy();
     return returnValue;
 };
 exports.parseMedia = parseMedia;

package/dist/parse-result.d.ts

@@ -1,24 +1,36 @@
 import type { BaseBox } from './boxes/iso-base-media/base-type';
 import type { EsdsBox } from './boxes/iso-base-media/esds/esds';
 import type { FtypBox } from './boxes/iso-base-media/ftyp';
+import type { MdatBox } from './boxes/iso-base-media/mdat/mdat';
 import type { MdhdBox } from './boxes/iso-base-media/mdhd';
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
 import type { MvhdBox } from './boxes/iso-base-media/mvhd';
+import type { Av1CBox } from './boxes/iso-base-media/stsd/av1c';
+import type { AvccBox } from './boxes/iso-base-media/stsd/avcc';
+import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
+import type { CttsBox } from './boxes/iso-base-media/stsd/ctts';
+import type { HvccBox } from './boxes/iso-base-media/stsd/hvcc';
 import type { KeysBox } from './boxes/iso-base-media/stsd/keys';
 import type { MebxBox } from './boxes/iso-base-media/stsd/mebx';
+import type { PaspBox } from './boxes/iso-base-media/stsd/pasp';
+import type { StcoBox } from './boxes/iso-base-media/stsd/stco';
+import type { StscBox } from './boxes/iso-base-media/stsd/stsc';
 import type { StsdBox } from './boxes/iso-base-media/stsd/stsd';
-import type { SttsBox } from './boxes/iso-base-media/stts/stts';
+import type { StssBox } from './boxes/iso-base-media/stsd/stss';
+import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
+import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
 import type { TkhdBox } from './boxes/iso-base-media/tkhd';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { VoidBox } from './boxes/iso-base-media/void-box';
 import type { MatroskaSegment } from './boxes/webm/segments';
-interface RegularBox extends BaseBox {
+export interface RegularBox extends BaseBox {
     boxType: string;
     boxSize: number;
     children: AnySegment[];
     offset: number;
     type: 'regular-box';
 }
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | EsdsBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | ColorParameterBox;
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
 export type ParseResult = {
     status: 'done';
@@ -27,6 +39,5 @@ export type ParseResult = {
     status: 'incomplete';
     segments: AnySegment[];
     skipTo: number | null;
-    continueParsing: () => ParseResult;
+    continueParsing: () => Promise<ParseResult>;
 };
-export {};

package/dist/parse-video.d.ts

@@ -1,5 +1,11 @@
 import type { BufferIterator } from './buffer-iterator';
 import type { IsoBaseMediaBox, ParseResult } from './parse-result';
+import type { ParserContext } from './parser-context';
+export type PartialMdatBox = {
+    type: 'partial-mdat-box';
+    boxSize: number;
+    fileOffset: number;
+};
 export type BoxAndNext = {
     type: 'complete';
     box: IsoBaseMediaBox;
@@ -7,5 +13,8 @@ export type BoxAndNext = {
     skipTo: number | null;
 } | {
     type: 'incomplete';
-};
-export declare const parseVideo: (iterator: BufferIterator) => ParseResult;
+} | PartialMdatBox;
+export declare const parseVideo: ({ iterator, options, }: {
+    iterator: BufferIterator;
+    options: ParserContext;
+}) => Promise<ParseResult>;

package/dist/parse-video.js

@@ -3,16 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVideo = void 0;
 const process_box_1 = require("./boxes/iso-base-media/process-box");
 const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
-const parseVideo = (iterator) => {
+const parseVideo = ({ iterator, options, }) => {
     if (iterator.bytesRemaining() === 0) {
-        return {
+        return Promise.resolve({
             status: 'incomplete',
             segments: [],
             continueParsing: () => {
-                return (0, exports.parseVideo)(iterator);
+                return (0, exports.parseVideo)({
+                    iterator,
+                    options,
+                });
             },
             skipTo: null,
-        };
+        });
     }
     if (iterator.isIsoBaseMedia()) {
         return (0, process_box_1.parseBoxes)({
@@ -20,11 +23,16 @@ const parseVideo = (iterator) => {
             maxBytes: Infinity,
             allowIncompleteBoxes: true,
             initialBoxes: [],
+            options,
+            continueMdat: false,
         });
     }
     if (iterator.isWebm()) {
-        return (0, parse_webm_header_1.parseWebm)(iterator);
+        return Promise.resolve((0, parse_webm_header_1.parseWebm)(iterator, options));
+    }
+    if (iterator.isMp3()) {
+        return Promise.reject(new Error('MP3 files are not yet supported'));
     }
-    throw new Error('Unknown video format');
+    return Promise.reject(new Error('Unknown video format'));
 };
 exports.parseVideo = parseVideo;

package/dist/parser-context.d.ts

@@ -0,0 +1,8 @@
+import type { ParserState } from './parser-state';
+import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
+export type ParserContext = {
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    canSkipVideoData: boolean;
+    parserState: ParserState;
+};

package/dist/parser-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parser-state.d.ts

@@ -0,0 +1,23 @@
+import type { OnTrackEntrySegment } from './boxes/webm/segments';
+import type { CodecSegment } from './boxes/webm/segments/track-entry';
+import type { AudioSample, OnAudioSample, OnVideoSample, VideoSample } from './webcodec-sample-types';
+export type InternalStats = {
+    samplesThatHadToBeQueued: number;
+};
+export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, }: {
+    hasAudioCallbacks: boolean;
+    hasVideoCallbacks: boolean;
+}) => {
+    onTrackEntrySegment: OnTrackEntrySegment;
+    getTrackInfoByNumber: (id: number) => CodecSegment;
+    registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
+    registerAudioSampleCallback: (id: number, callback: OnAudioSample | null) => Promise<void>;
+    onAudioSample: (trackId: number, audioSample: AudioSample) => Promise<void>;
+    onVideoSample: (trackId: number, videoSample: VideoSample) => Promise<void>;
+    getInternalStats: () => {
+        samplesThatHadToBeQueued: number;
+    };
+    getTimescale: () => number;
+    setTimescale: (newTimescale: number) => void;
+};
+export type ParserState = ReturnType<typeof makeParserState>;