@remotion/media-parser 4.0.199 → 4.0.201

package/src/boxes/webm/make-header.ts

@@ -0,0 +1,138 @@
+import {getVariableInt} from './ebml';
+import type {
+	Ebml,
+	EbmlWithChildren,
+	EbmlWithHexString,
+	EbmlWithString,
+	EbmlWithUint8,
+	EmblTypes,
+	HeaderStructure,
+	matroskaElements,
+} from './segments/all-segments';
+import {getIdForName} from './segments/all-segments';
+
+export const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
+
+const matroskaToHex = (
+	matrId: (typeof matroskaElements)[keyof typeof matroskaElements],
+) => {
+	const numbers: Uint8Array = new Uint8Array((matrId.length - 2) / 2);
+
+	for (let i = 2; i < matrId.length; i += 2) {
+		const hex = matrId.substring(i, i + 2);
+		numbers[(i - 2) / 2] = parseInt(hex, 16);
+	}
+
+	return numbers;
+};
+
+type Numbers = '0' | '1' | '2' | '3' | '4' | '5' | '6';
+
+type ChildFields<Struct extends HeaderStructure> = {
+	[key in keyof Struct &
+		Numbers as Struct[key]['name']]: EmblTypes[Struct[key]['type']];
+};
+
+type SerializeValue<Struct extends Ebml> = Struct extends EbmlWithChildren
+	? ChildFields<Struct['children']>
+	: Struct extends EbmlWithString
+		? string
+		: Struct extends EbmlWithUint8
+			? number
+			: Struct extends EbmlWithHexString
+				? string
+				: undefined;
+
+function putUintDynamic(number: number) {
+	if (number < 0) {
+		throw new Error(
+			'This function is designed for non-negative integers only.',
+		);
+	}
+
+	// Calculate the minimum number of bytes needed to store the integer
+	const length = Math.ceil(Math.log2(number + 1) / 8);
+	const bytes = new Uint8Array(length);
+
+	for (let i = 0; i < length; i++) {
+		// Extract each byte from the number
+		bytes[length - 1 - i] = (number >> (8 * i)) & 0xff;
+	}
+
+	return bytes;
+}
+
+const makeFromHeaderStructure = <Struct extends Ebml>(
+	struct: Struct,
+	fields: SerializeValue<Struct>,
+): Uint8Array => {
+	const arrays: Uint8Array[] = [];
+
+	if (struct.type === 'children') {
+		for (const item of struct.children) {
+			arrays.push(
+				makeMatroskaHeader(
+					item,
+					// @ts-expect-error
+					fields[item.name],
+				),
+			);
+		}
+
+		return combineUint8Arrays(arrays);
+	}
+
+	if (struct.type === 'string') {
+		return new TextEncoder().encode(fields as string);
+	}
+
+	if (struct.type === 'uint') {
+		return putUintDynamic(fields as number);
+	}
+
+	if (struct.type === 'hex-string') {
+		const hex = (fields as string).substring(2);
+		const arr = new Uint8Array(hex.length / 2);
+		for (let i = 0; i < hex.length; i += 2) {
+			const byte = parseInt(hex.substring(i, i + 2), 16);
+			arr[i / 2] = byte;
+		}
+
+		return arr;
+	}
+
+	if (struct.type === 'void') {
+		throw new Error('Serializing Void is not implemented');
+	}
+
+	throw new Error('Unexpected type');
+};
+
+export const makeMatroskaHeader = <Struct extends Ebml>(
+	struct: Struct,
+	fields: SerializeValue<Struct>,
+) => {
+	const value = makeFromHeaderStructure(struct, fields);
+
+	return combineUint8Arrays([
+		matroskaToHex(getIdForName(struct.name)),
+		getVariableInt(value.length),
+		value,
+	]);
+};
+
+const combineUint8Arrays = (arrays: Uint8Array[]) => {
+	let totalLength = 0;
+	for (const array of arrays) {
+		totalLength += array.length;
+	}
+
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const array of arrays) {
+		result.set(array, offset);
+		offset += array.length;
+	}
+
+	return result;
+};

package/src/boxes/webm/parse-ebml.ts

