@remotion/media-parser 4.0.191

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

@@ -0,0 +1,19 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export type SeekPositionSegment = {
+	type: 'seek-position-segment';
+	seekPosition: number;
+};
+
+export const parseSeekPositionSegment = (
+	iterator: BufferIterator,
+): SeekPositionSegment => {
+	const length = iterator.getVint();
+
+	const seekPosition = iterator.getDecimalBytes(length);
+
+	return {
+		type: 'seek-position-segment',
+		seekPosition,
+	};
+};

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

@@ -0,0 +1,23 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {MatroskaSegment} from '../segments';
+import {expectSegment} from '../segments';
+
+export type SeekSegment = {
+	type: 'seek-segment';
+	seekId: string;
+	child: MatroskaSegment;
+};
+
+export const parseSeekSegment = (iterator: BufferIterator): SeekSegment => {
+	// length
+	iterator.discard(4);
+
+	const seekId = iterator.getMatroskaSegmentId();
+	const child = expectSegment(iterator);
+
+	return {
+		type: 'seek-segment',
+		seekId,
+		child,
+	};
+};

package/src/boxes/webm/segments/timestamp-scale.ts

@@ -0,0 +1,17 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export type TimestampScaleSegment = {
+	type: 'timestamp-scale-segment';
+	timestampScale: number;
+};
+
+export const parseTimestampScaleSegment = (
+	iterator: BufferIterator,
+): TimestampScaleSegment => {
+	const timestampScale = iterator.getDecimalBytes(3);
+
+	return {
+		type: 'timestamp-scale-segment',
+		timestampScale,
+	};
+};

package/src/boxes/webm/segments/track-entry.ts

