fix debian

Trigger Build
fx
2026-08-27 17:31:31 +00:00 · 2026-08-23 06:47:16 +02:00 · 2026-08-23 06:47:16 +02:00 · 2026-08-23 06:47:16 +02:00 · 2026-08-23 06:47:16 +02:00 · 2026-08-23 06:47:16 +02:00
111 changed files with 1513 additions and 5587 deletions
@@ -1,28 +0,0 @@
-From cc15da16e533b2a801934eab2dfeaf3c3949a1dc Mon Sep 17 00:00:00 2001
-From: crueter <crueter@eden-emu.dev>
-Date: Mon, 8 Sep 2025 12:28:55 -0400
-Subject: [PATCH] [cmake] disable NEON runtime check on clang-cl
-
-When enabling runtime NEON checking for clang-cl, the linker would error out with `undefined symbol: __emit`, since clang doesn't actually implement this instruction. Therefore it makes sense to disable the runtime check by default on this platform, until either this is fixed or a clang-cl compatible intrinsic check is added (I don't have enough knowledge of MSVC to do this)
---
- cmake/OpusConfig.cmake | 7 ++++++-
- 1 file changed, 6 insertions(+), 1 deletion(-)
-
-diff --git a/cmake/OpusConfig.cmake b/cmake/OpusConfig.cmake
-index e9319fbad..d0f459e88 100644
--- a/cmake/OpusConfig.cmake
-+++ b/cmake/OpusConfig.cmake
-@@ -71,7 +71,12 @@ elseif(OPUS_CPU_ARM AND NOT OPUS_DISABLE_INTRINSICS)
-   opus_detect_neon(COMPILER_SUPPORT_NEON)
-   if(COMPILER_SUPPORT_NEON)
-     option(OPUS_USE_NEON "Option to enable NEON" ON)
-    option(OPUS_MAY_HAVE_NEON "Does runtime check for neon support" ON)
-+    if (MSVC AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-+      set(NEON_RUNTIME_CHECK_DEFAULT OFF)
-+    else()
-+      set(NEON_RUNTIME_CHECK_DEFAULT ON)
-+    endif()
-+    option(OPUS_MAY_HAVE_NEON "Does runtime check for neon support" ${NEON_RUNTIME_CHECK_DEFAULT})
-     option(OPUS_PRESUME_NEON "Assume target CPU has NEON support" OFF)
-     if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-       set(OPUS_PRESUME_NEON ON)
@@ -1,153 +0,0 @@
-From bf455b67b4eaa446ffae5d25410b141b7b1b1082 Mon Sep 17 00:00:00 2001
-From: crueter <crueter@eden-emu.dev>
-Date: Mon, 8 Sep 2025 12:08:20 -0400
-Subject: [PATCH] [cmake] `OPUS_INSTALL` option; only default install if root
- project
-
-Signed-off-by: crueter <crueter@eden-emu.dev>
---
- CMakeLists.txt | 112 ++++++++++++++++++++++++++++---------------------
- 1 file changed, 64 insertions(+), 48 deletions(-)
-
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index fcf034b19..08b5e16f8 100644
--- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -4,6 +4,13 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
- include(OpusPackageVersion)
- get_package_version(PACKAGE_VERSION PROJECT_VERSION)
- 
-+# root project detection
-+if(DEFINED PROJECT_NAME)
-+  set(root_project OFF)
-+else()
-+  set(root_project ON)
-+endif()
-+
- project(Opus LANGUAGES C VERSION ${PROJECT_VERSION})
- 
- include(OpusFunctions)
-@@ -83,12 +90,16 @@ set(OPUS_DNN_FLOAT_DEBUG_HELP_STR "Run DNN computations as float for debugging p
- option(OPUS_DNN_FLOAT_DEBUG ${OPUS_DNN_FLOAT_DEBUG_HELP_STR} OFF)
- add_feature_info(OPUS_DNN_FLOAT_DEBUG OPUS_DNN_FLOAT_DEBUG ${OPUS_DNN_FLOAT_DEBUG_HELP_STR})
- 
-+set(OPUS_INSTALL_HELP_STR "Install Opus targets")
-+option(OPUS_INSTALL ${OPUS_INSTALL_HELP_STR} ${root_project})
-+add_feature_info(OPUS_INSTALL OPUS_INSTALL ${OPUS_INSTALL_HELP_STR})
-+
- set(OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR "install pkg-config module.")
-option(OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR} ON)
-+option(OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR} ${OPUS_INSTALL})
- add_feature_info(OPUS_INSTALL_PKG_CONFIG_MODULE OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR})
- 
- set(OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR "install CMake package config module.")
-option(OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR} ON)
-+option(OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR} ${OPUS_INSTALL})
- add_feature_info(OPUS_INSTALL_CMAKE_CONFIG_MODULE OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR})
- 
- set(OPUS_DRED_HELP_STR "enable DRED.")
-@@ -613,53 +624,58 @@ if(OPUS_BUILD_FRAMEWORK)
-                         OUTPUT_NAME Opus)
- endif()
- 
-install(TARGETS opus
-        EXPORT OpusTargets
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-        FRAMEWORK DESTINATION ${CMAKE_INSTALL_PREFIX}
-        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/opus)
-
-if(OPUS_INSTALL_PKG_CONFIG_MODULE)
-  set(prefix ${CMAKE_INSTALL_PREFIX})
-  set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-  set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
-  set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
-  set(VERSION ${PACKAGE_VERSION})
-  if(HAVE_LIBM)
-    set(LIBM "-lm")
-+if (OPUS_INSTALL)
-+  install(TARGETS opus
-+          EXPORT OpusTargets
-+          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-+          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-+          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-+          FRAMEWORK DESTINATION ${CMAKE_INSTALL_PREFIX}
-+          PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/opus)
-+
-+  if(OPUS_INSTALL_PKG_CONFIG_MODULE)
-+    set(prefix ${CMAKE_INSTALL_PREFIX})
-+    set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-+    set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
-+    set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
-+    set(VERSION ${PACKAGE_VERSION})
-+    if(HAVE_LIBM)
-+      set(LIBM "-lm")
-+    endif()
-+    configure_file(opus.pc.in opus.pc)
-+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/opus.pc
-+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-+  endif()
-+
-+  if(OPUS_INSTALL_CMAKE_CONFIG_MODULE)
-+    set(CPACK_GENERATOR TGZ)
-+    include(CPack)
-+    set(CMAKE_INSTALL_PACKAGEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
-+    install(EXPORT OpusTargets
-+            NAMESPACE Opus::
-+            DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
-+
-+    include(CMakePackageConfigHelpers)
-+
-+    set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
-+    configure_package_config_file(
-+      ${PROJECT_SOURCE_DIR}/cmake/OpusConfig.cmake.in
-+      OpusConfig.cmake
-+      INSTALL_DESTINATION
-+      ${CMAKE_INSTALL_PACKAGEDIR}
-+      PATH_VARS
-+      INCLUDE_INSTALL_DIR
-+      INSTALL_PREFIX
-+      ${CMAKE_INSTALL_PREFIX})
-+
-+    write_basic_package_version_file(OpusConfigVersion.cmake
-+                                    VERSION ${PROJECT_VERSION}
-+                                    COMPATIBILITY SameMajorVersion)
-+
-+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/OpusConfig.cmake
-+                  ${CMAKE_CURRENT_BINARY_DIR}/OpusConfigVersion.cmake
-+            DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
-   endif()
-  configure_file(opus.pc.in opus.pc)
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/opus.pc
-          DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-endif()
-
-if(OPUS_INSTALL_CMAKE_CONFIG_MODULE)
-  set(CPACK_GENERATOR TGZ)
-  include(CPack)
-  set(CMAKE_INSTALL_PACKAGEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
-  install(EXPORT OpusTargets
-          NAMESPACE Opus::
-          DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
-
-  include(CMakePackageConfigHelpers)
-
-  set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
-  configure_package_config_file(${PROJECT_SOURCE_DIR}/cmake/OpusConfig.cmake.in
-                                OpusConfig.cmake
-                                INSTALL_DESTINATION
-                                ${CMAKE_INSTALL_PACKAGEDIR}
-                                PATH_VARS
-                                INCLUDE_INSTALL_DIR
-                                INSTALL_PREFIX
-                                ${CMAKE_INSTALL_PREFIX})
-  write_basic_package_version_file(OpusConfigVersion.cmake
-                                   VERSION ${PROJECT_VERSION}
-                                   COMPATIBILITY SameMajorVersion)
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/OpusConfig.cmake
-                ${CMAKE_CURRENT_BINARY_DIR}/OpusConfigVersion.cmake
-          DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
- endif()
- 
- if(OPUS_BUILD_PROGRAMS)
@@ -461,21 +461,6 @@ if (NOT YUZU_STATIC_ROOM)
    if (ZLIB_ADDED)
        add_library(ZLIB::ZLIB ALIAS zlibstatic)
    endif()
-
-    # Opus
-    AddJsonPackage(opus)
-
-    if (Opus_ADDED)
-        if (MSVC AND CXX_CLANG)
-            target_compile_options(opus PRIVATE
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-function-declaration>
-            )
-        endif()
-    endif()
-
-    if (NOT TARGET Opus::opus)
-        add_library(Opus::opus ALIAS opus)
-    endif()
 endif()

 if(NOT TARGET Boost::headers)
@@ -1,22 +0,0 @@
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-# SPDX-FileCopyrightText: 2022 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-find_package(PkgConfig QUIET)
-pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Opus
-    REQUIRED_VARS OPUS_LINK_LIBRARIES
-    VERSION_VAR OPUS_VERSION
-)
-
-if (MSYS2)
-    FixMsysPath(PkgConfig::OPUS)
-endif()
-
-if (Opus_FOUND AND NOT TARGET Opus::opus)
-    add_library(Opus::opus ALIAS PkgConfig::OPUS)
-endif()
@@ -218,21 +218,6 @@
        "repo": "jimmy-park/openssl-cmake",
        "version": "3.6.2"
    },
-    "opus": {
-        "find_args": "MODULE",
-        "hash": "9506147b0de35befda8633ff272981cc2575c860874791bd455b752f797fd7dbd1079f0ba42ccdd7bb1fe6773fa5e84b3d75667c2883dd1fb2d0e4a5fa4f8387",
-        "min_version": "1.3",
-        "options": [
-            "OPUS_PRESUME_NEON ON"
-        ],
-        "package": "Opus",
-        "patches": [
-            "0001-disable-clang-runtime-neon.patch",
-            "0002-no-install.patch"
-        ],
-        "repo": "xiph/opus",
-        "version": "a3f0ec02b3"
-    },
    "quazip": {
        "hash": "609c240c7f029ac26a37d8fbab51bc16284e05e128b78b9b9c0e95d083538c36047a67d682759ac990e4adb0eeb90f04f1ea7fe2253bbda7e7e3bcce32e53dd8",
        "min_version": "1.3",
@@ -60,7 +60,6 @@ All other dependencies will be downloaded and built by [CPM](https://github.com/
 * [ZLIB](https://www.zlib.net/) 1.2+
 * [zstd](https://facebook.github.io/zstd/) 1.5+
 * [enet](http://enet.bespin.org/) 1.3+
-* [Opus](https://opus-codec.org/) 1.3+

 Vulkan 1.3.274+ is also needed:

@@ -122,7 +121,7 @@ sudo emerge -a \
    dev-libs/unordered_dense dev-libs/boost dev-libs/openssl dev-libs/discord-rpc \
    dev-util/spirv-tools dev-util/spirv-headers dev-util/vulkan-headers \
    dev-util/vulkan-utility-libraries dev-util/glslang \
-    media-gfx/renderdoc media-libs/libva media-libs/opus media-video/ffmpeg \
+    media-gfx/renderdoc media-libs/libva media-video/ffmpeg \
    media-libs/VulkanMemoryAllocator media-libs/libsdl3 media-libs/cubeb \
    net-libs/enet \
    sys-libs/zlib \
@@ -154,7 +153,7 @@ Required USE flags:
 <summary>Arch Linux</summary>

 ```sh
-sudo pacman -Syu --needed base-devel boost catch2 cmake enet ffmpeg fmt git glslang libzip lz4 ninja nlohmann-json openssl opus qt6-base qt6-multimedia qt6-charts sdl3 zlib zstd zip unzip vulkan-headers vulkan-utility-libraries libusb spirv-tools spirv-headers
+sudo pacman -Syu --needed base-devel boost catch2 cmake enet ffmpeg fmt git glslang libzip lz4 ninja nlohmann-json openssl qt6-base qt6-multimedia qt6-charts sdl3 zlib zstd zip unzip vulkan-headers vulkan-utility-libraries libusb spirv-tools spirv-headers
 ```

 * Building with QT Web Engine requires `qt6-webengine` as well.
@@ -167,7 +166,7 @@ sudo pacman -Syu --needed base-devel boost catch2 cmake enet ffmpeg fmt git glsl
 <summary>Ubuntu, Debian, Mint Linux</summary>

 ```sh
-sudo apt-get install autoconf cmake g++ gcc git glslang-tools libglu1-mesa-dev libhidapi-dev libpulse-dev libtool libudev-dev libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-render-util0 libxcb-xinerama0 libxcb-xkb1 libxext-dev libxkbcommon-x11-0 mesa-common-dev nasm ninja-build qt6-base-private-dev catch2 libfmt-dev liblz4-dev nlohmann-json3-dev libzstd-dev libssl-dev libavfilter-dev libavcodec-dev libswscale-dev pkg-config zlib1g-dev libva-dev libvdpau-dev qt6-tools-dev qt6-charts-dev libvulkan-dev spirv-tools spirv-headers libusb-1.0-0-dev libxbyak-dev libboost-dev libboost-fiber-dev libboost-context-dev libsdl3-dev libopus-dev libasound2t64 vulkan-utility-libraries-dev
+sudo apt-get install autoconf cmake g++ gcc git glslang-tools libglu1-mesa-dev libhidapi-dev libpulse-dev libtool libudev-dev libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-render-util0 libxcb-xinerama0 libxcb-xkb1 libxext-dev libxkbcommon-x11-0 mesa-common-dev nasm ninja-build qt6-base-private-dev catch2 libfmt-dev liblz4-dev nlohmann-json3-dev libzstd-dev libssl-dev libavfilter-dev libavcodec-dev libswscale-dev pkg-config zlib1g-dev libva-dev libvdpau-dev qt6-tools-dev qt6-charts-dev libvulkan-dev spirv-tools spirv-headers libusb-1.0-0-dev libxbyak-dev libboost-dev libboost-fiber-dev libboost-context-dev libsdl3-dev libasound2t64 vulkan-utility-libraries-dev
 ```

 * Ubuntu 26.04, Linux Mint 22.3, or Debian 13 or later is required.
@@ -214,7 +213,7 @@ First, enable the community repository; [see here](https://wiki.alpinelinux.org/
 # Enable the community repository
 setup-apkrepos -c
 # Install
-apk add g++ git cmake make mesa-dev qt6-qtbase-dev qt6-qtbase-private-dev libquazip1-qt6 ffmpeg-dev qt6-charts-dev libusb-dev libtool boost-dev sdl3-dev zstd-dev vulkan-utility-libraries spirv-tools-dev openssl-dev nlohmann-json lz4-dev opus-dev jq patch
+apk add g++ git cmake make mesa-dev qt6-qtbase-dev qt6-qtbase-private-dev libquazip1-qt6 ffmpeg-dev qt6-charts-dev libusb-dev libtool boost-dev sdl3-dev zstd-dev vulkan-utility-libraries spirv-tools-dev openssl-dev nlohmann-json lz4-dev  jq patch
 ```

 </details>
@@ -260,7 +259,7 @@ brew install molten-vk
 <details>
 <summary>FreeBSD</summary>

-As root run: `pkg install devel/cmake sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/qt6-charts devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg audio/opus archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib devel/unordered-dense vulkan-headers quazip-qt6`
+As root run: `pkg install devel/cmake sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/qt6-charts devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib devel/unordered-dense vulkan-headers quazip-qt6`

 If using FreeBSD 12 or prior, use `devel/pkg-config` instead.

@@ -273,7 +272,7 @@ If using FreeBSD 12 or prior, use `devel/pkg-config` instead.
 For NetBSD +10.1:

 ```sh
-pkgin install git cmake boost fmtlib SDL3 catch2 libjwt spirv-headers spirv-tools ffmpeg7 libva nlohmann-json jq libopus qt6 cpp-httplib lz4 vulkan-headers nasm autoconf enet pkg-config libusb1 libcxx frozen
+pkgin install git cmake boost fmtlib SDL3 catch2 libjwt spirv-headers spirv-tools ffmpeg7 libva nlohmann-json jq qt6 cpp-httplib lz4 vulkan-headers nasm autoconf enet pkg-config libusb1 libcxx frozen
 ```

 [Caveats](./Caveats.md#netbsd).
@@ -304,7 +303,7 @@ pkg install gcc14 git cmake unzip nasm autoconf bash pkgconf ffmpeg glslang gmak
 <summary>OpenIndiana</summary>

 ```sh
-sudo pkg install git cmake qt6 boost glslang libzip library/lz4 libusb-1 nlohmann-json openssl opus sdl3 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt
+sudo pkg install git cmake qt6 boost glslang libzip library/lz4 libusb-1 nlohmann-json openssl sdl3 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt
 ```

 [Caveats](./Caveats.md#openindiana).
@@ -328,7 +327,7 @@ sudo pkgin install git cmake autoconf build-essential libusb-1 nasm gcc13

 ```sh
 BASE="git make autoconf libtool automake-wrapper jq patch"
-MINGW="qt6-base qt6-charts qt6-tools qt6-translations qt6-svg cmake toolchain clang python-pip openssl vulkan-memory-allocator vulkan-devel glslang boost fmt lz4 nlohmann-json zlib zstd enet opus libusb unordered_dense openssl SDL3"
+MINGW="qt6-base qt6-charts qt6-tools qt6-translations qt6-svg cmake toolchain clang python-pip openssl vulkan-memory-allocator vulkan-devel glslang boost fmt lz4 nlohmann-json zlib zstd enet libusb unordered_dense openssl SDL3"
 # Either x86_64 or clang-aarch64 (Windows on ARM)
 packages="$BASE"
 for pkg in $MINGW; do
@@ -354,7 +353,7 @@ pacman -Syuu --needed --noconfirm $packages
 <summary>HaikuOS</summary>

 ```sh
-pkgman install git cmake patch libfmt_devel nlohmann_json lz4_devel opus_devel boost1.90_devel vulkan_devel qt6_base_devel qt6_declarative_devel libsdl3_devel ffmpeg7_devel libx11_devel enet_devel catch2_devel quazip1_qt5_devel qt6_5compat_devel glslang qt6_devel qt6_charts_devel cubeb_devel simpleini quazip_qt6_devel
+pkgman install git cmake patch libfmt_devel nlohmann_json lz4_devel boost1.90_devel vulkan_devel qt6_base_devel qt6_declarative_devel libsdl3_devel ffmpeg7_devel libx11_devel enet_devel catch2_devel quazip1_qt5_devel qt6_5compat_devel glslang qt6_devel qt6_charts_devel cubeb_devel simpleini quazip_qt6_devel
 ```

 [Caveats](./Caveats.md#haikuos).
@@ -12,7 +12,7 @@ pkgs.mkShellNoCC {
    git cmake clang gnumake patch jq pkg-config
    # libraries
    openssl boost fmt nlohmann_json lz4 zlib zstd
-    enet libopus vulkan-headers vulkan-utility-libraries
+    enet vulkan-headers vulkan-utility-libraries
    spirv-tools spirv-headers vulkan-loader unzip
    glslang python3 httplib cpp-jwt ffmpeg-headless
    libusb1 cubeb
@@ -27,7 +27,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
    RENDERER_ASYNCHRONOUS_GPU_EMULATION("use_asynchronous_gpu_emulation"),
    RENDERER_ASYNC_PRESENTATION("async_presentation"),
    RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
-    RENDERER_UNIFIED_MEMORY("use_unified_memory"),
    RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
    ENABLE_BUFFER_HISTORY("enable_buffer_history"),
    USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
@@ -624,7 +624,6 @@ abstract class SettingsItem(
                    IntSetting.FSR_SHARPENING_SLIDER,
                    titleId = R.string.fsr_sharpness,
                    descriptionId = R.string.fsr_sharpness_description,
-                    max = 200,
                    units = "%"
                )
            )
@@ -789,13 +788,6 @@ abstract class SettingsItem(
                    descriptionId = R.string.renderer_asynchronous_shaders_description
                )
            )
-            put(
-                SwitchSetting(
-                    BooleanSetting.RENDERER_UNIFIED_MEMORY,
-                    titleId = R.string.renderer_unified_memory,
-                    descriptionId = R.string.renderer_unified_memory_description
-                )
-            )
            put(
                SingleChoiceSetting(
                    IntSetting.FAST_GPU_TIME,
@@ -344,7 +344,6 @@ class SettingsFragmentPresenter(
            add(BooleanSetting.FIX_BLOOM_EFFECTS.key)
            add(BooleanSetting.EMULATE_BGR565.key)
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
-            add(BooleanSetting.RENDERER_UNIFIED_MEMORY.key)
            add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
            add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)
@@ -1182,7 +1182,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                    container,
                    IntSetting.FSR_SHARPENING_SLIDER,
                    minValue = 0,
-                    maxValue = 200,
+                    maxValue = 100,
                    units = "%"
                )
            }
@@ -79,13 +79,6 @@ class LicensesFragment : Fragment() {
                R.string.license_ffmpeg_copyright,
                R.string.license_ffmpeg_text
            ),
-            License(
-                R.string.license_opus,
-                R.string.license_opus_description,
-                R.string.license_opus_link,
-                R.string.license_opus_copyright,
-                R.string.license_opus_text
-            ),
            License(
                R.string.license_sirit,
                R.string.license_sirit_description,
@@ -1107,6 +1107,7 @@
    <string name="theme_mode_light">فاتح</string>
    <string name="theme_mode_dark">داكن</string>

+    <string name="multiplier_none">لا شيء</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">خلفيات سوداء</string>
@@ -991,6 +991,7 @@ Wirklich fortfahren?</string>
    <string name="theme_mode_light">Hell</string>
    <string name="theme_mode_dark">Dunkel</string>

+    <string name="multiplier_none">Keine</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">Schwarze Hintergründe</string>
@@ -1092,6 +1092,7 @@
    <string name="theme_mode_light">Claro</string>
    <string name="theme_mode_dark">Oscuro</string>

+    <string name="multiplier_none">Nada</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">Fondos oscuros</string>
@@ -808,6 +808,9 @@
    <string name="multiplier_x4">x4</string>
    <string name="multiplier_x8">x8</string>
    <string name="multiplier_x16">x16</string>
+    <string name="multiplier_x32">x32</string>
+    <string name="multiplier_x64">x64</string>
+    <string name="multiplier_none">None</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">پس‌زمینه مشکی</string>
@@ -1004,6 +1004,7 @@
    <string name="theme_mode_light">Lumineux</string>
    <string name="theme_mode_dark">Sombre</string>

+    <string name="multiplier_none">Aucun</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">Arrière-plan noir</string>
@@ -935,6 +935,7 @@
    <string name="theme_mode_light">Jasny</string>
    <string name="theme_mode_dark">Ciemny</string>

+    <string name="multiplier_none">Brak</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">Czarne tła</string>
@@ -891,6 +891,7 @@
    <string name="theme_mode_light">Claro</string>
    <string name="theme_mode_dark">Escuro</string>

+    <string name="multiplier_none">Nenhum</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">Planos de fundo pretos</string>
@@ -1071,6 +1071,7 @@
    <string name="theme_mode_light">Светлая</string>
    <string name="theme_mode_dark">Темная</string>

+    <string name="multiplier_none">Отключено</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">Чёрный фон</string>
@@ -1053,6 +1053,7 @@
    <string name="theme_mode_light">Світла</string>
    <string name="theme_mode_dark">Темна</string>

+    <string name="multiplier_none">Жодного</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">Чорний фон</string>
@@ -1081,6 +1081,7 @@
    <string name="theme_mode_light">浅色</string>
    <string name="theme_mode_dark">深色</string>

+    <string name="multiplier_none">无</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">使用黑色背景</string>
@@ -1006,6 +1006,7 @@
    <string name="theme_mode_light">淺色</string>
    <string name="theme_mode_dark">深色</string>

+    <string name="multiplier_none">無</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">黑色背景</string>
@@ -111,38 +111,43 @@
        <item>1</item>
    </integer-array>

+    <!-- VRAM USAGE MODE CHOICES -->
    <string-array name="vramUsageMethodNames">
        <item>@string/vram_usage_conservative</item>
        <item>@string/vram_usage_aggressive</item>
    </string-array>

+    <!-- VRAM USAGE MODE VALUES -->
    <integer-array name="vramUsageMethodValues">
-        <item>0</item>
-        <item>1</item>
+        <item>0</item> <!-- Conservative -->
+        <item>1</item> <!-- Aggressive -->
    </integer-array>

+    <!-- ASTC Decoding Method Choices -->
    <string-array name="astcDecodingMethodNames">
        <item>@string/accelerate_astc_cpu</item>
        <item>@string/accelerate_astc_gpu</item>
        <item>@string/accelerate_astc_async</item>
    </string-array>

+    <!-- ASTC Decoding Method Values -->
    <integer-array name="astcDecodingMethodValues">
-        <item>0</item>
-        <item>1</item>
-        <item>2</item>
+        <item>0</item> <!-- CPU -->
+        <item>1</item> <!-- GPU -->
+        <item>2</item> <!-- CPU Asynchronously -->
    </integer-array>
-
+    <!-- NVDEC Emulation Choices -->
    <string-array name="rendererNvdecNames">
-        <item>@string/nvdec_emulation_none</item>
-        <item>@string/nvdec_emulation_cpu</item>
-        <item>@string/nvdec_emulation_gpu</item>
+        <item>@string/nvdec_emulation_none</item> <!-- Off -->
+        <item>@string/nvdec_emulation_cpu</item>  <!-- Cpu -->
+        <item>@string/nvdec_emulation_gpu</item>  <!-- Gpu -->
    </string-array>

+    <!-- NVDEC Emulation Values -->
    <integer-array name="rendererNvdecValues">
-        <item>0</item>
-        <item>1</item>
-        <item>2</item>
+        <item>3</item> <!-- Off value -->
+        <item>1</item> <!-- CPU value -->
+        <item>2</item> <!-- GPU value -->
    </integer-array>

    <string-array name="rendererResolutionNames">
@@ -508,6 +513,9 @@
        <item>@string/multiplier_x4</item>
        <item>@string/multiplier_x8</item>
        <item>@string/multiplier_x16</item>
+        <item>@string/multiplier_x32</item>
+        <item>@string/multiplier_x64</item>
+        <item>@string/multiplier_none</item>
    </string-array>
    <integer-array name="anisoValues">
        <item>0</item>
@@ -516,6 +524,9 @@
        <item>3</item>
        <item>4</item>
        <item>5</item>
+        <item>6</item>
+        <item>7</item>
+        <item>8</item>
    </integer-array>

    <string-array name="verticalAlignmentEntries">
@@ -585,8 +585,6 @@
    <string name="rescale_hack_description">Enables a legacy handling for the rescale configuration pass for games by using a quick rescale path</string>
    <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
    <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
-    <string name="renderer_unified_memory">Unified memory access</string>
-    <string name="renderer_unified_memory_description">Allows GPU write buffer readbacks directly into guest memory, skipping the CPU staging copy.</string>
    <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>
    <string name="gpu_unswizzle_settings_description">Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality.</string>
    <string name="gpu_unswizzle_enable">Enable GPU Unswizzle</string>
@@ -1248,6 +1246,9 @@
    <string name="multiplier_x4" translatable="false">x4</string>
    <string name="multiplier_x8" translatable="false">x8</string>
    <string name="multiplier_x16" translatable="false">x16</string>
+    <string name="multiplier_x32" translatable="false">x32</string>
+    <string name="multiplier_x64" translatable="false">x64</string>
+    <string name="multiplier_none">None</string>

    <!-- Black backgrounds theme -->
    <string name="use_black_backgrounds">Black backgrounds</string>
@@ -1762,51 +1763,6 @@ RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
 FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 DAMAGES.
-    </string>
-    <string name="license_opus" translatable="false">Opus</string>
-    <string name="license_opus_description" translatable="false">Modern audio compression for the internet</string>
-    <string name="license_opus_link" translatable="false">https://github.com/xiph/opus</string>
-    <string name="license_opus_copyright" translatable="false">Copyright 2001–2011 Xiph.Org, Skype Limited, Octasic, Jean-Marc Valin, Timothy B. Terriberry, CSIRO, Gregory Maxwell, Mark Borgerding, Erik de Castro Lopo</string>
-    <string name="license_opus_text" translatable="false">
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:\n\n
-
- Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.\n\n
-
- Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.\n\n
-
- Neither the name of Internet Society, IETF or IETF Trust, nor the
-names of specific contributors, may be used to endorse or promote
-products derived from this software without specific prior written
-permission.\n\n
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-``AS IS\'\' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n
-
-Opus is subject to the royalty-free patent licenses which are
-specified at:\n\n
-
-Xiph.Org Foundation:
-https://datatracker.ietf.org/ipr/1524/ \n\n
-
-Microsoft Corporation:
-https://datatracker.ietf.org/ipr/1914/ \n\n
-
-Broadcom Corporation:
-https://datatracker.ietf.org/ipr/1526/
    </string>
    <string name="license_sirit" translatable="false">Sirit</string>
    <string name="license_sirit_description" translatable="false">A runtime SPIR-V assembler</string>
@@ -226,8 +226,14 @@ else()
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>)
 endif()

-target_include_directories(audio_core PRIVATE ${OPUS_INCLUDE_DIRS})
-target_link_libraries(audio_core PUBLIC common core Opus::opus)
+if (YUZU_USE_EXTERNAL_FFMPEG)
+    add_dependencies(audio_core ffmpeg-build)
+endif()
+target_include_directories(audio_core PUBLIC ${FFmpeg_INCLUDE_DIR})
+target_link_libraries(audio_core PRIVATE ${FFmpeg_LIBRARIES})
+target_link_options(audio_core PRIVATE ${FFmpeg_LDFLAGS})
+
+target_link_libraries(audio_core PUBLIC common core)

 if (ENABLE_CUBEB)
    target_sources(audio_core PRIVATE
@@ -1,107 +1,71 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavcodec/codec.h>
+#include <libavcodec/packet.h>
+#include <libavutil/channel_layout.h>
+#include <libavutil/frame.h>
+}
 #include "audio_core/adsp/apps/opus/opus_decode_object.h"
+#include "audio_core/adsp/apps/opus/opus_types.h"
 #include "common/assert.h"
+#include "core/hle/service/audio/errors.h"

 namespace AudioCore::ADSP::OpusDecoder {
-namespace {
-bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
-}
-} // namespace

 u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {
-    if (!IsValidChannelCount(channel_count)) {
-        return 0;
-    }
-    return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
+    if (channel_count == 1 || channel_count == 2)
+        return u32(sizeof(OpusDecodeObject)) + 16 * channel_count;
+    return 0;
 }

-OpusDecodeObject& OpusDecodeObject::Initialize(u64 buffer, u64 buffer2) {
-    auto* new_decoder = reinterpret_cast<OpusDecodeObject*>(buffer);
-    auto* comparison = reinterpret_cast<OpusDecodeObject*>(buffer2);
-
-    if (new_decoder->magic == DecodeObjectMagic) {
-        if (!new_decoder->initialized ||
-            (new_decoder->initialized && new_decoder->self == comparison)) {
-            new_decoder->state_valid = true;
-        }
-    } else {
-        new_decoder->initialized = false;
-        new_decoder->state_valid = true;
-    }
-    return *new_decoder;
+Result OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {
+    if ((codec = avcodec_find_decoder(AV_CODEC_ID_OPUS)) == nullptr)
+        return Service::Audio::ResultLibOpusInvalidState;
+    if ((avctx = avcodec_alloc_context3(codec)) == nullptr)
+        return Service::Audio::ResultLibOpusInvalidState;
+    avctx->sample_rate = sample_rate;
+    av_channel_layout_default(&avctx->ch_layout, channel_count);
+    return ResultSuccess;
 }

-s32 OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        return OPUS_OK;
-    }
-
-    // Unfortunately libopus does not expose the OpusDecoder struct publicly, so we can't include
-    // it in this class. Nintendo does not allocate memory, which is why we have a workbuffer
-    // provided.
-    // We could use _create and have libopus allocate it for us, but then we have to separately
-    // track which decoder is being used between this and multistream in order to call the correct
-    // destroy from the host side.
-    // This is a bit cringe, but is safe as these objects are only ever initialized inside the given
-    // workbuffer, and GetWorkBufferSize will guarantee there's enough space to follow.
-    decoder = (LibOpusDecoder*)(this + 1);
-    s32 ret = opus_decoder_init(decoder, sample_rate, channel_count);
-    if (ret == OPUS_OK) {
-        magic = DecodeObjectMagic;
-        initialized = true;
-        state_valid = true;
-        self = this;
-        final_range = 0;
-    }
-    return ret;
+Result OpusDecodeObject::Shutdown() {
+    if (avctx)
+        avcodec_free_context(&avctx);
+    return ResultSuccess;
 }

-s32 OpusDecodeObject::Shutdown() {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+Result OpusDecodeObject::ResetDecoder() {
+    if (avctx) {
+        avcodec_flush_buffers(avctx);
+        return ResultSuccess;
    }
-
-    if (initialized) {
-        magic = 0x0;
-        initialized = false;
-        state_valid = false;
-        self = nullptr;
-        final_range = 0;
-        decoder = nullptr;
-    }
-    return OPUS_OK;
+    return Service::Audio::ResultLibOpusInvalidState;
 }

-s32 OpusDecodeObject::ResetDecoder() {
-    return opus_decoder_ctl(decoder, OPUS_RESET_STATE);
-}
-
-s32 OpusDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size,
-                             u64 input_data, u64 input_data_size) {
-    ASSERT(initialized);
+Result OpusDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data, u64 input_data_size) {
    out_sample_count = 0;
+    if (avctx) {
+        AVPacket* avpkt = av_packet_alloc();
+        av_new_packet(avpkt, int(input_data_size));
+        std::memcpy(avpkt->data, reinterpret_cast<const u8*>(input_data), input_data_size);
+        avcodec_send_packet(avctx, avpkt);

-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+        AVFrame* frame = av_frame_alloc();
+        avcodec_receive_frame(avctx, frame);
+        std::memcpy(reinterpret_cast<u16*>(output_data), frame->data, output_data_size);
+        av_frame_free(&frame);
+        av_packet_free(&avpkt);
+
+        out_sample_count = frame->nb_samples;
+        return ResultSuccess;
    }
-
-    auto ret_code_or_samples = opus_decode(
-        decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),
-        reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);
-
-    if (ret_code_or_samples < OPUS_OK) {
-        return ret_code_or_samples;
-    }
-
-    out_sample_count = ret_code_or_samples;
-    return opus_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
+    return Service::Audio::ResultLibOpusInvalidState;
 }

 } // namespace AudioCore::ADSP::OpusDecoder
@@ -1,38 +1,31 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

-#include <opus.h>
-
 #include "common/common_types.h"
+#include "audio_core/adsp/apps/opus/opus_types.h"
+#include "core/hle/result.h"
+
+struct AVCodec;
+struct AVCodecContext;

 namespace AudioCore::ADSP::OpusDecoder {
-using LibOpusDecoder = ::OpusDecoder;
-static constexpr u32 DecodeObjectMagic = 0xDEADBEEF;

 class OpusDecodeObject {
 public:
    static u32 GetWorkBufferSize(u32 channel_count);
-    static OpusDecodeObject& Initialize(u64 buffer, u64 buffer2);

-    s32 InitializeDecoder(u32 sample_rate, u32 channel_count);
-    s32 Shutdown();
-    s32 ResetDecoder();
-    s32 Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data,
-               u64 input_data_size);
-    u32 GetFinalRange() const noexcept {
-        return final_range;
-    }
+    Result InitializeDecoder(u32 sample_rate, u32 channel_count);
+    Result Shutdown();
+    Result ResetDecoder();
+    Result Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data, u64 input_data_size);

-private:
-    u32 magic;
-    bool initialized;
-    bool state_valid;
-    OpusDecodeObject* self;
-    u32 final_range;
-    LibOpusDecoder* decoder;
+    AVCodec const* codec = nullptr;
+    AVCodecContext* avctx = nullptr;
 };
-static_assert(std::is_trivially_constructible_v<OpusDecodeObject>);

 } // namespace AudioCore::ADSP::OpusDecoder
@@ -16,6 +16,7 @@
 #include "common/thread.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/hle/service/audio/errors.h"

 namespace AudioCore::ADSP::OpusDecoder {

@@ -49,11 +50,16 @@ OpusDecoder::~OpusDecoder() {
    // Shutdown the thread
    Send(Direction::DSP, Message::Shutdown);
    auto msg = Receive(Direction::Host);
-    ASSERT_MSG(msg == Message::ShutdownOK, "Expected Opus shutdown code {}, got {}",
-               Message::ShutdownOK, msg);
+    ASSERT_MSG(msg == Message::ShutdownOK, "Expected Opus shutdown code {}, got {}", Message::ShutdownOK, msg);
    main_thread.request_stop();
    main_thread.join();
    running = false;
+
+    // Must shutdown as there are AV allocations which are manual
+    for (auto& e : decode_objects)
+        e.second.Shutdown();
+    for (auto& e : ms_decode_objects)
+        e.second.Shutdown();
 }

 void OpusDecoder::Send(Direction dir, u32 message) {
@@ -68,202 +74,195 @@ void OpusDecoder::Init(std::stop_token stop_token) {
    Common::SetCurrentThreadName("DSP_OpusDecoder_Init");

    if (Receive(Direction::DSP, stop_token) != Message::Start) {
-        LOG_ERROR(Service_Audio,
-                  "DSP OpusDecoder failed to receive Start message. Opus initialization failed.");
+        LOG_ERROR(Service_Audio, "DSP OpusDecoder failed to receive Start message. Opus initialization failed.");
        return;
    }
-    main_thread = std::jthread([this](std::stop_token st) { Main(st); });
+    // Main OpusDecoder thread, responsible for processing the incoming Opus packets.
+    main_thread = std::jthread([this](std::stop_token thread_stop_token) {
+        Common::SetCurrentThreadName("DSP_OpusDecoder_Main");
+        while (!thread_stop_token.stop_requested()) {
+            auto msg = Receive(Direction::DSP, thread_stop_token);
+            switch (msg) {
+            case Shutdown:
+                Send(Direction::Host, Message::ShutdownOK);
+                return;
+            case GetWorkBufferSize: {
+                auto channel_count = s32(shared_memory->host_send_data[0]);
+
+                ASSERT(IsValidChannelCount(channel_count));
+
+                shared_memory->dsp_return_data[0] = OpusDecodeObject::GetWorkBufferSize(channel_count);
+                Send(Direction::Host, Message::GetWorkBufferSizeOK);
+                break;
+            }
+            case InitializeDecodeObject: {
+                auto buffer = shared_memory->host_send_data[0];
+                auto buffer_size = shared_memory->host_send_data[1];
+                auto sample_rate = s32(shared_memory->host_send_data[2]);
+                auto channel_count = s32(shared_memory->host_send_data[3]);
+
+                ASSERT(sample_rate >= 0);
+                ASSERT(IsValidChannelCount(channel_count));
+                ASSERT(buffer_size >= OpusDecodeObject::GetWorkBufferSize(channel_count));
+
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    it->second.Shutdown();
+                    shared_memory->dsp_return_data[0] = it->second.InitializeDecoder(sample_rate, channel_count).raw;
+                } else {
+                    OpusDecodeObject obj{};
+                    shared_memory->dsp_return_data[0] = obj.InitializeDecoder(sample_rate, channel_count).raw;
+                    decode_objects.insert_or_assign(buffer, obj);
+                }
+                Send(Direction::Host, Message::InitializeDecodeObjectOK);
+                break;
+            }
+            case ShutdownDecodeObject: {
+                auto buffer = shared_memory->host_send_data[0];
+                //[[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    shared_memory->dsp_return_data[0] = it->second.Shutdown().raw;
+                } else {
+                    LOG_ERROR(Audio_DSP, "operating unregistered buffer {}", buffer);
+                    shared_memory->dsp_return_data[0] = Service::Audio::ResultLibOpusInvalidState.raw;
+                }
+                Send(Direction::Host, Message::ShutdownDecodeObjectOK);
+                break;
+            }
+            case DecodeInterleaved: {
+                auto start_time = system.CoreTiming().GetGlobalTimeUs();
+
+                auto buffer = shared_memory->host_send_data[0];
+                auto input_data = shared_memory->host_send_data[1];
+                auto input_data_size = shared_memory->host_send_data[2];
+                auto output_data = shared_memory->host_send_data[3];
+                auto output_data_size = shared_memory->host_send_data[4];
+                //auto final_range = static_cast<u32>(shared_memory->host_send_data[5]);
+                auto reset_requested = shared_memory->host_send_data[6];
+
+                u32 decoded_samples{0};
+
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    auto res = ResultSuccess;
+                    if (reset_requested)
+                        res = it->second.ResetDecoder();
+                    if (res == ResultSuccess)
+                        res = it->second.Decode(decoded_samples, output_data, output_data_size, input_data, input_data_size);
+
+                    auto end_time = system.CoreTiming().GetGlobalTimeUs();
+                    shared_memory->dsp_return_data[0] = res.raw;
+                    shared_memory->dsp_return_data[1] = decoded_samples;
+                    shared_memory->dsp_return_data[2] = (end_time - start_time).count();
+                } else {
+                    LOG_ERROR(Audio_DSP, "operating unregistered buffer {}", buffer);
+                    shared_memory->dsp_return_data[0] = Service::Audio::ResultLibOpusInvalidState.raw;
+                }
+                Send(Direction::Host, Message::DecodeInterleavedOK);
+                break;
+            }
+            case MapMemory: {
+                [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
+                [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+                Send(Direction::Host, Message::MapMemoryOK);
+                break;
+            }
+            case UnmapMemory: {
+                [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
+                [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+                Send(Direction::Host, Message::UnmapMemoryOK);
+                break;
+            }
+            case GetWorkBufferSizeForMultiStream: {
+                auto total_stream_count = s32(shared_memory->host_send_data[0]);
+                auto stereo_stream_count = s32(shared_memory->host_send_data[1]);
+
+                ASSERT(IsValidMultiStreamStreamCounts(total_stream_count, stereo_stream_count));
+
+                shared_memory->dsp_return_data[0] = OpusMultiStreamDecodeObject::GetWorkBufferSize(
+                    total_stream_count, stereo_stream_count);
+                Send(Direction::Host, Message::GetWorkBufferSizeForMultiStreamOK);
+                break;
+            }
+            case InitializeMultiStreamDecodeObject: {
+                auto buffer = shared_memory->host_send_data[0];
+                auto buffer_size = shared_memory->host_send_data[1];
+                auto sample_rate = s32(shared_memory->host_send_data[2]);
+                auto channel_count = s32(shared_memory->host_send_data[3]);
+                auto total_stream_count = s32(shared_memory->host_send_data[4]);
+                auto stereo_stream_count = s32(shared_memory->host_send_data[5]);
+                // Nintendo seem to have a bug here, they try to use &host_send_data[6] for the channel
+                // mappings, but [6] is never set, and there is not enough room in the argument data for
+                // more than 40 channels, when 255 are possible.
+                // It also means the mapping values are undefined, though likely always 0,
+                // and the mappings given by the game are ignored. The mappings are copied to this
+                // dedicated buffer host side, so let's do as intended.
+                auto mappings = shared_memory->channel_mapping.data();
+
+                ASSERT(IsValidMultiStreamStreamCounts(total_stream_count, stereo_stream_count));
+                ASSERT(sample_rate >= 0);
+                ASSERT(buffer_size >= OpusMultiStreamDecodeObject::GetWorkBufferSize(total_stream_count, stereo_stream_count));
+
+                if (auto const it = ms_decode_objects.find(buffer); it != ms_decode_objects.end()) {
+                    it->second.Shutdown();
+                    shared_memory->dsp_return_data[0] = it->second.InitializeDecoder(sample_rate, total_stream_count, channel_count, stereo_stream_count, mappings).raw;
+                } else {
+                    OpusMultiStreamDecodeObject obj{};
+                    shared_memory->dsp_return_data[0] = obj.InitializeDecoder(sample_rate, total_stream_count, channel_count, stereo_stream_count, mappings).raw;
+                    ms_decode_objects.insert_or_assign(buffer, obj);
+                }
+                Send(Direction::Host, Message::InitializeMultiStreamDecodeObjectOK);
+                break;
+            }
+            case ShutdownMultiStreamDecodeObject: {
+                auto buffer = shared_memory->host_send_data[0];
+                //[[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+                if (auto const it = ms_decode_objects.find(buffer); it != ms_decode_objects.end()) {
+                    shared_memory->dsp_return_data[0] = it->second.Shutdown().raw;
+                } else {
+                    LOG_ERROR(Audio_DSP, "operating unregistered buffer {}", buffer);
+                    shared_memory->dsp_return_data[0] = Service::Audio::ResultLibOpusInvalidState.raw;
+                }
+                Send(Direction::Host, Message::ShutdownMultiStreamDecodeObjectOK);
+                break;
+            }
+            case DecodeInterleavedForMultiStream: {
+                auto start_time = system.CoreTiming().GetGlobalTimeUs();
+
+                auto buffer = shared_memory->host_send_data[0];
+                auto input_data = shared_memory->host_send_data[1];
+                auto input_data_size = shared_memory->host_send_data[2];
+                auto output_data = shared_memory->host_send_data[3];
+                auto output_data_size = shared_memory->host_send_data[4];
+                //auto final_range = static_cast<u32>(shared_memory->host_send_data[5]);
+                auto reset_requested = shared_memory->host_send_data[6];
+
+                u32 decoded_samples{0};
+
+                if (auto const it = ms_decode_objects.find(buffer); it != ms_decode_objects.end()) {
+                    auto res = ResultSuccess;
+                    if (reset_requested)
+                        res = it->second.ResetDecoder();
+                    if (res == ResultSuccess)
+                        res = it->second.Decode(decoded_samples, output_data, output_data_size, input_data, input_data_size);
+
+                    auto end_time = system.CoreTiming().GetGlobalTimeUs();
+                    shared_memory->dsp_return_data[0] = res.raw;
+                    shared_memory->dsp_return_data[1] = decoded_samples;
+                    shared_memory->dsp_return_data[2] = (end_time - start_time).count();
+                } else {
+                    LOG_ERROR(Audio_DSP, "operating unregistered buffer {}", buffer);
+                    shared_memory->dsp_return_data[0] = Service::Audio::ResultLibOpusInvalidState.raw;
+                }
+                Send(Direction::Host, Message::DecodeInterleavedForMultiStreamOK);
+                break;
+            }
+            default:
+                LOG_ERROR(Audio_DSP, "Invalid OpusDecoder command {}", msg);
+                continue;
+            }
+        }
+    });
    running = true;
    Send(Direction::Host, Message::StartOK);
 }

-void OpusDecoder::Main(std::stop_token stop_token) {
-    Common::SetCurrentThreadName("DSP_OpusDecoder_Main");
-
-    while (!stop_token.stop_requested()) {
-        auto msg = Receive(Direction::DSP, stop_token);
-        switch (msg) {
-        case Shutdown:
-            Send(Direction::Host, Message::ShutdownOK);
-            return;
-
-        case GetWorkBufferSize: {
-            auto channel_count = static_cast<s32>(shared_memory->host_send_data[0]);
-
-            ASSERT(IsValidChannelCount(channel_count));
-
-            shared_memory->dsp_return_data[0] = OpusDecodeObject::GetWorkBufferSize(channel_count);
-            Send(Direction::Host, Message::GetWorkBufferSizeOK);
-        } break;
-
-        case InitializeDecodeObject: {
-            auto buffer = shared_memory->host_send_data[0];
-            auto buffer_size = shared_memory->host_send_data[1];
-            auto sample_rate = static_cast<s32>(shared_memory->host_send_data[2]);
-            auto channel_count = static_cast<s32>(shared_memory->host_send_data[3]);
-
-            ASSERT(sample_rate >= 0);
-            ASSERT(IsValidChannelCount(channel_count));
-            ASSERT(buffer_size >= OpusDecodeObject::GetWorkBufferSize(channel_count));
-
-            auto& decoder_object = OpusDecodeObject::Initialize(buffer, buffer);
-            shared_memory->dsp_return_data[0] =
-                decoder_object.InitializeDecoder(sample_rate, channel_count);
-
-            Send(Direction::Host, Message::InitializeDecodeObjectOK);
-        } break;
-
-        case ShutdownDecodeObject: {
-            auto buffer = shared_memory->host_send_data[0];
-            [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
-
-            auto& decoder_object = OpusDecodeObject::Initialize(buffer, buffer);
-            shared_memory->dsp_return_data[0] = decoder_object.Shutdown();
-
-            Send(Direction::Host, Message::ShutdownDecodeObjectOK);
-        } break;
-
-        case DecodeInterleaved: {
-            auto start_time = system.CoreTiming().GetGlobalTimeUs();
-
-            auto buffer = shared_memory->host_send_data[0];
-            auto input_data = shared_memory->host_send_data[1];
-            auto input_data_size = shared_memory->host_send_data[2];
-            auto output_data = shared_memory->host_send_data[3];
-            auto output_data_size = shared_memory->host_send_data[4];
-            auto final_range = static_cast<u32>(shared_memory->host_send_data[5]);
-            auto reset_requested = shared_memory->host_send_data[6];
-
-            u32 decoded_samples{0};
-
-            auto& decoder_object = OpusDecodeObject::Initialize(buffer, buffer);
-            s32 error_code{OPUS_OK};
-            if (reset_requested) {
-                error_code = decoder_object.ResetDecoder();
-            }
-
-            if (error_code == OPUS_OK) {
-                error_code = decoder_object.Decode(decoded_samples, output_data, output_data_size,
-                                                   input_data, input_data_size);
-            }
-
-            if (error_code == OPUS_OK) {
-                if (final_range && decoder_object.GetFinalRange() != final_range) {
-                    error_code = OPUS_INVALID_PACKET;
-                }
-            }
-
-            auto end_time = system.CoreTiming().GetGlobalTimeUs();
-            shared_memory->dsp_return_data[0] = error_code;
-            shared_memory->dsp_return_data[1] = decoded_samples;
-            shared_memory->dsp_return_data[2] = (end_time - start_time).count();
-
-            Send(Direction::Host, Message::DecodeInterleavedOK);
-        } break;
-
-        case MapMemory: {
-            [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
-            [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
-            Send(Direction::Host, Message::MapMemoryOK);
-        } break;
-
-        case UnmapMemory: {
-            [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
-            [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
-            Send(Direction::Host, Message::UnmapMemoryOK);
-        } break;
-
-        case GetWorkBufferSizeForMultiStream: {
-            auto total_stream_count = static_cast<s32>(shared_memory->host_send_data[0]);
-            auto stereo_stream_count = static_cast<s32>(shared_memory->host_send_data[1]);
-
-            ASSERT(IsValidMultiStreamStreamCounts(total_stream_count, stereo_stream_count));
-
-            shared_memory->dsp_return_data[0] = OpusMultiStreamDecodeObject::GetWorkBufferSize(
-                total_stream_count, stereo_stream_count);
-            Send(Direction::Host, Message::GetWorkBufferSizeForMultiStreamOK);
-        } break;
-
-        case InitializeMultiStreamDecodeObject: {
-            auto buffer = shared_memory->host_send_data[0];
-            auto buffer_size = shared_memory->host_send_data[1];
-            auto sample_rate = static_cast<s32>(shared_memory->host_send_data[2]);
-            auto channel_count = static_cast<s32>(shared_memory->host_send_data[3]);
-            auto total_stream_count = static_cast<s32>(shared_memory->host_send_data[4]);
-            auto stereo_stream_count = static_cast<s32>(shared_memory->host_send_data[5]);
-            // Nintendo seem to have a bug here, they try to use &host_send_data[6] for the channel
-            // mappings, but [6] is never set, and there is not enough room in the argument data for
-            // more than 40 channels, when 255 are possible.
-            // It also means the mapping values are undefined, though likely always 0,
-            // and the mappings given by the game are ignored. The mappings are copied to this
-            // dedicated buffer host side, so let's do as intended.
-            auto mappings = shared_memory->channel_mapping.data();
-
-            ASSERT(IsValidMultiStreamStreamCounts(total_stream_count, stereo_stream_count));
-            ASSERT(sample_rate >= 0);
-            ASSERT(buffer_size >= OpusMultiStreamDecodeObject::GetWorkBufferSize(
-                                      total_stream_count, stereo_stream_count));
-
-            auto& decoder_object = OpusMultiStreamDecodeObject::Initialize(buffer, buffer);
-            shared_memory->dsp_return_data[0] = decoder_object.InitializeDecoder(
-                sample_rate, total_stream_count, channel_count, stereo_stream_count, mappings);
-
-            Send(Direction::Host, Message::InitializeMultiStreamDecodeObjectOK);
-        } break;
-
-        case ShutdownMultiStreamDecodeObject: {
-            auto buffer = shared_memory->host_send_data[0];
-            [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
-
-            auto& decoder_object = OpusMultiStreamDecodeObject::Initialize(buffer, buffer);
-            shared_memory->dsp_return_data[0] = decoder_object.Shutdown();
-
-            Send(Direction::Host, Message::ShutdownMultiStreamDecodeObjectOK);
-        } break;
-
-        case DecodeInterleavedForMultiStream: {
-            auto start_time = system.CoreTiming().GetGlobalTimeUs();
-
-            auto buffer = shared_memory->host_send_data[0];
-            auto input_data = shared_memory->host_send_data[1];
-            auto input_data_size = shared_memory->host_send_data[2];
-            auto output_data = shared_memory->host_send_data[3];
-            auto output_data_size = shared_memory->host_send_data[4];
-            auto final_range = static_cast<u32>(shared_memory->host_send_data[5]);
-            auto reset_requested = shared_memory->host_send_data[6];
-
-            u32 decoded_samples{0};
-
-            auto& decoder_object = OpusMultiStreamDecodeObject::Initialize(buffer, buffer);
-            s32 error_code{OPUS_OK};
-            if (reset_requested) {
-                error_code = decoder_object.ResetDecoder();
-            }
-
-            if (error_code == OPUS_OK) {
-                error_code = decoder_object.Decode(decoded_samples, output_data, output_data_size,
-                                                   input_data, input_data_size);
-            }
-
-            if (error_code == OPUS_OK) {
-                if (final_range && decoder_object.GetFinalRange() != final_range) {
-                    error_code = OPUS_INVALID_PACKET;
-                }
-            }
-
-            auto end_time = system.CoreTiming().GetGlobalTimeUs();
-            shared_memory->dsp_return_data[0] = error_code;
-            shared_memory->dsp_return_data[1] = decoded_samples;
-            shared_memory->dsp_return_data[2] = (end_time - start_time).count();
-
-            Send(Direction::Host, Message::DecodeInterleavedForMultiStreamOK);
-        } break;
-
-        default:
-            LOG_ERROR(Service_Audio, "Invalid OpusDecoder command {}", msg);
-            continue;
-        }
-    }
-}
-
 } // namespace AudioCore::ADSP::OpusDecoder
@@ -9,6 +9,9 @@
 #include <memory>
 #include <thread>

+#include "ankerl/unordered_dense.h"
+#include "audio_core/adsp/apps/opus/opus_decode_object.h"
+#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
 #include "audio_core/adsp/apps/opus/shared_memory.h"
 #include "audio_core/adsp/mailbox.h"
 #include "common/common_types.h"
@@ -68,9 +71,7 @@ public:
    }

 private:
-    /**
-     * Initializing thread, launched at audio_core boot to avoid blocking the main emu boot thread.
-     */
+    /// @brief Initializing thread, launched at audio_core boot to avoid blocking the main emu boot thread.
    void Init(std::stop_token stop_token);
    /**
     * Main OpusDecoder thread, responsible for processing the incoming Opus packets.
@@ -90,6 +91,9 @@ private:
    /// Structure shared with the host, input data set by the host before sending a mailbox message,
    /// and the responses are written back by the OpusDecoder.
    SharedMemory* shared_memory{};
+
+    ankerl::unordered_dense::map<u64, OpusDecodeObject> decode_objects;
+    ankerl::unordered_dense::map<u64, OpusMultiStreamDecodeObject> ms_decode_objects;
 };

 } // namespace AudioCore::ADSP::OpusDecoder
@@ -1,8 +1,20 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavcodec/codec.h>
+#include <libavcodec/packet.h>
+#include <libavutil/channel_layout.h>
+#include <libavutil/frame.h>
+}
 #include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
 #include "common/assert.h"
+#include "core/hle/result.h"
+#include "core/hle/service/audio/errors.h"

 namespace AudioCore::ADSP::OpusDecoder {

@@ -12,100 +24,59 @@ bool IsValidChannelCount(u32 channel_count) {
 }

 bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
-    return total_stream_count > 0 && static_cast<s32>(stereo_stream_count) >= 0 &&
-           stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);
+    return total_stream_count > 0 && s32(stereo_stream_count) >= 0
+        && stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);
 }
 } // namespace

-u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count,
-                                                   u32 stereo_stream_count) {
-    if (IsValidStreamCounts(total_stream_count, stereo_stream_count)) {
-        return static_cast<u32>(sizeof(OpusMultiStreamDecodeObject)) +
-               opus_multistream_decoder_get_size(total_stream_count, stereo_stream_count);
-    }
+u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count, u32 stereo_stream_count) {
+    if (IsValidStreamCounts(total_stream_count, stereo_stream_count))
+        return u32(sizeof(OpusMultiStreamDecodeObject)) + 2556 * (total_stream_count * stereo_stream_count);
    return 0;
 }

-OpusMultiStreamDecodeObject& OpusMultiStreamDecodeObject::Initialize(u64 buffer, u64 buffer2) {
-    auto* new_decoder = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer);
-    auto* comparison = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer2);
-
-    if (new_decoder->magic == DecodeMultiStreamObjectMagic) {
-        if (!new_decoder->initialized ||
-            (new_decoder->initialized && new_decoder->self == comparison)) {
-            new_decoder->state_valid = true;
-        }
-    } else {
-        new_decoder->initialized = false;
-        new_decoder->state_valid = true;
-    }
-    return *new_decoder;
+Result OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count, u32 channel_count, u32 stereo_stream_count, u8* mappings) {
+    if ((codec = avcodec_find_decoder(AV_CODEC_ID_OPUS)) == nullptr)
+        return Service::Audio::ResultLibOpusInvalidState;
+    if ((avctx = avcodec_alloc_context3(codec)))
+        return Service::Audio::ResultLibOpusInvalidState;
+    avctx->sample_rate = sample_rate;
+    av_channel_layout_default(&avctx->ch_layout, channel_count);
+    return ResultSuccess;
 }

-s32 OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count,
-                                                   u32 channel_count, u32 stereo_stream_count,
-                                                   u8* mappings) {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        return OPUS_OK;
-    }
-
-    // See OpusDecodeObject::InitializeDecoder for an explanation of this
-    decoder = (LibOpusMSDecoder*)(this + 1);
-    s32 ret = opus_multistream_decoder_init(decoder, sample_rate, channel_count, total_stream_count,
-                                            stereo_stream_count, mappings);
-    if (ret == OPUS_OK) {
-        magic = DecodeMultiStreamObjectMagic;
-        initialized = true;
-        state_valid = true;
-        self = this;
-        final_range = 0;
-    }
-    return ret;
+Result OpusMultiStreamDecodeObject::Shutdown() {
+    if (avctx)
+        avcodec_free_context(&avctx);
+    return ResultSuccess;
 }

-s32 OpusMultiStreamDecodeObject::Shutdown() {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+Result OpusMultiStreamDecodeObject::ResetDecoder() {
+    if (avctx) {
+        avcodec_flush_buffers(avctx);
+        return ResultSuccess;
    }
-
-    if (initialized) {
-        magic = 0x0;
-        initialized = false;
-        state_valid = false;
-        self = nullptr;
-        final_range = 0;
-        decoder = nullptr;
-    }
-    return OPUS_OK;
+    return Service::Audio::ResultLibOpusInvalidState;
 }

-s32 OpusMultiStreamDecodeObject::ResetDecoder() {
-    return opus_multistream_decoder_ctl(decoder, OPUS_RESET_STATE);
-}
-
-s32 OpusMultiStreamDecodeObject::Decode(u32& out_sample_count, u64 output_data,
-                                        u64 output_data_size, u64 input_data, u64 input_data_size) {
-    ASSERT(initialized);
+Result OpusMultiStreamDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data, u64 input_data_size) {
    out_sample_count = 0;
+    if (avctx) {
+        AVPacket* avpkt = av_packet_alloc();
+        av_new_packet(avpkt, int(input_data_size));
+        std::memcpy(avpkt->data, reinterpret_cast<const u8*>(input_data), input_data_size);
+        avcodec_send_packet(avctx, avpkt);

-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+        AVFrame* frame = av_frame_alloc();
+        avcodec_receive_frame(avctx, frame);
+        std::memcpy(reinterpret_cast<u16*>(output_data), frame->data, output_data_size);
+        av_frame_free(&frame);
+        av_packet_free(&avpkt);
+
+        out_sample_count = frame->nb_samples;
+        return ResultSuccess;
    }
-
-    auto ret_code_or_samples = opus_multistream_decode(
-        decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),
-        reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);
-
-    if (ret_code_or_samples < OPUS_OK) {
-        return ret_code_or_samples;
-    }
-
-    out_sample_count = ret_code_or_samples;
-    return opus_multistream_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
+    return Service::Audio::ResultLibOpusInvalidState;
 }

 } // namespace AudioCore::ADSP::OpusDecoder
@@ -1,39 +1,31 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

-#include <opus_multistream.h>
-
+#include "audio_core/adsp/apps/opus/opus_types.h"
 #include "common/common_types.h"
+#include "core/hle/result.h"
+
+struct AVCodec;
+struct AVCodecContext;

 namespace AudioCore::ADSP::OpusDecoder {
-using LibOpusMSDecoder = ::OpusMSDecoder;
-static constexpr u32 DecodeMultiStreamObjectMagic = 0xDEADBEEF;

 class OpusMultiStreamDecodeObject {
 public:
    static u32 GetWorkBufferSize(u32 total_stream_count, u32 stereo_stream_count);
-    static OpusMultiStreamDecodeObject& Initialize(u64 buffer, u64 buffer2);

-    s32 InitializeDecoder(u32 sample_rate, u32 total_stream_count, u32 channel_count,
-                          u32 stereo_stream_count, u8* mappings);
-    s32 Shutdown();
-    s32 ResetDecoder();
-    s32 Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data,
-               u64 input_data_size);
-    u32 GetFinalRange() const noexcept {
-        return final_range;
-    }
+    Result InitializeDecoder(u32 sample_rate, u32 total_stream_count, u32 channel_count, u32 stereo_stream_count, u8* mappings);
+    Result Shutdown();
+    Result ResetDecoder();
+    Result Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data, u64 input_data_size);

-private:
-    u32 magic;
-    bool initialized;
-    bool state_valid;
-    OpusMultiStreamDecodeObject* self;
-    u32 final_range;
-    LibOpusMSDecoder* decoder;
+    AVCodec const* codec = nullptr;
+    AVCodecContext* avctx = nullptr;
 };
-static_assert(std::is_trivially_constructible_v<OpusMultiStreamDecodeObject>);

 } // namespace AudioCore::ADSP::OpusDecoder
@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace AudioCore::ADSP {
+
+static constexpr u32 DECODE_OBJECT_MAGIC = 0xDEADBEEF;
+struct LibOpusDecoder {
+    u32 magic;
+    bool initialized;
+    bool state_valid;
+    LibOpusDecoder* self;
+    u32 final_range;
+    void* decoder;
+};
+static_assert(sizeof(LibOpusDecoder) == 32);
+
+static constexpr u32 DECODE_MULTISTREAM_OBJECT_MAGIC = 0xDEADBEEF;
+struct LibOpusMultistreamDecoder {
+    u32 magic;
+    bool initialized;
+    bool state_valid;
+    LibOpusMultistreamDecoder* self;
+    u32 final_range;
+    void* decoder;
+};
+static_assert(sizeof(LibOpusMultistreamDecoder) == 32);
+
+}
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -6,39 +9,18 @@
 #include "audio_core/audio_core.h"
 #include "audio_core/opus/hardware_opus.h"
 #include "core/core.h"
+#include "core/hle/result.h"

 namespace AudioCore::OpusDecoder {
+
 namespace {
 using namespace Service::Audio;
-
-static constexpr Result ResultCodeFromLibOpusErrorCode(u64 error_code) {
-    s32 error{static_cast<s32>(error_code)};
-    ASSERT(error <= OPUS_OK);
-    switch (error) {
-    case OPUS_ALLOC_FAIL:
-        R_THROW(ResultLibOpusAllocFail);
-    case OPUS_INVALID_STATE:
-        R_THROW(ResultLibOpusInvalidState);
-    case OPUS_UNIMPLEMENTED:
-        R_THROW(ResultLibOpusUnimplemented);
-    case OPUS_INVALID_PACKET:
-        R_THROW(ResultLibOpusInvalidPacket);
-    case OPUS_INTERNAL_ERROR:
-        R_THROW(ResultLibOpusInternalError);
-    case OPUS_BUFFER_TOO_SMALL:
-        R_THROW(ResultBufferTooSmall);
-    case OPUS_BAD_ARG:
-        R_THROW(ResultLibOpusBadArg);
-    case OPUS_OK:
-        R_RETURN(ResultSuccess);
-    }
-    UNREACHABLE();
-}
-
 } // namespace

 HardwareOpus::HardwareOpus(Core::System& system_)
-    : system{system_}, opus_decoder{system.AudioCore().ADSP().OpusDecoder()} {
+    : system{system_}
+    , opus_decoder{system.AudioCore().ADSP().OpusDecoder()}
+{
    opus_decoder.SetSharedMemory(shared_memory);
 }

@@ -89,7 +71,7 @@ Result HardwareOpus::InitializeDecodeObject(u32 sample_rate, u32 channel_count,
        R_THROW(ResultInvalidOpusDSPReturnCode);
    }

-    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
 }

 Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,
@@ -117,7 +99,7 @@ Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 chan
        R_THROW(ResultInvalidOpusDSPReturnCode);
    }

-    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
 }

 Result HardwareOpus::ShutdownDecodeObject(void* buffer, u64 buffer_size) {
@@ -131,7 +113,7 @@ Result HardwareOpus::ShutdownDecodeObject(void* buffer, u64 buffer_size) {
               "Expected Opus shutdown code {}, got {}",
               ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK, msg);

-    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
 }

 Result HardwareOpus::ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size) {
@@ -146,7 +128,7 @@ Result HardwareOpus::ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_si
               "Expected Opus shutdown code {}, got {}",
               ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK, msg);

-    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
 }

 Result HardwareOpus::DecodeInterleaved(u32& out_sample_count, void* output_data,
@@ -170,12 +152,12 @@ Result HardwareOpus::DecodeInterleaved(u32& out_sample_count, void* output_data,
        R_THROW(ResultInvalidOpusDSPReturnCode);
    }

-    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
-    if (error_code == OPUS_OK) {
-        out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
+    auto error_code = s32(shared_memory.dsp_return_data[0]);
+    if (error_code == ResultSuccess.raw) {
+        out_sample_count = u32(shared_memory.dsp_return_data[1]);
        out_time_taken = 1000 * shared_memory.dsp_return_data[2];
    }
-    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
+    R_RETURN(Result(u32(error_code)));
 }

 Result HardwareOpus::DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,
@@ -184,29 +166,27 @@ Result HardwareOpus::DecodeInterleavedForMultiStream(u32& out_sample_count, void
                                                     void* buffer, u64& out_time_taken,
                                                     bool reset) {
    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = (u64)input_data;
+    shared_memory.host_send_data[0] = u64(buffer);
+    shared_memory.host_send_data[1] = u64(input_data);
    shared_memory.host_send_data[2] = input_data_size;
-    shared_memory.host_send_data[3] = (u64)output_data;
+    shared_memory.host_send_data[3] = u64(output_data);
    shared_memory.host_send_data[4] = output_data_size;
    shared_memory.host_send_data[5] = 0;
    shared_memory.host_send_data[6] = reset;

-    opus_decoder.Send(ADSP::Direction::DSP,
-                      ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStream);
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStream);
    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
    if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK, msg);
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}", ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK, msg);
        R_THROW(ResultInvalidOpusDSPReturnCode);
    }

-    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
-    if (error_code == OPUS_OK) {
+    auto const error_code = shared_memory.dsp_return_data[0];
+    if (error_code == ResultSuccess.raw) {
        out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
        out_time_taken = 1000 * shared_memory.dsp_return_data[2];
    }
-    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
+    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
 }

 Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {
@@ -217,8 +197,7 @@ Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {
    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::MapMemory);
    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
    if (msg != ADSP::OpusDecoder::Message::MapMemoryOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::MapMemoryOK, msg);
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}", ADSP::OpusDecoder::Message::MapMemoryOK, msg);
        R_THROW(ResultInvalidOpusDSPReturnCode);
    }
    R_SUCCEED();
@@ -232,8 +211,7 @@ Result HardwareOpus::UnmapMemory(void* buffer, u64 buffer_size) {
    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::UnmapMemory);
    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
    if (msg != ADSP::OpusDecoder::Message::UnmapMemoryOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::UnmapMemoryOK, msg);
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}", ADSP::OpusDecoder::Message::UnmapMemoryOK, msg);
        R_THROW(ResultInvalidOpusDSPReturnCode);
    }
    R_SUCCEED();
@@ -1,11 +1,12 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

 #include <mutex>
-#include <opus.h>
-
 #include "audio_core/adsp/apps/opus/opus_decoder.h"
 #include "audio_core/adsp/apps/opus/shared_memory.h"
 #include "audio_core/adsp/mailbox.h"
@@ -4,17 +4,34 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <fstream>
 #include "common/heap_tracker.h"
 #include "common/logging.h"
-#include "common/memory_detect.h"
 #include "common/assert.h"

 namespace Common {

+namespace {
+
+s64 GetMaxPermissibleResidentMapCount() {
+    // Default value.
+    s64 value = 65530;
+
+    // Try to read how many mappings we can make.
+    std::ifstream s("/proc/sys/vm/max_map_count");
+    s >> value;
+
+    // Print, for debug.
+    LOG_INFO(HW_Memory, "Current maximum map count: {}", value);
+
+    // Allow 20000 maps for other code and to account for split inaccuracy.
+    return std::max<s64>(value - 20000, 0);
+}
+
+} // namespace
+
 HeapTracker::HeapTracker(Common::HostMemory& buffer)
-    : m_buffer(buffer),
-      m_has_hardware_buffer_backing(!buffer.BackingHardwareBuffers().empty()),
-      m_max_resident_map_count(static_cast<s64>(GetPermissibleMapCount())) {}
+    : m_buffer(buffer), m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {}
 HeapTracker::~HeapTracker() = default;

 void HeapTracker::Map(size_t virtual_offset, size_t host_offset, size_t length,
@@ -68,8 +85,7 @@ void HeapTracker::Unmap(size_t virtual_offset, size_t size, bool is_separate_hea

            // If resident, erase from resident map.
            if (item->is_resident) {
-                m_resident_map_count -= this->HostMapCount(item->paddr, item->size);
-                ASSERT(m_resident_map_count >= 0);
+                ASSERT(--m_resident_map_count >= 0);
                m_resident_mappings.erase(m_resident_mappings.iterator_to(*item));
            }

@@ -175,7 +191,7 @@ bool HeapTracker::DeferredMapSeparateHeap(size_t virtual_offset) {

        // This map is now resident.
        it->is_resident = true;
-        m_resident_map_count += this->HostMapCount(it->paddr, it->size);
+        m_resident_map_count++;
        m_resident_mappings.insert(*it);
    }

@@ -197,17 +213,17 @@ void HeapTracker::RebuildSeparateHeapAddressSpace() {
    // Despite being worse in theory, this has proven to be better in practice than more
    // regularly dumping a smaller amount, because it significantly reduces average case
    // lock contention.
-    s64 const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
+    std::size_t const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
+    std::size_t const evict_count = m_resident_map_count - desired_count;
    auto it = m_resident_mappings.begin();

-    while (m_resident_map_count > desired_count && it != m_resident_mappings.end()) {
+    for (size_t i = 0; i < evict_count && it != m_resident_mappings.end(); i++) {
        // Unmark and unmap.
        it->is_resident = false;
        m_buffer.Unmap(it->vaddr, it->size, false);

        // Advance.
-        m_resident_map_count -= this->HostMapCount(it->paddr, it->size);
-        ASSERT(m_resident_map_count >= 0);
+        ASSERT(--m_resident_map_count >= 0);
        it = m_resident_mappings.erase(it);
    }
 }
@@ -229,7 +245,6 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {
    // Cache the original values.
    auto* const left = std::addressof(*it);
    const size_t orig_size = left->size;
-    const s64 orig_host_map_count = this->HostMapCount(left->paddr, orig_size);

    // Adjust the left map.
    const size_t left_size = offset - left->vaddr;
@@ -251,20 +266,11 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {

    // If resident, also insert into resident map.
    if (right->is_resident) {
-        m_resident_map_count += this->HostMapCount(left->paddr, left->size) +
-                                this->HostMapCount(right->paddr, right->size) -
-                                orig_host_map_count;
+        m_resident_map_count++;
        m_resident_mappings.insert(*right);
    }
 }

-s64 HeapTracker::HostMapCount(PAddr paddr, size_t size) const {
-    if (!m_has_hardware_buffer_backing) {
-        return size != 0 ? 1 : 0;
-    }
-    return static_cast<s64>(m_buffer.BackingMapCount(paddr, size));
-}
-
 HeapTracker::AddrTree::iterator HeapTracker::GetNearestHeapMapLocked(VAddr offset) {
    const SeparateHeapMap key{
        .vaddr = offset,
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -85,13 +82,10 @@ private:

    AddrTree::iterator GetNearestHeapMapLocked(VAddr offset);

-    s64 HostMapCount(PAddr paddr, size_t size) const;
-
    void RebuildSeparateHeapAddressSpace();

 private:
    Common::HostMemory& m_buffer;
-    const bool m_has_hardware_buffer_backing;
    const s64 m_max_resident_map_count;

    std::shared_mutex m_rebuild_lock{};
@@ -51,65 +51,14 @@

 #endif // ^^^ POSIX ^^^

-#include <atomic>
 #include <mutex>
 #include <random>
-#include <vector>

 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/free_region_manager.h"
 #include "common/host_memory.h"
 #include "common/logging.h"
-#include "common/memory_detect.h"
-#include "common/settings.h"
-
-#ifdef __ANDROID__
-#include <cerrno>
-#include <dlfcn.h>
-#include <sys/ioctl.h>
-#include <android/hardware_buffer.h>
-
-namespace {
-
-struct NativeHandle {
-    int version;
-    int numFds;
-    int numInts;
-    int data[1];
-};
-
-using PFN_AHardwareBuffer_getNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*);
-
-PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
-    void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
-    if (lib == nullptr) {
-        return nullptr;
-    }
-    return reinterpret_cast<PFN_AHardwareBuffer_getNativeHandle>(
-        dlsym(lib, "AHardwareBuffer_getNativeHandle"));
-}
-
-struct DmaBufSync {
-    u64 flags;
-};
-
-constexpr u64 DmaBufSyncRead = 1ULL << 0;
-constexpr u64 DmaBufSyncWrite = 1ULL << 1;
-constexpr u64 DmaBufSyncStart = 0ULL << 2;
-constexpr u64 DmaBufSyncEnd = 1ULL << 2;
-
-void SyncDmaBufCpuAccess(int fd, u64 phase) {
-    DmaBufSync sync{.flags = phase | DmaBufSyncRead | DmaBufSyncWrite};
-    while (ioctl(fd, _IOW('b', 0, DmaBufSync), &sync) != 0) {
-        if (errno != EINTR) {
-            return;
-        }
-    }
-}
-
-} // namespace
-#endif

 #if defined(__ANDROID__) && __ANDROID_API__ < 30
 #include <sys/syscall.h>
@@ -126,12 +75,6 @@ namespace Common {
 [[maybe_unused]] constexpr size_t PageAlignment = 0x1000;
 [[maybe_unused]] constexpr size_t HugePageSize = 0x200000;

-static std::atomic<u64> committed_backing_size{};
-
-u64 GetCommittedBackingSize() noexcept {
-    return committed_backing_size.load(std::memory_order_relaxed);
-}
-
 #ifdef _WIN32

 // Manually imported for MinGW compatibility
@@ -180,7 +123,7 @@ static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn

 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t)
+    explicit Impl(size_t backing_size_, size_t virtual_size_)
        : backing_size{backing_size_}
        , virtual_size{virtual_size_}
        , process{GetCurrentProcess()}
@@ -286,10 +229,6 @@ public:
        UNREACHABLE();
    }

-    bool IsBackingShared() const noexcept {
-        return true;
-    }
-
    const size_t backing_size; ///< Size of the backing memory in bytes
    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes

@@ -562,10 +501,9 @@ static int shm_open_anon(int flags, mode_t mode) {

 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_)
        : backing_size{backing_size_}
        , virtual_size{virtual_size_}
-        , preferred_offset{preferred_offset_}
    {}

    bool Init() {
@@ -605,15 +543,10 @@ public:
            LOG_WARNING(Common_Memory, "Using private mappings instead of shared ones");
            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
            if (fd > 0) {
+                fd = -1;
                close(fd);
            }
-            fd = -1;
        } else {
-#ifdef __ANDROID__
-            if (InitAhbBacking()) {
-                return InitVirtual();
-            }
-#endif
            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
        }
        if (backing_base == MAP_FAILED) {
@@ -621,10 +554,7 @@ public:
            return false;
        }

-        return InitVirtual();
-    }
-
-    bool InitVirtual() {
+        // Virtual memory initialization
        virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
        if (virtual_base == MAP_FAILED) {
            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -637,244 +567,6 @@ public:
        return true;
    }

-#ifdef __ANDROID__
-    static AHardwareBuffer_Desc MakeBlobDesc(size_t len) {
-        return AHardwareBuffer_Desc{
-            .width = static_cast<u32>(len),
-            .height = 1,
-            .layers = 1,
-            .format = AHARDWAREBUFFER_FORMAT_BLOB,
-            .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
-                     AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
-                     AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER,
-            .stride = 0,
-            .rfu0 = 0,
-            .rfu1 = 0,
-        };
-    }
-
-    static bool ProbeAhbBacking(PFN_AHardwareBuffer_getNativeHandle get_native_handle) {
-        const AHardwareBuffer_Desc desc = MakeBlobDesc(PageAlignment * 2);
-        AHardwareBuffer* buffer{};
-        if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
-            return false;
-        }
-        const NativeHandle* const handle = get_native_handle(buffer);
-        if (handle == nullptr || handle->numFds < 1) {
-            AHardwareBuffer_release(buffer);
-            return false;
-        }
-        const int probe_fd = handle->data[0];
-        bool ok = true;
-        const auto try_map = [&](int prot, off_t offset) {
-            if (!ok) {
-                return;
-            }
-            void* const ptr = mmap(nullptr, PageAlignment, prot, MAP_SHARED, probe_fd, offset);
-            if (ptr == MAP_FAILED) {
-                ok = false;
-                return;
-            }
-            munmap(ptr, PageAlignment);
-        };
-        try_map(PROT_READ | PROT_WRITE, 0);
-        try_map(PROT_READ | PROT_WRITE, static_cast<off_t>(PageAlignment));
-#ifdef ARCHITECTURE_arm64
-        try_map(PROT_READ | PROT_EXEC, 0);
-#endif
-        AHardwareBuffer_release(buffer);
-        return ok;
-    }
-
-    size_t ComputeAhbBudget(size_t window_size) const {
-        const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
-        constexpr u64 BaselineFootprint = 6ULL << 30;
-        if (total_physical <= BaselineFootprint) {
-            return 0;
-        }
-        const u64 permissible_maps = Common::GetPermissibleMapCount();
-        if (permissible_maps == 0) {
-            return 0;
-        }
-        u64 budget = (total_physical - BaselineFootprint) / 2;
-        constexpr u64 MapSlotsPerWindow = 64;
-        const u64 affordable_windows = permissible_maps / MapSlotsPerWindow;
-        budget = (std::min)(budget, affordable_windows * window_size);
-        const u64 available = Common::GetAvailablePhysicalMemory();
-        if (available != 0) {
-            budget = (std::min)(budget, available / 2);
-        }
-        budget = (std::min)(budget, static_cast<u64>(backing_size));
-        budget = Common::AlignDown(budget, window_size);
-        constexpr u64 MinimumBudget = 256ULL << 20;
-        if (budget < MinimumBudget) {
-            return 0;
-        }
-        return static_cast<size_t>(budget);
-    }
-
-    bool InitAhbBacking() {
-        if (!Settings::values.use_unified_memory.GetValue()) {
-            return false;
-        }
-        static const PFN_AHardwareBuffer_getNativeHandle get_native_handle =
-            ResolveGetNativeHandle();
-        if (get_native_handle == nullptr) {
-            return false;
-        }
-        constexpr size_t window_size = 256ULL << 20;
-        const size_t budget = ComputeAhbBudget(window_size);
-        if (budget == 0) {
-            return false;
-        }
-        if (!ProbeAhbBacking(get_native_handle)) {
-            return false;
-        }
-        const size_t aligned_backing = Common::AlignDown(backing_size, window_size);
-        const size_t max_windows = (std::min)(budget, aligned_backing) / window_size;
-
-        std::vector<AHardwareBuffer*> buffers;
-        std::vector<int> buffer_fds;
-        const auto cleanup = [&] {
-            for (AHardwareBuffer* buffer : buffers) {
-                AHardwareBuffer_release(buffer);
-            }
-            buffers.clear();
-            buffer_fds.clear();
-        };
-        for (size_t i = 0; i < max_windows; ++i) {
-            const AHardwareBuffer_Desc desc = MakeBlobDesc(window_size);
-            AHardwareBuffer* buffer{};
-            if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
-                break;
-            }
-            const NativeHandle* const handle = get_native_handle(buffer);
-            if (handle == nullptr || handle->numFds < 1) {
-                AHardwareBuffer_release(buffer);
-                break;
-            }
-            const int buffer_fd = handle->data[0];
-            const off_t buffer_len = lseek(buffer_fd, 0, SEEK_END);
-            if (buffer_len < static_cast<off_t>(window_size)) {
-                AHardwareBuffer_release(buffer);
-                break;
-            }
-            buffers.push_back(buffer);
-            buffer_fds.push_back(buffer_fd);
-        }
-        const size_t num_windows = buffers.size();
-        if (num_windows == 0) {
-            return false;
-        }
-        const size_t region_size = num_windows * window_size;
-        const size_t region_base = Common::AlignDown(
-            (std::min)(preferred_offset, aligned_backing - region_size), window_size);
-        u8* const base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_NONE,
-                                               MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
-        if (base == MAP_FAILED) {
-            cleanup();
-            return false;
-        }
-        const auto map_over_reservation = [&](size_t offset, size_t len, int map_fd,
-                                              off_t map_offset) {
-            if (len == 0) {
-                return true;
-            }
-            if (mmap(base + offset, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, map_fd,
-                     map_offset) == MAP_FAILED) {
-                munmap(base, backing_size);
-                cleanup();
-                return false;
-            }
-            return true;
-        };
-        if (!map_over_reservation(0, region_base, fd, 0)) {
-            return false;
-        }
-        for (size_t i = 0; i < num_windows; ++i) {
-            if (!map_over_reservation(region_base + i * window_size, window_size, buffer_fds[i],
-                                      0)) {
-                return false;
-            }
-        }
-        const size_t tail_offset = region_base + region_size;
-        if (!map_over_reservation(tail_offset, backing_size - tail_offset, fd,
-                                  static_cast<off_t>(tail_offset))) {
-            return false;
-        }
-        backing_base = base;
-        ahb_windows = std::move(buffers);
-        ahb_fds = std::move(buffer_fds);
-        ahb_window_size = window_size;
-        ahb_base = region_base;
-        ahb_bytes = region_size;
-        committed_backing_size.store(region_size, std::memory_order_relaxed);
-        for (const int window_fd : ahb_fds) {
-            SyncDmaBufCpuAccess(window_fd, DmaBufSyncStart);
-        }
-        return true;
-    }
-
-    void MapBackingRange(size_t virtual_offset, size_t host_offset, size_t length, int prot_flags) {
-        while (length > 0) {
-            int map_fd = fd;
-            off_t map_offset = static_cast<off_t>(host_offset);
-            size_t chunk = length;
-            if (host_offset < ahb_base) {
-                chunk = (std::min)(chunk, ahb_base - host_offset);
-            } else if (host_offset < ahb_base + ahb_bytes) {
-                const size_t relative = host_offset - ahb_base;
-                const size_t window = relative / ahb_window_size;
-                const size_t local = relative % ahb_window_size;
-                map_fd = ahb_fds[window];
-                map_offset = static_cast<off_t>(local);
-                chunk = (std::min)(chunk, ahb_window_size - local);
-            }
-            void* const ret = mmap(virtual_base + virtual_offset, chunk, prot_flags,
-                                   MAP_SHARED | MAP_FIXED, map_fd, map_offset);
-            ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
-            virtual_offset += chunk;
-            host_offset += chunk;
-            length -= chunk;
-        }
-    }
-
-    size_t BackingMapCount(size_t host_offset, size_t length) const noexcept {
-        if (length == 0) {
-            return 0;
-        }
-        if (ahb_bytes == 0) {
-            return 1;
-        }
-        size_t count = 0;
-        while (length > 0) {
-            size_t chunk = length;
-            if (host_offset < ahb_base) {
-                chunk = (std::min)(chunk, ahb_base - host_offset);
-            } else if (host_offset < ahb_base + ahb_bytes) {
-                const size_t local = (host_offset - ahb_base) % ahb_window_size;
-                chunk = (std::min)(chunk, ahb_window_size - local);
-            }
-            host_offset += chunk;
-            length -= chunk;
-            ++count;
-        }
-        return count;
-    }
-
-    std::span<AHardwareBuffer* const> AhbWindows() const noexcept {
-        return ahb_windows;
-    }
-
-    size_t AhbWindowSize() const noexcept {
-        return ahb_bytes != 0 ? ahb_window_size : 0;
-    }
-
-    size_t AhbBase() const noexcept {
-        return ahb_base;
-    }
-#endif
-
    ~Impl() {
        Release();
    }
@@ -895,12 +587,6 @@ public:
 #ifdef ARCHITECTURE_arm64
        if (True(perms & MemoryPermission::Execute))
            prot_flags |= PROT_EXEC;
-#endif
-#ifdef __ANDROID__
-        if (ahb_bytes != 0) {
-            MapBackingRange(virtual_offset, host_offset, length, prot_flags);
-            return;
-        }
 #endif
        int flags = (fd >= 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
        void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
@@ -946,18 +632,8 @@ public:
        virtual_base = nullptr;
    }

-    bool IsBackingShared() const noexcept {
-#ifdef __ANDROID__
-        if (ahb_bytes != 0) {
-            return true;
-        }
-#endif
-        return fd >= 0;
-    }
-
    const size_t backing_size; ///< Size of the backing memory in bytes
    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
-    const size_t preferred_offset;

    u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
    u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
@@ -980,21 +656,6 @@ private:
            int ret = close(fd);
            ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
        }
-
-#ifdef __ANDROID__
-        for (const int window_fd : ahb_fds) {
-            SyncDmaBufCpuAccess(window_fd, DmaBufSyncEnd);
-        }
-        for (AHardwareBuffer* buffer : ahb_windows) {
-            AHardwareBuffer_release(buffer);
-        }
-        ahb_windows.clear();
-        ahb_fds.clear();
-        if (ahb_bytes != 0) {
-            committed_backing_size.store(0, std::memory_order_relaxed);
-            ahb_bytes = 0;
-        }
-#endif
    }

    void AdjustMap(size_t* virtual_offset, size_t* length) {
@@ -1020,19 +681,11 @@ private:

    int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
    FreeRegionManager free_manager{};
-
-#ifdef __ANDROID__
-    std::vector<AHardwareBuffer*> ahb_windows;
-    std::vector<int> ahb_fds;
-    size_t ahb_window_size{};
-    size_t ahb_base{};
-    size_t ahb_bytes{};
-#endif
 };

 #endif // ^^^ POSIX ^^^

-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
    : backing_size(backing_size_)
    , virtual_size(virtual_size_)
 {
@@ -1044,7 +697,7 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t prefer
 #else
    // Try to allocate a fastmem arena.
    // The implementation will fail with std::bad_alloc on errors.
-    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize, preferred_offset_);
+    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
    if (impl->Init()) {
        backing_base = impl->backing_base;
        virtual_base = impl->virtual_base;
@@ -1114,46 +767,6 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f
    std::memset(backing_base + physical_offset, fill_value, length);
 }

-std::span<AHardwareBuffer* const> HostMemory::BackingHardwareBuffers() const noexcept {
-#ifdef __ANDROID__
-    return impl ? impl->AhbWindows() : std::span<AHardwareBuffer* const>{};
-#else
-    return {};
-#endif
-}
-
-size_t HostMemory::BackingMapCount(size_t host_offset, size_t length) const noexcept {
-#ifdef __ANDROID__
-    return impl ? impl->BackingMapCount(host_offset, length) : (length != 0 ? 1 : 0);
-#else
-    return length != 0 ? 1 : 0;
-#endif
-}
-
-size_t HostMemory::BackingHardwareBufferWindowSize() const noexcept {
-#ifdef __ANDROID__
-    return impl ? impl->AhbWindowSize() : 0;
-#else
-    return 0;
-#endif
-}
-
-bool HostMemory::IsBackingShared() const noexcept {
-#if defined(__OPENORBIS__) || defined(__managarm__)
-    return false;
-#else
-    return impl && impl->IsBackingShared();
-#endif
-}
-
-size_t HostMemory::BackingHardwareBufferBase() const noexcept {
-#ifdef __ANDROID__
-    return impl ? impl->AhbBase() : 0;
-#else
-    return 0;
-#endif
-}
-
 void HostMemory::EnableDirectMappedAddress() {
 #if !(defined(__OPENORBIS__) || defined(__managarm__))
    if (impl) {
@@ -8,17 +8,12 @@

 #include <memory>
 #include <optional>
-#include <span>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/virtual_buffer.h"

-struct AHardwareBuffer;
-
 namespace Common {

-[[nodiscard]] u64 GetCommittedBackingSize() noexcept;
-
 enum class MemoryPermission : u32 {
    Read = 1 << 0,
    Write = 1 << 1,
@@ -33,7 +28,7 @@ DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission)
 */
 class HostMemory {
 public:
-    explicit HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_ = 0);
+    explicit HostMemory(size_t backing_size_, size_t virtual_size_);
    ~HostMemory();

    /**
@@ -67,20 +62,6 @@ public:
        return backing_base;
    }

-    [[nodiscard]] size_t BackingSize() const noexcept {
-        return backing_size;
-    }
-
-    [[nodiscard]] size_t BackingMapCount(size_t host_offset, size_t length) const noexcept;
-
-    [[nodiscard]] std::span<AHardwareBuffer* const> BackingHardwareBuffers() const noexcept;
-
-    [[nodiscard]] size_t BackingHardwareBufferWindowSize() const noexcept;
-
-    [[nodiscard]] size_t BackingHardwareBufferBase() const noexcept;
-
-    [[nodiscard]] bool IsBackingShared() const noexcept;
-
    [[nodiscard]] u8* VirtualBasePointer() noexcept {
        return virtual_base;
    }
@@ -39,19 +39,6 @@

 namespace Common::Log {

-/// @brief A log entry. Log entries are store in a structured format to permit more varied output
-/// formatting on different frontends, as well as facilitating filtering and aggregation.
-struct Entry {
-    char const* message = nullptr;
-    size_t message_len = 0;
-    std::chrono::microseconds timestamp;
-    Class log_class{};
-    Level log_level{};
-    const char* filename = nullptr;
-    const char* function = nullptr;
-    uint32_t line_num = 0;
-};
-
 namespace {

 /// @brief Returns the name of the passed log class as a C-string. Subclasses are separated by periods
@@ -83,6 +70,8 @@ const char* GetLevelName(Level log_level) {
    }
 }

+}
+
 // Some IDEs prefer <file>:<line> instead, so let's just do that :)
 std::string FormatLogMessage(const Entry& entry) noexcept {
    if (!entry.filename) return "";
@@ -90,9 +79,10 @@ std::string FormatLogMessage(const Entry& entry) noexcept {
    auto const time_fractional = uint32_t(entry.timestamp.count() % 1000000);
    auto const class_name = GetLogClassName(entry.log_class);
    auto const level_name = GetLevelName(entry.log_level);
-    return fmt::format("[{:4d}.{:06d}] {} <{}> {}:{}:{}: {}\n", time_seconds, time_fractional, class_name, level_name, entry.filename, entry.line_num, entry.function, entry.message);
+    return fmt::format("[{:4d}.{:06d}] {} <{}> {}:{}:{}: {}", time_seconds, time_fractional, class_name, level_name, entry.filename, entry.line_num, entry.function, entry.message);
 }

+namespace {
 template <typename It>
 Level GetLevelByName(const It begin, const It end) {
    for (u32 i = 0; i < u32(Level::Count); ++i) {
@@ -137,6 +127,25 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
    instance.SetClassLevel(log_class, level);
    return true;
 }
+} // Anonymous namespace
+
+void Filter::ParseFilterString(std::string_view filter_view) {
+    auto clause_begin = filter_view.cbegin();
+    while (clause_begin != filter_view.cend()) {
+        auto clause_end = std::find(clause_begin, filter_view.cend(), ' ');
+        // If clause isn't empty
+        if (clause_end != clause_begin) {
+            ParseFilterRule(*this, clause_begin, clause_end);
+        }
+        if (clause_end != filter_view.cend()) {
+            // Skip over the whitespace
+            ++clause_end;
+        }
+        clause_begin = clause_end;
+    }
+}
+
+namespace {

 /// @brief Trims up to and including the last of ../, ..\, src/, src\ in a string
 /// do not be fooled this isn't generating new strings on .rodata :)
@@ -199,7 +208,7 @@ struct ColorConsoleBackend final : public Backend {
            }());
            SetConsoleTextAttribute(console_handle, color);
            auto const df = GetDirectFormatArgs(entry);
-            std::fprintf(stdout, CCB_PRINTF_FMT "\n", df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message);
+            std::fprintf(stdout, CCB_PRINTF_FMT "\n", df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message.c_str());
        }
    }
    void Flush() noexcept override {}
@@ -211,24 +220,22 @@ struct ColorConsoleBackend final : public Backend {
    ~ColorConsoleBackend() noexcept override {}
    void Write(const Entry& entry) noexcept override {
        if (enabled) {
+#define ESC "\x1b"
            auto const color_str = [&entry]() -> const char* {
                switch (entry.log_level) {
-                case Level::Debug: return "[0;36m"; // Cyan
-                case Level::Info: return "[0;37m"; // Bright gray
-                case Level::Warning: return "[1;33m"; // Bright yellow
-                case Level::Error: return "[1;31m"; // Bright red
-                case Level::Critical: return "[1;35m"; // Bright magenta
-                default: return "[1;30m"; // Grey
+#define CCB_MAKE_COLOR_FMT(X) ESC X CCB_PRINTF_FMT ESC "[0m\n"
+                case Level::Debug: return CCB_MAKE_COLOR_FMT("[0;36m"); // Cyan
+                case Level::Info: return CCB_MAKE_COLOR_FMT("[0;37m"); // Bright gray
+                case Level::Warning: return CCB_MAKE_COLOR_FMT("[1;33m"); // Bright yellow
+                case Level::Error: return CCB_MAKE_COLOR_FMT("[1;31m"); // Bright red
+                case Level::Critical: return CCB_MAKE_COLOR_FMT("[1;35m"); // Bright magenta
+                default: return CCB_MAKE_COLOR_FMT("[1;30m"); // Grey
+#undef CCB_MAKE_COLOR_FMT
                }
            }();
            auto const df = GetDirectFormatArgs(entry);
-            // more restrictive, because take for example this simple prelude:
-            // [  50.872256] Config <Info> common/settings.cpp:142:LogSettings:
-            char buffer[128];
-            auto result = fmt::format_to_n(buffer, sizeof(buffer) - 1, "\x1b{}[{:4d}.{:06d}] {} <{}> {}:{}:{}: ", color_str, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message);
-            std::fwrite(buffer, 1, (std::min)(sizeof(buffer) - 1, result.size), stdout);
-            std::fwrite(entry.message, 1, entry.message_len, stdout);
-            std::fwrite("\x1b[0m\n", 1, sizeof("\x1b[0m\n"), stdout);
+            std::fprintf(stdout, color_str, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message.c_str());
+#undef ESC
        }
    }
    void Flush() noexcept override {}
@@ -239,7 +246,7 @@ struct ColorConsoleBackend final : public Backend {
 #ifndef __OPENORBIS__
 /// @brief Backend that writes to a file passed into the constructor
 struct FileBackend final : public Backend {
-    explicit FileBackend(const std::filesystem::path filename) noexcept {
+    explicit FileBackend(const std::filesystem::path& filename) noexcept {
        auto old_filename = filename;
        old_filename += ".old.txt";
        // Existence checks are done within the functions themselves.
@@ -254,7 +261,7 @@ struct FileBackend final : public Backend {
        if (!enabled)
            return;

-        auto message = FormatLogMessage(entry);
+        auto message = FormatLogMessage(entry).append(1, '\n');
 #ifndef __ANDROID__
        if (Settings::values.censor_username.GetValue()) {
            // This must be a static otherwise it would get checked on EVERY
@@ -262,7 +269,8 @@ struct FileBackend final : public Backend {
            static std::string username = []() -> std::string {
                // in order of precedence
                // LOGNAME usually works on UNIX, USERNAME on Windows
-                // Some UNIX systems suck and don't use LOGNAME so we also need USER :(
+                // Some UNIX systems suck and don't use LOGNAME so we also
+                // need USER :(
                for (auto const var : { "LOGNAME", "USERNAME", "USER", })
                    if (auto const s = ::getenv(var); s != nullptr)
                        return std::string{s};
@@ -272,7 +280,7 @@ struct FileBackend final : public Backend {
                boost::replace_all(message, username, "user");
        }
 #endif
-        bytes_written += file->WriteSpan(std::span<const char>{message.begin(), message.end()});
+        bytes_written += file->WriteString(message);

        // Option to log each line rather than 4k buffers
        if (Settings::values.log_flush_line.GetValue())
@@ -300,13 +308,14 @@ private:
    bool enabled = true;
 };
 #endif
+
 #ifdef _WIN32
 /// @brief Backend that writes to Visual Studio's output window
 struct DebuggerBackend final : public Backend {
    explicit DebuggerBackend() noexcept = default;
    ~DebuggerBackend() noexcept override = default;
    void Write(const Entry& entry) noexcept override {
-        ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry)).c_str());
+        ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
    }
    void Flush() noexcept override {}
 };
@@ -329,7 +338,7 @@ struct LogcatBackend : public Backend {
            }
        }();
        auto const df = GetDirectFormatArgs(entry);
-        __android_log_print(android_log_priority, "YuzuNative", CCB_PRINTF_FMT, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message);
+        __android_log_print(android_log_priority, "YuzuNative", CCB_PRINTF_FMT, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message.c_str());
    }
    void Flush() noexcept override {}
 };
@@ -368,23 +377,7 @@ struct Impl {
 #endif
    std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
-} // Anonymous namespace
-
-void Filter::ParseFilterString(std::string_view filter_view) {
-    auto clause_begin = filter_view.cbegin();
-    while (clause_begin < filter_view.cend()) {
-        auto clause_end = std::find(clause_begin, filter_view.cend(), ' ');
-        // If clause isn't empty
-        if (clause_end != clause_begin) {
-            ParseFilterRule(*this, clause_begin, clause_end);
-        }
-        if (clause_end != filter_view.cend()) {
-            // Skip over the whitespace
-            ++clause_end;
-        }
-        clause_begin = clause_end;
-    }
-}
+} // namespace

 // Constructor shall NOT depend upon Settings() or whatever
 // it's ran at global static ctor() time... so BE CAREFUL MFER!
@@ -425,14 +418,10 @@ void SetColorConsoleBackendEnabled(bool enabled) {

 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename, unsigned int line_num, const char* function, fmt::string_view format, const fmt::format_args& args) {
    if (logging_instance && logging_instance->filter.CheckMessage(log_class, log_level)) {
-        char buffer[BUFSIZ];
-        auto result = fmt::vformat_to_n(buffer, sizeof(buffer) - 1, format, args);
-        buffer[result.size] = '\0';
        auto const flush = ::Settings::values.log_flush_line.GetValue();
        logging_instance->ForEachBackend([=](Backend& backend) {
            backend.Write(Entry{
-                .message = buffer,
-                .message_len = (std::min)(sizeof(buffer) - 1, result.size),
+                .message = fmt::vformat(format, args),
                .timestamp = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - logging_instance->time_origin),
                .log_class = log_class,
                .log_level = log_level,
@@ -140,4 +140,25 @@ void Stop();
 void SetGlobalFilter(const Filter& filter);
 void SetColorConsoleBackendEnabled(bool enabled);

+/// @brief A log entry. Log entries are store in a structured format to permit more varied output
+/// formatting on different frontends, as well as facilitating filtering and aggregation.
+struct Entry {
+    std::string message;
+    std::chrono::microseconds timestamp;
+    Class log_class{};
+    Level log_level{};
+    const char* filename = nullptr;
+    const char* function = nullptr;
+    unsigned int line_num = 0;
+};
+
+/// Formats a log entry into the provided text buffer.
+std::string FormatLogMessage(const Entry& entry) noexcept;
+
+/// Prints the same message as `PrintMessage`, but colored according to the severity level.
+void PrintColoredMessage(const Entry& entry) noexcept;
+
+/// Formats and prints a log entry to the android logcat.
+void PrintMessageToLogcat(const Entry& entry) noexcept;
+
 } // namespace Common::Log
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -20,10 +17,6 @@
 #endif
 #endif

-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-
 #include "common/memory_detect.h"

 namespace Common {
@@ -76,61 +69,4 @@ const MemoryInfo& GetMemInfo() {
    return mem_info;
 }

-u64 GetPermissibleMapCount() {
-    constexpr u64 DefaultMapCount = 65530;
-    constexpr u64 ReservedMaps = 20000;
-    u64 count = DefaultMapCount;
-#ifdef __linux__
-    if (std::FILE* const file = std::fopen("/proc/sys/vm/max_map_count", "re")) {
-        char line[32];
-        if (std::fgets(line, sizeof(line), file) != nullptr) {
-            const u64 parsed = std::strtoull(line, nullptr, 10);
-            if (parsed != 0) {
-                count = parsed;
-            }
-        }
-        std::fclose(file);
-    }
-#endif
-    if (count <= ReservedMaps) {
-        return 0;
-    }
-    return count - ReservedMaps;
-}
-
-u64 GetAvailablePhysicalMemory() {
-#ifdef _WIN32
-    MEMORYSTATUSEX memorystatus;
-    memorystatus.dwLength = sizeof(memorystatus);
-    if (GlobalMemoryStatusEx(&memorystatus) == 0) {
-        return 0;
-    }
-    return memorystatus.ullAvailPhys;
-#elif defined(__linux__)
-    static constexpr char AvailableKey[] = "MemAvailable:";
-    if (std::FILE* const file = std::fopen("/proc/meminfo", "re")) {
-        char line[256];
-        u64 available = 0;
-        while (std::fgets(line, sizeof(line), file) != nullptr) {
-            if (std::strncmp(line, AvailableKey, sizeof(AvailableKey) - 1) != 0) {
-                continue;
-            }
-            available = std::strtoull(line + sizeof(AvailableKey) - 1, nullptr, 10) * 1024;
-            break;
-        }
-        std::fclose(file);
-        if (available != 0) {
-            return available;
-        }
-    }
-    struct sysinfo meminfo;
-    if (sysinfo(&meminfo) != 0) {
-        return 0;
-    }
-    return static_cast<u64>(meminfo.freeram) * static_cast<u64>(meminfo.mem_unit);
-#else
-    return 0;
-#endif
-}
-
 } // namespace Common
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -21,8 +18,4 @@ struct MemoryInfo {
 */
 [[nodiscard]] const MemoryInfo& GetMemInfo();

-[[nodiscard]] u64 GetPermissibleMapCount();
-
-[[nodiscard]] u64 GetAvailablePhysicalMemory();
-
 } // namespace Common
@@ -645,9 +645,6 @@ struct Values {
    SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                     Category::RendererHacks};

-    SwitchableSetting<bool> use_unified_memory{linkage, false, "use_unified_memory",
-                                               Category::RendererHacks};
-
    SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
                                                  GpuUnswizzleSize::Large,
                                                  "gpu_unswizzle_texture_size",
@@ -128,7 +128,7 @@ ENUM(TimeZone, Auto, Default, Cet, Cst6Cdt, Cuba, Eet, Egypt, Eire, Est, Est5Edt
    GmtPlusZero, GmtMinusZero, GmtZero, Greenwich, Hongkong, Hst, Iceland, Iran, Israel, Jamaica,
    Japan, Kwajalein, Libya, Met, Mst, Mst7Mdt, Navajo, Nz, NzChat, Poland, Portugal, Prc, Pst8Pdt,
    Roc, Rok, Singapore, Turkey, Uct, Universal, Utc, WSu, Wet, Zulu);
-ENUM(AnisotropyMode, Automatic, Default, X2, X4, X8, X16);
+ENUM(AnisotropyMode, Automatic, Default, X2, X4, X8, X16, X32, X64, None);
 ENUM(AstcDecodeMode, Cpu, Gpu, CpuAsynchronous);
 ENUM(AstcRecompression, Uncompressed, Bc1, Bc3);
 ENUM(FramePacingMode, Target_Auto, Target_30, Target_60, Target_90, Target_120);
@@ -1205,7 +1205,6 @@ else()
    endif()
 endif()

-target_include_directories(core PRIVATE ${OPUS_INCLUDE_DIRS})
 target_link_libraries(core PUBLIC common PRIVATE audio_core hid_core network video_core nx_tzdb tz)

 if (BOOST_NO_HEADERS)
@@ -286,7 +286,6 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
        break;
    // Paranoia mode for debugging optimizations
    case Settings::CpuAccuracy::Paranoid:
@@ -338,7 +338,6 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
        config.unsafe_optimizations = true;
        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
        config.fastmem_address_space_bits = 64;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
        break;
    // Paranoia mode for debugging optimizations
    case Settings::CpuAccuracy::Paranoid:
@@ -119,7 +119,6 @@ struct System::Impl {

        is_multicore = Settings::values.use_multi_core.GetValue();
        extended_memory_layout = Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
-        unified_memory = Settings::values.use_unified_memory.GetValue();

        core_timing.SetMulticore(is_multicore);
        core_timing.Initialize([&system]() { system.RegisterHostThread(); });
@@ -147,8 +146,7 @@ struct System::Impl {
            !device_memory.has_value() ||
            is_multicore != Settings::values.use_multi_core.GetValue() ||
            extended_memory_layout != (Settings::values.memory_layout_mode.GetValue() !=
-                                       Settings::MemoryLayout::Memory_4Gb) ||
-            unified_memory != Settings::values.use_unified_memory.GetValue();
+                                       Settings::MemoryLayout::Memory_4Gb);

        if (!must_reinitialize) {
            return;
@@ -159,7 +157,6 @@ struct System::Impl {
        is_multicore = Settings::values.use_multi_core.GetValue();
        extended_memory_layout =
            Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
-        unified_memory = Settings::values.use_unified_memory.GetValue();

        Initialize(system);
    }
@@ -506,7 +503,6 @@ struct System::Impl {
    std::atomic_bool is_powered_on{};
    bool is_multicore : 1 = false;
    bool extended_memory_layout : 1 = false;
-    bool unified_memory : 1 = false;
    bool exit_locked : 1 = false;
    bool exit_requested : 1 = false;
    bool nvdec_active : 1 = false;
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -15,18 +12,9 @@ constexpr size_t VirtualReserveSize = 1ULL << 38;
 constexpr size_t VirtualReserveSize = 1ULL << 39;
 #endif

-namespace {
-size_t ApplicationPoolOffset() {
-    using Init = Kernel::Board::Nintendo::Nx::KSystemControl::Init;
-    const size_t dram_size = Init::GetIntendedMemorySize();
-    const size_t application_pool_size = Init::GetApplicationPoolSize();
-    return dram_size > application_pool_size ? dram_size - application_pool_size : 0;
-}
-}
-
 DeviceMemory::DeviceMemory()
    : buffer{Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize(),
-             VirtualReserveSize, ApplicationPoolOffset()} {}
+             VirtualReserveSize} {}

 DeviceMemory::~DeviceMemory() = default;

@@ -20,8 +20,6 @@
 #include "common/scratch_buffer.h"
 #include "common/virtual_buffer.h"

-struct AHardwareBuffer;
-
 namespace Core {

 constexpr size_t DEVICE_PAGEBITS = 12ULL;
@@ -97,34 +95,6 @@ public:
        ApplyOpOnPAddr(address, buffer, operation);
    }

-    u8* GetPhysicalBase() noexcept {
-        return reinterpret_cast<u8*>(physical_base);
-    }
-
-    const u8* GetPhysicalBase() const noexcept {
-        return reinterpret_cast<const u8*>(physical_base);
-    }
-
-    size_t GetPhysicalSize() const noexcept {
-        return physical_size;
-    }
-
-    std::span<AHardwareBuffer* const> GetBackingHardwareBuffers() const noexcept {
-        return ahb_windows;
-    }
-
-    size_t GetBackingHardwareBufferWindowSize() const noexcept {
-        return ahb_window_size;
-    }
-
-    size_t GetBackingHardwareBufferBase() const noexcept {
-        return ahb_base;
-    }
-
-    bool IsBackingShared() const noexcept {
-        return backing_is_shared;
-    }
-
    PAddr GetPhysicalRawAddressFromDAddr(DAddr address) const {
        PAddr subbits = PAddr(address & page_mask);
        auto paddr = tracked_entries[(address >> page_bits)].compressed_physical_ptr;
@@ -201,11 +171,6 @@ private:
    std::unique_ptr<DeviceMemoryManagerAllocator<Traits>> impl;

    const uintptr_t physical_base;
-    const size_t physical_size;
-    const std::span<AHardwareBuffer* const> ahb_windows;
-    const size_t ahb_window_size;
-    const size_t ahb_base;
-    const bool backing_is_shared;
    DeviceInterface* device_inter;

    struct TrackedEntry {
@@ -171,11 +171,6 @@ struct DeviceMemoryManagerAllocator {
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
    : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())}
-    , physical_size{device_memory_.buffer.BackingSize()}
-    , ahb_windows{device_memory_.buffer.BackingHardwareBuffers()}
-    , ahb_window_size{device_memory_.buffer.BackingHardwareBufferWindowSize()}
-    , ahb_base{device_memory_.buffer.BackingHardwareBufferBase()}
-    , backing_is_shared{device_memory_.buffer.IsBackingShared()}
    , device_inter{nullptr}
    , compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS))
    , tracked_entries(device_as_size >> Memory::YUZU_PAGEBITS)
@@ -105,12 +105,7 @@ void LoopProcess(Core::System& system) {
    auto server_manager = std::make_unique<ServerManager>(system);
    auto module = std::make_shared<Module>(system);
    server_manager->RegisterNamedService("nvdrv", std::make_shared<NVDRV>(system, module, "nvdrv"));
-
-    const auto NvdrvInterfaceFactoryForApplets = [&, module] {
-        return std::make_shared<NVDRV>(system, module, "nvdrv:a");
-    };
-
-    server_manager->RegisterNamedService("nvdrv:a", NvdrvInterfaceFactoryForApplets);
+    server_manager->RegisterNamedService("nvdrv:a", std::make_shared<NVDRV>(system, module, "nvdrv:a"));
    server_manager->RegisterNamedService("nvdrv:s", std::make_shared<NVDRV>(system, module, "nvdrv:s"));
    server_manager->RegisterNamedService("nvdrv:t", std::make_shared<NVDRV>(system, module, "nvdrv:t"));
    server_manager->RegisterNamedService("nvmemp", std::make_shared<NVMEMP>(system));
@@ -588,12 +588,7 @@ void LoopProcess(Core::System& system) {
    auto server_manager = std::make_unique<ServerManager>(system);

    auto ro = std::make_shared<RoContext>();
-
-    const auto RoInterfaceFactoryForUser = [&, ro] {
-        return std::make_shared<RoInterface>(system, "ldr:ro", ro, NrrKind::User);
-    };
-
-    server_manager->RegisterNamedService("ldr:ro", std::move(RoInterfaceFactoryForUser));
+    server_manager->RegisterNamedService("ldr:ro", std::make_shared<RoInterface>(system, "ldr:ro", ro, NrrKind::User));
    server_manager->RegisterNamedService("ro:1", std::make_shared<RoInterface>(system, "ro:1", ro, NrrKind::JitPlugin));
    server_manager->RegisterNamedService("ro:dmnt", std::make_shared<IDebugMonitorInterface>(system));
    ServerManager::RunServer(std::move(server_manager));
@@ -227,8 +227,6 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
           tr("Preserves GPU-modified data by reading it back before uploading.\nSome games require this to render certain effects properly."));
    INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
           tr("May reduce shader stutter."));
-    INSERT(Settings, use_unified_memory, tr("Enable unified memory access"),
-           tr("Lets the GPU write buffer readbacks directly into guest memory."));
    INSERT(Settings, gpu_clock, tr("GPU Clocks"),
           tr("Makes the game believe GPU work finishes faster than it does, so it stops lowering "
              "resolution and render distance to fit the Switch's clocks."));
@@ -524,6 +522,9 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                              PAIR(AnisotropyMode, X4, tr("4x")),
                              PAIR(AnisotropyMode, X8, tr("8x")),
                              PAIR(AnisotropyMode, X16, tr("16x")),
+                              PAIR(AnisotropyMode, X32, tr("32x")),
+                              PAIR(AnisotropyMode, X64, tr("64x")),
+                              PAIR(AnisotropyMode, None, tr("None")),
                          }});
    translations->insert(
        {Settings::EnumMetadata<Settings::Language>::Index(),
@@ -335,7 +335,7 @@ void SetupDenormControl(const Profile& profile, const IR::Program& program, Emit
    if (info.uses_fp32_denorms_flush && info.uses_fp32_denorms_preserve) {
        LOG_DEBUG(Shader_SPIRV, "Fp32 denorm flush and preserve on the same shader");
    } else if (info.uses_fp32_denorms_flush) {
-        if (profile.support_fp32_denorm_flush && !profile.has_broken_fp32_denorm_flush) {
+        if (profile.support_fp32_denorm_flush) {
            ctx.AddCapability(spv::Capability::DenormFlushToZero);
            ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormFlushToZero, 32U);
        } else {
@@ -13,7 +13,6 @@
 namespace Shader::Backend::SPIRV {
 namespace {
 Id SharedPointer(EmitContext& ctx, Id offset, u32 index_offset = 0) {
-    offset = ctx.BoundSharedOffset(offset, 4 + index_offset * 4);
    const Id shift_id{ctx.Const(2U)};
    Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
    if (index_offset > 0) {
@@ -161,8 +160,7 @@ Id EmitSharedAtomicExchange32(EmitContext& ctx, Id offset, Id value) {
 Id EmitSharedAtomicExchange64(EmitContext& ctx, Id offset, Id value) {
    if (ctx.profile.support_shared_int64_atomics && ctx.uses_explicit_workgroup_layout) {
        const Id shift_id{ctx.Const(3U)};
-        const Id index{
-            ctx.OpShiftRightArithmetic(ctx.U32[1], ctx.BoundSharedOffset(offset, 8), shift_id)};
+        const Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u64, ctx.shared_memory_u64, ctx.u32_zero_value, index)};
        const auto [scope, semantics]{AtomicArgs(ctx)};
@@ -31,7 +31,6 @@ std::pair<Id, Id> ExtractArgs(EmitContext& ctx, Id offset, u32 mask, u32 count)
 } // Anonymous namespace

 Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
-    offset = ctx.BoundSharedOffset(offset, 1);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -43,7 +42,6 @@ Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
-    offset = ctx.BoundSharedOffset(offset, 1);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -55,7 +53,6 @@ Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
-    offset = ctx.BoundSharedOffset(offset, 2);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
        return ctx.OpUConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -66,7 +63,6 @@ Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
-    offset = ctx.BoundSharedOffset(offset, 2);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
        return ctx.OpSConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -77,7 +73,6 @@ Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
-    offset = ctx.BoundSharedOffset(offset, 4);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2)};
        return ctx.OpLoad(ctx.U32[1], pointer);
@@ -87,7 +82,6 @@ Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
-    offset = ctx.BoundSharedOffset(offset, 8);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
        return ctx.OpLoad(ctx.U32[2], pointer);
@@ -103,7 +97,6 @@ Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
-    offset = ctx.BoundSharedOffset(offset, 16);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
        return ctx.OpLoad(ctx.U32[4], pointer);
@@ -120,7 +113,6 @@ Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
 }

 void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
-    offset = ctx.BoundSharedOffset(offset, 1);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -131,7 +123,6 @@ void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
-    offset = ctx.BoundSharedOffset(offset, 2);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
        ctx.OpStore(pointer, ctx.OpUConvert(ctx.U16, value));
@@ -141,7 +132,6 @@ void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
-    offset = ctx.BoundSharedOffset(offset, 4);
    Id pointer{};
    if (ctx.uses_explicit_workgroup_layout) {
        pointer = Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2);
@@ -154,7 +144,6 @@ void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
-    offset = ctx.BoundSharedOffset(offset, 8);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
        ctx.OpStore(pointer, value);
@@ -170,7 +159,6 @@ void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU128(EmitContext& ctx, Id offset, Id value) {
-    offset = ctx.BoundSharedOffset(offset, 16);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
        ctx.OpStore(pointer, value);
@@ -600,16 +600,6 @@ void EmitContext::DefineLocalMemory(const IR::Program& program) {
    }
 }

-Id EmitContext::BoundSharedOffset(Id offset, u32 access_bytes) {
-    if (shared_memory_declared_bytes == 0) {
-        return offset;
-    }
-    const u32 last_valid{shared_memory_declared_bytes > access_bytes
-                             ? shared_memory_declared_bytes - access_bytes
-                             : 0U};
-    return OpUMin(U32[1], offset, Const(last_valid));
-}
-
 void EmitContext::DefineSharedMemory(const IR::Program& program) {
    uses_explicit_workgroup_layout =
        profile.support_explicit_workgroup_layout &&
@@ -618,15 +608,8 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
    if (program.shared_memory_size == 0) {
        return;
    }
-    const u32 device_limit{profile.max_shared_memory_size};
-    const u32 shared_memory_size{device_limit != 0 && program.shared_memory_size > device_limit
-                                     ? device_limit
-                                     : program.shared_memory_size};
-    if (shared_memory_size != program.shared_memory_size) {
-        shared_memory_declared_bytes = shared_memory_size;
-    }
    const auto make{[&](Id element_type, u32 element_size) {
-        const u32 num_elements{Common::DivCeil(shared_memory_size, element_size)};
+        const u32 num_elements{Common::DivCeil(program.shared_memory_size, element_size)};
        const Id array_type{TypeArray(element_type, Const(num_elements))};
        Decorate(array_type, spv::Decoration::ArrayStride, element_size);

@@ -661,7 +644,7 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
        std::tie(shared_memory_u32x4, shared_u32x4, std::ignore) = make(U32[4], 16);
        return;
    }
-    const u32 num_elements{Common::DivCeil(shared_memory_size, 4U)};
+    const u32 num_elements{Common::DivCeil(program.shared_memory_size, 4U)};
    const Id type{TypeArray(U32[1], Const(num_elements))};
    shared_memory_u32_type = TypePointer(spv::StorageClass::Workgroup, type);

@@ -312,8 +312,6 @@ public:
    Id local_memory{};

    bool uses_explicit_workgroup_layout{};
-    u32 shared_memory_declared_bytes{};
-    [[nodiscard]] Id BoundSharedOffset(Id offset, u32 access_bytes);
    Id shared_memory_u8{};
    Id shared_memory_u16{};
    Id shared_memory_u32{};
@@ -86,8 +86,6 @@ struct Profile {
    bool has_broken_signed_operations{};
    /// Float controls break when fp16 is enabled
    bool has_broken_fp16_float_controls{};
-    /// Declaring fp32 denorm flush to zero miscompiles on some drivers
-    bool has_broken_fp32_denorm_flush{};
    /// Dynamic vec4 indexing is broken on some OpenGL drivers
    bool has_gl_component_indexing_bug{};
    /// The precise type qualifier is broken in the fragment stage of some drivers
@@ -103,9 +101,6 @@ struct Profile {

    u32 gl_max_compute_smem_size{};

-    /// Largest workgroup shared memory allocation the device accepts, 0 when unconstrained
-    u32 max_shared_memory_size{};
-
    /// Maxwell and earlier nVidia architectures have broken robust support
    bool has_broken_robust{};

@@ -367,9 +367,7 @@ endif()
 if (YUZU_USE_EXTERNAL_FFMPEG)
    add_dependencies(video_core ffmpeg-build)
 endif()
-
 target_include_directories(video_core PUBLIC ${FFmpeg_INCLUDE_DIR})
-
 target_link_libraries(video_core PRIVATE ${FFmpeg_LIBRARIES})
 target_link_options(video_core PRIVATE ${FFmpeg_LDFLAGS})

@@ -571,11 +571,7 @@ void BufferCache<P>::AccumulateFlushes() {

 template <class P>
 bool BufferCache<P>::ShouldWaitAsyncFlushes() const noexcept {
-    if (async_buffers.empty()) {
-        return false;
-    }
-    return async_buffers.front().has_value() ||
-           !pending_downloads.front().unified_copies.empty();
+    return (!async_buffers.empty() && async_buffers.front().has_value());
 }

 template <class P>
@@ -583,7 +579,6 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
    AccumulateFlushes();

    if (committed_gpu_modified_ranges.empty()) {
-        pending_downloads.emplace_back();
        async_buffers.emplace_back(std::optional<Async_Buffer>{});
        return;
    }
@@ -643,84 +638,27 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
    }
    committed_gpu_modified_ranges.clear();
    if (downloads.empty()) {
-        pending_downloads.emplace_back();
        async_buffers.emplace_back(std::optional<Async_Buffer>{});
        return;
    }
-
-    struct QueuedUnifiedCopy {
-        u64 window;
-        BufferId buffer_id;
-        boost::container::small_vector<BufferCopy, 16> copies;
-    };
-
-    AsyncDownloadBatch batch;
-    boost::container::small_vector<std::pair<BufferCopy, BufferId>, 16> staging_downloads;
-    boost::container::small_vector<QueuedUnifiedCopy, 4> unified_copy_queue;
-    boost::container::small_vector<u64, 4> window_ids;
-    UnifiedWindowGroups groups;
-    u64 staging_size_bytes = 0;
-    for (auto& [copy, buffer_id] : downloads) {
-        Buffer& buffer = slot_buffers[buffer_id];
-        const DAddr orig_device_addr = buffer.CpuAddr() + copy.src_offset;
-        bool unified = false;
-        if constexpr (USE_UNIFIED_MEMORY) {
-            if (runtime.HasUnifiedMemory()) {
-                window_ids.clear();
-                groups.clear();
-                unified = ResolveUnifiedWindows(orig_device_addr, copy.src_offset, copy.size,
-                                                window_ids, groups);
-            }
-        }
-        BufferCopy record{copy};
-        record.src_offset = static_cast<size_t>(orig_device_addr);
-        if (unified) {
-            async_downloads.Add(orig_device_addr, copy.size);
-            buffer.MarkUsage(copy.src_offset, copy.size);
-            for (size_t i = 0; i < window_ids.size(); ++i) {
-                unified_copy_queue.push_back(
-                    QueuedUnifiedCopy{window_ids[i], buffer_id, std::move(groups[i])});
-            }
-            batch.unified_copies.push_back(record);
-            continue;
-        }
-        copy.dst_offset = staging_size_bytes;
-        constexpr u64 align = 64ULL;
-        staging_size_bytes += (copy.size + align - 1) & ~(align - 1ULL);
-        staging_downloads.push_back({copy, buffer_id});
-    }
-
-    std::optional<Async_Buffer> download_staging;
-    if (!staging_downloads.empty()) {
-        download_staging = runtime.DownloadStagingBuffer(staging_size_bytes, true);
-    }
+    auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes, true);
+    boost::container::small_vector<BufferCopy, 4> normalized_copies;
    runtime.PreCopyBarrier();
-    for (auto& [copy, buffer_id] : staging_downloads) {
-        copy.dst_offset += download_staging->offset;
+    for (auto& [copy, buffer_id] : downloads) {
+        copy.dst_offset += download_staging.offset;
        const std::array copies{copy};
+        BufferCopy second_copy{copy};
        Buffer& buffer = slot_buffers[buffer_id];
-        BufferCopy record{copy};
-        record.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
-        const DAddr orig_device_addr = static_cast<DAddr>(record.src_offset);
+        second_copy.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
+        const DAddr orig_device_addr = static_cast<DAddr>(second_copy.src_offset);
        async_downloads.Add(orig_device_addr, copy.size);
        buffer.MarkUsage(copy.src_offset, copy.size);
-        runtime.CopyBuffer(download_staging->buffer, buffer, copies, false);
-        batch.staging_copies.push_back(record);
-    }
-    if constexpr (USE_UNIFIED_MEMORY) {
-        for (const auto& queued : unified_copy_queue) {
-            const std::span<const BufferCopy> group_span(queued.copies.data(),
-                                                         queued.copies.size());
-            runtime.CopyToUnifiedMemory(queued.window, slot_buffers[queued.buffer_id], group_span);
-        }
-        if (!unified_copy_queue.empty()) {
-            runtime.FlushUnifiedMemoryCopies();
-            runtime.UnifiedMemoryHostBarrier();
-        }
+        runtime.CopyBuffer(download_staging.buffer, buffer, copies, false);
+        normalized_copies.push_back(second_copy);
    }
    runtime.PostCopyBarrier();
-    pending_downloads.emplace_back(std::move(batch));
-    async_buffers.emplace_back(std::move(download_staging));
+    pending_downloads.emplace_back(std::move(normalized_copies));
+    async_buffers.emplace_back(download_staging);
 }

 template <class P>
@@ -735,49 +673,32 @@ void BufferCache<P>::PopAsyncFlushes() {

 template <class P>
 void BufferCache<P>::PopAsyncBuffers() {
-    struct Writeback {
-        DAddr addr;
-        const u8* src;
-        u64 size;
-    };
-    boost::container::small_vector<Writeback, 8> writebacks;
-    {
-        std::scoped_lock lock{mutex};
-        if (async_buffers.empty()) {
-            return;
-        }
-        auto& batch = pending_downloads.front();
-        auto& async_buffer = async_buffers.front();
-        if (async_buffer.has_value()) {
-            const u8* base = async_buffer->mapped_span.data();
-            const size_t base_offset = async_buffer->offset;
-            for (const auto& copy : batch.staging_copies) {
-                const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
-                const u64 dst_offset = copy.dst_offset - base_offset;
-                const u8* read_mapped_memory = base + dst_offset;
-                async_downloads.ForEachInRange(
-                    device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
-                        writebacks.push_back(
-                            {start, &read_mapped_memory[start - device_addr], end - start});
-                    });
-                async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
-                    gpu_modified_ranges.Subtract(start, end - start);
-                });
-            }
-            async_buffers_death_ring.emplace_back(*async_buffer);
-        }
-        for (const auto& copy : batch.unified_copies) {
-            const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
-            async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
-                gpu_modified_ranges.Subtract(start, end - start);
-            });
-        }
+    if (async_buffers.empty()) {
+        return;
+    }
+    if (!async_buffers.front().has_value()) {
        async_buffers.pop_front();
-        pending_downloads.pop_front();
+        return;
    }
-    for (const auto& wb : writebacks) {
-        device_memory.WriteBlockUnsafe(wb.addr, wb.src, wb.size);
+    auto& downloads = pending_downloads.front();
+    auto& async_buffer = async_buffers.front();
+    u8* base = async_buffer->mapped_span.data();
+    const size_t base_offset = async_buffer->offset;
+    for (const auto& copy : downloads) {
+        const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
+        const u64 dst_offset = copy.dst_offset - base_offset;
+        const u8* read_mapped_memory = base + dst_offset;
+        async_downloads.ForEachInRange(device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
+            device_memory.WriteBlockUnsafe(start, &read_mapped_memory[start - device_addr],
+                                           end - start);
+        });
+        async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
+            gpu_modified_ranges.Subtract(start, end - start);
+        });
    }
+    async_buffers_death_ring.emplace_back(*async_buffer);
+    async_buffers.pop_front();
+    pending_downloads.pop_front();
 }

 template <class P>
@@ -1085,25 +1006,11 @@ void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
        Buffer& buffer = slot_buffers[binding.buffer_id];
        TouchBuffer(buffer, binding.buffer_id);
        const u32 size = binding.size;
-        const bool is_written = ((channel_state->written_storage_buffers[stage] >> index) & 1) != 0;
-
-        if constexpr (USE_UNIFIED_MEMORY) {
-            const auto window = TryResolveUnifiedRange(binding.device_addr, size);
-            if (window && runtime.IsUnifiedStorageRange(size, window->offset)) {
-                if (is_written) {
-                    memory_tracker.MarkRegionAsCpuModified(binding.device_addr, size);
-                }
-                runtime.BindStorageBuffer(runtime.UnifiedWindowBuffer(window->window),
-                                          runtime.UnifiedWindowAddress(window->window),
-                                          static_cast<u32>(window->offset), size, is_written);
-                return;
-            }
-        }
-
        SynchronizeBuffer(buffer, binding.device_addr, size);

        const u32 offset = buffer.Offset(binding.device_addr);
        buffer.MarkUsage(offset, size);
+        const bool is_written = ((channel_state->written_storage_buffers[stage] >> index) & 1) != 0;

        if (is_written) {
            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
@@ -1792,142 +1699,6 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
    }
 }

-template <class P>
-bool BufferCache<P>::ResolveUnifiedWindows(
-    [[maybe_unused]] DAddr device_addr, [[maybe_unused]] u64 buffer_offset,
-    [[maybe_unused]] u64 size, [[maybe_unused]] boost::container::small_vector<u64, 4>& window_ids,
-    [[maybe_unused]] UnifiedWindowGroups& groups) {
-    if constexpr (USE_UNIFIED_MEMORY) {
-        const u8* const physical_base = device_memory.GetPhysicalBase();
-        const u64 unified_base = runtime.UnifiedMemoryBase();
-        const u64 unified_size = runtime.UnifiedMemorySize();
-        const u64 window_size = runtime.UnifiedMemoryWindowSize();
-        if (window_size == 0) {
-            return false;
-        }
-        const auto group_for = [&](u64 window) -> boost::container::small_vector<BufferCopy, 16>& {
-            for (size_t i = 0; i < window_ids.size(); ++i) {
-                if (window_ids[i] == window) {
-                    return groups[i];
-                }
-            }
-            window_ids.push_back(window);
-            groups.emplace_back();
-            return groups.back();
-        };
-        u64 downloaded = 0;
-        while (downloaded < size) {
-            const DAddr page_addr = device_addr + downloaded;
-            const u8* const ptr = device_memory.GetPointer<u8>(page_addr);
-            if (ptr == nullptr) {
-                return false;
-            }
-            const u64 page_offset = page_addr & Core::DEVICE_PAGEMASK;
-            u64 chunk = (std::min)(size - downloaded,
-                                   static_cast<u64>(Core::DEVICE_PAGESIZE) - page_offset);
-            const u64 phys_offset = static_cast<u64>(ptr - physical_base);
-            if (phys_offset < unified_base || phys_offset - unified_base + chunk > unified_size) {
-                return false;
-            }
-            const u64 relative = phys_offset - unified_base;
-            const u64 window = relative / window_size;
-            const u64 local_offset = relative % window_size;
-            chunk = (std::min)(chunk, window_size - local_offset);
-            auto& group = group_for(window);
-            if (!group.empty()) {
-                BufferCopy& last = group.back();
-                if (last.src_offset + last.size == buffer_offset + downloaded &&
-                    last.dst_offset + last.size == local_offset) {
-                    last.size += chunk;
-                    downloaded += chunk;
-                    continue;
-                }
-            }
-            group.push_back(BufferCopy{
-                .src_offset = buffer_offset + downloaded,
-                .dst_offset = local_offset,
-                .size = chunk,
-            });
-            downloaded += chunk;
-        }
-        return true;
-    } else {
-        return false;
-    }
-}
-
-template <class P>
-std::optional<typename BufferCache<P>::UnifiedWindowRange>
-BufferCache<P>::TryResolveUnifiedRange([[maybe_unused]] DAddr device_addr,
-                                       [[maybe_unused]] u64 size) {
-    if constexpr (USE_UNIFIED_MEMORY) {
-        if (size == 0 || !runtime.IsUnifiedMemoryBindable()) {
-            return std::nullopt;
-        }
-        const u64 window_size = runtime.UnifiedMemoryWindowSize();
-        if (window_size == 0) {
-            return std::nullopt;
-        }
-        const u8* const first = device_memory.GetSpan(device_addr, size);
-        if (first == nullptr) {
-            return std::nullopt;
-        }
-        const u64 phys_offset = static_cast<u64>(first - device_memory.GetPhysicalBase());
-        const u64 unified_base = runtime.UnifiedMemoryBase();
-        if (phys_offset < unified_base) {
-            return std::nullopt;
-        }
-        const u64 relative = phys_offset - unified_base;
-        const u64 unified_size = runtime.UnifiedMemorySize();
-        if (relative >= unified_size || unified_size - relative < size) {
-            return std::nullopt;
-        }
-        const u64 local_offset = relative % window_size;
-        if (window_size - local_offset < size) {
-            return std::nullopt;
-        }
-        if (memory_tracker.IsRegionGpuModified(device_addr, size) ||
-            IsRegionGpuModified(device_addr, size)) {
-            return std::nullopt;
-        }
-        return UnifiedWindowRange{
-            .window = static_cast<size_t>(relative / window_size),
-            .offset = local_offset,
-        };
-    } else {
-        return std::nullopt;
-    }
-}
-
-template <class P>
-bool BufferCache<P>::TryUnifiedDownloadMemory([[maybe_unused]] Buffer& buffer,
-                                              [[maybe_unused]] std::span<BufferCopy> copies) {
-    if constexpr (USE_UNIFIED_MEMORY) {
-        boost::container::small_vector<u64, 4> window_ids;
-        UnifiedWindowGroups groups;
-        for (const BufferCopy& copy : copies) {
-            if (!ResolveUnifiedWindows(buffer.CpuAddr() + copy.src_offset, copy.src_offset,
-                                       copy.size, window_ids, groups)) {
-                return false;
-            }
-        }
-        for (const BufferCopy& copy : copies) {
-            buffer.MarkUsage(copy.src_offset, copy.size);
-        }
-        runtime.PreCopyBarrier();
-        for (size_t i = 0; i < window_ids.size(); ++i) {
-            const std::span<const BufferCopy> group_span(groups[i].data(), groups[i].size());
-            runtime.CopyToUnifiedMemory(window_ids[i], buffer, group_span);
-        }
-        runtime.FlushUnifiedMemoryCopies();
-        runtime.UnifiedMemoryHostBarrier();
-        runtime.Finish();
-        return true;
-    } else {
-        return false;
-    }
-}
-
 template <class P>
 void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
                                        [[maybe_unused]] u64 total_size_bytes,
@@ -2031,12 +1802,6 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64
    }

    if constexpr (USE_MEMORY_MAPS) {
-        if constexpr (USE_UNIFIED_MEMORY) {
-            if (runtime.HasUnifiedMemory() &&
-                TryUnifiedDownloadMemory(buffer, std::span(copies.data(), copies.size()))) {
-                return;
-            }
-        }
        auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
        const u8* const mapped_memory = download_staging.mapped_span.data();
        const std::span<BufferCopy> copies_span(copies.data(), copies.data() + copies.size());
@@ -12,7 +12,6 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <optional>
 #include <numeric>
 #include <span>
 #include <vector>
@@ -181,7 +180,6 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf
    static constexpr bool USE_MEMORY_MAPS = P::USE_MEMORY_MAPS;
    static constexpr bool SEPARATE_IMAGE_BUFFERS_BINDINGS = P::SEPARATE_IMAGE_BUFFER_BINDINGS;
    static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = P::USE_MEMORY_MAPS_FOR_UPLOADS;
-    static constexpr bool USE_UNIFIED_MEMORY = P::USE_UNIFIED_MEMORY;

 #ifdef YUZU_LEGACY
    static constexpr s64 TARGET_THRESHOLD = 3_GiB;
@@ -445,22 +443,6 @@ private:

    void MappedUploadMemory(Buffer& buffer, u64 total_size_bytes, std::span<BufferCopy> copies);

-    bool TryUnifiedDownloadMemory(Buffer& buffer, std::span<BufferCopy> copies);
-
-    struct UnifiedWindowRange {
-        size_t window;
-        u64 offset;
-    };
-
-    std::optional<UnifiedWindowRange> TryResolveUnifiedRange(DAddr device_addr, u64 size);
-
-    using UnifiedWindowGroups =
-        boost::container::small_vector<boost::container::small_vector<BufferCopy, 16>, 4>;
-
-    bool ResolveUnifiedWindows(DAddr device_addr, u64 buffer_offset, u64 size,
-                               boost::container::small_vector<u64, 4>& window_ids,
-                               UnifiedWindowGroups& groups);
-
    void DownloadBufferMemory(Buffer& buffer_id);

    void DownloadBufferMemory(Buffer& buffer_id, DAddr device_addr, u64 size);
@@ -516,14 +498,9 @@ private:
    std::deque<Common::RangeSet<DAddr>> committed_gpu_modified_ranges;

    // Async Buffers
-    struct AsyncDownloadBatch {
-        boost::container::small_vector<BufferCopy, 4> staging_copies;
-        boost::container::small_vector<BufferCopy, 4> unified_copies;
-    };
-
    Common::OverlapRangeSet<DAddr> async_downloads;
    std::deque<std::optional<Async_Buffer>> async_buffers;
-    std::deque<AsyncDownloadBatch> pending_downloads;
+    std::deque<boost::container::small_vector<BufferCopy, 4>> pending_downloads;
    std::optional<Async_Buffer> current_buffer;

    std::deque<Async_Buffer> async_buffers_death_ring;
@@ -17,14 +17,11 @@ set(SHADER_FILES
    ${CMAKE_CURRENT_SOURCE_DIR}/astc_decoder.comp
    ${CMAKE_CURRENT_SOURCE_DIR}/blit_color_float.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_2d.comp
-    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_2d_buffer.comp
    ${CMAKE_CURRENT_SOURCE_DIR}/blit_color_msaa.frag
-    ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth_msaa.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth_stencil_msaa.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d.comp
    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d_bcn.comp
-    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d_buffer.comp
    ${CMAKE_CURRENT_SOURCE_DIR}/convert_abgr8_to_d24s8.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/convert_abgr8_to_d32f.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/convert_d32f_to_abgr8.frag
@@ -33,12 +30,8 @@ set(SHADER_FILES
    ${CMAKE_CURRENT_SOURCE_DIR}/convert_float_to_depth.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/convert_msaa_to_non_msaa.comp
    ${CMAKE_CURRENT_SOURCE_DIR}/convert_msaa_to_non_msaa.frag
-    ${CMAKE_CURRENT_SOURCE_DIR}/convert_msaa_to_non_msaa_depth.frag
-    ${CMAKE_CURRENT_SOURCE_DIR}/convert_msaa_to_non_msaa_depth_stencil.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/convert_non_msaa_to_msaa.comp
    ${CMAKE_CURRENT_SOURCE_DIR}/convert_non_msaa_to_msaa.frag
-    ${CMAKE_CURRENT_SOURCE_DIR}/convert_non_msaa_to_msaa_depth.frag
-    ${CMAKE_CURRENT_SOURCE_DIR}/convert_non_msaa_to_msaa_depth_stencil.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/convert_s8d24_to_abgr8.frag
    ${CMAKE_CURRENT_SOURCE_DIR}/full_screen_triangle.vert
    ${CMAKE_CURRENT_SOURCE_DIR}/fxaa.frag
@@ -170,44 +163,6 @@ foreach(SOURCE_FILE IN ITEMS ${SHADER_FILES})
    endif()
 endforeach()

-# Integer variants of the MSAA conversion shaders. They only differ from the float
-# source in the sampler and output types, so they are generated from it via defines.
-set(SHADER_TYPE_VARIANTS
-    "convert_msaa_to_non_msaa.frag|sint|isampler2DMS|ivec4"
-    "convert_msaa_to_non_msaa.frag|uint|usampler2DMS|uvec4"
-    "convert_non_msaa_to_msaa.frag|sint|isampler2D|ivec4"
-    "convert_non_msaa_to_msaa.frag|uint|usampler2D|uvec4"
-)
-
-foreach(VARIANT IN ITEMS ${SHADER_TYPE_VARIANTS})
-    string(REPLACE "|" ";" VARIANT_PARTS ${VARIANT})
-    list(GET VARIANT_PARTS 0 VARIANT_FILENAME)
-    list(GET VARIANT_PARTS 1 VARIANT_SUFFIX)
-    list(GET VARIANT_PARTS 2 VARIANT_SAMPLER)
-    list(GET VARIANT_PARTS 3 VARIANT_TEXEL)
-
-    set(VARIANT_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/${VARIANT_FILENAME})
-    get_filename_component(VARIANT_STEM ${VARIANT_FILENAME} NAME_WE)
-    get_filename_component(VARIANT_EXT ${VARIANT_FILENAME} EXT)
-    string(REPLACE "." "" VARIANT_EXT ${VARIANT_EXT})
-    set(VARIANT_NAME ${VARIANT_STEM}_${VARIANT_SUFFIX}_${VARIANT_EXT})
-
-    string(TOUPPER ${VARIANT_NAME}_SPV VARIANT_VARIABLE_NAME)
-    set(VARIANT_HEADER_FILE ${SHADER_DIR}/${VARIANT_NAME}_spv.h)
-    add_custom_command(
-        OUTPUT
-            ${VARIANT_HEADER_FILE}
-        COMMAND
-            ${GLSLANGVALIDATOR} -V ${QUIET_FLAG} -I"${FIDELITYFX_INCLUDE_DIR}" ${GLSL_FLAGS}
-            -DSAMPLER_TYPE=${VARIANT_SAMPLER} -DTEXEL_TYPE=${VARIANT_TEXEL}
-            --variable-name ${VARIANT_VARIABLE_NAME} -o ${VARIANT_HEADER_FILE} ${VARIANT_SOURCE}
-            --target-env ${SPIR_V_VERSION}
-        MAIN_DEPENDENCY
-            ${VARIANT_SOURCE}
-    )
-    set(SHADER_HEADERS ${SHADER_HEADERS} ${VARIANT_HEADER_FILE})
-endforeach()
-
 foreach(FILEPATH IN ITEMS ${FIDELITYFX_FILES})
    get_filename_component(FILENAME ${FILEPATH} NAME)
    string(REPLACE "." "_" HEADER_NAME ${FILENAME})
@@ -1,12 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#version 450 core
-
-layout(binding = 0) uniform sampler2D depth_tex;
-
-layout(location = 0) in vec2 texcoord;
-
-void main() {
-    gl_FragDepth = textureLod(depth_tex, texcoord, 0).r;
-}
@@ -8,5 +8,5 @@ layout(binding = 0) uniform sampler2DMS depth_tex;
 layout(location = 0) in vec2 texcoord;

 void main() {
-    gl_FragDepth = texelFetch(depth_tex, ivec2(texcoord), gl_SampleID).r;
+    gl_FragDepth = texelFetch(depth_tex, ivec2(texcoord), 0).r;
 }
@@ -10,6 +10,6 @@ layout(binding = 1) uniform usampler2DMS stencil_tex;
 layout(location = 0) in vec2 texcoord;

 void main() {
-    gl_FragDepth = texelFetch(depth_tex, ivec2(texcoord), gl_SampleID).r;
-    gl_FragStencilRefARB = int(texelFetch(stencil_tex, ivec2(texcoord), gl_SampleID).r);
+    gl_FragDepth = texelFetch(depth_tex, ivec2(texcoord), 0).r;
+    gl_FragStencilRefARB = int(texelFetch(stencil_tex, ivec2(texcoord), 0).r);
 }
@@ -1,104 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#version 430
-
-#extension GL_EXT_shader_16bit_storage : require
-#extension GL_EXT_shader_8bit_storage : require
-
-#define BINDING_INPUT_BUFFER 0
-#define BINDING_OUTPUT_BUFFER 1
-
-layout(push_constant) uniform PushConstants {
-    uvec3 dim;
-    uint bytes_per_block_log2;
-
-    uvec3 origin;
-    uint layer_stride;
-
-    uint block_size;
-    uint x_shift;
-    uint block_height;
-    uint block_height_mask;
-} pc;
-
-layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU32 { uint u32data[]; };
-layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU64 { uvec2 u64data[]; };
-layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU128 { uvec4 u128data[]; };
-
-layout(binding = BINDING_OUTPUT_BUFFER, std430) writeonly buffer OutputBuffer {
-    uint out_u32[];
-};
-
-layout(local_size_x = 16, local_size_y = 8, local_size_z = 1) in;
-
-const uint GOB_SIZE_X = 64;
-const uint GOB_SIZE_Y = 8;
-
-const uint GOB_SIZE_X_SHIFT = 6;
-const uint GOB_SIZE_Y_SHIFT = 3;
-const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT;
-
-const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
-
-uint SwizzleTable(uint pos) {
-    const uint t[8] = uint[](
-        0x12100200, 0x13110301, 0x16140604, 0x17150705,
-        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
-    );
-    const uint i = pos >> 4;
-    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
-    return (h << 4) | (pos & 0xf);
-}
-
-uint SwizzleOffset(uvec2 pos) {
-    pos = pos & SWIZZLE_MASK;
-    return SwizzleTable(pos.y * 64u + pos.x);
-}
-
-uvec4 ReadTexel(uint offset) {
-    switch (pc.bytes_per_block_log2) {
-    case 2u:
-        return uvec4(u32data[offset / 4u], 0u, 0u, 0u);
-    case 3u:
-        return uvec4(u64data[offset / 8u], 0u, 0u);
-    case 4u:
-        return u128data[offset / 16u];
-    }
-    return uvec4(0u);
-}
-
-void main() {
-    uvec3 coord = gl_GlobalInvocationID;
-    if (coord.x >= pc.dim.x || coord.y >= pc.dim.y || coord.z >= pc.dim.z) {
-        return;
-    }
-
-    uvec3 pos = coord + pc.origin;
-    pos.x <<= pc.bytes_per_block_log2;
-
-    uint swizzle = SwizzleOffset(pos.xy);
-    uint block_y = pos.y >> GOB_SIZE_Y_SHIFT;
-
-    uint offset = 0u;
-    offset += pos.z * pc.layer_stride;
-    offset += (block_y >> pc.block_height) * pc.block_size;
-    offset += (block_y & pc.block_height_mask) << GOB_SIZE_SHIFT;
-    offset += (pos.x >> GOB_SIZE_X_SHIFT) << pc.x_shift;
-    offset += swizzle;
-
-    uvec4 texel = ReadTexel(offset);
-
-    uint words = 1u << (pc.bytes_per_block_log2 - 2u);
-    uint linear_index = coord.x + coord.y * pc.dim.x + coord.z * pc.dim.x * pc.dim.y;
-    uint out_idx = linear_index * words;
-
-    out_u32[out_idx] = texel.x;
-    if (words > 1u) {
-        out_u32[out_idx + 1u] = texel.y;
-    }
-    if (words > 2u) {
-        out_u32[out_idx + 2u] = texel.z;
-        out_u32[out_idx + 3u] = texel.w;
-    }
-}
@@ -1,105 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#version 430
-
-#define BINDING_INPUT_BUFFER 0
-#define BINDING_OUTPUT_BUFFER 1
-
-layout(push_constant) uniform PushConstants {
-    uvec3 dim;
-    uint bytes_per_block_log2;
-
-    uvec3 origin;
-    uint slice_size;
-
-    uint block_size;
-    uint x_shift;
-    uint block_height;
-    uint block_height_mask;
-
-    uint block_depth;
-    uint block_depth_mask;
-} pc;
-
-layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU32 { uint u32data[]; };
-layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU64 { uvec2 u64data[]; };
-layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU128 { uvec4 u128data[]; };
-
-layout(binding = BINDING_OUTPUT_BUFFER, std430) writeonly buffer OutputBuffer {
-    uint out_u32[];
-};
-
-layout(local_size_x = 8, local_size_y = 8, local_size_z = 4) in;
-
-const uint GOB_SIZE_X = 64;
-const uint GOB_SIZE_Y = 8;
-
-const uint GOB_SIZE_X_SHIFT = 6;
-const uint GOB_SIZE_Y_SHIFT = 3;
-const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT;
-
-const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
-
-uint SwizzleTable(uint pos) {
-    const uint t[8] = uint[](
-        0x12100200, 0x13110301, 0x16140604, 0x17150705,
-        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
-    );
-    const uint i = pos >> 4;
-    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
-    return (h << 4) | (pos & 0xf);
-}
-
-uint SwizzleOffset(uvec2 pos) {
-    pos = pos & SWIZZLE_MASK;
-    return SwizzleTable(pos.y * 64u + pos.x);
-}
-
-uvec4 ReadTexel(uint offset) {
-    switch (pc.bytes_per_block_log2) {
-    case 2u:
-        return uvec4(u32data[offset / 4u], 0u, 0u, 0u);
-    case 3u:
-        return uvec4(u64data[offset / 8u], 0u, 0u);
-    case 4u:
-        return u128data[offset / 16u];
-    }
-    return uvec4(0u);
-}
-
-void main() {
-    uvec3 coord = gl_GlobalInvocationID;
-    if (coord.x >= pc.dim.x || coord.y >= pc.dim.y || coord.z >= pc.dim.z) {
-        return;
-    }
-
-    uvec3 pos = coord + pc.origin;
-    pos.x <<= pc.bytes_per_block_log2;
-
-    uint swizzle = SwizzleOffset(pos.xy);
-    uint block_y = pos.y >> GOB_SIZE_Y_SHIFT;
-
-    uint offset = 0u;
-    offset += (pos.z >> pc.block_depth) * pc.slice_size;
-    offset += (pos.z & pc.block_depth_mask) << (GOB_SIZE_SHIFT + pc.block_height);
-    offset += (block_y >> pc.block_height) * pc.block_size;
-    offset += (block_y & pc.block_height_mask) << GOB_SIZE_SHIFT;
-    offset += (pos.x >> GOB_SIZE_X_SHIFT) << pc.x_shift;
-    offset += swizzle;
-
-    uvec4 texel = ReadTexel(offset);
-
-    uint words = 1u << (pc.bytes_per_block_log2 - 2u);
-    uint linear_index = coord.x + coord.y * pc.dim.x + coord.z * pc.dim.x * pc.dim.y;
-    uint out_idx = linear_index * words;
-
-    out_u32[out_idx] = texel.x;
-    if (words > 1u) {
-        out_u32[out_idx + 1u] = texel.y;
-    }
-    if (words > 2u) {
-        out_u32[out_idx + 2u] = texel.z;
-        out_u32[out_idx + 3u] = texel.w;
-    }
-}
@@ -3,14 +3,7 @@

 #version 450 core

-#ifndef SAMPLER_TYPE
-#define SAMPLER_TYPE sampler2DMS
-#endif
-#ifndef TEXEL_TYPE
-#define TEXEL_TYPE vec4
-#endif
-
-layout(binding = 0) uniform SAMPLER_TYPE msaa_in;
+layout(binding = 0) uniform sampler2DMS msaa_in;

 layout(push_constant) uniform PushConstants {
    ivec2 dst_offset;
@@ -18,7 +11,7 @@ layout(push_constant) uniform PushConstants {
    ivec2 scale;
 };

-layout(location = 0) out TEXEL_TYPE frag_color;
+layout(location = 0) out vec4 frag_color;

 void main() {
    const ivec2 coord = ivec2(gl_FragCoord.xy) - dst_offset + src_offset;
@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#version 450 core
-
-layout(binding = 0) uniform sampler2DMS msaa_in;
-
-layout(push_constant) uniform PushConstants {
-    ivec2 dst_offset;
-    ivec2 src_offset;
-    ivec2 scale;
-};
-
-void main() {
-    const ivec2 coord = ivec2(gl_FragCoord.xy) - dst_offset + src_offset;
-    const ivec2 msaa_coord = coord / scale;
-    const ivec2 sample_offset = coord % scale;
-    const int sample_id = sample_offset.x + scale.x * sample_offset.y;
-    gl_FragDepth = texelFetch(msaa_in, msaa_coord, sample_id).r;
-}
@@ -1,23 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#version 450 core
-#extension GL_ARB_shader_stencil_export : require
-
-layout(binding = 0) uniform sampler2DMS depth_tex;
-layout(binding = 1) uniform usampler2DMS stencil_tex;
-
-layout(push_constant) uniform PushConstants {
-    ivec2 dst_offset;
-    ivec2 src_offset;
-    ivec2 scale;
-};
-
-void main() {
-    const ivec2 coord = ivec2(gl_FragCoord.xy) - dst_offset + src_offset;
-    const ivec2 msaa_coord = coord / scale;
-    const ivec2 sample_offset = coord % scale;
-    const int sample_id = sample_offset.x + scale.x * sample_offset.y;
-    gl_FragDepth = texelFetch(depth_tex, msaa_coord, sample_id).r;
-    gl_FragStencilRefARB = int(texelFetch(stencil_tex, msaa_coord, sample_id).r);
-}
@@ -3,14 +3,7 @@

 #version 450 core

-#ifndef SAMPLER_TYPE
-#define SAMPLER_TYPE sampler2D
-#endif
-#ifndef TEXEL_TYPE
-#define TEXEL_TYPE vec4
-#endif
-
-layout(binding = 0) uniform SAMPLER_TYPE img_in;
+layout(binding = 0) uniform sampler2D img_in;

 layout(push_constant) uniform PushConstants {
    ivec2 dst_offset;
@@ -18,7 +11,7 @@ layout(push_constant) uniform PushConstants {
    ivec2 scale;
 };

-layout(location = 0) out TEXEL_TYPE frag_color;
+layout(location = 0) out vec4 frag_color;

 void main() {
    const ivec2 msaa_coord = ivec2(gl_FragCoord.xy) - dst_offset;
@@ -1,19 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#version 450 core
-
-layout(binding = 0) uniform sampler2D img_in;
-
-layout(push_constant) uniform PushConstants {
-    ivec2 dst_offset;
-    ivec2 src_offset;
-    ivec2 scale;
-};
-
-void main() {
-    const ivec2 msaa_coord = ivec2(gl_FragCoord.xy) - dst_offset;
-    const ivec2 sample_offset = ivec2(gl_SampleID % scale.x, gl_SampleID / scale.x);
-    const ivec2 coord = msaa_coord * scale + sample_offset + src_offset;
-    gl_FragDepth = texelFetch(img_in, coord, 0).r;
-}
@@ -1,22 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#version 450 core
-#extension GL_ARB_shader_stencil_export : require
-
-layout(binding = 0) uniform sampler2D depth_tex;
-layout(binding = 1) uniform usampler2D stencil_tex;
-
-layout(push_constant) uniform PushConstants {
-    ivec2 dst_offset;
-    ivec2 src_offset;
-    ivec2 scale;
-};
-
-void main() {
-    const ivec2 msaa_coord = ivec2(gl_FragCoord.xy) - dst_offset;
-    const ivec2 sample_offset = ivec2(gl_SampleID % scale.x, gl_SampleID / scale.x);
-    const ivec2 coord = msaa_coord * scale + sample_offset + src_offset;
-    gl_FragDepth = texelFetch(depth_tex, coord, 0).r;
-    gl_FragStencilRefARB = int(texelFetch(stencil_tex, coord, 0).r);
-}
@@ -7,7 +7,6 @@ layout(push_constant) uniform constants {
    vec2 scale;
    vec2 size;
    vec2 resize_factor;
-    vec2 crop_offset;
    float edge_sharpness;
 };
 layout(location = 0) out highp vec2 texcoord;
@@ -16,5 +15,5 @@ void main() {
    float x = float((gl_VertexIndex & 1) << 2);
    float y = float((gl_VertexIndex & 2) << 1);
    gl_Position = vec4(x - 1.0f, y - 1.0f, 0.0, 1.0f) * vec4(sign(resize_factor), 1.f, 1.f);
-    texcoord = crop_offset + vec2(x, y) * abs(resize_factor) * 0.5;
+    texcoord = vec2(x, y) * abs(resize_factor) * 0.5;
 }
@@ -6,52 +6,34 @@
 precision highp float;
 precision highp int;

+// Operation modes: RGBA -> 1, RGBY -> 3, LERP -> 4
+#define OPERATION_MODE 1
 #define EDGE_THRESHOLD (8.0 / 255.0)
-#define DIRECTION_EPSILON 6.5e-05
-#define DEVIATION_FLOOR 6.0e-02

 layout(push_constant) uniform constants {
    vec2 scale;
    vec2 size;
    vec2 resize_factor;
-    vec2 crop_offset;
    float edge_sharpness;
 };
 layout(set = 0, binding = 0) uniform sampler2D sampler0;
 layout(location=0) in vec2 texcoord;
 layout(location=0) out vec4 frag_color;

-mediump vec4 fastLanczos2(mediump vec4 x) {
-    mediump vec4 wA = x - 4.0f;
-    mediump vec4 wB = x * wA - wA;
-    wA *= wA;
-    return wB * wA;
-}
-
-mediump vec2 edgeDirection(mediump vec4 left, mediump vec4 right) {
-    mediump float RxLz = right.x - left.z;
-    mediump float RwLy = right.w - left.y;
-    mediump vec2 delta = vec2(RxLz + RwLy, RxLz - RwLy);
-    mediump float length_inv =
-        inversesqrt((delta.x * delta.x + DIRECTION_EPSILON) + delta.y * delta.y);
-    return delta * length_inv;
-}
-
-mediump vec4 weightY(mediump vec4 dx, mediump vec4 dy, mediump vec4 c, mediump float std,
-                     mediump vec2 dir) {
-    mediump vec4 edge_dis = dx * dir.y + dy * dir.x;
-    mediump vec4 x = (dx * dx + dy * dy) +
-                     (edge_dis * edge_dis) * (clamp((c * c) * std, 0.0f, 1.0f) * 0.7f - 1.0f);
-    return fastLanczos2(x);
+vec4 weightY(vec4 dx, vec4 dy, vec4 std) {
+    vec4 x = ((dx * dx) + (dy * dy)) * 0.55f + std;
+    return (x - 1.f) * (x - 4.f) * 3.8125f; // approx. of (x - 1) * (x - 4)^3
 }

 void main() {
-    mediump vec4 color = textureLod(sampler0, texcoord.xy, 0.0f);
-    highp vec2 icoord = (texcoord * size + vec2(-0.5f, 0.5f));
-    highp vec2 icoord_pixel = floor(icoord);
-    highp vec2 coord = icoord_pixel * scale;
-    mediump vec2 pl = icoord - icoord_pixel;
-    mediump mat3x4 dg = mat3x4(
+    vec4 color = textureLod(sampler0, texcoord.xy, 0.0f);
+    // image coord
+    vec2 icoord = (texcoord * size + vec2(-0.5f, 0.5f));
+    vec2 icoord_pixel = floor(icoord);
+    vec2 coord = icoord_pixel * scale;
+    vec2 pl = icoord - icoord_pixel;
+    // left: 0, right: 1, upDown: 2
+    mat3x4 dg = mat3x4(
        textureGather(sampler0, coord, 1),
        textureGather(sampler0, coord + vec2(2.f * scale.x, 0.0f), 1),
        vec4(
@@ -59,40 +41,42 @@ void main() {
            textureGather(sampler0, coord + vec2(scale.x, +scale.y), 1).yx
        )
    );
-    mediump float edgeVote =
-        abs(dg[0].z - dg[0].y) + abs(color.y - dg[0].y) + abs(color.y - dg[0].z);
+    float edgeVote = abs(dg[0].z - dg[0].y) + abs(color.y - dg[0].y) + abs(color.y - dg[0].z);
    if (edgeVote > EDGE_THRESHOLD) {
-        mediump float mean = (dg[0].y + dg[0].z + dg[1].x + dg[1].w) * 0.25f;
+        float mean = (dg[0].y + dg[0].z + dg[1].x + dg[1].w) * 0.25f;
        dg = dg - mean;
-        mediump float sum = dot(abs(dg[0]) + abs(dg[1]) + abs(dg[2]), vec4(1.0f));
-        mediump float sum_mean = 1.014185e+01f / max(sum, DEVIATION_FLOOR);
-        mediump float std = sum_mean * sum_mean;
-        mediump vec2 dir = edgeDirection(dg[0], dg[1]);
-        mediump vec4 w0 = weightY(
-            pl.xxxx + vec4(+1.0f, +0.0f, +0.0f, +1.0f),
-            pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
-            dg[0], std, dir
+        vec4 sum = abs(dg[0]) + abs(dg[1]) + abs(dg[2]);
+        float std = 2.181818f / (sum.x + sum.y + sum.z + sum.w);
+        mat2x4 w = mat2x4(
+            weightY(
+                pl.xxxx + vec4(+1.0f, +0.0f, +0.0f, +1.0f),
+                pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
+                clamp(abs(dg[0]) * std, 0.0f, 1.0f)
+            ) + weightY(
+                pl.xxxx + vec4(-1.0f, -2.0f, -2.0f, -1.0f),
+                pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
+                clamp(abs(dg[1]) * std, 0.0f, 1.0f)
+            ) + weightY(
+                pl.xxxx + vec4(+0.0f, -1.0f, -1.0f, +0.0f),
+                pl.yyyy + vec4(+1.0f, +1.0f, -2.0f, -2.0f),
+                clamp(abs(dg[2]) * std, 0.0f, 1.0f)
+            ),
+            dg[0] + dg[1] + dg[2]
        );
-        mediump vec4 w1 = weightY(
-            pl.xxxx + vec4(-1.0f, -2.0f, -2.0f, -1.0f),
-            pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
-            dg[1], std, dir
+        // compute final y with bounds
+        vec2 yb = vec2(
+            min(min(dg[0].y, dg[0].z), min(dg[1].x, dg[1].w)), // min
+            max(max(dg[0].y, dg[0].z), max(dg[1].x, dg[1].w))  // max
        );
-        mediump vec4 w2 = weightY(
-            pl.xxxx + vec4(+0.0f, -1.0f, -1.0f, +0.0f),
-            pl.yyyy + vec4(+1.0f, +1.0f, -2.0f, -2.0f),
-            dg[2], std, dir
+        vec2 fvy = vec2(
+            w[0].x + w[0].y + w[0].z + w[0].w,
+            w[1].x + w[1].y + w[1].z + w[1].w
        );
-        mediump float sum_w = dot(w0 + w1 + w2, vec4(1.0f));
-        mediump float sum_wc = dot(w0 * dg[0] + w1 * dg[1] + w2 * dg[2], vec4(1.0f));
-        mediump vec2 yb = vec2(
-            min(min(dg[0].y, dg[0].z), min(dg[1].x, dg[1].w)),
-            max(max(dg[0].y, dg[0].z), max(dg[1].x, dg[1].w))
-        );
-        mediump float fy = clamp((sum_wc / sum_w) * edge_sharpness, yb[0], yb[1]);
-        mediump float dy = clamp(fy - color.y + mean, -23.0f / 255.0f, 23.0f / 255.0f);
+        float fy = clamp((fvy.y / fvy.x) * edge_sharpness, yb[0], yb[1]);
+        // Smooth high contrast input
+        float dy = clamp(fy - color.y + mean, -23.0f / 255.0f, 23.0f / 255.0f);
        color = clamp(color + dy, 0.0f, 1.0f);
    }
-    color.w = 1.0f;
+    color.w = 1.0f;  //assume alpha channel is not used
    frag_color.xyzw = color;
-}
+}
@@ -13,7 +13,6 @@
 layout( push_constant ) uniform constants {
    vec4 ViewportInfo[1];
    vec2 ResizeFactor;
-    vec2 CropOffset;
    float EdgeSharpness;
 };
 layout(set = 0, binding = 0) uniform sampler2D ps0;
@@ -261,7 +261,6 @@ struct BufferCacheParams {

    // TODO: Investigate why OpenGL seems to perform worse with persistently mapped buffer uploads
    static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = false;
-    static constexpr bool USE_UNIFIED_MEMORY = false;
 };

 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;
@@ -231,14 +231,12 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
          .has_broken_unsigned_image_offsets = true,
          .has_broken_signed_operations = true,
          .has_broken_fp16_float_controls = false,
-          .has_broken_fp32_denorm_flush = false,
          .has_gl_component_indexing_bug = device.HasComponentIndexingBug(),
          .has_gl_precise_bug = device.HasPreciseBug(),
          .has_gl_cbuf_ftou_bug = device.HasCbufFtouBug(),
          .has_gl_bool_ref_bug = device.HasBoolRefBug(),
          .ignore_nan_fp_comparisons = true,
          .gl_max_compute_smem_size = device.GetMaxComputeSharedMemorySize(),
-          .max_shared_memory_size = device.GetMaxComputeSharedMemorySize(),
          .min_ssbo_alignment = device.GetShaderStorageBufferAlignment(),
          // Use the host limit, but never more than the guest can produce. Maxwell exposes 8 clip
          // distances and the SPIR-V output array is sized for at most 8, so clamping here keeps a
@@ -75,8 +75,6 @@ public:

    void Finish();

-    void FlushDeferredClear() {}
-
    StagingBufferMap UploadStagingBuffer(size_t size, bool deferred = false);

    StagingBufferMap DownloadStagingBuffer(size_t size, bool deferred = false);
@@ -372,8 +370,6 @@ struct TextureCacheParams {
    static constexpr bool HAS_EMULATED_COPIES = true;
    static constexpr bool HAS_DEVICE_MEMORY_INFO = true;
    static constexpr bool IMPLEMENTS_ASYNC_DOWNLOADS = true;
-    static constexpr bool HAS_MSAA_DOWNLOADS = false;
-    static constexpr bool USE_UNIFIED_MEMORY = false;

    using Runtime = OpenGL::TextureCacheRuntime;
    using Image = OpenGL::Image;
@@ -12,7 +12,6 @@
 #include "common/settings.h"
 #include "video_core/host_shaders/blit_color_float_frag_spv.h"
 #include "video_core/host_shaders/blit_color_msaa_frag_spv.h"
-#include "video_core/host_shaders/blit_depth_frag_spv.h"
 #include "video_core/host_shaders/blit_depth_msaa_frag_spv.h"
 #include "video_core/host_shaders/blit_depth_stencil_msaa_frag_spv.h"
 #include "video_core/host_shaders/convert_abgr8_to_d24s8_frag_spv.h"
@@ -22,15 +21,7 @@
 #include "video_core/host_shaders/convert_depth_to_float_frag_spv.h"
 #include "video_core/host_shaders/convert_float_to_depth_frag_spv.h"
 #include "video_core/host_shaders/convert_msaa_to_non_msaa_frag_spv.h"
-#include "video_core/host_shaders/convert_msaa_to_non_msaa_depth_frag_spv.h"
-#include "video_core/host_shaders/convert_msaa_to_non_msaa_depth_stencil_frag_spv.h"
-#include "video_core/host_shaders/convert_msaa_to_non_msaa_sint_frag_spv.h"
-#include "video_core/host_shaders/convert_msaa_to_non_msaa_uint_frag_spv.h"
 #include "video_core/host_shaders/convert_non_msaa_to_msaa_frag_spv.h"
-#include "video_core/host_shaders/convert_non_msaa_to_msaa_sint_frag_spv.h"
-#include "video_core/host_shaders/convert_non_msaa_to_msaa_uint_frag_spv.h"
-#include "video_core/host_shaders/convert_non_msaa_to_msaa_depth_frag_spv.h"
-#include "video_core/host_shaders/convert_non_msaa_to_msaa_depth_stencil_frag_spv.h"
 #include "video_core/host_shaders/convert_s8d24_to_abgr8_frag_spv.h"
 #include "video_core/host_shaders/full_screen_triangle_vert_spv.h"
 #include "video_core/host_shaders/vulkan_blit_depth_stencil_frag_spv.h"
@@ -527,19 +518,8 @@ void RecordShaderReadBarrier(Scheduler& scheduler, const ImageView& image_view)
    }
 }

-[[nodiscard]] MSAACopyFormatClass FormatClass(VideoCore::Surface::PixelFormat format) {
-    if (!VideoCore::Surface::IsPixelFormatInteger(format)) {
-        return MSAACopyFormatClass::Float;
-    }
-    if (VideoCore::Surface::IsPixelFormatSignedInteger(format)) {
-        return MSAACopyFormatClass::SignedInteger;
-    }
-    return MSAACopyFormatClass::UnsignedInteger;
-}
-
 [[nodiscard]] vk::ImageView MakeMSAACopyView(const vk::Device& device, VkImage image,
-                                             VkFormat format, u32 base_level, u32 base_layer,
-                                             VkImageAspectFlags aspect_mask) {
+                                             VkFormat format, u32 base_level) {
    return device.CreateImageView(VkImageViewCreateInfo{
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .pNext = nullptr,
@@ -554,10 +534,10 @@ void RecordShaderReadBarrier(Scheduler& scheduler, const ImageView& image_view)
            .a = VK_COMPONENT_SWIZZLE_IDENTITY,
        },
        .subresourceRange{
-            .aspectMask = aspect_mask,
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
            .baseMipLevel = base_level,
            .levelCount = 1,
-            .baseArrayLayer = base_layer,
+            .baseArrayLayer = 0,
            .layerCount = 1,
        },
    });
@@ -606,17 +586,12 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
      msaa_copy_pipeline_layout(device.GetLogical().CreatePipelineLayout(PipelineLayoutCreateInfo(
          one_texture_set_layout.address(),
          PUSH_CONSTANT_RANGE<VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(MSAACopyPushConstants)>))),
-      msaa_copy_depth_stencil_pipeline_layout(
-          device.GetLogical().CreatePipelineLayout(PipelineLayoutCreateInfo(
-              two_textures_set_layout.address(),
-              PUSH_CONSTANT_RANGE<VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(MSAACopyPushConstants)>))),
      full_screen_vert(BuildShader(device, FULL_SCREEN_TRIANGLE_VERT_SPV)),
      blit_color_to_color_frag(BuildShader(device, BLIT_COLOR_FLOAT_FRAG_SPV)),
      blit_color_msaa_frag(BuildShader(device, BLIT_COLOR_MSAA_FRAG_SPV)),
      blit_depth_stencil_frag(device.IsExtShaderStencilExportSupported()
                             ? BuildShader(device, VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV)
                             : vk::ShaderModule{}),
-      blit_depth_frag(BuildShader(device, BLIT_DEPTH_FRAG_SPV)),
      blit_depth_msaa_frag(BuildShader(device, BLIT_DEPTH_MSAA_FRAG_SPV)),
      blit_depth_stencil_msaa_frag(device.IsExtShaderStencilExportSupported()
                             ? BuildShader(device, BLIT_DEPTH_STENCIL_MSAA_FRAG_SPV)
@@ -634,25 +609,7 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
      convert_d24s8_to_abgr8_frag(BuildShader(device, CONVERT_D24S8_TO_ABGR8_FRAG_SPV)),
      convert_s8d24_to_abgr8_frag(BuildShader(device, CONVERT_S8D24_TO_ABGR8_FRAG_SPV)),
      convert_msaa_to_non_msaa_frag(BuildShader(device, CONVERT_MSAA_TO_NON_MSAA_FRAG_SPV)),
-      convert_msaa_to_non_msaa_sint_frag(
-          BuildShader(device, CONVERT_MSAA_TO_NON_MSAA_SINT_FRAG_SPV)),
-      convert_msaa_to_non_msaa_uint_frag(
-          BuildShader(device, CONVERT_MSAA_TO_NON_MSAA_UINT_FRAG_SPV)),
-      convert_msaa_to_non_msaa_depth_frag(
-          BuildShader(device, CONVERT_MSAA_TO_NON_MSAA_DEPTH_FRAG_SPV)),
-      convert_msaa_to_non_msaa_depth_stencil_frag(
-          BuildShader(device, CONVERT_MSAA_TO_NON_MSAA_DEPTH_STENCIL_FRAG_SPV)),
      convert_non_msaa_to_msaa_frag(BuildShader(device, CONVERT_NON_MSAA_TO_MSAA_FRAG_SPV)),
-      convert_non_msaa_to_msaa_sint_frag(
-          BuildShader(device, CONVERT_NON_MSAA_TO_MSAA_SINT_FRAG_SPV)),
-      convert_non_msaa_to_msaa_uint_frag(
-          BuildShader(device, CONVERT_NON_MSAA_TO_MSAA_UINT_FRAG_SPV)),
-      convert_non_msaa_to_msaa_depth_frag(
-          BuildShader(device, CONVERT_NON_MSAA_TO_MSAA_DEPTH_FRAG_SPV)),
-      convert_non_msaa_to_msaa_depth_stencil_frag(
-          device.IsExtShaderStencilExportSupported()
-              ? BuildShader(device, CONVERT_NON_MSAA_TO_MSAA_DEPTH_STENCIL_FRAG_SPV)
-              : vk::ShaderModule{}),
      linear_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_LINEAR>)),
      nearest_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_NEAREST>)) {}

@@ -667,13 +624,24 @@ void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, const ImageV
        .renderpass = dst_framebuffer->RenderPass(),
        .operation = operation,
    };
-    VkSampler sampler = *nearest_sampler;
-    if (is_linear) {
-        sampler = *linear_sampler;
-    }
-    BlitImpl(dst_framebuffer, src_image_view, dst_region, src_region,
-             FindOrEmplaceColorPipeline(key), sampler,
-             src_image_view.Handle(Shader::TextureType::Color2D), VK_NULL_HANDLE, false);
+    const VkPipelineLayout layout = *one_texture_pipeline_layout;
+    const VkSampler sampler = is_linear ? *linear_sampler : *nearest_sampler;
+    const VkPipeline pipeline = FindOrEmplaceColorPipeline(key);
+    const VkImageView src_view = src_image_view.Handle(Shader::TextureType::Color2D);
+
+    RecordShaderReadBarrier(scheduler, src_image_view);
+    scheduler.RequestRenderpass(dst_framebuffer);
+    scheduler.Record([this, dst_region, src_region, pipeline, layout, sampler,
+                      src_view](vk::CommandBuffer cmdbuf) {
+        const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();
+        UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_view);
+        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
+                                  nullptr);
+        BindBlitState(cmdbuf, layout, dst_region, src_region);
+        cmdbuf.Draw(3, 1, 0, 0);
+    });
+    scheduler.InvalidateState();
 }

 void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, VkImageView src_image_view,
@@ -702,29 +670,24 @@ void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, VkImageView
    });
 }

-void BlitImageHelper::BlitImpl(const Framebuffer* dst_framebuffer,
-                               const ImageView& src_image_view, const Region2D& dst_region,
-                               const Region2D& src_region, VkPipeline pipeline, VkSampler sampler,
-                               VkImageView src_view, VkImageView src_stencil_view,
-                               bool blit_stencil) {
-    VkPipelineLayout layout = *one_texture_pipeline_layout;
-    if (blit_stencil) {
-        layout = *two_textures_pipeline_layout;
-    }
+void BlitImageHelper::BlitColorMSAA(const Framebuffer* dst_framebuffer,
+                                    const ImageView& src_image_view, const Region2D& dst_region,
+                                    const Region2D& src_region) {
+    const BlitMSAAPipelineKey key{
+        .renderpass = dst_framebuffer->RenderPass(),
+        .samples = dst_framebuffer->Samples(),
+    };
+    const VkPipelineLayout layout = *one_texture_pipeline_layout;
+    const VkSampler sampler = *nearest_sampler;
+    const VkPipeline pipeline = FindOrEmplaceBlitColorMSAAPipeline(key);
+    const VkImageView src_view = src_image_view.Handle(Shader::TextureType::Color2D);

    RecordShaderReadBarrier(scheduler, src_image_view);
    scheduler.RequestRenderpass(dst_framebuffer);
-    scheduler.Record([this, dst_region, src_region, pipeline, layout, sampler, src_view,
-                      src_stencil_view, blit_stencil](vk::CommandBuffer cmdbuf) {
-        VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
-        if (blit_stencil) {
-            descriptor_set = two_textures_descriptor_allocator.Commit();
-            UpdateTwoTexturesDescriptorSet(device, descriptor_set, sampler, src_view,
-                                           src_stencil_view);
-        } else {
-            descriptor_set = one_texture_descriptor_allocator.Commit();
-            UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_view);
-        }
+    scheduler.Record([this, dst_region, src_region, pipeline, layout, sampler,
+                      src_view](vk::CommandBuffer cmdbuf) {
+        const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();
+        UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_view);
        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
                                  nullptr);
@@ -734,56 +697,41 @@ void BlitImageHelper::BlitImpl(const Framebuffer* dst_framebuffer,
    scheduler.InvalidateState();
 }

-void BlitImageHelper::BlitColorMSAA(const Framebuffer* dst_framebuffer,
-                                    const ImageView& src_image_view, const Region2D& dst_region,
-                                    const Region2D& src_region) {
-    const BlitMSAAPipelineKey key{
-        .renderpass = dst_framebuffer->RenderPass(),
-        .samples = dst_framebuffer->Samples(),
-    };
-    BlitImpl(dst_framebuffer, src_image_view, dst_region, src_region,
-             FindOrEmplaceBlitColorMSAAPipeline(key), *nearest_sampler,
-             src_image_view.Handle(Shader::TextureType::Color2D), VK_NULL_HANDLE, false);
-}
-
-void BlitImageHelper::BlitDepthStencilMSAA(const Framebuffer* dst_framebuffer,
-                                           ImageView& src_image_view, const Region2D& dst_region,
-                                           const Region2D& src_region) {
-    const bool blit_stencil =
-        dst_framebuffer->HasAspectStencilBit() && device.IsExtShaderStencilExportSupported();
-    const BlitMSAAPipelineKey key{
-        .renderpass = dst_framebuffer->RenderPass(),
-        .samples = dst_framebuffer->Samples(),
-    };
-    VkImageView src_stencil_view = VK_NULL_HANDLE;
-    if (blit_stencil) {
-        src_stencil_view = src_image_view.StencilView();
-    }
-    BlitImpl(dst_framebuffer, src_image_view, dst_region, src_region,
-             FindOrEmplaceBlitDepthStencilMSAAPipeline(key, blit_stencil), *nearest_sampler,
-             src_image_view.DepthView(), src_stencil_view, blit_stencil);
-}
-
-void BlitImageHelper::BlitDepth(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
-                                const Region2D& dst_region, const Region2D& src_region) {
-    BlitImpl(dst_framebuffer, src_image_view, dst_region, src_region,
-             FindOrEmplaceBlitDepthPipeline(dst_framebuffer->RenderPass()), *nearest_sampler,
-             src_image_view.DepthView(), VK_NULL_HANDLE, false);
-}
-
 void BlitImageHelper::ResolveDepthStencil(const Framebuffer* dst_framebuffer,
                                          ImageView& src_image_view, const Region2D& dst_region,
                                          const Region2D& src_region) {
    const bool resolve_stencil =
        dst_framebuffer->HasAspectStencilBit() && device.IsExtShaderStencilExportSupported();
-    VkImageView src_stencil_view = VK_NULL_HANDLE;
-    if (resolve_stencil) {
-        src_stencil_view = src_image_view.StencilView();
-    }
-    BlitImpl(dst_framebuffer, src_image_view, dst_region, src_region,
-             FindOrEmplaceResolveDepthStencilPipeline(dst_framebuffer->RenderPass(),
-                                                      resolve_stencil),
-             *nearest_sampler, src_image_view.DepthView(), src_stencil_view, resolve_stencil);
+    const VkPipeline pipeline =
+        FindOrEmplaceResolveDepthStencilPipeline(dst_framebuffer->RenderPass(), resolve_stencil);
+    const VkPipelineLayout layout =
+        resolve_stencil ? *two_textures_pipeline_layout : *one_texture_pipeline_layout;
+    const VkSampler sampler = *nearest_sampler;
+    const VkImageView src_depth_view = src_image_view.DepthView();
+    const VkImageView src_stencil_view =
+        resolve_stencil ? src_image_view.StencilView() : VK_NULL_HANDLE;
+
+    RecordShaderReadBarrier(scheduler, src_image_view);
+    scheduler.RequestRenderpass(dst_framebuffer);
+    scheduler.Record([this, dst_region, src_region, pipeline, layout, sampler, src_depth_view,
+                      src_stencil_view, resolve_stencil](vk::CommandBuffer cmdbuf) {
+        if (resolve_stencil) {
+            const VkDescriptorSet descriptor_set = two_textures_descriptor_allocator.Commit();
+            UpdateTwoTexturesDescriptorSet(device, descriptor_set, sampler, src_depth_view,
+                                           src_stencil_view);
+            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
+                                      nullptr);
+        } else {
+            const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();
+            UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_depth_view);
+            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
+                                      nullptr);
+        }
+        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+        BindBlitState(cmdbuf, layout, dst_region, src_region);
+        cmdbuf.Draw(3, 1, 0, 0);
+    });
+    scheduler.InvalidateState();
 }

 void BlitImageHelper::BlitDepthStencil(const Framebuffer* dst_framebuffer,
@@ -791,23 +739,35 @@ void BlitImageHelper::BlitDepthStencil(const Framebuffer* dst_framebuffer,
                                       const Region2D& dst_region, const Region2D& src_region,
                                       Tegra::Engines::Fermi2D::Filter filter,
                                       Tegra::Engines::Fermi2D::Operation operation) {
+    if (!device.IsExtShaderStencilExportSupported()) {
+        return;
+    }
    ASSERT(filter == Tegra::Engines::Fermi2D::Filter::Point);
    ASSERT(operation == Tegra::Engines::Fermi2D::Operation::SrcCopy);
-    const bool blit_stencil = device.IsExtShaderStencilExportSupported();
    const BlitImagePipelineKey key{
        .renderpass = dst_framebuffer->RenderPass(),
        .operation = operation,
    };
-    VkPipeline pipeline{};
-    VkImageView src_stencil_view = VK_NULL_HANDLE;
-    if (blit_stencil) {
-        pipeline = FindOrEmplaceDepthStencilPipeline(key);
-        src_stencil_view = src_image_view.StencilView();
-    } else {
-        pipeline = FindOrEmplaceBlitDepthPipeline(key.renderpass);
-    }
-    BlitImpl(dst_framebuffer, src_image_view, dst_region, src_region, pipeline, *nearest_sampler,
-             src_image_view.DepthView(), src_stencil_view, blit_stencil);
+    const VkPipelineLayout layout = *two_textures_pipeline_layout;
+    const VkSampler sampler = *nearest_sampler;
+    const VkPipeline pipeline = FindOrEmplaceDepthStencilPipeline(key);
+    const VkImageView src_depth_view = src_image_view.DepthView();
+    const VkImageView src_stencil_view = src_image_view.StencilView();
+
+    RecordShaderReadBarrier(scheduler, src_image_view);
+    scheduler.RequestRenderpass(dst_framebuffer);
+    scheduler.Record([dst_region, src_region, pipeline, layout, sampler, src_depth_view,
+                      src_stencil_view, this](vk::CommandBuffer cmdbuf) {
+        const VkDescriptorSet descriptor_set = two_textures_descriptor_allocator.Commit();
+        UpdateTwoTexturesDescriptorSet(device, descriptor_set, sampler, src_depth_view,
+                                       src_stencil_view);
+        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
+                                  nullptr);
+        BindBlitState(cmdbuf, layout, dst_region, src_region);
+        cmdbuf.Draw(3, 1, 0, 0);
+    });
+    scheduler.InvalidateState();
 }

 void BlitImageHelper::ConvertD32ToR32(const Framebuffer* dst_framebuffer,
@@ -922,183 +882,19 @@ void BlitImageHelper::ClearDepthStencil(const Framebuffer* dst_framebuffer, bool
    scheduler.InvalidateState();
 }

-void BlitImageHelper::CopyMSAAImpl(VkRenderPass renderpass, VkPipeline pipeline,
-                                   VkPipelineLayout layout, VkImage dst_image,
-                                   VkFormat dst_vk_format, VkImage src_image,
-                                   VkFormat src_vk_format, s32 scale_x, s32 scale_y,
-                                   std::span<const VideoCommon::ImageCopy> copies,
-                                   const MSAACopyAspectInfo& aspect_info, bool copy_stencil) {
-    while (!msaa_copy_resources.empty() && scheduler.IsFree(msaa_copy_resources.front().tick)) {
-        msaa_copy_resources.pop_front();
-    }
-    const VkSampler sampler = *nearest_sampler;
-    for (const VideoCommon::ImageCopy& copy : copies) {
-        const s32 num_layers = (std::min)(copy.src_subresource.num_layers,
-                                          copy.dst_subresource.num_layers);
-        for (s32 layer = 0; layer < num_layers; ++layer) {
-            const u32 src_level = static_cast<u32>(copy.src_subresource.base_level);
-            const u32 src_layer = static_cast<u32>(copy.src_subresource.base_layer + layer);
-            vk::ImageView src_view =
-                MakeMSAACopyView(device.GetLogical(), src_image, src_vk_format, src_level,
-                                 src_layer, aspect_info.src_view_aspect);
-            vk::ImageView src_stencil_view;
-            if (copy_stencil) {
-                src_stencil_view =
-                    MakeMSAACopyView(device.GetLogical(), src_image, src_vk_format, src_level,
-                                     src_layer, VK_IMAGE_ASPECT_STENCIL_BIT);
-            }
-            vk::ImageView dst_view =
-                MakeMSAACopyView(device.GetLogical(), dst_image, dst_vk_format,
-                                 static_cast<u32>(copy.dst_subresource.base_level),
-                                 static_cast<u32>(copy.dst_subresource.base_layer + layer),
-                                 aspect_info.attachment_aspect);
-            const VkOffset2D dst_offset{copy.dst_offset.x, copy.dst_offset.y};
-            const VkExtent2D dst_extent{copy.extent.width, copy.extent.height};
-            const VkRect2D render_area{
-                .offset = dst_offset,
-                .extent = dst_extent,
-            };
-            vk::Framebuffer framebuffer = device.GetLogical().CreateFramebuffer(VkFramebufferCreateInfo{
-                .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
-                .pNext = nullptr,
-                .flags = 0,
-                .renderPass = renderpass,
-                .attachmentCount = 1,
-                .pAttachments = dst_view.address(),
-                .width = static_cast<u32>(dst_offset.x) + dst_extent.width,
-                .height = static_cast<u32>(dst_offset.y) + dst_extent.height,
-                .layers = 1,
-            });
-            const MSAACopyPushConstants push_constants{
-                .dst_offset = {dst_offset.x, dst_offset.y},
-                .src_offset = {copy.src_offset.x, copy.src_offset.y},
-                .scale = {scale_x, scale_y},
-            };
-            VkImageView src_stencil_handle = VK_NULL_HANDLE;
-            if (copy_stencil) {
-                src_stencil_handle = *src_stencil_view;
-            }
-            scheduler.RequestOutsideRenderPassOperationContext();
-            scheduler.Record([this, pipeline, layout, sampler, renderpass,
-                              framebuffer_handle = *framebuffer, src_view_handle = *src_view,
-                              src_stencil_handle, src = src_image, dst = dst_image, render_area,
-                              aspect_info, push_constants](vk::CommandBuffer cmdbuf) {
-                const VkImageSubresourceRange barrier_range{
-                    .aspectMask = aspect_info.barrier_aspect,
-                    .baseMipLevel = 0,
-                    .levelCount = VK_REMAINING_MIP_LEVELS,
-                    .baseArrayLayer = 0,
-                    .layerCount = VK_REMAINING_ARRAY_LAYERS,
-                };
-                const std::array pre_barriers{
-                    VkImageMemoryBarrier{
-                        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-                        .pNext = nullptr,
-                        .srcAccessMask = aspect_info.pre_src_access,
-                        .dstAccessMask = aspect_info.pre_src_dst_access,
-                        .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
-                        .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-                        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                        .image = src,
-                        .subresourceRange = barrier_range,
-                    },
-                    VkImageMemoryBarrier{
-                        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-                        .pNext = nullptr,
-                        .srcAccessMask = aspect_info.pre_src_access,
-                        .dstAccessMask = aspect_info.pre_dst_dst_access,
-                        .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
-                        .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-                        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                        .image = dst,
-                        .subresourceRange = barrier_range,
-                    },
-                };
-                cmdbuf.PipelineBarrier(aspect_info.pre_src_stages, aspect_info.pre_dst_stages, 0,
-                                       nullptr, nullptr, pre_barriers);
-                const VkRenderPassBeginInfo renderpass_bi{
-                    .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-                    .pNext = nullptr,
-                    .renderPass = renderpass,
-                    .framebuffer = framebuffer_handle,
-                    .renderArea = render_area,
-                    .clearValueCount = 0,
-                    .pClearValues = nullptr,
-                };
-                cmdbuf.BeginRenderPass(renderpass_bi, VK_SUBPASS_CONTENTS_INLINE);
-                VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
-                if (src_stencil_handle != VK_NULL_HANDLE) {
-                    descriptor_set = two_textures_descriptor_allocator.Commit();
-                    UpdateTwoTexturesDescriptorSet(device, descriptor_set, sampler, src_view_handle,
-                                                   src_stencil_handle);
-                } else {
-                    descriptor_set = one_texture_descriptor_allocator.Commit();
-                    UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_view_handle);
-                }
-                cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
-                cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
-                                          nullptr);
-                const VkViewport viewport{
-                    .x = static_cast<float>(render_area.offset.x),
-                    .y = static_cast<float>(render_area.offset.y),
-                    .width = static_cast<float>(render_area.extent.width),
-                    .height = static_cast<float>(render_area.extent.height),
-                    .minDepth = 0.0f,
-                    .maxDepth = 1.0f,
-                };
-                cmdbuf.SetViewport(0, viewport);
-                cmdbuf.SetScissor(0, render_area);
-                cmdbuf.PushConstants(layout, VK_SHADER_STAGE_FRAGMENT_BIT, push_constants);
-                cmdbuf.Draw(3, 1, 0, 0);
-                cmdbuf.EndRenderPass();
-                const VkImageMemoryBarrier post_barrier{
-                    .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-                    .pNext = nullptr,
-                    .srcAccessMask = aspect_info.post_src_access,
-                    .dstAccessMask = aspect_info.post_dst_access,
-                    .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
-                    .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-                    .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                    .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                    .image = dst,
-                    .subresourceRange = barrier_range,
-                };
-                cmdbuf.PipelineBarrier(aspect_info.post_src_stages, aspect_info.post_dst_stages, 0,
-                                       post_barrier);
-            });
-            msaa_copy_resources.push_back(MSAACopyResources{
-                .tick = scheduler.CurrentTick(),
-                .src_view = std::move(src_view),
-                .dst_view = std::move(dst_view),
-                .framebuffer = std::move(framebuffer),
-            });
-            if (copy_stencil) {
-                msaa_copy_resources.push_back(MSAACopyResources{
-                    .tick = scheduler.CurrentTick(),
-                    .src_view = std::move(src_stencil_view),
-                    .dst_view = vk::ImageView{},
-                    .framebuffer = vk::Framebuffer{},
-                });
-            }
-        }
-    }
-    scheduler.InvalidateState();
-}
-
 void BlitImageHelper::CopyMSAA(RenderPassCache& render_pass_cache, VkImage dst_image,
                               VideoCore::Surface::PixelFormat dst_format, VkImage src_image,
                               VideoCore::Surface::PixelFormat src_format, u32 num_samples,
                               std::span<const VideoCommon::ImageCopy> copies,
                               bool msaa_to_non_msaa) {
+    while (!msaa_copy_resources.empty() && scheduler.IsFree(msaa_copy_resources.front().tick)) {
+        msaa_copy_resources.pop_front();
+    }
    const auto [samples_x, samples_y] = VideoCommon::SamplesLog2(static_cast<int>(num_samples));
    const s32 scale_x = 1 << samples_x;
    const s32 scale_y = 1 << samples_y;
-    VkSampleCountFlagBits samples = SampleCountFlag(num_samples);
-    if (msaa_to_non_msaa) {
-        samples = VK_SAMPLE_COUNT_1_BIT;
-    }
+    const VkSampleCountFlagBits samples =
+        msaa_to_non_msaa ? VK_SAMPLE_COUNT_1_BIT : SampleCountFlag(num_samples);
    RenderPassKey renderpass_key{};
    renderpass_key.color_formats.fill(VideoCore::Surface::PixelFormat::Invalid);
    renderpass_key.color_formats[0] = dst_format;
@@ -1109,35 +905,149 @@ void BlitImageHelper::CopyMSAA(RenderPassCache& render_pass_cache, VkImage dst_i
        .renderpass = renderpass,
        .samples = samples,
        .msaa_to_non_msaa = msaa_to_non_msaa,
-        .format_class = FormatClass(dst_format),
-    };
-    const MSAACopyAspectInfo aspect_info{
-        .src_view_aspect = VK_IMAGE_ASPECT_COLOR_BIT,
-        .attachment_aspect = VK_IMAGE_ASPECT_COLOR_BIT,
-        .barrier_aspect = VK_IMAGE_ASPECT_COLOR_BIT,
-        .pre_src_access = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_WRITE_BIT |
-                          VK_ACCESS_TRANSFER_WRITE_BIT,
-        .pre_src_dst_access = VK_ACCESS_SHADER_READ_BIT,
-        .pre_dst_dst_access =
-            VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        .pre_src_stages = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
-                          VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
-                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT,
-        .pre_dst_stages =
-            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        .post_src_access = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        .post_dst_access = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT,
-        .post_src_stages = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        .post_dst_stages = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                           VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT,
    };
+    const VkPipeline pipeline = FindOrEmplaceMSAACopyPipeline(key);
+    const VkPipelineLayout layout = *msaa_copy_pipeline_layout;
+    const VkSampler sampler = *nearest_sampler;
    const VkFormat src_vk_format =
        MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, true, src_format).format;
    const VkFormat dst_vk_format =
        MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, true, dst_format).format;
-    CopyMSAAImpl(renderpass, FindOrEmplaceMSAACopyPipeline(key), *msaa_copy_pipeline_layout,
-                 dst_image, dst_vk_format, src_image, src_vk_format, scale_x, scale_y, copies,
-                 aspect_info, false);
+    for (const VideoCommon::ImageCopy& copy : copies) {
+        ASSERT(copy.src_subresource.base_layer == 0);
+        ASSERT(copy.src_subresource.num_layers == 1);
+        ASSERT(copy.dst_subresource.base_layer == 0);
+        ASSERT(copy.dst_subresource.num_layers == 1);
+        vk::ImageView src_view =
+            MakeMSAACopyView(device.GetLogical(), src_image, src_vk_format,
+                             static_cast<u32>(copy.src_subresource.base_level));
+        vk::ImageView dst_view =
+            MakeMSAACopyView(device.GetLogical(), dst_image, dst_vk_format,
+                             static_cast<u32>(copy.dst_subresource.base_level));
+        const VkOffset2D dst_offset{copy.dst_offset.x, copy.dst_offset.y};
+        const VkExtent2D dst_extent{copy.extent.width, copy.extent.height};
+        const VkRect2D render_area{
+            .offset = dst_offset,
+            .extent = dst_extent,
+        };
+        vk::Framebuffer framebuffer = device.GetLogical().CreateFramebuffer(VkFramebufferCreateInfo{
+            .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0,
+            .renderPass = renderpass,
+            .attachmentCount = 1,
+            .pAttachments = dst_view.address(),
+            .width = static_cast<u32>(dst_offset.x) + dst_extent.width,
+            .height = static_cast<u32>(dst_offset.y) + dst_extent.height,
+            .layers = 1,
+        });
+        const MSAACopyPushConstants push_constants{
+            .dst_offset = {dst_offset.x, dst_offset.y},
+            .src_offset = {copy.src_offset.x, copy.src_offset.y},
+            .scale = {scale_x, scale_y},
+        };
+        scheduler.RequestOutsideRenderPassOperationContext();
+        scheduler.Record([this, pipeline, layout, sampler, renderpass,
+                          framebuffer_handle = *framebuffer, src_view_handle = *src_view,
+                          src = src_image, dst = dst_image, render_area,
+                          push_constants](vk::CommandBuffer cmdbuf) {
+            constexpr VkImageSubresourceRange color_range{
+                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                .baseMipLevel = 0,
+                .levelCount = VK_REMAINING_MIP_LEVELS,
+                .baseArrayLayer = 0,
+                .layerCount = VK_REMAINING_ARRAY_LAYERS,
+            };
+            const std::array pre_barriers{
+                VkImageMemoryBarrier{
+                    .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                    .pNext = nullptr,
+                    .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
+                                     VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+                    .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
+                    .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
+                    .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+                    .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                    .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                    .image = src,
+                    .subresourceRange = color_range,
+                },
+                VkImageMemoryBarrier{
+                    .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                    .pNext = nullptr,
+                    .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
+                                     VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+                    .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+                                     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                    .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
+                    .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+                    .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                    .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                    .image = dst,
+                    .subresourceRange = color_range,
+                },
+            };
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
+                                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
+                                       VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+                                       VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                   VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+                                       VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                                   0, nullptr, nullptr, pre_barriers);
+            const VkRenderPassBeginInfo renderpass_bi{
+                .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+                .pNext = nullptr,
+                .renderPass = renderpass,
+                .framebuffer = framebuffer_handle,
+                .renderArea = render_area,
+                .clearValueCount = 0,
+                .pClearValues = nullptr,
+            };
+            cmdbuf.BeginRenderPass(renderpass_bi, VK_SUBPASS_CONTENTS_INLINE);
+            const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();
+            UpdateOneTextureDescriptorSet(device, descriptor_set, sampler, src_view_handle);
+            cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
+                                      nullptr);
+            const VkViewport viewport{
+                .x = static_cast<float>(render_area.offset.x),
+                .y = static_cast<float>(render_area.offset.y),
+                .width = static_cast<float>(render_area.extent.width),
+                .height = static_cast<float>(render_area.extent.height),
+                .minDepth = 0.0f,
+                .maxDepth = 1.0f,
+            };
+            cmdbuf.SetViewport(0, viewport);
+            cmdbuf.SetScissor(0, render_area);
+            cmdbuf.PushConstants(layout, VK_SHADER_STAGE_FRAGMENT_BIT, push_constants);
+            cmdbuf.Draw(3, 1, 0, 0);
+            cmdbuf.EndRenderPass();
+            const VkImageMemoryBarrier post_barrier{
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT,
+                .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = dst,
+                .subresourceRange = color_range,
+            };
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                                   VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+                                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
+                                       VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                   0, post_barrier);
+        });
+        msaa_copy_resources.push_back(MSAACopyResources{
+            .tick = scheduler.CurrentTick(),
+            .src_view = std::move(src_view),
+            .dst_view = std::move(dst_view),
+            .framebuffer = std::move(framebuffer),
+        });
+    }
+    scheduler.InvalidateState();
 }

 void BlitImageHelper::Convert(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
@@ -1469,87 +1379,6 @@ VkPipeline BlitImageHelper::FindOrEmplaceBlitColorMSAAPipeline(const BlitMSAAPip
    return *blit_msaa_color_pipelines.back();
 }

-VkPipeline BlitImageHelper::FindOrEmplaceBlitDepthStencilMSAAPipeline(
-    const BlitMSAAPipelineKey& key, bool blit_stencil) {
-    auto& keys = blit_stencil ? blit_msaa_depth_stencil_keys : blit_msaa_depth_keys;
-    auto& pipelines = blit_stencil ? blit_msaa_depth_stencil_pipelines : blit_msaa_depth_pipelines;
-    const auto it = std::ranges::find(keys, key);
-    if (it != keys.end()) {
-        return *pipelines[std::distance(keys.begin(), it)];
-    }
-    keys.push_back(key);
-    const std::array stages =
-        MakeStages(*full_screen_vert,
-                   blit_stencil ? *blit_depth_stencil_msaa_frag : *blit_depth_msaa_frag);
-    const VkPipelineMultisampleStateCreateInfo multisample_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .rasterizationSamples = key.samples,
-        .sampleShadingEnable = VK_TRUE,
-        .minSampleShading = 1.0f,
-        .pSampleMask = nullptr,
-        .alphaToCoverageEnable = VK_FALSE,
-        .alphaToOneEnable = VK_FALSE,
-    };
-    const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
-    pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({
-        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .stageCount = static_cast<u32>(stages.size()),
-        .pStages = stages.data(),
-        .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
-        .pInputAssemblyState = &input_assembly_ci,
-        .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
-        .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
-        .pMultisampleState = &multisample_ci,
-        .pDepthStencilState = blit_stencil ? &PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
-                                           : &PIPELINE_DEPTH_ONLY_STATE_CREATE_INFO,
-        .pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_EMPTY_CREATE_INFO,
-        .pDynamicState = &PIPELINE_DYNAMIC_STATE_CREATE_INFO,
-        .layout = blit_stencil ? *two_textures_pipeline_layout : *one_texture_pipeline_layout,
-        .renderPass = key.renderpass,
-        .subpass = 0,
-        .basePipelineHandle = VK_NULL_HANDLE,
-        .basePipelineIndex = 0,
-    }));
-    return *pipelines.back();
-}
-
-VkPipeline BlitImageHelper::FindOrEmplaceBlitDepthPipeline(VkRenderPass renderpass) {
-    const auto it = std::ranges::find(blit_depth_keys, renderpass);
-    if (it != blit_depth_keys.end()) {
-        return *blit_depth_pipelines[std::distance(blit_depth_keys.begin(), it)];
-    }
-    blit_depth_keys.push_back(renderpass);
-    const std::array stages = MakeStages(*full_screen_vert, *blit_depth_frag);
-    const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci = GetPipelineInputAssemblyStateCreateInfo(device);
-    blit_depth_pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({
-        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .stageCount = static_cast<u32>(stages.size()),
-        .pStages = stages.data(),
-        .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
-        .pInputAssemblyState = &input_assembly_ci,
-        .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
-        .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
-        .pMultisampleState = &PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
-        .pDepthStencilState = &PIPELINE_DEPTH_ONLY_STATE_CREATE_INFO,
-        .pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_EMPTY_CREATE_INFO,
-        .pDynamicState = &PIPELINE_DYNAMIC_STATE_CREATE_INFO,
-        .layout = *one_texture_pipeline_layout,
-        .renderPass = renderpass,
-        .subpass = 0,
-        .basePipelineHandle = VK_NULL_HANDLE,
-        .basePipelineIndex = 0,
-    }));
-    return *blit_depth_pipelines.back();
-}
-
 VkPipeline BlitImageHelper::FindOrEmplaceResolveDepthStencilPipeline(VkRenderPass renderpass,
                                                                     bool resolve_stencil) {
    auto& keys = resolve_stencil ? resolve_depth_stencil_keys : resolve_depth_keys;
@@ -1588,83 +1417,15 @@ VkPipeline BlitImageHelper::FindOrEmplaceResolveDepthStencilPipeline(VkRenderPas
    return *pipelines.back();
 }

-void BlitImageHelper::CopyMSAADepth(RenderPassCache& render_pass_cache, VkImage dst_image,
-                                    VideoCore::Surface::PixelFormat dst_format, VkImage src_image,
-                                    VideoCore::Surface::PixelFormat src_format, u32 num_samples,
-                                    std::span<const VideoCommon::ImageCopy> copies,
-                                    bool copy_stencil, bool msaa_to_non_msaa) {
-    const auto [samples_x, samples_y] = VideoCommon::SamplesLog2(static_cast<int>(num_samples));
-    const s32 scale_x = 1 << samples_x;
-    const s32 scale_y = 1 << samples_y;
-    VkSampleCountFlagBits samples = SampleCountFlag(num_samples);
-    if (msaa_to_non_msaa) {
-        samples = VK_SAMPLE_COUNT_1_BIT;
-    }
-    RenderPassKey renderpass_key{};
-    renderpass_key.color_formats.fill(VideoCore::Surface::PixelFormat::Invalid);
-    renderpass_key.depth_format = dst_format;
-    renderpass_key.samples = samples;
-    const VkRenderPass renderpass = render_pass_cache.Get(renderpass_key);
-    const MSAACopyPipelineKey key{
-        .renderpass = renderpass,
-        .samples = samples,
-        .msaa_to_non_msaa = msaa_to_non_msaa,
-        .format_class = MSAACopyFormatClass::Float,
-    };
-    VkImageAspectFlags attachment_aspect = VK_IMAGE_ASPECT_DEPTH_BIT;
-    if (VideoCore::Surface::GetFormatType(dst_format) ==
-        VideoCore::Surface::SurfaceType::DepthStencil) {
-        attachment_aspect |= VK_IMAGE_ASPECT_STENCIL_BIT;
-    }
-    VkPipelineLayout layout = *msaa_copy_pipeline_layout;
-    if (copy_stencil) {
-        layout = *msaa_copy_depth_stencil_pipeline_layout;
-    }
-    const MSAACopyAspectInfo aspect_info{
-        .src_view_aspect = VK_IMAGE_ASPECT_DEPTH_BIT,
-        .attachment_aspect = attachment_aspect,
-        .barrier_aspect = attachment_aspect,
-        .pre_src_access =
-            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
-        .pre_src_dst_access = VK_ACCESS_SHADER_READ_BIT,
-        .pre_dst_dst_access = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
-                              VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-        .pre_src_stages = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
-                          VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
-                          VK_PIPELINE_STAGE_TRANSFER_BIT,
-        .pre_dst_stages =
-            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
-        .post_src_access = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-        .post_dst_access = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT |
-                           VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
-        .post_src_stages = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-        .post_dst_stages = vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER,
-    };
-    const VkFormat src_vk_format =
-        MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, true, src_format).format;
-    const VkFormat dst_vk_format =
-        MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, true, dst_format).format;
-    CopyMSAAImpl(renderpass, FindOrEmplaceMSAACopyDepthPipeline(key, copy_stencil), layout,
-                 dst_image, dst_vk_format, src_image, src_vk_format, scale_x, scale_y, copies,
-                 aspect_info, copy_stencil);
-}
-
 VkPipeline BlitImageHelper::FindOrEmplaceMSAACopyPipeline(const MSAACopyPipelineKey& key) {
    const auto it = std::ranges::find(msaa_copy_keys, key);
    if (it != msaa_copy_keys.end()) {
        return *msaa_copy_pipelines[std::distance(msaa_copy_keys.begin(), it)];
    }
    msaa_copy_keys.push_back(key);
-    VkShaderModule frag_module = key.msaa_to_non_msaa ? *convert_msaa_to_non_msaa_frag
-                                                     : *convert_non_msaa_to_msaa_frag;
-    if (key.format_class == MSAACopyFormatClass::SignedInteger) {
-        frag_module = key.msaa_to_non_msaa ? *convert_msaa_to_non_msaa_sint_frag
-                                           : *convert_non_msaa_to_msaa_sint_frag;
-    } else if (key.format_class == MSAACopyFormatClass::UnsignedInteger) {
-        frag_module = key.msaa_to_non_msaa ? *convert_msaa_to_non_msaa_uint_frag
-                                           : *convert_non_msaa_to_msaa_uint_frag;
-    }
-    const std::array stages = MakeStages(*clear_color_vert, frag_module);
+    const std::array stages = MakeStages(*clear_color_vert, key.msaa_to_non_msaa
+                                                                ? *convert_msaa_to_non_msaa_frag
+                                                                : *convert_non_msaa_to_msaa_frag);
    const VkPipelineMultisampleStateCreateInfo multisample_ci{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
        .pNext = nullptr,
@@ -1701,85 +1462,6 @@ VkPipeline BlitImageHelper::FindOrEmplaceMSAACopyPipeline(const MSAACopyPipeline
    return *msaa_copy_pipelines.back();
 }

-VkPipeline BlitImageHelper::FindOrEmplaceMSAACopyDepthPipeline(const MSAACopyPipelineKey& key,
-                                                               bool copy_stencil) {
-    auto& keys = copy_stencil ? msaa_copy_depth_stencil_keys : msaa_copy_depth_keys;
-    auto& pipelines = copy_stencil ? msaa_copy_depth_stencil_pipelines : msaa_copy_depth_pipelines;
-    const auto it = std::ranges::find(keys, key);
-    if (it != keys.end()) {
-        return *pipelines[std::distance(keys.begin(), it)];
-    }
-    keys.push_back(key);
-    VkShaderModule frag_module;
-    if (key.msaa_to_non_msaa) {
-        frag_module = copy_stencil ? *convert_msaa_to_non_msaa_depth_stencil_frag
-                                   : *convert_msaa_to_non_msaa_depth_frag;
-    } else {
-        frag_module = copy_stencil ? *convert_non_msaa_to_msaa_depth_stencil_frag
-                                   : *convert_non_msaa_to_msaa_depth_frag;
-    }
-    const std::array stages = MakeStages(*clear_color_vert, frag_module);
-    const VkPipelineMultisampleStateCreateInfo multisample_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .rasterizationSamples = key.samples,
-        .sampleShadingEnable = key.msaa_to_non_msaa ? VK_FALSE : VK_TRUE,
-        .minSampleShading = key.msaa_to_non_msaa ? 0.0f : 1.0f,
-        .pSampleMask = nullptr,
-        .alphaToCoverageEnable = VK_FALSE,
-        .alphaToOneEnable = VK_FALSE,
-    };
-    static constexpr VkStencilOpState REPLACE_STENCIL_OP{
-        .failOp = VK_STENCIL_OP_REPLACE,
-        .passOp = VK_STENCIL_OP_REPLACE,
-        .depthFailOp = VK_STENCIL_OP_REPLACE,
-        .compareOp = VK_COMPARE_OP_ALWAYS,
-        .compareMask = 0xFF,
-        .writeMask = 0xFF,
-        .reference = 0,
-    };
-    const VkPipelineDepthStencilStateCreateInfo depth_stencil_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .depthTestEnable = VK_TRUE,
-        .depthWriteEnable = VK_TRUE,
-        .depthCompareOp = VK_COMPARE_OP_ALWAYS,
-        .depthBoundsTestEnable = VK_FALSE,
-        .stencilTestEnable = copy_stencil ? VK_TRUE : VK_FALSE,
-        .front = copy_stencil ? REPLACE_STENCIL_OP : VkStencilOpState{},
-        .back = copy_stencil ? REPLACE_STENCIL_OP : VkStencilOpState{},
-        .minDepthBounds = 0.0f,
-        .maxDepthBounds = 0.0f,
-    };
-    const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci =
-        GetPipelineInputAssemblyStateCreateInfo(device);
-    pipelines.push_back(device.GetLogical().CreateGraphicsPipeline({
-        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .stageCount = static_cast<u32>(stages.size()),
-        .pStages = stages.data(),
-        .pVertexInputState = &PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
-        .pInputAssemblyState = &input_assembly_ci,
-        .pTessellationState = nullptr,
-        .pViewportState = &PIPELINE_VIEWPORT_STATE_CREATE_INFO,
-        .pRasterizationState = &PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
-        .pMultisampleState = &multisample_ci,
-        .pDepthStencilState = &depth_stencil_ci,
-        .pColorBlendState = &PIPELINE_COLOR_BLEND_STATE_EMPTY_CREATE_INFO,
-        .pDynamicState = &PIPELINE_DYNAMIC_STATE_CREATE_INFO,
-        .layout = copy_stencil ? *msaa_copy_depth_stencil_pipeline_layout
-                               : *msaa_copy_pipeline_layout,
-        .renderPass = key.renderpass,
-        .subpass = 0,
-        .basePipelineHandle = VK_NULL_HANDLE,
-        .basePipelineIndex = 0,
-    }));
-    return *pipelines.back();
-}
-
 void BlitImageHelper::ConvertDepthToColorPipeline(vk::Pipeline& pipeline, VkRenderPass renderpass) {
    ConvertPipeline(pipeline, renderpass, false);
 }
@@ -45,19 +45,12 @@ struct BlitDepthStencilPipelineKey {
    u32 stencil_ref;
 };

-enum class MSAACopyFormatClass : u32 {
-    Float,
-    SignedInteger,
-    UnsignedInteger,
-};
-
 struct MSAACopyPipelineKey {
    constexpr auto operator<=>(const MSAACopyPipelineKey&) const noexcept = default;

    VkRenderPass renderpass;
    VkSampleCountFlagBits samples;
    bool msaa_to_non_msaa;
-    MSAACopyFormatClass format_class;
 };

 struct BlitMSAAPipelineKey {
@@ -85,12 +78,6 @@ public:
    void BlitColorMSAA(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,
                       const Region2D& dst_region, const Region2D& src_region);

-    void BlitDepthStencilMSAA(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
-                              const Region2D& dst_region, const Region2D& src_region);
-
-    void BlitDepth(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
-                   const Region2D& dst_region, const Region2D& src_region);
-
    void ResolveDepthStencil(const Framebuffer* dst_framebuffer, ImageView& src_image_view,
                             const Region2D& dst_region, const Region2D& src_region);

@@ -129,39 +116,7 @@ public:
                  VideoCore::Surface::PixelFormat src_format, u32 num_samples,
                  std::span<const VideoCommon::ImageCopy> copies, bool msaa_to_non_msaa);

-    void CopyMSAADepth(RenderPassCache& render_pass_cache, VkImage dst_image,
-                       VideoCore::Surface::PixelFormat dst_format, VkImage src_image,
-                       VideoCore::Surface::PixelFormat src_format, u32 num_samples,
-                       std::span<const VideoCommon::ImageCopy> copies, bool copy_stencil,
-                       bool msaa_to_non_msaa);
-
 private:
-    struct MSAACopyAspectInfo {
-        VkImageAspectFlags src_view_aspect;
-        VkImageAspectFlags attachment_aspect;
-        VkImageAspectFlags barrier_aspect;
-        VkAccessFlags pre_src_access;
-        VkAccessFlags pre_src_dst_access;
-        VkAccessFlags pre_dst_dst_access;
-        VkPipelineStageFlags pre_src_stages;
-        VkPipelineStageFlags pre_dst_stages;
-        VkAccessFlags post_src_access;
-        VkAccessFlags post_dst_access;
-        VkPipelineStageFlags post_src_stages;
-        VkPipelineStageFlags post_dst_stages;
-    };
-
-    void BlitImpl(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,
-                  const Region2D& dst_region, const Region2D& src_region, VkPipeline pipeline,
-                  VkSampler sampler, VkImageView src_view, VkImageView src_stencil_view,
-                  bool blit_stencil);
-
-    void CopyMSAAImpl(VkRenderPass renderpass, VkPipeline pipeline, VkPipelineLayout layout,
-                      VkImage dst_image, VkFormat dst_vk_format, VkImage src_image,
-                      VkFormat src_vk_format, s32 scale_x, s32 scale_y,
-                      std::span<const VideoCommon::ImageCopy> copies,
-                      const MSAACopyAspectInfo& aspect_info, bool copy_stencil);
-
    void Convert(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
                 const ImageView& src_image_view);

@@ -176,13 +131,7 @@ private:
    [[nodiscard]] VkPipeline FindOrEmplaceClearStencilPipeline(
        const BlitDepthStencilPipelineKey& key);
    [[nodiscard]] VkPipeline FindOrEmplaceMSAACopyPipeline(const MSAACopyPipelineKey& key);
-
-    [[nodiscard]] VkPipeline FindOrEmplaceMSAACopyDepthPipeline(const MSAACopyPipelineKey& key,
-                                                                bool copy_stencil);
    [[nodiscard]] VkPipeline FindOrEmplaceBlitColorMSAAPipeline(const BlitMSAAPipelineKey& key);
-    [[nodiscard]] VkPipeline FindOrEmplaceBlitDepthStencilMSAAPipeline(
-        const BlitMSAAPipelineKey& key, bool blit_stencil);
-    [[nodiscard]] VkPipeline FindOrEmplaceBlitDepthPipeline(VkRenderPass renderpass);
    [[nodiscard]] VkPipeline FindOrEmplaceResolveDepthStencilPipeline(VkRenderPass renderpass,
                                                                      bool resolve_stencil);

@@ -213,12 +162,10 @@ private:
    vk::PipelineLayout two_textures_pipeline_layout;
    vk::PipelineLayout clear_color_pipeline_layout;
    vk::PipelineLayout msaa_copy_pipeline_layout;
-    vk::PipelineLayout msaa_copy_depth_stencil_pipeline_layout;
    vk::ShaderModule full_screen_vert;
    vk::ShaderModule blit_color_to_color_frag;
    vk::ShaderModule blit_color_msaa_frag;
    vk::ShaderModule blit_depth_stencil_frag;
-    vk::ShaderModule blit_depth_frag;
    vk::ShaderModule blit_depth_msaa_frag;
    vk::ShaderModule blit_depth_stencil_msaa_frag;
    vk::ShaderModule clear_color_vert;
@@ -232,15 +179,7 @@ private:
    vk::ShaderModule convert_d24s8_to_abgr8_frag;
    vk::ShaderModule convert_s8d24_to_abgr8_frag;
    vk::ShaderModule convert_msaa_to_non_msaa_frag;
-    vk::ShaderModule convert_msaa_to_non_msaa_sint_frag;
-    vk::ShaderModule convert_msaa_to_non_msaa_uint_frag;
-    vk::ShaderModule convert_msaa_to_non_msaa_depth_frag;
-    vk::ShaderModule convert_msaa_to_non_msaa_depth_stencil_frag;
    vk::ShaderModule convert_non_msaa_to_msaa_frag;
-    vk::ShaderModule convert_non_msaa_to_msaa_sint_frag;
-    vk::ShaderModule convert_non_msaa_to_msaa_uint_frag;
-    vk::ShaderModule convert_non_msaa_to_msaa_depth_frag;
-    vk::ShaderModule convert_non_msaa_to_msaa_depth_stencil_frag;
    vk::Sampler linear_sampler;
    vk::Sampler nearest_sampler;

@@ -254,18 +193,8 @@ private:
    std::vector<vk::Pipeline> clear_stencil_pipelines;
    std::vector<MSAACopyPipelineKey> msaa_copy_keys;
    std::vector<vk::Pipeline> msaa_copy_pipelines;
-    std::vector<MSAACopyPipelineKey> msaa_copy_depth_keys;
-    std::vector<vk::Pipeline> msaa_copy_depth_pipelines;
-    std::vector<MSAACopyPipelineKey> msaa_copy_depth_stencil_keys;
-    std::vector<vk::Pipeline> msaa_copy_depth_stencil_pipelines;
    std::vector<BlitMSAAPipelineKey> blit_msaa_color_keys;
    std::vector<vk::Pipeline> blit_msaa_color_pipelines;
-    std::vector<VkRenderPass> blit_depth_keys;
-    std::vector<vk::Pipeline> blit_depth_pipelines;
-    std::vector<BlitMSAAPipelineKey> blit_msaa_depth_keys;
-    std::vector<vk::Pipeline> blit_msaa_depth_pipelines;
-    std::vector<BlitMSAAPipelineKey> blit_msaa_depth_stencil_keys;
-    std::vector<vk::Pipeline> blit_msaa_depth_stencil_pipelines;
    std::vector<VkRenderPass> resolve_depth_keys;
    std::vector<vk::Pipeline> resolve_depth_pipelines;
    std::vector<VkRenderPass> resolve_depth_stencil_keys;
@@ -370,9 +370,20 @@ inline void PushImageDescriptors(TextureCache& texture_cache,
                const VkImageView null_image_view{texture_cache.GetImageView(VideoCommon::NULL_IMAGE_VIEW_ID).Handle(desc.type)};
                if (null_image_view != VK_NULL_HANDLE) vk_image_view = null_image_view;
            }
-            Sampler& sampler{texture_cache.GetSampler(sampler_id)};
-            guest_descriptor_queue.AddSampledImage(vk_image_view,
-                                                   sampler.HandleFor(image_view, desc.is_depth));
+            const Sampler& sampler{texture_cache.GetSampler(sampler_id)};
+            const bool use_fallback_sampler{sampler.HasAddedAnisotropy() &&
+                                            !image_view.SupportsAnisotropy()};
+            VkSampler vk_sampler{use_fallback_sampler ? sampler.HandleWithDefaultAnisotropy()
+                                                      : sampler.Handle()};
+            if (sampler.HasLinearFiltering() &&
+                VideoCore::Surface::IsPixelFormatInteger(image_view.format)) {
+                vk_sampler = sampler.HandleWithNearestFilter();
+            }
+            if (desc.is_depth && sampler.HasDepthComparison() &&
+                !image_view.SupportsDepthComparison()) {
+                vk_sampler = sampler.HandleWithoutDepthComparison();
+            }
+            guest_descriptor_queue.AddSampledImage(vk_image_view, vk_sampler);
            const bool element_rescaled{texture_cache.IsRescaling(image_view)};
            is_rescaled |= element_rescaled;
        }
@@ -1,8 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

-#include <algorithm>
-
 #include "common/common_types.h"
 #include "common/div_ceil.h"
 #include "common/settings.h"
@@ -19,7 +17,7 @@

 namespace Vulkan {

-using PushConstants = std::array<u32, 4 + 2 + 2 + 1>;
+using PushConstants = std::array<u32, 4 + 2 + 1>;

 SGSR::SGSR(const Device& device, MemoryAllocator& memory_allocator, size_t image_count, VkExtent2D extent, bool edge_dir)
    : m_memory_allocator{memory_allocator}
@@ -102,28 +100,26 @@ VkImageView SGSR::Draw(const Device& device, Scheduler& scheduler, size_t image_

    const f32 input_image_width = f32(input_image_extent.width);
    const f32 input_image_height = f32(input_image_extent.height);
-    const f32 crop_width = (crop_rect.right - crop_rect.left) * input_image_width;
-    const f32 crop_height = (crop_rect.bottom - crop_rect.top) * input_image_height;
-    static constexpr f32 EDGE_SHARPNESS_MAX = 2.0f;
-    const f32 edge_sharpness =
-        EDGE_SHARPNESS_MAX - f32(Settings::values.fsr_sharpening_slider.GetValue()) / 200.0f;
+    const f32 viewport_width = (crop_rect.right - crop_rect.left) * input_image_width;
+    const f32 viewport_height = (crop_rect.bottom - crop_rect.top) * input_image_height;
+    // expected [0, 2]
+    const f32 sharpening = f32(Settings::values.fsr_sharpening_slider.GetValue()) / 100.0f;

+    // p = (tex * viewport) / input = [0,n] (normalized texcoords)
+    // p * input = [0,1024], [0,768]
    // layout( push_constant ) uniform constants {
    //     highp vec4 ViewportInfo[1];
    //     highp vec2 ResizeFactor;
-    //     highp vec2 CropOffset;
    //     highp float EdgeSharpness;
    // };
    PushConstants viewport_con{};
-    viewport_con[0] = std::bit_cast<u32>(1.f / input_image_width);
-    viewport_con[1] = std::bit_cast<u32>(1.f / input_image_height);
-    viewport_con[2] = std::bit_cast<u32>(input_image_width);
-    viewport_con[3] = std::bit_cast<u32>(input_image_height);
-    viewport_con[4] = std::bit_cast<u32>(crop_width / input_image_width);
-    viewport_con[5] = std::bit_cast<u32>(crop_height / input_image_height);
-    viewport_con[6] = std::bit_cast<u32>((std::min)(crop_rect.left, crop_rect.right));
-    viewport_con[7] = std::bit_cast<u32>((std::min)(crop_rect.top, crop_rect.bottom));
-    viewport_con[8] = std::bit_cast<u32>(edge_sharpness);
+    viewport_con[0] = std::bit_cast<u32>(std::abs(1.f / viewport_width));
+    viewport_con[1] = std::bit_cast<u32>(std::abs(1.f / viewport_height));
+    viewport_con[2] = std::bit_cast<u32>(std::abs(viewport_width));
+    viewport_con[3] = std::bit_cast<u32>(std::abs(viewport_height));
+    viewport_con[4] = std::bit_cast<u32>(viewport_width / input_image_width);
+    viewport_con[5] = std::bit_cast<u32>(viewport_height / input_image_height);
+    viewport_con[6] = std::bit_cast<u32>(sharpening);

    UploadImages(device, scheduler);
    UpdateDescriptorSets(device, source_image_view, image_index);
@@ -7,9 +7,7 @@
 #include <algorithm>
 #include <array>
 #include <cstring>
-#include <limits>
 #include <span>
-#include <utility>
 #include <vector>

 #include "video_core/buffer_cache/buffer_cache_base.h"
@@ -34,32 +32,6 @@ VkBufferCopy MakeBufferCopy(const VideoCommon::BufferCopy& copy) {
    };
 }

-constexpr size_t MAX_WINDOW_BARRIER_RANGES = 8;
-
-using WindowRange = std::pair<VkDeviceSize, VkDeviceSize>;
-using WindowRanges = boost::container::small_vector<WindowRange, MAX_WINDOW_BARRIER_RANGES>;
-
-void CoalesceWindowRanges(WindowRanges& ranges) {
-    if (ranges.size() < 2) {
-        return;
-    }
-    std::sort(ranges.begin(), ranges.end());
-    size_t merged = 0;
-    for (size_t index = 1; index < ranges.size(); ++index) {
-        if (ranges[index].first <= ranges[merged].second) {
-            ranges[merged].second = (std::max)(ranges[merged].second, ranges[index].second);
-        } else {
-            ranges[++merged] = ranges[index];
-        }
-    }
-    ranges.resize(merged + 1);
-    if (ranges.size() > MAX_WINDOW_BARRIER_RANGES) {
-        const WindowRange bounding{ranges.front().first, ranges.back().second};
-        ranges.clear();
-        ranges.push_back(bounding);
-    }
-}
-
 VkIndexType IndexTypeFromNumElements(const Device& device, u32 num_elements) {
    if (num_elements <= 0xff && device.IsExtIndexTypeUint8Supported()) {
        return VK_INDEX_TYPE_UINT8_EXT;
@@ -70,16 +42,6 @@ VkIndexType IndexTypeFromNumElements(const Device& device, u32 num_elements) {
    return VK_INDEX_TYPE_UINT32;
 }

-u32 GrowIndexCount(u32 current, u32 requested) {
-    constexpr u32 MinimumIndices = 4096;
-    constexpr u32 GrowthLimit = (std::numeric_limits<u32>::max)() / 2;
-    u32 grown = (std::max)(requested, MinimumIndices);
-    if (current <= GrowthLimit) {
-        grown = (std::max)(grown, current * 2);
-    }
-    return grown;
-}
-
 size_t BytesPerIndex(VkIndexType index_type) {
    switch (index_type) {
    case VK_INDEX_TYPE_UINT8_EXT:
@@ -196,12 +158,13 @@ public:
    virtual ~QuadIndexBuffer() = default;

    void UpdateBuffer(u32 num_indices_) {
-        ReleaseRetiredBuffers();
        if (num_indices_ <= num_indices) {
            return;
        }

-        num_indices = GrowIndexCount(num_indices, num_indices_);
+        scheduler.Finish();
+
+        num_indices = num_indices_;
        index_type = IndexTypeFromNumElements(device, num_indices);

        const u32 num_quads = GetQuadsNum(num_indices);
@@ -219,12 +182,6 @@ public:
            .queueFamilyIndexCount = 0,
            .pQueueFamilyIndices = nullptr,
        };
-        if (buffer) {
-            retired_buffers.push_back(RetiredBuffer{
-                .buffer = std::move(buffer),
-                .tick = scheduler.CurrentTick(),
-            });
-        }
        buffer = memory_allocator.CreateBuffer(buffer_ci, MemoryUsage::DeviceLocal);
        if (device.HasDebuggingToolAttached()) {
            buffer.SetObjectNameEXT("Quad LUT");
@@ -292,17 +249,6 @@ protected:

    virtual void MakeAndUpdateIndices(u8* staging_data, size_t quad_size, u32 quad, u32 first) = 0;

-    struct RetiredBuffer {
-        vk::Buffer buffer;
-        u64 tick;
-    };
-
-    void ReleaseRetiredBuffers() {
-        std::erase_if(retired_buffers, [this](const RetiredBuffer& entry) {
-            return scheduler.IsFree(entry.tick);
-        });
-    }
-
    const Device& device;
    MemoryAllocator& memory_allocator;
    Scheduler& scheduler;
@@ -310,7 +256,6 @@ protected:

    vk::Buffer buffer{};
    MemoryCommit memory_commit{};
-    std::vector<RetiredBuffer> retired_buffers;
    VkIndexType index_type{};
    u32 num_indices = 0;
 };
@@ -420,138 +365,6 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
                                                                     scheduler_, staging_pool_);
 }

-void BufferCacheRuntime::TryEnableUnifiedMemory(void* base, size_t size,
-                                                std::span<AHardwareBuffer* const> hardware_buffers,
-                                                size_t hardware_buffer_window,
-                                                size_t hardware_buffer_base) {
-    unified_memory = memory_allocator.CreateHostMemoryImport(
-        base, size, hardware_buffers, hardware_buffer_window, hardware_buffer_base);
-}
-
-void BufferCacheRuntime::CopyToUnifiedMemory(
-    size_t window_index, VkBuffer src_buffer,
-    std::span<const VideoCommon::BufferCopy> copies) {
-    if (!unified_memory || src_buffer == VK_NULL_HANDLE || copies.empty() ||
-        window_index >= unified_memory->GetWindowCount() ||
-        unified_memory->GetWindowBuffer(window_index) == VK_NULL_HANDLE) {
-        return;
-    }
-    PendingUnifiedCopy& pending = pending_unified_copies.emplace_back();
-    pending.window = window_index;
-    pending.buffer = src_buffer;
-    pending.copies.resize(copies.size());
-    std::ranges::transform(copies, pending.copies.begin(), MakeBufferCopy);
-}
-
-void BufferCacheRuntime::FlushUnifiedMemoryCopies() {
-    if (pending_unified_copies.empty()) {
-        return;
-    }
-    struct UnifiedCopyCommand {
-        VkBuffer buffer;
-        boost::container::small_vector<VkBufferCopy, 8> copies;
-    };
-
-    std::stable_sort(pending_unified_copies.begin(), pending_unified_copies.end(),
-                     [](const PendingUnifiedCopy& lhs, const PendingUnifiedCopy& rhs) {
-                         return lhs.window < rhs.window;
-                     });
-
-    const bool foreign = unified_memory->NeedsForeignOwnershipTransfer();
-    const u32 queue_family = device.GetGraphicsFamily();
-
-    size_t group_begin = 0;
-    while (group_begin < pending_unified_copies.size()) {
-        const size_t window = pending_unified_copies[group_begin].window;
-        size_t group_end = group_begin;
-        while (group_end < pending_unified_copies.size() &&
-               pending_unified_copies[group_end].window == window) {
-            ++group_end;
-        }
-        const VkBuffer window_buffer = unified_memory->GetWindowBuffer(window);
-
-        WindowRanges ranges;
-        for (size_t index = group_begin; index < group_end; ++index) {
-            for (const VkBufferCopy& copy : pending_unified_copies[index].copies) {
-                ranges.emplace_back(copy.dstOffset, copy.dstOffset + copy.size);
-            }
-        }
-        CoalesceWindowRanges(ranges);
-
-        boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> acquire;
-        boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> release;
-        if (foreign) {
-            for (const WindowRange& range : ranges) {
-                acquire.push_back(VkBufferMemoryBarrier{
-                    .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-                    .pNext = nullptr,
-                    .srcAccessMask = 0,
-                    .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-                    .srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
-                    .dstQueueFamilyIndex = queue_family,
-                    .buffer = window_buffer,
-                    .offset = range.first,
-                    .size = range.second - range.first,
-                });
-                release.push_back(VkBufferMemoryBarrier{
-                    .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-                    .pNext = nullptr,
-                    .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-                    .dstAccessMask = 0,
-                    .srcQueueFamilyIndex = queue_family,
-                    .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
-                    .buffer = window_buffer,
-                    .offset = range.first,
-                    .size = range.second - range.first,
-                });
-            }
-        }
-
-        boost::container::small_vector<UnifiedCopyCommand, 4> commands;
-        commands.reserve(group_end - group_begin);
-        for (size_t index = group_begin; index < group_end; ++index) {
-            PendingUnifiedCopy& pending = pending_unified_copies[index];
-            commands.push_back(UnifiedCopyCommand{pending.buffer, std::move(pending.copies)});
-        }
-
-        scheduler.RequestOutsideRenderPassOperationContext();
-        scheduler.Record([window_buffer, acquire = std::move(acquire), release = std::move(release),
-                          commands = std::move(commands)](vk::CommandBuffer cmdbuf) {
-            if (!acquire.empty()) {
-                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                                       VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {},
-                                       VideoCommon::FixSmallVectorADL(acquire), {});
-            }
-            for (const UnifiedCopyCommand& command : commands) {
-                cmdbuf.CopyBuffer(command.buffer, window_buffer,
-                                  VideoCommon::FixSmallVectorADL(command.copies));
-            }
-            if (!release.empty()) {
-                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                       VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, {},
-                                       VideoCommon::FixSmallVectorADL(release), {});
-            }
-        });
-
-        group_begin = group_end;
-    }
-    pending_unified_copies.clear();
-}
-
-void BufferCacheRuntime::UnifiedMemoryHostBarrier() {
-    static constexpr VkMemoryBarrier HOST_BARRIER{
-        .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
-        .pNext = nullptr,
-        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-        .dstAccessMask = VK_ACCESS_HOST_READ_BIT,
-    };
-    scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([](vk::CommandBuffer cmdbuf) {
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0,
-                               HOST_BARRIER);
-    });
-}
-
 StagingBufferRef BufferCacheRuntime::UploadStagingBuffer(size_t size) {
    return staging_pool.Request(size, MemoryUsage::Upload);
 }
@@ -589,7 +402,6 @@ u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
 }

 void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept {
-    FlushUnifiedMemoryCopies();
    for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
        if (scheduler.IsFree(it->LastUsageTick())) {
            it->ResetUsageTracking();
@@ -7,10 +7,6 @@
 #pragma once

 #include <limits>
-#include <memory>
-#include <span>
-
-#include <boost/container/small_vector.hpp>

 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/buffer_cache/memory_tracker_base.h"
@@ -101,33 +97,6 @@ public:

    void TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept;

-    void TryEnableUnifiedMemory(void* base, size_t size,
-                                std::span<AHardwareBuffer* const> hardware_buffers,
-                                size_t hardware_buffer_window, size_t hardware_buffer_base);
-
-    [[nodiscard]] bool HasUnifiedMemory() const noexcept {
-        return unified_memory != nullptr && unified_memory->IsValid();
-    }
-
-    [[nodiscard]] u64 UnifiedMemorySize() const noexcept {
-        return unified_memory ? unified_memory->GetSize() : 0;
-    }
-
-    [[nodiscard]] u64 UnifiedMemoryBase() const noexcept {
-        return unified_memory ? unified_memory->GetBaseOffset() : 0;
-    }
-
-    [[nodiscard]] u64 UnifiedMemoryWindowSize() const noexcept {
-        return unified_memory ? unified_memory->GetWindowSize() : 0;
-    }
-
-    void CopyToUnifiedMemory(size_t window_index, VkBuffer src_buffer,
-                             std::span<const VideoCommon::BufferCopy> copies);
-
-    void FlushUnifiedMemoryCopies();
-
-    void UnifiedMemoryHostBarrier();
-
    u64 CurrentTick();

    u64 KnownGpuTick();
@@ -195,29 +164,6 @@ public:
        BindBuffer(buffer, offset, size);
    }

-    void BindStorageBuffer(VkBuffer buffer, VkDeviceAddress address, u32 offset, u32 size,
-                           [[maybe_unused]] bool is_written) {
-        guest_descriptor_queue.AddBuffer(buffer, address, offset, size);
-    }
-
-    [[nodiscard]] bool IsUnifiedMemoryBindable() const noexcept {
-        return unified_memory != nullptr && unified_memory->IsValid() &&
-               unified_memory->IsBindable();
-    }
-
-    [[nodiscard]] VkBuffer UnifiedWindowBuffer(size_t index) const noexcept {
-        return unified_memory->GetWindowBuffer(index);
-    }
-
-    [[nodiscard]] VkDeviceAddress UnifiedWindowAddress(size_t index) const noexcept {
-        return unified_memory->GetWindowAddress(index);
-    }
-
-    [[nodiscard]] bool IsUnifiedStorageRange(u32 size, u64 offset) const {
-        return size <= device.GetMaxStorageBufferRange() &&
-               (offset % device.GetStorageBufferAlignment()) == 0;
-    }
-
    void BindTextureBuffer(Buffer& buffer, u32 offset, u32 size,
                           VideoCore::Surface::PixelFormat format) {
        guest_descriptor_queue.AddTexelBuffer(buffer.View(offset, size, format),
@@ -234,12 +180,6 @@ public:
    }

 private:
-    struct PendingUnifiedCopy {
-        size_t window;
-        VkBuffer buffer;
-        boost::container::small_vector<VkBufferCopy, 8> copies;
-    };
-
    void BindBuffer(const Buffer& buffer, u32 offset, u32 size) {
        const VkBuffer handle = buffer.Handle();
        if (handle == VK_NULL_HANDLE) {
@@ -264,8 +204,6 @@ private:
    std::shared_ptr<QuadStripIndexBuffer> quad_strip_index_buffer;

    vk::Buffer null_buffer;
-    HostMemoryImport* unified_memory{};
-    boost::container::small_vector<PendingUnifiedCopy, 8> pending_unified_copies;

    std::unique_ptr<Uint8Pass> uint8_pass;
    QuadIndexedPass quad_index_pass;
@@ -288,7 +226,6 @@ struct BufferCacheParams {
    static constexpr bool USE_MEMORY_MAPS = true;
    static constexpr bool SEPARATE_IMAGE_BUFFER_BINDINGS = false;
    static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = true;
-    static constexpr bool USE_UNIFIED_MEMORY = true;
 };

 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;
@@ -4,7 +4,6 @@
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#include <algorithm>
 #include <array>
 #include <memory>
 #include <numeric>
@@ -13,7 +12,6 @@

 #include "video_core/renderer_vulkan/vk_texture_cache.h"

-#include "common/alignment.h"
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/div_ceil.h"
@@ -24,9 +22,7 @@
 #include "video_core/host_shaders/resolve_conditional_render_comp_spv.h"
 #include "video_core/host_shaders/vulkan_quad_indexed_comp_spv.h"
 #include "video_core/host_shaders/vulkan_uint8_comp_spv.h"
-#include "video_core/host_shaders/block_linear_unswizzle_2d_buffer_comp_spv.h"
 #include "video_core/host_shaders/block_linear_unswizzle_3d_bcn_comp_spv.h"
-#include "video_core/host_shaders/block_linear_unswizzle_3d_buffer_comp_spv.h"
 #include "video_core/renderer_vulkan/vk_compute_pass.h"
 #include "video_core/surface.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
@@ -876,537 +872,4 @@ void BlockLinearUnswizzle3DPass::UnswizzleChunk(
    });
 }

-namespace {
-constexpr u32 BL2D_BINDING_INPUT_BUFFER = 0;
-constexpr u32 BL2D_BINDING_OUTPUT_BUFFER = 1;
-
-struct alignas(16) BlockLinearUnswizzle2DPushConstants {
-    std::array<u32, 3> dim;
-    u32 bytes_per_block_log2;
-    std::array<u32, 3> origin;
-    u32 layer_stride;
-    u32 block_size;
-    u32 x_shift;
-    u32 block_height;
-    u32 block_height_mask;
-};
-static_assert(sizeof(BlockLinearUnswizzle2DPushConstants) <= 128);
-
-constexpr std::array<VkDescriptorSetLayoutBinding, 2> BL2D_BINDINGS{{
-    {
-        .binding = BL2D_BINDING_INPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-    {
-        .binding = BL2D_BINDING_OUTPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-}};
-
-constexpr std::array<VkDescriptorUpdateTemplateEntry, 2> BL2D_TEMPLATE{{
-    {
-        .dstBinding = BL2D_BINDING_INPUT_BUFFER,
-        .dstArrayElement = 0,
-        .descriptorCount = 1,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .offset = BL2D_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-        .stride = sizeof(DescriptorUpdateEntry),
-    },
-    {
-        .dstBinding = BL2D_BINDING_OUTPUT_BUFFER,
-        .dstArrayElement = 0,
-        .descriptorCount = 1,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .offset = BL2D_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-        .stride = sizeof(DescriptorUpdateEntry),
-    },
-}};
-
-constexpr DescriptorBankInfo BL2D_BANK_INFO{
-    .uniform_buffers = 0,
-    .storage_buffers = 2,
-    .texture_buffers = 0,
-    .image_buffers = 0,
-    .textures = 0,
-    .images = 0,
-    .score = 2,
-};
-} // Anonymous namespace
-
-BlockLinearUnswizzle2DPass::BlockLinearUnswizzle2DPass(
-    const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
-    StagingBufferPool& staging_buffer_pool_,
-    ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
-    : ComputePass(device_, scheduler_, descriptor_pool_, BL2D_BINDINGS, BL2D_TEMPLATE,
-                  BL2D_BANK_INFO,
-                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinearUnswizzle2DPushConstants)>,
-                  BLOCK_LINEAR_UNSWIZZLE_2D_BUFFER_COMP_SPV),
-      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
-      compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
-
-BlockLinearUnswizzle2DPass::~BlockLinearUnswizzle2DPass() = default;
-
-bool BlockLinearUnswizzle2DPass::IsSupported(const Device& device,
-                                             const VideoCommon::ImageInfo& info) {
-    if (info.type != VideoCommon::ImageType::e2D) {
-        return false;
-    }
-    if (info.num_samples > 1) {
-        return false;
-    }
-    if (device.GetStorageBufferAlignment() > Tegra::Texture::GOB_SIZE) {
-        return false;
-    }
-    if (VideoCore::Surface::GetFormatType(info.format) !=
-        VideoCore::Surface::SurfaceType::ColorTexture) {
-        return false;
-    }
-    if (VideoCore::Surface::IsPixelFormatASTC(info.format) && !device.IsOptimalAstcSupported()) {
-        return false;
-    }
-    if (VideoCore::Surface::IsPixelFormatBCn(info.format) && !device.IsOptimalBcnSupported()) {
-        return false;
-    }
-    const u32 bytes_per_block = VideoCore::Surface::BytesPerBlock(info.format);
-    return bytes_per_block == 4 || bytes_per_block == 8 || bytes_per_block == 16;
-}
-
-void BlockLinearUnswizzle2DPass::Unswizzle(
-    Image& image, const StagingBufferRef& swizzled,
-    std::span<const VideoCommon::SwizzleParameters> swizzles) {
-    UnswizzleFrom(image, swizzled.buffer, swizzled.offset, swizzles);
-}
-
-void BlockLinearUnswizzle2DPass::UnswizzleFrom(
-    Image& image, VkBuffer source_buffer, VkDeviceSize source_offset,
-    std::span<const VideoCommon::SwizzleParameters> swizzles) {
-    const VkImage dst_image = image.Handle();
-    if (swizzles.empty() || source_buffer == VK_NULL_HANDLE || dst_image == VK_NULL_HANDLE) {
-        return;
-    }
-    const u32 layers = image.info.resources.layers;
-    const VkImageAspectFlags aspect = image.AspectMask();
-
-    const VkDeviceSize output_alignment =
-        (std::max)(device.GetStorageBufferAlignment(), VkDeviceSize{16});
-    VkDeviceSize total_output = 0;
-    for (const VideoCommon::SwizzleParameters& sw : swizzles) {
-        const auto params =
-            VideoCommon::Accelerated::MakeBlockLinearSwizzle2DParams(sw, image.info);
-        const VkDeviceSize level_size = static_cast<VkDeviceSize>(sw.num_tiles.width) *
-                                        sw.num_tiles.height * layers *
-                                        (1ULL << params.bytes_per_block_log2);
-        if (level_size == 0) {
-            continue;
-        }
-        total_output = Common::AlignUp(total_output, output_alignment) + level_size;
-    }
-    if (total_output == 0) {
-        return;
-    }
-    const StagingBufferRef output =
-        staging_buffer_pool.Request(static_cast<size_t>(total_output), MemoryUsage::DeviceLocal);
-    const VkBuffer out_buffer = output.buffer;
-    if (out_buffer == VK_NULL_HANDLE) {
-        return;
-    }
-    VkDeviceSize level_offset = 0;
-
-    scheduler.RequestOutsideRenderPassOperationContext();
-
-    VkAccessFlags pre_access = VK_ACCESS_NONE;
-    VkImageLayout pre_layout = VK_IMAGE_LAYOUT_UNDEFINED;
-    VkPipelineStageFlags pre_stage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
-    if (image.ExchangeInitialization()) {
-        pre_access = VK_ACCESS_SHADER_READ_BIT;
-        pre_layout = VK_IMAGE_LAYOUT_GENERAL;
-        pre_stage = vk::PIPELINE_STAGE_GRAPHICS_COMPUTE;
-    }
-    scheduler.Record([dst_image, aspect, pre_access, pre_layout,
-                      pre_stage](vk::CommandBuffer cmdbuf) {
-        const VkImageMemoryBarrier barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = pre_access,
-            .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-            .oldLayout = pre_layout,
-            .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = dst_image,
-            .subresourceRange{
-                .aspectMask = aspect,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(pre_stage, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, {}, barrier);
-    });
-
-    for (const VideoCommon::SwizzleParameters& sw : swizzles) {
-        const auto params =
-            VideoCommon::Accelerated::MakeBlockLinearSwizzle2DParams(sw, image.info);
-        const u32 width = sw.num_tiles.width;
-        const u32 height = sw.num_tiles.height;
-        const u32 bytes_per_block = 1u << params.bytes_per_block_log2;
-        const VkDeviceSize output_size =
-            static_cast<VkDeviceSize>(width) * height * layers * bytes_per_block;
-        if (output_size == 0) {
-            continue;
-        }
-        const u32 level = static_cast<u32>(sw.level);
-        const u32 texel_width = (std::max)(1u, image.info.size.width >> level);
-        const u32 texel_height = (std::max)(1u, image.info.size.height >> level);
-
-        level_offset = Common::AlignUp(level_offset, output_alignment);
-        const VkDeviceSize out_offset = output.offset + level_offset;
-        level_offset += output_size;
-
-        BlockLinearUnswizzle2DPushConstants pc{};
-        pc.dim = {width, height, layers};
-        pc.bytes_per_block_log2 = params.bytes_per_block_log2;
-        pc.origin = params.origin;
-        pc.layer_stride = params.layer_stride;
-        pc.block_size = params.block_size;
-        pc.x_shift = params.x_shift;
-        pc.block_height = params.block_height;
-        pc.block_height_mask = params.block_height_mask;
-
-        compute_pass_descriptor_queue.Acquire(scheduler, 2);
-        compute_pass_descriptor_queue.AddBuffer(source_buffer, sw.buffer_offset + source_offset,
-                                                image.guest_size_bytes - sw.buffer_offset);
-        compute_pass_descriptor_queue.AddBuffer(out_buffer, out_offset, output_size);
-
-        const void* descriptor_data = compute_pass_descriptor_queue.UpdateData();
-        const VkDescriptorSet set = descriptor_allocator.Commit();
-
-        const u32 gx = Common::DivCeil(width, 16u);
-        const u32 gy = Common::DivCeil(height, 8u);
-
-        scheduler.Record([this, set, descriptor_data, pc, gx, gy, layers, output_size, out_buffer,
-                          out_offset, dst_image, aspect, texel_width, texel_height,
-                          level](vk::CommandBuffer cmdbuf) {
-            device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
-            cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
-            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
-            cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
-            cmdbuf.Dispatch(gx, gy, layers);
-
-            const VkBufferMemoryBarrier buffer_barrier{
-                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-                .pNext = nullptr,
-                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-                .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
-                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                .buffer = out_buffer,
-                .offset = out_offset,
-                .size = output_size,
-            };
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                                   VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, buffer_barrier, {});
-
-            const VkBufferImageCopy copy{
-                .bufferOffset = out_offset,
-                .bufferRowLength = 0,
-                .bufferImageHeight = 0,
-                .imageSubresource{
-                    .aspectMask = aspect,
-                    .mipLevel = level,
-                    .baseArrayLayer = 0,
-                    .layerCount = layers,
-                },
-                .imageOffset = {0, 0, 0},
-                .imageExtent = {texel_width, texel_height, 1},
-            };
-            cmdbuf.CopyBufferToImage(out_buffer, dst_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                                     copy);
-        });
-    }
-
-    scheduler.Record([dst_image, aspect](vk::CommandBuffer cmdbuf) {
-        const VkImageMemoryBarrier barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
-            .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = dst_image,
-            .subresourceRange{
-                .aspectMask = aspect,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, {}, {}, barrier);
-    });
-}
-
-namespace {
-constexpr u32 BL3DB_BINDING_INPUT_BUFFER = 0;
-constexpr u32 BL3DB_BINDING_OUTPUT_BUFFER = 1;
-
-struct alignas(16) BlockLinearUnswizzle3DBufferPushConstants {
-    std::array<u32, 3> dim;
-    u32 bytes_per_block_log2;
-    std::array<u32, 3> origin;
-    u32 slice_size;
-    u32 block_size;
-    u32 x_shift;
-    u32 block_height;
-    u32 block_height_mask;
-    u32 block_depth;
-    u32 block_depth_mask;
-};
-static_assert(sizeof(BlockLinearUnswizzle3DBufferPushConstants) <= 128);
-
-constexpr std::array<VkDescriptorSetLayoutBinding, 2> BL3DB_BINDINGS{{
-    {
-        .binding = BL3DB_BINDING_INPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-    {
-        .binding = BL3DB_BINDING_OUTPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-}};
-
-constexpr std::array<VkDescriptorUpdateTemplateEntry, 2> BL3DB_TEMPLATE{{
-    {
-        .dstBinding = BL3DB_BINDING_INPUT_BUFFER,
-        .dstArrayElement = 0,
-        .descriptorCount = 1,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .offset = BL3DB_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-        .stride = sizeof(DescriptorUpdateEntry),
-    },
-    {
-        .dstBinding = BL3DB_BINDING_OUTPUT_BUFFER,
-        .dstArrayElement = 0,
-        .descriptorCount = 1,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .offset = BL3DB_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-        .stride = sizeof(DescriptorUpdateEntry),
-    },
-}};
-
-constexpr DescriptorBankInfo BL3DB_BANK_INFO{
-    .uniform_buffers = 0,
-    .storage_buffers = 2,
-    .texture_buffers = 0,
-    .image_buffers = 0,
-    .textures = 0,
-    .images = 0,
-    .score = 2,
-};
-} // Anonymous namespace
-
-BlockLinearUnswizzle3DBufferPass::BlockLinearUnswizzle3DBufferPass(
-    const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
-    StagingBufferPool& staging_buffer_pool_,
-    ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
-    : ComputePass(device_, scheduler_, descriptor_pool_, BL3DB_BINDINGS, BL3DB_TEMPLATE,
-                  BL3DB_BANK_INFO,
-                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinearUnswizzle3DBufferPushConstants)>,
-                  BLOCK_LINEAR_UNSWIZZLE_3D_BUFFER_COMP_SPV),
-      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
-      compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
-
-BlockLinearUnswizzle3DBufferPass::~BlockLinearUnswizzle3DBufferPass() = default;
-
-bool BlockLinearUnswizzle3DBufferPass::IsSupported(const Device& device,
-                                                   const VideoCommon::ImageInfo& info) {
-    if (info.type != VideoCommon::ImageType::e3D) {
-        return false;
-    }
-    if (info.resources.levels != 1 || info.resources.layers != 1) {
-        return false;
-    }
-    if (info.num_samples > 1) {
-        return false;
-    }
-    if (info.size.depth <= 1) {
-        return false;
-    }
-    if (VideoCore::Surface::GetFormatType(info.format) !=
-        VideoCore::Surface::SurfaceType::ColorTexture) {
-        return false;
-    }
-    if (VideoCore::Surface::IsPixelFormatASTC(info.format)) {
-        return false;
-    }
-    if (VideoCore::Surface::IsPixelFormatBCn(info.format) && !device.IsOptimalBcnSupported()) {
-        return false;
-    }
-    const u32 bytes_per_block = VideoCore::Surface::BytesPerBlock(info.format);
-    return bytes_per_block == 4 || bytes_per_block == 8 || bytes_per_block == 16;
-}
-
-void BlockLinearUnswizzle3DBufferPass::Unswizzle(
-    Image& image, const StagingBufferRef& swizzled,
-    std::span<const VideoCommon::SwizzleParameters> swizzles) {
-    if (swizzles.empty()) {
-        return;
-    }
-
-    const VideoCommon::SwizzleParameters& sw = swizzles.front();
-    const auto params = VideoCommon::Accelerated::MakeBlockLinearSwizzle3DParams(sw, image.info);
-
-    const u32 blocks_x = sw.num_tiles.width;
-    const u32 blocks_y = sw.num_tiles.height;
-    const u32 blocks_z = sw.num_tiles.depth;
-    const u32 bytes_per_block = 1u << params.bytes_per_block_log2;
-    const VkDeviceSize output_size =
-        static_cast<VkDeviceSize>(blocks_x) * blocks_y * blocks_z * bytes_per_block;
-
-    const StagingBufferRef output =
-        staging_buffer_pool.Request(static_cast<size_t>(output_size), MemoryUsage::DeviceLocal);
-
-    BlockLinearUnswizzle3DBufferPushConstants pc{};
-    pc.dim = {blocks_x, blocks_y, blocks_z};
-    pc.bytes_per_block_log2 = params.bytes_per_block_log2;
-    pc.origin = params.origin;
-    pc.slice_size = params.slice_size;
-    pc.block_size = params.block_size;
-    pc.x_shift = params.x_shift;
-    pc.block_height = params.block_height;
-    pc.block_height_mask = params.block_height_mask;
-    pc.block_depth = params.block_depth;
-    pc.block_depth_mask = params.block_depth_mask;
-
-    scheduler.RequestOutsideRenderPassOperationContext();
-
-    compute_pass_descriptor_queue.Acquire(scheduler, 2);
-    compute_pass_descriptor_queue.AddBuffer(swizzled.buffer, sw.buffer_offset + swizzled.offset,
-                                            image.guest_size_bytes - sw.buffer_offset);
-    compute_pass_descriptor_queue.AddBuffer(output.buffer, output.offset, output_size);
-
-    const void* descriptor_data = compute_pass_descriptor_queue.UpdateData();
-    const VkDescriptorSet set = descriptor_allocator.Commit();
-
-    const u32 gx = Common::DivCeil(blocks_x, 8u);
-    const u32 gy = Common::DivCeil(blocks_y, 8u);
-    const u32 gz = Common::DivCeil(blocks_z, 4u);
-    const bool is_initialized = image.ExchangeInitialization();
-
-    const VkBuffer out_buffer = output.buffer;
-    const VkDeviceSize out_offset = output.offset;
-    const VkImage dst_image = image.Handle();
-    const VkImageAspectFlags aspect = image.AspectMask();
-    const VkExtent3D extent{
-        .width = image.info.size.width,
-        .height = image.info.size.height,
-        .depth = image.info.size.depth,
-    };
-
-    scheduler.Record([this, set, descriptor_data, pc, gx, gy, gz, output_size, out_buffer,
-                      out_offset, dst_image, aspect, extent,
-                      is_initialized](vk::CommandBuffer cmdbuf) {
-        if (dst_image == VK_NULL_HANDLE || out_buffer == VK_NULL_HANDLE) {
-            return;
-        }
-        device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
-        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
-        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
-        cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
-        cmdbuf.Dispatch(gx, gy, gz);
-
-        const VkBufferMemoryBarrier buffer_barrier{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-            .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .buffer = out_buffer,
-            .offset = out_offset,
-            .size = output_size,
-        };
-        VkAccessFlags pre_copy_access = VK_ACCESS_NONE;
-        VkImageLayout pre_copy_layout = VK_IMAGE_LAYOUT_UNDEFINED;
-        VkPipelineStageFlags pre_copy_stage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
-        if (is_initialized) {
-            pre_copy_access = VK_ACCESS_SHADER_READ_BIT;
-            pre_copy_layout = VK_IMAGE_LAYOUT_GENERAL;
-            pre_copy_stage = vk::PIPELINE_STAGE_GRAPHICS_COMPUTE;
-        }
-        const VkImageMemoryBarrier pre_copy{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = pre_copy_access,
-            .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-            .oldLayout = pre_copy_layout,
-            .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = dst_image,
-            .subresourceRange{
-                .aspectMask = aspect,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | pre_copy_stage,
-                               VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, buffer_barrier, pre_copy);
-
-        const VkBufferImageCopy copy{
-            .bufferOffset = out_offset,
-            .bufferRowLength = 0,
-            .bufferImageHeight = 0,
-            .imageSubresource{
-                .aspectMask = aspect,
-                .mipLevel = 0,
-                .baseArrayLayer = 0,
-                .layerCount = 1,
-            },
-            .imageOffset = {0, 0, 0},
-            .imageExtent = extent,
-        };
-        cmdbuf.CopyBufferToImage(out_buffer, dst_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, copy);
-
-        const VkImageMemoryBarrier post_copy{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
-            .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = dst_image,
-            .subresourceRange{
-                .aspectMask = aspect,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
-                               0, {}, {}, post_copy);
-    });
-}
-
 } // namespace Vulkan
@@ -164,46 +164,4 @@ private:
    ComputePassDescriptorQueue& compute_pass_descriptor_queue;
 };

-class BlockLinearUnswizzle2DPass final : public ComputePass {
-public:
-    explicit BlockLinearUnswizzle2DPass(const Device& device_, Scheduler& scheduler_,
-                                        DescriptorPool& descriptor_pool_,
-                                        StagingBufferPool& staging_buffer_pool_,
-                                        ComputePassDescriptorQueue& compute_pass_descriptor_queue_);
-    ~BlockLinearUnswizzle2DPass();
-
-    [[nodiscard]] static bool IsSupported(const Device& device,
-                                          const VideoCommon::ImageInfo& info);
-
-    void Unswizzle(Image& image, const StagingBufferRef& swizzled,
-                   std::span<const VideoCommon::SwizzleParameters> swizzles);
-
-    void UnswizzleFrom(Image& image, VkBuffer source_buffer, VkDeviceSize source_offset,
-                       std::span<const VideoCommon::SwizzleParameters> swizzles);
-
-private:
-    Scheduler& scheduler;
-    StagingBufferPool& staging_buffer_pool;
-    ComputePassDescriptorQueue& compute_pass_descriptor_queue;
-};
-
-class BlockLinearUnswizzle3DBufferPass final : public ComputePass {
-public:
-    explicit BlockLinearUnswizzle3DBufferPass(
-        const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
-        StagingBufferPool& staging_buffer_pool_,
-        ComputePassDescriptorQueue& compute_pass_descriptor_queue_);
-    ~BlockLinearUnswizzle3DBufferPass();
-
-    [[nodiscard]] static bool IsSupported(const Device& device, const VideoCommon::ImageInfo& info);
-
-    void Unswizzle(Image& image, const StagingBufferRef& swizzled,
-                   std::span<const VideoCommon::SwizzleParameters> swizzles);
-
-private:
-    Scheduler& scheduler;
-    StagingBufferPool& staging_buffer_pool;
-    ComputePassDescriptorQueue& compute_pass_descriptor_queue;
-};
-
 } // namespace Vulkan
@@ -444,10 +444,8 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .has_broken_unsigned_image_offsets = false,
        .has_broken_signed_operations = false,
        .has_broken_fp16_float_controls = driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY,
-        .has_broken_fp32_denorm_flush = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
        .ignore_nan_fp_comparisons = false,
        .has_broken_spirv_subgroup_mask_vector_extract_dynamic = false,
-        .max_shared_memory_size = device.GetMaxComputeSharedMemorySize(),
        .has_broken_robust =
            device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
        .min_ssbo_alignment = device.GetStorageBufferAlignment(),
@@ -923,6 +921,19 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
    }

    auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
+    const VkDriverIdKHR driver_id = device.GetDriverID();
+    const bool needs_shared_mem_clamp =
+        driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+        driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
+    const u32 max_shared_memory = device.GetMaxComputeSharedMemorySize();
+    if (needs_shared_mem_clamp && program.shared_memory_size > max_shared_memory) {
+        LOG_WARNING(Render_Vulkan,
+                    "Compute shader {:#016x} requests {}KB shared memory but device max is {}KB - clamping",
+                    key.unique_hash,
+                    program.shared_memory_size / 1024,
+                    max_shared_memory / 1024);
+        program.shared_memory_size = max_shared_memory;
+    }
    const std::vector<u32> code{EmitSPIRV(profile, program)};
    device.SaveShader(code);
    vk::ShaderModule spv_module{BuildShader(device, code)};
@@ -225,13 +225,6 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
      fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler),
      wfi_event(device.GetLogical().CreateEvent()) {
    scheduler.SetQueryCache(query_cache);
-    if (Settings::values.use_unified_memory.GetValue() && device_memory.IsBackingShared()) {
-        buffer_cache_runtime.TryEnableUnifiedMemory(
-            device_memory.GetPhysicalBase(), device_memory.GetPhysicalSize(),
-            device_memory.GetBackingHardwareBuffers(),
-            device_memory.GetBackingHardwareBufferWindowSize(),
-            device_memory.GetBackingHardwareBufferBase());
-    }
 }

 RasterizerVulkan::~RasterizerVulkan() {
@@ -431,12 +424,24 @@ void RasterizerVulkan::Clear(u32 layer_count) {
    const bool ds_deferrable =
        !ds_used || ((!framebuffer->HasAspectDepthBit() || use_depth) &&
                     (!framebuffer->HasAspectStencilBit() || use_stencil) && !stencil_partial);
+    const bool can_defer_clear = ENABLE_DEFERRED_CLEAR && !regs.clear_control.use_scissor &&
+                                 regs.clear_surface.layer == 0 &&
+                                 !scheduler.IsRenderPassActive() &&
+                                 (!use_color || color_full_channels) && ds_deferrable;
+    if (!can_defer_clear) {
+        scheduler.RequestRenderpass(framebuffer);
+    }
+
+    query_cache.NotifySegment(true);
+    query_cache.CounterEnable(VideoCommon::QueryType::ZPassPixelCount64, maxwell3d->regs.zpass_pixel_count_enable);
    u32 up_scale = 1;
    u32 down_shift = 0;
    if (texture_cache.IsRescaling()) {
        up_scale = Settings::values.resolution_info.up_scale;
        down_shift = Settings::values.resolution_info.down_shift;
    }
+    UpdateViewportsState(regs);
+
    VkRect2D default_scissor{};
    default_scissor.offset.x = 0;
    default_scissor.offset.y = 0;
@@ -492,22 +497,6 @@ void RasterizerVulkan::Clear(u32 layer_count) {
        return;
    }

-    const bool clear_covers_render_area =
-        clear_rect.rect.offset.x == 0 && clear_rect.rect.offset.y == 0 &&
-        clear_rect.rect.extent.width >= render_area.width &&
-        clear_rect.rect.extent.height >= render_area.height;
-    const bool can_defer_clear = ENABLE_DEFERRED_CLEAR && (!regs.clear_control.use_scissor || clear_covers_render_area) &&
-                                 regs.clear_surface.layer == 0 &&
-                                 !scheduler.IsRenderPassActive() &&
-                                 (!use_color || color_full_channels) && ds_deferrable;
-    if (!can_defer_clear) {
-        scheduler.RequestRenderpass(framebuffer);
-    }
-
-    query_cache.NotifySegment(true);
-    query_cache.CounterEnable(VideoCommon::QueryType::ZPassPixelCount64, maxwell3d->regs.zpass_pixel_count_enable);
-    UpdateViewportsState(regs);
-
    const u32 color_attachment = regs.clear_surface.RT;
    if (use_color && framebuffer->HasAspectColorBit(color_attachment)) {
        const auto format = VideoCore::Surface::PixelFormatFromRenderTargetFormat(regs.rt[color_attachment].format);
@@ -65,72 +65,8 @@ using VideoCore::Surface::SurfaceType;
                .finalLayout = VK_IMAGE_LAYOUT_GENERAL,
            };
        }
-
-        struct ResolveAspects {
-            bool depth;
-            bool stencil;
-        };
-
-        struct ResolveModes {
-            VkResolveModeFlagBits depth;
-            VkResolveModeFlagBits stencil;
-        };
-
-        constexpr ResolveAspects GetResolveAspects(PixelFormat format) {
-            const SurfaceType surface_type = GetSurfaceType(format);
-            return ResolveAspects{
-                .depth = surface_type == SurfaceType::Depth ||
-                         surface_type == SurfaceType::DepthStencil,
-                .stencil = surface_type == SurfaceType::Stencil ||
-                           surface_type == SurfaceType::DepthStencil,
-            };
-        }
-
-        ResolveModes PickResolveModes(const Device& device, PixelFormat format) {
-            constexpr VkResolveModeFlagBits mode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
-
-            const ResolveAspects aspects = GetResolveAspects(format);
-            const bool depth_mode_supported = (device.GetDepthResolveModes() & mode) != 0;
-            const bool stencil_mode_supported = (device.GetStencilResolveModes() & mode) != 0;
-
-            ResolveModes modes{
-                .depth = VK_RESOLVE_MODE_NONE,
-                .stencil = VK_RESOLVE_MODE_NONE,
-            };
-            if (aspects.depth && depth_mode_supported) {
-                modes.depth = mode;
-            }
-            if (aspects.stencil && stencil_mode_supported) {
-                modes.stencil = mode;
-            }
-            if (modes.depth == modes.stencil || device.SupportsIndependentResolveNone()) {
-                return modes;
-            }
-            if (modes.depth != VK_RESOLVE_MODE_NONE && stencil_mode_supported) {
-                modes.stencil = mode;
-            } else if (modes.stencil != VK_RESOLVE_MODE_NONE && depth_mode_supported) {
-                modes.depth = mode;
-            }
-            return modes;
-        }
    } // Anonymous namespace

-bool SupportsDepthStencilResolve(const Device& device, PixelFormat depth_format) {
-    if (depth_format == PixelFormat::Invalid || !device.IsKhrDepthStencilResolveSupported()) {
-        return false;
-    }
-    const ResolveAspects aspects = GetResolveAspects(depth_format);
-    if (!aspects.depth && !aspects.stencil) {
-        return false;
-    }
-    const ResolveModes modes = PickResolveModes(device, depth_format);
-    if ((aspects.depth && modes.depth == VK_RESOLVE_MODE_NONE) ||
-        (aspects.stencil && modes.stencil == VK_RESOLVE_MODE_NONE)) {
-        return false;
-    }
-    return modes.depth == modes.stencil || device.SupportsIndependentResolveNone();
-}
-
 RenderPassCache::RenderPassCache(const Device& device_) : device{&device_} {}

 VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {
@@ -139,9 +75,7 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {
    if (!is_new) {
        return *pair->second;
    }
-    static constexpr size_t MAX_ATTACHMENTS =
-        2 * std::tuple_size_v<decltype(RenderPassKey::color_formats)> + 2;
-    boost::container::static_vector<VkAttachmentDescription, MAX_ATTACHMENTS> descriptions;
+    boost::container::static_vector<VkAttachmentDescription, 9> descriptions;
    std::array<VkAttachmentReference, 8> references{};
    u32 num_attachments{};
    u32 num_colors{};
@@ -175,11 +109,8 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {
        const VkAttachmentLoadOp depth_load_op = key.depth_stencil_clear
                                                     ? VK_ATTACHMENT_LOAD_OP_CLEAR
                                                     : VK_ATTACHMENT_LOAD_OP_LOAD;
-        const VkAttachmentStoreOp depth_store_op = key.depth_stencil_discard
-                                                       ? VK_ATTACHMENT_STORE_OP_DONT_CARE
-                                                       : VK_ATTACHMENT_STORE_OP_STORE;
        descriptions.push_back(AttachmentDescription(*device, key.depth_format, key.samples,
-                                                     depth_load_op, depth_store_op));
+                                                     depth_load_op, VK_ATTACHMENT_STORE_OP_STORE));
    }
    std::array<VkAttachmentReference, 8> resolve_references{};
    const bool do_resolve_color =
@@ -202,21 +133,6 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {
            }
        }
    }
-    const bool do_resolve_depth_stencil = key.resolve_depth_stencil && has_depth &&
-                                          key.samples != VK_SAMPLE_COUNT_1_BIT &&
-                                          SupportsDepthStencilResolve(*device, key.depth_format);
-    VkAttachmentReference depth_resolve_reference{};
-    if (do_resolve_depth_stencil) {
-        depth_resolve_reference = VkAttachmentReference{
-            .attachment = static_cast<u32>(descriptions.size()),
-            .layout = VK_IMAGE_LAYOUT_GENERAL,
-        };
-        VkAttachmentDescription resolve_desc =
-            AttachmentDescription(*device, key.depth_format, VK_SAMPLE_COUNT_1_BIT,
-                                  VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_STORE);
-        resolve_desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-        descriptions.push_back(resolve_desc);
-    }
    const VkSubpassDescription subpass{
        .flags = 0,
        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
@@ -241,92 +157,6 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {
            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
            .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT
    };
-
-    if (device->IsKhrCreateRenderPass2Supported()) {
-        boost::container::static_vector<VkAttachmentDescription2, MAX_ATTACHMENTS> descriptions2;
-        for (const VkAttachmentDescription& description : descriptions) {
-            descriptions2.push_back(VkAttachmentDescription2{
-                .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
-                .pNext = nullptr,
-                .flags = description.flags,
-                .format = description.format,
-                .samples = description.samples,
-                .loadOp = description.loadOp,
-                .storeOp = description.storeOp,
-                .stencilLoadOp = description.stencilLoadOp,
-                .stencilStoreOp = description.stencilStoreOp,
-                .initialLayout = description.initialLayout,
-                .finalLayout = description.finalLayout,
-            });
-        }
-        const auto promote = [](const VkAttachmentReference& reference) {
-            return VkAttachmentReference2{
-                .sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,
-                .pNext = nullptr,
-                .attachment = reference.attachment,
-                .layout = reference.layout,
-                .aspectMask = 0,
-            };
-        };
-        std::array<VkAttachmentReference2, 8> references2{};
-        std::array<VkAttachmentReference2, 8> resolve_references2{};
-        for (size_t index = 0; index < references.size(); ++index) {
-            references2[index] = promote(references[index]);
-            resolve_references2[index] = promote(resolve_references[index]);
-        }
-        const VkAttachmentReference2 depth_reference2 = promote(depth_reference);
-        const VkAttachmentReference2 depth_resolve_reference2 = promote(depth_resolve_reference);
-        const ResolveModes resolve_modes = PickResolveModes(*device, key.depth_format);
-        const VkSubpassDescriptionDepthStencilResolve depth_stencil_resolve{
-            .sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
-            .pNext = nullptr,
-            .depthResolveMode = resolve_modes.depth,
-            .stencilResolveMode = resolve_modes.stencil,
-            .pDepthStencilResolveAttachment = &depth_resolve_reference2,
-        };
-        const VkSubpassDescription2 subpass2{
-            .sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,
-            .pNext = do_resolve_depth_stencil ? &depth_stencil_resolve : nullptr,
-            .flags = 0,
-            .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
-            .viewMask = 0,
-            .inputAttachmentCount = 0,
-            .pInputAttachments = nullptr,
-            .colorAttachmentCount = num_attachments,
-            .pColorAttachments = references2.data(),
-            .pResolveAttachments = do_resolve_color ? resolve_references2.data() : nullptr,
-            .pDepthStencilAttachment = has_depth ? &depth_reference2 : nullptr,
-            .preserveAttachmentCount = 0,
-            .pPreserveAttachments = nullptr,
-        };
-        const VkSubpassDependency2 dependency2{
-            .sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,
-            .pNext = nullptr,
-            .srcSubpass = dependency.srcSubpass,
-            .dstSubpass = dependency.dstSubpass,
-            .srcStageMask = dependency.srcStageMask,
-            .dstStageMask = dependency.dstStageMask,
-            .srcAccessMask = dependency.srcAccessMask,
-            .dstAccessMask = dependency.dstAccessMask,
-            .dependencyFlags = dependency.dependencyFlags,
-            .viewOffset = 0,
-        };
-        pair->second = device->GetLogical().CreateRenderPass2({
-            .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,
-            .pNext = nullptr,
-            .flags = 0,
-            .attachmentCount = static_cast<u32>(descriptions2.size()),
-            .pAttachments = descriptions2.empty() ? nullptr : descriptions2.data(),
-            .subpassCount = 1,
-            .pSubpasses = &subpass2,
-            .dependencyCount = 1,
-            .pDependencies = &dependency2,
-            .correlatedViewMaskCount = 0,
-            .pCorrelatedViewMasks = nullptr,
-        });
-        return *pair->second;
-    }
-
    pair->second = device->GetLogical().CreateRenderPass({
        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
        .pNext = nullptr,
@@ -9,7 +9,6 @@
 #include <mutex>
 #include <ankerl/unordered_dense.h>

-#include "common/container_hash.h"
 #include "video_core/surface.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"

@@ -22,11 +21,9 @@ struct RenderPassKey {
    VideoCore::Surface::PixelFormat depth_format;
    VkSampleCountFlagBits samples;
    bool resolve_color;
-    bool resolve_depth_stencil;
    u32 color_clear_mask;
    bool depth_stencil_clear;
    u32 color_discard_mask;
-    bool depth_stencil_discard;
 };

 } // namespace Vulkan
@@ -34,28 +31,17 @@ struct RenderPassKey {
 namespace std {
 template <>
 struct hash<Vulkan::RenderPassKey> {
-    static_assert(std::tuple_size_v<decltype(Vulkan::RenderPassKey::color_formats)> <= 8);
-    static_assert(static_cast<u32>(VideoCore::Surface::PixelFormat::Invalid) <= 0xFF);
-    static_assert(static_cast<u32>(VideoCore::Surface::PixelFormat::Max) <= 0xFF);
-    static_assert(VK_SAMPLE_COUNT_64_BIT <= 0xFF);
-
    [[nodiscard]] size_t operator()(const Vulkan::RenderPassKey& key) const noexcept {
-        u64 formats = 0;
-        for (size_t index = 0; index < key.color_formats.size(); ++index) {
-            formats |= static_cast<u64>(key.color_formats[index]) << (index * 8);
+        size_t value = static_cast<size_t>(key.depth_format) << 48;
+        value ^= static_cast<size_t>(key.samples) << 52;
+        value ^= static_cast<size_t>(key.resolve_color) << 63;
+        value ^= static_cast<size_t>(key.color_clear_mask) << 54;
+        value ^= static_cast<size_t>(key.depth_stencil_clear) << 62;
+        value ^= static_cast<size_t>(key.color_discard_mask) << 24;
+        for (size_t i = 0; i < key.color_formats.size(); ++i) {
+            value ^= static_cast<size_t>(key.color_formats[i]) << (i * 6);
        }
-        const u64 state = static_cast<u64>(key.depth_format) |
-                          (static_cast<u64>(key.samples) << 8) |
-                          (static_cast<u64>(key.color_clear_mask) << 16) |
-                          (static_cast<u64>(key.color_discard_mask) << 24) |
-                          (static_cast<u64>(key.resolve_color) << 32) |
-                          (static_cast<u64>(key.depth_stencil_clear) << 33) |
-                          (static_cast<u64>(key.resolve_depth_stencil) << 34) |
-                          (static_cast<u64>(key.depth_stencil_discard) << 35);
-        size_t seed = 0;
-        Common::HashCombine(seed, formats);
-        Common::HashCombine(seed, state);
-        return seed;
+        return value;
    }
 };
 } // namespace std
@@ -64,9 +50,6 @@ namespace Vulkan {

 class Device;

-[[nodiscard]] bool SupportsDepthStencilResolve(const Device& device,
-                                               VideoCore::Surface::PixelFormat depth_format);
-
 class RenderPassCache {
 public:
    explicit RenderPassCache(const Device& device_);
@@ -132,7 +132,6 @@ void Scheduler::BeginRenderPassImpl(const Framebuffer* framebuffer, VkRenderPass
    num_renderpass_images = framebuffer->NumImages();
    renderpass_images = framebuffer->Images();
    renderpass_image_ranges = framebuffer->ImageRanges();
-    framebuffer->MarkResolveShadowsUpToDate();
 }

 void Scheduler::RealizeDeferredClear() {
@@ -156,10 +155,8 @@ void Scheduler::RealizeDeferredClear() {
    }
    const u32 color_discard_mask =
        dc.framebuffer->DiscardsMsaaColor() ? dc.color_clear_mask : 0u;
-    const bool depth_stencil_discard =
-        dc.depth_stencil && dc.framebuffer->DiscardsMsaaDepthStencil();
    const VkRenderPass renderpass = dc.framebuffer->RenderPassVariant(
-        dc.color_clear_mask, dc.depth_stencil, color_discard_mask, depth_stencil_discard);
+        dc.color_clear_mask, dc.depth_stencil, color_discard_mask);
    EndRenderPass();
    BeginRenderPassImpl(dc.framebuffer, renderpass, clear_values.data(), count);
 }
@@ -193,14 +190,6 @@ bool Scheduler::DeferDepthStencilClear(const Framebuffer* framebuffer, const VkC
    return true;
 }

-void Scheduler::FlushDeferredClear() {
-    if (deferred_clear.framebuffer == nullptr) {
-        return;
-    }
-    RealizeDeferredClear();
-    EndRenderPass();
-}
-
 void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {
    if (deferred_clear.framebuffer == framebuffer) {
        RealizeDeferredClear();
@@ -65,9 +65,6 @@ public:
    /// Defers a full depth/stencil clear so it becomes the next render pass.
    bool DeferDepthStencilClear(const Framebuffer* framebuffer, const VkClearValue& value);

-    /// Realizes any pending deferred clear before its framebuffer can be moved or freed.
-    void FlushDeferredClear();
-
    /// Requests the current execution context to be able to execute operations only allowed outside
    /// of a renderpass.
    void RequestOutsideRenderPassOperationContext();
@@ -129,10 +126,6 @@ public:
        return master_semaphore->IsFree(tick);
    }

-    void RefreshTick() {
-        master_semaphore->Refresh();
-    }
-
    /// Waits for the given GPU tick, optionally pacing frames.
    void Wait(u64 tick, double target_fps = 0.0) {
        if (tick > 0) {
@@ -33,10 +33,10 @@ constexpr VkDeviceSize MAX_ALIGNMENT = 256;
 // Windows ones however, can intake bigger buffers and generally do not OOM.
 // - GTX 960 on Windows will not OOM with 256mib
 // - GT 1030 on ^NIX will OOM with 256mib
-#if defined(__FreeBSD__)
-constexpr VkDeviceSize MAX_STREAM_BUFFER_SIZE = 128_MiB;
-#else
+#if defined(_WIN32) || defined(__ANDROID__)
 constexpr VkDeviceSize MAX_STREAM_BUFFER_SIZE = 256_MiB;
+#else
+constexpr VkDeviceSize MAX_STREAM_BUFFER_SIZE = 128_MiB;
 #endif

 size_t GetStreamBufferSize(const Device& device) {
@@ -60,19 +60,13 @@ public:

    void TickFrame();

-    void FlushDeferredClear();
-
    u64 GetDeviceLocalMemory() const;

    u64 GetDeviceMemoryUsage() const;

    bool CanReportMemoryUsage() const;

-    bool CanDownloadMsaa(const VideoCommon::ImageInfo& info) const;
-
-    [[nodiscard]] VkImage AcquireMsaaScratchImage(const VkImageCreateInfo& image_ci);
-
-    void ReleaseMsaaScratchImage(VkImage image);
+    std::optional<size_t> GetSamplerHeapBudget() const;

    void BlitImage(Framebuffer* dst_framebuffer, ImageView& dst, ImageView& src,
                   const Region2D& dst_region, const Region2D& src_region,
@@ -101,23 +95,6 @@ public:
                               std::span<const VideoCommon::SwizzleParameters>,
                               u32 z_start, u32 z_count);

-    [[nodiscard]] bool IsUnifiedMemoryBindable() const noexcept;
-
-    [[nodiscard]] u64 UnifiedMemoryBase() const noexcept;
-
-    [[nodiscard]] u64 UnifiedMemorySize() const noexcept;
-
-    [[nodiscard]] u64 UnifiedMemoryWindowSize() const noexcept;
-
-    [[nodiscard]] bool CanUploadImageDirectly(const VideoCommon::ImageInfo& info) const;
-
-    bool UploadImageDirectly(Image& image, size_t window_index, u64 window_offset,
-                             std::span<const VideoCommon::SwizzleParameters> swizzles);
-
-    [[nodiscard]] u64 CurrentTick() const noexcept;
-
-    [[nodiscard]] bool IsDirectUploadRetired(u64 tick);
-
    void InsertUploadMemoryBarrier() {}

    void TransitionImageLayout(Image& image);
@@ -140,20 +117,16 @@ public:
        VkFormat format = VK_FORMAT_UNDEFINED;
        VkExtent2D extent{};
        u32 layers = 0;
-        VkImageAspectFlags aspect_mask = VK_IMAGE_ASPECT_COLOR_BIT;
        bool up_to_date = false;
    };

    [[nodiscard]] VkImageView GetOrCreateResolveShadow(VkImage msaa_image, VkFormat format,
-                                                       VkExtent2D extent, u32 layers,
-                                                       VkImageAspectFlags aspect_mask);
+                                                       VkExtent2D extent, u32 layers);

    [[nodiscard]] const ResolveShadow* GetValidResolveShadow(VkImage msaa_image) const;

    void InvalidateResolveShadow(VkImage msaa_image);

-    void MarkResolveShadowUpToDate(VkImage msaa_image);
-
    void EraseResolveShadow(VkImage msaa_image);

    std::span<const VkFormat> ViewFormats(PixelFormat format) {
@@ -176,37 +149,13 @@ public:
    std::optional<ASTCDecoderPass> astc_decoder_pass;

    std::optional<BlockLinearUnswizzle3DPass> bl3d_unswizzle_pass;
-    std::optional<BlockLinearUnswizzle2DPass> bl2d_unswizzle_pass;
-    std::optional<BlockLinearUnswizzle3DBufferPass> bl3db_unswizzle_pass;
    const Settings::ResolutionScalingInfo& resolution;
    std::array<std::vector<VkFormat>, VideoCore::Surface::MaxPixelFormat> view_formats;

    static constexpr size_t indexing_slots = 8 * sizeof(size_t);
    std::array<vk::Buffer, indexing_slots> buffers{};
-    struct MsaaScratchKey {
-        VkFormat format;
-        VkImageType type;
-        u32 width;
-        u32 height;
-        u32 depth;
-        u32 levels;
-        u32 layers;
-        VkImageUsageFlags usage;
-        VkImageCreateFlags flags;
-
-        bool operator==(const MsaaScratchKey&) const noexcept = default;
-    };
-
-    struct MsaaScratchImage {
-        MsaaScratchKey key;
-        vk::Image image;
-        u64 tick;
-        u32 unused_frames;
-    };
-
-    std::vector<MsaaScratchImage> msaa_scratch_images;
+    std::vector<std::pair<u64, vk::Image>> pending_msaa_images;
    ankerl::unordered_dense::map<VkImage, ResolveShadow> resolve_shadows;
-    std::vector<std::pair<u64, ResolveShadow>> pending_resolve_shadows;
 };

 class Framebuffer {
@@ -242,8 +191,7 @@ public:
    }

    [[nodiscard]] VkRenderPass RenderPassVariant(u32 color_clear_mask, bool depth_stencil_clear,
-                                                 u32 color_discard_mask,
-                                                 bool depth_stencil_discard) const;
+                                                 u32 color_discard_mask) const;

    [[nodiscard]] VkExtent2D RenderArea() const noexcept {
        return render_area;
@@ -285,21 +233,19 @@ public:
        return is_rescaled;
    }

+    [[nodiscard]] bool HasResolveColor() const noexcept {
+        return !resolve_images.empty();
+    }
+
+    [[nodiscard]] VkImage ResolveColorImage(size_t index) const noexcept {
+        return index < resolve_images.size() ? *resolve_images[index] : VK_NULL_HANDLE;
+    }
+
    [[nodiscard]] bool DiscardsMsaaColor() const noexcept {
        return discard_msaa_color;
    }

-    [[nodiscard]] bool DiscardsMsaaDepthStencil() const noexcept {
-        return discard_msaa_depth_stencil;
-    }
-
-    /// Records that a render pass has begun, so its resolve attachments will hold valid contents
-    /// once it ends.
-    void MarkResolveShadowsUpToDate() const;
-
 private:
-    static constexpr size_t NUM_MEMOIZED_RENDER_PASS_VARIANTS = 8;
-
    vk::Framebuffer framebuffer;
    VkRenderPass renderpass{};
    VkExtent2D render_area{};
@@ -312,16 +258,11 @@ private:
    bool has_depth{};
    bool has_stencil{};
    bool is_rescaled{};
-    std::array<VkImage, 9> resolve_shadow_images{};
-    u32 num_resolve_shadows = 0;
-    TextureCacheRuntime* runtime_ptr{nullptr};
+    std::vector<vk::Image> resolve_images;
+    std::vector<vk::ImageView> resolve_image_views;
    RenderPassKey render_pass_key{};
    RenderPassCache* render_pass_cache{nullptr};
    bool discard_msaa_color{};
-    bool discard_msaa_depth_stencil{};
-    mutable std::array<u32, NUM_MEMOIZED_RENDER_PASS_VARIANTS> variant_keys{};
-    mutable std::array<VkRenderPass, NUM_MEMOIZED_RENDER_PASS_VARIANTS> variant_render_passes{};
-    mutable u32 num_memoized_variants{};
 };

 class Image : public VideoCommon::ImageBase {
@@ -463,22 +404,6 @@ public:
        return supports_depth_comparison;
    }

-    [[nodiscard]] bool RequiresBorderColorFormat() const noexcept {
-        return requires_border_color_format;
-    }
-
-    [[nodiscard]] bool SupportsMinmaxFilter() const noexcept {
-        return supports_minmax_filter;
-    }
-
-    [[nodiscard]] const VkComponentMapping& Swizzle() const noexcept {
-        return swizzle_mapping;
-    }
-
-    [[nodiscard]] bool HasIdentitySwizzle() const noexcept {
-        return has_identity_swizzle;
-    }
-
    [[nodiscard]] GPUVAddr GpuAddr() const noexcept {
        return gpu_addr;
    }
@@ -511,91 +436,48 @@ private:
    VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
    u32 buffer_size = 0;

-    VkComponentMapping swizzle_mapping{};
-
    bool supports_depth_comparison = false;
-    bool requires_border_color_format = false;
-    bool supports_minmax_filter = false;
-    bool has_identity_swizzle = true;
 };

 class ImageAlloc : public VideoCommon::ImageAllocBase {};

-class CustomBorderColorBudget {
-public:
-    CustomBorderColorBudget() = default;
-    ~CustomBorderColorBudget();
-
-    CustomBorderColorBudget(const CustomBorderColorBudget&) = delete;
-    CustomBorderColorBudget& operator=(const CustomBorderColorBudget&) = delete;
-
-    CustomBorderColorBudget(CustomBorderColorBudget&& rhs) noexcept;
-    CustomBorderColorBudget& operator=(CustomBorderColorBudget&& rhs) noexcept;
-
-    bool TryAcquire(const Device& device, size_t count);
-
-private:
-    void Release() noexcept;
-
-    const Device* device_ptr = nullptr;
-    size_t held = 0;
-};
-
 class Sampler {
 public:
    explicit Sampler(TextureCacheRuntime&, const Tegra::Texture::TSCEntry&);

    [[nodiscard]] VkSampler Handle() const noexcept {
-        return *variants.front().sampler;
+        return *sampler;
    }

-    [[nodiscard]] VkSampler HandleFor(const ImageView& image_view, bool is_depth);
+    [[nodiscard]] VkSampler HandleWithDefaultAnisotropy() const noexcept {
+        return *sampler_default_anisotropy;
+    }
+
+    [[nodiscard]] bool HasAddedAnisotropy() const noexcept {
+        return static_cast<bool>(sampler_default_anisotropy);
+    }
+
+    [[nodiscard]] VkSampler HandleWithNearestFilter() const noexcept {
+        return *sampler_nearest;
+    }
+
+    [[nodiscard]] bool HasLinearFiltering() const noexcept {
+        return static_cast<bool>(sampler_nearest);
+    }
+
+    [[nodiscard]] VkSampler HandleWithoutDepthComparison() const noexcept {
+        return *sampler_noncompare;
+    }
+
+    [[nodiscard]] bool HasDepthComparison() const noexcept {
+        return static_cast<bool>(sampler_noncompare);
+    }

 private:
-    struct VariantKey {
-        bool reduce_anisotropy;
-        bool force_nearest;
-        bool drop_depth_comparison;
-        bool drop_reduction;
-        bool drop_custom_border;
-        bool srgb_border;
-        std::array<VkComponentSwizzle, 4> swizzle;
-
-        bool operator==(const VariantKey&) const noexcept = default;
-
-        [[nodiscard]] bool HasSwizzle() const noexcept {
-            return swizzle != std::array<VkComponentSwizzle, 4>{};
-        }
-    };
-
-    struct Variant {
-        VariantKey key;
-        vk::Sampler sampler;
-    };
-
-    static constexpr size_t MAX_VARIANTS = 32;
-
-    [[nodiscard]] VariantKey MakeKey(const ImageView& image_view, bool is_depth) const noexcept;
-    [[nodiscard]] VkSampler Find(const VariantKey& key) const noexcept;
-    VkSampler Emplace(VariantKey key);
-
-    CustomBorderColorBudget custom_border_color_budget;
-    std::vector<Variant> variants;
-
-    const Device* device_ptr{nullptr};
-    VkSamplerCreateInfo base_ci{};
-    VkSamplerReductionModeEXT reduction_mode{VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT};
-    std::array<float, 4> border_color{};
-    std::array<float, 4> srgb_border_color{};
-    f32 default_anisotropy{1.0f};
-
-    bool has_added_anisotropy{};
-    bool has_linear_filtering{};
-    bool has_depth_comparison{};
-    bool has_minmax_reduction{};
-    bool has_custom_border_colors{};
-    bool has_srgb_border_color{};
-    bool needs_swizzle_mapping{};
+    vk::Sampler sampler;
+    vk::Sampler sampler_default_anisotropy;
+    vk::Sampler sampler_nearest;
+    vk::Sampler sampler_noncompare;
 };

 struct TextureCacheParams {
@@ -604,8 +486,6 @@ struct TextureCacheParams {
    static constexpr bool HAS_EMULATED_COPIES = false;
    static constexpr bool HAS_DEVICE_MEMORY_INFO = true;
    static constexpr bool IMPLEMENTS_ASYNC_DOWNLOADS = true;
-    static constexpr bool HAS_MSAA_DOWNLOADS = true;
-    static constexpr bool USE_UNIFIED_MEMORY = true;

    using Runtime = Vulkan::TextureCacheRuntime;
    using Image = Vulkan::Image;
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -121,7 +121,7 @@ void ImageBase::InsertView(const ImageViewInfo& view_info, ImageViewId image_vie
    image_view_ids.push_back(image_view_id);
 }

-bool ImageBase::IsSafeGpuCopy() const noexcept {
+bool ImageBase::IsSafeDownload() const noexcept {
    // Skip images that were not modified from the GPU
    if (False(flags & ImageFlagBits::GpuModified)) {
        return false;
@@ -131,6 +131,10 @@ bool ImageBase::IsSafeGpuCopy() const noexcept {
    if (True(flags & ImageFlagBits::CpuModified)) {
        return false;
    }
+    if (info.num_samples > 1) {
+        LOG_WARNING(HW_GPU, "MSAA image downloads are not implemented");
+        return false;
+    }
    return true;
 }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
lizzie	dab73ea765	fix debian	2026-08-23 06:47:16 +02:00
lizzie	d432eca239	Trigger Build	2026-08-23 06:47:16 +02:00
lizzie	c783990791	fx	2026-08-23 06:47:16 +02:00
lizzie	3718e505d4	brain no work	2026-08-23 06:47:16 +02:00
lizzie	1358d7c584	implodes	2026-08-23 06:47:16 +02:00
lizzie	8e86ec4f4b	[audio_core/dsp] nuke libopus, use ffmpeg for opus decoding Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-08-23 06:47:16 +02:00