@remotion/media-parser 4.0.207 → 4.0.209

package/dist/read-and-increment-offset.js

@@ -0,0 +1,177 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _OffsetCounter_offset;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayBufferIterator = exports.OffsetCounter = void 0;
+class OffsetCounter {
+    constructor(initial) {
+        _OffsetCounter_offset.set(this, void 0);
+        __classPrivateFieldSet(this, _OffsetCounter_offset, initial, "f");
+    }
+    increment(amount) {
+        if (amount < 0) {
+            throw new Error('Cannot increment by a negative amount');
+        }
+        __classPrivateFieldSet(this, _OffsetCounter_offset, __classPrivateFieldGet(this, _OffsetCounter_offset, "f") + amount, "f");
+    }
+    getOffset() {
+        return __classPrivateFieldGet(this, _OffsetCounter_offset, "f");
+    }
+}
+exports.OffsetCounter = OffsetCounter;
+_OffsetCounter_offset = new WeakMap();
+const makeOffsetCounter = (initial) => {
+    return new OffsetCounter(initial);
+};
+const getArrayBufferIterator = (data, initialOffset) => {
+    const view = new DataView(data);
+    const counter = makeOffsetCounter(initialOffset);
+    const getSlice = (amount) => {
+        const value = data.slice(counter.getOffset(), counter.getOffset() + amount);
+        counter.increment(amount);
+        return value;
+    };
+    const getUint8 = () => {
+        const val = view.getUint8(counter.getOffset());
+        counter.increment(1);
+        return val;
+    };
+    const getUint32 = () => {
+        const val = view.getUint32(counter.getOffset());
+        counter.increment(4);
+        return val;
+    };
+    return {
+        view,
+        counter,
+        data,
+        discard: (length) => {
+            counter.increment(length);
+        },
+        getSlice,
+        getAtom: () => {
+            const atom = getSlice(4);
+            return new TextDecoder().decode(atom);
+        },
+        getMatroskaSegmentId: () => {
+            const first = getSlice(1);
+            const firstOneString = `0x${Array.from(new Uint8Array(first))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            // Catch void block
+            const knownIdsWithOneLength = ['0xec', '0xae'];
+            if (knownIdsWithOneLength.includes(firstOneString)) {
+                return firstOneString;
+            }
+            const firstTwo = getSlice(1);
+            const knownIdsWithTwoLength = ['0x4dbb', '0x53ac', '0xec01'];
+            const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            if (knownIdsWithTwoLength.includes(firstTwoString)) {
+                return firstTwoString;
+            }
+            const knownIdsWithThreeLength = ['0x4d808c', '0x57418c', '0x448988'];
+            const firstThree = getSlice(1);
+            const firstThreeString = `${firstTwoString}${Array.from(new Uint8Array(firstThree))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            if (knownIdsWithThreeLength.includes(firstThreeString)) {
+                return firstThreeString;
+            }
+            const segmentId = getSlice(1);
+            return `${firstThreeString}${Array.from(new Uint8Array(segmentId))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+        },
+        getVint: (bytes) => {
+            const slice = getSlice(bytes);
+            const d = [...Array.from(new Uint8Array(slice))];
+            const totalLength = d[0];
+            if (totalLength === 0) {
+                return 0;
+            }
+            // Calculate the actual length of the data based on the first set bit
+            let actualLength = 0;
+            while (((totalLength >> (7 - actualLength)) & 0x01) === 0) {
+                actualLength++;
+            }
+            actualLength += 1; // Include the first byte set as 1
+            // Combine the numbers to form the integer value
+            let value = 0;
+            // Mask the first byte properly then start combining
+            value = totalLength & (0xff >> actualLength);
+            for (let i = 1; i < actualLength; i++) {
+                value = (value << 8) | d[i];
+            }
+            return value;
+        },
+        getUint8,
+        getEBML: () => {
+            const val = getUint8();
+            // https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/#:~:text=The%20first%20four%20bytes%20(%201A,%E2%80%93%20read%20on%20for%20why).
+            // You drop the initial 0 bits and the first 1 bit to get the value. 0x81 is 0b10000001, so there are zero inital 0 bits, meaning length one byte, and the value is 1. The 0x9F value for length of the EBML header we saw earlier is 0b10011111, still one byte, value is 0b0011111, which is 31 (the python repl is very helpful for these conversions).
+            const actualValue = val & 0x7f; // 0x7F is binary 01111111, which masks out the first bit
+            return actualValue;
+        },
+        getInt8: () => {
+            const val = view.getInt8(counter.getOffset());
+            counter.increment(1);
+            return val;
+        },
+        getUint16: () => {
+            const val = view.getUint16(counter.getOffset());
+            counter.increment(2);
+            return val;
+        },
+        getInt16: () => {
+            const val = view.getInt16(counter.getOffset());
+            counter.increment(2);
+            return val;
+        },
+        getUint32,
+        // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_description_version_1
+        // A 32-bit unsigned fixed-point number (16.16) that indicates the rate at which the sound samples were obtained.
+        getFixedPoint1616Number: () => {
+            const val = getUint32();
+            return val / 2 ** 16;
+        },
+        getPascalString: () => {
+            const val = getSlice(32);
+            return [...Array.from(new Uint8Array(val))];
+        },
+        getDecimalBytes(length) {
+            const bytes = getSlice(length);
+            const numbers = [...Array.from(new Uint8Array(bytes))];
+            return numbers.reduce((acc, byte, index) => acc + (byte << (8 * (numbers.length - index - 1))), 0);
+        },
+        getByteString(length) {
+            const bytes = getSlice(length);
+            return new TextDecoder().decode(bytes);
+        },
+        getFloat64: () => {
+            const val = view.getFloat64(counter.getOffset());
+            counter.increment(8);
+            return val;
+        },
+    };
+};
+exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/readers/from-fetch.js

@@ -12,7 +12,7 @@ exports.fetchReader = {
         if (!resolvedUrl.startsWith('https://') &&
             !resolvedUrl.startsWith('http://')) {
             return Promise.reject(new Error(resolvedUrl +
-                ' is not a URL - needs to start with http:// or https://. If you want to read a local file, pass `nodeReader` to parseMedia().'));
+                ' is not a URL - needs to start with http:// or https://. If you want to read a local file, pass `reader: nodeReader` to parseMedia().'));
         }
         const res = await fetch(resolvedUrl, {
             headers: range === null

package/dist/understand-vorbis.d.ts

@@ -0,0 +1 @@
+declare const understand: (src: string) => Promise<void>;

package/dist/understand-vorbis.js

@@ -0,0 +1,12 @@
+"use strict";
+const understand = async (src) => {
+    const content = await Bun.file(src).arrayBuffer();
+    const firstBit = new DataView(content).getUint8(0);
+    const offset = new DataView(content).getUint8(1);
+    const offset2 = new DataView(content).getUint8(2);
+    const globalOffset = firstBit + 1;
+    const header = new TextDecoder().decode(content.slice(globalOffset, globalOffset + offset));
+    const comment = new TextDecoder().decode(content.slice(globalOffset + offset, globalOffset + offset2));
+    const rest = new TextDecoder().decode(content.slice(globalOffset + offset2 + offset, globalOffset + offset2 + offset + 50));
+    console.log({ firstBit, offset, offset2, header, comment, rest });
+};

package/package.json

@@ -3,12 +3,12 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.207",
+  "version": "4.0.209",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
-    "@remotion/renderer": "4.0.207"
+    "@remotion/renderer": "4.0.209"
   },
   "publishConfig": {
     "access": "public"

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

@@ -110,6 +110,10 @@ export const parseEbml = async (
 
 		// eslint-disable-next-line no-constant-condition
 		while (true) {
+			if (size === 0) {
+				break;
+			}
+
 			const offset = iterator.counter.getOffset();
 			const value = await parseEbml(iterator, parserContext);
 			const remapped = await postprocessEbml({

package/src/buffer-iterator.ts

@@ -459,6 +459,13 @@ export const getArrayBufferIterator = (
 				value = (value << 8) | d[i];
 			}
 
+			// Livestreamed segments sometimes have a Cluster length of 0xFFFFFFFFFFFFFF
+			// which we parse as -1
+			// this should be treated as Infinity
+			if (value === -1) {
+				return Infinity;
+			}
+
 			return value;
 		},
 		getUint8,

package/src/create/cluster-segment.ts

@@ -8,15 +8,15 @@ import {
 
 export const CLUSTER_MIN_VINT_WIDTH = 8;
 
-export const createClusterSegment = () => {
+export const createClusterSegment = (timestamp: number) => {
 	return makeMatroskaBytes({
 		type: 'Cluster',
 		value: [
 			{
 				type: 'Timestamp',
-				minVintWidth: 4,
+				minVintWidth: null,
 				value: {
-					value: 0,
+					value: timestamp,
 					byteLength: null,
 				},
 			},

package/src/create/cluster.ts

@@ -0,0 +1,64 @@
+import {getVariableInt} from '../boxes/webm/ebml';
+import {matroskaToHex} from '../boxes/webm/make-header';
+import {matroskaElements} from '../boxes/webm/segments/all-segments';
+import type {Writer} from '../writers/writer';
+import {
+	CLUSTER_MIN_VINT_WIDTH,
+	createClusterSegment,
+	makeSimpleBlock,
+} from './cluster-segment';
+import {CREATE_TIME_SCALE} from './timescale';
+
+const maxClusterTimestamp = 2 ** 15;
+
+const timestampToClusterTimestamp = (timestamp: number) => {
+	return Math.round((timestamp / CREATE_TIME_SCALE) * 1000);
+};
+
+export const makeCluster = async (w: Writer, timestamp: number) => {
+	const cluster = createClusterSegment(timestampToClusterTimestamp(timestamp));
+	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 timecodeRelativeToCluster =
+			timestampToClusterTimestamp(chunk.timestamp) -
+			timestampToClusterTimestamp(timestamp);
+		if (timecodeRelativeToCluster > maxClusterTimestamp) {
+			throw new Error('timecodeRelativeToCluster is too big');
+		}
+
+		const keyframe = chunk.type === 'key';
+		const simpleBlock = makeSimpleBlock({
+			bytes: arr,
+			invisible: false,
+			keyframe,
+			lacing: 0,
+			trackNumber,
+			timecodeRelativeToCluster,
+		});
+
+		clusterSize += simpleBlock.byteLength;
+		await w.updateDataAt(
+			clusterVIntPosition,
+			getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH),
+		);
+		await w.write(simpleBlock);
+	};
+
+	const shouldMakeNewCluster = (chunk: EncodedVideoChunk) => {
+		const newTimestamp = timestampToClusterTimestamp(chunk.timestamp);
+		const oldTimestamp = timestampToClusterTimestamp(timestamp);
+
+		return newTimestamp - oldTimestamp >= 2000 && chunk.type === 'key';
+	};
+
+	return {addSample, shouldMakeNewCluster};
+};

package/src/create/create-media.ts

@@ -1,17 +1,8 @@
-import {getVariableInt} from '../boxes/webm/ebml';
-import {
-	combineUint8Arrays,
-	matroskaToHex,
-	padMatroskaBytes,
-} from '../boxes/webm/make-header';
+import {combineUint8Arrays} 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 {makeCluster} from './cluster';
+import {makeDurationWithPadding} from './make-duration-with-padding';
 import {makeMatroskaHeader} from './matroska-header';
 import {makeMatroskaInfo} from './matroska-info';
 import {createMatroskaSegment} from './matroska-segment';
@@ -21,6 +12,7 @@ import {
 	makeMatroskaTracks,
 	makeMatroskaVideoTrackEntryBytes,
 } from './matroska-trackentry';
+import {CREATE_TIME_SCALE} from './timescale';
 
 export type MediaFn = {
 	save: () => Promise<void>;
@@ -43,9 +35,7 @@ export const createMedia = async (
 	const w = await writer.createContent();
 	await w.write(header.bytes);
 	const matroskaInfo = makeMatroskaInfo({
-		timescale: 1_000_000,
-		// TODO: Hardcoded
-		duration: 2658,
+		timescale: CREATE_TIME_SCALE,
 	});
 
 	const currentTracks: BytesAndOffset[] = [];
@@ -74,50 +64,24 @@ export const createMedia = async (
 
 	await w.write(matroskaSegment.bytes);
 
-	const cluster = createClusterSegment();
-	const clusterVIntPosition =
-		w.getWrittenByteCount() +
-		cluster.offsets.offset +
-		matroskaToHex(matroskaElements.Cluster).byteLength;
+	let currentCluster = await makeCluster(w, 0);
 
-	let clusterSize = cluster.bytes.byteLength;
-	await w.write(cluster.bytes);
+	const getClusterOrMakeNew = async (chunk: EncodedVideoChunk) => {
+		if (!currentCluster.shouldMakeNewCluster(chunk)) {
+			return currentCluster;
+		}
+
+		currentCluster = await makeCluster(w, chunk.timestamp);
+		return currentCluster;
+	};
 
 	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 cluster = await getClusterOrMakeNew(chunk);
+		return cluster.addSample(chunk, trackNumber);
 	};
 
 	const updateDuration = async (newDuration: number) => {
-		const blocks = padMatroskaBytes(
-			{
-				type: 'Duration',
-				value: {
-					value: newDuration,
-					size: '64',
-				},
-				minVintWidth: null,
-			},
-			// TODO: That's too much padding
-			1000,
-		);
+		const blocks = makeDurationWithPadding(newDuration);
 		await w.updateDataAt(
 			durationOffset,
 			combineUint8Arrays(blocks.map((b) => b.bytes)),

package/src/create/make-duration-with-padding.ts

@@ -0,0 +1,15 @@
+import {padMatroskaBytes} from '../boxes/webm/make-header';
+
+export const makeDurationWithPadding = (newDuration: number) => {
+	return padMatroskaBytes(
+		{
+			type: 'Duration',
+			value: {
+				value: newDuration,
+				size: '64',
+			},
+			minVintWidth: null,
+		},
+		100,
+	);
+};

package/src/create/matroska-info.ts

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

package/src/create/timescale.ts

@@ -0,0 +1 @@
+export const CREATE_TIME_SCALE = 1_000_000;

package/src/readers/from-fetch.ts

@@ -18,7 +18,7 @@ export const fetchReader: ReaderInterface = {
 			return Promise.reject(
 				new Error(
 					resolvedUrl +
-						' is not a URL - needs to start with http:// or https://. If you want to read a local file, pass `nodeReader` to parseMedia().',
+						' is not a URL - needs to start with http:// or https://. If you want to read a local file, pass `reader: nodeReader` to parseMedia().',
 				),
 			);
 		}