.ci/scripts/windows/scan_dll.py

@@ -40,7 +40,7 @@ def parse_imports(file_name):
 
 def parse_imports_recursive(file_name, path_list=[]):
     q = queue.Queue()  # create a FIFO queue
-    # file_name can be a string or a list for the convenience
+    # file_name can be a string or a list for the convience
     if isinstance(file_name, str):
         q.put(file_name)
     elif isinstance(file_name, list):

.ci/templates/build-msvc.yml

@@ -9,7 +9,7 @@ parameters:
 steps:
 - script: choco install vulkan-sdk
   displayName: 'Install vulkan-sdk'
-- script: refreshenv && mkdir build && cd build && cmake -E env CXXFLAGS="/Gw /GA /Gr /Ob2" cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DYUZU_ENABLE_LTO=ON -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
+- script: refreshenv && mkdir build && cd build && cmake -E env CXXFLAGS="/Gw /GA /Gr /Ob2" cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
   displayName: 'Configure CMake'
 - task: MSBuild@1
   displayName: 'Build'

.codespellrc

@@ -1,6 +0,0 @@
-; SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-; SPDX-License-Identifier: GPL-2.0-or-later
-
-[codespell]
-skip = ./.git,./build,./dist,./Doxyfile,./externals,./LICENSES
-ignore-words-list = aci,allright,ba,deques,froms,hda,inout,lod,masia,nam,nax,nd,pullrequests,pullrequest,te,transfered,unstall,uscaled,zink

.github/workflows/codespell.yml

@@ -1,17 +0,0 @@
-# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-# GitHub Action to automate the identification of common misspellings in text files.
-# https://github.com/codespell-project/actions-codespell
-# https://github.com/codespell-project/codespell
-name: codespell
-on: pull_request
-permissions: {}
-jobs:
-  codespell:
-    name: Check for spelling errors
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          persist-credentials: false
-      - uses: codespell-project/actions-codespell@master

.gitmodules

@@ -13,6 +13,9 @@
 [submodule "dynarmic"]
     path = externals/dynarmic
     url = https://github.com/MerryMage/dynarmic.git
+[submodule "libressl"]
+    path = externals/libressl
+    url = https://github.com/citra-emu/ext-libressl-portable.git
 [submodule "libusb"]
 	path = externals/libusb/libusb
 	url = https://github.com/libusb/libusb.git

CMakeLists.txt

@@ -56,8 +56,6 @@ option(YUZU_USE_BUNDLED_VCPKG "Use vcpkg for yuzu dependencies" "${MSVC}")
 
 option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ON)
 
-option(YUZU_ENABLE_LTO "Enable link-time optimization" OFF)
-
 CMAKE_DEPENDENT_OPTION(YUZU_USE_FASTER_LD "Check if a faster linker is available" ON "NOT WIN32" OFF)
 
 if (YUZU_USE_BUNDLED_VCPKG)
@@ -67,9 +65,6 @@ if (YUZU_USE_BUNDLED_VCPKG)
     if (YUZU_CRASH_DUMPS)
         list(APPEND VCPKG_MANIFEST_FEATURES "dbghelp")
     endif()
-    if (ENABLE_WEB_SERVICE)
-        list(APPEND VCPKG_MANIFEST_FEATURES "web-service")
-    endif()
 
     include(${CMAKE_SOURCE_DIR}/externals/vcpkg/scripts/buildsystems/vcpkg.cmake)
 elseif(NOT "$ENV{VCPKG_TOOLCHAIN_FILE}" STREQUAL "")
@@ -210,11 +205,10 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 # =======================================================================
 
 # Enforce the search mode of non-required packages for better and shorter failure messages
-find_package(Boost 1.79.0 REQUIRED context)
 find_package(enet 1.3 MODULE)
 find_package(fmt 9 REQUIRED)
-find_package(inih 52 MODULE COMPONENTS INIReader)
-find_package(LLVM MODULE COMPONENTS Demangle)
+find_package(inih MODULE)
+find_package(LLVM MODULE)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
 find_package(Opus 1.3 MODULE)
@@ -222,7 +216,7 @@ find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)
 
 if (NOT YUZU_USE_EXTERNAL_VULKAN_HEADERS)
-    find_package(Vulkan 1.3.246 REQUIRED)
+    find_package(Vulkan 1.3.238 REQUIRED)
 endif()
 
 if (ENABLE_LIBUSB)
@@ -247,13 +241,26 @@ endif()
 
 if (ENABLE_WEB_SERVICE)
     find_package(cpp-jwt 1.4 CONFIG)
-    find_package(httplib 0.12 MODULE COMPONENTS OpenSSL)
+    find_package(httplib 0.11 MODULE)
 endif()
 
 if (YUZU_TESTS)
     find_package(Catch2 3.0.1 REQUIRED)
 endif()
 
+find_package(Boost 1.73.0 COMPONENTS context)
+if (Boost_FOUND)
+    set(Boost_LIBRARIES Boost::boost)
+    # Conditionally add Boost::context only if the found Boost package provides it
+    # The old version is missing Boost::context, so we want to avoid adding in that case
+    # The new version requires adding Boost::context to prevent linking issues
+    if (TARGET Boost::context)
+        list(APPEND Boost_LIBRARIES Boost::context)
+    endif()
+else()
+    message(FATAL_ERROR "Boost 1.73.0 or newer not found")
+endif()
+
 # boost:asio has functions that require AcceptEx et al
 if (MINGW)
     find_library(MSWSOCK_LIBRARY mswsock REQUIRED)
@@ -344,12 +351,12 @@ if(ENABLE_QT)
                 find_package(PkgConfig REQUIRED)
                 pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
                 if (NOT QT_DEP_GLU_FOUND)
