@remotion/media-parser 4.0.202 → 4.0.204

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,
 	};

package/src/get-duration.ts

@@ -1,6 +1,10 @@
+import {getSamplePositionsFromTrack} from './boxes/iso-base-media/get-sample-positions-from-track';
+import type {TrakBox} from './boxes/iso-base-media/trak/trak';
 import type {DurationSegment} from './boxes/webm/segments/all-segments';
+import {getTracks} from './get-tracks';
 import type {AnySegment} from './parse-result';
-import {getMoovBox, getMvhdBox} from './traversal';
+import type {ParserState} from './parser-state';
+import {getMoofBox, getMoovBox, getMvhdBox} from './traversal';
 
 const getDurationFromMatroska = (segments: AnySegment[]): number | null => {
 	const mainSegment = segments.find((s) => s.type === 'Segment');
@@ -35,7 +39,10 @@ const getDurationFromMatroska = (segments: AnySegment[]): number | null => {
 	return (duration.value.value / timestampScale.value.value) * 1000;
 };
 
-export const getDuration = (boxes: AnySegment[]): number | null => {
+export const getDuration = (
+	boxes: AnySegment[],
+	parserState: ParserState,
+): number | null => {
 	const matroskaBox = boxes.find((b) => b.type === 'Segment');
 	if (matroskaBox) {
 		return getDurationFromMatroska(boxes);
@@ -46,6 +53,7 @@ export const getDuration = (boxes: AnySegment[]): number | null => {
 		return null;
 	}
 
+	const moofBox = getMoofBox(boxes);
 	const mvhdBox = getMvhdBox(moovBox);
 
 	if (!mvhdBox) {
@@ -56,12 +64,39 @@ export const getDuration = (boxes: AnySegment[]): number | null => {
 		throw new Error('Expected mvhd-box');
 	}
 
-	return mvhdBox.durationInSeconds;
+	if (mvhdBox.durationInSeconds > 0) {
+		return mvhdBox.durationInSeconds;
+	}
+
+	const tracks = getTracks(boxes, parserState);
+	const allTracks = [
+		...tracks.videoTracks,
+		...tracks.audioTracks,
+		...tracks.otherTracks,
+	];
+	const allSamples = allTracks.map((t) => {
+		const {timescale: ts} = t;
+		const samplePositions = getSamplePositionsFromTrack(
+			t.trakBox as TrakBox,
+			moofBox,
+		);
+
+		const highest = samplePositions
+			?.map((sp) => (sp.cts + sp.duration) / ts)
+			.reduce((a, b) => Math.max(a, b), 0);
+		return highest ?? 0;
+	});
+	const highestTimestamp = Math.max(...allSamples);
+	return highestTimestamp;
 };
 
-export const hasDuration = (boxes: AnySegment[]): boolean => {
+export const hasDuration = (
+	boxes: AnySegment[],
+	parserState: ParserState,
+): boolean => {
 	try {
-		return getDuration(boxes) !== null;
+		const duration = getDuration(boxes, parserState);
+		return getDuration(boxes, parserState) !== null && duration !== 0;
 	} catch (err) {
 		return false;
 	}

package/src/get-tracks.ts

@@ -1,8 +1,8 @@
 import {makeBaseMediaTrack} from './boxes/iso-base-media/make-track';
 import type {MoovBox} from './boxes/iso-base-media/moov/moov';
+import type {TrakBox} from './boxes/iso-base-media/trak/trak';
 import {getTracksFromMatroska} from './boxes/webm/get-ready-tracks';
 import {getMainSegment} from './boxes/webm/traversal';
-import type {SamplePosition} from './get-sample-positions';
 import type {AnySegment} from './parse-result';
 import type {ParserState} from './parser-state';
 import {getMoovBox, getMvhdBox, getTracksSegment, getTraks} from './traversal';
@@ -14,7 +14,6 @@ type SampleAspectRatio = {
 
 export type VideoTrack = {
 	type: 'video';
-	samplePositions: SamplePosition[] | null;
 	trackId: number;
 	description: Uint8Array | undefined;
 	timescale: number;
@@ -27,24 +26,25 @@ export type VideoTrack = {
 	codedWidth: number;
 	codedHeight: number;
 	rotation: number;
+	trakBox: TrakBox | null;
 };
 
 export type AudioTrack = {
 	type: 'audio';
-	samplePositions: SamplePosition[] | null;
 	trackId: number;
 	timescale: number;
 	codec: string;
 	numberOfChannels: number;
 	sampleRate: number;
 	description: Uint8Array | undefined;
+	trakBox: TrakBox | null;
 };
 
 export type OtherTrack = {
 	type: 'other';
-	samplePositions: SamplePosition[] | null;
 	trackId: number;
 	timescale: number;
+	trakBox: TrakBox | null;
 };
 
 export type Track = VideoTrack | AudioTrack | OtherTrack;

package/src/has-all-info.ts

@@ -45,7 +45,7 @@ export const hasAllInfo = (
 		}
 
 		if (key === 'durationInSeconds') {
-			return hasDuration(parseResult.segments);
+			return hasDuration(parseResult.segments, state);
 		}
 
 		if (

package/src/parse-media.ts

@@ -149,7 +149,7 @@ export const parseMedia: ParseMedia = async ({
 	}
 
 	if (fields?.durationInSeconds) {
-		returnValue.durationInSeconds = getDuration(parseResult.segments);
+		returnValue.durationInSeconds = getDuration(parseResult.segments, state);
 	}
 
 	if (fields?.fps) {

package/src/parse-result.ts

@@ -19,8 +19,11 @@ import type {StsdBox} from './boxes/iso-base-media/stsd/stsd';
 import type {StssBox} from './boxes/iso-base-media/stsd/stss';
 import type {StszBox} from './boxes/iso-base-media/stsd/stsz';
 import type {SttsBox} from './boxes/iso-base-media/stsd/stts';
+import type {TfdtBox} from './boxes/iso-base-media/tfdt';
+import type {TfhdBox} from './boxes/iso-base-media/tfhd';
 import type {TkhdBox} from './boxes/iso-base-media/tkhd';
 import type {TrakBox} from './boxes/iso-base-media/trak/trak';
+import type {TrunBox} from './boxes/iso-base-media/trun';
 import type {VoidBox} from './boxes/iso-base-media/void-box';
 import type {MatroskaSegment} from './boxes/webm/segments';
 
@@ -56,7 +59,10 @@ export type IsoBaseMediaBox =
 	| PaspBox
 	| CttsBox
 	| Av1CBox
-	| ColorParameterBox;
+	| TrunBox
+	| ColorParameterBox
+	| TfdtBox
+	| TfhdBox;
 
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
 

package/src/samples-from-moof.ts

@@ -0,0 +1,101 @@
+import type {SamplePosition} from './get-sample-positions';
+import type {AnySegment, IsoBaseMediaBox} from './parse-result';
+import {getTfdtBox, getTfhdBox, getTrunBoxes} from './traversal';
+
+const getSamplesFromTraf = (
+	trafSegment: IsoBaseMediaBox,
+	moofOffset: number,
+): SamplePosition[] => {
+	if (trafSegment.type !== 'regular-box' || trafSegment.boxType !== 'traf') {
+		throw new Error('Expected traf-box');
+	}
+
+	const tfhdBox = getTfhdBox(trafSegment);
+	const defaultSampleDuration = tfhdBox?.defaultSampleDuration ?? null;
+	const defaultSampleSize = tfhdBox?.defaultSampleSize ?? null;
+	const defaultSampleFlags = tfhdBox?.defaultSampleFlags ?? null;
+
+	const tfdtBox = getTfdtBox(trafSegment);
+	const trunBoxes = getTrunBoxes(trafSegment);
+
+	let time = 0;
+	let offset = 0;
+
+	let dataOffset = 0;
+
+	const samples: SamplePosition[] = [];
+
+	for (const trunBox of trunBoxes) {
+		let i = -1;
+
+		if (dataOffset === 0 && trunBox.dataOffset) {
+			dataOffset = trunBox.dataOffset;
+		}
+
+		for (const sample of trunBox.samples) {
+			i++;
+			const duration = sample.sampleDuration ?? defaultSampleDuration;
+			if (duration === null) {
+				throw new Error('Expected duration');
+			}
+
+			const size = sample.sampleSize ?? defaultSampleSize;
+			if (size === null) {
+				throw new Error('Expected size');
+			}
+
+			const isFirstSample = i === 0;
+			const sampleFlags = sample.sampleFlags
+				? sample.sampleFlags
+				: isFirstSample && trunBox.firstSampleFlags !== null
+					? trunBox.firstSampleFlags
+					: defaultSampleFlags;
+			if (sampleFlags === null) {
+				throw new Error('Expected sample flags');
+			}
+
+			const keyframe = !((sampleFlags >> 16) & 0x1);
+
+			const dts = time + (tfdtBox?.baseMediaDecodeTime ?? 0);
+
+			const samplePosition: SamplePosition = {
+				offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
+				dts,
+				cts: dts,
+				duration,
+				isKeyframe: keyframe,
+				size,
+			};
+			samples.push(samplePosition);
+			offset += size;
+			time += duration;
+		}
+	}
+
+	return samples;
+};
+
+export const getSamplesFromMoof = ({
+	moofBox,
+	trackId,
+}: {
+	moofBox: AnySegment;
+	trackId: number;
+}) => {
+	if (moofBox.type !== 'regular-box') {
+		throw new Error('Expected moof-box');
+	}
+
+	const trafs = moofBox.children.filter(
+		(c) => c.type === 'regular-box' && c.boxType === 'traf',
+	) as IsoBaseMediaBox[];
+
+	const mapped = trafs.map((traf) => {
+		const tfhdBox = getTfhdBox(traf);
+
+		return tfhdBox?.trackId === trackId
+			? getSamplesFromTraf(traf, moofBox.offset)
+			: [];
+	});
+	return mapped.flat(1);
+};