react-native-vision-camera-spoof-detector 1.0.6 → 1.0.7

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

@@ -153,6 +153,7 @@ class FaceAntiSpoofFrameProcessor : FrameProcessorPlugin() {
                     "combinedScore" to result.combinedScore.toDouble(),
                     "recognitionImageBase64" to result.recognitionImageBase64,
                     // Image format metadata
+                    // NOTE: Image is in BGR format (OpenCV compatible), encoded as Base64 JPEG
                     "imageFormat" to result.imageFormat,
                     "imageResolution" to result.imageResolution,
                     "imageQuality" to result.imageQuality

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

@@ -412,6 +412,7 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             Log.d(TAG, "YUV to RGB conversion completed in ${convertTime}ms. RGB data: ${convertedRgb.size} bytes")
 
             // Encode RGB to target format (JPEG, PNG, or BMP) and Base64
+            // NOTE: ImageFormatEncoder.rgbToBase64() automatically converts RGB→BGR for OpenCV compatibility
             val startEncode = System.currentTimeMillis()
             val format = when (outputImageFormat) {
                 "PNG" -> ImageFormatEncoder.ImageFormat.PNG
@@ -430,16 +431,16 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             
             if (base64Result != null) {
                 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)")
+                Log.d(TAG, "✅ Generated ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64 for recognition API in BGR format (total: ${convertTime + encodeTime}ms)")
                 val estSize = estimateImageSize()
-                Log.d(TAG, "Format: $outputImageFormat, Quality: $outputImageQuality, Estimated: ${estSize / 1024}KB")
+                Log.d(TAG, "Format: $outputImageFormat (BGR), Quality: $outputImageQuality, Estimated: ${estSize / 1024}KB")
             } else {
-                Log.w(TAG, "⚠️ ImageFormatEncoder returned null")
+                Log.w(TAG, "⚠️ ImageFormatEncoder returned null for BGR conversion")
             }
             
             base64Result
         } catch (e: Exception) {
-            Log.e(TAG, "❌ Error generating ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64: ${e.message}", e)
+            Log.e(TAG, "❌ Error generating ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64 (BGR format): ${e.message}", e)
             e.printStackTrace()
             null
         }

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

