fs: adjust future save path

am: stub CreateCacheStorage
fs: stub cache storage and fix params alignment
2023-05-11 17:30:30 -04:00 · 2023-05-11 17:26:02 -04:00 · 2023-05-11 17:23:28 -04:00 · 2023-05-11 10:45:59 -04:00 · 2023-05-11 10:45:47 -04:00 · 2023-05-11 10:45:36 -04:00
967 changed files with 56486 additions and 36837 deletions
@@ -10,7 +10,7 @@ if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .ci* dis
 fi

 # Default clang-format points to default 3.5 version one
-CLANG_FORMAT=${CLANG_FORMAT:-clang-format-12}
+CLANG_FORMAT=${CLANG_FORMAT:-clang-format-15}
 $CLANG_FORMAT --version

 if [ "$TRAVIS_EVENT_TYPE" = "pull_request" ]; then
@@ -22,6 +22,7 @@ cmake .. \
      -DUSE_DISCORD_PRESENCE=ON \
      -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
      -DYUZU_USE_BUNDLED_FFMPEG=ON \
+      -DYUZU_ENABLE_LTO=ON \
      -GNinja

 ninja
@@ -2,15 +2,12 @@
 # SPDX-License-Identifier: GPL-2.0-or-later

 # Download all pull requests as patches that match a specific label
-# Usage: python download-patches-by-label.py <Label to Match> <Root Path Folder to DL to>
+# Usage: python apply-patches-by-label.py <Label to Match>

-import requests, sys, json, urllib3.request, shutil, subprocess, os, traceback
+import json, requests, subprocess, sys, traceback

 tagline = sys.argv[2]

-http = urllib3.PoolManager()
-dl_list = {}
-
 def check_individual(labels):
    for label in labels:
        if (label["name"] == sys.argv[1]):
@@ -18,8 +15,9 @@ def check_individual(labels):
    return False

 def do_page(page):
-    url = 'https://api.github.com/repos/yuzu-emu/yuzu/pulls?page=%s' % page
+    url = f"https://api.github.com/repos/yuzu-emu/yuzu/pulls?page={page}"
    response = requests.get(url)
+    response.raise_for_status()
    if (response.ok):
        j = json.loads(response.content)
        if j == []:
@@ -27,13 +25,13 @@ def do_page(page):
        for pr in j:
            if (check_individual(pr["labels"])):
                pn = pr["number"]
-                print("Matched PR# %s" % pn)
-                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f", "--no-recurse-submodules"]))
-                print(subprocess.check_output(["git", "merge", "--squash", "pr-%s" % pn]))
-                print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))
+                print(f"Matched PR# {pn}")
+                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", f"pull/{pn}/head:pr-{pn}", "-f", "--no-recurse-submodules"]))
+                print(subprocess.check_output(["git", "merge", "--squash", f"pr-{pn}"]))
+                print(subprocess.check_output(["git", "commit", f"-m\"Merge {tagline} PR {pn}\""]))

 try:
-    for i in range(1,30):
+    for i in range(1,10):
        do_page(i)
 except:
    traceback.print_exc(file=sys.stdout)
@@ -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 convience
+    # file_name can be a string or a list for the convenience
    if isinstance(file_name, str):
        q.put(file_name)
    elif isinstance(file_name, list):
@@ -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_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 ..
+- 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 ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
@@ -0,0 +1,6 @@
+; 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
@@ -0,0 +1,17 @@
+# 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
@@ -13,9 +13,6 @@
 [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
@@ -1,13 +0,0 @@
-# SPDX-FileCopyrightText: 2020 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-path_classifiers:
-  library: "externals"
-extraction:
-  cpp:
-    prepare:
-      packages:
-      - "libsdl2-dev"
-      - "qtmultimedia5-dev"
-      - "libtbb-dev"
-      - "libjack-jackd2-dev"
@@ -56,6 +56,8 @@ 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)
@@ -65,6 +67,9 @@ 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 "")
@@ -205,10 +210,11 @@ 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 MODULE)
-find_package(LLVM MODULE)
+find_package(inih 52 MODULE COMPONENTS INIReader)
+find_package(LLVM MODULE COMPONENTS Demangle)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
 find_package(Opus 1.3 MODULE)
@@ -216,7 +222,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.238 REQUIRED)
+    find_package(Vulkan 1.3.246 REQUIRED)
 endif()

 if (ENABLE_LIBUSB)
@@ -241,26 +247,13 @@ endif()

 if (ENABLE_WEB_SERVICE)
    find_package(cpp-jwt 1.4 CONFIG)
-    find_package(httplib 0.11 MODULE)
+    find_package(httplib 0.12 MODULE COMPONENTS OpenSSL)
 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)
