feat: add support for compressing images

Author: surajkumar

README.md

@@ -10,8 +10,9 @@ A Kotlin Multiplatform image selection library for Android, iOS and Desktop.
 ## Features
 * Selecting images on Android, iOS and Desktop
 * Setting aspect ratios
+* Compressing images by quality or toward a target file size
 
-## ✅ Supported Platform
+## Supported Platform
 
 | Platform | Supported |
 |:---------|:----------|
@@ -20,7 +21,7 @@ A Kotlin Multiplatform image selection library for Android, iOS and Desktop.
 | Desktop  | ✔️        |
 | Web      | ❌️        |
 
-## 🚀 Installation
+## Installation
 See the releases section of this repository for the latest version.
 
 To your `build.gradle` under `commonMain.dependencies` add:
@@ -68,6 +69,24 @@ class AppViewModel : ViewModel() {
 }
 ```
 
+You can then compress the selected image when needed:
+
+```kotlin
+val compressed = image.value?.compress(
+    ImageCompressionOptions(
+        quality = 88
+    )
+)
+```
+
+Or target a maximum size, for example 5 MB:
+
+```kotlin
+val underFiveMb = image.value?.compressToMaxBytes(
+    maxBytes = 5L * 1024L * 1024L
+)
+```
+
 Example Composable:
 ```kotlin
 @Composable
