2026-09-15 19:23:45

Signed-off-by: lizzie <lizzie@eden-emu.dev>
2026-09-14 09:32:00
2026-09-20 09:26:53 +00:00 · 2026-09-15 19:23:45 +00:00 · 2026-09-15 22:12:39 +02:00 · 2026-09-15 22:12:39 +02:00 · 2026-09-15 22:12:39 +02:00 · 2026-09-15 22:12:39 +02:00
91 changed files with 1522 additions and 2080 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)
@@ -460,21 +460,6 @@ if (NOT YUZU_STATIC_ROOM)
    if (ZLIB_ADDED)
        add_library(ZLIB::ZLIB ALIAS zlibstatic)
    endif()
-
-    # Opus
-    AddJsonPackage(opus)
-
-    if (Opus_ADDED)
-        if (MSVC AND CXX_CLANG)
-            target_compile_options(opus PRIVATE
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-function-declaration>
-            )
-        endif()
-    endif()
-
-    if (NOT TARGET Opus::opus)
-        add_library(Opus::opus ALIAS opus)
-    endif()
 endif()

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

 Vulkan 1.3.274+ is also needed:

@@ -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).
@@ -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,
@@ -1784,51 +1784,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>
@@ -15,10 +15,6 @@ add_library(audio_core STATIC
    adsp/apps/audio_renderer/command_list_processor.h
    adsp/apps/opus/opus_decoder.cpp
    adsp/apps/opus/opus_decoder.h
-    adsp/apps/opus/opus_decode_object.cpp
-    adsp/apps/opus/opus_decode_object.h
-    adsp/apps/opus/opus_multistream_decode_object.cpp
-    adsp/apps/opus/opus_multistream_decode_object.h
    adsp/apps/opus/shared_memory.h
    audio_core.cpp
    audio_core.h
@@ -226,8 +222,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,110 +0,0 @@
-// 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
-
-#include "audio_core/adsp/apps/opus/opus_decode_object.h"
-#include "common/assert.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);
-}
-
-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;
-}
-
-s32 OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        return OPUS_OK;
-    }
-
-    // Unfortunately libopus does not expose the OpusDecoder struct publicly, so we can't include
-    // it in this class. Nintendo does not allocate memory, which is why we have a workbuffer
-    // provided.
-    // We could use _create and have libopus allocate it for us, but then we have to separately
-    // track which decoder is being used between this and multistream in order to call the correct
-    // destroy from the host side.
-    // This is a bit cringe, but is safe as these objects are only ever initialized inside the given
-    // workbuffer, and GetWorkBufferSize will guarantee there's enough space to follow.
-    decoder = (LibOpusDecoder*)(this + 1);
-    s32 ret = opus_decoder_init(decoder, sample_rate, channel_count);
-    if (ret == OPUS_OK) {
-        magic = DecodeObjectMagic;
-        initialized = true;
-        state_valid = true;
-        self = this;
-        final_range = 0;
-    }
-    return ret;
-}
-
-s32 OpusDecodeObject::Shutdown() {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        magic = 0x0;
-        initialized = false;
-        state_valid = false;
-        self = nullptr;
-        final_range = 0;
-        decoder = nullptr;
-    }
-    return OPUS_OK;
-}
-
-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);
-    out_sample_count = 0;
-
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    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);
-}
-
-} // namespace AudioCore::ADSP::OpusDecoder
@@ -1,41 +0,0 @@
-// 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"
-
-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;
-    }
-
-private:
-    u32 magic;
-    bool initialized;
-    bool state_valid;
-    OpusDecodeObject* self;
-    u32 final_range;
-    LibOpusDecoder* decoder;
-};
-static_assert(std::is_trivially_constructible_v<OpusDecodeObject>);
-
-} // namespace AudioCore::ADSP::OpusDecoder
@@ -5,55 +5,445 @@
 // 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"
+extern "C" {
+#include <libswresample/swresample.h>
+#include <libavcodec/avcodec.h>
+#include <libavcodec/codec.h>
+#include <libavcodec/packet.h>
+#include <libavutil/channel_layout.h>
+#include <libavutil/frame.h>
+#include <libavutil/opt.h>
+#include <libavutil/samplefmt.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 {

 namespace {
-constexpr size_t OpusStreamCountMax = 255;
+constexpr u32 OPUS_STREAM_COUNT_MAX = 255;
+// https://git.ffmpeg.org/gitweb/ffmpeg.git/blob_plain/HEAD:/libavcodec/libopusdec.c
+constexpr u32 OPUS_HEAD_SIZE = 19;
+constexpr u32 OPUS_MAX_CHANNELS = 2;

 bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
+    return channel_count >= 1 || channel_count <= OPUS_MAX_CHANNELS;
 }

-bool IsValidMultiStreamChannelCount(u32 channel_count) {
-    return channel_count <= OpusStreamCountMax;
+bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
+    return total_stream_count > 0 && total_stream_count <= OPUS_STREAM_COUNT_MAX
+        && s32(stereo_stream_count) >= 0 && stereo_stream_count <= total_stream_count;
 }

-bool IsValidMultiStreamStreamCounts(s32 total_stream_count, s32 stereo_stream_count) {
-    return IsValidMultiStreamChannelCount(total_stream_count) && total_stream_count > 0 &&
-           stereo_stream_count >= 0 && stereo_stream_count <= total_stream_count;
-}
+struct OpusGenericDecodeParams {
+    static constexpr size_t SWR_CONV_16KHZ = 0;
+    static constexpr size_t SWR_CONV_24KHZ = 1;
+    static constexpr size_t SWR_CONV_48KHZ = 2;
+
+    static constexpr size_t SWR_CONV_1CH = 0;
+    static constexpr size_t SWR_CONV_2CH = 1;
+
+    SwrContext* swr_fltp_to_s16_from_48khz[3][2] = {};
+    AVPacket* pkt = nullptr;
+    AVFrame* frame = nullptr;
+    u8* tmp_buf[8] = {};
+
+    static size_t ToSampleIndex(size_t v) noexcept {
+        switch (v) {
+        case 48000: return SWR_CONV_48KHZ;
+        case 24000: return SWR_CONV_24KHZ;
+        case 16000: return SWR_CONV_16KHZ;
+        default: UNREACHABLE();
+        }
+    }
+};
+
+struct OpusGenericDecodeObject {
+    static u32 GetWorkBufferSizeMultistream(u32 total_stream_count, u32 stereo_stream_count) {
+        if (IsValidStreamCounts(total_stream_count, stereo_stream_count))
+            return 32 + 2556 * (total_stream_count * stereo_stream_count);
+        return 0;
+    }
+
+    static u32 GetWorkBufferSize(u32 channel_count) {
+        if (channel_count == 1 || channel_count == 2)
+            return 32 + 2556 * channel_count;
+        return 0;
+    }
+
+    /// idempotency of initialize is guaranteed
+    Result InitializeDecoder(u32 sample_rate, u32 total_stream_count, u32 channel_count, u32 stereo_stream_count, u8 const* mappings, OpusGenericDecodeParams params) {
+        LOG_DEBUG(Audio_DSP, "sample_rate={}, total_stream_count={}, channel_count={}, stereo_stream_count={}, mappings={}", sample_rate, total_stream_count, channel_count, stereo_stream_count, fmt::ptr(mappings));
+        ASSERT(channel_count >= 1 && channel_count <= 2);
+        // prefer libopus, ffmpeg docs say to use libopus **if** available
+        // However, native opus can also work with swrescale:
+        // it uses planarfloat, we can resample to s16
+        AVCodec const* codec = avcodec_find_decoder_by_name("libopus");
+        bool is_libopus = codec != nullptr;
+        if (!codec) {
+            LOG_WARNING(Audio_DSP, "using ffmpeg native opus decoder");
+            codec = avcodec_find_decoder(AV_CODEC_ID_OPUS);
+        }
+        ASSERT(!avc);
+        if ((avc = avcodec_alloc_context3(codec)) != nullptr) {
+            if (is_libopus) {
+                const std::array<u8, 2> mapping_arr{0, 1};
+                mappings = mappings ? mappings : mapping_arr.data();
+
+                // freed by avcodec_context_free()
+                u8 *edata = reinterpret_cast<u8*>(av_mallocz(OPUS_HEAD_SIZE + 2 * OPUS_MAX_CHANNELS + AV_INPUT_BUFFER_PADDING_SIZE));
+                ASSERT(edata);
+                edata[9] = u8(channel_count); //channels
+                edata[10] = u8(0); //opus->pre_skip
+                edata[16] = u8(0); //gain_db
+                edata[18] = u8(0); //channel_map
+                edata[OPUS_HEAD_SIZE + 0] = u8(total_stream_count);
+                edata[OPUS_HEAD_SIZE + 1] = u8(stereo_stream_count);
+                if (channel_count >= 1) edata[OPUS_HEAD_SIZE + 2] = mappings[0];
+                if (channel_count >= 2) edata[OPUS_HEAD_SIZE + 3] = mappings[1];
+                avc->extradata = edata;
+                avc->extradata_size = OPUS_HEAD_SIZE + 2 * channel_count;
+            }
+
+            // FFmpeg hardcodes sample rate
+            exposed_sample_rate = sample_rate;
+            avc->sample_rate = sample_rate;
+            avc->request_sample_fmt = AV_SAMPLE_FMT_S16;
+            avc->max_samples = 0x10000; //64K
+            av_channel_layout_default(&avc->ch_layout, channel_count);
+            if (avcodec_open2(avc, codec, nullptr) >= 0) {
+                ASSERT(avc->request_sample_fmt == AV_SAMPLE_FMT_S16);
+                return ResultSuccess;
+            }
+        }
+        Shutdown(params);
+        return Service::Audio::ResultLibOpusInternalError;
+    }
+
+    Result Shutdown(OpusGenericDecodeParams params) {
+        LOG_DEBUG(Audio_DSP, "called avc={}", fmt::ptr(avc));
+        if (avc) {
+            if (avcodec_is_open(avc))
+                avcodec_flush_buffers(avc);
+            avcodec_free_context(&avc);
+        }
+        return ResultSuccess;
+    }
+
+    Result ResetDecoder(OpusGenericDecodeParams params) {
+        LOG_DEBUG(Audio_DSP, "called avc={}", fmt::ptr(avc));
+        if (avc) {
+            if (avcodec_is_open(avc))
+                avcodec_flush_buffers(avc);
+            return ResultSuccess;
+        }
+        return Service::Audio::ResultLibOpusInvalidState;
+    }
+
+    Result Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data, u64 input_data_size, OpusGenericDecodeParams params) {
+        LOG_TRACE(Audio_DSP, "called out_sample_count={},output_data={:#x},output_data_size={},input_data={:#x},input_data_size={}", fmt::ptr(&out_sample_count), output_data, output_data_size, input_data, input_data_size);
+        ASSERT(avc && avcodec_is_open(avc));
+        out_sample_count = 0;
+        int r;
+        LOG_TRACE(Audio_DSP, "old packet data={}", fmt::ptr(params.pkt->data));
+
+        // select software raster (fltp -> s16)
+        ASSERT(avc->ch_layout.nb_channels - 1 >= 0 && avc->ch_layout.nb_channels - 1 <= 1);
+        if ((r = av_new_packet(params.pkt, int(input_data_size))) >= 0) {
+            LOG_TRACE(Audio_DSP, "new packet data={}", fmt::ptr(params.pkt->data));
+            std::memcpy(params.pkt->data, reinterpret_cast<const u8*>(input_data), input_data_size);
+            if ((r = avcodec_send_packet(avc, params.pkt)) >= 0) {
+                av_packet_unref(params.pkt);
+                while ((r = avcodec_receive_frame(avc, params.frame)) >= 0) {
+                    LOG_TRACE(Audio_DSP, "frame data={},data[0]={},nb_samples={}", fmt::ptr(params.frame->data), fmt::ptr(params.frame->data[0]), params.frame->nb_samples);
+                    ASSERT(std::in_range<u16>(params.frame->nb_samples));
+                    u8 *dst_arr[2] = {reinterpret_cast<u8*>(output_data), nullptr};
+                    if (params.frame->format == avc->request_sample_fmt) {
+                        // input_bsize == output_bsize
+                        av_samples_copy(dst_arr, params.frame->data, out_sample_count, 0, params.frame->nb_samples, params.frame->ch_layout.nb_channels, (enum AVSampleFormat)params.frame->format);
+                        out_sample_count += params.frame->nb_samples;
+                    } else {
+                        // needs conversion
+                        SwrContext* swr = params.swr_fltp_to_s16_from_48khz[params.ToSampleIndex(exposed_sample_rate)][avc->ch_layout.nb_channels - 1];
+                        int out_samples = int(av_rescale_rnd(swr_get_delay(swr, exposed_sample_rate) + params.frame->nb_samples, params.frame->sample_rate, exposed_sample_rate, AV_ROUND_UP));
+                        out_samples = swr_convert(swr, params.tmp_buf, out_samples, (const u8 **)params.frame->data, params.frame->nb_samples);
+                        av_samples_copy(dst_arr, params.tmp_buf, out_sample_count, 0, out_samples, params.frame->ch_layout.nb_channels, avc->request_sample_fmt);
+                        out_sample_count += out_samples;
+                    }
+                    av_frame_unref(params.frame);
+                }
+                ASSERT_MSG(r == AVERROR(EAGAIN) || r == AVERROR_EOF || r >= 0, "{}", r);
+                avcodec_flush_buffers(avc);
+                return ResultSuccess;
+            }
+        }
+        avcodec_flush_buffers(avc);
+        LOG_ERROR(Audio_DSP, "{}", r);
+        return Service::Audio::ResultLibOpusInvalidState;
+    }
+
+    AVCodecContext* avc = nullptr;
+    // Sample rate that application will see
+    int exposed_sample_rate = 0;
+};
 } // namespace

