@remotion/media-parser 4.0.206 → 4.0.208

package/src/boxes/webm/segments/all-segments.ts

@@ -360,7 +360,7 @@ export const ebmlReadVersion = {
 export const ebmlMaxIdLength = {
 	name: 'EBMLMaxIDLength',
 	type: 'uint',
-} satisfies Ebml;
+} as const satisfies Ebml;
 
 export const ebmlMaxSizeLength = {
 	name: 'EBMLMaxSizeLength',
@@ -539,7 +539,37 @@ export const trackUID = {
 
 export const color = {
 	name: 'Colour',
-	type: 'uint8array',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const transfer = {
+	name: 'TransferCharacteristics',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const matrix = {
+	name: 'MatrixCoefficients',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const primaries = {
+	name: 'Primaries',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const range = {
+	name: 'Range',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const ChromaSitingHorz = {
+	name: 'ChromaSitingHorz',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const ChromaSitingVert = {
+	name: 'ChromaSitingVert',
+	type: 'uint',
 } as const satisfies Ebml;
 
 export const language = {
@@ -579,7 +609,7 @@ export const videoSegment = {
 
 export const flagDefault = {
 	name: 'FlagDefault',
-	type: 'uint8array',
+	type: 'uint',
 } as const satisfies Ebml;
 
 export const referenceBlock = {
@@ -661,7 +691,7 @@ export type ClusterSegment = EbmlParsed<typeof cluster>;
 export type Tracks = EbmlParsed<typeof tracks>;
 
 export type FloatWithSize = {value: number; size: '32' | '64'};
-export type UintWithSize = {value: number; byteLength: number};
+export type UintWithSize = {value: number; byteLength: number | null};
 
 export type EbmlValue<
 	T extends Ebml,
@@ -687,13 +717,13 @@ export type EbmlValueOrUint8Array<T extends Ebml> =
 export type EbmlParsed<T extends Ebml> = {
 	type: T['name'];
 	value: EbmlValue<T>;
-	minVintWidth: number;
+	minVintWidth: number | null;
 };
 
 export type EbmlParsedOrUint8Array<T extends Ebml> = {
 	type: T['name'];
 	value: EbmlValueOrUint8Array<T>;
-	minVintWidth: number;
+	minVintWidth: number | null;
 };
 
 export const ebmlMap = {
@@ -807,6 +837,12 @@ export const ebmlMap = {
 		name: 'Cluster',
 		type: 'children',
 	},
+	[matroskaElements.TransferCharacteristics]: transfer,
+	[matroskaElements.MatrixCoefficients]: matrix,
+	[matroskaElements.Primaries]: primaries,
+	[matroskaElements.Range]: range,
+	[matroskaElements.ChromaSitingHorz]: ChromaSitingHorz,
+	[matroskaElements.ChromaSitingVert]: ChromaSitingVert,
 } as const satisfies Partial<Record<MatroskaElement, Ebml>>;
 
 export type PossibleEbml = Prettify<
@@ -815,6 +851,30 @@ export type PossibleEbml = Prettify<
 	}[keyof typeof ebmlMap]
 >;
 
+export type OffsetAndChildren = {
+	offset: number;
+	children: OffsetAndChildren[];
+	field: keyof typeof matroskaElements;
+};
+
+export const incrementOffsetAndChildren = (
+	offset: OffsetAndChildren,
+	increment: number,
+): OffsetAndChildren => {
+	return {
+		offset: offset.offset + increment,
+		children: offset.children.map((c) =>
+			incrementOffsetAndChildren(c, increment),
+		),
+		field: offset.field,
+	};
+};
+
+export type BytesAndOffset = {
+	bytes: Uint8Array;
+	offsets: OffsetAndChildren;
+};
+
 export type PossibleEbmlOrUint8Array =
 	| Prettify<
 			{
@@ -823,6 +883,6 @@ export type PossibleEbmlOrUint8Array =
 				>;
 			}[keyof typeof ebmlMap]
 	  >
-	| Uint8Array;
+	| BytesAndOffset;
 
 export type EbmlMapKey = keyof typeof ebmlMap;

package/src/create/cluster-segment.ts

@@ -0,0 +1,62 @@
+import {getVariableInt} from '../boxes/webm/ebml';
+import {
+	combineUint8Arrays,
+	makeMatroskaBytes,
+	matroskaToHex,
+	serializeUint16,
+} from '../boxes/webm/make-header';
+
+export const CLUSTER_MIN_VINT_WIDTH = 8;
+
+export const createClusterSegment = () => {
+	return makeMatroskaBytes({
+		type: 'Cluster',
+		value: [
+			{
+				type: 'Timestamp',
+				minVintWidth: 4,
+				value: {
+					value: 0,
+					byteLength: null,
+				},
+			},
+		],
+		minVintWidth: CLUSTER_MIN_VINT_WIDTH,
+	});
+};
+
+export const makeSimpleBlock = ({
+	bytes,
+	trackNumber,
+	timecodeRelativeToCluster,
+	keyframe,
+	invisible,
+	lacing,
+}: {
+	bytes: Uint8Array;
+	trackNumber: number;
+	timecodeRelativeToCluster: number;
+	keyframe: boolean;
+	invisible: boolean;
+	lacing: number;
+}) => {
+	const simpleBlockHeader = matroskaToHex('0xa3');
+
+	const headerByte =
+		(Number(keyframe) << 7) | (Number(invisible) << 3) | (lacing << 1);
+
+	const body = combineUint8Arrays([
+		getVariableInt(trackNumber, null),
+		// TODO: Cannot encode long videos because of uint16 overflow
+		// need to make new cluster
+		serializeUint16(timecodeRelativeToCluster),
+		new Uint8Array([headerByte]),
+		bytes,
+	]);
+
+	return combineUint8Arrays([
+		simpleBlockHeader,
+		getVariableInt(body.length, null),
+		body,
+	]);
+};

package/src/create/create-media.ts

@@ -0,0 +1,172 @@
+import {getVariableInt} from '../boxes/webm/ebml';
+import {
+	combineUint8Arrays,
+	matroskaToHex,
+	padMatroskaBytes,
+} from '../boxes/webm/make-header';
+import type {BytesAndOffset} from '../boxes/webm/segments/all-segments';
+import {matroskaElements} from '../boxes/webm/segments/all-segments';
+import type {WriterInterface} from '../writers/writer';
+import {
+	CLUSTER_MIN_VINT_WIDTH,
+	createClusterSegment,
+	makeSimpleBlock,
+} from './cluster-segment';
+import {makeMatroskaHeader} from './matroska-header';
+import {makeMatroskaInfo} from './matroska-info';
+import {createMatroskaSegment} from './matroska-segment';
+import type {MakeTrackAudio, MakeTrackVideo} from './matroska-trackentry';
+import {
+	makeMatroskaAudioTrackEntryBytes,
+	makeMatroskaTracks,
+	makeMatroskaVideoTrackEntryBytes,
+} from './matroska-trackentry';
+
+export type MediaFn = {
+	save: () => Promise<void>;
+	addSample: (chunk: EncodedVideoChunk, trackNumber: number) => Promise<void>;
+	updateDuration: (duration: number) => Promise<void>;
+	addTrack: (
+		track:
+			| Omit<MakeTrackAudio, 'trackNumber'>
+			| Omit<MakeTrackVideo, 'trackNumber'>,
+	) => Promise<{trackNumber: number}>;
+	addWaitForFinishPromise: (promise: () => Promise<void>) => void;
+	waitForFinish: () => Promise<void>;
+};
+
+export const createMedia = async (
+	writer: WriterInterface,
+): Promise<MediaFn> => {
+	const header = makeMatroskaHeader();
+
+	const w = await writer.createContent();
+	await w.write(header.bytes);
+	const matroskaInfo = makeMatroskaInfo({
+		timescale: 1_000_000,
+		// TODO: Hardcoded
+		duration: 2658,
+	});
+
+	const currentTracks: BytesAndOffset[] = [];
+
+	const matroskaTracks = makeMatroskaTracks(currentTracks);
+	const matroskaSegment = createMatroskaSegment([
+		matroskaInfo,
+		...matroskaTracks,
+	]);
+
+	const durationOffset =
+		(matroskaSegment.offsets.children[0].children.find(
+			(c) => c.field === 'Duration',
+		)?.offset ?? 0) + w.getWrittenByteCount();
+	const tracksOffset =
+		(matroskaSegment.offsets.children.find((o) => o.field === 'Tracks')
+			?.offset ?? 0) + w.getWrittenByteCount();
+
+	if (!durationOffset) {
+		throw new Error('could not get duration offset');
+	}
+
+	if (!tracksOffset) {
+		throw new Error('could not get tracks offset');
+	}
+
+	await w.write(matroskaSegment.bytes);
+
+	const cluster = createClusterSegment();
+	const clusterVIntPosition =
+		w.getWrittenByteCount() +
+		cluster.offsets.offset +
+		matroskaToHex(matroskaElements.Cluster).byteLength;
+
+	let clusterSize = cluster.bytes.byteLength;
+	await w.write(cluster.bytes);
+
+	const addSample = async (chunk: EncodedVideoChunk, trackNumber: number) => {
+		const arr = new Uint8Array(chunk.byteLength);
+		chunk.copyTo(arr);
+		const simpleBlock = makeSimpleBlock({
+			bytes: arr,
+			invisible: false,
+			keyframe: chunk.type === 'key',
+			lacing: 0,
+			trackNumber,
+			// TODO: Maybe this is bad, because it's in microseconds, but should be in timescale
+			// Maybe it only works by coincidence
+			timecodeRelativeToCluster: Math.round(chunk.timestamp / 1000),
+		});
+
+		clusterSize += simpleBlock.byteLength;
+		await w.updateDataAt(
+			clusterVIntPosition,
+			getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH),
+		);
+		await w.write(simpleBlock);
+	};
+
+	const updateDuration = async (newDuration: number) => {
+		const blocks = padMatroskaBytes(
+			{
+				type: 'Duration',
+				value: {
+					value: newDuration,
+					size: '64',
+				},
+				minVintWidth: null,
+			},
+			// TODO: That's too much padding
+			1000,
+		);
+		await w.updateDataAt(
+			durationOffset,
+			combineUint8Arrays(blocks.map((b) => b.bytes)),
+		);
+	};
+
+	const addTrack = async (track: BytesAndOffset) => {
+		currentTracks.push(track);
+		const newTracks = makeMatroskaTracks(currentTracks);
+
+		await w.updateDataAt(
+			tracksOffset,
+			combineUint8Arrays(newTracks.map((b) => b.bytes)),
+		);
+	};
+
+	let operationProm = Promise.resolve();
+
+	const waitForFinishPromises: (() => Promise<void>)[] = [];
+
+	return {
+		save: async () => {
+			await w.save();
+		},
+		addSample: (chunk, trackNumber) => {
+			operationProm = operationProm.then(() => addSample(chunk, trackNumber));
+			return operationProm;
+		},
+		updateDuration: (duration) => {
+			operationProm = operationProm.then(() => updateDuration(duration));
+			return operationProm;
+		},
+		addTrack: (track) => {
+			const trackNumber = currentTracks.length + 1;
+
+			const bytes =
+				track.type === 'video'
+					? makeMatroskaVideoTrackEntryBytes({...track, trackNumber})
+					: makeMatroskaAudioTrackEntryBytes({...track, trackNumber});
+
+			operationProm = operationProm.then(() => addTrack(bytes));
+
+			return operationProm.then(() => ({trackNumber}));
+		},
+		addWaitForFinishPromise: (promise) => {
+			waitForFinishPromises.push(promise);
+		},
+		async waitForFinish() {
+			await Promise.all(waitForFinishPromises.map((p) => p()));
+		},
+	};
+};

package/src/create/matroska-header.ts

@@ -0,0 +1,63 @@
+import {makeMatroskaBytes} from '../boxes/webm/make-header';
+
+export const makeMatroskaHeader = () => {
+	return makeMatroskaBytes({
+		type: 'Header',
+		value: [
+			{
+				minVintWidth: null,
+				type: 'EBMLVersion',
+				value: {
+					value: 1,
+					byteLength: null,
+				},
+			},
+			{
+				minVintWidth: null,
+				type: 'EBMLReadVersion',
+				value: {
+					value: 1,
+					byteLength: null,
+				},
+			},
+			{
+				type: 'EBMLMaxIDLength',
+				value: {
+					byteLength: null,
+					value: 4,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'EBMLMaxSizeLength',
+				value: {
+					byteLength: null,
+					value: 8,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'DocType',
+				value: 'webm',
+				minVintWidth: null,
+			},
+			{
+				type: 'DocTypeVersion',
+				value: {
+					byteLength: null,
+					value: 4,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'DocTypeReadVersion',
+				value: {
+					byteLength: null,
+					value: 2,
+				},
+				minVintWidth: null,
+			},
+		],
+		minVintWidth: null,
+	});
+};

package/src/create/matroska-info.ts

@@ -0,0 +1,46 @@
+import {makeMatroskaBytes, padMatroskaBytes} from '../boxes/webm/make-header';
+
+export const makeMatroskaInfo = ({
+	timescale,
+	duration,
+}: {
+	timescale: number;
+	duration: number;
+}) => {
+	return makeMatroskaBytes({
+		type: 'Info',
+		value: [
+			{
+				type: 'TimestampScale',
+				value: {
+					value: timescale,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'MuxingApp',
+				value: '@remotion/media-parser',
+				minVintWidth: null,
+			},
+			{
+				type: 'WritingApp',
+				value: '@remotion/media-parser',
+				minVintWidth: null,
+			},
+			...padMatroskaBytes(
+				{
+					type: 'Duration',
+					value: {
+						value: duration,
+						size: '64',
+					},
+					minVintWidth: null,
+				},
+				// TODO: That's too much padding
+				1000,
+			),
+		],
+		minVintWidth: null,
+	});
+};

package/src/create/matroska-segment.ts

@@ -0,0 +1,10 @@
+import {makeMatroskaBytes} from '../boxes/webm/make-header';
+import type {BytesAndOffset} from '../boxes/webm/segments/all-segments';
+
+export const createMatroskaSegment = (children: BytesAndOffset[]) => {
+	return makeMatroskaBytes({
+		type: 'Segment',
+		value: children,
+		minVintWidth: 8,
+	});
+};