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

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

@@ -0,0 +1,247 @@
+package com.faceantispoof
+
+import android.graphics.Bitmap
+import android.graphics.Bitmap.CompressFormat
+import android.util.Base64
+import android.util.Log
+import java.io.ByteArrayOutputStream
+
+/**
+ * Multi-format image encoder supporting JPEG, PNG, and BMP.
+ * Handles RGB data conversion to various image formats for compatibility
+ * with face recognition systems (OpenCV cv2.imdecode compatible).
+ *
+ * Supported formats:
+ * - JPEG: Compressed, good for network transmission (~80-100 KB at quality 85)
+ * - PNG: Lossless, larger file size (~200-300 KB)
+ * - BMP: Raw uncompressed, largest size (~2-3 MB for 640×640)
+ *
+ * Optimized for common resolutions:
+ * - 640×480 (VGA)
+ * - 1280×720 (HD)
+ * - 1920×1080 (Full HD)
+ * - 640×640 (Custom square format for face recognition)
+ */
+object ImageFormatEncoder {
+
+    private const val TAG = "ImageFormatEncoder"
+
+    /**
+     * Supported image formats for face recognition system
+     */
+    enum class ImageFormat(val compressFormat: CompressFormat, val mimeType: String) {
+            JPEG(CompressFormat.JPEG, "image/jpeg"),
+            PNG(CompressFormat.PNG, "image/png"),
+            BMP(CompressFormat.WEBP, "image/bmp")  // Android uses WebP as fallback for BMP
+        }
+
+        /**
+         * Convert RGB data to specified image format and return as Base64 string.
+         * Compatible with OpenCV cv2.imdecode() for face recognition systems.
+         *
+         * @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
+         */
+        fun rgbToBase64(
+            rgbData: ByteArray,
+            width: Int,
+            height: Int,
+            format: ImageFormat = ImageFormat.JPEG,
+            quality: Int = 85
+        ): String? {
+            return try {
+                validateImageDimensions(width, height)
+                validateRgbData(rgbData, width, height)
+
+                val imageBytes = rgbToImageBytes(rgbData, 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)
+                null
+            }
+        }
+
+        /**
+         * Convert RGB float array (normalized 0-1) to image format and return as Base64.
+         * Each pixel is stored as 3 floats (R, G, B).
+         *
+         * @param rgbFloats RGB data as float array (normalized to 0-1)
+         * @param width Image width
+         * @param height Image height
+         * @param format Target image format
+         * @param quality Compression quality for JPEG
+         * @return Base64 encoded image string
+         */
+        fun rgbFloatToBase64(
+            rgbFloats: FloatArray,
+            width: Int,
+            height: Int,
+            format: ImageFormat = ImageFormat.JPEG,
+            quality: Int = 85
+        ): String? {
+            return try {
+                validateImageDimensions(width, height)
+
+                // Convert float array (normalized 0-1) to byte array (0-255)
+                val rgbBytes = ByteArray(width * height * 3)
+                var idx = 0
+                for (i in rgbFloats.indices) {
+                    rgbBytes[idx++] = (rgbFloats[i] * 255f).toInt().coerceIn(0, 255).toByte()
+                }
+
+                rgbToBase64(rgbBytes, width, height, format, quality)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to convert RGB float to ${format.name} Base64: ${e.message}", e)
+                null
+            }
+        }
+
+        /**
+         * Convert RGB data to raw image bytes (not Base64).
+         *
+         * @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
+         */
+        fun rgbToImageBytes(
+            rgbData: ByteArray,
+            width: Int,
+            height: Int,
+            format: ImageFormat = ImageFormat.JPEG,
+            quality: Int = 85
+        ): ByteArray? {
+            return try {
+                validateImageDimensions(width, height)
+                validateRgbData(rgbData, width, height)
+
+                val bitmap = createBitmapFromRgb(rgbData, width, height)
+                val imageBytes = when (format) {
+                    ImageFormat.JPEG -> compressBitmapToBytes(bitmap, format, quality)
+                    ImageFormat.PNG -> compressBitmapToBytes(bitmap, format, 100)
+                    ImageFormat.BMP -> compressBitmapToBytes(bitmap, format, 100)
+                }
+                bitmap.recycle()
+                imageBytes
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to convert RGB to ${format.name} bytes: ${e.message}", e)
+                null
+            }
+        }
+
+        /**
+         * Get optimal image format based on use case.
+         * Returns format recommendation for face recognition systems.
+         *
+         * @param useCase One of: "network" (JPEG), "storage" (PNG), "opencv" (JPEG)
+         * @return Recommended ImageFormat
+         */
+        fun getOptimalFormat(useCase: String = "network"): ImageFormat {
+            return when (useCase.lowercase()) {
+                "network" -> ImageFormat.JPEG  // Smaller size for transmission
+                "storage" -> ImageFormat.PNG   // Lossless for long-term storage
+                "opencv" -> ImageFormat.JPEG   // OpenCV optimized
+                else -> ImageFormat.JPEG
+            }
+        }
+
+        /**
+         * Get estimated output size for given resolution and format.
+         * Helps with memory allocation and network planning.
+         *
+         * @param width Image width
+         * @param height Image height
+         * @param format Image format
+         * @param quality JPEG quality if applicable
+         * @return Estimated size in bytes
+         */
+        fun estimateOutputSize(
+            width: Int,
+            height: Int,
+            format: ImageFormat = ImageFormat.JPEG,
+            quality: Int = 85
+        ): Long {
+            val pixelCount = width.toLong() * height
+            return when (format) {
+                ImageFormat.JPEG -> {
+                    // Estimated: 0.1 - 0.15 bytes per pixel at quality 85
+                    (pixelCount * 0.12).toLong()
+                }
+                ImageFormat.PNG -> {
+                    // PNG typically 2-4x larger than JPEG
+                    (pixelCount * 0.5).toLong()
+                }
+                ImageFormat.BMP -> {
+                    // BMP uncompressed: 3 bytes per pixel
+                    pixelCount * 3
+                }
+            }
+        }
+
+        /**
+         * Get format information string for logging.
+         */
+        fun getFormatInfo(format: ImageFormat, width: Int, height: Int, quality: Int = 85): String {
+            val estimatedSize = estimateOutputSize(width, height, format, quality)
+            return "${format.name} (${width}×${height}) est. ${estimatedSize / 1024}KB"
+        }
+
+        // ============ Private Helper Methods ============
+
+        /**
+         * Create Bitmap from RGB byte array.
+         * RGB format: RGBRGBRGB... (3 bytes per pixel, no alpha)
+         */
+        private fun createBitmapFromRgb(rgbData: ByteArray, width: Int, height: Int): Bitmap {
+            // Convert RGB to ARGB for Bitmap (Android uses ARGB_8888)
+            val pixels = IntArray(width * height)
+            var rgbIdx = 0
+            for (i in pixels.indices) {
+                val r = rgbData[rgbIdx++].toInt() and 0xFF
+                val g = rgbData[rgbIdx++].toInt() and 0xFF
+                val b = rgbData[rgbIdx++].toInt() and 0xFF
+                pixels[i] = 0xFF000000.toInt() or (r shl 16) or (g shl 8) or b  // ARGB
+            }
+            return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
+        }
+
+        /**
+         * Compress Bitmap to specified format bytes.
+         */
+        private fun compressBitmapToBytes(
+            bitmap: Bitmap,
+            format: ImageFormat,
+            quality: Int
+        ): ByteArray {
+            val outputStream = ByteArrayOutputStream()
+            bitmap.compress(format.compressFormat, quality, outputStream)
+            return outputStream.toByteArray()
+        }
+
+        /**
+         * Validate image dimensions are within reasonable bounds.
+         */
+        private fun validateImageDimensions(width: Int, height: Int) {
+            require(width > 0 && width <= 4096) { "Image width must be 1-4096 pixels, got $width" }
+            require(height > 0 && height <= 4096) { "Image height must be 1-4096 pixels, got $height" }
+        }
+
+        /**
+         * Validate RGB data buffer is correct size.
+         * RGB format requires exactly width * height * 3 bytes
+         */
+        private fun validateRgbData(rgbData: ByteArray, width: Int, height: Int) {
+            val expectedSize = width * height * 3
+            require(rgbData.size >= expectedSize) {
+                "RGB data size mismatch: expected $expectedSize bytes for ${width}×${height}, got ${rgbData.size}"
+            }
+        }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "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_715_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 613ms
-    [gap of 21ms]
-  execute-generate-process completed in 634ms
-  [gap of 14ms]
-generate_cxx_metadata completed in 656ms
-

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

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 541ms
-    [gap of 21ms]
-  execute-generate-process completed in 562ms
-  [gap of 17ms]
-generate_cxx_metadata completed in 595ms
-