@remotion/media-parser 4.0.194 → 4.0.196

package/src/get-fps.ts

@@ -1,5 +1,13 @@
-import type {SttsBox} from './boxes/iso-base-media/stts/stts';
+import type {SttsBox} from './boxes/iso-base-media/stsd/stts';
+import type {TrakBox} from './boxes/iso-base-media/trak/trak';
 import type {AnySegment} from './parse-result';
+import {
+	getMdhdBox,
+	getMoovBox,
+	getStsdBox,
+	getSttsBox,
+	getTraks,
+} from './traversal';
 
 const calculateFps = ({
 	sttsBox,
@@ -27,43 +35,9 @@ type TimescaleAndDuration = {
 	duration: number;
 };
 
-export const trakBoxContainsAudio = (trakBox: AnySegment): boolean => {
-	if (trakBox.type !== 'trak-box') {
-		return false;
-	}
-
-	const {children} = trakBox;
-	const mediaBoxes = children.filter(
-		(c) => c.type === 'regular-box' && c.boxType === 'mdia',
-	);
-	if (!mediaBoxes || mediaBoxes.length === 0) {
-		return false;
-	}
-
-	const firstMediaBox = mediaBoxes[0];
-	if (
-		firstMediaBox.type !== 'regular-box' ||
-		firstMediaBox.boxType !== 'mdia'
-	) {
-		return false;
-	}
-
-	const minf = firstMediaBox.children.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'minf',
-	);
-	if (!minf || minf.type !== 'regular-box' || minf.boxType !== 'minf') {
-		return false;
-	}
-
-	const stbl = minf.children.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'stbl',
-	);
-	if (!stbl || stbl.type !== 'regular-box' || stbl.boxType !== 'stbl') {
-		return false;
-	}
-
-	const stsd = stbl.children.find((c) => c.type === 'stsd-box');
-	if (!stsd || stsd.type !== 'stsd-box') {
+export const trakBoxContainsAudio = (trakBox: TrakBox): boolean => {
+	const stsd = getStsdBox(trakBox);
+	if (!stsd) {
 		return false;
 	}
 
@@ -75,43 +49,9 @@ export const trakBoxContainsAudio = (trakBox: AnySegment): boolean => {
 	return true;
 };
 
-export const trakBoxContainsVideo = (trakBox: AnySegment): boolean => {
-	if (trakBox.type !== 'trak-box') {
-		return false;
-	}
-
-	const {children} = trakBox;
-	const mediaBoxes = children.filter(
-		(c) => c.type === 'regular-box' && c.boxType === 'mdia',
-	);
-	if (!mediaBoxes || mediaBoxes.length === 0) {
-		return false;
-	}
-
-	const firstMediaBox = mediaBoxes[0];
-	if (
-		firstMediaBox.type !== 'regular-box' ||
-		firstMediaBox.boxType !== 'mdia'
-	) {
-		return false;
-	}
-
-	const minf = firstMediaBox.children.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'minf',
-	);
-	if (!minf || minf.type !== 'regular-box' || minf.boxType !== 'minf') {
-		return false;
-	}
-
-	const stbl = minf.children.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'stbl',
-	);
-	if (!stbl || stbl.type !== 'regular-box' || stbl.boxType !== 'stbl') {
-		return false;
-	}
-
-	const stsd = stbl.children.find((c) => c.type === 'stsd-box');
-	if (!stsd || stsd.type !== 'stsd-box') {
+export const trakBoxContainsVideo = (trakBox: TrakBox): boolean => {
+	const stsd = getStsdBox(trakBox);
+	if (!stsd) {
 		return false;
 	}
 
@@ -124,121 +64,36 @@ export const trakBoxContainsVideo = (trakBox: AnySegment): boolean => {
 };
 
 export const getTimescaleAndDuration = (
-	boxes: AnySegment[],
+	trakBox: TrakBox,
 ): TimescaleAndDuration | null => {
-	const moovBox = boxes.find((s) => s.type === 'moov-box');
-	if (!moovBox || moovBox.type !== 'moov-box') {
-		return null;
-	}
-
-	const {children} = moovBox;
-	const trackBoxes = children.filter((c) => c.type === 'trak-box');
-	if (!trackBoxes || trackBoxes.length === 0) {
-		return null;
-	}
-
-	const trackBox = trackBoxes.find(trakBoxContainsVideo);
-	if (!trackBox || trackBox.type !== 'trak-box') {
-		return null;
-	}
-
-	const trackBoxChildren = trackBox.children;
-	if (!trackBoxChildren || trackBoxChildren.length === 0) {
-		return null;
-	}
-
-	const mdiaBox = trackBoxChildren.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'mdia',
-	);
-	if (
-		!mdiaBox ||
-		mdiaBox.type !== 'regular-box' ||
-		mdiaBox.boxType !== 'mdia'
-	) {
-		return null;
-	}
-
-	const mdhdBox = mdiaBox?.children.find((c) => c.type === 'mdhd-box');
-	if (mdhdBox && mdhdBox.type === 'mdhd-box') {
+	const mdhdBox = getMdhdBox(trakBox);
+	if (mdhdBox) {
 		return {timescale: mdhdBox.timescale, duration: mdhdBox.duration};
 	}
 
-	const mvhdBox = moovBox.children.find((c) => c.type === 'mvhd-box');
-	if (!mvhdBox || mvhdBox.type !== 'mvhd-box') {
-		return null;
-	}
-
-	const {timeScale, durationInUnits} = mvhdBox;
-	return {timescale: timeScale, duration: durationInUnits};
+	return null;
 };
 
 export const getFps = (segments: AnySegment[]) => {
-	const timescaleAndDuration = getTimescaleAndDuration(segments);
-	if (!timescaleAndDuration) {
-		return null;
-	}
-
-	const moovBox = segments.find((s) => s.type === 'moov-box');
-	if (!moovBox || moovBox.type !== 'moov-box') {
+	const moovBox = getMoovBox(segments);
+	if (!moovBox) {
 		return null;
 	}
 
-	const mvhdBox = moovBox.children.find((c) => c.type === 'mvhd-box');
-	if (!mvhdBox || mvhdBox.type !== 'mvhd-box') {
-		return null;
-	}
-
-	const {children} = moovBox;
-	const trackBoxes = children.filter((c) => c.type === 'trak-box');
-	if (!trackBoxes || trackBoxes.length === 0) {
-		return null;
-	}
+	const trackBoxes = getTraks(moovBox);
 
 	const trackBox = trackBoxes.find(trakBoxContainsVideo);
-	if (!trackBox || trackBox.type !== 'trak-box') {
+	if (!trackBox) {
 		return null;
 	}
 
-	const trackBoxChildren = trackBox.children;
-	if (!trackBoxChildren || trackBoxChildren.length === 0) {
-		return null;
-	}
-
-	const mdiaBox = trackBoxChildren.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'mdia',
-	);
-	if (
-		!mdiaBox ||
-		mdiaBox.type !== 'regular-box' ||
-		mdiaBox.boxType !== 'mdia'
-	) {
-		return null;
-	}
-
-	const minfBox = mdiaBox.children.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'minf',
-	);
-	if (
-		!minfBox ||
-		minfBox.type !== 'regular-box' ||
-		minfBox.boxType !== 'minf'
-	) {
-		return null;
-	}
-
-	const stblBox = minfBox.children.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'stbl',
-	);
-	if (
-		!stblBox ||
-		stblBox.type !== 'regular-box' ||
-		stblBox.boxType !== 'stbl'
-	) {
+	const timescaleAndDuration = getTimescaleAndDuration(trackBox);
+	if (!timescaleAndDuration) {
 		return null;
 	}
 
-	const sttsBox = stblBox.children.find((c) => c.type === 'stts-box');
-	if (!sttsBox || sttsBox.type !== 'stts-box') {
+	const sttsBox = getSttsBox(trackBox);
+	if (!sttsBox) {
 		return null;
 	}
 

package/src/get-sample-aspect-ratio.ts

@@ -0,0 +1,204 @@
+import type {Av1CBox} from './boxes/iso-base-media/stsd/av1c';
+import type {AvccBox} from './boxes/iso-base-media/stsd/avcc';
+import type {ColorParameterBox} from './boxes/iso-base-media/stsd/colr';
+import type {HvccBox} from './boxes/iso-base-media/stsd/hvcc';
+import type {PaspBox} from './boxes/iso-base-media/stsd/pasp';
+import type {VideoSample} from './boxes/iso-base-media/stsd/samples';
+import type {TkhdBox} from './boxes/iso-base-media/tkhd';
+import type {TrakBox} from './boxes/iso-base-media/trak/trak';
+import type {Dimensions} from './get-dimensions';
+import {getStsdBox} from './traversal';
+
+type AspectRatio = {
+	numerator: number;
+	denominator: number;
+};
+
+export const getVideoSample = (trakBox: TrakBox): VideoSample | null => {
+	const stsdBox = getStsdBox(trakBox);
+
+	if (!stsdBox) {
+		return null;
+	}
+
+	const videoSample = stsdBox.samples.find((s) => s.type === 'video');
+	if (!videoSample || videoSample.type !== 'video') {
+		return null;
+	}
+
+	return videoSample;
+};
+
+export const getAvccBox = (trakBox: TrakBox): AvccBox | null => {
+	const videoSample = getVideoSample(trakBox);
+	if (!videoSample) {
+		return null;
+	}
+
+	const avccBox = videoSample.descriptors.find((c) => c.type === 'avcc-box');
+
+	if (!avccBox || avccBox.type !== 'avcc-box') {
+		return null;
+	}
+
+	return avccBox;
+};
+
+export const getAv1CBox = (trakBox: TrakBox): Av1CBox | null => {
+	const videoSample = getVideoSample(trakBox);
+	if (!videoSample) {
+		return null;
+	}
+
+	const av1cBox = videoSample.descriptors.find((c) => c.type === 'av1C-box');
+
+	if (!av1cBox || av1cBox.type !== 'av1C-box') {
+		return null;
+	}
+
+	return av1cBox;
+};
+
+export const getPaspBox = (trakBox: TrakBox): PaspBox | null => {
+	const videoSample = getVideoSample(trakBox);
+	if (!videoSample) {
+		return null;
+	}
+
+	const paspBox = videoSample.descriptors.find((c) => c.type === 'pasp-box');
+
+	if (!paspBox || paspBox.type !== 'pasp-box') {
+		return null;
+	}
+
+	return paspBox;
+};
+
+export const getHvccBox = (trakBox: TrakBox): HvccBox | null => {
+	const videoSample = getVideoSample(trakBox);
+	if (!videoSample) {
+		return null;
+	}
+
+	const hvccBox = videoSample.descriptors.find((c) => c.type === 'hvcc-box');
+
+	if (!hvccBox || hvccBox.type !== 'hvcc-box') {
+		return null;
+	}
+
+	return hvccBox;
+};
+
+export const getSampleAspectRatio = (trakBox: TrakBox): AspectRatio => {
+	const paspBox = getPaspBox(trakBox);
+	if (!paspBox) {
+		return {
+			numerator: 1,
+			denominator: 1,
+		};
+	}
+
+	return {
+		numerator: paspBox.hSpacing,
+		denominator: paspBox.vSpacing,
+	};
+};
+
+export const getColrBox = (
+	videoSample: VideoSample,
+): ColorParameterBox | null => {
+	const colrBox = videoSample.descriptors.find((c) => c.type === 'colr-box');
+
+	if (!colrBox || colrBox.type !== 'colr-box') {
+		return null;
+	}
+
+	return colrBox;
+};
+
+export const applyTkhdBox = (
+	aspectRatioApplied: Dimensions,
+	tkhdBox: TkhdBox,
+): {
+	displayAspectWidth: number;
+	displayAspectHeight: number;
+	width: number;
+	height: number;
+	rotation: number;
+} => {
+	if (tkhdBox === null || tkhdBox.rotation === 0) {
+		return {
+			displayAspectWidth: aspectRatioApplied.width,
+			displayAspectHeight: aspectRatioApplied.height,
+			width: aspectRatioApplied.width,
+			height: aspectRatioApplied.height,
+			rotation: 0,
+		};
+	}
+
+	return {
+		width: tkhdBox.width,
+		height: tkhdBox.height,
+		rotation: tkhdBox.rotation,
+		displayAspectWidth: aspectRatioApplied.width,
+		displayAspectHeight: aspectRatioApplied.height,
+	};
+};
+
+export const applyAspectRatios = ({
+	dimensions,
+	sampleAspectRatio,
+	displayAspectRatio,
+}: {
+	dimensions: Dimensions;
+	sampleAspectRatio: AspectRatio;
+	displayAspectRatio: AspectRatio;
+}): Dimensions => {
+	if (displayAspectRatio.numerator === 0) {
+		return dimensions;
+	}
+
+	if (displayAspectRatio.denominator === 0) {
+		return dimensions;
+	}
+
+	const newWidth = Math.round(
+		(dimensions.width * sampleAspectRatio.numerator) /
+			sampleAspectRatio.denominator,
+	);
+	const newHeight = Math.floor(
+		newWidth / (displayAspectRatio.numerator / displayAspectRatio.denominator),
+	);
+
+	return {
+		width: Math.floor(newWidth),
+		height: newHeight,
+	};
+};
+
+function gcd(a: number, b: number): number {
+	return b === 0 ? a : gcd(b, a % b);
+}
+
+function reduceFraction(numerator: number, denominator: number) {
+	const greatestCommonDivisor = gcd(Math.abs(numerator), Math.abs(denominator));
+	return {
+		numerator: numerator / greatestCommonDivisor,
+		denominator: denominator / greatestCommonDivisor,
+	};
+}
+
+export const getDisplayAspectRatio = ({
+	sampleAspectRatio,
+	nativeDimensions,
+}: {
+	sampleAspectRatio: AspectRatio;
+	nativeDimensions: Dimensions;
+}): AspectRatio => {
+	const num = Math.round(nativeDimensions.width * sampleAspectRatio.numerator);
+	const den = Math.round(
+		nativeDimensions.height * sampleAspectRatio.denominator,
+	);
+
+	return reduceFraction(num, den);
+};

package/src/get-sample-positions.ts

@@ -0,0 +1,93 @@
+import type {CttsBox} from './boxes/iso-base-media/stsd/ctts';
+import type {StcoBox} from './boxes/iso-base-media/stsd/stco';
+import type {StscBox} from './boxes/iso-base-media/stsd/stsc';
+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';
+
+export type SamplePosition = {
+	offset: number;
+	size: number;
+	isKeyframe: boolean;
+	dts: number;
+	cts: number;
+	duration: number;
+};
+
+export const getSamplePositions = ({
+	stcoBox,
+	stszBox,
+	stscBox,
+	stssBox,
+	sttsBox,
+	cttsBox,
+}: {
+	stcoBox: StcoBox;
+	stszBox: StszBox;
+	stscBox: StscBox;
+	stssBox: StssBox | null;
+	sttsBox: SttsBox;
+	cttsBox: CttsBox | null;
+}) => {
+	const sttsDeltas: number[] = [];
+	for (const distribution of sttsBox.sampleDistribution) {
+		for (let i = 0; i < distribution.sampleCount; i++) {
+			sttsDeltas.push(distribution.sampleDelta);
+		}
+	}
+
+	const cttsEntries: number[] = [];
+	for (const entry of cttsBox?.entries ?? [
+		{sampleCount: sttsDeltas.length, sampleOffset: 0},
+	]) {
+		for (let i = 0; i < entry.sampleCount; i++) {
+			cttsEntries.push(entry.sampleOffset);
+		}
+	}
+
+	let dts = 0;
+
+	const chunks = stcoBox.entries;
+	const samples: SamplePosition[] = [];
+
+	let samplesPerChunk = 1;
+
+	for (let i = 0; i < chunks.length; i++) {
+		const hasEntry = stscBox.entries.find(
+			(entry) => entry.firstChunk === i + 1,
+		);
+		if (hasEntry) {
+			samplesPerChunk = hasEntry.samplesPerChunk;
+		}
+
+		let offsetInThisChunk = 0;
+
+		for (let j = 0; j < samplesPerChunk; j++) {
+			const size =
+				stszBox.countType === 'fixed'
+					? stszBox.sampleSize
+					: stszBox.entries[samples.length];
+
+			const isKeyframe = stssBox
+				? stssBox.sampleNumber.includes(samples.length + 1)
+				: true;
+
+			const delta = sttsDeltas[samples.length];
+			const ctsOffset = cttsEntries[samples.length];
+			const cts = dts + ctsOffset;
+
+			samples.push({
+				offset: chunks[i] + offsetInThisChunk,
+				size,
+				isKeyframe,
+				dts,
+				cts,
+				duration: delta,
+			});
+			dts += delta;
+			offsetInThisChunk += size;
+		}
+	}
+
+	return samples;
+};

package/src/get-tracks.ts

@@ -0,0 +1,147 @@
+import {makeBaseMediaTrack} from './boxes/iso-base-media/make-track';
+import type {MoovBox} from './boxes/iso-base-media/moov/moov';
+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';
+
+type SampleAspectRatio = {
+	numerator: number;
+	denominator: number;
+};
+
+export type VideoTrack = {
+	type: 'video';
+	samplePositions: SamplePosition[] | null;
+	trackId: number;
+	description: Uint8Array | undefined;
+	timescale: number;
+	codec: string;
+	sampleAspectRatio: SampleAspectRatio;
+	width: number;
+	height: number;
+	displayAspectWidth: number;
+	displayAspectHeight: number;
+	codedWidth: number;
+	codedHeight: number;
+	rotation: number;
+};
+
+export type AudioTrack = {
+	type: 'audio';
+	samplePositions: SamplePosition[] | null;
+	trackId: number;
+	timescale: number;
+	codec: string;
+	numberOfChannels: number;
+	sampleRate: number;
+	description: Uint8Array | undefined;
+};
+
+export type OtherTrack = {
+	type: 'other';
+	samplePositions: SamplePosition[] | null;
+	trackId: number;
+	timescale: number;
+};
+
+export type Track = VideoTrack | AudioTrack | OtherTrack;
+
+export const getNumberOfTracks = (moovBox: MoovBox): number => {
+	const mvHdBox = getMvhdBox(moovBox);
+	if (!mvHdBox) {
+		return 0;
+	}
+
+	return mvHdBox.nextTrackId - 1;
+};
+
+export const hasTracks = (segments: AnySegment[]): boolean => {
+	const mainSegment = getMainSegment(segments);
+
+	if (mainSegment) {
+		return getTracksSegment(mainSegment) !== null;
+	}
+
+	const moovBox = getMoovBox(segments);
+
+	if (!moovBox) {
+		return false;
+	}
+
+	const numberOfTracks = getNumberOfTracks(moovBox);
+	const tracks = getTraks(moovBox);
+
+	return tracks.length === numberOfTracks;
+};
+
+export const getTracks = (
+	segments: AnySegment[],
+	state: ParserState,
+): {
+	videoTracks: VideoTrack[];
+	audioTracks: AudioTrack[];
+	otherTracks: OtherTrack[];
+} => {
+	const videoTracks: VideoTrack[] = [];
+	const audioTracks: AudioTrack[] = [];
+	const otherTracks: OtherTrack[] = [];
+
+	const mainSegment = segments.find((s) => s.type === 'main-segment');
+	if (mainSegment && mainSegment.type === 'main-segment') {
+		const matroskaTracks = getTracksFromMatroska(
+			mainSegment,
+			state.getTimescale(),
+		);
+
+		for (const track of matroskaTracks) {
+			if (track.type === 'video') {
+				videoTracks.push(track);
+			} else if (track.type === 'audio') {
+				audioTracks.push(track);
+			} else if (track.type === 'other') {
+				otherTracks.push(track);
+			}
+		}
+
+		return {
+			videoTracks,
+			audioTracks,
+			otherTracks,
+		};
+	}
+
+	const moovBox = getMoovBox(segments);
+	if (!moovBox) {
+		return {
+			videoTracks,
+			audioTracks,
+			otherTracks,
+		};
+	}
+
+	const tracks = getTraks(moovBox);
+
+	for (const trakBox of tracks) {
+		const track = makeBaseMediaTrack(trakBox);
+		if (!track) {
+			continue;
+		}
+
+		if (track.type === 'video') {
+			videoTracks.push(track);
+		} else if (track.type === 'audio') {
+			audioTracks.push(track);
+		} else if (track.type === 'other') {
+			otherTracks.push(track);
+		}
+	}
+
+	return {
+		videoTracks,
+		audioTracks,
+		otherTracks,
+	};
+};