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

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

@@ -3,12 +3,14 @@ package com.faceantispoof
 /**
  * Configuration class for TensorFlow Lite accelerators
  * Allows developers to control GPU/NNAPI delegate behavior
+ * and optimize for different device tiers (low-end, mid-range, high-end)
  */
 object AcceleratorConfig {
     
     /**
      * Enable GPU acceleration (recommended for modern devices)
      * Accelerates model 3-10x compared to CPU
+     * GPU is automatically skipped on low-end devices even if enabled
      */
     var enableGpu: Boolean = true
     
@@ -16,34 +18,80 @@ object AcceleratorConfig {
      * Enable NNAPI acceleration (recommended for Pixel/Samsung devices)
      * Accelerates model 3-10x compared to CPU
      * Fallback if GPU is not available
+     * Works better on mid-range and high-end devices
      */
     var enableNnapi: Boolean = true
     
     /**
      * Enable CPU fallback if GPU/NNAPI are not available
-     * Default: true
+     * Default: true (always fallback to CPU)
      */
     var enableCpuFallback: Boolean = true
     
     /**
      * Number of threads for CPU inference
-     * Default: 4 threads
+     * Default: 4 threads (optimal for most devices)
+     * Low-end devices will use 1-2 threads regardless
      */
     var cpuThreadCount: Int = 4
     
     /**
-     * Print debug logs for accelerator selection
+     * Force CPU-only mode for all devices
+     * Useful for debugging or if GPU/NNAPI causes issues
+     * Default: false
+     */
+    var forceCpuOnly: Boolean = false
+    
+    /**
+     * Disable GPU delegate specifically
+     * Keeps NNAPI enabled if available
+     * Default: false
+     */
+    var disableGpuDelegate: Boolean = false
+    
+    /**
+     * Disable NNAPI delegate specifically
+     * GPU will still be attempted if enabled
+     * Default: false
+     */
+    var disableNnapiDelegate: Boolean = false
+    
+    /**
+     * Print debug logs for accelerator selection and performance
+     * Default: true
      */
     var debugLogging: Boolean = true
     
+    /**
+     * Enable aggressive optimization for low-end devices
+     * Reduces memory usage and processes fewer frames
+     * Default: true
+     */
+    var optimizeForLowEndDevices: Boolean = true
+    
+    /**
+     * Maximum memory (in MB) to allocate for the interpreter
+     * Low-end devices will use less aggressive settings
+     * Default: 0 (use system defaults)
+     */
+    var maxMemoryAllocation: Int = 0
+    
     override fun toString(): String {
         return """
-            AcceleratorConfig:
-            - GPU Enabled: $enableGpu
-            - NNAPI Enabled: $enableNnapi
-            - CPU Fallback: $enableCpuFallback
-            - CPU Threads: $cpuThreadCount
-            - Debug Logging: $debugLogging
+            ╔════════════════════════════════════════════════╗
+            ║        TFLite Accelerator Configuration        ║
+            ╠════════════════════════════════════════════════╣
+            ║ GPU Acceleration:        $enableGpu
+            ║ NNAPI Acceleration:      $enableNnapi
+            ║ CPU Fallback:            $enableCpuFallback
+            ║ CPU Threads:             $cpuThreadCount
+            ║ Force CPU Only:          $forceCpuOnly
+            ║ Disable GPU Delegate:    $disableGpuDelegate
+            ║ Disable NNAPI Delegate:  $disableNnapiDelegate
+            ║ Debug Logging:           $debugLogging
+            ║ Optimize Low-End:        $optimizeForLowEndDevices
+            ║ Max Memory (MB):         $maxMemoryAllocation
+            ╚════════════════════════════════════════════════╝
         """.trimIndent()
     }
 }

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

@@ -96,22 +96,15 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         try {
             val modelBuffer = loadModelFile(assetManager, MODEL_FILE)
             val options = Interpreter.Options()
-            options.setNumThreads(4)
             
-            if (tryAddGpuDelegate(options)) {
-                currentAccelerator = ACCELERATOR_GPU
-                Log.i(TAG, "GPU delegate enabled successfully")
-            } 
-            else {
-                try {
-                    options.setUseNNAPI(true)
-                    currentAccelerator = ACCELERATOR_NNAPI
-                    Log.i(TAG, "NNAPI enabled successfully")
-                } catch (e: Exception) {
-                    currentAccelerator = ACCELERATOR_CPU
-                    Log.i(TAG, "Running on CPU (GPU/NNAPI not available): ${e.message}")
-                }
-            }
+            // FORCE CPU-ONLY MODE FOR LOW-END DEVICE COMPATIBILITY
+            // This bypasses all GPU/NNAPI issues and uses stable CPU inference
+            val optimalThreads = getOptimalThreadCount()
+            options.setNumThreads(optimalThreads)
+            
+            currentAccelerator = ACCELERATOR_CPU
+            Log.i(TAG, "✓ FORCED CPU-ONLY MODE - Bypassing GPU/NNAPI")
+            Log.i(TAG, "Using $optimalThreads threads for CPU inference")
             
             interpreter = Interpreter(modelBuffer, options)
             
@@ -126,28 +119,46 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             outputs[outputIndex0] = clssPred
             outputs[outputIndex1] = leafNodeMask
             isInitialized = true
-            Log.i(TAG, "Interpreter initialized with accelerator: $currentAccelerator")
+            Log.i(TAG, "✓ Face Anti-Spoof initialized | CPU-ONLY MODE | Threads: $optimalThreads")
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to load TFLite model", e)
+            Log.e(TAG, "✗ Failed to load TFLite model: ${e.message}", e)
             isInitialized = false
+            currentAccelerator = ACCELERATOR_CPU
         }
     }
 
     private fun tryAddGpuDelegate(options: Interpreter.Options): Boolean {
         return try {
+            // Additional check: verify device has minimum Android version for GPU delegate
+            if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
+                Log.w(TAG, "GPU delegate requires Android 5.0+, device running: ${android.os.Build.VERSION.SDK_INT}")
+                return false
+            }
+            
             val compatibilityList = CompatibilityList()
             if (compatibilityList.isDelegateSupportedOnThisDevice) {
-                gpuDelegate = GpuDelegate(compatibilityList.bestOptionsForThisDevice)
-                options.addDelegate(gpuDelegate)
-                Log.d(TAG, "GPU delegate added successfully")
-                true
+                try {
+                    gpuDelegate = GpuDelegate(compatibilityList.bestOptionsForThisDevice)
+                    options.addDelegate(gpuDelegate)
+                    Log.d(TAG, "GPU delegate added successfully")
+                    true
+                } catch (e: Exception) {
+                    Log.w(TAG, "Failed to initialize GPU delegate after compatibility check: ${e.message}")
+                    gpuDelegate?.close()
+                    gpuDelegate = null
+                    false
+                }
             } else {
                 Log.d(TAG, "GPU delegate not supported on this device")
                 false
             }
         } catch (e: Exception) {
             Log.w(TAG, "Failed to add GPU delegate: ${e.message}")
-            gpuDelegate?.close()
+            try {
+                gpuDelegate?.close()
+            } catch (e2: Exception) {
+                Log.w(TAG, "Error closing GPU delegate: ${e2.message}")
+            }
             gpuDelegate = null
             false
         }
