echogarden 0.12.2 → 1.0.0

package/src/cli/CLIConfigFile.ts

@@ -1,7 +1,7 @@
-import { readAndParseJsonFile, readFile } from "../utilities/FileSystem.js"
+import { readAndParseJsonFile, readFile } from '../utilities/FileSystem.js'
 
 export async function parseConfigFile(path: string): Promise<ParsedConfigFile> {
-	const fileContent = await readFile(path, { encoding: "utf-8" })
+	const fileContent = await readFile(path, { encoding: 'utf-8' })
 
 	const lines = fileContent
 		.split(/\r?\n/g)
@@ -11,12 +11,12 @@ export async function parseConfigFile(path: string): Promise<ParsedConfigFile> {
 
 	const sectionMap = new Map<string, Map<string, string>>()
 
-	let currentSectionName = ""
+	let currentSectionName = ''
 
 	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
 		const line = lines[lineIndex]
 
-		if (line.length == 0 || line.startsWith("#")) {
+		if (line.length == 0 || line.startsWith('#')) {
 			continue
 		}
 
@@ -31,7 +31,7 @@ export async function parseConfigFile(path: string): Promise<ParsedConfigFile> {
 			sectionMap.set(currentSectionName, new Map())
 		}
 
-		const splitPoint = line.indexOf("=")
+		const splitPoint = line.indexOf('=')
 
 		let key: string
 		let value: string
@@ -65,10 +65,10 @@ export async function parseJSONConfigFile(path: string): Promise<ParsedConfigFil
 			for (const propertyName in obj) {
 				const propertyValue = obj[propertyName]
 
-				const propertyPath = pathPrefix == "" ? propertyName : `${pathPrefix}.${propertyName}`
+				const propertyPath = pathPrefix == '' ? propertyName : `${pathPrefix}.${propertyName}`
 
 
-				if (typeof propertyValue == "object") {
+				if (typeof propertyValue == 'object') {
 					if (Array.isArray(propertyValue)) {
 						commandMap.set(propertyPath, JSON.stringify(propertyValue))
 					} else {
@@ -80,7 +80,7 @@ export async function parseJSONConfigFile(path: string): Promise<ParsedConfigFil
 			}
 		}
 
-		addFromObject(commandObj, "")
+		addFromObject(commandObj, '')
 
 		result.set(command, commandMap)
 	}

package/src/cli/CLILauncher.ts

@@ -9,18 +9,18 @@ setupUnhandledExceptionListeners()
 const cmd = process.argv[0]
 const scriptArgs = process.argv.slice(2)
 
-const cliScriptPath = resolveToModuleRootDir("dist/cli/CLIStarter.js")
+const cliScriptPath = resolveToModuleRootDir('dist/cli/CLIStarter.js')
 
 const args = [
-	"--no-warnings",
-	"--no-experimental-fetch",
-	"--experimental-wasi-unstable-preview1",
+	'--no-warnings',
+	'--no-experimental-fetch',
+	'--experimental-wasi-unstable-preview1',
 	cliScriptPath,
 	...scriptArgs
 ]
 
-const child = spawn(cmd, args, { stdio: "inherit" })
+const child = spawn(cmd, args, { stdio: 'inherit' })
 
-child.on("close", code => {
+child.on('close', code => {
 	process.exit(code as number)
 })

package/src/cli/CLIOptionsSchema.ts

@@ -11,10 +11,10 @@ export function getOptionTypeFromSchema(path: string[], schema: any): SchemaType
 		currentObject = currentObject[key]
 
 		if (!currentObject) {
-			throw new Error(`'${key}' is not a valid property of '${path.slice(0, keyIndex).join(".")}'.`)
+			throw new Error(`'${key}' is not a valid property of '${path.slice(0, keyIndex).join('.')}'.`)
 		}
 
-		if ("$ref" in currentObject) {
+		if ('$ref' in currentObject) {
 			const refString = currentObject['$ref'] as string
 			const parsedRef = refString.substring(refString.lastIndexOf('/') + 1)
 

package/src/cli/CLIParser.ts

@@ -7,20 +7,20 @@ export function parseCLIArguments(command: string, args: string[]): CLIArguments
 
 	for (let i = 0; i < args.length; i++) {
 		const currentArg = args[i]
-		const currentArgIsNewOption = currentArg.startsWith("-")
+		const currentArgIsNewOption = currentArg.startsWith('-')
 
 		if (currentArgIsNewOption) {
-			if (!currentArg.startsWith("--")) {
+			if (!currentArg.startsWith('--')) {
 				throw new Error(`'${currentArg}' has a single dash prefix. You should use '-${currentArg}' instead.`)
 			}
 
 			const optionText = currentArg.substring(2)
 
-			const indexOfEquals = optionText.indexOf("=")
+			const indexOfEquals = optionText.indexOf('=')
 			if (indexOfEquals == 0) {
-				throw new Error("An option cannot have an empty name.")
+				throw new Error('An option cannot have an empty name.')
 			} else if (indexOfEquals == -1) {
-				parsedArgs.options.set(optionText, "")
+				parsedArgs.options.set(optionText, '')
 			} else {
 				const key = optionText.substring(0, indexOfEquals)
 				const value = optionText.substring(indexOfEquals + 1)

package/src/cli/CLIStarter.ts

@@ -9,7 +9,7 @@ setupProgramTerminationListeners(() => {
 	process.kill(process.pid, 'SIGKILL')
 })
 
-const worker = new Worker(resolveToModuleRootDir("dist/cli/CLI.js"), {
+const worker = new Worker(resolveToModuleRootDir('dist/cli/CLI.js'), {
 	argv: process.argv.slice(2),
 	env: SHARE_ENV
 })
@@ -29,12 +29,12 @@ process.stdin.on('keypress', (str, key) => {
 	})
 })
 
-worker.on("message", (message) => {
-	if (message.name == "writeToStdErr") {
+worker.on('message', (message) => {
+	if (message.name == 'writeToStdErr') {
 		writeToStderr(message.text)
 	}
 })
 
-worker.on("exit", (err) => {
+worker.on('exit', (err) => {
 	process.exit(err ? 1 : 0)
 })

package/src/codecs/FFMpegTranscoder.ts

@@ -1,12 +1,12 @@
-import { spawn } from "child_process"
+import { spawn } from 'child_process'
 
-import { encodeWaveBuffer, decodeWaveBuffer, RawAudio } from "../audio/AudioUtilities.js"
+import { encodeRawAudioToWave, decodeWaveToRawAudio, RawAudio } from '../audio/AudioUtilities.js'
 
-import { Logger } from "../utilities/Logger.js"
-import { commandExists, logToStderr } from "../utilities/Utilities.js"
-import path from "node:path"
-import { loadPackage } from "../utilities/PackageManager.js"
-import { getGlobalOption } from "../api/GlobalOptions.js"
+import { Logger } from '../utilities/Logger.js'
+import { commandExists, logToStderr } from '../utilities/Utilities.js'
+import path from 'node:path'
+import { loadPackage } from '../utilities/PackageManager.js'
+import { getGlobalOption } from '../api/GlobalOptions.js'
 
 const log = logToStderr
 
@@ -15,7 +15,7 @@ export type FFMpegOutputOptions = {
 	codec?: string
 	format?: string
 	sampleRate?: number
-	sampleFormat?: "u8" | "s16" | "s32" | "s64" | "flt" | "dbl"
+	sampleFormat?: 'u8' | 's16' | 's32' | 's64' | 'flt' | 'dbl'
 	channelCount?: number
 	bitrate?: number
 	audioOnly?: boolean
@@ -23,13 +23,13 @@ export type FFMpegOutputOptions = {
 }
 
 export async function encodeFromChannels(rawAudio: RawAudio, outputOptions: FFMpegOutputOptions) {
-	return transcode(encodeWaveBuffer(rawAudio), outputOptions)
+	return transcode(encodeRawAudioToWave(rawAudio), outputOptions)
 }
 
 export async function decodeToChannels(input: string | Buffer, outSampleRate?: number, outChannelCount?: number) {
 	const outputOptions: FFMpegOutputOptions = {
-		codec: "pcm_f32le",
-		format: "wav",
+		codec: 'pcm_f32le',
+		format: 'wav',
 		sampleRate: outSampleRate,
 		channelCount: outChannelCount,
 		audioOnly: true
@@ -37,7 +37,7 @@ export async function decodeToChannels(input: string | Buffer, outSampleRate?: n
 
 	const waveAudio = await transcode(input, outputOptions)
 
-	const { rawAudio } = decodeWaveBuffer(waveAudio, true)
+	const { rawAudio } = decodeWaveToRawAudio(waveAudio, true)
 
 	return rawAudio
 }
@@ -46,7 +46,7 @@ export async function transcode(input: string | Buffer, outputOptions: FFMpegOut
 	const executablePath = await getFFMpegExecutablePath()
 
 	if (!executablePath) {
-		throw new Error("The ffmpeg utility wasn't found. Please ensure it is available on the system path.")
+		throw new Error(`The ffmpeg utility wasn't found. Please ensure it is available on the system path.`)
 	}
 
 	return transcode_CLI(executablePath, input, outputOptions)
@@ -55,9 +55,9 @@ export async function transcode(input: string | Buffer, outputOptions: FFMpegOut
 async function transcode_CLI(ffmpegCommand: string, input: string | Buffer, outputOptions: FFMpegOutputOptions) {
 	return new Promise<Buffer>((resolve, reject) => {
 		const logger = new Logger()
-		logger.start("Transcode with command-line ffmpeg")
+		logger.start('Transcode with command-line ffmpeg')
 
-		const args = buildCommandLineArguments(Buffer.isBuffer(input) ? "-" : input, outputOptions)
+		const args = buildCommandLineArguments(Buffer.isBuffer(input) ? '-' : input, outputOptions)
 
 		const process = spawn(ffmpegCommand, args)
 
@@ -65,29 +65,29 @@ async function transcode_CLI(ffmpegCommand: string, input: string | Buffer, outp
 			process.stdin.end(input)
 		}
 
-		const stdOutChunks: Buffer[] = []
-		let stdErrOutput = ""
+		const stdoutChunks: Buffer[] = []
+		let stderrOutput = ''
 
 		process.stdout.on('data', (data) => {
-			stdOutChunks.push(data)
+			stdoutChunks.push(data)
 		})
 
-		process.stderr.setEncoding("utf8")
+		process.stderr.setEncoding('utf8')
 		process.stderr.on('data', (data) => {
 			//log(data)
-			stdErrOutput += data
+			stderrOutput += data
 		})
 
-		process.on("error", (e) => {
+		process.on('error', (e) => {
 			reject(e)
 		})
 
 		process.on('close', (exitCode) => {
 			if (exitCode == 0) {
-				resolve(Buffer.concat(stdOutChunks))
+				resolve(Buffer.concat(stdoutChunks))
 			} else {
 				reject(`ffmpeg exited with code ${exitCode}`)
-				log(stdErrOutput)
+				log(stderrOutput)
 			}
 
 			logger.end()
@@ -99,7 +99,7 @@ function buildCommandLineArguments(inputFilename: string, outputOptions: FFMpegO
 	outputOptions = { ...outputOptions }
 
 	if (!outputOptions.filename) {
-		outputOptions.filename = "-"
+		outputOptions.filename = '-'
 	}
 
 	const args: string[] = []
@@ -200,36 +200,36 @@ async function getFFMpegExecutablePath() {
 export function getDefaultFFMpegOptionsForSpeech(fileExtension: string, customBitrate?: number) {
 	let ffmpegOptions: FFMpegOutputOptions
 
-	if (fileExtension == "mp3") {
+	if (fileExtension == 'mp3') {
 		ffmpegOptions = {
-			format: "mp3",
-			codec: "libmp3lame",
+			format: 'mp3',
+			codec: 'libmp3lame',
 			bitrate: 64,
 			customOptions: []
 		}
-	} else if (fileExtension == "opus") {
+	} else if (fileExtension == 'opus') {
 		ffmpegOptions = {
-			codec: "libopus",
+			codec: 'libopus',
 			bitrate: 48,
 			customOptions: []
 		}
-	} else if (fileExtension == "m4a") {
+	} else if (fileExtension == 'm4a') {
 		ffmpegOptions = {
-			format: "mp4",
-			codec: "aac",
+			format: 'mp4',
+			codec: 'aac',
 			bitrate: 48,
-			customOptions: ["-profile:a", "aac_low", "-movflags", "frag_keyframe+empty_moov"]
+			customOptions: ['-profile:a', 'aac_low', '-movflags', 'frag_keyframe+empty_moov']
 		}
-	} else if (fileExtension == "ogg") {
+	} else if (fileExtension == 'ogg') {
 		ffmpegOptions = {
-			codec: "libvorbis",
+			codec: 'libvorbis',
 			bitrate: 48,
 			customOptions: []
 		}
-	} else if (fileExtension == "flac") {
+	} else if (fileExtension == 'flac') {
 		ffmpegOptions = {
-			format: "flac",
-			customOptions: ["-compression_level", "6"]
+			format: 'flac',
+			customOptions: ['-compression_level', '6']
 		}
 	} else {
 		throw new Error(`Unsupported codec extension: '${fileExtension}'`)

package/src/codecs/TIMITCodec.ts

@@ -1,14 +1,14 @@
-import { decodeToChannels } from "../audio/AudioBufferConversion.js"
-import { readFile } from "../utilities/FileSystem.js"
-import { SampleFormat } from "./WaveCodec.js"
+import { decodeToChannels } from '../audio/AudioBufferConversion.js'
+import { readFile } from '../utilities/FileSystem.js'
+import { SampleFormat } from './WaveCodec.js'
 
 export async function decodeTimitAudioFile(filename: string) {
 	return decodeTimitAudio(await readFile(filename))
 }
 
 export function decodeTimitAudio(data: Buffer) {
-	if (data.subarray(0, 16).toString("ascii") != "NIST_1A\n   1024\n") {
-		throw new Error("Data is not a valid TIMIT audio file")
+	if (data.subarray(0, 16).toString('ascii') != 'NIST_1A\n   1024\n') {
+		throw new Error('Data is not a valid TIMIT audio file')
 	}
 
 	const pcm = data.subarray(1024)

package/src/codecs/WaveCodec.ts

@@ -17,14 +17,14 @@ export function encodeWave(rawAudio: RawAudio, bitDepth: BitDepth = 16, sampleFo
 	const formatSubChunkBuffer = formatSubChunk.serialize(shouldUseExtensibleFormat)
 
 	const dataSubChunkBuffer = Buffer.alloc(4 + 4 + audioDataLength)
-	dataSubChunkBuffer.write("data", 0, "ascii")
+	dataSubChunkBuffer.write('data', 0, 'ascii')
 	dataSubChunkBuffer.writeUint32LE(audioDataLength, 4)
 	dataSubChunkBuffer.set(audioBuffer, 8)
 
 	const riffChunkHeaderBuffer = Buffer.alloc(12)
-	riffChunkHeaderBuffer.write("RIFF", 0, "ascii")
+	riffChunkHeaderBuffer.write('RIFF', 0, 'ascii')
 	riffChunkHeaderBuffer.writeUint32LE(4 + formatSubChunkBuffer.length + dataSubChunkBuffer.length, 4)
-	riffChunkHeaderBuffer.write("WAVE", 8, "ascii")
+	riffChunkHeaderBuffer.write('WAVE', 8, 'ascii')
 
 	return Buffer.concat([riffChunkHeaderBuffer, formatSubChunkBuffer, dataSubChunkBuffer])
 }
@@ -32,10 +32,10 @@ export function encodeWave(rawAudio: RawAudio, bitDepth: BitDepth = 16, sampleFo
 export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
 	let readOffset = 0
 
-	const riffId = waveData.subarray(readOffset, readOffset + 4).toString("ascii")
+	const riffId = waveData.subarray(readOffset, readOffset + 4).toString('ascii')
 
-	if (riffId != "RIFF") {
-		throw new Error("Not a valid wave file. No RIFF id found at offset 0.")
+	if (riffId != 'RIFF') {
+		throw new Error('Not a valid wave file. No RIFF id found at offset 0.')
 	}
 
 	readOffset += 4
@@ -44,10 +44,10 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
 
 	readOffset += 4
 
-	const waveId = waveData.subarray(readOffset, readOffset + 4).toString("ascii")
+	const waveId = waveData.subarray(readOffset, readOffset + 4).toString('ascii')
 
-	if (waveId != "WAVE") {
-		throw new Error("Not a valid wave file. No WAVE id found at offset 8.")
+	if (waveId != 'WAVE') {
+		throw new Error('Not a valid wave file. No WAVE id found at offset 8.')
 	}
 
 	if (riffChunkSize < waveData.length - 8) {
@@ -64,7 +64,7 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
 	const dataBuffers: Buffer[] = []
 
 	while (true) {
-		const subChunkIdentifier = waveData.subarray(readOffset, readOffset + 4).toString("ascii")
+		const subChunkIdentifier = waveData.subarray(readOffset, readOffset + 4).toString('ascii')
 		readOffset += 4
 
 		const subChunkSize = waveData.readUInt32LE(readOffset)
@@ -74,11 +74,11 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
 			throw new Error(`Encountered a '${subChunkIdentifier}' subchunk with a size of ${subChunkSize} which is greater than the remaining size of the buffer (${waveData.length - readOffset})`)
 		}
 
-		if (subChunkIdentifier == "fmt ") {
+		if (subChunkIdentifier == 'fmt ') {
 			formatSubChunkBodyBuffer = waveData.subarray(readOffset, readOffset + subChunkSize)
-		} else if (subChunkIdentifier == "data") {
+		} else if (subChunkIdentifier == 'data') {
 			if (!formatSubChunkBodyBuffer) {
-				throw new Error("A data subchunk was encountered before a format subchunk")
+				throw new Error('A data subchunk was encountered before a format subchunk')
 			}
 
 			// If the data chunk is truncated, but truncations are ignored,
@@ -98,7 +98,7 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = false) {
 	}
 
 	if (!formatSubChunkBodyBuffer) {
-		throw new Error("No format subchunk was found in the wave file")
+		throw new Error('No format subchunk was found in the wave file')
 	}
 
 	const waveFormat = WaveFormat.deserializeFrom(formatSubChunkBodyBuffer)
@@ -161,7 +161,7 @@ class WaveFormat { // 24 bytes total for PCM, 26 for float
 
 		const result = Buffer.alloc(serializedSize)
 
-		result.write("fmt ", 0, "ascii") // + 4
+		result.write('fmt ', 0, 'ascii') // + 4
 		result.writeUint32LE(serializedSize - 8, 4) // + 4
 
 		result.writeUint16LE(sampleFormatId, 8) // + 2
@@ -177,7 +177,7 @@ class WaveFormat { // 24 bytes total for PCM, 26 for float
 			result.writeUint32LE(this.speakerPositionMask, 28) // + 2 (speaker position mask)
 
 			if (this.sampleFormat == SampleFormat.PCM || this.sampleFormat == SampleFormat.Float) {
-				result.set(Buffer.from(this.guid, "hex"), 32)
+				result.set(Buffer.from(this.guid, 'hex'), 32)
 			} else {
 				throw new Error(`Extensible format is not supported for sample format ${this.sampleFormat}`)
 			}
@@ -200,7 +200,7 @@ class WaveFormat { // 24 bytes total for PCM, 26 for float
 
 			speakerPositionMask = formatChunkBody.readUint16LE(20)
 
-			const guid = formatChunkBody.subarray(24, 40).toString("hex")
+			const guid = formatChunkBody.subarray(24, 40).toString('hex')
 
 			if (guid == sampleFormatToGuid[SampleFormat.PCM]) {
 				sampleFormat = SampleFormat.PCM
@@ -237,7 +237,7 @@ class WaveFormat { // 24 bytes total for PCM, 26 for float
 
 export enum SampleFormat {
 	PCM = 1,
-	Float = 2,
+	Float = 3,
 	Alaw = 6,
 	Mulaw = 7,
 }
@@ -253,8 +253,8 @@ const sampleFormatToSerializedSize = {
 }
 
 const sampleFormatToGuid = {
-	[SampleFormat.PCM]: "0100000000001000800000aa00389b71",
-	[SampleFormat.Float]: "0300000000001000800000aa00389b71",
-	[SampleFormat.Alaw]: "",
-	[SampleFormat.Mulaw]: "",
+	[SampleFormat.PCM]: '0100000000001000800000aa00389b71',
+	[SampleFormat.Float]: '0300000000001000800000aa00389b71',
+	[SampleFormat.Alaw]: '',
+	[SampleFormat.Mulaw]: '',
 }

package/src/denoising/RNNoise.ts

@@ -1,29 +1,29 @@
-import { float32ToInt16Pcm } from "../audio/AudioBufferConversion.js"
-import { concatFloat32Arrays } from "../utilities/Utilities.js"
-import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js"
-import { Logger } from "../utilities/Logger.js"
-import { RawAudio, cloneRawAudio } from "../audio/AudioUtilities.js"
+import { float32ToInt16Pcm } from '../audio/AudioBufferConversion.js'
+import { concatFloat32Arrays } from '../utilities/Utilities.js'
+import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
+import { Logger } from '../utilities/Logger.js'
+import { RawAudio, cloneRawAudio } from '../audio/AudioUtilities.js'
 
 let rnnoiseInstance: any
 
 export async function denoiseAudio(rawAudio: RawAudio) {
 	const logger = new Logger()
 	if (rawAudio.sampleRate != 48000) {
-		throw new Error("Sample rate must be 48000")
+		throw new Error('Sample rate must be 48000')
 	}
 
 	if (rawAudio.audioChannels.length != 1) {
-		throw new Error("Channel count must be 1")
+		throw new Error('Channel count must be 1')
 	}
 
 	if (rawAudio.audioChannels[0].length == 0) {
 		return { denoisedRawAudio: cloneRawAudio(rawAudio), frameVadProbabilities: [] }
 	}
 
-	logger.start("Get RNNoise WASM instance")
+	logger.start('Get RNNoise WASM instance')
 	const m = await getRnnoiseInstance()
 
-	logger.start("Process with RNNoise")
+	logger.start('Process with RNNoise')
 	const wasmMemory = new WasmMemoryManager(m)
 
 	const stateSize = m._rnnoise_get_size()

package/src/dsp/BiquadFilter.ts

@@ -11,35 +11,35 @@
 // https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode
 
 export function createLowpassFilter(sampleRate: number, cutoffFrequency: number, q = 0.7071) {
-	return createFilter("lowpass", sampleRate, cutoffFrequency, q, 0)
+	return createFilter('lowpass', sampleRate, cutoffFrequency, q, 0)
 }
 
 export function createHighpassFilter(sampleRate: number, cutoffFrequency: number, q = 0.7071) {
-	return createFilter("highpass", sampleRate, cutoffFrequency, q, 0)
+	return createFilter('highpass', sampleRate, cutoffFrequency, q, 0)
 }
 
 export function createBandpassFilter(sampleRate: number, centerFrequency: number, q = 1) {
-	return createFilter("bandpass", sampleRate, centerFrequency, q, 0)
+	return createFilter('bandpass', sampleRate, centerFrequency, q, 0)
 }
 
 export function createLowshelfFilter(sampleRate: number, midpointFrequency: number, gain: number) {
-	return createFilter("lowshelf", sampleRate, midpointFrequency, 0, gain)
+	return createFilter('lowshelf', sampleRate, midpointFrequency, 0, gain)
 }
 
 export function createHighshelfFilter(sampleRate: number, midpointFrequency: number, gain: number) {
-	return createFilter("highshelf", sampleRate, midpointFrequency, 0, gain)
+	return createFilter('highshelf', sampleRate, midpointFrequency, 0, gain)
 }
 
 export function createPeakingFilter(sampleRate: number, centerFrequency: number, q = 1, gain = 0) {
-	return createFilter("peaking", sampleRate, centerFrequency, q, gain)
+	return createFilter('peaking', sampleRate, centerFrequency, q, gain)
 }
 
 export function createNotchFilter(sampleRate: number, centerFrequency: number, q = 1) {
-	return createFilter("notch", sampleRate, centerFrequency, q, 0)
+	return createFilter('notch', sampleRate, centerFrequency, q, 0)
 }
 
 export function createAllpassFilter(sampleRate: number, centerFrequency: number, q = 1) {
-	return createFilter("allpass", sampleRate, centerFrequency, q, 0)
+	return createFilter('allpass', sampleRate, centerFrequency, q, 0)
 }
 
 export function createFilter(filterType: FilterType, sampleRate: number, frequency: number, q: number, gain: number) {
@@ -65,7 +65,7 @@ export class BiquadFilter {
 		this.setCoefficients(coefficients)
 	}
 
-	step(sample: number): number {
+	filter(sample: number): number {
 		const filteredSample =
 			(this.b0 * sample) +
 			(this.b1 * this.prevInput1) +
@@ -82,9 +82,9 @@ export class BiquadFilter {
 		return filteredSample
 	}
 
-	apply(samples: Float32Array) {
+	filterSamplesInPlace(samples: Float32Array) {
 		for (let i = 0; i < samples.length; i++) {
-			samples[i] = this.step(samples[i])
+			samples[i] = this.filter(samples[i])
 		}
 	}
 
@@ -486,3 +486,11 @@ export type FilterCoefficients = {
 	a1: number
 	a2: number
 }
+
+export const emptyBiquadCoefficients: FilterCoefficients = {
+	b0: 0,
+	b1: 0,
+	b2: 0,
+	a1: 0,
+	a2: 0,
+}

package/src/dsp/DecayingPeakEstimator.ts

@@ -0,0 +1,35 @@
+export class DecayingPeakEstimator {
+	public readonly decayPerTick: number
+
+	currentPeak: number
+
+	constructor(
+		public readonly options: DecayingPeakEstimatorOptions,
+		public readonly ticksPerSecond: number) {
+
+		this.currentPeak = options.initialPeak
+		this.decayPerTick = this.options.decayPerSecond / this.ticksPerSecond
+
+		this.process = options.kind === 'maximum' ? this.processMaximum : this.processMinimum
+	}
+
+	public readonly process: (value: number) => void
+
+	private processMaximum(value: number) {
+		this.currentPeak -= this.decayPerTick
+		this.currentPeak = Math.max(value, this.currentPeak)
+	}
+
+	private processMinimum(value: number) {
+		this.currentPeak += this.decayPerTick
+		this.currentPeak = Math.min(value, this.currentPeak)
+	}
+}
+
+export interface DecayingPeakEstimatorOptions {
+	kind: DecayingPeakEstimatorKind
+	decayPerSecond: number
+	initialPeak: number
+}
+
+export type DecayingPeakEstimatorKind = 'maximum' | 'minimum'