echogarden 1.6.2 → 1.8.0

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/build-tools/MakeTarballsForInstalledPackages.ts

@@ -0,0 +1,25 @@
+import path from 'path'
+import { existsSync, readdir } from '../utilities/FileSystem.js'
+import { ensureAndGetPackagesDir } from '../utilities/PackageManager.js'
+import { createNamedTarball } from '../utilities/TarballMaker.js'
+import { setupProgramTerminationListeners } from '../utilities/Utilities.js'
+
+async function makeTarballsForInstalledPackages(tarballDir: string, skipIfExists = false) {
+	const packagesDir = await ensureAndGetPackagesDir()
+	const packageList = await readdir(packagesDir)
+
+	for (const packageName of packageList) {
+		if (skipIfExists && existsSync(path.join(tarballDir, `${packageName}.tar.gz`))) {
+			continue
+		}
+
+		const packagePath = path.join(packagesDir, packageName)
+		await createNamedTarball(packagePath, packageName, tarballDir)
+	}
+}
+
+setupProgramTerminationListeners()
+
+await makeTarballsForInstalledPackages('../resources/tarballs', true)
+
+process.exit(0)

package/src/cli/CLI.ts

@@ -1,6 +1,6 @@
 import * as API from '../api/API.js'
 import { parseCLIArguments } from './CLIParser.js'
-import { convertHtmlToText, formatIntegerWithLeadingZeros, formatListWithQuotedElements, getWithDefault, logToStderr, setupUnhandledExceptionListeners, splitFilenameOnExtendedExtension, stringifyAndFormatJson } from '../utilities/Utilities.js'
+import { getWithDefault, logToStderr, setupUnhandledExceptionListeners, splitFilenameOnExtendedExtension, stringifyAndFormatJson } from '../utilities/Utilities.js'
 import { getOptionTypeFromSchema, SchemaTypeDefinition } from './CLIOptionsSchema.js'
 import { ParsedConfigFile, parseConfigFile, parseJSONConfigFile } from './CLIConfigFile.js'
 
@@ -26,6 +26,7 @@ import { OpenPromise } from '../utilities/OpenPromise.js'
 import JSON5 from 'json5'
 import { getLowercaseFileExtension, resolveToModuleRootDir } from '../utilities/PathUtilities.js'
 import { CLIOptions, CLIOptionsKeys } from './CLIOptions.js'
+import { convertHtmlToText, formatIntegerWithLeadingZeros, formatListWithQuotedElements } from '../utilities/StringUtilities.js'
 
 //const log = logToStderr
 
@@ -1049,7 +1050,7 @@ export async function translateText(operationData: CLIOperationData) {
 	} else if (inputFileExtension == 'srt' || inputFileExtension == 'vtt') {
 		inputText = subtitlesToText(inputFileContent)
 	} else {
-		throw new Error(`align only supports reference files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`)
+		throw new Error(`translate-text only supports input files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`)
 	}
 
 	const options = await optionsLookupToTypedObject(operationOptionsLookup, 'TextTranslationOptions')
