@remotion/media-parser 4.0.192 → 4.0.194

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

@@ -1,6 +1,7 @@
 import type {BufferIterator} from '../../buffer-iterator';
 import type {IsoBaseMediaBox, ParseResult} from '../../parse-result';
 import type {BoxAndNext} from '../../parse-video';
+import {parseEsds} from './esds/esds';
 import {parseFtyp} from './ftyp';
 import {parseMdhd} from './mdhd';
 import {parseMoov} from './moov/moov';
@@ -25,6 +26,7 @@ const getChildren = ({
 		boxType === 'minf' ||
 		boxType === 'stbl' ||
 		boxType === 'dims' ||
+		boxType === 'wave' ||
 		boxType === 'stsb';
 
 	if (parseChildren) {
@@ -42,6 +44,10 @@ const getChildren = ({
 		return parsed.segments;
 	}
 
+	if (bytesRemainingInBox < 0) {
+		throw new Error('Box size is too big ' + JSON.stringify({boxType}));
+	}
+
 	iterator.discard(bytesRemainingInBox);
 	return [];
 };
@@ -62,6 +68,32 @@ const processBox = ({
 	}
 
 	if (bytesRemaining < boxSize) {
+		if (bytesRemaining >= 4) {
+			const type = iterator.getByteString(4);
+			iterator.counter.decrement(4);
+
+			if (type === 'mdat') {
+				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: 'regular-box',
+							boxType: 'mdat',
+							children: [],
+							boxSize,
+							offset: fileOffset,
+						},
+						size: boxSize,
+						skipTo: fileOffset + boxSize,
+					};
+				}
+			}
+		}
+
 		iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
 		if (allowIncompleteBoxes) {
 			return {
@@ -82,6 +114,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -92,6 +125,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -102,6 +136,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -112,6 +147,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -122,6 +158,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -132,6 +169,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -146,6 +184,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -160,6 +199,7 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -174,6 +214,22 @@ const processBox = ({
 			type: 'complete',
 			box,
 			size: boxSize,
+			skipTo: null,
+		};
+	}
+
+	if (boxType === 'esds') {
+		const box = parseEsds({
+			data: iterator,
+			size: boxSize,
+			fileOffset,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+			skipTo: null,
 		};
 	}
 
@@ -196,6 +252,7 @@ const processBox = ({
 			offset: fileOffset,
 		},
 		size: boxSize,
+		skipTo: null,
 	};
 };
 
@@ -237,10 +294,28 @@ export const parseBoxes = ({
 						initialBoxes: boxes,
 					});
 				},
+				skipTo: null,
 			};
 		}
 
 		boxes.push(result.box);
+
+		if (result.skipTo !== null) {
+			return {
+				status: 'incomplete',
+				segments: boxes,
+				continueParsing: () => {
+					return parseBoxes({
+						iterator,
+						maxBytes,
+						allowIncompleteBoxes,
+						initialBoxes: boxes,
+					});
+				},
+				skipTo: result.skipTo,
+			};
+		}
+
 		iterator.discardFirstBytes();
 	}
 

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

@@ -1,4 +1,6 @@
 import type {BufferIterator} from '../../../buffer-iterator';