-OpusDecoder::OpusDecoder(Core::System& system_) : system{system_} {
-    init_thread = std::jthread([this](std::stop_token stop_token) { Init(stop_token); });
+OpusDecoder::OpusDecoder(Core::System& system) {
+    dsp_thread = std::jthread([this, &system](std::stop_token stop_token) {
+        Common::SetCurrentThreadName("DSP_OpusDecoder");
+        if (Receive(Direction::DSP, stop_token) != Message::Start) {
+            LOG_ERROR(Service_Audio, "DSP OpusDecoder failed to receive Start message. Opus initialization failed.");
+            return;
+        }
+        Send(Direction::Host, Message::StartOK);
+
+        // Main OpusDecoder thread, responsible for processing the incoming Opus packets.
+        ::Common::unordered_map<u64, OpusGenericDecodeObject> decode_objects;
+        // Staging buffers used by various decoders
+        // 1 <= channels <= 2, then, UPB channels => 2
+        // 64K is enough for most
+        OpusGenericDecodeParams params{};
+        av_samples_alloc(params.tmp_buf, nullptr, 2, (int)0x10000, AV_SAMPLE_FMT_S16, 0);
+        params.pkt = av_packet_alloc();
+        params.frame = av_frame_alloc();
+
+        // opus fltp -> libopus s16 software converters
+        AVChannelLayout channel_layouts[2];
+        av_channel_layout_default(&channel_layouts[0], 1);
+        av_channel_layout_default(&channel_layouts[1], 2);
+        int r;
+        int const sample_rates[] = { 16000, 24000, 48000 };
+        for (size_t i = 0; i < 3; ++i) {
+            if ((r = swr_alloc_set_opts2(&params.swr_fltp_to_s16_from_48khz[i][params.SWR_CONV_1CH],
+                &channel_layouts[0], AV_SAMPLE_FMT_S16, sample_rates[i],
+                &channel_layouts[0], AV_SAMPLE_FMT_FLTP, 48000,
+                0, nullptr)) < 0)
+                ASSERT_MSG(false, "{}", r);
+            if ((r = swr_alloc_set_opts2(&params.swr_fltp_to_s16_from_48khz[i][params.SWR_CONV_2CH],
+                &channel_layouts[1], AV_SAMPLE_FMT_S16, sample_rates[i],
+                &channel_layouts[1], AV_SAMPLE_FMT_FLTP, 48000,
+                0, nullptr)) < 0)
+                ASSERT_MSG(false, "{}", r);
+        }
+        for (size_t i = 0; i < 3; ++i) {
+            if ((r = swr_init(params.swr_fltp_to_s16_from_48khz[i][params.SWR_CONV_1CH])) < 0)
+                ASSERT_MSG(false, "{}", r);
+            if ((r = swr_init(params.swr_fltp_to_s16_from_48khz[i][params.SWR_CONV_2CH])) < 0)
+                ASSERT_MSG(false, "{}", r);
+        }
+
+        while (!stop_token.stop_requested()) {
+            auto msg = Receive(Direction::DSP, stop_token);
+            LOG_TRACE(Audio_DSP, "msg={}, buffer={}", msg, shared_memory->host_send_data[0]);
+            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] = OpusGenericDecodeObject::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 >= OpusGenericDecodeObject::GetWorkBufferSize(channel_count));
+
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    it->second.Shutdown(params);
+                    shared_memory->dsp_return_data[0] = it->second.InitializeDecoder(sample_rate, 1, channel_count, channel_count == 2 ? 1 : 0, nullptr, params).raw;
+                } else {
+                    OpusGenericDecodeObject obj{};
+                    shared_memory->dsp_return_data[0] = obj.InitializeDecoder(sample_rate, 1, channel_count, channel_count == 2 ? 1 : 0, nullptr, params).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(params).raw;
+                    decode_objects.erase(buffer);
+                } 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(params);
+                    if (res == ResultSuccess)
+                        res = it->second.Decode(decoded_samples, output_data, output_data_size, input_data, input_data_size, params);
+
+                    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(IsValidStreamCounts(total_stream_count, stereo_stream_count));
+
+                shared_memory->dsp_return_data[0] = OpusGenericDecodeObject::GetWorkBufferSizeMultistream(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(IsValidStreamCounts(total_stream_count, stereo_stream_count));
+                ASSERT(sample_rate >= 0);
+                ASSERT(buffer_size >= OpusGenericDecodeObject::GetWorkBufferSizeMultistream(total_stream_count, stereo_stream_count));
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    it->second.Shutdown(params);
+                    shared_memory->dsp_return_data[0] = it->second.InitializeDecoder(sample_rate, total_stream_count, channel_count, stereo_stream_count, mappings, params).raw;
+                } else {
+                    OpusGenericDecodeObject obj{};
+                    shared_memory->dsp_return_data[0] = obj.InitializeDecoder(sample_rate, total_stream_count, channel_count, stereo_stream_count, mappings, params).raw;
+                    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 = decode_objects.find(buffer); it != decode_objects.end()) {
+                    shared_memory->dsp_return_data[0] = it->second.Shutdown(params).raw;
+                    decode_objects.erase(buffer);
+                } 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 = decode_objects.find(buffer); it != decode_objects.end()) {
+                    auto res = ResultSuccess;
+                    if (reset_requested)
+                        res = it->second.ResetDecoder(params);
+                    if (res == ResultSuccess)
+                        res = it->second.Decode(decoded_samples, output_data, output_data_size, input_data, input_data_size, params);
+
+                    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;
+            }
+        }
+        for (auto e : decode_objects)
+            e.second.Shutdown(params);
+        // global params handlers
+        for (size_t i = 0; i < 3; ++i) {
+            for (size_t j = 0; j < 2; ++j) {
+                swr_free(&params.swr_fltp_to_s16_from_48khz[i][j]);
+            }
+        }
+        av_freep(&params.tmp_buf[0]);
+        av_frame_free(&params.frame);
+        av_packet_free(&params.pkt);
+    });
 }

 OpusDecoder::~OpusDecoder() {
-    if (!running) {
-        init_thread.request_stop();
-        return;
+    if (dsp_thread.joinable()) {
+        // Shutdown the thread
+        auto const stop_token = dsp_thread.get_stop_token();
+        Send(Direction::DSP, Message::Shutdown);
+        auto msg = Receive(Direction::Host, stop_token);
+        ASSERT_MSG(msg == Message::ShutdownOK, "Expected Opus shutdown code {}, got {}", Message::ShutdownOK, msg);
+        dsp_thread.request_stop();
+        dsp_thread.join();
    }
-
-    // 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);
-    main_thread.request_stop();
-    main_thread.join();
-    running = false;
 }

 void OpusDecoder::Send(Direction dir, u32 message) {
@@ -64,206 +454,4 @@ u32 OpusDecoder::Receive(Direction dir, std::stop_token stop_token) {
    return mailbox.Receive(dir, stop_token);
 }

-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.");
-        return;
-    }
-    main_thread = std::jthread([this](std::stop_token st) { Main(st); });
-    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,12 +6,13 @@

 #pragma once

-#include <memory>
 #include <thread>

+#include "common/container/unordered_map.h"
 #include "audio_core/adsp/apps/opus/shared_memory.h"
 #include "audio_core/adsp/mailbox.h"
 #include "common/common_types.h"
+#include "core/hle/result.h"

 namespace Core {
 class System;
@@ -48,16 +49,14 @@ enum Message : u32 {
    DecodeInterleavedForMultiStreamOK = 50,
 };

-/**
- * The AudioRenderer application running on the ADSP.
- */
+/// @brief The AudioRenderer application running on the ADSP.
 class OpusDecoder {
 public:
    explicit OpusDecoder(Core::System& system);
    ~OpusDecoder();

    bool IsRunning() const noexcept {
-        return running;
+        return dsp_thread.joinable();
    }

    void Send(Direction dir, u32 message);
@@ -68,28 +67,12 @@ public:
    }

 private:
-    /**
-     * 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;
-    /// Init thread
-    std::jthread init_thread{};
-    /// Main thread
-    std::jthread main_thread{};
-    /// 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{};
+    std::jthread dsp_thread{};
 };

 } // namespace AudioCore::ADSP::OpusDecoder
@@ -1,113 +0,0 @@
-// 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
-
-#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
-#include "common/assert.h"
-
-namespace AudioCore::ADSP::OpusDecoder {
-
-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;
-}
-} // 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);
-    }
-    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;
-}
-
-s32 OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count,
-                                                   u32 channel_count, u32 stereo_stream_count,
-                                                   u8* mappings) {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        return OPUS_OK;
-    }
-
-    // See OpusDecodeObject::InitializeDecoder for an explanation of this
-    decoder = (LibOpusMSDecoder*)(this + 1);
-    s32 ret = opus_multistream_decoder_init(decoder, sample_rate, channel_count, total_stream_count,
-                                            stereo_stream_count, mappings);
-    if (ret == OPUS_OK) {
-        magic = DecodeMultiStreamObjectMagic;
-        initialized = true;
-        state_valid = true;
-        self = this;
-        final_range = 0;
-    }
-    return ret;
-}
-
-s32 OpusMultiStreamDecodeObject::Shutdown() {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        magic = 0x0;
-        initialized = false;
-        state_valid = false;
-        self = nullptr;
-        final_range = 0;
-        decoder = nullptr;
-    }
-    return OPUS_OK;
-}
-
-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);
-    out_sample_count = 0;
-
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    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);
-}
-
-} // namespace AudioCore::ADSP::OpusDecoder
@@ -1,42 +0,0 @@
-// 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"
-
-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;
-    }
-
-private:
-    u32 magic;
-    bool initialized;
-    bool state_valid;
-    OpusMultiStreamDecodeObject* self;
-    u32 final_range;
-    LibOpusMSDecoder* decoder;
-};
-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);
+
+}
@@ -6,7 +6,6 @@

 #pragma once

-#include "common/common_funcs.h"
 #include "common/common_types.h"

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

@@ -112,7 +91,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,
@@ -140,7 +119,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) {
@@ -154,7 +133,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) {
@@ -169,7 +148,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,
@@ -193,12 +172,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,
@@ -207,29 +186,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) {
@@ -240,8 +217,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();
@@ -255,8 +231,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();
@@ -8,8 +8,6 @@

 #include <array>
 #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"
@@ -110,6 +110,7 @@ add_library(
    socket_types.h
    sparse_large_vector.cpp
    sparse_large_vector.h
+    spin_lock.h
    stb.cpp
    stb.h
    steady_clock.cpp
@@ -244,8 +244,7 @@ WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept
    , ns_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency_) : 0}
    , us_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency_) : 0}
    , ms_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency_) : 0}
-    , rdtsc_ns_integer{invariant_ ? rdtsc_frequency_ / NsRatio::den : 1}
-    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_ % NsRatio::den, NsRatio::den) : 0}
+    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_, NsRatio::den) : 1}
    , cntpct_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency_) : 0}
    , gputick_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency_) : 0}
    , invariant{invariant_}
@@ -292,7 +291,7 @@ bool WallClock::IsNative() const {
 }

 u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
-    return ns.count() * rdtsc_ns_integer + MultiplyHigh(ns.count(), rdtsc_ns_factor);
+    return invariant ? MultiplyHigh(ns.count(), rdtsc_ns_factor) : ns.count();
 }
 #elif defined(HAS_NCE)
 namespace {
@@ -417,7 +416,7 @@ u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
 const WallClock g_wall_clock = [] {
 #if defined(ARCHITECTURE_x86_64)
    auto const& caps = Common::g_cpu_caps;
-    return WallClock(caps.invariant_tsc && caps.tsc_frequency > std::nano::den, caps.tsc_frequency);
+    return WallClock(caps.invariant_tsc && caps.tsc_frequency >= std::nano::den, caps.tsc_frequency);
 #elif defined(HAS_NCE)
    return WallClock(false, 1);
 #else
@@ -96,7 +96,6 @@ public:
    u64 ns_rdtsc_factor;
    u64 us_rdtsc_factor;
    u64 ms_rdtsc_factor;
-    u64 rdtsc_ns_integer;
    u64 rdtsc_ns_factor;
    u64 cntpct_rdtsc_factor;
    u64 gputick_rdtsc_factor;
@@ -17,33 +17,35 @@

 namespace Common {

-// glibc, mlibc, musl, and newlib all define their own variants of strerror_r
-// We don't need to use the preprocessor, we can just select depending on return type
-template<typename T> std::string HandleStrerrorR(T r, char *err_str);
-template<> std::string HandleStrerrorR(char* r, char *) { return std::string{r}; }
-template<> std::string HandleStrerrorR(const char* r, char *) { return std::string{r}; }
-template<> std::string HandleStrerrorR(int r, char *err_str) {
-    return std::string{r != 0
-        ? "(strerror_r failed to format error)"
-        : err_str};
-}
-
 std::string NativeErrorToString(int e) {
 #ifdef _WIN32
    LPSTR err_str;
+
    DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                   FORMAT_MESSAGE_IGNORE_INSERTS,
                               nullptr, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                               LPSTR(&err_str), 1, nullptr);
-    if (res) {
-        std::string ret(err_str);
-        LocalFree(err_str);
-        return ret;
+                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
+    if (!res) {
+        return "(FormatMessageA failed to format error)";
    }
-    return "(FormatMessageA failed to format error)";
+    std::string ret(err_str);
+    LocalFree(err_str);
+    return ret;
 #else
    char err_str[255];
-    return HandleStrerrorR(strerror_r(e, err_str, sizeof(err_str)), err_str);
+#if defined(__ANDROID__) ||                                                                            \
+    (defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600)))
+    // Thread safe (GNU-specific)
+    const char* str = strerror_r(e, err_str, sizeof(err_str));
+    return std::string(str);
+#else
+    // Thread safe (XSI-compliant)
+    int second_err = strerror_r(e, err_str, sizeof(err_str));
+    if (second_err != 0) {
+        return "(strerror_r failed to format error)";
+    }
+    return std::string(err_str);
+#endif // GLIBC etc.
 #endif // _WIN32
 }

@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <algorithm>
-#include <cctype>
 #include <iostream>
 #include <sstream>
 #include "common/container/unordered_map.h"
@@ -481,80 +480,28 @@ std::string SanitizePath(std::string_view path_, DirectorySeparator directory_se
                           [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
               path.end());

-    std::string root;
-    std::string_view components{path};
-    bool drive_relative = false;
-
-#ifdef _WIN32
-    const bool network = path.size() > 1 && path[0] == type2 && path[1] == type2;
-    const bool drive =
-        path.size() > 1 && std::isalpha(static_cast<unsigned char>(path[0])) && path[1] == ':';
-
-    if (network) {
-        root.assign(2, type2);
-        components.remove_prefix(2);
-    } else if (drive) {
-        root.assign(path.data(), 2);
-        components.remove_prefix(2);
-        if (!components.empty() && components.front() == type2) {
-            root += type2;
-            components.remove_prefix(1);
-        } else {
-            drive_relative = true;
-        }
-    }
-#endif
-
-    if (root.empty() && !components.empty() && components.front() == type2) {
-        root += type2;
-        components.remove_prefix(1);
-    }
-
-    const auto path_parts = SplitPathComponents(components);
-    std::size_t root_component_count = 0;
-#ifdef _WIN32
-    if (network) {
-        root_component_count = 2;
-
-        const auto is_unc = [](std::string_view part) {
-            return part.size() == 3 && (part[0] == 'U' || part[0] == 'u') &&
-                   (part[1] == 'N' || part[1] == 'n') && (part[2] == 'C' || part[2] == 'c');
-        };
-        if (path_parts.size() >= 2 && path_parts[0] == "?" && is_unc(path_parts[1])) {
-            root_component_count = 4;
-        }
-    }
-#endif
-
+    const bool absolute = !path.empty() && path[0] == type2;
    std::vector<std::string_view> parts;
-    for (std::size_t i = 0; i < path_parts.size(); ++i) {
-        const auto part = path_parts[i];
-        if (i < root_component_count) {
-            parts.push_back(part);
-        } else if (part.empty() || part == ".") {
+
+    for (const auto part : SplitPathComponents(path))
+    {
+        if (part.empty() || part == ".")
            continue;
-        } else if (part == "..") {
-            if (parts.size() > root_component_count) {
-                parts.pop_back();
-            }
-        } else {
-            parts.push_back(part);
-        }
+        if (part == ".." && !parts.empty() && parts.back() != "..")
+            parts.pop_back();
+        else if (part != "..") parts.push_back(part);
    }

-    const std::size_t root_length = root.size();
-    std::string resolved = std::move(root);
-    for (std::size_t i = 0; i < parts.size(); ++i) {
-        if (i != 0 || (!resolved.empty() && resolved.back() != type2 && !drive_relative))
+    std::string resolved = absolute ? std::string(1, type2) : std::string{};
+    for (std::size_t i = 0; i < parts.size(); ++i)
+    {
+        if (i != 0)
            resolved += type2;
        resolved.append(parts[i].data(), parts[i].size());
    }

    path = std::move(resolved);

-    if (!path.empty() && path.size() == root_length) {
-        return path;
-    }
    return std::string(RemoveTrailingSlash(path));
 }

@@ -347,9 +347,8 @@ enum class DirectorySeparator {
 // i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
 [[nodiscard]] std::vector<std::string> SplitPathComponentsCopy(std::string_view filename);

-// Normalizes directory separators, removes duplicate and non-root trailing separators, and resolves
-// '.' and '..' components without traversing above the path root. Windows drive and UNC roots are
-// preserved.
+// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
+// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
 [[nodiscard]] std::string SanitizePath(
    std::string_view path,
    DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
@@ -96,15 +96,15 @@ struct PageTable {
        }

        /// Write page info atomically
-        inline void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
+        constexpr void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
            data_raw.store(std::bit_cast<u64>(Data{marked, type, block, pointer}));
        }

-        inline void MarkRasterizerCached() noexcept {
+        constexpr void MarkRasterizerCached() noexcept {
            data_raw.fetch_or(0b111);
        }

-        inline void MarkDebug(u64 ptr, u16 block) noexcept {
+        constexpr void MarkDebug(u64 ptr, u16 block) noexcept {
            Store(true, PageType::DebugMemory, block, ptr);
        }

@@ -38,8 +38,7 @@ void FreeMemoryPages(void* base, std::size_t size) noexcept;

 /// A large page-aligned buffer that has optimized memory usage for zero-writes.
 template <typename T>
-    // MSVC doesn't regard structs with atomics as trivially copyable
-    // requires std::is_trivially_copyable_v<T>
+requires std::is_trivially_copyable_v<T>
 class SparseLargeVector final {
 public:
    constexpr SparseLargeVector() = default;
@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#elif defined(ARCHITECTURE_x86_64)
+#include <xmmintrin.h>
+#endif
+#include <atomic>
+
+namespace Common {
+
+/// @brief A lock similar to mutex that forces a thread to spin wait instead calling the
+/// supervisor. Should be used on short sequences of code.
+struct SpinLock {
+    SpinLock() noexcept = default;
+    SpinLock(const SpinLock&) noexcept = delete;
+    SpinLock& operator=(const SpinLock&) noexcept = delete;
+    SpinLock(SpinLock&&) noexcept = delete;
+    SpinLock& operator=(SpinLock&&) noexcept = delete;
+
+    inline void lock() noexcept {
+        while (lck.test_and_set(std::memory_order_acquire)) {
+#if defined(ARCHITECTURE_x86_64)
+            _mm_pause();
+#elif defined(ARCHITECTURE_arm64) && defined(_MSC_VER)
+            __yield();
+#elif defined(ARCHITECTURE_arm64)
+            asm("yield");
+#endif
+        }
+    }
+
+    inline void unlock() noexcept {
+        lck.clear(std::memory_order_release);
+    }
+
+    [[nodiscard]] inline bool try_lock() noexcept {
+        return !lck.test_and_set(std::memory_order_acquire);
+    }
+
+    std::atomic_flag lck = ATOMIC_FLAG_INIT;
+};
+
+} // namespace Common
@@ -208,9 +208,9 @@ UUID UUID::MakeRandomRFC4122V4() {
    return uuid;
 }

-UUID UUID::MakeRFC4122V5(std::span<u8, 16> sha1) {
+UUID UUID::MakeRFC4122V5(std::span<u8, 20> sha1) {
    UUID uuid{};
-    std::memcpy(&uuid.uuid, sha1.data(), sha1.size());
+    std::memcpy(&uuid.uuid, sha1.data(), sizeof(UUID));
    uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
    uuid.uuid[6] = 0x50 | (uuid.uuid[6] & 0xF);
    return uuid;
@@ -104,7 +104,7 @@ struct UUID {
    /// @returns A random UUID that is RFC 4122 Version 4 compliant.
    [[nodiscard]] static UUID MakeRandomRFC4122V4();

-    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 16> sha1);
+    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 20> sha1);

    friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) = default;
 };
@@ -796,8 +796,6 @@ add_library(core STATIC
    hle/service/ns/application_manager_interface.h
    hle/service/ns/application_version_interface.cpp
    hle/service/ns/application_version_interface.h
-    hle/service/ns/async_result.cpp
-    hle/service/ns/async_result.h
    hle/service/ns/content_management_interface.cpp
    hle/service/ns/content_management_interface.h
    hle/service/ns/develop_interface.cpp
@@ -812,6 +810,8 @@ add_library(core STATIC
    hle/service/ns/ecommerce_interface.h
    hle/service/ns/factory_reset_interface.cpp
    hle/service/ns/factory_reset_interface.h
+    hle/service/ns/i_async_result.cpp
+    hle/service/ns/i_async_result.h
    hle/service/ns/language.cpp
    hle/service/ns/language.h
    hle/service/ns/ns.cpp
@@ -1201,7 +1201,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)
@@ -22,15 +22,21 @@ DynarmicCallbacks32::DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess
    , m_check_memory_access{m_debugger_enabled || !Settings::values.cpuopt_ignore_memory_aborts.GetValue()}
 {}

-u64 DynarmicCallbacks32::MemoryRead(u32 vaddr, size_t size) {
-    CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Read);
-    switch (size) {
-    case sizeof(u64): return m_memory.Read64(vaddr);
-    case sizeof(u32): return m_memory.Read32(vaddr);
-    case sizeof(u16): return m_memory.Read16(vaddr);
-    case sizeof(u8): return m_memory.Read8(vaddr);
-    default: UNREACHABLE();
-    }
+u8 DynarmicCallbacks32::MemoryRead8(u32 vaddr) {
+    CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read8(vaddr);
+}
+u16 DynarmicCallbacks32::MemoryRead16(u32 vaddr) {
+    CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read16(vaddr);
+}
+u32 DynarmicCallbacks32::MemoryRead32(u32 vaddr) {
+    CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read32(vaddr);
+}
+u64 DynarmicCallbacks32::MemoryRead64(u32 vaddr) {
+    CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read64(vaddr);
 }

 std::optional<u32> DynarmicCallbacks32::MemoryReadCode(u32 vaddr) {
@@ -44,17 +50,27 @@ std::optional<u32> DynarmicCallbacks32::MemoryReadCode(u32 vaddr) {
    return cached_code_page.inst[(vaddr & Core::Memory::YUZU_PAGEMASK) / sizeof(u32)];
 }

-void DynarmicCallbacks32::MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) {
-    if (CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Write)) {
-        switch (size) {
-        case sizeof(u64): return m_memory.Write64(vaddr, value);
-        case sizeof(u32): return m_memory.Write32(vaddr, u32(value));
-        case sizeof(u16): return m_memory.Write16(vaddr, u16(value));
-        case sizeof(u8): return m_memory.Write8(vaddr, u8(value));
-        default: UNREACHABLE();
-        }
+void DynarmicCallbacks32::MemoryWrite8(u32 vaddr, u8 value) {
+    if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write8(vaddr, value);
    }
 }
+void DynarmicCallbacks32::MemoryWrite16(u32 vaddr, u16 value) {
+    if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write16(vaddr, value);
+    }
+}
+void DynarmicCallbacks32::MemoryWrite32(u32 vaddr, u32 value) {
+    if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write32(vaddr, value);
+    }
+}
+void DynarmicCallbacks32::MemoryWrite64(u32 vaddr, u64 value) {
+    if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write64(vaddr, value);
+    }
+}
+
 bool DynarmicCallbacks32::MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) {
    return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) &&
            m_memory.WriteExclusive8(vaddr, value, expected);
@@ -161,7 +177,7 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
        config.page_table = reinterpret_cast<std::array<std::uint8_t*, NumPageTableEntries>*>(
            const_cast<Common::PageTable::PageEntryData*>(page_table->entries.data()));
        config.page_table_pointer_mask = Common::PageTable::ATTRIBUTE_MASK;
-        config.page_table_marked_bit = uint8_t(0);
+        config.page_table_marked_bit = 0;
        config.absolute_offset_page_table = true;
        config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
        config.only_detect_misalignment_via_page_table_on_page_boundary = true;
@@ -177,7 +193,7 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
            Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize()) < (1ULL << 39)) {
            // Systems like FreeBSD allocate memory really low by default, and since we pack our page table entries,
            // we have to manually sign extend when our actual pointer is negative.
-            config.page_table_sign_extension = std::uint8_t(Common::PageTable::SIGN_BIT);
+            config.page_table_sign_extension = Common::PageTable::SIGN_BIT;
        }
    }

@@ -30,12 +30,18 @@ class System;
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
    explicit DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess* process);
-    u64 MemoryRead(u32 vaddr, size_t size) override;
+    u8 MemoryRead8(u32 vaddr) override;
+    u16 MemoryRead16(u32 vaddr) override;
+    u32 MemoryRead32(u32 vaddr) override;
+    u64 MemoryRead64(u32 vaddr) override;
    std::optional<u32> MemoryReadCode(u32 vaddr) override;
    void InstructionSynchronizationBarrierRaised() override {
        last_code_addr = u64(-1); //reset back, force refetch
    }
-    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override;
+    void MemoryWrite8(u32 vaddr, u8 value) override;
+    void MemoryWrite16(u32 vaddr, u16 value) override;
+    void MemoryWrite32(u32 vaddr, u32 value) override;
+    void MemoryWrite64(u32 vaddr, u64 value) override;
    bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override;
    bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override;
    bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override;
@@ -10,7 +10,6 @@
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_process.h"
-#include "dynarmic/interface/A64/config.h"

 namespace Core {

@@ -22,15 +21,21 @@ DynarmicCallbacks64::DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess
    , m_check_memory_access{m_debugger_enabled || !Settings::values.cpuopt_ignore_memory_aborts.GetValue()}
 {}

-u64 DynarmicCallbacks64::MemoryRead(u64 vaddr, size_t size) {
-    CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Read);
-    switch (size) {
-    case sizeof(u64): return m_memory.Read64(vaddr);
-    case sizeof(u32): return m_memory.Read32(vaddr);
-    case sizeof(u16): return m_memory.Read16(vaddr);
-    case sizeof(u8): return m_memory.Read8(vaddr);
-    default: UNREACHABLE();
-    }
+u8 DynarmicCallbacks64::MemoryRead8(u64 vaddr) {
+    CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read8(vaddr);
+}
+u16 DynarmicCallbacks64::MemoryRead16(u64 vaddr) {
+    CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read16(vaddr);
+}
+u32 DynarmicCallbacks64::MemoryRead32(u64 vaddr) {
+    CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read32(vaddr);
+}
+u64 DynarmicCallbacks64::MemoryRead64(u64 vaddr) {
+    CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read64(vaddr);
 }
 Dynarmic::A64::Vector DynarmicCallbacks64::MemoryRead128(u64 vaddr) {
    CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Read);
@@ -48,15 +53,24 @@ std::optional<u32> DynarmicCallbacks64::MemoryReadCode(u64 vaddr) {
    return cached_code_page.inst[(vaddr & Core::Memory::YUZU_PAGEMASK) / sizeof(u32)];
 }

-void DynarmicCallbacks64::MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, std::size_t size) {
-    if (CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Write)) {
-        switch (size) {
-        case sizeof(u64): return m_memory.Write64(vaddr, u64(value));
-        case sizeof(u32): return m_memory.Write32(vaddr, u32(value));
-        case sizeof(u16): return m_memory.Write16(vaddr, u16(value));
-        case sizeof(u8): return m_memory.Write8(vaddr, u8(value));
-        default: UNREACHABLE();
-        }
+void DynarmicCallbacks64::MemoryWrite8(u64 vaddr, u8 value) {
+    if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write8(vaddr, value);
+    }
+}
+void DynarmicCallbacks64::MemoryWrite16(u64 vaddr, u16 value) {
+    if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write16(vaddr, value);
+    }
+}
+void DynarmicCallbacks64::MemoryWrite32(u64 vaddr, u32 value) {
+    if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write32(vaddr, value);
+    }
+}
+void DynarmicCallbacks64::MemoryWrite64(u64 vaddr, u64 value) {
+    if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write64(vaddr, value);
    }
 }
 void DynarmicCallbacks64::MemoryWrite128(u64 vaddr, Dynarmic::A64::Vector value) {
@@ -202,7 +216,7 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
            const_cast<Common::PageTable::PageEntryData*>(page_table->entries.data()));
        config.page_table_address_space_bits = std::uint32_t(address_space_bits);
        config.page_table_pointer_mask = Common::PageTable::ATTRIBUTE_MASK;
-        config.page_table_marked_bit = uint8_t(0);
+        config.page_table_marked_bit = 0;
        config.silently_mirror_page_table = false;
        config.absolute_offset_page_table = true;
        config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
@@ -221,7 +235,7 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
            Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize()) < (1ULL << 39)) {
            // Systems like FreeBSD allocate memory really low by default, and since we pack our page table entries,
            // we have to manually sign extend when our actual pointer is negative.
-            config.page_table_sign_extension = std::uint8_t(Common::PageTable::SIGN_BIT);
+            config.page_table_sign_extension = Common::PageTable::SIGN_BIT;
        }
    }

@@ -16,7 +16,6 @@
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
-#include "dynarmic/interface/A64/config.h"

 namespace Core::Memory {
 class Memory;
@@ -37,13 +36,19 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
    explicit DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess* process);

-    u64 MemoryRead(u64 vaddr, size_t size) override;
+    u8 MemoryRead8(u64 vaddr) override;
+    u16 MemoryRead16(u64 vaddr) override;
+    u32 MemoryRead32(u64 vaddr) override;
+    u64 MemoryRead64(u64 vaddr) override;
    Dynarmic::A64::Vector MemoryRead128(u64 vaddr) override;
    std::optional<u32> MemoryReadCode(u64 vaddr) override;
    void InstructionSynchronizationBarrierRaised() override {
        last_code_addr = u64(-1); //reset back, force refetch
    }
-    void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, std::size_t size) override;
+    void MemoryWrite8(u64 vaddr, u8 value) override;
+    void MemoryWrite16(u64 vaddr, u16 value) override;
+    void MemoryWrite32(u64 vaddr, u32 value) override;
+    void MemoryWrite64(u64 vaddr, u64 value) override;
    void MemoryWrite128(u64 vaddr, Dynarmic::A64::Vector value) override;
    bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, std::uint8_t expected) override;
    bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override;
@@ -100,7 +100,8 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {


 struct IPSwitchRecord {
-    std::vector<uint8_t> data;
+    std::array<uint8_t, 256 - sizeof(size_t)> data;
+    size_t count;
 };
 struct IPSwitchCompiler::IPSwitchPatch {
    ::Common::unordered_map<u32, IPSwitchRecord> records;
@@ -121,23 +122,22 @@ static IPSwitchRecord EscapeStringSequences(std::string_view sv) {
    IPSwitchRecord r{};
    for (auto it = sv.cbegin(); it < sv.cend(); ) {
        if (*it == '\\' && it + 1 < sv.cend()) {
-            r.data.push_back([it]() {
-                switch (it[1]) {
-                case 'a': return '\a';
-                case 'b': return '\b';
-                case 'e': return '\e';
-                case 'f': return '\f';
-                case 'n': return '\n';
-                case 'r': return '\r';
-                case 't': return '\t';
-                case 'v': return '\v';
-                case '?': return '\?';
-                default: return it[1];
-                }
-            }());
+            switch (it[1]) {
+            case 'a': r.data[r.count] = '\a'; break;
+            case 'b': r.data[r.count] = '\b'; break;
+            case 'e': r.data[r.count] = '\e'; break;
+            case 'f': r.data[r.count] = '\f'; break;
+            case 'n': r.data[r.count] = '\n'; break;
+            case 'r': r.data[r.count] = '\r'; break;
+            case 't': r.data[r.count] = '\t'; break;
+            case 'v': r.data[r.count] = '\v'; break;
+            case '?': r.data[r.count] = '\?'; break;
+            default: r.data[r.count] = it[1]; break;
+            }
+            ++r.count;
            it += 2;
        } else {
-            r.data.push_back(*it);
+            ++r.count;
            ++it;
        }
    }
@@ -223,8 +223,8 @@ void IPSwitchCompiler::Parse(std::span<u8 const> bytes) {
                if (start <= line.cend() && end <= line.cend()) {
                    // Actually IPS wants ordering from {lsb, ..., msb} -- so LE and BE are inverted, fun!
                    auto const hs = Common::HexStringToVector({start, end}, is_little_endian);
-                    r.data.resize(hs.size());
                    std::memcpy(r.data.data(), hs.data(), hs.size());
+                    r.count = hs.size();
                    LOG_INFO(Loader, "[H] value @ {:#08X}", offset);
                    patches.back().records.insert_or_assign(u32(offset), std::move(r));
                } else {
@@ -293,7 +293,7 @@ VirtualFile IPSwitchCompiler::Apply(const VirtualFile& in) const {
        if (patch.enabled) {
            for (const auto& record : patch.records) {
                if (record.first < in_data.size()) {
-                    auto replace_size = record.second.data.size();
+                    auto replace_size = record.second.count;
                    if (record.first + replace_size > in_data.size())
                        replace_size = in_data.size() - record.first;
                    std::memcpy(in_data.data() + record.first, record.second.data.data(), replace_size);
@@ -9,7 +9,6 @@
 #include <cstddef>
 #include <cstring>

-#include "common/assert.h"
 #include "common/hex_util.h"
 #include "common/logging.h"
 #include "common/settings.h"
@@ -157,15 +156,12 @@ std::string GetUpdateVersionStringFromSlot(const ContentProvider* provider, u64
    NACP nacp{nacp_file};
    return nacp.GetVersionString();
 }
-YUZU_NO_INLINE std::optional<u64> GetParentApplicationId(const ContentProvider* provider, u64 title_id) {
-    return provider == nullptr ? std::nullopt : provider->GetParentApplicationId(title_id);
-}
 } // Anonymous namespace

 PatchManager::PatchManager(u64 title_id_,
                           const Service::FileSystem::FileSystemController& fs_controller_,
                           const ContentProvider& content_provider_)
-    : title_id{title_id_}, parent_title_id{GetParentApplicationId(std::addressof(content_provider_), title_id_)}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
+    : title_id{title_id_}, fs_controller{fs_controller_}, content_provider{content_provider_} {}

 PatchManager::~PatchManager() = default;

@@ -173,35 +169,13 @@ u64 PatchManager::GetTitleID() const {
    return title_id;
 }

-VirtualDir PatchManager::GetModificationLoadRoot(bool sdmc) const {
-    const auto get_root = [&](u64 id) {
-        return sdmc ? fs_controller.GetSDMCModificationLoadRoot(id) : fs_controller.GetModificationLoadRoot(id);
-    };
-    auto root = get_root(title_id);
-    if (!parent_title_id) {
-        return root;
-    }
-    std::vector<VirtualDir> roots{std::move(root), get_root(*parent_title_id)};
-    std::erase(roots, nullptr);
-    return LayeredVfsDirectory::MakeLayeredDirectory(std::move(roots));
-}
-
-std::vector<std::string> PatchManager::GetDisabledAddons() const {
-    auto disabled = Settings::values.disabled_addons[title_id];
-    if (parent_title_id) {
-        const auto& shared = Settings::values.disabled_addons[*parent_title_id];
-        disabled.insert(disabled.end(), shared.begin(), shared.end());
-    }
-    return disabled;
-}
-
 VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);

    if (exefs == nullptr)
        return exefs;

-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];

    bool update_disabled = true;
    std::optional<u32> enabled_version;
@@ -329,8 +303,8 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    }

    // LayeredExeFS
-    const auto load_dir = GetModificationLoadRoot();
-    const auto sdmc_load_dir = GetModificationLoadRoot(true);
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);

    std::vector<VirtualDir> patch_dirs = {sdmc_load_dir};
    if (load_dir != nullptr) {
@@ -372,7 +346,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 }

 std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs, const std::string& build_id) const {
-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
    const auto nso_build_id = fmt::format("{:0<64}", build_id);

    std::vector<VirtualFile> out;
@@ -431,7 +405,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st

    LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);

-    const auto load_dir = GetModificationLoadRoot();
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
        return nso;
@@ -474,7 +448,7 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)

    LOG_INFO(Loader, "Querying NSO patch existence for build_id={}, name={}", build_id, name);

-    const auto load_dir = GetModificationLoadRoot();
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
        return false;
@@ -488,13 +462,13 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)
 }

 std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildID& build_id_) const {
-    const auto load_dir = GetModificationLoadRoot();
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
        return {};
    }

-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
    auto patch_dirs = load_dir->GetSubdirectories();
    std::sort(patch_dirs.begin(), patch_dirs.end(), [](auto const& l, auto const& r) { return l->GetName() < r->GetName(); });

@@ -528,16 +502,17 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildI
    return out;
 }

-void PatchManager::ApplyLayeredFS(VirtualFile& romfs, ContentRecordType type) const {
-    const auto load_dir = GetModificationLoadRoot();
-    const auto sdmc_load_dir = GetModificationLoadRoot(true);
+static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type,
+                           const Service::FileSystem::FileSystemController& fs_controller) {
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
    if ((type != ContentRecordType::Program && type != ContentRecordType::Data &&
         type != ContentRecordType::HtmlDocument) ||
        (load_dir == nullptr && sdmc_load_dir == nullptr)) {
        return;
    }

-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
    std::vector<VirtualDir> patch_dirs = load_dir->GetSubdirectories();
    if (std::find(disabled.cbegin(), disabled.cend(), "SDMC") == disabled.cend()) {
        patch_dirs.push_back(sdmc_load_dir);
@@ -616,7 +591,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs

    // Game Updates
    const auto update_tid = GetUpdateTitleID(title_id);
-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];

    bool update_disabled = true;
    std::optional<u32> enabled_version;
@@ -723,7 +698,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs

    // LayeredFS
    if (apply_layeredfs) {
-        ApplyLayeredFS(romfs, type);
+        ApplyLayeredFS(romfs, title_id, type, fs_controller);
    }

    return romfs;
@@ -1097,22 +1072,15 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
 std::optional<u32> PatchManager::GetGameVersion() const {
    const auto update_tid = GetUpdateTitleID(title_id);
    if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
-        const auto version = content_provider.GetEntryVersion(update_tid);
-        return version || !parent_title_id ? version : content_provider.GetEntryVersion(GetUpdateTitleID(*parent_title_id));
+        return content_provider.GetEntryVersion(update_tid);
    }

-    const auto version = content_provider.GetEntryVersion(title_id);
-    return version || !parent_title_id ? version : content_provider.GetEntryVersion(*parent_title_id);
+    return content_provider.GetEntryVersion(title_id);
 }

 PatchManager::Metadata PatchManager::GetControlMetadata() const {
    const auto base_control_nca = content_provider.GetEntry(title_id, ContentRecordType::Control);
    if (base_control_nca == nullptr) {
-        if (parent_title_id) {
-            const auto control_id = content_provider.HasEntry(*parent_title_id, ContentRecordType::Control) ? *parent_title_id : GetUpdateTitleID(*parent_title_id);
-            const PatchManager parent{control_id, fs_controller, content_provider};
-            return parent.GetControlMetadata();
-        }
        return {};
    }

@@ -109,14 +109,10 @@ public:
    [[nodiscard]] static PatchManager::Metadata GetMetadataFromBaseOrUpdate(Core::System& system, u64 application_id) noexcept;

 private:
-    [[nodiscard]] VirtualDir GetModificationLoadRoot(bool sdmc = false) const;
-    [[nodiscard]] std::vector<std::string> GetDisabledAddons() const;
-    void ApplyLayeredFS(VirtualFile& romfs, ContentRecordType type) const;
    [[nodiscard]] std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
                                                          const std::string& build_id) const;

    u64 title_id;
-    std::optional<u64> parent_title_id;
    const Service::FileSystem::FileSystemController& fs_controller;
    const ContentProvider& content_provider;
 };
@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <algorithm>
-#include <limits>
 #include <random>
 #include <regex>
 #include <openssl/evp.h>
@@ -349,22 +348,6 @@ std::vector<ContentProviderEntry> ContentProvider::ListEntries() const {
    return ListEntriesFilter(std::nullopt, std::nullopt, std::nullopt);
 }

-std::optional<u64> ContentProvider::GetParentApplicationId(u64 program_id) const {
-    const auto application_id = GetBaseTitleID(program_id);
-    const auto program_index = program_id - application_id;
-    if (program_index == 0 || program_index > std::numeric_limits<u8>::max()) {
-        return std::nullopt;
-    }
-    if (!ListEntriesFilter(TitleType::Application, ContentRecordType::Meta, program_id).empty()) {
-        return std::nullopt;
-    }
-    if ((!ListEntriesFilter(TitleType::Application, ContentRecordType::Meta, application_id).empty() && HasEntry(program_id, ContentRecordType::Program))
-     || (!ListEntriesFilter(TitleType::Update, ContentRecordType::Meta, GetUpdateTitleID(application_id)).empty() && HasEntry(GetUpdateTitleID(program_id), ContentRecordType::Program))) {
-        return application_id;
-    }
-    return std::nullopt;
-}
-
 PlaceholderCache::PlaceholderCache(VirtualDir dir_) : dir(std::move(dir_)) {}

 bool PlaceholderCache::Create(const NcaID& id, u64 size) const {
@@ -100,8 +100,6 @@ public:
        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
        std::optional<u64> title_id = {}) const = 0;

-    [[nodiscard]] std::optional<u64> GetParentApplicationId(u64 program_id) const;
-
 protected:
    // A single instance of KeyManager to be used by GetEntry()
    Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();
@@ -9,7 +9,6 @@
 #include "common/logging.h"
 #include "common/uuid.h"
 #include "core/core.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs/vfs.h"

@@ -62,24 +61,17 @@ SaveDataFactory::SaveDataFactory(Core::System& system_, ProgramId program_id_,

 SaveDataFactory::~SaveDataFactory() = default;

-std::string SaveDataFactory::GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const {
-    if (type == SaveDataType::Account || type == SaveDataType::Device) {
-        const auto requested_id = title_id != 0 ? title_id : program_id;
-        const auto parent_id = system.GetContentProvider().GetParentApplicationId(requested_id);
-        title_id = parent_id.value_or(requested_id);
-    }
-    return GetFullPath(program_id, dir, space, type, title_id, user_id, save_id);
-}
-
 VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
-    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);

    return dir->CreateDirectoryRelative(save_directory);
 }

 VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {

-    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);

    auto out = dir->GetDirectoryRelative(save_directory);

@@ -162,7 +154,8 @@ std::string SaveDataFactory::GetUserGameSaveDataRoot(u128 user_id, bool future)

 SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
                                               u128 user_id) const {
-    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
    const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);

    const auto size_file = relative_dir->GetFile(GetSaveDataSizeFileName());
@@ -180,7 +173,8 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,

 void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
                                        SaveDataSize new_value) const {
-    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
    const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);

    const auto size_file = relative_dir->CreateFile(GetSaveDataSizeFileName());
@@ -1,6 +1,3 @@
-// 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

@@ -50,7 +47,6 @@ public:
    void SetAutoCreate(bool state);

 private:
-    std::string GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const;
    Core::System& system;
    ProgramId program_id;
    VirtualDir dir;
@@ -465,10 +465,6 @@ void KScheduler::ScheduleImplFiber(KernelCore& kernel) {
        // Check if we need scheduling. If we do, then we can't complete the switch and should
        // retry.
        if (m_state.needs_scheduling.load(std::memory_order_seq_cst)) {
-            // Some libc++ lazily init mutex
-            [[maybe_unused]] auto const can_lock = highest_priority_thread->m_context_guard.try_lock();
-            DEBUG_ASSERT(!can_lock);
-
            // Our switch failed.
            // We should unlock the thread context, and then retry.
            highest_priority_thread->m_context_guard.unlock();
@@ -500,10 +496,6 @@ void KScheduler::Unload(KernelCore& kernel, KThread* thread) {

    // Check if the thread is terminated by checking the DPC flags.
    if ((thread->GetStackParameters().dpc_flags & static_cast<u32>(DpcFlag::Terminated)) == 0) {
-        // Some libc++ lazily init mutex
-        [[maybe_unused]] auto const can_lock = thread->m_context_guard.try_lock();
-        DEBUG_ASSERT(!can_lock);
-
        // The thread isn't terminated, so we want to unlock it.
        thread->m_context_guard.unlock();
    }
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -12,6 +12,7 @@
 #include "common/atomic_ops.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/spin_lock.h"

 namespace Kernel {

@@ -29,7 +30,7 @@ public:
    };

 public:
-    KSlabHeapImpl() = default;
+    constexpr KSlabHeapImpl() = default;

    void Initialize() {
        ASSERT(m_head == nullptr);
@@ -67,7 +68,7 @@ public:

 private:
    std::atomic<Node*> m_head{};
-    std::mutex m_lock;
+    Common::SpinLock m_lock;
 };

 } // namespace impl
@@ -19,6 +19,7 @@

 #include "common/intrusive_red_black_tree.h"
 #include "common/scratch_buffer.h"
+#include "common/spin_lock.h"
 #include "core/arm/arm_interface.h"
 #include "core/hle/kernel/k_affinity_mask.h"
 #include "core/hle/kernel/k_light_lock.h"
@@ -919,7 +920,7 @@ private:
    bool m_resource_limit_release_hint{};
    bool m_is_kernel_address_key{};
    StackParameters m_stack_parameters{};
-    std::mutex m_context_guard{};
+    Common::SpinLock m_context_guard{};

    // For emulation
    std::shared_ptr<Common::Fiber> m_host_context{};
@@ -23,12 +23,6 @@ constexpr std::size_t profile_username_size{32};
 using ProfileUsername = std::array<u8, profile_username_size>;
 using UserIDArray = std::array<Common::UUID, MAX_USERS>;

-// This is nn::account::Uid
-struct Uid {
-    std::array<u8, 0x10> unk0;
-};
-static_assert(sizeof(Uid) == 0x10);
-
 /// Contains extra data related to a user.
 /// TODO: RE this structure
 struct UserData {
@@ -29,7 +29,6 @@
 #include "core/hle/service/am/frontend/applet_web_browser.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/am/service/storage.h"
-#include "core/hle/service/am/window_system.h"
 #include "core/hle/service/sm/sm.h"

 namespace Service::AM::Frontend {
@@ -73,16 +72,10 @@ void FrontendApplet::PushInteractiveOutData(std::shared_ptr<IStorage> storage) {

 void FrontendApplet::Exit() {
    auto applet_ = applet.lock();
-    {
-        std::scoped_lock lk{applet_->lock};
-        applet_->is_completed = true;
-        applet_->state_changed_event.Signal(system.Kernel());
-    }
-    if (auto caller_applet = applet_->caller_applet.lock()) {
-        std::scoped_lock lk{caller_applet->lock};
-        std::erase(caller_applet->child_applets, applet_);
-    }
-    if (auto* window_system = system.GetAppletManager().GetWindowSystem()) window_system->RequestUpdate();
+
+    std::scoped_lock lk{applet_->lock};
+    applet_->is_completed = true;
+    applet_->state_changed_event.Signal(system.Kernel());
 }

 FrontendAppletSet::FrontendAppletSet() = default;
@@ -92,13 +92,6 @@ public:
        }
    }

-    void RequestFocusStateChangedNotification(Kernel::KernelCore& kernel) {
-        if (m_focus_state_changed_notification_enabled) {
-            m_has_focus_state_changed = true;
-            this->SignalSystemEventIfNeeded(kernel);
-        }
-    }
-
    void OnOperationAndPerformanceModeChanged(Kernel::KernelCore& kernel);

 public:
@@ -347,22 +347,21 @@ Result IApplicationFunctions::NotifyRunning(Out<bool> out_became_running) {

 Result IApplicationFunctions::GetPseudoDeviceId(Out<Common::UUID> out_pseudo_device_id) {
    LOG_WARNING(Service_AM, "(stubbed)");
-    R_UNLESS(out_pseudo_device_id != nullptr, ResultUnknown);
+    R_UNLESS(out_pseudo_device_id, ResultUnknown);

    // This should be hashed with the device specific hash
    // for now this will do
    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
-    R_UNLESS(res.first != nullptr, ResultUnknown);
-    std::array<u8, EVP_MAX_MD_SIZE> hash;
+    u8 hash[EVP_MAX_MD_SIZE];
    unsigned int hash_len = 0;
    auto const seed = res.first->raw.seed_for_pseudo_device_id;
    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
    auto const algorithm = EVP_sha1();
    EVP_DigestInit_ex(ctx, algorithm, nullptr);
    EVP_DigestUpdate(ctx, &seed, sizeof(seed));
-    EVP_DigestFinal_ex(ctx, hash.data(), &hash_len);
+    EVP_DigestFinal_ex(ctx, hash, &hash_len);
    EVP_MD_CTX_free(ctx);
-    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 16>{hash.begin(), hash.begin() + 16});
+    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 20>{hash, std::size(hash)});
    R_SUCCEED();
 }

@@ -164,15 +164,15 @@ Result ILibraryAppletAccessor::PushInData(SharedPointer<IStorage> storage) {
 Result ILibraryAppletAccessor::PopOutData(Out<SharedPointer<IStorage>> out_storage) {
    LOG_DEBUG(Service_AM, "called");

-    R_TRY(m_broker->GetOutData().Pop(system.Kernel(), out_storage.Get()));
    if (auto caller_applet = m_applet->caller_applet.lock(); caller_applet) {
-        std::scoped_lock lk{caller_applet->lock};
-        const bool focus_state_changed = caller_applet->lifecycle_manager.UpdateRequestedFocusState();
-        const bool is_front_app = m_applet->frontend && caller_applet->lifecycle_manager.IsApplication();
-        if (focus_state_changed) caller_applet->lifecycle_manager.SignalSystemEventIfNeeded(system.Kernel());
-        else if (is_front_app) caller_applet->lifecycle_manager.RequestFocusStateChangedNotification(system.Kernel());
+        caller_applet->lifecycle_manager.GetSystemEvent().Signal(system.Kernel());
+        caller_applet->lifecycle_manager.RequestResumeNotification();
+        caller_applet->lifecycle_manager.GetSystemEvent().Clear(system.Kernel());
+        caller_applet->lifecycle_manager.UpdateRequestedFocusState();
    }

+    R_TRY(m_broker->GetOutData().Pop(system.Kernel(), out_storage.Get()));
+
    if (m_applet->applet_id == AppletId::ProfileSelect && *out_storage) {
        auto impl = (*out_storage)->GetImpl();

@@ -122,10 +122,7 @@ std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,
        auto broker = std::make_shared<AppletDataBroker>(system);
        applet->caller_applet = caller_applet;
        applet->caller_applet_broker = broker;
-        {
-            std::scoped_lock lk{caller_applet->lock};
-            caller_applet->child_applets.push_back(applet);
-        }
+        caller_applet->child_applets.push_back(applet);
        window_system.TrackApplet(applet, false);
        return std::make_shared<ILibraryAppletAccessor>(system, broker, applet);
    }
@@ -151,10 +148,10 @@ std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(Core::System& syste
    applet->caller_applet = caller_applet;
    applet->caller_applet_broker = storage;
    applet->frontend = system.GetFrontendAppletHolder().GetApplet(applet, applet_id, mode);
-    {
-        std::scoped_lock lk{caller_applet->lock};
-        caller_applet->child_applets.push_back(applet);
-    }
+    caller_applet->child_applets.push_back(applet);
+
+    window_system.TrackApplet(applet, false);
+
    return std::make_shared<ILibraryAppletAccessor>(system, storage, applet);
 }

@@ -154,9 +154,6 @@ FSP_SRV::FSP_SRV(Core::System& system_)
        {720, nullptr, "AbandonAccessFailure"},
        {800, nullptr, "GetAndClearFileSystemProxyErrorInfo"},
        {810, nullptr, "RegisterProgramIndexMapInfo"},
-        {820, nullptr, "GetContentStorageInfoIndex"},
-        {830, nullptr, "EncryptStreamPlaySaveData"},
-        {831, nullptr, "DecryptStreamPlaySaveData"},
        {1000, nullptr, "SetBisRootForHost"},
        {1001, nullptr, "SetSaveDataSize"},
        {1002, nullptr, "SetSaveDataRootPath"},
@@ -121,7 +121,7 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour
        {547, nullptr, "GetAllowedBluetoothLinksCount"},
        {548, &IHidSystemServer::GetRegisteredDevices, "GetRegisteredDevices"},
        {549, nullptr, "GetConnectableRegisteredDevices"},
-        {551, &IHidSystemServer::GetRegisteredDevices, "GetRegisteredDevicesForControllerSupport"}, //20.0.0+ //mocked via 548 for Diablo 3 (at least)
+        {551, nullptr, "GetRegisteredDevicesForControllerSupport"}, //20.0.0+
        {700, nullptr, "ActivateUniquePad"},
        {702, &IHidSystemServer::AcquireUniquePadConnectionEventHandle, "AcquireUniquePadConnectionEventHandle"},
        {703, &IHidSystemServer::GetUniquePadIds, "GetUniquePadIds"},
@@ -758,7 +758,7 @@ void IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport(HLEReque
 }

 void IHidSystemServer::GetRegisteredDevices(HLERequestContext& ctx) {
-    LOG_WARNING(Service_HID, "(STUBBED) called, command={}", ctx.GetCommand()); //548 or 551
+    LOG_WARNING(Service_HID, "(STUBBED) called");

    struct RegisterData {
        std::array<u8, 0x68> data;
@@ -22,7 +22,6 @@

 namespace IPC {

-constexpr Result ResultNotSupported{ErrorModule::HIPC, 1};
 constexpr Result ResultSessionClosed{ErrorModule::HIPC, 301};

 struct ResponseBuilder {
@@ -71,14 +71,17 @@ public:
    void InstructionSynchronizationBarrierRaised() override {
        last_code_addr = u64(-1); //reset back, force refetch
    }
-    u64 MemoryRead(u64 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return ReadMemory<u64>(vaddr);
-        case sizeof(u32): return ReadMemory<u32>(vaddr);
-        case sizeof(u16): return ReadMemory<u16>(vaddr);
-        case sizeof(u8): return ReadMemory<u8>(vaddr);
-        default: UNREACHABLE();
-        }
+    u8 MemoryRead8(u64 vaddr) override {
+        return ReadMemory<u8>(vaddr);
+    }
+    u16 MemoryRead16(u64 vaddr) override {
+        return ReadMemory<u16>(vaddr);
+    }
+    u32 MemoryRead32(u64 vaddr) override {
+        return ReadMemory<u32>(vaddr);
+    }
+    u64 MemoryRead64(u64 vaddr) override {
+        return ReadMemory<u64>(vaddr);
    }
    u128 MemoryRead128(u64 vaddr) override {
        return ReadMemory<u128>(vaddr);
@@ -86,19 +89,22 @@ public:
    std::string MemoryReadCString(u64 vaddr) {
        std::string result{};
        u8 next;
-        while ((next = u8(MemoryRead(vaddr++, sizeof(u8)))) != 0)
+        while ((next = MemoryRead8(vaddr++)) != 0)
            result += char(next);
        return result;
    }

-    void MemoryWrite(u64 vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64): WriteMemory<u64>(vaddr, u64(value)); break;
-        case sizeof(u32): WriteMemory<u32>(vaddr, u32(value)); break;
-        case sizeof(u16): WriteMemory<u16>(vaddr, u16(value)); break;
-        case sizeof(u8): WriteMemory<u8>(vaddr, u8(value)); break;
-        default: UNREACHABLE();
-        }
+    void MemoryWrite8(u64 vaddr, u8 value) override {
+        WriteMemory<u8>(vaddr, value);
+    }
+    void MemoryWrite16(u64 vaddr, u16 value) override {
+        WriteMemory<u16>(vaddr, value);
+    }
+    void MemoryWrite32(u64 vaddr, u32 value) override {
+        WriteMemory<u32>(vaddr, value);
+    }
+    void MemoryWrite64(u64 vaddr, u64 value) override {
+        WriteMemory<u64>(vaddr, value);
    }
    void MemoryWrite128(u64 vaddr, u128 value) override {
        WriteMemory<u128>(vaddr, value);
@@ -187,14 +193,14 @@ public:
        // The loaded NRO file has ELF relocations that must be processed before it can run.
        // Normally this would be processed by RTLD, but in HLE context, we don't have
        // the linker available, so we have to do it ourselves.
-        const VAddr mod_offset{callbacks->MemoryRead(4, sizeof(u32))};
-        if (callbacks->MemoryRead(mod_offset, sizeof(u32)) != Common::MakeMagic('M', 'O', 'D', '0'))
+        const VAddr mod_offset{callbacks->MemoryRead32(4)};
+        if (callbacks->MemoryRead32(mod_offset) != Common::MakeMagic('M', 'O', 'D', '0'))
            return false;

        // For more info about dynamic entries, see the ELF ABI specification:
        // https://refspecs.linuxbase.org/elf/gabi4+/ch5.dynamic.html
        // https://refspecs.linuxbase.org/elf/gabi4+/ch4.reloc.html
-        VAddr dynamic_offset{mod_offset + callbacks->MemoryRead(mod_offset + 4, sizeof(u32))};
+        VAddr dynamic_offset{mod_offset + callbacks->MemoryRead32(mod_offset + 4)};
        VAddr rela_dyn = 0, relr_dyn = 0;
        size_t num_rela = 0, num_relr = 0;
        while (true) {
@@ -216,8 +222,8 @@ public:
        for (size_t i = 0; i < num_rela; i++) {
            const auto rela{callbacks->ReadMemory<Elf64_Rela>(rela_dyn + i * sizeof(Elf64_Rela))};
            if (Elf64RelType(rela.r_info) == ElfAArch64Relative) {
-                const VAddr contents{callbacks->MemoryRead(rela.r_offset, sizeof(u64))};
-                callbacks->MemoryWrite(rela.r_offset, contents + rela.r_addend, sizeof(u64));
+                const VAddr contents{callbacks->MemoryRead64(rela.r_offset)};
+                callbacks->MemoryWrite64(rela.r_offset, contents + rela.r_addend);
            }
        }

@@ -225,7 +231,7 @@ public:
        for (size_t i = 0; i < num_relr; i++) {
            const auto relr = callbacks->ReadMemory<Elf64_Relr>(relr_dyn + i * sizeof(Elf64_Relr));
            const auto incr = [&](VAddr where) {
-                callbacks->MemoryWrite(where, callbacks->MemoryRead(where, sizeof(u64)) + relocbase, sizeof(u64));
+                callbacks->MemoryWrite64(where, callbacks->MemoryRead64(where) + relocbase);
            };
            if ((relr & 1) == 0) {
                // where pointer
@@ -288,7 +294,7 @@ public:
        if (argument_stack.size() > 8) {
            const VAddr new_sp = Common::AlignDown(top_of_stack - (argument_stack.size() - 8) * sizeof(u64), STACK_ALIGN);
            for (size_t i = 8; i < argument_stack.size(); i++)
-                callbacks->MemoryWrite(new_sp + (i - 8) * sizeof(u64), argument_stack[i], sizeof(u64));
+                callbacks->MemoryWrite64(new_sp + (i - 8) * sizeof(u64), argument_stack[i]);
            jit->SetSP(new_sp);
        }
        // Reset the call state for the next invocation
@@ -379,17 +385,17 @@ void DynarmicCallbacks64::CallSVC(u32 swi) {

        if (dest < src) {
            for (size_t i = 0; i < n; i++)
-                MemoryWrite(dest + i, u8(MemoryRead(src + i, sizeof(u8))), sizeof(u8));
+                MemoryWrite8(dest + i, MemoryRead8(src + i));
        } else {
            for (size_t i = n; i > 0; i--)
-                MemoryWrite(dest + i - 1, u8(MemoryRead(src + i - 1, sizeof(u8))), sizeof(u8));
+                MemoryWrite8(dest + i - 1, MemoryRead8(src + i - 1));
        }
    } else if (pc == parent.helpers[size_t(HelperFn::Memset)]) {
        const VAddr dest{parent.jit->GetRegister(0)};
        const u64 c{parent.jit->GetRegister(1)};
        const size_t n{parent.jit->GetRegister(2)};
        for (size_t i = 0; i < n; i++)
-            MemoryWrite(dest + i, u8(c), sizeof(u8));
+            MemoryWrite8(dest + i, u8(c));
    } else if (pc == parent.helpers[size_t(HelperFn::Resolve)]) {
        // X0 contains a char* for a symbol to resolve
        const auto name{MemoryReadCString(parent.jit->GetRegister(0))};
@@ -416,7 +422,7 @@ void DynarmicCallbacks64::CallSVC(u32 swi) {
 }

 void DynarmicCallbacks64::ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) {
-    auto const inst = MemoryRead(pc, sizeof(u32));
+    auto const inst = MemoryRead32(pc);
    LOG_CRITICAL(Service_JIT, "{} PC @ {:08x}, data = {:08x}", exception, pc, inst);
    parent.jit->HaltExecution();
 }
@@ -6,16 +6,10 @@

 #include "common/string_util.h"
 #include "core/core.h"
-#include "core/hle/kernel/k_client_session.h"
-#include "core/hle/result.h"
-#include "core/hle/service/acc/profile_manager.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ngc/ngc.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "frontend_common/firmware_manager.h"

 namespace Service::NGC {

@@ -172,123 +166,12 @@ public:
    }
 };

-struct SaveDataHandle {
-    u64 unk0;
-};
-static_assert(sizeof(SaveDataHandle) == 0x08);
-
-class IUserShimScopedObject final : public ServiceFramework<IUserShimScopedObject> {
-public:
-    explicit IUserShimScopedObject(Core::System& system_) : ServiceFramework(system_, "IUserShimScopedObject") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {450, nullptr, "InitializeForSaveData"},
-            {451, nullptr, "FinalizeForSaveData"},
-            {452, D<&IUserShimScopedObject::OpenSaveData>, "OpenSaveData"},
-            {453, nullptr, "CloseSaveData"},
-            {454, D<&IUserShimScopedObject::ReadSaveSlot>, "ReadSaveSlot"},
-            {455, D<&IUserShimScopedObject::WriteSaveSlot>, "WriteSaveSlot"},
-            {456, nullptr, "FlushSaveSlot"},
-            {457, nullptr, "CommitSaveData"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-
-    Result OpenSaveData(Account::Uid unk0, Out<SaveDataHandle> unk1) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-
-    Result ReadSaveSlot(s32 offset, SaveDataHandle handle, OutBuffer<BufferAttr_HipcAutoSelect> out_data, Out<u32> out_size) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-
-    Result WriteSaveSlot(s32 offset, SaveDataHandle handle, InBuffer<BufferAttr_HipcAutoSelect> out_data) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        // to implement
-        R_SUCCEED();
-    }
-};
-
-class IUserService final : public ServiceFramework<IUserService> {
-public:
-    explicit IUserService(Core::System& system_) : ServiceFramework(system_, "stpl:u") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0 , D<&IUserService::Cmd0>, "Cmd0"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-    Result Cmd0(u32 unk0, OutInterface<IUserShimScopedObject> out_interface) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        *out_interface = std::make_shared<IUserShimScopedObject>(system);
-        R_SUCCEED();
-    }
-};
-
-class ISystemShimScopedObject final : public ServiceFramework<ISystemShimScopedObject> {
-public:
-    explicit ISystemShimScopedObject(Core::System& system_) : ServiceFramework(system_, "ISystemShimScopedObject") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {106, nullptr, "Cmd106"},
-            {107, nullptr, "Cmd107"},
-            {108, D<&ISystemShimScopedObject::Cmd108>, "Cmd108"},
-            {207, nullptr, "Cmd207"},
-            {208, D<&ISystemShimScopedObject::Cmd208>, "Cmd208"},
-            {209, nullptr, "Cmd209"},
-            {210, nullptr, "Cmd210"},
-            {211, nullptr, "Cmd211"},
-            {212, nullptr, "Cmd212"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-
-    Result Cmd108() {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-
-    Result Cmd208(Out<std::array<u8, 0x20>> unk0) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-};
-
-class ISystemService final : public ServiceFramework<ISystemService> {
-public:
-    explicit ISystemService(Core::System& system_) : ServiceFramework(system_, "stpl:sys") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0 , D<&ISystemService::Cmd0>, "Cmd0"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-    Result Cmd0(OutInterface<ISystemShimScopedObject> out_interface) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        *out_interface = std::make_shared<ISystemShimScopedObject>(system);
-        R_SUCCEED();
-    }
-};
-
 void LoopProcess(Core::System& system) {
    auto server_manager = std::make_unique<ServerManager>(system);

    server_manager->RegisterNamedService("ngct:u", std::make_shared<IService>(system), 4);
    server_manager->RegisterNamedService("ngct:s", std::make_shared<IServiceWithManagementApi>(system), 4);
    server_manager->RegisterNamedService("ngc:u", std::make_shared<NgcServiceImpl>(system), 4);
-
-    // +23.0.0
-    if (FirmwareManager::GetFirmwareVersion(system).first.major >= 23) {
-        server_manager->RegisterNamedService("stpl:u", std::make_shared<IUserService>(system), 4);
-        server_manager->RegisterNamedService("stpl:sys", std::make_shared<ISystemService>(system), 4);
-    }
-
    ServerManager::RunServer(std::move(server_manager));
 }

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

 #include "core/hle/service/cmif_types.h"
-#include "core/hle/service/ns/async_result.h"
+#include "core/hle/service/ns/i_async_result.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/os/event.h"
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later

 #include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ns/async_result.h"
+#include "core/hle/service/ns/i_async_result.h"

 #include <cstring>

@@ -32,4 +32,4 @@ Result IAsyncResult::Cancel() {
    R_SUCCEED();
 }

-} // namespace Service::NS
+} // namespace Service::NS
@@ -311,30 +311,27 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestCon
        // u64 - app count
        memory.WriteBlock(t_mem_address + out_length, &app_count, sizeof(u64));
        out_length += sizeof(u64);
-        ASSERT(out_length <= t_mem->GetSize());
        // [list of u64] - size of icons
        for (size_t i = 0; i < app_count; ++i) {
            const u64 app_id = app_ids_buffer[i];
            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            if (const auto control = pm.GetControlMetadata(); control.second) {
-                u64 full_size = control.second->GetSize();
-                memory.WriteBlock(t_mem_address + out_length, &full_size, sizeof(u64));
-            }
+            const auto control = pm.GetControlMetadata();
+            u64 full_size = control.second->GetSize();
+            memory.WriteBlock(t_mem_address + out_length, &full_size, sizeof(u64));
            out_length += sizeof(u64);
-            ASSERT(out_length <= t_mem->GetSize());
        }
        // [list of raw icon data]
+        std::vector<u8> full_icon_data;
        for (size_t i = 0; i < app_count; ++i) {
            const u64 app_id = app_ids_buffer[i];
            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            if (const auto control = pm.GetControlMetadata(); control.second) {
-                if (auto const full_size = control.second->GetSize(); full_size > 0) {
-                    std::vector<u8> full_icon_data(full_size);
-                    control.second->Read(full_icon_data.data(), full_size, 0);
-                    memory.WriteBlock(t_mem_address + out_length, full_icon_data.data(), full_size);
-                    out_length += full_size;
-                    ASSERT(out_length <= t_mem->GetSize());
-                }
+            const auto control = pm.GetControlMetadata();
+            auto const full_size = control.second->GetSize();
+            if (full_size > 0) {
+                full_icon_data.resize(full_size);
+                control.second->Read(full_icon_data.data(), full_size, 0);
+                memory.WriteBlock(t_mem_address + out_length, full_icon_data.data(), full_size);
+                out_length += full_size;
            }
        }
    }
@@ -348,12 +345,6 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestCon
 void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestContext& ctx) {
    const auto app_ids_buffer = ctx.ReadBuffer();
    const size_t app_count = app_ids_buffer.size() / sizeof(u64);
-
-    std::vector<u64> application_ids(app_count);
-    if (app_count > 0) {
-        std::memcpy(application_ids.data(), app_ids_buffer.data(), app_count * sizeof(u64));
-    }
-
    auto t_mem_obj = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(ctx.GetCopyHandle(0));
    auto* t_mem = t_mem_obj.GetPointerUnsafe();
    constexpr size_t title_entry_size = sizeof(FileSys::LanguageEntry);
@@ -363,9 +354,8 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestCo
        auto& memory = system.ApplicationMemory();
        const auto t_mem_address = t_mem->GetSourceAddress();
        for (size_t i = 0; i < app_count; ++i) {
-            const u64 app_id = application_ids[i];
-            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(),
-                                           system.GetContentProvider()};
+            const u64 app_id = app_ids_buffer[i];
+            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
            const auto control = pm.GetControlMetadata();
            FileSys::LanguageEntry entry{};
            if (control.first != nullptr) {
@@ -48,12 +48,6 @@ enum class OptionType : u32 {
    EnableAlpn = 3,
 };

-// This is nn::ssl::sf::RenegotiationMode
-enum RenegotiationMode : u32 {
-    None = 0, ///< None
-    Secure = 1, ///< Secure
-};
-
 // This is nn::ssl::sf::SslVersion
 struct SslVersion {
    union {
@@ -81,34 +75,34 @@ public:
          shared_data{shared_data_in}, backend{std::move(backend_in)} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, D<&ISslConnection::SetSocketDescriptor>, "SetSocketDescriptor"},
-            {1, D<&ISslConnection::SetHostName>, "SetHostName"},
-            {2, D<&ISslConnection::SetVerifyOption>, "SetVerifyOption"},
-            {3, D<&ISslConnection::SetIoMode>, "SetIoMode"},
-            {4, D<&ISslConnection::GetSocketDescriptor>, "GetSocketDescriptor"},
-            {5, D<&ISslConnection::GetHostName>, "GetHostName"},
+            {0, &ISslConnection::SetSocketDescriptor, "SetSocketDescriptor"},
+            {1, &ISslConnection::SetHostName, "SetHostName"},
+            {2, &ISslConnection::SetVerifyOption, "SetVerifyOption"},
+            {3, &ISslConnection::SetIoMode, "SetIoMode"},
+            {4, nullptr, "GetSocketDescriptor"},
+            {5, nullptr, "GetHostName"},
            {6, nullptr, "GetVerifyOption"},
-            {7, D<&ISslConnection::GetIoMode>, "GetIoMode"},
-            {8, D<&ISslConnection::DoHandshake>, "DoHandshake"},
+            {7, nullptr, "GetIoMode"},
+            {8, &ISslConnection::DoHandshake, "DoHandshake"},
            {9, &ISslConnection::DoHandshakeGetServerCert, "DoHandshakeGetServerCert"},
-            {10, D<&ISslConnection::Read>, "Read"},
-            {11, D<&ISslConnection::Write>, "Write"},
-            {12, D<&ISslConnection::Pending>, "Pending"},
-            {13, D<&ISslConnection::Peek>, "Peek"},
-            {14, D<&ISslConnection::Poll>, "Poll"},
-            {15, D<&ISslConnection::GetVerifyCertError>, "GetVerifyCertError"},
-            {16, D<&ISslConnection::GetNeededServerCertBufferSize>, "GetNeededServerCertBufferSize"},
-            {17, D<&ISslConnection::SetSessionCacheMode>, "SetSessionCacheMode"},
-            {18, D<&ISslConnection::GetSessionCacheMode>, "GetSessionCacheMode"},
-            {19, D<&ISslConnection::FlushSessionCache>, "FlushSessionCache"},
-            {20, D<&ISslConnection::SetRenegotiationMode>, "SetRenegotiationMode"},
-            {21, D<&ISslConnection::GetRenegotiationMode>, "GetRenegotiationMode"},
-            {22, D<&ISslConnection::SetOption>, "SetOption"},
-            {23, D<&ISslConnection::GetOption>, "GetOption"},
+            {10, &ISslConnection::Read, "Read"},
+            {11, &ISslConnection::Write, "Write"},
+            {12, &ISslConnection::Pending, "Pending"},
+            {13, nullptr, "Peek"},
+            {14, nullptr, "Poll"},
+            {15, nullptr, "GetVerifyCertError"},
+            {16, nullptr, "GetNeededServerCertBufferSize"},
+            {17, &ISslConnection::SetSessionCacheMode, "SetSessionCacheMode"},
+            {18, nullptr, "GetSessionCacheMode"},
+            {19, nullptr, "FlushSessionCache"},
+            {20, nullptr, "SetRenegotiationMode"},
+            {21, nullptr, "GetRenegotiationMode"},
+            {22, &ISslConnection::SetOption, "SetOption"},
+            {23, &ISslConnection::GetOption, "GetOption"},
            {24, nullptr, "GetVerifyCertErrors"},
            {25, nullptr, "GetCipherInfo"},
-            {26, D<&ISslConnection::SetNextAlpnProto>, "SetNextAlpnProto"},
-            {27, D<&ISslConnection::GetNextAlpnProto>, "GetNextAlpnProto"},
+            {26, &ISslConnection::SetNextAlpnProto, "SetNextAlpnProto"},
+            {27, &ISslConnection::GetNextAlpnProto, "GetNextAlpnProto"},
            {28, nullptr, "SetDtlsSocketDescriptor"},
            {29, nullptr, "GetDtlsHandshakeTimeout"},
            {30, nullptr, "SetPrivateOption"},
@@ -147,6 +141,80 @@ public:
    }

 private:
+    SslVersion ssl_version;
+    std::shared_ptr<SslContextSharedData> shared_data;
+    std::unique_ptr<SSLConnectionBackend> backend;
+    std::optional<int> fd_to_close;
+    bool do_not_close_socket = false;
+    bool get_server_cert_chain = false;
+    bool skip_default_verify = false;
+    bool enable_alpn = false;
+    std::shared_ptr<Network::SocketBase> socket;
+    std::vector<u8> next_alpn_proto;
+    bool did_handshake = false;
+    u32 verify_option = 0;
+
+    Result SetSocketDescriptorImpl(s32* out_fd, s32 fd) {
+        LOG_DEBUG(Service_SSL, "called, fd={}", fd);
+        ASSERT(!did_handshake);
+        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
+        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
+
+        auto const res_v = bsd->DuplicateSocketImpl(fd);
+        if (auto *res = std::get_if<s32>(&res_v)) {
+            const s32 duplicated_fd = *res;
+            if (do_not_close_socket) {
+                *out_fd = duplicated_fd;
+            } else {
+                *out_fd = -1;
+                fd_to_close = duplicated_fd;
+            }
+            std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(duplicated_fd);
+            if (!sock.has_value()) {
+                LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", duplicated_fd);
+                return ResultInvalidSocket;
+            }
+            socket = std::move(*sock);
+            backend->SetSocket(socket);
+            return ResultSuccess;
+        }
+        LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", fd);
+        return ResultInvalidSocket;
+    }
+
+    Result SetHostNameImpl(const std::string& hostname) {
+        LOG_DEBUG(Service_SSL, "called. hostname={}", hostname);
+        ASSERT(!did_handshake);
+        return backend->SetHostName(hostname);
+    }
+
+    Result SetVerifyOptionImpl(u32 option) {
+        ASSERT(!did_handshake);
+        LOG_DEBUG(Service_SSL, "called. option={} (forcing 0)", option);
+        verify_option = 0;
+        backend->SetVerifyOption(0);
+        return ResultSuccess;
+    }
+
+    Result SetIoModeImpl(u32 input_mode) {
+        auto mode = static_cast<IoMode>(input_mode);
+        ASSERT(mode == IoMode::Blocking || mode == IoMode::NonBlocking);
+        ASSERT_OR_EXECUTE(socket, { return ResultNoSocket; });
+
+        const bool non_block = mode == IoMode::NonBlocking;
+        const Network::Errno error = socket->SetNonBlock(non_block);
+        if (error != Network::Errno::SUCCESS) {
+            LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block);
+        }
+        return ResultSuccess;
+    }
+
+    Result SetSessionCacheModeImpl(u32 mode) {
+        ASSERT(!did_handshake);
+        LOG_WARNING(Service_SSL, "(STUBBED) called. value={}", mode);
+        return ResultSuccess;
+    }
+
    Result DoHandshakeImpl() {
        ASSERT_OR_EXECUTE(!did_handshake && socket, { return ResultNoSocket; });
        Result res = backend->DoHandshake();
@@ -166,17 +234,19 @@ private:
        };
        if (!get_server_cert_chain) {
            // Just return the first one, unencoded.
-            ASSERT_OR_EXECUTE_MSG(!certs.empty(), { return {}; }, "Should be at least one server cert");
+            ASSERT_OR_EXECUTE_MSG(
+                !certs.empty(), { return {}; }, "Should be at least one server cert");
            return certs[0];
        }
        std::vector<u8> ret;
-        Header header{0x4E4D684374726543, u32(certs.size()), 0};
+        Header header{0x4E4D684374726543, static_cast<u32>(certs.size()), 0};
        ret.insert(ret.end(), reinterpret_cast<u8*>(&header), reinterpret_cast<u8*>(&header + 1));
        size_t data_offset = sizeof(Header) + certs.size() * sizeof(EntryHeader);
        for (auto& cert : certs) {
-            EntryHeader entry_header{u32(cert.size()), u32(data_offset)};
+            EntryHeader entry_header{static_cast<u32>(cert.size()), static_cast<u32>(data_offset)};
            data_offset += cert.size();
-            ret.insert(ret.end(), reinterpret_cast<u8*>(&entry_header), reinterpret_cast<u8*>(&entry_header + 1));
+            ret.insert(ret.end(), reinterpret_cast<u8*>(&entry_header),
+                       reinterpret_cast<u8*>(&entry_header + 1));
        }
        for (auto& cert : certs) {
            ret.insert(ret.end(), cert.begin(), cert.end());
@@ -184,77 +254,65 @@ private:
        return ret;
    }

-    Result SetSocketDescriptor(s32 in_fd, Out<s32> out_fd) {
-        LOG_DEBUG(Service_SSL, "called, fd={}", in_fd);
-        ASSERT(!did_handshake);
-        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
-        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
-
-        auto const res_v = bsd->DuplicateSocketImpl(in_fd);
-        if (auto *res = std::get_if<s32>(&res_v)) {
-            const s32 dup_fd = *res;
-            *out_fd = do_not_close_socket ? dup_fd : -1;
-            if (!do_not_close_socket)
-                fd_to_close = dup_fd;
-            auto const sock = bsd->GetSocket(dup_fd);
-            if (!sock.has_value()) {
-                LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", dup_fd);
-                return ResultInvalidSocket;
-            }
-            socket = std::move(*sock);
-            backend->SetSocket(std::move(socket));
-            return ResultSuccess;
+    Result ReadImpl(std::vector<u8>* out_data) {
+        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
+        size_t actual_size{};
+        Result res = backend->Read(&actual_size, *out_data);
+        if (res != ResultSuccess) {
+            return res;
        }
-        LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", in_fd);
-        return ResultInvalidSocket;
+        out_data->resize(actual_size);
+        return res;
    }

-    Result SetHostName(InBuffer<BufferAttr_HipcMapAlias> buf) {
-        auto const hostname = Common::StringFromBuffer(buf);
-        LOG_DEBUG(Service_SSL, "called. hostname={}", hostname);
-        ASSERT(!did_handshake);
-        return backend->SetHostName(hostname.c_str());
+    Result WriteImpl(size_t* out_size, std::span<const u8> data) {
+        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
+        return backend->Write(out_size, data);
    }

-    Result SetVerifyOption(u32 option) {
-        LOG_DEBUG(Service_SSL, "called. option={} (forcing 0)", option);
-        ASSERT(!did_handshake);
-        verify_option = 0;
-        backend->SetVerifyOption(0);
-        R_SUCCEED();
+    Result PendingImpl(s32* out_pending) {
+        LOG_WARNING(Service_SSL, "(STUBBED) called.");
+        *out_pending = 0;
+        return ResultSuccess;
    }

-    Result SetIoMode(u32 input_mode) {
-        auto mode = IoMode(input_mode);
-        ASSERT(mode == IoMode::Blocking || mode == IoMode::NonBlocking);
-        R_UNLESS(socket, ResultNoSocket);
-        const bool non_block = mode == IoMode::NonBlocking;
-        const Network::Errno error = socket->SetNonBlock(non_block);
-        if (error != Network::Errno::SUCCESS) {
-            LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block);
-        }
-        R_SUCCEED();
+    void SetSocketDescriptor(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const s32 in_fd = rp.Pop<s32>();
+        s32 out_fd{-1};
+        const Result res = SetSocketDescriptorImpl(&out_fd, in_fd);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        rb.Push<s32>(out_fd);
    }

-    Result GetSocketDescriptor(Out<u32> out_fd) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        *out_fd = uint32_t(socket->GetFD());
-        R_SUCCEED();
+    void SetHostName(HLERequestContext& ctx) {
+        const std::string hostname = Common::StringFromBuffer(ctx.ReadBuffer());
+        const Result res = SetHostNameImpl(hostname);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

-    Result GetHostName(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        ASSERT(!did_handshake);
-        return backend->GetHostName(std::span<u8>{data.begin(), data.end()}, out_size);
+    void SetVerifyOption(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u32 option = rp.Pop<u32>();
+        const Result res = SetVerifyOptionImpl(option);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

-    Result GetIoMode(Out<u32> out_mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
+    void SetIoMode(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u32 mode = rp.Pop<u32>();
+        const Result res = SetIoModeImpl(mode);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

-    Result DoHandshake() {
-        return DoHandshakeImpl();
+    void DoHandshake(HLERequestContext& ctx) {
+        const Result res = DoHandshakeImpl();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

    void DoHandshakeGetServerCert(HLERequestContext& ctx) {
@@ -293,158 +351,131 @@ private:
        rb.PushRaw(out);
    }

-    Result Read(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        R_UNLESS(did_handshake, ResultInternalError);
-        size_t tmp{};
-        auto const res = backend->Read(&tmp, data);
-        *out_size = u32(tmp);
-        return res;
+    void Read(HLERequestContext& ctx) {
+        std::vector<u8> output_bytes(ctx.GetWriteBufferSize());
+        const Result res = ReadImpl(&output_bytes);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        if (res == ResultSuccess) {
+            rb.Push(static_cast<u32>(output_bytes.size()));
+            ctx.WriteBuffer(output_bytes);
+        } else {
+            rb.Push(static_cast<u32>(0));
+        }
    }

-    Result Write(InBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        R_UNLESS(did_handshake, ResultInternalError);
-        size_t tmp{};
-        auto const res = backend->Write(&tmp, data);
-        *out_size = u32(tmp);
-        return res;
+    void Write(HLERequestContext& ctx) {
+        size_t write_size{0};
+        const Result res = WriteImpl(&write_size, ctx.ReadBuffer());
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        rb.Push(static_cast<u32>(write_size));
    }

-    Result Pending(Out<s32> out_pending_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        *out_pending_size = s32(backend->Pending());
-        R_SUCCEED();
+    void Pending(HLERequestContext& ctx) {
+        s32 pending_size{0};
+        const Result res = PendingImpl(&pending_size);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        rb.Push<s32>(pending_size);
    }

-    Result Peek(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        size_t tmp{};
-        auto const res = backend->Peek(&tmp, data);
-        *out_size = u32(tmp);
-        return res;
+    void SetSessionCacheMode(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u32 mode = rp.Pop<u32>();
+        const Result res = SetSessionCacheModeImpl(mode);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

-    Result Poll(u32 in_pollevent, u32 timer, Out<u32> out_pollevent) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
+    void SetOption(HLERequestContext& ctx) {
+        struct Parameters {
+            OptionType option;
+            s32 value;
+        };
+        static_assert(sizeof(Parameters) == 0x8, "Parameters is an invalid size");

-    Result GetVerifyCertError() {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
+        IPC::RequestParser rp{ctx};
+        const auto parameters = rp.PopRaw<Parameters>();

-    Result GetNeededServerCertBufferSize(Out<u32> out_needed_buffer_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
-
-    Result SetSessionCacheMode(u32 mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED) called. value={}", mode);
-        R_UNLESS(!did_handshake, ResultInternalError);
-        R_SUCCEED();
-    }
-
-    Result GetSessionCacheMode(Out<u32> mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_UNLESS(!did_handshake, ResultInternalError);
-        R_SUCCEED();
-    }
-
-    Result FlushSessionCache() {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_UNLESS(!did_handshake, ResultInternalError);
-        R_SUCCEED();
-    }
-
-    Result SetRenegotiationMode(RenegotiationMode mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        backend->SetRenegotiationMode(u32(mode));
-        R_SUCCEED();
-    }
-
-    Result GetRenegotiationMode(Out<RenegotiationMode> mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        u32 tmp{};
-        auto const res = backend->GetRenegotiationMode(&tmp);
-        *mode = RenegotiationMode(tmp);
-        return res;
-    }
-
-    Result SetOption(OptionType option, s32 value) {
-        switch (option) {
+        switch (parameters.option) {
        case OptionType::DoNotCloseSocket:
-            do_not_close_socket = bool(value);
+            do_not_close_socket = static_cast<bool>(parameters.value);
            break;
        case OptionType::GetServerCertChain:
-            get_server_cert_chain = bool(value);
+            get_server_cert_chain = static_cast<bool>(parameters.value);
            break;
        case OptionType::SkipDefaultVerify:
-            skip_default_verify = bool(value);
+            skip_default_verify = static_cast<bool>(parameters.value);
            break;
        case OptionType::EnableAlpn:
-            enable_alpn = bool(value);
+            enable_alpn = static_cast<bool>(parameters.value);
            break;
        default:
-            LOG_WARNING(Service_SSL, "Unknown option={}, value={}", option, value);
+            LOG_WARNING(Service_SSL, "Unknown option={}, value={}", parameters.option,
+                        parameters.value);
        }
-        R_SUCCEED();
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
    }

-    Result GetOption(OptionType option, Out<u8> value) {
+    void GetOption(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto option = rp.PopRaw<OptionType>();
+
+        u8 value = 0;
+
        switch (option) {
        case OptionType::DoNotCloseSocket:
-            *value = u8(do_not_close_socket);
+            value = static_cast<u8>(do_not_close_socket);
            break;
        case OptionType::GetServerCertChain:
-            *value = u8(get_server_cert_chain);
+            value = static_cast<u8>(get_server_cert_chain);
            break;
        case OptionType::SkipDefaultVerify:
-            *value = u8(skip_default_verify);
+            value = static_cast<u8>(skip_default_verify);
            break;
        case OptionType::EnableAlpn:
-            *value = u8(enable_alpn);
+            value = static_cast<u8>(enable_alpn);
            break;
        default:
-            LOG_WARNING(Service_SSL, "Unknown option={}", u32(option));
-            *value = 0;
+            LOG_WARNING(Service_SSL, "Unknown option={}", option);
+            value = 0;
            break;
        }
-        LOG_DEBUG(Service_SSL, "GetOption called, option={}, ret value={}", u32(option), *value);
-        R_SUCCEED();
+
+        LOG_DEBUG(Service_SSL, "GetOption called, option={}, ret value={}", option, value);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u8>(value);
    }

-    Result SetNextAlpnProto(InBuffer<BufferAttr_HipcMapAlias> data) {
-        auto const to_write = u32((std::min)(next_alpn_proto.size(), data.size()));
-        next_alpn_proto.assign(data.begin(), data.begin() + to_write);
+    void SetNextAlpnProto(HLERequestContext& ctx) {
+        const auto data = ctx.ReadBuffer(0);
+        next_alpn_proto.assign(data.begin(), data.end());
+
        LOG_DEBUG(Service_SSL, "SetNextAlpnProto called, size={}", next_alpn_proto.size());
-        R_SUCCEED();
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
    }

-    Result GetNextAlpnProto(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> to_write) {
-        *to_write = u32((std::min)(next_alpn_proto.size(), data.size()));
-        next_alpn_proto.assign(data.begin(), data.begin() + *to_write);
-        LOG_DEBUG(Service_SSL, "GetNextAlpnProto called, size={}", *to_write);
-        R_SUCCEED();
+    void GetNextAlpnProto(HLERequestContext& ctx) {
+        const size_t writable = ctx.GetWriteBufferSize();
+        const size_t to_write = (std::min)(next_alpn_proto.size(), writable);
+
+        if (to_write != 0) {
+            ctx.WriteBuffer(std::span<const u8>(next_alpn_proto.data(), to_write));
+        }
+
+        LOG_DEBUG(Service_SSL, "GetNextAlpnProto called, size={}", to_write);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u32>(static_cast<u32>(to_write));
    }
-
-    Result GetVerifyCertErrors(OutBuffer<BufferAttr_HipcMapAlias> unk0, Out<u32> unk1, Out<u32> unk2) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
-
-    SslVersion ssl_version;
-    std::shared_ptr<SslContextSharedData> shared_data;
-    std::unique_ptr<SSLConnectionBackend> backend;
-    std::optional<int> fd_to_close;
-    std::shared_ptr<Network::SocketBase> socket;
-    std::vector<u8> next_alpn_proto;
-    u32 verify_option = 0;
-
-    bool do_not_close_socket = false;
-    bool get_server_cert_chain = false;
-    bool skip_default_verify = false;
-    bool enable_alpn = false;
-    bool did_handshake = false;
 };

 class ISslContext final : public ServiceFramework<ISslContext> {
@@ -461,7 +492,7 @@ public:
            {5, &ISslContext::ImportClientPki, "ImportClientPki"},
            {6, nullptr, "RemoveServerPki"},
            {7, nullptr, "RemoveClientPki"},
-            {8, D<&ISslContext::RegisterInternalPki>, "RegisterInternalPki"},
+            {8, nullptr, "RegisterInternalPki"},
            {9, nullptr, "AddPolicyOid"},
            {10, nullptr, "ImportCrl"},
            {11, nullptr, "RemoveCrl"},
@@ -556,11 +587,6 @@ private:
        rb.Push(ResultSuccess);
        rb.Push(client_id);
    }
-
-    Result RegisterInternalPki() {
-        LOG_WARNING(Service_SSL, "(STUBBED) called");
-        R_SUCCEED();
-    }
 };

 class ISslService final : public ServiceFramework<ISslService> {
@@ -36,17 +36,12 @@ class SSLConnectionBackend {
 public:
    virtual ~SSLConnectionBackend() {}
    virtual void SetSocket(std::shared_ptr<Network::SocketBase> socket) = 0;
+    virtual Result SetHostName(const std::string& hostname) = 0;
    virtual void SetVerifyOption(u32 option) = 0;
    virtual Result DoHandshake() = 0;
    virtual Result Read(size_t* out_size, std::span<u8> data) = 0;
-    virtual Result Peek(size_t* out_size, std::span<u8> data) = 0;
    virtual Result Write(size_t* out_size, std::span<const u8> data) = 0;
    virtual Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) = 0;
-    virtual Result SetHostName(const char* hostname) = 0;
-    virtual Result GetHostName(std::span<u8> hostname, u32* out_size) = 0;
-    virtual int Pending() = 0;
-    virtual Result SetRenegotiationMode(u32 mode) = 0;
-    virtual Result GetRenegotiationMode(u32* mode) = 0;
 };

 Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend);
@@ -157,30 +157,18 @@ public:
        socket = std::move(socket_in);
    }

-    Result SetHostName(const char* hostname) override {
+    Result SetHostName(const std::string& hostname) override {
        if (!skip_cert_verification) {
-            if (!SSL_set1_host(ssl, hostname)) {
+            if (!SSL_set1_host(ssl, hostname.c_str())) {
                LOG_ERROR(Service_SSL, "SSL_set1_host({}) failed", hostname);
                return CheckOpenSSLErrors();
            }
        }
-        if (!SSL_set_tlsext_host_name(ssl, hostname)) { // hostname for SNI
+        if (!SSL_set_tlsext_host_name(ssl, hostname.c_str())) { // hostname for SNI
            LOG_ERROR(Service_SSL, "SSL_set_tlsext_host_name({}) failed", hostname);
            return CheckOpenSSLErrors();
        }
-        R_SUCCEED();
-    }
-
-    Result GetHostName(std::span<u8> data, u32* out_size) override {
-        auto const peer_name = SSL_get0_peername(ssl);
-        if (peer_name == nullptr) {
-            LOG_ERROR(Service_SSL, "SSL_get0_peername()");
-            return CheckOpenSSLErrors();
-        }
-        auto const s = std::string{peer_name};
-        *out_size = u32(s.size());
-        std::memcpy(data.data(), s.data(), (std::min)(s.size(), data.size()));
-        R_SUCCEED();
+        return ResultSuccess;
    }

    void SetVerifyOption(u32 option) override {
@@ -225,13 +213,6 @@ public:
        return HandleReturn("SSL_read_ex", out_size, ret);
    }

-    Result Peek(size_t* out_size, std::span<u8> data) override {
-        auto const n = (std::min)(data.size(), *out_size);
-        const int ret = SSL_peek(ssl, data.data(), int(n));
-        *out_size = n;
-        return HandleReturn("SSL_write_ex", out_size, ret);
-    }
-
    Result Write(size_t* out_size, std::span<const u8> data) override {
        const int ret = SSL_write_ex(ssl, data.data(), data.size(), out_size);
        return HandleReturn("SSL_write_ex", out_size, ret);
@@ -282,25 +263,7 @@ public:
            out_certs->emplace_back(buf, buf + len);
            OPENSSL_free(buf);
        }
-        R_SUCCEED();
-    }
-
-    int Pending() override {
-        return SSL_pending(ssl);
-    }
-
-    Result SetRenegotiationMode(u32 mode) override {
-        if (mode == 0) {
-            SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_RENEGOTIATION);
-        } else {
-            SSL_CTX_set_options(ssl_ctx, SSL_OP_ALLOW_CLIENT_RENEGOTIATION);
-        }
-        R_SUCCEED();
-    }
-
-    Result GetRenegotiationMode(u32* mode) override {
-        *mode = SSL_get_secure_renegotiation_support(ssl) ? 1 : 0;
-        R_SUCCEED();
+        return ResultSuccess;
    }

    ~SSLConnectionBackendOpenSSL() {
@@ -33,10 +33,18 @@ u64 MemoryReadWidth(Core::Memory::Memory& memory, u32 width, VAddr addr) {

 void MemoryWriteWidth(Core::Memory::Memory& memory, u32 width, VAddr addr, u64 value) {
    switch (width) {
-    case sizeof(u64): return memory.Write64(addr, value);
-    case sizeof(u32): return memory.Write32(addr, u32(value));
-    case sizeof(u16): return memory.Write16(addr, u16(value));
-    case sizeof(u8): return memory.Write8(addr, u8(value));
+    case 1:
+        memory.Write8(addr, static_cast<u8>(value));
+        break;
+    case 2:
+        memory.Write16(addr, static_cast<u16>(value));
+        break;
+    case 4:
+        memory.Write32(addr, static_cast<u32>(value));
+        break;
+    case 8:
+        memory.Write64(addr, value);
+        break;
    default:
        UNREACHABLE();
    }
@@ -82,7 +82,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const

    auto fn = [](const A32::UserConfig& conf, A32::VAddr vaddr) -> T {
        return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
-            return (conf.callbacks->*callback)(vaddr, sizeof(T));
+            return (conf.callbacks->*callback)(vaddr);
        });
    };

@@ -136,9 +136,12 @@ static void* EmitExclusiveWriteCallTrampoline(oaknut::CodeGenerator& code, const
    oaknut::Label l_addr, l_this;

    auto fn = [](const A32::UserConfig& conf, A32::VAddr vaddr, T value) -> u32 {
-        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr, [&](T expected) -> bool {
-            return (conf.callbacks->*callback)(vaddr, value, expected);
-        }) ? 0 : 1;
+        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr,
+                                                            [&](T expected) -> bool {
+                                                                return (conf.callbacks->*callback)(vaddr, value, expected);
+                                                            })
+                 ? 0
+                 : 1;
    };

    void* target = code.xptr<void*>();
@@ -176,14 +179,26 @@ void A32AddressSpace::EmitPrelude() {

    UnprotectCodeMemory();

-    prelude_info.read_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
-    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u8>(code, conf);
-    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u16>(code, conf);
-    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u32>(code, conf);
-    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u64>(code, conf);
-    prelude_info.write_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.read_memory_8 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead8>(code, conf.callbacks);
+    prelude_info.read_memory_16 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead16>(code, conf.callbacks);
+    prelude_info.read_memory_32 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead32>(code, conf.callbacks);
+    prelude_info.read_memory_64 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead64>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead8>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead16>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead32>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead64>(code, conf.callbacks);
+    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead8, u8>(code, conf);
+    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead16, u16>(code, conf);
+    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead32, u32>(code, conf);
+    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead64, u64>(code, conf);
+    prelude_info.write_memory_8 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
+    prelude_info.write_memory_16 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
+    prelude_info.write_memory_32 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
+    prelude_info.write_memory_64 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
    prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);
    prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);
    prelude_info.exclusive_write_memory_32 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive32, u32>(code, conf);
@@ -81,7 +81,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const

    auto fn = [](const A64::UserConfig& conf, A64::VAddr vaddr) -> T {
        return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
-            return (conf.callbacks->*callback)(vaddr, sizeof(T));
+            return (conf.callbacks->*callback)(vaddr);
        });
    };

@@ -133,10 +133,14 @@ static void* EmitExclusiveWriteCallTrampoline(oaknut::CodeGenerator& code, const
    using namespace oaknut::util;

    oaknut::Label l_addr, l_this;
+
    auto fn = [](const A64::UserConfig& conf, A64::VAddr vaddr, T value) -> u32 {
-        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr, [&](T expected) -> bool {
-            return (conf.callbacks->*callback)(vaddr, value, expected);
-        }) ? 0 : 1;
+        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr,
+                                                            [&](T expected) -> bool {
+                                                                return (conf.callbacks->*callback)(vaddr, value, expected);
+                                                            })
+                 ? 0
+                 : 1;
    };

    void* target = code.xptr<void*>();
@@ -342,18 +346,30 @@ void A64AddressSpace::EmitPrelude() {

    UnprotectCodeMemory();

-    prelude_info.read_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.read_memory_8 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead8>(code, conf.callbacks);
+    prelude_info.read_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead16>(code, conf.callbacks);
+    prelude_info.read_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead32>(code, conf.callbacks);
+    prelude_info.read_memory_64 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead64>(code, conf.callbacks);
    prelude_info.read_memory_128 = EmitRead128CallTrampoline(code, conf.callbacks);
-    prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead8>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead16>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead32>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead64>(code, conf.callbacks);
    prelude_info.wrapped_read_memory_128 = EmitWrappedRead128CallTrampoline(code, conf.callbacks);
-    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u8>(code, conf);
-    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u16>(code, conf);
-    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u32>(code, conf);
-    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u64>(code, conf);
+    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead8, u8>(code, conf);
+    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead16, u16>(code, conf);
+    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead32, u32>(code, conf);
+    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead64, u64>(code, conf);
    prelude_info.exclusive_read_memory_128 = EmitExclusiveRead128CallTrampoline(code, conf);
-    prelude_info.write_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.write_memory_8 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
+    prelude_info.write_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
+    prelude_info.write_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
+    prelude_info.write_memory_64 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
    prelude_info.write_memory_128 = EmitWrite128CallTrampoline(code, conf.callbacks);
-    prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
    prelude_info.wrapped_write_memory_128 = EmitWrappedWrite128CallTrampoline(code, conf.callbacks);
    prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);
    prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);
@@ -145,42 +145,32 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
        case LinkTarget::ReturnFromRunCode:
            c.B(prelude_info.return_from_run_code);
            break;
-        // { this, vaddr, size }
        case LinkTarget::ReadMemory8:
-            c.LDR(X2, 1);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_8);
            break;
        case LinkTarget::ReadMemory16:
-            c.LDR(X2, 2);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_16);
            break;
        case LinkTarget::ReadMemory32:
-            c.LDR(X2, 4);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_32);
            break;
        case LinkTarget::ReadMemory64:
-            c.LDR(X2, 8);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_64);
            break;
        case LinkTarget::ReadMemory128:
            c.BL(prelude_info.read_memory_128);
            break;
-        // { this, vaddr, size }
        case LinkTarget::WrappedReadMemory8:
-            c.LDR(X2, 1);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_8);
            break;
        case LinkTarget::WrappedReadMemory16:
-            c.LDR(X2, 2);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_16);
            break;
        case LinkTarget::WrappedReadMemory32:
-            c.LDR(X2, 4);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_32);
            break;
        case LinkTarget::WrappedReadMemory64:
-            c.LDR(X2, 8);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_64);
            break;
        case LinkTarget::WrappedReadMemory128:
            c.BL(prelude_info.wrapped_read_memory_128);
@@ -200,41 +190,32 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
        case LinkTarget::ExclusiveReadMemory128:
            c.BL(prelude_info.exclusive_read_memory_128);
            break;
-        // { this, vaddr, value, size }
        case LinkTarget::WriteMemory8:
-            c.LDR(X3, 1);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_8);
            break;
        case LinkTarget::WriteMemory16:
-            c.LDR(X3, 2);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_16);
            break;
        case LinkTarget::WriteMemory32:
-            c.LDR(X3, 4);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_32);
            break;
        case LinkTarget::WriteMemory64:
-            c.LDR(X3, 8);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_64);
            break;
        case LinkTarget::WriteMemory128:
            c.BL(prelude_info.write_memory_128);
            break;
        case LinkTarget::WrappedWriteMemory8:
-            c.LDR(X3, 1);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_8);
            break;
        case LinkTarget::WrappedWriteMemory16:
-            c.LDR(X3, 2);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_16);
            break;
        case LinkTarget::WrappedWriteMemory32:
-            c.LDR(X3, 4);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_32);
            break;
        case LinkTarget::WrappedWriteMemory64:
-            c.LDR(X3, 8);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_64);
            break;
        case LinkTarget::WrappedWriteMemory128:
            c.BL(prelude_info.wrapped_write_memory_128);
@@ -93,18 +93,30 @@ protected:
        void* return_to_dispatcher;
        void* return_from_run_code;

-        void* read_memory;
+        void* read_memory_8;
+        void* read_memory_16;
+        void* read_memory_32;
+        void* read_memory_64;
        void* read_memory_128;
-        void* wrapped_read_memory;
+        void* wrapped_read_memory_8;
+        void* wrapped_read_memory_16;
+        void* wrapped_read_memory_32;
+        void* wrapped_read_memory_64;
        void* wrapped_read_memory_128;
        void* exclusive_read_memory_8;
        void* exclusive_read_memory_16;
        void* exclusive_read_memory_32;
        void* exclusive_read_memory_64;
        void* exclusive_read_memory_128;
-        void* write_memory;
+        void* write_memory_8;
+        void* write_memory_16;
+        void* write_memory_32;
+        void* write_memory_64;
        void* write_memory_128;
-        void* wrapped_write_memory;
+        void* wrapped_write_memory_8;
+        void* wrapped_write_memory_16;
+        void* wrapped_write_memory_32;
+        void* wrapped_write_memory_64;
        void* wrapped_write_memory_128;
        void* exclusive_write_memory_8;
        void* exclusive_write_memory_16;
@@ -31,16 +31,16 @@ using namespace Xbyak::util;
 void A32EmitX64::GenFastmemFallbacks() {
    const std::initializer_list<int> idxes{0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
    const std::array<std::pair<size_t, ArgCallback>, 4> read_callbacks{{
-        {8, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {16, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {32, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {64, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {8, Devirtualize<&A32::UserCallbacks::MemoryRead8>(conf.callbacks)},
+        {16, Devirtualize<&A32::UserCallbacks::MemoryRead16>(conf.callbacks)},
+        {32, Devirtualize<&A32::UserCallbacks::MemoryRead32>(conf.callbacks)},
+        {64, Devirtualize<&A32::UserCallbacks::MemoryRead64>(conf.callbacks)},
    }};
    const std::array<std::pair<size_t, ArgCallback>, 4> write_callbacks{{
-        {8, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {16, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {32, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {64, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {8, Devirtualize<&A32::UserCallbacks::MemoryWrite8>(conf.callbacks)},
+        {16, Devirtualize<&A32::UserCallbacks::MemoryWrite16>(conf.callbacks)},
+        {32, Devirtualize<&A32::UserCallbacks::MemoryWrite32>(conf.callbacks)},
+        {64, Devirtualize<&A32::UserCallbacks::MemoryWrite64>(conf.callbacks)},
    }};
    const std::array<std::pair<size_t, ArgCallback>, 4> exclusive_write_callbacks{{
        {8, Devirtualize<&A32::UserCallbacks::MemoryWriteExclusive8>(conf.callbacks)},
@@ -56,12 +56,12 @@ void A32EmitX64::GenFastmemFallbacks() {
                    code.align();
                    read_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                    ABI_PushCallerSaveRegistersAndAdjustStackExcept(code, HostLocRegIdx(value_idx));
-                    // params = { this, vaddr, size }
                    if (vaddr_idx != code.ABI_PARAM2.getIdx()) {
                        code.mov(code.ABI_PARAM2, Xbyak::Reg64{vaddr_idx});
                    }
-                    code.mov(code.ABI_PARAM3, bitsize / CHAR_BIT);
-                    if (ordered) code.mfence();
+                    if (ordered) {
+                        code.mfence();
+                    }
                    callback.EmitCall(code);
                    if (value_idx != code.ABI_RETURN.getIdx()) {
                        code.mov(Xbyak::Reg64{value_idx}, code.ABI_RETURN);
@@ -76,7 +76,6 @@ void A32EmitX64::GenFastmemFallbacks() {
                    code.align();
                    write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                    ABI_PushCallerSaveRegistersAndAdjustStack(code);
-                    // params = { this, vaddr, value, size }
                    if (vaddr_idx == code.ABI_PARAM3.getIdx() && value_idx == code.ABI_PARAM2.getIdx()) {
                        code.xchg(code.ABI_PARAM2, code.ABI_PARAM3);
                    } else if (vaddr_idx == code.ABI_PARAM3.getIdx()) {
@@ -93,9 +92,10 @@ void A32EmitX64::GenFastmemFallbacks() {
                        }
                    }
                    code.ZeroExtendFrom(bitsize, code.ABI_PARAM3);
-                    code.mov(code.ABI_PARAM4, bitsize / CHAR_BIT);
                    callback.EmitCall(code);
-                    if (ordered) code.mfence();
+                    if (ordered) {
+                        code.mfence();
+                    }
                    ABI_PopCallerSaveRegistersAndAdjustStack(code);
                    code.ret();
                    PerfMapRegister(write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)], code.getCurr(), fmt::format("a32_write_fallback_{}", bitsize));
@@ -138,35 +138,35 @@ void A32EmitX64::GenFastmemFallbacks() {
 #undef Axx

 void A32EmitX64::EmitA32ReadMemory8(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);
 }

 void A32EmitX64::EmitA32ReadMemory16(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);
 }

 void A32EmitX64::EmitA32ReadMemory32(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);
 }

 void A32EmitX64::EmitA32ReadMemory64(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);
 }

 void A32EmitX64::EmitA32WriteMemory8(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<8, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<8, &A32::UserCallbacks::MemoryWrite8>(ctx, inst);
 }

 void A32EmitX64::EmitA32WriteMemory16(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<16, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<16, &A32::UserCallbacks::MemoryWrite16>(ctx, inst);
 }

 void A32EmitX64::EmitA32WriteMemory32(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<32, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<32, &A32::UserCallbacks::MemoryWrite32>(ctx, inst);
 }

 void A32EmitX64::EmitA32WriteMemory64(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<64, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<64, &A32::UserCallbacks::MemoryWrite64>(ctx, inst);
 }

 void A32EmitX64::EmitA32ClearExclusive(A32EmitContext&, IR::Inst*) {
@@ -175,33 +175,33 @@ void A32EmitX64::EmitA32ClearExclusive(A32EmitContext&, IR::Inst*) {

 void A32EmitX64::EmitA32ExclusiveReadMemory8(A32EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);
    }
 }

 void A32EmitX64::EmitA32ExclusiveReadMemory16(A32EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);
    }
 }

 void A32EmitX64::EmitA32ExclusiveReadMemory32(A32EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);
    }
 }

 void A32EmitX64::EmitA32ExclusiveReadMemory64(A32EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);
    }
 }

@@ -115,16 +115,16 @@ void A64EmitX64::GenMemory128Accessors() {
 void A64EmitX64::GenFastmemFallbacks() {
    const std::initializer_list<int> idxes{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    const std::array<std::pair<size_t, ArgCallback>, 4> read_callbacks{{
-        {8, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {16, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {32, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {64, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {8, Devirtualize<&A64::UserCallbacks::MemoryRead8>(conf.callbacks)},
+        {16, Devirtualize<&A64::UserCallbacks::MemoryRead16>(conf.callbacks)},
+        {32, Devirtualize<&A64::UserCallbacks::MemoryRead32>(conf.callbacks)},
+        {64, Devirtualize<&A64::UserCallbacks::MemoryRead64>(conf.callbacks)},
    }};
    const std::array<std::pair<size_t, ArgCallback>, 4> write_callbacks{{
-        {8, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {16, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {32, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {64, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {8, Devirtualize<&A64::UserCallbacks::MemoryWrite8>(conf.callbacks)},
+        {16, Devirtualize<&A64::UserCallbacks::MemoryWrite16>(conf.callbacks)},
+        {32, Devirtualize<&A64::UserCallbacks::MemoryWrite32>(conf.callbacks)},
+        {64, Devirtualize<&A64::UserCallbacks::MemoryWrite64>(conf.callbacks)},
    }};
    const std::array<std::pair<size_t, ArgCallback>, 4> exclusive_write_callbacks{{
        {8, Devirtualize<&A64::UserCallbacks::MemoryWriteExclusive8>(conf.callbacks)},
@@ -204,12 +204,12 @@ void A64EmitX64::GenFastmemFallbacks() {
                    code.align();
                    read_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                    ABI_PushCallerSaveRegistersAndAdjustStackExcept(code, HostLocRegIdx(value_idx));
-                    // params = { this, vaddr, size }
                    if (vaddr_idx != code.ABI_PARAM2.getIdx()) {
                        code.mov(code.ABI_PARAM2, Xbyak::Reg64{vaddr_idx});
                    }
-                    code.mov(code.ABI_PARAM3, bitsize / CHAR_BIT);
-                    if (ordered) code.mfence();
+                    if (ordered) {
+                        code.mfence();
+                    }
                    callback.EmitCall(code);
                    if (value_idx != code.ABI_RETURN.getIdx()) {
                        code.mov(Xbyak::Reg64{value_idx}, code.ABI_RETURN);
@@ -224,7 +224,6 @@ void A64EmitX64::GenFastmemFallbacks() {
                    code.align();
                    write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                    ABI_PushCallerSaveRegistersAndAdjustStack(code);
-                    // params = { this, vaddr, value, size }
                    if (vaddr_idx == code.ABI_PARAM3.getIdx() && value_idx == code.ABI_PARAM2.getIdx()) {
                        code.xchg(code.ABI_PARAM2, code.ABI_PARAM3);
                    } else if (vaddr_idx == code.ABI_PARAM3.getIdx()) {
@@ -241,9 +240,10 @@ void A64EmitX64::GenFastmemFallbacks() {
                        }
                    }
                    code.ZeroExtendFrom(bitsize, code.ABI_PARAM3);
-                    code.mov(code.ABI_PARAM4, bitsize / CHAR_BIT);
                    callback.EmitCall(code);
-                    if (ordered) code.mfence();
+                    if (ordered) {
+                        code.mfence();
+                    }
                    ABI_PopCallerSaveRegistersAndAdjustStack(code);
                    code.ret();
                    PerfMapRegister(write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)], code.getCurr(), fmt::format("a64_write_fallback_{}", bitsize));
@@ -286,19 +286,19 @@ void A64EmitX64::GenFastmemFallbacks() {
 #undef Axx

 void A64EmitX64::EmitA64ReadMemory8(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);
 }

 void A64EmitX64::EmitA64ReadMemory16(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);
 }

 void A64EmitX64::EmitA64ReadMemory32(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);
 }

 void A64EmitX64::EmitA64ReadMemory64(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);
 }

 void A64EmitX64::EmitA64ReadMemory128(A64EmitContext& ctx, IR::Inst* inst) {
@@ -306,23 +306,23 @@ void A64EmitX64::EmitA64ReadMemory128(A64EmitContext& ctx, IR::Inst* inst) {
 }

 void A64EmitX64::EmitA64WriteMemory8(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<8, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<8, &A64::UserCallbacks::MemoryWrite8>(ctx, inst);
 }

 void A64EmitX64::EmitA64WriteMemory16(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<16, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<16, &A64::UserCallbacks::MemoryWrite16>(ctx, inst);
 }

 void A64EmitX64::EmitA64WriteMemory32(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<32, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<32, &A64::UserCallbacks::MemoryWrite32>(ctx, inst);
 }

 void A64EmitX64::EmitA64WriteMemory64(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<64, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<64, &A64::UserCallbacks::MemoryWrite64>(ctx, inst);
 }

 void A64EmitX64::EmitA64WriteMemory128(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<128, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<128, &A64::UserCallbacks::MemoryWrite64>(ctx, inst);
 }

 void A64EmitX64::EmitA64ClearExclusive(A64EmitContext&, IR::Inst*) {
@@ -331,33 +331,33 @@ void A64EmitX64::EmitA64ClearExclusive(A64EmitContext&, IR::Inst*) {

 void A64EmitX64::EmitA64ExclusiveReadMemory8(A64EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);
    }
 }

 void A64EmitX64::EmitA64ExclusiveReadMemory16(A64EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);
    }
 }

 void A64EmitX64::EmitA64ExclusiveReadMemory32(A64EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);
    }
 }

 void A64EmitX64::EmitA64ExclusiveReadMemory64(A64EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);
    }
 }

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 /* This file is part of the dynarmic project.
 * Copyright (c) 2022 MerryMage
 * SPDX-License-Identifier: 0BSD
@@ -59,13 +56,16 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {
        // Neither fastmem nor page table: Use callbacks
        if constexpr (bitsize == 128) {
            ctx.reg_alloc.HostCall(code, nullptr, {}, args[1]);
-            if (ordered) code.mfence();
+            if (ordered) {
+                code.mfence();
+            }
            code.CallFunction(memory_read_128);
            ctx.reg_alloc.DefineValue(code, inst, xmm1);
        } else {
            ctx.reg_alloc.HostCall(code, inst, {}, args[1]);
-            code.mov(code.ABI_PARAM3.cvt32(), bitsize / CHAR_BIT);
-            if (ordered) code.mfence();
+            if (ordered) {
+                code.mfence();
+            }
            Devirtualize<callback>(conf.callbacks).EmitCall(code);
            code.ZeroExtendFrom(bitsize, code.ABI_RETURN);
        }
@@ -148,12 +148,12 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
            ctx.reg_alloc.HostCall(code, nullptr);
            code.CallFunction(memory_write_128);
        } else {
-            // { this, vaddr, value, size }
            ctx.reg_alloc.HostCall(code, nullptr, {}, args[1], args[2]);
-            code.mov(code.ABI_PARAM4.cvt32(), bitsize / CHAR_BIT);
            Devirtualize<callback>(conf.callbacks).EmitCall(code);
        }
-        if (ordered) code.mfence();
+        if (ordered) {
+            code.mfence();
+        }
        EmitCheckMemoryAbort(ctx, inst);
        return;
    }
@@ -230,11 +230,12 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {
        if (ordered) {
            code.mfence();
        }
-        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr) -> T {
-            return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
-                return (conf.callbacks->*callback)(vaddr, bitsize / CHAR_BIT);
+        code.CallLambda(
+            [](AxxUserConfig& conf, Axx::VAddr vaddr) -> T {
+                return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
+                    return (conf.callbacks->*callback)(vaddr);
+                });
            });
-        });
        code.ZeroExtendFrom(bitsize, code.ABI_RETURN);
    } else {
        const Xbyak::Xmm result = ctx.reg_alloc.ScratchXmm(code);
@@ -249,11 +250,12 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {
        if (ordered) {
            code.mfence();
        }
-        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& ret) {
-            ret = conf.global_monitor->ReadAndMark<Vector>(conf.processor_id, vaddr, [&]() -> Vector {
-                return (conf.callbacks->*callback)(vaddr);
+        code.CallLambda(
+            [](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& ret) {
+                ret = conf.global_monitor->ReadAndMark<Vector>(conf.processor_id, vaddr, [&]() -> Vector {
+                    return (conf.callbacks->*callback)(vaddr);
+                });
            });
-        });
        code.movups(result, xword[rsp + ABI_SHADOW_SPACE]);
        ctx.reg_alloc.ReleaseStackSpace(code, 16 + ABI_SHADOW_SPACE);

@@ -90,7 +90,7 @@ template<>
        code.shl(tmp, int(ctx.conf.page_table_log2_stride));
        code.mov(page, qword[r14 + tmp.cvt64()]);
    } else {
-        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
+        code.mov(page, qword[r14 + tmp.cvt64() * int(ctx.conf.page_table_log2_stride)]);
    }

    // check for marked bit, use as unmapped if marked
@@ -161,12 +161,8 @@ template<>
        code.jnz(abort, code.T_NEAR);
    }

-    if (ctx.conf.page_table_log2_stride > 3) {
-        code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-        code.mov(page, qword[r14 + tmp.cvt64()]);
-    } else {
-        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
-    }
+    code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+    code.mov(page, qword[r14 + tmp]);

    // check for marked bit, use as unmapped if marked
    if (ctx.conf.page_table_marked_bit) {
@@ -182,7 +178,6 @@ template<>
        code.mov(tmp, ctx.conf.page_table_pointer_mask);
        code.and_(page, tmp);
    }
-    // check for sign bit, apply sign extension as needed
    if (ctx.conf.page_table_sign_extension) {
        code.shl(page, *ctx.conf.page_table_sign_extension);
        code.sar(page, *ctx.conf.page_table_sign_extension);
@@ -66,9 +66,7 @@ struct UserCallbacks : public TranslateCallbacks {

    // All reads through this callback are 4-byte aligned.
    // Memory must be interpreted as little endian.
-    std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) override {
-        return std::uint32_t(MemoryRead(vaddr, sizeof(std::uint32_t)));
-    }
+    std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) override { return MemoryRead32(vaddr); }

    // This function is called before the instruction at pc is read.
    // IR code can be emitted by the callee prior to instruction handling.
@@ -82,10 +80,16 @@ struct UserCallbacks : public TranslateCallbacks {

    // Reads through these callbacks may not be aligned.
    // Memory must be interpreted as if ENDIANSTATE == 0, endianness will be corrected by the JIT.
-    virtual std::uint64_t MemoryRead(VAddr vaddr, std::size_t size) = 0;
+    virtual std::uint8_t MemoryRead8(VAddr vaddr) = 0;
+    virtual std::uint16_t MemoryRead16(VAddr vaddr) = 0;
+    virtual std::uint32_t MemoryRead32(VAddr vaddr) = 0;
+    virtual std::uint64_t MemoryRead64(VAddr vaddr) = 0;

    // Writes through these callbacks may not be aligned.
-    virtual void MemoryWrite(VAddr vaddr, std::uint64_t value, std::size_t size) = 0;
+    virtual void MemoryWrite8(VAddr vaddr, std::uint8_t value) = 0;
+    virtual void MemoryWrite16(VAddr vaddr, std::uint16_t value) = 0;
+    virtual void MemoryWrite32(VAddr vaddr, std::uint32_t value) = 0;
+    virtual void MemoryWrite64(VAddr vaddr, std::uint64_t value) = 0;

    // Writes through these callbacks may not be aligned.
    virtual bool MemoryWriteExclusive8(VAddr /*vaddr*/, std::uint8_t /*value*/, std::uint8_t /*expected*/) { return false; }
@@ -89,16 +89,20 @@ struct UserCallbacks {

    // All reads through this callback are 4-byte aligned.
    // Memory must be interpreted as little endian.
-    virtual std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) {
-        return std::uint32_t(MemoryRead(vaddr, sizeof(std::uint32_t)));
-    }
+    virtual std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) { return MemoryRead32(vaddr); }

    // Reads through these callbacks may not be aligned.
