@remotion/media-parser 4.0.191 → 4.0.193

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

@@ -5,14 +5,14 @@ import {expectSegment} from './segments';
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
 export const parseWebm = (counter: BufferIterator): ParseResult => {
 	counter.discard(4);
-	const length = counter.getEBML();
+	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

@@ -51,10 +51,6 @@ export type TrackUIDSegment = {
 
 export const parseTrackUID = (iterator: BufferIterator): TrackUIDSegment => {
 	const length = iterator.getVint();
-	// Observation: AV1 has 8 bytes, WebM has 7
-	if (length !== 8 && length !== 7) {
-		throw new Error('Expected track number to be 8 byte');
-	}
 
 	const bytes = iterator.getSlice(length);
 
@@ -187,16 +183,11 @@ export type VideoSegment = {
 };
 
 export const parseVideoSegment = (iterator: BufferIterator): VideoSegment => {
-	const offset = iterator.counter.getOffset();
-
 	const length = iterator.getVint();
 
 	return {
 		type: 'video-segment',
-		children: expectChildren(
-			iterator,
-			length - (iterator.counter.getOffset() - offset),
-		),
+		children: expectChildren(iterator, length),
 	};
 };
 
@@ -287,9 +278,110 @@ export type ColorSegment = {
 export const parseColorSegment = (iterator: BufferIterator): ColorSegment => {
 	const length = iterator.getVint();
 
-	iterator.discard(length - 1);
+	iterator.discard(length);
 
 	return {
 		type: 'color-segment',
 	};
 };
+
+export type TitleSegment = {
+	type: 'title-segment';
+	title: string;
+};
+
+export const parseTitleSegment = (iterator: BufferIterator): TitleSegment => {
+	const length = iterator.getVint();
+	const title = iterator.getByteString(length);
+
+	return {
+		type: 'title-segment',
+		title,
+	};
+};
+
+export type InterlacedSegment = {
+	type: 'interlaced-segment';
+	interlaced: boolean;
+};
+
+export const parseInterlacedSegment = (
+	iterator: BufferIterator,
+): InterlacedSegment => {
+	const length = iterator.getVint();
+	if (length !== 1) {
+		throw new Error('Expected interlaced segment to be 1 byte');
+	}
+
+	const interlaced = iterator.getUint8();
+
+	return {
+		type: 'interlaced-segment',
+		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,13 +17,19 @@ 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,
 	TrackTypeSegment,
@@ -33,13 +39,19 @@ import type {
 } from './segments/track-entry';
 import {
 	parseAlphaModeSegment,
+	parseCodecPrivateSegment,
 	parseCodecSegment,
 	parseColorSegment,
+	parseCrc32Segment,
 	parseDefaultDurationSegment,
+	parseDefaultFlagSegment,
 	parseFlagLacing,
 	parseHeightSegment,
+	parseInterlacedSegment,
 	parseLanguageSegment,
 	parseMaxBlockAdditionId,
+	parseSegmentUUIDSegment,
+	parseTitleSegment,
 	parseTrackEntry,
 	parseTrackNumber,
 	parseTrackTypeSegment,
@@ -82,7 +94,13 @@ export type MatroskaSegment =
 	| HeightSegment
 	| AlphaModeSegment
 	| MaxBlockAdditionId
-	| ColorSegment;
+	| ColorSegment
+	| TitleSegment
+	| InterlacedSegment
+	| CodecPrivateSegment
+	| Crc32Segment
+	| SegmentUUIDSegment
+	| DefaultFlagSegment;
 
 export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
 	const segmentId = iterator.getMatroskaSegmentId();
@@ -189,10 +207,34 @@ export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
 		return parseHeightSegment(iterator);
 	}
 
+	if (segmentId === '0x9a') {
+		return parseInterlacedSegment(iterator);
+	}
+
 	if (segmentId === '0x53c0') {
 		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,16 @@ 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,
+	});
+	let data = new Uint8Array(buf);
+	data.set(initialData);
+
 	let view = new DataView(data.buffer);
 	const counter = makeOffsetCounter();
 
@@ -76,6 +84,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 +100,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);
 	};
@@ -111,9 +128,9 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 	const removeBytesRead = () => {
 		const bytesToRemove = counter.getDiscardedOffset();
 		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);
 	};
 
@@ -134,6 +151,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))
@@ -154,6 +172,10 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 				'0xe0',
 				'0xb0',
 				'0xba',
