@remotion/media-parser 4.0.206 → 4.0.207

package/src/create/cluster-segment.ts

@@ -0,0 +1,62 @@
+import {getVariableInt} from '../boxes/webm/ebml';
+import {
+	combineUint8Arrays,
+	makeMatroskaBytes,
+	matroskaToHex,
+	serializeUint16,
+} from '../boxes/webm/make-header';
+
+export const CLUSTER_MIN_VINT_WIDTH = 8;
+
+export const createClusterSegment = () => {
+	return makeMatroskaBytes({
+		type: 'Cluster',
+		value: [
+			{
+				type: 'Timestamp',
+				minVintWidth: 4,
+				value: {
+					value: 0,
+					byteLength: null,
+				},
+			},
+		],
+		minVintWidth: CLUSTER_MIN_VINT_WIDTH,
+	});
+};
+
+export const makeSimpleBlock = ({
+	bytes,
+	trackNumber,
+	timecodeRelativeToCluster,
+	keyframe,
+	invisible,
+	lacing,
+}: {
+	bytes: Uint8Array;
+	trackNumber: number;
+	timecodeRelativeToCluster: number;
+	keyframe: boolean;
+	invisible: boolean;
+	lacing: number;
+}) => {
+	const simpleBlockHeader = matroskaToHex('0xa3');
+
+	const headerByte =
+		(Number(keyframe) << 7) | (Number(invisible) << 3) | (lacing << 1);
+
+	const body = combineUint8Arrays([
+		getVariableInt(trackNumber, null),
+		// TODO: Cannot encode long videos because of uint16 overflow
+		// need to make new cluster
+		serializeUint16(timecodeRelativeToCluster),
+		new Uint8Array([headerByte]),
+		bytes,
+	]);
+
+	return combineUint8Arrays([
+		simpleBlockHeader,
+		getVariableInt(body.length, null),
+		body,
+	]);
+};

package/src/create/create-media.ts

