@remotion/media-parser 4.0.205 → 4.0.207

package/dist/create/matroska-trackentry.d.ts

@@ -11,12 +11,22 @@ export declare const makeMatroskaVideoBytes: ({ color, width, height, }: {
     width: number;
     height: number;
 }) => BytesAndOffset;
-export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, defaultDuration, trackNumber, codecId, }: {
+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;
-}) => BytesAndOffset;
-export declare const makeMatroskaTracks: (tracks: BytesAndOffset[]) => BytesAndOffset;
+    type: 'video';
+};
+export declare const makeMatroskaAudioTrackEntryBytes: ({ trackNumber, codecId, numberOfChannels: audioChannels, sampleRate, }: MakeTrackAudio) => BytesAndOffset;
+export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, defaultDuration, trackNumber, codecId, }: MakeTrackVideo) => BytesAndOffset;
+export declare const makeMatroskaTracks: (tracks: BytesAndOffset[]) => BytesAndOffset[];

package/dist/create/matroska-trackentry.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMatroskaTracks = exports.makeMatroskaVideoTrackEntryBytes = exports.makeMatroskaVideoBytes = exports.makeMatroskaColorBytes = void 0;
+exports.makeMatroskaTracks = exports.makeMatroskaVideoTrackEntryBytes = exports.makeMatroskaAudioTrackEntryBytes = exports.makeMatroskaVideoBytes = exports.makeMatroskaColorBytes = void 0;
 const make_header_1 = require("../boxes/webm/make-header");
 const makeMatroskaColorBytes = ({ transferChracteristics, matrixCoefficients, primaries, fullRange, }) => {
     const rangeValue = transferChracteristics && matrixCoefficients
@@ -112,6 +112,79 @@ const makeMatroskaVideoBytes = ({ color, width, height, }) => {
     });
 };
 exports.makeMatroskaVideoBytes = makeMatroskaVideoBytes;
+const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codecId, numberOfChannels: audioChannels, sampleRate, }) => {
+    return (0, make_header_1.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,
+            },
+        ],
+    });
+};
+exports.makeMatroskaAudioTrackEntryBytes = makeMatroskaAudioTrackEntryBytes;
 const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, defaultDuration, trackNumber, codecId, }) => {
     return (0, make_header_1.makeMatroskaBytes)({
         type: 'TrackEntry',
@@ -182,10 +255,12 @@ const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, defaultDuratio
 };
 exports.makeMatroskaVideoTrackEntryBytes = makeMatroskaVideoTrackEntryBytes;
 const makeMatroskaTracks = (tracks) => {
-    return (0, make_header_1.makeMatroskaBytes)({
+    return (0, make_header_1.padMatroskaBytes)((0, make_header_1.makeMatroskaBytes)({
         type: 'Tracks',
         value: tracks,
         minVintWidth: null,
-    });
+    }), 
+    // TODO: That's too much padding
+    1000);
 };
 exports.makeMatroskaTracks = makeMatroskaTracks;

package/dist/index.d.ts

@@ -1,2 +1,7 @@
+export { AudioTrack, OtherTrack, Track, VideoTrack } from './get-tracks';
 export { parseMedia } from './parse-media';
 export { AudioSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, VideoSample, } from './webcodec-sample-types';
+export type { MediaFn } from './create/create-media';
+export declare const MediaParserInternals: {
+    createMedia: (writer: import("./writers/writer").WriterInterface) => Promise<import("./create/create-media").MediaFn>;
+};

package/dist/index.js

@@ -1,5 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMedia = void 0;
+exports.MediaParserInternals = exports.parseMedia = void 0;
+const create_media_1 = require("./create/create-media");
 var parse_media_1 = require("./parse-media");
 Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
+exports.MediaParserInternals = {
+    createMedia: create_media_1.createMedia,
+};

package/dist/options.d.ts

@@ -2,7 +2,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 = 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1' | 'prores';
 export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis' | 'unknown';

package/dist/parse-media.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMedia = void 0;
 const buffer_iterator_1 = require("./buffer-iterator");
-const from_fetch_1 = require("./from-fetch");
 const get_audio_codec_1 = require("./get-audio-codec");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
@@ -12,6 +11,7 @@ const get_video_codec_1 = require("./get-video-codec");
 const has_all_info_1 = require("./has-all-info");
 const parse_video_1 = require("./parse-video");
 const parser_state_1 = require("./parser-state");
+const from_fetch_1 = require("./readers/from-fetch");
 const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, }) => {
     const state = (0, parser_state_1.makeParserState)({
         hasAudioCallbacks: onAudioTrack !== null,

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/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.205",
+  "version": "4.0.207",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.205"
+    "@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

@@ -41,10 +41,13 @@ export const parseEbml = async (
 
 	if (hasInMap.type === 'uint') {
 		const beforeUintOffset = iterator.counter.getOffset();
-		const value = iterator.getUint(size);
+		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,
@@ -64,7 +67,12 @@ export const parseEbml = async (
 	}
 
 	if (hasInMap.type === 'float') {
-		const value = size === 4 ? iterator.getFloat32() : iterator.getFloat64();
+		const value =
+			size === 0
+				? 0.0
+				: size === 4
+					? iterator.getFloat32()
+					: iterator.getFloat64();
 
 		return {
 			type: hasInMap.name,