echogarden 1.8.7 → 2.0.0

package/src/encodings/Utf32.ts

@@ -0,0 +1,62 @@
+import { EncodeIntoResult } from "./TextEncodingsCommon.js"
+
+export function encodeUtf32(text: string) {
+	const resultArray = new Uint32Array(text.length * 2)
+
+	const { written } = encodeUtf32Into(text, resultArray)
+
+	return resultArray.subarray(0, written)
+}
+
+export function encodeUtf32Into(text: string, resultBuffer: Uint32Array): EncodeIntoResult {
+	const len = text.length
+
+	let readOffset = 0
+	let writeOffset = 0
+
+	while (readOffset < len && writeOffset < resultBuffer.length) {
+		const codepoint = text.codePointAt(readOffset)
+
+		if (codepoint === undefined) {
+			throw new Error(`Couldn't read a codepoint at offset ${readOffset}`)
+		}
+
+		resultBuffer[writeOffset++] = codepoint
+
+		if (codepoint > 0xffff) {
+			readOffset += 2
+		} else {
+			readOffset += 1
+		}
+	}
+
+	return { read: readOffset, written: writeOffset }
+}
+
+export function decodeUtf32(encodedString: Uint32Array) {
+	const maxChunkLength = 2 ** 10
+
+	const decoder = new ChunkedUtf32Decoder()
+
+	for (let offset = 0; offset < encodedString.length; offset += maxChunkLength) {
+		const chunk = encodedString.subarray(offset, offset + maxChunkLength)
+
+		decoder.writeChunk(chunk)
+	}
+
+	return decoder.toString()
+}
+
+export class ChunkedUtf32Decoder {
+	private str = ''
+
+	writeChunk(chunk: Uint32Array) {
+		const decodedChunk = String.fromCodePoint(...chunk)
+
+		this.str += decodedChunk
+	}
+
+	toString() {
+		return this.str
+	}
+}

package/src/encodings/Utf8.ts

