Upload 7 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+sherpa-onnx-wasm-main-tts.data filter=lfs diff=lfs merge=lfs -text

app-tts.js

@@ -0,0 +1,380 @@
+const generateBtn = document.getElementById('generateBtn');
+const speakerIdLabel = document.getElementById('speakerIdLabel');
+const speakerIdInput = document.getElementById('speakerId');
+const speakerIdSection = document.getElementById('speakerIdSection');
+const referenceAudioSection = document.getElementById('referenceAudioSection');
+const referenceTextSection = document.getElementById('referenceTextSection');
+const referenceAudioInput = document.getElementById('referenceAudio');
+const referenceTextInput = document.getElementById('referenceText');
+const speedInput = document.getElementById('speed');
+const speedValue = document.getElementById('speedValue');
+const textArea = document.getElementById('text');
+const soundClips = document.getElementById('sound-clips');
+const statusElement = document.getElementById('status');
+const generationStatusElement = document.getElementById('generationStatus');
+
+speedValue.innerHTML = speedInput.value;
+
+let index = 0;
+
+let audioCtx = null;
+const worker = new Worker("sherpa-onnx-tts.worker.js", { type: "module" });
+let ttsInstanceInfo = {
+  modelType: null,
+  numSpeakers: 0,
+  isReady: false,
+};
+worker.onmessage = (e) => {
+  if (e.data.type === "sherpa-onnx-tts-progress") {
+    Module.setStatus(e.data.status);
+    return;
+  }
+  if (e.data.type === "sherpa-onnx-tts-generation-progress") {
+    const percent = Math.max(0, Math.min(100, (e.data.progress || 0) * 100));
+    setGenerationStatus(`Generating audio... ${percent.toFixed(2)}%`);
+    return;
+  }
+  if (e.data.type === "sherpa-onnx-tts-ready") {
+    ttsInstanceInfo.modelType = e.data.modelType;
+    ttsInstanceInfo.numSpeakers = e.data.numSpeakers;
+    ttsInstanceInfo.isReady = true;
+    generateBtn.disabled = false;
+    speakerIdLabel.innerHTML = `Speaker ID (0 - ${e.data.numSpeakers - 1}):`;
+    updateUiForModelType();
+    Module.setStatus('');
+    return;
+  }
+  if (e.data.type === "error") {
+    generateBtn.disabled = false;
+    if (ttsInstanceInfo.isReady) {
+      setGenerationStatus(e.data.message);
+    } else {
+      Module.setStatus(e.data.message);
+    }
+    return;
+  }
+  if (e.data.type === "sherpa-onnx-tts-result") {
+    let audio = e.data;
+    generateBtn.disabled = false;
+    setGenerationStatus('');
+
+    console.log(audio.samples.length, audio.sampleRate);
+
+    if (!audioCtx) {
+      audioCtx = new AudioContext({ sampleRate: audio.sampleRate });
+    }
+
+    const buffer = audioCtx.createBuffer(
+      1,
+      audio.samples.length,
+      audio.sampleRate,
+    );
+
+    buffer.getChannelData(0).set(audio.samples); // 使用 .set() 比 for 循环快得多
+    const source = audioCtx.createBufferSource();
+    source.buffer = buffer;
+    source.connect(audioCtx.destination);
+    source.start();
+
+    createAudioTag(audio);
+  }
+};
+
+Module = {};
+
+// https://emscripten.org/docs/api_reference/module.html#Module.locateFile
+Module.setStatus = function(status) {
+  console.log(`status ${status}`);
+  if (status == 'Running...') {
+    status = 'Model downloaded. Initializing text to speech model...'
+  }
+
+  const downloadMatch = status.match(/Downloading data... \((\d+)\/(\d+)\)/);
+  if (downloadMatch) {
+    const downloaded = BigInt(downloadMatch[1]);
+    const total = BigInt(downloadMatch[2]);
+    const percent =
+        total === 0 ? 0.00 : Number((downloaded * 10000n) / total) / 100;
+    const downloadedMB = Number(downloaded) / (1024 * 1024);
+    const totalMB = Number(total) / (1024 * 1024);
+    status = `Downloading data... ${percent.toFixed(2)}% (${downloadedMB.toFixed(2)} MB/${
+        totalMB.toFixed(2)} MB)`;
+    console.log(`here ${status}`)
+  }
+
+  statusElement.textContent = status;
+  if (status === '') {
+    statusElement.style.display = 'none';
+    // statusElement.parentNode.removeChild(statusElement);
+
+    document.querySelectorAll('.tab-content').forEach((tabContentElement) => {
+      tabContentElement.classList.remove('loading');
+    });
+  } else {
+    statusElement.style.display = 'block';
+    document.querySelectorAll('.tab-content').forEach((tabContentElement) => {
+      tabContentElement.classList.add('loading');
+    });
+  }
+};
+speedInput.oninput = function() {
+  speedValue.innerHTML = this.value;
+};
+
+function updateUiForModelType() {
+  const isZipVoice = ttsInstanceInfo.modelType === 4;
+  const isPocketTts = ttsInstanceInfo.modelType === 5;
+  const useGenerationConfig = isZipVoice || isPocketTts;
+  speakerIdSection.classList.toggle('hidden', useGenerationConfig);
+  referenceAudioSection.classList.toggle('hidden', !useGenerationConfig);
+  referenceTextSection.classList.toggle('hidden', !isZipVoice);
+}
+
+function setGenerationStatus(status) {
+  if (!generationStatusElement) {
+    return;
+  }
+
+  generationStatusElement.textContent = status;
+  generationStatusElement.style.display = status ? 'block' : 'none';
+}
+
+function getMonoSamples(audioBuffer) {
+  if (audioBuffer.numberOfChannels === 1) {
+    return new Float32Array(audioBuffer.getChannelData(0));
+  }
+
+  const samples = new Float32Array(audioBuffer.length);
+  for (let c = 0; c < audioBuffer.numberOfChannels; ++c) {
+    const channel = audioBuffer.getChannelData(c);
+    for (let i = 0; i < channel.length; ++i) {
+      samples[i] += channel[i];
+    }
+  }
+
+  for (let i = 0; i < samples.length; ++i) {
+    samples[i] /= audioBuffer.numberOfChannels;
+  }
+
+  return samples;
+}
+
+async function readReferenceAudio(file) {
+  const arrayBuffer = await file.arrayBuffer();
+  const ctx = new AudioContext();
+  try {
+    const audioBuffer = await ctx.decodeAudioData(arrayBuffer.slice(0));
+    return {
+      samples: getMonoSamples(audioBuffer),
+      sampleRate: audioBuffer.sampleRate,
+    };
+  } finally {
+    await ctx.close();
+  }
+}
+
+function isWaveFile(file) {
+  const name = file.name || '';
+  return name.toLowerCase().endsWith('.wav');
+}
+
+function sanitizeFilename(name) {
+  return name.replace(/[^a-zA-Z0-9._-]+/g, '-');
+}
+
+function downloadBlob(blob, filename) {
+  const url = window.URL.createObjectURL(blob);
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  window.URL.revokeObjectURL(url);
+}
+
+generateBtn.onclick = async function() {
+  const isZipVoice = ttsInstanceInfo.modelType === 4;
+  const isPocketTts = ttsInstanceInfo.modelType === 5;
+  const useGenerationConfig = isZipVoice || isPocketTts;
+
+  let speakerId = speakerIdInput.value;
+  if (!useGenerationConfig) {
+    if (speakerId.trim().length == 0) {
+      alert('Please input a speakerId');
+      return;
+    }
+
+    if (!speakerId.match(/^\d+$/)) {
+      alert(`Input speakerID ${
+          speakerId} is not a number.\nPlease enter a number between 0 and ${
+          ttsInstanceInfo.numSpeakers - 1}`);
+      return;
+    }
+    speakerId = parseInt(speakerId, 10);
+    if (speakerId > ttsInstanceInfo.numSpeakers - 1) {
+      alert(`Pleaser enter a number between 0 and ${ttsInstanceInfo.numSpeakers - 1}`);
+      return;
+    }
+  }
+
+  let text = textArea.value.trim();
+  if (text.length == 0) {
+    alert('Please input a non-blank text');
+    return;
+  }
+
+  console.log('speakerId', speakerId);
+  console.log('speed', speedInput.value);
+  console.log('text', text);
+
+  if (useGenerationConfig) {
+    if (!referenceAudioInput.files || referenceAudioInput.files.length === 0) {
+      alert('Please select a reference audio file');
+      return;
+    }
+
+    const referenceFile = referenceAudioInput.files[0];
+    if (!isWaveFile(referenceFile)) {
+      alert('Please select a .wav reference audio file');
+      return;
+    }
+
+    const referenceAudio = await readReferenceAudio(referenceFile);
+    const genConfig = {
+      speed: parseFloat(speedInput.value),
+      referenceAudio: referenceAudio.samples,
+      referenceSampleRate: referenceAudio.sampleRate,
+      numSteps: isPocketTts ? 5 : 4,
+    };
+
+    if (isZipVoice) {
+      const referenceText = referenceTextInput.value.trim();
+      if (referenceText.length === 0) {
+        alert('Please input the transcript of the reference audio');
+        return;
+      }
+
+      genConfig.referenceText = referenceText;
+      genConfig.extra = {
+        min_char_in_sentence: 10,
+      };
+    }
+
+    generateBtn.disabled = true;
+    setGenerationStatus('Generating audio...');
+
+    worker.postMessage({
+      text,
+      genConfig,
+      type: "generateWithConfig",
+    }, [genConfig.referenceAudio.buffer]);
+    return;
+  }
+
+  worker.postMessage({
+    text,
+    sid: speakerId,
+    speed: parseFloat(speedInput.value),
+    type: "generate",
+  });
+};
+
+function createAudioTag(generateAudio) {
+  const blob = toWav(generateAudio.samples, generateAudio.sampleRate);
+
+  const text = textArea.value.trim().substring(0, 100);
+  const clipName = `${index} ${text} ...`;
+  const filename = `${sanitizeFilename(clipName)}.wav`;
+  index += 1;
+
+  const clipContainer = document.createElement('article');
+  const clipLabel = document.createElement('p');
+  const audio = document.createElement('audio');
+  const saveButton = document.createElement('button');
+  const deleteButton = document.createElement('button');
+  clipContainer.classList.add('clip');
+  audio.setAttribute('controls', '');
+  saveButton.textContent = 'Save';
+  saveButton.className = 'save';
+  deleteButton.textContent = 'Delete';
+  deleteButton.className = 'delete';
+
+  clipLabel.textContent = clipName;
+
+  clipContainer.appendChild(audio);
+
+  clipContainer.appendChild(clipLabel);
+  clipContainer.appendChild(saveButton);
+  clipContainer.appendChild(deleteButton);
+  soundClips.appendChild(clipContainer);
+
+  audio.controls = true;
+
+  const audioURL = window.URL.createObjectURL(blob);
+  audio.src = audioURL;
+
+  saveButton.onclick = function() {
+    downloadBlob(blob, filename);
+  };
+
+  deleteButton.onclick = function(e) {
+    let evtTgt = e.target;
+    evtTgt.parentNode.parentNode.removeChild(evtTgt.parentNode);
+  };
+
+  clipLabel.onclick = function() {
+    const existingName = clipLabel.textContent;
+    const newClipName = prompt('Enter a new name for your sound clip?');
+    if (newClipName === null) {
+      clipLabel.textContent = existingName;
+    } else {
+      clipLabel.textContent = newClipName;
+    }
+  };
+}
+
+// this function is copied/modified from
+// https://gist.github.com/meziantou/edb7217fddfbb70e899e
+function toWav(floatSamples, sampleRate) {
+  let samples = new Int16Array(floatSamples.length);
+  for (let i = 0; i < samples.length; ++i) {
+    let s = floatSamples[i];
+    if (s >= 1)
+      s = 1;
+    else if (s <= -1)
+      s = -1;
+
+    samples[i] = s * 32767;
+  }
+
+  let buf = new ArrayBuffer(44 + samples.length * 2);
+  var view = new DataView(buf);
+
+  // http://soundfile.sapp.org/doc/WaveFormat/
+  //                   F F I R
+  view.setUint32(0, 0x46464952, true);               // chunkID
+  view.setUint32(4, 36 + samples.length * 2, true);  // chunkSize
+  //                   E V A W
+  view.setUint32(8, 0x45564157, true);  // format
+                                        //
+  //                      t m f
+  view.setUint32(12, 0x20746d66, true);          // subchunk1ID
+  view.setUint32(16, 16, true);                  // subchunk1Size, 16 for PCM
+  view.setUint32(20, 1, true);                   // audioFormat, 1 for PCM
+  view.setUint16(22, 1, true);                   // numChannels: 1 channel
+  view.setUint32(24, sampleRate, true);          // sampleRate
+  view.setUint32(28, sampleRate * 2, true);      // byteRate
+  view.setUint16(32, 2, true);                   // blockAlign
+  view.setUint16(34, 16, true);                  // bitsPerSample
+  view.setUint32(36, 0x61746164, true);          // Subchunk2ID
+  view.setUint32(40, samples.length * 2, true);  // subchunk2Size
+
+  let offset = 44;
+  for (let i = 0; i < samples.length; ++i) {
+    view.setInt16(offset, samples[i], true);
+    offset += 2;
+  }
+
+  return new Blob([view], {type: 'audio/wav'});
+}