-    virtual std::uint64_t MemoryRead(VAddr vaddr, std::size_t size) = 0;
+    virtual std::uint8_t MemoryRead8(VAddr vaddr) = 0;
+    virtual std::uint16_t MemoryRead16(VAddr vaddr) = 0;
+    virtual std::uint32_t MemoryRead32(VAddr vaddr) = 0;
+    virtual std::uint64_t MemoryRead64(VAddr vaddr) = 0;
    virtual Vector MemoryRead128(VAddr vaddr) = 0;

    // Writes through these callbacks may not be aligned.
-    virtual void MemoryWrite(VAddr vaddr, std::uint64_t value, std::size_t size) = 0;
+    virtual void MemoryWrite8(VAddr vaddr, std::uint8_t value) = 0;
+    virtual void MemoryWrite16(VAddr vaddr, std::uint16_t value) = 0;
+    virtual void MemoryWrite32(VAddr vaddr, std::uint32_t value) = 0;
+    virtual void MemoryWrite64(VAddr vaddr, std::uint64_t value) = 0;
    virtual void MemoryWrite128(VAddr vaddr, Vector value) = 0;

    // Writes through these callbacks may not be aligned.
@@ -40,7 +40,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
            if (inst.AreAllArgsImmediates()) {
                const u32 vaddr = inst.GetArg(1).GetU32();
                if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u8 value_from_memory = u8(cb->MemoryRead(vaddr, sizeof(u8)));
+                    const u8 value_from_memory = cb->MemoryRead8(vaddr);
                    inst.ReplaceUsesWith(IR::Value{value_from_memory});
                }
            }
