@remotion/media-parser 4.0.208 → 4.0.210

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

@@ -1,257 +0,0 @@
-import {getArrayBufferIterator} from '../../buffer-iterator';
-import type {AudioTrack, VideoTrack} from '../../get-tracks';
-import {getHvc1CodecString} from '../../make-hvc1-codec-strings';
-import {
-	getBitDepth,
-	getCodecSegment,
-	getDisplayHeightSegment,
-	getDisplayWidthSegment,
-	getHeightSegment,
-	getNumberOfChannels,
-	getPrivateData,
-	getSampleRate,
-	getTrackId,
-	getTrackTypeSegment,
-	getWidthSegment,
-} from '../../traversal';
-import {parseAv1PrivateData} from './av1-codec-private';
-import {getAudioDescription} from './description';
-import type {CodecIdSegment, TrackEntry} from './segments/all-segments';
-import {trackTypeToString} from './segments/track-entry';
-
-const getDescription = (track: TrackEntry): undefined | Uint8Array => {
-	const codec = getCodecSegment(track);
-	if (!codec) {
-		return undefined;
-	}
-
-	if (codec.value === 'V_MPEG4/ISO/AVC' || codec.value === 'V_MPEGH/ISO/HEVC') {
-		const priv = getPrivateData(track);
-		if (priv) {
-			return priv;
-		}
-	}
-
-	return undefined;
-};
-
-const getMatroskaVideoCodecString = ({
-	track,
-	codecSegment: codec,
-}: {
-	track: TrackEntry;
-	codecSegment: CodecIdSegment;
-}): string | null => {
-	if (codec.value === 'V_VP8') {
-		return 'vp8';
-	}
-
-	if (codec.value === 'V_VP9') {
-		const priv = getPrivateData(track);
-		if (priv) {
-			throw new Error(
-				'@remotion/media-parser cannot handle the private data for VP9. Do you have an example file you could send so we can implement it?',
-			);
-		}
-
-		return 'vp09.00.10.08';
-	}
-
-	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')}`;
-		}
-
-		throw new Error('Could not find a CodecPrivate field in TrackEntry');
-	}
-
-	if (codec.value === 'V_AV1') {
-		const priv = getPrivateData(track);
-
-		if (!priv) {
-			throw new Error('Expected private data in AV1 track');
-		}
-
-		return parseAv1PrivateData(priv, null);
-	}
-
-	if (codec.value === 'V_MPEGH/ISO/HEVC') {
-		const priv = getPrivateData(track);
-		const iterator = getArrayBufferIterator(
-			priv as Uint8Array,
-			(priv as Uint8Array).length,
-		);
-
-		return 'hvc1.' + getHvc1CodecString(iterator);
-	}
-
-	throw new Error(`Unknown codec: ${codec.value}`);
-};
-
-const getMatroskaAudioCodecString = (track: TrackEntry): string => {
-	const codec = getCodecSegment(track);
-	if (!codec) {
-		throw new Error('Expected codec segment');
-	}
-
-	if (codec.value === 'A_OPUS') {
-		return 'opus';
-	}
-
-	if (codec.value === 'A_VORBIS') {
-		return 'vorbis';
-	}
-
-	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.
-
-		const bitDepth = getBitDepth(track);
-		if (bitDepth === null) {
-			throw new Error('Expected bit depth');
-		}
-
-		if (bitDepth === 8) {
-			return 'pcm-u8';
-		}
-
-		return 'pcm-s' + bitDepth;
-	}
-
-	if (codec.value === 'A_AAC') {
-		const priv = getPrivateData(track);
-
-		const iterator = getArrayBufferIterator(
-			priv as Uint8Array,
-			(priv as Uint8Array).length,
-		);
-
-		iterator.startReadingBits();
-		/**
-		 * ChatGPT
-		 * 	▪	The first 5 bits represent the AOT.
-				▪	Common values:
-				◦	1 for AAC Main
-				◦	2 for AAC LC (Low Complexity)
-				◦	3 for AAC SSR (Scalable Sample Rate)
-				◦	4 for AAC LTP (Long Term Prediction)
-				◦	5 for SBR (Spectral Band Replication)
-				◦	29 for HE-AAC (which uses SBR with AAC LC)
-		 */
-		/** 
-		 * Fully qualified codec: 
-		 * This codec has multiple possible codec strings:
-			"mp4a.40.2" — MPEG-4 AAC LC
-			"mp4a.40.02" — MPEG-4 AAC LC, leading 0 for Aud-OTI compatibility
-			"mp4a.40.5" — MPEG-4 HE-AAC v1 (AAC LC + SBR)
-			"mp4a.40.05" — MPEG-4 HE-AAC v1 (AAC LC + SBR), leading 0 for Aud-OTI compatibility
-			"mp4a.40.29" — MPEG-4 HE-AAC v2 (AAC LC + SBR + PS)
-			"mp4a.67" — MPEG-2 AAC LC
-		*/
-
-		const profile = iterator.getBits(5);
-		iterator.stopReadingBits();
-		iterator.destroy();
-
-		return `mp4a.40.${profile.toString().padStart(2, '0')}`;
-	}
-
-	if (codec.value === 'A_MPEG/L3') {
-		return 'mp3';
-	}
-
-	throw new Error(`Unknown codec: ${codec.value}`);
-};
-
-export const getTrack = ({
-	timescale,
-	track,
-}: {
-	timescale: number;
-	track: TrackEntry;
-}): VideoTrack | AudioTrack | null => {
-	const trackType = getTrackTypeSegment(track);
-
-	if (!trackType) {
-		throw new Error('Expected track type segment');
-	}
-
-	const trackId = getTrackId(track);
-
-	if (trackTypeToString(trackType.value.value) === 'video') {
-		const width = getWidthSegment(track);
-
-		if (width === null) {
-			throw new Error('Expected width segment');
-		}
-
-		const height = getHeightSegment(track);
-
-		if (height === null) {
-			throw new Error('Expected height segment');
-		}
-
-		const displayHeight = getDisplayHeightSegment(track);
-		const displayWidth = getDisplayWidthSegment(track);
-
-		const codec = getCodecSegment(track);
-		if (!codec) {
-			return null;
-		}
-
-		const codecString = getMatroskaVideoCodecString({
-			track,
-			codecSegment: codec,
-		});
-
-		if (!codecString) {
-			return null;
-		}
-
-		return {
-			type: 'video',
-			trackId,
-			codec: codecString,
-			description: getDescription(track),
-			height: displayHeight ? displayHeight.value.value : height.value.value,
-			width: displayWidth ? displayWidth.value.value : width.value.value,
-			sampleAspectRatio: {
-				numerator: 1,
-				denominator: 1,
-			},
-			timescale,
-			codedHeight: height.value.value,
-			codedWidth: width.value.value,
-			displayAspectHeight: displayHeight
-				? displayHeight.value.value
-				: height.value.value,
-			displayAspectWidth: displayWidth
-				? displayWidth.value.value
-				: width.value.value,
-			rotation: 0,
-			trakBox: null,
-		};
-	}
-
-	if (trackTypeToString(trackType.value.value) === 'audio') {
-		const sampleRate = getSampleRate(track);
-		const numberOfChannels = getNumberOfChannels(track);
-		if (sampleRate === null) {
-			throw new Error('Could not find sample rate or number of channels');
-		}
-
-		return {
-			type: 'audio',
-			trackId,
-			codec: getMatroskaAudioCodecString(track),
-			timescale,
-			numberOfChannels,
-			sampleRate,
-			description: getAudioDescription(track),
-			trakBox: null,
-		};
-	}
-
-	return null;
-};

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

