yuzu: Make unlimited frame rate non persistent between game boots

general: improve handling of system startup failure

.ci/scripts/clang/docker.sh

@@ -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

.gitmodules

@@ -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

CMakeLists.txt

@@ -3,6 +3,10 @@
 
 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")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/find-modules")
@@ -18,6 +22,8 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON
 # On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
 CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)
 
+option(ENABLE_OPENGL "Enable OpenGL" ON)
+mark_as_advanced(FORCE ENABLE_OPENGL)
 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/")
@@ -27,8 +33,6 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSV
 
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
-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)
@@ -39,16 +43,18 @@ 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}")
 
 option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ON)
 
+CMAKE_DEPENDENT_OPTION(YUZU_USE_FASTER_LD "Check if a faster linker is available" ON "NOT WIN32" OFF)
+
 if (YUZU_USE_BUNDLED_VCPKG)
     if (YUZU_TESTS)
         list(APPEND VCPKG_MANIFEST_FEATURES "yuzu-tests")
@@ -64,6 +70,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)
@@ -180,24 +201,40 @@ 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(libusb 1.0.24)
+find_package(lz4 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.4.0)
+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)
@@ -399,23 +436,13 @@ if (ENABLE_SDL2)
         set(SDL2_LIBRARY "${SDL2_PREFIX}/lib/x64/SDL2.lib" CACHE PATH "Path to SDL2 library")
         set(SDL2_DLL_DIR "${SDL2_PREFIX}/lib/x64/" CACHE PATH "Path to SDL2.dll")
 
-        add_library(SDL2 INTERFACE)
-        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARY}")
-        target_include_directories(SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
+        add_library(SDL2::SDL2 INTERFACE IMPORTED)
+        target_link_libraries(SDL2::SDL2 INTERFACE "${SDL2_LIBRARY}")
+        target_include_directories(SDL2::SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
     elseif (YUZU_USE_EXTERNAL_SDL2)
         message(STATUS "Using SDL2 from externals.")
     else()
         find_package(SDL2 2.0.18 REQUIRED)
-
-        # Some installations don't set SDL2_LIBRARIES
-        if("${SDL2_LIBRARIES}" STREQUAL "")
-            message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
-            set(SDL2_LIBRARIES "SDL2::SDL2")
-        endif()
-
-        include_directories(SYSTEM ${SDL2_INCLUDE_DIRS})
-        add_library(SDL2 INTERFACE)
-        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
     endif()
 endif()
 
@@ -427,25 +454,6 @@ if (TARGET Boost::boost)
     add_library(boost ALIAS Boost::boost)
 endif()
 
-# Ensure libusb is properly configured (based on dolphin libusb include)
-if(NOT APPLE AND 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)
-    else()
-        find_package(LibUSB)
-    endif()
-
-    if (LIBUSB_FOUND)
-        add_library(usb INTERFACE)
-        target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")
-        target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARIES}")
-    else()
-        message(WARNING "libusb not found, falling back to externals")
-        set(YUZU_USE_BUNDLED_LIBUSB ON)
-    endif()
-endif()
-
 # List of all FFmpeg components required
 set(FFmpeg_COMPONENTS
     avcodec
@@ -458,22 +466,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.
@@ -590,6 +583,21 @@ if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
     )
 endif()
 
+if (YUZU_USE_FASTER_LD AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # We will assume that if the compiler is GCC, it will attempt to use ld.bfd by default.
+    # Try to pick a faster linker.
+    find_program(LLD lld)
+    find_program(MOLD mold)
+
+    if (MOLD AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.1")
+        message(NOTICE "Selecting mold as linker")
+        add_link_options("-fuse-ld=mold")
+    elseif (LLD)
+        message(NOTICE "Selecting lld as linker")
+        add_link_options("-fuse-ld=lld")
+    endif()
+endif()
+
 enable_testing()
 add_subdirectory(externals)
 add_subdirectory(src)

externals/CMakeLists.txt

@@ -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)
@@ -45,8 +45,8 @@ if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12" AND CMAKE_CXX_COMPILER
 endif()
 
 # libusb
-if (NOT LIBUSB_FOUND OR YUZU_USE_BUNDLED_LIBUSB)
-    add_subdirectory(libusb)
+if (NOT TARGET libusb::usb)
+    add_subdirectory(libusb EXCLUDE_FROM_ALL)
 endif()
 
 # SDL2
@@ -67,30 +67,38 @@ 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)
 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)
+if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)
     if (NOT WIN32)
         find_package(OpenSSL 1.1)
         if (OPENSSL_FOUND)
@@ -118,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
@@ -140,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()

externals/find-modules/FindDiscordRPC.cmake

@@ -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
+)

externals/find-modules/FindFFmpeg.cmake

@@ -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
+)

externals/find-modules/FindLibUSB.cmake

@@ -1,44 +0,0 @@
-# SPDX-FileCopyrightText: 2009 Michal Cihar <michal@cihar.com>
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-# - Find libusb-1.0 library
-# This module defines
-#  LIBUSB_INCLUDE_DIR, where to find bluetooth.h
-#  LIBUSB_LIBRARIES, the libraries needed to use libusb-1.0.
-#  LIBUSB_FOUND, If false, do not try to use libusb-1.0.
-#
-# vim: expandtab sw=4 ts=4 sts=4:
-
-if(ANDROID)
-       set(LIBUSB_FOUND FALSE CACHE INTERNAL "libusb-1.0 found")
-       message(STATUS "libusb-1.0 not found.")
-elseif (NOT LIBUSB_FOUND)
-    pkg_check_modules (LIBUSB_PKG libusb-1.0)
-
-    find_path(LIBUSB_INCLUDE_DIR NAMES libusb.h
-       PATHS
-       ${LIBUSB_PKG_INCLUDE_DIRS}
-       /usr/include/libusb-1.0
-       /usr/include
-       /usr/local/include/libusb-1.0
-       /usr/local/include
-    )
-
-    find_library(LIBUSB_LIBRARIES NAMES usb-1.0 usb
-       PATHS
-       ${LIBUSB_PKG_LIBRARY_DIRS}
-       /usr/lib
-       /usr/local/lib
-    )
-
-    if(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-       set(LIBUSB_FOUND TRUE CACHE INTERNAL "libusb-1.0 found")
-       message(STATUS "Found libusb-1.0: ${LIBUSB_INCLUDE_DIR}, ${LIBUSB_LIBRARIES}")
-    else(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-       set(LIBUSB_FOUND FALSE CACHE INTERNAL "libusb-1.0 found")
-       message(STATUS "libusb-1.0 not found.")
-    endif(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-
-    mark_as_advanced(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARIES)
-endif ()
-

externals/find-modules/FindOpus.cmake

@@ -1,19 +1,17 @@
 # SPDX-FileCopyrightText: 2022 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-find_package(PkgConfig)
-
+find_package(PkgConfig QUIET)
 if (PKG_CONFIG_FOUND)
-    pkg_search_module(opus IMPORTED_TARGET GLOBAL opus)
-    if (opus_FOUND)
-        add_library(Opus::opus ALIAS PkgConfig::opus)
-    endif()
+    pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)
 endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Opus
-    REQUIRED_VARS
-        opus_LINK_LIBRARIES
-        opus_FOUND
-    VERSION_VAR opus_VERSION
+    REQUIRED_VARS OPUS_LINK_LIBRARIES
+    VERSION_VAR OPUS_VERSION
 )
+
+if (Opus_FOUND AND NOT TARGET Opus::opus)
+    add_library(Opus::opus ALIAS PkgConfig::OPUS)
+endif()

externals/find-modules/Findenet.cmake

@@ -0,0 +1,18 @@
+# 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 libenet)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(enet
+    REQUIRED_VARS ENET_LINK_LIBRARIES
+    VERSION_VAR ENET_VERSION
+)
+
+if (enet_FOUND AND NOT TARGET enet::enet)
+    add_library(enet::enet ALIAS PkgConfig::ENET)
+endif()

externals/find-modules/Findhttplib.cmake

@@ -0,0 +1,23 @@
+# 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 cpp-httplib)
+    endif()
+    find_package_handle_standard_args(httplib
+        REQUIRED_VARS HTTPLIB_INCLUDEDIR
+        VERSION_VAR HTTPLIB_VERSION
+    )
+endif()
+
+if (httplib_FOUND AND NOT TARGET httplib::httplib)
+    add_library(httplib::httplib ALIAS PkgConfig::HTTPLIB)
+endif()

