echogarden 0.11.12 → 0.11.13

package/src/cli/CLIConfigFile.ts

@@ -0,0 +1,91 @@
+import { readAndParseJsonFile, readFile } from "../utilities/FileSystem.js"
+
+export async function parseConfigFile(path: string): Promise<ParsedConfigFile> {
+	const fileContent = await readFile(path, { encoding: "utf-8" })
+
+	const lines = fileContent
+		.split(/\r?\n/g)
+		.map(line => line.trim())
+
+	const sectionRegExp = /^\s*\[(.*)\]\s*$/
+
+	const sectionMap = new Map<string, Map<string, string>>()
+
+	let currentSectionName = ""
+
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+		const line = lines[lineIndex]
+
+		if (line.length == 0 || line.startsWith("#")) {
+			continue
+		}
+
+		const sectionMatch = sectionRegExp.exec(line)
+
+		if (sectionMatch) {
+			currentSectionName = sectionMatch[1]
+			continue
+		}
+
+		if (!(sectionMap.has(currentSectionName))) {
+			sectionMap.set(currentSectionName, new Map())
+		}
+
+		const splitPoint = line.indexOf("=")
+
+		let key: string
+		let value: string
+
+		if (splitPoint == 0) {
+			throw new Error(`Invalid empty key on line ${lineIndex + 1}`)
+		} else if (splitPoint > 0) {
+			key = line.substring(0, splitPoint).trim()
+			value = line.substring(splitPoint + 1).trim()
+
+			if (value) {
+				sectionMap.get(currentSectionName)!.set(key, value)
+			}
+		}
+	}
+
+	return sectionMap
+}
+
+export async function parseJSONConfigFile(path: string): Promise<ParsedConfigFile> {
+	const parsedJSON = await readAndParseJsonFile(path, true)
+
+	const result: ParsedConfigFile = new Map()
+
+	for (const command in parsedJSON) {
+		const commandObj = parsedJSON[command]
+
+		const commandMap = new Map<string, string>()
+
+		function addFromObject(obj: any, pathPrefix: string): void {
+			for (const propertyName in obj) {
+				const propertyValue = obj[propertyName]
+
+				const propertyPath = pathPrefix == "" ? propertyName : `${pathPrefix}.${propertyName}`
+
+
+				if (typeof propertyValue == "object") {
+					if (Array.isArray(propertyValue)) {
+						commandMap.set(propertyPath, JSON.stringify(propertyValue))
+					} else {
+						addFromObject(propertyValue, propertyPath)
+					}
+				} else {
+					commandMap.set(propertyPath, propertyValue)
+				}
+			}
+		}
+
+		addFromObject(commandObj, "")
+
+		result.set(command, commandMap)
+	}
+
+	return result
+}
+
+export type ParsedConfigFile = Map<string, Map<string, string>>

package/src/cli/CLILauncher.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process'
+import { setupUnhandledExceptionListeners } from '../utilities/Utilities.js'
+import { resolveToModuleRootDir } from '../utilities/FileSystem.js'
+
+setupUnhandledExceptionListeners()
+
+const cmd = process.argv[0]
+const scriptArgs = process.argv.slice(2)
+
+const cliScriptPath = resolveToModuleRootDir("dist/cli/CLIStarter.js")
+
+const args = [
+	"--no-warnings",
+	"--no-experimental-fetch",
+	"--experimental-wasi-unstable-preview1",
+	cliScriptPath,
+	...scriptArgs
+]
+
+const child = spawn(cmd, args, { stdio: "inherit" })
+
+child.on("close", code => {
+	process.exit(code as number)
+})

package/src/cli/CLIOptionsSchema.ts

@@ -0,0 +1,54 @@
+export function getOptionTypeFromSchema(path: string[], schema: any): SchemaTypeDefinition {
+	const definitions = schema.definitions as any
+
+	let currentObject = definitions
+
+	for (let keyIndex = 0; keyIndex < path.length; keyIndex++) {
+		const isLastKey = keyIndex == path.length - 1
+
+		const key = path[keyIndex]
+
+		currentObject = currentObject[key]
+
+		if (!currentObject) {
+			throw new Error(`'${key}' is not a valid property of '${path.slice(0, keyIndex).join(".")}'.`)
+		}
+
+		if ("$ref" in currentObject) {
+			const refString = currentObject['$ref'] as string
+			const parsedRef = refString.substring(refString.lastIndexOf('/') + 1)
+
+			currentObject = definitions[parsedRef]
+		}
+
+		const currentObjectType = currentObject['type']
+
+		if (isLastKey) {
+			let possibleValues: any[] | undefined = undefined
+
+			if ('enum' in currentObject) {
+				possibleValues = currentObject['enum'] as any[]
+			} else if ('const' in currentObject) {
+				possibleValues = [currentObject['const']]
+			}
+
+			const isUnion = ('anyOf' in currentObject)
+
+			return { type: currentObjectType, enum: possibleValues, isUnion }
+		}
+
+		if (currentObjectType == 'object') {
+			currentObject = currentObject['properties']
+		} else {
+			throw new Error(`Property '${key}' is not an object, but has type ${currentObjectType}`)
+		}
+	}
+
+	return {}
+}
+
+export type SchemaTypeDefinition = {
+	type?: string
+	enum?: any[]
+	isUnion?: boolean
+}

