@remotion/media-parser 4.0.191

package/dist/parse-media.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMedia = void 0;
+const buffer_iterator_1 = require("./buffer-iterator");
+const from_web_1 = require("./from-web");
+const get_dimensions_1 = require("./get-dimensions");
+const get_duration_1 = require("./get-duration");
+const get_fps_1 = require("./get-fps");
+const has_all_info_1 = require("./has-all-info");
+const parse_video_1 = require("./parse-video");
+const parseMedia = async (src, options, readerInterface = from_web_1.webReader) => {
+    const reader = await readerInterface.read(src, null);
+    const returnValue = {};
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]));
+    let parseResult = (0, parse_video_1.parseVideo)(iterator);
+    while (parseResult.status === 'incomplete') {
+        const result = await reader.read();
+        if (result.done) {
+            break;
+        }
+        iterator.addData(result.value);
+        parseResult = parseResult.continueParsing();
+        if ((0, has_all_info_1.hasAllInfo)(options, parseResult)) {
+            if (!reader.closed) {
+                reader.cancel(new Error('has all information'));
+            }
+            break;
+        }
+    }
+    if (options.dimensions) {
+        returnValue.dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments);
+    }
+    if (options.durationInSeconds) {
+        returnValue.durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments);
+    }
+    if (options.fps) {
+        returnValue.fps = (0, get_fps_1.getFps)(parseResult.segments);
+    }
+    if (options.boxes) {
+        returnValue.boxes = parseResult.segments;
+    }
+    return returnValue;
+};
+exports.parseMedia = parseMedia;

package/dist/parse-result.d.ts

@@ -0,0 +1,29 @@
+import type { BaseBox } from './boxes/iso-base-media/base-type';
+import type { FtypBox } from './boxes/iso-base-media/ftyp';
+import type { MoovBox } from './boxes/iso-base-media/moov/moov';
+import type { MvhdBox } from './boxes/iso-base-media/mvhd';
+import type { KeysBox } from './boxes/iso-base-media/stsd/keys';
+import type { MebxBox } from './boxes/iso-base-media/stsd/mebx';
+import type { StsdBox } from './boxes/iso-base-media/stsd/stsd';
+import type { SttsBox } from './boxes/iso-base-media/stts/stts';
+import type { TkhdBox } from './boxes/iso-base-media/tkhd';
+import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { MatroskaSegment } from './boxes/webm/segments';
+interface RegularBox extends BaseBox {
+    boxType: string;
+    boxSize: number;
+    children: AnySegment[];
+    offset: number;
+    type: 'regular-box';
+}
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox;
+export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
+export type ParseResult = {
+    status: 'done';
+    segments: AnySegment[];
+} | {
+    status: 'incomplete';
+    segments: AnySegment[];
+    continueParsing: () => ParseResult;
+};
+export {};

package/dist/parse-result.js

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

package/dist/parse-video.d.ts

@@ -0,0 +1,10 @@
+import type { BufferIterator } from './buffer-iterator';
+import type { IsoBaseMediaBox, ParseResult } from './parse-result';
+export type BoxAndNext = {
+    type: 'complete';
+    box: IsoBaseMediaBox;
+    size: number;
+} | {
+    type: 'incomplete';
+};
+export declare const parseVideo: (iterator: BufferIterator) => ParseResult;

package/dist/parse-video.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVideo = void 0;
+const process_box_1 = require("./boxes/iso-base-media/process-box");
+const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
+const parseVideo = (iterator) => {
+    if (iterator.bytesRemaining() === 0) {
+        return {
+            status: 'incomplete',
+            segments: [],
+            continueParsing: () => {
+                return (0, exports.parseVideo)(iterator);
+            },
+        };
+    }
+    if (iterator.isIsoBaseMedia()) {
+        return (0, process_box_1.parseBoxes)({
+            iterator,
+            maxBytes: Infinity,
+            allowIncompleteBoxes: true,
+            initialBoxes: [],
+        });
+    }
+    if (iterator.isWebm()) {
+        return (0, parse_webm_header_1.parseWebm)(iterator);
+    }
+    throw new Error('Unknown video format');
+};
+exports.parseVideo = parseVideo;

package/dist/reader.d.ts

@@ -0,0 +1,7 @@
+type ReadContent = (src: string, range: [number, number] | null) => Promise<ReadableStreamDefaultReader<Uint8Array>>;
+type GetLength = (src: string) => Promise<number>;
+export type ReaderInterface = {
+    read: ReadContent;
+    getLength: GetLength;
+};
+export {};

