@remotion/media-parser 4.0.206 → 4.0.207

package/dist/readers/from-node.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeReader = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("node:fs/promises");
+const stream_1 = require("stream");
+exports.nodeReader = {
+    read: async (src, range, signal) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `nodeReader`');
+        }
+        const stream = (0, fs_1.createReadStream)(src, {
+            start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+            end: range === null
+                ? Infinity
+                : typeof range === 'number'
+                    ? Infinity
+                    : range[1],
+            signal,
+        });
+        const stats = await (0, promises_1.stat)(src);
+        const reader = stream_1.Readable.toWeb(stream).getReader();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.cancel();
+            }, { once: true });
+        }
+        return {
+            reader,
+            contentLength: stats.size,
+        };
+    },
+    getLength: async (src) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `nodeReader`');
+        }
+        const stats = await (0, promises_1.stat)(src);
+        return stats.size;
+    },
+};

package/dist/readers/from-web-file.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const webFileReader: ReaderInterface;

package/dist/readers/from-web-file.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFileReader = void 0;
+exports.webFileReader = {
+    read: (file, range, signal) => {
+        if (typeof file === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        const part = range === null
+            ? file
+            : typeof range === 'number'
+                ? file.slice(range)
+                : file.slice(range[0], range[1]);
+        const reader = new FileReader();
+        reader.readAsArrayBuffer(file);
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.abort();
+            }, { once: true });
+        }
+        return new Promise((resolve, reject) => {
+            reader.onload = () => {
+                resolve({
+                    reader: part.stream().getReader(),
+                    contentLength: file.size,
+                });
+            };
+            reader.onerror = (error) => {
+                reject(error);
+            };
+        });
+    },
+    getLength: (src) => {
+        if (typeof src === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        return Promise.resolve(src.size);
+    },
+};

package/dist/readers/reader.d.ts

@@ -0,0 +1,11 @@
+type ReadResult = {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    contentLength: number | null;
+};
+type ReadContent = (src: string | File, range: [number, number] | number | null, signal: AbortSignal | undefined) => Promise<ReadResult>;
+type GetLength = (src: string | File) => Promise<number>;
+export type ReaderInterface = {
+    read: ReadContent;
+    getLength: GetLength;
+};
+export {};

package/dist/readers/reader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/traversal.d.ts

@@ -40,7 +40,7 @@ export declare const getClusterSegment: (segment: MainSegment) => ClusterSegment
 export declare const getTracksSegment: (segment: MainSegment) => {
     type: "Tracks";
     value: import("./boxes/webm/segments/all-segments").PossibleEbml[];
-    minVintWidth: number;
+    minVintWidth: number | null;
 } | null;
 export declare const getTimescaleSegment: (segment: MainSegment) => TimestampScaleSegment | null;
 export declare const getVideoSegment: (track: TrackEntry) => VideoSegment | null;

package/dist/writers/web-fs.d.ts

@@ -0,0 +1,2 @@
+import type { WriterInterface } from './writer';
+export declare const webFsWriter: WriterInterface;

package/dist/writers/web-fs.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFsWriter = void 0;
+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 = {
+        write: async (arr) => {
+            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, vint) => {
+            await writable.seek(position);
+            await writable.write(vint);
+            await writable.seek(written);
+        },
+    };
+    return writer;
+};
+exports.webFsWriter = {
+    createContent,
+};

package/dist/writers/writer.d.ts

@@ -0,0 +1,11 @@
+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;
+};
+export {};

