@remotion/media-parser 4.0.201 → 4.0.204

package/src/boxes/webm/ebml.ts

@@ -32,10 +32,9 @@ export const measureEBMLVarInt = (value: number) => {
 	throw new Error('EBML VINT size not supported ' + value);
 };
 
-export const getVariableInt = (
-	value: number,
-	width: number = measureEBMLVarInt(value),
-) => {
+export const getVariableInt = (value: number, minWidth: number | null) => {
+	const width = Math.max(measureEBMLVarInt(value), minWidth ?? 0);
+
 	switch (width) {
 		case 1:
 			return new Uint8Array([(1 << 7) | value]);
@@ -72,6 +71,27 @@ export const getVariableInt = (
 				value >> 8,
 				value,
 			]);
+		case 7:
+			return new Uint8Array([
+				(1 << 1) | ((value / 2 ** 48) & 0x1),
+				(value / 2 ** 40) | 0,
+				(value / 2 ** 32) | 0,
+				value >> 24,
+				value >> 16,
+				value >> 8,
+				value,
+			]);
+		case 8:
+			return new Uint8Array([
+				(1 << 0) | ((value / 2 ** 56) & 0x1),
+				(value / 2 ** 48) | 0,
+				(value / 2 ** 40) | 0,
+				(value / 2 ** 32) | 0,
+				value >> 24,
+				value >> 16,
+				value >> 8,
+				value,
+			]);
 		default:
 			throw new Error('Bad EBML VINT size ' + width);
 	}

package/src/boxes/webm/get-ready-tracks.ts

@@ -1,7 +1,7 @@
 import type {Track} from '../../get-tracks';
 import {getTracksSegment} from '../../traversal';
 import {getTrack} from './get-track';
-import type {MainSegment} from './segments/main';
+import type {MainSegment} from './segments/all-segments';
 
 export const getTracksFromMatroska = (
 	segment: MainSegment,
@@ -14,12 +14,12 @@ export const getTracksFromMatroska = (
 
 	const tracks: Track[] = [];
 
-	for (const trackEntrySegment of tracksSegment.children) {
-		if (trackEntrySegment.type === 'crc32-segment') {
+	for (const trackEntrySegment of tracksSegment.value) {
+		if (trackEntrySegment.type === 'Crc32') {
 			continue;
 		}
 
-		if (trackEntrySegment.type !== 'track-entry-segment') {
+		if (trackEntrySegment.type !== 'TrackEntry') {
 			throw new Error('Expected track entry segment');
 		}
 

package/src/boxes/webm/get-sample-from-block.ts

@@ -0,0 +1,125 @@
+import {getArrayBufferIterator} from '../../buffer-iterator';
+import type {ParserContext} from '../../parser-context';
+import type {AudioSample, VideoSample} from '../../webcodec-sample-types';
+import type {BlockSegment, SimpleBlockSegment} from './segments/all-segments';
+import {matroskaElements} from './segments/all-segments';
+import {parseBlockFlags} from './segments/block-simple-block-flags';
+
+type SampleResult =
+	| {
+			type: 'video-sample';
+			videoSample: VideoSample;
+	  }
+	| {
+			type: 'audio-sample';
+			audioSample: AudioSample;
+	  }
+	| {
+			type: 'partial-video-sample';
+			partialVideoSample: Omit<VideoSample, 'type'>;
+	  }
+	| {
+			type: 'no-sample';
+	  };
+
+export const getSampleFromBlock = (
+	ebml: BlockSegment | SimpleBlockSegment,
+	parserContext: ParserContext,
+	offset: number,
+): SampleResult => {
+	const iterator = getArrayBufferIterator(ebml.value, ebml.value.length);
+	const trackNumber = iterator.getVint();
+	if (trackNumber === null) {
+		throw new Error('Not enough data to get track number, should not happen');
+	}
+
+	const timecodeRelativeToCluster = iterator.getUint16();
+
+	const {keyframe} = parseBlockFlags(
+		iterator,
+		ebml.type === 'SimpleBlock'
+			? matroskaElements.SimpleBlock
+			: matroskaElements.Block,
+	);
+
+	const {codec, trackTimescale} =
+		parserContext.parserState.getTrackInfoByNumber(trackNumber);
+
+	const clusterOffset =
+		parserContext.parserState.getTimestampOffsetForByteOffset(offset);
+
+	const timescale = parserContext.parserState.getTimescale();
+
+	if (clusterOffset === undefined) {
+		throw new Error('Could not find offset for byte offset ' + offset);
+	}
+
+	// https://github.com/hubblec4/Matroska-Chapters-Specs/blob/master/notes.md/#timestampscale
+	// The TimestampScale Element is used to calculate the Raw Timestamp of a Block. The timestamp is obtained by adding the Block's timestamp to the Cluster's Timestamp Element, and then multiplying that result by the TimestampScale. The result will be the Block's Raw Timestamp in nanoseconds.
+	const timecodeInNanoSeconds =
+		(timecodeRelativeToCluster + clusterOffset) *
+		timescale *
+		(trackTimescale ?? 1);
+
+	// Timecode should be in microseconds
+	const timecodeInMicroseconds = timecodeInNanoSeconds / 1000;
+
+	if (!codec) {
+		throw new Error(`Could not find codec for track ${trackNumber}`);
+	}
+
+	const remainingNow = ebml.value.length - (iterator.counter.getOffset() - 0);
+
+	if (codec.startsWith('V_')) {
+		const partialVideoSample: Omit<VideoSample, 'type'> = {
+			data: iterator.getSlice(remainingNow),
+			cts: null,
+			dts: null,
+			duration: undefined,
+			trackId: trackNumber,
+			timestamp: timecodeInMicroseconds,
+		};
+
+		if (keyframe === null) {
+			iterator.destroy();
+
+			return {
+				type: 'partial-video-sample',
+				partialVideoSample,
+			};
+		}
+
+		const sample: VideoSample = {
+			...partialVideoSample,
+			type: keyframe ? 'key' : 'delta',
+		};
+
+		iterator.destroy();
+
+		return {
+			type: 'video-sample',
+			videoSample: sample,
+		};
+	}
+
+	if (codec.startsWith('A_')) {
+		const audioSample: AudioSample = {
+			data: iterator.getSlice(remainingNow),
+			trackId: trackNumber,
+			timestamp: timecodeInMicroseconds,
+			type: 'key',
+		};
+
+		iterator.destroy();
+
+		return {
+			type: 'audio-sample',
+			audioSample,
+		};
+	}
+
+	iterator.destroy();
+	return {
+		type: 'no-sample',
+	};
+};

package/src/boxes/webm/get-track.ts

@@ -16,15 +16,16 @@ import {
 } from '../../traversal';
 import {parseAv1PrivateData} from './av1-codec-private';
 import {getAudioDescription} from './description';
-import type {CodecSegment, TrackEntrySegment} from './segments/track-entry';
+import type {CodecIdSegment, TrackEntry} from './segments/all-segments';
+import {trackTypeToString} from './segments/track-entry';
 
-const getDescription = (track: TrackEntrySegment): undefined | Uint8Array => {
+const getDescription = (track: TrackEntry): undefined | Uint8Array => {
 	const codec = getCodecSegment(track);
 	if (!codec) {
 		return undefined;
 	}
 
-	if (codec.codec === 'V_MPEG4/ISO/AVC' || codec.codec === 'V_MPEGH/ISO/HEVC') {
+	if (codec.value === 'V_MPEG4/ISO/AVC' || codec.value === 'V_MPEGH/ISO/HEVC') {
 		const priv = getPrivateData(track);
 		if (priv) {
 			return priv;
@@ -38,14 +39,14 @@ const getMatroskaVideoCodecString = ({
 	track,
 	codecSegment: codec,
 }: {
-	track: TrackEntrySegment;
-	codecSegment: CodecSegment;
+	track: TrackEntry;
+	codecSegment: CodecIdSegment;
 }): string | null => {
-	if (codec.codec === 'V_VP8') {
+	if (codec.value === 'V_VP8') {
 		return 'vp8';
 	}
 
-	if (codec.codec === 'V_VP9') {
+	if (codec.value === 'V_VP9') {
 		const priv = getPrivateData(track);
 		if (priv) {
 			throw new Error(
@@ -56,7 +57,7 @@ const getMatroskaVideoCodecString = ({
 		return 'vp09.00.10.08';
 	}
 
-	if (codec.codec === 'V_MPEG4/ISO/AVC') {
+	if (codec.value === 'V_MPEG4/ISO/AVC') {
 		const priv = getPrivateData(track);
 		if (priv) {
 			return `avc1.${priv[1].toString(16).padStart(2, '0')}${priv[2].toString(16).padStart(2, '0')}${priv[3].toString(16).padStart(2, '0')}`;
@@ -65,7 +66,7 @@ const getMatroskaVideoCodecString = ({
 		throw new Error('Could not find a CodecPrivate field in TrackEntry');
 	}
 
-	if (codec.codec === 'V_AV1') {
+	if (codec.value === 'V_AV1') {
 		const priv = getPrivateData(track);
 
 		if (!priv) {
@@ -75,31 +76,34 @@ const getMatroskaVideoCodecString = ({
 		return parseAv1PrivateData(priv, null);
 	}
 
-	if (codec.codec === 'V_MPEGH/ISO/HEVC') {
+	if (codec.value === 'V_MPEGH/ISO/HEVC') {
 		const priv = getPrivateData(track);
-		const iterator = getArrayBufferIterator(priv as Uint8Array);
+		const iterator = getArrayBufferIterator(
+			priv as Uint8Array,
+			(priv as Uint8Array).length,
+		);
 
 		return 'hvc1.' + getHvc1CodecString(iterator);
 	}
 
-	throw new Error(`Unknown codec: ${codec.codec}`);
+	throw new Error(`Unknown codec: ${codec.value}`);
 };
 
-const getMatroskaAudioCodecString = (track: TrackEntrySegment): string => {
+const getMatroskaAudioCodecString = (track: TrackEntry): string => {
 	const codec = getCodecSegment(track);
 	if (!codec) {
 		throw new Error('Expected codec segment');
 	}
 
-	if (codec.codec === 'A_OPUS') {
+	if (codec.value === 'A_OPUS') {
 		return 'opus';
 	}
 
-	if (codec.codec === 'A_VORBIS') {
+	if (codec.value === 'A_VORBIS') {
 		return 'vorbis';
 	}
 
-	if (codec.codec === 'A_PCM/INT/LIT') {
+	if (codec.value === 'A_PCM/INT/LIT') {
 		// https://github.com/ietf-wg-cellar/matroska-specification/issues/142#issuecomment-330004950
 		// Audio samples MUST be considered as signed values, except if the audio bit depth is 8 which MUST be interpreted as unsigned values.
 
@@ -115,10 +119,13 @@ const getMatroskaAudioCodecString = (track: TrackEntrySegment): string => {
 		return 'pcm-s' + bitDepth;
 	}
 
-	if (codec.codec === 'A_AAC') {
+	if (codec.value === 'A_AAC') {
 		const priv = getPrivateData(track);
 
-		const iterator = getArrayBufferIterator(priv as Uint8Array);
+		const iterator = getArrayBufferIterator(
+			priv as Uint8Array,
+			(priv as Uint8Array).length,
+		);
 
 		iterator.startReadingBits();
 		/**
@@ -150,11 +157,11 @@ const getMatroskaAudioCodecString = (track: TrackEntrySegment): string => {
 		return `mp4a.40.${profile.toString().padStart(2, '0')}`;
 	}
 
-	if (codec.codec === 'A_MPEG/L3') {
+	if (codec.value === 'A_MPEG/L3') {
 		return 'mp3';
 	}
 
-	throw new Error(`Unknown codec: ${codec.codec}`);
+	throw new Error(`Unknown codec: ${codec.value}`);
 };
 
 export const getTrack = ({
@@ -162,7 +169,7 @@ export const getTrack = ({
 	track,
 }: {
 	timescale: number;
-	track: TrackEntrySegment;
+	track: TrackEntry;
 }): VideoTrack | AudioTrack | null => {
 	const trackType = getTrackTypeSegment(track);
 
@@ -172,7 +179,7 @@ export const getTrack = ({
 
 	const trackId = getTrackId(track);
 
-	if (trackType.trackType === 'video') {
+	if (trackTypeToString(trackType.value.value) === 'video') {
 		const width = getWidthSegment(track);
 
 		if (width === null) {
@@ -207,27 +214,27 @@ export const getTrack = ({
 			trackId,
 			codec: codecString,
 			description: getDescription(track),
-			height: displayHeight ? displayHeight.displayHeight : height.height,
-			width: displayWidth ? displayWidth.displayWidth : width.width,
+			height: displayHeight ? displayHeight.value.value : height.value.value,
+			width: displayWidth ? displayWidth.value.value : width.value.value,
 			sampleAspectRatio: {
 				numerator: 1,
 				denominator: 1,
 			},
 			timescale,
-			samplePositions: [],
-			codedHeight: height.height,
-			codedWidth: width.width,
+			codedHeight: height.value.value,
+			codedWidth: width.value.value,
 			displayAspectHeight: displayHeight
-				? displayHeight.displayHeight
-				: height.height,
+				? displayHeight.value.value
+				: height.value.value,
 			displayAspectWidth: displayWidth
-				? displayWidth.displayWidth
-				: width.width,
+				? displayWidth.value.value
+				: width.value.value,
 			rotation: 0,
+			trakBox: null,
 		};
 	}
 
-	if (trackType.trackType === 'audio') {
+	if (trackTypeToString(trackType.value.value) === 'audio') {
 		const sampleRate = getSampleRate(track);
 		const numberOfChannels = getNumberOfChannels(track);
 		if (sampleRate === null) {
@@ -238,11 +245,11 @@ export const getTrack = ({
 			type: 'audio',
 			trackId,
 			codec: getMatroskaAudioCodecString(track),
-			samplePositions: null,
 			timescale,
 			numberOfChannels,
 			sampleRate,
 			description: getAudioDescription(track),
+			trakBox: null,
 		};
 	}
 

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

@@ -1,15 +1,12 @@
 import {getVariableInt} from './ebml';
 import type {
-	Ebml,
-	EbmlWithChildren,
-	EbmlWithHexString,
-	EbmlWithString,
-	EbmlWithUint8,
-	EmblTypes,
-	HeaderStructure,
+	FloatWithSize,
+	PossibleEbml,
+	PossibleEbmlOrUint8Array,
+	UintWithSize,
 	matroskaElements,
 } from './segments/all-segments';
-import {getIdForName} from './segments/all-segments';
+import {ebmlMap, getIdForName} from './segments/all-segments';
 
 export const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
 
@@ -26,24 +23,7 @@ const matroskaToHex = (
 	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) {
+function putUintDynamic(number: number, minimumLength: number | null) {
 	if (number < 0) {
 		throw new Error(
 			'This function is designed for non-negative integers only.',
@@ -51,7 +31,10 @@ function putUintDynamic(number: number) {
 	}
 
 	// Calculate the minimum number of bytes needed to store the integer
-	const length = Math.ceil(Math.log2(number + 1) / 8);
+	const length = Math.max(
+		minimumLength ?? 0,
+		Math.ceil(Math.log2(number + 1) / 8),
+	);
 	const bytes = new Uint8Array(length);
 
 	for (let i = 0; i < length; i++) {
@@ -62,36 +45,42 @@ function putUintDynamic(number: number) {
 	return bytes;
 }
 
-const makeFromHeaderStructure = <Struct extends Ebml>(
-	struct: Struct,
-	fields: SerializeValue<Struct>,
+const makeFromHeaderStructure = (
+	fields: PossibleEbmlOrUint8Array,
 ): Uint8Array => {
+	if (fields instanceof Uint8Array) {
+		return fields;
+	}
+
 	const arrays: Uint8Array[] = [];
 
+	const struct = ebmlMap[getIdForName(fields.type)];
+
+	if (struct.type === 'uint8array') {
+		return fields.value as Uint8Array;
+	}
+
 	if (struct.type === 'children') {
-		for (const item of struct.children) {
-			arrays.push(
-				makeMatroskaHeader(
-					item,
-					// @ts-expect-error
-					fields[item.name],
-				),
-			);
+		for (const item of fields.value as PossibleEbml[]) {
+			arrays.push(makeMatroskaBytes(item));
 		}
 
 		return combineUint8Arrays(arrays);
 	}
 
 	if (struct.type === 'string') {
-		return new TextEncoder().encode(fields as string);
+		return new TextEncoder().encode(fields.value as string);
 	}
 
 	if (struct.type === 'uint') {
-		return putUintDynamic(fields as number);
+		return putUintDynamic(
+			(fields.value as UintWithSize).value,
+			(fields.value as UintWithSize).byteLength,
+		);
 	}
 
 	if (struct.type === 'hex-string') {
-		const hex = (fields as string).substring(2);
+		const hex = (fields.value 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);
@@ -101,27 +90,45 @@ const makeFromHeaderStructure = <Struct extends Ebml>(
 		return arr;
 	}
 
-	if (struct.type === 'void') {
-		throw new Error('Serializing Void is not implemented');
+	if (struct.type === 'float') {
+		const value = fields.value as FloatWithSize;
+		if (value.size === '32') {
+			const dataView = new DataView(new ArrayBuffer(4));
+			dataView.setFloat32(0, value.value);
+			return new Uint8Array(dataView.buffer);
+		}
+
+		const dataView2 = new DataView(new ArrayBuffer(8));
+		dataView2.setFloat64(0, value.value);
+		return new Uint8Array(dataView2.buffer);
 	}
 
 	throw new Error('Unexpected type');
 };
 
-export const makeMatroskaHeader = <Struct extends Ebml>(
-	struct: Struct,
-	fields: SerializeValue<Struct>,
-) => {
-	const value = makeFromHeaderStructure(struct, fields);
+export const makeMatroskaBytes = (fields: PossibleEbmlOrUint8Array) => {
+	if (fields instanceof Uint8Array) {
+		return fields;
+	}
+
+	const value = makeFromHeaderStructure(fields);
 
 	return combineUint8Arrays([
-		matroskaToHex(getIdForName(struct.name)),
-		getVariableInt(value.length),
+		matroskaToHex(getIdForName(fields.type)),
+		getVariableInt(value.length, fields.minVintWidth),
 		value,
 	]);
 };
 
-const combineUint8Arrays = (arrays: Uint8Array[]) => {
+export const combineUint8Arrays = (arrays: Uint8Array[]) => {
+	if (arrays.length === 0) {
+		return new Uint8Array([]);
+	}
+
+	if (arrays.length === 1) {
+		return arrays[0];
+	}
+
 	let totalLength = 0;
 	for (const array of arrays) {
 		totalLength += array.length;