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

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

@@ -0,0 +1,204 @@
+package com.faceantispoof
+
+import android.graphics.Bitmap
+import android.graphics.Bitmap.CompressFormat
+import android.util.Base64
+import android.util.Log
+import java.io.ByteArrayOutputStream
+
+/**
+ * High-performance JPEG encoder for RGB data.
+ * Converts RGB data to JPEG and encodes as Base64 for network transmission.
+ */
+class JpegEncoder {
+
+    companion object {
+        private const val TAG = "JpegEncoder"
+        private const val DEFAULT_JPEG_QUALITY = 85
+
+        /**
+         * Convert RGB byte array to JPEG and return as Base64 string.
+         * Optimized for high-speed encoding without intermediate Bitmap copies.
+         *
+         * @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
+         * @return Base64 encoded JPEG string, or null if encoding fails
+         */
+        fun rgbToJpegBase64(
+            rgbData: ByteArray,
+            width: Int,
+            height: Int,
+            quality: Int = DEFAULT_JPEG_QUALITY
+        ): String? {
+            return try {
+                val jpegBytes = rgbToJpeg(rgbData, width, height, quality) ?: return null
+                Base64.encodeToString(jpegBytes, Base64.NO_WRAP)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to encode RGB to JPEG Base64", e)
+                null
+            }
+        }
+
+        /**
+         * Convert RGB float array (normalized 0-1) to JPEG and return as Base64 string.
+         * 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 quality JPEG quality (0-100), default 85
+         * @return Base64 encoded JPEG string, or null if encoding fails
+         */
+        fun rgbFloatToJpegBase64(
+            rgbFloats: FloatArray,
+            width: Int,
+            height: Int,
+            quality: Int = DEFAULT_JPEG_QUALITY
+        ): String? {
+            return try {
+                // Convert float array to byte array
+                val rgbBytes = convertFloatArrayToRgbBytes(rgbFloats, width, height)
+                rgbToJpegBase64(rgbBytes, width, height, quality)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to encode RGB float array to JPEG Base64", e)
+                null
+            }
+        }
+
+        /**
+         * Convert RGB byte array to JPEG bytes.
+         *
+         * @param rgbData RGB data as byte array
+         * @param width Image width
+         * @param height Image height
+         * @param quality JPEG quality (0-100)
+         * @return JPEG encoded byte array, or null if encoding fails
+         */
+        fun rgbToJpeg(
+            rgbData: ByteArray,
+            width: Int,
+            height: Int,
+            quality: Int = DEFAULT_JPEG_QUALITY
+        ): ByteArray? {
+            return try {
+                // Create bitmap from RGB data
+                val bitmap = createBitmapFromRgb(rgbData, width, height)
+                val jpegBytes = compressBitmapToJpeg(bitmap, quality)
+                bitmap.recycle()
+                jpegBytes
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to encode RGB to JPEG", e)
+                null
+            }
+        }
+
+        /**
+         * Compress bitmap to JPEG bytes.
+         */
+        private fun compressBitmapToJpeg(bitmap: Bitmap, quality: Int): ByteArray {
+            val stream = ByteArrayOutputStream()
+            bitmap.compress(CompressFormat.JPEG, quality.coerceIn(0, 100), stream)
+            return stream.toByteArray()
+        }
+
+        /**
+         * Create Bitmap from RGB byte array.
+         * Assumes RGB format: RGBRGBRGB...
+         */
+        private fun createBitmapFromRgb(rgbData: ByteArray, width: Int, height: Int): Bitmap {
+            val pixels = IntArray(width * height)
+            var rgbIndex = 0
+
+            for (i in pixels.indices) {
+                val r = rgbData[rgbIndex++].toInt() and 0xFF
+                val g = rgbData[rgbIndex++].toInt() and 0xFF
+                val b = rgbData[rgbIndex++].toInt() and 0xFF
+                pixels[i] = (0xFF shl 24) or (r shl 16) or (g shl 8) or b
+            }
+
+            return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
+        }
+
+        /**
+         * Convert float array (normalized 0-1) to RGB byte array (0-255).
+         */
+        private fun convertFloatArrayToRgbBytes(rgbFloats: FloatArray, width: Int, height: Int): ByteArray {
+            val rgbBytes = ByteArray(width * height * 3)
+            var byteIndex = 0
+
+            for (i in rgbFloats.indices step 3) {
+                rgbBytes[byteIndex++] = (rgbFloats[i] * 255f).toInt().coerceIn(0, 255).toByte()
+                rgbBytes[byteIndex++] = (rgbFloats[i + 1] * 255f).toInt().coerceIn(0, 255).toByte()
+                rgbBytes[byteIndex++] = (rgbFloats[i + 2] * 255f).toInt().coerceIn(0, 255).toByte()
+            }
+
+            return rgbBytes
+        }
+
+        /**
+         * Fast JPEG encoding with minimal memory footprint.
+         * Directly processes YUV data to JPEG without intermediate RGB conversion.
+         * Note: For best performance, use this when you have NV21/I420 data directly.
+         */
+        fun directYuvToJpegBase64(
+            nv21Data: ByteArray,
+            width: Int,
+            height: Int,
+            quality: Int = DEFAULT_JPEG_QUALITY
+        ): String? {
+            return try {
+                // This is a placeholder for direct YUV to JPEG conversion
+                // In production, you might use libjpeg-turbo or native code
+                // For now, convert to RGB first then to JPEG
+                val rgbBytes = ByteArray(width * height * 3)
+                nv21ToRgbDirect(nv21Data, width, height, rgbBytes)
+                rgbToJpegBase64(rgbBytes, width, height, quality)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to encode NV21 to JPEG Base64", e)
+                null
+            }
+        }
+
+        /**
+         * Direct NV21 to RGB conversion (minimal overhead).
+         */
+        private fun nv21ToRgbDirect(nv21: ByteArray, width: Int, height: Int, rgbOut: ByteArray) {
+            val ySize = width * height
+            var rgbIndex = 0
+
+            for (y in 0 until height) {
+                val yRowOffset = y * width
+                for (x in 0 until width) {
+                    val yVal = nv21[yRowOffset + x].toInt() and 0xFF
+                    val uvIndex = ySize + (y / 2) * width + (x / 2) * 2
+                    val vVal = nv21[uvIndex].toInt() and 0xFF
+                    val uVal = nv21[uvIndex + 1].toInt() and 0xFF
+
+                    val yf = yVal.toFloat()
+                    val uf = uVal - 128f
+                    val vf = vVal - 128f
+
+                    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()
+
+                    rgbOut[rgbIndex++] = r
+                    rgbOut[rgbIndex++] = g
+                    rgbOut[rgbIndex++] = b
+                }
+            }
+        }
+
+        /**
+         * Get compressed file size estimate for JPEG.
+         */
+        fun estimateJpegSize(width: Int, height: Int, quality: Int): Int {
+            // Rough estimate: RGB uncompressed size * quality factor
+            val uncompressedSize = width * height * 3
+            val qualityFactor = 100.0 / (100 + (100 - quality))
+            return (uncompressedSize * qualityFactor).toInt()
+        }
+    }
+}

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

