echogarden 0.11.12 → 0.11.13

package/src/dsp/MFCC.ts

@@ -0,0 +1,227 @@
+import { extendDeep } from "../utilities/ObjectUtilities.js"
+import { Logger } from "../utilities/Logger.js"
+import { resampleAudioSpeex } from "./SpeexResampler.js"
+import { computeMelSpectogram } from "./MelSpectogram.js"
+import { RawAudio, powerToDecibels } from "../audio/AudioUtilities.js"
+import { normalizeVectors } from "../math/VectorMath.js"
+
+export async function computeMFCCs(monoAudio: RawAudio, options: MfccOptions = {}) {
+	const logger = new Logger()
+	logger.start("Initialize options")
+
+	if (monoAudio.audioChannels.length != 1) {
+		throw new Error("Audio must be mono")
+	}
+
+	options = extendDefaultMfccOptions(options)
+
+	const analysisSampleRate = options.analysisSampleRate!
+	const featureCount = options.featureCount!
+
+	const fftOrder = options.fftOrder!
+
+	const windowDuration = options.windowDuration!
+	const windowSize = windowDuration * analysisSampleRate
+	const hopDuration = options.hopDuration!
+	const hopLength = hopDuration * analysisSampleRate
+
+	const filterbankCount = options.filterbankCount!
+	const lowerFrequencyHz = options.lowerFreq!
+	const upperFrequencyHz = options.upperFreq!
+
+	const emphasisFactor = options.emphasisFactor!
+	const lifteringFactor = options.lifteringFactor!
+	const zeroFirstCoefficient = options.zeroFirstCoefficient!
+
+	logger.start(`Resample audio to analysis sample rate (${analysisSampleRate}Hz)`)
+	const resampledAudio = await resampleAudioSpeex(monoAudio, analysisSampleRate)
+
+	let mfccs: number[][]
+
+	if (emphasisFactor > 0) {
+		logger.start("Apply emphasis")
+		resampledAudio.audioChannels[0] = applyEmphasis(resampledAudio.audioChannels[0], emphasisFactor)
+	}
+
+	logger.start("Compute Mel spectogram")
+	const { melSpectogram } = await computeMelSpectogram(resampledAudio, fftOrder, windowSize, hopLength, filterbankCount, lowerFrequencyHz, upperFrequencyHz)
+
+	logger.start("Extract MFCCs from Mel spectogram")
+	const mfccsFloat32 = melSpectogramToMFCCs(melSpectogram, featureCount)
+
+	mfccs = mfccsFloat32.map(mfcc => Array.from(mfcc))
+
+	if (options.normalize!) {
+		logger.start("Normalize MFCCs")
+
+		const { normalizedVectors, mean, stdDeviation } = normalizeVectors(mfccs)
+		mfccs = normalizedVectors
+		//mfccs = mfccs.map(mfcc => subtractVectors(mfcc, mean))
+	}
+
+	if (lifteringFactor > 0) {
+		logger.start("Apply liftering to MFCCs")
+		mfccs = applyLiftering(mfccs, lifteringFactor)
+	}
+
+	if (zeroFirstCoefficient) {
+		for (const mfcc of mfccs) {
+			mfcc[0] = 0
+		}
+	}
+
+	logger.end()
+
+	return mfccs
+}
+
+export function melSpectogramToMFCCs(melSpectogram: Float32Array[], mfccFeatureCount: number) {
+	const melBandCount = melSpectogram[0].length
+	const dctMatrix = createDCTType2CoefficientMatrix(mfccFeatureCount, melBandCount)
+
+	const mfccs = melSpectogram.map(frame => melSpectrumToMFCC(frame, mfccFeatureCount, dctMatrix))
+
+	return mfccs
+}
+
+export function melSpectrumToMFCC(melSpectrum: Float32Array, mfccFeatureCount: number, dctMatrix: Float32Array[], normalization: "none" | "orthonormal" = "orthonormal") {
+	const melBandCount = melSpectrum.length
+
+	let firstFeatureNormalizationFactor: number
+	let nonfirstFeatureNormalizationFactor: number
+
+	if (normalization == "orthonormal") {
+		firstFeatureNormalizationFactor = Math.sqrt(1 / (4 * mfccFeatureCount))
+		nonfirstFeatureNormalizationFactor = Math.sqrt(1 / (2 * mfccFeatureCount))
+	} else {
+		firstFeatureNormalizationFactor = 1
+		nonfirstFeatureNormalizationFactor = 1
+	}
+
+	const mfcc = new Float32Array(mfccFeatureCount)
+
+	for (let mfccFeatureIndex = 0; mfccFeatureIndex < mfccFeatureCount; mfccFeatureIndex++) {
+		const dctMatrixRow = dctMatrix[mfccFeatureIndex]
+
+		let sum = 0
+
+		for (let j = 0; j < melBandCount; j++) {
+			const dctCoefficient = dctMatrixRow[j]
+			const logMel = powerToDecibels(melSpectrum[j])
+			//const logMel = Math.log(1e-40 + melSpectrum[j])
+
+			sum += dctCoefficient * logMel
+		}
+
+		const normalizationFactor = mfccFeatureIndex == 0 ? firstFeatureNormalizationFactor : nonfirstFeatureNormalizationFactor
+
+		//mfcc[mfccFeatureIndex] = normalizationFactor * sum
+		mfcc[mfccFeatureIndex] = normalizationFactor * 2 * sum // Sum multiplied by 2 to match with librosa
+	}
+
+	return mfcc
+}
+
+export function createDCTType2CoefficientMatrix(mfccFeatureCount: number, melBandCount: number) {
+	const dctMatrix = new Array<Float32Array>(mfccFeatureCount)
+
+	for (let mfccFeatureIndex = 0; mfccFeatureIndex < mfccFeatureCount; mfccFeatureIndex++) {
+		const row = new Float32Array(melBandCount)
+
+		const innerMultiplier = Math.PI * mfccFeatureIndex / melBandCount
+
+		for (let melBandIndex = 0; melBandIndex < melBandCount; melBandIndex++) {
+			row[melBandIndex] = Math.cos(innerMultiplier * (melBandIndex + 0.5))
+		}
+
+		dctMatrix[mfccFeatureIndex] = row
+	}
+
+	return dctMatrix
+}
+
+export function mfccBufferToVectors(mfccBuffer: Float64Array, mfccFeatureCount: number) {
+	if (mfccBuffer.length % mfccFeatureCount != 0) {
+		throw new Error(`MFCC buffer length is not a multiple of the expected feature count (${mfccFeatureCount})`)
+	}
+
+	const mfccVectors: number[][] = []
+
+	for (let offset = 0; offset < mfccBuffer.length; offset += mfccFeatureCount) {
+		const mfccVector = Array.from(mfccBuffer.subarray(offset, offset + mfccFeatureCount))
+
+		mfccVectors.push(mfccVector)
+	}
+
+	return mfccVectors
+}
+
+export function applyEmphasis(samples: Float32Array, emphasisFactor = 0.97, initialState = 0) {
+	const processedSamples = new Float32Array(samples.length)
+
+	processedSamples[0] = samples[0] - (emphasisFactor * initialState)
+
+	for (let i = 1; i < processedSamples.length; i++) {
+		processedSamples[i] = samples[i] - (emphasisFactor * samples[i - 1])
+	}
+
+	return processedSamples
+}
+
+export function applyLiftering(mfccs: number[][], lifteringFactor: number) {
+	const featureCount = mfccs[0].length
+
+	const lifterMultipliers = new Float32Array(featureCount)
+
+	for (let i = 0; i < featureCount; i++) {
+		lifterMultipliers[i] = 1 + (lifteringFactor / 2) * Math.sin(Math.PI * (i + 1) / lifteringFactor)
+	}
+
+	const lifteredMfccs: number[][] = []
+
+	for (const mfcc of mfccs) {
+		const lifteredMfcc = new Array(featureCount)
+
+		for (let i = 0; i < featureCount; i++) {
+			lifteredMfcc[i] = mfcc[i] * lifterMultipliers[i]
+		}
+
+		lifteredMfccs.push(lifteredMfcc)
+	}
+
+	return lifteredMfccs
+}
+
+export type MfccOptions = {
+	filterbankCount?: number
+	featureCount?: number
+	fftOrder?: number
+	lowerFreq?: number
+	upperFreq?: number
+	windowDuration?: number
+	hopDuration?: number
+	emphasisFactor?: number
+	analysisSampleRate?: number
+	lifteringFactor?: number
+	normalize?: boolean
+	zeroFirstCoefficient?: boolean
+}
+
+export const defaultMfccOptions: MfccOptions = {
+	filterbankCount: 40,
+	featureCount: 13,
+	fftOrder: 512,
+	lowerFreq: 133.3333,
+	upperFreq: 6855.4976,
+	windowDuration: 0.025,
+	hopDuration: 0.010,
+	emphasisFactor: 0.97,
+	analysisSampleRate: 16000,
+	lifteringFactor: 0,
+	normalize: false,
+	zeroFirstCoefficient: false,
+}
+
+export function extendDefaultMfccOptions(options: MfccOptions) {
+	return extendDeep(defaultMfccOptions, options)
+}

