@osmo.inc/cli 0.1.15

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

@@ -0,0 +1,391 @@
+/*!
+ * 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 { InputDisposedError } from './input';
+import { assert, clamp, getUint24, MaybePromise, textDecoder, toDataView } from './misc';
+import { DEFAULT_MAX_READ_POSITION, DEFAULT_MIN_READ_POSITION, Source } from './source';
+
+export class Reader {
+	constructor(public source: Source) {}
+
+	get fileSize(): number | null {
+		const size = this.source._getFileSize();
+		if (size === undefined) {
+			throw new Error('Reading file size too early; read required first.');
+		}
+
+		return size;
+	}
+
+	get fileSizeNonStrict() {
+		return this.source._getFileSize() ?? null;
+	}
+
+	requestSlice(start: number, length: number): MaybePromise<FileSlice | null> {
+		if (this.source._disposed) {
+			throw new InputDisposedError();
+		}
+
+		if (start < 0) {
+			return null;
+		}
+
+		if (this.fileSizeNonStrict !== null && start + length > this.fileSizeNonStrict) {
+			return null;
+		}
+
+		if (length === 0) {
+			const buffer = new Uint8Array(0);
+			return new FileSlice(buffer, toDataView(buffer), 0, start, start);
+		}
+
+		const end = start + length;
+		const result = this.source._read(start, end, DEFAULT_MIN_READ_POSITION, DEFAULT_MAX_READ_POSITION);
+
+		if (result instanceof Promise) {
+			return result.then((x) => {
+				if (!x) {
+					return null;
+				}
+
+				return new FileSlice(x.bytes, x.view, x.offset, start, end);
+			});
+		} else {
+			if (!result) {
+				return null;
+			}
+
+			return new FileSlice(result.bytes, result.view, result.offset, start, end);
+		}
+	}
+
+	requestSliceRange(start: number, minLength: number, maxLength: number): MaybePromise<FileSlice | null> {
+		if (this.source._disposed) {
+			throw new InputDisposedError();
+		}
+
+		if (start < 0) {
+			return null;
+		}
+
+		if (this.fileSizeNonStrict !== null) {
+			return this.requestSlice(
+				start,
+				clamp(this.fileSizeNonStrict - start, minLength, maxLength),
+			);
+		} else {
+			const promisedAttempt = this.requestSlice(start, maxLength);
+
+			const handleAttempt = (attempt: FileSlice | null) => {
+				if (attempt) {
+					return attempt;
+				}
+
+				// The slice couldn't fit, meaning we must know the file size now
+				assert(this.fileSizeNonStrict !== null);
+
+				return this.requestSlice(
+					start,
+					clamp(this.fileSizeNonStrict - start, minLength, maxLength),
+				);
+			};
+
+			if (promisedAttempt instanceof Promise) {
+				return promisedAttempt.then(handleAttempt);
+			} else {
+				return handleAttempt(promisedAttempt);
+			}
+		}
+	}
+
+	requestEntireFile(): MaybePromise<FileSlice | null> {
+		if (this.fileSizeNonStrict !== null) {
+			return this.requestSlice(0, this.fileSizeNonStrict);
+		}
+
+		const CHUNK_SIZE = 1024;
+
+		return (async () => {
+			const chunks: Uint8Array[] = [];
+			let currentSize = 0;
+
+			while (true) {
+				if (chunks.length === 1 && this.fileSizeNonStrict !== null) {
+					// It only took one read to get to know the whole file size
+					return this.requestSlice(0, this.fileSizeNonStrict);
+				}
+
+				let slice = this.requestSliceRange(currentSize, 0, CHUNK_SIZE);
+				if (slice instanceof Promise) slice = await slice;
+
+				if (!slice || slice.length === 0) {
+					break;
+				}
+
+				const chunk = readBytes(slice, slice.length);
+				chunks.push(chunk);
+
+				currentSize += slice.length;
+			}
+
+			const joined = new Uint8Array(currentSize);
+			let offset = 0;
+			for (const chunk of chunks) {
+				joined.set(chunk, offset);
+				offset += chunk.length;
+			}
+
+			return new FileSlice(joined, toDataView(joined), 0, 0, currentSize);
+		})();
+	}
+}
+
+export class FileSlice {
+	/** The current position in the backing buffer. Do not modify directly, prefer `.skip()` instead. */
+	bufferPos: number;
+
+	constructor(
+		/** The underlying bytes backing this slice. Avoid using this directly and prefer reader functions instead. */
+		public readonly bytes: Uint8Array,
+		/** A view into the bytes backing this slice. Avoid using this directly and prefer reader functions instead. */
+		public readonly view: DataView,
+		/** The offset in "file bytes" at which `bytes` begins in the file. */
+		private readonly offset: number,
+		/** The offset in "file bytes" where this slice begins. */
+		public readonly start: number,
+		/** The offset in "file bytes" where this slice ends (exclusive). */
+		public readonly end: number,
+	) {
+		this.bufferPos = start - offset;
+	}
+
+	static tempFromBytes(bytes: Uint8Array) {
+		return new FileSlice(
+			bytes,
+			toDataView(bytes),
+			0,
+			0,
+			bytes.length,
+		);
+	}
+
+	get length() {
+		return this.end - this.start;
+	}
+
+	get filePos() {
+		return this.offset + this.bufferPos;
+	}
+
+	set filePos(value: number) {
+		this.bufferPos = value - this.offset;
+	}
+
+	/** The number of bytes left from the current pos to the end of the slice. */
+	get remainingLength() {
+		return Math.max(this.end - this.filePos, 0);
+	}
+
+	skip(byteCount: number) {
+		this.bufferPos += byteCount;
+	}
+
+	/** Creates a new subslice of this slice whose byte range must be contained within this slice. */
+	slice(filePos: number, length = this.end - filePos) {
+		if (filePos < this.start || filePos + length > this.end) {
+			throw new RangeError('Slicing outside of original slice.');
+		}
+
+		return new FileSlice(
+			this.bytes,
+			this.view,
+			this.offset,
+			filePos,
+			filePos + length,
+		);
+	}
+}
+
+const checkIsInRange = (slice: FileSlice, bytesToRead: number) => {
+	if (slice.filePos < slice.start || slice.filePos + bytesToRead > slice.end) {
+		throw new RangeError(
+			`Tried reading [${slice.filePos}, ${slice.filePos + bytesToRead}), but slice is`
+			+ ` [${slice.start}, ${slice.end}). This is likely an internal error, please report it alongside the file`
+			+ ` that caused it.`,
+		);
+	}
+};
+
+export const readBytes = (slice: FileSlice, length: number) => {
+	checkIsInRange(slice, length);
+
+	const bytes = slice.bytes.subarray(slice.bufferPos, slice.bufferPos + length);
+	slice.bufferPos += length;
+
+	return bytes;
+};
+
+export const readU8 = (slice: FileSlice) => {
+	checkIsInRange(slice, 1);
+	return slice.view.getUint8(slice.bufferPos++);
+};
+
+export const readU16 = (slice: FileSlice, littleEndian: boolean) => {
+	checkIsInRange(slice, 2);
+
+	const value = slice.view.getUint16(slice.bufferPos, littleEndian);
+	slice.bufferPos += 2;
+
+	return value;
+};
+
+export const readU16Be = (slice: FileSlice) => {
+	checkIsInRange(slice, 2);
+
+	const value = slice.view.getUint16(slice.bufferPos, false);
+	slice.bufferPos += 2;
+
+	return value;
+};
+
+export const readU24Be = (slice: FileSlice) => {
+	checkIsInRange(slice, 3);
+
+	const value = getUint24(slice.view, slice.bufferPos, false);
+	slice.bufferPos += 3;
+
+	return value;
+};
+
+export const readI16Be = (slice: FileSlice) => {
+	checkIsInRange(slice, 2);
+
+	const value = slice.view.getInt16(slice.bufferPos, false);
+	slice.bufferPos += 2;
+
+	return value;
+};
+
+export const readU32 = (slice: FileSlice, littleEndian: boolean) => {
+	checkIsInRange(slice, 4);
+
+	const value = slice.view.getUint32(slice.bufferPos, littleEndian);
+	slice.bufferPos += 4;
+
+	return value;
+};
+
+export const readU32Be = (slice: FileSlice) => {
+	checkIsInRange(slice, 4);
+
+	const value = slice.view.getUint32(slice.bufferPos, false);
+	slice.bufferPos += 4;
+
+	return value;
+};
+
+export const readU32Le = (slice: FileSlice) => {
+	checkIsInRange(slice, 4);
+
+	const value = slice.view.getUint32(slice.bufferPos, true);
+	slice.bufferPos += 4;
+
+	return value;
+};
+
+export const readI32Be = (slice: FileSlice) => {
+	checkIsInRange(slice, 4);
+
+	const value = slice.view.getInt32(slice.bufferPos, false);
+	slice.bufferPos += 4;
+
+	return value;
+};
+
+export const readI32Le = (slice: FileSlice) => {
+	checkIsInRange(slice, 4);
+
+	const value = slice.view.getInt32(slice.bufferPos, true);
+	slice.bufferPos += 4;
+
+	return value;
+};
+
+export const readU64 = (slice: FileSlice, littleEndian: boolean) => {
+	let low: number;
+	let high: number;
+
+	if (littleEndian) {
+		low = readU32(slice, true);
+		high = readU32(slice, true);
+	} else {
+		high = readU32(slice, false);
+		low = readU32(slice, false);
+	}
+
+	return high * 0x100000000 + low;
+};
+
+export const readU64Be = (slice: FileSlice) => {
+	const high = readU32Be(slice);
+	const low = readU32Be(slice);
+	return high * 0x100000000 + low;
+};
+
+export const readI64Be = (slice: FileSlice) => {
+	const high = readI32Be(slice);
+	const low = readU32Be(slice);
+	return high * 0x100000000 + low;
+};
+
+export const readI64Le = (slice: FileSlice) => {
+	const low = readU32Le(slice);
+	const high = readI32Le(slice);
+	return high * 0x100000000 + low;
+};
+
+export const readF32Be = (slice: FileSlice) => {
+	checkIsInRange(slice, 4);
+
+	const value = slice.view.getFloat32(slice.bufferPos, false);
+	slice.bufferPos += 4;
+
+	return value;
+};
+
+export const readF64Be = (slice: FileSlice) => {
+	checkIsInRange(slice, 8);
+
+	const value = slice.view.getFloat64(slice.bufferPos, false);
+	slice.bufferPos += 8;
+
+	return value;
+};
+
+export const readAscii = (slice: FileSlice, length: number) => {
+	checkIsInRange(slice, length);
+
+	let str = '';
+
+	for (let i = 0; i < length; i++) {
+		str += String.fromCharCode(slice.bytes[slice.bufferPos++]!);
+	}
+
+	return str;
+};
+
+export const readAllLines = (slice: FileSlice, length: number, options?: {
+	ignore?: (line: string) => boolean;
+}) => {
+	const text = textDecoder.decode(readBytes(slice, length));
+	const lines = text.split('\n')
+		.map(x => x.trim())
+		.filter(x => x.length > 0 && !options?.ignore?.(x));
+
+	return lines;
+};

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

