react-native-vision-camera-spoof-detector 1.0.9 → 1.0.11

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

@@ -14,15 +14,11 @@ import java.nio.ByteOrder
 import java.util.*
 import android.util.Log
 import kotlin.collections.ArrayList
-import android.util.Base64
-import com.faceantispoof.ImageFormatEncoder
-import com.faceantispoof.ImageFormatEncoder.ImageFormat
-
 class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     companion object {
         const val INPUT_IMAGE_SIZE = 256
-        const val BASE_THRESHOLD = 0.2f 
+        const val BASE_THRESHOLD = 0.35f  // Reduced from 0.2f to be more lenient with real faces 
         const val ROUTE_INDEX = 6
         const val LAPLACE_THRESHOLD = 50
         const val LAPLACIAN_THRESHOLD = 1000
@@ -34,26 +30,16 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         const val ACCELERATOR_GPU = "GPU"
         const val ACCELERATOR_NNAPI = "NNAPI"
         
-        // ENHANCED IMAGE FORMAT CONFIGURATION FOR FACE RECOGNITION
-        // Optimized for maximum quality for face detection APIs
-        const val DEFAULT_IMAGE_FORMAT = "JPEG"  // Options: "JPEG", "PNG", "BMP"
-        const val DEFAULT_JPEG_QUALITY = 92      // Increased from 85 to 92 for better quality
-        const val DEFAULT_OUTPUT_RESOLUTION = 640 // 640×640 for face recognition
-        
         // 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 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
         
-        // STABILITY ENHANCEMENT CONSTANTS
-        private const val BLUR_DETECTION_THRESHOLD = 100  // Laplacian score threshold
-        private const val MIN_STABLE_FRAMES = 3  // Require stable frames before generating base64
-        private const val MOTION_THRESHOLD = 0.1f  // Limit motion/instability
     }
 
     private var interpreter: Interpreter? = null
@@ -61,11 +47,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     private var gpuDelegate: GpuDelegate? = null
     private var currentAccelerator: String = ACCELERATOR_CPU
     
-    // Image format configuration for face recognition
-    private var outputImageFormat: String = DEFAULT_IMAGE_FORMAT
-    private var outputImageQuality: Int = DEFAULT_JPEG_QUALITY
-    private var outputImageResolution: Int = DEFAULT_OUTPUT_RESOLUTION
-    
     // 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())
@@ -83,21 +64,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     private val laplacianHistory = LinkedList<Int>()
     private var frameCount = 0
     private var adaptiveThreshold = BASE_THRESHOLD
-    private var environmentAssessment = EnvironmentAssessment()
-    
-    // STABILITY AND QUALITY TRACKING
-    private var consecutiveQualityFrames = 0  // Track consecutive high-quality frames
-    private var lastStableFrameTime = System.currentTimeMillis()
-    private var lastProcessedBlurScore = 0
-    private var frameStabilityScore = 0f
-
-    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()
@@ -114,7 +80,7 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             options.setNumThreads(optimalThreads)
             
             currentAccelerator = ACCELERATOR_CPU
-            Log.i(TAG, "✓ FORCED CPU-ONLY MODE - Bypassing GPU/NNAPI")
+            Log.i(TAG, "FORCED CPU-ONLY MODE - Bypassing GPU/NNAPI")
             Log.i(TAG, "Using $optimalThreads threads for CPU inference")
             
             interpreter = Interpreter(modelBuffer, options)
@@ -130,9 +96,9 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             outputs[outputIndex0] = clssPred
             outputs[outputIndex1] = leafNodeMask
             isInitialized = true
-            Log.i(TAG, "✓ Face Anti-Spoof initialized | CPU-ONLY MODE | Threads: $optimalThreads")
+            Log.i(TAG, "Face Anti-Spoof initialized | CPU-ONLY MODE | Threads: $optimalThreads")
         } catch (e: Exception) {
-            Log.e(TAG, "✗ Failed to load TFLite model: ${e.message}", e)
+            Log.e(TAG, "FAILED to load TFLite model: ${e.message}", e)
             isInitialized = false
             currentAccelerator = ACCELERATOR_CPU
         }
@@ -177,57 +143,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     fun getAccelerator(): String = currentAccelerator
 
