@remotion/media-parser 4.0.231 → 4.0.233

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiff = exports.parseRiffBody = void 0;
+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') {
+        if (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 === '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);
+        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, }) => {
+    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 });
+    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-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,122 @@
+"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 });
+        }
+        await options.parserState.onVideoSample(trackId, {
+            cts: timestamp,
+            dts: timestamp,
+            data,
+            duration,
+            timestamp,
+            trackId,
+            type: keyOrDelta.type === 'keyframe' ? 'key' : 'delta',
+        });
+    }
+    else {
+        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 (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',
+            },
+        };
+    }
+    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,33 @@
+"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_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 === '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;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrf = void 0;
+const parseStrfAudio = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const formatTag = iterator.getUint16Le();
+    const numberOfChannels = iterator.getUint16Le();
+    const samplesPerSec = iterator.getUint32Le();
+    const avgBytesPerSec = iterator.getUint32Le();
+    const blockAlign = iterator.getUint16Le();
+    const bitsPerSample = iterator.getUint16Le();
+    const cbSize = iterator.getUint16Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-audio',
+        avgBytesPerSecond: avgBytesPerSec,
+        bitsPerSample,
+        blockAlign,
+        cbSize,
+        formatTag,
+        numberOfChannels,
+        sampleRate: samplesPerSec,
+    };
+};
+const parseStrfVideo = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const biSize = iterator.getUint32Le();
+    const width = iterator.getInt32Le();
+    const height = iterator.getInt32Le();
+    const planes = iterator.getUint16Le();
+    const bitCount = iterator.getUint16Le();
+    const compression = iterator.getByteString(4);
+    const sizeImage = iterator.getUint32Le();
+    const xPelsPerMeter = iterator.getInt32Le();
+    const yPelsPerMeter = iterator.getInt32Le();
+    const clrUsed = iterator.getUint32Le();
+    const clrImportant = iterator.getUint32Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-video',
+        biSize,
+        bitCount,
+        clrImportant,
+        clrUsed,
+        compression,
+        height,
+        planes,
+        sizeImage,
+        width,
+        xPelsPerMeter,
+        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') {
+        return parseStrfVideo({ iterator, size });
+    }
+    if (strh.fccType === 'auds') {
+        return parseStrfAudio({ iterator, size });
+    }
+    throw new Error(`Unsupported fccType: ${strh.fccType}`);
+};
+exports.parseStrf = parseStrf;

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

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

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrh = void 0;
+const parseStrh = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const fccType = iterator.getByteString(4);
+    if (fccType !== 'vids' && fccType !== 'auds') {
+        throw new Error('Expected AVI handler to be vids / auds');
+    }
+    const handler = fccType === 'vids' ? iterator.getByteString(4) : iterator.getUint32Le();
+    if (typeof handler === 'string' && handler !== 'H264') {
+        throw new Error(`Only H264 is supported as a stream type in .avi, got ${handler}`);
+    }
+    if (fccType === 'auds' && handler !== 1) {
+        throw new Error(`Only "1" is supported as a stream type in .avi, got ${handler}`);
+    }
+    const flags = iterator.getUint32Le();
+    const priority = iterator.getUint16Le();
+    const language = iterator.getUint16Le();
+    const initialFrames = iterator.getUint32Le();
+    const scale = iterator.getUint32Le();
+    const rate = iterator.getUint32Le();
+    const start = iterator.getUint32Le();
+    const length = iterator.getUint32Le();
+    const suggestedBufferSize = iterator.getUint32Le();
+    const quality = iterator.getUint32Le();
+    const sampleSize = iterator.getUint32Le();
+    box.discardRest();
+    return {
+        type: 'strh-box',
+        fccType,
+        handler,
+        flags,
+        priority,
+        initialFrames,
+        length,
+        quality,
+        rate,
+        sampleSize,
+        scale,
+        start,
+        suggestedBufferSize,
+        language,
+    };
+};
+exports.parseStrh = parseStrh;

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