@@ -351,12 +344,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 pacakge dependency `glu` not found. \
+                    message(FATAL_ERROR "Qt bundled package 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 pacakge dependency `dri` not found. \
+                    message(FATAL_ERROR "Qt bundled package dependency `dri` not found. \
                        Perhaps `mesa-common-dev` needs to be installed?")
                endif()

@@ -457,14 +450,6 @@ 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
@@ -492,8 +477,8 @@ if (APPLE)
    find_library(COCOA_LIBRARY Cocoa)
    set(PLATFORM_LIBRARIES ${COCOA_LIBRARY} ${IOKIT_LIBRARY} ${COREVIDEO_LIBRARY})
 elseif (WIN32)
-    # WSAPoll and SHGetKnownFolderPath (AppData/Roaming) didn't exist before WinNT 6.x (Vista)
-    add_definitions(-D_WIN32_WINNT=0x0600 -DWINVER=0x0600)
+    # Target Windows 10
+    add_definitions(-D_WIN32_WINNT=0x0A00 -DWINVER=0x0A00)
    set(PLATFORM_LIBRARIES winmm ws2_32 iphlpapi)
    if (MINGW)
        # PSAPI is the Process Status API
@@ -514,7 +499,7 @@ endif()
 # against all the src files. This should be used before making a pull request.
 # =======================================================================

-set(CLANG_FORMAT_POSTFIX "-12")
+set(CLANG_FORMAT_POSTFIX "-15")
 find_program(CLANG_FORMAT
    NAMES clang-format${CLANG_FORMAT_POSTFIX}
          clang-format
@@ -580,11 +565,7 @@ function(create_target_directory_groups target_name)
 endfunction()

 # Prevent boost from linking against libs when building
-add_definitions(-DBOOST_ERROR_CODE_HEADER_ONLY
-    -DBOOST_SYSTEM_NO_LIB
-    -DBOOST_DATE_TIME_NO_LIB
-    -DBOOST_REGEX_NO_LIB
-)
+target_link_libraries(Boost::headers INTERFACE Boost::disable_autolinking)
 # Adjustments for MSVC + Ninja
 if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
    add_compile_options(
@@ -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 prefered over variables:
+# This module defines the following targets, which are preferred 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
@@ -2,15 +2,25 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later

-find_package(LLVM QUIET CONFIG)
+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()

 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(LLVM CONFIG_MODE)
+find_package_handle_standard_args(LLVM HANDLE_COMPONENTS CONFIG_MODE)

-if (LLVM_FOUND AND NOT TARGET LLVM::Demangle)
+if (LLVM_FOUND AND LLVM_Demangle_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()
@@ -6,13 +6,23 @@ include(FindPackageHandleStandardArgs)

 find_package(httplib QUIET CONFIG)
 if (httplib_CONSIDERED_CONFIGS)
-    find_package_handle_standard_args(httplib CONFIG_MODE)
+    find_package_handle_standard_args(httplib HANDLE_COMPONENTS 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()

@@ -3,14 +3,25 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 find_package(PkgConfig QUIET)
-pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)
+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()

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(inih
-    REQUIRED_VARS INIREADER_LINK_LIBRARIES
-    VERSION_VAR INIREADER_VERSION
+    REQUIRED_VARS INIH_LINK_LIBRARIES
+    VERSION_VAR INIH_VERSION
+    HANDLE_COMPONENTS
 )

-if (inih_FOUND AND NOT TARGET inih::INIReader)
+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)
    add_library(inih::INIReader ALIAS PkgConfig::INIREADER)
 endif()
@@ -83,5 +83,3 @@ If you wish to support us a different way, please join our [Discord](https://dis
 ## License

 yuzu is licensed under the GPLv3 (or any later version). Refer to the [LICENSE.txt](https://github.com/yuzu-emu/yuzu/blob/master/LICENSE.txt) file.
-
-The [Skyline-Emulator Team](https://github.com/skyline-emu/skyline) may choose to use the code from these contributors under the GPL-3.0-or-later OR MPL-2.0: [FernandoS27](https://github.com/FernandoS27), [lioncash](https://github.com/lioncash), [bunnei](https://github.com/bunnei), [ReinUsesLisp](https://github.com/ReinUsesLisp), [Morph1984](https://github.com/Morph1984), [ogniK5377](https://github.com/ogniK5377), [german77](https://github.com/german77), [ameerj](https://github.com/ameerj), [Kelebek1](https://github.com/Kelebek1) and [lat9nq](https://github.com/lat9nq)
@@ -36,12 +36,6 @@ 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
@@ -102,41 +102,16 @@ add_subdirectory(sirit EXCLUDE_FROM_ALL)

 # httplib
 if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)
-    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)
+    set(HTTPLIB_REQUIRE_OPENSSL ON)
+    add_subdirectory(cpp-httplib EXCLUDE_FROM_ALL)
 endif()

 # cpp-jwt
 if (ENABLE_WEB_SERVICE AND NOT TARGET cpp-jwt::cpp-jwt)
-    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)
+    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)
 endif()

 # Opus
@@ -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 cachable format
+    # when caching, we need to use /Z7 to downgrade debug info to use an older but more cacheable format
    # Precompiled headers are deleted if not using /Z7. See https://github.com/nanoant/CMakePCHCompiler/issues/21
        add_compile_options(/Z7)
    else()
@@ -113,6 +113,9 @@ else()

        $<$<CXX_COMPILER_ID:Clang>:-Wno-braced-scalar-init>
        $<$<CXX_COMPILER_ID:Clang>:-Wno-unused-private-field>
+        $<$<CXX_COMPILER_ID:Clang>:-Werror=shadow-uncaptured-local>
+        $<$<CXX_COMPILER_ID:Clang>:-Werror=implicit-fallthrough>
+        $<$<CXX_COMPILER_ID:Clang>:-Werror=type-limits>
        $<$<CXX_COMPILER_ID:AppleClang>:-Wno-braced-scalar-init>
        $<$<CXX_COMPILER_ID:AppleClang>:-Wno-unused-private-field>
    )
@@ -126,6 +129,17 @@ else()
        add_compile_options("-stdlib=libc++")
    endif()

+    # GCC bugs
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12" AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        # These diagnostics would be great if they worked, but are just completely broken
+        # and produce bogus errors on external libraries like fmt.
+        add_compile_options(
+            -Wno-array-bounds
+            -Wno-stringop-overread
+            -Wno-stringop-overflow
+        )
+    endif()
+
    # Set file offset size to 64 bits.
    #
    # On modern Unixes, this is typically already the case. The lone exception is
@@ -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::ERR_MAXIMUM_SESSIONS_REACHED;
+        return Service::Audio::ResultOutOfSessions;
    }
    session_id = session_ids[next_session_id];
    next_session_id = (next_session_id + 1) % MaxInSessions;
@@ -19,7 +19,7 @@ void AudioManager::Shutdown() {

 Result AudioManager::SetOutManager(BufferEventFunc buffer_func) {
    if (!running) {
-        return Service::Audio::ERR_OPERATION_FAILED;
+        return Service::Audio::ResultOperationFailed;
    }

    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::ERR_OPERATION_FAILED;
+        return Service::Audio::ResultOperationFailed;
    }

    std::scoped_lock l{lock};
@@ -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::ERR_MAXIMUM_SESSIONS_REACHED;
+        return Service::Audio::ResultOutOfSessions;
    }
    session_id = session_ids[next_session_id];
    next_session_id = (next_session_id + 1) % MaxOutSessions;
