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

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

@@ -0,0 +1,68 @@
+package com.faceantispoof
+
+import android.util.Log
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * Buffer pool manager for efficient reuse of large byte arrays.
+ * Reduces garbage collection pressure during continuous frame processing.
+ */
+class ByteBufferPool(private val bufferSize: Int) {
+    companion object {
+        private const val TAG = "ByteBufferPool"
+    }
+
+    private val availableBuffers = mutableListOf<ByteArray>()
+    private val allocatedCount = AtomicInteger(0)
+    private val maxPoolSize = 3  // Keep max 3 buffers in pool
+
+    /**
+     * Acquire a buffer from the pool or allocate a new one if needed.
+     */
+    fun acquire(): ByteArray {
+        synchronized(availableBuffers) {
+            val buffer = if (availableBuffers.isNotEmpty()) {
+                availableBuffers.removeAt(0)
+            } else {
+                allocatedCount.incrementAndGet()
+                Log.d(TAG, "Allocated new buffer ($allocatedCount allocated)")
+                ByteArray(bufferSize)
+            }
+            return buffer
+        }
+    }
+
+    /**
+     * Return a buffer to the pool for reuse.
+     */
+    fun release(buffer: ByteArray) {
+        if (buffer.size != bufferSize) {
+            Log.w(TAG, "Buffer size mismatch: expected $bufferSize, got ${buffer.size}")
+            return
+        }
+
+        synchronized(availableBuffers) {
+            if (availableBuffers.size < maxPoolSize) {
+                availableBuffers.add(buffer)
+                Log.d(TAG, "Buffer returned to pool (available: ${availableBuffers.size})")
+            } else {
+                Log.d(TAG, "Pool is full, discarding buffer")
+            }
+        }
+    }
+
+    /**
+     * Get current pool statistics.
+     */
+    fun getStats(): String {
+        return "ByteBufferPool(size=$bufferSize, allocated=$allocatedCount, available=${availableBuffers.size})"
+    }
+
+    fun clear() {
+        synchronized(availableBuffers) {
+            availableBuffers.clear()
+            Log.d(TAG, "Buffer pool cleared")
+        }
+    }
+}
+

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

@@ -131,7 +131,12 @@ class FaceAntiSpoofFrameProcessor : FrameProcessorPlugin() {
                     "label" to result.label,
                     "neuralNetworkScore" to result.neuralNetworkScore.toDouble(),
                     "laplacianScore" to result.laplacianScore,
-                    "combinedScore" to result.combinedScore.toDouble()
+                    "combinedScore" to result.combinedScore.toDouble(),
+                    "recognitionImageBase64" to result.recognitionImageBase64,
+                    // Image format metadata
+                    "imageFormat" to result.imageFormat,
+                    "imageResolution" to result.imageResolution,
+                    "imageQuality" to result.imageQuality
                 )
                 
                 // Update the latest result for the next callback

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

@@ -14,15 +14,18 @@ import java.nio.ByteOrder
 import java.util.*
 import android.util.Log
 import kotlin.collections.ArrayList
