reporter: Pass by const reference where applicable

Same behavior, but without memory churn.
reporter: Eliminate undefined behavior in SaveErrorReport
2022-12-05 21:48:42 -05:00 · 2022-12-05 21:31:34 -05:00 · 2022-12-05 12:26:09 -05:00 · 2022-12-05 12:25:46 -05:00 · 2022-12-05 12:33:12 +01:00 · 2022-12-04 22:30:16 +00:00
295 changed files with 26096 additions and 15732 deletions
@@ -19,6 +19,7 @@ cmake .. \
      -DENABLE_QT_TRANSLATION=ON \
      -DUSE_DISCORD_PRESENCE=ON \
      -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
+      -DYUZU_USE_BUNDLED_FFMPEG=ON \
      -GNinja

 ninja
@@ -27,7 +27,7 @@
    url = https://github.com/KhronosGroup/Vulkan-Headers.git
 [submodule "sirit"]
    path = externals/sirit
-    url = https://github.com/ReinUsesLisp/sirit
+    url = https://github.com/yuzu-emu/sirit
 [submodule "mbedtls"]
    path = externals/mbedtls
    url = https://github.com/yuzu-emu/mbedtls
@@ -1,7 +1,11 @@
 # SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later

-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.22)
+
+# Dynarmic has cmake_minimum_required(3.12) and we may want to override
+# some of its variables, which is only possible in 3.13+
+set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
@@ -19,6 +23,9 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON
 CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)

 option(ENABLE_QT "Enable the Qt frontend" ON)
+option(ENABLE_QT6 "Allow usage of Qt6 to be attempted" OFF)
+set(QT6_LOCATION "" CACHE PATH "Additional Location to search for Qt6 libraries like C:/Qt/6.3.1/msvc2019_64/")
+
 option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSVC}" "ENABLE_QT" OFF)

@@ -28,16 +35,18 @@ option(YUZU_USE_BUNDLED_LIBUSB "Compile bundled libusb" OFF)

 option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")

+option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)
+
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)

 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)

 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)

-option(YUZU_USE_BUNDLED_OPUS "Compile bundled opus" ON)
-
 option(YUZU_TESTS "Compile tests" ON)

+option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)
+
 CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile Windows crash dump (Minidump) support" OFF "WIN32" OFF)

 option(YUZU_USE_BUNDLED_VCPKG "Use vcpkg for yuzu dependencies" "${MSVC}")
@@ -59,6 +68,21 @@ elseif(NOT "$ENV{VCPKG_TOOLCHAIN_FILE}" STREQUAL "")
    include("$ENV{VCPKG_TOOLCHAIN_FILE}")
 endif()

+if (YUZU_USE_PRECOMPILED_HEADERS)
+    if (MSVC AND CCACHE)
+        # buildcache does not properly cache PCH files, leading to compilation errors.
+        # See https://github.com/mbitsnbites/buildcache/discussions/230
+        message(WARNING "buildcache does not properly support Precompiled Headers. Disabling PCH")
+        set(DYNARMIC_USE_PRECOMPILED_HEADERS OFF CACHE BOOL "" FORCE)
+        set(YUZU_USE_PRECOMPILED_HEADERS OFF CACHE BOOL "" FORCE)
+    endif()
+endif()
+if (YUZU_USE_PRECOMPILED_HEADERS)
+    message(STATUS "Using Precompiled Headers.")
+    set(CMAKE_PCH_INSTANTIATE_TEMPLATES ON)
+endif()
+
+
 # Default to a Release build
 get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
@@ -175,24 +199,39 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 # System imported libraries
 # =======================================================================

-find_package(fmt 8.0.1 REQUIRED CONFIG)
-find_package(nlohmann_json 3.8 REQUIRED CONFIG)
+find_package(enet 1.3)
+find_package(fmt 9 REQUIRED)
+find_package(inih)
+find_package(lz4 1.8 REQUIRED)
+find_package(nlohmann_json 3.8 REQUIRED)
+find_package(Opus 1.3)
+find_package(Vulkan 1.3.213)
 find_package(ZLIB 1.2 REQUIRED)
+find_package(zstd 1.5 REQUIRED)

-# Search for config-only package first (for vcpkg), then try non-config
-find_package(zstd 1.5 CONFIG)
-if (NOT zstd_FOUND)
-    find_package(zstd 1.5 REQUIRED)
+if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
+    find_package(xbyak 6)
 endif()

-# lz4 1.8 is required, but vcpkg's lz4-config.cmake does not have version info
-find_package(lz4 CONFIG)
-if (NOT lz4_FOUND)
-    find_package(lz4 1.8 REQUIRED)
+if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
+    find_package(dynarmic 6.2.4)
+endif()
+
+if (ENABLE_CUBEB)
+    find_package(cubeb)
+endif()
+
+if (USE_DISCORD_PRESENCE)
+    find_package(DiscordRPC)
+endif()
+
+if (ENABLE_WEB_SERVICE)
+    find_package(cpp-jwt 1.4)
+    find_package(httplib 0.11)
 endif()

 if (YUZU_TESTS)
-    find_package(Catch2 2.13.7 REQUIRED CONFIG)
+    find_package(Catch2 2.13.7 REQUIRED)
 endif()

 find_package(Boost 1.73.0 COMPONENTS context)
@@ -213,128 +252,166 @@ if (MINGW)
    find_library(MSWSOCK_LIBRARY mswsock REQUIRED)
 endif()

+# Please consider this as a stub
+if(ENABLE_QT6 AND Qt6_LOCATION)
+    list(APPEND CMAKE_PREFIX_PATH "${Qt6_LOCATION}")
+endif()
+
+function(set_yuzu_qt_components)
+    # Best practice is to ask for all components at once, so they are from the same version
+    set(YUZU_QT_COMPONENTS2 Core Widgets Concurrent)
+    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+        list(APPEND YUZU_QT_COMPONENTS2 DBus)
+    endif()
+    if (YUZU_USE_QT_MULTIMEDIA)
+        list(APPEND YUZU_QT_COMPONENTS2 Multimedia)
+    endif()
+    if (YUZU_USE_QT_WEB_ENGINE)
+        list(APPEND YUZU_QT_COMPONENTS2 WebEngineCore WebEngineWidgets)
+    endif()
+    if (ENABLE_QT_TRANSLATION)
+        list(APPEND YUZU_QT_COMPONENTS2 LinguistTools)
+    endif()
+    set(YUZU_QT_COMPONENTS ${YUZU_QT_COMPONENTS2} PARENT_SCOPE)
+endfunction(set_yuzu_qt_components)
+
 # Qt5 requires that we find components, so it doesn't fit our pretty little find package function
 if(ENABLE_QT)
    set(QT_VERSION 5.15)
+    # These are used to specify minimum versions
+    set(QT5_VERSION 5.15)
+    set(QT6_VERSION 6.3.1)

-    # Check for system Qt on Linux, fallback to bundled Qt
-    if (UNIX AND NOT APPLE)
-        if (NOT YUZU_USE_BUNDLED_QT)
-            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets DBus Multimedia)
-        endif()
-        if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND (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
-            find_package(PkgConfig REQUIRED)
-            pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
-            if (NOT QT_DEP_GLU_FOUND)
-                message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
-                    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
-            set(YUZU_USE_QT_WEB_ENGINE OFF CACHE BOOL "Use Qt Webengine" FORCE)
-        endif()
+    set_yuzu_qt_components()
+    if (ENABLE_QT6)
+        find_package(Qt6 ${QT6_VERSION} COMPONENTS ${YUZU_QT_COMPONENTS})
    endif()
-
-    set(YUZU_QT_NO_CMAKE_SYSTEM_PATH)
-
-    if(YUZU_USE_BUNDLED_QT)
-        if ((MSVC_VERSION GREATER_EQUAL 1920 AND MSVC_VERSION LESS 1940) AND ARCHITECTURE_x86_64)
-            set(QT_BUILD qt-5.15.2-msvc2019_64)
-        elseif ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND NOT MINGW AND ARCHITECTURE_x86_64)
-            set(QT_BUILD qt5_5_15_2)
-        else()
-            message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
-        endif()
-
-        if (DEFINED QT_BUILD)
-            download_bundled_external("qt/" ${QT_BUILD} QT_PREFIX)
-        endif()
-
-        set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
-
-        set(YUZU_QT_NO_CMAKE_SYSTEM_PATH "NO_CMAKE_SYSTEM_PATH")
-    endif()
-    if (UNIX AND NOT APPLE AND YUZU_USE_BUNDLED_QT)
-        find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets Concurrent Multimedia DBus ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
+    if (Qt6_FOUND)
+        message(STATUS "yuzu/CMakeLists.txt: Qt6Widgets_VERSION ${Qt6Widgets_VERSION}, setting QT_VERSION")
+        set(QT_VERSION ${Qt6Widgets_VERSION})
+        set(QT_MAJOR_VERSION 6)
+        # Qt6 sets cxx_std_17 and we need to undo that
+        set_target_properties(Qt6::Platform PROPERTIES INTERFACE_COMPILE_FEATURES "")
    else()
-        find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets Concurrent Multimedia ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
-    endif()
-    if (YUZU_USE_QT_WEB_ENGINE)
-        find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets)
+        message(STATUS "yuzu/CMakeLists.txt: Qt6 not found/not selected, trying for Qt5")
+        # When Qt6 partially found, need this set to use Qt5 when not specifying version
+        set(QT_DEFAULT_MAJOR_VERSION 5)
+        set(QT_MAJOR_VERSION 5)
+
+        set(YUZU_USE_QT_MULTIMEDIA ON)
+        # Check for system Qt on Linux, fallback to bundled Qt
+        if (UNIX AND NOT APPLE)
+            if (NOT YUZU_USE_BUNDLED_QT)
+                find_package(Qt5 ${QT5_VERSION} COMPONENTS Widgets DBus Multimedia)
+            endif()
+            if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND (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 (NOT OBJDUMP)
+                    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
+                find_package(PkgConfig REQUIRED)
+                pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
+                if (NOT QT_DEP_GLU_FOUND)
+                    message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
+                        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 (NOT BUNDLED_QT_${REQUIREMENT})
+                        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
+                set(YUZU_USE_QT_WEB_ENGINE OFF CACHE BOOL "Use Qt Webengine" FORCE)
+            endif()
+        endif()
+
+        set(YUZU_QT_NO_CMAKE_SYSTEM_PATH)
+
+        if(YUZU_USE_BUNDLED_QT)
+            if ((MSVC_VERSION GREATER_EQUAL 1920 AND MSVC_VERSION LESS 1940) AND ARCHITECTURE_x86_64)
+                set(QT_BUILD qt-5.15.2-msvc2019_64)
+            elseif ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND NOT MINGW AND ARCHITECTURE_x86_64)
+                set(QT_BUILD qt5_5_15_2)
+            else()
+                message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
+            endif()
+
+            if (DEFINED QT_BUILD)
+                download_bundled_external("qt/" ${QT_BUILD} QT_PREFIX)
+            endif()
+
+            set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
+
+            set(YUZU_QT_NO_CMAKE_SYSTEM_PATH "NO_CMAKE_SYSTEM_PATH")
+            # Binary package for Qt5 has Qt Multimedia
+            set(YUZU_USE_QT_MULTIMEDIA ON CACHE BOOL "Use Qt Multimedia" FORCE)
+        endif()
+
+        set_yuzu_qt_components()
+        find_package(Qt5 ${QT5_VERSION} COMPONENTS ${YUZU_QT_COMPONENTS} ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
    endif()

-    if (ENABLE_QT_TRANSLATION)
-        find_package(Qt5 REQUIRED COMPONENTS LinguistTools ${QT_PREFIX_HINT})
-    endif()
 endif()

 # find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the yuzu_find_package
@@ -385,7 +462,7 @@ if (TARGET Boost::boost)
 endif()

 # Ensure libusb is properly configured (based on dolphin libusb include)
-if(NOT APPLE AND NOT YUZU_USE_BUNDLED_LIBUSB)
+if(NOT YUZU_USE_BUNDLED_LIBUSB)
    find_package(PkgConfig)
    if (PKG_CONFIG_FOUND AND NOT CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD")
        pkg_check_modules(LIBUSB QUIET libusb-1.0>=1.0.24)
@@ -395,7 +472,8 @@ if(NOT APPLE AND NOT YUZU_USE_BUNDLED_LIBUSB)

    if (LIBUSB_FOUND)
        add_library(usb INTERFACE)
-        target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")
+        target_include_directories(usb INTERFACE "${LIBUSB_INCLUDEDIR}" "${LIBUSB_INCLUDE_DIRS}")
+        target_link_directories(usb INTERFACE "${LIBUSB_LIBRARY_DIRS}")
        target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARIES}")
    else()
        message(WARNING "libusb not found, falling back to externals")
@@ -415,22 +493,7 @@ if (UNIX AND NOT APPLE)
 endif()
 if (NOT YUZU_USE_BUNDLED_FFMPEG)
    # Use system installed FFmpeg
-    find_package(FFmpeg 4.3 QUIET COMPONENTS ${FFmpeg_COMPONENTS})
-
-    if (FFmpeg_FOUND)
-        # Overwrite aggregate defines from FFmpeg module to avoid over-linking libraries.
-        # Prevents shipping too many libraries with the AppImage.
-        set(FFmpeg_LIBRARIES "")
-        set(FFmpeg_INCLUDE_DIR "")
-
-        foreach(COMPONENT ${FFmpeg_COMPONENTS})
-            set(FFmpeg_LIBRARIES ${FFmpeg_LIBRARIES} ${FFmpeg_LIBRARY_${COMPONENT}} CACHE PATH "Paths to FFmpeg libraries" FORCE)
-            set(FFmpeg_INCLUDE_DIR ${FFmpeg_INCLUDE_DIR} ${FFmpeg_INCLUDE_${COMPONENT}} CACHE PATH "Path to FFmpeg headers" FORCE)
-        endforeach()
-    else()
-        message(WARNING "FFmpeg not found or too old, falling back to externals")
-        set(YUZU_USE_BUNDLED_FFMPEG ON)
-    endif()
+    find_package(FFmpeg 4.3 REQUIRED QUIET COMPONENTS ${FFmpeg_COMPONENTS})
 endif()

 # Prefer the -pthread flag on Linux.
@@ -27,10 +27,13 @@ function(copy_yuzu_Qt5_deps target_dir)
            Qt5Core$<$<CONFIG:Debug>:d>.*
            Qt5Gui$<$<CONFIG:Debug>:d>.*
            Qt5Widgets$<$<CONFIG:Debug>:d>.*
-            Qt5Multimedia$<$<CONFIG:Debug>:d>.*
            Qt5Network$<$<CONFIG:Debug>:d>.*
        )
