@remotion/media-parser 4.0.194 → 4.0.196

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

@@ -0,0 +1,55 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {BaseBox} from '../base-type';
+
+type CttsEntry = {
+	sampleCount: number;
+	sampleOffset: number;
+};
+
+export interface CttsBox extends BaseBox {
+	type: 'ctts-box';
+	version: number;
+	flags: number[];
+	entryCount: number;
+	entries: CttsEntry[];
+}
+
+export const parseCtts = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): CttsBox => {
+	const version = iterator.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported CTTS version ${version}`);
+	}
+
+	const flags = iterator.getSlice(3);
+	const entryCount = iterator.getUint32();
+
+	const entries: CttsEntry[] = [];
+
+	for (let i = 0; i < entryCount; i++) {
+		const sampleCount = iterator.getUint32();
+		const sampleOffset = iterator.getUint32();
+
+		entries.push({
+			sampleCount,
+			sampleOffset,
+		});
+	}
+
+	return {
+		type: 'ctts-box',
+		boxSize: size,
+		offset,
+		version,
+		flags: [...flags],
+		entryCount,
+		entries,
+	};
+};

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

@@ -0,0 +1,32 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import {getHvc1CodecString} from '../../../make-hvc1-codec-strings';
+
+export interface HvccBox {
+	type: 'hvcc-box';
+	data: Uint8Array;
+	configurationString: string;
+}
+
+export const parseHvcc = ({
+	data,
+	size,
+	offset,
+}: {
+	data: BufferIterator;
+	size: number;
+	offset: number;
+}): HvccBox => {
+	const raw = data.getSlice(size - 8);
+	data.counter.decrement(size - 8);
+
+	const constraintString = getHvc1CodecString(data);
+
+	const remaining = size - (data.counter.getOffset() - offset);
+	data.discard(remaining);
+
+	return {
+		type: 'hvcc-box',
+		data: raw,
+		configurationString: constraintString,
+	};
+};

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

@@ -17,6 +17,8 @@ export const parseKeys = (data: Uint8Array, offset: number): KeysBox => {
 		throw new Error(`Expected keys type of keys, got ${atom}`);
 	}
 
+	iterator.destroy();
+
 	return {
 		type: 'keys-box',
 		boxSize: data.byteLength,

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

@@ -1,5 +1,6 @@
 import type {BufferIterator} from '../../../buffer-iterator';
 import type {AnySegment} from '../../../parse-result';
+import type {ParserContext} from '../../../parser-context';
 import type {BaseBox} from '../base-type';
 import {parseBoxes} from '../process-box';
 
@@ -10,25 +11,29 @@ export interface MebxBox extends BaseBox {
 	children: AnySegment[];
 }
 
-export const parseMebx = ({
+export const parseMebx = async ({
 	iterator,
 	offset,
 	size,
+	options,
 }: {
 	iterator: BufferIterator;
 	offset: number;
 	size: number;
-}): MebxBox => {
+	options: ParserContext;
+}): Promise<MebxBox> => {
 	// reserved, 6 bit
 	iterator.discard(6);
 
 	const dataReferenceIndex = iterator.getUint16();
 
-	const children = parseBoxes({
+	const children = await parseBoxes({
 		iterator,
 		maxBytes: iterator.counter.getOffset() - offset,
 		allowIncompleteBoxes: false,
 		initialBoxes: [],
+		options,
+		continueMdat: false,
 	});
 
 	if (children.status === 'incomplete') {

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

@@ -0,0 +1,32 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {BaseBox} from '../base-type';
+
+export interface PaspBox extends BaseBox {
+	type: 'pasp-box';
+	hSpacing: number;
+	vSpacing: number;
+}
+
+export const parsePasp = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): PaspBox => {
+	const hSpacing = iterator.getUint32();
+	const vSpacing = iterator.getUint32();
+
+	const bytesRemainingInBox = size - (iterator.counter.getOffset() - offset);
+	iterator.discard(bytesRemainingInBox);
+
+	return {
+		type: 'pasp-box',
+		boxSize: size,
+		offset,
+		hSpacing,
+		vSpacing,
+	};
+};

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

@@ -1,5 +1,6 @@
 import type {BufferIterator} from '../../../buffer-iterator';
 import type {AnySegment} from '../../../parse-result';
+import type {ParserContext} from '../../../parser-context';
 import {parseBoxes} from '../process-box';
 
 type SampleBase = {
@@ -12,7 +13,7 @@ type SampleBase = {
 	size: number;
 };
 
-type AudioSample = SampleBase & {
+export type AudioSample = SampleBase & {
 	type: 'audio';
 	numberOfChannels: number;
 	sampleSize: number;
@@ -26,7 +27,7 @@ type AudioSample = SampleBase & {
 	children: AnySegment[];
 };
 
-type VideoSample = SampleBase & {
+export type VideoSample = SampleBase & {
 	type: 'video';
 	temporalQuality: number;
 	spacialQuality: number;
@@ -39,6 +40,7 @@ type VideoSample = SampleBase & {
 	frameCountPerSample: number;
 	depth: number;
 	colorTableId: number;
+	descriptors: AnySegment[];
 };
 
 type UnknownSample = SampleBase & {
@@ -81,6 +83,7 @@ const videoTags = [
 	'v210',
 	'hvc1',
 	'ap4h',
+	'av01',
 ];
 
 // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_descriptions
@@ -111,11 +114,13 @@ const audioTags = [
 	'ac-3',
 ];
 
-export const processSample = ({
+export const processSample = async ({
 	iterator,
+	options,
 }: {
 	iterator: BufferIterator;
-}): SampleAndNext => {
+	options: ParserContext;
+}): Promise<SampleAndNext> => {
 	const fileOffset = iterator.counter.getOffset();
 	const bytesRemaining = iterator.bytesRemaining();
 	const boxSize = iterator.getUint32();
@@ -163,15 +168,17 @@ export const processSample = ({
 			const sampleSize = iterator.getUint16();
 			const compressionId = iterator.getUint16();
 			const packetSize = iterator.getUint16();
-			const sampleRate = iterator.getFixedPoint1616Number();
+			const sampleRate = iterator.getFixedPointUnsigned1616Number();
 
 			const bytesRemainingInBox =
 				boxSize - (iterator.counter.getOffset() - fileOffset);
-			const children = parseBoxes({
+			const children = await parseBoxes({
 				iterator,
 				allowIncompleteBoxes: false,
 				maxBytes: bytesRemainingInBox,
 				initialBoxes: [],
+				options,
+				continueMdat: false,
 			});
 
 			if (children.status === 'incomplete') {
@@ -207,7 +214,7 @@ export const processSample = ({
 			const sampleSize = iterator.getUint16();
 			const compressionId = iterator.getInt16();
 			const packetSize = iterator.getUint16();
-			const sampleRate = iterator.getFixedPoint1616Number();
+			const sampleRate = iterator.getFixedPointUnsigned1616Number();
 
 			const samplesPerPacket = iterator.getUint32();
 
@@ -218,11 +225,13 @@ export const processSample = ({
 			const bytesRemainingInBox =
 				boxSize - (iterator.counter.getOffset() - fileOffset);
 
-			const children = parseBoxes({
+			const children = await parseBoxes({
 				iterator,
 				allowIncompleteBoxes: false,
 				maxBytes: bytesRemainingInBox,
 				initialBoxes: [],
+				options,
+				continueMdat: false,
 			});
 
 			if (children.status === 'incomplete') {
@@ -261,8 +270,8 @@ export const processSample = ({
 		const spacialQuality = iterator.getUint32();
 		const width = iterator.getUint16();
 		const height = iterator.getUint16();
-		const horizontalResolution = iterator.getFixedPoint1616Number();
-		const verticalResolution = iterator.getFixedPoint1616Number();
+		const horizontalResolution = iterator.getFixedPointUnsigned1616Number();
+		const verticalResolution = iterator.getFixedPointUnsigned1616Number();
 		const dataSize = iterator.getUint32();
 		const frameCountPerSample = iterator.getUint16();
 		const compressorName = iterator.getPascalString();
@@ -272,7 +281,18 @@ export const processSample = ({
 		const bytesRemainingInBox =
 			boxSize - (iterator.counter.getOffset() - fileOffset);
 
-		iterator.discard(bytesRemainingInBox);
+		const children = await parseBoxes({
+			iterator,
+			allowIncompleteBoxes: false,
+			maxBytes: bytesRemainingInBox,
+			initialBoxes: [],
+			options,
+			continueMdat: false,
+		});
+
+		if (children.status === 'incomplete') {
+			throw new Error('Incomplete boxes are not allowed');
+		}
 
 		return {
 			sample: {
@@ -295,6 +315,7 @@ export const processSample = ({
 				compressorName,
 				depth,
 				colorTableId,
+				descriptors: children.segments,
 			},
 		};
 	}
@@ -302,10 +323,15 @@ export const processSample = ({
 	throw new Error(`Unknown sample format ${boxFormat}`);
 };
 
-export const parseSamples = (
-	iterator: BufferIterator,
-	maxBytes: number,
-): Sample[] => {
+export const parseSamples = async ({
+	iterator,
+	maxBytes,
+	options,
+}: {
+	iterator: BufferIterator;
+	maxBytes: number;
+	options: ParserContext;
+}): Promise<Sample[]> => {
 	const samples: Sample[] = [];
 	const initialOffset = iterator.counter.getOffset();
 
@@ -313,8 +339,9 @@ export const parseSamples = (
 		iterator.bytesRemaining() > 0 &&
 		iterator.counter.getOffset() - initialOffset < maxBytes
 	) {
-		const {sample} = processSample({
+		const {sample} = await processSample({
 			iterator,
+			options,
 		});
 
 		if (sample) {

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

@@ -0,0 +1,50 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {BaseBox} from '../base-type';
+
+export interface StcoBox extends BaseBox {
+	type: 'stco-box';
+	version: number;
+	flags: number[];
+	entryCount: number;
+	entries: number[];
+}
+
+export const parseStco = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): StcoBox => {
+	const version = iterator.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported STSD version ${version}`);
+	}
+
+	const flags = iterator.getSlice(3);
+	const entryCount = iterator.getUint32();
+
+	const entries: number[] = [];
+	for (let i = 0; i < entryCount; i++) {
+		const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+		if (bytesRemaining < 4) {
+			break;
+		}
+
+		entries.push(iterator.getUint32());
+	}
+
+	iterator.discard(size - (iterator.counter.getOffset() - offset));
+
+	return {
+		type: 'stco-box',
+		boxSize: size,
+		offset,
+		version,
+		flags: [...flags],
+		entries,
+		entryCount,
+	};
+};

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

