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

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

@@ -88,11 +88,27 @@ object ImageFormatEncoder {
             return try {
                 validateImageDimensions(width, height)
 
+                if (rgbFloats.isEmpty()) {
+                    Log.e(TAG, "RGB float array is empty")
+                    return null
+                }
+
+                val expectedSize = width * height * 3
+                if (rgbFloats.size < expectedSize) {
+                    Log.e(TAG, "RGB float array too small: expected $expectedSize, got ${rgbFloats.size}")
+                    return null
+                }
+
                 // Convert float array (normalized 0-1) to byte array (0-255)
-                val rgbBytes = ByteArray(width * height * 3)
+                val rgbBytes = ByteArray(expectedSize)
                 var idx = 0
-                for (i in rgbFloats.indices) {
-                    rgbBytes[idx++] = (rgbFloats[i] * 255f).toInt().coerceIn(0, 255).toByte()
+                for (i in 0 until expectedSize) {
+                    if (idx >= rgbFloats.size) {
+                        Log.e(TAG, "Float array index out of bounds at $idx")
+                        return null
+                    }
+                    val floatVal = rgbFloats[idx++].coerceIn(0f, 1f)
+                    rgbBytes[i] = (floatVal * 255f).toInt().coerceIn(0, 255).toByte()
                 }
 
                 rgbToBase64(rgbBytes, width, height, format, quality)
@@ -124,12 +140,25 @@ object ImageFormatEncoder {
                 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)
+                    ?: 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}")
+                    }
                 }