+import type {AnySegment} from '../../../parse-result';
+import {parseBoxes} from '../process-box';
 
 type SampleBase = {
 	format: string;
@@ -21,6 +23,7 @@ type AudioSample = SampleBase & {
 	bytesPerPacket: number | null;
 	bytesPerFrame: number | null;
 	bitsPerSample: number | null;
+	children: AnySegment[];
 };
 
 type VideoSample = SampleBase & {
@@ -164,7 +167,16 @@ export const processSample = ({
 
 			const bytesRemainingInBox =
 				boxSize - (iterator.counter.getOffset() - fileOffset);
-			iterator.discard(bytesRemainingInBox);
+			const children = parseBoxes({
+				iterator,
+				allowIncompleteBoxes: false,
+				maxBytes: bytesRemainingInBox,
+				initialBoxes: [],
+			});
+
+			if (children.status === 'incomplete') {
+				throw new Error('Incomplete boxes are not allowed');
+			}
 
 			return {
 				sample: {
@@ -185,6 +197,7 @@ export const processSample = ({
 					bytesPerPacket: null,
 					bytesPerFrame: null,
 					bitsPerSample: null,
+					children: children.segments,
 				},
 			};
 		}
@@ -192,17 +205,29 @@ export const processSample = ({
 		if (version === 1) {
 			const numberOfChannels = iterator.getUint16();
 			const sampleSize = iterator.getUint16();
-			const compressionId = iterator.getUint16();
+			const compressionId = iterator.getInt16();
 			const packetSize = iterator.getUint16();
 			const sampleRate = iterator.getFixedPoint1616Number();
-			const samplesPerPacket = iterator.getUint16();
-			const bytesPerPacket = iterator.getUint16();
-			const bytesPerFrame = iterator.getUint16();
-			const bitsPerSample = iterator.getUint16();
+
+			const samplesPerPacket = iterator.getUint32();
+
+			const bytesPerPacket = iterator.getUint32();
+			const bytesPerFrame = iterator.getUint32();
+			const bytesPerSample = iterator.getUint32();
 
 			const bytesRemainingInBox =
 				boxSize - (iterator.counter.getOffset() - fileOffset);
-			iterator.discard(bytesRemainingInBox);
+
+			const children = parseBoxes({
+				iterator,
+				allowIncompleteBoxes: false,
+				maxBytes: bytesRemainingInBox,
+				initialBoxes: [],
+			});
+
+			if (children.status === 'incomplete') {
+				throw new Error('Incomplete boxes are not allowed');
+			}
 
 			return {
 				sample: {
@@ -222,7 +247,8 @@ export const processSample = ({
 					samplesPerPacket,
 					bytesPerPacket,
 					bytesPerFrame,
-					bitsPerSample,
+					bitsPerSample: bytesPerSample,
+					children: children.segments,
 				},
 			};
 		}
@@ -245,6 +271,7 @@ export const processSample = ({
 
 		const bytesRemainingInBox =
 			boxSize - (iterator.counter.getOffset() - fileOffset);
+
 		iterator.discard(bytesRemainingInBox);
 
 		return {

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

@@ -7,12 +7,12 @@ export const parseWebm = (counter: BufferIterator): ParseResult => {
 	counter.discard(4);
 	const length = counter.getVint();
 
-	if (length !== 31) {
-		throw new Error(`Expected header length 31, got ${length}`);
+	if (length !== 31 && length !== 35) {
+		throw new Error(`Expected header length 31 or 25, got ${length}`);
 	}
 
 	// Discard header for now
-	counter.discard(31);
+	counter.discard(length);
 
 	return {status: 'done', segments: [expectSegment(counter)]};
 };

package/src/boxes/webm/segments/track-entry.ts

@@ -278,7 +278,7 @@ export type ColorSegment = {
 export const parseColorSegment = (iterator: BufferIterator): ColorSegment => {
 	const length = iterator.getVint();
 
-	iterator.discard(length - 1);
+	iterator.discard(length);
 
 	return {
 		type: 'color-segment',
@@ -320,3 +320,68 @@ export const parseInterlacedSegment = (
 		interlaced: Boolean(interlaced),
 	};
 };
+
+export type CodecPrivateSegment = {
+	type: 'codec-private-segment';
+	codecPrivateData: number[];
+};
+
+export const parseCodecPrivateSegment = (
+	iterator: BufferIterator,
+): CodecPrivateSegment => {
+	const length = iterator.getVint();
+
+	return {
+		type: 'codec-private-segment',
+		codecPrivateData: [...iterator.getSlice(length)],
+	};
+};
+
+export type Crc32Segment = {
+	type: 'crc32-segment';
+	crc32: number[];
+};
+
+export const parseCrc32Segment = (iterator: BufferIterator): Crc32Segment => {
+	const length = iterator.getVint();
+
+	return {
+		type: 'crc32-segment',
+		crc32: [...iterator.getSlice(length)],
+	};
+};
+
+export type SegmentUUIDSegment = {
+	type: 'segment-uuid-segment';
+	segmentUUID: string;
+};
+
+export const parseSegmentUUIDSegment = (
+	iterator: BufferIterator,
+): SegmentUUIDSegment => {
+	const length = iterator.getVint();
+
+	return {
+		type: 'segment-uuid-segment',
+		segmentUUID: iterator.getSlice(length).toString(),
+	};
+};
+
+export type DefaultFlagSegment = {
+	type: 'default-flag-segment';
+	defaultFlag: boolean;
+};
+
+export const parseDefaultFlagSegment = (
+	iterator: BufferIterator,
+): DefaultFlagSegment => {
+	const length = iterator.getVint();
+	if (length !== 1) {
+		throw new Error('Expected default flag segment to be 1 byte');
+	}
+
+	return {
+		type: 'default-flag-segment',
+		defaultFlag: Boolean(iterator.getUint8()),
+	};
+};

package/src/boxes/webm/segments.ts

@@ -17,14 +17,18 @@ import type {TimestampScaleSegment} from './segments/timestamp-scale';
 import {parseTimestampScaleSegment} from './segments/timestamp-scale';
 import type {
 	AlphaModeSegment,
+	CodecPrivateSegment,
 	CodecSegment,
 	ColorSegment,
+	Crc32Segment,
 	DefaultDurationSegment,
+	DefaultFlagSegment,
 	FlagLacingSegment,
 	HeightSegment,
 	InterlacedSegment,
 	LanguageSegment,
 	MaxBlockAdditionId,
+	SegmentUUIDSegment,
 	TitleSegment,
 	TrackEntrySegment,
 	TrackNumberSegment,
@@ -35,14 +39,18 @@ import type {
 } from './segments/track-entry';
 import {
 	parseAlphaModeSegment,
+	parseCodecPrivateSegment,
 	parseCodecSegment,
 	parseColorSegment,
+	parseCrc32Segment,
 	parseDefaultDurationSegment,
+	parseDefaultFlagSegment,
 	parseFlagLacing,
 	parseHeightSegment,
 	parseInterlacedSegment,
 	parseLanguageSegment,
 	parseMaxBlockAdditionId,
+	parseSegmentUUIDSegment,
 	parseTitleSegment,
 	parseTrackEntry,
 	parseTrackNumber,
@@ -88,7 +96,11 @@ export type MatroskaSegment =
 	| MaxBlockAdditionId
 	| ColorSegment
 	| TitleSegment
-	| InterlacedSegment;
+	| InterlacedSegment
+	| CodecPrivateSegment
+	| Crc32Segment
+	| SegmentUUIDSegment
+	| DefaultFlagSegment;
 
 export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
 	const segmentId = iterator.getMatroskaSegmentId();
@@ -203,10 +215,26 @@ export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
 		return parseAlphaModeSegment(iterator);
 	}
 
+	if (segmentId === '0x63a2') {
+		return parseCodecPrivateSegment(iterator);
+	}
+
 	if (segmentId === '0x7ba9') {
 		return parseTitleSegment(iterator);
 	}
 
+	if (segmentId === '0xbf') {
+		return parseCrc32Segment(iterator);
+	}
+
+	if (segmentId === '0x73a4') {
+		return parseSegmentUUIDSegment(iterator);
+	}
+
+	if (segmentId === '0x88') {
+		return parseDefaultFlagSegment(iterator);
+	}
+
 	const length = iterator.getVint();
 
 	const bytesRemaining = iterator.byteLength() - iterator.counter.getOffset();

package/src/buffer-iterator.ts

@@ -48,8 +48,22 @@ const makeOffsetCounter = (): OffsetCounter => {
 	return new OffsetCounter(0);
 };
 
-export const getArrayBufferIterator = (initialData: Uint8Array) => {
-	let data = initialData;
+export const getArrayBufferIterator = (
+	initialData: Uint8Array,
+	maxBytes?: number,
+) => {
+	const buf = new ArrayBuffer(initialData.byteLength, {
+		maxByteLength: maxBytes ?? 1_000_000_000,
+	});
+	if (!buf.resize) {
+		throw new Error(
+			'`ArrayBuffer.resize` is not supported in this Runtime. Use at least Node.js 20 or Bun.',
+		);
+	}
+
+	let data = new Uint8Array(buf);
+	data.set(initialData);
+
 	let view = new DataView(data.buffer);
 	const counter = makeOffsetCounter();
 
@@ -76,6 +90,15 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 		);
 	};
 
+	const getPaddedFourByteNumber = () => {
+		let lastInt = 128;
+		while (((lastInt = getUint8()), lastInt === 128)) {
+			// Do nothing
+		}
+
+		return lastInt;
+	};
+
 	const getUint32 = () => {
 		const val = view.getUint32(counter.getDiscardedOffset());
 		counter.increment(4);
@@ -83,11 +106,11 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 	};
 
 	const addData = (newData: Uint8Array) => {
-		const newArray = new Uint8Array(
-			data.buffer.byteLength + newData.byteLength,
-		);
-		newArray.set(data);
-		newArray.set(new Uint8Array(newData), data.byteLength);
+		const oldLength = buf.byteLength;
+		const newLength = oldLength + newData.byteLength;
+		buf.resize(newLength);
+		const newArray = new Uint8Array(buf);
+		newArray.set(newData, oldLength);
 		data = newArray;
 		view = new DataView(data.buffer);
 	};
@@ -110,14 +133,28 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 
 	const removeBytesRead = () => {
 		const bytesToRemove = counter.getDiscardedOffset();
+
+		// Only to this operation if it is really worth it 😇
+		if (bytesToRemove < 100_000) {
+			return;
+		}
+
 		counter.discardBytes(bytesToRemove);
-		const newArray = new Uint8Array(data.buffer.byteLength - bytesToRemove);
-		newArray.set(data.slice(bytesToRemove));
-		data = newArray;
+		const newData = data.slice(bytesToRemove);
+		data.set(newData);
+		buf.resize(newData.byteLength);
 		view = new DataView(data.buffer);
 	};
 
+	const skipTo = (offset: number) => {
+		buf.resize(offset);
+		const currentOffset = counter.getOffset();
+		counter.increment(offset - currentOffset);
+		removeBytesRead();
+	};
+
 	return {
+		skipTo,
 		addData,
 		counter,
 		byteLength,
@@ -134,6 +171,7 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 			const atom = getSlice(4);
 			return new TextDecoder().decode(atom);
 		},
+		getPaddedFourByteNumber,
 		getMatroskaSegmentId: () => {
 			const first = getSlice(1);
 			const firstOneString = `0x${Array.from(new Uint8Array(first))
@@ -155,6 +193,9 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 				'0xb0',
 				'0xba',
 				'0x9a',
+				'0xe1',
+				'0xbf',
+				'0x88',
 			];
 			if (knownIdsWithOneLength.includes(firstOneString)) {
 				return firstOneString;
@@ -174,6 +215,8 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 				'0x55ee',
 				'0x55b0',
 				'0x7ba9',
+				'0x63a2',
+				'0x73a4',
 			];
 
 			const firstTwoString = `${firstOneString}${Array.from(
@@ -267,6 +310,7 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 			counter.increment(2);
 			return val;
 		},
+
 		getInt16: () => {
 			const val = view.getInt16(counter.getDiscardedOffset());
 			counter.increment(2);

package/src/from-node.ts

@@ -4,16 +4,23 @@ import {Readable} from 'stream';
 import type {ReaderInterface} from './reader';
 
 export const nodeReader: ReaderInterface = {
-	read: (src, range) => {
+	read: async (src, range) => {
 		const stream = createReadStream(src, {
-			start: range === null ? 0 : range[0],
-			end: range === null ? Infinity : range[1],
+			start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+			end:
+				range === null
+					? Infinity
+					: typeof range === 'number'
+						? Infinity
+						: range[1],
 		});
-		return Promise.resolve(
-			Readable.toWeb(
+		const stats = await stat(src);
+		return {
+			reader: Readable.toWeb(
 				stream,
 			).getReader() as ReadableStreamDefaultReader<Uint8Array>,
-		);
+			contentLength: stats.size,
+		};
 	},
 	getLength: async (src) => {
 		const stats = await stat(src);

package/src/from-web.ts

@@ -23,17 +23,27 @@ export const webReader: ReaderInterface = {
 			headers:
 				range === null
 					? {}
-					: {
-							Range: `bytes=${`${range[0]}-${range[1]}`}`,
-						},
+					: typeof range === 'number'
+						? {
+								Range: `bytes=${range}`,
+							}
+						: {
+								Range: `bytes=${`${range[0]}-${range[1]}`}`,
+							},
+			// Disable Next.js caching
+			cache: 'no-store',
 		});
 		if (!res.body) {
 			throw new Error('No body');
 		}
 
+		const length = res.headers.get('content-length');
+
+		const contentLength = length === null ? null : parseInt(length, 10);
+
 		const reader = res.body.getReader();
 
-		return reader;
+		return {reader, contentLength};
 	},
 	getLength: async (src) => {
 		const res = await fetch(src, {