-                    message(FATAL_ERROR "Qt bundled package dependency `glu` not found. \
+                    message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
                         Perhaps `libglu1-mesa-dev` needs to be installed?")
                 endif()
                 pkg_check_modules(QT_DEP_MESA QUIET dri>=20.0.8)
                 if (NOT QT_DEP_MESA_FOUND)
-                    message(FATAL_ERROR "Qt bundled package dependency `dri` not found. \
+                    message(FATAL_ERROR "Qt bundled pacakge dependency `dri` not found. \
                         Perhaps `mesa-common-dev` needs to be installed?")
                 endif()
 
@@ -450,6 +457,14 @@ if (ENABLE_SDL2)
     endif()
 endif()
 
+# Reexport some targets that are named differently when using the upstream CmakeConfig
+# In order to ALIAS targets to a new name, they first need to be IMPORTED_GLOBAL
+# Dynarmic checks for target `boost` and so we want to make sure it can find it through our system instead of using their external
+if (TARGET Boost::boost)
+    set_target_properties(Boost::boost PROPERTIES IMPORTED_GLOBAL TRUE)
+    add_library(boost ALIAS Boost::boost)
+endif()
+
 # List of all FFmpeg components required
 set(FFmpeg_COMPONENTS
     avcodec
@@ -477,8 +492,8 @@ if (APPLE)
     find_library(COCOA_LIBRARY Cocoa)
     set(PLATFORM_LIBRARIES ${COCOA_LIBRARY} ${IOKIT_LIBRARY} ${COREVIDEO_LIBRARY})
 elseif (WIN32)
-    # Target Windows 10
-    add_definitions(-D_WIN32_WINNT=0x0A00 -DWINVER=0x0A00)
+    # WSAPoll and SHGetKnownFolderPath (AppData/Roaming) didn't exist before WinNT 6.x (Vista)
+    add_definitions(-D_WIN32_WINNT=0x0600 -DWINVER=0x0600)
     set(PLATFORM_LIBRARIES winmm ws2_32 iphlpapi)
     if (MINGW)
         # PSAPI is the Process Status API
@@ -565,7 +580,11 @@ function(create_target_directory_groups target_name)
 endfunction()
 
 # Prevent boost from linking against libs when building
-target_link_libraries(Boost::headers INTERFACE Boost::disable_autolinking)
+add_definitions(-DBOOST_ERROR_CODE_HEADER_ONLY
+    -DBOOST_SYSTEM_NO_LIB
+    -DBOOST_DATE_TIME_NO_LIB
+    -DBOOST_REGEX_NO_LIB
+)
 # Adjustments for MSVC + Ninja
 if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
     add_compile_options(

CMakeModules/FindFFmpeg.cmake

@@ -14,7 +14,7 @@
 #  FFmpeg_LIBRARIES: aggregate all the paths to the libraries
 #  FFmpeg_FOUND: True if all components have been found
 #
-# This module defines the following targets, which are preferred over variables:
+# This module defines the following targets, which are prefered over variables:
 #
 #  FFmpeg::<component>: Target to use <component> directly, with include path,
 #    library and dependencies set up. If you are using a static build, you are

CMakeModules/FindLLVM.cmake

@@ -2,25 +2,15 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-find_package(LLVM QUIET COMPONENTS CONFIG)
-if (LLVM_FOUND)
-    separate_arguments(LLVM_DEFINITIONS)
-    if (LLVMDemangle IN_LIST LLVM_AVAILABLE_LIBS)
-        set(LLVM_Demangle_FOUND TRUE)
-    endif()
-endif()
+find_package(LLVM QUIET CONFIG)
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(LLVM HANDLE_COMPONENTS CONFIG_MODE)
+find_package_handle_standard_args(LLVM CONFIG_MODE)
 
-if (LLVM_FOUND AND LLVM_Demangle_FOUND AND NOT TARGET LLVM::Demangle)
+if (LLVM_FOUND AND NOT TARGET LLVM::Demangle)
     add_library(LLVM::Demangle INTERFACE IMPORTED)
+    llvm_map_components_to_libnames(LLVM_LIBRARIES demangle)
     target_compile_definitions(LLVM::Demangle INTERFACE ${LLVM_DEFINITIONS})
     target_include_directories(LLVM::Demangle INTERFACE ${LLVM_INCLUDE_DIRS})
-    # prefer shared LLVM: https://github.com/llvm/llvm-project/issues/34593
-    # but use ugly hack because llvm_config doesn't support interface library
-    add_library(_dummy_lib SHARED EXCLUDE_FROM_ALL src/yuzu/main.cpp)
-    llvm_config(_dummy_lib USE_SHARED demangle)
-    get_target_property(LLVM_LIBRARIES _dummy_lib LINK_LIBRARIES)
     target_link_libraries(LLVM::Demangle INTERFACE ${LLVM_LIBRARIES})
 endif()

CMakeModules/Findhttplib.cmake

@@ -6,23 +6,13 @@ include(FindPackageHandleStandardArgs)
 
 find_package(httplib QUIET CONFIG)
 if (httplib_CONSIDERED_CONFIGS)
-    find_package_handle_standard_args(httplib HANDLE_COMPONENTS CONFIG_MODE)
+    find_package_handle_standard_args(httplib CONFIG_MODE)
 else()
     find_package(PkgConfig QUIET)
     pkg_search_module(HTTPLIB QUIET IMPORTED_TARGET cpp-httplib)
-    if ("-DCPPHTTPLIB_OPENSSL_SUPPORT" IN_LIST HTTPLIB_CFLAGS_OTHER)
-        set(httplib_OpenSSL_FOUND TRUE)
-    endif()
-    if ("-DCPPHTTPLIB_ZLIB_SUPPORT" IN_LIST HTTPLIB_CFLAGS_OTHER)
-        set(httplib_ZLIB_FOUND TRUE)
-    endif()
-    if ("-DCPPHTTPLIB_BROTLI_SUPPORT" IN_LIST HTTPLIB_CFLAGS_OTHER)
-        set(httplib_Brotli_FOUND TRUE)
-    endif()
     find_package_handle_standard_args(httplib
         REQUIRED_VARS HTTPLIB_INCLUDEDIR
         VERSION_VAR HTTPLIB_VERSION
-        HANDLE_COMPONENTS
     )
 endif()
 

CMakeModules/Findinih.cmake

@@ -3,25 +3,14 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 find_package(PkgConfig QUIET)
-pkg_search_module(INIH QUIET IMPORTED_TARGET inih)
-if (INIReader IN_LIST inih_FIND_COMPONENTS)
-    pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)
-    if (INIREADER_FOUND)
-        set(inih_INIReader_FOUND TRUE)
-    endif()
-endif()
+pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(inih
-    REQUIRED_VARS INIH_LINK_LIBRARIES
-    VERSION_VAR INIH_VERSION
-    HANDLE_COMPONENTS
+    REQUIRED_VARS INIREADER_LINK_LIBRARIES
+    VERSION_VAR INIREADER_VERSION
 )
 
-if (inih_FOUND AND NOT TARGET inih::inih)
-    add_library(inih::inih ALIAS PkgConfig::INIH)
-endif()
-
-if (inih_FOUND AND inih_INIReader_FOUND AND NOT TARGET inih::INIReader)
+if (inih_FOUND AND NOT TARGET inih::INIReader)
     add_library(inih::INIReader ALIAS PkgConfig::INIREADER)
 endif()

dist/yuzu.manifest

@@ -36,6 +36,12 @@ SPDX-License-Identifier: GPL-2.0-or-later
     <application>
       <!-- Windows 10 -->
       <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+      <!-- Windows 8.1 -->
+      <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+      <!-- Windows 8 -->
+      <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+      <!-- Windows 7 -->
+      <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
     </application>
   </compatibility>
   <trustInfo

externals/CMakeLists.txt

@@ -102,16 +102,41 @@ add_subdirectory(sirit EXCLUDE_FROM_ALL)
 
 # httplib
 if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)
-    set(HTTPLIB_REQUIRE_OPENSSL ON)
-    add_subdirectory(cpp-httplib EXCLUDE_FROM_ALL)
+    if (NOT WIN32)
+        find_package(OpenSSL 1.1)
+        if (OPENSSL_FOUND)
+            set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
+        endif()
+    endif()
+
+    if (WIN32 OR NOT OPENSSL_FOUND)
+        # LibreSSL
+        set(LIBRESSL_SKIP_INSTALL ON)
+        set(OPENSSLDIR "/etc/ssl/")
+        add_subdirectory(libressl EXCLUDE_FROM_ALL)
+        target_include_directories(ssl INTERFACE ./libressl/include)
+        target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
+        get_directory_property(OPENSSL_LIBRARIES
+            DIRECTORY libressl
+            DEFINITION OPENSSL_LIBS)
+    endif()
+
+    add_library(httplib INTERFACE)
+    target_include_directories(httplib INTERFACE ./cpp-httplib)
+    target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
+    target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
+    if (WIN32)
+        target_link_libraries(httplib INTERFACE crypt32 cryptui ws2_32)
+    endif()
+    add_library(httplib::httplib ALIAS httplib)
 endif()
 
 # cpp-jwt
 if (ENABLE_WEB_SERVICE AND NOT TARGET cpp-jwt::cpp-jwt)
-    set(CPP_JWT_BUILD_EXAMPLES OFF)
-    set(CPP_JWT_BUILD_TESTS OFF)
-    set(CPP_JWT_USE_VENDORED_NLOHMANN_JSON OFF)
-    add_subdirectory(cpp-jwt EXCLUDE_FROM_ALL)
+    add_library(cpp-jwt INTERFACE)
+    target_include_directories(cpp-jwt INTERFACE ./cpp-jwt/include)
+    target_compile_definitions(cpp-jwt INTERFACE CPP_JWT_USE_VENDORED_NLOHMANN_JSON)
+    add_library(cpp-jwt::cpp-jwt ALIAS cpp-jwt)
 endif()
 
 # Opus

externals/Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 63af1cf1ee906ba4dcd5a324bdd0201d4f4bfd12
+Subproject commit 00671c64ba5c488ade22ad572a0ef81d5e64c803

externals/cpp-httplib

@@ -1 +1 @@
-Subproject commit 6d963fbe8d415399d65e94db7910bbd22fe3741c
+Subproject commit 305a7abcb9b4e9e349843c6d563212e6c1bbbf21

externals/dynarmic

@@ -1 +1 @@
-Subproject commit c08c5a9362bb224dc343c2f616c24df027dfdf13
+Subproject commit befe547d5631024a70d81d2ccee808bbfcb3854e

externals/libressl

@@ -0,0 +1 @@
+Subproject commit 8929f818fd748fd31a34fec7c04558399e13014a

externals/vcpkg

@@ -1 +1 @@
-Subproject commit a7b6122f6b6504d16d96117336a0562693579933
+Subproject commit 9b22b40c6c61bf0da2d46346dd44a11e90972cc9

src/CMakeLists.txt

@@ -83,7 +83,7 @@ if (MSVC)
     )
 
     if (USE_CCACHE OR YUZU_USE_PRECOMPILED_HEADERS)
-    # when caching, we need to use /Z7 to downgrade debug info to use an older but more cacheable format
+    # when caching, we need to use /Z7 to downgrade debug info to use an older but more cachable format
     # Precompiled headers are deleted if not using /Z7. See https://github.com/nanoant/CMakePCHCompiler/issues/21
         add_compile_options(/Z7)
     else()

src/audio_core/audio_in_manager.cpp

@@ -20,7 +20,7 @@ Manager::Manager(Core::System& system_) : system{system_} {
 Result Manager::AcquireSessionId(size_t& session_id) {
     if (num_free_sessions == 0) {
         LOG_ERROR(Service_Audio, "All 4 AudioIn sessions are in use, cannot create any more");
-        return Service::Audio::ResultOutOfSessions;
+        return Service::Audio::ERR_MAXIMUM_SESSIONS_REACHED;
     }
     session_id = session_ids[next_session_id];
     next_session_id = (next_session_id + 1) % MaxInSessions;

src/audio_core/audio_manager.cpp

@@ -19,7 +19,7 @@ void AudioManager::Shutdown() {
 
 Result AudioManager::SetOutManager(BufferEventFunc buffer_func) {
     if (!running) {
-        return Service::Audio::ResultOperationFailed;
+        return Service::Audio::ERR_OPERATION_FAILED;
     }
 
     std::scoped_lock l{lock};
@@ -35,7 +35,7 @@ Result AudioManager::SetOutManager(BufferEventFunc buffer_func) {
 
 Result AudioManager::SetInManager(BufferEventFunc buffer_func) {
     if (!running) {
-        return Service::Audio::ResultOperationFailed;
+        return Service::Audio::ERR_OPERATION_FAILED;
     }
 
     std::scoped_lock l{lock};

src/audio_core/audio_out_manager.cpp

@@ -19,7 +19,7 @@ Manager::Manager(Core::System& system_) : system{system_} {
 Result Manager::AcquireSessionId(size_t& session_id) {
     if (num_free_sessions == 0) {
         LOG_ERROR(Service_Audio, "All 12 Audio Out sessions are in use, cannot create any more");
-        return Service::Audio::ResultOutOfSessions;
+        return Service::Audio::ERR_MAXIMUM_SESSIONS_REACHED;
     }
     session_id = session_ids[next_session_id];
     next_session_id = (next_session_id + 1) % MaxOutSessions;

src/audio_core/audio_out_manager.h

@@ -58,7 +58,7 @@ public:
     /**
      * Get a list of audio out device names.
      *
-     * @param names     - Output container to write names to.
+     * @oaram names     - Output container to write names to.
      * @return Number of names written.
      */
     u32 GetAudioOutDeviceNames(

src/audio_core/audio_render_manager.cpp

@@ -28,7 +28,7 @@ SystemManager& Manager::GetSystemManager() {
 Result Manager::GetWorkBufferSize(const AudioRendererParameterInternal& params,
                                   u64& out_count) const {
     if (!CheckValidRevision(params.revision)) {
-        return Service::Audio::ResultInvalidRevision;
+        return Service::Audio::ERR_INVALID_REVISION;
     }
 
     out_count = System::GetWorkBufferSize(params);

src/audio_core/device/audio_buffer.h

@@ -16,7 +16,7 @@ struct AudioBuffer {
     s64 played_timestamp;
     /// Game memory address for these samples.
     VAddr samples;
-    /// Unique identifier for this buffer.
+    /// Unqiue identifier for this buffer.
     u64 tag;
     /// Size of the samples buffer.
     u64 size;

src/audio_core/device/device_session.cpp

@@ -93,7 +93,7 @@ void DeviceSession::AppendBuffers(std::span<const AudioBuffer> buffers) const {
             stream->AppendBuffer(new_buffer, samples);
         } else {
             std::vector<s16> samples(buffer.size / sizeof(s16));
-            system.ApplicationMemory().ReadBlockUnsafe(buffer.samples, samples.data(), buffer.size);
+            system.Memory().ReadBlockUnsafe(buffer.samples, samples.data(), buffer.size);
             stream->AppendBuffer(new_buffer, samples);
         }
     }
@@ -102,7 +102,7 @@ void DeviceSession::AppendBuffers(std::span<const AudioBuffer> buffers) const {
 void DeviceSession::ReleaseBuffer(const AudioBuffer& buffer) const {
     if (type == Sink::StreamType::In) {
         auto samples{stream->ReleaseBuffer(buffer.size / sizeof(s16))};
-        system.ApplicationMemory().WriteBlockUnsafe(buffer.samples, samples.data(), buffer.size);
+        system.Memory().WriteBlockUnsafe(buffer.samples, samples.data(), buffer.size);
     }
 }
 
@@ -121,7 +121,8 @@ u64 DeviceSession::GetPlayedSampleCount() const {
 }
 
 std::optional<std::chrono::nanoseconds> DeviceSession::ThreadFunc() {
-    played_sample_count = stream->GetExpectedPlayedSampleCount();
+    // Add 5ms of samples at a 48K sample rate.
+    played_sample_count += 48'000 * INCREMENT_TIME / 1s;
     if (type == Sink::StreamType::Out) {
         system.AudioCore().GetAudioManager().SetEvent(Event::Type::AudioOutManager, true);
     } else {

src/audio_core/in/audio_in.cpp

@@ -46,7 +46,7 @@ Result In::AppendBuffer(const AudioInBuffer& buffer, u64 tag) {
     if (system.AppendBuffer(buffer, tag)) {
         return ResultSuccess;
     }
-    return Service::Audio::ResultBufferCountReached;
+    return Service::Audio::ERR_BUFFER_COUNT_EXCEEDED;
 }
 
 void In::ReleaseAndRegisterBuffers() {

src/audio_core/in/audio_in_system.cpp

@@ -45,11 +45,11 @@ Result System::IsConfigValid(const std::string_view device_name,
                              const AudioInParameter& in_params) const {
     if ((device_name.size() > 0) &&
         (device_name != GetDefaultDeviceName() && device_name != GetDefaultUacDeviceName())) {
-        return Service::Audio::ResultNotFound;
+        return Service::Audio::ERR_INVALID_DEVICE_NAME;
     }
 
     if (in_params.sample_rate != TargetSampleRate && in_params.sample_rate > 0) {
-        return Service::Audio::ResultInvalidSampleRate;
+        return Service::Audio::ERR_INVALID_SAMPLE_RATE;
     }
 
     return ResultSuccess;
@@ -80,7 +80,7 @@ Result System::Initialize(std::string device_name, const AudioInParameter& in_pa
 
 Result System::Start() {
     if (state != State::Stopped) {
-        return Service::Audio::ResultOperationFailed;
+        return Service::Audio::ERR_OPERATION_FAILED;
     }
 
     session->Initialize(name, sample_format, channel_count, session_id, handle,

src/audio_core/out/audio_out.cpp

@@ -46,7 +46,7 @@ Result Out::AppendBuffer(const AudioOutBuffer& buffer, const u64 tag) {
     if (system.AppendBuffer(buffer, tag)) {
         return ResultSuccess;
     }
-    return Service::Audio::ResultBufferCountReached;
+    return Service::Audio::ERR_BUFFER_COUNT_EXCEEDED;
 }
 
 void Out::ReleaseAndRegisterBuffers() {

src/audio_core/out/audio_out_system.cpp

@@ -33,11 +33,11 @@ std::string_view System::GetDefaultOutputDeviceName() const {
 Result System::IsConfigValid(std::string_view device_name,
                              const AudioOutParameter& in_params) const {
     if ((device_name.size() > 0) && (device_name != GetDefaultOutputDeviceName())) {
-        return Service::Audio::ResultNotFound;
+        return Service::Audio::ERR_INVALID_DEVICE_NAME;
     }
 
     if (in_params.sample_rate != TargetSampleRate && in_params.sample_rate > 0) {
-        return Service::Audio::ResultInvalidSampleRate;
+        return Service::Audio::ERR_INVALID_SAMPLE_RATE;
     }
 
     if (in_params.channel_count == 0 || in_params.channel_count == 2 ||
@@ -45,7 +45,7 @@ Result System::IsConfigValid(std::string_view device_name,
         return ResultSuccess;
     }
 
-    return Service::Audio::ResultInvalidChannelCount;
+    return Service::Audio::ERR_INVALID_CHANNEL_COUNT;
 }
 
 Result System::Initialize(std::string device_name, const AudioOutParameter& in_params, u32 handle_,
@@ -80,7 +80,7 @@ size_t System::GetSessionId() const {
 
 Result System::Start() {
     if (state != State::Stopped) {
-        return Service::Audio::ResultOperationFailed;
+        return Service::Audio::ERR_OPERATION_FAILED;
     }
 
     session->Initialize(name, sample_format, channel_count, session_id, handle,

src/audio_core/renderer/adsp/adsp.cpp

@@ -13,7 +13,7 @@
 namespace AudioCore::AudioRenderer::ADSP {
 
 ADSP::ADSP(Core::System& system_, Sink::Sink& sink_)
-    : system{system_}, memory{system.ApplicationMemory()}, sink{sink_} {}
+    : system{system_}, memory{system.Memory()}, sink{sink_} {}
 
 ADSP::~ADSP() {
     ClearCommandBuffers();

src/audio_core/renderer/adsp/audio_renderer.cpp

@@ -132,10 +132,10 @@ void AudioRenderer::CreateSinkStreams() {
 }
 
 void AudioRenderer::ThreadFunc() {
-    static constexpr char name[]{"AudioRenderer"};
+    constexpr char name[]{"AudioRenderer"};
     MicroProfileOnThreadCreate(name);
     Common::SetCurrentThreadName(name);
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
     if (mailbox->ADSPWaitMessage() != RenderMessage::AudioRenderer_InitializeOK) {
         LOG_ERROR(Service_Audio,
                   "ADSP Audio Renderer -- Failed to receive initialize message from host!");
@@ -165,7 +165,7 @@ void AudioRenderer::ThreadFunc() {
                 // Check this buffer is valid, as it may not be used.
                 if (command_buffer.buffer != 0) {
                     // If there are no remaining commands (from the previous list),
-                    // this is a new command list, initialize it.
+                    // this is a new command list, initalize it.
                     if (command_buffer.remaining_command_count == 0) {
                         command_list_processor.Initialize(system, command_buffer.buffer,
                                                           command_buffer.size, streams[index]);
@@ -189,8 +189,6 @@ void AudioRenderer::ThreadFunc() {
                     max_time = std::min(command_buffer.time_limit, max_time);
                     command_list_processor.SetProcessTimeMax(max_time);
 
-                    streams[index]->WaitFreeSpace();
-
                     // Process the command list
                     {
                         MICROPROFILE_SCOPE(Audio_Renderer);

src/audio_core/renderer/adsp/audio_renderer.h

@@ -10,7 +10,6 @@
 #include "audio_core/renderer/adsp/command_buffer.h"
 #include "audio_core/renderer/adsp/command_list_processor.h"
 #include "common/common_types.h"
-#include "common/polyfill_thread.h"
 #include "common/reader_writer_queue.h"
 #include "common/thread.h"
 

src/audio_core/renderer/adsp/command_list_processor.cpp

@@ -17,7 +17,7 @@ namespace AudioCore::AudioRenderer::ADSP {
 void CommandListProcessor::Initialize(Core::System& system_, CpuAddr buffer, u64 size,
                                       Sink::SinkStream* stream_) {
     system = &system_;
-    memory = &system->ApplicationMemory();
+    memory = &system->Memory();
     stream = stream_;
     header = reinterpret_cast<CommandListHeader*>(buffer);
     commands = reinterpret_cast<u8*>(buffer + sizeof(CommandListHeader));

src/audio_core/renderer/audio_renderer.cpp

@@ -22,7 +22,7 @@ Result Renderer::Initialize(const AudioRendererParameterInternal& params,
         if (!manager.AddSystem(system)) {
             LOG_ERROR(Service_Audio,
                       "Both Audio Render sessions are in use, cannot create any more");
-            return Service::Audio::ResultOutOfSessions;
+            return Service::Audio::ERR_MAXIMUM_SESSIONS_REACHED;
         }
         system_registered = true;
     }

src/audio_core/renderer/behavior/behavior_info.h

@@ -155,7 +155,7 @@ public:
     /**
      * Check if a variadic command buffer is supported.
      * As of Rev 5 with the added optional performance metric logging, the command
-     * buffer can be a variable size, so take that into account for calculating its size.
+     * buffer can be a variable size, so take that into account for calcualting its size.
      *
      * @return True if supported, otherwise false.
      */

src/audio_core/renderer/behavior/info_updater.cpp

@@ -48,7 +48,7 @@ Result InfoUpdater::UpdateVoiceChannelResources(VoiceContext& voice_context) {
         LOG_ERROR(Service_Audio,
                   "Consumed an incorrect voice resource size, header size={}, consumed={}",
                   in_header->voice_resources_size, consumed_input_size);
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     input += consumed_input_size;
@@ -123,7 +123,7 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
     if (consumed_input_size != in_header->voices_size) {
         LOG_ERROR(Service_Audio, "Consumed an incorrect voices size, header size={}, consumed={}",
                   in_header->voices_size, consumed_input_size);
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     out_header->voices_size = consumed_output_size;
@@ -184,7 +184,7 @@ Result InfoUpdater::UpdateEffectsVersion1(EffectContext& effect_context, const b
     if (consumed_input_size != in_header->effects_size) {
         LOG_ERROR(Service_Audio, "Consumed an incorrect effects size, header size={}, consumed={}",
                   in_header->effects_size, consumed_input_size);
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     out_header->effects_size = consumed_output_size;
@@ -239,7 +239,7 @@ Result InfoUpdater::UpdateEffectsVersion2(EffectContext& effect_context, const b
     if (consumed_input_size != in_header->effects_size) {
         LOG_ERROR(Service_Audio, "Consumed an incorrect effects size, header size={}, consumed={}",
                   in_header->effects_size, consumed_input_size);
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     out_header->effects_size = consumed_output_size;
@@ -267,7 +267,7 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
     }
 
     if (mix_buffer_count == 0) {
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     std::span<const MixInfo::InParameter> in_params{
@@ -281,13 +281,13 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
             total_buffer_count += params.buffer_count;
             if (params.dest_mix_id > static_cast<s32>(mix_context.GetCount()) &&
                 params.dest_mix_id != UnusedMixId && params.mix_id != FinalMixId) {
-                return Service::Audio::ResultInvalidUpdateInfo;
+                return Service::Audio::ERR_INVALID_UPDATE_DATA;
             }
         }
     }
 
     if (total_buffer_count > mix_buffer_count) {
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     bool mix_dirty{false};
@@ -317,7 +317,7 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
     if (mix_dirty) {
         if (behaviour.IsSplitterSupported() && splitter_context.UsingSplitter()) {
             if (!mix_context.TSortInfo(splitter_context)) {
-                return Service::Audio::ResultInvalidUpdateInfo;
+                return Service::Audio::ERR_INVALID_UPDATE_DATA;
             }
         } else {
             mix_context.SortInfo();
@@ -327,7 +327,7 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
     if (consumed_input_size != in_header->mix_size) {
         LOG_ERROR(Service_Audio, "Consumed an incorrect mixes size, header size={}, consumed={}",
                   in_header->mix_size, consumed_input_size);
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     input += mix_count * sizeof(MixInfo::InParameter);
@@ -384,7 +384,7 @@ Result InfoUpdater::UpdateSinks(SinkContext& sink_context, std::span<MemoryPoolI
     if (consumed_input_size != in_header->sinks_size) {
         LOG_ERROR(Service_Audio, "Consumed an incorrect sinks size, header size={}, consumed={}",
                   in_header->sinks_size, consumed_input_size);
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     input += consumed_input_size;
@@ -411,7 +411,7 @@ Result InfoUpdater::UpdateMemoryPools(std::span<MemoryPoolInfo> memory_pools,
             state != MemoryPoolInfo::ResultState::MapFailed &&
             state != MemoryPoolInfo::ResultState::InUse) {
             LOG_WARNING(Service_Audio, "Invalid ResultState from updating memory pools");
-            return Service::Audio::ResultInvalidUpdateInfo;
+            return Service::Audio::ERR_INVALID_UPDATE_DATA;
         }
     }
 
@@ -423,7 +423,7 @@ Result InfoUpdater::UpdateMemoryPools(std::span<MemoryPoolInfo> memory_pools,
         LOG_ERROR(Service_Audio,
                   "Consumed an incorrect memory pool size, header size={}, consumed={}",
                   in_header->memory_pool_size, consumed_input_size);
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     input += consumed_input_size;
@@ -453,7 +453,7 @@ Result InfoUpdater::UpdatePerformanceBuffer(std::span<u8> performance_output,
         LOG_ERROR(Service_Audio,
                   "Consumed an incorrect performance size, header size={}, consumed={}",
                   in_header->performance_buffer_size, consumed_input_size);
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     input += consumed_input_size;
@@ -467,18 +467,18 @@ Result InfoUpdater::UpdateBehaviorInfo(BehaviorInfo& behaviour_) {
     const auto in_params{reinterpret_cast<const BehaviorInfo::InParameter*>(input)};
 
     if (!CheckValidRevision(in_params->revision)) {
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     if (in_params->revision != behaviour_.GetUserRevision()) {
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     behaviour_.ClearError();
     behaviour_.UpdateFlags(in_params->flags);
 
     if (in_header->behaviour_size != sizeof(BehaviorInfo::InParameter)) {
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     input += sizeof(BehaviorInfo::InParameter);
@@ -500,7 +500,7 @@ Result InfoUpdater::UpdateErrorInfo(const BehaviorInfo& behaviour_) {
 Result InfoUpdater::UpdateSplitterInfo(SplitterContext& splitter_context) {
     u32 consumed_size{0};
     if (!splitter_context.Update(input, consumed_size)) {
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
 
     input += consumed_size;
@@ -529,9 +529,9 @@ Result InfoUpdater::UpdateRendererInfo(const u64 elapsed_frames) {
 
 Result InfoUpdater::CheckConsumedSize() {
     if (CpuAddr(input) - CpuAddr(input_origin.data()) != expected_input_size) {
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     } else if (CpuAddr(output) - CpuAddr(output_origin.data()) != expected_output_size) {
-        return Service::Audio::ResultInvalidUpdateInfo;
+        return Service::Audio::ERR_INVALID_UPDATE_DATA;
     }
     return ResultSuccess;
 }

src/audio_core/renderer/command/command_buffer.cpp

@@ -251,8 +251,8 @@ void CommandBuffer::GenerateBiquadFilterCommand(const s32 node_id, EffectInfoBas
 
     const auto& parameter{
         *reinterpret_cast<BiquadFilterInfo::ParameterVersion1*>(effect_info.GetParameter())};
-    const auto state{reinterpret_cast<VoiceState::BiquadFilterState*>(
-        effect_info.GetStateBuffer() + channel * sizeof(VoiceState::BiquadFilterState))};
+    const auto state{
+        reinterpret_cast<VoiceState::BiquadFilterState*>(effect_info.GetStateBuffer())};
 
     cmd.input = buffer_offset + parameter.inputs[channel];
     cmd.output = buffer_offset + parameter.outputs[channel];

src/audio_core/renderer/command/command_generator.cpp

@@ -46,7 +46,7 @@ void CommandGenerator::GenerateDataSourceCommand(VoiceInfo& voice_info,
             while (destination != nullptr) {
                 if (destination->IsConfigured()) {
                     auto mix_id{destination->GetMixId()};
-                    if (mix_id < mix_context.GetCount() && mix_id != UnusedSplitterId) {
+                    if (mix_id < mix_context.GetCount()) {
                         auto mix_info{mix_context.GetInfo(mix_id)};
                         command_buffer.GenerateDepopPrepareCommand(
                             voice_info.node_id, voice_state, render_context.depop_buffer,

src/audio_core/renderer/command/effect/aux_.cpp

@@ -4,7 +4,6 @@
 #include "audio_core/renderer/adsp/command_list_processor.h"
 #include "audio_core/renderer/command/effect/aux_.h"
 #include "audio_core/renderer/effect/aux_.h"
-#include "core/core.h"
 #include "core/memory.h"
 
 namespace AudioCore::AudioRenderer {
@@ -20,24 +19,10 @@ static void ResetAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr aux_in
         return;
     }
 
-    AuxInfo::AuxInfoDsp info{};
-    auto info_ptr{&info};
-    bool host_safe{(aux_info & Core::Memory::YUZU_PAGEMASK) <=
-                   (Core::Memory::YUZU_PAGESIZE - sizeof(AuxInfo::AuxInfoDsp))};
-
-    if (host_safe) [[likely]] {
-        info_ptr = memory.GetPointer<AuxInfo::AuxInfoDsp>(aux_info);
-    } else {
-        memory.ReadBlockUnsafe(aux_info, info_ptr, sizeof(AuxInfo::AuxInfoDsp));
-    }
-
-    info_ptr->read_offset = 0;
-    info_ptr->write_offset = 0;
-    info_ptr->total_sample_count = 0;
-
-    if (!host_safe) [[unlikely]] {
-        memory.WriteBlockUnsafe(aux_info, info_ptr, sizeof(AuxInfo::AuxInfoDsp));
-    }
+    auto info{reinterpret_cast<AuxInfo::AuxInfoDsp*>(memory.GetPointer(aux_info))};
+    info->read_offset = 0;
+    info->write_offset = 0;
+    info->total_sample_count = 0;
 }
 
 /**
@@ -55,10 +40,11 @@ static void ResetAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr aux_in
  * @param update_count - If non-zero, send_info_ will be updated.
  * @return Number of samples written.
  */
-static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, CpuAddr send_info_,
-                             [[maybe_unused]] u32 sample_count, CpuAddr send_buffer, u32 count_max,
-                             std::span<const s32> input, u32 write_count_, u32 write_offset,
-                             u32 update_count) {
+static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_info_,
+                             [[maybe_unused]] u32 sample_count, const CpuAddr send_buffer,
+                             const u32 count_max, std::span<const s32> input,
+                             const u32 write_count_, const u32 write_offset,
+                             const u32 update_count) {
     if (write_count_ > count_max) {
         LOG_ERROR(Service_Audio,
                   "write_count must be smaller than count_max! write_count {}, count_max {}",
@@ -66,11 +52,6 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, CpuAddr send_info_,
         return 0;
     }
 
-    if (send_info_ == 0) {
-        LOG_ERROR(Service_Audio, "send_info_ is 0!");
-        return 0;
-    }
-
     if (input.empty()) {
         LOG_ERROR(Service_Audio, "input buffer is empty!");
         return 0;
@@ -86,47 +67,33 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, CpuAddr send_info_,
     }
 
     AuxInfo::AuxInfoDsp send_info{};
-    auto send_ptr = &send_info;
-    bool host_safe = (send_info_ & Core::Memory::YUZU_PAGEMASK) <=
-                     (Core::Memory::YUZU_PAGESIZE - sizeof(AuxInfo::AuxInfoDsp));
+    memory.ReadBlockUnsafe(send_info_, &send_info, sizeof(AuxInfo::AuxInfoDsp));
 
-    if (host_safe) [[likely]] {
-        send_ptr = memory.GetPointer<AuxInfo::AuxInfoDsp>(send_info_);
-    } else {
-        memory.ReadBlockUnsafe(send_info_, send_ptr, sizeof(AuxInfo::AuxInfoDsp));
-    }
-
-    u32 target_write_offset{send_ptr->write_offset + write_offset};
-    if (target_write_offset > count_max) {
+    u32 target_write_offset{send_info.write_offset + write_offset};
+    if (target_write_offset > count_max || write_count_ == 0) {
         return 0;
     }
 
     u32 write_count{write_count_};
-    u32 read_pos{0};
+    u32 write_pos{0};
     while (write_count > 0) {
         u32 to_write{std::min(count_max - target_write_offset, write_count)};
-        const auto write_addr = send_buffer + target_write_offset * sizeof(s32);
-        bool write_safe{(write_addr & Core::Memory::YUZU_PAGEMASK) <=
-                        (Core::Memory::YUZU_PAGESIZE - (write_addr + to_write * sizeof(s32)))};
-        if (write_safe) [[likely]] {
-            auto ptr = memory.GetPointer(write_addr);
-            std::memcpy(ptr, &input[read_pos], to_write * sizeof(s32));
-        } else {
+
+        if (to_write > 0) {
             memory.WriteBlockUnsafe(send_buffer + target_write_offset * sizeof(s32),
-                                    &input[read_pos], to_write * sizeof(s32));
+                                    &input[write_pos], to_write * sizeof(s32));
         }
+
         target_write_offset = (target_write_offset + to_write) % count_max;
         write_count -= to_write;
-        read_pos += to_write;
+        write_pos += to_write;
     }
 
     if (update_count) {
-        send_ptr->write_offset = (send_ptr->write_offset + update_count) % count_max;
+        send_info.write_offset = (send_info.write_offset + update_count) % count_max;
     }
 
-    if (!host_safe) [[unlikely]] {
-        memory.WriteBlockUnsafe(send_info_, send_ptr, sizeof(AuxInfo::AuxInfoDsp));
-    }
+    memory.WriteBlockUnsafe(send_info_, &send_info, sizeof(AuxInfo::AuxInfoDsp));
 
     return write_count_;
 }
@@ -135,7 +102,7 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, CpuAddr send_info_,
  * Read the given memory at return_buffer into the output mix buffer, and update return_info_ if
  * update_count is set, to notify the game that an update happened.
  *
- * @param memory        - Core memory for reading.
+ * @param memory        - Core memory for writing.
  * @param return_info_  - Meta information for where to read the mix buffer.
  * @param return_buffer - Memory address to read the samples from.
  * @param count_max     - Maximum number of samples in the receiving buffer.
@@ -145,21 +112,16 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, CpuAddr send_info_,
  * @param update_count  - If non-zero, send_info_ will be updated.
  * @return Number of samples read.
  */
-static u32 ReadAuxBufferDsp(Core::Memory::Memory& memory, CpuAddr return_info_,
-                            CpuAddr return_buffer, u32 count_max, std::span<s32> output,
-                            u32 read_count_, u32 read_offset, u32 update_count) {
+static u32 ReadAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr return_info_,
+                            const CpuAddr return_buffer, const u32 count_max, std::span<s32> output,
+                            const u32 count_, const u32 read_offset, const u32 update_count) {
     if (count_max == 0) {
         return 0;
     }
 
-    if (read_count_ > count_max) {
+    if (count_ > count_max) {
         LOG_ERROR(Service_Audio, "count must be smaller than count_max! count {}, count_max {}",
-                  read_count_, count_max);
-        return 0;
-    }
-
-    if (return_info_ == 0) {
-        LOG_ERROR(Service_Audio, "return_info_ is 0!");
+                  count_, count_max);
         return 0;
     }
 
@@ -174,49 +136,35 @@ static u32 ReadAuxBufferDsp(Core::Memory::Memory& memory, CpuAddr return_info_,
     }
 
     AuxInfo::AuxInfoDsp return_info{};
-    auto return_ptr = &return_info;
-    bool host_safe = (return_info_ & Core::Memory::YUZU_PAGEMASK) <=
-                     (Core::Memory::YUZU_PAGESIZE - sizeof(AuxInfo::AuxInfoDsp));
+    memory.ReadBlockUnsafe(return_info_, &return_info, sizeof(AuxInfo::AuxInfoDsp));
 
-    if (host_safe) [[likely]] {
-        return_ptr = memory.GetPointer<AuxInfo::AuxInfoDsp>(return_info_);
-    } else {
-        memory.ReadBlockUnsafe(return_info_, return_ptr, sizeof(AuxInfo::AuxInfoDsp));
-    }
-
-    u32 target_read_offset{return_ptr->read_offset + read_offset};
+    u32 target_read_offset{return_info.read_offset + read_offset};
     if (target_read_offset > count_max) {
         return 0;
     }
 
-    u32 read_count{read_count_};
-    u32 write_pos{0};
+    u32 read_count{count_};
+    u32 read_pos{0};
     while (read_count > 0) {
         u32 to_read{std::min(count_max - target_read_offset, read_count)};
-        const auto read_addr = return_buffer + target_read_offset * sizeof(s32);
-        bool read_safe{(read_addr & Core::Memory::YUZU_PAGEMASK) <=
-                       (Core::Memory::YUZU_PAGESIZE - (read_addr + to_read * sizeof(s32)))};
-        if (read_safe) [[likely]] {
-            auto ptr = memory.GetPointer(read_addr);
-            std::memcpy(&output[write_pos], ptr, to_read * sizeof(s32));
-        } else {
+
+        if (to_read > 0) {
             memory.ReadBlockUnsafe(return_buffer + target_read_offset * sizeof(s32),
-                                   &output[write_pos], to_read * sizeof(s32));
+                                   &output[read_pos], to_read * sizeof(s32));
         }
+
         target_read_offset = (target_read_offset + to_read) % count_max;
         read_count -= to_read;
-        write_pos += to_read;
+        read_pos += to_read;
     }
 
     if (update_count) {
-        return_ptr->read_offset = (return_ptr->read_offset + update_count) % count_max;
+        return_info.read_offset = (return_info.read_offset + update_count) % count_max;
     }
 
-    if (!host_safe) [[unlikely]] {
-        memory.WriteBlockUnsafe(return_info_, return_ptr, sizeof(AuxInfo::AuxInfoDsp));
-    }
+    memory.WriteBlockUnsafe(return_info_, &return_info, sizeof(AuxInfo::AuxInfoDsp));
 
-    return read_count_;
+    return count_;
 }
 
 void AuxCommand::Dump([[maybe_unused]] const ADSP::CommandListProcessor& processor,
@@ -241,7 +189,7 @@ void AuxCommand::Process(const ADSP::CommandListProcessor& processor) {
                                    update_count)};
 
         if (read != processor.sample_count) {
-            std::memset(&output_buffer[read], 0, (processor.sample_count - read) * sizeof(s32));
+            std::memset(&output_buffer[read], 0, processor.sample_count - read);
         }
     } else {
         ResetAuxBufferDsp(*processor.memory, send_buffer_info);

src/audio_core/renderer/command/effect/biquad_filter.cpp

@@ -4,7 +4,6 @@
 #include "audio_core/renderer/adsp/command_list_processor.h"
 #include "audio_core/renderer/command/effect/biquad_filter.h"
 #include "audio_core/renderer/voice/voice_state.h"
-#include "common/bit_cast.h"
 
 namespace AudioCore::AudioRenderer {
 /**
@@ -20,21 +19,21 @@ namespace AudioCore::AudioRenderer {
 void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
                             std::array<s16, 3>& b_, std::array<s16, 2>& a_,
                             VoiceState::BiquadFilterState& state, const u32 sample_count) {
-    constexpr f64 min{std::numeric_limits<s32>::min()};
-    constexpr f64 max{std::numeric_limits<s32>::max()};
+    constexpr s64 min{std::numeric_limits<s32>::min()};
+    constexpr s64 max{std::numeric_limits<s32>::max()};
     std::array<f64, 3> b{Common::FixedPoint<50, 14>::from_base(b_[0]).to_double(),
                          Common::FixedPoint<50, 14>::from_base(b_[1]).to_double(),
                          Common::FixedPoint<50, 14>::from_base(b_[2]).to_double()};
     std::array<f64, 2> a{Common::FixedPoint<50, 14>::from_base(a_[0]).to_double(),
                          Common::FixedPoint<50, 14>::from_base(a_[1]).to_double()};
-    std::array<f64, 4> s{Common::BitCast<f64>(state.s0), Common::BitCast<f64>(state.s1),
-                         Common::BitCast<f64>(state.s2), Common::BitCast<f64>(state.s3)};
+    std::array<f64, 4> s{state.s0.to_double(), state.s1.to_double(), state.s2.to_double(),
+                         state.s3.to_double()};
 
     for (u32 i = 0; i < sample_count; i++) {
         f64 in_sample{static_cast<f64>(input[i])};
         auto sample{in_sample * b[0] + s[0] * b[1] + s[1] * b[2] + s[2] * a[0] + s[3] * a[1]};
 
-        output[i] = static_cast<s32>(std::clamp(sample, min, max));
+        output[i] = static_cast<s32>(std::clamp(static_cast<s64>(sample), min, max));
 
         s[1] = s[0];
         s[0] = in_sample;
@@ -42,10 +41,10 @@ void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
         s[2] = sample;
     }
 
-    state.s0 = Common::BitCast<s64>(s[0]);
-    state.s1 = Common::BitCast<s64>(s[1]);
-    state.s2 = Common::BitCast<s64>(s[2]);
-    state.s3 = Common::BitCast<s64>(s[3]);
+    state.s0 = s[0];
+    state.s1 = s[1];
+    state.s2 = s[2];
+    state.s3 = s[3];
 }
 
 /**
@@ -59,20 +58,29 @@ void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
  * @param sample_count - Number of samples to process.
  */
 static void ApplyBiquadFilterInt(std::span<s32> output, std::span<const s32> input,
-                                 std::array<s16, 3>& b, std::array<s16, 2>& a,
+                                 std::array<s16, 3>& b_, std::array<s16, 2>& a_,
                                  VoiceState::BiquadFilterState& state, const u32 sample_count) {
     constexpr s64 min{std::numeric_limits<s32>::min()};
     constexpr s64 max{std::numeric_limits<s32>::max()};
+    std::array<Common::FixedPoint<50, 14>, 3> b{
+        Common::FixedPoint<50, 14>::from_base(b_[0]),
+        Common::FixedPoint<50, 14>::from_base(b_[1]),
+        Common::FixedPoint<50, 14>::from_base(b_[2]),
+    };
+    std::array<Common::FixedPoint<50, 14>, 3> a{
+        Common::FixedPoint<50, 14>::from_base(a_[0]),
+        Common::FixedPoint<50, 14>::from_base(a_[1]),
+    };
 
     for (u32 i = 0; i < sample_count; i++) {
-        const s64 in_sample{input[i]};
-        const s64 sample{in_sample * b[0] + state.s0};
-        const s64 out_sample{std::clamp<s64>((sample + (1 << 13)) >> 14, min, max)};
+        s64 in_sample{input[i]};
+        auto sample{in_sample * b[0] + state.s0};
+        const auto out_sample{std::clamp(sample.to_long(), min, max)};
 
         output[i] = static_cast<s32>(out_sample);
 
         state.s0 = state.s1 + b[1] * in_sample + a[0] * out_sample;
-        state.s1 = b[2] * in_sample + a[1] * out_sample;
+        state.s1 = 0 + b[2] * in_sample + a[1] * out_sample;
     }
 }
 

src/audio_core/renderer/command/effect/i3dl2_reverb.cpp

@@ -244,16 +244,16 @@ template <size_t NumChannels>
 static void ApplyI3dl2ReverbEffect(I3dl2ReverbInfo::State& state,
                                    std::span<std::span<const s32>> inputs,
                                    std::span<std::span<s32>> outputs, const u32 sample_count) {
-    static constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
+    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     };
-    static constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
+    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
         0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,
     };
-    static constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
+    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
         0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 3, 3, 3,
     };
-    static constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
+    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
         2, 0, 0, 1, 1, 1, 1, 4, 4, 4, 1, 1, 1, 0, 0, 0, 0, 5, 5, 5,
     };
 

src/audio_core/renderer/command/effect/reverb.cpp

@@ -252,16 +252,16 @@ template <size_t NumChannels>
 static void ApplyReverbEffect(const ReverbInfo::ParameterVersion2& params, ReverbInfo::State& state,
                               std::vector<std::span<const s32>>& inputs,
                               std::vector<std::span<s32>>& outputs, const u32 sample_count) {
-    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
+    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     };
-    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
+    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
         0, 0, 1, 1, 0, 1, 0, 0, 1, 1,
     };
-    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
+    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
         0, 0, 1, 1, 0, 1, 2, 2, 3, 3,
     };
-    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
+    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
         0, 0, 1, 1, 2, 2, 4, 4, 5, 5,
     };
 
@@ -308,8 +308,7 @@ static void ApplyReverbEffect(const ReverbInfo::ParameterVersion2& params, Rever
         }
 
         Common::FixedPoint<50, 14> pre_delay_sample{
-            state.pre_delay_line.TapOut(state.pre_delay_time) *
-            Common::FixedPoint<50, 14>::from_base(params.late_gain)};
+            state.pre_delay_line.Read() * Common::FixedPoint<50, 14>::from_base(params.late_gain)};
 
         std::array<Common::FixedPoint<50, 14>, ReverbInfo::MaxDelayLines> mix_matrix{
             state.prev_feedback_output[2] + state.prev_feedback_output[1] + pre_delay_sample,

src/audio_core/renderer/command/resample/upsample.cpp

@@ -19,24 +19,24 @@ namespace AudioCore::AudioRenderer {
 static void SrcProcessFrame(std::span<s32> output, std::span<const s32> input,
                             const u32 target_sample_count, const u32 source_sample_count,
                             UpsamplerState* state) {
-    static constexpr u32 WindowSize = 10;
-    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc1{
+    constexpr u32 WindowSize = 10;
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc1{
         0.95376587f,   -0.12872314f, 0.060028076f,  -0.032470703f, 0.017669678f,
         -0.009124756f, 0.004272461f, -0.001739502f, 0.000579834f,  -0.000091552734f,
     };
-    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc2{
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc2{
         0.8230896f,    -0.19161987f,  0.093444824f,  -0.05090332f,   0.027557373f,
         -0.014038086f, 0.0064697266f, -0.002532959f, 0.00079345703f, -0.00012207031f,
     };
-    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc3{
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc3{
         0.6298828f,    -0.19274902f, 0.09725952f,    -0.05319214f,  0.028625488f,
         -0.014373779f, 0.006500244f, -0.0024719238f, 0.0007324219f, -0.000091552734f,
     };
-    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc4{
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc4{
         0.4057312f,    -0.1468811f,  0.07601929f,    -0.041656494f,  0.022216797f,
         -0.011016846f, 0.004852295f, -0.0017700195f, 0.00048828125f, -0.000030517578f,
     };
-    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc5{
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc5{
         0.1854248f,    -0.075164795f, 0.03967285f,    -0.021728516f,  0.011474609f,
         -0.005584717f, 0.0024108887f, -0.0008239746f, 0.00021362305f, 0.0f,
     };

src/audio_core/renderer/effect/effect_info_base.h

@@ -192,7 +192,7 @@ public:
     /**
      * Get this effect's parameter data.
      *
-     * @return Pointer to the parameter, must be cast to the correct type.
+     * @return Pointer to the parametter, must be cast to the correct type.
      */
     u8* GetParameter() {
         return parameter.data();
@@ -201,7 +201,7 @@ public:
     /**
      * Get this effect's parameter data.
      *
-     * @return Pointer to the parameter, must be cast to the correct type.
+     * @return Pointer to the parametter, must be cast to the correct type.
      */
     u8* GetStateBuffer() {
         return state.data();

src/audio_core/renderer/effect/i3dl2.h

@@ -104,8 +104,7 @@ public:
         }
 
         void Write(const Common::FixedPoint<50, 14> sample) {
-            *input = sample;
-            input++;
+            *(input++) = sample;
             if (input >= buffer_end) {
                 input = buffer.data();
             }

src/audio_core/renderer/effect/reverb.h

@@ -79,10 +79,12 @@ public:
                 return;
             }
             sample_count = delay_time;
-            input = &buffer[0];
+            input = &buffer[(output - buffer.data() + sample_count) % (sample_count_max + 1)];
         }
 
         Common::FixedPoint<50, 14> Tick(const Common::FixedPoint<50, 14> sample) {
+            Write(sample);
+
             auto out_sample{Read()};
 
             output++;
@@ -90,7 +92,6 @@ public:
                 output = buffer.data();
             }
 
-            Write(sample);
             return out_sample;
         }
 
@@ -99,8 +100,7 @@ public:
         }
 
         void Write(const Common::FixedPoint<50, 14> sample) {
-            *input = sample;
-            input++;
+            *(input++) = sample;
             if (input >= buffer_end) {
                 input = buffer.data();
             }

src/audio_core/renderer/memory/memory_pool_info.h

@@ -29,7 +29,7 @@ public:
      */
     enum class State {
         Invalid,
-        Acquired,
+        Aquired,
         RequestDetach,
         Detached,
         RequestAttach,

src/audio_core/renderer/memory/pool_mapper.cpp

@@ -92,7 +92,7 @@ bool PoolMapper::TryAttachBuffer(BehaviorInfo::ErrorInfo& error_info, AddressInf
     address_info.Setup(address, size);
 
     if (!FillDspAddr(address_info)) {
-        error_info.error_code = Service::Audio::ResultInvalidAddressInfo;
+        error_info.error_code = Service::Audio::ERR_POOL_MAPPING_FAILED;
         error_info.address = address;
         return force_map;
     }

src/audio_core/renderer/mix/mix_context.h

@@ -93,7 +93,7 @@ public:
      * Splitter sort, traverse the splitter node graph and sort the sorted mixes from results.
      *
      * @param splitter_context - Splitter context for the sort.
-     * @return True if the sort was successful, otherwise false.
+     * @return True if the sort was successful, othewise false.
      */
     bool TSortInfo(const SplitterContext& splitter_context);
 

src/audio_core/renderer/performance/performance_detail.h

@@ -33,7 +33,7 @@ struct PerformanceDetailVersion1 {
     /* 0x0D */ PerformanceEntryType entry_type;
 };
 static_assert(sizeof(PerformanceDetailVersion1) == 0x10,
-              "PerformanceDetailVersion1 has the wrong size!");
+              "PerformanceDetailVersion1 has the worng size!");
 
 struct PerformanceDetailVersion2 {
     /* 0x00 */ u32 node_id;
@@ -45,6 +45,6 @@ struct PerformanceDetailVersion2 {
     /* 0x14 */ char unk14[0x4];
 };
 static_assert(sizeof(PerformanceDetailVersion2) == 0x18,
-              "PerformanceDetailVersion2 has the wrong size!");
+              "PerformanceDetailVersion2 has the worng size!");
 
 } // namespace AudioCore::AudioRenderer

src/audio_core/renderer/performance/performance_entry.h

@@ -22,7 +22,7 @@ struct PerformanceEntryVersion1 {
     /* 0x0C */ PerformanceEntryType entry_type;
 };
 static_assert(sizeof(PerformanceEntryVersion1) == 0x10,
-              "PerformanceEntryVersion1 has the wrong size!");
+              "PerformanceEntryVersion1 has the worng size!");
 
 struct PerformanceEntryVersion2 {
     /* 0x00 */ u32 node_id;
@@ -32,6 +32,6 @@ struct PerformanceEntryVersion2 {
     /* 0x0D */ char unk0D[0xB];
 };
 static_assert(sizeof(PerformanceEntryVersion2) == 0x18,
-              "PerformanceEntryVersion2 has the wrong size!");
+              "PerformanceEntryVersion2 has the worng size!");
 
 } // namespace AudioCore::AudioRenderer

src/audio_core/renderer/performance/performance_frame_header.h

@@ -16,7 +16,7 @@ struct PerformanceFrameHeaderVersion1 {
     /* 0x14 */ u32 frame_index;
 };
 static_assert(sizeof(PerformanceFrameHeaderVersion1) == 0x18,
-              "PerformanceFrameHeaderVersion1 has the wrong size!");
+              "PerformanceFrameHeaderVersion1 has the worng size!");
 
 struct PerformanceFrameHeaderVersion2 {
     /* 0x00 */ u32 magic; // "PERF"
@@ -31,6 +31,6 @@ struct PerformanceFrameHeaderVersion2 {
     /* 0x25 */ char unk25[0xB];
 };
 static_assert(sizeof(PerformanceFrameHeaderVersion2) == 0x30,
-              "PerformanceFrameHeaderVersion2 has the wrong size!");
+              "PerformanceFrameHeaderVersion2 has the worng size!");
 
 } // namespace AudioCore::AudioRenderer

src/audio_core/renderer/splitter/splitter_context.h

@@ -55,7 +55,7 @@ public:
     /**
      * Get the total number of splitter destinations.
      *
-     * @return Number of destinations.
+     * @return Number of destiantions.
      */
     u32 GetDataCount() const;
 

src/audio_core/renderer/splitter/splitter_destinations_data.h

@@ -87,7 +87,7 @@ public:
     /**
      * Update this destination.
      *
-     * @param params - Input parameters to update the destination.
+     * @param params - Inpout parameters to update the destination.
      */
     void Update(const InParameter& params);
 
@@ -126,9 +126,9 @@ private:
     std::array<f32, MaxMixBuffers> prev_mix_volumes{0.0f};
     /// Next destination in the mix chain
     SplitterDestinationData* next{};
-    /// Is this destination in use?
+    /// Is this destiantion in use?
     bool in_use{};
-    /// Does this destination need its volumes updated?
+    /// Does this destiantion need its volumes updated?
     bool need_update{};
 };
 

src/audio_core/renderer/splitter/splitter_info.h

@@ -49,14 +49,14 @@ public:
     /**
      * Get the number of destinations in this splitter.
      *
-     * @return The number of destinations.
+     * @return The number of destiantions.
      */
     u32 GetDestinationCount() const;
 
     /**
      * Set the number of destinations in this splitter.
      *
-     * @param count - The new number of destinations.
+     * @param count - The new number of destiantions.
      */
     void SetDestinationCount(u32 count);
 

src/audio_core/renderer/system.cpp

@@ -101,15 +101,15 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
                           Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
                           u32 process_handle_, u64 applet_resource_user_id_, s32 session_id_) {
     if (!CheckValidRevision(params.revision)) {
-        return Service::Audio::ResultInvalidRevision;
+        return Service::Audio::ERR_INVALID_REVISION;
     }
 
     if (GetWorkBufferSize(params) > transfer_memory_size) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     if (process_handle_ == 0) {
-        return Service::Audio::ResultInvalidHandle;
+        return Service::Audio::ERR_INVALID_PROCESS_HANDLE;
     }
 
     behavior.SetUserLibRevision(params.revision);
@@ -127,7 +127,8 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     render_device = params.rendering_device;
     execution_mode = params.execution_mode;
 
-    core.ApplicationMemory().ZeroBlock(transfer_memory->GetSourceAddress(), transfer_memory_size);
+    core.Memory().ZeroBlock(*core.Kernel().CurrentProcess(), transfer_memory->GetSourceAddress(),
+                            transfer_memory_size);
 
     // Note: We're not actually using the transfer memory because it's a pain to code for.
     // Allocate the memory normally instead and hope the game doesn't try to read anything back
@@ -142,19 +143,19 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     samples_workbuffer =
         allocator.Allocate<s32>((voice_channels + mix_buffer_count) * sample_count, 0x10);
     if (samples_workbuffer.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     auto upsampler_workbuffer{allocator.Allocate<s32>(
         (voice_channels + mix_buffer_count) * TargetSampleCount * upsampler_count, 0x10)};
     if (upsampler_workbuffer.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     depop_buffer =
         allocator.Allocate<s32>(Common::AlignUp(static_cast<u32>(mix_buffer_count), 0x40), 0x40);
     if (depop_buffer.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     // invalidate samples_workbuffer DSP cache
@@ -165,12 +166,12 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     }
 
     if (voice_infos.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     auto sorted_voice_infos{allocator.Allocate<VoiceInfo*>(params.voices, 0x10)};
     if (sorted_voice_infos.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     std::memset(sorted_voice_infos.data(), 0, sorted_voice_infos.size_bytes());
@@ -182,12 +183,12 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     }
 
     if (voice_channel_resources.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     auto voice_cpu_states{allocator.Allocate<VoiceState>(params.voices, 0x10)};
     if (voice_cpu_states.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     for (auto& voice_state : voice_cpu_states) {
@@ -197,7 +198,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     auto mix_infos{allocator.Allocate<MixInfo>(params.sub_mixes + 1, 0x10)};
 
     if (mix_infos.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     u32 effect_process_order_count{0};
@@ -207,7 +208,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
         effect_process_order_count = params.effects * (params.sub_mixes + 1);
         effect_process_order_buffer = allocator.Allocate<s32>(effect_process_order_count, 0x10);
         if (effect_process_order_buffer.empty()) {
-            return Service::Audio::ResultInsufficientBuffer;
+            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
         }
     }
 
@@ -221,7 +222,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
 
     auto sorted_mix_infos{allocator.Allocate<MixInfo*>(params.sub_mixes + 1, 0x10)};
     if (sorted_mix_infos.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     std::memset(sorted_mix_infos.data(), 0, sorted_mix_infos.size_bytes());
@@ -234,7 +235,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
         auto edge_matrix_workbuffer{allocator.Allocate<u8>(edge_matrix_size, 1)};
 
         if (node_states_workbuffer.empty() || edge_matrix_workbuffer.size() == 0) {
-            return Service::Audio::ResultInsufficientBuffer;
+            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
         }
 
         mix_context.Initialize(sorted_mix_infos, mix_infos, params.sub_mixes + 1,
@@ -249,7 +250,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
 
     upsampler_manager = allocator.Allocate<UpsamplerManager>(1, 0x10).data();
     if (upsampler_manager == nullptr) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     memory_pool_workbuffer = allocator.Allocate<MemoryPoolInfo>(memory_pool_count, 0x10);
@@ -258,18 +259,18 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     }
 
     if (memory_pool_workbuffer.empty() && memory_pool_count > 0) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     if (!splitter_context.Initialize(behavior, params, allocator)) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     std::span<EffectResultState> effect_result_states_cpu{};
     if (behavior.IsEffectInfoVersion2Supported() && params.effects > 0) {
         effect_result_states_cpu = allocator.Allocate<EffectResultState>(params.effects, 0x10);
         if (effect_result_states_cpu.empty()) {
-            return Service::Audio::ResultInsufficientBuffer;
+            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
         }
         std::memset(effect_result_states_cpu.data(), 0, effect_result_states_cpu.size_bytes());
     }
@@ -288,7 +289,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
                                         upsampler_workbuffer);
 
     if (upsampler_infos.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     auto effect_infos{allocator.Allocate<EffectInfoBase>(params.effects, 0x40)};
@@ -297,14 +298,14 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     }
 
     if (effect_infos.empty() && params.effects > 0) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     std::span<EffectResultState> effect_result_states_dsp{};
     if (behavior.IsEffectInfoVersion2Supported() && params.effects > 0) {
         effect_result_states_dsp = allocator.Allocate<EffectResultState>(params.effects, 0x40);
         if (effect_result_states_dsp.empty()) {
-            return Service::Audio::ResultInsufficientBuffer;
+            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
         }
         std::memset(effect_result_states_dsp.data(), 0, effect_result_states_dsp.size_bytes());
     }
@@ -318,14 +319,14 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     }
 
     if (sinks.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     sink_context.Initialize(sinks, params.sinks);
 
     auto voice_dsp_states{allocator.Allocate<VoiceState>(params.voices, 0x40)};
     if (voice_dsp_states.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     for (auto& voice_state : voice_dsp_states) {
@@ -343,7 +344,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
             0xC};
         performance_workbuffer = allocator.Allocate<u8>(perf_workbuffer_size, 0x40);
         if (performance_workbuffer.empty()) {
-            return Service::Audio::ResultInsufficientBuffer;
+            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
         }
         std::memset(performance_workbuffer.data(), 0, performance_workbuffer.size_bytes());
         performance_manager.Initialize(performance_workbuffer, performance_workbuffer.size_bytes(),
@@ -359,7 +360,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     command_workbuffer_size = allocator.GetRemainingSize();
     command_workbuffer = allocator.Allocate<u8>(command_workbuffer_size, 0x40);
     if (command_workbuffer.empty()) {
-        return Service::Audio::ResultInsufficientBuffer;
+        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
     }
 
     command_buffer_size = 0;

src/audio_core/renderer/system.h

@@ -154,7 +154,7 @@ public:
     ExecutionMode GetExecutionMode() const;
 
     /**
-     * Get the rendering device for this system.
+     * Get the rendering deivce for this system.
      * This is unused.
      *
      * @return Rendering device for this system.
@@ -241,7 +241,7 @@ private:
     std::span<u8> command_workbuffer{};
     /// Size of command workbuffer
     u64 command_workbuffer_size{};
-    /// Number of commands in the workbuffer
+    /// Numebr of commands in the workbuffer
     u64 command_buffer_size{};
     /// Manager for upsamplers
     UpsamplerManager* upsampler_manager{};

src/audio_core/renderer/system_manager.cpp

@@ -15,9 +15,14 @@ MICROPROFILE_DEFINE(Audio_RenderSystemManager, "Audio", "Render System Manager",
                     MP_RGB(60, 19, 97));
 
 namespace AudioCore::AudioRenderer {
+constexpr std::chrono::nanoseconds RENDER_TIME{5'000'000UL};
 
 SystemManager::SystemManager(Core::System& core_)
-    : core{core_}, adsp{core.AudioCore().GetADSP()}, mailbox{adsp.GetRenderMailbox()} {}
+    : core{core_}, adsp{core.AudioCore().GetADSP()}, mailbox{adsp.GetRenderMailbox()},
+      thread_event{Core::Timing::CreateEvent(
+          "AudioRendererSystemManager", [this](std::uintptr_t, s64 time, std::chrono::nanoseconds) {
+              return ThreadFunc2(time);
+          })} {}
 
 SystemManager::~SystemManager() {
     Stop();
@@ -28,6 +33,8 @@ bool SystemManager::InitializeUnsafe() {
         if (adsp.Start()) {
             active = true;
             thread = std::jthread([this](std::stop_token stop_token) { ThreadFunc(); });
+            core.CoreTiming().ScheduleLoopingEvent(std::chrono::nanoseconds(0), RENDER_TIME,
+                                                   thread_event);
         }
     }
 
@@ -38,6 +45,7 @@ void SystemManager::Stop() {
     if (!active) {
         return;
     }
+    core.CoreTiming().UnscheduleEvent(thread_event, {});
     active = false;
     update.store(true);
     update.notify_all();
@@ -86,7 +94,7 @@ bool SystemManager::Remove(System& system_) {
 }
 
 void SystemManager::ThreadFunc() {
-    static constexpr char name[]{"AudioRenderSystemManager"};
+    constexpr char name[]{"AudioRenderSystemManager"};
     MicroProfileOnThreadCreate(name);
     Common::SetCurrentThreadName(name);
     Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
@@ -103,7 +111,16 @@ void SystemManager::ThreadFunc() {
 
         adsp.Signal();
         adsp.Wait();
+
+        update.wait(false);
+        update.store(false);
     }
 }
 
+std::optional<std::chrono::nanoseconds> SystemManager::ThreadFunc2(s64 time) {
+    update.store(true);
+    update.notify_all();
+    return std::nullopt;
+}
+
 } // namespace AudioCore::AudioRenderer

src/audio_core/renderer/system_manager.h

@@ -36,7 +36,7 @@ public:
     /**
      * Initialize the system manager, called when any system is registered.
      *
-     * @return True if successfully initialized, otherwise false.
+     * @return True if sucessfully initialized, otherwise false.
      */
     bool InitializeUnsafe();
 
@@ -50,7 +50,7 @@ public:
      * The manager does not own the system, so do not free it without calling Remove.
      *
      * @param system - The system to add.
-     * @return True if successfully added, otherwise false.
+     * @return True if succesfully added, otherwise false.
      */
     bool Add(System& system);
 
@@ -58,7 +58,7 @@ public:
      * Remove an audio render system from the manager.
      *
      * @param system - The system to remove.
-     * @return True if successfully removed, otherwise false.
+     * @return True if succesfully removed, otherwise false.
      */
     bool Remove(System& system);
 
@@ -68,6 +68,11 @@ private:
      */
     void ThreadFunc();
 
+    /**
+     * Signalling core timing thread to run ThreadFunc.
+     */
+    std::optional<std::chrono::nanoseconds> ThreadFunc2(s64 time);
+
     enum class StreamState {
         Filling,
         Steady,
@@ -90,6 +95,8 @@ private:
     ADSP::ADSP& adsp;
     /// AudioRenderer mailbox for communication
     ADSP::AudioRenderer_Mailbox* mailbox{};
+    /// Core timing event to signal main thread
+    std::shared_ptr<Core::Timing::EventType> thread_event;
     /// Atomic for main thread to wait on
     std::atomic<bool> update{};
 };

src/audio_core/renderer/voice/voice_info.cpp

@@ -181,7 +181,7 @@ void VoiceInfo::UpdateWaveBuffer(std::span<BehaviorInfo::ErrorInfo> error_info,
         if (wave_buffer_internal.start_offset * byte_size > wave_buffer_internal.size ||
             wave_buffer_internal.end_offset * byte_size > wave_buffer_internal.size) {
             LOG_ERROR(Service_Audio, "Invalid PCM16 start/end wavebuffer sizes!");
-            error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
+            error_info[0].error_code = Service::Audio::ERR_INVALID_UPDATE_DATA;
             error_info[0].address = wave_buffer_internal.address;
             return;
         }
@@ -192,7 +192,7 @@ void VoiceInfo::UpdateWaveBuffer(std::span<BehaviorInfo::ErrorInfo> error_info,
         if (wave_buffer_internal.start_offset * byte_size > wave_buffer_internal.size ||
             wave_buffer_internal.end_offset * byte_size > wave_buffer_internal.size) {
             LOG_ERROR(Service_Audio, "Invalid PCMFloat start/end wavebuffer sizes!");
-            error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
+            error_info[0].error_code = Service::Audio::ERR_INVALID_UPDATE_DATA;
             error_info[0].address = wave_buffer_internal.address;
             return;
         }
@@ -216,7 +216,7 @@ void VoiceInfo::UpdateWaveBuffer(std::span<BehaviorInfo::ErrorInfo> error_info,
         if (start > static_cast<s64>(wave_buffer_internal.size) ||
             end > static_cast<s64>(wave_buffer_internal.size)) {
             LOG_ERROR(Service_Audio, "Invalid ADPCM start/end wavebuffer sizes!");
-            error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
+            error_info[0].error_code = Service::Audio::ERR_INVALID_UPDATE_DATA;
             error_info[0].address = wave_buffer_internal.address;
             return;
         }
@@ -228,7 +228,7 @@ void VoiceInfo::UpdateWaveBuffer(std::span<BehaviorInfo::ErrorInfo> error_info,
 
     if (wave_buffer_internal.start_offset < 0 || wave_buffer_internal.end_offset < 0) {
         LOG_ERROR(Service_Audio, "Invalid input start/end wavebuffer sizes!");
-        error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
+        error_info[0].error_code = Service::Audio::ERR_INVALID_UPDATE_DATA;
         error_info[0].address = wave_buffer_internal.address;
         return;
     }

src/audio_core/renderer/voice/voice_info.h

@@ -183,7 +183,7 @@ public:
     void Initialize();
 
     /**
-     * Does this voice need an update?
+     * Does this voice ned an update?
      *
      * @param params - Input parameters to check matching.
      *
@@ -236,7 +236,7 @@ public:
      *
      * @param error_info           - Output array of errors.
      * @param wave_buffer          - The wavebuffer to be updated.
-     * @param wave_buffer_internal - Input parameters to be used for the update.
+     * @param wave_buffer_internal - Input parametters to be used for the update.
      * @param sample_format        - Sample format of the wavebuffer.
      * @param valid                - Is this wavebuffer valid?
      * @param pool_mapper          - Used to map the wavebuffers.

src/audio_core/renderer/voice/voice_state.h

@@ -19,10 +19,10 @@ struct VoiceState {
      * State of the voice's biquad filter.
      */
     struct BiquadFilterState {
-        s64 s0;
-        s64 s1;
-        s64 s2;
-        s64 s3;
+        Common::FixedPoint<50, 14> s0;
+        Common::FixedPoint<50, 14> s1;
+        Common::FixedPoint<50, 14> s2;
+        Common::FixedPoint<50, 14> s3;
     };
 
     /**

src/audio_core/sink/cubeb_sink.cpp

@@ -101,6 +101,8 @@ public:
     ~CubebSinkStream() override {
         LOG_DEBUG(Service_Audio, "Destructing cubeb stream {}", name);
 
+        Unstall();
+
         if (!ctx) {
             return;
         }
@@ -141,6 +143,8 @@ public:
      * Stop the sink stream.
      */
     void Stop() override {
+        Unstall();
+
         if (!ctx || paused) {
             return;
         }
@@ -298,21 +302,11 @@ std::vector<std::string> ListCubebSinkDevices(bool capture) {
     std::vector<std::string> device_list;
     cubeb* ctx;
 
-#ifdef _WIN32
-    auto com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
-
     if (cubeb_init(&ctx, "yuzu Device Enumerator", nullptr) != CUBEB_OK) {
         LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
         return {};
     }
 
-#ifdef _WIN32
-    if (SUCCEEDED(com_init_result)) {
-        CoUninitialize();
-    }
-#endif
-
     auto type{capture ? CUBEB_DEVICE_TYPE_INPUT : CUBEB_DEVICE_TYPE_OUTPUT};
     cubeb_device_collection collection;
     if (cubeb_enumerate_devices(ctx, type, &collection) != CUBEB_OK) {
@@ -335,22 +329,12 @@ std::vector<std::string> ListCubebSinkDevices(bool capture) {
 u32 GetCubebLatency() {
     cubeb* ctx;
 
-#ifdef _WIN32
-    auto com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
-
     if (cubeb_init(&ctx, "yuzu Latency Getter", nullptr) != CUBEB_OK) {
         LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
         // Return a large latency so we choose SDL instead.
         return 10000u;
     }
 
-#ifdef _WIN32
-    if (SUCCEEDED(com_init_result)) {
-        CoUninitialize();
-    }
-#endif
-
     cubeb_stream_params params{};
     params.rate = TargetSampleRate;
     params.channels = 2;

src/audio_core/sink/sdl2_sink.cpp

@@ -88,6 +88,7 @@ public:
      * Finalize the sink stream.
      */
     void Finalize() override {
+        Unstall();
         if (device == 0) {
             return;
         }
@@ -115,6 +116,7 @@ public:
      * Stop the sink stream.
      */
     void Stop() override {
+        Unstall();
         if (device == 0 || paused) {
             return;
         }

src/audio_core/sink/sink_stream.cpp

@@ -14,8 +14,6 @@
 #include "common/fixed_point.h"
 #include "common/settings.h"
 #include "core/core.h"
-#include "core/core_timing.h"
-#include "core/core_timing_util.h"
 
 namespace AudioCore::Sink {
 
@@ -37,7 +35,7 @@ void SinkStream::AppendBuffer(SinkBuffer& buffer, std::vector<s16>& samples) {
 
     if (system_channels == 6 && device_channels == 2) {
         // We're given 6 channels, but our device only outputs 2, so downmix.
-        static constexpr std::array<f32, 4> down_mix_coeff{1.0f, 0.707f, 0.251f, 0.707f};
+        constexpr std::array<f32, 4> down_mix_coeff{1.0f, 0.707f, 0.251f, 0.707f};
 
         for (u32 read_index = 0, write_index = 0; read_index < samples.size();
              read_index += system_channels, write_index += device_channels) {
@@ -151,6 +149,10 @@ void SinkStream::ProcessAudioIn(std::span<const s16> input_buffer, std::size_t n
         return;
     }
 
+    if (queued_buffers > max_queue_size) {
+        Stall();
+    }
+
     while (frames_written < num_frames) {
         // If the playing buffer has been consumed or has no frames, we need a new one
         if (playing_buffer.consumed || playing_buffer.frames == 0) {
@@ -185,6 +187,10 @@ void SinkStream::ProcessAudioIn(std::span<const s16> input_buffer, std::size_t n
     }
 
     std::memcpy(&last_frame[0], &input_buffer[(frames_written - 1) * frame_size], frame_size_bytes);
+
+    if (queued_buffers <= max_queue_size) {
+        Unstall();
+    }
 }
 
 void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::size_t num_frames) {
@@ -192,22 +198,31 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
     const std::size_t frame_size = num_channels;
     const std::size_t frame_size_bytes = frame_size * sizeof(s16);
     size_t frames_written{0};
-    size_t actual_frames_written{0};
 
     // If we're paused or going to shut down, we don't want to consume buffers as coretiming is
     // paused and we'll desync, so just play silence.
     if (system.IsPaused() || system.IsShuttingDown()) {
-        if (system.IsShuttingDown()) {
-            release_cv.notify_one();
-        }
-
-        static constexpr std::array<s16, 6> silence{};
+        constexpr std::array<s16, 6> silence{};
         for (size_t i = frames_written; i < num_frames; i++) {
             std::memcpy(&output_buffer[i * frame_size], &silence[0], frame_size_bytes);
         }
         return;
     }
 
+    // Due to many frames being queued up with nvdec (5 frames or so?), a lot of buffers also get
+    // queued up (30+) but not all at once, which causes constant stalling here, so just let the
+    // video play out without attempting to stall.
+    // Can hopefully remove this later with a more complete NVDEC implementation.
+    const auto nvdec_active{system.AudioCore().IsNVDECActive()};
+
+    // Core timing cannot be paused in single-core mode, so Stall ends up being called over and over
+    // and never recovers to a normal state, so just skip attempting to sync things on single-core.
+    if (system.IsMulticore() && !nvdec_active && queued_buffers > max_queue_size) {
+        Stall();
+    } else if (system.IsMulticore() && queued_buffers <= max_queue_size) {
+        Unstall();
+    }
+
     while (frames_written < num_frames) {
         // If the playing buffer has been consumed or has no frames, we need a new one
         if (playing_buffer.consumed || playing_buffer.frames == 0) {
@@ -222,10 +237,6 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
             }
             // Successfully dequeued a new buffer.
             queued_buffers--;
-
-            { std::unique_lock lk{release_mutex}; }
-
-            release_cv.notify_one();
         }
 
         // Get the minimum frames available between the currently playing buffer, and the
@@ -237,7 +248,6 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
                            frames_available * frame_size);
 
         frames_written += frames_available;
-        actual_frames_written += frames_available;
         playing_buffer.frames_played += frames_available;
 
         // If that's all the frames in the current buffer, add its samples and mark it as
@@ -250,29 +260,26 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
     std::memcpy(&last_frame[0], &output_buffer[(frames_written - 1) * frame_size],
                 frame_size_bytes);
 
-    {
-        std::scoped_lock lk{sample_count_lock};
-        last_sample_count_update_time =
-            Core::Timing::CyclesToUs(system.CoreTiming().GetClockTicks());
-        min_played_sample_count = max_played_sample_count;
-        max_played_sample_count += actual_frames_written;
+    if (system.IsMulticore() && queued_buffers <= max_queue_size) {
+        Unstall();
     }
 }
 
-u64 SinkStream::GetExpectedPlayedSampleCount() {
-    std::scoped_lock lk{sample_count_lock};
-    auto cur_time{Core::Timing::CyclesToUs(system.CoreTiming().GetClockTicks())};
-    auto time_delta{cur_time - last_sample_count_update_time};
-    auto exp_played_sample_count{min_played_sample_count +
-                                 (TargetSampleRate * time_delta) / std::chrono::seconds{1}};
-
-    return std::min<u64>(exp_played_sample_count, max_played_sample_count);
+void SinkStream::Stall() {
+    std::scoped_lock lk{stall_guard};
+    if (stalled_lock) {
+        return;
+    }
+    stalled_lock = system.StallProcesses();
 }
 
-void SinkStream::WaitFreeSpace() {
-    std::unique_lock lk{release_mutex};
-    release_cv.wait(
-        lk, [this]() { return queued_buffers < max_queue_size || system.IsShuttingDown(); });
+void SinkStream::Unstall() {
+    std::scoped_lock lk{stall_guard};
+    if (!stalled_lock) {
+        return;
+    }
+    system.UnstallProcesses();
+    stalled_lock.unlock();
 }
 
 } // namespace AudioCore::Sink

src/audio_core/sink/sink_stream.h

@@ -5,7 +5,6 @@
 
 #include <array>
 #include <atomic>
-#include <chrono>
 #include <memory>
 #include <mutex>
 #include <span>
@@ -15,7 +14,6 @@
 #include "common/common_types.h"
 #include "common/reader_writer_queue.h"
 #include "common/ring_buffer.h"
-#include "common/thread.h"
 
 namespace Core {
 class System;
@@ -55,7 +53,9 @@ struct SinkBuffer {
 class SinkStream {
 public:
     explicit SinkStream(Core::System& system_, StreamType type_) : system{system_}, type{type_} {}
-    virtual ~SinkStream() {}
+    virtual ~SinkStream() {
+        Unstall();
+    }
 
     /**
      * Finalize the sink stream.
@@ -201,16 +201,14 @@ public:
     void ProcessAudioOutAndRender(std::span<s16> output_buffer, std::size_t num_frames);
 
     /**
-     * Get the total number of samples expected to have been played by this stream.
-     *
-     * @return The number of samples.
+     * Stall core processes if the audio thread falls too far behind.
      */
-    u64 GetExpectedPlayedSampleCount();
+    void Stall();
 
     /**
-     * Waits for free space in the sample ring buffer
+     * Unstall core processes.
      */
-    void WaitFreeSpace();
+    void Unstall();
 
 protected:
     /// Core system
@@ -239,21 +237,12 @@ private:
     std::atomic<u32> queued_buffers{};
     /// The ring size for audio out buffers (usually 4, rarely 2 or 8)
     u32 max_queue_size{};
-    /// Locks access to sample count tracking info
-    std::mutex sample_count_lock;
-    /// Minimum number of total samples that have been played since the last callback
-    u64 min_played_sample_count{};
-    /// Maximum number of total samples that can be played since the last callback
-    u64 max_played_sample_count{};
-    /// The time the two above tracking variables were last written to
-    std::chrono::microseconds last_sample_count_update_time{};
     /// Set by the audio render/in/out system which uses this stream
     f32 system_volume{1.0f};
     /// Set via IAudioDevice service calls
     f32 device_volume{1.0f};
-    /// Signalled when ring buffer entries are consumed
-    std::condition_variable release_cv;
-    std::mutex release_mutex;
+    std::mutex stall_guard;
+    std::unique_lock<std::mutex> stalled_lock;
 };
 
 using SinkStreamPtr = std::unique_ptr<SinkStream>;

src/common/CMakeLists.txt

@@ -38,7 +38,6 @@ add_library(common STATIC
     common_precompiled_headers.h
     common_types.h
     concepts.h
-    container_hash.h
     demangle.cpp
     demangle.h
     div_ceil.h
@@ -92,7 +91,6 @@ add_library(common STATIC
     multi_level_page_table.h
     nvidia_flags.cpp
     nvidia_flags.h
-    overflow.h
     page_table.cpp
     page_table.h
     param_package.cpp
@@ -115,8 +113,6 @@ add_library(common STATIC
     socket_types.h
     spin_lock.cpp
     spin_lock.h
-    steady_clock.cpp
-    steady_clock.h
     stream.cpp
     stream.h
     string_util.cpp
@@ -133,7 +129,6 @@ add_library(common STATIC
     time_zone.h
     tiny_mt.h
     tree.h
-    typed_address.h
     uint128.h
     unique_function.h
     uuid.cpp
@@ -147,21 +142,11 @@ add_library(common STATIC
     zstd_compression.h
 )
 
-if (WIN32)
-  target_sources(common PRIVATE
-    windows/timer_resolution.cpp
-    windows/timer_resolution.h
-  )
-  target_link_libraries(common PRIVATE ntdll)
-endif()
-
 if(ARCHITECTURE_x86_64)
     target_sources(common
         PRIVATE
             x64/cpu_detect.cpp
             x64/cpu_detect.h
-            x64/cpu_wait.cpp
-            x64/cpu_wait.h
             x64/native_clock.cpp
             x64/native_clock.h
             x64/xbyak_abi.h
@@ -191,7 +176,7 @@ endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC Boost::context Boost::headers fmt::fmt microprofile Threads::Threads)
+target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
 target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd LLVM::Demangle)
 
 if (YUZU_USE_PRECOMPILED_HEADERS)

src/common/announce_multiplayer_room.h

@@ -66,7 +66,7 @@ public:
      * @param description The room description
      * @param port The port of the room
      * @param net_version The version of the libNetwork that gets used
-     * @param has_password True if the room is password protected
+     * @param has_password True if the room is passowrd protected
      * @param preferred_game The preferred game of the room
      * @param preferred_game_id The title id of the preferred game
      */

src/common/bit_cast.h

@@ -3,21 +3,19 @@
 
 #pragma once
 
-#include <version>
-
-#ifdef __cpp_lib_bit_cast
-#include <bit>
-#endif
+#include <cstring>
+#include <type_traits>
 
 namespace Common {
 
 template <typename To, typename From>
-constexpr inline To BitCast(const From& from) {
-#ifdef __cpp_lib_bit_cast
-    return std::bit_cast<To>(from);
-#else
-    return __builtin_bit_cast(To, from);
-#endif
+[[nodiscard]] std::enable_if_t<sizeof(To) == sizeof(From) && std::is_trivially_copyable_v<From> &&
+                                   std::is_trivially_copyable_v<To>,
+                               To>
+BitCast(const From& src) noexcept {
+    To dst;
+    std::memcpy(&dst, &src, sizeof(To));
+    return dst;
 }
 
 } // namespace Common

src/common/bounded_threadsafe_queue.h

@@ -1,249 +1,158 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-FileCopyrightText: Copyright (c) 2020 Erik Rigtorp <erik@rigtorp.se>
+// SPDX-License-Identifier: MIT
 
 #pragma once
 
 #include <atomic>
+#include <bit>
 #include <condition_variable>
-#include <cstddef>
+#include <memory>
 #include <mutex>
 #include <new>
-
-#include "common/polyfill_thread.h"
+#include <stop_token>
+#include <type_traits>
+#include <utility>
 
 namespace Common {
 
-namespace detail {
-constexpr size_t DefaultCapacity = 0x1000;
-} // namespace detail
+#if defined(__cpp_lib_hardware_interference_size)
+constexpr size_t hardware_interference_size = std::hardware_destructive_interference_size;
+#else
+constexpr size_t hardware_interference_size = 64;
+#endif
 
-template <typename T, size_t Capacity = detail::DefaultCapacity>
-class SPSCQueue {
-    static_assert((Capacity & (Capacity - 1)) == 0, "Capacity must be a power of two.");
-
-public:
-    template <typename... Args>
-    bool TryEmplace(Args&&... args) {
-        return Emplace<PushMode::Try>(std::forward<Args>(args)...);
-    }
-
-    template <typename... Args>
-    void EmplaceWait(Args&&... args) {
-        Emplace<PushMode::Wait>(std::forward<Args>(args)...);
-    }
-
-    bool TryPop(T& t) {
-        return Pop<PopMode::Try>(t);
-    }
-
-    void PopWait(T& t) {
-        Pop<PopMode::Wait>(t);
-    }
-
-    void PopWait(T& t, std::stop_token stop_token) {
-        Pop<PopMode::WaitWithStopToken>(t, stop_token);
-    }
-
-    T PopWait() {
-        T t;
-        Pop<PopMode::Wait>(t);
-        return t;
-    }
-
-    T PopWait(std::stop_token stop_token) {
-        T t;
-        Pop<PopMode::WaitWithStopToken>(t, stop_token);
-        return t;
-    }
-
-private:
-    enum class PushMode {
-        Try,
-        Wait,
-        Count,
-    };
-
-    enum class PopMode {
-        Try,
-        Wait,
-        WaitWithStopToken,
-        Count,
-    };
-
-    template <PushMode Mode, typename... Args>
-    bool Emplace(Args&&... args) {
-        const size_t write_index = m_write_index.load(std::memory_order::relaxed);
-
-        if constexpr (Mode == PushMode::Try) {
-            // Check if we have free slots to write to.
-            if ((write_index - m_read_index.load(std::memory_order::acquire)) == Capacity) {
-                return false;
-            }
-        } else if constexpr (Mode == PushMode::Wait) {
-            // Wait until we have free slots to write to.
-            std::unique_lock lock{producer_cv_mutex};
-            producer_cv.wait(lock, [this, write_index] {
-                return (write_index - m_read_index.load(std::memory_order::acquire)) < Capacity;
-            });
-        } else {
-            static_assert(Mode < PushMode::Count, "Invalid PushMode.");
-        }
-
-        // Determine the position to write to.
-        const size_t pos = write_index % Capacity;
-
-        // Emplace into the queue.
-        std::construct_at(std::addressof(m_data[pos]), std::forward<Args>(args)...);
-
-        // Increment the write index.
-        ++m_write_index;
-
-        // Notify the consumer that we have pushed into the queue.
-        std::scoped_lock lock{consumer_cv_mutex};
-        consumer_cv.notify_one();
-
-        return true;
-    }
-
-    template <PopMode Mode>
-    bool Pop(T& t, [[maybe_unused]] std::stop_token stop_token = {}) {
-        const size_t read_index = m_read_index.load(std::memory_order::relaxed);
-
-        if constexpr (Mode == PopMode::Try) {
-            // Check if the queue is empty.
-            if (read_index == m_write_index.load(std::memory_order::acquire)) {
-                return false;
-            }
-        } else if constexpr (Mode == PopMode::Wait) {
-            // Wait until the queue is not empty.
-            std::unique_lock lock{consumer_cv_mutex};
-            consumer_cv.wait(lock, [this, read_index] {
-                return read_index != m_write_index.load(std::memory_order::acquire);
-            });
-        } else if constexpr (Mode == PopMode::WaitWithStopToken) {
-            // Wait until the queue is not empty.
-            std::unique_lock lock{consumer_cv_mutex};
-            Common::CondvarWait(consumer_cv, lock, stop_token, [this, read_index] {
-                return read_index != m_write_index.load(std::memory_order::acquire);
-            });
-            if (stop_token.stop_requested()) {
-                return false;
-            }
-        } else {
-            static_assert(Mode < PopMode::Count, "Invalid PopMode.");
-        }
-
-        // Determine the position to read from.
-        const size_t pos = read_index % Capacity;
-
-        // Pop the data off the queue, moving it.
-        t = std::move(m_data[pos]);
-
-        // Increment the read index.
-        ++m_read_index;
-
-        // Notify the producer that we have popped off the queue.
-        std::scoped_lock lock{producer_cv_mutex};
-        producer_cv.notify_one();
-
-        return true;
-    }
-
-    alignas(128) std::atomic_size_t m_read_index{0};
-    alignas(128) std::atomic_size_t m_write_index{0};
-
-    std::array<T, Capacity> m_data;
-
-    std::condition_variable_any producer_cv;
-    std::mutex producer_cv_mutex;
-    std::condition_variable_any consumer_cv;
-    std::mutex consumer_cv_mutex;
-};
-
-template <typename T, size_t Capacity = detail::DefaultCapacity>
+template <typename T, size_t capacity = 0x400>
 class MPSCQueue {
 public:
-    template <typename... Args>
-    bool TryEmplace(Args&&... args) {
-        std::scoped_lock lock{write_mutex};
-        return spsc_queue.TryEmplace(std::forward<Args>(args)...);
+    explicit MPSCQueue() : allocator{std::allocator<Slot<T>>()} {
+        // Allocate one extra slot to prevent false sharing on the last slot
+        slots = allocator.allocate(capacity + 1);
+        // Allocators are not required to honor alignment for over-aligned types
+        // (see http://eel.is/c++draft/allocator.requirements#10) so we verify
+        // alignment here
+        if (reinterpret_cast<uintptr_t>(slots) % alignof(Slot<T>) != 0) {
+            allocator.deallocate(slots, capacity + 1);
+            throw std::bad_alloc();
+        }
+        for (size_t i = 0; i < capacity; ++i) {
+            std::construct_at(&slots[i]);
+        }
+        static_assert(std::has_single_bit(capacity), "capacity must be an integer power of 2");
+        static_assert(alignof(Slot<T>) == hardware_interference_size,
+                      "Slot must be aligned to cache line boundary to prevent false sharing");
+        static_assert(sizeof(Slot<T>) % hardware_interference_size == 0,
+                      "Slot size must be a multiple of cache line size to prevent "
+                      "false sharing between adjacent slots");
+        static_assert(sizeof(MPSCQueue) % hardware_interference_size == 0,
+                      "Queue size must be a multiple of cache line size to "
+                      "prevent false sharing between adjacent queues");
     }
 
-    template <typename... Args>
-    void EmplaceWait(Args&&... args) {
-        std::scoped_lock lock{write_mutex};
-        spsc_queue.EmplaceWait(std::forward<Args>(args)...);
+    ~MPSCQueue() noexcept {
+        for (size_t i = 0; i < capacity; ++i) {
+            std::destroy_at(&slots[i]);
+        }
+        allocator.deallocate(slots, capacity + 1);
     }
 
-    bool TryPop(T& t) {
-        return spsc_queue.TryPop(t);
+    // The queue must be both non-copyable and non-movable
+    MPSCQueue(const MPSCQueue&) = delete;
+    MPSCQueue& operator=(const MPSCQueue&) = delete;
+
+    MPSCQueue(MPSCQueue&&) = delete;
+    MPSCQueue& operator=(MPSCQueue&&) = delete;
+
+    void Push(const T& v) noexcept {
+        static_assert(std::is_nothrow_copy_constructible_v<T>,
+                      "T must be nothrow copy constructible");
+        emplace(v);
     }
 
-    void PopWait(T& t) {
-        spsc_queue.PopWait(t);
+    template <typename P, typename = std::enable_if_t<std::is_nothrow_constructible_v<T, P&&>>>
+    void Push(P&& v) noexcept {
+        emplace(std::forward<P>(v));
     }
 
-    void PopWait(T& t, std::stop_token stop_token) {
-        spsc_queue.PopWait(t, stop_token);
-    }
-
-    T PopWait() {
-        return spsc_queue.PopWait();
-    }
-
-    T PopWait(std::stop_token stop_token) {
-        return spsc_queue.PopWait(stop_token);
+    void Pop(T& v, std::stop_token stop) noexcept {
+        auto const tail = tail_.fetch_add(1);
+        auto& slot = slots[idx(tail)];
+        if (!slot.turn.test()) {
+            std::unique_lock lock{cv_mutex};
+            cv.wait(lock, stop, [&slot] { return slot.turn.test(); });
+        }
+        v = slot.move();
+        slot.destroy();
+        slot.turn.clear();
+        slot.turn.notify_one();
     }
 
 private:
-    SPSCQueue<T, Capacity> spsc_queue;
-    std::mutex write_mutex;
-};
+    template <typename U = T>
+    struct Slot {
+        ~Slot() noexcept {
+            if (turn.test()) {
+                destroy();
+            }
+        }
 
-template <typename T, size_t Capacity = detail::DefaultCapacity>
-class MPMCQueue {
-public:
-    template <typename... Args>
-    bool TryEmplace(Args&&... args) {
-        std::scoped_lock lock{write_mutex};
-        return spsc_queue.TryEmplace(std::forward<Args>(args)...);
-    }
+        template <typename... Args>
+        void construct(Args&&... args) noexcept {
+            static_assert(std::is_nothrow_constructible_v<U, Args&&...>,
+                          "T must be nothrow constructible with Args&&...");
+            std::construct_at(reinterpret_cast<U*>(&storage), std::forward<Args>(args)...);
+        }
+
+        void destroy() noexcept {
+            static_assert(std::is_nothrow_destructible_v<U>, "T must be nothrow destructible");
+            std::destroy_at(reinterpret_cast<U*>(&storage));
+        }
+
+        U&& move() noexcept {
+            return reinterpret_cast<U&&>(storage);
+        }
+
+        // Align to avoid false sharing between adjacent slots
+        alignas(hardware_interference_size) std::atomic_flag turn{};
+        struct aligned_store {
+            struct type {
+                alignas(U) unsigned char data[sizeof(U)];
+            };
+        };
+        typename aligned_store::type storage;
+    };
 
     template <typename... Args>
-    void EmplaceWait(Args&&... args) {
-        std::scoped_lock lock{write_mutex};
-        spsc_queue.EmplaceWait(std::forward<Args>(args)...);
+    void emplace(Args&&... args) noexcept {
+        static_assert(std::is_nothrow_constructible_v<T, Args&&...>,
+                      "T must be nothrow constructible with Args&&...");
+        auto const head = head_.fetch_add(1);
+        auto& slot = slots[idx(head)];
+        slot.turn.wait(true);
+        slot.construct(std::forward<Args>(args)...);
+        slot.turn.test_and_set();
+        cv.notify_one();
     }
 
-    bool TryPop(T& t) {
-        std::scoped_lock lock{read_mutex};
-        return spsc_queue.TryPop(t);
+    constexpr size_t idx(size_t i) const noexcept {
+        return i & mask;
     }
 
-    void PopWait(T& t) {
-        std::scoped_lock lock{read_mutex};
-        spsc_queue.PopWait(t);
-    }
+    static constexpr size_t mask = capacity - 1;
 
-    void PopWait(T& t, std::stop_token stop_token) {
-        std::scoped_lock lock{read_mutex};
-        spsc_queue.PopWait(t, stop_token);
-    }
+    // Align to avoid false sharing between head_ and tail_
+    alignas(hardware_interference_size) std::atomic<size_t> head_{0};
+    alignas(hardware_interference_size) std::atomic<size_t> tail_{0};
 
-    T PopWait() {
-        std::scoped_lock lock{read_mutex};
-        return spsc_queue.PopWait();
-    }
+    std::mutex cv_mutex;
+    std::condition_variable_any cv;
 
-    T PopWait(std::stop_token stop_token) {
-        std::scoped_lock lock{read_mutex};
-        return spsc_queue.PopWait(stop_token);
-    }
+    Slot<T>* slots;
+    [[no_unique_address]] std::allocator<Slot<T>> allocator;
 
-private:
-    SPSCQueue<T, Capacity> spsc_queue;
-    std::mutex write_mutex;
-    std::mutex read_mutex;
+    static_assert(std::is_nothrow_copy_assignable_v<T> || std::is_nothrow_move_assignable_v<T>,
+                  "T must be nothrow copy or move assignable");
+
+    static_assert(std::is_nothrow_destructible_v<T>, "T must be nothrow destructible");
 };
 
 } // namespace Common

src/common/container_hash.h

@@ -1,92 +0,0 @@
-// SPDX-FileCopyrightText: 2005-2014 Daniel James
-// SPDX-FileCopyrightText: 2016 Austin Appleby
-// SPDX-License-Identifier: BSL-1.0
-
-#include <array>
-#include <climits>
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-#include <vector>
-
-namespace Common {
-
-namespace detail {
-
-template <typename T>
-    requires std::is_unsigned_v<T>
-inline std::size_t HashValue(T val) {
-    const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
-    const unsigned int length =
-        (std::numeric_limits<T>::digits - 1) / static_cast<unsigned int>(size_t_bits);
-
-    std::size_t seed = 0;
-
-    for (unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits) {
-        seed ^= static_cast<size_t>(val >> i) + (seed << 6) + (seed >> 2);
-    }
-
-    seed ^= static_cast<size_t>(val) + (seed << 6) + (seed >> 2);
-
-    return seed;
-}
-
-template <size_t Bits>
-struct HashCombineImpl {
-    template <typename T>
-    static inline T fn(T seed, T value) {
-        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-        return seed;
-    }
-};
-
-template <>
-struct HashCombineImpl<64> {
-    static inline std::uint64_t fn(std::uint64_t h, std::uint64_t k) {
-        const std::uint64_t m = (std::uint64_t(0xc6a4a793) << 32) + 0x5bd1e995;
-        const int r = 47;
-
-        k *= m;
-        k ^= k >> r;
-        k *= m;
-
-        h ^= k;
-        h *= m;
-
-        // Completely arbitrary number, to prevent 0's
-        // from hashing to 0.
-        h += 0xe6546b64;
-
-        return h;
-    }
-};
-
-} // namespace detail
-
-template <typename T>
-inline void HashCombine(std::size_t& seed, const T& v) {
-    seed = detail::HashCombineImpl<sizeof(std::size_t) * CHAR_BIT>::fn(seed, detail::HashValue(v));
-}
-
-template <typename It>
-inline std::size_t HashRange(It first, It last) {
-    std::size_t seed = 0;
-
-    for (; first != last; ++first) {
-        HashCombine<typename std::iterator_traits<It>::value_type>(seed, *first);
-    }
-
-    return seed;
-}
-
-template <typename T, size_t Size>
-std::size_t HashValue(const std::array<T, Size>& v) {
-    return HashRange(v.cbegin(), v.cend());
-}
-
-template <typename T, typename Allocator>
-std::size_t HashValue(const std::vector<T, Allocator>& v) {
-    return HashRange(v.cbegin(), v.cend());
-}
-
-} // namespace Common

src/common/fiber.cpp

@@ -90,7 +90,7 @@ Fiber::~Fiber() {
 }
 
 void Fiber::Exit() {
-    ASSERT_MSG(impl->is_thread_fiber, "Exiting non main thread fiber");
+    ASSERT_MSG(impl->is_thread_fiber, "Exitting non main thread fiber");
     if (!impl->is_thread_fiber) {
         return;
     }

src/common/fixed_point.h

@@ -22,7 +22,7 @@ class FixedPoint;
 namespace detail {
 
 // helper templates to make magic with types :)
-// these allow us to determine reasonable types from
+// these allow us to determine resonable types from
 // a desired size, they also let us infer the next largest type
 // from a type which is nice for the division op
 template <size_t T>

src/common/host_memory.cpp

@@ -322,7 +322,7 @@ private:
     }
 
     /// Return true when a given memory region is a "nieche" and the placeholders don't have to be
-    /// split.
+    /// splitted.
     bool IsNiechePlaceholder(size_t virtual_offset, size_t length) const {
         const auto it = placeholders.upper_bound({virtual_offset, virtual_offset + length});
         if (it != placeholders.end() && it->lower() == virtual_offset + length) {
@@ -484,7 +484,7 @@ class HostMemory::Impl {
 public:
     explicit Impl(size_t /*backing_size */, size_t /* virtual_size */) {
         // This is just a place holder.
-        // Please implement fastmem in a proper way on your platform.
+        // Please implement fastmem in a propper way on your platform.
         throw std::bad_alloc{};
     }
 

src/common/input.h

@@ -15,7 +15,7 @@
 
 namespace Common::Input {
 
-// Type of data that is expected to receive or send
+// Type of data that is expected to recieve or send
 enum class InputType {
     None,
     Battery,
@@ -46,7 +46,7 @@ enum class PollingMode {
     // Constant polling of buttons, analogs and motion data
     Active,
     // Only update on button change, digital analogs
-    Passive,
+    Pasive,
     // Enable near field communication polling
     NFC,
     // Enable infrared camera polling
@@ -103,7 +103,7 @@ enum class VibrationAmplificationType {
 struct AnalogProperties {
     // Anything below this value will be detected as zero
     float deadzone{};
-    // Anything above this values will be detected as one
+    // Anyting above this values will be detected as one
     float range{1.0f};
     // Minimum value to be detected as active
     float threshold{0.5f};
@@ -130,8 +130,6 @@ struct ButtonStatus {
     bool inverted{};
     // Press once to activate, press again to release
     bool toggle{};
-    // Spams the button when active
-    bool turbo{};
     // Internal lock for the toggle status
     bool locked{};
 };
@@ -209,7 +207,7 @@ struct LedStatus {
     bool led_4{};
 };
 
-// Raw data from camera
+// Raw data fom camera
 struct CameraStatus {
     CameraFormat format{CameraFormat::None};
     std::vector<u8> data{};
@@ -428,7 +426,7 @@ inline void UnregisterOutputFactory(const std::string& name) {
 }
 
 /**
- * Create an input device from given parameters.
+ * Create an input device from given paramters.
  * @tparam InputDeviceType the type of input devices to create
  * @param params a serialized ParamPackage string that contains all parameters for creating the
  * device

src/common/logging/backend.cpp

@@ -28,7 +28,7 @@
 #ifdef _WIN32
 #include "common/string_util.h"
 #endif
-#include "common/bounded_threadsafe_queue.h"
+#include "common/threadsafe_queue.h"
 
 namespace Common::Log {
 
@@ -204,11 +204,11 @@ public:
 
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
                    const char* function, std::string&& message) {
-        if (!filter.CheckMessage(log_class, log_level)) {
+        if (!filter.CheckMessage(log_class, log_level))
             return;
-        }
-        message_queue.EmplaceWait(
-            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message)));
+        const Entry& entry =
+            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message));
+        message_queue.Push(entry);
     }
 
 private:
@@ -225,7 +225,7 @@ private:
                 ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
             };
             while (!stop_token.stop_requested()) {
-                message_queue.PopWait(entry, stop_token);
+                entry = message_queue.PopWait(stop_token);
                 if (entry.filename != nullptr) {
                     write_logs();
                 }
@@ -233,7 +233,7 @@ private:
             // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
             // case where a system is repeatedly spamming logs even on close.
             int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-            while (max_logs_to_write-- && message_queue.TryPop(entry)) {
+            while (max_logs_to_write-- && message_queue.Pop(entry)) {
                 write_logs();
             }
         });
@@ -273,7 +273,7 @@ private:
     ColorConsoleBackend color_console_backend{};
     FileBackend file_backend;
 
-    MPSCQueue<Entry> message_queue{};
+    MPSCQueue<Entry, true> message_queue{};
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
     std::jthread backend_thread;
 };

src/common/logging/filter.cpp

@@ -119,7 +119,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Service, NPNS)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
-    SUB(Service, Nvnflinger)                                                                       \
+    SUB(Service, NVFlinger)                                                                        \
     SUB(Service, OLSC)                                                                             \
     SUB(Service, PCIE)                                                                             \
     SUB(Service, PCTL)                                                                             \

src/common/logging/types.h

@@ -29,107 +29,107 @@ enum class Level : u8 {
  * filter.cpp.
  */
 enum class Class : u8 {
-    Log,                ///< Messages about the log system itself
-    Common,             ///< Library routines
-    Common_Filesystem,  ///< Filesystem interface library
-    Common_Memory,      ///< Memory mapping and management functions
-    Core,               ///< LLE emulation core
-    Core_ARM,           ///< ARM CPU core
-    Core_Timing,        ///< CoreTiming functions
-    Config,             ///< Emulator configuration (including commandline)
-    Debug,              ///< Debugging tools
-    Debug_Emulated,     ///< Debug messages from the emulated programs
-    Debug_GPU,          ///< GPU debugging tools
-    Debug_Breakpoint,   ///< Logging breakpoints and watchpoints
-    Debug_GDBStub,      ///< GDB Stub
-    Kernel,             ///< The HLE implementation of the CTR kernel
-    Kernel_SVC,         ///< Kernel system calls
-    Service,            ///< HLE implementation of system services. Each major service
-                        ///< should have its own subclass.
-    Service_ACC,        ///< The ACC (Accounts) service
-    Service_AM,         ///< The AM (Applet manager) service
-    Service_AOC,        ///< The AOC (AddOn Content) service
-    Service_APM,        ///< The APM (Performance) service
-    Service_ARP,        ///< The ARP service
-    Service_Audio,      ///< The Audio (Audio control) service
-    Service_BCAT,       ///< The BCAT service
-    Service_BGTC,       ///< The BGTC (Background Task Controller) service
-    Service_BPC,        ///< The BPC service
-    Service_BTDRV,      ///< The Bluetooth driver service
-    Service_BTM,        ///< The BTM service
-    Service_Capture,    ///< The capture service
-    Service_ERPT,       ///< The error reporting service
-    Service_ETicket,    ///< The ETicket service
-    Service_EUPLD,      ///< The error upload service
-    Service_Fatal,      ///< The Fatal service
-    Service_FGM,        ///< The FGM service
-    Service_Friend,     ///< The friend service
-    Service_FS,         ///< The FS (Filesystem) service
-    Service_GRC,        ///< The game recording service
-    Service_HID,        ///< The HID (Human interface device) service
-    Service_IRS,        ///< The IRS service
-    Service_JIT,        ///< The JIT service
-    Service_LBL,        ///< The LBL (LCD backlight) service
-    Service_LDN,        ///< The LDN (Local domain network) service
-    Service_LDR,        ///< The loader service
-    Service_LM,         ///< The LM (Logger) service
-    Service_Migration,  ///< The migration service
-    Service_Mii,        ///< The Mii service
-    Service_MM,         ///< The MM (Multimedia) service
-    Service_MNPP,       ///< The MNPP service
-    Service_NCM,        ///< The NCM service
-    Service_NFC,        ///< The NFC (Near-field communication) service
-    Service_NFP,        ///< The NFP service
-    Service_NGCT,       ///< The NGCT (No Good Content for Terra) service
-    Service_NIFM,       ///< The NIFM (Network interface) service
-    Service_NIM,        ///< The NIM service
-    Service_NOTIF,      ///< The NOTIF (Notification) service
-    Service_NPNS,       ///< The NPNS service
-    Service_NS,         ///< The NS services
-    Service_NVDRV,      ///< The NVDRV (Nvidia driver) service
-    Service_Nvnflinger, ///< The Nvnflinger service
-    Service_OLSC,       ///< The OLSC service
-    Service_PCIE,       ///< The PCIe service
-    Service_PCTL,       ///< The PCTL (Parental control) service
-    Service_PCV,        ///< The PCV service
-    Service_PM,         ///< The PM service
-    Service_PREPO,      ///< The PREPO (Play report) service
-    Service_PSC,        ///< The PSC service
-    Service_PTM,        ///< The PTM service
-    Service_SET,        ///< The SET (Settings) service
-    Service_SM,         ///< The SM (Service manager) service
-    Service_SPL,        ///< The SPL service
-    Service_SSL,        ///< The SSL service
-    Service_TCAP,       ///< The TCAP service.
-    Service_Time,       ///< The time service
-    Service_USB,        ///< The USB (Universal Serial Bus) service
-    Service_VI,         ///< The VI (Video interface) service
-    Service_WLAN,       ///< The WLAN (Wireless local area network) service
-    HW,                 ///< Low-level hardware emulation
-    HW_Memory,          ///< Memory-map and address translation
-    HW_LCD,             ///< LCD register emulation
-    HW_GPU,             ///< GPU control emulation
-    HW_AES,             ///< AES engine emulation
-    IPC,                ///< IPC interface
-    Frontend,           ///< Emulator UI
-    Render,             ///< Emulator video output and hardware acceleration
-    Render_Software,    ///< Software renderer backend
-    Render_OpenGL,      ///< OpenGL backend
-    Render_Vulkan,      ///< Vulkan backend
-    Shader,             ///< Shader recompiler
-    Shader_SPIRV,       ///< Shader SPIR-V code generation
-    Shader_GLASM,       ///< Shader GLASM code generation
-    Shader_GLSL,        ///< Shader GLSL code generation
-    Audio,              ///< Audio emulation
-    Audio_DSP,          ///< The HLE implementation of the DSP
-    Audio_Sink,         ///< Emulator audio output backend
-    Loader,             ///< ROM loader
-    CheatEngine,        ///< Memory manipulation and engine VM functions
-    Crypto,             ///< Cryptographic engine/functions
-    Input,              ///< Input emulation
-    Network,            ///< Network emulation
-    WebService,         ///< Interface to yuzu Web Services
-    Count               ///< Total number of logging classes
+    Log,               ///< Messages about the log system itself
+    Common,            ///< Library routines
+    Common_Filesystem, ///< Filesystem interface library
+    Common_Memory,     ///< Memory mapping and management functions
+    Core,              ///< LLE emulation core
+    Core_ARM,          ///< ARM CPU core
+    Core_Timing,       ///< CoreTiming functions
+    Config,            ///< Emulator configuration (including commandline)
+    Debug,             ///< Debugging tools
+    Debug_Emulated,    ///< Debug messages from the emulated programs
+    Debug_GPU,         ///< GPU debugging tools
+    Debug_Breakpoint,  ///< Logging breakpoints and watchpoints
+    Debug_GDBStub,     ///< GDB Stub
+    Kernel,            ///< The HLE implementation of the CTR kernel
+    Kernel_SVC,        ///< Kernel system calls
+    Service,           ///< HLE implementation of system services. Each major service
+                       ///< should have its own subclass.
+    Service_ACC,       ///< The ACC (Accounts) service
+    Service_AM,        ///< The AM (Applet manager) service
+    Service_AOC,       ///< The AOC (AddOn Content) service
+    Service_APM,       ///< The APM (Performance) service
+    Service_ARP,       ///< The ARP service
+    Service_Audio,     ///< The Audio (Audio control) service
+    Service_BCAT,      ///< The BCAT service
+    Service_BGTC,      ///< The BGTC (Background Task Controller) service
+    Service_BPC,       ///< The BPC service
+    Service_BTDRV,     ///< The Bluetooth driver service
+    Service_BTM,       ///< The BTM service
+    Service_Capture,   ///< The capture service
+    Service_ERPT,      ///< The error reporting service
+    Service_ETicket,   ///< The ETicket service
+    Service_EUPLD,     ///< The error upload service
+    Service_Fatal,     ///< The Fatal service
+    Service_FGM,       ///< The FGM service
+    Service_Friend,    ///< The friend service
+    Service_FS,        ///< The FS (Filesystem) service
+    Service_GRC,       ///< The game recording service
+    Service_HID,       ///< The HID (Human interface device) service
+    Service_IRS,       ///< The IRS service
+    Service_JIT,       ///< The JIT service
+    Service_LBL,       ///< The LBL (LCD backlight) service
+    Service_LDN,       ///< The LDN (Local domain network) service
+    Service_LDR,       ///< The loader service
+    Service_LM,        ///< The LM (Logger) service
+    Service_Migration, ///< The migration service
+    Service_Mii,       ///< The Mii service
+    Service_MM,        ///< The MM (Multimedia) service
+    Service_MNPP,      ///< The MNPP service
+    Service_NCM,       ///< The NCM service
+    Service_NFC,       ///< The NFC (Near-field communication) service
+    Service_NFP,       ///< The NFP service
+    Service_NGCT,      ///< The NGCT (No Good Content for Terra) service
+    Service_NIFM,      ///< The NIFM (Network interface) service
+    Service_NIM,       ///< The NIM service
+    Service_NOTIF,     ///< The NOTIF (Notification) service
+    Service_NPNS,      ///< The NPNS service
+    Service_NS,        ///< The NS services
+    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
+    Service_NVFlinger, ///< The NVFlinger service
+    Service_OLSC,      ///< The OLSC service
+    Service_PCIE,      ///< The PCIe service
+    Service_PCTL,      ///< The PCTL (Parental control) service
+    Service_PCV,       ///< The PCV service
+    Service_PM,        ///< The PM service
+    Service_PREPO,     ///< The PREPO (Play report) service
+    Service_PSC,       ///< The PSC service
+    Service_PTM,       ///< The PTM service
+    Service_SET,       ///< The SET (Settings) service
+    Service_SM,        ///< The SM (Service manager) service
+    Service_SPL,       ///< The SPL service
+    Service_SSL,       ///< The SSL service
+    Service_TCAP,      ///< The TCAP service.
+    Service_Time,      ///< The time service
+    Service_USB,       ///< The USB (Universal Serial Bus) service
+    Service_VI,        ///< The VI (Video interface) service
+    Service_WLAN,      ///< The WLAN (Wireless local area network) service
+    HW,                ///< Low-level hardware emulation
+    HW_Memory,         ///< Memory-map and address translation
+    HW_LCD,            ///< LCD register emulation
+    HW_GPU,            ///< GPU control emulation
+    HW_AES,            ///< AES engine emulation
+    IPC,               ///< IPC interface
+    Frontend,          ///< Emulator UI
+    Render,            ///< Emulator video output and hardware acceleration
+    Render_Software,   ///< Software renderer backend
+    Render_OpenGL,     ///< OpenGL backend
+    Render_Vulkan,     ///< Vulkan backend
+    Shader,            ///< Shader recompiler
+    Shader_SPIRV,      ///< Shader SPIR-V code generation
+    Shader_GLASM,      ///< Shader GLASM code generation
+    Shader_GLSL,       ///< Shader GLSL code generation
+    Audio,             ///< Audio emulation
+    Audio_DSP,         ///< The HLE implementation of the DSP
+    Audio_Sink,        ///< Emulator audio output backend
+    Loader,            ///< ROM loader
+    CheatEngine,       ///< Memory manipulation and engine VM functions
+    Crypto,            ///< Cryptographic engine/functions
+    Input,             ///< Input emulation
+    Network,           ///< Network emulation
+    WebService,        ///< Interface to yuzu Web Services
+    Count              ///< Total number of logging classes
 };
 
 } // namespace Common::Log