echogarden 1.7.0 → 1.8.1

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
 			}
 
@@ -497,7 +497,7 @@ export class Whisper {
 
 		logger.end()
 
-		return { transcript, timeline }
+		return { transcript, timeline, allDecodedTokens }
 	}
 
 	async align(rawAudio: RawAudio, transcript: string, sourceLanguage: string, task: 'transcribe' | 'translate', whisperAlignmentOptions: WhisperAlignmentOptions) {
@@ -523,8 +523,10 @@ export class Whisper {
 			}
 		} else {
 			let words = await splitToWords(transcript, targetLanguage)
+
 			words = words.map(word => word.trim())
 			words = words.filter(word => isWord(word))
+
 			simplifiedTranscript = words.join(' ')
 		}
 
@@ -566,17 +568,64 @@ 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,
 		}
 
 		// Recognize
-		const { timeline } = await this.recognize(rawAudio, task, sourceLanguage, options, logitFilter)
+		const { timeline, allDecodedTokens } = await this.recognize(rawAudio, task, sourceLanguage, options, logitFilter)
+
+		{
+			// If not all tokens were decoded, add the remaining ones to the timeline
+			const lastKnownWordStartTime = timeline.length > 0 ? timeline[timeline.length - 1].startTime : 0
+
+			const allDecodedTextTokens = allDecodedTokens.filter(token => this.isTextToken(token))
+
+			while (allDecodedTextTokens.length < simplifiedTranscriptTokens.length) {
+				const token = simplifiedTranscriptTokens[allDecodedTextTokens.length]
+				const tokenText = this.tokenToText(token)
+
+				allDecodedTextTokens.push(token)
+
+				const newTokenEntry: TimelineEntry = {
+					type: 'token',
+					text: tokenText,
+
+					startTime: lastKnownWordStartTime,
+					endTime: lastKnownWordStartTime,
+
+					id: token,
+					confidence: 0,
+				}
+
+				if (tokenText.startsWith(' ') || timeline.length === 0) {
+					timeline.push({
+						type: 'word',
+						text: tokenText.trim(),
+
+						startTime: lastKnownWordStartTime,
+						endTime: lastKnownWordStartTime,
+
+						timeline: [newTokenEntry],
+
+						confidence: 0,
+					})
+				} else {
+					const lastWordEntry = timeline[timeline.length - 1]
+
+					lastWordEntry.timeline!.push(newTokenEntry)
+					lastWordEntry.text += tokenText
+				}
+			}
+		}
 
 		return timeline
 	}
@@ -1103,7 +1152,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 +1178,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 +2490,7 @@ export interface WhisperOptions {
 	decodeTimestampTokens?: boolean
 	endTokenThreshold?: number
 	includeEndTokenInCandidates?: boolean
+	useOptimizedAlignmentHeads?: boolean,
 	encoderProvider?: OnnxExecutionProvider
 	decoderProvider?: OnnxExecutionProvider
 	seed?: number
@@ -2458,6 +2509,7 @@ export const defaultWhisperOptions: WhisperOptions = {
 	decodeTimestampTokens: true,
 	endTokenThreshold: 0.9,
 	includeEndTokenInCandidates: true,
+	useOptimizedAlignmentHeads: true,
 	encoderProvider: undefined,
 	decoderProvider: undefined,
 	seed: undefined,
@@ -2467,6 +2519,9 @@ export const defaultWhisperOptions: WhisperOptions = {
 export interface WhisperAlignmentOptions {
 	model?: WhisperModelName
 	endTokenThreshold?: number
+	maxTokensPerPart?: number
+	useOptimizedAlignmentHeads?: boolean
+
 	encoderProvider?: OnnxExecutionProvider
 	decoderProvider?: OnnxExecutionProvider
 }
@@ -2474,8 +2529,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