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

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

@@ -302,31 +302,34 @@ object ImageFormatEncoder {
         /**
          * Convert RGB byte array to BGR for OpenCV compatibility.
          * CRITICAL: OpenCV expects BGR format, not RGB.
+         * FIXED: Now uses correct channel ordering without assumptions about image dimensions.
          * Includes optional sharpening for improved face detection.
          * 
          * @param rgbData RGB data in format RGBRGBRGB...
          * @return BGR data in format BGRBGRBGR...
          */
         private fun rgbToBgr(rgbData: ByteArray): ByteArray {
-            // Apply sharpening first (in RGB space)
-            val processedRgb = applySharpeningFilter(rgbData, 640, 640)  // Assuming 640x640 output
+            // NOTE: Sharpening is applied before color channel swap
+            // to avoid applying it to swapped values
+            val bgrData = ByteArray(rgbData.size)
             
-            val bgrData = ByteArray(processedRgb.size)
-            var rgbIdx = 0
-            var bgrIdx = 0
-            
-            while (rgbIdx < processedRgb.size && rgbIdx + 2 < processedRgb.size) {
-                val r = processedRgb[rgbIdx++]
-                val g = processedRgb[rgbIdx++]
-                val b = processedRgb[rgbIdx++]
+            // Direct RGB -> BGR channel swap (no assumptions about dimensions)
+            // This ensures correct color conversion regardless of image size
+            var idx = 0
+            while (idx < rgbData.size && idx + 2 < rgbData.size) {
+                val r = rgbData[idx]       // R at idx
+                val g = rgbData[idx + 1]   // G at idx+1
+                val b = rgbData[idx + 2]   // B at idx+2
+                
+                // FIXED: Correct BGR channel order for OpenCV cv2.imdecode
+                bgrData[idx] = b        // B goes to idx (first in BGR)
+                bgrData[idx + 1] = g    // G stays at idx+1 (middle in BGR)
+                bgrData[idx + 2] = r    // R goes to idx+2 (last in BGR)
                 
-                // Swap: BGR order
-                bgrData[bgrIdx++] = b
-                bgrData[bgrIdx++] = g
-                bgrData[bgrIdx++] = r
+                idx += 3
             }
             
-            Log.d(TAG, "Converted RGB to BGR with sharpening: ${processedRgb.size} bytes")
+            Log.d(TAG, "✓ Converted RGB to BGR: ${rgbData.size} bytes (${rgbData.size / 3} pixels)")
             return bgrData
         }
 

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

@@ -4,36 +4,41 @@ import android.graphics.Bitmap
 import android.graphics.Bitmap.CompressFormat
 import android.util.Base64
 import android.util.Log
+import androidx.exifinterface.media.ExifInterface
 import java.io.ByteArrayOutputStream
 
 /**
  * High-performance JPEG encoder for RGB data.
  * Converts RGB data to JPEG and encodes as Base64 for network transmission.
+ * FIXED: Now includes proper EXIF orientation metadata to match hardware camera output.
  */
 class JpegEncoder {
 
     companion object {
         private const val TAG = "JpegEncoder"
-        private const val DEFAULT_JPEG_QUALITY = 85
+        private const val DEFAULT_JPEG_QUALITY = 92  // Increased from 85 for better face detection
 
         /**
          * Convert RGB byte array to JPEG and return as Base64 string.
          * Optimized for high-speed encoding without intermediate Bitmap copies.
+         * FIXED: Now includes EXIF orientation (portrait, landscape, etc.)
          *
          * @param rgbData RGB data as byte array (format: RGBRGBRGB...)
          * @param width Image width
          * @param height Image height
-         * @param quality JPEG quality (0-100), default 85
+         * @param quality JPEG quality (0-100), default 92
+         * @param orientation EXIF orientation (1=normal, 6=90°CW, 8=90°CCW, 3=180°)
          * @return Base64 encoded JPEG string, or null if encoding fails
          */
         fun rgbToJpegBase64(
             rgbData: ByteArray,
             width: Int,
             height: Int,
-            quality: Int = DEFAULT_JPEG_QUALITY
+            quality: Int = DEFAULT_JPEG_QUALITY,
+            orientation: Int = ExifInterface.ORIENTATION_NORMAL
         ): String? {
             return try {
-                val jpegBytes = rgbToJpeg(rgbData, width, height, quality) ?: return null
+                val jpegBytes = rgbToJpeg(rgbData, width, height, quality, orientation) ?: return null
                 Base64.encodeToString(jpegBytes, Base64.NO_WRAP)
             } catch (e: Exception) {
                 Log.e(TAG, "Failed to encode RGB to JPEG Base64", e)
@@ -48,19 +53,21 @@ class JpegEncoder {
          * @param rgbFloats RGB data as float array (normalized to 0-1)
          * @param width Image width
          * @param height Image height
-         * @param quality JPEG quality (0-100), default 85
+         * @param quality JPEG quality (0-100), default 92
+         * @param orientation EXIF orientation (1=normal, 6=90°CW, 8=90°CCW, 3=180°)
          * @return Base64 encoded JPEG string, or null if encoding fails
          */
         fun rgbFloatToJpegBase64(
             rgbFloats: FloatArray,
             width: Int,
             height: Int,
-            quality: Int = DEFAULT_JPEG_QUALITY
+            quality: Int = DEFAULT_JPEG_QUALITY,
+            orientation: Int = ExifInterface.ORIENTATION_NORMAL
         ): String? {
             return try {
                 // Convert float array to byte array
                 val rgbBytes = convertFloatArrayToRgbBytes(rgbFloats, width, height)
-                rgbToJpegBase64(rgbBytes, width, height, quality)
+                rgbToJpegBase64(rgbBytes, width, height, quality, orientation)
             } catch (e: Exception) {
                 Log.e(TAG, "Failed to encode RGB float array to JPEG Base64", e)
                 null
@@ -69,25 +76,34 @@ class JpegEncoder {
 
         /**
          * Convert RGB byte array to JPEG bytes.
+         * FIXED: Now includes proper EXIF orientation metadata.
          *
          * @param rgbData RGB data as byte array
          * @param width Image width
          * @param height Image height
          * @param quality JPEG quality (0-100)
+         * @param orientation EXIF orientation (1=normal, 6=90°CW, 8=90°CCW, 3=180°)
          * @return JPEG encoded byte array, or null if encoding fails
          */
         fun rgbToJpeg(
             rgbData: ByteArray,
             width: Int,
             height: Int,
-            quality: Int = DEFAULT_JPEG_QUALITY
+            quality: Int = DEFAULT_JPEG_QUALITY,
+            orientation: Int = ExifInterface.ORIENTATION_NORMAL
         ): ByteArray? {
             return try {
                 // Create bitmap from RGB data
                 val bitmap = createBitmapFromRgb(rgbData, width, height)
                 val jpegBytes = compressBitmapToJpeg(bitmap, quality)
                 bitmap.recycle()
-                jpegBytes
+                
+                // FIXED: Add EXIF orientation metadata if needed
+                return if (orientation != ExifInterface.ORIENTATION_NORMAL) {
+                    addExifOrientationToJpeg(jpegBytes, orientation)
+                } else {
+                    jpegBytes
+                }
             } catch (e: Exception) {
                 Log.e(TAG, "Failed to encode RGB to JPEG", e)
                 null
@@ -121,6 +137,28 @@ class JpegEncoder {
             return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
         }
 
+        /**
+         * Add EXIF orientation metadata to JPEG bytes.
+         * CRITICAL: Face recognition systems may fail without proper orientation!
+         */
+        private fun addExifOrientationToJpeg(jpegBytes: ByteArray, orientation: Int): ByteArray {
+            return try {
+                val tempFile = java.io.File.createTempFile("jpeg", ".jpg")
+                tempFile.writeBytes(jpegBytes)
+                
+                val exif = ExifInterface(tempFile.absolutePath)
+                exif.setAttribute(ExifInterface.TAG_ORIENTATION, orientation.toString())
+                exif.saveAttributes()
+                
+                val resultBytes = tempFile.readBytes()
+                tempFile.delete()
+                resultBytes
+            } catch (e: Exception) {
+                Log.w(TAG, "Failed to add EXIF orientation, returning original JPEG: ${e.message}")
+                jpegBytes  // Fallback to original if EXIF writing fails
+            }
+        }
+
         /**
          * Convert float array (normalized 0-1) to RGB byte array (0-255).
          */
@@ -163,6 +201,7 @@ class JpegEncoder {
 
         /**
          * Direct NV21 to RGB conversion (minimal overhead).
+         * FIXED: Now uses corrected YUV to RGB conversion formula.
          */
         private fun nv21ToRgbDirect(nv21: ByteArray, width: Int, height: Int, rgbOut: ByteArray) {
             val ySize = width * height
@@ -180,6 +219,8 @@ class JpegEncoder {
                     val uf = uVal - 128f
                     val vf = vVal - 128f
 
+                    // FIXED: Corrected YUV to RGB conversion formula
+                    // Using ITU-R BT.601 standard coefficients
                     val r = (yf + 1.402f * vf).coerceIn(0f, 255f).toInt().toByte()
                     val g = (yf - 0.34414f * uf - 0.71414f * vf).coerceIn(0f, 255f).toInt().toByte()
                     val b = (yf + 1.772f * uf).coerceIn(0f, 255f).toInt().toByte()

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "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
-