[debug] debug knobs adjustments

.patch/opus/0001-disable-clang-runtime-neon.patch

@@ -0,0 +1,28 @@
+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)

.patch/opus/0002-no-install.patch

@@ -0,0 +1,153 @@
+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)

CMakeLists.txt

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

CMakeModules/find/FindOpus.cmake

@@ -0,0 +1,22 @@
+# 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()

cpmfile.json

@@ -218,6 +218,21 @@
         "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",

docs/Deps.md

@@ -60,6 +60,7 @@ 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 +122,7 @@ sudo emerge -a \
     dev-libs/unordered_dense dev-libs/boost dev-libs/openssl dev-libs/discord-rpc \
     dev-util/spirv-tools dev-util/spirv-headers dev-util/vulkan-headers \
     dev-util/vulkan-utility-libraries dev-util/glslang \
-    media-gfx/renderdoc media-libs/libva media-video/ffmpeg \
+    media-gfx/renderdoc media-libs/libva media-libs/opus media-video/ffmpeg \
     media-libs/VulkanMemoryAllocator media-libs/libsdl3 media-libs/cubeb \
     net-libs/enet \
     sys-libs/zlib \
@@ -153,7 +154,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 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 opus 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 +167,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 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 libopus-dev libasound2t64 vulkan-utility-libraries-dev
 ```
 
 * Ubuntu 26.04, Linux Mint 22.3, or Debian 13 or later is required.
@@ -213,7 +214,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  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 opus-dev jq patch
 ```
 
 </details>
@@ -259,7 +260,7 @@ brew install molten-vk
 <details>
 <summary>FreeBSD</summary>
 
-As root run: `pkg install devel/cmake sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/qt6-charts devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib devel/unordered-dense vulkan-headers quazip-qt6`
+As root run: `pkg install devel/cmake sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/qt6-charts devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg audio/opus archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib devel/unordered-dense vulkan-headers quazip-qt6`
 
 If using FreeBSD 12 or prior, use `devel/pkg-config` instead.
 