@@ -0,0 +1,61 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {BaseBox} from '../base-type';
+
+type StscEntry = {
+	firstChunk: number;
+	samplesPerChunk: number;
+};
+
+export interface StscBox extends BaseBox {
+	type: 'stsc-box';
+	version: number;
+	flags: number[];
+	entryCount: number;
+	entries: StscEntry[];
+}
+
+export const parseStsc = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): StscBox => {
+	const version = iterator.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported STSD version ${version}`);
+	}
+
+	const flags = iterator.getSlice(3);
+	const entryCount = iterator.getUint32();
+
+	const entries: StscEntry[] = [];
+
+	for (let i = 0; i < entryCount; i++) {
+		const firstChunk = iterator.getUint32();
+		const samplesPerChunk = iterator.getUint32();
+		const sampleDescriptionIndex = iterator.getUint32();
+		if (sampleDescriptionIndex !== 1) {
+			throw new Error(
+				`Expected sampleDescriptionIndex to be 1, but got ${sampleDescriptionIndex}`,
+			);
+		}
+
+		entries.push({
+			firstChunk,
+			samplesPerChunk,
+		});
+	}
+
+	return {
+		type: 'stsc-box',
+		boxSize: size,
+		offset,
+		version,
+		flags: [...flags],
+		entryCount,
+		entries,
+	};
+};

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

@@ -1,4 +1,5 @@
 import type {BufferIterator} from '../../../buffer-iterator';
+import type {ParserContext} from '../../../parser-context';
 import type {BaseBox} from '../base-type';
 import type {Sample} from './samples';
 import {parseSamples} from './samples';
@@ -9,15 +10,17 @@ export interface StsdBox extends BaseBox {
 	samples: Sample[];
 }
 
-export const parseStsd = ({
+export const parseStsd = async ({
 	iterator,
 	offset,
 	size,
+	options,
 }: {
 	iterator: BufferIterator;
 	offset: number;
 	size: number;
-}): StsdBox => {
+	options: ParserContext;
+}): Promise<StsdBox> => {
 	const version = iterator.getUint8();
 	if (version !== 0) {
 		throw new Error(`Unsupported STSD version ${version}`);
@@ -30,7 +33,11 @@ export const parseStsd = ({
 
 	const bytesRemainingInBox = size - (iterator.counter.getOffset() - offset);
 
-	const boxes = parseSamples(iterator, bytesRemainingInBox);
+	const boxes = await parseSamples({
+		iterator,
+		maxBytes: bytesRemainingInBox,
+		options,
+	});
 
 	if (boxes.length !== numberOfEntries) {
 		throw new Error(

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

@@ -0,0 +1,47 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {BaseBox} from '../base-type';
+
+export interface StssBox extends BaseBox {
+	type: 'stss-box';
+	version: number;
+	flags: number[];
+	sampleNumber: number[];
+}
+
+export const parseStss = ({
+	iterator,
+	offset,
+	boxSize,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	boxSize: number;
+}): StssBox => {
+	const version = iterator.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported STSS version ${version}`);
+	}
+
+	const flags = iterator.getSlice(3);
+	const sampleCount = iterator.getUint32();
+
+	const sampleNumber: number[] = [];
+	for (let i = 0; i < sampleCount; i++) {
+		sampleNumber.push(iterator.getUint32());
+	}
+
+	const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - offset);
+
+	if (bytesRemainingInBox > 0) {
+		throw new Error(`Unexpected bytes remaining in box stss`);
+	}
+
+	return {
+		type: 'stss-box',
+		version,
+		flags: [...flags],
+		sampleNumber,
+		boxSize,
+		offset,
+	};
+};

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

