react-native-sherpa-onnx 0.3.6 → 0.3.8

package/android/src/main/cpp/CMakeLists.txt

@@ -29,7 +29,7 @@ get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../../.." ABSOL
 set(USE_FFMPEG ON)
 if(SHERPA_ONNX_DISABLE_FFMPEG)
     set(USE_FFMPEG OFF)
-    message(STATUS "FFmpeg disabled (SHERPA_ONNX_DISABLE_FFMPEG=ON). convertAudioToWav16k/convertAudioToFormat will return an error at runtime.")
+    message(STATUS "FFmpeg disabled (SHERPA_ONNX_DISABLE_FFMPEG=ON). convertAudioToWav16k/convertAudioToFormat and decode (non-WAV) will return an error at runtime.")
 endif()
 
 if(USE_FFMPEG)
@@ -39,25 +39,32 @@ set(FFMPEG_PREBUILT_BASE "${PROJECT_ROOT}/../third_party/ffmpeg_prebuilt/android
 set(FFMPEG_PREBUILT_LIB "${FFMPEG_PREBUILT_BASE}/${ANDROID_ABI}/lib")
 set(FFMPEG_JNILIBS "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}")
 set(FFMPEG_INCLUDE_CPP "${PROJECT_ROOT}/src/main/cpp/include/ffmpeg")
-if(EXISTS "${FFMPEG_PREBUILT_BASE}/include")
+# Require a real header — an empty third_party/.../include/ dir must not win over Gradle-populated cpp/include/ffmpeg.
+if(EXISTS "${FFMPEG_PREBUILT_BASE}/include/libavcodec/avcodec.h")
     set(FFMPEG_INCLUDE_DIR "${FFMPEG_PREBUILT_BASE}/include")
     message(STATUS "FFmpeg headers: prebuilts ${FFMPEG_INCLUDE_DIR}")
-elseif(EXISTS "${FFMPEG_INCLUDE_CPP}")
+elseif(EXISTS "${FFMPEG_INCLUDE_CPP}/libavcodec/avcodec.h")
     set(FFMPEG_INCLUDE_DIR "${FFMPEG_INCLUDE_CPP}")
-    message(STATUS "FFmpeg headers: jniLibs/release ${FFMPEG_INCLUDE_DIR}")
+    message(STATUS "FFmpeg headers: module tree ${FFMPEG_INCLUDE_DIR}")
 else()
     message(FATAL_ERROR "FFmpeg headers missing. Either:\n"
                         "  - Build: cd third_party/ffmpeg_prebuilt && ./build_ffmpeg.sh (creates android/include)\n"
                         "  - Or use a release that includes include/ (Gradle extracts to ${FFMPEG_INCLUDE_CPP})")
 endif()
+# Prebuilts may be either legacy layout android/<abi>/lib/ (build_ffmpeg.sh) or
+# android/jni/<abi>/ (same as Gradle THIRD_PARTY in docs/PREBUILT_RESOLUTION.md).
+set(FFMPEG_PREBUILT_JNI_ABI "${FFMPEG_PREBUILT_BASE}/jni/${ANDROID_ABI}")
 if(EXISTS "${FFMPEG_PREBUILT_LIB}/libavcodec.so")
     set(FFMPEG_LIB_DIR "${FFMPEG_PREBUILT_LIB}")
     message(STATUS "FFmpeg libs: prebuilts ${FFMPEG_LIB_DIR}")
+elseif(EXISTS "${FFMPEG_PREBUILT_JNI_ABI}/libavcodec.so")
+    set(FFMPEG_LIB_DIR "${FFMPEG_PREBUILT_JNI_ABI}")
+    message(STATUS "FFmpeg libs: prebuilts (jni/<abi>) ${FFMPEG_LIB_DIR}")
 elseif(EXISTS "${FFMPEG_JNILIBS}/libavcodec.so")
     set(FFMPEG_LIB_DIR "${FFMPEG_JNILIBS}")
     message(STATUS "FFmpeg libs: jniLibs ${FFMPEG_LIB_DIR}")
 else()
-    message(FATAL_ERROR "FFmpeg libs missing for ABI ${ANDROID_ABI}. Run third_party/ffmpeg_prebuilt/copy_prebuilts_to_sdk.js or ensure ANDROID_RELEASE_TAG release is downloaded.")
+    message(FATAL_ERROR "FFmpeg libs missing for ABI ${ANDROID_ABI}. Run a Gradle Android build so prebuilts populate jniLibs, or add local .so under jniLibs / ffmpeg prebuilts paths.")
 endif()
 endif(USE_FFMPEG)
 
@@ -82,7 +89,6 @@ set(SOURCES
     jni/model_detect/sherpa-onnx-stt-wrapper.cpp
     jni/model_detect/sherpa-onnx-tts-wrapper.cpp
     jni/audio/sherpa-onnx-audio-convert-jni.cpp
-    jni/tts/sherpa-onnx-tts-zipvoice-jni.cpp
     crypto/sha256.cpp
 )
 
@@ -93,10 +99,19 @@ set(LIBARCHIVE_PREBUILT_LIB "${LIBARCHIVE_PREBUILT_BASE}/${ANDROID_ABI}/lib")
 set(LIBARCHIVE_JNILIBS "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}")
 set(LIBARCHIVE_INCLUDE_CPP "${PROJECT_ROOT}/src/main/cpp/include/libarchive")
 set(USE_LIBARCHIVE_PREBUILT OFF)
+set(LIBARCHIVE_PREBUILT_JNI_ABI "${LIBARCHIVE_PREBUILT_BASE}/jni/${ANDROID_ABI}")
 if(EXISTS "${LIBARCHIVE_PREBUILT_LIB}/libarchive.so")
     set(USE_LIBARCHIVE_PREBUILT ON)
     set(LIBARCHIVE_LIB_DIR "${LIBARCHIVE_PREBUILT_LIB}")
-    if(EXISTS "${LIBARCHIVE_PREBUILT_BASE}/include")
+    if(EXISTS "${LIBARCHIVE_PREBUILT_BASE}/include/archive.h")
+        set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_PREBUILT_BASE}/include")
+    elseif(EXISTS "${LIBARCHIVE_INCLUDE_CPP}/archive.h")
+        set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_INCLUDE_CPP}")
+    endif()
+elseif(EXISTS "${LIBARCHIVE_PREBUILT_JNI_ABI}/libarchive.so")
+    set(USE_LIBARCHIVE_PREBUILT ON)
+    set(LIBARCHIVE_LIB_DIR "${LIBARCHIVE_PREBUILT_JNI_ABI}")
+    if(EXISTS "${LIBARCHIVE_PREBUILT_BASE}/include/archive.h")
         set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_PREBUILT_BASE}/include")
     elseif(EXISTS "${LIBARCHIVE_INCLUDE_CPP}/archive.h")
         set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_INCLUDE_CPP}")
