@remotion/media-parser 4.0.191 → 4.0.192

package/src/boxes/iso-base-media/stsd/samples.ts

@@ -77,6 +77,7 @@ const videoTags = [
 	'v410',
 	'v210',
 	'hvc1',
+	'ap4h',
 ];
 
 // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_descriptions

package/src/boxes/webm/parse-webm-header.ts

@@ -5,7 +5,7 @@ import {expectSegment} from './segments';
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
 export const parseWebm = (counter: BufferIterator): ParseResult => {
 	counter.discard(4);
-	const length = counter.getEBML();
+	const length = counter.getVint();
 
 	if (length !== 31) {
 		throw new Error(`Expected header length 31, got ${length}`);

package/src/boxes/webm/segments/track-entry.ts

@@ -51,10 +51,6 @@ export type TrackUIDSegment = {
 
 export const parseTrackUID = (iterator: BufferIterator): TrackUIDSegment => {
 	const length = iterator.getVint();
-	// Observation: AV1 has 8 bytes, WebM has 7
-	if (length !== 8 && length !== 7) {
-		throw new Error('Expected track number to be 8 byte');
-	}
 
 	const bytes = iterator.getSlice(length);
 
@@ -187,16 +183,11 @@ export type VideoSegment = {
 };
 
 export const parseVideoSegment = (iterator: BufferIterator): VideoSegment => {
-	const offset = iterator.counter.getOffset();
-
 	const length = iterator.getVint();
 
 	return {
 		type: 'video-segment',
-		children: expectChildren(
-			iterator,
-			length - (iterator.counter.getOffset() - offset),
-		),
+		children: expectChildren(iterator, length),
 	};
 };
 
@@ -293,3 +284,39 @@ export const parseColorSegment = (iterator: BufferIterator): ColorSegment => {
 		type: 'color-segment',
 	};
 };
+
+export type TitleSegment = {
+	type: 'title-segment';
+	title: string;
+};
+
+export const parseTitleSegment = (iterator: BufferIterator): TitleSegment => {
+	const length = iterator.getVint();
+	const title = iterator.getByteString(length);
+
+	return {
+		type: 'title-segment',
+		title,
+	};
+};
+
+export type InterlacedSegment = {
+	type: 'interlaced-segment';
+	interlaced: boolean;
+};
+
+export const parseInterlacedSegment = (
+	iterator: BufferIterator,
+): InterlacedSegment => {
+	const length = iterator.getVint();
+	if (length !== 1) {
+		throw new Error('Expected interlaced segment to be 1 byte');
+	}
+
+	const interlaced = iterator.getUint8();
+
+	return {
+		type: 'interlaced-segment',
+		interlaced: Boolean(interlaced),
+	};
+};

package/src/boxes/webm/segments.ts

@@ -22,8 +22,10 @@ import type {
 	DefaultDurationSegment,
 	FlagLacingSegment,
 	HeightSegment,
+	InterlacedSegment,
 	LanguageSegment,
 	MaxBlockAdditionId,
+	TitleSegment,
 	TrackEntrySegment,
 	TrackNumberSegment,
 	TrackTypeSegment,
@@ -38,8 +40,10 @@ import {
 	parseDefaultDurationSegment,
 	parseFlagLacing,
 	parseHeightSegment,
+	parseInterlacedSegment,
 	parseLanguageSegment,
 	parseMaxBlockAdditionId,
+	parseTitleSegment,
 	parseTrackEntry,
 	parseTrackNumber,
 	parseTrackTypeSegment,
@@ -82,7 +86,9 @@ export type MatroskaSegment =
 	| HeightSegment
 	| AlphaModeSegment
 	| MaxBlockAdditionId
-	| ColorSegment;
+	| ColorSegment
+	| TitleSegment
+	| InterlacedSegment;
 
 export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
 	const segmentId = iterator.getMatroskaSegmentId();
@@ -189,10 +195,18 @@ export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
 		return parseHeightSegment(iterator);
 	}
 
+	if (segmentId === '0x9a') {
+		return parseInterlacedSegment(iterator);
+	}
+
 	if (segmentId === '0x53c0') {
 		return parseAlphaModeSegment(iterator);
 	}
 
+	if (segmentId === '0x7ba9') {
+		return parseTitleSegment(iterator);
+	}
+
 	const length = iterator.getVint();
 
 	const bytesRemaining = iterator.byteLength() - iterator.counter.getOffset();

package/src/buffer-iterator.ts

@@ -154,6 +154,7 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 				'0xe0',
 				'0xb0',
 				'0xba',
+				'0x9a',
 			];
 			if (knownIdsWithOneLength.includes(firstOneString)) {
 				return firstOneString;
@@ -172,6 +173,7 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 				'0x4489',
 				'0x55ee',
 				'0x55b0',
+				'0x7ba9',
 			];
 
 			const firstTwoString = `${firstOneString}${Array.from(

package/src/get-fps.ts

@@ -1,18 +1,135 @@
 import type {SttsBox} from './boxes/iso-base-media/stts/stts';
 import type {AnySegment} from './parse-result';
 
-const calculateFps = (sttsBox: SttsBox, timeScale: number) => {
-	let sum = 0;
+const calculateFps = ({
+	sttsBox,
+	timeScale,
+	durationInSamples,
+}: {
+	sttsBox: SttsBox;
+	timeScale: number;
+	durationInSamples: number;
+}) => {
 	let totalSamples = 0;
+
 	for (const sample of sttsBox.sampleDistribution) {
-		sum += sample.sampleCount * sample.sampleDelta;
 		totalSamples += sample.sampleCount;
 	}
 
-	return timeScale / (sum / totalSamples);
+	const durationInSeconds = durationInSamples / timeScale;
+	const fps = totalSamples / durationInSeconds;
+
+	return fps;
+};
+
+type TimescaleAndDuration = {
+	timescale: number;
+	duration: number;
+};
+
+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') {
+		return false;
+	}
+
+	const videoSample = stsd.samples.find((s) => s.type === 'video');
+	if (!videoSample || videoSample.type !== 'video') {
+		return false;
+	}
+
+	return true;
+};
+
+export const getTimescaleAndDuration = (
+	boxes: AnySegment[],
+): 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') {
+		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};
 };
 
 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') {
 		return null;
@@ -23,16 +140,13 @@ export const getFps = (segments: AnySegment[]) => {
 		return null;
 	}
 
-	const {timeScale} = mvhdBox;
-
 	const {children} = moovBox;
 	const trackBoxes = children.filter((c) => c.type === 'trak-box');
 	if (!trackBoxes || trackBoxes.length === 0) {
 		return null;
 	}
 
-	// TODO: What if the video track is not the first track?
-	const trackBox = trackBoxes[0];
+	const trackBox = trackBoxes.find(trakBoxContainsVideo);
 	if (!trackBox || trackBox.type !== 'trak-box') {
 		return null;
 	}
@@ -80,7 +194,11 @@ export const getFps = (segments: AnySegment[]) => {
 		return null;
 	}
 
-	return calculateFps(sttsBox, timeScale);
+	return calculateFps({
+		sttsBox,
+		timeScale: timescaleAndDuration.timescale,
+		durationInSamples: timescaleAndDuration.duration,
+	});
 };
 
 export const hasFps = (boxes: AnySegment[]): boolean => {

package/src/get-video-codec.ts

@@ -0,0 +1,100 @@
+/* eslint-disable max-depth */
+import {trakBoxContainsVideo} from './get-fps';
+import type {KnownVideoCodecs} from './options';
+import type {AnySegment} from './parse-result';
+
+export const hasVideoCodec = (boxes: AnySegment[]): boolean => {
+	try {
+		return getVideoCodec(boxes) !== null;
+	} catch (e) {
+		return false;
+	}
+};
+
+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 mainSegment = boxes.find((b) => b.type === 'main-segment');
+	if (!mainSegment || mainSegment.type !== 'main-segment') {
+		return null;
+	}
+
+	const tracksSegment = mainSegment.children.find(
+		(b) => b.type === 'tracks-segment',
+	);
+	if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+		return null;
+	}
+
+	for (const track of tracksSegment.children) {
+		if (track.type === 'track-entry-segment') {
+			const trackType = track.children.find((b) => b.type === 'codec-segment');
+			if (trackType && trackType.type === 'codec-segment') {
+				if (trackType.codec === 'V_VP8') {
+					return 'vp8';
+				}
+
+				if (trackType.codec === 'V_VP9') {
+					return 'vp9';
+				}
+
+				if (trackType.codec === 'V_AV1') {
+					return 'av1';
+				}
+			}
+		}
+	}
+
+	return null;
+};

package/src/has-all-info.ts

@@ -1,16 +1,17 @@
 import {hasDimensions} from './get-dimensions';
 import {hasDuration} from './get-duration';
 import {hasFps} from './get-fps';
+import {hasVideoCodec} from './get-video-codec';
 import type {Options} from './options';
 import type {ParseResult} from './parse-result';
 
 export const hasAllInfo = (
-	options: Options<boolean, boolean, boolean, boolean>,
+	options: Options<boolean, boolean, boolean, boolean, boolean>,
 	parseResult: ParseResult,
 ) => {
 	const keys = Object.entries(options)
 		.filter(([, value]) => value)
-		.map(([key]) => key) as (keyof Options<true, true, true, true>)[];
+		.map(([key]) => key) as (keyof Options<true, true, true, true, true>)[];
 
 	return keys.every((key) => {
 		if (key === 'boxes') {
@@ -29,6 +30,10 @@ export const hasAllInfo = (
 			return hasFps(parseResult.segments) !== null;
 		}
 
+		if (key === 'videoCodec') {
+			return hasVideoCodec(parseResult.segments) !== null;
+		}
+
 		throw new Error(`Unknown key: ${key satisfies never}`);
 	});
 };

package/src/options.ts

@@ -2,16 +2,26 @@ import type {Dimensions} from './get-dimensions';
 import type {AnySegment} from './parse-result';
 import type {ReaderInterface} from './reader';
 
+export type KnownVideoCodecs =
+	| 'h264'
+	| 'h265'
+	| 'vp8'
+	| 'vp9'
+	| 'av1'
+	| 'prores';
+
 export type Options<
 	EnableDimensions extends boolean,
 	EnableDuration extends boolean,
 	EnableBoxes extends boolean,
 	EnableFps extends boolean,
+	EnableVideoCodec extends boolean,
 > = {
 	dimensions?: EnableDimensions;
 	durationInSeconds?: EnableDuration;
 	boxes?: EnableBoxes;
 	fps?: EnableFps;
+	videoCodec?: EnableVideoCodec;
 };
 
 export type Metadata<
@@ -19,20 +29,35 @@ export type Metadata<
 	EnableDuration extends boolean,
 	EnableBoxes extends boolean,
 	EnableFps extends boolean,
+	EnableVideoCodec extends boolean,
 > = (EnableDimensions extends true ? {dimensions: Dimensions} : {}) &
 	(EnableDuration extends true ? {durationInSeconds: number | null} : {}) &
 	(EnableBoxes extends true ? {boxes: AnySegment[]} : {}) &
-	(EnableFps extends true ? {fps: number | null} : {});
+	(EnableFps extends true ? {fps: number | null} : {}) &
+	(EnableVideoCodec extends true ? {videoCodec: KnownVideoCodecs | null} : {});
 
 export type ParseMedia = <
 	EnableDimensions extends boolean,
 	EnableDuration extends boolean,
 	EnableBoxes extends boolean,
 	EnableFps extends boolean,
+	EnableVideoCodec extends boolean,
 >(
 	src: string,
-	options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps>,
+	options: Options<
+		EnableDimensions,
+		EnableDuration,
+		EnableBoxes,
+		EnableFps,
+		EnableVideoCodec
+	>,
 	readerInterface?: ReaderInterface,
 ) => Promise<
-	Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps>
+	Metadata<
+		EnableDimensions,
+		EnableDuration,
+		EnableBoxes,
+		EnableFps,
+		EnableVideoCodec
+	>
 >;

package/src/parse-media.ts

@@ -3,6 +3,7 @@ import {webReader} from './from-web';
 import {getDimensions} from './get-dimensions';
 import {getDuration} from './get-duration';
 import {getFps} from './get-fps';
+import {getVideoCodec} from './get-video-codec';
 import {hasAllInfo} from './has-all-info';
 import type {Metadata, ParseMedia} from './options';
 import {parseVideo} from './parse-video';
@@ -14,7 +15,7 @@ export const parseMedia: ParseMedia = async (
 ) => {
 	const reader = await readerInterface.read(src, null);
 
-	const returnValue = {} as Metadata<true, true, true, true>;
+	const returnValue = {} as Metadata<true, true, true, true, true>;
 
 	const iterator = getArrayBufferIterator(new Uint8Array([]));
 	let parseResult = parseVideo(iterator);
@@ -49,6 +50,10 @@ export const parseMedia: ParseMedia = async (
 		returnValue.fps = getFps(parseResult.segments);
 	}
 
+	if (options.videoCodec) {
+		returnValue.videoCodec = getVideoCodec(parseResult.segments);
+	}
+
 	if (options.boxes) {
 		returnValue.boxes = parseResult.segments;
 	}

package/src/parse-result.ts

@@ -1,5 +1,6 @@
 import type {BaseBox} from './boxes/iso-base-media/base-type';
 import type {FtypBox} from './boxes/iso-base-media/ftyp';
+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 {KeysBox} from './boxes/iso-base-media/stsd/keys';
@@ -28,7 +29,8 @@ export type IsoBaseMediaBox =
 	| KeysBox
 	| MoovBox
 	| TrakBox
-	| SttsBox;
+	| SttsBox
+	| MdhdBox;
 
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
 

package/src/test/matroska.test.ts

@@ -137,18 +137,18 @@ test('Should get duration of AV1 video', async () => {
 										{
 											type: 'color-segment',
 										},
+										{
+											id: '0x0163a294',
+											type: 'unknown-segment',
+										},
 									],
 								},
 								{
-									id: '0x0163a294',
+									id: '0x0c000a0e',
 									type: 'unknown-segment',
 								},
 							],
 						},
-						{
-							id: '0x0c000a0e',
-							type: 'unknown-segment',
-						},
 					],
 				},
 				{

package/src/test/parse-webm.test.ts

@@ -8,8 +8,10 @@ test('should be able to parse a WebM', async () => {
 		RenderInternals.exampleVideos.transparentWebm,
 		{
 			durationInSeconds: true,
+			videoCodec: true,
 		},
 		nodeReader,
 	);
 	expect(webm.durationInSeconds).toBe(5);
+	expect(webm.videoCodec).toBe('vp8');
 });