@remotion/media-parser 4.0.201 → 4.0.204

package/src/boxes/webm/segments.ts

@@ -1,164 +1,13 @@
-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 type {VideoSample} from '../../webcodec-sample-types';
-import {getTrack} from './get-track';
-import {parseEbml} from './parse-ebml';
-import type {PossibleEbml} from './segments/all-segments';
-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 {parseMuxingSegment, type MuxingAppSegment} from './segments/muxing';
+import {parseEbml, postprocessEbml} from './parse-ebml';
+import type {PossibleEbml, TrackEntry} from './segments/all-segments';
 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 {
-	parseSeekPositionSegment,
-	type SeekPositionSegment,
-} from './segments/seek-position';
-import type {TimestampScaleSegment} from './segments/timestamp-scale';
-import {parseTimestampScaleSegment} from './segments/timestamp-scale';
-import type {
-	AlphaModeSegment,
-	AudioSegment,
-	BitDepthSegment,
-	BlockAdditionsSegment,
-	BlockElement,
-	BlockGroupSegment,
-	ChannelsSegment,
-	ClusterSegment,
-	CodecPrivateSegment,
-	CodecSegment,
-	ColorSegment,
-	Crc32Segment,
-	DefaultDurationSegment,
-	DefaultFlagSegment,
-	DisplayHeightSegment,
-	DisplayWidthSegment,
-	FlagLacingSegment,
-	HeightSegment,
-	InterlacedSegment,
-	LanguageSegment,
-	MaxBlockAdditionId,
-	ReferenceBlockSegment,
-	SamplingFrequencySegment,
-	SegmentUUIDSegment,
-	SimpleBlockOrBlockSegment,
-	TagSegment,
-	TagsSegment,
-	TimestampSegment,
-	TitleSegment,
-	TrackEntrySegment,
-	TrackNumberSegment,
-	TrackTypeSegment,
-	TrackUIDSegment,
-	VideoSegment,
-	WidthSegment,
-} from './segments/track-entry';
-import {
-	parseAlphaModeSegment,
-	parseAudioSegment,
-	parseBitDepthSegment,
-	parseBlockAdditionsSegment,
-	parseBlockElementSegment,
-	parseBlockGroupSegment,
-	parseChannelsSegment,
-	parseCodecPrivateSegment,
-	parseCodecSegment,
-	parseColorSegment,
-	parseCrc32Segment,
-	parseDefaultDurationSegment,
-	parseDefaultFlagSegment,
-	parseDisplayHeightSegment,
-	parseDisplayWidthSegment,
-	parseFlagLacing,
-	parseHeightSegment,
-	parseInterlacedSegment,
-	parseLanguageSegment,
-	parseMaxBlockAdditionId,
-	parseReferenceBlockSegment,
-	parseSamplingFrequencySegment,
-	parseSegmentUUIDSegment,
-	parseSimpleBlockOrBlockSegment,
-	parseTagSegment,
-	parseTagsSegment,
-	parseTimestampSegment,
-	parseTitleSegment,
-	parseTrackEntry,
-	parseTrackNumber,
-	parseTrackTypeSegment,
-	parseTrackUID,
-	parseVideoSegment,
-	parseWidthSegment,
-} from './segments/track-entry';
-import type {TracksSegment} from './segments/tracks';
-import {parseTracksSegment} from './segments/tracks';
-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
-	| SeekHeadSegment
-	| SeekSegment
-	| SeekPositionSegment
-	| VoidSegment
-	| InfoSegment
-	| TimestampScaleSegment
-	| MuxingAppSegment
-	| WritingAppSegment
-	| DurationSegment
-	| TracksSegment
-	| TrackEntrySegment
-	| TrackNumberSegment
-	| TrackUIDSegment
-	| FlagLacingSegment
-	| LanguageSegment
-	| CodecSegment
-	| TrackTypeSegment
-	| DefaultDurationSegment
-	| VideoSegment
-	| WidthSegment
-	| HeightSegment
-	| DisplayWidthSegment
-	| DisplayHeightSegment
-	| AlphaModeSegment
-	| MaxBlockAdditionId
-	| ColorSegment
-	| TitleSegment
-	| InterlacedSegment
-	| CodecPrivateSegment
-	| Crc32Segment
-	| SegmentUUIDSegment
-	| DefaultFlagSegment
-	| TagsSegment
-	| TagSegment
-	| ClusterSegment
-	| TimestampSegment
-	| SimpleBlockOrBlockSegment
-	| BlockGroupSegment
-	| BlockElement
-	| SeekIdSegment
-	| AudioSegment
-	| SamplingFrequencySegment
-	| ChannelsSegment
-	| BitDepthSegment
-	| ReferenceBlockSegment
-	| BlockAdditionsSegment
-	| PossibleEbml;
+export type MatroskaSegment = PossibleEbml;
 
