react-native-sherpa-onnx 0.3.8 → 0.4.0

package/android/src/main/java/com/sherpaonnx/SherpaOnnxArchiveHelper.kt

@@ -54,7 +54,8 @@ class SherpaOnnxArchiveHelper {
     targetPath: String,
     force: Boolean,
     promise: Promise,
-    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
   ) {
     val promiseSettled = AtomicBoolean(false)
     fun resolveOnce(success: Boolean, reason: String? = null) {
@@ -70,26 +71,28 @@ class SherpaOnnxArchiveHelper {
       val cancelFlag = AtomicBoolean(false)
       cancelFlags[sourcePath] = cancelFlag
 
-      // Create a progress callback object that JNI can call
-      val progressCallback = object : Any() {
-        fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
-          onProgress(bytesExtracted, totalBytes, percent)
-        }
-      }
-
       // Run extraction on a background thread so the React Native bridge thread is not blocked.
       // The thread pool allows multiple extractions in parallel.
       extractExecutor.execute {
+        val notif = extractionNotification
         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)
+          notif?.start()
+          val wrappedCallback = object : Any() {
+            fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+              onProgress(bytesExtracted, totalBytes, percent)
+              notif?.updateProgress(percent)
+            }
+          }
+          nativeExtractTarBz2(sourcePath, targetPath, force, wrappedCallback, promise)
         } catch (e: Exception) {
           resolveOnce(false, "Archive extraction error: ${e.message}")
         } finally {
+          notif?.finish()
           cancelFlags.remove(sourcePath)
         }
       }
@@ -104,7 +107,8 @@ class SherpaOnnxArchiveHelper {
     targetPath: String,
     force: Boolean,
     promise: Promise,
-    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
   ) {
     val promiseSettled = AtomicBoolean(false)
     fun resolveOnce(success: Boolean, reason: String? = null) {
@@ -119,22 +123,26 @@ class SherpaOnnxArchiveHelper {
       val cancelFlag = AtomicBoolean(false)
       cancelFlags[sourcePath] = cancelFlag
 
-      val progressCallback = object : Any() {
-        fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
-          onProgress(bytesExtracted, totalBytes, percent)
-        }
-      }
       extractExecutor.execute {
+        val notif = extractionNotification
         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)
+          notif?.start()
+          val wrappedCallback = object : Any() {
+            fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+              onProgress(bytesExtracted, totalBytes, percent)
+              notif?.updateProgress(percent)
+            }
+          }
+          nativeExtractTarZst(sourcePath, targetPath, force, wrappedCallback, promise)
         } catch (e: Exception) {
           resolveOnce(false, "Archive extraction error: ${e.message}")
         } finally {
+          notif?.finish()
           cancelFlags.remove(sourcePath)
         }
       }
@@ -144,47 +152,106 @@ class SherpaOnnxArchiveHelper {
     }
   }
 
+  /**
+   * Which JNI stream entry to use for APK asset extraction.
+   *
+   * Both paths invoke libarchive’s `ExtractFromStream`, which **auto-detects** compression
+   * (`.tar.zst` vs `.tar.bz2`, etc.); `nativeExtractTarBz2FromStream` forwards to the same
+   * native implementation as zst. Keeping distinct JNI symbols preserves a clear API and avoids
+   * the impression that bz2 assets are mistakenly wired only to a “zst” method.
+   */
+  private enum class AssetTarStreamKind {
+    ZST,
+    BZ2,
+  }
+
   fun extractTarZstFromAsset(
     context: Context,
     assetPath: String,
     targetPath: String,
     force: Boolean,
     promise: Promise,
-    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
+  ) {
+    extractTarArchiveFromAsset(
+      context,
+      assetPath,
+      targetPath,
+      force,
+      promise,
+      onProgress,
+      extractionNotification,
+      AssetTarStreamKind.ZST,
+    )
+  }
+
+  fun extractTarBz2FromAsset(
+    context: Context,
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
+  ) {
+    extractTarArchiveFromAsset(
+      context,
+      assetPath,
+      targetPath,
+      force,
+      promise,
+      onProgress,
+      extractionNotification,
+      AssetTarStreamKind.BZ2,
+    )
+  }
+
+  private fun extractTarArchiveFromAsset(
+    context: Context,
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit,
+    extractionNotification: SherpaOnnxExtractionNotificationHelper? = null,
+    kind: AssetTarStreamKind,
   ) {
     if (BuildConfig.DEBUG) {
-      Log.i("SherpaOnnx", "extractTarZstFromAsset assetPath=$assetPath targetPath=$targetPath")
-    }
-    val progressCallback = object : Any() {
-      fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
-        onProgress(bytesExtracted, totalBytes, percent)
-      }
+      Log.i(
+        "SherpaOnnx",
+        "extractTar${if (kind == AssetTarStreamKind.ZST) "Zst" else "Bz2"}FromAsset assetPath=$assetPath targetPath=$targetPath",
+      )
     }
     extractExecutor.execute {
+      val notif = extractionNotification
       try {
+        notif?.start()
+        val progressCallback = object : Any() {
+          fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+            onProgress(bytesExtracted, totalBytes, percent)
+            notif?.updateProgress(percent)
+          }
+        }
         context.assets.open(assetPath).use { stream ->
-          nativeExtractTarZstFromStream(stream, targetPath, force, progressCallback, promise)
+          when (kind) {
+            AssetTarStreamKind.ZST ->
+              nativeExtractTarZstFromStream(stream, targetPath, force, progressCallback, promise)
+            AssetTarStreamKind.BZ2 ->
+              nativeExtractTarBz2FromStream(stream, targetPath, force, progressCallback, promise)
+          }
         }
       } catch (e: Exception) {
         val result = Arguments.createMap()
         result.putBoolean("success", false)
         result.putString("reason", e.message ?: "Failed to open asset")
         promise.resolve(result)
+      } finally {
+        notif?.finish()
       }
     }
   }
 
