@remotion/media-parser 4.0.192 → 4.0.193

package/src/boxes/iso-base-media/esds/esds-descriptors.ts

@@ -0,0 +1,104 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+type AudioObjectType = 'aac' | 'mp3' | 'unknown';
+
+type DecoderConfigDescriptor = {
+	type: 'decoder-config-descriptor';
+	objectTypeIndication: AudioObjectType;
+};
+
+const mapToObjectAudioIndicator = (num: number): AudioObjectType => {
+	// https://chromium.googlesource.com/chromium/src/media/+/master/formats/mp4/es_descriptor.h
+	// http://netmedia.zju.edu.cn/multimedia2013/mpeg-4/ISO%20IEC%2014496-1%20MPEG-4%20System%20Standard.pdf
+	// Page 42, table 8
+	if (num === 0x40) {
+		return 'aac';
+	}
+
+	if (num === 0x6b) {
+		return 'mp3';
+	}
+
+	return 'unknown';
+};
+
+type SlConfigDescriptor = {
+	type: 'sl-config-descriptor';
+};
+
+type UnknownDescriptor = {
+	type: 'unknown-descriptor';
+};
+
+export type Descriptor =
+	| DecoderConfigDescriptor
+	| SlConfigDescriptor
+	| UnknownDescriptor;
+
+type DescriptorAndNext = {
+	descriptor: Descriptor | null;
+};
+
+export const processDescriptor = ({
+	iterator,
+}: {
+	iterator: BufferIterator;
+}): DescriptorAndNext => {
+	const tag = iterator.getUint8();
+
+	if (tag === 4) {
+		const size = iterator.getPaddedFourByteNumber();
+		const initialOffset = iterator.counter.getOffset();
+
+		const objectTypeIndication = iterator.getUint8();
+
+		const remaining = size - (iterator.counter.getOffset() - initialOffset);
+		iterator.discard(remaining);
+		return {
+			descriptor: {
+				type: 'decoder-config-descriptor',
+				objectTypeIndication: mapToObjectAudioIndicator(objectTypeIndication),
+			},
+		};
+	}
+
+	if (tag === 6) {
+		const size = iterator.getPaddedFourByteNumber();
+
+		iterator.discard(size);
+		return {
+			descriptor: {
+				type: 'sl-config-descriptor',
+			},
+		};
+	}
+
+	return {
+		descriptor: null,
+	};
+};
+
+export const parseDescriptors = (
+	iterator: BufferIterator,
+	maxBytes: number,
+): Descriptor[] => {
+	const descriptors: Descriptor[] = [];
+	const initialOffset = iterator.counter.getOffset();
+
+	while (
+		iterator.bytesRemaining() > 0 &&
+		iterator.counter.getOffset() - initialOffset < maxBytes
+	) {
+		const {descriptor} = processDescriptor({
+			iterator,
+		});
+
+		if (descriptor) {
+			descriptors.push(descriptor);
+		} else {
+			break;
+		}
+	}
+
+	return descriptors;
+};

package/src/boxes/iso-base-media/esds/esds.ts

@@ -0,0 +1,49 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {Descriptor} from './esds-descriptors';
+import {parseDescriptors} from './esds-descriptors';
+
+export interface EsdsBox {
+	type: 'esds-box';
+	version: number;
+	tag: number;
+	sizeOfInstance: number;
+	esId: number;
+	descriptors: Descriptor[];
+}
+
+export const parseEsds = ({
+	data,
+	size,
+	fileOffset,
+}: {
+	data: BufferIterator;
+	size: number;
+	fileOffset: number;
+}): EsdsBox => {
+	const version = data.getUint8();
+	// Flags, we discard them
+	data.discard(3);
+	const tag = data.getUint8();
+
+	const sizeOfInstance = data.getPaddedFourByteNumber();
+	const esId = data.getUint16();
+
+	// disard 1 byte, currently unknown
+	data.discard(1);
+
+	const remaining = size - (data.counter.getOffset() - fileOffset);
+	const descriptors = parseDescriptors(data, remaining);
+
+	const remainingNow = size - (data.counter.getOffset() - fileOffset);
+
+	data.discard(remainingNow);
+
+	return {
+		type: 'esds-box',
+		version,
+		tag,
+		sizeOfInstance,
+		esId,
+		descriptors,
+	};
+};

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 [];
 };
@@ -177,6 +183,20 @@ const processBox = ({
 		};
 	}
 
+	if (boxType === 'esds') {
+		const box = parseEsds({
+			data: iterator,
+			size: boxSize,
+			fileOffset,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
 	const bytesRemainingInBox =
 		boxSize - (iterator.counter.getOffset() - fileOffset);
 

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,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))
@@ -155,6 +173,9 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 				'0xb0',
 				'0xba',
 				'0x9a',
+				'0xe1',
+				'0xbf',
+				'0x88',
 			];
 			if (knownIdsWithOneLength.includes(firstOneString)) {
 				return firstOneString;
@@ -174,6 +195,8 @@ export const getArrayBufferIterator = (initialData: Uint8Array) => {
 				'0x55ee',
 				'0x55b0',
 				'0x7ba9',
+				'0x63a2',
+				'0x73a4',
 			];
 
 			const firstTwoString = `${firstOneString}${Array.from(
@@ -267,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, {