@remotion/media-parser 4.0.249 → 4.0.250

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

@@ -67,9 +67,6 @@ const makeAviVideoTrack = ({ strh, strf, index, }) => {
 };
 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 = [];
@@ -77,10 +74,10 @@ const getTracksFromAvi = (structure, state) => {
     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) {
+        if (!strh) {
             continue;
         }
+        const { strf } = strh;
         if (strf.type === 'strf-box-video') {
             videoTracks.push((0, add_avc_profile_to_track_1.addAvcProfileToTrack)((0, exports.makeAviVideoTrack)({ strh, strf, index: i }), state.riff.getAvcProfile()));
         }
@@ -95,17 +92,16 @@ const getTracksFromAvi = (structure, state) => {
     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 hasAllTracksFromAvi = (state) => {
     try {
+        const structure = state.structure.getStructure();
         const numberOfTracks = (0, exports.getNumberOfTracks)(structure);
         const tracks = (0, exports.getTracksFromAvi)(structure, state);
         return (tracks.videoTracks.length +
             tracks.audioTracks.length +
             tracks.otherTracks.length ===
-            numberOfTracks);
+            numberOfTracks &&
+            !tracks.videoTracks.find((t) => t.codec === exports.TO_BE_OVERRIDDEN_LATER));
     }
     catch (_a) {
         return false;

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

@@ -1,7 +1,8 @@
 import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseFmtBox: ({ iterator, boxes, size, }: {
+export declare const parseFmtBox: ({ iterator, size, state, }: {
     iterator: BufferIterator;
-    boxes: RiffBox[];
     size: number;
+    state: ParserState;
 }) => RiffBox;

package/dist/boxes/riff/parse-fmt-box.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFmtBox = void 0;
-const parseFmtBox = ({ iterator, boxes, size, }) => {
+const parseFmtBox = ({ iterator, size, state, }) => {
     const box = iterator.startBox(size);
-    const header = boxes.find((b) => b.type === 'riff-header');
-    if (!header) {
-        throw new Error('Expected RIFF header');
+    const structure = state.structure.getStructure();
+    const riffHeader = structure.boxes.find((b) => b.type === 'riff-header');
+    if (!riffHeader) {
+        throw new Error('Expected RIFF header to be parsed before fmt');
     }
-    if (header.fileType !== 'WAVE') {
+    // TODO: Can we delete this?
+    if (riffHeader.fileType !== 'WAVE') {
         throw new Error('Only supporting WAVE type');
     }
     const wFormatTag = iterator.getUint16Le();

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

@@ -1,10 +1,8 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseListBox: ({ iterator, size, state, fields, }: {
+export declare const parseListBox: ({ iterator, size, state, }: {
     iterator: BufferIterator;
     size: number;
     state: ParserState;
-    fields: Options<ParseMediaFields>;
 }) => Promise<RiffBox>;

package/dist/boxes/riff/parse-list-box.js

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseListBox = void 0;
-const parse_riff_body_1 = require("./parse-riff-body");
-const parseListBox = async ({ iterator, size, state, fields, }) => {
+const expect_riff_box_1 = require("./expect-riff-box");
+const parseListBox = async ({ iterator, size, state, }) => {
     const counter = iterator.counter.getOffset();
     const listType = iterator.getByteString(4, false);
     if (listType === 'movi') {
         throw new Error('should not be handled here');
     }
-    const structure = {
-        type: 'riff',
-        boxes: [],
-    };
-    const result = await (0, parse_riff_body_1.parseRiffBody)({
-        structure,
-        iterator,
-        maxOffset: counter + size,
-        state,
-        fields,
-    });
-    if (result.status === 'incomplete') {
-        throw new Error(`Should only parse complete boxes (${listType})`);
+    const boxes = [];
+    const maxOffset = counter + size;
+    while (iterator.counter.getOffset() < maxOffset) {
+        const result = await (0, expect_riff_box_1.expectRiffBox)({
+            iterator,
+            state,
+        });
+        if (result.box !== null) {
+            boxes.push(result.box);
+        }
+        else {
+            throw new Error('Unexpected result');
+        }
     }
     return {
         type: 'list-box',
         listType,
-        children: structure.boxes,
+        children: boxes,
     };
 };
 exports.parseListBox = parseListBox;

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

@@ -1,17 +1,14 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { RiffStructure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffResult } from './expect-riff-box';
-export declare const handleChunk: ({ iterator, state, structure, ckId, ckSize, }: {
+export declare const handleChunk: ({ iterator, state, ckId, ckSize, }: {
     iterator: BufferIterator;
     state: ParserState;
-    structure: RiffStructure;
     ckId: string;
     ckSize: number;
 }) => Promise<void>;
-export declare const parseMovi: ({ iterator, maxOffset, state, structure, }: {
+export declare const parseMovi: ({ iterator, maxOffset, state, }: {
     iterator: BufferIterator;
     maxOffset: number;
     state: ParserState;
-    structure: RiffStructure;
 }) => Promise<RiffResult>;

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

@@ -18,12 +18,12 @@ const getStrhForIndex = (structure, trackId) => {
     }
     return strh;
 };
-const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
+const handleChunk = async ({ iterator, state, ckId, ckSize, }) => {
     const offset = iterator.counter.getOffset();
     const videoChunk = ckId.match(/^([0-9]{2})dc$/);
     if (videoChunk) {
         const trackId = parseInt(videoChunk[1], 10);
-        const strh = getStrhForIndex(structure, trackId);
+        const strh = getStrhForIndex(state.structure.getStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
@@ -56,7 +56,7 @@ const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
     const audioChunk = ckId.match(/^([0-9]{2})wb$/);
     if (audioChunk) {
         const trackId = parseInt(audioChunk[1], 10);
-        const strh = getStrhForIndex(structure, trackId);
+        const strh = getStrhForIndex(state.structure.getStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
@@ -81,66 +81,44 @@ const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
     }
 };
 exports.handleChunk = handleChunk;
-const parseMovi = async ({ iterator, maxOffset, state, structure, }) => {
-    while (iterator.counter.getOffset() < maxOffset) {
-        if (iterator.bytesRemaining() < 8) {
-            return {
-                type: 'incomplete',
-                continueParsing: () => {
-                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
-                },
-            };
-        }
-        const ckId = iterator.getByteString(4, false);
-        const ckSize = iterator.getUint32Le();
-        if ((0, may_skip_video_data_1.maySkipVideoData)({
-            state,
-        }) &&
-            state.riff.getAvcProfile()) {
-            return {
-                type: 'complete',
-                box: {
-                    type: 'movi-box',
-                },
-                skipTo: maxOffset,
-            };
-        }
-        if (iterator.bytesRemaining() < ckSize) {
-            iterator.counter.decrement(8);
-            return {
-                type: 'incomplete',
-                continueParsing: () => {
-                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
-                },
-            };
-        }
-        await (0, exports.handleChunk)({ iterator, state, structure, ckId, ckSize });
-        // Discard added zeroes
-        while (iterator.counter.getOffset() < maxOffset &&
-            iterator.bytesRemaining() > 0) {
-            if (iterator.getUint8() !== 0) {
-                iterator.counter.decrement(1);
-                break;
-            }
-        }
+const parseMovi = async ({ iterator, maxOffset, state, }) => {
+    if ((0, may_skip_video_data_1.maySkipVideoData)({
+        state,
+    }) &&
+        state.riff.getAvcProfile()) {
+        return {
+            box: null,
+            skipTo: maxOffset,
+        };
     }
-    if (iterator.counter.getOffset() === maxOffset) {
+    if (iterator.bytesRemaining() < 8) {
         return {
-            type: 'complete',
-            box: {
-                type: 'movi-box',
-            },
+            box: null,
             skipTo: null,
         };
     }
-    if (iterator.counter.getOffset() > maxOffset) {
-        throw new Error('Oops, this should not happen!');
+    const checkpoint = iterator.startCheckpoint();
+    const ckId = iterator.getByteString(4, false);
+    const ckSize = iterator.getUint32Le();
+    if (iterator.bytesRemaining() < ckSize) {
+        checkpoint.returnToCheckpoint();
+        return {
+            box: null,
+            skipTo: null,
+        };
+    }
+    await (0, exports.handleChunk)({ iterator, state, ckId, ckSize });
+    // Discard added zeroes
+    while (iterator.counter.getOffset() < maxOffset &&
+        iterator.bytesRemaining() > 0) {
+        if (iterator.getUint8() !== 0) {
+            iterator.counter.decrement(1);
+            break;
+        }
     }
     return {
-        type: 'incomplete',
-        continueParsing: () => {
-            return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
-        },
+        box: null,
+        skipTo: null,
     };
 };
 exports.parseMovi = parseMovi;

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

@@ -1,11 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
-import type { ParseResult, RiffStructure } from '../../parse-result';
+import type { ParseResult } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-export declare const parseRiffBody: ({ iterator, structure, maxOffset, state, fields, }: {
+export declare const parseRiffBody: ({ iterator, state, }: {
     iterator: BufferIterator;
-    structure: RiffStructure;
-    maxOffset: number;
     state: ParserState;
-    fields: Options<ParseMediaFields>;
 }) => Promise<ParseResult>;

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

@@ -1,105 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRiffBody = void 0;
-const get_tracks_1 = require("../../get-tracks");
-const has_all_info_1 = require("../../has-all-info");
-const register_track_1 = require("../../register-track");
-const continue_after_riff_result_1 = require("./continue-after-riff-result");
 const expect_riff_box_1 = require("./expect-riff-box");
-const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
-const traversal_1 = require("./traversal");
-const parseRiffBody = async ({ iterator, structure, maxOffset, state, fields, }) => {
-    while (iterator.bytesRemaining() > 0 &&
-        iterator.counter.getOffset() < maxOffset &&
-        !(0, has_all_info_1.hasAllInfo)({ fields, state })) {
-        const result = await (0, expect_riff_box_1.expectRiffBox)({
-            iterator,
-            state,
-            structure,
-            fields,
-        });
-        if (result.type === 'complete' && result.skipTo !== null) {
-            return {
-                status: 'incomplete',
-                skipTo: result.skipTo,
-                continueParsing() {
-                    return Promise.resolve((0, continue_after_riff_result_1.continueAfterRiffBoxResult)({
-                        iterator,
-                        maxOffset,
-                        state,
-                        result,
-                        structure,
-                        fields,
-                    }));
-                },
-            };
-        }
-        if (result.type === 'incomplete') {
-            return {
-                status: 'incomplete',
-                async continueParsing() {
-                    return Promise.resolve((0, continue_after_riff_result_1.continueAfterRiffBoxResult)({
-                        iterator,
-                        maxOffset,
-                        state,
-                        result: await result.continueParsing(),
-                        structure,
-                        fields,
-                    }));
-                },
-                skipTo: null,
-            };
-        }
-        if (result.box === null) {
-            continue;
-        }
+const parse_video_section_1 = require("./parse-video-section");
+const parseRiffBody = async ({ iterator, state, }) => {
+    if (state.videoSection.isInVideoSectionState(iterator) === 'in-section') {
+        const videoSec = await (0, parse_video_section_1.parseVideoSection)({ state, iterator });
+        return {
+            skipTo: videoSec.skipTo,
+        };
+    }
+    const result = await (0, expect_riff_box_1.expectRiffBox)({
+        iterator,
+        state,
+    });
+    if (result.box !== null) {
+        const structure = state.structure.getStructure();
         structure.boxes.push(result.box);
-        // When parsing an AVI
-        if (result.box.type === 'list-box' && result.box.listType === 'hdrl') {
-            const tracks = (0, get_tracks_1.getTracks)(structure, state);
-            if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
-                state.callbacks.tracks.setIsDone();
-            }
-        }
-        // When parsing a WAV
-        if (result.box.type === 'wave-format-box') {
-            state.callbacks.tracks.setIsDone();
-        }
-        if (result.box.type === 'strf-box-video' ||
-            result.box.type === 'strf-box-audio') {
-            const strh = (0, traversal_1.getStrhBox)(structure.boxes);
-            const strf = (0, traversal_1.getStrfBox)(structure.boxes);
-            if (!strh || !strf) {
-                throw new Error('strh or strf box missing');
-            }
-            if (strf.type === 'strf-box-audio' && state.onAudioTrack) {
-                const audioTrack = (0, get_tracks_from_avi_1.makeAviAudioTrack)({
-                    index: state.riff.getNextTrackIndex(),
-                    strf,
-                });
-                await (0, register_track_1.registerTrack)({
-                    state,
-                    track: audioTrack,
-                    container: 'avi',
-                });
-            }
-            if (state.onVideoTrack && strf.type === 'strf-box-video') {
-                const videoTrack = (0, get_tracks_from_avi_1.makeAviVideoTrack)({
-                    strh,
-                    index: state.riff.getNextTrackIndex(),
-                    strf,
-                });
-                (0, register_track_1.registerVideoTrackWhenProfileIsAvailable)({
-                    state,
-                    track: videoTrack,
-                    container: 'avi',
-                });
-            }
-            state.riff.incrementNextTrackIndex();
-        }
     }
     return {
-        status: 'done',
+        skipTo: result.skipTo,
     };
 };
 exports.parseRiffBody = parseRiffBody;

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

@@ -1,12 +1,9 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseRiffBox: ({ iterator, size, id, boxes, state, fields, }: {
+export declare const parseRiffBox: ({ iterator, size, id, state, }: {
     iterator: BufferIterator;
     size: number;
     id: string;
-    boxes: RiffBox[];
     state: ParserState;
-    fields: Options<ParseMediaFields>;
 }) => Promise<RiffBox>;

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

@@ -5,14 +5,13 @@ const parse_avih_1 = require("./parse-avih");
 const parse_fmt_box_1 = require("./parse-fmt-box");
 const parse_isft_1 = require("./parse-isft");
 const parse_list_box_1 = require("./parse-list-box");
-const parse_strf_1 = require("./parse-strf");
 const parse_strh_1 = require("./parse-strh");
-const parseRiffBox = ({ iterator, size, id, boxes, state, fields, }) => {
+const parseRiffBox = ({ iterator, size, id, state, }) => {
     if (id === 'fmt') {
-        return Promise.resolve((0, parse_fmt_box_1.parseFmtBox)({ iterator, boxes, size }));
+        return Promise.resolve((0, parse_fmt_box_1.parseFmtBox)({ iterator, size, state }));
     }
     if (id === 'LIST') {
-        return (0, parse_list_box_1.parseListBox)({ iterator, size, state, fields });
+        return (0, parse_list_box_1.parseListBox)({ iterator, size, state });
     }
     if (id === 'ISFT') {
         return Promise.resolve((0, parse_isft_1.parseIsft)({ iterator, size }));
@@ -23,9 +22,6 @@ const parseRiffBox = ({ iterator, size, id, boxes, state, fields, }) => {
     if (id === 'strh') {
         return Promise.resolve((0, parse_strh_1.parseStrh)({ iterator, size }));
     }
-    if (id === 'strf') {
-        return Promise.resolve((0, parse_strf_1.parseStrf)({ iterator, size, boxes }));
-    }
     iterator.discard(size);
     const box = {
         type: 'riff-box',

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

@@ -0,0 +1,7 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseRiffHeader: ({ iterator, state, }: {
+    iterator: BufferIterator;
+    state: ParserState;
+}) => ParseResult;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiffHeader = void 0;
+const parseRiffHeader = ({ iterator, state, }) => {
+    const riff = iterator.getByteString(4, false);
+    if (riff !== 'RIFF') {
+        throw new Error('Not a RIFF file');
+    }
+    const structure = state.structure.getStructure();
+    if (structure.type !== 'riff') {
+        throw new Error('Structure is not a RIFF structure');
+    }
+    const size = iterator.getUint32Le();
+    const fileType = iterator.getByteString(4, false);
+    if (fileType !== 'WAVE' && fileType !== 'AVI') {
+        throw new Error(`File type ${fileType} not supported`);
+    }
+    structure.boxes.push({ type: 'riff-header', fileSize: size, fileType });
+    return {
+        skipTo: null,
+    };
+};
+exports.parseRiffHeader = parseRiffHeader;

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

@@ -0,0 +1,7 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseRiff: ({ iterator, state, }: {
+    iterator: BufferIterator;
+    state: ParserState;
+}) => Promise<ParseResult>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiff = void 0;
+const parse_riff_body_1 = require("./parse-riff-body");
+const parse_riff_header_1 = require("./parse-riff-header");
+const parseRiff = ({ iterator, state, }) => {
+    if (iterator.counter.getOffset() === 0) {
+        return Promise.resolve((0, parse_riff_header_1.parseRiffHeader)({ iterator, state }));
+    }
+    return (0, parse_riff_body_1.parseRiffBody)({
+        iterator,
+        state,
+    });
+};
+exports.parseRiff = parseRiff;

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

@@ -1,7 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { RiffBox } from './riff-box';
-export declare const parseStrf: ({ iterator, size, boxes, }: {
+import type { FccType, StrfBoxAudio, StrfBoxVideo } from './riff-box';
+export declare const parseStrf: ({ iterator, size, fccType, }: {
     iterator: BufferIterator;
     size: number;
-    boxes: RiffBox[];
-}) => RiffBox;
+    fccType: FccType;
+}) => StrfBoxAudio | StrfBoxVideo;

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

@@ -51,17 +51,13 @@ const parseStrfVideo = ({ iterator, size, }) => {
         yPelsPerMeter,
     };
 };
-const parseStrf = ({ iterator, size, boxes, }) => {
-    const strh = boxes.find((b) => b.type === 'strh-box');
-    if (!strh) {
-        throw new Error('strh box not found');
-    }
-    if (strh.fccType === 'vids') {
+const parseStrf = ({ iterator, size, fccType, }) => {
+    if (fccType === 'vids') {
         return parseStrfVideo({ iterator, size });
     }
-    if (strh.fccType === 'auds') {
+    if (fccType === 'auds') {
         return parseStrfAudio({ iterator, size });
     }
-    throw new Error(`Unsupported fccType: ${strh.fccType}`);
+    throw new Error(`Unsupported fccType: ${fccType}`);
 };
 exports.parseStrf = parseStrf;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStrh = void 0;
+const parse_strf_1 = require("./parse-strf");
 const parseStrh = ({ iterator, size, }) => {
     const box = iterator.startBox(size);
     const fccType = iterator.getByteString(4, false);
@@ -28,6 +29,15 @@ const parseStrh = ({ iterator, size, }) => {
     const quality = iterator.getUint32Le();
     const sampleSize = iterator.getUint32Le();
     box.discardRest();
+    const ckId = iterator.getByteString(4, false);
+    const ckSize = iterator.getUint32Le();
+    if (ckId !== 'strf') {
+        throw new Error(`Expected strf, got ${JSON.stringify(ckId)}`);
+    }
+    if (iterator.bytesRemaining() < ckSize) {
+        throw new Error('Expected strf to be complete');
+    }
+    const strf = (0, parse_strf_1.parseStrf)({ iterator, size: ckSize, fccType });
     return {
         type: 'strh-box',
         fccType,
@@ -43,6 +53,7 @@ const parseStrh = ({ iterator, size, }) => {
         start,
         suggestedBufferSize,
         language,
+        strf,
     };
 };
 exports.parseStrh = parseStrh;

package/dist/boxes/riff/parse-video-section.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseVideoSection: ({ state, iterator, }: {
+    state: ParserState;
+    iterator: BufferIterator;
+}) => Promise<import("./expect-riff-box").RiffResult>;

package/dist/boxes/riff/parse-video-section.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVideoSection = void 0;
+const get_tracks_1 = require("../../get-tracks");
+const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
+const parse_movi_1 = require("./parse-movi");
+const parseVideoSection = ({ state, iterator, }) => {
+    const videoSection = state.videoSection.getVideoSection();
+    const movi = (0, parse_movi_1.parseMovi)({
+        iterator,
+        maxOffset: videoSection.start + videoSection.size,
+        state,
+    });
+    const tracks = (0, get_tracks_1.getTracks)(state);
+    if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
+        state.callbacks.tracks.setIsDone();
+    }
+    return movi;
+};
+exports.parseVideoSection = parseVideoSection;

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

@@ -30,9 +30,10 @@ export type AvihBox = {
     width: number;
     height: number;
 };
+export type FccType = 'vids' | 'auds';
 export type StrhBox = {
     type: 'strh-box';
-    fccType: 'vids' | 'auds';
+    fccType: FccType;
     handler: 'H264' | number;
     flags: number;
     priority: number;
@@ -45,6 +46,7 @@ export type StrhBox = {
     quality: number;
     sampleSize: number;
     language: number;
+    strf: StrfBoxVideo | StrfBoxAudio;
 };
 export type StrfBoxVideo = {
     type: 'strf-box-video';
@@ -75,11 +77,8 @@ export type RiffHeader = {
     fileSize: number;
     fileType: string;
 };
-export type MoviBox = {
-    type: 'movi-box';
-};
 export type IsftBox = {
     type: 'isft-box';
     software: string;
 };
-export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | MoviBox | IsftBox;
+export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | IsftBox;