@remotion/media-parser 4.0.194 → 4.0.196

package/src/boxes/webm/segments/tracks.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,16 +8,25 @@ export type TracksSegment = {
 	children: MatroskaSegment[];
 };
 
-export const parseTracksSegment = (iterator: BufferIterator): TracksSegment => {
-	const offset = iterator.counter.getOffset();
+export const parseTracksSegment = async (
+	iterator: BufferIterator,
+	length: number,
+	parserContext: ParserContext,
+): Promise<TracksSegment> => {
+	const children = await expectChildren({
+		iterator,
+		length,
+		initialChildren: [],
+		wrap: null,
+		parserContext,
+	});
 
-	const length = iterator.getVint();
+	if (children.status === 'incomplete') {
+		throw new Error('Incomplete children');
+	}
 
 	return {
 		type: 'tracks-segment',
-		children: expectChildren(
-			iterator,
-			length - (iterator.counter.getOffset() - offset),
-		),
+		children: children.segments as MatroskaSegment[],
 	};
 };

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

@@ -5,8 +5,10 @@ export type VoidSegment = {
 	length: number;
 };
 
-export const parseVoidSegment = (iterator: BufferIterator): VoidSegment => {
-	const length = iterator.getVint();
+export const parseVoidSegment = (
+	iterator: BufferIterator,
+	length: number,
+): VoidSegment => {
 	iterator.discard(length);
 
 	return {

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

@@ -7,8 +7,8 @@ export type WritingAppSegment = {
 
 export const parseWritingSegment = (
 	iterator: BufferIterator,
+	length: number,
 ): WritingAppSegment => {
-	const length = iterator.getVint();
 	const value = iterator.getByteString(length);
 
 	return {

package/src/boxes/webm/segments.ts

@@ -1,12 +1,22 @@
+import {registerTrack} from '../../add-new-matroska-tracks';
 import type {BufferIterator} from '../../buffer-iterator';
+import type {ParseResult} from '../../parse-result';
+import type {ParserContext} from '../../parser-context';
+import {getTrack} from './get-track';
+import {matroskaElements} from './segments/all-segments';
 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 {type MainSegment} from './segments/main';
 import {parseMuxingSegment, type MuxingAppSegment} from './segments/muxing';
-import {parseSeekSegment, type SeekSegment} from './segments/seek';
+import {expectChildren} from './segments/parse-children';
+import type {SeekIdSegment} from './segments/seek';
+import {
+	parseSeekIdSegment,
+	parseSeekSegment,
+	type SeekSegment,
+} from './segments/seek';
 import type {SeekHeadSegment} from './segments/seek-head';
 import {parseSeekHeadSegment} from './segments/seek-head';
 import {
@@ -17,18 +27,31 @@ import type {TimestampScaleSegment} from './segments/timestamp-scale';
 import {parseTimestampScaleSegment} from './segments/timestamp-scale';
 import type {
 	AlphaModeSegment,
+	AudioSegment,
+	BitDepthSegment,
+	BlockElement,
+	BlockGroupSegment,
+	ChannelsSegment,
+	ClusterSegment,
 	CodecPrivateSegment,
 	CodecSegment,
 	ColorSegment,
 	Crc32Segment,
 	DefaultDurationSegment,
 	DefaultFlagSegment,
+	DisplayHeightSegment,
+	DisplayWidthSegment,
 	FlagLacingSegment,
 	HeightSegment,
 	InterlacedSegment,
 	LanguageSegment,
 	MaxBlockAdditionId,
+	SamplingFrequencySegment,
 	SegmentUUIDSegment,
+	SimpleBlockSegment,
+	TagSegment,
+	TagsSegment,
+	TimestampSegment,
 	TitleSegment,
 	TrackEntrySegment,
 	TrackNumberSegment,
@@ -39,18 +62,30 @@ import type {
 } from './segments/track-entry';
 import {
 	parseAlphaModeSegment,
+	parseAudioSegment,
+	parseBitDepthSegment,
+	parseBlockElementSegment,
+	parseBlockGroupSegment,
+	parseChannelsSegment,
 	parseCodecPrivateSegment,
 	parseCodecSegment,
 	parseColorSegment,
 	parseCrc32Segment,
 	parseDefaultDurationSegment,
 	parseDefaultFlagSegment,
+	parseDisplayHeightSegment,
+	parseDisplayWidthSegment,
 	parseFlagLacing,
 	parseHeightSegment,
 	parseInterlacedSegment,
 	parseLanguageSegment,
 	parseMaxBlockAdditionId,
+	parseSamplingFrequencySegment,
 	parseSegmentUUIDSegment,
+	parseSimpleBlockSegment,
+	parseTagSegment,
+	parseTagsSegment,
+	parseTimestampSegment,
 	parseTitleSegment,
 	parseTrackEntry,
 	parseTrackNumber,
@@ -92,6 +127,8 @@ export type MatroskaSegment =
 	| VideoSegment
 	| WidthSegment
 	| HeightSegment
+	| DisplayWidthSegment
+	| DisplayHeightSegment
 	| AlphaModeSegment
 	| MaxBlockAdditionId
 	| ColorSegment
@@ -100,10 +137,37 @@ export type MatroskaSegment =
 	| CodecPrivateSegment
 	| Crc32Segment
 	| SegmentUUIDSegment
-	| DefaultFlagSegment;
+	| DefaultFlagSegment
+	| TagsSegment
+	| TagSegment
+	| ClusterSegment
+	| TimestampSegment
+	| SimpleBlockSegment
+	| BlockGroupSegment
+	| BlockElement
+	| SeekIdSegment
+	| AudioSegment
+	| SamplingFrequencySegment
+	| ChannelsSegment
+	| BitDepthSegment;
+
+export type OnTrackEntrySegment = (trackEntry: TrackEntrySegment) => void;
+
+const parseSegment = async ({
+	segmentId,
+	iterator,
+	length,
+	parserContext,
+}: {
+	segmentId: string;
+	iterator: BufferIterator;
+	length: number;
+	parserContext: ParserContext;
+}): Promise<Promise<MatroskaSegment> | MatroskaSegment> => {
+	if (length === 0) {
+		throw new Error(`Expected length of ${segmentId} to be greater than 0`);
+	}
 
-export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
-	const segmentId = iterator.getMatroskaSegmentId();
 	if (segmentId === '0x') {
 		return {
 			type: 'unknown-segment',
@@ -111,131 +175,210 @@ export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
 		};
 	}
 
-	if (segmentId === '0x18538067') {
-		return parseMainSegment(iterator);
-	}
+	// Log this to debug
+	/*
+	console.log(
+		'segmentId',
+		segmentId,
+		getSegmentName(segmentId),
+		iterator.counter.getOffset(),
+	);
+	*/
 
 	if (segmentId === '0x114d9b74') {
-		return parseSeekHeadSegment(iterator);
+		return parseSeekHeadSegment(iterator, length, parserContext);
+	}
+
+	if (segmentId === '0x53ab') {
+		return parseSeekIdSegment(iterator);
 	}
 
 	if (segmentId === '0x4dbb') {
-		return parseSeekSegment(iterator);
+		return parseSeekSegment(iterator, length, parserContext);
 	}
 
 	if (segmentId === '0x53ac') {
-		return parseSeekPositionSegment(iterator);
+		return parseSeekPositionSegment(iterator, length);
 	}
 
 	if (segmentId === '0xec') {
-		return parseVoidSegment(iterator);
+		return parseVoidSegment(iterator, length);
 	}
 
 	if (segmentId === '0x1549a966') {
-		return parseInfoSegment(iterator);
+		return parseInfoSegment(iterator, length, parserContext);
 	}
 
-	if (segmentId === '0x2ad7b183') {
-		return parseTimestampScaleSegment(iterator);
+	if (segmentId === matroskaElements.TimestampScale) {
+		const timestampScale = parseTimestampScaleSegment(iterator);
+		parserContext.parserState.setTimescale(timestampScale.timestampScale);
+		return timestampScale;
 	}
 
 	if (segmentId === '0x4d80') {
-		return parseMuxingSegment(iterator);
+		return parseMuxingSegment(iterator, length);
 	}
 
 	if (segmentId === '0x5741') {
-		return parseWritingSegment(iterator);
+		return parseWritingSegment(iterator, length);
 	}
 
 	if (segmentId === '0x4489') {
-		return parseDurationSegment(iterator);
+		return parseDurationSegment(iterator, length);
 	}
 
 	if (segmentId === '0x1654ae6b') {
-		return parseTracksSegment(iterator);
+		return parseTracksSegment(iterator, length, parserContext);
 	}
 
-	if (segmentId === '0xae') {
-		return parseTrackEntry(iterator);
+	if (segmentId === matroskaElements.TrackEntry) {
+		const trackEntry = await parseTrackEntry(iterator, length, parserContext);
+
+		parserContext.parserState.onTrackEntrySegment(trackEntry);
+
+		const track = getTrack({
+			track: trackEntry,
+			timescale: parserContext.parserState.getTimescale(),
+		});
+
+		if (track) {
+			await registerTrack({
+				state: parserContext.parserState,
+				options: parserContext,
+				track,
+			});
+		}
+
+		return trackEntry;
 	}
 
 	if (segmentId === '0xd7') {
-		return parseTrackNumber(iterator);
+		return parseTrackNumber(iterator, length);
 	}
 
 	if (segmentId === '0x73c5') {
-		return parseTrackUID(iterator);
+		return parseTrackUID(iterator, length);
 	}
 
 	if (segmentId === '0x9c') {
-		return parseFlagLacing(iterator);
+		return parseFlagLacing(iterator, length);
 	}
 
 	if (segmentId === '0x22b59c') {
-		return parseLanguageSegment(iterator);
+		return parseLanguageSegment(iterator, length);
 	}
 
 	if (segmentId === '0x86') {
-		return parseCodecSegment(iterator);
+		return parseCodecSegment(iterator, length);
 	}
 
 	if (segmentId === '0x83') {
-		return parseTrackTypeSegment(iterator);
+		return parseTrackTypeSegment(iterator, length);
 	}
 
 	if (segmentId === '0x55ee') {
-		return parseMaxBlockAdditionId(iterator);
+		return parseMaxBlockAdditionId(iterator, length);
 	}
 
 	if (segmentId === '0x55b0') {
-		return parseColorSegment(iterator);
+		return parseColorSegment(iterator, length);
 	}
 
 	if (segmentId === '0x23e383') {
-		return parseDefaultDurationSegment(iterator);
+		return parseDefaultDurationSegment(iterator, length);
 	}
 
 	if (segmentId === '0xe0') {
-		return parseVideoSegment(iterator);
+		return parseVideoSegment(iterator, length, parserContext);
+	}
+
+	if (segmentId === '0xe1') {
+		return parseAudioSegment(iterator, length, parserContext);
 	}
 
 	if (segmentId === '0xb0') {
-		return parseWidthSegment(iterator);
+		return parseWidthSegment(iterator, length);
 	}
 
 	if (segmentId === '0xba') {
-		return parseHeightSegment(iterator);
+		return parseHeightSegment(iterator, length);
+	}
+
+	if (segmentId === matroskaElements.DisplayWidth) {
+		return parseDisplayWidthSegment(iterator, length);
+	}
+
+	if (segmentId === matroskaElements.DisplayHeight) {
+		return parseDisplayHeightSegment(iterator, length);
 	}
 
 	if (segmentId === '0x9a') {
-		return parseInterlacedSegment(iterator);
+		return parseInterlacedSegment(iterator, length);
 	}
 
 	if (segmentId === '0x53c0') {
-		return parseAlphaModeSegment(iterator);
+		return parseAlphaModeSegment(iterator, length);
 	}
 
 	if (segmentId === '0x63a2') {
-		return parseCodecPrivateSegment(iterator);
+		return parseCodecPrivateSegment(iterator, length);
 	}
 
 	if (segmentId === '0x7ba9') {
-		return parseTitleSegment(iterator);
+		return parseTitleSegment(iterator, length);
 	}
 
 	if (segmentId === '0xbf') {
-		return parseCrc32Segment(iterator);
+		return parseCrc32Segment(iterator, length);
 	}
 
 	if (segmentId === '0x73a4') {
-		return parseSegmentUUIDSegment(iterator);
+		return parseSegmentUUIDSegment(iterator, length);
 	}
 
 	if (segmentId === '0x88') {
-		return parseDefaultFlagSegment(iterator);
+		return parseDefaultFlagSegment(iterator, length);
 	}
 
-	const length = iterator.getVint();
+	if (segmentId === '0x1254c367') {
+		return parseTagsSegment(iterator, length, parserContext);
+	}
+
+	if (segmentId === '0x7373') {
+		return parseTagSegment(iterator, length);
+	}
+
+	if (segmentId === matroskaElements.SamplingFrequency) {
+		return parseSamplingFrequencySegment(iterator, length);
+	}
+
+	if (segmentId === matroskaElements.Channels) {
+		return parseChannelsSegment(iterator, length);
+	}
+
+	if (segmentId === matroskaElements.BitDepth) {
+		return parseBitDepthSegment(iterator, length);
+	}
+
+	if (segmentId === '0xe7') {
+		return parseTimestampSegment(iterator, length);
+	}
+
+	if (segmentId === '0xa3') {
+		return parseSimpleBlockSegment({
+			iterator,
+			length,
+			parserContext,
+		});
+	}
+
+	if (segmentId === '0xa0') {
+		return parseBlockGroupSegment(iterator, length, parserContext);
+	}
+
+	if (segmentId === '0xa1') {
+		return parseBlockElementSegment(iterator, length);
+	}
 
 	const bytesRemaining = iterator.byteLength() - iterator.counter.getOffset();
 	const toDiscard = Math.min(
@@ -246,3 +389,84 @@ export const expectSegment = (iterator: BufferIterator): MatroskaSegment => {
 	const child = parseUnknownSegment(iterator, segmentId, toDiscard);
 	return child;
 };
+
+export const expectSegment = async (
+	iterator: BufferIterator,
+	parserContext: ParserContext,
+): Promise<ParseResult> => {
+	const bytesRemaining_ = iterator.bytesRemaining();
+	if (bytesRemaining_ === 0) {
+		return {
+			status: 'incomplete',
+			segments: [],
+			continueParsing: () => {
+				return Promise.resolve(expectSegment(iterator, parserContext));
+			},
+			skipTo: null,
+		};
+	}
+
+	const offset = iterator.counter.getOffset();
+	const segmentId = iterator.getMatroskaSegmentId();
+	const length = iterator.getVint();
+	const bytesRemainingNow =
+		iterator.byteLength() - iterator.counter.getOffset();
+
+	if (segmentId === '0x18538067' || segmentId === '0x1f43b675') {
+		const main = await expectChildren({
+			iterator,
+			length,
+			initialChildren: [],
+			wrap:
+				segmentId === '0x18538067'
+					? (s) => ({
+							type: 'main-segment',
+							children: s,
+						})
+					: (s) => ({
+							type: 'cluster-segment',
+							children: s,
+						}),
+			parserContext,
+		});
+
+		if (main.status === 'incomplete') {
+			return {
+				status: 'incomplete',
+				segments: main.segments,
+				skipTo: null,
+				continueParsing: main.continueParsing,
+			};
+		}
+
+		return {
+			status: 'done',
+			segments: main.segments,
+		};
+	}
+
+	if (bytesRemainingNow < length) {
+		const bytesRead = iterator.counter.getOffset() - offset;
+		iterator.counter.decrement(bytesRead);
+		return {
+			status: 'incomplete',
+			segments: [],
+			continueParsing: () => {
+				return Promise.resolve(expectSegment(iterator, parserContext));
+			},
+			skipTo: null,
+		};
+	}
+
+	const segment = await parseSegment({
+		segmentId,
+		iterator,
+		length,
+		parserContext,
+	});
+
+	return {
+		status: 'done',
+		segments: [segment],
+	};
+};

package/src/boxes/webm/traversal.ts

@@ -0,0 +1,32 @@
+import type {AnySegment} from '../../parse-result';
+import type {MainSegment} from './segments/main';
+import type {
+	CodecSegment,
+	TrackEntrySegment,
+	TrackNumberSegment,
+} from './segments/track-entry';
+
+export const getMainSegment = (segments: AnySegment[]): MainSegment | null => {
+	return segments.find((s) => s.type === 'main-segment') as MainSegment | null;
+};
+
+export const getTrackNumber = (track: TrackEntrySegment) => {
+	const child = track.children.find(
+		(b) => b.type === 'track-number-segment',
+	) as TrackNumberSegment | null;
+	return child?.trackNumber ?? null;
+};
+
+export const getTrackCodec = (track: TrackEntrySegment) => {
+	const child = track.children.find(
+		(b) => b.type === 'codec-segment',
+	) as CodecSegment | null;
+	return child ?? null;
+};
+
+export const getTrackByNumber = (tracks: TrackEntrySegment[], id: number) => {
+	return tracks.find((track) => {
+		const trackNumber = getTrackNumber(track);
+		return trackNumber === id;
+	});
+};