@remotion/media-parser 4.0.194 → 4.0.195

package/dist/add-new-matroska-tracks.d.ts

@@ -0,0 +1,8 @@
+import type { Track } from './get-tracks';
+import type { ParserContext } from './parser-context';
+import type { ParserState } from './parser-state';
+export declare const registerTrack: ({ state, options, track, }: {
+    state: ParserState;
+    options: ParserContext;
+    track: Track;
+}) => Promise<void>;

package/dist/add-new-matroska-tracks.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTrack = void 0;
+const registerTrack = async ({ state, options, track, }) => {
+    if (track.type === 'video' && options.onVideoTrack) {
+        const callback = await options.onVideoTrack(track);
+        await state.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    }
+    if (track.type === 'audio' && options.onAudioTrack) {
+        const callback = await options.onAudioTrack(track);
+        await state.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    }
+};
+exports.registerTrack = registerTrack;

package/dist/av1-codec-string.d.ts

@@ -0,0 +1,3 @@
+import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
+import type { Av1BitstreamHeaderSegment } from './boxes/webm/bitstream/av1/header-segment';
+export declare const constructAv1CodecString: (av1BitstreamHeader: Av1BitstreamHeaderSegment, colrAtom: ColorParameterBox | null) => string;

package/dist/av1-codec-string.js

@@ -0,0 +1,91 @@
+"use strict";
+// https://aomediacodec.github.io/av1-isobmff/#codecsparam
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructAv1CodecString = void 0;
+const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
+    let str = 'av01.';
+    // Profile
+    str += av1BitstreamHeader.seq_profile;
+    str += '.';
+    // Level
+    // The level parameter value SHALL equal the first level value indicated by seq_level_idx in the Sequence Header OBU
+    str += av1BitstreamHeader.seq_level[0].seq_level_idx
+        .toString()
+        .padStart(2, '0');
+    // Tier
+    // The tier parameter value SHALL be equal to M when the first seq_tier value in the Sequence Header OBU is equal to 0, and H when it is equal to 1
+    str += av1BitstreamHeader.seq_level[0].seq_tier ? 'H' : 'M';
+    str += '.';
+    // bitDepth
+    // The bitDepth parameter value SHALL equal the value of BitDepth variable as defined in [AV1] derived from the Sequence Header OBU
+    str += av1BitstreamHeader.color_config.bitDepth.toString().padStart(2, '0');
+    str += '.';
+    // monochrome
+    // The monochrome parameter value, represented by a single digit decimal, SHALL equal the value of mono_chrome in the Sequence Header OBU
+    str += av1BitstreamHeader.color_config.mono_chrome ? '1' : '0';
+    str += '.';
+    // The chromaSubsampling parameter value, represented by a three-digit decimal,
+    // SHALL have its first digit equal to subsampling_x
+    str += av1BitstreamHeader.color_config.subsampling_x ? '1' : '0';
+    // and its second digit equal to subsampling_y.
+    str += av1BitstreamHeader.color_config.subsampling_y ? '1' : '0';
+    // If both subsampling_x and subsampling_y are set to 1, then the third digit SHALL be equal to chroma_sample_position, otherwise it SHALL be set to 0
+    str +=
+        av1BitstreamHeader.color_config.subsampling_x &&
+            av1BitstreamHeader.color_config.subsampling_y
+            ? av1BitstreamHeader.color_config.chroma_sample_position === 1
+                ? '1'
+                : '0'
+            : '0';
+    str += '.';
+    // The colorPrimaries, transferCharacteristics, matrixCoefficients, and videoFullRangeFlag parameter values are set as follows:
+    // If a colr box with colour_type set to nclx is present, the colorPrimaries, transferCharacteristics, matrixCoefficients, and videoFullRangeFlag parameter values SHALL equal the values of matching fields in the colr box.
+    if (colrAtom) {
+        str += colrAtom.primaries.toString().padStart(2, '0');
+        str += '.';
+        str += colrAtom.transfer.toString().padStart(2, '0');
+        str += '.';
+        str += colrAtom.matrixIndex.toString().padStart(2, '0');
+        str += '.';
+        str += colrAtom.fullRangeFlag ? '1' : '0';
+    }
+    // Otherwise, a colr box with colour_type set to nclx is absent.
+    // If the color_description_present_flag is set to 1 in the Sequence Header OBU, the colorPrimaries, transferCharacteristics, and matrixCoefficients parameter values SHALL equal the values of matching fields in the Sequence Header OBU.
+    else if (av1BitstreamHeader.color_config.color_description_present_flag) {
+        str += av1BitstreamHeader.color_config.color_primaries
+            .toString()
+            .padStart(2, '0');
+        str += '.';
+        str += av1BitstreamHeader.color_config.transfer_characteristics
+            .toString()
+            .padStart(2, '0');
+        str += '.';
+        str += av1BitstreamHeader.color_config.matrix_coefficients
+            .toString()
+            .padStart(2, '0');
+        str += '.';
+        //		The videoFullRangeFlag parameter value SHALL equal the color_range flag in the Sequence Header OBU.
+        str += av1BitstreamHeader.color_config.color_range ? '1' : '0';
+    }
+    else {
+        // Otherwise, the color_description_present_flag is set to 0 in the Sequence Header OBU. The colorPrimaries, transferCharacteristics, and matrixCoefficients parameter values SHOULD be set to the default values below.
+        // colorPrimaries 01 (ITU-R BT.709)
+        str += '01';
+        str += '.';
+        // transferCharacteristics 01 (ITU-R BT.709)
+        str += '01';
+        str += '.';
+        // matrixCoefficients 00 (ITU-R BT.709)
+        str += '01';
+        str += '.';
+        // videoFullRangeFlag 0 (studio swing representation)
+        str += '0';
+    }
+    // If the codecs parameter string ends with ".0.110.01.01.01.0" (containing all the default values below), that trailing part of the string SHOULD be omitted.
+    const suffix = '.0.110.01.01.01.0';
+    if (str.endsWith(suffix)) {
+        str = str.slice(0, -suffix.length);
+    }
+    return str;
+};
+exports.constructAv1CodecString = constructAv1CodecString;

