@remotion/media-parser 4.0.201 → 4.0.204

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

@@ -1,12 +1,20 @@
-import type {BufferIterator} from '../../buffer-iterator';
+import {registerTrack} from '../../add-new-matroska-tracks';
+import {type BufferIterator} from '../../buffer-iterator';
+import type {ParserContext} from '../../parser-context';
+import type {VideoSample} from '../../webcodec-sample-types';
+import {getSampleFromBlock} from './get-sample-from-block';
+import {getTrack} from './get-track';
 import type {PossibleEbml} from './segments/all-segments';
-import {ebmlMap, type Ebml, type EbmlParsed} from './segments/all-segments';
+import {ebmlMap} from './segments/all-segments';
 
-type Prettify<T> = {
+export type Prettify<T> = {
 	[K in keyof T]: T[K];
 } & {};
 
-export const parseEbml = (iterator: BufferIterator): Prettify<PossibleEbml> => {
+export const parseEbml = async (
+	iterator: BufferIterator,
+	parserContext: ParserContext,
+): Promise<Prettify<PossibleEbml>> => {
 	const hex = iterator.getMatroskaSegmentId();
 	if (hex === null) {
 		throw new Error(
@@ -21,7 +29,10 @@ export const parseEbml = (iterator: BufferIterator): Prettify<PossibleEbml> => {
 		);
 	}
 
+	const off = iterator.counter.getOffset();
 	const size = iterator.getVint();
+	const minVintWidth = iterator.counter.getOffset() - off;
+
 	if (size === null) {
 		throw new Error(
 			'Not enough bytes left to parse EBML - this should not happen',
@@ -29,9 +40,17 @@ export const parseEbml = (iterator: BufferIterator): Prettify<PossibleEbml> => {
 	}
 
 	if (hasInMap.type === 'uint') {
+		const beforeUintOffset = iterator.counter.getOffset();
 		const value = iterator.getUint(size);
 
-		return {type: hasInMap.name, value, hex};
+		return {
+			type: hasInMap.name,
+			value: {
+				value,
+				byteLength: iterator.counter.getOffset() - beforeUintOffset,
+			},
+			minVintWidth,
+		};
 	}
 
 	if (hasInMap.type === 'string') {
@@ -40,7 +59,7 @@ export const parseEbml = (iterator: BufferIterator): Prettify<PossibleEbml> => {
 		return {
 			type: hasInMap.name,
 			value,
-			hex,
+			minVintWidth,
 		};
 	}
 
@@ -49,29 +68,49 @@ export const parseEbml = (iterator: BufferIterator): Prettify<PossibleEbml> => {
 
 		return {
 			type: hasInMap.name,
-			value,
-			hex,
+			value: {
+				value,
+				size: size === 4 ? '32' : '64',
+			},
+			minVintWidth,
 		};
 	}
 
-	if (hasInMap.type === 'void') {
-		iterator.discard(size);
+	if (hasInMap.type === 'hex-string') {
+		return {
+			type: hasInMap.name,
+			value:
+				'0x' +
+				[...iterator.getSlice(size)]
+					.map((b) => b.toString(16).padStart(2, '0'))
+					.join(''),
+			minVintWidth,
+		};
+	}
 
+	if (hasInMap.type === 'uint8array') {
 		return {
 			type: hasInMap.name,
-			value: undefined,
-			hex,
+			value: iterator.getSlice(size),
+			minVintWidth,
 		};
 	}
 
 	if (hasInMap.type === 'children') {
-		const children: EbmlParsed<Ebml>[] = [];
+		const children: PossibleEbml[] = [];
 		const startOffset = iterator.counter.getOffset();
 
 		// eslint-disable-next-line no-constant-condition
 		while (true) {
-			const value = parseEbml(iterator);
-			children.push(value);
+			const offset = iterator.counter.getOffset();
+			const value = await parseEbml(iterator, parserContext);
+			const remapped = await postprocessEbml({
+				offset,
+				ebml: value,
+				parserContext,
+			});
+			children.push(remapped);
+
 			const offsetNow = iterator.counter.getOffset();
 
 			if (offsetNow - startOffset > size) {
@@ -85,9 +124,124 @@ export const parseEbml = (iterator: BufferIterator): Prettify<PossibleEbml> => {
 			}
 		}
 
-		return {type: hasInMap.name, value: children as EbmlParsed<Ebml>[], hex};
+		return {type: hasInMap.name, value: children, minVintWidth};
 	}
 
 	// @ts-expect-error
 	throw new Error(`Unknown segment type ${hasInMap.type}`);
 };
+
+export const postprocessEbml = async ({
+	offset,
+	ebml,
+	parserContext,
+}: {
+	offset: number;
+	ebml: Prettify<PossibleEbml>;
+	parserContext: ParserContext;
+}): Promise<Prettify<PossibleEbml>> => {
+	if (ebml.type === 'TimestampScale') {
+		parserContext.parserState.setTimescale(ebml.value.value);
+	}
+
+	if (ebml.type === 'TrackEntry') {
+		parserContext.parserState.onTrackEntrySegment(ebml);
+
+		const track = getTrack({
+			track: ebml,
+			timescale: parserContext.parserState.getTimescale(),
+		});
+
+		if (track) {
+			await registerTrack({
+				state: parserContext.parserState,
+				options: parserContext,
+				track,
+			});
+		}
+	}
+
+	if (ebml.type === 'Timestamp') {
+		parserContext.parserState.setTimestampOffset(offset, ebml.value.value);
+	}
+
+	if (ebml.type === 'Block' || ebml.type === 'SimpleBlock') {
+		const sample = getSampleFromBlock(ebml, parserContext, offset);
+
+		if (sample.type === 'video-sample' && parserContext.nullifySamples) {
+			await parserContext.parserState.onVideoSample(
+				sample.videoSample.trackId,
+				sample.videoSample,
+			);
+			return {
+				type: 'Block',
+				value: new Uint8Array([]),
+				minVintWidth: ebml.minVintWidth,
+			};
+		}
+
+		if (sample.type === 'audio-sample' && parserContext.nullifySamples) {
+			await parserContext.parserState.onAudioSample(
+				sample.audioSample.trackId,
+				sample.audioSample,
+			);
+			return {
+				type: 'Block',
+				value: new Uint8Array([]),
+				minVintWidth: ebml.minVintWidth,
+			};
+		}
+
+		if (sample.type === 'no-sample' && parserContext.nullifySamples) {
+			return {
+				type: 'Block',
+				value: new Uint8Array([]),
+				minVintWidth: ebml.minVintWidth,
+			};
+		}
+	}
+
+	if (ebml.type === 'BlockGroup') {
+		// 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 = ebml.value.find(
+			(c) => c.type === 'SimpleBlock' || c.type === 'Block',
+		);
+		if (!block || (block.type !== 'SimpleBlock' && block.type !== 'Block')) {
+			throw new Error('Expected block segment');
+		}
+
+		const hasReferenceBlock = ebml.value.find(
+			(c) => c.type === 'ReferenceBlock',
+		);
+
+		const sample =
+			block.value.length === 0
+				? null
+				: getSampleFromBlock(block, parserContext, offset);
+
+		if (sample && sample.type === 'partial-video-sample') {
+			const completeFrame: VideoSample = {
+				...sample.partialVideoSample,
+				type: hasReferenceBlock ? 'delta' : 'key',
+			};
+			await parserContext.parserState.onVideoSample(
+				sample.partialVideoSample.trackId,
+				completeFrame,
+			);
+		}
+
+		if (parserContext.nullifySamples) {
+			return {
+				type: 'BlockGroup',
+				value: [],
+				minVintWidth: ebml.minVintWidth,
+			};
+		}
+	}
+
+	return ebml;
+};