2026-09-15 19:23:45

Signed-off-by: lizzie <lizzie@eden-emu.dev>
2026-09-14 09:32:00
2026-09-17 08:37:43 +00:00 · 2026-09-15 19:23:45 +00:00 · 2026-09-15 22:12:39 +02:00 · 2026-09-15 22:12:39 +02:00 · 2026-09-15 22:12:39 +02:00 · 2026-09-15 22:12:39 +02:00
33 changed files with 722 additions and 972 deletions
@@ -1,13 +0,0 @@
-diff --git a/libs/cobalt/include/boost/cobalt/concepts.hpp b/libs/cobalt/include/boost/cobalt/concepts.hpp
-index d49f2ec..a9bdb80 100644
--- a/libs/cobalt/include/boost/cobalt/concepts.hpp
-+++ b/libs/cobalt/include/boost/cobalt/concepts.hpp
-@@ -62,7 +62,7 @@ struct enable_awaitables
- template <typename T>
- concept with_get_executor = requires (T& t)
- {
-  {t.get_executor()} -> asio::execution::executor;
-+  t.get_executor();
- };
- 
- 
@@ -1,28 +0,0 @@
-From cc15da16e533b2a801934eab2dfeaf3c3949a1dc Mon Sep 17 00:00:00 2001
-From: crueter <crueter@eden-emu.dev>
-Date: Mon, 8 Sep 2025 12:28:55 -0400
-Subject: [PATCH] [cmake] disable NEON runtime check on clang-cl
-
-When enabling runtime NEON checking for clang-cl, the linker would error out with `undefined symbol: __emit`, since clang doesn't actually implement this instruction. Therefore it makes sense to disable the runtime check by default on this platform, until either this is fixed or a clang-cl compatible intrinsic check is added (I don't have enough knowledge of MSVC to do this)
---
- cmake/OpusConfig.cmake | 7 ++++++-
- 1 file changed, 6 insertions(+), 1 deletion(-)
-
-diff --git a/cmake/OpusConfig.cmake b/cmake/OpusConfig.cmake
-index e9319fbad..d0f459e88 100644
--- a/cmake/OpusConfig.cmake
-+++ b/cmake/OpusConfig.cmake
-@@ -71,7 +71,12 @@ elseif(OPUS_CPU_ARM AND NOT OPUS_DISABLE_INTRINSICS)
-   opus_detect_neon(COMPILER_SUPPORT_NEON)
-   if(COMPILER_SUPPORT_NEON)
-     option(OPUS_USE_NEON "Option to enable NEON" ON)
-    option(OPUS_MAY_HAVE_NEON "Does runtime check for neon support" ON)
-+    if (MSVC AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-+      set(NEON_RUNTIME_CHECK_DEFAULT OFF)
-+    else()
-+      set(NEON_RUNTIME_CHECK_DEFAULT ON)
-+    endif()
-+    option(OPUS_MAY_HAVE_NEON "Does runtime check for neon support" ${NEON_RUNTIME_CHECK_DEFAULT})
-     option(OPUS_PRESUME_NEON "Assume target CPU has NEON support" OFF)
-     if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-       set(OPUS_PRESUME_NEON ON)
@@ -1,153 +0,0 @@
-From bf455b67b4eaa446ffae5d25410b141b7b1b1082 Mon Sep 17 00:00:00 2001
-From: crueter <crueter@eden-emu.dev>
-Date: Mon, 8 Sep 2025 12:08:20 -0400
-Subject: [PATCH] [cmake] `OPUS_INSTALL` option; only default install if root
- project
-
-Signed-off-by: crueter <crueter@eden-emu.dev>
---
- CMakeLists.txt | 112 ++++++++++++++++++++++++++++---------------------
- 1 file changed, 64 insertions(+), 48 deletions(-)
-
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index fcf034b19..08b5e16f8 100644
--- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -4,6 +4,13 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
- include(OpusPackageVersion)
- get_package_version(PACKAGE_VERSION PROJECT_VERSION)
- 
-+# root project detection
-+if(DEFINED PROJECT_NAME)
-+  set(root_project OFF)
-+else()
-+  set(root_project ON)
-+endif()
-+
- project(Opus LANGUAGES C VERSION ${PROJECT_VERSION})
- 
- include(OpusFunctions)
-@@ -83,12 +90,16 @@ set(OPUS_DNN_FLOAT_DEBUG_HELP_STR "Run DNN computations as float for debugging p
- option(OPUS_DNN_FLOAT_DEBUG ${OPUS_DNN_FLOAT_DEBUG_HELP_STR} OFF)
- add_feature_info(OPUS_DNN_FLOAT_DEBUG OPUS_DNN_FLOAT_DEBUG ${OPUS_DNN_FLOAT_DEBUG_HELP_STR})
- 
-+set(OPUS_INSTALL_HELP_STR "Install Opus targets")
-+option(OPUS_INSTALL ${OPUS_INSTALL_HELP_STR} ${root_project})
-+add_feature_info(OPUS_INSTALL OPUS_INSTALL ${OPUS_INSTALL_HELP_STR})
-+
- set(OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR "install pkg-config module.")
-option(OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR} ON)
-+option(OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR} ${OPUS_INSTALL})
- add_feature_info(OPUS_INSTALL_PKG_CONFIG_MODULE OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR})
- 
- set(OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR "install CMake package config module.")
-option(OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR} ON)
-+option(OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR} ${OPUS_INSTALL})
- add_feature_info(OPUS_INSTALL_CMAKE_CONFIG_MODULE OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR})
- 
- set(OPUS_DRED_HELP_STR "enable DRED.")
-@@ -613,53 +624,58 @@ if(OPUS_BUILD_FRAMEWORK)
-                         OUTPUT_NAME Opus)
- endif()
- 
-install(TARGETS opus
-        EXPORT OpusTargets
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-        FRAMEWORK DESTINATION ${CMAKE_INSTALL_PREFIX}
-        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/opus)
-
-if(OPUS_INSTALL_PKG_CONFIG_MODULE)
-  set(prefix ${CMAKE_INSTALL_PREFIX})
-  set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-  set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
-  set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
-  set(VERSION ${PACKAGE_VERSION})
-  if(HAVE_LIBM)
-    set(LIBM "-lm")
-+if (OPUS_INSTALL)
-+  install(TARGETS opus
-+          EXPORT OpusTargets
-+          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-+          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-+          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-+          FRAMEWORK DESTINATION ${CMAKE_INSTALL_PREFIX}
-+          PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/opus)
-+
-+  if(OPUS_INSTALL_PKG_CONFIG_MODULE)
-+    set(prefix ${CMAKE_INSTALL_PREFIX})
-+    set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-+    set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
-+    set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
-+    set(VERSION ${PACKAGE_VERSION})
-+    if(HAVE_LIBM)
-+      set(LIBM "-lm")
-+    endif()
-+    configure_file(opus.pc.in opus.pc)
-+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/opus.pc
-+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-+  endif()
-+
-+  if(OPUS_INSTALL_CMAKE_CONFIG_MODULE)
-+    set(CPACK_GENERATOR TGZ)
-+    include(CPack)
-+    set(CMAKE_INSTALL_PACKAGEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
-+    install(EXPORT OpusTargets
-+            NAMESPACE Opus::
-+            DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
-+
-+    include(CMakePackageConfigHelpers)
-+
-+    set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
-+    configure_package_config_file(
-+      ${PROJECT_SOURCE_DIR}/cmake/OpusConfig.cmake.in
-+      OpusConfig.cmake
-+      INSTALL_DESTINATION
-+      ${CMAKE_INSTALL_PACKAGEDIR}
-+      PATH_VARS
-+      INCLUDE_INSTALL_DIR
-+      INSTALL_PREFIX
-+      ${CMAKE_INSTALL_PREFIX})
-+
-+    write_basic_package_version_file(OpusConfigVersion.cmake
-+                                    VERSION ${PROJECT_VERSION}
-+                                    COMPATIBILITY SameMajorVersion)
-+
-+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/OpusConfig.cmake
-+                  ${CMAKE_CURRENT_BINARY_DIR}/OpusConfigVersion.cmake
-+            DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
-   endif()
-  configure_file(opus.pc.in opus.pc)
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/opus.pc
-          DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-endif()
-
-if(OPUS_INSTALL_CMAKE_CONFIG_MODULE)
-  set(CPACK_GENERATOR TGZ)
-  include(CPack)
-  set(CMAKE_INSTALL_PACKAGEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
-  install(EXPORT OpusTargets
-          NAMESPACE Opus::
-          DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
-
-  include(CMakePackageConfigHelpers)
-
-  set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
-  configure_package_config_file(${PROJECT_SOURCE_DIR}/cmake/OpusConfig.cmake.in
-                                OpusConfig.cmake
-                                INSTALL_DESTINATION
-                                ${CMAKE_INSTALL_PACKAGEDIR}
-                                PATH_VARS
-                                INCLUDE_INSTALL_DIR
-                                INSTALL_PREFIX
-                                ${CMAKE_INSTALL_PREFIX})
-  write_basic_package_version_file(OpusConfigVersion.cmake
-                                   VERSION ${PROJECT_VERSION}
-                                   COMPATIBILITY SameMajorVersion)
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/OpusConfig.cmake
-                ${CMAKE_CURRENT_BINARY_DIR}/OpusConfigVersion.cmake
-          DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
- endif()
- 
- if(OPUS_BUILD_PROGRAMS)
@@ -417,12 +417,9 @@ AddJsonPackage(boost)
 set(BOOST_NO_HEADERS ${Boost_ADDED})

 if (Boost_ADDED)
-    if (MSVC OR ANDROID)
-        add_compile_definitions(YUZU_BOOST_v1)
-    endif()
-
+    add_compile_definitions(YUZU_BOOST_v1)
    if (NOT MSVC OR CXX_CLANG)
-        # boost sucks
+        # solaris sucks
        if (SOLARIS)
            add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthreads>)
        endif()
@@ -431,8 +428,7 @@ if (Boost_ADDED)
        target_compile_options(boost_icl INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
        target_compile_options(boost_asio INTERFACE
            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>
-        )
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>)
    endif()
 endif()

@@ -464,21 +460,6 @@ if (NOT YUZU_STATIC_ROOM)
    if (ZLIB_ADDED)
        add_library(ZLIB::ZLIB ALIAS zlibstatic)
    endif()
-
-    # Opus
-    AddJsonPackage(opus)
-
-    if (Opus_ADDED)
-        if (MSVC AND CXX_CLANG)
-            target_compile_options(opus PRIVATE
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-function-declaration>
-            )
-        endif()
-    endif()
-
-    if (NOT TARGET Opus::opus)
-        add_library(Opus::opus ALIAS opus)
-    endif()
 endif()

 if(NOT TARGET Boost::headers)
@@ -1,22 +0,0 @@
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-# SPDX-FileCopyrightText: 2022 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-find_package(PkgConfig QUIET)
-pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Opus
-    REQUIRED_VARS OPUS_LINK_LIBRARIES
-    VERSION_VAR OPUS_VERSION
-)
-
-if (MSYS2)
-    FixMsysPath(PkgConfig::OPUS)
-endif()
-
-if (Opus_FOUND AND NOT TARGET Opus::opus)
-    add_library(Opus::opus ALIAS PkgConfig::OPUS)
-endif()
@@ -6,22 +6,19 @@
        "version": "v0.19.0"
    },
    "boost": {
-        "artifact": "%VERSION%-cmake.tar.xz",
+        "artifact": "boost-%VERSION%.tar.zst",
        "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",
-        "hash": "6ae6e94664fe7f2fb01976b59b276ac5df8085c7503fa829d810fbfe495960cfec44fa2c36e2cb23480bc19c956ed199d4952b02639a00a6c07625d4e7130c2d",
+        "hash": "681d97be4386767662e230b2e7c9754d45e709cc5db4e747c23c27d1f5b0e87770bdf19b0bc44dcb0e8349324887bbb8fffb432098f4d0ce74a5043021a90afc",
        "min_version": "1.57",
        "package": "Boost",
-        "patches": [
-            "0001-clang-cl.patch"
-        ],
-        "repo": "boostorg/boost",
-        "version": "boost-1.90.0"
+        "repo": "eden-emulator/ext-boost",
+        "version": "1.92.0"
    },
    "boost_headers": {
        "bundled": true,
-        "hash": "4ef845775e2277a8104ded6ddf749aa262ce52cf8438042869a048f9a0156dd772fbbcfa74efa1378fecef339b7286f6fe4b4feb5c45d49966b35d08e3e83507",
+        "hash": "c5fa2cd72f6e6666b7963b97bc359c75284b8fb540c30f3629a028b85270c9bc66c8a051383964f2bd4c1e005a4691593d15696e7ef39ea87cf6cff9e5691fb2",
        "repo": "boostorg/headers",
-        "version": "boost-1.90.0"
+        "version": "boost-1.91.0"
    },
    "catch2": {
        "hash": "7eea385d79d88a5690cde131fe7ccda97d5c54ea09d6f515000d7bf07c828809d61c1ac99912c1ee507cf933f61c1c47ecdcc45df7850ffa82714034b0fccf35",
@@ -82,7 +79,7 @@
        "name": "ffmpeg",
        "package": "FFmpeg",
        "repo": "crueter-ci/FFmpeg",
-        "version": "9.0.1-1788120736-bf1b838f2a"
+        "version": "9.0.1-1788303113-bf1b838f2a"
    },
    "fmt": {
        "hash": "f0da82c545b01692e9fd30fdfb613dbb8dd9716983dcd0ff19ac2a8d36f74beb5540ef38072fdecc1e34191b3682a8542ecbf3a61ef287dbba0a2679d4e023f2",
@@ -210,21 +207,6 @@
        "repo": "jimmy-park/openssl-cmake",
        "version": "3.6.2"
    },
-    "opus": {
-        "find_args": "MODULE",
-        "hash": "9506147b0de35befda8633ff272981cc2575c860874791bd455b752f797fd7dbd1079f0ba42ccdd7bb1fe6773fa5e84b3d75667c2883dd1fb2d0e4a5fa4f8387",
-        "min_version": "1.3",
-        "options": [
-            "OPUS_PRESUME_NEON ON"
-        ],
-        "package": "Opus",
-        "patches": [
-            "0001-disable-clang-runtime-neon.patch",
-            "0002-no-install.patch"
-        ],
-        "repo": "xiph/opus",
-        "version": "a3f0ec02b3"
-    },
    "quazip": {
        "hash": "609c240c7f029ac26a37d8fbab51bc16284e05e128b78b9b9c0e95d083538c36047a67d682759ac990e4adb0eeb90f04f1ea7fe2253bbda7e7e3bcce32e53dd8",
        "min_version": "1.3",
@@ -60,7 +60,6 @@ All other dependencies will be downloaded and built by [CPM](https://github.com/
 * [ZLIB](https://www.zlib.net/) 1.2+
 * [zstd](https://facebook.github.io/zstd/) 1.5+
 * [enet](http://enet.bespin.org/) 1.3+
-* [Opus](https://opus-codec.org/) 1.3+

 Vulkan 1.3.274+ is also needed:

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

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

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

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

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

 </details>
@@ -261,7 +260,7 @@ brew install molten-vk

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

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

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

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

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

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

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

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

 [Caveats](./Caveats.md#haikuos).
@@ -12,7 +12,7 @@ pkgs.mkShellNoCC {
    git cmake clang gnumake patch jq pkg-config
    # libraries
    openssl boost fmt nlohmann_json lz4 zlib zstd
-    enet libopus vulkan-headers vulkan-utility-libraries
+    enet vulkan-headers vulkan-utility-libraries
    spirv-tools spirv-headers vulkan-loader unzip
    glslang python3 httplib cpp-jwt ffmpeg-headless
    libusb1 cubeb
@@ -79,13 +79,6 @@ class LicensesFragment : Fragment() {
                R.string.license_ffmpeg_copyright,
                R.string.license_ffmpeg_text
            ),
-            License(
-                R.string.license_opus,
-                R.string.license_opus_description,
-                R.string.license_opus_link,
-                R.string.license_opus_copyright,
-                R.string.license_opus_text
-            ),
            License(
                R.string.license_sirit,
                R.string.license_sirit_description,
@@ -1784,51 +1784,6 @@ RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
 FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 DAMAGES.
-    </string>
-    <string name="license_opus" translatable="false">Opus</string>
-    <string name="license_opus_description" translatable="false">Modern audio compression for the internet</string>
-    <string name="license_opus_link" translatable="false">https://github.com/xiph/opus</string>
-    <string name="license_opus_copyright" translatable="false">Copyright 2001–2011 Xiph.Org, Skype Limited, Octasic, Jean-Marc Valin, Timothy B. Terriberry, CSIRO, Gregory Maxwell, Mark Borgerding, Erik de Castro Lopo</string>
-    <string name="license_opus_text" translatable="false">
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:\n\n
-
- Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.\n\n
-
- Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.\n\n
-
- Neither the name of Internet Society, IETF or IETF Trust, nor the
-names of specific contributors, may be used to endorse or promote
-products derived from this software without specific prior written
-permission.\n\n
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-``AS IS\'\' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n
-
-Opus is subject to the royalty-free patent licenses which are
-specified at:\n\n
-
-Xiph.Org Foundation:
-https://datatracker.ietf.org/ipr/1524/ \n\n
-
-Microsoft Corporation:
-https://datatracker.ietf.org/ipr/1914/ \n\n
-
-Broadcom Corporation:
-https://datatracker.ietf.org/ipr/1526/
    </string>
    <string name="license_sirit" translatable="false">Sirit</string>
    <string name="license_sirit_description" translatable="false">A runtime SPIR-V assembler</string>
@@ -15,10 +15,6 @@ add_library(audio_core STATIC
    adsp/apps/audio_renderer/command_list_processor.h
    adsp/apps/opus/opus_decoder.cpp
    adsp/apps/opus/opus_decoder.h
-    adsp/apps/opus/opus_decode_object.cpp
-    adsp/apps/opus/opus_decode_object.h
-    adsp/apps/opus/opus_multistream_decode_object.cpp
-    adsp/apps/opus/opus_multistream_decode_object.h
    adsp/apps/opus/shared_memory.h
    audio_core.cpp
    audio_core.h
@@ -226,8 +222,14 @@ else()
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>)
 endif()

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

 if (ENABLE_CUBEB)
    target_sources(audio_core PRIVATE
@@ -1,110 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "audio_core/adsp/apps/opus/opus_decode_object.h"
-#include "common/assert.h"
-
-namespace AudioCore::ADSP::OpusDecoder {
-namespace {
-bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
-}
-} // namespace
-
-u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {
-    if (!IsValidChannelCount(channel_count)) {
-        return 0;
-    }
-    return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
-}
-
-OpusDecodeObject& OpusDecodeObject::Initialize(u64 buffer, u64 buffer2) {
-    auto* new_decoder = reinterpret_cast<OpusDecodeObject*>(buffer);
-    auto* comparison = reinterpret_cast<OpusDecodeObject*>(buffer2);
-
-    if (new_decoder->magic == DecodeObjectMagic) {
-        if (!new_decoder->initialized ||
-            (new_decoder->initialized && new_decoder->self == comparison)) {
-            new_decoder->state_valid = true;
-        }
-    } else {
-        new_decoder->initialized = false;
-        new_decoder->state_valid = true;
-    }
-    return *new_decoder;
-}
-
-s32 OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        return OPUS_OK;
-    }
-
-    // Unfortunately libopus does not expose the OpusDecoder struct publicly, so we can't include
-    // it in this class. Nintendo does not allocate memory, which is why we have a workbuffer
-    // provided.
-    // We could use _create and have libopus allocate it for us, but then we have to separately
-    // track which decoder is being used between this and multistream in order to call the correct
-    // destroy from the host side.
-    // This is a bit cringe, but is safe as these objects are only ever initialized inside the given
-    // workbuffer, and GetWorkBufferSize will guarantee there's enough space to follow.
-    decoder = (LibOpusDecoder*)(this + 1);
-    s32 ret = opus_decoder_init(decoder, sample_rate, channel_count);
-    if (ret == OPUS_OK) {
-        magic = DecodeObjectMagic;
-        initialized = true;
-        state_valid = true;
-        self = this;
-        final_range = 0;
-    }
-    return ret;
-}
-
-s32 OpusDecodeObject::Shutdown() {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        magic = 0x0;
-        initialized = false;
-        state_valid = false;
-        self = nullptr;
-        final_range = 0;
-        decoder = nullptr;
-    }
-    return OPUS_OK;
-}
-
-s32 OpusDecodeObject::ResetDecoder() {
-    return opus_decoder_ctl(decoder, OPUS_RESET_STATE);
-}
-
-s32 OpusDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size,
-                             u64 input_data, u64 input_data_size) {
-    ASSERT(initialized);
-    out_sample_count = 0;
-
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    auto ret_code_or_samples = opus_decode(
-        decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),
-        reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);
-
-    if (ret_code_or_samples < OPUS_OK) {
-        return ret_code_or_samples;
-    }
-
-    out_sample_count = ret_code_or_samples;
-    return opus_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
-}
-
-} // namespace AudioCore::ADSP::OpusDecoder
@@ -1,41 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <opus.h>
-
-#include "common/common_types.h"
-
-namespace AudioCore::ADSP::OpusDecoder {
-using LibOpusDecoder = ::OpusDecoder;
-static constexpr u32 DecodeObjectMagic = 0xDEADBEEF;
-
-class OpusDecodeObject {
-public:
-    static u32 GetWorkBufferSize(u32 channel_count);
-    static OpusDecodeObject& Initialize(u64 buffer, u64 buffer2);
-
-    s32 InitializeDecoder(u32 sample_rate, u32 channel_count);
-    s32 Shutdown();
-    s32 ResetDecoder();
-    s32 Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data,
-               u64 input_data_size);
-    u32 GetFinalRange() const noexcept {
-        return final_range;
-    }
-
-private:
-    u32 magic;
-    bool initialized;
-    bool state_valid;
-    OpusDecodeObject* self;
-    u32 final_range;
-    LibOpusDecoder* decoder;
-};
-static_assert(std::is_trivially_constructible_v<OpusDecodeObject>);
-
-} // namespace AudioCore::ADSP::OpusDecoder
@@ -5,55 +5,445 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <array>
-#include <chrono>

-#include "audio_core/adsp/apps/opus/opus_decode_object.h"
-#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
+extern "C" {
+#include <libswresample/swresample.h>
+#include <libavcodec/avcodec.h>
+#include <libavcodec/codec.h>
+#include <libavcodec/packet.h>
+#include <libavutil/channel_layout.h>
+#include <libavutil/frame.h>
+#include <libavutil/opt.h>
+#include <libavutil/samplefmt.h>
+}
+
 #include "audio_core/adsp/apps/opus/shared_memory.h"
 #include "audio_core/audio_core.h"
-#include "audio_core/common/common.h"
 #include "common/logging.h"
 #include "common/thread.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/hle/service/audio/errors.h"

 namespace AudioCore::ADSP::OpusDecoder {

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

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

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

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

-OpusDecoder::OpusDecoder(Core::System& system_) : system{system_} {
-    init_thread = std::jthread([this](std::stop_token stop_token) { Init(stop_token); });
+OpusDecoder::OpusDecoder(Core::System& system) {
+    dsp_thread = std::jthread([this, &system](std::stop_token stop_token) {
+        Common::SetCurrentThreadName("DSP_OpusDecoder");
+        if (Receive(Direction::DSP, stop_token) != Message::Start) {
+            LOG_ERROR(Service_Audio, "DSP OpusDecoder failed to receive Start message. Opus initialization failed.");
+            return;
+        }
+        Send(Direction::Host, Message::StartOK);
+
+        // Main OpusDecoder thread, responsible for processing the incoming Opus packets.
+        ::Common::unordered_map<u64, OpusGenericDecodeObject> decode_objects;
+        // Staging buffers used by various decoders
+        // 1 <= channels <= 2, then, UPB channels => 2
+        // 64K is enough for most
+        OpusGenericDecodeParams params{};
+        av_samples_alloc(params.tmp_buf, nullptr, 2, (int)0x10000, AV_SAMPLE_FMT_S16, 0);
+        params.pkt = av_packet_alloc();
+        params.frame = av_frame_alloc();
+
+        // opus fltp -> libopus s16 software converters
+        AVChannelLayout channel_layouts[2];
+        av_channel_layout_default(&channel_layouts[0], 1);
+        av_channel_layout_default(&channel_layouts[1], 2);
+        int r;
+        int const sample_rates[] = { 16000, 24000, 48000 };
+        for (size_t i = 0; i < 3; ++i) {
+            if ((r = swr_alloc_set_opts2(&params.swr_fltp_to_s16_from_48khz[i][params.SWR_CONV_1CH],
+                &channel_layouts[0], AV_SAMPLE_FMT_S16, sample_rates[i],
+                &channel_layouts[0], AV_SAMPLE_FMT_FLTP, 48000,
+                0, nullptr)) < 0)
+                ASSERT_MSG(false, "{}", r);
+            if ((r = swr_alloc_set_opts2(&params.swr_fltp_to_s16_from_48khz[i][params.SWR_CONV_2CH],
+                &channel_layouts[1], AV_SAMPLE_FMT_S16, sample_rates[i],
+                &channel_layouts[1], AV_SAMPLE_FMT_FLTP, 48000,
+                0, nullptr)) < 0)
+                ASSERT_MSG(false, "{}", r);
+        }
+        for (size_t i = 0; i < 3; ++i) {
+            if ((r = swr_init(params.swr_fltp_to_s16_from_48khz[i][params.SWR_CONV_1CH])) < 0)
+                ASSERT_MSG(false, "{}", r);
+            if ((r = swr_init(params.swr_fltp_to_s16_from_48khz[i][params.SWR_CONV_2CH])) < 0)
+                ASSERT_MSG(false, "{}", r);
+        }
+
+        while (!stop_token.stop_requested()) {
+            auto msg = Receive(Direction::DSP, stop_token);
+            LOG_TRACE(Audio_DSP, "msg={}, buffer={}", msg, shared_memory->host_send_data[0]);
+            switch (msg) {
+            case Shutdown:
+                Send(Direction::Host, Message::ShutdownOK);
+                return;
+            case GetWorkBufferSize: {
+                auto channel_count = s32(shared_memory->host_send_data[0]);
+
+                ASSERT(IsValidChannelCount(channel_count));
+
+                shared_memory->dsp_return_data[0] = OpusGenericDecodeObject::GetWorkBufferSize(channel_count);
+                Send(Direction::Host, Message::GetWorkBufferSizeOK);
+                break;
+            }
+            case InitializeDecodeObject: {
+                auto buffer = shared_memory->host_send_data[0];
+                auto buffer_size = shared_memory->host_send_data[1];
+                auto sample_rate = s32(shared_memory->host_send_data[2]);
+                auto channel_count = s32(shared_memory->host_send_data[3]);
+
+                ASSERT(sample_rate >= 0);
+                ASSERT(IsValidChannelCount(channel_count));
+                ASSERT(buffer_size >= OpusGenericDecodeObject::GetWorkBufferSize(channel_count));
+
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    it->second.Shutdown(params);
+                    shared_memory->dsp_return_data[0] = it->second.InitializeDecoder(sample_rate, 1, channel_count, channel_count == 2 ? 1 : 0, nullptr, params).raw;
+                } else {
+                    OpusGenericDecodeObject obj{};
+                    shared_memory->dsp_return_data[0] = obj.InitializeDecoder(sample_rate, 1, channel_count, channel_count == 2 ? 1 : 0, nullptr, params).raw;
+                    decode_objects.insert_or_assign(buffer, obj);
+                }
+                Send(Direction::Host, Message::InitializeDecodeObjectOK);
+                break;
+            }
+            case ShutdownDecodeObject: {
+                auto buffer = shared_memory->host_send_data[0];
+                //[[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    shared_memory->dsp_return_data[0] = it->second.Shutdown(params).raw;
+                    decode_objects.erase(buffer);
+                } else {
+                    LOG_ERROR(Audio_DSP, "operating unregistered buffer {}", buffer);
+                    shared_memory->dsp_return_data[0] = Service::Audio::ResultLibOpusInvalidState.raw;
+                }
+                Send(Direction::Host, Message::ShutdownDecodeObjectOK);
+                break;
+            }
+            case DecodeInterleaved: {
+                auto start_time = system.CoreTiming().GetGlobalTimeUs();
+
+                auto buffer = shared_memory->host_send_data[0];
+                auto input_data = shared_memory->host_send_data[1];
+                auto input_data_size = shared_memory->host_send_data[2];
+                auto output_data = shared_memory->host_send_data[3];
+                auto output_data_size = shared_memory->host_send_data[4];
+                //auto final_range = static_cast<u32>(shared_memory->host_send_data[5]);
+                auto reset_requested = shared_memory->host_send_data[6];
+
+                u32 decoded_samples{0};
+
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    auto res = ResultSuccess;
+                    if (reset_requested)
+                        res = it->second.ResetDecoder(params);
+                    if (res == ResultSuccess)
+                        res = it->second.Decode(decoded_samples, output_data, output_data_size, input_data, input_data_size, params);
+
+                    auto end_time = system.CoreTiming().GetGlobalTimeUs();
+                    shared_memory->dsp_return_data[0] = res.raw;
+                    shared_memory->dsp_return_data[1] = decoded_samples;
+                    shared_memory->dsp_return_data[2] = (end_time - start_time).count();
+                } else {
+                    LOG_ERROR(Audio_DSP, "operating unregistered buffer {}", buffer);
+                    shared_memory->dsp_return_data[0] = Service::Audio::ResultLibOpusInvalidState.raw;
+                }
+                Send(Direction::Host, Message::DecodeInterleavedOK);
+                break;
+            }
+            case MapMemory: {
+                [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
+                [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+                Send(Direction::Host, Message::MapMemoryOK);
+                break;
+            }
+            case UnmapMemory: {
+                [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
+                [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+                Send(Direction::Host, Message::UnmapMemoryOK);
+                break;
+            }
+            case GetWorkBufferSizeForMultiStream: {
+                auto total_stream_count = s32(shared_memory->host_send_data[0]);
+                auto stereo_stream_count = s32(shared_memory->host_send_data[1]);
+
+                ASSERT(IsValidStreamCounts(total_stream_count, stereo_stream_count));
+
+                shared_memory->dsp_return_data[0] = OpusGenericDecodeObject::GetWorkBufferSizeMultistream(total_stream_count, stereo_stream_count);
+                Send(Direction::Host, Message::GetWorkBufferSizeForMultiStreamOK);
+                break;
+            }
+            case InitializeMultiStreamDecodeObject: {
+                auto buffer = shared_memory->host_send_data[0];
+                auto buffer_size = shared_memory->host_send_data[1];
+                auto sample_rate = s32(shared_memory->host_send_data[2]);
+                auto channel_count = s32(shared_memory->host_send_data[3]);
+                auto total_stream_count = s32(shared_memory->host_send_data[4]);
+                auto stereo_stream_count = s32(shared_memory->host_send_data[5]);
+                // Nintendo seem to have a bug here, they try to use &host_send_data[6] for the channel
+                // mappings, but [6] is never set, and there is not enough room in the argument data for
+                // more than 40 channels, when 255 are possible.
+                // It also means the mapping values are undefined, though likely always 0,
+                // and the mappings given by the game are ignored. The mappings are copied to this
+                // dedicated buffer host side, so let's do as intended.
+                auto mappings = shared_memory->channel_mapping.data();
+
+                ASSERT(IsValidStreamCounts(total_stream_count, stereo_stream_count));
+                ASSERT(sample_rate >= 0);
+                ASSERT(buffer_size >= OpusGenericDecodeObject::GetWorkBufferSizeMultistream(total_stream_count, stereo_stream_count));
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    it->second.Shutdown(params);
+                    shared_memory->dsp_return_data[0] = it->second.InitializeDecoder(sample_rate, total_stream_count, channel_count, stereo_stream_count, mappings, params).raw;
+                } else {
+                    OpusGenericDecodeObject obj{};
+                    shared_memory->dsp_return_data[0] = obj.InitializeDecoder(sample_rate, total_stream_count, channel_count, stereo_stream_count, mappings, params).raw;
+                    decode_objects.insert_or_assign(buffer, obj);
+                }
+                Send(Direction::Host, Message::InitializeMultiStreamDecodeObjectOK);
+                break;
+            }
+            case ShutdownMultiStreamDecodeObject: {
+                auto buffer = shared_memory->host_send_data[0];
+                //[[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    shared_memory->dsp_return_data[0] = it->second.Shutdown(params).raw;
+                    decode_objects.erase(buffer);
+                } else {
+                    LOG_ERROR(Audio_DSP, "operating unregistered buffer {}", buffer);
+                    shared_memory->dsp_return_data[0] = Service::Audio::ResultLibOpusInvalidState.raw;
+                }
+                Send(Direction::Host, Message::ShutdownMultiStreamDecodeObjectOK);
+                break;
+            }
+            case DecodeInterleavedForMultiStream: {
+                auto start_time = system.CoreTiming().GetGlobalTimeUs();
+
+                auto buffer = shared_memory->host_send_data[0];
+                auto input_data = shared_memory->host_send_data[1];
+                auto input_data_size = shared_memory->host_send_data[2];
+                auto output_data = shared_memory->host_send_data[3];
+                auto output_data_size = shared_memory->host_send_data[4];
+                //auto final_range = static_cast<u32>(shared_memory->host_send_data[5]);
+                auto reset_requested = shared_memory->host_send_data[6];
+
+                u32 decoded_samples{0};
+
+                if (auto const it = decode_objects.find(buffer); it != decode_objects.end()) {
+                    auto res = ResultSuccess;
+                    if (reset_requested)
+                        res = it->second.ResetDecoder(params);
+                    if (res == ResultSuccess)
+                        res = it->second.Decode(decoded_samples, output_data, output_data_size, input_data, input_data_size, params);
+
+                    auto end_time = system.CoreTiming().GetGlobalTimeUs();
+                    shared_memory->dsp_return_data[0] = res.raw;
+                    shared_memory->dsp_return_data[1] = decoded_samples;
+                    shared_memory->dsp_return_data[2] = (end_time - start_time).count();
+                } else {
+                    LOG_ERROR(Audio_DSP, "operating unregistered buffer {}", buffer);
+                    shared_memory->dsp_return_data[0] = Service::Audio::ResultLibOpusInvalidState.raw;
+                }
+                Send(Direction::Host, Message::DecodeInterleavedForMultiStreamOK);
+                break;
+            }
+            default:
+                LOG_ERROR(Audio_DSP, "Invalid OpusDecoder command {}", msg);
+                continue;
+            }
+        }
+        for (auto e : decode_objects)
+            e.second.Shutdown(params);
+        // global params handlers
+        for (size_t i = 0; i < 3; ++i) {
+            for (size_t j = 0; j < 2; ++j) {
+                swr_free(&params.swr_fltp_to_s16_from_48khz[i][j]);
+            }
+        }
+        av_freep(&params.tmp_buf[0]);
+        av_frame_free(&params.frame);
+        av_packet_free(&params.pkt);
+    });
 }

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

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

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

 #pragma once

-#include <memory>
 #include <thread>

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

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

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

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

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

 private:
-    /**
-     * Initializing thread, launched at audio_core boot to avoid blocking the main emu boot thread.
-     */
-    void Init(std::stop_token stop_token);
-    /**
-     * Main OpusDecoder thread, responsible for processing the incoming Opus packets.
-     */
-    void Main(std::stop_token stop_token);
-
-    /// Core system
-    Core::System& system;
    /// Mailbox to communicate messages with the host, drives the main thread
    Mailbox mailbox;
-    /// Init thread
-    std::jthread init_thread{};
-    /// Main thread
-    std::jthread main_thread{};
-    /// The current state
-    bool running{};
    /// Structure shared with the host, input data set by the host before sending a mailbox message,
    /// and the responses are written back by the OpusDecoder.
    SharedMemory* shared_memory{};
+    std::jthread dsp_thread{};
 };

 } // namespace AudioCore::ADSP::OpusDecoder
@@ -1,113 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
-#include "common/assert.h"
-
-namespace AudioCore::ADSP::OpusDecoder {
-
-namespace {
-constexpr u32 OpusStreamCountMax = 255;
-
-bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
-    return total_stream_count > 0 && total_stream_count <= OpusStreamCountMax &&
-           static_cast<s32>(stereo_stream_count) >= 0 &&
-           stereo_stream_count <= total_stream_count;
-}
-} // namespace
-
-u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count,
-                                                   u32 stereo_stream_count) {
-    if (IsValidStreamCounts(total_stream_count, stereo_stream_count)) {
-        return static_cast<u32>(sizeof(OpusMultiStreamDecodeObject)) +
-               opus_multistream_decoder_get_size(total_stream_count, stereo_stream_count);
-    }
-    return 0;
-}
-
-OpusMultiStreamDecodeObject& OpusMultiStreamDecodeObject::Initialize(u64 buffer, u64 buffer2) {
-    auto* new_decoder = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer);
-    auto* comparison = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer2);
-
-    if (new_decoder->magic == DecodeMultiStreamObjectMagic) {
-        if (!new_decoder->initialized ||
-            (new_decoder->initialized && new_decoder->self == comparison)) {
-            new_decoder->state_valid = true;
-        }
-    } else {
-        new_decoder->initialized = false;
-        new_decoder->state_valid = true;
-    }
-    return *new_decoder;
-}
-
-s32 OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count,
-                                                   u32 channel_count, u32 stereo_stream_count,
-                                                   u8* mappings) {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        return OPUS_OK;
-    }
-
-    // See OpusDecodeObject::InitializeDecoder for an explanation of this
-    decoder = (LibOpusMSDecoder*)(this + 1);
-    s32 ret = opus_multistream_decoder_init(decoder, sample_rate, channel_count, total_stream_count,
-                                            stereo_stream_count, mappings);
-    if (ret == OPUS_OK) {
-        magic = DecodeMultiStreamObjectMagic;
-        initialized = true;
-        state_valid = true;
-        self = this;
-        final_range = 0;
-    }
-    return ret;
-}
-
-s32 OpusMultiStreamDecodeObject::Shutdown() {
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    if (initialized) {
-        magic = 0x0;
-        initialized = false;
-        state_valid = false;
-        self = nullptr;
-        final_range = 0;
-        decoder = nullptr;
-    }
-    return OPUS_OK;
-}
-
-s32 OpusMultiStreamDecodeObject::ResetDecoder() {
-    return opus_multistream_decoder_ctl(decoder, OPUS_RESET_STATE);
-}
-
-s32 OpusMultiStreamDecodeObject::Decode(u32& out_sample_count, u64 output_data,
-                                        u64 output_data_size, u64 input_data, u64 input_data_size) {
-    ASSERT(initialized);
-    out_sample_count = 0;
-
-    if (!state_valid) {
-        return OPUS_INVALID_STATE;
-    }
-
-    auto ret_code_or_samples = opus_multistream_decode(
-        decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),
-        reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);
-
-    if (ret_code_or_samples < OPUS_OK) {
-        return ret_code_or_samples;
-    }
-
-    out_sample_count = ret_code_or_samples;
-    return opus_multistream_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
-}
-
-} // namespace AudioCore::ADSP::OpusDecoder
@@ -1,42 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <opus_multistream.h>
-
-#include "common/common_types.h"
-
-namespace AudioCore::ADSP::OpusDecoder {
-using LibOpusMSDecoder = ::OpusMSDecoder;
-static constexpr u32 DecodeMultiStreamObjectMagic = 0xDEADBEEF;
-
-class OpusMultiStreamDecodeObject {
-public:
-    static u32 GetWorkBufferSize(u32 total_stream_count, u32 stereo_stream_count);
-    static OpusMultiStreamDecodeObject& Initialize(u64 buffer, u64 buffer2);
-
-    s32 InitializeDecoder(u32 sample_rate, u32 total_stream_count, u32 channel_count,
-                          u32 stereo_stream_count, u8* mappings);
-    s32 Shutdown();
-    s32 ResetDecoder();
-    s32 Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data,
-               u64 input_data_size);
-    u32 GetFinalRange() const noexcept {
-        return final_range;
-    }
-
-private:
-    u32 magic;
-    bool initialized;
-    bool state_valid;
-    OpusMultiStreamDecodeObject* self;
-    u32 final_range;
-    LibOpusMSDecoder* decoder;
-};
-static_assert(std::is_trivially_constructible_v<OpusMultiStreamDecodeObject>);
-
-} // namespace AudioCore::ADSP::OpusDecoder
@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace AudioCore::ADSP {
+
+static constexpr u32 DECODE_OBJECT_MAGIC = 0xDEADBEEF;
+struct LibOpusDecoder {
+    u32 magic;
+    bool initialized;
+    bool state_valid;
+    LibOpusDecoder* self;
+    u32 final_range;
+    void* decoder;
+};
+static_assert(sizeof(LibOpusDecoder) == 32);
+
+static constexpr u32 DECODE_MULTISTREAM_OBJECT_MAGIC = 0xDEADBEEF;
+struct LibOpusMultistreamDecoder {
+    u32 magic;
+    bool initialized;
+    bool state_valid;
+    LibOpusMultistreamDecoder* self;
+    u32 final_range;
+    void* decoder;
+};
+static_assert(sizeof(LibOpusMultistreamDecoder) == 32);
+
+}
@@ -6,7 +6,6 @@

 #pragma once

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

 namespace AudioCore::ADSP::OpusDecoder {
@@ -10,39 +10,18 @@
 #include "audio_core/audio_core.h"
 #include "audio_core/opus/hardware_opus.h"
 #include "core/core.h"
+#include "core/hle/result.h"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {
@@ -240,8 +217,7 @@ Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {
    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::MapMemory);
    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
    if (msg != ADSP::OpusDecoder::Message::MapMemoryOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::MapMemoryOK, msg);
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}", ADSP::OpusDecoder::Message::MapMemoryOK, msg);
        R_THROW(ResultInvalidOpusDSPReturnCode);
    }
    R_SUCCEED();
