react-native-vision-camera-spoof-detector 1.0.12 → 1.0.17

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

@@ -1,6 +1,7 @@
 package com.faceantispoof
 
 import android.content.res.AssetManager
+import android.graphics.Bitmap
 import org.tensorflow.lite.Interpreter
 import org.tensorflow.lite.gpu.CompatibilityList
 import org.tensorflow.lite.gpu.GpuDelegate
@@ -14,14 +15,16 @@ import java.nio.ByteOrder
 import java.util.*
 import android.util.Log
 import kotlin.collections.ArrayList
+import kotlinx.coroutines.runBlocking
+
 class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     companion object {
         const val INPUT_IMAGE_SIZE = 256
-        const val BASE_THRESHOLD = 0.35f  // Reduced from 0.2f to be more lenient with real faces 
+        const val BASE_THRESHOLD = 0.2f
         const val ROUTE_INDEX = 6
         const val LAPLACE_THRESHOLD = 50
-        const val LAPLACIAN_THRESHOLD = 1000
+        const val LAPLACIAN_THRESHOLD = 4000  // Increased from 1000 - real faces have ~3500+ laplacian score
         const val MODEL_FILE = "FaceAntiSpoofing.tflite"
         private const val TAG = "FaceAntiSpoofing"
         
@@ -29,17 +32,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         const val ACCELERATOR_CPU = "CPU"
         const val ACCELERATOR_GPU = "GPU"
         const val ACCELERATOR_NNAPI = "NNAPI"
-        
-        // Advanced spoof detection constants
-        private const val HISTORY_SIZE = 10
-        private const val TEMPORAL_CONSISTENCY_THRESHOLD = 0.12f  // More lenient for slightly moving faces
-        private const val SCORE_VARIANCE_THRESHOLD = 0.04f  // Allow more score variance for real faces
-        private const val MIN_FRAMES_FOR_ANALYSIS = 5
-        private const val DYNAMIC_THRESHOLD_MULTIPLIER = 1.3f
-        private const val TEXTURE_COMPLEXITY_THRESHOLD = 800
-        private const val COLOR_SATURATION_THRESHOLD = 0.4f
-        private const val DEPTH_VARIATION_THRESHOLD = 0.1f
-        
     }
 
     private var interpreter: Interpreter? = null
@@ -47,23 +39,12 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     private var gpuDelegate: GpuDelegate? = null
     private var currentAccelerator: String = ACCELERATOR_CPU
     
-    // Reusable buffers to avoid per-frame allocations
-    private val inputImageSize = INPUT_IMAGE_SIZE
-    private val inputBuffer: ByteBuffer = ByteBuffer.allocateDirect(4 * inputImageSize * inputImageSize * 3).order(ByteOrder.nativeOrder())
+    // Reuse output arrays to avoid allocations
     private val clssPred = Array(1) { FloatArray(8) }
     private val leafNodeMask = Array(1) { FloatArray(8) }
-    private val outputs = HashMap<Int, Any>()
+    private val outputs = mutableMapOf<Int, Any>()
     private var outputIndex0: Int = 0
     private var outputIndex1: Int = 1
