@remotion/media-parser 4.0.191

package/src/has-all-info.ts

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

package/src/index.ts

@@ -0,0 +1 @@
+export {parseMedia} from './parse-media';

package/src/options.ts

@@ -0,0 +1,38 @@
+import type {Dimensions} from './get-dimensions';
+import type {AnySegment} from './parse-result';
+import type {ReaderInterface} from './reader';
+
+export type Options<
+	EnableDimensions extends boolean,
+	EnableDuration extends boolean,
+	EnableBoxes extends boolean,
+	EnableFps extends boolean,
+> = {
+	dimensions?: EnableDimensions;
+	durationInSeconds?: EnableDuration;
+	boxes?: EnableBoxes;
+	fps?: EnableFps;
+};
+
+export type Metadata<
+	EnableDimensions extends boolean,
+	EnableDuration extends boolean,
+	EnableBoxes extends boolean,
+	EnableFps extends boolean,
+> = (EnableDimensions extends true ? {dimensions: Dimensions} : {}) &
+	(EnableDuration extends true ? {durationInSeconds: number | null} : {}) &
+	(EnableBoxes extends true ? {boxes: AnySegment[]} : {}) &
+	(EnableFps extends true ? {fps: number | null} : {});
+
+export type ParseMedia = <
+	EnableDimensions extends boolean,
+	EnableDuration extends boolean,
+	EnableBoxes extends boolean,
+	EnableFps extends boolean,
+>(
+	src: string,
+	options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps>,
+	readerInterface?: ReaderInterface,
+) => Promise<
+	Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps>
+>;

package/src/parse-media.ts

@@ -0,0 +1,57 @@
+import {getArrayBufferIterator} from './buffer-iterator';
+import {webReader} from './from-web';
+import {getDimensions} from './get-dimensions';
+import {getDuration} from './get-duration';
+import {getFps} from './get-fps';
+import {hasAllInfo} from './has-all-info';
+import type {Metadata, ParseMedia} from './options';
+import {parseVideo} from './parse-video';
+
+export const parseMedia: ParseMedia = async (
+	src,
+	options,
+	readerInterface = webReader,
+) => {
+	const reader = await readerInterface.read(src, null);
+
+	const returnValue = {} as Metadata<true, true, true, true>;
+
+	const iterator = getArrayBufferIterator(new Uint8Array([]));
+	let parseResult = parseVideo(iterator);
+
+	while (parseResult.status === 'incomplete') {
+		const result = await reader.read();
+		if (result.done) {
+			break;
+		}
+
+		iterator.addData(result.value);
+		parseResult = parseResult.continueParsing();
+
+		if (hasAllInfo(options, parseResult)) {
+			if (!reader.closed) {
+				reader.cancel(new Error('has all information'));
+			}
+
+			break;
+		}
+	}
+
+	if (options.dimensions) {
+		returnValue.dimensions = getDimensions(parseResult.segments);
+	}
+
+	if (options.durationInSeconds) {
+		returnValue.durationInSeconds = getDuration(parseResult.segments);
+	}
+
+	if (options.fps) {
+		returnValue.fps = getFps(parseResult.segments);
+	}
+
+	if (options.boxes) {
+		returnValue.boxes = parseResult.segments;
+	}
+
+	return returnValue;
+};

package/src/parse-result.ts