@@ -0,0 +1,287 @@
+/*!
+ * 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 { assert } from './misc';
+import { AudioSample } from './sample';
+
+/**
+ * Utility class to handle audio resampling, handling both sample rate resampling as well as channel up/downmixing.
+ * The advantage over doing this manually rather than using OfflineAudioContext to do it for us is the artifact-free
+ * handling of putting multiple resampled audio samples back to back, which produces flaky results using
+ * OfflineAudioContext.
+ */
+export class AudioResampler {
+	sourceSampleRate: number | null = null;
+	targetSampleRate: number;
+	sourceNumberOfChannels: number | null = null;
+	targetNumberOfChannels: number;
+	startTime: number | null = null;
+	onSample: (sample: AudioSample) => Promise<void>;
+
+	bufferSizeInFrames: number;
+	bufferSizeInSamples: number;
+	outputBuffer: Float32Array;
+	/** Start frame of current buffer */
+	bufferStartFrame = 0;
+	/** The highest index written to in the current buffer */
+	maxWrittenFrame: number | null = null;
+	channelMixer!: (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => number;
+	tempSourceBuffer!: Float32Array;
+
+	constructor(options: {
+		targetSampleRate: number;
+		targetNumberOfChannels: number;
+		onSample: (sample: AudioSample) => Promise<void>;
+	}) {
+		this.targetSampleRate = options.targetSampleRate;
+		this.targetNumberOfChannels = options.targetNumberOfChannels;
+		this.onSample = options.onSample;
+
+		this.bufferSizeInFrames = Math.floor(this.targetSampleRate * 5.0); // 5 seconds
+		this.bufferSizeInSamples = this.bufferSizeInFrames * this.targetNumberOfChannels;
+
+		this.outputBuffer = new Float32Array(this.bufferSizeInSamples);
+	}
+
+	/**
+	 * Sets up the channel mixer to handle up/downmixing in the case where input and output channel counts don't match.
+	 */
+	doChannelMixerSetup(): void {
+		assert(this.sourceNumberOfChannels !== null);
+
+		const sourceNum = this.sourceNumberOfChannels;
+		const targetNum = this.targetNumberOfChannels;
+
+		// Logic taken from
+		// https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Basic_concepts_behind_Web_Audio_API
+		// Most of the mapping functions are branchless.
+
+		if (sourceNum === 1 && targetNum === 2) {
+			// Mono to Stereo: M -> L, M -> R
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number) => {
+				return sourceData[sourceFrameIndex * sourceNum]!;
+			};
+		} else if (sourceNum === 1 && targetNum === 4) {
+			// Mono to Quad: M -> L, M -> R, 0 -> SL, 0 -> SR
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => {
+				return sourceData[sourceFrameIndex * sourceNum]! * +(targetChannelIndex < 2);
+			};
+		} else if (sourceNum === 1 && targetNum === 6) {
+			// Mono to 5.1: 0 -> L, 0 -> R, M -> C, 0 -> LFE, 0 -> SL, 0 -> SR
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => {
+				return sourceData[sourceFrameIndex * sourceNum]! * +(targetChannelIndex === 2);
+			};
+		} else if (sourceNum === 2 && targetNum === 1) {
+			// Stereo to Mono: 0.5 * (L + R)
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number) => {
+				const baseIdx = sourceFrameIndex * sourceNum;
+				return 0.5 * (sourceData[baseIdx]! + sourceData[baseIdx + 1]!);
+			};
+		} else if (sourceNum === 2 && targetNum === 4) {
+			// Stereo to Quad: L -> L, R -> R, 0 -> SL, 0 -> SR
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => {
+				return sourceData[sourceFrameIndex * sourceNum + targetChannelIndex]! * +(targetChannelIndex < 2);
+			};
+		} else if (sourceNum === 2 && targetNum === 6) {
+			// Stereo to 5.1: L -> L, R -> R, 0 -> C, 0 -> LFE, 0 -> SL, 0 -> SR
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => {
+				return sourceData[sourceFrameIndex * sourceNum + targetChannelIndex]! * +(targetChannelIndex < 2);
+			};
+		} else if (sourceNum === 4 && targetNum === 1) {
+			// Quad to Mono: 0.25 * (L + R + SL + SR)
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number) => {
+				const baseIdx = sourceFrameIndex * sourceNum;
+				return 0.25 * (
+					sourceData[baseIdx]! + sourceData[baseIdx + 1]!
+					+ sourceData[baseIdx + 2]! + sourceData[baseIdx + 3]!
+				);
+			};
+		} else if (sourceNum === 4 && targetNum === 2) {
+			// Quad to Stereo: 0.5 * (L + SL), 0.5 * (R + SR)
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => {
+				const baseIdx = sourceFrameIndex * sourceNum;
+				return 0.5 * (
+					sourceData[baseIdx + targetChannelIndex]!
+					+ sourceData[baseIdx + targetChannelIndex + 2]!
+				);
+			};
+		} else if (sourceNum === 4 && targetNum === 6) {
+			// Quad to 5.1: L -> L, R -> R, 0 -> C, 0 -> LFE, SL -> SL, SR -> SR
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => {
+				const baseIdx = sourceFrameIndex * sourceNum;
+
+				// It's a bit harder to do this one branchlessly
+				if (targetChannelIndex < 2) return sourceData[baseIdx + targetChannelIndex]!; // L, R
+				if (targetChannelIndex === 2 || targetChannelIndex === 3) return 0; // C, LFE
+				return sourceData[baseIdx + targetChannelIndex - 2]!; // SL, SR
+			};
+		} else if (sourceNum === 6 && targetNum === 1) {
+			// 5.1 to Mono: sqrt(1/2) * (L + R) + C + 0.5 * (SL + SR)
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number) => {
+				const baseIdx = sourceFrameIndex * sourceNum;
+				return Math.SQRT1_2 * (sourceData[baseIdx]! + sourceData[baseIdx + 1]!)
+					+ sourceData[baseIdx + 2]!
+					+ 0.5 * (sourceData[baseIdx + 4]! + sourceData[baseIdx + 5]!);
+			};
+		} else if (sourceNum === 6 && targetNum === 2) {
+			// 5.1 to Stereo: L + sqrt(1/2) * (C + SL), R + sqrt(1/2) * (C + SR)
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => {
+				const baseIdx = sourceFrameIndex * sourceNum;
+				return sourceData[baseIdx + targetChannelIndex]!
+					+ Math.SQRT1_2 * (sourceData[baseIdx + 2]! + sourceData[baseIdx + targetChannelIndex + 4]!);
+			};
+		} else if (sourceNum === 6 && targetNum === 4) {
+			// 5.1 to Quad: L + sqrt(1/2) * C, R + sqrt(1/2) * C, SL, SR
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => {
+				const baseIdx = sourceFrameIndex * sourceNum;
+
+				// It's a bit harder to do this one branchlessly
+				if (targetChannelIndex < 2) {
+					return sourceData[baseIdx + targetChannelIndex]! + Math.SQRT1_2 * sourceData[baseIdx + 2]!;
+				}
+				return sourceData[baseIdx + targetChannelIndex + 2]!; // SL, SR
+			};
+		} else {
+			// Discrete fallback: direct mapping with zero-fill or drop
+			this.channelMixer = (sourceData: Float32Array, sourceFrameIndex: number, targetChannelIndex: number) => {
+				return targetChannelIndex < sourceNum
+					? sourceData[sourceFrameIndex * sourceNum + targetChannelIndex]!
+					: 0;
+			};
+		}
+	}
+
+	ensureTempBufferSize(requiredSamples: number): void {
+		let length = this.tempSourceBuffer.length;
+
+		while (length < requiredSamples) {
+			length *= 2;
+		}
+
+		if (length !== this.tempSourceBuffer.length) {
+			const newBuffer = new Float32Array(length);
+			newBuffer.set(this.tempSourceBuffer);
+			this.tempSourceBuffer = newBuffer;
+		}
+	}
+
+	async add(audioSample: AudioSample) {
+		if (this.sourceSampleRate === null) {
+			// This is the first sample, so let's init the missing data. Initing the sample rate from the decoded
+			// sample is more reliable than using the file's metadata, because decoders are free to emit any sample rate
+			// they see fit.
+			this.sourceSampleRate = audioSample.sampleRate;
+			this.sourceNumberOfChannels = audioSample.numberOfChannels;
+			this.startTime = audioSample.timestamp;
+
+			// Pre-allocate temporary buffer for source data
+			this.tempSourceBuffer = new Float32Array(this.sourceSampleRate * this.sourceNumberOfChannels);
+
+			this.doChannelMixerSetup();
+		}
+
+		assert(this.startTime !== null);
+
+		const requiredSamples = audioSample.numberOfFrames * audioSample.numberOfChannels;
+		this.ensureTempBufferSize(requiredSamples);
+
+		// Copy the audio data to the temp buffer
+		const sourceDataSize = audioSample.allocationSize({ planeIndex: 0, format: 'f32' });
+		const sourceView = new Float32Array(this.tempSourceBuffer.buffer, 0, sourceDataSize / 4);
+		audioSample.copyTo(sourceView, { planeIndex: 0, format: 'f32' });
+
+		const inputStartTime = audioSample.timestamp - this.startTime;
+		const inputEndTime = inputStartTime + audioSample.duration;
+
+		// Compute which output frames are affected by this sample
+		const outputStartFrame = Math.floor((inputStartTime - 1 / this.sourceSampleRate) * this.targetSampleRate) + 1;
+		const outputEndFrame = Math.ceil(inputEndTime * this.targetSampleRate);
+
+		for (let outputFrame = outputStartFrame; outputFrame < outputEndFrame; outputFrame++) {
+			if (outputFrame < this.bufferStartFrame) {
+				continue; // Skip writes to the past
+			}
+
+			while (outputFrame >= this.bufferStartFrame + this.bufferSizeInFrames) {
+				// The write is after the current buffer, so finalize it
+				await this.finalizeCurrentBuffer();
+				this.bufferStartFrame += this.bufferSizeInFrames;
+			}
+
+			const bufferFrameIndex = outputFrame - this.bufferStartFrame;
+			assert(bufferFrameIndex < this.bufferSizeInFrames);
+
+			const outputTime = outputFrame / this.targetSampleRate;
+			const inputTime = outputTime - inputStartTime;
+			const sourcePosition = inputTime * this.sourceSampleRate;
+
+			const sourceLowerFrame = Math.floor(sourcePosition);
+			const sourceUpperFrame = Math.ceil(sourcePosition);
+			const fraction = sourcePosition - sourceLowerFrame;
+
+			// Process each output channel
+			for (let targetChannel = 0; targetChannel < this.targetNumberOfChannels; targetChannel++) {
+				let lowerSample = 0;
+				let upperSample = 0;
+
+				if (sourceLowerFrame >= 0 && sourceLowerFrame < audioSample.numberOfFrames) {
+					lowerSample = this.channelMixer(sourceView, sourceLowerFrame, targetChannel);
+				}
+
+				if (sourceUpperFrame >= 0 && sourceUpperFrame < audioSample.numberOfFrames) {
+					upperSample = this.channelMixer(sourceView, sourceUpperFrame, targetChannel);
+				}
+
+				// For resampling, we do naive linear interpolation to find the in-between sample. This produces
+				// suboptimal results especially for downsampling (for which a low-pass filter would first need to be
+				// applied), but AudioContext doesn't do this either, so, whatever, for now.
+				const outputSample = lowerSample + fraction * (upperSample - lowerSample);
+
+				// Write to output buffer (interleaved)
+				const outputIndex = bufferFrameIndex * this.targetNumberOfChannels + targetChannel;
+				this.outputBuffer[outputIndex]! += outputSample; // Add in case of overlapping samples
+			}
+
+			if (this.maxWrittenFrame === null) {
+				this.maxWrittenFrame = bufferFrameIndex;
+			} else {
+				this.maxWrittenFrame = Math.max(this.maxWrittenFrame, bufferFrameIndex);
+			}
+		}
+	}
+
+	async finalizeCurrentBuffer() {
+		if (this.maxWrittenFrame === null) {
+			return; // Nothing to finalize
+		}
+
+		assert(this.startTime !== null);
+
+		const samplesWritten = (this.maxWrittenFrame + 1) * this.targetNumberOfChannels;
+
+		const outputData = new Float32Array(samplesWritten);
+		outputData.set(this.outputBuffer.subarray(0, samplesWritten));
+
+		const audioSample = new AudioSample({
+			format: 'f32',
+			sampleRate: this.targetSampleRate,
+			numberOfChannels: this.targetNumberOfChannels,
+			timestamp: this.startTime + this.bufferStartFrame / this.targetSampleRate,
+			data: outputData,
+		});
+
+		await this.onSample(audioSample);
+
+		this.outputBuffer.fill(0);
+		this.maxWrittenFrame = null;
+	}
+
+	finalize() {
+		return this.finalizeCurrentBuffer();
+	}
+}