@@ -272,7 +273,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 qt6 cpp-httplib lz4 vulkan-headers nasm autoconf enet pkg-config libusb1 libcxx frozen
+pkgin install git cmake boost fmtlib SDL3 catch2 libjwt spirv-headers spirv-tools ffmpeg7 libva nlohmann-json jq libopus qt6 cpp-httplib lz4 vulkan-headers nasm autoconf enet pkg-config libusb1 libcxx frozen
 ```
 
 [Caveats](./Caveats.md#netbsd).
@@ -303,7 +304,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 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 opus sdl3 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt
 ```
 
 [Caveats](./Caveats.md#openindiana).
@@ -327,7 +328,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 libusb unordered_dense openssl SDL3"
+MINGW="qt6-base qt6-charts qt6-tools qt6-translations qt6-svg cmake toolchain clang python-pip openssl vulkan-memory-allocator vulkan-devel glslang boost fmt lz4 nlohmann-json zlib zstd enet opus libusb unordered_dense openssl SDL3"
 # Either x86_64 or clang-aarch64 (Windows on ARM)
 packages="$BASE"
 for pkg in $MINGW; do
@@ -353,7 +354,7 @@ pacman -Syuu --needed --noconfirm $packages
 <summary>HaikuOS</summary>
 
 ```sh
-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
+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
 ```
 
 [Caveats](./Caveats.md#haikuos).

docs/Settings.md

@@ -43,6 +43,7 @@ This guide will walk you through adding a new boolean toggle setting to Eden's c
 Firstly add your desired toggle:
 
 Example: `src/common/setting.h`
+
 ```cpp
 SwitchableSetting<bool> your_setting_name{linkage, false, "your_setting_name", Category::RendererExtensions};
 ```
@@ -67,6 +68,7 @@ Common Categories:
 Add the toggle to the Qt UI, where you wish for it to appear and place it there.
 
 Example: `src/qt_common/config/shared_translation.cpp`
+
 ```cpp
 INSERT(Settings,
        your_setting_name,
@@ -91,6 +93,7 @@ INSERT(Settings,
 Add where it should be in the settings.
 
 Example: `src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt`
+
 ```kts
 RENDERER_YOUR_SETTING_NAME("your_setting_name"),
 ```
@@ -106,6 +109,7 @@ RENDERER_YOUR_SETTING_NAME("your_setting_name"),
 Add the toggle to the Kotlin (Android) UI
 
 Example: `src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt`
+
 ```kts
 put(
     SwitchSetting(
@@ -123,6 +127,7 @@ put(
 Add your setting within the right category.
 
 Example: `src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt`
+
 ```kts
 add(BooleanSetting.RENDERER_YOUR_SETTING_NAME.key)
 ```
@@ -137,6 +142,7 @@ add(BooleanSetting.RENDERER_YOUR_SETTING_NAME.key)
 Add your setting and description in the appropriate place.
 
 Example: `src/android/app/src/main/res/values/strings.xml`
+
 ```xml
 <string name="your_setting_name">Your Setting Display Name</string>
 <string name="your_setting_name_description">Detailed description of what this setting does. Explain any caveats, requirements, or warnings here.</string>
@@ -150,6 +156,7 @@ Now the UI part is done find a place in the code for the toggle,
 And use it to your heart's desire!
 
 Example:
+
 ```cpp
 const bool your_value = Settings::values.your_setting_name.GetValue();
 
@@ -196,25 +203,31 @@ Common advantages recap:
 
 #### Accessing Debug Knobs (dev side)
 
-Use the `Settings::getDebugKnobAt(u8 i)` function to check if a specific bit is set:
+Use the `Settings::GetDebugKnobAt(u8 i)` function to check if a specific bit is set:
 
 ```cpp
 //cpp side
 #include "common/settings.h"
 
+//To use it as a general purpose uint var:
+unsigned int debug_knobs = Settings::values.debug_knobs.GetValue();
+
 // Check if bit 0 is set
-bool feature_enabled = Settings::getDebugKnobAt(0);
+bool feature_enabled = Settings::GetDebugKnobAt(0);
 
 // Check if bit 15 is set
-bool another_feature = Settings::getDebugKnobAt(15);
+bool another_feature = Settings::GetDebugKnobAt(15);
 ```
 
 ```kts
 //kotlin side
 import org.yuzu.yuzu_emu.features.settings.model.Settings
 
+//To use it as a general purpose uint var
+val debug_knobs: Int = UShortSetting.DEBUG_KNOBS.getInt()
+
 // Check if bit x is set
-bool feature_enabled = Settings.getDebugKnobAt(x); //x as integer from 0 to 15
+bool feature_enabled = Settings.GetDebugKnobAt(x); //x as integer from 0 to 15
 ```
 
 The function returns `true` if the specified bit (0-15) is set in the `debug_knobs` value, `false` otherwise.
@@ -247,6 +260,7 @@ There are two main confusions when talking about knobs:
 Sometimes when an user reports: knobs 1 and 2 gets better performance, dev may get confuse whether he means the knobs 1 and 2 literally, or the 1st and 2nd knobs (knobs 0 and 1).
 
 Debug knobs are **zero-based**, which means:
+
 * The first knob is the knob(0) (or knob0 henceforth), and the last one is the 15 (knob15, likewise)
 * You can talk: "knob0 is enabled/disabled", "In this video i was using only knobs 0 and 2", etc.
 
@@ -259,6 +273,7 @@ Whenever you're instructing tests or reporting results, be precise about whether
 
 ALWAYS use the word in PLURAL (knobs), without mentioning which one, to refer to the setting, aka multiple knobs at once:
 Examples:
+
 - **knobs=0**: no knobs enabled
 - **knobs=1**: knob0 enabled, others disabled
 - **knobs=2**: knob1 enabled, others disabled
@@ -270,6 +285,7 @@ Examples:
 
 Use the word in SINGULAR (knob), or in plural but referring which ones, when meaning multiple knobs at once:
 Examples:
+
 - **knob0**: knob 0 enabled, others disabled
 - **knob1**: knob 1 enabled, others disabled
 - **knobs 0 and 1**: knobs 0 and 1 enabled, others disabled
@@ -282,12 +298,12 @@ Examples:
 
 ```cpp
 void SomeFunction() {
-    if (Settings::getDebugKnobAt(0)) {
+    if (Settings::GetDebugKnobAt(0)) {
         LOG_DEBUG(Common, "Debug feature 0 is enabled");
         // Additional debug code here
     }
-    
+  
-    if (Settings::getDebugKnobAt(1)) {
+    if (Settings::GetDebugKnobAt(1)) {
         LOG_DEBUG(Common, "Debug feature 1 is enabled");
         // Different debug behavior
     }
@@ -299,7 +315,7 @@ void SomeFunction() {
 ```cpp
 bool UseOptimizedPath() {
     // Skip optimization if debug bit 2 is set for testing
-    return !Settings::getDebugKnobAt(2);
+    return !Settings::GetDebugKnobAt(2);
 }
 ```
 
@@ -308,13 +324,13 @@ bool UseOptimizedPath() {
 ```cpp
 void ExperimentalFeature() {
     static constexpr u8 EXPERIMENTAL_FEATURE_BIT = 3;
-    
+  
-    if (!Settings::getDebugKnobAt(EXPERIMENTAL_FEATURE_BIT)) {
+    if (!Settings::GetDebugKnobAt(EXPERIMENTAL_FEATURE_BIT)) {
         // Fallback to stable implementation
         StableImplementation();
         return;
     }
-    
+  
     // Experimental implementation
     ExperimentalImplementation();
 }

shell.nix

@@ -12,7 +12,7 @@ pkgs.mkShellNoCC {
     git cmake clang gnumake patch jq pkg-config
     # libraries
     openssl boost fmt nlohmann_json lz4 zlib zstd
-    enet vulkan-headers vulkan-utility-libraries
+    enet libopus vulkan-headers vulkan-utility-libraries
     spirv-tools spirv-headers vulkan-loader unzip
     glslang python3 httplib cpp-jwt ffmpeg-headless
     libusb1 cubeb

src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt

@@ -220,7 +220,7 @@ object NativeLibrary {
 
     external fun refreshThreadPolicies()
 
-    external fun getDebugKnobAt(index: Int): Boolean
+    external fun GetDebugKnobAt(index: Int): Boolean
 
     /**
      * Set the current speed limit to the configured turbo speed.

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/Settings.kt

@@ -35,8 +35,8 @@ object Settings {
     fun getPlayerString(player: Int): String =
         YuzuApplication.appContext.getString(R.string.preferences_player, player)
 
-    fun getDebugKnobAt(index: Int): Boolean {
+    fun GetDebugKnobAt(index: Int): Boolean {
-        return org.yuzu.yuzu_emu.NativeLibrary.getDebugKnobAt(index)
+        return org.yuzu.yuzu_emu.NativeLibrary.GetDebugKnobAt(index)
     }
 
     const val PREF_FIRST_APP_LAUNCH = "FirstApplicationLaunch"

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/ShortSetting.kt

@@ -11,8 +11,7 @@ import org.yuzu.yuzu_emu.utils.NativeConfig
 enum class ShortSetting(override val key: String) : AbstractShortSetting {
     RENDERER_SPEED_LIMIT("speed_limit"),
     RENDERER_TURBO_SPEED_LIMIT("turbo_speed_limit"),
-    RENDERER_SLOW_SPEED_LIMIT("slow_speed_limit"),
+    RENDERER_SLOW_SPEED_LIMIT("slow_speed_limit")
-    DEBUG_KNOBS("debug_knobs")
     ;
 
     override fun getShort(needsGlobal: Boolean): Short = NativeConfig.getShort(key, needsGlobal)
@@ -29,4 +28,4 @@ enum class ShortSetting(override val key: String) : AbstractShortSetting {
     override fun getValueAsString(needsGlobal: Boolean): String = getShort(needsGlobal).toString()
 
     override fun reset() = NativeConfig.setShort(key, defaultValue)
-}
+}

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/UShortSetting.kt

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package org.yuzu.yuzu_emu.features.settings.model
+
+import org.yuzu.yuzu_emu.utils.NativeConfig
+
+enum class UShortSetting(override val key: String) : AbstractIntSetting {
+    DEBUG_KNOBS("debug_knobs")
+    ;
+
+    override fun getInt(needsGlobal: Boolean): Int =
+        NativeConfig.getUnsignedShort(key, needsGlobal)
+
+    override fun setInt(value: Int) {
+        if (NativeConfig.isPerGameConfigLoaded()) {
+            global = false
+        }
+        NativeConfig.setUnsignedShort(key, value)
+    }
+
+    override val defaultValue: Int by lazy { NativeConfig.getDefaultToString(key).toInt() }
+
+    override fun getValueAsString(needsGlobal: Boolean): String = getInt(needsGlobal).toString()
+
+    override fun reset() = NativeConfig.setUnsignedShort(key, defaultValue)
+}

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -20,6 +20,7 @@ import org.yuzu.yuzu_emu.features.settings.model.IntSetting
 import org.yuzu.yuzu_emu.features.settings.model.LongSetting
 import org.yuzu.yuzu_emu.features.settings.model.ShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
+import org.yuzu.yuzu_emu.features.settings.model.UShortSetting
 import org.yuzu.yuzu_emu.network.NetDataValidators
 import org.yuzu.yuzu_emu.utils.LosslessScalingHelper
 import org.yuzu.yuzu_emu.utils.NativeConfig
@@ -1034,7 +1035,7 @@ abstract class SettingsItem(
             )
             put(
                 SpinBoxSetting(
-                    ShortSetting.DEBUG_KNOBS,
+                    UShortSetting.DEBUG_KNOBS,
                     titleId = R.string.debug_knobs,
                     descriptionId = R.string.debug_knobs_description,
                     valueHint = R.string.debug_knobs_hint,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -25,6 +25,7 @@ import org.yuzu.yuzu_emu.features.settings.model.Settings
 import org.yuzu.yuzu_emu.features.settings.model.Settings.MenuTag
 import org.yuzu.yuzu_emu.features.settings.model.ShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
+import org.yuzu.yuzu_emu.features.settings.model.UShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.view.*
 import org.yuzu.yuzu_emu.utils.InputHandler
 import org.yuzu.yuzu_emu.utils.LosslessScalingHelper
@@ -1326,7 +1327,7 @@ class SettingsFragmentPresenter(
 
             add(HeaderSetting(R.string.general))
 
-            add(ShortSetting.DEBUG_KNOBS.key)
+            add(UShortSetting.DEBUG_KNOBS.key)
             add(StringSetting.PROGRAM_ARGS.key)
 
             if (!NativeConfig.isPerGameConfigLoaded()) {

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/LicensesFragment.kt

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

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/NativeConfig.kt

@@ -80,6 +80,12 @@ object NativeConfig {
     @Synchronized
     external fun setShort(key: String, value: Short)
 
+    @Synchronized
+    external fun getUnsignedShort(key: String, needsGlobal: Boolean): Int
+
+    @Synchronized
+    external fun setUnsignedShort(key: String, value: Int)
+
     @Synchronized
     external fun getInt(key: String, needsGlobal: Boolean): Int
 

src/android/app/src/main/jni/native.cpp

@@ -76,7 +76,6 @@ extern "C" {
 #include "core/frontend/applets/software_keyboard.h"
 #include "core/frontend/applets/web_browser.h"
 #include "common/android/applets/web_browser.h"
-#include "core/file_sys/common_funcs.h"
 #include "core/hle/service/am/applet_manager.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/filesystem/filesystem.h"
@@ -312,23 +311,11 @@ Core::SystemResultStatus EmulationSession::InitializeEmulation(const std::string
     ConfigureFilesystemProvider(filepath);
 
     // Load the ROM.
-    const u64 previous_program_id =
-        program_index != 0 && m_next_program_id.load() >
-                                  static_cast<u64>(Service::AM::AppletProgramId::MaxProgramId)
-            ? m_next_program_id.load()
-            : 0;
-
     Service::AM::FrontendAppletParameters params{
-        .program_id = previous_program_id,
         .applet_id = static_cast<Service::AM::AppletId>(m_applet_id),
         .launch_type = frontend_initiated ? Service::AM::LaunchType::FrontendInitiated
                                           : Service::AM::LaunchType::ApplicationInitiated,
         .program_index = static_cast<s32>(program_index),
-        .previous_program_index =
-            previous_program_id != 0
-                ? static_cast<s32>(previous_program_id -
-                                   FileSys::GetBaseTitleID(previous_program_id))
-                : -1,
     };
 
     m_load_result = m_system.Load(EmulationSession::GetInstance().Window(), filepath, params);
@@ -341,12 +328,8 @@ Core::SystemResultStatus EmulationSession::InitializeEmulation(const std::string
     m_system.GetCpuManager().OnGpuReady();
     m_system.RegisterExitCallback([&] { HaltEmulation(); });
 
-    m_system.RegisterApplicationChangedCallback(
-        [&](u64 changed_program_id) { RequestDiskShaderCacheReload(changed_program_id); });
-
     // Register an ExecuteProgram callback such that Core can execute a sub-program
     m_system.RegisterExecuteProgramCallback([&](std::size_t program_index_) {
-        m_next_program_id = m_system.GetApplicationProcessProgramID();
         m_next_program_index = program_index_;
         EmulationSession::GetInstance().HaltEmulation();
     });
@@ -424,58 +407,20 @@ void EmulationSession::RunEmulation() {
     }
 
     while (true) {
-        std::optional<u64> reload_title;
         {
             [[maybe_unused]] std::unique_lock lock(m_mutex);
-            if (m_cv.wait_for(lock, std::chrono::milliseconds(800), [&]() {
+            if (m_cv.wait_for(lock, std::chrono::milliseconds(800),
-                    return !m_is_running || m_pending_shader_cache_title.has_value();
+                              [&]() { return !m_is_running; })) {
-                })) {
+                // Emulation halted.
-                if (!m_is_running) {
+                break;
-                    break;
-                }
-                reload_title = std::exchange(m_pending_shader_cache_title, std::nullopt);
             }
         }
-
-        if (reload_title.has_value())
-            ReloadDiskShaderCache(*reload_title);
     }
 
     // Reset current applet ID.
     m_applet_id = static_cast<int>(Service::AM::AppletId::Application);
 }
 
-void EmulationSession::RequestDiskShaderCacheReload(u64 program_id) {
-    {
-        std::scoped_lock lock(m_mutex);
-        m_pending_shader_cache_title = program_id;
-    }
-    m_cv.notify_one();
-}
-
-void EmulationSession::ReloadDiskShaderCache(u64 program_id) {
-    if (!Settings::values.use_disk_shader_cache.GetValue())
-        return;
-
-    LOG_INFO(Frontend, "Reloading disk shader cache for {:016X}", program_id);
-
-    const bool was_paused = m_is_paused;
-
-    m_system.Pause();
-    m_system.GPU().WaitForIdle();
-    m_system.GPU().ObtainContext();
-
-    LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
-    m_system.Renderer().ReadRasterizer()->LoadDiskResources(program_id, std::stop_token{},
-                                                            LoadDiskCacheProgress);
-    LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Complete, 0, 0);
-
-    m_system.GPU().ReleaseContext();
-
-    if (!was_paused)
-        m_system.Run();
-}
-
 Common::Android::SoftwareKeyboard::AndroidKeyboard* EmulationSession::SoftwareKeyboard() {
     return m_software_keyboard;
 }
@@ -1300,8 +1245,8 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_refreshThreadPolicies(JNIEnv* env, jo
     Common::RefreshThreadPolicies();
 }
 
-jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_getDebugKnobAt(JNIEnv* env, jobject jobj, jint index) {
+jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_GetDebugKnobAt(JNIEnv* env, jobject jobj, jint index) {
-    return static_cast<jboolean>(Settings::getDebugKnobAt(static_cast<u8>(index)));
+    return static_cast<jboolean>(Settings::GetDebugKnobAt(static_cast<u8>(index)));
 }
 
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_setTurboSpeedLimit(JNIEnv *env, jobject jobj, jboolean enabled) {

src/android/app/src/main/jni/native.h

@@ -4,8 +4,6 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <optional>
-
 #include <android/native_window_jni.h>
 #include "common/android/applets/software_keyboard.h"
 #include "core/core.h"
@@ -46,7 +44,6 @@ public:
     void HaltEmulation();
     void RunEmulation();
     void ShutdownEmulation();
-    void RequestDiskShaderCacheReload(u64 program_id);
 
     const Core::PerfStatsResults& PerfStats();
     int ShadersBuilding();
@@ -68,7 +65,6 @@ private:
     static void LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress, int max);
     static void OnEmulationStopped(Core::SystemResultStatus result);
     static void ChangeProgram(std::size_t program_index);
-    void ReloadDiskShaderCache(u64 program_id);
 
 private:
     // Window management
@@ -87,7 +83,6 @@ private:
     Common::Android::SoftwareKeyboard::AndroidKeyboard* m_software_keyboard{};
     std::unique_ptr<FileSys::ManualContentProvider> m_manual_provider;
     int m_applet_id{1};
-    std::optional<u64> m_pending_shader_cache_title;
 
     // GPU driver parameters
     std::shared_ptr<Common::DynamicLibrary> m_vulkan_library;
@@ -98,5 +93,4 @@ private:
 
     // Program index for next boot
     std::atomic<s32> m_next_program_index = -1;
-    std::atomic<u64> m_next_program_id = 0;
 };

src/android/app/src/main/jni/native_config.cpp

@@ -130,6 +130,25 @@ void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_setShort(JNIEnv* env, jobject ob
     setting->SetValue(value);
 }
 
+jint Java_org_yuzu_yuzu_1emu_utils_NativeConfig_getUnsignedShort(JNIEnv* env, jobject obj,
+                                                                 jstring jkey,
+                                                                 jboolean needGlobal) {
+    auto setting = getSetting<u16>(env, jkey);
+    if (setting == nullptr) {
+        return -1;
+    }
+    return static_cast<jint>(setting->GetValue(static_cast<bool>(needGlobal)));
+}
+
+void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_setUnsignedShort(JNIEnv* env, jobject obj,
+                                                                  jstring jkey, jint value) {
+    auto setting = getSetting<u16>(env, jkey);
+    if (setting == nullptr) {
+        return;
+    }
+    setting->SetValue(static_cast<u16>(value));
+}
+
 jint Java_org_yuzu_yuzu_1emu_utils_NativeConfig_getInt(JNIEnv* env, jobject obj, jstring jkey,
                                                        jboolean needGlobal) {
     auto setting = getSetting<int>(env, jkey);

src/android/app/src/main/res/values/strings.xml

@@ -1760,6 +1760,51 @@ 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>

src/audio_core/CMakeLists.txt

@@ -226,14 +226,8 @@ else()
         $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>)
 endif()
 
-if (YUZU_USE_EXTERNAL_FFMPEG)
+target_include_directories(audio_core PRIVATE ${OPUS_INCLUDE_DIRS})
-    add_dependencies(audio_core ffmpeg-build)
+target_link_libraries(audio_core PUBLIC common core Opus::opus)
-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

src/audio_core/adsp/apps/opus/opus_decode_object.cpp

@@ -1,71 +1,107 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavcodec/codec.h>
-#include <libavcodec/packet.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/frame.h>
-}
 #include "audio_core/adsp/apps/opus/opus_decode_object.h"
-#include "audio_core/adsp/apps/opus/opus_types.h"
 #include "common/assert.h"
-#include "core/hle/service/audio/errors.h"
 
 namespace AudioCore::ADSP::OpusDecoder {
+namespace {
+bool IsValidChannelCount(u32 channel_count) {
+    return channel_count == 1 || channel_count == 2;
+}
+} // namespace
 
 u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {
-    if (channel_count == 1 || channel_count == 2)
+    if (!IsValidChannelCount(channel_count)) {
-        return u32(sizeof(OpusDecodeObject)) + 16 * channel_count;
+        return 0;
-    return 0;
-}
-
-Result OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {
-    if ((codec = avcodec_find_decoder(AV_CODEC_ID_OPUS)) == nullptr)
-        return Service::Audio::ResultLibOpusInvalidState;
-    if ((avctx = avcodec_alloc_context3(codec)) == nullptr)
-        return Service::Audio::ResultLibOpusInvalidState;
-    avctx->sample_rate = sample_rate;
-    av_channel_layout_default(&avctx->ch_layout, channel_count);
-    return ResultSuccess;
-}
-
-Result OpusDecodeObject::Shutdown() {
-    if (avctx)
-        avcodec_free_context(&avctx);
-    return ResultSuccess;
-}
-
-Result OpusDecodeObject::ResetDecoder() {
-    if (avctx) {
-        avcodec_flush_buffers(avctx);
-        return ResultSuccess;
     }
-    return Service::Audio::ResultLibOpusInvalidState;
+    return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
 }
 
-Result OpusDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data, u64 input_data_size) {
+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 (avctx) {
-        AVPacket* avpkt = av_packet_alloc();
-        av_new_packet(avpkt, int(input_data_size));
-        std::memcpy(avpkt->data, reinterpret_cast<const u8*>(input_data), input_data_size);
-        avcodec_send_packet(avctx, avpkt);
 
-        AVFrame* frame = av_frame_alloc();
+    if (!state_valid) {
-        avcodec_receive_frame(avctx, frame);
+        return OPUS_INVALID_STATE;
-        std::memcpy(reinterpret_cast<u16*>(output_data), frame->data, output_data_size);
-        av_frame_free(&frame);
-        av_packet_free(&avpkt);
-
-        out_sample_count = frame->nb_samples;
-        return ResultSuccess;
     }
-    return Service::Audio::ResultLibOpusInvalidState;
+
+    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

src/audio_core/adsp/apps/opus/opus_decode_object.h

@@ -1,31 +1,38 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
-#include "common/common_types.h"
+#include <opus.h>
-#include "audio_core/adsp/apps/opus/opus_types.h"
-#include "core/hle/result.h"
 
-struct AVCodec;
+#include "common/common_types.h"
-struct AVCodecContext;
 
 namespace AudioCore::ADSP::OpusDecoder {
+using LibOpusDecoder = ::OpusDecoder;
+static constexpr u32 DecodeObjectMagic = 0xDEADBEEF;
 
 class OpusDecodeObject {
 public:
     static u32 GetWorkBufferSize(u32 channel_count);
+    static OpusDecodeObject& Initialize(u64 buffer, u64 buffer2);
 
-    Result InitializeDecoder(u32 sample_rate, u32 channel_count);
+    s32 InitializeDecoder(u32 sample_rate, u32 channel_count);
-    Result Shutdown();
+    s32 Shutdown();
-    Result ResetDecoder();
+    s32 ResetDecoder();
-    Result Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data, u64 input_data_size);
+    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;
+    }
 
-    AVCodec const* codec = nullptr;
+private:
-    AVCodecContext* avctx = nullptr;
+    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

src/audio_core/adsp/apps/opus/opus_decoder.cpp

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

src/audio_core/adsp/apps/opus/opus_decoder.h

@@ -9,9 +9,6 @@
 #include <memory>
 #include <thread>
 
-#include "ankerl/unordered_dense.h"
-#include "audio_core/adsp/apps/opus/opus_decode_object.h"
-#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
 #include "audio_core/adsp/apps/opus/shared_memory.h"
 #include "audio_core/adsp/mailbox.h"
 #include "common/common_types.h"
@@ -71,7 +68,9 @@ public:
     }
 
 private:
-    /// @brief Initializing thread, launched at audio_core boot to avoid blocking the main emu boot thread.
+    /**
+     * 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.
@@ -91,9 +90,6 @@ private:
     /// Structure shared with the host, input data set by the host before sending a mailbox message,
     /// and the responses are written back by the OpusDecoder.
     SharedMemory* shared_memory{};
-
-    ankerl::unordered_dense::map<u64, OpusDecodeObject> decode_objects;
-    ankerl::unordered_dense::map<u64, OpusMultiStreamDecodeObject> ms_decode_objects;
 };
 
 } // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp

@@ -1,80 +1,111 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavcodec/codec.h>
-#include <libavcodec/packet.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/frame.h>
-}
 #include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
 #include "common/assert.h"
-#include "core/hle/result.h"
-#include "core/hle/service/audio/errors.h"
 
 namespace AudioCore::ADSP::OpusDecoder {
 
 namespace {
-constexpr u32 OpusStreamCountMax = 255;
+bool IsValidChannelCount(u32 channel_count) {
+    return channel_count == 1 || channel_count == 2;
+}
 
 bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
-    return total_stream_count > 0 && total_stream_count <= OpusStreamCountMax
+    return total_stream_count > 0 && static_cast<s32>(stereo_stream_count) >= 0 &&
-        && s32(stereo_stream_count) >= 0 && stereo_stream_count <= total_stream_count;
+           stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);
 }
 } // namespace
 
-u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count, u32 stereo_stream_count) {
+u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count,
-    if (IsValidStreamCounts(total_stream_count, stereo_stream_count))
+                                                   u32 stereo_stream_count) {
-        return u32(sizeof(OpusMultiStreamDecodeObject)) + 2556 * (total_stream_count * 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;
 }
 
-Result OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count, u32 channel_count, u32 stereo_stream_count, u8* mappings) {
+OpusMultiStreamDecodeObject& OpusMultiStreamDecodeObject::Initialize(u64 buffer, u64 buffer2) {
-    if ((codec = avcodec_find_decoder(AV_CODEC_ID_OPUS)) == nullptr)
+    auto* new_decoder = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer);
-        return Service::Audio::ResultLibOpusInvalidState;
+    auto* comparison = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer2);
-    if ((avctx = avcodec_alloc_context3(codec)))
-        return Service::Audio::ResultLibOpusInvalidState;
-    avctx->sample_rate = sample_rate;
-    av_channel_layout_default(&avctx->ch_layout, channel_count);
-    return ResultSuccess;
-}
 
-Result OpusMultiStreamDecodeObject::Shutdown() {
+    if (new_decoder->magic == DecodeMultiStreamObjectMagic) {
-    if (avctx)
+        if (!new_decoder->initialized ||
-        avcodec_free_context(&avctx);
+            (new_decoder->initialized && new_decoder->self == comparison)) {
-    return ResultSuccess;
+            new_decoder->state_valid = true;
-}
+        }
-
+    } else {
-Result OpusMultiStreamDecodeObject::ResetDecoder() {
+        new_decoder->initialized = false;
-    if (avctx) {
+        new_decoder->state_valid = true;
-        avcodec_flush_buffers(avctx);
-        return ResultSuccess;
     }
-    return Service::Audio::ResultLibOpusInvalidState;
+    return *new_decoder;
 }
 
-Result OpusMultiStreamDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data, u64 input_data_size) {
+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 (avctx) {
-        AVPacket* avpkt = av_packet_alloc();
-        av_new_packet(avpkt, int(input_data_size));
-        std::memcpy(avpkt->data, reinterpret_cast<const u8*>(input_data), input_data_size);
-        avcodec_send_packet(avctx, avpkt);
 
-        AVFrame* frame = av_frame_alloc();
+    if (!state_valid) {
-        avcodec_receive_frame(avctx, frame);
+        return OPUS_INVALID_STATE;
-        std::memcpy(reinterpret_cast<u16*>(output_data), frame->data, output_data_size);
-        av_frame_free(&frame);
-        av_packet_free(&avpkt);
-
-        out_sample_count = frame->nb_samples;
-        return ResultSuccess;
     }
-    return Service::Audio::ResultLibOpusInvalidState;
+
+    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

src/audio_core/adsp/apps/opus/opus_multistream_decode_object.h

@@ -1,31 +1,39 @@
-// 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 "audio_core/adsp/apps/opus/opus_types.h"
+#include <opus_multistream.h>
-#include "common/common_types.h"
-#include "core/hle/result.h"
 
-struct AVCodec;
+#include "common/common_types.h"
-struct AVCodecContext;
 
 namespace AudioCore::ADSP::OpusDecoder {
+using LibOpusMSDecoder = ::OpusMSDecoder;
+static constexpr u32 DecodeMultiStreamObjectMagic = 0xDEADBEEF;
 
 class OpusMultiStreamDecodeObject {
 public:
     static u32 GetWorkBufferSize(u32 total_stream_count, u32 stereo_stream_count);
+    static OpusMultiStreamDecodeObject& Initialize(u64 buffer, u64 buffer2);
 
-    Result InitializeDecoder(u32 sample_rate, u32 total_stream_count, u32 channel_count, u32 stereo_stream_count, u8* mappings);
+    s32 InitializeDecoder(u32 sample_rate, u32 total_stream_count, u32 channel_count,
-    Result Shutdown();
+                          u32 stereo_stream_count, u8* mappings);
-    Result ResetDecoder();
+    s32 Shutdown();
-    Result Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data, u64 input_data_size);
+    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;
+    }
 
-    AVCodec const* codec = nullptr;
+private:
-    AVCodecContext* avctx = nullptr;
+    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

src/audio_core/adsp/apps/opus/opus_types.h

@@ -1,32 +0,0 @@
-// 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);
-
-}

src/audio_core/opus/hardware_opus.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,18 +6,39 @@
 #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_}
+    : system{system_}, opus_decoder{system.AudioCore().ADSP().OpusDecoder()} {
-    , opus_decoder{system.AudioCore().ADSP().OpusDecoder()}
-{
     opus_decoder.SetSharedMemory(shared_memory);
 }
 
@@ -71,7 +89,7 @@ Result HardwareOpus::InitializeDecodeObject(u32 sample_rate, u32 channel_count,
         R_THROW(ResultInvalidOpusDSPReturnCode);
     }
 
-    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
 }
 
 Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,
@@ -87,7 +105,7 @@ Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 chan
     shared_memory.host_send_data[4] = total_stream_count;
     shared_memory.host_send_data[5] = stereo_stream_count;
 
-    ASSERT(channel_count <= shared_memory.channel_mapping.size());
+    ASSERT(channel_count <= MaxChannels);
     std::memcpy(shared_memory.channel_mapping.data(), mappings, channel_count * sizeof(u8));
 
     opus_decoder.Send(ADSP::Direction::DSP,
@@ -99,7 +117,7 @@ Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 chan
         R_THROW(ResultInvalidOpusDSPReturnCode);
     }
 
-    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
 }
 
 Result HardwareOpus::ShutdownDecodeObject(void* buffer, u64 buffer_size) {
@@ -113,7 +131,7 @@ Result HardwareOpus::ShutdownDecodeObject(void* buffer, u64 buffer_size) {
                "Expected Opus shutdown code {}, got {}",
                ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK, msg);
 
-    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
 }
 
 Result HardwareOpus::ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size) {
@@ -128,7 +146,7 @@ Result HardwareOpus::ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_si
                "Expected Opus shutdown code {}, got {}",
                ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK, msg);
 
-    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
 }
 
 Result HardwareOpus::DecodeInterleaved(u32& out_sample_count, void* output_data,
@@ -152,12 +170,12 @@ Result HardwareOpus::DecodeInterleaved(u32& out_sample_count, void* output_data,
         R_THROW(ResultInvalidOpusDSPReturnCode);
     }
 
-    auto error_code = s32(shared_memory.dsp_return_data[0]);
+    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
-    if (error_code == ResultSuccess.raw) {
+    if (error_code == OPUS_OK) {
-        out_sample_count = u32(shared_memory.dsp_return_data[1]);
+        out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
         out_time_taken = 1000 * shared_memory.dsp_return_data[2];
     }
-    R_RETURN(Result(u32(error_code)));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
 }
 
 Result HardwareOpus::DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,
@@ -166,27 +184,29 @@ 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[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = u64(input_data);
+    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 const error_code = shared_memory.dsp_return_data[0];
+    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
-    if (error_code == ResultSuccess.raw) {
+    if (error_code == OPUS_OK) {
         out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
         out_time_taken = 1000 * shared_memory.dsp_return_data[2];
     }
-    R_RETURN(Result(u32(shared_memory.dsp_return_data[0])));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
 }
 
 Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {
@@ -197,7 +217,8 @@ 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();
@@ -211,7 +232,8 @@ 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();

src/audio_core/opus/hardware_opus.h

@@ -1,12 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
 #include <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"

src/common/settings.cpp

@@ -146,7 +146,7 @@ void LogSettings() {
 #undef LOG_PATH
 }
 
-bool getDebugKnobAt(u8 i) {
+bool GetDebugKnobAt(u8 i) {
     return (values.debug_knobs.GetValue() & (1 << (i & 0xF))) != 0;
 }
 

src/common/settings.h

@@ -904,7 +904,7 @@ struct Values {
                                            0,
                                            65535,
                                            "debug_knobs",
-                                           Category::Debugging,
+                                           Category::System,
                                            Specialization::Countable,
                                            true,
                                            true};

src/core/CMakeLists.txt

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

src/core/core.cpp

@@ -295,10 +295,6 @@ struct System::Impl {
     SystemResultStatus Load(System& system, Frontend::EmuWindow& emu_window, const std::string& filepath, Service::AM::FrontendAppletParameters& params) {
         InitializeKernel(system);
 
-        if (params.applet_type == Service::AM::AppletType::Application) {
-            current_application_filepath = filepath;
-        }
-
         const auto file = GetGameFileFromPath(virtual_filesystem, filepath);
 
         // Create the application process
@@ -334,7 +330,7 @@ struct System::Impl {
         LaunchTimestampCache::SaveLaunchTimestamp(params.program_id);
 
         // Make the process created be the application
-        kernel.SetApplicationProcess(process->GetHandle());
+        kernel.MakeApplicationProcess(process->GetHandle());
 
         // Set up the rest of the system.
         SystemResultStatus init_result{SetupForApplicationProcess(system, emu_window)};
@@ -471,7 +467,6 @@ struct System::Impl {
     Core::SpeedLimiter speed_limiter;
     ExecuteProgramCallback execute_program_callback;
     ExitCallback exit_callback;
-    ApplicationChangedCallback application_changed_callback;
 
     std::optional<Service::Services> services;
     std::optional<Core::Debugger> debugger;
@@ -493,8 +488,6 @@ struct System::Impl {
     std::array<u64, Core::Hardware::NUM_CPU_CORES> dynarmic_ticks{};
     std::array<u8, 0x20> build_id{};
 
-    std::string current_application_filepath;
-
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
     /// ContentProviderUnion instance
@@ -734,25 +727,7 @@ const Core::SpeedLimiter& System::SpeedLimiter() const {
 }
 
 u64 System::GetApplicationProcessProgramID() const {
-    const auto* const process = impl->kernel.ApplicationProcess();
+    return impl->kernel.ApplicationProcess()->GetProgramId();
-    return process != nullptr ? process->GetProgramId() : 0;
-}
-
-u64 System::GetProgramIdForProcessId(u64 process_id) const {
-    auto process = impl->kernel.GetProcessByProcessId(process_id);
-    return process.IsNull() ? 0 : process->GetProgramId();
-}
-
-u64 System::ResolveCallerProgramId(u64 process_id) const {
-    if (const auto program_id = this->GetProgramIdForProcessId(process_id); program_id != 0) {
-        return program_id;
-    }
-
-    const auto fallback = this->GetApplicationProcessProgramID();
-    LOG_WARNING(Core,
-                "Could not resolve caller process_id={}, falling back to application {:016X}",
-                process_id, fallback);
-    return fallback;
 }
 
 Loader::ResultStatus System::GetGameName(std::string& out) const {
@@ -935,10 +910,6 @@ void System::ExecuteProgram(std::size_t program_index) {
     }
 }
 
-const std::string& System::GetCurrentApplicationFilePath() const {
-    return impl->current_application_filepath;
-}
-
 /// @brief Gets a reference to the user channel stack.
 /// It is used to transfer data between programs.
 std::vector<std::vector<u8>>& System::GetUserChannel() {
@@ -990,18 +961,6 @@ void System::Exit() {
     }
 }
 
-void System::RegisterApplicationChangedCallback(ApplicationChangedCallback&& callback) {
-    impl->application_changed_callback = std::move(callback);
-}
-
-void System::NotifyApplicationChanged(u64 program_id) {
-    //LOG_DEBUG(Core, "Running application changed to {:016X}", program_id);
-
-    if (impl->application_changed_callback) {
-        impl->application_changed_callback(program_id);
-    }
-}
-
 void System::ApplySettings() {
     impl->RefreshTime(*this);
 

src/core/core.h

@@ -322,10 +322,6 @@ public:
 
     [[nodiscard]] u64 GetApplicationProcessProgramID() const;
 
-    [[nodiscard]] u64 GetProgramIdForProcessId(u64 process_id) const;
-
-    [[nodiscard]] u64 ResolveCallerProgramId(u64 process_id) const;
-
     /// Gets the name of the current game
     [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
 
@@ -426,7 +422,6 @@ public:
     void PushGeneralChannelData(std::vector<u8>&& data);
     bool TryPopGeneralChannel(std::vector<u8>& out_data);
     [[nodiscard]] Service::Event& GetGeneralChannelEvent();
-    [[nodiscard]] const std::string& GetCurrentApplicationFilePath() const;
 
     /// Type used for the frontend to designate a callback for System to exit the application.
     using ExitCallback = std::function<void()>;
@@ -440,10 +435,6 @@ public:
     /// Instructs the frontend to exit the application.
     void Exit();
 
-    using ApplicationChangedCallback = std::function<void(u64 program_id)>;
-    void RegisterApplicationChangedCallback(ApplicationChangedCallback&& callback);
-    void NotifyApplicationChanged(u64 program_id);
-
     /// Applies any changes to settings to this core instance.
     void ApplySettings();
 

src/core/file_sys/content_archive.cpp

@@ -29,7 +29,7 @@ static u8 MasterKeyIdForKeyGeneration(u8 key_generation) {
     return std::max<u8>(key_generation, 1) - 1;
 }
 
-NCA::NCA(VirtualFile file_, const NCA* base_nca, bool allow_missing_base)
+NCA::NCA(VirtualFile file_, const NCA* base_nca)
     : file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
     if (file == nullptr) {
         status = Loader::ResultStatus::ErrorNullFile;
@@ -110,7 +110,7 @@ NCA::NCA(VirtualFile file_, const NCA* base_nca, bool allow_missing_base)
         }
     }
 
-    if (is_update && base_nca == nullptr && !allow_missing_base) {
+    if (is_update && base_nca == nullptr) {
         status = Loader::ResultStatus::ErrorMissingBKTRBaseRomFS;
     } else {
         status = Loader::ResultStatus::Success;

src/core/file_sys/content_archive.h

@@ -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
 
@@ -66,7 +63,7 @@ inline bool IsDirectoryLogoPartition(const VirtualDir& pfs) {
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
 public:
-    explicit NCA(VirtualFile file, const NCA* base_nca = nullptr, bool allow_missing_base = false);
+    explicit NCA(VirtualFile file, const NCA* base_nca = nullptr);
     ~NCA() override;
 
     Loader::ResultStatus GetStatus() const;

src/core/file_sys/fssystem/fssystem_indirect_storage.cpp

@@ -4,7 +4,6 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging.h"
 #include "core/file_sys/errors.h"
 #include "core/file_sys/fssystem/fssystem_indirect_storage.h"
 
@@ -100,18 +99,6 @@ Result IndirectStorage::GetEntryList(Entry* out_entries, s32* out_entry_count, s
     R_SUCCEED();
 }
 
-void IndirectStorage::ReportMissingOriginal(s64 offset, s64 size) {
-    if (m_reported_missing_original) {
-        return;
-    }
-    m_reported_missing_original = true;
-
-    LOG_ERROR(Common_Filesystem,
-              "Patch storage requests {:#x} bytes at {:#x} from a base storage that is not "
-              "present; this data will read as garbage",
-              size, offset);
-}
-
 size_t IndirectStorage::Read(u8* buffer, size_t size, size_t offset) const {
     // Validate pre-conditions.
     ASSERT(this->IsInitialized());

src/core/file_sys/fssystem/fssystem_indirect_storage.h

@@ -85,9 +85,6 @@ public:
     void SetStorage(s32 idx, VirtualFile storage) {
         ASSERT(0 <= idx && idx < StorageCount);
         m_data_storage[idx] = storage;
-        if (idx == 0) {
-            m_original_missing = storage == nullptr || storage->GetSize() == 0;
-        }
     }
 
     template <typename T>
@@ -133,9 +130,6 @@ protected:
 
     template <bool ContinuousCheck, bool RangeCheck, typename F>
     Result OperatePerEntry(s64 offset, s64 size, F func);
-    // Launching another game makes the original storage inaccessable.
-    // This is a helper for multi-nca games.
-    void ReportMissingOriginal(s64 offset, s64 size);
 
 private:
     struct ContinuousReadingEntry {
@@ -160,8 +154,6 @@ private:
 private:
     mutable BucketTree m_table;
     std::array<VirtualFile, StorageCount> m_data_storage;
-    bool m_original_missing{false};
-    bool m_reported_missing_original{false};
 };
 
 template <bool ContinuousCheck, bool RangeCheck, typename F>
@@ -280,10 +272,6 @@ Result IndirectStorage::OperatePerEntry(s64 offset, s64 size, F func) {
         if (needs_operate) {
             const auto cur_entry_phys_offset = cur_entry.GetPhysicalOffset();
 
-            if (cur_entry.storage_index == 0 && m_original_missing) {
-                this->ReportMissingOriginal(cur_offset, cur_size);
-            }
-
             if constexpr (RangeCheck) {
                 // Get the current data storage's size.
                 s64 cur_data_storage_size = m_data_storage[cur_entry.storage_index]->GetSize();

src/core/file_sys/nca_metadata.h

@@ -48,11 +48,11 @@ struct ContentRecord {
     std::array<u8, 0x10> nca_id;
     std::array<u8, 0x6> size;
     ContentRecordType type;
-    u8 id_offset;
+    INSERT_PADDING_BYTES(1);
 };
 static_assert(sizeof(ContentRecord) == 0x38, "ContentRecord has incorrect size.");
 
-constexpr ContentRecord EMPTY_META_CONTENT_RECORD{{}, {}, {}, ContentRecordType::Meta, 0};
+constexpr ContentRecord EMPTY_META_CONTENT_RECORD{{}, {}, {}, ContentRecordType::Meta, {}};
 
 struct MetaRecord {
     u64_le title_id;

src/core/file_sys/registered_cache.cpp

@@ -567,45 +567,20 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
 }
 
 static std::optional<NcaID> CheckMapForContentRecord(const ankerl::unordered_dense::map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
-    auto cmnt_iter = map.find(title_id);
+    const auto cmnt_iter = map.find(title_id);
-    u8 id_offset = 0;
-
     if (cmnt_iter == map.cend()) {
-        const auto program_index = title_id & AOC_TITLE_ID_MASK;
+        return std::nullopt;
-        if (program_index == 0) {
-            return std::nullopt;
-        }
-
-        cmnt_iter = map.find(title_id & ~AOC_TITLE_ID_MASK);
-        if (cmnt_iter == map.cend()) {
-            return std::nullopt;
-        }
-
-        id_offset = static_cast<u8>(program_index);
     }
 
     const auto& cnmt = cmnt_iter->second;
     const auto& content_records = cnmt.GetContentRecords();
     const auto iter = std::find_if(content_records.cbegin(), content_records.cend(),
-                                   [type, id_offset](const ContentRecord& rec) {
+                                   [type](const ContentRecord& rec) { return rec.type == type; });
-                                       return rec.type == type && rec.id_offset == id_offset;
+    if (iter == content_records.cend()) {
-                                   });
-    if (iter != content_records.cend()) {
-        return std::make_optional(iter->nca_id);
-    }
-
-    if (id_offset != 0) {
         return std::nullopt;
     }
 
-    const auto fallback_iter =
+    return std::make_optional(iter->nca_id);
-        std::find_if(content_records.cbegin(), content_records.cend(),
-                     [type](const ContentRecord& rec) { return rec.type == type; });
-    if (fallback_iter == content_records.cend()) {
-        return std::nullopt;
-    }
-
-    return std::make_optional(fallback_iter->nca_id);
 }
 
 std::optional<NcaID> RegisteredCache::GetNcaIDFromMetadata(u64 title_id,

src/core/file_sys/submission_package.cpp

@@ -12,7 +12,6 @@
 #include "common/hex_util.h"
 #include "common/logging.h"
 #include "core/crypto/key_manager.h"
-#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
@@ -66,12 +65,10 @@ u64 NSP::GetProgramTitleID() const {
     }
 
     auto program_id = expected_program_id;
-    if (program_id == 0 && !program_status.empty()) {
+    if (program_id == 0) {
-        program_id = std::min_element(program_status.cbegin(), program_status.cend(),
+        if (!program_status.empty()) {
-                                      [](const auto& lhs, const auto& rhs) {
+            program_id = program_status.begin()->first;
-                                          return lhs.first < rhs.first;
+        }
-                                      })
-                         ->first;
     }
 
     program_id = program_id + program_index;
@@ -276,7 +273,8 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                     // If the last 3 hexadecimal digits of the NCA's TitleID is between 0x1 and
                     // 0x7FF, this is a multi-program update NCA. Otherwise, this is a regular
                     // update NCA.
-                    if ((next_nca->GetTitleId() & AOC_TITLE_ID_MASK) != 0) {
+                    if ((next_nca->GetTitleId() & 0x7FF) != 0 &&
+                        (next_nca->GetTitleId() & 0x800) == 0) {
                         ncas[next_nca->GetTitleId()][{cnmt.GetType(), rec.type}] =
                             std::move(next_nca);
                     } else {

src/core/hle/kernel/kernel.cpp

@@ -349,18 +349,9 @@ struct KernelCore::Impl {
         object_name_global_data.emplace(kernel);
     }
 
-    void SetApplicationProcess(KernelCore& kernel, KProcess* process) {
+    void MakeApplicationProcess(KernelCore& kernel, KProcess* process) {
-        if (application_process == process)
-            return;
-
-        KProcess* const previous = application_process;
         application_process = process;
-
+        application_process->Open(kernel);
-        if (application_process != nullptr)
-            application_process->Open(kernel);
-
-        if (previous != nullptr)
-            previous->Close(kernel);
     }
 
     /// Sets the host thread ID for the caller.
@@ -888,8 +879,8 @@ void KernelCore::RemoveProcess(KProcess* process) {
     }
 }
 
-void KernelCore::SetApplicationProcess(KProcess* process) {
+void KernelCore::MakeApplicationProcess(KProcess* process) {
-    impl->SetApplicationProcess(*this, process);
+    impl->MakeApplicationProcess(*this, process);
 }
 
 KProcess* KernelCore::ApplicationProcess() {
@@ -900,14 +891,6 @@ const KProcess* KernelCore::ApplicationProcess() const {
     return impl->application_process;
 }
 
-KScopedAutoObject<KProcess> KernelCore::GetProcessByProcessId(u64 process_id) {
-    std::scoped_lock lk{impl->process_list_lock};
-    for (auto* const process : impl->process_list)
-        if (process != nullptr && process->GetProcessId() == process_id)
-            return {*this, process};
-    return {*this, nullptr};
-}
-
 std::list<KScopedAutoObject<KProcess>> KernelCore::GetProcessList() {
     std::list<KScopedAutoObject<KProcess>> processes;
     std::scoped_lock lk{impl->process_list_lock};

src/core/hle/kernel/kernel.h

@@ -124,8 +124,8 @@ public:
     void AppendNewProcess(KProcess* process);
     void RemoveProcess(KProcess* process);
 
-    /// Makes the given process the current application process.
+    /// Makes the given process the new application process.
-    void SetApplicationProcess(KProcess* process);
+    void MakeApplicationProcess(KProcess* process);
 
     /// Retrieves a pointer to the application process.
     KProcess* ApplicationProcess();
@@ -133,9 +133,6 @@ public:
     /// Retrieves a const pointer to the application process.
     const KProcess* ApplicationProcess() const;
 
-    /// Retrieves the process with the given process ID, or a null object.
-    KScopedAutoObject<KProcess> GetProcessByProcessId(u64 process_id);
-
     /// Retrieves the list of processes.
     std::list<KScopedAutoObject<KProcess>> GetProcessList();
 

src/core/hle/service/am/am_results.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -13,7 +10,6 @@ namespace Service::AM {
 constexpr Result ResultNoDataInChannel{ErrorModule::AM, 2};
 constexpr Result ResultNoMessages{ErrorModule::AM, 3};
 constexpr Result ResultLibraryAppletTerminated{ErrorModule::AM, 22};
-constexpr Result ResultApplicationRecordNotFound{ErrorModule::AM, 37};
 constexpr Result ResultInvalidOffset{ErrorModule::AM, 503};
 constexpr Result ResultInvalidStorageType{ErrorModule::AM, 511};
 constexpr Result ResultFatalSectionCountImbalance{ErrorModule::AM, 512};

src/core/hle/service/am/am_types.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -201,14 +201,6 @@ enum class ProgramSpecifyKind : u32 {
     RestartProgram = 2,
 };
 
-// Maufeat: Use enums for zindex instead of using random zindex numbers
-enum AppletZIndex : s32 {
-    Background = 0,
-    Foreground = 1,
-    ForegroundVisible = 2,
-    Overlay = 3,
-};
-
 struct CommonArguments {
     CommonArgumentVersion arguments_version;
     CommonArgumentSize size;

src/core/hle/service/am/applet.cpp

@@ -56,22 +56,22 @@ void Applet::UpdateSuspensionStateLocked(bool force_message) {
     }
 }
 
-void Applet::SetInteractibleLocked(bool pad_interactible, bool touch_interactible) {
+void Applet::SetInteractibleLocked(bool interactible) {
-    if (is_pad_interactible == pad_interactible && is_touch_interactible == touch_interactible) {
+    if (is_interactible == interactible) {
         return;
     }
 
-    is_pad_interactible = pad_interactible;
+    is_interactible = interactible;
-    is_touch_interactible = touch_interactible;
 
     const bool exit_requested = lifecycle_manager.GetExitRequested();
-    const bool pad_enabled = pad_interactible && !exit_requested;
+    const bool input_enabled = interactible && !exit_requested;
-    const bool touch_enabled = touch_interactible && !exit_requested;
 
-    LOG_DEBUG(Service_AM, "applet={} pad={} touch={} exit_requested={}",
+    if (applet_id == AppletId::OverlayDisplay || applet_id == AppletId::Application) {
-              static_cast<u32>(applet_id), pad_enabled, touch_enabled, exit_requested);
+        LOG_DEBUG(Service_AM, "called, applet={} interactible={} exit_requested={} input_enabled={} overlay_in_foreground={}",
+                 static_cast<u32>(applet_id), interactible, exit_requested, input_enabled, overlay_in_foreground);
+    }
 
-    hid_registration.EnableAppletToGetInput(pad_enabled, touch_enabled);
+    hid_registration.EnableAppletToGetInput(input_enabled);
 }
 
 void Applet::OnProcessTerminatedLocked() {

src/core/hle/service/am/applet.h

@@ -125,11 +125,9 @@ struct Applet {
     bool album_image_taken_notification_enabled{};
     bool record_volume_muted{};
     bool is_activity_runnable{};
-    bool is_pad_interactible{true};
+    bool is_interactible{true};
-    bool is_touch_interactible{true};
     bool window_visible{true};
-    bool overlay_watching_short_home_button{false};
+    bool overlay_in_foreground{false};
-    bool overlay_handling_touch_input{false};
 
     // Events
     Event overlay_event;
@@ -150,7 +148,7 @@ struct Applet {
 
     // Process state management
     void UpdateSuspensionStateLocked(bool force_message);
-    void SetInteractibleLocked(bool pad_interactible, bool touch_interactible);
+    void SetInteractibleLocked(bool interactible);
     void OnProcessTerminatedLocked();
 };
 

src/core/hle/service/am/display_layer_manager.cpp

@@ -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 2024 yuzu Emulator Project
@@ -6,7 +6,6 @@
 
 #include "core/core.h"
 #include "core/hle/service/am/display_layer_manager.h"
-#include "core/hle/service/nvnflinger/hwc_layer.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/vi/application_display_service.h"
 #include "core/hle/service/vi/container.h"
@@ -34,7 +33,6 @@ void DisplayLayerManager::Initialize(Core::System& system, Kernel::KProcess* pro
     m_system_shared_buffer_id = 0;
     m_system_shared_layer_id = 0;
     m_applet_id = applet_id;
-    m_library_applet_mode = mode;
     m_buffer_sharing_enabled = false;
     m_blending_enabled = mode == LibraryAppletMode::PartialForeground ||
                          mode == LibraryAppletMode::PartialForegroundIndirectDisplay;
@@ -74,16 +72,14 @@ Result DisplayLayerManager::CreateManagedDisplayLayer(u64* out_layer_id) {
         out_layer_id, 0, display_id, Service::AppletResourceUserId{m_process->GetProcessId()}));
 
     m_manager_display_service->SetLayerVisibility(m_visible, *out_layer_id);
-    (void)m_display_service->GetContainer()->SetLayerStackMask(*out_layer_id,
-                                                              this->GetLayerStackMask());
 
     if (m_applet_id != AppletId::Application) {
         (void)m_manager_display_service->SetLayerBlending(m_blending_enabled, *out_layer_id);
         if (m_applet_id == AppletId::OverlayDisplay) {
-            (void)m_manager_display_service->SetLayerZIndex(Overlay, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(-1, *out_layer_id);
             (void)m_display_service->GetContainer()->SetLayerIsOverlay(*out_layer_id, true);
         } else {
-            (void)m_manager_display_service->SetLayerZIndex(Foreground, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(1, *out_layer_id);
         }
     }
 
@@ -126,12 +122,10 @@ Result DisplayLayerManager::IsSystemBufferSharingEnabled() {
 
     // Ensure the overlay layer is visible
     m_manager_display_service->SetLayerVisibility(m_visible, m_system_shared_layer_id);
-    (void)m_display_service->GetContainer()->SetLayerStackMask(m_system_shared_layer_id,
-                                                              this->GetLayerStackMask());
     m_manager_display_service->SetLayerBlending(m_blending_enabled, m_system_shared_layer_id);
-    s32 initial_z = Foreground;
+    s32 initial_z = 1;
     if (m_applet_id == AppletId::OverlayDisplay) {
-        initial_z = Overlay;
+        initial_z = -1;
         (void)m_display_service->GetContainer()->SetLayerIsOverlay(m_system_shared_layer_id, true);
     }
     m_manager_display_service->SetLayerZIndex(initial_z, m_system_shared_layer_id);
@@ -148,36 +142,6 @@ Result DisplayLayerManager::GetSystemSharedLayerHandle(u64* out_system_shared_bu
     R_SUCCEED();
 }
 
-u32 DisplayLayerManager::GetLayerStackMask() const {
-    using Nvnflinger::LayerStackBit;
-    using Nvnflinger::LayerStackId;
-
-    constexpr u32 Displayed = LayerStackBit(LayerStackId::Default);
-    constexpr u32 Screenshot = LayerStackBit(LayerStackId::Screenshot);
-    constexpr u32 Recording = LayerStackBit(LayerStackId::Recording);
-    constexpr u32 LastFrame = LayerStackBit(LayerStackId::LastFrame);
-    constexpr u32 Debug = LayerStackBit(LayerStackId::ApplicationForDebug);
-
-    switch (m_applet_id) {
-        case AppletId::Application:
-            return Displayed | Screenshot | Recording | LastFrame | Debug;
-        case AppletId::OverlayDisplay:
-            return Displayed;
-        case AppletId::QLaunch:
-            return Displayed;
-        default:
-            break;
-    }
-
-    switch (m_library_applet_mode) {
-    case LibraryAppletMode::AllForeground:
-    case LibraryAppletMode::AllForegroundInitiallyHidden:
-        return Displayed | Screenshot | LastFrame;
-    default:
-        return Displayed | Screenshot;
-    }
-}
-
 void DisplayLayerManager::SetWindowVisibility(bool visible) {
     if (m_visible == visible) {
         return;
@@ -221,17 +185,10 @@ void DisplayLayerManager::SetOverlayZIndex(s32 z_index) {
 }
 
 Result DisplayLayerManager::WriteAppletCaptureBuffer(bool* out_was_written,
-                                                     s32* out_fbshare_layer_index,
+                                                     s32* out_fbshare_layer_index) {
-                                                     VI::CaptureKind kind) {
     R_UNLESS(m_buffer_sharing_enabled, VI::ResultPermissionDenied);
     R_RETURN(m_display_service->GetContainer()->GetSharedBufferManager()->WriteAppletCaptureBuffer(
-        out_was_written, out_fbshare_layer_index, kind));
+        out_was_written, out_fbshare_layer_index));
-}
-
-Result DisplayLayerManager::ClearAppletCaptureBuffer(s32 fbshare_layer_index, u32 color) {
-    R_UNLESS(m_buffer_sharing_enabled, VI::ResultPermissionDenied);
-    R_RETURN(m_display_service->GetContainer()->GetSharedBufferManager()->ClearAppletCaptureBuffer(
-        fbshare_layer_index, color));
 }
 
 } // namespace Service::AM

src/core/hle/service/am/display_layer_manager.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -23,7 +23,6 @@ class KProcess;
 namespace Service::VI {
 class IApplicationDisplayService;
 class IManagerDisplayService;
-enum class CaptureKind : u32;
 } // namespace Service::VI
 
 namespace Service::AM {
@@ -49,13 +48,9 @@ public:
 
     void SetOverlayZIndex(s32 z_index);
 
-    Result WriteAppletCaptureBuffer(bool* out_was_written, s32* out_fbshare_layer_index,
+    Result WriteAppletCaptureBuffer(bool* out_was_written, s32* out_fbshare_layer_index);
-                                    VI::CaptureKind kind);
-    Result ClearAppletCaptureBuffer(s32 fbshare_layer_index, u32 color);
 
 private:
-    u32 GetLayerStackMask() const;
-
     Kernel::KProcess* m_process{};
     std::shared_ptr<VI::IApplicationDisplayService> m_display_service{};
     std::shared_ptr<VI::IManagerDisplayService> m_manager_display_service{};
@@ -64,7 +59,6 @@ private:
     u64 m_system_shared_buffer_id{};
     u64 m_system_shared_layer_id{};
     AppletId m_applet_id{};
-    LibraryAppletMode m_library_applet_mode{};
     bool m_buffer_sharing_enabled{};
     bool m_blending_enabled{};
     bool m_visible{true};

src/core/hle/service/am/hid_registration.cpp

@@ -36,17 +36,12 @@ HidRegistration::~HidRegistration() {
     }
 }
 
-void HidRegistration::EnableAppletToGetInput(bool enable_pad, bool enable_touch) {
+void HidRegistration::EnableAppletToGetInput(bool enable) {
-    if (!m_process.IsInitialized())
+    if (m_process.IsInitialized()) {
-        return;
+        m_hid_server->GetResourceManager()->SetAruidValidForVibration(m_process.GetProcessId(),
-
+                                                                      enable);
-    const auto resource_manager = m_hid_server->GetResourceManager();
+        m_hid_server->GetResourceManager()->EnableInput(m_process.GetProcessId(), enable);
-    const u64 aruid = m_process.GetProcessId();
+    }
-
-    resource_manager->EnablePadInput(aruid, enable_pad);
-    resource_manager->EnableTouchScreen(aruid, enable_touch);
-
-    resource_manager->SetAruidValidForVibration(aruid, enable_pad);
 }
 
 } // namespace Service::AM

src/core/hle/service/am/hid_registration.h

@@ -28,7 +28,7 @@ public:
     ~HidRegistration();
 
     void RegisterCurrentProcess();
-    void EnableAppletToGetInput(bool enable_pad, bool enable_touch);
+    void EnableAppletToGetInput(bool enable);
 
 private:
     Process& m_process;

src/core/hle/service/am/service/applet_common_functions.cpp

@@ -4,8 +4,6 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/core.h"
-#include "core/file_sys/common_funcs.h"
 #include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/service/applet_common_functions.h"
 #include "core/hle/service/cmif_serialization.h"
@@ -80,7 +78,7 @@ Result IAppletCommonFunctions::SetCpuBoostRequestPriority(s32 priority) {
 
 Result IAppletCommonFunctions::GetCurrentApplicationId(Out<u64> out_application_id) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_application_id = FileSys::GetBaseTitleID(system.GetApplicationProcessProgramID());
+    *out_application_id = system.GetApplicationProcessProgramID() & ~0xFFFULL;
     R_SUCCEED();
 }
 

src/core/hle/service/am/service/application_functions.cpp

@@ -6,10 +6,8 @@
 
 #include <openssl/evp.h>
 
-#include "common/hex_util.h"
 #include "common/settings.h"
 #include "common/uuid.h"
-#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
@@ -30,27 +28,6 @@
 
 namespace Service::AM {
 
-namespace {
-
-FileSys::PatchManager::Metadata GetApplicationMetadata(Core::System& system, u64 program_id) {
-    auto metadata = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, program_id);
-    if (metadata.first != nullptr) {
-        return metadata;
-    }
-
-    const auto application_id = FileSys::GetBaseTitleID(program_id);
-    if (application_id == program_id) {
-        return metadata;
-    }
-
-    LOG_DEBUG(Service_AM,
-              "no metadata for program_id={:016X}, falling back to application_id={:016X}",
-              program_id, application_id);
-    return FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, application_id);
-}
-
-} // Anonymous namespace
-
 IApplicationFunctions::IApplicationFunctions(Core::System& system_, std::shared_ptr<Applet> applet)
     : ServiceFramework{system_, "IApplicationFunctions"}, m_applet{std::move(applet)} {
     // clang-format off
@@ -179,7 +156,7 @@ Result IApplicationFunctions::GetDesiredLanguage(Out<u64> out_language_code) {
     // Default to 0 (all languages supported)
     u32 supported_languages = 0;
 
-    const auto res = GetApplicationMetadata(system, m_applet->program_id);
+    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
     if (res.first != nullptr) {
         supported_languages = res.first->GetSupportedLanguages();
     }
@@ -217,7 +194,7 @@ Result IApplicationFunctions::SetTerminateResult(Result terminate_result) {
 Result IApplicationFunctions::GetDisplayVersion(Out<DisplayVersion> out_display_version) {
     LOG_DEBUG(Service_AM, "called");
 
-    const auto res = GetApplicationMetadata(system, m_applet->program_id);
+    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
     if (res.first != nullptr) {
         const auto& version = res.first->GetVersionString();
         std::memcpy(out_display_version->string.data(), version.data(),
@@ -454,21 +431,15 @@ Result IApplicationFunctions::ExecuteProgram(ProgramSpecifyKind kind, u64 value)
 
 // https://switchbrew.org/wiki/Applet_Manager_services#CreateApplicationAndRequestToStart
 Result IApplicationFunctions::CreateApplicationAndRequestToStart(u64 application_id) {
-    LOG_INFO(Service_AM, "called, application_id={:016X} current_program_id={:016X}", application_id, m_applet->program_id);
+    LOG_INFO(Service_AM, "called, application_id={:016X}", application_id);
 
-    if (application_id == 0 ||
+    // If application_id is 0, relaunch the current application
-        FileSys::GetBaseTitleID(application_id) == FileSys::GetBaseTitleID(m_applet->program_id)) {
+    const u64 target_application_id =
-        const auto program_index = application_id == 0
+        (application_id == 0) ? m_applet->program_id : application_id;
-                                       ? 0
-                                       : application_id - FileSys::GetBaseTitleID(application_id);
 
-        system.GetUserChannel() = m_applet->user_channel_launch_parameter;
+    system.GetUserChannel() = m_applet->user_channel_launch_parameter;
-        system.ExecuteProgram(program_index);
+    system.ExecuteProgram(target_application_id);
-        R_SUCCEED();
+    R_SUCCEED();
-    }
-
-    LOG_ERROR(Service_AM, "Launching a different application ({:016X}) is not implemented!", application_id);
-    R_THROW(ResultUnknown);
 }
 
 Result IApplicationFunctions::ClearUserChannel() {

src/core/hle/service/am/service/display_controller.cpp

@@ -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 2024 yuzu Emulator Project
@@ -8,7 +8,6 @@
 #include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/service/display_controller.h"
 #include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/vi/shared_buffer_manager.h"
 
 namespace Service::AM {
 
@@ -72,16 +71,16 @@ Result IDisplayController::TakeScreenShotOfOwnLayer(bool unknown0, s32 fbshare_l
 }
 
 Result IDisplayController::ClearCaptureBuffer(bool unknown0, s32 fbshare_layer_index, u32 color) {
-    LOG_DEBUG(Service_AM, "called, unknown0={} fbshare_layer_index={} color={:#x}", unknown0,
+    LOG_WARNING(Service_AM, "(STUBBED) called, unknown0={} fbshare_layer_index={} color={:#x}",
-              fbshare_layer_index, color);
+                unknown0, fbshare_layer_index, color);
-    R_RETURN(applet->display_layer_manager.ClearAppletCaptureBuffer(fbshare_layer_index, color));
+    R_SUCCEED();
 }
 
 Result IDisplayController::AcquireLastForegroundCaptureSharedBuffer(
     Out<bool> out_was_written, Out<s32> out_fbshare_layer_index) {
-    LOG_DEBUG(Service_AM, "called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
-    R_RETURN(applet->display_layer_manager.WriteAppletCaptureBuffer(
+    R_RETURN(applet->display_layer_manager.WriteAppletCaptureBuffer(out_was_written,
-        out_was_written, out_fbshare_layer_index, VI::CaptureKind::LastForeground));
+                                                                    out_fbshare_layer_index));
 }
 
 Result IDisplayController::ReleaseLastForegroundCaptureSharedBuffer() {
@@ -91,9 +90,9 @@ Result IDisplayController::ReleaseLastForegroundCaptureSharedBuffer() {
 
 Result IDisplayController::AcquireCallerAppletCaptureSharedBuffer(
     Out<bool> out_was_written, Out<s32> out_fbshare_layer_index) {
-    LOG_DEBUG(Service_AM, "called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
-    R_RETURN(applet->display_layer_manager.WriteAppletCaptureBuffer(
+    R_RETURN(applet->display_layer_manager.WriteAppletCaptureBuffer(out_was_written,
-        out_was_written, out_fbshare_layer_index, VI::CaptureKind::CallerApplet));
+                                                                    out_fbshare_layer_index));
 }
 
 Result IDisplayController::ReleaseCallerAppletCaptureSharedBuffer() {
@@ -103,9 +102,9 @@ Result IDisplayController::ReleaseCallerAppletCaptureSharedBuffer() {
 
 Result IDisplayController::AcquireLastApplicationCaptureSharedBuffer(
     Out<bool> out_was_written, Out<s32> out_fbshare_layer_index) {
-    LOG_DEBUG(Service_AM, "called");
+    LOG_WARNING(Service_AM, "(STUBBED) called");
-    R_RETURN(applet->display_layer_manager.WriteAppletCaptureBuffer(
+    R_RETURN(applet->display_layer_manager.WriteAppletCaptureBuffer(out_was_written,
-        out_was_written, out_fbshare_layer_index, VI::CaptureKind::LastApplication));
+                                                                    out_fbshare_layer_index));
 }
 
 Result IDisplayController::ReleaseLastApplicationCaptureSharedBuffer() {

src/core/hle/service/am/service/overlay_functions.cpp

@@ -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
 
 #include "core/hle/service/am/applet.h"
@@ -22,7 +22,7 @@ namespace Service::AM {
         {10, nullptr, "StartShutdownSequenceForOverlay"},
         {11, nullptr, "StartRebootSequenceForOverlay"},
         {20, D<&IOverlayFunctions::SetHandlingHomeButtonShortPressedEnabled>, "SetHandlingHomeButtonShortPressedEnabled"},
-        {21, D<&IOverlayFunctions::SetHandlingTouchScreenInputEnabled>, "SetHandlingTouchScreenInputEnabled"},
+        {21, nullptr, "SetHandlingTouchScreenInputEnabled"},
         {30, nullptr, "SetHealthWarningShowingState"},
         {31, D<&IOverlayFunctions::IsHealthWarningRequired>, "IsHealthWarningRequired"},
         {40, nullptr, "GetApplicationNintendoLogo"},
@@ -43,12 +43,10 @@ namespace Service::AM {
     Result IOverlayFunctions::BeginToWatchShortHomeButtonMessage() {
         LOG_DEBUG(Service_AM, "called");
 
-        {
+        m_applet->overlay_in_foreground = true;
-            std::scoped_lock lk{m_applet->lock};
+        m_applet->home_button_short_pressed_blocked = false;
-            m_applet->overlay_watching_short_home_button = true;
-        }
 
-        if (auto* window_system = system.GetAppletManager().GetWindowSystem()) {
+        if (auto *window_system = system.GetAppletManager().GetWindowSystem()) {
             window_system->RequestUpdate();
         }
 
@@ -58,26 +56,16 @@ namespace Service::AM {
     Result IOverlayFunctions::EndToWatchShortHomeButtonMessage() {
         LOG_DEBUG(Service_AM, "called");
 
-        {
+        m_applet->overlay_in_foreground = false;
-            std::scoped_lock lk{m_applet->lock};
+        m_applet->home_button_short_pressed_blocked = false;
-            m_applet->overlay_watching_short_home_button = false;
-        }
 
-        if (auto* window_system = system.GetAppletManager().GetWindowSystem()) {
+        if (auto *window_system = system.GetAppletManager().GetWindowSystem()) {
             window_system->RequestUpdate();
         }
 
         R_SUCCEED();
     }
 
-    Result IOverlayFunctions::SetHandlingTouchScreenInputEnabled(bool enabled) {
-        LOG_DEBUG(Service_AM, "called, enabled={}", enabled);
-
-        std::scoped_lock lk{m_applet->lock};
-        m_applet->overlay_handling_touch_input = enabled;
-        R_SUCCEED();
-    }
-
     Result IOverlayFunctions::GetApplicationIdForLogo(Out<u64> out_application_id) {
         LOG_DEBUG(Service_AM, "called");
 

src/core/hle/service/am/service/overlay_functions.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #pragma once
@@ -20,7 +20,6 @@ namespace Service::AM {
         Result SetAutoSleepTimeAndDimmingTimeEnabled(bool enabled);
         Result IsHealthWarningRequired(Out<bool> is_required);
         Result SetHandlingHomeButtonShortPressedEnabled(bool enabled);
-        Result SetHandlingTouchScreenInputEnabled(bool enabled);
         Result Unknown70();
 
     private:

src/core/hle/service/am/window_system.cpp

@@ -4,11 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <utility>
-
-#include "common/settings.h"
 #include "core/core.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/service/am/am_results.h"
 #include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/applet_manager.h"
@@ -36,82 +32,46 @@ void WindowSystem::RequestUpdate() {
 }
 
 void WindowSystem::Update() {
-    {
+    std::scoped_lock lk{m_lock};
-        std::scoped_lock lk{m_lock};
 
-        LOG_DEBUG(Service_AM, "called, home_menu={} application={} overlay={}",
+    LOG_DEBUG(Service_AM, "called, home_menu={} application={} overlay={}",
-                  m_home_menu != nullptr, m_application != nullptr, m_overlay_display != nullptr);
+              m_home_menu != nullptr, m_application != nullptr, m_overlay_display != nullptr);
 
-        // Loop through all applets and remove terminated applets.
+    // Loop through all applets and remove terminated applets.
-        this->PruneTerminatedAppletsLocked();
+    this->PruneTerminatedAppletsLocked();
 
-        // If the home menu is being locked into the foreground, handle that.
+    // If the home menu is being locked into the foreground, handle that.
-        if (!this->LockHomeMenuIntoForegroundLocked()) {
+    if (this->LockHomeMenuIntoForegroundLocked()) {
-            const bool overlay_takes_input = this->DoesOverlayTakeInputLocked();
+        return;
-
-            this->UpdateAppletStateLocked(m_overlay_display, true, overlay_takes_input);
-            this->UpdateAppletStateLocked(m_home_menu, m_foreground_requested_applet == m_home_menu, overlay_takes_input);
-            this->UpdateAppletStateLocked(m_application, m_foreground_requested_applet == m_application, overlay_takes_input);
-        }
     }
 
-    this->NotifyApplicationChangedIfNeeded();
+    bool overlay_blocks_input = false;
+    if (m_overlay_display) {
+        std::scoped_lock lk_overlay{m_overlay_display->lock};
+        overlay_blocks_input = m_overlay_display->overlay_in_foreground;
+    }
+
+    // Recursively update each applet root.
+    this->UpdateAppletStateLocked(m_home_menu, m_foreground_requested_applet == m_home_menu, overlay_blocks_input);
+    this->UpdateAppletStateLocked(m_application, m_foreground_requested_applet == m_application, overlay_blocks_input);
+    this->UpdateAppletStateLocked(m_overlay_display, true, false); // overlay is always updated, never blocked
 }
 
 void WindowSystem::TrackApplet(std::shared_ptr<Applet> applet, bool is_application) {
-    {
+    std::scoped_lock lk{m_lock};
-        std::scoped_lock lk{m_lock};
 
-        if (applet->applet_id == AppletId::QLaunch) {
+    if (applet->applet_id == AppletId::QLaunch) {
-            ASSERT(m_home_menu == nullptr);
+        ASSERT(m_home_menu == nullptr);
-            m_home_menu = applet.get();
+        m_home_menu = applet.get();
-        } else if (applet->applet_id == AppletId::OverlayDisplay) {
+    } else if (applet->applet_id == AppletId::OverlayDisplay) {
-            m_overlay_display = applet.get();
+        m_overlay_display = applet.get();
-        } else if (is_application) {
+    } else if (is_application) {
-            ASSERT(m_application == nullptr);
+        ASSERT(m_application == nullptr);
-            m_application = applet.get();
+        m_application = applet.get();
-        }
-
-        this->UpdateCurrentApplicationLocked();
-
-        m_event_observer->TrackAppletProcess(*applet);
-        m_applets.emplace(applet->aruid.pid, std::move(applet));
     }
 
-    this->NotifyApplicationChangedIfNeeded();
+    m_event_observer->TrackAppletProcess(*applet);
-}
+    m_applets.emplace(applet->aruid.pid, std::move(applet));
-
-void WindowSystem::UpdateCurrentApplicationLocked() {
-    const Applet* const candidate = m_application != nullptr ? m_application : m_home_menu;
-    if (candidate == nullptr) {
-        return;
-    }
-
-    auto* const process = candidate->process->GetHandle();
-    if (process == nullptr || process == m_system.Kernel().ApplicationProcess()) {
-        return;
-    }
-
-    LOG_INFO(Service_AM, "Current application is now {:016X}", candidate->program_id);
-
-    m_system.Kernel().SetApplicationProcess(process);
-    Settings::SetCurrentProgramID(candidate->program_id);
-
-    m_pending_application_notification = candidate->program_id;
-}
-
-void WindowSystem::NotifyApplicationChangedIfNeeded() {
-    std::optional<u64> program_id;
-    {
-        std::scoped_lock lk{m_lock};
-        program_id = std::exchange(m_pending_application_notification, std::nullopt);
-    }
-
-    if (!program_id.has_value()) {
-        return;
-    }
-
-    m_system.NotifyApplicationChanged(*program_id);
 }
 
 std::shared_ptr<Applet> WindowSystem::GetByAppletResourceUserId(u64 aruid) {
@@ -209,40 +169,18 @@ void WindowSystem::OnExitRequested() {
 }
 
 void WindowSystem::SendButtonAppletMessageLocked(AppletMessage message) {
-    const auto is_blocked = [message](const Applet& applet) {
+    if (m_home_menu) {
-        if (message == AppletMessage::DetectShortPressingHomeButton &&
+        std::scoped_lock lk_home{m_home_menu->lock};
-            applet.applet_id == AppletId::OverlayDisplay &&
+        m_home_menu->lifecycle_manager.PushUnorderedMessage(m_system.Kernel(), message);
-            !applet.overlay_watching_short_home_button) {
+    }
-            return true;
+    if (m_overlay_display) {
-        }
+        std::scoped_lock lk_overlay{m_overlay_display->lock};
-
+        m_overlay_display->lifecycle_manager.PushUnorderedMessage(m_system.Kernel(), message);
-        switch (message) {
+    }
-        case AppletMessage::DetectShortPressingHomeButton:
+    if (m_application) {
-            return applet.home_button_short_pressed_blocked;
+        std::scoped_lock lk_application{m_application->lock};
-        case AppletMessage::DetectLongPressingHomeButton:
+        m_application->lifecycle_manager.PushUnorderedMessage(m_system.Kernel(), message);
-            return applet.home_button_long_pressed_blocked;
+    }
-        default:
-            return false;
-        }
-    };
-
-    const auto send_to = [&](Applet* applet) {
-        if (!applet) {
-            return;
-        }
-        std::scoped_lock lk{applet->lock};
-        if (is_blocked(*applet)) {
-            LOG_DEBUG(Service_AM, "Applet {} is blocking message {}",
-                      static_cast<u32>(applet->applet_id), static_cast<u32>(message));
-            return;
-        }
-        applet->lifecycle_manager.PushUnorderedMessage(m_system.Kernel(), message);
-    };
-
-    send_to(m_home_menu);
-    send_to(m_overlay_display);
-    send_to(m_application);
-
     if (m_event_observer) {
         m_event_observer->RequestUpdate();
     }
@@ -254,9 +192,19 @@ void WindowSystem::OnSystemButtonPress(SystemButtonType type) {
     case SystemButtonType::HomeButtonShortPressing:
         SendButtonAppletMessageLocked(AppletMessage::DetectShortPressingHomeButton);
         break;
-    case SystemButtonType::HomeButtonLongPressing:
+    case SystemButtonType::HomeButtonLongPressing: {
+        // Toggle overlay foreground visibility on long home press
+        if (m_overlay_display) {
+            std::scoped_lock lk_overlay{m_overlay_display->lock};
+            m_overlay_display->overlay_in_foreground = !m_overlay_display->overlay_in_foreground;
+            LOG_INFO(Service_AM, "Overlay long-press toggle: overlay_in_foreground={} window_visible={}", m_overlay_display->overlay_in_foreground, m_overlay_display->window_visible);
+        }
         SendButtonAppletMessageLocked(AppletMessage::DetectLongPressingHomeButton);
-        break;
+        // Force a state update after toggling overlay
+        if (m_event_observer) {
+            m_event_observer->RequestUpdate();
+        }
+        break; }
     case SystemButtonType::CaptureButtonShortPressing:
         SendButtonAppletMessageLocked(AppletMessage::DetectShortPressingCaptureButton);
         break;
@@ -369,8 +317,6 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
             m_overlay_display = nullptr;
         }
 
-        this->UpdateCurrentApplicationLocked();
-
         // Finalize applet.
         applet->OnProcessTerminatedLocked();
 
@@ -443,20 +389,7 @@ void WindowSystem::TerminateChildAppletsLocked(Applet* applet) {
     applet->lock.lock();
 }
 
-bool WindowSystem::IsOverlayOpenLocked(const Applet& overlay) const {
+void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, bool overlay_blocking) {
-    return overlay.window_visible && overlay.overlay_watching_short_home_button;
-}
-
-bool WindowSystem::DoesOverlayTakeInputLocked() const {
-    if (m_overlay_display == nullptr) {
-        return false;
-    }
-
-    std::scoped_lock lk{m_overlay_display->lock};
-    return this->IsOverlayOpenLocked(*m_overlay_display);
-}
-
-void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, bool overlay_takes_input) {
     // With no applet, we don't have anything to do.
     if (!applet) {
         return;
@@ -487,18 +420,24 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
         return false;
     }();
 
-    const bool is_overlay = applet->applet_id == AppletId::OverlayDisplay;
-
     // Update visibility state.
-    const bool should_be_visible =
+    // Overlay applets should always be visible when window_visible is true, regardless of foreground state
-        is_overlay ? applet->window_visible : (is_foreground && applet->window_visible);
+    const bool should_be_visible = (applet->applet_id == AppletId::OverlayDisplay)
+                                     ? applet->window_visible
+                                     : (is_foreground && applet->window_visible);
     applet->display_layer_manager.SetWindowVisibility(should_be_visible);
 
-    const bool needs_hid_input =
-        is_overlay ? this->IsOverlayOpenLocked(*applet)
-                   : (is_foreground && applet->window_visible && !overlay_takes_input);
 
-    applet->SetInteractibleLocked(needs_hid_input, needs_hid_input);
+    const bool should_be_interactible = (applet->applet_id == AppletId::OverlayDisplay)
+                                          ? applet->overlay_in_foreground
+                                          : (is_foreground && applet->window_visible && !overlay_blocking);
+
+    if (applet->applet_id == AppletId::OverlayDisplay || applet->applet_id == AppletId::Application) {
+        LOG_DEBUG(Service_AM, "UpdateAppletStateLocked: applet={} overlay_in_foreground={} is_foreground={} window_visible={} overlay_blocking={} should_be_interactible={}",
+                 static_cast<u32>(applet->applet_id), applet->overlay_in_foreground, is_foreground, applet->window_visible, overlay_blocking, should_be_interactible);
+    }
+
+    applet->SetInteractibleLocked(should_be_interactible);
 
     // Update focus state and suspension.
     const bool is_obscured = has_obscuring_child_applets || !applet->window_visible;
@@ -514,18 +453,23 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
         applet->UpdateSuspensionStateLocked(true);
     }
 
-    // Layer ordering. Composition sorts back-to-front. Now with enums for calrity.
+    // Z-index logic like in reference C# implementation (tuned for overlay extremes)
-    s32 z_index = Background;
+    s32 z_index = 0;
-    if (is_overlay) {
+    const bool now_foreground = inherited_foreground;
-        z_index = Overlay;
+    if (applet->applet_id == AppletId::OverlayDisplay) {
-    } else if (inherited_foreground) {
+        z_index = applet->overlay_in_foreground ? 100000 : -1;
-        z_index = is_obscured ? Foreground : ForegroundVisible;
+    } else if (now_foreground && !is_obscured) {
+        z_index = 2;
+    } else if (now_foreground) {
+        z_index = 1;
+    } else {
+        z_index = 0;
     }
     applet->display_layer_manager.SetOverlayZIndex(z_index);
 
     // Recurse into child applets.
     for (const auto& child_applet : applet->child_applets) {
-        this->UpdateAppletStateLocked(child_applet.get(), is_foreground, overlay_takes_input);
+        this->UpdateAppletStateLocked(child_applet.get(), is_foreground, overlay_blocking);
     }
 }
 

src/core/hle/service/am/window_system.h

@@ -9,7 +9,6 @@
 #include <map>
 #include <memory>
 #include <mutex>
-#include <optional>
 
 #include "common/common_types.h"
 #include "core/hle/service/am/am_types.h"
@@ -61,16 +60,11 @@ public:
     void OnPowerButtonPressed(ButtonPressDuration type) {}
 
 private:
-    void UpdateCurrentApplicationLocked();
-    void NotifyApplicationChangedIfNeeded();
     void PruneTerminatedAppletsLocked();
     bool RestartAppletProcessLocked(Applet* applet);
     bool LockHomeMenuIntoForegroundLocked();
     void TerminateChildAppletsLocked(Applet* applet);
-    bool IsOverlayOpenLocked(const Applet& overlay) const;
+    void UpdateAppletStateLocked(Applet* applet, bool is_foreground, bool overlay_blocking = false);
-    bool DoesOverlayTakeInputLocked() const;
-
-    void UpdateAppletStateLocked(Applet* applet, bool is_foreground, bool overlay_takes_input);
     void SendButtonAppletMessageLocked(AppletMessage message);
 
 private:
@@ -94,7 +88,6 @@ private:
 
     // Applet map by aruid.
     std::map<u64, std::shared_ptr<Applet>> m_applets{};
-    std::optional<u64> m_pending_application_notification{};
 };
 
 } // namespace Service::AM

src/core/hle/service/aoc/addon_content_manager.cpp

@@ -23,7 +23,6 @@
 #include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/server_manager.h"
-#include "core/hle/service/am/am_results.h"
 #include "core/loader/loader.h"
 
 namespace Service::AOC {
@@ -32,10 +31,6 @@ static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
     return FileSys::GetBaseTitleID(title_id) == base;
 }
 
-static u64 GetCallerBaseTitleID(Core::System& system, const ClientProcessId& process_id) {
-    return FileSys::GetBaseTitleID(system.ResolveCallerProgramId(*process_id));
-}
-
 static std::vector<u64> AccumulateAOCTitleIDs(Core::System& system) {
     std::vector<u64> add_on_content;
     const auto& rcu = system.GetContentProvider();
@@ -96,7 +91,7 @@ IAddOnContentManager::~IAddOnContentManager() {
 Result IAddOnContentManager::CountAddOnContent(Out<u32> out_count, ClientProcessId process_id) {
     LOG_DEBUG(Service_AOC, "called. process_id={}", process_id.pid);
 
-    const auto current = GetCallerBaseTitleID(system, process_id);
+    const auto current = system.GetApplicationProcessProgramID();
 
     const auto& disabled = Settings::values.disabled_addons[current];
     if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end()) {
@@ -117,7 +112,7 @@ Result IAddOnContentManager::ListAddOnContent(Out<u32> out_count,
     LOG_DEBUG(Service_AOC, "called with offset={}, count={}, process_id={}", offset, count,
               process_id.pid);
 
-    const auto current = GetCallerBaseTitleID(system, process_id);
+    const auto current = FileSys::GetBaseTitleID(system.GetApplicationProcessProgramID());
 
     std::vector<u32> out;
     const auto& disabled = Settings::values.disabled_addons[current];
@@ -131,7 +126,8 @@ Result IAddOnContentManager::ListAddOnContent(Out<u32> out_count,
         }
     }
 
-    R_UNLESS(out.size() >= offset, AM::ResultApplicationRecordNotFound);
+    // TODO(DarkLordZach): Find the correct error code.
+    R_UNLESS(out.size() >= offset, ResultUnknown);
 
     *out_count = static_cast<u32>(std::min<size_t>(out.size() - offset, count));
     std::rotate(out.begin(), out.begin() + offset, out.end());
@@ -145,7 +141,7 @@ Result IAddOnContentManager::GetAddOnContentBaseId(Out<u64> out_title_id,
                                                    ClientProcessId process_id) {
     LOG_DEBUG(Service_AOC, "called. process_id={}", process_id.pid);
 
-    const auto title_id = system.ResolveCallerProgramId(*process_id);
+    const auto title_id = system.GetApplicationProcessProgramID();
     const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
                                    system.GetContentProvider()};
 

src/core/hle/service/bcat/bcat_service.cpp

@@ -24,8 +24,8 @@ static u64 GetCurrentBuildID(const Core::System::CurrentBuildProcessID& id) {
     return out;
 }
 
-IBcatService::IBcatService(Core::System& system_, BcatBackend& backend_, u64 program_id_)
+IBcatService::IBcatService(Core::System& system_, BcatBackend& backend_)
-    : ServiceFramework{system_, "IBcatService"}, backend{backend_}, program_id{program_id_},
+    : ServiceFramework{system_, "IBcatService"}, backend{backend_},
       progress{{
           ProgressServiceBackend{system_, "Normal"},
           ProgressServiceBackend{system_, "Directory"},
@@ -70,7 +70,8 @@ Result IBcatService::RequestSyncDeliveryCache(
     LOG_DEBUG(Service_BCAT, "called");
 
     auto& progress_backend{GetProgressBackend(SyncType::Normal)};
-    backend.Synchronize(system.Kernel(), {program_id, GetCurrentBuildID(system.GetApplicationProcessBuildID())},
+    backend.Synchronize(system.Kernel(), {system.GetApplicationProcessProgramID(),
+                         GetCurrentBuildID(system.GetApplicationProcessBuildID())},
                         GetProgressBackend(SyncType::Normal));
 
     *out_interface = std::make_shared<IDeliveryCacheProgressService>(
@@ -85,8 +86,9 @@ Result IBcatService::RequestSyncDeliveryCacheWithDirectoryName(
     LOG_DEBUG(Service_BCAT, "called, name={}", name);
 
     auto& progress_backend{GetProgressBackend(SyncType::Directory)};
-    backend.SynchronizeDirectory(system.Kernel(), {program_id, GetCurrentBuildID(system.GetApplicationProcessBuildID())},
+    backend.SynchronizeDirectory(system.Kernel(), {system.GetApplicationProcessProgramID(),
-        name, progress_backend);
+                                  GetCurrentBuildID(system.GetApplicationProcessBuildID())},
+                                 name, progress_backend);
 
     *out_interface = std::make_shared<IDeliveryCacheProgressService>(
         system, progress_backend.GetEvent(), progress_backend.GetImpl());

src/core/hle/service/bcat/bcat_service.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -22,7 +19,7 @@ class IDeliveryCacheProgressService;
 
 class IBcatService final : public ServiceFramework<IBcatService> {
 public:
-    explicit IBcatService(Core::System& system_, BcatBackend& backend_, u64 program_id_);
+    explicit IBcatService(Core::System& system_, BcatBackend& backend_);
     ~IBcatService() override;
 
 private:
@@ -42,7 +39,6 @@ private:
     const ProgressServiceBackend& GetProgressBackend(SyncType type) const;
 
     BcatBackend& backend;
-    u64 program_id;
     std::array<ProgressServiceBackend, static_cast<size_t>(SyncType::Count)> progress;
 };
 

src/core/hle/service/bcat/service_creator.cpp

@@ -1,10 +1,6 @@
-// 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
 
-#include "core/core.h"
 #include "core/hle/service/bcat/bcat_service.h"
 #include "core/hle/service/bcat/delivery_cache_storage_service.h"
 #include "core/hle/service/bcat/service_creator.h"
@@ -41,8 +37,7 @@ IServiceCreator::~IServiceCreator() = default;
 Result IServiceCreator::CreateBcatService(ClientProcessId process_id,
                                           OutInterface<IBcatService> out_interface) {
     LOG_INFO(Service_BCAT, "called, process_id={}", process_id.pid);
-    *out_interface =
+    *out_interface = std::make_shared<IBcatService>(system, *backend);
-        std::make_shared<IBcatService>(system, *backend, system.ResolveCallerProgramId(*process_id));
     R_SUCCEED();
 }
 
@@ -50,7 +45,7 @@ Result IServiceCreator::CreateDeliveryCacheStorageService(
     ClientProcessId process_id, OutInterface<IDeliveryCacheStorageService> out_interface) {
     LOG_INFO(Service_BCAT, "called, process_id={}", process_id.pid);
 
-    const auto title_id = system.ResolveCallerProgramId(*process_id);
+    const auto title_id = system.GetApplicationProcessProgramID();
     *out_interface =
         std::make_shared<IDeliveryCacheStorageService>(system, fsc.GetBCATDirectory(title_id));
     R_SUCCEED();

src/core/hle/service/caps/caps_manager.cpp

@@ -243,15 +243,10 @@ Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry,
     return SaveScreenShot(out_entry, attribute, report_option, {}, image_data, aruid);
 }
 
-Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry,
+Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry, const ScreenShotAttribute& attribute, AlbumReportOption report_option, const ApplicationData& app_data, std::span<const u8> image_data, u64 aruid) {
-                                    const ScreenShotAttribute& attribute,
-                                    AlbumReportOption report_option,
-                                    const ApplicationData& app_data, std::span<const u8> image_data,
-                                    u64 aruid) {
     R_UNLESS(!image_data.empty(), ResultUnknown); //TODO: ???
 
-    const u64 title_id = system.ResolveCallerProgramId(aruid);
+    const u64 title_id = system.GetApplicationProcessProgramID();
-
     auto static_service =
         system.ServiceManager().GetService<Service::Glue::Time::StaticService>("time:u", true);
 

src/core/hle/service/caps/caps_su.cpp

@@ -95,8 +95,7 @@ void IScreenShotApplicationService::CaptureAndSaveScreenshot(AlbumReportOption r
             manager->FlipVerticallyOnWrite(invert_y);
             manager->SaveScreenShot(entry, attribute, report_option, image_data, {});
         },
-        layout,
+        layout);
-        Nvnflinger::LayerStackId::Screenshot);
 }
 
 } // namespace Service::Capture

src/core/hle/service/hid/hid_server.cpp

@@ -1164,7 +1164,7 @@ Result IHidServer::InitializeSevenSixAxisSensor(ClientAppletResourceUserId aruid
     GetResourceManager()->GetConsoleSixAxis()->Activate();
     GetResourceManager()->GetSevenSixAxis()->Activate();
 
-    GetResourceManager()->GetSevenSixAxis()->SetTransferMemoryAddress(t_mem_1->GetSourceAddress(), t_mem_1->GetOwner());
+    GetResourceManager()->GetSevenSixAxis()->SetTransferMemoryAddress(t_mem_1->GetSourceAddress());
 
     R_SUCCEED();
 }

src/core/hle/service/hid/hidbus.cpp

@@ -312,7 +312,7 @@ Result Hidbus::EnableJoyPollingReceiveMode(u32 t_mem_size, JoyPollingMode pollin
 
     auto& device = devices[device_index.value()].device;
     device->SetPollingMode(polling_mode);
-    device->SetTransferMemoryAddress(t_mem->GetSourceAddress(), t_mem->GetOwner());
+    device->SetTransferMemoryAddress(t_mem->GetSourceAddress());
     R_SUCCEED();
 }
 

src/core/hle/service/hid/irs.cpp

@@ -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
 
@@ -150,7 +147,7 @@ Result IRS::RunImageTransferProcessor(
     MakeProcessorWithCoreContext<ImageTransferProcessor>(camera_handle, device);
     auto& image_transfer_processor = GetProcessor<ImageTransferProcessor>(camera_handle);
     image_transfer_processor.SetConfig(processor_config);
-    image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress(), t_mem->GetOwner());
+    image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
     npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
                                 Common::Input::PollingMode::IR);
 
@@ -298,8 +295,7 @@ Result IRS::RunImageTransferExProcessor(
     MakeProcessorWithCoreContext<ImageTransferProcessor>(camera_handle, device);
     auto& image_transfer_processor = GetProcessor<ImageTransferProcessor>(camera_handle);
     image_transfer_processor.SetConfig(processor_config);
-    image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress(),
+    image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
-                                                      t_mem->GetOwner());
     npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
                                 Common::Input::PollingMode::IR);
 

src/core/hle/service/jit/jit.cpp

@@ -35,7 +35,7 @@ public:
         , process{kernel, process_}
         , user_rx{std::move(user_rx_)}
         , user_ro{std::move(user_ro_)}
-        , context{process_->GetMemory()}
+        , context{system_.ApplicationMemory()}
     {
 
         // clang-format off

src/core/hle/service/ns/read_only_application_control_data_interface.cpp

@@ -14,7 +14,6 @@
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/vfs/vfs.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_transfer_memory.h"
 #include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ns/language.h"
@@ -333,8 +332,8 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestCo
 
     constexpr s32 data_offset = 0;
 
-    if (t_mem != nullptr && t_mem->GetOwner() != nullptr && app_count > 0) {
+    if (t_mem != nullptr && app_count > 0) {
-        auto& memory = t_mem->GetOwner()->GetMemory();
+        auto& memory = system.ApplicationMemory();
         const auto t_mem_address = t_mem->GetSourceAddress();
 
         for (size_t i = 0; i < app_count; ++i) {

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -77,7 +77,6 @@ void nvdisp_disp0::Composite(std::span<const Nvnflinger::HwcLayer> sorted_layers
             .transform_flags = layer.transform,
             .crop_rect = layer.crop_rect,
             .blending = ConvertBlending(layer.blending),
-            .layer_stack_mask = layer.layer_stack_mask,
         });
 
         for (size_t i = 0; i < layer.acquire_fence.num_fences; i++) {

src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp

@@ -69,7 +69,7 @@ NvResult nvhost_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
         case 0x3:
             return WrapFixed(this, &nvhost_gpu::ChannelSetTimeout, input, output);
         case 0x8:
-            return WrapFixedVariable(this, &nvhost_gpu::SubmitGPFIFOBase1, input, output, fd, false);
+            return WrapFixedVariable(this, &nvhost_gpu::SubmitGPFIFOBase1, input, output, false);
         case 0x9:
             return WrapFixed(this, &nvhost_gpu::AllocateObjectContext, input, output);
         case 0xb:
@@ -83,7 +83,7 @@ NvResult nvhost_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
         case 0x1a:
             return WrapFixed(this, &nvhost_gpu::AllocGPFIFOEx2, input, output, fd);
         case 0x1b:
-            return WrapFixedVariable(this, &nvhost_gpu::SubmitGPFIFOBase1, input, output, fd, true);
+            return WrapFixedVariable(this, &nvhost_gpu::SubmitGPFIFOBase1, input, output, true);
         case 0x1d:
             return WrapFixed(this, &nvhost_gpu::ChannelSetTimeslice, input, output);
         default:
@@ -387,19 +387,8 @@ NvResult nvhost_gpu::SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandL
     return NvResult::Success;
 }
 
-Core::Memory::Memory& nvhost_gpu::GetSessionMemory(DeviceFD fd) {
-    if (const auto it = sessions.find(fd); it != sessions.end())
-        if (auto* const session = core.GetSession(it->second);
-            session != nullptr && session->process != nullptr)
-            return session->process->GetMemory();
-
-    LOG_ERROR(Service_NVDRV, "No session for fd={}, falling back to application memory", fd);
-    return system.ApplicationMemory();
-}
-
 NvResult nvhost_gpu::SubmitGPFIFOBase1(IoctlSubmitGpfifo& params,
-                                       std::span<Tegra::CommandListHeader> commands, DeviceFD fd,
+                                       std::span<Tegra::CommandListHeader> commands, bool kickoff) {
-                                       bool kickoff) {
     if (params.num_entries > commands.size()) {
         UNIMPLEMENTED();
         return NvResult::InvalidSize;
@@ -407,7 +396,7 @@ NvResult nvhost_gpu::SubmitGPFIFOBase1(IoctlSubmitGpfifo& params,
 
     Tegra::CommandList entries(params.num_entries);
     if (kickoff) {
-        this->GetSessionMemory(fd).ReadBlock(params.address, entries.command_lists.data(),
+        system.ApplicationMemory().ReadBlock(params.address, entries.command_lists.data(),
                                              params.num_entries * sizeof(Tegra::CommandListHeader));
     } else {
         std::memcpy(entries.command_lists.data(), commands.data(),

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -16,10 +16,6 @@
 #include "core/hle/service/nvdrv/nvdata.h"
 #include "video_core/dma_pusher.h"
 
-namespace Core::Memory {
-class Memory;
-}
-
 namespace Tegra {
 namespace Control {
 struct ChannelState;
@@ -200,11 +196,8 @@ private:
 
     NvResult SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandList&& entries);
 
-    Core::Memory::Memory& GetSessionMemory(DeviceFD fd);
-
     NvResult SubmitGPFIFOBase1(IoctlSubmitGpfifo& params,
-                               std::span<Tegra::CommandListHeader> commands, DeviceFD fd,
+                               std::span<Tegra::CommandListHeader> commands, bool kickoff = false);
-                               bool kickoff = false);
     NvResult SubmitGPFIFOBase2(IoctlSubmitGpfifo& params,
                                std::span<const Tegra::CommandListHeader> commands);
 

src/core/hle/service/nvnflinger/display.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -15,8 +15,7 @@ struct Layer {
     explicit Layer(std::shared_ptr<android::BufferItemConsumer> buffer_item_consumer_,
                    s32 consumer_id_)
         : buffer_item_consumer(std::move(buffer_item_consumer_)), consumer_id(consumer_id_),
-          blending(LayerBlending::None), visible(true), z_index(0), is_overlay(false),
+          blending(LayerBlending::None), visible(true), z_index(0), is_overlay(false) {}
-          layer_stack_mask(DefaultLayerStackMask) {}
     ~Layer() {
         buffer_item_consumer->Abandon();
     }
@@ -27,7 +26,6 @@ struct Layer {
     bool visible;
     s32 z_index;
     bool is_overlay;
-    u32 layer_stack_mask;
 };
 
 struct LayerStack {

src/core/hle/service/nvnflinger/hardware_composer.cpp

@@ -115,7 +115,6 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,
                 .transform = static_cast<android::BufferTransformFlags>(item.transform),
                 .crop_rect = item.crop,
                 .acquire_fence = item.fence,
-                .layer_stack_mask = layer->layer_stack_mask,
             });
         }
 

src/core/hle/service/nvnflinger/hwc_layer.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -26,25 +23,6 @@ enum class LayerBlending : u32 {
     Coverage = 0x405,
 };
 
-enum class LayerStackId : u32 {
-    Default = 0,
-    Lcd = 1,
-    Screenshot = 2,
-    Recording = 3,
-    LastFrame = 4,
-    Arbitrary = 5,
-    ApplicationForDebug = 6,
-    Null = 10,
-};
-
-constexpr u32 LayerStackBit(LayerStackId id) {
-    return 1U << static_cast<u32>(id);
-}
-
-constexpr u32 DefaultLayerStackMask =
-    LayerStackBit(LayerStackId::Default) | LayerStackBit(LayerStackId::Screenshot) |
-    LayerStackBit(LayerStackId::Recording) | LayerStackBit(LayerStackId::LastFrame);
-
 struct HwcLayer {
     u32 buffer_handle;
     u32 offset;
@@ -57,7 +35,6 @@ struct HwcLayer {
     android::BufferTransformFlags transform;
     Common::Rectangle<int> crop_rect;
     android::Fence acquire_fence;
-    u32 layer_stack_mask;
 };
 
 } // namespace Service::Nvnflinger

src/core/hle/service/nvnflinger/surface_flinger.cpp

@@ -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 2024 yuzu Emulator Project
@@ -104,14 +104,6 @@ void SurfaceFlinger::SetLayerBlending(s32 consumer_binder_id, LayerBlending blen
     }
 }
 
-void SurfaceFlinger::SetLayerStackMask(s32 consumer_binder_id, u32 layer_stack_mask) {
-    if (const auto layer = this->FindLayer(consumer_binder_id); layer != nullptr) {
-        layer->layer_stack_mask = layer_stack_mask;
-        LOG_DEBUG(Service_VI, "Layer {} stack mask set to {:#x}", consumer_binder_id,
-                  layer_stack_mask);
-    }
-}
-
 void SurfaceFlinger::SetLayerIsOverlay(s32 consumer_binder_id, bool is_overlay) {
     if (const auto layer = this->FindLayer(consumer_binder_id); layer != nullptr) {
         layer->is_overlay = is_overlay;

src/core/hle/service/nvnflinger/surface_flinger.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -48,7 +48,6 @@ public:
     void SetLayerVisibility(s32 consumer_binder_id, bool visible);
     void SetLayerBlending(s32 consumer_binder_id, LayerBlending blending);
     void SetLayerIsOverlay(s32 consumer_binder_id, bool is_overlay);
-    void SetLayerStackMask(s32 consumer_binder_id, u32 layer_stack_mask);
 
     std::shared_ptr<Layer> FindLayer(s32 consumer_binder_id);
 

src/core/hle/service/pctl/parental_control_service.cpp

@@ -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 2024 yuzu Emulator Project
@@ -13,10 +13,8 @@
 
 namespace Service::PCTL {
 
-IParentalControlService::IParentalControlService(Core::System& system_, Capability capability_,
+IParentalControlService::IParentalControlService(Core::System& system_, Capability capability_)
-                                                 u64 program_id_)
     : ServiceFramework{system_, "IParentalControlService"}, capability{capability_},
-      program_id{program_id_},
       service_context{system_, "IParentalControlService"}, synchronization_event{service_context},
       unlinked_event{service_context}, request_suspension_event{service_context} {
     // clang-format off
@@ -204,6 +202,7 @@ Result IParentalControlService::Initialize() {
 
     // TODO(ogniK): Recovery flag initialization for pctl:r
 
+    const auto program_id = system.GetApplicationProcessProgramID();
     if (program_id != 0) {
         const FileSys::PatchManager pm{program_id, system.GetFileSystemController(),
                                        system.GetContentProvider()};

src/core/hle/service/pctl/parental_control_service.h

@@ -16,8 +16,7 @@ namespace Service::PCTL {
 
 class IParentalControlService final : public ServiceFramework<IParentalControlService> {
 public:
-    explicit IParentalControlService(Core::System& system_, Capability capability_,
+    explicit IParentalControlService(Core::System& system_, Capability capability_);
-                                     u64 program_id_);
     ~IParentalControlService() override;
 
 private:
@@ -85,7 +84,6 @@ private:
     RestrictionSettings restriction_settings{};
     std::array<char, 8> pin_code{};
     Capability capability{};
-    u64 program_id{};
     // TODO: this is raw
     PlayTimerSettings raw_play_timer_settings{};
 

src/core/hle/service/pctl/parental_control_service_factory.cpp

@@ -1,10 +1,6 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/core.h"
 #include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/pctl/parental_control_service.h"
 #include "core/hle/service/pctl/parental_control_service_factory.h"
@@ -27,17 +23,17 @@ IParentalControlServiceFactory::~IParentalControlServiceFactory() = default;
 
 Result IParentalControlServiceFactory::CreateService(
     Out<SharedPointer<IParentalControlService>> out_service, ClientProcessId process_id) {
-    LOG_DEBUG(Service_PCTL, "called, process_id={}", process_id.pid);
+    LOG_DEBUG(Service_PCTL, "called");
-    *out_service = std::make_shared<IParentalControlService>(
+    // TODO(ogniK): Get application id from process
-        system, capability, system.ResolveCallerProgramId(*process_id));
+    *out_service = std::make_shared<IParentalControlService>(system, capability);
     R_SUCCEED();
 }
 
 Result IParentalControlServiceFactory::CreateServiceWithoutInitialize(
     Out<SharedPointer<IParentalControlService>> out_service, ClientProcessId process_id) {
-    LOG_DEBUG(Service_PCTL, "called, process_id={}", process_id.pid);
+    LOG_DEBUG(Service_PCTL, "called");
-    *out_service = std::make_shared<IParentalControlService>(
+    // TODO(ogniK): Get application id from process
-        system, capability, system.ResolveCallerProgramId(*process_id));
+    *out_service = std::make_shared<IParentalControlService>(system, capability);
     R_SUCCEED();
 }
 

src/core/hle/service/pm/pm.cpp

@@ -132,7 +132,8 @@ private:
 
         LOG_WARNING(Service_PM, "(Partial Implementation) called, pid={:016X}", pid);
 
-        auto process = kernel.GetProcessByProcessId(pid);
+        auto list = kernel.GetProcessList();
+        auto process = SearchProcessList(system.Kernel(), list, [pid](auto& p) { return p->GetProcessId() == pid; });
 
         if (process.IsNull()) {
             IPC::ResponseBuilder rb{ctx, 2};
@@ -185,7 +186,9 @@ private:
 
         LOG_DEBUG(Service_PM, "called, process_id={:016X}", process_id);
 
-        auto process = kernel.GetProcessByProcessId(process_id);
+        auto list = kernel.GetProcessList();
+        auto process = SearchProcessList(system.Kernel(),
+            list, [process_id](auto& p) { return p->GetProcessId() == process_id; });
 
         if (process.IsNull()) {
             IPC::ResponseBuilder rb{ctx, 2};

src/core/hle/service/prepo/prepo.cpp

@@ -76,7 +76,7 @@ private:
                   Type, process_id, data1.size(), data2.size());
 
         const auto& reporter{system.GetReporter()};
-        reporter.SavePlayReport(Type, system.ResolveCallerProgramId(process_id), {data1, data2},
+        reporter.SavePlayReport(Type, system.GetApplicationProcessProgramID(), {data1, data2},
                                 process_id);
 
         IPC::ResponseBuilder rb{ctx, 2};
@@ -98,7 +98,7 @@ private:
                   Type, user_id[1], user_id[0], process_id, data1.size(), data2.size());
 
         const auto& reporter{system.GetReporter()};
-        reporter.SavePlayReport(Type, system.ResolveCallerProgramId(process_id), {data1, data2},
+        reporter.SavePlayReport(Type, system.GetApplicationProcessProgramID(), {data1, data2},
                                 process_id, user_id);
 
         IPC::ResponseBuilder rb{ctx, 2};

src/core/hle/service/vi/container.cpp

@@ -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 2024 yuzu Emulator Project
@@ -166,16 +166,6 @@ Result Container::GetLayerZIndex(u64 layer_id, s32* out_z_index) {
     R_RETURN(VI::ResultNotFound);
 }
 
-Result Container::SetLayerStackMask(u64 layer_id, u32 layer_stack_mask) {
-    std::scoped_lock lk{m_lock};
-
-    auto* const layer = m_layers.GetLayerById(layer_id);
-    R_UNLESS(layer != nullptr, VI::ResultNotFound);
-
-    m_surface_flinger->SetLayerStackMask(layer->GetConsumerBinderId(), layer_stack_mask);
-    R_SUCCEED();
-}
-
 Result Container::SetLayerIsOverlay(u64 layer_id, bool is_overlay) {
     std::scoped_lock lk{m_lock};
 

src/core/hle/service/vi/container.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -68,7 +68,6 @@ public:
     Result SetLayerZIndex(u64 layer_id, s32 z_index);
     Result GetLayerZIndex(u64 layer_id, s32* out_z_index);
     Result SetLayerIsOverlay(u64 layer_id, bool is_overlay);
-    Result SetLayerStackMask(u64 layer_id, u32 layer_stack_mask);
 
     void LinkVsyncEvent(u64 display_id, Event* event);
     void UnlinkVsyncEvent(u64 display_id, Event* event);

src/core/hle/service/vi/shared_buffer_manager.cpp

@@ -4,15 +4,9 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <algorithm>
-#include <array>
 #include <random>
 
-#include "common/assert.h"
-#include "common/logging.h"
-#include "common/scratch_buffer.h"
 #include "core/core.h"
-#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_system_resource.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
@@ -53,7 +47,7 @@ Result AllocateSharedBufferMemory(std::unique_ptr<Kernel::KPageGroup>* out_page_
         u32* end = system.DeviceMemory().GetPointer<u32>(block.GetAddress() + block.GetSize());
 
         for (; start < end; start++) {
-            *start = 0x00000000;
+            *start = 0xFF0000FF;
         }
     }
 
@@ -174,14 +168,7 @@ constexpr u32 SharedBufferBlockLinearWidth = 1280;
 constexpr u32 SharedBufferBlockLinearHeight = 768;
 constexpr u32 SharedBufferBlockLinearStride =
     SharedBufferBlockLinearWidth * SharedBufferBlockLinearBpp;
-
+constexpr u32 SharedBufferNumSlots = 7;
-constexpr u32 SharedBufferNumCaptureSlots = 3;
-constexpr u32 SharedBufferSlotsPerSession = 2;
-constexpr u32 SharedBufferMaxSessions = 2;
-
-constexpr u32 SharedBufferNumSlots =
-    SharedBufferNumCaptureSlots + SharedBufferSlotsPerSession * SharedBufferMaxSessions;
-static_assert(SharedBufferNumSlots <= 16, "Shared buffer pool exceeds the maximum texture count");
 
 constexpr u32 SharedBufferWidth = 1280;
 constexpr u32 SharedBufferHeight = 720;
@@ -205,52 +192,7 @@ constexpr SharedMemoryPoolLayout SharedBufferPoolLayout = [] {
     return layout;
 }();
 
-constexpr u32 GetCaptureSlot(CaptureKind kind) {
+void MakeGraphicBuffer(android::BufferQueueProducer& producer, u32 slot, u32 handle) {
-    return static_cast<u32>(kind);
-}
-static_assert(static_cast<u32>(CaptureKind::CallerApplet) + 1 == SharedBufferNumCaptureSlots,
-              "Capture slot count does not match CaptureKind");
-
-constexpr u32 GetPresentationSlot(u32 slot_base, u32 index) {
-    return SharedBufferNumCaptureSlots + slot_base + index;
-}
-
-constexpr u32 ColorOpaqueBlackRgba32 = 0xFF000000;
-
-template <typename F>
-void ForEachPoolChunk(Core::System& system, Kernel::KPageGroup& page_group, u64 offset, u64 size,
-                      F&& writer) {
-    Common::ScratchBuffer<u32> scratch;
-    const u64 range_end = offset + size;
-    u64 pool_pos = 0;
-
-    for (auto& block : page_group) {
-        const u64 block_begin = pool_pos;
-        const u64 block_end = block_begin + block.GetSize();
-        pool_pos = block_end;
-
-        if (block_end <= offset) {
-            continue;
-        }
-        if (block_begin >= range_end) {
-            break;
-        }
-
-        const u64 chunk_begin = (std::max)(block_begin, offset);
-        const u64 chunk_end = (std::min)(block_end, range_end);
-        const u64 chunk_size = chunk_end - chunk_begin;
-
-        u8* const dst =
-            system.DeviceMemory().GetPointer<u8>(block.GetAddress()) + (chunk_begin - block_begin);
-
-        writer(dst, chunk_begin - offset, chunk_size);
-
-        system.GPU().Host1x().MemoryManager().ApplyOpOnPointer(
-            dst, scratch, [&](DAddr addr) { system.GPU().InvalidateRegion(addr, chunk_size); });
-    }
-}
-
-void MakeGraphicBuffer(android::BufferQueueProducer& producer, u32 producer_slot, u32 pool_slot, u32 handle) {
     auto buffer = std::make_shared<android::NvGraphicBuffer>();
     buffer->width = SharedBufferWidth;
     buffer->height = SharedBufferHeight;
@@ -258,8 +200,8 @@ void MakeGraphicBuffer(android::BufferQueueProducer& producer, u32 producer_slot
     buffer->format = SharedBufferBlockLinearFormat;
     buffer->external_format = SharedBufferBlockLinearFormat;
     buffer->buffer_id = handle;
-    buffer->offset = pool_slot * SharedBufferSlotSize;
+    buffer->offset = slot * SharedBufferSlotSize;
-    ASSERT(producer.SetPreallocatedBuffer(producer_slot, buffer) == android::Status::NoError);
+    ASSERT(producer.SetPreallocatedBuffer(slot, buffer) == android::Status::NoError);
 }
 
 } // namespace
@@ -273,91 +215,59 @@ SharedBufferManager::~SharedBufferManager() = default;
 Result SharedBufferManager::CreateSession(Kernel::KProcess* owner_process, u64* out_buffer_id,
                                           u64* out_layer_handle, u64 display_id,
                                           bool enable_blending) {
-    {
+    std::scoped_lock lk{m_guard};
-        std::scoped_lock lk{m_guard};
 
-        // Ensure we haven't already created.
+    // Ensure we haven't already created.
-        const u64 aruid = owner_process->GetProcessId();
+    const u64 aruid = owner_process->GetProcessId();
-        R_UNLESS(!m_sessions.contains(aruid), VI::ResultPermissionDenied);
+    R_UNLESS(!m_sessions.contains(aruid), VI::ResultPermissionDenied);
 
-        // Allocate memory for the shared buffer if needed.
+    // Allocate memory for the shared buffer if needed.
-        if (!m_buffer_page_group) {
+    if (!m_buffer_page_group) {
-            R_TRY(AllocateSharedBufferMemory(std::addressof(m_buffer_page_group), m_system,
+        R_TRY(AllocateSharedBufferMemory(std::addressof(m_buffer_page_group), m_system,
-                                             SharedBufferSize));
+                                         SharedBufferSize));
 
-            // Record buffer id.
+        // Record buffer id.
-            m_buffer_id = m_next_buffer_id++;
+        m_buffer_id = m_next_buffer_id++;
 
-            // Record display id.
+        // Record display id.
-            m_display_id = display_id;
+        m_display_id = display_id;
-
-            for (u32 slot = 0; slot < SharedBufferNumCaptureSlots; slot++) {
-                ForEachPoolChunk(m_system, *m_buffer_page_group, u64{slot} * SharedBufferSlotSize,
-                                 SharedBufferSlotSize, [](u8* dst, u64, u64 length) {
-                                     std::fill_n(reinterpret_cast<u32*>(dst), length / sizeof(u32),
-                                                 ColorOpaqueBlackRgba32);
-                                 });
-            }
-        }
-
-        // Claim a presentation slot range.
-        u32 slot_base = 0;
-
-        std::array<bool, SharedBufferMaxSessions> in_use{};
-        for (const auto& [existing_aruid, existing] : m_sessions) {
-            const u32 index = existing.presentation_slot_base / SharedBufferSlotsPerSession;
-
-            if (index < in_use.size())
-                in_use[index] = true;
-        }
-
-        u32 index = 0;
-        while (index < in_use.size() && in_use[index])
-            index++;
-
-        if (index >= in_use.size()) {
-            LOG_ERROR(Service_VI, "Out of shared buffer presentation slots ({} sessions)", SharedBufferMaxSessions);
-            R_THROW(VI::ResultOperationFailed);
-        }
-
-        slot_base = index * SharedBufferSlotsPerSession;
-
-        // Map into process.
-        Common::ProcessAddress map_address{};
-        R_TRY(MapSharedBufferIntoProcessAddressSpace(std::addressof(map_address), m_buffer_page_group,
-                                                     owner_process, m_system));
-
-        // Create new session.
-        auto [it, was_emplaced] = m_sessions.emplace(aruid, SharedBufferSession{});
-        auto& session = it->second;
-        session.presentation_slot_base = slot_base;
-
-        auto& container = m_nvdrv->GetContainer();
-        session.session_id = container.OpenSession(owner_process);
-        session.nvmap_fd = m_nvdrv->Open("/dev/nvmap", session.session_id);
-
-        // Create an nvmap handle for the buffer and assign the memory to it.
-        R_TRY(AllocateHandleForBuffer(std::addressof(session.buffer_nvmap_handle), *m_nvdrv,
-                                      session.nvmap_fd, map_address, SharedBufferSize));
-
-        // Create and open a layer for the display.
-        s32 producer_binder_id;
-        R_TRY(m_container.CreateStrayLayer(std::addressof(producer_binder_id),
-                                           std::addressof(session.layer_id), display_id));
-
-        // Configure blending and z-index
-        R_ASSERT(m_container.SetLayerBlending(session.layer_id, enable_blending));
-
-        // Get the producer and set preallocated buffers.
-        std::shared_ptr<android::BufferQueueProducer> producer;
-        R_TRY(m_container.GetLayerProducerHandle(std::addressof(producer), session.layer_id));
-        for (u32 i = 0; i < SharedBufferSlotsPerSession; i++)
-            MakeGraphicBuffer(*producer, i, GetPresentationSlot(session.presentation_slot_base, i), session.buffer_nvmap_handle);
-
-        // Assign outputs.
-        *out_buffer_id = m_buffer_id;
-        *out_layer_handle = session.layer_id;
     }
+
+    // Map into process.
+    Common::ProcessAddress map_address{};
+    R_TRY(MapSharedBufferIntoProcessAddressSpace(std::addressof(map_address), m_buffer_page_group,
+                                                 owner_process, m_system));
+
+    // Create new session.
+    auto [it, was_emplaced] = m_sessions.emplace(aruid, SharedBufferSession{});
+    auto& session = it->second;
+
+    auto& container = m_nvdrv->GetContainer();
+    session.session_id = container.OpenSession(owner_process);
+    session.nvmap_fd = m_nvdrv->Open("/dev/nvmap", session.session_id);
+
+    // Create an nvmap handle for the buffer and assign the memory to it.
+    R_TRY(AllocateHandleForBuffer(std::addressof(session.buffer_nvmap_handle), *m_nvdrv,
+                                  session.nvmap_fd, map_address, SharedBufferSize));
+
+    // Create and open a layer for the display.
+    s32 producer_binder_id;
+    R_TRY(m_container.CreateStrayLayer(std::addressof(producer_binder_id),
+                                       std::addressof(session.layer_id), display_id));
+
+    // Configure blending and z-index
+    R_ASSERT(m_container.SetLayerBlending(session.layer_id, enable_blending));
+
+    // Get the producer and set preallocated buffers.
+    std::shared_ptr<android::BufferQueueProducer> producer;
+    R_TRY(m_container.GetLayerProducerHandle(std::addressof(producer), session.layer_id));
+    MakeGraphicBuffer(*producer, 0, session.buffer_nvmap_handle);
+    MakeGraphicBuffer(*producer, 1, session.buffer_nvmap_handle);
+
+    // Assign outputs.
+    *out_buffer_id = m_buffer_id;
+    *out_layer_handle = session.layer_id;
+
     // We succeeded.
     R_SUCCEED();
 }
@@ -426,51 +336,14 @@ Result SharedBufferManager::AcquireSharedFrameBuffer(android::Fence* out_fence,
                                      SharedBufferBlockLinearFormat, 0) == android::Status::NoError,
              VI::ResultOperationFailed);
 
-    out_slot_indexes.fill(-1);
+    // Assign remaining outputs.
-
+    *out_target_slot = slot;
-    {
+    out_slot_indexes = {0, 1, -1, -1};
-        std::scoped_lock lk{m_guard};
-        const auto* const session = this->FindSessionByLayerIdLocked(layer_id);
-        if (session == nullptr) {
-            producer->CancelBuffer(slot, *out_fence);
-            // LOG_DEBUG(Service_VI, "No Session found");
-            R_THROW(VI::ResultNotFound);
-        }
-
-        for (u32 i = 0; i < SharedBufferSlotsPerSession; i++)
-            out_slot_indexes[i] =
-                static_cast<s32>(GetPresentationSlot(session->presentation_slot_base, i));
-
-        *out_target_slot = static_cast<s64>(
-            GetPresentationSlot(session->presentation_slot_base, static_cast<u32>(slot)));
-    }
 
     // We succeeded.
     R_SUCCEED();
 }
 
-Result SharedBufferManager::GetProducerSlotLocked(s32* out_producer_slot, u64 layer_id,
-                                                   s64 pool_slot) const {
-    const auto* const session = this->FindSessionByLayerIdLocked(layer_id);
-    R_UNLESS(session != nullptr, VI::ResultNotFound);
-
-    const s64 base = GetPresentationSlot(session->presentation_slot_base, 0);
-    const s64 producer_slot = pool_slot - base;
-    R_UNLESS(producer_slot >= 0 && producer_slot < SharedBufferSlotsPerSession,
-             VI::ResultOperationFailed);
-
-    *out_producer_slot = static_cast<s32>(producer_slot);
-    R_SUCCEED();
-}
-
-const SharedBufferSession* SharedBufferManager::FindSessionByLayerIdLocked(u64 layer_id) const {
-    for (const auto& [aruid, session] : m_sessions)
-        if (session.layer_id == layer_id)
-            return std::addressof(session);
-
-    return nullptr;
-}
-
 Result SharedBufferManager::PresentSharedFrameBuffer(android::Fence fence,
                                                      Common::Rectangle<s32> crop_region,
                                                      u32 transform, s32 swap_interval, u64 layer_id,
@@ -479,20 +352,14 @@ Result SharedBufferManager::PresentSharedFrameBuffer(android::Fence fence,
     std::shared_ptr<android::BufferQueueProducer> producer;
     R_TRY(m_container.GetLayerProducerHandle(std::addressof(producer), layer_id));
 
-    s32 producer_slot;
-    {
-        std::scoped_lock lk{m_guard};
-        R_TRY(this->GetProducerSlotLocked(std::addressof(producer_slot), layer_id, slot));
-    }
-
     // Request to queue the buffer.
     std::shared_ptr<android::GraphicBuffer> buffer;
-    R_UNLESS(producer->RequestBuffer(producer_slot, std::addressof(buffer)) ==
+    R_UNLESS(producer->RequestBuffer(static_cast<s32>(slot), std::addressof(buffer)) ==
                  android::Status::NoError,
              VI::ResultOperationFailed);
 
     ON_RESULT_FAILURE {
-        producer->CancelBuffer(producer_slot, fence);
+        producer->CancelBuffer(static_cast<s32>(slot), fence);
     };
 
     // Queue the buffer to the producer.
@@ -502,10 +369,12 @@ Result SharedBufferManager::PresentSharedFrameBuffer(android::Fence fence,
     input.fence = fence;
     input.transform = static_cast<android::NativeWindowTransform>(transform);
     input.swap_interval = swap_interval;
-    R_UNLESS(producer->QueueBuffer(producer_slot, input, std::addressof(output)) ==
+    R_UNLESS(producer->QueueBuffer(static_cast<s32>(slot), input, std::addressof(output)) ==
                  android::Status::NoError,
              VI::ResultOperationFailed);
 
+    (void)m_container.SetLayerZIndex(layer_id, 100000);
+
     // We succeeded.
     R_SUCCEED();
 }
@@ -515,14 +384,8 @@ Result SharedBufferManager::CancelSharedFrameBuffer(u64 layer_id, s64 slot) {
     std::shared_ptr<android::BufferQueueProducer> producer;
     R_TRY(m_container.GetLayerProducerHandle(std::addressof(producer), layer_id));
 
-    s32 producer_slot;
-    {
-        std::scoped_lock lk{m_guard};
-        R_TRY(this->GetProducerSlotLocked(std::addressof(producer_slot), layer_id, slot));
-    }
-
     // Cancel.
-    producer->CancelBuffer(producer_slot, android::Fence::NoFence());
+    producer->CancelBuffer(static_cast<s32>(slot), android::Fence::NoFence());
 
     // We succeeded.
     R_SUCCEED();
@@ -541,47 +404,31 @@ Result SharedBufferManager::GetSharedFrameBufferAcquirableEvent(Kernel::KReadabl
     R_SUCCEED();
 }
 
-Result SharedBufferManager::WriteAppletCaptureBuffer(bool* out_was_written, s32* out_layer_index, CaptureKind kind) {
+Result SharedBufferManager::WriteAppletCaptureBuffer(bool* out_was_written, s32* out_layer_index) {
-    std::scoped_lock lk{m_guard};
+    std::vector<u8> capture_buffer(m_system.GPU().GetAppletCaptureBuffer());
-    R_UNLESS(m_buffer_page_group != nullptr, VI::ResultNotFound);
+    Common::ScratchBuffer<u32> scratch;
 
-    const std::vector<u8> capture = m_system.GPU().GetAppletCaptureBuffer();
+    // TODO: this could be optimized
-    const u32 slot = GetCaptureSlot(kind);
+    s64 e = -1280 * 768 * 4;
+    for (auto& block : *m_buffer_page_group) {
+        u8* start = m_system.DeviceMemory().GetPointer<u8>(block.GetAddress());
+        u8* end = m_system.DeviceMemory().GetPointer<u8>(block.GetAddress() + block.GetSize());
 
-    if (capture.size() < SharedBufferSlotSize) {
+        for (; start < end; start++) {
-        //LOG_WARNING(Service_VI, "Capture buffer is {} bytes, expected at least {}; not writing",
+            *start = 0;
-        //            capture.size(), SharedBufferSlotSize);
+            if (e >= 0 && e < static_cast<s64>(capture_buffer.size())) {
-        *out_was_written = false;
+                *start = capture_buffer[e];
-        *out_layer_index = static_cast<s32>(slot);
+            }
-        R_SUCCEED();
+            e++;
+        }
+
+        m_system.GPU().Host1x().MemoryManager().ApplyOpOnPointer(start, scratch, [&](DAddr addr) {
+            m_system.GPU().InvalidateRegion(addr, end - start);
+        });
     }
 
-    ForEachPoolChunk(m_system, *m_buffer_page_group, u64{slot} * SharedBufferSlotSize,
-                     SharedBufferSlotSize,
-                     [&](u8* dst, u64 src_offset, u64 length) {
-                         std::memcpy(dst, capture.data() + src_offset, length);
-                     });
-
     *out_was_written = true;
-    *out_layer_index = static_cast<s32>(slot);
+    *out_layer_index = 1;
-    R_SUCCEED();
-}
-
-Result SharedBufferManager::ClearAppletCaptureBuffer(s32 layer_index, u32 color) {
-    std::scoped_lock lk{m_guard};
-    R_UNLESS(m_buffer_page_group != nullptr, VI::ResultNotFound);
-
-    if (layer_index < 0 || layer_index >= static_cast<s32>(SharedBufferNumCaptureSlots)) {
-        LOG_WARNING(Service_VI, "Couldnt clear non-capture slot {}", layer_index);
-        R_SUCCEED();
-    }
-
-    ForEachPoolChunk(m_system, *m_buffer_page_group, u64{static_cast<u32>(layer_index)} * SharedBufferSlotSize,
-                     SharedBufferSlotSize, [&](u8* dst, u64 src_offset, u64 length) {
-                         ASSERT(src_offset % sizeof(u32) == 0 && length % sizeof(u32) == 0);
-                         std::fill_n(reinterpret_cast<u32*>(dst), length / sizeof(u32), color);
-                     });
-
     R_SUCCEED();
 }
 

src/core/hle/service/vi/shared_buffer_manager.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -48,12 +48,6 @@ static_assert(sizeof(SharedMemoryPoolLayout) == 0x188, "SharedMemoryPoolLayout h
 
 struct SharedBufferSession;
 
-enum class CaptureKind : u32 {
-    LastApplication,
-    LastForeground,
-    CallerApplet,
-};
-
 class SharedBufferManager final {
 public:
     explicit SharedBufferManager(Core::System& system, Container& container,
@@ -74,15 +68,9 @@ public:
     Result CancelSharedFrameBuffer(u64 layer_id, s64 slot);
     Result GetSharedFrameBufferAcquirableEvent(Kernel::KReadableEvent** out_event, u64 layer_id);
 
-    Result WriteAppletCaptureBuffer(bool* out_was_written, s32* out_layer_index, CaptureKind kind);
+    Result WriteAppletCaptureBuffer(bool* out_was_written, s32* out_layer_index);
-    Result ClearAppletCaptureBuffer(s32 layer_index, u32 color);
 
 private:
-    const SharedBufferSession* FindSessionByLayerIdLocked(u64 layer_id) const;
-
-    /// Converts a pool slot index, which is what the guest works in, back to the buffer queues slot index
-    Result GetProducerSlotLocked(s32* out_producer_slot, u64 layer_id, s64 pool_slot) const;
-
     u64 m_next_buffer_id = 1;
     u64 m_display_id = 0;
     u64 m_buffer_id = 0;
@@ -101,7 +89,6 @@ struct SharedBufferSession {
     Nvidia::NvCore::SessionId session_id = {};
     u64 layer_id = {};
     u32 buffer_nvmap_handle = 0;
-    u32 presentation_slot_base = 0;
 };
 
 } // namespace Service::VI

src/core/loader/loader.cpp

@@ -17,8 +17,6 @@
 #include "core/core.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/common_funcs.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/submission_package.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/loader/deconstructed_rom_directory.h"
@@ -43,38 +41,6 @@ std::optional<FileType> IdentifyFileLoader(FileSys::VirtualFile file) {
     return std::nullopt;
 }
 
-struct IndexedProgram {
-    FileSys::VirtualFile file;
-    u64 program_id;
-    bool update_only;
-};
-
-std::optional<IndexedProgram> ResolveIndexedProgram(Core::System& system, u64 program_id,
-                                                    std::size_t program_index) {
-    if (program_index == 0 || program_id == 0) {
-        return std::nullopt;
-    }
-
-    const auto target_id = FileSys::GetBaseTitleIDWithProgramIndex(program_id, program_index);
-    const auto& provider = system.GetContentProvider();
-
-    if (auto base = provider.GetEntryRaw(target_id, FileSys::ContentRecordType::Program)) {
-        LOG_INFO(Loader, "Program index {} resolved to {:016X}", program_index, target_id);
-        return IndexedProgram{std::move(base), target_id, false};
-    }
-
-    const auto update_id = FileSys::GetUpdateTitleID(target_id);
-    if (auto update = provider.GetEntryRaw(update_id, FileSys::ContentRecordType::Program)) {
-        LOG_INFO(Loader, "Program index {} has no base program, loading it from update {:016X}",
-                 program_index, update_id);
-        return IndexedProgram{std::move(update), target_id, true};
-    }
-
-    LOG_WARNING(Loader, "No program NCA for {:016X} (index {}), falling back to the container",
-                target_id, program_index);
-    return std::nullopt;
-}
-
 std::shared_ptr<FileSys::NSP> OpenContainerAsNsp(FileSys::VirtualFile file, FileType type,
                                                  u64 program_id = 0,
                                                  std::size_t program_index = 0) {
@@ -355,11 +321,6 @@ std::unique_ptr<AppLoader> GetLoader(Core::System& system, FileSys::VirtualFile
         return nullptr;
     }
 
-    if (const auto indexed = ResolveIndexedProgram(system, program_id, program_index)) {
-        return std::make_unique<AppLoader_NCA>(
-            indexed->file, indexed->update_only ? indexed->program_id : 0);
-    }
-
     FileType type = IdentifyFile(file);
     const FileType filename_type = GuessFromFilename(file->GetName());
 

src/core/loader/nca.cpp

@@ -12,9 +12,7 @@
 #include "common/scope_exit.h"
 #include "core/core.h"
 #include "core/file_sys/content_archive.h"
-#include "core/file_sys/control_metadata.h"
 #include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs_factory.h"
 #include "core/hle/kernel/k_process.h"
@@ -35,14 +33,8 @@ static u32 CalculatePointerBufferSize(size_t heap_size) {
     }
 }
 
-AppLoader_NCA::AppLoader_NCA(FileSys::VirtualFile file_, u64 update_only_program_id_)
+AppLoader_NCA::AppLoader_NCA(FileSys::VirtualFile file_)
-    : AppLoader(std::move(file_)),
+    : AppLoader(std::move(file_)), nca(std::make_unique<FileSys::NCA>(file)) {}
-      nca(std::make_unique<FileSys::NCA>(file, nullptr, update_only_program_id_ != 0)),
-      update_only_program_id(update_only_program_id_) {}
-
-u64 AppLoader_NCA::GetProgramId() const {
-    return update_only_program_id != 0 ? update_only_program_id : nca->GetTitleId();
-}
 
 AppLoader_NCA::~AppLoader_NCA() = default;
 
@@ -118,21 +110,11 @@ AppLoader_NCA::LoadResult AppLoader_NCA::Load(Kernel::KProcess& process, Core::S
     }
 
     LOG_INFO(Loader, "Set pointer buffer size to {:#x} bytes for ProgramID {:#018x} (Heap size: {:#x})",
-             process.GetPointerBufferSize(), GetProgramId(), heap_size);
+             process.GetPointerBufferSize(), nca->GetTitleId(), heap_size);
-
-    auto metadata =
-        FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, this->GetProgramId());
-    if (metadata.first != nullptr) {
-        nacp = std::move(metadata.first);
-        LOG_INFO(Loader, "Control data for {:016X}: name=\"{}\" supported_languages={:08X}",
-                 this->GetProgramId(), nacp->GetApplicationName(), nacp->GetSupportedLanguages());
-    } else {
-        LOG_WARNING(Loader, "No control data found for program {:016X}", this->GetProgramId());
-    }
 
     // Register the process in the file system controller
     system.GetFileSystemController().RegisterProcess(
-        process.GetProcessId(), GetProgramId(),
+        process.GetProcessId(), nca->GetTitleId(),
         std::make_shared<FileSys::RomFSFactory>(*this, system.GetContentProvider(),
                                                 system.GetFileSystemController()));
 
@@ -240,25 +222,7 @@ ResultStatus AppLoader_NCA::ReadProgramId(u64& out_program_id) {
         return ResultStatus::ErrorNotInitialized;
     }
 
-    out_program_id = GetProgramId();
+    out_program_id = nca->GetTitleId();
-    return ResultStatus::Success;
-}
-
-ResultStatus AppLoader_NCA::ReadControlData(FileSys::NACP& out_control) {
-    if (nacp == nullptr) {
-        return ResultStatus::ErrorNoControl;
-    }
-
-    out_control = *nacp;
-    return ResultStatus::Success;
-}
-
-ResultStatus AppLoader_NCA::ReadTitle(std::string& out_title) {
-    if (nacp == nullptr) {
-        return ResultStatus::ErrorNoControl;
-    }
-
-    out_title = nacp->GetApplicationName();
     return ResultStatus::Success;
 }
 

src/core/loader/nca.h

@@ -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
 
@@ -14,7 +11,6 @@ class System;
 }
 
 namespace FileSys {
-class NACP;
 class NCA;
 }
 
@@ -25,7 +21,7 @@ class AppLoader_DeconstructedRomDirectory;
 /// Loads an NCA file
 class AppLoader_NCA final : public AppLoader {
 public:
-    explicit AppLoader_NCA(FileSys::VirtualFile file_, u64 update_only_program_id = 0);
+    explicit AppLoader_NCA(FileSys::VirtualFile file_);
     ~AppLoader_NCA() override;
 
     /**
@@ -47,20 +43,14 @@ public:
 
     ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
     ResultStatus ReadProgramId(u64& out_program_id) override;
-    ResultStatus ReadControlData(FileSys::NACP& out_control) override;
-    ResultStatus ReadTitle(std::string& out_title) override;
 
     ResultStatus ReadBanner(std::vector<u8>& buffer) override;
     ResultStatus ReadLogo(std::vector<u8>& buffer) override;
 
     ResultStatus ReadNSOModules(Modules& modules) override;
 
-    u64 GetProgramId() const;
-
 private:
     std::unique_ptr<FileSys::NCA> nca;
-    u64 update_only_program_id{};
-    std::unique_ptr<FileSys::NACP> nacp;
     std::unique_ptr<AppLoader_DeconstructedRomDirectory> directory_loader;
 };
 

src/core/loader/nso.cpp

@@ -209,10 +209,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
 
     // Apply cheats if they exist and the program has a valid title ID
     if (pm) {
-        // TODO(Maufeat): Check if there is a better way to check
+        system.SetApplicationProcessBuildID(nso_header.build_id);
-        if (name == "main")
-            system.SetApplicationProcessBuildID(nso_header.build_id);
-
         const auto cheats = pm->CreateCheatList(nso_header.build_id);
         if (!cheats.empty()) {
             system.RegisterCheatList(cheats, nso_header.build_id, load_base, image_size);

src/core/loader/nsp.cpp

@@ -8,7 +8,6 @@
 
 #include "common/common_types.h"
 #include "core/core.h"
-#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/nca_metadata.h"
@@ -38,13 +37,13 @@ AppLoader_NSP::AppLoader_NSP(FileSys::VirtualFile file_,
         secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(nsp->GetExeFS(), false);
     } else {
         const auto control_nca =
-            nsp->GetNCA(FileSys::GetBaseTitleID(nsp->GetProgramTitleID()), FileSys::ContentRecordType::Control);
+            nsp->GetNCA(nsp->GetProgramTitleID(), FileSys::ContentRecordType::Control);
         if (control_nca == nullptr || control_nca->GetStatus() != ResultStatus::Success) {
             return;
         }
 
         std::tie(nacp_file, icon_file) = [this, &content_provider, &control_nca, &fsc] {
-            const FileSys::PatchManager pm{FileSys::GetBaseTitleID(nsp->GetProgramTitleID()), fsc, content_provider};
+            const FileSys::PatchManager pm{nsp->GetProgramTitleID(), fsc, content_provider};
             return pm.ParseControlNCA(*control_nca);
         }();
 

src/core/memory/cheat_engine.cpp

@@ -51,41 +51,24 @@ StandardVmCallbacks::StandardVmCallbacks(System& system_, const CheatProcessMeta
 
 StandardVmCallbacks::~StandardVmCallbacks() = default;
 
-Kernel::KProcess* StandardVmCallbacks::GetProcess() const {
-    if (cached_process != nullptr && cached_process_id == metadata.process_id) {
-        return cached_process;
-    }
-
-    auto process = system.Kernel().GetProcessByProcessId(metadata.process_id);
-    cached_process = process.IsNull() ? nullptr : process.GetPointerUnsafe();
-    cached_process_id = metadata.process_id;
-    return cached_process;
-}
-
 void StandardVmCallbacks::MemoryReadUnsafe(VAddr address, void* data, u64 size) {
-    auto* const process = this->GetProcess();
-
     // Return zero on invalid address
-    if (process == nullptr || !IsAddressInRange(address) ||
+    if (!IsAddressInRange(address) || !system.ApplicationMemory().IsValidVirtualAddress(address)) {
-        !process->GetMemory().IsValidVirtualAddress(address)) {
         std::memset(data, 0, size);
         return;
     }
 
-    process->GetMemory().ReadBlock(address, data, size);
+    system.ApplicationMemory().ReadBlock(address, data, size);
 }
 
 void StandardVmCallbacks::MemoryWriteUnsafe(VAddr address, const void* data, u64 size) {
-    auto* const process = this->GetProcess();
-
     // Skip invalid memory write address
-    if (process == nullptr || !IsAddressInRange(address) ||
+    if (!IsAddressInRange(address) || !system.ApplicationMemory().IsValidVirtualAddress(address)) {
-        !process->GetMemory().IsValidVirtualAddress(address)) {
         return;
     }
 
-    if (process->GetMemory().WriteBlock(address, data, size)) {
+    if (system.ApplicationMemory().WriteBlock(address, data, size)) {
-        Core::InvalidateInstructionCacheRange(process, address, size);
+        Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), address, size);
     }
 }
 
@@ -108,16 +91,14 @@ u64 StandardVmCallbacks::HidKeysDown() {
 }
 
 void StandardVmCallbacks::PauseProcess() {
-    auto* const process = this->GetProcess();
+    if (!system.ApplicationProcess()->IsSuspended()) {
-    if (process != nullptr && !process->IsSuspended()) {
+        system.ApplicationProcess()->SetActivity(system.Kernel(), Kernel::Svc::ProcessActivity::Paused);
-        process->SetActivity(system.Kernel(), Kernel::Svc::ProcessActivity::Paused);
     }
 }
 
 void StandardVmCallbacks::ResumeProcess() {
-    auto* const process = this->GetProcess();
+    if (system.ApplicationProcess()->IsSuspended()) {
-    if (process != nullptr && process->IsSuspended()) {
+        system.ApplicationProcess()->SetActivity(system.Kernel(), Kernel::Svc::ProcessActivity::Runnable);
-        process->SetActivity(system.Kernel(), Kernel::Svc::ProcessActivity::Runnable);
     }
 }
 

src/core/memory/cheat_engine.h

@@ -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
 
@@ -18,10 +15,6 @@ namespace Core {
 class System;
 }
 
-namespace Kernel {
-class KProcess;
-}
-
 namespace Core::Timing {
 class CoreTiming;
 struct EventType;
@@ -45,12 +38,8 @@ public:
 private:
     bool IsAddressInRange(VAddr address) const;
 
-    Kernel::KProcess* GetProcess() const;
-
     const CheatProcessMetadata& metadata;
     Core::System& system;
-    mutable Kernel::KProcess* cached_process{};
-    mutable u64 cached_process_id{};
 };
 
 // Intermediary class that parses a text file or other disk format for storing cheats into a

src/core/reporter.cpp

@@ -239,7 +239,7 @@ void Reporter::SaveUnimplementedFunctionReport(Service::HLERequestContext& ctx,
     const auto title_id = system.GetApplicationProcessProgramID();
     auto out = GetFullDataAuto(timestamp, title_id, system);
 
-    auto function_out = GetHLERequestContextData(ctx, ctx.GetMemory());
+    auto function_out = GetHLERequestContextData(ctx, system.ApplicationMemory());
     function_out["command_id"] = command_id;
     function_out["function_name"] = name;
     function_out["service_name"] = service_name;

src/hid_core/hidbus/hidbus_base.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -65,9 +62,8 @@ void HidbusBase::DisablePollingMode() {
     polling_mode_enabled = false;
 }
 
-void HidbusBase::SetTransferMemoryAddress(Common::ProcessAddress t_mem, Kernel::KProcess* owner) {
+void HidbusBase::SetTransferMemoryAddress(Common::ProcessAddress t_mem) {
     transfer_memory = t_mem;
-    transfer_memory_owner = owner;
 }
 
 Kernel::KReadableEvent& HidbusBase::GetSendCommandAsycEvent() const {

src/hid_core/hidbus/hidbus_base.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -17,7 +14,6 @@ class System;
 
 namespace Kernel {
 class KEvent;
-class KProcess;
 class KReadableEvent;
 } // namespace Kernel
 
@@ -142,7 +138,7 @@ public:
     void DisablePollingMode();
 
     // Called on EnableJoyPollingReceiveMode
-    void SetTransferMemoryAddress(Common::ProcessAddress t_mem, Kernel::KProcess* owner);
+    void SetTransferMemoryAddress(Common::ProcessAddress t_mem);
 
     Kernel::KReadableEvent& GetSendCommandAsycEvent() const;
 
@@ -179,7 +175,6 @@ protected:
     ButtonOnlyPollingDataAccessor button_only_data{};
 
     Common::ProcessAddress transfer_memory{};
-    Kernel::KProcess* transfer_memory_owner{};
 
     Core::System& system;
     Kernel::KEvent* send_command_async_event;

src/hid_core/hidbus/ringcon.cpp

@@ -6,7 +6,6 @@
 
 #include "core/core.h"
 #include "core/hle/kernel/k_event.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/memory.h"
 #include "hid_core/frontend/emulated_controller.h"
@@ -68,10 +67,8 @@ void RingController::OnUpdate() {
         curr_entry.polling_data.out_size = sizeof(ringcon_value);
         std::memcpy(curr_entry.polling_data.data.data(), &ringcon_value, sizeof(ringcon_value));
 
-        if (transfer_memory_owner != nullptr) {
+        system.ApplicationMemory().WriteBlock(transfer_memory, &enable_sixaxis_data,
-            transfer_memory_owner->GetMemory().WriteBlock(transfer_memory, &enable_sixaxis_data,
+                                              sizeof(enable_sixaxis_data));
-                                                          sizeof(enable_sixaxis_data));
-        }
         break;
     }
     default:

src/hid_core/irsensor/image_transfer_processor.cpp

@@ -1,11 +1,10 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "core/core.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/memory.h"
 #include "hid_core/frontend/emulated_controller.h"
 #include "hid_core/hid_core.h"
@@ -49,12 +48,10 @@ void ImageTransferProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType
     if (type != Core::HID::ControllerTriggerType::IrSensor) {
         return;
     }
-    if (transfer_memory == 0 || transfer_memory_owner == nullptr) {
+    if (transfer_memory == 0) {
         return;
     }
 
-    auto& memory = transfer_memory_owner->GetMemory();
-
     const auto& camera_data = npad_device->GetCamera();
 
     // This indicates how much ambient light is present
@@ -64,14 +61,16 @@ void ImageTransferProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType
     if (camera_data.format != current_config.origin_format) {
         LOG_WARNING(Service_IRS, "Wrong Input format {} expected {}", camera_data.format,
                     current_config.origin_format);
-        memory.ZeroBlock(transfer_memory, GetDataSize(current_config.trimming_format));
+        system.ApplicationMemory().ZeroBlock(transfer_memory,
+                                             GetDataSize(current_config.trimming_format));
         return;
     }
 
     if (current_config.origin_format > current_config.trimming_format) {
         LOG_WARNING(Service_IRS, "Origin format {} is smaller than trimming format {}",
                     current_config.origin_format, current_config.trimming_format);
-        memory.ZeroBlock(transfer_memory, GetDataSize(current_config.trimming_format));
+        system.ApplicationMemory().ZeroBlock(transfer_memory,
+                                             GetDataSize(current_config.trimming_format));
         return;
     }
 
@@ -88,7 +87,8 @@ void ImageTransferProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType
                     "Trimming area ({}, {}, {}, {}) is outside of origin area ({}, {})",
                     current_config.trimming_start_x, current_config.trimming_start_y,
                     trimming_width, trimming_height, origin_width, origin_height);
-        memory.ZeroBlock(transfer_memory, GetDataSize(current_config.trimming_format));
+        system.ApplicationMemory().ZeroBlock(transfer_memory,
+                                             GetDataSize(current_config.trimming_format));
         return;
     }
 
@@ -102,8 +102,8 @@ void ImageTransferProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType
         }
     }
 
-    memory.WriteBlock(transfer_memory, window_data.data(),
+    system.ApplicationMemory().WriteBlock(transfer_memory, window_data.data(),
-                      GetDataSize(current_config.trimming_format));
+                                          GetDataSize(current_config.trimming_format));
 
     if (!IsProcessorActive()) {
         StartProcessor();
@@ -143,19 +143,14 @@ void ImageTransferProcessor::SetConfig(
     npad_device->SetCameraFormat(current_config.origin_format);
 }
 
-void ImageTransferProcessor::SetTransferMemoryAddress(Common::ProcessAddress t_mem,
+void ImageTransferProcessor::SetTransferMemoryAddress(Common::ProcessAddress t_mem) {
-                                                      Kernel::KProcess* owner) {
     transfer_memory = t_mem;
-    transfer_memory_owner = owner;
 }
 
 Core::IrSensor::ImageTransferProcessorState ImageTransferProcessor::GetState(
     std::span<u8> data) const {
-    if (transfer_memory_owner == nullptr)
-        return processor_state;
-
     const auto size = (std::min)(GetDataSize(current_config.trimming_format), data.size());
-    transfer_memory_owner->GetMemory().ReadBlock(transfer_memory, data.data(), size);
+    system.ApplicationMemory().ReadBlock(transfer_memory, data.data(), size);
     return processor_state;
 }
 

src/hid_core/irsensor/image_transfer_processor.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -12,10 +9,6 @@
 #include "hid_core/irsensor/irs_types.h"
 #include "hid_core/irsensor/processor_base.h"
 
-namespace Kernel {
-class KProcess;
-}
-
 namespace Core {
 class System;
 }
@@ -46,7 +39,7 @@ public:
     void SetConfig(Core::IrSensor::PackedImageTransferProcessorExConfig config);
 
     // Transfer memory where the image data will be stored
-    void SetTransferMemoryAddress(Common::ProcessAddress t_mem, Kernel::KProcess* owner);
+    void SetTransferMemoryAddress(Common::ProcessAddress t_mem);
 
     Core::IrSensor::ImageTransferProcessorState GetState(std::span<u8> data) const;
 
@@ -82,6 +75,5 @@ private:
 
     Core::System& system;
     Common::ProcessAddress transfer_memory{};
-    Kernel::KProcess* transfer_memory_owner{};
 };
 } // namespace Service::IRS