@@ -0,0 +1,44 @@
+import type {BaseBox} from './boxes/iso-base-media/base-type';
+import type {FtypBox} from './boxes/iso-base-media/ftyp';
+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';
+import type {MebxBox} from './boxes/iso-base-media/stsd/mebx';
+import type {StsdBox} from './boxes/iso-base-media/stsd/stsd';
+import type {SttsBox} from './boxes/iso-base-media/stts/stts';
+import type {TkhdBox} from './boxes/iso-base-media/tkhd';
+import type {TrakBox} from './boxes/iso-base-media/trak/trak';
+import type {MatroskaSegment} from './boxes/webm/segments';
+
+interface RegularBox extends BaseBox {
+	boxType: string;
+	boxSize: number;
+	children: AnySegment[];
+	offset: number;
+	type: 'regular-box';
+}
+
+export type IsoBaseMediaBox =
+	| RegularBox
+	| FtypBox
+	| MvhdBox
+	| TkhdBox
+	| StsdBox
+	| MebxBox
+	| KeysBox
+	| MoovBox
+	| TrakBox
+	| SttsBox;
+
+export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
+
+export type ParseResult =
+	| {
+			status: 'done';
+			segments: AnySegment[];
+	  }
+	| {
+			status: 'incomplete';
+			segments: AnySegment[];
+			continueParsing: () => ParseResult;
+	  };

package/src/parse-video.ts

@@ -0,0 +1,41 @@
+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';
+
+export type BoxAndNext =
+	| {
+			type: 'complete';
+			box: IsoBaseMediaBox;
+			size: number;
+	  }
+	| {
+			type: 'incomplete';
+	  };
+
+export const parseVideo = (iterator: BufferIterator): ParseResult => {
+	if (iterator.bytesRemaining() === 0) {
+		return {
+			status: 'incomplete',
+			segments: [],
+			continueParsing: () => {
+				return parseVideo(iterator);
+			},
+		};
+	}
+
+	if (iterator.isIsoBaseMedia()) {
+		return parseBoxes({
+			iterator,
+			maxBytes: Infinity,
+			allowIncompleteBoxes: true,
+			initialBoxes: [],
+		});
+	}
+
+	if (iterator.isWebm()) {
+		return parseWebm(iterator);
+	}
+
+	throw new Error('Unknown video format');
+};

package/src/reader.ts

@@ -0,0 +1,10 @@
+type ReadContent = (
+	src: string,
+	range: [number, number] | null,
+) => Promise<ReadableStreamDefaultReader<Uint8Array>>;
+type GetLength = (src: string) => Promise<number>;
+
+export type ReaderInterface = {
+	read: ReadContent;
+	getLength: GetLength;
+};

package/src/test/duration.test.ts

@@ -0,0 +1,34 @@
+import {RenderInternals} from '@remotion/renderer';
+import {expect, test} from 'bun:test';
+import {nodeReader} from '../from-node';
+import {parseMedia} from '../parse-media';
+
+test('Should get duration of video', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.framer24fps,
+		{
+			durationInSeconds: true,
+			dimensions: true,
+		},
+		nodeReader,
+	);
+
+	expect(parsed.durationInSeconds).toBe(4.167);
+	expect(parsed.dimensions).toEqual({width: 1080, height: 1080});
+});
+
+test('Should get duration of HEVC video', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.iphonehevc,
+		{durationInSeconds: true, dimensions: true, fps: true},
+		nodeReader,
+	);
+
+	expect(parsed.durationInSeconds).toBe(3.4);
+	// TODO: Should apply rotation matrix to get the correct dimensions
+	expect(parsed.dimensions).toEqual({
+		width: 1920,
+		height: 1080,
+	});
+	expect(parsed.fps).toEqual(30);
+});

package/src/test/keys.test.ts

