echogarden 0.12.2 → 1.0.0

package/src/utilities/Timeline.ts

@@ -1,7 +1,7 @@
-import { ParagraphBreakType, WhitespaceProcessing } from "../api/Common.js"
-import { isWordOrSymbolWord, splitToParagraphs, splitToSentences } from "../nlp/Segmentation.js"
-import { deepClone } from "./ObjectUtilities.js"
-import { getUTF32Chars, roundToDigits } from "./Utilities.js"
+import { ParagraphBreakType, WhitespaceProcessing } from '../api/Common.js'
+import { isWordOrSymbolWord, splitToParagraphs, splitToSentences } from '../nlp/Segmentation.js'
+import { deepClone } from './ObjectUtilities.js'
+import { getUTF32Chars, roundToDigits } from './Utilities.js'
 
 export function addTimeOffsetToTimeline(targetTimeline: Timeline, timeOffset: number) {
 	if (!targetTimeline) {
@@ -62,14 +62,14 @@ export function roundTimelineProperties(targetTimeline: Timeline, decimalDigits
 }
 
 export async function wordTimelineToSegmentSentenceTimeline(wordTimeline: Timeline, transcript: string, language: string, paragraphBreaks: ParagraphBreakType = 'double', whitespace: WhitespaceProcessing = 'collapse') {
-	const paragraphs = await splitToParagraphs(transcript, paragraphBreaks, whitespace)
+	const paragraphs = splitToParagraphs(transcript, paragraphBreaks, whitespace)
 
 	const segments = paragraphs
 		.map(segment =>
 			splitToSentences(segment, language).map(sentence =>
 				sentence.trim()))
 
-	let text = ""
+	let text = ''
 	const charIndexToSentenceEntryMapping: TimelineEntry[] = []
 
 	const segmentTimeline: Timeline = []
@@ -78,8 +78,8 @@ export async function wordTimelineToSegmentSentenceTimeline(wordTimeline: Timeli
 		const sentencesInSegment: Timeline = []
 
 		const segmentEntry: TimelineEntry = {
-			type: "segment",
-			text: "",
+			type: 'segment',
+			text: '',
 			startTime: -1,
 			endTime: -1,
 			timeline: sentencesInSegment
@@ -87,14 +87,14 @@ export async function wordTimelineToSegmentSentenceTimeline(wordTimeline: Timeli
 
 		for (const sentence of segment) {
 			const sentenceEntry: TimelineEntry = {
-				type: "sentence",
+				type: 'sentence',
 				text: sentence,
 				startTime: -1,
 				endTime: -1,
 				timeline: []
 			}
 
-			for (const char of sentence + " ") {
+			for (const char of sentence + ' ') {
 				text += char
 				charIndexToSentenceEntryMapping.push(sentenceEntry)
 			}
@@ -122,7 +122,7 @@ export async function wordTimelineToSegmentSentenceTimeline(wordTimeline: Timeli
 		}
 
 		const targetSentenceEntry = charIndexToSentenceEntryMapping[indexOfWordInText]
-		targetSentenceEntry.timeline!.push(wordEntry)
+		targetSentenceEntry.timeline!.push(deepClone(wordEntry))
 
 		wordSearchStartOffset = indexOfWordInText + wordText.length
 	}
@@ -151,7 +151,7 @@ export async function wordTimelineToSegmentSentenceTimeline(wordTimeline: Timeli
 			continue
 		}
 
-		segmentEntry.text = newSentenceTimeline.map(sentenceEntry => sentenceEntry.text).join(" ")
+		segmentEntry.text = newSentenceTimeline.map(sentenceEntry => sentenceEntry.text).join(' ')
 
 		segmentEntry.startTime = newSentenceTimeline[0].startTime
 		segmentEntry.endTime = newSentenceTimeline[newSentenceTimeline.length - 1].endTime
@@ -207,7 +207,7 @@ export function addWordTextOffsetsToTimeline(timeline: Timeline, text: string, c
 	return currentOffset
 }
 
-export type TimelineEntryType = "segment" | "paragraph" | "sentence" | "clause" | "phrase" | "word" | "token" | "letter" | "phone" | "subphone"
+export type TimelineEntryType = 'segment' | 'paragraph' | 'sentence' | 'clause' | 'phrase' | 'word' | 'token' | 'letter' | 'phone' | 'subphone'
 
 export type TimelineEntry = {
 	type: TimelineEntryType
@@ -225,6 +225,8 @@ export type TimelineEntry = {
 
 	confidence?: number
 
+	id?: number
+
 	timeline?: Timeline
 }
 

package/src/utilities/Timer.ts

@@ -1,4 +1,4 @@
-import { roundToDigits, writeToStderr } from "./Utilities.js"
+import { roundToDigits, writeToStderr } from './Utilities.js'
 
 declare const chrome: any
 declare const process: any
@@ -56,7 +56,7 @@ export class Timer {
 	}
 
 	private static createGlobalTimestampFunction() {
-		if (typeof process === "object" && typeof process.hrtime === "function") {
+		if (typeof process === 'object' && typeof process.hrtime === 'function') {
 			let baseTimestamp = 0
 
 			this.timestampFunc = () => {
@@ -68,7 +68,7 @@ export class Timer {
 
 			baseTimestamp = Date.now() - this.timestampFunc()
 		}
-		else if (typeof chrome === "object" && chrome.Interval) {
+		else if (typeof chrome === 'object' && chrome.Interval) {
 			const baseTimestamp = Date.now()
 
 			const chromeIntervalObject = new chrome.Interval()
@@ -76,7 +76,7 @@ export class Timer {
 
 			this.timestampFunc = () => baseTimestamp + chromeIntervalObject.microseconds() / 1000
 		}
-		else if (typeof performance === "object" && performance.now) {
+		else if (typeof performance === 'object' && performance.now) {
 			const baseTimestamp = Date.now() - performance.now()
 
 			this.timestampFunc = () => baseTimestamp + performance.now()

package/src/utilities/Utilities.ts

@@ -5,6 +5,7 @@ import { inspect } from 'node:util'
 import { RandomGenerator } from './RandomGenerator.js'
 import { randomUUID, randomBytes } from 'node:crypto'
 import { Logger } from './Logger.js'
+import { ChildProcessWithoutNullStreams } from 'node:child_process'
 
 const log = logToStderr
 
@@ -84,7 +85,7 @@ export function printToStderr(message: any) {
 
 export function logToStderr(message: any) {
 	printToStderr(message)
-	writeToStderr("\n")
+	writeToStderr('\n')
 }
 
 export function objToString(obj: any) {
@@ -105,7 +106,7 @@ export function getRandomHexString(charCount = 32, upperCase = false) {
 		throw new Error(`'charCount' must be an even number`)
 	}
 
-	let hex = randomBytes(charCount / 2).toString("hex")
+	let hex = randomBytes(charCount / 2).toString('hex')
 
 	if (upperCase) {
 		hex = hex.toUpperCase()
@@ -118,7 +119,7 @@ export function getRandomUUID(dashes = true) {
 	let uuid = randomUUID() as string
 
 	if (dashes == false) {
-		uuid = uuid.replaceAll("-", "")
+		uuid = uuid.replaceAll('-', '')
 	}
 
 	return uuid
@@ -181,7 +182,7 @@ export function printMatrix(matrix: Float32Array[]) {
 	const rowCount = matrix.length
 
 	for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-		log(matrix[rowIndex].join(", "))
+		log(matrix[rowIndex].join(', '))
 	}
 }
 
@@ -212,11 +213,11 @@ export function secondsToMS(totalSeconds: number) {
 	return { minutes: (hours * 60) + minutes, seconds, milliseconds }
 }
 
-export function formatHMS(timeHMS: { hours: number, minutes: number, seconds: number, milliseconds: number }, decimalSeparator = ".") {
+export function formatHMS(timeHMS: { hours: number, minutes: number, seconds: number, milliseconds: number }, decimalSeparator = '.') {
 	return `${formatIntegerWithLeadingZeros(timeHMS.hours, 2)}:${formatIntegerWithLeadingZeros(timeHMS.minutes, 2)}:${formatIntegerWithLeadingZeros(timeHMS.seconds, 2)}${decimalSeparator}${formatIntegerWithLeadingZeros(timeHMS.milliseconds, 3)}`
 }
 
-export function formatMS(timeMS: { minutes: number, seconds: number, milliseconds: number }, decimalSeparator = ".") {
+export function formatMS(timeMS: { minutes: number, seconds: number, milliseconds: number }, decimalSeparator = '.') {
 	return `${formatIntegerWithLeadingZeros(timeMS.minutes, 2)}:${formatIntegerWithLeadingZeros(timeMS.seconds, 2)}${decimalSeparator}${formatIntegerWithLeadingZeros(timeMS.milliseconds, 3)}`
 }
 
@@ -356,15 +357,15 @@ export function readBinaryIncomingMessage(incomingMessage: IncomingMessage) {
 	return new Promise<Buffer>((resolve, reject) => {
 		const chunks: Buffer[] = []
 
-		incomingMessage.on("data", (chunk) => {
+		incomingMessage.on('data', (chunk) => {
 			chunks.push(Buffer.from(chunk))
 		})
 
-		incomingMessage.on("end", () => {
+		incomingMessage.on('end', () => {
 			resolve(Buffer.concat(chunks))
 		})
 
-		incomingMessage.on("error", (e) => {
+		incomingMessage.on('error', (e) => {
 			reject(e)
 		})
 	})
@@ -388,7 +389,7 @@ export async function sha256AsHex(input: string) {
 }
 
 export async function commandExists(command: string) {
-	const { default: commandExists } = await import("command-exists")
+	const { default: commandExists } = await import('command-exists')
 
 	try {
 		await commandExists(command)
@@ -415,11 +416,11 @@ export async function convertHtmlToText(html: string) {
 		]
 	})
 
-	return text || ""
+	return text || ''
 }
 
 export function formatListWithQuotedElements(strings: string[], quoteSymbol = `'`) {
-	return strings.map(str => `${quoteSymbol}${str}${quoteSymbol}`).join(", ")
+	return strings.map(str => `${quoteSymbol}${str}${quoteSymbol}`).join(', ')
 }
 
 export async function resolveModuleMainPath(moduleName: string) {
@@ -441,7 +442,7 @@ export function splitFilenameOnExtendedExtension(filenameWithExtension: string)
 	let splitPoint = filenameWithExtension.length
 
 	for (let i = filenameWithExtension.length - 1; i >= 0; i--) {
-		if (filenameWithExtension[i] == ".") {
+		if (filenameWithExtension[i] == '.') {
 			if (/^[a-zA-Z0-9\.]+$/.test(filenameWithExtension.slice(i + 1))) {
 				splitPoint = i
 
@@ -577,7 +578,7 @@ export async function resolveModuleScriptPath(moduleName: string) {
 export async function runOperationWithRetries<R>(
 	operationFunc: () => Promise<R>,
 	logger: Logger,
-	opreationName = "Operation",
+	opreationName = 'Operation',
 	delayBetweenRetries = 2000,
 	maxRetries = 200) {
 
@@ -592,7 +593,7 @@ export async function runOperationWithRetries<R>(
 			const { shouldCancelCurrentTask } = await import('../server/Worker.js')
 
 			if (shouldCancelCurrentTask()) {
-				throw new Error("Canceled")
+				throw new Error('Canceled')
 			}
 
 			logger.setAsActiveLogger()
@@ -613,3 +614,36 @@ export async function runOperationWithRetries<R>(
 
 	throw new Error(`${opreationName} failed after ${maxRetries} retry attempts`)
 }
+
+export function writeToStdinInChunks(process: ChildProcessWithoutNullStreams, buffer: Buffer, chunkSize: number) {
+	const writeChunk = (chunkOffset: number) => {
+		if (chunkOffset >= buffer.length) {
+			process.stdin.end() // End the stream after writing all chunks
+
+			return
+		}
+
+		const startOffset = chunkOffset
+		const endOffset = Math.min(chunkOffset + chunkSize, buffer.length)
+
+		const chunk = buffer.subarray(startOffset, endOffset)
+
+		if (!process.stdin.writable) {
+			return
+		}
+
+		process.stdin.write(chunk, () => writeChunk(endOffset))
+	}
+
+	writeChunk(0)
+}
+
+export function getIntegerRange(start: number, end: number): number[] {
+	const result = []
+
+	for (let i = start; i < end; i++) {
+		result.push(i)
+	}
+
+	return result
+}

package/src/utilities/WasmMemoryManager.ts

@@ -196,7 +196,7 @@ export class WasmMemoryManager {
 	}
 
 	allocNullTerminatedUtf8String(str: string) {
-		const strBuffer = Buffer.concat([Buffer.from(str, "utf8"), Buffer.alloc(1)])
+		const strBuffer = Buffer.concat([Buffer.from(str, 'utf8'), Buffer.alloc(1)])
 		const ref = this.allocUint8Array(strBuffer.length)
 		ref.view.set(strBuffer)
 		return ref
@@ -266,7 +266,7 @@ abstract class ValueRef<T extends number | string> {
 		if (typeof this.value == 'number') {
 			this.value = 0 as any
 		} else if (typeof this.value == 'string') {
-			throw new Error("Unimplemented")
+			throw new Error('Unimplemented')
 		}
 
 		return this
@@ -284,7 +284,7 @@ abstract class ValueRef<T extends number | string> {
 
 	protected assertNotFreed() {
 		if (this.isFreed) {
-			throw new Error("Attempt to read a freed WASM value reference.")
+			throw new Error('Attempt to read a freed WASM value reference.')
 		}
 	}
 }
@@ -381,13 +381,13 @@ export class NullTerminatedUtf8StringRef extends ValueRef<string> {
 
 		const strBytes = heapU8.subarray(ptr, ptr + endByteOffset)
 
-		const str = Buffer.from(strBytes).toString("utf8")
+		const str = Buffer.from(strBytes).toString('utf8')
 
 		return str
 	}
 
 	setValue(newValue: string) {
-		throw new Error("Unimplemented")
+		throw new Error('Unimplemented')
 	}
 }
 
@@ -437,7 +437,7 @@ abstract class TypedArrayRef<T extends TypedArray> {
 
 	protected assertNotFreed() {
 		if (this.isFreed) {
-			throw new Error("Attempt to read a freed WASM typed array reference.")
+			throw new Error('Attempt to read a freed WASM typed array reference.')
 		}
 	}
 }
@@ -464,7 +464,7 @@ export class Uint8ArrayRef extends TypedArrayRef<Uint8Array> {
 			strBytes = strBytes.subarray(0, indexOfFirstZero)
 		}
 
-		const str = Buffer.from(strBytes).toString("utf8")
+		const str = Buffer.from(strBytes).toString('utf8')
 
 		return str
 	}

package/src/utilities/WebReader.ts

@@ -10,29 +10,29 @@ export async function fetchDocumentText(url: string) {
 
 	const response = await request<string>({
 		url,
-		responseType: "text",
+		responseType: 'text',
 		headers: {
-			"sec-ch-ua": `".Not/A)Brand";v="99", "Google Chrome";v="103", "Chromium";v="103"`,
-			"x-same-domain": "1",
-			"dnt": "1",
-			"content-type": "application/x-www-form-urlencoded;charset=UTF-8",
-			"sec-ch-ua-mobile": "?0",
-			"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36",
-			"sec-ch-ua-arch": "x86",
-			"sec-ch-ua-full-version": "103.0.5060.114",
-			"sec-ch-ua-platform-version": "10.0.0",
-			"sec-ch-ua-full-version-list": `".Not/A)Brand";v="99.0.0.0", "Google Chrome";v="103.0.5060.114", "Chromium";v="103.0.5060.114"`,
-			"sec-ch-ua-bitness": "64",
-			"sec-ch-ua-model": "",
-			"sec-ch-ua-platform": "Windows",
-			"accept": "*/*",
-			//"origin": "https://www.google.com/",
-			"sec-fetch-site": "same-origin",
-			"sec-fetch-mode": "cors",
-			"sec-fetch-dest": "empty",
-			"referer": "https://www.google.com/",
-			"accept-encoding": "gzip, deflate, br",
-			"accept-language": "en-US,en;q=0.9",
+			'sec-ch-ua': `".Not/A)Brand";v="99", "Google Chrome";v="103", "Chromium";v="103"`,
+			'x-same-domain': '1',
+			'dnt': '1',
+			'content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
+			'sec-ch-ua-mobile': '?0',
+			'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36',
+			'sec-ch-ua-arch': 'x86',
+			'sec-ch-ua-full-version': '103.0.5060.114',
+			'sec-ch-ua-platform-version': '10.0.0',
+			'sec-ch-ua-full-version-list': `".Not/A)Brand";v="99.0.0.0", "Google Chrome";v="103.0.5060.114", "Chromium";v="103.0.5060.114"`,
+			'sec-ch-ua-bitness': '64',
+			'sec-ch-ua-model': '',
+			'sec-ch-ua-platform': 'Windows',
+			'accept': '*/*',
+			//'origin': 'https://www.google.com/',
+			'sec-fetch-site': 'same-origin',
+			'sec-fetch-mode': 'cors',
+			'sec-fetch-dest': 'empty',
+			'referer': 'https://www.google.com/',
+			'accept-encoding': 'gzip, deflate, br',
+			'accept-language': 'en-US,en;q=0.9',
 		},
 	})
 
@@ -47,7 +47,7 @@ export async function fetchDocumentText(url: string) {
 
 	const article = reader.parse()
 
-	const text: string = await convertHtmlToText(article?.content || "")
+	const text: string = await convertHtmlToText(article?.content || '')
 
 	progressLogger.end()
 

package/src/utilities/WikipediaReader.ts

@@ -4,14 +4,14 @@ import { Logger } from './Logger.js'
 export async function parseWikipediaArticle(articleName: string, language: string) {
 	const logger = new Logger()
 
-	logger.startAsync("Fetching Wikipedia article")
+	logger.startAsync('Fetching Wikipedia article')
 
 	const { default: wtf } = await import('wtf_wikipedia')
 
 	const document = await wtf.fetch(articleName, language)
 
 	if (!document) {
-		throw new Error("Error fetching Wikipedia article")
+		throw new Error('Error fetching Wikipedia article')
 	}
 
 	const sections = document.sections()

package/src/voice-activity-detection/AdaptiveGateVAD.ts

@@ -0,0 +1,202 @@
+import { RawAudio, getRawAudioDuration } from '../audio/AudioUtilities.js';
+import { BiquadFilter, createHighpassFilter, createLowpassFilter } from '../dsp/BiquadFilter.js';
+import { DecayingPeakEstimator } from '../dsp/DecayingPeakEstimator.js';
+import { LoudnessEstimator } from '../dsp/LoudnessEstimator.js';
+import { extendDeep } from '../utilities/ObjectUtilities.js';
+import { Timeline } from '../utilities/Timeline.js';
+import { logToStderr } from '../utilities/Utilities.js';
+
+const log = logToStderr
+
+export async function detectVoiceActivity(rawAudio: RawAudio, options: AdaptiveGateVADOptions) {
+	const channelCount = rawAudio.audioChannels.length
+	const sampleCount = rawAudio.audioChannels[0].length
+	const sampleRate = rawAudio.sampleRate
+
+	const audioDuration = getRawAudioDuration(rawAudio)
+
+	options = extendDeep(defaultAdaptiveGateOptions, options)
+
+	const gateVAD = new AdaptiveGateVAD(sampleRate, channelCount, options)
+
+	type FrameRecord = {
+		timePosition: number
+		loudness: number
+		minimumLoudness: number
+		maximumLoudness: number
+	}
+
+	const frameDuration = 0.01
+
+	const frameRecords: FrameRecord[] = []
+
+	for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
+		const timePosition = sampleIndex / sampleRate
+
+		for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+			const sample = rawAudio.audioChannels[channelIndex][sampleIndex]
+
+			gateVAD.process(sample, channelIndex)
+		}
+
+		if (
+			frameRecords.length == 0 ||
+			timePosition > frameRecords[frameRecords.length - 1].timePosition + frameDuration) {
+
+			const record: FrameRecord = {
+				timePosition,
+				loudness: gateVAD.loudnessEstimator.currentLoudness,
+				minimumLoudness: gateVAD.minimumLoudnessEstimator.currentPeak,
+				maximumLoudness: gateVAD.maximumLoudnessEstimator.currentPeak,
+			}
+
+			frameRecords.push(record)
+
+			//log(`${timePosition.toFixed(3)}: loudness: ${record.loudness.toFixed(2)}dB, min: ${record.minimumLoudness.toFixed(2)}dB, max: ${record.maximumLoudness.toFixed(2)}dB dynamic range: ${record.dynamicRange.toFixed(2)}dB`)
+		}
+	}
+
+	const frameActive: boolean[] = []
+
+	for (let i = 0; i < frameRecords.length; i++) {
+		frameActive[i] = false
+	}
+
+	{
+		const backwardExtensionFrameCount = Math.floor(options.backwardExtensionDuration! / frameDuration)
+		const relativeThreshold = options.relativeThreshold!
+
+		let extendedActivityStartIndex = frameRecords.length
+
+		for (let i = frameRecords.length - 1; i >= 0; i--) {
+			const record = frameRecords[i]
+			const referenceLoudness = Math.max(record.maximumLoudness, -30)
+
+			let isActive = false
+
+			if (i >= extendedActivityStartIndex) {
+				isActive = true
+			}
+
+			if (record.loudness >= referenceLoudness + relativeThreshold) {
+				isActive = true
+
+				extendedActivityStartIndex = Math.max(i - backwardExtensionFrameCount, 0)
+			}
+
+			frameActive[i] = isActive
+		}
+	}
+
+	const timeline: Timeline = []
+
+	for (let i = 0; i < frameRecords.length; i++) {
+		const record = frameRecords[i]
+		const isActive = frameActive[i]
+		const activityText = isActive ? 'active' : 'inactive'
+		const startTime = record.timePosition
+		const endTime = Math.min(startTime + frameDuration, audioDuration)
+
+		if (timeline.length == 0 || timeline[timeline.length - 1].text != activityText) {
+			timeline.push({
+				type: 'segment',
+				text: activityText,
+				startTime,
+				endTime,
+			})
+		} else {
+			timeline[timeline.length - 1].endTime = endTime
+		}
+	}
+
+	return timeline
+}
+
+export class AdaptiveGateVAD {
+	channelHighpassFilters: BiquadFilter[]
+	channelLowpassFilters: BiquadFilter[]
+
+	loudnessEstimator: LoudnessEstimator
+
+	minimumLoudnessEstimator: DecayingPeakEstimator
+	maximumLoudnessEstimator: DecayingPeakEstimator
+
+	constructor(
+		public readonly sampleRate: number,
+		public readonly channelCount: number,
+		public readonly options: AdaptiveGateVADOptions) {
+
+		this.channelHighpassFilters = []
+		this.channelLowpassFilters = []
+
+		for (let i = 0; i < this.channelCount; i++) {
+			this.channelHighpassFilters.push(createHighpassFilter(this.sampleRate, options.lowCutoff!))
+			this.channelLowpassFilters.push(createLowpassFilter(this.sampleRate, options.highCutoff!))
+		}
+
+		this.loudnessEstimator = new LoudnessEstimator({
+			sampleRate: this.sampleRate,
+			channelCount: this.channelCount,
+			positiveAdaptationRate: options.positiveAdaptationRate!,
+			negativeAdaptationRate: options.negativeAdaptationRate!,
+			initialEstimate: -60,
+			minimumLoudness: -60,
+			applyKWeighting: false,
+		})
+
+		const ticksPerSecond = this.sampleRate * this.channelCount
+
+		this.minimumLoudnessEstimator = new DecayingPeakEstimator({
+			kind: 'minimum',
+			decayPerSecond: options.peakLoudnessDecay!,
+			initialPeak: -60,
+		}, ticksPerSecond)
+
+		this.maximumLoudnessEstimator = new DecayingPeakEstimator({
+			kind: 'maximum',
+			decayPerSecond: options.peakLoudnessDecay!,
+			initialPeak: -60,
+		}, ticksPerSecond)
+	}
+
+	process(sample: number, channelIndex: number) {
+		sample = this.channelHighpassFilters[channelIndex].filter(sample)
+		sample = this.channelLowpassFilters[channelIndex].filter(sample)
+
+		this.loudnessEstimator.process(sample, channelIndex)
+
+		const currentLoudness = this.loudnessEstimator.currentLoudness
+
+		this.minimumLoudnessEstimator.process(currentLoudness)
+
+		if (currentLoudness >= -60) {
+			this.maximumLoudnessEstimator.process(currentLoudness)
+		}
+	}
+}
+
+export interface AdaptiveGateVADOptions {
+	lowCutoff?: number
+	highCutoff?: number
+
+	positiveAdaptationRate?: number,
+	negativeAdaptationRate?: number,
+
+	peakLoudnessDecay?: number,
+
+	backwardExtensionDuration?: number
+	relativeThreshold?: number
+}
+
+export const defaultAdaptiveGateOptions: AdaptiveGateVADOptions = {
+	lowCutoff: 100,
+	highCutoff: 1000,
+
+	positiveAdaptationRate: 400.0,
+	negativeAdaptationRate: 10.0,
+
+	peakLoudnessDecay: 4.0,
+
+	backwardExtensionDuration: 0.2,
+	relativeThreshold: -15,
+}

package/src/voice-activity-detection/SileroVAD.ts

@@ -5,9 +5,9 @@ import { RawAudio } from '../audio/AudioUtilities.js'
 
 let sileroVad: SileroVAD
 
-export async function detectVoiceActivity(rawAudio: RawAudio, modelPath: string, frameDuration: 30 | 60 | 90 = 30) {
+export async function detectVoiceActivity(rawAudio: RawAudio, modelPath: string, frameDuration: 30 | 60 | 90) {
 	if (rawAudio.sampleRate != 16000) {
-		throw new Error("Audio sample rate must be 16KHz")
+		throw new Error('Audio sample rate must be 16KHz')
 	}
 
 	const audioSamples = rawAudio.audioChannels[0]
@@ -68,10 +68,10 @@ export class SileroVAD {
 
 		const results = await this.session!.run(inputs)
 
-		const probability = results["output"].data[0] as number
+		const probability = results['output'].data[0] as number
 
-		this.modelStateH = results["hn"]
-		this.modelStateC = results["cn"]
+		this.modelStateH = results['hn']
+		this.modelStateC = results['cn']
 
 		return probability
 	}

package/src/voice-activity-detection/WebRtcVAD.ts

@@ -1,10 +1,10 @@
-import * as AudioBufferConversion from "../audio/AudioBufferConversion.js"
-import { RawAudio } from "../audio/AudioUtilities.js"
-import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js"
+import * as AudioBufferConversion from '../audio/AudioBufferConversion.js'
+import { RawAudio } from '../audio/AudioUtilities.js'
+import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
 
 export async function detectVoiceActivity(rawAudio: RawAudio, frameDuration: 10 | 20 | 30 = 10, mode: 0 | 1 | 2 | 3 = 0) {
 	if (rawAudio.sampleRate != 16000) {
-		throw new Error("Audio sample rate must be 16KHz")
+		throw new Error('Audio sample rate must be 16KHz')
 	}
 
 	const frameClassifications: (0 | 1)[] = await fvad(AudioBufferConversion.float32ToInt16Pcm(rawAudio.audioChannels[0]), rawAudio.sampleRate, frameDuration, mode)
@@ -52,7 +52,7 @@ export async function fvad(samples: Int16Array, sampleRate: number, frameDuratio
 		const fvadResult = fvad_process(instancePtr, frameSamplesRef.address, frameSampleCount)
 
 		if (fvadResult == -1) {
-			throw new Error("fvad_process failed")
+			throw new Error('fvad_process failed')
 		}
 
 		result.push(fvadResult)