-  fun extractTarBz2FromAsset(
-    context: Context,
-    assetPath: String,
-    targetPath: String,
-    force: Boolean,
-    promise: Promise,
-    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
-  ) {
-    extractTarZstFromAsset(context, assetPath, targetPath, force, promise, onProgress)
-  }
-
   fun computeFileSha256(filePath: String, promise: Promise) {
     nativeComputeFileSha256(filePath, promise)
   }
@@ -214,6 +281,14 @@ class SherpaOnnxArchiveHelper {
     promise: Promise
   )
 
+  private external fun nativeExtractTarBz2FromStream(
+    inputStream: java.io.InputStream,
+    targetPath: String,
+    force: Boolean,
+    progressCallback: Any?,
+    promise: Promise
+  )
+
   private external fun nativeCancelExtract()
 
   private external fun nativeComputeFileSha256(

package/android/src/main/java/com/sherpaonnx/SherpaOnnxAssetHelper.kt

@@ -382,13 +382,19 @@ internal class SherpaOnnxAssetHelper(
       "mms",
       "tts"
     )
+    val enhancementHints = listOf(
+      "gtcrn",
+      "dpdfnet"
+    )
 
     val isStt = sttHints.any { name.contains(it) }
     val isTts = ttsHints.any { name.contains(it) }
+    val isEnhancement = enhancementHints.any { name.contains(it) }
 
     return when {
       isStt && !isTts -> "stt"
       isTts && !isStt -> "tts"
+      isEnhancement && !isStt && !isTts -> "enhancement"
       else -> "unknown"
     }
   }

package/android/src/main/java/com/sherpaonnx/SherpaOnnxEnhancementHelper.kt

