@remotion/media-parser 4.0.202 → 4.0.205

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

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

package/dist/av1-codec-string.js

@@ -1,9 +1,7 @@
 "use strict";
 // https://aomediacodec.github.io/av1-isobmff/#codecsparam
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.av1CodecStringToString = exports.constructAv1CodecString = void 0;
-const traversal_1 = require("./boxes/webm/traversal");
-const traversal_2 = require("./traversal");
+exports.constructAv1CodecString = void 0;
 const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
     let str = 'av01.';
     // Profile
@@ -91,18 +89,3 @@ const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
     return str;
 };
 exports.constructAv1CodecString = constructAv1CodecString;
-const av1CodecStringToString = ({ track, clusterSegment, }) => {
-    const codecSegment = (0, traversal_2.getCodecSegment)(track);
-    if (!codecSegment) {
-        throw new Error('Expected codec segment');
-    }
-    if (codecSegment.codec !== 'V_AV1') {
-        throw new Error(`Should not call this function if it is not AV1: ${codecSegment.codec}`);
-    }
-    const av1BitstreamHeader = (0, traversal_1.getAv1BitstreamHeader)(clusterSegment);
-    if (!av1BitstreamHeader) {
-        return null;
-    }
-    return (0, exports.constructAv1CodecString)(av1BitstreamHeader, null);
-};
-exports.av1CodecStringToString = av1CodecStringToString;

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

@@ -27,12 +27,17 @@ const parseDecoderSpecificConfig = (iterator) => {
     if (read < layerSize) {
         iterator.discard(layerSize - read);
     }
+    // Working around Chrome bug
+    // https://issues.chromium.org/issues/360083330#comment5
+    const patchedAsBytes = bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136
+        ? new Uint8Array([17, 144])
+        : bytes;
     return {
         type: 'audio-specific-config',
         audioObjectType,
         samplingFrequencyIndex,
         channelConfiguration,
-        asBytes: bytes,
+        asBytes: patchedAsBytes,
     };
 };
 exports.parseDecoderSpecificConfig = parseDecoderSpecificConfig;

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/get-sample-positions-from-track.d.ts

@@ -0,0 +1,4 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { IsoBaseMediaBox } from '../../parse-result';
+import type { TrakBox } from './trak/trak';
+export declare const getSamplePositionsFromTrack: (trakBox: TrakBox, moofBox: IsoBaseMediaBox | null) => SamplePosition[];

package/dist/boxes/iso-base-media/get-sample-positions-from-track.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplePositionsFromTrack = void 0;
+const get_fps_1 = require("../../get-fps");
+const get_sample_positions_1 = require("../../get-sample-positions");
+const samples_from_moof_1 = require("../../samples-from-moof");
+const traversal_1 = require("../../traversal");
+const getSamplePositionsFromTrack = (trakBox, moofBox) => {
+    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 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');
+    }
+    let samplePositions = (0, get_sample_positions_1.getSamplePositions)({
+        stcoBox,
+        stscBox,
+        stszBox,
+        stssBox,
+        sttsBox,
+        cttsBox,
+    });
+    if (samplePositions.length === 0 && moofBox) {
+        samplePositions = (0, samples_from_moof_1.getSamplesFromMoof)({ moofBox, trackId: tkhdBox.trackId });
+    }
+    return samplePositions;
+};
+exports.getSamplePositionsFromTrack = getSamplePositionsFromTrack;

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

@@ -4,45 +4,18 @@ 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) {
@@ -55,21 +28,21 @@ const makeBaseMediaTrack = (trakBox) => {
         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,
+            trakBox,
         };
     }
     if (!(0, get_fps_1.trakBoxContainsVideo)(trakBox)) {
         return {
             type: 'other',
-            samplePositions,
             trackId: tkhdBox.trackId,
             timescale: timescaleAndDuration.timescale,
+            trakBox,
         };
     }
     const videoSample = (0, get_sample_aspect_ratio_1.getVideoSample)(trakBox);
@@ -92,7 +65,6 @@ const makeBaseMediaTrack = (trakBox) => {
     }
     const track = {
         type: 'video',
-        samplePositions,
         trackId: tkhdBox.trackId,
         description: videoDescriptors !== null && videoDescriptors !== void 0 ? videoDescriptors : undefined,
         timescale: timescaleAndDuration.timescale,
@@ -106,6 +78,7 @@ const makeBaseMediaTrack = (trakBox) => {
         displayAspectWidth,
         displayAspectHeight,
         rotation,
+        trakBox,
     };
     return track;
 };

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

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMdat = void 0;
 const get_tracks_1 = require("../../../get-tracks");
