@remotion/media-parser 4.0.194 → 4.0.196

package/src/get-video-codec.ts

@@ -1,7 +1,17 @@
 /* eslint-disable max-depth */
+import type {TrakBox} from './boxes/iso-base-media/trak/trak';
+import {parseAv1PrivateData} from './boxes/webm/av1-codec-private';
 import {trakBoxContainsVideo} from './get-fps';
+import {
+	getAv1CBox,
+	getAvccBox,
+	getColrBox,
+	getHvccBox,
+	getVideoSample,
+} from './get-sample-aspect-ratio';
 import type {KnownVideoCodecs} from './options';
 import type {AnySegment} from './parse-result';
+import {getMoovBox, getStsdBox, getTraks} from './traversal';
 
 export const hasVideoCodec = (boxes: AnySegment[]): boolean => {
 	try {
@@ -11,54 +21,55 @@ export const hasVideoCodec = (boxes: AnySegment[]): boolean => {
 	}
 };
 
+export const getVideoCodecString = (trakBox: TrakBox): string | null => {
+	const videoSample = getVideoSample(trakBox);
+	const avccBox = getAvccBox(trakBox);
+	const hvccBox = getHvccBox(trakBox);
+	const av1cBox = getAv1CBox(trakBox);
+
+	if (!videoSample) {
+		return null;
+	}
+
+	if (avccBox) {
+		return `${videoSample.format}.${avccBox.configurationString}`;
+	}
+
+	if (hvccBox) {
+		return `${videoSample.format}.${hvccBox.configurationString}`;
+	}
+
+	if (av1cBox) {
+		const colrAtom = getColrBox(videoSample);
+		return parseAv1PrivateData(av1cBox.privateData, colrAtom);
+	}
+
+	return videoSample.format;
+};
+
 export const getVideoCodec = (boxes: AnySegment[]): KnownVideoCodecs | 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' && trakBoxContainsVideo(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 videoSample = stsdBox.samples.find(
-								(s) => s.type === 'video',
-							);
-							if (videoSample && videoSample.type === 'video') {
-								if (videoSample.format === 'hvc1') {
-									return 'h265';
-								}
-
-								if (videoSample.format === 'avc1') {
-									return 'h264';
-								}
-
-								if (videoSample.format === 'ap4h') {
-									return 'prores';
-								}
-							}
-						}
+	const moovBox = getMoovBox(boxes);
+	if (moovBox) {
+		const trakBox = getTraks(moovBox).filter((t) => trakBoxContainsVideo(t))[0];
+		if (trakBox) {
+			const stsdBox = getStsdBox(trakBox);
+			if (stsdBox && stsdBox.type === 'stsd-box') {
+				const videoSample = stsdBox.samples.find((s) => s.type === 'video');
+				if (videoSample && videoSample.type === 'video') {
+					if (videoSample.format === 'hvc1') {
+						return 'h265';
+					}
+
+					if (videoSample.format === 'avc1') {
+						return 'h264';
+					}
+
+					if (videoSample.format === 'av01') {
+						return 'av1';
+					}
+
+					if (videoSample.format === 'ap4h') {
+						return 'prores';
 					}
 				}
 			}
@@ -96,6 +107,10 @@ export const getVideoCodec = (boxes: AnySegment[]): KnownVideoCodecs | null => {
 				if (trackType.codec === 'V_MPEG4/ISO/AVC') {
 					return 'h264';
 				}
+
+				if (trackType.codec === 'V_MPEGH/ISO/HEVC') {
+					return 'h265';
+				}
 			}
 		}
 	}

package/src/has-all-info.ts

@@ -2,13 +2,27 @@ import {hasAudioCodec} from './get-audio-codec';
 import {hasDimensions} from './get-dimensions';
 import {hasDuration} from './get-duration';
 import {hasFps} from './get-fps';
+import {hasTracks} from './get-tracks';
 import {hasVideoCodec} from './get-video-codec';
 import type {Options} from './options';
 import type {ParseResult} from './parse-result';