@@ -8,9 +8,11 @@ import java.io.ByteArrayOutputStream
 
 /**
  * Multi-format image encoder supporting JPEG, PNG, and BMP.
- * Handles RGB data conversion to various image formats for compatibility
+ * Handles BGR data conversion (OpenCV compatible) to various image formats for compatibility
  * with face recognition systems (OpenCV cv2.imdecode compatible).
  *
+ * NOTE: Converts RGB input to BGR format as required by OpenCV and FastAPI server
+ *
  * Supported formats:
  * - JPEG: Compressed, good for network transmission (~80-100 KB at quality 85)
  * - PNG: Lossless, larger file size (~200-300 KB)
@@ -36,15 +38,17 @@ object ImageFormatEncoder {
         }
 
         /**
-         * Convert RGB data to specified image format and return as Base64 string.
-         * Compatible with OpenCV cv2.imdecode() for face recognition systems.
+         * Convert RGB data to BGR format (OpenCV compatible) and encode to specified image format.
+         * Returns Base64 string compatible with FastAPI server.
+         *
+         * IMPORTANT: This method performs RGB→BGR conversion required by OpenCV cv2.imdecode()
          *
          * @param rgbData RGB data as byte array (format: RGBRGBRGB..., 3 channels)
          * @param width Image width (pixels)
          * @param height Image height (pixels)
          * @param format Target image format (JPEG, PNG, BMP)
          * @param quality Compression quality for JPEG (0-100), ignored for PNG/BMP
-         * @return Base64 encoded image string, or null if encoding fails
+         * @return Base64 encoded image string in BGR color space, or null if encoding fails
          */
         fun rgbToBase64(
             rgbData: ByteArray,
@@ -57,18 +61,22 @@ object ImageFormatEncoder {
                 validateImageDimensions(width, height)
                 validateRgbData(rgbData, width, height)
 
-                val imageBytes = rgbToImageBytes(rgbData, width, height, format, quality)
+                // CRITICAL: Convert RGB to BGR for OpenCV compatibility
+                val bgrData = rgbToBgr(rgbData)
+
+                val imageBytes = bgrToImageBytes(bgrData, width, height, format, quality)
                     ?: return null
 
                 Base64.encodeToString(imageBytes, Base64.NO_WRAP)
             } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert RGB to ${format.name} Base64: ${e.message}", e)
+                Log.e(TAG, "Failed to convert RGB to BGR ${format.name} Base64: ${e.message}", e)
                 null
             }
         }
 
         /**
          * Convert RGB float array (normalized 0-1) to image format and return as Base64.
+         * Performs RGB→BGR conversion for OpenCV compatibility.
          * Each pixel is stored as 3 floats (R, G, B).
          *
          * @param rgbFloats RGB data as float array (normalized to 0-1)
@@ -76,7 +84,7 @@ object ImageFormatEncoder {
          * @param height Image height
          * @param format Target image format
          * @param quality Compression quality for JPEG
-         * @return Base64 encoded image string
+         * @return Base64 encoded image string in BGR format
          */
         fun rgbFloatToBase64(
             rgbFloats: FloatArray,
@@ -113,20 +121,21 @@ object ImageFormatEncoder {
 
                 rgbToBase64(rgbBytes, width, height, format, quality)
             } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert RGB float to ${format.name} Base64: ${e.message}", e)
+                Log.e(TAG, "Failed to convert RGB float to BGR ${format.name} Base64: ${e.message}", e)
                 null
             }
         }
 
         /**
          * Convert RGB data to raw image bytes (not Base64).
+         * Performs RGB→BGR conversion for OpenCV compatibility.
          *
          * @param rgbData RGB data as byte array
          * @param width Image width
          * @param height Image height
          * @param format Target image format
          * @param quality Compression quality for JPEG
-         * @return Raw image bytes, or null if encoding fails
+         * @return Raw image bytes in BGR format, or null if encoding fails
          */
         fun rgbToImageBytes(
             rgbData: ByteArray,
@@ -139,29 +148,12 @@ object ImageFormatEncoder {
                 validateImageDimensions(width, height)
                 validateRgbData(rgbData, width, height)
 
-                val bitmap = createBitmapFromRgb(rgbData, width, height)
-                    ?: return null
-                    
-                val imageBytes = try {
-                    when (format) {
-                        ImageFormat.JPEG -> compressBitmapToBytes(bitmap, format, quality)
-                        ImageFormat.PNG -> compressBitmapToBytes(bitmap, format, 100)
-                        ImageFormat.BMP -> compressBitmapToBytes(bitmap, format, 100)
-                    }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error compressing bitmap: ${e.message}", e)
-                    null
-                } finally {
-                    try {
-                        bitmap.recycle()
-                    } catch (e: Exception) {
-                        Log.w(TAG, "Error recycling bitmap: ${e.message}")
-                    }
-                }
-                
-                imageBytes
+                // CRITICAL: Convert RGB to BGR for OpenCV compatibility
+                val bgrData = rgbToBgr(rgbData)
+
+                bgrToImageBytes(bgrData, width, height, format, quality)
             } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert RGB to ${format.name} bytes: ${e.message}", e)
+                Log.e(TAG, "Failed to convert RGB to BGR ${format.name} bytes: ${e.message}", e)
                 null
             }
         }
