@kenzuya/mediabunny 1.26.0 → 1.28.6

package/src/mp3/mp3-demuxer.ts

@@ -1,383 +0,0 @@
-/*!
- * 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 { DEFAULT_TRACK_DISPOSITION, MetadataTags } from '../metadata';
-import { PacketRetrievalOptions } from '../media-sink';
-import { assert, AsyncMutex, binarySearchExact, binarySearchLessOrEqual, UNDETERMINED_LANGUAGE } from '../misc';
-import { EncodedPacket, PLACEHOLDER_DATA } from '../packet';
-import { FrameHeader, getXingOffset, INFO, XING } from '../../shared/mp3-misc';
-import {
-	ID3_V1_TAG_SIZE,
-	ID3_V2_HEADER_SIZE,
-	parseId3V1Tag,
-	parseId3V2Tag,
-	readId3V2Header,
-} from '../id3';
-import { readNextFrameHeader } 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: FrameHeader | null = null;
-	loadedSamples: Sample[] = []; // All samples from the start of the file to lastLoadedPos
-	metadataTags: MetadataTags | null = null;
-
-	tracks: InputAudioTrack[] = [];
-
-	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.tracks = [new InputAudioTrack(this.input, 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 readNextFrameHeader(this.reader, this.lastLoadedPos, this.reader.fileSize);
-		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
-				return;
-			}
-		}
-
-		if (!this.firstFrameHeader) {
-			this.firstFrameHeader = header;
-		}
-
-		if (header.sampleRate !== this.firstFrameHeader.sampleRate) {
-			console.warn(
-				`MP3 changed sample rate mid-file: ${this.firstFrameHeader.sampleRate} Hz to ${header.sampleRate} Hz.`
-				+ ` Might be a bug, so please report this file.`,
-			);
-		}
-
-		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 getTracks() {
-		await this.readMetadata();
-		return this.tracks;
-	}
-
-	async computeDuration() {
-		await this.readMetadata();
-
-		const track = this.tracks[0];
-		assert(track);
-
-		return track.computeDuration();
-	}
-
-	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) {}
-
-	getId() {
-		return 1;
-	}
-
-	async getFirstTimestamp() {
-		return 0;
-	}
-
-	getTimeResolution() {
-		assert(this.demuxer.firstFrameHeader);
-		return this.demuxer.firstFrameHeader.sampleRate / this.demuxer.firstFrameHeader.audioSamplesInFrame;
-	}
-
-	async computeDuration() {
-		const lastPacket = await this.getPacket(Infinity, { metadataOnly: true });
-		return (lastPacket?.timestamp ?? 0) + (lastPacket?.duration ?? 0);
-	}
-
-	getName() {
-		return null;
-	}
-
-	getLanguageCode() {
-		return UNDETERMINED_LANGUAGE;
-	}
-
-	getCodec(): AudioCodec {
-		return 'mp3';
-	}
-
-	getInternalCodecId() {
-		return null;
-	}
-
-	getNumberOfChannels() {
-		assert(this.demuxer.firstFrameHeader);
-		return this.demuxer.firstFrameHeader.channel === 3 ? 1 : 2;
-	}
-
-	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: this.demuxer.firstFrameHeader.channel === 3 ? 1 : 2,
-			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/src/mp3/mp3-muxer.ts

@@ -1,166 +0,0 @@
-/*!
- * 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 { assert, 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, readFrameHeader, 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;
-		this.writer = output._writer;
-		this.mp3Writer = new Mp3Writer(output._writer);
-	}
-
-	async start() {
-		if (!metadataTagsAreEmpty(this.output._metadataTags)) {
-			const id3Writer = new Id3V2Writer(this.writer);
-			id3Writer.writeId3V2Tag(this.output._metadataTags);
-		}
-	}
-
-	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 = readFrameHeader(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.validateAndNormalizeTimestamp(track, packet.timestamp, packet.type === 'key');
-
-			this.writer.write(packet.data);
-			this.frameCount++;
-
-			await this.writer.flush();
-
-			if (writeXingHeader) {
-				this.framePositions.push(this.writer.getPos());
-			}
-		} 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();
-
-		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));
-			assert(index !== -1 && index < this.framePositions.length);
-
-			const byteOffset = this.framePositions[index]!;
-			toc[i] = 256 * (byteOffset / endPos);
-		}
-
-		this.xingFrameData.frameCount = this.frameCount;
-		this.xingFrameData.fileSize = endPos;
-		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);
-		}
-
-		this.writer.seek(endPos);
-
-		release();
-	}
-}

package/src/mp3/mp3-reader.ts

@@ -1,34 +0,0 @@
-/*!
- * 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 { FRAME_HEADER_SIZE, FrameHeader, readFrameHeader } from '../../shared/mp3-misc';
-import { Reader, readU32Be } from '../reader';
-
-export const readNextFrameHeader = async (reader: Reader, startPos: number, until: number | null): Promise<{
-	header: FrameHeader;
-	startPos: number;
-} | null> => {
-	let currentPos = startPos;
-
-	while (until === null || currentPos < until) {
-		let slice = reader.requestSlice(currentPos, FRAME_HEADER_SIZE);
-		if (slice instanceof Promise) slice = await slice;
-		if (!slice) break;
-
-		const word = readU32Be(slice);
-
-		const result = readFrameHeader(word, reader.fileSize !== null ? reader.fileSize - currentPos : null);
-		if (result.header) {
-			return { header: result.header, startPos: currentPos };
-		}
-
-		currentPos += result.bytesAdvanced;
-	}
-
-	return null;
-};

package/src/mp3/mp3-writer.ts

@@ -1,120 +0,0 @@
-/*!
- * 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 { Writer } from '../writer';
-import {
-	computeMp3FrameSize,
-	getXingOffset,
-	KILOBIT_RATES,
-	XING,
-} from '../../shared/mp3-misc';
-
-export type XingFrameData = {
-	mpegVersionId: number;
-	layer: number;
-	frequencyIndex: number;
-	sampleRate: number;
-	channel: number;
-	modeExtension: number;
-	copyright: number;
-	original: number;
-	emphasis: number;
-
-	frameCount: number | null;
-	fileSize: number | null;
-	toc: Uint8Array | null;
-};
-
-export class Mp3Writer {
-	private helper = new Uint8Array(8);
-	private helperView = new DataView(this.helper.buffer);
-
-	constructor(private writer: Writer) {}
-
-	writeU32(value: number) {
-		this.helperView.setUint32(0, value, false);
-		this.writer.write(this.helper.subarray(0, 4));
-	}
-
-	writeXingFrame(data: XingFrameData) {
-		const startPos = this.writer.getPos();
-
-		const firstByte = 0xff;
-		const secondByte = 0xe0 | (data.mpegVersionId << 3) | (data.layer << 1);
-
-		let lowSamplingFrequency: number;
-		if (data.mpegVersionId & 2) {
-			lowSamplingFrequency = (data.mpegVersionId & 1) ? 0 : 1;
-		} else {
-			lowSamplingFrequency = 1;
-		}
-
-		const padding = 0;
-		const neededBytes = 155;
-
-		let bitrateIndex = -1;
-		const bitrateOffset = lowSamplingFrequency * 16 * 4 + data.layer * 16;
-
-		// Let's find the lowest bitrate for which the frame size is sufficiently large to fit all the data
-		for (let i = 0; i < 16; i++) {
-			const kbr = KILOBIT_RATES[bitrateOffset + i]!;
-			const size = computeMp3FrameSize(lowSamplingFrequency, data.layer, 1000 * kbr, data.sampleRate, padding);
-
-			if (size >= neededBytes) {
-				bitrateIndex = i;
-				break;
-			}
-		}
-
-		if (bitrateIndex === -1) {
-			throw new Error('No suitable bitrate found.');
-		}
-
-		const thirdByte = (bitrateIndex << 4) | (data.frequencyIndex << 2) | padding << 1;
-		const fourthByte = (data.channel << 6)
-			| (data.modeExtension << 4)
-			| (data.copyright << 3)
-			| (data.original << 2)
-			| data.emphasis;
-
-		this.helper[0] = firstByte;
-		this.helper[1] = secondByte;
-		this.helper[2] = thirdByte;
-		this.helper[3] = fourthByte;
-
-		this.writer.write(this.helper.subarray(0, 4));
-
-		const xingOffset = getXingOffset(data.mpegVersionId, data.channel);
-
-		this.writer.seek(startPos + xingOffset);
-		this.writeU32(XING);
-
-		let flags = 0;
-		if (data.frameCount !== null) {
-			flags |= 1;
-		}
-		if (data.fileSize !== null) {
-			flags |= 2;
-		}
-		if (data.toc !== null) {
-			flags |= 4;
-		}
-
-		this.writeU32(flags);
-
-		this.writeU32(data.frameCount ?? 0);
-		this.writeU32(data.fileSize ?? 0);
-		this.writer.write(data.toc ?? new Uint8Array(100));
-
-		const kilobitRate = KILOBIT_RATES[bitrateOffset + bitrateIndex]!;
-		const frameSize = computeMp3FrameSize(
-			lowSamplingFrequency, data.layer, 1000 * kilobitRate, data.sampleRate, padding,
-		);
-		this.writer.seek(startPos + frameSize);
-	}
-}