imp: improve scan speed for inverted images

Author: juliansteenbakker

android/src/main/kotlin/dev/steenbakker/mobile_scanner/MobileScanner.kt

@@ -4,7 +4,11 @@ import android.annotation.SuppressLint
 import android.app.Activity
 import android.content.Context
 import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.ColorMatrix
+import android.graphics.ColorMatrixColorFilter
 import android.graphics.Matrix
+import android.graphics.Paint
 import android.graphics.Rect
 import android.hardware.display.DisplayManager
 import android.media.Image
@@ -141,14 +145,13 @@ class MobileScanner(
                     mobileScannerCallback(
                         barcodeMap,
                         null,
-                        if (portrait) mediaImage.width else mediaImage.height,
-                        if (portrait) mediaImage.height else mediaImage.width)
+                        if (portrait) inputImage.width else inputImage.height,
+                        if (portrait) inputImage.height else inputImage.width)
                     return@addOnSuccessListener
                 }
 
                 val bitmap = Bitmap.createBitmap(mediaImage.width, mediaImage.height, Bitmap.Config.ARGB_8888)
-                val imageFormat = YuvToRgbConverter(activity.applicationContext)
-
+                val imageFormat =YuvToRgbConverter(activity.applicationContext)
                 imageFormat.yuvToRgb(mediaImage, bitmap)
 
                 val bmResult = rotateBitmap(bitmap, camera?.cameraInfo?.sensorRotationDegrees?.toFloat() ?: 90f)
