echogarden 1.7.0 → 1.8.0

package/src/api/SpeechLanguageDetection.ts

@@ -1,6 +1,6 @@
 import { deepClone, extendDeep } from '../utilities/ObjectUtilities.js'
 
-import { AudioSourceParam, RawAudio, ensureRawAudio, getRawAudioDuration, normalizeAudioLevel, sliceRawAudioByTime, trimAudioEnd } from '../audio/AudioUtilities.js'
+import { AudioSourceParam, RawAudio, ensureRawAudio, getRawAudioDuration, normalizeAudioLevelInPlace, sliceRawAudioByTime, trimAudioEnd } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 
 import * as API from './API.js'
@@ -28,7 +28,7 @@ export async function detectSpeechLanguage(input: AudioSourceParam, options: Spe
 
 	logger.start(`Resample audio to 16kHz mono`)
 	let sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
-	sourceRawAudio = normalizeAudioLevel(sourceRawAudio)
+	normalizeAudioLevelInPlace(sourceRawAudio)
 	sourceRawAudio.audioChannels[0] = trimAudioEnd(sourceRawAudio.audioChannels[0])
 
 	if (options.crop) {

package/src/api/SpeechTranslation.ts

@@ -1,7 +1,7 @@
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 
 import { logToStderr } from '../utilities/Utilities.js'
-import { AudioSourceParam, RawAudio, ensureRawAudio, normalizeAudioLevel, trimAudioEnd } from '../audio/AudioUtilities.js'
+import { AudioSourceParam, RawAudio, ensureRawAudio, normalizeAudioLevelInPlace, trimAudioEnd } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 
 import { Timeline, addWordTextOffsetsToTimeline, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
@@ -61,7 +61,7 @@ export async function translateSpeech(input: AudioSourceParam, options: SpeechTr
 
 	logger.start('Normalize and trim audio')
 
-	sourceRawAudio = normalizeAudioLevel(sourceRawAudio)
+	normalizeAudioLevelInPlace(sourceRawAudio)
 	sourceRawAudio.audioChannels[0] = trimAudioEnd(sourceRawAudio.audioChannels[0])
 
 	if (options.sourceLanguage) {

package/src/api/Synthesis.ts

@@ -5,7 +5,7 @@ import { deepClone, extendDeep } from '../utilities/ObjectUtilities.js'
 import * as FFMpegTranscoder from '../codecs/FFMpegTranscoder.js'
 
 import { clip, sha256AsHex, stringifyAndFormatJson, logToStderr, yieldToEventLoop, runOperationWithRetries } from '../utilities/Utilities.js'
-import { RawAudio, attenuateIfClipping, concatAudioSegments, downmixToMono, encodeRawAudioToWave, getSamplePeakDecibels, getEmptyRawAudio, getRawAudioDuration, normalizeAudioLevel, trimAudioEnd, trimAudioStart } from '../audio/AudioUtilities.js'
+import { RawAudio, concatAudioSegments, downmixToMono, encodeRawAudioToWave, getSamplePeakDecibels, getEmptyRawAudio, getRawAudioDuration, trimAudioEnd, trimAudioStart, attenuateIfClippingInPlace, normalizeAudioLevelInPlace } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 
 import { isWordOrSymbolWord, splitToParagraphs, splitToSentences } from '../nlp/Segmentation.js'
@@ -250,9 +250,9 @@ async function synthesizeSegments(segments: string[], options: SynthesisOptions,
 		resultRawAudio = { audioChannels: joinedAudioBuffers, sampleRate: segmentsRawAudio[0].sampleRate }
 
 		if (options.postProcessing!.normalizeAudio) {
-			resultRawAudio = normalizeAudioLevel(resultRawAudio, options.postProcessing!.targetPeak, options.postProcessing!.maxGainIncrease)
+			normalizeAudioLevelInPlace(resultRawAudio, options.postProcessing!.targetPeak, options.postProcessing!.maxGainIncrease)
 		} else {
-			resultRawAudio = attenuateIfClipping(resultRawAudio)
+			attenuateIfClippingInPlace(resultRawAudio)
 		}
 	} else {
 		resultRawAudio = getEmptyRawAudio(1, 24000)
@@ -866,9 +866,9 @@ async function synthesizeSegment(text: string, options: SynthesisOptions) {
 	synthesizedAudio = downmixToMono(synthesizedAudio)
 
 	if (options.postProcessing!.normalizeAudio) {
-		synthesizedAudio = normalizeAudioLevel(synthesizedAudio, options.postProcessing!.targetPeak!, options.postProcessing!.maxGainIncrease!)
+		normalizeAudioLevelInPlace(synthesizedAudio, options.postProcessing!.targetPeak!, options.postProcessing!.maxGainIncrease!)
 	} else {
-		synthesizedAudio = attenuateIfClipping(synthesizedAudio)
+		attenuateIfClippingInPlace(synthesizedAudio)
 	}
 
 	const preTrimSampleCount = synthesizedAudio.audioChannels[0].length

package/src/api/TranslationAlignment.ts

@@ -1,7 +1,7 @@
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 
 import { logToStderr } from '../utilities/Utilities.js'
-import { AudioSourceParam, RawAudio, ensureRawAudio, normalizeAudioLevel, trimAudioEnd } from '../audio/AudioUtilities.js'
+import { AudioSourceParam, RawAudio, ensureRawAudio, normalizeAudioLevelInPlace, trimAudioEnd } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 
 import * as API from './API.js'
@@ -53,7 +53,7 @@ export async function alignTranslation(input: AudioSourceParam, translatedTransc
 
 	logger.start('Normalize and trim audio')
 
-	sourceRawAudio = normalizeAudioLevel(sourceRawAudio)
+	normalizeAudioLevelInPlace(sourceRawAudio)
 	sourceRawAudio.audioChannels[0] = trimAudioEnd(sourceRawAudio.audioChannels[0])
 
 	logger.end()

package/src/audio/AudioUtilities.ts

@@ -47,11 +47,13 @@ export function trimAudioEnd(audioSamples: Float32Array, targetEndSilentSampleCo
 }
 
 export function getStartingSilentSampleCount(audioSamples: Float32Array, amplitudeThresholdDecibels = defaultSilenceThresholdDecibels) {
+	const sampleCount = audioSamples.length
+
 	const minSampleAmplitude = decibelsToGainFactor(amplitudeThresholdDecibels)
 
 	let silentSampleCount = 0
 
-	for (let i = 0; i < audioSamples.length - 1; i++) {
+	for (let i = 0; i < sampleCount - 1; i++) {
 		if (Math.abs(audioSamples[i]) > minSampleAmplitude) {
 			break
 		}
@@ -63,11 +65,13 @@ export function getStartingSilentSampleCount(audioSamples: Float32Array, amplitu
 }
 
 export function getEndingSilentSampleCount(audioSamples: Float32Array, amplitudeThresholdDecibels = defaultSilenceThresholdDecibels) {
+	const sampleCount = audioSamples.length
+
 	const minSampleAmplitude = decibelsToGainFactor(amplitudeThresholdDecibels)
 
 	let silentSampleCount = 0
 
-	for (let i = audioSamples.length - 1; i >= 0; i--) {
+	for (let i = sampleCount - 1; i >= 0; i--) {
 		if (Math.abs(audioSamples[i]) > minSampleAmplitude) {
 			break
 		}
@@ -82,15 +86,27 @@ export function getEndingSilentSampleCount(audioSamples: Float32Array, amplitude
 // Gain, normalization, mixing, and channel downmixing
 ////////////////////////////////////////////////////////////////////////////////////////////////
 export function downmixToMonoAndNormalize(rawAudio: RawAudio, targetPeakDecibels = -3) {
-	return normalizeAudioLevel(downmixToMono(rawAudio), targetPeakDecibels)
+	const downmixedAudio = downmixToMono(rawAudio)
+
+	normalizeAudioLevelInPlace(downmixedAudio, targetPeakDecibels)
+
+	return downmixedAudio
+}
+
+export function attenuateIfClippingInPlace(rawAudio: RawAudio, clippingThreshold = -0.1) {
+	normalizeAudioLevelInPlace(rawAudio, clippingThreshold, 0)
 }
 
-export function attenuateIfClipping(rawAudio: RawAudio) {
-	return normalizeAudioLevel(rawAudio, -0.1, 0)
+export function normalizeAudioLevel(rawAudio: RawAudio, targetPeakDecibels = -3, maxGainIncreaseDecibels = 30) {
+	const clonedRawAudio = cloneRawAudio(rawAudio)
+
+	normalizeAudioLevelInPlace(clonedRawAudio, targetPeakDecibels, maxGainIncreaseDecibels)
+
+	return clonedRawAudio
 }
 
-export function normalizeAudioLevel(rawAudio: RawAudio, targetPeakDecibels = -3, maxGainIncreaseDecibels = 30): RawAudio {
-	//rawAudio = correctDCBias(rawAudio)
+export function normalizeAudioLevelInPlace(rawAudio: RawAudio, targetPeakDecibels = -3, maxGainIncreaseDecibels = 30){
+	//correctDCBiasInPlace(rawAudio)
 
 	const targetPeakAmplitude = decibelsToGainFactor(targetPeakDecibels)
 	const maxGainFactor = decibelsToGainFactor(maxGainIncreaseDecibels)
@@ -99,12 +115,10 @@ export function normalizeAudioLevel(rawAudio: RawAudio, targetPeakDecibels = -3,
 
 	const gainFactor = Math.min(targetPeakAmplitude / peakAmplitude, maxGainFactor)
 
-	return applyGainFactor(rawAudio, gainFactor)
+	applyGainFactorInPlace(rawAudio, gainFactor)
 }
 
-export function correctDCBias(rawAudio: RawAudio): RawAudio {
-	const outputAudioChannels: Float32Array[] = []
-
+export function correctDCBiasInPlace(rawAudio: RawAudio) {
 	for (const channelSamples of rawAudio.audioChannels) {
 		const sampleCount = channelSamples.length
 
@@ -116,38 +130,36 @@ export function correctDCBias(rawAudio: RawAudio): RawAudio {
 
 		const sampleAverage = sampleSum / sampleCount
 
-		const outputChannelSamples = new Float32Array(sampleCount)
-
 		for (let i = 0; i < sampleCount; i++) {
-			outputChannelSamples[i] = channelSamples[i] - sampleAverage
+			channelSamples[i] -= sampleAverage
 		}
-
-		outputAudioChannels.push(outputChannelSamples)
 	}
+}
 
-	return { audioChannels: outputAudioChannels, sampleRate: rawAudio.sampleRate } as RawAudio
+export function applyGainDecibels(rawAudio: RawAudio, gainDecibels: number) {
+	const clonedRawAudio = cloneRawAudio(rawAudio)
+
+	applyGainDecibelsInPlace(clonedRawAudio, gainDecibels)
+
+	return clonedRawAudio
 }
 
-export function applyGainDecibels(rawAudio: RawAudio, gainDecibels: number): RawAudio {
-	return applyGainFactor(rawAudio, decibelsToGainFactor(gainDecibels))
+export function applyGainDecibelsInPlace(rawAudio: RawAudio, gainDecibels: number) {
+	applyGainFactorInPlace(rawAudio, decibelsToGainFactor(gainDecibels))
 }
 
-export function applyGainFactor(rawAudio: RawAudio, gainFactor: number): RawAudio {
-	const outputAudioChannels: Float32Array[] = []
+export function applyGainFactorInPlace(rawAudio: RawAudio, gainFactor: number) {
+	if (gainFactor === 1.0) {
+		return
+	}
 
 	for (const channelSamples of rawAudio.audioChannels) {
 		const sampleCount = channelSamples.length
 
-		const outputChannelSamples = new Float32Array(sampleCount)
-
 		for (let i = 0; i < sampleCount; i++) {
-			outputChannelSamples[i] = channelSamples[i] * gainFactor
+			channelSamples[i] *= gainFactor
 		}
-
-		outputAudioChannels.push(outputChannelSamples)
 	}
-
-	return { audioChannels: outputAudioChannels, sampleRate: rawAudio.sampleRate } as RawAudio
 }
 
 export function downmixToMono(rawAudio: RawAudio): RawAudio {
@@ -183,8 +195,14 @@ export function getSamplePeakAmplitude(audioChannels: Float32Array[]) {
 	let maxAmplitude = 0.00001
 
 	for (const channelSamples of audioChannels) {
-		for (const sample of channelSamples) {
-			maxAmplitude = Math.max(maxAmplitude, Math.abs(sample))
+		const sampleCount = channelSamples.length
+
+		for (let i = 0; i < sampleCount; i++) {
+			const sampleAbsValue = Math.abs(channelSamples[i])
+
+			if (sampleAbsValue > maxAmplitude) {
+				maxAmplitude = sampleAbsValue
+			}
 		}
 	}
 
@@ -257,7 +275,7 @@ export function sliceAudioChannels(audioChannels: Float32Array[], startSampleInd
 }
 
 export function concatAudioSegments(audioSegments: Float32Array[][]) {
-	if (audioSegments.length == 0) {
+	if (audioSegments.length === 0) {
 		return []
 	}
 
@@ -317,7 +335,9 @@ export function fadeAudioInOut(rawAudio: RawAudio, fadeTime: number): RawAudio {
 	const outAudioChannels = rawAudio.audioChannels.map(channel => channel.slice())
 
 	for (const channel of outAudioChannels) {
-		if (channel.length < fadeSampleCount * 2) {
+		const sampleCount = channel.length
+
+		if (sampleCount < fadeSampleCount * 2) {
 			continue
 		}
 
@@ -331,7 +351,7 @@ export function fadeAudioInOut(rawAudio: RawAudio, fadeTime: number): RawAudio {
 
 		factor = 1.0
 
-		for (let i = channel.length - fadeSampleCount; i < channel.length; i++) {
+		for (let i = sampleCount - fadeSampleCount; i < sampleCount; i++) {
 			channel[i] *= factor
 
 			factor *= gainReductionPerFrameFactor

package/src/dsp/FFT.ts

@@ -2,8 +2,6 @@ import { ComplexNumber } from '../math/VectorMath.js'
 import { concatFloat32Arrays } from '../utilities/Utilities.js'
 import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
 
-let kissFFTInstance: any
-
 // Compute short-term Fourier transform (real-valued)
 export async function stftr(samples: Float32Array, fftOrder: number, windowSize: number, hopSize: number, windowType: WindowType) {
 	const frames: Float32Array[] = []
@@ -36,15 +34,18 @@ export async function* stftrGenerator(samples: Float32Array, fftOrder: number, w
 
 	const windowWeights = getWindowWeights(windowType, windowSize)
 
-	const m = await getKissFFTInstance()
-	const wasmMemory = new WasmMemoryManager(m)
+	const m = await getPFFFTInstance(isPffftSimdSupportedForFFTOrder(fftOrder))
+	const wasmMemory = new WasmMemoryManager(m, {
+		wasmAlloc: m._pffft_aligned_malloc,
+		wasmFree: m._pffft_aligned_free
+	})
 
-	const statePtr = m._kiss_fftr_alloc(fftOrder, 0, 0, 0)
-	wasmMemory.wrapPointer(statePtr)
+	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)
 
 	for (let offset = 0; offset < sampleCount; offset += hopSize) {
 		const windowSamples = samples.subarray(offset, offset + windowSize)
@@ -58,13 +59,15 @@ export async function* stftrGenerator(samples: Float32Array, fftOrder: number, w
 
 		binsBufferRef.clear()
 
-		m._kiss_fftr(statePtr, frameBufferRef.address, binsBufferRef.address)
+		m._pffft_transform_ordered(statePtr, frameBufferRef.address, binsBufferRef.address, workBufferRef.address, 0)
 
 		const bins = binsBufferRef.view.slice(0, fftOrder + 2)
 
 		yield bins
 	}
 
+	m._pffft_destroy_setup(statePtr)
+
 	wasmMemory.freeAll()
 }
 
@@ -96,14 +99,18 @@ export async function stiftr(binsForFrames: Float32Array[], fftOrder: number, wi
 
 	const outSamples = new Float32Array(outSampleCount)
 
-	const m = await getKissFFTInstance()
-	const wasmMemory = new WasmMemoryManager(m)
+	const m = await getPFFFTInstance(isPffftSimdSupportedForFFTOrder(fftOrder))
 
-	const statePtr = m._kiss_fftr_alloc(fftOrder, 1, 0, 0)
-	wasmMemory.wrapPointer(statePtr)
+	const wasmMemory = new WasmMemoryManager(m, {
+		wasmAlloc: m._pffft_aligned_malloc,
+		wasmFree: 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 sumOfSquaredWeightsForSample = new Float32Array(outSampleCount)
 
@@ -114,7 +121,7 @@ export async function stiftr(binsForFrames: Float32Array[], fftOrder: number, wi
 
 		frameBufferRef.clear()
 
-		m._kiss_fftri(statePtr, binsRef.address, frameBufferRef.address)
+		m._pffft_transform_ordered(statePtr, binsRef.address, frameBufferRef.address, workBufferRef.address, 1)
 
 		const frameSamples = frameBufferRef.view
 
@@ -132,6 +139,7 @@ export async function stiftr(binsForFrames: Float32Array[], fftOrder: number, wi
 		}
 	}
 
+	m._pffft_destroy_setup(statePtr)
 	wasmMemory.freeAll()
 
 	// Divide each output sample by the sum of squared weights
@@ -247,15 +255,33 @@ export function getWindowWeights(windowType: WindowType, windowSize: number) {
 	return weights
 }
 
-// Get KISS FFT instance (initialize new if not exists)
-export async function getKissFFTInstance() {
-	if (!kissFFTInstance) {
-		const { default: initializer } = await import('@echogarden/kissfft-wasm')
+export function isPffftSimdSupportedForFFTOrder(fftOrder: number) {
+	return fftOrder % 32 === 0
+}
 
-		kissFFTInstance = await initializer()
-	}
+let pffftNonSimdInstance: any
+let pffftSimdInstance: any
+
+export async function getPFFFTInstance(enableSimd: boolean) {
+	return enableSimd ? getSimdPFFFTInstance() : getNonSimdPFFFTInstance()
+}
+
+// Get non-SIMD PFFFT instance (initialize new if not exists)
+async function getNonSimdPFFFTInstance() {
+	const { default: initializer } = await import('@echogarden/pffft-wasm')
+
+	pffftNonSimdInstance = await initializer()
+
+	return pffftNonSimdInstance
+}
+
+// Get SIMD PFFFT instance (initialize new if not exists)
+async function getSimdPFFFTInstance() {
+	const { default: initializer } = await import('@echogarden/pffft-wasm/simd')
+
+	pffftSimdInstance = await initializer()
 
-	return kissFFTInstance
+	return pffftSimdInstance
 }
 
 export type WindowType = 'hann' | 'hamming' | 'povey'

package/src/recognition/WhisperSTT.ts

@@ -459,7 +459,7 @@ export class Whisper {
 			// Find alignment path
 			let alignmentHeads: number[] | undefined = undefined
 
-			if (this.modelName.startsWith('small') || this.modelName.startsWith('medium') || this.modelName.startsWith('large')) {
+			if (options.useOptimizedAlignmentHeads) {
 				alignmentHeads = this.alignmentHeadIndexes
 			}
 
@@ -566,12 +566,15 @@ export class Whisper {
 			topCandidateCount: 1,
 			punctuationThreshold: Infinity,
 			autoPromptParts: false,
-			maxTokensPerPart: Infinity,
+			maxTokensPerPart: whisperAlignmentOptions.maxTokensPerPart!,
 			suppressRepetition: false,
 			repetitionThreshold: Infinity,
 			decodeTimestampTokens: true,
-			endTokenThreshold: whisperAlignmentOptions!.endTokenThreshold!,
+			endTokenThreshold: whisperAlignmentOptions.endTokenThreshold!,
 			includeEndTokenInCandidates: false,
+			useOptimizedAlignmentHeads: whisperAlignmentOptions.useOptimizedAlignmentHeads!,
+			encoderProvider: whisperAlignmentOptions.encoderProvider!,
+			decoderProvider: whisperAlignmentOptions.decoderProvider!,
 			seed: undefined,
 		}
 
@@ -1103,7 +1106,8 @@ export class Whisper {
 		const sampleRate = rawAudio.sampleRate
 
 		const fftOrder = 400
-		const hopLength = 160
+		const fftWindowSize = 400
+		const fftHopLength = 160
 
 		const filterbankCount = this.filterbankCount
 		const filterbanks = this.filterbanks
@@ -1128,7 +1132,7 @@ export class Whisper {
 
 		const rawAudioPart: RawAudio = { audioChannels: [paddedAudioSamples], sampleRate }
 
-		const { melSpectogram } = await computeMelSpectogramUsingFilterbanks(rawAudioPart, fftOrder, fftOrder, hopLength, filterbanks)
+		const { melSpectogram } = await computeMelSpectogramUsingFilterbanks(rawAudioPart, fftOrder, fftWindowSize, fftHopLength, filterbanks)
 
 		await logger.startAsync('Normalize mel spectogram')
 
@@ -2440,6 +2444,7 @@ export interface WhisperOptions {
 	decodeTimestampTokens?: boolean
 	endTokenThreshold?: number
 	includeEndTokenInCandidates?: boolean
+	useOptimizedAlignmentHeads?: boolean,
 	encoderProvider?: OnnxExecutionProvider
 	decoderProvider?: OnnxExecutionProvider
 	seed?: number
@@ -2458,6 +2463,7 @@ export const defaultWhisperOptions: WhisperOptions = {
 	decodeTimestampTokens: true,
 	endTokenThreshold: 0.9,
 	includeEndTokenInCandidates: true,
+	useOptimizedAlignmentHeads: true,
 	encoderProvider: undefined,
 	decoderProvider: undefined,
 	seed: undefined,
@@ -2467,6 +2473,9 @@ export const defaultWhisperOptions: WhisperOptions = {
 export interface WhisperAlignmentOptions {
 	model?: WhisperModelName
 	endTokenThreshold?: number
+	maxTokensPerPart?: number
+	useOptimizedAlignmentHeads?: boolean
+
 	encoderProvider?: OnnxExecutionProvider
 	decoderProvider?: OnnxExecutionProvider
 }
@@ -2474,8 +2483,11 @@ export interface WhisperAlignmentOptions {
 export const defaultWhisperAlignmentOptions: WhisperAlignmentOptions = {
 	model: undefined,
 	endTokenThreshold: 0.9,
+	maxTokensPerPart: 250,
+	useOptimizedAlignmentHeads: true,
+
 	encoderProvider: undefined,
-	decoderProvider: undefined
+	decoderProvider: undefined,
 }
 
 // Language detection options

package/src/source-separation/MDXNetSourceSeparation.ts

@@ -6,6 +6,7 @@ import { Logger } from '../utilities/Logger.js'
 import { OnnxExecutionProvider, dmlProviderAvailable, getOnnxSessionOptions } from '../utilities/OnnxUtilities.js'
 import chalk from 'chalk'
 import { WindowedList } from '../utilities/WindowedList.js'
+import { logLevelGreaterOrEqualTo } from '../api/API.js'
 
 const log = logToStderr
 
@@ -13,9 +14,9 @@ export async function isolate(
 	rawAudio: RawAudio,
 	modelFilePath: string,
 	modelProfile: MDXNetModelProfile,
-	executionProviders: OnnxExecutionProvider[]) {
+	options: MDXNetOptions) {
 
-	const model = new MDXNet(modelFilePath, modelProfile, executionProviders)
+	const model = new MDXNet(modelFilePath, modelProfile, options)
 
 	return model.processAudio(rawAudio)
 }
@@ -27,11 +28,11 @@ export class MDXNet {
 	constructor(
 		public readonly modelFilePath: string,
 		public readonly modelProfile: MDXNetModelProfile,
-		public readonly executionProviders: OnnxExecutionProvider[]) {
+		public readonly options: MDXNetOptions) {
 	}
 
 	async processAudio(rawAudio: RawAudio) {
-		if (rawAudio.audioChannels.length != 2) {
+		if (rawAudio.audioChannels.length !== 2) {
 			throw new Error(`Input audio must be stereo`)
 		}
 
@@ -43,12 +44,18 @@ export class MDXNet {
 			return getEmptyRawAudio(rawAudio.audioChannels.length, rawAudio.sampleRate)
 		}
 
+		const enableTraceLogging = logLevelGreaterOrEqualTo('trace')
+
 		const logger = new Logger()
 
-		await logger.startAsync(`Initialize MDXNet model`)
+		await logger.startAsync(`Initialize session for MDX-NET model '${this.options.model!}'`)
 
 		await this.initializeSessionIfNeeded()
 
+		logger.end()
+
+		logger.logTitledMessage(`Using ONNX execution provider`, `${this.onnxSessionOptions!.executionProviders!.join(', ')}`)
+
 		const Onnx = await import('onnxruntime-node')
 
 		const sampleRate = this.modelProfile.sampleRate
@@ -81,7 +88,11 @@ export class MDXNet {
 
 			const timePosition = segmentStartFrameOffset * (fftHopSize / sampleRate)
 
-			await logger.startAsync(`Compute STFT of segment at time position ${timePosition.toFixed(2)}`, undefined, chalk.magentaBright)
+			if (enableTraceLogging) {
+				await logger.startAsync(`Compute STFT of segment at time position ${timePosition.toFixed(2)}`, undefined, chalk.magentaBright)
+			} else {
+				await logger.startAsync(`Process segment at time position ${timePosition.toFixed(2)}`)
+			}
 
 			while (fftFramesLeftWindowedList.endOffset < segmentEndFrameOffset) {
 				const nextLeftFrameResult = await fftFramesLeftGenerator.next()
@@ -109,7 +120,9 @@ export class MDXNet {
 
 			const isLastSegment = segmentLength < segmentSize
 
-			await logger.startAsync(`Reshape STFT frames`)
+			if (enableTraceLogging) {
+				await logger.startAsync(`Reshape STFT frames`)
+			}
 
 			const flattenedInputTensor = new Float32Array(1 * 4 * binCount * segmentSize)
 
@@ -142,13 +155,17 @@ export class MDXNet {
 				}
 			}
 
-			await logger.startAsync(`Process with MDXNet model (ONNX provider: ${this.onnxSessionOptions!.executionProviders!.join(', ')})`)
+			if (enableTraceLogging) {
+				await logger.startAsync(`Process segment with MDXNet model`)
+			}
 
 			const inputTensor = new Onnx.Tensor('float32', flattenedInputTensor, [1, 4, binCount, segmentSize])
 
 			const { output: outputTensor } = await this.session!.run({ input: inputTensor })
 
-			await logger.startAsync('Reshape processed frames')
+			if (enableTraceLogging) {
+				await logger.startAsync('Reshape processed frames')
+			}
 
 			const flattenedOutputTensor = outputTensor.data as Float32Array
 
@@ -191,7 +208,9 @@ export class MDXNet {
 
 			const outputAudioChannels: Float32Array[] = []
 
-			await logger.startAsync(`Compute inverse STFT of model output for segment`)
+			if (enableTraceLogging) {
+				await logger.startAsync(`Compute inverse STFT of model output for segment`)
+			}
 
 			for (let channelIndex = 0; channelIndex < 2; channelIndex++) {
 				const samples = await stiftr(
@@ -268,13 +287,16 @@ export class MDXNet {
 
 		const Onnx = await import('onnxruntime-node')
 
-		this.onnxSessionOptions = getOnnxSessionOptions({ executionProviders: this.executionProviders })
+		const executionProviders: OnnxExecutionProvider[] =
+			this.options.provider ? [this.options.provider] : getDefaultMDXNetProviders()
+
+		this.onnxSessionOptions = getOnnxSessionOptions({ executionProviders })
 
 		this.session = await Onnx.InferenceSession.create(this.modelFilePath, this.onnxSessionOptions)
 	}
 }
 
-export function getDefaultMDXNetProviders() : OnnxExecutionProvider[] {
+export function getDefaultMDXNetProviders(): OnnxExecutionProvider[] {
 	if (dmlProviderAvailable()) {
 		return ['dml', 'cpu']
 	} else {
@@ -344,3 +366,13 @@ export type MDXNetModelName =
 	'UVR_MDXNET_Main' |
 	'Kim_Vocal_1' |
 	'Kim_Vocal_2'
+
+export interface MDXNetOptions {
+	model?: MDXNetModelName
+	provider?: OnnxExecutionProvider
+}
+
+export const defaultMDXNetOptions: MDXNetOptions = {
+	model: 'UVR_MDXNET_1_9703',
+	provider: undefined,
+}

package/src/typings/Fillers.d.ts

@@ -56,6 +56,8 @@ declare module '@echogarden/rnnoise-wasm'
 declare module '@echogarden/fvad-wasm'
 declare module '@echogarden/sonic-wasm'
 declare module '@echogarden/kissfft-wasm'
+declare module '@echogarden/pffft-wasm'
+declare module '@echogarden/pffft-wasm/simd'
 declare module '@echogarden/speex-resampler-wasm'
 declare module '@echogarden/vosk'
 

package/src/utilities/PackageManager.ts

@@ -192,13 +192,9 @@ const packageVersionTagResolutionLookup: { [packageName: string]: string } = {
 	'whisper.cpp-large-v3-turbo-q5_0': '20241003',
 
 	// whisper.cpp binaries
-	'whisper.cpp-binaries-linux-x64-cpu-1.6.2': '20241001',
-	'whisper.cpp-binaries-windows-x64-cpu-1.6.2': '20241001',
-	'whisper.cpp-binaries-windows-x64-cublas-12.4.0-1.6.2': '20241002',
-
-	'whisper.cpp-binaries-linux-x64-cpu-latest': '20241003',
-	'whisper.cpp-binaries-windows-x64-cpu-latest': '20241003',
-	'whisper.cpp-binaries-windows-x64-cublas-12.4.0-latest': '20241003',
+	'whisper.cpp-binaries-linux-x64-cpu-latest': '20241010',
+	'whisper.cpp-binaries-windows-x64-cpu-latest': '20241010',
+	'whisper.cpp-binaries-windows-x64-cublas-12.4.0-latest': '20241010',
 
 	// E5 models
 	'xenova-multilingual-e5-small-q8': '20240504',