index.html

@@ -0,0 +1,100 @@
+<html lang="en">
+
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width" />
+  <title>Next-gen Kaldi WebAssembly with sherpa-onnx for Text-to-speech</title>
+  <style>
+    h1,div {
+      text-align: center;
+    }
+    textarea {
+      width:100%;
+    }
+    .loading {
+      display: none !important;
+    }
+    .hidden {
+      display: none !important;
+    }
+  </style>
+</head>
+
+<body style="font-family: 'Source Sans Pro', sans-serif; background-color: #f9fafb; color: #333; display: flex; flex-direction: column; align-items: center; height: 100vh; margin: 0;">
+  <h1>
+    Next-gen Kaldi + WebAssembly<br/>
+    Text-to-speech Demo with <a href="https://github.com/k2-fsa/sherpa-onnx">sherpa-onnx</a>
+  </h1>
+
+  <div style="width: 100%; max-width: 900px; background: #fff; padding: 1.5rem; border-radius: 8px; box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1); flex: 1;">
+    <div id="status">Loading...</div>
+
+    <div id="singleAudioContent" class="tab-content loading">
+      <div id="speakerIdSection">
+        <label for="speakerId" id="speakerIdLabel">Speaker ID: </label>
+        <input type="text" id="speakerId" name="speakerId" value="0" />
+        <br/>
+        <br/>
+      </div>
+      <div id="referenceAudioSection" class="hidden">
+        <label for="referenceAudio">Reference audio (.wav): </label>
+        <input type="file" id="referenceAudio" name="referenceAudio" accept=".wav,audio/wav" />
+        <div style="font-size: 0.9rem; color: #6c757d;">Only `.wav` files are supported.</div>
+        <br/>
+        <br/>
+      </div>
+      <div id="referenceTextSection" class="hidden">
+        <label for="referenceText">Reference transcript (must match the reference audio): </label>
+        <br/>
+        <textarea id="referenceText" rows="3" placeholder="Please enter the transcript of the reference audio exactly"></textarea>
+        <br/>
+        <br/>
+      </div>
+      <label for="speed" id="speedLabel">Speed: </label>
+      <input type="range" id="speed" name="speed" min="0.4" max="3.5" step="0.1" value="1.0" />
+      <span id="speedValue"></span>
+      <br/>
+      <br/>
+      <textarea id="text" rows="10" placeholder="Please enter your text here and click the Generate button"></textarea>
+      <br/>
+      <br/>
+      <button id="generateBtn" disabled>Generate</button>
+      <div id="generationStatus" style="display: none; margin-top: 0.75rem; font-size: 0.95rem; color: #6c757d;"></div>
+    </div>
+
+    <section flex="1" overflow="auto" id="sound-clips">
+    </section>
+  </div>
+
+  <!-- Footer Section -->
+  <div style="width: 100%; max-width: 900px; margin-top: 1.5rem; background: #fff; padding: 1.5rem; border-radius: 8px; box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1); text-align: left; font-size: 0.9rem; color: #6c757d;">
+    <h3>Description</h3>
+    <ul>
+      <li>Everything is <strong>open-sourced.</strong> <a href="https://github.com/k2-fsa/sherpa-onnx">code</a></li>
+      <li>If you have any issues, please either <a href="https://github.com/k2-fsa/sherpa-onnx/issues">file a ticket</a> or contact us via</li>
+        <ul>
+          <li><a href="https://k2-fsa.github.io/sherpa/social-groups.html#wechat">WeChat group</a></li>
+          <li><a href="https://k2-fsa.github.io/sherpa/social-groups.html#qq">QQ group</a></li>
+          <li><a href="https://k2-fsa.github.io/sherpa/social-groups.html#bilibili-b">Bilibili</a></li>
+        </ul>
+    </ul>
+    <h3>About This Demo</h3>
+    <ul>
+      <li><strong>Private and Secure:</strong> All processing is done locally on your device (CPU) within your browser with a single thread. No server is involved, ensuring privacy and security. You can disconnect from the Internet once this page is loaded.</li>
+      <li><strong>Efficient Resource Usage:</strong> No GPU is required, leaving system resources available for webLLM analysis.</li>
+    </ul>
+    <h3>Latest Update</h3>
+    <ul>
+      <li>Update UI.</li>
+      <li>First working version.</li>
+    </ul>
+
+    <h3>Acknowledgement</h3>
+    <ul>
+      <li>We refer to <a href="https://huggingface.co/spaces/Banafo/Kroko-Streaming-ASR-Wasm">https://huggingface.co/spaces/Banafo/Kroko-Streaming-ASR-Wasm</a> for the UI part.</li>
+    </ul>
+  </div>
+
+
+  <script src="app-tts.js"></script>
+</body>

