react-native-sherpa-onnx 0.3.5 → 0.3.7

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

@@ -49,11 +49,9 @@ Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarBz2(
     j_progress_callback_global = env->NewGlobalRef(j_progress_callback);
   }
 
-  // Get Promise.resolve and reject methods
+  // Get Promise.resolve method
   jclass promise_class = env->GetObjectClass(j_promise);
   jmethodID resolve_method = env->GetMethodID(promise_class, "resolve", "(Ljava/lang/Object;)V");
-  jmethodID reject_method = env->GetMethodID(promise_class, "reject", 
-                                              "(Ljava/lang/String;Ljava/lang/String;)V");
 
   // Get WritableMap from Arguments
   jclass arguments_class = env->FindClass("com/facebook/react/bridge/Arguments");
@@ -123,15 +121,12 @@ Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarBz2(
       env->CallVoidMethod(result_map, put_string_method,
                           env->NewStringUTF("sha256"), env->NewStringUTF(sha256.c_str()));
     }
-    env->CallVoidMethod(j_promise, resolve_method, result_map);
   } else {
     __android_log_print(ANDROID_LOG_WARN, "SherpaOnnxNative", "[ARCHIVE_ERROR] %s", error_msg.c_str());
     env->CallVoidMethod(result_map, put_string_method,
                         env->NewStringUTF("reason"), env->NewStringUTF(error_msg.c_str()));
-    env->CallVoidMethod(j_promise, reject_method,
-                        env->NewStringUTF("ARCHIVE_ERROR"),
-                        env->NewStringUTF(error_msg.c_str()));
   }