@@ -58,7 +58,7 @@ public:
    /**
     * Get a list of audio out device names.
     *
-     * @oaram names     - Output container to write names to.
+     * @param names     - Output container to write names to.
     * @return Number of names written.
     */
    u32 GetAudioOutDeviceNames(
@@ -28,7 +28,7 @@ SystemManager& Manager::GetSystemManager() {
 Result Manager::GetWorkBufferSize(const AudioRendererParameterInternal& params,
                                  u64& out_count) const {
    if (!CheckValidRevision(params.revision)) {
-        return Service::Audio::ERR_INVALID_REVISION;
+        return Service::Audio::ResultInvalidRevision;
    }

    out_count = System::GetWorkBufferSize(params);
@@ -16,7 +16,7 @@ struct AudioBuffer {
    s64 played_timestamp;
    /// Game memory address for these samples.
    VAddr samples;
-    /// Unqiue identifier for this buffer.
+    /// Unique identifier for this buffer.
    u64 tag;
    /// Size of the samples buffer.
    u64 size;
@@ -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.Memory().ReadBlockUnsafe(buffer.samples, samples.data(), buffer.size);
+            system.ApplicationMemory().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.Memory().WriteBlockUnsafe(buffer.samples, samples.data(), buffer.size);
+        system.ApplicationMemory().WriteBlockUnsafe(buffer.samples, samples.data(), buffer.size);
    }
 }

@@ -121,8 +121,7 @@ u64 DeviceSession::GetPlayedSampleCount() const {
 }

 std::optional<std::chrono::nanoseconds> DeviceSession::ThreadFunc() {
-    // Add 5ms of samples at a 48K sample rate.
-    played_sample_count += 48'000 * INCREMENT_TIME / 1s;
+    played_sample_count = stream->GetExpectedPlayedSampleCount();
    if (type == Sink::StreamType::Out) {
        system.AudioCore().GetAudioManager().SetEvent(Event::Type::AudioOutManager, true);
    } else {
@@ -46,7 +46,7 @@ Result In::AppendBuffer(const AudioInBuffer& buffer, u64 tag) {
    if (system.AppendBuffer(buffer, tag)) {
        return ResultSuccess;
    }
-    return Service::Audio::ERR_BUFFER_COUNT_EXCEEDED;
+    return Service::Audio::ResultBufferCountReached;
 }

 void In::ReleaseAndRegisterBuffers() {
@@ -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::ERR_INVALID_DEVICE_NAME;
+        return Service::Audio::ResultNotFound;
    }

    if (in_params.sample_rate != TargetSampleRate && in_params.sample_rate > 0) {
-        return Service::Audio::ERR_INVALID_SAMPLE_RATE;
+        return Service::Audio::ResultInvalidSampleRate;
    }

    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::ERR_OPERATION_FAILED;
+        return Service::Audio::ResultOperationFailed;
    }

    session->Initialize(name, sample_format, channel_count, session_id, handle,
@@ -46,7 +46,7 @@ Result Out::AppendBuffer(const AudioOutBuffer& buffer, const u64 tag) {
    if (system.AppendBuffer(buffer, tag)) {
        return ResultSuccess;
    }
-    return Service::Audio::ERR_BUFFER_COUNT_EXCEEDED;
+    return Service::Audio::ResultBufferCountReached;
 }

 void Out::ReleaseAndRegisterBuffers() {
@@ -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::ERR_INVALID_DEVICE_NAME;
+        return Service::Audio::ResultNotFound;
    }

    if (in_params.sample_rate != TargetSampleRate && in_params.sample_rate > 0) {
-        return Service::Audio::ERR_INVALID_SAMPLE_RATE;
+        return Service::Audio::ResultInvalidSampleRate;
    }

    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::ERR_INVALID_CHANNEL_COUNT;
+    return Service::Audio::ResultInvalidChannelCount;
 }

 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::ERR_OPERATION_FAILED;
+        return Service::Audio::ResultOperationFailed;
    }

    session->Initialize(name, sample_format, channel_count, session_id, handle,
@@ -13,7 +13,7 @@
 namespace AudioCore::AudioRenderer::ADSP {

 ADSP::ADSP(Core::System& system_, Sink::Sink& sink_)
-    : system{system_}, memory{system.Memory()}, sink{sink_} {}
+    : system{system_}, memory{system.ApplicationMemory()}, sink{sink_} {}

 ADSP::~ADSP() {
    ClearCommandBuffers();
@@ -132,10 +132,10 @@ void AudioRenderer::CreateSinkStreams() {
 }

 void AudioRenderer::ThreadFunc() {
-    constexpr char name[]{"AudioRenderer"};
+    static constexpr char name[]{"AudioRenderer"};
    MicroProfileOnThreadCreate(name);
    Common::SetCurrentThreadName(name);
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
    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, initalize it.
+                    // this is a new command list, initialize it.
                    if (command_buffer.remaining_command_count == 0) {
                        command_list_processor.Initialize(system, command_buffer.buffer,
                                                          command_buffer.size, streams[index]);
@@ -189,6 +189,8 @@ 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);
@@ -10,6 +10,7 @@
 #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"

@@ -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->Memory();
+    memory = &system->ApplicationMemory();
    stream = stream_;
    header = reinterpret_cast<CommandListHeader*>(buffer);
    commands = reinterpret_cast<u8*>(buffer + sizeof(CommandListHeader));
@@ -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::ERR_MAXIMUM_SESSIONS_REACHED;
+            return Service::Audio::ResultOutOfSessions;
        }
        system_registered = true;
    }
@@ -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 calcualting its size.
+     * buffer can be a variable size, so take that into account for calculating its size.
     *
     * @return True if supported, otherwise false.
     */
@@ -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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+                return Service::Audio::ResultInvalidUpdateInfo;
            }
        }
    }

    if (total_buffer_count > mix_buffer_count) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+                return Service::Audio::ResultInvalidUpdateInfo;
            }
        } 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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+            return Service::Audio::ResultInvalidUpdateInfo;
        }
    }

@@ -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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    if (in_params->revision != behaviour_.GetUserRevision()) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    behaviour_.ClearError();
    behaviour_.UpdateFlags(in_params->flags);

    if (in_header->behaviour_size != sizeof(BehaviorInfo::InParameter)) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    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::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    } else if (CpuAddr(output) - CpuAddr(output_origin.data()) != expected_output_size) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }
    return ResultSuccess;
 }
@@ -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())};
+    const auto state{reinterpret_cast<VoiceState::BiquadFilterState*>(
+        effect_info.GetStateBuffer() + channel * sizeof(VoiceState::BiquadFilterState))};

    cmd.input = buffer_offset + parameter.inputs[channel];
    cmd.output = buffer_offset + parameter.outputs[channel];
