echogarden 2.10.2 → 3.0.0

package/src/api/Denoising.ts

@@ -1,24 +1,26 @@
+import chalk from 'chalk'
+
+import * as API from './API.js'
+
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 
 import { AudioSourceParam, RawAudio, applyGainDecibels, applyGainDecibelsInPlace, attenuateIfClippingInPlace, ensureRawAudio, getSamplePeakDecibels, mixAudio, normalizeAudioLevelInPlace } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 
-import { logToStderr } from '../utilities/Utilities.js'
 import { resampleAudioSpeex } from '../dsp/SpeexResampler.js'
 import { EngineMetadata } from './Common.js'
-import chalk from 'chalk'
 import { defaultNSNet2Options, NSNet2Options } from '../denoising/NSNet2.js'
 import { loadPackage } from '../utilities/PackageManager.js'
 
-const log = logToStderr
+export async function denoise(input: AudioSourceParam, options: DenoisingOptions, callbacks?: DenoisingCallbacks) {
+	options = extendDeep(defaultDenoisingOptions, options)
+	callbacks = { logLevel: API.getGlobalLogLevel(), ...callbacks }
+
+	const logger = new Logger(callbacks.logLevel)
 
-export async function denoise(input: AudioSourceParam, options: DenoisingOptions) {
-	const logger = new Logger()
 	const startTime = logger.getTimestamp()
 
-	options = extendDeep(defaultDenoisingOptions, options)
-
-	const inputRawAudio = await ensureRawAudio(input)
+	const inputRawAudio = await ensureRawAudio(input, undefined, undefined, callbacks)
 
 	logger.start(`Initialize ${options.engine} module`)
 
@@ -42,9 +44,9 @@ export async function denoise(input: AudioSourceParam, options: DenoisingOptions
 				const audioChannelRawAudio: RawAudio = { audioChannels: [audioChannel], sampleRate: processingSampleRate }
 
 				logger.end()
-				logger.logTitledMessage(`Denoise audio channel`, `${channelIndex}`, chalk.magentaBright)
+				logger.logTitledMessage(`Denoise audio channel`, `${channelIndex}`, 'info', chalk.magentaBright)
 
-				const { denoisedRawAudio, frameVadProbabilities } = await RNNoise.denoiseAudio(audioChannelRawAudio)
+				const { denoisedRawAudio, frameVadProbabilities } = await RNNoise.denoiseAudio(audioChannelRawAudio, callbacks)
 
 				logger.end()
 
@@ -78,7 +80,7 @@ export async function denoise(input: AudioSourceParam, options: DenoisingOptions
 			}
 
 			if (!nsnet2Options.modelDirectoryPath) {
-				nsnet2Options.modelDirectoryPath = await loadPackage(packageName)
+				nsnet2Options.modelDirectoryPath = await loadPackage(packageName, callbacks)
 			}
 
 			logger.start(`Resample audio to ${processingSampleRate} Hz`)
@@ -93,9 +95,9 @@ export async function denoise(input: AudioSourceParam, options: DenoisingOptions
 
 				logger.end()
 
-				logger.logTitledMessage(`Denoise audio channel`, `${channelIndex}`, chalk.magentaBright)
+				logger.logTitledMessage(`Denoise audio channel`, `${channelIndex}`, 'info', chalk.magentaBright)
 
-				const { denoisedAudio } = await NSNet2.denoiseAudio(audioChannelRawAudio, nsnet2Options)
+				const { denoisedAudio } = await NSNet2.denoiseAudio(audioChannelRawAudio, nsnet2Options, callbacks)
 
 				logger.end()
 
@@ -112,11 +114,11 @@ export async function denoise(input: AudioSourceParam, options: DenoisingOptions
 		}
 	}
 
-	logger.logTitledMessage(`Postprocess`, ``, chalk.magentaBright)
+	logger.logTitledMessage(`Postprocess`, ``, 'info', chalk.magentaBright)
 
 	logger.start(`Resample denoised audio (${denoisedAudio.sampleRate} Hz) back to original sample rate (${inputRawAudio.sampleRate} Hz)`)
 
-	denoisedAudio = await ensureRawAudio(denoisedAudio, inputRawAudio.sampleRate, inputRawAudio.audioChannels.length)
+	denoisedAudio = await ensureRawAudio(denoisedAudio, inputRawAudio.sampleRate, inputRawAudio.audioChannels.length, callbacks)
 
 	logger.start('Postprocess audio')
 
@@ -141,7 +143,7 @@ export async function denoise(input: AudioSourceParam, options: DenoisingOptions
 	logger.end()
 
 	logger.log('')
-	logger.logDuration('Total denoising time', startTime, chalk.magentaBright)
+	logger.logDuration('Total denoising time', startTime, 'info', chalk.magentaBright)
 
 	return {
 		denoisedAudio,
@@ -156,7 +158,7 @@ export interface DenoisingResult {
 
 export type DenoisingEngine = 'rnnoise' | 'nsnet2'
 
-export interface DenoisingOptions {
+export interface DenoisingOptions extends API.OperationOptions {
 	engine?: DenoisingEngine,
 
 	postProcessing?: {
@@ -183,6 +185,9 @@ export const defaultDenoisingOptions: DenoisingOptions = {
 	nsnet2: defaultNSNet2Options,
 }
 
+export interface DenoisingCallbacks extends API.OperationCallbacks {
+}
+
 export const denoisingEngines: EngineMetadata[] = [
 	{
 		id: 'rnnoise',

package/src/api/GlobalOptions.ts

@@ -1,3 +1,5 @@
+import { LogLevel, logLevelGreaterOrEqualTo } from "../utilities/Logger.js"
+
 export function getGlobalOption<K extends keyof GlobalOptions>(key: K): GlobalOptions[K] {
 	if (!listGlobalOptions().includes(key)) {
 		throw new Error(`Unknown global option key '${key}'`)
@@ -18,36 +20,18 @@ export function listGlobalOptions() {
 	return Object.keys(globalOptions)
 }
 
-export function logLevelToNumber(logLevel: LogLevel) {
-	return logLevels.indexOf(logLevel)
-}
-
-export function getLogLevel() {
-	return globalOptions.logLevel ?? 'info'
-}
-
-export function logLevelGreaterOrEqualTo(referenceLevel: LogLevel) {
-	return !logLevelSmallerThan(referenceLevel)
+export function getGlobalLogLevel() {
+	return getGlobalOption('logLevel') ?? 'info'
 }
 
-export function logLevelSmallerThan(referenceLevel: LogLevel) {
-	return logLevelToNumber(getLogLevel()) < logLevelToNumber(referenceLevel)
-}
-
-const logLevels = ['silent', 'output', 'error', 'warning', 'info', 'trace'] as const
-
-export type LogLevel = typeof logLevels[number]
-
 export interface GlobalOptions {
 	ffmpegPath?: string
-	soxPath?: string
 	packageBaseURL?: string
 	logLevel?: LogLevel
 }
 
 const globalOptions: GlobalOptions = {
 	ffmpegPath: undefined,
-	soxPath: undefined,
 	packageBaseURL: 'https://huggingface.co/echogarden/echogarden-packages/resolve/main/',
 	logLevel: 'info',
 }

package/src/api/Recognition.ts

@@ -4,58 +4,61 @@ import * as API from './API.js'
 
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 
-import { logToStderr } from '../utilities/Utilities.js'
 import { AudioSourceParam, RawAudio, ensureRawAudio, normalizeAudioLevelInPlace, trimAudioEnd } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 
 import { Timeline, addWordTextOffsetsToTimelineInPlace, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
 import { formatLanguageCodeWithName, parseLangIdentifier } from '../utilities/Locale.js'
-import { loadPackage } from '../utilities/PackageManager.js'
 
-import { type WhisperPartCallback, type WhisperOptions } from '../recognition/WhisperSTT.js'
+import { type WhisperOptions, type WhisperPartCallback, type WhisperTokenCallback } from '../recognition/WhisperSTT.js'
 import { type SubtitlesConfig } from '../subtitles/Subtitles.js'
 import { type OpenAICloudSTTOptions } from '../recognition/OpenAICloudSTT.js'
-import { type WhisperCppOptions } from '../recognition/WhisperCppSTT.js'
-import { type SileroRecognitionOptions } from '../recognition/SileroSTT.js'
+import { type WhisperCppCliOptions } from '../recognition/WhisperCppCliSTT.js'
 import { type DeepgramSTTOptions } from '../recognition/DeepgramSTT.js'
-import { type OnnxExecutionProvider } from '../utilities/OnnxUtilities.js'
 
-const log = logToStderr
+export async function recognize(input: AudioSourceParam, options: RecognitionOptions, callbacks?: RecognitionCallbacks): Promise<RecognitionResult> {
+	options = extendDeep(defaultRecognitionOptions, options)
+	callbacks = { logLevel: API.getGlobalLogLevel(), ...callbacks }
 
-export async function recognize(input: AudioSourceParam, options: RecognitionOptions, onPart?: WhisperPartCallback): Promise<RecognitionResult> {
-	const logger = new Logger()
+	const logger = new Logger(callbacks.logLevel)
 
 	const startTimestamp = logger.getTimestamp()
 
-	options = extendDeep(defaultRecognitionOptions, options)
-
-	const inputRawAudio = await ensureRawAudio(input)
+	const inputRawAudio = await ensureRawAudio(input, undefined, undefined, callbacks)
 
 	let sourceRawAudio: RawAudio
 	let isolatedRawAudio: RawAudio | undefined
 	let backgroundRawAudio: RawAudio | undefined
 
 	if (options.isolate) {
-		logger.log(``)
-		logger.end();
+		logger.logTitledMessage(`Isolate vocals`, '');
 
-		({ isolatedRawAudio, backgroundRawAudio } = await API.isolate(inputRawAudio, options.sourceSeparation!))
+		({ isolatedRawAudio, backgroundRawAudio } = await API.isolate(
+			inputRawAudio,
+			options.sourceSeparation!,
+			{ ...callbacks, logLevel: logger.logLevel }))
 
 		logger.end()
-		logger.log(``)
 
 		logger.start(`Resample audio to 16kHz mono`)
-		sourceRawAudio = await ensureRawAudio(isolatedRawAudio, 16000, 1)
+		sourceRawAudio = await ensureRawAudio(isolatedRawAudio, 16000, 1, callbacks)
 	} else {
 		logger.start(`Resample audio to 16kHz mono`)
-		sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
+		sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1, callbacks)
 	}
 
+	logger.end()
+
 	let sourceUncropTimeline: Timeline | undefined
 
 	if (options.crop) {
 		logger.start('Crop using voice activity detection');
-		({ timeline: sourceUncropTimeline, croppedRawAudio: sourceRawAudio } = await API.detectVoiceActivity(sourceRawAudio, options.vad!))
+
+		({ timeline: sourceUncropTimeline, croppedRawAudio: sourceRawAudio } =
+			await API.detectVoiceActivity(
+				sourceRawAudio,
+				options.vad!,
+				{ ...callbacks, logLevel: 'warning' }))
 
 		logger.end()
 	}
@@ -76,7 +79,10 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 		logger.logTitledMessage('Language specified', formatLanguageCodeWithName(options.language))
 	} else {
 		logger.start('No language specified. Detect speech language')
-		const { detectedLanguage } = await API.detectSpeechLanguage(sourceRawAudio, options.languageDetection!)
+		const { detectedLanguage } = await API.detectSpeechLanguage(
+			sourceRawAudio,
+			options.languageDetection!,
+			{ abortSignal: callbacks.abortSignal, logLevel: 'warning' })
 
 		options.language = detectedLanguage
 
@@ -97,105 +103,67 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 	switch (engine) {
 		case 'whisper': {
 			const WhisperSTT = await import('../recognition/WhisperSTT.js')
+			const WhisperCommon = await import('../recognition/WhisperCommon.js')
 
-			const whisperOptions = options.whisper!
+			const whisperOptions: WhisperOptions =
+				extendDeep(WhisperSTT.defaultWhisperOptions, options.whisper)
 
-			logger.end()
+			const { modelId, modelPath } = await WhisperCommon.loadModelPackage(
+				whisperOptions.model,
+				shortLanguageCode,
+				callbacks,
+			)
 
-			const { modelName, modelDir } = await WhisperSTT.loadPackagesAndGetPaths(whisperOptions.model, shortLanguageCode)
+			const { libPath } = await WhisperSTT.loadLibraryPackages(
+				whisperOptions.enableGPU,
+				callbacks,
+			)
 
 			logger.end();
 
 			({ transcript, timeline } = await WhisperSTT.recognize(
 				sourceRawAudio,
-				modelName,
-				modelDir,
+				modelId,
+				modelPath,
+				libPath,
 				'transcribe',
 				shortLanguageCode,
 				whisperOptions,
-				onPart,
+				callbacks,
 			))
 
 			break
 		}
 
 		case 'whisper.cpp': {
-			const WhisperCppSTT = await import('../recognition/WhisperCppSTT.js')
+			const WhisperCppCliSTT = await import('../recognition/WhisperCppCliSTT.js')
+			const WhisperCommon = await import('../recognition/WhisperCommon.js')
 
 			const whisperCppOptions = options.whisperCpp!
 
 			logger.end()
 
-			const { modelName, modelPath } = await WhisperCppSTT.loadModelPackage(whisperCppOptions.model, shortLanguageCode)
+			const { modelId, modelPath } = await WhisperCommon.loadModelPackage(
+				whisperCppOptions.model,
+				shortLanguageCode,
+				callbacks,
+			)
 
 			logger.end();
 
-			({ transcript, timeline } = await WhisperCppSTT.recognize(
+			({ transcript, timeline } = await WhisperCppCliSTT.recognize(
 				sourceRawAudio,
 				'transcribe',
 				shortLanguageCode,
-				modelName,
+				modelId,
 				modelPath,
 				whisperCppOptions,
+				callbacks,
 			))
 
 			break
 		}
 
-		case 'vosk': {
-			const VoskSTT = await import('../recognition/VoskSTT.js')
-
-			try {
-				await import('@echogarden/vosk')
-			} catch (e) {
-				log(e)
-				throw new Error(`The vosk npm package, which is required for Vosk support, was not found, or had an error loading. If missing, you can install it by running 'npm install @echogarden/vosk -g'.`)
-			}
-
-			const voskOptions = options.vosk!
-
-			const modelPath = voskOptions.modelPath
-
-			if (!modelPath) {
-				throw new Error(`Vosk models are not currently auto-downloaded. You'll need to download a model manually and set a model path in 'vosk.modelPath'.`)
-			}
-
-			logger.end();
-
-			({ transcript, timeline } = await VoskSTT.recognize(sourceRawAudio, modelPath, true))
-
-			break
-		}
-
-		case 'silero': {
-			const SileroSTT = await import('../recognition/SileroSTT.js')
-
-			const sileroOptions = options.silero!
-
-			let modelPath = sileroOptions.modelPath
-
-			if (!modelPath) {
-				const packageName = SileroSTT.languageCodeToPackageName[shortLanguageCode]
-
-				if (!packageName) {
-					throw new Error(`Language '${shortLanguageCode}' is not supported by Silero`)
-				}
-
-				modelPath = await loadPackage(packageName)
-			}
-
-			const onnxExecutionProviders: OnnxExecutionProvider[] = sileroOptions.provider ? [sileroOptions.provider] : []
-
-			logger.end();
-
-			({ transcript, timeline } = await SileroSTT.recognize(
-				sourceRawAudio,
-				modelPath,
-				onnxExecutionProviders))
-
-			break
-		}
-
 		case 'google-cloud': {
 			const GoogleCloudSTT = await import('../recognition/GoogleCloudSTT.js')
 
@@ -207,7 +175,12 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 
 			logger.end();
 
-			({ transcript, timeline } = await GoogleCloudSTT.recognize(sourceRawAudio, apiKey, shortLanguageCode))
+			({ transcript, timeline } = await GoogleCloudSTT.recognize(
+				sourceRawAudio,
+				apiKey,
+				shortLanguageCode,
+				callbacks
+			))
 
 			break
 		}
@@ -229,7 +202,14 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 
 			logger.end();
 
-			({ transcript, timeline } = await AzureCognitiveServicesSTT.recognize(sourceRawAudio, subscriptionKey, serviceRegion, shortLanguageCode))
+			({ transcript, timeline } = await AzureCognitiveServicesSTT.recognize(
+				sourceRawAudio,
+				subscriptionKey,
+				serviceRegion,
+				shortLanguageCode,
+				undefined,
+				callbacks
+			))
 
 			break
 		}
@@ -257,7 +237,14 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 
 			logger.end();
 
-			({ transcript, timeline } = await AmazonTranscribeSTT.recgonize(sourceRawAudio, languageCode, region, accessKeyId, secretAccessKey))
+			({ transcript, timeline } = await AmazonTranscribeSTT.recgonize(
+				sourceRawAudio,
+				languageCode,
+				region,
+				accessKeyId,
+				secretAccessKey,
+				callbacks
+			))
 
 			break
 		}
@@ -273,7 +260,13 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 
 			logger.end();
 
-			({ transcript, timeline } = await OpenAICloudSTT.recognize(sourceRawAudio, shortLanguageCode, openAICloudSTTOptions))
+			({ transcript, timeline } = await OpenAICloudSTT.recognize(
+				sourceRawAudio,
+				shortLanguageCode,
+				openAICloudSTTOptions,
+				'transcribe',
+				callbacks
+			))
 
 			break
 		}
@@ -289,7 +282,12 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 
 			logger.end();
 
-			({ transcript, timeline } = await DeepgramSTT.recognize(sourceRawAudio, options.language ? shortLanguageCode : undefined, deepgramOptions))
+			({ transcript, timeline } = await DeepgramSTT.recognize(
+				sourceRawAudio,
+				options.language ? shortLanguageCode : undefined,
+				deepgramOptions,
+				callbacks,
+			))
 
 			break
 		}
@@ -304,7 +302,12 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 		logger.start(`Align audio to transcript`)
 		const alignmentOptions: API.AlignmentOptions = extendDeep(options.alignment, { language: languageCode })
 
-		const { wordTimeline } = await API.align(sourceRawAudio, transcript, alignmentOptions)
+		const { wordTimeline } = await API.align(
+			sourceRawAudio,
+			transcript,
+			alignmentOptions,
+			{ abortSignal: callbacks.abortSignal, logLevel: 'warning' },
+		)
 
 		timeline = wordTimeline
 	}
@@ -321,7 +324,7 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 	const { segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(timeline, transcript, languageCode, 'single', 'preserve')
 
 	logger.end()
-	logger.logDuration('\nTotal recognition time', startTimestamp, chalk.magentaBright)
+	logger.logDuration('\nTotal recognition time', startTimestamp, 'info', chalk.magentaBright)
 
 	return {
 		transcript,
@@ -350,9 +353,9 @@ export interface RecognitionResult {
 	backgroundRawAudio?: RawAudio
 }
 
-export type RecognitionEngine = 'whisper' | 'whisper.cpp' | 'vosk' | 'silero' | 'google-cloud' | 'microsoft-azure' | 'amazon-transcribe' | 'openai-cloud' | 'deepgram'
+export type RecognitionEngine = 'whisper' | 'whisper.cpp' | 'google-cloud' | 'microsoft-azure' | 'amazon-transcribe' | 'openai-cloud' | 'deepgram'
 
-export interface RecognitionOptions {
+export interface RecognitionOptions extends API.OperationOptions {
 	engine?: RecognitionEngine
 
 	language?: string
@@ -369,19 +372,13 @@ export interface RecognitionOptions {
 
 	subtitles?: SubtitlesConfig
 
-	vad?: API.VADOptions
+	vad?: API.VoiceActivityDetectionOptions
 
 	sourceSeparation?: API.SourceSeparationOptions
 
 	whisper?: WhisperOptions
 
-	whisperCpp?: WhisperCppOptions
-
-	vosk?: {
-		modelPath?: string
-	}
-
-	silero?: SileroRecognitionOptions
+	whisperCpp?: WhisperCppCliOptions
 
 	googleCloud?: {
 		apiKey?: string
@@ -437,13 +434,6 @@ export const defaultRecognitionOptions: RecognitionOptions = {
 	whisperCpp: {
 	},
 
-	vosk: {
-		modelPath: undefined
-	},
-
-	silero: {
-	},
-
 	googleCloud: {
 		apiKey: undefined,
 		alternativeLanguageCodes: [],
@@ -470,29 +460,22 @@ export const defaultRecognitionOptions: RecognitionOptions = {
 	}
 }
 
+export interface RecognitionCallbacks extends API.OperationCallbacks {
+	onPart?: WhisperPartCallback
+	onToken?: WhisperTokenCallback
+}
+
 export const recognitionEngines: API.EngineMetadata[] = [
 	{
 		id: 'whisper',
 		name: 'OpenAI Whisper',
-		description: 'A high accuracy transformer-based speech recognition architecture by OpenAI.',
+		description: 'High accuracy transformer-based speech recognition architecture by OpenAI.',
 		type: 'local'
 	},
 	{
 		id: 'whisper.cpp',
-		name: 'OpenAI Whisper (C++ port)',
-		description: 'A C++ port of the Whisper speech recognition architecture.',
-		type: 'local'
-	},
-	{
-		id: 'vosk',
-		name: 'Vosk',
-		description: 'A speech recognition toolkit.',
-		type: 'local'
-	},
-	{
-		id: 'silero',
-		name: 'Silero',
-		description: 'Speech recognition models.',
+		name: 'OpenAI Whisper (C++ port) CLI',
+		description: 'Invokes the CLI version of the whisper.cpp port of OpenAI Whisper.',
 		type: 'local'
 	},
 	{

package/src/api/SourceSeparation.ts

@@ -1,31 +1,36 @@
-import { AudioSourceParam, RawAudio, attenuateIfClippingInPlace, ensureRawAudio, subtractAudio } from '../audio/AudioUtilities.js';
-import { Logger } from '../utilities/Logger.js';
-import { extendDeep } from '../utilities/ObjectUtilities.js';
-import { loadPackage } from '../utilities/PackageManager.js';
-import { EngineMetadata } from './Common.js';
-import chalk from 'chalk';
-import { readdir } from '../utilities/FileSystem.js';
-import { defaultMDXNetOptions, getProfileForMDXNetModelName, MDXNetOptions } from '../source-separation/MDXNetSourceSeparation.js';
-import { joinPath } from '../utilities/PathUtilities.js';
-
-export async function isolate(input: AudioSourceParam, options: SourceSeparationOptions): Promise<SourceSeparationResult> {
-	const logger = new Logger()
+import chalk from 'chalk'
+
+import * as API from './API.js'
+
+import { AudioSourceParam, RawAudio, attenuateIfClippingInPlace, ensureRawAudio, subtractAudio } from '../audio/AudioUtilities.js'
+import { Logger } from '../utilities/Logger.js'
+import { extendDeep } from '../utilities/ObjectUtilities.js'
+import { loadPackage } from '../utilities/PackageManager.js'
+import { EngineMetadata } from './Common.js'
+import { readdir } from '../utilities/FileSystem.js'
+import { defaultMDXNetOptions, getProfileForMDXNetModelName, MDXNetOptions } from '../source-separation/MDXNetSourceSeparation.js'
+import { joinPath } from '../utilities/PathUtilities.js'
+
+export async function isolate(input: AudioSourceParam, options: SourceSeparationOptions, callbacks?: SourceSeparationCallbacks): Promise<SourceSeparationResult> {
+	options = extendDeep(defaultSourceSeparationOptions, options)
+	callbacks = { logLevel: API.getGlobalLogLevel(), ...callbacks }
+
+	const logger = new Logger(callbacks.logLevel)
+
 	const startTimestamp = logger.getTimestamp()
 
-	const inputRawAudio = await ensureRawAudio(input)
+	const inputRawAudio = await ensureRawAudio(input, undefined, undefined, callbacks)
 
 	let isolatedRawAudio: RawAudio
 	let backgroundRawAudio: RawAudio
 
-	options = extendDeep(defaultSourceSeparationOptions, options)
-
 	switch (options.engine) {
 		case 'mdx-net': {
 			const MDXNetSourceSeparation = await import('../source-separation/MDXNetSourceSeparation.js')
 
 			const mdxNetOptions = options.mdxNet!
 
-			const packageDir = await loadPackage(`mdxnet-${mdxNetOptions.model!}`)
+			const packageDir = await loadPackage(`mdxnet-${mdxNetOptions.model!}`, callbacks)
 			const modelFilename = (await readdir(packageDir)).filter(name => name.endsWith('onnx'))[0]
 
 			if (!modelFilename) {
@@ -36,20 +41,27 @@ export async function isolate(input: AudioSourceParam, options: SourceSeparation
 
 			await logger.startAsync(`Convert audio to 44.1 kHz stereo`)
 
-			let inputRawAudioAs44100Stereo: RawAudio | undefined = await ensureRawAudio(inputRawAudio, 44100, 2)
+			let inputRawAudioAs44100Stereo: RawAudio | undefined = await ensureRawAudio(inputRawAudio, 44100, 2, callbacks)
 
 			logger.end()
 
 			const modelProfile = getProfileForMDXNetModelName(mdxNetOptions.model!)
 
-			isolatedRawAudio = await MDXNetSourceSeparation.isolate(inputRawAudioAs44100Stereo, modelPath, modelProfile, mdxNetOptions)
+			isolatedRawAudio = await MDXNetSourceSeparation.isolate(
+				inputRawAudioAs44100Stereo,
+				modelPath,
+				modelProfile,
+				mdxNetOptions,
+				callbacks,
+			)
+
 			logger.end()
 
 			// Release memory for the converted input audio since it's not needed anymore
 			inputRawAudioAs44100Stereo = undefined
 
 			await logger.startAsync(`Convert isolated audio back to original sample rate (${inputRawAudio.sampleRate} Hz) and channel count (${inputRawAudio.audioChannels.length})`)
-			isolatedRawAudio = await ensureRawAudio(isolatedRawAudio, inputRawAudio.sampleRate, inputRawAudio.audioChannels.length)
+			isolatedRawAudio = await ensureRawAudio(isolatedRawAudio, inputRawAudio.sampleRate, inputRawAudio.audioChannels.length, callbacks)
 
 			await logger.startAsync(`Subtract from original waveform to extract background audio`)
 			backgroundRawAudio = subtractAudio(inputRawAudio, isolatedRawAudio)
@@ -69,7 +81,7 @@ export async function isolate(input: AudioSourceParam, options: SourceSeparation
 
 	logger.end()
 
-	logger.logDuration(`Total source separation time`, startTimestamp, chalk.magentaBright)
+	logger.logDuration(`Total source separation time`, startTimestamp, 'info', chalk.magentaBright)
 
 	return {
 		inputRawAudio,
@@ -80,7 +92,7 @@ export async function isolate(input: AudioSourceParam, options: SourceSeparation
 
 export type SourceSeparationEngine = 'mdx-net'
 
-export interface SourceSeparationOptions {
+export interface SourceSeparationOptions extends API.OperationOptions {
 	engine?: SourceSeparationEngine
 
 	mdxNet?: MDXNetOptions
@@ -98,6 +110,12 @@ export interface SourceSeparationResult {
 	backgroundRawAudio: RawAudio
 }
 
+export interface SourceSeparationCallbacks extends API.OperationCallbacks {
+	onSegment?: SourceSeparationSegmentCallback
+}
+
+export type SourceSeparationSegmentCallback = (timePosition: number, rawAudio: RawAudio) => Promise<void>
+
 export const sourceSeparationEngines: EngineMetadata[] = [
 	{
 		id: 'mdx-net',