package/dist/boxes/iso-base-media/esds/decoder-specific-config.d.ts

@@ -0,0 +1,14 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+type UnknownDecoderSpecificConfig = {
+    type: 'unknown-decoder-specific-config';
+};
+type AudioSpecificConfig = {
+    type: 'audio-specific-config';
+    audioObjectType: number;
+    samplingFrequencyIndex: number;
+    channelConfiguration: number;
+    asBytes: Uint8Array;
+};
+export type DecoderSpecificConfig = UnknownDecoderSpecificConfig | AudioSpecificConfig;
+export declare const parseDecoderSpecificConfig: (iterator: BufferIterator) => DecoderSpecificConfig;
+export {};

package/dist/boxes/iso-base-media/esds/decoder-specific-config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDecoderSpecificConfig = void 0;
+const parseDecoderSpecificConfig = (iterator) => {
+    const layerTag = iterator.getUint8();
+    const layerSize = iterator.getPaddedFourByteNumber();
+    const start = iterator.counter.getOffset();
+    if (layerTag !== 5) {
+        iterator.discard(layerSize);
+        return {
+            type: 'unknown-decoder-specific-config',
+        };
+    }
+    // https://csclub.uwaterloo.ca/~pbarfuss/ISO14496-3-2009.pdf
+    // 1.6.2.1 AudioSpecificConfig
+    const bytes = iterator.getSlice(layerSize);
+    iterator.counter.decrement(layerSize);
+    iterator.startReadingBits();
+    const audioObjectType = iterator.getBits(5);
+    const samplingFrequencyIndex = iterator.getBits(4);
+    if (samplingFrequencyIndex === 0xf) {
+        iterator.getBits(24);
+    }
+    const channelConfiguration = iterator.getBits(4);
+    iterator.stopReadingBits();
+    const read = iterator.counter.getOffset() - start;
+    if (read < layerSize) {
+        iterator.discard(layerSize - read);
+    }
+    return {
+        type: 'audio-specific-config',
+        audioObjectType,
+        samplingFrequencyIndex,
+        channelConfiguration,
+        asBytes: bytes,
+    };
+};
+exports.parseDecoderSpecificConfig = parseDecoderSpecificConfig;