+  env->CallVoidMethod(j_promise, resolve_method, result_map);
 
   // Clean up global reference
   if (j_progress_callback_global != nullptr) {
@@ -144,6 +139,270 @@ Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarBz2(
   env->DeleteLocalRef(writeable_map_class);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarZst(
+    JNIEnv* env,
+    jobject /* jthis */,
+    jstring j_source_path,
+    jstring j_target_path,
+    jboolean j_force,
+    jobject j_progress_callback,
+    jobject j_promise) {
+  const char* source_path = env->GetStringUTFChars(j_source_path, nullptr);
+  const char* target_path = env->GetStringUTFChars(j_target_path, nullptr);
+  std::string source_str(source_path);
+  std::string target_str(target_path);
+  env->ReleaseStringUTFChars(j_source_path, source_path);
+  env->ReleaseStringUTFChars(j_target_path, target_path);
+
+  jmethodID on_progress_method = nullptr;
+  jobject j_progress_callback_global = nullptr;
+  if (j_progress_callback != nullptr) {
+    jclass callback_class = env->GetObjectClass(j_progress_callback);
+    on_progress_method = env->GetMethodID(callback_class, "invoke", "(JJD)V");
+    env->DeleteLocalRef(callback_class);
+    j_progress_callback_global = env->NewGlobalRef(j_progress_callback);
+  }
+
+  jclass promise_class = env->GetObjectClass(j_promise);
+  jmethodID resolve_method = env->GetMethodID(promise_class, "resolve", "(Ljava/lang/Object;)V");
+
+  jclass arguments_class = env->FindClass("com/facebook/react/bridge/Arguments");
+  jmethodID create_map_method = env->GetStaticMethodID(
+      arguments_class, "createMap", "()Lcom/facebook/react/bridge/WritableMap;");
+  jobject result_map = env->CallStaticObjectMethod(arguments_class, create_map_method);
+
+  jclass writeable_map_class = env->FindClass("com/facebook/react/bridge/WritableMap");
+  jmethodID put_boolean_method = env->GetMethodID(
+      writeable_map_class, "putBoolean", "(Ljava/lang/String;Z)V");
+  jmethodID put_string_method = env->GetMethodID(
+      writeable_map_class, "putString", "(Ljava/lang/String;Ljava/lang/String;)V");
+
+  auto on_progress = [j_progress_callback_global, on_progress_method](
+      long long bytes_extracted, long long total_bytes, double percent) {
+    if (j_progress_callback_global != nullptr && on_progress_method != nullptr) {
+      JNIEnv* callback_env = nullptr;
+      bool should_detach = false;
+      if (g_vm->GetEnv(reinterpret_cast<void**>(&callback_env), JNI_VERSION_1_6) == JNI_EDETACHED) {
+        if (g_vm->AttachCurrentThread(&callback_env, nullptr) == JNI_OK) {
+          should_detach = true;
+        } else {
+          return;
+        }
+      }
+      if (callback_env != nullptr) {
+        callback_env->CallVoidMethod(j_progress_callback_global, on_progress_method,
+                            bytes_extracted, total_bytes, percent);
+        if (callback_env->ExceptionCheck()) {
+          callback_env->ExceptionClear();
+        }
+        if (should_detach) {
+          g_vm->DetachCurrentThread();
+        }
+      }
+    }
+  };
+
+  std::string error_msg;
+  std::string sha256;
+  bool success = ArchiveHelper::ExtractTarZst(
+      source_str,
+      target_str,
+      j_force == JNI_TRUE,
+      on_progress,
+      &error_msg,
+      &sha256);
+
+  env->CallVoidMethod(result_map, put_boolean_method,
+                      env->NewStringUTF("success"), success ? JNI_TRUE : JNI_FALSE);
+
+  if (success) {
+    env->CallVoidMethod(result_map, put_string_method,
+                        env->NewStringUTF("path"), env->NewStringUTF(target_str.c_str()));
+    if (!sha256.empty()) {
+      env->CallVoidMethod(result_map, put_string_method,
+                          env->NewStringUTF("sha256"), env->NewStringUTF(sha256.c_str()));
+    }
+  } else {
+    __android_log_print(ANDROID_LOG_WARN, "SherpaOnnxNative", "[ARCHIVE_ERROR] %s", error_msg.c_str());
+    env->CallVoidMethod(result_map, put_string_method,
+                        env->NewStringUTF("reason"), env->NewStringUTF(error_msg.c_str()));
+  }
+  env->CallVoidMethod(j_promise, resolve_method, result_map);
+
+  if (j_progress_callback_global != nullptr) {
+    env->DeleteGlobalRef(j_progress_callback_global);
+  }
+
+  env->DeleteLocalRef(result_map);
+  env->DeleteLocalRef(promise_class);
+  env->DeleteLocalRef(arguments_class);
+  env->DeleteLocalRef(writeable_map_class);
+}
+
+namespace {
+struct InputStreamReadContext {
+  JNIEnv* env = nullptr;
+  jobject stream_global = nullptr;
+  jmethodID read_method = nullptr;
+  jbyteArray byte_array = nullptr;
+  const size_t buffer_size = 64 * 1024;
+};
+
+static std::ptrdiff_t JniStreamRead(void* buf, size_t len, void* user_data) {
+  auto* ctx = static_cast<InputStreamReadContext*>(user_data);
+  if (!ctx || !ctx->env || !ctx->stream_global || !ctx->read_method || !ctx->byte_array) {
+    return -1;
+  }
+  size_t to_read = (len < ctx->buffer_size) ? len : ctx->buffer_size;
+  jint n = ctx->env->CallIntMethod(ctx->stream_global, ctx->read_method, ctx->byte_array);
+  if (ctx->env->ExceptionCheck()) {
+    ctx->env->ExceptionClear();
+    return -1;
+  }
+  if (n <= 0) return 0;
+  ctx->env->GetByteArrayRegion(ctx->byte_array, 0, n, static_cast<jbyte*>(buf));
+  return static_cast<std::ptrdiff_t>(n);
+}
+}  // namespace
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarZstFromStream(
+    JNIEnv* env,
+    jobject /* jthis */,
+    jobject j_input_stream,
+    jstring j_target_path,
+    jboolean j_force,
+    jobject j_progress_callback,
+    jobject j_promise) {
+  const char* target_path = env->GetStringUTFChars(j_target_path, nullptr);
+  std::string target_str(target_path);
+  env->ReleaseStringUTFChars(j_target_path, target_path);
+
+  jobject stream_global = env->NewGlobalRef(j_input_stream);
+  jclass stream_class = env->GetObjectClass(j_input_stream);
+  jmethodID read_method = env->GetMethodID(stream_class, "read", "([B)I");
+  env->DeleteLocalRef(stream_class);
+  if (!read_method) {
+    env->DeleteGlobalRef(stream_global);
+    jclass promise_class = env->GetObjectClass(j_promise);
+    jmethodID reject_method = env->GetMethodID(promise_class, "reject", "(Ljava/lang/String;Ljava/lang/String;)V");
+    env->CallVoidMethod(j_promise, reject_method,
+                        env->NewStringUTF("ARCHIVE_ERROR"),
+                        env->NewStringUTF("InputStream.read([B)I not found"));
+    env->DeleteLocalRef(promise_class);
+    return;
+  }
+
+  jbyteArray byte_array = env->NewByteArray(static_cast<jsize>(64 * 1024));
+  if (!byte_array) {
+    env->DeleteGlobalRef(stream_global);
+    return;
+  }
+
+  InputStreamReadContext read_ctx;
+  read_ctx.env = env;
+  read_ctx.stream_global = stream_global;
+  read_ctx.read_method = read_method;
+  read_ctx.byte_array = byte_array;
+
+  jmethodID on_progress_method = nullptr;
+  jobject j_progress_callback_global = nullptr;
+  if (j_progress_callback != nullptr) {
+    jclass callback_class = env->GetObjectClass(j_progress_callback);
+    on_progress_method = env->GetMethodID(callback_class, "invoke", "(JJD)V");
+    env->DeleteLocalRef(callback_class);
+    j_progress_callback_global = env->NewGlobalRef(j_progress_callback);
+  }
+
+  jclass promise_class = env->GetObjectClass(j_promise);
+  jmethodID resolve_method = env->GetMethodID(promise_class, "resolve", "(Ljava/lang/Object;)V");
+
+  jclass arguments_class = env->FindClass("com/facebook/react/bridge/Arguments");
+  jmethodID create_map_method = env->GetStaticMethodID(arguments_class, "createMap", "()Lcom/facebook/react/bridge/WritableMap;");
+  jobject result_map = env->CallStaticObjectMethod(arguments_class, create_map_method);
+
+  jclass writeable_map_class = env->FindClass("com/facebook/react/bridge/WritableMap");
+  jmethodID put_boolean_method = env->GetMethodID(writeable_map_class, "putBoolean", "(Ljava/lang/String;Z)V");
+  jmethodID put_string_method = env->GetMethodID(writeable_map_class, "putString", "(Ljava/lang/String;Ljava/lang/String;)V");
+
+  auto on_progress = [j_progress_callback_global, on_progress_method](
+      long long bytes_extracted, long long total_bytes, double percent) {
+    if (j_progress_callback_global != nullptr && on_progress_method != nullptr) {
+      JNIEnv* callback_env = nullptr;
+      bool should_detach = false;
+      if (g_vm->GetEnv(reinterpret_cast<void**>(&callback_env), JNI_VERSION_1_6) == JNI_EDETACHED) {
+        if (g_vm->AttachCurrentThread(&callback_env, nullptr) == JNI_OK) {
+          should_detach = true;
+        } else {
+          return;
+        }
+      }
+      if (callback_env != nullptr) {
+        callback_env->CallVoidMethod(j_progress_callback_global, on_progress_method,
+                            bytes_extracted, total_bytes, percent);
+        if (callback_env->ExceptionCheck()) {
+          callback_env->ExceptionClear();
+        }
+        if (should_detach) {
+          g_vm->DetachCurrentThread();
+        }
+      }
+    }
+  };
+
+  std::string error_msg;
+  std::string sha256;
+  bool success = ArchiveHelper::ExtractFromStream(
+      &JniStreamRead,
+      &read_ctx,
+      target_str,
+      j_force == JNI_TRUE,
+      on_progress,
+      &error_msg,
+      &sha256);
+
+  env->CallVoidMethod(result_map, put_boolean_method,
+                      env->NewStringUTF("success"), success ? JNI_TRUE : JNI_FALSE);
+
+  if (success) {
+    env->CallVoidMethod(result_map, put_string_method,
+                        env->NewStringUTF("path"), env->NewStringUTF(target_str.c_str()));
+    if (!sha256.empty()) {
+      env->CallVoidMethod(result_map, put_string_method,
+                          env->NewStringUTF("sha256"), env->NewStringUTF(sha256.c_str()));
+    }
+  } else {
+    __android_log_print(ANDROID_LOG_WARN, "SherpaOnnxNative", "[ARCHIVE_ERROR] %s", error_msg.c_str());
+    env->CallVoidMethod(result_map, put_string_method,
+                        env->NewStringUTF("reason"), env->NewStringUTF(error_msg.c_str()));
+  }
+  env->CallVoidMethod(j_promise, resolve_method, result_map);
+
+  env->DeleteGlobalRef(stream_global);
+  env->DeleteLocalRef(byte_array);
+  if (j_progress_callback_global != nullptr) {
+    env->DeleteGlobalRef(j_progress_callback_global);
+  }
+  env->DeleteLocalRef(result_map);
+  env->DeleteLocalRef(promise_class);
+  env->DeleteLocalRef(arguments_class);
+  env->DeleteLocalRef(writeable_map_class);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarBz2FromStream(
+    JNIEnv* env,
+    jobject jthis,
+    jobject j_input_stream,
+    jstring j_target_path,
+    jboolean j_force,
+    jobject j_progress_callback,
+    jobject j_promise) {
+  Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarZstFromStream(
+      env, jthis, j_input_stream, j_target_path, j_force, j_progress_callback, j_promise);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeCancelExtract(JNIEnv* /* env */, jobject /* jthis */) {
   ArchiveHelper::Cancel();

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