update model

app-tts.js

@@ -22,7 +22,7 @@ Module.onRuntimeInitialized = function() {
   console.log('Model files downloaded!');
 
   console.log('Initializing tts ......');
-  tts = initSherpaOnnxOfflineTts()
+  tts = createOfflineTts(Module)
   if (tts.numSpeakers > 1) {
     speakerIdLabel.innerHTML = `Speaker ID (0 - ${tts.numSpeakers - 1}):`;
   }

sherpa-onnx-tts.js

@@ -1,109 +1,109 @@
 
-function freeConfig(config) {
+function freeConfig(config, Module) {
   if ('buffer' in config) {
-    _free(config.buffer);
+    Module._free(config.buffer);
   }
 
   if ('config' in config) {
-    freeConfig(config.config)
+    freeConfig(config.config, Module)
   }
 
-  _free(config.ptr);
+  Module._free(config.ptr);
 }
 
 // The user should free the returned pointers
-function initSherpaOnnxOfflineTtsVitsModelConfig(config) {
-  let modelLen = lengthBytesUTF8(config.model) + 1;
-  let lexiconLen = lengthBytesUTF8(config.lexicon) + 1;
-  let tokensLen = lengthBytesUTF8(config.tokens) + 1;
-  let dataDirLen = lengthBytesUTF8(config.dataDir) + 1;
+function initSherpaOnnxOfflineTtsVitsModelConfig(config, Module) {
+  const modelLen = Module.lengthBytesUTF8(config.model) + 1;
+  const lexiconLen = Module.lengthBytesUTF8(config.lexicon) + 1;
+  const tokensLen = Module.lengthBytesUTF8(config.tokens) + 1;
+  const dataDirLen = Module.lengthBytesUTF8(config.dataDir) + 1;
 
-  let n = modelLen + lexiconLen + tokensLen + dataDirLen;
+  const n = modelLen + lexiconLen + tokensLen + dataDirLen;
 
-  let buffer = _malloc(n);
+  const buffer = Module._malloc(n);
 
-  let len = 7 * 4;
-  let ptr = _malloc(len);
+  const len = 7 * 4;
+  const ptr = Module._malloc(len);
 
   let offset = 0;
-  stringToUTF8(config.model, buffer + offset, modelLen);
+  Module.stringToUTF8(config.model, buffer + offset, modelLen);
   offset += modelLen;
 
-  stringToUTF8(config.lexicon, buffer + offset, lexiconLen);
+  Module.stringToUTF8(config.lexicon, buffer + offset, lexiconLen);
   offset += lexiconLen;
 
-  stringToUTF8(config.tokens, buffer + offset, tokensLen);
+  Module.stringToUTF8(config.tokens, buffer + offset, tokensLen);
   offset += tokensLen;
 
-  stringToUTF8(config.dataDir, buffer + offset, dataDirLen);
+  Module.stringToUTF8(config.dataDir, buffer + offset, dataDirLen);
   offset += dataDirLen;
 
   offset = 0;
-  setValue(ptr, buffer + offset, 'i8*');
+  Module.setValue(ptr, buffer + offset, 'i8*');
   offset += modelLen;
 
-  setValue(ptr + 4, buffer + offset, 'i8*');
+  Module.setValue(ptr + 4, buffer + offset, 'i8*');
   offset += lexiconLen;
 
-  setValue(ptr + 8, buffer + offset, 'i8*');
+  Module.setValue(ptr + 8, buffer + offset, 'i8*');
   offset += tokensLen;
 
-  setValue(ptr + 12, buffer + offset, 'i8*');
+  Module.setValue(ptr + 12, buffer + offset, 'i8*');
   offset += dataDirLen;
 
-  setValue(ptr + 16, config.noiseScale, 'float');
-  setValue(ptr + 20, config.noiseScaleW, 'float');
-  setValue(ptr + 24, config.lengthScale, 'float');
+  Module.setValue(ptr + 16, config.noiseScale, 'float');
+  Module.setValue(ptr + 20, config.noiseScaleW, 'float');
+  Module.setValue(ptr + 24, config.lengthScale, 'float');
 
   return {
     buffer: buffer, ptr: ptr, len: len,
   }
 }
 
-function initSherpaOnnxOfflineTtsModelConfig(config) {
-  let vitsModelConfig =
-      initSherpaOnnxOfflineTtsVitsModelConfig(config.offlineTtsVitsModelConfig);
+function initSherpaOnnxOfflineTtsModelConfig(config, Module) {
+  const vitsModelConfig = initSherpaOnnxOfflineTtsVitsModelConfig(
+      config.offlineTtsVitsModelConfig, Module);
 
-  let len = vitsModelConfig.len + 3 * 4;
-  let ptr = _malloc(len);
+  const len = vitsModelConfig.len + 3 * 4;
+  const ptr = Module._malloc(len);
 
   let offset = 0;
-  _CopyHeap(vitsModelConfig.ptr, vitsModelConfig.len, ptr + offset);
+  Module._CopyHeap(vitsModelConfig.ptr, vitsModelConfig.len, ptr + offset);
   offset += vitsModelConfig.len;
 
-  setValue(ptr + offset, config.numThreads, 'i32');
+  Module.setValue(ptr + offset, config.numThreads, 'i32');
   offset += 4;
 
-  setValue(ptr + offset, config.debug, 'i32');
+  Module.setValue(ptr + offset, config.debug, 'i32');
   offset += 4;
 
-  let providerLen = lengthBytesUTF8(config.provider) + 1;
-  let buffer = _malloc(providerLen);
-  stringToUTF8(config.provider, buffer, providerLen);
-  setValue(ptr + offset, buffer, 'i8*');
+  const providerLen = Module.lengthBytesUTF8(config.provider) + 1;
+  const buffer = Module._malloc(providerLen);
+  Module.stringToUTF8(config.provider, buffer, providerLen);
+  Module.setValue(ptr + offset, buffer, 'i8*');
 
   return {
     buffer: buffer, ptr: ptr, len: len, config: vitsModelConfig,
   }
 }
 
-function initSherpaOnnxOfflineTtsConfig(config) {
-  let modelConfig =
-      initSherpaOnnxOfflineTtsModelConfig(config.offlineTtsModelConfig);
-  let len = modelConfig.len + 2 * 4;
-  let ptr = _malloc(len);
+function initSherpaOnnxOfflineTtsConfig(config, Module) {
+  const modelConfig =
+      initSherpaOnnxOfflineTtsModelConfig(config.offlineTtsModelConfig, Module);
+  const len = modelConfig.len + 2 * 4;
+  const ptr = Module._malloc(len);
 
   let offset = 0;
-  _CopyHeap(modelConfig.ptr, modelConfig.len, ptr + offset);
+  Module._CopyHeap(modelConfig.ptr, modelConfig.len, ptr + offset);
   offset += modelConfig.len;
 
-  let ruleFstsLen = lengthBytesUTF8(config.ruleFsts) + 1;
-  let buffer = _malloc(ruleFstsLen);
-  stringToUTF8(config.ruleFsts, buffer, ruleFstsLen);
-  setValue(ptr + offset, buffer, 'i8*');
+  const ruleFstsLen = Module.lengthBytesUTF8(config.ruleFsts) + 1;
+  const buffer = Module._malloc(ruleFstsLen);
+  Module.stringToUTF8(config.ruleFsts, buffer, ruleFstsLen);
+  Module.setValue(ptr + offset, buffer, 'i8*');
   offset += 4;
 
-  setValue(ptr + offset, config.maxNumSentences, 'i32');
+  Module.setValue(ptr + offset, config.maxNumSentences, 'i32');
 
   return {
     buffer: buffer, ptr: ptr, len: len, config: modelConfig,
@@ -111,19 +111,21 @@ function initSherpaOnnxOfflineTtsConfig(config) {
 }
 
 class OfflineTts {
-  constructor(configObj) {
-    let config = initSherpaOnnxOfflineTtsConfig(configObj)
-    let handle = _SherpaOnnxCreateOfflineTts(config.ptr);
+  constructor(configObj, Module) {
+    console.log(configObj)
+    const config = initSherpaOnnxOfflineTtsConfig(configObj, Module)
+    const handle = Module._SherpaOnnxCreateOfflineTts(config.ptr);
 
-    freeConfig(config);
+    freeConfig(config, Module);
 
     this.handle = handle;
-    this.sampleRate = _SherpaOnnxOfflineTtsSampleRate(this.handle);
-    this.numSpeakers = _SherpaOnnxOfflineTtsNumSpeakers(this.handle);
+    this.sampleRate = Module._SherpaOnnxOfflineTtsSampleRate(this.handle);
+    this.numSpeakers = Module._SherpaOnnxOfflineTtsNumSpeakers(this.handle);
+    this.Module = Module
   }
 
   free() {
-    _SherpaOnnxDestroyOfflineTts(this.handle);
+    this.Module._SherpaOnnxDestroyOfflineTts(this.handle);
     this.handle = 0
   }
 
@@ -133,29 +135,44 @@ class OfflineTts {
   //   speed: 1.0
   // }
   generate(config) {
-    let textLen = lengthBytesUTF8(config.text) + 1;
-    let textPtr = _malloc(textLen);
-    stringToUTF8(config.text, textPtr, textLen);
+    const textLen = this.Module.lengthBytesUTF8(config.text) + 1;
+    const textPtr = this.Module._malloc(textLen);
+    this.Module.stringToUTF8(config.text, textPtr, textLen);
 
-    let h = _SherpaOnnxOfflineTtsGenerate(
+    const h = this.Module._SherpaOnnxOfflineTtsGenerate(
         this.handle, textPtr, config.sid, config.speed);
 
-    let numSamples = HEAP32[h / 4 + 1];
-    let sampleRate = HEAP32[h / 4 + 2];
+    const numSamples = this.Module.HEAP32[h / 4 + 1];
+    const sampleRate = this.Module.HEAP32[h / 4 + 2];
 
-    let samplesPtr = HEAP32[h / 4] / 4;
-    let samples = new Float32Array(numSamples);
+    const samplesPtr = this.Module.HEAP32[h / 4] / 4;
+    const samples = new Float32Array(numSamples);
     for (let i = 0; i < numSamples; i++) {
-      samples[i] = HEAPF32[samplesPtr + i];
+      samples[i] = this.Module.HEAPF32[samplesPtr + i];
     }
 
-    _SherpaOnnxDestroyOfflineTtsGeneratedAudio(h);
+    this.Module._SherpaOnnxDestroyOfflineTtsGeneratedAudio(h);
     return {samples: samples, sampleRate: sampleRate};
   }
+  save(filename, audio) {
+    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];
+    }
+
+    const filenameLen = this.Module.lengthBytesUTF8(filename) + 1;
+    const buffer = this.Module._malloc(filenameLen);
+    this.Module.stringToUTF8(filename, buffer, filenameLen);
+    this.Module._SherpaOnnxWriteWave(ptr, samples.length, sampleRate, buffer);
+    this.Module._free(buffer);
+    this.Module._free(ptr);
+  }
 }
 
-function initSherpaOnnxOfflineTts() {
-  let offlineTtsVitsModelConfig = {
+function createOfflineTts(Module, myConfig) {
+  const offlineTtsVitsModelConfig = {
     model: './model.onnx',
     lexicon: '',
     tokens: './tokens.txt',
@@ -164,7 +181,7 @@ function initSherpaOnnxOfflineTts() {
     noiseScaleW: 0.8,
     lengthScale: 1.0,
   };
-  let offlineTtsModelConfig = {
+  const offlineTtsModelConfig = {
     offlineTtsVitsModelConfig: offlineTtsVitsModelConfig,
     numThreads: 1,
     debug: 1,
@@ -176,5 +193,16 @@ function initSherpaOnnxOfflineTts() {
     maxNumSentences: 1,
   }
 
-  return new OfflineTts(offlineTtsConfig);
+  if (myConfig) {
+    offlineTtsConfig = myConfig;
+  }
+
+  return new OfflineTts(offlineTtsConfig, Module);
+}
+
+if (typeof process == 'object' && typeof process.versions == 'object' &&
+    typeof process.versions.node == 'string') {
+  module.exports = {
+    createOfflineTts,
+  };
 }