-export type OnTrackEntrySegment = (trackEntry: TrackEntrySegment) => void;
+export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
 
 const parseSegment = async ({
 	segmentId,
@@ -177,259 +26,13 @@ const parseSegment = async ({
 		throw new Error(`Expected length of ${segmentId} to be greater than 0`);
 	}
 
-	if (segmentId === '0x114d9b74') {
-		return parseSeekHeadSegment(iterator, length, parserContext);
-	}
-
-	if (segmentId === '0x53ab') {
-		return parseSeekIdSegment(iterator, length);
-	}
-
-	if (segmentId === '0x4dbb') {
-		return parseSeekSegment(iterator, length, parserContext);
-	}
-
-	if (segmentId === '0x53ac') {
-		return parseSeekPositionSegment(iterator, length);
-	}
-
-	if (segmentId === '0xec') {
-		return parseVoidSegment(iterator, length);
-	}
-
-	if (segmentId === '0x1549a966') {
-		return parseInfoSegment(iterator, length, parserContext);
-	}
-
-	if (segmentId === matroskaElements.TimestampScale) {
-		const timestampScale = parseTimestampScaleSegment(iterator);
-		parserContext.parserState.setTimescale(timestampScale.timestampScale);
-		return timestampScale;
-	}
-
-	if (segmentId === '0x4d80') {
-		return parseMuxingSegment(iterator, length);
-	}
-
-	if (segmentId === '0x5741') {
-		return parseWritingSegment(iterator, length);
-	}
-
-	if (segmentId === '0x4489') {
-		return parseDurationSegment(iterator, length);
-	}
-
-	if (segmentId === '0x1654ae6b') {
-		return parseTracksSegment(iterator, length, parserContext);
-	}
-
-	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, length);
-	}
-
-	if (segmentId === '0x73c5') {
-		return parseTrackUID(iterator, length);
-	}
-
-	if (segmentId === '0x9c') {
-		return parseFlagLacing(iterator, length);
-	}
-
-	if (segmentId === '0x22b59c') {
-		return parseLanguageSegment(iterator, length);
-	}
-
-	if (segmentId === '0x86') {
-		return parseCodecSegment(iterator, length);
-	}
-
-	if (segmentId === '0x83') {
-		return parseTrackTypeSegment(iterator, length);
-	}
-
-	if (segmentId === '0x55ee') {
-		return parseMaxBlockAdditionId(iterator, length);
-	}
-
-	if (segmentId === '0x55b0') {
-		return parseColorSegment(iterator, length);
-	}
-
-	if (segmentId === '0x23e383') {
-		return parseDefaultDurationSegment(iterator, length);
-	}
-
-	if (segmentId === '0xe0') {
-		return parseVideoSegment(iterator, length, parserContext);
-	}
-
-	if (segmentId === '0xe1') {
-		return parseAudioSegment(iterator, length, parserContext);
-	}
-
-	if (segmentId === '0xb0') {
-		return parseWidthSegment(iterator, length);
-	}
-
-	if (segmentId === '0xba') {
-		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, length);
-	}
-
-	if (segmentId === '0x53c0') {
-		return parseAlphaModeSegment(iterator, length);
-	}
-
-	if (segmentId === '0x63a2') {
-		return parseCodecPrivateSegment(iterator, length);
-	}
-
-	if (segmentId === '0x7ba9') {
-		return parseTitleSegment(iterator, length);
-	}
-
-	if (segmentId === '0xbf') {
-		return parseCrc32Segment(iterator, length);
-	}
-
-	if (segmentId === '0x73a4') {
-		return parseSegmentUUIDSegment(iterator, length);
-	}
-
-	if (segmentId === '0x88') {
-		return parseDefaultFlagSegment(iterator, length);
-	}
-
-	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 === matroskaElements.Timestamp) {
-		const offset = iterator.counter.getOffset();
-		const timestampSegment = parseTimestampSegment(iterator, length);
-
-		parserContext.parserState.setTimestampOffset(
-			offset,
-			timestampSegment.timestamp,
-		);
-
-		return timestampSegment;
-	}
-
-	if (
-		segmentId === matroskaElements.SimpleBlock ||
-		segmentId === matroskaElements.Block
-	) {
-		return parseSimpleBlockOrBlockSegment({
-			iterator,
-			length,
-			parserContext,
-			type: segmentId,
-		});
-	}
-
-	if (segmentId === matroskaElements.ReferenceBlock) {
-		return parseReferenceBlockSegment(iterator, length);
-	}
-
-	if (segmentId === matroskaElements.BlockAdditions) {
-		return parseBlockAdditionsSegment(iterator, length);
-	}
-
-	if (segmentId === '0xa0') {
-		const blockGroup = await parseBlockGroupSegment(
-			iterator,
-			length,
-			parserContext,
-		);
-
-		// Blocks don't have information about keyframes.
-		// https://ffmpeg.org/pipermail/ffmpeg-devel/2015-June/173825.html
-		// "For Blocks, keyframes is
-		// inferred by the absence of ReferenceBlock element (as done by matroskadec).""
-
-		const block = blockGroup.children.find(
-			(c) => c.type === 'simple-block-or-block-segment',
-		);
-		if (!block || block.type !== 'simple-block-or-block-segment') {
-			throw new Error('Expected block segment');
-		}
-
-		const hasReferenceBlock = blockGroup.children.find(
-			(c) => c.type === 'reference-block-segment',
-		);
-
-		const partialVideoSample = block.videoSample;
-
-		if (partialVideoSample) {
-			const completeFrame: VideoSample = {
-				...partialVideoSample,
-				type: hasReferenceBlock ? 'delta' : 'key',
-			};
-			await parserContext.parserState.onVideoSample(
-				partialVideoSample.trackId,
-				completeFrame,
-			);
-		}
-
-		return blockGroup;
-	}
-
-	if (segmentId === '0xa1') {
-		return parseBlockElementSegment(iterator, length);
-	}
-
 	iterator.counter.decrement(headerReadSoFar);
 