@@ -0,0 +1,75 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {BaseBox} from '../base-type';
+
+type Discriminated =
+	| {
+			countType: 'fixed';
+			sampleSize: number;
+	  }
+	| {
+			countType: 'variable';
+			entries: number[];
+	  };
+
+export type StszBox = BaseBox & {
+	type: 'stsz-box';
+	version: number;
+	flags: number[];
+	sampleCount: number;
+} & Discriminated;
+
+export const parseStsz = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): StszBox => {
+	const version = iterator.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported STSD version ${version}`);
+	}
+
+	const flags = iterator.getSlice(3);
+
+	const sampleSize = iterator.getUint32();
+	const sampleCount = iterator.getUint32();
+
+	if (sampleSize !== 0) {
+		return {
+			type: 'stsz-box',
+			boxSize: size,
+			offset,
+			version,
+			flags: [...flags],
+			sampleCount,
+			countType: 'fixed',
+			sampleSize,
+		};
+	}
+
+	const samples: number[] = [];
+	for (let i = 0; i < sampleCount; i++) {
+		const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+		if (bytesRemaining < 4) {
+			break;
+		}
+
+		samples.push(iterator.getUint32());
+	}
+
+	iterator.discard(size - (iterator.counter.getOffset() - offset));
+
+	return {
+		type: 'stsz-box',
+		boxSize: size,
+		offset,
+		version,
+		flags: [...flags],
+		sampleCount,
+		countType: 'variable',
+		entries: samples,
+	};
+};