@remotion/media-parser 4.0.194 → 4.0.196

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

@@ -1,4 +1,5 @@
 import type {BufferIterator} from '../../../buffer-iterator';
+import type {ParserContext} from '../../../parser-context';
 import type {MatroskaSegment} from '../segments';
 import {expectChildren} from './parse-children';
 
@@ -7,19 +8,25 @@ export type TrackEntrySegment = {
 	children: MatroskaSegment[];
 };
 
-export const parseTrackEntry = (
+export const parseTrackEntry = async (
 	iterator: BufferIterator,
-): TrackEntrySegment => {
-	const offset = iterator.counter.getOffset();
-
-	const length = iterator.getVint();
+	length: number,
+	parserContext: ParserContext,
+): Promise<TrackEntrySegment> => {
+	const children = await expectChildren({
+		iterator,
+		length,
+		initialChildren: [],
+		wrap: null,
+		parserContext,
+	});
+	if (children.status === 'incomplete') {
+		throw new Error('Incomplete children ' + length);
+	}
 
 	return {
 		type: 'track-entry-segment',
-		children: expectChildren(
-			iterator,
-			length - (iterator.counter.getOffset() - offset),
-		),
+		children: children.segments as MatroskaSegment[],
 	};
 };
 
@@ -28,30 +35,15 @@ export type TrackNumberSegment = {
 	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();
-
+export const parseTrackUID = (
+	iterator: BufferIterator,
+	length: number,
+): TrackUIDSegment => {
 	const bytes = iterator.getSlice(length);
 
 	const asString = [...bytes]
@@ -70,8 +62,8 @@ export type FlagLacingSegment = {
 
 export const parseFlagLacing = (
 	iterator: BufferIterator,
+	length: number,
 ): FlagLacingSegment => {
-	const length = iterator.getVint();
 	if (length !== 1) {
 		throw new Error('Expected flag lacing to be 1 byte');
 	}
@@ -95,8 +87,8 @@ export type LanguageSegment = {
 
 export const parseLanguageSegment = (
 	iterator: BufferIterator,
+	length: number,
 ): LanguageSegment => {
-	const length = iterator.getVint();
 	if (length !== 3) {
 		throw new Error('Expected language segment to be 3 bytes');
 	}
@@ -114,9 +106,10 @@ export type CodecSegment = {
 	codec: string;
 };
 
-export const parseCodecSegment = (iterator: BufferIterator): CodecSegment => {
-	const length = iterator.getVint();
-
+export const parseCodecSegment = (
+	iterator: BufferIterator,
+	length: number,
+): CodecSegment => {
 	// Could make a TypeScript enum with it
 	// https://www.matroska.org/technical/codec_specs.html
 	const codec = iterator.getByteString(length);
@@ -127,21 +120,53 @@ export const parseCodecSegment = (iterator: BufferIterator): CodecSegment => {
 	};
 };
 
+type TrackType =
+	| 'video'
+	| 'audio'
+	| 'complex'
+	| 'subtitle'
+	| 'button'
+	| 'control'
+	| 'metadata';
+
 export type TrackTypeSegment = {
 	type: 'track-type-segment';
-	trackType: number;
+	trackType: TrackType;
+};
+
+const trackTypeToString = (trackType: number): TrackType => {
+	switch (trackType) {
+		case 1:
+			return 'video';
+		case 2:
+			return 'audio';
+		case 3:
+			return 'complex';
+		case 4:
+			return 'subtitle';
+		case 5:
+			return 'button';
+		case 6:
+			return 'control';
+		case 7:
+			return 'metadata';
+		default:
+			throw new Error(`Unknown track type: ${trackType}`);
+	}
 };
 
 export const parseTrackTypeSegment = (
 	iterator: BufferIterator,
+	length: number,
 ): TrackTypeSegment => {
-	const length = iterator.getVint();
 	if (length !== 1) {
 		throw new Error('Expected track type segment to be 1 byte');
 	}
 
 	const trackType = iterator.getUint8();
 
+	const trackTypeString = trackTypeToString(trackType);
+
 	// Could make the return type nicer
 	/* 1 - video,
   	2 - audio,
@@ -154,7 +179,7 @@ export const parseTrackTypeSegment = (
     */
 	return {
 		type: 'track-type-segment',
-		trackType,
+		trackType: trackTypeString,
 	};
 };
 
@@ -165,9 +190,8 @@ export type DefaultDurationSegment = {
 
 export const parseDefaultDurationSegment = (
 	iterator: BufferIterator,
+	length: number,
 ): DefaultDurationSegment => {
-	const length = iterator.getVint();
-
 	const defaultDuration = iterator.getDecimalBytes(length);
 
 	return {
@@ -178,16 +202,57 @@ export const parseDefaultDurationSegment = (
 
 export type VideoSegment = {
 	type: 'video-segment';
-
 	children: MatroskaSegment[];
 };
 
-export const parseVideoSegment = (iterator: BufferIterator): VideoSegment => {
-	const length = iterator.getVint();
+export const parseVideoSegment = async (
+	iterator: BufferIterator,
+	length: number,
+	parserContext: ParserContext,
+): Promise<VideoSegment> => {
+	const children = await expectChildren({
+		iterator,
+		length,
+		initialChildren: [],
+		wrap: null,
+		parserContext,
+	});
+
+	if (children.status === 'incomplete') {
+		throw new Error('Incomplete children');
+	}
 
 	return {
 		type: 'video-segment',
-		children: expectChildren(iterator, length),
+		children: children.segments as MatroskaSegment[],
+	};
+};
+
+export type AudioSegment = {
+	type: 'audio-segment';
+	children: MatroskaSegment[];
+};
+
+export const parseAudioSegment = async (
+	iterator: BufferIterator,
+	length: number,
+	parserContext: ParserContext,
+): Promise<AudioSegment> => {
+	const children = await expectChildren({
+		iterator,
+		length,
+		initialChildren: [],
+		wrap: null,
+		parserContext,
+	});
+
+	if (children.status === 'incomplete') {
+		throw new Error('Incomplete children');
+	}
+
+	return {
+		type: 'audio-segment',
+		children: children.segments as MatroskaSegment[],
 	};
 };
 
@@ -196,8 +261,10 @@ export type WidthSegment = {
 	width: number;
 };
 
-export const parseWidthSegment = (iterator: BufferIterator): WidthSegment => {
-	const length = iterator.getVint();
+export const parseWidthSegment = (
+	iterator: BufferIterator,
+	length: number,
+): WidthSegment => {
 	if (length !== 2) {
 		throw new Error('Expected width segment to be 2 bytes');
 	}
@@ -215,8 +282,10 @@ export type HeightSegment = {
 	height: number;
 };
 
-export const parseHeightSegment = (iterator: BufferIterator): HeightSegment => {
-	const length = iterator.getVint();
+export const parseHeightSegment = (
+	iterator: BufferIterator,
+	length: number,
+): HeightSegment => {
 	if (length !== 2) {
 		throw new Error('Expected height segment to be 2 bytes');
 	}
@@ -229,6 +298,52 @@ export const parseHeightSegment = (iterator: BufferIterator): HeightSegment => {
 	};
 };
 
+export type DisplayWidthSegment = {
+	type: 'display-width-segment';
+	displayWidth: number;
+};
+
+export const parseDisplayWidthSegment = (
+	iterator: BufferIterator,
+	length: number,
+): DisplayWidthSegment => {
+	if (length !== 2) {
+		throw new Error(
+			`Expected display width segment to be 2 bytes, got ${length}`,
+		);
+	}
+
+	const displayWidth = iterator.getUint16();
+
+	return {
+		type: 'display-width-segment',
+		displayWidth,
+	};
+};
+
+export type DisplayHeightSegment = {
+	type: 'display-height-segment';
+	displayHeight: number;
+};
+
+export const parseDisplayHeightSegment = (
+	iterator: BufferIterator,
+	length: number,
+): DisplayHeightSegment => {
+	if (length !== 2) {
+		throw new Error(
+			`Expected display height segment to be 2 bytes, got ${length}`,
+		);
+	}
+
+	const displayHeight = iterator.getUint16();
+
+	return {
+		type: 'display-height-segment',
+		displayHeight,
+	};
+};
+
 export type AlphaModeSegment = {
 	type: 'alpha-mode-segment';
 	alphaMode: number;
@@ -236,8 +351,8 @@ export type AlphaModeSegment = {
 
 export const parseAlphaModeSegment = (
 	iterator: BufferIterator,
+	length: number,
 ): AlphaModeSegment => {
-	const length = iterator.getVint();
 	if (length !== 1) {
 		throw new Error('Expected alpha mode segment to be 1 byte');
 	}
@@ -257,8 +372,8 @@ export type MaxBlockAdditionId = {
 
 export const parseMaxBlockAdditionId = (
 	iterator: BufferIterator,
+	length: number,
 ): MaxBlockAdditionId => {
-	const length = iterator.getVint();
 	if (length !== 1) {
 		throw new Error('Expected alpha mode segment to be 1 byte');
 	}
@@ -273,15 +388,18 @@ export const parseMaxBlockAdditionId = (
 
 export type ColorSegment = {
 	type: 'color-segment';
+	length: number;
 };
 
-export const parseColorSegment = (iterator: BufferIterator): ColorSegment => {
-	const length = iterator.getVint();
-
+export const parseColorSegment = (
+	iterator: BufferIterator,
+	length: number,
+): ColorSegment => {
 	iterator.discard(length);
 
 	return {
 		type: 'color-segment',
+		length,
 	};
 };
 
@@ -290,8 +408,10 @@ export type TitleSegment = {
 	title: string;
 };
 
-export const parseTitleSegment = (iterator: BufferIterator): TitleSegment => {
-	const length = iterator.getVint();
+export const parseTitleSegment = (
+	iterator: BufferIterator,
+	length: number,
+): TitleSegment => {
 	const title = iterator.getByteString(length);
 
 	return {
@@ -307,10 +427,12 @@ export type InterlacedSegment = {
 
 export const parseInterlacedSegment = (
 	iterator: BufferIterator,
+	length: number,
 ): InterlacedSegment => {
-	const length = iterator.getVint();
 	if (length !== 1) {
-		throw new Error('Expected interlaced segment to be 1 byte');
+		throw new Error(
+			'Expected interlaced segment to be 1 byte, but is ' + length,
+		);
 	}
 
 	const interlaced = iterator.getUint8();
@@ -323,17 +445,16 @@ export const parseInterlacedSegment = (
 
 export type CodecPrivateSegment = {
 	type: 'codec-private-segment';
-	codecPrivateData: number[];
+	codecPrivateData: Uint8Array;
 };
 
 export const parseCodecPrivateSegment = (
 	iterator: BufferIterator,
+	length: number,
 ): CodecPrivateSegment => {
-	const length = iterator.getVint();
-
 	return {
 		type: 'codec-private-segment',
-		codecPrivateData: [...iterator.getSlice(length)],
+		codecPrivateData: iterator.getSlice(length),
 	};
 };
 
@@ -342,9 +463,10 @@ export type Crc32Segment = {
 	crc32: number[];
 };
 
-export const parseCrc32Segment = (iterator: BufferIterator): Crc32Segment => {
-	const length = iterator.getVint();
-
+export const parseCrc32Segment = (
+	iterator: BufferIterator,
+	length: number,
+): Crc32Segment => {
 	return {
 		type: 'crc32-segment',
 		crc32: [...iterator.getSlice(length)],
@@ -358,9 +480,8 @@ export type SegmentUUIDSegment = {
 
 export const parseSegmentUUIDSegment = (
 	iterator: BufferIterator,
+	length: number,
 ): SegmentUUIDSegment => {
-	const length = iterator.getVint();
-
 	return {
 		type: 'segment-uuid-segment',
 		segmentUUID: iterator.getSlice(length).toString(),
@@ -374,8 +495,8 @@ export type DefaultFlagSegment = {
 
 export const parseDefaultFlagSegment = (
 	iterator: BufferIterator,
+	length: number,
 ): DefaultFlagSegment => {
-	const length = iterator.getVint();
 	if (length !== 1) {
 		throw new Error('Expected default flag segment to be 1 byte');
 	}
@@ -385,3 +506,292 @@ export const parseDefaultFlagSegment = (
 		defaultFlag: Boolean(iterator.getUint8()),
 	};
 };
+
+export type TagsSegment = {
+	type: 'tags-segment';
+	children: MatroskaSegment[];
+};
+
+export const parseTagsSegment = async (
+	iterator: BufferIterator,
+	length: number,
+	parserContext: ParserContext,
+): Promise<TagsSegment> => {
+	const children = await expectChildren({
+		iterator,
+		length,
+		initialChildren: [],
+		wrap: null,
+		parserContext,
+	});
+
+	if (children.status === 'incomplete') {
+		throw new Error('Incomplete children');
+	}
+
+	return {
+		type: 'tags-segment',
+		children: children.segments as MatroskaSegment[],
+	};
+};
+
+export type TagSegment = {
+	type: 'tag-segment';
+	length: number;
+};
+
+export const parseTagSegment = (
+	iterator: BufferIterator,
+	length: number,
+): TagSegment => {
+	iterator.discard(length);
+
+	return {
+		type: 'tag-segment',
+		length,
+	};
+};
+
+export type ClusterSegment = {
+	type: 'cluster-segment';
+	children: MatroskaSegment[];
+};
+
+export type TimestampSegment = {
+	type: 'timestamp-segment';
+	timestamp: number;
+};
+
+export const parseTimestampSegment = (
+	iterator: BufferIterator,
+	length: number,
+): TimestampSegment => {
+	if (length > 2) {
+		throw new Error('Expected timestamp segment to be 1 byte or 2 bytes');
+	}
+
+	const value = length === 2 ? iterator.getUint16() : iterator.getUint8();
+
+	return {
+		type: 'timestamp-segment',
+		timestamp: value,
+	};
+};
+
+export type SimpleBlockSegment = {
+	type: 'simple-block-segment';
+	length: number;
+	trackNumber: number;
+	timecode: number;
+	headerFlags: number;
+	keyframe: boolean;
+	lacing: [number, number];
+	invisible: boolean;
+	children: MatroskaSegment[];
+};
+
+export type GetTracks = () => TrackEntrySegment[];
+
+export const parseSimpleBlockSegment = async ({
+	iterator,
+	length,
+	parserContext,
+}: {
+	iterator: BufferIterator;
+	length: number;
+	parserContext: ParserContext;
+}): Promise<SimpleBlockSegment> => {
+	const start = iterator.counter.getOffset();
+	const trackNumber = iterator.getVint();
+	const timecode = iterator.getUint16();
+	const headerFlags = iterator.getUint8();
+
+	const invisible = Boolean((headerFlags >> 5) & 1);
+	const pos6 = (headerFlags >> 6) & 1;
+	const pos7 = (headerFlags >> 6) & 1;
+	const keyframe = Boolean((headerFlags >> 7) & 1);
+
+	const codec = parserContext.parserState.getTrackInfoByNumber(trackNumber);
+
+	if (!codec) {
+		throw new Error('Could not find codec for track ' + trackNumber);
+	}
+
+	const children: MatroskaSegment[] = [];
+
+	if (codec.codec.startsWith('V_')) {
+		const remainingNow = length - (iterator.counter.getOffset() - start);
+
+		await parserContext.parserState.onVideoSample(trackNumber, {
+			data: iterator.getSlice(remainingNow),
+			cts: null,
+			dts: null,
+			duration: undefined,
+			type: keyframe ? 'key' : 'delta',
+			trackId: trackNumber,
+			timestamp: timecode,
+		});
+	}
+
+	if (codec.codec.startsWith('A_')) {
+		const vorbisRemaining = length - (iterator.counter.getOffset() - start);
+		await parserContext.parserState.onAudioSample(trackNumber, {
+			data: iterator.getSlice(vorbisRemaining),
+			offset: timecode,
+			trackId: trackNumber,
+			timestamp: timecode,
+			type: 'key',
+		});
+	}
+
+	const remainingNowAfter = length - (iterator.counter.getOffset() - start);
+	if (remainingNowAfter > 0) {
+		iterator.discard(remainingNowAfter);
+	}
+
+	return {
+		type: 'simple-block-segment',
+		length,
+		trackNumber,
+		timecode,
+		headerFlags,
+		keyframe,
+		lacing: [pos6, pos7],
+		invisible,
+		children,
+	};
+};
+
+export const parseTrackNumber = (
+	iterator: BufferIterator,
+	length: number,
+): TrackNumberSegment => {
+	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 BlockGroupSegment = {
+	type: 'block-group-segment';
+	children: MatroskaSegment[];
+};
+
+export const parseBlockGroupSegment = async (
+	iterator: BufferIterator,
+	length: number,
+	parserContext: ParserContext,
+): Promise<BlockGroupSegment> => {
+	const children = await expectChildren({
+		iterator,
+		length,
+		initialChildren: [],
+		wrap: null,
+		parserContext,
+	});
+	if (children.status === 'incomplete') {
+		throw new Error('Incomplete boxes are not allowed');
+	}
+
+	return {
+		type: 'block-group-segment',
+		children: children.segments as MatroskaSegment[],
+	};
+};
+
+export type BlockElement = {
+	type: 'block-element-segment';
+	length: number;
+};
+
+export const parseBlockElementSegment = (
+	iterator: BufferIterator,
+	length: number,
+): BlockElement => {
+	iterator.discard(length);
+
+	return {
+		type: 'block-element-segment',
+		length,
+	};
+};
+
+export type SamplingFrequencySegment = {
+	type: 'sampling-frequency-segment';
+	samplingFrequency: number;
+};
+
+export const parseSamplingFrequencySegment = (
+	iterator: BufferIterator,
+	length: number,
+): SamplingFrequencySegment => {
+	if (length === 4) {
+		return {
+			type: 'sampling-frequency-segment',
+			samplingFrequency: iterator.getFloat32(),
+		};
+	}
+
+	if (length === 8) {
+		return {
+			type: 'sampling-frequency-segment',
+			samplingFrequency: iterator.getFloat64(),
+		};
+	}
+
+	throw new Error(
+		`Expected length of sampling frequency segment to be 4 or 8, got ${length}`,
+	);
+};
+
+export type ChannelsSegment = {
+	type: 'channels-segment';
+	channels: number;
+};
+
+export const parseChannelsSegment = (
+	iterator: BufferIterator,
+	length: number,
+): ChannelsSegment => {
+	if (length !== 1) {
+		throw new Error(
+			`Expected length of channels segment to be 1, got ${length}`,
+		);
+	}
+
+	const channels = iterator.getUint8();
+
+	return {
+		type: 'channels-segment',
+		channels,
+	};
+};
+
+export type BitDepthSegment = {
+	type: 'bit-depth-segment';
+	bitDepth: number;
+};
+
+export const parseBitDepthSegment = (
+	iterator: BufferIterator,
+	length: number,
+): BitDepthSegment => {
+	if (length !== 1) {
+		throw new Error(
+			`Expected length of bit depth segment to be 1, got ${length}`,
+		);
+	}
+
+	const bitDepth = iterator.getUint8();
+
+	return {
+		type: 'bit-depth-segment',
+		bitDepth,
+	};
+};