react-native-sherpa-onnx 0.3.6 → 0.3.8

package/ios/SherpaOnnxAudioConvert.mm

@@ -2,6 +2,7 @@
 #import <React/RCTLog.h>
 #include <string>
 #include <sys/stat.h>
+#include <vector>
 
 #ifdef HAVE_FFMPEG
 extern "C" {
@@ -12,11 +13,14 @@ extern "C" {
 #include <libswresample/swresample.h>
 }
 #include <cstdio>
-#include <vector>
 #endif
 
 // Forward declaration — convertToFormat handles all formats including WAV (16 kHz mono).
 static std::string convertToFormat(const char* inputPath, const char* outputPath, const char* formatHint, int outputSampleRateHz);
+static std::string decodeAudioFileToFloatMono(const char* inputPath,
+                                              int targetSampleRateHz,
+                                              std::vector<float>* outSamples,
+                                              int* outSampleRate);
 
 // Convenience: convert any audio to 16 kHz mono WAV via the main convertToFormat pipeline.
 static std::string convertToWav16kMono(const char* inputPath, const char* outputPath) {
@@ -659,6 +663,222 @@ static std::string convertToFormat(const char* inputPath, const char* outputPath
 #endif
 }
 
+static std::string decodeAudioFileToFloatMono(const char* inputPath,
+                                              int targetSampleRateHz,
+                                              std::vector<float>* outSamples,
+                                              int* outSampleRate) {
+    outSamples->clear();
+    *outSampleRate = 0;
+#ifndef HAVE_FFMPEG
+    (void)inputPath;
+    (void)targetSampleRateHz;
+    return std::string("FFmpeg not available. Build prebuilts with third_party/ffmpeg_prebuilt/build_ffmpeg_ios.sh.");
+#else
+    if (!inputPath) {
+        return std::string("inputPath is null");
+    }
+
+    AVFormatContext* inFmt = nullptr;
+    if (avformat_open_input(&inFmt, inputPath, nullptr, nullptr) < 0) {
+        return std::string("Failed to open input file");
+    }
+    if (avformat_find_stream_info(inFmt, nullptr) < 0) {
+        avformat_close_input(&inFmt);
+        return std::string("Failed to find stream info");
+    }
+
+    int audioStreamIndex = -1;
+    for (unsigned i = 0; i < inFmt->nb_streams; ++i) {
+        if (inFmt->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+            audioStreamIndex = (int)i;
+            break;
+        }
+    }
+    if (audioStreamIndex < 0) {
+        avformat_close_input(&inFmt);
+        return std::string("No audio stream found in input");
+    }
+
+    AVStream* inStream = inFmt->streams[audioStreamIndex];
+    const AVCodec* decoder = avcodec_find_decoder(inStream->codecpar->codec_id);
+    if (!decoder) {
+        avformat_close_input(&inFmt);
+        return std::string("Unsupported input codec");
+    }
+
+    AVCodecContext* decCtx = avcodec_alloc_context3(decoder);
+    if (!decCtx) {
+        avformat_close_input(&inFmt);
+        return std::string("Failed to allocate decoder context");
+    }
+    if (avcodec_parameters_to_context(decCtx, inStream->codecpar) < 0) {
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Failed to copy codec parameters");
+    }
+    if (avcodec_open2(decCtx, decoder, nullptr) < 0) {
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Failed to open decoder");
+    }
+
+    int in_sr = decCtx->sample_rate;
+    if (inStream->codecpar->sample_rate > 0) {
+        in_sr = inStream->codecpar->sample_rate;
+    }
+    if (in_sr <= 0) {
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Invalid input sample rate");
+    }
+
+    int out_sr = (targetSampleRateHz > 0) ? targetSampleRateHz : in_sr;
+    if (out_sr <= 0) {
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Invalid output sample rate");
+    }
+
+    AVChannelLayout in_layout{};
+    if (inStream->codecpar->ch_layout.nb_channels > 0) {
+        if (av_channel_layout_copy(&in_layout, &inStream->codecpar->ch_layout) < 0) {
+            avcodec_free_context(&decCtx);
+            avformat_close_input(&inFmt);
+            return std::string("Failed to copy input channel layout");
+        }
+    } else {
+        if (av_channel_layout_copy(&in_layout, &decCtx->ch_layout) < 0) {
+            avcodec_free_context(&decCtx);
+            avformat_close_input(&inFmt);
+            return std::string("Failed to get decoder channel layout");
+        }
+    }
+
+    AVChannelLayout out_layout = AV_CHANNEL_LAYOUT_MONO;
+    SwrContext* swr = nullptr;
+    if (swr_alloc_set_opts2(&swr,
+                           &out_layout,
+                           AV_SAMPLE_FMT_FLT,
+                           out_sr,
+                           &in_layout,
+                           decCtx->sample_fmt,
+                           in_sr,
+                           0,
+                           nullptr) < 0 ||
+        !swr) {
+        av_channel_layout_uninit(&in_layout);
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Failed to initialize resampler");
+    }
+    if (swr_init(swr) < 0) {
+        av_channel_layout_uninit(&in_layout);
+        swr_free(&swr);
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Failed to initialize resampler (swr_init)");
+    }
+    av_channel_layout_uninit(&in_layout);
+
+    AVPacket* pkt = av_packet_alloc();
+    AVFrame* frame = av_frame_alloc();
+    if (!pkt || !frame) {
+        if (pkt) av_packet_free(&pkt);
+        if (frame) av_frame_free(&frame);
+        swr_free(&swr);
+        avcodec_free_context(&decCtx);
+        avformat_close_input(&inFmt);
+        return std::string("Out of memory");
+    }
+
+    auto appendConverted = [&](uint8_t* buf, int nbFloats) {
+        if (!buf || nbFloats <= 0) return;
+        const float* f = reinterpret_cast<const float*>(buf);
+        outSamples->insert(outSamples->end(), f, f + nbFloats);
+    };
+
+    auto convertOneFrame = [&](AVFrame* fr) {
+        // Copy plane pointers so we can pass const uint8_t** to swr_convert without
+        // reinterpret_cast(uint8_t** -> const uint8_t**), which triggers -Wcast-qual.
+        uint8_t** src = fr->extended_data ? fr->extended_data : fr->data;
+        int nplanes = fr->ch_layout.nb_channels;
+        if (nplanes <= 0) nplanes = AV_NUM_DATA_POINTERS;
+
+        const uint8_t* in_stack[AV_NUM_DATA_POINTERS] = {};
+        std::vector<const uint8_t*> in_heap;
+        const uint8_t** in_arg;
+        if (nplanes > AV_NUM_DATA_POINTERS) {
+            in_heap.resize(static_cast<size_t>(nplanes));
+            for (int i = 0; i < nplanes; ++i) {
+                in_heap[static_cast<size_t>(i)] = src[i];
+            }
+            in_arg = in_heap.data();
+        } else {
+            for (int i = 0; i < nplanes; ++i) {
+                in_stack[i] = src[i];
+            }
+            in_arg = in_stack;
+        }
+
+        int in_sr2 = inStream->codecpar->sample_rate ? inStream->codecpar->sample_rate : decCtx->sample_rate;
+        int64_t max_out =
+            av_rescale_rnd(swr_get_delay(swr, in_sr2) + (int64_t)fr->nb_samples, out_sr, in_sr2, AV_ROUND_UP);
+        if (max_out < 1) max_out = 1;
+        uint8_t* out_buf = nullptr;
+        if (av_samples_alloc(&out_buf, nullptr, 1, (int)max_out, AV_SAMPLE_FMT_FLT, 0) < 0) {
+            return;
+        }
+        int converted = swr_convert(swr, &out_buf, (int)max_out, in_arg, fr->nb_samples);
+        if (converted > 0) {
+            appendConverted(out_buf, converted);
+        }
+        av_freep(&out_buf);
+    };
+
+    while (av_read_frame(inFmt, pkt) >= 0) {
+        if (pkt->stream_index == audioStreamIndex) {
+            if (avcodec_send_packet(decCtx, pkt) == 0) {
+                while (avcodec_receive_frame(decCtx, frame) == 0) {
+                    convertOneFrame(frame);
+                    av_frame_unref(frame);
+                }
+            }
+        }
+        av_packet_unref(pkt);
+    }
+
+    if (avcodec_send_packet(decCtx, nullptr) == 0) {
+        while (avcodec_receive_frame(decCtx, frame) == 0) {
+            convertOneFrame(frame);
+            av_frame_unref(frame);
+        }
+    }
+
+    {
+        int in_sr2 = inStream->codecpar->sample_rate ? inStream->codecpar->sample_rate : decCtx->sample_rate;
+        int tailCap = (int)swr_get_delay(swr, in_sr2) + 4096;
+        if (tailCap < 16) tailCap = 16;
+        uint8_t* tailData = nullptr;
+        if (av_samples_alloc(&tailData, nullptr, 1, tailCap, AV_SAMPLE_FMT_FLT, 0) >= 0) {
+            int tailConverted = swr_convert(swr, &tailData, tailCap, nullptr, 0);
+            if (tailConverted > 0) {
+                appendConverted(tailData, tailConverted);
+            }
+            av_freep(&tailData);
+        }
+    }
+
+    av_packet_free(&pkt);
+    av_frame_free(&frame);
+    swr_free(&swr);
+    avcodec_free_context(&decCtx);
+    avformat_close_input(&inFmt);
+
+    *outSampleRate = out_sr;
+    return std::string("");
+#endif
+}
+
 @implementation SherpaOnnxAudioConvert
 
 + (BOOL)convertAudioToWav16k:(NSString *)inputPath
@@ -695,4 +915,40 @@ static std::string convertToFormat(const char* inputPath, const char* outputPath
     return YES;
 }
 
++ (BOOL)decodeAudioFileToFloatSamples:(NSString *)inputPath
+                   targetSampleRateHz:(int)targetSampleRateHz
+                           outSamples:(NSArray<NSNumber *> **)outSamples
+                        outSampleRate:(int *)outSampleRate
+                                error:(NSError **)error
+{
+    if (!outSamples || !outSampleRate) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"SherpaOnnxAudioConvert"
+                                         code:-2
+                                     userInfo:@{NSLocalizedDescriptionKey: @"outSamples/outSampleRate required"}];
+        }
+        return NO;
+    }
+    *outSamples = nil;
+    *outSampleRate = 0;
+    std::vector<float> v;
+    int sr = 0;
+    std::string err = decodeAudioFileToFloatMono(inputPath.UTF8String, targetSampleRateHz, &v, &sr);
+    if (!err.empty()) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"SherpaOnnxAudioConvert"
+                                         code:-1
+                                     userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithUTF8String:err.c_str()]}];
+        }
+        return NO;
+    }
+    NSMutableArray<NSNumber *> *arr = [NSMutableArray arrayWithCapacity:v.size()];
+    for (size_t i = 0; i < v.size(); ++i) {
+        [arr addObject:@(v[i])];
+    }
+    *outSamples = arr;
+    *outSampleRate = sr;
+    return YES;
+}
+
 @end