@@ -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()) {
+                    if (mix_id < mix_context.GetCount() && mix_id != UnusedSplitterId) {
                        auto mix_info{mix_context.GetInfo(mix_id)};
                        command_buffer.GenerateDepopPrepareCommand(
                            voice_info.node_id, voice_state, render_context.depop_buffer,
@@ -4,6 +4,7 @@
 #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 {
@@ -19,10 +20,24 @@ static void ResetAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr aux_in
        return;
    }

-    auto info{reinterpret_cast<AuxInfo::AuxInfoDsp*>(memory.GetPointer(aux_info))};
-    info->read_offset = 0;
-    info->write_offset = 0;
-    info->total_sample_count = 0;
+    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));
+    }
 }

 /**
@@ -40,11 +55,10 @@ 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, 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) {
+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) {
    if (write_count_ > count_max) {
        LOG_ERROR(Service_Audio,
                  "write_count must be smaller than count_max! write_count {}, count_max {}",
@@ -52,6 +66,11 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_in
        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;
@@ -67,33 +86,47 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_in
    }

    AuxInfo::AuxInfoDsp send_info{};
-    memory.ReadBlockUnsafe(send_info_, &send_info, sizeof(AuxInfo::AuxInfoDsp));
+    auto send_ptr = &send_info;
+    bool host_safe = (send_info_ & Core::Memory::YUZU_PAGEMASK) <=
+                     (Core::Memory::YUZU_PAGESIZE - sizeof(AuxInfo::AuxInfoDsp));

-    u32 target_write_offset{send_info.write_offset + write_offset};
-    if (target_write_offset > count_max || write_count_ == 0) {
+    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) {
        return 0;
    }

    u32 write_count{write_count_};
-    u32 write_pos{0};
+    u32 read_pos{0};
    while (write_count > 0) {
        u32 to_write{std::min(count_max - target_write_offset, write_count)};
-
-        if (to_write > 0) {
+        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 {
            memory.WriteBlockUnsafe(send_buffer + target_write_offset * sizeof(s32),
-                                    &input[write_pos], to_write * sizeof(s32));
+                                    &input[read_pos], to_write * sizeof(s32));
        }
-
        target_write_offset = (target_write_offset + to_write) % count_max;
        write_count -= to_write;
-        write_pos += to_write;
+        read_pos += to_write;
    }

    if (update_count) {
-        send_info.write_offset = (send_info.write_offset + update_count) % count_max;
+        send_ptr->write_offset = (send_ptr->write_offset + update_count) % count_max;
    }

-    memory.WriteBlockUnsafe(send_info_, &send_info, sizeof(AuxInfo::AuxInfoDsp));
+    if (!host_safe) [[unlikely]] {
+        memory.WriteBlockUnsafe(send_info_, send_ptr, sizeof(AuxInfo::AuxInfoDsp));
+    }

    return write_count_;
 }
@@ -102,7 +135,7 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_in
 * 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 writing.
+ * @param memory        - Core memory for reading.
 * @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.
@@ -112,16 +145,21 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_in
 * @param update_count  - If non-zero, send_info_ will be updated.
 * @return Number of samples read.
 */
-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) {
+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) {
    if (count_max == 0) {
        return 0;
    }

-    if (count_ > count_max) {
+    if (read_count_ > count_max) {
        LOG_ERROR(Service_Audio, "count must be smaller than count_max! count {}, count_max {}",
-                  count_, count_max);
+                  read_count_, count_max);
+        return 0;
+    }
+
+    if (return_info_ == 0) {
+        LOG_ERROR(Service_Audio, "return_info_ is 0!");
        return 0;
    }

@@ -136,35 +174,49 @@ static u32 ReadAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr return_i
    }

    AuxInfo::AuxInfoDsp return_info{};
-    memory.ReadBlockUnsafe(return_info_, &return_info, sizeof(AuxInfo::AuxInfoDsp));
+    auto return_ptr = &return_info;
+    bool host_safe = (return_info_ & Core::Memory::YUZU_PAGEMASK) <=
+                     (Core::Memory::YUZU_PAGESIZE - sizeof(AuxInfo::AuxInfoDsp));

-    u32 target_read_offset{return_info.read_offset + read_offset};
+    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};
    if (target_read_offset > count_max) {
        return 0;
    }

-    u32 read_count{count_};
-    u32 read_pos{0};
+    u32 read_count{read_count_};
+    u32 write_pos{0};
    while (read_count > 0) {
        u32 to_read{std::min(count_max - target_read_offset, read_count)};
-
-        if (to_read > 0) {
+        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 {
            memory.ReadBlockUnsafe(return_buffer + target_read_offset * sizeof(s32),
-                                   &output[read_pos], to_read * sizeof(s32));
+                                   &output[write_pos], to_read * sizeof(s32));
        }
-
        target_read_offset = (target_read_offset + to_read) % count_max;
        read_count -= to_read;
-        read_pos += to_read;
+        write_pos += to_read;
    }

    if (update_count) {
-        return_info.read_offset = (return_info.read_offset + update_count) % count_max;
+        return_ptr->read_offset = (return_ptr->read_offset + update_count) % count_max;
    }

-    memory.WriteBlockUnsafe(return_info_, &return_info, sizeof(AuxInfo::AuxInfoDsp));
+    if (!host_safe) [[unlikely]] {
+        memory.WriteBlockUnsafe(return_info_, return_ptr, sizeof(AuxInfo::AuxInfoDsp));
+    }

