@remotion/media-parser 4.0.200 → 4.0.202

package/dist/traversal.js

@@ -151,41 +151,41 @@ const getStssBox = (trakBox) => {
 };
 exports.getStssBox = getStssBox;
 const getClusterSegment = (segment) => {
-    const clusterSegment = segment.children.find((b) => b.type === 'cluster-segment');
+    const clusterSegment = segment.value.find((b) => b.type === 'Cluster');
     return clusterSegment !== null && clusterSegment !== void 0 ? clusterSegment : null;
 };
 exports.getClusterSegment = getClusterSegment;
 const getTracksSegment = (segment) => {
-    const tracksSegment = segment.children.find((b) => b.type === 'tracks-segment');
-    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+    const tracksSegment = segment.value.find((b) => b.type === 'Tracks');
+    if (!tracksSegment || tracksSegment.type !== 'Tracks') {
         return null;
     }
     return tracksSegment;
 };
 exports.getTracksSegment = getTracksSegment;
 const getTimescaleSegment = (segment) => {
-    const infoSegment = segment.children.find((b) => b.type === 'info-segment');
-    if (!infoSegment || infoSegment.type !== 'info-segment') {
+    const infoSegment = segment.value.find((b) => b.type === 'Info');
+    if (!infoSegment || infoSegment.type !== 'Info') {
         return null;
     }
-    const timescale = infoSegment.children.find((b) => b.type === 'timestamp-scale-segment');
-    if (!timescale || timescale.type !== 'timestamp-scale-segment') {
+    const timescale = infoSegment.value.find((b) => b.type === 'TimestampScale');
+    if (!timescale || timescale.type !== 'TimestampScale') {
         return null;
     }
     return timescale;
 };
 exports.getTimescaleSegment = getTimescaleSegment;
 const getVideoSegment = (track) => {
-    const videoSegment = track.children.find((b) => b.type === 'video-segment');
-    if (!videoSegment || videoSegment.type !== 'video-segment') {
+    const videoSegment = track.value.find((b) => b.type === 'Video');
+    if (!videoSegment || videoSegment.type !== 'Video') {
         return null;
     }
     return videoSegment !== null && videoSegment !== void 0 ? videoSegment : null;
 };
 exports.getVideoSegment = getVideoSegment;
 const getAudioSegment = (track) => {
-    const audioSegment = track.children.find((b) => b.type === 'audio-segment');
-    if (!audioSegment || audioSegment.type !== 'audio-segment') {
+    const audioSegment = track.value.find((b) => b.type === 'Audio');
+    if (!audioSegment || audioSegment.type !== 'Audio') {
         return null;
     }
     return audioSegment !== null && audioSegment !== void 0 ? audioSegment : null;
@@ -196,12 +196,11 @@ const getSampleRate = (track) => {
     if (!audioSegment) {
         return null;
     }
-    const samplingFrequency = audioSegment.children.find((b) => b.type === 'sampling-frequency-segment');
-    if (!samplingFrequency ||
-        samplingFrequency.type !== 'sampling-frequency-segment') {
+    const samplingFrequency = audioSegment.value.find((b) => b.type === 'SamplingFrequency');
+    if (!samplingFrequency || samplingFrequency.type !== 'SamplingFrequency') {
         return null;
     }
-    return samplingFrequency.samplingFrequency;
+    return samplingFrequency.value.value;
 };
 exports.getSampleRate = getSampleRate;
 const getNumberOfChannels = (track) => {
@@ -209,11 +208,11 @@ const getNumberOfChannels = (track) => {
     if (!audioSegment) {
         throw new Error('Could not find audio segment');
     }
-    const channels = audioSegment.children.find((b) => b.type === 'channels-segment');
-    if (!channels || channels.type !== 'channels-segment') {
+    const channels = audioSegment.value.find((b) => b.type === 'Channels');
+    if (!channels || channels.type !== 'Channels') {
         return 1;
     }
-    return channels.channels;
+    return channels.value.value;
 };
 exports.getNumberOfChannels = getNumberOfChannels;
 const getBitDepth = (track) => {
@@ -221,19 +220,19 @@ const getBitDepth = (track) => {
     if (!audioSegment) {
         return null;
     }
-    const bitDepth = audioSegment.children.find((b) => b.type === 'bit-depth-segment');
-    if (!bitDepth || bitDepth.type !== 'bit-depth-segment') {
+    const bitDepth = audioSegment.value.find((b) => b.type === 'BitDepth');
+    if (!bitDepth || bitDepth.type !== 'BitDepth') {
         return null;
     }
-    return bitDepth.bitDepth;
+    return bitDepth.value.value;
 };
 exports.getBitDepth = getBitDepth;
 const getPrivateData = (track) => {
-    const privateData = track.children.find((b) => b.type === 'codec-private-segment');
-    if (!privateData || privateData.type !== 'codec-private-segment') {
+    const privateData = track.value.find((b) => b.type === 'CodecPrivate');
+    if (!privateData || privateData.type !== 'CodecPrivate') {
         return null;
     }
-    return privateData.codecPrivateData;
+    return privateData.value;
 };
 exports.getPrivateData = getPrivateData;
 const getWidthSegment = (track) => {
@@ -241,8 +240,8 @@ const getWidthSegment = (track) => {
     if (!videoSegment) {
         return null;
     }
-    const width = videoSegment.children.find((b) => b.type === 'width-segment');
-    if (!width || width.type !== 'width-segment') {
+    const width = videoSegment.value.find((b) => b.type === 'PixelWidth');
+    if (!width || width.type !== 'PixelWidth') {
         return null;
     }
     return width;
@@ -253,8 +252,8 @@ const getHeightSegment = (track) => {
     if (!videoSegment) {
         return null;
     }
-    const height = videoSegment.children.find((b) => b.type === 'height-segment');
-    if (!height || height.type !== 'height-segment') {
+    const height = videoSegment.value.find((b) => b.type === 'PixelHeight');
+    if (!height || height.type !== 'PixelHeight') {
         return null;
     }
     return height;
@@ -265,8 +264,8 @@ const getDisplayWidthSegment = (track) => {
     if (!videoSegment) {
         return null;
     }
-    const displayWidth = videoSegment.children.find((b) => b.type === 'display-width-segment');
-    if (!displayWidth || displayWidth.type !== 'display-width-segment') {
+    const displayWidth = videoSegment.value.find((b) => b.type === 'DisplayWidth');
+    if (!displayWidth || displayWidth.type !== 'DisplayWidth') {
         return null;
     }
     return displayWidth;
@@ -277,32 +276,32 @@ const getDisplayHeightSegment = (track) => {
     if (!videoSegment) {
         return null;
     }
-    const displayHeight = videoSegment.children.find((b) => b.type === 'display-height-segment');
-    if (!displayHeight || displayHeight.type !== 'display-height-segment') {
+    const displayHeight = videoSegment.value.find((b) => b.type === 'DisplayHeight');
+    if (!displayHeight || displayHeight.type !== 'DisplayHeight') {
         return null;
     }
     return displayHeight;
 };
 exports.getDisplayHeightSegment = getDisplayHeightSegment;
 const getTrackTypeSegment = (track) => {
-    const trackType = track.children.find((b) => b.type === 'track-type-segment');
-    if (!trackType || trackType.type !== 'track-type-segment') {
+    const trackType = track.value.find((b) => b.type === 'TrackType');
+    if (!trackType || trackType.type !== 'TrackType') {
         return null;
     }
     return trackType;
 };
 exports.getTrackTypeSegment = getTrackTypeSegment;
 const getTrackId = (track) => {
-    const trackId = track.children.find((b) => b.type === 'track-number-segment');
-    if (!trackId || trackId.type !== 'track-number-segment') {
+    const trackId = track.value.find((b) => b.type === 'TrackNumber');
+    if (!trackId || trackId.type !== 'TrackNumber') {
         throw new Error('Expected track number segment');
     }
-    return trackId.trackNumber;
+    return trackId.value.value;
 };
 exports.getTrackId = getTrackId;
 const getCodecSegment = (track) => {
-    const codec = track.children.find((b) => b.type === 'codec-segment');
-    if (!codec || codec.type !== 'codec-segment') {
+    const codec = track.value.find((b) => b.type === 'CodecID');
+    if (!codec || codec.type !== 'CodecID') {
         return null;
     }
     return codec;

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/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,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFsWriter = void 0;
+const createContent = async () => {
+    const directoryHandle = await navigator.storage.getDirectory();
+    const fileHandle = await directoryHandle.getFileHandle('out.web', {
+        create: true,
+    });
+    const f = await fileHandle.getFile();
+    const writable = await fileHandle.createWritable();
+    return {
+        write: async (arr) => {
+            await writable.write(arr);
+        },
+        save: async () => {
+            const picker = await window.showSaveFilePicker({
+                suggestedName: `${Math.random().toString().replace('.', '')}.webm`,
+            });
+            const pickerWriteable = await picker.createWritable();
+            const stream = f.stream();
+            await stream.pipeTo(pickerWriteable);
+            await writable.close();
+        },
+    };
+};
+exports.webFsWriter = {
+    createContent,
+};

package/dist/writers/writer.d.ts

@@ -0,0 +1,9 @@
+type Writer = {
+    write: (arr: Uint8Array) => Promise<void>;
+    save: () => 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,11 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.200",
+  "version": "4.0.202",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.200"
+    "@remotion/renderer": "4.0.202"
   },
   "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,
@@ -116,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/mvhd.ts

@@ -59,7 +59,7 @@ export const parseMvhd = ({
 	const durationInSeconds = durationInUnits / timeScale;
 
 	const rateArray = iterator.getSlice(4);
-	const rateView = getArrayBufferIterator(rateArray);
+	const rateView = getArrayBufferIterator(rateArray, rateArray.length);
 	const rate =
 		rateView.getInt8() * 10 +
 		rateView.getInt8() +
@@ -67,7 +67,7 @@ export const parseMvhd = ({
 		rateView.getInt8() * 0.01;
 
 	const volumeArray = iterator.getSlice(2);
-	const volumeView = getArrayBufferIterator(volumeArray);
+	const volumeView = getArrayBufferIterator(volumeArray, volumeArray.length);
 
 	const volume = volumeView.getInt8() + volumeView.getInt8() * 0.1;
 

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/keys.ts

@@ -6,7 +6,7 @@ export interface KeysBox extends BaseBox {
 }
 
 export const parseKeys = (data: Uint8Array, offset: number): KeysBox => {
-	const iterator = getArrayBufferIterator(data);
+	const iterator = getArrayBufferIterator(data, data.byteLength);
 	const size = iterator.getUint32();
 	if (size !== data.byteLength) {
 		throw new Error(`Expected keys size of ${data.byteLength}, got ${size}`);

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') {