@remotion/media-parser 4.0.191

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

@@ -0,0 +1,113 @@
+import {RenderInternals} from '@remotion/renderer';
+import {expect, test} from 'bun:test';
+import {nodeReader} from '../from-node';
+import {parseMedia} from '../parse-media';
+
+test('Parse Big Buck bunny', async () => {
+	const data = await parseMedia(
+		RenderInternals.exampleVideos.bigBuckBunny,
+		{
+			boxes: true,
+		},
+		nodeReader,
+	);
+	expect(data.boxes.slice(0, 2)).toEqual([
+		{
+			offset: 0,
+			boxSize: 32,
+			type: 'ftyp-box',
+			majorBrand: 'isom',
+			minorVersion: 512,
+			compatibleBrands: ['isom', 'iso2', 'avc1', 'mp41'],
+		},
+		{
+			offset: 32,
+			boxSize: 8,
+			boxType: 'free',
+			type: 'regular-box',
+			children: [],
+		},
+	]);
+});
+
+test('Parse an iPhone video', async () => {
+	const data = await parseMedia(
+		RenderInternals.exampleVideos.iphonevideo,
+		{durationInSeconds: true, dimensions: true},
+		nodeReader,
+	);
+
+	expect(data.durationInSeconds).toBe(12.568333333333333);
+	expect(data.dimensions).toEqual({
+		width: 3840,
+		height: 2160,
+	});
+});
+
+test('Parse framer', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.framerWithoutFileExtension,
+		{
+			boxes: true,
+		},
+		nodeReader,
+	);
+	expect(parsed.boxes.slice(0, 2)).toEqual([
+		{
+			offset: 0,
+			boxSize: 32,
+			compatibleBrands: ['isom', 'iso2', 'avc1', 'mp41'],
+			majorBrand: 'isom',
+			minorVersion: 512,
+			type: 'ftyp-box',
+		},
+		{
+			offset: 32,
+			boxSize: 8,
+			boxType: 'free',
+			type: 'regular-box',
+			children: [],
+		},
+	]);
+});
+
+test('Parse a full video', async () => {
+	const data = await parseMedia(
+		RenderInternals.exampleVideos.framer24fps,
+		{boxes: true},
+		nodeReader,
+	);
+	if (!data) throw new Error('No data');
+
+	const [first, second, third] = data.boxes;
+
+	expect(first).toEqual({
+		offset: 0,
+		boxSize: 32,
+		type: 'ftyp-box',
+		majorBrand: 'isom',
+		minorVersion: 512,
+		compatibleBrands: ['isom', 'iso2', 'avc1', 'mp41'],
+	});
+	expect(second).toEqual({
+		offset: 32,
+		boxType: 'free',
+		boxSize: 8,
+		type: 'regular-box',
+		children: [],
+	});
+	expect(third).toEqual({
+		offset: 40,
+		boxSize: 57014,
+		boxType: 'mdat',
+		children: [],
+		type: 'regular-box',
+	});
+});
+
+test('Should warn if missing node reader', () => {
+	const data = parseMedia(RenderInternals.exampleVideos.framer24fps, {
+		boxes: true,
+	});
+	expect(data).rejects.toThrow(/node/);
+});

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

@@ -0,0 +1,15 @@
+import {RenderInternals} from '@remotion/renderer';
+import {expect, test} from 'bun:test';
+import {nodeReader} from '../from-node';
+import {parseMedia} from '../parse-media';
+
+test('should be able to parse a WebM', async () => {
+	const webm = await parseMedia(
+		RenderInternals.exampleVideos.transparentWebm,
+		{
+			durationInSeconds: true,
+		},
+		nodeReader,
+	);
+	expect(webm.durationInSeconds).toBe(5);
+});

package/src/test/stream-local.test.ts