@@ -51,7 +51,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
            if (inst.AreAllArgsImmediates()) {
                const u32 vaddr = inst.GetArg(1).GetU32();
                if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u16 value_from_memory = u16(cb->MemoryRead(vaddr, sizeof(u16)));
+                    const u16 value_from_memory = cb->MemoryRead16(vaddr);
                    inst.ReplaceUsesWith(IR::Value{value_from_memory});
                }
            }
@@ -62,7 +62,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
            if (inst.AreAllArgsImmediates()) {
                const u32 vaddr = inst.GetArg(1).GetU32();
                if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u32 value_from_memory = u32(cb->MemoryRead(vaddr, sizeof(u32)));
+                    const u32 value_from_memory = cb->MemoryRead32(vaddr);
                    inst.ReplaceUsesWith(IR::Value{value_from_memory});
                }
            }
@@ -73,7 +73,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
            if (inst.AreAllArgsImmediates()) {
                const u32 vaddr = inst.GetArg(1).GetU32();
                if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u64 value_from_memory = u64(cb->MemoryRead(vaddr, sizeof(u64)));
+                    const u64 value_from_memory = cb->MemoryRead64(vaddr);
                    inst.ReplaceUsesWith(IR::Value{value_from_memory});
                }
            }
@@ -503,7 +503,7 @@ TEST_CASE("Fuzz Thumb32 instructions set", "[JitX64][Thumb][Thumb32]") {
    }
 }