-
+        if (YUZU_USE_QT_MULTIMEDIA)
+            windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
+                Qt5Multimedia$<$<CONFIG:Debug>:d>.*
+            )
+        endif()
        if (YUZU_USE_QT_WEB_ENGINE)
            windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
                Qt5Network$<$<CONFIG:Debug>:d>.*
@@ -6,18 +6,16 @@ list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/externals/find-modules")
 include(DownloadExternals)

 # xbyak
-if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    add_subdirectory(xbyak)
+if ((ARCHITECTURE_x86 OR ARCHITECTURE_x86_64) AND NOT TARGET xbyak::xbyak)
+    add_subdirectory(xbyak EXCLUDE_FROM_ALL)
 endif()

 # Dynarmic
-if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
-    if (ARCHITECTURE_arm64)
-       set(DYNARMIC_FRONTENDS "A32")
-    endif()
+if ((ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64) AND NOT TARGET dynarmic::dynarmic)
    set(DYNARMIC_NO_BUNDLED_FMT ON)
    set(DYNARMIC_IGNORE_ASSERTS ON CACHE BOOL "" FORCE)
-    add_subdirectory(dynarmic)
+    add_subdirectory(dynarmic EXCLUDE_FROM_ALL)
+    add_library(dynarmic::dynarmic ALIAS dynarmic)
 endif()

 # getopt
@@ -29,7 +27,9 @@ endif()
 add_subdirectory(glad)

 # inih
-add_subdirectory(inih)
+if (NOT TARGET inih::INIReader)
+    add_subdirectory(inih)
+endif()

 # mbedtls
 add_subdirectory(mbedtls EXCLUDE_FROM_ALL)
@@ -67,35 +67,46 @@ if (YUZU_USE_EXTERNAL_SDL2)
    endif()
    set(SDL_STATIC ON)
    set(SDL_SHARED OFF)
+    if (APPLE)
+        set(SDL_FILE ON)
+    endif()

    add_subdirectory(SDL EXCLUDE_FROM_ALL)
-    add_library(SDL2 ALIAS SDL2-static)
 endif()

 # ENet
-add_subdirectory(enet)
-target_include_directories(enet INTERFACE ./enet/include)
+if (NOT TARGET enet::enet)
+    add_subdirectory(enet EXCLUDE_FROM_ALL)
+    target_include_directories(enet INTERFACE ./enet/include)
+    add_library(enet::enet ALIAS enet)
+endif()

 # Cubeb
-if(ENABLE_CUBEB)
+if (ENABLE_CUBEB AND NOT TARGET cubeb::cubeb)
    set(BUILD_TESTS OFF CACHE BOOL "")
    add_subdirectory(cubeb EXCLUDE_FROM_ALL)
+    add_library(cubeb::cubeb ALIAS cubeb)
 endif()

 # DiscordRPC
-if (USE_DISCORD_PRESENCE)
+if (USE_DISCORD_PRESENCE AND NOT TARGET DiscordRPC::discord-rpc)
    add_subdirectory(discord-rpc EXCLUDE_FROM_ALL)
    target_include_directories(discord-rpc INTERFACE ./discord-rpc/include)
+    add_library(DiscordRPC::discord-rpc ALIAS discord-rpc)
 endif()

 # Sirit
-add_subdirectory(sirit)
+add_subdirectory(sirit EXCLUDE_FROM_ALL)

-if (ENABLE_WEB_SERVICE)
-    find_package(OpenSSL 1.1)
-    if (OPENSSL_FOUND)
-        set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
-    else()
+if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)
+    if (NOT WIN32)
+        find_package(OpenSSL 1.1)
+        if (OPENSSL_FOUND)
+            set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
+        endif()
+    endif()
+
+    if (WIN32 OR NOT OPENSSL_FOUND)
        # LibreSSL
        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
        set(OPENSSLDIR "/etc/ssl/")
@@ -115,18 +126,20 @@ if (ENABLE_WEB_SERVICE)
    if (WIN32)
        target_link_libraries(httplib INTERFACE crypt32 cryptui ws2_32)
    endif()
-	
-    # cpp-jwt
+    add_library(httplib::httplib ALIAS httplib)
+endif()
+
+# cpp-jwt
+if (ENABLE_WEB_SERVICE AND NOT TARGET cpp-jwt::cpp-jwt)
    add_library(cpp-jwt INTERFACE)
    target_include_directories(cpp-jwt INTERFACE ./cpp-jwt/include)
    target_compile_definitions(cpp-jwt INTERFACE CPP_JWT_USE_VENDORED_NLOHMANN_JSON)
+    add_library(cpp-jwt::cpp-jwt ALIAS cpp-jwt)
 endif()

 # Opus
-if (YUZU_USE_BUNDLED_OPUS)
+if (NOT TARGET Opus::opus)
    add_subdirectory(opus EXCLUDE_FROM_ALL)
-else()
-    find_package(Opus 1.3 REQUIRED)
 endif()

 # FFMpeg
@@ -137,3 +150,8 @@ if (YUZU_USE_BUNDLED_FFMPEG)
    set(FFmpeg_LIBRARIES "${FFmpeg_LIBRARIES}" PARENT_SCOPE)
    set(FFmpeg_INCLUDE_DIR "${FFmpeg_INCLUDE_DIR}" PARENT_SCOPE)
 endif()
+
+# Vulkan-Headers
+if (NOT TARGET Vulkan::Headers)
+    add_subdirectory(Vulkan-Headers EXCLUDE_FROM_ALL)
+endif()
@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: 2022 Alexandre Bouvier <contact@amb.tf>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+find_path(DiscordRPC_INCLUDE_DIR discord_rpc.h)
+
+find_library(DiscordRPC_LIBRARY discord-rpc)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(DiscordRPC
+    REQUIRED_VARS
+        DiscordRPC_LIBRARY
+        DiscordRPC_INCLUDE_DIR
+)
+
+if (DiscordRPC_FOUND AND NOT TARGET DiscordRPC::discord-rpc)
+    add_library(DiscordRPC::discord-rpc UNKNOWN IMPORTED)
+    set_target_properties(DiscordRPC::discord-rpc PROPERTIES
+        IMPORTED_LOCATION "${DiscordRPC_LIBRARY}"
+        INTERFACE_INCLUDE_DIRECTORIES "${DiscordRPC_INCLUDE_DIR}"
+    )
+endif()
+
+mark_as_advanced(
+    DiscordRPC_INCLUDE_DIR
+    DiscordRPC_LIBRARY
+)
@@ -185,3 +185,11 @@ foreach(c ${_FFmpeg_ALL_COMPONENTS})
 endforeach()
 unset(_FFmpeg_ALL_COMPONENTS)
 unset(_FFmpeg_REQUIRED_VARS)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(FFmpeg
+  REQUIRED_VARS
+    FFmpeg_LIBRARIES
+    FFmpeg_INCLUDE_DIR
+  HANDLE_COMPONENTS
+)
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2022 Alexandre Bouvier <contact@amb.tf>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+find_package(PkgConfig QUIET)
+if (PKG_CONFIG_FOUND)
+    pkg_search_module(ENET QUIET IMPORTED_TARGET GLOBAL libenet)
+    if (ENET_FOUND)
+        add_library(enet::enet ALIAS PkgConfig::ENET)
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(enet
+    REQUIRED_VARS ENET_LINK_LIBRARIES
+    VERSION_VAR ENET_VERSION
+)
@@ -0,0 +1,22 @@
+# SPDX-FileCopyrightText: 2022 Andrea Pappacoda <andrea@pappacoda.it>
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+include(FindPackageHandleStandardArgs)
+
+find_package(httplib QUIET CONFIG)
+if (httplib_FOUND)
+    find_package_handle_standard_args(httplib CONFIG_MODE)
+else()
+    find_package(PkgConfig QUIET)
+    if (PKG_CONFIG_FOUND)
+        pkg_search_module(HTTPLIB QUIET IMPORTED_TARGET GLOBAL cpp-httplib)
+        if (HTTPLIB_FOUND)
+            add_library(httplib::httplib ALIAS PkgConfig::HTTPLIB)
+        endif()
+    endif()
+    find_package_handle_standard_args(httplib
+        REQUIRED_VARS HTTPLIB_INCLUDEDIR
+        VERSION_VAR HTTPLIB_VERSION
+    )
+endif()
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2022 Alexandre Bouvier <contact@amb.tf>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+find_package(PkgConfig QUIET)
+if (PKG_CONFIG_FOUND)
+    pkg_search_module(INIREADER QUIET IMPORTED_TARGET GLOBAL INIReader)
+    if (INIREADER_FOUND)
+        add_library(inih::INIReader ALIAS PkgConfig::INIREADER)
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(inih
+    REQUIRED_VARS INIREADER_LINK_LIBRARIES
+    VERSION_VAR INIREADER_VERSION
+)
@@ -1,19 +1,30 @@
 # SPDX-FileCopyrightText: 2022 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later

