@osmo.inc/cli 0.1.18-preview.2 → 0.1.19

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

@@ -1,165 +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 { Bitstream } from '../../shared/bitstream';
-import { assert, assertNever } from '../misc';
-import { FileSlice, readBytes, readU16Be, readU8 } from '../reader';
-
-type BlockSizeOrUncommon = number | 'uncommon-u16' | 'uncommon-u8';
-type SampleRateOrUncommon =
-	| number
-	| 'uncommon-u8'
-	| 'uncommon-u16'
-	| 'uncommon-u16-10';
-
-// https://www.rfc-editor.org/rfc/rfc9639.html#name-block-size-bits
-export const getBlockSizeOrUncommon = (bits: number): BlockSizeOrUncommon | null => {
-	if (bits === 0b0000) {
-		return null;
-	} else if (bits === 0b0001) {
-		return 192;
-	} else if (bits >= 0b0010 && bits <= 0b0101) {
-		return 144 * 2 ** bits;
-	} else if (bits === 0b0110) {
-		return 'uncommon-u8';
-	} else if (bits === 0b0111) {
-		return 'uncommon-u16';
-	} else if (bits >= 0b1000 && bits <= 0b1111) {
-		return 2 ** bits;
-	} else {
-		return null;
-	}
-};
-
-// https://www.rfc-editor.org/rfc/rfc9639.html#name-sample-rate-bits
-export const getSampleRateOrUncommon = (
-	sampleRateBits: number,
-	streamInfoSampleRate: number,
-): SampleRateOrUncommon | null => {
-	switch (sampleRateBits) {
-		case 0b0000: return streamInfoSampleRate;
-		case 0b0001: return 88200;
-		case 0b0010: return 176400;
-		case 0b0011: return 192000;
-		case 0b0100: return 8000;
-		case 0b0101: return 16000;
-		case 0b0110: return 22050;
-		case 0b0111: return 24000;
-		case 0b1000: return 32000;
-		case 0b1001: return 44100;
-		case 0b1010: return 48000;
-		case 0b1011: return 96000;
-		case 0b1100: return 'uncommon-u8';
-		case 0b1101: return 'uncommon-u16';
-		case 0b1110: return 'uncommon-u16-10';
-		default: return null;
-	}
-};
-
-// https://www.rfc-editor.org/rfc/rfc9639.html#name-coded-number
-export const readCodedNumber = (fileSlice: FileSlice): number => {
-	let ones = 0;
-
-	const bitstream1 = new Bitstream(readBytes(fileSlice, 1));
-	while (bitstream1.readBits(1) === 1) {
-		ones++;
-	}
-
-	if (ones === 0) {
-		return bitstream1.readBits(7);
-	}
-
-	const bitArray: number[] = [];
-	const extraBytes = ones - 1;
-	const bitstream2 = new Bitstream(readBytes(fileSlice, extraBytes));
-
-	const firstByteBits = 8 - ones - 1;
-	for (let i = 0; i < firstByteBits; i++) {
-		bitArray.unshift(bitstream1.readBits(1));
-	}
-
-	for (let i = 0; i < extraBytes; i++) {
-		for (let j = 0; j < 8; j++) {
-			const val = bitstream2.readBits(1);
-			if (j < 2) {
-				continue;
-			}
-
-			bitArray.unshift(val);
-		}
-	}
-
-	const encoded = bitArray.reduce((acc, bit, index) => {
-		return acc | (bit << index);
-	}, 0);
-
-	return encoded;
-};
-
-export const readBlockSize = (
-	slice: FileSlice,
-	blockSizeBits: BlockSizeOrUncommon,
-) => {
-	if (blockSizeBits === 'uncommon-u16') {
-		return readU16Be(slice) + 1;
-	} else if (blockSizeBits === 'uncommon-u8') {
-		return readU8(slice) + 1;
-	} else if (typeof blockSizeBits === 'number') {
-		return blockSizeBits;
-	} else {
-		assertNever(blockSizeBits);
-		assert(false);
-	}
-};
-
-export const readSampleRate = (
-	slice: FileSlice,
-	sampleRateOrUncommon: SampleRateOrUncommon,
-) => {
-	if (sampleRateOrUncommon === 'uncommon-u16') {
-		return readU16Be(slice);
-	}
-
-	if (sampleRateOrUncommon === 'uncommon-u16-10') {
-		return readU16Be(slice) * 10;
-	}
-
-	if (sampleRateOrUncommon === 'uncommon-u8') {
-		return readU8(slice);
-	}
-
-	if (typeof sampleRateOrUncommon === 'number') {
-		return sampleRateOrUncommon;
-	}
-
-	return null;
-};
-
-// https://www.rfc-editor.org/rfc/rfc9639.html#section-9.1.1
-export const calculateCrc8 = (data: Uint8Array) => {
-	const polynomial = 0x07; // x^8 + x^2 + x^1 + x^0
-	let crc = 0x00; // Initialize CRC to 0
-
-	for (const byte of data) {
-		crc ^= byte; // XOR byte into least significant byte of crc
-
-		for (let i = 0; i < 8; i++) {
-			// For each bit in the byte
-			if ((crc & 0x80) !== 0) {
-				// If the leftmost bit (MSB) is set
-				crc = (crc << 1) ^ polynomial; // Shift left and XOR with polynomial
-			} else {
-				crc <<= 1; // Just shift left
-			}
-
-			crc &= 0xff; // Ensure CRC remains 8-bit
-		}
-	}
-
-	return crc;
-};

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