package/dist/boxes/iso-base-media/esds/esds-descriptors.d.ts

@@ -1,8 +1,16 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { DecoderSpecificConfig } from './decoder-specific-config';
 type AudioObjectType = 'aac' | 'mp3' | 'unknown';
 type DecoderConfigDescriptor = {
     type: 'decoder-config-descriptor';
     objectTypeIndication: AudioObjectType;
+    asNumber: number;
+    streamType: number;
+    upStream: number;
+    bufferSizeDB: number;
+    maxBitrate: number;
+    avgBitrate: number;
+    decoderSpecificConfigs: DecoderSpecificConfig[];
 };
 type SlConfigDescriptor = {
     type: 'sl-config-descriptor';

package/dist/boxes/iso-base-media/esds/esds-descriptors.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDescriptors = exports.processDescriptor = void 0;
+const decoder_specific_config_1 = require("./decoder-specific-config");
 const mapToObjectAudioIndicator = (num) => {
     // https://chromium.googlesource.com/chromium/src/media/+/master/formats/mp4/es_descriptor.h
     // http://netmedia.zju.edu.cn/multimedia2013/mpeg-4/ISO%20IEC%2014496-1%20MPEG-4%20System%20Standard.pdf
@@ -19,12 +20,31 @@ const processDescriptor = ({ iterator, }) => {
         const size = iterator.getPaddedFourByteNumber();
         const initialOffset = iterator.counter.getOffset();
         const objectTypeIndication = iterator.getUint8();
-        const remaining = size - (iterator.counter.getOffset() - initialOffset);
-        iterator.discard(remaining);
+        iterator.startReadingBits();
+        const streamType = iterator.getBits(6);
+        const upStream = iterator.getBits(1);
+        // reserved
+        iterator.getBits(1);
+        const bufferSizeDB = iterator.getBits(24);
+        iterator.stopReadingBits();
+        const maxBitrate = iterator.getUint32();
+        const avgBitrate = iterator.getUint32();
+        const decoderSpecificConfigs = [];
+        while (size - (iterator.counter.getOffset() - initialOffset) >= 0) {
+            const decoderSpecificConfig = (0, decoder_specific_config_1.parseDecoderSpecificConfig)(iterator);
+            decoderSpecificConfigs.push(decoderSpecificConfig);
+        }
         return {
             descriptor: {
                 type: 'decoder-config-descriptor',
                 objectTypeIndication: mapToObjectAudioIndicator(objectTypeIndication),
+                asNumber: objectTypeIndication,
+                bufferSizeDB,
+                streamType,
+                upStream,
+                avgBitrate,
+                maxBitrate,
+                decoderSpecificConfigs,
             },
         };
     }

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

@@ -0,0 +1,9 @@
+import type { BaseBox } from './base-type';
+export interface FtypBox extends BaseBox {
+    type: 'ftyp-box';
+    majorBrand: string;
+    minorVersion: number;
+    compatibleBrands: string[];
+}
+export declare const fourByteToNumber: (data: ArrayBuffer, from: number) => number;
+export declare const parseFtyp: (data: ArrayBuffer, offset: number) => FtypBox;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFtyp = exports.fourByteToNumber = void 0;
+const fourByteToNumber = (data, from) => {
+    const view = new DataView(data);
+    return ((view.getUint8(from + 0) << 24) |
+        (view.getUint8(from + 1) << 16) |
+        (view.getUint8(from + 2) << 8) |
+        view.getUint8(from + 3));
+};
+exports.fourByteToNumber = fourByteToNumber;
+const parseFtyp = (data, offset) => {
+    const majorBrand = new TextDecoder().decode(data.slice(8, 12)).trim();
+    const minorVersion = (0, exports.fourByteToNumber)(data, 12);
+    const rest = data.slice(16);
+    const types = rest.byteLength / 4;
+    const compatibleBrands = [];
+    for (let i = 0; i < types; i++) {
+        const fourBytes = rest.slice(i * 4, i * 4 + 4);
+        compatibleBrands.push(new TextDecoder().decode(fourBytes).trim());
+    }
+    return {
+        type: 'ftyp-box',
+        majorBrand,
+        minorVersion,
+        compatibleBrands,
+        offset,
+        boxSize: data.byteLength,
+    };
+};
+exports.parseFtyp = parseFtyp;

package/dist/boxes/iso-base-media/make-track.d.ts

@@ -0,0 +1,3 @@
+import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { TrakBox } from './trak/trak';
+export declare const makeBaseMediaTrack: (trakBox: TrakBox) => VideoTrack | AudioTrack | OtherTrack | null;

package/dist/boxes/iso-base-media/make-track.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBaseMediaTrack = void 0;
+const get_audio_codec_1 = require("../../get-audio-codec");
+const get_fps_1 = require("../../get-fps");
+const get_sample_aspect_ratio_1 = require("../../get-sample-aspect-ratio");
+const get_sample_positions_1 = require("../../get-sample-positions");
+const get_video_codec_1 = require("../../get-video-codec");
+const traversal_1 = require("../../traversal");
+const makeBaseMediaTrack = (trakBox) => {
+    const stszBox = (0, traversal_1.getStszBox)(trakBox);
+    const stcoBox = (0, traversal_1.getStcoBox)(trakBox);
+    const stscBox = (0, traversal_1.getStscBox)(trakBox);
+    const stssBox = (0, traversal_1.getStssBox)(trakBox);
+    const sttsBox = (0, traversal_1.getSttsBox)(trakBox);
+    const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
+    const cttsBox = (0, traversal_1.getCttsBox)(trakBox);
+    const videoDescriptors = (0, traversal_1.getVideoDescriptors)(trakBox);
+    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
+    if (!tkhdBox) {
+        throw new Error('Expected tkhd box in trak box');
+    }
+    if (!stszBox) {
+        throw new Error('Expected stsz box in trak box');
+    }
+    if (!stcoBox) {
+        throw new Error('Expected stco box in trak box');
+    }
+    if (!stscBox) {
+        throw new Error('Expected stsc box in trak box');
+    }
+    if (!sttsBox) {
+        throw new Error('Expected stts box in trak box');
+    }
+    if (!timescaleAndDuration) {
+        throw new Error('Expected timescale and duration in trak box');
+    }
+    const samplePositions = (0, get_sample_positions_1.getSamplePositions)({
+        stcoBox,
+        stscBox,
+        stszBox,
+        stssBox,
+        sttsBox,
+        cttsBox,
+    });
+    if ((0, get_fps_1.trakBoxContainsAudio)(trakBox)) {
+        const numberOfChannels = (0, get_audio_codec_1.getNumberOfChannelsFromTrak)(trakBox);
+        if (numberOfChannels === null) {
+            throw new Error('Could not find number of channels');
+        }
+        const sampleRate = (0, get_audio_codec_1.getSampleRate)(trakBox);
+        if (sampleRate === null) {
+            throw new Error('Could not find sample rate');
+        }
+        const { codecString, description } = (0, get_audio_codec_1.getAudioCodecStringFromTrak)(trakBox);
+        return {
+            type: 'audio',
+            samplePositions,
+            trackId: tkhdBox.trackId,
+            timescale: timescaleAndDuration.timescale,
+            codec: codecString,
+            numberOfChannels,
+            sampleRate,
+            description,
+        };
+    }
+    if (!(0, get_fps_1.trakBoxContainsVideo)(trakBox)) {
+        return {
+            type: 'other',
+            samplePositions,
+            trackId: tkhdBox.trackId,
+            timescale: timescaleAndDuration.timescale,
+        };
+    }
+    const videoSample = (0, get_sample_aspect_ratio_1.getVideoSample)(trakBox);
+    if (!videoSample) {
+        throw new Error('No video sample');
+    }
+    const sampleAspectRatio = (0, get_sample_aspect_ratio_1.getSampleAspectRatio)(trakBox);
+    const aspectRatioApplied = (0, get_sample_aspect_ratio_1.applyAspectRatios)({
+        dimensions: videoSample,
+        sampleAspectRatio,
+        displayAspectRatio: (0, get_sample_aspect_ratio_1.getDisplayAspectRatio)({
+            sampleAspectRatio,
+            nativeDimensions: videoSample,
+        }),
+    });
+    const { displayAspectHeight, displayAspectWidth, height, rotation, width } = (0, get_sample_aspect_ratio_1.applyTkhdBox)(aspectRatioApplied, tkhdBox);
+    const codec = (0, get_video_codec_1.getVideoCodecString)(trakBox);
+    if (!codec) {
+        throw new Error('Could not find video codec');
+    }
+    const track = {
+        type: 'video',
+        samplePositions,
+        trackId: tkhdBox.trackId,
+        description: videoDescriptors !== null && videoDescriptors !== void 0 ? videoDescriptors : undefined,
+        timescale: timescaleAndDuration.timescale,
+        codec,
+        sampleAspectRatio: (0, get_sample_aspect_ratio_1.getSampleAspectRatio)(trakBox),
+        width,
+        height,
+        codedWidth: videoSample.width,
+        codedHeight: videoSample.height,
+        // Repeating those keys because they get picked up by VideoDecoder
+        displayAspectWidth,
+        displayAspectHeight,
+        rotation,
+    };
+    return track;
+};
+exports.makeBaseMediaTrack = makeBaseMediaTrack;

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

@@ -1,12 +1,16 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
 export interface MdatBox {
     type: 'mdat-box';
+    samplesProcessed: boolean;
     boxSize: number;
+    fileOffset: number;
 }
-export declare const parseMdat: ({ data, size, fileOffset, }: {
+export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, options, }: {
     data: BufferIterator;
     size: number;
     fileOffset: number;
     existingBoxes: AnySegment[];
-}) => MdatBox;
+    options: ParserContext;
+}) => Promise<MdatBox>;

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