+import android.util.Base64
+import com.faceantispoof.ImageFormatEncoder
+import com.faceantispoof.ImageFormatEncoder.ImageFormat
 
 class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     companion object {
         const val INPUT_IMAGE_SIZE = 256
-        const val BASE_THRESHOLD = 0.1f 
+        const val BASE_THRESHOLD = 0.2f 
         const val ROUTE_INDEX = 6
         const val LAPLACE_THRESHOLD = 50
-        const val LAPLACIAN_THRESHOLD = 10000
+        const val LAPLACIAN_THRESHOLD = 1000
         const val MODEL_FILE = "FaceAntiSpoofing.tflite"
         private const val TAG = "FaceAntiSpoofing"
         
@@ -31,6 +34,12 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         const val ACCELERATOR_GPU = "GPU"
         const val ACCELERATOR_NNAPI = "NNAPI"
         
+        // Image format configuration for face recognition systems
+        // Supported: JPEG (compressed), PNG (lossless), BMP (uncompressed)
+        const val DEFAULT_IMAGE_FORMAT = "JPEG"  // Options: "JPEG", "PNG", "BMP"
+        const val DEFAULT_JPEG_QUALITY = 85      // 0-100, higher = better quality but larger
+        const val DEFAULT_OUTPUT_RESOLUTION = 640 // 640×640 for face recognition
+        
         // Advanced spoof detection constants
         private const val HISTORY_SIZE = 10
         private const val TEMPORAL_CONSISTENCY_THRESHOLD = 0.08f
@@ -47,6 +56,11 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     private var gpuDelegate: GpuDelegate? = null
     private var currentAccelerator: String = ACCELERATOR_CPU
     
+    // Image format configuration for face recognition
+    private var outputImageFormat: String = DEFAULT_IMAGE_FORMAT
+    private var outputImageQuality: Int = DEFAULT_JPEG_QUALITY
+    private var outputImageResolution: Int = DEFAULT_OUTPUT_RESOLUTION
+    
     // Reusable buffers to avoid per-frame allocations
     private val inputImageSize = INPUT_IMAGE_SIZE
     private val inputBuffer: ByteBuffer = ByteBuffer.allocateDirect(4 * inputImageSize * inputImageSize * 3).order(ByteOrder.nativeOrder())
@@ -141,6 +155,57 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     fun getAccelerator(): String = currentAccelerator
 
+    /**
+     * Configure output image format for face recognition system.
+     * Supports JPEG (compressed), PNG (lossless), or BMP (uncompressed).
+     *
+     * @param format Image format: "JPEG" (default), "PNG", or "BMP"
+     * @param quality JPEG quality 0-100 (only applies to JPEG, ignored for PNG/BMP)
+     * @param resolution Output resolution in pixels (640 for 640×640, etc.)
+     */
+    fun setImageFormatConfig(
+        format: String = "JPEG",
+        quality: Int = 85,
+        resolution: Int = 640
+    ) {
+        val uppercaseFormat = format.uppercase()
+        outputImageFormat = if (uppercaseFormat in listOf("JPEG", "PNG", "BMP")) {
+            uppercaseFormat
+        } else {
+            "JPEG"
+        }
+        outputImageQuality = quality.coerceIn(1, 100)
+        outputImageResolution = resolution.coerceIn(64, 2048)
+        Log.d(TAG, "Image format config: $outputImageFormat quality=$outputImageQuality resolution=${outputImageResolution}×${outputImageResolution}")
+    }
+
+    /**
+     * Get current image format configuration.
+     * @return Map containing format, quality, and resolution
+     */
+    fun getImageFormatConfig(): Map<String, Any> {
+        return mapOf(
+            "format" to outputImageFormat,
+            "quality" to outputImageQuality,
+            "resolution" to outputImageResolution,
+            "estimatedSize" to estimateImageSize()
+        )
+    }
+
+    /**
+     * Estimate output image size for current format configuration.
+     * Useful for memory and network planning.
+     */
+    private fun estimateImageSize(): Long {
+        val pixelCount = outputImageResolution.toLong() * outputImageResolution
+        return when (outputImageFormat) {
+            "JPEG" -> (pixelCount * (100 - outputImageQuality) * 0.0012).toLong() // Quality-based estimation
+            "PNG" -> (pixelCount * 0.5).toLong()  // PNG typically 2-4x larger than JPEG
+            "BMP" -> pixelCount * 3  // Uncompressed RGB
+            else -> (pixelCount * 0.12).toLong()
+        }
+    }
+
     fun advancedAntiSpoofing(nv21: ByteArray, width: Int, height: Int): AntiSpoofingResult {
         if (!isInitialized) {
             return AntiSpoofingResult(
@@ -153,18 +218,23 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 isLive = false,
                 confidence = 0f,
                 label = "Not Initialized",
-                spoofType = "UNKNOWN"
+                spoofType = "UNKNOWN",
+                imageFormat = outputImageFormat,
+                imageResolution = outputImageResolution,
+                imageQuality = outputImageQuality
             )
         }
 
         // Enhanced input validation
         if (nv21.isEmpty()) {
-            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Invalid NV21 buffer", "INVALID_INPUT")
+            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Invalid NV21 buffer", "INVALID_INPUT",
+                imageFormat = outputImageFormat, imageResolution = outputImageResolution, imageQuality = outputImageQuality)
         }
 
         val expectedSize = width * height + (width * height) / 2
         if (nv21.size < expectedSize) {
-            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Buffer size mismatch", "INVALID_INPUT")
+            return AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: Buffer size mismatch", "INVALID_INPUT",
+                imageFormat = outputImageFormat, imageResolution = outputImageResolution, imageQuality = outputImageQuality)
         }
 
         return try {
@@ -200,6 +270,27 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 spoofDetection
             )
 
+            // Generate recognition image (JPEG/PNG/BMP) Base64 when face is live
+            var recognitionImageBase64: String? = null
+            val DEBUG_FORCE_BASE64 = false // Set to true to force Base64 generation for testing
+            
+            if (isLive || DEBUG_FORCE_BASE64) {
+                Log.d(TAG, "🔍 isLive=$isLive (DEBUG_FORCE_BASE64=$DEBUG_FORCE_BASE64) - generating ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64...")
+                try {
+                    recognitionImageBase64 = generateRecognitionImageBase64(nv21, width, height)
+                    if (recognitionImageBase64 != null) {
+                        Log.d(TAG, " Generated 640x640 JPEG Base64 for recognition API (size: ${recognitionImageBase64.length} bytes)")
+                    } else {
+                        Log.w(TAG, " generate640x640JpegBase64 returned null")
+                    }
+                } catch (e: Exception) {
+                    Log.w(TAG, " Failed to generate 640x640 JPEG Base64: ${e.message}", e)
+                    // Continue without the image - it's not critical
+                }
+            } else {
+                Log.d(TAG, " isLive is FALSE - skipping Base64 generation")
+            }
+
             AntiSpoofingResult(
                 neuralNetworkScore = nnScore,
                 laplacianScore = laplacianScore,
@@ -210,11 +301,16 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 isLive = isLive,
                 confidence = confidence,
                 label = if (isLive) "Live Face" else "Spoof Face: ${spoofDetection.type}",
-                spoofType = spoofDetection.type
+                spoofType = spoofDetection.type,
+                recognitionImageBase64 = recognitionImageBase64,
+                imageFormat = outputImageFormat,
+                imageResolution = outputImageResolution,
+                imageQuality = outputImageQuality
             )
         } catch (e: Exception) {
             Log.e(TAG, "Error in advancedAntiSpoofing", e)
-            AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: ${e.message}", "PROCESSING_ERROR")
+            AntiSpoofingResult(0f, 0, 0, 0f, 0f, 0f, false, 0f, "Error: ${e.message}", "PROCESSING_ERROR",
+                imageFormat = outputImageFormat, imageResolution = outputImageResolution, imageQuality = outputImageQuality)
         }
     }
 