-    private var rgbFloatBuffer: FloatArray? = null
-    private var grayscaleBuffer: IntArray? = null
-    private val yuvConverter = YuvToFloatArrayConverter()
-
-    // Advanced spoof detection fields
-    private val scoreHistory = LinkedList<Float>()
-    private val laplacianHistory = LinkedList<Int>()
-    private var frameCount = 0
-    private var adaptiveThreshold = BASE_THRESHOLD
 
     init {
         initializeInterpreter()
@@ -74,14 +55,12 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             val modelBuffer = loadModelFile(assetManager, MODEL_FILE)
             val options = Interpreter.Options()
             
-            // FORCE CPU-ONLY MODE FOR LOW-END DEVICE COMPATIBILITY
-            // This bypasses all GPU/NNAPI issues and uses stable CPU inference
-            val optimalThreads = getOptimalThreadCount()
+            // Use optimal settings
+            val optimalThreads = 4 // Fixed as in working version
             options.setNumThreads(optimalThreads)
             
             currentAccelerator = ACCELERATOR_CPU
-            Log.i(TAG, "FORCED CPU-ONLY MODE - Bypassing GPU/NNAPI")
-            Log.i(TAG, "Using $optimalThreads threads for CPU inference")
+            Log.i(TAG, "CPU-ONLY MODE - Using $optimalThreads threads")
             
             interpreter = Interpreter(modelBuffer, options)
             
@@ -90,9 +69,11 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 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.clear()
             outputs[outputIndex0] = clssPred
             outputs[outputIndex1] = leafNodeMask
             isInitialized = true
@@ -104,45 +85,39 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
-    private fun tryAddGpuDelegate(options: Interpreter.Options): Boolean {
+    fun getAccelerator(): String = currentAccelerator
+
+    // NEW: Add this method to accept Bitmap as input (matching working version)
+    suspend fun advancedAntiSpoofing(bitmap: Bitmap): Result<AntiSpoofingResult> {
         return try {
-            // Additional check: verify device has minimum Android version for GPU delegate
-            if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
-                Log.w(TAG, "GPU delegate requires Android 5.0+, device running: ${android.os.Build.VERSION.SDK_INT}")
-                return false
-            }
-            
-            val compatibilityList = CompatibilityList()
-            if (compatibilityList.isDelegateSupportedOnThisDevice) {
-                try {
-                    gpuDelegate = GpuDelegate(compatibilityList.bestOptionsForThisDevice)
-                    options.addDelegate(gpuDelegate)
-                    Log.d(TAG, "GPU delegate added successfully")
-                    true
-                } catch (e: Exception) {
-                    Log.w(TAG, "Failed to initialize GPU delegate after compatibility check: ${e.message}")
-                    gpuDelegate?.close()
-                    gpuDelegate = null
-                    false
-                }
+            if (!isInitialized) {
+                Result.failure(IllegalStateException("Classifier not initialized"))
             } else {
-                Log.d(TAG, "GPU delegate not supported on this device")
-                false
+                val nnScore = neuralNetworkAntiSpoofing(bitmap).getOrThrow()
+                val laplacianScore = laplacian(bitmap).getOrThrow()
+                val isLive = nnScore < BASE_THRESHOLD && laplacianScore > LAPLACIAN_THRESHOLD
+                val combinedScore = calculateCombinedScore(nnScore, laplacianScore)
+                val confidence = calculateConfidence(nnScore, laplacianScore)
+
+                Result.success(
+                    AntiSpoofingResult(
+                        neuralNetworkScore = nnScore,
+                        laplacianScore = laplacianScore,
+                        textureComplexity = 0, // Not calculated in working version
+                        temporalConsistency = 0f, // Not calculated in working version
+                        colorSaturation = 0f, // Not calculated in working version
+                        combinedScore = combinedScore,
+                        confidence = confidence
+                    )
+                )
             }
         } catch (e: Exception) {
-            Log.w(TAG, "Failed to add GPU delegate: ${e.message}")
-            try {
-                gpuDelegate?.close()
-            } catch (e2: Exception) {
-                Log.w(TAG, "Error closing GPU delegate: ${e2.message}")
-            }
-            gpuDelegate = null
-            false
+            Log.e(TAG, "Error in advancedAntiSpoofing", e)
+            Result.failure(e)
         }
     }
 
-    fun getAccelerator(): String = currentAccelerator
-
+    // NEW: Legacy method for NV21 compatibility
     fun advancedAntiSpoofing(nv21: ByteArray, width: Int, height: Int): AntiSpoofingResult {
         if (!isInitialized) {
             return AntiSpoofingResult(
@@ -152,393 +127,242 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 temporalConsistency = 0f,
                 colorSaturation = 0f,
                 combinedScore = 0f,
-                isLive = false,
-                confidence = 0f,
-                label = "Not Initialized",
-                spoofType = "UNKNOWN"
+                confidence = 0f
             )
         }
 
-        // Enhanced input validation
-        if (nv21.isEmpty() || width <= 0 || height <= 0) {
-            Log.w(TAG, "Invalid input: nv21 empty=${nv21.isEmpty()}, width=$width, height=$height")
-            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Invalid input parameters", "INVALID_INPUT")
-        }
-
-        val expectedSize = width * height + (width * height) / 2
-        if (nv21.size < expectedSize) {
-            Log.w(TAG, "Buffer size mismatch: expected $expectedSize, got ${nv21.size}")
-            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Buffer size mismatch", "INVALID_INPUT")
-        }
-
         return try {
-            // Multiple detection techniques
-            val nnScore = neuralNetworkAntiSpoofing(nv21, width, height)
-            val laplacianScore = laplacian(nv21, width, height)
-            val textureScore = calculateTextureComplexity(nv21, width, height)
-            val colorSat = calculateColorSaturation(nv21, width, height)
-            val temporalConsistency = calculateTemporalConsistency(nnScore)
-            
-            // Multi-factor spoof detection
-            val spoofDetection = detectSpoofType(
-                nnScore, 
-                laplacianScore, 
-                textureScore, 
-                colorSat, 
-                temporalConsistency
-            )
-            
-            val confidence = calculateConfidence(nnScore, laplacianScore, textureScore, temporalConsistency)
-            val combinedScore = calculateCombinedScore(nnScore, laplacianScore, textureScore, temporalConsistency)
+            // Convert NV21 to Bitmap
+            val bitmap = nv21ToBitmap(nv21, width, height)
+            val result = runBlocking { advancedAntiSpoofing(bitmap) }
             
-            // Final decision with multiple safeguards
-            val isLive = isLiveFace(
-                nnScore, 
-                laplacianScore, 
-                textureScore, 
-                colorSat, 
-                temporalConsistency, 
-                spoofDetection
-            )
-
-            AntiSpoofingResult(
-                neuralNetworkScore = nnScore,
-                laplacianScore = laplacianScore,
-                textureComplexity = textureScore,
-                temporalConsistency = temporalConsistency,
-                colorSaturation = colorSat,
-                combinedScore = combinedScore,
-                isLive = isLive,
-                confidence = confidence,
-                label = if (isLive) "Live Face" else "Spoof Face: ${spoofDetection.type}",
-                spoofType = spoofDetection.type
-            )
+            val spoofResult = result.getOrNull()
+            if (spoofResult != null) {
+                spoofResult
+            } else {
+                Log.e(TAG, "Anti-spoofing analysis failed", result.exceptionOrNull())
+                AntiSpoofingResult(
+                    neuralNetworkScore = 0f,
+                    laplacianScore = 0,
+                    textureComplexity = 0,
+                    temporalConsistency = 0f,
+                    colorSaturation = 0f,
+                    combinedScore = 0f,
+                    confidence = 0f
+                )
+            }
         } catch (e: Exception) {
             Log.e(TAG, "Error in advancedAntiSpoofing", e)
-            AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: ${e.message}", "PROCESSING_ERROR")
+            AntiSpoofingResult(
+                neuralNetworkScore = 0f,
+                laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = 0f,
+                confidence = 0f
+            )
         }
     }
 
-    private fun neuralNetworkAntiSpoofing(nv21: ByteArray, width: Int, height: Int): Float {
+    // FROM WORKING VERSION: neuralNetworkAntiSpoofing with Bitmap
+    private fun neuralNetworkAntiSpoofing(bitmap: Bitmap): Result<Float> {
         return try {
-            val expectedSize = width * height + (width * height) / 2
-            if (nv21.size < expectedSize) {
-                throw IllegalArgumentException("NV21 buffer size mismatch: expected $expectedSize, got ${nv21.size}")
-            }
-
-            if (!isInitialized || interpreter == null) {
-                throw Exception("Interpreter not initialized")
-            }
+            val bitmapScale = Bitmap.createScaledBitmap(bitmap, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE, true)
+            val img = normalizeImage(bitmapScale)
+            val input = arrayOf(img)
 
-            if (rgbFloatBuffer == null || rgbFloatBuffer!!.size < INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE * 3) {
-                rgbFloatBuffer = FloatArray(INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE * 3)
-            }
+            // Clear and prepare outputs
+            clssPred[0].fill(0f)
+            leafNodeMask[0].fill(0f)
             
-            val rgbFloats = try {
-                yuvConverter.nv21ToRgbFloatArray(
-                    nv21, width, height,
-                    INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE,
-                    rgbFloatBuffer
-                )
-            } catch (e: Exception) {
-                Log.e(TAG, "Error in YUV conversion: ${e.message}", e)
-                throw e
-            }
+            outputs[outputIndex0] = clssPred
+            outputs[outputIndex1] = leafNodeMask
 
-            if (rgbFloats == null || rgbFloats.isEmpty()) {
-                throw Exception("RGB conversion returned empty array")
-            }
+            interpreter!!.runForMultipleInputsOutputs(arrayOf(input), outputs)
 
-            try {
-                inputBuffer.rewind()
-                for (i in 0 until (INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE * 3)) {
-                    inputBuffer.putFloat(rgbFloats[i])
-                }
-                inputBuffer.rewind()
-            } catch (e: Exception) {
-                Log.e(TAG, "Error writing to input buffer: ${e.message}", e)
-                throw e
-            }
+            Log.i(TAG, "clss_pred: [${clssPred[0].joinToString()}]")
+            Log.i(TAG, "leaf_node_mask: [${leafNodeMask[0].joinToString()}]")
 
-            outputs[outputIndex0] = clssPred
-            outputs[outputIndex1] = leafNodeMask
+            val score = leafScore1(clssPred, leafNodeMask)
 
-            try {
-                interpreter!!.runForMultipleInputsOutputs(arrayOf<Any>(inputBuffer), outputs)
-            } catch (e: Exception) {
-                Log.e(TAG, "Error running interpreter: ${e.message}", e)
-                throw e
+            if (bitmapScale != bitmap) {
+                bitmapScale.recycle()
             }
 
-            val rawScore = leafScore1(clssPred, leafNodeMask)
-            
-            // Apply non-linear scaling to make high scores more sensitive
-            applyNonLinearScaling(rawScore)
+            Result.success(score)
         } catch (e: Exception) {
-            Log.e(TAG, "Error in neuralNetworkAntiSpoofing: ${e.message}", e)
-            throw e
+            Log.e(TAG, "Error in neuralNetworkAntiSpoofing", e)
+            Result.failure(e)
         }
     }
 
-    private fun applyNonLinearScaling(score: Float): Float {
-        // Exponential scaling to make scores > 0.1 much more sensitive
-        return if (score > 0.1f) {
-            score * (1 + (score - 0.1f) * 2.0f) // Amplify higher scores
-        } else {
-            score
+    // FROM WORKING VERSION: leafScore1
+    private fun leafScore1(clssPred: Array<FloatArray>, leafNodeMask: Array<FloatArray>): Float {
+        var score = 0f
+        for (i in 0 until 8) {
+            score += abs(clssPred[0][i]) * leafNodeMask[0][i]
         }
+        return score
     }
 
-    /**
-     * Generate image as Base64 string for face recognition API.
-     * 
-     * QUALITY ENHANCEMENTS:
-     * - Uses bilinear interpolation for smooth resizing (no blur artifacts)
-     * - Applies unsharp masking for edge enhancement
-     * - Uses quality 92 JPEG encoding (up from 85) for better face detection
-     * - Validates frame stability before generation
-     *
-     * Supports JPEG, PNG, and BMP formats with configurable resolution.
-     * Compatible with OpenCV cv2.imdecode() for face recognition systems.
-     *
-     * @param nv21 NV21 encoded YUV frame
-     * @param width Original frame width
-     * @param height Original frame height
-     * @return Base64 encoded image string, or null if generation fails
-     */
-    private fun leafScore1(clssPred: Array<FloatArray>, leafNodeMask: Array<FloatArray>): Float {
-        if (clssPred.isEmpty() || clssPred[0].isEmpty()) {
-            Log.e(TAG, "clssPred array is empty or null")
-            return 0f
-        }
-        if (leafNodeMask.isEmpty() || leafNodeMask[0].isEmpty()) {
-            Log.e(TAG, "leafNodeMask array is empty or null")
-            return 0f
-        }
-        
-        var score = 0f
-        val minSize = minOf(clssPred[0].size, leafNodeMask[0].size, 8)
-        for (i in 0 until minSize) {
-            try {
-                score += abs(clssPred[0][i]) * leafNodeMask[0][i]
-            } catch (e: Exception) {
-                Log.e(TAG, "Error computing leaf score at index $i: ${e.message}", e)
+    // FROM WORKING VERSION: normalizeImage
+    private fun normalizeImage(bitmap: Bitmap): Array<Array<FloatArray>> {
+        val h = bitmap.height
+        val w = bitmap.width
+        val floatValues = Array(h) { Array(w) { FloatArray(3) } }
+
+        val imageStd = 255f
+        val pixels = IntArray(h * w)
+        bitmap.getPixels(pixels, 0, w, 0, 0, w, h)
+
+        for (i in 0 until h) {
+            for (j in 0 until w) {
+                val pixel = pixels[i * w + j]
+                val r = ((pixel shr 16) and 0xFF) / imageStd
+                val g = ((pixel shr 8) and 0xFF) / imageStd
+                val b = (pixel and 0xFF) / imageStd
+                floatValues[i][j] = floatArrayOf(r, g, b)
             }
         }
-        return score
+        return floatValues
     }
 
-    private fun laplacian(nv21: ByteArray, width: Int, height: Int): Int {
+    // FROM WORKING VERSION: laplacian with Bitmap
+    private fun laplacian(bitmap: Bitmap): Result<Int> {
         return try {
-            calculateLaplacianScore(nv21, width, height)
+            val bitmapScale = Bitmap.createScaledBitmap(bitmap, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE, true)
+            val score = calculateLaplacianScore(bitmapScale)
+
+            if (bitmapScale != bitmap) {
+                bitmapScale.recycle()
+            }
+
+            Result.success(score)
         } catch (e: Exception) {
             Log.e(TAG, "Error in laplacian calculation", e)
-            throw e
+            Result.failure(e)
         }
     }
 
-    private fun calculateLaplacianScore(nv21: ByteArray, width: Int, height: Int): Int {
-        val expectedSize = width * height + (width * height) / 2
-        if (nv21.size < expectedSize) {
-            throw IllegalArgumentException("NV21 buffer size mismatch for Laplacian: expected $expectedSize, got ${nv21.size}")
-        }
-
-        if (grayscaleBuffer == null || grayscaleBuffer!!.size < INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE) {
-            grayscaleBuffer = IntArray(INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE)
-        }
-        
-        val grayscale = yuvConverter.nv21ToGrayscaleIntArray(
-            nv21, width, height,
-            INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE,
-            grayscaleBuffer
+    // FROM WORKING VERSION: calculateLaplacianScore
+    private fun calculateLaplacianScore(bitmap: Bitmap): Int {
+        val laplace = arrayOf(
+            intArrayOf(0, 1, 0),
+            intArrayOf(1, -4, 1),
+            intArrayOf(0, 1, 0)
         )
 
-        if (grayscale == null || grayscale.isEmpty()) {
-            throw Exception("Grayscale conversion returned empty array")
-        }
+        val size = laplace.size
+        val img = convertGreyImg(bitmap)
+        val height = img.size
+        val width = img[0].size
 
         var score = 0
-        for (y in 1 until INPUT_IMAGE_SIZE - 1) {
-            val rowOffset = y * INPUT_IMAGE_SIZE
-            for (x in 1 until INPUT_IMAGE_SIZE - 1) {
-                val center = grayscale[rowOffset + x]
-                val top = grayscale[rowOffset - INPUT_IMAGE_SIZE + x]
-                val bottom = grayscale[rowOffset + INPUT_IMAGE_SIZE + x]
-                val left = grayscale[rowOffset + x - 1]
-                val right = grayscale[rowOffset + x + 1]
-                val result = (top + left + right + bottom) - (4 * center)
-                if (abs(result) > LAPLACE_THRESHOLD) score++
+        for (x in 0 until height - size + 1) {
+            for (y in 0 until width - size + 1) {
+                var result = 0
+                for (i in 0 until size) {
+                    for (j in 0 until size) {
+                        result += img[x + i][y + j] * laplace[i][j]
+                    }
+                }
+                if (result > LAPLACE_THRESHOLD) {
+                    score++
+                }
             }
         }
-
         return score
     }
 
-    private fun calculateTextureComplexity(nv21: ByteArray, width: Int, height: Int): Int {
-        // Enhanced texture analysis using multiple filters
-        if (grayscaleBuffer == null || grayscaleBuffer!!.size < INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE) {
-            grayscaleBuffer = IntArray(INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE)
-        }
-        
-        val grayscale = yuvConverter.nv21ToGrayscaleIntArray(
-            nv21, width, height,
-            INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE,
-            grayscaleBuffer
-        ) ?: return 0
-
-        var complexity = 0
-        
-        // Sobel edge detection for texture analysis
-        for (y in 1 until INPUT_IMAGE_SIZE - 1) {
-            val rowOffset = y * INPUT_IMAGE_SIZE
-            for (x in 1 until INPUT_IMAGE_SIZE - 1) {
-                val gx = (-1 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x - 1] +
-                          1 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x + 1] +
-                          -2 * grayscale[rowOffset + x - 1] +
-                          2 * grayscale[rowOffset + x + 1] +
-                          -1 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x - 1] +
-                          1 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x + 1])
-                
-                val gy = (-1 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x - 1] +
-                          -2 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x] +
-                          -1 * grayscale[rowOffset - INPUT_IMAGE_SIZE + x + 1] +
-                          1 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x - 1] +
-                          2 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x] +
-                          1 * grayscale[rowOffset + INPUT_IMAGE_SIZE + x + 1])
-                
-                val gradient = sqrt((gx * gx + gy * gy).toDouble()).toInt()
-                if (gradient > 50) complexity++
+    // FROM WORKING VERSION: convertGreyImg
+    private fun convertGreyImg(bitmap: Bitmap): Array<IntArray> {
+        val width = bitmap.width
+        val height = bitmap.height
+        val greyImg = Array(height) { IntArray(width) }
+
+        val pixels = IntArray(width * height)
+        bitmap.getPixels(pixels, 0, width, 0, 0, width, height)
+
+        for (i in 0 until height) {
+            for (j in 0 until width) {
+                val pixel = pixels[i * width + j]
+                val r = (pixel shr 16) and 0xFF
+                val g = (pixel shr 8) and 0xFF
+                val b = pixel and 0xFF
+                greyImg[i][j] = (0.299 * r + 0.587 * g + 0.114 * b).toInt()
             }
         }
-        
-        return complexity
+        return greyImg
     }
 
-    private fun calculateColorSaturation(nv21: ByteArray, width: Int, height: Int): Float {
-        // Calculate average color saturation to detect printed attacks
-        val uvStart = width * height
-        var totalSaturation = 0f
-        var sampleCount = 0
+    // FROM WORKING VERSION: calculateCombinedScore
+    private fun calculateCombinedScore(neuralScore: Float, laplacianScore: Int): Float {
+        // Normalize both scores to 0-1 range
+        val normalizedNeural = neuralScore.coerceIn(0f, 1f)
+        val normalizedLaplacian = (laplacianScore.toFloat() / LAPLACIAN_THRESHOLD).coerceIn(0f, 1f)
         
-        for (i in uvStart until nv21.size step 2) {
-            val u = (nv21[i].toInt() and 0xFF) - 128
-            val v = (nv21[i + 1].toInt() and 0xFF) - 128
-            val saturation = sqrt((u * u + v * v).toDouble()).toFloat()
-            totalSaturation += saturation
-            sampleCount++
-        }
+        // For real face: neuralScore should be LOW (< 0.2), laplacianScore should be HIGH (> 3000)
+        // Combined score: lower neural + higher laplacian = higher (more live)
+        val neuralWeight = 0.6f
+        val laplacianWeight = 0.4f
         
-        return if (sampleCount > 0) totalSaturation / sampleCount / 128.0f else 0f
-    }
-
-    private fun calculateTemporalConsistency(currentScore: Float): Float {
-        // Analyze score consistency over time
-        scoreHistory.addFirst(currentScore)
-        if (scoreHistory.size > HISTORY_SIZE) {
-            scoreHistory.removeLast()
-        }
-        
-        if (scoreHistory.size < MIN_FRAMES_FOR_ANALYSIS) {
-            return 1.0f // Maximum consistency initially
-        }
+        // Invert neural score since low neural = live, high neural = spoof
+        val invertedNeural = 1f - normalizedNeural
         
-        // Calculate variance of recent scores
-        val mean = scoreHistory.average().toFloat()
-        val variance = scoreHistory.map { (it - mean) * (it - mean) }.average().toFloat()
-        
-        // Convert variance to consistency score (lower variance = higher consistency)
-        return max(0f, 1.0f - (variance / SCORE_VARIANCE_THRESHOLD))
+        return (invertedNeural * neuralWeight) + (normalizedLaplacian * laplacianWeight)
     }
 
-    data class SpoofDetectionResult(
-        val type: String,
-        val confidence: Float
-    )
-
-    private fun detectSpoofType(
-        nnScore: Float, 
-        laplacianScore: Int, 
-        textureScore: Int, 
-        colorSat: Float, 
-        temporalConsistency: Float
-    ): SpoofDetectionResult {
-        
-        // Detect specific spoof types based on feature patterns
-        return when {
-            // Printed photo detection (low texture, low laplacian)
-            textureScore < TEXTURE_COMPLEXITY_THRESHOLD * 0.6 && 
-            laplacianScore < LAPLACIAN_THRESHOLD * 0.7 -> 
-                SpoofDetectionResult("PRINTED_PHOTO", 0.8f)
-            
-            // Screen replay detection (high color saturation, medium texture)
-            colorSat > COLOR_SATURATION_THRESHOLD * 1.2 && 
-            textureScore > TEXTURE_COMPLEXITY_THRESHOLD * 0.8 -> 
-                SpoofDetectionResult("SCREEN_REPLAY", 0.7f)
-            
-            // 3D mask detection (medium scores across all features)
-            nnScore > BASE_THRESHOLD * 1.5 && 
-            temporalConsistency < 0.7f -> 
-                SpoofDetectionResult("3D_MASK", 0.6f)
-            
-            // General spoof
-            nnScore > BASE_THRESHOLD -> 
-                SpoofDetectionResult("GENERAL_SPOOF", 0.9f)
-            
-            else -> SpoofDetectionResult("UNKNOWN", 0.5f)
-        }
-    }
-
-    private fun calculateConfidence(
-        nnScore: Float, 
-        laplacianScore: Int, 
-        textureScore: Int, 
-        temporalConsistency: Float
-    ): Float {
-        val nnConfidence = 1.0f - (nnScore / BASE_THRESHOLD).coerceIn(0f, 1f)
-        val textureConfidence = (textureScore.toFloat() / TEXTURE_COMPLEXITY_THRESHOLD).coerceIn(0f, 1f)
+    // NEW: Helper function to calculate confidence
+    private fun calculateConfidence(neuralScore: Float, laplacianScore: Int): Float {
+        // Confidence based on how well both metrics indicate a real face
+        val neuralConfidence = neuralScore.coerceIn(0f, 1f)  // High neural score = spoof (lower confidence)
         val laplacianConfidence = (laplacianScore.toFloat() / LAPLACIAN_THRESHOLD).coerceIn(0f, 1f)
         
-        return (nnConfidence * 0.4f + textureConfidence * 0.3f + 
-                laplacianConfidence * 0.2f + temporalConsistency * 0.1f)
-    }
-
-    private fun calculateCombinedScore(
-        neuralScore: Float, 
-        laplacianScore: Int, 
-        textureScore: Int, 
-        temporalConsistency: Float
-    ): Float {
-        val normalizedLaplacian = laplacianScore.toFloat() / LAPLACIAN_THRESHOLD
-        val normalizedTexture = textureScore.toFloat() / TEXTURE_COMPLEXITY_THRESHOLD
+        // For real face: neural should be high (bad) and laplacian should be high (good)
+        // So: (1 - neural) gives us confidence from neural, and laplacian gives direct confidence
+        val invertedNeural = 1f - neuralConfidence
         
-        return (1 - neuralScore) * 0.5f + 
-               normalizedLaplacian * 0.25f + 
-               normalizedTexture * 0.15f + 
-               temporalConsistency * 0.1f
+        return (invertedNeural * 0.6f + laplacianConfidence * 0.4f)
     }
 
-    private fun isLiveFace(
-        nnScore: Float,
-        laplacianScore: Int,
-        textureScore: Int,
-        colorSat: Float,
-        temporalConsistency: Float,
-        spoofDetection: SpoofDetectionResult
-    ): Boolean {
+    // NEW: Convert NV21 to Bitmap
+    private fun nv21ToBitmap(nv21: ByteArray, width: Int, height: Int): Bitmap {
+        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        val pixels = IntArray(width * height)
         
-        // Multi-layered spoof detection
-        val layer1 = nnScore < adaptiveThreshold
-        val layer2 = laplacianScore > LAPLACIAN_THRESHOLD
-        val layer3 = textureScore > TEXTURE_COMPLEXITY_THRESHOLD
-        val layer4 = temporalConsistency < 0.5f  // Low temporal consistency (stable) = real face
-        val layer5 = colorSat < COLOR_SATURATION_THRESHOLD * 1.5f
+        val ySize = width * height
+        val uvSize = (width * height) / 4
+        val uvOffset = ySize
         
-        // Require majority of layers to pass, with neural network score being most important
-        val passedLayers = listOf(layer1, layer2, layer3, layer4, layer5).count { it }
+        for (y in 0 until height) {
+            for (x in 0 until width) {
+                val yIndex = y * width + x
+                val uvIndex = uvOffset + ((y / 2) * (width / 2) + (x / 2)) * 2
+                
+                val yValue = (nv21[yIndex].toInt() and 0xFF)
+                val uValue = (nv21[uvIndex].toInt() and 0xFF) - 128
+                val vValue = (nv21[uvIndex + 1].toInt() and 0xFF) - 128
+                
+                // YUV to RGB conversion
+                var r = yValue + (1.402f * vValue)
+                var g = yValue - (0.344f * uValue) - (0.714f * vValue)
+                var b = yValue + (1.772f * uValue)
+                
+                // Clamp values
+                r = r.coerceIn(0f, 255f)
+                g = g.coerceIn(0f, 255f)
+                b = b.coerceIn(0f, 255f)
+                
+                pixels[yIndex] = (0xFF shl 24) or 
+                               ((r.toInt() and 0xFF) shl 16) or 
+                               ((g.toInt() and 0xFF) shl 8) or 
+                               (b.toInt() and 0xFF)
+            }
+        }
         
-        // More lenient: must pass at least 3 out of 5 layers, with neural network being primary indicator
-        // Layer1 (nnScore) is most reliable, so prioritize it heavily
-        return (passedLayers >= 3 && layer1) || (passedLayers >= 4)
+        bitmap.setPixels(pixels, 0, width, 0, 0, width, height)
+        return bitmap
     }
 
     @Throws(IOException::class)
@@ -560,13 +384,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     fun isInitialized(): Boolean = isInitialized
 
-    fun resetHistory() {
-        scoreHistory.clear()
-        laplacianHistory.clear()
-        frameCount = 0
-        adaptiveThreshold = BASE_THRESHOLD
-    }
-
     fun close() {
         try {
             interpreter?.close()
@@ -574,94 +391,11 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             gpuDelegate?.close()
             gpuDelegate = null
             currentAccelerator = ACCELERATOR_CPU
-            resetHistory()
             Log.i(TAG, "Interpreter and delegates closed successfully")
         } catch (e: Exception) {
             Log.e(TAG, "Error closing interpreter", e)
         }
     }
-
-    /**
-     * Detects if the device is high-end based on RAM, processor, and Android version.
-     * High-end devices can use GPU/NNAPI delegates.
-     * Low-end devices default to optimized CPU inference.
-     */
-    private fun isHighEndDevice(): Boolean {
-        try {
-            // Check Android version
-            if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
-                Log.d(TAG, "Device running Android ${android.os.Build.VERSION.SDK_INT} (< 5.0) - low-end")
-                return false
-            }
-            
-            // Check available RAM
-            val runtime = Runtime.getRuntime()
-            val maxMemory = runtime.maxMemory() / (1024 * 1024) // Convert to MB
-            if (maxMemory < 256) { // Less than 256MB allocated
-                Log.d(TAG, "Low available RAM: ${maxMemory}MB - treating as low-end device")
-                return false
-            }
-            
-            // Check processor cores (devices with 2 cores or less are typically low-end)
-            val processorCount = Runtime.getRuntime().availableProcessors()
-            if (processorCount <= 2) {
-                Log.d(TAG, "Limited CPU cores: $processorCount - low-end device")
-                return false
-            }
-            
-            // Check device name for known low-end models
-            val model = android.os.Build.MODEL.lowercase()
-            val lowEndMarkers = listOf(
-                "moto g", "samsung a", "samsung j", "redmi 6", "redmi 7", 
-                "honor 8a", "galaxy a01", "galaxy j2"
-            )
-            
-            for (marker in lowEndMarkers) {
-                if (model.contains(marker)) {
-                    Log.d(TAG, "Known low-end device model: ${android.os.Build.MODEL}")
-                    return false
-                }
-            }
-            
-            Log.d(TAG, "Device appears to be high-end (Android ${android.os.Build.VERSION.SDK_INT}, $processorCount cores, ${maxMemory}MB RAM)")
-            return true
-        } catch (e: Exception) {
-            Log.w(TAG, "Error detecting device tier: ${e.message}, defaulting to CPU-only")
-            return false
-        }
-    }
-
-    /**
-     * Calculates optimal thread count based on available processors and device resources.
-     * Low-end devices use 1-2 threads to avoid memory issues.
-     */
-    private fun getOptimalThreadCount(): Int {
-        return try {
-            val availableProcessors = Runtime.getRuntime().availableProcessors()
-            
-            // For low-end devices, limit thread count
-            if (!isHighEndDevice()) {
-                Log.d(TAG, "Low-end device: limiting threads to 1-2")
-                return maxOf(1, minOf(2, availableProcessors - 1))
-            }
-            
-            // For high-end devices, use configured count or optimal calculation
-            val configured = AcceleratorConfig.cpuThreadCount
-            val optimal = maxOf(1, availableProcessors - 1)
-            
-            val threadCount = if (configured > 0) {
-                minOf(configured, availableProcessors)
-            } else {
-                optimal
-            }
-            
-            Log.d(TAG, "Optimal thread count: $threadCount (available processors: $availableProcessors)")
-            threadCount
-        } catch (e: Exception) {
-            Log.w(TAG, "Error calculating optimal threads: ${e.message}, using default")
-            AcceleratorConfig.cpuThreadCount
-        }
-    }
 }
 
 data class AntiSpoofingResult(
@@ -671,8 +405,5 @@ data class AntiSpoofingResult(
     val temporalConsistency: Float,
     val colorSaturation: Float,
     val combinedScore: Float,
-    val isLive: Boolean,
-    val confidence: Float,
-    val label: String,
-    val spoofType: String
+    val confidence: Float
 )