@@ -255,8 +231,7 @@ Result HardwareOpus::UnmapMemory(void* buffer, u64 buffer_size) {
    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::UnmapMemory);
    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
    if (msg != ADSP::OpusDecoder::Message::UnmapMemoryOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::UnmapMemoryOK, msg);
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}", ADSP::OpusDecoder::Message::UnmapMemoryOK, msg);
        R_THROW(ResultInvalidOpusDSPReturnCode);
    }
    R_SUCCEED();
@@ -8,8 +8,6 @@

 #include <array>
 #include <mutex>
-#include <opus.h>
-
 #include "audio_core/adsp/apps/opus/opus_decoder.h"
 #include "audio_core/adsp/apps/opus/shared_memory.h"
 #include "audio_core/adsp/mailbox.h"
@@ -810,6 +810,8 @@ add_library(core STATIC
    hle/service/ns/ecommerce_interface.h
    hle/service/ns/factory_reset_interface.cpp
    hle/service/ns/factory_reset_interface.h
+    hle/service/ns/i_async_result.cpp
+    hle/service/ns/i_async_result.h
    hle/service/ns/language.cpp
    hle/service/ns/language.h
    hle/service/ns/ns.cpp
@@ -1199,7 +1201,6 @@ else()
    endif()
 endif()

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

 if (BOOST_NO_HEADERS)
@@ -12,6 +12,7 @@
 #include "hid_core/frontend/emulated_controller.h"
 #include "hid_core/hid_core.h"
 #include "hid_core/hid_types.h"
+#include <array>

 namespace Core::Frontend {

@@ -29,23 +30,39 @@ void DefaultControllerApplet::ReconfigureControllers(ReconfigureCallback callbac

    const std::size_t min_supported_players =
        parameters.enable_single_mode ? 1 : parameters.min_players;
+    using Core::HID::NpadStyleIndex;
+    const std::size_t max_supported_players = parameters.enable_single_mode ? 1 : parameters.max_players;
+    std::size_t num_selected_players = 0;
+    std::array<bool, HID::HIDCore::available_controllers> keep_connected{};

-    // Disconnect Handheld first.
+    // reserve existing AND valid players before filling slots. include Handheld, but not other
+    for (std::size_t index = 0; index < hid_core.available_controllers - 1; ++index) {
+        const auto* controller = hid_core.GetEmulatedControllerByIndex(index);
+        if (!parameters.keep_controllers_connected || !controller->IsConnected() || num_selected_players >= max_supported_players) continue;
+
+        const auto style = controller->GetNpadStyleIndex();
+        keep_connected[index] =
+            (style == NpadStyleIndex::Fullkey && parameters.allow_pro_controller) ||
+            (style == NpadStyleIndex::JoyconDual && parameters.allow_dual_joycons) ||
+            (style == NpadStyleIndex::JoyconLeft && parameters.allow_left_joycon) ||
+            (style == NpadStyleIndex::JoyconRight && parameters.allow_right_joycon) ||
+            (style == NpadStyleIndex::Handheld && parameters.enable_single_mode && parameters.allow_handheld && !Settings::IsDockedMode()) ||
+            (style == NpadStyleIndex::GameCube && parameters.allow_gamecube_controller);
+        num_selected_players += keep_connected[index];
+    }
    auto* handheld = hid_core.GetEmulatedController(Core::HID::NpadIdType::Handheld);
-    handheld->Disconnect();
+    if (!keep_connected[hid_core.available_controllers - 2]) handheld->Disconnect();

    // Deduce the best configuration based on the input parameters.
    for (std::size_t index = 0; index < hid_core.available_controllers - 2; ++index) {
        auto* controller = hid_core.GetEmulatedControllerByIndex(index);

-        // First, disconnect all controllers regardless of the value of keep_controllers_connected.
-        // This makes it easy to connect the desired controllers.
+        if (keep_connected[index]) continue;
        controller->Disconnect();

-        // Only connect the minimum number of required players.
-        if (index >= min_supported_players) {
-            continue;
-        }
+        // only add players still needed to reach the minimum
+        if (num_selected_players >= min_supported_players) continue;
+        ++num_selected_players;

        // Connect controllers based on the following priority list from highest to lowest priority:
        // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld
@@ -228,9 +228,9 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
        {930, nullptr, "Unknown930"}, //20.0.0+
        {931, nullptr, "Unknown931"}, //20.0.0+
        {933, nullptr, "Unknown933"}, //20.0.0+
-        {934, nullptr, "Unknown934"}, //20.0.0+
-        {935, nullptr, "Unknown935"}, //20.0.0+
-        {936, nullptr, "Unknown936"}, //20.0.0+
+        {934, nullptr, "Unknown934"}, //21.0.0+
+        {935, nullptr, "Unknown935"}, //21.0.0+
+        {936, D<&IApplicationManagerInterface::Unknown936>, "Unknown936"}, //21.0.0+
        {1000, nullptr, "RequestVerifyApplicationDeprecated"},
        {1001, nullptr, "CorruptApplicationForDebug"},
        {1002, nullptr, "RequestVerifyAddOnContentsRights"},
@@ -422,7 +422,7 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
        {4039, nullptr, "Unknown4039"}, //20.0.0+
        {4040, nullptr, "Unknown4040"}, //20.0.0+
        {4041, nullptr, "Unknown4041"}, //20.0.0+
-        {4042, nullptr, "Unknown4042"}, //20.0.0+
+        {4042, D<&IApplicationManagerInterface::Unknown4042>, "Unknown4042"}, //20.0.0+
        {4043, nullptr, "Unknown4043"}, //20.0.0+
        {4044, nullptr, "Unknown4044"}, //20.0.0+
        {4045, nullptr, "Unknown4045"}, //20.0.0+
@@ -639,6 +639,12 @@ Result IApplicationManagerInterface::IsGameCardApplicationRunning(Out<bool> out_
    R_SUCCEED();
 }

+Result IApplicationManagerInterface::Unknown936(Out<u64> out_result) {
+    LOG_WARNING(Service_NS, "(STUBBED) called.");
+    *out_result = 0;
+    R_SUCCEED();
+}
+
 Result IApplicationManagerInterface::IsAnyApplicationEntityInstalled(
    Out<bool> out_is_any_application_entity_installed) {
    LOG_WARNING(Service_NS, "(STUBBED) called");
@@ -862,6 +868,15 @@ Result IApplicationManagerInterface::Unknown4023(Out<u64> out_result) {
    R_SUCCEED();
 }

+Result IApplicationManagerInterface::Unknown4042(OutInterface<IAsyncResult> out_interface,
+                                                 OutCopyHandle<Kernel::KReadableEvent> out_event,
+                                                 u64 arg1, u64 arg2) {
+    LOG_WARNING(Service_NS, "(STUBBED) called, arg1={:016X}, arg2={:016X}", arg1, arg2);
+    *out_event = unknown_event.GetHandle();
+    *out_interface = std::make_shared<IAsyncResult>(system, &unknown_event);
+    R_SUCCEED();
+}
+
 Result IApplicationManagerInterface::Unknown4053() {
    LOG_WARNING(Service_NS, "(STUBBED) called.");
    R_SUCCEED();
@@ -7,6 +7,7 @@
 #pragma once

 #include "core/hle/service/cmif_types.h"
+#include "core/hle/service/ns/i_async_result.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/os/event.h"
@@ -34,6 +35,7 @@ public:
    Result GetGameCardMountFailureEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result GetGameCardWakenReadyEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result IsGameCardApplicationRunning(Out<bool> out_is_running);
+    Result Unknown936(Out<u64> out_result);
    Result IsAnyApplicationEntityInstalled(Out<bool> out_is_any_application_entity_installed);
    Result GetApplicationViewDeprecated(
        OutArray<ApplicationViewV19, BufferAttr_HipcMapAlias> out_application_views,
@@ -71,6 +73,9 @@ public:
                                  InBuffer<BufferAttr_HipcMapAlias> logo_path_buffer);
    Result Unknown4022(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result Unknown4023(Out<u64> out_result);
+    Result Unknown4042(OutInterface<IAsyncResult> out_interface,
+                       OutCopyHandle<Kernel::KReadableEvent> out_event,
+                       u64 arg1, u64 arg2);
    Result Unknown4053();
    Result Unknown4105();

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/ns/i_async_result.h"
+
+#include <cstring>
+
+namespace Service::NS {
+
+IAsyncResult::IAsyncResult(Core::System& system_, Service::Event* event_)
+    : ServiceFramework{system_, "nn::ns::detail::IAsyncResult"}, event{event_} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "Get"},
+        {1, D<&IAsyncResult::Cancel>, "Cancel"},
+        {2, nullptr, "GetErrorContext"}, // 4.0.0+
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IAsyncResult::~IAsyncResult() = default;
+
+Result IAsyncResult::Cancel() {
+    LOG_DEBUG(Service_NS, "called");
+    if (event != nullptr) {
+        event->Signal(system.Kernel());
+    }
+
+    R_SUCCEED();
+}
+
+} // namespace Service::NS
@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/service.h"
+
+namespace Service::NS {
+
+class IAsyncResult final : public ServiceFramework<IAsyncResult> {
+public:
+    explicit IAsyncResult(Core::System& system_, Service::Event* event_);
+    ~IAsyncResult() override;
+
+private:
+    Result Cancel();
+
+    Service::Event* event{};
+};
+
+} // namespace Service::NS
@@ -23,7 +23,7 @@ namespace ConfigurationShared {

 std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
    std::unique_ptr<TranslationMap> translations = std::make_unique<TranslationMap>();
-    const auto& tr = [parent](const char* text) -> QString { return parent->tr(text); };
+    const auto& tr = [](const char* text) -> QString { return QCoreApplication::translate("ConfigurationShared", text); };

 #define INSERT(SETTINGS, ID, NAME, TOOLTIP)                                                        \
    translations->insert(std::pair{SETTINGS::values.ID.Id(), std::pair{(NAME), (TOOLTIP)}})
@@ -151,6 +151,9 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
           tr("The anti-aliasing method to use.\nSMAA offers the best quality.\nFXAA "
              "can produce a more stable picture in lower resolutions."));
    INSERT(Settings, post_shader_chain, QString(), QString());
+    INSERT(Settings, post_shader_preset, QString(), QString());
+    INSERT(Settings, post_shader_enabled, tr("Enable post-processing effects"),
+           tr("Applies post-processing effects to the final image."));
    INSERT(Settings, fullscreen_mode, tr("Fullscreen Mode:"),
           tr("The method used to render the window in fullscreen.\nBorderless offers the best "
              "compatibility with the on-screen keyboard that some games request for "
@@ -368,8 +371,8 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
 std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
    std::unique_ptr<ComboboxTranslationMap> translations =
        std::make_unique<ComboboxTranslationMap>();
-    const auto& tr = [&](const char* text, const char* context = "") {
-        return parent->tr(text, context);
+    const auto& tr = [](const char* text, const char* context = "") {
+        return QCoreApplication::translate("ConfigurationShared", text, context);
    };

 #define PAIR(ENUM, VALUE, TRANSLATION) {static_cast<u32>(Settings::ENUM::VALUE), (TRANSLATION)}
@@ -414,9 +414,7 @@ endif()
 if (YUZU_USE_EXTERNAL_FFMPEG)
    add_dependencies(video_core ffmpeg-build)
 endif()
-
 target_include_directories(video_core PUBLIC ${FFmpeg_INCLUDE_DIR})
-
 target_link_libraries(video_core PRIVATE ${FFmpeg_LIBRARIES})
 target_link_options(video_core PRIVATE ${FFmpeg_LDFLAGS})

@@ -37,6 +37,10 @@
 #include "yuzu/configuration/configure_graphics.h"
 #include "yuzu/configuration/shared_widget.h"

+#ifdef HAS_RESHADE
+#include "yuzu/configuration/configure_post_processing.h"
+#endif
+
 ConfigureGraphics::ConfigureGraphics(
    const Core::System& system_, std::vector<VkDeviceInfo::Record>& records_,
    const std::function<void()>& expose_compute_option_,
@@ -216,6 +220,12 @@ void ConfigureGraphics::Setup(const ConfigurationShared::Builder& builder) {
    std::vector<QWidget*> hold_api;

    for (const auto setting : Settings::values.linkage.by_category[Settings::Category::Renderer]) {
+#ifndef HAS_RESHADE
+        if (setting->Id() == Settings::values.post_shader_enabled.Id()) {
+            continue;
+        }
+#endif
+
        ConfigurationShared::Widget* widget = [&]() {
            if (setting->Id() == Settings::values.fsr_sharpening_slider.Id()) {
                // FSR needs a reversed slider and a 0.5 multiplier
@@ -295,6 +305,23 @@ void ConfigureGraphics::Setup(const ConfigurationShared::Builder& builder) {
            // Keep track of the resolution combobox to update other UI tabs that need it
            resolution_combobox = widget->combobox;
            hold_graphics.emplace(setting->Id(), widget);
+#ifdef HAS_RESHADE
+        } else if (setting->Id() == Settings::values.post_shader_enabled.Id()) {
+            QPushButton* post_shader_button = new QPushButton(tr("Configure Effects..."), widget);
+            post_shader_button->setVisible(widget->checkbox->isChecked());
+
+            connect(post_shader_button, &QAbstractButton::clicked, this, [this]() {
+                ConfigurePostProcessing dialog(this);
+                dialog.exec();
+            });
+            connect(widget->checkbox, &QCheckBox::toggled, post_shader_button,
+                    &QWidget::setVisible);
+
+            QBoxLayout* row = qobject_cast<QBoxLayout*>(widget->layout());
+            row->insertWidget(1, post_shader_button);
+
+            hold_graphics.emplace(setting->Id(), widget);
+#endif
        } else {
            hold_graphics.emplace(setting->Id(), widget);
        }
@@ -70,10 +70,8 @@ ConfigurePostProcessing::ConfigurePostProcessing(QWidget* parent) : QDialog(pare

    auto* root = new QVBoxLayout(this);

-    auto* description = new QLabel(
-        tr("ReShade FX effects are loaded from the post_shaders folder in the Eden data "
-           "directory. Changes apply immediately while a game is running."),
-        this);
+    auto* description =
+        new QLabel(tr("Changes apply immediately while a game is running."), this);
    description->setWordWrap(true);
    root->addWidget(description);

@@ -128,17 +126,15 @@ ConfigurePostProcessing::ConfigurePostProcessing(QWidget* parent) : QDialog(pare
    });
    preset_row->addWidget(save_button);

-    auto* delete_button = new QPushButton(tr("Delete"), this);
-    connect(delete_button, &QPushButton::clicked, this, [this]() {
-        const QString name = preset_combo->currentData().toString();
-        if (name.isEmpty()) {
-            return;
-        }
-        VideoCore::DeleteFxPreset(name.toStdString());
-        PopulatePresetCombo();
-        RefreshPresetStatus();
+    auto* clear_button = new QPushButton(tr("Clear"), this);
+    clear_button->setToolTip(tr("Remove every effect in use and deselect the preset."));
+    connect(clear_button, &QPushButton::clicked, this, [this]() {
+        VideoCore::FxChain::Instance().Clear();
+        VideoCore::SetActiveFxPreset(std::string());
+        preset_combo->setCurrentIndex(0);
+        ApplyStructuralChange();
    });
-    preset_row->addWidget(delete_button);
+    preset_row->addWidget(clear_button);

    root->addLayout(preset_row);

@@ -203,6 +199,7 @@ void ConfigurePostProcessing::ApplyStructuralChange() {
 void ConfigurePostProcessing::PopulatePresetCombo() {
    const QString previous = preset_combo->currentData().toString();
    preset_combo->clear();
+    preset_combo->addItem(tr("None"), QString());

    for (const auto& preset : VideoCore::GetFxPresetCatalog()) {
        const QString name = QString::fromStdString(preset.name);
@@ -212,7 +209,7 @@ void ConfigurePostProcessing::PopulatePresetCombo() {
    }

    const int restored = preset_combo->findData(previous);
-    if (restored >= 0) {
+    if (!previous.isEmpty() && restored >= 0) {
        preset_combo->setCurrentIndex(restored);
        return;
    }
@@ -220,12 +217,21 @@ void ConfigurePostProcessing::PopulatePresetCombo() {
    const int active = preset_combo->findData(QString::fromStdString(VideoCore::GetActiveFxPreset()));
    if (active >= 0) {
        preset_combo->setCurrentIndex(active);
+        return;
    }
+
+    preset_combo->setCurrentIndex(0);
 }

 void ConfigurePostProcessing::RefreshPresetStatus() {
    const std::string active = VideoCore::GetActiveFxPreset();
    if (active.empty()) {
+        if (VideoCore::FxChain::Instance().Size() == 0) {
+            preset_status->setText(
+                tr("No effects in use. Pick a preset and press Apply, or add effects one "
+                   "by one."));
+            return;
+        }
        preset_status->setText(tr("Custom chain. Pick a preset above and press Apply to replace it."));
        return;
    }
@@ -15,6 +15,7 @@
 #include "render/performance_overlay.h"
 #ifdef HAS_RESHADE
 #include "configuration/configure_post_processing.h"
+#include "video_core/post_processing/fx_preset.h"
 #endif
 #include "updater/update_dialog.h"

@@ -1090,6 +1091,41 @@ void MainWindow::InitializeWidgets() {

    statusBar()->insertPermanentWidget(0, volume_button);

+#ifdef HAS_RESHADE
+    post_shader_status_button = new QPushButton();
+    post_shader_status_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
+    post_shader_status_button->setFocusPolicy(Qt::NoFocus);
+    post_shader_status_button->setCheckable(true);
+    connect(post_shader_status_button, &QPushButton::clicked, this, [this] {
+        const bool enabled = Settings::values.post_shader_enabled.GetValue();
+        Settings::values.post_shader_enabled.SetValue(!enabled);
+        UpdatePostShaderText();
+    });
+    UpdatePostShaderText();
+    post_shader_status_button->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(post_shader_status_button, &QPushButton::customContextMenuRequested,
+            [this](const QPoint& menu_location) {
+                QMenu context_menu;
+
+                for (auto const& preset : VideoCore::GetFxPresetCatalog()) {
+                    context_menu.addAction(QString::fromStdString(preset.name),
+                                           [this, name = preset.name] {
+                                               VideoCore::ApplyFxPreset(name);
+                                               Settings::values.post_shader_enabled.SetValue(true);
+                                               UpdatePostShaderText();
+                                           });
+                }
+
+                context_menu.addSeparator();
+                context_menu.addAction(tr("Configure Effects..."), this,
+                                       &MainWindow::OnPostProcessingShaders);
+
+                context_menu.exec(post_shader_status_button->mapToGlobal(menu_location));
+                post_shader_status_button->repaint();
+            });
+    statusBar()->insertPermanentWidget(0, post_shader_status_button);
+#endif
+
    // setup AA button
    aa_status_button = new QPushButton();
    aa_status_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
@@ -3908,6 +3944,7 @@ void MainWindow::OnPostProcessingShaders() {
        connect(post_processing_dialog, &QDialog::finished, post_processing_dialog, [this]() {
            post_processing_dialog->deleteLater();
            post_processing_dialog = nullptr;
+            UpdatePostShaderText();
        });
    }

@@ -4262,6 +4299,26 @@ void MainWindow::UpdateAAText() {
                                  : aa_text.toUpper());
 }

+#ifdef HAS_RESHADE
+void MainWindow::UpdatePostShaderText() {
+    const bool enabled = Settings::values.post_shader_enabled.GetValue();
+    post_shader_status_button->setChecked(enabled);
+
+    if (!enabled) {
+        post_shader_status_button->setText(tr("NO FX"));
+        return;
+    }
+
+    const std::string preset = VideoCore::GetActiveFxPreset();
+    if (preset.empty()) {
+        post_shader_status_button->setText(tr("FX"));
+        return;
+    }
+
+    post_shader_status_button->setText(QString::fromStdString(preset).toUpper());
+}
+#endif
+
 void MainWindow::UpdateVolumeUI() {
    const auto volume_value = static_cast<int>(Settings::values.volume.GetValue());
    volume_slider->setValue(volume_value);
@@ -448,6 +448,7 @@ private:
    void UpdateAPIText();
    void UpdateFilterText();
    void UpdateAAText();
+    void UpdatePostShaderText();
    void UpdateVolumeUI();
    void UpdateStatusBar();
    void UpdateGPUAccuracyButton();
@@ -524,6 +525,7 @@ private:
    QPushButton* dock_status_button = nullptr;
    QPushButton* filter_status_button = nullptr;
    QPushButton* aa_status_button = nullptr;
+    QPushButton* post_shader_status_button = nullptr;
    VolumeButton* volume_button = nullptr;
    QWidget* volume_popup = nullptr;
    QSlider* volume_slider = nullptr;
Author	SHA1	Message	Date
lizzie	d9376695cf	2026-09-15 19:23:45 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 19:23:45 +00:00
lizzie	7e14631b33	2026-09-14 09:32:00 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 22:12:39 +02:00
lizzie	401707294a	2026-09-14 09:23:00 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 22:12:39 +02:00
lizzie	14d79755c6	2026-09-14 09:22:19 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 22:12:39 +02:00
lizzie	2114b7eb4b	2026-09-14 08:48:05 Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 22:12:39 +02:00
lizzie	02726fbcd8	Reapply "[audio] Replace libopus with FFmpeg (#4169 )" (#4419 ) This reverts commit `2b4184dd2b`.	2026-09-15 22:12:39 +02:00
lizzie	7766fe7501	Trigger build	2026-09-15 22:12:39 +02:00
xbzk	b77308ced6	[applet] ReconfigureControllers fallback unconditional disconnect fix (#4420 ) - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- So, about Absolum's no overlay applet P2 issue: The fallback controller applet ignored keep_controllers_connected, according comment: "This makes it easy to connect the desired controllers". Unfortunately it was not good enough. It disconnected every controller, then reconnected only the minimum player count. That disconnect interacts with some guests (absolum in this case) causing undesired behaviors. The fix is entwined to original routine but it is a lot simple tho: preserves compatible connected controllers within the requested player range, while the existing routine configures only the remaining slots. This may fix some games, and should not harm others. Let us give it a go. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4420 Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-09-15 21:53:07 +02:00
PavelBARABANOV	defddec47f	[ns] add stubs for cmd936 and cmd4042 (#4429 ) - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- This is necessary to close Absolum and Hades 2 in qlaunch. Cmd4042 is necessary that there are no freezes when opening virtual cartridges. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4429 Reviewed-by: lizzie <lizzie@eden-emu.dev> Reviewed-by: Maufeat <sahyno1996@gmail.com>	2026-09-15 08:01:17 +02:00
CamilleLaVey	c5405250d1	[common, ui] Refining UI for FX shaders for PC (#4426 ) Self-explanatory refinements on the already existing access/usage of post-processing shaders on Eden for PC UI. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4426 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 07:23:12 +02:00
crueter	10c07d700c	[cmake] Use a debloated boost distribution (#4198 ) This addresses another issue that caused Windows configure time to take significantly longer than other platforms. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4198 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: lizzie <lizzie@eden-emu.dev>	2026-09-15 07:22:23 +02:00
PavelBARABANOV	505b157647	[qt common] use ConfigurationShared translation context (#4430 ) - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4430 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-09-15 03:42:11 +02:00