@remotion/media-parser 4.0.202 → 4.0.205

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

@@ -138,7 +138,6 @@ test('Should stream AV1', async () => {
 			denominator: 1,
 			numerator: 1,
 		},
-		samplePositions: [],
 		timescale: 1000000,
 		trackId: 1,
 		codedHeight: 1080,
@@ -148,6 +147,7 @@ test('Should stream AV1', async () => {
 		displayAspectHeight: 1080,
 		displayAspectWidth: 1920,
 		rotation: 0,
+		trakBox: null,
 	});
 	expect(parsed.audioTracks.length).toBe(0);
 	expect(videoTracks).toBe(1);
@@ -263,12 +263,12 @@ test('Should stream variable fps video', async () => {
 			boxes: true,
 		},
 		reader: nodeReader,
-		onAudioTrack: (track) => {
-			expect(track.type).toBe('audio');
-			expect(track.trackId).toBe(1);
-			expect(track.codec).toBe('opus');
-			expect(track.numberOfChannels).toBe(1);
-			expect(track.sampleRate).toBe(48000);
+		onAudioTrack: (track_) => {
+			expect(track_.type).toBe('audio');
+			expect(track_.trackId).toBe(1);
+			expect(track_.codec).toBe('opus');
+			expect(track_.numberOfChannels).toBe(1);
+			expect(track_.sampleRate).toBe(48000);
 			audioTracks++;
 			return () => {
 				samples++;
@@ -293,7 +293,6 @@ test('Should stream variable fps video', async () => {
 			denominator: 1,
 			numerator: 1,
 		},
-		samplePositions: [],
 		timescale: 1000000,
 		trackId: 2,
 		codedHeight: 720,
@@ -303,17 +302,18 @@ test('Should stream variable fps video', async () => {
 		displayAspectHeight: 720,
 		displayAspectWidth: 1280,
 		rotation: 0,
+		trakBox: null,
 	});
 	expect(parsed.audioTracks.length).toBe(1);
 	expect(parsed.audioTracks[0]).toEqual({
 		type: 'audio',
 		codec: 'opus',
-		samplePositions: null,
 		timescale: 1000000,
 		trackId: 1,
 		numberOfChannels: 1,
 		sampleRate: 48000,
 		description: undefined,
+		trakBox: null,
 	});
 	expect(audioTracks).toBe(1);
 	expect(samples).toBe(381);
@@ -574,27 +574,25 @@ test('Stretched VP8', async () => {
 		reader: nodeReader,
 	});
 
-	expect(videoTracks).toEqual([
-		{
-			codec: 'vp8',
-			codedHeight: 1080,
-			codedWidth: 1440,
-			description: undefined,
-			height: 1080,
-			sampleAspectRatio: {
-				denominator: 1,
-				numerator: 1,
-			},
-			samplePositions: [],
-			timescale: 1000000,
-			trackId: 1,
-			type: 'video',
-			width: 1920,
-			displayAspectHeight: 1080,
-			displayAspectWidth: 1920,
-			rotation: 0,
-		},
-	]);
+	const {trakBox, ...track} = videoTracks[0];
+	expect(track).toEqual({
+		codec: 'vp8',
+		codedHeight: 1080,
+		codedWidth: 1440,
+		description: undefined,
+		height: 1080,
+		sampleAspectRatio: {
+			denominator: 1,
+			numerator: 1,
+		},
+		timescale: 1000000,
+		trackId: 1,
+		type: 'video',
+		width: 1920,
+		displayAspectHeight: 1080,
+		displayAspectWidth: 1920,
+		rotation: 0,
+	});
 });
 
 test('HEVC and AAC in Matroska', async () => {

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

@@ -1,5 +1,7 @@
 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 {nodeReader} from '../from-node';
 import {parseMedia} from '../parse-media';
 
@@ -20,240 +22,160 @@ test('Stream samples', async () => {
 		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,
+	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(audioTracks).toEqual([
+	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,
+		},
 		{
-			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,
+			offset: 25398,
+			size: 960,
+			isKeyframe: true,
+			dts: 16128,
+			duration: 1152,
+			cts: 16128,
 		},
 	]);
 });

package/src/traversal.ts

@@ -9,8 +9,11 @@ import type {StsdBox} from './boxes/iso-base-media/stsd/stsd';
 import type {StssBox} from './boxes/iso-base-media/stsd/stss';
 import type {StszBox} from './boxes/iso-base-media/stsd/stsz';
 import type {SttsBox} from './boxes/iso-base-media/stsd/stts';
+import type {TfdtBox} from './boxes/iso-base-media/tfdt';
+import type {TfhdBox} from './boxes/iso-base-media/tfhd';
 import type {TkhdBox} from './boxes/iso-base-media/tkhd';
 import type {TrakBox} from './boxes/iso-base-media/trak/trak';
+import type {TrunBox} from './boxes/iso-base-media/trun';
 import type {
 	AudioSegment,
 	ClusterSegment,
@@ -25,7 +28,7 @@ import type {
 	VideoSegment,
 	WidthSegment,
 } from './boxes/webm/segments/all-segments';
-import type {AnySegment, RegularBox} from './parse-result';
+import type {AnySegment, IsoBaseMediaBox, RegularBox} from './parse-result';
 
 export const getFtypBox = (segments: AnySegment[]): FtypBox | null => {
 	const ftypBox = segments.find((s) => s.type === 'ftyp-box');
@@ -45,6 +48,18 @@ export const getMoovBox = (segments: AnySegment[]): MoovBox | null => {
 	return moovBox;
 };
 
+export const getMoofBox = (main: AnySegment[]): IsoBaseMediaBox | null => {
+	const moofBox = main.find(
+		(s) => s.type === 'regular-box' && s.boxType === 'moof',
+	);
+
+	if (!moofBox || moofBox.type !== 'regular-box') {
+		return null;
+	}
+
+	return moofBox;
+};
+
 export const getMvhdBox = (moovBox: MoovBox): MvhdBox | null => {
 	const mvHdBox = moovBox.children.find((s) => s.type === 'mvhd-box');
 
@@ -239,6 +254,46 @@ export const getStssBox = (trakBox: TrakBox): StssBox | null => {
 	return stssBox;
 };
 
+export const getTfdtBox = (segment: IsoBaseMediaBox): TfdtBox | null => {
+	if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+		throw new Error('Expected traf-box');
+	}
+
+	const tfhdBox = segment.children.find((c) => c.type === 'tfdt-box');
+
+	if (!tfhdBox || tfhdBox.type !== 'tfdt-box') {
+		throw new Error('Expected tfhd-box');
+	}
+
+	return tfhdBox;
+};
+
+export const getTfhdBox = (segment: IsoBaseMediaBox): TfhdBox | null => {
+	if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+		throw new Error('Expected traf-box');
+	}
+
+	const tfhdBox = segment.children.find(
+		(c) => c.type === 'tfhd-box',
+	) as TfhdBox;
+
+	if (!tfhdBox || tfhdBox.type !== 'tfhd-box') {
+		throw new Error('Expected tfhd-box');
+	}
+
+	return tfhdBox;
+};
+
+export const getTrunBoxes = (segment: IsoBaseMediaBox): TrunBox[] => {
+	if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+		throw new Error('Expected traf-box');
+	}
+
+	const trunBoxes = segment.children.filter((c) => c.type === 'trun-box');
+
+	return trunBoxes as TrunBox[];
+};
+
 export const getClusterSegment = (
 	segment: MainSegment,
 ): ClusterSegment | null => {