-	return parseEbml(iterator);
+	const offset = iterator.counter.getOffset();
+	const ebml = await parseEbml(iterator, parserContext);
+	const remapped = await postprocessEbml({offset, ebml, parserContext});
+
+	return remapped;
 };
 
 export const expectSegment = async (
@@ -462,7 +65,10 @@ export const expectSegment = async (
 		};
 	}
 
+	const offsetBeforeVInt = iterator.counter.getOffset();
 	const length = iterator.getVint();
+	const offsetAfterVInt = iterator.counter.getOffset();
+
 	if (length === null) {
 		iterator.counter.decrement(iterator.counter.getOffset() - offset);
 		return {
@@ -486,12 +92,14 @@ export const expectSegment = async (
 			wrap:
 				segmentId === '0x18538067'
 					? (s) => ({
-							type: 'main-segment',
-							children: s,
+							type: 'Segment',
+							value: s,
+							minVintWidth: offsetAfterVInt - offsetBeforeVInt,
 						})
 					: (s) => ({
-							type: 'cluster-segment',
-							children: s,
+							type: 'Cluster',
+							value: s,
+							minVintWidth: offsetAfterVInt - offsetBeforeVInt,
 						}),
 			parserContext,
 		});

package/src/boxes/webm/traversal.ts

@@ -1,31 +1,31 @@
 import type {AnySegment} from '../../parse-result';
-import type {MainSegment} from './segments/main';
 import type {
-	CodecSegment,
-	TrackEntrySegment,
+	CodecIdSegment,
+	MainSegment,
+	TrackEntry,
 	TrackNumberSegment,
-} from './segments/track-entry';
+} from './segments/all-segments';
 
 export const getMainSegment = (segments: AnySegment[]): MainSegment | null => {
-	return segments.find((s) => s.type === 'main-segment') as MainSegment | null;
+	return segments.find((s) => s.type === 'Segment') as MainSegment | null;
 };
 
