react-native-sherpa-onnx 0.3.9 → 0.4.1

package/README.md

@@ -92,6 +92,7 @@ Full step-by-step: [Download manager – Setup (iOS & Android)](docs/download-ma
 - [Supported Model Types](#supported-model-types)
   - [Speech-to-Text (STT) Models](#speech-to-text-stt-models)
   - [Text-to-Speech (TTS) Models](#text-to-speech-tts-models)
+  - [Speech Enhancement Models](#speech-enhancement-models)
 - [Documentation](#documentation)
 - [Requirements](#requirements)
 - [Breaking changes (upgrading to 0.3.0)](#breaking-changes-upgrading-to-030)
@@ -108,8 +109,8 @@ Full step-by-step: [Download manager – Setup (iOS & Android)](docs/download-ma
 
 | Platform | Version |
 |----------|---------|
-| Android | 1.12.31 |
-| iOS | 1.12.31 |
+| Android | 1.12.34 |
+| iOS | 1.12.34 |
 
 ## Feature Support
 
@@ -126,7 +127,7 @@ Full step-by-step: [Download manager – Setup (iOS & Android)](docs/download-ma
 | Model quantization | ✅ **Supported** | [Model setup](./docs/model-setup.md) | Automatic detection and preference for quantized (int8) models. |
 | Flexible model loading | ✅ **Supported** | [Model setup](./docs/model-setup.md) | Asset models, file system models, or auto-detection. |
 | TypeScript | ✅ **Supported** | — | Full type definitions included. |
-| Speech Enhancement | ❌ Not yet supported | [Enhancement](./docs/enhancement.md) | Scheduled for release 0.4.0 |
+| Speech Enhancement | ✅ **Supported** | [Speech Enhancement](./docs/speech-enhancement.md) | API and initialization covered in docs. |
 | Speaker Diarization | ❌ Not yet supported | [Diarization](./docs/diarization.md) | Scheduled for release 0.5.0 |
 | Source Separation | ❌ Not yet supported | [Separation](./docs/separation.md) | Scheduled for release 0.6.0 |
 | VAD (Voice Activity Detection) | ❌ Not yet supported | [VAD](./docs/vad.md) | Scheduled for release 0.7.0 |
@@ -184,6 +185,18 @@ For **real-time (streaming) recognition** from a microphone or audio stream, use
 
 For **streaming TTS** (incremental generation, low latency), use `createStreamingTTS()` with supported model types. See [Streaming Text-to-Speech](./docs/tts-streaming.md).
 
+### Speech Enhancement Models
+
+Speech enhancement improves noisy or degraded speech using ONNX models from the sherpa-onnx **speech-enhancement-models** release. Detection looks for **`.onnx`** filenames containing **`gtcrn`** or **`dpdfnet`** (case-insensitive). With **`'auto'`**, **GTCRN** is preferred when both are present in the same folder.
+
+| Model Type   | `modelType` Value | Description                                                                 | Download Links                                                                 |
+| ------------ | ----------------- | --------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| **Auto Detect** | `'auto'`       | Picks **GTCRN** if a matching `.onnx` exists, otherwise **DPDFNet** if found. | n/a                                                                              |
+| **GTCRN**    | `'gtcrn'`         | Lightweight speech enhancement (e.g. `gtcrn_simple.onnx`).                  | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/speech-enhancement-models) |
+| **DPDFNet**  | `'dpdfnet'`       | Deep speech enhancement variants (e.g. `dpdfnet2.onnx`, `dpdfnet4.onnx`, `dpdfnet8.onnx`, `dpdfnet_baseline.onnx`, `dpdfnet2_48khz_hr.onnx`). | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/speech-enhancement-models) |
+
+APIs, batch vs online processing, and initialization are covered in [Speech Enhancement](./docs/speech-enhancement.md).
+
 ## Documentation
 
 - [Known issues](./docs/KNOWN_ISSUES.md) – SDK-facing notes (e.g. Pocket TTS cloning / cross-platform behavior)
@@ -195,7 +208,7 @@ For **streaming TTS** (incremental generation, low latency), use `createStreamin
 - [Execution provider support (QNN, NNAPI, XNNPACK, Core ML)](./docs/execution-providers.md) – Checking and using acceleration backends
 - [Voice Activity Detection (VAD)](./docs/vad.md)
 - [Speaker Diarization](./docs/diarization.md)
-- [Speech Enhancement](./docs/enhancement.md)
+- [Speech Enhancement](./docs/speech-enhancement.md)
 - [Source Separation](./docs/separation.md)
 - [Model Setup](./docs/model-setup.md) – Bundled assets, Play Asset Delivery (PAD), model discovery APIs, and troubleshooting
 - [Model Download Manager](./docs/download-manager.md)

package/SherpaOnnx.podspec

@@ -94,6 +94,7 @@ Pod::Spec.new do |s|
     "\"#{pod_root}/ios/model_detect\"",
     "\"#{pod_root}/ios/stt\"",
     "\"#{pod_root}/ios/tts\"",
+    "\"#{pod_root}/ios/enhancement\"",
     "\"#{pod_root}/ios/online_stt\"",
     "\"#{device_headers}\"",
     "\"#{simulator_headers}\""

package/android/prebuilt-download.gradle

@@ -19,10 +19,12 @@ def requiredFfmpegSoFiles = [
   'libavcodec.so', 'libavformat.so', 'libavutil.so', 'libswresample.so', 'libavfilter.so', 'libshine.so'
 ]
 def requiredSherpaOnnxSoFiles = [
-  'libsherpa-onnx-jni.so', 'libsherpa-onnx-c-api.so', 'libsherpa-onnx-cxx-api.so', 'libonnxruntime.so'
+  'libsherpa-onnx-jni.so', 'libsherpa-onnx-c-api.so', 'libsherpa-onnx-cxx-api.so'
 ]
 def requiredLibarchiveSoFiles = ['libarchive.so', 'libzstd.so']
 def requiredOnnxruntimeJniSoFiles = ['libonnxruntime4j_jni.so']
+/** Both from the same onnxruntime release (AAR or third_party); required for Java ORT + symbol consistency. */
+def requiredOnnxruntimeBundleSoFiles = ['libonnxruntime4j_jni.so', 'libonnxruntime.so']
 
 def jniLibsDir = file("${project.projectDir}/src/main/jniLibs")
 def sherpaOnnxClassesDir = file("${project.buildDir}/sherpa-onnx-classes")
@@ -79,11 +81,12 @@ def hasLibarchiveHeaders = {
   return new File(project.projectDir, "src/main/cpp/include/libarchive/archive.h").exists()
 }
 
-def hasAllOnnxruntimeJniLibs = {
+/** Both ORT .so present per ABI (sherpa-onnx AAR no longer ships libonnxruntime.so). */
+def hasAllOnnxruntimeBundleLibs = {
   for (abi in requiredAbis) {
     def dir = new File(jniLibsDir, abi)
     if (!dir.exists()) return false
-    for (soName in requiredOnnxruntimeJniSoFiles) {
+    for (soName in requiredOnnxruntimeBundleSoFiles) {
       if (!new File(dir, soName).exists()) return false
     }
   }
@@ -163,14 +166,11 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
     def libarchiveHdrsOk = hasLibarchiveHeaders()
     def libarchiveNeedsUpdate = !libarchiveLibsOk || !libarchiveHdrsOk || storedLibarchiveVersion == null || storedLibarchiveVersion != currentLibarchiveVersion
 
-    def ortJniOk = hasAllOnnxruntimeJniLibs()
-
     println "[prebuilt] Resolution order: (1) THIRD_PARTY  (2) LOCAL_SDK  (3) MAVEN_AAR  (4) GITHUB_RELEASE — see docs/PREBUILT_RESOLUTION.md"
 
     def sherpaResolved = false
     def ffmpegResolved = false
     def libarchiveResolved = false
-    def ortJniResolved = ortJniOk
 
     // =====================================================================
     // sherpa-onnx: JNI (.so) + C headers
@@ -374,13 +374,55 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
     }
 
     // =====================================================================
-    // onnxruntime: JNI bridge only (libonnxruntime4j_jni.so)
-    // libonnxruntime.so comes from sherpa-onnx prebuilts; not extracted here.
+    // onnxruntime: libonnxruntime.so + libonnxruntime4j_jni.so (same ORT build)
+    //
+    // Java OrtEnvironment loads libonnxruntime4j_jni.so, which dlopen's libonnxruntime.so.
+    // Sherpa-onnx AAR does not ship libonnxruntime.so; both come from the onnxruntime AAR
+    // or a full third_party/onnxruntime_prebuilt/android bundle.
     // =====================================================================
-    if (!ortJniOk) {
-      // Stage 1: THIRD_PARTY
-      def tpJni = hasAllLibsUnder(thirdPartyOrtDir, requiredOnnxruntimeJniSoFiles)
-      if (tpJni) {
+    def ortMatchedPairCopied = false
+    if (hasAllLibsUnder(thirdPartyOrtDir, requiredOnnxruntimeBundleSoFiles)) {
+      requiredAbis.each { abi ->
+        copy {
+          from new File(thirdPartyOrtDir, "jni/${abi}")
+          include 'libonnxruntime4j_jni.so', 'libonnxruntime.so'
+          into new File(jniLibsDir, abi)
+        }
+      }
+      ortMatchedPairCopied = true
+      println "[onnxruntime] libonnxruntime.so + libonnxruntime4j_jni.so (matched pair) .... THIRD_PARTY  ${thirdPartyOrtDir}"
+    }
+    if (!ortMatchedPairCopied) {
+      try {
+        def aarFiles = project.configurations.onnxruntimeAar.files
+        if (!aarFiles.isEmpty()) {
+          downloadDir.mkdirs()
+          def aar = aarFiles.iterator().next()
+          def aarExtractDir = new File(downloadDir, "onnxruntime-aar-extract")
+          if (aarExtractDir.exists()) aarExtractDir.deleteDir()
+          aarExtractDir.mkdirs()
+          copy { from zipTree(aar); into aarExtractDir }
+          requiredAbis.each { abi ->
+            def aarJniDir = new File(aarExtractDir, "jni/${abi}")
+            if (aarJniDir.exists()) {
+              copy {
+                from aarJniDir
+                include 'libonnxruntime4j_jni.so', 'libonnxruntime.so'
+                into new File(jniLibsDir, abi)
+              }
+            }
+          }
+          ortMatchedPairCopied = true
+          println "[onnxruntime] libonnxruntime.so + libonnxruntime4j_jni.so (matched pair) .... MAVEN_AAR  ${aar.name}"
+        }
+      } catch (Exception e) {
+        println "[onnxruntime] MAVEN_AAR matched-pair copy failed: ${e.message}"
+      }
+    }
+    if (!ortMatchedPairCopied && !hasAllOnnxruntimeBundleLibs()) {
+      // Legacy: third_party with JNI only (incomplete bundle)
+      def tpJniOnly = hasAllLibsUnder(thirdPartyOrtDir, requiredOnnxruntimeJniSoFiles)
+      if (tpJniOnly) {
         requiredAbis.each { abi ->
           copy {
             from new File(thirdPartyOrtDir, "jni/${abi}")
@@ -388,18 +430,16 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             into new File(jniLibsDir, abi)
           }
         }
-        ortJniResolved = true
-        println "[onnxruntime] libonnxruntime4j_jni.so .......... THIRD_PARTY  ${thirdPartyOrtDir}"
+        println "[onnxruntime] libonnxruntime4j_jni.so only .... THIRD_PARTY  ${thirdPartyOrtDir}"
+        println "[onnxruntime]   WARN: no libonnxruntime.so in ort third_party — add full bundle or resolve onnxruntime AAR."
       }
-
-      // Stage 3: MAVEN_AAR
-      if (!ortJniResolved) {
+      if (!hasAllOnnxruntimeBundleLibs()) {
         try {
           def aarFiles = project.configurations.onnxruntimeAar.files
           if (!aarFiles.isEmpty()) {
             downloadDir.mkdirs()
             def aar = aarFiles.iterator().next()
-            def aarExtractDir = new File(downloadDir, "onnxruntime-aar-extract")
+            def aarExtractDir = new File(downloadDir, "onnxruntime-aar-extract-jni-only")
             if (aarExtractDir.exists()) aarExtractDir.deleteDir()
             aarExtractDir.mkdirs()
             copy { from zipTree(aar); into aarExtractDir }
@@ -413,18 +453,18 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
                 }
               }
             }
-            ortJniResolved = true
-            println "[onnxruntime] libonnxruntime4j_jni.so .......... MAVEN_AAR  ${aar.name}"
-            println "[onnxruntime]   install: per ABI --> ${jniLibsHuman}/<abi>/ (only JNI bridge; libonnxruntime.so from sherpa prebuilts)"
+            println "[onnxruntime] libonnxruntime4j_jni.so only .... MAVEN_AAR  ${aar.name}"
+            println "[onnxruntime]   WARN: AAR jni/<abi> missing libonnxruntime.so — use a complete onnxruntime AAR."
           } else {
-            println "[onnxruntime] MAVEN_AAR: onnxruntimeAar empty — libonnxruntime4j_jni.so still missing"
+            println "[onnxruntime] MAVEN_AAR: onnxruntimeAar empty — ORT native libs still missing"
           }
         } catch (Exception e) {
-          println "[onnxruntime] MAVEN_AAR failed: ${e.message}"
+          println "[onnxruntime] MAVEN_AAR jni-only failed: ${e.message}"
         }
       }
-    } else {
-      println "[onnxruntime] libonnxruntime4j_jni.so (per ABI) .... LOCAL_SDK"
+    }
+    if (!hasAllOnnxruntimeBundleLibs()) {
+      println "[onnxruntime] WARN: libonnxruntime.so and/or libonnxruntime4j_jni.so missing after resolution. checkJniLibs will fail; use com.xdcobra.sherpa:onnxruntime or full third_party bundle."
     }
 
     // =====================================================================
@@ -598,10 +638,10 @@ project.tasks.register("checkJniLibs") {
           }
         }
       }
-      requiredOnnxruntimeJniSoFiles.each { soName ->
+      requiredOnnxruntimeBundleSoFiles.each { soName ->
         def soFile = new File(dir, soName)
         if (!soFile.exists()) {
-          throw new RuntimeException("Missing onnxruntime JNI bridge '${soName}' for ABI ${abi}. Ensure Maven com.xdcobra.sherpa:onnxruntime is available.")
+          throw new RuntimeException("Missing onnxruntime native library '${soName}' for ABI ${abi}. Ensure Maven com.xdcobra.sherpa:onnxruntime (libonnxruntime.so + libonnxruntime4j_jni.so) resolves.")
         }
       }
     }

package/android/prebuilt-versions.gradle

@@ -45,7 +45,7 @@ println "[react-native-sherpa-onnx] libarchive version (extracted/used): ${libar
 def ortVersion = System.getenv('ORT_VERSION')
 if (!ortVersion) {
   def v = readVersionFromTagFile(new File(moduleRoot, 'third_party/onnxruntime_prebuilt/ANDROID_RELEASE_TAG'), 'ort-android-qnn-v')
-  ortVersion = v ?: (project.hasProperty('ortVersion') ? project.ortVersion : '1.24.2-qnn2.43.1.260218')
+  ortVersion = v ?: (project.hasProperty('ortVersion') ? project.ortVersion : '1.24.4-qnn2.43.1.260218-1')
 }
 project.ext.ortVersion = ortVersion
 println "[react-native-sherpa-onnx] onnxruntime version (extracted/used): ${ortVersion}"

package/android/src/main/assets/model_licenses/speech-enhancement-models-license-status.csv

@@ -0,0 +1,7 @@
+asset_name,license_type,commercial_use,confidence,detection_source,license_file
+dpdfnet2.onnx,apache-2.0,yes,high,manual,https://huggingface.co/Ceva-IP/DPDFNet/tree/main/onnx
+dpdfnet2_48khz_hr.onnx,apache-2.0,yes,high,manual,https://huggingface.co/Ceva-IP/DPDFNet/tree/main/onnx
+dpdfnet4.onnx,apache-2.0,yes,high,manual,https://huggingface.co/Ceva-IP/DPDFNet/tree/main/onnx
+dpdfnet8.onnx,apache-2.0,yes,high,manual,https://huggingface.co/Ceva-IP/DPDFNet/tree/main/onnx
+dpdfnet_baseline.onnx,apache-2.0,yes,high,manual,https://huggingface.co/Ceva-IP/DPDFNet/tree/main/onnx
+gtcrn_simple.onnx,mit,yes,high,manual,https://github.com/Xiaobin-Rong/gtcrn/tree/main

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

@@ -83,11 +83,14 @@ set(SOURCES
     jni/model_detect/sherpa-onnx-model-detect-helper.cpp
     jni/model_detect/sherpa-onnx-model-detect-stt.cpp
     jni/model_detect/sherpa-onnx-model-detect-tts.cpp
+    jni/model_detect/sherpa-onnx-model-detect-enhancement.cpp
     jni/model_detect/sherpa-onnx-validate-stt.cpp
     jni/model_detect/sherpa-onnx-validate-tts.cpp
+    jni/model_detect/sherpa-onnx-validate-enhancement.cpp
     jni/model_detect/sherpa-onnx-detect-jni-common.cpp
     jni/model_detect/sherpa-onnx-stt-wrapper.cpp
     jni/model_detect/sherpa-onnx-tts-wrapper.cpp
+    jni/model_detect/sherpa-onnx-enhancement-wrapper.cpp
     jni/audio/sherpa-onnx-audio-convert-jni.cpp
     crypto/sha256.cpp
 )

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-enhancement-wrapper.cpp

@@ -0,0 +1,68 @@
+#include "sherpa-onnx-enhancement-wrapper.h"
+
+#include "sherpa-onnx-detect-jni-common.h"
+
+namespace sherpaonnx {
+namespace {
+
+const char* EnhancementModelKindToString(EnhancementModelKind k) {
+  switch (k) {
+    case EnhancementModelKind::kGtcrn:
+      return "gtcrn";
+    case EnhancementModelKind::kDpdfNet:
+      return "dpdfnet";
+    default:
+      return "unknown";
+  }
+}
+
+} // namespace
+
+jobject EnhancementDetectResultToJava(
+    JNIEnv* env,
+    const EnhancementDetectResult& result
+) {
+  jclass mapClass = env->FindClass("java/util/HashMap");
+  if (!mapClass) return nullptr;
+  jmethodID mapInit = env->GetMethodID(mapClass, "<init>", "()V");
+  jmethodID mapPut =
+      env->GetMethodID(mapClass, "put",
+                       "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+  if (!mapInit || !mapPut) {
+    env->DeleteLocalRef(mapClass);
+    return nullptr;
+  }
+  jobject map = env->NewObject(mapClass, mapInit);
+  env->DeleteLocalRef(mapClass);
+  if (!map) return nullptr;
+
+  PutBoolean(env, map, mapPut, "success", result.ok);
+  PutString(env, map, mapPut, "error", result.error);
+  PutString(env, map, mapPut, "modelType",
+            EnhancementModelKindToString(result.selectedKind));
+
+  jobject detectedList = BuildDetectedModelsList(env, result.detectedModels);
+  if (detectedList) {
+    jstring keyDetected = env->NewStringUTF("detectedModels");
+    env->CallObjectMethod(map, mapPut, keyDetected, detectedList);
+    env->DeleteLocalRef(keyDetected);
+    env->DeleteLocalRef(detectedList);
+  }
+
+  jclass hashMapClass = env->FindClass("java/util/HashMap");
+  if (hashMapClass) {
+    jobject pathsMap = env->NewObject(hashMapClass, mapInit);
+    env->DeleteLocalRef(hashMapClass);
+    if (pathsMap) {
+      PutString(env, pathsMap, mapPut, "model", result.paths.model);
+      jstring keyPaths = env->NewStringUTF("paths");
+      env->CallObjectMethod(map, mapPut, keyPaths, pathsMap);
+      env->DeleteLocalRef(keyPaths);
+      env->DeleteLocalRef(pathsMap);
+    }
+  }
+
+  return map;
+}
+
+} // namespace sherpaonnx

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-enhancement-wrapper.h

@@ -0,0 +1,17 @@
+#ifndef SHERPA_ONNX_ENHANCEMENT_WRAPPER_H
+#define SHERPA_ONNX_ENHANCEMENT_WRAPPER_H
+
+#include <jni.h>
+
+#include "sherpa-onnx-model-detect.h"
+
+namespace sherpaonnx {
+
+jobject EnhancementDetectResultToJava(
+    JNIEnv* env,
+    const EnhancementDetectResult& result
+);
+
+} // namespace sherpaonnx
+
+#endif // SHERPA_ONNX_ENHANCEMENT_WRAPPER_H

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

@@ -0,0 +1,119 @@
+#include "sherpa-onnx-model-detect.h"
+#include "sherpa-onnx-model-detect-helper.h"
+#include "sherpa-onnx-validate-enhancement.h"
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace {
+
+using namespace sherpaonnx::model_detect;
+
+sherpaonnx::EnhancementModelKind ParseEnhancementModelType(const std::string& modelType) {
+    if (modelType == "gtcrn") return sherpaonnx::EnhancementModelKind::kGtcrn;
+    if (modelType == "dpdfnet") return sherpaonnx::EnhancementModelKind::kDpdfNet;
+    return sherpaonnx::EnhancementModelKind::kUnknown;
+}
+
+sherpaonnx::EnhancementDetectResult DetectEnhancementModelFromFiles(
+    const std::vector<FileEntry>& files,
+    const std::string& modelDir,
+    const std::string& modelType
+) {
+    sherpaonnx::EnhancementDetectResult result;
+
+    const std::string gtcrnModel =
+        FindOnnxByAnyToken(files, {"gtcrn"}, std::nullopt);
+    const std::string dpdfnetModel =
+        FindOnnxByAnyToken(files, {"dpdfnet"}, std::nullopt);
+
+    if (!gtcrnModel.empty()) {
+        result.detectedModels.push_back({"gtcrn", modelDir});
+    }
+    if (!dpdfnetModel.empty()) {
+        result.detectedModels.push_back({"dpdfnet", modelDir});
+    }
+
+    sherpaonnx::EnhancementModelKind selected = sherpaonnx::EnhancementModelKind::kUnknown;
+    if (modelType == "auto" || modelType.empty()) {
+        if (!gtcrnModel.empty()) {
+            selected = sherpaonnx::EnhancementModelKind::kGtcrn;
+        } else if (!dpdfnetModel.empty()) {
+            selected = sherpaonnx::EnhancementModelKind::kDpdfNet;
+        }
+    } else {
+        selected = ParseEnhancementModelType(modelType);
+        if (selected == sherpaonnx::EnhancementModelKind::kUnknown) {
+            result.error = "Enhancement: unknown model type: " + modelType;
+            return result;
+        }
+    }
+
+    switch (selected) {
+        case sherpaonnx::EnhancementModelKind::kGtcrn:
+            result.paths.model = gtcrnModel;
+            break;
+        case sherpaonnx::EnhancementModelKind::kDpdfNet:
+            result.paths.model = dpdfnetModel;
+            break;
+        default:
+            result.error = "Enhancement: no compatible model type detected in " +
+                           modelDir;
+            return result;
+    }
+
+    auto validation =
+        sherpaonnx::ValidateEnhancementPaths(selected, result.paths, modelDir);
+    if (!validation.ok) {
+        result.error = validation.error;
+        return result;
+    }
+
+    result.selectedKind = selected;
+    result.ok = true;
+    return result;
+}
+
+} // namespace
+
+namespace sherpaonnx {
+
+using namespace model_detect;
+
+EnhancementDetectResult DetectEnhancementModel(
+    const std::string& modelDir,
+    const std::string& modelType
+) {
+    EnhancementDetectResult result;
+
+    if (modelDir.empty()) {
+        result.error = "Enhancement: model directory is empty";
+        return result;
+    }
+    if (!FileExists(modelDir) || !IsDirectory(modelDir)) {
+        result.error =
+            "Enhancement: model directory does not exist or is not a directory: " +
+            modelDir;
+        return result;
+    }
+
+    const std::vector<model_detect::FileEntry> files = ListFilesRecursive(modelDir, 4);
+    return DetectEnhancementModelFromFiles(files, modelDir, modelType);
+}
+
+// Test-only: used by host-side model_detect_test; not used in production.
+EnhancementDetectResult DetectEnhancementModelFromFileList(
+    const std::vector<model_detect::FileEntry>& files,
+    const std::string& modelDir,
+    const std::string& modelType
+) {
+    EnhancementDetectResult result;
+    if (modelDir.empty()) {
+        result.error = "Enhancement: model directory is empty";
+        return result;
+    }
+    return DetectEnhancementModelFromFiles(files, modelDir, modelType);
+}
+
+} // namespace sherpaonnx

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

@@ -43,6 +43,12 @@ enum class TtsModelKind {
     kSupertonic
 };
 
+enum class EnhancementModelKind {
+    kUnknown,
+    kGtcrn,
+    kDpdfNet
+};
+
 struct SttModelPaths {
     std::string encoder;
     std::string decoder;
@@ -174,6 +180,10 @@ struct TtsModelPaths {
     std::string voiceStyle;
 };
 
+struct EnhancementModelPaths {
+    std::string model;
+};
+
 struct SttDetectResult {
     bool ok = false;
     std::string error;
@@ -195,6 +205,14 @@ struct TtsDetectResult {
     std::vector<std::string> lexiconLanguageCandidates;
 };
 
+struct EnhancementDetectResult {
+    bool ok = false;
+    std::string error;
+    std::vector<DetectedModel> detectedModels;
+    EnhancementModelKind selectedKind = EnhancementModelKind::kUnknown;
+    EnhancementModelPaths paths;
+};
+
 SttDetectResult DetectSttModel(
     const std::string& modelDir,
     const std::optional<bool>& preferInt8,
@@ -228,6 +246,19 @@ TtsDetectResult DetectTtsModelFromFileList(
     const std::string& modelType = "auto"
 );
 
+EnhancementDetectResult DetectEnhancementModel(
+    const std::string& modelDir,
+    const std::string& modelType
+);
+
+/** Test-only: Like DetectEnhancementModel but takes a pre-built file list; no filesystem access.
+ *  Only used by the host-side C++ test suite (test/cpp/model_detect_test.cpp). */
+EnhancementDetectResult DetectEnhancementModelFromFileList(
+    const std::vector<model_detect::FileEntry>& files,
+    const std::string& modelDir,
+    const std::string& modelType = "auto"
+);
+
 } // namespace sherpaonnx
 
 #endif // SHERPA_ONNX_MODEL_DETECT_H

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

@@ -0,0 +1,68 @@
+#include "sherpa-onnx-validate-enhancement.h"
+
+#include <cstddef>
+
+namespace sherpaonnx {
+namespace {
+
+static const EnhancementFieldRequirement kGenericReqs[] = {
+    {"model", &EnhancementModelPaths::model, true},
+};
+
+static const EnhancementFieldRequirement* GetRequirements(
+    EnhancementModelKind kind,
+    size_t& count
+) {
+    switch (kind) {
+        case EnhancementModelKind::kGtcrn:
+        case EnhancementModelKind::kDpdfNet:
+            count = std::size(kGenericReqs);
+            return kGenericReqs;
+        default:
+            count = 0;
+            return nullptr;
+    }
+}
+
+static const char* EnhancementKindToName(EnhancementModelKind kind) {
+    switch (kind) {
+        case EnhancementModelKind::kGtcrn:
+            return "GTCRN";
+        case EnhancementModelKind::kDpdfNet:
+            return "DPDFNet";
+        default:
+            return "Unknown";
+    }
+}
+
+} // namespace
+
+EnhancementValidationResult ValidateEnhancementPaths(
+    EnhancementModelKind kind,
+    const EnhancementModelPaths& paths,
+    const std::string& modelDir
+) {
+    EnhancementValidationResult result;
+    size_t count = 0;
+    const auto* reqs = GetRequirements(kind, count);
+    if (!reqs) return result;
+
+    for (size_t i = 0; i < count; ++i) {
+        if (reqs[i].required && (paths.*(reqs[i].field)).empty()) {
+            result.missingRequired.push_back(reqs[i].fieldName);
+        }
+    }
+
+    if (!result.missingRequired.empty()) {
+        result.ok = false;
+        result.error = std::string("Enhancement ") + EnhancementKindToName(kind) +
+                       ": missing required files in " + modelDir + ": ";
+        for (size_t i = 0; i < result.missingRequired.size(); ++i) {
+            if (i > 0) result.error += ", ";
+            result.error += result.missingRequired[i];
+        }
+    }
+    return result;
+}
+
+} // namespace sherpaonnx

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

@@ -0,0 +1,30 @@
+#ifndef SHERPA_ONNX_VALIDATE_ENHANCEMENT_H
+#define SHERPA_ONNX_VALIDATE_ENHANCEMENT_H
+
+#include "sherpa-onnx-model-detect.h"
+#include <string>
+#include <vector>
+
+namespace sherpaonnx {
+
+struct EnhancementFieldRequirement {
+    const char* fieldName;
+    std::string EnhancementModelPaths::* field;
+    bool required;
+};
+
+struct EnhancementValidationResult {
+    bool ok = true;
+    std::vector<std::string> missingRequired;
+    std::string error;
+};
+
+EnhancementValidationResult ValidateEnhancementPaths(
+    EnhancementModelKind kind,
+    const EnhancementModelPaths& paths,
+    const std::string& modelDir
+);
+
+} // namespace sherpaonnx
+
+#endif // SHERPA_ONNX_VALIDATE_ENHANCEMENT_H

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

@@ -20,6 +20,7 @@
 #include "sherpa-onnx-model-detect.h"
 #include "sherpa-onnx-stt-wrapper.h"
 #include "sherpa-onnx-tts-wrapper.h"
+#include "sherpa-onnx-enhancement-wrapper.h"
 
 extern "C" {
 
@@ -187,4 +188,24 @@ Java_com_sherpaonnx_SherpaOnnxModule_nativeDetectTtsModel(
   return sherpaonnx::TtsDetectResultToJava(env, result);
 }
 
+// Detect enhancement model in directory. Returns HashMap with success, error, detectedModels, modelType, paths.
+JNIEXPORT jobject JNICALL
+Java_com_sherpaonnx_SherpaOnnxModule_nativeDetectEnhancementModel(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring j_model_dir,
+    jstring j_model_type) {
+  const char* model_dir_c = env->GetStringUTFChars(j_model_dir, nullptr);
+  const char* model_type_c =
+      j_model_type ? env->GetStringUTFChars(j_model_type, nullptr) : nullptr;
+  std::string model_dir(model_dir_c ? model_dir_c : "");
+  std::string model_type(model_type_c ? model_type_c : "auto");
+  env->ReleaseStringUTFChars(j_model_dir, model_dir_c);
+  if (model_type_c) env->ReleaseStringUTFChars(j_model_type, model_type_c);
+
+  sherpaonnx::EnhancementDetectResult result =
+      sherpaonnx::DetectEnhancementModel(model_dir, model_type);
+  return sherpaonnx::EnhancementDetectResultToJava(env, result);
+}
+
 }  // extern "C"