echogarden 0.12.2 → 1.0.0

package/src/api/Translation.ts

@@ -1,16 +1,20 @@
-import { extendDeep } from "../utilities/ObjectUtilities.js"
+import { extendDeep } from '../utilities/ObjectUtilities.js'
 
-import { logToStderr } from "../utilities/Utilities.js"
-import { AudioSourceParam, RawAudio, ensureRawAudio, normalizeAudioLevel, trimAudioEnd } from "../audio/AudioUtilities.js"
-import { Logger } from "../utilities/Logger.js"
+import { logToStderr } from '../utilities/Utilities.js'
+import { AudioSourceParam, RawAudio, ensureRawAudio, normalizeAudioLevel, trimAudioEnd } from '../audio/AudioUtilities.js'
+import { Logger } from '../utilities/Logger.js'
 
-import { Timeline, addWordTextOffsetsToTimeline, wordTimelineToSegmentSentenceTimeline } from "../utilities/Timeline.js"
-import { whisperOptionsDefaults, type WhisperOptions } from "../recognition/WhisperSTT.js"
-import { formatLanguageCodeWithName, getShortLanguageCode, normalizeLanguageCode } from "../utilities/Locale.js"
-import { EngineMetadata } from "./Common.js"
-import { SpeechLanguageDetectionOptions, detectSpeechLanguage } from "./API.js"
-import chalk from "chalk"
-import { SubtitlesConfig, defaultSubtitlesBaseConfig } from "../subtitles/Subtitles.js"
+import { Timeline, addWordTextOffsetsToTimeline, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
+import { defaultWhisperOptions, type WhisperOptions } from '../recognition/WhisperSTT.js'
+import { formatLanguageCodeWithName, getShortLanguageCode, normalizeLanguageCode } from '../utilities/Locale.js'
+import { EngineMetadata } from './Common.js'
+import { SpeechLanguageDetectionOptions, detectSpeechLanguage } from './API.js'
+import chalk from 'chalk'
+import { SubtitlesConfig, defaultSubtitlesBaseConfig } from '../subtitles/Subtitles.js'
+
+import * as API from './API.js'
+import { OpenAICloudSTTOptions, defaultOpenAICloudSTTOptions } from '../recognition/OpenAICloudSTT.js'
+import { WhisperCppOptions, defaultWhisperCppOptions } from '../recognition/WhisperCppSTT.js'
 
 const log = logToStderr
 
@@ -19,65 +23,164 @@ const log = logToStderr
 /////////////////////////////////////////////////////////////////////////////////////////////
 export async function translateSpeech(input: AudioSourceParam, options: SpeechTranslationOptions): Promise<SpeechTranslationResult> {
 	const logger = new Logger()
+
 	const startTimestamp = logger.getTimestamp()
 
-	logger.start("Prepare for speech translation")
+	options = extendDeep(defaultSpeechTranslationOptions, options)
 
 	const inputRawAudio = await ensureRawAudio(input)
 
-	let sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
+	let sourceRawAudio: RawAudio
+	let isolatedRawAudio: RawAudio | undefined
+	let backgroundRawAudio: RawAudio | undefined
+
+	if (options.isolate) {
+		logger.log(``)
+		logger.end();
+
+		({ isolatedRawAudio, backgroundRawAudio } = await API.isolate(inputRawAudio, options.sourceSeparation!))
+
+		logger.end()
+		logger.log(``)
+
+		sourceRawAudio = await ensureRawAudio(isolatedRawAudio, 16000, 1)
+	} else {
+		sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
+	}
+
+	let sourceUncropTimeline: Timeline | undefined
+
+	if (options.crop) {
+		logger.start('Crop using voice activity detection');
+		({ timeline: sourceUncropTimeline, croppedRawAudio: sourceRawAudio } = await API.detectVoiceActivity(sourceRawAudio, options.vad!))
+
+		logger.end()
+	}
+
+	logger.start('Prepare for speech translation')
+
 	sourceRawAudio = normalizeAudioLevel(sourceRawAudio)
 	sourceRawAudio.audioChannels[0] = trimAudioEnd(sourceRawAudio.audioChannels[0])
 
-	options = extendDeep(defaultSpeechTranslationOptions, options)
-
 	if (!options.sourceLanguage) {
-		logger.start("No language specified. Detecting speech language")
-		const { detectedLanguage } = await detectSpeechLanguage(inputRawAudio, options.languageDetection || {})
+		logger.start('No source language specified. Detecting speech language')
+		const { detectedLanguage } = await detectSpeechLanguage(sourceRawAudio, options.languageDetection || {})
 
 		logger.end()
-		logger.logTitledMessage('Language detected', formatLanguageCodeWithName(detectedLanguage))
+		logger.logTitledMessage('Source language detected', formatLanguageCodeWithName(detectedLanguage))
 
 		options.sourceLanguage = detectedLanguage
+	} else {
+		logger.end()
+
+		const specifiedLanguageFormatted = formatLanguageCodeWithName(getShortLanguageCode(normalizeLanguageCode(options.sourceLanguage)))
+
+		logger.logTitledMessage('Source language', specifiedLanguageFormatted)
 	}
 
-	logger.start("Preprocess audio for translation")
+	logger.logTitledMessage('Target language', formatLanguageCodeWithName(getShortLanguageCode(normalizeLanguageCode(options.targetLanguage!))))
+
+	logger.start('Preprocess audio for translation')
 
 	const engine = options.engine!
 	const sourceLanguage = normalizeLanguageCode(options.sourceLanguage!)
 	const targetLanguage = options.targetLanguage!
 
 	let transcript: string
-	let timeline: Timeline | undefined
+	let wordTimeline: Timeline | undefined
+	let segmentTimeline: Timeline | undefined
 
 	logger.start(`Load ${engine} module`)
 
 	switch (engine) {
-		case "whisper": {
-			const WhisperSTT = await import("../recognition/WhisperSTT.js")
+		case 'whisper': {
+			const WhisperSTT = await import('../recognition/WhisperSTT.js')
 
 			const whisperOptions = options.whisper!
 
 			const shortSourceLanguageCode = getShortLanguageCode(sourceLanguage)
 			const shortTargetLanguageCode = getShortLanguageCode(targetLanguage)
 
-			const { modelName, modelDir, tokenizerDir } = await WhisperSTT.loadPackagesAndGetPaths(whisperOptions.model, shortSourceLanguageCode)
+			const { modelName, modelDir } = await WhisperSTT.loadPackagesAndGetPaths(whisperOptions.model, shortSourceLanguageCode)
+
+			if (shortTargetLanguageCode != 'en') {
+				throw new Error('Whisper translation only supports English as target language')
+			}
+
+			if (modelName.endsWith('.en')) {
+				throw new Error('Whisper translation tasks are only possible with a multilingual model')
+			}
+
+			if (shortSourceLanguageCode == 'en' && shortTargetLanguageCode == 'en') {
+				throw new Error('Both translation source and target languages are English')
+			}
+
+			logger.end();
+
+			({ transcript, timeline: wordTimeline } = await WhisperSTT.recognize(sourceRawAudio, modelName, modelDir, 'translate', sourceLanguage, whisperOptions))
+
+			addWordTextOffsetsToTimeline(wordTimeline, transcript);
+
+			({ segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(wordTimeline, transcript, targetLanguage, 'single', 'preserve'))
+
+			break
+		}
+
+		case 'whisper.cpp': {
+			const WhisperCppSTT = await import('../recognition/WhisperCppSTT.js')
+
+			const whisperCppOptions = options.whisperCpp!
+
+			const shortSourceLanguageCode = getShortLanguageCode(sourceLanguage)
+			const shortTargetLanguageCode = getShortLanguageCode(targetLanguage)
+
+			logger.end()
 
-			if (shortTargetLanguageCode != "en") {
-				throw new Error("Whisper translation only supports English as target language")
+			const { modelName, modelPath } = await WhisperCppSTT.loadModelPackage(whisperCppOptions.model, shortSourceLanguageCode)
+
+			if (shortTargetLanguageCode != 'en') {
+				throw new Error('Whisper.cpp translation only supports English as target language')
 			}
 
-			if (modelName.endsWith(".en")) {
-				throw new Error("Whisper translation tasks are only possible with a multilingual model")
+			if (modelName.endsWith('.en')) {
+				throw new Error('Whisper.cpp translation tasks are only possible with a multilingual model')
 			}
 
-			if (shortSourceLanguageCode == "en" && shortTargetLanguageCode == "en") {
-				throw new Error("Both translation source and target language are English")
+			logger.end();
+
+			({ transcript, timeline: wordTimeline } = await WhisperCppSTT.recognize(
+				sourceRawAudio,
+				'translate',
+				shortSourceLanguageCode,
+				modelName,
+				modelPath,
+				whisperCppOptions,
+			));
+
+			({ segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(wordTimeline, transcript, targetLanguage, 'single', 'preserve'))
+
+			break
+		}
+
+		case 'openai-cloud': {
+			const OpenAICloudSTT = await import('../recognition/OpenAICloudSTT.js')
+
+			const openAICloudSTTOptions = options.openAICloud!
+
+			if (!openAICloudSTTOptions.apiKey) {
+				throw new Error(`No OpenAI Cloud API key provided`)
+			}
+
+			const shortSourceLanguageCode = getShortLanguageCode(sourceLanguage)
+			const shortTargetLanguageCode = getShortLanguageCode(targetLanguage)
+
+			if (shortTargetLanguageCode != 'en') {
+				throw new Error('OpenAI cloud speech translation only supports English as target language')
 			}
 
 			logger.end();
 
-			({ transcript, timeline } = await WhisperSTT.recognize(sourceRawAudio, modelName, modelDir, tokenizerDir, "translate", sourceLanguage, whisperOptions))
+			({ transcript, timeline: segmentTimeline } = await OpenAICloudSTT.recognize(sourceRawAudio, shortSourceLanguageCode, openAICloudSTTOptions, 'translate'))
 
 			break
 		}
@@ -87,57 +190,107 @@ export async function translateSpeech(input: AudioSourceParam, options: SpeechTr
 		}
 	}
 
-	addWordTextOffsetsToTimeline(timeline, transcript)
+	logger.end()
 
-	const { segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(timeline, transcript, targetLanguage, 'single', 'preserve')
+	// If the audio was cropped before recognition, map the timestamps back to the original audio
+	if (sourceUncropTimeline && sourceUncropTimeline.length > 0) {
+		API.convertCroppedToUncroppedTimeline(segmentTimeline, sourceUncropTimeline)
+
+		if (wordTimeline) {
+			API.convertCroppedToUncroppedTimeline(wordTimeline, sourceUncropTimeline)
+		}
+	}
 
-	logger.end()
 	logger.log('')
 	logger.logDuration(`Total speech translation time`, startTimestamp, chalk.magentaBright)
 
-	return { transcript, timeline: segmentTimeline, wordTimeline: timeline, sourceLanguage, targetLanguage, inputRawAudio }
+	return {
+		transcript,
+		timeline: segmentTimeline,
+		wordTimeline,
+
+		sourceLanguage,
+		targetLanguage,
+
+		inputRawAudio,
+		isolatedRawAudio,
+		backgroundRawAudio,
+	}
 }
 
 export interface SpeechTranslationResult {
 	transcript: string
 	timeline: Timeline
-	wordTimeline: Timeline
+	wordTimeline?: Timeline
+
 	sourceLanguage: string
 	targetLanguage: string
+
 	inputRawAudio: RawAudio
+	isolatedRawAudio?: RawAudio
+	backgroundRawAudio?: RawAudio
 }
 
-export type SpeechTranslationEngine = "whisper"
+export type SpeechTranslationEngine = 'whisper' | 'whisper.cpp' | 'openai-cloud'
 
 export interface SpeechTranslationOptions {
 	engine?: SpeechTranslationEngine
 
 	sourceLanguage?: string
 	targetLanguage?: string
+
+	crop?: boolean
+	isolate?: boolean
+
 	languageDetection?: SpeechLanguageDetectionOptions
 	subtitles?: SubtitlesConfig
+	vad?: API.VADOptions
+	sourceSeparation?: API.SourceSeparationOptions
 
 	whisper?: WhisperOptions
+	whisperCpp?: WhisperCppOptions
+	openAICloud?: OpenAICloudSTTOptions
 }
 
 export const defaultSpeechTranslationOptions: SpeechTranslationOptions = {
-	engine: "whisper",
+	engine: 'whisper',
 
 	sourceLanguage: undefined,
-	targetLanguage: "en",
+	targetLanguage: 'en',
+
+	crop: true,
+	isolate: false,
 
 	languageDetection: undefined,
 
 	subtitles: defaultSubtitlesBaseConfig,
 
-	whisper: whisperOptionsDefaults,
+	vad: {
+		engine: 'adaptive-gate'
+	},
+
+	whisper: defaultWhisperOptions,
+	whisperCpp: defaultWhisperCppOptions,
+	openAICloud: defaultOpenAICloudSTTOptions,
 }
 
 export const speechTranslationEngines: EngineMetadata[] = [
 	{
 		id: 'whisper',
 		name: 'OpenAI Whisper',
-		description: "Uses Whisper's speech translation capability to produce an English transcript from speech in a different language.",
+		description: `Uses Whisper's speech translation capability to produce an English transcript from speech in a different language.`,
+		type: 'local'
+	},
+	{
+		id: 'whisper.cpp',
+		name: 'OpenAI Whisper (C++ port)',
+		description: `Uses Whisper's speech translation capability to produce an English transcript from speech in a different language.`,
 		type: 'local'
+	},
+	{
+		id: 'openai-cloud',
+		name: 'OpenAI Cloud',
+		description: 'Speech translation cloud service provided by OpenAI. Only support English as target language.',
+		type: 'cloud'
 	}
 ]

package/src/api/Vad.ts

@@ -1,22 +1,24 @@
-import { extendDeep } from "../utilities/ObjectUtilities.js"
+import { extendDeep } from '../utilities/ObjectUtilities.js'
 
-import { logToStderr } from "../utilities/Utilities.js"
-import { AudioSourceParam, RawAudio, ensureRawAudio, } from "../audio/AudioUtilities.js"
-import { Logger } from "../utilities/Logger.js"
+import { logToStderr } from '../utilities/Utilities.js'
+import { AudioSourceParam, RawAudio, cropToTimeline, ensureRawAudio, } from '../audio/AudioUtilities.js'
+import { Logger } from '../utilities/Logger.js'
 
-import { Timeline } from "../utilities/Timeline.js"
-import path from "path"
-import { loadPackage } from "../utilities/PackageManager.js"
-import { EngineMetadata } from "./Common.js"
-import chalk from "chalk"
+import { Timeline } from '../utilities/Timeline.js'
+import path from 'path'
+import { loadPackage } from '../utilities/PackageManager.js'
+import { EngineMetadata } from './Common.js'
+import chalk from 'chalk'
+import { type AdaptiveGateVADOptions } from '../voice-activity-detection/AdaptiveGateVAD.js'
 
 const log = logToStderr
 
 export async function detectVoiceActivity(input: AudioSourceParam, options: VADOptions): Promise<VADResult> {
 	const logger = new Logger()
+
 	const startTimestamp = logger.getTimestamp()
 
-	logger.start("Prepare for voice activity detection")
+	logger.start('Prepare for voice activity detection')
 
 	const inputRawAudio = await ensureRawAudio(input)
 
@@ -26,46 +28,65 @@ export async function detectVoiceActivity(input: AudioSourceParam, options: VADO
 
 	logger.start(`Detect voice activity with ${options.engine}`)
 
-	let frameDurationSeconds: number
-	let frameProbabilities: number[]
+	const activityThreshold = options.activityThreshold!
+
+	let verboseTimeline: Timeline
 
 	switch (options.engine) {
-		case "webrtc": {
-			const WebRtcVAD = await import("../voice-activity-detection/WebRtcVAD.js")
+		case 'webrtc': {
+			const WebRtcVAD = await import('../voice-activity-detection/WebRtcVAD.js')
 
 			const webrtcOptions = options.webrtc!
 
-			frameProbabilities = await WebRtcVAD.detectVoiceActivity(sourceRawAudio, webrtcOptions.frameDuration!)
-			frameDurationSeconds = webrtcOptions.frameDuration! / 1000
+			const frameProbabilities = await WebRtcVAD.detectVoiceActivity(sourceRawAudio, webrtcOptions.frameDuration!)
+			const frameDurationSeconds = webrtcOptions.frameDuration! / 1000
+
+			verboseTimeline = frameProbabilitiesToTimeline(frameProbabilities, frameDurationSeconds, activityThreshold)
 
 			break
 		}
 
-		case "silero": {
-			const SileroVAD = await import("../voice-activity-detection/SileroVAD.js")
+		case 'silero': {
+			const SileroVAD = await import('../voice-activity-detection/SileroVAD.js')
 
 			const sileroOptions = options.silero!
 
-			const modelDir = await loadPackage("silero-vad")
+			const modelDir = await loadPackage('silero-vad')
 
-			const modelPath = path.join(modelDir, "silero-vad.onnx")
+			const modelPath = path.join(modelDir, 'silero-vad.onnx')
 			const frameDuration = sileroOptions.frameDuration!
 
-			frameProbabilities = await SileroVAD.detectVoiceActivity(sourceRawAudio, modelPath, frameDuration)
-			frameDurationSeconds = sileroOptions.frameDuration! / 1000
+			const frameProbabilities = await SileroVAD.detectVoiceActivity(sourceRawAudio, modelPath, frameDuration)
+			const frameDurationSeconds = sileroOptions.frameDuration! / 1000
+
+			verboseTimeline = frameProbabilitiesToTimeline(frameProbabilities, frameDurationSeconds, activityThreshold)
 
 			break
 		}
 
-		case "rnnoise": {
-			const RNNoise = await import("../denoising/RNNoise.js")
+		case 'rnnoise': {
+			const RNNoise = await import('../denoising/RNNoise.js')
+
+			const audio48k = await ensureRawAudio(sourceRawAudio, 48000, 1)
 
 			const rnnoiseOptions = options.rnnoise!
 
-			const { denoisedRawAudio, frameVadProbabilities } = await RNNoise.denoiseAudio(sourceRawAudio)
+			const { denoisedRawAudio, frameVadProbabilities } = await RNNoise.denoiseAudio(audio48k)
+
+			const frameDurationSeconds = 0.01
+			const frameProbabilities = frameVadProbabilities
+
+			verboseTimeline = frameProbabilitiesToTimeline(frameProbabilities, frameDurationSeconds, activityThreshold)
+
+			break
+		}
+
+		case 'adaptive-gate': {
+			const AdaptiveGateVAD = await import('../voice-activity-detection/AdaptiveGateVAD.js')
 
-			frameDurationSeconds = 0.01
-			frameProbabilities = frameVadProbabilities
+			const adaptiveGateOptions = options.adaptiveGate!
+
+			verboseTimeline = await AdaptiveGateVAD.detectVoiceActivity(sourceRawAudio, adaptiveGateOptions)
 
 			break
 		}
@@ -75,6 +96,18 @@ export async function detectVoiceActivity(input: AudioSourceParam, options: VADO
 		}
 	}
 
+	const timeline = verboseTimeline.filter(entry => entry.text === 'active')
+
+	const croppedRawAudio = cropToTimeline(inputRawAudio, timeline)
+
+	logger.end()
+	logger.log('')
+	logger.logDuration(`Total voice activity detection time`, startTimestamp, chalk.magentaBright)
+
+	return { timeline, verboseTimeline, inputRawAudio, croppedRawAudio }
+}
+
+function frameProbabilitiesToTimeline(frameProbabilities: number[], frameDurationSeconds: number, activityThreshold: number) {
 	const timeline: Timeline = []
 
 	for (let i = 0; i < frameProbabilities.length; i++) {
@@ -83,14 +116,16 @@ export async function detectVoiceActivity(input: AudioSourceParam, options: VADO
 		const startTime = i * frameDurationSeconds
 		const endTime = (i + 1) * frameDurationSeconds
 
-		if (frameProbability >= options.activityThreshold!) {
-			if (timeline.length == 0 || timeline[timeline.length - 1].text == "nonspeech") {
-				timeline.push({ type: "segment", text: "speech", startTime, endTime })
+		if (frameProbability >= activityThreshold) {
+			if (timeline.length == 0 || timeline[timeline.length - 1].text == 'inactive') {
+				timeline.push({ type: 'segment', text: 'active', startTime, endTime })
+
 				continue
 			}
 		} else {
-			if (timeline.length == 0 || timeline[timeline.length - 1].text == "speech") {
-				timeline.push({ type: "segment", text: "nonspeech", startTime, endTime })
+			if (timeline.length == 0 || timeline[timeline.length - 1].text == 'active') {
+				timeline.push({ type: 'segment', text: 'inactive', startTime, endTime })
+
 				continue
 			}
 		}
@@ -98,19 +133,50 @@ export async function detectVoiceActivity(input: AudioSourceParam, options: VADO
 		timeline[timeline.length - 1].endTime = endTime
 	}
 
-	logger.end()
-	logger.log('')
-	logger.logDuration(`Total voice activity detection time`, startTimestamp, chalk.magentaBright)
+	return timeline
+}
+
+export function convertCroppedToUncroppedTimeline(timeline: Timeline, uncropTimeline: Timeline) {
+	for (const entry of timeline) {
+		entry.startTime = mapTimestampUsingUncropTimeline(entry.startTime, uncropTimeline)
+		entry.endTime = mapTimestampUsingUncropTimeline(entry.endTime, uncropTimeline)
 
-	return { timeline, inputRawAudio }
+		if (entry.timeline) {
+			convertCroppedToUncroppedTimeline(entry.timeline, uncropTimeline)
+		}
+	}
+}
+
+export function mapTimestampUsingUncropTimeline(timeInCroppedAudio: number, uncropTimeline: Timeline) {
+	let offsetInCroppedAudio = 0
+
+	for (let i = 0; i < uncropTimeline.length; i++) {
+		const entry = uncropTimeline[i]
+
+		const entryDuration = entry.endTime - entry.startTime
+
+		const endOffset = offsetInCroppedAudio + entryDuration
+
+		if ((i === uncropTimeline.length - 1) ||
+			(timeInCroppedAudio >= offsetInCroppedAudio && timeInCroppedAudio < endOffset)) {
+			return entry.startTime + (timeInCroppedAudio - offsetInCroppedAudio)
+		}
+
+		offsetInCroppedAudio += entryDuration
+	}
+
+	throw new Error(`Should not be reached`)
 }
 
 export interface VADResult {
 	timeline: Timeline
+	verboseTimeline: Timeline
+
 	inputRawAudio: RawAudio
+	croppedRawAudio: RawAudio
 }
 
-export type VADEngine = "webrtc" | "silero" | "rnnoise"
+export type VADEngine = 'webrtc' | 'silero' | 'rnnoise' | 'adaptive-gate'
 
 export interface VADOptions {
 	engine?: VADEngine
@@ -123,16 +189,17 @@ export interface VADOptions {
 	}
 
 	silero?: {
-		modelPath?: string
 		frameDuration?: 30 | 60 | 90
 	}
 
 	rnnoise?: {
 	}
+
+	adaptiveGate?: AdaptiveGateVADOptions
 }
 
 export const defaultVADOptions: VADOptions = {
-	engine: "webrtc",
+	engine: 'silero',
 
 	activityThreshold: 0.5,
 
@@ -142,11 +209,13 @@ export const defaultVADOptions: VADOptions = {
 	},
 
 	silero: {
-		modelPath: undefined,
 		frameDuration: 90,
 	},
 
 	rnnoise: {
+	},
+
+	adaptiveGate: {
 	}
 }
 
@@ -166,7 +235,7 @@ export const vadEngines: EngineMetadata[] = [
 	{
 		id: 'rnnoise',
 		name: 'RNNoise',
-		description: "Uses RNNoise's speech probabilities as VAD metrics.",
+		description: `Uses RNNoise's internal speech probabilities as VAD metrics.`,
 		type: 'local'
 	}
 ]

package/src/audio/AudioBufferConversion.ts

@@ -1,6 +1,6 @@
-import AlawMulaw from "alawmulaw"
+import AlawMulaw from 'alawmulaw'
 import * as BinaryArrayConversion from '../utilities/BinaryArrayConversion.js'
-import { BitDepth, SampleFormat } from "../codecs/WaveCodec.js"
+import { BitDepth, SampleFormat } from '../codecs/WaveCodec.js'
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 // Low level audio sample conversions
@@ -186,7 +186,7 @@ export function interleaveChannels(channels: Float32Array[]) {
 	const channelCount = channels.length
 
 	if (channelCount == 0) {
-		throw new Error("Empty channel array received")
+		throw new Error('Empty channel array received')
 	}
 
 	if (channelCount == 1) {
@@ -210,7 +210,7 @@ export function interleaveChannels(channels: Float32Array[]) {
 
 export function deInterleaveChannels(interleavedChannels: Float32Array, channelCount: number) {
 	if (channelCount == 0) {
-		throw new Error("0 channel count received")
+		throw new Error('0 channel count received')
 	}
 
 	if (channelCount == 1) {