echogarden 1.3.3 → 1.4.1

package/src/api/LanguageDetection.ts

@@ -257,7 +257,7 @@ export async function detectTextLanguage(input: string, options: TextLanguageDet
 		case 'tinyld': {
 			const { detectLanguage } = await import('../text-language-detection/TinyLDLanguageDetection.js')
 
-			logger.start('Detecting text language using tinyld')
+			logger.start('Detect text language using tinyld')
 
 			detectedLanguageProbabilities = await detectLanguage(input)
 
@@ -267,7 +267,7 @@ export async function detectTextLanguage(input: string, options: TextLanguageDet
 		case 'fasttext': {
 			const { detectLanguage } = await import('../text-language-detection/FastTextLanguageDetection.js')
 
-			logger.start('Detecting text language using FastText')
+			logger.start('Detect text language using FastText')
 
 			detectedLanguageProbabilities = await detectLanguage(input)
 

package/src/api/Synthesis.ts

@@ -54,7 +54,7 @@ async function synthesizeSegments(segments: string[], options: SynthesisOptions,
 	options = extendDeep(defaultSynthesisOptions, options)
 
 	if (!options.language && !options.voice) {
-		logger.start('No language or voice specified. Detecting language')
+		logger.start('No language or voice specified. Detect language')
 
 		let segmentsPlainText = segments
 

package/src/synthesis/EspeakTTS.ts

@@ -26,7 +26,7 @@ export async function preprocessAndSynthesize(text: string, language: string, es
 
 	let lowerCaseLanguageCode = language.toLowerCase()
 
-	if (lowerCaseLanguageCode == 'en-gb') {
+	if (lowerCaseLanguageCode === 'en-gb') {
 		lowerCaseLanguageCode = 'en-gb-x-rp'
 	}
 
@@ -44,9 +44,9 @@ export async function preprocessAndSynthesize(text: string, language: string, es
 
 	for (let i = 0; i < words.length; i++) {
 		const currentWord = words[i]
-		const previousWord = words[i-1]
+		const previousWord = words[i - 1]
 
-		if (i > 0 && currentWord == previousWord && !wordCharacterPattern.test(currentWord)) {
+		if (i > 0 && currentWord === previousWord && !wordCharacterPattern.test(currentWord)) {
 			wordsWithMerges[wordsWithMerges.length - 1] += currentWord
 		} else {
 			wordsWithMerges.push(currentWord)
@@ -144,7 +144,7 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 
 	//fragments = fragments.filter(fragment => fragment.trim() != '')
 
-	if (fragments.length == 0) {
+	if (fragments.length === 0) {
 		return {
 			rawAudio: getEmptyRawAudio(1, sampleRate),
 			timeline: [] as Timeline,
@@ -152,7 +152,13 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 		}
 	}
 
-	let textWithMarkers = '() '
+	let textWithMarkers: string
+
+	if (espeakOptions.insertSeparators) {
+		textWithMarkers = `() | `
+	} else {
+		textWithMarkers = `() `
+	}
 
 	for (let i = 0; i < fragments.length; i++) {
 		let fragment = fragments[i]
@@ -180,6 +186,21 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 
 	const { rawAudio, events } = await synthesize(textWithMarkers, { ...espeakOptions, ssml: true })
 
+	// Add first marker if missing
+	if (fragments.length > 0) {
+		const firstMarkerEvent = events.find(event => event.type === 'mark')
+
+		if (firstMarkerEvent && firstMarkerEvent.id === 'e-0') {
+			events.unshift({
+				type: 'mark',
+				text_position: 0,
+				word_length: 0,
+				audio_position: 0,
+				id: 's-0',
+			})
+		}
+	}
+
 	// Build word timeline from events
 	const wordTimeline: Timeline = fragments.map(word => ({
 		type: 'word',
@@ -210,16 +231,16 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 		const currentPhoneTimeline = currentTokenEntry.timeline!
 		const lastPhoneEntry = currentPhoneTimeline[currentPhoneTimeline.length - 1]
 
-		if (lastPhoneEntry && lastPhoneEntry.endTime == -1) {
+		if (lastPhoneEntry && lastPhoneEntry.endTime === -1) {
 			lastPhoneEntry.endTime = eventTime
 		}
 
-		if (event.type == 'word') {
-			if (!event.id || currentPhoneTimeline.length == 0) {
+		if (event.type === 'word') {
+			if (!event.id || currentPhoneTimeline.length === 0) {
 				continue
 			}
 
-			if (currentTokenEntry.endTime == -1) {
+			if (currentTokenEntry.endTime === -1) {
 				currentTokenEntry.endTime = eventTime
 			}
 
@@ -230,7 +251,7 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 				endTime: -1,
 				timeline: []
 			})
-		} else if (event.type == 'phoneme') {
+		} else if (event.type === 'phoneme') {
 			const phoneText = event.id as string
 
 			if (!phoneText || phoneText.startsWith('(')) {
@@ -246,7 +267,7 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 
 			currentTokenEntry.text += phoneText
 			currentTokenEntry.startTime = currentPhoneTimeline[0].startTime
-		} else if (event.type == 'mark') {
+		} else if (event.type === 'mark') {
 			const markerName = event.id! as string
 
 			if (markerName.startsWith('s-')) {
@@ -276,13 +297,13 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 
 				wordIndex += 1
 
-				if (wordIndex == wordTimeline.length) {
+				if (wordIndex === wordTimeline.length) {
 					break
 				}
 			} else {
 				continue
 			}
-		} else if (event.type == 'end') {
+		} else if (event.type === 'end') {
 			clauseEndIndexes.push(wordIndex)
 		}
 	}
@@ -293,11 +314,11 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 	for (const [index, wordEntry] of wordTimeline.entries()) {
 		const tokenTimeline = wordEntry.timeline
 
-		if (index == 0) {
+		if (index === 0) {
 			continue
 		}
 
-		if (!tokenTimeline || tokenTimeline.length == 0) {
+		if (!tokenTimeline || tokenTimeline.length === 0) {
 			throw new Error('Unexpected: token timeline should exist and have at least one token')
 		}
 
@@ -309,7 +330,7 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 
 		const wordReferenceIPA = wordReferencePhonemes.join(' ')
 
-		if (wordReferenceIPA.trim().length == 0) {
+		if (wordReferenceIPA.trim().length === 0) {
 			continue
 		}
 
@@ -382,7 +403,7 @@ export async function synthesizeFragments(fragments: string[], espeakOptions: Es
 
 		for (let entryIndex = clauseStartIndex; entryIndex <= clauseEndIndex && entryIndex < wordTimeline.length; entryIndex++) {
 			const wordEntry = wordTimeline[entryIndex]
-			if (newClause.startTime == -1) {
+			if (newClause.startTime === -1) {
 				newClause.startTime = wordEntry.startTime
 			}
 
@@ -438,7 +459,7 @@ export async function synthesize(text: string, espeakOptions: EspeakOptions) {
 		}
 
 		for (const event of events) {
-			if (event.type == 'word') {
+			if (event.type === 'word') {
 				const textPosition = event.text_position - 1;
 				(event as any)['text'] = text.substring(textPosition, textPosition + event.word_length)
 			}

package/src/utilities/Compression.ts

@@ -110,3 +110,18 @@ export async function getDeflateCompressionMetricsForString(str: string) {
 		ratio: originalStringBytes.length / compressedStringBytes.length
 	}
 }
+
+export function computeDeltas(data: Float32Array) {
+	const deltas = new Float32Array(data.length)
+
+	let val = 0
+
+	for (let i = 0; i < data.length; i++) {
+		const delta = Math.floor(data[i] - val)
+		deltas[i] = delta
+
+		val += delta
+	}
+
+	return deltas
+}

package/src/utilities/LEB128.ts

@@ -0,0 +1,237 @@
+import { logToStderr } from "./Utilities.js"
+
+////////////////////////////////////////////////////////////////////////////////////
+// Encode
+////////////////////////////////////////////////////////////////////////////////////
+export function encodeSignedInt32(value: number, outEncodedData: number[]) {
+	if (value < -2147483648 || value > 2147483647) {
+		throw new Error('Value must be between -2147483648 and 2147483647')
+	}
+
+	while (true) {
+		const lowest7Bits = value & 127
+
+		value >>= 7
+
+		if (
+			(value === 0 && (lowest7Bits & 64) === 0) ||
+			(value === -1 && (lowest7Bits & 64) !== 0)) {
+			outEncodedData.push(lowest7Bits)
+
+			return outEncodedData
+		} else {
+			outEncodedData.push(lowest7Bits | 128)
+		}
+	}
+}
+
+export function encodeSignedInt32sFast(value: number, outEncodedData: number[]) {
+	const absValue = Math.abs(value)
+	//const absMask = value >> 31
+	//const absValue = (value ^ absMask) - absMask
+
+	if (absValue < (2 ** 6)) {
+		outEncodedData.push(
+			(value & 127)
+		)
+	} else if (absValue < (2 ** 13)) {
+		outEncodedData.push(
+			(value & 127) | 128,
+			(value >> 7) & 127
+		)
+	} else if (absValue < (2 ** 20)) {
+		outEncodedData.push(
+			(value & 127) | 128,
+			((value >> 7) & 127) | 128,
+			(value >> 14) & 127
+		)
+	} else if (absValue < (2 ** 27)) {
+		outEncodedData.push(
+			(value & 127) | 128,
+			((value >> 7) & 127) | 128,
+			((value >> 14) & 127) | 128,
+			(value >> 21) & 127
+		)
+	} else if (value < (2 ** 31) && value >= -(2 ** 31)) {
+		outEncodedData.push(
+			(value & 127) | 128,
+			((value >> 7) & 127) | 128,
+			((value >> 14) & 127) | 128,
+			((value >> 21) & 127) | 128,
+			(value >> 28) & 127
+		)
+	} else {
+		throw new Error(`Value must be between -2147483648 and 2147483647`)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Decode
+////////////////////////////////////////////////////////////////////////////////////
+export function decodeSignedInt32s(encodedData: ArrayLike<number>, outDecodedValues: number[]) {
+	for (let readIndex = 0; readIndex < encodedData.length;) {
+		let currentDecodedValue = 0
+		let shiftAmount = 0
+
+		while (true) {
+			const encodedByte = encodedData[readIndex++]
+			const lowest7Bits = encodedByte & 127
+
+			currentDecodedValue |= lowest7Bits << shiftAmount
+
+			// If 8th bit is 0, then this is the last byte in the sequence
+			if ((encodedByte & 128) === 0) {
+				// If 7th bit is 1, then the value is negative
+				if ((encodedByte & 64) !== 0) {
+					// If the value should be negative
+					// Ensure that the value is encoded as a negative number by
+					// setting all higher bits to 1
+					currentDecodedValue |= -1 << Math.min(shiftAmount + 7, 31)
+				}
+
+				break
+			}
+
+			if (readIndex === encodedData.length) {
+				throw new Error(`Invalid LEB128 data. Last encoded byte sequence is truncated.`)
+			}
+
+			shiftAmount += 7
+
+			if (shiftAmount > 31) {
+				throw new Error(`LEB128 sequence can't be decoded. Byte sequence extends beyond the range of a signed 32 bit integer.`)
+			}
+		}
+
+		outDecodedValues.push(currentDecodedValue)
+	}
+
+	return outDecodedValues
+}
+
+export function decodeSignedInt32sFast(encodedData: ArrayLike<number>, outDecodedValues: number[]) {
+	for (let readIndex = 0; readIndex < encodedData.length;) {
+		const byte0 = encodedData[readIndex++]
+
+		if ((byte0 & 128) === 0) {
+			let decodedValue =
+				(byte0 & 127)
+
+			if ((byte0 & 64) !== 0) {
+				decodedValue |= -1 << 7
+			}
+
+			outDecodedValues.push(decodedValue)
+
+			continue
+		}
+
+		const byte1 = encodedData[readIndex++]
+
+		if ((byte1 & 128) === 0) {
+			let decodedValue =
+				(byte0 & 127) |
+				(byte1 & 127) << 7
+
+			if ((byte1 & 64) !== 0) {
+				decodedValue |= -1 << 14
+			}
+
+			outDecodedValues.push(decodedValue)
+
+			continue
+		}
+
+		const byte2 = encodedData[readIndex++]
+
+		if ((byte2 & 128) === 0) {
+			let decodedValue =
+				(byte0 & 127) |
+				(byte1 & 127) << 7 |
+				(byte2 & 127) << 14
+
+			if ((byte2 & 64) !== 0) {
+				decodedValue |= -1 << 21
+			}
+
+			outDecodedValues.push(decodedValue)
+
+			continue
+		}
+
+		const byte3 = encodedData[readIndex++]
+
+		if ((byte3 & 128) === 0) {
+			let decodedValue =
+				(byte0 & 127) |
+				(byte1 & 127) << 7 |
+				(byte2 & 127) << 14 |
+				(byte3 & 127) << 21
+
+			if ((byte3 & 64) !== 0) {
+				decodedValue |= -1 << 28
+			}
+
+			outDecodedValues.push(decodedValue)
+
+			continue
+		}
+
+		const byte4 = encodedData[readIndex++]
+
+		if ((byte4 & 128) === 0) {
+			let decodedValue =
+				(byte0 & 127) |
+				(byte1 & 127) << 7 |
+				(byte2 & 127) << 14 |
+				(byte3 & 127) << 21 |
+				(byte4 & 127) << 28
+
+			if ((byte4 & 64) !== 0) {
+				decodedValue |= -1 << 31
+			}
+
+			outDecodedValues.push(decodedValue)
+
+			continue
+		}
+
+		if (readIndex >= encodedData.length) {
+			throw new Error(`Invalid LEB128 data. Last encoded byte sequence is truncated.`)
+		} else {
+			throw new Error(`LEB128 sequence can't be decoded. Encoded byte sequence represents a value that extends beyond the range of a signed 32 bit integer.`)
+		}
+	}
+
+	return outDecodedValues
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////////////////
+export function testLeb128() {
+	const encodedBytes: number[] = []
+	const decodedValues: number[] = []
+
+	function runTest(testValue: number) {
+		encodedBytes.length = 0
+		decodedValues.length = 0
+
+		encodeSignedInt32sFast(testValue, encodedBytes)
+		decodeSignedInt32sFast(encodedBytes, decodedValues)
+
+		if (decodedValues[0] !== testValue) {
+			throw new Error(`Expected ${testValue} but got ${decodedValues[0]}`)
+		}
+	}
+
+	for (let i = -(2 ** 22); i < 2 ** 22; i++) {
+		if (i % 1000000 === 0) {
+			logToStderr(i)
+		}
+
+		runTest(i)
+	}
+
+	const x = 1
+}