package/dist/reader.js

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

package/package.json

@@ -0,0 +1,47 @@
+{
+  "repository": {
+    "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
+  },
+  "name": "@remotion/media-parser",
+  "version": "4.0.191",
+  "main": "dist/index.js",
+  "sideEffects": false,
+  "devDependencies": {
+    "@remotion/renderer": "4.0.191"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/remotion-dev/remotion/issues"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./node": "./dist/from-node.js",
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    ">=1.0": {
+      "node": [
+        "dist/from-node.d.ts"
+      ]
+    }
+  },
+  "author": "Jonny Burger <jonny@remotion.dev>",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "keywords": [
+    "remotion",
+    "ffmpeg",
+    "video",
+    "react",
+    "player"
+  ],
+  "homepage": "https://www.remotion.dev/docs/media-parser",
+  "description": "A pure JavaScript library for parsing video files",
+  "scripts": {
+    "formatting": "prettier src --check",
+    "lint": "eslint src --ext ts,tsx",
+    "test": "bun test src/test",
+    "watch": "tsc -w"
+  }
+}

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

@@ -0,0 +1,4 @@
+export interface BaseBox {
+	boxSize: number;
+	offset: number;
+}

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

@@ -0,0 +1,39 @@
+import type {BufferIterator} from '../../buffer-iterator';
+import type {BaseBox} from './base-type';
+
+export interface FtypBox extends BaseBox {
+	type: 'ftyp-box';
+	majorBrand: string;
+	minorVersion: number;
+	compatibleBrands: string[];
+}
+
+export const parseFtyp = ({
+	iterator,
+	size,
+	offset,
+}: {
+	iterator: BufferIterator;
+	size: number;
+	offset: number;
+}): FtypBox => {
+	const majorBrand = iterator.getByteString(4);
+	const minorVersion = iterator.getFourByteNumber();
+
+	const types = (size - iterator.counter.getOffset()) / 4;
+	const compatibleBrands: string[] = [];
+	for (let i = 0; i < types; i++) {
+		compatibleBrands.push(iterator.getByteString(4).trim());
+	}
+
+	const offsetAtEnd = iterator.counter.getOffset();
+
+	return {
+		type: 'ftyp-box',
+		majorBrand,
+		minorVersion,
+		compatibleBrands,
+		offset,
+		boxSize: offsetAtEnd - offset,
+	};
+};

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

@@ -0,0 +1,37 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {AnySegment} from '../../../parse-result';
+import type {BaseBox} from '../base-type';
+import {parseBoxes} from '../process-box';
+
+export interface MoovBox extends BaseBox {
+	type: 'moov-box';
+	children: AnySegment[];
+}
+
+export const parseMoov = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): MoovBox => {
+	const children = parseBoxes({
+		iterator,
+		maxBytes: size - (iterator.counter.getOffset() - offset),
+		allowIncompleteBoxes: false,
+		initialBoxes: [],
+	});
+
+	if (children.status === 'incomplete') {
+		throw new Error('Incomplete boxes are not allowed');
+	}
+
+	return {
+		offset,
+		boxSize: size,
+		type: 'moov-box',
+		children: children.segments,
+	};
+};

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

