echogarden 1.3.1 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "echogarden",
-	"version": "1.3.1",
+	"version": "1.3.3",
 	"description": "An easy-to-use speech toolset. Includes tools for synthesis, recognition, alignment, speech translation, language detection, source separation and more.",
 	"author": "Rotem Dan",
 	"license": "GPL-3.0",
@@ -55,8 +55,8 @@
 		"echogarden": "./dist/cli/CLILauncher.js"
 	},
 	"dependencies": {
-		"@aws-sdk/client-polly": "^3.569.0",
-		"@aws-sdk/client-transcribe-streaming": "^3.569.0",
+		"@aws-sdk/client-polly": "^3.572.0",
+		"@aws-sdk/client-transcribe-streaming": "^3.572.0",
 		"@echogarden/espeak-ng-emscripten": "^0.1.2",
 		"@echogarden/fasttext-wasm": "^0.1.0",
 		"@echogarden/flite-wasi": "^0.1.1",
@@ -89,7 +89,7 @@
 		"moving-median": "^1.0.0",
 		"msgpack-lite": "^0.1.26",
 		"onnxruntime-node": "^1.17.3",
-		"openai": "^4.42.0",
+		"openai": "^4.43.0",
 		"sam-js": "^0.2.1",
 		"strip-ansi": "^7.1.0",
 		"tar": "^7.1.0",
@@ -120,11 +120,11 @@
 		"@types/graceful-fs": "^4.1.9",
 		"@types/jsdom": "^21.1.6",
 		"@types/msgpack-lite": "^0.1.11",
-		"@types/node": "^20.12.10",
+		"@types/node": "^20.12.11",
 		"@types/recursive-readdir": "^2.2.4",
 		"@types/tar": "^6.1.13",
 		"@types/ws": "^8.5.10",
-		"ts-json-schema-generator": "^2.1.1",
+		"ts-json-schema-generator": "^2.1.2-next.1",
 		"typescript": "^5.4.5"
 	}
 }

package/src/api/LanguageDetection.ts