@@ -0,0 +1,295 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {MatroskaSegment} from '../segments';
+import {expectChildren} from './parse-children';
+
+export type TrackEntrySegment = {
+	type: 'track-entry-segment';
+	children: MatroskaSegment[];
+};
+
+export const parseTrackEntry = (
+	iterator: BufferIterator,
+): TrackEntrySegment => {
+	const offset = iterator.counter.getOffset();
+
+	const length = iterator.getVint();
+
+	return {
+		type: 'track-entry-segment',
+		children: expectChildren(
+			iterator,
+			length - (iterator.counter.getOffset() - offset),
+		),
+	};
+};
+
+export type TrackNumberSegment = {
+	type: 'track-number-segment';
+	trackNumber: number;
+};
+
+export const parseTrackNumber = (
+	iterator: BufferIterator,
+): TrackNumberSegment => {
+	const length = iterator.getVint();
+	if (length !== 1) {
+		throw new Error('Expected track number to be 1 byte');
+	}
+
+	const trackNumber = iterator.getUint8();
+
+	return {
+		type: 'track-number-segment',
+		trackNumber,
+	};
+};
+
+export type TrackUIDSegment = {
+	type: 'track-uid-segment';
+	trackUid: string;
+};
+
+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);
+
+	const asString = [...bytes]
+		.map((b) => b.toString(16).padStart(2, '0'))
+		.join('');
+	return {
+		type: 'track-uid-segment',
+		trackUid: asString,
+	};
+};
+
+export type FlagLacingSegment = {
+	type: 'flag-lacing-segment';
+	lacing: boolean;
+};
+
+export const parseFlagLacing = (
+	iterator: BufferIterator,
+): FlagLacingSegment => {
+	const length = iterator.getVint();
+	if (length !== 1) {
+		throw new Error('Expected flag lacing to be 1 byte');
+	}
+
+	const bytes = iterator.getSlice(length);
+
+	if (bytes[0] !== 1 && bytes[0] !== 0) {
+		throw new Error('Expected lacing to be 1 or 0');
+	}
+
+	return {
+		type: 'flag-lacing-segment',
+		lacing: Boolean(bytes[0]),
+	};
+};
+
+export type LanguageSegment = {
+	type: 'language-segment';
+	language: string;
+};
+
+export const parseLanguageSegment = (
+	iterator: BufferIterator,
+): LanguageSegment => {
+	const length = iterator.getVint();
+	if (length !== 3) {
+		throw new Error('Expected language segment to be 3 bytes');
+	}
+
+	const language = iterator.getByteString(length);
+
+	return {
+		type: 'language-segment',
+		language,
+	};
+};
+
+export type CodecSegment = {
+	type: 'codec-segment';
+	codec: string;
+};
+
+export const parseCodecSegment = (iterator: BufferIterator): CodecSegment => {
+	const length = iterator.getVint();
+
+	// Could make a TypeScript enum with it
+	// https://www.matroska.org/technical/codec_specs.html
+	const codec = iterator.getByteString(length);
+
+	return {
+		type: 'codec-segment',
+		codec,
+	};
+};
+
+export type TrackTypeSegment = {
+	type: 'track-type-segment';
+	trackType: number;
+};
+
+export const parseTrackTypeSegment = (
+	iterator: BufferIterator,
+): TrackTypeSegment => {
+	const length = iterator.getVint();
+	if (length !== 1) {
+		throw new Error('Expected track type segment to be 1 byte');
+	}
+
+	const trackType = iterator.getUint8();
+
+	// Could make the return type nicer
+	/* 1 - video,
+  	2 - audio,
+		3 - complex,
+		16 - logo,
+		17 - subtitle,
+		18 - buttons,
+		32 - control,
+		33 - metadata;
+    */
+	return {
+		type: 'track-type-segment',
+		trackType,
+	};
+};
+
+export type DefaultDurationSegment = {
+	type: 'default-duration-segment';
+	defaultDuration: number;
+};
+
+export const parseDefaultDurationSegment = (
+	iterator: BufferIterator,
+): DefaultDurationSegment => {
+	const length = iterator.getVint();
+
+	const defaultDuration = iterator.getDecimalBytes(length);
+
+	return {
+		type: 'default-duration-segment',
+		defaultDuration,
+	};
+};
+
+export type VideoSegment = {
+	type: 'video-segment';
+
+	children: MatroskaSegment[];
+};
+
+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),
+		),
+	};
+};
+
+export type WidthSegment = {
+	type: 'width-segment';
+	width: number;
+};
+
+export const parseWidthSegment = (iterator: BufferIterator): WidthSegment => {
+	const length = iterator.getVint();
+	if (length !== 2) {
+		throw new Error('Expected width segment to be 2 bytes');
+	}
+
+	const width = iterator.getUint16();
+
+	return {
+		type: 'width-segment',
+		width,
+	};
+};
+
+export type HeightSegment = {
+	type: 'height-segment';
+	height: number;
+};
+
+export const parseHeightSegment = (iterator: BufferIterator): HeightSegment => {
+	const length = iterator.getVint();
+	if (length !== 2) {
+		throw new Error('Expected height segment to be 2 bytes');
+	}
+
+	const height = iterator.getUint16();
+
+	return {
+		type: 'height-segment',
+		height,
+	};
+};
+
+export type AlphaModeSegment = {
+	type: 'alpha-mode-segment';
+	alphaMode: number;
+};
+
+export const parseAlphaModeSegment = (
+	iterator: BufferIterator,
+): AlphaModeSegment => {
+	const length = iterator.getVint();
+	if (length !== 1) {
+		throw new Error('Expected alpha mode segment to be 1 byte');
+	}
+
+	const alphaMode = iterator.getUint8();
+
+	return {
+		type: 'alpha-mode-segment',
+		alphaMode,
+	};
+};
+
+export type MaxBlockAdditionId = {
+	type: 'max-block-addition-id-segment';
+	maxBlockAdditionId: number;
+};
+
+export const parseMaxBlockAdditionId = (
+	iterator: BufferIterator,
+): MaxBlockAdditionId => {
+	const length = iterator.getVint();
+	if (length !== 1) {
+		throw new Error('Expected alpha mode segment to be 1 byte');
+	}
+
+	const maxBlockAdditionId = iterator.getUint8();
+
+	return {
+		type: 'max-block-addition-id-segment',
+		maxBlockAdditionId,
+	};
+};
+
+export type ColorSegment = {
+	type: 'color-segment';
+};
+
+export const parseColorSegment = (iterator: BufferIterator): ColorSegment => {
+	const length = iterator.getVint();
+
+	iterator.discard(length - 1);
+
+	return {
+		type: 'color-segment',
+	};
+};

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

