@remotion/media-parser 4.0.200 → 4.0.202

package/src/boxes/webm/av1-codec-private.ts

@@ -5,7 +5,7 @@ export const parseAv1PrivateData = (
 	data: Uint8Array,
 	colrAtom: ColorParameterBox | null,
 ) => {
-	const iterator = getArrayBufferIterator(data);
+	const iterator = getArrayBufferIterator(data, data.byteLength);
 	iterator.startReadingBits();
 	if (iterator.getBits(1) !== 1) {
 		iterator.destroy();

package/src/boxes/webm/description.ts

@@ -1,12 +1,12 @@
 import {getArrayBufferIterator} from '../../buffer-iterator';
 import {getCodecSegment, getPrivateData} from '../../traversal';
-import type {TrackEntrySegment} from './segments/track-entry';
+import type {TrackEntry} from './segments/all-segments';
 
 export const getAudioDescription = (
-	track: TrackEntrySegment,
+	track: TrackEntry,
 ): undefined | Uint8Array => {
 	const codec = getCodecSegment(track);
-	if (!codec || codec.codec !== 'A_VORBIS') {
+	if (!codec || codec.value !== 'A_VORBIS') {
 		return undefined;
 	}
 
@@ -59,7 +59,10 @@ export const getAudioDescription = (
 
 	const vorbisBooks = privateData.slice(offset);
 
-	const bufferIterator = getArrayBufferIterator(vorbisInfo.slice(0));
+	const bufferIterator = getArrayBufferIterator(
+		vorbisInfo.slice(0),
+		vorbisInfo.length,
+	);
 
 	// type
 	bufferIterator.getUint8();

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,
 		};
 	}
 
-	if (trackType.trackType === 'audio') {
+	if (trackTypeToString(trackType.value.value) === 'audio') {
 		const sampleRate = getSampleRate(track);
 		const numberOfChannels = getNumberOfChannels(track);
 		if (sampleRate === null) {

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

@@ -1,48 +1,145 @@
 import {getVariableInt} from './ebml';
-import {matroskaElements} from './segments/all-segments';
+import type {
+	FloatWithSize,
+	PossibleEbml,
+	PossibleEbmlOrUint8Array,
+	UintWithSize,
+	matroskaElements,
+} from './segments/all-segments';
+import {ebmlMap, getIdForName} from './segments/all-segments';
 
 export const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
 
 const matroskaToHex = (
 	matrId: (typeof matroskaElements)[keyof typeof matroskaElements],
 ) => {
-	const numbers: number[] = [];
+	const numbers: Uint8Array = new Uint8Array((matrId.length - 2) / 2);
+
 	for (let i = 2; i < matrId.length; i += 2) {
-		const hex = matrId.substr(i, 2);
-		numbers.push(parseInt(hex, 16));
+		const hex = matrId.substring(i, i + 2);
+		numbers[(i - 2) / 2] = parseInt(hex, 16);
 	}
 
 	return numbers;
 };
 
-export const makeMatroskaHeader = () => {
-	const size = 0x23;
-
-	const array = new Uint8Array([
-		...webmPattern,
-		...getVariableInt(size),
-		...matroskaToHex(matroskaElements.EBMLVersion),
-		...getVariableInt(1),
-		1,
-		...matroskaToHex(matroskaElements.EBMLReadVersion),
-		...getVariableInt(1),
-		1,
-		...matroskaToHex(matroskaElements.EBMLMaxIDLength),
-		...getVariableInt(1),
-		4,
-		...matroskaToHex(matroskaElements.EBMLMaxSizeLength),
-		...getVariableInt(1),
-		8,
-		...matroskaToHex(matroskaElements.DocType),
-		...getVariableInt(8),
-		...new TextEncoder().encode('matroska'),
-		...matroskaToHex(matroskaElements.DocTypeVersion),
-		...getVariableInt(1),
-		4,
-		...matroskaToHex(matroskaElements.DocTypeReadVersion),
-		...getVariableInt(1),
-		2,
+function putUintDynamic(number: number, minimumLength: number | null) {
+	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.max(
+		minimumLength ?? 0,
+		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 = (
+	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 fields.value as PossibleEbml[]) {
+			arrays.push(makeMatroskaBytes(item));
+		}
+
+		return combineUint8Arrays(arrays);
+	}
+
+	if (struct.type === 'string') {
+		return new TextEncoder().encode(fields.value as string);
+	}
+
+	if (struct.type === 'uint') {
+		return putUintDynamic(
+			(fields.value as UintWithSize).value,
+			(fields.value as UintWithSize).byteLength,
+		);
+	}
+
+	if (struct.type === 'hex-string') {
+		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);
+			arr[i / 2] = byte;
+		}
+
+		return arr;
+	}
+
+	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 makeMatroskaBytes = (fields: PossibleEbmlOrUint8Array) => {
+	if (fields instanceof Uint8Array) {
+		return fields;
+	}
+
+	const value = makeFromHeaderStructure(fields);
+
+	return combineUint8Arrays([
+		matroskaToHex(getIdForName(fields.type)),
+		getVariableInt(value.length, fields.minVintWidth),
+		value,
 	]);
+};
+
+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;
+	}
+
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const array of arrays) {
+		result.set(array, offset);
+		offset += array.length;
+	}
 
-	return array;
+	return result;
 };