+import type {ParserState} from './parser-state';
 
 export const hasAllInfo = (
-	options: Options<boolean, boolean, boolean, boolean, boolean, boolean>,
+	options: Options<
+		boolean,
+		boolean,
+		boolean,
+		boolean,
+		boolean,
+		boolean,
+		boolean,
+		boolean,
+		boolean,
+		boolean
+	>,
 	parseResult: ParseResult,
+	state: ParserState,
 ) => {
 	const keys = Object.entries(options)
 		.filter(([, value]) => value)
@@ -18,6 +32,10 @@ export const hasAllInfo = (
 		true,
 		true,
 		true,
+		true,
+		true,
+		true,
+		true,
 		true
 	>)[];
 
@@ -30,8 +48,12 @@ export const hasAllInfo = (
 			return hasDuration(parseResult.segments);
 		}
 
-		if (key === 'dimensions') {
-			return hasDimensions(parseResult.segments);
+		if (
+			key === 'dimensions' ||
+			key === 'rotation' ||
+			key === 'unrotatedDimension'
+		) {
+			return hasDimensions(parseResult.segments, state);
 		}
 
 		if (key === 'fps') {
@@ -39,11 +61,19 @@ export const hasAllInfo = (
 		}
 
 		if (key === 'videoCodec') {
-			return hasVideoCodec(parseResult.segments) !== null;
+			return hasVideoCodec(parseResult.segments);
 		}
 
 		if (key === 'audioCodec') {
-			return hasAudioCodec(parseResult.segments) !== null;
+			return hasAudioCodec(parseResult.segments);
+		}
+
+		if (key === 'tracks') {
+			return hasTracks(parseResult.segments);
+		}
+
+		if (key === 'internalStats') {
+			return false;
 		}
 
 		throw new Error(`Unknown key: ${key satisfies never}`);

package/src/index.ts

@@ -1 +1,9 @@
 export {parseMedia} from './parse-media';
+export {
+	AudioSample,
+	OnAudioSample,
+	OnAudioTrack,
+	OnVideoSample,
+	OnVideoTrack,
+	VideoSample,
+} from './webcodec-sample-types';

package/src/make-hvc1-codec-strings.ts

@@ -0,0 +1,55 @@
+import type {BufferIterator} from './buffer-iterator';
+
+export const getHvc1CodecString = (data: BufferIterator) => {
+	const configurationVersion = data.getUint8();
+	if (configurationVersion !== 1) {
+		throw new Error(`Unsupported HVCC version ${configurationVersion}`);
+	}
+
+	const generalProfileSpaceTierFlagAndIdc = data.getUint8();
+	let generalProfileCompatibility = data.getUint32();
+	//  unsigned int(2) general_profile_space;
+	// 	unsigned int(1) general_tier_flag;
+	//	unsigned int(5) general_profile_idc;
+
+	const generalProfileSpace = generalProfileSpaceTierFlagAndIdc >> 6;
+	const generalTierFlag = generalProfileSpaceTierFlagAndIdc >> 5;
+	const generalProfileIdc = generalProfileSpaceTierFlagAndIdc >> 0;
+
+	// general_constraint_indicator_flags(48)
+	const generalConstraintIndicator = data.getSlice(6);
+	const generalLevelIdc = data.getUint8();
+
+	let reversedGeneralProfileSpace = 0;
+	for (let i = 0; i < 32; i++) {
+		reversedGeneralProfileSpace |= generalProfileCompatibility & 1;
+		if (i === 31) break;
+
+		reversedGeneralProfileSpace <<= 1;
+		generalProfileCompatibility >>= 1;
+	}
+
+	const profileSpaceChar =
+		generalProfileSpace === 0
+			? ''
+			: generalProfileSpace === 1
+				? 'A'
+				: generalProfileSpace === 2
+					? 'B'
+					: 'C';
+
+	const generalTierChar = generalTierFlag === 0 ? 'L' : 'H';
+
+	let hasByte = false;
+
+	let generalConstraintString = '';
+	for (let i = 5; i >= 0; i--) {
+		if (generalConstraintIndicator[i] || hasByte) {
+			generalConstraintString =
+				generalConstraintIndicator[i].toString(16) + generalConstraintString;
+			hasByte = true;
+		}
+	}
+
+	return `${profileSpaceChar}${generalProfileIdc.toString(16)}.${reversedGeneralProfileSpace.toString(16)}.${generalTierChar}${generalLevelIdc}.${generalConstraintString}`;
+};

package/src/options.ts

@@ -1,6 +1,10 @@
+import type {} from './boxes/iso-base-media/mdat/mdat';
 import type {Dimensions} from './get-dimensions';
+import type {AudioTrack, VideoTrack} from './get-tracks';
 import type {AnySegment} from './parse-result';
+import type {InternalStats} from './parser-state';
 import type {ReaderInterface} from './reader';
+import type {OnAudioTrack, OnVideoTrack} from './webcodec-sample-types';
 
 export type KnownVideoCodecs =
 	| 'h264'
@@ -16,6 +20,7 @@ export type KnownAudioCodecs =
 	| 'aiff'
 	| 'opus'
 	| 'pcm'
+	| 'vorbis'
 	| 'unknown';
 
 export type Options<
@@ -25,6 +30,10 @@ export type Options<
 	EnableFps extends boolean,
 	EnableVideoCodec extends boolean,
 	EnableAudioCodec extends boolean,
+	EnableTracks extends boolean,
+	EnableRotation extends boolean,
+	EnableUnrotatedDimensions extends boolean,
+	EnableInternalStats extends boolean,
 > = {
 	dimensions?: EnableDimensions;
 	durationInSeconds?: EnableDuration;
@@ -32,6 +41,10 @@ export type Options<
 	fps?: EnableFps;
 	videoCodec?: EnableVideoCodec;
 	audioCodec?: EnableAudioCodec;
+	tracks?: EnableTracks;
+	rotation?: EnableRotation;
+	unrotatedDimension?: EnableUnrotatedDimensions;
+	internalStats?: EnableInternalStats;
 };
 
 export type Metadata<
@@ -41,12 +54,24 @@ export type Metadata<
 	EnableFps extends boolean,
 	EnableVideoCodec extends boolean,
 	EnableAudioCodec extends boolean,
+	EnableTracks extends boolean,
+	EnableRotation extends boolean,
+	EnableUnrotatedDimensions extends boolean,
+	EnableInternalStats extends boolean,
 > = (EnableDimensions extends true ? {dimensions: Dimensions} : {}) &
 	(EnableDuration extends true ? {durationInSeconds: number | null} : {}) &
 	(EnableBoxes extends true ? {boxes: AnySegment[]} : {}) &
 	(EnableFps extends true ? {fps: number | null} : {}) &
 	(EnableVideoCodec extends true ? {videoCodec: KnownVideoCodecs | null} : {}) &
-	(EnableAudioCodec extends true ? {audioCodec: KnownAudioCodecs | null} : {});
+	(EnableAudioCodec extends true ? {audioCodec: KnownAudioCodecs | null} : {}) &
+	(EnableTracks extends true
+		? {videoTracks: VideoTrack[]; audioTracks: AudioTrack[]}
+		: {}) &
+	(EnableRotation extends true ? {rotation: number | null} : {}) &
+	(EnableUnrotatedDimensions extends true
+		? {unrotatedDimension: Dimensions}
+		: {}) &
+	(EnableInternalStats extends true ? {internalStats: InternalStats} : {});
 
 export type ParseMedia = <
 	EnableDimensions extends boolean,
@@ -55,24 +80,38 @@ export type ParseMedia = <
 	EnableFps extends boolean,
 	EnableVideoCodec extends boolean,
 	EnableAudioCodec extends boolean,
->(
-	src: string,
-	options: Options<
+	EnableTracks extends boolean,
+	EnableRotation extends boolean,
+	EnableUnrotatedDimensions extends boolean,
+	EnableInternalStats extends boolean,
+>(options: {
+	src: string | File;
+	fields?: Options<
 		EnableDimensions,
 		EnableDuration,
 		EnableBoxes,
 		EnableFps,
 		EnableVideoCodec,
-		EnableAudioCodec
-	>,
-	readerInterface?: ReaderInterface,
-) => Promise<
+		EnableAudioCodec,
+		EnableTracks,
+		EnableRotation,
+		EnableUnrotatedDimensions,
+		EnableInternalStats
+	>;
+	reader?: ReaderInterface;
+	onAudioTrack?: OnAudioTrack;
+	onVideoTrack?: OnVideoTrack;
+}) => Promise<
 	Metadata<
 		EnableDimensions,
 		EnableDuration,
 		EnableBoxes,
 		EnableFps,
 		EnableVideoCodec,
-		EnableAudioCodec
+		EnableAudioCodec,
+		EnableTracks,
+		EnableRotation,
+		EnableUnrotatedDimensions,
+		EnableInternalStats
 	>
 >;

package/src/parse-media.ts

@@ -1,51 +1,92 @@
+/* eslint-disable max-depth */
 import type {BufferIterator} from './buffer-iterator';
 import {getArrayBufferIterator} from './buffer-iterator';
-import {webReader} from './from-web';
+import {fetchReader} from './from-fetch';
 import {getAudioCodec} from './get-audio-codec';
 import {getDimensions} from './get-dimensions';
 import {getDuration} from './get-duration';
 import {getFps} from './get-fps';
+import {getTracks} from './get-tracks';
 import {getVideoCodec} from './get-video-codec';
 import {hasAllInfo} from './has-all-info';
 import type {Metadata, ParseMedia} from './options';
 import type {ParseResult} from './parse-result';
 import {parseVideo} from './parse-video';
+import type {ParserContext} from './parser-context';
+import {makeParserState} from './parser-state';
 
-export const parseMedia: ParseMedia = async (
+export const parseMedia: ParseMedia = async ({
 	src,
-	options,
-	readerInterface = webReader,
-) => {
+	fields,
+	reader: readerInterface = fetchReader,
+	onAudioTrack,
+	onVideoTrack,
+}) => {
 	const {reader, contentLength} = await readerInterface.read(src, null);
 	let currentReader = reader;
 
-	const returnValue = {} as Metadata<true, true, true, true, true, true>;
+	const returnValue = {} as Metadata<
+		true,
+		true,
+		true,
+		true,
+		true,
+		true,
+		true,
+		true,
+		true,
+		true
+	>;
 
 	let iterator: BufferIterator | null = null;
 	let parseResult: ParseResult | null = null;
 
+	const state = makeParserState({
+		hasAudioCallbacks: onAudioTrack !== null,
+		hasVideoCallbacks: onVideoTrack !== null,
+	});
+
+	const options: ParserContext = {
+		canSkipVideoData: !(onAudioTrack || onVideoTrack),
+		onAudioTrack: onAudioTrack ?? null,
+		onVideoTrack: onVideoTrack ?? null,
+		parserState: state,
+	};
+
 	while (parseResult === null || parseResult.status === 'incomplete') {
 		const result = await currentReader.read();
-		if (result.done) {
-			break;
-		}
 
 		if (iterator) {
-			iterator.addData(result.value);
+			if (!result.done) {
+				iterator.addData(result.value);
+			}
 		} else {
+			if (result.done) {
+				throw new Error('Unexpectedly reached EOF');
+			}
+
 			iterator = getArrayBufferIterator(
 				result.value,
 				contentLength ?? undefined,
 			);
 		}
 
-		if (parseResult) {
-			parseResult = parseResult.continueParsing();
+		if (parseResult && parseResult.status === 'incomplete') {
+			parseResult = await parseResult.continueParsing();
 		} else {
-			parseResult = parseVideo(iterator);
+			parseResult = await parseVideo({
+				iterator,
+				options,
+			});
 		}
 
-		if (hasAllInfo(options, parseResult)) {
+		// TODO Better: Check if no active listeners are registered
+		// Also maybe check for canSkipVideoData
+		if (
+			hasAllInfo(fields ?? {}, parseResult, state) &&
+			!onVideoTrack &&
+			!onAudioTrack
+		) {
 			if (!currentReader.closed) {
 				currentReader.cancel(new Error('has all information'));
 			}
@@ -75,29 +116,57 @@ export const parseMedia: ParseMedia = async (
 		throw new Error('Could not parse video');
 	}
 
-	if (options.dimensions) {
-		returnValue.dimensions = getDimensions(parseResult.segments);
+	if (fields?.dimensions) {
+		const dimensions = getDimensions(parseResult.segments, state);
+		returnValue.dimensions = {
+			width: dimensions.width,
+			height: dimensions.height,
+		};
 	}
 
-	if (options.durationInSeconds) {
+	if (fields?.unrotatedDimension) {
+		const dimensions = getDimensions(parseResult.segments, state);
+		returnValue.unrotatedDimension = {
+			width: dimensions.unrotatedWidth,
+			height: dimensions.unrotatedHeight,
+		};
+	}
+
+	if (fields?.rotation) {
+		const dimensions = getDimensions(parseResult.segments, state);
+		returnValue.rotation = dimensions.rotation;
+	}
+
+	if (fields?.durationInSeconds) {
 		returnValue.durationInSeconds = getDuration(parseResult.segments);
 	}
 
-	if (options.fps) {
+	if (fields?.fps) {
 		returnValue.fps = getFps(parseResult.segments);
 	}
 
-	if (options.videoCodec) {
+	if (fields?.videoCodec) {
 		returnValue.videoCodec = getVideoCodec(parseResult.segments);
 	}
 
-	if (options.audioCodec) {
+	if (fields?.audioCodec) {
 		returnValue.audioCodec = getAudioCodec(parseResult.segments);
 	}
 
-	if (options.boxes) {
+	if (fields?.tracks) {
+		const {audioTracks, videoTracks} = getTracks(parseResult.segments, state);
+		returnValue.audioTracks = audioTracks;
+		returnValue.videoTracks = videoTracks;
+	}
+
+	if (fields?.boxes) {
 		returnValue.boxes = parseResult.segments;
 	}
 
+	if (fields?.internalStats) {
+		returnValue.internalStats = state.getInternalStats();
+	}
+
+	iterator?.destroy();
 	return returnValue;
 };

package/src/parse-result.ts

@@ -1,18 +1,30 @@
 import type {BaseBox} from './boxes/iso-base-media/base-type';
 import type {EsdsBox} from './boxes/iso-base-media/esds/esds';
 import type {FtypBox} from './boxes/iso-base-media/ftyp';
+import type {MdatBox} from './boxes/iso-base-media/mdat/mdat';
 import type {MdhdBox} from './boxes/iso-base-media/mdhd';
 import type {MoovBox} from './boxes/iso-base-media/moov/moov';
 import type {MvhdBox} from './boxes/iso-base-media/mvhd';
+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 {CttsBox} from './boxes/iso-base-media/stsd/ctts';
+import type {HvccBox} from './boxes/iso-base-media/stsd/hvcc';
 import type {KeysBox} from './boxes/iso-base-media/stsd/keys';
 import type {MebxBox} from './boxes/iso-base-media/stsd/mebx';
+import type {PaspBox} from './boxes/iso-base-media/stsd/pasp';
+import type {StcoBox} from './boxes/iso-base-media/stsd/stco';
+import type {StscBox} from './boxes/iso-base-media/stsd/stsc';
 import type {StsdBox} from './boxes/iso-base-media/stsd/stsd';
-import type {SttsBox} from './boxes/iso-base-media/stts/stts';
+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 {TkhdBox} from './boxes/iso-base-media/tkhd';
 import type {TrakBox} from './boxes/iso-base-media/trak/trak';
+import type {VoidBox} from './boxes/iso-base-media/void-box';
 import type {MatroskaSegment} from './boxes/webm/segments';
 
-interface RegularBox extends BaseBox {
+export interface RegularBox extends BaseBox {
 	boxType: string;
 	boxSize: number;
 	children: AnySegment[];
@@ -32,7 +44,19 @@ export type IsoBaseMediaBox =
 	| TrakBox
 	| SttsBox
 	| MdhdBox
-	| EsdsBox;
+	| EsdsBox
+	| MdatBox
+	| StszBox
+	| StcoBox
+	| StscBox
+	| AvccBox
+	| HvccBox
+	| VoidBox
+	| StssBox
+	| PaspBox
+	| CttsBox
+	| Av1CBox
+	| ColorParameterBox;
 
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
 
@@ -45,5 +69,5 @@ export type ParseResult =
 			status: 'incomplete';
 			segments: AnySegment[];
 			skipTo: number | null;
-			continueParsing: () => ParseResult;
+			continueParsing: () => Promise<ParseResult>;
 	  };

package/src/parse-video.ts

@@ -2,6 +2,13 @@ import {parseBoxes} from './boxes/iso-base-media/process-box';
 import {parseWebm} from './boxes/webm/parse-webm-header';
 import type {BufferIterator} from './buffer-iterator';
 import type {IsoBaseMediaBox, ParseResult} from './parse-result';
+import type {ParserContext} from './parser-context';
+
+export type PartialMdatBox = {
+	type: 'partial-mdat-box';
+	boxSize: number;
+	fileOffset: number;
+};
 
 export type BoxAndNext =
 	| {
@@ -12,18 +19,28 @@ export type BoxAndNext =
 	  }
 	| {
 			type: 'incomplete';
-	  };
+	  }
+	| PartialMdatBox;
 
-export const parseVideo = (iterator: BufferIterator): ParseResult => {
+export const parseVideo = ({
+	iterator,
+	options,
+}: {
+	iterator: BufferIterator;
+	options: ParserContext;
+}): Promise<ParseResult> => {
 	if (iterator.bytesRemaining() === 0) {
-		return {
+		return Promise.resolve({
 			status: 'incomplete',
 			segments: [],
 			continueParsing: () => {
-				return parseVideo(iterator);
+				return parseVideo({
+					iterator,
+					options,
+				});
 			},
 			skipTo: null,
-		};
+		});
 	}
 
 	if (iterator.isIsoBaseMedia()) {
@@ -32,12 +49,18 @@ export const parseVideo = (iterator: BufferIterator): ParseResult => {
 			maxBytes: Infinity,
 			allowIncompleteBoxes: true,
 			initialBoxes: [],
+			options,
+			continueMdat: false,
 		});
 	}
 
 	if (iterator.isWebm()) {
-		return parseWebm(iterator);
+		return Promise.resolve(parseWebm(iterator, options));
+	}
+
+	if (iterator.isMp3()) {
+		return Promise.reject(new Error('MP3 files are not yet supported'));
 	}
 
-	throw new Error('Unknown video format');
+	return Promise.reject(new Error('Unknown video format'));
 };