@remotion/media-parser 4.0.191

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

@@ -0,0 +1,298 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+type SampleBase = {
+	format: string;
+	offset: number;
+	dataReferenceIndex: number;
+	version: number;
+	revisionLevel: number;
+	vendor: number[];
+	size: number;
+};
+
+type AudioSample = SampleBase & {
+	type: 'audio';
+	numberOfChannels: number;
+	sampleSize: number;
+	compressionId: number;
+	packetSize: number;
+	sampleRate: number;
+	samplesPerPacket: number | null;
+	bytesPerPacket: number | null;
+	bytesPerFrame: number | null;
+	bitsPerSample: number | null;
+};
+
+type VideoSample = SampleBase & {
+	type: 'video';
+	temporalQuality: number;
+	spacialQuality: number;
+	width: number;
+	height: number;
+	compressorName: number[];
+	horizontalResolutionPpi: number;
+	verticalResolutionPpi: number;
+	dataSize: number;
+	frameCountPerSample: number;
+	depth: number;
+	colorTableId: number;
+};
+
+type UnknownSample = SampleBase & {
+	type: 'unknown';
+};
+
+export type Sample = AudioSample | VideoSample | UnknownSample;
+
+type SampleAndNext = {
+	sample: Sample | null;
+};
+
+// https://developer.apple.com/documentation/quicktime-file-format/video_sample_description
+const videoTags = [
+	'cvid',
+	'jpeg',
+	'smc ',
+	'rle ',
+	'rpza',
+	'kpcd',
+	'png ',
+	'mjpa',
+	'mjpb',
+	'SVQ1',
+	'SVQ3',
+	'mp4v',
+	'avc1',
+	'dvc ',
+	'dvcp',
+	'gif ',
+	'h263',
+	'tiff',
+	'raw ',
+	'2vuY',
+	'yuv2',
+	'v308',
+	'v408',
+	'v216',
+	'v410',
+	'v210',
+	'hvc1',
+];
+
+// https://developer.apple.com/documentation/quicktime-file-format/sound_sample_descriptions
+const audioTags = [
+	0x00000000,
+	'NONE',
+	'raw ',
+	'twos',
+	'sowt',
+	'MAC3 ',
+	'MAC6 ',
+	'ima4',
+	'fl32',
+	'fl64',
+	'in24',
+	'in32',
+	'ulaw',
+	'alaw',
+	0x6d730002,
+	0x6d730011,
+	'dvca',
+	'QDMC',
+	'QDM2',
+	'Qclp',
+	0x6d730055,
+	'.mp3',
+	'mp4a',
+	'ac-3',
+];
+
+export const processSample = ({
+	iterator,
+}: {
+	iterator: BufferIterator;
+}): SampleAndNext => {
+	const fileOffset = iterator.counter.getOffset();
+	const bytesRemaining = iterator.bytesRemaining();
+	const boxSize = iterator.getUint32();
+
+	if (bytesRemaining < boxSize) {
+		throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSize}`);
+	}
+
+	const boxFormat = iterator.getAtom();
+
+	const isVideo = videoTags.includes(boxFormat);
+	const isAudio =
+		audioTags.includes(boxFormat) || audioTags.includes(Number(boxFormat));
+
+	// 6 reserved bytes
+	iterator.discard(6);
+
+	const dataReferenceIndex = iterator.getUint16();
+	const version = iterator.getUint16();
+	const revisionLevel = iterator.getUint16();
+	const vendor = iterator.getSlice(4);
+
+	if (!isVideo && !isAudio) {
+		const bytesRemainingInBox =
+			boxSize - (iterator.counter.getOffset() - fileOffset);
+		iterator.discard(bytesRemainingInBox);
+
+		return {
+			sample: {
+				type: 'unknown',
+				offset: fileOffset,
+				dataReferenceIndex,
+				version,
+				revisionLevel,
+				vendor: [...Array.from(new Uint8Array(vendor))],
+				size: boxSize,
+				format: boxFormat,
+			},
+		};
+	}
+
+	if (isAudio) {
+		if (version === 0) {
+			const numberOfChannels = iterator.getUint16();
+			const sampleSize = iterator.getUint16();
+			const compressionId = iterator.getUint16();
+			const packetSize = iterator.getUint16();
+			const sampleRate = iterator.getFixedPoint1616Number();
+
+			const bytesRemainingInBox =
+				boxSize - (iterator.counter.getOffset() - fileOffset);
+			iterator.discard(bytesRemainingInBox);
+
+			return {
+				sample: {
+					format: boxFormat,
+					offset: fileOffset,
+					dataReferenceIndex,
+					version,
+					revisionLevel,
+					vendor: [...Array.from(new Uint8Array(vendor))],
+					size: boxSize,
+					type: 'audio',
+					numberOfChannels,
+					sampleSize,
+					compressionId,
+					packetSize,
+					sampleRate,
+					samplesPerPacket: null,
+					bytesPerPacket: null,
+					bytesPerFrame: null,
+					bitsPerSample: null,
+				},
+			};
+		}
+
+		if (version === 1) {
+			const numberOfChannels = iterator.getUint16();
+			const sampleSize = iterator.getUint16();
+			const compressionId = iterator.getUint16();
+			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 bytesRemainingInBox =
+				boxSize - (iterator.counter.getOffset() - fileOffset);
+			iterator.discard(bytesRemainingInBox);
+
+			return {
+				sample: {
+					format: boxFormat,
+					offset: fileOffset,
+					dataReferenceIndex,
+					version,
+					revisionLevel,
+					vendor: [...Array.from(new Uint8Array(vendor))],
+					size: boxSize,
+					type: 'audio',
+					numberOfChannels,
+					sampleSize,
+					compressionId,
+					packetSize,
+					sampleRate,
+					samplesPerPacket,
+					bytesPerPacket,
+					bytesPerFrame,
+					bitsPerSample,
+				},
+			};
+		}
+
+		throw new Error(`Unsupported version ${version}`);
+	}
+
+	if (isVideo) {
+		const temporalQuality = iterator.getUint32();
+		const spacialQuality = iterator.getUint32();
+		const width = iterator.getUint16();
+		const height = iterator.getUint16();
+		const horizontalResolution = iterator.getFixedPoint1616Number();
+		const verticalResolution = iterator.getFixedPoint1616Number();
+		const dataSize = iterator.getUint32();
+		const frameCountPerSample = iterator.getUint16();
+		const compressorName = iterator.getPascalString();
+		const depth = iterator.getUint16();
+		const colorTableId = iterator.getInt16();
+
+		const bytesRemainingInBox =
+			boxSize - (iterator.counter.getOffset() - fileOffset);
+		iterator.discard(bytesRemainingInBox);
+
+		return {
+			sample: {
+				format: boxFormat,
+				offset: fileOffset,
+				dataReferenceIndex,
+				version,
+				revisionLevel,
+				vendor: [...Array.from(new Uint8Array(vendor))],
+				size: boxSize,
+				type: 'video',
+				width,
+				height,
+				horizontalResolutionPpi: horizontalResolution,
+				verticalResolutionPpi: verticalResolution,
+				spacialQuality,
+				temporalQuality,
+				dataSize,
+				frameCountPerSample,
+				compressorName,
+				depth,
+				colorTableId,
+			},
+		};
+	}
+
+	throw new Error(`Unknown sample format ${boxFormat}`);
+};
+
+export const parseSamples = (
+	iterator: BufferIterator,
+	maxBytes: number,
+): Sample[] => {
+	const samples: Sample[] = [];
+	const initialOffset = iterator.counter.getOffset();
+
+	while (
+		iterator.bytesRemaining() > 0 &&
+		iterator.counter.getOffset() - initialOffset < maxBytes
+	) {
+		const {sample} = processSample({
+			iterator,
+		});
+
+		if (sample) {
+			samples.push(sample);
+		}
+	}
+
+	return samples;
+};

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

@@ -0,0 +1,48 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {BaseBox} from '../base-type';
+import type {Sample} from './samples';
+import {parseSamples} from './samples';
+
+export interface StsdBox extends BaseBox {
+	type: 'stsd-box';
+	numberOfEntries: number;
+	samples: Sample[];
+}
+
+export const parseStsd = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): StsdBox => {
+	const version = iterator.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported STSD version ${version}`);
+	}
+
+	// flags, we discard them
+	iterator.discard(3);
+
+	const numberOfEntries = iterator.getUint32();
+
+	const bytesRemainingInBox = size - (iterator.counter.getOffset() - offset);
+
+	const boxes = parseSamples(iterator, bytesRemainingInBox);
+
+	if (boxes.length !== numberOfEntries) {
+		throw new Error(
+			`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`,
+		);
+	}
+
+	return {
+		type: 'stsd-box',
+		boxSize: size,
+		offset,
+		numberOfEntries,
+		samples: boxes,
+	};
+};

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

