@remotion/media-parser 4.0.191 → 4.0.193

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

@@ -9,17 +9,27 @@ test('Should stream ISO base media', async () => {
 		{
 			durationInSeconds: true,
 			fps: true,
+			videoCodec: true,
+			audioCodec: true,
 		},
 		nodeReader,
 	);
 	expect(result.durationInSeconds).toBe(12.568333333333333);
 	expect(result.fps).toBe(29.99602174777881);
+	expect(result.videoCodec).toBe('h265');
+	expect(result.audioCodec).toBe('aac');
 });
 
 test('Should stream WebM with no duration', async () => {
 	const result = await parseMedia(
 		RenderInternals.exampleVideos.nofps,
-		{fps: true, durationInSeconds: true, dimensions: true},
+		{
+			fps: true,
+			durationInSeconds: true,
+			dimensions: true,
+			videoCodec: true,
+			audioCodec: true,
+		},
 		nodeReader,
 	);
 	expect(result.durationInSeconds).toBe(6.57);
@@ -28,6 +38,8 @@ test('Should stream WebM with no duration', async () => {
 		height: 690,
 	});
 	expect(result.fps).toBeDefined();
+	expect(result.videoCodec).toBe('vp8');
+	expect(result.audioCodec).toBe(null);
 });
 
 test('Should stream AV1 with no duration', async () => {
@@ -37,6 +49,8 @@ test('Should stream AV1 with no duration', async () => {
 			durationInSeconds: true,
 			dimensions: true,
 			fps: true,
+			videoCodec: true,
+			audioCodec: true,
 		},
 		nodeReader,
 	);
@@ -47,6 +61,8 @@ test('Should stream AV1 with no duration', async () => {
 		width: 1920,
 		height: 1080,
 	});
+	expect(parsed.videoCodec).toBe('av1');
+	expect(parsed.audioCodec).toBe(null);
 });
 
 test('Should stream corrupted video', async () => {
@@ -56,16 +72,20 @@ test('Should stream corrupted video', async () => {
 			durationInSeconds: true,
 			dimensions: true,
 			fps: true,
+			videoCodec: true,
+			audioCodec: true,
 		},
 		nodeReader,
 	);
 
 	expect(parsed.durationInSeconds).toBe(30.03);
-	expect(parsed.fps).toBe(23.976023976023978);
+	expect(parsed.fps).toBe(23.976023976023974);
 	expect(parsed.dimensions).toEqual({
 		width: 1920,
 		height: 1080,
 	});
+	expect(parsed.videoCodec).toBe('h264');
+	expect(parsed.audioCodec).toBe('aac');
 });
 
 test('Should stream screen recording video', async () => {
@@ -75,17 +95,22 @@ test('Should stream screen recording video', async () => {
 			durationInSeconds: true,
 			dimensions: true,
 			fps: true,
+			videoCodec: true,
+			audioCodec: true,
 		},
 		nodeReader,
 	);
 
 	expect(parsed.durationInSeconds).toBe(5.866666666666666);
-	expect(parsed.fps).toBe(58.98305084745763);
+	expect(parsed.fps).toBe(58.983050847457626);
 	expect(parsed.dimensions).toEqual({
 		height: 1766,
 		width: 2874,
 	});
+	expect(parsed.videoCodec).toBe('h264');
+	expect(parsed.audioCodec).toBe(null);
 });
+
 test('Should stream ProRes video', async () => {
 	const parsed = await parseMedia(
 		RenderInternals.exampleVideos.prores,
@@ -93,13 +118,76 @@ test('Should stream ProRes video', async () => {
 			fps: true,
 			dimensions: true,
 			durationInSeconds: true,
+			videoCodec: true,
+			audioCodec: true,
 		},
 		nodeReader,
 	);
 
-	// TODO: FPS should be 60
-	expect(parsed.fps).toBe(3.90625);
+	expect(parsed.fps).toBe(60);
 	expect(parsed.dimensions.width).toBe(1920);
 	expect(parsed.dimensions.height).toBe(1080);
 	expect(parsed.durationInSeconds).toBe(0.034);
+	expect(parsed.videoCodec).toBe('prores');
+	expect(parsed.audioCodec).toBe('aiff');
+});
+
+test('Should stream variable fps video', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.variablefps,
+		{
+			fps: true,
+			dimensions: true,
+			durationInSeconds: true,
+			videoCodec: true,
+			audioCodec: true,
+		},
+		nodeReader,
+	);
+
+	expect(parsed.dimensions.width).toBe(1280);
+	expect(parsed.dimensions.height).toBe(720);
+	expect(parsed.durationInSeconds).toBe(22.901);
+	expect(parsed.videoCodec).toBe('vp8');
+	expect(parsed.audioCodec).toBe('opus');
+});
+
+test('Should stream MKV video', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.matroskaPcm16,
+		{
+			fps: true,
+			dimensions: true,
+			durationInSeconds: true,
+			videoCodec: true,
+			audioCodec: true,
+		},
+		nodeReader,
+	);
+
+	expect(parsed.dimensions.width).toBe(1080);
+	expect(parsed.dimensions.height).toBe(1080);
+	expect(parsed.durationInSeconds).toBe(0.333);
+	expect(parsed.videoCodec).toBe('h264');
+	expect(parsed.audioCodec).toBe('pcm');
+});
+
+test('Should stream MP3 in MP4 video', async () => {
+	const parsed = await parseMedia(
+		RenderInternals.exampleVideos.mp4withmp3,
+		{
+			fps: true,
+			dimensions: true,
+			durationInSeconds: true,
+			videoCodec: true,
+			audioCodec: true,
+		},
+		nodeReader,
+	);
+
+	expect(parsed.dimensions.width).toBe(1080);
+	expect(parsed.dimensions.height).toBe(1080);
+	expect(parsed.durationInSeconds).toBe(0.337);
+	expect(parsed.videoCodec).toBe('h264');
+	expect(parsed.audioCodec).toBe('mp3');
 });

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

@@ -6,7 +6,48 @@ test('Should stream', async () => {
 		'https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/1080/Big_Buck_Bunny_1080_10s_1MB.mp4',
 		{
 			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(
+		'https://upload.wikimedia.org/wikipedia/commons/transcoded/c/c0/Big_Buck_Bunny_4K.webm/Big_Buck_Bunny_4K.webm.720p.vp9.webm',
+		{
+			boxes: true,
+			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');
+});
+
+test('Should handle redirect', async () => {
+	const result = await parseMedia('https://remotion.dev/bbb.mp4', {
+		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/stsd.test.ts

@@ -60,13 +60,60 @@ test('Should be able to parse a STSD audio box correctly', () => {
 				numberOfChannels: 2,
 				type: 'audio',
 				sampleSize: 16,
-				compressionId: 65534,
+				compressionId: -2,
 				packetSize: 0,
-				samplesPerPacket: 0,
-				bitsPerSample: 1,
-				bytesPerFrame: 0,
-				bytesPerPacket: 1024,
+				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',
+									},
+									{
+										type: 'sl-config-descriptor',
+									},
+								],
+								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',
+					},
+				],
 			},
 		],
 	});