@@ -0,0 +1,377 @@
+package com.sherpaonnx
+
+import android.net.Uri
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.k2fsa.sherpa.onnx.DenoisedAudio
+import com.k2fsa.sherpa.onnx.OfflineSpeechDenoiser
+import com.k2fsa.sherpa.onnx.OfflineSpeechDenoiserConfig
+import com.k2fsa.sherpa.onnx.OfflineSpeechDenoiserDpdfNetModelConfig
+import com.k2fsa.sherpa.onnx.OfflineSpeechDenoiserGtcrnModelConfig
+import com.k2fsa.sherpa.onnx.OfflineSpeechDenoiserModelConfig
+import com.k2fsa.sherpa.onnx.OnlineSpeechDenoiser
+import com.k2fsa.sherpa.onnx.OnlineSpeechDenoiserConfig
+import com.k2fsa.sherpa.onnx.WaveReader
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+
+internal class SherpaOnnxEnhancementHelper(
+  private val context: ReactApplicationContext,
+  private val nativeDetectEnhancementModel: (modelDir: String, modelType: String) -> HashMap<String, Any>?
+) {
+  private data class EnhancementInstance(
+    @Volatile var denoiser: OfflineSpeechDenoiser? = null
+  ) {
+    fun release() {
+      denoiser?.release()
+      denoiser = null
+    }
+  }
+
+  private data class OnlineEnhancementInstance(
+    @Volatile var denoiser: OnlineSpeechDenoiser? = null
+  ) {
+    fun release() {
+      denoiser?.release()
+      denoiser = null
+    }
+  }
+
+  private val instances = ConcurrentHashMap<String, EnhancementInstance>()
+  private val onlineInstances = ConcurrentHashMap<String, OnlineEnhancementInstance>()
+
+  fun shutdown() {
+    instances.values.forEach { it.release() }
+    instances.clear()
+    onlineInstances.values.forEach { it.release() }
+    onlineInstances.clear()
+  }
+
+  private fun path(map: Map<String, String>, key: String): String = map[key].orEmpty()
+
+  private fun toEnhancedAudioMap(audio: DenoisedAudio): WritableMap {
+    val samples = Arguments.createArray()
+    for (sample in audio.samples) {
+      samples.pushDouble(sample.toDouble())
+    }
+    val out = Arguments.createMap()
+    out.putArray("samples", samples)
+    out.putInt("sampleRate", audio.sampleRate)
+    return out
+  }
+
+  private fun readableArrayToFloatArray(samples: ReadableArray): FloatArray {
+    val out = FloatArray(samples.size())
+    for (i in 0 until samples.size()) {
+      out[i] = samples.getDouble(i).toFloat()
+    }
+    return out
+  }
+
+  private fun copyContentUriToTemp(path: String, prefix: String): Pair<String, File?> {
+    if (!path.startsWith("content://")) return Pair(path, null)
+    val uri = Uri.parse(path)
+    val tmp = File(context.cacheDir, "${prefix}_${System.nanoTime()}.wav")
+    context.contentResolver.openInputStream(uri)?.use { input ->
+      tmp.outputStream().use { output -> input.copyTo(output) }
+    } ?: throw IllegalStateException("File is not readable: $path")
+    return Pair(tmp.absolutePath, tmp)
+  }
+
+  fun detectEnhancementModel(
+    modelDir: String,
+    modelType: String?,
+    promise: Promise
+  ) {
+    try {
+      val result = nativeDetectEnhancementModel(modelDir, modelType ?: "auto")
+      if (result == null) {
+        promise.reject("DETECT_ERROR", "Enhancement model detection returned null")
+        return
+      }
+      val success = result["success"] as? Boolean ?: false
+      val detectedModels = result["detectedModels"] as? ArrayList<*>
+        ?: arrayListOf<HashMap<String, String>>()
+      val modelTypeStr = result["modelType"] as? String
+
+      val resultMap = Arguments.createMap()
+      resultMap.putBoolean("success", success)
+      val modelsArray = Arguments.createArray()
+      for (model in detectedModels) {
+        val modelMap = model as? HashMap<*, *>
+        if (modelMap != null) {
+          val entry = Arguments.createMap()
+          entry.putString("type", modelMap["type"] as? String ?: "")
+          entry.putString("modelDir", modelMap["modelDir"] as? String ?: "")
+          modelsArray.pushMap(entry)
+        }
+      }
+      resultMap.putArray("detectedModels", modelsArray)
+      if (modelTypeStr != null) {
+        resultMap.putString("modelType", modelTypeStr)
+      }
+      if (!success) {
+        val error = result["error"] as? String
+        if (!error.isNullOrBlank()) {
+          resultMap.putString("error", error)
+        }
+      }
+      promise.resolve(resultMap)
+    } catch (e: Exception) {
+      Log.e("SherpaOnnxEnhancement", "Enhancement detection failed", e)
+      promise.reject("DETECT_ERROR", "Enhancement model detection failed: ${e.message}", e)
+    }
+  }
+
+  fun initializeEnhancement(
+    instanceId: String,
+    modelDir: String,
+    modelType: String?,
+    numThreads: Double?,
+    provider: String?,
+    debug: Boolean?,
+    promise: Promise
+  ) {
+    try {
+      val result = nativeDetectEnhancementModel(modelDir, modelType ?: "auto")
+      if (result == null || result["success"] as? Boolean != true) {
+        val reason = result?.get("error") as? String ?: "Failed to detect enhancement model"
+        promise.reject("ENHANCEMENT_INIT_ERROR", reason)
+        return
+      }
+      val modelTypeStr = result["modelType"] as? String ?: "gtcrn"
+      val paths = (result["paths"] as? Map<*, *>)
+        ?.mapValues { (_, v) -> (v as? String).orEmpty() }
+        ?.mapKeys { it.key.toString() }
+        ?: emptyMap()
+
+      val offlineModelConfig = when (modelTypeStr) {
+        "gtcrn" -> OfflineSpeechDenoiserModelConfig(
+          gtcrn = OfflineSpeechDenoiserGtcrnModelConfig(model = path(paths, "model")),
+          numThreads = numThreads?.toInt() ?: 1,
+          provider = provider ?: "cpu",
+          debug = debug ?: false
+        )
+        "dpdfnet" -> OfflineSpeechDenoiserModelConfig(
+          dpdfnet = OfflineSpeechDenoiserDpdfNetModelConfig(model = path(paths, "model")),
+          numThreads = numThreads?.toInt() ?: 1,
+          provider = provider ?: "cpu",
+          debug = debug ?: false
+        )
+        else -> {
+          promise.reject("ENHANCEMENT_INIT_ERROR", "Unsupported enhancement model type: $modelTypeStr")
+          return
+        }
+      }
+
+      val inst = instances.getOrPut(instanceId) { EnhancementInstance() }
+      inst.release()
+      val denoiser = OfflineSpeechDenoiser(
+        config = OfflineSpeechDenoiserConfig(model = offlineModelConfig)
+      )
+      inst.denoiser = denoiser
+
+      val modelsArray = Arguments.createArray()
+      val detectedModels = result["detectedModels"] as? ArrayList<*>
+      detectedModels?.forEach { modelObj ->
+        if (modelObj is HashMap<*, *>) {
+          val modelMap = Arguments.createMap()
+          modelMap.putString("type", modelObj["type"] as? String ?: "")
+          modelMap.putString("modelDir", modelObj["modelDir"] as? String ?: "")
+          modelsArray.pushMap(modelMap)
+        }
+      }
+
+      val out = Arguments.createMap()
+      out.putBoolean("success", true)
+      out.putArray("detectedModels", modelsArray)
+      out.putString("modelType", modelTypeStr)
+      out.putInt("sampleRate", denoiser.sampleRate)
+      promise.resolve(out)
+    } catch (e: Exception) {
+      Log.e("SherpaOnnxEnhancement", "Failed to initialize enhancement", e)
+      promise.reject("ENHANCEMENT_INIT_ERROR", "Failed to initialize enhancement: ${e.message}", e)
+    }
+  }
+
+  fun enhanceSamples(
+    instanceId: String,
+    samples: ReadableArray,
+    sampleRate: Double,
+    promise: Promise
+  ) {
+    val inst = instances[instanceId]
+    val denoiser = inst?.denoiser
+    if (denoiser == null) {
+      promise.reject("ENHANCEMENT_ERROR", "Enhancement instance not found: $instanceId")
+      return
+    }
+    try {
+      val audio = denoiser.run(readableArrayToFloatArray(samples), sampleRate.toInt())
+      promise.resolve(toEnhancedAudioMap(audio))
+    } catch (e: Exception) {
+      promise.reject("ENHANCEMENT_ERROR", "Failed to enhance samples: ${e.message}", e)
+    }
+  }
+
+  fun enhanceFile(
+    instanceId: String,
+    inputPath: String,
+    outputPath: String?,
+    promise: Promise
+  ) {
+    val inst = instances[instanceId]
+    val denoiser = inst?.denoiser
+    if (denoiser == null) {
+      promise.reject("ENHANCEMENT_ERROR", "Enhancement instance not found: $instanceId")
+      return
+    }
+
+    var tmpInput: File? = null
+    try {
+      val (resolvedInputPath, tmp) = copyContentUriToTemp(inputPath, "enhancement_in")
+      tmpInput = tmp
+      val wave = WaveReader.readWave(resolvedInputPath)
+      val audio = denoiser.run(wave.samples, wave.sampleRate)
+      if (!outputPath.isNullOrBlank()) {
+        audio.save(outputPath)
+      }
+      promise.resolve(toEnhancedAudioMap(audio))
+    } catch (e: Exception) {
+      promise.reject("ENHANCEMENT_ERROR", "Failed to enhance file: ${e.message}", e)
+    } finally {
+      tmpInput?.delete()
+    }
+  }
+
+  fun getSampleRate(instanceId: String, promise: Promise) {
+    val inst = instances[instanceId]
+    val denoiser = inst?.denoiser
+    if (denoiser == null) {
+      promise.reject("ENHANCEMENT_ERROR", "Enhancement instance not found: $instanceId")
+      return
+    }
+    promise.resolve(denoiser.sampleRate)
+  }
+
+  fun unloadEnhancement(instanceId: String, promise: Promise) {
+    instances.remove(instanceId)?.release()
+    promise.resolve(null)
+  }
+
+  fun initializeOnlineEnhancement(
+    instanceId: String,
+    modelDir: String,
+    modelType: String?,
+    numThreads: Double?,
+    provider: String?,
+    debug: Boolean?,
+    promise: Promise
+  ) {
+    try {
+      val result = nativeDetectEnhancementModel(modelDir, modelType ?: "auto")
+      if (result == null || result["success"] as? Boolean != true) {
+        val reason = result?.get("error") as? String ?: "Failed to detect enhancement model"
+        promise.reject("ONLINE_ENHANCEMENT_INIT_ERROR", reason)
+        return
+      }
+      val modelTypeStr = result["modelType"] as? String ?: "gtcrn"
+      val paths = (result["paths"] as? Map<*, *>)
+        ?.mapValues { (_, v) -> (v as? String).orEmpty() }
+        ?.mapKeys { it.key.toString() }
+        ?: emptyMap()
+
+      val offlineModelConfig = when (modelTypeStr) {
+        "gtcrn" -> OfflineSpeechDenoiserModelConfig(
+          gtcrn = OfflineSpeechDenoiserGtcrnModelConfig(model = path(paths, "model")),
+          numThreads = numThreads?.toInt() ?: 1,
+          provider = provider ?: "cpu",
+          debug = debug ?: false
+        )
+        "dpdfnet" -> OfflineSpeechDenoiserModelConfig(
+          dpdfnet = OfflineSpeechDenoiserDpdfNetModelConfig(model = path(paths, "model")),
+          numThreads = numThreads?.toInt() ?: 1,
+          provider = provider ?: "cpu",
+          debug = debug ?: false
+        )
+        else -> {
+          promise.reject("ONLINE_ENHANCEMENT_INIT_ERROR", "Unsupported enhancement model type: $modelTypeStr")
+          return
+        }
+      }
+
+      val inst = onlineInstances.getOrPut(instanceId) { OnlineEnhancementInstance() }
+      inst.release()
+      val denoiser = OnlineSpeechDenoiser(
+        config = OnlineSpeechDenoiserConfig(model = offlineModelConfig)
+      )
+      inst.denoiser = denoiser
+
+      val out = Arguments.createMap()
+      out.putBoolean("success", true)
+      out.putInt("sampleRate", denoiser.sampleRate)
+      out.putInt("frameShiftInSamples", denoiser.frameShiftInSamples)
+      promise.resolve(out)
+    } catch (e: Exception) {
+      promise.reject("ONLINE_ENHANCEMENT_INIT_ERROR", "Failed to initialize online enhancement: ${e.message}", e)
+    }
+  }
+
+  fun feedSamples(
+    instanceId: String,
+    samples: ReadableArray,
+    sampleRate: Double,
+    promise: Promise
+  ) {
+    val inst = onlineInstances[instanceId]
+    val denoiser = inst?.denoiser
+    if (denoiser == null) {
+      promise.reject("ONLINE_ENHANCEMENT_ERROR", "Online enhancement instance not found: $instanceId")
+      return
+    }
+    try {
+      val audio = denoiser.run(readableArrayToFloatArray(samples), sampleRate.toInt())
+      promise.resolve(toEnhancedAudioMap(audio))
+    } catch (e: Exception) {
+      promise.reject("ONLINE_ENHANCEMENT_ERROR", "Failed to feed enhancement samples: ${e.message}", e)
+    }
+  }
+
+  fun flushOnline(instanceId: String, promise: Promise) {
+    val inst = onlineInstances[instanceId]
+    val denoiser = inst?.denoiser
+    if (denoiser == null) {
+      promise.reject("ONLINE_ENHANCEMENT_ERROR", "Online enhancement instance not found: $instanceId")
+      return
+    }
+    try {
+      promise.resolve(toEnhancedAudioMap(denoiser.flush()))
+    } catch (e: Exception) {
+      promise.reject("ONLINE_ENHANCEMENT_ERROR", "Failed to flush online enhancement: ${e.message}", e)
+    }
+  }
+
+  fun resetOnline(instanceId: String, promise: Promise) {
+    val inst = onlineInstances[instanceId]
+    val denoiser = inst?.denoiser
+    if (denoiser == null) {
+      promise.reject("ONLINE_ENHANCEMENT_ERROR", "Online enhancement instance not found: $instanceId")
+      return
+    }
+    try {
+      denoiser.reset()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("ONLINE_ENHANCEMENT_ERROR", "Failed to reset online enhancement: ${e.message}", e)
+    }
+  }
+
+  fun unloadOnline(instanceId: String, promise: Promise) {
+    onlineInstances.remove(instanceId)?.release()
+    promise.resolve(null)
+  }
+}