@@ -128,15 +143,19 @@ add_library(sherpaonnx SHARED
 # If we used IMPORTED here, AGP would also copy .so from CMake --> duplicate in mergeNativeLibs.
 set(SHERPA_ONNX_PREBUILT_BASE "${PROJECT_ROOT}/../third_party/sherpa-onnx-prebuilt/android")
 set(SHERPA_ONNX_ABI_LIB "${SHERPA_ONNX_PREBUILT_BASE}/${ANDROID_ABI}/lib")
+set(SHERPA_ONNX_JNI_ABI "${SHERPA_ONNX_PREBUILT_BASE}/jni/${ANDROID_ABI}")
 set(SHERPA_C_API_LIB_DIR "")
 if(EXISTS "${SHERPA_ONNX_ABI_LIB}/libsherpa-onnx-c-api.so")
     set(SHERPA_C_API_LIB_DIR "${SHERPA_ONNX_ABI_LIB}")
     message(STATUS "sherpa-onnx C-API (link only): ${SHERPA_C_API_LIB_DIR}")
+elseif(EXISTS "${SHERPA_ONNX_JNI_ABI}/libsherpa-onnx-c-api.so")
+    set(SHERPA_C_API_LIB_DIR "${SHERPA_ONNX_JNI_ABI}")
+    message(STATUS "sherpa-onnx C-API (link only, third_party jni/<abi>): ${SHERPA_C_API_LIB_DIR}")
 elseif(EXISTS "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}/libsherpa-onnx-c-api.so")
     set(SHERPA_C_API_LIB_DIR "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}")
     message(STATUS "sherpa-onnx C-API (link only, jniLibs): ${SHERPA_C_API_LIB_DIR}")
 else()
-    message(WARNING "sherpa-onnx C-API not found. Zipvoice TTS will not be available. "
+    message(WARNING "sherpa-onnx C-API not found. Prebuilt sherpa native libs may be incomplete. "
                     "Build prebuilts: cd third_party/sherpa-onnx-prebuilt && ./build_sherpa_onnx.sh")
 endif()
 
@@ -148,7 +167,6 @@ target_include_directories(sherpaonnx PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/jni/archive
     ${CMAKE_CURRENT_SOURCE_DIR}/jni/model_detect
     ${CMAKE_CURRENT_SOURCE_DIR}/jni/audio
-    ${CMAKE_CURRENT_SOURCE_DIR}/jni/tts
     ${CMAKE_CURRENT_SOURCE_DIR}/include
 )
 if(USE_FFMPEG)
@@ -167,7 +185,7 @@ if(USE_LIBARCHIVE)
     target_compile_definitions(sherpaonnx PRIVATE HAVE_LIBARCHIVE=1)
 endif()
 
-# Link libraries (Kotlin API from AAR handles STT/TTS; C-API only for Zipvoice)
+# Link libraries (Kotlin API from AAR handles STT/TTS incl. Zipvoice)
 if(USE_FFMPEG)
     target_link_directories(sherpaonnx PRIVATE ${FFMPEG_LIB_DIR})
 endif()

package/android/src/main/cpp/jni/archive/sherpa-onnx-archive-helper.cpp

@@ -157,7 +157,7 @@ bool ArchiveHelper::ExtractTarBz2(
   // If target exists and is a directory, extract into it (merge). Otherwise require empty or force-remove.
   if (std::filesystem::exists(target_path)) {
     if (std::filesystem::is_directory(target_path)) {
-      // Merge: extract into existing directory (e.g. multiple archives → same base path)
+      // Merge: extract into existing directory (e.g. multiple archives --> same base path)
     } else if (force) {
       std::error_code ec;
       std::filesystem::remove_all(target_path, ec);
@@ -459,7 +459,7 @@ bool ArchiveHelper::ExtractFromStream(
 
   if (std::filesystem::exists(target_path)) {
     if (std::filesystem::is_directory(target_path)) {
-      // Merge: extract into existing directory (e.g. multiple archives → same base path)
+      // Merge: extract into existing directory (e.g. multiple archives --> same base path)
     } else if (force) {
       std::error_code ec;
       std::filesystem::remove_all(target_path, ec);

package/android/src/main/cpp/jni/audio/sherpa-onnx-audio-convert-jni.cpp

@@ -9,6 +9,7 @@
 #include <jni.h>
 #include <string>
 #include <sys/stat.h>
+#include <vector>
 
 #define LOG_TAG "AudioConvertJNI"
 #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
@@ -24,11 +25,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) {
@@ -614,7 +618,8 @@ static std::string convertToFormat(const char* inputPath, const char* outputPath
                         av_packet_unref(pkt);
                         continue;
                     }
-                    int converted = swr_convert(swr, outData, (int)out_nb_samples, (const uint8_t**)frame->data, frame->nb_samples);
+                    const uint8_t* const* in_data = frame->extended_data ? frame->extended_data : frame->data;
+                    int converted = swr_convert(swr, outData, (int)out_nb_samples, in_data, frame->nb_samples);
                     if (converted <= 0) {
                         av_freep(&outData[0]);
                         av_freep(&outData);
@@ -701,6 +706,204 @@ static std::string convertToFormat(const char* inputPath, const char* outputPath
 #endif
 }
 
+// Decode any FFmpeg-supported audio to mono float PCM in [-1,1] (clipping not applied) at outSampleRate.
+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.ps1 or build_ffmpeg.sh.");
+#else
+    if (!inputPath) {
+        return std::string("inputPath is null");
+    }
+
+    AVFormatContext* inFmt = nullptr;
+    if (avformat_open_input(&inFmt, inputPath, nullptr, nullptr) < 0) {
+        LOGE("decodeAudioFileToFloatMono: failed to open inputPath=%s", inputPath);
+        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) {
+        const uint8_t* const* in_data = fr->extended_data ? fr->extended_data : fr->data;
+        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_data, 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;
+    LOGI("decodeAudioFileToFloatMono: samples=%zu sampleRate=%d", outSamples->size(), out_sr);
+    return std::string("");
+#endif
+}
+
 extern "C" {
 
 // Called from Kotlin: SherpaOnnxModule.nativeConvertAudioToWav16k(inputPath, outputPath) -> Boolean
@@ -759,4 +962,67 @@ Java_com_sherpaonnx_SherpaOnnxModule_nativeConvertAudioToFormat(
     return env->NewStringUTF(err.c_str());
 }
 
+// Returns Object[]: on error [String message]; on success [float[] samples, Integer sampleRate].
+JNIEXPORT jobjectArray JNICALL
+Java_com_sherpaonnx_SherpaOnnxModule_nativeDecodeAudioFileToFloatSamples(JNIEnv* env,
+                                                                       jobject /* this */,
+                                                                       jstring inputPath,
+                                                                       jint targetSampleRateHz) {
+    jclass objectClass = env->FindClass("java/lang/Object");
+    if (!objectClass) {
+        return nullptr;
+    }
+
+    auto makeError = [&](const char* msg) -> jobjectArray {
+        jobjectArray ret = env->NewObjectArray(1, objectClass, nullptr);
+        if (!ret) return nullptr;
+        jstring jmsg = env->NewStringUTF(msg);
+        env->SetObjectArrayElement(ret, 0, jmsg);
+        env->DeleteLocalRef(jmsg);
+        return ret;
+    };
+
+    if (inputPath == nullptr) {
+        return makeError("inputPath must be non-null");
+    }
+    const char* input = env->GetStringUTFChars(inputPath, nullptr);
+    if (input == nullptr) {
+        return makeError("Failed to get path string");
+    }
+
+    std::vector<float> samples;
+    int sampleRate = 0;
+    std::string err = decodeAudioFileToFloatMono(input, (int)targetSampleRateHz, &samples, &sampleRate);
+    env->ReleaseStringUTFChars(inputPath, input);
+
+    if (!err.empty()) {
+        return makeError(err.c_str());
+    }
+
+    jfloatArray jfloats = env->NewFloatArray((jsize)samples.size());
+    if (!jfloats) {
+        return makeError("Failed to allocate float array");
+    }
+    if (!samples.empty()) {
+        env->SetFloatArrayRegion(jfloats, 0, (jsize)samples.size(), samples.data());
+    }
+
+    jobjectArray ret = env->NewObjectArray(2, objectClass, nullptr);
+    if (!ret) {
+        env->DeleteLocalRef(jfloats);
+        return makeError("Failed to allocate result array");
+    }
+    env->SetObjectArrayElement(ret, 0, jfloats);
+
+    jclass intCls = env->FindClass("java/lang/Integer");
+    jmethodID intCtor = env->GetMethodID(intCls, "<init>", "(I)V");
+    jobject jrate = env->NewObject(intCls, intCtor, sampleRate);
+    env->SetObjectArrayElement(ret, 1, jrate);
+
+    env->DeleteLocalRef(jfloats);
+    env->DeleteLocalRef(jrate);
+    env->DeleteLocalRef(intCls);
+    return ret;
+}
+
 }  // extern "C"

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-tts.cpp

@@ -2,7 +2,7 @@
  * sherpa-onnx-model-detect-tts.cpp
  *
  * Purpose: Detects TTS model type and fills TtsModelPaths from a model directory. Used by
- * nativeDetectTtsModel (module-jni). Supports Vits, Matcha, Kokoro, Kitten, Pocket, Zipvoice.
+ * nativeDetectTtsModel (module-jni). Supports Vits, Matcha, Kokoro, Kitten, Pocket, Zipvoice, Supertonic.
  *
  * --- Detection pipeline (overview) ---
  *
@@ -56,18 +56,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
 ) {
@@ -83,6 +85,8 @@ static bool CapabilitySupportsTtsKind(
             return hasPocket;
         case TtsModelKind::kZipvoice:
             return hasZipvoice;
+        case TtsModelKind::kSupertonic:
+            return hasSupertonic;
         default:
             return false;
     }
@@ -108,6 +112,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);
@@ -128,6 +133,10 @@ static TtsDetectResult DetectTtsModelFromFiles(
     std::string tokensFile = FindFileByName(files, "tokens.txt");
     std::vector<LexiconCandidate> lexiconCandidates = FindLexiconCandidates(files, modelDir);
     std::string dataDirPath = FindDirectoryUnderRoot(files, modelDir, "espeak-ng-data");
+    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);
@@ -139,16 +148,27 @@ static TtsDetectResult DetectTtsModelFromFiles(
     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"
+        "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())
@@ -165,6 +185,9 @@ static TtsDetectResult DetectTtsModelFromFiles(
     }
     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;
@@ -173,6 +196,7 @@ static TtsDetectResult DetectTtsModelFromFiles(
     if (hasMatcha) result.detectedModels.push_back({"matcha", modelDir});
     if (hasPocket) result.detectedModels.push_back({"pocket", modelDir});
     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});
@@ -201,7 +225,7 @@ static TtsDetectResult DetectTtsModelFromFiles(
         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;
@@ -212,6 +236,7 @@ static TtsDetectResult DetectTtsModelFromFiles(
             if (hasMatcha) selected = TtsModelKind::kMatcha;
             else if (hasPocket) selected = TtsModelKind::kPocket;
             else if (hasZipvoice) selected = TtsModelKind::kZipvoice;
+            else if (hasSupertonic) selected = TtsModelKind::kSupertonic;
             else if (hasVoicesFile) {
                 if (isLikelyKitten && !isLikelyKokoro) selected = TtsModelKind::kKitten;
                 else if (isLikelyKokoro && !isLikelyKitten) selected = TtsModelKind::kKokoro;
@@ -252,6 +277,12 @@ static TtsDetectResult DetectTtsModelFromFiles(
     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/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect.h

@@ -38,7 +38,8 @@ enum class TtsModelKind {
     kKokoro,
     kKitten,
     kPocket,
-    kZipvoice
+    kZipvoice,
+    kSupertonic
 };
 
 struct SttModelPaths {
@@ -154,6 +155,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/android/src/main/cpp/jni/model_detect/sherpa-onnx-tts-wrapper.cpp

@@ -20,6 +20,7 @@ const char* TtsModelKindToString(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";
   }
 }
@@ -78,6 +79,12 @@ jobject TtsDetectResultToJava(JNIEnv* env, const TtsDetectResult& result) {
       PutString(env, pathsMap, mapPut, "textConditioner", result.paths.textConditioner);
       PutString(env, pathsMap, mapPut, "vocabJson", result.paths.vocabJson);
       PutString(env, pathsMap, mapPut, "tokenScoresJson", result.paths.tokenScoresJson);
+      PutString(env, pathsMap, mapPut, "durationPredictor", result.paths.durationPredictor);
+      PutString(env, pathsMap, mapPut, "textEncoder", result.paths.textEncoder);
+      PutString(env, pathsMap, mapPut, "vectorEstimator", result.paths.vectorEstimator);
+      PutString(env, pathsMap, mapPut, "ttsJson", result.paths.ttsJson);
+      PutString(env, pathsMap, mapPut, "unicodeIndexer", result.paths.unicodeIndexer);
+      PutString(env, pathsMap, mapPut, "voiceStyle", result.paths.voiceStyle);
       jstring keyPaths = env->NewStringUTF("paths");
       env->CallObjectMethod(map, mapPut, keyPaths, pathsMap);
       env->DeleteLocalRef(keyPaths);

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-validate-tts.cpp

@@ -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;
 }