@@ -0,0 +1,93 @@
+import type {BufferIterator} from '../../buffer-iterator';
+import type {PossibleEbml} from './segments/all-segments';
+import {ebmlMap, type Ebml, type EbmlParsed} from './segments/all-segments';
+
+type Prettify<T> = {
+	[K in keyof T]: T[K];
+} & {};
+
+export const parseEbml = (iterator: BufferIterator): Prettify<PossibleEbml> => {
+	const hex = iterator.getMatroskaSegmentId();
+	if (hex === null) {
+		throw new Error(
+			'Not enough bytes left to parse EBML - this should not happen',
+		);
+	}
+
+	const hasInMap = ebmlMap[hex as keyof typeof ebmlMap];
+	if (!hasInMap) {
+		throw new Error(
+			`Don't know how to parse EBML hex ID ${JSON.stringify(hex)}`,
+		);
+	}
+
+	const size = iterator.getVint();
+	if (size === null) {
+		throw new Error(
+			'Not enough bytes left to parse EBML - this should not happen',
+		);
+	}
+
+	if (hasInMap.type === 'uint') {
+		const value = iterator.getUint(size);
+
+		return {type: hasInMap.name, value, hex};
+	}
+
+	if (hasInMap.type === 'string') {
+		const value = iterator.getByteString(size);
+
+		return {
+			type: hasInMap.name,
+			value,
+			hex,
+		};
+	}
+
+	if (hasInMap.type === 'float') {
+		const value = size === 4 ? iterator.getFloat32() : iterator.getFloat64();
+
+		return {
+			type: hasInMap.name,
+			value,
+			hex,
+		};
+	}
+
+	if (hasInMap.type === 'void') {
+		iterator.discard(size);
+
+		return {
+			type: hasInMap.name,
+			value: undefined,
+			hex,
+		};
+	}
+
+	if (hasInMap.type === 'children') {
+		const children: EbmlParsed<Ebml>[] = [];
+		const startOffset = iterator.counter.getOffset();
+
+		// eslint-disable-next-line no-constant-condition
+		while (true) {
+			const value = parseEbml(iterator);
+			children.push(value);
+			const offsetNow = iterator.counter.getOffset();
+
+			if (offsetNow - startOffset > size) {
+				throw new Error(
+					`Offset ${offsetNow - startOffset} is larger than the length of the hex ${size}`,
+				);
+			}
+
+			if (offsetNow - startOffset === size) {
+				break;
+			}
+		}
+
+		return {type: hasInMap.name, value: children as EbmlParsed<Ebml>[], hex};
+	}
+
+	// @ts-expect-error
+	throw new Error(`Unknown segment type ${hasInMap.type}`);
+};

package/src/boxes/webm/parse-webm-header.ts

@@ -1,22 +1,18 @@
 import type {BufferIterator} from '../../buffer-iterator';
 import type {ParseResult} from '../../parse-result';
 import type {ParserContext} from '../../parser-context';
-import {expectSegment} from './segments';
+import {expectChildren} from './segments/parse-children';
 
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
 export const parseWebm = (
 	counter: BufferIterator,
 	parserContext: ParserContext,
 ): Promise<ParseResult> => {
-	counter.discard(4);
-	const length = counter.getVint();
-
-	if (length !== 31 && length !== 35) {
-		throw new Error(`Expected header length 31 or 25, got ${length}`);
-	}
-
-	// Discard header for now
-	counter.discard(length);
-
-	return expectSegment(counter, parserContext);
+	return expectChildren({
+		iterator: counter,
+		length: Infinity,
+		initialChildren: [],
+		wrap: null,
+		parserContext,
+	});
 };

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

@@ -1,6 +1,12 @@
 export const matroskaElements = {
+	Header: '0x1a45dfa3',
 	EBMLMaxIDLength: '0x42f2',
+	EBMLVersion: '0x4286',
+	EBMLReadVersion: '0x42f7',
 	EBMLMaxSizeLength: '0x42f3',
+	DocType: '0x4282',
+	DocTypeVersion: '0x4287',
+	DocTypeReadVersion: '0x4285',
 	Segment: '0x18538067',
 	SeekHead: '0x114d9b74',
 	Seek: '0x4dbb',
@@ -283,3 +289,223 @@ export const getSegmentName = (id: string) => {
 		([, value]) => value === id,
 	)?.[0];
 };