@@ -0,0 +1,22 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {MatroskaSegment} from '../segments';
+import {expectChildren} from './parse-children';
+
+export type TracksSegment = {
+	type: 'tracks-segment';
+	children: MatroskaSegment[];
+};
+
+export const parseTracksSegment = (iterator: BufferIterator): TracksSegment => {
+	const offset = iterator.counter.getOffset();
+
+	const length = iterator.getVint();
+
+	return {
+		type: 'tracks-segment',
+		children: expectChildren(
+			iterator,
+			length - (iterator.counter.getOffset() - offset),
+		),
+	};
+};

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

@@ -0,0 +1,19 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export type UnknownSegment = {
+	id: string;
+	type: 'unknown-segment';
+};
+
+export const parseUnknownSegment = (
+	iterator: BufferIterator,
+	id: string,
+	length: number,
+): UnknownSegment => {
+	iterator.discard(length);
+
+	return {
+		id,
+		type: 'unknown-segment',
+	};
+};

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

@@ -0,0 +1,16 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+export type VoidSegment = {
+	type: 'void-segment';
+	length: number;
+};
+
+export const parseVoidSegment = (iterator: BufferIterator): VoidSegment => {
+	const length = iterator.getVint();
+	iterator.discard(length);
+
+	return {
+		type: 'void-segment',
+		length,
+	};
+};

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

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

package/src/boxes/webm/segments.ts