externals/find-modules/Findinih.cmake

@@ -0,0 +1,18 @@
+# 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 INIReader)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(inih
+    REQUIRED_VARS INIREADER_LINK_LIBRARIES
+    VERSION_VAR INIREADER_VERSION
+)
+
+if (inih_FOUND AND NOT TARGET inih::INIReader)
+    add_library(inih::INIReader ALIAS PkgConfig::INIREADER)
+endif()

externals/find-modules/Findlibusb.cmake

@@ -0,0 +1,18 @@
+# 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(LIBUSB QUIET IMPORTED_TARGET libusb-1.0)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(libusb
+    REQUIRED_VARS LIBUSB_LINK_LIBRARIES
+    VERSION_VAR LIBUSB_VERSION
+)
+
+if (libusb_FOUND AND NOT TARGET libusb::usb)
+    add_library(libusb::usb ALIAS PkgConfig::LIBUSB)
+endif()

externals/find-modules/Findlz4.cmake

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

externals/find-modules/Findzstd.cmake

@@ -1,19 +1,28 @@
 # SPDX-FileCopyrightText: 2022 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-find_package(PkgConfig)
+include(FindPackageHandleStandardArgs)
 
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(libzstd IMPORTED_TARGET GLOBAL libzstd)
-    if (libzstd_FOUND)
-        add_library(zstd::zstd ALIAS PkgConfig::libzstd)
+find_package(zstd QUIET CONFIG)
+if (zstd_FOUND)
+    find_package_handle_standard_args(zstd CONFIG_MODE)
+else()
+    find_package(PkgConfig QUIET)
+    if (PKG_CONFIG_FOUND)
+        pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
     endif()
+    find_package_handle_standard_args(zstd
+        REQUIRED_VARS ZSTD_LINK_LIBRARIES
+        VERSION_VAR ZSTD_VERSION
+    )
 endif()
 
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(zstd
-    REQUIRED_VARS
-        libzstd_LINK_LIBRARIES
-        libzstd_FOUND
-    VERSION_VAR libzstd_VERSION
-)
+if (zstd_FOUND AND NOT TARGET zstd::zstd)
+    if (TARGET zstd::libzstd_shared)
+        add_library(zstd::zstd ALIAS zstd::libzstd_shared)
+    elseif (TARGET zstd::libzstd_static)
+        add_library(zstd::zstd ALIAS zstd::libzstd_static)
+    else()
+        add_library(zstd::zstd ALIAS PkgConfig::ZSTD)
+    endif()
+endif()

externals/inih/CMakeLists.txt

@@ -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)

externals/libusb/CMakeLists.txt

@@ -273,3 +273,5 @@ else() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 
     configure_file(config.h.in config.h)
 endif() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+
+add_library(libusb::usb ALIAS usb)

src/CMakeLists.txt

@@ -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)

src/audio_core/CMakeLists.txt

@@ -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,18 +219,18 @@ 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)
-    if (YUZU_USE_EXTERNAL_SDL2)
-        target_link_libraries(audio_core PRIVATE SDL2-static)
-    else()
-        target_link_libraries(audio_core PRIVATE SDL2)
-    endif()
+    target_link_libraries(audio_core PRIVATE SDL2::SDL2)
     target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()
+
+if (YUZU_USE_PRECOMPILED_HEADERS)
+    target_precompile_headers(audio_core PRIVATE precompiled_headers.h)
+endif()

src/audio_core/audio_event.cpp

@@ -3,6 +3,7 @@
 
 #include "audio_core/audio_event.h"
 #include "common/assert.h"