-    return count_;
+    return read_count_;
 }

 void AuxCommand::Dump([[maybe_unused]] const ADSP::CommandListProcessor& processor,
@@ -189,7 +241,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);
+            std::memset(&output_buffer[read], 0, (processor.sample_count - read) * sizeof(s32));
        }
    } else {
        ResetAuxBufferDsp(*processor.memory, send_buffer_info);
@@ -4,6 +4,7 @@
 #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 {
 /**
@@ -19,21 +20,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 s64 min{std::numeric_limits<s32>::min()};
-    constexpr s64 max{std::numeric_limits<s32>::max()};
+    constexpr f64 min{std::numeric_limits<s32>::min()};
+    constexpr f64 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{state.s0.to_double(), state.s1.to_double(), state.s2.to_double(),
-                         state.s3.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)};

    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(static_cast<s64>(sample), min, max));
+        output[i] = static_cast<s32>(std::clamp(sample, min, max));

        s[1] = s[0];
        s[0] = in_sample;
@@ -41,10 +42,10 @@ void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
        s[2] = sample;
    }

-    state.s0 = s[0];
-    state.s1 = s[1];
-    state.s2 = s[2];
-    state.s3 = s[3];
+    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]);
 }

 /**
@@ -58,29 +59,20 @@ 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++) {
-        s64 in_sample{input[i]};
-        auto sample{in_sample * b[0] + state.s0};
-        const auto out_sample{std::clamp(sample.to_long(), min, max)};
+        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)};

        output[i] = static_cast<s32>(out_sample);

        state.s0 = state.s1 + b[1] * in_sample + a[0] * out_sample;
-        state.s1 = 0 + b[2] * in_sample + a[1] * out_sample;
+        state.s1 = b[2] * in_sample + a[1] * out_sample;
    }
 }

@@ -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) {
-    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
+    static 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,
    };
-    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
+    static 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,
    };
-    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
+    static 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,
    };
-    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
+    static 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,
    };

@@ -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) {
-    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
+    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    };
-    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
+    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
        0, 0, 1, 1, 0, 1, 0, 0, 1, 1,
    };
-    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
+    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
        0, 0, 1, 1, 0, 1, 2, 2, 3, 3,
    };
-    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
+    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
        0, 0, 1, 1, 2, 2, 4, 4, 5, 5,
    };

@@ -308,7 +308,8 @@ static void ApplyReverbEffect(const ReverbInfo::ParameterVersion2& params, Rever
        }

        Common::FixedPoint<50, 14> pre_delay_sample{
-            state.pre_delay_line.Read() * Common::FixedPoint<50, 14>::from_base(params.late_gain)};
+            state.pre_delay_line.TapOut(state.pre_delay_time) *
+            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,
@@ -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) {
-    constexpr u32 WindowSize = 10;
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc1{
+    static constexpr u32 WindowSize = 10;
+    static 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,
    };
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc2{
+    static 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,
    };
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc3{
+    static 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,
    };
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc4{
+    static 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,
    };
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc5{
+    static 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,
    };
@@ -192,7 +192,7 @@ public:
    /**
     * Get this effect's parameter data.
     *
-     * @return Pointer to the parametter, must be cast to the correct type.
+     * @return Pointer to the parameter, 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 parametter, must be cast to the correct type.
+     * @return Pointer to the parameter, must be cast to the correct type.
     */
    u8* GetStateBuffer() {
        return state.data();
@@ -104,7 +104,8 @@ public:
        }

        void Write(const Common::FixedPoint<50, 14> sample) {
-            *(input++) = sample;
+            *input = sample;
+            input++;
            if (input >= buffer_end) {
                input = buffer.data();
            }
@@ -79,12 +79,10 @@ public:
                return;
            }
            sample_count = delay_time;
-            input = &buffer[(output - buffer.data() + sample_count) % (sample_count_max + 1)];
+            input = &buffer[0];
        }

        Common::FixedPoint<50, 14> Tick(const Common::FixedPoint<50, 14> sample) {
-            Write(sample);
-
            auto out_sample{Read()};

            output++;
@@ -92,6 +90,7 @@ public:
                output = buffer.data();
            }

+            Write(sample);
            return out_sample;
        }

@@ -100,7 +99,8 @@ public:
        }

        void Write(const Common::FixedPoint<50, 14> sample) {
-            *(input++) = sample;
+            *input = sample;
+            input++;
            if (input >= buffer_end) {
                input = buffer.data();
            }
@@ -29,7 +29,7 @@ public:
     */
    enum class State {
        Invalid,
-        Aquired,
+        Acquired,
        RequestDetach,
        Detached,
        RequestAttach,
@@ -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::ERR_POOL_MAPPING_FAILED;
+        error_info.error_code = Service::Audio::ResultInvalidAddressInfo;
        error_info.address = address;
        return force_map;
    }
@@ -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, othewise false.
+     * @return True if the sort was successful, otherwise false.
     */
    bool TSortInfo(const SplitterContext& splitter_context);

@@ -33,7 +33,7 @@ struct PerformanceDetailVersion1 {
    /* 0x0D */ PerformanceEntryType entry_type;
 };
 static_assert(sizeof(PerformanceDetailVersion1) == 0x10,
-              "PerformanceDetailVersion1 has the worng size!");
+              "PerformanceDetailVersion1 has the wrong 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 worng size!");
+              "PerformanceDetailVersion2 has the wrong size!");

 } // namespace AudioCore::AudioRenderer
@@ -22,7 +22,7 @@ struct PerformanceEntryVersion1 {
    /* 0x0C */ PerformanceEntryType entry_type;
 };
 static_assert(sizeof(PerformanceEntryVersion1) == 0x10,
-              "PerformanceEntryVersion1 has the worng size!");
+              "PerformanceEntryVersion1 has the wrong 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 worng size!");
+              "PerformanceEntryVersion2 has the wrong size!");

 } // namespace AudioCore::AudioRenderer
@@ -16,7 +16,7 @@ struct PerformanceFrameHeaderVersion1 {
    /* 0x14 */ u32 frame_index;
 };
 static_assert(sizeof(PerformanceFrameHeaderVersion1) == 0x18,
-              "PerformanceFrameHeaderVersion1 has the worng size!");
+              "PerformanceFrameHeaderVersion1 has the wrong 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 worng size!");
+              "PerformanceFrameHeaderVersion2 has the wrong size!");

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

@@ -87,7 +87,7 @@ public:
    /**
     * Update this destination.
     *
-     * @param params - Inpout parameters to update the destination.
+     * @param params - Input 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 destiantion in use?
+    /// Is this destination in use?
    bool in_use{};
-    /// Does this destiantion need its volumes updated?
+    /// Does this destination need its volumes updated?
    bool need_update{};
 };

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

    /**
     * Set the number of destinations in this splitter.
     *
-     * @param count - The new number of destiantions.
+     * @param count - The new number of destinations.
     */
    void SetDestinationCount(u32 count);

@@ -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::ERR_INVALID_REVISION;
+        return Service::Audio::ResultInvalidRevision;
    }

    if (GetWorkBufferSize(params) > transfer_memory_size) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    if (process_handle_ == 0) {
-        return Service::Audio::ERR_INVALID_PROCESS_HANDLE;
+        return Service::Audio::ResultInvalidHandle;
    }

    behavior.SetUserLibRevision(params.revision);
