@osmo.inc/cli 0.1.15

package/third-party/npm/mediabunny@1.52.2/source/src/custom-coder.ts

@@ -0,0 +1,212 @@
+/*!
+ * Copyright (c) 2026-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import { AudioCodec, VideoCodec } from './codec';
+import { canDecodeAudioMemo, canDecodeVideoMemo } from './decode';
+import { canEncodeAudioMemo, canEncodeVideoMemo } from './encode';
+import { Logging } from './logging';
+import { MaybePromise } from './misc';
+import { EncodedPacket } from './packet';
+import { AudioSample, VideoSample } from './sample';
+
+/**
+ * Base class for custom video decoders. To add your own custom video decoder, extend this class, implement the
+ * abstract methods and static `supports` method, and register the decoder using {@link registerDecoder}.
+ * @group Custom coders
+ * @public
+ */
+export abstract class CustomVideoDecoder {
+	/** The input video's codec. */
+	readonly codec!: VideoCodec;
+	/** The input video's decoder config. */
+	readonly config!: VideoDecoderConfig;
+	/** The callback to call when a decoded VideoSample is available. */
+	readonly onSample!: (sample: VideoSample) => unknown;
+	/** The callback to call to surface out-of-band errors that can't be surfaced through the main methods. */
+	readonly onError!: (error: unknown) => undefined;
+
+	/** Returns true if and only if the decoder can decode the given codec configuration. */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	static supports(codec: VideoCodec, config: VideoDecoderConfig): boolean {
+		return false;
+	}
+
+	/** Called after decoder creation; can be used for custom initialization logic. */
+	abstract init(): MaybePromise<void>;
+	/** Decodes the provided encoded packet. */
+	abstract decode(packet: EncodedPacket): MaybePromise<void>;
+	/** Decodes all remaining packets and then resolves. */
+	abstract flush(): MaybePromise<void>;
+	/** Called when the decoder is no longer needed and its resources can be freed. */
+	abstract close(): MaybePromise<void>;
+}
+
+/**
+ * Base class for custom audio decoders. To add your own custom audio decoder, extend this class, implement the
+ * abstract methods and static `supports` method, and register the decoder using {@link registerDecoder}.
+ * @group Custom coders
+ * @public
+ */
+export abstract class CustomAudioDecoder {
+	/** The input audio's codec. */
+	readonly codec!: AudioCodec;
+	/** The input audio's decoder config. */
+	readonly config!: AudioDecoderConfig;
+	/** The callback to call when a decoded AudioSample is available. */
+	readonly onSample!: (sample: AudioSample) => unknown;
+	/** The callback to call to surface out-of-band errors that can't be surfaced through the main methods. */
+	readonly onError!: (error: unknown) => undefined;
+
+	/** Returns true if and only if the decoder can decode the given codec configuration. */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	static supports(codec: AudioCodec, config: AudioDecoderConfig): boolean {
+		return false;
+	}
+
+	/** Called after decoder creation; can be used for custom initialization logic. */
+	abstract init(): MaybePromise<void>;
+	/** Decodes the provided encoded packet. */
+	abstract decode(packet: EncodedPacket): MaybePromise<void>;
+	/** Decodes all remaining packets and then resolves. */
+	abstract flush(): MaybePromise<void>;
+	/** Called when the decoder is no longer needed and its resources can be freed. */
+	abstract close(): MaybePromise<void>;
+}
+
+/**
+ * Base class for custom video encoders. To add your own custom video encoder, extend this class, implement the
+ * abstract methods and static `supports` method, and register the encoder using {@link registerEncoder}.
+ * @group Custom coders
+ * @public
+ */
+export abstract class CustomVideoEncoder {
+	/** The codec with which to encode the video. */
+	readonly codec!: VideoCodec;
+	/** Config for the encoder. */
+	readonly config!: VideoEncoderConfig;
+	/** The callback to call when an EncodedPacket is available. */
+	readonly onPacket!: (packet: EncodedPacket, meta?: EncodedVideoChunkMetadata) => unknown;
+	/** The callback to call to surface out-of-band errors that can't be surfaced through the main methods. */
+	readonly onError!: (error: unknown) => undefined;
+
+	/** Returns true if and only if the encoder can encode the given codec configuration. */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	static supports(codec: VideoCodec, config: VideoEncoderConfig): boolean {
+		return false;
+	}
+
+	/** Called after encoder creation; can be used for custom initialization logic. */
+	abstract init(): MaybePromise<void>;
+	/** Encodes the provided video sample. */
+	abstract encode(videoSample: VideoSample, options: VideoEncoderEncodeOptions): MaybePromise<void>;
+	/** Encodes all remaining video samples and then resolves. */
+	abstract flush(): MaybePromise<void>;
+	/** Called when the encoder is no longer needed and its resources can be freed. */
+	abstract close(): MaybePromise<void>;
+}
+
+/**
+ * Base class for custom audio encoders. To add your own custom audio encoder, extend this class, implement the
+ * abstract methods and static `supports` method, and register the encoder using {@link registerEncoder}.
+ * @group Custom coders
+ * @public
+ */
+export abstract class CustomAudioEncoder {
+	/** The codec with which to encode the audio. */
+	readonly codec!: AudioCodec;
+	/** Config for the encoder. */
+	readonly config!: AudioEncoderConfig;
+	/** The callback to call when an EncodedPacket is available. */
+	readonly onPacket!: (packet: EncodedPacket, meta?: EncodedAudioChunkMetadata) => unknown;
+	/** The callback to call to surface out-of-band errors that can't be surfaced through the main methods. */
+	readonly onError!: (error: unknown) => undefined;
+
+	/** Returns true if and only if the encoder can encode the given codec configuration. */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	static supports(codec: AudioCodec, config: AudioEncoderConfig): boolean {
+		return false;
+	}
+
+	/** Called after encoder creation; can be used for custom initialization logic. */
+	abstract init(): MaybePromise<void>;
+	/** Encodes the provided audio sample. */
+	abstract encode(audioSample: AudioSample): MaybePromise<void>;
+	/** Encodes all remaining audio samples and then resolves. */
+	abstract flush(): MaybePromise<void>;
+	/** Called when the encoder is no longer needed and its resources can be freed. */
+	abstract close(): MaybePromise<void>;
+}
+
+export const customVideoDecoders: typeof CustomVideoDecoder[] = [];
+export const customAudioDecoders: typeof CustomAudioDecoder[] = [];
+export const customVideoEncoders: typeof CustomVideoEncoder[] = [];
+export const customAudioEncoders: typeof CustomAudioEncoder[] = [];
+
+/**
+ * Registers a custom video or audio decoder. Registered decoders will automatically be used for decoding whenever
+ * possible.
+ * @group Custom coders
+ * @public
+ */
+export const registerDecoder = (decoder: typeof CustomVideoDecoder | typeof CustomAudioDecoder) => {
+	if (decoder.prototype instanceof CustomVideoDecoder) {
+		const casted = decoder as typeof CustomVideoDecoder;
+
+		if (customVideoDecoders.includes(casted)) {
+			Logging._warn('Video decoder already registered.');
+			return;
+		}
+
+		customVideoDecoders.push(casted);
+		canDecodeVideoMemo.clear();
+	} else if (decoder.prototype instanceof CustomAudioDecoder) {
+		const casted = decoder as typeof CustomAudioDecoder;
+
+		if (customAudioDecoders.includes(casted)) {
+			Logging._warn('Audio decoder already registered.');
+			return;
+		}
+
+		customAudioDecoders.push(casted);
+		canDecodeAudioMemo.clear();
+	} else {
+		throw new TypeError('Decoder must be a CustomVideoDecoder or CustomAudioDecoder.');
+	}
+};
+
+/**
+ * Registers a custom video or audio encoder. Registered encoders will automatically be used for encoding whenever
+ * possible.
+ * @group Custom coders
+ * @public
+ */
+export const registerEncoder = (encoder: typeof CustomVideoEncoder | typeof CustomAudioEncoder) => {
+	if (encoder.prototype instanceof CustomVideoEncoder) {
+		const casted = encoder as typeof CustomVideoEncoder;
+
+		if (customVideoEncoders.includes(casted)) {
+			Logging._warn('Video encoder already registered.');
+			return;
+		}
+
+		customVideoEncoders.push(casted);
+		canEncodeVideoMemo.clear();
+	} else if (encoder.prototype instanceof CustomAudioEncoder) {
+		const casted = encoder as typeof CustomAudioEncoder;
+
+		if (customAudioEncoders.includes(casted)) {
+			Logging._warn('Audio encoder already registered.');
+			return;
+		}
+
+		customAudioEncoders.push(casted);
+		canEncodeAudioMemo.clear();
+	} else {
+		throw new TypeError('Encoder must be a CustomVideoEncoder or CustomAudioEncoder.');
+	}
+};