+#include "common/polyfill_ranges.h"
 
 namespace AudioCore {
 

src/audio_core/audio_manager.h

@@ -9,6 +9,8 @@
 #include <mutex>
 #include <thread>
 
+#include "common/polyfill_thread.h"
+
 #include "audio_core/audio_event.h"
 
 union Result;

src/audio_core/audio_render_manager.h

@@ -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"

src/audio_core/common/feature_support.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;

src/audio_core/precompiled_headers.h

@@ -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"

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

@@ -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 {
 

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

@@ -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 {
 

src/audio_core/renderer/mix/mix_context.cpp

@@ -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 {
 

src/audio_core/renderer/performance/detail_aspect.h

@@ -16,7 +16,6 @@ class CommandGenerator;
  */
 class DetailAspect {
 public:
-    DetailAspect() = default;
     DetailAspect(CommandGenerator& command_generator, PerformanceEntryType entry_type, s32 node_id,
                  PerformanceDetailType detail_type);
 

src/audio_core/renderer/performance/entry_aspect.h

@@ -16,7 +16,6 @@ class CommandGenerator;
  */
 class EntryAspect {
 public:
-    EntryAspect() = default;
     EntryAspect(CommandGenerator& command_generator, PerformanceEntryType type, s32 node_id);
 
     /// Command generator the command will be generated into

src/audio_core/renderer/voice/voice_context.cpp

@@ -4,6 +4,7 @@
 #include <ranges>
 
 #include "audio_core/renderer/voice/voice_context.h"
+#include "common/polyfill_ranges.h"
 
 namespace AudioCore::AudioRenderer {
 

src/audio_core/sink/sink_stream.cpp

@@ -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);

src/common/CMakeLists.txt

@@ -34,9 +34,8 @@ add_library(common STATIC
     bit_util.h
     cityhash.cpp
     cityhash.h
-    cache_management.cpp
-    cache_management.h
     common_funcs.h
+    common_precompiled_headers.h
     common_types.h
     concepts.h
     div_ceil.h
@@ -95,6 +94,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 +147,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 +172,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()

src/common/cache_management.cpp

@@ -1,59 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <cstdint>
-#include <cstring>
-
-#include "common/cache_management.h"
-
-namespace Common {
-
-#if defined(ARCHITECTURE_x86_64)
-
-// Most cache operations are no-ops on x86
-
-void DataCacheLineCleanByVAToPoU(void* start, size_t size) {}
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size) {}
-void DataCacheLineCleanByVAToPoC(void* start, size_t size) {}
-void DataCacheZeroByVA(void* start, size_t size) {
-    std::memset(start, 0, size);
-}
-
-#elif defined(ARCHITECTURE_arm64)
-
-// BS/DminLine is log2(cache size in words), we want size in bytes
-#define EXTRACT_DMINLINE(ctr_el0) (1 << ((((ctr_el0) >> 16) & 0xf) + 2))
-#define EXTRACT_BS(dczid_el0) (1 << (((dczid_el0)&0xf) + 2))
-
-#define DEFINE_DC_OP(op_name, function_name)                                                       \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t ctr_el0;                                                                            \
-        asm volatile("mrs %[ctr_el0], ctr_el0\n\t" : [ctr_el0] "=r"(ctr_el0));                     \
-        size_t cacheline_size = EXTRACT_DMINLINE(ctr_el0);                                         \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-#define DEFINE_DC_OP_DCZID(op_name, function_name)                                                 \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t dczid_el0;                                                                          \
-        asm volatile("mrs %[dczid_el0], dczid_el0\n\t" : [dczid_el0] "=r"(dczid_el0));             \
-        size_t cacheline_size = EXTRACT_BS(dczid_el0);                                             \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-DEFINE_DC_OP(cvau, DataCacheLineCleanByVAToPoU);
-DEFINE_DC_OP(civac, DataCacheLineCleanAndInvalidateByVAToPoC);
-DEFINE_DC_OP(cvac, DataCacheLineCleanByVAToPoC);
-DEFINE_DC_OP_DCZID(zva, DataCacheZeroByVA);
-
-#endif
-
-} // namespace Common

src/common/cache_management.h

@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <cstddef>
-
-namespace Common {
-
-// Data cache instructions enabled at EL0 by SCTLR_EL1.UCI.
-// VA = virtual address
-// PoC = point of coherency
-// PoU = point of unification
-
-// dc cvau
-void DataCacheLineCleanByVAToPoU(void* start, size_t size);
-
-// dc civac
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size);
-
-// dc cvac
-void DataCacheLineCleanByVAToPoC(void* start, size_t size);
-
-// dc zva
-void DataCacheZeroByVA(void* start, size_t size);
-
-} // namespace Common

src/common/common_precompiled_headers.h

@@ -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"

src/common/fs/file.cpp

@@ -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"

src/common/fs/fs_util.cpp

@@ -4,6 +4,7 @@
 #include <algorithm>
 
 #include "common/fs/fs_util.h"
+#include "common/polyfill_ranges.h"
 
 namespace Common::FS {
 

src/common/fs/path_util.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
+#include <sstream>
 #include <unordered_map>
 
 #include "common/fs/fs.h"

src/common/input.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"

src/common/logging/backend.cpp

@@ -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"

src/common/polyfill_ranges.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

src/common/polyfill_thread.h

@@ -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

src/common/precompiled_headers.h

@@ -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"

src/common/settings.h

@@ -19,6 +19,7 @@ namespace Settings {
 enum class RendererBackend : u32 {
     OpenGL = 0,
     Vulkan = 1,
+    Null = 2,
 };
 
 enum class ShaderBackend : u32 {
@@ -75,7 +76,8 @@ enum class ScalingFilter : u32 {
 enum class AntiAliasing : u32 {
     None = 0,
     Fxaa = 1,
-    LastAA = Fxaa,
+    Smaa = 2,
+    LastAA = Smaa,
 };
 
 struct ResolutionScalingInfo {
@@ -399,6 +401,7 @@ struct Values {
     Setting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
     Setting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"};
     Setting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"};
+    Setting<bool> cpuopt_ignore_memory_aborts{true, "cpuopt_ignore_memory_aborts"};
 
     SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
     SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
@@ -411,7 +414,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"};

src/common/settings_input.h

@@ -391,6 +391,7 @@ struct PlayerInput {
     u32 body_color_right;
     u32 button_color_left;
     u32 button_color_right;
+    std::string profile_name;
 };
 
 struct TouchscreenInput {

src/common/string_util.cpp

@@ -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');

src/common/thread.h

@@ -11,6 +11,7 @@
 #include <mutex>
 #include <thread>
 #include "common/common_types.h"
+#include "common/polyfill_thread.h"
 
 namespace Common {
 
@@ -69,7 +70,7 @@ public:
     explicit Barrier(std::size_t count_) : count(count_) {}
 
     /// Blocks until all "count" threads have called Sync()
-    void Sync() {
+    bool Sync(std::stop_token token = {}) {
         std::unique_lock lk{mutex};
         const std::size_t current_generation = generation;
 
@@ -77,14 +78,16 @@ public:
             generation++;
             waiting = 0;
             condvar.notify_all();
+            return true;
         } else {
-            condvar.wait(lk,
-                         [this, current_generation] { return current_generation != generation; });
+            CondvarWait(condvar, lk, token,
+                        [this, current_generation] { return current_generation != generation; });
+            return !token.stop_requested();
         }
     }
 
 private:
-    std::condition_variable condvar;
+    std::condition_variable_any condvar;
     std::mutex mutex;
     std::size_t count;
     std::size_t waiting = 0;

src/common/thread_worker.h

@@ -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;
                         }

src/common/threadsafe_queue.h

@@ -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{};

src/core/CMakeLists.txt

@@ -528,6 +528,8 @@ add_library(core STATIC
     hle/service/mnpp/mnpp_app.h
     hle/service/ncm/ncm.cpp
     hle/service/ncm/ncm.h
+    hle/service/nfc/mifare_user.cpp
+    hle/service/nfc/mifare_user.h
     hle/service/nfc/nfc.cpp
     hle/service/nfc/nfc.h
     hle/service/nfc/nfc_device.cpp
@@ -771,6 +773,7 @@ add_library(core STATIC
     memory.h
     perf_stats.cpp
     perf_stats.h
+    precompiled_headers.h
     reporter.cpp
     reporter.h
     telemetry_session.cpp
@@ -823,5 +826,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()

src/core/arm/arm_interface.cpp

@@ -145,11 +145,15 @@ void ARM_Interface::Run() {
         // Notify the debugger and go to sleep if a breakpoint was hit,
         // or if the thread is unable to continue for any reason.
         if (Has(hr, breakpoint) || Has(hr, no_execute)) {
-            RewindBreakpointInstruction();
+            if (!Has(hr, no_execute)) {
+                RewindBreakpointInstruction();
+            }
             if (system.DebuggerEnabled()) {
                 system.GetDebugger().NotifyThreadStopped(current_thread);
+            } else {
+                LogBacktrace();
             }
-            current_thread->RequestSuspend(Kernel::SuspendType::Debug);
+            current_thread->RequestSuspend(SuspendType::Debug);
             break;
         }
 

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -29,7 +29,9 @@ class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
     explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_)
         : parent{parent_},
-          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()} {}
+          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()},
+          check_memory_access{debugger_enabled ||
+                              !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
 
     u8 MemoryRead8(u32 vaddr) override {
         CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
@@ -154,6 +156,17 @@ public:
     }
 
     bool CheckMemoryAccess(VAddr addr, u64 size, Kernel::DebugWatchpointType type) {
+        if (!check_memory_access) {
+            return true;
+        }
+
+        if (!memory.IsValidVirtualAddressRange(addr, size)) {
+            LOG_CRITICAL(Core_ARM, "Stopping execution due to unmapped memory access at {:#x}",
+                         addr);
+            parent.jit.load()->HaltExecution(ARM_Interface::no_execute);
+            return false;
+        }
+
         if (!debugger_enabled) {
             return true;
         }
@@ -181,7 +194,8 @@ public:
     ARM_Dynarmic_32& parent;
     Core::Memory::Memory& memory;
     std::size_t num_interpreted_instructions{};
-    bool debugger_enabled{};
+    const bool debugger_enabled{};
+    const bool check_memory_access{};
     static constexpr u64 minimum_run_cycles = 10000U;
 };
 
@@ -264,6 +278,9 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_recompile_exclusives) {
             config.recompile_on_exclusive_fastmem_failure = false;
         }
+        if (!Settings::values.cpuopt_ignore_memory_aborts) {
+            config.check_halt_on_memory_access = true;
+        }
     } else {
         // Unsafe optimizations
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -29,7 +29,9 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
     explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_)
         : parent{parent_},
-          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()} {}
+          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()},
+          check_memory_access{debugger_enabled ||
+                              !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
 
     u8 MemoryRead8(u64 vaddr) override {
         CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
@@ -198,6 +200,17 @@ public:
     }
 
     bool CheckMemoryAccess(VAddr addr, u64 size, Kernel::DebugWatchpointType type) {
+        if (!check_memory_access) {
+            return true;
+        }
+
+        if (!memory.IsValidVirtualAddressRange(addr, size)) {
+            LOG_CRITICAL(Core_ARM, "Stopping execution due to unmapped memory access at {:#x}",
+                         addr);
+            parent.jit.load()->HaltExecution(ARM_Interface::no_execute);
+            return false;
+        }
+
         if (!debugger_enabled) {
             return true;
         }
@@ -226,7 +239,8 @@ public:
     Core::Memory::Memory& memory;
     u64 tpidrro_el0 = 0;
     u64 tpidr_el0 = 0;
-    bool debugger_enabled{};
+    const bool debugger_enabled{};
+    const bool check_memory_access{};
     static constexpr u64 minimum_run_cycles = 10000U;
 };
 
@@ -323,6 +337,9 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_recompile_exclusives) {
             config.recompile_on_exclusive_fastmem_failure = false;
         }
+        if (!Settings::values.cpuopt_ignore_memory_aborts) {
+            config.check_halt_on_memory_access = true;
+        }
     } else {
         // Unsafe optimizations
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {

src/core/core.cpp

@@ -389,7 +389,9 @@ struct System::Impl {
         kernel.ShutdownCores();
         cpu_manager.Shutdown();
         debugger.reset();
-        services->KillNVNFlinger();
+        if (services) {
+            services->KillNVNFlinger();
+        }
         kernel.CloseServices();
         services.reset();
         service_manager.reset();

src/core/cpu_manager.cpp

@@ -20,23 +20,20 @@ namespace Core {
 CpuManager::CpuManager(System& system_) : system{system_} {}
 CpuManager::~CpuManager() = default;
 
-void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
-                             std::size_t core) {
-    cpu_manager.RunThread(core);
-}
-
 void CpuManager::Initialize() {
     num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1;
     gpu_barrier = std::make_unique<Common::Barrier>(num_cores + 1);
 
     for (std::size_t core = 0; core < num_cores; core++) {
-        core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
+        core_data[core].host_thread =
+            std::jthread([this, core](std::stop_token token) { RunThread(token, core); });
     }
 }
 
 void CpuManager::Shutdown() {
     for (std::size_t core = 0; core < num_cores; core++) {
         if (core_data[core].host_thread.joinable()) {
+            core_data[core].host_thread.request_stop();
             core_data[core].host_thread.join();
         }
     }
@@ -184,7 +181,7 @@ void CpuManager::ShutdownThread() {
     UNREACHABLE();
 }
 
-void CpuManager::RunThread(std::size_t core) {
+void CpuManager::RunThread(std::stop_token token, std::size_t core) {
     /// Initialization
     system.RegisterCoreThread(core);
     std::string name;
@@ -206,7 +203,9 @@ void CpuManager::RunThread(std::size_t core) {
     });
 
     // Running
-    gpu_barrier->Sync();
+    if (!gpu_barrier->Sync(token)) {
+        return;
+    }
 
     if (!is_async_gpu && !is_multicore) {
         system.GPU().ObtainContext();

src/core/cpu_manager.h

@@ -10,6 +10,7 @@
 #include <thread>
 
 #include "common/fiber.h"
+#include "common/polyfill_thread.h"
 #include "common/thread.h"
 #include "core/hardware_properties.h"
 
@@ -80,12 +81,10 @@ private:
     void SingleCoreRunGuestThread();
     void SingleCoreRunIdleThread();
 
-    static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);
-
     void GuestActivate();
     void HandleInterrupt();
     void ShutdownThread();
-    void RunThread(std::size_t core);
+    void RunThread(std::stop_token stop_token, std::size_t core);
 
     struct CoreData {
         std::shared_ptr<Common::Fiber> host_context;

src/core/debugger/debugger.cpp

@@ -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"

src/core/file_sys/content_archive.cpp

@@ -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"

src/core/frontend/applets/controller.cpp

@@ -16,7 +16,7 @@ DefaultControllerApplet::DefaultControllerApplet(HID::HIDCore& hid_core_) : hid_
 
 DefaultControllerApplet::~DefaultControllerApplet() = default;
 
-void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callback,
+void DefaultControllerApplet::ReconfigureControllers(ReconfigureCallback callback,
                                                      const ControllerParameters& parameters) const {
     LOG_INFO(Service_HID, "called, deducing the best configuration based on the given parameters!");
 

src/core/frontend/applets/controller.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <functional>
+#include <vector>
 
 #include "common/common_types.h"
 
@@ -35,9 +36,11 @@ struct ControllerParameters {
 
 class ControllerApplet {
 public:
+    using ReconfigureCallback = std::function<void()>;
+
     virtual ~ControllerApplet();
 
-    virtual void ReconfigureControllers(std::function<void()> callback,
+    virtual void ReconfigureControllers(ReconfigureCallback callback,
                                         const ControllerParameters& parameters) const = 0;
 };
 
@@ -46,7 +49,7 @@ public:
     explicit DefaultControllerApplet(HID::HIDCore& hid_core_);
     ~DefaultControllerApplet() override;
 
-    void ReconfigureControllers(std::function<void()> callback,
+    void ReconfigureControllers(ReconfigureCallback callback,
                                 const ControllerParameters& parameters) const override;
 
 private:

src/core/frontend/applets/error.cpp

@@ -8,13 +8,13 @@ namespace Core::Frontend {
 
 ErrorApplet::~ErrorApplet() = default;
 
-void DefaultErrorApplet::ShowError(Result error, std::function<void()> finished) const {
+void DefaultErrorApplet::ShowError(Result error, FinishedCallback finished) const {
     LOG_CRITICAL(Service_Fatal, "Application requested error display: {:04}-{:04} (raw={:08X})",
                  error.module.Value(), error.description.Value(), error.raw);
 }
 
 void DefaultErrorApplet::ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
-                                                std::function<void()> finished) const {
+                                                FinishedCallback finished) const {
     LOG_CRITICAL(
         Service_Fatal,
         "Application requested error display: {:04X}-{:04X} (raw={:08X}) with timestamp={:016X}",
@@ -23,7 +23,7 @@ void DefaultErrorApplet::ShowErrorWithTimestamp(Result error, std::chrono::secon
 
 void DefaultErrorApplet::ShowCustomErrorText(Result error, std::string main_text,
                                              std::string detail_text,
-                                             std::function<void()> finished) const {
+                                             FinishedCallback finished) const {
     LOG_CRITICAL(Service_Fatal,
                  "Application requested custom error with error_code={:04X}-{:04X} (raw={:08X})",
                  error.module.Value(), error.description.Value(), error.raw);

src/core/frontend/applets/error.h

@@ -12,25 +12,27 @@ namespace Core::Frontend {
 
 class ErrorApplet {
 public:
+    using FinishedCallback = std::function<void()>;
+
     virtual ~ErrorApplet();
 
-    virtual void ShowError(Result error, std::function<void()> finished) const = 0;
+    virtual void ShowError(Result error, FinishedCallback finished) const = 0;
 
     virtual void ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
-                                        std::function<void()> finished) const = 0;
+                                        FinishedCallback finished) const = 0;
 
     virtual void ShowCustomErrorText(Result error, std::string dialog_text,
                                      std::string fullscreen_text,
-                                     std::function<void()> finished) const = 0;
+                                     FinishedCallback finished) const = 0;
 };
 
 class DefaultErrorApplet final : public ErrorApplet {
 public:
-    void ShowError(Result error, std::function<void()> finished) const override;
+    void ShowError(Result error, FinishedCallback finished) const override;
     void ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
-                                std::function<void()> finished) const override;
+                                FinishedCallback finished) const override;
     void ShowCustomErrorText(Result error, std::string main_text, std::string detail_text,
-                             std::function<void()> finished) const override;
+                             FinishedCallback finished) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/mii_edit.cpp

@@ -8,7 +8,7 @@ namespace Core::Frontend {
 
 MiiEditApplet::~MiiEditApplet() = default;
 
-void DefaultMiiEditApplet::ShowMiiEdit(const std::function<void()>& callback) const {
+void DefaultMiiEditApplet::ShowMiiEdit(const MiiEditCallback& callback) const {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
     callback();

src/core/frontend/applets/mii_edit.h

@@ -9,14 +9,16 @@ namespace Core::Frontend {
 
 class MiiEditApplet {
 public:
+    using MiiEditCallback = std::function<void()>;
+
     virtual ~MiiEditApplet();
 
-    virtual void ShowMiiEdit(const std::function<void()>& callback) const = 0;
+    virtual void ShowMiiEdit(const MiiEditCallback& callback) const = 0;
 };
 
 class DefaultMiiEditApplet final : public MiiEditApplet {
 public:
-    void ShowMiiEdit(const std::function<void()>& callback) const override;
+    void ShowMiiEdit(const MiiEditCallback& callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/profile_select.cpp

@@ -9,8 +9,7 @@ namespace Core::Frontend {
 
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
-void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Common::UUID>)> callback) const {
+void DefaultProfileSelectApplet::SelectProfile(SelectProfileCallback callback) const {
     Service::Account::ProfileManager manager;
     callback(manager.GetUser(Settings::values.current_user.GetValue()).value_or(Common::UUID{}));
     LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");

src/core/frontend/applets/profile_select.h

@@ -11,14 +11,16 @@ namespace Core::Frontend {
 
 class ProfileSelectApplet {
 public:
+    using SelectProfileCallback = std::function<void(std::optional<Common::UUID>)>;
+
     virtual ~ProfileSelectApplet();
 
-    virtual void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const = 0;
+    virtual void SelectProfile(SelectProfileCallback callback) const = 0;
 };
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
-    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
+    void SelectProfile(SelectProfileCallback callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/software_keyboard.cpp

@@ -15,10 +15,7 @@ DefaultSoftwareKeyboardApplet::~DefaultSoftwareKeyboardApplet() = default;
 
 void DefaultSoftwareKeyboardApplet::InitializeKeyboard(
     bool is_inline, KeyboardInitializeParameters initialize_parameters,
-    std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-        submit_normal_callback_,
-    std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
-        submit_inline_callback_) {
+    SubmitNormalCallback submit_normal_callback_, SubmitInlineCallback submit_inline_callback_) {
     if (is_inline) {
         LOG_WARNING(
             Service_AM,

src/core/frontend/applets/software_keyboard.h

@@ -54,14 +54,17 @@ struct InlineTextParameters {
 
 class SoftwareKeyboardApplet {
 public:
+    using SubmitInlineCallback =
+        std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>;
+    using SubmitNormalCallback =
+        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>;
+
     virtual ~SoftwareKeyboardApplet();
 
-    virtual void InitializeKeyboard(
-        bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-            submit_normal_callback_,
-        std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
-            submit_inline_callback_) = 0;
+    virtual void InitializeKeyboard(bool is_inline,
+                                    KeyboardInitializeParameters initialize_parameters,
+                                    SubmitNormalCallback submit_normal_callback_,
+                                    SubmitInlineCallback submit_inline_callback_) = 0;
 
     virtual void ShowNormalKeyboard() const = 0;
 
@@ -81,12 +84,9 @@ class DefaultSoftwareKeyboardApplet final : public SoftwareKeyboardApplet {
 public:
     ~DefaultSoftwareKeyboardApplet() override;
 
-    void InitializeKeyboard(
-        bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-            submit_normal_callback_,
-        std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
-            submit_inline_callback_) override;
+    void InitializeKeyboard(bool is_inline, KeyboardInitializeParameters initialize_parameters,
+                            SubmitNormalCallback submit_normal_callback_,
+                            SubmitInlineCallback submit_inline_callback_) override;
 
     void ShowNormalKeyboard() const override;
 
@@ -105,12 +105,10 @@ private:
     void SubmitNormalText(std::u16string text) const;
     void SubmitInlineText(std::u16string_view text) const;
 
-    KeyboardInitializeParameters parameters;
+    KeyboardInitializeParameters parameters{};
 
-    mutable std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-        submit_normal_callback;
-    mutable std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
-        submit_inline_callback;
+    mutable SubmitNormalCallback submit_normal_callback;
+    mutable SubmitInlineCallback submit_inline_callback;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/web_browser.cpp

@@ -10,18 +10,17 @@ WebBrowserApplet::~WebBrowserApplet() = default;
 
 DefaultWebBrowserApplet::~DefaultWebBrowserApplet() = default;
 
-void DefaultWebBrowserApplet::OpenLocalWebPage(
-    const std::string& local_url, std::function<void()> extract_romfs_callback,
-    std::function<void(Service::AM::Applets::WebExitReason, std::string)> callback) const {
+void DefaultWebBrowserApplet::OpenLocalWebPage(const std::string& local_url,
+                                               ExtractROMFSCallback extract_romfs_callback,
+                                               OpenWebPageCallback callback) const {
     LOG_WARNING(Service_AM, "(STUBBED) called, backend requested to open local web page at {}",
                 local_url);
 
     callback(Service::AM::Applets::WebExitReason::WindowClosed, "http://localhost/");
 }
 
-void DefaultWebBrowserApplet::OpenExternalWebPage(
-    const std::string& external_url,
-    std::function<void(Service::AM::Applets::WebExitReason, std::string)> callback) const {
+void DefaultWebBrowserApplet::OpenExternalWebPage(const std::string& external_url,
+                                                  OpenWebPageCallback callback) const {
     LOG_WARNING(Service_AM, "(STUBBED) called, backend requested to open external web page at {}",
                 external_url);
 

src/core/frontend/applets/web_browser.h

@@ -11,29 +11,29 @@ namespace Core::Frontend {
 
 class WebBrowserApplet {
 public:
+    using ExtractROMFSCallback = std::function<void()>;
+    using OpenWebPageCallback =
+        std::function<void(Service::AM::Applets::WebExitReason, std::string)>;
+
     virtual ~WebBrowserApplet();
 
-    virtual void OpenLocalWebPage(
-        const std::string& local_url, std::function<void()> extract_romfs_callback,
-        std::function<void(Service::AM::Applets::WebExitReason, std::string)> callback) const = 0;
+    virtual void OpenLocalWebPage(const std::string& local_url,
+                                  ExtractROMFSCallback extract_romfs_callback,
+                                  OpenWebPageCallback callback) const = 0;
 
-    virtual void OpenExternalWebPage(
-        const std::string& external_url,
-        std::function<void(Service::AM::Applets::WebExitReason, std::string)> callback) const = 0;
+    virtual void OpenExternalWebPage(const std::string& external_url,
+                                     OpenWebPageCallback callback) const = 0;
 };
 
 class DefaultWebBrowserApplet final : public WebBrowserApplet {
 public:
     ~DefaultWebBrowserApplet() override;
 
-    void OpenLocalWebPage(const std::string& local_url,
-                          std::function<void()> extract_romfs_callback,
-                          std::function<void(Service::AM::Applets::WebExitReason, std::string)>
-                              callback) const override;
+    void OpenLocalWebPage(const std::string& local_url, ExtractROMFSCallback extract_romfs_callback,
+                          OpenWebPageCallback callback) const override;
 
     void OpenExternalWebPage(const std::string& external_url,
-                             std::function<void(Service::AM::Applets::WebExitReason, std::string)>
-                                 callback) const override;
+                             OpenWebPageCallback callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/emu_window.h

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

src/core/hid/emulated_console.cpp

@@ -37,7 +37,7 @@ void EmulatedConsole::SetTouchParams() {
         touchscreen_param.Set("axis_x", i * 2);
         touchscreen_param.Set("axis_y", (i * 2) + 1);
         touchscreen_param.Set("button", i);
-        touch_params[index++] = touchscreen_param;
+        touch_params[index++] = std::move(touchscreen_param);
     }
 
     const auto button_index =
@@ -59,7 +59,7 @@ void EmulatedConsole::SetTouchParams() {
         touch_button_params.Set("button", params.Serialize());
         touch_button_params.Set("x", x);
         touch_button_params.Set("y", y);
-        touch_params[index] = touch_button_params;
+        touch_params[index] = std::move(touch_button_params);
         index++;
     }
 }
@@ -131,7 +131,7 @@ Common::ParamPackage EmulatedConsole::GetMotionParam() const {
 }
 
 void EmulatedConsole::SetMotionParam(Common::ParamPackage param) {
-    motion_params = param;
+    motion_params = std::move(param);
     ReloadInput();
 }
 
@@ -199,7 +199,7 @@ void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, st
 
     if (is_new_input) {
         touch_value.pressed.value = true;
-        touch_value.id = static_cast<u32>(index);
+        touch_value.id = static_cast<int>(index);
     }
 
     touch_value.x = touch_input.x;
@@ -284,7 +284,7 @@ void EmulatedConsole::TriggerOnChange(ConsoleTriggerType type) {
 
 int EmulatedConsole::SetCallback(ConsoleUpdateCallback update_callback) {
     std::scoped_lock lock{callback_mutex};
-    callback_list.insert_or_assign(last_callback_key, update_callback);
+    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
     return last_callback_key++;
 }
 

src/core/hid/emulated_controller.cpp

@@ -3,6 +3,7 @@
 
 #include <algorithm>
 
+#include "common/polyfill_ranges.h"
 #include "common/thread.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/input_converter.h"
@@ -109,10 +110,9 @@ void EmulatedController::ReloadFromSettings() {
         original_npad_type = npad_type;
     }
 
+    Disconnect();
     if (player.connected) {
         Connect();
-    } else {
-        Disconnect();
     }
 
     ReloadInput();
@@ -424,15 +424,14 @@ void EmulatedController::RestoreConfig() {
     ReloadFromSettings();
 }
 
-std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices(
-    EmulatedDeviceIndex device_index) const {
+std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices() const {
     std::vector<Common::ParamPackage> devices;
     for (const auto& param : button_params) {
         if (!param.Has("engine")) {
             continue;
         }
         const auto devices_it = std::find_if(
-            devices.begin(), devices.end(), [param](const Common::ParamPackage param_) {
+            devices.begin(), devices.end(), [&param](const Common::ParamPackage& param_) {
                 return param.Get("engine", "") == param_.Get("engine", "") &&
                        param.Get("guid", "") == param_.Get("guid", "") &&
                        param.Get("port", 0) == param_.Get("port", 0) &&
@@ -441,12 +440,12 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices(
         if (devices_it != devices.end()) {
             continue;
         }
-        Common::ParamPackage device{};
+
+        auto& device = devices.emplace_back();
         device.Set("engine", param.Get("engine", ""));
         device.Set("guid", param.Get("guid", ""));
         device.Set("port", param.Get("port", 0));
         device.Set("pad", param.Get("pad", 0));
-        devices.push_back(device);
     }
 
     for (const auto& param : stick_params) {
@@ -457,7 +456,7 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices(
             continue;
         }
         const auto devices_it = std::find_if(
-            devices.begin(), devices.end(), [param](const Common::ParamPackage param_) {
+            devices.begin(), devices.end(), [&param](const Common::ParamPackage& param_) {
                 return param.Get("engine", "") == param_.Get("engine", "") &&
                        param.Get("guid", "") == param_.Get("guid", "") &&
                        param.Get("port", 0) == param_.Get("port", 0) &&
@@ -466,12 +465,12 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices(
         if (devices_it != devices.end()) {
             continue;
         }
-        Common::ParamPackage device{};
+
+        auto& device = devices.emplace_back();
         device.Set("engine", param.Get("engine", ""));
         device.Set("guid", param.Get("guid", ""));
         device.Set("port", param.Get("port", 0));
         device.Set("pad", param.Get("pad", 0));
-        devices.push_back(device);
     }
     return devices;
 }

src/core/hid/emulated_controller.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <mutex>
 #include <unordered_map>
+#include <vector>
 
 #include "common/common_types.h"
 #include "common/input.h"
@@ -243,7 +244,7 @@ public:
     void RestoreConfig();
 
     /// Returns a vector of mapped devices from the mapped button and stick parameters
-    std::vector<Common::ParamPackage> GetMappedDevices(EmulatedDeviceIndex device_index) const;
+    std::vector<Common::ParamPackage> GetMappedDevices() const;
 
     // Returns the current mapped button device
     Common::ParamPackage GetButtonParam(std::size_t index) const;

src/core/hid/emulated_devices.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <mutex>
 #include <unordered_map>
+#include <vector>
 
 #include "common/common_types.h"
 #include "common/input.h"

src/core/hle/kernel/k_memory_block.h

@@ -280,18 +280,19 @@ struct KMemoryInfo {
 
 class KMemoryBlock : public Common::IntrusiveRedBlackTreeBaseNode<KMemoryBlock> {
 private:
-    u16 m_device_disable_merge_left_count;
-    u16 m_device_disable_merge_right_count;
-    VAddr m_address;
-    size_t m_num_pages;
-    KMemoryState m_memory_state;
-    u16 m_ipc_lock_count;
-    u16 m_device_use_count;
-    u16 m_ipc_disable_merge_count;
-    KMemoryPermission m_permission;
-    KMemoryPermission m_original_permission;
-    KMemoryAttribute m_attribute;
-    KMemoryBlockDisableMergeAttribute m_disable_merge_attribute;
+    u16 m_device_disable_merge_left_count{};
+    u16 m_device_disable_merge_right_count{};
+    VAddr m_address{};
+    size_t m_num_pages{};
+    KMemoryState m_memory_state{KMemoryState::None};
+    u16 m_ipc_lock_count{};
+    u16 m_device_use_count{};
+    u16 m_ipc_disable_merge_count{};
+    KMemoryPermission m_permission{KMemoryPermission::None};
+    KMemoryPermission m_original_permission{KMemoryPermission::None};
+    KMemoryAttribute m_attribute{KMemoryAttribute::None};
+    KMemoryBlockDisableMergeAttribute m_disable_merge_attribute{
+        KMemoryBlockDisableMergeAttribute::None};
 
 public:
     static constexpr int Compare(const KMemoryBlock& lhs, const KMemoryBlock& rhs) {
@@ -367,12 +368,8 @@ public:
 
     constexpr KMemoryBlock(VAddr addr, size_t np, KMemoryState ms, KMemoryPermission p,
                            KMemoryAttribute attr)
-        : Common::IntrusiveRedBlackTreeBaseNode<KMemoryBlock>(),
-          m_device_disable_merge_left_count(), m_device_disable_merge_right_count(),
-          m_address(addr), m_num_pages(np), m_memory_state(ms), m_ipc_lock_count(0),
-          m_device_use_count(0), m_ipc_disable_merge_count(), m_permission(p),
-          m_original_permission(KMemoryPermission::None), m_attribute(attr),
-          m_disable_merge_attribute() {}
+        : Common::IntrusiveRedBlackTreeBaseNode<KMemoryBlock>(), m_address(addr), m_num_pages(np),
+          m_memory_state(ms), m_permission(p), m_attribute(attr) {}
 
     constexpr void Initialize(VAddr addr, size_t np, KMemoryState ms, KMemoryPermission p,
                               KMemoryAttribute attr) {

src/core/hle/kernel/k_memory_block_manager.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <array>
 #include <functional>
 
 #include "common/common_funcs.h"
@@ -17,9 +18,9 @@ public:
     static constexpr size_t MaxBlocks = 2;
 
 private:
-    KMemoryBlock* m_blocks[MaxBlocks];
-    size_t m_index;
-    KMemoryBlockSlabManager* m_slab_manager;
+    std::array<KMemoryBlock*, MaxBlocks> m_blocks{};
+    size_t m_index{MaxBlocks};
+    KMemoryBlockSlabManager* m_slab_manager{};
 
 private:
     Result Initialize(size_t num_blocks) {
@@ -41,7 +42,7 @@ private:
 public:
     KMemoryBlockManagerUpdateAllocator(Result* out_result, KMemoryBlockSlabManager* sm,
                                        size_t num_blocks = MaxBlocks)
-        : m_blocks(), m_index(MaxBlocks), m_slab_manager(sm) {
+        : m_slab_manager(sm) {
         *out_result = this->Initialize(num_blocks);
     }
 

src/core/hle/kernel/k_memory_manager.cpp

@@ -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();

src/core/hle/kernel/k_shared_memory.h

@@ -74,7 +74,7 @@ public:
     static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
 
 private:
-    Core::DeviceMemory* device_memory;
+    Core::DeviceMemory* device_memory{};
     KProcess* owner_process{};
     KPageGroup page_list;
     Svc::MemoryPermission owner_permission{};

src/core/hle/kernel/k_slab_heap.h

@@ -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:

src/core/hle/kernel/k_thread.h

@@ -784,8 +784,8 @@ private:
     std::vector<KSynchronizationObject*> wait_objects_for_debugging;
     VAddr mutex_wait_address_for_debugging{};
     ThreadWaitReasonForDebugging wait_reason_for_debugging{};
-    uintptr_t argument;
-    VAddr stack_top;
+    uintptr_t argument{};
+    VAddr stack_top{};
 
 public:
     using ConditionVariableThreadTreeType = ConditionVariableThreadTree;

src/core/hle/kernel/k_thread_local_page.h

@@ -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"

src/core/hle/kernel/kernel.cpp

@@ -104,12 +104,16 @@ struct KernelCore::Impl {
     }
 
     void CloseCurrentProcess() {
-        (*current_process).Finalize();
-        // current_process->Close();
-        // TODO: The current process should be destroyed based on accurate ref counting after
+        KProcess* old_process = current_process.exchange(nullptr);
+        if (old_process == nullptr) {
+            return;
+        }
+
+        // old_process->Close();
+        // TODO: The process should be destroyed based on accurate ref counting after
         // calling Close(). Adding a manual Destroy() call instead to avoid a memory leak.
-        (*current_process).Destroy();
-        current_process = nullptr;
+        old_process->Finalize();
+        old_process->Destroy();
     }
 
     void Shutdown() {
@@ -891,7 +895,7 @@ struct KernelCore::Impl {
     Common::ThreadWorker service_threads_manager;
     Common::Barrier service_thread_barrier;
 
-    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads;
+    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads{};
     std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
 
     bool is_multicore{};

src/core/hle/kernel/physical_core.h

@@ -85,7 +85,7 @@ private:
     std::mutex guard;
     std::condition_variable on_interrupt;
     std::unique_ptr<Core::ARM_Interface> arm_interface;
-    bool is_interrupted;
+    bool is_interrupted{};
 };
 
 } // namespace Kernel

src/core/hle/kernel/service_thread.cpp

@@ -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() {
@@ -162,9 +163,6 @@ ServiceThread::Impl::~Impl() {
     m_wakeup_event->Signal();
     m_host_thread.join();
 
-    // Lock mutex.
-    m_session_mutex.lock();
-
     // Close all remaining sessions.
     for (const auto& [server_session, manager] : m_sessions) {
         server_session->Close();

src/core/hle/kernel/svc_wrap.h

@@ -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;

src/core/hle/service/acc/acc.cpp

@@ -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"

src/core/hle/service/acc/profile_manager.cpp

@@ -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"
 

src/core/hle/service/am/am.cpp

@@ -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);
 

src/core/hle/service/audio/audin_u.cpp

@@ -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"},

src/core/hle/service/audio/audout_u.cpp

@@ -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
@@ -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"},

src/core/hle/service/audio/audren_u.cpp

@@ -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"},
@@ -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[] = {

src/core/hle/service/nfc/mifare_user.cpp

@@ -0,0 +1,400 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/hid/hid_types.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/nfc/mifare_user.h"
+#include "core/hle/service/nfc/nfc_device.h"
+#include "core/hle/service/nfc/nfc_result.h"
+
+namespace Service::NFC {
+
+MFIUser::MFIUser(Core::System& system_)
+    : ServiceFramework{system_, "NFC::MFIUser"}, service_context{system_, service_name} {
+    static const FunctionInfo functions[] = {
+        {0, &MFIUser::Initialize, "Initialize"},
+        {1, &MFIUser::Finalize, "Finalize"},
+        {2, &MFIUser::ListDevices, "ListDevices"},
+        {3, &MFIUser::StartDetection, "StartDetection"},
+        {4, &MFIUser::StopDetection, "StopDetection"},
+        {5, &MFIUser::Read, "Read"},
+        {6, &MFIUser::Write, "Write"},
+        {7, &MFIUser::GetTagInfo, "GetTagInfo"},
+        {8, &MFIUser::GetActivateEventHandle, "GetActivateEventHandle"},
+        {9, &MFIUser::GetDeactivateEventHandle, "GetDeactivateEventHandle"},
+        {10, &MFIUser::GetState, "GetState"},
+        {11, &MFIUser::GetDeviceState, "GetDeviceState"},
+        {12, &MFIUser::GetNpadId, "GetNpadId"},
+        {13, &MFIUser::GetAvailabilityChangeEventHandle, "GetAvailabilityChangeEventHandle"},
+    };
+    RegisterHandlers(functions);
+
+    availability_change_event = service_context.CreateEvent("MFIUser:AvailabilityChangeEvent");
+
+    for (u32 device_index = 0; device_index < 10; device_index++) {
+        devices[device_index] =
+            std::make_shared<NfcDevice>(Core::HID::IndexToNpadIdType(device_index), system,
+                                        service_context, availability_change_event);
+    }
+}
+
+MFIUser ::~MFIUser() {
+    availability_change_event->Close();
+}
+
+void MFIUser::Initialize(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFC, "called");
+
+    state = State::Initialized;
+
+    for (auto& device : devices) {
+        device->Initialize();
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 0};
+    rb.Push(ResultSuccess);
+}
+
+void MFIUser::Finalize(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFC, "called");
+
+    state = State::NonInitialized;
+
+    for (auto& device : devices) {
+        device->Finalize();
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void MFIUser::ListDevices(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_NFC, "called");
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    if (!ctx.CanWriteBuffer()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareInvalidArgument);
+        return;
+    }
+
+    if (ctx.GetWriteBufferSize() == 0) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareInvalidArgument);
+        return;
+    }
+
+    std::vector<u64> nfp_devices;
+    const std::size_t max_allowed_devices = ctx.GetWriteBufferNumElements<u64>();
+
+    for (const auto& device : devices) {
+        if (nfp_devices.size() >= max_allowed_devices) {
+            continue;
+        }
+        if (device->GetCurrentState() != NFP::DeviceState::Unavailable) {
+            nfp_devices.push_back(device->GetHandle());
+        }
+    }
+
+    if (nfp_devices.empty()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    ctx.WriteBuffer(nfp_devices);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(static_cast<s32>(nfp_devices.size()));
+}
+
+void MFIUser::StartDetection(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    const auto result = device.value()->StartDetection(NFP::TagProtocol::All);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::StopDetection(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    const auto result = device.value()->StopDetection();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::Read(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto buffer{ctx.ReadBuffer()};
+    const auto number_of_commands{ctx.GetReadBufferNumElements<NFP::MifareReadBlockParameter>()};
+    std::vector<NFP::MifareReadBlockParameter> read_commands(number_of_commands);
+
+    memcpy(read_commands.data(), buffer.data(),
+           number_of_commands * sizeof(NFP::MifareReadBlockParameter));
+
+    LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, read_commands_size={}",
+             device_handle, number_of_commands);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    Result result = ResultSuccess;
+    std::vector<NFP::MifareReadBlockData> out_data(number_of_commands);
+    for (std::size_t i = 0; i < number_of_commands; i++) {
+        result = device.value()->MifareRead(read_commands[i], out_data[i]);
+        if (result.IsError()) {
+            break;
+        }
+    }
+
+    ctx.WriteBuffer(out_data);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::Write(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    const auto buffer{ctx.ReadBuffer()};
+    const auto number_of_commands{ctx.GetReadBufferNumElements<NFP::MifareWriteBlockParameter>()};
+    std::vector<NFP::MifareWriteBlockParameter> write_commands(number_of_commands);
+
+    memcpy(write_commands.data(), buffer.data(),
+           number_of_commands * sizeof(NFP::MifareWriteBlockParameter));
+
+    LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, write_commands_size={}",
+             device_handle, number_of_commands);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    Result result = ResultSuccess;
+    std::vector<NFP::MifareReadBlockData> out_data(number_of_commands);
+    for (std::size_t i = 0; i < number_of_commands; i++) {
+        result = device.value()->MifareWrite(write_commands[i]);
+        if (result.IsError()) {
+            break;
+        }
+    }
+
+    if (result.IsSuccess()) {
+        result = device.value()->Flush();
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::GetTagInfo(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    NFP::TagInfo tag_info{};
+    const auto result = device.value()->GetTagInfo(tag_info, true);
+    ctx.WriteBuffer(tag_info);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void MFIUser::GetActivateEventHandle(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(device.value()->GetActivateEvent());
+}
+
+void MFIUser::GetDeactivateEventHandle(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(device.value()->GetDeactivateEvent());
+}
+
+void MFIUser::GetState(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_NFC, "called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(state);
+}
+
+void MFIUser::GetDeviceState(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(device.value()->GetCurrentState());
+}
+
+void MFIUser::GetNpadId(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto device_handle{rp.Pop<u64>()};
+    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    auto device = GetNfcDevice(device_handle);
+
+    if (!device.has_value()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareDeviceNotFound);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(device.value()->GetNpadId());
+}
+
+void MFIUser::GetAvailabilityChangeEventHandle(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_NFC, "called");
+
+    if (state == State::NonInitialized) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(MifareNfcDisabled);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(availability_change_event->GetReadableEvent());
+}
+
+std::optional<std::shared_ptr<NfcDevice>> MFIUser::GetNfcDevice(u64 handle) {
+    for (auto& device : devices) {
+        if (device->GetHandle() == handle) {
+            return device;
+        }
+    }
+    return std::nullopt;
+}
+
+} // namespace Service::NFC

src/core/hle/service/nfc/mifare_user.h

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <optional>
+
+#include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/service.h"
+
+namespace Service::NFC {
+class NfcDevice;
+
+class MFIUser final : public ServiceFramework<MFIUser> {
+public:
+    explicit MFIUser(Core::System& system_);
+    ~MFIUser();
+
+private:
+    enum class State : u32 {
+        NonInitialized,
+        Initialized,
+    };
+
+    void Initialize(Kernel::HLERequestContext& ctx);
+    void Finalize(Kernel::HLERequestContext& ctx);
+    void ListDevices(Kernel::HLERequestContext& ctx);
+    void StartDetection(Kernel::HLERequestContext& ctx);
+    void StopDetection(Kernel::HLERequestContext& ctx);
+    void Read(Kernel::HLERequestContext& ctx);
+    void Write(Kernel::HLERequestContext& ctx);
+    void GetTagInfo(Kernel::HLERequestContext& ctx);
+    void GetActivateEventHandle(Kernel::HLERequestContext& ctx);
+    void GetDeactivateEventHandle(Kernel::HLERequestContext& ctx);
+    void GetState(Kernel::HLERequestContext& ctx);
+    void GetDeviceState(Kernel::HLERequestContext& ctx);
+    void GetNpadId(Kernel::HLERequestContext& ctx);
+    void GetAvailabilityChangeEventHandle(Kernel::HLERequestContext& ctx);
+
+    std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle);
+
+    KernelHelpers::ServiceContext service_context;
+
+    std::array<std::shared_ptr<NfcDevice>, 10> devices{};
+
+    State state{State::NonInitialized};
+    Kernel::KEvent* availability_change_event;
+};
+
+} // namespace Service::NFC

src/core/hle/service/nfc/nfc.cpp

@@ -6,6 +6,7 @@
 #include "common/logging/log.h"
 #include "common/settings.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/service/nfc/mifare_user.h"
 #include "core/hle/service/nfc/nfc.h"
 #include "core/hle/service/nfc/nfc_user.h"
 #include "core/hle/service/service.h"
@@ -50,32 +51,6 @@ private:
     }
 };
 
-class MFIUser final : public ServiceFramework<MFIUser> {
-public:
-    explicit MFIUser(Core::System& system_) : ServiceFramework{system_, "NFC::MFIUser"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Initialize"},
-            {1, nullptr, "Finalize"},
-            {2, nullptr, "ListDevices"},
-            {3, nullptr, "StartDetection"},
-            {4, nullptr, "StopDetection"},
-            {5, nullptr, "Read"},
-            {6, nullptr, "Write"},
-            {7, nullptr, "GetTagInfo"},
-            {8, nullptr, "GetActivateEventHandle"},
-            {9, nullptr, "GetDeactivateEventHandle"},
-            {10, nullptr, "GetState"},
-            {11, nullptr, "GetDeviceState"},
-            {12, nullptr, "GetNpadId"},
-            {13, nullptr, "GetAvailabilityChangeEventHandle"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
 class NFC_MF_U final : public ServiceFramework<NFC_MF_U> {
 public:
     explicit NFC_MF_U(Core::System& system_) : ServiceFramework{system_, "nfc:mf:u"} {

src/core/hle/service/nfc/nfc_device.cpp

@@ -77,11 +77,13 @@ bool NfcDevice::LoadNfcTag(std::span<const u8> data) {
         return false;
     }
 
-    if (data.size() != sizeof(NFP::EncryptedNTAG215File)) {
+    if (data.size() < sizeof(NFP::EncryptedNTAG215File)) {
         LOG_ERROR(Service_NFC, "Not an amiibo, size={}", data.size());
         return false;
     }
 
+    tag_data.resize(data.size());
+    memcpy(tag_data.data(), data.data(), data.size());
     memcpy(&encrypted_tag_data, data.data(), sizeof(NFP::EncryptedNTAG215File));
 
     device_state = NFP::DeviceState::TagFound;
@@ -121,7 +123,7 @@ void NfcDevice::Finalize() {
     device_state = NFP::DeviceState::Unavailable;
 }
 
-Result NfcDevice::StartDetection(s32 protocol_) {
+Result NfcDevice::StartDetection(NFP::TagProtocol allowed_protocol) {
     if (device_state != NFP::DeviceState::Initialized &&
         device_state != NFP::DeviceState::TagRemoved) {
         LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
@@ -134,7 +136,7 @@ Result NfcDevice::StartDetection(s32 protocol_) {
     }
 
     device_state = NFP::DeviceState::SearchingForTag;
-    protocol = protocol_;
+    allowed_protocols = allowed_protocol;
     return ResultSuccess;
 }
 
@@ -160,7 +162,7 @@ Result NfcDevice::StopDetection() {
     return WrongDeviceState;
 }
 
-Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info) const {
+Result NfcDevice::Flush() {
     if (device_state != NFP::DeviceState::TagFound &&
         device_state != NFP::DeviceState::TagMounted) {
         LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
@@ -170,6 +172,34 @@ Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info) const {
         return WrongDeviceState;
     }
 
+    if (!npad_device->WriteNfc(tag_data)) {
+        LOG_ERROR(Service_NFP, "Error writing to file");
+        return MifareReadError;
+    }
+
+    return ResultSuccess;
+}
+
+Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info, bool is_mifare) const {
+    if (device_state != NFP::DeviceState::TagFound &&
+        device_state != NFP::DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
+        if (device_state == NFP::DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+
+    if (is_mifare) {
+        tag_info = {
+            .uuid = encrypted_tag_data.uuid.uid,
+            .uuid_length = static_cast<u8>(encrypted_tag_data.uuid.uid.size()),
+            .protocol = NFP::TagProtocol::TypeA,
+            .tag_type = NFP::TagType::Type4,
+        };
+        return ResultSuccess;
+    }
+
     // Protocol and tag type may change here
     tag_info = {
         .uuid = encrypted_tag_data.uuid.uid,
@@ -181,6 +211,52 @@ Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info) const {
     return ResultSuccess;
 }
 
+Result NfcDevice::MifareRead(const NFP::MifareReadBlockParameter& parameter,
+                             NFP::MifareReadBlockData& read_block_data) {
+    const std::size_t sector_index = parameter.sector_number * sizeof(NFP::DataBlock);
+    read_block_data.sector_number = parameter.sector_number;
+
+    if (device_state != NFP::DeviceState::TagFound &&
+        device_state != NFP::DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
+        if (device_state == NFP::DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+
+    if (tag_data.size() < sector_index + sizeof(NFP::DataBlock)) {
+        return MifareReadError;
+    }
+
+    // TODO: Use parameter.sector_key to read encrypted data
+    memcpy(read_block_data.data.data(), tag_data.data() + sector_index, sizeof(NFP::DataBlock));
+
+    return ResultSuccess;
+}
+
+Result NfcDevice::MifareWrite(const NFP::MifareWriteBlockParameter& parameter) {
+    const std::size_t sector_index = parameter.sector_number * sizeof(NFP::DataBlock);
+
+    if (device_state != NFP::DeviceState::TagFound &&
+        device_state != NFP::DeviceState::TagMounted) {
+        LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);
+        if (device_state == NFP::DeviceState::TagRemoved) {
+            return TagRemoved;
+        }
+        return WrongDeviceState;
+    }
+
+    if (tag_data.size() < sector_index + sizeof(NFP::DataBlock)) {
+        return MifareReadError;
+    }
+
+    // TODO: Use parameter.sector_key to encrypt the data
+    memcpy(tag_data.data() + sector_index, parameter.data.data(), sizeof(NFP::DataBlock));
+
+    return ResultSuccess;
+}
+
 u64 NfcDevice::GetHandle() const {
     // Generate a handle based of the npad id
     return static_cast<u64>(npad_id);

src/core/hle/service/nfc/nfc_device.h

@@ -34,10 +34,16 @@ public:
     void Initialize();
     void Finalize();
 
-    Result StartDetection(s32 protocol_);
+    Result StartDetection(NFP::TagProtocol allowed_protocol);
     Result StopDetection();
+    Result Flush();
 
-    Result GetTagInfo(NFP::TagInfo& tag_info) const;
+    Result GetTagInfo(NFP::TagInfo& tag_info, bool is_mifare) const;
+
+    Result MifareRead(const NFP::MifareReadBlockParameter& parameter,
+                      NFP::MifareReadBlockData& read_block_data);
+
+    Result MifareWrite(const NFP::MifareWriteBlockParameter& parameter);
 
     u64 GetHandle() const;
     NFP::DeviceState GetCurrentState() const;
@@ -61,10 +67,11 @@ private:
     Kernel::KEvent* deactivate_event = nullptr;
     Kernel::KEvent* availability_change_event = nullptr;
 
-    s32 protocol{};
+    NFP::TagProtocol allowed_protocols{};
     NFP::DeviceState device_state{NFP::DeviceState::Unavailable};
 
     NFP::EncryptedNTAG215File encrypted_tag_data{};
+    std::vector<u8> tag_data{};
 };
 
 } // namespace Service::NFC