-TEST_CASE("Verify fix for off by one error in MemoryRead<32> worked", "[Thumb][Thumb16]") {
+TEST_CASE("Verify fix for off by one error in MemoryRead32 worked", "[Thumb][Thumb16]") {
    ThumbTestEnv test_env;

    // Prepare test subjects
@@ -553,9 +553,9 @@ TEST_CASE("arm: Memory access (fastmem)", "[arm][A32]") {
    memset(backing_memory, 0, memory_size);
    memcpy(backing_memory + 0x100, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 57);

-    env.MemoryWrite(0, 0xE5904000, sizeof(u32));  // LDR R4, [R0]
-    env.MemoryWrite(4, 0xE5814000, sizeof(u32));  // STR R4, [R1]
-    env.MemoryWrite(8, 0xEAFFFFFE, sizeof(u32));  // B .
+    env.MemoryWrite32(0, 0xE5904000);  // LDR R4, [R0]
+    env.MemoryWrite32(4, 0xE5814000);  // STR R4, [R1]
+    env.MemoryWrite32(8, 0xEAFFFFFE);  // B .
    jit.Regs()[0] = 0x100;
    jit.Regs()[1] = 0x1F0;
    jit.Regs()[15] = 0;       // PC = 0
@@ -16,7 +16,6 @@

 #include "common/assert.h"
 #include "common/common_types.h"
-#include "dynarmic/frontend/A32/translate/translate_callbacks.h"
 #include "dynarmic/interface/A32/a32.h"

 template<typename InstructionType_, u32 infinite_loop_u32>
@@ -60,51 +59,42 @@ public:
        return infinite_loop_u32;  // B .
    }

-    u64 MemoryRead(u32 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            return MemoryRead(vaddr, sizeof(u32))
-                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
-        case sizeof(u32):
-            return MemoryRead(vaddr, sizeof(u16))
-                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
-        case sizeof(u16):
-            return MemoryRead(vaddr, sizeof(u8))
-                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
-        case sizeof(u8): {
-            if (IsInCodeMem(vaddr))
-                return reinterpret_cast<u8*>(code_mem.data())[vaddr];
-            if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end())
-                return iter->second;
-            return u8(vaddr);
+    std::uint8_t MemoryRead8(u32 vaddr) override {
+        if (IsInCodeMem(vaddr)) {
+            return reinterpret_cast<u8*>(code_mem.data())[vaddr];
        }
-        default:
-            std::abort();
+        if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end()) {
+            return iter->second;
        }
+        return static_cast<u8>(vaddr);
+    }
+    std::uint16_t MemoryRead16(u32 vaddr) override {
+        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
+    }
+    std::uint32_t MemoryRead32(u32 vaddr) override {
+        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
+    }
+    std::uint64_t MemoryRead64(u32 vaddr) override {
+        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
    }

-    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            MemoryWrite(vaddr, u32(value), sizeof(u32));
-            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
-            break;
-        case sizeof(u32):
-            MemoryWrite(vaddr, u16(value), sizeof(u16));
-            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
-            break;
-        case sizeof(u16):
-            MemoryWrite(vaddr, u8(value), sizeof(u8));
-            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
-            break;
-        case sizeof(u8):
-            if (vaddr < code_mem.size() * sizeof(u32))
-                code_mem_modified_by_guest = true;
-            modified_memory[vaddr] = value;
-            break;
-        default:
-            std::abort();
+    void MemoryWrite8(u32 vaddr, std::uint8_t value) override {
+        if (vaddr < code_mem.size() * sizeof(u32)) {
+            code_mem_modified_by_guest = true;
        }
+        modified_memory[vaddr] = value;
+    }
+    void MemoryWrite16(u32 vaddr, std::uint16_t value) override {
+        MemoryWrite8(vaddr, static_cast<u8>(value));
+        MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8));
+    }
+    void MemoryWrite32(u32 vaddr, std::uint32_t value) override {
+        MemoryWrite16(vaddr, static_cast<u16>(value));
+        MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16));
+    }
+    void MemoryWrite64(u32 vaddr, std::uint64_t value) override {
+        MemoryWrite32(vaddr, static_cast<u32>(value));
+        MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32));
    }

    void CallSVC(std::uint32_t swi) override {
@@ -153,41 +143,46 @@ public:
        return read<std::uint32_t>(vaddr);
    }