sherpa-onnx-tts.js

@@ -0,0 +1,1101 @@
+
+function freeConfig(config, Module) {
+  if ('buffer' in config) {
+    Module._free(config.buffer);
+  }
+
+  if ('config' in config) {
+    freeConfig(config.config, Module)
+  }
+
+  if ('matcha' in config) {
+    freeConfig(config.matcha, Module)
+  }
+
+  if ('kokoro' in config) {
+    freeConfig(config.kokoro, Module)
+  }
+
+  if ('kitten' in config) {
+    freeConfig(config.kitten, Module)
+  }
+
+  if ('zipvoice' in config) {
+    freeConfig(config.zipvoice, Module)
+  }
+
+  if ('pocket' in config) {
+    freeConfig(config.pocket, Module)
+  }
+
+  if ('supertonic' in config) {
+    freeConfig(config.supertonic, Module)
+  }
+
+  if (config.ptr) {
+    Module._free(config.ptr);
+  }
+}
+
+// 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;
+  const dictDir = ''
+  const dictDirLen = Module.lengthBytesUTF8(dictDir) + 1;
+
+  const n = modelLen + lexiconLen + tokensLen + dataDirLen + dictDirLen;
+
+  const buffer = Module._malloc(n);
+
+  const len = 8 * 4;
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  Module.stringToUTF8(config.model || '', buffer + offset, modelLen);
+  offset += modelLen;
+
+  Module.stringToUTF8(config.lexicon || '', buffer + offset, lexiconLen);
+  offset += lexiconLen;
+
+  Module.stringToUTF8(config.tokens || '', buffer + offset, tokensLen);
+  offset += tokensLen;
+
+  Module.stringToUTF8(config.dataDir || '', buffer + offset, dataDirLen);
+  offset += dataDirLen;
+
+  Module.stringToUTF8(dictDir, buffer + offset, dictDirLen);
+  offset += dictDirLen;
+
+  offset = 0;
+  Module.setValue(ptr, buffer + offset, 'i8*');
+  offset += modelLen;
+
+  Module.setValue(ptr + 4, buffer + offset, 'i8*');
+  offset += lexiconLen;
+
+  Module.setValue(ptr + 8, buffer + offset, 'i8*');
+  offset += tokensLen;
+
+  Module.setValue(ptr + 12, buffer + offset, 'i8*');
+  offset += dataDirLen;
+
+  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;
+
+  return {
+    buffer: buffer,
+    ptr: ptr,
+    len: len,
+  };
+}
+
+function initSherpaOnnxOfflineTtsMatchaModelConfig(config, Module) {
+  const acousticModelLen = Module.lengthBytesUTF8(config.acousticModel) + 1;
+  const vocoderLen = Module.lengthBytesUTF8(config.vocoder) + 1;
+  const lexiconLen = Module.lengthBytesUTF8(config.lexicon || '') + 1;
+  const tokensLen = Module.lengthBytesUTF8(config.tokens || '') + 1;
+  const dataDirLen = Module.lengthBytesUTF8(config.dataDir || '') + 1;
+
+  const dictDir = '';
+  const dictDirLen = Module.lengthBytesUTF8(dictDir) + 1;
+
+  const n = acousticModelLen + vocoderLen + lexiconLen + tokensLen +
+      dataDirLen + dictDirLen;
+
+  const buffer = Module._malloc(n);
+
+  const len = 8 * 4;
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  Module.stringToUTF8(
+      config.acousticModel || '', buffer + offset, acousticModelLen);
+  offset += acousticModelLen;
+
+  Module.stringToUTF8(config.vocoder || '', buffer + offset, vocoderLen);
+  offset += vocoderLen;
+
+  Module.stringToUTF8(config.lexicon || '', buffer + offset, lexiconLen);
+  offset += lexiconLen;
+
+  Module.stringToUTF8(config.tokens || '', buffer + offset, tokensLen);
+  offset += tokensLen;
+
+  Module.stringToUTF8(config.dataDir || '', buffer + offset, dataDirLen);
+  offset += dataDirLen;
+
+  Module.stringToUTF8(dictDir, buffer + offset, dictDirLen);
+  offset += dictDirLen;
+
+  offset = 0;
+  Module.setValue(ptr, buffer + offset, 'i8*');
+  offset += acousticModelLen;
+
+  Module.setValue(ptr + 4, buffer + offset, 'i8*');
+  offset += vocoderLen;
+
+  Module.setValue(ptr + 8, buffer + offset, 'i8*');
+  offset += lexiconLen;
+
+  Module.setValue(ptr + 12, buffer + offset, 'i8*');
+  offset += tokensLen;
+
+  Module.setValue(ptr + 16, buffer + offset, 'i8*');
+  offset += dataDirLen;
+
+  Module.setValue(ptr + 20, config.noiseScale || 0.667, 'float');
+  Module.setValue(ptr + 24, config.lengthScale || 1.0, 'float');
+  Module.setValue(ptr + 28, buffer + offset, 'i8*');
+  offset += dictDirLen;
+
+  return {
+    buffer: buffer,
+    ptr: ptr,
+    len: len,
+  };
+}
+
+function initSherpaOnnxOfflineTtsKokoroModelConfig(config, Module) {
+  const modelLen = Module.lengthBytesUTF8(config.model) + 1;
+  const voicesLen = Module.lengthBytesUTF8(config.voices) + 1;
+  const tokensLen = Module.lengthBytesUTF8(config.tokens || '') + 1;
+  const dataDirLen = Module.lengthBytesUTF8(config.dataDir || '') + 1;
+  const dictDir = '';
+  const dictDirLen = Module.lengthBytesUTF8(dictDir) + 1;
+  const lexiconLen = Module.lengthBytesUTF8(config.lexicon || '') + 1;
+  const langLen = Module.lengthBytesUTF8(config.lang || '') + 1;
+
+  const n = modelLen + voicesLen + tokensLen + dataDirLen + dictDirLen +
+      lexiconLen + langLen;
+
+  const buffer = Module._malloc(n);
+
+  const len = 8 * 4;
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  Module.stringToUTF8(config.model || '', buffer + offset, modelLen);
+  offset += modelLen;
+
+  Module.stringToUTF8(config.voices || '', buffer + offset, voicesLen);
+  offset += voicesLen;
+
+  Module.stringToUTF8(config.tokens || '', buffer + offset, tokensLen);
+  offset += tokensLen;
+
+  Module.stringToUTF8(config.dataDir || '', buffer + offset, dataDirLen);
+  offset += dataDirLen;
+
+  Module.stringToUTF8(dictDir, buffer + offset, dictDirLen);
+  offset += dictDirLen;
+
+  Module.stringToUTF8(config.lexicon || '', buffer + offset, lexiconLen);
+  offset += lexiconLen;
+
+  Module.stringToUTF8(config.lang || '', buffer + offset, langLen);
+  offset += langLen;
+
+  offset = 0;
+  Module.setValue(ptr, buffer + offset, 'i8*');
+  offset += modelLen;
+
+  Module.setValue(ptr + 4, buffer + offset, 'i8*');
+  offset += voicesLen;
+
+  Module.setValue(ptr + 8, buffer + offset, 'i8*');
+  offset += tokensLen;
+
+  Module.setValue(ptr + 12, buffer + offset, 'i8*');
+  offset += dataDirLen;
+
+  Module.setValue(ptr + 16, config.lengthScale || 1.0, 'float');
+
+  Module.setValue(ptr + 20, buffer + offset, 'i8*');
+  offset += dictDirLen;
+
+  Module.setValue(ptr + 24, buffer + offset, 'i8*');
+  offset += lexiconLen;
+
+  Module.setValue(ptr + 28, buffer + offset, 'i8*');
+  offset += langLen;
+
+  return {
+    buffer: buffer,
+    ptr: ptr,
+    len: len,
+  };
+}
+
+function initSherpaOnnxOfflineTtsKittenModelConfig(config, Module) {
+  const modelLen = Module.lengthBytesUTF8(config.model) + 1;
+  const voicesLen = Module.lengthBytesUTF8(config.voices) + 1;
+  const tokensLen = Module.lengthBytesUTF8(config.tokens || '') + 1;
+  const dataDirLen = Module.lengthBytesUTF8(config.dataDir || '') + 1;
+
+  const n = modelLen + voicesLen + tokensLen + dataDirLen;
+
+  const buffer = Module._malloc(n);
+
+  const len = 5 * 4;
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  Module.stringToUTF8(config.model || '', buffer + offset, modelLen);
+  offset += modelLen;
+
+  Module.stringToUTF8(config.voices || '', buffer + offset, voicesLen);
+  offset += voicesLen;
+
+  Module.stringToUTF8(config.tokens || '', buffer + offset, tokensLen);
+  offset += tokensLen;
+
+  Module.stringToUTF8(config.dataDir || '', buffer + offset, dataDirLen);
+  offset += dataDirLen;
+
+  offset = 0;
+  Module.setValue(ptr, buffer + offset, 'i8*');
+  offset += modelLen;
+
+  Module.setValue(ptr + 4, buffer + offset, 'i8*');
+  offset += voicesLen;
+
+  Module.setValue(ptr + 8, buffer + offset, 'i8*');
+  offset += tokensLen;
+
+  Module.setValue(ptr + 12, buffer + offset, 'i8*');
+  offset += dataDirLen;
+
+  Module.setValue(ptr + 16, config.lengthScale || 1.0, 'float');
+
+  return {
+    buffer: buffer,
+    ptr: ptr,
+    len: len,
+  };
+}
+
+function initSherpaOnnxOfflineTtsZipVoiceModelConfig(config, Module) {
+  const tokensLen = Module.lengthBytesUTF8(config.tokens || '') + 1;
+  const encoderLen = Module.lengthBytesUTF8(config.encoder || '') + 1;
+  const decoderLen = Module.lengthBytesUTF8(config.decoder || '') + 1;
+  const vocoderLen = Module.lengthBytesUTF8(config.vocoder || '') + 1;
+  const dataDirLen = Module.lengthBytesUTF8(config.dataDir || '') + 1;
+  const lexiconLen = Module.lengthBytesUTF8(config.lexicon || '') + 1;
+
+  const n = tokensLen + encoderLen + decoderLen + vocoderLen + dataDirLen +
+      lexiconLen;
+
+  const buffer = Module._malloc(n);
+
+  const len = 10 * 4;
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  Module.stringToUTF8(config.tokens || '', buffer + offset, tokensLen);
+  offset += tokensLen;
+
+  Module.stringToUTF8(config.encoder || '', buffer + offset, encoderLen);
+  offset += encoderLen;
+
+  Module.stringToUTF8(config.decoder || '', buffer + offset, decoderLen);
+  offset += decoderLen;
+
+  Module.stringToUTF8(config.vocoder || '', buffer + offset, vocoderLen);
+  offset += vocoderLen;
+
+  Module.stringToUTF8(config.dataDir || '', buffer + offset, dataDirLen);
+  offset += dataDirLen;
+
+  Module.stringToUTF8(config.lexicon || '', buffer + offset, lexiconLen);
+  offset += lexiconLen;
+
+  offset = 0;
+  Module.setValue(ptr, buffer + offset, 'i8*');
+  offset += tokensLen;
+
+  Module.setValue(ptr + 4, buffer + offset, 'i8*');
+  offset += encoderLen;
+
+  Module.setValue(ptr + 8, buffer + offset, 'i8*');
+  offset += decoderLen;
+
+  Module.setValue(ptr + 12, buffer + offset, 'i8*');
+  offset += vocoderLen;
+
+  Module.setValue(ptr + 16, buffer + offset, 'i8*');
+  offset += dataDirLen;
+
+  Module.setValue(ptr + 20, buffer + offset, 'i8*');
+  offset += lexiconLen;
+
+  Module.setValue(ptr + 24, config.featScale || 0.1, 'float');
+  Module.setValue(ptr + 28, config.tShift || 0.5, 'float');
+  Module.setValue(ptr + 32, config.targetRMS || 0.1, 'float');
+  Module.setValue(ptr + 36, config.guidanceScale || 1.0, 'float');
+
+  return {
+    buffer: buffer,
+    ptr: ptr,
+    len: len,
+  };
+}
+
+function initSherpaOnnxOfflineTtsPocketModelConfig(config, Module) {
+  const lmFlowLen = Module.lengthBytesUTF8(config.lmFlow || '') + 1;
+  const lmMainLen = Module.lengthBytesUTF8(config.lmMain || '') + 1;
+  const encoderLen = Module.lengthBytesUTF8(config.encoder || '') + 1;
+  const decoderLen = Module.lengthBytesUTF8(config.decoder || '') + 1;
+  const textConditionerLen =
+      Module.lengthBytesUTF8(config.textConditioner || '') + 1;
+  const vocabJsonLen = Module.lengthBytesUTF8(config.vocabJson || '') + 1;
+  const tokenScoresJsonLen =
+      Module.lengthBytesUTF8(config.tokenScoresJson || '') + 1;
+
+
+  const n = lmFlowLen + lmMainLen + encoderLen + decoderLen +
+      textConditionerLen + vocabJsonLen + tokenScoresJsonLen;
+
+  const buffer = Module._malloc(n);
+
+  const len = 8 * 4;
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  Module.stringToUTF8(config.lmFlow || '', buffer + offset, lmFlowLen);
+  offset += lmFlowLen;
+
+  Module.stringToUTF8(config.lmMain || '', buffer + offset, lmMainLen);
+  offset += lmMainLen;
+
+  Module.stringToUTF8(config.encoder || '', buffer + offset, encoderLen);
+  offset += encoderLen;
+
+  Module.stringToUTF8(config.decoder || '', buffer + offset, decoderLen);
+  offset += decoderLen;
+
+  Module.stringToUTF8(
+      config.textConditioner || '', buffer + offset, textConditionerLen);
+  offset += textConditionerLen;
+
+  Module.stringToUTF8(config.vocabJson || '', buffer + offset, vocabJsonLen);
+  offset += vocabJsonLen;
+
+  Module.stringToUTF8(
+      config.tokenScoresJson || '', buffer + offset, tokenScoresJsonLen);
+  offset += tokenScoresJsonLen;
+
+  offset = 0;
+  Module.setValue(ptr + 0 * 4, buffer + offset, 'i8*');
+  offset += lmFlowLen;
+
+  Module.setValue(ptr + 1 * 4, buffer + offset, 'i8*');
+  offset += lmMainLen;
+
+  Module.setValue(ptr + 2 * 4, buffer + offset, 'i8*');
+  offset += encoderLen;
+
+  Module.setValue(ptr + 3 * 4, buffer + offset, 'i8*');
+  offset += decoderLen;
+
+  Module.setValue(ptr + 4 * 4, buffer + offset, 'i8*');
+  offset += textConditionerLen;
+
+  Module.setValue(ptr + 5 * 4, buffer + offset, 'i8*');
+  offset += vocabJsonLen;
+
+  Module.setValue(ptr + 6 * 4, buffer + offset, 'i8*');
+  offset += tokenScoresJsonLen;
+
+  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,
+    ptr: ptr,
+    len: len,
+  };
+}
+
+function initSherpaOnnxOfflineTtsModelConfig(config, Module) {
+  if (!('offlineTtsVitsModelConfig' in config)) {
+    config.offlineTtsVitsModelConfig = {
+      model: '',
+      lexicon: '',
+      tokens: '',
+      noiseScale: 0.667,
+      noiseScaleW: 0.8,
+      lengthScale: 1.0,
+      dataDir: '',
+    };
+  }
+
+  if (!('offlineTtsMatchaModelConfig' in config)) {
+    config.offlineTtsMatchaModelConfig = {
+      acousticModel: '',
+      vocoder: '',
+      lexicon: '',
+      tokens: '',
+      noiseScale: 0.667,
+      lengthScale: 1.0,
+      dataDir: '',
+    };
+  }
+
+  if (!('offlineTtsKokoroModelConfig' in config)) {
+    config.offlineTtsKokoroModelConfig = {
+      model: '',
+      voices: '',
+      tokens: '',
+      lengthScale: 1.0,
+      dataDir: '',
+      lexicon: '',
+      lang: '',
+    };
+  }
+
+  if (!('offlineTtsKittenModelConfig' in config)) {
+    config.offlineTtsKittenModelConfig = {
+      model: '',
+      voices: '',
+      tokens: '',
+      lengthScale: 1.0,
+    };
+  }
+
+  if (!('offlineTtsZipVoiceModelConfig' in config)) {
+    config.offlineTtsZipVoiceModelConfig = {
+      tokens: '',
+      encoder: '',
+      decoder: '',
+      vocoder: '',
+      dataDir: '',
+      lexicon: '',
+      featScale: 0.1,
+      tShift: 0.5,
+      targetRMS: 0.1,
+      guidanceScale: 1.0,
+    };
+  }
+
+  if (!('offlineTtsPocketModelConfig' in config)) {
+    config.offlineTtsPocketModelConfig = {
+      lmFlow: '',
+      lmMain: '',
+      encoder: '',
+      decoder: '',
+      textConditioner: '',
+      vocabJson: '',
+      tokenScoresJson: '',
+      voiceEmbeddingCacheCapacity: 50,
+    };
+  }
+
+  if (!('offlineTtsSupertonicModelConfig' in config)) {
+    config.offlineTtsSupertonicModelConfig = {
+      durationPredictor: '',
+      textEncoder: '',
+      vectorEstimator: '',
+      vocoder: '',
+      ttsJson: '',
+      unicodeIndexer: '',
+      voiceStyle: '',
+    };
+  }
+
+  const vitsModelConfig = initSherpaOnnxOfflineTtsVitsModelConfig(
+      config.offlineTtsVitsModelConfig, Module);
+
+  const matchaModelConfig = initSherpaOnnxOfflineTtsMatchaModelConfig(
+      config.offlineTtsMatchaModelConfig, Module);
+
+  const kokoroModelConfig = initSherpaOnnxOfflineTtsKokoroModelConfig(
+      config.offlineTtsKokoroModelConfig, Module);
+
+  const kittenModelConfig = initSherpaOnnxOfflineTtsKittenModelConfig(
+      config.offlineTtsKittenModelConfig, Module);
+
+  const zipVoiceModelConfig = initSherpaOnnxOfflineTtsZipVoiceModelConfig(
+      config.offlineTtsZipVoiceModelConfig, 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 + supertonicModelConfig.len + 3 * 4;
+
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  Module._CopyHeap(vitsModelConfig.ptr, vitsModelConfig.len, ptr + offset);
+  offset += vitsModelConfig.len;
+
+  Module.setValue(ptr + offset, config.numThreads || 1, 'i32');
+  offset += 4;
+
+  Module.setValue(ptr + offset, config.debug || 0, 'i32');
+  offset += 4;
+
+  const providerLen = Module.lengthBytesUTF8(config.provider || 'cpu') + 1;
+  const buffer = Module._malloc(providerLen);
+  Module.stringToUTF8(config.provider || 'cpu', buffer, providerLen);
+  Module.setValue(ptr + offset, buffer, 'i8*');
+  offset += 4;
+
+  Module._CopyHeap(matchaModelConfig.ptr, matchaModelConfig.len, ptr + offset);
+  offset += matchaModelConfig.len;
+
+  Module._CopyHeap(kokoroModelConfig.ptr, kokoroModelConfig.len, ptr + offset);
+  offset += kokoroModelConfig.len;
+
+  Module._CopyHeap(kittenModelConfig.ptr, kittenModelConfig.len, ptr + offset);
+  offset += kittenModelConfig.len;
+
+  Module._CopyHeap(
+      zipVoiceModelConfig.ptr, zipVoiceModelConfig.len, ptr + offset);
+  offset += zipVoiceModelConfig.len;
+
+  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,
+    len: len,
+    config: vitsModelConfig,
+    matcha: matchaModelConfig,
+    kokoro: kokoroModelConfig,
+    kitten: kittenModelConfig,
+    zipvoice: zipVoiceModelConfig,
+    pocket: pocketModelConfig,
+    supertonic: supertonicModelConfig,
+  };
+}
+
+function initSherpaOnnxOfflineTtsConfig(config, Module) {
+  const modelConfig =
+      initSherpaOnnxOfflineTtsModelConfig(config.offlineTtsModelConfig, Module);
+  const len = modelConfig.len + 4 * 4;
+  const ptr = Module._malloc(len);
+
+  let offset = 0;
+  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 buffer = Module._malloc(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 || 1, 'i32');
+  offset += 4;
+
+  Module.setValue(ptr + offset, buffer + ruleFstsLen, 'i8*');
+  offset += 4;
+
+  Module.setValue(ptr + offset, config.silenceScale || 0.2, 'float');
+  offset += 4;
+
+  return {
+    buffer: buffer,
+    ptr: ptr,
+    len: len,
+    config: modelConfig,
+  };
+}
+
+/*
+const genConfig = {
+  silenceScale: 0.2,
+  speed: 1.0,
+  sid: 1,
+  referenceAudio: myFloat32Array, // optional
+  referenceSampleRate: 16000, // used if referenceAudio is required
+  referenceText: "Hello world", // optional
+  numSteps: 5, // optional
+  extra: { bar: "ok", foo: 0.8, foobar: 10}
+};
+
+ */
+
+// Allocate a SherpaOnnxGenerationConfig in WASM
+function initSherpaOnnxGenerationConfig(config, Module) {
+  const len = 9 * 4;
+  const ptr = Module._malloc(len);
+
+  // float silence_scale
+  Module.setValue(ptr + 0 * 4, config.silenceScale || 0.2, 'float');
+
+  // float speed
+  Module.setValue(ptr + 1 * 4, config.speed || 1.0, 'float');
+
+  // int32_t sid
+  Module.setValue(ptr + 2 * 4, config.sid || 0, 'i32');
+
+  // const float* reference_audio
+  let referenceAudioPtr = 0;
+  if (config.referenceAudio && config.referenceAudio.length > 0) {
+    referenceAudioPtr = Module._malloc(config.referenceAudio.length * 4);
+    Module.HEAPF32.set(config.referenceAudio, referenceAudioPtr / 4);
+  }
+  Module.setValue(ptr + 3 * 4, referenceAudioPtr, 'i8*');
+
+  // int32_t reference_audio_len
+  Module.setValue(
+      ptr + 4 * 4, config.referenceAudio ? config.referenceAudio.length : 0,
+      'i32');
+
+  // int32_t reference_sample_rate
+  Module.setValue(ptr + 5 * 4, config.referenceSampleRate || 0, 'i32');
+
+  // const char* reference_text
+  let referenceTextPtr = 0;
+  if (config.referenceText) {
+    const textLen = Module.lengthBytesUTF8(config.referenceText) + 1;
+    referenceTextPtr = Module._malloc(textLen);
+    Module.stringToUTF8(config.referenceText, referenceTextPtr, textLen);
+  }
+  Module.setValue(ptr + 6 * 4, referenceTextPtr, 'i8*');
+
+  // int32_t num_steps
+  Module.setValue(ptr + 7 * 4, config.numSteps || 5, 'i32');
+
+  // const char* extra (JSON string)
+  let extraPtr = 0;
+  let extraStr = null;
+
+  if (config.extra) {
+    if (typeof config.extra === 'object') {
+      extraStr = JSON.stringify(config.extra);
+    } else if (typeof config.extra === 'string') {
+      extraStr = config.extra;
+    }
+  }
+
+  if (extraStr !== null) {
+    const extraLen = Module.lengthBytesUTF8(extraStr) + 1;
+    extraPtr = Module._malloc(extraLen);
+    Module.stringToUTF8(extraStr, extraPtr, extraLen);
+  }
+
+  Module.setValue(ptr + 8 * 4, extraPtr, 'i8*');
+
+  return {
+    ptr,
+    referenceAudioPtr,
+    referenceTextPtr,
+    extraPtr,
+  };
+}
+
+
+// Free the memory allocated for a SherpaOnnxGenerationConfig
+function freeSherpaOnnxGenerationConfig(cfg, Module) {
+  if (!cfg) return;
+
+  if (cfg.referenceAudioPtr) Module._free(cfg.referenceAudioPtr);
+  if (cfg.referenceTextPtr) Module._free(cfg.referenceTextPtr);
+  if (cfg.extraPtr) Module._free(cfg.extraPtr);
+  if (cfg.ptr) Module._free(cfg.ptr);
+}
+
+
+class OfflineTts {
+  constructor(configObj, Module) {
+    const config = initSherpaOnnxOfflineTtsConfig(configObj, Module)
+    const handle = Module._SherpaOnnxCreateOfflineTts(config.ptr);
+
+    freeConfig(config, Module);
+
+    this.handle = handle;
+    this.sampleRate = Module._SherpaOnnxOfflineTtsSampleRate(this.handle);
+    this.numSpeakers = Module._SherpaOnnxOfflineTtsNumSpeakers(this.handle);
+    this.Module = Module
+  }
+
+  free() {
+    if (!this.handle) return;
+
+    this.Module._SherpaOnnxDestroyOfflineTts(this.handle);
+    this.handle = 0
+  }
+
+  // {
+  //   text: "hello",
+  //   sid: 1,
+  //   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 genConfig = {
+      sid: config.sid ?? 0,
+      speed: config.speed ?? 1.0,
+    };
+    const cfgWasm = initSherpaOnnxGenerationConfig(genConfig, this.Module);
+
+    const h = this.Module._SherpaOnnxOfflineTtsGenerateWithConfig(
+        this.handle, textPtr, cfgWasm.ptr, 0, 0);
+
+    freeSherpaOnnxGenerationConfig(cfgWasm, this.Module);
+    this.Module._free(textPtr);
+
+    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;
+    const textPtr = this.Module._malloc(textLen);
+    this.Module.stringToUTF8(text, textPtr, textLen);
+
+    let callbackPtr = 0;
+    if (genConfig.callback) {
+      callbackPtr = this.Module.addFunction((samplesPtr, n, progress, arg) => {
+        const heapSamples =
+            this.Module.HEAPF32.subarray(samplesPtr / 4, samplesPtr / 4 + n);
+        const samples = new Float32Array(heapSamples);
+        return genConfig.callback(samples, n, progress, arg);
+      }, 'iiifi');
+    }
+
+    let audioPtr = 0;
+    try {
+      audioPtr = this.Module._SherpaOnnxOfflineTtsGenerateWithConfig(
+          this.handle, textPtr, cfgWasm.ptr, callbackPtr, 0);
+    } finally {
+      this.Module._free(textPtr);
+      freeSherpaOnnxGenerationConfig(cfgWasm, this.Module);
+      if (callbackPtr) {
+        this.Module.removeFunction(callbackPtr);
+      }
+    }
+
+    if (!audioPtr) {
+      throw new Error('Failed to generate audio');
+    }
+
+    const base = audioPtr / 4;
+
+    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);
+
+    return {samples, sampleRate};
+  }
+
+  save(filename, audio) {
+    const samples = audio.samples;
+    const sampleRate = audio.sampleRate;
+    const ptr = this.Module._malloc(samples.length * 4);
+
+    this.Module.HEAPF32.set(samples, ptr / 4);
+
+    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);
+  }
+}
+
+let modelType = 4;
+
+function getDefaultOfflineTtsModelType() {
+  return modelType;
+}
+
+function createOfflineTts(Module, myConfig) {
+  const vits = {
+    model: '',
+    lexicon: '',
+    tokens: '',
+    dataDir: '',
+    noiseScale: 0.667,
+    noiseScaleW: 0.8,
+    lengthScale: 1.0,
+  };
+
+  const matcha = {
+    acousticModel: '',
+    vocoder: '',
+    lexicon: '',
+    tokens: '',
+    dataDir: '',
+    noiseScale: 0.667,
+    lengthScale: 1.0,
+  };
+
+  const offlineTtsKokoroModelConfig = {
+    model: '',
+    voices: '',
+    tokens: '',
+    dataDir: '',
+    lengthScale: 1.0,
+    lexicon: '',
+    lang: '',
+  };
+
+  const offlineTtsKittenModelConfig = {
+    model: '',
+    voices: '',
+    tokens: '',
+    dataDir: '',
+    lengthScale: 1.0,
+  };
+
+  const offlineTtsZipVoiceModelConfig = {
+    tokens: '',
+    encoder: '',
+    decoder: '',
+    vocoder: '',
+    dataDir: '',
+    lexicon: '',
+    featScale: 0.1,
+    tShift: 0.5,
+    targetRMS: 0.1,
+    guidanceScale: 1.0,
+  };
+
+  const offlineTtsPocketModelConfig = {
+    lmFlow: '',
+    lmMain: '',
+    encoder: '',
+    decoder: '',
+    textConditioner: '',
+    vocabJson: '',
+    tokenScoresJson: '',
+    voiceEmbeddingCacheCapacity: 50,
+  };
+
+  let ruleFsts = '';
+
+  switch (modelType) {
+    case 0:
+      // vits
+      vits.model = './model.onnx';
+      vits.tokens = './tokens.txt';
+      vits.dataDir = './espeak-ng-data';
+      break;
+    case 1:
+      // matcha zh-en
+      // https://k2-fsa.github.io/sherpa/onnx/tts/all/Chinese-English/matcha-icefall-zh-en.html
+      matcha.acousticModel = './model-steps-3.onnx';
+      matcha.vocoder = './vocos-16khz-univ.onnx';
+      matcha.lexicon = './lexicon.txt';
+      matcha.tokens = './tokens.txt';
+      matcha.dataDir = './espeak-ng-data';
+      ruleFsts = './phone-zh.fst,./date-zh.fst,./number-zh.fst';
+      break;
+    case 2:
+      // matcha zh
+      // https://k2-fsa.github.io/sherpa/onnx/tts/all/Chinese/matcha-icefall-zh-baker.html
+      matcha.acousticModel = './model-steps-3.onnx';
+      matcha.vocoder = './vocos-22khz-univ.onnx';
+      matcha.lexicon = './lexicon.txt';
+      matcha.tokens = './tokens.txt';
+      ruleFsts = './phone.fst,./date.fst,./number.fst';
+      break;
+    case 3:
+      // matcha en
+      // https://k2-fsa.github.io/sherpa/onnx/tts/all/English/matcha-icefall-en_US-ljspeech.html
+      matcha.acousticModel = './model-steps-3.onnx';
+      matcha.vocoder = './vocos-22khz-univ.onnx';
+      matcha.tokens = './tokens.txt';
+      matcha.dataDir = './espeak-ng-data';
+      break;
+    case 4:
+      // zipvoice zh-en
+      // https://k2-fsa.github.io/sherpa/onnx/tts/zipvoice.html
+      offlineTtsZipVoiceModelConfig.tokens = './tokens.txt';
+      offlineTtsZipVoiceModelConfig.encoder = './encoder.int8.onnx';
+      offlineTtsZipVoiceModelConfig.decoder = './decoder.int8.onnx';
+      offlineTtsZipVoiceModelConfig.vocoder = './vocos_24khz.onnx';
+      offlineTtsZipVoiceModelConfig.dataDir = './espeak-ng-data';
+      offlineTtsZipVoiceModelConfig.lexicon = './lexicon.txt';
+      break;
+    case 5:
+      // pocket tts
+      // https://k2-fsa.github.io/sherpa/onnx/tts/pocket.html
+      offlineTtsPocketModelConfig.lmFlow = './lm_flow.int8.onnx';
+      offlineTtsPocketModelConfig.lmMain = './lm_main.int8.onnx';
+      offlineTtsPocketModelConfig.encoder = './encoder.onnx';
+      offlineTtsPocketModelConfig.decoder = './decoder.int8.onnx';
+      offlineTtsPocketModelConfig.textConditioner = './text_conditioner.onnx';
+      offlineTtsPocketModelConfig.vocabJson = './vocab.json';
+      offlineTtsPocketModelConfig.tokenScoresJson = './token_scores.json';
+      break;
+    case 6:
+      // KittenTTS
+      offlineTtsKittenModelConfig.model = './model.onnx';
+      offlineTtsKittenModelConfig.voices = './voices.bin';
+      offlineTtsKittenModelConfig.tokens = './tokens.txt';
+      offlineTtsKittenModelConfig.dataDir = './espeak-ng-data';
+      break;
+  }
+
+  const offlineTtsModelConfig = {
+    offlineTtsVitsModelConfig: vits,
+    offlineTtsMatchaModelConfig: matcha,
+    offlineTtsKokoroModelConfig: offlineTtsKokoroModelConfig,
+    offlineTtsKittenModelConfig: offlineTtsKittenModelConfig,
+    offlineTtsZipVoiceModelConfig: offlineTtsZipVoiceModelConfig,
+    offlineTtsPocketModelConfig: offlineTtsPocketModelConfig,
+    numThreads: 1,
+    debug: 1,
+    provider: 'cpu',
+  };
+
+  let offlineTtsConfig = {
+    offlineTtsModelConfig: offlineTtsModelConfig,
+    ruleFsts: ruleFsts,
+    ruleFars: '',
+    maxNumSentences: 1,
+  }
+
+  if (myConfig) {
+    offlineTtsConfig = myConfig;
+  }
+
+  return new OfflineTts(offlineTtsConfig, Module);
+}
+
+export {
+  createOfflineTts,
+  getDefaultOfflineTtsModelType,
+};

