@remotion/media-parser 4.0.209 → 4.0.211

package/src/options.ts

@@ -1,118 +0,0 @@
-import type {} from './boxes/iso-base-media/mdat/mdat';
-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 './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';
-
-export type Options<
-	EnableDimensions extends boolean,
-	EnableDuration extends boolean,
-	EnableBoxes extends boolean,
-	EnableFps extends boolean,
-	EnableVideoCodec extends boolean,
-	EnableAudioCodec extends boolean,
-	EnableTracks extends boolean,
-	EnableRotation extends boolean,
-	EnableUnrotatedDimensions extends boolean,
-	EnableInternalStats extends boolean,
-> = {
-	dimensions?: EnableDimensions;
-	durationInSeconds?: EnableDuration;
-	boxes?: EnableBoxes;
-	fps?: EnableFps;
-	videoCodec?: EnableVideoCodec;
-	audioCodec?: EnableAudioCodec;
-	tracks?: EnableTracks;
-	rotation?: EnableRotation;
-	unrotatedDimensions?: EnableUnrotatedDimensions;
-	internalStats?: EnableInternalStats;
-};
-
-export type Metadata<
-	EnableDimensions extends boolean,
-	EnableDuration extends boolean,
-	EnableBoxes extends boolean,
-	EnableFps extends boolean,
-	EnableVideoCodec extends boolean,
-	EnableAudioCodec extends boolean,
-	EnableTracks extends boolean,
-	EnableRotation extends boolean,
-	EnableUnrotatedDimensions extends boolean,
-	EnableInternalStats extends boolean,
-> = (EnableDimensions extends true ? {dimensions: Dimensions} : {}) &
-	(EnableDuration extends true ? {durationInSeconds: number | null} : {}) &
-	(EnableBoxes extends true ? {boxes: AnySegment[]} : {}) &
-	(EnableFps extends true ? {fps: number | null} : {}) &
-	(EnableVideoCodec extends true ? {videoCodec: KnownVideoCodecs | null} : {}) &
-	(EnableAudioCodec extends true ? {audioCodec: KnownAudioCodecs | null} : {}) &
-	(EnableTracks extends true
-		? {videoTracks: VideoTrack[]; audioTracks: AudioTrack[]}
-		: {}) &
-	(EnableRotation extends true ? {rotation: number | null} : {}) &
-	(EnableUnrotatedDimensions extends true
-		? {unrotatedDimensions: Dimensions}
-		: {}) &
-	(EnableInternalStats extends true ? {internalStats: InternalStats} : {});
-
-export type ParseMedia = <
-	EnableDimensions extends boolean,
-	EnableDuration extends boolean,
-	EnableBoxes extends boolean,
-	EnableFps extends boolean,
-	EnableVideoCodec extends boolean,
-	EnableAudioCodec extends boolean,
-	EnableTracks extends boolean,
-	EnableRotation extends boolean,
-	EnableUnrotatedDimensions extends boolean,
-	EnableInternalStats extends boolean,
->(options: {
-	src: string | File;
-	fields?: Options<
-		EnableDimensions,
-		EnableDuration,
-		EnableBoxes,
-		EnableFps,
-		EnableVideoCodec,
-		EnableAudioCodec,
-		EnableTracks,
-		EnableRotation,
-		EnableUnrotatedDimensions,
-		EnableInternalStats
-	>;
-	reader?: ReaderInterface;
-	onAudioTrack?: OnAudioTrack;
-	onVideoTrack?: OnVideoTrack;
-	signal?: AbortSignal;
-}) => Promise<
-	Metadata<
-		EnableDimensions,
-		EnableDuration,
-		EnableBoxes,
-		EnableFps,
-		EnableVideoCodec,
-		EnableAudioCodec,
-		EnableTracks,
-		EnableRotation,
-		EnableUnrotatedDimensions,
-		EnableInternalStats
-	>
->;

package/src/parse-media.ts