-    u64 MemoryRead(u32 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return read<u64>(vaddr);
-        case sizeof(u32): return read<u32>(vaddr);
-        case sizeof(u16): return read<u16>(vaddr);
-        case sizeof(u8): return read<u8>(vaddr);
-        default:
-            std::abort();
-        }
+    std::uint8_t MemoryRead8(std::uint32_t vaddr) override {
+        return read<std::uint8_t>(vaddr);
+    }
+    std::uint16_t MemoryRead16(std::uint32_t vaddr) override {
+        return read<std::uint16_t>(vaddr);
+    }
+    std::uint32_t MemoryRead32(std::uint32_t vaddr) override {
+        return read<std::uint32_t>(vaddr);
+    }
+    std::uint64_t MemoryRead64(std::uint32_t vaddr) override {
+        return read<std::uint64_t>(vaddr);
    }

-    void MemoryWrite(Dynarmic::A32::VAddr vaddr, std::uint64_t value, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return write<u64>(vaddr, u64(value));
-        case sizeof(u32): return write<u32>(vaddr, u32(value));
-        case sizeof(u16): return write<u16>(vaddr, u16(value));
-        case sizeof(u8): return write<u8>(vaddr, u8(value));
-        default: std::abort();
-        }
+    void MemoryWrite8(std::uint32_t vaddr, std::uint8_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite16(std::uint32_t vaddr, std::uint16_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite32(std::uint32_t vaddr, std::uint32_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite64(std::uint32_t vaddr, std::uint64_t value) override {
+        write(vaddr, value);
    }

-    bool MemoryWriteExclusive8(Dynarmic::A32::VAddr vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u8));
+    bool MemoryWriteExclusive8(std::uint32_t vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
+        MemoryWrite8(vaddr, value);
        return true;
    }
-    bool MemoryWriteExclusive16(Dynarmic::A32::VAddr vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u16));
+    bool MemoryWriteExclusive16(std::uint32_t vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
+        MemoryWrite16(vaddr, value);
        return true;
    }
-    bool MemoryWriteExclusive32(Dynarmic::A32::VAddr vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u32));
+    bool MemoryWriteExclusive32(std::uint32_t vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
+        MemoryWrite32(vaddr, value);
        return true;
    }