package/third-party/npm/mediabunny@1.52.2/source/src/decode.ts

@@ -0,0 +1,263 @@
+/*!
+ * Copyright (c) 2026-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import {
+	AUDIO_CODECS,
+	AudioCodec,
+	buildAudioCodecString,
+	buildVideoCodecString,
+	guessDescriptionForAudio,
+	guessDescriptionForVideo,
+	inferCodecFromCodecString,
+	MediaCodec,
+	PCM_AUDIO_CODECS,
+	VIDEO_CODECS,
+	VideoCodec,
+} from './codec';
+import { customAudioDecoders, customVideoDecoders } from './custom-coder';
+import { isAllowSharedBufferSource, SetOptional } from './misc';
+
+export const canDecodeVideoMemo = new Map<string, Promise<boolean>>();
+export const canDecodeAudioMemo = new Map<string, Promise<boolean>>();
+
+const validateVideoDecodingConfig = (codec: VideoCodec, options: SetOptional<VideoDecoderConfig, 'codec'>) => {
+	if (!options || typeof options !== 'object') {
+		throw new TypeError('options must be an object.');
+	}
+	if (options.codec !== undefined && typeof options.codec !== 'string') {
+		throw new TypeError('options.codec, when provided, must be a string.');
+	}
+	if (options.codec !== undefined && inferCodecFromCodecString(options.codec) !== codec) {
+		throw new TypeError(`options.codec, when provided, must match the specified codec (${codec}).`);
+	}
+	if (
+		options.codedWidth !== undefined
+		&& (!Number.isInteger(options.codedWidth) || options.codedWidth <= 0)
+	) {
+		throw new TypeError('options.codedWidth, when provided, must be a positive integer.');
+	}
+	if (
+		options.codedHeight !== undefined
+		&& (!Number.isInteger(options.codedHeight) || options.codedHeight <= 0)
+	) {
+		throw new TypeError('options.codedHeight, when provided, must be a positive integer.');
+	}
+	if (
+		options.displayAspectWidth !== undefined
+		&& (!Number.isInteger(options.displayAspectWidth) || options.displayAspectWidth <= 0)
+	) {
+		throw new TypeError('options.displayAspectWidth, when provided, must be a positive integer.');
+	}
+	if (
+		options.displayAspectHeight !== undefined
+		&& (!Number.isInteger(options.displayAspectHeight) || options.displayAspectHeight <= 0)
+	) {
+		throw new TypeError('options.displayAspectHeight, when provided, must be a positive integer.');
+	}
+	if (options.description !== undefined && !isAllowSharedBufferSource(options.description)) {
+		throw new TypeError('options.description, when provided, must be a buffer source.');
+	}
+	if (
+		options.hardwareAcceleration !== undefined
+		&& !['no-preference', 'prefer-hardware', 'prefer-software'].includes(options.hardwareAcceleration)
+	) {
+		throw new TypeError(
+			'options.hardwareAcceleration, when provided, must be \'no-preference\', \'prefer-hardware\' or'
+			+ ' \'prefer-software\'.',
+		);
+	}
+	if (options.optimizeForLatency !== undefined && typeof options.optimizeForLatency !== 'boolean') {
+		throw new TypeError('options.optimizeForLatency, when provided, must be a boolean.');
+	}
+};
+
+const validateAudioDecodingConfig = (
+	codec: AudioCodec,
+	options: SetOptional<AudioDecoderConfig, 'codec' | 'numberOfChannels' | 'sampleRate'>,
+) => {
+	if (!options || typeof options !== 'object') {
+		throw new TypeError('options must be an object.');
+	}
+	if (options.codec !== undefined && typeof options.codec !== 'string') {
+		throw new TypeError('options.codec, when provided, must be a string.');
+	}
+	if (options.codec !== undefined && inferCodecFromCodecString(options.codec) !== codec) {
+		throw new TypeError(`options.codec, when provided, must match the specified codec (${codec}).`);
+	}
+	if (
+		options.numberOfChannels !== undefined
+		&& (!Number.isInteger(options.numberOfChannels) || options.numberOfChannels <= 0)
+	) {
+		throw new TypeError('options.numberOfChannels, when provided, must be a positive integer.');
+	}
+	if (
+		options.sampleRate !== undefined
+		&& (!Number.isInteger(options.sampleRate) || options.sampleRate <= 0)
+	) {
+		throw new TypeError('options.sampleRate, when provided, must be a positive integer.');
+	}
+	if (options.description !== undefined && !isAllowSharedBufferSource(options.description)) {
+		throw new TypeError('options.description, when provided, must be a buffer source.');
+	}
+};
+
+/**
+ * Checks if the browser is able to decode the given codec.
+ * @group Decoding
+ * @public
+ */
+export const canDecode = (codec: MediaCodec) => {
+	if ((VIDEO_CODECS as readonly string[]).includes(codec)) {
+		return canDecodeVideo(codec as VideoCodec);
+	} else if ((AUDIO_CODECS as readonly string[]).includes(codec)) {
+		return canDecodeAudio(codec as AudioCodec);
+	}
+
+	return false;
+};
+
+/**
+ * Checks if the browser is able to decode the given video codec with the given parameters.
+ * @group Decoding
+ * @public
+ */
+export const canDecodeVideo = async (
+	codec: VideoCodec,
+	options: SetOptional<VideoDecoderConfig, 'codec'> = {},
+) => {
+	if (!VIDEO_CODECS.includes(codec)) {
+		return false;
+	}
+
+	validateVideoDecodingConfig(codec, options);
+
+	const resolvedOptions: VideoDecoderConfig = {
+		...options,
+		codedWidth: options.codedWidth ?? 1280,
+		codedHeight: options.codedHeight ?? 720,
+		codec: options.codec ?? buildVideoCodecString(codec, 1280, 720, 1e6, false),
+	};
+	resolvedOptions.description ??= guessDescriptionForVideo(resolvedOptions);
+
+	const key = JSON.stringify(resolvedOptions);
+	const memoized = canDecodeVideoMemo.get(key);
+	if (memoized) {
+		return memoized;
+	}
+
+	const promise = (async () => {
+		if (customVideoDecoders.some(x => x.supports(codec, resolvedOptions))) {
+			return true;
+		}
+		if (typeof VideoDecoder === 'undefined') {
+			return false;
+		}
+
+		const support = await VideoDecoder.isConfigSupported(resolvedOptions);
+		return support.supported === true;
+	})();
+	canDecodeVideoMemo.set(key, promise);
+
+	return promise;
+};
+
+/**
+ * Checks if the browser is able to decode the given audio codec with the given parameters.
+ * @group Decoding
+ * @public
+ */
+export const canDecodeAudio = async (
+	codec: AudioCodec,
+	options: SetOptional<AudioDecoderConfig, 'codec' | 'numberOfChannels' | 'sampleRate'> = {},
+) => {
+	if (!AUDIO_CODECS.includes(codec)) {
+		return false;
+	}
+
+	validateAudioDecodingConfig(codec, options);
+
+	const resolvedOptions: AudioDecoderConfig = {
+		...options,
+		numberOfChannels: options.numberOfChannels ?? 2,
+		sampleRate: options.sampleRate ?? 48000,
+		codec: options.codec ?? buildAudioCodecString(codec, 2, 48000),
+	};
+
+	if (resolvedOptions.description === undefined) {
+		const generatedDescription = guessDescriptionForAudio(resolvedOptions);
+		if (generatedDescription === false) {
+			return false;
+		}
+
+		resolvedOptions.description = generatedDescription;
+	}
+
+	const key = JSON.stringify(resolvedOptions);
+	const memoized = canDecodeAudioMemo.get(key);
+	if (memoized) {
+		return memoized;
+	}
+
+	const promise = (async () => {
+		if (customAudioDecoders.some(x => x.supports(codec, resolvedOptions))) {
+			return true;
+		}
+		if ((PCM_AUDIO_CODECS as readonly string[]).includes(codec)) {
+			return true;
+		}
+		if (typeof AudioDecoder === 'undefined') {
+			return false;
+		}
+
+		const support = await AudioDecoder.isConfigSupported(resolvedOptions);
+		return support.supported === true;
+	})();
+	canDecodeAudioMemo.set(key, promise);
+
+	return promise;
+};
+
+/**
+ * Returns the list of all media codecs that can be decoded by the browser.
+ * @group Decoding
+ * @public
+ */
+export const getDecodableCodecs = async (): Promise<MediaCodec[]> => {
+	const [videoCodecs, audioCodecs] = await Promise.all([
+		getDecodableVideoCodecs(),
+		getDecodableAudioCodecs(),
+	]);
+
+	return [...videoCodecs, ...audioCodecs];
+};
+
+/**
+ * Returns the list of all video codecs that can be decoded by the browser.
+ * @group Decoding
+ * @public
+ */
+export const getDecodableVideoCodecs = async (
+	checkedCodecs: VideoCodec[] = VIDEO_CODECS as unknown as VideoCodec[],
+	options?: SetOptional<VideoDecoderConfig, 'codec'>,
+): Promise<VideoCodec[]> => {
+	const bools = await Promise.all(checkedCodecs.map(codec => canDecodeVideo(codec, options)));
+	return checkedCodecs.filter((_, i) => bools[i]);
+};
+
+/**
+ * Returns the list of all audio codecs that can be decoded by the browser.
+ * @group Decoding
+ * @public
+ */
+export const getDecodableAudioCodecs = async (
+	checkedCodecs: AudioCodec[] = AUDIO_CODECS as unknown as AudioCodec[],
+	options?: SetOptional<AudioDecoderConfig, 'codec' | 'numberOfChannels' | 'sampleRate'>,
+): Promise<AudioCodec[]> => {
+	const bools = await Promise.all(checkedCodecs.map(codec => canDecodeAudio(codec, options)));
+	return checkedCodecs.filter((_, i) => bools[i]);
+};

package/third-party/npm/mediabunny@1.52.2/source/src/demuxer.ts

@@ -0,0 +1,43 @@
+/*!
+ * Copyright (c) 2026-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import { Input } from './input';
+import { InputTrackBacking } from './input-track';
+import { MetadataTags } from './metadata';
+
+/**
+ * Options for retrieving media duration from metadata.
+ * @group Input files & tracks
+ * @public
+ */
+export type DurationMetadataRequestOptions = {
+	/**
+	 * When the underlying media is live, querying the duration will, by default, wait until the live stream has ended.
+	 * Setting this field to `true` skips that wait and returns the current duration of the stream. When the media isn't
+	 * live, this field has no effect.
+	 *
+	 * See also {@link PacketRetrievalOptions.skipLiveWait}.
+	 */
+	skipLiveWait?: boolean;
+};
+
+export abstract class Demuxer {
+	input: Input;
+
+	constructor(input: Input) {
+		this.input = input;
+	}
+
+	abstract getTrackBackings(): Promise<InputTrackBacking[]>;
+	abstract getMimeType(): Promise<string>;
+	abstract getMetadataTags(): Promise<MetadataTags>;
+
+	dispose() {
+		// Can be overridden
+	}
+}