-    /**
-     * Configure output image format for face recognition system.
-     * Supports JPEG (compressed), PNG (lossless), or BMP (uncompressed).
-     *
-     * @param format Image format: "JPEG" (default), "PNG", or "BMP"
-     * @param quality JPEG quality 0-100 (only applies to JPEG, ignored for PNG/BMP)
-     * @param resolution Output resolution in pixels (640 for 640×640, etc.)
-     */
-    fun setImageFormatConfig(
-        format: String = "JPEG",
-        quality: Int = 85,
-        resolution: Int = 640
-    ) {
-        val uppercaseFormat = format.uppercase()
-        outputImageFormat = if (uppercaseFormat in listOf("JPEG", "PNG", "BMP")) {
-            uppercaseFormat
-        } else {
-            "JPEG"
-        }
-        outputImageQuality = quality.coerceIn(1, 100)
-        outputImageResolution = resolution.coerceIn(64, 2048)
-        Log.d(TAG, "Image format config: $outputImageFormat quality=$outputImageQuality resolution=${outputImageResolution}×${outputImageResolution}")
-    }
-
-    /**
-     * Get current image format configuration.
-     * @return Map containing format, quality, and resolution
-     */
-    fun getImageFormatConfig(): Map<String, Any> {
-        return mapOf(
-            "format" to outputImageFormat,
-            "quality" to outputImageQuality,
-            "resolution" to outputImageResolution,
-            "estimatedSize" to estimateImageSize()
-        )
-    }
-
-    /**
-     * Estimate output image size for current format configuration.
-     * Useful for memory and network planning.
-     */
-    private fun estimateImageSize(): Long {
-        val pixelCount = outputImageResolution.toLong() * outputImageResolution
-        return when (outputImageFormat) {
-            "JPEG" -> (pixelCount * (100 - outputImageQuality) * 0.0012).toLong() // Quality-based estimation
-            "PNG" -> (pixelCount * 0.5).toLong()  // PNG typically 2-4x larger than JPEG
-            "BMP" -> pixelCount * 3  // Uncompressed RGB
-            else -> (pixelCount * 0.12).toLong()
-        }
-    }
-
     fun advancedAntiSpoofing(nv21: ByteArray, width: Int, height: Int): AntiSpoofingResult {
         if (!isInitialized) {
             return AntiSpoofingResult(
@@ -240,23 +155,20 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 isLive = false,
                 confidence = 0f,
                 label = "Not Initialized",
-                spoofType = "UNKNOWN",
-                imageFormat = outputImageFormat,
-                imageResolution = outputImageResolution,
-                imageQuality = outputImageQuality
+                spoofType = "UNKNOWN"
             )
         }
 
         // Enhanced input validation
-        if (nv21.isEmpty()) {
-            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Invalid NV21 buffer", "INVALID_INPUT",
-                imageFormat = outputImageFormat, imageResolution = outputImageResolution, imageQuality = outputImageQuality)
+        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) {
-            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Buffer size mismatch", "INVALID_INPUT",
-                imageFormat = outputImageFormat, imageResolution = outputImageResolution, imageQuality = outputImageQuality)
+            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 {
@@ -267,9 +179,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             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, 
@@ -292,53 +201,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 spoofDetection
             )
 