@@ -1,183 +0,0 @@
-/* eslint-disable max-depth */
-import type {BufferIterator} from './buffer-iterator';
-import {getArrayBufferIterator} from './buffer-iterator';
-import {getAudioCodec} from './get-audio-codec';
-import {getDimensions} from './get-dimensions';
-import {getDuration} from './get-duration';
-import {getFps} from './get-fps';
-import {getTracks} from './get-tracks';
-import {getVideoCodec} from './get-video-codec';
-import {hasAllInfo} from './has-all-info';
-import type {Metadata, ParseMedia} from './options';
-import type {ParseResult} from './parse-result';
-import {parseVideo} from './parse-video';
-import type {ParserContext} from './parser-context';
-import {makeParserState} from './parser-state';
-import {fetchReader} from './readers/from-fetch';
-
-export const parseMedia: ParseMedia = async ({
-	src,
-	fields,
-	reader: readerInterface = fetchReader,
-	onAudioTrack,
-	onVideoTrack,
-	signal,
-}) => {
-	const state = makeParserState({
-		hasAudioCallbacks: onAudioTrack !== null,
-		hasVideoCallbacks: onVideoTrack !== null,
-		signal,
-	});
-	const {reader, contentLength} = await readerInterface.read(src, null, signal);
-	let currentReader = reader;
-
-	const returnValue = {} as Metadata<
-		true,
-		true,
-		true,
-		true,
-		true,
-		true,
-		true,
-		true,
-		true,
-		true
-	>;
-
-	let iterator: BufferIterator | null = null;
-	let parseResult: ParseResult | null = null;
-
-	const options: ParserContext = {
-		canSkipVideoData: !(onAudioTrack || onVideoTrack),
-		onAudioTrack: onAudioTrack ?? null,
-		onVideoTrack: onVideoTrack ?? null,
-		parserState: state,
-		nullifySamples: !(
-			typeof process !== 'undefined' &&
-			typeof process.env !== 'undefined' &&
-			process.env.KEEP_SAMPLES === 'true'
-		),
-	};
-
-	while (parseResult === null || parseResult.status === 'incomplete') {
-		if (signal?.aborted) {
-			throw new Error('Aborted');
-		}
-
-		const result = await currentReader.read();
-
-		if (iterator) {
-			if (!result.done) {
-				iterator.addData(result.value);
-			}
-		} else {
-			if (result.done) {
-				throw new Error('Unexpectedly reached EOF');
-			}
-
-			iterator = getArrayBufferIterator(
-				result.value,
-				contentLength ?? 1_000_000_000,
-			);
-		}
-
-		if (parseResult && parseResult.status === 'incomplete') {
-			parseResult = await parseResult.continueParsing();
-		} else {
-			parseResult = await parseVideo({
-				iterator,
-				options,
-			});
-		}
-
-		// TODO Better: Check if no active listeners are registered
-		// Also maybe check for canSkipVideoData
-		if (
-			hasAllInfo(fields ?? {}, parseResult, state) &&
-			!onVideoTrack &&
-			!onAudioTrack
-		) {
-			if (!currentReader.closed) {
-				currentReader.cancel(new Error('has all information'));
-			}
-
-			break;
-		}
-
-		if (
-			parseResult &&
-			parseResult.status === 'incomplete' &&
-			parseResult.skipTo !== null
-		) {
-			if (!currentReader.closed) {
-				currentReader.cancel(new Error('skipped ahead'));
-			}
-
-			const {reader: newReader} = await readerInterface.read(
-				src,
-				parseResult.skipTo,
-				signal,
-			);
-			currentReader = newReader;
-			iterator.skipTo(parseResult.skipTo);
-		}
-	}
-
-	if (!parseResult) {
-		throw new Error('Could not parse video');
-	}
-
-	if (fields?.dimensions) {
-		const dimensions = getDimensions(parseResult.segments, state);
-		returnValue.dimensions = {
-			width: dimensions.width,
-			height: dimensions.height,
-		};
-	}
-
-	if (fields?.unrotatedDimensions) {
-		const dimensions = getDimensions(parseResult.segments, state);
-		returnValue.unrotatedDimensions = {
-			width: dimensions.unrotatedWidth,
-			height: dimensions.unrotatedHeight,
-		};
-	}
-
-	if (fields?.rotation) {
-		const dimensions = getDimensions(parseResult.segments, state);
-		returnValue.rotation = dimensions.rotation;
-	}
-
-	if (fields?.durationInSeconds) {
-		returnValue.durationInSeconds = getDuration(parseResult.segments, state);
-	}
-
-	if (fields?.fps) {
-		returnValue.fps = getFps(parseResult.segments);
-	}
-
-	if (fields?.videoCodec) {
-		returnValue.videoCodec = getVideoCodec(parseResult.segments);
-	}
-
-	if (fields?.audioCodec) {
-		returnValue.audioCodec = getAudioCodec(parseResult.segments);
-	}
-
-	if (fields?.tracks) {
-		const {audioTracks, videoTracks} = getTracks(parseResult.segments, state);
-		returnValue.audioTracks = audioTracks;
-		returnValue.videoTracks = videoTracks;
-	}
-
-	if (fields?.boxes) {
-		returnValue.boxes = parseResult.segments;
-	}
-
-	if (fields?.internalStats) {
-		returnValue.internalStats = state.getInternalStats();
-	}
-
-	iterator?.destroy();
-	return returnValue;
-};