+const traversal_1 = require("../../../traversal");
+const get_sample_positions_from_track_1 = require("../get-sample-positions-from-track");
 const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) => {
     const alreadyHas = (0, get_tracks_1.hasTracks)(existingBoxes);
     if (!alreadyHas) {
@@ -21,12 +23,13 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) =>
     ];
     const flatSamples = allTracks
         .map((track) => {
-        if (!track.samplePositions) {
+        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)(track.trakBox, (0, traversal_1.getMoofBox)(existingBoxes));
+        if (!samplePositions) {
             throw new Error('No sample positions');
         }
-        return track.samplePositions.map((samplePosition) => {
+        return samplePositions.map((samplePosition) => {
             return {
-                track,
+                track: { ...track },
                 samplePosition,
             };
         });
@@ -34,10 +37,10 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) =>
         .flat(1);
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        const sampleWithIndex = flatSamples.find((sample) => {
+        const samplesWithIndex = flatSamples.find((sample) => {
             return sample.samplePosition.offset === data.counter.getOffset();
         });
-        if (!sampleWithIndex) {
+        if (!samplesWithIndex) {
             // 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
@@ -54,31 +57,31 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) =>
                 break;
             }
         }
-        if (data.bytesRemaining() < sampleWithIndex.samplePosition.size) {
+        if (data.bytesRemaining() < samplesWithIndex.samplePosition.size) {
             break;
         }
-        const bytes = data.getSlice(sampleWithIndex.samplePosition.size);
-        if (sampleWithIndex.track.type === 'audio') {
-            await options.parserState.onAudioSample(sampleWithIndex.track.trackId, {
+        const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
+        if (samplesWithIndex.track.type === 'audio') {
+            await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
                 data: bytes,
-                timestamp: sampleWithIndex.samplePosition.offset,
-                trackId: sampleWithIndex.track.trackId,
-                type: sampleWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
+                timestamp: samplesWithIndex.samplePosition.offset,
+                trackId: samplesWithIndex.track.trackId,
+                type: samplesWithIndex.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, {
+        if (samplesWithIndex.track.type === 'video') {
+            const timestamp = Math.floor((samplesWithIndex.samplePosition.cts * 1000000) /
+                samplesWithIndex.track.timescale);
+            const duration = Math.floor((samplesWithIndex.samplePosition.duration * 1000000) /
+                samplesWithIndex.track.timescale);
+            await options.parserState.onVideoSample(samplesWithIndex.track.trackId, {
                 data: bytes,
                 timestamp,
                 duration,
-                cts: sampleWithIndex.samplePosition.cts,
-                dts: sampleWithIndex.samplePosition.dts,
-                trackId: sampleWithIndex.track.trackId,
-                type: sampleWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
+                cts: samplesWithIndex.samplePosition.cts,
+                dts: samplesWithIndex.samplePosition.dts,
+                trackId: samplesWithIndex.track.trackId,
+                type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
             });
         }
         const remaining = size - (data.counter.getOffset() - fileOffset);

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

@@ -6,6 +6,8 @@ export interface MdhdBox {
     duration: number;
     language: number;
     quality: number;
+    creationTime: number | null;
+    modificationTime: number | null;
 }
 export declare const parseMdhd: ({ data, size, fileOffset, }: {
     data: BufferIterator;

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

@@ -3,17 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMdhd = void 0;
 const parseMdhd = ({ data, size, fileOffset, }) => {
     const version = data.getUint8();
-    if (version !== 0) {
-        throw new Error(`Unsupported MDHD version ${version}`);
-    }
     // flags, we discard them
     data.discard(3);
     // creation time
-    data.discard(4);
+    const creationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
     // modification time
-    data.discard(4);
+    const modificationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
     const timescale = data.getUint32();
-    const duration = data.getUint32();
+    const duration = version === 1 ? data.getUint64() : data.getUint32();
     const language = data.getUint16();
     // quality
     const quality = data.getUint16();
@@ -23,11 +20,13 @@ const parseMdhd = ({ data, size, fileOffset, }) => {
     }
     return {
         type: 'mdhd-box',
-        duration,
+        duration: Number(duration),
         timescale,
         version,
         language,
         quality,
+        creationTime,
+        modificationTime,
     };
 };
 exports.parseMdhd = parseMdhd;

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

@@ -5,19 +5,13 @@ const buffer_iterator_1 = require("../../buffer-iterator");
 const to_date_1 = require("./to-date");
 const parseMvhd = ({ iterator, offset, size, }) => {
     const version = iterator.getUint8();
-    if (version !== 0) {
-        throw new Error(`Unsupported MVHD version ${version}`);
-    }
-    if (size !== 108) {
-        throw new Error(`Expected mvhd size of version 0 to be 108, got ${size}`);
-    }
     // Flags, we discard them
     iterator.discard(3);
-    const creationTime = iterator.getUint32();
-    const modificationTime = iterator.getUint32();
+    const creationTime = version === 1 ? iterator.getUint64() : iterator.getUint32();
+    const modificationTime = version === 1 ? iterator.getUint64() : iterator.getUint32();
     const timeScale = iterator.getUint32();
-    const durationInUnits = iterator.getUint32();
-    const durationInSeconds = durationInUnits / timeScale;
+    const durationInUnits = version === 1 ? iterator.getUint64() : iterator.getUint32();
+    const durationInSeconds = Number(durationInUnits) / timeScale;
     const rateArray = iterator.getSlice(4);
     const rateView = (0, buffer_iterator_1.getArrayBufferIterator)(rateArray, rateArray.length);
     const rate = rateView.getInt8() * 10 +
@@ -47,11 +41,15 @@ const parseMvhd = ({ iterator, offset, size, }) => {
     // next track id
     const nextTrackId = iterator.getUint32();
     volumeView.destroy();
+    const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+    if (bytesRemaining !== 0) {
+        throw new Error('expected 0 bytes ' + bytesRemaining);
+    }
     return {
-        creationTime: (0, to_date_1.toUnixTimestamp)(creationTime),
-        modificationTime: (0, to_date_1.toUnixTimestamp)(modificationTime),
+        creationTime: (0, to_date_1.toUnixTimestamp)(Number(creationTime)),
+        modificationTime: (0, to_date_1.toUnixTimestamp)(Number(modificationTime)),
         timeScale,
-        durationInUnits,
+        durationInUnits: Number(durationInUnits),
         durationInSeconds,
         rate,
         volume,

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

@@ -23,14 +23,19 @@ const stsd_1 = require("./stsd/stsd");
 const stss_1 = require("./stsd/stss");
 const stsz_1 = require("./stsd/stsz");
 const stts_1 = require("./stsd/stts");
+const tfdt_1 = require("./tfdt");
+const tfhd_1 = require("./tfhd");
 const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
+const trun_1 = require("./trun");
 const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, littleEndian, }) => {
     const parseChildren = boxType === 'mdia' ||
         boxType === 'minf' ||
         boxType === 'stbl' ||
+        boxType === 'moof' ||
         boxType === 'dims' ||
         boxType === 'wave' ||
+        boxType === 'traf' ||
         boxType === 'stsb';
     if (parseChildren) {
         const parsed = await (0, exports.parseBoxes)({
@@ -183,6 +188,24 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             skipTo: null,
         };
     }
+    if (boxType === 'trun') {
+        const box = (0, trun_1.parseTrun)({ iterator, offset: fileOffset, size: boxSize });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    if (boxType === 'tfdt') {
+        const box = (0, tfdt_1.parseTfdt)({ iterator, size: boxSize, offset: fileOffset });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
     if (boxType === 'stsd') {
         const box = await (0, stsd_1.parseStsd)({
             iterator,
@@ -380,6 +403,19 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
             skipTo: null,
         };
     }
+    if (boxType === 'tfhd') {
+        const box = (0, tfhd_1.getTfhd)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
     if (boxType === 'mdhd') {
         const box = (0, mdhd_1.parseMdhd)({
             data: iterator,

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

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface TfdtBox {
+    type: 'tfdt-box';
+    version: number;
+    baseMediaDecodeTime: number;
+    offset: number;
+}
+export declare const parseTfdt: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => TfdtBox;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTfdt = void 0;
+const parseTfdt = ({ iterator, size, offset, }) => {
+    const version = iterator.getUint8();
+    iterator.discard(3);
+    // Flags, discard them
+    const num = version === 0 ? iterator.getUint32() : Number(iterator.getUint64());
+    const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+    if (bytesRemaining !== 0) {
+        throw new Error('expected 0 bytes ' + bytesRemaining);
+    }
+    return {
+        type: 'tfdt-box',
+        version,
+        baseMediaDecodeTime: num,
+        offset,
+    };
+};
+exports.parseTfdt = parseTfdt;

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

@@ -0,0 +1,16 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface TfhdBox {
+    type: 'tfhd-box';
+    version: number;
+    trackId: number;
+    baseDataOffset: number;
+    baseSampleDescriptionIndex: number;
+    defaultSampleDuration: number;
+    defaultSampleSize: number;
+    defaultSampleFlags: number;
+}
+export declare const getTfhd: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => TfhdBox;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTfhd = void 0;
+const getTfhd = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    const flags = iterator.getUint24();
+    const trackId = iterator.getUint32();
+    const baseDataOffsetPresent = flags & 0x01;
+    const baseDataOffset = baseDataOffsetPresent
+        ? Number(iterator.getUint64())
+        : 0;
+    const baseSampleDescriptionIndexPresent = flags & 0x02;
+    const baseSampleDescriptionIndex = baseSampleDescriptionIndexPresent
+        ? iterator.getUint32()
+        : 0;
+    const defaultSampleDurationPresent = flags & 0x08;
+    const defaultSampleDuration = defaultSampleDurationPresent
+        ? iterator.getUint32()
+        : 0;
+    const defaultSampleSizePresent = flags & 0x10;
+    const defaultSampleSize = defaultSampleSizePresent ? iterator.getUint32() : 0;
+    const defaultSampleFlagsPresent = flags & 0x20;
+    const defaultSampleFlags = defaultSampleFlagsPresent
+        ? iterator.getUint32()
+        : 0;
+    const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+    if (bytesRemaining !== 0) {
+        throw new Error('expected 0 bytes ' + bytesRemaining);
+    }
+    return {
+        type: 'tfhd-box',
+        version,
+        trackId,
+        baseDataOffset,
+        baseSampleDescriptionIndex,
+        defaultSampleDuration,
+        defaultSampleSize,
+        defaultSampleFlags,
+    };
+};
+exports.getTfhd = getTfhd;

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

@@ -5,6 +5,9 @@ const to_date_1 = require("./to-date");
 function getRotationAngleFromMatrix(matrix) {
     // Extract elements from the matrix
     const [a, b, c, d] = matrix;
+    if (a === 0 && b === 0 && c === 0 && d === 0) {
+        return 0;
+    }
     // Check if the matrix is a valid rotation matrix
     if (Math.round(a * a + b * b) !== 1 || Math.round(c * c + d * d) !== 1) {
         throw new Error('The provided matrix is not a valid rotation matrix.');
@@ -23,21 +26,15 @@ const applyRotation = ({ matrix, width, height, }) => {
     };
 };
 const parseTkhd = ({ iterator, offset, size, }) => {
-    if (size !== 92) {
-        throw new Error(`Expected tkhd size of version 0 to be 92, got ${size}`);
-    }
     const version = iterator.getUint8();
-    if (version !== 0) {
-        throw new Error(`Unsupported TKHD version ${version}`);
-    }
     // Flags, we discard them
     iterator.discard(3);
-    const creationTime = iterator.getUint32();
-    const modificationTime = iterator.getUint32();
+    const creationTime = version === 1 ? iterator.getUint64() : iterator.getUint32();
+    const modificationTime = version === 1 ? iterator.getUint64() : iterator.getUint32();
     const trackId = iterator.getUint32();
     // reserved
     iterator.discard(4);
-    const duration = iterator.getUint32();
+    const duration = version === 1 ? iterator.getUint64() : iterator.getUint32();
     // reserved 2
     iterator.discard(4);
     // reserved 3
@@ -71,10 +68,10 @@ const parseTkhd = ({ iterator, offset, size, }) => {
         offset,
         boxSize: size,
         type: 'tkhd-box',
-        creationTime: (0, to_date_1.toUnixTimestamp)(creationTime),
-        modificationTime: (0, to_date_1.toUnixTimestamp)(modificationTime),
+        creationTime: (0, to_date_1.toUnixTimestamp)(Number(creationTime)),
+        modificationTime: (0, to_date_1.toUnixTimestamp)(Number(modificationTime)),
         trackId,
-        duration,
+        duration: Number(duration),
         layer,
         alternateGroup,
         volume,

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

@@ -0,0 +1,21 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface TrunBox {
+    type: 'trun-box';
+    version: number;
+    sampleCount: number;
+    dataOffset: number | null;
+    firstSampleFlags: number | null;
+    samples: TRunSample[];
+}
+type TRunSample = {
+    sampleDuration: number | null;
+    sampleSize: number | null;
+    sampleFlags: number | null;
+    sampleCompositionTimeOffset: number | null;
+};
+export declare const parseTrun: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => TrunBox;
+export {};