@remotion/media-parser 4.0.199 → 4.0.201

package/src/buffer-iterator.ts

@@ -1,3 +1,4 @@
+import {webmPattern} from './boxes/webm/make-header';
 import {
 	knownIdsWithOneLength,
 	knownIdsWithThreeLength,
@@ -46,8 +47,8 @@ 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 riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
 
 const matchesPattern = (pattern: Uint8Array) => {
 	return (data: Uint8Array) => {
@@ -64,7 +65,9 @@ export const getArrayBufferIterator = (
 	maxBytes?: number,
 ) => {
 	const buf = new ArrayBuffer(initialData.byteLength, {
-		maxByteLength: maxBytes ?? 1_000_000_000,
+		maxByteLength: maxBytes
+			? Math.min(maxBytes as number, 2 ** 32)
+			: 1_000_000_000,
 	});
 	if (!buf.resize) {
 		throw new Error(
@@ -95,7 +98,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 +167,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 +219,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 +253,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 +342,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 +375,10 @@ export const getArrayBufferIterator = (
 				return firstOneString;
 			}
 
+			if (bytesRemaining() === 0) {
+				return null;
+			}
+
 			const firstTwo = getSlice(1);
 
 			const firstTwoString = `${firstOneString}${Array.from(
@@ -317,6 +393,10 @@ export const getArrayBufferIterator = (
 				return firstTwoString;
 			}
 
+			if (bytesRemaining() === 0) {
+				return null;
+			}
+
 			const firstThree = getSlice(1);
 
 			const firstThreeString = `${firstTwoString}${Array.from(
@@ -331,6 +411,10 @@ export const getArrayBufferIterator = (
 				return firstThreeString;
 			}
 
+			if (bytesRemaining() === 0) {
+				return null;
+			}
+
 			const segmentId = getSlice(1);
 
 			return `${firstThreeString}${Array.from(new Uint8Array(segmentId))
@@ -339,7 +423,11 @@ export const getArrayBufferIterator = (
 				})
 				.join('')}`;
 		},
-		getVint: () => {
+		getVint: (): number | null => {
+			if (bytesRemaining() === 0) {
+				return null;
+			}
+
 			const firstByte = getUint8();
 			const totalLength = firstByte;
 
@@ -353,6 +441,10 @@ export const getArrayBufferIterator = (
 				actualLength++;
 			}
 
+			if (bytesRemaining() < actualLength) {
+				return null;
+			}
+
 			const slice = getSlice(actualLength);
 			const d = [firstByte, ...Array.from(new Uint8Array(slice))];
 
@@ -388,6 +480,13 @@ export const getArrayBufferIterator = (
 			counter.increment(2);
 			return val;
 		},
+		getUint24: () => {
+			const val1 = view.getUint8(counter.getDiscardedOffset());
+			const val2 = view.getUint8(counter.getDiscardedOffset());
+			const val3 = view.getUint8(counter.getDiscardedOffset());
+			counter.increment(3);
+			return (val1 << 16) | (val2 << 8) | val3;
+		},
 
 		getInt16: () => {
 			const val = view.getInt16(counter.getDiscardedOffset());
@@ -395,6 +494,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: () => {
@@ -413,7 +513,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-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/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,11 +47,6 @@ 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,
@@ -54,6 +55,10 @@ export const parseMedia: ParseMedia = async ({
 	};
 
 	while (parseResult === null || parseResult.status === 'incomplete') {
+		if (signal?.aborted) {
+			throw new Error('Aborted');
+		}
+
 		const result = await currentReader.read();
 
 		if (iterator) {
@@ -106,6 +111,7 @@ export const parseMedia: ParseMedia = async ({
 			const {reader: newReader} = await readerInterface.read(
 				src,
 				parseResult.skipTo,
+				signal,
 			);
 			currentReader = newReader;
 			iterator.skipTo(parseResult.skipTo);
@@ -124,9 +130,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-state.ts

@@ -1,6 +1,6 @@
 import type {OnTrackEntrySegment} from './boxes/webm/segments';
-import type {CodecSegment} from './boxes/webm/segments/track-entry';
-import {getTrackCodec} from './boxes/webm/traversal';
+import type {TrackInfo} from './boxes/webm/segments/track-entry';
+import {getTrackCodec, getTrackTimestampScale} from './boxes/webm/traversal';
 import {getTrackId} from './traversal';
 import type {
 	AudioSample,
@@ -9,18 +9,18 @@ import type {
 	VideoSample,
 } from './webcodec-sample-types';
 
-export type InternalStats = {
-	samplesThatHadToBeQueued: number;
-};
+export type InternalStats = {};
 
 export const makeParserState = ({
 	hasAudioCallbacks,
 	hasVideoCallbacks,
+	signal,
 }: {
 	hasAudioCallbacks: boolean;
 	hasVideoCallbacks: boolean;
+	signal: AbortSignal | undefined;
 }) => {
-	const trackEntries: Record<number, CodecSegment> = {};
+	const trackEntries: Record<number, TrackInfo> = {};
 
 	const onTrackEntrySegment: OnTrackEntrySegment = (trackEntry) => {
 		const trackId = getTrackId(trackEntry);
@@ -37,14 +37,17 @@ export const makeParserState = ({
 			throw new Error('Expected codec');
 		}
 
-		trackEntries[trackId] = codec;
+		const trackTimescale = getTrackTimestampScale(trackEntry);
+
+		trackEntries[trackId] = {
+			codec: codec.codec,
+			trackTimescale,
+		};
 	};
 
 	const videoSampleCallbacks: Record<number, OnVideoSample> = {};
 	const audioSampleCallbacks: Record<number, OnAudioSample> = {};
 
-	let samplesThatHadToBeQueued = 0;
-
 	const queuedAudioSamples: Record<number, AudioSample[]> = {};
 	const queuedVideoSamples: Record<number, VideoSample[]> = {};
 
@@ -53,8 +56,10 @@ export const makeParserState = ({
 	let timescale: number | null = null;
 
 	const getTimescale = () => {
+		// https://www.matroska.org/technical/notes.html
+		// When using the default value of TimestampScale of “1,000,000”, one Segment Tick represents one millisecond.
 		if (timescale === null) {
-			throw new Error('Timescale not set');
+			return 1_000_000;
 		}
 
 		return timescale;
@@ -64,6 +69,30 @@ export const makeParserState = ({
 		timescale = newTimescale;
 	};
 
+	const timestampMap = new Map<number, number>();
+
+	const setTimestampOffset = (byteOffset: number, timestamp: number) => {
+		timestampMap.set(byteOffset, timestamp);
+	};
+
+	const getTimestampOffsetForByteOffset = (byteOffset: number) => {
+		const entries = Array.from(timestampMap.entries());
+		const sortedByByteOffset = entries
+			.sort((a, b) => {
+				return a[0] - b[0];
+			})
+			.reverse();
+		for (const [offset, timestamp] of sortedByByteOffset) {
+			if (offset >= byteOffset) {
+				continue;
+			}
+
+			return timestamp;
+		}
+
+		return timestampMap.get(byteOffset);
+	};
+
 	return {
 		onTrackEntrySegment,
 		getTrackInfoByNumber: (id: number) => trackEntries[id],
@@ -85,6 +114,8 @@ export const makeParserState = ({
 
 			queuedVideoSamples[id] = [];
 		},
+		setTimestampOffset,
+		getTimestampOffsetForByteOffset,
 		registerAudioSampleCallback: async (
 			id: number,
 			callback: OnAudioSample | null,
@@ -103,6 +134,10 @@ export const makeParserState = ({
 			queuedAudioSamples[id] = [];
 		},
 		onAudioSample: async (trackId: number, audioSample: AudioSample) => {
+			if (signal?.aborted) {
+				throw new Error('Aborted');
+			}
+
 			const callback = audioSampleCallbacks[trackId];
 			if (callback) {
 				await callback(audioSample);
@@ -112,15 +147,15 @@ export const makeParserState = ({
 				}
 
 				if (!hasAudioCallbacks) {
-					return;
+					throw new Error('No audio callbacks registered');
 				}
-
-				queuedAudioSamples[trackId] ??= [];
-				queuedAudioSamples[trackId].push(audioSample);
-				samplesThatHadToBeQueued++;
 			}
 		},
 		onVideoSample: async (trackId: number, videoSample: VideoSample) => {
+			if (signal?.aborted) {
+				throw new Error('Aborted');
+			}
+
 			const callback = videoSampleCallbacks[trackId];
 			if (callback) {
 				await callback(videoSample);
@@ -130,19 +165,11 @@ export const makeParserState = ({
 				}
 
 				if (!hasVideoCallbacks) {
-					return;
+					throw new Error('No video callbacks registered');
 				}
-
-				queuedVideoSamples[trackId] ??= [];
-				queuedVideoSamples[trackId].push(videoSample);
-				samplesThatHadToBeQueued++;
 			}
 		},
-		getInternalStats: () => {
-			return {
-				samplesThatHadToBeQueued,
-			};
-		},
+		getInternalStats: () => ({}),
 		getTimescale,
 		setTimescale,
 	};

package/src/reader.ts

@@ -5,6 +5,7 @@ type ReadResult = {
 type ReadContent = (
 	src: string | File,
 	range: [number, number] | number | null,
+	signal: AbortSignal | undefined,
 ) => Promise<ReadResult>;
 type GetLength = (src: string | File) => Promise<number>;
 

package/src/test/create-matroska.test.ts

@@ -0,0 +1,48 @@
+import {RenderInternals} from '@remotion/renderer';
+import {expect, test} from 'bun:test';
+import {makeMatroskaHeader} from '../boxes/webm/make-header';
+import {
+	matroskaHeader,
+	seek,
+	seekId,
+} from '../boxes/webm/segments/all-segments';
+
+test('Should make Matroska header that is same as input', async () => {
+	const exampleVideo = RenderInternals.exampleVideos.matroskaMp3;
+	const file = await Bun.file(exampleVideo).arrayBuffer();
+
+	const headerInput = new Uint8Array(file.slice(0, 0x28));
+
+	const headerOutput = makeMatroskaHeader(matroskaHeader, {
+		DocType: 'matroska',
+		DocTypeVersion: 4,
+		DocTypeReadVersion: 2,
+		EBMLMaxIDLength: 4,
+		EBMLMaxSizeLength: 8,
+		EBMLReadVersion: 1,
+		EBMLVersion: 1,
+	});
+
+	expect(headerInput).toEqual(headerOutput);
+});
+
+test('Should be able to create SeekIdBox', async () => {
+	const file = new Uint8Array(
+		await Bun.file('vp8-segments/56-0x53ab').arrayBuffer(),
+	);
+
+	const custom = makeMatroskaHeader(seekId, '0x1549a966');
+	expect(custom).toEqual(file);
+});
+
+test('Should be able to create Seek', async () => {
+	const file = new Uint8Array(
+		await Bun.file('vp8-segments/53-0x4dbb').arrayBuffer(),
+	);
+
+	const custom = makeMatroskaHeader(seek, {
+		SeekID: '0x1549a966',
+		SeekPosition: 0x40,
+	});
+	expect(custom).toEqual(file);
+});