perf(mms): decode an image once per attachment instead of per attempt

Addresses the review feedback on #826.

Compression searches for a size that fits under the carrier limit, so it encodes
the same image many times: a binary search over dimensions, then a quality ladder
from 90 down to 40 if nothing fit. Every one of those attempts went through
ImageUtils.getScaledImage, which re-opened the source URI and re-decoded it from
scratch. Decoding is the expensive part and it was the only part being repeated
unnecessarily; a large photo could be decoded a dozen or more times to send once.

ScaledImageEncoder decodes the source a single time, sampled down to no smaller
than the largest width the search will ask for, and re-encodes that bitmap from
memory for each attempt. The search itself is unchanged.

The decode is guarded: with no carrier cap the target size is the original image,
which on a modern camera sensor is large enough to matter, so an OutOfMemoryError
returns null and the caller falls back to Glide, which streams instead of holding
the whole bitmap.

Also fixes three edge cases raised in review:

- A bounds decode that fails leaves outWidth/outHeight at zero, making the aspect
  ratio 0/0 and every derived dimension garbage. Detect it and fall back rather
  than divide by it.

- searchHi was floored at 100, which raised it above the original width, and above
  the carrier maximum when that was under 100. Both upscale the image and inflate
  the payload. The floor is now 1 and the search starts at 1 rather than 100.

- The last-resort fallback hard-coded a width of 100, upscaling anything narrower.
  It is now bounded by searchHi, so it can only shrink.
