@osmo.inc/cli 0.1.18 → 0.1.19

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

@@ -1,469 +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 } from '../codec';
-import { Demuxer } from '../demuxer';
-import { Input } from '../input';
-import { InputAudioTrackBacking } from '../input-track';
-import { DEFAULT_TRACK_DISPOSITION, MetadataTags } from '../metadata';
-import { PacketRetrievalOptions } from '../media-sink';
-import {
-	assert,
-	AsyncMutex,
-	binarySearchExact,
-	binarySearchLessOrEqual,
-	toDataView,
-	UNDETERMINED_LANGUAGE,
-} from '../misc';
-import { EncodedPacket, PLACEHOLDER_DATA } from '../packet';
-import {
-	Mp3FrameHeader,
-	getXingOffset,
-	INFO,
-	XING,
-	XingFlags,
-	computeAverageMp3FrameSize,
-	getMp3ChannelCount,
-} from '../../shared/mp3-misc';
-import {
-	ID3_V1_TAG_SIZE,
-	ID3_V2_HEADER_SIZE,
-	parseId3V1Tag,
-	parseId3V2Tag,
-	readId3V2Header,
-} from '../id3';
-import { readNextMp3FrameHeader } from './mp3-reader';
-import { readAscii, readBytes, Reader, readU32Be } from '../reader';
-
-type Sample = {
-	timestamp: number;
-	duration: number;
-	dataStart: number;
-	dataSize: number;
-};
-
-export class Mp3Demuxer extends Demuxer {
-	reader: Reader;
-
-	metadataPromise: Promise<void> | null = null;
-	firstFrameHeader: Mp3FrameHeader | null = null;
-	firstFrameHeaderPos: number | null = null;
-	loadedSamples: Sample[] = []; // All samples from the start of the file to lastLoadedPos
-	metadataTags: MetadataTags | null = null;
-	xingData: {
-		frameCount: number | null;
-		fileSize: number | null;
-	} | null = null;
-
-	trackBackings: Mp3AudioTrackBacking[] = [];
-
-	readingMutex = new AsyncMutex();
-	lastSampleLoaded = false;
-	lastLoadedPos = 0;
-	nextTimestampInSamples = 0;
-
-	constructor(input: Input) {
-		super(input);
-
-		this.reader = input._reader;
-	}
-
-	async readMetadata() {
-		return this.metadataPromise ??= (async () => {
-			// Keep loading until we find the first frame header
-			while (!this.firstFrameHeader && !this.lastSampleLoaded) {
-				await this.advanceReader();
-			}
-
-			if (!this.firstFrameHeader) {
-				throw new Error('No valid MP3 frame found.');
-			}
-
-			this.trackBackings = [new Mp3AudioTrackBacking(this)];
-		})();
-	}
-
-	async advanceReader() {
-		if (this.lastLoadedPos === 0) {
-			// Let's skip all ID3v2 tags at the start of the file
-			while (true) {
-				let slice = this.reader.requestSlice(this.lastLoadedPos, ID3_V2_HEADER_SIZE);
-				if (slice instanceof Promise) slice = await slice;
-
-				if (!slice) {
-					this.lastSampleLoaded = true;
-					return;
-				}
-
-				const id3V2Header = readId3V2Header(slice);
-				if (!id3V2Header) {
-					break;
-				}
-
-				this.lastLoadedPos = slice.filePos + id3V2Header.size;
-			}
-		}
-
-		const result = await readNextMp3FrameHeader(
-			this.reader,
-			this.lastLoadedPos,
-			this.reader.fileSize,
-			this.firstFrameHeader,
-		);
-		if (!result) {
-			this.lastSampleLoaded = true;
-			return;
-		}
-
-		const header = result.header;
-
-		this.lastLoadedPos = result.startPos + header.totalSize - 1; // -1 in case the frame is 1 byte too short
-
-		const xingOffset = getXingOffset(header.mpegVersionId, header.channel);
-
-		let slice = this.reader.requestSlice(result.startPos + xingOffset, 4);
-		if (slice instanceof Promise) slice = await slice;
-		if (slice) {
-			const word = readU32Be(slice);
-			const isXing = word === XING || word === INFO;
-
-			if (isXing) {
-				// There's no actual audio data in this frame, so let's skip it
-
-				if (!this.xingData) {
-					let xingDataSlice = this.reader.requestSlice(result.startPos + xingOffset + 4, 12);
-					if (xingDataSlice instanceof Promise) xingDataSlice = await xingDataSlice;
-					if (xingDataSlice) {
-						const xingData = readBytes(xingDataSlice, 12);
-						const view = toDataView(xingData);
-						const flags = view.getUint32(0, false);
-
-						this.xingData = {
-							frameCount: (flags & XingFlags.FrameCount)
-								? view.getUint32(4, false)
-								: null,
-							fileSize: (flags & XingFlags.FileSize)
-								? view.getUint32(8, false)
-								: null,
-						};
-					}
-				}
-
-				return;
-			}
-		}
-
-		if (!this.firstFrameHeader) {
-			this.firstFrameHeader = header;
-			this.firstFrameHeaderPos = result.startPos;
-		}
-
-		const sampleDuration = header.audioSamplesInFrame / this.firstFrameHeader.sampleRate;
-		const sample: Sample = {
-			timestamp: this.nextTimestampInSamples / this.firstFrameHeader.sampleRate,
-			duration: sampleDuration,
-			dataStart: result.startPos,
-			dataSize: header.totalSize,
-		};
-
-		this.loadedSamples.push(sample);
-		this.nextTimestampInSamples += header.audioSamplesInFrame;
-
-		return;
-	}
-
-	async getMimeType() {
-		return 'audio/mpeg';
-	}
-
-	async getTrackBackings() {
-		await this.readMetadata();
-		return this.trackBackings;
-	}
-
-	async getMetadataTags() {
-		const release = await this.readingMutex.acquire();
-
-		try {
-			await this.readMetadata();
-
-			if (this.metadataTags) {
-				return this.metadataTags;
-			}
-
-			this.metadataTags = {};
-			let currentPos = 0;
-			let id3V2HeaderFound = false;
-
-			while (true) {
-				let headerSlice = this.reader.requestSlice(currentPos, ID3_V2_HEADER_SIZE);
-				if (headerSlice instanceof Promise) headerSlice = await headerSlice;
-				if (!headerSlice) break;
-
-				const id3V2Header = readId3V2Header(headerSlice);
-				if (!id3V2Header) {
-					break;
-				}
-
-				id3V2HeaderFound = true;
-
-				let contentSlice = this.reader.requestSlice(headerSlice.filePos, id3V2Header.size);
-				if (contentSlice instanceof Promise) contentSlice = await contentSlice;
-				if (!contentSlice) break;
-
-				parseId3V2Tag(contentSlice, id3V2Header, this.metadataTags);
-
-				currentPos = headerSlice.filePos + id3V2Header.size;
-			}
-
-			if (!id3V2HeaderFound && this.reader.fileSize !== null && this.reader.fileSize >= ID3_V1_TAG_SIZE) {
-				// Try reading an ID3v1 tag at the end of the file
-				let slice = this.reader.requestSlice(this.reader.fileSize - ID3_V1_TAG_SIZE, ID3_V1_TAG_SIZE);
-				if (slice instanceof Promise) slice = await slice;
-				assert(slice);
-
-				const tag = readAscii(slice, 3);
-				if (tag === 'TAG') {
-					parseId3V1Tag(slice, this.metadataTags);
-				}
-			}
-
-			return this.metadataTags;
-		} finally {
-			release();
-		}
-	}
-}
-
-class Mp3AudioTrackBacking implements InputAudioTrackBacking {
-	constructor(public demuxer: Mp3Demuxer) {}
-
-	getType() {
-		return 'audio' as const;
-	}
-
-	getId() {
-		return 1;
-	}
-
-	getNumber() {
-		return 1;
-	}
-
-	getTimeResolution() {
-		assert(this.demuxer.firstFrameHeader);
-		return this.demuxer.firstFrameHeader.sampleRate / this.demuxer.firstFrameHeader.audioSamplesInFrame;
-	}
-
-	isRelativeToUnixEpoch() {
-		return false;
-	}
-
-	getUnixTimeForTimestamp() {
-		return null;
-	}
-
-	getPairingMask() {
-		return 1n;
-	}
-
-	getBitrate() {
-		return null;
-	}
-
-	getAverageBitrate() {
-		return null;
-	}
-
-	async getDurationFromMetadata() {
-		const demuxer = this.demuxer;
-
-		assert(demuxer.firstFrameHeader !== null);
-		assert(demuxer.firstFrameHeaderPos !== null);
-
-		if (demuxer.xingData) {
-			if (demuxer.xingData.frameCount !== null) {
-				return demuxer.xingData.frameCount
-					* demuxer.firstFrameHeader.audioSamplesInFrame
-					/ demuxer.firstFrameHeader.sampleRate;
-			}
-		} else {
-			// No Xing, assuming CBR
-
-			if (demuxer.reader.fileSize !== null) {
-				const averageFrameSize = computeAverageMp3FrameSize(
-					demuxer.firstFrameHeader.lowSamplingFrequency,
-					demuxer.firstFrameHeader.layer,
-					demuxer.firstFrameHeader.bitrate,
-					demuxer.firstFrameHeader.sampleRate,
-				);
-				const frameCount = (demuxer.reader.fileSize - demuxer.firstFrameHeaderPos) / averageFrameSize;
-
-				return Math.round(frameCount)
-					* demuxer.firstFrameHeader.audioSamplesInFrame
-					/ demuxer.firstFrameHeader.sampleRate;
-			}
-		}
-
-		return null;
-	}
-
-	async getLiveRefreshInterval() {
-		return null;
-	}
-
-	getName() {
-		return null;
-	}
-
-	getLanguageCode() {
-		return UNDETERMINED_LANGUAGE;
-	}
-
-	getCodec(): AudioCodec {
-		return 'mp3';
-	}
-
-	getInternalCodecId() {
-		return null;
-	}
-
-	getNumberOfChannels() {
-		assert(this.demuxer.firstFrameHeader);
-		return getMp3ChannelCount(this.demuxer.firstFrameHeader.channel);
-	}
-
-	getSampleRate() {
-		assert(this.demuxer.firstFrameHeader);
-		return this.demuxer.firstFrameHeader.sampleRate;
-	}
-
-	getDisposition() {
-		return {
-			...DEFAULT_TRACK_DISPOSITION,
-		};
-	}
-
-	async getDecoderConfig(): Promise<AudioDecoderConfig> {
-		assert(this.demuxer.firstFrameHeader);
-
-		return {
-			codec: 'mp3',
-			numberOfChannels: getMp3ChannelCount(this.demuxer.firstFrameHeader.channel),
-			sampleRate: this.demuxer.firstFrameHeader.sampleRate,
-		};
-	}
-
-	async getPacketAtIndex(sampleIndex: number, options: PacketRetrievalOptions) {
-		if (sampleIndex === -1) {
-			return null;
-		}
-
-		const rawSample = this.demuxer.loadedSamples[sampleIndex];
-		if (!rawSample) {
-			return null;
-		}
-
-		let data: Uint8Array;
-		if (options.metadataOnly) {
-			data = PLACEHOLDER_DATA;
-		} else {
-			let slice = this.demuxer.reader.requestSlice(rawSample.dataStart, rawSample.dataSize);
-			if (slice instanceof Promise) slice = await slice;
-
-			if (!slice) {
-				return null; // Data didn't fit into the rest of the file
-			}
-
-			data = readBytes(slice, rawSample.dataSize);
-		}
-
-		return new EncodedPacket(
-			data,
-			'key',
-			rawSample.timestamp,
-			rawSample.duration,
-			sampleIndex,
-			rawSample.dataSize,
-		);
-	}
-
-	getFirstPacket(options: PacketRetrievalOptions) {
-		return this.getPacketAtIndex(0, options);
-	}
-
-	async getNextPacket(packet: EncodedPacket, options: PacketRetrievalOptions) {
-		const release = await this.demuxer.readingMutex.acquire();
-
-		try {
-			const sampleIndex = binarySearchExact(
-				this.demuxer.loadedSamples,
-				packet.timestamp,
-				x => x.timestamp,
-			);
-			if (sampleIndex === -1) {
-				throw new Error('Packet was not created from this track.');
-			}
-
-			const nextIndex = sampleIndex + 1;
-			// Ensure the next sample exists
-			while (
-				nextIndex >= this.demuxer.loadedSamples.length
-				&& !this.demuxer.lastSampleLoaded
-			) {
-				await this.demuxer.advanceReader();
-			}
-
-			return this.getPacketAtIndex(nextIndex, options);
-		} finally {
-			release();
-		}
-	}
-
-	async getPacket(timestamp: number, options: PacketRetrievalOptions) {
-		const release = await this.demuxer.readingMutex.acquire();
-
-		try {
-			while (true) {
-				const index = binarySearchLessOrEqual(
-					this.demuxer.loadedSamples,
-					timestamp,
-					x => x.timestamp,
-				);
-
-				if (index === -1 && this.demuxer.loadedSamples.length > 0) {
-					// We're before the first sample
-					return null;
-				}
-
-				if (this.demuxer.lastSampleLoaded) {
-					// All data is loaded, return what we found
-					return this.getPacketAtIndex(index, options);
-				}
-
-				if (index >= 0 && index + 1 < this.demuxer.loadedSamples.length) {
-					// The next packet also exists, we're done
-					return this.getPacketAtIndex(index, options);
-				}
-
-				// Otherwise, keep loading data
-				await this.demuxer.advanceReader();
-			}
-		} finally {
-			release();
-		}
-	}
-
-	getKeyPacket(timestamp: number, options: PacketRetrievalOptions) {
-		return this.getPacket(timestamp, options);
-	}
-
-	getNextKeyPacket(packet: EncodedPacket, options: PacketRetrievalOptions) {
-		return this.getNextPacket(packet, options);
-	}
-}

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

