nullptr check on multistream

reset to nil
a
2026-09-06 04:06:58 +00:00 · 2026-09-03 07:43:44 +00:00 · 2026-09-03 06:55:12 +00:00 · 2026-09-03 06:32:44 +00:00 · 2026-09-03 06:32:44 +00:00 · 2026-09-03 06:32:44 +00:00
76 changed files with 840 additions and 2215 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)
@@ -1,112 +0,0 @@
-diff --git a/include/vk_mem_alloc.h b/include/vk_mem_alloc.h
-index 8df0364..4856064 100644
--- a/include/vk_mem_alloc.h
-+++ b/include/vk_mem_alloc.h
-@@ -3017,7 +3017,7 @@ remove them if not needed.
- 
- #if defined(__ANDROID_API__) && (__ANDROID_API__ < 16)
- #include <cstdlib>
-static void* vma_aligned_alloc(size_t alignment, size_t size)
-+static inline void* vma_aligned_alloc(size_t alignment, size_t size)
- {
-     // alignment must be >= sizeof(void*)
-     if(alignment < sizeof(void*))
-@@ -3860,7 +3860,7 @@ Returned value is the found element, if present in the collection or place where
- new element with value (key) should be inserted.
- */
- template <typename CmpLess, typename IterT, typename KeyT>
-static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT& key, const CmpLess& cmp)
-+static inline IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT& key, const CmpLess& cmp)
- {
-     size_t down = 0;
-     size_t up = size_t(end - beg);
-@@ -3898,7 +3898,7 @@ Warning! O(n^2) complexity. Use only inside VMA_HEAVY_ASSERT.
- T must be pointer type, e.g. VmaAllocation, VmaPool.
- */
- template<typename T>
-static bool VmaValidatePointerArray(uint32_t count, const T* arr)
-+static inline bool VmaValidatePointerArray(uint32_t count, const T* arr)
- {
-     for (uint32_t i = 0; i < count; ++i)
-     {
-@@ -4188,13 +4188,13 @@ static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr
- }
- 
- template<typename T>
-static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
-+static inline T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
- {
-     return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
- }
- 
- template<typename T>
-static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
-+static inline T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
- {
-     return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
- }
-@@ -4204,14 +4204,14 @@ static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, si
- #define vma_new_array(allocator, type, count)   new(VmaAllocateArray<type>((allocator), (count)))(type)
- 
- template<typename T>
-static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
-+static inline void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
- {
-     ptr->~T();
-     VmaFree(pAllocationCallbacks, ptr);
- }
- 
- template<typename T>
-static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
-+static inline void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
- {
-     if (ptr != VMA_NULL)
-     {
-@@ -4658,13 +4658,13 @@ void VmaVector<T, AllocatorT>::remove(size_t index)
- #endif // _VMA_VECTOR_FUNCTIONS
- 
- template<typename T, typename allocatorT>
-static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
-+static inline void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
- {
-     vec.insert(index, item);
- }
- 
- template<typename T, typename allocatorT>
-static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
-+static inline void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
- {
-     vec.remove(index);
- }
-@@ -10620,19 +10620,19 @@ static void VmaFree(VmaAllocator hAllocator, void* ptr)
- }
- 
- template<typename T>
-static T* VmaAllocate(VmaAllocator hAllocator)
-+static inline T* VmaAllocate(VmaAllocator hAllocator)
- {
-     return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
- }
- 
- template<typename T>
-static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
-+static inline T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
- {
-     return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
- }
- 
- template<typename T>
-static void vma_delete(VmaAllocator hAllocator, T* ptr)
-+static inline void vma_delete(VmaAllocator hAllocator, T* ptr)
- {
-     if(ptr != VMA_NULL)
-     {
-@@ -10642,7 +10642,7 @@ static void vma_delete(VmaAllocator hAllocator, T* ptr)
- }
- 
- template<typename T>
-static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
-+static inline void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
- {
-     if(ptr != VMA_NULL)
-     {
@@ -3,7 +3,6 @@

 cmake_minimum_required(VERSION 3.31)

-set(CMAKE_OSX_DEPLOYMENT_TARGET "15.0" CACHE STRING "macOS deployment target")
 project(yuzu)

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
@@ -462,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)
@@ -513,7 +497,7 @@ endfunction()
 # =============================================

 if (APPLE)
-    foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers Foundation)
+    foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers)
        find_library(${fw}_LIBRARY ${fw} REQUIRED)
        list(APPEND PLATFORM_LIBRARIES ${${fw}_LIBRARY})
    endforeach()
@@ -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()
@@ -1,4 +1,12 @@
 {
+    "": {
+        "ci": true,
+        "hash": "9f50d993c39529e022ad456163de91ac5934e16faf8fc348f305355fc0a643c534f87ded707e11bd03bcbc0a1760bd20852b6533a67ac0558a078385181cb184",
+        "name": "SDL3",
+        "package": "SDL3",
+        "repo": "crueter-ci/SDL3",
+        "version": "3.4.14-1788231389-147a8ee32d"
+    },
    "biscuit": {
        "hash": "1229f345b014f7ca544dedb4edb3311e41ba736f9aa9a67f88b5f26f3c983288c6bb6cdedcfb0b8a02c63088a37e6a0d7ba97d9c2a4d721b213916327cffe28a",
        "min_version": "0.9.1",
@@ -60,10 +68,10 @@
    },
    "discord-rpc": {
        "find_args": "MODULE",
-        "hash": "8d680b3a16d6f6bf292ad823cf8635595ff986f2a49f758e3009f505b540a9d75194a8cf44cddea75736a8c3e3b5160166e716a0939ce3f18cc463cf648753fe",
+        "hash": "8213c43dcb0f7d479f5861091d111ed12fbdec1e62e6d729d65a4bc181d82f48a35d5fd3cd5c291f2393ac7c9681eabc6b76609755f55376284c8a8d67e148f3",
        "package": "DiscordRPC",
        "repo": "eden-emulator/discord-rpc",
-        "version": "76616d8675"
+        "version": "0d8b2d6a37"
    },
    "enet": {
        "find_args": "MODULE",
@@ -82,7 +90,7 @@
        "name": "ffmpeg",
        "package": "FFmpeg",
        "repo": "crueter-ci/FFmpeg",
-        "version": "9.0.1-1788120736-bf1b838f2a"
+        "version": "9.0.1-1788303113-bf1b838f2a"
    },
    "fmt": {
        "hash": "f0da82c545b01692e9fd30fdfb613dbb8dd9716983dcd0ff19ac2a8d36f74beb5540ef38072fdecc1e34191b3682a8542ecbf3a61ef287dbba0a2679d4e023f2",
@@ -210,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",
@@ -303,9 +296,6 @@
        "find_args": "CONFIG",
        "hash": "deb5902ef8db0e329fbd5f3f4385eb0e26bdd9f14f3a2334823fb3fe18f36bc5d235d620d6e5f6fe3551ec3ea7038638899db8778c09f6d5c278f5ff95c3344b",
        "package": "VulkanMemoryAllocator",
-        "patches": [
-            "0001-macos-clang.patch"
-        ],
        "repo": "GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator",
        "version": "v3.3.0"
    },
@@ -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:

@@ -121,7 +120,7 @@ sudo emerge -a \
    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 \
@@ -153,7 +152,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.
@@ -166,7 +165,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.
@@ -213,7 +212,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>
@@ -261,7 +260,7 @@ brew install molten-vk

 As root run:
 ```sh
-pkg install devel/cmake devel/sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base x11-toolkits/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 graphics/vulkan-utility-libraries graphics/vulkan-headers graphics/spirv-headers quazip-qt6
+pkg install devel/cmake devel/sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base x11-toolkits/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 graphics/vulkan-utility-libraries graphics/vulkan-headers graphics/spirv-headers quazip-qt6
 ```

 If using FreeBSD 12 or prior, use `devel/pkg-config` instead.
@@ -275,7 +274,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-qtbase qt6-qtcharts qt6-qtmultimedia qt6-qttools 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-qtbase qt6-qtcharts qt6-qtmultimedia qt6-qttools cpp-httplib lz4 vulkan-headers nasm autoconf enet pkg-config libusb1 libcxx frozen
 ```

 [Caveats](./Caveats.md#netbsd).
@@ -306,7 +305,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).
@@ -330,7 +329,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 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 openssl SDL3"
 # Either x86_64 or clang-aarch64 (Windows on ARM)
 packages="$BASE"
 for pkg in $MINGW; do
@@ -356,7 +355,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).
@@ -11,7 +11,6 @@
 #include <limits>
 #include <span>
 #include <array>
-#include <algorithm>
 #include <time.h>

 namespace Tz {
@@ -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
@@ -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,
@@ -1762,51 +1762,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,72 @@
+// 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 "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;
+Result OpusDecodeObject::Shutdown() {
+    if (avctx) {
+        avcodec_free_context(&avctx);
+        avctx = nullptr;
    }
-
-    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;
+    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,30 @@
+// 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 "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
@@ -5,17 +5,16 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <array>
-#include <chrono>

 #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/audio_core.h"
-#include "audio_core/common/common.h"
 #include "common/logging.h"
 #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 +48,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 +72,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
@@ -6,9 +6,11 @@

 #pragma once

-#include <memory>
 #include <thread>

+#include "common/container/unordered_map.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,28 +70,30 @@ 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.
     */
    void Main(std::stop_token stop_token);

-    /// Core system
-    Core::System& system;
    /// Mailbox to communicate messages with the host, drives the main thread
    Mailbox mailbox;
+    /// Core system
+    Core::System& system;
+    /// 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{};
    /// Init thread
    std::jthread init_thread{};
    /// Main thread
    std::jthread main_thread{};
+
+    ::Common::unordered_map<u64, OpusDecodeObject> decode_objects;
+    ::Common::unordered_map<u64, OpusMultiStreamDecodeObject> ms_decode_objects;
+
    /// The current state
    bool running{};
-    /// 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{};
 };

 } // namespace AudioCore::ADSP::OpusDecoder
@@ -4,8 +4,17 @@
 // 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 {

@@ -13,101 +22,61 @@ namespace {
 constexpr u32 OpusStreamCountMax = 255;

 bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
-    return total_stream_count > 0 && total_stream_count <= OpusStreamCountMax &&
-           static_cast<s32>(stereo_stream_count) >= 0 &&
-           stereo_stream_count <= total_stream_count;
+    return total_stream_count > 0 && total_stream_count <= OpusStreamCountMax
+        && s32(stereo_stream_count) >= 0 && stereo_stream_count <= 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)) == nullptr)
+        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;
+Result OpusMultiStreamDecodeObject::Shutdown() {
+    if (avctx) {
+        avcodec_free_context(&avctx);
+        avctx = nullptr;
    }
-
-    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;
+    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,30 @@
+// 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 "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,9 +1,11 @@
+// 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 "common/common_funcs.h"
 #include "common/common_types.h"

 namespace AudioCore::ADSP::OpusDecoder {
@@ -9,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);
 }

@@ -92,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,
@@ -120,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) {
@@ -134,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) {
@@ -149,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,
@@ -173,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,
@@ -187,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) {
@@ -220,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();
@@ -235,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"
@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <string>
-#include <cstdlib>
 #include <string_view>
 #ifdef _WIN32
 #include <llvm/Demangle/Demangle.h>
@@ -1,13 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

 #include <iterator>
-#include <cstring>

 #include "common/make_unique_for_overwrite.h"

@@ -65,7 +61,7 @@ public:
    void resize(size_type size) {
        if (size > buffer_capacity) {
            auto new_buffer = Common::make_unique_for_overwrite<T[]>(size);
-            std::memcpy(new_buffer.get(), buffer.get(), buffer_capacity * sizeof(T));
+            std::move(buffer.get(), buffer.get() + buffer_capacity, new_buffer.get());
            buffer = std::move(new_buffer);
            buffer_capacity = size;
        }
@@ -10,7 +10,6 @@
 #include <functional>
 #include <span>
 #include <string>
-#include <type_traits>

 #include "common/common_types.h"

@@ -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)
@@ -6,13 +6,13 @@

 #include <mutex>
 #include <utility>
-#include <type_traits>
-
 #include <boost/asio.hpp>
 #include <boost/version.hpp>
+
 #if BOOST_VERSION > 108400 && (!defined(_WINDOWS) && !defined(__ANDROID__)) || defined(YUZU_BOOST_v1)
 #define USE_BOOST_v1
 #endif
+
 #ifdef USE_BOOST_v1
 #include <boost/process/v1/async_pipe.hpp>
 #else
@@ -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 2023 yuzu Emulator Project
@@ -6,7 +6,6 @@

 #pragma once

-#include <type_traits>
 #include "common/common_funcs.h"

 namespace FileSys {
@@ -7,7 +7,6 @@
 #pragma once

 #include <optional>
-#include <type_traits>

 #include "common/literals.h"
 #include "core/file_sys/fssystem/fs_i_storage.h"
@@ -4,7 +4,6 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#include <type_traits>
 #include "core/file_sys/errors.h"
 #include "core/file_sys/fssystem/fssystem_bucket_tree.h"
 #include "core/file_sys/fssystem/fssystem_bucket_tree_utils.h"
@@ -1,13 +1,9 @@
-// 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 <type_traits>

 #include "common/alignment.h"
 #include "common/common_funcs.h"
@@ -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 2023 yuzu Emulator Project
@@ -6,7 +6,6 @@

 #pragma once

-#include <type_traits>
 #include "core/file_sys/errors.h"
 #include "core/file_sys/fssystem/fssystem_bucket_tree.h"
 #include "core/file_sys/fssystem/fssystem_bucket_tree_utils.h"
@@ -6,8 +6,6 @@

 #pragma once

-#include <type_traits>
-#include <cstddef>
 #include "common/literals.h"

 #include "core/file_sys/errors.h"
@@ -1,12 +1,8 @@
-// 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 <type_traits>
 #include "common/alignment.h"
 #include "core/file_sys/fssystem/fs_i_storage.h"
 #include "core/file_sys/fssystem/fs_types.h"
@@ -6,9 +6,6 @@

 #pragma once

-#include <type_traits>
-#include <array>
-#include <cstddef>
 #include "core/file_sys/errors.h"
 #include "core/file_sys/fssystem/fs_i_storage.h"
 #include "core/file_sys/fssystem/fssystem_bucket_tree.h"
@@ -1,15 +1,9 @@
-// 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 <optional>
-#include <array>
-#include <cstddef>
-#include <type_traits>

 #include "core/file_sys/fssystem/fs_i_storage.h"
 #include "core/file_sys/fssystem/fs_types.h"
@@ -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 2023 yuzu Emulator Project
@@ -6,8 +6,6 @@

 #pragma once

-#include <type_traits>
-#include <cstddef>
 #include "core/file_sys/fssystem/fssystem_compression_common.h"
 #include "core/file_sys/fssystem/fssystem_nca_header.h"
 #include "core/file_sys/vfs/vfs.h"
@@ -1,14 +1,8 @@
-// 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 <type_traits>
-#include <array>
-#include <cstddef>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/literals.h"
@@ -7,7 +7,6 @@
 #pragma once

 #include <memory>
-#include <type_traits>

 #include "common/common_funcs.h"
 #include "common/page_table.h"
@@ -6,7 +6,6 @@

 #pragma once

-#include <type_traits>
 #include "common/assert.h"
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
@@ -1,13 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 #pragma once

 #include <array>
-#include <type_traits>
 #include <functional>

 #include "common/common_funcs.h"
@@ -175,10 +175,19 @@ Result AlbumManager::LoadAlbumScreenShotImage(LoadAlbumScreenShotImageOutput& ou
        return ResultIsNotMounted;
    }

-    out_image_output = {};
-    out_image_output.width = 1280;
-    out_image_output.height = 720;
-    out_image_output.attribute.orientation = AlbumImageOrientation::None;
+    out_image_output = {
+        .width = 1280,
+        .height = 720,
+        .attribute =
+            {
+                .unknown_0{},
+                .orientation = AlbumImageOrientation::None,
+                .unknown_1{},
+                .unknown_2{},
+                .pad163{},
+            },
+        .pad179{},
+    };

    std::filesystem::path path;
    const auto result = GetFile(path, file_id);
@@ -202,10 +211,19 @@ Result AlbumManager::LoadAlbumScreenShotThumbnail(
        return ResultIsNotMounted;
    }

-    out_image_output = {};
-    out_image_output.width = 320;
-    out_image_output.height = 180;
-    out_image_output.attribute.orientation = AlbumImageOrientation::None;
+    out_image_output = {
+        .width = 320,
+        .height = 180,
+        .attribute =
+            {
+                .unknown_0{},
+                .orientation = AlbumImageOrientation::None,
+                .unknown_1{},
+                .unknown_2{},
+                .pad163{},
+            },
+        .pad179{},
+    };

    std::filesystem::path path;
    const auto result = GetFile(path, file_id);
@@ -73,8 +73,13 @@ void IScreenShotApplicationService::CaptureAndSaveScreenshot(AlbumReportOption r
    Layout::FramebufferLayout layout =
        Layout::DefaultFrameLayout(screenshot_width, screenshot_height);

-    Capture::ScreenShotAttribute attribute{};
-    attribute.orientation = Capture::AlbumImageOrientation::None;
+    const Capture::ScreenShotAttribute attribute{
+        .unknown_0{},
+        .orientation = Capture::AlbumImageOrientation::None,
+        .unknown_1{},
+        .unknown_2{},
+        .pad163{},
+    };

    renderer.RequestScreenshot(
        image_data.data(),
@@ -1,12 +1,8 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

-#include <type_traits>
 #include "common/common_funcs.h"
 #include "common/common_types.h"

@@ -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 2022 yuzu Emulator Project
@@ -6,7 +6,6 @@

 #pragma once

-#include <type_traits>
 #include <fmt/ranges.h>

 #include "common/common_funcs.h"
@@ -8,7 +8,6 @@

 #include <array>
 #include <chrono>
-#include <type_traits>
 #include <fmt/ranges.h>

 #include "common/common_types.h"
@@ -1,13 +1,10 @@
-// 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 <array>
-#include <type_traits>
+
 #include "common/common_types.h"
 #include "core/hle/service/psc/time/common.h"

@@ -7,7 +7,6 @@
 #pragma once

 #include <array>
-#include <type_traits>

 #include "common/bit_field.h"
 #include "common/common_funcs.h"
@@ -1,15 +1,8 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

-#include <cstddef>
-#include <array>
-#include <type_traits>
-
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -6,6 +6,55 @@

 add_library(shader_recompiler STATIC
    backend/bindings.h
+    backend/glasm/emit_glasm.cpp
+    backend/glasm/emit_glasm.h
+    backend/glasm/emit_glasm_barriers.cpp
+    backend/glasm/emit_glasm_bitwise_conversion.cpp
+    backend/glasm/emit_glasm_composite.cpp
+    backend/glasm/emit_glasm_context_get_set.cpp
+    backend/glasm/emit_glasm_control_flow.cpp
+    backend/glasm/emit_glasm_convert.cpp
+    backend/glasm/emit_glasm_floating_point.cpp
+    backend/glasm/emit_glasm_image.cpp
+    backend/glasm/emit_glasm_instructions.h
+    backend/glasm/emit_glasm_integer.cpp
+    backend/glasm/emit_glasm_logical.cpp
+    backend/glasm/emit_glasm_memory.cpp
+    backend/glasm/emit_glasm_not_implemented.cpp
+    backend/glasm/emit_glasm_select.cpp
+    backend/glasm/emit_glasm_shared_memory.cpp
+    backend/glasm/emit_glasm_special.cpp
+    backend/glasm/emit_glasm_undefined.cpp
+    backend/glasm/emit_glasm_warp.cpp
+    backend/glasm/glasm_emit_context.cpp
+    backend/glasm/glasm_emit_context.h
+    backend/glasm/reg_alloc.cpp
+    backend/glasm/reg_alloc.h
+    backend/glsl/emit_glsl.cpp
+    backend/glsl/emit_glsl.h
+    backend/glsl/emit_glsl_atomic.cpp
+    backend/glsl/emit_glsl_barriers.cpp
+    backend/glsl/emit_glsl_bitwise_conversion.cpp
+    backend/glsl/emit_glsl_composite.cpp
+    backend/glsl/emit_glsl_context_get_set.cpp
+    backend/glsl/emit_glsl_control_flow.cpp
+    backend/glsl/emit_glsl_convert.cpp
+    backend/glsl/emit_glsl_floating_point.cpp
+    backend/glsl/emit_glsl_image.cpp
+    backend/glsl/emit_glsl_instructions.h
+    backend/glsl/emit_glsl_integer.cpp
+    backend/glsl/emit_glsl_logical.cpp
+    backend/glsl/emit_glsl_memory.cpp
+    backend/glsl/emit_glsl_not_implemented.cpp
+    backend/glsl/emit_glsl_select.cpp
+    backend/glsl/emit_glsl_shared_memory.cpp
+    backend/glsl/emit_glsl_special.cpp
+    backend/glsl/emit_glsl_undefined.cpp
+    backend/glsl/emit_glsl_warp.cpp
+    backend/glsl/glsl_emit_context.cpp
+    backend/glsl/glsl_emit_context.h
+    backend/glsl/var_alloc.cpp
+    backend/glsl/var_alloc.h
    backend/spirv/emit_spirv.cpp
    backend/spirv/emit_spirv.h
    backend/spirv/emit_spirv_atomic.cpp
@@ -190,60 +239,9 @@ add_library(shader_recompiler STATIC
    program_header.h
    runtime_info.h
    shader_info.h
-    varying_state.h)
+    varying_state.h

-if (ENABLE_OPENGL)
-    target_sources(shader_recompiler PRIVATE
-        backend/glasm/emit_glasm.cpp
-        backend/glasm/emit_glasm.h
-        backend/glasm/emit_glasm_barriers.cpp
-        backend/glasm/emit_glasm_bitwise_conversion.cpp
-        backend/glasm/emit_glasm_composite.cpp
-        backend/glasm/emit_glasm_context_get_set.cpp
-        backend/glasm/emit_glasm_control_flow.cpp
-        backend/glasm/emit_glasm_convert.cpp
-        backend/glasm/emit_glasm_floating_point.cpp
-        backend/glasm/emit_glasm_image.cpp
-        backend/glasm/emit_glasm_instructions.h
-        backend/glasm/emit_glasm_integer.cpp
-        backend/glasm/emit_glasm_logical.cpp
-        backend/glasm/emit_glasm_memory.cpp
-        backend/glasm/emit_glasm_not_implemented.cpp
-        backend/glasm/emit_glasm_select.cpp
-        backend/glasm/emit_glasm_shared_memory.cpp
-        backend/glasm/emit_glasm_special.cpp
-        backend/glasm/emit_glasm_undefined.cpp
-        backend/glasm/emit_glasm_warp.cpp
-        backend/glasm/glasm_emit_context.cpp
-        backend/glasm/glasm_emit_context.h
-        backend/glasm/reg_alloc.cpp
-        backend/glasm/reg_alloc.h
-        backend/glsl/emit_glsl.cpp
-        backend/glsl/emit_glsl.h
-        backend/glsl/emit_glsl_atomic.cpp
-        backend/glsl/emit_glsl_barriers.cpp
-        backend/glsl/emit_glsl_bitwise_conversion.cpp
-        backend/glsl/emit_glsl_composite.cpp
-        backend/glsl/emit_glsl_context_get_set.cpp
-        backend/glsl/emit_glsl_control_flow.cpp
-        backend/glsl/emit_glsl_convert.cpp
-        backend/glsl/emit_glsl_floating_point.cpp
-        backend/glsl/emit_glsl_image.cpp
-        backend/glsl/emit_glsl_instructions.h
-        backend/glsl/emit_glsl_integer.cpp
-        backend/glsl/emit_glsl_logical.cpp
-        backend/glsl/emit_glsl_memory.cpp
-        backend/glsl/emit_glsl_not_implemented.cpp
-        backend/glsl/emit_glsl_select.cpp
-        backend/glsl/emit_glsl_shared_memory.cpp
-        backend/glsl/emit_glsl_special.cpp
-        backend/glsl/emit_glsl_undefined.cpp
-        backend/glsl/emit_glsl_warp.cpp
-        backend/glsl/glsl_emit_context.cpp
-        backend/glsl/glsl_emit_context.h
-        backend/glsl/var_alloc.cpp
-        backend/glsl/var_alloc.h)
-endif()
+)

 target_link_libraries(shader_recompiler PUBLIC common fmt::fmt sirit::sirit)

@@ -553,6 +553,17 @@ void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateIn
    }
 }

+template <typename Descriptors, typename Descriptor, typename Func>
+static u32 Add(Descriptors& descriptors, const Descriptor& desc, Func&& pred) {
+    // TODO: Handle arrays
+    const auto it{std::ranges::find_if(descriptors, pred)};
+    if (it != descriptors.end()) {
+        return static_cast<u32>(std::distance(descriptors.begin(), it));
+    }
+    descriptors.push_back(desc);
+    return static_cast<u32>(descriptors.size()) - 1;
+}
+
 void JoinStorageInfo(Info& base, Info& source) {
    auto& descriptors = base.storage_buffers_descriptors;
    for (auto& desc : source.storage_buffers_descriptors) {
@@ -312,66 +312,10 @@ static inline std::optional<ConstBufferAddr> TrackCached(const IR::Value& v, Env

 std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environment& env, const HostTranslateInfo& host_info);

-bool IsSameConstBufferAddr(const ConstBufferAddr& lhs, const ConstBufferAddr& rhs) {
-    return lhs.index == rhs.index && lhs.offset == rhs.offset &&
-           lhs.shift_left == rhs.shift_left && lhs.secondary_index == rhs.secondary_index &&
-           lhs.secondary_offset == rhs.secondary_offset &&
-           lhs.secondary_shift_left == rhs.secondary_shift_left && lhs.count == rhs.count &&
-           lhs.has_secondary == rhs.has_secondary && lhs.dynamic_offset == rhs.dynamic_offset;
-}
-
-std::optional<ConstBufferAddr> TrackPhi(const IR::Inst* phi, Environment& env,
-                                        const HostTranslateInfo& host_info, bool& ambiguous) {
-    std::optional<ConstBufferAddr> agreed;
-    const size_t num_args{phi->NumArgs()};
-    for (size_t index = 0; index < num_args; ++index) {
-        const IR::Value arg{phi->Arg(index).Resolve()};
-        if (arg.IsImmediate()) {
-            ambiguous = true;
-            return std::nullopt;
-        }
-        const IR::Inst* arg_inst{arg.InstRecursive()};
-        if (arg_inst == phi) {
-            continue;
-        }
-        if (arg_inst->GetOpcode() == IR::Opcode::Phi) {
-            ambiguous = true;
-            return std::nullopt;
-        }
-        const std::optional<ConstBufferAddr> operand{TrackCached(arg, env, host_info)};
-        if (!operand) {
-            ambiguous = true;
-            return std::nullopt;
-        }
-        if (!agreed) {
-            agreed = operand;
-            continue;
-        }
-        if (!IsSameConstBufferAddr(*agreed, *operand)) {
-            ambiguous = true;
-            return std::nullopt;
-        }
-    }
-    if (!agreed) {
-        ambiguous = true;
-    }
-    return agreed;
-}
-
 std::optional<ConstBufferAddr> Track(const IR::Value& value, Environment& env, const HostTranslateInfo& host_info) {
-    bool ambiguous = false;
-    const std::optional<ConstBufferAddr> result{IR::BreadthFirstSearch(
-        value, [&env, &host_info, &ambiguous](const IR::Inst* inst)
-                   -> std::optional<ConstBufferAddr> {
-            if (inst->GetOpcode() == IR::Opcode::Phi) {
-                return TrackPhi(inst, env, host_info, ambiguous);
-            }
-            return TryGetConstBuffer(inst, env, host_info);
-        })};
-    if (ambiguous) {
-        return std::nullopt;
-    }
-    return result;
+    return IR::BreadthFirstSearch(value, [&env, &host_info](const IR::Inst* inst) {
+        return TryGetConstBuffer(inst, env, host_info);
+    });
 }

 std::optional<u32> TryGetConstant(IR::Value& value, Environment& env) {
@@ -20,7 +20,6 @@ add_library(video_core STATIC
    buffer_cache/buffer_cache.h
    buffer_cache/memory_tracker_base.h
    buffer_cache/usage_tracker.h
-    buffer_cache/virtual_range_cache.h
    buffer_cache/word_manager.h
    cache_types.h
    capture.h
@@ -167,8 +166,6 @@ add_library(video_core STATIC
    renderer_vulkan/vk_fence_manager.h
    renderer_vulkan/vk_graphics_pipeline.cpp
    renderer_vulkan/vk_graphics_pipeline.h
-    renderer_vulkan/vk_multi_range_buffer.cpp
-    renderer_vulkan/vk_multi_range_buffer.h
    renderer_vulkan/vk_master_semaphore.cpp
    renderer_vulkan/vk_master_semaphore.h
    renderer_vulkan/vk_pipeline_cache.cpp
@@ -370,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})

@@ -112,11 +112,6 @@ void BufferCache<P>::TickFrame() {
    async_buffers_death_ring.clear();
 }

-template <class P>
-void BufferCache<P>::UnmapGPUMemory(size_t as_id, GPUVAddr gpu_addr, size_t size) {
-    virtual_ranges.Unmap(as_id, gpu_addr, size);
-}
-
 template <class P>
 void BufferCache<P>::WriteMemory(DAddr device_addr, u64 size) {
    if (memory_tracker.IsRegionGpuModified(device_addr, size)) {
@@ -1003,56 +998,11 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
    channel_state->fast_bound_uniform_buffers[stage] &= ~(1u << binding_index);
 }

-template <class P>
-bool BufferCache<P>::BindMultiRangeStorage(const Binding& binding, bool is_written) {
-    if constexpr (requires { runtime.BindMultiRangeStorageBuffer(u64{}); }) {
-        if (binding.gpu_addr == 0 || binding.size == 0) {
-            return false;
-        }
-        if (is_written && !runtime.PrefersSparseSources()) {
-            return false;
-        }
-        const VirtualSegments* segments =
-            virtual_ranges.Query(*gpu_memory, binding.gpu_addr, binding.size);
-        if (!segments || segments->size() < 2) {
-            return false;
-        }
-        const u64 key = (static_cast<u64>(gpu_memory->GetID()) << 48) ^ binding.gpu_addr;
-        const bool prefer_sparse = runtime.PrefersSparseSources();
-        runtime.ResetMultiRange();
-        for (const VirtualSegment& segment : *segments) {
-            const BufferId buffer_id =
-                FindBuffer(segment.device_addr, segment.size, prefer_sparse);
-            if (!buffer_id) {
-                return false;
-            }
-            Buffer& buffer = slot_buffers[buffer_id];
-            TouchBuffer(buffer, buffer_id);
-            if (SynchronizeBuffer(buffer, segment.device_addr, segment.size)) {
-                runtime.InvalidateMultiRange(key);
-            }
-            const u32 offset = buffer.Offset(segment.device_addr);
-            buffer.MarkUsage(offset, segment.size);
-            if (is_written) {
-                MarkWrittenBuffer(buffer_id, segment.device_addr, segment.size);
-            }
-            runtime.PushMultiRangeSource(buffer, offset, segment.size);
-        }
-        return runtime.BindMultiRangeStorageBuffer(key);
-    } else {
-        return false;
-    }
-}
-
 template <class P>
 void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
    u32 binding_index = 0;
    ForEachEnabledBit(channel_state->enabled_storage_buffers[stage], [&](u32 index) {
        const Binding& binding = channel_state->storage_buffers[stage][index];
-        const bool is_written = ((channel_state->written_storage_buffers[stage] >> index) & 1) != 0;
-        if (BindMultiRangeStorage(binding, is_written)) {
-            return;
-        }
        Buffer& buffer = slot_buffers[binding.buffer_id];
        TouchBuffer(buffer, binding.buffer_id);
        const u32 size = binding.size;
@@ -1060,6 +1010,7 @@ void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {

        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);
@@ -1188,11 +1139,6 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
    u32 binding_index = 0;
    ForEachEnabledBit(channel_state->enabled_compute_storage_buffers, [&](u32 index) {
        const Binding& binding = channel_state->compute_storage_buffers[index];
-        const bool is_written =
-            ((channel_state->written_compute_storage_buffers >> index) & 1) != 0;
-        if (BindMultiRangeStorage(binding, is_written)) {
-            return;
-        }
        Buffer& buffer = slot_buffers[binding.buffer_id];
        TouchBuffer(buffer, binding.buffer_id);
        const u32 size = binding.size;
@@ -1200,6 +1146,8 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {

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

        if (is_written) {
            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
@@ -1492,7 +1440,7 @@ void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u3
 }

 template <class P>
-BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size, bool sparse_compatible) {
+BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size) {
    if (device_addr == 0) {
        return NULL_BUFFER_ID;
    }
@@ -1502,18 +1450,10 @@ BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size, bool sparse_com
        Buffer& buffer = slot_buffers[buffer_id];
        WaitForGpuFenceIfNeeded(buffer);
        if (buffer.IsInBounds(device_addr, size)) {
-            bool usable = true;
-            if constexpr (requires { buffer.IsSparseCompatible(); }) {
-                if (sparse_compatible && !buffer.IsSparseCompatible()) {
-                    usable = false;
-                }
-            }
-            if (usable) {
-                return buffer_id;
-            }
+            return buffer_id;
        }
    }
-    return CreateBuffer(device_addr, size, sparse_compatible);
+    return CreateBuffer(device_addr, size);
 }

 template <class P>
@@ -1635,15 +1575,13 @@ void BufferCache<P>::JoinOverlap(BufferId new_buffer_id, BufferId overlap_id,
 }

 template <class P>
-BufferId BufferCache<P>::CreateBuffer(DAddr device_addr, u32 wanted_size,
-                                      bool sparse_compatible) {
+BufferId BufferCache<P>::CreateBuffer(DAddr device_addr, u32 wanted_size) {
    DAddr device_addr_end = Common::AlignUp(device_addr + wanted_size, CACHING_PAGESIZE);
    device_addr = Common::AlignDown(device_addr, CACHING_PAGESIZE);
    wanted_size = static_cast<u32>(device_addr_end - device_addr);
    const OverlapResult overlap = ResolveOverlaps(device_addr, wanted_size);
    const u32 size = static_cast<u32>(overlap.end - overlap.begin);
-    const BufferId new_buffer_id =
-        slot_buffers.insert(runtime, overlap.begin, size, sparse_compatible);
+    const BufferId new_buffer_id = slot_buffers.insert(runtime, overlap.begin, size);
    auto& new_buffer = slot_buffers[new_buffer_id];
    const size_t size_bytes = new_buffer.SizeBytes();
    runtime.ClearBuffer(new_buffer, 0, size_bytes, 0);
@@ -1996,15 +1934,10 @@ Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
    // The end address used for size calculation does not need to be aligned
    const DAddr cpu_end = Common::AlignUp(*device_addr + size, Core::DEVICE_PAGESIZE);

-    u32 binding_size = static_cast<u32>(cpu_end - *aligned_device_addr);
-    if (is_written) {
-        binding_size = aligned_size;
-    }
    const Binding binding{
        .device_addr = *aligned_device_addr,
-        .size = binding_size,
+        .size = is_written ? aligned_size : static_cast<u32>(cpu_end - *aligned_device_addr),
        .buffer_id = BufferId{},
-        .gpu_addr = aligned_gpu_addr,
    };
    return binding;
 }
@@ -29,7 +29,6 @@
 #include "common/settings.h"
 #include "common/slot_vector.h"
 #include "video_core/buffer_cache/buffer_base.h"
-#include "video_core/buffer_cache/virtual_range_cache.h"
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/delayed_destruction_ring.h"
 #include "video_core/dirty_flags.h"
@@ -84,7 +83,6 @@ struct Binding {
    DAddr device_addr{};
    u32 size{};
    BufferId buffer_id;
-    GPUVAddr gpu_addr{};
 };

 struct TextureBufferBinding : Binding {
@@ -217,10 +215,6 @@ public:

    void TickFrame();

-    bool BindMultiRangeStorage(const Binding& binding, bool is_written);
-
-    void UnmapGPUMemory(size_t as_id, GPUVAddr gpu_addr, size_t size);
-
    void WriteMemory(DAddr device_addr, u64 size);

    void CachedWriteMemory(DAddr device_addr, u64 size);
@@ -420,8 +414,7 @@ private:

    void MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size);

-    [[nodiscard]] BufferId FindBuffer(DAddr device_addr, u32 size,
-                                      bool sparse_compatible = false);
+    [[nodiscard]] BufferId FindBuffer(DAddr device_addr, u32 size);

    void WaitForGpuFenceIfNeeded(Buffer& buffer);

@@ -429,8 +422,7 @@ private:

    void JoinOverlap(BufferId new_buffer_id, BufferId overlap_id, bool accumulate_stream_score);

-    [[nodiscard]] BufferId CreateBuffer(DAddr device_addr, u32 wanted_size,
-                                        bool sparse_compatible = false);
+    [[nodiscard]] BufferId CreateBuffer(DAddr device_addr, u32 wanted_size);

    void Register(BufferId buffer_id);

@@ -522,7 +514,6 @@ private:
    };
    Common::LeastRecentlyUsedCache<LRUItemParams> lru_cache;
    u64 frame_tick = 0;
-    VirtualRangeCache virtual_ranges;
    u64 total_used_memory = 0;
    u64 minimum_memory = 0;
    u64 critical_memory = 0;
@@ -1,152 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <atomic>
-#include <limits>
-#include <mutex>
-#include <optional>
-#include <unordered_map>
-#include <vector>
-
-#include <boost/container/small_vector.hpp>
-
-#include "common/common_types.h"
-#include "video_core/memory_manager.h"
-
-namespace VideoCommon {
-
-struct VirtualSegment {
-    GPUVAddr gpu_addr;
-    DAddr device_addr;
-    u32 size;
-};
-
-using VirtualSegments = boost::container::small_vector<VirtualSegment, 8>;
-
-class VirtualRangeCache {
-public:
-    const VirtualSegments* Query(Tegra::MemoryManager& memory, GPUVAddr gpu_addr, u32 size) {
-        if (has_deferred.load(std::memory_order_acquire)) {
-            ApplyDeferred();
-        }
-        const size_t as_id = memory.GetID();
-        const u64 key = MakeKey(as_id, gpu_addr);
-        const auto it = entries.find(key);
-        if (it != entries.end() && it->second.as_id == as_id &&
-            it->second.gpu_addr == gpu_addr && it->second.size == size) {
-            return &it->second.segments;
-        }
-        Entry entry;
-        entry.as_id = as_id;
-        entry.gpu_addr = gpu_addr;
-        entry.size = size;
-        const auto ranges = memory.GetSubmappedRange(gpu_addr, size);
-        for (const auto& [range_addr, range_size] : ranges) {
-            const std::optional<DAddr> device_addr = memory.GpuToCpuAddress(range_addr);
-            if (!device_addr) {
-                break;
-            }
-            u32 segment_size = (std::numeric_limits<u32>::max)();
-            if (range_size < static_cast<size_t>(segment_size)) {
-                segment_size = static_cast<u32>(range_size);
-            }
-            entry.segments.push_back(VirtualSegment{
-                .gpu_addr = range_addr,
-                .device_addr = *device_addr,
-                .size = segment_size,
-            });
-        }
-        const auto result = entries.insert_or_assign(key, std::move(entry));
-        return &result.first->second.segments;
-    }
-
-    void Unmap(size_t as_id, GPUVAddr gpu_addr, u64 size) {
-        if (size == 0) {
-            return;
-        }
-        {
-            std::scoped_lock lock{deferred_mutex};
-            if (!deferred.empty()) {
-                DeferredUnmap& last = deferred.back();
-                if (last.as_id == as_id && last.gpu_addr + last.size == gpu_addr) {
-                    last.size += size;
-                    has_deferred.store(true, std::memory_order_release);
-                    return;
-                }
-            }
-            deferred.push_back(DeferredUnmap{
-                .as_id = as_id,
-                .gpu_addr = gpu_addr,
-                .size = size,
-            });
-        }
-        has_deferred.store(true, std::memory_order_release);
-    }
-
-    void Clear() {
-        {
-            std::scoped_lock lock{deferred_mutex};
-            deferred.clear();
-        }
-        has_deferred.store(false, std::memory_order_release);
-        entries.clear();
-    }
-
-private:
-    struct Entry {
-        size_t as_id{};
-        GPUVAddr gpu_addr{};
-        u32 size{};
-        VirtualSegments segments;
-    };
-
-    struct DeferredUnmap {
-        size_t as_id;
-        GPUVAddr gpu_addr;
-        u64 size;
-    };
-
-    static u64 MakeKey(size_t as_id, GPUVAddr gpu_addr) {
-        return (static_cast<u64>(as_id) << 48) ^ gpu_addr;
-    }
-
-    void ApplyDeferred() {
-        std::vector<DeferredUnmap> pending;
-        {
-            std::scoped_lock lock{deferred_mutex};
-            has_deferred.store(false, std::memory_order_release);
-            pending.swap(deferred);
-        }
-        if (pending.empty() || entries.empty()) {
-            return;
-        }
-        for (auto it = entries.begin(); it != entries.end();) {
-            const Entry& entry = it->second;
-            const GPUVAddr entry_end = entry.gpu_addr + entry.size;
-            bool overlaps = false;
-            for (const DeferredUnmap& unmap : pending) {
-                if (unmap.as_id != entry.as_id) {
-                    continue;
-                }
-                if (entry.gpu_addr < unmap.gpu_addr + unmap.size && unmap.gpu_addr < entry_end) {
-                    overlaps = true;
-                    break;
-                }
-            }
-            if (overlaps) {
-                it = entries.erase(it);
-            } else {
-                ++it;
-            }
-        }
-    }
-
-    std::unordered_map<u64, Entry> entries;
-    std::vector<DeferredUnmap> deferred;
-    std::mutex deferred_mutex;
-    std::atomic<bool> has_deferred{false};
-};
-
-} // namespace VideoCommon
@@ -8,7 +8,6 @@

 #include <array>
 #include <vector>
-#include <type_traits>

 #include "common/bit_field.h"
 #include "common/common_funcs.h"
@@ -1,15 +1,8 @@
-// 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

 #pragma once

-#include <array>
-#include <cstddef>
-#include <type_traits>
-
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -7,7 +7,6 @@
 #pragma once

 #include <memory>
-#include <type_traits>

 #include "common/common_types.h"
 #include "common/scratch_buffer.h"
@@ -52,7 +52,7 @@ constexpr std::array PROGRAM_LUT{
 Buffer::Buffer(BufferCacheRuntime&, VideoCommon::NullBufferParams null_params)
    : VideoCommon::BufferBase(null_params) {}

-Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_, bool)
+Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_)
    : VideoCommon::BufferBase(cpu_addr_, size_bytes_) {
    buffer.Create();
    if (runtime.device.HasDebuggingToolAttached()) {
@@ -23,8 +23,7 @@ class BufferCacheRuntime;

 class Buffer : public VideoCommon::BufferBase {
 public:
-    explicit Buffer(BufferCacheRuntime&, DAddr cpu_addr, u64 size_bytes,
-                    bool sparse_compatible = false);
+    explicit Buffer(BufferCacheRuntime&, DAddr cpu_addr, u64 size_bytes);
    explicit Buffer(BufferCacheRuntime&, VideoCommon::NullBufferParams);

    void ImmediateUpload(size_t offset, std::span<const u8> data) noexcept;
@@ -56,8 +56,7 @@ size_t BytesPerIndex(VkIndexType index_type) {
    }
 }

-vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allocator, u64 size,
-                        VkDeviceSize sparse_alignment) {
+vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allocator, u64 size) {
    VkBufferUsageFlags flags =
        VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
        VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT |
@@ -83,9 +82,6 @@ vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allo
        .queueFamilyIndexCount = 0,
        .pQueueFamilyIndices = nullptr,
    };
-    if (sparse_alignment > 1) {
-        return memory_allocator.CreateBuffer(buffer_ci, MemoryUsage::DeviceLocal, sparse_alignment);
-    }
    return memory_allocator.CreateBuffer(buffer_ci, MemoryUsage::DeviceLocal);
 }
 } // Anonymous namespace
@@ -103,14 +99,10 @@ Buffer::Buffer(BufferCacheRuntime& runtime, VideoCommon::NullBufferParams null_p
    }
 }

-Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_,
-               bool sparse_compatible_)
+Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_)
    : VideoCommon::BufferBase(cpu_addr_, size_bytes_), device{&runtime.device},
      scheduler{&runtime.scheduler},
-      buffer{CreateBuffer(*device, runtime.memory_allocator, SizeBytes(),
-                          runtime.SparseAlignmentFor(sparse_compatible_))},
-      tracker{SizeBytes()} {
-    sparse_compatible = sparse_compatible_;
+      buffer{CreateBuffer(*device, runtime.memory_allocator, SizeBytes())}, tracker{SizeBytes()} {
    if (runtime.device.HasDebuggingToolAttached()) {
        buffer.SetObjectNameEXT(fmt::format("Buffer {:#x}", CpuAddr()).c_str());
    }
@@ -356,8 +348,7 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
    : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
      staging_pool{staging_pool_}, guest_descriptor_queue{guest_descriptor_queue_},
      quad_index_pass(device, scheduler, descriptor_pool, staging_pool,
-                      compute_pass_descriptor_queue),
-      multi_range_buffers(device_, memory_allocator_, scheduler_) {
+                      compute_pass_descriptor_queue) {
    const VkDriverIdKHR driver_id = device.GetDriverID();
    limit_dynamic_storage_buffers = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
                                    driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
@@ -545,33 +536,6 @@ void BufferCacheRuntime::ClearBuffer(VkBuffer dest_buffer, u32 offset, size_t si
    });
 }

-bool BufferCacheRuntime::BindMultiRangeStorageBuffer(u64 key) {
-    if (multi_range_sources.empty() || multi_range_total == 0) {
-        return false;
-    }
-    const MultiRangeRef ref = multi_range_buffers.Get(key, multi_range_sources, multi_range_total);
-    if (ref.handle == VK_NULL_HANDLE) {
-        return false;
-    }
-    if (ref.needs_gather) {
-        PreCopyBarrier();
-        VkDeviceSize dst_offset = 0;
-        for (const MultiRangeSource& source : multi_range_sources) {
-            const std::array<VideoCommon::BufferCopy, 1> copy{VideoCommon::BufferCopy{
-                .src_offset = static_cast<u64>(source.offset),
-                .dst_offset = static_cast<u64>(dst_offset),
-                .size = static_cast<size_t>(source.size),
-            }};
-            CopyBuffer(ref.handle, source.handle, copy, false);
-            dst_offset += source.size;
-        }
-        PostCopyBarrier();
-        multi_range_buffers.MarkGathered(key);
-    }
-    guest_descriptor_queue.AddBuffer(ref.handle, ref.address, 0, ref.size);
-    return true;
-}
-
 void BufferCacheRuntime::BindIndexBuffer(PrimitiveTopology topology, IndexFormat index_format,
                                         u32 base_vertex, u32 num_indices, VkBuffer buffer,
                                         u32 offset, [[maybe_unused]] u32 size) {
@@ -8,14 +8,11 @@

 #include <limits>

-#include <boost/container/small_vector.hpp>
-
 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/buffer_cache/memory_tracker_base.h"
 #include "video_core/buffer_cache/usage_tracker.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_vulkan/vk_compute_pass.h"
-#include "video_core/renderer_vulkan/vk_multi_range_buffer.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/surface.h"
@@ -34,8 +31,7 @@ class BufferCacheRuntime;
 class Buffer : public VideoCommon::BufferBase {
 public:
    explicit Buffer(BufferCacheRuntime&, VideoCommon::NullBufferParams null_params);
-    explicit Buffer(BufferCacheRuntime& runtime, VAddr cpu_addr_, u64 size_bytes_,
-                    bool sparse_compatible_ = false);
+    explicit Buffer(BufferCacheRuntime& runtime, VAddr cpu_addr_, u64 size_bytes_);

    [[nodiscard]] VkBufferView View(u32 offset, u32 size, VideoCore::Surface::PixelFormat format);

@@ -47,14 +43,6 @@ public:
        return device_address;
    }

-    [[nodiscard]] bool IsSparseCompatible() const noexcept {
-        return sparse_compatible;
-    }
-
-    [[nodiscard]] vk::MemoryLocation Location() const noexcept {
-        return buffer.Location();
-    }
-
    [[nodiscard]] bool IsRegionUsed(u64 offset, u64 size) const noexcept {
        return tracker.IsUsed(offset, size);
    }
@@ -89,7 +77,6 @@ private:
    VkDeviceAddress device_address{};
    u64 last_usage_tick{};
    bool is_null{};
-    bool sparse_compatible{};
 };

 class QuadArrayIndexBuffer;
@@ -138,7 +125,7 @@ public:

    void PreCopyBarrier();

-    void CopyBuffer(VkBuffer dst_buffer, VkBuffer src_buffer,
+    void CopyBuffer(VkBuffer src_buffer, VkBuffer dst_buffer,
                    std::span<const VideoCommon::BufferCopy> copies, bool barrier,
                    bool can_reorder_upload = false);

@@ -168,40 +155,6 @@ public:
        return ref.mapped_span;
    }

-    [[nodiscard]] VkDeviceSize SparseAlignmentFor(bool sparse_compatible) const noexcept {
-        if (!sparse_compatible || !multi_range_buffers.UsesSparse()) {
-            return 0;
-        }
-        return multi_range_buffers.BlockSize();
-    }
-
-    [[nodiscard]] bool PrefersSparseSources() const noexcept {
-        return multi_range_buffers.UsesSparse();
-    }
-
-    void ResetMultiRange() noexcept {
-        multi_range_sources.clear();
-        multi_range_total = 0;
-    }
-
-    void PushMultiRangeSource(const Buffer& buffer, u32 offset, u32 size) {
-        const vk::MemoryLocation location = buffer.Location();
-        multi_range_sources.push_back(MultiRangeSource{
-            .handle = buffer.Handle(),
-            .memory = location.memory,
-            .memory_offset = location.offset,
-            .offset = offset,
-            .size = size,
-        });
-        multi_range_total += size;
-    }
-
-    bool BindMultiRangeStorageBuffer(u64 key);
-
-    void InvalidateMultiRange(u64 key) {
-        multi_range_buffers.Invalidate(key);
-    }
-
    void BindUniformBuffer(const Buffer& buffer, u32 offset, u32 size) {
        BindBuffer(buffer, offset, size);
    }
@@ -255,10 +208,6 @@ private:
    std::unique_ptr<Uint8Pass> uint8_pass;
    QuadIndexedPass quad_index_pass;

-    MultiRangeBufferCache multi_range_buffers;
-    boost::container::small_vector<MultiRangeSource, 16> multi_range_sources;
-    VkDeviceSize multi_range_total{};
-
    bool limit_dynamic_storage_buffers = false;
    u32 max_dynamic_storage_buffers = (std::numeric_limits<u32>::max)();
 };
@@ -1,304 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <mutex>
-
-#include "video_core/renderer_vulkan/vk_multi_range_buffer.h"
-#include "video_core/renderer_vulkan/vk_scheduler.h"
-#include "video_core/vulkan_common/vulkan_device.h"
-
-namespace Vulkan {
-
-MultiRangeBufferCache::MultiRangeBufferCache(const Device& device_,
-                                             MemoryAllocator& memory_allocator_,
-                                             Scheduler& scheduler_)
-    : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_} {
-    sparse_usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                   VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-    if (device.IsBufferDeviceAddressSupported()) {
-        sparse_usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
-    }
-    if (!device.IsSparseBindingSupported()) {
-        return;
-    }
-    const VkDeviceSize queried = QueryBlockSize();
-    if (queried == 0) {
-        return;
-    }
-    block_size = queried;
-    use_sparse = true;
-}
-
-MultiRangeBufferCache::~MultiRangeBufferCache() {
-    const VkDevice logical = *device.GetLogical();
-    const auto& dld = device.GetDispatchLoader();
-    for (auto& [key, entry] : entries) {
-        if (entry.sparse_handle != VK_NULL_HANDLE) {
-            dld.vkDestroyBuffer(logical, entry.sparse_handle, nullptr);
-        }
-    }
-    entries.clear();
-    for (const Retired& item : retired) {
-        dld.vkDestroyBuffer(logical, item.handle, nullptr);
-    }
-    retired.clear();
-}
-
-VkDeviceSize MultiRangeBufferCache::QueryBlockSize() const {
-    const VkDevice logical = *device.GetLogical();
-    const auto& dld = device.GetDispatchLoader();
-    const VkBufferCreateInfo probe_ci{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = VK_BUFFER_CREATE_SPARSE_BINDING_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
-        .size = DEFAULT_BLOCK_SIZE,
-        .usage = sparse_usage,
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = nullptr,
-    };
-    VkBuffer probe{};
-    if (dld.vkCreateBuffer(logical, &probe_ci, nullptr, &probe) != VK_SUCCESS) {
-        return 0;
-    }
-    const VkBufferMemoryRequirementsInfo2 reqs_info{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
-        .pNext = nullptr,
-        .buffer = probe,
-    };
-    VkMemoryRequirements2 reqs2{
-        .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
-        .pNext = nullptr,
-        .memoryRequirements = {},
-    };
-    dld.vkGetBufferMemoryRequirements2(logical, &reqs_info, &reqs2);
-    dld.vkDestroyBuffer(logical, probe, nullptr);
-    return reqs2.memoryRequirements.alignment;
-}
-
-u64 MultiRangeBufferCache::HashSources(std::span<const MultiRangeSource> sources) const {
-    u64 hash = 0xcbf29ce484222325ULL;
-    const auto mix = [&hash](u64 value) {
-        hash ^= value;
-        hash *= 0x100000001b3ULL;
-    };
-    for (const MultiRangeSource& source : sources) {
-        mix(reinterpret_cast<u64>(source.handle));
-        mix(static_cast<u64>(source.offset));
-        mix(static_cast<u64>(source.size));
-    }
-    return hash;
-}
-
-bool MultiRangeBufferCache::CanBindSparse(std::span<const MultiRangeSource> sources) const {
-    if (!use_sparse) {
-        return false;
-    }
-    for (const MultiRangeSource& source : sources) {
-        if (source.memory == VK_NULL_HANDLE) {
-            return false;
-        }
-        const VkDeviceSize memory_offset = source.memory_offset + source.offset;
-        if ((memory_offset % block_size) != 0) {
-            return false;
-        }
-        if ((source.size % block_size) != 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
-VkBuffer MultiRangeBufferCache::CreateSparse(std::span<const MultiRangeSource> sources,
-                                             VkDeviceSize total) {
-    const VkDevice logical = *device.GetLogical();
-    const auto& dld = device.GetDispatchLoader();
-    const VkBufferCreateInfo buffer_ci{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = VK_BUFFER_CREATE_SPARSE_BINDING_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
-        .size = total,
-        .usage = sparse_usage,
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = nullptr,
-    };
-    VkBuffer handle{};
-    if (dld.vkCreateBuffer(logical, &buffer_ci, nullptr, &handle) != VK_SUCCESS) {
-        return VK_NULL_HANDLE;
-    }
-    std::vector<VkSparseMemoryBind> binds;
-    binds.reserve(sources.size());
-    VkDeviceSize resource_offset = 0;
-    for (const MultiRangeSource& source : sources) {
-        binds.push_back(VkSparseMemoryBind{
-            .resourceOffset = resource_offset,
-            .size = source.size,
-            .memory = source.memory,
-            .memoryOffset = source.memory_offset + source.offset,
-            .flags = 0,
-        });
-        resource_offset += source.size;
-    }
-    const VkSparseBufferMemoryBindInfo buffer_bind{
-        .buffer = handle,
-        .bindCount = static_cast<u32>(binds.size()),
-        .pBinds = binds.data(),
-    };
-    const VkBindSparseInfo bind_info{
-        .sType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
-        .pNext = nullptr,
-        .waitSemaphoreCount = 0,
-        .pWaitSemaphores = nullptr,
-        .bufferBindCount = 1,
-        .pBufferBinds = &buffer_bind,
-        .imageOpaqueBindCount = 0,
-        .pImageOpaqueBinds = nullptr,
-        .imageBindCount = 0,
-        .pImageBinds = nullptr,
-        .signalSemaphoreCount = 0,
-        .pSignalSemaphores = nullptr,
-    };
-    const VkFenceCreateInfo fence_ci{
-        .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-    };
-    vk::Fence fence = device.GetLogical().CreateFence(fence_ci);
-    VkResult bind_result = VK_ERROR_UNKNOWN;
-    {
-        std::scoped_lock lock{scheduler.submit_mutex};
-        bind_result = device.GetGraphicsQueue().BindSparse(bind_info, *fence);
-    }
-    if (bind_result != VK_SUCCESS) {
-        dld.vkDestroyBuffer(logical, handle, nullptr);
-        return VK_NULL_HANDLE;
-    }
-    fence.Wait();
-    return handle;
-}
-
-void MultiRangeBufferCache::DestroySparse(VkBuffer handle) {
-    if (handle == VK_NULL_HANDLE) {
-        return;
-    }
-    retired.push_back(Retired{
-        .handle = handle,
-        .tick = scheduler.CurrentTick(),
-    });
-}
-
-void MultiRangeBufferCache::DrainRetired() {
-    const VkDevice logical = *device.GetLogical();
-    const auto& dld = device.GetDispatchLoader();
-    size_t index = 0;
-    while (index < retired.size()) {
-        if (scheduler.IsFree(retired[index].tick)) {
-            dld.vkDestroyBuffer(logical, retired[index].handle, nullptr);
-            retired[index] = retired.back();
-            retired.pop_back();
-        } else {
-            ++index;
-        }
-    }
-}
-
-MultiRangeRef MultiRangeBufferCache::Get(u64 key, std::span<const MultiRangeSource> sources,
-                                         VkDeviceSize total) {
-    if (sources.empty() || total == 0) {
-        return MultiRangeRef{};
-    }
-    if (!retired.empty()) {
-        DrainRetired();
-    }
-    const u64 geometry = HashSources(sources);
-    const auto it = entries.find(key);
-    if (it != entries.end() && it->second.geometry == geometry && it->second.size == total) {
-        Entry& entry = it->second;
-        MultiRangeRef ref{
-            .handle = entry.sparse_handle,
-            .address = entry.address,
-            .size = entry.size,
-            .needs_gather = false,
-        };
-        if (entry.sparse_handle == VK_NULL_HANDLE) {
-            ref.handle = *entry.gathered;
-            ref.needs_gather = entry.dirty;
-        }
-        return ref;
-    }
-    if (it != entries.end()) {
-        DestroySparse(it->second.sparse_handle);
-        entries.erase(it);
-    }
-
-    Entry entry;
-    entry.geometry = geometry;
-    entry.size = total;
-    if (CanBindSparse(sources)) {
-        entry.sparse_handle = CreateSparse(sources, total);
-    }
-    if (entry.sparse_handle == VK_NULL_HANDLE) {
-        VkBufferUsageFlags flags = VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
-                                   VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                                   VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-        if (device.IsBufferDeviceAddressSupported()) {
-            flags |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
-        }
-        const VkBufferCreateInfo gather_ci{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0,
-            .size = total,
-            .usage = flags,
-            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-            .queueFamilyIndexCount = 0,
-            .pQueueFamilyIndices = nullptr,
-        };
-        entry.gathered = memory_allocator.CreateBuffer(gather_ci, MemoryUsage::DeviceLocal);
-        entry.dirty = true;
-    }
-    if (device.IsBufferDeviceAddressSupported()) {
-        VkBuffer address_handle = entry.sparse_handle;
-        if (address_handle == VK_NULL_HANDLE) {
-            address_handle = *entry.gathered;
-        }
-        entry.address = device.GetLogical().GetBufferDeviceAddress(address_handle);
-    }
-
-    MultiRangeRef ref{
-        .handle = entry.sparse_handle,
-        .address = entry.address,
-        .size = entry.size,
-        .needs_gather = false,
-    };
-    if (entry.sparse_handle == VK_NULL_HANDLE) {
-        ref.handle = *entry.gathered;
-        ref.needs_gather = true;
-    }
-    entries.emplace(key, std::move(entry));
-    return ref;
-}
-
-void MultiRangeBufferCache::MarkGathered(u64 key) {
-    const auto it = entries.find(key);
-    if (it != entries.end()) {
-        it->second.dirty = false;
-    }
-}
-
-void MultiRangeBufferCache::Invalidate(u64 key) {
-    const auto it = entries.find(key);
-    if (it != entries.end()) {
-        it->second.dirty = true;
-    }
-}
-
-void MultiRangeBufferCache::Clear() {
-    for (auto& [key, entry] : entries) {
-        DestroySparse(entry.sparse_handle);
-    }
-    entries.clear();
-}
-
-} // namespace Vulkan
@@ -1,100 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <span>
-#include <unordered_map>
-#include <vector>
-
-#include "common/common_types.h"
-#include "video_core/vulkan_common/vulkan_memory_allocator.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-
-namespace Vulkan {
-
-class Device;
-class Scheduler;
-
-struct MultiRangeSource {
-    VkBuffer handle{};
-    VkDeviceMemory memory{};
-    VkDeviceSize memory_offset{};
-    VkDeviceSize offset{};
-    VkDeviceSize size{};
-};
-
-struct MultiRangeRef {
-    VkBuffer handle{};
-    VkDeviceAddress address{};
-    VkDeviceSize size{};
-    bool needs_gather{};
-};
-
-class MultiRangeBufferCache final {
-public:
-    static constexpr VkDeviceSize DEFAULT_BLOCK_SIZE = 64 * 1024;
-
-    explicit MultiRangeBufferCache(const Device& device_, MemoryAllocator& memory_allocator_,
-                                   Scheduler& scheduler_);
-    ~MultiRangeBufferCache();
-
-    MultiRangeBufferCache(const MultiRangeBufferCache&) = delete;
-    MultiRangeBufferCache& operator=(const MultiRangeBufferCache&) = delete;
-
-    [[nodiscard]] bool UsesSparse() const noexcept {
-        return use_sparse;
-    }
-
-    [[nodiscard]] VkDeviceSize BlockSize() const noexcept {
-        return block_size;
-    }
-
-    [[nodiscard]] MultiRangeRef Get(u64 key, std::span<const MultiRangeSource> sources,
-                                    VkDeviceSize total);
-
-    void MarkGathered(u64 key);
-
-    void Invalidate(u64 key);
-
-    void Clear();
-
-private:
-    struct Retired {
-        VkBuffer handle{};
-        u64 tick{};
-    };
-
-    struct Entry {
-        vk::Buffer gathered;
-        VkBuffer sparse_handle{};
-        VkDeviceAddress address{};
-        VkDeviceSize size{};
-        u64 geometry{};
-        bool dirty{true};
-    };
-
-    [[nodiscard]] u64 HashSources(std::span<const MultiRangeSource> sources) const;
-
-    [[nodiscard]] bool CanBindSparse(std::span<const MultiRangeSource> sources) const;
-
-    [[nodiscard]] VkBuffer CreateSparse(std::span<const MultiRangeSource> sources,
-                                        VkDeviceSize total);
-
-    [[nodiscard]] VkDeviceSize QueryBlockSize() const;
-
-    void DestroySparse(VkBuffer handle);
-
-    void DrainRetired();
-
-    const Device& device;
-    MemoryAllocator& memory_allocator;
-    Scheduler& scheduler;
-    bool use_sparse{};
-    VkDeviceSize block_size{DEFAULT_BLOCK_SIZE};
-    VkBufferUsageFlags sparse_usage{};
-    std::unordered_map<u64, Entry> entries;
-    std::vector<Retired> retired;
-};
-
-} // namespace Vulkan
@@ -338,7 +338,7 @@ void PresentManager::PresentThread(std::stop_token token) {
            // By exchanging the lock ownership we take the swapchain lock
            // before the queue lock goes out of scope. This way the swapchain
            // lock in WaitPresent is guaranteed to occur after here.
-            void(std::exchange(lock, std::unique_lock{swapchain_mutex}));
+            std::exchange(lock, std::unique_lock{swapchain_mutex});
            CopyToSwapchain(frame);

            // Free the frame for reuse
@@ -819,7 +819,6 @@ void RasterizerVulkan::ModifyGPUMemory(size_t as_id, GPUVAddr addr, u64 size) {
        std::scoped_lock lock{texture_cache.mutex};
        texture_cache.UnmapGPUMemory(as_id, addr, size);
    }
-    buffer_cache.UnmapGPUMemory(as_id, addr, size);
 }

 void RasterizerVulkan::SignalFence(std::function<void()>&& func) {
@@ -300,7 +300,7 @@ void Scheduler::WorkerThread(std::stop_token stop_token) {
            // Exchange lock ownership so that we take the execution lock before
            // the queue lock goes out of scope. This allows us to force execution
            // to complete in the next step.
-            void(std::exchange(lk, std::unique_lock{execution_mutex}));
+            std::exchange(lk, std::unique_lock{execution_mutex});

            // Perform the work, tracking whether the chunk was a submission
            // before executing.
@@ -1570,8 +1570,6 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
    }
    if (graphics) {
        graphics_family = *graphics;
-        graphics_family_sparse_binding =
-            (queue_family_properties[*graphics].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) != 0;
    }
    if (present) {
        present_family = *present;
@@ -317,10 +317,6 @@ public:
        return properties.driver.driverID;
    }

-    bool IsSparseBindingSupported() const {
-        return features.features.sparseBinding && graphics_family_sparse_binding;
-    }
-
    /// Returns true for tile-based deferred renderers.
    bool IsTiler() const {
        switch (GetDriverID()) {
@@ -1150,7 +1146,6 @@ private:
    bool owns_static_pipeline_cache{};
    u32 instance_version{};      ///< Vulkan instance version.
    u32 graphics_family{};       ///< Main graphics queue family index.
-    bool graphics_family_sparse_binding{};
    u32 present_family{};        ///< Main present queue family index.

    struct Extensions {
@@ -26,408 +26,350 @@
 #include "common/settings.h"

 namespace Vulkan {
-namespace {
+    namespace {

 // Helpers translating MemoryUsage to flags/usage

-    [[maybe_unused]] VkMemoryPropertyFlags MemoryUsagePropertyFlags(MemoryUsage usage) {
-        switch (usage) {
-            case MemoryUsage::DeviceLocal:
-                return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
-            case MemoryUsage::Upload:
-                return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-                        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
-            case MemoryUsage::Download:
-                return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-                        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
-                        VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
-            case MemoryUsage::Stream:
-                return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
-                        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-                        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+        [[maybe_unused]] VkMemoryPropertyFlags MemoryUsagePropertyFlags(MemoryUsage usage) {
+            switch (usage) {
+                case MemoryUsage::DeviceLocal:
+                    return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+                case MemoryUsage::Upload:
+                    return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                           VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+                case MemoryUsage::Download:
+                    return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                           VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+                           VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+                case MemoryUsage::Stream:
+                    return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
+                           VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                           VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+            }
+            ASSERT_MSG(false, "Invalid memory usage={}", usage);
+            return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        }
-        ASSERT_MSG(false, "Invalid memory usage={}", usage);
-        return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
-    }

-    [[nodiscard]] VkMemoryPropertyFlags MemoryUsagePreferredVmaFlags(MemoryUsage usage) {
-        if (usage == MemoryUsage::Download) {
-            return VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+        [[nodiscard]] VkMemoryPropertyFlags MemoryUsagePreferredVmaFlags(MemoryUsage usage) {
+            if (usage == MemoryUsage::Download) {
+                return VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+            }
+            return usage != MemoryUsage::DeviceLocal ? VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
+                                                     : VkMemoryPropertyFlagBits{};
        }
-        return usage != MemoryUsage::DeviceLocal ? VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
-                                                    : VkMemoryPropertyFlagBits{};
-    }

-    [[nodiscard]] VmaAllocationCreateFlags MemoryUsageVmaFlags(MemoryUsage usage) {
-        switch (usage) {
-            case MemoryUsage::Upload:
-            case MemoryUsage::Stream:
-                return VMA_ALLOCATION_CREATE_MAPPED_BIT |
-                        VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
-            case MemoryUsage::Download:
-                return VMA_ALLOCATION_CREATE_MAPPED_BIT |
-                        VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT;
-            case MemoryUsage::DeviceLocal:
-                return {};
+        [[nodiscard]] VmaAllocationCreateFlags MemoryUsageVmaFlags(MemoryUsage usage) {
+            switch (usage) {
+                case MemoryUsage::Upload:
+                case MemoryUsage::Stream:
+                    return VMA_ALLOCATION_CREATE_MAPPED_BIT |
+                           VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
+                case MemoryUsage::Download:
+                    return VMA_ALLOCATION_CREATE_MAPPED_BIT |
+                           VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT;
+                case MemoryUsage::DeviceLocal:
+                    return {};
+            }
+            return {};
        }
-        return {};
-    }

-    [[nodiscard]] VmaMemoryUsage MemoryUsageVma(MemoryUsage usage) {
-        switch (usage) {
-            case MemoryUsage::DeviceLocal:
-            case MemoryUsage::Stream:
-                return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
-            case MemoryUsage::Upload:
-            case MemoryUsage::Download:
-                return VMA_MEMORY_USAGE_AUTO_PREFER_HOST;
+        [[nodiscard]] VmaMemoryUsage MemoryUsageVma(MemoryUsage usage) {
+            switch (usage) {
+                case MemoryUsage::DeviceLocal:
+                case MemoryUsage::Stream:
+                    return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
+                case MemoryUsage::Upload:
+                case MemoryUsage::Download:
+                    return VMA_MEMORY_USAGE_AUTO_PREFER_HOST;
+            }
+            return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
        }
-        return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
-    }
-} // namespace
+
+
+// This avoids calling vkGetBufferMemoryRequirements* directly.
+        template<typename T>
+        static VkBuffer GetVkHandleFromBuffer(const T &buf) {
+            if constexpr (requires { static_cast<VkBuffer>(buf); }) {
+                return static_cast<VkBuffer>(buf);
+            } else if constexpr (requires {{ buf.GetHandle() } -> std::convertible_to<VkBuffer>; }) {
+                return buf.GetHandle();
+            } else if constexpr (requires {{ buf.Handle() } -> std::convertible_to<VkBuffer>; }) {
+                return buf.Handle();
+            } else if constexpr (requires {{ buf.vk_handle() } -> std::convertible_to<VkBuffer>; }) {
+                return buf.vk_handle();
+            } else {
+                static_assert(sizeof(T) == 0, "Cannot extract VkBuffer handle from vk::Buffer");
+                return VK_NULL_HANDLE;
+            }
+        }
+
+    } // namespace

 //MemoryCommit is now VMA-backed
-MemoryCommit::MemoryCommit(VmaAllocator alloc, VmaAllocation a,
-                            const VmaAllocationInfo &info) noexcept
-        : allocator{alloc}, allocation{a}, memory{info.deviceMemory},
-            offset{info.offset}, size{info.size}, mapped_ptr{info.pMappedData} {
-    // Log GPU memory allocation
-    if (GPU::Logging::IsActive() &&
-        Settings::values.gpu_log_memory_tracking.GetValue()) {
-        GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
-            reinterpret_cast<uintptr_t>(memory),
-            static_cast<u64>(size),
-            0  // Memory property flags (not easily available from VMA)
-        );
-    }
-}
-
-MemoryCommit::~MemoryCommit() { Release(); }
-
-MemoryCommit::MemoryCommit(MemoryCommit &&rhs) noexcept
-        : allocator{std::exchange(rhs.allocator, nullptr)},
-            allocation{std::exchange(rhs.allocation, nullptr)},
-            memory{std::exchange(rhs.memory, VK_NULL_HANDLE)},
-            offset{std::exchange(rhs.offset, 0)},
-            size{std::exchange(rhs.size, 0)},
-            mapped_ptr{std::exchange(rhs.mapped_ptr, nullptr)} {}
-
-MemoryCommit &MemoryCommit::operator=(MemoryCommit &&rhs) noexcept {
-    if (this != &rhs) {
-        Release();
-        allocator = std::exchange(rhs.allocator, nullptr);
-        allocation = std::exchange(rhs.allocation, nullptr);
-        memory = std::exchange(rhs.memory, VK_NULL_HANDLE);
-        offset = std::exchange(rhs.offset, 0);
-        size = std::exchange(rhs.size, 0);
-        mapped_ptr = std::exchange(rhs.mapped_ptr, nullptr);
-    }
-    return *this;
-}
-
-std::span<u8> MemoryCommit::Map()
-{
-    if (!allocation) return {};
-    if (!mapped_ptr) {
-        if (vmaMapMemory(allocator, allocation, &mapped_ptr) != VK_SUCCESS) return {};
-    }
-    const size_t n = static_cast<size_t>(std::min<VkDeviceSize>(size,
-                                                                (std::numeric_limits<size_t>::max)()));
-    return std::span<u8>{static_cast<u8 *>(mapped_ptr), n};
-}
-
-std::span<const u8> MemoryCommit::Map() const
-{
-    if (!allocation) return {};
-    if (!mapped_ptr) {
-        void *p = nullptr;
-        if (vmaMapMemory(allocator, allocation, &p) != VK_SUCCESS) return {};
-        const_cast<MemoryCommit *>(this)->mapped_ptr = p;
-    }
-    const size_t n = static_cast<size_t>(std::min<VkDeviceSize>(size,
-                                                                (std::numeric_limits<size_t>::max)()));
-    return std::span<const u8>{static_cast<const u8 *>(mapped_ptr), n};
-}
-
-void MemoryCommit::Unmap()
-{
-    if (allocation && mapped_ptr) {
-        vmaUnmapMemory(allocator, allocation);
-        mapped_ptr = nullptr;
-    }
-}
-
-void MemoryCommit::Release() {
-    if (allocation && allocator) {
-        // Log GPU memory deallocation
+    MemoryCommit::MemoryCommit(VmaAllocator alloc, VmaAllocation a,
+                               const VmaAllocationInfo &info) noexcept
+            : allocator{alloc}, allocation{a}, memory{info.deviceMemory},
+              offset{info.offset}, size{info.size}, mapped_ptr{info.pMappedData} {
+        // Log GPU memory allocation
        if (GPU::Logging::IsActive() &&
-            Settings::values.gpu_log_memory_tracking.GetValue() &&
-            memory != VK_NULL_HANDLE) {
-            GPU::Logging::GPULogger::GetInstance().LogMemoryDeallocation(
-                reinterpret_cast<uintptr_t>(memory)
+            Settings::values.gpu_log_memory_tracking.GetValue()) {
+            GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
+                reinterpret_cast<uintptr_t>(memory),
+                static_cast<u64>(size),
+                0  // Memory property flags (not easily available from VMA)
            );
        }
+    }

-        if (mapped_ptr) {
+    MemoryCommit::~MemoryCommit() { Release(); }
+
+    MemoryCommit::MemoryCommit(MemoryCommit &&rhs) noexcept
+            : allocator{std::exchange(rhs.allocator, nullptr)},
+              allocation{std::exchange(rhs.allocation, nullptr)},
+              memory{std::exchange(rhs.memory, VK_NULL_HANDLE)},
+              offset{std::exchange(rhs.offset, 0)},
+              size{std::exchange(rhs.size, 0)},
+              mapped_ptr{std::exchange(rhs.mapped_ptr, nullptr)} {}
+
+    MemoryCommit &MemoryCommit::operator=(MemoryCommit &&rhs) noexcept {
+        if (this != &rhs) {
+            Release();
+            allocator = std::exchange(rhs.allocator, nullptr);
+            allocation = std::exchange(rhs.allocation, nullptr);
+            memory = std::exchange(rhs.memory, VK_NULL_HANDLE);
+            offset = std::exchange(rhs.offset, 0);
+            size = std::exchange(rhs.size, 0);
+            mapped_ptr = std::exchange(rhs.mapped_ptr, nullptr);
+        }
+        return *this;
+    }
+
+    std::span<u8> MemoryCommit::Map()
+    {
+        if (!allocation) return {};
+        if (!mapped_ptr) {
+            if (vmaMapMemory(allocator, allocation, &mapped_ptr) != VK_SUCCESS) return {};
+        }
+        const size_t n = static_cast<size_t>(std::min<VkDeviceSize>(size,
+                                                                    (std::numeric_limits<size_t>::max)()));
+        return std::span<u8>{static_cast<u8 *>(mapped_ptr), n};
+    }
+
+    std::span<const u8> MemoryCommit::Map() const
+    {
+        if (!allocation) return {};
+        if (!mapped_ptr) {
+            void *p = nullptr;
+            if (vmaMapMemory(allocator, allocation, &p) != VK_SUCCESS) return {};
+            const_cast<MemoryCommit *>(this)->mapped_ptr = p;
+        }
+        const size_t n = static_cast<size_t>(std::min<VkDeviceSize>(size,
+                                                                    (std::numeric_limits<size_t>::max)()));
+        return std::span<const u8>{static_cast<const u8 *>(mapped_ptr), n};
+    }
+
+    void MemoryCommit::Unmap()
+    {
+        if (allocation && mapped_ptr) {
            vmaUnmapMemory(allocator, allocation);
            mapped_ptr = nullptr;
        }
-        vmaFreeMemory(allocator, allocation);
    }
-    allocation = nullptr;
-    allocator = nullptr;
-    memory = VK_NULL_HANDLE;
-    offset = 0;
-    size = 0;
-}

-MemoryAllocator::MemoryAllocator(const Device &device_)
-        : device{device_}, allocator{device.GetAllocator()},
-            properties{device_.GetPhysical().GetMemoryProperties().memoryProperties},
-            buffer_image_granularity{
-                    device_.GetPhysical().GetProperties().limits.bufferImageGranularity} {
+    void MemoryCommit::Release() {
+        if (allocation && allocator) {
+            // Log GPU memory deallocation
+            if (GPU::Logging::IsActive() &&
+                Settings::values.gpu_log_memory_tracking.GetValue() &&
+                memory != VK_NULL_HANDLE) {
+                GPU::Logging::GPULogger::GetInstance().LogMemoryDeallocation(
+                    reinterpret_cast<uintptr_t>(memory)
+                );
+            }

-    // Preserve the previous "RenderDoc small heap" trimming behavior that we had in original vma minus the heap bug
-    if (device.HasDebuggingToolAttached())
-    {
-        using namespace Common::Literals;
-        ForEachDeviceLocalHostVisibleHeap(device, [this](size_t heap_idx, VkMemoryHeap &heap) {
-            if (heap.size <= 256_MiB) {
-                for (u32 t = 0; t < properties.memoryTypeCount; ++t) {
-                    if (properties.memoryTypes[t].heapIndex == heap_idx) {
-                        valid_memory_types &= ~(1u << t);
+            if (mapped_ptr) {
+                vmaUnmapMemory(allocator, allocation);
+                mapped_ptr = nullptr;
+            }
+            vmaFreeMemory(allocator, allocation);
+        }
+        allocation = nullptr;
+        allocator = nullptr;
+        memory = VK_NULL_HANDLE;
+        offset = 0;
+        size = 0;
+    }
+
+    MemoryAllocator::MemoryAllocator(const Device &device_)
+            : device{device_}, allocator{device.GetAllocator()},
+              properties{device_.GetPhysical().GetMemoryProperties().memoryProperties},
+              buffer_image_granularity{
+                      device_.GetPhysical().GetProperties().limits.bufferImageGranularity} {
+
+        // Preserve the previous "RenderDoc small heap" trimming behavior that we had in original vma minus the heap bug
+        if (device.HasDebuggingToolAttached())
+        {
+            using namespace Common::Literals;
+            ForEachDeviceLocalHostVisibleHeap(device, [this](size_t heap_idx, VkMemoryHeap &heap) {
+                if (heap.size <= 256_MiB) {
+                    for (u32 t = 0; t < properties.memoryTypeCount; ++t) {
+                        if (properties.memoryTypes[t].heapIndex == heap_idx) {
+                            valid_memory_types &= ~(1u << t);
+                        }
                    }
                }
-            }
-        });
+            });
+        }
    }
-}

-MemoryAllocator::~MemoryAllocator() = default;
+    MemoryAllocator::~MemoryAllocator() = default;

-vk::Image MemoryAllocator::CreateImage(const VkImageCreateInfo &ci) const
-{
-    const VmaAllocationCreateInfo alloc_ci = {
-            .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT,
-            .usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE,
+    vk::Image MemoryAllocator::CreateImage(const VkImageCreateInfo &ci) const
+    {
+        const VmaAllocationCreateInfo alloc_ci = {
+                .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT,
+                .usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE,
+                .requiredFlags = 0,
+                .preferredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+                .memoryTypeBits = 0,
+                .pool = VK_NULL_HANDLE,
+                .pUserData = nullptr,
+                .priority = 0.f,
+        };
+
+        VkImage handle{};
+        VmaAllocation allocation{};
+        VmaAllocationInfo alloc_info{};
+        vk::Check(vmaCreateImage(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info));
+
+        // Log GPU memory allocation for images
+        if (GPU::Logging::IsActive() &&
+            Settings::values.gpu_log_memory_tracking.GetValue()) {
+            GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
+                reinterpret_cast<uintptr_t>(alloc_info.deviceMemory),
+                static_cast<u64>(alloc_info.size),
+                VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
+            );
+        }
+
+        return vk::Image(handle, ci.usage, *device.GetLogical(), allocator, allocation,
+                         device.GetDispatchLoader());
+    }
+
+    vk::Buffer MemoryAllocator::CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage) const {
+        // MESA will do memcpy() if not marked as host cached, so just force mark it for most buffers
+        auto const anv_flags = (usage == MemoryUsage::Stream
+            && device.GetDriverID() == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA)
+            ? VK_MEMORY_PROPERTY_HOST_CACHED_BIT : 0;
+        const VmaAllocationCreateInfo alloc_ci = {
+            .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage),
+            .usage = MemoryUsageVma(usage),
            .requiredFlags = 0,
-            .preferredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
-            .memoryTypeBits = 0,
+            .preferredFlags = MemoryUsagePreferredVmaFlags(usage) | anv_flags,
+            .memoryTypeBits = usage == MemoryUsage::Stream ? 0u : valid_memory_types,
            .pool = VK_NULL_HANDLE,
            .pUserData = nullptr,
            .priority = 0.f,
-    };
+        };

-    VkImage handle{};
-    VmaAllocation allocation{};
-    VmaAllocationInfo alloc_info{};
-    vk::Check(vmaCreateImage(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info));
+        VkBuffer handle{};
+        VmaAllocationInfo alloc_info{};
+        VmaAllocation allocation{};
+        VkMemoryPropertyFlags property_flags{};

-    // Log GPU memory allocation for images
-    if (GPU::Logging::IsActive() &&
-        Settings::values.gpu_log_memory_tracking.GetValue()) {
-        GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
-            reinterpret_cast<uintptr_t>(alloc_info.deviceMemory),
-            static_cast<u64>(alloc_info.size),
-            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
-        );
+        vk::Check(vmaCreateBuffer(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info));
+        vmaGetAllocationMemoryProperties(allocator, allocation, &property_flags);
+
+        // Log GPU memory allocation for buffers
+        if (GPU::Logging::IsActive() &&
+            Settings::values.gpu_log_memory_tracking.GetValue()) {
+            GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
+                reinterpret_cast<uintptr_t>(alloc_info.deviceMemory),
+                static_cast<u64>(alloc_info.size),
+                property_flags
+            );
+        }
+
+        u8 *data = reinterpret_cast<u8 *>(alloc_info.pMappedData);
+        const std::span<u8> mapped_data = data ? std::span<u8>{data, ci.size} : std::span<u8>{};
+        const bool is_coherent = (property_flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
+
+        return vk::Buffer(handle, *device.GetLogical(), allocator, allocation, mapped_data,
+                          is_coherent,
+                          device.GetDispatchLoader());
    }

-    return vk::Image(handle, ci.usage, *device.GetLogical(), allocator, allocation,
-                        device.GetDispatchLoader());
-}
+    MemoryCommit MemoryAllocator::Commit(const VkMemoryRequirements &reqs, MemoryUsage usage)
+    {
+        const auto vma_usage = MemoryUsageVma(usage);
+        VmaAllocationCreateInfo ci{};
+        ci.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage);
+        ci.usage = vma_usage;
+        ci.memoryTypeBits = reqs.memoryTypeBits & valid_memory_types;
+        ci.requiredFlags = 0;
+        ci.preferredFlags = MemoryUsagePreferredVmaFlags(usage);

-vk::Buffer MemoryAllocator::CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage) const {
-    // MESA will do memcpy() if not marked as host cached, so just force mark it for most buffers
-    auto const anv_flags = (usage == MemoryUsage::Stream
-        && device.GetDriverID() == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA)
-        ? VK_MEMORY_PROPERTY_HOST_CACHED_BIT : 0;
-    const VmaAllocationCreateInfo alloc_ci = {
-        .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage),
-        .usage = MemoryUsageVma(usage),
-        .requiredFlags = 0,
-        .preferredFlags = MemoryUsagePreferredVmaFlags(usage) | anv_flags,
-        .memoryTypeBits = usage == MemoryUsage::Stream ? 0u : valid_memory_types,
-        .pool = VK_NULL_HANDLE,
-        .pUserData = nullptr,
-        .priority = 0.f,
-    };
+        VmaAllocation a{};
+        VmaAllocationInfo info{};

-    VkBuffer handle{};
-    VmaAllocationInfo alloc_info{};
-    VmaAllocation allocation{};
-    VkMemoryPropertyFlags property_flags{};
+        VkResult res = vmaAllocateMemory(allocator, &reqs, &ci, &a, &info);

-    vk::Check(vmaCreateBuffer(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info));
-    vmaGetAllocationMemoryProperties(allocator, allocation, &property_flags);
+        if (res != VK_SUCCESS) {
+            // Relax 1: drop budget constraint
+            auto ci2 = ci;
+            ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT;
+            res = vmaAllocateMemory(allocator, &reqs, &ci2, &a, &info);

-    // Log GPU memory allocation for buffers
-    if (GPU::Logging::IsActive() &&
-        Settings::values.gpu_log_memory_tracking.GetValue()) {
-        GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(
-            reinterpret_cast<uintptr_t>(alloc_info.deviceMemory),
-            static_cast<u64>(alloc_info.size),
-            property_flags
-        );
-    }
+            // Relax 2: if we preferred DEVICE_LOCAL, drop that preference
+            if (res != VK_SUCCESS && (ci.preferredFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) {
+                auto ci3 = ci2;
+                ci3.preferredFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+                res = vmaAllocateMemory(allocator, &reqs, &ci3, &a, &info);
+            }
+        }

-    u8 *data = reinterpret_cast<u8 *>(alloc_info.pMappedData);
-    const std::span<u8> mapped_data = data ? std::span<u8>{data, ci.size} : std::span<u8>{};
-    const bool is_coherent = (property_flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
-
-    return vk::Buffer(handle, *device.GetLogical(), allocator, allocation, mapped_data,
-                        is_coherent,
-                        device.GetDispatchLoader());
-}
-
-vk::Buffer MemoryAllocator::CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage,
-                                         VkDeviceSize min_alignment) const {
-    if (min_alignment <= 1) {
-        return CreateBuffer(ci, usage);
-    }
-    VkMemoryPropertyFlags anv_flags = 0;
-    if (usage == MemoryUsage::Stream &&
-        device.GetDriverID() == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA) {
-        anv_flags = VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
-    }
-    u32 memory_type_bits = valid_memory_types;
-    if (usage == MemoryUsage::Stream) {
-        memory_type_bits = 0u;
-    }
-    const VmaAllocationCreateInfo alloc_ci = {
-        .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage),
-        .usage = MemoryUsageVma(usage),
-        .requiredFlags = 0,
-        .preferredFlags = MemoryUsagePreferredVmaFlags(usage) | anv_flags,
-        .memoryTypeBits = memory_type_bits,
-        .pool = VK_NULL_HANDLE,
-        .pUserData = nullptr,
-        .priority = 0.f,
-    };
-
-    const VkDevice logical = *device.GetLogical();
-    const auto &dld = device.GetDispatchLoader();
-
-    VkBuffer handle{};
-    vk::Check(dld.vkCreateBuffer(logical, &ci, nullptr, &handle));
-
-    const VkBufferMemoryRequirementsInfo2 reqs_info{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
-        .pNext = nullptr,
-        .buffer = handle,
-    };
-    VkMemoryRequirements2 reqs2{
-        .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
-        .pNext = nullptr,
-        .memoryRequirements = {},
-    };
-    dld.vkGetBufferMemoryRequirements2(logical, &reqs_info, &reqs2);
-
-    VkMemoryRequirements reqs = reqs2.memoryRequirements;
-    reqs.alignment = (std::max)(reqs.alignment, min_alignment);
-    reqs.memoryTypeBits &= alloc_ci.memoryTypeBits;
-
-    VmaAllocation allocation{};
-    VmaAllocationInfo alloc_info{};
-    VkResult res = vmaAllocateMemory(allocator, &reqs, &alloc_ci, &allocation, &alloc_info);
-    if (res != VK_SUCCESS) {
-        auto relaxed = alloc_ci;
-        relaxed.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT;
-        res = vmaAllocateMemory(allocator, &reqs, &relaxed, &allocation, &alloc_info);
-    }
-    if (res != VK_SUCCESS) {
-        dld.vkDestroyBuffer(logical, handle, nullptr);
        vk::Check(res);
-    }
-    const VkResult bind_res = vmaBindBufferMemory(allocator, allocation, handle);
-    if (bind_res != VK_SUCCESS) {
-        vmaFreeMemory(allocator, allocation);
-        dld.vkDestroyBuffer(logical, handle, nullptr);
-        vk::Check(bind_res);
+        return MemoryCommit(allocator, a, info);
    }

-    VkMemoryPropertyFlags property_flags{};
-    vmaGetAllocationMemoryProperties(allocator, allocation, &property_flags);
+    MemoryCommit MemoryAllocator::Commit(const vk::Buffer &buffer, MemoryUsage usage) {
+        // Allocate memory appropriate for this buffer automatically
+        const auto vma_usage = MemoryUsageVma(usage);

-    u8 *data = reinterpret_cast<u8 *>(alloc_info.pMappedData);
-    std::span<u8> mapped_data{};
-    if (data) {
-        mapped_data = std::span<u8>{data, ci.size};
-    }
-    const bool is_coherent = (property_flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
+        VmaAllocationCreateInfo ci{};
+        ci.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage);
+        ci.usage = vma_usage;
+        ci.requiredFlags = 0;
+        ci.preferredFlags = MemoryUsagePreferredVmaFlags(usage);
+        ci.pool = VK_NULL_HANDLE;
+        ci.pUserData = nullptr;
+        ci.priority = 0.0f;

-    return vk::Buffer(handle, logical, allocator, allocation, mapped_data, is_coherent, dld);
-}
+        const VkBuffer raw = *buffer;

-MemoryCommit MemoryAllocator::Commit(const VkMemoryRequirements &reqs, MemoryUsage usage)
-{
-    const auto vma_usage = MemoryUsageVma(usage);
-    VmaAllocationCreateInfo ci{};
-    ci.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage);
-    ci.usage = vma_usage;
-    ci.memoryTypeBits = reqs.memoryTypeBits & valid_memory_types;
-    ci.requiredFlags = 0;
-    ci.preferredFlags = MemoryUsagePreferredVmaFlags(usage);
+        VmaAllocation a{};
+        VmaAllocationInfo info{};

-    VmaAllocation a{};
-    VmaAllocationInfo info{};
+        // Let VMA infer memory requirements from the buffer
+        VkResult res = vmaAllocateMemoryForBuffer(allocator, raw, &ci, &a, &info);

-    VkResult res = vmaAllocateMemory(allocator, &reqs, &ci, &a, &info);
+        if (res != VK_SUCCESS) {
+            auto ci2 = ci;
+            ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT;
+            res = vmaAllocateMemoryForBuffer(allocator, raw, &ci2, &a, &info);

-    if (res != VK_SUCCESS) {
-        // Relax 1: drop budget constraint
-        auto ci2 = ci;
-        ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT;
-        res = vmaAllocateMemory(allocator, &reqs, &ci2, &a, &info);
-
-        // Relax 2: if we preferred DEVICE_LOCAL, drop that preference
-        if (res != VK_SUCCESS && (ci.preferredFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) {
-            auto ci3 = ci2;
-            ci3.preferredFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
-            res = vmaAllocateMemory(allocator, &reqs, &ci3, &a, &info);
+            if (res != VK_SUCCESS && (ci.preferredFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) {
+                auto ci3 = ci2;
+                ci3.preferredFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+                res = vmaAllocateMemoryForBuffer(allocator, raw, &ci3, &a, &info);
+            }
        }
+
+        vk::Check(res);
+        vk::Check(vmaBindBufferMemory2(allocator, a, 0, raw, nullptr));
+        return MemoryCommit(allocator, a, info);
    }

-    vk::Check(res);
-    return MemoryCommit(allocator, a, info);
-}

-MemoryCommit MemoryAllocator::Commit(const vk::Buffer &buffer, MemoryUsage usage) {
-    // Allocate memory appropriate for this buffer automatically
-    const auto vma_usage = MemoryUsageVma(usage);
-
-    VmaAllocationCreateInfo ci{};
-    ci.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage);
-    ci.usage = vma_usage;
-    ci.requiredFlags = 0;
-    ci.preferredFlags = MemoryUsagePreferredVmaFlags(usage);
-    ci.pool = VK_NULL_HANDLE;
-    ci.pUserData = nullptr;
-    ci.priority = 0.0f;
-
-    const VkBuffer raw = *buffer;
-
-    VmaAllocation a{};
-    VmaAllocationInfo info{};
-
-    // Let VMA infer memory requirements from the buffer
-    VkResult res = vmaAllocateMemoryForBuffer(allocator, raw, &ci, &a, &info);
-
-    if (res != VK_SUCCESS) {
-        auto ci2 = ci;
-        ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT;
-        res = vmaAllocateMemoryForBuffer(allocator, raw, &ci2, &a, &info);
-
-        if (res != VK_SUCCESS && (ci.preferredFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) {
-            auto ci3 = ci2;
-            ci3.preferredFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
-            res = vmaAllocateMemoryForBuffer(allocator, raw, &ci3, &a, &info);
-        }
-    }
-
-    vk::Check(res);
-    vk::Check(vmaBindBufferMemory2(allocator, a, 0, raw, nullptr));
-    return MemoryCommit(allocator, a, info);
-}

 } // namespace Vulkan
@@ -107,9 +107,6 @@ namespace Vulkan {

        vk::Buffer CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage) const;

-        vk::Buffer CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage,
-                                VkDeviceSize min_alignment) const;
-
        /**
         * Commits a memory with the specified requirements.
         *
@@ -229,7 +229,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
    X(vkGetPipelineExecutableStatisticsKHR);
    X(vkGetSemaphoreCounterValue);
    X(vkMapMemory);
-    X(vkQueueBindSparse);
    X(vkQueueSubmit);
    X(vkQueueSubmit2);
    X(vkResetFences);
@@ -540,18 +539,6 @@ void Buffer::SetObjectNameEXT(const char* name) const {
    SetObjectName(dld, owner, handle, VK_OBJECT_TYPE_BUFFER, name);
 }

-MemoryLocation Buffer::Location() const noexcept {
-    if (!allocation) {
-        return MemoryLocation{};
-    }
-    VmaAllocationInfo info{};
-    vmaGetAllocationInfo(allocator, allocation, &info);
-    return MemoryLocation{
-        .memory = info.deviceMemory,
-        .offset = info.offset,
-    };
-}
-
 void Buffer::Release() const noexcept {
    if (handle) {
        vmaDestroyBuffer(allocator, handle, allocation);
@@ -345,7 +345,6 @@ struct DeviceDispatch : InstanceDispatch {
    PFN_vkGetQueryPoolResults vkGetQueryPoolResults{};
    PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue{};
    PFN_vkMapMemory vkMapMemory{};
-    PFN_vkQueueBindSparse vkQueueBindSparse{};
    PFN_vkQueueSubmit vkQueueSubmit{};
    PFN_vkQueueSubmit2 vkQueueSubmit2{};
    PFN_vkResetFences vkResetFences{};
@@ -741,11 +740,6 @@ private:
    const DeviceDispatch* dld = nullptr;
 };

-struct MemoryLocation {
-    VkDeviceMemory memory{};
-    VkDeviceSize offset{};
-};
-
 class Buffer {
 public:
    explicit Buffer(VkBuffer handle_, VkDevice owner_, VmaAllocator allocator_,
@@ -817,8 +811,6 @@ public:

    void SetObjectNameEXT(const char* name) const;

-    MemoryLocation Location() const noexcept;
-
 private:
    void Release() const noexcept;

@@ -851,11 +843,6 @@ public:
        return dld->vkQueueSubmit2(queue, submit_infos.size(), submit_infos.data(), fence);
    }

-    VkResult BindSparse(Span<VkBindSparseInfo> bind_infos,
-                        VkFence fence = VK_NULL_HANDLE) const noexcept {
-        return dld->vkQueueBindSparse(queue, bind_infos.size(), bind_infos.data(), fence);
-    }
-
    VkResult Present(const VkPresentInfoKHR& present_info) const noexcept {
        return dld->vkQueuePresentKHR(queue, &present_info);
    }
@@ -4796,6 +4796,6 @@ void VolumeButton::ResetMultiplier() {
 #endif

 #if !defined(QT_STATICPLUGIN) || defined(__APPLE__)
-#define VMA_IMPLEMENTATION 1
+#define VMA_IMPLEMENTATION
 #include "video_core/vulkan_common/vma.h"
 #endif
@@ -65,7 +65,7 @@ else()
 endif()

 # update cached cpmfile content
-string(JSON cpmfile SET "${cpmfile}" "${KEY}" "${new_object}")
+string(JSON cpmfile SET "${cpmfile}" "${key}" "${new_object}")

 # write cached cpmfile
 get_cpmfile_path(file)
Author	SHA1	Message	Date
lizzie	b4309dfa4f	nullptr check on multistream	2026-09-03 07:43:44 +00:00
lizzie	234086ba8d	reset to nil	2026-09-03 06:55:12 +00:00
crueter	d8b3a57322	a Signed-off-by: crueter <crueter@eden-emu.dev>	2026-09-03 06:32:44 +00:00
crueter	51d4906738	Fix license headers	2026-09-03 06:32:44 +00:00
crueter	ebe7bf7d9b	Cleanup Signed-off-by: crueter <crueter@eden-emu.dev>	2026-09-03 06:32:44 +00:00
crueter	3c133db2a0	Improve padding Signed-off-by: crueter <crueter@eden-emu.dev>	2026-09-03 06:32:44 +00:00
crueter	dc75c629ca	Rebase Signed-off-by: crueter <crueter@eden-emu.dev>	2026-09-03 06:32:44 +00:00
lizzie	a514f74ffb	adjust IsValidStreamCounts	2026-09-03 06:32:44 +00:00
lizzie	a276b29fa7	fix debian	2026-09-03 06:32:44 +00:00
lizzie	68cbf12283	Trigger Build	2026-09-03 06:32:44 +00:00
lizzie	ee708f56f9	fx	2026-09-03 06:32:44 +00:00
lizzie	6fb2892e17	brain no work	2026-09-03 06:32:44 +00:00
lizzie	7b0804cc15	implodes	2026-09-03 06:32:44 +00:00
lizzie	1a4d6fc199	[audio_core/dsp] nuke libopus, use ffmpeg for opus decoding Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-03 06:32:44 +00:00