Add WebAssembly for SenseVoice (#1158)

wasm/asr/sherpa-onnx-asr.js

@@ -39,6 +39,10 @@ function freeConfig(config, Module) {
     freeConfig(config.tdnn, Module)
   }
 
+  if ('senseVoice' in config) {
+    freeConfig(config.senseVoice, Module)
+  }
+
   if ('lm' in config) {
     freeConfig(config.lm, Module)
   }
@@ -52,9 +56,9 @@ function freeConfig(config, Module) {
 
 // The user should free the returned pointers
 function initSherpaOnnxOnlineTransducerModelConfig(config, Module) {
-  const encoderLen = Module.lengthBytesUTF8(config.encoder) + 1;
-  const decoderLen = Module.lengthBytesUTF8(config.decoder) + 1;
-  const joinerLen = Module.lengthBytesUTF8(config.joiner) + 1;
+  const encoderLen = Module.lengthBytesUTF8(config.encoder || '') + 1;
+  const decoderLen = Module.lengthBytesUTF8(config.decoder || '') + 1;
+  const joinerLen = Module.lengthBytesUTF8(config.joiner || '') + 1;
 
   const n = encoderLen + decoderLen + joinerLen;
 
@@ -64,13 +68,13 @@ function initSherpaOnnxOnlineTransducerModelConfig(config, Module) {
   const ptr = Module._malloc(len);
 
   let offset = 0;
-  Module.stringToUTF8(config.encoder, buffer + offset, encoderLen);
+  Module.stringToUTF8(config.encoder || '', buffer + offset, encoderLen);
   offset += encoderLen;
 
-  Module.stringToUTF8(config.decoder, buffer + offset, decoderLen);
+  Module.stringToUTF8(config.decoder || '', buffer + offset, decoderLen);
   offset += decoderLen;
 
-  Module.stringToUTF8(config.joiner, buffer + offset, joinerLen);
+  Module.stringToUTF8(config.joiner || '', buffer + offset, joinerLen);
 
   offset = 0;
   Module.setValue(ptr, buffer + offset, 'i8*');
@@ -87,8 +91,8 @@ function initSherpaOnnxOnlineTransducerModelConfig(config, Module) {
 }
 
 function initSherpaOnnxOnlineParaformerModelConfig(config, Module) {
-  const encoderLen = Module.lengthBytesUTF8(config.encoder) + 1;
-  const decoderLen = Module.lengthBytesUTF8(config.decoder) + 1;
+  const encoderLen = Module.lengthBytesUTF8(config.encoder || '') + 1;
+  const decoderLen = Module.lengthBytesUTF8(config.decoder || '') + 1;
 
   const n = encoderLen + decoderLen;
   const buffer = Module._malloc(n);
@@ -97,10 +101,10 @@ function initSherpaOnnxOnlineParaformerModelConfig(config, Module) {
   const ptr = Module._malloc(len);
 
   let offset = 0;
-  Module.stringToUTF8(config.encoder, buffer + offset, encoderLen);
+  Module.stringToUTF8(config.encoder || '', buffer + offset, encoderLen);
   offset += encoderLen;
 
-  Module.stringToUTF8(config.decoder, buffer + offset, decoderLen);
+  Module.stringToUTF8(config.decoder || '', buffer + offset, decoderLen);
 
   offset = 0;
   Module.setValue(ptr, buffer + offset, 'i8*');
@@ -114,13 +118,13 @@ function initSherpaOnnxOnlineParaformerModelConfig(config, Module) {
 }
 
 function initSherpaOnnxOnlineZipformer2CtcModelConfig(config, Module) {
-  const n = Module.lengthBytesUTF8(config.model) + 1;
+  const n = Module.lengthBytesUTF8(config.model || '') + 1;
   const buffer = Module._malloc(n);
 
   const len = 1 * 4;  // 1 pointer
   const ptr = Module._malloc(len);
 
-  Module.stringToUTF8(config.model, buffer, n);
+  Module.stringToUTF8(config.model || '', buffer, n);
 
   Module.setValue(ptr, buffer, 'i8*');
 
@@ -130,10 +134,33 @@ function initSherpaOnnxOnlineZipformer2CtcModelConfig(config, Module) {
 }
 
 function initSherpaOnnxOnlineModelConfig(config, Module) {
+  if (!('transducer' in config)) {
+    config.transducer = {
+      encoder: '',
+      decoder: '',
+      joiner: '',
+    };
+  }
+
+  if (!('paraformer' in config)) {
+    config.paraformer = {
+      encoder: '',
+      decoder: '',
+    };
+  }
+
+  if (!('zipformer2Ctc' in config)) {
+    config.zipformer2Ctc = {
+      model: '',
+    };
+  }
+
   const transducer =
       initSherpaOnnxOnlineTransducerModelConfig(config.transducer, Module);
+
   const paraformer =
       initSherpaOnnxOnlineParaformerModelConfig(config.paraformer, Module);
+
   const ctc = initSherpaOnnxOnlineZipformer2CtcModelConfig(
       config.zipformer2Ctc, Module);
 
@@ -150,9 +177,9 @@ function initSherpaOnnxOnlineModelConfig(config, Module) {
   Module._CopyHeap(ctc.ptr, ctc.len, ptr + offset);
   offset += ctc.len;
 
-  const tokensLen = Module.lengthBytesUTF8(config.tokens) + 1;
-  const providerLen = Module.lengthBytesUTF8(config.provider) + 1;
-  const modelTypeLen = Module.lengthBytesUTF8(config.modelType) + 1;
+  const tokensLen = Module.lengthBytesUTF8(config.tokens || '') + 1;
+  const providerLen = Module.lengthBytesUTF8(config.provider || 'cpu') + 1;
+  const modelTypeLen = Module.lengthBytesUTF8(config.modelType || '') + 1;
   const modelingUnitLen = Module.lengthBytesUTF8(config.modelingUnit || '') + 1;
   const bpeVocabLen = Module.lengthBytesUTF8(config.bpeVocab || '') + 1;
 
@@ -161,13 +188,13 @@ function initSherpaOnnxOnlineModelConfig(config, Module) {
   const buffer = Module._malloc(bufferLen);
 
   offset = 0;
-  Module.stringToUTF8(config.tokens, buffer, tokensLen);
+  Module.stringToUTF8(config.tokens || '', buffer, tokensLen);
   offset += tokensLen;
 
-  Module.stringToUTF8(config.provider, buffer + offset, providerLen);
+  Module.stringToUTF8(config.provider || 'cpu', buffer + offset, providerLen);
   offset += providerLen;
 
-  Module.stringToUTF8(config.modelType, buffer + offset, modelTypeLen);
+  Module.stringToUTF8(config.modelType || '', buffer + offset, modelTypeLen);
   offset += modelTypeLen;
 
   Module.stringToUTF8(
@@ -181,13 +208,13 @@ function initSherpaOnnxOnlineModelConfig(config, Module) {
   Module.setValue(ptr + offset, buffer, 'i8*');  // tokens
   offset += 4;
 
-  Module.setValue(ptr + offset, config.numThreads, 'i32');
+  Module.setValue(ptr + offset, config.numThreads || 1, 'i32');
   offset += 4;
 
   Module.setValue(ptr + offset, buffer + tokensLen, 'i8*');  // provider
   offset += 4;
 
-  Module.setValue(ptr + offset, config.debug, 'i32');
+  Module.setValue(ptr + offset, config.debug || 0, 'i32');
   offset += 4;
 
   Module.setValue(
@@ -215,8 +242,8 @@ function initSherpaOnnxFeatureConfig(config, Module) {
   const len = 2 * 4;  // 2 pointers
   const ptr = Module._malloc(len);
 
-  Module.setValue(ptr, config.sampleRate, 'i32');
-  Module.setValue(ptr + 4, config.featureDim, 'i32');
+  Module.setValue(ptr, config.sampleRate || 16000, 'i32');
+  Module.setValue(ptr + 4, config.featureDim || 80, 'i32');
   return {ptr: ptr, len: len};
 }
 
@@ -224,16 +251,30 @@ function initSherpaOnnxOnlineCtcFstDecoderConfig(config, Module) {
   const len = 2 * 4;
   const ptr = Module._malloc(len);
 
-  const graphLen = Module.lengthBytesUTF8(config.graph) + 1;
+  const graphLen = Module.lengthBytesUTF8(config.graph || '') + 1;
   const buffer = Module._malloc(graphLen);
   Module.stringToUTF8(config.graph, buffer, graphLen);
 
   Module.setValue(ptr, buffer, 'i8*');
-  Module.setValue(ptr + 4, config.maxActive, 'i32');
+  Module.setValue(ptr + 4, config.maxActive || 3000, 'i32');
   return {ptr: ptr, len: len, buffer: buffer};
 }
 
 function initSherpaOnnxOnlineRecognizerConfig(config, Module) {
+  if (!('featConfig' in config)) {
+    config.featConfig = {
+      sampleRate: 16000,
+      featureDim: 80,
+    };
+  }
+
+  if (!('ctcFstDecoderConfig' in config)) {
+    config.ctcFstDecoderConfig = {
+      graph: '',
+      maxActive: 3000,
+    };
+  }
+
   const feat = initSherpaOnnxFeatureConfig(config.featConfig, Module);
   const model = initSherpaOnnxOnlineModelConfig(config.modelConfig, Module);
   const ctcFstDecoder = initSherpaOnnxOnlineCtcFstDecoderConfig(
@@ -249,8 +290,9 @@ function initSherpaOnnxOnlineRecognizerConfig(config, Module) {
   Module._CopyHeap(model.ptr, model.len, ptr + offset);
   offset += model.len;
 
-  const decodingMethodLen = Module.lengthBytesUTF8(config.decodingMethod) + 1;
-  const hotwordsFileLen = Module.lengthBytesUTF8(config.hotwordsFile) + 1;
+  const decodingMethodLen =
+      Module.lengthBytesUTF8(config.decodingMethod || 'greedy_search') + 1;
+  const hotwordsFileLen = Module.lengthBytesUTF8(config.hotwordsFile || '') + 1;
   const ruleFstsFileLen = Module.lengthBytesUTF8(config.ruleFsts || '') + 1;
   const ruleFarsFileLen = Module.lengthBytesUTF8(config.ruleFars || '') + 1;
   const bufferLen =
@@ -258,10 +300,12 @@ function initSherpaOnnxOnlineRecognizerConfig(config, Module) {
   const buffer = Module._malloc(bufferLen);
 
   offset = 0;
-  Module.stringToUTF8(config.decodingMethod, buffer, decodingMethodLen);
+  Module.stringToUTF8(
+      config.decodingMethod || 'greedy_search', buffer, decodingMethodLen);
   offset += decodingMethodLen;
 
-  Module.stringToUTF8(config.hotwordsFile, buffer + offset, hotwordsFileLen);
+  Module.stringToUTF8(
+      config.hotwordsFile || '', buffer + offset, hotwordsFileLen);
   offset += hotwordsFileLen;
 
   Module.stringToUTF8(config.ruleFsts || '', buffer + offset, ruleFstsFileLen);
@@ -274,25 +318,25 @@ function initSherpaOnnxOnlineRecognizerConfig(config, Module) {
   Module.setValue(ptr + offset, buffer, 'i8*');  // decoding method
   offset += 4;
 
-  Module.setValue(ptr + offset, config.maxActivePaths, 'i32');
+  Module.setValue(ptr + offset, config.maxActivePaths || 4, 'i32');
   offset += 4;
 
-  Module.setValue(ptr + offset, config.enableEndpoint, 'i32');
+  Module.setValue(ptr + offset, config.enableEndpoint || 0, 'i32');
   offset += 4;
 
-  Module.setValue(ptr + offset, config.rule1MinTrailingSilence, 'float');
+  Module.setValue(ptr + offset, config.rule1MinTrailingSilence || 2.4, 'float');
   offset += 4;
 
-  Module.setValue(ptr + offset, config.rule2MinTrailingSilence, 'float');
+  Module.setValue(ptr + offset, config.rule2MinTrailingSilence || 1.2, 'float');
   offset += 4;
 
-  Module.setValue(ptr + offset, config.rule3MinUtteranceLength, 'float');
+  Module.setValue(ptr + offset, config.rule3MinUtteranceLength || 20, 'float');
   offset += 4;
 
   Module.setValue(ptr + offset, buffer + decodingMethodLen, 'i8*');
   offset += 4;
 
-  Module.setValue(ptr + offset, config.hotwordsScore, 'float');
+  Module.setValue(ptr + offset, config.hotwordsScore || 1.5, 'float');
   offset += 4;
 
   Module._CopyHeap(ctcFstDecoder.ptr, ctcFstDecoder.len, ptr + offset);
@@ -313,7 +357,6 @@ function initSherpaOnnxOnlineRecognizerConfig(config, Module) {
   }
 }
 
-
 function createOnlineRecognizer(Module, myConfig) {
   const onlineTransducerModelConfig = {
     encoder: '',
@@ -395,9 +438,9 @@ function createOnlineRecognizer(Module, myConfig) {
 }
 
 function initSherpaOnnxOfflineTransducerModelConfig(config, Module) {
-  const encoderLen = Module.lengthBytesUTF8(config.encoder) + 1;
-  const decoderLen = Module.lengthBytesUTF8(config.decoder) + 1;
-  const joinerLen = Module.lengthBytesUTF8(config.joiner) + 1;
+  const encoderLen = Module.lengthBytesUTF8(config.encoder || '') + 1;
+  const decoderLen = Module.lengthBytesUTF8(config.decoder || '') + 1;
+  const joinerLen = Module.lengthBytesUTF8(config.joiner || '') + 1;
 
   const n = encoderLen + decoderLen + joinerLen;
 
@@ -407,13 +450,13 @@ function initSherpaOnnxOfflineTransducerModelConfig(config, Module) {
   const ptr = Module._malloc(len);
 
   let offset = 0;
-  Module.stringToUTF8(config.encoder, buffer + offset, encoderLen);
+  Module.stringToUTF8(config.encoder || '', buffer + offset, encoderLen);
   offset += encoderLen;
 
-  Module.stringToUTF8(config.decoder, buffer + offset, decoderLen);
+  Module.stringToUTF8(config.decoder || '', buffer + offset, decoderLen);
   offset += decoderLen;
 
-  Module.stringToUTF8(config.joiner, buffer + offset, joinerLen);
+  Module.stringToUTF8(config.joiner || '', buffer + offset, joinerLen);
 
   offset = 0;
   Module.setValue(ptr, buffer + offset, 'i8*');
@@ -430,14 +473,14 @@ function initSherpaOnnxOfflineTransducerModelConfig(config, Module) {
 }
 
 function initSherpaOnnxOfflineParaformerModelConfig(config, Module) {
-  const n = Module.lengthBytesUTF8(config.model) + 1;
+  const n = Module.lengthBytesUTF8(config.model || '') + 1;
 
   const buffer = Module._malloc(n);
 
   const len = 1 * 4;  // 1 pointer
   const ptr = Module._malloc(len);
 
-  Module.stringToUTF8(config.model, buffer, n);
+  Module.stringToUTF8(config.model || '', buffer, n);
 
   Module.setValue(ptr, buffer, 'i8*');
 
@@ -447,14 +490,14 @@ function initSherpaOnnxOfflineParaformerModelConfig(config, Module) {
 }
 
 function initSherpaOnnxOfflineNemoEncDecCtcModelConfig(config, Module) {
-  const n = Module.lengthBytesUTF8(config.model) + 1;
+  const n = Module.lengthBytesUTF8(config.model || '') + 1;
 
   const buffer = Module._malloc(n);
 
   const len = 1 * 4;  // 1 pointer
   const ptr = Module._malloc(len);
 
-  Module.stringToUTF8(config.model, buffer, n);
+  Module.stringToUTF8(config.model || '', buffer, n);
 
   Module.setValue(ptr, buffer, 'i8*');
 
@@ -464,10 +507,10 @@ function initSherpaOnnxOfflineNemoEncDecCtcModelConfig(config, Module) {
 }
 
 function initSherpaOnnxOfflineWhisperModelConfig(config, Module) {
-  const encoderLen = Module.lengthBytesUTF8(config.encoder) + 1;
-  const decoderLen = Module.lengthBytesUTF8(config.decoder) + 1;
-  const languageLen = Module.lengthBytesUTF8(config.language) + 1;
-  const taskLen = Module.lengthBytesUTF8(config.task) + 1;
+  const encoderLen = Module.lengthBytesUTF8(config.encoder || '') + 1;
+  const decoderLen = Module.lengthBytesUTF8(config.decoder || '') + 1;
+  const languageLen = Module.lengthBytesUTF8(config.language || '') + 1;
+  const taskLen = Module.lengthBytesUTF8(config.task || '') + 1;
 
   const n = encoderLen + decoderLen + languageLen + taskLen;
   const buffer = Module._malloc(n);
@@ -476,16 +519,16 @@ function initSherpaOnnxOfflineWhisperModelConfig(config, Module) {
   const ptr = Module._malloc(len);
 
   let offset = 0;
-  Module.stringToUTF8(config.encoder, buffer + offset, encoderLen);
+  Module.stringToUTF8(config.encoder || '', buffer + offset, encoderLen);
   offset += encoderLen;
 
-  Module.stringToUTF8(config.decoder, buffer + offset, decoderLen);
+  Module.stringToUTF8(config.decoder || '', buffer + offset, decoderLen);
   offset += decoderLen;
 
-  Module.stringToUTF8(config.language, buffer + offset, languageLen);
+  Module.stringToUTF8(config.language || '', buffer + offset, languageLen);
   offset += languageLen;
 
-  Module.stringToUTF8(config.task, buffer + offset, taskLen);
+  Module.stringToUTF8(config.task || '', buffer + offset, taskLen);
 
   offset = 0;
   Module.setValue(ptr, buffer + offset, 'i8*');
@@ -508,13 +551,13 @@ function initSherpaOnnxOfflineWhisperModelConfig(config, Module) {
 }
 
 function initSherpaOnnxOfflineTdnnModelConfig(config, Module) {
-  const n = Module.lengthBytesUTF8(config.model) + 1;
+  const n = Module.lengthBytesUTF8(config.model || '') + 1;
   const buffer = Module._malloc(n);
 
   const len = 1 * 4;  // 1 pointer
   const ptr = Module._malloc(len);
 
-  Module.stringToUTF8(config.model, buffer, n);
+  Module.stringToUTF8(config.model || '', buffer, n);
 
   Module.setValue(ptr, buffer, 'i8*');
 
@@ -523,16 +566,48 @@ function initSherpaOnnxOfflineTdnnModelConfig(config, Module) {
   }
 }
 
+function initSherpaOnnxOfflineSenseVoiceModelConfig(config, Module) {
+  const modelLen = Module.lengthBytesUTF8(config.model || '') + 1;
+  const languageLen = Module.lengthBytesUTF8(config.language || '') + 1;
+
+  // useItn is a integer with 4 bytes
+  const n = modelLen + languageLen;
+  const buffer = Module._malloc(n);
+
+  const len = 3 * 4;  // 2 pointers + 1 int
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  Module.stringToUTF8(config.model || '', buffer + offset, modelLen);
+  offset += modelLen;
+
+  Module.stringToUTF8(config.language || '', buffer + offset, languageLen);
+  offset += languageLen;
+
+  offset = 0;
+  Module.setValue(ptr, buffer + offset, 'i8*');
+  offset += modelLen;
+
+  Module.setValue(ptr + 4, buffer + offset, 'i8*');
+  offset += languageLen;
+
+  Module.setValue(ptr + 8, config.useInverseTextNormalization || 0, 'i32');
+
+  return {
+    buffer: buffer, ptr: ptr, len: len,
+  }
+}
+
 function initSherpaOnnxOfflineLMConfig(config, Module) {
-  const n = Module.lengthBytesUTF8(config.model) + 1;
+  const n = Module.lengthBytesUTF8(config.model || '') + 1;
   const buffer = Module._malloc(n);
 
   const len = 2 * 4;
   const ptr = Module._malloc(len);
 
-  Module.stringToUTF8(config.model, buffer, n);
+  Module.stringToUTF8(config.model || '', buffer, n);
   Module.setValue(ptr, buffer, 'i8*');
-  Module.setValue(ptr + 4, config.scale, 'float');
+  Module.setValue(ptr + 4, config.scale || 1, 'float');
 
   return {
     buffer: buffer, ptr: ptr, len: len,
@@ -540,18 +615,70 @@ function initSherpaOnnxOfflineLMConfig(config, Module) {
 }
 
 function initSherpaOnnxOfflineModelConfig(config, Module) {
+  if (!('transducer' in config)) {
+    config.transducer = {
+      encoder: '',
+      decoder: '',
+      joiner: '',
+    };
+  }
+
+  if (!('paraformer' in config)) {
+    config.paraformer = {
+      model: '',
+    };
+  }
+
+  if (!('nemoCtc' in config)) {
+    config.nemoCtc = {
+      model: '',
+    };
+  }
+
+  if (!('whisper' in config)) {
+    config.whisper = {
+      encoder: '',
+      decoder: '',
+      language: '',
+      task: '',
+      tailPaddings: -1,
+    };
+  }
+
+  if (!('tdnn' in config)) {
+    config.tdnn = {
+      model: '',
+    };
+  }
+
+  if (!('senseVoice' in config)) {
+    config.senseVoice = {
+      model: '',
+      language: '',
+      useInverseTextNormalization: 0,
+    };
+  }
+
   const transducer =
       initSherpaOnnxOfflineTransducerModelConfig(config.transducer, Module);
+
   const paraformer =
       initSherpaOnnxOfflineParaformerModelConfig(config.paraformer, Module);
+
   const nemoCtc =
       initSherpaOnnxOfflineNemoEncDecCtcModelConfig(config.nemoCtc, Module);
+
   const whisper =
       initSherpaOnnxOfflineWhisperModelConfig(config.whisper, Module);
+
   const tdnn = initSherpaOnnxOfflineTdnnModelConfig(config.tdnn, Module);
 
+  const senseVoice =
+      initSherpaOnnxOfflineSenseVoiceModelConfig(config.senseVoice, Module);
+
   const len = transducer.len + paraformer.len + nemoCtc.len + whisper.len +
-      tdnn.len + 8 * 4;
+      tdnn.len + 8 * 4 + senseVoice.len;
+
   const ptr = Module._malloc(len);
 
   let offset = 0;
@@ -570,9 +697,10 @@ function initSherpaOnnxOfflineModelConfig(config, Module) {
   Module._CopyHeap(tdnn.ptr, tdnn.len, ptr + offset);
   offset += tdnn.len;
 
-  const tokensLen = Module.lengthBytesUTF8(config.tokens) + 1;
-  const providerLen = Module.lengthBytesUTF8(config.provider) + 1;
-  const modelTypeLen = Module.lengthBytesUTF8(config.modelType) + 1;
+
+  const tokensLen = Module.lengthBytesUTF8(config.tokens || '') + 1;
+  const providerLen = Module.lengthBytesUTF8(config.provider || 'cpu') + 1;
+  const modelTypeLen = Module.lengthBytesUTF8(config.modelType || '') + 1;
   const modelingUnitLen = Module.lengthBytesUTF8(config.modelingUnit || '') + 1;
   const bpeVocabLen = Module.lengthBytesUTF8(config.bpeVocab || '') + 1;
   const teleSpeechCtcLen =
@@ -580,16 +708,17 @@ function initSherpaOnnxOfflineModelConfig(config, Module) {
 
   const bufferLen = tokensLen + providerLen + modelTypeLen + modelingUnitLen +
       bpeVocabLen + teleSpeechCtcLen;
+
   const buffer = Module._malloc(bufferLen);
 
   offset = 0;
   Module.stringToUTF8(config.tokens, buffer, tokensLen);
   offset += tokensLen;
 
-  Module.stringToUTF8(config.provider, buffer + offset, providerLen);
+  Module.stringToUTF8(config.provider || 'cpu', buffer + offset, providerLen);
   offset += providerLen;
 
-  Module.stringToUTF8(config.modelType, buffer + offset, modelTypeLen);
+  Module.stringToUTF8(config.modelType || '', buffer + offset, modelTypeLen);
   offset += modelTypeLen;
 
   Module.stringToUTF8(
@@ -608,10 +737,10 @@ function initSherpaOnnxOfflineModelConfig(config, Module) {
   Module.setValue(ptr + offset, buffer, 'i8*');  // tokens
   offset += 4;
 
-  Module.setValue(ptr + offset, config.numThreads, 'i32');
+  Module.setValue(ptr + offset, config.numThreads || 1, 'i32');
   offset += 4;
 
-  Module.setValue(ptr + offset, config.debug, 'i32');
+  Module.setValue(ptr + offset, config.debug || 0, 'i32');
   offset += 4;
 
   Module.setValue(ptr + offset, buffer + tokensLen, 'i8*');  // provider
@@ -639,13 +768,30 @@ function initSherpaOnnxOfflineModelConfig(config, Module) {
       'i8*');  // teleSpeechCtc
   offset += 4;
 
+  Module._CopyHeap(senseVoice.ptr, senseVoice.len, ptr + offset);
+
   return {
     buffer: buffer, ptr: ptr, len: len, transducer: transducer,
-        paraformer: paraformer, nemoCtc: nemoCtc, whisper: whisper, tdnn: tdnn
+        paraformer: paraformer, nemoCtc: nemoCtc, whisper: whisper, tdnn: tdnn,
+        senseVoice: senseVoice,
   }
 }
 
 function initSherpaOnnxOfflineRecognizerConfig(config, Module) {
+  if (!('featConfig' in config)) {
+    config.featConfig = {
+      sampleRate: 16000,
+      featureDim: 80,
+    };
+  }
+
+  if (!('lmConfig' in config)) {
+    config.lmConfig = {
+      model: '',
+      scale: 1.0,
+    };
+  }
+
   const feat = initSherpaOnnxFeatureConfig(config.featConfig, Module);
   const model = initSherpaOnnxOfflineModelConfig(config.modelConfig, Module);
   const lm = initSherpaOnnxOfflineLMConfig(config.lmConfig, Module);
@@ -663,8 +809,9 @@ function initSherpaOnnxOfflineRecognizerConfig(config, Module) {
   Module._CopyHeap(lm.ptr, lm.len, ptr + offset);
   offset += lm.len;
 
-  const decodingMethodLen = Module.lengthBytesUTF8(config.decodingMethod) + 1;
-  const hotwordsFileLen = Module.lengthBytesUTF8(config.hotwordsFile) + 1;
+  const decodingMethodLen =
+      Module.lengthBytesUTF8(config.decodingMethod || 'greedy_search') + 1;
+  const hotwordsFileLen = Module.lengthBytesUTF8(config.hotwordsFile || '') + 1;
   const ruleFstsLen = Module.lengthBytesUTF8(config.ruleFsts || '') + 1;
   const ruleFarsLen = Module.lengthBytesUTF8(config.ruleFars || '') + 1;
   const bufferLen =
@@ -672,10 +819,12 @@ function initSherpaOnnxOfflineRecognizerConfig(config, Module) {
   const buffer = Module._malloc(bufferLen);
 
   offset = 0;
-  Module.stringToUTF8(config.decodingMethod, buffer, decodingMethodLen);
+  Module.stringToUTF8(
+      config.decodingMethod || 'greedy_search', buffer, decodingMethodLen);
   offset += decodingMethodLen;
 
-  Module.stringToUTF8(config.hotwordsFile, buffer + offset, hotwordsFileLen);
+  Module.stringToUTF8(
+      config.hotwordsFile || '', buffer + offset, hotwordsFileLen);
   offset += hotwordsFileLen;
 
   Module.stringToUTF8(config.ruleFsts || '', buffer + offset, ruleFstsLen);
@@ -689,13 +838,13 @@ function initSherpaOnnxOfflineRecognizerConfig(config, Module) {
   Module.setValue(ptr + offset, buffer, 'i8*');  // decoding method
   offset += 4;
 
-  Module.setValue(ptr + offset, config.maxActivePaths, 'i32');
+  Module.setValue(ptr + offset, config.maxActivePaths || 4, 'i32');
   offset += 4;
 
   Module.setValue(ptr + offset, buffer + decodingMethodLen, 'i8*');
   offset += 4;
 
-  Module.setValue(ptr + offset, config.hotwordsScore, 'float');
+  Module.setValue(ptr + offset, config.hotwordsScore || 1.5, 'float');
   offset += 4;
 
   Module.setValue(

wasm/nodejs/sherpa-onnx-wasm-nodejs.cc

@@ -16,6 +16,7 @@ static_assert(sizeof(SherpaOnnxOfflineParaformerModelConfig) == 4, "");
 static_assert(sizeof(SherpaOnnxOfflineNemoEncDecCtcModelConfig) == 4, "");
 static_assert(sizeof(SherpaOnnxOfflineWhisperModelConfig) == 5 * 4, "");
 static_assert(sizeof(SherpaOnnxOfflineTdnnModelConfig) == 4, "");
+static_assert(sizeof(SherpaOnnxOfflineSenseVoiceModelConfig) == 3 * 4, "");
 static_assert(sizeof(SherpaOnnxOfflineLMConfig) == 2 * 4, "");
 
 static_assert(sizeof(SherpaOnnxOfflineModelConfig) ==
@@ -23,7 +24,8 @@ static_assert(sizeof(SherpaOnnxOfflineModelConfig) ==
                       sizeof(SherpaOnnxOfflineParaformerModelConfig) +
                       sizeof(SherpaOnnxOfflineNemoEncDecCtcModelConfig) +
                       sizeof(SherpaOnnxOfflineWhisperModelConfig) +
-                      sizeof(SherpaOnnxOfflineTdnnModelConfig) + 8 * 4,
+                      sizeof(SherpaOnnxOfflineTdnnModelConfig) + 8 * 4 +
+                      sizeof(SherpaOnnxOfflineSenseVoiceModelConfig),
               "");
 static_assert(sizeof(SherpaOnnxFeatureConfig) == 2 * 4, "");
 static_assert(sizeof(SherpaOnnxOfflineRecognizerConfig) ==
@@ -63,6 +65,7 @@ void PrintOfflineRecognizerConfig(SherpaOnnxOfflineRecognizerConfig *config) {
   auto nemo_ctc = &model_config->nemo_ctc;
   auto whisper = &model_config->whisper;
   auto tdnn = &model_config->tdnn;
+  auto sense_voice = &model_config->sense_voice;
 
   fprintf(stdout, "----------offline transducer model config----------\n");
   fprintf(stdout, "encoder: %s\n", transducer->encoder);
@@ -85,6 +88,11 @@ void PrintOfflineRecognizerConfig(SherpaOnnxOfflineRecognizerConfig *config) {
   fprintf(stdout, "----------offline tdnn model config----------\n");
   fprintf(stdout, "model: %s\n", tdnn->model);
 
+  fprintf(stdout, "----------offline sense_voice model config----------\n");
+  fprintf(stdout, "model: %s\n", sense_voice->model);
+  fprintf(stdout, "language: %s\n", sense_voice->language);
+  fprintf(stdout, "use_itn: %d\n", sense_voice->use_itn);
+
   fprintf(stdout, "tokens: %s\n", model_config->tokens);
   fprintf(stdout, "num_threads: %d\n", model_config->num_threads);
   fprintf(stdout, "provider: %s\n", model_config->provider);

wasm/tts/sherpa-onnx-tts.js

@@ -14,14 +14,10 @@ function freeConfig(config, Module) {
 // The user should free the returned pointers
 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;
-
-  if (!('dictDir' in config)) {
-    config.dictDir = ''
-  }
-  const dictDirLen = Module.lengthBytesUTF8(config.dictDir) + 1;
+  const lexiconLen = Module.lengthBytesUTF8(config.lexicon || '') + 1;
+  const tokensLen = Module.lengthBytesUTF8(config.tokens || '') + 1;
+  const dataDirLen = Module.lengthBytesUTF8(config.dataDir || '') + 1;
+  const dictDirLen = Module.lengthBytesUTF8(config.dictDir || '') + 1;
 
   const n = modelLen + lexiconLen + tokensLen + dataDirLen + dictDirLen;
 
@@ -31,19 +27,19 @@ function initSherpaOnnxOfflineTtsVitsModelConfig(config, Module) {
   const ptr = Module._malloc(len);
 
   let offset = 0;
-  Module.stringToUTF8(config.model, buffer + offset, modelLen);
+  Module.stringToUTF8(config.model || '', buffer + offset, modelLen);
   offset += modelLen;
 
-  Module.stringToUTF8(config.lexicon, buffer + offset, lexiconLen);
+  Module.stringToUTF8(config.lexicon || '', buffer + offset, lexiconLen);
   offset += lexiconLen;
 
-  Module.stringToUTF8(config.tokens, buffer + offset, tokensLen);
+  Module.stringToUTF8(config.tokens || '', buffer + offset, tokensLen);
   offset += tokensLen;
 
-  Module.stringToUTF8(config.dataDir, buffer + offset, dataDirLen);
+  Module.stringToUTF8(config.dataDir || '', buffer + offset, dataDirLen);
   offset += dataDirLen;
 
-  Module.stringToUTF8(config.dictDir, buffer + offset, dictDirLen);
+  Module.stringToUTF8(config.dictDir || '', buffer + offset, dictDirLen);
   offset += dictDirLen;
 
   offset = 0;
@@ -59,9 +55,9 @@ function initSherpaOnnxOfflineTtsVitsModelConfig(config, Module) {
   Module.setValue(ptr + 12, buffer + offset, 'i8*');
   offset += dataDirLen;
 
-  Module.setValue(ptr + 16, config.noiseScale, 'float');
-  Module.setValue(ptr + 20, config.noiseScaleW, 'float');
-  Module.setValue(ptr + 24, config.lengthScale, 'float');
+  Module.setValue(ptr + 16, config.noiseScale || 0.667, 'float');
+  Module.setValue(ptr + 20, config.noiseScaleW || 0.8, 'float');
+  Module.setValue(ptr + 24, config.lengthScale || 1.0, 'float');
   Module.setValue(ptr + 28, buffer + offset, 'i8*');
   offset += dictDirLen;
 
@@ -81,13 +77,13 @@ function initSherpaOnnxOfflineTtsModelConfig(config, Module) {
   Module._CopyHeap(vitsModelConfig.ptr, vitsModelConfig.len, ptr + offset);
   offset += vitsModelConfig.len;
 
-  Module.setValue(ptr + offset, config.numThreads, 'i32');
+  Module.setValue(ptr + offset, config.numThreads || 1, 'i32');
   offset += 4;
 
-  Module.setValue(ptr + offset, config.debug, 'i32');
+  Module.setValue(ptr + offset, config.debug || 0, 'i32');
   offset += 4;
 
-  const providerLen = Module.lengthBytesUTF8(config.provider) + 1;
+  const providerLen = Module.lengthBytesUTF8(config.provider || 'cpu') + 1;
   const buffer = Module._malloc(providerLen);
   Module.stringToUTF8(config.provider, buffer, providerLen);
   Module.setValue(ptr + offset, buffer, 'i8*');
@@ -107,17 +103,17 @@ function initSherpaOnnxOfflineTtsConfig(config, Module) {
   Module._CopyHeap(modelConfig.ptr, modelConfig.len, ptr + offset);
   offset += modelConfig.len;
 
-  const ruleFstsLen = Module.lengthBytesUTF8(config.ruleFsts) + 1;
-  const ruleFarsLen = Module.lengthBytesUTF8(config.ruleFars) + 1;
+  const ruleFstsLen = Module.lengthBytesUTF8(config.ruleFsts || '') + 1;
+  const ruleFarsLen = Module.lengthBytesUTF8(config.ruleFars || '') + 1;
 
   const buffer = Module._malloc(ruleFstsLen + ruleFarsLen);
-  Module.stringToUTF8(config.ruleFsts, buffer, ruleFstsLen);
-  Module.stringToUTF8(config.ruleFars, buffer + ruleFstsLen, ruleFarsLen);
+  Module.stringToUTF8(config.ruleFsts || '', buffer, ruleFstsLen);
+  Module.stringToUTF8(config.ruleFars || '', buffer + ruleFstsLen, ruleFarsLen);
 
   Module.setValue(ptr + offset, buffer, 'i8*');
   offset += 4;
 
-  Module.setValue(ptr + offset, config.maxNumSentences, 'i32');
+  Module.setValue(ptr + offset, config.maxNumSentences || 1, 'i32');
   offset += 4;
 
   Module.setValue(ptr + offset, buffer + ruleFstsLen, 'i8*');