@@ -0,0 +1,81 @@
+export type WaveFormatBox = {
+    type: 'wave-format-box';
+    formatTag: 1;
+    numberOfChannels: number;
+    sampleRate: number;
+    blockAlign: number;
+    byteRate: number;
+    bitsPerSample: number;
+};
+export type ListBox = {
+    type: 'list-box';
+    listType: string;
+    children: RiffBox[];
+};
+export type RiffRegularBox = {
+    type: 'riff-box';
+    size: number;
+    id: string;
+};
+export type AvihBox = {
+    type: 'avih-box';
+    microSecPerFrame: number;
+    maxBytesPerSecond: number;
+    paddingGranularity: number;
+    flags: number;
+    totalFrames: number;
+    initialFrames: number;
+    streams: number;
+    suggestedBufferSize: number;
+    width: number;
+    height: number;
+};
+export type StrhBox = {
+    type: 'strh-box';
+    fccType: 'vids' | 'auds';
+    handler: 'H264' | number;
+    flags: number;
+    priority: number;
+    initialFrames: number;
+    scale: number;
+    rate: number;
+    start: number;
+    length: number;
+    suggestedBufferSize: number;
+    quality: number;
+    sampleSize: number;
+    language: number;
+};
+export type StrfBoxVideo = {
+    type: 'strf-box-video';
+    biSize: number;
+    width: number;
+    height: number;
+    planes: number;
+    bitCount: number;
+    compression: string;
+    sizeImage: number;
+    xPelsPerMeter: number;
+    yPelsPerMeter: number;
+    clrUsed: number;
+    clrImportant: number;
+};
+export type StrfBoxAudio = {
+    type: 'strf-box-audio';
+    formatTag: number;
+    numberOfChannels: number;
+    sampleRate: number;
+    avgBytesPerSecond: number;
+    blockAlign: number;
+    bitsPerSample: number;
+    cbSize: number;
+};
+export type RiffHeader = {
+    type: 'riff-header';
+    fileSize: number;
+    fileType: string;
+};
+export type MoviBox = {
+    type: 'movi-box';
+};
+export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | MoviBox;

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

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

package/dist/boxes/riff/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;

package/dist/boxes/riff/strf.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrf = void 0;
+const parseStrfAudio = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const formatTag = iterator.getUint16Le();
+    const numberOfChannels = iterator.getUint16Le();
+    const samplesPerSec = iterator.getUint32Le();
+    const avgBytesPerSec = iterator.getUint32Le();
+    const blockAlign = iterator.getUint16Le();
+    const bitsPerSample = iterator.getUint16Le();
+    const cbSize = iterator.getUint16Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-audio',
+        avgBytesPerSecond: avgBytesPerSec,
+        bitsPerSample,
+        blockAlign,
+        cbSize,
+        formatTag,
+        numberOfChannels,
+        sampleRate: samplesPerSec,
+    };
+};
+const parseStrfVideo = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const biSize = iterator.getUint32Le();
+    const width = iterator.getInt32Le();
+    const height = iterator.getInt32Le();
+    const planes = iterator.getUint16Le();
+    const bitCount = iterator.getUint16Le();
+    const compression = iterator.getByteString(4);
+    const sizeImage = iterator.getUint32Le();
+    const xPelsPerMeter = iterator.getInt32Le();
+    const yPelsPerMeter = iterator.getInt32Le();
+    const clrUsed = iterator.getUint32Le();
+    const clrImportant = iterator.getUint32Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-video',
+        biSize,
+        bitCount,
+        clrImportant,
+        clrUsed,
+        compression,
+        height,
+        planes,
+        sizeImage,
+        width,
+        xPelsPerMeter,
+        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') {
+        return parseStrfVideo({ iterator, size });
+    }
+    if (strh.fccType === 'auds') {
+        return parseStrfAudio({ iterator, size });
+    }
+    throw new Error(`Unsupported fccType: ${strh.fccType}`);
+};
+exports.parseStrf = parseStrf;

package/dist/boxes/riff/timescale.d.ts

@@ -0,0 +1 @@
+export declare const MEDIA_PARSER_RIFF_TIMESCALE = 1000000;

package/dist/boxes/riff/timescale.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEDIA_PARSER_RIFF_TIMESCALE = void 0;
+exports.MEDIA_PARSER_RIFF_TIMESCALE = 1000000;