Update androidx.paging to v3.5.3 (#4099)

Keeps the changelog entries that f45d0ad31d removed for the release under
Unreleased, since main still has the WebGPU reader and the new image
decoder.

(cherry picked from commit 9612d955db)

CHANGELOG.md

@@ -11,6 +11,32 @@ The format is a modified version of [Keep a Changelog](https://keepachangelog.co
 - `Other` - for technical stuff.
 
 ## [Unreleased]
+### Added
+- Add experimental high quality reader renderer (Settings → Advanced → Use high quality renderer) with better image scaling, page transition animations, dual page view and display cutout handling ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3388](https://github.com/mihonapp/mihon/pull/3388))
+  - Match background and transition page colors to the old reader ([@AntsyLich](https://github.com/AntsyLich)) ([#3765](https://github.com/mihonapp/mihon/pull/3765))
+  - Support the Fit width, Fit height and Original size scale types and the zoom start position ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3801](https://github.com/mihonapp/mihon/pull/3801))
+  - Fix preloading and navigation across chapters, and right-to-left navigation ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3823](https://github.com/mihonapp/mihon/pull/3823))
+  - Add a "None" page transition and fix the background color of animated images ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3843](https://github.com/mihonapp/mihon/pull/3843))
+  - Improve transition and error pages, dual page animations and border cropping ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3852](https://github.com/mihonapp/mihon/pull/3852))
+  - Fix navigation directions and long strip bounds, and fade in loaded pages ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3870](https://github.com/mihonapp/mihon/pull/3870))
+  - Add a "Page flip" transition, a long strip minimum width setting and separate dual page settings, and show wide pages on their own in dual page view ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3886](https://github.com/mihonapp/mihon/pull/3886))
+  - Fix freezes and running out of memory when jumping between pages with the slider ([@Danidukiyu](https://github.com/Danidukiyu)) ([#3872](https://github.com/mihonapp/mihon/pull/3872))
+  - Add HDR, ICC color profile and EXIF orientation support ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3933](https://github.com/mihonapp/mihon/pull/3933))
+  - Add a page gap setting for long strip with gaps and a "Disable zoom out" setting for long strip modes ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3933](https://github.com/mihonapp/mihon/pull/3933))
+  - Fix a crash on Android 15 and long strip progress and background color ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3949](https://github.com/mihonapp/mihon/pull/3949))
+  - Keep the reader menu open while moving through pages with the slider ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3956](https://github.com/mihonapp/mihon/pull/3956))
+  - Show pages progressively while they download ([@wwww-wwww](https://github.com/wwww-wwww)) ([#4023](https://github.com/mihonapp/mihon/pull/4023))
+  - Lower memory use for animated images and support cropping borders in long strip ([@wwww-wwww](https://github.com/wwww-wwww)) ([#4029](https://github.com/mihonapp/mihon/pull/4029))
+  - Pair more wide pages in dual page view by comparing them with neighbouring pages ([@wwww-wwww](https://github.com/wwww-wwww)) ([#4051](https://github.com/mihonapp/mihon/pull/4051))
+
+### Changed
+- Use a new decoder for images Android can't decode itself, like AVIF, JPEG XL and HEIF, and support JPEG 2000 images ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3786](https://github.com/mihonapp/mihon/pull/3786))
+
+### Improved
+- Create and restore backups faster and with less memory ([@NGB-Was-Taken](https://github.com/NGB-Was-Taken), [@AntsyLich](https://github.com/AntsyLich))
+
+### Removed
+- Remove "Custom hardware bitmap threshold" and "Custom display profile" advanced settings ([@wwww-wwww](https://github.com/wwww-wwww)) ([#3786](https://github.com/mihonapp/mihon/pull/3786))
 
 ## [v0.21.2] - 2026-10-13
 ### Fixed

app/build.gradle.kts

@@ -292,6 +292,8 @@ dependencies {
     }
     implementation(libs.image.decoder)
 
+    implementation(libs.webgpuviewer)
+
     // UI libraries
     implementation(libs.material)
     implementation(libs.flexibleAdapter)

app/src/main/java/eu/kanade/domain/base/BasePreferences.kt

@@ -5,7 +5,6 @@ import dev.icerock.moko.resources.StringResource
 import dev.zacsweers.metro.AppScope
 import dev.zacsweers.metro.Inject
 import dev.zacsweers.metro.SingleIn
-import eu.kanade.tachiyomi.util.system.GLUtil
 import tachiyomi.core.common.preference.Preference
 import tachiyomi.core.common.preference.PreferenceStore
 import tachiyomi.i18n.MR
@@ -38,12 +37,7 @@ class BasePreferences(
         PRIVATE(MR.strings.ext_installer_private, false),
     }
 
-    val displayProfile: Preference<String> = preferenceStore.getString("pref_display_profile_key", "")
-
-    val hardwareBitmapThreshold: Preference<Int> = preferenceStore.getInt(
-        "pref_hardware_bitmap_threshold",
-        GLUtil.SAFE_TEXTURE_LIMIT,
-    )
+    val highQualityRenderer: Preference<Boolean> = preferenceStore.getBoolean("pref_high_quality_renderer_key", false)
 
     val installationId: Preference<String> = preferenceStore.getString(Preference.appStateKey("installation_id"), "")
 

app/src/main/java/eu/kanade/presentation/manga/components/MangaCoverDialog.kt

@@ -18,6 +18,7 @@ import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -25,7 +26,9 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.unit.DpOffset
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.viewinterop.AndroidView
@@ -33,16 +36,27 @@ import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
 import androidx.core.graphics.drawable.toDrawable
 import androidx.core.view.updatePadding
+import ca.mpreg.webgpuviewer.renderer.GainmapInput
+import ca.mpreg.webgpuviewer.renderer.Image
+import ca.mpreg.webgpuviewer.viewer.ImagePage
+import ca.mpreg.webgpuviewer.viewer.ImageViewer
+import ca.mpreg.webgpuviewer.viewer.ImageViewerState
 import coil3.asDrawable
 import coil3.imageLoader
 import coil3.request.CachePolicy
 import coil3.request.ImageRequest
+import coil3.request.SuccessResult
 import coil3.size.Size
 import eu.kanade.presentation.components.AppBar
 import eu.kanade.presentation.components.AppBarActions
 import eu.kanade.presentation.components.DropdownMenu
 import eu.kanade.presentation.manga.EditCoverAction
+import eu.kanade.tachiyomi.data.coil.ImageDecoder
+import eu.kanade.tachiyomi.data.coil.newDecoder
 import eu.kanade.tachiyomi.ui.reader.viewer.ReaderPageImageView
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import mihon.app.di.appGraph
 import mihon.icons.materialsymbols.MaterialSymbols
 import mihon.icons.materialsymbols.rounded.Close
 import mihon.icons.materialsymbols.rounded.Edit
@@ -65,6 +79,9 @@ fun MangaCoverDialog(
     onEditClick: ((EditCoverAction) -> Unit)?,
     onDismissRequest: () -> Unit,
 ) {
+    val useNewRenderer = LocalContext.current.appGraph.basePreferences.highQualityRenderer.get()
+    val view = LocalView.current
+
     Dialog(
         onDismissRequest = onDismissRequest,
         properties = DialogProperties(
@@ -151,6 +168,59 @@ fun MangaCoverDialog(
                 }
             },
         ) { contentPadding ->
+            if (useNewRenderer) {
+                val state = remember(manga) { ImageViewerState() }
+                LaunchedEffect(manga) {
+                    val request = ImageRequest.Builder(view.context)
+                        .data(manga)
+                        .size(Size.ORIGINAL)
+                        .memoryCachePolicy(CachePolicy.DISABLED)
+                        .newDecoder(true)
+                        .build()
+                    val result = view.context.imageLoader.execute(request) as? SuccessResult ?: return@LaunchedEffect
+                    val res = result.image as? ImageDecoder.DecodeResultImage ?: return@LaunchedEffect
+                    // Held, then freed, around the upload: its buffer alone doesn't keep
+                    // the frame's native pixels alive.
+                    val page = res.frame.use {
+                        withContext(Dispatchers.Default) {
+                            ImagePage.ImageSingle(
+                                Image(
+                                    res.image,
+                                    res.width,
+                                    res.height,
+                                    createMipMaps = true,
+                                    backgroundColor = 0,
+                                    hdr = res.isHdr,
+                                    hdrHeadroom = res.hdrHeadroom,
+                                    gainmap = res.gainmap?.let {
+                                        GainmapInput(
+                                            pixels = it.pixels,
+                                            width = it.width,
+                                            height = it.height,
+                                            channels = it.channels,
+                                            gamma = it.gamma,
+                                            minContentBoost = it.minContentBoost,
+                                            maxContentBoost = it.maxContentBoost,
+                                            offsetSdr = it.offsetSdr,
+                                            offsetHdr = it.offsetHdr,
+                                        )
+                                    },
+                                ),
+                            )
+                        }
+                    }
+                    state.apply {
+                        fetchPage = { index ->
+                            if (index == 0) page else null
+                        }
+                        invalidate()
+                    }
+                }
+
+                ImageViewer(state = state)
+                return@Scaffold
+            }
+
             val statusBarPaddingPx = with(LocalDensity.current) { contentPadding.calculateTopPadding().roundToPx() }
             val bottomPaddingPx = with(LocalDensity.current) { contentPadding.calculateBottomPadding().roundToPx() }
 

app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsAdvancedScreen.kt

@@ -6,8 +6,6 @@ import android.content.Intent
 import android.provider.Settings
 import android.webkit.WebStorage
 import android.webkit.WebView
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
@@ -43,7 +41,6 @@ import eu.kanade.tachiyomi.network.PREF_DOH_QUAD101
 import eu.kanade.tachiyomi.network.PREF_DOH_QUAD9
 import eu.kanade.tachiyomi.network.PREF_DOH_SHECAN
 import eu.kanade.tachiyomi.ui.more.OnboardingScreen
-import eu.kanade.tachiyomi.util.system.GLUtil
 import eu.kanade.tachiyomi.util.system.isReleaseBuildType
 import eu.kanade.tachiyomi.util.system.isShizukuInstalled
 import eu.kanade.tachiyomi.util.system.powerManager
@@ -56,7 +53,6 @@ import kotlinx.coroutines.withContext
 import logcat.LogPriority
 import mihon.app.di.appGraph
 import okhttp3.Headers
-import tachiyomi.core.common.util.system.ImageUtil
 import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.library.service.LibraryPreferences
 import tachiyomi.i18n.MR
@@ -337,43 +333,12 @@ object SettingsAdvancedScreen : SearchableSettings {
         basePreferences: BasePreferences,
     ): Preference.PreferenceGroup {
         val context = LocalContext.current
-        val chooseColorProfile = rememberLauncherForActivityResult(
-            contract = ActivityResultContracts.OpenDocument(),
-        ) { uri ->
-            uri?.let {
-                val flags = Intent.FLAG_GRANT_READ_URI_PERMISSION
-                context.contentResolver.takePersistableUriPermission(uri, flags)
-                basePreferences.displayProfile.set(uri.toString())
-            }
-        }
         return Preference.PreferenceGroup(
             title = stringResource(MR.strings.pref_category_reader),
             preferenceItems = listOf(
-                Preference.PreferenceItem.ListPreference(
-                    preference = basePreferences.hardwareBitmapThreshold,
-                    entries = GLUtil.CUSTOM_TEXTURE_LIMIT_OPTIONS
-                        .mapIndexed { index, option ->
-                            val display = if (index == 0) {
-                                stringResource(MR.strings.pref_hardware_bitmap_threshold_default, option)
-                            } else {
-                                option.toString()
-                            }
-                            option to display
-                        }
-                        .toMap(),
-                    title = stringResource(MR.strings.pref_hardware_bitmap_threshold),
-                    subtitleProvider = { value, options ->
-                        stringResource(MR.strings.pref_hardware_bitmap_threshold_summary, options[value].orEmpty())
-                    },
-                    visible = !ImageUtil.HARDWARE_BITMAP_UNSUPPORTED &&
-                        GLUtil.DEVICE_TEXTURE_LIMIT > GLUtil.SAFE_TEXTURE_LIMIT,
-                ),
-                Preference.PreferenceItem.TextPreference(
-                    title = stringResource(MR.strings.pref_display_profile),
-                    subtitle = basePreferences.displayProfile.get(),
-                    onClick = {
-                        chooseColorProfile.launch(arrayOf("*/*"))
-                    },
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = basePreferences.highQualityRenderer,
+                    title = stringResource(MR.strings.pref_high_quality_renderer),
                 ),
             ),
         )

app/src/main/java/eu/kanade/presentation/reader/settings/ReadingModePage.kt

@@ -15,6 +15,7 @@ import eu.kanade.tachiyomi.ui.reader.setting.ReaderOrientation
 import eu.kanade.tachiyomi.ui.reader.setting.ReaderPreferences
 import eu.kanade.tachiyomi.ui.reader.setting.ReaderSettingsViewModel
 import eu.kanade.tachiyomi.ui.reader.setting.ReadingMode
+import eu.kanade.tachiyomi.ui.reader.viewer.webgpu.WebGpuViewer
 import eu.kanade.tachiyomi.ui.reader.viewer.webtoon.WebtoonViewer
 import mihon.app.di.appGraph
 import tachiyomi.i18n.MR
@@ -30,6 +31,7 @@ import java.text.NumberFormat
 internal fun ColumnScope.ReadingModePage(viewModel: ReaderSettingsViewModel) {
     HeadingItem(MR.strings.pref_category_for_this_series)
     val manga by viewModel.mangaFlow.collectAsState()
+    val viewer by viewModel.viewerFlow.collectAsState()
 
     val readingMode = remember(manga) { ReadingMode.fromPreference(manga?.readingMode?.toInt()) }
     SettingsChipRow(MR.strings.pref_category_reading_mode) {
@@ -42,6 +44,62 @@ internal fun ColumnScope.ReadingModePage(viewModel: ReaderSettingsViewModel) {
         }
     }
 
+    if (viewer is WebGpuViewer) {
+        val default = LocalContext.current.appGraph.readerPreferences.defaultReadingMode.get()
+        val resolved = ReadingMode.fromPreference(
+            when {
+                readingMode == ReadingMode.DEFAULT -> default
+                else -> manga?.readingMode?.toInt() ?: default
+            },
+        )
+        if (resolved == ReadingMode.LEFT_TO_RIGHT || resolved == ReadingMode.RIGHT_TO_LEFT) {
+            val dualPageView by viewModel.preferences.dualPageView.collectAsState()
+            SettingsChipRow(MR.strings.pref_dual_page_view) {
+                ReaderPreferences.DualPageView.entries.map {
+                    FilterChip(
+                        selected = it == dualPageView,
+                        onClick = { viewModel.preferences.dualPageView.set(it) },
+                        label = { Text(stringResource(it.titleRes)) },
+                    )
+                }
+            }
+        }
+
+        if (resolved == ReadingMode.WEBTOON || resolved == ReadingMode.CONTINUOUS_VERTICAL) {
+            val numberFormat = remember { NumberFormat.getPercentInstance() }
+            val continuousMinWidth by viewModel.preferences.continuousMinWidth.collectAsState()
+            SliderItem(
+                value = continuousMinWidth,
+                valueRange = ReaderPreferences.let { 1..100 },
+                label = stringResource(MR.strings.pref_continuous_minwidth),
+                valueString = numberFormat.format(continuousMinWidth / 100f),
+                onChange = {
+                    viewModel.preferences.continuousMinWidth.set(it)
+                },
+                pillColor = MaterialTheme.colorScheme.surfaceContainerHighest,
+            )
+
+            if (resolved == ReadingMode.CONTINUOUS_VERTICAL) {
+                val continuousGap by viewModel.preferences.continuousGap.collectAsState()
+                SliderItem(
+                    value = continuousGap,
+                    valueRange = ReaderPreferences.let { 1..100 },
+                    label = stringResource(MR.strings.pref_continuous_gap),
+                    valueString = numberFormat.format(continuousGap / 100f),
+                    onChange = {
+                        viewModel.preferences.continuousGap.set(it)
+                    },
+                    pillColor = MaterialTheme.colorScheme.surfaceContainerHighest,
+                )
+            }
+
+            CheckboxItem(
+                label = stringResource(MR.strings.pref_webtoon_disable_zoom_out),
+                pref = viewModel.preferences.webtoonDisableZoomOut,
+            )
+        }
+    }
+
     val orientation = remember(manga) { ReaderOrientation.fromPreference(manga?.readerOrientation?.toInt()) }
     SettingsChipRow(MR.strings.rotation_type) {
         ReaderOrientation.entries.map {
@@ -53,11 +111,10 @@ internal fun ColumnScope.ReadingModePage(viewModel: ReaderSettingsViewModel) {
         }
     }
 
-    val viewer by viewModel.viewerFlow.collectAsState()
-    if (viewer is WebtoonViewer) {
-        WebtoonViewerSettings(viewModel)
-    } else {
-        PagerViewerSettings(viewModel)
+    when (viewer) {
+        is WebtoonViewer -> WebtoonViewerSettings(viewModel)
+        is WebGpuViewer -> WebGpuViewerSettings(viewModel)
+        else -> PagerViewerSettings(viewModel)
     }
 }
 
@@ -235,3 +292,120 @@ private fun ColumnScope.TapZonesItems(
         }
     }
 }
+
+@Composable
+private fun ColumnScope.WebGpuViewerSettings(viewModel: ReaderSettingsViewModel) {
+    HeadingItem(MR.strings.webgpu_viewer)
+
+    val manga by viewModel.mangaFlow.collectAsState()
+    val viewer by viewModel.viewerFlow.collectAsState()
+
+    val readingMode = remember(manga) { ReadingMode.fromPreference(manga?.readingMode?.toInt()) }
+    val default = LocalContext.current.appGraph.readerPreferences.defaultReadingMode.get()
+    val resolved = ReadingMode.fromPreference(
+        when {
+            readingMode == ReadingMode.DEFAULT -> default
+            else -> manga?.readingMode?.toInt() ?: default
+        },
+    )
+    val isDual = (viewer as? WebGpuViewer)?.isDualPageMode() == true
+
+    val navigationModePager by viewModel.preferences.navigationModePager.collectAsState()
+    val pagerNavInverted by viewModel.preferences.pagerNavInverted.collectAsState()
+    TapZonesItems(
+        selected = navigationModePager,
+        onSelect = viewModel.preferences.navigationModePager::set,
+        invertMode = pagerNavInverted,
+        onSelectInvertMode = viewModel.preferences.pagerNavInverted::set,
+    )
+
+    if (isDual) {
+        val transitionAnimation by viewModel.preferences.transitionAnimationDual.collectAsState()
+        SettingsChipRow(MR.strings.pref_transition_animation_dual) {
+            (
+                ReaderPreferences.TransitionAnimation.entries - ReaderPreferences.TransitionAnimation.FLIP_LEFT -
+                    ReaderPreferences.TransitionAnimation.FLIP_RIGHT
+                ).forEach {
+                FilterChip(
+                    selected = it == transitionAnimation,
+                    onClick = { viewModel.preferences.transitionAnimationDual.set(it) },
+                    label = { Text(stringResource(it.titleRes)) },
+                )
+            }
+        }
+        val cutoutMode by viewModel.preferences.cutoutModeDual.collectAsState()
+        SettingsChipRow(MR.strings.pref_cutout_mode_dual) {
+            ReaderPreferences.CutoutMode.entries.forEach {
+                FilterChip(
+                    selected = it == cutoutMode,
+                    onClick = { viewModel.preferences.cutoutModeDual.set(it) },
+                    label = { Text(stringResource(it.titleRes)) },
+                )
+            }
+        }
+        return
+    }
+
+    if (resolved != ReadingMode.WEBTOON && resolved != ReadingMode.CONTINUOUS_VERTICAL) {
+        val imageScaleType by viewModel.preferences.imageScaleType.collectAsState()
+        SettingsChipRow(MR.strings.pref_image_scale_type) {
+            ReaderPreferences.ImageScaleTypeWebGpuViewer.forEach {
+                FilterChip(
+                    selected = ReaderPreferences.ImageScaleType[imageScaleType - 1] == it,
+                    onClick = {
+                        viewModel.preferences.imageScaleType.set(ReaderPreferences.ImageScaleType.indexOf(it) + 1)
+                    },
+                    label = { Text(stringResource(it)) },
+                )
+            }
+        }
+
+        val zoomStart by viewModel.preferences.zoomStart.collectAsState()
+        SettingsChipRow(MR.strings.pref_zoom_start) {
+            ReaderPreferences.ZoomStart.mapIndexed { index, it ->
+                FilterChip(
+                    selected = zoomStart == index + 1,
+                    onClick = { viewModel.preferences.zoomStart.set(index + 1) },
+                    label = { Text(stringResource(it)) },
+                )
+            }
+        }
+
+        CheckboxItem(
+            label = stringResource(MR.strings.pref_crop_borders),
+            pref = viewModel.preferences.cropBorders,
+        )
+
+        CheckboxItem(
+            label = stringResource(MR.strings.pref_landscape_zoom),
+            pref = viewModel.preferences.landscapeZoom,
+        )
+
+        CheckboxItem(
+            label = stringResource(MR.strings.pref_navigate_pan),
+            pref = viewModel.preferences.navigateToPan,
+        )
+
+        val transitionAnimation by viewModel.preferences.transitionAnimation.collectAsState()
+        SettingsChipRow(MR.strings.pref_transition_animation) {
+            ReaderPreferences.TransitionAnimation.entries.forEach {
+                FilterChip(
+                    selected = it == transitionAnimation,
+                    onClick = { viewModel.preferences.transitionAnimation.set(it) },
+                    label = { Text(stringResource(it.titleRes)) },
+                )
+            }
+        }
+
+        val cutoutMode by viewModel.preferences.cutoutMode.collectAsState()
+        SettingsChipRow(MR.strings.pref_cutout_mode) {
+            ReaderPreferences.CutoutMode.entries.forEach {
+                FilterChip(
+                    selected = it == cutoutMode,
+                    onClick = { viewModel.preferences.cutoutMode.set(it) },
+                    label = { Text(stringResource(it.titleRes)) },
+                )
+            }
+        }
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/App.kt

@@ -45,7 +45,6 @@ import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.network.NetworkPreferences
 import eu.kanade.tachiyomi.ui.base.delegate.SecureActivityDelegate
 import eu.kanade.tachiyomi.util.system.DeviceUtil
-import eu.kanade.tachiyomi.util.system.GLUtil
 import eu.kanade.tachiyomi.util.system.WebViewUtil
 import eu.kanade.tachiyomi.util.system.animatorDurationScale
 import eu.kanade.tachiyomi.util.system.cancelNotification
@@ -69,7 +68,6 @@ import org.conscrypt.Conscrypt
 import tachiyomi.core.common.i18n.stringResource
 import tachiyomi.core.common.preference.Preference
 import tachiyomi.core.common.preference.PreferenceStore
-import tachiyomi.core.common.util.system.ImageUtil
 import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.source.service.SourceManager
 import tachiyomi.i18n.MR
@@ -186,14 +184,6 @@ class App : Application(), DefaultLifecycleObserver, SingletonImageLoader.Factor
             .onEach(TelemetryConfig::setCrashlyticsEnabled)
             .launchIn(scope)
 
-        basePreferences.hardwareBitmapThreshold.let { preference ->
-            if (!preference.isSet()) preference.set(GLUtil.DEVICE_TEXTURE_LIMIT)
-        }
-
-        basePreferences.hardwareBitmapThreshold.changes()
-            .onEach { ImageUtil.hardwareBitmapThreshold = it }
-            .launchIn(scope)
-
         setAppCompatDelegateThemeMode(uiPreferences.themeMode.get())
 
         // Updates widget update

app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupDecoder.kt

@@ -4,8 +4,11 @@ import android.content.Context
 import android.net.Uri
 import dev.zacsweers.metro.Inject
 import eu.kanade.tachiyomi.data.backup.models.Backup
-import kotlinx.serialization.SerializationException
+import eu.kanade.tachiyomi.data.backup.models.BackupManga
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
 import kotlinx.serialization.protobuf.ProtoBuf
+import okio.BufferedSource
 import okio.buffer
 import okio.gzip
 import okio.source
@@ -19,9 +22,38 @@ class BackupDecoder(
     private val parser: ProtoBuf,
 ) {
     /**
-     * Decode a potentially-gzipped backup.
+     * Decode everything but the entries of a potentially-gzipped backup, counting the entries without decoding them.
      */
-    fun decode(uri: Uri): Backup {
+    fun decodeMetadata(uri: Uri): Metadata {
+        return read(uri) { reader ->
+            orInvalid {
+                var entryCount = 0
+                while (reader.nextEntry()) {
+                    reader.skipEntry()
+                    entryCount++
+                }
+                Metadata(entryCount, reader.readMetadata())
+            }
+        }
+    }
+
+    /**
+     * Decode the entries of a potentially-gzipped backup one at a time, skipping those whose index [include] rejects.
+     */
+    fun decodeEntries(uri: Uri, include: (index: Int) -> Boolean = { true }): Flow<BackupManga> = flow {
+        read(uri) { reader ->
+            var index = 0
+            while (orInvalid { reader.nextEntry() }) {
+                if (include(index++)) {
+                    emit(orInvalid { reader.readEntry() })
+                } else {
+                    orInvalid { reader.skipEntry() }
+                }
+            }
+        }
+    }
+
+    private inline fun <T> read(uri: Uri, block: (BackupReader) -> T): T {
         return context.contentResolver.openInputStream(uri)!!.use { inputStream ->
             val source = inputStream.source().buffer()
 
@@ -29,22 +61,32 @@ class BackupDecoder(
                 require(2)
             }
             val id1id2 = peeked.readShort()
-            val backupString = when (id1id2.toInt()) {
+            val backupSource: BufferedSource = when (id1id2.toInt()) {
                 0x1f8b -> source.gzip().buffer() // 0x1f8b is gzip magic bytes
                 MAGIC_JSON_SIGNATURE1, MAGIC_JSON_SIGNATURE2, MAGIC_JSON_SIGNATURE3 -> {
                     throw IOException(context.stringResource(MR.strings.invalid_backup_file_json))
                 }
                 else -> source
-            }.use { it.readByteArray() }
-
-            try {
-                parser.decodeFromByteArray(Backup.serializer(), backupString)
-            } catch (_: SerializationException) {
-                throw IOException(context.stringResource(MR.strings.invalid_backup_file_unknown))
             }
+
+            backupSource.use { block(BackupReader(it, parser)) }
         }
     }
 
+    // Only around reading, so the JSON error above and anything thrown downstream of emit keep their own messages
+    private inline fun <T> orInvalid(block: () -> T): T {
+        return try {
+            block()
+        } catch (e: IOException) {
+            throw IOException(context.stringResource(MR.strings.invalid_backup_file_unknown), e)
+        }
+    }
+
+    data class Metadata(
+        val entryCount: Int,
+        val backup: Backup,
+    )
+
     companion object {
         private const val MAGIC_JSON_SIGNATURE1 = 0x7b7d // `{}`
         private const val MAGIC_JSON_SIGNATURE2 = 0x7b22 // `{"`

app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupFileValidator.kt

@@ -3,6 +3,7 @@ package eu.kanade.tachiyomi.data.backup
 import android.net.Uri
 import dev.zacsweers.metro.Inject
 import eu.kanade.tachiyomi.data.track.TrackerManager
+import kotlinx.coroutines.CancellationException
 import tachiyomi.domain.source.service.SourceManager
 
 @Inject
@@ -18,8 +19,14 @@ class BackupFileValidator(
      * @return List of missing sources or missing trackers.
      */
     suspend fun validate(uri: Uri): Results {
+        val trackerIds = mutableSetOf<Int>()
         val backup = try {
-            backupDecoder.decode(uri)
+            backupDecoder.decodeEntries(uri).collect { manga ->
+                manga.tracking.mapTo(trackerIds) { it.syncId }
+            }
+            backupDecoder.decodeMetadata(uri).backup
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException(e)
         }
@@ -38,11 +45,7 @@ class BackupFileValidator(
             .distinct()
             .sorted()
 
-        val trackers = backup.backupManga
-            .flatMap { it.tracking }
-            .map { it.syncId }
-            .distinct()
-        val missingTrackers = trackers
+        val missingTrackers = trackerIds
             .mapNotNull { trackerManager.get(it.toLong()) }
             .filter { !it.isLoggedIn }
             .map { it.name }

app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupStream.kt

@@ -0,0 +1,153 @@
+package eu.kanade.tachiyomi.data.backup
+
+import eu.kanade.tachiyomi.data.backup.models.Backup
+import eu.kanade.tachiyomi.data.backup.models.BackupManga
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.protobuf.ProtoBuf
+import okio.Buffer
+import okio.BufferedSink
+import okio.BufferedSource
+import java.io.IOException
+
+/**
+ * Writes the same bytes as encoding a whole [Backup], without holding all of its entries at once.
+ */
+class BackupWriter(
+    private val sink: BufferedSink,
+    private val parser: ProtoBuf,
+) {
+    var isEmpty = true
+        private set
+
+    fun writeEntry(entry: BackupManga) {
+        val bytes = parser.encodeToByteArray(BackupManga.serializer(), entry)
+        sink.writeVarint(ENTRY_TAG)
+        sink.writeVarint(bytes.size.toLong())
+        sink.write(bytes)
+        isEmpty = false
+    }
+
+    /**
+     * Writes the other fields after the entries, as [metadata] without entries of its own.
+     */
+    fun writeMetadata(metadata: Backup) {
+        val bytes = parser.encodeToByteArray(Backup.serializer(), metadata)
+        sink.write(bytes)
+        if (bytes.isNotEmpty()) isEmpty = false
+    }
+}
+
+/**
+ * Reads an encoded [Backup] one entry at a time. Every other field is set aside for [readMetadata], wherever it
+ * appears.
+ *
+ * Malformed or truncated input throws an [IOException].
+ */
+class BackupReader(
+    private val source: BufferedSource,
+    private val parser: ProtoBuf,
+) {
+    private val metadata = Buffer()
+    private var entryLength = NO_ENTRY
+
+    /**
+     * Moves to the next entry, which [readEntry] or [skipEntry] then consumes.
+     *
+     * @return false once the input is exhausted.
+     */
+    fun nextEntry(): Boolean {
+        check(entryLength == NO_ENTRY)
+        while (!source.exhausted()) {
+            val tag = source.readVarint()
+            val fieldNumber = tag ushr 3
+            val wireType = (tag and 0x7).toInt()
+            if (fieldNumber == 0L) throw IOException("Invalid field number 0")
+
+            if (tag == ENTRY_TAG) {
+                entryLength = source.readLength()
+                return true
+            }
+
+            metadata.writeVarint(tag)
+            when (wireType) {
+                WIRE_TYPE_VARINT -> metadata.writeVarint(source.readVarint())
+                WIRE_TYPE_FIXED64 -> metadata.write(source, 8)
+                WIRE_TYPE_LENGTH_DELIMITED -> {
+                    val length = source.readLength()
+                    metadata.writeVarint(length)
+                    metadata.write(source, length)
+                }
+                WIRE_TYPE_FIXED32 -> metadata.write(source, 4)
+                else -> throw IOException("Unsupported wire type $wireType")
+            }
+        }
+        return false
+    }
+
+    fun readEntry(): BackupManga {
+        val bytes = source.readByteArray(takeEntryLength())
+        return decode(BackupManga.serializer(), bytes)
+    }
+
+    fun skipEntry() {
+        source.skip(takeEntryLength())
+    }
+
+    /**
+     * Skips the remaining entries and decodes everything else as a [Backup] without entries.
+     */
+    fun readMetadata(): Backup {
+        if (entryLength != NO_ENTRY) skipEntry()
+        while (nextEntry()) skipEntry()
+        return decode(Backup.serializer(), metadata.readByteArray())
+    }
+
+    private fun takeEntryLength(): Long {
+        check(entryLength != NO_ENTRY)
+        return entryLength.also { entryLength = NO_ENTRY }
+    }
+
+    private fun <T> decode(deserializer: DeserializationStrategy<T>, bytes: ByteArray): T {
+        return try {
+            parser.decodeFromByteArray(deserializer, bytes)
+        } catch (e: SerializationException) {
+            throw IOException(e)
+        }
+    }
+}
+
+private fun BufferedSource.readVarint(): Long {
+    var result = 0L
+    for (shift in 0 until Long.SIZE_BITS step 7) {
+        val byte = readByte().toInt()
+        result = result or ((byte and 0x7F).toLong() shl shift)
+        if ((byte and 0x80) == 0) return result
+    }
+    throw IOException("Malformed varint")
+}
+
+private fun BufferedSource.readLength(): Long {
+    val length = readVarint()
+    if (length !in 0..Int.MAX_VALUE) throw IOException("Invalid length $length")
+    return length
+}
+
+private fun BufferedSink.writeVarint(value: Long) {
+    var remaining = value
+    while ((remaining and 0x7FL.inv()) != 0L) {
+        writeByte((remaining and 0x7F).toInt() or 0x80)
+        remaining = remaining ushr 7
+    }
+    writeByte(remaining.toInt())
+}
+
+private const val WIRE_TYPE_VARINT = 0
+private const val WIRE_TYPE_FIXED64 = 1
+private const val WIRE_TYPE_LENGTH_DELIMITED = 2
+private const val WIRE_TYPE_FIXED32 = 5
+
+// Backup.backupManga is field 1, and each entry is length-delimited
+private const val ENTRY_TAG = 1L shl 3 or WIRE_TYPE_LENGTH_DELIMITED.toLong()
+
+private const val NO_ENTRY = -1L

app/src/main/java/eu/kanade/tachiyomi/data/backup/create/BackupCreator.kt

@@ -8,6 +8,7 @@ import dev.zacsweers.metro.AssistedFactory
 import dev.zacsweers.metro.AssistedInject
 import eu.kanade.tachiyomi.BuildConfig
 import eu.kanade.tachiyomi.data.backup.BackupFileValidator
+import eu.kanade.tachiyomi.data.backup.BackupWriter
 import eu.kanade.tachiyomi.data.backup.create.creators.CategoriesBackupCreator
 import eu.kanade.tachiyomi.data.backup.create.creators.ExtensionStoresBackupCreator
 import eu.kanade.tachiyomi.data.backup.create.creators.MangaBackupCreator
@@ -20,6 +21,8 @@ import eu.kanade.tachiyomi.data.backup.models.BackupManga
 import eu.kanade.tachiyomi.data.backup.models.BackupPreference
 import eu.kanade.tachiyomi.data.backup.models.BackupSource
 import eu.kanade.tachiyomi.data.backup.models.BackupSourcePreferences
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
 import kotlinx.serialization.protobuf.ProtoBuf
 import logcat.LogPriority
 import okio.buffer
@@ -85,27 +88,31 @@ class BackupCreator(
             val nonFavoriteManga = if (options.readEntries) mangaRepository.getReadMangaNotInLibrary() else emptyList()
             val backupManga = backupMangas(getFavorites.await() + nonFavoriteManga, options)
 
-            val backup = Backup(
-                backupManga = backupManga,
-                backupCategories = backupCategories(options),
-                backupSources = backupSources(backupManga),
-                backupPreferences = backupAppPreferences(options),
-                backupExtensionStores = backupExtensionStores(options),
-                backupSourcePreferences = backupSourcePreferences(options),
-            )
-
-            val byteArray = parser.encodeToByteArray(Backup.serializer(), backup)
-            if (byteArray.isEmpty()) {
-                throw IllegalStateException(context.stringResource(MR.strings.empty_backup_error))
-            }
-
             file.openOutputStream()
                 .also {
                     // Force overwrite old file
                     (it as? FileOutputStream)?.channel?.truncate(0)
                 }
                 .sink().gzip().buffer().use {
-                    it.write(byteArray)
+                    val writer = BackupWriter(it, parser)
+                    val sourceIds = mutableSetOf<Long>()
+                    backupManga.collect { manga ->
+                        writer.writeEntry(manga)
+                        sourceIds += manga.source
+                    }
+                    writer.writeMetadata(
+                        Backup(
+                            backupManga = emptyList(),
+                            backupCategories = backupCategories(options),
+                            backupSources = backupSources(sourceIds),
+                            backupPreferences = backupAppPreferences(options),
+                            backupExtensionStores = backupExtensionStores(options),
+                            backupSourcePreferences = backupSourcePreferences(options),
+                        ),
+                    )
+                    if (writer.isEmpty) {
+                        throw IllegalStateException(context.stringResource(MR.strings.empty_backup_error))
+                    }
                 }
             val fileUri = file.uri
 
@@ -130,14 +137,14 @@ class BackupCreator(
         return categoriesBackupCreator()
     }
 
-    private suspend fun backupMangas(mangas: List<Manga>, options: BackupOptions): List<BackupManga> {
-        if (!options.libraryEntries) return emptyList()
+    private fun backupMangas(mangas: List<Manga>, options: BackupOptions): Flow<BackupManga> {
+        if (!options.libraryEntries) return emptyFlow()
 
         return mangaBackupCreator(mangas, options)
     }
 
-    private suspend fun backupSources(mangas: List<BackupManga>): List<BackupSource> {
-        return sourcesBackupCreator(mangas)
+    private suspend fun backupSources(sourceIds: Set<Long>): List<BackupSource> {
+        return sourcesBackupCreator(sourceIds)
     }
 
     private fun backupAppPreferences(options: BackupOptions): List<BackupPreference> {

app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/MangaBackupCreator.kt

@@ -7,11 +7,13 @@ import eu.kanade.tachiyomi.data.backup.models.BackupManga
 import eu.kanade.tachiyomi.data.backup.models.toBackupChapter
 import eu.kanade.tachiyomi.data.backup.models.toBackupTracking
 import eu.kanade.tachiyomi.ui.reader.setting.ReadingMode
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
 import mihon.core.common.extensions.toByteArray
 import mihon.core.common.extensions.toEpochMillisOrZero
-import tachiyomi.domain.category.interactor.GetCategories
+import tachiyomi.domain.category.repository.CategoryRepository
 import tachiyomi.domain.chapter.repository.ChapterRepository
-import tachiyomi.domain.history.interactor.GetHistory
+import tachiyomi.domain.history.repository.HistoryRepository
 import tachiyomi.domain.manga.model.Manga
 import tachiyomi.domain.manga.repository.MangaRepository
 import tachiyomi.domain.track.repository.TrackRepository
@@ -20,62 +22,71 @@ import tachiyomi.domain.track.repository.TrackRepository
 class MangaBackupCreator(
     private val mangaRepository: MangaRepository,
     private val chapterRepository: ChapterRepository,
+    private val categoryRepository: CategoryRepository,
+    private val historyRepository: HistoryRepository,
     private val trackRepository: TrackRepository,
-    private val getCategories: GetCategories,
-    private val getHistory: GetHistory,
 ) {
 
-    suspend operator fun invoke(mangas: List<Manga>, options: BackupOptions): List<BackupManga> {
-        return mangas.map {
-            backupManga(it, options)
+    /**
+     * Builds the entries a chunk at a time, so only one chunk's chapters are held at once.
+     */
+    operator fun invoke(mangas: List<Manga>, options: BackupOptions): Flow<BackupManga> = flow {
+        mangas.chunked(CHUNK_SIZE).forEach { chunk ->
+            backupMangas(chunk, options).forEach { emit(it) }
         }
     }
 
-    private suspend fun backupManga(manga: Manga, options: BackupOptions): BackupManga {
-        // Entry for this manga
-        val mangaObject = manga.toBackupManga()
+    private suspend fun backupMangas(mangas: List<Manga>, options: BackupOptions): List<BackupManga> {
+        val mangaIds = mangas.map { it.id }
 
-        mangaObject.excludedScanlators = mangaRepository.getExcludedScanlators(manga.id).toList()
-
-        if (options.chapters) {
-            // Backup all the chapters
-            chapterRepository.getChapterByMangaId(manga.id, applyScanlatorFilter = false)
-                .map { it.toBackupChapter() }
-                .takeUnless { it.isEmpty() }
-                ?.let { mangaObject.chapters = it }
+        val excludedScanlatorsByMangaId = mangaRepository.getExcludedScanlatorsByMangaIds(mangaIds)
+        // History is backed up by chapter URL, so it needs the chapters too
+        val chaptersByMangaId = if (options.chapters || options.history) {
+            chapterRepository.getChaptersByMangaIds(mangaIds)
+        } else {
+            emptyMap()
         }
+        val categoriesByMangaId = if (options.categories) {
+            categoryRepository.getCategoriesByMangaIds(mangaIds)
+        } else {
+            emptyMap()
+        }
+        val tracksByMangaId = if (options.tracking) trackRepository.getTracksByMangaIds(mangaIds) else emptyMap()
+        val historyByMangaId = if (options.history) historyRepository.getHistoryByMangaIds(mangaIds) else emptyMap()
 
-        if (options.categories) {
-            // Backup categories for this manga
-            val categoriesForManga = getCategories.await(manga.id)
-            if (categoriesForManga.isNotEmpty()) {
-                mangaObject.categories = categoriesForManga.map { it.order }
+        return mangas.map { manga ->
+            val mangaObject = manga.toBackupManga()
+            val chapters = chaptersByMangaId[manga.id].orEmpty()
+
+            mangaObject.excludedScanlators = excludedScanlatorsByMangaId[manga.id].orEmpty()
+
+            if (options.chapters) {
+                mangaObject.chapters = chapters.map { it.toBackupChapter() }
             }
-        }
 
-        if (options.tracking) {
-            val tracks = trackRepository.getTracksByMangaId(manga.id).map { it.toBackupTracking() }
-            if (tracks.isNotEmpty()) {
-                mangaObject.tracking = tracks
+            if (options.categories) {
+                mangaObject.categories = categoriesByMangaId[manga.id].orEmpty().map { it.order }
             }
-        }
 
-        if (options.history) {
-            val historyByMangaId = getHistory.await(manga.id)
-            if (historyByMangaId.isNotEmpty()) {
-                val chapterUrlsById = chapterRepository.getChapterByMangaId(manga.id).associate { it.id to it.url }
-                val history = historyByMangaId.mapNotNull { history ->
+            if (options.tracking) {
+                mangaObject.tracking = tracksByMangaId[manga.id].orEmpty().map { it.toBackupTracking() }
+            }
+
+            if (options.history) {
+                val chapterUrlsById = chapters.associate { it.id to it.url }
+                mangaObject.history = historyByMangaId[manga.id].orEmpty().mapNotNull { history ->
                     // A chapter removed since its history was read takes that history with it
                     val url = chapterUrlsById[history.chapterId] ?: return@mapNotNull null
                     BackupHistory(url, history.readAt.toEpochMillisOrZero(), history.readDuration)
                 }
-                if (history.isNotEmpty()) {
-                    mangaObject.history = history
-                }
             }
-        }
 
-        return mangaObject
+            mangaObject
+        }
+    }
+
+    private companion object {
+        const val CHUNK_SIZE = 100
     }
 }
 

app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/SourcesBackupCreator.kt

@@ -1,7 +1,6 @@
 package eu.kanade.tachiyomi.data.backup.create.creators
 
 import dev.zacsweers.metro.Inject
-import eu.kanade.tachiyomi.data.backup.models.BackupManga
 import eu.kanade.tachiyomi.data.backup.models.BackupSource
 import eu.kanade.tachiyomi.source.Source
 import tachiyomi.domain.source.service.SourceManager
@@ -11,11 +10,8 @@ class SourcesBackupCreator(
     private val sourceManager: SourceManager,
 ) {
 
-    suspend operator fun invoke(mangas: List<BackupManga>): List<BackupSource> {
-        return mangas
-            .map(BackupManga::source)
-            .distinct()
-            .map { sourceManager.getOrStub(it).toBackupSource() }
+    suspend operator fun invoke(sourceIds: Set<Long>): List<BackupSource> {
+        return sourceIds.map { sourceManager.getOrStub(it).toBackupSource() }
     }
 }
 

app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/BackupRestorer.kt

@@ -9,7 +9,6 @@ import eu.kanade.tachiyomi.data.backup.BackupDecoder
 import eu.kanade.tachiyomi.data.backup.BackupNotifier
 import eu.kanade.tachiyomi.data.backup.models.BackupCategory
 import eu.kanade.tachiyomi.data.backup.models.BackupExtensionStore
-import eu.kanade.tachiyomi.data.backup.models.BackupManga
 import eu.kanade.tachiyomi.data.backup.models.BackupPreference
 import eu.kanade.tachiyomi.data.backup.models.BackupSource
 import eu.kanade.tachiyomi.data.backup.models.BackupSourcePreferences
@@ -23,6 +22,12 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.flow.chunked
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.withIndex
 import kotlinx.coroutines.launch
 import logcat.LogPriority
 import tachiyomi.core.common.i18n.stringResource
@@ -32,6 +37,7 @@ import tachiyomi.domain.source.service.SourceManager
 import tachiyomi.i18n.MR
 import java.io.File
 import java.text.SimpleDateFormat
+import java.util.BitSet
 import java.util.Date
 import java.util.Locale
 import java.util.concurrent.CopyOnWriteArrayList
@@ -97,7 +103,7 @@ class BackupRestorer(
     }
 
     private suspend fun restoreFromFile(uri: Uri, options: RestoreOptions) {
-        val backup = backupDecoder.decode(uri)
+        val (entryCount, backup) = backupDecoder.decodeMetadata(uri)
 
         // Store source mapping for error messages
         val backupMaps = backup.backupSources
@@ -105,7 +111,7 @@ class BackupRestorer(
 
         if (options.libraryEntries) {
             restoreSourceNames(backupMaps)
-            restoreAmount += backup.backupManga.size
+            restoreAmount += entryCount
         }
         if (options.categories) {
             restoreAmount += 1
@@ -138,7 +144,7 @@ class BackupRestorer(
             }
             if (options.libraryEntries) {
                 restoreManga(
-                    backup.backupManga,
+                    uri,
                     if (options.categories) backup.backupCategories else emptyList(),
                     restoreCategoriesJob,
                 )
@@ -175,14 +181,31 @@ class BackupRestorer(
     }
 
     private fun CoroutineScope.restoreManga(
-        backupMangas: List<BackupManga>,
+        uri: Uri,
         backupCategories: List<BackupCategory>,
         categoriesRestoreJob: Job?,
     ) = launch {
         categoriesRestoreJob?.join()
-        mangaRestorer.sortByNew(backupMangas)
+
+        // New entries go first. Rather than hold the others back in memory, a second pass reads them again.
+        val isExisting = mangaRestorer.getExistingMatcher()
+        val existingIndices = BitSet()
+        val newMangas = backupDecoder.decodeEntries(uri)
+            .withIndex()
+            .filter { (index, manga) ->
+                val exists = isExisting(manga)
+                if (exists) existingIndices.set(index)
+                !exists
+            }
+            .map { it.value }
+        val backupMangas = flow {
+            emitAll(newMangas)
+            emitAll(backupDecoder.decodeEntries(uri, existingIndices::get))
+        }
+
+        backupMangas
             .chunked(100)
-            .forEach { chunk ->
+            .collect { chunk ->
                 val restoredAsBatch = try {
                     ensureActive()
                     mangaRestorer.restore(chunk, backupCategories)

app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers/MangaRestorer.kt

@@ -23,11 +23,13 @@ class MangaRestorer(
     private val now = Clock.System.now().toLocalDateTime(timeZone)
     private val currentFetchWindow = fetchInterval.getWindow(now.date, timeZone)
 
-    suspend fun sortByNew(backupMangas: List<BackupManga>): List<BackupManga> {
+    /**
+     * Returns whether an entry was already in the database at the time of this call.
+     */
+    suspend fun getExistingMatcher(): (BackupManga) -> Boolean {
         val urlsBySource = restoreRepository.getMangaUrlsBySourceId()
 
-        return backupMangas
-            .sortedBy { it.url in urlsBySource[it.source].orEmpty() }
+        return { it.url in urlsBySource[it.source].orEmpty() }
     }
 
     /**

app/src/main/java/eu/kanade/tachiyomi/data/cache/ChapterCache.kt

@@ -7,6 +7,7 @@ import dev.zacsweers.metro.AppScope
 import dev.zacsweers.metro.Inject
 import dev.zacsweers.metro.SingleIn
 import eu.kanade.tachiyomi.source.model.Page
+import eu.kanade.tachiyomi.ui.reader.model.DownloadStream
 import eu.kanade.tachiyomi.util.storage.DiskUtil
 import eu.kanade.tachiyomi.util.storage.saveTo
 import kotlinx.serialization.json.Json
@@ -150,10 +151,11 @@ class ChapterCache(
      *
      * @param imageUrl url of image.
      * @param response http response from page.
+     * @param live also receives the bytes as they arrive.
      * @throws IOException image error.
      */
     @Throws(IOException::class)
-    fun putImageToCache(imageUrl: String, response: Response) {
+    fun putImageToCache(imageUrl: String, response: Response, live: DownloadStream? = null) {
         // Initialize editor (edits the values for an entry).
         var editor: DiskLruCache.Editor? = null
 
@@ -163,7 +165,22 @@ class ChapterCache(
             editor = diskCache.edit(key) ?: return
 
             // Get OutputStream and write image with Okio.
-            response.body.source().saveTo(editor.newOutputStream(0))
+            if (live == null) {
+                response.body.source().saveTo(editor.newOutputStream(0))
+            } else {
+                live.reserve(response.body.contentLength())
+                response.body.source().use { source ->
+                    editor.newOutputStream(0).use { out ->
+                        val buffer = ByteArray(1 shl 16)
+                        while (true) {
+                            val n = source.read(buffer)
+                            if (n < 0) break
+                            out.write(buffer, 0, n)
+                            live.append(buffer, 0, n)
+                        }
+                    }
+                }
+            }
 
             diskCache.flush()
             editor.commit()

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

@@ -2,6 +2,9 @@ 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
 import coil3.Canvas
 import coil3.Image
 import coil3.ImageLoader
@@ -12,20 +15,39 @@ import coil3.decode.Decoder
 import coil3.decode.ImageSource
 import coil3.fetch.SourceFetchResult
 import coil3.request.Options
-import coil3.request.bitmapConfig
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
 import okio.BufferedSource
 import tachiyomi.core.common.util.system.ImageUtil
-import tachiyomi.decoder.ImageDecoder
 import kotlin.math.min
 import kotlin.math.sqrt
 
 /**
- * A [Decoder] that uses built-in [ImageDecoder] to decode images that is not supported by the system.
+ * A [Decoder] that uses [ImageDecoder] to decode image formats not supported
+ * by the Android system decoder (AVIF, JXL, HEIF, etc.).
  */
 class ImageDecoder(private val resources: ImageSource, private val options: Options) : Decoder {
 
+    /**
+     * Wraps a raw [ImageDecoder.Frame] as a Coil [Image] for callers that want
+     * direct access to the RGBA [java.nio.ByteBuffer] (e.g. the new-decoder path).
+     */
+    class DecodeResultImage(
+        val frame: ImageDecoder.Frame,
+        val isHdr: Boolean,
+        val hdrHeadroom: Float,
+        val gainmap: ImageDecoder.Gainmap?,
+    ) : Image {
+        val image: java.nio.ByteBuffer get() = frame.image
+
+        // Taken now: a caller may close the frame once it has the pixels.
+        override val size: Long = frame.image.capacity().toLong()
+        override val width: Int get() = frame.width
+        override val height: Int get() = frame.height
+        override val shareable: Boolean get() = true
+        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
@@ -42,18 +64,32 @@ class ImageDecoder(private val resources: ImageSource, private val options: Opti
     override suspend fun decode(): DecodeResult {
         if (options.webtoonStrips) return decodeStrips()
 
-        val decoder = resources.sourceOrNull()?.use {
-            ImageDecoder.newInstance(it.inputStream(), options.cropBorders, displayProfile)
+        val res = resources.source().use {
+            ImageDecoder.open(it.inputStream()).use { dec ->
+                DecodeResultImage(
+                    dec.decodeNext(),
+                    dec.isHdr,
+                    dec.hdrHeadroom,
+                    if (dec.hdrKind == ImageDecoder.HdrKind.GAINMAP) dec.getGainmap() else null,
+                )
+            }
         }
 
-        check(decoder != null && decoder.width > 0 && decoder.height > 0) { "Failed to initialize decoder" }
+        val srcWidth = res.width
+        val srcHeight = res.height
 
-        val srcWidth = decoder.width
-        val srcHeight = decoder.height
+        // newDecoder path: caller wants the raw DecodeResult (e.g. for custom rendering).
+        // Hand it back as-is; sampling is the caller's responsibility.
+        if (options.newDecoder) {
+            return DecodeResult(
+                image = res,
+                isSampled = false,
+            )
+        }
 
+        // Normal path: produce a Bitmap scaled to the requested output size.
         val dstWidth = options.size.widthPx(options.scale) { srcWidth }
         val dstHeight = options.size.heightPx(options.scale) { srcHeight }
-
         val sampleSize = DecodeUtils.calculateInSampleSize(
             srcWidth = srcWidth,
             srcHeight = srcHeight,
@@ -62,17 +98,25 @@ class ImageDecoder(private val resources: ImageSource, private val options: Opti
             scale = options.scale,
         )
 
-        var bitmap = decoder.decode(sampleSize = sampleSize)
-        decoder.recycle()
+        // Copy RGBA pixels from the native buffer into a full-resolution bitmap.
+        // We must do this while `res` (and its native memory) is still alive.
+        // HDR frames are half-float RGBA.
+        val config = if (res.isHdr) Bitmap.Config.RGBA_F16 else Bitmap.Config.ARGB_8888
+        val fullBitmap = createBitmap(srcWidth, srcHeight, config)
+        res.image.rewind()
+        fullBitmap.copyPixelsFromBuffer(res.image)
+        res.frame.close()
 
-        check(bitmap != null) { "Failed to decode image" }
-
-        if (options.bitmapConfig == Bitmap.Config.HARDWARE && ImageUtil.canUseHardwareBitmap(bitmap)) {
-            val hwBitmap = bitmap.copy(Bitmap.Config.HARDWARE, false)
-            if (hwBitmap != null) {
-                bitmap.recycle()
-                bitmap = hwBitmap
-            }
+        // Downsample if needed. sampleSize is a power-of-two factor; the target
+        // dimensions are src / sampleSize, matching BitmapFactory inSampleSize behaviour.
+        val bitmap = if (sampleSize > 1) {
+            val scaledWidth = (srcWidth / sampleSize).coerceAtLeast(1)
+            val scaledHeight = (srcHeight / sampleSize).coerceAtLeast(1)
+            val scaled = fullBitmap.scale(scaledWidth, scaledHeight)
+            fullBitmap.recycle()
+            scaled
+        } else {
+            fullBitmap
         }
 
         return DecodeResult(
@@ -82,62 +126,66 @@ class ImageDecoder(private val resources: ImageSource, private val options: Opti
     }
 
     /**
-     * Decodes a webtoon page and cuts it into strips, freeing the decoded page once they're copied.
+     * 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 decoder = resources.sourceOrNull()?.use {
-            ImageDecoder.newInstance(it.inputStream(), options.cropBorders, displayProfile)
+        val (frame, isHdr) = resources.source().use {
+            ImageDecoder.open(it.inputStream()).use { dec -> dec.decodeNext() to dec.isHdr }
         }
-        check(decoder != null && decoder.width > 0 && decoder.height > 0) { "Failed to initialize decoder" }
+        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
 
-        val srcWidth = decoder.width
-        val viewWidth = options.size.widthPx(options.scale) { srcWidth }
-        val sampleSize = DecodeUtils.calculateInSampleSize(
-            srcWidth = decoder.width,
-            srcHeight = decoder.height,
-            dstWidth = viewWidth,
-            dstHeight = options.size.heightPx(options.scale) { decoder.height },
-            scale = options.scale,
-        )
-        val page = decoder.decode(sampleSize = sampleSize)
-        decoder.recycle()
-        check(page != null) { "Failed to decode image" }
-
-        val config = page.config ?: Bitmap.Config.ARGB_8888
-        val bytesPerPixel = page.rowBytes / page.width
-        val budgetWidth = sqrt(MAX_PAGE_BYTES.toDouble() / bytesPerPixel * page.width / page.height).toInt()
-        val stripWidth = maxOf(viewWidth, min(page.width, budgetWidth))
-            // Older GPUs can't draw a texture wider than this
-            .coerceAtMost(MAX_STRIP_WIDTH)
-            .coerceIn(1, page.width)
-        val scale = stripWidth.toFloat() / page.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, page.height)
-        val matrix = Matrix().apply { setScale(scale, scale) }
-        val strips = (0..<page.height step bandRows).map { top ->
-            val rows = min(bandRows, page.height - top)
-            val band = if (stripWidth < page.width) {
-                Bitmap.createBitmap(page, 0, top, page.width, rows, matrix, true)
-            } else {
-                Bitmap.createBitmap(page, 0, top, page.width, rows)
+            // 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() }
             }
-            // createBitmap returns a mutable bitmap despite its docs, and copy is the only way to an immutable one
-            band.copy(config, false).also { if (band !== page) band.recycle() }
+            band.recycle()
+            DecodeResult(image = StripsImage(strips), isSampled = stripWidth < frame.width)
         }
-        page.recycle()
-        DecodeResult(image = StripsImage(strips), isSampled = stripWidth < srcWidth)
     }
 
     class Factory : Decoder.Factory {
-
         override fun create(result: SourceFetchResult, options: Options, imageLoader: ImageLoader): Decoder? {
-            return if (options.webtoonStrips || isApplicable(result.source.source())) {
+            return if (options.newDecoder || options.webtoonStrips || isApplicable(result.source.source())) {
                 ImageDecoder(result.source, options)
             } else {
                 null
@@ -149,7 +197,12 @@ class ImageDecoder(private val resources: ImageSource, private val options: Opti
                 ImageUtil.findImageType(it)
             }
             return when (type) {
-                ImageUtil.ImageType.AVIF, ImageUtil.ImageType.JXL, ImageUtil.ImageType.HEIF -> true
+                ImageUtil.ImageType.AVIF,
+                ImageUtil.ImageType.JXL,
+                ImageUtil.ImageType.HEIF,
+                ImageUtil.ImageType.JP2,
+                -> true
+
                 else -> false
             }
         }
@@ -158,10 +211,6 @@ class ImageDecoder(private val resources: ImageSource, private val options: Opti
 
         override fun hashCode() = javaClass.hashCode()
     }
-
-    companion object {
-        var displayProfile: ByteArray? = null
-    }
 }
 
 private const val STRIP_BYTES = 4 * 1024 * 1024
@@ -170,5 +219,5 @@ private const val MAX_PAGE_BYTES = 128 * 1024 * 1024
 
 private const val MAX_STRIP_WIDTH = 4096
 
-// Each decode holds the whole page until its strips are copied, and the reader loads pages ahead in parallel
+// 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)

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

@@ -42,3 +42,11 @@ val Options.webtoonStrips: Boolean
     get() = getExtra(webtoonStripsKey)
 
 private val webtoonStripsKey = Extras.Key(default = false)
+
+fun ImageRequest.Builder.newDecoder(enable: Boolean) = apply {
+    extras[newDecoderKey] = enable
+}
+val Options.newDecoder: Boolean
+    get() = getExtra(newDecoderKey)
+
+private val newDecoderKey = Extras.Key(default = false)

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

@@ -43,9 +43,7 @@ import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
 import androidx.lifecycle.lifecycleScope
-import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
 import com.google.android.material.transition.platform.MaterialContainerTransform
-import com.hippo.unifile.UniFile
 import dev.zacsweers.metro.Inject
 import eu.kanade.domain.base.BasePreferences
 import eu.kanade.presentation.reader.DisplayRefreshHost
@@ -58,7 +56,6 @@ import eu.kanade.presentation.reader.appbars.ReaderAppBars
 import eu.kanade.presentation.reader.components.ChapterNavigatorType
 import eu.kanade.presentation.reader.settings.ReaderSettingsDialog
 import eu.kanade.tachiyomi.R
-import eu.kanade.tachiyomi.data.coil.ImageDecoder
 import eu.kanade.tachiyomi.data.notification.NotificationReceiver
 import eu.kanade.tachiyomi.data.notification.Notifications
 import eu.kanade.tachiyomi.databinding.ReaderActivityBinding
@@ -77,6 +74,7 @@ import eu.kanade.tachiyomi.ui.reader.setting.ReaderSettingsViewModel
 import eu.kanade.tachiyomi.ui.reader.setting.ReadingMode
 import eu.kanade.tachiyomi.ui.reader.viewer.ReaderProgressIndicator
 import eu.kanade.tachiyomi.ui.reader.viewer.pager.R2LPagerViewer
+import eu.kanade.tachiyomi.ui.reader.viewer.webgpu.WebGpuViewer
 import eu.kanade.tachiyomi.ui.webview.WebViewActivity
 import eu.kanade.tachiyomi.util.system.openInBrowser
 import eu.kanade.tachiyomi.util.system.readerBackgroundColor
@@ -101,7 +99,6 @@ import tachiyomi.core.common.i18n.stringResource
 import tachiyomi.core.common.util.system.logcat
 import tachiyomi.i18n.MR
 import tachiyomi.presentation.core.util.collectAsState
-import java.io.ByteArrayOutputStream
 import kotlin.time.Duration.Companion.seconds
 
 class ReaderActivity : BaseActivity() {
@@ -476,7 +473,7 @@ class ReaderActivity : BaseActivity() {
             onShare = ::shareChapter.takeIf { isHttpSource },
 
             chapterNavigatorType = if (!verticalNavigator) {
-                if (state.viewer is R2LPagerViewer) {
+                if (state.viewer is R2LPagerViewer || (state.viewer as? WebGpuViewer)?.isReversed ?: false) {
                     ChapterNavigatorType.HORIZONTAL_RTL
                 } else {
                     ChapterNavigatorType.HORIZONTAL_LTR
@@ -863,10 +860,6 @@ class ReaderActivity : BaseActivity() {
                 }
                 .launchIn(lifecycleScope)
 
-            preferences.displayProfile.changes()
-                .onEach { setDisplayProfile(it) }
-                .launchIn(lifecycleScope)
-
             readerPreferences.keepScreenOn.changes()
                 .onEach(::setKeepScreenOn)
                 .launchIn(lifecycleScope)
@@ -894,25 +887,6 @@ class ReaderActivity : BaseActivity() {
                 .launchIn(lifecycleScope)
         }
 
-        /**
-         * Sets the display profile to [path].
-         */
-        private fun setDisplayProfile(path: String) {
-            val file = UniFile.fromUri(baseContext, path.toUri())
-            if (file != null && file.exists()) {
-                val inputStream = file.openInputStream()
-                val outputStream = ByteArrayOutputStream()
-                inputStream.use { input ->
-                    outputStream.use { output ->
-                        input.copyTo(output)
-                    }
-                }
-                val data = outputStream.toByteArray()
-                SubsamplingScaleImageView.setDisplayProfile(data)
-                ImageDecoder.displayProfile = data
-            }
-        }
-
         /**
          * Sets the keep screen on mode according to [enabled].
          */

app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/HttpPageLoader.kt

@@ -231,14 +231,23 @@ internal class HttpPageLoader(
             val imageUrl = page.imageUrl!!
 
             if (force || !chapterCache.isImageInCache(imageUrl)) {
+                val live = page.downloadStream
                 page.status = Page.State.DownloadImage
-                val imageResponse = source.getImage(page)
-                chapterCache.putImageToCache(imageUrl, imageResponse)
+                try {
+                    val imageResponse = source.getImage(page)
+                    chapterCache.putImageToCache(imageUrl, imageResponse, live)
+                    live?.finish()
+                } catch (e: Throwable) {
+                    live?.finish(e)
+                    throw e
+                }
             }
 
+            page.downloadStream = null
             page.stream = { chapterCache.getImageFile(imageUrl).inputStream() }
             page.status = Page.State.Ready
         } catch (e: Throwable) {
+            page.downloadStream = null
             if (e is CancellationException) {
                 // Chunk chains get cancelled on every page turn, so a cancelled page isn't an error. Put it back in
                 // the queue, otherwise it's stuck in a state no later pass will pick up.

app/src/main/java/eu/kanade/tachiyomi/ui/reader/model/DownloadStream.kt

@@ -0,0 +1,130 @@
+package eu.kanade.tachiyomi.ui.reader.model
+
+import java.io.IOException
+import java.io.InputStream
+
+/**
+ * A download's bytes as they arrive, for one reader. Past [MAX_BYTES], or once that reader is
+ * closed, it stops keeping them; [append] never throws, so the download itself carries on.
+ */
+class DownloadStream {
+    private val lock = Object()
+    private var data = ByteArray(1 shl 16)
+    private var size = 0
+    private var done = false
+    private var error: Throwable? = null
+
+    /** Presizes for [bytes], e.g. Content-Length; ignored if implausible. */
+    fun reserve(bytes: Long) {
+        synchronized(lock) {
+            if (error == null && bytes > data.size && bytes <= MAX_RESERVE) {
+                try {
+                    data = data.copyOf(bytes.toInt())
+                } catch (e: OutOfMemoryError) {
+                    // Only a hint.
+                }
+            }
+        }
+    }
+
+    fun append(src: ByteArray, offset: Int, length: Int) {
+        synchronized(lock) {
+            if (error != null || done) return
+            val needed = size.toLong() + length
+            if (needed > MAX_BYTES) {
+                // Too big to decode while downloading; the whole-file decode takes over.
+                drop("Download too large to stream")
+                return
+            }
+            if (needed > data.size) {
+                data = try {
+                    data.copyOf(maxOf(needed, minOf(data.size.toLong() * 2, MAX_BYTES)).toInt())
+                } catch (e: OutOfMemoryError) {
+                    // As too large: the download mustn't fail over this copy.
+                    drop("Out of memory buffering the download")
+                    return
+                }
+            }
+            System.arraycopy(src, offset, data, size, length)
+            size += length
+            lock.notifyAll()
+        }
+    }
+
+    /** Ends the bytes; readers throw [error] if given. */
+    fun finish(error: Throwable? = null) {
+        synchronized(lock) {
+            done = true
+            if (this.error == null) this.error = error
+            lock.notifyAll()
+        }
+    }
+
+    /** From the start; [Reader.read] blocks for bytes. Closing it drops what's kept. */
+    fun reader(): Reader = Reader()
+
+    // Rather than hold a second copy of the page.
+    private fun drop(why: String) {
+        if (error == null) error = IOException(why)
+        data = ByteArray(0)
+        size = 0
+        lock.notifyAll()
+    }
+
+    private companion object {
+        // As the decoder's own input limit.
+        const val MAX_BYTES = 1L shl 30
+        const val MAX_RESERVE = 64L shl 20
+    }
+
+    inner class Reader : InputStream() {
+        private var position = 0
+
+        /** All read; throws if the download failed. */
+        val ended: Boolean
+            get() = synchronized(lock) {
+                checkError()
+                done && position >= size
+            }
+
+        override fun read(): Int {
+            val b = ByteArray(1)
+            return if (read(b, 0, 1) < 0) -1 else b[0].toInt() and 0xFF
+        }
+
+        override fun read(b: ByteArray, off: Int, len: Int): Int {
+            synchronized(lock) {
+                if (len == 0) return 0
+                while (position >= size && !done && error == null) lock.wait()
+                checkError()
+                if (position >= size) return -1
+                val n = minOf(len, size - position)
+                System.arraycopy(data, position, b, off, n)
+                position += n
+                return n
+            }
+        }
+
+        override fun available(): Int = synchronized(lock) { if (error != null) 0 else size - position }
+
+        /** Waits up to [timeoutMs] for [min] unread bytes or the end. */
+        fun await(min: Int, timeoutMs: Long) {
+            synchronized(lock) {
+                val until = System.nanoTime() + timeoutMs * 1_000_000
+                while (size - position < min && !done && error == null) {
+                    val left = (until - System.nanoTime()) / 1_000_000
+                    if (left <= 0) return
+                    lock.wait(left)
+                }
+            }
+        }
+
+        override fun close() {
+            synchronized(lock) { drop("No longer read") }
+        }
+
+        private fun checkError() {
+            error?.let { throw IOException("Download failed", it) }
+        }
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/ui/reader/model/ReaderPage.kt

@@ -11,4 +11,8 @@ open class ReaderPage(
 ) : Page(index, url, imageUrl, null) {
 
     open lateinit var chapter: ReaderChapter
+
+    /** Set by a viewer before the download; filled during [Page.State.DownloadImage]. */
+    @Volatile
+    var downloadStream: DownloadStream? = null
 }

app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderPreferences.kt

@@ -142,6 +142,11 @@ class ReaderPreferences(
         false,
     )
 
+    val dualPageView: Preference<DualPageView> = preferenceStore.getEnum(
+        "pref_dual_page_view",
+        DualPageView.NEVER,
+    )
+
     // endregion
 
     // region Color filter
@@ -199,6 +204,24 @@ class ReaderPreferences(
 
     // endregion
 
+    // region WebGpu
+
+    val transitionAnimation: Preference<TransitionAnimation> =
+        preferenceStore.getEnum("webgpu_transition_animation", TransitionAnimation.BASIC)
+
+    val transitionAnimationDual: Preference<TransitionAnimation> =
+        preferenceStore.getEnum("webgpu_dual_transition_animation", TransitionAnimation.BASIC)
+
+    val cutoutMode: Preference<CutoutMode> = preferenceStore.getEnum("webgpu_cutout_mode", CutoutMode.AVOID)
+
+    val cutoutModeDual: Preference<CutoutMode> = preferenceStore.getEnum("webgpu_dual_cutout_mode", CutoutMode.IGNORE)
+
+    val continuousMinWidth: Preference<Int> = preferenceStore.getInt("webgpu_continuous_minwidth", 100)
+
+    val continuousGap: Preference<Int> = preferenceStore.getInt("webgpu_continuous_gap", 10)
+
+    // endregion
+
     enum class FlashColor {
         BLACK,
         WHITE,
@@ -211,8 +234,14 @@ class ReaderPreferences(
         val shouldInvertVertical: Boolean = false,
     ) {
         NONE(MR.strings.tapping_inverted_none),
-        HORIZONTAL(MR.strings.tapping_inverted_horizontal, shouldInvertHorizontal = true),
-        VERTICAL(MR.strings.tapping_inverted_vertical, shouldInvertVertical = true),
+        HORIZONTAL(
+            MR.strings.tapping_inverted_horizontal,
+            shouldInvertHorizontal = true,
+        ),
+        VERTICAL(
+            MR.strings.tapping_inverted_vertical,
+            shouldInvertVertical = true,
+        ),
         BOTH(MR.strings.tapping_inverted_both, shouldInvertHorizontal = true, shouldInvertVertical = true),
     }
 
@@ -223,6 +252,43 @@ class ReaderPreferences(
         LOWEST(47),
     }
 
+    enum class TransitionAnimation(val titleRes: StringResource) {
+        BASIC(MR.strings.transition_animation_basic),
+        FLIP(MR.strings.transition_animation_flip),
+        FLIP_LEFT(MR.strings.transition_animation_flip_left),
+        FLIP_RIGHT(
+            MR.strings.transition_animation_flip_right,
+        ),
+        STACK_LEFT(MR.strings.transition_animation_stack_left),
+        STACK_RIGHT(MR.strings.transition_animation_stack_right),
+        STACK_UP(
+            MR.strings.transition_animation_stack_up,
+        ),
+        STACK_DOWN(MR.strings.transition_animation_stack_down),
+        SPHERE(MR.strings.transition_animation_sphere),
+        CUBE_INSIDE(
+            MR.strings.transition_animation_cube_inside,
+        ),
+        CUBE_OUTSIDE(MR.strings.transition_animation_cube_outside),
+        FADE(MR.strings.transition_animation_fade),
+        FADE_WHITE(
+            MR.strings.transition_animation_fade_white,
+        ),
+        NONE(MR.strings.transition_animation_none),
+    }
+
+    enum class CutoutMode(val titleRes: StringResource) {
+        IGNORE(MR.strings.cutout_mode_ignore),
+        AVOID(MR.strings.cutout_mode_avoid),
+        SHIFT(MR.strings.cutout_mode_shift),
+    }
+
+    enum class DualPageView(val titleRes: StringResource) {
+        NEVER(MR.strings.dual_page_view_never),
+        ALWAYS(MR.strings.dual_page_view_always),
+        WIDE(MR.strings.dual_page_view_wide),
+    }
+
     companion object {
         const val WEBTOON_PADDING_MIN = 0
         const val WEBTOON_PADDING_MAX = 25
@@ -247,6 +313,13 @@ class ReaderPreferences(
             MR.strings.scale_type_smart_fit,
         )
 
+        val ImageScaleTypeWebGpuViewer = listOf(
+            MR.strings.scale_type_fit_screen,
+            MR.strings.scale_type_fit_width,
+            MR.strings.scale_type_fit_height,
+            MR.strings.scale_type_original_size,
+        )
+
         val ZoomStart = listOf(
             MR.strings.zoom_start_automatic,
             MR.strings.zoom_start_left,

app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReadingMode.kt

@@ -7,7 +7,10 @@ import eu.kanade.tachiyomi.ui.reader.viewer.Viewer
 import eu.kanade.tachiyomi.ui.reader.viewer.pager.L2RPagerViewer
 import eu.kanade.tachiyomi.ui.reader.viewer.pager.R2LPagerViewer
 import eu.kanade.tachiyomi.ui.reader.viewer.pager.VerticalPagerViewer
+import eu.kanade.tachiyomi.ui.reader.viewer.webgpu.WebGpuViewer
+import eu.kanade.tachiyomi.ui.reader.viewer.webgpu.WebGpuViewerContinuous
 import eu.kanade.tachiyomi.ui.reader.viewer.webtoon.WebtoonViewer
+import mihon.app.di.appGraph
 import mihon.icons.custommaterialsymbols.CustomMaterialSymbols
 import mihon.icons.custommaterialsymbols.rounded.ReaderLeftToRight
 import mihon.icons.custommaterialsymbols.rounded.ReaderLongStrip
@@ -74,6 +77,16 @@ enum class ReadingMode(
         }
 
         fun toViewer(preference: Int?, activity: ReaderActivity): Viewer {
+            if (activity.appGraph.basePreferences.highQualityRenderer.get()) {
+                return when (fromPreference(preference)) {
+                    LEFT_TO_RIGHT -> WebGpuViewer(activity, isReversed = false, isVertical = false)
+                    RIGHT_TO_LEFT -> WebGpuViewer(activity, isReversed = true, isVertical = false)
+                    VERTICAL -> WebGpuViewer(activity, isReversed = false, isVertical = true)
+                    WEBTOON -> WebGpuViewerContinuous(activity, useGap = false)
+                    CONTINUOUS_VERTICAL -> WebGpuViewerContinuous(activity, useGap = true)
+                    DEFAULT -> throw IllegalStateException("Preference value must be resolved: $preference")
+                }
+            }
             return when (fromPreference(preference)) {
                 LEFT_TO_RIGHT -> L2RPagerViewer(activity)
                 RIGHT_TO_LEFT -> R2LPagerViewer(activity)

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

@@ -41,7 +41,6 @@ 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
-import tachiyomi.core.common.util.system.ImageUtil
 
 /**
  * A wrapper view for showing page image.
@@ -241,7 +240,6 @@ open class ReaderPageImageView @JvmOverloads constructor(
         removeView(pageView)
 
         pageView = SubsamplingScaleImageView(context).apply {
-            setMaxTileSize(ImageUtil.hardwareBitmapThreshold)
             setDoubleTapZoomStyle(SubsamplingScaleImageView.ZOOM_FOCUS_CENTER)
             setPanLimit(SubsamplingScaleImageView.PAN_LIMIT_INSIDE)
             setMinimumTileDpi(180)
@@ -302,7 +300,6 @@ open class ReaderPageImageView @JvmOverloads constructor(
                 isVisible = true
             }
             is BufferedSource -> {
-                setHardwareConfig(ImageUtil.canUseHardwareBitmap(data))
                 setImage(ImageSource.inputStream(data.inputStream()))
                 isVisible = true
             }

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

@@ -0,0 +1,212 @@
+package eu.kanade.tachiyomi.ui.reader.viewer.webgpu
+
+import eu.kanade.tachiyomi.ui.reader.setting.ReaderPreferences
+import eu.kanade.tachiyomi.ui.reader.viewer.ReaderPageImageView
+import eu.kanade.tachiyomi.ui.reader.viewer.ViewerConfig
+import eu.kanade.tachiyomi.ui.reader.viewer.ViewerNavigation
+import eu.kanade.tachiyomi.ui.reader.viewer.navigation.DisabledNavigation
+import eu.kanade.tachiyomi.ui.reader.viewer.navigation.EdgeNavigation
+import eu.kanade.tachiyomi.ui.reader.viewer.navigation.KindlishNavigation
+import eu.kanade.tachiyomi.ui.reader.viewer.navigation.LNavigation
+import eu.kanade.tachiyomi.ui.reader.viewer.navigation.RightAndLeftNavigation
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+
+/**
+ * Configuration used by pager viewers.
+ */
+class WebGpuConfig(
+    private val viewer: WebGpuViewer,
+    scope: CoroutineScope,
+    readerPreferences: ReaderPreferences,
+) : ViewerConfig(readerPreferences, scope) {
+
+    var theme = readerPreferences.readerTheme.get()
+        private set
+
+    var automaticBackground = false
+        private set
+
+    var dualPageSplitChangedListener: ((Boolean) -> Unit)? = null
+
+    var imageScaleType = 1
+        private set
+
+    var imageZoomType = ReaderPageImageView.ZoomStartPosition.LEFT
+        private set
+
+    var imageCropBorders = false
+        private set
+
+    var imageCropBordersWebtoon = false
+        private set
+
+    var navigateToPan = false
+        private set
+
+    var landscapeZoom = false
+        private set
+
+    var transitionAnimation = ReaderPreferences.TransitionAnimation.BASIC
+        private set
+
+    var transitionAnimationDual = ReaderPreferences.TransitionAnimation.BASIC
+        private set
+
+    var cutoutMode = ReaderPreferences.CutoutMode.AVOID
+        private set
+
+    var cutoutModeDual = ReaderPreferences.CutoutMode.AVOID
+        private set
+
+    var dualPageView = ReaderPreferences.DualPageView.NEVER
+        private set
+
+    var continuousMinWidth = 100
+        private set
+
+    var zoomOutDisabled = false
+        private set
+
+    var continuousGap = 10
+        private set
+
+    init {
+        readerPreferences.readerTheme.register(
+            {
+                theme = it
+                automaticBackground = it == 3
+            },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.imageScaleType.register({ imageScaleType = it }, { imagePropertyChangedListener?.invoke() })
+
+        readerPreferences.zoomStart.register({ zoomTypeFromPreference(it) }, { imagePropertyChangedListener?.invoke() })
+
+        readerPreferences.cropBorders.register({ imageCropBorders = it }, { imagePropertyChangedListener?.invoke() })
+
+        readerPreferences.cropBordersWebtoon.register(
+            { imageCropBordersWebtoon = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.navigateToPan.register({ navigateToPan = it })
+
+        readerPreferences.landscapeZoom.register({ landscapeZoom = it }, { imagePropertyChangedListener?.invoke() })
+
+        readerPreferences.navigationModePager.register({ navigationMode = it }, { updateNavigation(navigationMode) })
+
+        readerPreferences.pagerNavInverted.register({ tappingInverted = it }, { navigator.invertMode = it })
+        readerPreferences.pagerNavInverted.changes().drop(1).onEach { navigationModeChangedListener?.invoke() }
+            .launchIn(scope)
+
+        readerPreferences.dualPageSplitPaged.register(
+            { dualPageSplit = it },
+            {
+                imagePropertyChangedListener?.invoke()
+                dualPageSplitChangedListener?.invoke(it)
+            },
+        )
+
+        readerPreferences.dualPageInvertPaged.register(
+            { dualPageInvert = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.dualPageRotateToFit.register(
+            { dualPageRotateToFit = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.dualPageRotateToFitInvert.register(
+            { dualPageRotateToFitInvert = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.transitionAnimation.register(
+            { transitionAnimation = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.transitionAnimationDual.register(
+            { transitionAnimationDual = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.cutoutMode.register(
+            { cutoutMode = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.cutoutModeDual.register(
+            { cutoutModeDual = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.dualPageView.register(
+            { dualPageView = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.continuousMinWidth.register(
+            { continuousMinWidth = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.webtoonDisableZoomOut.register(
+            { zoomOutDisabled = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+
+        readerPreferences.continuousGap.register(
+            { continuousGap = it },
+            { imagePropertyChangedListener?.invoke() },
+        )
+    }
+
+    private fun zoomTypeFromPreference(value: Int) {
+        imageZoomType = when (value) {
+            // Auto
+            1 -> if (viewer.isReversed) {
+                ReaderPageImageView.ZoomStartPosition.RIGHT
+            } else {
+                ReaderPageImageView.ZoomStartPosition.LEFT
+            }
+            // Left
+            2 -> ReaderPageImageView.ZoomStartPosition.LEFT
+            // Right
+            3 -> ReaderPageImageView.ZoomStartPosition.RIGHT
+            // Center
+            else -> ReaderPageImageView.ZoomStartPosition.CENTER
+        }
+    }
+
+    override var navigator: ViewerNavigation = defaultNavigation()
+        set(value) {
+            field = value.also { it.invertMode = this.tappingInverted }
+        }
+
+    override fun defaultNavigation(): ViewerNavigation {
+        return if (viewer.isVertical) {
+            LNavigation()
+        } else {
+            RightAndLeftNavigation()
+        }
+    }
+
+    override fun updateNavigation(navigationMode: Int) {
+        navigator = when (navigationMode) {
+            0 -> defaultNavigation()
+            1 -> LNavigation()
+            2 -> KindlishNavigation()
+            3 -> EdgeNavigation()
+            4 -> RightAndLeftNavigation()
+            5 -> DisabledNavigation()
+            else -> defaultNavigation()
+        }
+        navigationModeChangedListener?.invoke()
+    }
+}

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

@@ -0,0 +1,102 @@
+package eu.kanade.tachiyomi.ui.reader.viewer.webgpu
+
+import ca.mpreg.webgpuviewer.ImageViewContinuous
+import ca.mpreg.webgpuviewer.viewer.ImagePage
+import eu.kanade.tachiyomi.ui.reader.ReaderActivity
+import eu.kanade.tachiyomi.ui.reader.model.ReaderPage
+import kotlinx.coroutines.launch
+import kotlin.math.max
+
+class WebGpuViewerContinuous(activity: ReaderActivity, val useGap: Boolean = false) :
+    WebGpuViewer(activity, isReversed = false, isVertical = true, pager = ImageViewContinuous(activity)) {
+
+    override val isContinuous: Boolean get() = true
+
+    // How many pages the viewport shows depends on the zoom, and a page on screen has to be
+    // decoded rather than merely reserved - so the window follows what the last frame reached.
+    override val preloadAhead get() = max(3, state.pagesBelow)
+    override val preloadBehind get() = max(2, state.pagesAbove)
+
+    override val cacheSize get() = 2 + 2 * max(4, state.pagesAbove + state.pagesBelow)
+
+    private val state get() = (pager as ImageViewContinuous).state
+
+    init {
+        state.backgroundColor = readerBackgroundColor()
+
+        state.onViewport = { readThrough ->
+            val pageChanged = readThrough !== lastReadThrough
+            if (pageChanged) {
+                lastReadThrough = readThrough
+                readThrough?.let { select(it) }
+            }
+
+            val page0 = state.getPage(0)
+            val edge = (page0 is TransitionPage && page0.prevChapter == null) ||
+                (readThrough is TransitionPage && readThrough.nextChapter == null)
+
+            val first = wasAtEdge == null
+            val edgeChanged = edge != wasAtEdge
+            wasAtEdge = edge
+            if (edge) {
+                if (edgeChanged) scope.launch { activity.showMenu() }
+            } else if (!first && (edgeChanged || pageChanged) && !activity.isScrollingThroughPages) {
+                scope.launch { activity.hideMenu() }
+            }
+        }
+    }
+
+    /** Null until the first frame, so opening mid-document neither shows nor hides. */
+    @Volatile
+    private var wasAtEdge: Boolean? = null
+
+    @Volatile
+    private var lastReadThrough: ImagePage? = null
+
+    /**
+     * Mark [imagePage] read - its bottom has cleared the viewport, which is later than
+     * onPageChange's "top arrived" and the reason this mode selects from here: scrolling up to
+     * reveal the page above would otherwise walk progress back past pages still on screen.
+     */
+    private fun select(imagePage: ImagePage) {
+        val page = readerPageFor(imagePage) ?: return
+        scope.launch { activity.onPageSelected(page) }
+    }
+
+    private fun readerPageFor(imagePage: ImagePage): ReaderPage? {
+        // Off the page itself: a transition page is never currentPage (the scroll walk stops
+        // before it), so it is the first thing a preload evicts.
+        if (imagePage is TransitionPage) return imagePage.prevChapter?.pages?.lastOrNull()
+
+        // Only an image page needs the lookup - nothing on it names its ReaderPage. Evicted
+        // means scrolled well clear of, so there is no progress left to report.
+        return (viewerPageFor(imagePage) as? ViewerReaderPage)?.page
+    }
+
+    override fun destroy() {
+        state.onViewport = null
+        lastReadThrough = null
+        wasAtEdge = null
+        super.destroy()
+    }
+
+    private fun scrollByHalfPage(direction: Int) {
+        state.animateScroll(direction * state.height / 2f)
+    }
+
+    override fun moveRight() = scrollByHalfPage(1)
+
+    override fun moveLeft() = scrollByHalfPage(-1)
+
+    override fun moveToPage(page: ReaderPage) {
+        super.moveToPage(page)
+        wasAtEdge = null
+        lastReadThrough = null
+        // Also for a jump to the page already showing, which turns nothing to slide in.
+        state.resetScroll()
+    }
+
+    override fun animateTurn(direction: Int, fromSpread: ImagePage) {
+        state.animateSlideIn(direction)
+    }
+}

app/src/test/java/eu/kanade/tachiyomi/data/backup/BackupStreamTest.kt

@@ -0,0 +1,202 @@
+package eu.kanade.tachiyomi.data.backup
+
+import eu.kanade.tachiyomi.data.backup.models.Backup
+import eu.kanade.tachiyomi.data.backup.models.BackupCategory
+import eu.kanade.tachiyomi.data.backup.models.BackupChapter
+import eu.kanade.tachiyomi.data.backup.models.BackupExtensionStore
+import eu.kanade.tachiyomi.data.backup.models.BackupHistory
+import eu.kanade.tachiyomi.data.backup.models.BackupManga
+import eu.kanade.tachiyomi.data.backup.models.BackupPreference
+import eu.kanade.tachiyomi.data.backup.models.BackupSource
+import eu.kanade.tachiyomi.data.backup.models.BackupSourcePreferences
+import eu.kanade.tachiyomi.data.backup.models.BackupTracking
+import eu.kanade.tachiyomi.data.backup.models.BooleanPreferenceValue
+import eu.kanade.tachiyomi.data.backup.models.StringPreferenceValue
+import eu.kanade.tachiyomi.data.backup.models.StringSetPreferenceValue
+import io.kotest.matchers.shouldBe
+import kotlinx.serialization.protobuf.ProtoBuf
+import okio.Buffer
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.api.parallel.Execution
+import org.junit.jupiter.api.parallel.ExecutionMode
+import java.io.IOException
+
+@Execution(ExecutionMode.CONCURRENT)
+class BackupStreamTest {
+
+    private val parser = ProtoBuf
+
+    @Test
+    fun `writer output is the plain encoding`() {
+        val backup = backup()
+
+        val bytes = write(backup)
+
+        bytes shouldBe encode(backup)
+        encode(parser.decodeFromByteArray(Backup.serializer(), bytes)) shouldBe encode(backup)
+    }
+
+    @Test
+    fun `reader reads the plain encoding`() {
+        val backup = backup()
+
+        val (entries, metadata) = read(encode(backup))
+
+        entries.map(::encode) shouldBe backup.backupManga.map(::encode)
+        encode(metadata) shouldBe encode(backup.copy(backupManga = emptyList()))
+    }
+
+    @Test
+    fun `reader counts entries without decoding them`() {
+        val backup = backup()
+        val reader = BackupReader(Buffer().write(encode(backup)), parser)
+
+        var count = 0
+        while (reader.nextEntry()) {
+            reader.skipEntry()
+            count++
+        }
+
+        count shouldBe backup.backupManga.size
+        encode(reader.readMetadata()) shouldBe encode(backup.copy(backupManga = emptyList()))
+    }
+
+    @Test
+    fun `reader takes fields in any order`() {
+        val backup = backup()
+        val (first, second, third) = backup.backupManga
+        val input = Buffer()
+            .write(encode(Backup(emptyList(), backupSources = backup.backupSources)))
+            .write(encode(Backup(listOf(first))))
+            // Fields Backup doesn't know, one of each remaining wire type
+            .writeByte(3 shl 3 or 0).writeByte(0x96).writeByte(0x01)
+            .writeByte(4 shl 3 or 1).writeLongLe(42)
+            .write(encode(Backup(listOf(second), backupCategories = backup.backupCategories)))
+            .writeByte(5 shl 3 or 5).writeIntLe(42)
+            .write(encode(Backup(emptyList(), backupPreferences = backup.backupPreferences)))
+            .write(encode(Backup(listOf(third), backupExtensionStores = backup.backupExtensionStores)))
+            .write(encode(Backup(emptyList(), backupSourcePreferences = backup.backupSourcePreferences)))
+            .readByteArray()
+
+        val (entries, metadata) = read(input)
+
+        entries.map(::encode) shouldBe backup.backupManga.map(::encode)
+        encode(metadata) shouldBe encode(backup.copy(backupManga = emptyList()))
+    }
+
+    @Test
+    fun `empty backup`() {
+        val sink = Buffer()
+        val writer = BackupWriter(sink, parser)
+        writer.writeMetadata(Backup(emptyList()))
+
+        writer.isEmpty shouldBe true
+        sink.size shouldBe 0L
+
+        val (entries, metadata) = read(ByteArray(0))
+        entries shouldBe emptyList()
+        encode(metadata) shouldBe ByteArray(0)
+    }
+
+    @Test
+    fun `truncated input throws`() {
+        val bytes = encode(backup())
+
+        // Cut inside the last entry, inside the metadata, and right after a tag
+        val entryEnd = encode(Backup(backup().backupManga)).size
+        listOf(entryEnd - 1, bytes.size - 1, entryEnd + 1).forEach { size ->
+            assertThrows<IOException> { read(bytes.copyOf(size)) }
+        }
+    }
+
+    @Test
+    fun `garbage input throws`() {
+        listOf(
+            // Wire type 7 doesn't exist
+            byteArrayOf(0x0F),
+            // Field number 0
+            byteArrayOf(0x02, 0x00),
+            // A varint that never ends
+            ByteArray(11) { 0xFF.toByte() },
+            // An entry longer than the input
+            byteArrayOf(0x0A, 0x10, 0x01),
+            // An entry that isn't a BackupManga
+            byteArrayOf(0x0A, 0x02, 0x0F, 0x00),
+        ).forEach { input ->
+            assertThrows<IOException> { read(input) }
+        }
+    }
+
+    private fun write(backup: Backup): ByteArray {
+        val sink = Buffer()
+        val writer = BackupWriter(sink, parser)
+        backup.backupManga.forEach(writer::writeEntry)
+        writer.writeMetadata(backup.copy(backupManga = emptyList()))
+        writer.isEmpty shouldBe false
+        return sink.readByteArray()
+    }
+
+    private fun read(bytes: ByteArray): Pair<List<BackupManga>, Backup> {
+        val reader = BackupReader(Buffer().write(bytes), parser)
+        val entries = buildList {
+            while (reader.nextEntry()) add(reader.readEntry())
+        }
+        return entries to reader.readMetadata()
+    }
+
+    private fun encode(backup: Backup) = parser.encodeToByteArray(Backup.serializer(), backup)
+
+    private fun encode(manga: BackupManga) = parser.encodeToByteArray(BackupManga.serializer(), manga)
+
+    private fun backup() = Backup(
+        backupManga = listOf(
+            BackupManga(
+                source = 1L,
+                url = "/manga/1",
+                title = "First",
+                genre = listOf("Action", "Drama"),
+                chapters = listOf(
+                    BackupChapter(url = "/chapter/1", name = "Chapter 1", read = true, chapterNumber = 1f),
+                    BackupChapter(url = "/chapter/2", name = "Chapter 2", bookmark = true, lastPageRead = 4),
+                ),
+                categories = listOf(0L, 1L),
+                tracking = listOf(BackupTracking(syncId = 2, libraryId = 3L, title = "First", mediaId = 7L)),
+                history = listOf(BackupHistory(url = "/chapter/1", lastRead = 1_700_000_000_000L, readDuration = 60)),
+                excludedScanlators = listOf("Group"),
+            ),
+            BackupManga(source = 2L, url = "/manga/2", title = "Second", favorite = false),
+            BackupManga(
+                source = 1L,
+                url = "/manga/3",
+                title = "Third",
+                description = "x".repeat(300),
+                chapters = List(200) { BackupChapter(url = "/chapter/3/$it", name = "Chapter $it") },
+            ),
+        ),
+        backupCategories = listOf(
+            BackupCategory(name = "Reading", order = 0),
+            BackupCategory(name = "Done", order = 1),
+        ),
+        backupSources = listOf(BackupSource(name = "One", sourceId = 1L), BackupSource(name = "Two", sourceId = 2L)),
+        backupPreferences = listOf(
+            BackupPreference("flag", BooleanPreferenceValue(true)),
+            BackupPreference("tags", StringSetPreferenceValue(setOf("a", "b"))),
+        ),
+        backupSourcePreferences = listOf(
+            BackupSourcePreferences("source_1", listOf(BackupPreference("lang", StringPreferenceValue("en")))),
+        ),
+        backupExtensionStores = listOf(
+            BackupExtensionStore(
+                indexUrl = "https://example.org/index.min.json",
+                name = "Store",
+                badgeLabel = null,
+                signingKey = "key",
+                contactWebsite = "https://example.org",
+                contactDiscord = null,
+                isLegacy = false,
+                extensionListUrl = null,
+            ),
+        ),
+    )
+}

core/common/src/main/kotlin/eu/kanade/tachiyomi/util/system/GLUtil.kt

@@ -1,60 +0,0 @@
-package eu.kanade.tachiyomi.util.system
-
-import javax.microedition.khronos.egl.EGL10
-import javax.microedition.khronos.egl.EGLConfig
-import javax.microedition.khronos.egl.EGLContext
-import kotlin.math.max
-
-object GLUtil {
-    val DEVICE_TEXTURE_LIMIT: Int by lazy {
-        // Get EGL Display
-        val egl = EGLContext.getEGL() as EGL10
-        val display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY)
-
-        // Initialise
-        val version = IntArray(2)
-        egl.eglInitialize(display, version)
-
-        // Query total number of configurations
-        val totalConfigurations = IntArray(1)
-        egl.eglGetConfigs(display, null, 0, totalConfigurations)
-
-        // Query actual list configurations
-        val configurationsList = arrayOfNulls<EGLConfig>(totalConfigurations[0])
-        egl.eglGetConfigs(display, configurationsList, totalConfigurations[0], totalConfigurations)
-
-        val textureSize = IntArray(1)
-        var maximumTextureSize = 0
-
-        // Iterate through all the configurations to located the maximum texture size
-        for (i in 0..<totalConfigurations[0]) {
-            // Only need to check for width since opengl textures are always squared
-            egl.eglGetConfigAttrib(display, configurationsList[i], EGL10.EGL_MAX_PBUFFER_WIDTH, textureSize)
-
-            // Keep track of the maximum texture size
-            if (maximumTextureSize < textureSize[0]) maximumTextureSize = textureSize[0]
-        }
-
-        // Release
-        egl.eglTerminate(display)
-
-        // Return largest texture size found (after making it a multiplier of [Multiplier]), or default
-        max(maximumTextureSize, SAFE_TEXTURE_LIMIT)
-    }
-
-    const val SAFE_TEXTURE_LIMIT: Int = 2048
-
-    val CUSTOM_TEXTURE_LIMIT_OPTIONS: List<Int> by lazy {
-        val steps = DEVICE_TEXTURE_LIMIT / MULTIPLIER
-        buildList(steps) {
-            add(DEVICE_TEXTURE_LIMIT)
-            for (step in steps downTo 2) {
-                val value = step * MULTIPLIER
-                if (value >= DEVICE_TEXTURE_LIMIT) continue
-                add(value)
-            }
-        }
-    }
-}
-
-private const val MULTIPLIER: Int = 1024

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

@@ -21,13 +21,11 @@ import androidx.core.graphics.drawable.toDrawable
 import androidx.core.graphics.get
 import androidx.core.graphics.green
 import androidx.core.graphics.red
+import ca.mpreg.imagedecoder.ImageDecoder
 import com.hippo.unifile.UniFile
-import eu.kanade.tachiyomi.util.system.GLUtil
 import logcat.LogPriority
 import okio.Buffer
 import okio.BufferedSource
-import tachiyomi.decoder.Format
-import tachiyomi.decoder.ImageDecoder
 import java.io.InputStream
 import java.util.Locale
 import kotlin.math.abs
@@ -49,17 +47,20 @@ object ImageUtil {
 
     fun findImageType(stream: InputStream): ImageType? {
         return try {
-            when (getImageType(stream)?.format) {
-                Format.Avif -> ImageType.AVIF
-                Format.Gif -> ImageType.GIF
-                Format.Heif -> ImageType.HEIF
-                Format.Jpeg -> ImageType.JPEG
-                Format.Jxl -> ImageType.JXL
-                Format.Png -> ImageType.PNG
-                Format.Webp -> ImageType.WEBP
+            val format = ImageDecoder.open(stream).use { dec -> dec.format }
+            when (format) {
+                ImageDecoder.Format.JPEG -> ImageType.JPEG
+                ImageDecoder.Format.PNG -> ImageType.PNG
+                ImageDecoder.Format.WEBP -> ImageType.WEBP
+                ImageDecoder.Format.GIF -> ImageType.GIF
+                ImageDecoder.Format.AVIF -> ImageType.AVIF
+                ImageDecoder.Format.HEIF -> ImageType.HEIF
+                ImageDecoder.Format.JXL -> ImageType.JXL
+                ImageDecoder.Format.JP2 -> ImageType.JP2
                 else -> null
             }
         } catch (e: Exception) {
+            logcat(LogPriority.ERROR) { "findImageType: ${e.message}" }
             null
         }
     }
@@ -71,38 +72,22 @@ object ImageUtil {
 
     fun isAnimatedAndSupported(source: BufferedSource): Boolean {
         return try {
-            val type = getImageType(source.peek().inputStream()) ?: return false
-            // https://coil-kt.github.io/coil/getting_started/#supported-image-formats
-            when (type.format) {
-                Format.Gif -> true
-                // Animated WebP on Android 9+
-                Format.Webp -> type.isAnimated && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P
-                // Animated Heif on Android 11+
-                Format.Heif -> type.isAnimated && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
+            val type = findImageType(source.peek().inputStream()) ?: return false
+            when (type) {
+                ImageType.GIF -> true
+                ImageType.WEBP, ImageType.HEIF -> {
+                    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) return false
+                    ImageDecoder.open(source.peek().inputStream()).use { dec -> dec.pages > 1 }
+                }
+
                 else -> false
             }
         } catch (e: Exception) {
+            logcat(LogPriority.ERROR) { "isAnimatedAndSupported: ${e.message}" }
             false
         }
     }
 
-    private fun getImageType(stream: InputStream): tachiyomi.decoder.ImageType? {
-        val bytes = ByteArray(32)
-
-        val length = if (stream.markSupported()) {
-            stream.mark(bytes.size)
-            stream.read(bytes, 0, bytes.size).also { stream.reset() }
-        } else {
-            stream.read(bytes, 0, bytes.size)
-        }
-
-        if (length == -1) {
-            return null
-        }
-
-        return ImageDecoder.findType(bytes)
-    }
-
     enum class ImageType(val mime: String, val extension: String) {
         AVIF("image/avif", "avif"),
         GIF("image/gif", "gif"),
@@ -111,6 +96,8 @@ object ImageUtil {
         JXL("image/jxl", "jxl"),
         PNG("image/png", "png"),
         WEBP("image/webp", "webp"),
+        JP2("image/jp2", "jp2"),
+        JPX("image/jpx", "jpx"),
     }
 
     /**
@@ -312,30 +299,24 @@ object ImageUtil {
         val bottomOffset = topOffset + splitHeight
     }
 
-    fun canUseHardwareBitmap(bitmap: Bitmap): Boolean {
-        return canUseHardwareBitmap(bitmap.width, bitmap.height)
-    }
-
-    fun canUseHardwareBitmap(imageSource: BufferedSource): Boolean {
-        return with(extractImageOptions(imageSource)) {
-            canUseHardwareBitmap(outWidth, outHeight)
-        }
-    }
-
-    var hardwareBitmapThreshold: Int = GLUtil.SAFE_TEXTURE_LIMIT
-
-    private fun canUseHardwareBitmap(width: Int, height: Int): Boolean {
-        if (HARDWARE_BITMAP_UNSUPPORTED) return false
-        return maxOf(width, height) <= hardwareBitmapThreshold
-    }
-
     /**
      * Algorithm for determining what background to accompany a comic/manga page
      */
     fun chooseBackground(context: Context, imageStream: InputStream): Drawable {
-        val decoder = ImageDecoder.newInstance(imageStream)
-        val image = decoder?.decode()
-        decoder?.recycle()
+        val image = try {
+            ImageDecoder.open(imageStream).use { it.decodeNext() to it.isHdr }.let { (res, hdr) ->
+                res.use {
+                    val config = if (hdr) Bitmap.Config.RGBA_F16 else Bitmap.Config.ARGB_8888
+                    createBitmap(res.width, res.height, config).also { bitmap ->
+                        res.image.rewind()
+                        bitmap.copyPixelsFromBuffer(res.image)
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR) { "chooseBackground: ${e.message}" }
+            null
+        }
 
         if (image == null) return Color.WHITE.toDrawable()
         return try {
@@ -583,121 +564,6 @@ object ImageUtil {
     }
 
     private val optimalImageHeight = getDisplayMaxHeightInPx * 2
-
-    /**
-     * Taken from Coil
-     * (https://github.com/coil-kt/coil/blob/1674d3516f061aeacbe749a435b1924f9648fd41/coil-core/src/androidMain/kotlin/coil3/util/hardwareBitmaps.kt)
-     * ---
-     * Maintains a list of devices with broken/incomplete/unstable hardware bitmap implementations.
-     *
-     * Model names are retrieved from
-     * [Google's official device list](https://support.google.com/googleplay/answer/1727131?hl=en).
-     *
-     */
-    val HARDWARE_BITMAP_UNSUPPORTED = when (Build.VERSION.SDK_INT) {
-        26 -> run {
-            val model = Build.MODEL ?: return@run false
-
-            // Samsung Galaxy (ALL)
-            if (model.removePrefix("SAMSUNG-").startsWith("SM-")) return@run true
-
-            val device = Build.DEVICE ?: return@run false
-
-            return@run device in arrayOf(
-                "nora", "nora_8917", "nora_8917_n", // Moto E5
-                "james", "rjames_f", "rjames_go", "pettyl", // Moto E5 Play
-                "hannah", "ahannah", "rhannah", // Moto E5 Plus
-
-                "ali", "ali_n", // Moto G6
-                "aljeter", "aljeter_n", "jeter", // Moto G6 Play
-                "evert", "evert_n", "evert_nt", // Moto G6 Plus
-
-                "G3112", "G3116", "G3121", "G3123", "G3125", // Xperia XA1
-                "G3412", "G3416", "G3421", "G3423", "G3426", // Xperia XA1 Plus
-                "G3212", "G3221", "G3223", "G3226", // Xperia XA1 Ultra
-
-                "BV6800Pro", // BlackView BV6800Pro
-                "CatS41", // Cat S41
-                "Hi9Pro", // CHUWI Hi9 Pro
-                "manning", // Lenovo K8 Note
-                "N5702L", // NUU Mobile G3
-            )
-        }
-
-        27 -> run {
-            val device = Build.DEVICE ?: return@run false
-
-            return@run device in arrayOf(
-                "mcv1s", // LG Tribute Empire
-                "mcv3", // LG K11
-                "mcv5a", // LG Q7
-                "mcv7a", // LG Stylo 4
-
-                "A30ATMO", // T-Mobile REVVL 2
-                "A70AXLTMO", // T-Mobile REVVL 2 PLUS
-
-                "A3A_8_4G_TMO", // Alcatel 9027W
-                "Edison_CKT", // Alcatel ONYX
-                "EDISON_TF", // Alcatel TCL XL2
-                "FERMI_TF", // Alcatel A501DL
-                "U50A_ATT", // Alcatel TETRA
-                "U50A_PLUS_ATT", // Alcatel 5059R
-                "U50A_PLUS_TF", // Alcatel TCL LX
-                "U50APLUSTMO", // Alcatel 5059Z
-                "U5A_PLUS_4G", // Alcatel 1X
-
-                "RCT6513W87DK5e", // RCA Galileo Pro
-                "RCT6873W42BMF9A", // RCA Voyager
-                "RCT6A03W13", // RCA 10 Viking
-                "RCT6B03W12", // RCA Atlas 10 Pro
-                "RCT6B03W13", // RCA Atlas 10 Pro+
-                "RCT6T06E13", // RCA Artemis 10
-
-                "A3_Pro", // Umidigi A3 Pro
-                "One", // Umidigi One
-                "One_Max", // Umidigi One Max
-                "One_Pro", // Umidigi One Pro
-                "Z2", // Umidigi Z2
-                "Z2_PRO", // Umidigi Z2 Pro
-
-                "Armor_3", // Ulefone Armor 3
-                "Armor_6", // Ulefone Armor 6
-
-                "Blackview", // Blackview BV6000
-                "BV9500", // Blackview BV9500
-                "BV9500Pro", // Blackview BV9500Pro
-
-                "A6L-C", // Nuu A6L-C
-                "N5002LA", // Nuu A7L
-                "N5501LA", // Nuu A5L
-
-                "Power_2_Pro", // Leagoo Power 2 Pro
-                "Power_5", // Leagoo Power 5
-                "Z9", // Leagoo Z9
-
-                "V0310WW", // Blu VIVO VI+
-                "V0330WW", // Blu VIVO XI
-
-                "A3", // BenQ A3
-                "ASUS_X018_4", // Asus ZenFone Max Plus M1 (ZB570TL)
-                "C210AE", // Wiko Life
-                "fireball", // DROID Incredible 4G LTE
-                "ILA_X1", // iLA X1
-                "Infinix-X605_sprout", // Infinix NOTE 5 Stylus
-                "j7maxlte", // Samsung Galaxy J7 Max
-                "KING_KONG_3", // Cubot King Kong 3
-                "M10500", // Packard Bell M10500
-                "S70", // Altice ALTICE S70
-                "S80Lite", // Doogee S80Lite
-                "SGINO6", // SGiNO 6
-                "st18c10bnn", // Barnes and Noble BNTV650
-                "TECNO-CA8", // Tecno CAMON X Pro,
-                "SHIFT6m", // SHIFT 6m
-            )
-        }
-
-        else -> false
-    }
 }
 
 val getDisplayMaxHeightInPx: Int

data/src/main/java/tachiyomi/data/category/CategoryRepositoryImpl.kt

@@ -50,6 +50,15 @@ class CategoryRepositoryImpl(
             .subscribeToList()
     }
 
+    override suspend fun getCategoriesByMangaIds(mangaIds: List<Long>): Map<Long, List<Category>> {
+        return database.categoryQueries
+            .getCategoriesByMangaIds(mangaIds) { mangaId, id, name, order, flags ->
+                mangaId to mapCategory(id, name, order, flags)
+            }
+            .awaitAsList()
+            .groupBy({ it.first }, { it.second })
+    }
+
     override suspend fun insert(category: NewCategory) {
         database.categoryQueries.insert(name = category.name, flags = category.flags)
     }

data/src/main/java/tachiyomi/data/chapter/ChapterRepositoryImpl.kt

@@ -113,6 +113,13 @@ class ChapterRepositoryImpl(
             .awaitAsList()
     }
 
+    override suspend fun getChaptersByMangaIds(mangaIds: List<Long>): Map<Long, List<Chapter>> {
+        return database.chapterQueries
+            .getChaptersByMangaIds(mangaIds, ::mapChapter)
+            .awaitAsList()
+            .groupBy { it.mangaId }
+    }
+
     override suspend fun getChapterSummaryByMangaId(mangaId: Long): ChapterSummary {
         return database.chapterQueries
             .getChapterSummaryByMangaId(mangaId) { total, latestChapterNumber ->

data/src/main/java/tachiyomi/data/history/HistoryRepositoryImpl.kt

@@ -48,6 +48,15 @@ class HistoryRepositoryImpl(
             .awaitAsList()
     }
 
+    override suspend fun getHistoryByMangaIds(mangaIds: List<Long>): Map<Long, List<History>> {
+        return database.historyQueries
+            .getHistoryByMangaIds(mangaIds) { mangaId, id, chapterId, readAt, readDuration ->
+                mangaId to HistoryMapper.mapHistory(id, chapterId, readAt, readDuration)
+            }
+            .awaitAsList()
+            .groupBy({ it.first }, { it.second })
+    }
+
     override suspend fun resetHistory(historyId: Long) {
         try {
             database.historyQueries.resetHistoryById(historyId)

data/src/main/java/tachiyomi/data/manga/MangaRepositoryImpl.kt

@@ -144,6 +144,13 @@ class MangaRepositoryImpl(
             .toSet()
     }
 
+    override suspend fun getExcludedScanlatorsByMangaIds(mangaIds: List<Long>): Map<Long, List<String>> {
+        return database.excluded_scanlatorQueries
+            .getExcludedScanlatorsByMangaIds(mangaIds)
+            .awaitAsList()
+            .groupBy({ it.manga_id }, { it.scanlator })
+    }
+
     override fun getExcludedScanlatorsAsFlow(mangaId: Long): Flow<Set<String>> {
         return database.excluded_scanlatorQueries
             .getExcludedScanlatorsByMangaId(mangaId)

data/src/main/java/tachiyomi/data/track/TrackRepositoryImpl.kt

@@ -31,6 +31,13 @@ class TrackRepositoryImpl(
             .awaitAsList()
     }
 
+    override suspend fun getTracksByMangaIds(mangaIds: List<Long>): Map<Long, List<Track>> {
+        return database.manga_trackQueries
+            .getTracksByMangaIds(mangaIds, TrackMapper::mapTrack)
+            .awaitAsList()
+            .groupBy { it.mangaId }
+    }
+
     override suspend fun getTracks(): List<Track> {
         return database.manga_trackQueries
             .getTracks(TrackMapper::mapTrack)

data/src/main/sqldelight/tachiyomi/data/category.sq

@@ -34,6 +34,14 @@ ON C.id = MC.category_id
 WHERE MC.manga_id = :mangaId
 ORDER BY C.`order`;
 
+getCategoriesByMangaIds:
+SELECT MC.manga_id, C.id, C.name, C.`order`, C.flags
+FROM category C
+JOIN manga_category MC
+ON C.id = MC.category_id
+WHERE MC.manga_id IN :mangaIds
+ORDER BY MC.manga_id, C.`order`;
+
 insert:
 -- The position is taken inside the insert, so two categories created at once cannot claim the same one
 INSERT INTO category(name, `order`, flags)

data/src/main/sqldelight/tachiyomi/data/chapter.sq

@@ -48,6 +48,16 @@ AND (
     OR ES.scanlator IS NULL
 );
 
+getChaptersByMangaIds:
+-- The unique index's order, which getChaptersByMangaId returns too, so backups keep their chapter order
+SELECT
+    id, manga_id, remote_url, remote_name, remote_scanlator, remote_chapter_number,
+    remote_date_upload, remote_order, remote_memo, user_read, user_bookmark,
+    user_last_page_read, state_date_fetch
+FROM chapter
+WHERE manga_id IN :mangaIds
+ORDER BY manga_id, remote_url;
+
 getChapterSummaryByMangaId:
 SELECT count(*) AS total, max(remote_chapter_number) AS latestChapterNumber
 FROM chapter

data/src/main/sqldelight/tachiyomi/data/excluded_scanlator.sq

@@ -21,3 +21,9 @@ getExcludedScanlatorsByMangaId:
 SELECT scanlator
 FROM excluded_scanlator
 WHERE manga_id = :mangaId;
+
+getExcludedScanlatorsByMangaIds:
+SELECT manga_id, scanlator
+FROM excluded_scanlator
+WHERE manga_id IN :mangaIds
+ORDER BY manga_id, scanlator;

data/src/main/sqldelight/tachiyomi/data/history.sq

@@ -20,6 +20,12 @@ SELECT id, chapter_id, read_at, read_duration
 FROM history
 WHERE manga_id = :mangaId;
 
+getHistoryByMangaIds:
+SELECT manga_id, id, chapter_id, read_at, read_duration
+FROM history
+WHERE manga_id IN :mangaIds
+ORDER BY manga_id, id;
+
 resetHistoryById:
 UPDATE history
 SET read_at = NULL

data/src/main/sqldelight/tachiyomi/data/manga_track.sq

@@ -48,6 +48,14 @@ SELECT
 FROM manga_track
 WHERE manga_id = :mangaId;
 
+getTracksByMangaIds:
+SELECT
+    id, manga_id, tracker_id, remote_id, remote_url, library_id, title, last_chapter_read,
+    total_chapters, status, score, start_date, finish_date, private
+FROM manga_track
+WHERE manga_id IN :mangaIds
+ORDER BY manga_id, tracker_id;
+
 upsert:
 INSERT INTO manga_track(
     manga_id, tracker_id, remote_id, remote_url, library_id, title, last_chapter_read,

domain/src/main/java/tachiyomi/domain/category/repository/CategoryRepository.kt

@@ -16,6 +16,8 @@ interface CategoryRepository {
 
     fun getCategoriesByMangaIdAsFlow(mangaId: Long): Flow<List<Category>>
 
+    suspend fun getCategoriesByMangaIds(mangaIds: List<Long>): Map<Long, List<Category>>
+
     suspend fun insert(category: NewCategory)
 
     suspend fun insertAll(categories: List<NewCategory>)

domain/src/main/java/tachiyomi/domain/chapter/repository/ChapterRepository.kt

@@ -20,6 +20,8 @@ interface ChapterRepository {
 
     suspend fun getChapterByMangaId(mangaId: Long, applyScanlatorFilter: Boolean = false): List<Chapter>
 
+    suspend fun getChaptersByMangaIds(mangaIds: List<Long>): Map<Long, List<Chapter>>
+
     suspend fun getChapterSummaryByMangaId(mangaId: Long): ChapterSummary
 
     suspend fun getScanlatorsByMangaId(mangaId: Long): List<String>

domain/src/main/java/tachiyomi/domain/history/repository/HistoryRepository.kt

@@ -15,6 +15,8 @@ interface HistoryRepository {
 
     suspend fun getHistoryByMangaId(mangaId: Long): List<History>
 
+    suspend fun getHistoryByMangaIds(mangaIds: List<Long>): Map<Long, List<History>>
+
     suspend fun resetHistory(historyId: Long)
 
     suspend fun resetHistoryByMangaId(mangaId: Long)

domain/src/main/java/tachiyomi/domain/manga/repository/MangaRepository.kt

@@ -43,6 +43,8 @@ interface MangaRepository {
 
     suspend fun getExcludedScanlators(mangaId: Long): Set<String>
 
+    suspend fun getExcludedScanlatorsByMangaIds(mangaIds: List<Long>): Map<Long, List<String>>
+
     fun getExcludedScanlatorsAsFlow(mangaId: Long): Flow<Set<String>>
 
     suspend fun setExcludedScanlators(mangaId: Long, excludedScanlators: Set<String>)

domain/src/main/java/tachiyomi/domain/track/repository/TrackRepository.kt

@@ -9,6 +9,8 @@ interface TrackRepository {
 
     suspend fun getTracksByMangaId(mangaId: Long): List<Track>
 
+    suspend fun getTracksByMangaIds(mangaIds: List<Long>): Map<Long, List<Track>>
+
     suspend fun getTracks(): List<Track>
 
     fun getTracksAsFlow(): Flow<List<Track>>

gradle/libs.versions.toml

@@ -16,7 +16,7 @@ androidx-glance = "1.2.0"
 androidx-interpolator = "1.0.0"
 androidx-lifecycle = "2.11.0"
 androidx-navigationEvent = "1.2.0"
-androidx-paging = "3.5.2"
+androidx-paging = "3.5.3"
 androidx-preference = "1.2.1"
 androidx-profileInstaller = "1.4.1"
 androidx-recyclerView = "1.4.0"
@@ -42,7 +42,7 @@ firebase-bom = "35.0.0"
 firebase-crashlytics = "3.0.8"
 flexibleAdapter = "5.1.0"
 google-services = "4.5.0"
-image-decoder = "e03b81e18a"
+image-decoder = "16"
 injekt = "1.16.1"
 jsoup = "1.23.2"
 junit = "6.1.3"
@@ -71,12 +71,13 @@ spotless = "8.10.4"
 sqldelight = "2.4.1"
 sqldelight-androidx-driver = "0.2.2"
 stringSimilarity = "0.1.0"
-subsamplingScaleImageView = "66e0db195d"
+subsamplingScaleImageView = "1b283e2bc4"
 swipe = "1.3.0"
 tapmoc = "0.4.2"
 unifile = "08f224c8f9"
 valkyrie = "0.5.2"
 voyager = "2.2.21-1.10.3"
+webgpuviewer = "52"
 xmlutil = "1.0.2"
 
 [libraries]
@@ -141,7 +142,7 @@ firebase-analytics = { module = "com.google.firebase:firebase-analytics" }
 firebase-bom = { module = "com.google.firebase:firebase-bom", version.ref = "firebase-bom" }
 firebase-crashlytics = { module = "com.google.firebase:firebase-crashlytics" }
 flexibleAdapter = { module = "eu.davidea:flexible-adapter", version.ref = "flexibleAdapter" }
-image-decoder = { module = "com.github.mihonapp:image-decoder", version.ref = "image-decoder" }
+image-decoder = { module = "ca.mpreg:imagedecoder", version.ref = "image-decoder" }
 injekt = { module = "uy.kohesive.injekt:injekt-core", version.ref = "injekt" }
 jsoup = { module = "org.jsoup:jsoup", version.ref = "jsoup" }
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit" }
@@ -191,13 +192,14 @@ sqldelight-async = { module = "app.cash.sqldelight:async-extensions", version.re
 sqldelight-coroutines = { module = "app.cash.sqldelight:coroutines-extensions", version.ref = "sqldelight" }
 sqldelight-sqliteDialect338 = { module = "app.cash.sqldelight:sqlite-3-38-dialect", version.ref = "sqldelight" }
 stringSimilarity = { module = "com.aallam.similarity:string-similarity-kotlin", version.ref = "stringSimilarity" }
-subsamplingScaleImageView = { module = "com.github.tachiyomiorg:subsampling-scale-image-view", version.ref = "subsamplingScaleImageView" }
+subsamplingScaleImageView = { module = "com.github.mihonapp:subsampling-scale-image-view", version.ref = "subsamplingScaleImageView" }
 swipe = { module = "me.saket.swipe:swipe", version.ref = "swipe" }
 tapmoc-gradle = { module = "com.gradleup.tapmoc:tapmoc-gradle-plugin", version.ref = "tapmoc" }
 unifile = { module = "com.github.mihon:unifile", version.ref = "unifile" }
 voyager-navigator = { module = "cafe.adriel.voyager:voyager-navigator", version.ref = "voyager" }
 voyager-tabNavigator = { module = "cafe.adriel.voyager:voyager-tab-navigator", version.ref = "voyager" }
 voyager-transitions = { module = "cafe.adriel.voyager:voyager-transitions", version.ref = "voyager" }
+webgpuviewer = { module = "ca.mpreg:webgpuviewer", version.ref = "webgpuviewer" }
 xmlutil-core = { module = "io.github.pdvrieze.xmlutil:core-android", version.ref = "xmlutil" }
 xmlutil-serialization = { module = "io.github.pdvrieze.xmlutil:serialization", version.ref = "xmlutil" }
 

i18n/src/commonMain/moko-resources/base/strings.xml

@@ -427,9 +427,7 @@
     <string name="pref_webtoon_vertical_navigator_on_left">Place vertical navigator on the left side</string>
     <string name="pref_show_reading_mode">Show reading mode</string>
     <string name="pref_show_reading_mode_summary">Briefly show current mode when reader is opened</string>
-    <string name="pref_hardware_bitmap_threshold">Custom hardware bitmap threshold</string>
-    <string name="pref_hardware_bitmap_threshold_default">Default (%d)</string>
-    <string name="pref_hardware_bitmap_threshold_summary">If reader loads a blank image incrementally reduce the threshold.\nSelected: %s</string>
+    <string name="pref_high_quality_renderer">Use high quality renderer</string>
     <string name="pref_display_profile">Custom display profile</string>
     <string name="pref_crop_borders">Crop borders</string>
     <string name="pref_custom_brightness">Custom brightness</string>
@@ -519,6 +517,34 @@
     <string name="pref_low">Low</string>
     <string name="pref_lowest">Lowest</string>
     <string name="pref_webtoon_disable_zoom_out">Disable zoom out</string>
+    <string name="webgpu_viewer">WebGPU</string>
+    <string name="pref_transition_animation">Transition animation</string>
+    <string name="pref_transition_animation_dual">Transition animation (dual)</string>
+    <string name="transition_animation_basic">Basic</string>
+    <string name="transition_animation_flip_left">Page flip (left)</string>
+    <string name="transition_animation_flip_right">Page flip (right)</string>
+    <string name="transition_animation_stack_left">Stack (left)</string>
+    <string name="transition_animation_stack_right">Stack (right)</string>
+    <string name="transition_animation_stack_up">Stack (up)</string>
+    <string name="transition_animation_stack_down">Stack (down)</string>
+    <string name="transition_animation_sphere">Sphere</string>
+    <string name="transition_animation_cube_inside">Cube (Inside)</string>
+    <string name="transition_animation_cube_outside">Cube (Outside)</string>
+    <string name="transition_animation_fade">Fade</string>
+    <string name="transition_animation_fade_white">Fade to white</string>
+    <string name="transition_animation_none">None</string>
+    <string name="transition_animation_flip">Page flip</string>
+    <string name="pref_cutout_mode">Display cutout mode</string>
+    <string name="pref_cutout_mode_dual">Display cutout mode (dual)</string>
+    <string name="cutout_mode_ignore">Ignore</string>
+    <string name="cutout_mode_avoid">Avoid</string>
+    <string name="cutout_mode_shift">Shift</string>
+    <string name="pref_dual_page_view">Dual page view</string>
+    <string name="dual_page_view_never">Never</string>
+    <string name="dual_page_view_always">Always</string>
+    <string name="dual_page_view_wide">When wide</string>
+    <string name="pref_continuous_minwidth">Min width</string>
+    <string name="pref_continuous_gap">Gap</string>
 
       <!-- Downloads section -->
     <string name="pref_category_delete_chapters">Delete chapters</string>