react-native-vision-camera-spoof-detector 1.1.22 → 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 {
@@ -381,6 +425,45 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return SampledFrame(modelInputBuffer, grayBuffer)
     }
 
+    private fun sampleRgbaBufferToModelAndGray(
+        buffer: ByteBuffer,
+        srcWidth: 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 pixelIndex = rowOffset + srcX * pixelStride
+
+                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 / 255f
+                modelInputBuffer[targetY][targetX][1] = g / 255f
+                modelInputBuffer[targetY][targetX][2] = b / 255f
+                grayBuffer[targetY][targetX] = (
+                    0.299f * r +
+                    0.587f * g +
+                    0.114f * b
+                ).toInt()
+            }
+        }
+
+        return SampledFrame(modelInputBuffer, 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

@@ -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.22",
+  "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": {