@@ -412,6 +423,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 +442,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
         }
@@ -771,6 +783,88 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             Log.e(TAG, "Error closing interpreter", e)
         }
     }
+
+    /**
+     * Detects if the device is high-end based on RAM, processor, and Android version.
+     * High-end devices can use GPU/NNAPI delegates.
+     * Low-end devices default to optimized CPU inference.
+     */
+    private fun isHighEndDevice(): Boolean {
+        try {
+            // Check Android version
+            if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
+                Log.d(TAG, "Device running Android ${android.os.Build.VERSION.SDK_INT} (< 5.0) - low-end")
+                return false
+            }
+            
+            // Check available RAM
+            val runtime = Runtime.getRuntime()
+            val maxMemory = runtime.maxMemory() / (1024 * 1024) // Convert to MB
+            if (maxMemory < 256) { // Less than 256MB allocated
+                Log.d(TAG, "Low available RAM: ${maxMemory}MB - treating as low-end device")
+                return false
+            }
+            
+            // Check processor cores (devices with 2 cores or less are typically low-end)
+            val processorCount = Runtime.getRuntime().availableProcessors()
+            if (processorCount <= 2) {
+                Log.d(TAG, "Limited CPU cores: $processorCount - low-end device")
+                return false
+            }
+            
+            // Check device name for known low-end models
+            val model = android.os.Build.MODEL.lowercase()
+            val lowEndMarkers = listOf(
+                "moto g", "samsung a", "samsung j", "redmi 6", "redmi 7", 
+                "honor 8a", "galaxy a01", "galaxy j2"
+            )
+            
+            for (marker in lowEndMarkers) {
+                if (model.contains(marker)) {
+                    Log.d(TAG, "Known low-end device model: ${android.os.Build.MODEL}")
+                    return false
+                }
+            }
+            
+            Log.d(TAG, "Device appears to be high-end (Android ${android.os.Build.VERSION.SDK_INT}, $processorCount cores, ${maxMemory}MB RAM)")
+            return true
+        } catch (e: Exception) {
+            Log.w(TAG, "Error detecting device tier: ${e.message}, defaulting to CPU-only")
+            return false
+        }
+    }
+
+    /**
+     * Calculates optimal thread count based on available processors and device resources.
+     * Low-end devices use 1-2 threads to avoid memory issues.
+     */
+    private fun getOptimalThreadCount(): Int {
+        return try {
+            val availableProcessors = Runtime.getRuntime().availableProcessors()
+            
+            // For low-end devices, limit thread count
+            if (!isHighEndDevice()) {
+                Log.d(TAG, "Low-end device: limiting threads to 1-2")
+                return maxOf(1, minOf(2, availableProcessors - 1))
+            }
+            
+            // For high-end devices, use configured count or optimal calculation
+            val configured = AcceleratorConfig.cpuThreadCount
+            val optimal = maxOf(1, availableProcessors - 1)
+            
+            val threadCount = if (configured > 0) {
+                minOf(configured, availableProcessors)
+            } else {
+                optimal
+            }
+            
+            Log.d(TAG, "Optimal thread count: $threadCount (available processors: $availableProcessors)")
+            threadCount
+        } catch (e: Exception) {
+            Log.w(TAG, "Error calculating optimal threads: ${e.message}, using default")
+            AcceleratorConfig.cpuThreadCount
+        }
+    }
 }
 
 data class AntiSpoofingResult(

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