@remotion/media-parser 4.0.194 → 4.0.196

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

@@ -2,15 +2,15 @@ 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',
-		{
+	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({
@@ -21,16 +21,15 @@ test('Should stream', async () => {
 });
 
 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,
+	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);
@@ -42,10 +41,13 @@ test('Should stream from Wikipedia', async () => {
 });
 
 test('Should handle redirect', async () => {
-	const result = await parseMedia('https://remotion.dev/bbb.mp4', {
-		fps: true,
-		videoCodec: true,
-		durationInSeconds: true,
+	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);

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

@@ -0,0 +1,259 @@
+import {RenderInternals} from '@remotion/renderer';
+import {expect, test} from 'bun:test';
+import {nodeReader} from '../from-node';
+import {parseMedia} from '../parse-media';
+
+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,
+	]);
+
+	expect(videoTracks).toEqual([
+		{
+			type: 'video',
+			trackId: 1,
+			samplePositions: [
+				{
+					offset: 1637,
+					size: 4834,
+					isKeyframe: true,
+					dts: 0,
+					duration: 512,
+					cts: 1024,
+				},
+				{
+					offset: 6471,
+					size: 437,
+					isKeyframe: false,
+					dts: 512,
+					duration: 512,
+					cts: 1536,
+				},
+				{
+					offset: 7868,
+					size: 698,
+					isKeyframe: false,
+					dts: 1024,
+					duration: 512,
+					cts: 2048,
+				},
+				{
+					offset: 10486,
+					size: 595,
+					isKeyframe: false,
+					dts: 1536,
+					duration: 512,
+					cts: 2560,
+				},
+				{
+					offset: 12041,
+					size: 548,
+					isKeyframe: false,
+					dts: 2048,
+					duration: 512,
+					cts: 3072,
+				},
+				{
+					offset: 14509,
+					size: 611,
+					isKeyframe: false,
+					dts: 2560,
+					duration: 512,
+					cts: 3584,
+				},
+				{
+					offset: 16080,
+					size: 701,
+					isKeyframe: false,
+					dts: 3072,
+					duration: 512,
+					cts: 4096,
+				},
+				{
+					offset: 17741,
+					size: 535,
+					isKeyframe: false,
+					dts: 3584,
+					duration: 512,
+					cts: 4608,
+				},
+				{
+					offset: 20196,
+					size: 776,
+					isKeyframe: false,
+					dts: 4096,
+					duration: 512,
+					cts: 5120,
+				},
+				{
+					offset: 21932,
+					size: 586,
+					isKeyframe: false,
+					dts: 4608,
+					duration: 512,
+					cts: 5632,
+				},
+			],
+			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(audioTracks).toEqual([
+		{
+			type: 'audio',
+			trackId: 2,
+			samplePositions: [
+				{
+					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,
+				},
+			],
+			timescale: 48000,
+			numberOfChannels: 2,
+			codec: 'mp3',
+			sampleRate: 48000,
+			description: undefined,
+		},
+	]);
+});

package/src/test/stsd.test.ts

@@ -2,8 +2,9 @@ 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', () => {
+test('Should be able to parse a STSD audio box correctly', async () => {
 	const buffer = Uint8Array.from([
 		// box size
 		0, 0, 0, 159,
@@ -23,7 +24,7 @@ test('Should be able to parse a STSD audio box correctly', () => {
 		0, 1,
 		// version
 		0, 1,
-		// revisioon level
+		// 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,
@@ -37,10 +38,19 @@ test('Should be able to parse a STSD audio box correctly', () => {
 	const iterator = getArrayBufferIterator(buffer);
 	iterator.discard(8);
 
-	const parsed = parseStsd({
+	const parsed = await parseStsd({
 		iterator,
 		offset: 0,
 		size: 159,
+		options: {
+			canSkipVideoData: true,
+			onAudioTrack: null,
+			onVideoTrack: null,
+			parserState: makeParserState({
+				hasAudioCallbacks: false,
+				hasVideoCallbacks: false,
+			}),
+		},
 	});
 
 	expect(parsed).toEqual({
@@ -91,9 +101,24 @@ test('Should be able to parse a STSD audio box correctly', () => {
 									{
 										objectTypeIndication: 'aac',
 										type: 'decoder-config-descriptor',
-									},
-									{
-										type: 'sl-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,
@@ -119,7 +144,7 @@ test('Should be able to parse a STSD audio box correctly', () => {
 	});
 });
 
-test('Should be able to parse a STSD video box correctly', () => {
+test('Should be able to parse a STSD video box correctly', async () => {
 	const buffer = Uint8Array.from([
 		// box size
 		0, 0, 0, 158,
@@ -179,8 +204,17 @@ test('Should be able to parse a STSD video box correctly', () => {
 		0, 0, 0, 16, 112, 97, 115, 112, 0, 0, 0, 1, 0, 0, 0, 1,
 	]);
 
-	const parsed = processSample({
+	const parsed = await processSample({
 		iterator: getArrayBufferIterator(buffer),
+		options: {
+			canSkipVideoData: true,
+			onAudioTrack: null,
+			onVideoTrack: null,
+			parserState: makeParserState({
+				hasAudioCallbacks: false,
+				hasVideoCallbacks: false,
+			}),
+		},
 	});
 	expect(parsed.sample).toEqual({
 		size: 158,
@@ -205,5 +239,23 @@ test('Should be able to parse a STSD video box correctly', () => {
 		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

@@ -77,8 +77,11 @@ test('Should be able to parse a TKHD box', () => {
 		version: 0,
 		layer: 0,
 		volume: 0,
-		matrix: [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824],
+		matrix: [1, 0, 0, 0, 1, 0, 0, 0, 1],
 		width: 0,
 		height: 0,
+		rotation: 0,
+		unrotatedWidth: 0,
+		unrotatedHeight: 0,
 	});
 });