@@ -0,0 +1,172 @@
+import {getVariableInt} from '../boxes/webm/ebml';
+import {
+	combineUint8Arrays,
+	matroskaToHex,
+	padMatroskaBytes,
+} from '../boxes/webm/make-header';
+import type {BytesAndOffset} from '../boxes/webm/segments/all-segments';
+import {matroskaElements} from '../boxes/webm/segments/all-segments';
+import type {WriterInterface} from '../writers/writer';
+import {
+	CLUSTER_MIN_VINT_WIDTH,
+	createClusterSegment,
+	makeSimpleBlock,
+} from './cluster-segment';
+import {makeMatroskaHeader} from './matroska-header';
+import {makeMatroskaInfo} from './matroska-info';
+import {createMatroskaSegment} from './matroska-segment';
+import type {MakeTrackAudio, MakeTrackVideo} from './matroska-trackentry';
+import {
+	makeMatroskaAudioTrackEntryBytes,
+	makeMatroskaTracks,
+	makeMatroskaVideoTrackEntryBytes,
+} from './matroska-trackentry';
+
+export type MediaFn = {
+	save: () => Promise<void>;
+	addSample: (chunk: EncodedVideoChunk, trackNumber: number) => Promise<void>;
+	updateDuration: (duration: number) => Promise<void>;
+	addTrack: (
+		track:
+			| Omit<MakeTrackAudio, 'trackNumber'>
+			| Omit<MakeTrackVideo, 'trackNumber'>,
+	) => Promise<{trackNumber: number}>;
+	addWaitForFinishPromise: (promise: () => Promise<void>) => void;
+	waitForFinish: () => Promise<void>;
+};
+
+export const createMedia = async (
+	writer: WriterInterface,
+): Promise<MediaFn> => {
+	const header = makeMatroskaHeader();
+
+	const w = await writer.createContent();
+	await w.write(header.bytes);
+	const matroskaInfo = makeMatroskaInfo({
+		timescale: 1_000_000,
+		// TODO: Hardcoded
+		duration: 2658,
+	});
+
+	const currentTracks: BytesAndOffset[] = [];
+
+	const matroskaTracks = makeMatroskaTracks(currentTracks);
+	const matroskaSegment = createMatroskaSegment([
+		matroskaInfo,
+		...matroskaTracks,
+	]);
+
+	const durationOffset =
+		(matroskaSegment.offsets.children[0].children.find(
+			(c) => c.field === 'Duration',
+		)?.offset ?? 0) + w.getWrittenByteCount();
+	const tracksOffset =
+		(matroskaSegment.offsets.children.find((o) => o.field === 'Tracks')
+			?.offset ?? 0) + w.getWrittenByteCount();
+
+	if (!durationOffset) {
+		throw new Error('could not get duration offset');
+	}
+
+	if (!tracksOffset) {
+		throw new Error('could not get tracks offset');
+	}
+
+	await w.write(matroskaSegment.bytes);
+
+	const cluster = createClusterSegment();
+	const clusterVIntPosition =
+		w.getWrittenByteCount() +
+		cluster.offsets.offset +
+		matroskaToHex(matroskaElements.Cluster).byteLength;
+
+	let clusterSize = cluster.bytes.byteLength;
+	await w.write(cluster.bytes);
+
+	const addSample = async (chunk: EncodedVideoChunk, trackNumber: number) => {
+		const arr = new Uint8Array(chunk.byteLength);
+		chunk.copyTo(arr);
+		const simpleBlock = makeSimpleBlock({
+			bytes: arr,
+			invisible: false,
+			keyframe: chunk.type === 'key',
+			lacing: 0,
+			trackNumber,
+			// TODO: Maybe this is bad, because it's in microseconds, but should be in timescale
+			// Maybe it only works by coincidence
+			timecodeRelativeToCluster: Math.round(chunk.timestamp / 1000),
+		});
+
+		clusterSize += simpleBlock.byteLength;
+		await w.updateDataAt(
+			clusterVIntPosition,
+			getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH),
+		);
+		await w.write(simpleBlock);
+	};
+
+	const updateDuration = async (newDuration: number) => {
+		const blocks = padMatroskaBytes(
+			{
+				type: 'Duration',
+				value: {
+					value: newDuration,
+					size: '64',
+				},
+				minVintWidth: null,
+			},
+			// TODO: That's too much padding
+			1000,
+		);
+		await w.updateDataAt(
+			durationOffset,
+			combineUint8Arrays(blocks.map((b) => b.bytes)),
+		);
+	};
+
+	const addTrack = async (track: BytesAndOffset) => {
+		currentTracks.push(track);
+		const newTracks = makeMatroskaTracks(currentTracks);
+
+		await w.updateDataAt(
+			tracksOffset,
+			combineUint8Arrays(newTracks.map((b) => b.bytes)),
+		);
+	};
+
+	let operationProm = Promise.resolve();
+
+	const waitForFinishPromises: (() => Promise<void>)[] = [];
+
+	return {
+		save: async () => {
+			await w.save();
+		},
+		addSample: (chunk, trackNumber) => {
+			operationProm = operationProm.then(() => addSample(chunk, trackNumber));
+			return operationProm;
+		},
+		updateDuration: (duration) => {
+			operationProm = operationProm.then(() => updateDuration(duration));
+			return operationProm;
+		},
+		addTrack: (track) => {
+			const trackNumber = currentTracks.length + 1;
+
+			const bytes =
+				track.type === 'video'
+					? makeMatroskaVideoTrackEntryBytes({...track, trackNumber})
+					: makeMatroskaAudioTrackEntryBytes({...track, trackNumber});
+
+			operationProm = operationProm.then(() => addTrack(bytes));
+
+			return operationProm.then(() => ({trackNumber}));
+		},
+		addWaitForFinishPromise: (promise) => {
+			waitForFinishPromises.push(promise);
+		},
+		async waitForFinish() {
+			await Promise.all(waitForFinishPromises.map((p) => p()));
+		},
+	};
+};

package/src/create/matroska-header.ts

