mediabunny 1.0.2 → 1.0.4

package/src/wave/wave-demuxer.ts

@@ -0,0 +1,317 @@
+/*!
+ * Copyright (c) 2025-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 { InputAudioTrack, InputAudioTrackBacking } from '../input-track';
+import { PacketRetrievalOptions } from '../media-sink';
+import { assert, UNDETERMINED_LANGUAGE } from '../misc';
+import { EncodedPacket, PLACEHOLDER_DATA } from '../packet';
+import { Reader } from '../reader';
+import { RiffReader } from './riff-reader';
+
+export enum WaveFormat {
+	PCM = 0x0001,
+	IEEE_FLOAT = 0x0003,
+	ALAW = 0x0006,
+	MULAW = 0x0007,
+	EXTENSIBLE = 0xFFFE,
+}
+
+export class WaveDemuxer extends Demuxer {
+	metadataReader: RiffReader;
+	chunkReader: RiffReader;
+
+	metadataPromise: Promise<void> | null = null;
+	dataStart = -1;
+	dataSize = -1;
+	audioInfo: {
+		format: number;
+		numberOfChannels: number;
+		sampleRate: number;
+		sampleSizeInBytes: number;
+		blockSizeInBytes: number;
+	} | null = null;
+
+	tracks: InputAudioTrack[] = [];
+
+	constructor(input: Input) {
+		super(input);
+
+		this.metadataReader = new RiffReader(input._mainReader);
+		this.chunkReader = new RiffReader(new Reader(input.source, 64 * 2 ** 20));
+	}
+
+	async readMetadata() {
+		return this.metadataPromise ??= (async () => {
+			const actualFileSize = await this.metadataReader.reader.source.getSize();
+
+			const riffType = this.metadataReader.readAscii(4);
+			this.metadataReader.littleEndian = riffType === 'RIFF';
+
+			const totalFileSize = Math.min(this.metadataReader.readU32() + 8, actualFileSize);
+			const format = this.metadataReader.readAscii(4);
+
+			if (format !== 'WAVE') {
+				throw new Error('Invalid WAVE file - wrong format');
+			}
+
+			this.metadataReader.pos = 12;
+			while (this.metadataReader.pos < totalFileSize) {
+				await this.metadataReader.reader.loadRange(this.metadataReader.pos, this.metadataReader.pos + 8);
+
+				const chunkId = this.metadataReader.readAscii(4);
+				const chunkSize = this.metadataReader.readU32();
+				const startPos = this.metadataReader.pos;
+
+				if (chunkId === 'fmt ') {
+					await this.parseFmtChunk(chunkSize);
+				} else if (chunkId === 'data') {
+					this.dataStart = this.metadataReader.pos;
+					this.dataSize = Math.min(chunkSize, totalFileSize - this.dataStart);
+				}
+
+				this.metadataReader.pos = startPos + chunkSize + (chunkSize & 1); // Handle padding
+			}
+
+			if (!this.audioInfo) {
+				throw new Error('Invalid WAVE file - missing "fmt " chunk');
+			}
+			if (this.dataStart === -1) {
+				throw new Error('Invalid WAVE file - missing "data" chunk');
+			}
+
+			const blockSize = this.audioInfo.blockSizeInBytes;
+			this.dataSize = Math.floor(this.dataSize / blockSize) * blockSize;
+
+			this.tracks.push(new InputAudioTrack(new WaveAudioTrackBacking(this)));
+		})();
+	}
+
+	private async parseFmtChunk(size: number) {
+		await this.metadataReader.reader.loadRange(this.metadataReader.pos, this.metadataReader.pos + size);
+
+		let formatTag = this.metadataReader.readU16();
+		const numChannels = this.metadataReader.readU16();
+		const sampleRate = this.metadataReader.readU32();
+		this.metadataReader.pos += 4; // Bytes per second
+		const blockAlign = this.metadataReader.readU16();
+
+		let bitsPerSample: number;
+
+		if (size === 14) { // Plain WAVEFORMAT
+			bitsPerSample = 8;
+		} else {
+			bitsPerSample = this.metadataReader.readU16();
+		}
+
+		// Handle WAVEFORMATEXTENSIBLE
+		if (size >= 18 && formatTag !== 0x0165) {
+			const cbSize = this.metadataReader.readU16();
+			const remainingSize = size - 18;
+			const extensionSize = Math.min(remainingSize, cbSize);
+
+			if (extensionSize >= 22 && formatTag === WaveFormat.EXTENSIBLE) {
+				// Parse WAVEFORMATEXTENSIBLE
+				this.metadataReader.pos += 2 + 4;
+				const subFormat = this.metadataReader.readBytes(16);
+
+				// Get actual format from subFormat GUID
+				formatTag = subFormat[0]! | (subFormat[1]! << 8);
+			}
+		}
+
+		if (formatTag === WaveFormat.MULAW || formatTag === WaveFormat.ALAW) {
+			bitsPerSample = 8;
+		}
+
+		this.audioInfo = {
+			format: formatTag,
+			numberOfChannels: numChannels,
+			sampleRate,
+			sampleSizeInBytes: Math.ceil(bitsPerSample / 8),
+			blockSizeInBytes: blockAlign,
+		};
+	}
+
+	getCodec(): AudioCodec | null {
+		assert(this.audioInfo);
+
+		if (this.audioInfo.format === WaveFormat.MULAW) {
+			return 'ulaw';
+		}
+		if (this.audioInfo.format === WaveFormat.ALAW) {
+			return 'alaw';
+		}
+		if (this.audioInfo.format === WaveFormat.PCM) {
+			// All formats are little-endian
+			if (this.audioInfo.sampleSizeInBytes === 1) {
+				return 'pcm-u8';
+			} else if (this.audioInfo.sampleSizeInBytes === 2) {
+				return 'pcm-s16';
+			} else if (this.audioInfo.sampleSizeInBytes === 3) {
+				return 'pcm-s24';
+			} else if (this.audioInfo.sampleSizeInBytes === 4) {
+				return 'pcm-s32';
+			}
+		}
+		if (this.audioInfo.format === WaveFormat.IEEE_FLOAT) {
+			if (this.audioInfo.sampleSizeInBytes === 4) {
+				return 'pcm-f32';
+			}
+		}
+
+		return null;
+	}
+
+	async getMimeType() {
+		return 'audio/wav';
+	}
+
+	async computeDuration() {
+		await this.readMetadata();
+		assert(this.audioInfo);
+
+		const numberOfBlocks = this.dataSize / this.audioInfo.blockSizeInBytes;
+		return numberOfBlocks / this.audioInfo.sampleRate;
+	}
+
+	async getTracks() {
+		await this.readMetadata();
+		return this.tracks;
+	}
+}
+
+const PACKET_SIZE_IN_FRAMES = 2048;
+
+class WaveAudioTrackBacking implements InputAudioTrackBacking {
+	constructor(public demuxer: WaveDemuxer) {}
+
+	getId() {
+		return 1;
+	}
+
+	getCodec() {
+		return this.demuxer.getCodec();
+	}
+
+	async getDecoderConfig(): Promise<AudioDecoderConfig | null> {
+		const codec = this.demuxer.getCodec();
+		if (!codec) {
+			return null;
+		}
+
+		assert(this.demuxer.audioInfo);
+		return {
+			codec,
+			numberOfChannels: this.demuxer.audioInfo.numberOfChannels,
+			sampleRate: this.demuxer.audioInfo.sampleRate,
+		};
+	}
+
+	computeDuration() {
+		return this.demuxer.computeDuration();
+	}
+
+	getNumberOfChannels() {
+		assert(this.demuxer.audioInfo);
+		return this.demuxer.audioInfo.numberOfChannels;
+	}
+
+	getSampleRate() {
+		assert(this.demuxer.audioInfo);
+		return this.demuxer.audioInfo.sampleRate;
+	}
+
+	getTimeResolution() {
+		assert(this.demuxer.audioInfo);
+		return this.demuxer.audioInfo.sampleRate;
+	}
+
+	getLanguageCode() {
+		return UNDETERMINED_LANGUAGE;
+	}
+
+	async getFirstTimestamp() {
+		return 0;
+	}
+
+	private async getPacketAtIndex(
+		packetIndex: number,
+		options: PacketRetrievalOptions,
+	): Promise<EncodedPacket | null> {
+		assert(this.demuxer.audioInfo);
+		const startOffset = packetIndex * PACKET_SIZE_IN_FRAMES * this.demuxer.audioInfo.blockSizeInBytes;
+		if (startOffset >= this.demuxer.dataSize) {
+			return null;
+		}
+
+		const sizeInBytes = Math.min(
+			PACKET_SIZE_IN_FRAMES * this.demuxer.audioInfo.blockSizeInBytes,
+			this.demuxer.dataSize - startOffset,
+		);
+
+		let data: Uint8Array;
+		if (options.metadataOnly) {
+			data = PLACEHOLDER_DATA;
+		} else {
+			const sizeOfOnePacket = PACKET_SIZE_IN_FRAMES * this.demuxer.audioInfo.blockSizeInBytes;
+			const chunkSize = Math.ceil(2 ** 19 / sizeOfOnePacket) * sizeOfOnePacket;
+			const chunkStart = Math.floor(startOffset / chunkSize) * chunkSize;
+			const chunkEnd = chunkStart + chunkSize;
+
+			// Always load large 0.5 MiB chunks instead of just the required packet
+			await this.demuxer.chunkReader.reader.loadRange(
+				this.demuxer.dataStart + chunkStart,
+				this.demuxer.dataStart + chunkEnd,
+			);
+
+			this.demuxer.chunkReader.pos = this.demuxer.dataStart + startOffset;
+			data = this.demuxer.chunkReader.readBytes(sizeInBytes);
+		}
+
+		const timestamp = packetIndex * PACKET_SIZE_IN_FRAMES / this.demuxer.audioInfo.sampleRate;
+		const duration = sizeInBytes / this.demuxer.audioInfo.blockSizeInBytes / this.demuxer.audioInfo.sampleRate;
+
+		return new EncodedPacket(
+			data,
+			'key',
+			timestamp,
+			duration,
+			packetIndex,
+			sizeInBytes,
+		);
+	}
+
+	getFirstPacket(options: PacketRetrievalOptions) {
+		return this.getPacketAtIndex(0, options);
+	}
+
+	getPacket(timestamp: number, options: PacketRetrievalOptions) {
+		assert(this.demuxer.audioInfo);
+		const packetIndex = Math.floor(timestamp * this.demuxer.audioInfo.sampleRate / PACKET_SIZE_IN_FRAMES);
+
+		return this.getPacketAtIndex(packetIndex, options);
+	}
+
+	getNextPacket(packet: EncodedPacket, options: PacketRetrievalOptions) {
+		assert(this.demuxer.audioInfo);
+		const packetIndex = Math.round(packet.timestamp * this.demuxer.audioInfo.sampleRate / PACKET_SIZE_IN_FRAMES);
+
+		return this.getPacketAtIndex(packetIndex + 1, options);
+	}
+
+	getKeyPacket(timestamp: number, options: PacketRetrievalOptions) {
+		return this.getPacket(timestamp, options);
+	}
+
+	getNextKeyPacket(packet: EncodedPacket, options: PacketRetrievalOptions) {
+		return this.getNextPacket(packet, options);
+	}
+}

package/src/wave/wave-muxer.ts

@@ -0,0 +1,145 @@
+/*!
+ * Copyright (c) 2025-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 { Muxer } from '../muxer';
+import { Output, OutputAudioTrack } from '../output';
+import { parsePcmCodec, PcmAudioCodec, validateAudioChunkMetadata } from '../codec';
+import { WaveFormat } from './wave-demuxer';
+import { RiffWriter } from './riff-writer';
+import { Writer } from '../writer';
+import { EncodedPacket } from '../packet';
+import { WavOutputFormat } from '../output-format';
+import { assert } from '../misc';
+
+export class WaveMuxer extends Muxer {
+	private format: WavOutputFormat;
+	private writer: Writer;
+	private riffWriter: RiffWriter;
+	private headerWritten = false;
+	private dataSize = 0;
+
+	constructor(output: Output, format: WavOutputFormat) {
+		super(output);
+
+		this.format = format;
+		this.writer = output._writer;
+		this.riffWriter = new RiffWriter(output._writer);
+	}
+
+	async start() {
+		// Nothing needed here - we'll write the header with the first sample
+	}
+
+	async getMimeType() {
+		return 'audio/wav';
+	}
+
+	async addEncodedVideoPacket() {
+		throw new Error('WAVE does not support video.');
+	}
+
+	async addEncodedAudioPacket(
+		track: OutputAudioTrack,
+		packet: EncodedPacket,
+		meta?: EncodedAudioChunkMetadata,
+	) {
+		const release = await this.mutex.acquire();
+
+		try {
+			if (!this.headerWritten) {
+				validateAudioChunkMetadata(meta);
+
+				assert(meta);
+				assert(meta.decoderConfig);
+
+				this.writeHeader(track, meta.decoderConfig);
+				this.headerWritten = true;
+			}
+
+			this.validateAndNormalizeTimestamp(track, packet.timestamp, packet.type === 'key');
+
+			this.writer.write(packet.data);
+			this.dataSize += packet.data.byteLength;
+
+			await this.writer.flush();
+		} finally {
+			release();
+		}
+	}
+
+	async addSubtitleCue() {
+		throw new Error('WAVE does not support subtitles.');
+	}
+
+	private writeHeader(track: OutputAudioTrack, config: AudioDecoderConfig) {
+		if (this.format._options.onHeader) {
+			this.writer.startTrackingWrites();
+		}
+
+		let format: WaveFormat;
+
+		const codec = track.source._codec;
+		const pcmInfo = parsePcmCodec(codec as PcmAudioCodec);
+
+		if (pcmInfo.dataType === 'ulaw') {
+			format = WaveFormat.MULAW;
+		} else if (pcmInfo.dataType === 'alaw') {
+			format = WaveFormat.ALAW;
+		} else if (pcmInfo.dataType === 'float') {
+			format = WaveFormat.IEEE_FLOAT;
+		} else {
+			format = WaveFormat.PCM;
+		}
+
+		const channels = config.numberOfChannels;
+		const sampleRate = config.sampleRate;
+		const blockSize = pcmInfo.sampleSize * channels;
+
+		// RIFF header
+		this.riffWriter.writeAscii('RIFF');
+		this.riffWriter.writeU32(0); // File size placeholder
+		this.riffWriter.writeAscii('WAVE');
+
+		// fmt chunk
+		this.riffWriter.writeAscii('fmt ');
+		this.riffWriter.writeU32(16); // Chunk size
+		this.riffWriter.writeU16(format);
+		this.riffWriter.writeU16(channels);
+		this.riffWriter.writeU32(sampleRate);
+		this.riffWriter.writeU32(sampleRate * blockSize); // Bytes per second
+		this.riffWriter.writeU16(blockSize);
+		this.riffWriter.writeU16(8 * pcmInfo.sampleSize);
+
+		// data chunk
+		this.riffWriter.writeAscii('data');
+		this.riffWriter.writeU32(0); // Data size placeholder
+
+		if (this.format._options.onHeader) {
+			const { data, start } = this.writer.stopTrackingWrites();
+			this.format._options.onHeader(data, start);
+		}
+	}
+
+	async finalize() {
+		const release = await this.mutex.acquire();
+
+		const endPos = this.writer.getPos();
+
+		// Write file size
+		this.writer.seek(4);
+		this.riffWriter.writeU32(this.dataSize + 36); // File size - 8
+
+		// Write data chunk size
+		this.writer.seek(40);
+		this.riffWriter.writeU32(this.dataSize);
+
+		this.writer.seek(endPos);
+
+		release();
+	}
+}