@@ -195,4 +195,66 @@ class YuvToFloatArrayConverter {
 
         return output
     }
+
+    /**
+     * Convert NV21 directly to RGB byte array without float conversion.
+     * Optimized for JPEG encoding (where RGB bytes are needed directly).
+     * Output format: RGBRGBRGB... (no alpha channel)
+     *
+     * @param nv21 NV21 encoded YUV data
+     * @param width Original frame width
+     * @param height Original frame height
+     * @param targetWidth Target output width (for resizing)
+     * @param targetHeight Target output height (for resizing)
+     * @param outputRgbBytes Pre-allocated byte array, or null to allocate new
+     * @return Byte array of size [targetHeight * targetWidth * 3] with RGB bytes
+     */
+    fun nv21ToRgbByteArray(
+        nv21: ByteArray,
+        width: Int,
+        height: Int,
+        targetWidth: Int = width,
+        targetHeight: Int = height,
+        outputRgbBytes: ByteArray? = null
+    ): ByteArray {
+        val outputSize = targetWidth * targetHeight * 3
+        val output = outputRgbBytes?.takeIf { it.size >= outputSize } ?: ByteArray(outputSize)
+
+        val ySize = width * height
+        val uvPixelStride = 2
+
+        var outIdx = 0
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * height) / targetHeight
+            val srcRowOffset = srcY * width
+
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * width) / targetWidth
+
+                // Get Y component
+                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
+
+                // Get U and V components (NV21 layout: UV interleaved in second half)
+                val uvIndex = ySize + (srcY / 2) * width + (srcX / 2) * uvPixelStride
+                val vVal = nv21[uvIndex].toInt() and 0xFF
+                val uVal = nv21[uvIndex + 1].toInt() and 0xFF
+
+                // YUV to RGB conversion
+                val yf = yVal.toFloat()
+                val uf = uVal - 128f
+                val vf = vVal - 128f
+
+                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()
+
+                output[outIdx++] = r
+                output[outIdx++] = g
+                output[outIdx++] = b
+            }
+        }
+
+        return output
+    }
 }

package/package.json

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

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 690ms
-    [gap of 22ms]
-  execute-generate-process completed in 713ms
-  [gap of 22ms]
-generate_cxx_metadata completed in 741ms
-

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

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 603ms
-    [gap of 22ms]
-  execute-generate-process completed in 625ms
-  [gap of 18ms]
-generate_cxx_metadata completed in 649ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/x86/generate_cxx_metadata_2399_timing.txt

@@ -1,3 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata 17ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/x86/generate_cxx_metadata_2616_timing.txt

@@ -1,3 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata 19ms
-

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

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 537ms
-    [gap of 20ms]
-  execute-generate-process completed in 558ms
-  [gap of 21ms]
-generate_cxx_metadata completed in 588ms
-

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

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 463ms
-    [gap of 22ms]
-  execute-generate-process completed in 487ms
-  [gap of 17ms]
-generate_cxx_metadata completed in 510ms
-