package/src/dsp/MelSpectogram.ts

@@ -0,0 +1,145 @@
+import { RawAudio } from "../audio/AudioUtilities.js"
+import { Logger } from "../utilities/Logger.js"
+import * as FFT from "./FFT.js"
+
+export async function computeMelSpectogram(rawAudio: RawAudio, fftOrder: number, windowSize: number, hopLength: number, filterbankCount: number, lowerFrequencyHz: number, upperFrequencyHz: number) {
+	const logger = new Logger()
+
+	logger.start("Compute mel filterbank")
+	const binCount = (fftOrder / 2) + 2
+	const nyquistFrequency = rawAudio.sampleRate / 2
+	const binFrequencies = FFT.getBinFrequencies(binCount, nyquistFrequency)
+
+	const lowerFrequencyMel = hertzToMel(lowerFrequencyHz)
+	const upperFrequencyMel = hertzToMel(upperFrequencyHz)
+
+	const filterbanksCenterFrequencies = getMelFilterbanksCenterFrequencies(filterbankCount, lowerFrequencyMel, upperFrequencyMel)
+	const melFilterbanks = getMelFilterbanks(binFrequencies, filterbanksCenterFrequencies, lowerFrequencyMel, upperFrequencyMel)
+
+	logger.end()
+
+	return computeMelSpectogramUsingFilterbanks(rawAudio, fftOrder, windowSize, hopLength, melFilterbanks)
+}
+
+export async function computeMelSpectogramUsingFilterbanks(rawAudio: RawAudio, fftOrder: number, windowSize: number, hopLength: number, filterbanks: Filterbank[]) {
+	const logger = new Logger()
+
+	logger.start("Compute short-time FFTs")
+	const audioSamples = rawAudio.audioChannels[0]
+	const fftFrames = await FFT.stftr(audioSamples, fftOrder, windowSize, hopLength, "hann")
+
+	logger.start("Convert FFT frames to a mel spectogram")
+	const melSpectogram = fftFramesToMelSpectogram(fftFrames, filterbanks)
+
+	logger.end()
+
+	return { melSpectogram, fftFrames }
+}
+
+export function fftFramesToMelSpectogram(fftFrames: Float32Array[], melFilterbanks: Filterbank[]) {
+	return fftFrames.map(fftFrame => {
+		const powerSpectrum = FFT.fftFrameToPowerSpectrum(fftFrame)
+		return powerSpectrumToMelSpectrum(powerSpectrum, melFilterbanks)
+	})
+}
+
+export function powerSpectrumToMelSpectrum(powerSpectrum: Float32Array, filterbanks: Filterbank[]) {
+	const filterbankCount = filterbanks.length
+	const melSpectrum = new Float32Array(filterbankCount)
+
+	for (let melBandIndex = 0; melBandIndex < filterbankCount; melBandIndex++) {
+		const filterbank = filterbanks[melBandIndex]
+		const filterbankStartIndex = filterbank.startIndex
+		const filterbankWeights = filterbank.weights
+
+		if (filterbankStartIndex == -1) {
+			continue
+		}
+
+		let bandValue = 0
+
+		for (let i = 0; i < filterbankWeights.length; i++) {
+			bandValue += filterbankWeights[i] * powerSpectrum[filterbankStartIndex + i]
+		}
+
+		melSpectrum[melBandIndex] = bandValue
+	}
+
+	return melSpectrum
+}
+
+export function getMelFilterbanks(powerSpectrumFrequenciesHz: Float32Array, centerFrequenciesMel: Float32Array, lowerFrequencyMel: number, upperFrequencyMel: number) {
+	const filterbankCount = centerFrequenciesMel.length
+	const powerSpectrumFrequenciesMel = powerSpectrumFrequenciesHz.map(frequencyHz => hertzToMel(frequencyHz))
+
+	const filterbanks: Filterbank[] = []
+
+	for (let filterbankIndex = 0; filterbankIndex < filterbankCount; filterbankIndex++) {
+		const centerFrequency = centerFrequenciesMel[filterbankIndex]
+
+		const leftFrequency = filterbankIndex > 0 ? centerFrequenciesMel[filterbankIndex - 1] : lowerFrequencyMel
+		const rightFrequency = filterbankIndex < filterbankCount - 1 ? centerFrequenciesMel[filterbankIndex + 1] : upperFrequencyMel
+
+		const width = rightFrequency - leftFrequency
+		const halfWidth = width / 2
+
+		let startIndex = -1
+		let weights: number[] = []
+
+		let weightSum = 0
+
+		for (let powerSpectrumBandIndex = 0; powerSpectrumBandIndex < powerSpectrumFrequenciesMel.length; powerSpectrumBandIndex++) {
+			const powerSpectrumBandFrequencyMel = powerSpectrumFrequenciesMel[powerSpectrumBandIndex]
+
+			let weight = 0
+
+			if (powerSpectrumBandFrequencyMel >= leftFrequency && powerSpectrumBandFrequencyMel <= centerFrequency) {
+				weight = (powerSpectrumBandFrequencyMel - leftFrequency) / halfWidth
+			} else if (powerSpectrumBandFrequencyMel > centerFrequency && powerSpectrumBandFrequencyMel <= rightFrequency) {
+				weight = (rightFrequency - powerSpectrumBandFrequencyMel) / halfWidth
+			}
+
+			if (weight > 0) {
+				if (startIndex == -1) {
+					startIndex = powerSpectrumBandIndex
+				}
+
+				weights.push(weight)
+				weightSum += weight
+			} else if (startIndex != -1) {
+				break
+			}
+		}
+
+		weights = weights.map(weight => weight / weightSum)
+
+		filterbanks.push({ startIndex, weights })
+	}
+
+	return filterbanks
+}
+
+export function getMelFilterbanksCenterFrequencies(melBandCount: number, lowerFrequencyMel: number, upperFrequencyMel: number) {
+	const stepSizeMel = (upperFrequencyMel - lowerFrequencyMel) / (melBandCount + 1)
+
+	const centerFrequencies = new Float32Array(melBandCount)
+
+	for (let i = 0; i < melBandCount; i++) {
+		centerFrequencies[i] = lowerFrequencyMel + ((i + 1) * stepSizeMel)
+	}
+
+	return centerFrequencies
+}
+
+export function hertzToMel(frequency: number) {
+	return 2595.0 * Math.log10(1.0 + (frequency / 700.0))
+}
+
+export function melToHertz(mel: number) {
+	return 700.0 * (Math.pow(10.0, mel / 2595.0) - 1.0)
+}
+
+export type Filterbank = {
+	startIndex: number
+	weights: number[]
+}

