react-native-vision-camera-spoof-detector 1.1.18 → 1.1.20

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

@@ -45,6 +45,8 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     private val outputs = mutableMapOf<Int, Any>()
     private var outputIndex0: Int = 0
     private var outputIndex1: Int = 1
+    private val modelInputBuffer = Array(INPUT_IMAGE_SIZE) { Array(INPUT_IMAGE_SIZE) { FloatArray(3) } }
+    private val grayBuffer = Array(INPUT_IMAGE_SIZE) { IntArray(INPUT_IMAGE_SIZE) }
 
     init {
         initializeInterpreter()
@@ -53,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
@@ -371,8 +402,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     ): SampledFrame {
         val targetWidth = INPUT_IMAGE_SIZE
         val targetHeight = INPUT_IMAGE_SIZE
-        val rgbBuffer = Array(targetHeight) { Array(targetWidth) { FloatArray(3) } }
-        val grayBuffer = Array(targetHeight) { IntArray(targetWidth) }
         val scaleX = srcWidth.toFloat() / targetWidth
         val scaleY = srcHeight.toFloat() / targetHeight
 
@@ -385,12 +414,19 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 val r = (rgba[srcIndex].toInt() and 0xFF) / 255f
                 val g = (rgba[srcIndex + 1].toInt() and 0xFF) / 255f
                 val b = (rgba[srcIndex + 2].toInt() and 0xFF) / 255f
-                rgbBuffer[targetY][targetX] = floatArrayOf(r, g, b)
-                grayBuffer[targetY][targetX] = (0.299f * rgba[srcIndex].toInt() + 0.587f * rgba[srcIndex + 1].toInt() + 0.114f * rgba[srcIndex + 2].toInt()).toInt()
+
+                modelInputBuffer[targetY][targetX][0] = r
+                modelInputBuffer[targetY][targetX][1] = g
+                modelInputBuffer[targetY][targetX][2] = b
+                grayBuffer[targetY][targetX] = (
+                    0.299f * rgba[srcIndex].toInt() +
+                    0.587f * rgba[srcIndex + 1].toInt() +
+                    0.114f * rgba[srcIndex + 2].toInt()
+                ).toInt()
             }
         }
 
-        return SampledFrame(rgbBuffer, grayBuffer)
+        return SampledFrame(modelInputBuffer, grayBuffer)
     }
 
     // FROM WORKING VERSION: laplacian with Bitmap

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.1.18",
+  "version": "1.1.20",
   "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": {