@@ -159,6 +162,7 @@ class MobileScanner(
                 val bmWidth = bmResult.width
                 val bmHeight = bmResult.height
                 bmResult.recycle()
+                imageFormat.release()
 
                 mobileScannerCallback(
                     barcodeMap,
@@ -233,8 +237,7 @@ class MobileScanner(
         mobileScannerStartedCallback: MobileScannerStartedCallback,
         mobileScannerErrorCallback: (exception: Exception) -> Unit,
         detectionTimeout: Long,
-        cameraResolution: Size?,
-        newCameraResolutionSelector: Boolean,
+        cameraResolutionWanted: Size?,
         shouldConsiderInvertedImages: Boolean,
     ) {
         this.detectionSpeed = detectionSpeed
@@ -492,40 +495,45 @@ class MobileScanner(
     /**
      * Inverts the image colours respecting the alpha channel
      */
-    @SuppressLint("UnsafeOptInUsageError")
+    @ExperimentalGetImage
     fun invertInputImage(imageProxy: ImageProxy): InputImage {
         val image = imageProxy.image ?: throw IllegalArgumentException("Image is null")
 
-        // Convert YUV_420_888 image to NV21 format
-        // based on our util helper
+        // Convert YUV_420_888 image to RGB Bitmap
         val bitmap = Bitmap.createBitmap(image.width, image.height, Bitmap.Config.ARGB_8888)
-        YuvToRgbConverter(activity).yuvToRgb(image, bitmap)
-
-        // Invert RGB values
-        invertBitmapColors(bitmap)
-
-        return InputImage.fromBitmap(bitmap, imageProxy.imageInfo.rotationDegrees)
+        try {
+            val imageFormat =YuvToRgbConverter(activity.applicationContext);
+            imageFormat.yuvToRgb(image, bitmap)
+
+            // Create an inverted bitmap
+            val invertedBitmap = invertBitmapColors(bitmap)
+            imageFormat.release()
+
+            return InputImage.fromBitmap(invertedBitmap, imageProxy.imageInfo.rotationDegrees)
+        } finally {
+            // Release resources
+            bitmap.recycle() // Free up bitmap memory
+            imageProxy.close() // Close ImageProxy
+        }
     }
 
-    // Helper function to invert the colors of the bitmap
-    private fun invertBitmapColors(bitmap: Bitmap) {
-        val width = bitmap.width
-        val height = bitmap.height
-        for (x in 0 until width) {
-            for (y in 0 until height) {
-                val pixel = bitmap.getPixel(x, y)
-                val invertedColor = invertColor(pixel)
-                bitmap.setPixel(x, y, invertedColor)
-            }
+    // Efficiently invert bitmap colors using ColorMatrix
+    private fun invertBitmapColors(bitmap: Bitmap): Bitmap {
+        val colorMatrix = ColorMatrix().apply {
+            set(floatArrayOf(
+                -1f, 0f, 0f, 0f, 255f,  // Red
+                0f, -1f, 0f, 0f, 255f,  // Green
+                0f, 0f, -1f, 0f, 255f,  // Blue
+                0f, 0f, 0f, 1f, 0f      // Alpha
+            ))
         }
-    }
+        val paint = Paint().apply { colorFilter = ColorMatrixColorFilter(colorMatrix) }
+
+        val invertedBitmap = Bitmap.createBitmap(bitmap.width, bitmap.height, bitmap.config)
+        val canvas = Canvas(invertedBitmap)
+        canvas.drawBitmap(bitmap, 0f, 0f, paint)
 
-    private fun invertColor(pixel: Int): Int {
-        val alpha = pixel and 0xFF000000.toInt()
-        val red = 255 - (pixel shr 16 and 0xFF)
-        val green = 255 - (pixel shr 8 and 0xFF)
-        val blue = 255 - (pixel and 0xFF)
-        return alpha or (red shl 16) or (green shl 8) or blue
+        return invertedBitmap
     }
 
     /**

android/src/main/kotlin/dev/steenbakker/mobile_scanner/MobileScannerHandler.kt

@@ -211,7 +211,6 @@ class MobileScannerHandler(
             },
             timeout.toLong(),
             cameraResolution,
-            useNewCameraSelector,
             shouldConsiderInvertedImages,
         )
     }

android/src/main/kotlin/dev/steenbakker/mobile_scanner/utils/YuvToRgbConverter.kt

@@ -6,6 +6,7 @@ import android.graphics.ImageFormat
 import android.media.Image
 import android.os.Build
 import android.renderscript.Allocation
+import android.renderscript.Allocation.createAllocations
 import android.renderscript.Element
 import android.renderscript.RenderScript
 import android.renderscript.ScriptIntrinsicYuvToRGB
@@ -23,59 +24,69 @@ import java.nio.ByteBuffer
  * The [yuvToRgb] method is able to achieve the same FPS as the CameraX image
  * analysis use case at the default analyzer resolution, which is 30 FPS with
  * 640x480 on a Pixel 3 XL device.
- */class YuvToRgbConverter(context: Context) {
+ */
+class YuvToRgbConverter(context: Context) {
     private val rs = RenderScript.create(context)
     private val scriptYuvToRgb =
         ScriptIntrinsicYuvToRGB.create(rs, Element.U8_4(rs))
 
-    // Do not add getters/setters functions to these private variables
-    // because yuvToRgb() assume they won't be modified elsewhere
     private var yuvBits: ByteBuffer? = null
     private var bytes: ByteArray = ByteArray(0)
     private var inputAllocation: Allocation? = null
     private var outputAllocation: Allocation? = null
 
     @Synchronized
     fun yuvToRgb(image: Image, output: Bitmap) {
-        val yuvBuffer = YuvByteBuffer(image, yuvBits)
-        yuvBits = yuvBuffer.buffer
+        try {
+            val yuvBuffer = YuvByteBuffer(image, yuvBits)
+            yuvBits = yuvBuffer.buffer
 
-        if (needCreateAllocations(image, yuvBuffer)) {
-            val yuvType = Type.Builder(rs, Element.U8(rs))
-                .setX(image.width)
-                .setY(image.height)
-                .setYuvFormat(yuvBuffer.type)
-            inputAllocation = Allocation.createTyped(
-                rs,
-                yuvType.create(),
-                Allocation.USAGE_SCRIPT
-            )
-            bytes = ByteArray(yuvBuffer.buffer.capacity())
-            val rgbaType = Type.Builder(rs, Element.RGBA_8888(rs))
-                .setX(image.width)
-                .setY(image.height)
-            outputAllocation = Allocation.createTyped(
-                rs,
-                rgbaType.create(),
-                Allocation.USAGE_SCRIPT
-            )
-        }
+            if (needCreateAllocations(image, yuvBuffer)) {
+                createAllocations(image, yuvBuffer)
+            }
 
-        yuvBuffer.buffer.get(bytes)
-        inputAllocation!!.copyFrom(bytes)
+            yuvBuffer.buffer.get(bytes)
+            inputAllocation!!.copyFrom(bytes)
 
-        // Convert NV21 or YUV_420_888 format to RGB
-        inputAllocation!!.copyFrom(bytes)
-        scriptYuvToRgb.setInput(inputAllocation)
-        scriptYuvToRgb.forEach(outputAllocation)
-        outputAllocation!!.copyTo(output)
+            scriptYuvToRgb.setInput(inputAllocation)
+            scriptYuvToRgb.forEach(outputAllocation)
+            outputAllocation!!.copyTo(output)
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to convert YUV to RGB", e)
+        }
     }
 
     private fun needCreateAllocations(image: Image, yuvBuffer: YuvByteBuffer): Boolean {
-        return (inputAllocation == null ||               // the very 1st call
-                inputAllocation!!.type.x != image.width ||   // image size changed
-                inputAllocation!!.type.y != image.height ||
-                inputAllocation!!.type.yuv != yuvBuffer.type || // image format changed
-                bytes.size == yuvBuffer.buffer.capacity())
+        return inputAllocation?.type?.x != image.width ||
+                inputAllocation?.type?.y != image.height ||
+                inputAllocation?.type?.yuv != yuvBuffer.type
+    }
+
+    private fun createAllocations(image: Image, yuvBuffer: YuvByteBuffer) {
+        val yuvType = Type.Builder(rs, Element.U8(rs))
+            .setX(image.width)
+            .setY(image.height)
+            .setYuvFormat(yuvBuffer.type)
+        inputAllocation = Allocation.createTyped(
+            rs,
+            yuvType.create(),
+            Allocation.USAGE_SCRIPT
+        )
+        bytes = ByteArray(yuvBuffer.buffer.capacity())
+        val rgbaType = Type.Builder(rs, Element.RGBA_8888(rs))
+            .setX(image.width)
+            .setY(image.height)
+        outputAllocation = Allocation.createTyped(
+            rs,
+            rgbaType.create(),
+            Allocation.USAGE_SCRIPT
+        )
+    }
+
+    fun release() {
+        inputAllocation?.destroy()
+        outputAllocation?.destroy()
+        scriptYuvToRgb.destroy()
+        rs.destroy()
     }
-}
+}