@@ -0,0 +1,47 @@
+import {expect, test} from 'bun:test';
+import {parseKeys} from '../boxes/iso-base-media/stsd/keys';
+
+test('Should parse keyd box', () => {
+	const buffer = Uint8Array.from([
+		0, 0, 2, 60, 107, 101, 121, 115, 0, 0, 2, 52, 0, 0, 0, 1, 0, 0, 0, 47, 107,
+		101, 121, 100, 109, 100, 116, 97, 99, 111, 109, 46, 97, 112, 112, 108, 101,
+		46, 113, 117, 105, 99, 107, 116, 105, 109, 101, 46, 108, 105, 118, 101, 45,
+		112, 104, 111, 116, 111, 45, 105, 110, 102, 111, 0, 0, 0, 67, 100, 116, 121,
+		112, 0, 0, 0, 1, 99, 111, 109, 46, 97, 112, 112, 108, 101, 46, 113, 117,
+		105, 99, 107, 116, 105, 109, 101, 46, 99, 111, 109, 46, 97, 112, 112, 108,
+		101, 46, 113, 117, 105, 99, 107, 116, 105, 109, 101, 46, 108, 105, 118, 101,
+		45, 112, 104, 111, 116, 111, 45, 105, 110, 102, 111, 0, 0, 0, 20, 115, 100,
+		112, 100, 0, 0, 0, 12, 115, 100, 112, 105, 0, 0, 0, 0, 0, 0, 1, 142, 115,
+		101, 116, 117, 0, 0, 1, 118, 99, 102, 103, 118, 98, 112, 108, 105, 115, 116,
+		48, 48, 211, 1, 2, 3, 4, 5, 12, 95, 16, 33, 76, 105, 118, 101, 80, 104, 111,
+		116, 111, 77, 101, 116, 97, 100, 97, 116, 97, 83, 101, 116, 117, 112, 68,
+		97, 116, 97, 86, 101, 114, 115, 105, 111, 110, 93, 83, 121, 115, 116, 101,
+		109, 86, 101, 114, 115, 105, 111, 110, 95, 16, 17, 70, 114, 97, 109, 101,
+		119, 111, 114, 107, 86, 101, 114, 115, 105, 111, 110, 115, 16, 1, 211, 6, 7,
+		8, 9, 10, 11, 95, 16, 19, 80, 114, 111, 100, 117, 99, 116, 66, 117, 105,
+		108, 100, 86, 101, 114, 115, 105, 111, 110, 91, 80, 114, 111, 100, 117, 99,
+		116, 78, 97, 109, 101, 94, 80, 114, 111, 100, 117, 99, 116, 86, 101, 114,
+		115, 105, 111, 110, 88, 50, 49, 70, 53, 48, 52, 56, 102, 89, 105, 80, 104,
+		111, 110, 101, 32, 79, 83, 84, 49, 55, 46, 53, 213, 13, 14, 15, 16, 17, 18,
+		19, 20, 21, 22, 94, 72, 49, 51, 73, 83, 80, 83, 101, 114, 118, 105, 99, 101,
+		115, 90, 67, 111, 114, 101, 77, 111, 116, 105, 111, 110, 93, 67, 77, 67, 97,
+		112, 116, 117, 114, 101, 67, 111, 114, 101, 94, 72, 49, 48, 73, 83, 80, 83,
+		101, 114, 118, 105, 99, 101, 115, 89, 67, 111, 114, 101, 77, 101, 100, 105,
+		97, 85, 56, 46, 53, 48, 50, 94, 50, 56, 57, 48, 46, 49, 54, 46, 49, 51, 46,
+		48, 46, 49, 87, 52, 55, 55, 46, 50, 46, 49, 86, 50, 48, 46, 53, 48, 48, 88,
+		51, 49, 49, 48, 46, 52, 46, 49, 0, 8, 0, 15, 0, 51, 0, 65, 0, 85, 0, 87, 0,
+		94, 0, 116, 0, 128, 0, 143, 0, 152, 0, 162, 0, 167, 0, 178, 0, 193, 0, 204,
+		0, 218, 0, 233, 0, 243, 0, 249, 1, 8, 1, 16, 1, 23, 0, 0, 0, 0, 0, 0, 2, 1,
+		0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 32, 0,
+		0, 0, 16, 100, 105, 109, 115, 0, 0, 7, 128, 0, 0, 4, 56, 0, 0, 0, 24, 99,
+		116, 112, 115, 0, 0, 0, 16, 100, 116, 121, 112, 0, 0, 0, 0, 0, 0, 0, 0,
+	]);
+
+	const data = parseKeys(buffer, 0);
+
+	expect(data).toEqual({
+		type: 'keys-box',
+		boxSize: 572,
+		offset: 0,
+	});
+});

