@remotion/media-parser 4.0.193 → 4.0.195

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

@@ -1,25 +1,47 @@
+/* eslint-disable max-depth */
 import type {BufferIterator} from '../../buffer-iterator';
-import type {IsoBaseMediaBox, ParseResult} from '../../parse-result';
-import type {BoxAndNext} from '../../parse-video';
+import {hasTracks} from '../../get-tracks';
+import type {
+	AnySegment,
+	IsoBaseMediaBox,
+	ParseResult,
+} from '../../parse-result';
+import type {BoxAndNext, PartialMdatBox} from '../../parse-video';
+import type {ParserContext} from '../../parser-context';
+import {hasSkippedMdatProcessing} from '../../traversal';
 import {parseEsds} from './esds/esds';
 import {parseFtyp} from './ftyp';
+import {makeBaseMediaTrack} from './make-track';
+import {parseMdat} from './mdat/mdat';
 import {parseMdhd} from './mdhd';
 import {parseMoov} from './moov/moov';
 import {parseMvhd} from './mvhd';
+import {parseAv1C} from './stsd/av1c';
+import {parseAvcc} from './stsd/avcc';
+import {parseColorParameterBox} from './stsd/colr';
+import {parseCtts} from './stsd/ctts';
+import {parseHvcc} from './stsd/hvcc';
 import {parseMebx} from './stsd/mebx';
+import {parsePasp} from './stsd/pasp';
+import {parseStco} from './stsd/stco';
+import {parseStsc} from './stsd/stsc';
 import {parseStsd} from './stsd/stsd';
-import {parseStts} from './stts/stts';
+import {parseStss} from './stsd/stss';
+import {parseStsz} from './stsd/stsz';
+import {parseStts} from './stsd/stts';
 import {parseTkhd} from './tkhd';
 import {parseTrak} from './trak/trak';
 