@@ -1066,7 +1067,7 @@ export async function translateText(operationData: CLIOperationData) {
 
 		sourceLanguage,
 		targetLanguage,
-	} = await API.translateText(inputFileContent, options)
+	} = await API.translateText(inputText, options)
 
 	if (outputFilenames.length > 0) {
 		logger.start('\nWrite output files')

package/src/dsp/FFT.ts

@@ -1,13 +1,22 @@
-import { RawAudio } from '../audio/AudioUtilities.js'
-import { ComplexNumber, sumVector } from '../math/VectorMath.js'
+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[] = []
+
+	for await (const frame of stftrGenerator(samples, fftOrder, windowSize, hopSize, windowType)) {
+		frames.push(frame)
+	}
+
+	return frames
+}
+
+// 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) {
-		throw new Error('FFT order and window size must multiples of 2')
+		throw new Error('FFT order and window size must be multiples of 2')
 	}
 
 	if (windowSize > fftOrder) {
@@ -25,17 +34,18 @@ export async function stftr(samples: Float32Array, fftOrder: number, windowSize:
 
 	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 frames: Float32Array[] = []
+	const workBufferRef = wasmMemory.allocFloat32Array(fftOrder * 2)
 
 	for (let offset = 0; offset < sampleCount; offset += hopSize) {
 		const windowSamples = samples.subarray(offset, offset + windowSize)
@@ -49,17 +59,19 @@ export async function stftr(samples: Float32Array, fftOrder: number, windowSize:
 
 		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)
-		frames.push(bins)
+
+		yield bins
 	}
 
-	wasmMemory.freeAll()
+	m._pffft_destroy_setup(statePtr)
 
-	return frames
+	wasmMemory.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) {
 		throw new Error('FFT order and window size must multiples of 2')
@@ -87,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 wasmMemory = new WasmMemoryManager(m, {
+		wasmAlloc: m._pffft_aligned_malloc,
+		wasmFree: m._pffft_aligned_free
+	})
 
-	const statePtr = m._kiss_fftr_alloc(fftOrder, 1, 0, 0)
-	wasmMemory.wrapPointer(statePtr)
+	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)
 
@@ -105,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
 
@@ -123,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
@@ -135,6 +152,7 @@ export async function stiftr(binsForFrames: Float32Array[], fftOrder: number, wi
 	return outSamplesTrimmed
 }
 
+// Get bin frequency thresholds for a particular bin count and maximum frequency
 export function getBinFrequencies(binCount: number, maxFrequency: number) {
 	const binFrequencies = new Float32Array(binCount)
 	const frequencyStep = maxFrequency / (binCount - 1)
@@ -146,10 +164,12 @@ export function getBinFrequencies(binCount: number, maxFrequency: number) {
 	return binFrequencies
 }
 
+// Convert an array of raw FFT frames to a power spectrum
 export function fftFramesToPowerSpectogram(fftFrames: Float32Array[]) {
 	return fftFrames.map(fftFrame => fftFrameToPowerSpectrum(fftFrame))
 }
 
+// Convert a raw FFT frame to a power spectrum
 export function fftFrameToPowerSpectrum(fftFrame: Float32Array) {
 	const powerSpectrum = new Float32Array(fftFrame.length / 2)
 
@@ -165,6 +185,7 @@ export function fftFrameToPowerSpectrum(fftFrame: Float32Array) {
 	return powerSpectrum
 }
 
+// Convert raw FFT frames to an array of complex numbers
 export function binBufferToComplex(bins: Float32Array, extendAndMirror = false) {
 	const complexBins: ComplexNumber[] = []
 
@@ -191,6 +212,7 @@ export function binBufferToComplex(bins: Float32Array, extendAndMirror = false)
 	return complexBins
 }
 
+// Convert an array of complex numbers to raw FFT frames
 export function complexToBinBuffer(complexBins: ComplexNumber[]) {
 	const binBuffer = new Float32Array(complexBins.length * 2)
 
@@ -204,16 +226,7 @@ export function complexToBinBuffer(complexBins: ComplexNumber[]) {
 	return binBuffer
 }
 
-export async function getKissFFTInstance() {
-	if (!kissFFTInstance) {
-		const { default: initializer } = await import('@echogarden/kissfft-wasm')
-
-		kissFFTInstance = await initializer()
-	}
-
-	return kissFFTInstance
-}
-
+// Get window weights for a particular window function
 export function getWindowWeights(windowType: WindowType, windowSize: number) {
 	const weights = new Float32Array(windowSize)
 
@@ -242,23 +255,33 @@ export function getWindowWeights(windowType: WindowType, windowSize: number) {
 	return weights
 }
 
-export async function testFFT1(rawAudio: RawAudio) {
-	const { resampleAudioSpeex } = await import('./SpeexResampler.js')
+export function isPffftSimdSupportedForFFTOrder(fftOrder: number) {
+	return fftOrder % 32 === 0
+}
+
+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')
 
-	const samples = (await resampleAudioSpeex(rawAudio, 16000)).audioChannels[0]
+	pffftNonSimdInstance = await initializer()
 
-	const fftOrder = 512
-	const windowSize = 320
-	const hopLength = windowSize / 2
-	const windowType: WindowType = 'hann'
+	return pffftNonSimdInstance
+}
 
-	const bins = await stftr(samples, fftOrder, windowSize, hopLength, windowType)
-	const normalizedBins = bins.map(bin => bin.map(x => x / fftOrder))
-	const recoveredSamples = await stiftr(normalizedBins, fftOrder, windowSize, hopLength, windowType, samples.length)
+// Get SIMD PFFFT instance (initialize new if not exists)
+async function getSimdPFFFTInstance() {
+	const { default: initializer } = await import('@echogarden/pffft-wasm/simd')
 
-	const recoveredRawAudio: RawAudio = { audioChannels: [recoveredSamples], sampleRate: 16000 }
+	pffftSimdInstance = await initializer()
 
-	return recoveredRawAudio
+	return pffftSimdInstance
 }
 
 export type WindowType = 'hann' | 'hamming' | 'povey'

package/src/nlp/Segmentation.ts

@@ -1,10 +1,11 @@
 import * as CldrSegmentation from 'cldr-segmentation'
 import { splitChineseTextToWords_Jieba } from './ChineseSegmentation.js'
 
-import { sumArray, includesAnyOf, indexOfAnyOf, logToStderr } from '../utilities/Utilities.js'
+import { sumArray, logToStderr } from '../utilities/Utilities.js'
 import { getShortLanguageCode } from '../utilities/Locale.js'
 import { splitJapaneseTextToWords_Kuromoji } from './JapaneseSegmentation.js'
 import { ParagraphBreakType, WhitespaceProcessing } from '../api/Common.js'
+import { includesAnyOf, indexOfAnyOf } from '../utilities/StringUtilities.js'
 
 const log = logToStderr
 

package/src/nlp/TextNormalizer.ts

@@ -1,4 +1,5 @@
 import { getShortLanguageCode } from '../utilities/Locale.js'
+import { substituteCharactersUsingLookup } from '../utilities/StringUtilities.js'
 
 export function getNormalizedFragmentsForSpeech(words: string[], language: string) {
 	language = getShortLanguageCode(language)
@@ -158,3 +159,62 @@ export function normalizeFourDigitDecadeString(decadeString: string) {
 
 	return normalizedString
 }
+
+export function simplifyPunctuationCharacters(text: string) {
+	return substituteCharactersUsingLookup(text, punctuationSubstitutionLookup)
+}
+
+export const punctuationSubstitutionLookup: Record<string, string> = {
+	'“': `"`,
+	'”': `"`,
+	'‟': `"`,
+	'ˮ': `"`,
+	'„': `"`,
+	'‹': `"`,
+	'›': `"`,
+	'❮': `"`,
+	'❯': '"',
+	'«': `"`,
+	'»': `"`,
+	'״': `"`,
+	'❝': `"`,
+	'❞': `"`,
+	'🙶': `"`,
+	'🙷': `"`,
+	'⹂': `"`,
+	'〝': `"`,
+	'〞': `"`,
+	'〟': `"`,
+	'＂': `"`,
+	'❠': `"`,
+	'🙸': `"`,
+
+	'ߵ': `'`,
+	'ߴ': `'`,
+	'’': `'`,
+	'‘': `'`,
+	'ʹ': `'`,
+	'ʼ': `'`,
+	'＇': `'`,
+	'ʻ': `'`,
+	'՚': `'`,
+	'՛': `'`,
+	'❛': `'`,
+	'❜': `'`,
+	'❟': `'`,
+
+	'，': `,`,
+	'、': `,`,
+
+	'：': `:`,
+
+	'；': `;`,
+
+	'。': `.`,
+
+	'？': `?`,
+	'؟': `?`,
+
+	'！': `!`,
+	'¡': `!`,
+}

package/src/recognition/WhisperSTT.ts

@@ -2,7 +2,7 @@ import type * as Onnx from 'onnxruntime-node'
 
 import { Logger } from '../utilities/Logger.js'
 import { computeMelSpectogramUsingFilterbanks, Filterbank } from '../dsp/MelSpectogram.js'
-import { clip, containsInvalidCodepoint, getIntegerRange, getTokenRepetitionScore, splitFloat32Array, yieldToEventLoop } from '../utilities/Utilities.js'
+import { clip, getIntegerRange, splitFloat32Array, yieldToEventLoop } from '../utilities/Utilities.js'
 import { indexOfMax, logOfVector, logSumExp, meanOfVector, softmax, stdDeviationOfVector } from '../math/VectorMath.js'
 
 import { alignDTWWindowed } from '../alignment/DTWSequenceAlignmentWindowed.js'
@@ -22,8 +22,9 @@ import { type Tiktoken } from 'tiktoken/lite'
 import { isPunctuation, isWhitespace, isWord, splitToSentences, splitToWords } from '../nlp/Segmentation.js'
 import { medianOf5Filter } from '../math/MedianFilter.js'
 import { getDeflateCompressionMetricsForString } from '../utilities/Compression.js'
-import { getOnnxSessionOptions, makeOnnxLikeFloat32Tensor, OnnxExecutionProvider, OnnxLikeFloat32Tensor } from '../utilities/OnnxUtilities.js'
+import { dmlProviderAvailable, getOnnxSessionOptions, makeOnnxLikeFloat32Tensor, OnnxExecutionProvider, OnnxLikeFloat32Tensor } from '../utilities/OnnxUtilities.js'
 import { murmurHash3_int32Input } from '../utilities/Hashing.js'
+import { containsInvalidCodepoint, getTokenRepetitionScore } from '../utilities/StringUtilities.js'
 
 export async function recognize(
 	sourceRawAudio: RawAudio,
@@ -458,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
 			}
 
@@ -565,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,
 		}
 
@@ -1102,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
@@ -1127,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')
 
@@ -1841,17 +1846,17 @@ export function isEnglishOnlyModel(modelName: WhisperModelName) {
 	return modelName.endsWith('.en')
 }
 
-function getDefaultEncoderProvidersForModel(modelName: WhisperModelName): OnnxExecutionProvider[] {
-	if (process.platform === 'win32') {
+export function getDefaultEncoderProvidersForModel(modelName: WhisperModelName): OnnxExecutionProvider[] {
+	if (dmlProviderAvailable()) {
 		return ['dml', 'cpu']
 	} else {
 		return []
 	}
 }
 
-function getDefaultDecoderProvidersForModel(modelName: WhisperModelName): OnnxExecutionProvider[] {
+export function getDefaultDecoderProvidersForModel(modelName: WhisperModelName): OnnxExecutionProvider[] {
 	if (modelName.startsWith('small') || modelName.startsWith('medium') || modelName.startsWith('large')) {
-		if (process.platform === 'win32') {
+		if (dmlProviderAvailable()) {
 			return ['dml', 'cpu']
 		} else {
 			return []
@@ -2439,6 +2444,7 @@ export interface WhisperOptions {
 	decodeTimestampTokens?: boolean
 	endTokenThreshold?: number
 	includeEndTokenInCandidates?: boolean
+	useOptimizedAlignmentHeads?: boolean,
 	encoderProvider?: OnnxExecutionProvider
 	decoderProvider?: OnnxExecutionProvider
 	seed?: number
@@ -2457,6 +2463,7 @@ export const defaultWhisperOptions: WhisperOptions = {
 	decodeTimestampTokens: true,
 	endTokenThreshold: 0.9,
 	includeEndTokenInCandidates: true,
+	useOptimizedAlignmentHeads: true,
 	encoderProvider: undefined,
 	decoderProvider: undefined,
 	seed: undefined,
@@ -2466,6 +2473,9 @@ export const defaultWhisperOptions: WhisperOptions = {
 export interface WhisperAlignmentOptions {
 	model?: WhisperModelName
 	endTokenThreshold?: number
+	maxTokensPerPart?: number
+	useOptimizedAlignmentHeads?: boolean
+
 	encoderProvider?: OnnxExecutionProvider
 	decoderProvider?: OnnxExecutionProvider
 }
@@ -2473,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