@@ -1,169 +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 { toDataView } from '../misc';
-import { metadataTagsAreEmpty } from '../metadata';
-import { Muxer } from '../muxer';
-import { Output, OutputAudioTrack } from '../output';
-import { Mp3OutputFormat } from '../output-format';
-import { EncodedPacket } from '../packet';
-import { Writer } from '../writer';
-import { getXingOffset, INFO, readMp3FrameHeader, XING } from '../../shared/mp3-misc';
-import { Mp3Writer, XingFrameData } from './mp3-writer';
-import { Id3V2Writer } from '../id3';
-
-export class Mp3Muxer extends Muxer {
-	private format: Mp3OutputFormat;
-	private writer!: Writer;
-	private mp3Writer!: Mp3Writer;
-	private xingFrameData: XingFrameData | null = null;
-	private frameCount = 0;
-	private framePositions: number[] = [];
-	private xingFramePos: number | null = null;
-
-	constructor(output: Output, format: Mp3OutputFormat) {
-		super(output);
-
-		this.format = format;
-	}
-
-	async start() {
-		const release = await this.mutex.acquire();
-
-		this.writer = await this.output._getRootWriter(this.format._options.xingHeader === false);
-		this.mp3Writer = new Mp3Writer(this.writer);
-
-		if (!metadataTagsAreEmpty(this.output._metadataTags)) {
-			const id3Writer = new Id3V2Writer(this.writer);
-			id3Writer.writeId3V2Tag(this.output._metadataTags);
-		}
-
-		release();
-	}
-
-	async getMimeType() {
-		return 'audio/mpeg';
-	}
-
-	async addEncodedVideoPacket() {
-		throw new Error('MP3 does not support video.');
-	}
-
-	async addEncodedAudioPacket(
-		track: OutputAudioTrack,
-		packet: EncodedPacket,
-	) {
-		const release = await this.mutex.acquire();
-
-		try {
-			const writeXingHeader = this.format._options.xingHeader !== false;
-
-			if (!this.xingFrameData && writeXingHeader) {
-				const view = toDataView(packet.data);
-				if (view.byteLength < 4) {
-					throw new Error('Invalid MP3 header in sample.');
-				}
-
-				const word = view.getUint32(0, false);
-				const header = readMp3FrameHeader(word, null).header;
-				if (!header) {
-					throw new Error('Invalid MP3 header in sample.');
-				}
-
-				const xingOffset = getXingOffset(header.mpegVersionId, header.channel);
-				if (view.byteLength >= xingOffset + 4) {
-					const word = view.getUint32(xingOffset, false);
-					const isXing = word === XING || word === INFO;
-
-					if (isXing) {
-						// This is not a data frame, so let's completely ignore this sample
-						return;
-					}
-				}
-
-				this.xingFrameData = {
-					mpegVersionId: header.mpegVersionId,
-					layer: header.layer,
-					frequencyIndex: header.frequencyIndex,
-					sampleRate: header.sampleRate,
-					channel: header.channel,
-					modeExtension: header.modeExtension,
-					copyright: header.copyright,
-					original: header.original,
-					emphasis: header.emphasis,
-
-					frameCount: null,
-					fileSize: null,
-					toc: null,
-				};
-
-				// Write a Xing frame because this muxer doesn't make any bitrate constraints, meaning we don't know if
-				// this will be a constant or variable bitrate file. Therefore, always write the Xing frame.
-				this.xingFramePos = this.writer.getPos();
-				this.mp3Writer.writeXingFrame(this.xingFrameData);
-
-				this.frameCount++;
-			}
-
-			this.validateTimestamp(track, packet.timestamp, packet.type === 'key');
-
-			if (writeXingHeader) {
-				this.framePositions.push(this.writer.getPos());
-			}
-
-			this.writer.write(packet.data);
-			this.frameCount++;
-
-			await this.writer.flush();
-		} finally {
-			release();
-		}
-	}
-
-	async addSubtitleCue() {
-		throw new Error('MP3 does not support subtitles.');
-	}
-
-	async finalize() {
-		if (!this.xingFrameData || this.xingFramePos === null) {
-			return;
-		}
-
-		const release = await this.mutex.acquire();
-
-		const endPos = this.writer.getPos();
-		const audioDataEndPos = endPos - this.xingFramePos;
-
-		this.writer.seek(this.xingFramePos);
-
-		const toc = new Uint8Array(100);
-		for (let i = 0; i < 100; i++) {
-			const index = Math.floor(this.framePositions.length * (i / 100));
-
-			const byteOffset = this.framePositions[index]! - this.xingFramePos;
-			toc[i] = 256 * (byteOffset / audioDataEndPos);
-		}
-
-		this.xingFrameData.frameCount = this.frameCount;
-		this.xingFrameData.fileSize = audioDataEndPos;
-		this.xingFrameData.toc = toc;
-
-		if (this.format._options.onXingFrame) {
-			this.writer.startTrackingWrites();
-		}
-
-		this.mp3Writer.writeXingFrame(this.xingFrameData);
-
-		if (this.format._options.onXingFrame) {
-			const { data, start } = this.writer.stopTrackingWrites();
-			this.format._options.onXingFrame(data, start);
-		}
-
-		release();
-	}
-}

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