package/src/test/matroska.test.ts

@@ -0,0 +1,163 @@
+import {RenderInternals} from '@remotion/renderer';
+import {expect, test} from 'bun:test';
+import {nodeReader} from '../from-node';
+import {parseMedia} from '../parse-media';
+
+test('Should get duration of AV1 video', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.av1,
+		{
+			durationInSeconds: true,
+			boxes: true,
+			dimensions: true,
+			fps: true,
+		},
+		nodeReader,
+	);
+
+	expect(parsed.durationInSeconds).toBe(1);
+	expect(parsed.fps).toBe(null);
+	expect(parsed.dimensions).toEqual({
+		width: 1920,
+		height: 1080,
+	});
+	expect(parsed.boxes).toEqual([
+		{
+			type: 'main-segment',
+			children: [
+				{
+					type: 'seek-head-segment',
+					length: 59,
+					children: [
+						{
+							type: 'seek-segment',
+							seekId: '0x1549a966',
+							child: {
+								type: 'seek-position-segment',
+								seekPosition: 161,
+							},
+						},
+						{
+							type: 'seek-segment',
+							seekId: '0x1654ae6b',
+							child: {
+								type: 'seek-position-segment',
+								seekPosition: 214,
+							},
+						},
+						{
+							type: 'seek-segment',
+							seekId: '0x1254c367',
+							child: {
+								type: 'seek-position-segment',
+								seekPosition: 322,
+							},
+						},
+						{
+							type: 'seek-segment',
+							seekId: '0x1c53bb6b',
+							child: {
+								type: 'seek-position-segment',
+								seekPosition: 347329,
+							},
+						},
+					],
+				},
+				{
+					type: 'void-segment',
+					length: 88,
+				},
+				{
+					type: 'info-segment',
+					length: 48,
+					children: [
+						{
+							type: 'timestamp-scale-segment',
+							timestampScale: 1000000,
+						},
+						{
+							type: 'muxing-app-segment',
+							value: 'Lavf60.3.100',
+						},
+						{
+							type: 'writing-app-segment',
+							value: 'Lavf60.3.100',
+						},
+						{
+							type: 'duration-segment',
+							duration: 1000,
+						},
+					],
+				},
+				{
+					type: 'tracks-segment',
+					children: [
+						{
+							type: 'track-entry-segment',
+							children: [
+								{
+									type: 'track-number-segment',
+									trackNumber: 1,
+								},
+								{
+									type: 'track-uid-segment',
+									trackUid: 'ab2171012bb9020a',
+								},
+								{
+									type: 'flag-lacing-segment',
+									lacing: false,
+								},
+								{
+									type: 'language-segment',
+									language: 'und',
+								},
+								{
+									type: 'codec-segment',
+									codec: 'V_AV1',
+								},
+								{
+									type: 'track-type-segment',
+									trackType: 1,
+								},
+								{
+									type: 'default-duration-segment',
+									defaultDuration: 40000000,
+								},
+								{
+									type: 'video-segment',
+									children: [
+										{
+											type: 'width-segment',
+											width: 1920,
+										},
+										{
+											height: 1080,
+											type: 'height-segment',
+										},
+										{
+											type: 'color-segment',
+										},
+									],
+								},
+								{
+									id: '0x0163a294',
+									type: 'unknown-segment',
+								},
+							],
+						},
+						{
+							id: '0x0c000a0e',
+							type: 'unknown-segment',
+						},
+					],
+				},
+				{
+					id: '0x',
+					type: 'unknown-segment',
+				},
+			],
+		},
+	]);
+
+	expect(parsed.durationInSeconds).toBe(1);
+});

package/src/test/mvhd.test.ts

