echogarden 2.10.2 → 3.0.1

package/src/server/Client.ts

@@ -1,7 +1,7 @@
 import { WebSocket } from 'ws'
 import { encode as encodeMsgPack, decode as decodeMsgPack } from 'msgpack-lite'
-import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentEvent, SynthesisResult, VoiceListRequestOptions } from '../api/Synthesis.js'
-import { SynthesisResponseMessage, SynthesisSegmentEventMessage, SynthesisSentenceEventMessage, VoiceListRequestMessage, WorkerRequestMessage, VoiceListResponseMessage, AlignmentRequestMessage, AlignmentResponseMessage, RecognitionRequestMessage, RecognitionResponseMessage, SpeechTranslationRequestMessage, SpeechTranslationResponseMessage, SpeechLanguageDetectionRequestMessage, SpeechLanguageDetectionResponseMessage, TextLanguageDetectionResponseMessage, TextLanguageDetectionRequestMessage, SynthesisRequestMessage } from './Worker.js'
+import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentCallback, SynthesisResult, VoiceListRequestOptions } from '../api/Synthesis.js'
+import { SynthesisResponseMessage, SynthesisSegmentCallbackMessage, SynthesisSentenceCallbackMessage, VoiceListRequestMessage, WorkerRequestMessage, VoiceListResponseMessage, AlignmentRequestMessage, AlignmentResponseMessage, RecognitionRequestMessage, RecognitionResponseMessage, SpeechTranslationRequestMessage, SpeechTranslationResponseMessage, SpeechLanguageDetectionRequestMessage, SpeechLanguageDetectionResponseMessage, TextLanguageDetectionResponseMessage, TextLanguageDetectionRequestMessage, SynthesisRequestMessage } from './Worker.js'
 import { getRandomHexString, logToStderr } from '../utilities/Utilities.js'
 import { OpenPromise } from '../utilities/OpenPromise.js'
 import { AudioSourceParam, RawAudio } from '../audio/AudioUtilities.js'
@@ -62,7 +62,7 @@ export class Client {
 		}
 	}
 
