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

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

@@ -198,8 +198,10 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
 
         return try {
-            val nnScore = neuralNetworkAntiSpoofingRGBA(rgba, width, height).getOrThrow()
-            val laplacianScore = laplacianFromRgba(rgba, width, height).getOrThrow()
+            val sampled = sampleRgbaToModelAndGray(rgba, width, height)
+            val nnResult = neuralNetworkAntiSpoofingSampled(sampled.rgbBuffer)
+            val nnScore = nnResult.getOrNull() ?: throw IllegalStateException(nnResult.exceptionOrNull()?.message ?: "NN inference failed")
+            val laplacianScore = calculateLaplacianFromGray(sampled.grayBuffer)
             val isLive = nnScore < BASE_THRESHOLD && laplacianScore > LAPLACIAN_THRESHOLD
             val combinedScore = calculateCombinedScore(nnScore, laplacianScore)
             val confidence = calculateConfidence(nnScore, laplacianScore)
@@ -282,6 +284,23 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    private fun neuralNetworkAntiSpoofingSampled(rgbBuffer: Array<Array<FloatArray>>): Result<Float> {
+        return try {
+            val input = arrayOf(rgbBuffer)
+            clssPred[0].fill(0f)
+            leafNodeMask[0].fill(0f)
+            outputs[outputIndex0] = clssPred
+            outputs[outputIndex1] = leafNodeMask
+            interpreter!!.runForMultipleInputsOutputs(arrayOf(input), outputs)
+            Log.i(TAG, "clss_pred: [${clssPred[0].joinToString()}]")
+            Log.i(TAG, "leaf_node_mask: [${leafNodeMask[0].joinToString()}]")
+            Result.success(leafScore1(clssPred, leafNodeMask))
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in neuralNetworkAntiSpoofingSampled", e)
+            Result.failure(e)
+        }
+    }
+
     // FROM WORKING VERSION: leafScore1
     private fun leafScore1(clssPred: Array<FloatArray>, leafNodeMask: Array<FloatArray>): Float {
         var score = 0f
@@ -340,6 +359,40 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return floatValues
     }
 
+    private data class SampledFrame(
+        val rgbBuffer: Array<Array<FloatArray>>,
+        val grayBuffer: Array<IntArray>
+    )
+
+    private fun sampleRgbaToModelAndGray(
+        rgba: ByteArray,
+        srcWidth: Int,
+        srcHeight: Int
+    ): 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
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * scaleY).toInt().coerceIn(0, srcHeight - 1)
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * scaleX).toInt().coerceIn(0, srcWidth - 1)
+                val srcIndex = (srcY * srcWidth + srcX) * 4
+
+                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()
+            }
+        }
+
+        return SampledFrame(rgbBuffer, grayBuffer)
+    }
+
     // FROM WORKING VERSION: laplacian with Bitmap
     private fun laplacian(bitmap: Bitmap): Result<Int> {
         return try {

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

@@ -100,42 +100,33 @@ class HybridSpoofDetectorOutput(
     val width = image.width
     val height = image.height
     val bytesPerPixel = 4
-    val rowBytes = width * bytesPerPixel
-    val rgba = ByteArray(rowBytes * height)
+    val outputSize = width * height * bytesPerPixel
+    val packed = ByteArray(outputSize)
     val buffer = plane.buffer.duplicate()
     buffer.order(java.nio.ByteOrder.nativeOrder())
 
-    for (y in 0 until height) {
-      val srcOffset = y * rowStride
-      val dstOffset = y * rowBytes
-      val copyLength = rowBytes.coerceAtMost(rowStride)
-      buffer.position(srcOffset)
-      val slice = ByteArray(copyLength)
-      buffer.get(slice)
-      System.arraycopy(slice, 0, rgba, dstOffset, copyLength)
+    if (pixelStride == bytesPerPixel && rowStride == width * bytesPerPixel) {
+      buffer.get(packed)
+      return packed
     }
 
-    if (pixelStride != 4) {
-      val packed = ByteArray(width * height * bytesPerPixel)
-      var outputIndex = 0
-      for (y in 0 until height) {
-        val rowOffset = y * rowStride
-        for (x in 0 until width) {
-          val pixelOffset = rowOffset + x * pixelStride
-          val r = buffer.get(pixelOffset).toInt() and 0xFF
-          val g = buffer.get(pixelOffset + 1).toInt() and 0xFF
-          val b = buffer.get(pixelOffset + 2).toInt() and 0xFF
-          val a = buffer.get(pixelOffset + 3).toInt() and 0xFF
-          packed[outputIndex++] = r.toByte()
-          packed[outputIndex++] = g.toByte()
-          packed[outputIndex++] = b.toByte()
-          packed[outputIndex++] = a.toByte()
-        }
+    var outputIndex = 0
+    for (y in 0 until height) {
+      val rowOffset = y * rowStride
+      for (x in 0 until width) {
+        val pixelOffset = rowOffset + x * pixelStride
+        val r = buffer.get(pixelOffset).toInt() and 0xFF
+        val g = buffer.get(pixelOffset + 1).toInt() and 0xFF
+        val b = buffer.get(pixelOffset + 2).toInt() and 0xFF
+        val a = buffer.get(pixelOffset + 3).toInt() and 0xFF
+        packed[outputIndex++] = r.toByte()
+        packed[outputIndex++] = g.toByte()
+        packed[outputIndex++] = b.toByte()
+        packed[outputIndex++] = a.toByte()
       }
-      return packed
     }
 
-    return rgba
+    return packed
   }
 
   override fun dispose() {

package/package.json

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