-            // Generate recognition image (JPEG/PNG/BMP) Base64 when face is live
-            var recognitionImageBase64: String? = null
-            val DEBUG_FORCE_BASE64 = false // Set to true to force Base64 generation for testing
-            
-            // STABILITY CHECK: Only generate base64 for high-quality, stable frames
-            val isQualityFrame = laplacianScore > BLUR_DETECTION_THRESHOLD && 
-                                temporalConsistency < MOTION_THRESHOLD &&
-                                textureScore > TEXTURE_COMPLEXITY_THRESHOLD / 2
-            
-            if (isQualityFrame) {
-                consecutiveQualityFrames++
-                frameStabilityScore = (laplacianScore.toFloat() / 1000f).coerceIn(0f, 1f)
-            } else {
-                consecutiveQualityFrames = 0
-                frameStabilityScore = 0f
-            }
-            
-            // Only generate base64 after collecting stable frames
-            val shouldGenerateBase64 = (isLive && (consecutiveQualityFrames >= MIN_STABLE_FRAMES || DEBUG_FORCE_BASE64)) ||
-                                       DEBUG_FORCE_BASE64
-            
-            if (shouldGenerateBase64) {
-                Log.d(TAG, "🔍 Quality Frame Detected - Stability Score: $frameStabilityScore (${consecutiveQualityFrames}/$MIN_STABLE_FRAMES frames)")
-                Log.d(TAG, "   Blur Score: $laplacianScore (threshold: $BLUR_DETECTION_THRESHOLD)")
-                Log.d(TAG, "   Motion: $temporalConsistency (threshold: $MOTION_THRESHOLD)")
-                Log.d(TAG, "   Texture: $textureScore (min: ${TEXTURE_COMPLEXITY_THRESHOLD / 2})")
-                
-                try {
-                    recognitionImageBase64 = generateRecognitionImageBase64(nv21, width, height)
-                    if (recognitionImageBase64 != null) {
-                        Log.d(TAG, "✅ Generated 640x640 JPEG Base64 for recognition API (size: ${recognitionImageBase64.length} bytes)")
-                    } else {
-                        Log.w(TAG, "⚠️ generateRecognitionImageBase64 returned null")
-                    }
-                } catch (e: Exception) {
-                    Log.w(TAG, "❌ Failed to generate Base64: ${e.message}", e)
-                    // Continue without the image - it's not critical
-                }
-            } else {
-                if (!isLive) {
-                    Log.d(TAG, "🚫 Not generating Base64 - Spoof detected (${spoofDetection.type})")
-                } else {
-                    Log.d(TAG, "🚫 Waiting for stable frames... (${consecutiveQualityFrames}/$MIN_STABLE_FRAMES)")
-                    Log.d(TAG, "   Quality Score: $frameStabilityScore | Blur: $laplacianScore | Motion: $temporalConsistency")
-                }
-            }
-
             AntiSpoofingResult(
                 neuralNetworkScore = nnScore,
                 laplacianScore = laplacianScore,
@@ -349,16 +211,11 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 isLive = isLive,
                 confidence = confidence,
                 label = if (isLive) "Live Face" else "Spoof Face: ${spoofDetection.type}",
-                spoofType = spoofDetection.type,
-                recognitionImageBase64 = recognitionImageBase64,
-                imageFormat = outputImageFormat,
-                imageResolution = outputImageResolution,
-                imageQuality = outputImageQuality
+                spoofType = spoofDetection.type
             )
         } catch (e: Exception) {
             Log.e(TAG, "Error in advancedAntiSpoofing", e)
-            AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: ${e.message}", "PROCESSING_ERROR",
-                imageFormat = outputImageFormat, imageResolution = outputImageResolution, imageQuality = outputImageQuality)
+            AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: ${e.message}", "PROCESSING_ERROR")
         }
     }
 
@@ -449,91 +306,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
      * @param height Original frame height
      * @return Base64 encoded image string, or null if generation fails
      */