-	async synthesize(input: string | string[], options: SynthesisOptions, onSegment?: SynthesisSegmentEvent, onSentence?: SynthesisSegmentEvent): Promise<SynthesisResult> {
+	async synthesize(input: string | string[], options: SynthesisOptions, onSegment?: SynthesisSegmentCallback, onSentence?: SynthesisSegmentCallback): Promise<SynthesisResult> {
 		const requestOpenPromise = new OpenPromise<SynthesisResult>()
 
 		const requestMessage: SynthesisRequestMessage = {
@@ -71,7 +71,7 @@ export class Client {
 			options
 		}
 
-		function onResponse(responseMessage: SynthesisResponseMessage | SynthesisSegmentEventMessage | SynthesisSentenceEventMessage) {
+		function onResponse(responseMessage: SynthesisResponseMessage | SynthesisSegmentCallbackMessage | SynthesisSentenceCallbackMessage) {
 			if (responseMessage.messageType == 'SynthesisResponse') {
 				requestOpenPromise.resolve(responseMessage)
 			} else if (responseMessage.messageType == 'SynthesisSegmentEvent' && onSegment) {

package/src/server/Worker.ts

@@ -1,17 +1,17 @@
-import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentEventData, SynthesisResult, VoiceListRequestOptions, requestVoiceList, synthesize } from '../api/Synthesis.js'
+import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentCallbackData, SynthesisResult, VoiceListRequestOptions, requestVoiceList, synthesize, VoiceListRequestCallbacks, SynthesisCallbacks } from '../api/Synthesis.js'
 import { Queue } from '../data-structures/Queue.js'
 import { logToStderr, yieldToEventLoop } from '../utilities/Utilities.js'
 import { AudioSourceParam } from '../audio/AudioUtilities.js'
-import { RecognitionOptions, RecognitionResult, recognize } from '../api/Recognition.js'
-import { AlignmentOptions, AlignmentResult, align } from '../api/Alignment.js'
-import { SpeechTranslationOptions, SpeechTranslationResult, translateSpeech } from '../api/SpeechTranslation.js'
-import { resetActiveLogger } from '../utilities/Logger.js'
+import { RecognitionCallbacks, RecognitionOptions, RecognitionResult, recognize } from '../api/Recognition.js'
+import { AlignmentCallbacks, AlignmentOptions, AlignmentResult, align } from '../api/Alignment.js'
+import { SpeechTranslationCallbacks, SpeechTranslationOptions, SpeechTranslationResult, translateSpeech } from '../api/SpeechTranslation.js'
 import { writeToStderr } from '../utilities/Utilities.js'
-import { Worker, SHARE_ENV } from 'node:worker_threads'
-import { SpeechLanguageDetectionOptions, SpeechLanguageDetectionResult, detectSpeechLanguage } from '../api/SpeechLanguageDetection.js'
-import chalk from 'chalk'
+import { SpeechLanguageDetectionCallbacks, SpeechLanguageDetectionOptions, SpeechLanguageDetectionResult, detectSpeechLanguage } from '../api/SpeechLanguageDetection.js'
 import { resolveToModuleRootDir } from '../utilities/PathUtilities.js'
-import { TextLanguageDetectionOptions, TextLanguageDetectionResult, detectTextLanguage } from '../api/TextLanguageDetection.js'
+import { TextLanguageDetectionCallbacks, TextLanguageDetectionOptions, TextLanguageDetectionResult, detectTextLanguage } from '../api/TextLanguageDetection.js'
+import { OperationCallbacks } from '../api/Common.js'
+import { getGlobalLogLevel } from '../api/GlobalOptions.js'
+import { Logger } from '../utilities/Logger.js'
 
 const log = logToStderr
 
@@ -19,8 +19,6 @@ let messageChannel: MessageChannel | undefined = undefined
 
 const canceledRequests = new Set<string>()
 
-let cancelCurrentTask = false
-
 const messageQueue = new Queue<any>()
 let isProcessing = false
 
@@ -44,10 +42,6 @@ export function startMessageChannel() {
 	})
 }
 
-export function shouldCancelCurrentTask() {
-	return cancelCurrentTask
-}
-
 function enqueueAndProcessIfIdle(message: any) {
 	messageQueue.enqueue(message)
 	processQueueIfIdle()
@@ -71,27 +65,34 @@ async function processQueueIfIdle() {
 			})
 		}
 
-		function setCancellationFlagIfNeeded() {
+		const abortController = new AbortController()
+		const abortSignal = abortController.signal
+
+		const callbacks: OperationCallbacks = {
+			logLevel: getGlobalLogLevel(),
+			abortSignal: abortController.signal
+		}
+
+		function sendAbortSignalIfNeeded() {
 			if (canceledRequests.has(requestId)) {
-				cancelCurrentTask = true
+				abortController.abort()
 				canceledRequests.delete(requestId)
 			}
 		}
 
 		await yieldToEventLoop()
 
-		setCancellationFlagIfNeeded()
-		const cancellationFlagSetterInterval = setInterval(setCancellationFlagIfNeeded, 20)
+		sendAbortSignalIfNeeded()
+		const abortSignalSenderInterval = setInterval(sendAbortSignalIfNeeded, 20)
 
 		try {
-			if (cancelCurrentTask) {
-				//log(`******* CANCELED BEFORE START: ${requestId} *******`)
-				throw new Error('Canceled')
-			}
+			abortSignal.throwIfAborted()
 
-			await processMessage(incomingMessage, sendMessage)
+			await processMessage(incomingMessage, sendMessage, callbacks)
 		} catch (e: any) {
-			log(`${chalk.redBright('Error')}: ${e.message}`)
+			const logger = new Logger(getGlobalLogLevel())
+
+			logger.logTitledMessage('Error', e.message, 'error')
 
 			sendMessageToClient({
 				requestId,
@@ -99,50 +100,47 @@ async function processQueueIfIdle() {
 				error: e
 			})
 		} finally {
-			resetActiveLogger()
-
-			clearInterval(cancellationFlagSetterInterval)
-			cancelCurrentTask = false
+			clearInterval(abortSignalSenderInterval)
 		}
 	}
 
 	isProcessing = false
 }
 
-export async function processMessage(message: WorkerRequestMessage, sendMessage: MessageFunc) {
+export async function processMessage(message: WorkerRequestMessage, sendMessage: MessageFunc, callbacks: OperationCallbacks) {
 	switch (message.messageType) {
 		case 'SynthesisRequest': {
-			await processSynthesisRequest(message, sendMessage)
+			await processSynthesisRequest(message, sendMessage, callbacks)
 			break
 		}
 
 		case 'VoiceListRequest': {
-			await processVoiceListRequest(message, sendMessage)
+			await processVoiceListRequest(message, sendMessage, callbacks)
 			break
 		}
 
 		case 'RecognitionRequest': {
-			await processRecognitionRequest(message, sendMessage)
+			await processRecognitionRequest(message, sendMessage, callbacks)
 			break
 		}
 
 		case 'AlignmentRequest': {
-			await processAlignmentRequest(message, sendMessage)
+			await processAlignmentRequest(message, sendMessage, callbacks)
 			break
 		}
 
 		case 'SpeechTranslationRequest': {
-			await processSpeechTranslationRequest(message, sendMessage)
+			await processSpeechTranslationRequest(message, sendMessage, callbacks)
 			break
 		}
 
 		case 'SpeechLanguageDetectionRequest': {
-			await processSpeechLanguageDetectionRequest(message, sendMessage)
+			await processSpeechLanguageDetectionRequest(message, sendMessage, callbacks)
 			break
 		}
 
 		case 'TextLanguageDetectionRequest': {
-			await processTextLanguageDetectionRequest(message, sendMessage)
+			await processTextLanguageDetectionRequest(message, sendMessage, callbacks)
 			break
 		}
 
@@ -155,9 +153,9 @@ export async function processMessage(message: WorkerRequestMessage, sendMessage:
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // Synthesis operations
 ///////////////////////////////////////////////////////////////////////////////////////////////
-async function processSynthesisRequest(message: SynthesisRequestMessage, sendMessage: MessageFunc) {
-	async function onSegment(eventData: SynthesisSegmentEventData) {
-		const responseMessage: SynthesisSegmentEventMessage = {
+async function processSynthesisRequest(message: SynthesisRequestMessage, sendMessage: MessageFunc, callbacks: SynthesisCallbacks) {
+	async function onSegment(eventData: SynthesisSegmentCallbackData) {
+		const responseMessage: SynthesisSegmentCallbackMessage = {
 			messageType: 'SynthesisSegmentEvent',
 			...eventData
 		}
@@ -165,8 +163,8 @@ async function processSynthesisRequest(message: SynthesisRequestMessage, sendMes
 		sendMessage(responseMessage)
 	}
 
-	async function onSentence(eventData: SynthesisSegmentEventData) {
-		const responseMessage: SynthesisSentenceEventMessage = {
+	async function onSentence(eventData: SynthesisSegmentCallbackData) {
+		const responseMessage: SynthesisSentenceCallbackMessage = {
 			messageType: 'SynthesisSentenceEvent',
 			...eventData
 		}
@@ -174,7 +172,7 @@ async function processSynthesisRequest(message: SynthesisRequestMessage, sendMes
 		sendMessage(responseMessage)
 	}
 
-	const result = await synthesize(message.input, message.options, onSegment, onSentence)
+	const result = await synthesize(message.input, message.options, { ...callbacks, onSegment, onSentence })
 
 	const responseMessage: SynthesisResponseMessage = {
 		messageType: 'SynthesisResponse',
@@ -195,16 +193,16 @@ export interface SynthesisResponseMessage extends WorkerMessageBase, SynthesisRe
 	messageType: 'SynthesisResponse'
 }
 
-export interface SynthesisSegmentEventMessage extends WorkerMessageBase, SynthesisSegmentEventData {
+export interface SynthesisSegmentCallbackMessage extends WorkerMessageBase, SynthesisSegmentCallbackData {
 	messageType: 'SynthesisSegmentEvent'
 }
 
-export interface SynthesisSentenceEventMessage extends WorkerMessageBase, SynthesisSegmentEventData {
+export interface SynthesisSentenceCallbackMessage extends WorkerMessageBase, SynthesisSegmentCallbackData {
 	messageType: 'SynthesisSentenceEvent'
 }
 
-async function processVoiceListRequest(message: VoiceListRequestMessage, sendMessage: MessageFunc) {
-	const result = await requestVoiceList(message.options)
+async function processVoiceListRequest(message: VoiceListRequestMessage, sendMessage: MessageFunc, callbacks: VoiceListRequestCallbacks) {
+	const result = await requestVoiceList(message.options, callbacks)
 
 	const responseMessage: VoiceListResponseMessage = {
 		messageType: 'VoiceListResponse',
@@ -227,8 +225,8 @@ export interface VoiceListResponseMessage extends WorkerMessageBase, RequestVoic
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // Recognition operations
 ///////////////////////////////////////////////////////////////////////////////////////////////
-async function processRecognitionRequest(message: RecognitionRequestMessage, sendMessage: MessageFunc) {
-	const result = await recognize(message.input, message.options)
+async function processRecognitionRequest(message: RecognitionRequestMessage, sendMessage: MessageFunc, callbacks: RecognitionCallbacks) {
+	const result = await recognize(message.input, message.options, callbacks)
 
 	const responseMessage: RecognitionResponseMessage = {
 		messageType: 'RecognitionResponse',
@@ -252,8 +250,8 @@ export interface RecognitionResponseMessage extends WorkerMessageBase, Recogniti
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // Alignment operations
 ///////////////////////////////////////////////////////////////////////////////////////////////
-async function processAlignmentRequest(message: AlignmentRequestMessage, sendMessage: MessageFunc) {
-	const result = await align(message.input, message.transcript, message.options)
+async function processAlignmentRequest(message: AlignmentRequestMessage, sendMessage: MessageFunc, callbacks: AlignmentCallbacks) {
+	const result = await align(message.input, message.transcript, message.options, callbacks)
 
 	const responseMessage: AlignmentResponseMessage = {
 		messageType: 'AlignmentResponse',
@@ -278,8 +276,8 @@ export interface AlignmentResponseMessage extends WorkerMessageBase, AlignmentRe
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // Speech translation operations
 ///////////////////////////////////////////////////////////////////////////////////////////////
-async function processSpeechTranslationRequest(message: SpeechTranslationRequestMessage, sendMessage: MessageFunc) {
-	const result = await translateSpeech(message.input, message.options)
+async function processSpeechTranslationRequest(message: SpeechTranslationRequestMessage, sendMessage: MessageFunc, callbacks: SpeechTranslationCallbacks) {
+	const result = await translateSpeech(message.input, message.options, callbacks)
 
 	const responseMessage: SpeechTranslationResponseMessage = {
 		messageType: 'SpeechTranslationResponse',
@@ -303,8 +301,8 @@ export interface SpeechTranslationResponseMessage extends WorkerMessageBase, Spe
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // Speech Language detection operations
 ///////////////////////////////////////////////////////////////////////////////////////////////
-async function processSpeechLanguageDetectionRequest(message: SpeechLanguageDetectionRequestMessage, sendMessage: MessageFunc) {
-	const result = await detectSpeechLanguage(message.input, message.options)
+async function processSpeechLanguageDetectionRequest(message: SpeechLanguageDetectionRequestMessage, sendMessage: MessageFunc, callbacks: SpeechLanguageDetectionCallbacks) {
+	const result = await detectSpeechLanguage(message.input, message.options, callbacks)
 
 	const responseMessage: SpeechLanguageDetectionResponseMessage = {
 		messageType: 'SpeechLanguageDetectionResponse',
@@ -328,8 +326,8 @@ export interface SpeechLanguageDetectionResponseMessage extends WorkerMessageBas
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // Text Language detection operations
 ///////////////////////////////////////////////////////////////////////////////////////////////
-async function processTextLanguageDetectionRequest(message: TextLanguageDetectionRequestMessage, sendMessage: MessageFunc) {
-	const result = await detectTextLanguage(message.input, message.options)
+async function processTextLanguageDetectionRequest(message: TextLanguageDetectionRequestMessage, sendMessage: MessageFunc, callbacks: TextLanguageDetectionCallbacks) {
+	const result = await detectTextLanguage(message.input, message.options, callbacks)
 
 	const responseMessage: TextLanguageDetectionResponseMessage = {
 		messageType: 'TextLanguageDetectionResponse',
@@ -391,9 +389,11 @@ function ensureMessageChannelCreated() {
 // Worker thread methods
 ///////////////////////////////////////////////////////////////////////////////////////////////
 export async function startNewWorkerThread() {
-	const workerThread = new Worker(resolveToModuleRootDir('dist/server/WorkerStarter.js'), {
+	const WorkerThreads = await import('node:worker_threads')
+
+	const workerThread = new WorkerThreads.Worker(resolveToModuleRootDir('dist/server/WorkerStarter.js'), {
 		argv: process.argv.slice(2),
-		env: SHARE_ENV
+		env: WorkerThreads.SHARE_ENV
 	})
 
 	workerThread.on('message', (message) => {

package/src/source-separation/MDXNetSourceSeparation.ts

@@ -1,24 +1,22 @@
 import type * as Onnx from 'onnxruntime-node'
 import { getEmptyRawAudio, RawAudio } from '../audio/AudioUtilities.js'
 import { getWindowWeights, createStftrGenerator, stiftr, WindowType } from '../dsp/FFT.js'
-import { logToStderr } from '../utilities/Utilities.js'
 import { Logger } from '../utilities/Logger.js'
 import { OnnxExecutionProvider, dmlProviderAvailable, getOnnxSessionOptions } from '../utilities/OnnxUtilities.js'
 import chalk from 'chalk'
 import { WindowedList } from '../data-structures/WindowedList.js'
-import { logLevelGreaterOrEqualTo } from '../api/API.js'
-
-const log = logToStderr
+import { SourceSeparationCallbacks } from '../api/API.js'
 
 export async function isolate(
 	rawAudio: RawAudio,
 	modelFilePath: string,
 	modelProfile: MDXNetModelProfile,
-	options: MDXNetOptions) {
+	options: MDXNetOptions,
+	callbacks: SourceSeparationCallbacks) {
 
 	const model = new MDXNet(modelFilePath, modelProfile, options)
 
-	return model.processAudio(rawAudio)
+	return model.processAudio(rawAudio, callbacks)
 }
 
 export class MDXNet {
@@ -31,7 +29,7 @@ export class MDXNet {
 		public readonly options: MDXNetOptions) {
 	}
 
-	async processAudio(rawAudio: RawAudio) {
+	async processAudio(rawAudio: RawAudio, callbacks: SourceSeparationCallbacks) {
 		if (rawAudio.audioChannels.length !== 2) {
 			throw new Error(`Input audio must be stereo`)
 		}
@@ -44,9 +42,8 @@ export class MDXNet {
 			return getEmptyRawAudio(rawAudio.audioChannels.length, rawAudio.sampleRate)
 		}
 
-		const enableTraceLogging = logLevelGreaterOrEqualTo('trace')
-
-		const logger = new Logger()
+		const logger = new Logger(callbacks.logLevel)
+		const enableTraceLogging = logger.logLevelGreaterOrEqualTo('trace')
 
 		await logger.startAsync(`Initialize session for MDX-NET model '${this.options.model!}'`)
 
@@ -84,6 +81,8 @@ export class MDXNet {
 		const audioForSegments: Float32Array[][] = []
 
 		for (let segmentStartFrameOffset = 0; ; segmentStartFrameOffset += segmentHopSize) {
+			callbacks.abortSignal?.throwIfAborted()
+
 			const segmentEndFrameOffset = segmentStartFrameOffset + segmentSize
 
 			const timePosition = segmentStartFrameOffset * (fftHopSize / sampleRate)
@@ -225,6 +224,12 @@ export class MDXNet {
 
 			audioForSegments.push(outputAudioChannels)
 
+			if (callbacks.onSegment) {
+				const rawAudio: RawAudio = { audioChannels: outputAudioChannels, sampleRate }
+
+				await callbacks.onSegment(timePosition, rawAudio)
+			}
+
 			if (isLastSegment) {
 				break
 			}

package/src/speech-embeddings/WavToVec2BertFeatureEmbeddings.ts

@@ -6,14 +6,15 @@ import { computeMelSpectrogram } from "../dsp/MelSpectrogram.js";
 import { Logger } from '../utilities/Logger.js';
 import { concatFloat32Arrays, splitFloat32Array } from '../utilities/Utilities.js';
 import { applyEmphasis } from '../dsp/MFCC.js';
+import { OperationCallbacks } from '../api/Common.js';
 
-export function computeEmbeddings(audioSamples: RawAudio, modelFilePath: string, executionProviders: OnnxExecutionProvider[]) {
+export function computeEmbeddings(audioSamples: RawAudio, modelFilePath: string, executionProviders: OnnxExecutionProvider[], callbacks: OperationCallbacks) {
 	const wav2vecBert = new Wav2Vec2BertFeatureEmbeddings(
 		modelFilePath,
 		executionProviders,
 	)
 
-	const result = wav2vecBert.computeEmbeddings(audioSamples)
+	const result = wav2vecBert.computeEmbeddings(audioSamples, callbacks)
 
 	return result
 }
@@ -26,8 +27,8 @@ export class Wav2Vec2BertFeatureEmbeddings {
 		public readonly executionProviders: OnnxExecutionProvider[]) {
 	}
 
-	async computeEmbeddings(rawAudio: RawAudio) {
-		const logger = new Logger()
+	async computeEmbeddings(rawAudio: RawAudio, callbacks: OperationCallbacks) {
+		const logger = new Logger(callbacks.logLevel)
 
 		rawAudio.audioChannels[0] = applyEmphasis(rawAudio.audioChannels[0], 0.97)
 
@@ -39,7 +40,8 @@ export class Wav2Vec2BertFeatureEmbeddings {
 			80,
 			20,
 			8000,
-			'povey')
+			'povey',
+			callbacks)
 
 		// Ensure even length
 		if (melSpectrogram.length % 2 != 0) {

package/src/speech-language-detection/SileroLanguageDetection.ts

@@ -1,19 +1,22 @@
 import type * as Onnx from 'onnxruntime-node'
+
 import { softmax } from '../math/VectorMath.js'
 import { Logger } from '../utilities/Logger.js'
 import { RawAudio } from '../audio/AudioUtilities.js'
 import { readAndParseJsonFile } from '../utilities/FileSystem.js'
-import { detectSpeechLanguageByParts } from '../api/SpeechLanguageDetection.js'
+import { detectSpeechLanguageByParts, SpeechLanguageDetectionCallbacks } from '../api/SpeechLanguageDetection.js'
 import { languageCodeToName } from '../utilities/Locale.js'
 import { OnnxExecutionProvider, getOnnxSessionOptions } from '../utilities/OnnxUtilities.js'
 import { LanguageDetectionResults } from '../api/LanguageDetectionCommon.js'
+import { OperationCallbacks } from '../api/Common.js'
 
 export async function detectLanguage(
 	rawAudio: RawAudio,
 	modelPath: string,
 	languageDictionaryPath: string,
 	languageGroupDictionaryPath: string,
-	onnxExecutionProviders: OnnxExecutionProvider[]) {
+	onnxExecutionProviders: OnnxExecutionProvider[],
+	callbacks: SpeechLanguageDetectionCallbacks) {
 
 	const languageDetection = new SileroLanguageDetection(
 		modelPath,
@@ -22,12 +25,18 @@ export async function detectLanguage(
 		onnxExecutionProviders)
 
 	async function detectLanguageForPart(partAudio: RawAudio) {
-		const { languageResults } = await languageDetection.detectLanguage(partAudio)
+		const { languageResults } = await languageDetection.detectLanguage(partAudio, callbacks)
 
 		return languageResults
 	}
 
-	const results = await detectSpeechLanguageByParts(rawAudio, detectLanguageForPart)
+	const results = await detectSpeechLanguageByParts(
+		rawAudio,
+		detectLanguageForPart,
+		undefined,
+		undefined,
+		callbacks,
+	)
 
 	results.sort((a, b) => b.probability - a.probability)
 
@@ -47,10 +56,10 @@ export class SileroLanguageDetection {
 		public readonly onnxExecutionProviders: OnnxExecutionProvider[]) {
 	}
 
-	async detectLanguage(rawAudio: RawAudio) {
-		await this.initializeIfNeeded()
+	async detectLanguage(rawAudio: RawAudio, callbacks: SpeechLanguageDetectionCallbacks) {
+		await this.initializeIfNeeded(callbacks)
 
-		const logger = new Logger()
+		const logger = new Logger(callbacks.logLevel)
 
 		logger.start('Detect language with Silero')
 
@@ -99,12 +108,12 @@ export class SileroLanguageDetection {
 		return { languageResults, languageGroupResults }
 	}
 
-	async initializeIfNeeded() {
+	async initializeIfNeeded(callbacks: OperationCallbacks) {
 		if (this.session) {
 			return
 		}
 
-		const logger = new Logger()
+		const logger = new Logger(callbacks.logLevel)
 
 		logger.start('Initialize ONNX inference session for Silero language detection')
 

package/src/speech-search/DTWSpeechSearch.ts

@@ -1,21 +1,22 @@
 import { DtwGranularity, getMfccOptionsForGranularity } from "../alignment/SpeechAlignment.js";
+import { SpeechSearchCallbacks } from "../api/SpeechSearch.js";
 import { RawAudio } from "../audio/AudioUtilities.js";
 import { computeMFCCs, extendDefaultMfccOptions, MfccOptions } from "../dsp/MFCC.js";
 import { euclideanDistance13Dim } from "../math/VectorMath.js";
 import { Logger } from "../utilities/Logger.js";
 
-export async function searchSpeech(sourceRawAudio: RawAudio, queryRawAudio: RawAudio) {
-	const logger = new Logger()
+export async function searchSpeech(sourceRawAudio: RawAudio, queryRawAudio: RawAudio, callbacks: SpeechSearchCallbacks) {
+	const logger = new Logger(callbacks.logLevel)
 
 	const granularity: DtwGranularity = 'low'
 
 	const mfccOptions = extendDefaultMfccOptions({ ...getMfccOptionsForGranularity(granularity), zeroFirstCoefficient: true }) as MfccOptions
 
 	logger.start('Compute query MFCC features')
-	const queryMfccs = await computeMFCCs(queryRawAudio, mfccOptions)
+	const queryMfccs = await computeMFCCs(queryRawAudio, mfccOptions, callbacks)
 
 	logger.start('Compute source MFCC features')
-	const sourceMfccs = await computeMFCCs(sourceRawAudio, mfccOptions)
+	const sourceMfccs = await computeMFCCs(sourceRawAudio, mfccOptions, callbacks)
 
 	logger.start('Compute cost matrix')
 
@@ -31,7 +32,7 @@ export async function searchSpeech(sourceRawAudio: RawAudio, queryRawAudio: RawA
 	for (let rowStartOffset = 0; rowStartOffset < rowCount; rowStartOffset++) {
 		const rowEndOffset = Math.min(rowStartOffset + maxSearchWindow, rowCount)
 
-		
+
 	}
 }