@remotion/media-parser 4.0.194 → 4.0.196

package/src/get-audio-codec.ts

@@ -1,8 +1,13 @@
 /* eslint-disable max-depth */
-import type {Sample} from './boxes/iso-base-media/stsd/samples';
+import type {EsdsBox} from './boxes/iso-base-media/esds/esds';
+import type {MoovBox} from './boxes/iso-base-media/moov/moov';
+import type {AudioSample} from './boxes/iso-base-media/stsd/samples';
+import type {TrakBox} from './boxes/iso-base-media/trak/trak';
+import type {MainSegment} from './boxes/webm/segments/main';
 import {trakBoxContainsAudio} from './get-fps';
 import type {KnownAudioCodecs} from './options';
 import type {AnySegment} from './parse-result';
+import {getMoovBox, getStsdBox, getTraks} from './traversal';
 
 export const hasAudioCodec = (boxes: AnySegment[]): boolean => {
 	try {
@@ -12,111 +17,152 @@ export const hasAudioCodec = (boxes: AnySegment[]): boolean => {
 	}
 };
 
-const onEsdsBox = (child: AnySegment): KnownAudioCodecs | null => {
+const getCodecSpecificatorFromEsdsBox = ({
+	child,
+}: {
+	child: EsdsBox;
+}): {
+	primary: number;
+	secondary: number | null;
+	description: Uint8Array | undefined;
+} => {
+	const descriptor = child.descriptors.find(
+		(d) => d.type === 'decoder-config-descriptor',
+	);
+	if (!descriptor) {
+		throw new Error('No decoder-config-descriptor');
+	}
+
+	if (descriptor.type !== 'decoder-config-descriptor') {
+		throw new Error('Expected decoder-config-descriptor');
+	}
+
+	if (descriptor.asNumber !== 0x40) {
+		return {
+			primary: descriptor.asNumber,
+			secondary: null,
+			description: undefined,
+		};
+	}
+
+	const audioSpecificConfig = descriptor.decoderSpecificConfigs.find((d) => {
+		return d.type === 'audio-specific-config' ? d : null;
+	});
+	if (
+		!audioSpecificConfig ||
+		audioSpecificConfig.type !== 'audio-specific-config'
+	) {
+		throw new Error('No audio-specific-config');
+	}
+
+	return {
+		primary: descriptor.asNumber,
+		secondary: audioSpecificConfig.audioObjectType,
+		description: audioSpecificConfig.asBytes,
+	};
+};
+
+type AudioCodecInfo = {
+	format: string;
+	primarySpecificator: number | null;
+	secondarySpecificator: number | null;
+	description: Uint8Array | undefined;
+};
+
+const onSample = (
+	sample: AudioSample,
+	children: AnySegment[],
+): AudioCodecInfo | null => {
+	const child = children.find((c) => c.type === 'esds-box');
+
 	if (child && child.type === 'esds-box') {
-		const descriptor = child.descriptors.find(
-			(d) => d.type === 'decoder-config-descriptor',
-		);
-		if (descriptor && descriptor.type === 'decoder-config-descriptor') {
-			return descriptor.objectTypeIndication;
-		}
+		const ret = getCodecSpecificatorFromEsdsBox({child});
+		return {
+			format: sample.format,
+			primarySpecificator: ret.primary,
+			secondarySpecificator: ret.secondary,
+			description: ret.description,
+		};
 	}
 
-	return null;
+	return {
+		format: sample.format,
+		primarySpecificator: null,
+		secondarySpecificator: null,
+		description: undefined,
+	};
 };
 
-const onSample = (sample: Sample): KnownAudioCodecs | null | undefined => {
-	if (!sample) {
+export const getNumberOfChannelsFromTrak = (trak: TrakBox): number | null => {
+	const stsdBox = getStsdBox(trak);
+	if (!stsdBox) {
 		return null;
 	}
 
-	if (sample.type !== 'audio') {
+	const sample = stsdBox.samples.find((s) => s.type === 'audio');
+	if (!sample || sample.type !== 'audio') {
 		return null;
 	}
 
-	if (sample.format === 'sowt') {
-		return 'aiff';
-	}
+	return sample.numberOfChannels;
+};
 
-	const child = sample.children.find((c) => c.type === 'esds-box');
+export const getSampleRate = (trak: TrakBox): number | null => {
+	const stsdBox = getStsdBox(trak);
+	if (!stsdBox) {
+		return null;
+	}
 
-	if (child && child.type === 'esds-box') {
-		const ret = onEsdsBox(child);
-		if (ret) {
-			return ret;
-		}
+	const sample = stsdBox.samples.find((s) => s.type === 'audio');
+	if (!sample || sample.type !== 'audio') {
+		return null;
 	}
+
+	return sample.sampleRate;
 };
 
-export const getAudioCodec = (boxes: AnySegment[]): KnownAudioCodecs | null => {
-	const moovBox = boxes.find((b) => b.type === 'moov-box');
-	if (moovBox && moovBox.type === 'moov-box') {
-		const trakBox = moovBox.children.find(
-			(b) => b.type === 'trak-box' && trakBoxContainsAudio(b),
-		);
-		if (trakBox && trakBox.type === 'trak-box') {
-			const mdiaBox = trakBox.children.find(
-				(b) => b.type === 'regular-box' && b.boxType === 'mdia',
-			);
-			if (
-				mdiaBox &&
-				mdiaBox.type === 'regular-box' &&
-				mdiaBox.boxType === 'mdia'
-			) {
-				const minfBox = mdiaBox?.children.find(
-					(b) => b.type === 'regular-box' && b.boxType === 'minf',
-				);
-				if (
-					minfBox &&
-					minfBox.type === 'regular-box' &&
-					minfBox.boxType === 'minf'
-				) {
-					const stblBox = minfBox?.children.find(
-						(b) => b.type === 'regular-box' && b.boxType === 'stbl',
-					);
-					if (stblBox && stblBox.type === 'regular-box') {
-						const stsdBox = stblBox?.children.find(
-							(b) => b.type === 'stsd-box',
-						);
-						if (stsdBox && stsdBox.type === 'stsd-box') {
-							const sample = stsdBox.samples.find((s) => s.type === 'audio');
-							if (sample && sample.type === 'audio') {
-								const ret = onSample(sample);
-								if (ret) {
-									return ret;
-								}
-
-								const waveBox = sample.children.find(
-									(b) => b.type === 'regular-box' && b.boxType === 'wave',
-								);
-								if (
-									waveBox &&
-									waveBox.type === 'regular-box' &&
-									waveBox.boxType === 'wave'
-								) {
-									const esdsBox = waveBox.children.find(
-										(b) => b.type === 'esds-box',
-									);
-									if (esdsBox && esdsBox.type === 'esds-box') {
-										const ret2 = onEsdsBox(esdsBox);
-										if (ret2) {
-											return ret2;
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			}
+export const getAudioCodecFromTrak = (trak: TrakBox): AudioCodecInfo | null => {
+	const stsdBox = getStsdBox(trak);
+	if (!stsdBox) {
+		return null;
+	}
+
+	const sample = stsdBox.samples.find((s) => s.type === 'audio');
+	if (!sample || sample.type !== 'audio') {
+		return null;
+	}
+
+	const waveBox = sample.children.find(
+		(b) => b.type === 'regular-box' && b.boxType === 'wave',
+	);
+	if (waveBox && waveBox.type === 'regular-box' && waveBox.boxType === 'wave') {
+		const esdsSample = onSample(sample, waveBox.children);
+		if (esdsSample) {
+			return esdsSample;
 		}
 	}
 
-	const mainSegment = boxes.find((b) => b.type === 'main-segment');
-	if (!mainSegment || mainSegment.type !== 'main-segment') {
+	const ret = onSample(sample, sample.children);
+	if (ret) {
+		return ret;
+	}
+
+	return null;
+};
+
+export const getAudioCodecFromIso = (moov: MoovBox) => {
+	const traks = getTraks(moov);
+	const trakBox = traks.find(
+		(b) => b.type === 'trak-box' && trakBoxContainsAudio(b),
+	);
+	if (!trakBox) {
 		return null;
 	}
 
+	return getAudioCodecFromTrak(trakBox);
+};
+
+export const getAudioCodecFromMatroska = (mainSegment: MainSegment) => {
 	const tracksSegment = mainSegment.children.find(
 		(b) => b.type === 'tracks-segment',
 	);
@@ -132,12 +178,95 @@ export const getAudioCodec = (boxes: AnySegment[]): KnownAudioCodecs | null => {
 					return 'opus';
 				}
 
+				if (trackType.codec === 'A_VORBIS') {
+					return 'vorbis';
+				}
+
 				if (trackType.codec === 'A_PCM/INT/LIT') {
 					return 'pcm';
 				}
+
+				if (trackType.codec === 'A_AAC') {
+					return 'aac';
+				}
+
+				if (trackType.codec === 'A_MPEG/L3') {
+					return 'mp3';
+				}
 			}
 		}
 	}
 
 	return null;
 };
+
+export const getAudioCodecStringFromTrak = (
+	trak: TrakBox,
+): {codecString: string; description: Uint8Array | undefined} => {
+	const codec = getAudioCodecFromTrak(trak);
+	if (!codec) {
+		throw new Error('Expected codec');
+	}
+
+	const codecStringWithoutMp3Exception = (
+		[
+			codec.format,
+			codec.primarySpecificator ? codec.primarySpecificator.toString(16) : null,
+			codec.secondarySpecificator
+				? codec.secondarySpecificator.toString().padStart(2, '0')
+				: null,
+		].filter(Boolean) as string[]
+	).join('.');
+
+	// Really, MP3? 😔
+	const codecString =
+		codecStringWithoutMp3Exception === 'mp4a.6b'
+			? 'mp3' // or "mp4a.6B" would also work, with the uppercasing, but mp3 is probably more obvious
+			: codecStringWithoutMp3Exception;
+
+	return {
+		codecString,
+		description: codec.description,
+	};
+};
+
+export const getAudioCodec = (boxes: AnySegment[]): KnownAudioCodecs | null => {
+	const moovBox = getMoovBox(boxes);
+
+	if (moovBox) {
+		const codec = getAudioCodecFromIso(moovBox);
+
+		if (!codec) {
+			return null;
+		}
+
+		if (codec.format === 'sowt') {
+			return 'aiff';
+		}
+
+		if (codec.format === 'mp4a') {
+			if (codec.primarySpecificator === 0x40) {
+				return 'aac';
+			}
+
+			if (codec.primarySpecificator === 0x6b) {
+				return 'mp3';
+			}
+
+			if (codec.primarySpecificator === null) {
+				return 'aac';
+			}
+
+			throw new Error('Unknown mp4a codec: ' + codec.primarySpecificator);
+		}
+
+		throw new Error('Unknown audio format: ' + codec.format);
+	}
+
+	const mainSegment = boxes.find((b) => b.type === 'main-segment');
+	if (!mainSegment || mainSegment.type !== 'main-segment') {
+		return null;
+	}
+
+	return getAudioCodecFromMatroska(mainSegment);
+};

package/src/get-dimensions.ts

@@ -1,153 +1,46 @@
-import type {MainSegment} from './boxes/webm/segments/main';
+import {getTracks} from './get-tracks';
 import type {AnySegment} from './parse-result';
+import type {ParserState} from './parser-state';
 
 export type Dimensions = {
 	width: number;
 	height: number;
 };
 
-const getDimensionsFromMatroska = (segments: MainSegment): Dimensions => {
-	const tracksSegment = segments.children.find(
-		(b) => b.type === 'tracks-segment',
-	);
-	if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
-		throw new Error('No tracks segment');
-	}
-
-	const trackEntrySegment = tracksSegment.children.find((b) => {
-		if (b.type !== 'track-entry-segment') {
-			return false;
-		}
-
-		return (
-			b.children.find(
-				(c) => c.type === 'codec-segment' && c.codec.startsWith('V_'),
-			) !== undefined
-		);
-	});
-	if (!trackEntrySegment || trackEntrySegment.type !== 'track-entry-segment') {
-		throw new Error('No track entry segment');
-	}
-
-	const videoSegment = trackEntrySegment.children.find(
-		(b) => b.type === 'video-segment',
-	);
-	if (!videoSegment || videoSegment.type !== 'video-segment') {
-		throw new Error('No video segment');
-	}
+export type ExpandedDimensions = Dimensions & {
+	rotation: number;
+	unrotatedWidth: number;
+	unrotatedHeight: number;
+};
 
-	const widthSegment = videoSegment.children.find(
-		(b) => b.type === 'width-segment',
-	);
-	if (!widthSegment || widthSegment.type !== 'width-segment') {
-		throw new Error('No width segment');
+export const getDimensions = (
+	boxes: AnySegment[],
+	state: ParserState,
+): ExpandedDimensions => {
+	const {videoTracks} = getTracks(boxes, state);
+	if (!videoTracks.length) {
+		throw new Error('Expected video track');
 	}
 
-	const heightSegment = videoSegment.children.find(
-		(b) => b.type === 'height-segment',
-	);
-	if (!heightSegment || heightSegment.type !== 'height-segment') {
-		throw new Error('No height segment');
-	}
+	const firstVideoTrack = videoTracks[0];
 
 	return {
-		width: widthSegment.width,
-		height: heightSegment.height,
+		width: firstVideoTrack.width,
+		height: firstVideoTrack.height,
+		rotation: firstVideoTrack.rotation,
+		unrotatedHeight: firstVideoTrack.displayAspectHeight,
+		unrotatedWidth: firstVideoTrack.displayAspectWidth,
 	};
 };
 
-export const getDimensions = (boxes: AnySegment[]): Dimensions => {
-	const matroskaBox = boxes.find((b) => b.type === 'main-segment');
-	if (matroskaBox && matroskaBox.type === 'main-segment') {
-		return getDimensionsFromMatroska(matroskaBox);
-	}
-
-	const moovBox = boxes.find((b) => b.type === 'moov-box');
-	if (!moovBox || moovBox.type !== 'moov-box') {
-		throw new Error('Expected moov box');
-	}
-
-	const {children} = moovBox;
-	if (!children) {
-		throw new Error('Expected moov box children');
-	}
-
-	const t = children.find((b) => b.type === 'trak-box');
-
-	if (!t || t.type !== 'trak-box') {
-		throw new Error('Expected trak box');
-	}
-
-	const mdiaBox = t.children.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'mdia',
-	);
-	const tkhdBox = t.children.find((c) => c.type === 'tkhd-box');
-	if (tkhdBox && tkhdBox.type === 'tkhd-box') {
-		return {
-			width: tkhdBox.width,
-			height: tkhdBox.height,
-		};
-	}
-
-	if (!mdiaBox) {
-		throw new Error('Expected mdia box');
-	}
-
-	if (mdiaBox.type !== 'regular-box') {
-		throw new Error('Expected mdia box');
-	}
-
-	const minfBox = mdiaBox.children.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'minf',
-	);
-	if (!minfBox) {
-		throw new Error('Expected minf box');
-	}
-
-	if (minfBox.type !== 'regular-box') {
-		throw new Error('Expected minf box');
-	}
-
-	const stblBox = minfBox.children.find(
-		(c) => c.type === 'regular-box' && c.boxType === 'stbl',
-	);
-
-	if (!stblBox) {
-		throw new Error('Expected stbl box');
-	}
-
-	if (stblBox.type !== 'regular-box') {
-		throw new Error('Expected stbl box');
-	}
-
-	const stsdBox = stblBox.children.find((c) => c.type === 'stsd-box');
-
-	if (!stsdBox) {
-		throw new Error('Expected stsd box');
-	}
-
-	if (stsdBox.type !== 'stsd-box') {
-		throw new Error('Expected stsd box');
-	}
-
-	const videoSamples = stsdBox.samples.filter((s) => s.type === 'video');
-	if (videoSamples.length === 0) {
-		throw new Error('Has no video stream');
-	}
-
-	const [firstTrack] = videoSamples;
-	if (firstTrack.type !== 'video') {
-		throw new Error('Expected video track');
-	}
-
-	return {width: firstTrack.width, height: firstTrack.height};
-};
-
 // TODO: An audio track should return 'hasDimensions' = true on an audio file
 // and stop parsing
-export const hasDimensions = (boxes: AnySegment[]): boolean => {
+export const hasDimensions = (
+	boxes: AnySegment[],
+	state: ParserState,
+): boolean => {
 	try {
-		return getDimensions(boxes) !== null;
+		return getDimensions(boxes, state) !== null;
 	} catch (err) {
 		return false;
 	}

package/src/get-duration.ts

@@ -1,4 +1,5 @@
 import type {AnySegment} from './parse-result';
+import {getMoovBox, getMvhdBox} from './traversal';
 
 const getDurationFromMatroska = (segments: AnySegment[]): number | null => {
 	const mainSegment = segments.find((s) => s.type === 'main-segment');
@@ -41,17 +42,12 @@ export const getDuration = (boxes: AnySegment[]): number | null => {
 		return getDurationFromMatroska(boxes);
 	}
 
-	const moovBox = boxes.find((b) => b.type === 'moov-box');
-	if (!moovBox || moovBox.type !== 'moov-box') {
+	const moovBox = getMoovBox(boxes);
+	if (!moovBox) {
 		return null;
 	}
 
-	const {children} = moovBox;
-	if (!children) {
-		return null;
-	}
-
-	const mvhdBox = children.find((b) => b.type === 'mvhd-box');
+	const mvhdBox = getMvhdBox(moovBox);
 
 	if (!mvhdBox) {
 		return null;