-    bool MemoryWriteExclusive64(Dynarmic::A32::VAddr vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u64));
+    bool MemoryWriteExclusive64(std::uint32_t vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
+        MemoryWrite64(vaddr, value);
        return true;
    }

@@ -25,55 +25,48 @@ public:
    u64 ticks_left = 0;
    ::Common::unordered_map<u64, u8> memory{};

-    u64 MemoryRead(u64 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            return MemoryRead(vaddr, sizeof(u32))
-                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
-        case sizeof(u32):
-            return MemoryRead(vaddr, sizeof(u16))
-                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
-        case sizeof(u16):
-            return MemoryRead(vaddr, sizeof(u8))
-                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
-        case sizeof(u8):
-            return memory[vaddr];
-        default:
-            std::abort();
-        }
+    u8 MemoryRead8(u64 vaddr) override {
+        return memory[vaddr];
+    }
+
+    u16 MemoryRead16(u64 vaddr) override {
+        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
+    }
+
+    u32 MemoryRead32(u64 vaddr) override {
+        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
+    }
+
+    u64 MemoryRead64(u64 vaddr) override {
+        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
    }

    std::array<u64, 2> MemoryRead128(u64 vaddr) override {
-        return {
-            MemoryRead(vaddr, sizeof(u64)),
-            MemoryRead(vaddr + sizeof(u64), sizeof(u64))
-        };
+        return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)};
    }

