react-native-vision-camera-spoof-detector 1.0.3 → 1.0.4

package/android/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/counters.tab

@@ -1,2 +1,2 @@
-10
+11
 0

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

@@ -132,7 +132,11 @@ class FaceAntiSpoofFrameProcessor : FrameProcessorPlugin() {
                     "neuralNetworkScore" to result.neuralNetworkScore.toDouble(),
                     "laplacianScore" to result.laplacianScore,
                     "combinedScore" to result.combinedScore.toDouble(),
-                    "recognitionImageBase64" to result.recognitionImageBase64
+                    "recognitionImageBase64" to result.recognitionImageBase64,
+                    // Image format metadata
+                    "imageFormat" to result.imageFormat,
+                    "imageResolution" to result.imageResolution,
+                    "imageQuality" to result.imageQuality
                 )
                 
                 // Update the latest result for the next callback

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

@@ -15,6 +15,8 @@ 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) {
 
@@ -32,6 +34,12 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         const val ACCELERATOR_GPU = "GPU"
         const val ACCELERATOR_NNAPI = "NNAPI"
         
+        // Image format configuration for face recognition systems
+        // Supported: JPEG (compressed), PNG (lossless), BMP (uncompressed)
+        const val DEFAULT_IMAGE_FORMAT = "JPEG"  // Options: "JPEG", "PNG", "BMP"
+        const val DEFAULT_JPEG_QUALITY = 85      // 0-100, higher = better quality but larger
+        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
@@ -48,6 +56,11 @@ 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())
@@ -142,6 +155,57 @@ 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(
@@ -154,18 +218,23 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 isLive = false,
                 confidence = 0f,
                 label = "Not Initialized",
-                spoofType = "UNKNOWN"
+                spoofType = "UNKNOWN",
+                imageFormat = outputImageFormat,
+                imageResolution = outputImageResolution,
+                imageQuality = outputImageQuality
             )
         }
 
         // Enhanced input validation
         if (nv21.isEmpty()) {
-            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Invalid NV21 buffer", "INVALID_INPUT")
+            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Invalid NV21 buffer", "INVALID_INPUT",
+                imageFormat = outputImageFormat, imageResolution = outputImageResolution, imageQuality = outputImageQuality)
         }
 
         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 AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Buffer size mismatch", "INVALID_INPUT",
+                imageFormat = outputImageFormat, imageResolution = outputImageResolution, imageQuality = outputImageQuality)
         }
 
         return try {
@@ -201,14 +270,14 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 spoofDetection
             )
 
-            // Generate 640×640 JPEG Base64 for Recognition API when face is live
+            // 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
             
             if (isLive || DEBUG_FORCE_BASE64) {
-                Log.d(TAG, "🔍 isLive=$isLive (DEBUG_FORCE_BASE64=$DEBUG_FORCE_BASE64) - generating 640x640 JPEG Base64...")
+                Log.d(TAG, "🔍 isLive=$isLive (DEBUG_FORCE_BASE64=$DEBUG_FORCE_BASE64) - generating ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64...")
                 try {
-                    recognitionImageBase64 = generate640x640JpegBase64(nv21, width, height)
+                    recognitionImageBase64 = generateRecognitionImageBase64(nv21, width, height)
                     if (recognitionImageBase64 != null) {
                         Log.d(TAG, " Generated 640x640 JPEG Base64 for recognition API (size: ${recognitionImageBase64.length} bytes)")
                     } else {
@@ -233,11 +302,15 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 confidence = confidence,
                 label = if (isLive) "Live Face" else "Spoof Face: ${spoofDetection.type}",
                 spoofType = spoofDetection.type,
-                recognitionImageBase64 = recognitionImageBase64
+                recognitionImageBase64 = recognitionImageBase64,
+                imageFormat = outputImageFormat,
+                imageResolution = outputImageResolution,
+                imageQuality = outputImageQuality
             )
         } 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(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: ${e.message}", "PROCESSING_ERROR",
+                imageFormat = outputImageFormat, imageResolution = outputImageResolution, imageQuality = outputImageQuality)
         }
     }
 
@@ -296,52 +369,90 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     }
 
     /**
-     * Generate 640×640 JPEG image as Base64 string for Recognition API.
-     * Optimized for high-speed encoding without intermediate allocations.
+     * Generate image as Base64 string for face recognition API.
+     * 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 JPEG string (640×640), or null if generation fails
+     * @return Base64 encoded image string, or null if generation fails
      */
-    private fun generate640x640JpegBase64(nv21: ByteArray, width: Int, height: Int): String? {
+    private fun generateRecognitionImageBase64(nv21: ByteArray, width: Int, height: Int): String? {
         return try {
-            val TARGET_SIZE = 640
-            Log.d(TAG, "Starting 640x640 JPEG generation. Input: ${width}x${height}, NV21 size: ${nv21.size}")
+            Log.d(TAG, "Starting ${outputImageResolution}×${outputImageResolution} $outputImageFormat generation. Input: ${width}x${height}, NV21 size: ${nv21.size}")
             
-            // Convert NV21 to RGB byte array directly (640×640)
-            val rgbBytes = ByteArray(TARGET_SIZE * TARGET_SIZE * 3)
+            // Convert NV21 to RGB byte array directly (configurable resolution)
+            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,
-                TARGET_SIZE, TARGET_SIZE,
+                outputImageResolution, outputImageResolution,
                 rgbBytes
             )
             val convertTime = System.currentTimeMillis() - startConvert
             Log.d(TAG, "YUV to RGB conversion completed in ${convertTime}ms. RGB data: ${convertedRgb.size} bytes")
 
-            // Encode RGB to JPEG Base64 with quality 85
-            val startJpeg = System.currentTimeMillis()
-            val base64Result = JpegEncoder.rgbToJpegBase64(convertedRgb, TARGET_SIZE, TARGET_SIZE, quality = 85)
-            val jpegTime = System.currentTimeMillis() - startJpeg
+            // Encode RGB to target format (JPEG, PNG, or BMP) and Base64
+            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
+            )
+            val encodeTime = System.currentTimeMillis() - startEncode
             
             if (base64Result != null) {
-                Log.d(TAG, "JPEG encoding completed in ${jpegTime}ms. Base64 size: ${base64Result.length} bytes")
-                Log.d(TAG, " Generated 640x640 JPEG Base64 for recognition API (total: ${convertTime + jpegTime}ms)")
+                Log.d(TAG, "$outputImageFormat encoding completed in ${encodeTime}ms. Base64 size: ${base64Result.length} bytes")
+                Log.d(TAG, "✅ Generated ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64 for recognition API (total: ${convertTime + encodeTime}ms)")
+                val estSize = estimateImageSize()
+                Log.d(TAG, "Format: $outputImageFormat, Quality: $outputImageQuality, Estimated: ${estSize / 1024}KB")
             } else {
-                Log.w(TAG, " JpegEncoder returned null")
+                Log.w(TAG, "⚠️ ImageFormatEncoder returned null")
             }
             
             base64Result
         } catch (e: Exception) {
-            Log.e(TAG, " Error generating 640x640 JPEG Base64: ${e.message}", e)
+            Log.e(TAG, "❌ Error generating ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64: ${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 {
         var score = 0f
         for (i in 0 until 8) {
@@ -643,5 +754,9 @@ data class AntiSpoofingResult(
     val confidence: Float,
     val label: String,
     val spoofType: String,
-    val recognitionImageBase64: String? = null
+    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)
 )