@remotion/media-parser 4.0.200 → 4.0.202

package/src/buffer-iterator.ts

@@ -48,6 +48,7 @@ export class OffsetCounter {
 
 const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
 const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
+const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
 
 const matchesPattern = (pattern: Uint8Array) => {
 	return (data: Uint8Array) => {
@@ -61,10 +62,13 @@ const makeOffsetCounter = (): OffsetCounter => {
 
 export const getArrayBufferIterator = (
 	initialData: Uint8Array,
-	maxBytes?: number,
+	maxBytes: number | null,
 ) => {
 	const buf = new ArrayBuffer(initialData.byteLength, {
-		maxByteLength: maxBytes ?? 1_000_000_000,
+		maxByteLength:
+			maxBytes === null
+				? initialData.byteLength
+				: Math.min(maxBytes as number, 2 ** 32),
 	});
 	if (!buf.resize) {
 		throw new Error(
@@ -95,7 +99,61 @@ export const getArrayBufferIterator = (
 		return val;
 	};
 
-	const getFourByteNumber = () => {
+	const getEightByteNumber = (littleEndian = false) => {
+		if (littleEndian) {
+			const one = getUint8();
+			const two = getUint8();
+			const three = getUint8();
+			const four = getUint8();
+			const five = getUint8();
+			const six = getUint8();
+			const seven = getUint8();
+			const eight = getUint8();
+
+			return (
+				(eight << 56) |
+				(seven << 48) |
+				(six << 40) |
+				(five << 32) |
+				(four << 24) |
+				(three << 16) |
+				(two << 8) |
+				one
+			);
+		}
+
+		function byteArrayToBigInt(byteArray: number[]): BigInt {
+			let result = BigInt(0);
+			for (let i = 0; i < byteArray.length; i++) {
+				result = (result << BigInt(8)) + BigInt(byteArray[i]);
+			}
+
+			return result;
+		}
+
+		const bigInt = byteArrayToBigInt([
+			getUint8(),
+			getUint8(),
+			getUint8(),
+			getUint8(),
+			getUint8(),
+			getUint8(),
+			getUint8(),
+			getUint8(),
+		]);
+
+		return Number(bigInt);
+	};
+
+	const getFourByteNumber = (littleEndian = false) => {
+		if (littleEndian) {
+			const one = getUint8();
+			const two = getUint8();
+			const three = getUint8();
+			const four = getUint8();
+			return (four << 24) | (three << 16) | (two << 8) | one;
+		}
+
 		return (
 			(getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8()
 		);
@@ -110,12 +168,18 @@ export const getArrayBufferIterator = (
 		return lastInt;
 	};
 
-	const getUint32 = () => {
-		const val = view.getUint32(counter.getDiscardedOffset());
+	const getUint32 = (littleEndian = false) => {
+		const val = view.getUint32(counter.getDiscardedOffset(), littleEndian);
 		counter.increment(4);
 		return val;
 	};
 
+	const getUint64 = (littleEndian = false) => {
+		const val = view.getBigUint64(counter.getDiscardedOffset(), littleEndian);
+		counter.increment(8);
+		return val;
+	};
+
 	const getUint32Le = () => {
 		const val = view.getUint32(counter.getDiscardedOffset(), true);
 		counter.increment(4);
@@ -156,6 +220,10 @@ export const getArrayBufferIterator = (
 		return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
 	};
 
+	const isRiff = () => {
+		return matchesPattern(riffPattern)(data.subarray(0, 4));
+	};
+
 	const isWebm = () => {
 		return matchesPattern(webmPattern)(data.subarray(0, 4));
 	};
@@ -186,7 +254,6 @@ export const getArrayBufferIterator = (
 			counter.decrement(counter.getOffset() - offset);
 			counter.setDiscardedOffset(offset);
 		} else {
-			buf.resize(offset);
 			const currentOffset = counter.getOffset();
 			counter.increment(offset - currentOffset);
 			removeBytesRead();
@@ -276,19 +343,25 @@ export const getArrayBufferIterator = (
 		bytesRemaining,
 		isIsoBaseMedia,
 		leb128,
-		discardFirstBytes: removeBytesRead,
+		removeBytesRead,
 		isWebm,
 		discard: (length: number) => {
 			counter.increment(length);
 		},
+		getEightByteNumber,
 		getFourByteNumber,
 		getSlice,
 		getAtom: () => {
 			const atom = getSlice(4);
 			return new TextDecoder().decode(atom);
 		},
+		isRiff,
 		getPaddedFourByteNumber,
-		getMatroskaSegmentId: () => {
+		getMatroskaSegmentId: (): string | null => {
+			if (bytesRemaining() === 0) {
+				return null;
+			}
+
 			const first = getSlice(1);
 			const firstOneString = `0x${Array.from(new Uint8Array(first))
 				.map((b) => {
@@ -303,6 +376,10 @@ export const getArrayBufferIterator = (
 				return firstOneString;
 			}
 
+			if (bytesRemaining() === 0) {
+				return null;
+			}
+
 			const firstTwo = getSlice(1);
 
 			const firstTwoString = `${firstOneString}${Array.from(
@@ -317,6 +394,10 @@ export const getArrayBufferIterator = (
 				return firstTwoString;
 			}
 
+			if (bytesRemaining() === 0) {
+				return null;
+			}
+
 			const firstThree = getSlice(1);
 
 			const firstThreeString = `${firstTwoString}${Array.from(
@@ -331,6 +412,10 @@ export const getArrayBufferIterator = (
 				return firstThreeString;
 			}
 
+			if (bytesRemaining() === 0) {
+				return null;
+			}
+
 			const segmentId = getSlice(1);
 
 			return `${firstThreeString}${Array.from(new Uint8Array(segmentId))
@@ -339,7 +424,11 @@ export const getArrayBufferIterator = (
 				})
 				.join('')}`;
 		},
-		getVint: () => {
+		getVint: (): number | null => {
+			if (bytesRemaining() === 0) {
+				return null;
+			}
+
 			const firstByte = getUint8();
 			const totalLength = firstByte;
 
@@ -353,6 +442,10 @@ export const getArrayBufferIterator = (
 				actualLength++;
 			}
 
+			if (bytesRemaining() < actualLength) {
+				return null;
+			}
+
 			const slice = getSlice(actualLength);
 			const d = [firstByte, ...Array.from(new Uint8Array(slice))];
 
@@ -402,6 +495,7 @@ export const getArrayBufferIterator = (
 			return val;
 		},
 		getUint32,
+		getUint64,
 		// 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.
 		getFixedPointUnsigned1616Number: () => {
@@ -420,7 +514,7 @@ export const getArrayBufferIterator = (
 			const val = getSlice(32);
 			return [...Array.from(new Uint8Array(val))];
 		},
-		getDecimalBytes(length: number): number {
+		getUint(length: number): number {
 			const bytes = getSlice(length);
 			const numbers = [...Array.from(new Uint8Array(bytes))];
 			return numbers.reduce(

package/src/from-fetch.ts

@@ -1,9 +1,9 @@
 import type {ReaderInterface} from './reader';
 
 export const fetchReader: ReaderInterface = {
-	read: async (src, range) => {
+	read: async (src, range, signal) => {
 		if (typeof src !== 'string') {
-			throw new Error('src must be a string when using `webReader`');
+			throw new Error('src must be a string when using `fetchReader`');
 		}
 
 		const resolvedUrl =
@@ -34,9 +34,18 @@ export const fetchReader: ReaderInterface = {
 						: {
 								Range: `bytes=${`${range[0]}-${range[1]}`}`,
 							},
+			signal,
 			// Disable Next.js caching
 			cache: 'no-store',
 		});
+
+		if (
+			res.status.toString().startsWith('4') ||
+			res.status.toString().startsWith('5')
+		) {
+			throw new Error(`Server returned status code ${res.status} for ${src}`);
+		}
+
 		if (!res.body) {
 			throw new Error('No body');
 		}
@@ -47,11 +56,21 @@ export const fetchReader: ReaderInterface = {
 
 		const reader = res.body.getReader();
 
+		if (signal) {
+			signal.addEventListener(
+				'abort',
+				() => {
+					reader.cancel();
+				},
+				{once: true},
+			);
+		}
+
 		return {reader, contentLength};
 	},
 	getLength: async (src) => {
 		if (typeof src !== 'string') {
-			throw new Error('src must be a string when using `webReader`');
+			throw new Error('src must be a string when using `fetchReader`');
 		}
 
 		const res = await fetch(src, {

package/src/from-node.ts

@@ -4,7 +4,7 @@ import {Readable} from 'stream';
 import type {ReaderInterface} from './reader';
 
 export const nodeReader: ReaderInterface = {
-	read: async (src, range) => {
+	read: async (src, range, signal) => {
 		if (typeof src !== 'string') {
 			throw new Error('src must be a string when using `nodeReader`');
 		}
@@ -17,12 +17,26 @@ export const nodeReader: ReaderInterface = {
 					: typeof range === 'number'
 						? Infinity
 						: range[1],
+			signal,
 		});
 		const stats = await stat(src);
+
+		const reader = Readable.toWeb(
+			stream,
+		).getReader() as ReadableStreamDefaultReader<Uint8Array>;
+
+		if (signal) {
+			signal.addEventListener(
+				'abort',
+				() => {
+					reader.cancel();
+				},
+				{once: true},
+			);
+		}
+
 		return {
-			reader: Readable.toWeb(
-				stream,
-			).getReader() as ReadableStreamDefaultReader<Uint8Array>,
+			reader,
 			contentLength: stats.size,
 		};
 	},

package/src/from-web-file.ts

@@ -1,7 +1,7 @@
 import type {ReaderInterface} from './reader';
 
 export const webFileReader: ReaderInterface = {
-	read: (file, range) => {
+	read: (file, range, signal) => {
 		if (typeof file === 'string') {
 			throw new Error('`inputTypeFileReader` only supports `File` objects');
 		}
@@ -16,6 +16,16 @@ export const webFileReader: ReaderInterface = {
 		const reader = new FileReader();
 		reader.readAsArrayBuffer(file);
 
+		if (signal) {
+			signal.addEventListener(
+				'abort',
+				() => {
+					reader.abort();
+				},
+				{once: true},
+			);
+		}
+
 		return new Promise((resolve, reject) => {
 			reader.onload = () => {
 				resolve({

package/src/get-audio-codec.ts

@@ -3,7 +3,7 @@ import type {EsdsBox} from './boxes/iso-base-media/esds/esds';
 import type {MoovBox} from './boxes/iso-base-media/moov/moov';
 import type {AudioSample} from './boxes/iso-base-media/stsd/samples';
 import type {TrakBox} from './boxes/iso-base-media/trak/trak';
-import type {MainSegment} from './boxes/webm/segments/main';
+import type {MainSegment} from './boxes/webm/segments/all-segments';
 import {trakBoxContainsAudio} from './get-fps';
 import type {KnownAudioCodecs} from './options';
 import type {AnySegment} from './parse-result';
@@ -163,34 +163,32 @@ export const getAudioCodecFromIso = (moov: MoovBox) => {
 };
 
 export const getAudioCodecFromMatroska = (mainSegment: MainSegment) => {
-	const tracksSegment = mainSegment.children.find(
-		(b) => b.type === 'tracks-segment',
-	);
-	if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+	const tracksSegment = mainSegment.value.find((b) => b.type === 'Tracks');
+	if (!tracksSegment || tracksSegment.type !== 'Tracks') {
 		return null;
 	}
 
-	for (const track of tracksSegment.children) {
-		if (track.type === 'track-entry-segment') {
-			const trackType = track.children.find((b) => b.type === 'codec-segment');
-			if (trackType && trackType.type === 'codec-segment') {
-				if (trackType.codec === 'A_OPUS') {
+	for (const track of tracksSegment.value) {
+		if (track.type === 'TrackEntry') {
+			const trackType = track.value.find((b) => b.type === 'CodecID');
+			if (trackType && trackType.type === 'CodecID') {
+				if (trackType.value === 'A_OPUS') {
 					return 'opus';
 				}
 
-				if (trackType.codec === 'A_VORBIS') {
+				if (trackType.value === 'A_VORBIS') {
 					return 'vorbis';
 				}
 
-				if (trackType.codec === 'A_PCM/INT/LIT') {
+				if (trackType.value === 'A_PCM/INT/LIT') {
 					return 'pcm';
 				}
 
-				if (trackType.codec === 'A_AAC') {
+				if (trackType.value === 'A_AAC') {
 					return 'aac';
 				}
 
-				if (trackType.codec === 'A_MPEG/L3') {
+				if (trackType.value === 'A_MPEG/L3') {
 					return 'mp3';
 				}
 			}
@@ -263,8 +261,8 @@ export const getAudioCodec = (boxes: AnySegment[]): KnownAudioCodecs | null => {
 		throw new Error('Unknown audio format: ' + codec.format);
 	}
 
-	const mainSegment = boxes.find((b) => b.type === 'main-segment');
-	if (!mainSegment || mainSegment.type !== 'main-segment') {
+	const mainSegment = boxes.find((b) => b.type === 'Segment');
+	if (!mainSegment || mainSegment.type !== 'Segment') {
 		return null;
 	}
 

package/src/get-duration.ts

@@ -1,43 +1,42 @@
+import type {DurationSegment} from './boxes/webm/segments/all-segments';
 import type {AnySegment} from './parse-result';
 import {getMoovBox, getMvhdBox} from './traversal';
 
 const getDurationFromMatroska = (segments: AnySegment[]): number | null => {
-	const mainSegment = segments.find((s) => s.type === 'main-segment');
-	if (!mainSegment || mainSegment.type !== 'main-segment') {
+	const mainSegment = segments.find((s) => s.type === 'Segment');
+	if (!mainSegment || mainSegment.type !== 'Segment') {
 		return null;
 	}
 
-	const {children} = mainSegment;
+	const {value: children} = mainSegment;
 	if (!children) {
 		return null;
 	}
 
-	const infoSegment = children.find((s) => s.type === 'info-segment');
+	const infoSegment = children.find((s) => s.type === 'Info');
 
 	const relevantBoxes = [
-		...mainSegment.children,
-		...(infoSegment && infoSegment.type === 'info-segment'
-			? infoSegment.children
-			: []),
+		...mainSegment.value,
+		...(infoSegment && infoSegment.type === 'Info' ? infoSegment.value : []),
 	];
 
-	const timestampScale = relevantBoxes.find(
-		(s) => s.type === 'timestamp-scale-segment',
-	);
-	if (!timestampScale || timestampScale.type !== 'timestamp-scale-segment') {
+	const timestampScale = relevantBoxes.find((s) => s.type === 'TimestampScale');
+	if (!timestampScale || timestampScale.type !== 'TimestampScale') {
 		return null;
 	}
 
-	const duration = relevantBoxes.find((s) => s.type === 'duration-segment');
-	if (!duration || duration.type !== 'duration-segment') {
+	const duration = relevantBoxes.find(
+		(s) => s.type === 'Duration',
+	) as DurationSegment;
+	if (!duration || duration.type !== 'Duration') {
 		return null;
 	}
 
-	return (duration.duration / timestampScale.timestampScale) * 1000;
+	return (duration.value.value / timestampScale.value.value) * 1000;
 };
 
 export const getDuration = (boxes: AnySegment[]): number | null => {
-	const matroskaBox = boxes.find((b) => b.type === 'main-segment');
+	const matroskaBox = boxes.find((b) => b.type === 'Segment');
 	if (matroskaBox) {
 		return getDurationFromMatroska(boxes);
 	}

package/src/get-sample-positions.ts

@@ -77,7 +77,7 @@ export const getSamplePositions = ({
 			const cts = dts + ctsOffset;
 
 			samples.push({
-				offset: chunks[i] + offsetInThisChunk,
+				offset: Number(chunks[i]) + offsetInThisChunk,
 				size,
 				isKeyframe,
 				dts,

package/src/get-tracks.ts

@@ -89,8 +89,8 @@ export const getTracks = (
 	const audioTracks: AudioTrack[] = [];
 	const otherTracks: OtherTrack[] = [];
 
-	const mainSegment = segments.find((s) => s.type === 'main-segment');
-	if (mainSegment && mainSegment.type === 'main-segment') {
+	const mainSegment = segments.find((s) => s.type === 'Segment');
+	if (mainSegment && mainSegment.type === 'Segment') {
 		const matroskaTracks = getTracksFromMatroska(
 			mainSegment,
 			state.getTimescale(),

package/src/get-video-codec.ts

@@ -76,39 +76,37 @@ export const getVideoCodec = (boxes: AnySegment[]): KnownVideoCodecs | null => {
 		}
 	}
 
-	const mainSegment = boxes.find((b) => b.type === 'main-segment');
-	if (!mainSegment || mainSegment.type !== 'main-segment') {
+	const mainSegment = boxes.find((b) => b.type === 'Segment');
+	if (!mainSegment || mainSegment.type !== 'Segment') {
 		return null;
 	}
 
-	const tracksSegment = mainSegment.children.find(
-		(b) => b.type === 'tracks-segment',
-	);
-	if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+	const tracksSegment = mainSegment.value.find((b) => b.type === 'Tracks');
+	if (!tracksSegment || tracksSegment.type !== 'Tracks') {
 		return null;
 	}
 
-	for (const track of tracksSegment.children) {
-		if (track.type === 'track-entry-segment') {
-			const trackType = track.children.find((b) => b.type === 'codec-segment');
-			if (trackType && trackType.type === 'codec-segment') {
-				if (trackType.codec === 'V_VP8') {
+	for (const track of tracksSegment.value) {
+		if (track.type === 'TrackEntry') {
+			const trackType = track.value.find((b) => b.type === 'CodecID');
+			if (trackType && trackType.type === 'CodecID') {
+				if (trackType.value === 'V_VP8') {
 					return 'vp8';
 				}
 
-				if (trackType.codec === 'V_VP9') {
+				if (trackType.value === 'V_VP9') {
 					return 'vp9';
 				}
 
-				if (trackType.codec === 'V_AV1') {
+				if (trackType.value === 'V_AV1') {
 					return 'av1';
 				}
 
-				if (trackType.codec === 'V_MPEG4/ISO/AVC') {
+				if (trackType.value === 'V_MPEG4/ISO/AVC') {
 					return 'h264';
 				}
 
-				if (trackType.codec === 'V_MPEGH/ISO/HEVC') {
+				if (trackType.value === 'V_MPEGH/ISO/HEVC') {
 					return 'h265';
 				}
 			}

package/src/has-all-info.ts

@@ -51,7 +51,7 @@ export const hasAllInfo = (
 		if (
 			key === 'dimensions' ||
 			key === 'rotation' ||
-			key === 'unrotatedDimension'
+			key === 'unrotatedDimensions'
 		) {
 			return hasDimensions(parseResult.segments, state);
 		}

package/src/options.ts

@@ -43,7 +43,7 @@ export type Options<
 	audioCodec?: EnableAudioCodec;
 	tracks?: EnableTracks;
 	rotation?: EnableRotation;
-	unrotatedDimension?: EnableUnrotatedDimensions;
+	unrotatedDimensions?: EnableUnrotatedDimensions;
 	internalStats?: EnableInternalStats;
 };
 
@@ -69,7 +69,7 @@ export type Metadata<
 		: {}) &
 	(EnableRotation extends true ? {rotation: number | null} : {}) &
 	(EnableUnrotatedDimensions extends true
-		? {unrotatedDimension: Dimensions}
+		? {unrotatedDimensions: Dimensions}
 		: {}) &
 	(EnableInternalStats extends true ? {internalStats: InternalStats} : {});
 
@@ -101,6 +101,7 @@ export type ParseMedia = <
 	reader?: ReaderInterface;
 	onAudioTrack?: OnAudioTrack;
 	onVideoTrack?: OnVideoTrack;
+	signal?: AbortSignal;
 }) => Promise<
 	Metadata<
 		EnableDimensions,

package/src/parse-media.ts

@@ -21,8 +21,14 @@ export const parseMedia: ParseMedia = async ({
 	reader: readerInterface = fetchReader,
 	onAudioTrack,
 	onVideoTrack,
+	signal,
 }) => {
-	const {reader, contentLength} = await readerInterface.read(src, null);
+	const state = makeParserState({
+		hasAudioCallbacks: onAudioTrack !== null,
+		hasVideoCallbacks: onVideoTrack !== null,
+		signal,
+	});
+	const {reader, contentLength} = await readerInterface.read(src, null, signal);
 	let currentReader = reader;
 
 	const returnValue = {} as Metadata<
@@ -41,19 +47,23 @@ export const parseMedia: ParseMedia = async ({
 	let iterator: BufferIterator | null = null;
 	let parseResult: ParseResult | null = null;
 
-	const state = makeParserState({
-		hasAudioCallbacks: onAudioTrack !== null,
-		hasVideoCallbacks: onVideoTrack !== null,
-	});
-
 	const options: ParserContext = {
 		canSkipVideoData: !(onAudioTrack || onVideoTrack),
 		onAudioTrack: onAudioTrack ?? null,
 		onVideoTrack: onVideoTrack ?? null,
 		parserState: state,
+		nullifySamples: !(
+			typeof process !== 'undefined' &&
+			typeof process.env !== 'undefined' &&
+			process.env.KEEP_SAMPLES === 'true'
+		),
 	};
 
 	while (parseResult === null || parseResult.status === 'incomplete') {
+		if (signal?.aborted) {
+			throw new Error('Aborted');
+		}
+
 		const result = await currentReader.read();
 
 		if (iterator) {
@@ -67,7 +77,7 @@ export const parseMedia: ParseMedia = async ({
 
 			iterator = getArrayBufferIterator(
 				result.value,
-				contentLength ?? undefined,
+				contentLength ?? 1_000_000_000,
 			);
 		}
 
@@ -106,6 +116,7 @@ export const parseMedia: ParseMedia = async ({
 			const {reader: newReader} = await readerInterface.read(
 				src,
 				parseResult.skipTo,
+				signal,
 			);
 			currentReader = newReader;
 			iterator.skipTo(parseResult.skipTo);
@@ -124,9 +135,9 @@ export const parseMedia: ParseMedia = async ({
 		};
 	}
 
-	if (fields?.unrotatedDimension) {
+	if (fields?.unrotatedDimensions) {
 		const dimensions = getDimensions(parseResult.segments, state);
-		returnValue.unrotatedDimension = {
+		returnValue.unrotatedDimensions = {
 			width: dimensions.unrotatedWidth,
 			height: dimensions.unrotatedHeight,
 		};

package/src/parse-video.ts

@@ -43,6 +43,22 @@ export const parseVideo = ({
 		});
 	}
 
+	if (iterator.isRiff()) {
+		throw new Error('AVI files are not yet supported');
+		/*
+		iterator.discard(4);
+		return parseBoxes({
+			iterator,
+			maxBytes: Infinity,
+			allowIncompleteBoxes: true,
+			initialBoxes: [],
+			options,
+			continueMdat: false,
+			littleEndian: true,
+		});
+		*/
+	}
+
 	if (iterator.isIsoBaseMedia()) {
 		return parseBoxes({
 			iterator,
@@ -51,6 +67,7 @@ export const parseVideo = ({
 			initialBoxes: [],
 			options,
 			continueMdat: false,
+			littleEndian: false,
 		});
 	}
 

package/src/parser-context.ts

@@ -6,4 +6,5 @@ export type ParserContext = {
 	onVideoTrack: OnVideoTrack | null;
 	canSkipVideoData: boolean;
 	parserState: ParserState;
+	nullifySamples: boolean;
 };