@@ -1,13 +1,97 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMdat = void 0;
-const parseMdat = ({ data, size, fileOffset, }) => {
-    // TODO: Do something cool with it
-    // 	const tracks = getTracks(existingBoxes);
-    data.discard(size - (data.counter.getOffset() - fileOffset));
-    return {
+const get_tracks_1 = require("../../../get-tracks");
+const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) => {
+    const alreadyHas = (0, get_tracks_1.hasTracks)(existingBoxes);
+    if (!alreadyHas) {
+        data.discard(size - 8);
+        return Promise.resolve({
+            type: 'mdat-box',
+            boxSize: size,
+            samplesProcessed: false,
+            fileOffset,
+        });
+    }
+    const tracks = (0, get_tracks_1.getTracks)(existingBoxes, options.parserState);
+    const allTracks = [
+        ...tracks.videoTracks,
+        ...tracks.audioTracks,
+        ...tracks.otherTracks,
+    ];
+    const flatSamples = allTracks
+        .map((track) => {
+        if (!track.samplePositions) {
+            throw new Error('No sample positions');
+        }
+        return track.samplePositions.map((samplePosition) => {
+            return {
+                track,
+                samplePosition,
+            };
+        });
+    })
+        .flat(1);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const sampleWithIndex = flatSamples.find((sample) => {
+            return sample.samplePosition.offset === data.counter.getOffset();
+        });
+        if (!sampleWithIndex) {
+            // There are various reasons why in mdat we find weird stuff:
+            // - iphonevideo.hevc has a fake hoov atom which is not mapped
+            // - corrupted.mp4 has a corrupt table
+            const nextSample_ = flatSamples
+                .filter((s) => s.samplePosition.offset > data.counter.getOffset())
+                .sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
+            if (nextSample_) {
+                data.discard(nextSample_.samplePosition.offset - data.counter.getOffset());
+                continue;
+            }
+            else {
+                const bytesRemaining = size + fileOffset - data.counter.getOffset();
+                data.discard(bytesRemaining);
+                break;
+            }
+        }
+        if (data.bytesRemaining() < sampleWithIndex.samplePosition.size) {
+            break;
+        }
+        const bytes = data.getSlice(sampleWithIndex.samplePosition.size);
+        if (sampleWithIndex.track.type === 'audio') {
+            await options.parserState.onAudioSample(sampleWithIndex.track.trackId, {
+                data: bytes,
+                timestamp: sampleWithIndex.samplePosition.offset,
+                offset: data.counter.getOffset(),
+                trackId: sampleWithIndex.track.trackId,
+                type: sampleWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
+            });
+        }
+        if (sampleWithIndex.track.type === 'video') {
+            const timestamp = (sampleWithIndex.samplePosition.cts * 1000000) /
+                sampleWithIndex.track.timescale;
+            const duration = (sampleWithIndex.samplePosition.duration * 1000000) /
+                sampleWithIndex.track.timescale;
+            await options.parserState.onVideoSample(sampleWithIndex.track.trackId, {
+                data: bytes,
+                timestamp,
+                duration,
+                cts: sampleWithIndex.samplePosition.cts,
+                dts: sampleWithIndex.samplePosition.dts,
+                trackId: sampleWithIndex.track.trackId,
+                type: sampleWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
+            });
+        }
+        const remaining = size - (data.counter.getOffset() - fileOffset);
+        if (remaining === 0) {
+            break;
+        }
+    }
+    return Promise.resolve({
         type: 'mdat-box',
         boxSize: size,
-    };
+        samplesProcessed: true,
+        fileOffset,
+    });
 };
 exports.parseMdat = parseMdat;

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

