echogarden 0.12.2 → 1.0.0

package/src/dsp/FFT.ts

@@ -1,16 +1,21 @@
-import { RawAudio } from "../audio/AudioUtilities.js"
-import { concatFloat32Arrays } from "../utilities/Utilities.js"
-import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js"
+import { RawAudio } from '../audio/AudioUtilities.js'
+import { ComplexNumber, sumVector } from '../math/VectorMath.js'
+import { concatFloat32Arrays } from '../utilities/Utilities.js'
+import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
 
 let kissFFTInstance: any
 
-export async function stftr(samples: Float32Array, fftOrder: number, windowSize: number, hopLength: number, windowType: WindowType) {
+export async function stftr(samples: Float32Array, fftOrder: number, windowSize: number, hopSize: number, windowType: WindowType) {
 	if (fftOrder % 2 != 0 || windowSize % 2 != 0) {
-		throw new Error("FFT order and window size must multiples of 2")
+		throw new Error('FFT order and window size must multiples of 2')
 	}
 
 	if (windowSize > fftOrder) {
-		throw new Error("Window size must be lesser or equal to the FFT order")
+		throw new Error('Window size must be lesser or equal to the FFT size')
+	}
+
+	if (hopSize > windowSize) {
+		throw new Error('Hop size must be lesser or equal to the window size')
 	}
 
 	const halfWindowSize = windowSize / 2
@@ -32,7 +37,7 @@ export async function stftr(samples: Float32Array, fftOrder: number, windowSize:
 
 	const frames: Float32Array[] = []
 
-	for (let offset = 0; offset < sampleCount; offset += hopLength) {
+	for (let offset = 0; offset < sampleCount; offset += hopSize) {
 		const windowSamples = samples.subarray(offset, offset + windowSize)
 		frameBufferRef.clear()
 
@@ -54,53 +59,77 @@ export async function stftr(samples: Float32Array, fftOrder: number, windowSize:
 	return frames
 }
 
-export async function stiftr(binsForFrames: Float32Array[], fftOrder: number, windowSize: number, hopSize: number, windowType: WindowType, expectedOutputLength: number) {
+export async function stiftr(binsForFrames: Float32Array[], fftOrder: number, windowSize: number, hopSize: number, windowType: WindowType, expectedOutputLength?: number) {
 	if (fftOrder % 2 != 0 || windowSize % 2 != 0) {
-		throw new Error("FFT order and window size must multiples of 2")
+		throw new Error('FFT order and window size must multiples of 2')
 	}
 
 	if (windowSize > fftOrder) {
-		throw new Error("Window size must be lesser or equal to the FFT order")
+		throw new Error('Window size must be lesser or equal to the FFT size')
 	}
 
+	if (hopSize > windowSize) {
+		throw new Error('Hop size must be lesser or equal to the window size')
+	}
+
+	const frameCount = binsForFrames.length
+
 	const halfWindowSize = windowSize / 2
 
-	if (hopSize != halfWindowSize) {
-		throw new Error("To perform inverse short-time FFT, hop size must be half the window size")
-	}
+	const windowWeights = getWindowWeights(windowType, windowSize)
+
+	const outSampleCount = hopSize * frameCount
 
-	if (windowType != "hann") {
-		throw new Error("Only Hann window is currently supported for inverse short-time FFT")
+	if (expectedOutputLength == null) {
+		expectedOutputLength = outSampleCount
 	}
 
+	const outSamples = new Float32Array(outSampleCount)
+
 	const m = await getKissFFTInstance()
 	const wasmMemory = new WasmMemoryManager(m)
 
 	const statePtr = m._kiss_fftr_alloc(fftOrder, 1, 0, 0)
 	wasmMemory.wrapPointer(statePtr)
 
-	const outSamples = new Float32Array(binsForFrames.length * hopSize)
-
 	const frameBufferRef = wasmMemory.allocFloat32Array(fftOrder)
 	const binsRef = wasmMemory.allocFloat32Array(fftOrder * 2)
 
-	for (let frameIndex = 0, writeOffset = 0; frameIndex < binsForFrames.length; frameIndex++, writeOffset += hopSize) {
-		const bins = binsForFrames[frameIndex]
+	const sumOfSquaredWeightsForSample = new Float32Array(outSampleCount)
+
+	for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+		const binsForFrame = binsForFrames[frameIndex]
 		binsRef.clear()
-		binsRef.view.set(bins)
+		binsRef.view.set(binsForFrame)
 
 		frameBufferRef.clear()
 		m._kiss_fftri(statePtr, binsRef.address, frameBufferRef.address)
-
 		const frameSamples = frameBufferRef.view
-		for (let i = 0; i < windowSize; i++) {
-			outSamples[writeOffset + i] += frameSamples[i]
+
+		const frameStartOffset = frameIndex * hopSize
+
+		for (let windowOffset = 0; windowOffset < windowSize; windowOffset++) {
+			const frameSample = frameSamples[windowOffset]
+			const weight = windowWeights[windowOffset]
+
+			const writePosition = frameStartOffset + windowOffset
+
+			outSamples[writePosition] += frameSample * weight
+
+			sumOfSquaredWeightsForSample[writePosition] += weight ** 2
 		}
 	}
 
 	wasmMemory.freeAll()
 
-	return outSamples.subarray(halfWindowSize, halfWindowSize + expectedOutputLength)
+	// Divide by sum of weight squares for each samples
+	for (let i = 0; i < outSamples.length; i++) {
+		outSamples[i] /= sumOfSquaredWeightsForSample[i] + 1e-8
+	}
+
+	const outSamplesTrimmed = outSamples.slice(halfWindowSize, halfWindowSize + expectedOutputLength)
+
+	return outSamplesTrimmed
 }
 
 export function getBinFrequencies(binCount: number, maxFrequency: number) {
@@ -133,6 +162,45 @@ export function fftFrameToPowerSpectrum(fftFrame: Float32Array) {
 	return powerSpectrum
 }
 
+export function binBufferToComplex(bins: Float32Array, extendAndMirror = false) {
+	const complexBins: ComplexNumber[] = []
+
+	for (let i = 0; i < bins.length; i += 2) {
+		complexBins.push({
+			real: bins[i],
+			imaginary: bins[i + 1]
+		})
+	}
+
+	if (extendAndMirror) {
+		const fftSize = bins.length - 2
+
+		for (let i = complexBins.length; i < fftSize; i++) {
+			const complexBinToMirror = complexBins[fftSize - i]
+
+			complexBins.push({
+				real: complexBinToMirror.real,
+				imaginary: -complexBinToMirror.imaginary
+			})
+		}
+	}
+
+	return complexBins
+}
+
+export function complexToBinBuffer(complexBins: ComplexNumber[]) {
+	const binBuffer = new Float32Array(complexBins.length * 2)
+
+	for (let i = 0, outIndex = 0; i < complexBins.length; i++) {
+		const complexBin = complexBins[i]
+
+		binBuffer[outIndex++] = complexBin.real
+		binBuffer[outIndex++] = complexBin.imaginary
+	}
+
+	return binBuffer
+}
+
 export async function getKissFFTInstance() {
 	if (!kissFFTInstance) {
 		const { default: initializer } = await import('@echogarden/kissfft-wasm')
@@ -143,20 +211,20 @@ export async function getKissFFTInstance() {
 	return kissFFTInstance
 }
 
-function getWindowWeights(windowType: WindowType, windowSize: number) {
+export function getWindowWeights(windowType: WindowType, windowSize: number) {
 	const weights = new Float32Array(windowSize)
 
-	if (windowType == "hann") {
-		//const innerMultiplier = (2 * Math.PI) / (windowSize - 1)
+	const innerFactor = (2 * Math.PI) / (windowSize - 1)
 
+	if (windowType == 'hann') {
 		for (let i = 0; i < windowSize; i++) {
-			weights[i] = 0.5 * (1 - Math.cos(2 * Math.PI * (i / (windowSize - 1))))
-			//weights[i] = 0.5 * (1 - Math.cos(innerMultiplier * i))
+			//weights[i] = 0.5 * (1 - Math.cos(2 * Math.PI * (i / (windowSize - 1))))
+			weights[i] = 0.5 * (1 - Math.cos(innerFactor * i))
 		}
-	} else if (windowType == "hamming") {
+	} else if (windowType == 'hamming') {
 		for (let i = 0; i < windowSize; i++) {
-			weights[i] = 0.54 - (0.46 * Math.cos(2 * Math.PI * (i / (windowSize - 1))))
-			//weights[i] = 0.54 - (0.46 * Math.cos(i * innerMultiplier))
+			//weights[i] = 0.54 - (0.46 * Math.cos(2 * Math.PI * (i / (windowSize - 1))))
+			weights[i] = 0.54 - (0.46 * Math.cos(innerFactor * i))
 		}
 	} else {
 		throw new Error(`Unsupported window function type: ${windowType}`)
@@ -166,14 +234,14 @@ function getWindowWeights(windowType: WindowType, windowSize: number) {
 }
 
 export async function testFFT1(rawAudio: RawAudio) {
-	const { resampleAudioSpeex } = await import("./SpeexResampler.js")
+	const { resampleAudioSpeex } = await import('./SpeexResampler.js')
 
 	const samples = (await resampleAudioSpeex(rawAudio, 16000)).audioChannels[0]
 
 	const fftOrder = 512
 	const windowSize = 320
 	const hopLength = windowSize / 2
-	const windowType: WindowType = "hann"
+	const windowType: WindowType = 'hann'
 
 	const bins = await stftr(samples, fftOrder, windowSize, hopLength, windowType)
 	const normalizedBins = bins.map(bin => bin.map(x => x / fftOrder))
@@ -184,4 +252,4 @@ export async function testFFT1(rawAudio: RawAudio) {
 	return recoveredRawAudio
 }
 
-export type WindowType = "hann" | "hamming"
+export type WindowType = 'hann' | 'hamming'

package/src/dsp/KWeightingFilter.ts

@@ -0,0 +1,43 @@
+import { BiquadFilter, createHighpassFilter, createHighshelfFilter } from './BiquadFilter.js';
+
+export class KWeightingFilter {
+	readonly highShelfFilter: BiquadFilter
+	readonly highPassFilter: BiquadFilter
+
+	constructor(
+		public readonly sampleRate: number,
+		public readonly useStandard44100Filters = false) {
+
+		if (useStandard44100Filters) {
+			// These parameter values are taken from ITU-R BS.1770-2
+			// and designed only for a 44100 Hz sampling rate:
+			this.highShelfFilter = new BiquadFilter({
+				b0: 1.53512485958697,
+				b1: -2.69169618940638,
+				b2: 1.19839281085285,
+				a1: -1.69065929318241,
+				a2: 0.73248077421585,
+			})
+
+			this.highPassFilter = new BiquadFilter({
+				b0: 1.0,
+				b1: -2.0,
+				b2: 1.0,
+				a1: -1.99004745483398,
+				a2: 0.99007225036621,
+			})
+		} else {
+			this.highShelfFilter = createHighshelfFilter(sampleRate, 2000.0, 4.0)
+			this.highPassFilter = createHighpassFilter(sampleRate, 1.5, 0.01)
+		}
+	}
+
+	process(sample: number): number {
+		let outputSample = sample
+
+		outputSample = this.highShelfFilter.filter(outputSample)
+		outputSample = this.highPassFilter.filter(outputSample)
+
+		return outputSample
+	}
+}

package/src/dsp/LoudnessEstimator.ts

@@ -0,0 +1,74 @@
+import { decibelsToGainFactor, gainFactorToDecibels } from '../audio/AudioUtilities.js';
+import { SmoothEstimator } from '../utilities/SmoothEstimator.js';
+import { KWeightingFilter } from './KWeightingFilter.js';
+
+export class LoudnessEstimator {
+	readonly channelFilters: KWeightingFilter[] = []
+	readonly channelMeanSquares: SmoothEstimator[] = []
+
+	readonly minPower: number
+
+	constructor(public readonly options: LoudnessEstimatorOptions) {
+		const initialMeanSquares = decibelsToGainFactor(options.initialEstimate) ** 2
+
+		const ticksPerSecond = this.options.sampleRate * this.options.channelCount
+
+		for (let i = 0; i < options.channelCount; i++) {
+			const weightingFilter =
+				new KWeightingFilter(options.sampleRate)
+
+			const channelMeanSquares =
+				new SmoothEstimator(options.positiveAdaptationRate / ticksPerSecond, options.negativeAdaptationRate / ticksPerSecond, initialMeanSquares)
+
+			this.channelFilters.push(weightingFilter)
+			this.channelMeanSquares.push(channelMeanSquares)
+		}
+
+		this.minPower = decibelsToGainFactor(options.minimumLoudness) ** 2
+	}
+
+	process(sample: number, channel: number) {
+		let filteredSample: number
+
+		if (this.options.applyKWeighting) {
+			filteredSample = this.channelFilters[channel].process(sample)
+		} else {
+			filteredSample = sample
+		}
+
+		const filteredSampleSquared = filteredSample ** 2
+
+		const channelMeanSquares = this.channelMeanSquares[channel]
+
+		channelMeanSquares.update(filteredSampleSquared)
+
+		channelMeanSquares.estimate = Math.max(channelMeanSquares.estimate, this.minPower)
+	}
+
+	get currentLoudness() {
+		let totalMeanSquares = 0
+
+		for (let i = 0; i < this.options.channelCount; i++) {
+			totalMeanSquares += this.channelMeanSquares[i].estimate
+		}
+
+		const rms = Math.sqrt(totalMeanSquares / this.options.channelCount)
+		const rmsDecibels = gainFactorToDecibels(rms)
+
+		return rmsDecibels
+	}
+
+	getCurrentRMSForChannel(channel: number) {
+		return Math.sqrt(this.channelMeanSquares[channel].estimate)
+	}
+}
+
+export interface LoudnessEstimatorOptions {
+	sampleRate: number
+	channelCount: number
+	positiveAdaptationRate: number
+	negativeAdaptationRate: number
+	initialEstimate: number
+	minimumLoudness: number
+	applyKWeighting: boolean
+}

package/src/dsp/MFCC.ts

@@ -1,16 +1,16 @@
-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"
+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")
+	logger.start('Initialize options')
 
 	if (monoAudio.audioChannels.length != 1) {
-		throw new Error("Audio must be mono")
+		throw new Error('Audio must be mono')
 	}
 
 	options = extendDefaultMfccOptions(options)
@@ -39,20 +39,20 @@ export async function computeMFCCs(monoAudio: RawAudio, options: MfccOptions = {
 	let mfccs: number[][]
 
 	if (emphasisFactor > 0) {
-		logger.start("Apply emphasis")
+		logger.start('Apply emphasis')
 		resampledAudio.audioChannels[0] = applyEmphasis(resampledAudio.audioChannels[0], emphasisFactor)
 	}
 
-	logger.start("Compute Mel spectogram")
+	logger.start('Compute Mel spectogram')
 	const { melSpectogram } = await computeMelSpectogram(resampledAudio, fftOrder, windowSize, hopLength, filterbankCount, lowerFrequencyHz, upperFrequencyHz)
 
-	logger.start("Extract MFCCs from Mel spectogram")
+	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")
+		logger.start('Normalize MFCCs')
 
 		const { normalizedVectors, mean, stdDeviation } = normalizeVectors(mfccs)
 		mfccs = normalizedVectors
@@ -60,7 +60,7 @@ export async function computeMFCCs(monoAudio: RawAudio, options: MfccOptions = {
 	}
 
 	if (lifteringFactor > 0) {
-		logger.start("Apply liftering to MFCCs")
+		logger.start('Apply liftering to MFCCs')
 		mfccs = applyLiftering(mfccs, lifteringFactor)
 	}
 
@@ -84,13 +84,13 @@ export function melSpectogramToMFCCs(melSpectogram: Float32Array[], mfccFeatureC
 	return mfccs
 }
 
-export function melSpectrumToMFCC(melSpectrum: Float32Array, mfccFeatureCount: number, dctMatrix: Float32Array[], normalization: "none" | "orthonormal" = "orthonormal") {
+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") {
+	if (normalization == 'orthonormal') {
 		firstFeatureNormalizationFactor = Math.sqrt(1 / (4 * mfccFeatureCount))
 		nonfirstFeatureNormalizationFactor = Math.sqrt(1 / (2 * mfccFeatureCount))
 	} else {

package/src/dsp/MelSpectogram.ts

@@ -1,11 +1,11 @@
-import { RawAudio } from "../audio/AudioUtilities.js"
-import { Logger } from "../utilities/Logger.js"
-import * as FFT from "./FFT.js"
+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")
+	logger.start('Compute mel filterbank')
 	const binCount = (fftOrder / 2) + 2
 	const nyquistFrequency = rawAudio.sampleRate / 2
 	const binFrequencies = FFT.getBinFrequencies(binCount, nyquistFrequency)
@@ -24,11 +24,11 @@ export async function computeMelSpectogram(rawAudio: RawAudio, fftOrder: number,
 export async function computeMelSpectogramUsingFilterbanks(rawAudio: RawAudio, fftOrder: number, windowSize: number, hopLength: number, filterbanks: Filterbank[]) {
 	const logger = new Logger()
 
-	logger.start("Compute short-time FFTs")
+	logger.start('Compute short-time FFTs')
 	const audioSamples = rawAudio.audioChannels[0]
-	const fftFrames = await FFT.stftr(audioSamples, fftOrder, windowSize, hopLength, "hann")
+	const fftFrames = await FFT.stftr(audioSamples, fftOrder, windowSize, hopLength, 'hann')
 
-	logger.start("Convert FFT frames to a mel spectogram")
+	logger.start('Convert FFT frames to a mel spectogram')
 	const melSpectogram = fftFramesToMelSpectogram(fftFrames, filterbanks)
 
 	logger.end()

package/src/dsp/Rubberband.ts

@@ -1,7 +1,7 @@
-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"
+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
 
@@ -123,51 +123,51 @@ export async function getRubberbandInstance() {
 export function rubberBandOptionsToFlags(options: RubberbandOptions) {
 	let flags = 0
 
-	if (options.stretch == "precise") {
+	if (options.stretch == 'precise') {
 		flags += RubberBandOptionFlag.StretchPrecise
 	}
 
-	if (options.transients == "mixed") {
+	if (options.transients == 'mixed') {
 		flags += RubberBandOptionFlag.TransientsMixed
-	} else if (options.transients == "smooth") {
+	} else if (options.transients == 'smooth') {
 		flags += RubberBandOptionFlag.TransientsSmooth
 	}
 
-	if (options.detector == "percussive") {
+	if (options.detector == 'percussive') {
 		flags += RubberBandOptionFlag.DetectorPercussive
-	} else if (options.detector == "soft") {
+	} else if (options.detector == 'soft') {
 		flags += RubberBandOptionFlag.DetectorSoft
 	}
 
-	if (options.phase == "independent") {
+	if (options.phase == 'independent') {
 		flags += RubberBandOptionFlag.PhaseIndependent
 	}
 
-	if (options.window == "short") {
+	if (options.window == 'short') {
 		flags += RubberBandOptionFlag.WindowShort
-	} else if (options.window == "long") {
+	} else if (options.window == 'long') {
 		flags += RubberBandOptionFlag.WindowLong
 	}
 
-	if (options.smoothing == "on") {
+	if (options.smoothing == 'on') {
 		flags += RubberBandOptionFlag.SmoothingOn
 	}
 
-	if (options.formant == "preserved") {
+	if (options.formant == 'preserved') {
 		flags += RubberBandOptionFlag.FormantPreserved
 	}
 
-	if (options.pitch == "high-quality") {
+	if (options.pitch == 'high-quality') {
 		flags += RubberBandOptionFlag.PitchHighQuality
-	} else if (options.pitch == "high-consistency") {
+	} else if (options.pitch == 'high-consistency') {
 		flags += RubberBandOptionFlag.PitchHighConsistency
 	}
 
-	if (options.channels == "together") {
+	if (options.channels == 'together') {
 		flags += RubberBandOptionFlag.ChannelsTogether
 	}
 
-	if (options.engine == "finer") {
+	if (options.engine == 'finer') {
 		flags += RubberBandOptionFlag.EngineFiner
 	}
 
@@ -223,27 +223,27 @@ export enum RubberBandPresetOption {
 }
 
 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"
+	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"
+	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

@@ -1,5 +1,5 @@
-import { RawAudio } from "../audio/AudioUtilities.js"
-import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js"
+import { RawAudio } from '../audio/AudioUtilities.js'
+import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
 
 let sonicInstance: any
 
@@ -22,13 +22,13 @@ export async function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchS
 	const writeSuccess = m._sonicWriteFloatToStream(streamPtr, inputSamplesRef.address, inputSampleCount)
 
 	if (writeSuccess != 1) {
-		throw new Error("Sonic error: failed write to stream")
+		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")
+		throw new Error('Sonic error: failed flushing stream')
 	}
 
 	const samplesAvailable = m._sonicSamplesAvailable(streamPtr)

package/src/dsp/SpeexResampler.ts

@@ -1,5 +1,5 @@
-import { RawAudio, cloneRawAudio } from "../audio/AudioUtilities.js"
-import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js"
+import { RawAudio, cloneRawAudio } from '../audio/AudioUtilities.js'
+import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
 
 let speexResamplerInstance: any