Switch to hardware bitmap in reader only if device can handle it

Closes #1460

app/src/main/java/eu/kanade/tachiyomi/data/coil/TachiyomiImageDecoder.kt

@@ -10,7 +10,6 @@ import coil3.decode.ImageSource
 import coil3.fetch.SourceFetchResult
 import coil3.request.Options
 import coil3.request.bitmapConfig
-import eu.kanade.tachiyomi.util.system.GLUtil
 import okio.BufferedSource
 import tachiyomi.core.common.util.system.ImageUtil
 import tachiyomi.decoder.ImageDecoder
@@ -46,10 +45,7 @@ class TachiyomiImageDecoder(private val resources: ImageSource, private val opti
 
         check(bitmap != null) { "Failed to decode image" }
 
-        if (
+        if (options.bitmapConfig == Bitmap.Config.HARDWARE && ImageUtil.canUseHardwareBitmap(bitmap)) {
-            options.bitmapConfig == Bitmap.Config.HARDWARE &&
-            maxOf(bitmap.width, bitmap.height) <= GLUtil.maxTextureSize
-        ) {
             val hwBitmap = bitmap.copy(Bitmap.Config.HARDWARE, false)
             if (hwBitmap != null) {
                 bitmap.recycle()

app/src/main/java/eu/kanade/tachiyomi/ui/reader/viewer/ReaderPageImageView.kt

@@ -295,32 +295,34 @@ open class ReaderPageImageView @JvmOverloads constructor(
                 isVisible = true
             }
             is BufferedSource -> {
-                if (!isWebtoon || !ImageUtil.canUseCoilToDecode(data)) {
+                if (!isWebtoon) {
+                    setHardwareConfig(ImageUtil.canUseHardwareBitmap(data))
                     setImage(ImageSource.inputStream(data.inputStream()))
                     isVisible = true
-                } else {
+                    return@apply
-                    val request = ImageRequest.Builder(context)
-                        .data(data)
-                        .memoryCachePolicy(CachePolicy.DISABLED)
-                        .diskCachePolicy(CachePolicy.DISABLED)
-                        .target(
-                            onSuccess = { result ->
-                                val image = result as BitmapImage
-                                setImage(ImageSource.bitmap(image.bitmap))
-                                isVisible = true
-                            },
-                            onError = {
-                                this@ReaderPageImageView.onImageLoadError()
-                            },
-                        )
-                        .size(ViewSizeResolver(this@ReaderPageImageView))
-                        .precision(Precision.INEXACT)
-                        .cropBorders(config.cropBorders)
-                        .customDecoder(true)
-                        .crossfade(false)
-                        .build()
-                    context.imageLoader.enqueue(request)
                 }
+
+                ImageRequest.Builder(context)
+                    .data(data)
+                    .memoryCachePolicy(CachePolicy.DISABLED)
+                    .diskCachePolicy(CachePolicy.DISABLED)
+                    .target(
+                        onSuccess = { result ->
+                            val image = result as BitmapImage
+                            setImage(ImageSource.bitmap(image.bitmap))
+                            isVisible = true
+                        },
+                        onError = {
+                            onImageLoadError()
+                        },
+                    )
+                    .size(ViewSizeResolver(this@ReaderPageImageView))
+                    .precision(Precision.INEXACT)
+                    .cropBorders(config.cropBorders)
+                    .customDecoder(true)
+                    .crossfade(false)
+                    .build()
+                    .let(context.imageLoader::enqueue)
             }
             else -> {
                 throw IllegalArgumentException("Not implemented for class ${data::class.simpleName}")

core/common/src/main/kotlin/tachiyomi/core/common/util/system/ImageUtil.kt

@@ -310,9 +310,18 @@ object ImageUtil {
         val bottomOffset = topOffset + splitHeight
     }
 
-    fun canUseCoilToDecode(imageSource: BufferedSource): Boolean {
+    fun canUseHardwareBitmap(bitmap: Bitmap): Boolean {
-        val options = extractImageOptions(imageSource)
+        return canUseHardwareBitmap(bitmap.width, bitmap.height)
-        return maxOf(options.outWidth, options.outHeight) <= GLUtil.maxTextureSize
+    }
+
+    fun canUseHardwareBitmap(imageSource: BufferedSource): Boolean {
+        return with(extractImageOptions(imageSource)) {
+            canUseHardwareBitmap(outWidth, outHeight)
+        }
+    }
+
+    private fun canUseHardwareBitmap(width: Int, height: Int): Boolean {
+        return maxOf(width, height) <= GLUtil.maxTextureSize
     }
 
     /**

gradle/libs.versions.toml

@@ -48,7 +48,7 @@ coil-gif = { module = "io.coil-kt.coil3:coil-gif" }
 coil-compose = { module = "io.coil-kt.coil3:coil-compose" }
 coil-network-okhttp = { module = "io.coil-kt.coil3:coil-network-okhttp" }
 
-subsamplingscaleimageview = "com.github.tachiyomiorg:subsampling-scale-image-view:b8e1b0ed2b"
+subsamplingscaleimageview = "com.github.tachiyomiorg:subsampling-scale-image-view:66e0db195d"
 image-decoder = "com.github.tachiyomiorg:image-decoder:41c059e540"
 
 natural-comparator = "com.github.gpanther:java-nat-sort:natural-comparator-1.1"