@@ -96,9 +115,9 @@ fun App(viewModel: AppViewModel = viewModel { AppViewModel() }) {
 }
 ```
 
-## 📄 License
+## License
 MIT LICENSE. See [LICENSE](./LICENSE) for details.
 
-## 🙌 Contributing
+## Contributing
 Pull requests and feature requests are welcome!
-If you encounter any issues, feel free to open an issue.
+If you encounter any issues, feel free to open an issue.

imageselector/src/androidMain/kotlin/com/wannaverse/imageselector/ByteArrayExtension.kt

@@ -16,4 +16,35 @@ actual fun ImageBitmap.toByteArray(): ByteArray {
     val stream = ByteArrayOutputStream()
     bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
     return stream.toByteArray()
-}
+}
+
+actual fun ByteArray.compressImage(options: ImageCompressionOptions): ByteArray {
+    val bitmap = BitmapFactory.decodeByteArray(this, 0, size) ?: return this
+
+    val format = when (options.format) {
+        ImageCompressionFormat.JPEG -> Bitmap.CompressFormat.JPEG
+        ImageCompressionFormat.PNG -> Bitmap.CompressFormat.PNG
+    }
+
+    var quality = options.quality
+    var compressed = bitmap.encode(format, quality)
+
+    if (format == Bitmap.CompressFormat.JPEG) {
+        val maxBytes = options.maxBytes
+        while (maxBytes != null && compressed.size > maxBytes && quality > options.minQuality) {
+            quality = maxOf(options.minQuality, quality - options.qualityStep)
+            compressed = bitmap.encode(format, quality)
+            if (quality == options.minQuality) {
+                break
+            }
+        }
+    }
+
+    return compressed
+}
+
+private fun Bitmap.encode(format: Bitmap.CompressFormat, quality: Int): ByteArray {
+    val stream = ByteArrayOutputStream()
+    compress(format, quality, stream)
+    return stream.toByteArray()
+}

imageselector/src/commonMain/kotlin/com/wannaverse/imageselector/ByteArrayExtension.kt

@@ -15,3 +15,12 @@ expect fun ByteArray.toImageBitmap(): ImageBitmap
  * This is an `expect` function; its actual implementation is platform-specific.
  */
 expect fun ImageBitmap.toByteArray(): ByteArray
+
+/**
+ * Compresses this [ByteArray] if it contains a supported image.
+ *
+ * If compression cannot be applied, the original bytes are returned unchanged.
+ */
+expect fun ByteArray.compressImage(
+    options: ImageCompressionOptions = ImageCompressionOptions()
+): ByteArray

imageselector/src/commonMain/kotlin/com/wannaverse/imageselector/ImageCompression.kt

@@ -0,0 +1,78 @@
+package com.wannaverse.imageselector
+
+/**
+ * Output format used during compression.
+ */
+enum class ImageCompressionFormat {
+    JPEG,
+    PNG
+}
+
+/**
+ * Options that control image compression.
+ *
+ * JPEG is the default because it gives predictable file-size savings for photos.
+ * PNG is supported as a lossless option, but size targeting becomes best-effort.
+ */
+data class ImageCompressionOptions(
+    val format: ImageCompressionFormat = ImageCompressionFormat.JPEG,
+    val quality: Int = 90,
+    val maxBytes: Long? = null,
+    val minQuality: Int = 55,
+    val qualityStep: Int = 5
+) {
+    init {
+        require(quality in 0..100) { "quality must be between 0 and 100." }
+        require(minQuality in 0..100) { "minQuality must be between 0 and 100." }
+        require(minQuality <= quality) { "minQuality must be less than or equal to quality." }
+        require(qualityStep > 0) { "qualityStep must be greater than 0." }
+        require(maxBytes == null || maxBytes > 0) { "maxBytes must be greater than 0 when provided." }
+    }
+}
+
+/**
+ * Returns a compressed copy of this [ImageData].
+ */
+fun ImageData.compress(
+    options: ImageCompressionOptions = ImageCompressionOptions()
+): ImageData = copy(
+    bytes = bytes?.compressImage(options)
+)
+
+/**
+ * Compresses this [ByteArray] toward the provided maximum size.
+ */
+fun ByteArray.compressToMaxBytes(
+    maxBytes: Long,
+    format: ImageCompressionFormat = ImageCompressionFormat.JPEG,
+    quality: Int = 90,
+    minQuality: Int = 55,
+    qualityStep: Int = 5
+): ByteArray = compressImage(
+    ImageCompressionOptions(
+        format = format,
+        quality = quality,
+        maxBytes = maxBytes,
+        minQuality = minQuality,
+        qualityStep = qualityStep
+    )
+)
+
+/**
+ * Compresses this [ImageData] toward the provided maximum size.
+ */
+fun ImageData.compressToMaxBytes(
+    maxBytes: Long,
+    format: ImageCompressionFormat = ImageCompressionFormat.JPEG,
+    quality: Int = 90,
+    minQuality: Int = 55,
+    qualityStep: Int = 5
+): ImageData = compress(
+    ImageCompressionOptions(
+        format = format,
+        quality = quality,
+        maxBytes = maxBytes,
+        minQuality = minQuality,
+        qualityStep = qualityStep
+    )
+)

imageselector/src/iosMain/kotlin/com/wannaverse/imageselector/ByteArrayExtension.kt

@@ -3,9 +3,17 @@ package com.wannaverse.imageselector
 import androidx.compose.ui.graphics.ImageBitmap
 import androidx.compose.ui.graphics.asSkiaBitmap
 import androidx.compose.ui.graphics.toComposeImageBitmap
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.addressOf
+import kotlinx.cinterop.usePinned
 import org.jetbrains.skia.Data
 import org.jetbrains.skia.EncodedImageFormat
 import org.jetbrains.skia.Image
+import platform.Foundation.NSData
+import platform.UIKit.UIImage
+import platform.UIKit.UIImageJPEGRepresentation
+import platform.UIKit.UIImagePNGRepresentation
+import platform.posix.memcpy
 
 actual fun ByteArray.toImageBitmap(): ImageBitmap {
     return Image
@@ -16,4 +24,45 @@ actual fun ByteArray.toImageBitmap(): ImageBitmap {
 actual fun ImageBitmap.toByteArray(): ByteArray {
     val skiaImage = Image.makeFromBitmap(this.asSkiaBitmap())
     return skiaImage.encodeToData(EncodedImageFormat.PNG, 100)?.bytes ?: ByteArray(0)
-}
+}
+
+actual fun ByteArray.compressImage(options: ImageCompressionOptions): ByteArray {
+    val image = UIImage(data = toNSData()) ?: return this
+
+    var quality = options.quality
+    var compressed = image.encode(options.format, quality) ?: return this
+
+    if (options.format == ImageCompressionFormat.JPEG) {
+        val maxBytes = options.maxBytes
+        while (maxBytes != null && compressed.length.toLong() > maxBytes && quality > options.minQuality) {
+            quality = maxOf(options.minQuality, quality - options.qualityStep)
+            compressed = image.encode(options.format, quality) ?: break
+            if (quality == options.minQuality) {
+                break
+            }
+        }
+    }
+
+    return compressed.toByteArray()
+}
+
+private fun UIImage.encode(format: ImageCompressionFormat, quality: Int): NSData? {
+    return when (format) {
+        ImageCompressionFormat.JPEG -> UIImageJPEGRepresentation(this, quality.toDouble() / 100.0)
+        ImageCompressionFormat.PNG -> UIImagePNGRepresentation(this)
+    }
+}
+
+@OptIn(ExperimentalForeignApi::class)
+private fun ByteArray.toNSData(): NSData = usePinned {
+    NSData.dataWithBytes(bytes = it.addressOf(0), length = size.toULong())
+}
+
+@OptIn(ExperimentalForeignApi::class)
+private fun NSData.toByteArray(): ByteArray {
+    val bytes = ByteArray(length.toInt())
+    bytes.usePinned {
+        memcpy(it.addressOf(0), this.bytes, length)
+    }
+    return bytes
+}

imageselector/src/jvmMain/kotlin/com/wannaverse/imageselector/ByteArrayExtension.kt

@@ -3,10 +3,15 @@ package com.wannaverse.imageselector
 import androidx.compose.ui.graphics.ImageBitmap
 import androidx.compose.ui.graphics.toAwtImage
 import androidx.compose.ui.graphics.toComposeImageBitmap
+import java.awt.Color
+import java.awt.RenderingHints
 import java.awt.image.BufferedImage
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 import javax.imageio.ImageIO
+import javax.imageio.ImageWriteParam
+import javax.imageio.ImageWriter
+import javax.imageio.stream.MemoryCacheImageOutputStream
 
 actual fun ByteArray.toImageBitmap(): ImageBitmap {
     val inputStream = ByteArrayInputStream(this)
@@ -19,4 +24,65 @@ actual fun ImageBitmap.toByteArray(): ByteArray {
     val outputStream = ByteArrayOutputStream()
     ImageIO.write(bufferedImage, "png", outputStream)
     return outputStream.toByteArray()
-}
+}
+
+actual fun ByteArray.compressImage(options: ImageCompressionOptions): ByteArray {
+    val sourceImage = ImageIO.read(ByteArrayInputStream(this)) ?: return this
+
+    var quality = options.quality
+    var compressed = sourceImage.encode(options.format, quality) ?: return this
+
+    if (options.format == ImageCompressionFormat.JPEG) {
+        val maxBytes = options.maxBytes
+        while (maxBytes != null && compressed.size > maxBytes && quality > options.minQuality) {
+            quality = maxOf(options.minQuality, quality - options.qualityStep)
+            compressed = sourceImage.encode(options.format, quality) ?: break
+            if (quality == options.minQuality) {
+                break
+            }
+        }
+    }
+
+    return compressed
+}
+
+private fun BufferedImage.encode(format: ImageCompressionFormat, quality: Int): ByteArray? {
+    return when (format) {
+        ImageCompressionFormat.PNG -> ByteArrayOutputStream().use { output ->
+            ImageIO.write(this, "png", output)
+            output.toByteArray()
+        }
+        ImageCompressionFormat.JPEG -> encodeJpeg(quality)
+    }
+}
+
+private fun BufferedImage.encodeJpeg(quality: Int): ByteArray? {
+    val writer = ImageIO.getImageWritersByFormatName("jpeg").asSequence().firstOrNull() ?: return null
+    return ByteArrayOutputStream().use { output ->
+        MemoryCacheImageOutputStream(output).use { imageOutput ->
+            writer.output = imageOutput
+            writer.write(null, javax.imageio.IIOImage(asJpegCompatibleImage(), null, null), writer.jpegWriteParam(quality))
+            writer.dispose()
+        }
+        output.toByteArray()
+    }
+}
+
+private fun BufferedImage.asJpegCompatibleImage(): BufferedImage {
+    if (type == BufferedImage.TYPE_INT_RGB) return this
+
+    val converted = BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
+    val graphics = converted.createGraphics()
+    graphics.color = Color.WHITE
+    graphics.fillRect(0, 0, width, height)
+    graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR)
+    graphics.drawImage(this, 0, 0, null)
+    graphics.dispose()
+    return converted
+}
+
+private fun ImageWriter.jpegWriteParam(quality: Int): ImageWriteParam =
+    defaultWriteParam.apply {
+        compressionMode = ImageWriteParam.MODE_EXPLICIT
+        compressionQuality = quality.coerceIn(0, 100) / 100f
+    }