echogarden 2.6.0 → 2.8.0

package/src/audio/AudioBufferConversion.ts

@@ -1,297 +1,51 @@
-import * as AlawMulaw from 'alawmulaw'
-import * as BinaryArrayConversion from '../utilities/BinaryArrayConversion.js'
-import { BitDepth, SampleFormat } from '../codecs/WaveCodec.js'
+import * as WaveCodec from '@echogarden/wave-codec'
+import { BitDepth, SampleFormat } from '@echogarden/wave-codec'
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 // Low level audio sample conversions
 /////////////////////////////////////////////////////////////////////////////////////////////
 export function encodeToAudioBuffer(audioChannels: Float32Array[], targetBitDepth: BitDepth = 16, targetSampleFormat: SampleFormat = SampleFormat.PCM): Uint8Array {
-	const interleavedChannels = interleaveChannels(audioChannels)
-
-	audioChannels = [] // Zero the array references to allow the GC to free up memory, if possible
-
-	if (targetSampleFormat === SampleFormat.PCM) {
-		if (targetBitDepth === 8) {
-			return BinaryArrayConversion.int8ToBuffer(float32ToInt8Pcm(interleavedChannels))
-		} else if (targetBitDepth === 16) {
-			return BinaryArrayConversion.int16ToBufferLE(float32ToInt16Pcm(interleavedChannels))
-		} else if (targetBitDepth === 24) {
-			return BinaryArrayConversion.int24ToBufferLE(float32ToInt24Pcm(interleavedChannels))
-		} else if (targetBitDepth === 32) {
-			return BinaryArrayConversion.int32ToBufferLE(float32ToInt32Pcm(interleavedChannels))
-		} else {
-			throw new Error(`Unsupported PCM bit depth: ${targetBitDepth}`)
-		}
-	} else if (targetSampleFormat === SampleFormat.Float) {
-		if (targetBitDepth === 32) {
-			return BinaryArrayConversion.float32ToBufferLE(interleavedChannels)
-		} else if (targetBitDepth === 64) {
-			return BinaryArrayConversion.float64ToBufferLE(BinaryArrayConversion.float32Tofloat64(interleavedChannels))
-		} else {
-			throw new Error(`Unsupported float bit depth: ${targetBitDepth}`)
-		}
-	} else if (targetSampleFormat === SampleFormat.Alaw) {
-		if (targetBitDepth === 8) {
-			return AlawMulaw.alaw.encode(float32ToInt16Pcm(interleavedChannels))
-		} else {
-			throw new Error(`Unsupported alaw bit depth: ${targetBitDepth}`)
-		}
-	} else if (targetSampleFormat === SampleFormat.Mulaw) {
-		if (targetBitDepth === 8) {
-			return AlawMulaw.mulaw.encode(float32ToInt16Pcm(interleavedChannels))
-		} else {
-			throw new Error(`Unsupported mulaw bit depth: ${targetBitDepth}`)
-		}
-	} else {
-		throw new Error(`Unsupported audio format: ${targetSampleFormat}`)
-	}
-}
-
-export function decodeToChannels(audioBuffer: Uint8Array, channelCount: number, sourceBitDepth: number, sourceSampleFormat: SampleFormat) {
-	let interleavedChannels: Float32Array
-
-	if (sourceSampleFormat === SampleFormat.PCM) {
-		if (sourceBitDepth === 8) {
-			interleavedChannels = int8PcmToFloat32(BinaryArrayConversion.bufferToInt8(audioBuffer))
-		} else if (sourceBitDepth === 16) {
-			interleavedChannels = int16PcmToFloat32(BinaryArrayConversion.bufferLEToInt16(audioBuffer))
-		} else if (sourceBitDepth === 24) {
-			interleavedChannels = int24PcmToFloat32(BinaryArrayConversion.bufferLEToInt24(audioBuffer))
-		} else if (sourceBitDepth === 32) {
-			interleavedChannels = int32PcmToFloat32(BinaryArrayConversion.bufferLEToInt32(audioBuffer))
-		} else {
-			throw new Error(`Unsupported PCM bit depth: ${sourceBitDepth}`)
-		}
-	} else if (sourceSampleFormat === SampleFormat.Float) {
-		if (sourceBitDepth === 32) {
-			interleavedChannels = BinaryArrayConversion.bufferLEToFloat32(audioBuffer)
-		} else if (sourceBitDepth === 64) {
-			interleavedChannels = BinaryArrayConversion.float64Tofloat32(BinaryArrayConversion.bufferLEToFloat64(audioBuffer))
-		} else {
-			throw new Error(`Unsupported float bit depth: ${sourceBitDepth}`)
-		}
-	} else if (sourceSampleFormat === SampleFormat.Alaw) {
-		if (sourceBitDepth === 8) {
-			interleavedChannels = int16PcmToFloat32(AlawMulaw.alaw.decode(audioBuffer))
-		} else {
-			throw new Error(`Unsupported alaw bit depth: ${sourceBitDepth}`)
-		}
-	} else if (sourceSampleFormat === SampleFormat.Mulaw) {
-		if (sourceBitDepth === 8) {
-			interleavedChannels = int16PcmToFloat32(AlawMulaw.mulaw.decode(audioBuffer))
-		} else {
-			throw new Error(`Unsupported mulaw bit depth: ${sourceBitDepth}`)
-		}
-	} else {
-		throw new Error(`Unsupported audio format: ${sourceSampleFormat}`)
-	}
-
-	audioBuffer = new Uint8Array(0) // Zero the buffer reference to allow the GC to free up memory, if possible
-
-	return deInterleaveChannels(interleavedChannels, channelCount)
+	return WaveCodec.float32ChannelsToBuffer(audioChannels, targetBitDepth, targetSampleFormat)
 }
 
