Fix webtoon scroll stutter between pages

Closes #4026

Co-authored-by: Matheus William <matheuswr89@outlook.com>
This commit is contained in:
AntsyLich
2026-10-12 00:29:08 +06:00
parent 039138ce99
commit b5856135c5
6 changed files with 266 additions and 69 deletions
@@ -1,6 +1,7 @@
package eu.kanade.tachiyomi.data.coil
import android.graphics.Bitmap
import android.graphics.Matrix
import androidx.core.graphics.createBitmap
import androidx.core.graphics.scale
import ca.mpreg.imagedecoder.ImageDecoder
@@ -14,8 +15,12 @@ import coil3.decode.Decoder
import coil3.decode.ImageSource
import coil3.fetch.SourceFetchResult
import coil3.request.Options
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withPermit
import okio.BufferedSource
import tachiyomi.core.common.util.system.ImageUtil
import kotlin.math.min
import kotlin.math.sqrt
/**
* A [Decoder] that uses [ImageDecoder] to decode image formats not supported
@@ -43,7 +48,22 @@ class ImageDecoder(private val resources: ImageSource, private val options: Opti
override fun draw(canvas: Canvas) {}
}
/**
* A page cut into immutable strips of about [STRIP_BYTES] each. The renderer uploads an
* immutable bitmap only when it is drawn, so only the strips on screen reach the GPU instead of
* the whole page as one texture.
*/
class StripsImage(val strips: List<Bitmap>) : Image {
override val size: Long = strips.sumOf { it.allocationByteCount.toLong() }
override val width: Int = strips.firstOrNull()?.width ?: 0
override val height: Int = strips.sumOf { it.height }
override val shareable: Boolean get() = false
override fun draw(canvas: Canvas) {}
}
override suspend fun decode(): DecodeResult {
if (options.webtoonStrips) return decodeStrips()
val res = resources.source().use {
ImageDecoder.open(it.inputStream()).use { dec ->
DecodeResultImage(
@@ -105,9 +125,67 @@ class ImageDecoder(private val resources: ImageSource, private val options: Opti
)
}
/**
* Copies bands of rows straight from the native frame into strips, so the page never exists as
* one Java bitmap on top of the frame.
*
* Strips keep the resolution a power-of-two sample size leaves, like the other paths, so zooming
* in still shows the page's detail, unless that would make the page take more than
* [MAX_PAGE_BYTES]. They are never narrower than the view, so the page stays sharp unzoomed.
*/
private suspend fun decodeStrips(): DecodeResult = stripDecodes.withPermit {
val (frame, isHdr) = resources.source().use {
ImageDecoder.open(it.inputStream()).use { dec -> dec.decodeNext() to dec.isHdr }
}
frame.use {
val config = if (isHdr) Bitmap.Config.RGBA_F16 else Bitmap.Config.ARGB_8888
val bytesPerPixel = if (isHdr) 8 else 4
val rowBytes = frame.width * bytesPerPixel
val viewWidth = options.size.widthPx(options.scale) { frame.width }
val sampleSize = DecodeUtils.calculateInSampleSize(
srcWidth = frame.width,
srcHeight = frame.height,
dstWidth = viewWidth,
dstHeight = options.size.heightPx(options.scale) { frame.height },
scale = options.scale,
)
val budgetWidth = sqrt(MAX_PAGE_BYTES.toDouble() / bytesPerPixel * frame.width / frame.height).toInt()
val stripWidth = maxOf(viewWidth, min(frame.width / sampleSize, budgetWidth))
// Older GPUs can't draw a texture wider than this
.coerceAtMost(MAX_STRIP_WIDTH)
.coerceIn(1, frame.width)
val scale = stripWidth.toFloat() / frame.width
// Strips of about the same size in bytes, so each takes about as long to upload
val stripRows = (STRIP_BYTES / (stripWidth * bytesPerPixel)).coerceAtLeast(1)
val bandRows = (stripRows / scale).toInt().coerceIn(1, frame.height)
val matrix = Matrix().apply { setScale(scale, scale) }
val band = createBitmap(frame.width, bandRows, config)
val strips = (0..<frame.height step bandRows).map { top ->
val rows = min(bandRows, frame.height - top)
if (rows != band.height) band.reconfigure(frame.width, rows, config)
band.copyPixelsFromBuffer(
frame.image.duplicate().apply {
position(top * rowBytes)
limit((top + rows) * rowBytes)
},
)
val strip = if (stripWidth < frame.width) {
Bitmap.createBitmap(band, 0, 0, frame.width, rows, matrix, true)
} else {
band
}
// createBitmap returns a mutable bitmap despite its docs, and copy is the only way to an immutable one
strip.copy(config, false).also { if (strip !== band) strip.recycle() }
}
band.recycle()
DecodeResult(image = StripsImage(strips), isSampled = stripWidth < frame.width)
}
}
class Factory : Decoder.Factory {
override fun create(result: SourceFetchResult, options: Options, imageLoader: ImageLoader): Decoder? {
return if (options.newDecoder || options.customDecoder || isApplicable(result.source.source())) {
return if (options.newDecoder || options.webtoonStrips || isApplicable(result.source.source())) {
ImageDecoder(result.source, options)
} else {
null
@@ -134,3 +212,12 @@ class ImageDecoder(private val resources: ImageSource, private val options: Opti
override fun hashCode() = javaClass.hashCode()
}
}
private const val STRIP_BYTES = 4 * 1024 * 1024
private const val MAX_PAGE_BYTES = 128 * 1024 * 1024
private const val MAX_STRIP_WIDTH = 4096
// Each decode holds the whole native frame until its strips are copied, and the reader loads pages ahead in parallel
private val stripDecodes = Semaphore(1)
@@ -34,14 +34,14 @@ val Options.cropBorders: Boolean
private val cropBordersKey = Extras.Key(default = false)
fun ImageRequest.Builder.customDecoder(enable: Boolean) = apply {
extras[customDecoderKey] = enable
fun ImageRequest.Builder.webtoonStrips(enable: Boolean) = apply {
extras[webtoonStripsKey] = enable
}
val Options.customDecoder: Boolean
get() = getExtra(customDecoderKey)
val Options.webtoonStrips: Boolean
get() = getExtra(webtoonStripsKey)
private val customDecoderKey = Extras.Key(default = false)
private val webtoonStripsKey = Extras.Key(default = false)
fun ImageRequest.Builder.newDecoder(enable: Boolean) = apply {
extras[newDecoderKey] = enable
@@ -11,6 +11,7 @@ import android.view.GestureDetector
import android.view.MotionEvent
import android.view.View
import android.view.ViewGroup.LayoutParams.MATCH_PARENT
import android.view.ViewGroup.LayoutParams.WRAP_CONTENT
import android.widget.FrameLayout
import androidx.annotation.AttrRes
import androidx.annotation.CallSuper
@@ -18,11 +19,11 @@ import androidx.annotation.StyleRes
import androidx.appcompat.widget.AppCompatImageView
import androidx.core.os.postDelayed
import androidx.core.view.isVisible
import coil3.BitmapImage
import coil3.asDrawable
import coil3.dispose
import coil3.imageLoader
import coil3.request.CachePolicy
import coil3.request.Disposable
import coil3.request.ImageRequest
import coil3.request.crossfade
import coil3.size.Precision
@@ -33,9 +34,10 @@ import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView.EASE_IN_OUT
import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView.EASE_OUT_QUAD
import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView.SCALE_TYPE_CENTER_INSIDE
import com.github.chrisbanes.photoview.PhotoView
import eu.kanade.tachiyomi.data.coil.ImageDecoder
import eu.kanade.tachiyomi.data.coil.cropBorders
import eu.kanade.tachiyomi.data.coil.customDecoder
import eu.kanade.tachiyomi.ui.reader.viewer.webtoon.WebtoonSubsamplingImageView
import eu.kanade.tachiyomi.data.coil.webtoonStrips
import eu.kanade.tachiyomi.ui.reader.viewer.webtoon.WebtoonStripImageView
import eu.kanade.tachiyomi.util.system.animatorDurationScale
import eu.kanade.tachiyomi.util.view.isVisibleOnScreen
import okio.BufferedSource
@@ -45,7 +47,7 @@ import okio.BufferedSource
*
* Animated image will be drawn by [PhotoView] while [SubsamplingScaleImageView] will take non-animated image.
*
* @param isWebtoon if true, [WebtoonSubsamplingImageView] will be used instead of [SubsamplingScaleImageView]
* @param isWebtoon if true, [WebtoonStripImageView] will be used instead of [SubsamplingScaleImageView]
* and [AppCompatImageView] will be used instead of [PhotoView]
*/
open class ReaderPageImageView @JvmOverloads constructor(
@@ -58,6 +60,8 @@ open class ReaderPageImageView @JvmOverloads constructor(
private var pageView: View? = null
private var stripRequest: Disposable? = null
private var config: Config? = null
var onImageLoaded: (() -> Unit)? = null
@@ -155,18 +159,26 @@ open class ReaderPageImageView @JvmOverloads constructor(
if (isAnimated) {
prepareAnimatedImageView()
setAnimatedImage(source, config)
} else if (isWebtoon) {
prepareStripImageView()
setStripImage(source, config)
} else {
prepareNonAnimatedImageView()
setNonAnimatedImage(source, config)
}
}
fun recycle() = pageView?.let {
when (it) {
is SubsamplingScaleImageView -> it.recycle()
is AppCompatImageView -> it.dispose()
fun recycle() {
stripRequest?.dispose()
stripRequest = null
pageView?.let {
when (it) {
is SubsamplingScaleImageView -> it.recycle()
is AppCompatImageView -> it.dispose()
is WebtoonStripImageView -> it.recycle()
}
it.isVisible = false
}
it.isVisible = false
}
/**
@@ -227,11 +239,7 @@ open class ReaderPageImageView @JvmOverloads constructor(
if (pageView is SubsamplingScaleImageView) return
removeView(pageView)
pageView = if (isWebtoon) {
WebtoonSubsamplingImageView(context)
} else {
SubsamplingScaleImageView(context)
}.apply {
pageView = SubsamplingScaleImageView(context).apply {
setDoubleTapZoomStyle(SubsamplingScaleImageView.ZOOM_FOCUS_CENTER)
setPanLimit(SubsamplingScaleImageView.PAN_LIMIT_INSIDE)
setMinimumTileDpi(180)
@@ -292,35 +300,8 @@ open class ReaderPageImageView @JvmOverloads constructor(
isVisible = true
}
is BufferedSource -> {
if (!isWebtoon) {
setImage(ImageSource.inputStream(data.inputStream()))
isVisible = true
return@apply
}
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
},
)
.listener(
onError = { _, result ->
onImageLoadError(result.throwable)
},
)
.size(ViewSizeResolver(this@ReaderPageImageView))
.precision(Precision.INEXACT)
.cropBorders(config.cropBorders)
.customDecoder(true)
.crossfade(false)
.build()
.let(context.imageLoader::enqueue)
setImage(ImageSource.inputStream(data.inputStream()))
isVisible = true
}
else -> {
throw IllegalArgumentException("Not implemented for class ${data::class.simpleName}")
@@ -328,6 +309,51 @@ open class ReaderPageImageView @JvmOverloads constructor(
}
}
private fun prepareStripImageView() {
if (pageView is WebtoonStripImageView) return
removeView(pageView)
pageView = WebtoonStripImageView(context)
addView(pageView, MATCH_PARENT, WRAP_CONTENT)
}
private fun setStripImage(data: BufferedSource, config: Config) {
val view = pageView as? WebtoonStripImageView ?: return
view.onReload = { requestStrips(view, data, config, isReload = true) }
requestStrips(view, data, config, isReload = false)
}
private fun requestStrips(view: WebtoonStripImageView, data: BufferedSource, config: Config, isReload: Boolean) {
// A recycled view is reused for another page, where a request still running for the old one must not land
stripRequest?.dispose()
stripRequest = ImageRequest.Builder(context)
// Peeking leaves the data whole for decoding again after the strips were freed off screen
.data(data.peek())
.memoryCachePolicy(CachePolicy.DISABLED)
.diskCachePolicy(CachePolicy.DISABLED)
.target(
onSuccess = { result ->
view.setImage(result as ImageDecoder.StripsImage)
if (!isReload) {
view.isVisible = true
onImageLoaded()
}
},
)
.listener(
onError = { _, result ->
onImageLoadError(result.throwable)
},
)
.size(ViewSizeResolver(this))
.precision(Precision.INEXACT)
.cropBorders(config.cropBorders)
.webtoonStrips(true)
.crossfade(false)
.build()
.let(context.imageLoader::enqueue)
}
private fun prepareAnimatedImageView() {
if (pageView is AppCompatImageView) return
removeView(pageView)
@@ -0,0 +1,103 @@
package eu.kanade.tachiyomi.ui.reader.viewer.webtoon
import android.content.Context
import android.graphics.Bitmap
import android.graphics.Canvas
import android.graphics.Paint
import android.graphics.Rect
import android.view.MotionEvent
import android.view.View
import eu.kanade.tachiyomi.data.coil.ImageDecoder
import kotlin.math.roundToInt
/**
* Draws a webtoon page as a stack of strips, so a very tall page never becomes one huge GPU texture.
*
* Ignores all touch events, because the webtoon viewer handles all the gestures.
*/
class WebtoonStripImageView(context: Context) : View(context) {
private var strips: List<Bitmap> = emptyList()
private var imageWidth = 0
private var imageHeight = 0
private val paint = Paint(Paint.FILTER_BITMAP_FLAG)
private val clipRect = Rect()
private val dstRect = Rect()
/** Decodes the page again after its strips were freed off screen. */
var onReload: (() -> Unit)? = null
private var isReleasedOffScreen = false
fun setImage(image: ImageDecoder.StripsImage) {
releaseStrips()
isReleasedOffScreen = false
strips = image.strips
imageWidth = image.width
imageHeight = image.height
requestLayout()
invalidate()
}
fun recycle() {
releaseStrips()
isReleasedOffScreen = false
onReload = null
imageWidth = 0
imageHeight = 0
requestLayout()
}
// The viewer keeps a few pages off screen without recycling them, which adds up for huge pages.
// The size stays, so the layout doesn't move while the page decodes again.
override fun onDetachedFromWindow() {
super.onDetachedFromWindow()
if (strips.sumOf { it.allocationByteCount.toLong() } > LARGE_PAGE_BYTES) {
releaseStrips()
isReleasedOffScreen = true
}
}
override fun onAttachedToWindow() {
super.onAttachedToWindow()
if (isReleasedOffScreen) {
isReleasedOffScreen = false
onReload?.invoke()
}
}
// A page's strips can be hundreds of MB, which would otherwise wait for a garbage collection to be freed
private fun releaseStrips() {
val released = strips
strips = emptyList()
released.forEach(Bitmap::recycle)
}
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
val width = MeasureSpec.getSize(widthMeasureSpec)
val height = if (imageWidth > 0) (width.toLong() * imageHeight / imageWidth).toInt() else 0
setMeasuredDimension(width, height)
}
override fun onDraw(canvas: Canvas) {
if (imageWidth <= 0) return
canvas.getClipBounds(clipRect)
val scale = width.toFloat() / imageWidth
var srcTop = 0
for (strip in strips) {
val top = (srcTop * scale).roundToInt()
srcTop += strip.height
val bottom = (srcTop * scale).roundToInt()
if (bottom <= clipRect.top) continue
if (top >= clipRect.bottom) break
dstRect.set(0, top, width, bottom)
canvas.drawBitmap(strip, null, dstRect, paint)
}
}
override fun onTouchEvent(event: MotionEvent): Boolean = false
}
private const val LARGE_PAGE_BYTES = 64L * 1024 * 1024
@@ -1,20 +0,0 @@
package eu.kanade.tachiyomi.ui.reader.viewer.webtoon
import android.content.Context
import android.util.AttributeSet
import android.view.MotionEvent
import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
/**
* Implementation of subsampling scale image view that ignores all touch events, because the
* webtoon viewer handles all the gestures.
*/
class WebtoonSubsamplingImageView @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null,
) : SubsamplingScaleImageView(context, attrs) {
override fun onTouchEvent(event: MotionEvent): Boolean {
return false
}
}