@@ -0,0 +1,62 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export interface SttsBox {
+	type: 'stts-box';
+	sampleDistribution: SampleDistribution[];
+}
+
+type SampleDistribution = {
+	sampleCount: number;
+	sampleDelta: number;
+};
+
+export const parseStts = ({
+	data,
+	size,
+	fileOffset,
+}: {
+	data: BufferIterator;
+	size: number;
+	fileOffset: number;
+}): SttsBox => {
+	const initialOffset = data.counter.getOffset();
+	const initialCounter = initialOffset - fileOffset;
+
+	const version = data.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported STTS version ${version}`);
+	}
+
+	// flags, we discard them
+	data.discard(3);
+
+	// entry count
+	const entryCount = data.getUint32();
+
+	const sampleDistributions: SampleDistribution[] = [];
+
+	// entries
+	for (let i = 0; i < entryCount; i++) {
+		const sampleCount = data.getUint32();
+		const sampleDelta = data.getUint32();
+
+		const sampleDistribution: SampleDistribution = {
+			sampleCount,
+			sampleDelta,
+		};
+		sampleDistributions.push(sampleDistribution);
+	}
+
+	const bytesUsed = data.counter.getOffset() - initialOffset + initialCounter;
+
+	if (bytesUsed !== size) {
+		throw new Error(
+			`Expected stts box to be ${size} bytes, but was ${bytesUsed} bytes`,
+		);
+	}
+
+	return {
+		type: 'stts-box',
+		sampleDistribution: sampleDistributions,
+	};
+};

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

@@ -0,0 +1,105 @@
+import type {BufferIterator} from '../../buffer-iterator';
+import type {BaseBox} from './base-type';
+import type {ThreeDMatrix} from './mvhd';
+import {toUnixTimestamp} from './to-date';
+
+export interface TkhdBox extends BaseBox {
+	type: 'tkhd-box';
+	alternateGroup: number;
+	creationTime: number | null;
+	duration: number;
+	modificationTime: number | null;
+	trackId: number;
+	version: number;
+	layer: number;
+	volume: number;
+	matrix: ThreeDMatrix;
+	width: number;
+	height: number;
+}
+
+export const parseTkhd = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): TkhdBox => {
+	if (size !== 92) {
+		throw new Error(`Expected tkhd size of version 0 to be 92, got ${size}`);
+	}
+
+	const version = iterator.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported TKHD version ${version}`);
+	}
+
+	// Flags, we discard them
+	iterator.discard(3);
+
+	const creationTime = iterator.getUint32();
+
+	const modificationTime = iterator.getUint32();
+
+	const trackId = iterator.getUint32();
+
+	// reserved
+	iterator.discard(4);
+
+	const duration = iterator.getUint32();
+
+	// reserved 2
+	iterator.discard(4);
+
+	// reserved 3
+	iterator.discard(4);
+
+	const layer = iterator.getUint16();
+
+	const alternateGroup = iterator.getUint16();
+
+	const volume = iterator.getUint16();
+
+	// reserved 4
+	iterator.discard(2);
+
+	const matrix = [
+		iterator.getUint32(),
+		iterator.getUint32(),
+		iterator.getUint32(),
+		iterator.getUint32(),
+		iterator.getUint32(),
+		iterator.getUint32(),
+		iterator.getUint32(),
+		iterator.getUint32(),
+		iterator.getUint32(),
+	];
+	const widthWithoutRotationApplied =
+		iterator.getUint32() / (matrix[0] === 0 ? 1 : matrix[0]);
+	const heightWithoutRotationApplied =
+		iterator.getUint32() / (matrix[4] === 0 ? 1 : matrix[4]);
+
+	// TODO: This is not correct, HEVC videos with matrix is wrong
+	const width = widthWithoutRotationApplied / (matrix[1] === 0 ? 1 : matrix[1]);
+	const height =
+		heightWithoutRotationApplied / (matrix[1] === 0 ? 1 : matrix[1]);
+
+	return {
+		offset,
+		boxSize: size,
+		type: 'tkhd-box',
+		creationTime: toUnixTimestamp(creationTime),
+		modificationTime: toUnixTimestamp(modificationTime),
+		trackId,
+		duration,
+		layer,
+		alternateGroup,
+		volume,
+		matrix: matrix as ThreeDMatrix,
+		width,
+		height,
+		version,
+	};
+};