package/src/cli/CLIParser.ts

@@ -0,0 +1,41 @@
+export function parseCLIArguments(command: string, args: string[]): CLIArguments {
+	const parsedArgs: CLIArguments = {
+		command,
+		commandArgs: [],
+		options: new Map(),
+	}
+
+	for (let i = 0; i < args.length; i++) {
+		const currentArg = args[i]
+		const currentArgIsNewOption = currentArg.startsWith("-")
+
+		if (currentArgIsNewOption) {
+			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("=")
+			if (indexOfEquals == 0) {
+				throw new Error("An option cannot have an empty name.")
+			} else if (indexOfEquals == -1) {
+				parsedArgs.options.set(optionText, "")
+			} else {
+				const key = optionText.substring(0, indexOfEquals)
+				const value = optionText.substring(indexOfEquals + 1)
+				parsedArgs.options.set(key, value)
+			}
+		} else {
+			parsedArgs.commandArgs.push(currentArg)
+		}
+	}
+
+	return parsedArgs
+}
+
+export type CLIArguments = {
+	command: string
+	commandArgs: string[]
+	options: Map<string, string>
+}

package/src/cli/CLIStarter.ts

@@ -0,0 +1,40 @@
+import { resolveToModuleRootDir } from '../utilities/FileSystem.js'
+import { setupProgramTerminationListeners, setupUnhandledExceptionListeners, writeToStderr } from '../utilities/Utilities.js'
+import { Worker, SHARE_ENV } from 'node:worker_threads'
+
+setupUnhandledExceptionListeners()
+
+setupProgramTerminationListeners(() => {
+	writeToStderr('\n')
+	process.kill(process.pid, 'SIGKILL')
+})
+
+const worker = new Worker(resolveToModuleRootDir("dist/cli/CLI.js"), {
+	argv: process.argv.slice(2),
+	env: SHARE_ENV
+})
+
+worker.postMessage({
+	name: 'init',
+	stdErrIsTTY: process.stderr.isTTY,
+	stdErrHasColors: process.stderr.hasColors ? process.stderr.hasColors() : false
+})
+
+process.stdin.on('keypress', (str, key) => {
+	worker.postMessage({
+		name: 'keypress',
+		str,
+		key,
+		timestamp: Date.now()
+	})
+})
+
+worker.on("message", (message) => {
+	if (message.name == "writeToStdErr") {
+		writeToStderr(message.text)
+	}
+})
+
+worker.on("exit", (err) => {
+	process.exit(err ? 1 : 0)
+})

package/src/codecs/FFMpegTranscoder.ts