-    private fun generateRecognitionImageBase64(nv21: ByteArray, width: Int, height: Int): String? {
-        return try {
-            Log.d(TAG, "Starting HIGH-QUALITY ${outputImageResolution}×${outputImageResolution} $outputImageFormat generation...")
-            Log.d(TAG, "Input: ${width}x${height}, JPEG Quality: $outputImageQuality (optimized for face detection)")
-            
-            // Convert NV21 to RGB byte array using HIGH-QUALITY BILINEAR interpolation
-            val rgbBytes = ByteArray(outputImageResolution * outputImageResolution * 3)
-            Log.d(TAG, "Allocated RGB buffer: ${rgbBytes.size} bytes")
-            
-            val startConvert = System.currentTimeMillis()
-            val convertedRgb = yuvConverter.nv21ToRgbByteArray(
-                nv21, width, height,
-                outputImageResolution, outputImageResolution,
-                rgbBytes
-            )
-            val convertTime = System.currentTimeMillis() - startConvert
-            Log.d(TAG, "✓ YUV→RGB conversion (bilinear): ${convertTime}ms | ${convertedRgb.size} bytes")
-
-            // Encode RGB to target format with sharpening
-            // NOTE: ImageFormatEncoder.rgbToBase64() automatically:
-            //   - Applies unsharp masking for edge enhancement
-            //   - Converts RGB→BGR for OpenCV compatibility
-            //   - Uses optimized JPEG quality
-            val startEncode = System.currentTimeMillis()
-            val format = when (outputImageFormat) {
-                "PNG" -> ImageFormatEncoder.ImageFormat.PNG
-                "BMP" -> ImageFormatEncoder.ImageFormat.BMP
-                else -> ImageFormatEncoder.ImageFormat.JPEG
-            }
-            
-            val base64Result = ImageFormatEncoder.rgbToBase64(
-                convertedRgb, 
-                outputImageResolution, 
-                outputImageResolution,
-                format,
-                outputImageQuality  // Using quality 92 for better face detection
-            )
-            val encodeTime = System.currentTimeMillis() - startEncode
-            
-            if (base64Result != null) {
-                Log.d(TAG, "✓ $outputImageFormat encoding (with sharpening): ${encodeTime}ms")
-                Log.d(TAG, "✅ HIGH-QUALITY Base64 Generated:")
-                Log.d(TAG, "   Resolution: ${outputImageResolution}×${outputImageResolution}")
-                Log.d(TAG, "   Format: $outputImageFormat (BGR for OpenCV)")
-                Log.d(TAG, "   Quality: $outputImageQuality (enhanced for face recognition)")
-                Log.d(TAG, "   Size: ${base64Result.length} chars (est. ${base64Result.length * 0.75 / 1024}KB)")
-                Log.d(TAG, "   Total Time: ${convertTime + encodeTime}ms")
-                val estSize = estimateImageSize()
-                Log.d(TAG, "   Estimated: ${estSize / 1024}KB")
-            } else {
-                Log.w(TAG, "⚠️ ImageFormatEncoder returned null")
-            }
-            
-            base64Result
-        } catch (e: Exception) {
-            Log.e(TAG, "❌ Error generating ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64 (BGR format): ${e.message}", e)
-            e.printStackTrace()
-            null
-        }
-    }
-
-    /**
-     * Legacy method: Generate 640×640 JPEG image as Base64 string.
-     * Kept for backward compatibility. Use generateRecognitionImageBase64() for new code.
-     */
-    @Deprecated("Use generateRecognitionImageBase64() instead", ReplaceWith("generateRecognitionImageBase64(nv21, width, height)"))
-    private fun generate640x640JpegBase64(nv21: ByteArray, width: Int, height: Int): String? {
-        // Temporarily set format to JPEG for backward compatibility
-        val savedFormat = outputImageFormat
-        outputImageFormat = "JPEG"
-        val savedQuality = outputImageQuality
-        outputImageQuality = 85
-        val savedResolution = outputImageResolution
-        outputImageResolution = 640
-        
-        val result = generateRecognitionImageBase64(nv21, width, height)
-        
-        // Restore original config
-        outputImageFormat = savedFormat
-        outputImageQuality = savedQuality
-        outputImageResolution = savedResolution
-        
-        return result
-    }
-
     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")
@@ -678,35 +450,6 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         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
@@ -787,14 +530,15 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         val layer1 = nnScore < adaptiveThreshold
         val layer2 = laplacianScore > LAPLACIAN_THRESHOLD
         val layer3 = textureScore > TEXTURE_COMPLEXITY_THRESHOLD
-        val layer4 = temporalConsistency > 0.7f
+        val layer4 = temporalConsistency < 0.5f  // Low temporal consistency (stable) = real face
         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
+        // 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)
     }
 
     @Throws(IOException::class)
@@ -930,10 +674,5 @@ data class AntiSpoofingResult(
     val isLive: Boolean,
     val confidence: Float,
     val label: String,
-    val spoofType: String,
-    val recognitionImageBase64: String? = null,
-    // Image format metadata
-    val imageFormat: String = "JPEG",           // Format: JPEG, PNG, BMP
-    val imageResolution: Int = 640,             // 640×640, 1280×720, etc.
-    val imageQuality: Int = 85                  // Quality for JPEG (0-100)
+    val spoofType: String
 )

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

@@ -2,6 +2,7 @@ package com.faceantispoof
 
 import java.nio.ByteBuffer
 import kotlin.math.abs