package/src/dsp/Rubberband.ts

@@ -0,0 +1,249 @@
+import { RawAudio } from "../audio/AudioUtilities.js"
+import { extendDeep } from "../utilities/ObjectUtilities.js"
+import { concatFloat32Arrays } from "../utilities/Utilities.js"
+import { Float32ArrayRef, WasmMemoryManager } from "../utilities/WasmMemoryManager.js"
+
+let rubberbandInstance: any
+
+export async function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchScale: number, options: RubberbandOptions) {
+	options = extendDeep(defaultRubberbandOptions, options)
+
+	const channels = rawAudio.audioChannels
+	const channelCount = channels.length
+	const sampleCount = channels[0].length
+	const sampleRate = rawAudio.sampleRate
+
+	const m = await getRubberbandInstance()
+	const wasmMemory = new WasmMemoryManager(m)
+
+	const optionFlags = rubberBandOptionsToFlags(options)
+
+	const statePtr = m._rubberband_new(sampleRate, channelCount, optionFlags, 1, 1)
+	m._rubberband_set_time_ratio(statePtr, 1 / speed)
+	m._rubberband_set_pitch_scale(statePtr, pitchScale)
+
+	const samplesRequired = m._rubberband_get_samples_required(statePtr)
+	const bufferSize = Math.min(samplesRequired, sampleCount)
+
+	const bufferChannelPtrsRef = wasmMemory.allocUint32Array(bufferSize)
+	const bufferChannelRefs: Float32ArrayRef[] = []
+
+	for (let i = 0; i < channelCount; i++) {
+		const bufferChannelRef = wasmMemory.allocFloat32Array(bufferSize)
+		bufferChannelPtrsRef.view[i] = bufferChannelRef.address
+
+		bufferChannelRefs.push(bufferChannelRef)
+	}
+
+	m._rubberband_set_expected_input_duration(statePtr, sampleCount)
+
+	//m._rubberband_set_max_process_size(statePtr, bufferSize)
+
+	for (let offset = 0; offset < sampleCount; offset += bufferSize) {
+		let writtenSize: number
+		let isFinal: 0 | 1
+
+		if (sampleCount - offset > bufferSize) {
+			writtenSize = bufferSize
+			isFinal = 0
+		} else {
+			writtenSize = sampleCount - offset
+			isFinal = 1
+		}
+
+		for (let i = 0; i < channelCount; i++) {
+			const samplesToWrite = channels[i].subarray(offset, offset + writtenSize)
+			bufferChannelRefs[i].view.set(samplesToWrite)
+		}
+
+		m._rubberband_study(statePtr, bufferChannelPtrsRef.address, writtenSize, isFinal)
+	}
+
+	const outputAudioChannelChunks: Float32Array[][] = []
+
+	for (let i = 0; i < channelCount; i++) {
+		outputAudioChannelChunks.push([])
+	}
+
+	for (let readOffset = 0; readOffset < sampleCount; readOffset += bufferSize) {
+		let writtenSize: number
+		let isFinal: 0 | 1
+
+		if (sampleCount - readOffset > bufferSize) {
+			writtenSize = bufferSize
+			isFinal = 0
+		} else {
+			writtenSize = sampleCount - readOffset
+			isFinal = 1
+		}
+
+		for (let i = 0; i < channelCount; i++) {
+			const samplesToWrite = channels[i].subarray(readOffset, readOffset + writtenSize)
+			bufferChannelRefs[i].view.set(samplesToWrite)
+		}
+
+		m._rubberband_process(statePtr, bufferChannelPtrsRef.address, writtenSize, isFinal)
+
+		while (true) {
+			const samplesAvailable = m._rubberband_available(statePtr)
+			if (samplesAvailable <= 0) {
+				break
+			}
+
+			const sizeToRead = Math.min(samplesAvailable, bufferSize)
+
+			const readCount = m._rubberband_retrieve(statePtr, bufferChannelPtrsRef.address, sizeToRead)
+
+			for (let i = 0; i < channelCount; i++) {
+				const readSamplesForChannel = bufferChannelRefs[i].view.slice(0, readCount)
+				outputAudioChannelChunks[i].push(readSamplesForChannel)
+			}
+		}
+	}
+
+	m._rubberband_delete(statePtr)
+	wasmMemory.freeAll()
+
+	const outputAudioChannels = outputAudioChannelChunks.map(chunks => concatFloat32Arrays(chunks))
+	const outputRawAudio: RawAudio = { audioChannels: outputAudioChannels, sampleRate }
+
+	return outputRawAudio
+}
+
+export async function getRubberbandInstance() {
+	if (!rubberbandInstance) {
+		const { default: RubberbandInitializer } = await import('@echogarden/rubberband-wasm')
+
+		rubberbandInstance = await RubberbandInitializer()
+	}
+
+	return rubberbandInstance
+}
+
+export function rubberBandOptionsToFlags(options: RubberbandOptions) {
+	let flags = 0
+
+	if (options.stretch == "precise") {
+		flags += RubberBandOptionFlag.StretchPrecise
+	}
+
+	if (options.transients == "mixed") {
+		flags += RubberBandOptionFlag.TransientsMixed
+	} else if (options.transients == "smooth") {
+		flags += RubberBandOptionFlag.TransientsSmooth
+	}
+
+	if (options.detector == "percussive") {
+		flags += RubberBandOptionFlag.DetectorPercussive
+	} else if (options.detector == "soft") {
+		flags += RubberBandOptionFlag.DetectorSoft
+	}
+
+	if (options.phase == "independent") {
+		flags += RubberBandOptionFlag.PhaseIndependent
+	}
+
+	if (options.window == "short") {
+		flags += RubberBandOptionFlag.WindowShort
+	} else if (options.window == "long") {
+		flags += RubberBandOptionFlag.WindowLong
+	}
+
+	if (options.smoothing == "on") {
+		flags += RubberBandOptionFlag.SmoothingOn
+	}
+
+	if (options.formant == "preserved") {
+		flags += RubberBandOptionFlag.FormantPreserved
+	}
+
+	if (options.pitch == "high-quality") {
+		flags += RubberBandOptionFlag.PitchHighQuality
+	} else if (options.pitch == "high-consistency") {
+		flags += RubberBandOptionFlag.PitchHighConsistency
+	}
+
+	if (options.channels == "together") {
+		flags += RubberBandOptionFlag.ChannelsTogether
+	}
+
+	if (options.engine == "finer") {
+		flags += RubberBandOptionFlag.EngineFiner
+	}
+
+	return flags
+}
+
+export enum RubberBandOptionFlag {
+	ProcessOffline = 0x00000000,
+	ProcessRealTime = 0x00000001,
+
+	StretchElastic = 0x00000000,
+	StretchPrecise = 0x00000010,
+
+	TransientsCrisp = 0x00000000,
+	TransientsMixed = 0x00000100,
+	TransientsSmooth = 0x00000200,
+
+	DetectorCompound = 0x00000000,
+	DetectorPercussive = 0x00000400,
+	DetectorSoft = 0x00000800,
+
+	PhaseLaminar = 0x00000000,
+	PhaseIndependent = 0x00002000,
+
+	ThreadingAuto = 0x00000000,
+	ThreadingNever = 0x00010000,
+	ThreadingAlways = 0x00020000,
+
+	WindowStandard = 0x00000000,
+	WindowShort = 0x00100000,
+	WindowLong = 0x00200000,
+
+	SmoothingOff = 0x00000000,
+	SmoothingOn = 0x00800000,
+
+	FormantShifted = 0x00000000,
+	FormantPreserved = 0x01000000,
+
+	PitchHighSpeed = 0x00000000,
+	PitchHighQuality = 0x02000000,
+	PitchHighConsistency = 0x04000000,
+
+	ChannelsApart = 0x00000000,
+	ChannelsTogether = 0x10000000,
+
+	EngineFaster = 0x00000000,
+	EngineFiner = 0x20000000
+}
+
+export enum RubberBandPresetOption {
+	DefaultOptions = 0x00000000,
+	PercussiveOptions = 0x00102000,
+}
+
+export const defaultRubberbandOptions: RubberbandOptions = {
+	stretch: "elastic",
+	transients: "crisp",
+	detector: "compound",
+	phase: "laminar",
+	window: "standard",
+	smoothing: "off",
+	formant: "shited",
+	pitch: "high-speed",
+	channels: "apart",
+	engine: "faster"
+}
+
+export type RubberbandOptions = {
+	stretch?: "elastic" | "precise"
+	transients?: "crisp" | "mixed" | "smooth"
+	detector?: "compound" | "percussive" | "soft"
+	phase?: "laminar" | "independent"
+	window?: "standard" | "long" | "short"
+	smoothing?: "off" | "on"
+	formant?: "shited" | "preserved"
+	pitch?: "high-speed" | "high-quality" | "high-consistency"
+	channels?: "apart" | "together"
+	engine?: "faster" | "finer"
+}

