react-native-vision-camera-spoof-detector 1.0.0 → 1.0.2

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

@@ -8,20 +8,21 @@ import java.io.IOException
 import java.nio.MappedByteBuffer
 import java.nio.channels.FileChannel
 import java.io.FileInputStream
-import kotlin.math.abs
+import kotlin.math.*
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
-import java.util.HashMap
+import java.util.*
 import android.util.Log
+import kotlin.collections.ArrayList
 
 class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     companion object {
         const val INPUT_IMAGE_SIZE = 256
-        const val THRESHOLD = 0.2f
+        const val BASE_THRESHOLD = 0.1f 
         const val ROUTE_INDEX = 6
         const val LAPLACE_THRESHOLD = 50
-        const val LAPLACIAN_THRESHOLD = 1000
+        const val LAPLACIAN_THRESHOLD = 10000
         const val MODEL_FILE = "FaceAntiSpoofing.tflite"
         private const val TAG = "FaceAntiSpoofing"
         
@@ -29,6 +30,16 @@ 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.08f
+        private const val SCORE_VARIANCE_THRESHOLD = 0.02f
+        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
@@ -48,6 +59,21 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     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
+    private var environmentAssessment = EnvironmentAssessment()
+
+    data class EnvironmentAssessment(
+        var avgBrightness: Float = 0f,
+        var brightnessVariance: Float = 0f,
+        var estimatedDistance: Float = 0f,
+        var lightingConsistency: Float = 0f,
+        var lastAssessmentTime: Long = 0
+    )
+
     init {
         initializeInterpreter()
     }
@@ -58,13 +84,11 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             val options = Interpreter.Options()
             options.setNumThreads(4)
             
-            // Try to add GPU delegate first
             if (tryAddGpuDelegate(options)) {
                 currentAccelerator = ACCELERATOR_GPU
                 Log.i(TAG, "GPU delegate enabled successfully")
             } 
             else {
-                // GPU not available, enable NNAPI through interpreter options
                 try {
                     options.setUseNNAPI(true)
                     currentAccelerator = ACCELERATOR_NNAPI
@@ -77,12 +101,10 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             
             interpreter = Interpreter(modelBuffer, options)
             
-            // Try to find output indices once and prepare outputs map
             try {
                 outputIndex0 = interpreter!!.getOutputIndex("Identity")
                 outputIndex1 = interpreter!!.getOutputIndex("Identity_1")
             } catch (e: Exception) {
-                // Keep defaults (0 and 1) if named outputs not available
                 Log.w(TAG, "Could not resolve named output indices, using defaults: ${e.message}")
             }
             
@@ -97,13 +119,8 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
-    /**
-     * Try to enable GPU delegate for modern devices
-     * Returns true if GPU delegate was successfully added
-     */
     private fun tryAddGpuDelegate(options: Interpreter.Options): Boolean {
         return try {
-            // Check if device supports GPU delegate
             val compatibilityList = CompatibilityList()
             if (compatibilityList.isDelegateSupportedOnThisDevice) {
                 gpuDelegate = GpuDelegate(compatibilityList.bestOptionsForThisDevice)
@@ -122,9 +139,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
-    /**
-     * Get the currently active accelerator type
-     */
     fun getAccelerator(): String = currentAccelerator
 
     fun advancedAntiSpoofing(nv21: ByteArray, width: Int, height: Int): AntiSpoofingResult {
@@ -132,35 +146,85 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             return AntiSpoofingResult(
                 neuralNetworkScore = 0f,
                 laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
                 combinedScore = 0f,
                 isLive = false,
-                label = "Not Initialized"
+                confidence = 0f,
+                label = "Not Initialized",
+                spoofType = "UNKNOWN"
             )
         }
 
+        // Enhanced input validation
+        if (nv21.isEmpty()) {
+            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Invalid NV21 buffer", "INVALID_INPUT")
+        }
+
+        val expectedSize = width * height + (width * height) / 2
+        if (nv21.size < expectedSize) {
+            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Buffer size mismatch", "INVALID_INPUT")
+        }
+
         return try {
+            // Multiple detection techniques
             val nnScore = neuralNetworkAntiSpoofing(nv21, width, height)
             val laplacianScore = laplacian(nv21, width, height)
-
-            val isLive = nnScore < THRESHOLD && laplacianScore > LAPLACIAN_THRESHOLD
-            val combinedScore = calculateCombinedScore(nnScore, laplacianScore)
+            val textureScore = calculateTextureComplexity(nv21, width, height)
+            val colorSat = calculateColorSaturation(nv21, width, height)
+            val temporalConsistency = calculateTemporalConsistency(nnScore)
+            
+            // Update adaptive threshold based on environment
+            updateAdaptiveThreshold(nv21, width, height)
+            
+            // 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)
+            
+            // 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,
-                label = if (isLive) "Live Face" else "Spoof Face"
+                confidence = confidence,
+                label = if (isLive) "Live Face" else "Spoof Face: ${spoofDetection.type}",
+                spoofType = spoofDetection.type
             )
         } catch (e: Exception) {
-            android.util.Log.e(TAG, "Error in advancedAntiSpoofing", e)
-            AntiSpoofingResult(0f, 0, 0f, false, "Error: ${e.message}")
+            Log.e(TAG, "Error in advancedAntiSpoofing", e)
+            AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: ${e.message}", "PROCESSING_ERROR")
         }
     }
 
     private fun neuralNetworkAntiSpoofing(nv21: ByteArray, width: Int, height: Int): Float {
         return try {
-            // Convert NV21 YUV to RGB float array, resized to model input size
+            val expectedSize = width * height + (width * height) / 2
+            if (nv21.size < expectedSize) {
+                throw IllegalArgumentException("NV21 buffer size mismatch: expected $expectedSize, got ${nv21.size}")
+            }
+
             if (rgbFloatBuffer == null || rgbFloatBuffer!!.size < INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE * 3) {
                 rgbFloatBuffer = FloatArray(INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE * 3)
             }
@@ -170,27 +234,44 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 rgbFloatBuffer
             )
 
-            // Fill reusable inputBuffer with normalized floats (row-major RGB)
+            if (rgbFloats == null || rgbFloats.isEmpty()) {
+                throw Exception("RGB conversion returned empty array")
+            }
+
             inputBuffer.rewind()
             for (i in 0 until (INPUT_IMAGE_SIZE * INPUT_IMAGE_SIZE * 3)) {
                 inputBuffer.putFloat(rgbFloats[i])
             }
             inputBuffer.rewind()
 
-            // Reuse preallocated outputs map and arrays
+            if (interpreter == null) {
+                throw Exception("Interpreter is null")
+            }
+
             outputs[outputIndex0] = clssPred
             outputs[outputIndex1] = leafNodeMask
 
-            // Run model with ByteBuffer input (single input)
             interpreter!!.runForMultipleInputsOutputs(arrayOf<Any>(inputBuffer), outputs)
 
-            leafScore1(clssPred, leafNodeMask)
+            val rawScore = leafScore1(clssPred, leafNodeMask)
+            
+            // Apply non-linear scaling to make high scores more sensitive
+            applyNonLinearScaling(rawScore)
         } catch (e: Exception) {
-            android.util.Log.e(TAG, "Error in neuralNetworkAntiSpoofing", e)
+            Log.e(TAG, "Error in neuralNetworkAntiSpoofing: ${e.message}", e)
             throw 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
+        }
+    }
+
     private fun leafScore1(clssPred: Array<FloatArray>, leafNodeMask: Array<FloatArray>): Float {
         var score = 0f
         for (i in 0 until 8) {
@@ -203,13 +284,17 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return try {
             calculateLaplacianScore(nv21, width, height)
         } catch (e: Exception) {
-            android.util.Log.e(TAG, "Error in laplacian calculation", e)
+            Log.e(TAG, "Error in laplacian calculation", e)
             throw e
         }
     }
 
     private fun calculateLaplacianScore(nv21: ByteArray, width: Int, height: Int): Int {
-        // Convert to grayscale intensity array (resized to model input size)
+        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)
         }
@@ -220,8 +305,11 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             grayscaleBuffer
         )
 
+        if (grayscale == null || grayscale.isEmpty()) {
+            throw Exception("Grayscale conversion returned empty array")
+        }
+
         var score = 0
-        // Apply 3x3 laplacian kernel without extra allocation
         for (y in 1 until INPUT_IMAGE_SIZE - 1) {
             val rowOffset = y * INPUT_IMAGE_SIZE
             for (x in 1 until INPUT_IMAGE_SIZE - 1) {
@@ -238,9 +326,199 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return score
     }
 
-    private fun calculateCombinedScore(neuralScore: Float, laplacianScore: Int): Float {
+    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++
+            }
+        }
+        
+        return complexity
+    }
+
+    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
+        
+        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++
+        }
+        
+        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
+        }
+        
+        // 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))
+    }
+
+    private fun updateAdaptiveThreshold(nv21: ByteArray, width: Int, height: Int) {
+        // Adjust threshold based on environmental factors
+        val brightness = calculateBrightness(nv21, width, height)
+        val currentTime = System.currentTimeMillis()
+        
+        if (currentTime - environmentAssessment.lastAssessmentTime > 1000) { // Assess every second
+            environmentAssessment.avgBrightness = brightness
+            environmentAssessment.lastAssessmentTime = currentTime
+            
+            // Make threshold more strict in good lighting conditions
+            adaptiveThreshold = if (brightness > 0.6f) {
+                BASE_THRESHOLD * 0.8f  // Stricter in good light
+            } else if (brightness < 0.3f) {
+                BASE_THRESHOLD * 1.2f  // Slightly more lenient in poor light
+            } else {
+                BASE_THRESHOLD
+            }
+        }
+    }
+
+    private fun calculateBrightness(nv21: ByteArray, width: Int, height: Int): Float {
+        // Calculate average brightness from Y channel
+        var totalLuma = 0f
+        for (i in 0 until width * height) {
+            totalLuma += (nv21[i].toInt() and 0xFF) / 255.0f
+        }
+        return totalLuma / (width * height)
+    }
+
+    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)
+        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
-        return (1 - neuralScore) * 0.7f + (normalizedLaplacian * 0.3f)
+        val normalizedTexture = textureScore.toFloat() / TEXTURE_COMPLEXITY_THRESHOLD
+        
+        return (1 - neuralScore) * 0.5f + 
+               normalizedLaplacian * 0.25f + 
+               normalizedTexture * 0.15f + 
+               temporalConsistency * 0.1f
+    }
+
+    private fun isLiveFace(
+        nnScore: Float,
+        laplacianScore: Int,
+        textureScore: Int,
+        colorSat: Float,
+        temporalConsistency: Float,
+        spoofDetection: SpoofDetectionResult
+    ): Boolean {
+        
+        // Multi-layered spoof detection
+        val layer1 = nnScore < adaptiveThreshold
+        val layer2 = laplacianScore > LAPLACIAN_THRESHOLD
+        val layer3 = textureScore > TEXTURE_COMPLEXITY_THRESHOLD
+        val layer4 = temporalConsistency > 0.7f
+        val layer5 = colorSat < COLOR_SATURATION_THRESHOLD * 1.5f
+        
+        // Require majority of layers to pass, with neural network score being most important
+        val passedLayers = listOf(layer1, layer2, layer3, layer4, layer5).count { it }
+        
+        // Stricter requirement: must pass at least 4 out of 5 layers, including neural network
+        return passedLayers >= 4 && layer1
     }
 
     @Throws(IOException::class)