@@ -0,0 +1,214 @@
+import { spawn } from "child_process"
+
+import { encodeWaveBuffer, decodeWaveBuffer, 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"
+
+const log = logToStderr
+
+export type FFMpegOutputOptions = {
+	filename?: string
+	codec?: string
+	format?: string
+	sampleRate?: number
+	sampleFormat?: "u8" | "s16" | "s32" | "s64" | "flt" | "dbl"
+	channelCount?: number
+	bitrate?: number
+	audioOnly?: boolean
+	customOptions?: string[]
+}
+
+export async function encodeFromChannels(rawAudio: RawAudio, outputOptions: FFMpegOutputOptions) {
+	return transcode(encodeWaveBuffer(rawAudio), outputOptions)
+}
+
+export async function decodeToChannels(input: string | Buffer, outSampleRate?: number, outChannelCount?: number) {
+	const outputOptions: FFMpegOutputOptions = {
+		codec: "pcm_f32le",
+		format: "wav",
+		sampleRate: outSampleRate,
+		channelCount: outChannelCount,
+		audioOnly: true
+	}
+
+	const waveAudio = await transcode(input, outputOptions)
+
+	const { rawAudio } = decodeWaveBuffer(waveAudio, true)
+
+	return rawAudio
+}
+
+export async function transcode(input: string | Buffer, outputOptions: FFMpegOutputOptions) {
+	const executablePath = await getFFMpegExecutablePath()
+
+	if (!executablePath) {
+		throw new Error("The ffmpeg utility wasn't found. Please ensure it is available on the system path.")
+	}
+
+	return transcode_CLI(executablePath, input, outputOptions)
+}
+
+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")
+
+		const args = buildCommandLineArguments(Buffer.isBuffer(input) ? "-" : input, outputOptions)
+
+		const process = spawn(ffmpegCommand, args)
+
+		if (Buffer.isBuffer(input)) {
+			process.stdin.end(input)
+		}
+
+		const stdOutChunks: Buffer[] = []
+		let stdErrOutput = ""
+
+		process.stdout.on('data', (data) => {
+			stdOutChunks.push(data)
+		})
+
+		process.stderr.setEncoding("utf8")
+		process.stderr.on('data', (data) => {
+			//log(data)
+			stdErrOutput += data
+		})
+
+		process.on("error", (e) => {
+			reject(e)
+		})
+
+		process.on('close', (exitCode) => {
+			if (exitCode == 0) {
+				resolve(Buffer.concat(stdOutChunks))
+			} else {
+				reject(`ffmpeg exited with code ${exitCode}`)
+				log(stdErrOutput)
+			}
+
+			logger.end()
+		})
+	})
+}
+
+function buildCommandLineArguments(inputFilename: string, outputOptions: FFMpegOutputOptions) {
+	outputOptions = { ...outputOptions }
+
+	if (!outputOptions.filename) {
+		outputOptions.filename = "-"
+	}
+
+	const args: string[] = []
+
+	args.push(
+		`-i`, `${inputFilename}`,
+	)
+
+	if (outputOptions.audioOnly) {
+		args.push(`-map`, `a`)
+	}
+
+	if (outputOptions.codec) {
+		args.push(`-c:a`, `${outputOptions.codec}`)
+	}
+
+	if (outputOptions.format) {
+		args.push(`-f:a`, `${outputOptions.format}`)
+	}
+
+	if (outputOptions.sampleRate) {
+		args.push(`-ar`, `${outputOptions.sampleRate}`)
+	}
+
+	if (outputOptions.sampleFormat) {
+		args.push(`-sample_fmt`, `${outputOptions.sampleFormat}`)
+	}
+
+	if (outputOptions.channelCount) {
+		args.push(`-ac`, `${outputOptions.channelCount}`)
+	}
+
+	if (outputOptions.bitrate) {
+		args.push(`-ab`, `${outputOptions.bitrate}k`)
+	}
+
+	args.push(`-y`)
+
+	if (outputOptions.customOptions) {
+		args.push(...outputOptions.customOptions)
+	}
+
+	args.push(outputOptions.filename)
+
+	return args
+}
+
+async function getFFMpegExecutablePath() {
+	if (process.platform == "win32") {
+		const ffmpegPackagePath = await loadPackage("ffmpeg-6.0-essentials-win64")
+
+		return path.join(ffmpegPackagePath, "ffmpeg.exe")
+	}
+	/* else if (process.platform == "darwin" && process.arch == "x64") {
+		const ffmpegPackagePath = await loadPackage("ffmpeg-6.0-macos64")
+
+		return path.join(ffmpegPackagePath, "ffmpeg")
+	}
+	*/ else if (process.platform == "linux" && process.arch == "x64") {
+		const ffmpegPackagePath = await loadPackage("ffmpeg-6.0-linux-amd64")
+
+		return path.join(ffmpegPackagePath, "ffmpeg")
+	} else if (await commandExists("ffmpeg")) {
+		return "ffmpeg"
+	}
+
+	return undefined
+}
+
+export function getDefaultFFMpegOptionsForSpeech(fileExtension: string, customBitrate?: number) {
+	let ffmpegOptions: FFMpegOutputOptions
+
+	if (fileExtension == "mp3") {
+		ffmpegOptions = {
+			format: "mp3",
+			codec: "libmp3lame",
+			bitrate: 64,
+			customOptions: []
+		}
+	} else if (fileExtension == "opus") {
+		ffmpegOptions = {
+			codec: "libopus",
+			bitrate: 48,
+			customOptions: []
+		}
+	} else if (fileExtension == "m4a") {
+		ffmpegOptions = {
+			format: "mp4",
+			codec: "aac",
+			bitrate: 48,
+			customOptions: ["-profile:a", "aac_low", "-movflags", "frag_keyframe+empty_moov"]
+		}
+	} else if (fileExtension == "ogg") {
+		ffmpegOptions = {
+			codec: "libvorbis",
+			bitrate: 48,
+			customOptions: []
+		}
+	} else if (fileExtension == "flac") {
+		ffmpegOptions = {
+			format: "flac",
+			customOptions: ["-compression_level", "6"]
+		}
+	} else {
+		throw new Error(`Unsupported codec extension: '${fileExtension}'`)
+	}
+
+	if (customBitrate != null) {
+		ffmpegOptions.bitrate = customBitrate
+	}
+
+	return ffmpegOptions
+}

package/src/codecs/TIMITCodec.ts

@@ -0,0 +1,17 @@
+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")
+	}
+
+	const pcm = data.subarray(1024)
+
+	return { audioChannels: decodeToChannels(pcm, 1, 16, SampleFormat.PCM), sampleRate: 16000 }
+}