@remotion/media-parser 4.0.194 → 4.0.196

package/src/buffer-iterator.ts

@@ -1,3 +1,9 @@
+import {
+	knownIdsWithOneLength,
+	knownIdsWithThreeLength,
+	knownIdsWithTwoLength,
+} from './boxes/webm/segments/all-segments';
+
 export class OffsetCounter {
 	#offset: number;
 	#discardedBytes: number;
@@ -22,6 +28,10 @@ export class OffsetCounter {
 		return this.#offset - this.#discardedBytes;
 	}
 
+	setDiscardedOffset(offset: number) {
+		this.#discardedBytes = offset;
+	}
+
 	discardBytes(amount: number) {
 		this.#discardedBytes += amount;
 	}
@@ -37,6 +47,7 @@ export class OffsetCounter {
 
 const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
 const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
+const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
 
 const matchesPattern = (pattern: Uint8Array) => {
 	return (data: Uint8Array) => {
@@ -57,7 +68,7 @@ export const getArrayBufferIterator = (
 	});
 	if (!buf.resize) {
 		throw new Error(
-			'`ArrayBuffer.resize` is not supported in this Runtime. Use at least Node.js 20 or Bun.',
+			'`ArrayBuffer.resize` is not supported in this Runtime. On the server: Use at least Node.js 20 or Bun. In the browser: Chrome 111, Edge 111, Safari 16.4, Firefox 128, Opera 111',
 		);
 	}
 
@@ -105,6 +116,24 @@ export const getArrayBufferIterator = (
 		return val;
 	};
 
+	const getUint32Le = () => {
+		const val = view.getUint32(counter.getDiscardedOffset(), true);
+		counter.increment(4);
+		return val;
+	};
+
+	const getInt32Le = () => {
+		const val = view.getInt32(counter.getDiscardedOffset(), true);
+		counter.increment(4);
+		return val;
+	};
+
+	const getInt32 = () => {
+		const val = view.getInt32(counter.getDiscardedOffset());
+		counter.increment(4);
+		return val;
+	};
+
 	const addData = (newData: Uint8Array) => {
 		const oldLength = buf.byteLength;
 		const newLength = oldLength + newData.byteLength;
@@ -131,6 +160,10 @@ export const getArrayBufferIterator = (
 		return matchesPattern(webmPattern)(data.subarray(0, 4));
 	};
 
+	const isMp3 = () => {
+		return matchesPattern(mpegPattern)(data.subarray(0, 4));
+	};
+
 	const removeBytesRead = () => {
 		const bytesToRemove = counter.getDiscardedOffset();
 
@@ -147,19 +180,102 @@ export const getArrayBufferIterator = (
 	};
 
 	const skipTo = (offset: number) => {
-		buf.resize(offset);
-		const currentOffset = counter.getOffset();
-		counter.increment(offset - currentOffset);
-		removeBytesRead();
+		const becomesSmaller = offset < counter.getOffset();
+		if (becomesSmaller) {
+			buf.resize(0);
+			counter.decrement(counter.getOffset() - offset);
+			counter.setDiscardedOffset(offset);
+		} else {
+			buf.resize(offset);
+			const currentOffset = counter.getOffset();
+			counter.increment(offset - currentOffset);
+			removeBytesRead();
+		}
+	};
+
+	const peekB = (length: number) => {
+		// eslint-disable-next-line no-console
+		console.log(
+			[...getSlice(length)].map((b) => b.toString(16).padStart(2, '0')),
+		);
+		counter.decrement(length);
+	};
+
+	const peekD = (length: number) => {
+		// eslint-disable-next-line no-console
+		console.log([...getSlice(length)].map((b) => b));
+		counter.decrement(length);
+	};
+
+	const leb128 = () => {
+		let result = 0;
+		let shift = 0;
+		let byte;
+
+		do {
+			byte = getBits(8);
+			result |= (byte & 0x7f) << shift;
+			shift += 7;
+		} while (byte >= 0x80); // Continue if the high bit is set
+
+		return result;
+	};
+
+	let bitIndex = 0;
+
+	const stopReadingBits = () => {
+		bitIndex = 0;
+	};
+
+	let byteToShift = 0;
+
+	const startReadingBits = () => {
+		byteToShift = getUint8();
+	};
+
+	const getBits = (bits: number) => {
+		let result = 0;
+		let bitsCollected = 0;
+
+		while (bitsCollected < bits) {
+			if (bitIndex >= 8) {
+				bitIndex = 0;
+				byteToShift = getUint8();
+			}
+
+			const remainingBitsInByte = 8 - bitIndex;
+			const bitsToReadNow = Math.min(bits - bitsCollected, remainingBitsInByte);
+			const mask = (1 << bitsToReadNow) - 1;
+			const shift = remainingBitsInByte - bitsToReadNow;
+
+			result <<= bitsToReadNow;
+			result |= (byteToShift >> shift) & mask;
+
+			bitsCollected += bitsToReadNow;
+			bitIndex += bitsToReadNow;
+		}
+
+		return result;
+	};
+
+	const destroy = () => {
+		data = new Uint8Array(0);
+		buf.resize(0);
 	};
 
 	return {
+		startReadingBits,
+		stopReadingBits,
 		skipTo,
 		addData,
 		counter,
+		peekB,
+		peekD,
+		getBits,
 		byteLength,
 		bytesRemaining,
 		isIsoBaseMedia,
+		leb128,
 		discardFirstBytes: removeBytesRead,
 		isWebm,
 		discard: (length: number) => {
@@ -182,43 +298,13 @@ export const getArrayBufferIterator = (
 
 			// Catch void block
 			// https://www.matroska.org/technical/elements.html
-			const knownIdsWithOneLength = [
-				'0xec',
-				'0xae',
-				'0xd7',
-				'0x9c',
-				'0x86',
-				'0x83',
-				'0xe0',
-				'0xb0',
-				'0xba',
-				'0x9a',
-				'0xe1',
-				'0xbf',
-				'0x88',
-			];
+
 			if (knownIdsWithOneLength.includes(firstOneString)) {
 				return firstOneString;
 			}
 
 			const firstTwo = getSlice(1);
 
-			const knownIdsWithTwoLength = [
-				'0x4dbb',
-				'0x53ac',
-				'0xec01',
-				'0x73c5',
-				'0x53c0',
-				'0x4d80',
-				'0x5741',
-				'0x4489',
-				'0x55ee',
-				'0x55b0',
-				'0x7ba9',
-				'0x63a2',
-				'0x73a4',
-			];
-
 			const firstTwoString = `${firstOneString}${Array.from(
 				new Uint8Array(firstTwo),
 			)
@@ -231,14 +317,6 @@ export const getArrayBufferIterator = (
 				return firstTwoString;
 			}
 
-			const knownIdsWithThreeLength = [
-				'0x4d808c',
-				'0x57418c',
-				'0x448988',
-				'0x22b59c',
-				'0x23e383',
-			];
-
 			const firstThree = getSlice(1);
 
 			const firstThreeString = `${firstTwoString}${Array.from(
@@ -319,10 +397,18 @@ export const getArrayBufferIterator = (
 		getUint32,
 		// https://developer.apple.com/documentation/quicktime-file-format/sound_sample_description_version_1
 		// A 32-bit unsigned fixed-point number (16.16) that indicates the rate at which the sound samples were obtained.
-		getFixedPoint1616Number: () => {
+		getFixedPointUnsigned1616Number: () => {
 			const val = getUint32();
 			return val / 2 ** 16;
 		},
+		getFixedPointSigned1616Number: () => {
+			const val = getInt32();
+			return val / 2 ** 16;
+		},
+		getFixedPointSigned230Number: () => {
+			const val = getInt32();
+			return val / 2 ** 30;
+		},
 		getPascalString: () => {
 			const val = getSlice(32);
 			return [...Array.from(new Uint8Array(val))];
@@ -345,6 +431,15 @@ export const getArrayBufferIterator = (
 			counter.increment(8);
 			return val;
 		},
+		getFloat32: () => {
+			const val = view.getFloat32(counter.getDiscardedOffset());
+			counter.increment(4);
+			return val;
+		},
+		getUint32Le,
+		getInt32Le,
+		destroy,
+		isMp3,
 	};
 };
 

package/src/combine-uint8array.ts

@@ -0,0 +1,13 @@
+export const combineUint8Arrays = (
+	array1: Uint8Array | null,
+	array2: Uint8Array,
+) => {
+	if (!array1) {
+		return array2;
+	}
+
+	const combined = new Uint8Array(array1.length + array2.length);
+	combined.set(array1);
+	combined.set(array2, array1.length);
+	return combined;
+};

package/src/{from-web.ts → from-fetch.ts}

@@ -1,7 +1,11 @@
 import type {ReaderInterface} from './reader';
 
-export const webReader: ReaderInterface = {
+export const fetchReader: ReaderInterface = {
 	read: async (src, range) => {
+		if (typeof src !== 'string') {
+			throw new Error('src must be a string when using `webReader`');
+		}
+
 		const resolvedUrl =
 			typeof window !== 'undefined' && typeof window.location !== 'undefined'
 				? new URL(src, window.location.origin).toString()
@@ -46,6 +50,10 @@ export const webReader: ReaderInterface = {
 		return {reader, contentLength};
 	},
 	getLength: async (src) => {
+		if (typeof src !== 'string') {
+			throw new Error('src must be a string when using `webReader`');
+		}
+
 		const res = await fetch(src, {
 			method: 'HEAD',
 		});

package/src/from-node.ts

@@ -5,6 +5,10 @@ import type {ReaderInterface} from './reader';
 
 export const nodeReader: ReaderInterface = {
 	read: async (src, range) => {
+		if (typeof src !== 'string') {
+			throw new Error('src must be a string when using `nodeReader`');
+		}
+
 		const stream = createReadStream(src, {
 			start: range === null ? 0 : typeof range === 'number' ? range : range[0],
 			end:
@@ -23,6 +27,10 @@ export const nodeReader: ReaderInterface = {
 		};
 	},
 	getLength: async (src) => {
+		if (typeof src !== 'string') {
+			throw new Error('src must be a string when using `nodeReader`');
+		}
+
 		const stats = await stat(src);
 		return stats.size;
 	},

package/src/from-web-file.ts

@@ -0,0 +1,39 @@
+import type {ReaderInterface} from './reader';
+
+export const webFileReader: ReaderInterface = {
+	read: (file, range) => {
+		if (typeof file === 'string') {
+			throw new Error('`inputTypeFileReader` only supports `File` objects');
+		}
+
+		const part =
+			range === null
+				? file
+				: typeof range === 'number'
+					? file.slice(range)
+					: file.slice(range[0], range[1]);
+
+		const reader = new FileReader();
+		reader.readAsArrayBuffer(file);
+
+		return new Promise((resolve, reject) => {
+			reader.onload = () => {
+				resolve({
+					reader: part.stream().getReader(),
+					contentLength: file.size,
+				});
+			};
+
+			reader.onerror = (error) => {
+				reject(error);
+			};
+		});
+	},
+	getLength: (src) => {
+		if (typeof src === 'string') {
+			throw new Error('`inputTypeFileReader` only supports `File` objects');
+		}
+
+		return Promise.resolve(src.size);
+	},
+};