@@ -1,253 +0,0 @@
-import {getVariableInt} from './ebml';
-import type {
-	BytesAndOffset,
-	FloatWithSize,
-	OffsetAndChildren,
-	PossibleEbml,
-	PossibleEbmlOrUint8Array,
-	UintWithSize,
-} from './segments/all-segments';
-import {
-	ebmlMap,
-	getIdForName,
-	incrementOffsetAndChildren,
-	matroskaElements,
-} from './segments/all-segments';
-
-export const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
-
-export 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;
-};
-
-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 makeFromStructure = (
-	fields: PossibleEbmlOrUint8Array,
-): BytesAndOffset => {
-	if ('bytes' in fields) {
-		return fields;
-	}
-
-	const arrays: Uint8Array[] = [];
-
-	const struct = ebmlMap[getIdForName(fields.type)];
-
-	if (struct.type === 'uint8array') {
-		return {
-			bytes: fields.value as Uint8Array,
-			offsets: {offset: 0, children: [], field: fields.type},
-		};
-	}
-
-	if (struct.type === 'children') {
-		const children: OffsetAndChildren[] = [];
-		let bytesWritten = 0;
-		for (const item of fields.value as PossibleEbml[]) {
-			const {bytes, offsets} = makeMatroskaBytes(item);
-			arrays.push(bytes);
-			children.push(incrementOffsetAndChildren(offsets, bytesWritten));
-			bytesWritten += bytes.byteLength;
-		}
-
-		return {
-			bytes: combineUint8Arrays(arrays),
-			offsets: {offset: 0, children, field: fields.type},
-		};
-	}
-
-	if (struct.type === 'string') {
-		return {
-			bytes: new TextEncoder().encode(fields.value as string),
-			offsets: {
-				children: [],
-				offset: 0,
-				field: fields.type,
-			},
-		};
-	}
-
-	if (struct.type === 'uint') {
-		return {
-			bytes: putUintDynamic(
-				(fields.value as UintWithSize).value,
-				(fields.value as UintWithSize).byteLength,
-			),
-			offsets: {
-				children: [],
-				offset: 0,
-				field: fields.type,
-			},
-		};
-	}
-
-	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 {
-			bytes: arr,
-			offsets: {
-				children: [],
-				offset: 0,
-				field: fields.type,
-			},
-		};
-	}
-
-	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 {
-				bytes: new Uint8Array(dataView.buffer),
-				offsets: {
-					children: [],
-					offset: 0,
-					field: fields.type,
-				},
-			};
-		}
-
-		const dataView2 = new DataView(new ArrayBuffer(8));
-		dataView2.setFloat64(0, value.value);
-		return {
-			bytes: new Uint8Array(dataView2.buffer),
-			offsets: {
-				children: [],
-				offset: 0,
-				field: fields.type,
-			},
-		};
-	}
-
-	throw new Error('Unexpected type');
-};
-
-export const makeMatroskaBytes = (
-	fields: PossibleEbmlOrUint8Array,
-): BytesAndOffset => {
-	if ('bytes' in fields) {
-		return fields;
-	}
-
-	const value = makeFromStructure(fields);
-	const header = matroskaToHex(getIdForName(fields.type));
-	const size = getVariableInt(value.bytes.length, fields.minVintWidth);
-
-	const bytes = combineUint8Arrays([header, size, value.bytes]);
-
-	return {
-		bytes,
-		offsets: {
-			offset: value.offsets.offset,
-			field: value.offsets.field,
-			children: value.offsets.children.map((c) => {
-				return incrementOffsetAndChildren(
-					c,
-					header.byteLength + size.byteLength,
-				);
-			}),
-		},
-	};
-};
-
-export const padMatroskaBytes = (
-	fields: PossibleEbmlOrUint8Array,
-	totalLength: number,
-): BytesAndOffset[] => {
-	const regular = makeMatroskaBytes(fields);
-	const paddingLength =
-		totalLength -
-		regular.bytes.byteLength -
-		matroskaToHex(matroskaElements.Void).byteLength;
-
-	if (paddingLength < 0) {
-		throw new Error('ooops');
-	}
-
-	const padding = makeMatroskaBytes({
-		type: 'Void',
-		value: new Uint8Array(paddingLength).fill(0),
-		minVintWidth: null,
-	});
-
-	return [
-		regular,
-		{
-			bytes: padding.bytes,
-			offsets: incrementOffsetAndChildren(
-				padding.offsets,
-				regular.bytes.length,
-			),
-		},
-	];
-};
-
-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 result;
-};
-
-export function serializeUint16(value: number): Uint8Array {
-	const buffer = new ArrayBuffer(2);
-
-	const view = new DataView(buffer);
-
-	view.setUint16(0, value);
-
-	return new Uint8Array(buffer);
-}