feat: Implement Android

Author: mrousavy

packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/ArrayBuffer+copyIfNotOwner.kt

@@ -0,0 +1,10 @@
+package com.margelo.nitro.image
+
+import com.margelo.nitro.core.ArrayBuffer
+
+fun ArrayBuffer.copyIfNotOwner(): ArrayBuffer {
+    if (!this.isOwner) {
+        return ArrayBuffer.copy(this)
+    }
+    return this
+}

packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/Bitmap+fromRawPixelData.kt

@@ -0,0 +1,80 @@
+package com.margelo.nitro.image
+
+import android.graphics.Bitmap
+import androidx.core.graphics.createBitmap
+import java.io.File
+import java.io.FileOutputStream
+import java.nio.IntBuffer
+
+private data class Swizzle(val r: Int, val g: Int, val b: Int, val a: Int, val bpp: Int)
+
+private val SW = mapOf(
+    PixelFormat.ARGB to Swizzle(1,2,3,0,4), // A R G B
+    PixelFormat.BGRA to Swizzle(2,1,0,3,4), // B G R A
+    PixelFormat.ABGR to Swizzle(3,2,1,0,4), // A B G R
+    PixelFormat.RGBA to Swizzle(0,1,2,3,4), // R G B A
+    PixelFormat.XRGB to Swizzle(1,2,3,-1,4),// X R G B
+    PixelFormat.BGRX to Swizzle(2,1,0,-1,4),// B G R X
+    PixelFormat.XBGR to Swizzle(3,2,1,-1,4),// X B G R
+    PixelFormat.RGBX to Swizzle(0,1,2,-1,4),// R G B X
+    PixelFormat.RGB  to Swizzle(0,1,2,-1,3),// R G B
+    PixelFormat.BGR  to Swizzle(2,1,0,-1,3) // B G R
+)
+
+fun bitmapFromRawPixelData(data: RawPixelData): Bitmap {
+    val w = data.width.toInt()
+    val h = data.height.toInt()
+    val sw = SW[data.pixelFormat] ?: throw Error("Unsupported Pixel Format: ${data.pixelFormat}")
+    val stride = w * sw.bpp
+    val buffer = data.buffer.getBuffer(false)
+    buffer.rewind()
+    if (buffer.remaining() < stride * h) {
+        throw Error("ByteBuffer is too small! (Remaining: ${buffer.remaining()}/${buffer.capacity()}, Expected Bytes: ${stride * h})")
+    }
+
+    val out = IntArray(w * h)
+
+    fun packPremul(r: Int, g: Int, b_: Int, a: Int): Int {
+        val a8 = if (a < 0) 0xFF else a
+        val rr = if (a8 == 255) r else (r * a8 + 127) / 255
+        val gg = if (a8 == 255) g else (g * a8 + 127) / 255
+        val bb = if (a8 == 255) b_ else (b_ * a8 + 127) / 255
+        return (a8 shl 24) or (rr shl 16) or (gg shl 8) or bb
+    }
+
+    var di = 0
+    if (sw.bpp == 4) {
+        for (y in 0 until h) {
+            val row = y * stride
+            for (x in 0 until w) {
+                val p = row + x * 4
+                val b0 = buffer.get(p).toInt() and 0xFF
+                val b1 = buffer.get(p + 1).toInt() and 0xFF
+                val b2 = buffer.get(p + 2).toInt() and 0xFF
+                val b3 = buffer.get(p + 3).toInt() and 0xFF
+                val ch = intArrayOf(b0, b1, b2, b3)
+                val r = ch[sw.r]; val g = ch[sw.g]; val bl = ch[sw.b]
+                val a = if (sw.a >= 0) ch[sw.a] else 255
+                out[di++] = packPremul(r, g, bl, a)
+            }
+        }
+    } else { // 3 bpp
+        for (y in 0 until h) {
+            val row = y * stride
+            for (x in 0 until w) {
+                val p = row + x * 3
+                val b0 = buffer.get(p).toInt() and 0xFF
+                val b1 = buffer.get(p + 1).toInt() and 0xFF
+                val b2 = buffer.get(p + 2).toInt() and 0xFF
+                val ch = intArrayOf(b0, b1, b2)
+                val r = ch[sw.r]; val g = ch[sw.g]; val bl = ch[sw.b]
+                out[di++] = packPremul(r, g, bl, 255)
+            }
+        }
+    }
+
+    val bitmap = createBitmap(w, h, Bitmap.Config.ARGB_8888)
+    bitmap.isPremultiplied = true
+    bitmap.copyPixelsFromBuffer(IntBuffer.wrap(out))
+    return bitmap
+}

packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/FastByteArrayOutputStream.kt

@@ -0,0 +1,34 @@
+package com.margelo.nitro.image
+
+import java.io.OutputStream
+import java.nio.ByteBuffer
+
+class FastByteArrayOutputStream(initialSize: Int = 64 * 1024) : OutputStream() {
+    var bytes = ByteArray(initialSize)
+        private set
+    var count = 0
+        private set
+
+    override fun write(b: Int) {
+        val i = count + 1
+        ensureCapacity(i)
+        bytes[count] = b.toByte()
+        count = i
+    }
+
+    override fun write(b: ByteArray, off: Int, len: Int) {
+        val i = count + len
+        ensureCapacity(i)
+        System.arraycopy(b, off, bytes, count, len)
+        count = i
+    }
+
+    private fun ensureCapacity(min: Int) {
+        if (min <= bytes.size) return
+        var newCap = bytes.size.coerceAtLeast(1)
+        while (newCap < min) newCap = newCap shl 1
+        bytes = bytes.copyOf(newCap)
+    }
+
+    fun toByteBuffer(): ByteBuffer = ByteBuffer.wrap(bytes, 0, count)
+}

packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridImage.kt

@@ -3,10 +3,12 @@ package com.margelo.nitro.image
 import android.graphics.Bitmap
 import android.os.Build
 import androidx.annotation.Keep
+import com.facebook.common.memory.PooledByteBufferOutputStream
 import com.facebook.proguard.annotations.DoNotStrip
 import com.madebyevan.thumbhash.ThumbHash
 import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.Promise
+import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
@@ -48,19 +50,43 @@ class HybridImage: HybridImageSpec {
         return buffer
     }
 