@@ -0,0 +1,89 @@
+import {expect, test} from 'bun:test';
+import {parseMvhd} from '../boxes/iso-base-media/mvhd';
+import {getArrayBufferIterator} from '../buffer-iterator';
+
+test('Should be able to parse a MVHD box correctly', () => {
+	const buffer = Uint8Array.from([
+		// size, 32 bit
+		0, 0, 0, 108,
+		// mvhd atom, 32 bit
+		109, 118, 104, 100,
+		// version, 8 unsigned bit
+		0,
+		// flags, 24 bit
+		0, 0, 0,
+		// creation time, 32 bit
+		0, 0, 0, 0,
+		// modification time, 32 bit
+		0, 0, 0, 0,
+		// time scale
+		0, 0, 3, 232,
+		// duration
+		0, 0, 16, 71,
+		// rate
+		0, 1, 0, 0,
+		// volume
+		1, 0,
+		// reserved 16 bit
+		0, 0,
+		// reserved 32 bit [0]
+		0, 0, 0, 0,
+		// reserved 32 bit [1]
+		0, 0, 0, 0,
+		// matrix [0]
+		0, 1, 0, 0,
+		// matrix [1]
+		0, 0, 0, 0,
+		// matrix [2]
+		0, 0, 0, 0,
+		// matrix [3]
+		0, 0, 0, 0,
+		// matrix [4]
+		0, 1, 0, 0,
+		// matrix [5]
+		0, 0, 0, 0,
+		// matrix [6]
+		0, 0, 0, 0,
+		// matrix [7]
+		0, 0, 0, 0,
+		// matrix [8]
+		64, 0, 0, 0,
+		// predefined [0]
+		0, 0, 0, 0,
+		// predefined [1]
+		0, 0, 0, 0,
+		// predefined [2]
+		0, 0, 0, 0,
+		// predefined [3]
+		0, 0, 0, 0,
+		// predefined [4]
+		0, 0, 0, 0,
+		// predefined [5]
+		0, 0, 0, 0,
+		// next track id
+		0, 0, 0, 2,
+	]);
+
+	const iterator = getArrayBufferIterator(buffer);
+	iterator.discard(8);
+
+	const mvhd = parseMvhd({
+		offset: 0,
+		size: 108,
+		iterator,
+	});
+	expect(mvhd).toEqual({
+		creationTime: null,
+		modificationTime: null,
+		timeScale: 1000,
+		durationInUnits: 4167,
+		durationInSeconds: 4.167,
+		rate: 1,
+		volume: 1,
+		matrix: [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824],
+		nextTrackId: 2,
+		type: 'mvhd-box',
+		boxSize: 108,
+		offset: 0,
+	});
+});

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

@@ -0,0 +1,38 @@
+import {expect, test} from 'bun:test';
+import {parseStts} from '../boxes/iso-base-media/stts/stts';
+import {getArrayBufferIterator} from '../buffer-iterator';
+
+const buffer = new Uint8Array([
+	// mock header
+	0, 0, 0, 0, 0, 0, 0, 0,
+	// actual box
+	0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 13, 0, 0, 0, 20, 0, 0, 0, 1, 0, 0, 0, 21, 0,
+	0, 0, 107, 0, 0, 0, 20, 0, 0, 11, 216, 99, 116, 116, 115,
+]);
+
+test('Should parse stts box', () => {
+	const iterator = getArrayBufferIterator(buffer);
+	iterator.counter.increment(8);
+	const result = parseStts({
+		data: iterator,
+		size: buffer.length - 8,
+		fileOffset: 0,
+	});
+	expect(result).toEqual({
+		type: 'stts-box',
+		sampleDistribution: [
+			{
+				sampleCount: 269,
+				sampleDelta: 20,
+			},
+			{
+				sampleCount: 1,
+				sampleDelta: 21,
+			},
+			{
+				sampleCount: 107,
+				sampleDelta: 20,
+			},
+		],
+	});
+});