package/src/parse-result.ts

@@ -1,79 +0,0 @@
-import type {BaseBox} from './boxes/iso-base-media/base-type';
-import type {EsdsBox} from './boxes/iso-base-media/esds/esds';
-import type {FtypBox} from './boxes/iso-base-media/ftyp';
-import type {MdatBox} from './boxes/iso-base-media/mdat/mdat';
-import type {MdhdBox} from './boxes/iso-base-media/mdhd';
-import type {MoovBox} from './boxes/iso-base-media/moov/moov';
-import type {MvhdBox} from './boxes/iso-base-media/mvhd';
-import type {Av1CBox} from './boxes/iso-base-media/stsd/av1c';
-import type {AvccBox} from './boxes/iso-base-media/stsd/avcc';
-import type {ColorParameterBox} from './boxes/iso-base-media/stsd/colr';
-import type {CttsBox} from './boxes/iso-base-media/stsd/ctts';
-import type {HvccBox} from './boxes/iso-base-media/stsd/hvcc';
-import type {KeysBox} from './boxes/iso-base-media/stsd/keys';
-import type {MebxBox} from './boxes/iso-base-media/stsd/mebx';
-import type {PaspBox} from './boxes/iso-base-media/stsd/pasp';
-import type {StcoBox} from './boxes/iso-base-media/stsd/stco';
-import type {StscBox} from './boxes/iso-base-media/stsd/stsc';
-import type {StsdBox} from './boxes/iso-base-media/stsd/stsd';
-import type {StssBox} from './boxes/iso-base-media/stsd/stss';
-import type {StszBox} from './boxes/iso-base-media/stsd/stsz';
-import type {SttsBox} from './boxes/iso-base-media/stsd/stts';
-import type {TfdtBox} from './boxes/iso-base-media/tfdt';
-import type {TfhdBox} from './boxes/iso-base-media/tfhd';
-import type {TkhdBox} from './boxes/iso-base-media/tkhd';
-import type {TrakBox} from './boxes/iso-base-media/trak/trak';
-import type {TrunBox} from './boxes/iso-base-media/trun';
-import type {VoidBox} from './boxes/iso-base-media/void-box';
-import type {MatroskaSegment} from './boxes/webm/segments';
-
-export 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
-	| MdhdBox
-	| EsdsBox
-	| MdatBox
-	| StszBox
-	| StcoBox
-	| StscBox
-	| AvccBox
-	| HvccBox
-	| VoidBox
-	| StssBox
-	| PaspBox
-	| CttsBox
-	| Av1CBox
-	| TrunBox
-	| ColorParameterBox
-	| TfdtBox
-	| TfhdBox;
-
-export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
-
-export type ParseResult =
-	| {
-			status: 'done';
-			segments: AnySegment[];
-	  }
-	| {
-			status: 'incomplete';
-			segments: AnySegment[];
-			skipTo: number | null;
-			continueParsing: () => Promise<ParseResult>;
-	  };