@@ -1,61 +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 { MP3_FRAME_HEADER_SIZE, getMp3ChannelCount, Mp3FrameHeader, readMp3FrameHeader } from '../../shared/mp3-misc';
-import { Reader, readU32Be } from '../reader';
-
-export const readNextMp3FrameHeader = async (
-	reader: Reader,
-	startPos: number,
-	until: number | null,
-	ref: Mp3FrameHeader | null = null,
-): Promise<{
-	header: Mp3FrameHeader;
-	startPos: number;
-} | null> => {
-	const CHUNK_SIZE = 2 ** 16; // So we don't need to grab thousands of slices
-	let currentPos = startPos;
-
-	while (until === null || currentPos < until) {
-		const maxLength = until !== null
-			? Math.min(CHUNK_SIZE, until - currentPos)
-			: CHUNK_SIZE;
-
-		let slice = reader.requestSliceRange(currentPos, MP3_FRAME_HEADER_SIZE, maxLength);
-		if (slice instanceof Promise) slice = await slice;
-		if (!slice || slice.length < MP3_FRAME_HEADER_SIZE) break;
-
-		while (slice.remainingLength >= MP3_FRAME_HEADER_SIZE) {
-			const posBeforeRead = slice.filePos;
-			const word = readU32Be(slice);
-			const remainingBytes = reader.fileSize !== null
-				? reader.fileSize - currentPos
-				: null;
-
-			const result = readMp3FrameHeader(word, remainingBytes);
-			if (
-				result.header
-				&& (!ref || (
-					// This condition helps us recover malformed streams
-					// https://stackoverflow.com/a/20884944
-					result.header.sampleRate === ref.sampleRate
-					&& result.header.mpegVersionId === ref.mpegVersionId
-					&& result.header.layer === ref.layer
-					&& getMp3ChannelCount(result.header.channel) === getMp3ChannelCount(ref.channel)
-				))
-			) {
-				return { header: result.header, startPos: currentPos };
-			}
-
-			slice.filePos = posBeforeRead + result.bytesAdvanced;
-			currentPos = slice.filePos;
-		}
-	}
-
-	return null;
-};