+
+export const getIdForName = (name: string) => {
+	const value = Object.entries(matroskaElements).find(
+		([key]) => key === name,
+	)?.[1];
+	if (!value) {
+		throw new Error(`Could not find id for name ${name}`);
+	}
+
+	return value;
+};
+
+export type MatroskaKey = keyof typeof matroskaElements;
+
+export type MatroskaElement = (typeof matroskaElements)[MatroskaKey];
+
+type EbmlType = 'string';
+
+export type EbmlWithChildren = {
+	name: MatroskaKey;
+	type: 'children';
+	children: HeaderStructure;
+};
+
+export type EbmlWithUint8 = {
+	name: MatroskaKey;
+	type: 'uint';
+};
+
+export type EbmlWithHexString = {
+	name: MatroskaKey;
+	type: 'hex-string';
+};
+
+export type EbmlWithString = {
+	name: MatroskaKey;
+	type: EbmlType;
+};
+
+export type EbmlWithVoid = {
+	name: MatroskaKey;
+	type: 'void';
+};
+
+export type EbmlWithFloat = {
+	name: MatroskaKey;
+	type: 'float';
+};
+
+export type Ebml =
+	| EbmlWithString
+	| EbmlWithUint8
+	| EbmlWithChildren
+	| EbmlWithVoid
+	| EbmlWithFloat
+	| EbmlWithHexString;
+
+export const ebmlVersion = {
+	name: 'EBMLVersion',
+	type: 'uint',
+} satisfies Ebml;
+
+export const ebmlReadVersion = {
+	name: 'EBMLReadVersion',
+	type: 'uint',
+} satisfies Ebml;
+
+export const ebmlMaxIdLength = {
+	name: 'EBMLMaxIDLength',
+	type: 'uint',
+} satisfies Ebml;
+
+export const ebmlMaxSizeLength = {
+	name: 'EBMLMaxSizeLength',
+	type: 'uint',
+} satisfies Ebml;
+
+export const docType = {
+	name: 'DocType',
+	type: 'string',
+} satisfies Ebml;
+
+export const docTypeVersion = {
+	name: 'DocTypeVersion',
+	type: 'uint',
+} satisfies Ebml;
+
+export const docTypeReadVersion = {
+	name: 'DocTypeReadVersion',
+	type: 'uint',
+} satisfies Ebml;
+
+export const voidEbml = {
+	name: 'Void',
+	type: 'void',
+} satisfies Ebml;
+
+export type EmblTypes = {
+	uint: number;
+	float: number;
+	string: string;
+	children: HeaderStructure;
+	void: undefined;
+	'hex-string': string;
+};
+
+export type HeaderStructure = Ebml[];
+
+export const matroskaHeaderStructure = [
+	ebmlVersion,
+	ebmlReadVersion,
+	ebmlMaxIdLength,
+	ebmlMaxSizeLength,
+	docType,
+	docTypeVersion,
+	docTypeReadVersion,
+] as const satisfies HeaderStructure;
+
+export const matroskaHeader = {
+	name: 'Header',
+	type: 'children',
+	children: matroskaHeaderStructure,
+} as const satisfies Ebml;
+
+export const seekId = {
+	name: 'SeekID',
+	type: 'hex-string',
+} as const satisfies Ebml;
+
+export const seekPosition = {
+	name: 'SeekPosition',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const seek = {
+	name: 'Seek',
+	type: 'children',
+	children: [seekId, seekPosition],
+} as const satisfies Ebml;
+
+export const voidHeader = {
+	name: 'Void',
+	type: 'void',
+} as const satisfies Ebml;
+
+export type EbmlValue<T extends Ebml> = T extends EbmlWithUint8
+	? number
+	: T extends EbmlWithVoid
+		? undefined
+		: T extends EbmlWithString
+			? string
+			: T extends EbmlWithFloat
+				? number
+				: EbmlParsed<Ebml>[];
+
+export type EbmlParsed<T extends Ebml> = {
+	type: T['name'];
+	value: EbmlValue<T>;
+	hex: string;
+};
+
+export const ebmlMap = {
+	[matroskaElements.Header]: matroskaHeader,
+	[matroskaElements.DocType]: docType,
+	[matroskaElements.DocTypeVersion]: docTypeVersion,
+	[matroskaElements.DocTypeReadVersion]: docTypeReadVersion,
+	[matroskaElements.EBMLVersion]: ebmlVersion,
+	[matroskaElements.EBMLReadVersion]: ebmlReadVersion,
+	[matroskaElements.EBMLMaxIDLength]: ebmlMaxIdLength,
+	[matroskaElements.EBMLMaxSizeLength]: ebmlMaxSizeLength,
+	[matroskaElements.Void]: voidEbml,
+	[matroskaElements.Cues]: {
+		name: 'Cues',
+		type: 'void',
+	},
+	[matroskaElements.DateUTC]: {
+		name: 'DateUTC',
+		type: 'void',
+	},
+	[matroskaElements.TrackTimestampScale]: {
+		name: 'TrackTimestampScale',
+		type: 'float',
+	},
+	[matroskaElements.CodecDelay]: {
+		name: 'CodecDelay',
+		type: 'void',
+	},
+	[matroskaElements.SeekPreRoll]: {
+		name: 'SeekPreRoll',
+		type: 'void',
+	},
+	[matroskaElements.DiscardPadding]: {
+		name: 'DiscardPadding',
+		type: 'void',
+	},
+	[matroskaElements.OutputSamplingFrequency]: {
+		name: 'OutputSamplingFrequency',
+		type: 'void',
+	},
+	[matroskaElements.CodecName]: {
+		name: 'CodecName',
+		type: 'void',
+	},
+	[matroskaElements.Position]: {
+		name: 'Position',
+		type: 'void',
+	},
+	[matroskaElements.SliceDuration]: {
+		name: 'SliceDuration',
+		type: 'void',
+	},
+} as const satisfies Partial<Record<MatroskaElement, Ebml>>;
+
+export type PossibleEbml = {
+	[key in keyof typeof ebmlMap]: {
+		type: (typeof ebmlMap)[key]['name'];
+		value: EbmlValue<(typeof ebmlMap)[key]>;
+		hex: string;
+	};
+}[keyof typeof ebmlMap];

package/src/boxes/webm/segments/block-simple-block-flags.ts

@@ -0,0 +1,52 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import {matroskaElements} from './all-segments';
+
+type BlockFlags = {
+	invisible: boolean;
+	lacing: number;
+	keyframe: boolean | null;
+};
+
+export const parseBlockFlags = (
+	iterator: BufferIterator,
+	type:
+		| (typeof matroskaElements)['Block']
+		| (typeof matroskaElements)['SimpleBlock'],
+): BlockFlags => {
+	if (type === matroskaElements.Block) {
+		iterator.startReadingBits();
+		// Reserved
+		iterator.getBits(4);
+		const invisible = Boolean(iterator.getBits(1));
+		const lacing = iterator.getBits(2);
+		// unused
+		iterator.getBits(1);
+		iterator.stopReadingBits();
+		return {
+			invisible,
+			lacing,
+			keyframe: null,
+		};
+	}
+
+	if (type === matroskaElements.SimpleBlock) {
+		iterator.startReadingBits();
+
+		const keyframe = Boolean(iterator.getBits(1));
+		// Reserved
+		iterator.getBits(3);
+		const invisible = Boolean(iterator.getBits(1));
+		const lacing = iterator.getBits(2);
+		iterator.getBits(1);
+
+		iterator.stopReadingBits();
+
+		return {
+			invisible,
+			lacing,
+			keyframe,
+		};
+	}
+
+	throw new Error('Unexpected type');
+};

package/src/boxes/webm/segments/seek-position.ts

@@ -9,7 +9,7 @@ export const parseSeekPositionSegment = (
 	iterator: BufferIterator,
 	length: number,
 ): SeekPositionSegment => {
-	const seekPosition = iterator.getDecimalBytes(length);
+	const seekPosition = iterator.getUint(length);
 
 	return {
 		type: 'seek-position-segment',

package/src/boxes/webm/segments/seek.ts

@@ -35,8 +35,18 @@ export type SeekIdSegment = {
 	seekId: string;
 };
 
-export const parseSeekIdSegment = (iterator: BufferIterator): SeekIdSegment => {
-	const seekId = iterator.getMatroskaSegmentId();
+export const parseSeekIdSegment = (
+	iterator: BufferIterator,
+	length: number,
+): SeekIdSegment => {
+	const seekId =
+		'0x' +
+		[...iterator.getSlice(length)]
+			.map((b) => b.toString(16).padStart(2, '0'))
+			.join('');
+	if (seekId === null) {
+		throw new Error('Not enough bytes to parse seek id');
+	}
 
 	return {
 		type: 'seek-id-segment',

package/src/boxes/webm/segments/timestamp-scale.ts

@@ -8,7 +8,7 @@ export type TimestampScaleSegment = {
 export const parseTimestampScaleSegment = (
 	iterator: BufferIterator,
 ): TimestampScaleSegment => {
-	const timestampScale = iterator.getDecimalBytes(3);
+	const timestampScale = iterator.getUint(3);
 
 	return {
 		type: 'timestamp-scale-segment',