echogarden 1.4.4 → 1.6.0

package/src/utilities/LPVarInt.ts

@@ -0,0 +1,292 @@
+import { DynamicUint8Array } from "./DynamicUint8Array.js"
+import { logToStderr } from "./Utilities.js"
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// Encode unsigned integer
+////////////////////////////////////////////////////////////////////////////////////
+export function encodeUnsignedInt31(value: number, outEncodedData: DynamicUint8Array) {
+	value = value >>> 0
+
+	if (value < (2 ** 7)) {
+		outEncodedData.add(
+			value
+		)
+	} else if (value < (2 ** 14)) {
+		outEncodedData.addMany(
+			(value & 0b00111111) | 0b10000000,
+			value >>> 6,
+		)
+	} else if (value < (2 ** 21)) {
+		outEncodedData.addMany(
+			(value & 0b00011111) | 0b11000000,
+			value >>> 5,
+			value >>> 13,
+		)
+	} else if (value < (2 ** 28)) {
+		outEncodedData.addMany(
+			(value & 0b00001111) | 0b11100000,
+			value >>> 4,
+			value >>> 12,
+			value >>> 20,
+		)
+	} else {
+		outEncodedData.addMany(
+			0b11110000,
+			value,
+			value >>> 8,
+			value >>> 16,
+			value >>> 24,
+		)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Decode unsigned integer
+////////////////////////////////////////////////////////////////////////////////////
+export function decodeUnsignedInt31(encodedData: ArrayLike<number>, readOffset: number): DecodedValueAndReadOffset {
+	readOffset = readOffset | 0
+
+	const byte0 = encodedData[readOffset++]
+
+	if ((byte0 & 0b10000000) === 0) {
+		// 1 byte
+		let decodedValue =
+			byte0
+
+		return { decodedValue, readOffset }
+	}
+
+	const byte1 = encodedData[readOffset++]
+
+	if ((byte0 & 0b01000000) === 0) {
+		// 2 bytes
+		let decodedValue =
+			(byte0 & 0b00111111) |
+			(byte1 << 6)
+
+		return { decodedValue, readOffset }
+	}
+
+	const byte2 = encodedData[readOffset++]
+
+	if ((byte0 & 0b00100000) === 0) {
+		// 3 bytes
+		let decodedValue =
+			(byte0 & 0b00011111) |
+			(byte1 << 5) |
+			(byte2 << 13)
+
+		return { decodedValue, readOffset }
+	}
+
+	const byte3 = encodedData[readOffset++]
+
+	if ((byte0 & 0b00010000) === 0) {
+		// 4 bytes
+		let decodedValue =
+			(byte0 & 0b00001111) |
+			(byte1 << 4) |
+			(byte2 << 12) |
+			(byte3 << 20)
+
+		return { decodedValue, readOffset }
+	}
+
+	const byte4 = encodedData[readOffset++]
+
+	if (byte0 === 0b11110000) {
+		// 5 bytes
+		let decodedValue =
+			(byte1) |
+			(byte2 << 8) |
+			(byte3 << 16) |
+			(byte4 << 24)
+
+		return { decodedValue, readOffset }
+	}
+
+	throw new Error(`Encountered a value that is encoded with more than 5 bytes (beyond Unsigned Int31 range).`)
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Encode signed integer
+////////////////////////////////////////////////////////////////////////////////////
+export function encodeSignedInt32(value: number, outEncodedData: DynamicUint8Array) {
+	const absValue = Math.abs(value | 0)
+
+	if (absValue < (2 ** 6)) {
+		outEncodedData.add(
+			value & 0b01111111
+		)
+	} else if (absValue < (2 ** 13)) {
+		outEncodedData.addMany(
+			(value & 0b00111111) | 0b10000000,
+			value >> 6
+		)
+	} else if (absValue < (2 ** 20)) {
+		outEncodedData.addMany(
+			(value & 0b00011111) | 0b11000000,
+			value >> 5,
+			value >> 13,
+		)
+	} else if (absValue < (2 ** 27)) {
+		outEncodedData.addMany(
+			(value & 0b00001111) | 0b11100000,
+			value >> 4,
+			value >> 12,
+			value >> 20,
+		)
+	} else {
+		outEncodedData.addMany(
+			0b11110000,
+			value,
+			value >> 8,
+			value >> 16,
+			value >> 24,
+		)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Decode signed integer
+////////////////////////////////////////////////////////////////////////////////////
+export function decodeSignedInt32(encodedData: ArrayLike<number>, readOffset: number): DecodedValueAndReadOffset {
+	const byte0 = encodedData[readOffset++]
+
+	if ((byte0 & 0b10000000) === 0) {
+		// 1 byte
+		let decodedValue =
+			byte0
+
+		if ((byte0 & 0b01000000) !== 0) {
+			decodedValue |= (-1 << 7)
+		}
+
+		return { decodedValue, readOffset }
+	}
+
+	const byte1 = encodedData[readOffset++]
+
+	if ((byte0 & 0b01000000) === 0) {
+		// 2 bytes
+		let decodedValue =
+			(byte0 & 0b00111111) |
+			(byte1 << 6)
+
+		if ((byte1 & 0b10000000) !== 0) {
+			decodedValue |= (-1 << 14)
+		}
+
+		return { decodedValue, readOffset }
+	}
+
+	const byte2 = encodedData[readOffset++]
+
+	if ((byte0 & 0b00100000) === 0) {
+		// 3 bytes
+		let decodedValue =
+			(byte0 & 0b00011111) |
+			(byte1 << 5) |
+			(byte2 << 13)
+
+		if ((byte2 & 0b10000000) !== 0) {
+			decodedValue |= (-1 << 21)
+		}
+
+		return { decodedValue, readOffset }
+	}
+
+	const byte3 = encodedData[readOffset++]
+
+	if ((byte0 & 0b00010000) === 0) {
+		// 4 bytes
+		let decodedValue =
+			(byte0 & 0b00001111) |
+			(byte1 << 4) |
+			(byte2 << 12) |
+			(byte3 << 20)
+
+		if ((byte3 & 0b10000000) !== 0) {
+			decodedValue |= (-1 << 28)
+		}
+
+		return { decodedValue, readOffset }
+	}
+
+	const byte4 = encodedData[readOffset++]
+
+	if (byte0 === 0b11110000) {
+		// 5 bytes
+		let decodedValue =
+			(byte1) |
+			(byte2 << 8) |
+			(byte3 << 16) |
+			(byte4 << 24)
+
+		return { decodedValue, readOffset }
+	}
+
+	throw new Error(`Encountered a value that is encoded with more than 5 bytes (beyond int32 range).`)
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Types
+////////////////////////////////////////////////////////////////////////////////////
+export interface DecodedValueAndReadOffset {
+	decodedValue: number
+	readOffset: number
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////////////////
+export function testLPVarintSigned() {
+	const encodedBytes = new DynamicUint8Array()
+
+	function runTest(testValue: number) {
+		encodedBytes.clear()
+
+		encodeSignedInt32(testValue, encodedBytes)
+		const { decodedValue } = decodeSignedInt32(encodedBytes.data, 0)
+
+		if (decodedValue !== testValue) {
+			throw new Error(`Expected ${testValue} but got ${decodedValue}`)
+		}
+	}
+
+	for (let i = -(2 ** 26); i < 2 ** 26; i++) {
+		if (i % 1000000 === 0) {
+			logToStderr(i)
+		}
+
+		runTest(i)
+	}
+
+	const x = 1
+}
+
+export function testLPVarintUnsigned() {
+	const encodedBytes = new DynamicUint8Array()
+
+	function runTest(testValue: number) {
+		encodedBytes.clear()
+
+		encodeUnsignedInt31(testValue, encodedBytes)
+		const { decodedValue } = decodeUnsignedInt31(encodedBytes.data, 0)
+
+		if (decodedValue !== testValue) {
+			throw new Error(`Expected ${testValue} but got ${decodedValue}`)
+		}
+	}
+
+	for (let i = 0; i < 2 ** 31; i++) {
+		if (i % 1000000 === 0) {
+			logToStderr(i)
+		}
+
+		runTest(i)
+	}
+
+	const x = 1
+}

package/src/utilities/Locale.ts

@@ -22,7 +22,7 @@ export function formatLanguageCodeWithName(languageCode: string, styleId: 1 | 2
 	}
 }
 
-export async function normalizeIdentifierToLangaugeCode(langIdentifier: string) {
+export async function normalizeIdentifierToLanguageCode(langIdentifier: string) {
 	const result = await parseLangIdentifier(langIdentifier)
 
 	return result.Name

package/src/utilities/OnnxUtilities.ts

@@ -65,4 +65,4 @@ export interface OnnxSessionOptions {
 	logSeverityLevel?: 0 | 1 | 2 | 3 | 4
 }
 
-export type OnnxExecutionProvider = 'cpu' | 'dml'
+export type OnnxExecutionProvider = 'cpu' | 'dml' | 'cuda'

package/src/utilities/PackageManager.ts

@@ -82,8 +82,10 @@ export function resolveVersionTagForUnversionedPackageName(unversionedPackageNam
 const defaultVersionTag = '20230718'
 
 const packageVersionTagResolutionLookup: { [packageName: string]: string } = {
+	// SOX binary
 	'sox-14.4.2-linux-minimal': '20230802',
 
+	// VITS voices
 	'vits-de_DE-thorsten_emotional-medium': '20230808',
 	'vits-en_GB-semaine-medium': '20230808',
 	'vits-fr_FR-upmc-medium': '20230808',
@@ -91,21 +93,41 @@ const packageVersionTagResolutionLookup: { [packageName: string]: string } = {
 	'vits-ro_RO-mihai-medium': '20230808',
 	'vits-sr_RS-serbski_institut-medium': '20230808',
 	'vits-tr_TR-dfki-medium': '20230808',
-
 	'vits-cs_CZ-jirka-medium': '20230824',
 	'vits-de_DE-thorsten-high': '20230824',
 	'vits-hu_HU-anna-medium': '20230824',
 	'vits-pt_PT-tugao-medium': '20230824',
 	'vits-sk_SK-lili-medium': '20230824',
 	'vits-tr_TR-fahrettin-medium': '20230824',
-
 	'vits-ar_JO-kareem-medium': '20231022',
 	'vits-cs_CZ-jirka-low': '20231022',
 	'vits-en_US-hfc_male-medium': '20231022',
 	'vits-en_US-libritts_r-medium': '20231022',
 	'vits-hu_HU-imre-medium': '20231022',
 	'vits-pl_PL-mc_speech-medium': '20231022',
-
+	'vits-ar_JO-kareem-low': '20231126',
+	'vits-en_US-hfc_female-medium': '20231126',
+	'vits-de_DE-mls-medium': '20240316',
+	'vits-en_GB-cori-high': '20240316',
+	'vits-en_US-kristin-medium': '20240316',
+	'vits-en_US-ljspeech-high': '20240316',
+	'vits-en_US-ljspeech-medium': '20240316',
+	'vits-es_MX-claude-high': '20240316',
+	'vits-fa_IR-amir-medium': '20240316',
+	'vits-fa_IR-gyro-medium': '20240316',
+	'vits-fr_FR-mls-medium': '20240316',
+	'vits-fr_FR-tom-medium': '20240316',
+	'vits-nl_NL-mls-medium': '20240316',
+	'vits-sl_SI-artur-medium': '20240316',
+	'vits-tr_TR-fettah-medium': '20240316',
+	'vits-it_IT-paola-medium': '20241001',
+	'vits-en_US-norman-medium': '20241001',
+	'vits-en_US-john-medium': '20241001',
+	'vits-en_US-bryce-medium': '20241001',
+	'vits-en_GB-cori-medium': '20241001',
+	'vits-cy_GB-gwryw_gogleddol-medium': '20241001',
+
+	// Whisper (integrated engine) models
 	'whisper-tiny': '20231126',
 	'whisper-tiny.en': '20231126',
 	'whisper-base': '20231126',
@@ -114,11 +136,12 @@ const packageVersionTagResolutionLookup: { [packageName: string]: string } = {
 	'whisper-small.en': '20231126',
 	'whisper-medium': '20231126',
 	'whisper-medium.en': '20231126',
-	'whisper-large-v3': '20231126',
+	'whisper-large-v3-turbo-fp16': '20241002',
 
-	'vits-ar_JO-kareem-low': '20231126',
-	'vits-en_US-hfc_female-medium': '20231126',
+	// Whisper tiktoken data
+	'whisper-tiktoken-data': '20240408',
 
+	// FFMpeg binaries
 	'ffmpeg-6.0-win32-x64': '20240316',
 	'ffmpeg-6.0-win32-ia32': '20240316',
 	'ffmpeg-6.0-darwin-x64': '20240316',
@@ -129,25 +152,13 @@ const packageVersionTagResolutionLookup: { [packageName: string]: string } = {
 	'ffmpeg-6.0-linux-arm': '20240316',
 	'ffmpeg-6.0-freebsd-x64': '20240316',
 
-	'vits-de_DE-mls-medium': '20240316',
-	'vits-en_GB-cori-high': '20240316',
-	'vits-en_US-kristin-medium': '20240316',
-	'vits-en_US-ljspeech-high': '20240316',
-	'vits-en_US-ljspeech-medium': '20240316',
-	'vits-es_MX-claude-high': '20240316',
-	'vits-fa_IR-amir-medium': '20240316',
-	'vits-fa_IR-gyro-medium': '20240316',
-	'vits-fr_FR-mls-medium': '20240316',
-	'vits-fr_FR-tom-medium': '20240316',
-	'vits-nl_NL-mls-medium': '20240316',
-	'vits-sl_SI-artur-medium': '20240316',
-	'vits-tr_TR-fettah-medium': '20240316',
-
+	// MDXNET models
 	'mdxnet-UVR_MDXNET_1_9703': '20240330',
 	'mdxnet-UVR_MDXNET_2_9682': '20240330',
 	'mdxnet-UVR_MDXNET_3_9662': '20240330',
 	'mdxnet-UVR_MDXNET_KARA': '20240330',
 
+	// whisper.cpp models
 	'whisper.cpp-tiny': '20240405',
 	'whisper.cpp-tiny-q5_1': '20240405',
 	'whisper.cpp-tiny.en': '20240405',
@@ -174,19 +185,29 @@ const packageVersionTagResolutionLookup: { [packageName: string]: string } = {
 	'whisper.cpp-large-v2-q5_0': '20240405',
 	'whisper.cpp-large-v3': '20240405',
 	'whisper.cpp-large-v3-q5_0': '20240405',
+	'whisper.cpp-large-v3-turbo': '20241003',
+	'whisper.cpp-large-v3-turbo-q5_0': '20241003',
 
-	'whisper.cpp-binaries-linux-x64-cpu-latest-patched': '20240405',
-	'whisper.cpp-binaries-windows-x64-cpu-latest-patched': '20240409',
+	// whisper.cpp binaries
+	'whisper.cpp-binaries-linux-x64-cpu-1.6.2': '20241001',
+	'whisper.cpp-binaries-windows-x64-cpu-1.6.2': '20241001',
+	'whisper.cpp-binaries-windows-x64-cublas-12.4.0-1.6.2': '20241002',
 
-	'whisper-tiktoken-data': '20240408',
-
-	'whisper.cpp-binaries-windows-x64-cublas-12.4.0-latest-patched': '20240409',
-	'whisper.cpp-binaries-windows-x64-cublas-11.8.0-latest-patched': '20240409',
+	'whisper.cpp-binaries-linux-x64-cpu-latest': '20241003',
+	'whisper.cpp-binaries-windows-x64-cpu-latest': '20241003',
+	'whisper.cpp-binaries-windows-x64-cublas-12.4.0-latest': '20241003',
 
-	'xenova-multilingual-e5-small-quantized': '20240504',
-	'xenova-nllb-200-distilled-600M-quantized': '20240505',
+	// E5 models
+	'xenova-multilingual-e5-small-q8': '20240504',
 	'xenova-multilingual-e5-small-fp16': '20240514',
 	'xenova-multilingual-e5-base-fp16': '20240514',
-	'xenova-multilingual-e5-base-quantized': '20240514',
-	'xenova-multilingual-e5-large-quantized': '20240514',
+	'xenova-multilingual-e5-base-q8': '20240514',
+	'xenova-multilingual-e5-large-q8': '20240514',
+
+	// NLLB models
+	'xenova-nllb-200-distilled-600M-q8': '20240505',
+
+	// W2V-BERT models
+	'w2v-bert-2.0-int8': '20240517',
+	'w2v-bert-2.0-uint8': '20240517',
 }

package/src/utilities/RandomGenerator.ts

@@ -1,5 +1,4 @@
 import { sumVector } from '../math/VectorMath.js'
-import { logToStderr } from './Utilities.js'
 
 export abstract class RandomGenerator {
 	getIntInRange(min: number, max: number) {
@@ -30,8 +29,8 @@ export abstract class RandomGenerator {
 		return result
 	}
 
-	getNormallyDistributedVector(featureCount: number, meanVector: number[], standardDeviationVector: number[]) {
-		const features = this.getNormallyDistributedValues(featureCount)
+	getNormallyDistributedVector(elementCount: number, meanVector: number[], standardDeviationVector: number[]) {
+		const features = this.getNormallyDistributedValues(elementCount)
 
 		for (let i = 0; i < features.length; i++) {
 			features[i] = meanVector[i] + (features[i] * standardDeviationVector[i])
@@ -104,134 +103,34 @@ export abstract class RandomGenerator {
 	abstract nextInt32(): number
 }
 
-export class MurmurRNG extends RandomGenerator {
-	state: number
-
-	constructor(seed: number) {
-		super()
-
-		this.state = seed
-	}
-
-	nextFloat() {
-		return this.nextUint32() / 4294967296
-	}
-
+export abstract class Int32RandomGenerator extends RandomGenerator {
 	nextUint32() {
 		return this.nextInt32() >>> 0
 	}
 
-	nextInt32() {
-		const multiplier = 3332679571
-
-		let s = this.state
-
-		s = Math.imul(s, multiplier)
-		s ^= s >>> 16
-
-		s = Math.imul(s, multiplier)
-		s ^= s >>> 10
-
-		s = Math.imul(s, multiplier)
-		s ^= s >>> 17
-
-		this.state = s
-
-		return s
-	}
-
-	static hashInt32(val: number, seed = 234928357) {
-		const rng = new MurmurRNG(seed ^ val)
-		return rng.nextUint32()
-	}
-}
-
-export class XorShift32RNG extends RandomGenerator {
-	state: number
-
-	constructor(seed: number) {
-		super()
-
-		this.state = seed
-	}
-
 	nextFloat() {
-		return this.nextUint32() / 4294967296
-	}
-
-	nextUint32() {
-		return this.nextInt32() >>> 0
-	}
-
-	nextInt32() {
-		let s = this.state
-
-		s ^= s << 13
-		s ^= s >>> 17
-		s ^= s << 5
-
-		this.state = s
-
-		return s
+		return this.nextUint32() * (1 / 4294967296)
 	}
 }
 
-export class LehmerRNG extends RandomGenerator {
+export class XorShift32PRNG extends Int32RandomGenerator {
 	state: number
 
 	constructor(seed: number) {
 		super()
 
-		this.state = seed
-	}
-
-	nextFloat() {
-		return this.nextUint32() / 4294967296
-	}
-
-	nextUint32() {
-		return this.nextInt32() >>> 0
+		this.state = (3077908504 + seed) | 0
 	}
 
 	nextInt32() {
-		let s = this.state
+		let state = this.state | 0
 
-		s = s * 48271 % 0x7fffffff
+		state ^= state << 13
+		state ^= state >>> 17
+		state ^= state << 5
 
-		this.state = s
-
-		return s
-	}
-}
-
-const log = logToStderr
-
-export function testRngCycleLength() {
-	const seed = 1
-
-	const rng = new XorShift32RNG(seed)
-
-	const bucketCount = 1000000
-	const seen: number[][] = []
-
-	for (let i = 0; i < bucketCount; i++) {
-		seen[i] = []
-	}
-
-	for (let i = 0; i < 4294967296; i++) {
-		if (i % 1000000 == 0) {
-			log(`${i} iterations`)
-		}
-
-		const r = rng.nextUint32()
-
-		const bucket = seen[r % bucketCount]
-
-		if (bucket.includes(r)) {
-			log(`Cycles at iteration ${i}`)
-			return
-		}
+		this.state = state
 
-		bucket.push(r)
+		return state
 	}
 }