@remotion/media-parser 4.0.231 → 4.0.233

package/dist/boxes/iso-base-media/process-box.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBoxes = exports.processBox = exports.parseMdatPartially = void 0;
+exports.parseIsoBaseMediaBoxes = exports.processBox = exports.parseMdatPartially = void 0;
 const get_tracks_1 = require("../../get-tracks");
+const register_track_1 = require("../../register-track");
 const esds_1 = require("./esds/esds");
 const ftyp_1 = require("./ftyp");
 const make_track_1 = require("./make-track");
@@ -39,7 +40,7 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, si
         boxType === 'stsb';
     if (parseChildren) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        const parsed = await (0, exports.parseBoxes)({
+        const parsed = await (0, exports.parseIsoBaseMediaBoxes)({
             iterator,
             maxBytes: bytesRemainingInBox,
             allowIncompleteBoxes: false,
@@ -52,7 +53,7 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, si
         if (parsed.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
         }
-        return parsed.segments;
+        return parsed.segments.boxes;
     }
     if (bytesRemainingInBox < 0) {
         throw new Error('Box size is too big ' + JSON.stringify({ boxType }));
@@ -87,7 +88,6 @@ const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes,
 };
 exports.parseMdatPartially = parseMdatPartially;
 const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, signal, logLevel, }) => {
-    var _a, _b;
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSizeRaw = iterator.getFourByteNumber();
@@ -117,7 +117,8 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
     if (bytesRemaining < boxSize) {
         if (boxType === 'mdat') {
-            const shouldSkip = (options.canSkipVideoData || !(0, get_tracks_1.hasTracks)(parsedBoxes)) &&
+            const shouldSkip = (options.canSkipVideoData ||
+                !(0, get_tracks_1.hasTracks)({ type: 'iso-base-media', boxes: parsedBoxes }, options.parserState)) &&
                 options.supportsContentRange;
             if (shouldSkip) {
                 const skipTo = fileOffset + boxSize;
@@ -349,14 +350,11 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         });
         const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
         if (transformedTrack) {
-            if (transformedTrack.type === 'audio') {
-                const callback = await ((_a = options.onAudioTrack) === null || _a === void 0 ? void 0 : _a.call(options, transformedTrack));
-                await options.parserState.registerAudioSampleCallback(transformedTrack.trackId, callback !== null && callback !== void 0 ? callback : null);
-            }
-            if (transformedTrack.type === 'video') {
-                const callback = await ((_b = options.onVideoTrack) === null || _b === void 0 ? void 0 : _b.call(options, transformedTrack));
-                await options.parserState.registerVideoSampleCallback(transformedTrack.trackId, callback !== null && callback !== void 0 ? callback : null);
-            }
+            await (0, register_track_1.registerTrack)({
+                options,
+                state: options.parserState,
+                track: transformedTrack,
+            });
         }
         return {
             type: 'complete',
@@ -446,7 +444,6 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             data: iterator,
             size: boxSize,
             fileOffset,
-            logLevel,
         });
         return {
             type: 'complete',
@@ -498,10 +495,13 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     };
 };
 exports.processBox = processBox;
-const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, }) => {
-    let boxes = initialBoxes;
+const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, }) => {
+    const structure = {
+        type: 'iso-base-media',
+        boxes: initialBoxes,
+    };
     const initialOffset = iterator.counter.getOffset();
-    const alreadyHasMdat = boxes.find((b) => b.type === 'mdat-box');
+    const alreadyHasMdat = structure.boxes.find((b) => b.type === 'mdat-box');
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
         const result = continueMdat
@@ -527,13 +527,13 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
             }
             return {
                 status: 'incomplete',
-                segments: boxes,
+                segments: structure,
                 continueParsing: () => {
-                    return (0, exports.parseBoxes)({
+                    return (0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: boxes,
+                        initialBoxes: structure.boxes,
                         options,
                         continueMdat: false,
                         signal,
@@ -546,13 +546,13 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
         if (result.type === 'partial-mdat-box') {
             return {
                 status: 'incomplete',
-                segments: boxes,
+                segments: structure,
                 continueParsing: () => {
-                    return Promise.resolve((0, exports.parseBoxes)({
+                    return Promise.resolve((0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: boxes,
+                        initialBoxes: structure.boxes,
                         options,
                         continueMdat: result,
                         signal,
@@ -563,8 +563,8 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
             };
         }
         if (result.box.type === 'mdat-box' && alreadyHasMdat) {
-            boxes = boxes.filter((b) => b.type !== 'mdat-box');
-            boxes.push(result.box);
+            structure.boxes = structure.boxes.filter((b) => b.type !== 'mdat-box');
+            structure.boxes.push(result.box);
             iterator.allowDiscard();
             if (result.box.status !== 'samples-processed') {
                 throw new Error('unexpected');
@@ -572,7 +572,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
             break;
         }
         else {
-            boxes.push(result.box);
+            structure.boxes.push(result.box);
         }
         if (result.skipTo !== null) {
             if (!options.supportsContentRange) {
@@ -580,13 +580,13 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
             }
             return {
                 status: 'incomplete',
-                segments: boxes,
+                segments: structure,
                 continueParsing: () => {
-                    return (0, exports.parseBoxes)({
+                    return (0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: boxes,
+                        initialBoxes: structure.boxes,
                         options,
                         continueMdat: false,
                         signal,
@@ -599,13 +599,13 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
         if (iterator.bytesRemaining() < 0) {
             return {
                 status: 'incomplete',
-                segments: boxes,
+                segments: structure,
                 continueParsing: () => {
-                    return (0, exports.parseBoxes)({
+                    return (0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: boxes,
+                        initialBoxes: structure.boxes,
                         options,
                         continueMdat: false,
                         signal,
@@ -617,7 +617,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
         }
         iterator.removeBytesRead();
     }
-    const mdatState = (0, traversal_1.getMdatBox)(boxes);
+    const mdatState = (0, traversal_1.getMdatBox)(structure.boxes);
     const skipped = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-skipped' &&
         !options.canSkipVideoData &&
         options.supportsContentRange;
@@ -625,16 +625,16 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
     if (skipped || buffered) {
         return {
             status: 'incomplete',
-            segments: boxes,
+            segments: structure,
             continueParsing: () => {
                 if (buffered) {
                     iterator.skipTo(mdatState.fileOffset, false);
                 }
-                return (0, exports.parseBoxes)({
+                return (0, exports.parseIsoBaseMediaBoxes)({
                     iterator,
                     maxBytes,
                     allowIncompleteBoxes: false,
-                    initialBoxes: boxes,
+                    initialBoxes: structure.boxes,
                     options,
                     continueMdat: false,
                     signal,
@@ -646,7 +646,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
     }
     return {
         status: 'done',
-        segments: boxes,
+        segments: structure,
     };
 };
-exports.parseBoxes = parseBoxes;
+exports.parseIsoBaseMediaBoxes = parseIsoBaseMediaBoxes;

package/dist/boxes/iso-base-media/stsd/mebx.js

@@ -6,7 +6,7 @@ const parseMebx = async ({ iterator, offset, size, options, signal, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
-    const children = await (0, process_box_1.parseBoxes)({
+    const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
         iterator,
         maxBytes: iterator.counter.getOffset() - offset,
         allowIncompleteBoxes: false,
@@ -25,7 +25,7 @@ const parseMebx = async ({ iterator, offset, size, options, signal, }) => {
         offset,
         dataReferenceIndex,
         format: 'mebx',
-        children: children.segments,
+        children: children.segments.boxes,
     };
 };
 exports.parseMebx = parseMebx;

package/dist/boxes/iso-base-media/stsd/samples.d.ts

@@ -1,6 +1,6 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { LogLevel } from '../../../log';
-import type { AnySegment } from '../../../parse-result';
+import type { AnySegment, IsoBaseMediaBox } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 type SampleBase = {
     format: string;
@@ -37,7 +37,7 @@ export type VideoSample = SampleBase & {
     frameCountPerSample: number;
     depth: number;
     colorTableId: number;
-    descriptors: AnySegment[];
+    descriptors: IsoBaseMediaBox[];
     version: number;
     revisionLevel: number;
     vendor: number[];

package/dist/boxes/iso-base-media/stsd/samples.js

@@ -45,6 +45,7 @@ const audioTags = [
     'MAC6 ',
     'ima4',
     'fl32',
+    'lpcm',
     'fl64',
     'in24',
     'in32',
@@ -98,7 +99,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
             const packetSize = iterator.getUint16();
             const sampleRate = iterator.getFixedPointUnsigned1616Number();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = await (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
@@ -130,7 +131,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                     bytesPerPacket: null,
                     bytesPerFrame: null,
                     bitsPerSample: null,
-                    children: children.segments,
+                    children: children.segments.boxes,
                 },
             };
         }
@@ -145,7 +146,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
             const bytesPerFrame = iterator.getUint32();
             const bytesPerSample = iterator.getUint32();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = await (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
@@ -177,26 +178,26 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                     bytesPerPacket,
                     bytesPerFrame,
                     bitsPerSample: bytesPerSample,
-                    children: children.segments,
+                    children: children.segments.boxes,
                 },
             };
         }
         if (version === 2) {
-            const numberOfChannels = iterator.getUint16();
+            iterator.getUint16(); // always 3
             const sampleSize = iterator.getUint16();
             const compressionId = iterator.getUint16();
             const packetSize = iterator.getUint16();
             iterator.getFixedPointUnsigned1616Number(); // LQ sample rate;
             iterator.getUint32(); // ignore
             const higherSampleRate = iterator.getFloat64();
-            iterator.getUint32(); // ignore;
+            const numAudioChannel = iterator.getUint32(); // ignore;
             iterator.getUint32(); // ignore, always 0x7F000000?
-            const bitsPerCodedSample = iterator.getUint32();
+            const bitsPerChannel = iterator.getUint32();
             iterator.getUint32(); // ignore;
             const bytesPerFrame = iterator.getUint32();
             const samplesPerPacket = iterator.getUint32();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = await (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
@@ -219,7 +220,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                     vendor: [...Array.from(new Uint8Array(vendor))],
                     size: boxSize,
                     type: 'audio',
-                    numberOfChannels,
+                    numberOfChannels: numAudioChannel,
                     sampleSize,
                     compressionId,
                     packetSize,
@@ -227,8 +228,8 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                     samplesPerPacket,
                     bytesPerPacket: null,
                     bytesPerFrame,
-                    bitsPerSample: bitsPerCodedSample,
-                    children: children.segments,
+                    bitsPerSample: bitsPerChannel,
+                    children: children.segments.boxes,
                 },
             };
         }
@@ -251,7 +252,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
         const colorTableId = iterator.getInt16();
         const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
         const children = bytesRemainingInBox > 8
-            ? await (0, process_box_1.parseBoxes)({
+            ? await (0, process_box_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
@@ -262,7 +263,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                 logLevel,
             })
             : (iterator.discard(bytesRemainingInBox),
-                { status: 'done', segments: [] });
+                { status: 'done', segments: { boxes: [], type: 'iso-base-media' } });
         if (children.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
         }
@@ -287,7 +288,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                 compressorName,
                 depth,
                 colorTableId,
-                descriptors: children.segments,
+                descriptors: children.segments.boxes,
             },
         };
     }

package/dist/boxes/iso-base-media/trak/trak.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTrak = void 0;
 const process_box_1 = require("../process-box");
 const parseTrak = async ({ data, size, offsetAtStart, options, signal, logLevel, }) => {
-    const children = await (0, process_box_1.parseBoxes)({
+    const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
         iterator: data,
         maxBytes: size - (data.counter.getOffset() - offsetAtStart),
         allowIncompleteBoxes: false,
@@ -20,7 +20,7 @@ const parseTrak = async ({ data, size, offsetAtStart, options, signal, logLevel,
         offset: offsetAtStart,
         boxSize: size,
         type: 'trak-box',
-        children: children.segments,
+        children: children.segments.boxes,
     };
 };
 exports.parseTrak = parseTrak;

package/dist/boxes/iso-base-media/traversal.d.ts

@@ -17,7 +17,7 @@ import type { TkhdBox } from './tkhd';
 import type { TrakBox } from './trak/trak';
 import type { TrunBox } from './trun';
 export declare const getFtypBox: (segments: AnySegment[]) => FtypBox | null;
-export declare const getMoovBox: (segments: AnySegment[]) => MoovBox | null;
+export declare const getMoovBox: (segments: IsoBaseMediaBox[]) => MoovBox | null;
 export declare const getMoofBox: (main: AnySegment[]) => IsoBaseMediaBox | null;
 export declare const getMvhdBox: (moovBox: MoovBox) => MvhdBox | null;
 export declare const getTraks: (moovBox: MoovBox) => TrakBox[];

package/dist/boxes/riff/expect-riff-box.d.ts

@@ -0,0 +1,16 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { RiffStructure } from '../../parse-result';
+import type { ParserContext } from '../../parser-context';
+import type { RiffBox } from './riff-box';
+export type RiffResult = {
+    type: 'incomplete';
+    continueParsing: () => Promise<RiffResult>;
+} | {
+    type: 'complete';
+    box: RiffBox | null;
+};
+export declare const expectRiffBox: ({ iterator, options, structure, }: {
+    iterator: BufferIterator;
+    options: ParserContext;
+    structure: RiffStructure;
+}) => Promise<RiffResult>;

package/dist/boxes/riff/expect-riff-box.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectRiffBox = void 0;
+const is_movi_1 = require("./is-movi");
+const parse_movi_1 = require("./parse-movi");
+const parse_riff_box_1 = require("./parse-riff-box");
+const expectRiffBox = async ({ iterator, options, structure, }) => {
+    // Need at least 16 bytes to read LIST,size,movi,size
+    if (iterator.bytesRemaining() < 16) {
+        return {
+            type: 'incomplete',
+            continueParsing() {
+                return (0, exports.expectRiffBox)({ structure, iterator, options });
+            },
+        };
+    }
+    const ckId = iterator.getByteString(4);
+    const ckSize = iterator.getUint32Le();
+    if ((0, is_movi_1.isMoviAtom)(iterator, ckId)) {
+        iterator.discard(4);
+        return (0, parse_movi_1.parseMovi)({
+            iterator,
+            maxOffset: ckSize + iterator.counter.getOffset() - 4,
+            options,
+            structure,
+        });
+    }
+    // TODO: Add capability to read partially
+    if (iterator.bytesRemaining() < ckSize) {
+        iterator.counter.decrement(8);
+        return {
+            type: 'incomplete',
+            continueParsing: () => {
+                return (0, exports.expectRiffBox)({ structure, iterator, options });
+            },
+        };
+    }
+    return {
+        type: 'complete',
+        box: await (0, parse_riff_box_1.parseRiffBox)({
+            id: ckId,
+            iterator,
+            size: ckSize,
+            boxes: structure.boxes,
+            options,
+        }),
+    };
+};
+exports.expectRiffBox = expectRiffBox;

package/dist/boxes/riff/get-tracks-from-avi.d.ts

@@ -0,0 +1,21 @@
+import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { RiffStructure } from '../../parse-result';
+import type { ParserState } from '../../parser-state';
+import type { StrfBoxAudio, StrfBoxVideo, StrhBox } from './riff-box';
+export type AllTracks = {
+    videoTracks: VideoTrack[];
+    audioTracks: AudioTrack[];
+    otherTracks: OtherTrack[];
+};
+export declare const getNumberOfTracks: (structure: RiffStructure) => number;
+export declare const makeAviAudioTrack: ({ strf, index, }: {
+    strf: StrfBoxAudio;
+    index: number;
+}) => AudioTrack;
+export declare const makeAviVideoTrack: ({ strh, strf, index, }: {
+    strh: StrhBox;
+    strf: StrfBoxVideo;
+    index: number;
+}) => VideoTrack;
+export declare const getTracksFromAvi: (structure: RiffStructure, state: ParserState) => AllTracks;
+export declare const hasAllTracksFromAvi: (structure: RiffStructure, state: ParserState) => boolean;

package/dist/boxes/riff/get-tracks-from-avi.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAllTracksFromAvi = exports.getTracksFromAvi = exports.makeAviVideoTrack = exports.makeAviAudioTrack = exports.getNumberOfTracks = void 0;
+const add_avc_profile_to_track_1 = require("../../add-avc-profile-to-track");
+const timescale_1 = require("./timescale");
+const traversal_1 = require("./traversal");
+const getNumberOfTracks = (structure) => {
+    const avihBox = (0, traversal_1.getAvihBox)(structure);
+    if (avihBox) {
+        return avihBox.streams;
+    }
+    throw new Error('No avih box found');
+};
+exports.getNumberOfTracks = getNumberOfTracks;
+const makeAviAudioTrack = ({ strf, index, }) => {
+    // 255 = AAC
+    if (strf.formatTag !== 255) {
+        throw new Error(`Unsupported audio format ${strf.formatTag}`);
+    }
+    return {
+        type: 'audio',
+        codec: 'mp4a.40.2', // According to Claude 3.5 Sonnet
+        codecPrivate: new Uint8Array([18, 16]),
+        codecWithoutConfig: 'aac',
+        description: new Uint8Array([18, 16]),
+        numberOfChannels: strf.numberOfChannels,
+        sampleRate: strf.sampleRate,
+        timescale: timescale_1.MEDIA_PARSER_RIFF_TIMESCALE,
+        trackId: index,
+        trakBox: null,
+    };
+};
+exports.makeAviAudioTrack = makeAviAudioTrack;
+const makeAviVideoTrack = ({ strh, strf, index, }) => {
+    if (strh.handler !== 'H264') {
+        throw new Error(`Unsupported video codec ${strh.handler}`);
+    }
+    return {
+        codecPrivate: null,
+        codec: 'to-be-overriden-later',
+        codecWithoutConfig: 'h264',
+        codedHeight: strf.height,
+        codedWidth: strf.width,
+        width: strf.width,
+        height: strf.height,
+        type: 'video',
+        displayAspectHeight: strf.height,
+        timescale: timescale_1.MEDIA_PARSER_RIFF_TIMESCALE,
+        description: undefined,
+        trackId: index,
+        color: {
+            fullRange: null,
+            matrixCoefficients: null,
+            primaries: null,
+            transferCharacteristics: null,
+        },
+        displayAspectWidth: strf.width,
+        trakBox: null,
+        rotation: 0,
+        sampleAspectRatio: {
+            numerator: 1,
+            denominator: 1,
+        },
+        fps: strh.rate / strh.scale,
+    };
+};
+exports.makeAviVideoTrack = makeAviVideoTrack;
+const getTracksFromAvi = (structure, state) => {
+    if (!(0, traversal_1.isRiffAvi)(structure)) {
+        throw new Error('Not an AVI file');
+    }
+    const videoTracks = [];
+    const audioTracks = [];
+    const otherTracks = [];
+    const boxes = (0, traversal_1.getStrlBoxes)(structure);
+    let i = 0;
+    for (const box of boxes) {
+        const strh = (0, traversal_1.getStrhBox)(box.children);
+        const strf = (0, traversal_1.getStrfBox)(box.children);
+        if (!strh || !strf) {
+            continue;
+        }
+        if (strf.type === 'strf-box-video') {
+            videoTracks.push((0, add_avc_profile_to_track_1.addAvcProfileToTrack)((0, exports.makeAviVideoTrack)({ strh, strf, index: i }), state.getAvcProfile()));
+        }
+        else if (strh.fccType === 'auds') {
+            audioTracks.push((0, exports.makeAviAudioTrack)({ strf, index: i }));
+        }
+        else {
+            throw new Error(`Unsupported track type ${strh.fccType}`);
+        }
+        i++;
+    }
+    return { audioTracks, otherTracks, videoTracks };
+};
+exports.getTracksFromAvi = getTracksFromAvi;
+const hasAllTracksFromAvi = (structure, state) => {
+    if (!(0, traversal_1.isRiffAvi)(structure)) {
+        throw new Error('Not an AVI file');
+    }
+    const numberOfTracks = (0, exports.getNumberOfTracks)(structure);
+    const tracks = (0, exports.getTracksFromAvi)(structure, state);
+    return (tracks.videoTracks.length +
+        tracks.audioTracks.length +
+        tracks.otherTracks.length ===
+        numberOfTracks);
+};
+exports.hasAllTracksFromAvi = hasAllTracksFromAvi;

package/dist/boxes/riff/is-movi.d.ts

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

package/dist/boxes/riff/is-movi.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMoviAtom = void 0;
+const isMoviAtom = (iterator, ckId) => {
+    if (ckId !== 'LIST') {
+        return false;
+    }
+    const listType = iterator.getByteString(4);
+    iterator.counter.decrement(4);
+    return listType === 'movi';
+};
+exports.isMoviAtom = isMoviAtom;

package/dist/boxes/riff/parse-avih.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { RiffBox } from './riff-box';
+export declare const parseAvih: ({ iterator, size, }: {
+    iterator: BufferIterator;
+    size: number;
+}) => RiffBox;

package/dist/boxes/riff/parse-avih.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAvih = void 0;
+const parseAvih = ({ iterator, size, }) => {
+    const { expectNoMoreBytes } = iterator.startBox(size);
+    const dwMicroSecPerFrame = iterator.getUint32Le();
+    const dwMaxBytesPerSec = iterator.getUint32Le();
+    const paddingGranularity = iterator.getUint32Le();
+    const flags = iterator.getUint32Le();
+    const totalFrames = iterator.getUint32Le();
+    const initialFrames = iterator.getUint32Le();
+    const streams = iterator.getUint32Le();
+    const suggestedBufferSize = iterator.getUint32Le();
+    const width = iterator.getUint32Le();
+    const height = iterator.getUint32Le();
+    iterator.discard(16);
+    expectNoMoreBytes();
+    return {
+        type: 'avih-box',
+        microSecPerFrame: dwMicroSecPerFrame,
+        maxBytesPerSecond: dwMaxBytesPerSec,
+        paddingGranularity,
+        flags,
+        totalFrames,
+        initialFrames,
+        streams,
+        suggestedBufferSize,
+        height,
+        width,
+    };
+};
+exports.parseAvih = parseAvih;

package/dist/boxes/riff/parse-box.d.ts

@@ -0,0 +1,13 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParseResult, RiffStructure } from '../../parse-result';
+import type { ParserContext } from '../../parser-context';
+export declare const parseRiffBody: ({ iterator, structure, maxOffset, options, }: {
+    iterator: BufferIterator;
+    structure: RiffStructure;
+    maxOffset: number;
+    options: ParserContext;
+}) => Promise<ParseResult<RiffStructure>>;
+export declare const parseRiff: ({ iterator, options, }: {
+    iterator: BufferIterator;
+    options: ParserContext;
+}) => Promise<ParseResult<RiffStructure>>;