@osmo.inc/cli 0.1.15

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

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

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

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