+import kotlin.math.pow
 
 /**
  * Converts YUV NV21 data directly to normalized RGB float arrays without creating Bitmaps.
@@ -221,7 +222,8 @@ class YuvToFloatArrayConverter {
     }
 
     /**
-     * Convert a single YUV pixel to RGB.
+     * Convert a single YUV pixel to RGB with optional gamma correction.
+     * Applies sRGB gamma curve to match hardware ISP output.
      */
     private fun yuvToRgb(
         nv21: ByteArray,
@@ -246,7 +248,17 @@ class YuvToFloatArrayConverter {
         val g = (yf - 0.34414f * uf - 0.71414f * vf).coerceIn(0f, 255f)
         val b = (yf + 1.772f * uf).coerceIn(0f, 255f)
 
-        return Triple(r, g, b)
+        // FIXED: Apply sRGB gamma correction to match hardware ISP
+        // This ensures that colors match hardware-captured JPEGs
+        val rLinear = r / 255f
+        val gLinear = g / 255f
+        val bLinear = b / 255f
+        
+        val rCorrected = applyGammaCorrection(rLinear)
+        val gCorrected = applyGammaCorrection(gLinear)
+        val bCorrected = applyGammaCorrection(bLinear)
+
+        return Triple(rCorrected * 255f, gCorrected * 255f, bCorrected * 255f)
     }
 
     /**
@@ -549,4 +561,24 @@ class YuvToFloatArrayConverter {
 
         return output
     }
+
+    /**
+     * Apply sRGB gamma correction to match hardware camera ISP output.
+     * This is CRITICAL for face recognition: hardware cameras apply gamma correction,
+     * but raw YUV conversion doesn't. This function brings the frame processor output
+     * in line with native camera JPEGs.
+     * 
+     * @param linear Linear RGB value in range [0, 1]
+     * @return Gamma-corrected RGB value in range [0, 1]
+     */
+    private fun applyGammaCorrection(linear: Float): Float {
+        return if (linear <= 0.0031308f) {
+            // Linear segment for very dark values
+            linear * 12.92f
+        } else {
+            // Power law segment for normal values
+            // sRGB formula: value^(1/2.4)
+            1.055f * Math.pow(linear.toDouble(), 1.0 / 2.4).toFloat() - 0.055f
+        }
+    }
 }

package/index.js

@@ -9,12 +9,31 @@ const _faceAntiSpoofPlugin = VisionCameraProxy.initFrameProcessorPlugin('faceAnt
 export const faceAntiSpoofFrameProcessor = function (frame) {
   'worklet';
   try {
-    if (_faceAntiSpoofPlugin && typeof _faceAntiSpoofPlugin.call === 'function') {
-      return _faceAntiSpoofPlugin.call(frame);
+    if (!_faceAntiSpoofPlugin) {
+      console.warn('[FaceAntiSpoof] Plugin not initialized');
+      return null;
     }
+    
+    if (typeof _faceAntiSpoofPlugin.call !== 'function') {
+      console.warn('[FaceAntiSpoof] Plugin call method not available');
+      return null;
+    }
+    
+    if (!frame) {
+      console.warn('[FaceAntiSpoof] Frame is null or undefined');
+      return null;
+    }
+    
+    const result = _faceAntiSpoofPlugin.call(frame);
+    
+    // Validate result structure
+    if (result && typeof result === 'object') {
+      return result;
+    }
+    
     return null;
   } catch (err) {
-    console.error('[FaceAntiSpoof] Error in frame processor call:', err);
+    console.error('[FaceAntiSpoof] Error in frame processor:', err);
     return null;
   }
 };
@@ -28,18 +47,28 @@ export const isFaceAntiSpoofAvailable = () => {
 
 export const initializeFaceAntiSpoof = async () => {
   try {
+    if (!FaceAntiSpoof) {
+      throw new Error('FaceAntiSpoof module not available on this platform');
+    }
+    
     const result = await FaceAntiSpoof.initialize();
     const status = await FaceAntiSpoof.checkModelStatus();
 
+    if (!result || !status) {
+      throw new Error('Initialization returned empty result');
+    }
+
     try {
       if (typeof FaceAntiSpoof.install === 'function') {
         await FaceAntiSpoof.install();
       }
     } catch (e) {
-      console.error('[FaceAntiSpoof] install() failed:', e);
+      console.warn('[FaceAntiSpoof] install() failed:', e);
     }
 
-    return result && status.pluginAvailable;
+    const isSuccess = result && status.pluginAvailable;
+    console.log('[FaceAntiSpoof] Initialization result:', isSuccess);
+    return isSuccess;
   } catch (error) {
     console.error('[FaceAntiSpoof] Initialization failed:', error);
     throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "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/android/build/intermediates/cxx/Debug/2a1it684/logs/arm64-v8a/generate_cxx_metadata_947_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 744ms
-    [gap of 21ms]
-  execute-generate-process completed in 766ms
-  [gap of 16ms]
-generate_cxx_metadata completed in 788ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/x86_64/generate_cxx_metadata_944_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 474ms
-    [gap of 22ms]
-  execute-generate-process completed in 497ms
-  [gap of 14ms]
-generate_cxx_metadata completed in 518ms
-