@remotion/media-parser 4.0.209 → 4.0.210

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

@@ -1,59 +0,0 @@
-import {expect, test} from 'bun:test';
-import {parseMedia} from '../parse-media';
-
-test('Should stream', async () => {
-	const result = await parseMedia({
-		src: 'https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/1080/Big_Buck_Bunny_1080_10s_1MB.mp4',
-		fields: {
-			durationInSeconds: true,
-			fps: true,
-			dimensions: true,
-			videoCodec: true,
-		},
-	});
-	expect(result.durationInSeconds).toBe(10);
-	expect(result.fps).toBe(60);
-	expect(result.dimensions).toEqual({
-		width: 1920,
-		height: 1080,
-	});
-	expect(result.videoCodec).toEqual('h264');
-});
-
-test(
-	'Should stream from Wikipedia',
-	async () => {
-		const result = await parseMedia({
-			src: 'https://upload.wikimedia.org/wikipedia/commons/transcoded/c/c0/Big_Buck_Bunny_4K.webm/Big_Buck_Bunny_4K.webm.720p.vp9.webm',
-			fields: {
-				durationInSeconds: true,
-				fps: true,
-				dimensions: true,
-				videoCodec: true,
-			},
-		});
-		expect(result.durationInSeconds).toBe(634.571);
-		// TODO: Not yet implemented
-		expect(result.fps).toBe(null);
-		expect(result.dimensions).toEqual({
-			width: 1280,
-			height: 720,
-		});
-		expect(result.videoCodec).toEqual('vp9');
-	},
-	{timeout: 10000},
-);
-
-test('Should handle redirect', async () => {
-	const result = await parseMedia({
-		src: 'https://remotion.dev/bbb.mp4',
-		fields: {
-			fps: true,
-			videoCodec: true,
-			durationInSeconds: true,
-		},
-	});
-	expect(result.videoCodec).toEqual('h264');
-	expect(result.fps).toEqual(24);
-	expect(result.durationInSeconds).toEqual(596.4733333333334);
-});

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

@@ -1,181 +0,0 @@
-import {RenderInternals} from '@remotion/renderer';
-import {expect, test} from 'bun:test';
-import {getSamplePositionsFromTrack} from '../boxes/iso-base-media/get-sample-positions-from-track';
-import type {TrakBox} from '../boxes/iso-base-media/trak/trak';
-import {parseMedia} from '../parse-media';
-import {nodeReader} from '../readers/from-node';
-
-test('Stream samples', async () => {
-	const {videoTracks, audioTracks} = await parseMedia({
-		src: RenderInternals.exampleVideos.mp4withmp3,
-		fields: {
-			tracks: true,
-			videoCodec: true,
-			audioCodec: true,
-		},
-		reader: nodeReader,
-	});
-
-	const description = new Uint8Array([
-		1, 100, 0, 32, 255, 225, 0, 32, 103, 100, 0, 32, 172, 217, 64, 68, 2, 39,
-		150, 92, 5, 168, 16, 16, 45, 40, 0, 0, 3, 0, 8, 0, 0, 3, 1, 224, 120, 193,
-		140, 176, 1, 0, 6, 104, 235, 224, 140, 178, 44, 253, 248, 248, 0,
-	]);
-
-	const {trakBox, ...trackInfo} = videoTracks[0];
-	expect(trackInfo).toEqual({
-		type: 'video',
-		trackId: 1,
-		description,
-		timescale: 15360,
-		codec: 'avc1.640020',
-		sampleAspectRatio: {
-			numerator: 1,
-			denominator: 1,
-		},
-		width: 1080,
-		height: 1080,
-		codedWidth: 1080,
-		codedHeight: 1080,
-		displayAspectHeight: 1080,
-		displayAspectWidth: 1080,
-		rotation: 0,
-	});
-
-	expect(getSamplePositionsFromTrack(trakBox as TrakBox, null));
-
-	const [firstAudioTrack] = audioTracks;
-	const {trakBox: trakBox2, ...audioTrack} = firstAudioTrack;
-
-	expect(audioTrack).toEqual({
-		type: 'audio',
-		trackId: 2,
-		timescale: 48000,
-		numberOfChannels: 2,
-		codec: 'mp3',
-		sampleRate: 48000,
-		description: undefined,
-	});
-	expect(getSamplePositionsFromTrack(trakBox2 as TrakBox, null)).toEqual([
-		{
-			offset: 6908,
-			size: 960,
-			isKeyframe: true,
-			dts: 0,
-			duration: 1152,
-			cts: 0,
-		},
-		{
-			offset: 8566,
-			size: 960,
-			isKeyframe: true,
-			dts: 1152,
-			duration: 1152,
-			cts: 1152,
-		},
-		{
-			offset: 9526,
-			size: 960,
-			isKeyframe: true,
-			dts: 2304,
-			duration: 1152,
-			cts: 2304,
-		},
-		{
-			offset: 11081,
-			size: 960,
-			isKeyframe: true,
-			dts: 3456,
-			duration: 1152,
-			cts: 3456,
-		},
-		{
-			offset: 12589,
-			size: 960,
-			isKeyframe: true,
-			dts: 4608,
-			duration: 1152,
-			cts: 4608,
-		},
-		{
-			offset: 13549,
-			size: 960,
-			isKeyframe: true,
-			dts: 5760,
-			duration: 1152,
-			cts: 5760,
-		},
-		{
-			offset: 15120,
-			size: 960,
-			isKeyframe: true,
-			dts: 6912,
-			duration: 1152,
-			cts: 6912,
-		},
-		{
-			offset: 16781,
-			size: 960,
-			isKeyframe: true,
-			dts: 8064,
-			duration: 1152,
-			cts: 8064,
-		},
-		{
-			offset: 18276,
-			size: 960,
-			isKeyframe: true,
-			dts: 9216,
-			duration: 1152,
-			cts: 9216,
-		},
-		{
-			offset: 19236,
-			size: 960,
-			isKeyframe: true,
-			dts: 10368,
-			duration: 1152,
-			cts: 10368,
-		},
-		{
-			offset: 20972,
-			size: 960,
-			isKeyframe: true,
-			dts: 11520,
-			duration: 1152,
-			cts: 11520,
-		},
-		{
-			offset: 22518,
-			size: 960,
-			isKeyframe: true,
-			dts: 12672,
-			duration: 1152,
-			cts: 12672,
-		},
-		{
-			offset: 23478,
-			size: 960,
-			isKeyframe: true,
-			dts: 13824,
-			duration: 1152,
-			cts: 13824,
-		},
-		{
-			offset: 24438,
-			size: 960,
-			isKeyframe: true,
-			dts: 14976,
-			duration: 1152,
-			cts: 14976,
-		},
-		{
-			offset: 25398,
-			size: 960,
-			isKeyframe: true,
-			dts: 16128,
-			duration: 1152,
-			cts: 16128,
-		},
-	]);
-});