@@ -127,8 +127,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    render_device = params.rendering_device;
    execution_mode = params.execution_mode;

-    core.Memory().ZeroBlock(*core.Kernel().CurrentProcess(), transfer_memory->GetSourceAddress(),
-                            transfer_memory_size);
+    core.ApplicationMemory().ZeroBlock(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
@@ -143,19 +142,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::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    auto upsampler_workbuffer{allocator.Allocate<s32>(
        (voice_channels + mix_buffer_count) * TargetSampleCount * upsampler_count, 0x10)};
    if (upsampler_workbuffer.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    depop_buffer =
        allocator.Allocate<s32>(Common::AlignUp(static_cast<u32>(mix_buffer_count), 0x40), 0x40);
    if (depop_buffer.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    // invalidate samples_workbuffer DSP cache
@@ -166,12 +165,12 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (voice_infos.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    auto sorted_voice_infos{allocator.Allocate<VoiceInfo*>(params.voices, 0x10)};
    if (sorted_voice_infos.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    std::memset(sorted_voice_infos.data(), 0, sorted_voice_infos.size_bytes());
@@ -183,12 +182,12 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (voice_channel_resources.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    auto voice_cpu_states{allocator.Allocate<VoiceState>(params.voices, 0x10)};
    if (voice_cpu_states.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    for (auto& voice_state : voice_cpu_states) {
@@ -198,7 +197,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::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    u32 effect_process_order_count{0};
@@ -208,7 +207,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::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }
    }

@@ -222,7 +221,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::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    std::memset(sorted_mix_infos.data(), 0, sorted_mix_infos.size_bytes());
@@ -235,7 +234,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::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }

        mix_context.Initialize(sorted_mix_infos, mix_infos, params.sub_mixes + 1,
@@ -250,7 +249,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,

    upsampler_manager = allocator.Allocate<UpsamplerManager>(1, 0x10).data();
    if (upsampler_manager == nullptr) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    memory_pool_workbuffer = allocator.Allocate<MemoryPoolInfo>(memory_pool_count, 0x10);
@@ -259,18 +258,18 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (memory_pool_workbuffer.empty() && memory_pool_count > 0) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    if (!splitter_context.Initialize(behavior, params, allocator)) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    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::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }
        std::memset(effect_result_states_cpu.data(), 0, effect_result_states_cpu.size_bytes());
    }
@@ -289,7 +288,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
                                        upsampler_workbuffer);

    if (upsampler_infos.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    auto effect_infos{allocator.Allocate<EffectInfoBase>(params.effects, 0x40)};
@@ -298,14 +297,14 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (effect_infos.empty() && params.effects > 0) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    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::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }
        std::memset(effect_result_states_dsp.data(), 0, effect_result_states_dsp.size_bytes());
    }
@@ -319,14 +318,14 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (sinks.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    sink_context.Initialize(sinks, params.sinks);

    auto voice_dsp_states{allocator.Allocate<VoiceState>(params.voices, 0x40)};
    if (voice_dsp_states.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    for (auto& voice_state : voice_dsp_states) {
@@ -344,7 +343,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
            0xC};
        performance_workbuffer = allocator.Allocate<u8>(perf_workbuffer_size, 0x40);
        if (performance_workbuffer.empty()) {
-            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }
        std::memset(performance_workbuffer.data(), 0, performance_workbuffer.size_bytes());
        performance_manager.Initialize(performance_workbuffer, performance_workbuffer.size_bytes(),
@@ -360,7 +359,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::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    command_buffer_size = 0;
@@ -437,10 +436,7 @@ void System::Stop() {
    }

    if (execution_mode == ExecutionMode::Auto) {
-        // Should wait for the system to terminate here, but core timing (should have) already
-        // stopped, so this isn't needed. Find a way to make this definite.
-
-        // terminate_event.Wait();
+        terminate_event.Wait();
    }
 }

@@ -154,7 +154,7 @@ public:
    ExecutionMode GetExecutionMode() const;

    /**
-     * Get the rendering deivce for this system.
+     * Get the rendering device 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{};
-    /// Numebr of commands in the workbuffer
+    /// Number of commands in the workbuffer
    u64 command_buffer_size{};
    /// Manager for upsamplers
    UpsamplerManager* upsampler_manager{};
@@ -15,14 +15,9 @@ 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()},
-      thread_event{Core::Timing::CreateEvent(
-          "AudioRendererSystemManager", [this](std::uintptr_t, s64 time, std::chrono::nanoseconds) {
-              return ThreadFunc2(time);
-          })} {}
+    : core{core_}, adsp{core.AudioCore().GetADSP()}, mailbox{adsp.GetRenderMailbox()} {}

 SystemManager::~SystemManager() {
    Stop();
@@ -33,8 +28,6 @@ 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);
        }
    }

@@ -45,7 +38,6 @@ void SystemManager::Stop() {
    if (!active) {
        return;
    }
-    core.CoreTiming().UnscheduleEvent(thread_event, {});
    active = false;
    update.store(true);
    update.notify_all();
@@ -94,7 +86,7 @@ bool SystemManager::Remove(System& system_) {
 }

 void SystemManager::ThreadFunc() {
-    constexpr char name[]{"AudioRenderSystemManager"};
+    static constexpr char name[]{"AudioRenderSystemManager"};
    MicroProfileOnThreadCreate(name);
    Common::SetCurrentThreadName(name);
    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
@@ -111,16 +103,7 @@ 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
@@ -36,7 +36,7 @@ public:
    /**
     * Initialize the system manager, called when any system is registered.
     *
-     * @return True if sucessfully initialized, otherwise false.
+     * @return True if successfully 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 succesfully added, otherwise false.
+     * @return True if successfully 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 succesfully removed, otherwise false.
+     * @return True if successfully removed, otherwise false.
     */
    bool Remove(System& system);

@@ -68,11 +68,6 @@ private:
     */
    void ThreadFunc();

-    /**
-     * Signalling core timing thread to run ThreadFunc.
-     */
-    std::optional<std::chrono::nanoseconds> ThreadFunc2(s64 time);
-
    enum class StreamState {
        Filling,
        Steady,
@@ -95,8 +90,6 @@ 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{};
 };
@@ -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::ERR_INVALID_UPDATE_DATA;
+            error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
            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::ERR_INVALID_UPDATE_DATA;
+            error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
            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::ERR_INVALID_UPDATE_DATA;
+            error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
            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::ERR_INVALID_UPDATE_DATA;
+        error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
        error_info[0].address = wave_buffer_internal.address;
        return;
    }
@@ -183,7 +183,7 @@ public:
    void Initialize();

    /**
-     * Does this voice ned an update?
+     * Does this voice need 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 parametters to be used for the update.
+     * @param wave_buffer_internal - Input parameters 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.
@@ -19,10 +19,10 @@ struct VoiceState {
     * State of the voice's biquad filter.
     */
    struct BiquadFilterState {
-        Common::FixedPoint<50, 14> s0;
-        Common::FixedPoint<50, 14> s1;
-        Common::FixedPoint<50, 14> s2;
-        Common::FixedPoint<50, 14> s3;
+        s64 s0;
+        s64 s1;
+        s64 s2;
+        s64 s3;
    };

    /**
@@ -101,8 +101,6 @@ public:
    ~CubebSinkStream() override {
        LOG_DEBUG(Service_Audio, "Destructing cubeb stream {}", name);

-        Unstall();
-
        if (!ctx) {
            return;
        }
@@ -143,8 +141,6 @@ public:
     * Stop the sink stream.
     */
    void Stop() override {
-        Unstall();
-
        if (!ctx || paused) {
            return;
        }
@@ -302,11 +298,21 @@ 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) {
@@ -329,12 +335,22 @@ 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;
@@ -3,6 +3,7 @@

 #include <span>
 #include <vector>
+#include <SDL.h>

 #include "audio_core/common/common.h"
 #include "audio_core/sink/sdl2_sink.h"
@@ -10,16 +11,6 @@
 #include "common/logging/log.h"
 #include "core/core.h"

-// Ignore -Wimplicit-fallthrough due to https://github.com/libsdl-org/SDL/issues/4307
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
-#endif
-#include <SDL.h>
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
 namespace AudioCore::Sink {
 /**
 * SDL sink stream, responsible for sinking samples to hardware.
@@ -88,7 +79,6 @@ public:
     * Finalize the sink stream.
     */
    void Finalize() override {
-        Unstall();
        if (device == 0) {
            return;
        }
@@ -116,7 +106,6 @@ public:
     * Stop the sink stream.
     */
    void Stop() override {
-        Unstall();
        if (device == 0 || paused) {
            return;
        }
@@ -14,6 +14,8 @@
 #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 {

@@ -35,7 +37,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.
-        constexpr std::array<f32, 4> down_mix_coeff{1.0f, 0.707f, 0.251f, 0.707f};
+        static 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) {
@@ -149,10 +151,6 @@ 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) {
@@ -187,10 +185,6 @@ 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) {
@@ -198,31 +192,22 @@ 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()) {
-        constexpr std::array<s16, 6> silence{};
+        if (system.IsShuttingDown()) {
+            release_cv.notify_one();
+        }
+
+        static 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) {
@@ -237,6 +222,10 @@ 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
@@ -248,6 +237,7 @@ 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
@@ -260,26 +250,29 @@ 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);

-    if (system.IsMulticore() && queued_buffers <= max_queue_size) {
-        Unstall();
+    {
+        std::scoped_lock lk{sample_count_lock};
+        last_sample_count_update_time = system.CoreTiming().GetGlobalTimeNs();
+        min_played_sample_count = max_played_sample_count;
+        max_played_sample_count += actual_frames_written;
    }
 }

-void SinkStream::Stall() {
-    std::scoped_lock lk{stall_guard};
-    if (stalled_lock) {
-        return;
-    }
-    stalled_lock = system.StallProcesses();
+u64 SinkStream::GetExpectedPlayedSampleCount() {
+    std::scoped_lock lk{sample_count_lock};
+    auto cur_time{system.CoreTiming().GetGlobalTimeNs()};
+    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}};
+
+    // Add 15ms of latency in sample reporting to allow for some leeway in scheduler timings
+    return std::min<u64>(exp_played_sample_count, max_played_sample_count) + TargetSampleCount * 3;
 }

-void SinkStream::Unstall() {
-    std::scoped_lock lk{stall_guard};
-    if (!stalled_lock) {
-        return;
-    }
-    system.UnstallProcesses();
-    stalled_lock.unlock();
+void SinkStream::WaitFreeSpace() {
+    std::unique_lock lk{release_mutex};
+    release_cv.wait(
+        lk, [this]() { return queued_buffers < max_queue_size || system.IsShuttingDown(); });
 }

 } // namespace AudioCore::Sink
@@ -5,6 +5,7 @@

 #include <array>
 #include <atomic>
+#include <chrono>
 #include <memory>
 #include <mutex>
 #include <span>
@@ -14,6 +15,7 @@
 #include "common/common_types.h"
 #include "common/reader_writer_queue.h"
 #include "common/ring_buffer.h"
+#include "common/thread.h"

 namespace Core {
 class System;
@@ -53,9 +55,7 @@ struct SinkBuffer {
 class SinkStream {
 public:
    explicit SinkStream(Core::System& system_, StreamType type_) : system{system_}, type{type_} {}
-    virtual ~SinkStream() {
-        Unstall();
-    }
+    virtual ~SinkStream() {}

    /**
     * Finalize the sink stream.
@@ -201,14 +201,16 @@ public:
    void ProcessAudioOutAndRender(std::span<s16> output_buffer, std::size_t num_frames);

    /**
-     * Stall core processes if the audio thread falls too far behind.
+     * Get the total number of samples expected to have been played by this stream.
+     *
+     * @return The number of samples.
     */
-    void Stall();
+    u64 GetExpectedPlayedSampleCount();

    /**
-     * Unstall core processes.
+     * Waits for free space in the sample ring buffer
     */
-    void Unstall();
+    void WaitFreeSpace();

 protected:
    /// Core system
@@ -237,12 +239,21 @@ 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::nanoseconds 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};
-    std::mutex stall_guard;
-    std::unique_lock<std::mutex> stalled_lock;
+    /// Signalled when ring buffer entries are consumed
+    std::condition_variable release_cv;
+    std::mutex release_mutex;
 };

 using SinkStreamPtr = std::unique_ptr<SinkStream>;
@@ -38,6 +38,7 @@ add_library(common STATIC
    common_precompiled_headers.h
    common_types.h
    concepts.h
+    container_hash.h
    demangle.cpp
    demangle.h
    div_ceil.h
@@ -91,6 +92,7 @@ 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
@@ -113,6 +115,8 @@ 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
@@ -129,6 +133,7 @@ add_library(common STATIC
    time_zone.h
    tiny_mt.h
    tree.h
+    typed_address.h
    uint128.h
    unique_function.h
    uuid.cpp
@@ -142,11 +147,21 @@ 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
@@ -176,7 +191,7 @@ endif()

 create_target_directory_groups(common)

-target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
+target_link_libraries(common PUBLIC Boost::context Boost::headers fmt::fmt microprofile Threads::Threads)
 target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd LLVM::Demangle)

 if (YUZU_USE_PRECOMPILED_HEADERS)
@@ -12,7 +12,8 @@

 namespace Common {
 template <typename VaType, size_t AddressSpaceBits>
-concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >= AddressSpaceBits;
+concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >=
+AddressSpaceBits;

 struct EmptyStruct {};

@@ -21,7 +22,7 @@ struct EmptyStruct {};
 */
 template <typename VaType, VaType UnmappedVa, typename PaType, PaType UnmappedPa,
          bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo = EmptyStruct>
-requires AddressSpaceValid<VaType, AddressSpaceBits>
+    requires AddressSpaceValid<VaType, AddressSpaceBits>
 class FlatAddressSpaceMap {
 public:
    /// The maximum VA that this AS can technically reach
@@ -109,7 +110,7 @@ private:
 * initial, fast linear pass and a subsequent slower pass that iterates until it finds a free block
 */
 template <typename VaType, VaType UnmappedVa, size_t AddressSpaceBits>
-requires AddressSpaceValid<VaType, AddressSpaceBits>
+    requires AddressSpaceValid<VaType, AddressSpaceBits>
 class FlatAllocator
    : public FlatAddressSpaceMap<VaType, UnmappedVa, bool, false, false, AddressSpaceBits> {
 private:
@@ -72,7 +72,7 @@ MAP_MEMBER(void)::MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInf
                }
            }()};

-            if (block_end_predecessor->virt >= virt) {
+            if (block_end_predecessor != blocks.begin() && block_end_predecessor->virt >= virt) {
                // If this block's start would be overlapped by the map then reuse it as a tail
                // block
                block_end_predecessor->virt = virt_end;
@@ -336,7 +336,7 @@ ALLOC_MEMBER(VaType)::Allocate(VaType size) {
            ASSERT_MSG(false, "Unexpected allocator state!");
        }

-        auto search_predecessor{this->blocks.begin()};
+        auto search_predecessor{std::next(this->blocks.begin())};
        auto search_successor{std::next(search_predecessor)};

        while (search_successor != this->blocks.end() &&
@@ -10,7 +10,7 @@
 namespace Common {

 template <typename T>
-requires std::is_unsigned_v<T>
+    requires std::is_unsigned_v<T>
 [[nodiscard]] constexpr T AlignUp(T value, size_t size) {
    auto mod{static_cast<T>(value % size)};
    value -= mod;
@@ -18,31 +18,31 @@ requires std::is_unsigned_v<T>
 }

 template <typename T>
-requires std::is_unsigned_v<T>
+    requires std::is_unsigned_v<T>
 [[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
    return static_cast<T>((value + ((1ULL << align_log2) - 1)) >> align_log2 << align_log2);
 }

 template <typename T>
-requires std::is_unsigned_v<T>
+    requires std::is_unsigned_v<T>
 [[nodiscard]] constexpr T AlignDown(T value, size_t size) {
    return static_cast<T>(value - value % size);
 }

 template <typename T>
-requires std::is_unsigned_v<T>
+    requires std::is_unsigned_v<T>
 [[nodiscard]] constexpr bool Is4KBAligned(T value) {
    return (value & 0xFFF) == 0;
 }

 template <typename T>
-requires std::is_unsigned_v<T>
+    requires std::is_unsigned_v<T>
 [[nodiscard]] constexpr bool IsWordAligned(T value) {
    return (value & 0b11) == 0;
 }

 template <typename T>
-requires std::is_integral_v<T>
+    requires std::is_integral_v<T>
 [[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
    using U = typename std::make_unsigned_t<T>;
    const U mask = static_cast<U>(alignment - 1);
@@ -50,7 +50,7 @@ requires std::is_integral_v<T>
 }

 template <typename T, typename U>
-requires std::is_integral_v<T>
+    requires std::is_integral_v<T>
 [[nodiscard]] constexpr T DivideUp(T x, U y) {
    return (x + (y - 1)) / y;
 }
@@ -73,11 +73,11 @@ public:
    constexpr AlignmentAllocator(const AlignmentAllocator<T2, Align>&) noexcept {}

    [[nodiscard]] T* allocate(size_type n) {
-        return static_cast<T*>(::operator new (n * sizeof(T), std::align_val_t{Align}));
+        return static_cast<T*>(::operator new(n * sizeof(T), std::align_val_t{Align}));
    }

    void deallocate(T* p, size_type n) {
-        ::operator delete (p, n * sizeof(T), std::align_val_t{Align});
+        ::operator delete(p, n * sizeof(T), std::align_val_t{Align});
    }

    template <typename T2>
@@ -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 passowrd protected
+     * @param has_password True if the room is password protected
     * @param preferred_game The preferred game of the room
     * @param preferred_game_id The title id of the preferred game
     */
@@ -75,7 +75,7 @@ extern "C" void AnnotateHappensAfter(const char*, int, void*);
 #if defined(AE_VCPP) || defined(AE_ICC)
 #define AE_FORCEINLINE __forceinline
 #elif defined(AE_GCC)
-//#define AE_FORCEINLINE __attribute__((always_inline))
+// #define AE_FORCEINLINE __attribute__((always_inline))
 #define AE_FORCEINLINE inline
 #else
 #define AE_FORCEINLINE inline
@@ -3,19 +3,21 @@

 #pragma once

-#include <cstring>
-#include <type_traits>
+#include <version>
+
+#ifdef __cpp_lib_bit_cast
+#include <bit>
+#endif

 namespace Common {

 template <typename To, typename From>
-[[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;
+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
 }

 } // namespace Common
--- a/Show More
+++ b/Show More