@@ -255,23 +533,28 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 fileDescriptor.declaredLength
             )
         } catch (e: Exception) {
-            android.util.Log.e(TAG, "Error loading model file", e)
+            Log.e(TAG, "Error loading model file", e)
             throw e
         }
     }
 
     fun isInitialized(): Boolean = isInitialized
 
+    fun resetHistory() {
+        scoreHistory.clear()
+        laplacianHistory.clear()
+        frameCount = 0
+        adaptiveThreshold = BASE_THRESHOLD
+    }
+
     fun close() {
         try {
             interpreter?.close()
             interpreter = null
-            
-            // Clean up GPU delegate
             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)
@@ -282,7 +565,12 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 data class AntiSpoofingResult(
     val neuralNetworkScore: Float,
     val laplacianScore: Int,
+    val textureComplexity: Int,
+    val temporalConsistency: Float,
+    val colorSaturation: Float,
     val combinedScore: Float,
     val isLive: Boolean,
-    val label: String
-)
+    val confidence: Float,
+    val label: String,
+    val spoofType: String
+)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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/jescon-tech/react-native-vision-camera-spoof-detector",
   "repository": {

package/CHANGELOG.md

@@ -1,48 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [1.0.0] - 2025-11-18
-
-### Added
-- Multi-threading support with `Executors.newSingleThreadExecutor()`
-- Proper npm package structure with reduced bundle size
-- TypeScript type definitions (`index.d.ts`)
-- `.npmignore` and `.gitignore` files for proper package management
-- Support for GPU acceleration via TensorFlow Lite GPU delegate
-- Support for NNAPI acceleration as fallback
-- Daemon thread configuration for proper app lifecycle management
-- Comprehensive error handling and logging
-
-### Changed
-- Updated package.json with proper metadata and peer dependencies
-- Improved module initialization and cleanup procedures
-- Enhanced frame processor to prevent blocking VisionCamera callback thread
-- Optimized YUV to RGB conversion with reusable buffers
-- Increased version from 0.0.26 to 1.0.0 for stable release
-
-### Fixed
-- Frame drops caused by blocking processing in callback thread
-- Memory leaks by implementing proper resource cleanup
-- Executor thread lifecycle management
-
-### Removed
-- Build artifacts from `.cxx/` directory (49.44 MB)
-- Build output from `build/` directory (56.99 MB)
-- Unnecessary Gradle wrapper binaries
-
-### Performance Improvements
-- Reduced package size from 127.35 MB to 20.92 MB (83.6% reduction)
-- Non-blocking callback returns immediately
-- Single-frame processing prevents queue overflow
-- Optimized memory usage with daemon threads
-
-## [0.0.26] - Previous
-
-### Initial Release
-- Basic face anti-spoofing detection
-- React Native Vision Camera integration
-- TensorFlow Lite model support