-                bitmap.recycle()
+                
                 imageBytes
             } catch (e: Exception) {
                 Log.e(TAG, "Failed to convert RGB to ${format.name} bytes: ${e.message}", e)
@@ -200,17 +229,47 @@ object ImageFormatEncoder {
          * 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
+        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 ARGB for Bitmap (Android uses ARGB_8888)
+                val pixels = IntArray(width * height)
+                var rgbIdx = 0
+                for (i in pixels.indices) {
+                    if (rgbIdx + 2 >= rgbData.size) {
+                        Log.e(TAG, "RGB 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
+                    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")
+                    return null
+                }
+                bitmap
+            } catch (e: Exception) {
+                Log.e(TAG, "Error creating bitmap from RGB: ${e.message}", e)
+                null
             }
-            return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
         }
 
         /**
@@ -221,9 +280,28 @@ object ImageFormatEncoder {
             format: ImageFormat,
             quality: Int
         ): ByteArray {
-            val outputStream = ByteArrayOutputStream()
-            bitmap.compress(format.compressFormat, quality, outputStream)
-            return outputStream.toByteArray()
+            return try {
+                if (bitmap.width <= 0 || bitmap.height <= 0) {
+                    throw IllegalArgumentException("Invalid bitmap dimensions: ${bitmap.width}×${bitmap.height}")
+                }
+                
+                val outputStream = ByteArrayOutputStream()
+                val compressed = bitmap.compress(format.compressFormat, quality, outputStream)
+                
+                if (!compressed) {
+                    Log.w(TAG, "Bitmap compression returned false for ${format.name}")
+                }
+                
+                val bytes = outputStream.toByteArray()
+                if (bytes.isEmpty()) {
+                    Log.w(TAG, "Compressed image bytes are empty")
+                }
+                
+                bytes
+            } catch (e: Exception) {
+                Log.e(TAG, "Error compressing bitmap: ${e.message}", e)
+                ByteArray(0)
+            }
         }
 
         /**

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

@@ -27,28 +27,55 @@ class YuvToFloatArrayConverter {
         targetHeight: Int = height,
         outputRgbFloat: FloatArray? = null
     ): FloatArray {
+        if (nv21.isEmpty()) {
+            throw IllegalArgumentException("NV21 array is empty")
+        }
+        if (width <= 0 || height <= 0) {
+            throw IllegalArgumentException("Invalid frame dimensions: width=$width, height=$height")
+        }
+        if (targetWidth <= 0 || targetHeight <= 0) {
+            throw IllegalArgumentException("Invalid target dimensions: targetWidth=$targetWidth, targetHeight=$targetHeight")
+        }
+        
         val outputSize = targetWidth * targetHeight * 3
         val output = outputRgbFloat?.takeIf { it.size >= outputSize } ?: FloatArray(outputSize)
 
         val ySize = width * height
         val uvPixelStride = 2
+        
+        // Validate NV21 buffer size
+        val minExpectedSize = width * height + (width * height) / 2
+        if (nv21.size < minExpectedSize) {
+            throw IllegalArgumentException("NV21 buffer too small: expected at least $minExpectedSize, got ${nv21.size}")
+        }
 
         var outIdx = 0
 
         for (targetY in 0 until targetHeight) {
-            // Map target Y to original frame Y (nearest-neighbor)
             val srcY = (targetY * height) / targetHeight
+            if (srcY >= height) {
+                throw IndexOutOfBoundsException("Source Y index out of bounds: srcY=$srcY, height=$height")
+            }
             val srcRowOffset = srcY * width
 
             for (targetX in 0 until targetWidth) {
-                // Map target X to original frame X (nearest-neighbor)
                 val srcX = (targetX * width) / targetWidth
+                if (srcX >= width) {
+                    throw IndexOutOfBoundsException("Source X index out of bounds: srcX=$srcX, width=$width")
+                }
 
                 // Get Y component
-                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
+                val yIdx = srcRowOffset + srcX
+                if (yIdx >= nv21.size) {
+                    throw IndexOutOfBoundsException("Y index out of bounds: yIdx=$yIdx, nv21.size=${nv21.size}")
+                }
+                val yVal = nv21[yIdx].toInt() and 0xFF
 
                 // Get U and V components (NV21 layout: UV interleaved in second half)
                 val uvIndex = ySize + (srcY / 2) * width + (srcX / 2) * uvPixelStride
+                if (uvIndex + 1 >= nv21.size) {
+                    throw IndexOutOfBoundsException("UV index out of bounds: uvIndex=$uvIndex, nv21.size=${nv21.size}")
+                }
                 val vVal = nv21[uvIndex].toInt() and 0xFF
                 val uVal = nv21[uvIndex + 1].toInt() and 0xFF
 
@@ -62,9 +89,13 @@ class YuvToFloatArrayConverter {
                 val b = (yf + 1.772f * uf).coerceIn(0f, 255f)
 
                 // Normalize to [0, 1]
-                output[outIdx++] = r / 255f
-                output[outIdx++] = g / 255f
-                output[outIdx++] = b / 255f
+                if (outIdx + 2 < output.size) {
+                    output[outIdx++] = r / 255f
+                    output[outIdx++] = g / 255f
+                    output[outIdx++] = b / 255f
+                } else {
+                    throw IndexOutOfBoundsException("Output array index out of bounds: outIdx=$outIdx, output.size=${output.size}")
+                }
             }
         }
 
@@ -176,20 +207,48 @@ class YuvToFloatArrayConverter {
         targetHeight: Int = height,
         outputGrayscale: IntArray? = null
     ): IntArray {
+        if (nv21.isEmpty()) {
+            throw IllegalArgumentException("NV21 array is empty")
+        }
+        if (width <= 0 || height <= 0) {
+            throw IllegalArgumentException("Invalid frame dimensions: width=$width, height=$height")
+        }
+        if (targetWidth <= 0 || targetHeight <= 0) {
+            throw IllegalArgumentException("Invalid target dimensions: targetWidth=$targetWidth, targetHeight=$targetHeight")
+        }
+        
         val outputSize = targetWidth * targetHeight
         val output = outputGrayscale?.takeIf { it.size >= outputSize } ?: IntArray(outputSize)
 
         val ySize = width * height
+        val minExpectedSize = width * height + (width * height) / 2
+        if (nv21.size < minExpectedSize) {
+            throw IllegalArgumentException("NV21 buffer too small: expected at least $minExpectedSize, got ${nv21.size}")
+        }
 
         var outIdx = 0
         for (targetY in 0 until targetHeight) {
             val srcY = (targetY * height) / targetHeight
+            if (srcY >= height) {
+                throw IndexOutOfBoundsException("Source Y out of bounds: srcY=$srcY, height=$height")
+            }
             val srcRowOffset = srcY * width
 
             for (targetX in 0 until targetWidth) {
                 val srcX = (targetX * width) / targetWidth
-                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
-                output[outIdx++] = yVal
+                if (srcX >= width) {
+                    throw IndexOutOfBoundsException("Source X out of bounds: srcX=$srcX, width=$width")
+                }
+                val yIdx = srcRowOffset + srcX
+                if (yIdx >= nv21.size) {
+                    throw IndexOutOfBoundsException("Y index out of bounds: yIdx=$yIdx, nv21.size=${nv21.size}")
+                }
+                val yVal = nv21[yIdx].toInt() and 0xFF
+                if (outIdx < output.size) {
+                    output[outIdx++] = yVal
+                } else {
+                    throw IndexOutOfBoundsException("Output index out of bounds: outIdx=$outIdx, output.size=${output.size}")
+                }
             }
         }
 
@@ -217,26 +276,54 @@ class YuvToFloatArrayConverter {
         targetHeight: Int = height,
         outputRgbBytes: ByteArray? = null
     ): ByteArray {
+        if (nv21.isEmpty()) {
+            throw IllegalArgumentException("NV21 array is empty")
+        }
+        if (width <= 0 || height <= 0) {
+            throw IllegalArgumentException("Invalid frame dimensions: width=$width, height=$height")
+        }
+        if (targetWidth <= 0 || targetHeight <= 0) {
+            throw IllegalArgumentException("Invalid target dimensions: targetWidth=$targetWidth, targetHeight=$targetHeight")
+        }
+        
         val outputSize = targetWidth * targetHeight * 3
         val output = outputRgbBytes?.takeIf { it.size >= outputSize } ?: ByteArray(outputSize)
 
         val ySize = width * height
         val uvPixelStride = 2
+        
+        val minExpectedSize = width * height + (width * height) / 2
+        if (nv21.size < minExpectedSize) {
+            throw IllegalArgumentException("NV21 buffer too small: expected at least $minExpectedSize, got ${nv21.size}")
+        }
 
         var outIdx = 0
 
         for (targetY in 0 until targetHeight) {
             val srcY = (targetY * height) / targetHeight
+            if (srcY >= height) {
+                throw IndexOutOfBoundsException("Source Y out of bounds: srcY=$srcY, height=$height")
+            }
             val srcRowOffset = srcY * width
 
             for (targetX in 0 until targetWidth) {
                 val srcX = (targetX * width) / targetWidth
+                if (srcX >= width) {
+                    throw IndexOutOfBoundsException("Source X out of bounds: srcX=$srcX, width=$width")
+                }
 
                 // Get Y component
-                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
+                val yIdx = srcRowOffset + srcX
+                if (yIdx >= nv21.size) {
+                    throw IndexOutOfBoundsException("Y index out of bounds: yIdx=$yIdx, nv21.size=${nv21.size}")
+                }
+                val yVal = nv21[yIdx].toInt() and 0xFF
 
                 // Get U and V components (NV21 layout: UV interleaved in second half)
                 val uvIndex = ySize + (srcY / 2) * width + (srcX / 2) * uvPixelStride
+                if (uvIndex + 1 >= nv21.size) {
+                    throw IndexOutOfBoundsException("UV index out of bounds: uvIndex=$uvIndex, nv21.size=${nv21.size}")
+                }
                 val vVal = nv21[uvIndex].toInt() and 0xFF
                 val uVal = nv21[uvIndex + 1].toInt() and 0xFF
 
@@ -249,9 +336,13 @@ class YuvToFloatArrayConverter {
                 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
+                if (outIdx + 2 < output.size) {
+                    output[outIdx++] = r
+                    output[outIdx++] = g
+                    output[outIdx++] = b
+                } else {
+                    throw IndexOutOfBoundsException("Output index out of bounds: outIdx=$outIdx, output.size=${output.size}")
+                }
             }
         }
 

package/package.json

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

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

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 962ms
-    [gap of 23ms]
-  execute-generate-process completed in 986ms
-  [gap of 17ms]
-generate_cxx_metadata completed in 1012ms
-

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

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