package/src/parse-video.ts

@@ -1,83 +0,0 @@
-import {parseBoxes} from './boxes/iso-base-media/process-box';
-import {parseWebm} from './boxes/webm/parse-webm-header';
-import type {BufferIterator} from './buffer-iterator';
-import type {IsoBaseMediaBox, ParseResult} from './parse-result';
-import type {ParserContext} from './parser-context';
-
-export type PartialMdatBox = {
-	type: 'partial-mdat-box';
-	boxSize: number;
-	fileOffset: number;
-};
-
-export type BoxAndNext =
-	| {
-			type: 'complete';
-			box: IsoBaseMediaBox;
-			size: number;
-			skipTo: number | null;
-	  }
-	| {
-			type: 'incomplete';
-	  }
-	| PartialMdatBox;
-
-export const parseVideo = ({
-	iterator,
-	options,
-}: {
-	iterator: BufferIterator;
-	options: ParserContext;
-}): Promise<ParseResult> => {
-	if (iterator.bytesRemaining() === 0) {
-		return Promise.resolve({
-			status: 'incomplete',
-			segments: [],
-			continueParsing: () => {
-				return parseVideo({
-					iterator,
-					options,
-				});
-			},
-			skipTo: null,
-		});
-	}
-
-	if (iterator.isRiff()) {
-		throw new Error('AVI files are not yet supported');
-		/*
-		iterator.discard(4);
-		return parseBoxes({
-			iterator,
-			maxBytes: Infinity,
-			allowIncompleteBoxes: true,
-			initialBoxes: [],
-			options,
-			continueMdat: false,
-			littleEndian: true,
-		});
-		*/
-	}
-
-	if (iterator.isIsoBaseMedia()) {
-		return parseBoxes({
-			iterator,
-			maxBytes: Infinity,
-			allowIncompleteBoxes: true,
-			initialBoxes: [],
-			options,
-			continueMdat: false,
-			littleEndian: false,
-		});
-	}
-
-	if (iterator.isWebm()) {
-		return Promise.resolve(parseWebm(iterator, options));
-	}
-
-	if (iterator.isMp3()) {
-		return Promise.reject(new Error('MP3 files are not yet supported'));
-	}
-
-	return Promise.reject(new Error('Unknown video format'));
-};

package/src/parser-context.ts

@@ -1,10 +0,0 @@
-import type {ParserState} from './parser-state';
-import type {OnAudioTrack, OnVideoTrack} from './webcodec-sample-types';
-
-export type ParserContext = {
-	onAudioTrack: OnAudioTrack | null;
-	onVideoTrack: OnVideoTrack | null;
-	canSkipVideoData: boolean;
-	parserState: ParserState;
-	nullifySamples: boolean;
-};

package/src/parser-state.ts

