update model

sherpa-onnx-tts.js

@@ -28,7 +28,13 @@ function freeConfig(config, Module) {
     freeConfig(config.pocket, Module)
   }
 
-  Module._free(config.ptr);
+  if ('supertonic' in config) {
+    freeConfig(config.supertonic, Module)
+  }
+
+  if (config.ptr) {
+    Module._free(config.ptr);
+  }
 }
 
 // The user should free the returned pointers
@@ -405,8 +411,91 @@ function initSherpaOnnxOfflineTtsPocketModelConfig(config, Module) {
 
   Module.setValue(ptr + 6 * 4, buffer + offset, 'i8*');
   offset += tokenScoresJsonLen;
-  
-  Module.setValue(ptr + 7 * 4, config.voiceEmbeddingCacheCapacity !== undefined ? config.voiceEmbeddingCacheCapacity : 50, 'i32');
+
+  Module.setValue(
+      ptr + 7 * 4,
+      config.voiceEmbeddingCacheCapacity !== undefined ?
+          config.voiceEmbeddingCacheCapacity :
+          50,
+      'i32');
+
+  return {
+    buffer: buffer,
+    ptr: ptr,
+    len: len,
+  };
+}
+
+function initSherpaOnnxOfflineTtsSupertonicModelConfig(config, Module) {
+  const durationPredictorLen =
+      Module.lengthBytesUTF8(config.durationPredictor || '') + 1;
+  const textEncoderLen =
+      Module.lengthBytesUTF8(config.textEncoder || '') + 1;
+  const vectorEstimatorLen =
+      Module.lengthBytesUTF8(config.vectorEstimator || '') + 1;
+  const vocoderLen = Module.lengthBytesUTF8(config.vocoder || '') + 1;
+  const ttsJsonLen = Module.lengthBytesUTF8(config.ttsJson || '') + 1;
+  const unicodeIndexerLen =
+      Module.lengthBytesUTF8(config.unicodeIndexer || '') + 1;
+  const voiceStyleLen =
+      Module.lengthBytesUTF8(config.voiceStyle || '') + 1;
+
+  const n = durationPredictorLen + textEncoderLen + vectorEstimatorLen +
+      vocoderLen + ttsJsonLen + unicodeIndexerLen + voiceStyleLen;
+
+  const buffer = Module._malloc(n);
+
+  const len = 7 * 4;
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  Module.stringToUTF8(
+      config.durationPredictor || '', buffer + offset, durationPredictorLen);
+  offset += durationPredictorLen;
+
+  Module.stringToUTF8(
+      config.textEncoder || '', buffer + offset, textEncoderLen);
+  offset += textEncoderLen;
+
+  Module.stringToUTF8(
+      config.vectorEstimator || '', buffer + offset, vectorEstimatorLen);
+  offset += vectorEstimatorLen;
+
+  Module.stringToUTF8(config.vocoder || '', buffer + offset, vocoderLen);
+  offset += vocoderLen;
+
+  Module.stringToUTF8(config.ttsJson || '', buffer + offset, ttsJsonLen);
+  offset += ttsJsonLen;
+
+  Module.stringToUTF8(
+      config.unicodeIndexer || '', buffer + offset, unicodeIndexerLen);
+  offset += unicodeIndexerLen;
+
+  Module.stringToUTF8(
+      config.voiceStyle || '', buffer + offset, voiceStyleLen);
+  offset += voiceStyleLen;
+
+  offset = 0;
+  Module.setValue(ptr + 0 * 4, buffer + offset, 'i8*');
+  offset += durationPredictorLen;
+
+  Module.setValue(ptr + 1 * 4, buffer + offset, 'i8*');
+  offset += textEncoderLen;
+
+  Module.setValue(ptr + 2 * 4, buffer + offset, 'i8*');
+  offset += vectorEstimatorLen;
+
+  Module.setValue(ptr + 3 * 4, buffer + offset, 'i8*');
+  offset += vocoderLen;
+
+  Module.setValue(ptr + 4 * 4, buffer + offset, 'i8*');
+  offset += ttsJsonLen;
+
+  Module.setValue(ptr + 5 * 4, buffer + offset, 'i8*');
+  offset += unicodeIndexerLen;
+
+  Module.setValue(ptr + 6 * 4, buffer + offset, 'i8*');
+  offset += voiceStyleLen;
 
   return {
     buffer: buffer,
@@ -489,6 +578,17 @@ function initSherpaOnnxOfflineTtsModelConfig(config, Module) {
     };
   }
 
+  if (!('offlineTtsSupertonicModelConfig' in config)) {
+    config.offlineTtsSupertonicModelConfig = {
+      durationPredictor: '',
+      textEncoder: '',
+      vectorEstimator: '',
+      vocoder: '',
+      ttsJson: '',
+      unicodeIndexer: '',
+      voiceStyle: '',
+    };
+  }
 
   const vitsModelConfig = initSherpaOnnxOfflineTtsVitsModelConfig(
       config.offlineTtsVitsModelConfig, Module);
@@ -508,9 +608,12 @@ function initSherpaOnnxOfflineTtsModelConfig(config, Module) {
   const pocketModelConfig = initSherpaOnnxOfflineTtsPocketModelConfig(
       config.offlineTtsPocketModelConfig, Module);
 
+  const supertonicModelConfig = initSherpaOnnxOfflineTtsSupertonicModelConfig(
+      config.offlineTtsSupertonicModelConfig, Module);
+
   const len = vitsModelConfig.len + matchaModelConfig.len +
       kokoroModelConfig.len + kittenModelConfig.len + zipVoiceModelConfig.len +
-      pocketModelConfig.len + 3 * 4;
+      pocketModelConfig.len + supertonicModelConfig.len + 3 * 4;
 
   const ptr = Module._malloc(len);
 
@@ -546,6 +649,10 @@ function initSherpaOnnxOfflineTtsModelConfig(config, Module) {
   Module._CopyHeap(pocketModelConfig.ptr, pocketModelConfig.len, ptr + offset);
   offset += pocketModelConfig.len;
 
+  Module._CopyHeap(
+      supertonicModelConfig.ptr, supertonicModelConfig.len, ptr + offset);
+  offset += supertonicModelConfig.len;
+
   return {
     buffer: buffer,
     ptr: ptr,
@@ -556,6 +663,7 @@ function initSherpaOnnxOfflineTtsModelConfig(config, Module) {
     kitten: kittenModelConfig,
     zipvoice: zipVoiceModelConfig,
     pocket: pocketModelConfig,
+    supertonic: supertonicModelConfig,
   };
 }
 
@@ -615,9 +723,6 @@ function initSherpaOnnxGenerationConfig(config, Module) {
   const len = 9 * 4;
   const ptr = Module._malloc(len);
 
-  // Zero-init for safety
-  Module.HEAPU8.fill(0, ptr, ptr + len);
-
   // float silence_scale
   Module.setValue(ptr + 0 * 4, config.silenceScale || 0.2, 'float');
 
@@ -709,6 +814,8 @@ class OfflineTts {
   }
 
   free() {
+    if (!this.handle) return;
+
     this.Module._SherpaOnnxDestroyOfflineTts(this.handle);
     this.handle = 0
   }
@@ -719,27 +826,47 @@ class OfflineTts {
   //   speed: 1.0
   // }
   generate(config) {
+    if (!this.handle) {
+      throw new Error('OfflineTts has been freed');
+    }
+
+    if (!config || !config.text) {
+      throw new Error('config.text is required');
+    }
+
     const textLen = this.Module.lengthBytesUTF8(config.text) + 1;
     const textPtr = this.Module._malloc(textLen);
     this.Module.stringToUTF8(config.text, textPtr, textLen);
 
     const h = this.Module._SherpaOnnxOfflineTtsGenerate(
-        this.handle, textPtr, config.sid, config.speed);
+        this.handle, textPtr, config.sid ?? 0, config.speed ?? 1.0);
 
-    const numSamples = this.Module.HEAP32[h / 4 + 1];
-    const sampleRate = this.Module.HEAP32[h / 4 + 2];
+    this.Module._free(textPtr);
 
-    const samplesPtr = this.Module.HEAP32[h / 4] / 4;
-    const samples = new Float32Array(numSamples);
-    for (let i = 0; i < numSamples; i++) {
-      samples[i] = this.Module.HEAPF32[samplesPtr + i];
+    if (!h) {
+      throw new Error('TTS generation failed');
     }
 
+    const base = h / 4;
+
+    const samplesPtr = this.Module.HEAPU32[base];
+    const numSamples = this.Module.HEAP32[base + 1];
+    const sampleRate = this.Module.HEAP32[base + 2];
+
+    const heapSamples = this.Module.HEAPF32.subarray(
+        samplesPtr / 4, samplesPtr / 4 + numSamples);
+
+    const samples = new Float32Array(heapSamples);
+
     this.Module._SherpaOnnxDestroyOfflineTtsGeneratedAudio(h);
     return {samples: samples, sampleRate: sampleRate};
   }
 
   generateWithConfig(text, genConfig) {
+    if (!this.handle) {
+      throw new Error('OfflineTts has been freed');
+    }
+
     const cfgWasm = initSherpaOnnxGenerationConfig(genConfig, this.Module);
 
     const textLen = this.Module.lengthBytesUTF8(text) + 1;
@@ -751,28 +878,24 @@ class OfflineTts {
         0,  // callback
         0   // callback arg
     );
+    this.Module._free(textPtr);
+    freeSherpaOnnxGenerationConfig(cfgWasm, this.Module);
 
     if (!audioPtr) {
-      this.Module._free(textPtr);
-      freeSherpaOnnxGenerationConfig(cfgWasm, this.Module);
       throw new Error('Failed to generate audio');
     }
 
-    const samplesPtr = this.Module.HEAP32[audioPtr / 4];  // float* samples
-    const numSamples =
-        this.Module.HEAP32[audioPtr / 4 + 1];  // int32 num_samples
-    const sampleRate =
-        this.Module.HEAP32[audioPtr / 4 + 2];  // int32 sample_rate
+    const base = audioPtr / 4;
 
-    // 5️⃣ Copy samples to Float32Array
-    const samples = new Float32Array(numSamples);
-    for (let i = 0; i < numSamples; i++) {
-      samples[i] = this.Module.HEAPF32[samplesPtr / 4 + i];
-    }
+    const samplesPtr = this.Module.HEAPU32[base];     // float* samples
+    const numSamples = this.Module.HEAP32[base + 1];  // int32 num_samples
+    const sampleRate = this.Module.HEAP32[base + 2];  // int32 sample_rate
+
+    const heapSamples = this.Module.HEAPF32.subarray(
+        samplesPtr / 4, samplesPtr / 4 + numSamples);
+    const samples = new Float32Array(heapSamples);
 
     this.Module._SherpaOnnxDestroyOfflineTtsGeneratedAudio(audioPtr);
-    this.Module._free(textPtr);
-    freeSherpaOnnxGenerationConfig(cfgWasm, this.Module);
 
     return {samples, sampleRate};
   }
@@ -781,9 +904,8 @@ class OfflineTts {
     const samples = audio.samples;
     const sampleRate = audio.sampleRate;
     const ptr = this.Module._malloc(samples.length * 4);
-    for (let i = 0; i < samples.length; i++) {
-      this.Module.HEAPF32[ptr / 4 + i] = samples[i];
-    }
+
+    this.Module.HEAPF32.set(samples, ptr / 4);
 
     const filenameLen = this.Module.lengthBytesUTF8(filename) + 1;
     const buffer = this.Module._malloc(filenameLen);

sherpa-onnx-wasm-main-tts.wasm

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f39411c53164c66e47504532f6b19ffc7ab34be9df81b64dd27ac181d9bd7f43
-size 11900557
+oid sha256:20ec17318118c73835b33cf44ed73e34e368c612104e6a584bbd3ea565eb0750
+size 11964249