@osmo.inc/cli 0.1.15

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

@@ -0,0 +1,400 @@
+/*!
+ * 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 { aacChannelMap, aacFrequencyTable } from '../../shared/aac-misc';
+import { AudioCodec } from '../codec';
+import { Demuxer } from '../demuxer';
+import {
+	ID3_V2_HEADER_SIZE,
+	parseId3V2Tag,
+	readId3V2Header,
+} from '../id3';
+import { Input } from '../input';
+import { InputAudioTrackBacking } from '../input-track';
+import { PacketRetrievalOptions } from '../media-sink';
+import { DEFAULT_TRACK_DISPOSITION, MetadataTags } from '../metadata';
+import {
+	assert,
+	AsyncMutex,
+	binarySearchExact,
+	binarySearchLessOrEqual,
+	UNDETERMINED_LANGUAGE,
+} from '../misc';
+import { EncodedPacket, PLACEHOLDER_DATA } from '../packet';
+import { readBytes, Reader } from '../reader';
+import {
+	AdtsFrameHeader,
+	MIN_ADTS_FRAME_HEADER_SIZE,
+	MAX_ADTS_FRAME_HEADER_SIZE,
+	readAdtsFrameHeader,
+} from './adts-reader';
+
+export const SAMPLES_PER_AAC_FRAME = 1024;
+
+type Sample = {
+	timestamp: number;
+	duration: number;
+	dataStart: number;
+	dataSize: number;
+};
+
+export class AdtsDemuxer extends Demuxer {
+	reader: Reader;
+
+	metadataPromise: Promise<void> | null = null;
+	firstFrameHeader: AdtsFrameHeader | null = null;
+	loadedSamples: Sample[] = [];
+	metadataTags: MetadataTags | null = null;
+
+	trackBackings: AdtsAudioTrackBacking[] = [];
+
+	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();
+			}
+
+			// There has to be a frame if this demuxer got selected
+			assert(this.firstFrameHeader);
+
+			// Create the single audio track
+			this.trackBackings = [new AdtsAudioTrackBacking(this)];
+		})();
+	}
+
+	async advanceReader() {
+		if (this.lastLoadedPos === 0) {
+			// 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;
+			}
+		}
+
+		let slice = this.reader.requestSliceRange(
+			this.lastLoadedPos,
+			MIN_ADTS_FRAME_HEADER_SIZE,
+			MAX_ADTS_FRAME_HEADER_SIZE,
+		);
+		if (slice instanceof Promise) slice = await slice;
+		if (!slice) {
+			this.lastSampleLoaded = true;
+			return;
+		}
+
+		const header = readAdtsFrameHeader(slice);
+		if (!header) {
+			this.lastSampleLoaded = true;
+			return;
+		}
+
+		if (this.reader.fileSize !== null && header.startPos + header.frameLength > this.reader.fileSize) {
+			// Frame doesn't fit in the rest of the file
+			this.lastSampleLoaded = true;
+			return;
+		}
+
+		if (!this.firstFrameHeader) {
+			this.firstFrameHeader = header;
+		}
+
+		const sampleRate = aacFrequencyTable[header.samplingFrequencyIndex];
+		assert(sampleRate !== undefined);
+		const sampleDuration = SAMPLES_PER_AAC_FRAME / sampleRate;
+
+		const sample: Sample = {
+			timestamp: this.nextTimestampInSamples / sampleRate,
+			duration: sampleDuration,
+			dataStart: header.startPos,
+			dataSize: header.frameLength,
+		};
+
+		this.loadedSamples.push(sample);
+		this.nextTimestampInSamples += SAMPLES_PER_AAC_FRAME;
+		this.lastLoadedPos = header.startPos + header.frameLength;
+	}
+
+	async getMimeType() {
+		return 'audio/aac';
+	}
+
+	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;
+
+			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;
+				}
+
+				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;
+			}
+
+			return this.metadataTags;
+		} finally {
+			release();
+		}
+	}
+}
+
+class AdtsAudioTrackBacking implements InputAudioTrackBacking {
+	constructor(public demuxer: AdtsDemuxer) {}
+
+	getType() {
+		return 'audio' as const;
+	}
+
+	getId() {
+		return 1;
+	}
+
+	getNumber() {
+		return 1;
+	}
+
+	getTimeResolution() {
+		const sampleRate = this.getSampleRate();
+		return sampleRate / SAMPLES_PER_AAC_FRAME;
+	}
+
+	isRelativeToUnixEpoch() {
+		return false;
+	}
+
+	getUnixTimeForTimestamp() {
+		return null;
+	}
+
+	getPairingMask() {
+		return 1n;
+	}
+
+	getBitrate() {
+		return null;
+	}
+
+	getAverageBitrate() {
+		return null;
+	}
+
+	async getDurationFromMetadata() {
+		return null; // No way
+	}
+
+	async getLiveRefreshInterval() {
+		return null;
+	}
+
+	getName() {
+		return null;
+	}
+
+	getLanguageCode() {
+		return UNDETERMINED_LANGUAGE;
+	}
+
+	getCodec(): AudioCodec {
+		return 'aac';
+	}
+
+	getInternalCodecId() {
+		assert(this.demuxer.firstFrameHeader);
+
+		return this.demuxer.firstFrameHeader.objectType;
+	}
+
+	getNumberOfChannels() {
+		assert(this.demuxer.firstFrameHeader);
+
+		const numberOfChannels = aacChannelMap[this.demuxer.firstFrameHeader.channelConfiguration];
+		assert(numberOfChannels !== undefined);
+
+		return numberOfChannels;
+	}
+
+	getSampleRate() {
+		assert(this.demuxer.firstFrameHeader);
+
+		const sampleRate = aacFrequencyTable[this.demuxer.firstFrameHeader.samplingFrequencyIndex];
+		assert(sampleRate !== undefined);
+
+		return sampleRate;
+	}
+
+	getDisposition() {
+		return {
+			...DEFAULT_TRACK_DISPOSITION,
+		};
+	}
+
+	async getDecoderConfig(): Promise<AudioDecoderConfig> {
+		assert(this.demuxer.firstFrameHeader);
+
+		return {
+			codec: `mp4a.40.${this.demuxer.firstFrameHeader.objectType}`,
+			numberOfChannels: this.getNumberOfChannels(),
+			sampleRate: this.getSampleRate(),
+		};
+	}
+
+	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/adts/adts-muxer.ts

@@ -0,0 +1,124 @@
+/*!
+ * 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 { buildAdtsHeaderTemplate, parseAacAudioSpecificConfig, writeAdtsFrameLength } from '../../shared/aac-misc';
+import { Bitstream } from '../../shared/bitstream';
+import { validateAudioChunkMetadata } from '../codec';
+import { Id3V2Writer } from '../id3';
+import { metadataTagsAreEmpty } from '../metadata';
+import { assert, toUint8Array } from '../misc';
+import { Muxer } from '../muxer';
+import { Output, OutputAudioTrack } from '../output';
+import { AdtsOutputFormat } from '../output-format';
+import { EncodedPacket } from '../packet';
+import { Writer } from '../writer';
+
+export class AdtsMuxer extends Muxer {
+	private format: AdtsOutputFormat;
+	private writer!: Writer;
+	private header: Uint8Array | null = null;
+	private headerBitstream: Bitstream | null = null;
+	private inputIsAdts: boolean | null = null;
+
+	constructor(output: Output, format: AdtsOutputFormat) {
+		super(output);
+
+		this.format = format;
+	}
+
+	async start() {
+		const release = await this.mutex.acquire();
+
+		this.writer = await this.output._getRootWriter(true);
+
+		if (!metadataTagsAreEmpty(this.output._metadataTags)) {
+			const id3Writer = new Id3V2Writer(this.writer);
+			id3Writer.writeId3V2Tag(this.output._metadataTags);
+		}
+
+		release();
+	}
+
+	async getMimeType() {
+		return 'audio/aac';
+	}
+
+	async addEncodedVideoPacket() {
+		throw new Error('ADTS does not support video.');
+	}
+
+	async addEncodedAudioPacket(
+		track: OutputAudioTrack,
+		packet: EncodedPacket,
+		meta?: EncodedAudioChunkMetadata,
+	) {
+		const release = await this.mutex.acquire();
+
+		try {
+			this.validateTimestamp(track, packet.timestamp, packet.type === 'key');
+
+			// First packet - determine input format from metadata
+			if (this.inputIsAdts === null) {
+				validateAudioChunkMetadata(meta);
+
+				const description = meta?.decoderConfig?.description;
+
+				// Follows from the Mediabunny Codec Registry:
+				this.inputIsAdts = !description;
+
+				if (!this.inputIsAdts) {
+					const config = parseAacAudioSpecificConfig(toUint8Array(description!));
+					const template = buildAdtsHeaderTemplate(config);
+					this.header = template.header;
+					this.headerBitstream = template.bitstream;
+				}
+			}
+
+			if (this.inputIsAdts) {
+				// Packets are already ADTS frames, write them directly
+				const startPos = this.writer.getPos();
+				this.writer.write(packet.data);
+
+				if (this.format._options.onFrame) {
+					this.format._options.onFrame(packet.data, startPos);
+				}
+			} else {
+				assert(this.header);
+
+				// Packets are raw AAC, we gotta turn it into ADTS
+				const frameLength = packet.data.byteLength + this.header.byteLength;
+				writeAdtsFrameLength(this.headerBitstream!, frameLength);
+
+				const startPos = this.writer.getPos();
+				this.writer.write(this.header);
+				this.writer.write(packet.data);
+
+				if (this.format._options.onFrame) {
+					const frameBytes = new Uint8Array(frameLength);
+					frameBytes.set(this.header, 0);
+					frameBytes.set(packet.data, this.header.byteLength);
+
+					this.format._options.onFrame(frameBytes, startPos);
+				}
+			}
+
+			await this.writer.flush();
+		} finally {
+			release();
+		}
+	}
+
+	async addSubtitleCue() {
+		throw new Error('ADTS does not support subtitles.');
+	}
+
+	async finalize() {
+		const release = await this.mutex.acquire(); // Required so that finalize() can't resolve before other calls
+		release();
+	}
+}

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

@@ -0,0 +1,85 @@
+/*!
+ * 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 { Bitstream } from '../../shared/bitstream';
+import { FileSlice, readBytes } from '../reader';
+
+export const MIN_ADTS_FRAME_HEADER_SIZE = 7;
+export const MAX_ADTS_FRAME_HEADER_SIZE = 9;
+
+export type AdtsFrameHeader = {
+	objectType: number;
+	samplingFrequencyIndex: number;
+	channelConfiguration: number;
+	frameLength: number;
+	numberOfAacFrames: number;
+	crcCheck: number | null;
+	startPos: number;
+};
+
+export const readAdtsFrameHeader = (slice: FileSlice): AdtsFrameHeader | null => {
+	// https://wiki.multimedia.cx/index.php/ADTS (last visited: 2025/08/17)
+
+	const startPos = slice.filePos;
+
+	const bytes = readBytes(slice, 9); // 9 with CRC, 7 without CRC
+	const bitstream = new Bitstream(bytes);
+
+	const syncword = bitstream.readBits(12);
+	if (syncword !== 0b1111_11111111) {
+		return null;
+	}
+
+	bitstream.skipBits(1); // MPEG version
+	const layer = bitstream.readBits(2);
+	if (layer !== 0) {
+		return null;
+	}
+
+	const protectionAbsence = bitstream.readBits(1);
+	const objectType = bitstream.readBits(2) + 1;
+	const samplingFrequencyIndex = bitstream.readBits(4);
+	if (samplingFrequencyIndex === 15) {
+		return null;
+	}
+
+	bitstream.skipBits(1); // Private bit
+	const channelConfiguration = bitstream.readBits(3);
+	if (channelConfiguration === 0) {
+		throw new Error('ADTS frames with channel configuration 0 are not supported.');
+	}
+
+	bitstream.skipBits(1); // Originality
+	bitstream.skipBits(1); // Home
+	bitstream.skipBits(1); // Copyright ID bit
+	bitstream.skipBits(1); // Copyright ID start
+	const frameLength = bitstream.readBits(13);
+	bitstream.skipBits(11); // Buffer fullness
+	const numberOfAacFrames = bitstream.readBits(2) + 1;
+	if (numberOfAacFrames !== 1) {
+		throw new Error('ADTS frames with more than one AAC frame are not supported.');
+	}
+
+	let crcCheck: number | null = null;
+
+	if (protectionAbsence === 1) { // No CRC
+		slice.filePos -= 2;
+	} else { // CRC
+		crcCheck = bitstream.readBits(16);
+	}
+
+	return {
+		objectType,
+		samplingFrequencyIndex,
+		channelConfiguration,
+		frameLength,
+		numberOfAacFrames,
+		crcCheck,
+		startPos,
+	};
+};