@osmo.inc/cli 0.1.18 → 0.1.19

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

@@ -1,212 +0,0 @@
-/*!
- * 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

@@ -1,263 +0,0 @@
-/*!
- * 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

@@ -1,43 +0,0 @@
-/*!
- * 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
-	}
-}