@remotion/media-parser 4.0.202 → 4.0.205

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,102 @@
+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 (trunBox.dataOffset) {
+			dataOffset = trunBox.dataOffset;
+			offset = 0;
+		}
+
+		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);
+};