@@ -0,0 +1,63 @@
+import {makeMatroskaBytes} from '../boxes/webm/make-header';
+
+export const makeMatroskaHeader = () => {
+	return makeMatroskaBytes({
+		type: 'Header',
+		value: [
+			{
+				minVintWidth: null,
+				type: 'EBMLVersion',
+				value: {
+					value: 1,
+					byteLength: null,
+				},
+			},
+			{
+				minVintWidth: null,
+				type: 'EBMLReadVersion',
+				value: {
+					value: 1,
+					byteLength: null,
+				},
+			},
+			{
+				type: 'EBMLMaxIDLength',
+				value: {
+					byteLength: null,
+					value: 4,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'EBMLMaxSizeLength',
+				value: {
+					byteLength: null,
+					value: 8,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'DocType',
+				value: 'webm',
+				minVintWidth: null,
+			},
+			{
+				type: 'DocTypeVersion',
+				value: {
+					byteLength: null,
+					value: 4,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'DocTypeReadVersion',
+				value: {
+					byteLength: null,
+					value: 2,
+				},
+				minVintWidth: null,
+			},
+		],
+		minVintWidth: null,
+	});
+};

package/src/create/matroska-info.ts

@@ -0,0 +1,46 @@
+import {makeMatroskaBytes, padMatroskaBytes} from '../boxes/webm/make-header';
+
+export const makeMatroskaInfo = ({
+	timescale,
+	duration,
+}: {
+	timescale: number;
+	duration: number;
+}) => {
+	return makeMatroskaBytes({
+		type: 'Info',
+		value: [
+			{
+				type: 'TimestampScale',
+				value: {
+					value: timescale,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'MuxingApp',
+				value: '@remotion/media-parser',
+				minVintWidth: null,
+			},
+			{
+				type: 'WritingApp',
+				value: '@remotion/media-parser',
+				minVintWidth: null,
+			},
+			...padMatroskaBytes(
+				{
+					type: 'Duration',
+					value: {
+						value: duration,
+						size: '64',
+					},
+					minVintWidth: null,
+				},
+				// TODO: That's too much padding
+				1000,
+			),
+		],
+		minVintWidth: null,
+	});
+};

package/src/create/matroska-segment.ts

@@ -0,0 +1,10 @@
+import {makeMatroskaBytes} from '../boxes/webm/make-header';
+import type {BytesAndOffset} from '../boxes/webm/segments/all-segments';
+
+export const createMatroskaSegment = (children: BytesAndOffset[]) => {
+	return makeMatroskaBytes({
+		type: 'Segment',
+		value: children,
+		minVintWidth: 8,
+	});
+};

package/src/create/matroska-trackentry.ts

@@ -0,0 +1,325 @@
+import {makeMatroskaBytes, padMatroskaBytes} from '../boxes/webm/make-header';
+import type {BytesAndOffset} from '../boxes/webm/segments/all-segments';
+
+export type MatroskaColorParams = {
+	transferChracteristics: 'bt709' | 'smpte170m' | 'iec61966-2-1' | null;
+	matrixCoefficients: 'bt709' | 'bt470bg' | 'rgb' | 'smpte170m' | null;
+	primaries: 'bt709' | 'smpte170m' | 'bt470bg' | null;
+	fullRange: boolean | null;
+};
+
+export const makeMatroskaColorBytes = ({
+	transferChracteristics,
+	matrixCoefficients,
+	primaries,
+	fullRange,
+}: MatroskaColorParams) => {
+	const rangeValue =
+		transferChracteristics && matrixCoefficients
+			? 3
+			: fullRange === true
+				? 2
+				: fullRange === false
+					? 1
+					: 0;
+
+	// https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
+	// 5.1.4.1.28.27
+	const primariesValue =
+		primaries === 'bt709'
+			? 1
+			: primaries === 'smpte170m'
+				? 6
+				: primaries === 'bt470bg'
+					? 5
+					: 2;
+
+	const transferChracteristicsValue =
+		transferChracteristics === 'bt709'
+			? 1
+			: transferChracteristics === 'smpte170m'
+				? 6
+				: transferChracteristics === 'iec61966-2-1'
+					? 13
+					: 2;
+
+	if (matrixCoefficients === 'rgb') {
+		throw new Error('Cannot encode Matroska in RGB');
+	}
+
+	const matrixCoefficientsValue =
+		matrixCoefficients === 'bt709'
+			? 1
+			: matrixCoefficients === 'bt470bg'
+				? 5
+				: matrixCoefficients === 'smpte170m'
+					? 6
+					: 2;
+
+	return makeMatroskaBytes({
+		type: 'Colour',
+		minVintWidth: null,
+		value: [
+			{
+				type: 'TransferCharacteristics',
+				value: {
+					value: transferChracteristicsValue,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'MatrixCoefficients',
+				value: {
+					value: matrixCoefficientsValue,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'Primaries',
+				value: {
+					value: primariesValue,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'Range',
+				value: {
+					value: rangeValue,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+		],
+	});
+};
+
+export const makeMatroskaVideoBytes = ({
+	color,
+	width,
+	height,
+}: {
+	color: MatroskaColorParams;
+	width: number;
+	height: number;
+}) => {
+	return makeMatroskaBytes({
+		type: 'Video',
+		value: [
+			{
+				type: 'PixelWidth',
+				value: {
+					value: width,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'PixelHeight',
+				value: {
+					value: height,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'FlagInterlaced',
+				value: {
+					// https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
+					// 5.1.4.1.28.1.
+					value: 2, // 2 - progressive, no interlaced
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			makeMatroskaColorBytes(color),
+		],
+		minVintWidth: null,
+	});
+};
+
+export type MakeTrackAudio = {
+	trackNumber: number;
+	codecId: string;
+	numberOfChannels: number;
+	sampleRate: number;
+	type: 'audio';
+};
+
+export type MakeTrackVideo = {
+	color: MatroskaColorParams;
+	width: number;
+	height: number;
+	defaultDuration: number;
+	trackNumber: number;
+	codecId: string;
+	type: 'video';
+};
+
+export const makeMatroskaAudioTrackEntryBytes = ({
+	trackNumber,
+	codecId,
+	numberOfChannels: audioChannels,
+	sampleRate,
+}: MakeTrackAudio) => {
+	return makeMatroskaBytes({
+		type: 'TrackEntry',
+		minVintWidth: null,
+		value: [
+			{
+				type: 'TrackNumber',
+				value: {
+					value: trackNumber,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'TrackUID',
+				value: '0x188FEB95C8EFABA',
+				minVintWidth: null,
+			},
+			{
+				type: 'TrackType',
+				value: {
+					value: 2,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'TrackTimestampScale',
+				value: {
+					value: 1,
+					size: '64',
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'CodecID',
+				value: codecId,
+				minVintWidth: null,
+			},
+			{
+				type: 'Audio',
+				value: [
+					{
+						type: 'Channels',
+						minVintWidth: null,
+						value: {
+							value: audioChannels,
+							byteLength: null,
+						},
+					},
+					{
+						type: 'SamplingFrequency',
+						minVintWidth: null,
+						value: {
+							value: sampleRate,
+							size: '64',
+						},
+					},
+					{
+						type: 'BitDepth',
+						minVintWidth: null,
+						value: {
+							value: 32,
+							byteLength: null,
+						},
+					},
+				],
+				minVintWidth: null,
+			},
+		],
+	});
+};
+
+export const makeMatroskaVideoTrackEntryBytes = ({
+	color,
+	width,
+	height,
+	defaultDuration,
+	trackNumber,
+	codecId,
+}: MakeTrackVideo) => {
+	return makeMatroskaBytes({
+		type: 'TrackEntry',
+		minVintWidth: null,
+		value: [
+			{
+				type: 'TrackNumber',
+				value: {
+					value: trackNumber,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'TrackUID',
+				value: '0xab2171012bb9020a',
+				minVintWidth: null,
+			},
+			{
+				type: 'FlagLacing',
+				value: {
+					value: 0,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'Language',
+				value: 'und',
+				minVintWidth: null,
+			},
+			{
+				type: 'FlagDefault',
+				value: {
+					value: 0,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'CodecID',
+				value: codecId,
+				minVintWidth: null,
+			},
+			{
+				type: 'TrackType',
+				value: {
+					value: 1, // 'video'
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			{
+				type: 'DefaultDuration',
+				value: {
+					value: defaultDuration,
+					byteLength: null,
+				},
+				minVintWidth: null,
+			},
+			makeMatroskaVideoBytes({
+				color,
+				width,
+				height,
+			}),
+		],
+	});
+};
+
+export const makeMatroskaTracks = (tracks: BytesAndOffset[]) => {
+	return padMatroskaBytes(
+		makeMatroskaBytes({
+			type: 'Tracks',
+			value: tracks,
+			minVintWidth: null,
+		}),
+		// TODO: That's too much padding
+		1000,
+	);
+};

package/src/index.ts

@@ -1,3 +1,6 @@
+import {createMedia} from './create/create-media';
+
+export {AudioTrack, OtherTrack, Track, VideoTrack} from './get-tracks';
 export {parseMedia} from './parse-media';
 export {
 	AudioSample,
@@ -7,3 +10,9 @@ export {
 	OnVideoTrack,
 	VideoSample,
 } from './webcodec-sample-types';
+
+export type {MediaFn} from './create/create-media';
+
+export const MediaParserInternals = {
+	createMedia,
+};

package/src/options.ts

@@ -3,7 +3,7 @@ import type {Dimensions} from './get-dimensions';
 import type {AudioTrack, VideoTrack} from './get-tracks';
 import type {AnySegment} from './parse-result';
 import type {InternalStats} from './parser-state';
-import type {ReaderInterface} from './reader';
+import type {ReaderInterface} from './readers/reader';
 import type {OnAudioTrack, OnVideoTrack} from './webcodec-sample-types';
 
 export type KnownVideoCodecs =

package/src/parse-media.ts

@@ -1,7 +1,6 @@
 /* eslint-disable max-depth */
 import type {BufferIterator} from './buffer-iterator';
 import {getArrayBufferIterator} from './buffer-iterator';
-import {fetchReader} from './from-fetch';
 import {getAudioCodec} from './get-audio-codec';
 import {getDimensions} from './get-dimensions';
 import {getDuration} from './get-duration';
@@ -14,6 +13,7 @@ import type {ParseResult} from './parse-result';
 import {parseVideo} from './parse-video';
 import type {ParserContext} from './parser-context';
 import {makeParserState} from './parser-state';
+import {fetchReader} from './readers/from-fetch';
 
 export const parseMedia: ParseMedia = async ({
 	src,