@@ -272,6 +368,91 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    /**
+     * Generate image as Base64 string for face recognition API.
+     * Supports JPEG, PNG, and BMP formats with configurable resolution.
+     * Compatible with OpenCV cv2.imdecode() for face recognition systems.
+     *
+     * @param nv21 NV21 encoded YUV frame
+     * @param width Original frame width
+     * @param height Original frame height
+     * @return Base64 encoded image string, or null if generation fails
+     */
+    private fun generateRecognitionImageBase64(nv21: ByteArray, width: Int, height: Int): String? {
+        return try {
+            Log.d(TAG, "Starting ${outputImageResolution}×${outputImageResolution} $outputImageFormat generation. Input: ${width}x${height}, NV21 size: ${nv21.size}")
+            
+            // Convert NV21 to RGB byte array directly (configurable resolution)
+            val rgbBytes = ByteArray(outputImageResolution * outputImageResolution * 3)
+            Log.d(TAG, "Allocated RGB buffer: ${rgbBytes.size} bytes")
+            
+            val startConvert = System.currentTimeMillis()
+            val convertedRgb = yuvConverter.nv21ToRgbByteArray(
+                nv21, width, height,
+                outputImageResolution, outputImageResolution,
+                rgbBytes
+            )
+            val convertTime = System.currentTimeMillis() - startConvert
+            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
+            val startEncode = System.currentTimeMillis()
+            val format = when (outputImageFormat) {
+                "PNG" -> ImageFormatEncoder.ImageFormat.PNG
+                "BMP" -> ImageFormatEncoder.ImageFormat.BMP
+                else -> ImageFormatEncoder.ImageFormat.JPEG
+            }
+            
+            val base64Result = ImageFormatEncoder.rgbToBase64(
+                convertedRgb, 
+                outputImageResolution, 
+                outputImageResolution,
+                format,
+                outputImageQuality
+            )
+            val encodeTime = System.currentTimeMillis() - startEncode
+            
+            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)")
+                val estSize = estimateImageSize()
+                Log.d(TAG, "Format: $outputImageFormat, Quality: $outputImageQuality, Estimated: ${estSize / 1024}KB")
+            } else {
+                Log.w(TAG, "⚠️ ImageFormatEncoder returned null")
+            }
+            
+            base64Result
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ Error generating ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64: ${e.message}", e)
+            e.printStackTrace()
+            null
+        }
+    }
+
+    /**
+     * Legacy method: Generate 640×640 JPEG image as Base64 string.
+     * Kept for backward compatibility. Use generateRecognitionImageBase64() for new code.
+     */
+    @Deprecated("Use generateRecognitionImageBase64() instead", ReplaceWith("generateRecognitionImageBase64(nv21, width, height)"))
+    private fun generate640x640JpegBase64(nv21: ByteArray, width: Int, height: Int): String? {
+        // Temporarily set format to JPEG for backward compatibility
+        val savedFormat = outputImageFormat
+        outputImageFormat = "JPEG"
+        val savedQuality = outputImageQuality
+        outputImageQuality = 85
+        val savedResolution = outputImageResolution
+        outputImageResolution = 640
+        
+        val result = generateRecognitionImageBase64(nv21, width, height)
+        
+        // Restore original config
+        outputImageFormat = savedFormat
+        outputImageQuality = savedQuality
+        outputImageResolution = savedResolution
+        
+        return result
+    }
+
     private fun leafScore1(clssPred: Array<FloatArray>, leafNodeMask: Array<FloatArray>): Float {
         var score = 0f
         for (i in 0 until 8) {
@@ -572,5 +753,10 @@ data class AntiSpoofingResult(
     val isLive: Boolean,
     val confidence: Float,
     val label: String,
-    val spoofType: String
+    val spoofType: String,
+    val recognitionImageBase64: String? = null,
+    // Image format metadata
+    val imageFormat: String = "JPEG",           // Format: JPEG, PNG, BMP
+    val imageResolution: Int = 640,             // 640×640, 1280×720, etc.
+    val imageQuality: Int = 85                  // Quality for JPEG (0-100)
 )

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}"
+            }
+        }
+}