@@ -1,350 +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 { validateAudioChunkMetadata } from '../codec';
-import { createVorbisComments, FlacBlockType } from '../codec-data';
-import {
-	assert,
-	textEncoder,
-	toDataView,
-	toUint8Array,
-} from '../misc';
-import { Muxer } from '../muxer';
-import { Output, OutputAudioTrack } from '../output';
-import { FlacOutputFormat } from '../output-format';
-import { EncodedPacket } from '../packet';
-import { FileSlice, readBytes } from '../reader';
-import { AttachedImage, metadataTagsAreEmpty } from '../metadata';
-import { Writer } from '../writer';
-import {
-	readBlockSize,
-	getBlockSizeOrUncommon,
-	readCodedNumber,
-} from './flac-misc';
-import { Bitstream } from '../../shared/bitstream';
-
-const FLAC_HEADER = /* #__PURE__ */ new Uint8Array([0x66, 0x4c, 0x61, 0x43]); // 'fLaC'
-const STREAMINFO_SIZE = 38;
-const STREAMINFO_BLOCK_SIZE = 34;
-
-export class FlacMuxer extends Muxer {
-	private writer!: Writer;
-	private metadataWritten = false;
-
-	private blockSizes: number[] = [];
-	private frameSizes: number[] = [];
-
-	private sampleRate: number | null = null;
-	private channels: number | null = null;
-	private bitsPerSample: number | null = null;
-
-	private format: FlacOutputFormat;
-
-	constructor(output: Output, format: FlacOutputFormat) {
-		super(output);
-
-		this.format = format;
-	}
-
-	async start() {
-		const release = await this.mutex.acquire();
-
-		this.writer = await this.output._getRootWriter(!!this.format._options.appendOnly);
-		this.writer.write(FLAC_HEADER);
-
-		release();
-	}
-
-	writeHeader({
-		bitsPerSample,
-		minimumBlockSize,
-		maximumBlockSize,
-		minimumFrameSize,
-		maximumFrameSize,
-		sampleRate,
-		channels,
-		totalSamples,
-	}: {
-		minimumBlockSize: number;
-		maximumBlockSize: number;
-		minimumFrameSize: number;
-		maximumFrameSize: number;
-		sampleRate: number;
-		channels: number;
-		bitsPerSample: number;
-		totalSamples: number;
-	}) {
-		assert(this.writer.getPos() === 4);
-
-		const hasMetadata = !metadataTagsAreEmpty(this.output._metadataTags);
-		const headerBitstream = new Bitstream(new Uint8Array(4));
-		headerBitstream.writeBits(1, Number(!hasMetadata)); // isLastMetadata
-		headerBitstream.writeBits(7, FlacBlockType.STREAMINFO); // metaBlockType = streaminfo
-		headerBitstream.writeBits(24, STREAMINFO_BLOCK_SIZE); // size
-		this.writer.write(headerBitstream.bytes);
-
-		const contentBitstream = new Bitstream(new Uint8Array(18));
-
-		contentBitstream.writeBits(16, minimumBlockSize);
-		contentBitstream.writeBits(16, maximumBlockSize);
-		contentBitstream.writeBits(24, minimumFrameSize);
-		contentBitstream.writeBits(24, maximumFrameSize);
-		contentBitstream.writeBits(20, sampleRate);
-		contentBitstream.writeBits(3, channels - 1);
-		contentBitstream.writeBits(5, bitsPerSample - 1);
-
-		// Bitstream operations are only safe until 32bit, breaks when using 36 bits
-		// Splitting up into writing 4 0 bits and then 32 bits is safe
-		// This is safe for audio up to (2 ** 32 / 44100 / 3600) -> 27 hours
-		// Not implementing support for more than 32 bits now
-		if (totalSamples >= 2 ** 32) {
-			throw new Error('This muxer only supports writing up to 2 ** 32 samples');
-		}
-
-		contentBitstream.writeBits(4, 0);
-		contentBitstream.writeBits(32, totalSamples);
-		this.writer.write(contentBitstream.bytes);
-		// The MD5 hash is calculated from decoded audio data, but we do not have access
-		// to it here. We are allowed to set 0:
-		// "A value of 0 signifies that the value is not known."
-		// https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
-		this.writer.write(new Uint8Array(16));
-	}
-
-	writePictureBlock(picture: AttachedImage) {
-		// Header size:
-		// 4 bytes: picture type
-		// 4 bytes: media type length
-		// x bytes: media type
-		// 4 bytes: description length
-		// y bytes: description
-		// 1 bytes: width
-		// 1 bytes: height
-		// 1 bytes: color depth
-		// 1 bytes: number of indexed colors
-		// 4 bytes: picture data length
-		// z bytes: picture data
-		// Total: 20 + x + y + z
-		const headerSize
-			= 32
-				+ picture.mimeType.length
-				+ (picture.description?.length ?? 0)
-				+ picture.data.length;
-
-		const header = new Uint8Array(headerSize);
-
-		let offset = 0;
-		const dataView = toDataView(header);
-		dataView.setUint32(
-			offset,
-			picture.kind === 'coverFront' ? 3 : picture.kind === 'coverBack' ? 4 : 0,
-		);
-		offset += 4;
-		dataView.setUint32(offset, picture.mimeType.length);
-		offset += 4;
-		header.set(textEncoder.encode(picture.mimeType), 8);
-		offset += picture.mimeType.length;
-		dataView.setUint32(offset, picture.description?.length ?? 0);
-		offset += 4;
-		header.set(textEncoder.encode(picture.description ?? ''), offset);
-		offset += picture.description?.length ?? 0;
-		offset += 4 + 4 + 4 + 4; // setting width, height, color depth, number of indexed colors to 0
-		dataView.setUint32(offset, picture.data.length);
-		offset += 4;
-		header.set(picture.data, offset);
-		offset += picture.data.length;
-		assert(offset === headerSize);
-
-		const headerBitstream = new Bitstream(new Uint8Array(4));
-		headerBitstream.writeBits(1, 0); // Last metadata block -> false, will be continued by vorbis comment
-		headerBitstream.writeBits(7, FlacBlockType.PICTURE); // Type -> Picture
-		headerBitstream.writeBits(24, headerSize);
-		this.writer.write(headerBitstream.bytes);
-		this.writer.write(header);
-	}
-
-	writeVorbisCommentAndPictureBlock() {
-		if (!this.format._options.appendOnly) {
-			this.writer.seek(STREAMINFO_SIZE + FLAC_HEADER.byteLength);
-		}
-		if (metadataTagsAreEmpty(this.output._metadataTags)) {
-			this.metadataWritten = true;
-			return;
-		}
-
-		const pictures = this.output._metadataTags.images ?? [];
-		for (const picture of pictures) {
-			this.writePictureBlock(picture);
-		}
-
-		const vorbisComment = createVorbisComments(
-			new Uint8Array(0),
-			this.output._metadataTags,
-			false,
-		);
-
-		const headerBitstream = new Bitstream(new Uint8Array(4));
-		headerBitstream.writeBits(1, 1); // Last metadata block -> true
-		headerBitstream.writeBits(7, FlacBlockType.VORBIS_COMMENT); // Type -> Vorbis comment
-		headerBitstream.writeBits(24, vorbisComment.length);
-		this.writer.write(headerBitstream.bytes);
-		this.writer.write(vorbisComment);
-
-		this.metadataWritten = true;
-	}
-
-	async getMimeType() {
-		return 'audio/flac';
-	}
-
-	async addEncodedVideoPacket() {
-		throw new Error('FLAC does not support video.');
-	}
-
-	async addEncodedAudioPacket(
-		track: OutputAudioTrack,
-		packet: EncodedPacket,
-		meta?: EncodedAudioChunkMetadata,
-	): Promise<void> {
-		const release = await this.mutex.acquire();
-
-		try {
-			this.validateTimestamp(
-				track,
-				packet.timestamp,
-				packet.type === 'key',
-			);
-
-			if (this.sampleRate === null) {
-				// It's the first packet
-				validateAudioChunkMetadata(meta);
-
-				assert(meta);
-				assert(meta.decoderConfig);
-				assert(meta.decoderConfig.description);
-
-				this.sampleRate = meta.decoderConfig.sampleRate;
-				this.channels = meta.decoderConfig.numberOfChannels;
-
-				const descriptionBitstream = new Bitstream(
-					toUint8Array(meta.decoderConfig.description),
-				);
-				// skip 'fLaC' + block size + frame size + sample rate + number of channels
-				// See demuxer for the exact structure
-				descriptionBitstream.skipBits(103 + 64);
-				const bitsPerSample = descriptionBitstream.readBits(5) + 1;
-				this.bitsPerSample = bitsPerSample;
-
-				if (this.format._options.appendOnly) {
-					// Write STREAMINFO immediately since we can't seek back later.
-					this.writeHeader({
-						// https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
-						// Per RFC 9639, min/max block sizes can be looser than
-						// actual values, so we use the full valid range (16–65535).
-						// "The actual max block size MAY be smaller than what's
-						// listed, and the actual min (excluding last block) MAY be
-						// larger. This is because the encoder has to write these
-						// fields before receiving any input audio data and cannot
-						// know beforehand what block sizes it will use."
-						minimumBlockSize: 16,
-						maximumBlockSize: 65535,
-						// https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
-						// "A value of 0 signifies that the value is not known."
-						minimumFrameSize: 0,
-						maximumFrameSize: 0,
-						sampleRate: this.sampleRate,
-						channels: this.channels,
-						bitsPerSample: this.bitsPerSample,
-						totalSamples: 0,
-					});
-				}
-			}
-
-			if (!this.metadataWritten) {
-				this.writeVorbisCommentAndPictureBlock();
-			}
-
-			const slice = FileSlice.tempFromBytes(packet.data);
-			slice.skip(2);
-			const bytes = readBytes(slice, 2);
-			const bitstream = new Bitstream(bytes);
-			const blockSizeOrUncommon = getBlockSizeOrUncommon(bitstream.readBits(4));
-			if (blockSizeOrUncommon === null) {
-				throw new Error('Invalid FLAC frame: Invalid block size.');
-			}
-
-			readCodedNumber(slice); // num
-			const blockSize = readBlockSize(slice, blockSizeOrUncommon);
-
-			if (!this.format._options.appendOnly) {
-				this.blockSizes.push(blockSize);
-				this.frameSizes.push(packet.data.length);
-			}
-
-			const startPos = this.writer.getPos();
-			this.writer.write(packet.data);
-
-			if (this.format._options.onFrame) {
-				this.format._options.onFrame(packet.data, startPos);
-			}
-
-			await this.writer.flush();
-		} finally {
-			release();
-		}
-	}
-
-	override addSubtitleCue(): Promise<void> {
-		throw new Error('FLAC does not support subtitles.');
-	}
-
-	async finalize(): Promise<void> {
-		const release = await this.mutex.acquire();
-
-		if (!this.format._options.appendOnly) {
-			let minimumBlockSize = Infinity;
-			let maximumBlockSize = 0;
-			let minimumFrameSize = Infinity;
-			let maximumFrameSize = 0;
-			let totalSamples = 0;
-			for (let i = 0; i < this.blockSizes.length; i++) {
-				minimumFrameSize = Math.min(minimumFrameSize, this.frameSizes[i]!);
-				maximumFrameSize = Math.max(maximumFrameSize, this.frameSizes[i]!);
-				maximumBlockSize = Math.max(maximumBlockSize, this.blockSizes[i]!);
-				totalSamples += this.blockSizes[i]!;
-
-				// Excluding the last frame from block size calculation
-				// https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
-				// "The minimum block size (in samples) used in the stream, excluding the last block."
-				const isLastFrame = i === this.blockSizes.length - 1;
-				if (isLastFrame) {
-					continue;
-				}
-				minimumBlockSize = Math.min(minimumBlockSize, this.blockSizes[i]!);
-			}
-
-			assert(this.sampleRate !== null);
-			assert(this.channels !== null);
-			assert(this.bitsPerSample !== null);
-
-			this.writer.seek(4);
-			this.writeHeader({
-				minimumBlockSize,
-				maximumBlockSize,
-				minimumFrameSize,
-				maximumFrameSize,
-				sampleRate: this.sampleRate,
-				channels: this.channels,
-				bitsPerSample: this.bitsPerSample,
-				totalSamples,
-			});
-		}
-
-		release();
-	}
-}