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

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

@@ -260,6 +260,50 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    fun advancedAntiSpoofingRGBA(buffer: ByteBuffer, width: Int, height: Int, rowStride: Int, pixelStride: Int): AntiSpoofingResult {
+        if (!isInitialized) {
+            return AntiSpoofingResult(
+                neuralNetworkScore = 0f,
+                laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = 0f,
+                confidence = 0f
+            )
+        }
+
+        return try {
+            val sampled = sampleRgbaBufferToModelAndGray(buffer, width, height, rowStride, pixelStride)
+            val nnResult = neuralNetworkAntiSpoofingSampled(sampled.rgbBuffer)
+            val nnScore = nnResult.getOrNull() ?: throw IllegalStateException(nnResult.exceptionOrNull()?.message ?: "NN inference failed")
+            val laplacianScore = calculateLaplacianFromGray(sampled.grayBuffer)
+            val combinedScore = calculateCombinedScore(nnScore, laplacianScore)
+            val confidence = calculateConfidence(nnScore, laplacianScore)
+
+            AntiSpoofingResult(
+                neuralNetworkScore = nnScore,
+                laplacianScore = laplacianScore,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = combinedScore,
+                confidence = confidence
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in advancedAntiSpoofingRGBA buffer path", e)
+            AntiSpoofingResult(
+                neuralNetworkScore = 0f,
+                laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = 0f,
+                confidence = 0f
+            )
+        }
+    }
+
     // FROM WORKING VERSION: neuralNetworkAntiSpoofing with Bitmap
     private fun neuralNetworkAntiSpoofing(bitmap: Bitmap): Result<Float> {
         return try {
@@ -292,29 +336,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
-    private fun neuralNetworkAntiSpoofingRGBA(rgba: ByteArray, width: Int, height: Int): Result<Float> {
-        return try {
-            val img = normalizeRgbaImage(rgba, width, height, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
-            val input = arrayOf(img)
-
-            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 neuralNetworkAntiSpoofingRGBA", e)
-            Result.failure(e)
-        }
-    }
-
     private fun neuralNetworkAntiSpoofingSampled(rgbBuffer: Array<Array<FloatArray>>): Result<Float> {
         return try {
             val input = arrayOf(rgbBuffer)
@@ -363,14 +384,20 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return floatValues
     }
 
-    private fun normalizeRgbaImage(
+    private data class SampledFrame(
+        val rgbBuffer: Array<Array<FloatArray>>,
+        val grayBuffer: Array<IntArray>
+    )
+
+    // Single-pass resize: one source pixel sample writes both the model RGB tensor
+    // and the grayscale buffer used for Laplacian scoring.
+    private fun sampleRgbaToModelAndGray(
         rgba: ByteArray,
         srcWidth: Int,
-        srcHeight: Int,
-        targetWidth: Int,
-        targetHeight: Int
-    ): Array<Array<FloatArray>> {
-        val floatValues = Array(targetHeight) { Array(targetWidth) { FloatArray(3) } }
+        srcHeight: Int
+    ): SampledFrame {
+        val targetWidth = INPUT_IMAGE_SIZE
+        val targetHeight = INPUT_IMAGE_SIZE
         val scaleX = srcWidth.toFloat() / targetWidth
         val scaleY = srcHeight.toFloat() / targetHeight
 
@@ -383,45 +410,53 @@ 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
-                floatValues[targetY][targetX] = floatArrayOf(r, g, b)
+
+                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 floatValues
+        return SampledFrame(modelInputBuffer, grayBuffer)
     }
 
-    private data class SampledFrame(
-        val rgbBuffer: Array<Array<FloatArray>>,
-        val grayBuffer: Array<IntArray>
-    )
-
-    private fun sampleRgbaToModelAndGray(
-        rgba: ByteArray,
+    private fun sampleRgbaBufferToModelAndGray(
+        buffer: ByteBuffer,
         srcWidth: Int,
-        srcHeight: Int
+        srcHeight: Int,
+        rowStride: Int,
+        pixelStride: Int
     ): SampledFrame {
         val targetWidth = INPUT_IMAGE_SIZE
         val targetHeight = INPUT_IMAGE_SIZE
         val scaleX = srcWidth.toFloat() / targetWidth
         val scaleY = srcHeight.toFloat() / targetHeight
+        val duplicated = buffer.duplicate()
+        duplicated.order(ByteOrder.nativeOrder())
 
         for (targetY in 0 until targetHeight) {
             val srcY = (targetY * scaleY).toInt().coerceIn(0, srcHeight - 1)
+            val rowOffset = srcY * rowStride
             for (targetX in 0 until targetWidth) {
                 val srcX = (targetX * scaleX).toInt().coerceIn(0, srcWidth - 1)
-                val srcIndex = (srcY * srcWidth + srcX) * 4
+                val pixelIndex = rowOffset + srcX * pixelStride
 
-                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
+                val r = duplicated.get(pixelIndex).toInt() and 0xFF
+                val g = duplicated.get(pixelIndex + 1).toInt() and 0xFF
+                val b = duplicated.get(pixelIndex + 2).toInt() and 0xFF
 
-                modelInputBuffer[targetY][targetX][0] = r
-                modelInputBuffer[targetY][targetX][1] = g
-                modelInputBuffer[targetY][targetX][2] = b
+                modelInputBuffer[targetY][targetX][0] = r / 255f
+                modelInputBuffer[targetY][targetX][1] = g / 255f
+                modelInputBuffer[targetY][targetX][2] = b / 255f
                 grayBuffer[targetY][targetX] = (
-                    0.299f * rgba[srcIndex].toInt() +
-                    0.587f * rgba[srcIndex + 1].toInt() +
-                    0.114f * rgba[srcIndex + 2].toInt()
+                    0.299f * r +
+                    0.587f * g +
+                    0.114f * b
                 ).toInt()
             }
         }
@@ -446,17 +481,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
-    private fun laplacianFromRgba(rgba: ByteArray, width: Int, height: Int): Result<Int> {
-        return try {
-            val gray = rgbaToGrayscale(rgba, width, height, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
-            val score = calculateLaplacianFromGray(gray)
-            Result.success(score)
-        } catch (e: Exception) {
-            Log.e(TAG, "Error in laplacianFromRgba", e)
-            Result.failure(e)
-        }
-    }
-
     // FROM WORKING VERSION: calculateLaplacianScore
     private fun calculateLaplacianScore(bitmap: Bitmap): Int {
         val laplace = arrayOf(
@@ -508,32 +532,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return greyImg
     }
 
-    private fun rgbaToGrayscale(
-        rgba: ByteArray,
-        srcWidth: Int,
-        srcHeight: Int,
-        targetWidth: Int,
-        targetHeight: Int
-    ): Array<IntArray> {
-        val gray = 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
-                val g = rgba[srcIndex + 1].toInt() and 0xFF
-                val b = rgba[srcIndex + 2].toInt() and 0xFF
-                gray[targetY][targetX] = (0.299 * r + 0.587 * g + 0.114 * b).toInt()
-            }
-        }
-
-        return gray
-    }
-
     private fun calculateLaplacianFromGray(img: Array<IntArray>): Int {
         val laplace = arrayOf(
             intArrayOf(0, 1, 0),

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

@@ -83,12 +83,21 @@ class HybridSpoofDetectorOutput(
       return
     }
     try {
-      val rgba = extractRgbaBytes(image)
-      if (!shouldProcessFrame(rgba, image.width, image.height)) {
+      val plane = image.planes.firstOrNull() ?: throw IllegalStateException("RGBA image has no planes")
+      val rgba = plane.buffer.duplicate()
+      rgba.order(java.nio.ByteOrder.nativeOrder())
+
+      if (!shouldProcessFrameFromPlane(rgba, image.width, image.height, plane.rowStride, plane.pixelStride)) {
         return
       }
 
-      val result = detector.advancedAntiSpoofingRGBA(rgba, image.width, image.height)
+      val result = detector.advancedAntiSpoofingRGBA(
+        rgba,
+        image.width,
+        image.height,
+        plane.rowStride,
+        plane.pixelStride,
+      )
       val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
         result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
       options.onResult.invoke(
@@ -109,7 +118,13 @@ class HybridSpoofDetectorOutput(
     }
   }
 
-  private fun shouldProcessFrame(rgba: ByteArray, width: Int, height: Int): Boolean {
+  private fun shouldProcessFrameFromPlane(
+    buffer: java.nio.ByteBuffer,
+    width: Int,
+    height: Int,
+    rowStride: Int,
+    pixelStride: Int,
+  ): Boolean {
     val frameIndex = frameCounter.incrementAndGet()
     if (frameIndex % FRAME_EVALUATION_INTERVAL != 0) {
       return false
@@ -121,14 +136,14 @@ class HybridSpoofDetectorOutput(
     var sampleCount = 0
 
     for (y in 0 until height step sampleStep) {
-      val rowOffset = y * width * 4
+      val rowOffset = y * rowStride
       for (x in 0 until width step sampleStep) {
-        val index = rowOffset + x * 4
-        if (index + 2 >= rgba.size) continue
+        val index = rowOffset + x * pixelStride
+        if (index + 2 >= buffer.capacity()) 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 r = buffer.get(index).toInt() and 0xFF
+        val g = buffer.get(index + 1).toInt() and 0xFF
+        val b = buffer.get(index + 2).toInt() and 0xFF
         val luma = (0.299 * r + 0.587 * g + 0.114 * b).toInt()
 
         brightnessSum += luma.toLong()
@@ -143,7 +158,7 @@ class HybridSpoofDetectorOutput(
 
     val avgBrightness = brightnessSum.toFloat() / sampleCount
     val variance = (brightnessSquaredSum.toFloat() / sampleCount) - (avgBrightness * avgBrightness)
-    val brightnessDelta = kotlin.math.abs(avgBrightness - lastFrameBrightness)
+    val brightnessDelta = abs(avgBrightness - lastFrameBrightness)
     lastFrameBrightness = avgBrightness
 
     val brightnessOk = avgBrightness in MIN_FRAME_BRIGHTNESS..MAX_FRAME_BRIGHTNESS

package/package.json

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