-const getChildren = ({
+const getChildren = async ({
 	boxType,
 	iterator,
 	bytesRemainingInBox,
+	options,
 }: {
 	boxType: string;
 	iterator: BufferIterator;
 	bytesRemainingInBox: number;
+	options: ParserContext;
 }) => {
 	const parseChildren =
 		boxType === 'mdia' ||
@@ -30,11 +52,13 @@ const getChildren = ({
 		boxType === 'stsb';
 
 	if (parseChildren) {
-		const parsed = parseBoxes({
+		const parsed = await parseBoxes({
 			iterator,
 			maxBytes: bytesRemainingInBox,
 			allowIncompleteBoxes: false,
 			initialBoxes: [],
+			options,
+			continueMdat: false,
 		});
 
 		if (parsed.status === 'incomplete') {
@@ -52,22 +76,112 @@ const getChildren = ({
 	return [];
 };
 
-const processBox = ({
+export const parseMdatPartially = async ({
+	iterator,
+	boxSize,
+	fileOffset,
+	parsedBoxes,
+	options,
+}: {
+	iterator: BufferIterator;
+	boxSize: number;
+	fileOffset: number;
+	parsedBoxes: AnySegment[];
+	options: ParserContext;
+}): Promise<BoxAndNext> => {
+	const box = await parseMdat({
+		data: iterator,
+		size: boxSize,
+		fileOffset,
+		existingBoxes: parsedBoxes,
+		options,
+	});
+
+	if (
+		box.samplesProcessed &&
+		box.fileOffset + boxSize === iterator.counter.getOffset()
+	) {
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	return {
+		type: 'partial-mdat-box',
+		boxSize,
+		fileOffset,
+	};
+};
+
+export const processBox = async ({
 	iterator,
 	allowIncompleteBoxes,
+	parsedBoxes,
+	options,
 }: {
 	iterator: BufferIterator;
 	allowIncompleteBoxes: boolean;
-}): BoxAndNext => {
+	parsedBoxes: AnySegment[];
+	options: ParserContext;
+}): Promise<BoxAndNext> => {
 	const fileOffset = iterator.counter.getOffset();
 	const bytesRemaining = iterator.bytesRemaining();
 
 	const boxSize = iterator.getFourByteNumber();
 	if (boxSize === 0) {
-		throw new Error(`Expected box size of not 0, got ${boxSize}`);
+		return {
+			type: 'complete',
+			box: {
+				type: 'void-box',
+				boxSize: 0,
+			},
+			size: 4,
+			skipTo: null,
+		};
 	}
 
 	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,
+					});
+				}
+			}
+		}
+
 		iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
 		if (allowIncompleteBoxes) {
 			return {
@@ -88,6 +202,19 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'colr') {
+		const box = parseColorParameterBox({
+			iterator,
+		});
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -98,6 +225,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -108,50 +236,179 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
 	if (boxType === 'stsd') {
-		const box = parseStsd({iterator, offset: fileOffset, size: boxSize});
+		const box = await parseStsd({
+			iterator,
+			offset: fileOffset,
+			size: boxSize,
+			options,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'stsz') {
+		const box = parseStsz({
+			iterator,
+			offset: fileOffset,
+			size: boxSize,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'stco') {
+		const box = parseStco({
+			iterator,
+			offset: fileOffset,
+			size: boxSize,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'pasp') {
+		const box = parsePasp({
+			iterator,
+			offset: fileOffset,
+			size: boxSize,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'stss') {
+		const box = parseStss({
+			iterator,
+			offset: fileOffset,
+			boxSize,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'ctts') {
+		const box = parseCtts({
+			iterator,
+			offset: fileOffset,
+			size: boxSize,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'stsc') {
+		const box = parseStsc({
+			iterator,
+			offset: fileOffset,
+			size: boxSize,
+		});
 
 		return {
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
 	if (boxType === 'mebx') {
-		const box = parseMebx({iterator, offset: fileOffset, size: boxSize});
+		const box = await parseMebx({
+			iterator,
+			offset: fileOffset,
+			size: boxSize,
+			options,
+		});
 
 		return {
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
 	if (boxType === 'moov') {
-		const box = parseMoov({iterator, offset: fileOffset, size: boxSize});
+		const box = await parseMoov({
+			iterator,
+			offset: fileOffset,
+			size: boxSize,
+			options,
+		});
 
 		return {
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
 	if (boxType === 'trak') {
-		const box = parseTrak({
+		const box = await parseTrak({
 			data: iterator,
 			size: boxSize,
 			offsetAtStart: fileOffset,
+			options,
 		});
+		const transformedTrack = makeBaseMediaTrack(box);
+		if (transformedTrack) {
+			if (transformedTrack.type === 'audio') {
+				const callback = await options.onAudioTrack?.(transformedTrack);
+				await options.parserState.registerAudioSampleCallback(
+					transformedTrack.trackId,
+					callback ?? null,
+				);
+			}
+
+			if (transformedTrack.type === 'video') {
+				const callback = await options.onVideoTrack?.(transformedTrack);
+				await options.parserState.registerVideoSampleCallback(
+					transformedTrack.trackId,
+					callback ?? null,
+				);
+			}
+		}
 
 		return {
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -166,6 +423,50 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'avcC') {
+		const box = parseAvcc({
+			data: iterator,
+			size: boxSize,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'av1C') {
+		const box = parseAv1C({
+			data: iterator,
+			size: boxSize,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'hvcC') {
+		const box = parseHvcc({
+			data: iterator,
+			size: boxSize,
+			offset: fileOffset,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -180,6 +481,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -194,16 +496,35 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'mdat') {
+		const box = await parseMdat({
+			data: iterator,
+			size: boxSize,
+			fileOffset,
+			existingBoxes: parsedBoxes,
+			options,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
 		};
 	}
 
 	const bytesRemainingInBox =
 		boxSize - (iterator.counter.getOffset() - fileOffset);
 
-	const children = getChildren({
+	const children = await getChildren({
 		boxType,
 		iterator,
 		bytesRemainingInBox,
+		options,
 	});
 
 	return {
@@ -216,31 +537,48 @@ const processBox = ({
 			offset: fileOffset,
 		},
 		size: boxSize,
+		skipTo: null,
 	};
 };
 
-export const parseBoxes = ({
+export const parseBoxes = async ({
 	iterator,
 	maxBytes,
 	allowIncompleteBoxes,
 	initialBoxes,
+	options,
+	continueMdat,
 }: {
 	iterator: BufferIterator;
 	maxBytes: number;
 	allowIncompleteBoxes: boolean;
 	initialBoxes: IsoBaseMediaBox[];
-}): ParseResult => {
-	const boxes: IsoBaseMediaBox[] = initialBoxes;
+	options: ParserContext;
+	continueMdat: false | PartialMdatBox;
+}): Promise<ParseResult> => {
+	let boxes: IsoBaseMediaBox[] = initialBoxes;
 	const initialOffset = iterator.counter.getOffset();
+	const alreadyHasMdat = boxes.find((b) => b.type === 'mdat-box');
 
 	while (
 		iterator.bytesRemaining() > 0 &&
 		iterator.counter.getOffset() - initialOffset < maxBytes
 	) {
-		const result = processBox({
-			iterator,
-			allowIncompleteBoxes,
-		});
+		const result = continueMdat
+			? await parseMdatPartially({
+					iterator,
+					boxSize: continueMdat.boxSize,
+					fileOffset: continueMdat.fileOffset,
+					parsedBoxes: initialBoxes,
+					options,
+				})
+			: await processBox({
+					iterator,
+					allowIncompleteBoxes,
+					parsedBoxes: initialBoxes,
+					options,
+				});
+
 		if (result.type === 'incomplete') {
 			if (Number.isFinite(maxBytes)) {
 				throw new Error('maxBytes must be Infinity for top-level boxes');
@@ -255,15 +593,82 @@ export const parseBoxes = ({
 						maxBytes,
 						allowIncompleteBoxes,
 						initialBoxes: boxes,
+						options,
+						continueMdat: false,
+					});
+				},
+				skipTo: null,
+			};
+		}
+
+		if (result.type === 'partial-mdat-box') {
+			return {
+				status: 'incomplete',
+				segments: boxes,
+				continueParsing: () => {
+					return Promise.resolve(
+						parseBoxes({
+							iterator,
+							maxBytes,
+							allowIncompleteBoxes,
+							initialBoxes: boxes,
+							options,
+							continueMdat: result,
+						}),
+					);
+				},
+				skipTo: null,
+			};
+		}
+
+		if (result.box.type === 'mdat-box' && alreadyHasMdat) {
+			boxes = boxes.filter((b) => b.type !== 'mdat-box');
+			boxes.push(result.box);
+			break;
+		} else {
+			boxes.push(result.box);
+		}
+
+		if (result.skipTo !== null) {
+			return {
+				status: 'incomplete',
+				segments: boxes,
+				continueParsing: () => {
+					return parseBoxes({
+						iterator,
+						maxBytes,
+						allowIncompleteBoxes,
+						initialBoxes: boxes,
+						options,
+						continueMdat: false,
 					});
 				},
+				skipTo: result.skipTo,
 			};
 		}
 
-		boxes.push(result.box);
 		iterator.discardFirstBytes();
 	}
 
+	const mdatState = hasSkippedMdatProcessing(boxes);
+	if (mdatState.skipped && !options.canSkipVideoData) {
+		return {
+			status: 'incomplete',
+			segments: boxes,
+			continueParsing: () => {
+				return parseBoxes({
+					iterator,
+					maxBytes,
+					allowIncompleteBoxes,
+					initialBoxes: boxes,
+					options,
+					continueMdat: false,
+				});
+			},
+			skipTo: mdatState.fileOffset,
+		};
+	}
+
 	return {
 		status: 'done',
 		segments: boxes,

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

@@ -0,0 +1,19 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export interface Av1CBox {
+	type: 'av1C-box';
+	privateData: Uint8Array;
+}
+
+export const parseAv1C = ({
+	data,
+	size,
+}: {
+	data: BufferIterator;
+	size: number;
+}): Av1CBox => {
+	return {
+		type: 'av1C-box',
+		privateData: data.getSlice(size - 8),
+	};
+};

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

@@ -0,0 +1,36 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export interface AvccBox {
+	type: 'avcc-box';
+	description: Uint8Array;
+	configurationString: string;
+}
+
+export const parseAvcc = ({
+	data,
+	size,
+}: {
+	data: BufferIterator;
+	size: number;
+}): AvccBox => {
+	const confVersion = data.getUint8();
+	if (confVersion !== 1) {
+		throw new Error(`Unsupported AVCC version ${confVersion}`);
+	}
+
+	const profile = data.getUint8();
+	const profileCompatibility = data.getUint8();
+	const level = data.getUint8();
+
+	const str = `${profile.toString(16).padStart(2, '0')}${profileCompatibility.toString(16).padStart(2, '0')}${level.toString(16).padStart(2, '0')}`;
+
+	data.counter.decrement(4);
+
+	const description = data.getSlice(size - 8);
+
+	return {
+		type: 'avcc-box',
+		description,
+		configurationString: str,
+	};
+};

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

@@ -0,0 +1,49 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export interface ColorParameterBox {
+	type: 'colr-box';
+	primaries: number;
+	transfer: number;
+	matrixIndex: number;
+	fullRangeFlag: boolean;
+}
+
+export const parseColorParameterBox = ({
+	iterator,
+}: {
+	iterator: BufferIterator;
+}): ColorParameterBox => {
+	const byteString = iterator.getByteString(4);
+	if (byteString === 'nclx') {
+		const primaries = iterator.getUint16();
+		const transfer = iterator.getUint16();
+		const matrixIndex = iterator.getUint16();
+		iterator.startReadingBits();
+		const fullRangeFlag = Boolean(iterator.getBits(1));
+		iterator.stopReadingBits();
+
+		return {
+			type: 'colr-box',
+			fullRangeFlag,
+			matrixIndex,
+			primaries,
+			transfer,
+		};
+	}
+
+	if (byteString === 'nclc') {
+		const primaries = iterator.getUint16();
+		const transfer = iterator.getUint16();
+		const matrixIndex = iterator.getUint16();
+
+		return {
+			type: 'colr-box',
+			fullRangeFlag: false,
+			matrixIndex,
+			primaries,
+			transfer,
+		};
+	}
+
+	throw new Error('Unexpected box type ' + byteString);
+};