This commit is contained in:
octoshrimpy
2026-08-01 17:15:23 -04:00
parent 96fcb8841a
commit 2bd62f2f94
2 changed files with 145 additions and 55 deletions
@@ -604,19 +604,34 @@ open class MessageRepositoryImpl @Inject constructor(
} }
val origWidth = opts.outWidth val origWidth = opts.outWidth
val origHeight = opts.outHeight val origHeight = opts.outHeight
// Bounds decoding fails on formats BitmapFactory can't read. Without real
// dimensions the aspect ratio is 0/0, so hand off to Glide rather than divide by it.
if (origWidth <= 0 || origHeight <= 0) {
Timber.w("Could not read image bounds, falling back to Glide scaling")
return ImageUtils.getScaledImage(context, attachment.uri, maxWidth, maxHeight)
}
val aspectRatio = origWidth.toFloat() / origHeight.toFloat() val aspectRatio = origWidth.toFloat() / origHeight.toFloat()
val maxWidthByHeight = if (maxHeight != Int.MAX_VALUE) { val maxWidthByHeight = if (maxHeight != Int.MAX_VALUE) {
minOf((maxHeight * aspectRatio.toDouble()).toInt(), origWidth) minOf((maxHeight * aspectRatio.toDouble()).toInt(), origWidth)
} else origWidth } else origWidth
val searchHi = minOf(origWidth, maxWidth, maxWidthByHeight).coerceAtLeast(100) // Never above the original or the carrier's ceiling: raising this to a floor of
// 100 would upscale images smaller than that and inflate the payload.
val searchHi = minOf(origWidth, maxWidth, maxWidthByHeight).coerceAtLeast(1)
var lo = minOf(100, searchHi) var lo = 1
var hi = searchHi var hi = searchHi
var bestBytes: ByteArray? = null var bestBytes: ByteArray? = null
var attempt = 0 var attempt = 0
if (isGif) { // Last-resort size when nothing in the search fit. Bounded by searchHi so an
// image already smaller than this is never upscaled back up.
val fallbackWidth = minOf(100, searchHi).coerceAtLeast(1)
val fallbackHeight = (fallbackWidth / aspectRatio).toInt().coerceAtLeast(1)
val result = if (isGif) {
bestBytes = gifCompressor.compressGif( bestBytes = gifCompressor.compressGif(
context, context,
attachment, attachment,
@@ -624,55 +639,62 @@ open class MessageRepositoryImpl @Inject constructor(
origWidth, origWidth,
aspectRatio aspectRatio
) )
attachment.releaseResourceBytes()
} else {
while (lo <= hi) {
val midWidth = (lo + hi) / 2
val midHeight = (midWidth / aspectRatio).toInt().coerceAtLeast(1)
attempt++
val candidate = ImageUtils.getScaledImage(context, attachment.uri, midWidth, midHeight)
Timber.d(
"Compression attempt $attempt: ${
candidate.size / 1024
}/${maxBytes / 1024}Kb ($origWidth*$origHeight -> $midWidth*$midHeight)"
)
if (candidate.size <= maxBytes) {
bestBytes = candidate
lo = midWidth + 1
} else {
hi = midWidth - 1
}
// release the attachment hold on the image bytes so the GC can reclaim bestBytes ?: ImageUtils
attachment.releaseResourceBytes() .getScaledGif(context, attachment.uri, fallbackWidth, fallbackHeight)
} .also {
}
val result = bestBytes ?: run {
val minHeight = (100 / aspectRatio).toInt().coerceAtLeast(1)
if (isGif) {
ImageUtils.getScaledGif(context, attachment.uri, 100, minHeight).also {
Timber.w( Timber.w(
"GIF too large after compression: ${ "GIF too large after compression: ${
it.size / 1024 it.size / 1024
}Kb target ${maxBytes / 1024}Kb, sending anyway" }Kb target ${maxBytes / 1024}Kb, sending anyway"
) )
} }
} else { } else {
ImageUtils.getScaledImageWithQuality( val searchHiHeight = (searchHi / aspectRatio).toInt().coerceAtLeast(1)
context, attachment.uri, 100, minHeight, maxBytes // Decode once for the whole search. Every attempt below re-encodes that
).also { // bitmap from memory instead of re-reading and re-decoding the source file.
if (it.size > maxBytes) { val encoder = ImageUtils.ScaledImageEncoder
Timber.w( .open(context, attachment.uri, searchHi, searchHiHeight)
"Failed to compress image: ${
it.size / 1024 if (encoder == null) {
}Kb target ${maxBytes / 1024}Kb, sending anyway" Timber.w("Could not decode image, falling back to Glide scaling")
) ImageUtils.getScaledImage(context, attachment.uri, maxWidth, maxHeight)
} else encoder.use {
while (lo <= hi) {
val midWidth = (lo + hi) / 2
val midHeight = (midWidth / aspectRatio).toInt().coerceAtLeast(1)
attempt++
val candidate = encoder.encode(midWidth, midHeight)
Timber.d(
"Compression attempt $attempt: ${
candidate.size / 1024
}/${maxBytes / 1024}Kb ($origWidth*$origHeight -> $midWidth*$midHeight)"
)
if (candidate.size <= maxBytes) {
bestBytes = candidate
lo = midWidth + 1
} else {
hi = midWidth - 1
} }
} }
bestBytes ?: encoder
.encodeWithinBytes(fallbackWidth, fallbackHeight, maxBytes)
.also {
if (it.size > maxBytes) {
Timber.w(
"Failed to compress image: ${
it.size / 1024
}Kb target ${maxBytes / 1024}Kb, sending anyway"
)
}
}
} }
} }
// release the attachment hold on the image bytes so the GC can reclaim
attachment.releaseResourceBytes()
Timber.v( Timber.v(
"Compressed to ${result.size / 1024}Kb with target ${ "Compressed to ${result.size / 1024}Kb with target ${
maxBytes / 1024 maxBytes / 1024
@@ -20,12 +20,15 @@ package dev.octoshrimpy.quik.util
import android.content.Context import android.content.Context
import android.content.res.AssetFileDescriptor import android.content.res.AssetFileDescriptor
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.net.Uri import android.net.Uri
import android.provider.OpenableColumns import android.provider.OpenableColumns
import com.bumptech.glide.load.engine.DiskCacheStrategy import com.bumptech.glide.load.engine.DiskCacheStrategy
import com.bumptech.glide.request.RequestOptions import com.bumptech.glide.request.RequestOptions
import dev.octoshrimpy.quik.model.Attachment import dev.octoshrimpy.quik.model.Attachment
import java.io.ByteArrayOutputStream import java.io.ByteArrayOutputStream
import java.io.Closeable
object ImageUtils { object ImageUtils {
@@ -60,22 +63,87 @@ object ImageUtils {
.get() .get()
} }
fun getScaledImageWithQuality( /**
context: Context, * Decodes an image once and re-encodes it from memory at whatever size and quality the
uri: Uri, * caller asks for.
maxWidth: Int, *
maxHeight: Int, * Compression searches for a size that fits under the carrier's limit, so it encodes the
targetBytes: Int * same image many times. Going through [getScaledImage] for each attempt re-read and
): ByteArray { * re-decoded the source file every time, and decoding is by far the expensive part. Callers
var result = getScaledImage(context, uri, maxWidth, maxHeight, 90) * should [open] once per attachment and reuse the result for every attempt.
if (result.size <= targetBytes) return result *
// If the image is too large, then try to scale it down * Close it when done so the decoded bitmap can be reclaimed.
// then return when we are within targetBytes */
for (quality in 80 downTo 40 step 10) { class ScaledImageEncoder private constructor(private val source: Bitmap) : Closeable {
result = getScaledImage(context, uri, maxWidth, maxHeight, quality)
if (result.size <= targetBytes) return result val width: Int get() = source.width
val height: Int get() = source.height
fun encode(width: Int, height: Int, quality: Int = 90): ByteArray {
val target = if (width == source.width && height == source.height) source
else Bitmap.createScaledBitmap(source, width, height, true)
val out = ByteArrayOutputStream()
target.compress(Bitmap.CompressFormat.JPEG, quality, out)
if (target !== source) target.recycle()
return out.toByteArray()
}
/**
* Encode at [width]x[height], dropping quality until the result fits [targetBytes].
* Returns the smallest attempt if nothing fits, so the caller still has something to send.
*/
fun encodeWithinBytes(width: Int, height: Int, targetBytes: Int): ByteArray {
var result = encode(width, height, 90)
if (result.size <= targetBytes) return result
for (quality in 80 downTo 40 step 10) {
result = encode(width, height, quality)
if (result.size <= targetBytes) return result
}
return result
}
override fun close() = source.recycle()
companion object {
/**
* Returns null when the image cannot be decoded, so callers can fall back rather than
* dividing by a zero dimension.
*/
fun open(context: Context, uri: Uri, targetWidth: Int, targetHeight: Int): ScaledImageEncoder? {
val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
context.contentResolver.openInputStream(uri)?.use {
BitmapFactory.decodeStream(it, null, bounds)
}
if (bounds.outWidth <= 0 || bounds.outHeight <= 0) return null
// Decode no smaller than the largest size we'll be asked for, so re-encoding
// never has to upscale, but no larger than necessary either.
val opts = BitmapFactory.Options().apply {
inSampleSize = sampleSizeFor(bounds.outWidth, bounds.outHeight, targetWidth, targetHeight)
}
// With no carrier cap the decode target is the original size, which on a modern
// camera can be hundreds of megabytes. Returning null lets the caller fall back
// to Glide, which streams rather than holding the whole bitmap.
val bitmap = try {
context.contentResolver.openInputStream(uri)?.use {
BitmapFactory.decodeStream(it, null, opts)
}
} catch (e: OutOfMemoryError) {
null
} ?: return null
return ScaledImageEncoder(bitmap)
}
private fun sampleSizeFor(width: Int, height: Int, targetWidth: Int, targetHeight: Int): Int {
var sample = 1
while (width / (sample * 2) >= targetWidth && height / (sample * 2) >= targetHeight) {
sample *= 2
}
return sample
}
} }
return result
} }
/** /**