package/src/boxes/iso-base-media/to-date.ts

@@ -0,0 +1,9 @@
+export const toUnixTimestamp = (value: number): number | null => {
+	if (value === 0) {
+		return null;
+	}
+
+	const baseDate = new Date('1904-01-01T00:00:00Z');
+
+	return Math.floor(value + baseDate.getTime() / 1000) * 1000;
+};

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

@@ -0,0 +1,37 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {AnySegment} from '../../../parse-result';
+import type {BaseBox} from '../base-type';
+import {parseBoxes} from '../process-box';
+
+export interface TrakBox extends BaseBox {
+	type: 'trak-box';
+	children: AnySegment[];
+}
+
+export const parseTrak = ({
+	data,
+	size,
+	offsetAtStart,
+}: {
+	data: BufferIterator;
+	size: number;
+	offsetAtStart: number;
+}): TrakBox => {
+	const children = parseBoxes({
+		iterator: data,
+		maxBytes: size - (data.counter.getOffset() - offsetAtStart),
+		allowIncompleteBoxes: false,
+		initialBoxes: [],
+	});
+
+	if (children.status === 'incomplete') {
+		throw new Error('Incomplete boxes are not allowed');
+	}
+
+	return {
+		offset: offsetAtStart,
+		boxSize: size,
+		type: 'trak-box',
+		children: children.segments,
+	};
+};

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

