@remotion/media-parser 4.0.199 → 4.0.201

package/dist/parser-state.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeParserState = void 0;
 const traversal_1 = require("./boxes/webm/traversal");
 const traversal_2 = require("./traversal");
-const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
+const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
     const trackEntries = {};
     const onTrackEntrySegment = (trackEntry) => {
         const trackId = (0, traversal_2.getTrackId)(trackEntry);
@@ -17,24 +17,48 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
         if (!codec) {
             throw new Error('Expected codec');
         }
-        trackEntries[trackId] = codec;
+        const trackTimescale = (0, traversal_1.getTrackTimestampScale)(trackEntry);
+        trackEntries[trackId] = {
+            codec: codec.codec,
+            trackTimescale,
+        };
     };
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
-    let samplesThatHadToBeQueued = 0;
     const queuedAudioSamples = {};
     const queuedVideoSamples = {};
     const declinedTrackNumbers = [];
     let timescale = null;
     const getTimescale = () => {
+        // https://www.matroska.org/technical/notes.html
+        // When using the default value of TimestampScale of “1,000,000”, one Segment Tick represents one millisecond.
         if (timescale === null) {
-            throw new Error('Timescale not set');
+            return 1000000;
         }
         return timescale;
     };
     const setTimescale = (newTimescale) => {
         timescale = newTimescale;
     };
+    const timestampMap = new Map();
+    const setTimestampOffset = (byteOffset, timestamp) => {
+        timestampMap.set(byteOffset, timestamp);
+    };
+    const getTimestampOffsetForByteOffset = (byteOffset) => {
+        const entries = Array.from(timestampMap.entries());
+        const sortedByByteOffset = entries
+            .sort((a, b) => {
+            return a[0] - b[0];
+        })
+            .reverse();
+        for (const [offset, timestamp] of sortedByByteOffset) {
+            if (offset >= byteOffset) {
+                continue;
+            }
+            return timestamp;
+        }
+        return timestampMap.get(byteOffset);
+    };
     return {
         onTrackEntrySegment,
         getTrackInfoByNumber: (id) => trackEntries[id],
@@ -51,6 +75,8 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
             }
             queuedVideoSamples[id] = [];
         },
+        setTimestampOffset,
+        getTimestampOffsetForByteOffset,
         registerAudioSampleCallback: async (id, callback) => {
             var _a;
             if (callback === null) {
@@ -65,7 +91,9 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
             queuedAudioSamples[id] = [];
         },
         onAudioSample: async (trackId, audioSample) => {
-            var _a;
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
             const callback = audioSampleCallbacks[trackId];
             if (callback) {
                 await callback(audioSample);
@@ -75,15 +103,14 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
                     return;
                 }
                 if (!hasAudioCallbacks) {
-                    return;
+                    throw new Error('No audio callbacks registered');
                 }
-                (_a = queuedAudioSamples[trackId]) !== null && _a !== void 0 ? _a : (queuedAudioSamples[trackId] = []);
-                queuedAudioSamples[trackId].push(audioSample);
-                samplesThatHadToBeQueued++;
             }
         },
         onVideoSample: async (trackId, videoSample) => {
-            var _a;
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
             const callback = videoSampleCallbacks[trackId];
             if (callback) {
                 await callback(videoSample);
@@ -93,18 +120,11 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, }) => {
                     return;
                 }
                 if (!hasVideoCallbacks) {
-                    return;
+                    throw new Error('No video callbacks registered');
                 }
-                (_a = queuedVideoSamples[trackId]) !== null && _a !== void 0 ? _a : (queuedVideoSamples[trackId] = []);
-                queuedVideoSamples[trackId].push(videoSample);
-                samplesThatHadToBeQueued++;
             }
         },
-        getInternalStats: () => {
-            return {
-                samplesThatHadToBeQueued,
-            };
-        },
+        getInternalStats: () => ({}),
         getTimescale,
         setTimescale,
     };

package/dist/reader.d.ts

@@ -2,7 +2,7 @@ type ReadResult = {
     reader: ReadableStreamDefaultReader<Uint8Array>;
     contentLength: number | null;
 };
-type ReadContent = (src: string | File, range: [number, number] | number | null) => Promise<ReadResult>;
+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;

package/dist/web-file.d.ts

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