package/dist/writers/writer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -3,11 +3,12 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.206",
+  "version": "4.0.207",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.206"
+    "@types/wicg-file-system-access": "2023.10.5",
+    "@remotion/renderer": "4.0.207"
   },
   "publishConfig": {
     "access": "public"
@@ -17,21 +18,25 @@
   },
   "exports": {
     ".": "./dist/index.js",
-    "./node": "./dist/from-node.js",
-    "./fetch": "./dist/from-fetch.js",
-    "./web-file": "./dist/from-web-file.js",
+    "./node": "./dist/readers/from-node.js",
+    "./fetch": "./dist/readers/from-fetch.js",
+    "./web-file": "./dist/readers/from-web-file.js",
+    "./web-fs": "./dist/writers/web-fs.js",
     "./package.json": "./package.json"
   },
   "typesVersions": {
     ">=1.0": {
       "node": [
-        "dist/from-node.d.ts"
+        "dist/readers/from-node.d.ts"
       ],
       "fetch": [
-        "dist/from-fetch.d.ts"
+        "dist/readers/from-fetch.d.ts"
       ],
       "web-file": [
-        "dist/from-web-file.d.ts"
+        "dist/readers/from-web-file.d.ts"
+      ],
+      "web-fs": [
+        "dist/writers/web-fs.d.ts"
       ]
     }
   },

package/src/boxes/iso-base-media/stsd/ctts.ts