@@ -0,0 +1,105 @@
+import {RenderInternals} from '@remotion/renderer';
+import {expect, test} from 'bun:test';
+import {nodeReader} from '../from-node';
+import {parseMedia} from '../parse-media';
+
+test('Should stream ISO base media', async () => {
+	const result = await parseMedia(
+		RenderInternals.exampleVideos.iphonevideo,
+		{
+			durationInSeconds: true,
+			fps: true,
+		},
+		nodeReader,
+	);
+	expect(result.durationInSeconds).toBe(12.568333333333333);
+	expect(result.fps).toBe(29.99602174777881);
+});
+
+test('Should stream WebM with no duration', async () => {
+	const result = await parseMedia(
+		RenderInternals.exampleVideos.nofps,
+		{fps: true, durationInSeconds: true, dimensions: true},
+		nodeReader,
+	);
+	expect(result.durationInSeconds).toBe(6.57);
+	expect(result.dimensions).toEqual({
+		width: 1470,
+		height: 690,
+	});
+	expect(result.fps).toBeDefined();
+});
+
+test('Should stream AV1 with no duration', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.av1,
+		{
+			durationInSeconds: true,
+			dimensions: true,
+			fps: true,
+		},
+		nodeReader,
+	);
+
+	expect(parsed.durationInSeconds).toBe(1);
+	expect(parsed.fps).toBe(null);
+	expect(parsed.dimensions).toEqual({
+		width: 1920,
+		height: 1080,
+	});
+});
+
+test('Should stream corrupted video', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.corrupted,
+		{
+			durationInSeconds: true,
+			dimensions: true,
+			fps: true,
+		},
+		nodeReader,
+	);
+
+	expect(parsed.durationInSeconds).toBe(30.03);
+	expect(parsed.fps).toBe(23.976023976023978);
+	expect(parsed.dimensions).toEqual({
+		width: 1920,
+		height: 1080,
+	});
+});
+
+test('Should stream screen recording video', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.screenrecording,
+		{
+			durationInSeconds: true,
+			dimensions: true,
+			fps: true,
+		},
+		nodeReader,
+	);
+
+	expect(parsed.durationInSeconds).toBe(5.866666666666666);
+	expect(parsed.fps).toBe(58.98305084745763);
+	expect(parsed.dimensions).toEqual({
+		height: 1766,
+		width: 2874,
+	});
+});
+test('Should stream ProRes video', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.prores,
+		{
+			fps: true,
+			dimensions: true,
+			durationInSeconds: true,
+		},
+		nodeReader,
+	);
+
+	// TODO: FPS should be 60
+	expect(parsed.fps).toBe(3.90625);
+	expect(parsed.dimensions.width).toBe(1920);
+	expect(parsed.dimensions.height).toBe(1080);
+	expect(parsed.durationInSeconds).toBe(0.034);
+});

package/src/test/stream-remote.test.ts

@@ -0,0 +1,12 @@
+import {expect, test} from 'bun:test';
+import {parseMedia} from '../parse-media';
+
+test('Should stream', async () => {
+	const result = await parseMedia(
+		'https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/1080/Big_Buck_Bunny_1080_10s_1MB.mp4',
+		{
+			durationInSeconds: true,
+		},
+	);
+	expect(result.durationInSeconds).toBe(10);
+});

package/src/test/stsd.test.ts

