@remotion/media-parser 4.0.255 → 4.0.256

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAllTracksFromAvi = exports.getTracksFromAvi = exports.makeAviVideoTrack = exports.makeAviAudioTrack = exports.getNumberOfTracks = exports.TO_BE_OVERRIDDEN_LATER = 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");
+exports.TO_BE_OVERRIDDEN_LATER = 'to-be-overriden-later';
+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: exports.TO_BE_OVERRIDDEN_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');
+    }
+    try {
+        const numberOfTracks = (0, exports.getNumberOfTracks)(structure);
+        const tracks = (0, exports.getTracksFromAvi)(structure, state);
+        return (tracks.videoTracks.length +
+            tracks.audioTracks.length +
+            tracks.otherTracks.length ===
+            numberOfTracks);
+    }
+    catch (_a) {
+        return false;
+    }
+};
+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,15 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { Options, ParseMediaFields } from '../../options';
+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, fields, }: {
+    iterator: BufferIterator;
+    options: ParserContext;
+    fields: Options<ParseMediaFields>;
+}) => Promise<ParseResult<RiffStructure>>;

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiff = 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 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 continueAfterRiffBoxResult = ({ result, structure, iterator, maxOffset, options, }) => {
+    if (result.type === 'incomplete') {
+        return Promise.resolve({
+            status: 'incomplete',
+            async continueParsing() {
+                return Promise.resolve(continueAfterRiffBoxResult({
+                    result: await result.continueParsing(),
+                    structure,
+                    iterator,
+                    maxOffset,
+                    options,
+                }));
+            },
+            segments: structure,
+            skipTo: null,
+        });
+    }
+    if (result.type === 'complete' && result.box) {
+        structure.boxes.push(result.box);
+    }
+    return (0, exports.parseRiffBody)({ iterator, maxOffset, options, structure });
+};
+const parseRiffBody = async ({ iterator, structure, maxOffset, options, }) => {
+    while (iterator.bytesRemaining() > 0 &&
+        iterator.counter.getOffset() < maxOffset) {
+        const result = await (0, expect_riff_box_1.expectRiffBox)({
+            iterator,
+            options,
+            structure,
+        });
+        if (result.type === 'complete' && result.skipTo !== null) {
+            return {
+                status: 'incomplete',
+                skipTo: result.skipTo,
+                segments: structure,
+                continueParsing() {
+                    return Promise.resolve(continueAfterRiffBoxResult({
+                        iterator,
+                        maxOffset,
+                        options,
+                        result,
+                        structure,
+                    }));
+                },
+            };
+        }
+        if (result.type === 'incomplete') {
+            return {
+                status: 'incomplete',
+                async continueParsing() {
+                    return Promise.resolve(continueAfterRiffBoxResult({
+                        iterator,
+                        maxOffset,
+                        options,
+                        result: await result.continueParsing(),
+                        structure,
+                    }));
+                },
+                segments: structure,
+                skipTo: null,
+            };
+        }
+        if (result.box === null) {
+            continue;
+        }
+        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, options.parserState);
+            if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
+                options.parserState.tracks.setIsDone();
+            }
+        }
+        // When parsing a WAV
+        if (result.box.type === 'wave-format-box') {
+            options.parserState.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' && options.onAudioTrack) {
+                const audioTrack = (0, get_tracks_from_avi_1.makeAviAudioTrack)({
+                    index: options.nextTrackIndex,
+                    strf,
+                });
+                await (0, register_track_1.registerTrack)({
+                    options,
+                    state: options.parserState,
+                    track: audioTrack,
+                });
+            }
+            if (options.onVideoTrack && strf.type === 'strf-box-video') {
+                const videoTrack = (0, get_tracks_from_avi_1.makeAviVideoTrack)({
+                    strh,
+                    index: options.nextTrackIndex,
+                    strf,
+                });
+                (0, register_track_1.registerVideoTrackWhenProfileIsAvailable)({
+                    options,
+                    state: options.parserState,
+                    track: videoTrack,
+                });
+            }
+            options.nextTrackIndex++;
+        }
+    }
+    return {
+        status: 'done',
+        segments: structure,
+    };
+};
+exports.parseRiffBody = parseRiffBody;
+const parseRiff = ({ iterator, options, fields, }) => {
+    const structure = { type: 'riff', boxes: [] };
+    const riff = iterator.getByteString(4);
+    if (riff !== 'RIFF') {
+        throw new Error('Not a RIFF file');
+    }
+    const size = iterator.getUint32Le();
+    const fileType = iterator.getByteString(4);
+    if (fileType !== 'WAVE' && fileType !== 'AVI') {
+        throw new Error(`File type ${fileType} not supported`);
+    }
+    structure.boxes.push({ type: 'riff-header', fileSize: size, fileType });
+    if ((0, has_all_info_1.hasAllInfo)({ fields, structure, state: options.parserState })) {
+        return Promise.resolve({
+            status: 'done',
+            segments: structure,
+        });
+    }
+    return (0, exports.parseRiffBody)({ iterator, structure, maxOffset: Infinity, options });
+};
+exports.parseRiff = parseRiff;

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

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

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFmtBox = void 0;
+const parseFmtBox = ({ iterator, boxes, size, }) => {
+    const box = iterator.startBox(size);
+    const header = boxes.find((b) => b.type === 'riff-header');
+    if (!header) {
+        throw new Error('Expected RIFF header');
+    }
+    if (header.fileType !== 'WAVE') {
+        throw new Error('Only supporting WAVE type');
+    }
+    const wFormatTag = iterator.getUint16Le();
+    if (wFormatTag !== 1) {
+        throw new Error('Expected wFormatTag to be 1, only supporting this');
+    }
+    const numberOfChannels = iterator.getUint16Le();
+    const sampleRate = iterator.getUint32Le();
+    const byteRate = iterator.getUint32Le();
+    const blockAlign = iterator.getUint16Le();
+    const bitsPerSample = iterator.getUint16Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'wave-format-box',
+        formatTag: wFormatTag,
+        numberOfChannels,
+        sampleRate,
+        blockAlign,
+        byteRate,
+        bitsPerSample,
+    };
+};
+exports.parseFmtBox = parseFmtBox;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIsft = void 0;
+const parseIsft = ({ iterator, size, }) => {
+    const { expectNoMoreBytes } = iterator.startBox(size);
+    const software = iterator.getByteString(size - 1);
+    const last = iterator.getUint8();
+    if (last !== 0) {
+        throw new Error(`Expected 0 byte, got ${last}`);
+    }
+    expectNoMoreBytes();
+    return {
+        type: 'isft-box',
+        software,
+    };
+};
+exports.parseIsft = parseIsft;

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseListBox = void 0;
+const parse_box_1 = require("./parse-box");
+const parseListBox = async ({ iterator, size, options, }) => {
+    const counter = iterator.counter.getOffset();
+    const listType = iterator.getByteString(4);
+    if (listType === 'movi') {
+        throw new Error('should not be handled here');
+    }
+    const structure = {
+        type: 'riff',
+        boxes: [],
+    };
+    const result = await (0, parse_box_1.parseRiffBody)({
+        structure,
+        iterator,
+        maxOffset: counter + size,
+        options,
+    });
+    if (result.status === 'incomplete') {
+        throw new Error(`Should only parse complete boxes (${listType})`);
+    }
+    return {
+        type: 'list-box',
+        listType,
+        children: structure.boxes,
+    };
+};
+exports.parseListBox = parseListBox;

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

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

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMovi = exports.handleChunk = void 0;
+const parse_avc_1 = require("../avc/parse-avc");
+const timescale_1 = require("./timescale");
+const traversal_1 = require("./traversal");
+const getStrhForIndex = (structure, trackId) => {
+    const boxes = (0, traversal_1.getStrlBoxes)(structure);
+    const box = boxes[trackId];
+    if (!box) {
+        throw new Error('Expected box');
+    }
+    const strh = (0, traversal_1.getStrhBox)(box.children);
+    if (!strh) {
+        throw new Error('strh');
+    }
+    return strh;
+};
+const handleChunk = async ({ iterator, options, structure, ckId, ckSize, }) => {
+    const videoChunk = ckId.match(/^([0-9]{2})dc$/);
+    if (videoChunk) {
+        const trackId = parseInt(videoChunk[1], 10);
+        const strh = getStrhForIndex(structure, trackId);
+        const samplesPerSecond = strh.rate / strh.scale;
+        const nthSample = options.parserState.getSamplesForTrack(trackId);
+        const timeInSec = nthSample / samplesPerSecond;
+        const timestamp = Math.floor(timeInSec * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE);
+        const duration = Math.floor((1 / samplesPerSecond) * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE);
+        const data = iterator.getSlice(ckSize);
+        const infos = (0, parse_avc_1.parseAvc)(data);
+        const keyOrDelta = infos.find((i) => i.type === 'keyframe' || i.type === 'delta-frame');
+        if (!keyOrDelta) {
+            throw new Error('expected avc to contain info about key or delta');
+        }
+        const avcProfile = infos.find((i) => i.type === 'avc-profile');
+        const ppsProfile = infos.find((i) => i.type === 'avc-pps');
+        if (avcProfile && ppsProfile) {
+            await options.parserState.onProfile({ pps: ppsProfile, sps: avcProfile });
+            options.parserState.tracks.setIsDone();
+        }
+        await options.parserState.onVideoSample(trackId, {
+            cts: timestamp,
+            dts: timestamp,
+            data,
+            duration,
+            timestamp,
+            trackId,
+            type: keyOrDelta.type === 'keyframe' ? 'key' : 'delta',
+        });
+        return;
+    }
+    const audioChunk = ckId.match(/^([0-9]{2})wb$/);
+    if (audioChunk) {
+        const trackId = parseInt(audioChunk[1], 10);
+        const strh = getStrhForIndex(structure, trackId);
+        const samplesPerSecond = strh.rate / strh.scale;
+        const nthSample = options.parserState.getSamplesForTrack(trackId);
+        const timeInSec = nthSample / samplesPerSecond;
+        const timestamp = timeInSec * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE;
+        const duration = (1 / samplesPerSecond) * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE;
+        await options.parserState.onAudioSample(trackId, {
+            cts: timestamp,
+            dts: timestamp,
+            data: iterator.getSlice(ckSize),
+            duration,
+            timestamp,
+            trackId,
+            type: 'key',
+        });
+    }
+};
+exports.handleChunk = handleChunk;
+const parseMovi = async ({ iterator, maxOffset, options, structure, }) => {
+    while (iterator.counter.getOffset() < maxOffset) {
+        if (iterator.bytesRemaining() < 8) {
+            return {
+                type: 'incomplete',
+                continueParsing: () => {
+                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, options, structure }));
+                },
+            };
+        }
+        const ckId = iterator.getByteString(4);
+        const ckSize = iterator.getUint32Le();
+        if (options.parserState.maySkipVideoData() &&
+            options.parserState.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, options, structure }));
+                },
+            };
+        }
+        await (0, exports.handleChunk)({ iterator, options, structure, ckId, ckSize });
+        // Discard added zeroes
+        while (iterator.counter.getOffset() < maxOffset &&
+            iterator.bytesRemaining() > 0) {
+            if (iterator.getUint8() !== 0) {
+                iterator.counter.decrement(1);
+                break;
+            }
+        }
+    }
+    if (iterator.counter.getOffset() === maxOffset) {
+        return {
+            type: 'complete',
+            box: {
+                type: 'movi-box',
+            },
+            skipTo: null,
+        };
+    }
+    if (iterator.counter.getOffset() > maxOffset) {
+        throw new Error('Oops, this should not happen!');
+    }
+    return {
+        type: 'incomplete',
+        continueParsing: () => {
+            return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, options, structure }));
+        },
+    };
+};
+exports.parseMovi = parseMovi;

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

@@ -0,0 +1,10 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserContext } from '../../parser-context';
+import type { RiffBox } from './riff-box';
+export declare const parseRiffBox: ({ iterator, size, id, boxes, options, }: {
+    iterator: BufferIterator;
+    size: number;
+    id: string;
+    boxes: RiffBox[];
+    options: ParserContext;
+}) => Promise<RiffBox>;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiffBox = void 0;
+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, options, }) => {
+    if (id === 'fmt') {
+        return Promise.resolve((0, parse_fmt_box_1.parseFmtBox)({ iterator, boxes, size }));
+    }
+    if (id === 'LIST') {
+        return (0, parse_list_box_1.parseListBox)({ iterator, size, options });
+    }
+    if (id === 'ISFT') {
+        return Promise.resolve((0, parse_isft_1.parseIsft)({ iterator, size }));
+    }
+    if (id === 'avih') {
+        return Promise.resolve((0, parse_avih_1.parseAvih)({ iterator, size }));
+    }
+    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',
+        size,
+        id,
+    };
+    return Promise.resolve(box);
+};
+exports.parseRiffBox = parseRiffBox;

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

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