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

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

@@ -1,245 +0,0 @@
-package com.faceantispoof
-
-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 = 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 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,
-            orientation: Int = ExifInterface.ORIENTATION_NORMAL
-        ): String? {
-            return try {
-                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)
-                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 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,
-            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, orientation)
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to encode RGB float array to JPEG Base64", e)
-                null
-            }
-        }
-
-        /**
-         * 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,
-            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()
-                
-                // 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
-            }
-        }
-
-        /**
-         * 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)
-        }
-
-        /**
-         * 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).
-         */
-        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).
-         * FIXED: Now uses corrected YUV to RGB conversion formula.
-         */
-        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
-
-                    // 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()
-
-                    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()
-        }
-    }
-}