@@ -158,7 +158,7 @@ export async function detectSpeechLanguageByParts(sourceRawAudio: RawAudio, getR
 		const endOffset = Math.min(audioTimeOffset + audioPartDuration, audioDuration)
 		const audioPartLength = endOffset - startOffset
 
-		logger.logTitledMessage(`\nDetecting speech language starting at audio offset`, `${startOffset.toFixed(1)}`, chalk.magentaBright)
+		logger.logTitledMessage(`\nDetect speech language starting at audio offset`, `${startOffset.toFixed(1)}`, chalk.magentaBright)
 		const audioPart = sliceRawAudioByTime(sourceRawAudio, startOffset, endOffset)
 
 		const resultsForPart = await getResultsForAudioPart(audioPart)

package/src/api/Recognition.ts

@@ -72,7 +72,7 @@ export async function recognize(input: AudioSourceParam, options: RecognitionOpt
 		logger.end()
 		logger.logTitledMessage('Language specified', formatLanguageCodeWithName(options.language))
 	} else {
-		logger.start('No language specified. Detecting speech language')
+		logger.start('No language specified. Detect speech language')
 		const { detectedLanguage } = await API.detectSpeechLanguage(sourceRawAudio, options.languageDetection!)
 
 		options.language = detectedLanguage

package/src/api/Translation.ts

@@ -72,7 +72,7 @@ export async function translateSpeech(input: AudioSourceParam, options: SpeechTr
 		logger.end()
 		logger.logTitledMessage('Source language specified', formatLanguageCodeWithName(options.sourceLanguage))
 	} else {
-		logger.start('No source language specified. Detecting speech language')
+		logger.start('No source language specified. Detect speech language')
 		const { detectedLanguage } = await detectSpeechLanguage(sourceRawAudio, options.languageDetection || {})
 
 		options.sourceLanguage = detectedLanguage

package/src/api/TranslationAlignment.ts

@@ -68,7 +68,7 @@ export async function alignTranslation(input: AudioSourceParam, transcript: stri
 		logger.end()
 		logger.logTitledMessage('Source language specified', formatLanguageCodeWithName(sourceLanguage))
 	} else {
-		logger.start('No source language specified. Detecting speech language')
+		logger.start('No source language specified. Detect speech language')
 		const { detectedLanguage } = await API.detectSpeechLanguage(sourceRawAudio, options.languageDetection || {})
 
 		sourceLanguage = detectedLanguage

package/src/audio/AudioBufferConversion.ts

@@ -8,34 +8,36 @@ import { BitDepth, SampleFormat } from '../codecs/WaveCodec.js'
 export function encodeToAudioBuffer(audioChannels: Float32Array[], targetBitDepth: BitDepth = 16, targetSampleFormat: SampleFormat = SampleFormat.PCM) {
 	const interleavedChannels = interleaveChannels(audioChannels)
 
-	if (targetSampleFormat == SampleFormat.PCM) {
-		if (targetBitDepth == 8) {
-			return Buffer.from(float32ToUint8Pcm(interleavedChannels).buffer)
-		} else if (targetBitDepth == 16) {
+	audioChannels = [] // Zero the array references to allow the GC to free up memory, if possible
+
+	if (targetSampleFormat === SampleFormat.PCM) {
+		if (targetBitDepth === 8) {
+			return BinaryArrayConversion.int8ToBuffer(float32ToInt8Pcm(interleavedChannels))
+		} else if (targetBitDepth === 16) {
 			return BinaryArrayConversion.int16ToBufferLE(float32ToInt16Pcm(interleavedChannels))
-		} else if (targetBitDepth == 24) {
+		} else if (targetBitDepth === 24) {
 			return BinaryArrayConversion.int24ToBufferLE(float32ToInt24Pcm(interleavedChannels))
-		} else if (targetBitDepth == 32) {
+		} else if (targetBitDepth === 32) {
 			return BinaryArrayConversion.int32ToBufferLE(float32ToInt32Pcm(interleavedChannels))
 		} else {
 			throw new Error(`Unsupported PCM bit depth: ${targetBitDepth}`)
 		}
-	} else if (targetSampleFormat == SampleFormat.Float) {
-		if (targetBitDepth == 32) {
+	} else if (targetSampleFormat === SampleFormat.Float) {
+		if (targetBitDepth === 32) {
 			return BinaryArrayConversion.float32ToBufferLE(interleavedChannels)
-		} else if (targetBitDepth == 64) {
+		} else if (targetBitDepth === 64) {
 			return BinaryArrayConversion.float64ToBufferLE(BinaryArrayConversion.float32Tofloat64(interleavedChannels))
 		} else {
 			throw new Error(`Unsupported float bit depth: ${targetBitDepth}`)
 		}
-	} else if (targetSampleFormat == SampleFormat.Alaw) {
-		if (targetBitDepth == 8) {
+	} else if (targetSampleFormat === SampleFormat.Alaw) {
+		if (targetBitDepth === 8) {
 			return Buffer.from(AlawMulaw.alaw.encode(float32ToInt16Pcm(interleavedChannels)))
 		} else {
 			throw new Error(`Unsupported alaw bit depth: ${targetBitDepth}`)
 		}
-	} else if (targetSampleFormat == SampleFormat.Mulaw) {
-		if (targetBitDepth == 8) {
+	} else if (targetSampleFormat === SampleFormat.Mulaw) {
+		if (targetBitDepth === 8) {
 			return Buffer.from(AlawMulaw.mulaw.encode(float32ToInt16Pcm(interleavedChannels)))
 		} else {
 			throw new Error(`Unsupported mulaw bit depth: ${targetBitDepth}`)
@@ -48,34 +50,34 @@ export function encodeToAudioBuffer(audioChannels: Float32Array[], targetBitDept
 export function decodeToChannels(audioBuffer: Buffer, channelCount: number, sourceBitDepth: number, sourceSampleFormat: SampleFormat) {
 	let interleavedChannels: Float32Array
 
-	if (sourceSampleFormat == SampleFormat.PCM) {
-		if (sourceBitDepth == 8) {
-			interleavedChannels = uint8PcmToFloat32(audioBuffer)
-		} else if (sourceBitDepth == 16) {
+	if (sourceSampleFormat === SampleFormat.PCM) {
+		if (sourceBitDepth === 8) {
+			interleavedChannels = int8PcmToFloat32(BinaryArrayConversion.bufferToInt8(audioBuffer))
+		} else if (sourceBitDepth === 16) {
 			interleavedChannels = int16PcmToFloat32(BinaryArrayConversion.bufferLEToInt16(audioBuffer))
-		} else if (sourceBitDepth == 24) {
+		} else if (sourceBitDepth === 24) {
 			interleavedChannels = int24PcmToFloat32(BinaryArrayConversion.bufferLEToInt24(audioBuffer))
-		} else if (sourceBitDepth == 32) {
+		} else if (sourceBitDepth === 32) {
 			interleavedChannels = int32PcmToFloat32(BinaryArrayConversion.bufferLEToInt32(audioBuffer))
 		} else {
 			throw new Error(`Unsupported PCM bit depth: ${sourceBitDepth}`)
 		}
-	} else if (sourceSampleFormat == SampleFormat.Float) {
-		if (sourceBitDepth == 32) {
+	} else if (sourceSampleFormat === SampleFormat.Float) {
+		if (sourceBitDepth === 32) {
 			interleavedChannels = BinaryArrayConversion.bufferLEToFloat32(audioBuffer)
-		} else if (sourceBitDepth == 64) {
+		} else if (sourceBitDepth === 64) {
 			interleavedChannels = BinaryArrayConversion.float64Tofloat32(BinaryArrayConversion.bufferLEToFloat64(audioBuffer))
 		} else {
 			throw new Error(`Unsupported float bit depth: ${sourceBitDepth}`)
 		}
-	} else if (sourceSampleFormat == SampleFormat.Alaw) {
-		if (sourceBitDepth == 8) {
+	} else if (sourceSampleFormat === SampleFormat.Alaw) {
+		if (sourceBitDepth === 8) {
 			interleavedChannels = int16PcmToFloat32(AlawMulaw.alaw.decode(audioBuffer))
 		} else {
 			throw new Error(`Unsupported alaw bit depth: ${sourceBitDepth}`)
 		}
-	} else if (sourceSampleFormat == SampleFormat.Mulaw) {
-		if (sourceBitDepth == 8) {
+	} else if (sourceSampleFormat === SampleFormat.Mulaw) {
+		if (sourceBitDepth === 8) {
 			interleavedChannels = int16PcmToFloat32(AlawMulaw.mulaw.decode(audioBuffer))
 		} else {
 			throw new Error(`Unsupported mulaw bit depth: ${sourceBitDepth}`)
@@ -84,27 +86,29 @@ export function decodeToChannels(audioBuffer: Buffer, channelCount: number, sour
 		throw new Error(`Unsupported audio format: ${sourceSampleFormat}`)
 	}
 
+	audioBuffer = Buffer.from([]) // Zero the buffer reference to allow the GC to free up memory, if possible
+
 	return deInterleaveChannels(interleavedChannels, channelCount)
 }
 
 // Int8 PCM <-> Float32 conversion
-export function uint8PcmToFloat32(input: Uint8Array) {
+export function int8PcmToFloat32(input: Int8Array) {
 	const output = new Float32Array(input.length)
 
 	for (let i = 0; i < input.length; i++) {
-		const sample = input[i] - 128
+		const sample = input[i]
 		output[i] = sample < 0 ? sample / 128 : sample / 127
 	}
 
 	return output
 }
 
-export function float32ToUint8Pcm(input: Float32Array) {
-	const output = new Uint8Array(input.length)
+export function float32ToInt8Pcm(input: Float32Array) {
+	const output = new Int8Array(input.length)
 
 	for (let i = 0; i < input.length; i++) {
 		const sample = clampFloatSample(input[i])
-		output[i] = ((sample < 0 ? sample * 128 : sample * 127) | 0) + 128
+		output[i] = (sample < 0 ? sample * 128 : sample * 127) | 0
 	}
 
 	return output
@@ -185,11 +189,11 @@ export function float32ToInt32Pcm(input: Float32Array) {
 export function interleaveChannels(channels: Float32Array[]) {
 	const channelCount = channels.length
 
-	if (channelCount == 0) {
+	if (channelCount === 0) {
 		throw new Error('Empty channel array received')
 	}
 
-	if (channelCount == 1) {
+	if (channelCount === 1) {
 		return channels[0]
 	}
 
@@ -209,11 +213,11 @@ export function interleaveChannels(channels: Float32Array[]) {
 }
 
 export function deInterleaveChannels(interleavedChannels: Float32Array, channelCount: number) {
-	if (channelCount == 0) {
+	if (channelCount === 0) {
 		throw new Error('0 channel count received')
 	}
 
-	if (channelCount == 1) {
+	if (channelCount === 1) {
 		return [interleavedChannels]
 	}
 
@@ -244,5 +248,11 @@ export function deInterleaveChannels(interleavedChannels: Float32Array, channelC
 // Utilities
 /////////////////////////////////////////////////////////////////////////////////////////////
 export function clampFloatSample(floatSample: number) {
-	return Math.max(-1, Math.min(floatSample, 1))
+	if (floatSample < -1.0) {
+		return -1.0
+	} else if (floatSample > 1.0) {
+		return 1.0
+	} else {
+		return floatSample
+	}
 }

package/src/cli/CLI.ts

@@ -425,6 +425,7 @@ async function speak(operationData: CLIOperationData) {
 		} else if (sourceFileExtension == 'srt' || sourceFileExtension == 'vtt') {
 			const fileContent = await readFile(sourceFile, { encoding: 'utf-8' })
 			textSegments = subtitlesToTimeline(fileContent).map(entry => entry.text)
+			//textSegments = [subtitlesToText(fileContent)]
 		} else if (sourceFileExtension == 'xml' || sourceFileExtension == 'ssml') {
 			options.ssml = true
 			textSegments = [fileContent]

package/src/codecs/FFMpegTranscoder.ts

@@ -88,7 +88,9 @@ async function transcode_CLI(ffmpegCommand: string, input: string | Buffer, outp
 
 		process.on('close', (exitCode) => {
 			if (exitCode == 0) {
-				resolve(Buffer.concat(stdoutChunks))
+				const concatenatedChunks = Buffer.concat(stdoutChunks)
+
+				resolve(concatenatedChunks)
 			} else {
 				reject(`ffmpeg exited with code ${exitCode}`)
 				log(stderrOutput)

package/src/codecs/WaveCodec.ts

@@ -87,13 +87,15 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = true, ignor
 				throw new Error('A data subchunk was encountered before a format subchunk')
 			}
 
+			// If the data chunk is truncated or extended beyond 4 GiB,
+			// the data would be read up to the end of the buffer
 			if (ignoreOverflowingDataChunks && subChunkSize === 4294967295) {
 				subChunkSize = waveData.length - readOffset
 			}
 
-			// If the data chunk is truncated, but truncations are ignored,
-			// it would be read up to the end of the buffer
-			dataBuffers.push(waveData.subarray(readOffset, readOffset + subChunkSize))
+			const subChunkData = waveData.subarray(readOffset, readOffset + subChunkSize)
+
+			dataBuffers.push(subChunkData)
 		}
 		// All sub chunks other than 'data' (e.g. 'LIST', 'fact', 'plst', 'junk' etc.) are ignored
 
@@ -111,6 +113,10 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = true, ignor
 		throw new Error('No format subchunk was found in the wave file')
 	}
 
+	if (dataBuffers.length === 0) {
+		throw new Error('No data subchunks were found in the wave file')
+	}
+
 	const waveFormat = WaveFormat.deserializeFrom(formatSubChunkBodyBuffer)
 
 	const sampleFormat = waveFormat.sampleFormat
@@ -120,6 +126,8 @@ export function decodeWave(waveData: Buffer, ignoreTruncatedChunks = true, ignor
 	const speakerPositionMask = waveFormat.speakerPositionMask
 
 	const concatenatedDataBuffers = Buffer.concat(dataBuffers)
+	dataBuffers.length = 0 // Allow the garbage collector to free up memory held by the data buffers
+
 	const audioChannels = AudioBufferConversion.decodeToChannels(concatenatedDataBuffers, channelCount, bitDepth, sampleFormat)
 
 	return {

package/src/recognition/WhisperSTT.ts

@@ -442,11 +442,6 @@ export class Whisper {
 			partTokensConfidence = partTokensConfidence.slice(initialTokens.length)
 			partCrossAttentionQKs = partCrossAttentionQKs.slice(initialTokens.length)
 
-			// Compute compression ratio for part (disabled for now)
-			if (false) {
-				const compressionRatioForPart = (await getDeflateCompressionMetricsForString(this.tokensToText(partTokens))).ratio
-			}
-
 			// Find alignment path
 			const alignmentPath = await this.findAlignmentPathFromQKs(partCrossAttentionQKs, partTokens, 0, segmentFrameCount) //, alignmentHeadsIndexes[this.modelName])
 
@@ -457,8 +452,17 @@ export class Whisper {
 			allDecodedTokens.push(...partTokens)
 			timeline.push(...partTimeline)
 
-			// Update previous text tokens
-			previousPartTextTokens = partTokens.filter(token => this.isTextToken(token))
+			// Determine compression ratio for recognized text (normalized to lowercase) of this part
+			const compressionRatioForPart = (await getDeflateCompressionMetricsForString(this.tokensToText(partTokens).toLocaleLowerCase())).ratio
+
+			// If the recognized text isn't too repetitive
+			if (compressionRatioForPart < options.repetitionThreshold!) {
+				// Set current part tokens as the previous part text tokens
+				previousPartTextTokens = partTokens.filter(token => this.isTextToken(token))
+			} else {
+				// Otherwise, set previous part tokens to an empty array
+				previousPartTextTokens = []
+			}
 
 			audioOffset = audioEndOffset
 
@@ -544,6 +548,7 @@ export class Whisper {
 			autoPromptParts: false,
 			maxTokensPerPart: Infinity,
 			suppressRepetition: false,
+			repetitionThreshold: Infinity,
 			decodeTimestampTokens: true,
 			endTokenThreshold: whisperAlignmentOptions!.endTokenThreshold!,
 			includeEndTokenInCandidates: false,
@@ -2111,6 +2116,7 @@ export interface WhisperOptions {
 	autoPromptParts?: boolean
 	maxTokensPerPart?: number
 	suppressRepetition?: boolean
+	repetitionThreshold?: number
 	decodeTimestampTokens?: boolean
 	endTokenThreshold?: number
 	includeEndTokenInCandidates?: boolean
@@ -2128,6 +2134,7 @@ export const defaultWhisperOptions: WhisperOptions = {
 	autoPromptParts: true,
 	maxTokensPerPart: 250,
 	suppressRepetition: true,
+	repetitionThreshold: 2.4,
 	decodeTimestampTokens: true,
 	endTokenThreshold: 0.9,
 	includeEndTokenInCandidates: true,

package/src/utilities/BinaryArrayConversion.ts

@@ -1,17 +1,30 @@
 // Typed arrays to Buffer (little endian) conversions
+//
+// The faster conversion methods (other than the methods for int8) would only work correctly
+// on little-endian architectures, since they assume the byte order of the underlying architecture.
+//
+// Since Echogarden only supports little-endian architectures, this shouldn't matter.
 
 // int8 <-> bufferLE
-export function int8ToBuffer(ints: Int8Array) {
-	const buffer = Buffer.alloc(ints.length)
+export function int8ToBuffer(int8s: Int8Array) {
+	return Buffer.copyBytesFrom(int8s)
+}
+
+export function int8ToBuffer_Slow(int8s: Int8Array) {
+	const buffer = Buffer.alloc(int8s.length)
 
-	for (let i = 0; i < ints.length; i++) {
-		buffer[i] = ints[i] + 128
+	for (let i = 0; i < int8s.length; i++) {
+		buffer[i] = int8s[i] + 128
 	}
 
 	return buffer
 }
 
 export function bufferToInt8(buffer: Buffer) {
+	return new Int8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+}
+
+export function bufferToInt8_Slow(buffer: Buffer) {
 	const result = new Int8Array(buffer.length)
 
 	for (let i = 0; i < result.length; i++) {
@@ -22,17 +35,25 @@ export function bufferToInt8(buffer: Buffer) {
 }
 
 // int16 <-> bufferLE
-export function int16ToBufferLE(ints: Int16Array) {
-	const buffer = Buffer.alloc(ints.length * 2)
+export function int16ToBufferLE(int16s: Int16Array) {
+	return Buffer.copyBytesFrom(int16s)
+}
+
+export function int16ToBufferLE_Slow(int16s: Int16Array) {
+	const buffer = Buffer.alloc(int16s.length * 2)
 
-	for (let i = 0; i < ints.length; i++) {
-		buffer.writeInt16LE(ints[i], i * 2)
+	for (let i = 0; i < int16s.length; i++) {
+		buffer.writeInt16LE(int16s[i], i * 2)
 	}
 
 	return buffer
 }
 
 export function bufferLEToInt16(buffer: Buffer) {
+	return new Int16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 2)
+}
+
+export function bufferLEToInt16_Slow(buffer: Buffer) {
 	const result = new Int16Array(buffer.length / 2)
 
 	for (let i = 0; i < result.length; i++) {
@@ -43,11 +64,11 @@ export function bufferLEToInt16(buffer: Buffer) {
 }
 
 // int24 <-> bufferLE (uses int32 for storage)
-export function int24ToBufferLE(ints: Int32Array) {
-	const buffer = Buffer.alloc(ints.length * 3)
+export function int24ToBufferLE(int24s: Int32Array) {
+	const buffer = Buffer.alloc(int24s.length * 3)
 
-	for (let i = 0; i < ints.length; i++) {
-		const val = ints[i]
+	for (let i = 0; i < int24s.length; i++) {
+		const val = int24s[i]
 		const encodedVal = val < 0 ? val + 0x1000000 : val
 
 		buffer[(i * 3) + 0] = (encodedVal >> 0) & 0xff
@@ -74,17 +95,25 @@ export function bufferLEToInt24(buffer: Buffer) {
 }
 
 // int32 <-> bufferLE
-export function int32ToBufferLE(ints: Int32Array) {
-	const buffer = Buffer.alloc(ints.length * 4)
+export function int32ToBufferLE(int32s: Int32Array) {
+	return Buffer.copyBytesFrom(int32s)
+}
 
-	for (let i = 0; i < ints.length; i++) {
-		buffer.writeInt32LE(ints[i], i * 4)
+export function int32ToBufferLE_Slow(int32s: Int32Array) {
+	const buffer = Buffer.alloc(int32s.length * 4)
+
+	for (let i = 0; i < int32s.length; i++) {
+		buffer.writeInt32LE(int32s[i], i * 4)
 	}
 
 	return buffer
 }
 
 export function bufferLEToInt32(buffer: Buffer) {
+	return new Int32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4)
+}
+
+export function bufferLEToInt32_Slow(buffer: Buffer) {
 	const result = new Int32Array(buffer.length / 4)
 
 	for (let i = 0; i < result.length; i++) {
@@ -95,17 +124,25 @@ export function bufferLEToInt32(buffer: Buffer) {
 }
 
 // float32 <-> bufferLE
-export function float32ToBufferLE(floats: Float32Array) {
-	const buffer = Buffer.alloc(floats.length * 4)
+export function float32ToBufferLE(float32s: Float32Array) {
+	return Buffer.copyBytesFrom(float32s)
+}
+
+export function float32ToBufferLE_Slow(float32s: Float32Array) {
+	const buffer = Buffer.alloc(float32s.length * 4)
 
-	for (let i = 0; i < floats.length; i++) {
-		buffer.writeFloatLE(floats[i], i * 4)
+	for (let i = 0; i < float32s.length; i++) {
+		buffer.writeFloatLE(float32s[i], i * 4)
 	}
 
 	return buffer
 }
 
 export function bufferLEToFloat32(buffer: Buffer) {
+	return new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4)
+}
+
+export function bufferLEToFloat32_Slow(buffer: Buffer) {
 	const result = new Float32Array(buffer.length / 4)
 
 	for (let i = 0; i < result.length; i++) {
@@ -116,17 +153,25 @@ export function bufferLEToFloat32(buffer: Buffer) {
 }
 
 // float64 <-> bufferLE
-export function float64ToBufferLE(floats: Float64Array) {
-	const buffer = Buffer.alloc(floats.length * 8)
+export function float64ToBufferLE(float64s: Float64Array) {
+	return Buffer.copyBytesFrom(float64s)
+}
+
+export function float64ToBufferLE_Slow(float64s: Float64Array) {
+	const buffer = Buffer.alloc(float64s.length * 8)
 
-	for (let i = 0; i < floats.length; i++) {
-		buffer.writeDoubleLE(floats[i], i * 8)
+	for (let i = 0; i < float64s.length; i++) {
+		buffer.writeDoubleLE(float64s[i], i * 8)
 	}
 
 	return buffer
 }
 
 export function bufferLEToFloat64(buffer: Buffer) {
+	return new Float64Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 8)
+}
+
+export function bufferLEToFloat64_Slow(buffer: Buffer) {
 	const result = new Float64Array(buffer.length / 8)
 
 	for (let i = 0; i < result.length; i++) {
@@ -137,23 +182,10 @@ export function bufferLEToFloat64(buffer: Buffer) {
 }
 
 // float64 <-> float32
-export function float64Tofloat32(doubles: Float64Array) {
-	const floats = new Float32Array(doubles.length)
-
-	for (let i = 0; i < doubles.length; i++) {
-		floats[i] = doubles[i]
-	}
-
-	return floats
+export function float64Tofloat32(float64s: Float64Array) {
+	return Float32Array.from(float64s)
 }
 
-export function float32Tofloat64(floats: Float32Array) {
-	const doubles = new Float64Array(floats.length)
-
-	for (let i = 0; i < floats.length; i++) {
-		doubles[i] = floats[i]
-	}
-
-	return doubles
+export function float32Tofloat64(float32s: Float32Array) {
+	return Float64Array.from(float32s)
 }
-

package/src/utilities/Compression.ts

@@ -107,6 +107,6 @@ export async function getDeflateCompressionMetricsForString(str: string) {
 	return {
 		originalSize: originalStringBytes.length,
 		compressedSize: compressedStringBytes.length,
-		ratio: compressedStringBytes.length / originalStringBytes.length
+		ratio: originalStringBytes.length / compressedStringBytes.length
 	}
 }