@@ -0,0 +1,206 @@
+import type {BufferIterator} from '../../buffer-iterator';
+import type {DurationSegment} from './segments/duration';
+import {parseDurationSegment} from './segments/duration';
+import type {InfoSegment} from './segments/info';
+import {parseInfoSegment} from './segments/info';
+import type {MainSegment} from './segments/main';
+import {parseMainSegment} from './segments/main';
+import {parseMuxingSegment, type MuxingAppSegment} from './segments/muxing';
+import {parseSeekSegment, type SeekSegment} from './segments/seek';
+import type {SeekHeadSegment} from './segments/seek-head';
+import {parseSeekHeadSegment} from './segments/seek-head';
+import {
+	parseSeekPositionSegment,
+	type SeekPositionSegment,
+} from './segments/seek-position';
+import type {TimestampScaleSegment} from './segments/timestamp-scale';
+import {parseTimestampScaleSegment} from './segments/timestamp-scale';
+import type {
+	AlphaModeSegment,
+	CodecSegment,
+	ColorSegment,
+	DefaultDurationSegment,
+	FlagLacingSegment,
+	HeightSegment,
+	LanguageSegment,
+	MaxBlockAdditionId,
+	TrackEntrySegment,
+	TrackNumberSegment,
+	TrackTypeSegment,
+	TrackUIDSegment,
+	VideoSegment,
+	WidthSegment,
+} from './segments/track-entry';
+import {
+	parseAlphaModeSegment,
+	parseCodecSegment,
+	parseColorSegment,
+	parseDefaultDurationSegment,
+	parseFlagLacing,
+	parseHeightSegment,
+	parseLanguageSegment,
+	parseMaxBlockAdditionId,
+	parseTrackEntry,
+	parseTrackNumber,
+	parseTrackTypeSegment,
+	parseTrackUID,
+	parseVideoSegment,
+	parseWidthSegment,
+} from './segments/track-entry';
+import type {TracksSegment} from './segments/tracks';
+import {parseTracksSegment} from './segments/tracks';
+import type {UnknownSegment} from './segments/unknown';
+import {parseUnknownSegment} from './segments/unknown';
+import type {VoidSegment} from './segments/void';
+import {parseVoidSegment} from './segments/void';
+import type {WritingAppSegment} from './segments/writing';
+import {parseWritingSegment} from './segments/writing';
+
+export type MatroskaSegment =
+	| MainSegment
+	| UnknownSegment
+	| SeekHeadSegment
+	| SeekSegment
+	| SeekPositionSegment
+	| VoidSegment
+	| InfoSegment
+	| TimestampScaleSegment
+	| MuxingAppSegment
+	| WritingAppSegment
+	| DurationSegment
+	| TracksSegment
+	| TrackEntrySegment
+	| TrackNumberSegment
+	| TrackUIDSegment
+	| FlagLacingSegment
+	| LanguageSegment
+	| CodecSegment
+	| TrackTypeSegment
+	| DefaultDurationSegment
+	| VideoSegment
+	| WidthSegment
+	| HeightSegment
+	| AlphaModeSegment
+	| MaxBlockAdditionId
+	| ColorSegment;
+
+export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
+	const segmentId = iterator.getMatroskaSegmentId();
+	if (segmentId === '0x') {
+		return {
+			type: 'unknown-segment',
+			id: segmentId,
+		};
+	}
+
+	if (segmentId === '0x18538067') {
+		return parseMainSegment(iterator);
+	}
+
+	if (segmentId === '0x114d9b74') {
+		return parseSeekHeadSegment(iterator);
+	}
+
+	if (segmentId === '0x4dbb') {
+		return parseSeekSegment(iterator);
+	}
+
+	if (segmentId === '0x53ac') {
+		return parseSeekPositionSegment(iterator);
+	}
+
+	if (segmentId === '0xec') {
+		return parseVoidSegment(iterator);
+	}
+
+	if (segmentId === '0x1549a966') {
+		return parseInfoSegment(iterator);
+	}
+
+	if (segmentId === '0x2ad7b183') {
+		return parseTimestampScaleSegment(iterator);
+	}
+
+	if (segmentId === '0x4d80') {
+		return parseMuxingSegment(iterator);
+	}
+
+	if (segmentId === '0x5741') {
+		return parseWritingSegment(iterator);
+	}
+
+	if (segmentId === '0x4489') {
+		return parseDurationSegment(iterator);
+	}
+
+	if (segmentId === '0x1654ae6b') {
+		return parseTracksSegment(iterator);
+	}
+
+	if (segmentId === '0xae') {
+		return parseTrackEntry(iterator);
+	}
+
+	if (segmentId === '0xd7') {
+		return parseTrackNumber(iterator);
+	}
+
+	if (segmentId === '0x73c5') {
+		return parseTrackUID(iterator);
+	}
+
+	if (segmentId === '0x9c') {
+		return parseFlagLacing(iterator);
+	}
+
+	if (segmentId === '0x22b59c') {
+		return parseLanguageSegment(iterator);
+	}
+
+	if (segmentId === '0x86') {
+		return parseCodecSegment(iterator);
+	}
+
+	if (segmentId === '0x83') {
+		return parseTrackTypeSegment(iterator);
+	}
+
+	if (segmentId === '0x55ee') {
+		return parseMaxBlockAdditionId(iterator);
+	}
+
+	if (segmentId === '0x55b0') {
+		return parseColorSegment(iterator);
+	}
+
+	if (segmentId === '0x23e383') {
+		return parseDefaultDurationSegment(iterator);
+	}
+
+	if (segmentId === '0xe0') {
+		return parseVideoSegment(iterator);
+	}
+
+	if (segmentId === '0xb0') {
+		return parseWidthSegment(iterator);
+	}
+
+	if (segmentId === '0xba') {
+		return parseHeightSegment(iterator);
+	}
+
+	if (segmentId === '0x53c0') {
+		return parseAlphaModeSegment(iterator);
+	}
+
+	const length = iterator.getVint();
+
+	const bytesRemaining = iterator.byteLength() - iterator.counter.getOffset();
+	const toDiscard = Math.min(
+		bytesRemaining,
+		length > 0 ? length : bytesRemaining,
+	);
+
+	const child = parseUnknownSegment(iterator, segmentId, toDiscard);
+	return child;
+};