-    void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            MemoryWrite(vaddr, u32(value), sizeof(u32));
-            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
-            break;
-        case sizeof(u32):
-            MemoryWrite(vaddr, u16(value), sizeof(u16));
-            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
-            break;
-        case sizeof(u16):
-            MemoryWrite(vaddr, u8(value), sizeof(u8));
-            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
-            break;
-        case sizeof(u8):
-            memory[vaddr] = value;
-            break;
-        default:
-            std::abort();
-        }
+    void MemoryWrite8(u64 vaddr, u8 value) override {
+        memory[vaddr] = value;
    }
+
+    void MemoryWrite16(u64 vaddr, u16 value) override {
+        MemoryWrite8(vaddr, u8(value));
+        MemoryWrite8(vaddr + 1, u8(value >> 8));
+    }
+
+    void MemoryWrite32(u64 vaddr, u32 value) override {
+        MemoryWrite16(vaddr, u16(value));
+        MemoryWrite16(vaddr + 2, u16(value >> 16));
+    }
+
+    void MemoryWrite64(u64 vaddr, u64 value) override {
+        MemoryWrite32(vaddr, u32(value));
+        MemoryWrite32(vaddr + 4, u32(value >> 32));
+    }
+
    void MemoryWrite128(u64 vaddr, std::array<u64, 2> value) override {
-        MemoryWrite(vaddr, value[0], sizeof(u64));
-        MemoryWrite(vaddr + 8, value[1], sizeof(u64));
+        MemoryWrite64(vaddr, value[0]);
+        MemoryWrite64(vaddr + 8, value[1]);
    }

    void CallSVC(u32) override {
@@ -142,9 +135,9 @@ TEST_CASE("A64: fibonacci", "[a64]") {
    code.RET();

    for (size_t i = 0; i < 1024; i++) {
-        env.MemoryWrite(i * 4, instructions[i], sizeof(u32));
+        env.MemoryWrite32(i * 4, instructions[i]);
    }
-    env.MemoryWrite(8888, 0xd4200000, sizeof(u32));
+    env.MemoryWrite32(8888, 0xd4200000);
    cpu.SetRegister(30, 8888);

    cpu.SetRegister(0, 10);
@@ -12,7 +12,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "dynarmic/interface/A64/a64.h"
-#include "dynarmic/interface/A64/config.h"

 using Vector = Dynarmic::A64::Vector;

@@ -35,79 +34,64 @@ public:
        return code_mem[index];
    }

-    u64 MemoryRead(u64 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            return MemoryRead(vaddr, sizeof(u32))
-                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
-        case sizeof(u32):
-            return MemoryRead(vaddr, sizeof(u16))
-                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
-        case sizeof(u16):
-            return MemoryRead(vaddr, sizeof(u8))
-                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
-        case sizeof(u8): {
-            if (IsInCodeMem(vaddr))
-                return reinterpret_cast<u8*>(code_mem.data())[vaddr - code_mem_start_address];
-            if (auto const it = modified_memory.find(vaddr); it != modified_memory.end())
-                return it->second;
-            return u8(vaddr);
-        }
-        default:
-            std::abort();
+    std::uint8_t MemoryRead8(u64 vaddr) override {
+        if (IsInCodeMem(vaddr)) {
+            return reinterpret_cast<u8*>(code_mem.data())[vaddr - code_mem_start_address];
        }
+        if (auto const it = modified_memory.find(vaddr); it != modified_memory.end())
+            return it->second;
+        return u8(vaddr);
+    }
+    std::uint16_t MemoryRead16(u64 vaddr) override {
+        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
+    }
+    std::uint32_t MemoryRead32(u64 vaddr) override {
+        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
+    }
+    std::uint64_t MemoryRead64(u64 vaddr) override {
+        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
    }
-
    Vector MemoryRead128(u64 vaddr) override {
-        return {
-            MemoryRead(vaddr, sizeof(u64)),
-            MemoryRead(vaddr + 8, sizeof(u64))
-        };
+        return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)};
    }

-    void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            MemoryWrite(vaddr, u32(value), sizeof(u32));
-            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
-            break;
-        case sizeof(u32):
-            MemoryWrite(vaddr, u16(value), sizeof(u16));
-            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
-            break;
-        case sizeof(u16):
-            MemoryWrite(vaddr, u8(value), sizeof(u8));
-            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
-            break;
-        case sizeof(u8):
-            if (IsInCodeMem(vaddr)) {
-                code_mem_modified_by_guest = true;
-            }
-            modified_memory[vaddr] = value;
-            break;
-        default:
-            std::abort();
+    void MemoryWrite8(u64 vaddr, std::uint8_t value) override {
+        if (IsInCodeMem(vaddr)) {
+            code_mem_modified_by_guest = true;
        }
+        modified_memory[vaddr] = value;
+    }
+    void MemoryWrite16(u64 vaddr, std::uint16_t value) override {
+        MemoryWrite8(vaddr, u8(value));
+        MemoryWrite8(vaddr + 1, u8(value >> 8));
+    }
+    void MemoryWrite32(u64 vaddr, std::uint32_t value) override {
+        MemoryWrite16(vaddr, u16(value));
+        MemoryWrite16(vaddr + 2, u16(value >> 16));
+    }
+    void MemoryWrite64(u64 vaddr, std::uint64_t value) override {
+        MemoryWrite32(vaddr, u32(value));
+        MemoryWrite32(vaddr + 4, u32(value >> 32));
    }
    void MemoryWrite128(u64 vaddr, Vector value) override {
-        MemoryWrite(vaddr, value[0], sizeof(u64));
-        MemoryWrite(vaddr + 8, value[1], sizeof(u64));
+        MemoryWrite64(vaddr, value[0]);
+        MemoryWrite64(vaddr + 8, value[1]);
    }

    bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u8));
+        MemoryWrite8(vaddr, value);
        return true;
    }
    bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u16));
+        MemoryWrite16(vaddr, value);
        return true;
    }
    bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u32));
+        MemoryWrite32(vaddr, value);
        return true;
    }
    bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u64));
+        MemoryWrite64(vaddr, value);
        return true;
    }
    bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override {
@@ -161,46 +145,52 @@ public:
        return read<std::uint32_t>(vaddr);
    }

-    u64 MemoryRead(u64 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return read<u64>(vaddr);
-        case sizeof(u32): return read<u32>(vaddr);
-        case sizeof(u16): return read<u16>(vaddr);
-        case sizeof(u8): return read<u8>(vaddr);
-        default: std::abort();
-        }
+    std::uint8_t MemoryRead8(u64 vaddr) override {
+        return read<std::uint8_t>(vaddr);
+    }
+    std::uint16_t MemoryRead16(u64 vaddr) override {
+        return read<std::uint16_t>(vaddr);
+    }
+    std::uint32_t MemoryRead32(u64 vaddr) override {
+        return read<std::uint32_t>(vaddr);
+    }
+    std::uint64_t MemoryRead64(u64 vaddr) override {
+        return read<std::uint64_t>(vaddr);
    }
    Vector MemoryRead128(u64 vaddr) override {
        return read<Vector>(vaddr);
    }

-    void MemoryWrite(u64 vaddr, std::uint64_t value, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return write<u64>(vaddr, u64(value));
-        case sizeof(u32): return write<u32>(vaddr, u32(value));
-        case sizeof(u16): return write<u16>(vaddr, u16(value));
-        case sizeof(u8): return write<u8>(vaddr, u8(value));
-        default: std::abort();
-        }
+    void MemoryWrite8(u64 vaddr, std::uint8_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite16(u64 vaddr, std::uint16_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite32(u64 vaddr, std::uint32_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite64(u64 vaddr, std::uint64_t value) override {
+        write(vaddr, value);
    }
    void MemoryWrite128(u64 vaddr, Vector value) override {
        write(vaddr, value);
    }

    bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u8));
+        MemoryWrite8(vaddr, value);
        return true;
    }
    bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u16));
+        MemoryWrite16(vaddr, value);
        return true;
    }
    bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u32));
+        MemoryWrite32(vaddr, value);
        return true;
    }
    bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u64));
+        MemoryWrite64(vaddr, value);
        return true;
    }
    bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override {
@@ -18,7 +18,6 @@
 #include <fmt/format.h>
 #include <fmt/ostream.h>
 #include <fmt/ranges.h>
-#include "dynarmic/frontend/A32/translate/translate_callbacks.h"
 #include "dynarmic/mcl/bit.hpp"
 #include "common/common_types.h"

@@ -119,47 +118,36 @@ public:
    u64 ticks_left = 0;
    std::map<u32, u8> memory;

-    u64 MemoryRead(Dynarmic::A32::VAddr vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            return MemoryRead(vaddr, sizeof(u32))
-                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
-        case sizeof(u32):
-            return MemoryRead(vaddr, sizeof(u16))
-                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
-        case sizeof(u16):
-            return MemoryRead(vaddr, sizeof(u8))
-                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
-        case sizeof(u8): {
-            if (auto const it = memory.find(vaddr); it != memory.end())
-                return it->second;
-            return 0;
-        }
-        default:
-            std::abort();
+    std::uint8_t MemoryRead8(u32 vaddr) override {
+        if (auto iter = memory.find(vaddr); iter != memory.end()) {
+            return iter->second;
        }
+        return 0;
+    }
+    std::uint16_t MemoryRead16(u32 vaddr) override {
+        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
+    }
+    std::uint32_t MemoryRead32(u32 vaddr) override {
+        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
+    }
+    std::uint64_t MemoryRead64(u32 vaddr) override {
+        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
    }

-    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            MemoryWrite(vaddr, u32(value), sizeof(u32));
-            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
-            break;
-        case sizeof(u32):
-            MemoryWrite(vaddr, u16(value), sizeof(u16));
-            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
-            break;
-        case sizeof(u16):
-            MemoryWrite(vaddr, u8(value), sizeof(u8));
-            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
-            break;
-        case sizeof(u8):
-            memory[vaddr] = value;
-            break;
-        default:
-            std::abort();
-        }
+    void MemoryWrite8(u32 vaddr, std::uint8_t value) override {
+        memory[vaddr] = value;
+    }
+    void MemoryWrite16(u32 vaddr, std::uint16_t value) override {
+        MemoryWrite8(vaddr, static_cast<u8>(value));
+        MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8));
+    }
+    void MemoryWrite32(u32 vaddr, std::uint32_t value) override {
+        MemoryWrite16(vaddr, static_cast<u16>(value));
+        MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16));
+    }
+    void MemoryWrite64(u32 vaddr, std::uint64_t value) override {
+        MemoryWrite32(vaddr, static_cast<u32>(value));
+        MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32));
    }

    void CallSVC(std::uint32_t swi) override {
@@ -243,7 +231,7 @@ void ExecuteA32Instruction(u32 instruction) {
            if (const auto address = get_value()) {
                fmt::print("value: ");
                if (const auto value = get_value()) {
-                    env.MemoryWrite(*address, *value, sizeof(u32));
+                    env.MemoryWrite32(*address, *value);
                    fmt::print("> mem[{:#08x}] = {:#08x}\n", *address, *value);
                }
            }
@@ -259,8 +247,8 @@ void ExecuteA32Instruction(u32 instruction) {
    cpu.SetFpscr(fpscr);

    const u32 initial_pc = regs[15];
-    env.MemoryWrite(initial_pc + 0, instruction, sizeof(u32));
-    env.MemoryWrite(initial_pc + 4, 0xEAFFFFFE, sizeof(u32));  // B +0
+    env.MemoryWrite32(initial_pc + 0, instruction);
+    env.MemoryWrite32(initial_pc + 4, 0xEAFFFFFE);  // B +0

    cpu.Run();
    fmt::print("{}", fmt::join(cpu.Disassemble(), "\n"));
@@ -290,7 +290,7 @@ bool A32Unicorn<TestEnvironment>::UnmappedMemoryHook(uc_engine* uc, uc_mem_type
        auto page = std::make_unique<Page>();
        page->address = base_address;
        for (size_t i = 0; i < page->data.size(); ++i)
-            page->data[i] = u8(this_->testenv.MemoryRead(u32(base_address + i), sizeof(u8)));
+            page->data[i] = this_->testenv.MemoryRead8(static_cast<u32>(base_address + i));

        uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data());
        if (err == UC_ERR_MAP)
@@ -321,7 +321,24 @@ bool A32Unicorn<TestEnvironment>::UnmappedMemoryHook(uc_engine* uc, uc_mem_type
 template<class TestEnvironment>
 bool A32Unicorn<TestEnvironment>::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u32 start_address, int size, u64 value, void* user_data) {
    auto* this_ = static_cast<A32Unicorn*>(user_data);
-    this_->testenv.MemoryWrite(start_address, value, size);
+
+    switch (size) {
+    case 1:
+        this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value));
+        break;
+    case 2:
+        this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value));
+        break;
+    case 4:
+        this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value));
+        break;
+    case 8:
+        this_->testenv.MemoryWrite64(start_address, value);
+        break;
+    default:
+        UNREACHABLE();
+    }
+
    return true;
 }

@@ -197,7 +197,7 @@ bool A64Unicorn::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u64 sta
        auto page = std::make_unique<Page>();
        page->address = base_address;
        for (size_t i = 0; i < page->data.size(); ++i)
-            page->data[i] = u8(this_->testenv.MemoryRead(base_address + i, sizeof(u8)));
+            page->data[i] = this_->testenv.MemoryRead8(base_address + i);

        uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data());
        if (err == UC_ERR_MAP)
@@ -227,6 +227,23 @@ bool A64Unicorn::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u64 sta

 bool A64Unicorn::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u64 start_address, int size, u64 value, void* user_data) {
    auto* this_ = static_cast<A64Unicorn*>(user_data);
-    this_->testenv.MemoryWrite(start_address, value, size);
+
+    switch (size) {
+    case 1:
+        this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value));
+        break;
+    case 2:
+        this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value));
+        break;
+    case 4:
+        this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value));
+        break;
+    case 8:
+        this_->testenv.MemoryWrite64(start_address, value);
+        break;
+    default:
+        UNREACHABLE();
+    }
+
    return true;
 }
@@ -761,6 +761,9 @@ void EmulatedController::StartMotionCalibration() {
 }

 void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index, Common::UUID uuid) {
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
+    const auto& player = Settings::values.players.GetValue()[player_index];
+
    if (index >= controller.button_values.size()) {
        return;
    }
@@ -913,10 +916,21 @@ void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback
        break;
    }

-    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
-    const auto& player = Settings::values.players.GetValue()[player_index];
-    if (player.connected) {
-        Connect();
+    if (!is_connected) {
+        if (npad_type == NpadStyleIndex::Handheld) {
+            if (npad_id_type == NpadIdType::Handheld) {
+                Connect();
+                controller_connected[player_index] = true;
+            }
+        } else if (npad_type != NpadStyleIndex::Handheld) {
+            if (npad_id_type == NpadIdType::Player1) {
+                Connect();
+                controller_connected[player_index] = true;
+            } else if (player.connected && !controller_connected[player_index]) {
+                Connect();
+                controller_connected[player_index] = true;
+            }
+        }
    }

    TriggerOnChange(ControllerTriggerType::Button, true);
@@ -22,6 +22,7 @@
 #include "common/settings.h"
 #include "common/vector_math.h"
 #include "hid_core/frontend/motion_input.h"
+#include "hid_core/hid_core.h"
 #include "hid_core/hid_types.h"
 #include "hid_core/irsensor/irs_types.h"

@@ -584,6 +585,7 @@ private:
    std::array<VibrationValue, 2> last_vibration_value{DEFAULT_VIBRATION_VALUE,
                                                       DEFAULT_VIBRATION_VALUE};
    std::array<std::chrono::steady_clock::time_point, 2> last_vibration_timepoint{};
+    std::array<bool, HIDCore::available_controllers> controller_connected{};

    // Atomically synched values
    std::atomic<HID::NpadStyleIndex> npad_type{HID::NpadStyleIndex::None};
@@ -398,21 +398,21 @@ void NPad::InitNewlyAddedController(Kernel::KernelCore& kernel, u64 aruid, Core:
 void NPad::WriteEmptyEntry(NpadInternalState* npad) {
    NPadGenericState dummy_pad_state{};
    NpadGcTriggerState dummy_gc_state{};
-    dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->fullkey_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->handheld_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->handheld_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_dual_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_dual_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->joy_dual_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_left_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->joy_left_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_right_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->joy_right_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->palma_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->palma_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->palma_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->system_ext_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->system_ext_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->system_ext_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_gc_state.sampling_number = npad->gc_trigger_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_gc_state.sampling_number = npad->gc_trigger_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->gc_trigger_lifo.WriteNextEntry(dummy_gc_state);
 }

@@ -414,9 +414,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})

@@ -2850,6 +2850,8 @@ Sampler::VariantKey Sampler::MakeKey(const ImageView& image_view, bool is_depth)
    VariantKey key{};
    key.reduce_anisotropy = has_added_anisotropy && !image_view.SupportsAnisotropy();
    key.force_nearest = has_linear_filtering && IsPixelFormatInteger(image_view.format);
+    key.drop_depth_comparison =
+        is_depth && has_depth_comparison && !image_view.SupportsDepthComparison();
    key.drop_reduction = has_minmax_reduction && !image_view.SupportsMinmaxFilter();
    key.drop_custom_border = has_custom_border_colors && image_view.RequiresBorderColorFormat();
    key.srgb_border = has_srgb_border_color && IsPixelFormatSRGB(image_view.format);
@@ -2927,6 +2929,9 @@ VkSampler Sampler::Emplace(VariantKey key) {
        create_info.anisotropyEnable = static_cast<VkBool32>(default_anisotropy > 1.0f);
        create_info.maxAnisotropy = default_anisotropy;
    }
+    if (key.drop_depth_comparison) {
+        create_info.compareEnable = VK_FALSE;
+    }
    if (!custom_border) {
        create_info.borderColor = ConvertBorderColor(color);
    }
@@ -536,6 +536,7 @@ private:
    struct VariantKey {
        bool reduce_anisotropy;
        bool force_nearest;
+        bool drop_depth_comparison;
        bool drop_reduction;
        bool drop_custom_border;
        bool srgb_border;
Author	SHA1	Message	Date
lizzie	d9376695cf	2026-09-15 19:23:45 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 19:23:45 +00:00
lizzie	7e14631b33	2026-09-14 09:32:00 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 22:12:39 +02:00
lizzie	401707294a	2026-09-14 09:23:00 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 22:12:39 +02:00
lizzie	14d79755c6	2026-09-14 09:22:19 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 22:12:39 +02:00
lizzie	2114b7eb4b	2026-09-14 08:48:05 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 22:12:39 +02:00
lizzie	02726fbcd8	Reapply "[audio] Replace libopus with FFmpeg (#4169 )" (#4419 ) This reverts commit `2b4184dd2b`.	2026-09-15 22:12:39 +02:00
lizzie	7766fe7501	Trigger build	2026-09-15 22:12:39 +02:00