@@ -24,7 +24,7 @@ export const parseCtts = ({
 	size: number;
 }): CttsBox => {
 	const version = iterator.getUint8();
-	if (version !== 0) {
+	if (version !== 0 && version !== 1) {
 		throw new Error(`Unsupported CTTS version ${version}`);
 	}
 
@@ -35,7 +35,16 @@ export const parseCtts = ({
 
 	for (let i = 0; i < entryCount; i++) {
 		const sampleCount = iterator.getUint32();
+
+		// V1 = signed, V0 = unsigned
+		// however some files are buggy
+
+		// Let's do the same thing as mp4box but uint32, based on our test set of videos
+		// https://github.com/gpac/mp4box.js/blob/c6cc468145bc5b031b866446111f29c8b620dbe6/src/parsing/ctts.js#L2
 		const sampleOffset = iterator.getUint32();
+		if (sampleOffset < 0) {
+			throw new Error('ctts box uses negative values without using version 1');
+		}
 
 		entries.push({
 			sampleCount,

package/src/boxes/iso-base-media/stsd/samples.ts

@@ -7,9 +7,6 @@ type SampleBase = {
 	format: string;
 	offset: number;
 	dataReferenceIndex: number;
-	version: number;
-	revisionLevel: number;
-	vendor: number[];
 	size: number;
 };
 
@@ -25,6 +22,9 @@ export type AudioSample = SampleBase & {
 	bytesPerFrame: number | null;
 	bitsPerSample: number | null;
 	children: AnySegment[];
+	version: number;
+	revisionLevel: number;
+	vendor: number[];
 };
 
 export type VideoSample = SampleBase & {
@@ -41,6 +41,9 @@ export type VideoSample = SampleBase & {
 	depth: number;
 	colorTableId: number;
 	descriptors: AnySegment[];
+	version: number;
+	revisionLevel: number;
+	vendor: number[];
 };
 
 type UnknownSample = SampleBase & {
@@ -139,9 +142,6 @@ export const processSample = async ({
 	iterator.discard(6);
 
 	const dataReferenceIndex = iterator.getUint16();
-	const version = iterator.getUint16();
-	const revisionLevel = iterator.getUint16();
-	const vendor = iterator.getSlice(4);
 
 	if (!isVideo && !isAudio) {
 		const bytesRemainingInBox =
@@ -153,9 +153,6 @@ export const processSample = async ({
 				type: 'unknown',
 				offset: fileOffset,
 				dataReferenceIndex,
-				version,
-				revisionLevel,
-				vendor: [...Array.from(new Uint8Array(vendor))],
 				size: boxSize,
 				format: boxFormat,
 			},
@@ -163,6 +160,9 @@ export const processSample = async ({
 	}
 
 	if (isAudio) {
+		const version = iterator.getUint16();
+		const revisionLevel = iterator.getUint16();
+		const vendor = iterator.getSlice(4);
 		if (version === 0) {
 			const numberOfChannels = iterator.getUint16();
 			const sampleSize = iterator.getUint16();
@@ -268,6 +268,9 @@ export const processSample = async ({
 	}
 
 	if (isVideo) {
+		const version = iterator.getUint16();
+		const revisionLevel = iterator.getUint16();
+		const vendor = iterator.getSlice(4);
 		const temporalQuality = iterator.getUint32();
 		const spacialQuality = iterator.getUint32();
 		const width = iterator.getUint16();

package/src/boxes/webm/make-header.ts

@@ -1,16 +1,22 @@
 import {getVariableInt} from './ebml';
 import type {
+	BytesAndOffset,
 	FloatWithSize,
+	OffsetAndChildren,
 	PossibleEbml,
 	PossibleEbmlOrUint8Array,
 	UintWithSize,
+} from './segments/all-segments';
+import {
+	ebmlMap,
+	getIdForName,
+	incrementOffsetAndChildren,
 	matroskaElements,
 } from './segments/all-segments';
-import {ebmlMap, getIdForName} from './segments/all-segments';
 
 export const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
 
-const matroskaToHex = (
+export const matroskaToHex = (
 	matrId: (typeof matroskaElements)[keyof typeof matroskaElements],
 ) => {
 	const numbers: Uint8Array = new Uint8Array((matrId.length - 2) / 2);
@@ -45,10 +51,10 @@ function putUintDynamic(number: number, minimumLength: number | null) {
 	return bytes;
 }
 
-const makeFromHeaderStructure = (
+const makeFromStructure = (
 	fields: PossibleEbmlOrUint8Array,
-): Uint8Array => {
-	if (fields instanceof Uint8Array) {
+): BytesAndOffset => {
+	if ('bytes' in fields) {
 		return fields;
 	}
 
@@ -57,26 +63,51 @@ const makeFromHeaderStructure = (
 	const struct = ebmlMap[getIdForName(fields.type)];
 
 	if (struct.type === 'uint8array') {
-		return fields.value as Uint8Array;
+		return {
+			bytes: fields.value as Uint8Array,
+			offsets: {offset: 0, children: [], field: fields.type},
+		};
 	}
 
 	if (struct.type === 'children') {
+		const children: OffsetAndChildren[] = [];
+		let bytesWritten = 0;
 		for (const item of fields.value as PossibleEbml[]) {
-			arrays.push(makeMatroskaBytes(item));
+			const {bytes, offsets} = makeMatroskaBytes(item);
+			arrays.push(bytes);
+			children.push(incrementOffsetAndChildren(offsets, bytesWritten));
+			bytesWritten += bytes.byteLength;
 		}
 
-		return combineUint8Arrays(arrays);
+		return {
+			bytes: combineUint8Arrays(arrays),
+			offsets: {offset: 0, children, field: fields.type},
+		};
 	}
 
 	if (struct.type === 'string') {
-		return new TextEncoder().encode(fields.value as string);
+		return {
+			bytes: new TextEncoder().encode(fields.value as string),
+			offsets: {
+				children: [],
+				offset: 0,
+				field: fields.type,
+			},
+		};
 	}
 
 	if (struct.type === 'uint') {
-		return putUintDynamic(
-			(fields.value as UintWithSize).value,
-			(fields.value as UintWithSize).byteLength,
-		);
+		return {
+			bytes: putUintDynamic(
+				(fields.value as UintWithSize).value,
+				(fields.value as UintWithSize).byteLength,
+			),
+			offsets: {
+				children: [],
+				offset: 0,
+				field: fields.type,
+			},
+		};
 	}
 
 	if (struct.type === 'hex-string') {
@@ -87,7 +118,14 @@ const makeFromHeaderStructure = (
 			arr[i / 2] = byte;
 		}
 
-		return arr;
+		return {
+			bytes: arr,
+			offsets: {
+				children: [],
+				offset: 0,
+				field: fields.type,
+			},
+		};
 	}
 
 	if (struct.type === 'float') {
@@ -95,29 +133,89 @@ const makeFromHeaderStructure = (
 		if (value.size === '32') {
 			const dataView = new DataView(new ArrayBuffer(4));
 			dataView.setFloat32(0, value.value);
-			return new Uint8Array(dataView.buffer);
+			return {
+				bytes: new Uint8Array(dataView.buffer),
+				offsets: {
+					children: [],
+					offset: 0,
+					field: fields.type,
+				},
+			};
 		}
 
 		const dataView2 = new DataView(new ArrayBuffer(8));
 		dataView2.setFloat64(0, value.value);
-		return new Uint8Array(dataView2.buffer);
+		return {
+			bytes: new Uint8Array(dataView2.buffer),
+			offsets: {
+				children: [],
+				offset: 0,
+				field: fields.type,
+			},
+		};
 	}
 
 	throw new Error('Unexpected type');
 };
 
-export const makeMatroskaBytes = (fields: PossibleEbmlOrUint8Array) => {
-	if (fields instanceof Uint8Array) {
+export const makeMatroskaBytes = (
+	fields: PossibleEbmlOrUint8Array,
+): BytesAndOffset => {
+	if ('bytes' in fields) {
 		return fields;
 	}
 
-	const value = makeFromHeaderStructure(fields);
+	const value = makeFromStructure(fields);
+	const header = matroskaToHex(getIdForName(fields.type));
+	const size = getVariableInt(value.bytes.length, fields.minVintWidth);
+
+	const bytes = combineUint8Arrays([header, size, value.bytes]);
+
+	return {
+		bytes,
+		offsets: {
+			offset: value.offsets.offset,
+			field: value.offsets.field,
+			children: value.offsets.children.map((c) => {
+				return incrementOffsetAndChildren(
+					c,
+					header.byteLength + size.byteLength,
+				);
+			}),
+		},
+	};
+};
+
+export const padMatroskaBytes = (
+	fields: PossibleEbmlOrUint8Array,
+	totalLength: number,
+): BytesAndOffset[] => {
+	const regular = makeMatroskaBytes(fields);
+	const paddingLength =
+		totalLength -
+		regular.bytes.byteLength -
+		matroskaToHex(matroskaElements.Void).byteLength;
+
+	if (paddingLength < 0) {
+		throw new Error('ooops');
+	}
 
-	return combineUint8Arrays([
-		matroskaToHex(getIdForName(fields.type)),
-		getVariableInt(value.length, fields.minVintWidth),
-		value,
-	]);
+	const padding = makeMatroskaBytes({
+		type: 'Void',
+		value: new Uint8Array(paddingLength).fill(0),
+		minVintWidth: null,
+	});
+
+	return [
+		regular,
+		{
+			bytes: padding.bytes,
+			offsets: incrementOffsetAndChildren(
+				padding.offsets,
+				regular.bytes.length,
+			),
+		},
+	];
 };
 
 export const combineUint8Arrays = (arrays: Uint8Array[]) => {
@@ -143,3 +241,13 @@ export const combineUint8Arrays = (arrays: Uint8Array[]) => {
 
 	return result;
 };
+
+export function serializeUint16(value: number): Uint8Array {
+	const buffer = new ArrayBuffer(2);
+
+	const view = new DataView(buffer);
+
+	view.setUint16(0, value);
+
+	return new Uint8Array(buffer);
+}

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

@@ -43,8 +43,11 @@ export const parseEbml = async (
 		const beforeUintOffset = iterator.counter.getOffset();
 		const value = size === 0 ? 0 : iterator.getUint(size);
 
+		const {name} = hasInMap;
+
 		return {
-			type: hasInMap.name,
+			// To work around TS limit
+			type: name as 'SeekPosition',
 			value: {
 				value,
 				byteLength: iterator.counter.getOffset() - beforeUintOffset,

package/src/boxes/webm/segments/all-segments.ts

@@ -360,7 +360,7 @@ export const ebmlReadVersion = {
 export const ebmlMaxIdLength = {
 	name: 'EBMLMaxIDLength',
 	type: 'uint',
-} satisfies Ebml;
+} as const satisfies Ebml;
 
 export const ebmlMaxSizeLength = {
 	name: 'EBMLMaxSizeLength',
@@ -539,7 +539,37 @@ export const trackUID = {
 
 export const color = {
 	name: 'Colour',
-	type: 'uint8array',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const transfer = {
+	name: 'TransferCharacteristics',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const matrix = {
+	name: 'MatrixCoefficients',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const primaries = {
+	name: 'Primaries',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const range = {
+	name: 'Range',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const ChromaSitingHorz = {
+	name: 'ChromaSitingHorz',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const ChromaSitingVert = {
+	name: 'ChromaSitingVert',
+	type: 'uint',
 } as const satisfies Ebml;
 
 export const language = {
@@ -579,7 +609,7 @@ export const videoSegment = {
 
 export const flagDefault = {
 	name: 'FlagDefault',
-	type: 'uint8array',
+	type: 'uint',
 } as const satisfies Ebml;
 
 export const referenceBlock = {
@@ -661,7 +691,7 @@ export type ClusterSegment = EbmlParsed<typeof cluster>;
 export type Tracks = EbmlParsed<typeof tracks>;
 
 export type FloatWithSize = {value: number; size: '32' | '64'};
-export type UintWithSize = {value: number; byteLength: number};
+export type UintWithSize = {value: number; byteLength: number | null};
 
 export type EbmlValue<
 	T extends Ebml,
@@ -687,13 +717,13 @@ export type EbmlValueOrUint8Array<T extends Ebml> =
 export type EbmlParsed<T extends Ebml> = {
 	type: T['name'];
 	value: EbmlValue<T>;
-	minVintWidth: number;
+	minVintWidth: number | null;
 };
 
 export type EbmlParsedOrUint8Array<T extends Ebml> = {
 	type: T['name'];
 	value: EbmlValueOrUint8Array<T>;
-	minVintWidth: number;
+	minVintWidth: number | null;
 };
 
 export const ebmlMap = {
@@ -807,6 +837,12 @@ export const ebmlMap = {
 		name: 'Cluster',
 		type: 'children',
 	},
+	[matroskaElements.TransferCharacteristics]: transfer,
+	[matroskaElements.MatrixCoefficients]: matrix,
+	[matroskaElements.Primaries]: primaries,
+	[matroskaElements.Range]: range,
+	[matroskaElements.ChromaSitingHorz]: ChromaSitingHorz,
+	[matroskaElements.ChromaSitingVert]: ChromaSitingVert,
 } as const satisfies Partial<Record<MatroskaElement, Ebml>>;
 
 export type PossibleEbml = Prettify<
@@ -815,6 +851,30 @@ export type PossibleEbml = Prettify<
 	}[keyof typeof ebmlMap]
 >;
 
+export type OffsetAndChildren = {
+	offset: number;
+	children: OffsetAndChildren[];
+	field: keyof typeof matroskaElements;
+};
+
+export const incrementOffsetAndChildren = (
+	offset: OffsetAndChildren,
+	increment: number,
+): OffsetAndChildren => {
+	return {
+		offset: offset.offset + increment,
+		children: offset.children.map((c) =>
+			incrementOffsetAndChildren(c, increment),
+		),
+		field: offset.field,
+	};
+};
+
+export type BytesAndOffset = {
+	bytes: Uint8Array;
+	offsets: OffsetAndChildren;
+};
+
 export type PossibleEbmlOrUint8Array =
 	| Prettify<
 			{
@@ -823,6 +883,6 @@ export type PossibleEbmlOrUint8Array =
 				>;
 			}[keyof typeof ebmlMap]
 	  >
-	| Uint8Array;
+	| BytesAndOffset;
 
 export type EbmlMapKey = keyof typeof ebmlMap;