@remotion/media-parser 4.0.200 → 4.0.201

package/dist/web-file.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputTypeFileReader = void 0;
+exports.inputTypeFileReader = {
+    read: (file, range) => {
+        if (typeof file === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        if (range !== null) {
+            throw new Error('`inputTypeFileReader` does not support `range`');
+        }
+        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);
+    },
+};

package/package.json

@@ -3,11 +3,11 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.200",
+  "version": "4.0.201",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.200"
+    "@remotion/renderer": "4.0.201"
   },
   "publishConfig": {
     "access": "public"

package/src/boxes/iso-base-media/mdat/mdat.ts

@@ -26,7 +26,7 @@ export const parseMdat = async ({
 }): Promise<MdatBox> => {
 	const alreadyHas = hasTracks(existingBoxes);
 	if (!alreadyHas) {
-		data.discard(size - 8);
+		data.discard(size - (data.counter.getOffset() - fileOffset));
 		return Promise.resolve({
 			type: 'mdat-box',
 			boxSize: size,
@@ -116,6 +116,7 @@ export const parseMdat = async ({
 		}
 
 		const remaining = size - (data.counter.getOffset() - fileOffset);
+		data.removeBytesRead();
 		if (remaining === 0) {
 			break;
 		}

package/src/boxes/iso-base-media/moov/moov.ts

@@ -27,6 +27,7 @@ export const parseMoov = async ({
 		initialBoxes: [],
 		options,
 		continueMdat: false,
+		littleEndian: false,
 	});
 
 	if (children.status === 'incomplete') {

package/src/boxes/iso-base-media/process-box.ts

@@ -37,11 +37,13 @@ const getChildren = async ({
 	iterator,
 	bytesRemainingInBox,
 	options,
+	littleEndian,
 }: {
 	boxType: string;
 	iterator: BufferIterator;
 	bytesRemainingInBox: number;
 	options: ParserContext;
+	littleEndian: boolean;
 }) => {
 	const parseChildren =
 		boxType === 'mdia' ||
@@ -59,6 +61,7 @@ const getChildren = async ({
 			initialBoxes: [],
 			options,
 			continueMdat: false,
+			littleEndian,
 		});
 
 		if (parsed.status === 'incomplete') {
@@ -121,17 +124,37 @@ export const processBox = async ({
 	allowIncompleteBoxes,
 	parsedBoxes,
 	options,
+	littleEndian,
 }: {
 	iterator: BufferIterator;
 	allowIncompleteBoxes: boolean;
 	parsedBoxes: AnySegment[];
 	options: ParserContext;
+	littleEndian: boolean;
 }): Promise<BoxAndNext> => {
 	const fileOffset = iterator.counter.getOffset();
 	const bytesRemaining = iterator.bytesRemaining();
 
-	const boxSize = iterator.getFourByteNumber();
-	if (boxSize === 0) {
+	const boxSizeRaw = iterator.getFourByteNumber(littleEndian);
+
+	// If `boxSize === 1`, the 8 bytes after the box type are the size of the box.
+	if (
+		(boxSizeRaw === 1 && iterator.bytesRemaining() < 12) ||
+		iterator.bytesRemaining() < 4
+	) {
+		iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
+		if (allowIncompleteBoxes) {
+			return {
+				type: 'incomplete',
+			};
+		}
+
+		throw new Error(
+			`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`,
+		);
+	}
+
+	if (boxSizeRaw === 0) {
 		return {
 			type: 'complete',
 			box: {
@@ -143,42 +166,41 @@ export const processBox = async ({
 		};
 	}
 
+	const boxType = iterator.getByteString(4);
+
+	const boxSize =
+		boxSizeRaw === 1 ? iterator.getEightByteNumber(littleEndian) : boxSizeRaw;
+
 	if (bytesRemaining < boxSize) {
-		if (bytesRemaining >= 4) {
-			const type = iterator.getByteString(4);
-			iterator.counter.decrement(4);
-
-			if (type === 'mdat') {
-				const shouldSkip = options.canSkipVideoData || !hasTracks(parsedBoxes);
-
-				if (shouldSkip) {
-					const skipTo = fileOffset + boxSize;
-					const bytesToSkip = skipTo - iterator.counter.getOffset();
-
-					// If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
-					if (bytesToSkip > 1_000_000) {
-						return {
-							type: 'complete',
-							box: {
-								type: 'mdat-box',
-								boxSize,
-								fileOffset,
-								samplesProcessed: false,
-							},
-							size: boxSize,
-							skipTo: fileOffset + boxSize,
-						};
-					}
-				} else {
-					iterator.discard(4);
-					return parseMdatPartially({
-						iterator,
-						boxSize,
-						fileOffset,
-						parsedBoxes,
-						options,
-					});
+		if (boxType === 'mdat') {
+			const shouldSkip = options.canSkipVideoData || !hasTracks(parsedBoxes);
+
+			if (shouldSkip) {
+				const skipTo = fileOffset + boxSize;
+				const bytesToSkip = skipTo - iterator.counter.getOffset();
+
+				// If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
+				if (bytesToSkip > 1_000_000) {
+					return {
+						type: 'complete',
+						box: {
+							type: 'mdat-box',
+							boxSize,
+							fileOffset,
+							samplesProcessed: false,
+						},
+						size: boxSize,
+						skipTo: fileOffset + boxSize,
+					};
 				}
+			} else {
+				return parseMdatPartially({
+					iterator,
+					boxSize,
+					fileOffset,
+					parsedBoxes,
+					options,
+				});
 			}
 		}
 
@@ -194,8 +216,6 @@ export const processBox = async ({
 		);
 	}
 
-	const boxType = iterator.getByteString(4);
-
 	if (boxType === 'ftyp') {
 		const box = parseFtyp({iterator, size: boxSize, offset: fileOffset});
 		return {
@@ -271,11 +291,12 @@ export const processBox = async ({
 		};
 	}
 
-	if (boxType === 'stco') {
+	if (boxType === 'stco' || boxType === 'co64') {
 		const box = parseStco({
 			iterator,
 			offset: fileOffset,
 			size: boxSize,
+			mode64Bit: boxType === 'co64',
 		});
 
 		return {
@@ -352,6 +373,7 @@ export const processBox = async ({
 			offset: fileOffset,
 			size: boxSize,
 			options,
+			littleEndian,
 		});
 
 		return {
@@ -525,6 +547,7 @@ export const processBox = async ({
 		iterator,
 		bytesRemainingInBox,
 		options,
+		littleEndian,
 	});
 
 	return {
@@ -548,6 +571,7 @@ export const parseBoxes = async ({
 	initialBoxes,
 	options,
 	continueMdat,
+	littleEndian,
 }: {
 	iterator: BufferIterator;
 	maxBytes: number;
@@ -555,6 +579,7 @@ export const parseBoxes = async ({
 	initialBoxes: IsoBaseMediaBox[];
 	options: ParserContext;
 	continueMdat: false | PartialMdatBox;
+	littleEndian: boolean;
 }): Promise<ParseResult> => {
 	let boxes: IsoBaseMediaBox[] = initialBoxes;
 	const initialOffset = iterator.counter.getOffset();
@@ -577,6 +602,7 @@ export const parseBoxes = async ({
 					allowIncompleteBoxes,
 					parsedBoxes: initialBoxes,
 					options,
+					littleEndian,
 				});
 
 		if (result.type === 'incomplete') {
@@ -595,6 +621,7 @@ export const parseBoxes = async ({
 						initialBoxes: boxes,
 						options,
 						continueMdat: false,
+						littleEndian,
 					});
 				},
 				skipTo: null,
@@ -614,6 +641,7 @@ export const parseBoxes = async ({
 							initialBoxes: boxes,
 							options,
 							continueMdat: result,
+							littleEndian,
 						}),
 					);
 				},
@@ -641,13 +669,14 @@ export const parseBoxes = async ({
 						initialBoxes: boxes,
 						options,
 						continueMdat: false,
+						littleEndian,
 					});
 				},
 				skipTo: result.skipTo,
 			};
 		}
 
-		iterator.discardFirstBytes();
+		iterator.removeBytesRead();
 	}
 
 	const mdatState = hasSkippedMdatProcessing(boxes);
@@ -663,6 +692,7 @@ export const parseBoxes = async ({
 					initialBoxes: boxes,
 					options,
 					continueMdat: false,
+					littleEndian,
 				});
 			},
 			skipTo: mdatState.fileOffset,

package/src/boxes/iso-base-media/stsd/mebx.ts

@@ -16,11 +16,13 @@ export const parseMebx = async ({
 	offset,
 	size,
 	options,
+	littleEndian,
 }: {
 	iterator: BufferIterator;
 	offset: number;
 	size: number;
 	options: ParserContext;
+	littleEndian: boolean;
 }): Promise<MebxBox> => {
 	// reserved, 6 bit
 	iterator.discard(6);
@@ -34,6 +36,7 @@ export const parseMebx = async ({
 		initialBoxes: [],
 		options,
 		continueMdat: false,
+		littleEndian,
 	});
 
 	if (children.status === 'incomplete') {

package/src/boxes/iso-base-media/stsd/samples.ts

@@ -179,6 +179,7 @@ export const processSample = async ({
 				initialBoxes: [],
 				options,
 				continueMdat: false,
+				littleEndian: false,
 			});
 
 			if (children.status === 'incomplete') {
@@ -232,6 +233,7 @@ export const processSample = async ({
 				initialBoxes: [],
 				options,
 				continueMdat: false,
+				littleEndian: false,
 			});
 
 			if (children.status === 'incomplete') {
@@ -288,6 +290,7 @@ export const processSample = async ({
 			initialBoxes: [],
 			options,
 			continueMdat: false,
+			littleEndian: false,
 		});
 
 		if (children.status === 'incomplete') {

package/src/boxes/iso-base-media/stsd/stco.ts

@@ -6,17 +6,19 @@ export interface StcoBox extends BaseBox {
 	version: number;
 	flags: number[];
 	entryCount: number;
-	entries: number[];
+	entries: (number | bigint)[];
 }
 
 export const parseStco = ({
 	iterator,
 	offset,
 	size,
+	mode64Bit,
 }: {
 	iterator: BufferIterator;
 	offset: number;
 	size: number;
+	mode64Bit: boolean;
 }): StcoBox => {
 	const version = iterator.getUint8();
 	if (version !== 0) {
@@ -26,14 +28,14 @@ export const parseStco = ({
 	const flags = iterator.getSlice(3);
 	const entryCount = iterator.getUint32();
 
-	const entries: number[] = [];
+	const entries: (number | bigint)[] = [];
 	for (let i = 0; i < entryCount; i++) {
 		const bytesRemaining = size - (iterator.counter.getOffset() - offset);
 		if (bytesRemaining < 4) {
 			break;
 		}
 
-		entries.push(iterator.getUint32());
+		entries.push(mode64Bit ? iterator.getUint64() : iterator.getUint32());
 	}
 
 	iterator.discard(size - (iterator.counter.getOffset() - offset));

package/src/boxes/iso-base-media/trak/trak.ts

@@ -27,6 +27,7 @@ export const parseTrak = async ({
 		initialBoxes: [],
 		options,
 		continueMdat: false,
+		littleEndian: false,
 	});
 
 	if (children.status === 'incomplete') {

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

@@ -1,48 +1,138 @@
 import {getVariableInt} from './ebml';
-import {matroskaElements} from './segments/all-segments';
+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: 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,
+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 array;
+	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}`);
+};