sherpa-onnx-tts.worker.js

@@ -0,0 +1,105 @@
+// Module-type worker. The wasm glue is built with -sEXPORT_ES6=1 so its
+// pthread runtime can spawn its own worker pool from inside this worker
+// (classic-worker importScripts() of the same glue hangs during nested
+// pthread bootstrap).
+import createModule from "./sherpa-onnx-wasm-main-tts.js";
+import {
+  createOfflineTts,
+  getDefaultOfflineTtsModelType,
+} from "./sherpa-onnx-tts.js";
+
+let tts = null;
+
+const Module = await createModule({
+  locateFile: (path, scriptDirectory = "") => scriptDirectory + path,
+  setStatus: (status) => {
+    self.postMessage({ type: "sherpa-onnx-tts-progress", status });
+  },
+});
+
+try {
+  tts = createOfflineTts(Module);
+  self.postMessage({
+    type: "sherpa-onnx-tts-ready",
+    modelType: getDefaultOfflineTtsModelType(),
+    numSpeakers: tts.numSpeakers,
+  });
+} catch (e) {
+  self.postMessage({
+    type: "error",
+    message: "TTS Initialization failed: " + e.message,
+  });
+}
+
+function getErrorMessage(err) {
+  if (err instanceof Error) {
+    if (err.stack) {
+      return `${err.message}\n${err.stack}`;
+    }
+    return err.message;
+  }
+
+  return `${err}`;
+}
+
+self.onmessage = async (e) => {
+  const { type, text, sid, speed, genConfig } = e.data;
+  if (type === "generate") {
+    if (!tts) {
+      return;
+    }
+    try {
+      const audio = tts.generate({
+        text: text,
+        sid: sid || 0,
+        speed: speed || 1.0,
+      });
+      const samples = audio.samples;
+      const sampleRate = tts.sampleRate;
+      self.postMessage(
+        {
+          type: "sherpa-onnx-tts-result",
+          samples: samples,
+          sampleRate: sampleRate,
+        },
+        [samples.buffer],
+      );
+    } catch (err) {
+      self.postMessage({
+        type: "error",
+        message: "Generation failed: " + getErrorMessage(err),
+      });
+    }
+  } else if (type === "generateWithConfig") {
+    if (!tts) {
+      return;
+    }
+    try {
+      const config = Object.assign({}, genConfig || {});
+      config.callback = (samples, n, progress) => {
+        self.postMessage({
+          type: "sherpa-onnx-tts-generation-progress",
+          progress: progress,
+        });
+        return 1;
+      };
+
+      const audio = tts.generateWithConfig(text, config);
+      const samples = audio.samples;
+      const sampleRate = audio.sampleRate;
+      self.postMessage(
+          {
+            type: "sherpa-onnx-tts-result",
+            samples: samples,
+            sampleRate: sampleRate,
+          },
+          [samples.buffer],
+      );
+    } catch (err) {
+      self.postMessage({
+        type: "error",
+        message: "Generation failed: " + getErrorMessage(err),
+      });
+    }
+  }
+};

sherpa-onnx-wasm-main-tts.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e2f08ed07e58a4970293252645f0fc92accc42dce40fad4a3e14a05c3f7fb21
+size 204108836

sherpa-onnx-wasm-main-tts.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9554feafc2bf4452c3e1f5d5d4b29b690e6e7db1eb3835478a793e864111f640
+size 12883754