-find_package(PkgConfig)
-
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(liblz4 IMPORTED_TARGET GLOBAL liblz4)
-    if (liblz4_FOUND)
-        add_library(lz4::lz4 ALIAS PkgConfig::liblz4)
-    endif()
-endif()
-
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(lz4
-    REQUIRED_VARS
-        liblz4_LINK_LIBRARIES
-        liblz4_FOUND
-    VERSION_VAR liblz4_VERSION
-)
+
+find_package(lz4 QUIET CONFIG)
+if (lz4_FOUND)
+    find_package_handle_standard_args(lz4 CONFIG_MODE)
+    if (NOT TARGET lz4::lz4)
+        if (TARGET LZ4::lz4_shared)
+            set_target_properties(LZ4::lz4_shared PROPERTIES IMPORTED_GLOBAL TRUE)
+            add_library(lz4::lz4 ALIAS LZ4::lz4_shared)
+        else()
+            set_target_properties(LZ4::lz4_static PROPERTIES IMPORTED_GLOBAL TRUE)
+            add_library(lz4::lz4 ALIAS LZ4::lz4_static)
+        endif()
+    endif()
+else()
+    find_package(PkgConfig QUIET)
+    if (PKG_CONFIG_FOUND)
+        pkg_search_module(liblz4 QUIET IMPORTED_TARGET GLOBAL liblz4)
+        if (liblz4_FOUND)
+            add_library(lz4::lz4 ALIAS PkgConfig::liblz4)
+        endif()
+    endif()
+    find_package_handle_standard_args(lz4
+        REQUIRED_VARS liblz4_LINK_LIBRARIES
+        VERSION_VAR liblz4_VERSION
+    )
+endif()
@@ -1,19 +1,30 @@
 # SPDX-FileCopyrightText: 2022 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later

-find_package(PkgConfig)
-
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(libzstd IMPORTED_TARGET GLOBAL libzstd)
-    if (libzstd_FOUND)
-        add_library(zstd::zstd ALIAS PkgConfig::libzstd)
-    endif()
-endif()
-
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(zstd
-    REQUIRED_VARS
-        libzstd_LINK_LIBRARIES
-        libzstd_FOUND
-    VERSION_VAR libzstd_VERSION
-)
+
+find_package(zstd QUIET CONFIG)
+if (zstd_FOUND)
+    find_package_handle_standard_args(zstd CONFIG_MODE)
+    if (NOT TARGET zstd::zstd)
+        if (TARGET zstd::libzstd_shared)
+            set_target_properties(zstd::libzstd_shared PROPERTIES IMPORTED_GLOBAL TRUE)
+            add_library(zstd::zstd ALIAS zstd::libzstd_shared)
+        else()
+            set_target_properties(zstd::libzstd_static PROPERTIES IMPORTED_GLOBAL TRUE)
+            add_library(zstd::zstd ALIAS zstd::libzstd_static)
+        endif()
+    endif()
+else()
+    find_package(PkgConfig QUIET)
+    if (PKG_CONFIG_FOUND)
+        pkg_search_module(libzstd QUIET IMPORTED_TARGET GLOBAL libzstd)
+        if (libzstd_FOUND)
+            add_library(zstd::zstd ALIAS PkgConfig::libzstd)
+        endif()
+    endif()
+    find_package_handle_standard_args(zstd
+        REQUIRED_VARS libzstd_LINK_LIBRARIES
+        VERSION_VAR libzstd_VERSION
+    )
+endif()
@@ -9,4 +9,5 @@ add_library(inih
 )

 create_target_directory_groups(inih)
-target_include_directories(inih INTERFACE .)
+target_include_directories(inih INTERFACE inih/cpp)
+add_library(inih::INIReader ALIAS inih)
@@ -82,8 +82,9 @@ if (MSVC)
        /wd4324 # 'struct_name': structure was padded due to __declspec(align())
    )

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

        $<$<CXX_COMPILER_ID:Clang>:-Wno-braced-scalar-init>
        $<$<CXX_COMPILER_ID:Clang>:-Wno-unused-private-field>
+        $<$<CXX_COMPILER_ID:AppleClang>:-Wno-braced-scalar-init>
+        $<$<CXX_COMPILER_ID:AppleClang>:-Wno-unused-private-field>
    )

    if (ARCHITECTURE_x86_64)
