react-native-vision-camera-spoof-detector 1.1.19 → 1.1.21

package/android/src/main/java/com/faceantispoof/FaceAntiSpoofingAdvanced.kt

@@ -55,31 +55,60 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     private fun initializeInterpreter() {
         try {
             val modelBuffer = loadModelFile(assetManager, MODEL_FILE)
-            val options = Interpreter.Options()
-            
-            // Use optimal settings
-            val optimalThreads = 4 // Fixed as in working version
-            options.setNumThreads(optimalThreads)
-            
-            currentAccelerator = ACCELERATOR_CPU
-            Log.i(TAG, "CPU-ONLY MODE - Using $optimalThreads threads")
-            
-            interpreter = Interpreter(modelBuffer, options)
-            
+            val optimalThreads = 4
+            val compatibilityList = CompatibilityList()
+            var selectedAccelerator = ACCELERATOR_CPU
+
+            try {
+                if (compatibilityList.isDelegateSupportedOnThisDevice) {
+                    val delegate = GpuDelegate(compatibilityList.bestOptionsForThisDevice)
+                    gpuDelegate = delegate
+                    val options = Interpreter.Options().apply {
+                        setNumThreads(optimalThreads)
+                        addDelegate(delegate)
+                    }
+                    interpreter = Interpreter(modelBuffer, options)
+                    selectedAccelerator = ACCELERATOR_GPU
+                    Log.i(TAG, "Face Anti-Spoof initialized | GPU delegate enabled | Threads: $optimalThreads")
+                } else {
+                    throw IllegalStateException("GPU delegate not supported")
+                }
+            } catch (e: Exception) {
+                Log.w(TAG, "GPU delegate unavailable or failed: ${e.message}", e)
+                try {
+                    val nnapiOptions = org.tensorflow.lite.nnapi.NnApiDelegate()
+                    val options = Interpreter.Options().apply {
+                        setNumThreads(optimalThreads)
+                        addDelegate(nnapiOptions)
+                    }
+                    interpreter = Interpreter(modelBuffer, options)
+                    selectedAccelerator = ACCELERATOR_NNAPI
+                    Log.i(TAG, "Face Anti-Spoof initialized | NNAPI delegate enabled | Threads: $optimalThreads")
+                } catch (nnapiError: Exception) {
+                    Log.w(TAG, "NNAPI delegate unavailable or failed: ${nnapiError.message}", nnapiError)
+                    val options = Interpreter.Options().apply {
+                        setNumThreads(optimalThreads)
+                    }
+                    interpreter = Interpreter(modelBuffer, options)
+                    selectedAccelerator = ACCELERATOR_CPU
+                    Log.i(TAG, "Face Anti-Spoof initialized | CPU fallback enabled | Threads: $optimalThreads")
+                }
+            }
+
+            currentAccelerator = selectedAccelerator
+
             try {
                 outputIndex0 = interpreter!!.getOutputIndex("Identity")
                 outputIndex1 = interpreter!!.getOutputIndex("Identity_1")
             } catch (e: Exception) {
                 Log.w(TAG, "Could not resolve named output indices, using defaults: ${e.message}")
-                // Fallback to default indices
                 outputIndex0 = 0
                 outputIndex1 = 1
             }
-            
+
             outputs[outputIndex0] = clssPred
             outputs[outputIndex1] = leafNodeMask
             isInitialized = true
-            Log.i(TAG, "Face Anti-Spoof initialized | CPU-ONLY MODE | Threads: $optimalThreads")
         } catch (e: Exception) {
             Log.e(TAG, "FAILED to load TFLite model: ${e.message}", e)
             isInitialized = false

package/android/src/main/java/com/margelo/nitro/camera/spoofdetector/HybridSpoofDetectorOutput.kt

@@ -13,6 +13,9 @@ import com.margelo.nitro.camera.extensions.setAllowDroppingLateFrames
 import com.margelo.nitro.camera.extensions.surfaceRotation
 import com.margelo.nitro.camera.public.NativeCameraOutput
 import com.faceantispoof.FaceAntiSpoofingAdvanced
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
 import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicBoolean
 
@@ -32,10 +35,19 @@ class HybridSpoofDetectorOutput(
   private val executor = Executors.newSingleThreadExecutor()
   private val busy = AtomicBoolean(false)
   private val disposed = AtomicBoolean(false)
+  private val frameCounter = java.util.concurrent.atomic.AtomicInteger(0)
+  private var lastFrameBrightness = 0f
   private val detector = FaceAntiSpoofingAdvanced(
     NitroModules.applicationContext?.assets ?: error("FaceAntiSpoof: no application context")
   )
   private var imageAnalysis: ImageAnalysis? = null
+  private companion object {
+    private const val FRAME_EVALUATION_INTERVAL = 3
+    private const val MIN_FRAME_BRIGHTNESS = 24f
+    private const val MAX_FRAME_BRIGHTNESS = 220f
+    private const val MIN_VARIANCE_FOR_ANALYSIS = 1500f
+    private const val MIN_BRIGHTNESS_DELTA = 8f
+  }
 
   override fun createUseCase(
     mirrorMode: MirrorMode,
@@ -72,6 +84,10 @@ class HybridSpoofDetectorOutput(
     }
     try {
       val rgba = extractRgbaBytes(image)
+      if (!shouldProcessFrame(rgba, image.width, image.height)) {
+        return
+      }
+
       val result = detector.advancedAntiSpoofingRGBA(rgba, image.width, image.height)
       val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
         result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
@@ -93,6 +109,50 @@ class HybridSpoofDetectorOutput(
     }
   }
 
+  private fun shouldProcessFrame(rgba: ByteArray, width: Int, height: Int): Boolean {
+    val frameIndex = frameCounter.incrementAndGet()
+    if (frameIndex % FRAME_EVALUATION_INTERVAL != 0) {
+      return false
+    }
+
+    val sampleStep = max(1, min(width, height) / 32)
+    var brightnessSum = 0L
+    var brightnessSquaredSum = 0L
+    var sampleCount = 0
+
+    for (y in 0 until height step sampleStep) {
+      val rowOffset = y * width * 4
+      for (x in 0 until width step sampleStep) {
+        val index = rowOffset + x * 4
+        if (index + 2 >= rgba.size) continue
+
+        val r = rgba[index].toInt() and 0xFF
+        val g = rgba[index + 1].toInt() and 0xFF
+        val b = rgba[index + 2].toInt() and 0xFF
+        val luma = (0.299 * r + 0.587 * g + 0.114 * b).toInt()
+
+        brightnessSum += luma.toLong()
+        brightnessSquaredSum += (luma.toLong() * luma.toLong())
+        sampleCount += 1
+      }
+    }
+
+    if (sampleCount == 0) {
+      return false
+    }
+
+    val avgBrightness = brightnessSum.toFloat() / sampleCount
+    val variance = (brightnessSquaredSum.toFloat() / sampleCount) - (avgBrightness * avgBrightness)
+    val brightnessDelta = kotlin.math.abs(avgBrightness - lastFrameBrightness)
+    lastFrameBrightness = avgBrightness
+
+    val brightnessOk = avgBrightness in MIN_FRAME_BRIGHTNESS..MAX_FRAME_BRIGHTNESS
+    val textureOk = variance >= MIN_VARIANCE_FOR_ANALYSIS
+    val motionLikely = brightnessDelta >= MIN_BRIGHTNESS_DELTA || lastFrameBrightness == 0f
+
+    return brightnessOk && textureOk && motionLikely
+  }
+
   private fun extractRgbaBytes(image: ImageProxy): ByteArray {
     val plane = image.planes.firstOrNull() ?: throw IllegalStateException("RGBA image has no planes")
     val rowStride = plane.rowStride

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "description": "High-performance face anti-spoofing and liveness detection module for React Native Vision Camera. Uses TensorFlow Lite with GPU acceleration and optimized YUV processing.",
   "homepage": "https://github.com/dpraful/react-native-vision-camera-spoof-detector",
   "repository": {