+				'0x9a',
+				'0xe1',
+				'0xbf',
+				'0x88',
 			];
 			if (knownIdsWithOneLength.includes(firstOneString)) {
 				return firstOneString;
@@ -172,6 +194,9 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 				'0x4489',
 				'0x55ee',
 				'0x55b0',
+				'0x7ba9',
+				'0x63a2',
+				'0x73a4',
 			];
 
 			const firstTwoString = `${firstOneString}${Array.from(
@@ -265,6 +290,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,18 @@ 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],
 		});
-		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

@@ -31,9 +31,16 @@ export const webReader: ReaderInterface = {
 			throw new Error('No body');
 		}
 
+		const length = res.headers.get('content-length');
+		if (!length) {
+			throw new Error('No 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, {

package/src/get-audio-codec.ts

@@ -0,0 +1,143 @@
+/* eslint-disable max-depth */
+import type {Sample} from './boxes/iso-base-media/stsd/samples';
+import {trakBoxContainsAudio} from './get-fps';
+import type {KnownAudioCodecs} from './options';
+import type {AnySegment} from './parse-result';
+
+export const hasAudioCodec = (boxes: AnySegment[]): boolean => {
+	try {
+		return getAudioCodec(boxes) !== null;
+	} catch (e) {
+		return false;
+	}
+};
+
+const onEsdsBox = (child: AnySegment): KnownAudioCodecs | null => {
+	if (child && child.type === 'esds-box') {
+		const descriptor = child.descriptors.find(
+			(d) => d.type === 'decoder-config-descriptor',
+		);
+		if (descriptor && descriptor.type === 'decoder-config-descriptor') {
+			return descriptor.objectTypeIndication;
+		}
+	}
+
+	return null;
+};
+
+const onSample = (sample: Sample): KnownAudioCodecs | null | undefined => {
+	if (!sample) {
+		return null;
+	}
+
+	if (sample.type !== 'audio') {
+		return null;
+	}
+
+	if (sample.format === 'sowt') {
+		return 'aiff';
+	}
+
+	const child = sample.children.find((c) => c.type === 'esds-box');
+
+	if (child && child.type === 'esds-box') {
+		const ret = onEsdsBox(child);
+		if (ret) {
+			return ret;
+		}
+	}
+};
+
+export const getAudioCodec = (boxes: AnySegment[]): KnownAudioCodecs | null => {
+	const moovBox = boxes.find((b) => b.type === 'moov-box');
+	if (moovBox && moovBox.type === 'moov-box') {
+		const trakBox = moovBox.children.find(
+			(b) => b.type === 'trak-box' && trakBoxContainsAudio(b),
+		);
+		if (trakBox && trakBox.type === 'trak-box') {
+			const mdiaBox = trakBox.children.find(
+				(b) => b.type === 'regular-box' && b.boxType === 'mdia',
+			);
+			if (
+				mdiaBox &&
+				mdiaBox.type === 'regular-box' &&
+				mdiaBox.boxType === 'mdia'
+			) {
+				const minfBox = mdiaBox?.children.find(
+					(b) => b.type === 'regular-box' && b.boxType === 'minf',
+				);
+				if (
+					minfBox &&
+					minfBox.type === 'regular-box' &&
+					minfBox.boxType === 'minf'
+				) {
+					const stblBox = minfBox?.children.find(
+						(b) => b.type === 'regular-box' && b.boxType === 'stbl',
+					);
+					if (stblBox && stblBox.type === 'regular-box') {
+						const stsdBox = stblBox?.children.find(
+							(b) => b.type === 'stsd-box',
+						);
+						if (stsdBox && stsdBox.type === 'stsd-box') {
+							const sample = stsdBox.samples.find((s) => s.type === 'audio');
+							if (sample && sample.type === 'audio') {
+								const ret = onSample(sample);
+								if (ret) {
+									return ret;
+								}
+
+								const waveBox = sample.children.find(
+									(b) => b.type === 'regular-box' && b.boxType === 'wave',
+								);
+								if (
+									waveBox &&
+									waveBox.type === 'regular-box' &&
+									waveBox.boxType === 'wave'
+								) {
+									const esdsBox = waveBox.children.find(
+										(b) => b.type === 'esds-box',
+									);
+									if (esdsBox && esdsBox.type === 'esds-box') {
+										const ret2 = onEsdsBox(esdsBox);
+										if (ret2) {
+											return ret2;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	const mainSegment = boxes.find((b) => b.type === 'main-segment');
+	if (!mainSegment || mainSegment.type !== 'main-segment') {
+		return null;
+	}
+
+	const tracksSegment = mainSegment.children.find(
+		(b) => b.type === 'tracks-segment',
+	);
+	if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+		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') {
+					return 'opus';
+				}
+
+				if (trackType.codec === 'A_PCM/INT/LIT') {
+					return 'pcm';
+				}
+			}
+		}
+	}
+
+	return null;
+};

package/src/get-dimensions.ts

@@ -14,10 +14,17 @@ const getDimensionsFromMatroska = (segments: MainSegment): Dimensions => {
 		throw new Error('No tracks segment');
 	}
 
-	// TODO: What if there are multiple video tracks, or audio track is first?
-	const trackEntrySegment = tracksSegment.children.find(
-		(b) => b.type === 'track-entry-segment',
-	);
+	const trackEntrySegment = tracksSegment.children.find((b) => {
+		if (b.type !== 'track-entry-segment') {
+			return false;
+		}
+
+		return (
+			b.children.find(
+				(c) => c.type === 'codec-segment' && c.codec.startsWith('V_'),
+			) !== undefined
+		);
+	});
 	if (!trackEntrySegment || trackEntrySegment.type !== 'track-entry-segment') {
 		throw new Error('No track entry segment');
 	}