-    override fun toRawArrayBuffer(): RawPixelData {
-        val arrayBuffer = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && isGPU) {
+    override fun toRawPixelData(allowGpu: Boolean?): RawPixelData {
+        val arrayBuffer = if (allowGpu == true && isGPU && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            // Wrap the existing GPU buffer (HardwareBuffer)
             ArrayBuffer.wrap(bitmap.hardwareBuffer)
         } else {
+            // Copy the data into a CPU buffer (ByteBuffer)
             val buffer = toByteBuffer()
             ArrayBuffer.wrap(buffer)
         }
-        bitmap.copyPixelsToBuffer()
-        return RawPixelData(arrayBuffer, width, height, )
+        // TODO: Figure out PixelFormat on GPU buffers
+        return RawPixelData(arrayBuffer, width, height, PixelFormat.ARGB)
+    }
+    override fun toRawPixelDataAsync(allowGpu: Boolean?): Promise<RawPixelData> {
+        return Promise.async { toRawPixelData(allowGpu) }
     }
 
-    override fun toRawArrayBufferAsync(): Promise<RawPixelData> {
-        return Promise.async { toArrayBuffer() }
+    override fun toEncodedImageData(format: ImageFormat, quality: Double?): EncodedImageData {
+        val quality = quality ?: 1.0
+        val estimatedByteSize = when (format) {
+            ImageFormat.JPG -> (width * height) / 2
+            ImageFormat.PNG -> width * height
+        }
+        val outputStream = FastByteArrayOutputStream(estimatedByteSize.toInt())
+        val successful = bitmap.compress(format.toBitmapFormat(), quality.toInt(), outputStream)
+        if (!successful) {
+            throw Error("Failed to compress the Bitmap into EncodedImageData! (Format: ${format.name}, " +
+                    "Quality: ${quality}, Written Bytes: ${outputStream.count})")
+        }
+        val byteBuffer = outputStream.toByteBuffer()
+        val arrayBuffer = ArrayBuffer.wrap(byteBuffer)
+        return EncodedImageData(arrayBuffer, width, height, format)
+    }
+    override fun toEncodedImageDataAsync(
+        format: ImageFormat,
+        quality: Double?
+    ): Promise<EncodedImageData> {
+        return Promise.async { toEncodedImageData(format, quality) }
     }
 
     override fun resize(width: Double, height: Double): HybridImageSpec {
@@ -102,14 +128,15 @@ class HybridImage: HybridImageSpec {
     override fun saveToFileAsync(
         path: String,
         format: ImageFormat,
-        quality: Double
+        quality: Double?
     ): Promise<Unit> {
+        val quality = quality ?: 1.0
         return Promise.async {
             bitmap.saveToFile(path, format, quality.toInt())
         }
     }
 
-    override fun saveToTemporaryFileAsync(format: ImageFormat, quality: Double): Promise<String> {
+    override fun saveToTemporaryFileAsync(format: ImageFormat, quality: Double?): Promise<String> {
         return Promise.async {
             val tempFile = File.createTempFile("nitro_image_", format.name)
             this.saveToFileAsync(tempFile.path, format, quality)

packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridImageFactory.kt

@@ -43,14 +43,27 @@ class HybridImageFactory: HybridImageFactorySpec() {
         throw Error("ImageFactory.loadFromSymbol(symbolName:) is not supported on Android!")
     }
 
-    override fun loadFromArrayBuffer(buffer: ArrayBuffer): HybridImageSpec {
-        val array = buffer.toByteArray()
-        val bitmap = BitmapFactory.decodeByteArray(array, 0, buffer.size)
+    override fun loadFromRawPixelData(data: RawPixelData): HybridImageSpec {
+        val bitmap = bitmapFromRawPixelData(data)
         return HybridImage(bitmap)
     }
+    override fun loadFromRawPixelDataAsync(data: RawPixelData): Promise<HybridImageSpec> {
+        val bufferCopy = data.buffer.copyIfNotOwner()
+        val dataCopy = RawPixelData(bufferCopy, data.width, data.height, data.pixelFormat)
+        return Promise.async { loadFromRawPixelData(dataCopy) }
+    }
 
-    override fun loadFromArrayBufferAsync(buffer: ArrayBuffer): Promise<HybridImageSpec> {
-        return Promise.async { loadFromArrayBuffer(buffer) }
+    private fun loadFromEncodedBytes(bytes: ByteArray): HybridImageSpec {
+        val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+        return HybridImage(bitmap)
+    }
+    override fun loadFromEncodedImageData(data: EncodedImageData): HybridImageSpec {
+        val bytes = data.buffer.toByteArray()
+        return loadFromEncodedBytes(bytes)
+    }
+    override fun loadFromEncodedImageDataAsync(data: EncodedImageData): Promise<HybridImageSpec> {
+        val bytes = data.buffer.toByteArray()
+        return Promise.async { loadFromEncodedBytes(bytes) }
     }
 
     override fun loadFromFile(filePath: String): HybridImageSpec {

packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridImageLoaderFactory.kt

@@ -22,7 +22,11 @@ class HybridImageLoaderFactory: HybridImageLoaderFactorySpec() {
         return HybridImageLoader { Promise.resolved(factory.loadFromSymbol(symbolName)) }
     }
 
-    override fun createArrayBufferImageLoader(buffer: ArrayBuffer): HybridImageLoaderSpec {
-        return HybridImageLoader { factory.loadFromArrayBufferAsync(buffer) }
+    override fun createRawPixelDataImageLoader(data: RawPixelData): HybridImageLoaderSpec {
+        return HybridImageLoader { factory.loadFromRawPixelDataAsync(data) }
+    }
+
+    override fun createEncodedImageDataImageLoader(data: EncodedImageData): HybridImageLoaderSpec {
+        return HybridImageLoader { factory.loadFromEncodedImageDataAsync(data) }
     }
 }

packages/react-native-nitro-image/ios/NativeImage.swift

@@ -23,20 +23,20 @@ public protocol NativeImage {
 public extension NativeImage {
   var width: Double { uiImage.size.width }
   var height: Double { uiImage.size.height }
-  
-  func toRawPixelData() throws -> RawPixelData {
+
+  func toRawPixelData(allowGpu _: Bool?) throws -> RawPixelData {
     return try uiImage.toRawPixelData()
   }
-  func toRawPixelDataAsync() throws -> Promise<RawPixelData> {
+  func toRawPixelDataAsync(allowGpu: Bool?) throws -> Promise<RawPixelData> {
     return Promise.async {
-      return try self.toRawPixelData()
+      return try self.toRawPixelData(allowGpu: allowGpu)
     }
   }
-  
+
   func toEncodedImageData(format: ImageFormat, quality: Double?) throws -> EncodedImageData {
     return try uiImage.toEncodedImageData(format: format, quality: quality ?? 1.0)
   }
-  
+
   func toEncodedImageDataAsync(format: ImageFormat, quality: Double?) throws -> Promise<EncodedImageData> {
     return Promise.async {
       return try self.toEncodedImageData(format: format, quality: quality)