package/dist/web-file.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputTypeFileReader = void 0;
+exports.inputTypeFileReader = {
+    read: (file, range) => {
+        if (typeof file === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        if (range !== null) {
+            throw new Error('`inputTypeFileReader` does not support `range`');
+        }
+        const part = range === null
+            ? file
+            : typeof range === 'number'
+                ? file.slice(range)
+                : file.slice(range[0], range[1]);
+        const reader = new FileReader();
+        reader.readAsArrayBuffer(file);
+        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/webcodec-sample-types.d.ts

@@ -2,7 +2,6 @@ import type { AudioTrack, VideoTrack } from './get-tracks';
 export type AudioSample = {
     data: Uint8Array;
     timestamp: number;
-    offset: number;
     trackId: number;
     type: 'key' | 'delta';
 };

package/package.json

@@ -3,11 +3,11 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.199",
+  "version": "4.0.201",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.199"
+    "@remotion/renderer": "4.0.201"
   },
   "publishConfig": {
     "access": "public"

package/src/boxes/iso-base-media/mdat/mdat.ts

@@ -26,7 +26,7 @@ export const parseMdat = async ({
 }): Promise<MdatBox> => {
 	const alreadyHas = hasTracks(existingBoxes);
 	if (!alreadyHas) {
-		data.discard(size - 8);
+		data.discard(size - (data.counter.getOffset() - fileOffset));
 		return Promise.resolve({
 			type: 'mdat-box',
 			boxSize: size,
@@ -91,7 +91,6 @@ export const parseMdat = async ({
 			await options.parserState.onAudioSample(sampleWithIndex.track.trackId, {
 				data: bytes,
 				timestamp: sampleWithIndex.samplePosition.offset,
-				offset: data.counter.getOffset(),
 				trackId: sampleWithIndex.track.trackId,
 				type: sampleWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
 			});
@@ -117,6 +116,7 @@ export const parseMdat = async ({
 		}
 
 		const remaining = size - (data.counter.getOffset() - fileOffset);
+		data.removeBytesRead();
 		if (remaining === 0) {
 			break;
 		}

package/src/boxes/iso-base-media/moov/moov.ts

@@ -27,6 +27,7 @@ export const parseMoov = async ({
 		initialBoxes: [],
 		options,
 		continueMdat: false,
+		littleEndian: false,
 	});
 
 	if (children.status === 'incomplete') {

package/src/boxes/iso-base-media/process-box.ts

@@ -37,11 +37,13 @@ const getChildren = async ({
 	iterator,
 	bytesRemainingInBox,
 	options,
+	littleEndian,
 }: {
 	boxType: string;
 	iterator: BufferIterator;
 	bytesRemainingInBox: number;
 	options: ParserContext;
+	littleEndian: boolean;
 }) => {
 	const parseChildren =
 		boxType === 'mdia' ||
@@ -59,6 +61,7 @@ const getChildren = async ({
 			initialBoxes: [],
 			options,
 			continueMdat: false,
+			littleEndian,
 		});
 
 		if (parsed.status === 'incomplete') {
@@ -121,17 +124,37 @@ export const processBox = async ({
 	allowIncompleteBoxes,
 	parsedBoxes,
 	options,
+	littleEndian,
 }: {
 	iterator: BufferIterator;
 	allowIncompleteBoxes: boolean;
 	parsedBoxes: AnySegment[];
 	options: ParserContext;
+	littleEndian: boolean;
 }): Promise<BoxAndNext> => {
 	const fileOffset = iterator.counter.getOffset();
 	const bytesRemaining = iterator.bytesRemaining();
 
-	const boxSize = iterator.getFourByteNumber();
-	if (boxSize === 0) {
+	const boxSizeRaw = iterator.getFourByteNumber(littleEndian);
+
+	// If `boxSize === 1`, the 8 bytes after the box type are the size of the box.
+	if (
+		(boxSizeRaw === 1 && iterator.bytesRemaining() < 12) ||
+		iterator.bytesRemaining() < 4
+	) {
+		iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
+		if (allowIncompleteBoxes) {
+			return {
+				type: 'incomplete',
+			};
+		}
+
+		throw new Error(
+			`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`,
+		);
+	}
+
+	if (boxSizeRaw === 0) {
 		return {
 			type: 'complete',
 			box: {
@@ -143,42 +166,41 @@ export const processBox = async ({
 		};
 	}
 
+	const boxType = iterator.getByteString(4);
+
+	const boxSize =
+		boxSizeRaw === 1 ? iterator.getEightByteNumber(littleEndian) : boxSizeRaw;
+
 	if (bytesRemaining < boxSize) {
-		if (bytesRemaining >= 4) {
-			const type = iterator.getByteString(4);
-			iterator.counter.decrement(4);
-
-			if (type === 'mdat') {
-				const shouldSkip = options.canSkipVideoData || !hasTracks(parsedBoxes);
-
-				if (shouldSkip) {
-					const skipTo = fileOffset + boxSize;
-					const bytesToSkip = skipTo - iterator.counter.getOffset();
-
-					// If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
-					if (bytesToSkip > 1_000_000) {
-						return {
-							type: 'complete',
-							box: {
-								type: 'mdat-box',
-								boxSize,
-								fileOffset,
-								samplesProcessed: false,
-							},
-							size: boxSize,
-							skipTo: fileOffset + boxSize,
-						};
-					}
-				} else {
-					iterator.discard(4);
-					return parseMdatPartially({
-						iterator,
-						boxSize,
-						fileOffset,
-						parsedBoxes,
-						options,
-					});
+		if (boxType === 'mdat') {
+			const shouldSkip = options.canSkipVideoData || !hasTracks(parsedBoxes);
+
+			if (shouldSkip) {
+				const skipTo = fileOffset + boxSize;
+				const bytesToSkip = skipTo - iterator.counter.getOffset();
+
+				// If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
+				if (bytesToSkip > 1_000_000) {
+					return {
+						type: 'complete',
+						box: {
+							type: 'mdat-box',
+							boxSize,
+							fileOffset,
+							samplesProcessed: false,
+						},
+						size: boxSize,
+						skipTo: fileOffset + boxSize,
+					};
 				}
+			} else {
+				return parseMdatPartially({
+					iterator,
+					boxSize,
+					fileOffset,
+					parsedBoxes,
+					options,
+				});
 			}
 		}
 
@@ -194,8 +216,6 @@ export const processBox = async ({
 		);
 	}
 
-	const boxType = iterator.getByteString(4);
-
 	if (boxType === 'ftyp') {
 		const box = parseFtyp({iterator, size: boxSize, offset: fileOffset});
 		return {
@@ -271,11 +291,12 @@ export const processBox = async ({
 		};
 	}
 
-	if (boxType === 'stco') {
+	if (boxType === 'stco' || boxType === 'co64') {
 		const box = parseStco({
 			iterator,
 			offset: fileOffset,
 			size: boxSize,
+			mode64Bit: boxType === 'co64',
 		});
 
 		return {
@@ -352,6 +373,7 @@ export const processBox = async ({
 			offset: fileOffset,
 			size: boxSize,
 			options,
+			littleEndian,
 		});
 
 		return {
@@ -525,6 +547,7 @@ export const processBox = async ({
 		iterator,
 		bytesRemainingInBox,
 		options,
+		littleEndian,
 	});
 
 	return {
@@ -548,6 +571,7 @@ export const parseBoxes = async ({
 	initialBoxes,
 	options,
 	continueMdat,
+	littleEndian,
 }: {
 	iterator: BufferIterator;
 	maxBytes: number;
@@ -555,6 +579,7 @@ export const parseBoxes = async ({
 	initialBoxes: IsoBaseMediaBox[];
 	options: ParserContext;
 	continueMdat: false | PartialMdatBox;
+	littleEndian: boolean;
 }): Promise<ParseResult> => {
 	let boxes: IsoBaseMediaBox[] = initialBoxes;
 	const initialOffset = iterator.counter.getOffset();
@@ -577,6 +602,7 @@ export const parseBoxes = async ({
 					allowIncompleteBoxes,
 					parsedBoxes: initialBoxes,
 					options,
+					littleEndian,
 				});
 
 		if (result.type === 'incomplete') {
@@ -595,6 +621,7 @@ export const parseBoxes = async ({
 						initialBoxes: boxes,
 						options,
 						continueMdat: false,
+						littleEndian,
 					});
 				},
 				skipTo: null,
@@ -614,6 +641,7 @@ export const parseBoxes = async ({
 							initialBoxes: boxes,
 							options,
 							continueMdat: result,
+							littleEndian,
 						}),
 					);
 				},
@@ -641,13 +669,14 @@ export const parseBoxes = async ({
 						initialBoxes: boxes,
 						options,
 						continueMdat: false,
+						littleEndian,
 					});
 				},
 				skipTo: result.skipTo,
 			};
 		}
 
-		iterator.discardFirstBytes();
+		iterator.removeBytesRead();
 	}
 
 	const mdatState = hasSkippedMdatProcessing(boxes);
@@ -663,6 +692,7 @@ export const parseBoxes = async ({
 					initialBoxes: boxes,
 					options,
 					continueMdat: false,
+					littleEndian,
 				});
 			},
 			skipTo: mdatState.fileOffset,

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

@@ -16,11 +16,13 @@ export const parseMebx = async ({
 	offset,
 	size,
 	options,
+	littleEndian,
 }: {
 	iterator: BufferIterator;
 	offset: number;
 	size: number;
 	options: ParserContext;
+	littleEndian: boolean;
 }): Promise<MebxBox> => {
 	// reserved, 6 bit
 	iterator.discard(6);
@@ -34,6 +36,7 @@ export const parseMebx = async ({
 		initialBoxes: [],
 		options,
 		continueMdat: false,
+		littleEndian,
 	});
 
 	if (children.status === 'incomplete') {

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

@@ -179,6 +179,7 @@ export const processSample = async ({
 				initialBoxes: [],
 				options,
 				continueMdat: false,
+				littleEndian: false,
 			});
 
 			if (children.status === 'incomplete') {
@@ -232,6 +233,7 @@ export const processSample = async ({
 				initialBoxes: [],
 				options,
 				continueMdat: false,
+				littleEndian: false,
 			});
 
 			if (children.status === 'incomplete') {
@@ -288,6 +290,7 @@ export const processSample = async ({
 			initialBoxes: [],
 			options,
 			continueMdat: false,
+			littleEndian: false,
 		});
 
 		if (children.status === 'incomplete') {

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

@@ -6,17 +6,19 @@ export interface StcoBox extends BaseBox {
 	version: number;
 	flags: number[];
 	entryCount: number;
-	entries: number[];
+	entries: (number | bigint)[];
 }
 
 export const parseStco = ({
 	iterator,
 	offset,
 	size,
+	mode64Bit,
 }: {
 	iterator: BufferIterator;
 	offset: number;
 	size: number;
+	mode64Bit: boolean;
 }): StcoBox => {
 	const version = iterator.getUint8();
 	if (version !== 0) {
@@ -26,14 +28,14 @@ export const parseStco = ({
 	const flags = iterator.getSlice(3);
 	const entryCount = iterator.getUint32();
 
-	const entries: number[] = [];
+	const entries: (number | bigint)[] = [];
 	for (let i = 0; i < entryCount; i++) {
 		const bytesRemaining = size - (iterator.counter.getOffset() - offset);
 		if (bytesRemaining < 4) {
 			break;
 		}
 
-		entries.push(iterator.getUint32());
+		entries.push(mode64Bit ? iterator.getUint64() : iterator.getUint32());
 	}
 
 	iterator.discard(size - (iterator.counter.getOffset() - offset));

package/src/boxes/iso-base-media/trak/trak.ts

@@ -27,6 +27,7 @@ export const parseTrak = async ({
 		initialBoxes: [],
 		options,
 		continueMdat: false,
+		littleEndian: false,
 	});
 
 	if (children.status === 'incomplete') {

package/src/boxes/webm/ebml.ts

@@ -0,0 +1,78 @@
+// https://github.com/Vanilagy/webm-muxer/blob/main/src/ebml.ts#L101
+
+export const measureEBMLVarInt = (value: number) => {
+	if (value < (1 << 7) - 1) {
+		/** Top bit is set, leaving 7 bits to hold the integer, but we can't store
+		 * 127 because "all bits set to one" is a reserved value. Same thing for the
+		 * other cases below:
+		 */
+		return 1;
+	}
+
+	if (value < (1 << 14) - 1) {
+		return 2;
+	}
+
+	if (value < (1 << 21) - 1) {
+		return 3;
+	}
+
+	if (value < (1 << 28) - 1) {
+		return 4;
+	}
+
+	if (value < 2 ** 35 - 1) {
+		return 5;
+	}
+
+	if (value < 2 ** 42 - 1) {
+		return 6;
+	}
+
+	throw new Error('EBML VINT size not supported ' + value);
+};
+
+export const getVariableInt = (
+	value: number,
+	width: number = measureEBMLVarInt(value),
+) => {
+	switch (width) {
+		case 1:
+			return new Uint8Array([(1 << 7) | value]);
+		case 2:
+			return new Uint8Array([(1 << 6) | (value >> 8), value]);
+		case 3:
+			return new Uint8Array([(1 << 5) | (value >> 16), value >> 8, value]);
+		case 4:
+			return new Uint8Array([
+				(1 << 4) | (value >> 24),
+				value >> 16,
+				value >> 8,
+				value,
+			]);
+		case 5:
+			/**
+			 * JavaScript converts its doubles to 32-bit integers for bitwise
+			 * operations, so we need to do a division by 2^32 instead of a
+			 * right-shift of 32 to retain those top 3 bits
+			 */
+			return new Uint8Array([
+				(1 << 3) | ((value / 2 ** 32) & 0x7),
+				value >> 24,
+				value >> 16,
+				value >> 8,
+				value,
+			]);
+		case 6:
+			return new Uint8Array([
+				(1 << 2) | ((value / 2 ** 40) & 0x3),
+				(value / 2 ** 32) | 0,
+				value >> 24,
+				value >> 16,
+				value >> 8,
+				value,
+			]);
+		default:
+			throw new Error('Bad EBML VINT size ' + width);
+	}
+};