@@ -0,0 +1,18 @@
+import type {BufferIterator} from '../../buffer-iterator';
+import type {ParseResult} from '../../parse-result';
+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();
+
+	if (length !== 31) {
+		throw new Error(`Expected header length 31, got ${length}`);
+	}
+
+	// Discard header for now
+	counter.discard(31);
+
+	return {status: 'done', segments: [expectSegment(counter)]};
+};

package/src/boxes/webm/segments/duration.ts

@@ -0,0 +1,22 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export type DurationSegment = {
+	type: 'duration-segment';
+	duration: number;
+};
+
+export const parseDurationSegment = (
+	iterator: BufferIterator,
+): DurationSegment => {
+	const length = iterator.getVint();
+	if (length !== 8) {
+		throw new Error('Expected duration segment to be 8 bytes');
+	}
+
+	const duration = iterator.getFloat64();
+
+	return {
+		type: 'duration-segment',
+		duration,
+	};
+};

package/src/boxes/webm/segments/info.ts

@@ -0,0 +1,20 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {MatroskaSegment} from '../segments';
+import {expectChildren} from './parse-children';
+
+export type InfoSegment = {
+	type: 'info-segment';
+	length: number;
+	children: MatroskaSegment[];
+};
+
+export const parseInfoSegment = (iterator: BufferIterator): InfoSegment => {
+	const length = iterator.getVint();
+	const children = expectChildren(iterator, length);
+
+	return {
+		type: 'info-segment',
+		length,
+		children,
+	};
+};

package/src/boxes/webm/segments/main.ts

@@ -0,0 +1,19 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import {type MatroskaSegment} from '../segments';
+import {expectChildren} from './parse-children';
+
+export type MainSegment = {
+	type: 'main-segment';
+	children: MatroskaSegment[];
+};
+
+export const parseMainSegment = (iterator: BufferIterator): MainSegment => {
+	const length = iterator.getVint();
+
+	const children = expectChildren(iterator, length);
+
+	return {
+		type: 'main-segment',
+		children,
+	};
+};

package/src/boxes/webm/segments/muxing.ts

@@ -0,0 +1,18 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export type MuxingAppSegment = {
+	type: 'muxing-app-segment';
+	value: string;
+};
+
+export const parseMuxingSegment = (
+	iterator: BufferIterator,
+): MuxingAppSegment => {
+	const length = iterator.getVint();
+	const value = iterator.getByteString(length);
+
+	return {
+		type: 'muxing-app-segment',
+		value,
+	};
+};

package/src/boxes/webm/segments/parse-children.ts

@@ -0,0 +1,21 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {MatroskaSegment} from '../segments';
+import {expectSegment} from '../segments';
+
+export const expectChildren = (
+	iterator: BufferIterator,
+	length: number,
+): MatroskaSegment[] => {
+	const children: MatroskaSegment[] = [];
+	const startOffset = iterator.counter.getOffset();
+
+	while (iterator.counter.getOffset() < startOffset + length) {
+		const child = expectSegment(iterator);
+		children.push(child);
+		if (child.type === 'unknown-segment') {
+			break;
+		}
+	}
+
+	return children;
+};

package/src/boxes/webm/segments/seek-head.ts

@@ -0,0 +1,21 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import {type MatroskaSegment} from '../segments';
+import {expectChildren} from './parse-children';
+
+export type SeekHeadSegment = {
+	type: 'seek-head-segment';
+	children: MatroskaSegment[];
+	length: number;
+};
+
+export const parseSeekHeadSegment = (
+	iterator: BufferIterator,
+): SeekHeadSegment => {
+	const length = iterator.getVint();
+
+	return {
+		type: 'seek-head-segment',
+		length,
+		children: expectChildren(iterator, length),
+	};
+};