-export const getTrackNumber = (track: TrackEntrySegment) => {
-	const child = track.children.find(
-		(b) => b.type === 'track-number-segment',
+export const getTrackNumber = (track: TrackEntry) => {
+	const child = track.value.find(
+		(b) => b.type === 'TrackNumber',
 	) as TrackNumberSegment | null;
-	return child?.trackNumber ?? null;
+	return child?.value ?? null;
 };
 
-export const getTrackCodec = (track: TrackEntrySegment) => {
-	const child = track.children.find(
-		(b) => b.type === 'codec-segment',
-	) as CodecSegment | null;
+export const getTrackCodec = (track: TrackEntry) => {
+	const child = track.value.find(
+		(b) => b.type === 'CodecID',
+	) as CodecIdSegment | null;
 	return child ?? null;
 };
 
-export const getTrackTimestampScale = (track: TrackEntrySegment) => {
-	const child = track.children.find((b) => b.type === 'TrackTimestampScale');
+export const getTrackTimestampScale = (track: TrackEntry) => {
+	const child = track.value.find((b) => b.type === 'TrackTimestampScale');
 	if (!child) {
 		return null;
 	}
@@ -37,9 +37,9 @@ export const getTrackTimestampScale = (track: TrackEntrySegment) => {
 	return child.value;
 };
 
-export const getTrackByNumber = (tracks: TrackEntrySegment[], id: number) => {
+export const getTrackByNumber = (tracks: TrackEntry[], id: number) => {
 	return tracks.find((track) => {
 		const trackNumber = getTrackNumber(track);
-		return trackNumber === id;
+		return trackNumber?.value === id;
 	});
 };

package/src/buffer-iterator.ts

@@ -62,12 +62,13 @@ const makeOffsetCounter = (): OffsetCounter => {
 
 export const getArrayBufferIterator = (
 	initialData: Uint8Array,
-	maxBytes?: number,
+	maxBytes: number | null,
 ) => {
 	const buf = new ArrayBuffer(initialData.byteLength, {
-		maxByteLength: maxBytes
-			? Math.min(maxBytes as number, 2 ** 32)
-			: 1_000_000_000,
+		maxByteLength:
+			maxBytes === null
+				? initialData.byteLength
+				: Math.min(maxBytes as number, 2 ** 32),
 	});
 	if (!buf.resize) {
 		throw new Error(
@@ -482,8 +483,8 @@ export const getArrayBufferIterator = (
 		},
 		getUint24: () => {
 			const val1 = view.getUint8(counter.getDiscardedOffset());
-			const val2 = view.getUint8(counter.getDiscardedOffset());
-			const val3 = view.getUint8(counter.getDiscardedOffset());
+			const val2 = view.getUint8(counter.getDiscardedOffset() + 1);
+			const val3 = view.getUint8(counter.getDiscardedOffset() + 2);
 			counter.increment(3);
 			return (val1 << 16) | (val2 << 8) | val3;
 		},
@@ -538,6 +539,7 @@ export const getArrayBufferIterator = (
 		},
 		getUint32Le,
 		getInt32Le,
+		getInt32,
 		destroy,
 		isMp3,
 	};

package/src/get-audio-codec.ts

@@ -3,7 +3,7 @@ import type {EsdsBox} from './boxes/iso-base-media/esds/esds';
 import type {MoovBox} from './boxes/iso-base-media/moov/moov';
 import type {AudioSample} from './boxes/iso-base-media/stsd/samples';
 import type {TrakBox} from './boxes/iso-base-media/trak/trak';
-import type {MainSegment} from './boxes/webm/segments/main';
+import type {MainSegment} from './boxes/webm/segments/all-segments';
 import {trakBoxContainsAudio} from './get-fps';
 import type {KnownAudioCodecs} from './options';
 import type {AnySegment} from './parse-result';
@@ -163,34 +163,32 @@ export const getAudioCodecFromIso = (moov: MoovBox) => {
 };
 
 export const getAudioCodecFromMatroska = (mainSegment: MainSegment) => {
-	const tracksSegment = mainSegment.children.find(
-		(b) => b.type === 'tracks-segment',
-	);
-	if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+	const tracksSegment = mainSegment.value.find((b) => b.type === 'Tracks');
+	if (!tracksSegment || tracksSegment.type !== 'Tracks') {
 		return null;
 	}
 
-	for (const track of tracksSegment.children) {
-		if (track.type === 'track-entry-segment') {
-			const trackType = track.children.find((b) => b.type === 'codec-segment');
-			if (trackType && trackType.type === 'codec-segment') {
-				if (trackType.codec === 'A_OPUS') {
+	for (const track of tracksSegment.value) {
+		if (track.type === 'TrackEntry') {
+			const trackType = track.value.find((b) => b.type === 'CodecID');
+			if (trackType && trackType.type === 'CodecID') {
+				if (trackType.value === 'A_OPUS') {
 					return 'opus';
 				}
 
-				if (trackType.codec === 'A_VORBIS') {
+				if (trackType.value === 'A_VORBIS') {
 					return 'vorbis';
 				}
 
-				if (trackType.codec === 'A_PCM/INT/LIT') {
+				if (trackType.value === 'A_PCM/INT/LIT') {
 					return 'pcm';
 				}
 
-				if (trackType.codec === 'A_AAC') {
+				if (trackType.value === 'A_AAC') {
 					return 'aac';
 				}
 
-				if (trackType.codec === 'A_MPEG/L3') {
+				if (trackType.value === 'A_MPEG/L3') {
 					return 'mp3';
 				}
 			}
@@ -263,8 +261,8 @@ export const getAudioCodec = (boxes: AnySegment[]): KnownAudioCodecs | null => {
 		throw new Error('Unknown audio format: ' + codec.format);
 	}
 
-	const mainSegment = boxes.find((b) => b.type === 'main-segment');
-	if (!mainSegment || mainSegment.type !== 'main-segment') {
+	const mainSegment = boxes.find((b) => b.type === 'Segment');
+	if (!mainSegment || mainSegment.type !== 'Segment') {
 		return null;
 	}