@remotion/media-parser 4.0.202 → 4.0.205

package/src/boxes/iso-base-media/make-track.ts

@@ -15,31 +15,15 @@ import {
 	getSampleAspectRatio,
 	getVideoSample,
 } from '../../get-sample-aspect-ratio';
-import {getSamplePositions} from '../../get-sample-positions';
 import type {AudioTrack, OtherTrack, VideoTrack} from '../../get-tracks';
 import {getVideoCodecString} from '../../get-video-codec';
-import {
-	getCttsBox,
-	getStcoBox,
-	getStscBox,
-	getStssBox,
-	getStszBox,
-	getSttsBox,
-	getTkhdBox,
-	getVideoDescriptors,
-} from '../../traversal';
+import {getTkhdBox, getVideoDescriptors} from '../../traversal';
 import type {TrakBox} from './trak/trak';
 
 export const makeBaseMediaTrack = (
 	trakBox: TrakBox,
 ): VideoTrack | AudioTrack | OtherTrack | null => {
-	const stszBox = getStszBox(trakBox);
-	const stcoBox = getStcoBox(trakBox);
-	const stscBox = getStscBox(trakBox);
-	const stssBox = getStssBox(trakBox);
-	const sttsBox = getSttsBox(trakBox);
 	const tkhdBox = getTkhdBox(trakBox);
-	const cttsBox = getCttsBox(trakBox);
 
 	const videoDescriptors = getVideoDescriptors(trakBox);
 	const timescaleAndDuration = getTimescaleAndDuration(trakBox);
@@ -48,35 +32,10 @@ export const makeBaseMediaTrack = (
 		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 = getSamplePositions({
-		stcoBox,
-		stscBox,
-		stszBox,
-		stssBox,
-		sttsBox,
-		cttsBox,
-	});
-
 	if (trakBoxContainsAudio(trakBox)) {
 		const numberOfChannels = getNumberOfChannelsFromTrak(trakBox);
 		if (numberOfChannels === null) {
@@ -92,22 +51,22 @@ export const makeBaseMediaTrack = (
 
 		return {
 			type: 'audio',
-			samplePositions,
 			trackId: tkhdBox.trackId,
 			timescale: timescaleAndDuration.timescale,
 			codec: codecString,
 			numberOfChannels,
 			sampleRate,
 			description,
+			trakBox,
 		};
 	}
 
 	if (!trakBoxContainsVideo(trakBox)) {
 		return {
 			type: 'other',
-			samplePositions,
 			trackId: tkhdBox.trackId,
 			timescale: timescaleAndDuration.timescale,
+			trakBox,
 		};
 	}
 
@@ -138,7 +97,6 @@ export const makeBaseMediaTrack = (
 
 	const track: VideoTrack = {
 		type: 'video',
-		samplePositions,
 		trackId: tkhdBox.trackId,
 		description: videoDescriptors ?? undefined,
 		timescale: timescaleAndDuration.timescale,
@@ -152,6 +110,7 @@ export const makeBaseMediaTrack = (
 		displayAspectWidth,
 		displayAspectHeight,
 		rotation,
+		trakBox,
 	};
 	return track;
 };

package/src/boxes/iso-base-media/mdat/mdat.ts

@@ -3,6 +3,9 @@ import type {BufferIterator} from '../../../buffer-iterator';
 import {getTracks, hasTracks} from '../../../get-tracks';
 import type {AnySegment} from '../../../parse-result';
 import type {ParserContext} from '../../../parser-context';
+import {getMoofBox} from '../../../traversal';
+import {getSamplePositionsFromTrack} from '../get-sample-positions-from-track';
+import type {TrakBox} from '../trak/trak';
 
 export interface MdatBox {
 	type: 'mdat-box';
@@ -44,13 +47,17 @@ export const parseMdat = async ({
 
 	const flatSamples = allTracks
 		.map((track) => {
-			if (!track.samplePositions) {
+			const samplePositions = getSamplePositionsFromTrack(
+				track.trakBox as TrakBox,
+				getMoofBox(existingBoxes),
+			);
+			if (!samplePositions) {
 				throw new Error('No sample positions');
 			}
 
-			return track.samplePositions.map((samplePosition) => {
+			return samplePositions.map((samplePosition) => {
 				return {
-					track,
+					track: {...track},
 					samplePosition,
 				};
 			});
@@ -59,10 +66,10 @@ export const parseMdat = async ({
 
 	// 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
@@ -81,37 +88,39 @@ export const parseMdat = async ({
 			}
 		}
 
-		if (data.bytesRemaining() < sampleWithIndex.samplePosition.size) {
+		if (data.bytesRemaining() < samplesWithIndex.samplePosition.size) {
 			break;
 		}
 
-		const bytes = data.getSlice(sampleWithIndex.samplePosition.size);
+		const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
 
-		if (sampleWithIndex.track.type === 'audio') {
-			await options.parserState.onAudioSample(sampleWithIndex.track.trackId, {
+		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 * 1_000_000) /
-				sampleWithIndex.track.timescale;
-			const duration =
-				(sampleWithIndex.samplePosition.duration * 1_000_000) /
-				sampleWithIndex.track.timescale;
+		if (samplesWithIndex.track.type === 'video') {
+			const timestamp = Math.floor(
+				(samplesWithIndex.samplePosition.cts * 1_000_000) /
+					samplesWithIndex.track.timescale,
+			);
+			const duration = Math.floor(
+				(samplesWithIndex.samplePosition.duration * 1_000_000) /
+					samplesWithIndex.track.timescale,
+			);
 
-			await options.parserState.onVideoSample(sampleWithIndex.track.trackId, {
+			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',
 			});
 		}
 

package/src/boxes/iso-base-media/mdhd.ts

@@ -7,6 +7,8 @@ export interface MdhdBox {
 	duration: number;
 	language: number;
 	quality: number;
+	creationTime: number | null;
+	modificationTime: number | null;
 }
 
 export const parseMdhd = ({
@@ -19,21 +21,20 @@ export const parseMdhd = ({
 	fileOffset: number;
 }): MdhdBox => {
 	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();
 
@@ -47,10 +48,12 @@ export const parseMdhd = ({
 
 	return {
 		type: 'mdhd-box',
-		duration,
+		duration: Number(duration),
 		timescale,
 		version,
 		language,
 		quality,
+		creationTime,
+		modificationTime,
 	};
 };

package/src/boxes/iso-base-media/mvhd.ts

@@ -38,25 +38,21 @@ export const parseMvhd = ({
 	size: number;
 }): MvhdBox => {
 	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 creationTime =
+		version === 1 ? iterator.getUint64() : iterator.getUint32();
 
-	const modificationTime = 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 = getArrayBufferIterator(rateArray, rateArray.length);
@@ -96,11 +92,16 @@ export const parseMvhd = ({
 
 	volumeView.destroy();
 
+	const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+	if (bytesRemaining !== 0) {
+		throw new Error('expected 0 bytes ' + bytesRemaining);
+	}
+
 	return {
-		creationTime: toUnixTimestamp(creationTime),
-		modificationTime: toUnixTimestamp(modificationTime),
+		creationTime: toUnixTimestamp(Number(creationTime)),
+		modificationTime: toUnixTimestamp(Number(modificationTime)),
 		timeScale,
-		durationInUnits,
+		durationInUnits: Number(durationInUnits),
 		durationInSeconds,
 		rate,
 		volume,

package/src/boxes/iso-base-media/process-box.ts

@@ -29,8 +29,11 @@ import {parseStsd} from './stsd/stsd';
 import {parseStss} from './stsd/stss';
 import {parseStsz} from './stsd/stsz';
 import {parseStts} from './stsd/stts';
+import {parseTfdt} from './tfdt';
+import {getTfhd} from './tfhd';
 import {parseTkhd} from './tkhd';
 import {parseTrak} from './trak/trak';
+import {parseTrun} from './trun';
 
 const getChildren = async ({
 	boxType,
@@ -49,8 +52,10 @@ const getChildren = async ({
 		boxType === 'mdia' ||
 		boxType === 'minf' ||
 		boxType === 'stbl' ||
+		boxType === 'moof' ||
 		boxType === 'dims' ||
 		boxType === 'wave' ||
+		boxType === 'traf' ||
 		boxType === 'stsb';
 
 	if (parseChildren) {
@@ -260,6 +265,28 @@ export const processBox = async ({
 		};
 	}
 
+	if (boxType === 'trun') {
+		const box = parseTrun({iterator, offset: fileOffset, size: boxSize});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'tfdt') {
+		const box = parseTfdt({iterator, size: boxSize, offset: fileOffset});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
 	if (boxType === 'stsd') {
 		const box = await parseStsd({
 			iterator,
@@ -492,6 +519,21 @@ export const processBox = async ({
 		};
 	}
 
+	if (boxType === 'tfhd') {
+		const box = getTfhd({
+			iterator,
+			offset: fileOffset,
+			size: boxSize,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
 	if (boxType === 'mdhd') {
 		const box = parseMdhd({
 			data: iterator,

package/src/boxes/iso-base-media/tfdt.ts

@@ -0,0 +1,37 @@
+import type {BufferIterator} from '../../buffer-iterator';
+
+export interface TfdtBox {
+	type: 'tfdt-box';
+	version: number;
+	baseMediaDecodeTime: number;
+	offset: number;
+}
+
+export const parseTfdt = ({
+	iterator,
+	size,
+	offset,
+}: {
+	iterator: BufferIterator;
+	size: number;
+	offset: number;
+}): TfdtBox => {
+	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,
+	};
+};

package/src/boxes/iso-base-media/tfhd.ts

@@ -0,0 +1,66 @@
+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 const getTfhd = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	size: number;
+	offset: number;
+}): TfhdBox => {
+	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,
+	};
+};

package/src/boxes/iso-base-media/tkhd.ts

@@ -26,6 +26,9 @@ type Matrix2x2 = readonly [number, number, number, number];
 function getRotationAngleFromMatrix(matrix: Matrix2x2): number {
 	// 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) {
@@ -66,28 +69,23 @@ export const parseTkhd = ({
 	offset: number;
 	size: number;
 }): TkhdBox => {
-	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 creationTime =
+		version === 1 ? iterator.getUint64() : iterator.getUint32();
 
-	const modificationTime = 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);
@@ -134,10 +132,10 @@ export const parseTkhd = ({
 		offset,
 		boxSize: size,
 		type: 'tkhd-box',
-		creationTime: toUnixTimestamp(creationTime),
-		modificationTime: toUnixTimestamp(modificationTime),
+		creationTime: toUnixTimestamp(Number(creationTime)),
+		modificationTime: toUnixTimestamp(Number(modificationTime)),
 		trackId,
-		duration,
+		duration: Number(duration),
 		layer,
 		alternateGroup,
 		volume,

package/src/boxes/iso-base-media/trun.ts

@@ -0,0 +1,74 @@
+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 const parseTrun = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): TrunBox => {
+	const version = iterator.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported TRUN version ${version}`);
+	}
+
+	const flags = iterator.getUint24();
+	const sampleCount = iterator.getUint32();
+
+	const dataOffset = flags & 0x01 ? iterator.getInt32() : null;
+	const firstSampleFlags = flags & 0x04 ? iterator.getUint32() : null;
+
+	const samples: TRunSample[] = [];
+
+	for (let i = 0; i < sampleCount; i++) {
+		const sampleDuration = flags & 0x100 ? iterator.getUint32() : null;
+		const sampleSize = flags & 0x200 ? iterator.getUint32() : null;
+		const sampleFlags = flags & 0x400 ? iterator.getUint32() : null;
+		const sampleCompositionTimeOffset =
+			flags & 0x800
+				? version === 0
+					? iterator.getUint32()
+					: iterator.getInt32Le()
+				: null;
+
+		samples.push({
+			sampleDuration,
+			sampleSize,
+			sampleFlags,
+			sampleCompositionTimeOffset,
+		});
+	}
+
+	const currentOffset = iterator.counter.getOffset();
+	const left = size - (currentOffset - offset);
+	if (left !== 0) {
+		throw new Error(`Unexpected data left in TRUN box: ${left}`);
+	}
+
+	return {
+		type: 'trun-box',
+		version,
+		sampleCount,
+		dataOffset,
+		firstSampleFlags,
+		samples,
+	};
+};

package/src/boxes/webm/get-track.ts

@@ -221,7 +221,6 @@ export const getTrack = ({
 				denominator: 1,
 			},
 			timescale,
-			samplePositions: [],
 			codedHeight: height.value.value,
 			codedWidth: width.value.value,
 			displayAspectHeight: displayHeight
@@ -231,6 +230,7 @@ export const getTrack = ({
 				? displayWidth.value.value
 				: width.value.value,
 			rotation: 0,
+			trakBox: null,
 		};
 	}
 
@@ -245,11 +245,11 @@ export const getTrack = ({
 			type: 'audio',
 			trackId,
 			codec: getMatroskaAudioCodecString(track),
-			samplePositions: null,
 			timescale,
 			numberOfChannels,
 			sampleRate,
 			description: getAudioDescription(track),
+			trakBox: null,
 		};
 	}
 

package/src/buffer-iterator.ts

@@ -483,8 +483,8 @@ export const getArrayBufferIterator = (
 		},
 		getUint24: () => {
 			const val1 = view.getUint8(counter.getDiscardedOffset());
-			const val2 = view.getUint8(counter.getDiscardedOffset());
-			const val3 = view.getUint8(counter.getDiscardedOffset());
+			const val2 = view.getUint8(counter.getDiscardedOffset() + 1);
+			const val3 = view.getUint8(counter.getDiscardedOffset() + 2);
 			counter.increment(3);
 			return (val1 << 16) | (val2 << 8) | val3;
 		},
@@ -539,6 +539,7 @@ export const getArrayBufferIterator = (
 		},
 		getUint32Le,
 		getInt32Le,
+		getInt32,
 		destroy,
 		isMp3,
 	};