Replace NaN mix volume samples with silence.

Fixes Xenoblade Chronicles 2 blowing out the audio.
Merge pull request #6569 from Kelebek1/Vol
2021-07-08 17:42:15 +01:00 · 2021-07-08 12:09:21 -04:00 · 2021-07-08 17:07:23 +01:00 · 2021-07-07 14:52:08 -07:00 · 2021-07-07 16:18:05 -03:00 · 2021-07-07 14:09:55 -04:00
186 changed files with 4813 additions and 8005 deletions
@@ -18,19 +18,20 @@ cd ..
 mkdir package

 if [ -d "/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/" ]; then
-  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
+  QT_PLUGINS_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins'
 else
  #fallback to qt
-  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt/plugins/platforms/'
+  QT_PLUGINS_PATH='/usr/x86_64-w64-mingw32/lib/qt/plugins'
 fi

 find build/ -name "yuzu*.exe" -exec cp {} 'package' \;

 # copy Qt plugins
 mkdir package/platforms
-cp "${QT_PLATFORM_DLL_PATH}/qwindows.dll" package/platforms/
-cp -rv "${QT_PLATFORM_DLL_PATH}/../mediaservice/" package/
-cp -rv "${QT_PLATFORM_DLL_PATH}/../imageformats/" package/
+cp -v "${QT_PLUGINS_PATH}/platforms/qwindows.dll" package/platforms/
+cp -rv "${QT_PLUGINS_PATH}/mediaservice/" package/
+cp -rv "${QT_PLUGINS_PATH}/imageformats/" package/
+cp -rv "${QT_PLUGINS_PATH}/styles/" package/
 rm -f package/mediaservice/*d.dll

 for i in package/*.exe; do
@@ -18,7 +18,7 @@
 	url = https://github.com/libusb/libusb.git
 [submodule "discord-rpc"]
    path = externals/discord-rpc
-    url = https://github.com/discordapp/discord-rpc.git
+    url = https://github.com/discord/discord-rpc.git
 [submodule "Vulkan-Headers"]
    path = externals/Vulkan-Headers
    url = https://github.com/KhronosGroup/Vulkan-Headers.git
@@ -43,3 +43,6 @@
 [submodule "SDL"]
 	path = externals/SDL
 	url = https://github.com/libsdl-org/SDL.git
+[submodule "externals/cpp-httplib"]
+	path = externals/cpp-httplib
+	url = https://github.com/yhirose/cpp-httplib.git
@@ -172,7 +172,7 @@ macro(yuzu_find_packages)
    set(REQUIRED_LIBS
    #    Cmake Pkg Prefix  Version     Conan Pkg
        "Catch2            2.13        catch2/2.13.0"
-        "fmt               7.1         fmt/7.1.2"
+        "fmt               8.0         fmt/8.0.0"
        "lz4               1.8         lz4/1.9.2"
        "nlohmann_json     3.8         nlohmann_json/3.8.0"
        "ZLIB              1.2         zlib/1.2.11"
@@ -253,11 +253,82 @@ if(ENABLE_QT)

    # Check for system Qt on Linux, fallback to bundled Qt
    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-        if (NOT YUZU_USE_BUNDLED_QT)
-            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets QUIET)
-            if (NOT Qt5_FOUND)
-                set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
+        find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets)
+        if (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT)
+            # Check for dependencies, then enable bundled Qt download
+
+            # Check that the system GLIBCXX version is compatible
+            find_program(OBJDUMP objdump)
+            if ("${OBJDUMP}" STREQUAL "OBJDUMP-NOTFOUND")
+                message(FATAL_ERROR "Required program `objdump` not found.")
            endif()
+            find_library(LIBSTDCXX libstdc++.so.6)
+            execute_process(
+                COMMAND
+                    ${OBJDUMP} -T ${LIBSTDCXX}
+                COMMAND
+                    grep GLIBCXX_3.4.28
+                COMMAND
+                    sed "s/[0-9a-f]*.*  //"
+                COMMAND
+                    sed "s/ .*//"
+                COMMAND
+                    sort -u
+                OUTPUT_VARIABLE
+                    GLIBCXX_MET
+            )
+            if (NOT GLIBCXX_MET)
+                message(FATAL_ERROR "Qt too old or not found, and bundled Qt package is not \
+                    compatible with this system. Either install Qt ${QT_VERSION}, or provide the path \
+                    to Qt by setting the variable Qt5_ROOT.")
+            endif()
+
+            # Check for headers
+            Include(FindPkgConfig 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. \
+                    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. \
+                    Perhaps `mesa-common-dev` needs to be installed?")
+            endif()
+
+            # Check for X libraries
+            set(BUNDLED_QT_REQUIREMENTS
+                libxcb-icccm.so.4
+                libxcb-image.so.0
+                libxcb-keysyms.so.1
+                libxcb-randr.so.0
+                libxcb-render-util.so.0
+                libxcb-render.so.0
+                libxcb-shape.so.0
+                libxcb-shm.so.0
+                libxcb-sync.so.1
+                libxcb-xfixes.so.0
+                libxcb-xinerama.so.0
+                libxcb-xkb.so.1
+                libxcb.so.1
+                libxkbcommon-x11.so.0
+                libxkbcommon.so.0
+            )
+            set(UNRESOLVED_QT_DEPS "")
+            foreach (REQUIREMENT ${BUNDLED_QT_REQUIREMENTS})
+                find_library(BUNDLED_QT_${REQUIREMENT} ${REQUIREMENT})
+                if ("${BUNDLED_QT_${REQUIREMENT}}" STREQUAL "BUNDLED_QT_${REQUIREMENT}-NOTFOUND")
+                    set(UNRESOLVED_QT_DEPS ${UNRESOLVED_QT_DEPS} ${REQUIREMENT})
+                endif()
+                unset(BUNDLED_QT_${REQUIREMENT})
+            endforeach()
+            unset(BUNDLED_QT_REQUIREMENTS)
+
+            if (NOT "${UNRESOLVED_QT_DEPS}" STREQUAL "")
+                message(FATAL_ERROR "Bundled Qt package missing required dependencies: ${UNRESOLVED_QT_DEPS}")
+            endif()
+
+            set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
        endif()
        if (YUZU_USE_BUNDLED_QT)
            # Binary package currently does not support Qt webengine, so make sure it's disabled
@@ -473,7 +544,15 @@ if (YUZU_USE_BUNDLED_FFMPEG)

        # FFmpeg has source that requires one of nasm or yasm to assemble it.
        # REQUIRED throws an error if not found here during configuration rather than during compilation.
-        find_program(ASSEMBLER NAMES nasm yasm REQUIRED)
+        find_program(ASSEMBLER NAMES nasm yasm)
+        if ("${ASSEMBLER}" STREQUAL "ASSEMBLER-NOTFOUND")
+            message(FATAL_ERROR "One of either `nasm` or `yasm` not found but is required.")
+        endif()
+
+        find_program(AUTOCONF autoconf)
+        if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
+            message(FATAL_ERROR "Required program `autoconf` not found.")
+        endif()

        set(FFmpeg_PREFIX ${PROJECT_SOURCE_DIR}/externals/ffmpeg)
        set(FFmpeg_BUILD_DIR ${PROJECT_BINARY_DIR}/externals/ffmpeg)
@@ -1,43 +1,80 @@
-yuzu emulator
-=============
-[![Travis CI Build Status](https://travis-ci.com/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.com/yuzu-emu/yuzu)
-[![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
-[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.com/invite/u77vRWY)
+<h1 align="center">
+  <br>
+  <a href="https://yuzu-emu.org/"><img src="https://raw.githubusercontent.com/yuzu-emu/yuzu-assets/master/icons/icon.png" alt="yuzu" width="200"></a>
+  <br>
+  <b>yuzu</b>
+  <br>
+</h1>

-yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).
+<h4 align="center"><b>yuzu</b> is the world's most popular, open-source, Nintendo Switch emulator — started by the creators of <a href="https://citra-emu.org" target="_blank">Citra</a>.
+<br>
+It is written in C++ with portability in mind, and we actively maintain builds for Windows and Linux.
+</h4>

-It is written in C++ with portability in mind, with builds actively maintained for Windows and Linux. The emulator is capable of running several commercial games.
+<p align="center">
+    <a href="https://dev.azure.com/yuzu-emu/yuzu/">
+        <img src="https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master"
+            alt="Azure Mainline CI Build Status">
+    </a>
+    <a href="https://discord.com/invite/u77vRWY">
+        <img src="https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white"
+            alt="Discord">
+    </a>
+</p>

-yuzu only emulates a subset of Switch hardware and therefore most commercial games **do not** run at full speed or are not fully functional.
+<p align="center">
+  <a href="#compatibility">Compatibility</a> |
+  <a href="#development">Development</a> |
+  <a href="#building">Building</a> |
+  <a href="#download">Download</a> |
+  <a href="#support">Support</a> |
+  <a href="#license">License</a>
+</p>

-Do you want to check which games are compatible and which ones are not? Please visit our [Compatibility page](https://yuzu-emu.org/game/)!
+## Compatibility

-yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
+The emulator is capable of running most commercial games at full speed, provided you meet the [necessary hardware requirements](https://yuzu-emu.org/help/quickstart/#hardware-requirements).

-Check out our [website](https://yuzu-emu.org/)!
+For a full list of games yuzu support, please visit our [Compatibility page](https://yuzu-emu.org/game/) 

-For development discussion, please join us on [Discord](https://discord.com/invite/u77vRWY).
+Check out our [website](https://yuzu-emu.org/) for the latest news on exciting features, monthly progress reports, and more!

-### Development
+## Development

-Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted.
+Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted. For development discussion, please join us on [Discord](https://discord.com/invite/u77vRWY).

-If you want to contribute please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should also contact any of the developers on Discord in order to know about the current state of the emulator.
+If you want to contribute, please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). 
+You can also contact any of the developers on Discord in order to know about the current state of the emulator.

-If you want to contribute to the user interface translation, please check out the [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu). We centralize translation work there, and periodically upstream translations.
+If you want to contribute to the user interface translation project, please check out the [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu). We centralize translation work there, and periodically upstream translations.

-### Building
+## Building

 * __Windows__: [Windows Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Windows)
 * __Linux__: [Linux Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Linux)

+## Download

-### Support
-We happily accept monetary donations, or donated games and hardware. Please see our [donations page](https://yuzu-emu.org/donate/) for more information on how you can contribute to yuzu. Any donations received will go towards things like:
+You can download the latest releases automatically via the installer on our [downloads](https://yuzu-emu.org/downloads/) page.
+
+
+## Support
+
+If you enjoy the project and want to support us financially, check out our Patreon!
+
+<a href="https://www.patreon.com/yuzuteam">
+    <img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" width="160">
+</a>
+
+Any donations received will go towards things like:
 * Switch consoles to explore and reverse-engineer the hardware
 * Switch games for testing, reverse-engineering, and implementing new features
 * Web hosting and infrastructure setup
 * Software licenses (e.g. Visual Studio, IDA Pro, etc.)
 * Additional hardware (e.g. GPUs as-needed to improve rendering support, other peripherals to add support for, etc.)

-We also more than gladly accept used Switch consoles, preferably ones with firmware 3.0.0 or lower! If you would like to give yours away, don't hesitate to join our [Discord](https://discord.gg/VXqngT3) and talk to bunnei. You may also contact: donations@yuzu-emu.org.
+If you wish to support us a different way, please join our [Discord](https://discord.gg/u77vRWY) and talk to bunnei. You may also contact: donations@yuzu-emu.org.
+
+## License
+
+yuzu is licensed under the GPLv2 (or any later version). Refer to the [license.txt](https://github.com/yuzu-emu/yuzu/blob/master/license.txt) file.
@@ -53,10 +53,10 @@ endif()
 # SDL2
 if (NOT SDL2_FOUND AND ENABLE_SDL2)
    if (NOT WIN32)
-        # Yuzu itself needs: Events Joystick Haptic Sensor Timers
+        # Yuzu itself needs: Events Joystick Haptic Sensor Timers Audio
        # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
        set(SDL_UNUSED_SUBSYSTEMS
-            Atomic Audio Render Power Threads
+            Atomic Render Power Threads
            File CPUinfo Filesystem Locale)
        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
          string(TOUPPER ${_SUB} _OPT)
@@ -115,7 +115,7 @@ if (ENABLE_WEB_SERVICE)

    # httplib
    add_library(httplib INTERFACE)
-    target_include_directories(httplib INTERFACE ./httplib)
+    target_include_directories(httplib INTERFACE ./cpp-httplib)
    target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
    target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
    if (WIN32)
@@ -1,15 +0,0 @@
-From https://github.com/yhirose/cpp-httplib/tree/ff5677ad197947177c158fe857caff4f0e242045 with https://github.com/yhirose/cpp-httplib/pull/701
-
-MIT License
-
-===
-
-cpp-httplib
-
-A C++11 header-only HTTP library.
-
-It's extremely easy to setup. Just include httplib.h file in your code!
-
-Inspired by Sinatra and express.
-
-© 2017 Yuji Hirose
@@ -1,10 +1,21 @@
-if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux"))
+if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)
    set(LIBUSB_FOUND ON CACHE BOOL "libusb is present" FORCE)
    set(LIBUSB_VERSION "1.0.24" CACHE STRING "libusb version string" FORCE)

    # GNU toolchains for some reason doesn't work with the later half of this CMakeLists after
    # updating to 1.0.24, so we do it the old-fashioned way for now.

+    # Require autoconf and libtoolize here, rather than crash during compilation
+    find_program(AUTOCONF autoconf)
+    if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
+        message(FATAL_ERROR "Required program `autoconf` not found.")
+    endif()
+
+    find_program(LIBTOOLIZE libtoolize)
+    if ("${LIBTOOLIZE}" STREQUAL "LIBTOOLIZE-NOTFOUND")
+        message(FATAL_ERROR "Required program `libtoolize` not found.")
+    endif()
+
    set(LIBUSB_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/libusb")
    set(LIBUSB_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libusb")

@@ -45,13 +45,23 @@ if (MSVC)
        /Zc:inline
        /Zc:throwingNew

+        # External headers diagnostics
+        /experimental:external  # Enables the external headers options. This option isn't required in Visual Studio 2019 version 16.10 and later
+        /external:anglebrackets # Treats all headers included by #include <header>, where the header file is enclosed in angle brackets (< >), as external headers
+        /external:W0            # Sets the default warning level to 0 for external headers, effectively turning off warnings for external headers
+
        # Warnings
        /W3
-        /we4062 # enumerator 'identifier' in a switch of enum 'enumeration' is not handled
+        /we4018 # 'expression': signed/unsigned mismatch
+        /we4062 # Enumerator 'identifier' in a switch of enum 'enumeration' is not handled
        /we4101 # 'identifier': unreferenced local variable
+        /we4189 # 'identifier': local variable is initialized but not referenced
        /we4265 # 'class': class has virtual functions, but destructor is not virtual
-        /we4388 # signed/unsigned mismatch
-        /we4547 # 'operator' : operator before comma has no effect; expected operator with side-effect
+        /we4267 # 'var': conversion from 'size_t' to 'type', possible loss of data
+        /we4305 # 'context': truncation from 'type1' to 'type2'
+        /we4388 # 'expression': signed/unsigned mismatch
+        /we4389 # 'operator': signed/unsigned mismatch
+        /we4547 # 'operator': operator before comma has no effect; expected operator with side-effect
        /we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
        /we4555 # Expression has no effect; expected expression with side-effect
        /we4715 # 'function': not all control paths return a value
@@ -72,6 +82,7 @@ else()
        -Werror=missing-declarations
        -Werror=missing-field-initializers
        -Werror=reorder
+        -Werror=sign-compare
        -Werror=switch
        -Werror=uninitialized
        -Werror=unused-function
@@ -42,6 +42,7 @@ add_library(audio_core STATIC
    voice_context.h

    $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
+    $<$<BOOL:${ENABLE_SDL2}>:sdl2_sink.cpp sdl2_sink.h>
 )

 create_target_directory_groups(audio_core)
@@ -50,9 +51,6 @@ if (NOT MSVC)
    target_compile_options(audio_core PRIVATE
        -Werror=conversion
        -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=reorder
-        -Werror=sign-compare
        -Werror=shadow
        -Werror=unused-parameter
        -Werror=unused-variable
@@ -71,3 +69,7 @@ if(ENABLE_CUBEB)
    target_link_libraries(audio_core PRIVATE cubeb)
    target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
+if(ENABLE_SDL2)
+    target_link_libraries(audio_core PRIVATE SDL2)
+    target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
+endif()
@@ -12,6 +12,7 @@
 #include "audio_core/voice_context.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
+#include "core/core_timing.h"
 #include "core/memory.h"

 namespace {
@@ -28,10 +29,9 @@ namespace {
                                       (static_cast<float>(r_channel) * r_mix_amount)));
 }

-[[nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(s16 fl_channel, s16 fr_channel,
-                                                            s16 fc_channel,
-                                                            [[maybe_unused]] s16 lf_channel,
-                                                            s16 bl_channel, s16 br_channel) {
+[[maybe_unused, nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(
+    s16 fl_channel, s16 fr_channel, s16 fc_channel, [[maybe_unused]] s16 lf_channel, s16 bl_channel,
+    s16 br_channel) {
    // Front channels are mixed 36.94%, Center channels are mixed to be 26.12% & the back channels
    // are mixed to be 36.94%

@@ -56,11 +56,11 @@ namespace {
    const std::array<float_le, 4>& coeff) {
    const auto left =
        static_cast<float>(fl_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[0];
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[3];

    const auto right =
        static_cast<float>(fr_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[0];
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[3];

    return {ClampToS16(static_cast<s32>(left)), ClampToS16(static_cast<s32>(right))};
 }
@@ -68,7 +68,9 @@ namespace {
 } // namespace

 namespace AudioCore {
-AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
+constexpr s32 NUM_BUFFERS = 2;
+
+AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_,
                             AudioCommon::AudioRendererParameter params,
                             Stream::ReleaseCallback&& release_callback,
                             std::size_t instance_number)
@@ -77,7 +79,8 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory
      sink_context(params.sink_count), splitter_context(),
      voices(params.voice_count), memory{memory_},
      command_generator(worker_params, voice_context, mix_context, splitter_context, effect_context,
-                        memory) {
+                        memory),
+      core_timing{core_timing_} {
    behavior_info.SetUserRevision(params.revision);
    splitter_context.Initialize(behavior_info, params.splitter_count,
                                params.num_splitter_send_channels);
@@ -86,16 +89,27 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory
    stream = audio_out->OpenStream(
        core_timing, params.sample_rate, AudioCommon::STREAM_NUM_CHANNELS,
        fmt::format("AudioRenderer-Instance{}", instance_number), std::move(release_callback));
-    audio_out->StartStream(stream);
-
-    QueueMixedBuffer(0);
-    QueueMixedBuffer(1);
-    QueueMixedBuffer(2);
-    QueueMixedBuffer(3);
+    process_event = Core::Timing::CreateEvent(
+        fmt::format("AudioRenderer-Instance{}-Process", instance_number),
+        [this](std::uintptr_t, std::chrono::nanoseconds) { ReleaseAndQueueBuffers(); });
+    for (s32 i = 0; i < NUM_BUFFERS; ++i) {
+        QueueMixedBuffer(i);
+    }
 }

 AudioRenderer::~AudioRenderer() = default;

+ResultCode AudioRenderer::Start() {
+    audio_out->StartStream(stream);
+    ReleaseAndQueueBuffers();
+    return ResultSuccess;
+}
+
+ResultCode AudioRenderer::Stop() {
+    audio_out->StopStream(stream);
+    return ResultSuccess;
+}
+
 u32 AudioRenderer::GetSampleRate() const {
    return worker_params.sample_rate;
 }
@@ -114,7 +128,7 @@ Stream::State AudioRenderer::GetStreamState() const {

 ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params,
                                              std::vector<u8>& output_params) {
-
+    std::scoped_lock lock{mutex};
    InfoUpdater info_updater{input_params, output_params, behavior_info};

    if (!info_updater.UpdateBehaviorInfo(behavior_info)) {
@@ -194,9 +208,6 @@ ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_param
        LOG_ERROR(Audio, "Audio buffers were not consumed!");
        return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
    }
-
-    ReleaseAndQueueBuffers();
-
    return ResultSuccess;
 }

@@ -220,10 +231,8 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
    command_generator.PostCommand();
    // Base sample size
    std::size_t BUFFER_SIZE{worker_params.sample_count};
-    // Samples
-    std::vector<s16> buffer(BUFFER_SIZE * stream->GetNumChannels());
-    // Make sure to clear our samples
-    std::memset(buffer.data(), 0, buffer.size() * sizeof(s16));
+    // Samples, making sure to clear
+    std::vector<s16> buffer(BUFFER_SIZE * stream->GetNumChannels(), 0);

    if (sink_context.InUse()) {
        const auto stream_channel_count = stream->GetNumChannels();
@@ -231,7 +240,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
        const auto channel_count = buffer_offsets.size();
        const auto& final_mix = mix_context.GetFinalMixInfo();
        const auto& in_params = final_mix.GetInParams();
-        std::vector<s32*> mix_buffers(channel_count);
+        std::vector<std::span<s32>> mix_buffers(channel_count);
        for (std::size_t i = 0; i < channel_count; i++) {
            mix_buffers[i] =
                command_generator.GetMixBuffer(in_params.buffer_offset + buffer_offsets[i]);
@@ -284,18 +293,11 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                    buffer[i * stream_channel_count + 0] = Mix2To1(fl_sample, fr_sample);
                } else if (stream_channel_count == 2) {
                    // Mix all channels into 2 channels
-                    if (sink_context.HasDownMixingCoefficients()) {
-                        const auto [left, right] = Mix6To2WithCoefficients(
-                            fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
-                            sink_context.GetDownmixCoefficients());
-                        buffer[i * stream_channel_count + 0] = left;
-                        buffer[i * stream_channel_count + 1] = right;
-                    } else {
-                        const auto [left, right] = Mix6To2(fl_sample, fr_sample, fc_sample,
-                                                           lf_sample, bl_sample, br_sample);
-                        buffer[i * stream_channel_count + 0] = left;
-                        buffer[i * stream_channel_count + 1] = right;
-                    }
+                    const auto [left, right] = Mix6To2WithCoefficients(
+                        fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
+                        sink_context.GetDownmixCoefficients());
+                    buffer[i * stream_channel_count + 0] = left;
+                    buffer[i * stream_channel_count + 1] = right;
                } else if (stream_channel_count == 6) {
                    // Pass through
                    buffer[i * stream_channel_count + 0] = fl_sample;
@@ -315,10 +317,24 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
 }

 void AudioRenderer::ReleaseAndQueueBuffers() {
-    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream)};
-    for (const auto& tag : released_buffers) {
-        QueueMixedBuffer(tag);
+    if (!stream->IsPlaying()) {
+        return;
    }
+
+    {
+        std::scoped_lock lock{mutex};
+        const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream)};
+        for (const auto& tag : released_buffers) {
+            QueueMixedBuffer(tag);
+        }
+    }
+
+    const f32 sample_rate = static_cast<f32>(GetSampleRate());
+    const f32 sample_count = static_cast<f32>(GetSampleCount());
+    const f32 consume_rate = sample_rate / (sample_count * (sample_count / 240));
+    const s32 ms = (1000 / static_cast<s32>(consume_rate)) - 1;
+    const std::chrono::milliseconds next_event_time(std::max(ms / NUM_BUFFERS, 1));
+    core_timing.ScheduleEvent(next_event_time, process_event, {});
 }

 } // namespace AudioCore
@@ -6,6 +6,7 @@

 #include <array>
 #include <memory>
+#include <mutex>
 #include <vector>

 #include "audio_core/behavior_info.h"
@@ -45,6 +46,8 @@ public:

    [[nodiscard]] ResultCode UpdateAudioRenderer(const std::vector<u8>& input_params,
                                                 std::vector<u8>& output_params);
+    [[nodiscard]] ResultCode Start();
+    [[nodiscard]] ResultCode Stop();
    void QueueMixedBuffer(Buffer::Tag tag);
    void ReleaseAndQueueBuffers();
    [[nodiscard]] u32 GetSampleRate() const;
@@ -68,6 +71,9 @@ private:
    Core::Memory::Memory& memory;
    CommandGenerator command_generator;
    std::size_t elapsed_frame_count{};
+    Core::Timing::CoreTiming& core_timing;
+    std::shared_ptr<Core::Timing::EventType> process_event;
+    std::mutex mutex;
 };

 } // namespace AudioCore
@@ -31,7 +31,7 @@ constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_GAIN{
    0.72867f, 0.69794f, 0.5464f,  0.24563f, 0.45214f, 0.44042f};

 template <std::size_t N>
-void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
+void ApplyMix(std::span<s32> output, std::span<const s32> input, s32 gain, s32 sample_count) {
    for (std::size_t i = 0; i < static_cast<std::size_t>(sample_count); i += N) {
        for (std::size_t j = 0; j < N; j++) {
            output[i + j] +=
@@ -40,7 +40,17 @@ void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
    }
 }

-s32 ApplyMixRamp(s32* output, const s32* input, float gain, float delta, s32 sample_count) {
+s32 ApplyMixRamp(std::span<s32> output, std::span<const s32> input, float gain, float delta,
+                 s32 sample_count) {
+    // XC2 passes in NaN mix volumes, causing further issues as we handle everything as s32 rather
+    // than float, so the NaN propogation is lost. As the samples get further modified for
+    // volume etc, they can get out of NaN range, so a later heuristic for catching this is
+    // more difficult. Handle it here by setting these samples to silence.
+    if (std::isnan(gain)) {
+        gain = 0.0f;
+        delta = 0.0f;
+    }
+
    s32 x = 0;
    for (s32 i = 0; i < sample_count; i++) {
        x = static_cast<s32>(static_cast<float>(input[i]) * gain);
@@ -50,20 +60,22 @@ s32 ApplyMixRamp(s32* output, const s32* input, float gain, float delta, s32 sam
    return x;
 }

-void ApplyGain(s32* output, const s32* input, s32 gain, s32 delta, s32 sample_count) {
+void ApplyGain(std::span<s32> output, std::span<const s32> input, s32 gain, s32 delta,
+               s32 sample_count) {
    for (s32 i = 0; i < sample_count; i++) {
        output[i] = static_cast<s32>((static_cast<s64>(input[i]) * gain + 0x4000) >> 15);
        gain += delta;
    }
 }

-void ApplyGainWithoutDelta(s32* output, const s32* input, s32 gain, s32 sample_count) {
+void ApplyGainWithoutDelta(std::span<s32> output, std::span<const s32> input, s32 gain,
+                           s32 sample_count) {
    for (s32 i = 0; i < sample_count; i++) {
        output[i] = static_cast<s32>((static_cast<s64>(input[i]) * gain + 0x4000) >> 15);
    }
 }

-s32 ApplyMixDepop(s32* output, s32 first_sample, s32 delta, s32 sample_count) {
+s32 ApplyMixDepop(std::span<s32> output, s32 first_sample, s32 delta, s32 sample_count) {
    const bool positive = first_sample > 0;
    auto final_sample = std::abs(first_sample);
    for (s32 i = 0; i < sample_count; i++) {
@@ -128,10 +140,10 @@ constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_6CH{4, 0, 0, 1, 1, 1, 1,
                                                           1, 1, 1, 0, 0, 0, 0, 3, 3, 3};

 template <std::size_t CHANNEL_COUNT>
-void ApplyReverbGeneric(I3dl2ReverbState& state,
-                        const std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT>& input,
-                        const std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT>& output,
-                        s32 sample_count) {
+void ApplyReverbGeneric(
+    I3dl2ReverbState& state,
+    const std::array<std::span<const s32>, AudioCommon::MAX_CHANNEL_COUNT>& input,
+    const std::array<std::span<s32>, AudioCommon::MAX_CHANNEL_COUNT>& output, s32 sample_count) {

    auto GetTapLookup = []() {
        if constexpr (CHANNEL_COUNT == 1) {
@@ -454,8 +466,8 @@ void CommandGenerator::GenerateBiquadFilterCommand([[maybe_unused]] s32 mix_buff
                  "input_mix_buffer={}, output_mix_buffer={}",
                  node_id, input_offset, output_offset);
    }
-    const auto* input = GetMixBuffer(input_offset);
-    auto* output = GetMixBuffer(output_offset);
+    std::span<const s32> input = GetMixBuffer(input_offset);
+    std::span<s32> output = GetMixBuffer(output_offset);

    // Biquad filter parameters
    const auto [n0, n1, n2] = params.numerator;
@@ -548,8 +560,8 @@ void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, E
        return;
    }

-    std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT> input{};
-    std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT> output{};
+    std::array<std::span<const s32>, AudioCommon::MAX_CHANNEL_COUNT> input{};
+    std::array<std::span<s32>, AudioCommon::MAX_CHANNEL_COUNT> output{};

    const auto status = params.status;
    for (s32 i = 0; i < channel_count; i++) {
@@ -584,7 +596,8 @@ void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, E
        for (s32 i = 0; i < channel_count; i++) {
            // Only copy if the buffer input and output do not match!
            if ((mix_buffer_offset + params.input[i]) != (mix_buffer_offset + params.output[i])) {
-                std::memcpy(output[i], input[i], worker_params.sample_count * sizeof(s32));
+                std::memcpy(output[i].data(), input[i].data(),
+                            worker_params.sample_count * sizeof(s32));
            }
        }
    }
@@ -600,8 +613,8 @@ void CommandGenerator::GenerateBiquadFilterEffectCommand(s32 mix_buffer_offset,
    for (s32 i = 0; i < channel_count; i++) {
        // TODO(ogniK): Actually implement biquad filter
        if (params.input[i] != params.output[i]) {
-            const auto* input = GetMixBuffer(mix_buffer_offset + params.input[i]);
-            auto* output = GetMixBuffer(mix_buffer_offset + params.output[i]);
+            std::span<const s32> input = GetMixBuffer(mix_buffer_offset + params.input[i]);
+            std::span<s32> output = GetMixBuffer(mix_buffer_offset + params.output[i]);
            ApplyMix<1>(output, input, 32768, worker_params.sample_count);
        }
    }
@@ -640,14 +653,15 @@ void CommandGenerator::GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* inf

                if (samples_read != static_cast<int>(worker_params.sample_count) &&
                    samples_read <= params.sample_count) {
-                    std::memset(GetMixBuffer(output_index), 0, params.sample_count - samples_read);
+                    std::memset(GetMixBuffer(output_index).data(), 0,
+                                params.sample_count - samples_read);
                }
            } else {
                AuxInfoDSP empty{};
                memory.WriteBlock(aux->GetSendInfo(), &empty, sizeof(AuxInfoDSP));
                memory.WriteBlock(aux->GetRecvInfo(), &empty, sizeof(AuxInfoDSP));
                if (output_index != input_index) {
-                    std::memcpy(GetMixBuffer(output_index), GetMixBuffer(input_index),
+                    std::memcpy(GetMixBuffer(output_index).data(), GetMixBuffer(input_index).data(),
                                worker_params.sample_count * sizeof(s32));
                }
            }
@@ -665,7 +679,7 @@ ServerSplitterDestinationData* CommandGenerator::GetDestinationData(s32 splitter
 }

 s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples,
-                                     const s32* data, u32 sample_count, u32 write_offset,
+                                     std::span<const s32> data, u32 sample_count, u32 write_offset,
                                     u32 write_count) {
    if (max_samples == 0) {
        return 0;
@@ -675,14 +689,14 @@ s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u3
        return 0;
    }

-    std::size_t data_offset{};
+    s32 data_offset{};
    u32 remaining = sample_count;
    while (remaining > 0) {
        // Get position in buffer
        const auto base = send_buffer + (offset * sizeof(u32));
        const auto samples_to_grab = std::min(max_samples - offset, remaining);
        // Write to output
-        memory.WriteBlock(base, (data + data_offset), samples_to_grab * sizeof(u32));
+        memory.WriteBlock(base, (data.data() + data_offset), samples_to_grab * sizeof(u32));
        offset = (offset + samples_to_grab) % max_samples;
        remaining -= samples_to_grab;
        data_offset += samples_to_grab;
@@ -695,7 +709,7 @@ s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u3
 }

 s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples,
-                                    s32* out_data, u32 sample_count, u32 read_offset,
+                                    std::span<s32> out_data, u32 sample_count, u32 read_offset,
                                    u32 read_count) {
    if (max_samples == 0) {
        return 0;
@@ -707,15 +721,16 @@ s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u3
    }

    u32 remaining = sample_count;
+    s32 data_offset{};
    while (remaining > 0) {
        const auto base = recv_buffer + (offset * sizeof(u32));
        const auto samples_to_grab = std::min(max_samples - offset, remaining);
        std::vector<s32> buffer(samples_to_grab);
        memory.ReadBlock(base, buffer.data(), buffer.size() * sizeof(u32));
-        std::memcpy(out_data, buffer.data(), buffer.size() * sizeof(u32));
-        out_data += samples_to_grab;
+        std::memcpy(out_data.data() + data_offset, buffer.data(), buffer.size() * sizeof(u32));
        offset = (offset + samples_to_grab) % max_samples;
        remaining -= samples_to_grab;
+        data_offset += samples_to_grab;
    }

    if (read_count != 0) {
@@ -795,7 +810,7 @@ void CommandGenerator::UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbSta
        state.lowpass_1 = 0.0f;
    } else {
        const auto a = 1.0f - hf_gain;
-        const auto b = 2.0f * (1.0f - hf_gain * CosD(256.0f * info.hf_reference /
+        const auto b = 2.0f * (2.0f - hf_gain * CosD(256.0f * info.hf_reference /
                                                     static_cast<f32>(info.sample_rate)));
        const auto c = std::sqrt(b * b - 4.0f * a * a);

@@ -843,7 +858,7 @@ void CommandGenerator::UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbSta
    }

    const auto max_early_delay = state.early_delay_line.GetMaxDelay();
-    const auto reflection_time = 1000.0f * (0.0098f * info.reverb_delay + 0.02f);
+    const auto reflection_time = 1000.0f * (0.9998f * info.reverb_delay + 0.02f);
    for (std::size_t tap = 0; tap < AudioCommon::I3DL2REVERB_TAPS; tap++) {
        const auto length = AudioCommon::CalculateDelaySamples(
            sample_rate, 1000.0f * info.reflection_delay + reflection_time * EARLY_TAP_TIMES[tap]);
@@ -962,8 +977,8 @@ void CommandGenerator::GenerateMixCommand(std::size_t output_offset, std::size_t
                  node_id, input_offset, output_offset, volume);
    }

-    auto* output = GetMixBuffer(output_offset);
-    const auto* input = GetMixBuffer(input_offset);
+    std::span<s32> output = GetMixBuffer(output_offset);
+    std::span<const s32> input = GetMixBuffer(input_offset);

    const s32 gain = static_cast<s32>(volume * 32768.0f);
    // Mix with loop unrolling
@@ -1004,7 +1019,8 @@ void CommandGenerator::GenerateFinalMixCommand() {
 }

 s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                  s32 sample_count, s32 channel, std::size_t mix_offset) {
+                                  s32 sample_start_offset, s32 sample_end_offset, s32 sample_count,
+                                  s32 channel, std::size_t mix_offset) {
    const auto& in_params = voice_info.GetInParams();
    const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
    if (wave_buffer.buffer_address == 0) {
@@ -1013,14 +1029,12 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    if (wave_buffer.buffer_size == 0) {
        return 0;
    }
-    if (wave_buffer.end_sample_offset < wave_buffer.start_sample_offset) {
+    if (sample_end_offset < sample_start_offset) {
        return 0;
    }
-    const auto samples_remaining =
-        (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) - dsp_state.offset;
+    const auto samples_remaining = (sample_end_offset - sample_start_offset) - dsp_state.offset;
    const auto start_offset =
-        ((wave_buffer.start_sample_offset + dsp_state.offset) * in_params.channel_count) *
-        sizeof(s16);
+        ((dsp_state.offset + sample_start_offset) * in_params.channel_count) * sizeof(s16);
    const auto buffer_pos = wave_buffer.buffer_address + start_offset;
    const auto samples_processed = std::min(sample_count, samples_remaining);

@@ -1044,8 +1058,8 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
 }

 s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                  s32 sample_count, [[maybe_unused]] s32 channel,
-                                  std::size_t mix_offset) {
+                                  s32 sample_start_offset, s32 sample_end_offset, s32 sample_count,
+                                  [[maybe_unused]] s32 channel, std::size_t mix_offset) {
    const auto& in_params = voice_info.GetInParams();
    const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
    if (wave_buffer.buffer_address == 0) {
@@ -1054,7 +1068,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    if (wave_buffer.buffer_size == 0) {
        return 0;
    }
-    if (wave_buffer.end_sample_offset < wave_buffer.start_sample_offset) {
+    if (sample_end_offset < sample_start_offset) {
        return 0;
    }

@@ -1079,10 +1093,9 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    s32 coef1 = coeffs[idx * 2];
    s32 coef2 = coeffs[idx * 2 + 1];

-    const auto samples_remaining =
-        (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) - dsp_state.offset;
+    const auto samples_remaining = (sample_end_offset - sample_start_offset) - dsp_state.offset;
    const auto samples_processed = std::min(sample_count, samples_remaining);
-    const auto sample_pos = wave_buffer.start_sample_offset + dsp_state.offset;
+    const auto sample_pos = dsp_state.offset + sample_start_offset;

    const auto samples_remaining_in_frame = sample_pos % SAMPLES_PER_FRAME;
    auto position_in_frame = ((sample_pos / SAMPLES_PER_FRAME) * NIBBLES_PER_SAMPLE) +
@@ -1157,12 +1170,14 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    return samples_processed;
 }

-s32* CommandGenerator::GetMixBuffer(std::size_t index) {
-    return mix_buffer.data() + (index * worker_params.sample_count);
+std::span<s32> CommandGenerator::GetMixBuffer(std::size_t index) {
+    return std::span<s32>(mix_buffer.data() + (index * worker_params.sample_count),
+                          worker_params.sample_count);
 }

-const s32* CommandGenerator::GetMixBuffer(std::size_t index) const {
-    return mix_buffer.data() + (index * worker_params.sample_count);
+std::span<const s32> CommandGenerator::GetMixBuffer(std::size_t index) const {
+    return std::span<const s32>(mix_buffer.data() + (index * worker_params.sample_count),
+                                worker_params.sample_count);
 }

 std::size_t CommandGenerator::GetMixChannelBufferOffset(s32 channel) const {
@@ -1173,15 +1188,15 @@ std::size_t CommandGenerator::GetTotalMixBufferCount() const {
    return worker_params.mix_buffer_count + AudioCommon::MAX_CHANNEL_COUNT;
 }

-s32* CommandGenerator::GetChannelMixBuffer(s32 channel) {
+std::span<s32> CommandGenerator::GetChannelMixBuffer(s32 channel) {
    return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }

-const s32* CommandGenerator::GetChannelMixBuffer(s32 channel) const {
+std::span<const s32> CommandGenerator::GetChannelMixBuffer(s32 channel) const {
    return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }

-void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* output,
+void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::span<s32> output,
                                             VoiceState& dsp_state, s32 channel,
                                             s32 target_sample_rate, s32 sample_count,
                                             s32 node_id) {
@@ -1193,7 +1208,7 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
                  node_id, channel, in_params.sample_format, sample_count, in_params.sample_rate,
                  in_params.mix_id, in_params.splitter_info_id);
    }
-    ASSERT_OR_EXECUTE(output != nullptr, { return; });
+    ASSERT_OR_EXECUTE(output.data() != nullptr, { return; });

    const auto resample_rate = static_cast<s32>(
        static_cast<float>(in_params.sample_rate) / static_cast<float>(target_sample_rate) *
@@ -1210,9 +1225,9 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
    }

    std::size_t temp_mix_offset{};
-    bool is_buffer_completed{false};
+    s32 samples_output{};
    auto samples_remaining = sample_count;
-    while (samples_remaining > 0 && !is_buffer_completed) {
+    while (samples_remaining > 0) {
        const auto samples_to_output = std::min(samples_remaining, min_required_samples);
        const auto samples_to_read = (samples_to_output * resample_rate + dsp_state.fraction) >> 15;

@@ -1229,24 +1244,38 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
            const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
            // No more data can be read
            if (!dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index]) {
-                is_buffer_completed = true;
                break;
            }

            if (in_params.sample_format == SampleFormat::Adpcm && dsp_state.offset == 0 &&
                wave_buffer.context_address != 0 && wave_buffer.context_size != 0) {
-                // TODO(ogniK): ADPCM loop context
+                memory.ReadBlock(wave_buffer.context_address, &dsp_state.context,
+                                 sizeof(ADPCMContext));
+            }
+
+            s32 samples_offset_start;
+            s32 samples_offset_end;
+            if (dsp_state.loop_count > 0 && wave_buffer.loop_start_sample != 0 &&
+                wave_buffer.loop_end_sample != 0 &&
+                wave_buffer.loop_start_sample <= wave_buffer.loop_end_sample) {
+                samples_offset_start = wave_buffer.loop_start_sample;
+                samples_offset_end = wave_buffer.loop_end_sample;
+            } else {
+                samples_offset_start = wave_buffer.start_sample_offset;
+                samples_offset_end = wave_buffer.end_sample_offset;
            }

            s32 samples_decoded{0};
            switch (in_params.sample_format) {
            case SampleFormat::Pcm16:
-                samples_decoded = DecodePcm16(voice_info, dsp_state, samples_to_read - samples_read,
-                                              channel, temp_mix_offset);
+                samples_decoded =
+                    DecodePcm16(voice_info, dsp_state, samples_offset_start, samples_offset_end,
+                                samples_to_read - samples_read, channel, temp_mix_offset);
                break;
            case SampleFormat::Adpcm:
-                samples_decoded = DecodeAdpcm(voice_info, dsp_state, samples_to_read - samples_read,
-                                              channel, temp_mix_offset);
+                samples_decoded =
+                    DecodeAdpcm(voice_info, dsp_state, samples_offset_start, samples_offset_end,
+                                samples_to_read - samples_read, channel, temp_mix_offset);
                break;
            default:
                UNREACHABLE_MSG("Unimplemented sample format={}", in_params.sample_format);
@@ -1257,15 +1286,19 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
            dsp_state.offset += samples_decoded;
            dsp_state.played_sample_count += samples_decoded;

-            if (dsp_state.offset >=
-                    (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) ||
+            if (dsp_state.offset >= (samples_offset_end - samples_offset_start) ||
                samples_decoded == 0) {
                // Reset our sample offset
                dsp_state.offset = 0;
                if (wave_buffer.is_looping) {
-                    if (samples_decoded == 0) {
+                    dsp_state.loop_count++;
+                    if (wave_buffer.loop_count > 0 &&
+                        (dsp_state.loop_count > wave_buffer.loop_count || samples_decoded == 0)) {
                        // End of our buffer
-                        is_buffer_completed = true;
+                        voice_info.SetWaveBufferCompleted(dsp_state, wave_buffer);
+                    }
+
+                    if (samples_decoded == 0) {
                        break;
                    }

@@ -1273,35 +1306,29 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
                        dsp_state.played_sample_count = 0;
                    }
                } else {
-
                    // Update our wave buffer states
-                    dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index] = false;
-                    dsp_state.wave_buffer_consumed++;
-                    dsp_state.wave_buffer_index =
-                        (dsp_state.wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS;
-                    if (wave_buffer.end_of_stream) {
-                        dsp_state.played_sample_count = 0;
-                    }
+                    voice_info.SetWaveBufferCompleted(dsp_state, wave_buffer);
                }
            }
        }

        if (in_params.behavior_flags.is_pitch_and_src_skipped.Value()) {
            // No need to resample
-            std::memcpy(output, sample_buffer.data(), samples_read * sizeof(s32));
+            std::memcpy(output.data() + samples_output, sample_buffer.data(),
+                        samples_read * sizeof(s32));
        } else {
            std::fill(sample_buffer.begin() + temp_mix_offset,
                      sample_buffer.begin() + temp_mix_offset + (samples_to_read - samples_read),
                      0);
-            AudioCore::Resample(output, sample_buffer.data(), resample_rate, dsp_state.fraction,
-                                samples_to_output);
+            AudioCore::Resample(output.data() + samples_output, sample_buffer.data(), resample_rate,
+                                dsp_state.fraction, samples_to_output);
            // Resample
            for (std::size_t i = 0; i < AudioCommon::MAX_SAMPLE_HISTORY; i++) {
                dsp_state.sample_history[i] = sample_buffer[samples_to_read + i];
            }
        }
-        output += samples_to_output;
        samples_remaining -= samples_to_output;
+        samples_output += samples_to_output;
    }
 }

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

 #include <array>
+#include <span>
 #include "audio_core/common.h"
 #include "audio_core/voice_context.h"
 #include "common/common_types.h"
@@ -41,10 +42,10 @@ public:
    void PreCommand();
    void PostCommand();

-    [[nodiscard]] s32* GetChannelMixBuffer(s32 channel);
-    [[nodiscard]] const s32* GetChannelMixBuffer(s32 channel) const;
-    [[nodiscard]] s32* GetMixBuffer(std::size_t index);
-    [[nodiscard]] const s32* GetMixBuffer(std::size_t index) const;
+    [[nodiscard]] std::span<s32> GetChannelMixBuffer(s32 channel);
+    [[nodiscard]] std::span<const s32> GetChannelMixBuffer(s32 channel) const;
+    [[nodiscard]] std::span<s32> GetMixBuffer(std::size_t index);
+    [[nodiscard]] std::span<const s32> GetMixBuffer(std::size_t index) const;
    [[nodiscard]] std::size_t GetMixChannelBufferOffset(s32 channel) const;

    [[nodiscard]] std::size_t GetTotalMixBufferCount() const;
@@ -77,21 +78,23 @@ private:
    void GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
    [[nodiscard]] ServerSplitterDestinationData* GetDestinationData(s32 splitter_id, s32 index);

-    s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples, const s32* data,
-                       u32 sample_count, u32 write_offset, u32 write_count);
-    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples, s32* out_data,
-                      u32 sample_count, u32 read_offset, u32 read_count);
+    s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples,
+                       std::span<const s32> data, u32 sample_count, u32 write_offset,
+                       u32 write_count);
+    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples,
+                      std::span<s32> out_data, u32 sample_count, u32 read_offset, u32 read_count);

    void InitializeI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
                               std::vector<u8>& work_buffer);
    void UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state, bool should_clear);
    // DSP Code
-    s32 DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
-                    s32 channel, std::size_t mix_offset);
-    s32 DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
-                    s32 channel, std::size_t mix_offset);
-    void DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* output, VoiceState& dsp_state,
-                               s32 channel, s32 target_sample_rate, s32 sample_count, s32 node_id);
+    s32 DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_start_offset,
+                    s32 sample_end_offset, s32 sample_count, s32 channel, std::size_t mix_offset);
+    s32 DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_start_offset,
+                    s32 sample_end_offset, s32 sample_count, s32 channel, std::size_t mix_offset);
+    void DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::span<s32> output,
+                               VoiceState& dsp_state, s32 channel, s32 target_sample_rate,
+                               s32 sample_count, s32 node_id);

    AudioCommon::AudioRendererParameter& worker_params;
    VoiceContext& voice_context;
@@ -15,7 +15,7 @@ constexpr ResultCode ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
 constexpr ResultCode ERR_SPLITTER_SORT_FAILED{ErrorModule::Audio, 43};
 } // namespace Audren

-constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '8');
+constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '9');
 constexpr std::size_t MAX_MIX_BUFFERS = 24;
 constexpr std::size_t MAX_BIQUAD_FILTERS = 2;
 constexpr std::size_t MAX_CHANNEL_COUNT = 6;
@@ -189,9 +189,6 @@ bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
        if (voice_in_params.is_new) {
            // Default our values for our voice
            voice_info.Initialize();
-            if (channel_count == 0 || channel_count > AudioCommon::MAX_CHANNEL_COUNT) {
-                continue;
-            }

            // Zero out our voice states
            for (std::size_t channel = 0; channel < channel_count; channel++) {
@@ -0,0 +1,163 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <atomic>
+#include <cstring>
+#include "audio_core/sdl2_sink.h"
+#include "audio_core/stream.h"
+#include "audio_core/time_stretch.h"
+#include "common/assert.h"
+#include "common/logging/log.h"
+//#include "common/settings.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 {
+
+class SDLSinkStream final : public SinkStream {
+public:
+    SDLSinkStream(u32 sample_rate, u32 num_channels_, const std::string& output_device)
+        : num_channels{std::min(num_channels_, 6u)}, time_stretch{sample_rate, num_channels} {
+
+        SDL_AudioSpec spec;
+        spec.freq = sample_rate;
+        spec.channels = static_cast<u8>(num_channels);
+        spec.format = AUDIO_S16SYS;
+        spec.samples = 4096;
+        spec.callback = nullptr;
+
+        SDL_AudioSpec obtained;
+        if (output_device.empty()) {
+            dev = SDL_OpenAudioDevice(nullptr, 0, &spec, &obtained, 0);
+        } else {
+            dev = SDL_OpenAudioDevice(output_device.c_str(), 0, &spec, &obtained, 0);
+        }
+
+        if (dev == 0) {
+            LOG_CRITICAL(Audio_Sink, "Error opening sdl audio device: {}", SDL_GetError());
+            return;
+        }
+
+        SDL_PauseAudioDevice(dev, 0);
+    }
+
+    ~SDLSinkStream() override {
+        if (dev == 0) {
+            return;
+        }
+
+        SDL_CloseAudioDevice(dev);
+    }
+
+    void EnqueueSamples(u32 source_num_channels, const std::vector<s16>& samples) override {
+        if (source_num_channels > num_channels) {
+            // Downsample 6 channels to 2
+            ASSERT_MSG(source_num_channels == 6, "Channel count must be 6");
+
+            std::vector<s16> buf;
+            buf.reserve(samples.size() * num_channels / source_num_channels);
+            for (std::size_t i = 0; i < samples.size(); i += source_num_channels) {
+                // Downmixing implementation taken from the ATSC standard
+                const s16 left{samples[i + 0]};
+                const s16 right{samples[i + 1]};
+                const s16 center{samples[i + 2]};
+                const s16 surround_left{samples[i + 4]};
+                const s16 surround_right{samples[i + 5]};
+                // Not used in the ATSC reference implementation
+                [[maybe_unused]] const s16 low_frequency_effects{samples[i + 3]};
+
+                constexpr s32 clev{707}; // center mixing level coefficient
+                constexpr s32 slev{707}; // surround mixing level coefficient
+
+                buf.push_back(static_cast<s16>(left + (clev * center / 1000) +
+                                               (slev * surround_left / 1000)));
+                buf.push_back(static_cast<s16>(right + (clev * center / 1000) +
+                                               (slev * surround_right / 1000)));
+            }
+            int ret = SDL_QueueAudio(dev, static_cast<const void*>(buf.data()),
+                                     static_cast<u32>(buf.size() * sizeof(s16)));
+            if (ret < 0)
+                LOG_WARNING(Audio_Sink, "Could not queue audio buffer: {}", SDL_GetError());
+            return;
+        }
+
+        int ret = SDL_QueueAudio(dev, static_cast<const void*>(samples.data()),
+                                 static_cast<u32>(samples.size() * sizeof(s16)));
+        if (ret < 0)
+            LOG_WARNING(Audio_Sink, "Could not queue audio buffer: {}", SDL_GetError());
+    }
+
+    std::size_t SamplesInQueue(u32 channel_count) const override {
+        if (dev == 0)
+            return 0;
+
+        return SDL_GetQueuedAudioSize(dev) / (channel_count * sizeof(s16));
+    }
+
+    void Flush() override {
+        should_flush = true;
+    }
+
+    u32 GetNumChannels() const {
+        return num_channels;
+    }
+
+private:
+    SDL_AudioDeviceID dev = 0;
+    u32 num_channels{};
+    std::atomic<bool> should_flush{};
+    TimeStretcher time_stretch;
+};
+
+SDLSink::SDLSink(std::string_view target_device_name) {
+    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+        if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
+            LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
+            return;
+        }
+    }
+
+    if (target_device_name != auto_device_name && !target_device_name.empty()) {
+        output_device = target_device_name;
+    } else {
+        output_device.clear();
+    }
+}
+
+SDLSink::~SDLSink() = default;
+
+SinkStream& SDLSink::AcquireSinkStream(u32 sample_rate, u32 num_channels, const std::string&) {
+    sink_streams.push_back(
+        std::make_unique<SDLSinkStream>(sample_rate, num_channels, output_device));
+    return *sink_streams.back();
+}
+
+std::vector<std::string> ListSDLSinkDevices() {
+    std::vector<std::string> device_list;
+
+    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+        if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
+            LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
+            return {};
+        }
+    }
+
+    const int device_count = SDL_GetNumAudioDevices(0);
+    for (int i = 0; i < device_count; ++i) {
+        device_list.emplace_back(SDL_GetAudioDeviceName(i, 0));
+    }
+
+    return device_list;
+}
+
+} // namespace AudioCore
@@ -0,0 +1,29 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "audio_core/sink.h"
+
+namespace AudioCore {
+
+class SDLSink final : public Sink {
+public:
+    explicit SDLSink(std::string_view device_id);
+    ~SDLSink() override;
+
+    SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels,
+                                  const std::string& name) override;
+
+private:
+    std::string output_device;
+    std::vector<SinkStreamPtr> sink_streams;
+};
+
+std::vector<std::string> ListSDLSinkDevices();
+
+} // namespace AudioCore
@@ -15,10 +15,17 @@ std::size_t SinkContext::GetCount() const {
 void SinkContext::UpdateMainSink(const SinkInfo::InParams& in) {
    ASSERT(in.type == SinkTypes::Device);

-    has_downmix_coefs = in.device.down_matrix_enabled;
-    if (has_downmix_coefs) {
+    if (in.device.down_matrix_enabled) {
        downmix_coefficients = in.device.down_matrix_coef;
+    } else {
+        downmix_coefficients = {
+            1.0f,   // front
+            0.707f, // center
+            0.0f,   // lfe
+            0.707f, // back
+        };
    }
+
    in_use = in.in_use;
    use_count = in.device.input_count;
    buffers = in.device.input;
@@ -34,10 +41,6 @@ std::vector<u8> SinkContext::OutputBuffers() const {
    return buffer_ret;
 }

-bool SinkContext::HasDownMixingCoefficients() const {
-    return has_downmix_coefs;
-}
-
 const DownmixCoefficients& SinkContext::GetDownmixCoefficients() const {
    return downmix_coefficients;
 }
@@ -4,6 +4,8 @@

 #pragma once

+#include <array>
+#include <vector>
 #include "audio_core/common.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -82,7 +84,6 @@ public:
    [[nodiscard]] bool InUse() const;
    [[nodiscard]] std::vector<u8> OutputBuffers() const;

-    [[nodiscard]] bool HasDownMixingCoefficients() const;
    [[nodiscard]] const DownmixCoefficients& GetDownmixCoefficients() const;

 private:
@@ -90,7 +91,6 @@ private:
    s32 use_count{};
    std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> buffers{};
    std::size_t sink_count{};
-    bool has_downmix_coefs{false};
    DownmixCoefficients downmix_coefficients{};
 };
 } // namespace AudioCore
@@ -11,6 +11,9 @@
 #ifdef HAVE_CUBEB
 #include "audio_core/cubeb_sink.h"
 #endif
+#ifdef HAVE_SDL2
+#include "audio_core/sdl2_sink.h"
+#endif
 #include "common/logging/log.h"

 namespace AudioCore {
@@ -35,6 +38,13 @@ constexpr SinkDetails sink_details[] = {
                    return std::make_unique<CubebSink>(device_id);
                },
                &ListCubebSinkDevices},
+#endif
+#ifdef HAVE_SDL2
+    SinkDetails{"sdl2",
+                [](std::string_view device_id) -> std::unique_ptr<Sink> {
+                    return std::make_unique<SDLSink>(device_id);
+                },
+                &ListSDLSinkDevices},
 #endif
    SinkDetails{"null",
                [](std::string_view device_id) -> std::unique_ptr<Sink> {
@@ -107,9 +107,12 @@ void Stream::PlayNextBuffer(std::chrono::nanoseconds ns_late) {
    active_buffer = queued_buffers.front();
    queued_buffers.pop();

-    VolumeAdjustSamples(active_buffer->GetSamples(), game_volume);
+    auto& samples = active_buffer->GetSamples();

-    sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
+    VolumeAdjustSamples(samples, game_volume);
+
+    sink_stream.EnqueueSamples(GetNumChannels(), samples);
+    played_samples += samples.size();

    const auto buffer_release_ns = GetBufferReleaseNS(*active_buffer);

@@ -89,6 +89,11 @@ public:
        return sample_rate;
    }

+    /// Gets the number of samples played so far
+    [[nodiscard]] u64 GetPlayedSampleCount() const {
+        return played_samples;
+    }
+
    /// Gets the number of channels
    [[nodiscard]] u32 GetNumChannels() const;

@@ -106,6 +111,7 @@ private:
    [[nodiscard]] std::chrono::nanoseconds GetBufferReleaseNS(const Buffer& buffer) const;

    u32 sample_rate;                  ///< Sample rate of the stream
+    u64 played_samples{};             ///< The current played sample count
    Format format;                    ///< Format of the stream
    float game_volume = 1.0f;         ///< The volume the game currently has set
    ReleaseCallback release_callback; ///< Buffer release callback for the stream
@@ -66,7 +66,7 @@ void ServerVoiceInfo::Initialize() {
    in_params.last_volume = 0.0f;
    in_params.biquad_filter.fill({});
    in_params.wave_buffer_count = 0;
-    in_params.wave_bufffer_head = 0;
+    in_params.wave_buffer_head = 0;
    in_params.mix_id = AudioCommon::NO_MIX;
    in_params.splitter_info_id = AudioCommon::NO_SPLITTER;
    in_params.additional_params_address = 0;
@@ -75,7 +75,7 @@ void ServerVoiceInfo::Initialize() {
    out_params.played_sample_count = 0;
    out_params.wave_buffer_consumed = 0;
    in_params.voice_drop_flag = false;
-    in_params.buffer_mapped = false;
+    in_params.buffer_mapped = true;
    in_params.wave_buffer_flush_request_count = 0;
    in_params.was_biquad_filter_enabled.fill(false);

@@ -126,7 +126,7 @@ void ServerVoiceInfo::UpdateParameters(const VoiceInfo::InParams& voice_in,
    in_params.volume = voice_in.volume;
    in_params.biquad_filter = voice_in.biquad_filter;
    in_params.wave_buffer_count = voice_in.wave_buffer_count;
-    in_params.wave_bufffer_head = voice_in.wave_buffer_head;
+    in_params.wave_buffer_head = voice_in.wave_buffer_head;
    if (behavior_info.IsFlushVoiceWaveBuffersSupported()) {
        const auto in_request_count = in_params.wave_buffer_flush_request_count;
        const auto voice_request_count = voice_in.wave_buffer_flush_request_count;
@@ -185,14 +185,16 @@ void ServerVoiceInfo::UpdateWaveBuffers(
            wave_buffer.buffer_size = 0;
            wave_buffer.context_address = 0;
            wave_buffer.context_size = 0;
+            wave_buffer.loop_start_sample = 0;
+            wave_buffer.loop_end_sample = 0;
            wave_buffer.sent_to_dsp = true;
        }

        // Mark all our wave buffers as invalid
        for (std::size_t channel = 0; channel < static_cast<std::size_t>(in_params.channel_count);
             channel++) {
-            for (auto& is_valid : voice_states[channel]->is_wave_buffer_valid) {
-                is_valid = false;
+            for (std::size_t i = 0; i < AudioCommon::MAX_WAVE_BUFFERS; ++i) {
+                voice_states[channel]->is_wave_buffer_valid[i] = false;
            }
        }
    }
@@ -211,7 +213,7 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
                                       const WaveBuffer& in_wave_buffer, SampleFormat sample_format,
                                       bool is_buffer_valid,
                                       [[maybe_unused]] BehaviorInfo& behavior_info) {
-    if (!is_buffer_valid && out_wavebuffer.sent_to_dsp) {
+    if (!is_buffer_valid && out_wavebuffer.sent_to_dsp && out_wavebuffer.buffer_address != 0) {
        out_wavebuffer.buffer_address = 0;
        out_wavebuffer.buffer_size = 0;
    }
@@ -219,11 +221,40 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
    if (!in_wave_buffer.sent_to_server || !in_params.buffer_mapped) {
        // Validate sample offset sizings
        if (sample_format == SampleFormat::Pcm16) {
-            const auto buffer_size = in_wave_buffer.buffer_size;
-            if (in_wave_buffer.start_sample_offset < 0 || in_wave_buffer.end_sample_offset < 0 ||
-                (buffer_size < (sizeof(s16) * in_wave_buffer.start_sample_offset)) ||
-                (buffer_size < (sizeof(s16) * in_wave_buffer.end_sample_offset))) {
+            const s64 buffer_size = static_cast<s64>(in_wave_buffer.buffer_size);
+            const s64 start = sizeof(s16) * in_wave_buffer.start_sample_offset;
+            const s64 end = sizeof(s16) * in_wave_buffer.end_sample_offset;
+            if (0 > start || start > buffer_size || 0 > end || end > buffer_size) {
                // TODO(ogniK): Write error info
+                LOG_ERROR(Audio,
+                          "PCM16 wavebuffer has an invalid size. Buffer has size 0x{:08X}, but "
+                          "offsets were "
+                          "{:08X} - 0x{:08X}",
+                          buffer_size, sizeof(s16) * in_wave_buffer.start_sample_offset,
+                          sizeof(s16) * in_wave_buffer.end_sample_offset);
+                return;
+            }
+        } else if (sample_format == SampleFormat::Adpcm) {
+            const s64 buffer_size = static_cast<s64>(in_wave_buffer.buffer_size);
+            const s64 start_frames = in_wave_buffer.start_sample_offset / 14;
+            const s64 start_extra = in_wave_buffer.start_sample_offset % 14 == 0
+                                        ? 0
+                                        : (in_wave_buffer.start_sample_offset % 14) / 2 + 1 +
+                                              (in_wave_buffer.start_sample_offset % 2);
+            const s64 start = start_frames * 8 + start_extra;
+            const s64 end_frames = in_wave_buffer.end_sample_offset / 14;
+            const s64 end_extra = in_wave_buffer.end_sample_offset % 14 == 0
+                                      ? 0
+                                      : (in_wave_buffer.end_sample_offset % 14) / 2 + 1 +
+                                            (in_wave_buffer.end_sample_offset % 2);
+            const s64 end = end_frames * 8 + end_extra;
+            if (in_wave_buffer.start_sample_offset < 0 || start > buffer_size ||
+                in_wave_buffer.end_sample_offset < 0 || end > buffer_size) {
+                LOG_ERROR(Audio,
+                          "ADPMC wavebuffer has an invalid size. Buffer has size 0x{:08X}, but "
+                          "offsets were "
+                          "{:08X} - 0x{:08X}",
+                          in_wave_buffer.buffer_size, start, end);
                return;
            }
        }
@@ -239,29 +270,34 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
        out_wavebuffer.buffer_size = in_wave_buffer.buffer_size;
        out_wavebuffer.context_address = in_wave_buffer.context_address;
        out_wavebuffer.context_size = in_wave_buffer.context_size;
+        out_wavebuffer.loop_start_sample = in_wave_buffer.loop_start_sample;
+        out_wavebuffer.loop_end_sample = in_wave_buffer.loop_end_sample;
        in_params.buffer_mapped =
            in_wave_buffer.buffer_address != 0 && in_wave_buffer.buffer_size != 0;
        // TODO(ogniK): Pool mapper attachment
        // TODO(ogniK): IsAdpcmLoopContextBugFixed
+        if (sample_format == SampleFormat::Adpcm && in_wave_buffer.context_address != 0 &&
+            in_wave_buffer.context_size != 0 && behavior_info.IsAdpcmLoopContextBugFixed()) {
+        } else {
+            out_wavebuffer.context_address = 0;
+            out_wavebuffer.context_size = 0;
+        }
    }
 }

 void ServerVoiceInfo::WriteOutStatus(
    VoiceInfo::OutParams& voice_out, VoiceInfo::InParams& voice_in,
    std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>& voice_states) {
-    if (voice_in.is_new) {
+    if (voice_in.is_new || in_params.is_new) {
        in_params.is_new = true;
        voice_out.wave_buffer_consumed = 0;
        voice_out.played_sample_count = 0;
        voice_out.voice_dropped = false;
-    } else if (!in_params.is_new) {
-        voice_out.wave_buffer_consumed = voice_states[0]->wave_buffer_consumed;
-        voice_out.played_sample_count = voice_states[0]->played_sample_count;
-        voice_out.voice_dropped = in_params.voice_drop_flag;
    } else {
-        voice_out.wave_buffer_consumed = 0;
-        voice_out.played_sample_count = 0;
-        voice_out.voice_dropped = false;
+        const auto& state = voice_states[0];
+        voice_out.wave_buffer_consumed = state->wave_buffer_consumed;
+        voice_out.played_sample_count = state->played_sample_count;
+        voice_out.voice_dropped = state->voice_dropped;
    }
 }

@@ -283,7 +319,8 @@ ServerVoiceInfo::OutParams& ServerVoiceInfo::GetOutParams() {

 bool ServerVoiceInfo::ShouldSkip() const {
    // TODO(ogniK): Handle unmapped wave buffers or parameters
-    return !in_params.in_use || (in_params.wave_buffer_count == 0) || in_params.voice_drop_flag;
+    return !in_params.in_use || in_params.wave_buffer_count == 0 || !in_params.buffer_mapped ||
+           in_params.voice_drop_flag;
 }

 bool ServerVoiceInfo::UpdateForCommandGeneration(VoiceContext& voice_context) {
@@ -381,7 +418,7 @@ bool ServerVoiceInfo::UpdateParametersForCommandGeneration(
 void ServerVoiceInfo::FlushWaveBuffers(
    u8 flush_count, std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>& dsp_voice_states,
    s32 channel_count) {
-    auto wave_head = in_params.wave_bufffer_head;
+    auto wave_head = in_params.wave_buffer_head;

    for (u8 i = 0; i < flush_count; i++) {
        in_params.wave_buffer[wave_head].sent_to_dsp = true;
@@ -401,6 +438,17 @@ bool ServerVoiceInfo::HasValidWaveBuffer(const VoiceState* state) const {
    return std::find(valid_wb.begin(), valid_wb.end(), true) != valid_wb.end();
 }

+void ServerVoiceInfo::SetWaveBufferCompleted(VoiceState& dsp_state,
+                                             const ServerWaveBuffer& wave_buffer) {
+    dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index] = false;
+    dsp_state.wave_buffer_consumed++;
+    dsp_state.wave_buffer_index = (dsp_state.wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS;
+    dsp_state.loop_count = 0;
+    if (wave_buffer.end_of_stream) {
+        dsp_state.played_sample_count = 0;
+    }
+}
+
 VoiceContext::VoiceContext(std::size_t voice_count_) : voice_count{voice_count_} {
    for (std::size_t i = 0; i < voice_count; i++) {
        voice_channel_resources.emplace_back(static_cast<s32>(i));
@@ -60,10 +60,12 @@ struct WaveBuffer {
    u8 is_looping{};
    u8 end_of_stream{};
    u8 sent_to_server{};
-    INSERT_PADDING_BYTES(5);
+    INSERT_PADDING_BYTES(1);
+    s32 loop_count{};
    u64 context_address{};
    u64 context_size{};
-    INSERT_PADDING_BYTES(8);
+    u32 loop_start_sample{};
+    u32 loop_end_sample{};
 };
 static_assert(sizeof(WaveBuffer) == 0x38, "WaveBuffer is an invalid size");

@@ -76,6 +78,9 @@ struct ServerWaveBuffer {
    bool end_of_stream{};
    VAddr context_address{};
    std::size_t context_size{};
+    s32 loop_count{};
+    u32 loop_start_sample{};
+    u32 loop_end_sample{};
    bool sent_to_dsp{true};
 };

@@ -108,6 +113,7 @@ struct VoiceState {
    u32 external_context_size;
    bool is_external_context_used;
    bool voice_dropped;
+    s32 loop_count;
 };

 class VoiceChannelResource {
@@ -206,7 +212,7 @@ public:
        float last_volume{};
        std::array<BiquadFilterParameter, AudioCommon::MAX_BIQUAD_FILTERS> biquad_filter{};
        s32 wave_buffer_count{};
-        s16 wave_bufffer_head{};
+        s16 wave_buffer_head{};
        INSERT_PADDING_BYTES(2);
        BehaviorFlags behavior_flags{};
        VAddr additional_params_address{};
@@ -252,6 +258,7 @@ public:
    void FlushWaveBuffers(u8 flush_count,
                          std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>& dsp_voice_states,
                          s32 channel_count);
+    void SetWaveBufferCompleted(VoiceState& dsp_state, const ServerWaveBuffer& wave_buffer);

 private:
    std::vector<s16> stored_samples;
@@ -110,7 +110,6 @@ add_library(common STATIC
    cityhash.cpp
    cityhash.h
    common_funcs.h
-    common_sizes.h
    common_types.h
    concepts.h
    div_ceil.h
@@ -134,6 +133,7 @@ add_library(common STATIC
    host_memory.cpp
    host_memory.h
    intrusive_red_black_tree.h
+    literals.h
    logging/backend.cpp
    logging/backend.h
    logging/filter.cpp
@@ -1,43 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <limits>
-
-#include "common/common_types.h"
-
-namespace Common {
-
-enum : u64 {
-    Size_1_KB = 0x400ULL,
-    Size_64_KB = 64ULL * Size_1_KB,
-    Size_128_KB = 128ULL * Size_1_KB,
-    Size_1_MB = 0x100000ULL,
-    Size_2_MB = 2ULL * Size_1_MB,
-    Size_4_MB = 4ULL * Size_1_MB,
-    Size_5_MB = 5ULL * Size_1_MB,
-    Size_14_MB = 14ULL * Size_1_MB,
-    Size_32_MB = 32ULL * Size_1_MB,
-    Size_33_MB = 33ULL * Size_1_MB,
-    Size_128_MB = 128ULL * Size_1_MB,
-    Size_448_MB = 448ULL * Size_1_MB,
-    Size_507_MB = 507ULL * Size_1_MB,
-    Size_562_MB = 562ULL * Size_1_MB,
-    Size_1554_MB = 1554ULL * Size_1_MB,
-    Size_2048_MB = 2048ULL * Size_1_MB,
-    Size_2193_MB = 2193ULL * Size_1_MB,
-    Size_3285_MB = 3285ULL * Size_1_MB,
-    Size_4916_MB = 4916ULL * Size_1_MB,
-    Size_1_GB = 0x40000000ULL,
-    Size_2_GB = 2ULL * Size_1_GB,
-    Size_4_GB = 4ULL * Size_1_GB,
-    Size_6_GB = 6ULL * Size_1_GB,
-    Size_8_GB = 8ULL * Size_1_GB,
-    Size_64_GB = 64ULL * Size_1_GB,
-    Size_512_GB = 512ULL * Size_1_GB,
-    Size_Invalid = std::numeric_limits<u64>::max(),
-};
-
-} // namespace Common
@@ -21,6 +21,8 @@ void DetachedTasks::WaitForAllTasks() {
 }

 DetachedTasks::~DetachedTasks() {
+    WaitForAllTasks();
+
    std::unique_lock lock{mutex};
    ASSERT(count == 0);
    instance = nullptr;
@@ -172,7 +172,7 @@ std::string ReadStringFromFile(const std::filesystem::path& path, FileType type)

 size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
                         std::string_view string) {
-    if (!IsFile(path)) {
+    if (Exists(path) && !IsFile(path)) {
        return 0;
    }

@@ -183,11 +183,7 @@ size_t WriteStringToFile(const std::filesystem::path& path, FileType type,

 size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
                          std::string_view string) {
-    if (!Exists(path)) {
-        return WriteStringToFile(path, type, string);
-    }
-
-    if (!IsFile(path)) {
+    if (Exists(path) && !IsFile(path)) {
        return 0;
    }

@@ -310,9 +306,9 @@ bool IOFile::Flush() const {
    errno = 0;

 #ifdef _WIN32
-    const auto flush_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
+    const auto flush_result = std::fflush(file) == 0;
 #else
-    const auto flush_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
+    const auto flush_result = std::fflush(file) == 0;
 #endif

    if (!flush_result) {
@@ -324,6 +320,28 @@ bool IOFile::Flush() const {
    return flush_result;
 }

+bool IOFile::Commit() const {
+    if (!IsOpen()) {
+        return false;
+    }
+
+    errno = 0;
+
+#ifdef _WIN32
+    const auto commit_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
+#else
+    const auto commit_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
+#endif
+
+    if (!commit_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to commit the file at path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+    }
+
+    return commit_result;
+}
+
 bool IOFile::SetSize(u64 size) const {
    if (!IsOpen()) {
        return false;
@@ -351,6 +369,9 @@ u64 IOFile::GetSize() const {
        return 0;
    }

+    // Flush any unwritten buffered data into the file prior to retrieving the file size.
+    std::fflush(file);
+
    std::error_code ec;

    const auto file_size = fs::file_size(file_path, ec);
@@ -49,7 +49,7 @@ void OpenFileStream(FileStream& file_stream, const Path& path, std::ios_base::op

 /**
 * Reads an entire file at path and returns a string of the contents read from the file.
- * If the filesystem object at path is not a file, this function returns an empty string.
+ * If the filesystem object at path is not a regular file, this function returns an empty string.
 *
 * @param path Filesystem path
 * @param type File type
@@ -71,8 +71,9 @@ template <typename Path>

 /**
 * Writes a string to a file at path and returns the number of characters successfully written.
- * If an file already exists at path, its contents will be erased.
- * If the filesystem object at path is not a file, this function returns 0.
+ * If a file already exists at path, its contents will be erased.
+ * If a file does not exist at path, it creates and opens a new empty file for writing.
+ * If the filesystem object at path exists and is not a regular file, this function returns 0.
 *
 * @param path Filesystem path
 * @param type File type
@@ -95,8 +96,8 @@ template <typename Path>

 /**
 * Appends a string to a file at path and returns the number of characters successfully written.
- * If a file does not exist at path, WriteStringToFile is called instead.
- * If the filesystem object at path is not a file, this function returns 0.
+ * If a file does not exist at path, it creates and opens a new empty file for appending.
+ * If the filesystem object at path exists and is not a regular file, this function returns 0.
 *
 * @param path Filesystem path
 * @param type File type
@@ -395,11 +396,20 @@ public:
    [[nodiscard]] size_t WriteString(std::span<const char> string) const;

    /**
-     * Flushes any unwritten buffered data into the file.
+     * Attempts to flush any unwritten buffered data into the file.
     *
     * @returns True if the flush was successful, false otherwise.
     */
-    [[nodiscard]] bool Flush() const;
+    bool Flush() const;
+
+    /**
+     * Attempts to commit the file into the disk.
+     * Note that this is an expensive operation as this forces the operating system to write
+     * the contents of the file associated with the file descriptor into the disk.
+     *
+     * @returns True if the commit was successful, false otherwise.
+     */
+    bool Commit() const;

    /**
     * Resizes the file to a given size.
@@ -135,8 +135,9 @@ std::shared_ptr<IOFile> FileOpen(const fs::path& path, FileAccessMode mode, File
        return nullptr;
    }

-    if (!IsFile(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a file",
+    if (Exists(path) && !IsFile(path)) {
+        LOG_ERROR(Common_Filesystem,
+                  "Filesystem object at path={} exists and is not a regular file",
                  PathToUTF8String(path));
        return nullptr;
    }
@@ -48,18 +48,18 @@ template <typename Path>
 *
 * Failures occur when:
 * - Input path is not valid
- * - Filesystem object at path is not a file
+ * - Filesystem object at path is not a regular file
 * - Filesystem at path is read only
 *
 * @param path Filesystem path
 *
 * @returns True if file removal succeeds or file does not exist, false otherwise.
 */
-[[nodiscard]] bool RemoveFile(const std::filesystem::path& path);
+bool RemoveFile(const std::filesystem::path& path);

 #ifdef _WIN32
 template <typename Path>
-[[nodiscard]] bool RemoveFile(const Path& path) {
+bool RemoveFile(const Path& path) {
    if constexpr (IsChar<typename Path::value_type>) {
        return RemoveFile(ToU8String(path));
    } else {
@@ -74,7 +74,7 @@ template <typename Path>
 * Failures occur when:
 * - One or both input path(s) is not valid
 * - Filesystem object at old_path does not exist
- * - Filesystem object at old_path is not a file
+ * - Filesystem object at old_path is not a regular file
 * - Filesystem object at new_path exists
 * - Filesystem at either path is read only
 *
@@ -110,8 +110,8 @@ template <typename Path1, typename Path2>
 *
 * Failures occur when:
 * - Input path is not valid
- * - Filesystem object at path is not a file
- * - The file is not opened
+ * - Filesystem object at path exists and is not a regular file
+ * - The file is not open
 *
 * @param path Filesystem path
 * @param mode File access mode
@@ -251,11 +251,11 @@ template <typename Path>
 *
 * @returns True if directory removal succeeds or directory does not exist, false otherwise.
 */
-[[nodiscard]] bool RemoveDir(const std::filesystem::path& path);
+bool RemoveDir(const std::filesystem::path& path);

 #ifdef _WIN32
 template <typename Path>
-[[nodiscard]] bool RemoveDir(const Path& path) {
+bool RemoveDir(const Path& path) {
    if constexpr (IsChar<typename Path::value_type>) {
        return RemoveDir(ToU8String(path));
    } else {
@@ -276,11 +276,11 @@ template <typename Path>
 *
 * @returns True if the directory and all of its contents are removed successfully, false otherwise.
 */
-[[nodiscard]] bool RemoveDirRecursively(const std::filesystem::path& path);
+bool RemoveDirRecursively(const std::filesystem::path& path);

 #ifdef _WIN32
 template <typename Path>
-[[nodiscard]] bool RemoveDirRecursively(const Path& path) {
+bool RemoveDirRecursively(const Path& path) {
    if constexpr (IsChar<typename Path::value_type>) {
        return RemoveDirRecursively(ToU8String(path));
    } else {
@@ -301,11 +301,11 @@ template <typename Path>
 *
 * @returns True if all of the directory's contents are removed successfully, false otherwise.
 */
-[[nodiscard]] bool RemoveDirContentsRecursively(const std::filesystem::path& path);
+bool RemoveDirContentsRecursively(const std::filesystem::path& path);

 #ifdef _WIN32
 template <typename Path>
-[[nodiscard]] bool RemoveDirContentsRecursively(const Path& path) {
+bool RemoveDirContentsRecursively(const Path& path) {
    if constexpr (IsChar<typename Path::value_type>) {
        return RemoveDirContentsRecursively(ToU8String(path));
    } else {
@@ -435,11 +435,13 @@ template <typename Path>
 #endif

 /**
- * Returns whether a filesystem object at path is a file.
+ * Returns whether a filesystem object at path is a regular file.
+ * A regular file is a file that stores text or binary data.
+ * It is not a directory, symlink, FIFO, socket, block device, or character device.
 *
 * @param path Filesystem path
 *
- * @returns True if a filesystem object at path is a file, false otherwise.
+ * @returns True if a filesystem object at path is a regular file, false otherwise.
 */
 [[nodiscard]] bool IsFile(const std::filesystem::path& path);

@@ -53,8 +53,9 @@ template <typename ContiguousContainer>
    std::string out;
    out.reserve(std::size(data) * pad_width);

+    const auto format_str = fmt::runtime(upper ? "{:02X}" : "{:02x}");
    for (const u8 c : data) {
-        out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
+        out += fmt::format(format_str, c);
    }

    return out;
@@ -34,7 +34,7 @@ constexpr size_t HugePageSize = 0x200000;

 // Manually imported for MinGW compatibility
 #ifndef MEM_RESERVE_PLACEHOLDER
-#define MEM_RESERVE_PLACEHOLDER 0x0004000
+#define MEM_RESERVE_PLACEHOLDER 0x00040000
 #endif
 #ifndef MEM_REPLACE_PLACEHOLDER
 #define MEM_REPLACE_PLACEHOLDER 0x00004000
@@ -0,0 +1,31 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace Common::Literals {
+
+constexpr u64 operator""_KiB(unsigned long long int x) {
+    return 1024ULL * x;
+}
+
+constexpr u64 operator""_MiB(unsigned long long int x) {
+    return 1024_KiB * x;
+}
+
+constexpr u64 operator""_GiB(unsigned long long int x) {
+    return 1024_MiB * x;
+}
+
+constexpr u64 operator""_TiB(unsigned long long int x) {
+    return 1024_GiB * x;
+}
+
+constexpr u64 operator""_PiB(unsigned long long int x) {
+    return 1024_TiB * x;
+}
+
+} // namespace Common::Literals
@@ -19,6 +19,8 @@
 #include "common/assert.h"
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
+#include "common/literals.h"
+
 #include "common/logging/backend.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
@@ -98,8 +100,8 @@ private:
                write_logs(entry);
            }

-            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a case
-            // where a system is repeatedly spamming logs even on close.
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
+            // case where a system is repeatedly spamming logs even on close.
            const int MAX_LOGS_TO_WRITE = filter.IsDebug() ? INT_MAX : 100;
            int logs_written = 0;
            while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
@@ -159,7 +161,7 @@ FileBackend::FileBackend(const std::filesystem::path& filename) {

    // Existence checks are done within the functions themselves.
    // We don't particularly care if these succeed or not.
-    void(FS::RemoveFile(old_filename));
+    FS::RemoveFile(old_filename);
    void(FS::RenameFile(filename, old_filename));

    file =
@@ -169,24 +171,28 @@ FileBackend::FileBackend(const std::filesystem::path& filename) {
 FileBackend::~FileBackend() = default;

 void FileBackend::Write(const Entry& entry) {
-    // prevent logs from going over the maximum size (in case its spamming and the user doesn't
-    // know)
-    constexpr std::size_t MAX_BYTES_WRITTEN = 100 * 1024 * 1024;
-    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1024 * 1024 * 1024;
-
    if (!file->IsOpen()) {
        return;
    }

-    if (Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN_EXTENDED) {
-        return;
-    } else if (!Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN) {
+    using namespace Common::Literals;
+    // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
+    constexpr std::size_t MAX_BYTES_WRITTEN = 100_MiB;
+    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1_GiB;
+
+    const bool write_limit_exceeded =
+        bytes_written > MAX_BYTES_WRITTEN_EXTENDED ||
+        (bytes_written > MAX_BYTES_WRITTEN && !Settings::values.extended_logging);
+
+    // Close the file after the write limit is exceeded.
+    if (write_limit_exceeded) {
+        file->Close();
        return;
    }

    bytes_written += file->WriteString(FormatLogMessage(entry).append(1, '\n'));
    if (entry.log_level >= Level::Error) {
-        void(file->Flush());
+        file->Flush();
    }
 }

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#pragma once
+
 #include <chrono>

 #include "common/common_types.h"
@@ -55,9 +55,11 @@ void LogSettings() {
    log_setting("Renderer_UseAsynchronousGpuEmulation",
                values.use_asynchronous_gpu_emulation.GetValue());
    log_setting("Renderer_UseNvdecEmulation", values.use_nvdec_emulation.GetValue());
+    log_setting("Renderer_AccelerateASTC", values.accelerate_astc.GetValue());
    log_setting("Renderer_UseVsync", values.use_vsync.GetValue());
    log_setting("Renderer_UseAssemblyShaders", values.use_assembly_shaders.GetValue());
    log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
+    log_setting("Renderer_UseGarbageCollection", values.use_caches_gc.GetValue());
    log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
    log_setting("Audio_OutputEngine", values.sink_id);
    log_setting("Audio_EnableAudioStretching", values.enable_audio_stretching.GetValue());
@@ -121,6 +123,7 @@ void RestoreGlobalState(bool is_powered_on) {
    values.cpu_accuracy.SetGlobal(true);
    values.cpuopt_unsafe_unfuse_fma.SetGlobal(true);
    values.cpuopt_unsafe_reduce_fp_error.SetGlobal(true);
+    values.cpuopt_unsafe_ignore_standard_fpcr.SetGlobal(true);
    values.cpuopt_unsafe_inaccurate_nan.SetGlobal(true);
    values.cpuopt_unsafe_fastmem_check.SetGlobal(true);

@@ -135,10 +138,12 @@ void RestoreGlobalState(bool is_powered_on) {
    values.gpu_accuracy.SetGlobal(true);
    values.use_asynchronous_gpu_emulation.SetGlobal(true);
    values.use_nvdec_emulation.SetGlobal(true);
+    values.accelerate_astc.SetGlobal(true);
    values.use_vsync.SetGlobal(true);
    values.use_assembly_shaders.SetGlobal(true);
    values.use_asynchronous_shaders.SetGlobal(true);
    values.use_fast_gpu_time.SetGlobal(true);
+    values.use_caches_gc.SetGlobal(true);
    values.bg_red.SetGlobal(true);
    values.bg_green.SetGlobal(true);
    values.bg_blue.SetGlobal(true);
@@ -129,6 +129,7 @@ struct Values {

    Setting<bool> cpuopt_unsafe_unfuse_fma;
    Setting<bool> cpuopt_unsafe_reduce_fp_error;
+    Setting<bool> cpuopt_unsafe_ignore_standard_fpcr;
    Setting<bool> cpuopt_unsafe_inaccurate_nan;
    Setting<bool> cpuopt_unsafe_fastmem_check;

@@ -147,10 +148,13 @@ struct Values {
    Setting<GPUAccuracy> gpu_accuracy;
    Setting<bool> use_asynchronous_gpu_emulation;
    Setting<bool> use_nvdec_emulation;
+    Setting<bool> accelerate_astc;
    Setting<bool> use_vsync;
+    Setting<bool> disable_fps_limit;
    Setting<bool> use_assembly_shaders;
    Setting<bool> use_asynchronous_shaders;
    Setting<bool> use_fast_gpu_time;
+    Setting<bool> use_caches_gc;

    Setting<float> bg_red;
    Setting<float> bg_green;
@@ -218,6 +222,7 @@ struct Values {
    std::string program_args;
    bool dump_exefs;
    bool dump_nso;
+    bool enable_fs_access_log;
    bool reporting_services;
    bool quest_flag;
    bool disable_macro_jit;
@@ -654,24 +654,19 @@ endif()

 if (MSVC)
    target_compile_options(core PRIVATE
-        /we4018 # 'expression' : signed/unsigned mismatch
-        /we4244 # 'argument' : conversion from 'type1' to 'type2', possible loss of data (floating-point)
-        /we4245 # 'conversion' : conversion from 'type1' to 'type2', signed/unsigned mismatch
+        /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
+        /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
+        /we4245 # 'conversion': conversion from 'type1' to 'type2', signed/unsigned mismatch
        /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
-        /we4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
-        /we4305 # 'context' : truncation from 'type1' to 'type2'
        /we4456 # Declaration of 'identifier' hides previous local declaration
        /we4457 # Declaration of 'identifier' hides function parameter
        /we4458 # Declaration of 'identifier' hides class member
        /we4459 # Declaration of 'identifier' hides global declaration
-        /we4715 # 'function' : not all control paths return a value
    )
 else()
    target_compile_options(core PRIVATE
        -Werror=conversion
        -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=sign-compare
        -Werror=shadow

        $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
@@ -8,6 +8,7 @@
 #include <dynarmic/interface/A32/config.h>
 #include <dynarmic/interface/A32/context.h>
 #include "common/assert.h"
+#include "common/literals.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "common/settings.h"
@@ -22,6 +23,8 @@

 namespace Core {

+using namespace Common::Literals;
+
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
    explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_)
@@ -143,8 +146,8 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
    config.wall_clock_cntpct = uses_wall_clock;

    // Code cache size
-    config.code_cache_size = 512 * 1024 * 1024;
-    config.far_code_offset = 400 * 1024 * 1024;
+    config.code_cache_size = 512_MiB;
+    config.far_code_offset = 400_MiB;

    // Safe optimizations
    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
@@ -186,6 +189,9 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
        if (Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue()) {
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
        }
+        if (Settings::values.cpuopt_unsafe_ignore_standard_fpcr.GetValue()) {
+            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
+        }
        if (Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue()) {
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
        }
@@ -7,6 +7,7 @@
 #include <dynarmic/interface/A64/a64.h>
 #include <dynarmic/interface/A64/config.h>
 #include "common/assert.h"
+#include "common/literals.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "common/settings.h"
@@ -24,6 +25,7 @@
 namespace Core {

 using Vector = Dynarmic::A64::Vector;
+using namespace Common::Literals;

 class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
@@ -184,8 +186,8 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
    config.wall_clock_cntpct = uses_wall_clock;

    // Code cache size
-    config.code_cache_size = 512 * 1024 * 1024;
-    config.far_code_offset = 400 * 1024 * 1024;
+    config.code_cache_size = 512_MiB;
+    config.far_code_offset = 400_MiB;

    // Safe optimizations
    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.

 #include <array>
+#include <atomic>
 #include <memory>
 #include <utility>

@@ -377,7 +378,7 @@ struct System::Impl {
    std::unique_ptr<Core::DeviceMemory> device_memory;
    Core::Memory::Memory memory;
    CpuManager cpu_manager;
-    bool is_powered_on = false;
+    std::atomic_bool is_powered_on{};
    bool exit_lock = false;

    Reporter reporter;
@@ -463,7 +464,7 @@ System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::st
 }

 bool System::IsPoweredOn() const {
-    return impl->is_powered_on;
+    return impl->is_powered_on.load(std::memory_order::relaxed);
 }

 void System::PrepareReschedule() {
@@ -835,7 +835,7 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
            "key_area_key_ocean_{:02X}",
            "key_area_key_system_{:02X}",
        };
-        WriteKeyToFile(category, fmt::format(kak_names.at(field2), field1), key);
+        WriteKeyToFile(category, fmt::format(fmt::runtime(kak_names.at(field2)), field1), key);
    } else if (id == S128KeyType::Master) {
        WriteKeyToFile(category, fmt::format("master_key_{:02X}", field1), key);
    } else if (id == S128KeyType::Package1) {
@@ -345,8 +345,10 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
 static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type,
                           const Service::FileSystem::FileSystemController& fs_controller) {
    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
    if ((type != ContentRecordType::Program && type != ContentRecordType::Data) ||
-        load_dir == nullptr || load_dir->GetSize() <= 0) {
+        ((load_dir == nullptr || load_dir->GetSize() <= 0) &&
+         (sdmc_load_dir == nullptr || sdmc_load_dir->GetSize() <= 0))) {
        return;
    }

@@ -356,7 +358,10 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
    }

    const auto& disabled = Settings::values.disabled_addons[title_id];
-    auto patch_dirs = load_dir->GetSubdirectories();
+    std::vector<VirtualDir> patch_dirs = load_dir->GetSubdirectories();
+    if (std::find(disabled.cbegin(), disabled.cend(), "SDMC") == disabled.cend()) {
+        patch_dirs.push_back(sdmc_load_dir);
+    }
    std::sort(patch_dirs.begin(), patch_dirs.end(),
              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });

@@ -402,7 +407,7 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
 }

 VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, ContentRecordType type,
-                                     VirtualFile update_raw) const {
+                                     VirtualFile update_raw, bool apply_layeredfs) const {
    const auto log_string = fmt::format("Patching RomFS for title_id={:016X}, type={:02X}",
                                        title_id, static_cast<u8>(type));

@@ -442,7 +447,9 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
    }

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

    return romfs;
 }
@@ -524,6 +531,15 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
        }
    }

+    // SDMC mod directory (RomFS LayeredFS)
+    const auto sdmc_mod_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
+    if (sdmc_mod_dir != nullptr && sdmc_mod_dir->GetSize() > 0 &&
+        IsDirValidAndNonEmpty(FindSubdirectoryCaseless(sdmc_mod_dir, "romfs"))) {
+        const auto mod_disabled =
+            std::find(disabled.begin(), disabled.end(), "SDMC") != disabled.end();
+        out.insert_or_assign(mod_disabled ? "[D] SDMC" : "SDMC", "LayeredFS");
+    }
+
    // DLC
    const auto dlc_entries =
        content_provider.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
@@ -64,7 +64,8 @@ public:
    // - LayeredFS
    [[nodiscard]] VirtualFile PatchRomFS(VirtualFile base, u64 ivfc_offset,
                                         ContentRecordType type = ContentRecordType::Program,
-                                         VirtualFile update_raw = nullptr) const;
+                                         VirtualFile update_raw = nullptr,
+                                         bool apply_layeredfs = true) const;

    // Returns a vector of pairs between patch names and patch versions.
    // i.e. Update 3.2.2 will return {"Update", "3.2.2"}
@@ -58,14 +58,17 @@ static bool FollowsNcaIdFormat(std::string_view name) {

 static std::string GetRelativePathFromNcaID(const std::array<u8, 16>& nca_id, bool second_hex_upper,
                                            bool within_two_digit, bool cnmt_suffix) {
-    if (!within_two_digit)
-        return fmt::format(cnmt_suffix ? "{}.cnmt.nca" : "/{}.nca",
-                           Common::HexToString(nca_id, second_hex_upper));
+    if (!within_two_digit) {
+        const auto format_str = fmt::runtime(cnmt_suffix ? "{}.cnmt.nca" : "/{}.nca");
+        return fmt::format(format_str, Common::HexToString(nca_id, second_hex_upper));
+    }

    Core::Crypto::SHA256Hash hash{};
    mbedtls_sha256_ret(nca_id.data(), nca_id.size(), hash.data(), 0);
-    return fmt::format(cnmt_suffix ? "/000000{:02X}/{}.cnmt.nca" : "/000000{:02X}/{}.nca", hash[0],
-                       Common::HexToString(nca_id, second_hex_upper));
+
+    const auto format_str =
+        fmt::runtime(cnmt_suffix ? "/000000{:02X}/{}.cnmt.nca" : "/000000{:02X}/{}.nca");
+    return fmt::format(format_str, hash[0], Common::HexToString(nca_id, second_hex_upper));
 }

 static std::string GetCNMTName(TitleType type, u64 title_id) {
@@ -12,23 +12,32 @@ namespace FileSys {

 constexpr u64 SDMC_TOTAL_SIZE = 0x10000000000; // 1 TiB

-SDMCFactory::SDMCFactory(VirtualDir dir_)
-    : dir(std::move(dir_)), contents(std::make_unique<RegisteredCache>(
-                                GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/registered"),
-                                [](const VirtualFile& file, const NcaID& id) {
-                                    return NAX{file, id}.GetDecrypted();
-                                })),
+SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
+    : sd_dir(std::move(sd_dir_)), sd_mod_dir(std::move(sd_mod_dir_)),
+      contents(std::make_unique<RegisteredCache>(
+          GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Contents/registered"),
+          [](const VirtualFile& file, const NcaID& id) {
+              return NAX{file, id}.GetDecrypted();
+          })),
      placeholder(std::make_unique<PlaceholderCache>(
-          GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/placehld"))) {}
+          GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Contents/placehld"))) {}

 SDMCFactory::~SDMCFactory() = default;

 ResultVal<VirtualDir> SDMCFactory::Open() const {
-    return MakeResult<VirtualDir>(dir);
+    return MakeResult<VirtualDir>(sd_dir);
+}
+
+VirtualDir SDMCFactory::GetSDMCModificationLoadRoot(u64 title_id) const {
+    // LayeredFS doesn't work on updates and title id-less homebrew
+    if (title_id == 0 || (title_id & 0xFFF) == 0x800) {
+        return nullptr;
+    }
+    return GetOrCreateDirectoryRelative(sd_mod_dir, fmt::format("/{:016X}", title_id));
 }

 VirtualDir SDMCFactory::GetSDMCContentDirectory() const {
-    return GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents");
+    return GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Contents");
 }

 RegisteredCache* SDMCFactory::GetSDMCContents() const {
@@ -40,11 +49,11 @@ PlaceholderCache* SDMCFactory::GetSDMCPlaceholder() const {
 }

 VirtualDir SDMCFactory::GetImageDirectory() const {
-    return GetOrCreateDirectoryRelative(dir, "/Nintendo/Album");
+    return GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Album");
 }

 u64 SDMCFactory::GetSDMCFreeSpace() const {
-    return GetSDMCTotalSpace() - dir->GetSize();
+    return GetSDMCTotalSpace() - sd_dir->GetSize();
 }

 u64 SDMCFactory::GetSDMCTotalSpace() const {
@@ -16,11 +16,12 @@ class PlaceholderCache;
 /// File system interface to the SDCard archive
 class SDMCFactory {
 public:
-    explicit SDMCFactory(VirtualDir dir);
+    explicit SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_);
    ~SDMCFactory();

    ResultVal<VirtualDir> Open() const;

+    VirtualDir GetSDMCModificationLoadRoot(u64 title_id) const;
    VirtualDir GetSDMCContentDirectory() const;

    RegisteredCache* GetSDMCContents() const;
@@ -32,7 +33,8 @@ public:
    u64 GetSDMCTotalSpace() const;

 private:
-    VirtualDir dir;
+    VirtualDir sd_dir;
+    VirtualDir sd_mod_dir;

    std::unique_ptr<RegisteredCache> contents;
    std::unique_ptr<PlaceholderCache> placeholder;
@@ -24,17 +24,12 @@ constexpr FS::FileAccessMode ModeFlagsToFileAccessMode(Mode mode) {
    case Mode::Read:
        return FS::FileAccessMode::Read;
    case Mode::Write:
-        return FS::FileAccessMode::Write;
    case Mode::ReadWrite:
-        return FS::FileAccessMode::ReadWrite;
    case Mode::Append:
-        return FS::FileAccessMode::Append;
    case Mode::ReadAppend:
-        return FS::FileAccessMode::ReadAppend;
    case Mode::WriteAppend:
-        return FS::FileAccessMode::Append;
    case Mode::All:
-        return FS::FileAccessMode::ReadAppend;
+        return FS::FileAccessMode::ReadWrite;
    default:
        return {};
    }
@@ -4,6 +4,7 @@

 #pragma once

+#include <functional>
 #include <memory>
 #include <string>
 #include <tuple>
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#pragma once
+
 #include "common/common_types.h"

 // This file contains yuzu's HLE API version constants.
@@ -345,8 +345,12 @@ public:
    explicit RequestParser(u32* command_buffer) : RequestHelperBase(command_buffer) {}

    explicit RequestParser(Kernel::HLERequestContext& ctx) : RequestHelperBase(ctx) {
-        ASSERT_MSG(ctx.GetDataPayloadOffset(), "context is incomplete");
-        Skip(ctx.GetDataPayloadOffset(), false);
+        // TIPC does not have data payload offset
+        if (!ctx.IsTipc()) {
+            ASSERT_MSG(ctx.GetDataPayloadOffset(), "context is incomplete");
+            Skip(ctx.GetDataPayloadOffset(), false);
+        }
+
        // Skip the u64 command id, it's already stored in the context
        static constexpr u32 CommandIdSize = 2;
        Skip(CommandIdSize, false);
@@ -4,7 +4,8 @@

 #include <random>

-#include "common/common_sizes.h"
+#include "common/literals.h"
+
 #include "core/hle/kernel/board/nintendo/nx/k_system_control.h"
 #include "core/hle/kernel/board/nintendo/nx/secure_monitor.h"
 #include "core/hle/kernel/k_trace.h"
@@ -25,6 +26,8 @@ constexpr const std::size_t RequiredNonSecureSystemMemorySize =

 namespace {

+using namespace Common::Literals;
+
 u32 GetMemoryModeForInit() {
    return 0x01;
 }
@@ -57,11 +60,11 @@ size_t KSystemControl::Init::GetIntendedMemorySize() {
    switch (GetMemorySizeForInit()) {
    case Smc::MemorySize_4GB:
    default: // All invalid modes should go to 4GB.
-        return Common::Size_4_GB;
+        return 4_GiB;
    case Smc::MemorySize_6GB:
-        return Common::Size_6_GB;
+        return 6_GiB;
    case Smc::MemorySize_8GB:
-        return Common::Size_8_GB;
+        return 8_GiB;
    }
 }

@@ -79,17 +82,17 @@ std::size_t KSystemControl::Init::GetApplicationPoolSize() {
        switch (GetMemoryArrangeForInit()) {
        case Smc::MemoryArrangement_4GB:
        default:
-            return Common::Size_3285_MB;
+            return 3285_MiB;
        case Smc::MemoryArrangement_4GBForAppletDev:
-            return Common::Size_2048_MB;
+            return 2048_MiB;
        case Smc::MemoryArrangement_4GBForSystemDev:
-            return Common::Size_3285_MB;
+            return 3285_MiB;
        case Smc::MemoryArrangement_6GB:
-            return Common::Size_4916_MB;
+            return 4916_MiB;
        case Smc::MemoryArrangement_6GBForAppletDev:
-            return Common::Size_3285_MB;
+            return 3285_MiB;
        case Smc::MemoryArrangement_8GB:
-            return Common::Size_4916_MB;
+            return 4916_MiB;
        }
    }();

@@ -103,22 +106,22 @@ size_t KSystemControl::Init::GetAppletPoolSize() {
        switch (GetMemoryArrangeForInit()) {
        case Smc::MemoryArrangement_4GB:
        default:
-            return Common::Size_507_MB;
+            return 507_MiB;
        case Smc::MemoryArrangement_4GBForAppletDev:
-            return Common::Size_1554_MB;
+            return 1554_MiB;
        case Smc::MemoryArrangement_4GBForSystemDev:
-            return Common::Size_448_MB;
+            return 448_MiB;
        case Smc::MemoryArrangement_6GB:
-            return Common::Size_562_MB;
+            return 562_MiB;
        case Smc::MemoryArrangement_6GBForAppletDev:
-            return Common::Size_2193_MB;
+            return 2193_MiB;
        case Smc::MemoryArrangement_8GB:
-            return Common::Size_2193_MB;
+            return 2193_MiB;
        }
    }();

    // Return (possibly) adjusted size.
-    constexpr size_t ExtraSystemMemoryForAtmosphere = Common::Size_33_MB;
+    constexpr size_t ExtraSystemMemoryForAtmosphere = 33_MiB;
    return base_pool_size - ExtraSystemMemoryForAtmosphere - KTraceBufferSize;
 }

@@ -5,34 +5,37 @@
 #include <array>

 #include "common/assert.h"
-#include "common/common_sizes.h"
+#include "common/literals.h"
 #include "core/hle/kernel/k_address_space_info.h"

 namespace Kernel {

 namespace {

+using namespace Common::Literals;
+
+constexpr u64 Size_Invalid = UINT64_MAX;
+
 // clang-format off
 constexpr std::array<KAddressSpaceInfo, 13> AddressSpaceInfos{{
-   { .bit_width = 32, .address = Common::Size_2_MB   , .size = Common::Size_1_GB   - Common::Size_2_MB  , .type = KAddressSpaceInfo::Type::MapSmall, },
-   { .bit_width = 32, .address = Common::Size_1_GB   , .size = Common::Size_4_GB   - Common::Size_1_GB  , .type = KAddressSpaceInfo::Type::MapLarge, },
-   { .bit_width = 32, .address = Common::Size_Invalid, .size = Common::Size_1_GB                        , .type = KAddressSpaceInfo::Type::Alias,    },
-   { .bit_width = 32, .address = Common::Size_Invalid, .size = Common::Size_1_GB                        , .type = KAddressSpaceInfo::Type::Heap,     },
-   { .bit_width = 36, .address = Common::Size_128_MB , .size = Common::Size_2_GB   - Common::Size_128_MB, .type = KAddressSpaceInfo::Type::MapSmall, },
-   { .bit_width = 36, .address = Common::Size_2_GB   , .size = Common::Size_64_GB  - Common::Size_2_GB  , .type = KAddressSpaceInfo::Type::MapLarge, },
-   { .bit_width = 36, .address = Common::Size_Invalid, .size = Common::Size_6_GB                        , .type = KAddressSpaceInfo::Type::Heap,     },
-   { .bit_width = 36, .address = Common::Size_Invalid, .size = Common::Size_6_GB                        , .type = KAddressSpaceInfo::Type::Alias,    },
-   { .bit_width = 39, .address = Common::Size_128_MB , .size = Common::Size_512_GB - Common::Size_128_MB, .type = KAddressSpaceInfo::Type::Map39Bit, },
-   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_64_GB                       , .type = KAddressSpaceInfo::Type::MapSmall  },
-   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_6_GB                        , .type = KAddressSpaceInfo::Type::Heap,     },
-   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_64_GB                       , .type = KAddressSpaceInfo::Type::Alias,    },
-   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_2_GB                        , .type = KAddressSpaceInfo::Type::Stack,    },
+   { .bit_width = 32, .address = 2_MiB       , .size = 1_GiB   - 2_MiB  , .type = KAddressSpaceInfo::Type::MapSmall, },
+   { .bit_width = 32, .address = 1_GiB       , .size = 4_GiB   - 1_GiB  , .type = KAddressSpaceInfo::Type::MapLarge, },
+   { .bit_width = 32, .address = Size_Invalid, .size = 1_GiB            , .type = KAddressSpaceInfo::Type::Alias,    },
+   { .bit_width = 32, .address = Size_Invalid, .size = 1_GiB            , .type = KAddressSpaceInfo::Type::Heap,     },
+   { .bit_width = 36, .address = 128_MiB     , .size = 2_GiB   - 128_MiB, .type = KAddressSpaceInfo::Type::MapSmall, },
+   { .bit_width = 36, .address = 2_GiB       , .size = 64_GiB  - 2_GiB  , .type = KAddressSpaceInfo::Type::MapLarge, },
+   { .bit_width = 36, .address = Size_Invalid, .size = 6_GiB            , .type = KAddressSpaceInfo::Type::Heap,     },
+   { .bit_width = 36, .address = Size_Invalid, .size = 6_GiB            , .type = KAddressSpaceInfo::Type::Alias,    },
+   { .bit_width = 39, .address = 128_MiB     , .size = 512_GiB - 128_MiB, .type = KAddressSpaceInfo::Type::Map39Bit, },
+   { .bit_width = 39, .address = Size_Invalid, .size = 64_GiB           , .type = KAddressSpaceInfo::Type::MapSmall  },
+   { .bit_width = 39, .address = Size_Invalid, .size = 6_GiB            , .type = KAddressSpaceInfo::Type::Heap,     },
+   { .bit_width = 39, .address = Size_Invalid, .size = 64_GiB           , .type = KAddressSpaceInfo::Type::Alias,    },
+   { .bit_width = 39, .address = Size_Invalid, .size = 2_GiB            , .type = KAddressSpaceInfo::Type::Stack,    },
 }};
 // clang-format on

 constexpr bool IsAllowedIndexForAddress(std::size_t index) {
-    return index < AddressSpaceInfos.size() &&
-           AddressSpaceInfos[index].address != Common::Size_Invalid;
+    return index < AddressSpaceInfos.size() && AddressSpaceInfos[index].address != Size_Invalid;
 }

 using IndexArray =
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.

 #include "common/alignment.h"
+#include "common/literals.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_system_control.h"
@@ -12,8 +13,10 @@ namespace Kernel {

 namespace {

+using namespace Common::Literals;
+
 constexpr size_t CarveoutAlignment = 0x20000;
-constexpr size_t CarveoutSizeMax = (512ULL * 1024 * 1024) - CarveoutAlignment;
+constexpr size_t CarveoutSizeMax = (512_MiB) - CarveoutAlignment;

 bool SetupPowerManagementControllerMemoryRegion(KMemoryLayout& memory_layout) {
    // Above firmware 2.0.0, the PMC is not mappable.
@@ -7,8 +7,7 @@
 #include <utility>

 #include "common/alignment.h"
-#include "common/common_sizes.h"
-#include "common/common_types.h"
+#include "common/literals.h"
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_memory_region.h"
 #include "core/hle/kernel/k_memory_region_type.h"
@@ -16,20 +15,22 @@

 namespace Kernel {

-constexpr std::size_t L1BlockSize = Common::Size_1_GB;
-constexpr std::size_t L2BlockSize = Common::Size_2_MB;
+using namespace Common::Literals;
+
+constexpr std::size_t L1BlockSize = 1_GiB;
+constexpr std::size_t L2BlockSize = 2_MiB;

 constexpr std::size_t GetMaximumOverheadSize(std::size_t size) {
    return (Common::DivideUp(size, L1BlockSize) + Common::DivideUp(size, L2BlockSize)) * PageSize;
 }

-constexpr std::size_t MainMemorySize = Common::Size_4_GB;
-constexpr std::size_t MainMemorySizeMax = Common::Size_8_GB;
+constexpr std::size_t MainMemorySize = 4_GiB;
+constexpr std::size_t MainMemorySizeMax = 8_GiB;

-constexpr std::size_t ReservedEarlyDramSize = 0x60000;
+constexpr std::size_t ReservedEarlyDramSize = 384_KiB;
 constexpr std::size_t DramPhysicalAddress = 0x80000000;

-constexpr std::size_t KernelAslrAlignment = Common::Size_2_MB;
+constexpr std::size_t KernelAslrAlignment = 2_MiB;
 constexpr std::size_t KernelVirtualAddressSpaceWidth = 1ULL << 39;
 constexpr std::size_t KernelPhysicalAddressSpaceWidth = 1ULL << 48;

@@ -40,7 +41,7 @@ constexpr std::size_t KernelVirtualAddressSpaceLast = KernelVirtualAddressSpaceE
 constexpr std::size_t KernelVirtualAddressSpaceSize =
    KernelVirtualAddressSpaceEnd - KernelVirtualAddressSpaceBase;
 constexpr std::size_t KernelVirtualAddressCodeBase = KernelVirtualAddressSpaceBase;
-constexpr std::size_t KernelVirtualAddressCodeSize = 0x62000;
+constexpr std::size_t KernelVirtualAddressCodeSize = 392_KiB;
 constexpr std::size_t KernelVirtualAddressCodeEnd =
    KernelVirtualAddressCodeBase + KernelVirtualAddressCodeSize;

@@ -53,14 +54,14 @@ constexpr std::size_t KernelPhysicalAddressSpaceSize =
 constexpr std::size_t KernelPhysicalAddressCodeBase = DramPhysicalAddress + ReservedEarlyDramSize;

 constexpr std::size_t KernelPageTableHeapSize = GetMaximumOverheadSize(MainMemorySizeMax);
-constexpr std::size_t KernelInitialPageHeapSize = Common::Size_128_KB;
+constexpr std::size_t KernelInitialPageHeapSize = 128_KiB;

-constexpr std::size_t KernelSlabHeapDataSize = Common::Size_5_MB;
-constexpr std::size_t KernelSlabHeapGapsSize = Common::Size_2_MB - Common::Size_64_KB;
+constexpr std::size_t KernelSlabHeapDataSize = 5_MiB;
+constexpr std::size_t KernelSlabHeapGapsSize = 2_MiB - 64_KiB;
 constexpr std::size_t KernelSlabHeapSize = KernelSlabHeapDataSize + KernelSlabHeapGapsSize;

 // NOTE: This is calculated from KThread slab counts, assuming KThread size <= 0x860.
-constexpr std::size_t KernelSlabHeapAdditionalSize = 0x68000ULL;
+constexpr std::size_t KernelSlabHeapAdditionalSize = 416_KiB;

 constexpr std::size_t KernelResourceSize =
    KernelPageTableHeapSize + KernelInitialPageHeapSize + KernelSlabHeapSize;
@@ -4,6 +4,7 @@

 #include "common/alignment.h"
 #include "common/assert.h"
+#include "common/literals.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
 #include "core/hle/kernel/k_address_space_info.h"
@@ -23,6 +24,8 @@ namespace Kernel {

 namespace {

+using namespace Common::Literals;
+
 constexpr std::size_t GetAddressSpaceWidthFromType(FileSys::ProgramAddressSpaceType as_type) {
    switch (as_type) {
    case FileSys::ProgramAddressSpaceType::Is32Bit:
@@ -89,7 +92,7 @@ ResultCode KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_
    }

    // Set code regions and determine remaining
-    constexpr std::size_t RegionAlignment{2 * 1024 * 1024};
+    constexpr std::size_t RegionAlignment{2_MiB};
    VAddr process_code_start{};
    VAddr process_code_end{};
    std::size_t stack_region_size{};
@@ -79,6 +79,7 @@ ResultCode KResourceLimit::SetLimitValue(LimitableResource which, s64 value) {
    R_UNLESS(current_values[index] <= value, ResultInvalidState);

    limit_values[index] = value;
+    peak_values[index] = current_values[index];

    return ResultSuccess;
 }
@@ -4,9 +4,13 @@

 #pragma once

+#include "common/common_funcs.h"
+
 namespace Kernel {

+using namespace Common::Literals;
+
 constexpr bool IsKTraceEnabled = false;
-constexpr std::size_t KTraceBufferSize = IsKTraceEnabled ? 16 * 1024 * 1024 : 0;
+constexpr std::size_t KTraceBufferSize = IsKTraceEnabled ? 16_MiB : 0;

 } // namespace Kernel
@@ -12,7 +12,6 @@
 #include <utility>

 #include "common/assert.h"
-#include "common/common_sizes.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/thread.h"
@@ -180,7 +179,7 @@ struct KernelCore::Impl {
        system_resource_limit->Reserve(LimitableResource::PhysicalMemory, kernel_size);

        // Reserve secure applet memory, introduced in firmware 5.0.0
-        constexpr u64 secure_applet_memory_size{Common::Size_4_MB};
+        constexpr u64 secure_applet_memory_size{4_MiB};
        ASSERT(system_resource_limit->Reserve(LimitableResource::PhysicalMemory,
                                              secure_applet_memory_size));

@@ -320,8 +319,8 @@ struct KernelCore::Impl {
        const VAddr code_end_virt_addr = KernelVirtualAddressCodeEnd;

        // Setup the containing kernel region.
-        constexpr size_t KernelRegionSize = Common::Size_1_GB;
-        constexpr size_t KernelRegionAlign = Common::Size_1_GB;
+        constexpr size_t KernelRegionSize = 1_GiB;
+        constexpr size_t KernelRegionAlign = 1_GiB;
        constexpr VAddr kernel_region_start =
            Common::AlignDown(code_start_virt_addr, KernelRegionAlign);
        size_t kernel_region_size = KernelRegionSize;
@@ -368,7 +367,7 @@ struct KernelCore::Impl {

        // Decide on the actual size for the misc region.
        constexpr size_t MiscRegionAlign = KernelAslrAlignment;
-        constexpr size_t MiscRegionMinimumSize = Common::Size_32_MB;
+        constexpr size_t MiscRegionMinimumSize = 32_MiB;
        const size_t misc_region_size = Common::AlignUp(
            std::max(misc_region_needed_size, MiscRegionMinimumSize), MiscRegionAlign);
        ASSERT(misc_region_size > 0);
@@ -381,7 +380,7 @@ struct KernelCore::Impl {
            misc_region_start, misc_region_size, KMemoryRegionType_KernelMisc));

        // Setup the stack region.
-        constexpr size_t StackRegionSize = Common::Size_14_MB;
+        constexpr size_t StackRegionSize = 14_MiB;
        constexpr size_t StackRegionAlign = KernelAslrAlignment;
        const VAddr stack_region_start =
            memory_layout.GetVirtualMemoryRegionTree().GetRandomAlignedRegion(
@@ -414,7 +413,7 @@ struct KernelCore::Impl {
            slab_region_start, slab_region_size, KMemoryRegionType_KernelSlab));

        // Setup the temp region.
-        constexpr size_t TempRegionSize = Common::Size_128_MB;
+        constexpr size_t TempRegionSize = 128_MiB;
        constexpr size_t TempRegionAlign = KernelAslrAlignment;
        const VAddr temp_region_start =
            memory_layout.GetVirtualMemoryRegionTree().GetRandomAlignedRegion(
@@ -470,7 +469,7 @@ struct KernelCore::Impl {
        // Determine size available for kernel page table heaps, requiring > 8 MB.
        const PAddr resource_end_phys_addr = slab_start_phys_addr + resource_region_size;
        const size_t page_table_heap_size = resource_end_phys_addr - slab_end_phys_addr;
-        ASSERT(page_table_heap_size / Common::Size_4_MB > 2);
+        ASSERT(page_table_heap_size / 4_MiB > 2);

        // Insert a physical region for the kernel page table heap region
        ASSERT(memory_layout.GetPhysicalMemoryRegionTree().Insert(
@@ -495,7 +494,7 @@ struct KernelCore::Impl {
        ASSERT(linear_extents.GetEndAddress() != 0);

        // Setup the linear mapping region.
-        constexpr size_t LinearRegionAlign = Common::Size_1_GB;
+        constexpr size_t LinearRegionAlign = 1_GiB;
        const PAddr aligned_linear_phys_start =
            Common::AlignDown(linear_extents.GetAddress(), LinearRegionAlign);
        const size_t linear_region_size =
@@ -117,7 +117,7 @@ AOC_U::AOC_U(Core::System& system_)
        {7, &AOC_U::PrepareAddOnContent, "PrepareAddOnContent"},
        {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
        {9, nullptr, "GetAddOnContentLostErrorCode"},
-        {10, nullptr, "GetAddOnContentListChangedEventWithProcessId"},
+        {10, &AOC_U::GetAddOnContentListChangedEventWithProcessId, "GetAddOnContentListChangedEventWithProcessId"},
        {100, &AOC_U::CreateEcPurchasedEventManager, "CreateEcPurchasedEventManager"},
        {101, &AOC_U::CreatePermanentEcPurchasedEventManager, "CreatePermanentEcPurchasedEventManager"},
        {110, nullptr, "CreateContentsServiceManager"},
@@ -257,6 +257,14 @@ void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) {
    rb.PushCopyObjects(aoc_change_event.GetReadableEvent());
 }

+void AOC_U::GetAddOnContentListChangedEventWithProcessId(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(aoc_change_event.GetReadableEvent());
+}
+
 void AOC_U::CreateEcPurchasedEventManager(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_AOC, "(STUBBED) called");

@@ -28,6 +28,7 @@ private:
    void GetAddOnContentBaseId(Kernel::HLERequestContext& ctx);
    void PrepareAddOnContent(Kernel::HLERequestContext& ctx);
    void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx);
+    void GetAddOnContentListChangedEventWithProcessId(Kernel::HLERequestContext& ctx);
    void CreateEcPurchasedEventManager(Kernel::HLERequestContext& ctx);
    void CreatePermanentEcPurchasedEventManager(Kernel::HLERequestContext& ctx);

@@ -58,7 +58,7 @@ public:
            {7, &IAudioOut::AppendAudioOutBufferImpl, "AppendAudioOutBufferAuto"},
            {8, &IAudioOut::GetReleasedAudioOutBufferImpl, "GetReleasedAudioOutBufferAuto"},
            {9, &IAudioOut::GetAudioOutBufferCount, "GetAudioOutBufferCount"},
-            {10, nullptr, "GetAudioOutPlayedSampleCount"},
+            {10, &IAudioOut::GetAudioOutPlayedSampleCount, "GetAudioOutPlayedSampleCount"},
            {11, &IAudioOut::FlushAudioOutBuffers, "FlushAudioOutBuffers"},
            {12, &IAudioOut::SetAudioOutVolume, "SetAudioOutVolume"},
            {13, &IAudioOut::GetAudioOutVolume, "GetAudioOutVolume"},
@@ -186,6 +186,14 @@ private:
        rb.Push(static_cast<u32>(stream->GetQueueSize()));
    }

+    void GetAudioOutPlayedSampleCount(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Audio, "called");
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(ResultSuccess);
+        rb.Push(stream->GetPlayedSampleCount());
+    }
+
    void FlushAudioOutBuffers(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_Audio, "called");

@@ -96,7 +96,7 @@ private:
    void RequestUpdateImpl(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_Audio, "(STUBBED) called");

-        std::vector<u8> output_params(ctx.GetWriteBufferSize());
+        std::vector<u8> output_params(ctx.GetWriteBufferSize(), 0);
        auto result = renderer->UpdateAudioRenderer(ctx.ReadBuffer(), output_params);

        if (result.IsSuccess()) {
@@ -110,17 +110,19 @@ private:
    void Start(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_Audio, "(STUBBED) called");

-        IPC::ResponseBuilder rb{ctx, 2};
+        const auto result = renderer->Start();

-        rb.Push(ResultSuccess);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
    }

    void Stop(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_Audio, "(STUBBED) called");

-        IPC::ResponseBuilder rb{ctx, 2};
+        const auto result = renderer->Stop();

-        rb.Push(ResultSuccess);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
    }

    void QuerySystemEvent(Kernel::HLERequestContext& ctx) {
@@ -288,7 +290,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        rb.Push<u32>(1);
+        rb.Push<u32>(2);
    }

    // Should be similar to QueryAudioDeviceOutputEvent
@@ -253,7 +253,11 @@ void HwOpus::GetWorkBufferSize(Kernel::HLERequestContext& ctx) {
    rb.Push<u32>(worker_buffer_sz);
 }

-void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
+void HwOpus::GetWorkBufferSizeEx(Kernel::HLERequestContext& ctx) {
+    GetWorkBufferSize(ctx);
+}
+
+void HwOpus::OpenHardwareOpusDecoder(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto sample_rate = rp.Pop<u32>();
    const auto channel_count = rp.Pop<u32>();
@@ -291,14 +295,47 @@ void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
        system, OpusDecoderState{std::move(decoder), sample_rate, channel_count});
 }

+void HwOpus::OpenHardwareOpusDecoderEx(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto sample_rate = rp.Pop<u32>();
+    const auto channel_count = rp.Pop<u32>();
+
+    LOG_CRITICAL(Audio, "called sample_rate={}, channel_count={}", sample_rate, channel_count);
+
+    ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 ||
+                   sample_rate == 12000 || sample_rate == 8000,
+               "Invalid sample rate");
+    ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
+
+    const int num_stereo_streams = channel_count == 2 ? 1 : 0;
+    const auto mapping_table = CreateMappingTable(channel_count);
+
+    int error = 0;
+    OpusDecoderPtr decoder{
+        opus_multistream_decoder_create(sample_rate, static_cast<int>(channel_count), 1,
+                                        num_stereo_streams, mapping_table.data(), &error)};
+    if (error != OPUS_OK || decoder == nullptr) {
+        LOG_ERROR(Audio, "Failed to create Opus decoder (error={}).", error);
+        IPC::ResponseBuilder rb{ctx, 2};
+        // TODO(ogniK): Use correct error code
+        rb.Push(ResultUnknown);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<IHardwareOpusDecoderManager>(
+        system, OpusDecoderState{std::move(decoder), sample_rate, channel_count});
+}
+
 HwOpus::HwOpus(Core::System& system_) : ServiceFramework{system_, "hwopus"} {
    static const FunctionInfo functions[] = {
-        {0, &HwOpus::OpenOpusDecoder, "OpenOpusDecoder"},
+        {0, &HwOpus::OpenHardwareOpusDecoder, "OpenHardwareOpusDecoder"},
        {1, &HwOpus::GetWorkBufferSize, "GetWorkBufferSize"},
        {2, nullptr, "OpenOpusDecoderForMultiStream"},
        {3, nullptr, "GetWorkBufferSizeForMultiStream"},
-        {4, nullptr, "OpenHardwareOpusDecoderEx"},
-        {5, nullptr, "GetWorkBufferSizeEx"},
+        {4, &HwOpus::OpenHardwareOpusDecoderEx, "OpenHardwareOpusDecoderEx"},
+        {5, &HwOpus::GetWorkBufferSizeEx, "GetWorkBufferSizeEx"},
        {6, nullptr, "OpenHardwareOpusDecoderForMultiStreamEx"},
        {7, nullptr, "GetWorkBufferSizeForMultiStreamEx"},
    };
@@ -18,8 +18,10 @@ public:
    ~HwOpus() override;

 private:
-    void OpenOpusDecoder(Kernel::HLERequestContext& ctx);
+    void OpenHardwareOpusDecoder(Kernel::HLERequestContext& ctx);
+    void OpenHardwareOpusDecoderEx(Kernel::HLERequestContext& ctx);
    void GetWorkBufferSize(Kernel::HLERequestContext& ctx);
+    void GetWorkBufferSizeEx(Kernel::HLERequestContext& ctx);
 };

 } // namespace Service::Audio
@@ -313,7 +313,7 @@ void SynchronizeInternal(AM::Applets::AppletManager& applet_manager, DirectoryGe
        LOG_ERROR(Service_BCAT, "Boxcat synchronization failed with error '{}'!", res);

        if (res == DownloadResult::NoMatchBuildId || res == DownloadResult::NoMatchTitleId) {
-            void(Common::FS::RemoveFile(zip_path));
+            Common::FS::RemoveFile(zip_path);
        }

        HandleDownloadDisplayResult(applet_manager, res);
@@ -445,7 +445,7 @@ std::optional<std::vector<u8>> Boxcat::GetLaunchParameter(TitleIDVersion title)
            LOG_ERROR(Service_BCAT, "Boxcat synchronization failed with error '{}'!", res);

            if (res == DownloadResult::NoMatchBuildId || res == DownloadResult::NoMatchTitleId) {
-                void(Common::FS::RemoveFile(bin_file_path));
+                Common::FS::RemoveFile(bin_file_path);
            }

            HandleDownloadDisplayResult(applet_manager, res);
@@ -703,6 +703,16 @@ FileSys::VirtualDir FileSystemController::GetModificationLoadRoot(u64 title_id)
    return bis_factory->GetModificationLoadRoot(title_id);
 }

+FileSys::VirtualDir FileSystemController::GetSDMCModificationLoadRoot(u64 title_id) const {
+    LOG_TRACE(Service_FS, "Opening SDMC mod load root for tid={:016X}", title_id);
+
+    if (sdmc_factory == nullptr) {
+        return nullptr;
+    }
+
+    return sdmc_factory->GetSDMCModificationLoadRoot(title_id);
+}
+
 FileSys::VirtualDir FileSystemController::GetModificationDumpRoot(u64 title_id) const {
    LOG_TRACE(Service_FS, "Opening mod dump root for tid={:016X}", title_id);

@@ -733,20 +743,23 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
    }

    using YuzuPath = Common::FS::YuzuPath;
+    const auto sdmc_dir_path = Common::FS::GetYuzuPath(YuzuPath::SDMCDir);
+    const auto sdmc_load_dir_path = sdmc_dir_path / "atmosphere/contents";
    const auto rw_mode = FileSys::Mode::ReadWrite;

    auto nand_directory =
        vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::NANDDir), rw_mode);
-    auto sd_directory =
-        vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::SDMCDir), rw_mode);
+    auto sd_directory = vfs.OpenDirectory(Common::FS::PathToUTF8String(sdmc_dir_path), rw_mode);
    auto load_directory =
        vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::LoadDir), FileSys::Mode::Read);
+    auto sd_load_directory =
+        vfs.OpenDirectory(Common::FS::PathToUTF8String(sdmc_load_dir_path), FileSys::Mode::Read);
    auto dump_directory =
        vfs.OpenDirectory(Common::FS::GetYuzuPathString(YuzuPath::DumpDir), rw_mode);

    if (bis_factory == nullptr) {
-        bis_factory =
-            std::make_unique<FileSys::BISFactory>(nand_directory, load_directory, dump_directory);
+        bis_factory = std::make_unique<FileSys::BISFactory>(
+            nand_directory, std::move(load_directory), std::move(dump_directory));
        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::SysNAND,
                                       bis_factory->GetSystemNANDContents());
        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::UserNAND,
@@ -759,7 +772,8 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
    }

    if (sdmc_factory == nullptr) {
-        sdmc_factory = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
+        sdmc_factory = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory),
+                                                              std::move(sd_load_directory));
        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::SDMC,
                                       sdmc_factory->GetSDMCContents());
    }
@@ -115,6 +115,7 @@ public:
    FileSys::VirtualDir GetContentDirectory(ContentStorageId id) const;
    FileSys::VirtualDir GetImageDirectory(ImageDirectoryId id) const;

+    FileSys::VirtualDir GetSDMCModificationLoadRoot(u64 title_id) const;
    FileSys::VirtualDir GetModificationLoadRoot(u64 title_id) const;
    FileSys::VirtualDir GetModificationDumpRoot(u64 title_id) const;

@@ -13,6 +13,7 @@
 #include "common/common_types.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
+#include "common/settings.h"
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/file_sys/directory.h"
@@ -785,6 +786,10 @@ FSP_SRV::FSP_SRV(Core::System& system_)
    };
    // clang-format on
    RegisterHandlers(functions);
+
+    if (Settings::values.enable_fs_access_log) {
+        access_log_mode = AccessLogMode::SdCard;
+    }
 }

 FSP_SRV::~FSP_SRV() = default;
@@ -1041,9 +1046,9 @@ void FSP_SRV::DisableAutoSaveDataCreation(Kernel::HLERequestContext& ctx) {

 void FSP_SRV::SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    log_mode = rp.PopEnum<LogMode>();
+    access_log_mode = rp.PopEnum<AccessLogMode>();

-    LOG_DEBUG(Service_FS, "called, log_mode={:08X}", log_mode);
+    LOG_DEBUG(Service_FS, "called, access_log_mode={}", access_log_mode);

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
@@ -1054,7 +1059,7 @@ void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(ResultSuccess);
-    rb.PushEnum(log_mode);
+    rb.PushEnum(access_log_mode);
 }

 void FSP_SRV::OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx) {
@@ -1062,9 +1067,9 @@ void FSP_SRV::OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx) {
    auto log = Common::StringFromFixedZeroTerminatedBuffer(
        reinterpret_cast<const char*>(raw.data()), raw.size());

-    LOG_DEBUG(Service_FS, "called, log='{}'", log);
+    LOG_DEBUG(Service_FS, "called");

-    reporter.SaveFilesystemAccessReport(log_mode, std::move(log));
+    reporter.SaveFSAccessLog(log);

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(ResultSuccess);
@@ -24,11 +24,10 @@ enum class AccessLogVersion : u32 {
    Latest = V7_0_0,
 };

-enum class LogMode : u32 {
-    Off,
+enum class AccessLogMode : u32 {
+    None,
    Log,
-    RedirectToSdCard,
-    LogToSdCard = Log | RedirectToSdCard,
+    SdCard,
 };

 class FSP_SRV final : public ServiceFramework<FSP_SRV> {
@@ -59,13 +58,12 @@ private:

    FileSystemController& fsc;
    const FileSys::ContentProvider& content_provider;
+    const Core::Reporter& reporter;

    FileSys::VirtualFile romfs;
    u64 current_process_id = 0;
    u32 access_log_program_index = 0;
-    LogMode log_mode = LogMode::LogToSdCard;
-
-    const Core::Reporter& reporter;
+    AccessLogMode access_log_mode = AccessLogMode::None;
 };

 } // namespace Service::FileSystem
@@ -314,6 +314,8 @@ void Controller_NPad::OnInit() {

 void Controller_NPad::OnLoadInputDevices() {
    const auto& players = Settings::values.players.GetValue();
+
+    std::lock_guard lock{mutex};
    for (std::size_t i = 0; i < players.size(); ++i) {
        std::transform(players[i].buttons.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
                       players[i].buttons.begin() + Settings::NativeButton::BUTTON_HID_END,
@@ -348,6 +350,8 @@ void Controller_NPad::OnRelease() {
 }

 void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
+    std::lock_guard lock{mutex};
+
    const auto controller_idx = NPadIdToIndex(npad_id);
    const auto controller_type = connected_controllers[controller_idx].type;
    if (!connected_controllers[controller_idx].is_connected) {
@@ -6,6 +6,8 @@

 #include <array>
 #include <atomic>
+#include <mutex>
+
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/quaternion.h"
@@ -563,6 +565,8 @@ private:
    using MotionArray = std::array<
        std::array<std::unique_ptr<Input::MotionDevice>, Settings::NativeMotion::NUM_MOTIONS_HID>,
        10>;
+
+    std::mutex mutex;
    ButtonArray buttons;
    StickArray sticks;
    VibrationArray vibrations;
@@ -20,6 +20,7 @@ namespace {

 constexpr ResultCode ERROR_CANNOT_FIND_ENTRY{ErrorModule::Mii, 4};

+constexpr std::size_t BaseMiiCount{2};
 constexpr std::size_t DefaultMiiCount{RawData::DefaultMii.size()};

 constexpr MiiStoreData::Name DefaultMiiName{u'y', u'u', u'z', u'u'};
@@ -415,7 +416,7 @@ u32 MiiManager::GetCount(SourceFlag source_flag) const {
        count += 0;
    }
    if ((source_flag & SourceFlag::Default) != SourceFlag::None) {
-        count += DefaultMiiCount;
+        count += (DefaultMiiCount - BaseMiiCount);
    }
    return static_cast<u32>(count);
 }
@@ -445,7 +446,7 @@ ResultVal<std::vector<MiiInfoElement>> MiiManager::GetDefault(SourceFlag source_
        return MakeResult(std::move(result));
    }

-    for (std::size_t index = 0; index < DefaultMiiCount; index++) {
+    for (std::size_t index = BaseMiiCount; index < DefaultMiiCount; index++) {
        result.emplace_back(BuildDefault(index), Source::Default);
    }

@@ -4,6 +4,8 @@

 #pragma once

+#include <array>
+#include <vector>
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/uuid.h"
@@ -307,6 +307,9 @@ void NVFlinger::Compose() {
 }

 s64 NVFlinger::GetNextTicks() const {
+    if (Settings::values.disable_fps_limit.GetValue()) {
+        return 0;
+    }
    constexpr s64 max_hertz = 120LL;
    return (1000000000 * (1LL << swap_interval)) / max_hertz;
 }
@@ -149,10 +149,10 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(Kernel::HLERequestContext
    std::string function_name = info == nullptr ? fmt::format("{}", ctx.GetCommand()) : info->name;

    fmt::memory_buffer buf;
-    fmt::format_to(buf, "function '{}': port='{}' cmd_buf={{[0]=0x{:X}", function_name,
-                   service_name, cmd_buf[0]);
+    fmt::format_to(std::back_inserter(buf), "function '{}': port='{}' cmd_buf={{[0]=0x{:X}",
+                   function_name, service_name, cmd_buf[0]);
    for (int i = 1; i <= 8; ++i) {
-        fmt::format_to(buf, ", [{}]=0x{:X}", i, cmd_buf[i]);
+        fmt::format_to(std::back_inserter(buf), ", [{}]=0x{:X}", i, cmd_buf[i]);
    }
    buf.push_back('}');

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#pragma once
+
 #include "core/hle/result.h"

 namespace Service::SPL {
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#pragma once
+
 #include <span>

 #include "common/bit_field.h"
@@ -125,7 +125,7 @@ ResultCode TimeZoneContentManager::GetTimeZoneInfoFile(const std::string& locati
        return ERROR_TIME_NOT_FOUND;
    }

-    vfs_file = zoneinfo_dir->GetFile(location_name);
+    vfs_file = zoneinfo_dir->GetFileRelative(location_name);
    if (!vfs_file) {
        LOG_ERROR(Service_Time, "{:016X} has no file \"{}\"! Using default timezone.",
                  time_zone_binary_titleid, location_name);
@@ -195,7 +195,9 @@ json GetHLERequestContextData(Kernel::HLERequestContext& ctx, Core::Memory::Memo

 namespace Core {

-Reporter::Reporter(System& system_) : system(system_) {}
+Reporter::Reporter(System& system_) : system(system_) {
+    ClearFSAccessLog();
+}

 Reporter::~Reporter() = default;

@@ -362,22 +364,12 @@ void Reporter::SaveErrorReport(u64 title_id, ResultCode result,
    SaveToFile(std::move(out), GetPath("error_report", title_id, timestamp));
 }

-void Reporter::SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
-                                          std::string log_message) const {
-    if (!IsReportingEnabled())
-        return;
+void Reporter::SaveFSAccessLog(std::string_view log_message) const {
+    const auto access_log_path =
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir) / "FsAccessLog.txt";

-    const auto timestamp = GetTimestamp();
-    const auto title_id = system.CurrentProcess()->GetTitleID();
-    json out;
-
-    out["yuzu_version"] = GetYuzuVersionData();
-    out["report_common"] = GetReportCommonData(title_id, ResultSuccess, timestamp);
-
-    out["log_mode"] = fmt::format("{:08X}", static_cast<u32>(log_mode));
-    out["log_message"] = std::move(log_message);
-
-    SaveToFile(std::move(out), GetPath("filesystem_access_report", title_id, timestamp));
+    void(Common::FS::AppendStringToFile(access_log_path, Common::FS::FileType::TextFile,
+                                        log_message));
 }

 void Reporter::SaveUserReport() const {
@@ -392,6 +384,18 @@ void Reporter::SaveUserReport() const {
               GetPath("user_report", title_id, timestamp));
 }

+void Reporter::ClearFSAccessLog() const {
+    const auto access_log_path =
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir) / "FsAccessLog.txt";
+
+    Common::FS::IOFile access_log_file{access_log_path, Common::FS::FileAccessMode::Write,
+                                       Common::FS::FileType::TextFile};
+
+    if (!access_log_file.IsOpen()) {
+        LOG_ERROR(Common_Filesystem, "Failed to clear the filesystem access log.");
+    }
+}
+
 bool Reporter::IsReportingEnabled() const {
    return Settings::values.reporting_services;
 }
@@ -16,10 +16,6 @@ namespace Kernel {
 class HLERequestContext;
 } // namespace Kernel

-namespace Service::FileSystem {
-enum class LogMode : u32;
-}
-
 namespace Service::LM {
 struct LogMessage;
 } // namespace Service::LM
@@ -69,14 +65,15 @@ public:
                         std::optional<std::string> custom_text_main = {},
                         std::optional<std::string> custom_text_detail = {}) const;

-    void SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
-                                    std::string log_message) const;
+    void SaveFSAccessLog(std::string_view log_message) const;

    // Can be used anywhere to generate a backtrace and general info report at any point during
    // execution. Not intended to be used for anything other than debugging or testing.
    void SaveUserReport() const;

 private:
+    void ClearFSAccessLog() const;
+
    bool IsReportingEnabled() const;

    System& system;
@@ -230,6 +230,7 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
             Settings::values.use_asynchronous_gpu_emulation.GetValue());
    AddField(field_type, "Renderer_UseNvdecEmulation",
             Settings::values.use_nvdec_emulation.GetValue());
+    AddField(field_type, "Renderer_AccelerateASTC", Settings::values.accelerate_astc.GetValue());
    AddField(field_type, "Renderer_UseVsync", Settings::values.use_vsync.GetValue());
    AddField(field_type, "Renderer_UseAssemblyShaders",
             Settings::values.use_assembly_shaders.GetValue());
@@ -34,28 +34,17 @@ if (MSVC)
        /W4
        /WX

-        # 'expression' : signed/unsigned mismatch
-        /we4018
-        # 'argument' : conversion from 'type1' to 'type2', possible loss of data (floating-point)
-        /we4244
-        # 'conversion' : conversion from 'type1' to 'type2', signed/unsigned mismatch
-        /we4245
-        # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
-        /we4254
-        # 'var' : conversion from 'size_t' to 'type', possible loss of data
-        /we4267
-        # 'context' : truncation from 'type1' to 'type2'
-        /we4305
+        /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
+        /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
+        /we4245 # 'conversion': conversion from 'type1' to 'type2', signed/unsigned mismatch
+        /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
    )
 else()
    target_compile_options(input_common PRIVATE
        -Werror
        -Werror=conversion
        -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=reorder
        -Werror=shadow
-        -Werror=sign-compare
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
        -Werror=unused-variable
@@ -27,6 +27,7 @@ public:
        down->SetCallback(callbacks);
        left->SetCallback(callbacks);
        right->SetCallback(callbacks);
+        modifier->SetCallback(callbacks);
    }

    bool IsAngleGreater(float old_angle, float new_angle) const {
@@ -5,14 +5,7 @@
 #include <chrono>
 #include <thread>

-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4200) // nonstandard extension used : zero-sized array in struct/union
-#endif
 #include <libusb.h>
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif

 #include "common/logging/log.h"
 #include "common/param_package.h"
@@ -2,25 +2,23 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.

+#include <stop_token>
+#include <thread>
+
 #include "common/settings.h"
 #include "input_common/mouse/mouse_input.h"

 namespace MouseInput {

 Mouse::Mouse() {
-    update_thread = std::thread(&Mouse::UpdateThread, this);
+    update_thread = std::jthread([this](std::stop_token stop_token) { UpdateThread(stop_token); });
 }

-Mouse::~Mouse() {
-    update_thread_running = false;
-    if (update_thread.joinable()) {
-        update_thread.join();
-    }
-}
+Mouse::~Mouse() = default;

-void Mouse::UpdateThread() {
+void Mouse::UpdateThread(std::stop_token stop_token) {
    constexpr int update_time = 10;
-    while (update_thread_running) {
+    while (!stop_token.stop_requested()) {
        for (MouseInfo& info : mouse_info) {
            const Common::Vec3f angular_direction{
                -info.tilt_direction.y,
@@ -6,6 +6,7 @@

 #include <array>
 #include <mutex>
+#include <stop_token>
 #include <thread>

 #include "common/common_types.h"
@@ -85,7 +86,7 @@ public:
    [[nodiscard]] const MouseData& GetMouseState(std::size_t button) const;

 private:
-    void UpdateThread();
+    void UpdateThread(std::stop_token stop_token);
    void UpdateYuzuSettings();
    void StopPanning();

@@ -105,12 +106,11 @@ private:
    u16 buttons{};
    u16 toggle_buttons{};
    u16 lock_buttons{};
-    std::thread update_thread;
+    std::jthread update_thread;
    MouseButton last_button{MouseButton::Undefined};
    std::array<MouseInfo, 7> mouse_info;
    Common::SPSCQueue<MouseStatus> mouse_queue;
    bool configuring{false};
-    bool update_thread_running{true};
    int mouse_panning_timout{};
 };
 } // namespace MouseInput
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <algorithm>
+#include <memory>
 #include <mutex>
 #include <utility>

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <algorithm>
 #include "common/settings.h"
 #include "core/frontend/framebuffer_layout.h"
 #include "input_common/touch_from_button.h"
@@ -8,14 +8,7 @@
 #include <optional>
 #include <type_traits>

-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4701)
-#endif
 #include <boost/crc.hpp>
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif

 #include "common/bit_field.h"
 #include "common/swap.h"
@@ -5,11 +5,13 @@
 #include <catch2/catch.hpp>

 #include "common/host_memory.h"
+#include "common/literals.h"

 using Common::HostMemory;
+using namespace Common::Literals;

 static constexpr size_t VIRTUAL_SIZE = 1ULL << 39;
-static constexpr size_t BACKING_SIZE = 4ULL * 1024 * 1024 * 1024;
+static constexpr size_t BACKING_SIZE = 4_GiB;

 TEST_CASE("HostMemory: Initialize and deinitialize", "[common]") {
    { HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE); }
@@ -237,6 +237,7 @@ add_library(video_core STATIC
    texture_cache/util.cpp
    texture_cache/util.h
    textures/astc.h
+    textures/astc.cpp
    textures/decoders.cpp
    textures/decoders.h
    textures/texture.cpp
@@ -291,12 +292,12 @@ endif()

 if (MSVC)
    target_compile_options(video_core PRIVATE
-        /we4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
+        /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
+        /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
        /we4456 # Declaration of 'identifier' hides previous local declaration
        /we4457 # Declaration of 'identifier' hides function parameter
        /we4458 # Declaration of 'identifier' hides class member
        /we4459 # Declaration of 'identifier' hides global declaration
-        /we4715 # 'function' : not all control paths return a value
    )
 else()
    target_compile_options(video_core PRIVATE
@@ -256,6 +256,16 @@ public:
        stream_score += score;
    }

+    /// Sets the new frame tick
+    void SetFrameTick(u64 new_frame_tick) noexcept {
+        frame_tick = new_frame_tick;
+    }
+
+    /// Returns the new frame tick
+    [[nodiscard]] u64 FrameTick() const noexcept {
+        return frame_tick;
+    }
+
    /// Returns the likeliness of this being a stream buffer
    [[nodiscard]] int StreamScore() const noexcept {
        return stream_score;
@@ -586,6 +596,7 @@ private:
    RasterizerInterface* rasterizer = nullptr;
    VAddr cpu_addr = 0;
    Words words;
+    u64 frame_tick = 0;
    BufferFlagBits flags{};
    int stream_score = 0;
 };
@@ -18,6 +18,7 @@

 #include "common/common_types.h"
 #include "common/div_ceil.h"
+#include "common/literals.h"
 #include "common/microprofile.h"
 #include "common/scope_exit.h"
 #include "common/settings.h"
@@ -47,8 +48,11 @@ constexpr u32 NUM_COMPUTE_UNIFORM_BUFFERS = 8;
 constexpr u32 NUM_STORAGE_BUFFERS = 16;
 constexpr u32 NUM_STAGES = 5;

+using namespace Common::Literals;
+
 template <typename P>
 class BufferCache {
+
    // Page size for caching purposes.
    // This is unrelated to the CPU page size and it can be changed as it seems optimal.
    static constexpr u32 PAGE_BITS = 16;
@@ -65,6 +69,9 @@ class BufferCache {

    static constexpr BufferId NULL_BUFFER_ID{0};

+    static constexpr u64 EXPECTED_MEMORY = 512_MiB;
+    static constexpr u64 CRITICAL_MEMORY = 1_GiB;
+
    using Maxwell = Tegra::Engines::Maxwell3D::Regs;

    using Runtime = typename P::Runtime;
@@ -92,7 +99,7 @@ class BufferCache {
    };

 public:
-    static constexpr u32 DEFAULT_SKIP_CACHE_SIZE = 4096;
+    static constexpr u32 DEFAULT_SKIP_CACHE_SIZE = static_cast<u32>(4_KiB);

    explicit BufferCache(VideoCore::RasterizerInterface& rasterizer_,
                         Tegra::Engines::Maxwell3D& maxwell3d_,
@@ -188,6 +195,8 @@ private:
               ((cpu_addr + size) & ~Core::Memory::PAGE_MASK);
    }

+    void RunGarbageCollector();
+
    void BindHostIndexBuffer();

    void BindHostVertexBuffers();
@@ -243,6 +252,8 @@ private:
    template <bool insert>
    void ChangeRegister(BufferId buffer_id);

+    void TouchBuffer(Buffer& buffer) const noexcept;
+
    bool SynchronizeBuffer(Buffer& buffer, VAddr cpu_addr, u32 size);

    bool SynchronizeBufferImpl(Buffer& buffer, VAddr cpu_addr, u32 size);
@@ -255,6 +266,10 @@ private:

    void MappedUploadMemory(Buffer& buffer, u64 total_size_bytes, std::span<BufferCopy> copies);

+    void DownloadBufferMemory(Buffer& buffer_id);
+
+    void DownloadBufferMemory(Buffer& buffer_id, VAddr cpu_addr, u64 size);
+
    void DeleteBuffer(BufferId buffer_id);

    void ReplaceBufferDownloads(BufferId old_buffer_id, BufferId new_buffer_id);
@@ -319,6 +334,10 @@ private:
    size_t immediate_buffer_capacity = 0;
    std::unique_ptr<u8[]> immediate_buffer_alloc;

+    typename SlotVector<Buffer>::Iterator deletion_iterator;
+    u64 frame_tick = 0;
+    u64 total_used_memory = 0;
+
    std::array<BufferId, ((1ULL << 39) >> PAGE_BITS)> page_table;
 };

@@ -332,6 +351,28 @@ BufferCache<P>::BufferCache(VideoCore::RasterizerInterface& rasterizer_,
      gpu_memory{gpu_memory_}, cpu_memory{cpu_memory_}, runtime{runtime_} {
    // Ensure the first slot is used for the null buffer
    void(slot_buffers.insert(runtime, NullBufferParams{}));
+    deletion_iterator = slot_buffers.end();
+}
+
+template <class P>
+void BufferCache<P>::RunGarbageCollector() {
+    const bool aggressive_gc = total_used_memory >= CRITICAL_MEMORY;
+    const u64 ticks_to_destroy = aggressive_gc ? 60 : 120;
+    int num_iterations = aggressive_gc ? 64 : 32;
+    for (; num_iterations > 0; --num_iterations) {
+        if (deletion_iterator == slot_buffers.end()) {
+            deletion_iterator = slot_buffers.begin();
+        }
+        ++deletion_iterator;
+        if (deletion_iterator == slot_buffers.end()) {
+            break;
+        }
+        const auto [buffer_id, buffer] = *deletion_iterator;
+        if (buffer->FrameTick() + ticks_to_destroy < frame_tick) {
+            DownloadBufferMemory(*buffer);
+            DeleteBuffer(buffer_id);
+        }
+    }
 }

 template <class P>
@@ -349,6 +390,10 @@ void BufferCache<P>::TickFrame() {
    const bool skip_preferred = hits * 256 < shots * 251;
    uniform_buffer_skip_cache_size = skip_preferred ? DEFAULT_SKIP_CACHE_SIZE : 0;

+    if (Settings::values.use_caches_gc.GetValue() && total_used_memory >= EXPECTED_MEMORY) {
+        RunGarbageCollector();
+    }
+    ++frame_tick;
    delayed_destruction_ring.Tick();
 }

@@ -372,48 +417,7 @@ void BufferCache<P>::CachedWriteMemory(VAddr cpu_addr, u64 size) {
 template <class P>
 void BufferCache<P>::DownloadMemory(VAddr cpu_addr, u64 size) {
    ForEachBufferInRange(cpu_addr, size, [&](BufferId, Buffer& buffer) {
-        boost::container::small_vector<BufferCopy, 1> copies;
-        u64 total_size_bytes = 0;
-        u64 largest_copy = 0;
-        buffer.ForEachDownloadRange(cpu_addr, size, [&](u64 range_offset, u64 range_size) {
-            copies.push_back(BufferCopy{
-                .src_offset = range_offset,
-                .dst_offset = total_size_bytes,
-                .size = range_size,
-            });
-            total_size_bytes += range_size;
-            largest_copy = std::max(largest_copy, range_size);
-        });
-        if (total_size_bytes == 0) {
-            return;
-        }
-        MICROPROFILE_SCOPE(GPU_DownloadMemory);
-
-        if constexpr (USE_MEMORY_MAPS) {
-            auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
-            const u8* const mapped_memory = download_staging.mapped_span.data();
-            const std::span<BufferCopy> copies_span(copies.data(), copies.data() + copies.size());
-            for (BufferCopy& copy : copies) {
-                // Modify copies to have the staging offset in mind
-                copy.dst_offset += download_staging.offset;
-            }
-            runtime.CopyBuffer(download_staging.buffer, buffer, copies_span);
-            runtime.Finish();
-            for (const BufferCopy& copy : copies) {
-                const VAddr copy_cpu_addr = buffer.CpuAddr() + copy.src_offset;
-                // Undo the modified offset
-                const u64 dst_offset = copy.dst_offset - download_staging.offset;
-                const u8* copy_mapped_memory = mapped_memory + dst_offset;
-                cpu_memory.WriteBlockUnsafe(copy_cpu_addr, copy_mapped_memory, copy.size);
-            }
-        } else {
-            const std::span<u8> immediate_buffer = ImmediateBuffer(largest_copy);
-            for (const BufferCopy& copy : copies) {
-                buffer.ImmediateDownload(copy.src_offset, immediate_buffer.subspan(0, copy.size));
-                const VAddr copy_cpu_addr = buffer.CpuAddr() + copy.src_offset;
-                cpu_memory.WriteBlockUnsafe(copy_cpu_addr, immediate_buffer.data(), copy.size);
-            }
-        }
+        DownloadBufferMemory(buffer, cpu_addr, size);
    });
 }

@@ -640,6 +644,7 @@ bool BufferCache<P>::IsRegionGpuModified(VAddr addr, size_t size) {
 template <class P>
 void BufferCache<P>::BindHostIndexBuffer() {
    Buffer& buffer = slot_buffers[index_buffer.buffer_id];
+    TouchBuffer(buffer);
    const u32 offset = buffer.Offset(index_buffer.cpu_addr);
    const u32 size = index_buffer.size;
    SynchronizeBuffer(buffer, index_buffer.cpu_addr, size);
@@ -658,6 +663,7 @@ void BufferCache<P>::BindHostVertexBuffers() {
    for (u32 index = 0; index < NUM_VERTEX_BUFFERS; ++index) {
        const Binding& binding = vertex_buffers[index];
        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer);
        SynchronizeBuffer(buffer, binding.cpu_addr, binding.size);
        if (!flags[Dirty::VertexBuffer0 + index]) {
            continue;
@@ -693,6 +699,7 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
    const VAddr cpu_addr = binding.cpu_addr;
    const u32 size = binding.size;
    Buffer& buffer = slot_buffers[binding.buffer_id];
+    TouchBuffer(buffer);
    const bool use_fast_buffer = binding.buffer_id != NULL_BUFFER_ID &&
                                 size <= uniform_buffer_skip_cache_size &&
                                 !buffer.IsRegionGpuModified(cpu_addr, size);
@@ -744,6 +751,7 @@ void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
    ForEachEnabledBit(enabled_storage_buffers[stage], [&](u32 index) {
        const Binding& binding = storage_buffers[stage][index];
        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer);
        const u32 size = binding.size;
        SynchronizeBuffer(buffer, binding.cpu_addr, size);

@@ -766,6 +774,7 @@ void BufferCache<P>::BindHostTransformFeedbackBuffers() {
    for (u32 index = 0; index < NUM_TRANSFORM_FEEDBACK_BUFFERS; ++index) {
        const Binding& binding = transform_feedback_buffers[index];
        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer);
        const u32 size = binding.size;
        SynchronizeBuffer(buffer, binding.cpu_addr, size);

@@ -784,6 +793,7 @@ void BufferCache<P>::BindHostComputeUniformBuffers() {
    ForEachEnabledBit(enabled_compute_uniform_buffers, [&](u32 index) {
        const Binding& binding = compute_uniform_buffers[index];
        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer);
        const u32 size = binding.size;
        SynchronizeBuffer(buffer, binding.cpu_addr, size);

@@ -803,6 +813,7 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
    ForEachEnabledBit(enabled_compute_storage_buffers, [&](u32 index) {
        const Binding& binding = compute_storage_buffers[index];
        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer);
        const u32 size = binding.size;
        SynchronizeBuffer(buffer, binding.cpu_addr, size);

@@ -1101,6 +1112,7 @@ BufferId BufferCache<P>::CreateBuffer(VAddr cpu_addr, u32 wanted_size) {
    const OverlapResult overlap = ResolveOverlaps(cpu_addr, wanted_size);
    const u32 size = static_cast<u32>(overlap.end - overlap.begin);
    const BufferId new_buffer_id = slot_buffers.insert(runtime, rasterizer, overlap.begin, size);
+    TouchBuffer(slot_buffers[new_buffer_id]);
    for (const BufferId overlap_id : overlap.ids) {
        JoinOverlap(new_buffer_id, overlap_id, !overlap.has_stream_leap);
    }
@@ -1122,8 +1134,14 @@ template <class P>
 template <bool insert>
 void BufferCache<P>::ChangeRegister(BufferId buffer_id) {
    const Buffer& buffer = slot_buffers[buffer_id];
+    const auto size = buffer.SizeBytes();
+    if (insert) {
+        total_used_memory += Common::AlignUp(size, 1024);
+    } else {
+        total_used_memory -= Common::AlignUp(size, 1024);
+    }
    const VAddr cpu_addr_begin = buffer.CpuAddr();
-    const VAddr cpu_addr_end = cpu_addr_begin + buffer.SizeBytes();
+    const VAddr cpu_addr_end = cpu_addr_begin + size;
    const u64 page_begin = cpu_addr_begin / PAGE_SIZE;
    const u64 page_end = Common::DivCeil(cpu_addr_end, PAGE_SIZE);
    for (u64 page = page_begin; page != page_end; ++page) {
@@ -1135,6 +1153,11 @@ void BufferCache<P>::ChangeRegister(BufferId buffer_id) {
    }
 }

+template <class P>
+void BufferCache<P>::TouchBuffer(Buffer& buffer) const noexcept {
+    buffer.SetFrameTick(frame_tick);
+}
+
 template <class P>
 bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, VAddr cpu_addr, u32 size) {
    if (buffer.CpuAddr() == 0) {
@@ -1211,6 +1234,57 @@ void BufferCache<P>::MappedUploadMemory(Buffer& buffer, u64 total_size_bytes,
    runtime.CopyBuffer(buffer, upload_staging.buffer, copies);
 }

+template <class P>
+void BufferCache<P>::DownloadBufferMemory(Buffer& buffer) {
+    DownloadBufferMemory(buffer, buffer.CpuAddr(), buffer.SizeBytes());
+}
+
+template <class P>
+void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, VAddr cpu_addr, u64 size) {
+    boost::container::small_vector<BufferCopy, 1> copies;
+    u64 total_size_bytes = 0;
+    u64 largest_copy = 0;
+    buffer.ForEachDownloadRange(cpu_addr, size, [&](u64 range_offset, u64 range_size) {
+        copies.push_back(BufferCopy{
+            .src_offset = range_offset,
+            .dst_offset = total_size_bytes,
+            .size = range_size,
+        });
+        total_size_bytes += range_size;
+        largest_copy = std::max(largest_copy, range_size);
+    });
+    if (total_size_bytes == 0) {
+        return;
+    }
+    MICROPROFILE_SCOPE(GPU_DownloadMemory);
+
+    if constexpr (USE_MEMORY_MAPS) {
+        auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
+        const u8* const mapped_memory = download_staging.mapped_span.data();
+        const std::span<BufferCopy> copies_span(copies.data(), copies.data() + copies.size());
+        for (BufferCopy& copy : copies) {
+            // Modify copies to have the staging offset in mind
+            copy.dst_offset += download_staging.offset;
+        }
+        runtime.CopyBuffer(download_staging.buffer, buffer, copies_span);
+        runtime.Finish();
+        for (const BufferCopy& copy : copies) {
+            const VAddr copy_cpu_addr = buffer.CpuAddr() + copy.src_offset;
+            // Undo the modified offset
+            const u64 dst_offset = copy.dst_offset - download_staging.offset;
+            const u8* copy_mapped_memory = mapped_memory + dst_offset;
+            cpu_memory.WriteBlockUnsafe(copy_cpu_addr, copy_mapped_memory, copy.size);
+        }
+    } else {
+        const std::span<u8> immediate_buffer = ImmediateBuffer(largest_copy);
+        for (const BufferCopy& copy : copies) {
+            buffer.ImmediateDownload(copy.src_offset, immediate_buffer.subspan(0, copy.size));
+            const VAddr copy_cpu_addr = buffer.CpuAddr() + copy.src_offset;
+            cpu_memory.WriteBlockUnsafe(copy_cpu_addr, immediate_buffer.data(), copy.size);
+        }
+    }
+}
+
 template <class P>
 void BufferCache<P>::DeleteBuffer(BufferId buffer_id) {
    const auto scalar_replace = [buffer_id](Binding& binding) {
@@ -1236,6 +1310,7 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id) {

    Unregister(buffer_id);
    delayed_destruction_ring.Push(std::move(slot_buffers[buffer_id]));
+    slot_buffers.erase(buffer_id);

    NotifyBufferDeletion();
 }
@@ -103,8 +103,7 @@ void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
        case ThiMethod::SetMethod1:
            LOG_DEBUG(Service_NVDRV, "NVDEC method 0x{:X}",
                      static_cast<u32>(nvdec_thi_state.method_0));
-            nvdec_processor->ProcessMethod(static_cast<Nvdec::Method>(nvdec_thi_state.method_0),
-                                           data);
+            nvdec_processor->ProcessMethod(nvdec_thi_state.method_0, data);
            break;
        default:
            break;
--- a/Show More
+++ b/Show More