@@ -0,0 +1,117 @@
+import { EncodeIntoResult } from "./TextEncodingsCommon.js"
+
+export function encodeUtf8(text: string) {
+	const textEncoder = new TextEncoder()
+
+	return textEncoder.encode(text)
+}
+
+export function encodeUtf8Into(text: string, outputArray: Uint8Array): EncodeIntoResult {
+	const textEncoder = new TextEncoder()
+
+	const result = textEncoder.encodeInto(text, outputArray)
+
+	return result
+}
+
+export function decodeUtf8(encodedString: Uint8Array) {
+	const maxChunkLength = 2 ** 24
+
+	const decoder = new ChunkedUtf8Decoder()
+
+	for (let offset = 0; offset < encodedString.length; offset += maxChunkLength) {
+		const chunk = encodedString.subarray(offset, offset + maxChunkLength)
+
+		decoder.writeChunk(chunk)
+	}
+
+	return decoder.toString()
+}
+
+export class ChunkedUtf8Decoder {
+	private str = ''
+	private readonly textDecoder = new TextDecoder('utf-8')
+
+	writeChunk(chunk: Uint8Array) {
+		const decodedChunk = this.textDecoder.decode(chunk)
+
+		this.str += decodedChunk
+	}
+
+	toString() {
+		return this.str
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Pure JavaScript implementations
+//////////////////////////////////////////////////////////////////////////////////////////////
+function encodeUtf8Into_JS(str: string, outputArray: Uint8Array): EncodeIntoResult {
+	let readOffset = 0
+	let writeOffset = 0
+
+	while (readOffset < str.length) {
+		const charCode = str.codePointAt(readOffset++)!
+
+		if (charCode <= 0x7f) {
+			outputArray[writeOffset++] = charCode
+		} else if (charCode <= 0x7ff) {
+			outputArray[writeOffset++] = 0xc0 | (charCode >>> 6)
+			outputArray[writeOffset++] = 0x80 | (charCode & 63)
+		} else if (charCode <= 0xffff) {
+			outputArray[writeOffset++] = 0xe0 | (charCode >>> 12)
+			outputArray[writeOffset++] = 0x80 | ((charCode >>> 6) & 63)
+			outputArray[writeOffset++] = 0x80 | (charCode & 63)
+		} else if (charCode <= 0x10ffff) {
+			outputArray[writeOffset++] = 0xf0 | (charCode >>> 18)
+			outputArray[writeOffset++] = 0x80 | ((charCode >>> 12) & 63)
+			outputArray[writeOffset++] = 0x80 | ((charCode >>> 6) & 63)
+			outputArray[writeOffset++] = 0x80 | (charCode & 63)
+
+			readOffset++
+		}
+	}
+
+	return { read: str.length, written: writeOffset }
+}
+
+function decodeUtf8_JS(utf8Bytes: Uint8Array): string {
+	let decodedString = ''
+
+	let readOffset = 0
+
+	while (readOffset < utf8Bytes.length) {
+		const leadByte = utf8Bytes[readOffset++]
+
+		let outputCodePoint: number
+
+		if (leadByte >>> 7 === 0) {
+			outputCodePoint = leadByte
+		} else if (leadByte >>> 5 === 6) {
+			outputCodePoint =
+				(leadByte & 31) << 6 |
+				(utf8Bytes[readOffset++] & 63)
+		} else if (leadByte >>> 4 === 14) {
+			outputCodePoint =
+				(leadByte & 15) << 12 |
+				(utf8Bytes[readOffset++] & 63) << 6 |
+				(utf8Bytes[readOffset++] & 63)
+		} else if (leadByte >>> 3 === 30) {
+			outputCodePoint =
+				(leadByte & 7) << 18 |
+				(utf8Bytes[readOffset++] & 63) << 12 |
+				(utf8Bytes[readOffset++] & 63) << 6 |
+				(utf8Bytes[readOffset++] & 63)
+		} else {
+			throw new Error(`Invalid UTF-8 stream: An invalid lead byte value encountered at position ${readOffset}`)
+		}
+
+		decodedString += String.fromCodePoint(outputCodePoint)
+	}
+
+	if (readOffset > utf8Bytes.length) {
+		throw new Error(`UTF-8 decoding failed. Byte sequence is truncated.`)
+	}
+
+	return decodedString
+}

package/src/math/MedianFilter.ts

@@ -1,5 +1,3 @@
-import { createVector } from "./VectorMath.js"
-
 export function medianOf5Filter(points: ArrayLike<number>): Float32Array {
 	// This function computes the moving median with a window of 5 elements.
 

package/src/nlp/JapaneseSegmentation.ts

@@ -1,5 +1,5 @@
-import path from 'path'
 import { OpenPromise } from '../utilities/OpenPromise.js'
+import { getDirName, joinPath } from '../utilities/PathUtilities.js'
 import { resolveModuleScriptPath } from '../utilities/Utilities.js'
 
 export async function splitJapaneseTextToWords_Kuromoji(text: string) {
@@ -23,7 +23,7 @@ async function getKuromojiTokenizer() {
 	const resultOpenPromise = new OpenPromise<any>()
 
 	const kuromojiScriptPath = await resolveModuleScriptPath('kuromoji')
-	const dictionaryPath = path.join(path.dirname(kuromojiScriptPath), '..', '/dict')
+	const dictionaryPath = joinPath(getDirName(kuromojiScriptPath), '..', '/dict')
 
 	kuromoji.builder({ dicPath: dictionaryPath }).build(function (error: any, tokenizer: any) {
 		if (error) {

package/src/recognition/GoogleCloudSTT.ts

@@ -4,6 +4,7 @@ import * as FFMpegTranscoder from '../codecs/FFMpegTranscoder.js'
 import { Logger } from '../utilities/Logger.js'
 import { Timeline } from '../utilities/Timeline.js'
 import { RawAudio } from '../audio/AudioUtilities.js'
+import { encodeBase64 } from '../encodings/Base64.js'
 
 export type AudioEncoding = 'LINEAR16' | 'FLAC' | 'MULAW' | 'AMR' | 'AMR' | 'AMR_WB' | 'OGG_OPUS' | 'SPEEX_WITH_HEADER_BYTE' | 'MP3' | 'WEBM_OPUS'
 
@@ -30,7 +31,7 @@ export async function recognize(rawAudio: RawAudio, apiKey: string, languageCode
 		},
 
 		audio: {
-			content: flac16Khz16bitMonoAudio.toString('base64')
+			content: encodeBase64(flac16Khz16bitMonoAudio)
 		}
 	}
 

package/src/recognition/SileroSTT.ts

@@ -5,10 +5,10 @@ import { logToStderr } from '../utilities/Utilities.js'
 import { Timeline } from '../utilities/Timeline.js'
 import { RawAudio, getRawAudioDuration } from '../audio/AudioUtilities.js'
 import { readAndParseJsonFile } from '../utilities/FileSystem.js'
-import path from 'path'
 
 import type * as Onnx from 'onnxruntime-node'
 import { OnnxExecutionProvider, getOnnxSessionOptions } from '../utilities/OnnxUtilities.js'
+import { joinPath } from '../utilities/PathUtilities.js'
 
 const log = logToStderr
 
@@ -87,8 +87,8 @@ export class SileroSTT {
 
 		const Onnx = await import('onnxruntime-node')
 
-		const modelPath = path.join(this.modelDirectoryPath, 'model.onnx')
-		const labelsPath = path.join(this.modelDirectoryPath, 'labels.json')
+		const modelPath = joinPath(this.modelDirectoryPath, 'model.onnx')
+		const labelsPath = joinPath(this.modelDirectoryPath, 'labels.json')
 
 		this.labels = await readAndParseJsonFile(labelsPath)
 

package/src/recognition/VoskSTT.ts

@@ -1,7 +1,7 @@
 import * as FFMpegTranscoder from '../codecs/FFMpegTranscoder.js'
 import * as AudioBufferConversion from '../audio/AudioBufferConversion.js'
 import { Logger } from '../utilities/Logger.js'
-import { concatBuffers, logToStderr } from '../utilities/Utilities.js'
+import { concatUint8Arrays, logToStderr } from '../utilities/Utilities.js'
 import { Timeline } from '../utilities/Timeline.js'
 import { RawAudio } from '../audio/AudioUtilities.js'
 
@@ -36,8 +36,8 @@ export async function recognize(rawAudio: RawAudio, modelPath: string, verbose =
 	const recognitionStartTimestamp = logger.getTimestamp()
 
 	const pcmAudio = AudioBufferConversion.encodeToAudioBuffer(audioChannels, 16)
-	const trailingSilence = Buffer.alloc(sampleRate * 4)
-	const pcmAudioWithTrailingSilence = concatBuffers([pcmAudio, trailingSilence])
+	const trailingSilence = new Uint8Array(sampleRate * 4)
+	const pcmAudioWithTrailingSilence = concatUint8Arrays([pcmAudio, trailingSilence])
 	const pcmAudioByteCount = pcmAudioWithTrailingSilence.length
 
 	const maxChunkSize = sampleRate * 2.0

package/src/recognition/WhisperCppSTT.ts

@@ -5,9 +5,8 @@ import { type WhisperTask, type WhisperModelName } from './WhisperSTT.js'
 import { getRandomHexString } from '../utilities/Utilities.js'
 import { Timeline, TimelineEntryType } from '../utilities/Timeline.js'
 import { tryParseTimeRangePatternWithHours } from '../subtitles/Subtitles.js'
-import { getAppTempDir } from '../utilities/PathUtilities.js'
+import { getAppTempDir, joinPath } from '../utilities/PathUtilities.js'
 import { appName } from '../api/Common.js'
-import path from 'node:path'
 import { readAndParseJsonFile, remove } from '../utilities/FileSystem.js'
 import { splitToLines } from '../nlp/Segmentation.js'
 import { extendDeep } from '../utilities/ObjectUtilities.js'
@@ -78,7 +77,7 @@ export async function recognize(
 		const sourceAsWave = encodeRawAudioToWave(sourceRawAudio)
 
 		const tempDirPath = getAppTempDir(appName)
-		const outJsonFilePathWithoutExtension = path.join(tempDirPath, `${getRandomHexString(16)}`)
+		const outJsonFilePathWithoutExtension = joinPath(tempDirPath, `${getRandomHexString(16)}`)
 		const outJsonFilePath = `${outJsonFilePathWithoutExtension}.json`
 
 		const args: string[] = [
@@ -396,7 +395,7 @@ export async function loadModelPackage(modelId: WhisperCppModelId | undefined, l
 
 	const packageName = `whisper.cpp-${modelId}`
 	const modelDir = await loadPackage(packageName)
-	const modelPath = path.join(modelDir, `ggml-${modelId}.bin`)
+	const modelPath = joinPath(modelDir, `ggml-${modelId}.bin`)
 	const modelName = getModelNameFromModelId(modelId)
 
 	return { modelName, modelPath }
@@ -440,7 +439,7 @@ export async function loadExecutablePackage(buildKind: WhisperCppBuild) {
 		filename += '.exe'
 	}
 
-	return path.join(packagePath, filename)
+	return joinPath(packagePath, filename)
 }
 
 function getModelNameFromModelId(modelId: WhisperCppModelId): WhisperModelName {

package/src/recognition/WhisperSTT.ts

@@ -10,8 +10,7 @@ import { extendDeep } from '../utilities/ObjectUtilities.js'
 import { Timeline, TimelineEntry } from '../utilities/Timeline.js'
 import { AlignmentPath } from '../alignment/SpeechAlignment.js'
 import { getRawAudioDuration, RawAudio, sliceRawAudio } from '../audio/AudioUtilities.js'
-import { readFile } from '../utilities/FileSystem.js'
-import path from 'path'
+import { readFileAsUtf8 } from '../utilities/FileSystem.js'
 import type { LanguageDetectionResults } from '../api/API.js'
 import { formatLanguageCodeWithName, getShortLanguageCode, languageCodeToName } from '../utilities/Locale.js'
 import { loadPackage } from '../utilities/PackageManager.js'
@@ -25,6 +24,8 @@ import { getDeflateCompressionMetricsForString } from '../utilities/Compression.
 import { dmlProviderAvailable, getOnnxSessionOptions, makeOnnxLikeFloat32Tensor, OnnxExecutionProvider, OnnxLikeFloat32Tensor } from '../utilities/OnnxUtilities.js'
 import { murmurHash3_int32Input } from '../utilities/Hashing.js'
 import { containsInvalidCodepoint, getTokenRepetitionScore } from '../utilities/StringUtilities.js'
+import { decodeUtf8 } from '../encodings/Utf8.js'
+import { joinPath } from '../utilities/PathUtilities.js'
 
 export async function recognize(
 	sourceRawAudio: RawAudio,
@@ -1538,8 +1539,8 @@ export class Whisper {
 
 		const tiktokenModulePackagePath = await loadPackage('whisper-tiktoken-data')
 
-		const tiktokenDataFilePath = path.join(tiktokenModulePackagePath, this.isMultiligualModel ? 'multilingual.tiktoken' : 'gpt2.tiktoken')
-		let tiktokenData = await readFile(tiktokenDataFilePath, { encoding: 'utf8' })
+		const tiktokenDataFilePath = joinPath(tiktokenModulePackagePath, this.isMultiligualModel ? 'multilingual.tiktoken' : 'gpt2.tiktoken')
+		let tiktokenData = await readFileAsUtf8(tiktokenDataFilePath)
 
 		const tokenConfig = this.tokenConfig
 
@@ -1603,7 +1604,7 @@ export class Whisper {
 
 		await logger.startAsync(`Create encoder inference session for model '${this.modelName}' (ONNX provider: ${onnxProvidersString})`)
 
-		const encoderFilePath = path.join(this.modelDir, 'encoder.onnx')
+		const encoderFilePath = joinPath(this.modelDir, 'encoder.onnx')
 
 		const Onnx = await import('onnxruntime-node')
 
@@ -1625,7 +1626,7 @@ export class Whisper {
 
 		await logger.startAsync(`Create decoder inference session for model '${this.modelName}' (ONNX provider: ${onnxProvidersString})`)
 
-		const decoderFilePath = path.join(this.modelDir, 'decoder.onnx')
+		const decoderFilePath = joinPath(this.modelDir, 'decoder.onnx')
 
 		const Onnx = await import('onnxruntime-node')
 
@@ -1689,7 +1690,7 @@ export class Whisper {
 		}
 
 		try {
-			return Buffer.from(this.tiktoken!.decode(new Uint32Array(tokens))).toString('utf8')
+			return decodeUtf8(this.tiktoken!.decode(new Uint32Array(tokens)))
 		} catch {
 			return '[TOKENIZER_FAILED]'
 		}

package/src/server/Client.ts

@@ -11,6 +11,7 @@ import { SpeechTranslationOptions, SpeechTranslationResult } from '../api/Speech
 import { Worker as WorkerThread } from 'node:worker_threads'
 import { SpeechLanguageDetectionOptions, SpeechLanguageDetectionResult } from '../api/SpeechLanguageDetection.js'
 import { TextLanguageDetectionOptions, TextLanguageDetectionResult } from '../api/TextLanguageDetection.js'
+import { decodeUtf8 } from '../encodings/Utf8.js'
 
 const log = logToStderr
 
@@ -23,14 +24,14 @@ export class Client {
 		if (sourceChannel instanceof WebSocket) {
 			sourceChannel.on('message', (messageData, isBinary) => {
 				if (!isBinary) {
-					log(`Received an unexpected string WebSocket message: '${(messageData as Buffer).toString('utf-8')}'`)
+					log(`Received an unexpected string WebSocket message: '${decodeUtf8(messageData as Uint8Array)}'`)
 					return
 				}
 
 				let incomingMessage: any
 
 				try {
-					incomingMessage = decodeMsgPack(messageData as Buffer)
+					incomingMessage = decodeMsgPack(messageData as Uint8Array)
 				} catch (e) {
 					log(`Failed to decode incoming message. Reason: ${e}`)
 					return
@@ -176,7 +177,7 @@ export class Client {
 		return requestOpenPromise.promise
 	}
 
-	async translateSpeech(input: string | Buffer | Uint8Array |RawAudio, options: SpeechTranslationOptions): Promise<SpeechTranslationResult> {
+	async translateSpeech(input: string | Uint8Array | RawAudio, options: SpeechTranslationOptions): Promise<SpeechTranslationResult> {
 		const requestOpenPromise = new OpenPromise<SpeechTranslationResult>()
 
 		const requestMessage: SpeechTranslationRequestMessage = {

package/src/server/Server.ts

@@ -2,13 +2,14 @@ import { WebSocketServer, WebSocket, ServerOptions as WsServerOptions } from 'ws
 import { encode as encodeMsgPack, decode as decodeMsgPack } from 'msgpack-lite'
 import { logToStderr } from '../utilities/Utilities.js'
 import { OpenPromise } from '../utilities/OpenPromise.js'
-import { readFile, existsSync } from '../utilities/FileSystem.js'
+import { existsSync, readFileAsBinary } from '../utilities/FileSystem.js'
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 import { sendMessageToWorker, addListenerToWorkerMessages, startNewWorkerThread, startMessageChannel } from './Worker.js'
 import { Worker } from 'node:worker_threads'
 import { IncomingMessage, ServerResponse } from 'node:http'
 import chalk from 'chalk'
 import { Logger } from '../utilities/Logger.js'
+import { decodeUtf8 } from '../encodings/Utf8.js'
 
 const log = logToStderr
 
@@ -37,8 +38,8 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 		const { createServer } = await import('https')
 
 		const httpsServer = createServer({
-			cert: await readFile(serverOptions.certPath!),
-			key: await readFile(serverOptions.keyPath!)
+			cert: Buffer.from(await readFileAsBinary(serverOptions.certPath!)),
+			key: Buffer.from(await readFileAsBinary(serverOptions.keyPath!))
 		}, onHttpRequest)
 
 		httpsServer.listen(serverOptions.port!)
@@ -107,14 +108,14 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 
 		ws.on('message', (messageData, isBinary) => {
 			if (!isBinary) {
-				log(chalk.gray(`Received an unexpected string WebSocket message: '${(messageData as Buffer).toString('utf-8')}'`))
+				log(chalk.gray(`Received an unexpected string WebSocket message: '${decodeUtf8(messageData as Uint8Array)}'`))
 				return
 			}
 
 			let incomingMessage: any
 
 			try {
-				incomingMessage = decodeMsgPack(messageData as Buffer)
+				incomingMessage = decodeMsgPack(messageData as Uint8Array)
 			} catch (e) {
 				log(chalk.gray(`Failed to decode binary WebSocket message. Reason: ${e}`))
 				return

package/src/server/Worker.ts

@@ -1,5 +1,5 @@
 import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentEventData, SynthesisResult, VoiceListRequestOptions, requestVoiceList, synthesize } from '../api/Synthesis.js'
-import { Queue } from '../utilities/Queue.js'
+import { Queue } from '../data-structures/Queue.js'
 import { logToStderr, yieldToEventLoop } from '../utilities/Utilities.js'
 import { AudioSourceParam } from '../audio/AudioUtilities.js'
 import { RecognitionOptions, RecognitionResult, recognize } from '../api/Recognition.js'

package/src/source-separation/MDXNetSourceSeparation.ts

@@ -5,7 +5,7 @@ import { logToStderr } from '../utilities/Utilities.js'
 import { Logger } from '../utilities/Logger.js'
 import { OnnxExecutionProvider, dmlProviderAvailable, getOnnxSessionOptions } from '../utilities/OnnxUtilities.js'
 import chalk from 'chalk'
-import { WindowedList } from '../utilities/WindowedList.js'
+import { WindowedList } from '../data-structures/WindowedList.js'
 import { logLevelGreaterOrEqualTo } from '../api/API.js'
 
 const log = logToStderr

package/src/speech-search/DTWSpeechSearch.ts

@@ -1,28 +1,57 @@
 import { DtwGranularity, getMfccOptionsForGranularity } from "../alignment/SpeechAlignment.js";
 import { RawAudio } from "../audio/AudioUtilities.js";
 import { computeMFCCs, extendDefaultMfccOptions, MfccOptions } from "../dsp/MFCC.js";
+import { euclideanDistance13Dim } from "../math/VectorMath.js";
 import { Logger } from "../utilities/Logger.js";
 
-export async function searchSpeech(sourceRawAudio: RawAudio, referenceRawAudio: RawAudio) {
+export async function searchSpeech(sourceRawAudio: RawAudio, queryRawAudio: RawAudio) {
 	const logger = new Logger()
 
 	const granularity: DtwGranularity = 'low'
 
 	const mfccOptions = extendDefaultMfccOptions({ ...getMfccOptionsForGranularity(granularity), zeroFirstCoefficient: true }) as MfccOptions
 
-	// Compute reference MFCCs
-	logger.start('Compute reference MFCC features')
-	const referenceMfccs = await computeMFCCs(referenceRawAudio, mfccOptions)
+	logger.start('Compute query MFCC features')
+	const queryMfccs = await computeMFCCs(queryRawAudio, mfccOptions)
 
-	// Compute source MFCCs
 	logger.start('Compute source MFCC features')
 	const sourceMfccs = await computeMFCCs(sourceRawAudio, mfccOptions)
 
 	logger.start('Compute cost matrix')
 
-	
+	const costMatrixColumns = computeCostMatrix(sourceMfccs, queryMfccs, euclideanDistance13Dim)
+
+	logger.start('Search')
+
+	const rowCount = sourceMfccs.length
+	const columnCount = queryMfccs.length
+
+	const maxSearchWindow = columnCount * 2
+
+	for (let rowStartOffset = 0; rowStartOffset < rowCount; rowStartOffset++) {
+		const rowEndOffset = Math.min(rowStartOffset + maxSearchWindow, rowCount)
+
+		
+	}
 }
 
-function computeCostMatrix<T, U>(sequence1: T[], sequence2: U[]) {
+function computeCostMatrix<T, U>(sequence1: T[], sequence2: U[], costFunction: (a: T, b: U) => number) {
+	const rowCount = sequence1.length
+	const columnCount = sequence2.length
+
+	const costMatrixColumns: Float32Array[] = []
+
+	for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+		const column = new Float32Array(rowCount)
+
+		for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+			const cost = costFunction(sequence1[rowIndex], sequence2[columnIndex])
+
+			column[columnIndex] = cost
+		}
+
+		costMatrixColumns.push(column)
+	}
 
+	return costMatrixColumns
 }

package/src/subtitles/Subtitles.ts

@@ -1,15 +1,15 @@
 import { htmlToText } from 'html-to-text'
 
 import { secondsToHMS, secondsToMS } from '../utilities/Utilities.js'
-import { isWord, isWordOrSymbolWord } from '../nlp/Segmentation.js'
+import { isWordOrSymbolWord } from '../nlp/Segmentation.js'
 import { charactersToWriteAhead } from '../audio/AudioPlayer.js'
 import { Timeline, TimelineEntry } from '../utilities/Timeline.js'
-import { readFile } from '../utilities/FileSystem.js'
+import { readFileAsUtf8 } from '../utilities/FileSystem.js'
 import { deepClone } from '../utilities/ObjectUtilities.js'
 import { formatHMS, formatMS, startsWithAnyOf } from '../utilities/StringUtilities.js'
 
 export async function subtitlesFileToText(filename: string) {
-	return subtitlesToText(await readFile(filename, 'utf8'))
+	return subtitlesToText(await readFileAsUtf8(filename))
 }
 
 export function subtitlesToText(subtitles: string) {

package/src/synthesis/AzureCognitiveServicesTTS.ts

@@ -7,6 +7,7 @@ import { escape } from 'html-escaper'
 import { Logger } from '../utilities/Logger.js'
 import { Timeline } from '../utilities/Timeline.js'
 import { RawAudio, getRawAudioDuration } from '../audio/AudioUtilities.js'
+import { concatUint8Arrays } from '../utilities/Utilities.js'
 
 export async function synthesize(
 	text: string,
@@ -46,27 +47,29 @@ export async function synthesize(
 				return
 			}
 
-			/*
-			const bufferSize = 2 ** 16
-			const buffers: Buffer[] = []
+			let encodedAudio: Uint8Array
 
-			while (true) {
+			if (false) {
+				const bufferSize = 2 ** 16
+				const buffers: Uint8Array[] = []
 
-				const buffer = Buffer.alloc(bufferSize)
-				const amountRead = await audioOutputStream.read(buffer)
+				while (true) {
 
-				if (amountRead == 0) {
-					audioOutputStream.close()
-					break
-				}
+					const buffer = new Uint8Array(bufferSize)
+					const amountRead = await audioOutputStream.read(buffer)
 
-				buffers.push(buffer.subarray(0, amountRead))
-			}
+					if (amountRead == 0) {
+						audioOutputStream.close()
+						break
+					}
 
-			const encodedAudio = concatBuffers(buffers)
-			*/
+					buffers.push(buffer.subarray(0, amountRead))
+				}
 
-			const encodedAudio = Buffer.from(result.audioData)
+				encodedAudio = concatUint8Arrays(buffers)
+			} else {
+				encodedAudio = new Uint8Array(result.audioData)
+			}
 
 			logger.end()
 

package/src/synthesis/CoquiServerTTS.ts

@@ -8,7 +8,7 @@ export async function synthesize(text: string, speakerId: string | null, serverU
 	const logger = new Logger()
 	logger.start('Request synthesis from Coqui Server')
 
-	const response = await request<Buffer>({
+	const response = await request<Uint8Array>({
 		url: `${serverURL}/api/tts`,
 
 		params: {
@@ -19,7 +19,7 @@ export async function synthesize(text: string, speakerId: string | null, serverU
 		responseType: 'arraybuffer'
 	})
 
-	const waveData = Buffer.from(response.data)
+	const waveData = new Uint8Array(response.data)
 
 	const { rawAudio } = decodeWaveToRawAudio(waveData)
 

package/src/synthesis/ElevenlabsTTS.ts

@@ -57,7 +57,7 @@ export async function synthesize(text: string, voiceId: string, modelId: string,
 	}
 
 	logger.start('Decode synthesized audio')
-	const rawAudio = await FFMpegTranscoder.decodeToChannels(Buffer.from(response.data))
+	const rawAudio = await FFMpegTranscoder.decodeToChannels(new Uint8Array(response.data))
 
 	logger.end()
 

package/src/synthesis/EspeakTTS.ts

@@ -3,7 +3,6 @@ import { int16PcmToFloat32 } from '../audio/AudioBufferConversion.js'
 import { Logger } from '../utilities/Logger.js'
 import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
 import { RawAudio, getEmptyRawAudio } from '../audio/AudioUtilities.js'
-import { playAudioWithTimelinePhones } from '../audio/AudioPlayer.js'
 import { getNormalizedFragmentsForSpeech, simplifyPunctuationCharacters } from '../nlp/TextNormalizer.js'
 import { ipaPhoneToKirshenbaum } from '../nlp/PhoneConversion.js'
 import { splitToWords, wordCharacterPattern } from '../nlp/Segmentation.js'
@@ -599,20 +598,6 @@ export const defaultEspeakOptions: EspeakOptions = {
 	insertSeparators: false
 }
 
-export async function testEspeakSynthesisWithPrePhonemizedInputs(text: string) {
-	const ipaPhonemizedSentence = (await phonemizeSentence(text, 'en-us')).flatMap(clause => clause)
-	const kirshenbaumPhonemizedSentence = (await phonemizeSentence(text, 'en-us', undefined, false)).flatMap(clause => clause)
-	log(kirshenbaumPhonemizedSentence)
-
-	const fragments = ipaPhonemizedSentence.map(word =>
-		word.map(phoneme =>
-			ipaPhoneToKirshenbaum(phoneme)).join('')).map(word => ` [[${word}]] `)
-
-	const { rawAudio, timeline } = await synthesizeFragments(fragments, defaultEspeakOptions)
-
-	await playAudioWithTimelinePhones(rawAudio, timeline)
-}
-
 export async function testKirshenbaumPhonemization(text: string) {
 	const ipaPhonemizedSentence = (await phonemizeSentence(text, 'en-us')).flatMap(clause => clause)
 	const kirshenbaumPhonemizedSentence = (await phonemizeSentence(text, 'en-us', undefined, false)).flatMap(clause => clause)