@remotion/media-parser 4.0.206 → 4.0.208

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,

package/src/test/av1.test.ts

@@ -1,9 +1,9 @@
 import {RenderInternals} from '@remotion/renderer';
 import {expect, test} from 'bun:test';
-import {nodeReader} from '../from-node';
 import {trakBoxContainsVideo} from '../get-fps';
 import {getAv1CBox} from '../get-sample-aspect-ratio';
 import {parseMedia} from '../parse-media';
+import {nodeReader} from '../readers/from-node';
 import {getMoovBox, getTraks} from '../traversal';
 
 test('AV1 in MP4', async () => {

package/src/test/create-matroska.test.ts

@@ -9,11 +9,11 @@ import type {
 	TrackEntry,
 } from '../boxes/webm/segments/all-segments';
 import {getArrayBufferIterator} from '../buffer-iterator';
-import {nodeReader} from '../from-node';
 import {parseMedia} from '../parse-media';
 import type {AnySegment} from '../parse-result';
 import type {ParserContext} from '../parser-context';
 import {makeParserState} from '../parser-state';
+import {nodeReader} from '../readers/from-node';
 
 const state = makeParserState({
 	hasAudioCallbacks: false,
@@ -72,7 +72,10 @@ test('Should make Matroska header that is same as input', async () => {
 		],
 	});
 
-	const iterator = getArrayBufferIterator(headerOutput, headerOutput.length);
+	const iterator = getArrayBufferIterator(
+		headerOutput.bytes,
+		headerOutput.bytes.length,
+	);
 	const parsed = await parseEbml(iterator, options);
 
 	expect(parsed).toEqual({
@@ -128,7 +131,7 @@ test('Should be able to create SeekIdBox', async () => {
 		value: '0x1549a966',
 		minVintWidth: 1,
 	});
-	expect(custom).toEqual(file);
+	expect(custom.bytes).toEqual(file);
 });
 
 test('Should be able to create Seek', async () => {
@@ -154,7 +157,7 @@ test('Should be able to create Seek', async () => {
 	});
 
 	const custom = makeMatroskaBytes(parsed);
-	expect(custom).toEqual(file);
+	expect(custom.bytes).toEqual(file);
 });
 
 test('Should parse seekHead', async () => {
@@ -186,7 +189,29 @@ test('Should parse seekHead', async () => {
 		],
 		minVintWidth: 1,
 	});
-	expect(custom).toEqual(file);
+	expect(custom.offsets).toEqual({
+		offset: 0,
+		children: [
+			{
+				offset: 5,
+				children: [
+					{
+						offset: 8,
+						children: [],
+						field: 'SeekID',
+					},
+					{
+						offset: 15,
+						children: [],
+						field: 'SeekPosition',
+					},
+				],
+				field: 'Seek',
+			},
+		],
+		field: 'SeekHead',
+	});
+	expect(custom.bytes).toEqual(file);
 
 	const iterator = getArrayBufferIterator(file, file.length);
 	const parsed = await parseEbml(iterator, options);
@@ -225,7 +250,7 @@ const parseWebm = async (str: string) => {
 const stringifyWebm = (boxes: AnySegment[]) => {
 	const buffers: Uint8Array[] = [];
 	for (const box of boxes) {
-		const bytes = makeMatroskaBytes(box as MatroskaSegment);
+		const {bytes} = makeMatroskaBytes(box as MatroskaSegment);
 		buffers.push(bytes);
 	}
 

package/src/test/duration.test.ts

@@ -1,7 +1,7 @@
 import {RenderInternals} from '@remotion/renderer';
 import {expect, test} from 'bun:test';
-import {nodeReader} from '../from-node';
 import {parseMedia} from '../parse-media';
+import {nodeReader} from '../readers/from-node';
 
 test('Should get duration of video', async () => {
 	const parsed = await parseMedia({

package/src/test/matroska.test.ts

@@ -1,7 +1,7 @@
 import {RenderInternals} from '@remotion/renderer';
 import {expect, test} from 'bun:test';
-import {nodeReader} from '../from-node';
 import {parseMedia} from '../parse-media';
+import {nodeReader} from '../readers/from-node';
 
 test('Should get duration of AV1 video', async () => {
 	const parsed = await parseMedia({
@@ -233,10 +233,40 @@ test('Should get duration of AV1 video', async () => {
 										},
 										{
 											type: 'Colour',
-											value: new Uint8Array([
-												85, 186, 129, 1, 85, 177, 129, 1, 85, 187, 129, 1, 85,
-												185, 129, 1,
-											]),
+											value: [
+												{
+													minVintWidth: 1,
+													type: 'TransferCharacteristics',
+													value: {
+														byteLength: 1,
+														value: 1,
+													},
+												},
+												{
+													minVintWidth: 1,
+													type: 'MatrixCoefficients',
+													value: {
+														byteLength: 1,
+														value: 1,
+													},
+												},
+												{
+													minVintWidth: 1,
+													type: 'Primaries',
+													value: {
+														byteLength: 1,
+														value: 1,
+													},
+												},
+												{
+													minVintWidth: 1,
+													type: 'Range',
+													value: {
+														byteLength: 1,
+														value: 1,
+													},
+												},
+											],
 											minVintWidth: 1,
 										},
 									],

package/src/test/parse-video.test.ts

@@ -1,7 +1,7 @@
 import {RenderInternals} from '@remotion/renderer';
 import {expect, test} from 'bun:test';
-import {nodeReader} from '../from-node';
 import {parseMedia} from '../parse-media';
+import {nodeReader} from '../readers/from-node';
 
 test('Parse Big Buck bunny', async () => {
 	const data = await parseMedia({

package/src/test/parse-webm.test.ts

@@ -1,7 +1,7 @@
 import {RenderInternals} from '@remotion/renderer';
 import {expect, test} from 'bun:test';
-import {nodeReader} from '../from-node';
 import {parseMedia} from '../parse-media';
+import {nodeReader} from '../readers/from-node';
 
 test('should be able to parse a WebM', async () => {
 	const webm = await parseMedia({

package/src/test/stream-local.test.ts

@@ -1,7 +1,7 @@
 import {RenderInternals} from '@remotion/renderer';
 import {expect, test} from 'bun:test';
-import {nodeReader} from '../from-node';
 import {parseMedia} from '../parse-media';
+import {nodeReader} from '../readers/from-node';
 
 test('Should stream ISO base media', async () => {
 	let videoTracks = 0;

package/src/test/stream-samples.test.ts

@@ -2,8 +2,8 @@ import {RenderInternals} from '@remotion/renderer';
 import {expect, test} from 'bun:test';
 import {getSamplePositionsFromTrack} from '../boxes/iso-base-media/get-sample-positions-from-track';
 import type {TrakBox} from '../boxes/iso-base-media/trak/trak';
-import {nodeReader} from '../from-node';
 import {parseMedia} from '../parse-media';
+import {nodeReader} from '../readers/from-node';
 
 test('Stream samples', async () => {
 	const {videoTracks, audioTracks} = await parseMedia({

package/src/writers/web-fs.ts

@@ -0,0 +1,50 @@
+import type {Writer, WriterInterface} from './writer';
+
+const createContent = async () => {
+	const directoryHandle = await navigator.storage.getDirectory();
+	const filename = `media-parser-${Math.random().toString().replace('0.', '')}.webm`;
+
+	const fileHandle = await directoryHandle.getFileHandle(filename, {
+		create: true,
+	});
+	const writable = await fileHandle.createWritable();
+
+	let written = 0;
+
+	const writer: Writer = {
+		write: async (arr: Uint8Array) => {
+			await writable.write(arr);
+			written += arr.byteLength;
+		},
+		save: async () => {
+			await writable.close();
+			const picker = await window.showSaveFilePicker({
+				suggestedName: `${Math.random().toString().replace('.', '')}.webm`,
+			});
+
+			const newHandle = await directoryHandle.getFileHandle(filename, {
+				create: true,
+			});
+			const newFile = await newHandle.getFile();
+			const pickerWriteable = await picker.createWritable();
+			const stream = newFile.stream();
+			await stream.pipeTo(pickerWriteable);
+
+			await directoryHandle.removeEntry(filename, {
+				recursive: true,
+			});
+		},
+		getWrittenByteCount: () => written,
+		updateDataAt: async (position: number, vint: Uint8Array) => {
+			await writable.seek(position);
+			await writable.write(vint);
+			await writable.seek(written);
+		},
+	};
+
+	return writer;
+};
+
+export const webFsWriter: WriterInterface = {
+	createContent,
+};

package/src/writers/writer.ts

@@ -0,0 +1,12 @@
+export type Writer = {
+	write: (arr: Uint8Array) => Promise<void>;
+	save: () => Promise<void>;
+	getWrittenByteCount: () => number;
+	updateDataAt: (position: number, vint: Uint8Array) => Promise<void>;
+};
+
+type CreateContent = () => Promise<Writer>;
+
+export type WriterInterface = {
+	createContent: CreateContent;
+};