@@ -31,6 +31,7 @@ add_library(audio_core STATIC
    out/audio_out.h
    out/audio_out_system.cpp
    out/audio_out_system.h
+    precompiled_headers.h
    renderer/adsp/adsp.cpp
    renderer/adsp/adsp.h
    renderer/adsp/audio_renderer.cpp
@@ -218,14 +219,22 @@ endif()

 target_link_libraries(audio_core PUBLIC common core)
 if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
-    target_link_libraries(audio_core PRIVATE dynarmic)
+    target_link_libraries(audio_core PRIVATE dynarmic::dynarmic)
 endif()

 if(ENABLE_CUBEB)
-    target_link_libraries(audio_core PRIVATE cubeb)
+    target_link_libraries(audio_core PRIVATE cubeb::cubeb)
    target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
 if(ENABLE_SDL2)
-    target_link_libraries(audio_core PRIVATE SDL2)
+    if (YUZU_USE_EXTERNAL_SDL2)
+        target_link_libraries(audio_core PRIVATE SDL2-static)
+    else()
+        target_link_libraries(audio_core PRIVATE SDL2)
+    endif()
    target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()
+
+if (YUZU_USE_PRECOMPILED_HEADERS)
+    target_precompile_headers(audio_core PRIVATE precompiled_headers.h)
+endif()
@@ -3,6 +3,7 @@

 #include "audio_core/audio_event.h"
 #include "common/assert.h"
+#include "common/polyfill_ranges.h"

 namespace AudioCore {

@@ -9,6 +9,8 @@
 #include <mutex>
 #include <thread>

+#include "common/polyfill_thread.h"
+
 #include "audio_core/audio_event.h"

 union Result;
@@ -7,6 +7,8 @@
 #include <memory>
 #include <mutex>

+#include "common/polyfill_thread.h"
+
 #include "audio_core/common/common.h"
 #include "audio_core/renderer/system_manager.h"
 #include "core/hle/service/audio/errors.h"
@@ -10,6 +10,7 @@
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/polyfill_ranges.h"

 namespace AudioCore {
 constexpr u32 CurrentRevision = 11;
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_precompiled_headers.h"
@@ -460,21 +460,23 @@ void CommandBuffer::GenerateDeviceSinkCommand(const s32 node_id, const s16 buffe

    cmd.session_id = session_id;

+    cmd.input_count = parameter.input_count;
+    s16 max_input{0};
+    for (u32 i = 0; i < parameter.input_count; i++) {
+        cmd.inputs[i] = buffer_offset + parameter.inputs[i];
+        max_input = std::max(max_input, cmd.inputs[i]);
+    }
+
    if (state.upsampler_info != nullptr) {
        const auto size_{state.upsampler_info->sample_count * parameter.input_count};
        const auto size_bytes{size_ * sizeof(s32)};
        const auto addr{memory_pool->Translate(state.upsampler_info->samples_pos, size_bytes)};
        cmd.sample_buffer = {reinterpret_cast<s32*>(addr),
-                             parameter.input_count * state.upsampler_info->sample_count};
+                             (max_input + 1) * state.upsampler_info->sample_count};
    } else {
        cmd.sample_buffer = samples_buffer;
    }

-    cmd.input_count = parameter.input_count;
-    for (u32 i = 0; i < parameter.input_count; i++) {
-        cmd.inputs[i] = buffer_offset + parameter.inputs[i];
-    }
-
    GenerateEnd<DeviceSinkCommand>(cmd);
 }

@@ -5,6 +5,7 @@

 #include "audio_core/renderer/adsp/command_list_processor.h"
 #include "audio_core/renderer/command/effect/i3dl2_reverb.h"
+#include "common/polyfill_ranges.h"

 namespace AudioCore::AudioRenderer {

@@ -6,6 +6,7 @@

 #include "audio_core/renderer/adsp/command_list_processor.h"
 #include "audio_core/renderer/command/effect/reverb.h"
+#include "common/polyfill_ranges.h"

 namespace AudioCore::AudioRenderer {

@@ -5,6 +5,7 @@

 #include "audio_core/renderer/mix/mix_context.h"
 #include "audio_core/renderer/splitter/splitter_context.h"
+#include "common/polyfill_ranges.h"

 namespace AudioCore::AudioRenderer {

@@ -4,6 +4,7 @@
 #include <ranges>

 #include "audio_core/renderer/voice/voice_context.h"
+#include "common/polyfill_ranges.h"

 namespace AudioCore::AudioRenderer {

@@ -170,8 +170,8 @@ void SinkStream::ProcessAudioIn(std::span<const s16> input_buffer, std::size_t n

        // Get the minimum frames available between the currently playing buffer, and the
        // amount we have left to fill
-        size_t frames_available{std::min(playing_buffer.frames - playing_buffer.frames_played,
-                                         num_frames - frames_written)};
+        size_t frames_available{std::min<u64>(playing_buffer.frames - playing_buffer.frames_played,
+                                              num_frames - frames_written)};

        samples_buffer.Push(&input_buffer[frames_written * frame_size],
                            frames_available * frame_size);
@@ -241,8 +241,8 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz

        // Get the minimum frames available between the currently playing buffer, and the
        // amount we have left to fill
-        size_t frames_available{std::min(playing_buffer.frames - playing_buffer.frames_played,
-                                         num_frames - frames_written)};
+        size_t frames_available{std::min<u64>(playing_buffer.frames - playing_buffer.frames_played,
+                                              num_frames - frames_written)};

        samples_buffer.Pop(&output_buffer[frames_written * frame_size],
                           frames_available * frame_size);
@@ -266,19 +266,20 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
 }

 void SinkStream::Stall() {
-    if (stalled) {
+    std::scoped_lock lk{stall_guard};
+    if (stalled_lock) {
        return;
    }
-    stalled = true;
-    system.StallProcesses();
+    stalled_lock = system.StallProcesses();
 }

 void SinkStream::Unstall() {
-    if (!stalled) {
+    std::scoped_lock lk{stall_guard};
+    if (!stalled_lock) {
        return;
    }
    system.UnstallProcesses();
-    stalled = false;
+    stalled_lock.unlock();
 }

 } // namespace AudioCore::Sink
@@ -6,6 +6,7 @@
 #include <array>
 #include <atomic>
 #include <memory>
+#include <mutex>
 #include <span>
 #include <vector>

@@ -240,8 +241,8 @@ private:
    f32 system_volume{1.0f};
    /// Set via IAudioDevice service calls
    f32 device_volume{1.0f};
-    /// True if coretiming has been stalled
-    bool stalled{false};
+    std::mutex stall_guard;
+    std::unique_lock<std::mutex> stalled_lock;
 };

 using SinkStreamPtr = std::unique_ptr<SinkStream>;
@@ -37,6 +37,7 @@ add_library(common STATIC
    cache_management.cpp
    cache_management.h
    common_funcs.h
+    common_precompiled_headers.h
    common_types.h
    concepts.h
    div_ceil.h
@@ -95,6 +96,7 @@ add_library(common STATIC
    param_package.h
    parent_of_member.h
    point.h
+    precompiled_headers.h
    quaternion.h
    reader_writer_queue.h
    ring_buffer.h
@@ -147,7 +149,7 @@ if(ARCHITECTURE_x86_64)
            x64/xbyak_abi.h
            x64/xbyak_util.h
    )
-    target_link_libraries(common PRIVATE xbyak)
+    target_link_libraries(common PRIVATE xbyak::xbyak)
 endif()

 if (MSVC)
@@ -172,14 +174,8 @@ endif()
 create_target_directory_groups(common)

 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
-if (TARGET lz4::lz4)
-  target_link_libraries(common PRIVATE lz4::lz4)
-else()
-  target_link_libraries(common PRIVATE LZ4::lz4_shared)
-endif()
-if (TARGET zstd::zstd)
-  target_link_libraries(common PRIVATE zstd::zstd)
-else()
-  target_link_libraries(common PRIVATE
-    $<IF:$<TARGET_EXISTS:zstd::libzstd_shared>,zstd::libzstd_shared,zstd::libzstd_static>)
+target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd)
+
+if (YUZU_USE_PRECOMPILED_HEADERS)
+    target_precompile_headers(common PRIVATE precompiled_headers.h)
 endif()
@@ -1,11 +1,10 @@
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <cstdint>
 #include <cstring>

-#include "alignment.h"
-#include "cache_management.h"
-#include "common_types.h"
+#include "common/cache_management.h"

 namespace Common {

@@ -3,7 +3,7 @@

 #pragma once

-#include "stdlib.h"
+#include <cstddef>

 namespace Common {

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <memory>
+
+#include <fmt/format.h>
+
+#include "common/assert.h"
+#include "common/common_types.h"
@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <vector>
+
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
 #include "common/logging/log.h"
@@ -4,6 +4,7 @@
 #include <algorithm>

 #include "common/fs/fs_util.h"
+#include "common/polyfill_ranges.h"

 namespace Common::FS {

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <algorithm>
+#include <sstream>
 #include <unordered_map>

 #include "common/fs/fs.h"
@@ -8,6 +8,7 @@
 #include <string>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 #include "common/logging/log.h"
 #include "common/param_package.h"
 #include "common/uuid.h"
@@ -383,6 +384,16 @@ void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDevic
    }
 }

+inline void RegisterInputFactory(const std::string& name,
+                                 std::shared_ptr<Factory<InputDevice>> factory) {
+    RegisterFactory<InputDevice>(name, std::move(factory));
+}
+
+inline void RegisterOutputFactory(const std::string& name,
+                                  std::shared_ptr<Factory<OutputDevice>> factory) {
+    RegisterFactory<OutputDevice>(name, std::move(factory));
+}
+
 /**
 * Unregisters an input device factory.
 * @tparam InputDeviceType the type of input devices the factory can create
@@ -395,6 +406,14 @@ void UnregisterFactory(const std::string& name) {
    }
 }

+inline void UnregisterInputFactory(const std::string& name) {
+    UnregisterFactory<InputDevice>(name);
+}
+
+inline void UnregisterOutputFactory(const std::string& name) {
+    UnregisterFactory<OutputDevice>(name);
+}
+
 /**
 * Create an input device from given paramters.
 * @tparam InputDeviceType the type of input devices to create
@@ -416,13 +435,21 @@ std::unique_ptr<InputDeviceType> CreateDeviceFromString(const std::string& param
    return pair->second->Create(package);
 }

+inline std::unique_ptr<InputDevice> CreateInputDeviceFromString(const std::string& params) {
+    return CreateDeviceFromString<InputDevice>(params);
+}
+
+inline std::unique_ptr<OutputDevice> CreateOutputDeviceFromString(const std::string& params) {
+    return CreateDeviceFromString<OutputDevice>(params);
+}
+
 /**
- * Create an input device from given paramters.
+ * Create an input device from given parameters.
 * @tparam InputDeviceType the type of input devices to create
- * @param A ParamPackage that contains all parameters for creating the device
+ * @param package A ParamPackage that contains all parameters for creating the device
 */
 template <typename InputDeviceType>
-std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package) {
+std::unique_ptr<InputDeviceType> CreateDevice(const ParamPackage& package) {
    const std::string engine = package.Get("engine", "null");
    const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
    const auto pair = factory_list.find(engine);
@@ -435,4 +462,12 @@ std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package
    return pair->second->Create(package);
 }

+inline std::unique_ptr<InputDevice> CreateInputDevice(const ParamPackage& package) {
+    return CreateDevice<InputDevice>(package);
+}
+
+inline std::unique_ptr<OutputDevice> CreateOutputDevice(const ParamPackage& package) {
+    return CreateDevice<OutputDevice>(package);
+}
+
 } // namespace Common::Input
@@ -4,7 +4,6 @@
 #include <atomic>
 #include <chrono>
 #include <climits>
-#include <stop_token>
 #include <thread>

 #include <fmt/format.h>
@@ -18,6 +17,7 @@
 #include "common/fs/fs_paths.h"
 #include "common/fs/path_util.h"
 #include "common/literals.h"
+#include "common/polyfill_thread.h"
 #include "common/thread.h"

 #include "common/logging/backend.h"
@@ -0,0 +1,530 @@
+// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+//
+// TODO: remove this file when ranges are supported by all compilation targets
+//
+
+#pragma once
+
+#include <algorithm>
+#include <utility>
+#include <version>
+
+#ifndef __cpp_lib_ranges
+
+namespace std {
+namespace ranges {
+
+template <typename T>
+concept range = requires(T& t) {
+    begin(t);
+    end(t);
+};
+
+template <typename T>
+concept input_range = range<T>;
+
+template <typename T>
+concept output_range = range<T>;
+
+template <range R>
+using range_difference_t = ptrdiff_t;
+
+//
+// find, find_if, find_if_not
+//
+
+struct find_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity>
+    constexpr Iterator operator()(Iterator first, Iterator last, const T& value,
+                                  Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (std::invoke(proj, *first) == value) {
+                return first;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T& value, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), value, std::ref(proj));
+    }
+};
+
+struct find_if_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr Iterator operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (std::invoke(pred, std::invoke(proj, *first))) {
+                return first;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+struct find_if_not_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr Iterator operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (!std::invoke(pred, std::invoke(proj, *first))) {
+                return first;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+inline constexpr find_fn find;
+inline constexpr find_if_fn find_if;
+inline constexpr find_if_not_fn find_if_not;
+
+//
+// any_of, all_of, none_of
+//
+
+struct all_of_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        return ranges::find_if_not(first, last, std::ref(pred), std::ref(proj)) == last;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+struct any_of_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) != last;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+struct none_of_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) == last;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+inline constexpr any_of_fn any_of;
+inline constexpr all_of_fn all_of;
+inline constexpr none_of_fn none_of;
+
+//
+// count, count_if
+//
+
+struct count_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity>
+    constexpr ptrdiff_t operator()(Iterator first, Iterator last, const T& value,
+                                   Proj proj = {}) const {
+        ptrdiff_t counter = 0;
+        for (; first != last; ++first)
+            if (std::invoke(proj, *first) == value)
+                ++counter;
+        return counter;
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity>
+    constexpr ptrdiff_t operator()(R&& r, const T& value, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), value, std::ref(proj));
+    }
+};
+
+struct count_if_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr ptrdiff_t operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        ptrdiff_t counter = 0;
+        for (; first != last; ++first)
+            if (std::invoke(pred, std::invoke(proj, *first)))
+                ++counter;
+        return counter;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr ptrdiff_t operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+inline constexpr count_fn count;
+inline constexpr count_if_fn count_if;
+
+//
+// transform
+//
+
+struct transform_fn {
+    template <typename InputIterator, typename OutputIterator, typename F,
+              typename Proj = std::identity>
+    constexpr void operator()(InputIterator first1, InputIterator last1, OutputIterator result,
+                              F op, Proj proj = {}) const {
+        for (; first1 != last1; ++first1, (void)++result) {
+            *result = std::invoke(op, std::invoke(proj, *first1));
+        }
+    }
+
+    template <ranges::input_range R, typename OutputIterator, typename F,
+              typename Proj = std::identity>
+    constexpr void operator()(R&& r, OutputIterator result, F op, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), result, std::ref(op), std::ref(proj));
+    }
+};
+
+inline constexpr transform_fn transform;
+
+//
+// sort
+//
+
+struct sort_fn {
+    template <typename Iterator, typename Comp = ranges::less, typename Proj = std::identity>
+    constexpr void operator()(Iterator first, Iterator last, Comp comp = {}, Proj proj = {}) const {
+        if (first == last)
+            return;
+
+        Iterator last_iter = ranges::next(first, last);
+        std::sort(first, last_iter,
+                  [&](auto& lhs, auto& rhs) { return comp(proj(lhs), proj(rhs)); });
+    }
+
+    template <ranges::input_range R, typename Comp = ranges::less, typename Proj = std::identity>
+    constexpr void operator()(R&& r, Comp comp = {}, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(comp), std::move(proj));
+    }
+};
+
+inline constexpr sort_fn sort;
+
+//
+// fill
+//
+
+struct fill_fn {
+    template <typename T, typename OutputIterator>
+    constexpr OutputIterator operator()(OutputIterator first, OutputIterator last,
+                                        const T& value) const {
+        while (first != last) {
+            *first++ = value;
+        }
+
+        return first;
+    }
+
+    template <typename T, ranges::output_range R>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T& value) const {
+        return operator()(ranges::begin(r), ranges::end(r), value);
+    }
+};
+
+inline constexpr fill_fn fill;
+
+//
+// for_each
+//
+
+struct for_each_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Fun>
+    constexpr void operator()(Iterator first, Iterator last, Fun f, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            std::invoke(f, std::invoke(proj, *first));
+        }
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Fun>
+    constexpr void operator()(R&& r, Fun f, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(f), std::ref(proj));
+    }
+};
+
+inline constexpr for_each_fn for_each;
+
+//
+// min_element, max_element
+//
+
+struct min_element_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Comp = ranges::less>
+    constexpr Iterator operator()(Iterator first, Iterator last, Comp comp = {},
+                                  Proj proj = {}) const {
+        if (first == last) {
+            return last;
+        }
+
+        auto smallest = first;
+        ++first;
+        for (; first != last; ++first) {
+            if (!std::invoke(comp, std::invoke(proj, *smallest), std::invoke(proj, *first))) {
+                smallest = first;
+            }
+        }
+        return smallest;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Comp = ranges::less>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Comp comp = {}, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
+    }
+};
+
+struct max_element_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Comp = ranges::less>
+    constexpr Iterator operator()(Iterator first, Iterator last, Comp comp = {},
+                                  Proj proj = {}) const {
+        if (first == last) {
+            return last;
+        }
+
+        auto largest = first;
+        ++first;
+        for (; first != last; ++first) {
+            if (std::invoke(comp, std::invoke(proj, *largest), std::invoke(proj, *first))) {
+                largest = first;
+            }
+        }
+        return largest;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Comp = ranges::less>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Comp comp = {}, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
+    }
+};
+
+inline constexpr min_element_fn min_element;
+inline constexpr max_element_fn max_element;
+
+//
+// replace, replace_if
+//
+
+struct replace_fn {
+    template <typename Iterator, typename T1, typename T2, typename Proj = std::identity>
+    constexpr Iterator operator()(Iterator first, Iterator last, const T1& old_value,
+                                  const T2& new_value, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (old_value == std::invoke(proj, *first)) {
+                *first = new_value;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename T1, typename T2, typename Proj = std::identity>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T1& old_value, const T2& new_value,
+                                               Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), old_value, new_value, std::move(proj));
+    }
+};
+
+struct replace_if_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity, typename Pred>
+    constexpr Iterator operator()(Iterator first, Iterator last, Pred pred, const T& new_value,
+                                  Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (!!std::invoke(pred, std::invoke(proj, *first))) {
+                *first = new_value;
+            }
+        }
+        return std::move(first);
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity, typename Pred>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred, const T& new_value,
+                                               Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(pred), new_value,
+                          std::move(proj));
+    }
+};
+
+inline constexpr replace_fn replace;
+inline constexpr replace_if_fn replace_if;
+
+//
+// copy, copy_if
+//
+
+struct copy_fn {
+    template <typename InputIterator, typename OutputIterator>
+    constexpr void operator()(InputIterator first, InputIterator last,
+                              OutputIterator result) const {
+        for (; first != last; ++first, (void)++result) {
+            *result = *first;
+        }
+    }
+
+    template <ranges::input_range R, typename OutputIterator>
+    constexpr void operator()(R&& r, OutputIterator result) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(result));
+    }
+};
+
+struct copy_if_fn {
+    template <typename InputIterator, typename OutputIterator, typename Proj = std::identity,
+              typename Pred>
+    constexpr void operator()(InputIterator first, InputIterator last, OutputIterator result,
+                              Pred pred, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (std::invoke(pred, std::invoke(proj, *first))) {
+                *result = *first;
+                ++result;
+            }
+        }
+    }
+
+    template <ranges::input_range R, typename OutputIterator, typename Proj = std::identity,
+              typename Pred>
+    constexpr void operator()(R&& r, OutputIterator result, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(result), std::ref(pred),
+                          std::ref(proj));
+    }
+};
+
+inline constexpr copy_fn copy;
+inline constexpr copy_if_fn copy_if;
+
+//
+// generate
+//
+
+struct generate_fn {
+    template <typename Iterator, typename F>
+    constexpr Iterator operator()(Iterator first, Iterator last, F gen) const {
+        for (; first != last; *first = std::invoke(gen), ++first)
+            ;
+        return first;
+    }
+
+    template <typename R, std::copy_constructible F>
+    requires std::invocable<F&> && ranges::output_range<R>
+    constexpr ranges::iterator_t<R> operator()(R&& r, F gen) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(gen));
+    }
+};
+
+inline constexpr generate_fn generate;
+
+//
+// lower_bound, upper_bound
+//
+
+struct lower_bound_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity,
+              typename Comp = ranges::less>
+    constexpr Iterator operator()(Iterator first, Iterator last, const T& value, Comp comp = {},
+                                  Proj proj = {}) const {
+        Iterator it;
+        std::ptrdiff_t _count, _step;
+        _count = std::distance(first, last);
+
+        while (_count > 0) {
+            it = first;
+            _step = _count / 2;
+            ranges::advance(it, _step, last);
+            if (comp(std::invoke(proj, *it), value)) {
+                first = ++it;
+                _count -= _step + 1;
+            } else {
+                _count = _step;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity,
+              typename Comp = ranges::less>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T& value, Comp comp = {},
+                                               Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), value, std::ref(comp), std::ref(proj));
+    }
+};
+
+struct upper_bound_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity,
+              typename Comp = ranges::less>
+    constexpr Iterator operator()(Iterator first, Iterator last, const T& value, Comp comp = {},
+                                  Proj proj = {}) const {
+        Iterator it;
+        std::ptrdiff_t _count, _step;
+        _count = std::distance(first, last);
+
+        while (_count > 0) {
+            it = first;
+            _step = _count / 2;
+            ranges::advance(it, _step, last);
+            if (!comp(value, std::invoke(proj, *it))) {
+                first = ++it;
+                _count -= _step + 1;
+            } else {
+                _count = _step;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity,
+              typename Comp = ranges::less>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T& value, Comp comp = {},
+                                               Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), value, std::ref(comp), std::ref(proj));
+    }
+};
+
+inline constexpr lower_bound_fn lower_bound;
+inline constexpr upper_bound_fn upper_bound;
+
+//
+// adjacent_find
+//
+
+struct adjacent_find_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred = ranges::equal_to>
+    constexpr Iterator operator()(Iterator first, Iterator last, Pred pred = {},
+                                  Proj proj = {}) const {
+        if (first == last)
+            return first;
+        auto _next = ranges::next(first);
+        for (; _next != last; ++_next, ++first)
+            if (std::invoke(pred, std::invoke(proj, *first), std::invoke(proj, *_next)))
+                return first;
+        return _next;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity,
+              typename Pred = ranges::equal_to>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred = {}, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+inline constexpr adjacent_find_fn adjacent_find;
+
+} // namespace ranges
+} // namespace std
+
+#endif
@@ -0,0 +1,323 @@
+// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+//
+// TODO: remove this file when jthread is supported by all compilation targets
+//
+
+#pragma once
+
+#include <version>
+
+#ifdef __cpp_lib_jthread
+
+#include <stop_token>
+#include <thread>
+
+namespace Common {
+
+template <typename Condvar, typename Lock, typename Pred>
+void CondvarWait(Condvar& cv, Lock& lock, std::stop_token token, Pred&& pred) {
+    cv.wait(lock, token, std::move(pred));
+}
+
+} // namespace Common
+
+#else
+
+#include <atomic>
+#include <functional>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <thread>
+#include <type_traits>
+
+namespace std {
+namespace polyfill {
+
+using stop_state_callbacks = list<function<void()>>;
+
+class stop_state {
+public:
+    stop_state() = default;
+    ~stop_state() = default;
+
+    bool request_stop() {
+        stop_state_callbacks callbacks;
+
+        {
+            scoped_lock lk{m_lock};
+
+            if (m_stop_requested.load()) {
+                // Already set, nothing to do
+                return false;
+            }
+
+            // Set as requested
+            m_stop_requested = true;
+
+            // Copy callback list
+            callbacks = m_callbacks;
+        }
+
+        for (auto callback : callbacks) {
+            callback();
+        }
+
+        return true;
+    }
+
+    bool stop_requested() const {
+        return m_stop_requested.load();
+    }
+
+    stop_state_callbacks::const_iterator insert_callback(function<void()> f) {
+        stop_state_callbacks::const_iterator ret{};
+        bool should_run{};
+
+        {
+            scoped_lock lk{m_lock};
+            should_run = m_stop_requested.load();
+            m_callbacks.push_front(f);
+            ret = m_callbacks.begin();
+        }
+
+        if (should_run) {
+            f();
+        }
+
+        return ret;
+    }
+
+    void remove_callback(stop_state_callbacks::const_iterator it) {
+        scoped_lock lk{m_lock};
+        m_callbacks.erase(it);
+    }
+
+private:
+    mutex m_lock;
+    atomic<bool> m_stop_requested;
+    stop_state_callbacks m_callbacks;
+};
+
+} // namespace polyfill
+
+class stop_token;
+class stop_source;
+struct nostopstate_t {
+    explicit nostopstate_t() = default;
+};
+inline constexpr nostopstate_t nostopstate{};
+
+template <class Callback>
+class stop_callback;
+
+class stop_token {
+public:
+    stop_token() noexcept = default;
+
+    stop_token(const stop_token&) noexcept = default;
+    stop_token(stop_token&&) noexcept = default;
+    stop_token& operator=(const stop_token&) noexcept = default;
+    stop_token& operator=(stop_token&&) noexcept = default;
+    ~stop_token() = default;
+
+    void swap(stop_token& other) noexcept {
+        m_stop_state.swap(other.m_stop_state);
+    }
+
+    [[nodiscard]] bool stop_requested() const noexcept {
+        return m_stop_state && m_stop_state->stop_requested();
+    }
+    [[nodiscard]] bool stop_possible() const noexcept {
+        return m_stop_state != nullptr;
+    }
+
+private:
+    friend class stop_source;
+    template <typename Callback>
+    friend class stop_callback;
+    stop_token(shared_ptr<polyfill::stop_state> stop_state) : m_stop_state(move(stop_state)) {}
+
+private:
+    shared_ptr<polyfill::stop_state> m_stop_state;
+};
+
+class stop_source {
+public:
+    stop_source() : m_stop_state(make_shared<polyfill::stop_state>()) {}
+    explicit stop_source(nostopstate_t) noexcept {}
+
+    stop_source(const stop_source&) noexcept = default;
+    stop_source(stop_source&&) noexcept = default;
+    stop_source& operator=(const stop_source&) noexcept = default;
+    stop_source& operator=(stop_source&&) noexcept = default;
+    ~stop_source() = default;
+    void swap(stop_source& other) noexcept {
+        m_stop_state.swap(other.m_stop_state);
+    }
+
+    [[nodiscard]] stop_token get_token() const noexcept {
+        return stop_token(m_stop_state);
+    }
+    [[nodiscard]] bool stop_possible() const noexcept {
+        return m_stop_state != nullptr;
+    }
+    [[nodiscard]] bool stop_requested() const noexcept {
+        return m_stop_state && m_stop_state->stop_requested();
+    }
+    bool request_stop() noexcept {
+        return m_stop_state && m_stop_state->request_stop();
+    }
+
+private:
+    friend class jthread;
+    explicit stop_source(shared_ptr<polyfill::stop_state> stop_state)
+        : m_stop_state(move(stop_state)) {}
+
+private:
+    shared_ptr<polyfill::stop_state> m_stop_state;
+};
+
+template <typename Callback>
+class stop_callback {
+    static_assert(is_nothrow_destructible_v<Callback>);
+    static_assert(is_invocable_v<Callback>);
+
+public:
+    using callback_type = Callback;
+
+    template <typename C>
+    requires constructible_from<Callback, C>
+    explicit stop_callback(const stop_token& st,
+                           C&& cb) noexcept(is_nothrow_constructible_v<Callback, C>)
+        : m_stop_state(st.m_stop_state) {
+        if (m_stop_state) {
+            m_callback = m_stop_state->insert_callback(move(cb));
+        }
+    }
+    template <typename C>
+    requires constructible_from<Callback, C>
+    explicit stop_callback(stop_token&& st,
+                           C&& cb) noexcept(is_nothrow_constructible_v<Callback, C>)
+        : m_stop_state(move(st.m_stop_state)) {
+        if (m_stop_state) {
+            m_callback = m_stop_state->insert_callback(move(cb));
+        }
+    }
+    ~stop_callback() {
+        if (m_stop_state && m_callback) {
+            m_stop_state->remove_callback(*m_callback);
+        }
+    }
+
+    stop_callback(const stop_callback&) = delete;
+    stop_callback(stop_callback&&) = delete;
+    stop_callback& operator=(const stop_callback&) = delete;
+    stop_callback& operator=(stop_callback&&) = delete;
+
+private:
+    shared_ptr<polyfill::stop_state> m_stop_state;
+    optional<polyfill::stop_state_callbacks::const_iterator> m_callback;
+};
+
+template <typename Callback>
+stop_callback(stop_token, Callback) -> stop_callback<Callback>;
+
+class jthread {
+public:
+    using id = thread::id;
+    using native_handle_type = thread::native_handle_type;
+
+    jthread() noexcept = default;
+
+    template <typename F, typename... Args,
+              typename = enable_if_t<!is_same_v<remove_cvref_t<F>, jthread>>>
+    explicit jthread(F&& f, Args&&... args)
+        : m_stop_state(make_shared<polyfill::stop_state>()),
+          m_thread(make_thread(move(f), move(args)...)) {}
+
+    ~jthread() {
+        if (joinable()) {
+            request_stop();
+            join();
+        }
+    }
+
+    jthread(const jthread&) = delete;
+    jthread(jthread&&) noexcept = default;
+    jthread& operator=(const jthread&) = delete;
+
+    jthread& operator=(jthread&& other) noexcept {
+        m_thread.swap(other.m_thread);
+        m_stop_state.swap(other.m_stop_state);
+        return *this;
+    }
+
+    void swap(jthread& other) noexcept {
+        m_thread.swap(other.m_thread);
+        m_stop_state.swap(other.m_stop_state);
+    }
+    [[nodiscard]] bool joinable() const noexcept {
+        return m_thread.joinable();
+    }
+    void join() {
+        m_thread.join();
+    }
+    void detach() {
+        m_thread.detach();
+        m_stop_state.reset();
+    }
+
+    [[nodiscard]] id get_id() const noexcept {
+        return m_thread.get_id();
+    }
+    [[nodiscard]] native_handle_type native_handle() {
+        return m_thread.native_handle();
+    }
+    [[nodiscard]] stop_source get_stop_source() noexcept {
+        return stop_source(m_stop_state);
+    }
+    [[nodiscard]] stop_token get_stop_token() const noexcept {
+        return stop_source(m_stop_state).get_token();
+    }
+    bool request_stop() noexcept {
+        return get_stop_source().request_stop();
+    }
+    [[nodiscard]] static unsigned int hardware_concurrency() noexcept {
+        return thread::hardware_concurrency();
+    }
+
+private:
+    template <typename F, typename... Args>
+    thread make_thread(F&& f, Args&&... args) {
+        if constexpr (is_invocable_v<decay_t<F>, stop_token, decay_t<Args>...>) {
+            return thread(move(f), get_stop_token(), move(args)...);
+        } else {
+            return thread(move(f), move(args)...);
+        }
+    }
+
+    shared_ptr<polyfill::stop_state> m_stop_state;
+    thread m_thread;
+};
+
+} // namespace std
+
+namespace Common {
+
+template <typename Condvar, typename Lock, typename Pred>
+void CondvarWait(Condvar& cv, Lock& lock, std::stop_token token, Pred pred) {
+    if (token.stop_requested()) {
+        return;
+    }
+
+    std::stop_callback callback(token, [&] { cv.notify_all(); });
+    cv.wait(lock, [&] { return pred() || token.stop_requested(); });
+}
+
+} // namespace Common
+
+#endif
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_precompiled_headers.h"
@@ -48,6 +48,7 @@ void LogSettings() {
    log_setting("CPU_Accuracy", values.cpu_accuracy.GetValue());
    log_setting("Renderer_UseResolutionScaling", values.resolution_setup.GetValue());
    log_setting("Renderer_ScalingFilter", values.scaling_filter.GetValue());
+    log_setting("Renderer_FSRSlider", values.fsr_sharpening_slider.GetValue());
    log_setting("Renderer_AntiAliasing", values.anti_aliasing.GetValue());
    log_setting("Renderer_UseSpeedLimit", values.use_speed_limit.GetValue());
    log_setting("Renderer_SpeedLimit", values.speed_limit.GetValue());
@@ -181,6 +182,7 @@ void RestoreGlobalState(bool is_powered_on) {
    values.cpuopt_unsafe_ignore_global_monitor.SetGlobal(true);

    // Renderer
+    values.fsr_sharpening_slider.SetGlobal(true);
    values.renderer_backend.SetGlobal(true);
    values.vulkan_device.SetGlobal(true);
    values.aspect_ratio.SetGlobal(true);
@@ -19,6 +19,7 @@ namespace Settings {
 enum class RendererBackend : u32 {
    OpenGL = 0,
    Vulkan = 1,
+    Null = 2,
 };

 enum class ShaderBackend : u32 {
@@ -411,7 +412,7 @@ struct Values {

    // Renderer
    SwitchableSetting<RendererBackend, true> renderer_backend{
-        RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"};
+        RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"};
    Setting<bool> renderer_debug{false, "debug"};
    Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
    Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
@@ -421,6 +422,7 @@ struct Values {
    ResolutionScalingInfo resolution_info{};
    SwitchableSetting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
    SwitchableSetting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
+    SwitchableSetting<int, true> fsr_sharpening_slider{25, 0, 200, "fsr_sharpening_slider"};
    SwitchableSetting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
    // *nix platforms may have issues with the borderless windowed fullscreen mode.
    // Default to exclusive fullscreen on these platforms for now.
@@ -442,7 +444,7 @@ struct Values {
    SwitchableSetting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
    SwitchableSetting<bool> accelerate_astc{true, "accelerate_astc"};
    SwitchableSetting<bool> use_vsync{true, "use_vsync"};
-    SwitchableSetting<ShaderBackend, true> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
+    SwitchableSetting<ShaderBackend, true> shader_backend{ShaderBackend::GLSL, ShaderBackend::GLSL,
                                                          ShaderBackend::SPIRV, "shader_backend"};
    SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
    SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
@@ -391,6 +391,7 @@ struct PlayerInput {
    u32 body_color_right;
    u32 button_color_left;
    u32 button_color_right;
+    std::string profile_name;
 };

 struct TouchscreenInput {
@@ -141,7 +141,7 @@ static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
        MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);

    if (size == 0) {
-        return L"";
+        return {};
    }

    std::wstring output(size, L'\0');
@@ -158,7 +158,7 @@ std::string UTF16ToUTF8(const std::wstring& input) {
    const auto size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
                                          nullptr, 0, nullptr, nullptr);
    if (size == 0) {
-        return "";
+        return {};
    }

    std::string output(size, '\0');
@@ -7,13 +7,13 @@
 #include <condition_variable>
 #include <functional>
 #include <mutex>
-#include <stop_token>
 #include <string>
 #include <thread>
 #include <type_traits>
 #include <vector>
 #include <queue>

+#include "common/polyfill_thread.h"
 #include "common/thread.h"
 #include "common/unique_function.h"

@@ -47,7 +47,8 @@ public:
                        if (requests.empty()) {
                            wait_condition.notify_all();
                        }
-                        condition.wait(lock, stop_token, [this] { return !requests.empty(); });
+                        Common::CondvarWait(condition, lock, stop_token,
+                                            [this] { return !requests.empty(); });
                        if (stop_token.stop_requested()) {
                            break;
                        }
@@ -12,6 +12,8 @@
 #include <mutex>
 #include <utility>

+#include "common/polyfill_thread.h"
+
 namespace Common {
 template <typename T, bool with_stop_token = false>
 class SPSCQueue {
@@ -97,7 +99,7 @@ public:
    T PopWait(std::stop_token stop_token) {
        if (Empty()) {
            std::unique_lock lock{cv_mutex};
-            cv.wait(lock, stop_token, [this] { return !Empty(); });
+            Common::CondvarWait(cv, lock, stop_token, [this] { return !Empty(); });
        }
        if (stop_token.stop_requested()) {
            return T{};
@@ -530,6 +530,11 @@ add_library(core STATIC
    hle/service/ncm/ncm.h
    hle/service/nfc/nfc.cpp
    hle/service/nfc/nfc.h
+    hle/service/nfc/nfc_device.cpp
+    hle/service/nfc/nfc_device.h
+    hle/service/nfc/nfc_result.h
+    hle/service/nfc/nfc_user.cpp
+    hle/service/nfc/nfc_user.h
    hle/service/nfp/amiibo_crypto.cpp
    hle/service/nfp/amiibo_crypto.h
    hle/service/nfp/nfp.cpp
@@ -766,6 +771,7 @@ add_library(core STATIC
    memory.h
    perf_stats.cpp
    perf_stats.h
+    precompiled_headers.h
    reporter.cpp
    reporter.h
    telemetry_session.cpp
@@ -818,5 +824,9 @@ if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
        hle/service/jit/jit.cpp
        hle/service/jit/jit.h
    )
-    target_link_libraries(core PRIVATE dynarmic)
+    target_link_libraries(core PRIVATE dynarmic::dynarmic)
+endif()
+
+if (YUZU_USE_PRECOMPILED_HEADERS)
+    target_precompile_headers(core PRIVATE precompiled_headers.h)
 endif()
@@ -189,7 +189,7 @@ struct System::Impl {

        kernel.Suspend(false);
        core_timing.SyncPause(false);
-        is_paused = false;
+        is_paused.store(false, std::memory_order_relaxed);

        return status;
    }
@@ -200,14 +200,13 @@ struct System::Impl {

        core_timing.SyncPause(true);
        kernel.Suspend(true);
-        is_paused = true;
+        is_paused.store(true, std::memory_order_relaxed);

        return status;
    }

    bool IsPaused() const {
-        std::unique_lock lk(suspend_guard);
-        return is_paused;
+        return is_paused.load(std::memory_order_relaxed);
    }

    std::unique_lock<std::mutex> StallProcesses() {
@@ -218,7 +217,7 @@ struct System::Impl {
    }

    void UnstallProcesses() {
-        if (!is_paused) {
+        if (!IsPaused()) {
            core_timing.SyncPause(false);
            kernel.Suspend(false);
        }
@@ -465,7 +464,7 @@ struct System::Impl {
    }

    mutable std::mutex suspend_guard;
-    bool is_paused{};
+    std::atomic_bool is_paused{};
    std::atomic<bool> is_shutting_down{};

    Timing::CoreTiming core_timing;
@@ -10,6 +10,7 @@
 #include <thread>

 #include "common/fiber.h"
+#include "common/polyfill_thread.h"
 #include "common/thread.h"
 #include "core/hardware_properties.h"

@@ -578,18 +578,18 @@ KeyManager::KeyManager() {

    if (Settings::values.use_dev_keys) {
        dev_mode = true;
-        LoadFromFile(yuzu_keys_dir / "dev.keys", false);
        LoadFromFile(yuzu_keys_dir / "dev.keys_autogenerated", false);
+        LoadFromFile(yuzu_keys_dir / "dev.keys", false);
    } else {
        dev_mode = false;
-        LoadFromFile(yuzu_keys_dir / "prod.keys", false);
        LoadFromFile(yuzu_keys_dir / "prod.keys_autogenerated", false);
+        LoadFromFile(yuzu_keys_dir / "prod.keys", false);
    }

-    LoadFromFile(yuzu_keys_dir / "title.keys", true);
    LoadFromFile(yuzu_keys_dir / "title.keys_autogenerated", true);
-    LoadFromFile(yuzu_keys_dir / "console.keys", false);
+    LoadFromFile(yuzu_keys_dir / "title.keys", true);
    LoadFromFile(yuzu_keys_dir / "console.keys_autogenerated", false);
+    LoadFromFile(yuzu_keys_dir / "console.keys", false);
 }

 static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_t length) {
@@ -9,6 +9,7 @@
 #include <boost/process/async_pipe.hpp>

 #include "common/logging/log.h"
+#include "common/polyfill_thread.h"
 #include "common/thread.h"
 #include "core/core.h"
 #include "core/debugger/debugger.h"
@@ -7,6 +7,7 @@
 #include <utility>

 #include "common/logging/log.h"
+#include "common/polyfill_ranges.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"
 #include "core/crypto/key_manager.h"
@@ -4,6 +4,7 @@
 #pragma once

 #include <functional>
+#include <vector>

 #include "common/common_types.h"

@@ -17,6 +17,8 @@ enum class WindowSystemType {
    Windows,
    X11,
    Wayland,
+    Cocoa,
+    Android,
 };

 /**
@@ -68,7 +68,7 @@ void EmulatedConsole::ReloadInput() {
    // If you load any device here add the equivalent to the UnloadInput() function
    SetTouchParams();

-    motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
+    motion_devices = Common::Input::CreateInputDevice(motion_params);
    if (motion_devices) {
        motion_devices->SetCallback({
            .on_change =
@@ -79,7 +79,7 @@ void EmulatedConsole::ReloadInput() {
    // Unique index for identifying touch device source
    std::size_t index = 0;
    for (auto& touch_device : touch_devices) {
-        touch_device = Common::Input::CreateDevice<Common::Input::InputDevice>(touch_params[index]);
+        touch_device = Common::Input::CreateInputDevice(touch_params[index]);
        if (!touch_device) {
            continue;
        }
@@ -1,6 +1,9 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <algorithm>
+
+#include "common/polyfill_ranges.h"
 #include "common/thread.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/input_converter.h"
@@ -107,10 +110,9 @@ void EmulatedController::ReloadFromSettings() {
        original_npad_type = npad_type;
    }

+    Disconnect();
    if (player.connected) {
        Connect();
-    } else {
-        Disconnect();
    }

    ReloadInput();
@@ -144,29 +146,23 @@ void EmulatedController::LoadDevices() {

    LoadTASParams();

-    std::transform(button_params.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
-                   button_params.begin() + Settings::NativeButton::BUTTON_NS_END,
-                   button_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(stick_params.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
-                   stick_params.begin() + Settings::NativeAnalog::STICK_HID_END,
-                   stick_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(motion_params.begin() + Settings::NativeMotion::MOTION_HID_BEGIN,
-                   motion_params.begin() + Settings::NativeMotion::MOTION_HID_END,
-                   motion_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(trigger_params.begin(), trigger_params.end(), trigger_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(battery_params.begin(), battery_params.end(), battery_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
-    camera_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(camera_params);
-    nfc_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(nfc_params);
-    std::transform(output_params.begin(), output_params.end(), output_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::OutputDevice>);
+    std::ranges::transform(button_params, button_devices.begin(), Common::Input::CreateInputDevice);
+    std::ranges::transform(stick_params, stick_devices.begin(), Common::Input::CreateInputDevice);
+    std::ranges::transform(motion_params, motion_devices.begin(), Common::Input::CreateInputDevice);
+    std::ranges::transform(trigger_params, trigger_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(battery_params, battery_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    camera_devices = Common::Input::CreateInputDevice(camera_params);
+    nfc_devices = Common::Input::CreateInputDevice(nfc_params);
+    std::ranges::transform(output_params, output_devices.begin(),
+                           Common::Input::CreateOutputDevice);

    // Initialize TAS devices
-    std::transform(tas_button_params.begin(), tas_button_params.end(), tas_button_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(tas_stick_params.begin(), tas_stick_params.end(), tas_stick_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
+    std::ranges::transform(tas_button_params, tas_button_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(tas_stick_params, tas_stick_devices.begin(),
+                           Common::Input::CreateInputDevice);
 }

 void EmulatedController::LoadTASParams() {
@@ -8,6 +8,7 @@
 #include <memory>
 #include <mutex>
 #include <unordered_map>
+#include <vector>

 #include "common/common_types.h"
 #include "common/input.h"
@@ -25,12 +25,12 @@ void EmulatedDevices::ReloadInput() {
        Common::ParamPackage mouse_params;
        mouse_params.Set("engine", "mouse");
        mouse_params.Set("button", static_cast<int>(key_index));
-        mouse_device = Common::Input::CreateDevice<Common::Input::InputDevice>(mouse_params);
+        mouse_device = Common::Input::CreateInputDevice(mouse_params);
        key_index++;
    }

-    mouse_stick_device = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
-        "engine:mouse,axis_x:0,axis_y:1");
+    mouse_stick_device =
+        Common::Input::CreateInputDeviceFromString("engine:mouse,axis_x:0,axis_y:1");

    // First two axis are reserved for mouse position
    key_index = 2;
@@ -38,7 +38,7 @@ void EmulatedDevices::ReloadInput() {
        Common::ParamPackage mouse_params;
        mouse_params.Set("engine", "mouse");
        mouse_params.Set("axis", static_cast<int>(key_index));
-        mouse_device = Common::Input::CreateDevice<Common::Input::InputDevice>(mouse_params);
+        mouse_device = Common::Input::CreateInputDevice(mouse_params);
        key_index++;
    }

@@ -50,7 +50,7 @@ void EmulatedDevices::ReloadInput() {
        keyboard_params.Set("button", static_cast<int>(key_index));
        keyboard_params.Set("port", 1);
        keyboard_params.Set("pad", 0);
-        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        keyboard_device = Common::Input::CreateInputDevice(keyboard_params);
        key_index++;
    }

@@ -62,11 +62,11 @@ void EmulatedDevices::ReloadInput() {
        keyboard_params.Set("button", static_cast<int>(key_index));
        keyboard_params.Set("port", 1);
        keyboard_params.Set("pad", 1);
-        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        keyboard_device = Common::Input::CreateInputDevice(keyboard_params);
        key_index++;
    }

-    ring_analog_device = Common::Input::CreateDevice<Common::Input::InputDevice>(ring_params);
+    ring_analog_device = Common::Input::CreateInputDevice(ring_params);

    for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
        if (!mouse_button_devices[index]) {
@@ -145,6 +145,7 @@ void EmulatedDevices::UnloadInput() {
    for (auto& button : keyboard_modifier_devices) {
        button.reset();
    }
+    ring_analog_device.reset();
 }

 void EmulatedDevices::EnableConfiguration() {
@@ -8,6 +8,7 @@
 #include <memory>
 #include <mutex>
 #include <unordered_map>
+#include <vector>

 #include "common/common_types.h"
 #include "common/input.h"
@@ -199,7 +199,7 @@ public:
    ~HLERequestContext();

    /// Returns a pointer to the IPC command buffer for this request.
-    u32* CommandBuffer() {
+    [[nodiscard]] u32* CommandBuffer() {
        return cmd_buf.data();
    }

@@ -207,7 +207,7 @@ public:
     * Returns the session through which this request was made. This can be used as a map key to
     * access per-client data on services.
     */
-    Kernel::KServerSession* Session() {
+    [[nodiscard]] Kernel::KServerSession* Session() {
        return server_session;
    }

@@ -217,61 +217,61 @@ public:
    /// Writes data from this context back to the requesting process/thread.
    Result WriteToOutgoingCommandBuffer(KThread& requesting_thread);

-    u32_le GetHipcCommand() const {
+    [[nodiscard]] u32_le GetHipcCommand() const {
        return command;
    }

-    u32_le GetTipcCommand() const {
+    [[nodiscard]] u32_le GetTipcCommand() const {
        return static_cast<u32_le>(command_header->type.Value()) -
               static_cast<u32_le>(IPC::CommandType::TIPC_CommandRegion);
    }

-    u32_le GetCommand() const {
+    [[nodiscard]] u32_le GetCommand() const {
        return command_header->IsTipc() ? GetTipcCommand() : GetHipcCommand();
    }

-    bool IsTipc() const {
+    [[nodiscard]] bool IsTipc() const {
        return command_header->IsTipc();
    }

-    IPC::CommandType GetCommandType() const {
+    [[nodiscard]] IPC::CommandType GetCommandType() const {
        return command_header->type;
    }

-    u64 GetPID() const {
+    [[nodiscard]] u64 GetPID() const {
        return pid;
    }

-    u32 GetDataPayloadOffset() const {
+    [[nodiscard]] u32 GetDataPayloadOffset() const {
        return data_payload_offset;
    }

-    const std::vector<IPC::BufferDescriptorX>& BufferDescriptorX() const {
+    [[nodiscard]] const std::vector<IPC::BufferDescriptorX>& BufferDescriptorX() const {
        return buffer_x_desciptors;
    }

-    const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorA() const {
+    [[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorA() const {
        return buffer_a_desciptors;
    }

-    const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorB() const {
+    [[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorB() const {
        return buffer_b_desciptors;
    }

-    const std::vector<IPC::BufferDescriptorC>& BufferDescriptorC() const {
+    [[nodiscard]] const std::vector<IPC::BufferDescriptorC>& BufferDescriptorC() const {
        return buffer_c_desciptors;
    }

-    const IPC::DomainMessageHeader& GetDomainMessageHeader() const {
+    [[nodiscard]] const IPC::DomainMessageHeader& GetDomainMessageHeader() const {
        return domain_message_header.value();
    }

-    bool HasDomainMessageHeader() const {
+    [[nodiscard]] bool HasDomainMessageHeader() const {
        return domain_message_header.has_value();
    }

    /// Helper function to read a buffer using the appropriate buffer descriptor
-    std::vector<u8> ReadBuffer(std::size_t buffer_index = 0) const;
+    [[nodiscard]] std::vector<u8> ReadBuffer(std::size_t buffer_index = 0) const;

    /// Helper function to write a buffer using the appropriate buffer descriptor
    std::size_t WriteBuffer(const void* buffer, std::size_t size,
@@ -308,22 +308,34 @@ public:
    }

    /// Helper function to get the size of the input buffer
-    std::size_t GetReadBufferSize(std::size_t buffer_index = 0) const;
+    [[nodiscard]] std::size_t GetReadBufferSize(std::size_t buffer_index = 0) const;

    /// Helper function to get the size of the output buffer
-    std::size_t GetWriteBufferSize(std::size_t buffer_index = 0) const;
+    [[nodiscard]] std::size_t GetWriteBufferSize(std::size_t buffer_index = 0) const;
+
+    /// Helper function to derive the number of elements able to be contained in the read buffer
+    template <typename T>
+    [[nodiscard]] std::size_t GetReadBufferNumElements(std::size_t buffer_index = 0) const {
+        return GetReadBufferSize(buffer_index) / sizeof(T);
+    }
+
+    /// Helper function to derive the number of elements able to be contained in the write buffer
+    template <typename T>
+    [[nodiscard]] std::size_t GetWriteBufferNumElements(std::size_t buffer_index = 0) const {
+        return GetWriteBufferSize(buffer_index) / sizeof(T);
+    }

    /// Helper function to test whether the input buffer at buffer_index can be read
-    bool CanReadBuffer(std::size_t buffer_index = 0) const;
+    [[nodiscard]] bool CanReadBuffer(std::size_t buffer_index = 0) const;

    /// Helper function to test whether the output buffer at buffer_index can be written
-    bool CanWriteBuffer(std::size_t buffer_index = 0) const;
+    [[nodiscard]] bool CanWriteBuffer(std::size_t buffer_index = 0) const;

-    Handle GetCopyHandle(std::size_t index) const {
+    [[nodiscard]] Handle GetCopyHandle(std::size_t index) const {
        return incoming_copy_handles.at(index);
    }

-    Handle GetMoveHandle(std::size_t index) const {
+    [[nodiscard]] Handle GetMoveHandle(std::size_t index) const {
        return incoming_move_handles.at(index);
    }

@@ -348,13 +360,13 @@ public:
        manager = manager_;
    }

-    std::string Description() const;
+    [[nodiscard]] std::string Description() const;

-    KThread& GetThread() {
+    [[nodiscard]] KThread& GetThread() {
        return *thread;
    }

-    std::shared_ptr<SessionRequestManager> GetManager() const {
+    [[nodiscard]] std::shared_ptr<SessionRequestManager> GetManager() const {
        return manager.lock();
    }

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include "core/hle/kernel/k_handle_table.h"
+#include "core/hle/kernel/k_process.h"

 namespace Kernel {

@@ -82,6 +83,22 @@ Result KHandleTable::Add(Handle* out_handle, KAutoObject* obj) {
    R_SUCCEED();
 }

+KScopedAutoObject<KAutoObject> KHandleTable::GetObjectForIpc(Handle handle,
+                                                             KThread* cur_thread) const {
+    // Handle pseudo-handles.
+    ASSERT(cur_thread != nullptr);
+    if (handle == Svc::PseudoHandle::CurrentProcess) {
+        auto* const cur_process = cur_thread->GetOwnerProcess();
+        ASSERT(cur_process != nullptr);
+        return cur_process;
+    }
+    if (handle == Svc::PseudoHandle::CurrentThread) {
+        return cur_thread;
+    }
+
+    return GetObjectForIpcWithoutPseudoHandle(handle);
+}
+
 Result KHandleTable::Reserve(Handle* out_handle) {
    KScopedDisableDispatch dd{m_kernel};
    KScopedSpinLock lk(m_lock);
@@ -113,21 +113,7 @@ public:
        return this->GetObjectImpl(handle);
    }

-    KScopedAutoObject<KAutoObject> GetObjectForIpc(Handle handle, KThread* cur_thread) const {
-        // Handle pseudo-handles.
-        ASSERT(cur_thread != nullptr);
-        if (handle == Svc::PseudoHandle::CurrentProcess) {
-            auto* const cur_process =
-                static_cast<KAutoObject*>(static_cast<void*>(cur_thread->GetOwnerProcess()));
-            ASSERT(cur_process != nullptr);
-            return cur_process;
-        }
-        if (handle == Svc::PseudoHandle::CurrentThread) {
-            return static_cast<KAutoObject*>(cur_thread);
-        }
-
-        return GetObjectForIpcWithoutPseudoHandle(handle);
-    }
+    KScopedAutoObject<KAutoObject> GetObjectForIpc(Handle handle, KThread* cur_thread) const;

    KScopedAutoObject<KAutoObject> GetObjectByIndex(Handle* out_handle, size_t index) const {
        KScopedDisableDispatch dd{m_kernel};
@@ -225,8 +225,8 @@ Result KMemoryManager::AllocatePageGroupImpl(KPageGroup* out, size_t num_pages,
    ON_RESULT_FAILURE {
        for (const auto& it : out->Nodes()) {
            auto& manager = this->GetManager(it.GetAddress());
-            const size_t node_num_pages =
-                std::min(it.GetNumPages(), (manager.GetEndAddress() - it.GetAddress()) / PageSize);
+            const size_t node_num_pages = std::min<u64>(
+                it.GetNumPages(), (manager.GetEndAddress() - it.GetAddress()) / PageSize);
            manager.Free(it.GetAddress(), node_num_pages);
        }
        out->Finalize();
@@ -6,6 +6,7 @@
 #include <atomic>

 #include "common/assert.h"
+#include "common/atomic_ops.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/spin_lock.h"
@@ -82,16 +83,13 @@ private:

 private:
    void UpdatePeakImpl(uintptr_t obj) {
-        static_assert(std::atomic_ref<uintptr_t>::is_always_lock_free);
-        std::atomic_ref<uintptr_t> peak_ref(m_peak);
-
        const uintptr_t alloc_peak = obj + this->GetObjectSize();
        uintptr_t cur_peak = m_peak;
        do {
            if (alloc_peak <= cur_peak) {
                break;
            }
-        } while (!peak_ref.compare_exchange_strong(cur_peak, alloc_peak));
+        } while (!Common::AtomicCompareAndSwap(&m_peak, alloc_peak, cur_peak, cur_peak));
    }

 public:
@@ -10,6 +10,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/intrusive_red_black_tree.h"
+#include "common/polyfill_ranges.h"
 #include "core/hle/kernel/memory_types.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/result.h"
@@ -7,6 +7,7 @@
 #include <thread>
 #include <vector>

+#include "common/polyfill_thread.h"
 #include "common/scope_exit.h"
 #include "common/thread.h"
 #include "core/hle/ipc_helpers.h"
@@ -35,14 +36,14 @@ public:

 private:
    KernelCore& kernel;
-
-    std::jthread m_host_thread;
-    std::mutex m_session_mutex;
-    std::map<KServerSession*, std::shared_ptr<SessionRequestManager>> m_sessions;
-    KEvent* m_wakeup_event;
-    KThread* m_thread;
-    std::atomic<bool> m_shutdown_requested;
    const std::string m_service_name;
+
+    std::jthread m_host_thread{};
+    std::mutex m_session_mutex{};
+    std::map<KServerSession*, std::shared_ptr<SessionRequestManager>> m_sessions{};
+    KEvent* m_wakeup_event{};
+    KThread* m_thread{};
+    std::atomic<bool> m_shutdown_requested{};
 };

 void ServiceThread::Impl::WaitAndProcessImpl() {
@@ -82,7 +82,7 @@ void SvcWrap64(Core::System& system) {
 }

 // Used by ControlCodeMemory
-template <Result func(Core::System&, Handle, u32, u64, u64, Svc::MemoryPermission)>
+template <Result func(Core::System&, Handle, u32, VAddr, size_t, Svc::MemoryPermission)>
 void SvcWrap64(Core::System& system) {
    FuncReturn(system, func(system, static_cast<Handle>(Param(system, 0)),
                            static_cast<u32>(Param(system, 1)), Param(system, 2), Param(system, 3),
@@ -327,7 +327,7 @@ void SvcWrap64(Core::System& system) {
 }

 // Used by CreateCodeMemory
-template <Result func(Core::System&, Handle*, u64, u64)>
+template <Result func(Core::System&, Handle*, VAddr, size_t)>
 void SvcWrap64(Core::System& system) {
    u32 param_1 = 0;
    const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2)).raw;
@@ -7,6 +7,7 @@
 #include "common/fs/file.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
+#include "common/polyfill_ranges.h"
 #include "common/string_util.h"
 #include "common/swap.h"
 #include "core/constants.h"
@@ -9,6 +9,7 @@
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "core/hle/service/acc/profile_manager.h"

@@ -1125,7 +1125,7 @@ void IStorageAccessor::Write(Kernel::HLERequestContext& ctx) {

    const u64 offset{rp.Pop<u64>()};
    const std::vector<u8> data{ctx.ReadBuffer()};
-    const std::size_t size{std::min(data.size(), backing.GetSize() - offset)};
+    const std::size_t size{std::min<u64>(data.size(), backing.GetSize() - offset)};

    LOG_DEBUG(Service_AM, "called, offset={}, size={}", offset, size);

@@ -1149,7 +1149,7 @@ void IStorageAccessor::Read(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};

    const u64 offset{rp.Pop<u64>()};
-    const std::size_t size{std::min(ctx.GetWriteBufferSize(), backing.GetSize() - offset)};
+    const std::size_t size{std::min<u64>(ctx.GetWriteBufferSize(), backing.GetSize() - offset)};

    LOG_DEBUG(Service_AM, "called, offset={}, size={}", offset, size);

@@ -122,10 +122,10 @@ private:
    }

    void GetReleasedAudioInBuffer(Kernel::HLERequestContext& ctx) {
-        auto write_buffer_size = ctx.GetWriteBufferSize() / sizeof(u64);
-        std::vector<u64> released_buffers(write_buffer_size, 0);
+        const auto write_buffer_size = ctx.GetWriteBufferNumElements<u64>();
+        std::vector<u64> released_buffers(write_buffer_size);

-        auto count = impl->GetReleasedBuffers(released_buffers);
+        const auto count = impl->GetReleasedBuffers(released_buffers);

        [[maybe_unused]] std::string tags{};
        for (u32 i = 0; i < count; i++) {
@@ -203,9 +203,8 @@ private:
 };

 AudInU::AudInU(Core::System& system_)
-    : ServiceFramework{system_, "audin:u", ServiceThreadType::CreateNew},
-      service_context{system_, "AudInU"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
-                                              system_)} {
+    : ServiceFramework{system_, "audin:u"}, service_context{system_, "AudInU"},
+      impl{std::make_unique<AudioCore::AudioIn::Manager>(system_)} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &AudInU::ListAudioIns, "ListAudioIns"},
@@ -228,7 +227,7 @@ void AudInU::ListAudioIns(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_Audio, "called");

    const auto write_count =
-        static_cast<u32>(ctx.GetWriteBufferSize() / sizeof(AudioDevice::AudioDeviceName));
+        static_cast<u32>(ctx.GetWriteBufferNumElements<AudioDevice::AudioDeviceName>());
    std::vector<AudioDevice::AudioDeviceName> device_names{};

    u32 out_count{0};
@@ -248,7 +247,7 @@ void AudInU::ListAudioInsAutoFiltered(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_Audio, "called");

    const auto write_count =
-        static_cast<u32>(ctx.GetWriteBufferSize() / sizeof(AudioDevice::AudioDeviceName));
+        static_cast<u32>(ctx.GetWriteBufferNumElements<AudioDevice::AudioDeviceName>());
    std::vector<AudioDevice::AudioDeviceName> device_names{};

    u32 out_count{0};
@@ -26,9 +26,8 @@ public:
    explicit IAudioOut(Core::System& system_, AudioCore::AudioOut::Manager& manager,
                       size_t session_id, const std::string& device_name,
                       const AudioOutParameter& in_params, u32 handle, u64 applet_resource_user_id)
-        : ServiceFramework{system_, "IAudioOut", ServiceThreadType::CreateNew},
-          service_context{system_, "IAudioOut"}, event{service_context.CreateEvent(
-                                                     "AudioOutEvent")},
+        : ServiceFramework{system_, "IAudioOut"}, service_context{system_, "IAudioOut"},
+          event{service_context.CreateEvent("AudioOutEvent")},
          impl{std::make_shared<AudioCore::AudioOut::Out>(system_, manager, event, session_id)} {

        // clang-format off
@@ -129,16 +128,16 @@ private:
    }

    void GetReleasedAudioOutBuffers(Kernel::HLERequestContext& ctx) {
-        auto write_buffer_size = ctx.GetWriteBufferSize() / sizeof(u64);
-        std::vector<u64> released_buffers(write_buffer_size, 0);
+        const auto write_buffer_size = ctx.GetWriteBufferNumElements<u64>();
+        std::vector<u64> released_buffers(write_buffer_size);

-        auto count = impl->GetReleasedBuffers(released_buffers);
+        const auto count = impl->GetReleasedBuffers(released_buffers);

        [[maybe_unused]] std::string tags{};
        for (u32 i = 0; i < count; i++) {
            tags += fmt::format("{:08X}, ", released_buffers[i]);
        }
-        [[maybe_unused]] auto sessionid{impl->GetSystem().GetSessionId()};
+        [[maybe_unused]] const auto sessionid{impl->GetSystem().GetSessionId()};
        LOG_TRACE(Service_Audio, "called. Session {} released {} buffers: {}", sessionid, count,
                  tags);

@@ -221,9 +220,8 @@ private:
 };

 AudOutU::AudOutU(Core::System& system_)
-    : ServiceFramework{system_, "audout:u", ServiceThreadType::CreateNew},
-      service_context{system_, "AudOutU"}, impl{std::make_unique<AudioCore::AudioOut::Manager>(
-                                               system_)} {
+    : ServiceFramework{system_, "audout:u"}, service_context{system_, "AudOutU"},
+      impl{std::make_unique<AudioCore::AudioOut::Manager>(system_)} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &AudOutU::ListAudioOuts, "ListAudioOuts"},
@@ -244,7 +242,7 @@ void AudOutU::ListAudioOuts(Kernel::HLERequestContext& ctx) {
    std::scoped_lock l{impl->mutex};

    const auto write_count =
-        static_cast<u32>(ctx.GetWriteBufferSize() / sizeof(AudioDevice::AudioDeviceName));
+        static_cast<u32>(ctx.GetWriteBufferNumElements<AudioDevice::AudioDeviceName>());
    std::vector<AudioDevice::AudioDeviceName> device_names{};
    if (write_count > 0) {
        device_names.emplace_back("DeviceOut");
@@ -14,6 +14,7 @@
 #include "common/bit_util.h"
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
+#include "common/polyfill_ranges.h"
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
@@ -34,10 +35,9 @@ public:
                            AudioCore::AudioRendererParameterInternal& params,
                            Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
                            u32 process_handle, u64 applet_resource_user_id, s32 session_id)
-        : ServiceFramework{system_, "IAudioRenderer", ServiceThreadType::CreateNew},
-          service_context{system_, "IAudioRenderer"}, rendered_event{service_context.CreateEvent(
-                                                          "IAudioRendererEvent")},
-          manager{manager_}, impl{std::make_unique<Renderer>(system_, manager, rendered_event)} {
+        : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
+          rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
+          impl{std::make_unique<Renderer>(system_, manager, rendered_event)} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &IAudioRenderer::GetSampleRate, "GetSampleRate"},
@@ -242,10 +242,8 @@ class IAudioDevice final : public ServiceFramework<IAudioDevice> {
 public:
    explicit IAudioDevice(Core::System& system_, u64 applet_resource_user_id, u32 revision,
                          u32 device_num)
-        : ServiceFramework{system_, "IAudioDevice", ServiceThreadType::CreateNew},
-          service_context{system_, "IAudioDevice"}, impl{std::make_unique<AudioDevice>(
-                                                        system_, applet_resource_user_id,
-                                                        revision)},
+        : ServiceFramework{system_, "IAudioDevice"}, service_context{system_, "IAudioDevice"},
+          impl{std::make_unique<AudioDevice>(system_, applet_resource_user_id, revision)},
          event{service_context.CreateEvent(fmt::format("IAudioDeviceEvent-{}", device_num))} {
        static const FunctionInfo functions[] = {
            {0, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceName"},
@@ -274,7 +272,7 @@ public:

 private:
    void ListAudioDeviceName(Kernel::HLERequestContext& ctx) {
-        const size_t in_count = ctx.GetWriteBufferSize() / sizeof(AudioDevice::AudioDeviceName);
+        const size_t in_count = ctx.GetWriteBufferNumElements<AudioDevice::AudioDeviceName>();

        std::vector<AudioDevice::AudioDeviceName> out_names{};

@@ -335,7 +333,7 @@ private:
    }

    void GetActiveAudioDeviceName(Kernel::HLERequestContext& ctx) {
-        const auto write_size = ctx.GetWriteBufferSize() / sizeof(char);
+        const auto write_size = ctx.GetWriteBufferSize();
        std::string out_name{"AudioTvOutput"};

        LOG_DEBUG(Service_Audio, "(STUBBED) called. Name={}", out_name);
@@ -387,7 +385,7 @@ private:
    }

    void ListAudioOutputDeviceName(Kernel::HLERequestContext& ctx) {
-        const size_t in_count = ctx.GetWriteBufferSize() / sizeof(AudioDevice::AudioDeviceName);
+        const size_t in_count = ctx.GetWriteBufferNumElements<AudioDevice::AudioDeviceName>();

        std::vector<AudioDevice::AudioDeviceName> out_names{};

@@ -420,7 +418,7 @@ private:
 };

 AudRenU::AudRenU(Core::System& system_)
-    : ServiceFramework{system_, "audren:u", ServiceThreadType::CreateNew},
+    : ServiceFramework{system_, "audren:u"},
      service_context{system_, "audren:u"}, impl{std::make_unique<Manager>(system_)} {
    // clang-format off
    static const FunctionInfo functions[] = {
--- a/Show More
+++ b/Show More