@@ -226,13 +218,93 @@ object ImageFormatEncoder {
         // ============ Private Helper Methods ============
 
         /**
-         * Create Bitmap from RGB byte array.
-         * RGB format: RGBRGBRGB... (3 bytes per pixel, no alpha)
+         * Convert RGB byte array to BGR for OpenCV compatibility.
+         * CRITICAL: OpenCV expects BGR format, not RGB.
+         * 
+         * @param rgbData RGB data in format RGBRGBRGB...
+         * @return BGR data in format BGRBGRBGR...
          */
-        private fun createBitmapFromRgb(rgbData: ByteArray, width: Int, height: Int): Bitmap? {
+        private fun rgbToBgr(rgbData: ByteArray): ByteArray {
+            val bgrData = ByteArray(rgbData.size)
+            var rgbIdx = 0
+            var bgrIdx = 0
+            
+            while (rgbIdx < rgbData.size && rgbIdx + 2 < rgbData.size) {
+                val r = rgbData[rgbIdx++]
+                val g = rgbData[rgbIdx++]
+                val b = rgbData[rgbIdx++]
+                
+                // Swap: BGR order
+                bgrData[bgrIdx++] = b
+                bgrData[bgrIdx++] = g
+                bgrData[bgrIdx++] = r
+            }
+            
+            Log.d(TAG, "Converted RGB to BGR: ${rgbData.size} bytes")
+            return bgrData
+        }
+
+        /**
+         * Convert BGR data to raw image bytes (not Base64).
+         * BGR data is already in OpenCV format.
+         *
+         * @param bgrData BGR data as byte array (already in OpenCV format)
+         * @param width Image width
+         * @param height Image height
+         * @param format Target image format
+         * @param quality Compression quality for JPEG
+         * @return Raw image bytes, or null if encoding fails
+         */
+        private fun bgrToImageBytes(
+            bgrData: ByteArray,
+            width: Int,
+            height: Int,
+            format: ImageFormat = ImageFormat.JPEG,
+            quality: Int = 85
+        ): ByteArray? {
             return try {
-                if (rgbData.isEmpty()) {
-                    Log.e(TAG, "RGB data is empty")
+                validateImageDimensions(width, height)
+                
+                if (bgrData.size < width * height * 3) {
+                    Log.e(TAG, "BGR data too small: expected ${width * height * 3}, got ${bgrData.size}")
+                    return null
+                }
+
+                val bitmap = createBitmapFromBgr(bgrData, width, height)
+                    ?: return null
+                    
+                val imageBytes = try {
+                    when (format) {
+                        ImageFormat.JPEG -> compressBitmapToBytes(bitmap, format, quality)
+                        ImageFormat.PNG -> compressBitmapToBytes(bitmap, format, 100)
+                        ImageFormat.BMP -> compressBitmapToBytes(bitmap, format, 100)
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error compressing bitmap: ${e.message}", e)
+                    null
+                } finally {
+                    try {
+                        bitmap.recycle()
+                    } catch (e: Exception) {
+                        Log.w(TAG, "Error recycling bitmap: ${e.message}")
+                    }
+                }
+                
+                imageBytes
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to convert BGR to ${format.name} bytes: ${e.message}", e)
+                null
+            }
+        }
+
+        /**
+         * Create Bitmap from BGR byte array (OpenCV format).
+         * BGR format: BGRBGRBGR... (3 bytes per pixel, no alpha)
+         */
+        private fun createBitmapFromBgr(bgrData: ByteArray, width: Int, height: Int): Bitmap? {
+            return try {
+                if (bgrData.isEmpty()) {
+                    Log.e(TAG, "BGR data is empty")
                     return null
                 }
                 if (width <= 0 || height <= 0) {
@@ -241,31 +313,64 @@ object ImageFormatEncoder {
                 }
                 
                 val expectedSize = width * height * 3
-                if (rgbData.size < expectedSize) {
-                    Log.e(TAG, "RGB data too small: expected at least $expectedSize, got ${rgbData.size}")
+                if (bgrData.size < expectedSize) {
+                    Log.e(TAG, "BGR data too small: expected at least $expectedSize, got ${bgrData.size}")
                     return null
                 }
                 
-                // Convert RGB to ARGB for Bitmap (Android uses ARGB_8888)
+                // Convert BGR to ARGB for Bitmap (Android uses ARGB_8888)
+                // BGR order: B, G, R
                 val pixels = IntArray(width * height)
-                var rgbIdx = 0
+                var bgrIdx = 0
                 for (i in pixels.indices) {
-                    if (rgbIdx + 2 >= rgbData.size) {
-                        Log.e(TAG, "RGB buffer index out of bounds at pixel $i")
+                    if (bgrIdx + 2 >= bgrData.size) {
+                        Log.e(TAG, "BGR buffer index out of bounds at pixel $i")
                         return null
                     }
-                    val r = rgbData[rgbIdx++].toInt() and 0xFF
-                    val g = rgbData[rgbIdx++].toInt() and 0xFF
-                    val b = rgbData[rgbIdx++].toInt() and 0xFF
+                    val b = bgrData[bgrIdx++].toInt() and 0xFF
+                    val g = bgrData[bgrIdx++].toInt() and 0xFF
+                    val r = bgrData[bgrIdx++].toInt() and 0xFF
                     pixels[i] = 0xFF000000.toInt() or (r shl 16) or (g shl 8) or b  // ARGB
                 }
                 
                 val bitmap = Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
                 if (bitmap == null) {
-                    Log.e(TAG, "Failed to create bitmap")
+                    Log.e(TAG, "Failed to create bitmap from BGR")
                     return null
                 }
                 bitmap
+            } catch (e: Exception) {
+                Log.e(TAG, "Error creating bitmap from BGR: ${e.message}", e)
+                null
+            }
+        }
+
+        /**
+         * Create Bitmap from RGB byte array.
+         * RGB format: RGBRGBRGB... (3 bytes per pixel, no alpha)
+         * DEPRECATED: Use createBitmapFromBgr instead for OpenCV compatibility
+         */
+        @Deprecated("Use createBitmapFromBgr for OpenCV compatibility")
+        private fun createBitmapFromRgb(rgbData: ByteArray, width: Int, height: Int): Bitmap? {
+            return try {
+                if (rgbData.isEmpty()) {
+                    Log.e(TAG, "RGB data is empty")
+                    return null
+                }
+                if (width <= 0 || height <= 0) {
+                    Log.e(TAG, "Invalid dimensions: width=$width, height=$height")
+                    return null
+                }
+                
+                val expectedSize = width * height * 3
+                if (rgbData.size < expectedSize) {
+                    Log.e(TAG, "RGB data too small: expected at least $expectedSize, got ${rgbData.size}")
+                    return null
+                }
+                
+                // Convert RGB to BGR first, then to ARGB for Bitmap
+                val bgrData = rgbToBgr(rgbData)
+                createBitmapFromBgr(bgrData, width, height)
             } catch (e: Exception) {
                 Log.e(TAG, "Error creating bitmap from RGB: ${e.message}", e)
                 null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "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": {
@@ -10,10 +10,10 @@
   "bugs": {
     "url": "https://github.com/jescon-tech/react-native-vision-camera-spoof-detector/issues"
   },
-  "license": "MIT",
+  "license": "JESCON TECHNOLOGIES PVT LTD",
   "author": {
     "name": "PRAFULDAS M M",
-    "company": "JESCON TECHNOLOGIES PVT LTD",
+    "company": "JESCON TECHNOLOGIES PVT LTD THRISSUR, KERALA, INDIA",
     "email": "jescontechnologies@gmail.com"
   },
   "main": "index.js",

package/android/build/intermediates/cxx/Debug/2a1it684/logs/arm64-v8a/generate_cxx_metadata_2688_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 829ms
-    [gap of 35ms]
-  execute-generate-process completed in 865ms
-  [gap of 16ms]
-generate_cxx_metadata completed in 887ms
-

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

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 557ms
-    [gap of 40ms]
-  execute-generate-process completed in 598ms
-  [gap of 15ms]
-generate_cxx_metadata completed in 619ms
-