@@ -0,0 +1,107 @@
+import type {BufferIterator} from '../../buffer-iterator';
+import {getArrayBufferIterator} from '../../buffer-iterator';
+import type {BaseBox} from './base-type';
+import {toUnixTimestamp} from './to-date';
+
+export type ThreeDMatrix = [
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+];
+
+export interface MvhdBox extends BaseBox {
+	durationInUnits: number;
+	durationInSeconds: number;
+	creationTime: number | null;
+	modificationTime: number | null;
+	timeScale: number;
+	rate: number;
+	volume: number;
+	matrix: ThreeDMatrix;
+	nextTrackId: number;
+	type: 'mvhd-box';
+}
+
+export const parseMvhd = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): MvhdBox => {
+	const version = iterator.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported MVHD version ${version}`);
+	}
+
+	if (size !== 108) {
+		throw new Error(`Expected mvhd size of version 0 to be 108, got ${size}`);
+	}
+
+	// Flags, we discard them
+	iterator.discard(3);
+
+	const creationTime = iterator.getUint32();
+
+	const modificationTime = iterator.getUint32();
+
+	const timeScale = iterator.getUint32();
+
+	const durationInUnits = iterator.getUint32();
+	const durationInSeconds = durationInUnits / timeScale;
+
+	const rateArray = iterator.getSlice(4);
+	const rateView = getArrayBufferIterator(rateArray);
+	const rate =
+		rateView.getInt8() * 10 +
+		rateView.getInt8() +
+		rateView.getInt8() * 0.1 +
+		rateView.getInt8() * 0.01;
+
+	const volumeArray = iterator.getSlice(2);
+	const volumeView = getArrayBufferIterator(volumeArray);
+
+	const volume = volumeView.getInt8() + volumeView.getInt8() * 0.1;
+
+	// reserved 16bit
+	iterator.discard(2);
+
+	// reserved 32bit x2
+	iterator.discard(4);
+	iterator.discard(4);
+
+	// matrix
+	const matrix: number[] = [];
+	for (let i = 0; i < 9; i++) {
+		matrix.push(iterator.getUint32());
+	}
+
+	// pre-defined
+	iterator.discard(4 * 6);
+
+	// next track id
+	const nextTrackId = iterator.getUint32();
+
+	return {
+		creationTime: toUnixTimestamp(creationTime),
+		modificationTime: toUnixTimestamp(modificationTime),
+		timeScale,
+		durationInUnits,
+		durationInSeconds,
+		rate,
+		volume,
+		matrix: matrix as ThreeDMatrix,
+		nextTrackId,
+		type: 'mvhd-box',
+		boxSize: size,
+		offset,
+	};
+};

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

@@ -0,0 +1,236 @@
+import type {BufferIterator} from '../../buffer-iterator';
+import type {IsoBaseMediaBox, ParseResult} from '../../parse-result';
+import type {BoxAndNext} from '../../parse-video';
+import {parseFtyp} from './ftyp';
+import {parseMoov} from './moov/moov';
+import {parseMvhd} from './mvhd';
+import {parseMebx} from './stsd/mebx';
+import {parseStsd} from './stsd/stsd';
+import {parseStts} from './stts/stts';
+import {parseTkhd} from './tkhd';
+import {parseTrak} from './trak/trak';
+
+const getChildren = ({
+	boxType,
+	iterator,
+	bytesRemainingInBox,
+}: {
+	boxType: string;
+	iterator: BufferIterator;
+	bytesRemainingInBox: number;
+}) => {
+	const parseChildren =
+		boxType === 'mdia' ||
+		boxType === 'minf' ||
+		boxType === 'stbl' ||
+		boxType === 'dims' ||
+		boxType === 'stsb';
+
+	if (parseChildren) {
+		const parsed = parseBoxes({
+			iterator,
+			maxBytes: bytesRemainingInBox,
+			allowIncompleteBoxes: false,
+			initialBoxes: [],
+		});
+
+		if (parsed.status === 'incomplete') {
+			throw new Error('Incomplete boxes are not allowed');
+		}
+
+		return parsed.segments;
+	}
+
+	iterator.discard(bytesRemainingInBox);
+	return [];
+};
+
+const processBox = ({
+	iterator,
+	allowIncompleteBoxes,
+}: {
+	iterator: BufferIterator;
+	allowIncompleteBoxes: boolean;
+}): BoxAndNext => {
+	const fileOffset = iterator.counter.getOffset();
+	const bytesRemaining = iterator.bytesRemaining();
+
+	const boxSize = iterator.getFourByteNumber();
+	if (boxSize === 0) {
+		throw new Error(`Expected box size of not 0, got ${boxSize}`);
+	}
+
+	if (bytesRemaining < boxSize) {
+		iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
+		if (allowIncompleteBoxes) {
+			return {
+				type: 'incomplete',
+			};
+		}
+
+		throw new Error(
+			`Expected box size of ${bytesRemaining}, got ${boxSize}. Incomplete boxes are not allowed.`,
+		);
+	}
+
+	const boxType = iterator.getByteString(4);
+
+	if (boxType === 'ftyp') {
+		const box = parseFtyp({iterator, size: boxSize, offset: fileOffset});
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
+	if (boxType === 'mvhd') {
+		const box = parseMvhd({iterator, offset: fileOffset, size: boxSize});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
+	if (boxType === 'tkhd') {
+		const box = parseTkhd({iterator, offset: fileOffset, size: boxSize});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
+	if (boxType === 'stsd') {
+		const box = parseStsd({iterator, offset: fileOffset, size: boxSize});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
+	if (boxType === 'mebx') {
+		const box = parseMebx({iterator, offset: fileOffset, size: boxSize});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
+	if (boxType === 'moov') {
+		const box = parseMoov({iterator, offset: fileOffset, size: boxSize});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
+	if (boxType === 'trak') {
+		const box = parseTrak({
+			data: iterator,
+			size: boxSize,
+			offsetAtStart: fileOffset,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
+	if (boxType === 'stts') {
+		const box = parseStts({
+			data: iterator,
+			size: boxSize,
+			fileOffset,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
+	const bytesRemainingInBox =
+		boxSize - (iterator.counter.getOffset() - fileOffset);
+
+	const children = getChildren({
+		boxType,
+		iterator,
+		bytesRemainingInBox,
+	});
+
+	return {
+		type: 'complete',
+		box: {
+			type: 'regular-box',
+			boxType,
+			boxSize,
+			children,
+			offset: fileOffset,
+		},
+		size: boxSize,
+	};
+};
+
+export const parseBoxes = ({
+	iterator,
+	maxBytes,
+	allowIncompleteBoxes,
+	initialBoxes,
+}: {
+	iterator: BufferIterator;
+	maxBytes: number;
+	allowIncompleteBoxes: boolean;
+	initialBoxes: IsoBaseMediaBox[];
+}): ParseResult => {
+	const boxes: IsoBaseMediaBox[] = initialBoxes;
+	const initialOffset = iterator.counter.getOffset();
+
+	while (
+		iterator.bytesRemaining() > 0 &&
+		iterator.counter.getOffset() - initialOffset < maxBytes
+	) {
+		const result = processBox({
+			iterator,
+			allowIncompleteBoxes,
+		});
+		if (result.type === 'incomplete') {
+			if (Number.isFinite(maxBytes)) {
+				throw new Error('maxBytes must be Infinity for top-level boxes');
+			}
+
+			return {
+				status: 'incomplete',
+				segments: boxes,
+				continueParsing: () => {
+					return parseBoxes({
+						iterator,
+						maxBytes,
+						allowIncompleteBoxes,
+						initialBoxes: boxes,
+					});
+				},
+			};
+		}
+
+		boxes.push(result.box);
+		iterator.discardFirstBytes();
+	}
+
+	return {
+		status: 'done',
+		segments: boxes,
+	};
+};

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

@@ -0,0 +1,25 @@
+import {getArrayBufferIterator} from '../../../buffer-iterator';
+import type {BaseBox} from '../base-type';
+
+export interface KeysBox extends BaseBox {
+	type: 'keys-box';
+}
+
+export const parseKeys = (data: Uint8Array, offset: number): KeysBox => {
+	const iterator = getArrayBufferIterator(data);
+	const size = iterator.getUint32();
+	if (size !== data.byteLength) {
+		throw new Error(`Expected keys size of ${data.byteLength}, got ${size}`);
+	}
+
+	const atom = iterator.getAtom();
+	if (atom !== 'keys') {
+		throw new Error(`Expected keys type of keys, got ${atom}`);
+	}
+
+	return {
+		type: 'keys-box',
+		boxSize: data.byteLength,
+		offset,
+	};
+};

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

@@ -0,0 +1,46 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {AnySegment} from '../../../parse-result';
+import type {BaseBox} from '../base-type';
+import {parseBoxes} from '../process-box';
+
+export interface MebxBox extends BaseBox {
+	type: 'mebx-box';
+	dataReferenceIndex: number;
+	format: string;
+	children: AnySegment[];
+}
+
+export const parseMebx = ({
+	iterator,
+	offset,
+	size,
+}: {
+	iterator: BufferIterator;
+	offset: number;
+	size: number;
+}): MebxBox => {
+	// reserved, 6 bit
+	iterator.discard(6);
+
+	const dataReferenceIndex = iterator.getUint16();
+
+	const children = parseBoxes({
+		iterator,
+		maxBytes: iterator.counter.getOffset() - offset,
+		allowIncompleteBoxes: false,
+		initialBoxes: [],
+	});
+
+	if (children.status === 'incomplete') {
+		throw new Error('Incomplete boxes are not allowed');
+	}
+
+	return {
+		type: 'mebx-box',
+		boxSize: size,
+		offset,
+		dataReferenceIndex,
+		format: 'mebx',
+		children: children.segments,
+	};
+};