@@ -1,178 +0,0 @@
-import type {OnTrackEntrySegment} from './boxes/webm/segments';
-import type {TrackInfo} from './boxes/webm/segments/track-entry';
-import {getTrackCodec, getTrackTimestampScale} from './boxes/webm/traversal';
-import {getTrackId} from './traversal';
-import type {
-	AudioSample,
-	OnAudioSample,
-	OnVideoSample,
-	VideoSample,
-} from './webcodec-sample-types';
-
-export type InternalStats = {};
-
-export const makeParserState = ({
-	hasAudioCallbacks,
-	hasVideoCallbacks,
-	signal,
-}: {
-	hasAudioCallbacks: boolean;
-	hasVideoCallbacks: boolean;
-	signal: AbortSignal | undefined;
-}) => {
-	const trackEntries: Record<number, TrackInfo> = {};
-
-	const onTrackEntrySegment: OnTrackEntrySegment = (trackEntry) => {
-		const trackId = getTrackId(trackEntry);
-		if (!trackId) {
-			throw new Error('Expected track id');
-		}
-
-		if (trackEntries[trackId]) {
-			return;
-		}
-
-		const codec = getTrackCodec(trackEntry);
-		if (!codec) {
-			throw new Error('Expected codec');
-		}
-
-		const trackTimescale = getTrackTimestampScale(trackEntry);
-
-		trackEntries[trackId] = {
-			codec: codec.value,
-			trackTimescale: trackTimescale?.value ?? null,
-		};
-	};
-
-	const videoSampleCallbacks: Record<number, OnVideoSample> = {};
-	const audioSampleCallbacks: Record<number, OnAudioSample> = {};
-
-	const queuedAudioSamples: Record<number, AudioSample[]> = {};
-	const queuedVideoSamples: Record<number, VideoSample[]> = {};
-
-	const declinedTrackNumbers: number[] = [];
-
-	let timescale: number | null = 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) {
-			return 1_000_000;
-		}
-
-		return timescale;
-	};
-
-	const setTimescale = (newTimescale: number) => {
-		timescale = newTimescale;
-	};
-
-	const timestampMap = new Map<number, number>();
-
-	const setTimestampOffset = (byteOffset: number, timestamp: number) => {
-		timestampMap.set(byteOffset, timestamp);
-	};
-
-	const getTimestampOffsetForByteOffset = (byteOffset: number) => {
-		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: number) => trackEntries[id],
-		registerVideoSampleCallback: async (
-			id: number,
-			callback: OnVideoSample | null,
-		) => {
-			if (callback === null) {
-				delete videoSampleCallbacks[id];
-				declinedTrackNumbers.push(id);
-				return;
-			}
-
-			videoSampleCallbacks[id] = callback;
-
-			for (const queued of queuedVideoSamples[id] ?? []) {
-				await callback(queued);
-			}
-
-			queuedVideoSamples[id] = [];
-		},
-		setTimestampOffset,
-		getTimestampOffsetForByteOffset,
-		registerAudioSampleCallback: async (
-			id: number,
-			callback: OnAudioSample | null,
-		) => {
-			if (callback === null) {
-				delete audioSampleCallbacks[id];
-				declinedTrackNumbers.push(id);
-				return;
-			}
-
-			audioSampleCallbacks[id] = callback;
-			for (const queued of queuedAudioSamples[id] ?? []) {
-				await callback(queued);
-			}
-
-			queuedAudioSamples[id] = [];
-		},
-		onAudioSample: async (trackId: number, audioSample: AudioSample) => {
-			if (signal?.aborted) {
-				throw new Error('Aborted');
-			}
-
-			const callback = audioSampleCallbacks[trackId];
-			if (callback) {
-				await callback(audioSample);
-			} else {
-				if (declinedTrackNumbers.includes(trackId)) {
-					return;
-				}
-
-				if (!hasAudioCallbacks) {
-					throw new Error('No audio callbacks registered');
-				}
-			}
-		},
-		onVideoSample: async (trackId: number, videoSample: VideoSample) => {
-			if (signal?.aborted) {
-				throw new Error('Aborted');
-			}
-
-			const callback = videoSampleCallbacks[trackId];
-			if (callback) {
-				await callback(videoSample);
-			} else {
-				if (declinedTrackNumbers.includes(trackId)) {
-					return;
-				}
-
-				if (!hasVideoCallbacks) {
-					throw new Error('No video callbacks registered');
-				}
-			}
-		},
-		getInternalStats: () => ({}),
-		getTimescale,
-		setTimescale,
-	};
-};
-
-export type ParserState = ReturnType<typeof makeParserState>;