package/src/test/stsd.test.ts

@@ -1,265 +0,0 @@
-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';
-import {makeParserState} from '../parser-state';
-
-test('Should be able to parse a STSD audio box correctly', async () => {
-	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,
-		// revision 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, null);
-	iterator.discard(8);
-
-	const parsed = await parseStsd({
-		iterator,
-		offset: 0,
-		size: 159,
-		options: {
-			canSkipVideoData: true,
-			onAudioTrack: null,
-			onVideoTrack: null,
-			parserState: makeParserState({
-				hasAudioCallbacks: false,
-				hasVideoCallbacks: false,
-				signal: undefined,
-			}),
-			nullifySamples: false,
-		},
-	});
-
-	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: -2,
-				packetSize: 0,
-				samplesPerPacket: 1024,
-				bitsPerSample: 2,
-				bytesPerFrame: 2,
-				bytesPerPacket: 1,
-				sampleRate: 44100,
-				children: [
-					{
-						boxSize: 91,
-						boxType: 'wave',
-						children: [
-							{
-								boxSize: 12,
-								boxType: 'frma',
-								children: [],
-								offset: 76,
-								type: 'regular-box',
-							},
-							{
-								boxSize: 12,
-								boxType: 'mp4a',
-								children: [],
-								offset: 88,
-								type: 'regular-box',
-							},
-							{
-								descriptors: [
-									{
-										objectTypeIndication: 'aac',
-										type: 'decoder-config-descriptor',
-										asNumber: 64,
-										avgBitrate: 0,
-										bufferSizeDB: 6144,
-										maxBitrate: 192000,
-										streamType: 5,
-										decoderSpecificConfigs: [
-											{
-												audioObjectType: 2,
-												channelConfiguration: 2,
-												samplingFrequencyIndex: 4,
-												type: 'audio-specific-config',
-												asBytes: new Uint8Array([18, 16]),
-											},
-											{
-												type: 'unknown-decoder-specific-config',
-											},
-										],
-										upStream: 0,
-									},
-								],
-								esId: 0,
-								sizeOfInstance: 34,
-								tag: 3,
-								type: 'esds-box',
-								version: 0,
-							},
-							{
-								boxSize: 8,
-								boxType: '\u0000\u0000\u0000\u0000',
-								children: [],
-								offset: 151,
-								type: 'regular-box',
-							},
-						],
-						offset: 68,
-						type: 'regular-box',
-					},
-				],
-			},
-		],
-	});
-});
-
-test('Should be able to parse a STSD video box correctly', async () => {
-	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 = await processSample({
-		iterator: getArrayBufferIterator(buffer, null),
-		options: {
-			canSkipVideoData: true,
-			onAudioTrack: null,
-			onVideoTrack: null,
-			parserState: makeParserState({
-				hasAudioCallbacks: false,
-				hasVideoCallbacks: false,
-				signal: undefined,
-			}),
-			nullifySamples: false,
-		},
-	});
-	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,
-		descriptors: [
-			{
-				description: new Uint8Array([
-					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,
-				]),
-				type: 'avcc-box',
-				configurationString: '640020',
-			},
-			{
-				boxSize: 16,
-				offset: 142,
-				type: 'pasp-box',
-				hSpacing: 1,
-				vSpacing: 1,
-			},
-		],
-	});
-});

package/src/test/tkhd.test.ts

@@ -1,87 +0,0 @@
-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, null);
-	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: [1, 0, 0, 0, 1, 0, 0, 0, 1],
-		width: 0,
-		height: 0,
-		rotation: 0,
-		unrotatedWidth: 0,
-		unrotatedHeight: 0,
-	});
-});