package/ios/archive/sherpa-onnx-archive-helper.h

@@ -23,6 +23,9 @@ typedef void (^SherpaOnnxArchiveProgressBlock)(long long bytes, long long totalB
 
 + (void)cancelExtractTarZst;
 
+/** Cancel extraction for a specific source archive path (per-operation cancel for parallel extractions). */
++ (void)cancelExtractForPath:(NSString *)sourcePath;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/archive/sherpa-onnx-archive-helper.mm

@@ -14,9 +14,24 @@
 #include <array>
 #include <atomic>
 #include <cstdio>
+#include <mutex>
+#include <set>
 #include <string>
 
-static std::atomic_bool g_cancelExtract(false);
+static std::mutex g_cancelMutex;
+static std::set<std::string> g_cancelledPaths;
+
+static bool isPathCancelled(const std::string& path) {
+  std::lock_guard<std::mutex> lock(g_cancelMutex);
+  // If the set contains an empty string, ALL extractions are cancelled (legacy global cancel).
+  return g_cancelledPaths.count("") > 0 || g_cancelledPaths.count(path) > 0;
+}
+
+static void clearCancelForPath(const std::string& path) {
+  std::lock_guard<std::mutex> lock(g_cancelMutex);
+  g_cancelledPaths.erase(path);
+  g_cancelledPaths.erase(""); // Clear the global cancel flag too
+}
 
 namespace {
 #ifdef HAVE_LIBARCHIVE
@@ -127,7 +142,8 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
 + (void)cancelExtractTarBz2
 {
 #ifdef HAVE_LIBARCHIVE
-  g_cancelExtract.store(true);
+  std::lock_guard<std::mutex> lock(g_cancelMutex);
+  g_cancelledPaths.insert(""); // Empty string = cancel ALL
 #else
   // feature disabled
 #endif
@@ -136,7 +152,21 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
 + (void)cancelExtractTarZst
 {
 #ifdef HAVE_LIBARCHIVE
-  g_cancelExtract.store(true);
+  std::lock_guard<std::mutex> lock(g_cancelMutex);
+  g_cancelledPaths.insert(""); // Empty string = cancel ALL
+#else
+  // feature disabled
+#endif
+}
+
++ (void)cancelExtractForPath:(NSString *)sourcePath
+{
+#ifdef HAVE_LIBARCHIVE
+  std::string path = [sourcePath UTF8String] ?: "";
+  if (!path.empty()) {
+    std::lock_guard<std::mutex> lock(g_cancelMutex);
+    g_cancelledPaths.insert(path);
+  }
 #else
   // feature disabled
 #endif
@@ -150,7 +180,8 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
 #ifndef HAVE_LIBARCHIVE
   return @{ @"success": @NO, @"reason": @"libarchive is disabled in this build. Rebuild without SHERPA_ONNX_DISABLE_LIBARCHIVE=1." };
 #else
-  g_cancelExtract.store(false);
+  std::string sourcePathStr = [sourcePath UTF8String] ?: "";
+  clearCancelForPath(sourcePathStr);
   NSFileManager *fileManager = [NSFileManager defaultManager];
 
   if (![fileManager fileExistsAtPath:sourcePath]) {
@@ -213,10 +244,11 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
   int lastPercent = -1;
   long long lastEmitBytes = 0;
   while ((result = archive_read_next_header(archive, &entry)) == ARCHIVE_OK) {
-    if (g_cancelExtract.load()) {
+    if (isPathCancelled(sourcePathStr)) {
       archive_read_free(archive);
       archive_write_free(disk);
       close_reader();
+      clearCancelForPath(sourcePathStr);
       return @{ @"success": @NO, @"reason": @"Extraction cancelled" };
     }
     const char *currentPath = archive_entry_pathname(entry);
@@ -245,10 +277,11 @@ static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
     size_t size = 0;
     la_int64_t offset = 0;
     while ((result = archive_read_data_block(archive, &buff, &size, &offset)) == ARCHIVE_OK) {
-      if (g_cancelExtract.load()) {
+      if (isPathCancelled(sourcePathStr)) {
         archive_read_free(archive);
         archive_write_free(disk);
         close_reader();
+        clearCancelForPath(sourcePathStr);
         return @{ @"success": @NO, @"reason": @"Extraction cancelled" };
       }
       la_ssize_t writeResult = archive_write_data_block(disk, buff, size, offset);

package/ios/model_detect/sherpa-onnx-model-detect-tts.mm

@@ -2,7 +2,7 @@
  * sherpa-onnx-model-detect-tts.mm
  *
  * Purpose: Detects TTS (text-to-speech) model type and fills TtsModelPaths from a model directory.
- * Used by the TTS wrapper on iOS. Supports Vits, Matcha, Kokoro, Kitten, Pocket, Zipvoice.
+ * Used by the TTS wrapper on iOS. Supports Vits, Matcha, Kokoro, Kitten, Pocket, Zipvoice, Supertonic.
  *
  * --- Detection pipeline (overview) ---
  *
@@ -39,6 +39,13 @@
 #include <string>
 #include <vector>
 
+#if defined(__APPLE__)
+#include <Foundation/Foundation.h>
+#define TTS_DETECT_LOGI(fmt, ...) NSLog(@"[TtsModelDetect] " fmt, ##__VA_ARGS__)
+#else
+#define TTS_DETECT_LOGI(fmt, ...) ((void)0)
+#endif
+
 namespace sherpaonnx {
 namespace {
 
@@ -51,18 +58,20 @@ TtsModelKind ParseTtsModelType(const std::string& modelType) {
     if (modelType == "kitten") return TtsModelKind::kKitten;
     if (modelType == "pocket") return TtsModelKind::kPocket;
     if (modelType == "zipvoice") return TtsModelKind::kZipvoice;
+    if (modelType == "supertonic") return TtsModelKind::kSupertonic;
     return TtsModelKind::kUnknown;
 }
 
 /** Returns true if the given kind is supported by the current paths and hints (required files present).
- *  data_dir (espeak-ng-data) is required only for Kitten and Kokoro (sherpa-onnx config Validate());
- *  VITS, Matcha, Zipvoice use it optionally; Pocket does not use it. */
+ *  data_dir (espeak-ng-data) is required for Kitten, Kokoro, and Zipvoice (Zipvoice uses MatchaTtsLexicon + espeak).
+ *  VITS and Matcha use dataDir optionally in this detector; Pocket does not use it. */
 static bool CapabilitySupportsTtsKind(
     TtsModelKind kind,
     bool hasVits,
     bool hasMatcha,
     bool hasPocket,
     bool hasZipvoice,
+    bool hasSupertonic,
     bool hasVoicesFile,
     bool hasDataDir
 ) {
@@ -78,6 +87,8 @@ static bool CapabilitySupportsTtsKind(
             return hasPocket;
         case TtsModelKind::kZipvoice:
             return hasZipvoice;
+        case TtsModelKind::kSupertonic:
+            return hasSupertonic;
         default:
             return false;
     }
@@ -102,6 +113,7 @@ static std::vector<TtsModelKind> GetKindsFromDirNameTts(const std::string& model
     if (lower.find("matcha") != std::string::npos) add(TtsModelKind::kMatcha);
     if (lower.find("pocket") != std::string::npos) add(TtsModelKind::kPocket);
     if (lower.find("zipvoice") != std::string::npos) add(TtsModelKind::kZipvoice);
+    if (lower.find("supertonic") != std::string::npos) add(TtsModelKind::kSupertonic);
     if (lower.find("kokoro") != std::string::npos) add(TtsModelKind::kKokoro);
     if (lower.find("kitten") != std::string::npos) add(TtsModelKind::kKitten);
     if (lower.find("vits") != std::string::npos) add(TtsModelKind::kVits);
@@ -132,6 +144,10 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     std::string tokensFile = FindFileByName(files, "tokens.txt");
     std::vector<LexiconCandidate> lexiconCandidates = FindLexiconCandidates(files, modelDir);
     std::string dataDirPath = FindDirectoryUnderRoot(files, modelDir, "espeak-ng-data");
+    TTS_DETECT_LOGI("DetectTtsModel: modelDir=%s espeak-ng dataDir=%s (empty=%d)",
+                    modelDir.c_str(),
+                    dataDirPath.empty() ? "(empty)" : dataDirPath.c_str(),
+                    (int)dataDirPath.empty());
     std::string voicesFile = FindFileByName(files, "voices.bin");
 
     std::string acousticModel = FindOnnxByAnyToken(files, {"acoustic_model", "acoustic-model"}, std::nullopt);
@@ -143,14 +159,27 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     std::string textConditioner = FindOnnxByAnyToken(files, {"text_conditioner", "text-conditioner"}, std::nullopt);
     std::string vocabJsonFile = FindFileByName(files, "vocab.json");
     std::string tokenScoresJsonFile = FindFileByName(files, "token_scores.json");
+    std::string durationPredictor = FindOnnxByAnyToken(files, {"duration_predictor", "duration-predictor"}, std::nullopt);
+    std::string textEncoderSupertonic = FindOnnxByAnyToken(files, {"text_encoder", "text-encoder"}, std::nullopt);
+    std::string vectorEstimator = FindOnnxByAnyToken(files, {"vector_estimator", "vector-estimator"}, std::nullopt);
+    std::string ttsJsonFile = FindFileByName(files, "tts.json");
+    std::string unicodeIndexerFile = FindFileByName(files, "unicode_indexer.bin");
+    std::string voiceStyleFile = FindFileByName(files, "voice.bin");
 
-    std::vector<std::string> modelExcludes = {"acoustic", "vocoder", "encoder", "decoder", "joiner"};
+    std::vector<std::string> modelExcludes = {
+        "acoustic", "vocoder", "encoder", "decoder", "joiner",
+        // Supertonic component models are not VITS monolithic model.onnx files.
+        "duration_predictor", "duration-predictor",
+        "text_encoder", "text-encoder",
+        "vector_estimator", "vector-estimator"
+    };
     std::string ttsModel = FindOnnxByAnyToken(files, {"model"}, std::nullopt);
     if (ttsModel.empty()) {
         ttsModel = FindLargestOnnxExcludingTokens(files, modelExcludes);
     }
 
-    bool hasVits = !ttsModel.empty();
+    // VITS requires both model.onnx-like file and tokens.txt
+    bool hasVits = !ttsModel.empty() && !tokensFile.empty();
     std::string modelDirLower = ToLower(modelDir);
     bool isLikelyMatcha = modelDirLower.find("matcha") != std::string::npos;
     bool hasMatcha = (!acousticModel.empty() && !vocoder.empty())
@@ -167,6 +196,9 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     }
     bool hasPocket = !lmFlow.empty() && !lmMain.empty() && !encoder.empty() && !decoder.empty() &&
                      !textConditioner.empty() && !vocabJsonFile.empty() && !tokenScoresJsonFile.empty();
+    bool hasSupertonic = !durationPredictor.empty() && !textEncoderSupertonic.empty() &&
+                         !vectorEstimator.empty() && !vocoder.empty() && !ttsJsonFile.empty() &&
+                         !unicodeIndexerFile.empty() && !voiceStyleFile.empty();
     bool hasDataDir = !dataDirPath.empty();
 
     bool isLikelyKitten = modelDirLower.find("kitten") != std::string::npos;
@@ -181,6 +213,9 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     if (hasZipvoice && !hasMatcha) {
         result.detectedModels.push_back({"zipvoice", modelDir});
     }
+    if (hasSupertonic) {
+        result.detectedModels.push_back({"supertonic", modelDir});
+    }
     if (hasVoicesFile) {
         if (isLikelyKitten && !isLikelyKokoro) {
             result.detectedModels.push_back({"kitten", modelDir});
@@ -217,7 +252,7 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
         std::vector<TtsModelKind> nameCandidates = GetKindsFromDirNameTts(modelDir);
         if (!nameCandidates.empty()) {
             for (TtsModelKind k : nameCandidates) {
-                if (CapabilitySupportsTtsKind(k, hasVits, hasMatcha, hasPocket, hasZipvoice,
+                if (CapabilitySupportsTtsKind(k, hasVits, hasMatcha, hasPocket, hasZipvoice, hasSupertonic,
                                               hasVoicesFile, hasDataDir)) {
                     selected = k;
                     break;
@@ -232,6 +267,8 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
                 selected = TtsModelKind::kPocket;
             } else if (hasZipvoice) {
                 selected = TtsModelKind::kZipvoice;
+            } else if (hasSupertonic) {
+                selected = TtsModelKind::kSupertonic;
             } else if (hasVoicesFile) {
                 if (isLikelyKitten && !isLikelyKokoro) {
                     selected = TtsModelKind::kKitten;
@@ -278,6 +315,12 @@ TtsDetectResult DetectTtsModel(const std::string& modelDir, const std::string& m
     result.paths.textConditioner = textConditioner;
     result.paths.vocabJson = vocabJsonFile;
     result.paths.tokenScoresJson = tokenScoresJsonFile;
+    result.paths.durationPredictor = durationPredictor;
+    result.paths.textEncoder = textEncoderSupertonic;
+    result.paths.vectorEstimator = vectorEstimator;
+    result.paths.ttsJson = ttsJsonFile;
+    result.paths.unicodeIndexer = unicodeIndexerFile;
+    result.paths.voiceStyle = voiceStyleFile;
 
     auto validation = ValidateTtsPaths(selected, result.paths, modelDir);
     if (!validation.ok) {

package/ios/model_detect/sherpa-onnx-model-detect.h

@@ -37,7 +37,8 @@ enum class TtsModelKind {
     kKokoro,
     kKitten,
     kPocket,
-    kZipvoice
+    kZipvoice,
+    kSupertonic
 };
 
 struct SttModelPaths {
@@ -150,6 +151,13 @@ struct TtsModelPaths {
     std::string textConditioner;
     std::string vocabJson;
     std::string tokenScoresJson;
+    // Supertonic TTS
+    std::string durationPredictor;
+    std::string textEncoder;
+    std::string vectorEstimator;
+    std::string ttsJson;
+    std::string unicodeIndexer;
+    std::string voiceStyle;
 };
 
 struct SttDetectResult {

package/ios/model_detect/sherpa-onnx-validate-tts.mm

@@ -55,8 +55,18 @@ static const TtsFieldRequirement kZipvoiceReqs[] = {
     {"decoder",  &TtsModelPaths::decoder,  true},
     {"vocoder",  &TtsModelPaths::vocoder,  true},
     {"tokens",   &TtsModelPaths::tokens,   true},
-    {"dataDir",  &TtsModelPaths::dataDir,  false},
-    {"lexicon",  &TtsModelPaths::lexicon,  false},
+    {"dataDir",  &TtsModelPaths::dataDir,  true},
+    {"lexicon",  &TtsModelPaths::lexicon,  true},
+};
+
+static const TtsFieldRequirement kSupertonicReqs[] = {
+    {"durationPredictor", &TtsModelPaths::durationPredictor, true},
+    {"textEncoder",       &TtsModelPaths::textEncoder,       true},
+    {"vectorEstimator",   &TtsModelPaths::vectorEstimator,   true},
+    {"vocoder",           &TtsModelPaths::vocoder,           true},
+    {"ttsJson",           &TtsModelPaths::ttsJson,           true},
+    {"unicodeIndexer",    &TtsModelPaths::unicodeIndexer,    true},
+    {"voiceStyle",        &TtsModelPaths::voiceStyle,        true},
 };
 
 // ============================================================
@@ -79,6 +89,9 @@ static const TtsFieldRequirement* GetRequirements(TtsModelKind kind, size_t& cou
         case TtsModelKind::kZipvoice:
             count = std::size(kZipvoiceReqs);
             return kZipvoiceReqs;
+        case TtsModelKind::kSupertonic:
+            count = std::size(kSupertonicReqs);
+            return kSupertonicReqs;
         default:
             count = 0;
             return nullptr;
@@ -93,6 +106,7 @@ static const char* TtsKindToName(TtsModelKind k) {
         case TtsModelKind::kKitten:   return "Kitten";
         case TtsModelKind::kPocket:   return "Pocket";
         case TtsModelKind::kZipvoice: return "Zipvoice";
+        case TtsModelKind::kSupertonic: return "Supertonic";
         default:                      return "Unknown";
     }
 }
@@ -102,6 +116,8 @@ static const char* GetFieldHint(const char* fieldName) {
         return "Copy espeak-ng-data into the model directory.";
     if (std::strcmp(fieldName, "tokens") == 0)
         return "Ensure tokens.txt is present in the model directory.";
+    if (std::strcmp(fieldName, "lexicon") == 0)
+        return "Add lexicon.txt (or lexicon-<lang>.txt) from the official sherpa-onnx Zipvoice/Matcha release; without it the native engine aborts.";
     return nullptr;
 }
 

package/ios/online_stt/sherpa-onnx-online-stt-wrapper.h

@@ -49,6 +49,7 @@ public:
         const std::string& provider,
         const std::string& ruleFsts,
         const std::string& ruleFars,
+        float dither,
         float blankPenalty,
         bool debug,
         bool rule1MustContainNonSilence,

package/ios/online_stt/sherpa-onnx-online-stt-wrapper.mm

@@ -103,6 +103,7 @@ OnlineSttInitResult OnlineSttWrapper::initialize(
     const std::string& provider,
     const std::string& ruleFsts,
     const std::string& ruleFars,
+    float dither,
     float blankPenalty,
     bool debug,
     // NOTE: rule*MustContainNonSilence, rule1/2MinUtteranceLength, and
@@ -138,6 +139,9 @@ OnlineSttInitResult OnlineSttWrapper::initialize(
     sherpa_onnx::cxx::OnlineRecognizerConfig config;
     config.feat_config.sample_rate = 16000;
     config.feat_config.feature_dim = 80;
+    // Dither is not exposed on cxx::FeatureConfig in the bundled sherpa-onnx headers;
+    // Android applies it via JNI. iOS uses the library default (no dither from JS).
+    (void)dither;
     config.decoding_method = decodingMethod.empty() ? "greedy_search" : decodingMethod;
     config.max_active_paths = maxActivePaths;
     config.enable_endpoint = enableEndpoint;