@@ -0,0 +1,162 @@
+import {expect, test} from 'bun:test';
+import {processSample} from '../boxes/iso-base-media/stsd/samples';
+import {parseStsd} from '../boxes/iso-base-media/stsd/stsd';
+import {getArrayBufferIterator} from '../buffer-iterator';
+
+test('Should be able to parse a STSD audio box correctly', () => {
+	const buffer = Uint8Array.from([
+		// box size
+		0, 0, 0, 159,
+		// data format "stsd"
+		115, 116, 115, 100,
+		// reserved
+		0, 0, 0, 0, 0, 0,
+		// number of entries
+		0, 1,
+		// size
+		0, 0, 0, 143,
+		// "mp4a"
+		109, 112, 52, 97,
+		// reserved
+		0, 0, 0, 0, 0, 0,
+		// data reference index
+		0, 1,
+		// version
+		0, 1,
+		// revisioon level
+		0, 0, 0, 0, 0, 0,
+		// revision level
+		0, 2, 0, 16, 255, 254, 0, 0, 172, 68, 0, 0, 0, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0,
+		2, 0, 0, 0, 2, 0, 0, 0, 91, 119, 97, 118, 101, 0, 0, 0, 12, 102, 114, 109,
+		97, 109, 112, 52, 97, 0, 0, 0, 12, 109, 112, 52, 97, 0, 0, 0, 0, 0, 0, 0,
+		51, 101, 115, 100, 115, 0, 0, 0, 0, 3, 128, 128, 128, 34, 0, 0, 0, 4, 128,
+		128, 128, 20, 64, 20, 0, 24, 0, 0, 2, 238, 0, 0, 0, 0, 0, 5, 128, 128, 128,
+		2, 18, 16, 6, 128, 128, 128, 1, 2, 0, 0, 0, 8, 0, 0, 0, 0,
+	]);
+
+	const iterator = getArrayBufferIterator(buffer);
+	iterator.discard(8);
+
+	const parsed = parseStsd({
+		iterator,
+		offset: 0,
+		size: 159,
+	});
+
+	expect(parsed).toEqual({
+		offset: 0,
+		boxSize: 159,
+		type: 'stsd-box',
+		numberOfEntries: 1,
+		samples: [
+			{
+				size: 143,
+				offset: 16,
+				format: 'mp4a',
+				dataReferenceIndex: 1,
+				version: 1,
+				revisionLevel: 0,
+				vendor: [0, 0, 0, 0],
+				numberOfChannels: 2,
+				type: 'audio',
+				sampleSize: 16,
+				compressionId: 65534,
+				packetSize: 0,
+				samplesPerPacket: 0,
+				bitsPerSample: 1,
+				bytesPerFrame: 0,
+				bytesPerPacket: 1024,
+				sampleRate: 44100,
+			},
+		],
+	});
+});
+
+test('Should be able to parse a STSD video box correctly', () => {
+	const buffer = Uint8Array.from([
+		// box size
+		0, 0, 0, 158,
+		// data format "avc1"
+		97, 118, 99, 49,
+		// padding
+		0, 0, 0, 0, 0, 0,
+		// data reference index
+		0, 1,
+		// version
+		0, 0,
+		// revision level
+		0, 0,
+		// vendor
+		0, 0, 0, 0,
+		// temporal quality
+		0, 0, 0, 0,
+		// spatial quality
+		0, 0, 0, 0,
+		// width
+		4, 56,
+		// height
+		4, 56,
+		// horiz resolution
+		0, 72, 0, 0,
+		// vert resolution
+		0, 72, 0, 0,
+		// frame count
+		0, 0,
+		// compressor name
+		// 0
+		0, 0, 0, 1,
+		// 1
+		0, 0, 0, 0,
+		// 2
+		0, 0, 0, 0,
+		// 3
+		0, 0, 0, 0,
+		// 4
+		0, 0, 0, 0,
+		// 5
+		0, 0, 0, 0,
+		// 6
+		0, 0, 0, 0,
+		// 7
+		0, 0, 0, 0,
+		// 8
+		0, 0, 0, 0,
+		// depth
+		0, 24,
+		// color space
+		255, 255,
+		// avcC info (not parsed)
+		0, 0, 0, 56, 97, 118, 99, 67, 1, 100, 0, 32, 255, 225, 0, 27, 103, 100, 0,
+		32, 172, 217, 64, 68, 2, 39, 150, 92, 4, 64, 0, 0, 3, 0, 64, 0, 0, 12, 3,
+		198, 12, 101, 128, 1, 0, 6, 104, 235, 224, 140, 178, 44, 253, 248, 248, 0,
+		0, 0, 0, 16, 112, 97, 115, 112, 0, 0, 0, 1, 0, 0, 0, 1,
+	]);
+
+	const parsed = processSample({
+		iterator: getArrayBufferIterator(buffer),
+	});
+	expect(parsed.sample).toEqual({
+		size: 158,
+		format: 'avc1',
+		dataReferenceIndex: 1,
+		version: 0,
+		revisionLevel: 0,
+		vendor: [0, 0, 0, 0],
+		type: 'video',
+		temporalQuality: 0,
+		spacialQuality: 0,
+		width: 1080,
+		height: 1080,
+		horizontalResolutionPpi: 72,
+		verticalResolutionPpi: 72,
+		dataSize: 0,
+		frameCountPerSample: 1,
+		compressorName: [
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0,
+		],
+		offset: 0,
+		depth: 24,
+		colorTableId: -1,
+	});
+});