@@ -1,12 +1,14 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
 export interface MoovBox extends BaseBox {
     type: 'moov-box';
     children: AnySegment[];
 }
-export declare const parseMoov: ({ iterator, offset, size, }: {
+export declare const parseMoov: ({ iterator, offset, size, options, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
-}) => MoovBox;
+    options: ParserContext;
+}) => Promise<MoovBox>;

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

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMoov = void 0;
 const process_box_1 = require("../process-box");
-const parseMoov = ({ iterator, offset, size, }) => {
-    const children = (0, process_box_1.parseBoxes)({
+const parseMoov = async ({ iterator, offset, size, options, }) => {
+    const children = await (0, process_box_1.parseBoxes)({
         iterator,
         maxBytes: size - (iterator.counter.getOffset() - offset),
         allowIncompleteBoxes: false,
         initialBoxes: [],
+        options,
+        continueMdat: false,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

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

@@ -35,12 +35,18 @@ const parseMvhd = ({ iterator, offset, size, }) => {
     // matrix
     const matrix = [];
     for (let i = 0; i < 9; i++) {
-        matrix.push(iterator.getUint32());
+        if (i % 3 === 2) {
+            matrix.push(iterator.getFixedPointSigned230Number());
+        }
+        else {
+            matrix.push(iterator.getFixedPointSigned1616Number());
+        }
     }
     // pre-defined
     iterator.discard(4 * 6);
     // next track id
     const nextTrackId = iterator.getUint32();
+    volumeView.destroy();
     return {
         creationTime: (0, to_date_1.toUnixTimestamp)(creationTime),
         modificationTime: (0, to_date_1.toUnixTimestamp)(modificationTime),

package/dist/boxes/iso-base-media/process-box.d.ts

@@ -1,8 +1,25 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { IsoBaseMediaBox, ParseResult } from '../../parse-result';
-export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, }: {
+import type { AnySegment, IsoBaseMediaBox, ParseResult } from '../../parse-result';
+import type { BoxAndNext, PartialMdatBox } from '../../parse-video';
+import type { ParserContext } from '../../parser-context';
+export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parsedBoxes, options, }: {
+    iterator: BufferIterator;
+    boxSize: number;
+    fileOffset: number;
+    parsedBoxes: AnySegment[];
+    options: ParserContext;
+}) => Promise<BoxAndNext>;
+export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, }: {
+    iterator: BufferIterator;
+    allowIncompleteBoxes: boolean;
+    parsedBoxes: AnySegment[];
+    options: ParserContext;
+}) => Promise<BoxAndNext>;
+export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, }: {
     iterator: BufferIterator;
     maxBytes: number;
     allowIncompleteBoxes: boolean;
     initialBoxes: IsoBaseMediaBox[];
-}) => ParseResult;
+    options: ParserContext;
+    continueMdat: false | PartialMdatBox;
+}) => Promise<ParseResult>;