-// Int8 PCM <-> Float32 conversion
-export function int8PcmToFloat32(input: Int8Array) {
-	const sampleCount = input.length
-
-	const output = new Float32Array(sampleCount)
-
-	for (let i = 0; i < sampleCount; i++) {
-		output[i] = input[i] / 128
-	}
-
-	return output
+export function decodeToChannels(audioBuffer: Uint8Array, channelCount: number, sourceBitDepth: BitDepth, sourceSampleFormat: SampleFormat) {
+	return WaveCodec.bufferToFloat32Channels(audioBuffer, channelCount, sourceBitDepth, sourceSampleFormat)
 }
 
-export function float32ToInt8Pcm(input: Float32Array) {
-	const sampleCount = input.length
-
-	const output = new Int8Array(sampleCount)
-
-	for (let i = 0; i < sampleCount; i++) {
-		const int8Sample = input[i] * 128
-
-		if (int8Sample < -128) {
-			output[i] = -128
-		} else if (int8Sample > 127) {
-			output[i] = 127
-		} else {
-			output[i] = int8Sample
-		}
-	}
-
-	return output
+export function float32ToUint8Pcm(input: Float32Array) {
+	return WaveCodec.float32ToUint8Pcm(input)
 }
 
-// Int16 PCM <-> Float32 conversion
 export function int16PcmToFloat32(input: Int16Array) {
-	const sampleCount = input.length
-
-	const output = new Float32Array(sampleCount)
-
-	for (let i = 0; i < sampleCount; i++) {
-		output[i] = input[i] / 32768
-	}
-
-	return output
+	return WaveCodec.int16PcmToFloat32(input)
 }
 
 export function float32ToInt16Pcm(input: Float32Array) {
-	const sampleCount = input.length
-
-	const output = new Int16Array(sampleCount)
-
-	for (let i = 0; i < sampleCount; i++) {
-		const int16Sample = input[i] * 32768
-
-		if (int16Sample < -32768) {
-			output[i] = -32768
-		} else if (int16Sample > 32767) {
-			output[i] = 32767
-		} else {
-			output[i] = int16Sample
-		}
-	}
-
-	return output
+	return WaveCodec.float32ToInt16Pcm(input)
 }
 
-// Int24 PCM <-> Float32 conversion (uses int32 for storage)
 export function int24PcmToFloat32(input: Int32Array) {
-	const sampleCount = input.length
-
-	const output = new Float32Array(sampleCount)
-
-	for (let i = 0; i < sampleCount; i++) {
-		output[i] = input[i] / 8388608
-	}
-
-	return output
+	return WaveCodec.int24PcmToFloat32(input)
 }
 
 export function float32ToInt24Pcm(input: Float32Array) {
-	const sampleCount = input.length
-
-	const output = new Int32Array(sampleCount)
-
-	for (let i = 0; i < sampleCount; i++) {
-		const int24Sample = input[i] * 8388608
-
-		if (int24Sample < -8388608) {
-			output[i] = -8388608
-		} else if (int24Sample > 8388607) {
-			output[i] = 8388607
-		} else {
-			output[i] = int24Sample
-		}
-	}
-
-	return output
+	return WaveCodec.float32ToInt24Pcm(input)
 }
 
-// Int32 PCM <-> Float32 conversion
 export function int32PcmToFloat32(input: Int32Array) {
-	const sampleCount = input.length
-
-	const output = new Float32Array(sampleCount)
-
-	for (let i = 0; i < sampleCount; i++) {
-		output[i] = input[i] / 2147483648
-	}
-
-	return output
+	return WaveCodec.int32PcmToFloat32(input)
 }
 
 export function float32ToInt32Pcm(input: Float32Array) {
-	const sampleCount = input.length
-
-	const output = new Int32Array(sampleCount)
-
-	for (let i = 0; i < sampleCount; i++) {
-		const int32Sample = input[i] * 2147483648
-
-		if (int32Sample < -2147483648) {
-			output[i] = -2147483648
-		} else if (int32Sample > 2147483647) {
-			output[i] = 2147483647
-		} else {
-			output[i] = int32Sample
-		}
-	}
-
-	return output
+	return WaveCodec.float32ToInt32Pcm(input)
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Channel interleaving
-/////////////////////////////////////////////////////////////////////////////////////////////
 export function interleaveChannels(channels: Float32Array[]) {
-	const channelCount = channels.length
-
-	if (channelCount === 0) {
-		throw new Error('Empty channel array received')
-	}
-
-	if (channelCount === 1) {
-		return channels[0]
-	}
-
-	const sampleCount = channels[0].length
-	const result = new Float32Array(sampleCount * channelCount)
-
-	let writeIndex = 0
-
-	for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
-		for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
-			result[writeIndex++] = channels[channelIndex][sampleIndex]
-		}
-	}
-
-	return result
+	return WaveCodec.interleaveChannels(channels)
 }
 
-export function deInterleaveChannels(interleavedChannels: Float32Array, channelCount: number) {
-	if (channelCount === 0) {
-		throw new Error('0 channel count received')
-	}
-
-	if (channelCount === 1) {
-		return [interleavedChannels]
-	}
-
-	if (interleavedChannels.length % channelCount != 0) {
-		throw new Error(`Size of interleaved channels (${interleaveChannels.length}) is not a multiple of channel count (${channelCount})`)
-	}
-
-	const sampleCount = interleavedChannels.length / channelCount
-
-	const channels: Float32Array[] = []
-
-	for (let i = 0; i < channelCount; i++) {
-		channels.push(new Float32Array(sampleCount))
-	}
-
-	let readIndex = 0
-
-	for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
-		for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
-			channels[channelIndex][sampleIndex] = interleavedChannels[readIndex++]
-		}
-	}
-
-	return channels
+export function deinterleaveChannels(interleavedChannels: Float32Array, channelCount: number) {
+	return WaveCodec.deinterleaveChannels(interleavedChannels, channelCount)
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Utilities
-/////////////////////////////////////////////////////////////////////////////////////////////
-export function clampFloatSample(floatSample: number) {
-	if (floatSample < -1.0) {
-		return -1.0
-	} else if (floatSample > 1.0) {
-		return 1.0
-	} else {
-		return floatSample
-	}
-}
+export { type BitDepth, SampleFormat } from '@echogarden/wave-codec'

package/src/audio/AudioPlayer.ts

@@ -2,14 +2,14 @@ import { parentPort } from 'node:worker_threads'
 
 import { ChildProcessWithoutNullStreams, spawn } from 'child_process'
 
-import { RawAudio, encodeRawAudioToWave, fadeAudioInOut, getRawAudioDuration, sliceAudioChannels, sliceRawAudioByTime } from './AudioUtilities.js'
+import { RawAudio, encodeRawAudioToWave, fadeAudioInOut, getRawAudioDuration, sliceAudioChannels } from './AudioUtilities.js'
 import * as FFMpegTranscoder from '../codecs/FFMpegTranscoder.js'
 
 import { Timer } from '../utilities/Timer.js'
 import { clip, getRandomHexString, waitTimeout, writeToStderr } from '../utilities/Utilities.js'
 import { encodeToAudioBuffer, float32ToInt16Pcm, interleaveChannels } from './AudioBufferConversion.js'
 import { OpenPromise } from '../utilities/OpenPromise.js'
-import { Timeline, addWordTextOffsetsToTimeline } from '../utilities/Timeline.js'
+import { Timeline, addWordTextOffsetsToTimelineInPlace } from '../utilities/Timeline.js'
 import { readAndParseJsonFile, readFileAsUtf8, remove, writeFile } from '../utilities/FileSystem.js'
 import { tryResolvingSoxPath } from './SoxPath.js'
 import { SignalChannel } from '../utilities/SignalChannel.js'
@@ -38,7 +38,7 @@ export async function playAudioWithWordTimeline(rawAudio: RawAudio, wordTimeline
 
 	wordTimeline = deepClone(wordTimeline)
 
-	addWordTextOffsetsToTimeline(wordTimeline, transcript)
+	addWordTextOffsetsToTimelineInPlace(wordTimeline, transcript)
 
 	let timelineEntryIndex = 0
 	let transcriptOffset = 0

package/src/audio/AudioRecorder.ts

@@ -6,8 +6,8 @@ import * as AudioBufferConversion from './AudioBufferConversion.js'
 import { Timer } from '../utilities/Timer.js'
 import { logToStderr } from '../utilities/Utilities.js'
 import { OpenPromise } from '../utilities/OpenPromise.js'
-import { SampleFormat } from '../codecs/WaveCodec.js'
 import { tryResolvingSoxPath } from './SoxPath.js'
+import { SampleFormat } from './AudioBufferConversion.js'
 
 const log = logToStderr
 

package/src/audio/AudioUtilities.ts

@@ -1,5 +1,5 @@
 import * as FFMpegTranscoder from '../codecs/FFMpegTranscoder.js'
-import { SampleFormat, encodeWave, decodeWave, BitDepth } from '../codecs/WaveCodec.js'
+import { SampleFormat, BitDepth, encodeWaveFromFloat32Channels, decodeWaveToFloat32Channels } from '@echogarden/wave-codec'
 import { resampleAudioSpeex } from '../dsp/SpeexResampler.js'
 import { Timeline } from '../utilities/Timeline.js'
 import { concatFloat32Arrays } from '../utilities/Utilities.js'
@@ -8,11 +8,13 @@ import { concatFloat32Arrays } from '../utilities/Utilities.js'
 // Wave encoding and decoding
 ////////////////////////////////////////////////////////////////////////////////////////////////
 export function encodeRawAudioToWave(rawAudio: RawAudio, bitDepth: BitDepth = 16, sampleFormat: SampleFormat = SampleFormat.PCM, speakerPositionMask = 0) {
-	return encodeWave(rawAudio, bitDepth, sampleFormat, speakerPositionMask)
+	return encodeWaveFromFloat32Channels(rawAudio.audioChannels, rawAudio.sampleRate, bitDepth, sampleFormat, speakerPositionMask)
 }
 
 export function decodeWaveToRawAudio(waveFileBuffer: Uint8Array, ignoreTruncatedChunks = true, ignoreOverflowingDataChunks = true) {
-	return decodeWave(waveFileBuffer, ignoreTruncatedChunks, ignoreOverflowingDataChunks)
+	const rawAudio = decodeWaveToFloat32Channels(waveFileBuffer, ignoreTruncatedChunks, ignoreOverflowingDataChunks)
+
+	return { rawAudio }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////

package/src/cli/CLI.ts

@@ -10,10 +10,10 @@ import { SubtitlesConfig, subtitlesToText, timelineToSubtitles } from '../subtit
 import { Logger, resetActiveLogger } from '../utilities/Logger.js'
 import { isMainThread, parentPort } from 'node:worker_threads'
 import { encodeFromChannels, getDefaultFFMpegOptionsForSpeech } from '../codecs/FFMpegTranscoder.js'
-import { splitToParagraphs, splitToWords, wordCharacterPattern } from '../nlp/Segmentation.js'
+import { splitToParagraphs, splitToWords } from '../nlp/Segmentation.js'
 import { playAudioSamplesWithKeyboardControls, playAudioWithWordTimeline } from '../audio/AudioPlayer.js'
 import { extendDeep } from '../utilities/ObjectUtilities.js'
-import { Timeline, TimelineEntry, addTimeOffsetToTimeline, addWordTextOffsetsToTimeline, roundTimelineProperties } from '../utilities/Timeline.js'
+import { Timeline, TimelineEntry, addTimeOffsetToTimeline, addWordTextOffsetsToTimelineInPlace, roundTimelineProperties } from '../utilities/Timeline.js'
 import { ensureDir, existsSync, readAndParseJsonFile, readdir, readFileAsUtf8, writeFileSafe } from '../utilities/FileSystem.js'
 import { formatLanguageCodeWithName, getShortLanguageCode } from '../utilities/Locale.js'
 import { APIOptions } from '../api/APIOptions.js'
@@ -509,7 +509,7 @@ export async function speak(operationData: CLIOperationData) {
 	const { audio: synthesizedAudio, timeline } = await API.synthesize(textSegments, options, onSegment, undefined)
 
 	if (plainText) {
-		addWordTextOffsetsToTimeline(timeline, plainText)
+		addWordTextOffsetsToTimelineInPlace(timeline, plainText)
 	}
 
 	if (outputFilenames.length > 0) {
@@ -1884,7 +1884,7 @@ async function checkOutputFilenames(outputFilenames: string[], acceptMediaOutput
 async function writeOutputFilesForSegment(outputFilenames: string[], index: number, total: number, audio: RawAudio, timeline: Timeline, text: string, language: string, allowOverwrite: boolean) {
 	const digitCount = Math.max((total + 1).toString().length, 2)
 
-	const segmentWords = (await splitToWords(text, language)).filter(text => wordCharacterPattern.test(text))
+	const segmentWords = (await splitToWords(text, language)).nonPunctuationWords
 
 	const segmentJoinedWords = segmentWords.join(' ').trim()
 

package/src/codecs/TIMITCodec.ts

@@ -1,7 +1,6 @@
-import { decodeToChannels } from '../audio/AudioBufferConversion.js'
+import { decodeToChannels, SampleFormat } from '../audio/AudioBufferConversion.js'
 import { decodeAscii } from '../encodings/Ascii.js'
 import { readFileAsBinary } from '../utilities/FileSystem.js'
-import { SampleFormat } from './WaveCodec.js'
 
 export async function decodeTimitAudioFile(filename: string) {
 	return decodeTimitAudio(await readFileAsBinary(filename))

package/src/denoising/RNNoise.ts

@@ -1,6 +1,6 @@
 import { float32ToInt16Pcm } from '../audio/AudioBufferConversion.js'
 import { concatFloat32Arrays } from '../utilities/Utilities.js'
-import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
+import { wrapEmscriptenModuleHeap } from 'wasm-heap-manager'
 import { Logger } from '../utilities/Logger.js'
 import { RawAudio, cloneRawAudio } from '../audio/AudioUtilities.js'
 
@@ -24,15 +24,15 @@ export async function denoiseAudio(rawAudio: RawAudio) {
 	const m = await getRnnoiseInstance()
 
 	logger.start('Process with RNNoise')
-	const wasmMemory = new WasmMemoryManager(m)
+	const wasmHeap = wrapEmscriptenModuleHeap(m)
 
 	const stateSize = m._rnnoise_get_size()
 	const frameSize = m._rnnoise_get_frame_size()
 
 	const denoiseState = m._rnnoise_create(0)
 
-	const inputRef = wasmMemory.allocFloat32Array(frameSize)
-	const outputRef = wasmMemory.allocFloat32Array(frameSize)
+	const inputRef = wasmHeap.allocFloat32Array(frameSize)
+	const outputRef = wasmHeap.allocFloat32Array(frameSize)
 
 	const floatSamples = rawAudio.audioChannels[0]
 	const int16Samples = float32ToInt16Pcm(floatSamples)
@@ -70,7 +70,7 @@ export async function denoiseAudio(rawAudio: RawAudio) {
 	outputNewFrame(outputRef.view.slice(), lastFrameVadProbability)
 
 	m._rnnoise_destroy(denoiseState)
-	wasmMemory.freeAll()
+	wasmHeap.freeAll()
 
 	const int16DenoisedSamplesAsFloats = concatFloat32Arrays(processedFrames)
 

package/src/dsp/FFT.ts

@@ -1,6 +1,6 @@
 import { ComplexNumber } from '../math/VectorMath.js'
 import { concatFloat32Arrays, isWasmSimdSupported } from '../utilities/Utilities.js'
-import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
+import { createWasmHeapManager } from 'wasm-heap-manager'
 
 // Compute short-term Fourier transform (real-valued)
 export async function stftr(samples: Float32Array, fftOrder: number, windowSize: number, hopSize: number, windowType: WindowType) {
@@ -15,7 +15,7 @@ export async function stftr(samples: Float32Array, fftOrder: number, windowSize:
 
 // Incrementally generate short-term Fourier transform frames (real-valued)
 export async function* stftrGenerator(samples: Float32Array, fftOrder: number, windowSize: number, hopSize: number, windowType: WindowType) {
-	if (fftOrder % 2 != 0 || windowSize % 2 != 0) {
+	if (fftOrder % 2 !== 0 || windowSize % 2 !== 0) {
 		throw new Error('FFT order and window size must be multiples of 2')
 	}
 
@@ -35,17 +35,19 @@ export async function* stftrGenerator(samples: Float32Array, fftOrder: number, w
 	const windowWeights = getWindowWeights(windowType, windowSize)
 
 	const m = await getPFFFTInstance(await isPffftSimdSupportedForFFTOrder(fftOrder))
-	const wasmMemory = new WasmMemoryManager(m, {
-		wasmAlloc: m._pffft_aligned_malloc,
-		wasmFree: m._pffft_aligned_free
-	})
+
+	const wasmHeap = createWasmHeapManager(
+		() => m.HEAPU8.buffer,
+		m._pffft_aligned_malloc,
+		m._pffft_aligned_free,
+	)
 
 	const statePtr = m._pffft_new_setup(fftOrder, 0)
 
 	const sampleCount = samples.length
-	const frameBufferRef = wasmMemory.allocFloat32Array(fftOrder)
-	const binsBufferRef = wasmMemory.allocFloat32Array(fftOrder * 2)
-	const workBufferRef = wasmMemory.allocFloat32Array(fftOrder * 2)
+	const frameBufferRef = wasmHeap.allocFloat32Array(fftOrder)
+	const binsBufferRef = wasmHeap.allocFloat32Array(fftOrder * 2)
+	const workBufferRef = wasmHeap.allocFloat32Array(fftOrder * 2)
 
 	for (let offset = 0; offset < sampleCount; offset += hopSize) {
 		const windowSamples = samples.subarray(offset, offset + windowSize)
@@ -68,12 +70,12 @@ export async function* stftrGenerator(samples: Float32Array, fftOrder: number, w
 
 	m._pffft_destroy_setup(statePtr)
 
-	wasmMemory.freeAll()
+	wasmHeap.freeAll()
 }
 
 // Compute short-term inverse Fourier transform (real-valued)
 export async function stiftr(binsForFrames: Float32Array[], fftOrder: number, windowSize: number, hopSize: number, windowType: WindowType, expectedOutputLength?: number) {
-	if (fftOrder % 2 != 0 || windowSize % 2 != 0) {
+	if (fftOrder % 2 !== 0 || windowSize % 2 !== 0) {
 		throw new Error('FFT order and window size must multiples of 2')
 	}
 
@@ -101,16 +103,17 @@ export async function stiftr(binsForFrames: Float32Array[], fftOrder: number, wi
 
 	const m = await getPFFFTInstance(await isPffftSimdSupportedForFFTOrder(fftOrder))
 
-	const wasmMemory = new WasmMemoryManager(m, {
-		wasmAlloc: m._pffft_aligned_malloc,
-		wasmFree: m._pffft_aligned_free
-	})
+	const wasmHeap = createWasmHeapManager(
+		() => m.HEAPU8.buffer,
+		m._pffft_aligned_malloc,
+		m._pffft_aligned_free,
+	)
 
 	const statePtr = m._pffft_new_setup(fftOrder, 0)
 
-	const frameBufferRef = wasmMemory.allocFloat32Array(fftOrder)
-	const binsRef = wasmMemory.allocFloat32Array(fftOrder * 2)
-	const workBufferRef = wasmMemory.allocFloat32Array(fftOrder * 2)
+	const frameBufferRef = wasmHeap.allocFloat32Array(fftOrder)
+	const binsRef = wasmHeap.allocFloat32Array(fftOrder * 2)
+	const workBufferRef = wasmHeap.allocFloat32Array(fftOrder * 2)
 
 	const sumOfSquaredWeightsForSample = new Float32Array(outSampleCount)
 
@@ -140,7 +143,7 @@ export async function stiftr(binsForFrames: Float32Array[], fftOrder: number, wi
 	}
 
 	m._pffft_destroy_setup(statePtr)
-	wasmMemory.freeAll()
+	wasmHeap.freeAll()
 
 	// Divide each output sample by the sum of squared weights
 	for (let i = 0; i < outSamples.length; i++) {

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 { Float32ArrayRef, wrapEmscriptenModuleHeap } from 'wasm-heap-manager'
 
 let rubberbandInstance: any
 
@@ -14,7 +14,7 @@ export async function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchS
 	const sampleRate = rawAudio.sampleRate
 
 	const m = await getRubberbandInstance()
-	const wasmMemory = new WasmMemoryManager(m)
+	const wasmHeap = wrapEmscriptenModuleHeap(m)
 
 	const optionFlags = rubberBandOptionsToFlags(options)
 
@@ -25,11 +25,11 @@ export async function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchS
 	const samplesRequired = m._rubberband_get_samples_required(statePtr)
 	const bufferSize = Math.min(samplesRequired, sampleCount)
 
-	const bufferChannelPtrsRef = wasmMemory.allocUint32Array(bufferSize)
+	const bufferChannelPtrsRef = wasmHeap.allocUint32Array(bufferSize)
 	const bufferChannelRefs: Float32ArrayRef[] = []
 
 	for (let i = 0; i < channelCount; i++) {
-		const bufferChannelRef = wasmMemory.allocFloat32Array(bufferSize)
+		const bufferChannelRef = wasmHeap.allocFloat32Array(bufferSize)
 		bufferChannelPtrsRef.view[i] = bufferChannelRef.address
 
 		bufferChannelRefs.push(bufferChannelRef)
@@ -102,7 +102,7 @@ export async function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchS
 	}
 
 	m._rubberband_delete(statePtr)
-	wasmMemory.freeAll()
+	wasmHeap.freeAll()
 
 	const outputAudioChannels = outputAudioChannelChunks.map(chunks => concatFloat32Arrays(chunks))
 	const outputRawAudio: RawAudio = { audioChannels: outputAudioChannels, sampleRate }

package/src/dsp/Sonic.ts

@@ -1,5 +1,5 @@
 import { RawAudio } from '../audio/AudioUtilities.js'
-import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
+import { wrapEmscriptenModuleHeap } from 'wasm-heap-manager'
 
 let sonicInstance: any
 
@@ -10,13 +10,13 @@ export async function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchS
 	const inputSampleCount = rawAudio.audioChannels[0].length
 
 	const m = await getSonicInstance()
-	const wasmMemory = new WasmMemoryManager(m)
+	const wasmHeap = wrapEmscriptenModuleHeap(m)
 
 	const streamPtr = m._sonicCreateStream(sampleRate, channelCount)
 	m._sonicSetSpeed(streamPtr, speed)
 	m._sonicSetPitch(streamPtr, pitchScale)
 
-	const inputSamplesRef = wasmMemory.allocFloat32Array(inputSampleCount)
+	const inputSamplesRef = wasmHeap.allocFloat32Array(inputSampleCount)
 	inputSamplesRef.view.set(inputSamples)
 
 	const writeSuccess = m._sonicWriteFloatToStream(streamPtr, inputSamplesRef.address, inputSampleCount)
@@ -33,9 +33,9 @@ export async function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchS
 
 	const samplesAvailable = m._sonicSamplesAvailable(streamPtr)
 
-	const outputSamplesRef = wasmMemory.allocFloat32Array(samplesAvailable)
+	const outputSamplesRef = wasmHeap.allocFloat32Array(samplesAvailable)
 
-	const samplesRead = m._sonicReadFloatFromStream(streamPtr, outputSamplesRef.address, outputSamplesRef.length)
+	const samplesRead = m._sonicReadFloatFromStream(streamPtr, outputSamplesRef.address, outputSamplesRef.allocatedByteCount)
 
 	const outputSamples = outputSamplesRef.view.slice(0, samplesRead)
 
@@ -43,7 +43,7 @@ export async function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchS
 
 	m._sonicDestroyStream(streamPtr)
 
-	wasmMemory.freeAll()
+	wasmHeap.freeAll()
 
 	return resultAudio
 }