@remotion/media-parser 4.0.201 → 4.0.202

package/src/get-video-codec.ts

@@ -76,39 +76,37 @@ export const getVideoCodec = (boxes: AnySegment[]): KnownVideoCodecs | null => {
 		}
 	}
 
-	const mainSegment = boxes.find((b) => b.type === 'main-segment');
-	if (!mainSegment || mainSegment.type !== 'main-segment') {
+	const mainSegment = boxes.find((b) => b.type === 'Segment');
+	if (!mainSegment || mainSegment.type !== 'Segment') {
 		return null;
 	}
 
-	const tracksSegment = mainSegment.children.find(
-		(b) => b.type === 'tracks-segment',
-	);
-	if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+	const tracksSegment = mainSegment.value.find((b) => b.type === 'Tracks');
+	if (!tracksSegment || tracksSegment.type !== 'Tracks') {
 		return null;
 	}
 
-	for (const track of tracksSegment.children) {
-		if (track.type === 'track-entry-segment') {
-			const trackType = track.children.find((b) => b.type === 'codec-segment');
-			if (trackType && trackType.type === 'codec-segment') {
-				if (trackType.codec === 'V_VP8') {
+	for (const track of tracksSegment.value) {
+		if (track.type === 'TrackEntry') {
+			const trackType = track.value.find((b) => b.type === 'CodecID');
+			if (trackType && trackType.type === 'CodecID') {
+				if (trackType.value === 'V_VP8') {
 					return 'vp8';
 				}
 
-				if (trackType.codec === 'V_VP9') {
+				if (trackType.value === 'V_VP9') {
 					return 'vp9';
 				}
 
-				if (trackType.codec === 'V_AV1') {
+				if (trackType.value === 'V_AV1') {
 					return 'av1';
 				}
 
-				if (trackType.codec === 'V_MPEG4/ISO/AVC') {
+				if (trackType.value === 'V_MPEG4/ISO/AVC') {
 					return 'h264';
 				}
 
-				if (trackType.codec === 'V_MPEGH/ISO/HEVC') {
+				if (trackType.value === 'V_MPEGH/ISO/HEVC') {
 					return 'h265';
 				}
 			}

package/src/parse-media.ts

@@ -52,6 +52,11 @@ export const parseMedia: ParseMedia = async ({
 		onAudioTrack: onAudioTrack ?? null,
 		onVideoTrack: onVideoTrack ?? null,
 		parserState: state,
+		nullifySamples: !(
+			typeof process !== 'undefined' &&
+			typeof process.env !== 'undefined' &&
+			process.env.KEEP_SAMPLES === 'true'
+		),
 	};
 
 	while (parseResult === null || parseResult.status === 'incomplete') {
@@ -72,7 +77,7 @@ export const parseMedia: ParseMedia = async ({
 
 			iterator = getArrayBufferIterator(
 				result.value,
-				contentLength ?? undefined,
+				contentLength ?? 1_000_000_000,
 			);
 		}
 

package/src/parser-context.ts

@@ -6,4 +6,5 @@ export type ParserContext = {
 	onVideoTrack: OnVideoTrack | null;
 	canSkipVideoData: boolean;
 	parserState: ParserState;
+	nullifySamples: boolean;
 };

package/src/parser-state.ts

@@ -40,8 +40,8 @@ export const makeParserState = ({
 		const trackTimescale = getTrackTimestampScale(trackEntry);
 
 		trackEntries[trackId] = {
-			codec: codec.codec,
-			trackTimescale,
+			codec: codec.value,
+			trackTimescale: trackTimescale?.value ?? null,
 		};
 	};
 

package/src/test/create-matroska.test.ts

@@ -1,29 +1,121 @@
-import {RenderInternals} from '@remotion/renderer';
+/* eslint-disable padding-line-between-statements */
+/* eslint-disable max-depth */
 import {expect, test} from 'bun:test';
-import {makeMatroskaHeader} from '../boxes/webm/make-header';
-import {
-	matroskaHeader,
-	seek,
-	seekId,
+import {combineUint8Arrays, makeMatroskaBytes} from '../boxes/webm/make-header';
+import {parseEbml} from '../boxes/webm/parse-ebml';
+import type {MatroskaSegment} from '../boxes/webm/segments';
+import type {
+	MainSegment,
+	TrackEntry,
 } from '../boxes/webm/segments/all-segments';
+import {getArrayBufferIterator} from '../buffer-iterator';
+import {nodeReader} from '../from-node';
+import {parseMedia} from '../parse-media';
+import type {AnySegment} from '../parse-result';
+import type {ParserContext} from '../parser-context';
+import {makeParserState} from '../parser-state';
 
-test('Should make Matroska header that is same as input', async () => {
-	const exampleVideo = RenderInternals.exampleVideos.matroskaMp3;
-	const file = await Bun.file(exampleVideo).arrayBuffer();
+const state = makeParserState({
+	hasAudioCallbacks: false,
+	hasVideoCallbacks: false,
+	signal: undefined,
+});
 
-	const headerInput = new Uint8Array(file.slice(0, 0x28));
+const options: ParserContext = {
+	canSkipVideoData: true,
+	onAudioTrack: null,
+	onVideoTrack: null,
+	parserState: state,
+	nullifySamples: false,
+};
 
-	const headerOutput = makeMatroskaHeader(matroskaHeader, {
-		DocType: 'matroska',
-		DocTypeVersion: 4,
-		DocTypeReadVersion: 2,
-		EBMLMaxIDLength: 4,
-		EBMLMaxSizeLength: 8,
-		EBMLReadVersion: 1,
-		EBMLVersion: 1,
+test('Should make Matroska header that is same as input', async () => {
+	const headerOutput = makeMatroskaBytes({
+		type: 'Header',
+		minVintWidth: 1,
+		value: [
+			{
+				type: 'EBMLVersion',
+				value: {value: 1, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLReadVersion',
+				value: {value: 1, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLMaxIDLength',
+				value: {value: 4, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLMaxSizeLength',
+				value: {value: 8, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocType',
+				value: 'webm',
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocTypeVersion',
+				value: {value: 4, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocTypeReadVersion',
+				value: {value: 2, byteLength: 1},
+				minVintWidth: 1,
+			},
+		],
 	});
 
-	expect(headerInput).toEqual(headerOutput);
+	const iterator = getArrayBufferIterator(headerOutput, headerOutput.length);
+	const parsed = await parseEbml(iterator, options);
+
+	expect(parsed).toEqual({
+		type: 'Header',
+		minVintWidth: 1,
+		value: [
+			{
+				type: 'EBMLVersion',
+				value: {value: 1, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLReadVersion',
+				value: {value: 1, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLMaxIDLength',
+				value: {value: 4, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLMaxSizeLength',
+				value: {value: 8, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocType',
+				value: 'webm',
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocTypeVersion',
+				value: {value: 4, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocTypeReadVersion',
+				value: {value: 2, byteLength: 1},
+				minVintWidth: 1,
+			},
+		],
+	});
 });
 
 test('Should be able to create SeekIdBox', async () => {
@@ -31,7 +123,11 @@ test('Should be able to create SeekIdBox', async () => {
 		await Bun.file('vp8-segments/56-0x53ab').arrayBuffer(),
 	);
 
-	const custom = makeMatroskaHeader(seekId, '0x1549a966');
+	const custom = makeMatroskaBytes({
+		type: 'SeekID',
+		value: '0x1549a966',
+		minVintWidth: 1,
+	});
 	expect(custom).toEqual(file);
 });
 
@@ -39,10 +135,128 @@ test('Should be able to create Seek', async () => {
 	const file = new Uint8Array(
 		await Bun.file('vp8-segments/53-0x4dbb').arrayBuffer(),
 	);
+	const parsed = await parseEbml(getArrayBufferIterator(file, null), options);
+	expect(parsed).toEqual({
+		type: 'Seek',
+		value: [
+			{
+				type: 'SeekID',
+				value: '0x1549a966',
+				minVintWidth: 1,
+			},
+			{
+				type: 'SeekPosition',
+				value: {value: 0x40, byteLength: 1},
+				minVintWidth: 1,
+			},
+		],
+		minVintWidth: 1,
+	});
+
+	const custom = makeMatroskaBytes(parsed);
+	expect(custom).toEqual(file);
+});
+
+test('Should parse seekHead', async () => {
+	const file = new Uint8Array(
+		await Bun.file('vp8-segments/2165155-0x114d9b74').arrayBuffer(),
+	);
+
+	const seekPosition = makeMatroskaBytes({
+		type: 'SeekPosition',
+		value: {value: 3911, byteLength: 2},
+		minVintWidth: 1,
+	});
 
-	const custom = makeMatroskaHeader(seek, {
-		SeekID: '0x1549a966',
-		SeekPosition: 0x40,
+	const custom = makeMatroskaBytes({
+		type: 'SeekHead',
+		value: [
+			{
+				type: 'Seek',
+				value: [
+					{
+						type: 'SeekID',
+						value: '0x1f43b675',
+						minVintWidth: 1,
+					},
+					seekPosition,
+				],
+				minVintWidth: 1,
+			},
+		],
+		minVintWidth: 1,
 	});
 	expect(custom).toEqual(file);
+
+	const iterator = getArrayBufferIterator(file, file.length);
+	const parsed = await parseEbml(iterator, options);
+
+	expect(parsed).toEqual({
+		minVintWidth: 1,
+		type: 'SeekHead',
+		value: [
+			{
+				minVintWidth: 1,
+				type: 'Seek',
+				value: [
+					{minVintWidth: 1, type: 'SeekID', value: '0x1f43b675'},
+					{
+						minVintWidth: 1,
+						type: 'SeekPosition',
+						value: {value: 3911, byteLength: 2},
+					},
+				],
+			},
+		],
+	});
+});
+
+const parseWebm = async (str: string) => {
+	const {boxes} = await parseMedia({
+		src: str,
+		fields: {
+			boxes: true,
+		},
+		reader: nodeReader,
+	});
+	return boxes;
+};
+
+const stringifyWebm = (boxes: AnySegment[]) => {
+	const buffers: Uint8Array[] = [];
+	for (const box of boxes) {
+		const bytes = makeMatroskaBytes(box as MatroskaSegment);
+		buffers.push(bytes);
+	}
+
+	const combined = combineUint8Arrays(buffers);
+	return combined;
+};
+
+test('Can we disassemble a Matroska file and assembled it again', async () => {
+	process.env.KEEP_SAMPLES = 'true';
+
+	const parsed = await parseWebm('input.webm');
+
+	const segment = parsed.find((s) => s.type === 'Segment') as MainSegment;
+	const tracks = segment.value.flatMap((s) =>
+		s.type === 'Tracks' ? s.value.filter((a) => a.type === 'TrackEntry') : [],
+	);
+	for (const track of tracks as TrackEntry[]) {
+		for (const child of track.value) {
+			if (child.type === 'Video') {
+				for (const attribute of child.value) {
+					if (attribute.type === 'DisplayHeight') {
+						attribute.value.value *= 2;
+					}
+				}
+			}
+		}
+	}
+
+	const bytes = await Bun.file('input.webm').arrayBuffer();
+	expect(stringifyWebm(parsed).byteLength).toEqual(
+		new Uint8Array(bytes).byteLength,
+	);
+	process.env.KEEP_SAMPLES = 'false';
 });