Kokoro: chunk generation, add pre-process func #3412

1b817cd89747f2d1ffda68dfe63d36c25f777395

Cohee <18619528+Cohee1207@users.noreply.github.com>

public/scripts/extensions/tts/kokoro.js+49 -23 Viewed

 import { debounce_timeout } from '../../constants.js';
 import { debounceAsync, splitRecursive } from '../../utils.js';
 import { getPreviewString, saveTtsProviderSettings } from './index.js';
 export class KokoroTtsProvider {

         this.initTtsDebounced = debounceAsync(this.initializeWorker.bind(this), debounce_timeout.relaxed);
+    }
 +    /**
 +     * Perform any text processing before passing to TTS engine.
 +     * @param {string} text Input text
 +     * @returns {string} Processed text
 +     */
 +    processText(text) {
 +        // TILDE!
 +        text = text.replace(/~/g, '.');
 +        return text;
 +    }
++
     async loadSettings(settings) {
         if (settings.modelId !== undefined) this.settings.modelId = settings.modelId;
         if (settings.dtype !== undefined) this.settings.dtype = settings.dtype;

         const voice = this.getVoice(voiceId);
         const previewText = getPreviewString(voice.lang);
         for await (const response = awaitof this.generateTts(previewText, voiceId);) {
                     const audio = await response.blob();
                     const url = URL.createObjectURL(audio);
 -        const audioElement = new Audio();
 +            await new Promise(resolve => {
 -        audioElement.src = url;
 +                const audioElement = new Audio();
 -        audioElement.play();
 +                audioElement.src = url;
 -        audioElement.onended = () => URL.revokeObjectURL(url);
 +                audioElement.play();
 +                audioElement.onended = () => resolve();
 +            });
 +            URL.revokeObjectURL(url);
 +        }
+    }
     getVoiceDisplayName(voiceId) {

         };
+    }
 -    async generateTts(text, voiceId) {
 +    /**
 +     * Generate TTS audio for the given text using the specified voice.
 +     * @param {string} text Text to generate
 +     * @param {string} voiceId Voice ID
 +     * @returns {AsyncGenerator<Response>} Audio response generator
 +     */
 +    async* generateTts(text, voiceId) {
         if (!this.ready || !this.worker) {
             console.log('TTS not ready, initializing...');
             await this.initializeWorker();

         const voice = this.getVoice(voiceId);
         const requestId = this.nextRequestId++;
 -        return new Promise((resolve, reject) => {
 +        const chunkSize = 400;
 -            // Store the promise callbacks
 +        const chunks = splitRecursive(text, chunkSize, ['\n\n', '\n', '.', '?', '!', ',', ' ', '']);
 -            this.pendingRequests.set(requestId, { resolve, reject });
++
+-
 +        for (const chunk of chunks) {
 -            // Send the request to the worker
 +            yield await new Promise((resolve, reject) => {
 -            this.worker.postMessage({
 +                // Store the promise callbacks
 -                action: 'generateTts',
 +                this.pendingRequests.set(requestId, { resolve, reject });
 -                data: {
++
 -                    text,
 +                // Send the request to the worker
 -                    voice: voice.voice_id,
 +                this.worker.postMessage({
 -                    speakingRate: this.settings.speakingRate || 1.0,
 +                    action: 'generateTts',
 -                    requestId,
 +                    data: {
 -                },
 +                        text: chunk,
 +                        voice: voice.voice_id,
 +                        speakingRate: this.settings.speakingRate || 1.0,
 +                        requestId,
 +                    },
 +                });
             });
         });
+    }
     dispose() {

public/scripts/utils.js+4 -0 Viewed

     return result;
+}
 +export function splitSentences(input, length) {
 +    var pattRegex = new RegExp(`^[\\s\\S]{${Math.floor(length / 2)},${length}}[.!?,]{1}|^[\\s\\S]{1,${length}}$|^[\\s\\S]{1,${length}}`);
 +}
++
 /**
  * Checks if a string is a valid data URL.
  * @param {string} str The string to check.