package/src/dsp/Sonic.ts

@@ -0,0 +1,59 @@
+import { RawAudio } from "../audio/AudioUtilities.js"
+import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js"
+
+let sonicInstance: any
+
+export async function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchScale: number) {
+	const sampleRate = rawAudio.sampleRate
+	const channelCount = rawAudio.audioChannels.length
+	const inputSamples = rawAudio.audioChannels[0]
+	const inputSampleCount = rawAudio.audioChannels[0].length
+
+	const m = await getSonicInstance()
+	const wasmMemory = new WasmMemoryManager(m)
+
+	const streamPtr = m._sonicCreateStream(sampleRate, channelCount)
+	m._sonicSetSpeed(streamPtr, speed)
+	m._sonicSetPitch(streamPtr, pitchScale)
+
+	const inputSamplesRef = wasmMemory.allocFloat32Array(inputSampleCount)
+	inputSamplesRef.view.set(inputSamples)
+
+	const writeSuccess = m._sonicWriteFloatToStream(streamPtr, inputSamplesRef.address, inputSampleCount)
+
+	if (writeSuccess != 1) {
+		throw new Error("Sonic error: failed write to stream")
+	}
+
+	const flushSuccess = m._sonicFlushStream(streamPtr)
+
+	if (flushSuccess != 1) {
+		throw new Error("Sonic error: failed flushing stream")
+	}
+
+	const samplesAvailable = m._sonicSamplesAvailable(streamPtr)
+
+	const outputSamplesRef = wasmMemory.allocFloat32Array(samplesAvailable)
+
+	const samplesRead = m._sonicReadFloatFromStream(streamPtr, outputSamplesRef.address, outputSamplesRef.length)
+
+	const outputSamples = outputSamplesRef.view.slice(0, samplesRead)
+
+	const resultAudio: RawAudio = { audioChannels: [outputSamples], sampleRate }
+
+	m._sonicDestroyStream(streamPtr)
+
+	wasmMemory.freeAll()
+
+	return resultAudio
+}
+
+async function getSonicInstance() {
+	if (!sonicInstance) {
+		const { default: SonicInitializer } = await import('@echogarden/sonic-wasm')
+
+		sonicInstance = await SonicInitializer()
+	}
+
+	return sonicInstance
+}