package/src/test/tkhd.test.ts

@@ -0,0 +1,84 @@
+import {expect, test} from 'bun:test';
+import {parseTkhd} from '../boxes/iso-base-media/tkhd';
+import {getArrayBufferIterator} from '../buffer-iterator';
+
+test('Should be able to parse a TKHD box', () => {
+	const buffer = Uint8Array.from([
+		// size, 32 bit
+		0, 0, 0, 92,
+		// mvhd atom, 32 bit
+		116, 107, 104, 100,
+		// version, 8 unsigned bit
+		0,
+		// flags, 24 bit
+		0, 0, 15,
+		// creation time, 32 bit
+		226, 94, 106, 178,
+		// modification time, 32 bit
+		226, 94, 106, 182,
+		// track id, 32 bit
+		0, 0, 0, 5,
+		// reserved, 32 bit
+		0, 0, 0, 0,
+		// duration, 32 bit
+		0, 0, 7, 248,
+		// reserved, 32 bit
+		0, 0, 0, 0,
+		// reserved, 32 bit
+		0, 0, 0, 0,
+		// layer, 16 bit
+		0, 0,
+		// alternate group, 16 bit
+		0, 0,
+		// volume, 16 bit
+		0, 0,
+		// reserved, 16 bit
+		0, 0,
+		// matrix[0], 32 bit
+		0, 1, 0, 0,
+		// matrix[1], 32 bit
+		0, 0, 0, 0,
+		// matrix[2], 32 bit
+		0, 0, 0, 0,
+		// matrix[3], 32 bit
+		0, 0, 0, 0,
+		// matrix[4], 32 bit
+		0, 1, 0, 0,
+		// matrix[5], 32 bit
+		0, 0, 0, 0,
+		// matrix[6], 32 bit
+		0, 0, 0, 0,
+		// matrix[7], 32 bit
+		0, 0, 0, 0,
+		// matrix[8], 32 bit
+		64, 0, 0, 0,
+		// width, 32 bit
+		0, 0, 0, 0,
+		// height, 32 bit
+		0, 0, 0, 0,
+	]);
+
+	const iterator = getArrayBufferIterator(buffer);
+	iterator.discard(8);
+	const mvhd = parseTkhd({
+		iterator,
+		offset: 0,
+		size: 92,
+	});
+	expect(mvhd).toEqual({
+		type: 'tkhd-box',
+		boxSize: 92,
+		offset: 0,
+		alternateGroup: 0,
+		creationTime: 1714993714000,
+		duration: 2040,
+		modificationTime: 1714993718000,
+		trackId: 5,
+		version: 0,
+		layer: 0,
+		volume: 0,
+		matrix: [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824],
+		width: 0,
+		height: 0,
+	});
+});

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+	"extends": "../tsconfig.settings.json",
+	"compilerOptions": {
+		"rootDir": "src",
+		"outDir": "./dist",
+		"skipLibCheck": true
+	},
+	"references": [],
+	"include": ["src"]
+}