react-native-sherpa-onnx 0.3.6 → 0.3.7

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

@@ -60,8 +60,8 @@ TtsModelKind ParseTtsModelType(const std::string& modelType) {
 }
 
 /** 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,
@@ -128,6 +128,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);

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

@@ -55,8 +55,8 @@ 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},
 };
 
 // ============================================================
@@ -102,6 +102,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/android/src/main/java/com/sherpaonnx/SherpaOnnxArchiveHelper.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicBoolean
@@ -13,11 +14,12 @@ import java.util.concurrent.atomic.AtomicBoolean
  * This class delegates to C++ native implementation via JNI.
  */
 class SherpaOnnxArchiveHelper {
-  private val cancelRequested = AtomicBoolean(false)
-
   companion object {
-    /** Single-thread executor so extractions run off the React Native bridge thread and do not block listDownloadedModelsByCategory / RNFS. */
-    private val extractExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+    /** Thread pool for extractions – allows up to 2 concurrent extractions while keeping them off the React Native bridge thread. */
+    private val extractExecutor: ExecutorService = Executors.newFixedThreadPool(2)
+
+    /** Per-source-path cancellation flags. Key = absolute source archive path. */
+    private val cancelFlags = ConcurrentHashMap<String, AtomicBoolean>()
 
     init {
       try {
@@ -29,15 +31,24 @@ class SherpaOnnxArchiveHelper {
   }
 
   fun cancelExtractTarBz2() {
-    cancelRequested.set(true)
+    // Cancel ALL ongoing extractions (legacy global cancel)
+    for (flag in cancelFlags.values) flag.set(true)
     nativeCancelExtract()
   }
 
   fun cancelExtractTarZst() {
-    cancelRequested.set(true)
+    // Cancel ALL ongoing extractions (legacy global cancel)
+    for (flag in cancelFlags.values) flag.set(true)
     nativeCancelExtract()
   }
 
+  /** Cancel a specific extraction identified by its source archive path. */
+  fun cancelExtractBySourcePath(sourcePath: String) {
+    // Only set the per-path flag; do not call nativeCancelExtract() since that is
+    // a global cancel that would also interrupt unrelated concurrent extractions.
+    cancelFlags[sourcePath]?.set(true)
+  }
+
   fun extractTarBz2(
     sourcePath: String,
     targetPath: String,
@@ -55,7 +66,9 @@ class SherpaOnnxArchiveHelper {
     }
 
     try {
-      cancelRequested.set(false)
+      // Register per-path cancel flag
+      val cancelFlag = AtomicBoolean(false)
+      cancelFlags[sourcePath] = cancelFlag
 
       // Create a progress callback object that JNI can call
       val progressCallback = object : Any() {
@@ -65,15 +78,23 @@ class SherpaOnnxArchiveHelper {
       }
 
       // Run extraction on a background thread so the React Native bridge thread is not blocked.
-      // Otherwise listDownloadedModelsByCategory (RNFS) and other native calls would wait until extraction finishes.
+      // The thread pool allows multiple extractions in parallel.
       extractExecutor.execute {
         try {
+          // Check per-path cancel flag before starting the native extraction.
+          if (cancelFlag.get()) {
+            resolveOnce(false, "Cancelled")
+            return@execute
+          }
           nativeExtractTarBz2(sourcePath, targetPath, force, progressCallback, promise)
         } catch (e: Exception) {
           resolveOnce(false, "Archive extraction error: ${e.message}")
+        } finally {
+          cancelFlags.remove(sourcePath)
         }
       }
     } catch (e: Exception) {
+      cancelFlags.remove(sourcePath)
       resolveOnce(false, "Archive extraction error: ${e.message}")
     }
   }
@@ -95,7 +116,9 @@ class SherpaOnnxArchiveHelper {
     }
 
     try {
-      cancelRequested.set(false)
+      val cancelFlag = AtomicBoolean(false)
+      cancelFlags[sourcePath] = cancelFlag
+
       val progressCallback = object : Any() {
         fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
           onProgress(bytesExtracted, totalBytes, percent)
@@ -103,12 +126,20 @@ class SherpaOnnxArchiveHelper {
       }
       extractExecutor.execute {
         try {
+          // Check per-path cancel flag before starting the native extraction.
+          if (cancelFlag.get()) {
+            resolveOnce(false, "Cancelled")
+            return@execute
+          }
           nativeExtractTarZst(sourcePath, targetPath, force, progressCallback, promise)
         } catch (e: Exception) {
           resolveOnce(false, "Archive extraction error: ${e.message}")
+        } finally {
+          cancelFlags.remove(sourcePath)
         }
       }
     } catch (e: Exception) {
+      cancelFlags.remove(sourcePath)
       resolveOnce(false, "Archive extraction error: ${e.message}")
     }
   }
@@ -124,7 +155,6 @@ class SherpaOnnxArchiveHelper {
     if (BuildConfig.DEBUG) {
       Log.i("SherpaOnnx", "extractTarZstFromAsset assetPath=$assetPath targetPath=$targetPath")
     }
-    cancelRequested.set(false)
     val progressCallback = object : Any() {
       fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
         onProgress(bytesExtracted, totalBytes, percent)