CMakeLists: Remove BoxCat build option

The current implementation of BoxCat as it stands is non-functional due to the reliance on a server providing BCAT files.
This implementation will eventually be replaced with one that allows the use of local BCAT files dumped from a Nintendo Switch.

.ci/scripts/format/script.sh

@@ -7,7 +7,7 @@ if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .ci* dis
 fi
 
 # Default clang-format points to default 3.5 version one
-CLANG_FORMAT=clang-format-10
+CLANG_FORMAT=clang-format-12
 $CLANG_FORMAT --version
 
 if [ "$TRAVIS_EVENT_TYPE" = "pull_request" ]; then

.gitmodules

@@ -28,9 +28,6 @@
 [submodule "mbedtls"]
     path = externals/mbedtls
     url = https://github.com/yuzu-emu/mbedtls
-[submodule "libzip"]
-    path = externals/libzip/libzip
-    url = https://github.com/nih-at/libzip.git
 [submodule "xbyak"]
     path = externals/xbyak
     url = https://github.com/herumi/xbyak.git

CMakeLists.txt

@@ -29,16 +29,10 @@ option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")
 
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
 
-option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implementation of BCAT" ON)
-
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
-if (NOT ENABLE_WEB_SERVICE)
-    set(YUZU_ENABLE_BOXCAT OFF)
-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)
@@ -135,7 +129,7 @@ endif()
 # boost asio's concept usage doesn't play nicely with some compilers yet.
 add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
 if (MSVC)
-    add_compile_options(/std:c++latest)
+    add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/std:c++latest>)
 
     # cubeb and boost still make use of deprecated result_of.
     add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
@@ -422,11 +416,6 @@ if (CONAN_REQUIRED_LIBS)
     endif()
     include(${CMAKE_BINARY_DIR}/conan.cmake)
 
-    set(CONAN_LIB_OPTIONS
-        libzip:with_openssl=False
-        libzip:enable_windows_crypto=False
-    )
-
     conan_check(VERSION 1.24.0 REQUIRED)
 
     # Manually add iconv to fix a dep conflict between qt and sdl2
@@ -518,6 +507,10 @@ set(FFmpeg_COMPONENTS
     avutil
     swscale)
 
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    Include(FindPkgConfig REQUIRED)
+    pkg_check_modules(LIBVA libva)
+endif()
 if (NOT YUZU_USE_BUNDLED_FFMPEG)
     # Use system installed FFmpeg
     find_package(FFmpeg QUIET COMPONENTS ${FFmpeg_COMPONENTS})
@@ -540,6 +533,9 @@ endif()
 
 if (YUZU_USE_BUNDLED_FFMPEG)
     if (NOT WIN32)
+        # TODO(lat9nq): Move this to externals/ffmpeg/CMakeLists.txt (and move externals/ffmpeg to
+        # externals/ffmpeg/ffmpeg)
+
         # Build FFmpeg from externals
         message(STATUS "Using FFmpeg from externals")
 
@@ -579,20 +575,23 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                 CACHE PATH "Paths to FFmpeg libraries" FORCE)
         endforeach()
 
-        set(FFmpeg_INCLUDE_DIR
-            "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR}"
-            CACHE PATH "Path to FFmpeg headers" FORCE)
+        Include(FindPkgConfig REQUIRED)
+        pkg_check_modules(LIBVA libva)
+        pkg_check_modules(CUDA cuda)
+        pkg_check_modules(FFNVCODEC ffnvcodec)
+        pkg_check_modules(VDPAU vdpau)
+
+        set(FFmpeg_HWACCEL_LIBRARIES)
+        set(FFmpeg_HWACCEL_FLAGS)
+        set(FFmpeg_HWACCEL_INCLUDE_DIRS)
+        set(FFmpeg_HWACCEL_LDFLAGS)
 
-        if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-            Include(FindPkgConfig REQUIRED)
-            pkg_check_modules(LIBVA libva)
-        endif()
         if(LIBVA_FOUND)
             pkg_check_modules(LIBDRM libdrm REQUIRED)
             find_package(X11 REQUIRED)
             pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
             pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
-            set(FFmpeg_LIBVA_LIBRARIES
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES
                 ${LIBDRM_LIBRARIES}
                 ${X11_LIBRARIES}
                 ${LIBVA-DRM_LIBRARIES}
@@ -602,11 +601,56 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                 --enable-hwaccel=h264_vaapi
                 --enable-hwaccel=vp9_vaapi
                 --enable-libdrm)
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+                ${LIBDRM_INCLUDE_DIRS}
+                ${X11_INCLUDE_DIRS}
+                ${LIBVA-DRM_INCLUDE_DIRS}
+                ${LIBVA-X11_INCLUDE_DIRS}
+                ${LIBVA_INCLUDE_DIRS}
+            )
             message(STATUS "VA-API found")
         else()
             set(FFmpeg_HWACCEL_FLAGS --disable-vaapi)
         endif()
 
+        if (FFNVCODEC_FOUND AND CUDA_FOUND)
+            list(APPEND FFmpeg_HWACCEL_FLAGS
+                --enable-cuvid
+                --enable-ffnvcodec
+                --enable-nvdec
+                --enable-hwaccel=h264_nvdec
+                --enable-hwaccel=vp9_nvdec
+                --extra-cflags=-I${CUDA_INCLUDE_DIRS}
+            )
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES
+                ${FFNVCODEC_LIBRARIES}
+                ${CUDA_LIBRARIES}
+            )
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+                ${FFNVCODEC_INCLUDE_DIRS}
+                ${CUDA_INCLUDE_DIRS}
+            )
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS
+                ${FFNVCODEC_LDFLAGS}
+                ${CUDA_LDFLAGS}
+            )
+            message(STATUS "ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
+        endif()
+
+        if (VDPAU_FOUND)
+            list(APPEND FFmpeg_HWACCEL_FLAGS
+                --enable-vdpau
+                --enable-hwaccel=h264_vdpau
+                --enable-hwaccel=vp9_vdpau
+            )
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
+            message(STATUS "vdpau libraries version ${VDPAU_VERSION} found")
+        else()
+            list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
+        endif()
+
         # `configure` parameters builds only exactly what yuzu needs from FFmpeg
         # `--disable-vdpau` is needed to avoid linking issues
         add_custom_command(
@@ -624,7 +668,6 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                     --disable-network
                     --disable-postproc
                     --disable-swresample
-                    --disable-vdpau
                     --enable-decoder=h264
                     --enable-decoder=vp9
                     --cc="${CMAKE_C_COMPILER}"
@@ -653,15 +696,26 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                 ${FFmpeg_BUILD_DIR}
         )
 
+        set(FFmpeg_INCLUDE_DIR
+            "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR};${FFmpeg_HWACCEL_INCLUDE_DIRS}"
+            CACHE PATH "Path to FFmpeg headers" FORCE)
+
+        set(FFmpeg_LDFLAGS
+            "${FFmpeg_HWACCEL_LDFLAGS}"
+            CACHE STRING "FFmpeg linker flags" FORCE)
+
         # ALL makes this custom target build every time
         # but it won't actually build if the DEPENDS parameter is up to date
         add_custom_target(ffmpeg-configure ALL DEPENDS ${FFmpeg_MAKEFILE})
         add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_BUILD_LIBRARIES} ffmpeg-configure)
         link_libraries(${FFmpeg_LIBVA_LIBRARIES})
-        set(FFmpeg_LIBRARIES ${FFmpeg_LIBVA_LIBRARIES} ${FFmpeg_BUILD_LIBRARIES}
+        set(FFmpeg_LIBRARIES ${FFmpeg_BUILD_LIBRARIES} ${FFmpeg_HWACCEL_LIBRARIES}
             CACHE PATH "Paths to FFmpeg libraries" FORCE)
         unset(FFmpeg_BUILD_LIBRARIES)
-        unset(FFmpeg_LIBVA_LIBRARIES)
+        unset(FFmpeg_HWACCEL_FLAGS)
+        unset(FFmpeg_HWACCEL_INCLUDE_DIRS)
+        unset(FFmpeg_HWACCEL_LDFLAGS)
+        unset(FFmpeg_HWACCEL_LIBRARIES)
 
         if (FFmpeg_FOUND)
             message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
@@ -670,12 +724,13 @@ if (YUZU_USE_BUNDLED_FFMPEG)
         endif()
     else() # WIN32
         # Use yuzu FFmpeg binaries
-        set(FFmpeg_EXT_NAME "ffmpeg-4.3.1")
+        set(FFmpeg_EXT_NAME "ffmpeg-4.4")
         set(FFmpeg_PATH "${CMAKE_BINARY_DIR}/externals/${FFmpeg_EXT_NAME}")
         download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "")
         set(FFmpeg_FOUND YES)
         set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
         set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg library directory" FORCE)
+        set(FFmpeg_LDFLAGS "" CACHE STRING "FFmpeg linker flags" FORCE)
         set(FFmpeg_DLL_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
         set(FFmpeg_LIBRARIES
             ${FFmpeg_LIBRARY_DIR}/swscale.lib
@@ -714,7 +769,7 @@ endif()
 # against all the src files. This should be used before making a pull request.
 # =======================================================================
 
-set(CLANG_FORMAT_POSTFIX "-10")
+set(CLANG_FORMAT_POSTFIX "-12")
 find_program(CLANG_FORMAT
     NAMES clang-format${CLANG_FORMAT_POSTFIX}
           clang-format

externals/CMakeLists.txt

@@ -93,13 +93,6 @@ endif()
 # Sirit
 add_subdirectory(sirit)
 
-# libzip
-find_package(libzip 1.5)
-if (NOT libzip_FOUND)
-    message(STATUS "libzip 1.5 or newer not found, falling back to externals")
-    add_subdirectory(libzip EXCLUDE_FROM_ALL)
-endif()
-
 if (ENABLE_WEB_SERVICE)
     find_package(OpenSSL 1.1)
     if (OPENSSL_FOUND)

externals/find-modules/Findlibzip.cmake

@@ -1,72 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_libzip QUIET libzip)
-
-find_path(libzip_INCLUDE_DIR
-  NAMES zip.h
-  PATHS ${PC_libzip_INCLUDE_DIRS}
-  "$ENV{LIB_DIR}/include"
-  "$ENV{INCLUDE}"
-  /usr/local/include
-  /usr/include
-)
-find_path(libzip_INCLUDE_DIR_ZIPCONF
-  NAMES zipconf.h
-  HINTS ${PC_libzip_INCLUDE_DIRS}
-  "$ENV{LIB_DIR}/include"
-  "$ENV{LIB_DIR}/lib/libzip/include"
-  "$ENV{LIB}/lib/libzip/include"
-  /usr/local/lib/libzip/include
-  /usr/lib/libzip/include
-  /usr/local/include
-  /usr/include
-  "$ENV{INCLUDE}"
-)
-find_library(libzip_LIBRARY
-  NAMES zip
-  PATHS ${PC_libzip_LIBRARY_DIRS}
-  "$ENV{LIB_DIR}/lib" "$ENV{LIB}" /usr/local/lib /usr/lib
-)
-
-if (libzip_INCLUDE_DIR_ZIPCONF)
-  FILE(READ "${libzip_INCLUDE_DIR_ZIPCONF}/zipconf.h" _libzip_VERSION_CONTENTS)
-  if (_libzip_VERSION_CONTENTS)
-    STRING(REGEX REPLACE ".*#define LIBZIP_VERSION \"([0-9.]+)\".*" "\\1" libzip_VERSION "${_libzip_VERSION_CONTENTS}")
-  endif()
-  unset(_libzip_VERSION_CONTENTS)
-endif()
-
-set(libzip_VERSION ${libzip_VERSION} CACHE STRING "Version number of libzip")
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(libzip
-  FOUND_VAR libzip_FOUND
-  REQUIRED_VARS
-    libzip_LIBRARY
-    libzip_INCLUDE_DIR
-    libzip_INCLUDE_DIR_ZIPCONF
-    libzip_VERSION
-  VERSION_VAR libzip_VERSION
-)
-
-if(libzip_FOUND)
-  set(libzip_LIBRARIES ${libzip_LIBRARY})
-  set(libzip_INCLUDE_DIRS ${libzip_INCLUDE_DIR})
-  set(libzip_DEFINITIONS ${PC_libzip_CFLAGS_OTHER})
-endif()
-
-if(libzip_FOUND AND NOT TARGET libzip::libzip)
-  add_library(libzip::libzip UNKNOWN IMPORTED)
-  set_target_properties(libzip::libzip PROPERTIES
-    IMPORTED_LOCATION "${libzip_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_libzip_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${libzip_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    libzip_INCLUDE_DIR
-    libzip_INCLUDE_DIR_ZIPCONF
-    libzip_LIBRARY
-    libzip_VERSION
-)

externals/libzip/CMakeLists.txt

@@ -1,564 +0,0 @@
-# TODO:
-# create usable libtool .la file
-
-CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)
-
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/libzip")
-
-PROJECT(libzip C)
-
-OPTION(ENABLE_COMMONCRYPTO "Enable use of CommonCrypto" ON)
-OPTION(ENABLE_GNUTLS "Enable use of GnuTLS" ON)
-OPTION(ENABLE_MBEDTLS "Enable use of mbed TLS" ON)
-OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON)
-OPTION(ENABLE_WINDOWS_CRYPTO "Enable use of Windows cryptography libraries" ON)
-
-OPTION(ENABLE_BZIP2 "Enable use of BZip2" OFF)
-OPTION(ENABLE_LZMA "Enable use of LZMA" OFF)
-
-INCLUDE(CheckFunctionExists)
-INCLUDE(CheckIncludeFiles)
-INCLUDE(CheckSymbolExists)
-INCLUDE(CheckTypeSize)
-INCLUDE(CheckCSourceRuns)
-INCLUDE(CheckCSourceCompiles)
-INCLUDE(CheckStructHasMember)
-INCLUDE(TestBigEndian)
-INCLUDE(GNUInstallDirs)
-IF(ENABLE_COMMONCRYPTO)
-  CHECK_INCLUDE_FILES(CommonCrypto/CommonCrypto.h COMMONCRYPTO_FOUND)
-ELSE()
-  SET(COMMONCRYPTO_FOUND FALSE)
-ENDIF()
-IF(ENABLE_GNUTLS)
-  INCLUDE(FindNettle)
-  INCLUDE(FindGnuTLS)
-ELSE()
-  SET(GNUTLS_FOUND FALSE)
-ENDIF()
-IF(ENABLE_MBEDTLS)
-  FIND_PATH(MBEDTLS_INCLUDE_DIR mbedtls/aes.h)
-  FIND_LIBRARY(MBEDTLS_LIBRARIES NAMES mbedcrypto)
-ELSE()
-  SET(MBEDTLS_LIBRARIES FALSE)
-ENDIF()
-IF(ENABLE_OPENSSL)
-  INCLUDE(FindOpenSSL)
-ELSE()
-  SET(OPENSSL_FOUND FALSE)
-ENDIF()
-IF(WIN32)
-  IF(ENABLE_WINDOWS_CRYPTO)
-    SET(WINDOWS_CRYPTO_FOUND TRUE)
-  ENDIF()
-ELSE()
-  SET(WINDOWS_CRYPTO_FOUND FALSE)
-ENDIF()
-
-OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON)
-OPTION(SHARED_LIB_VERSIONNING "Add SO version in .so build" ON)
-
-SET(PACKAGE "libzip")
-SET(PACKAGE_NAME ${PACKAGE})
-SET(PACKAGE_VERSION_MAJOR "1")
-SET(PACKAGE_VERSION_MINOR "5")
-SET(PACKAGE_VERSION_MICRO "2a")
-#SET(VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}")
-SET(VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_MICRO}")
-SET(PACKAGE_VERSION ${VERSION})
-SET(LIBZIP_VERSION ${PACKAGE_VERSION})
-SET(LIBZIP_VERSION_MAJOR ${PACKAGE_VERSION_MAJOR})
-SET(LIBZIP_VERSION_MINOR ${PACKAGE_VERSION_MINOR})
-SET(LIBZIP_VERSION_MICRO ${PACKAGE_VERSION_MICRO})
-SET(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
-
-SET(ARCHIVE_NAME ${PACKAGE_NAME}-${PACKAGE_VERSION})
-IF(NOT TARGET dist)
-ADD_CUSTOM_TARGET(dist
-  COMMAND git config tar.tar.xz.command "xz -c"
-  COMMAND git archive --prefix=${ARCHIVE_NAME}/ -o ${ARCHIVE_NAME}.tar.gz HEAD
-  COMMAND git archive --prefix=${ARCHIVE_NAME}/ -o ${ARCHIVE_NAME}.tar.xz HEAD
-  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-  )
-ADD_CUSTOM_TARGET(distcheck
-  COMMAND chmod -R u+w ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest 2>/dev/null || true
-  COMMAND rm -rf ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest
-  COMMAND cmake -E tar xf ${ARCHIVE_NAME}.tar.gz
-  COMMAND chmod -R u-w ${ARCHIVE_NAME}
-  COMMAND mkdir ${ARCHIVE_NAME}-build
-  COMMAND mkdir ${ARCHIVE_NAME}-dest
-  COMMAND cd ${ARCHIVE_NAME}-build && cmake -DCMAKE_INSTALL_PREFIX=../${ARCHIVE_NAME}-dest ../${ARCHIVE_NAME}
-  COMMAND cd ${ARCHIVE_NAME}-build && make -j4
-  COMMAND cd ${ARCHIVE_NAME}-build && make test
-  COMMAND cd ${ARCHIVE_NAME}-build && make install
-#  COMMAND cd ${ARCHIVE_NAME}-build && make uninstall
-#  COMMAND if [ `find ${ARCHIVE_NAME}-dest ! -type d | wc -l` -ne 0 ]; then echo leftover files in ${ARCHIVE_NAME}-dest; false; fi
-  COMMAND cd ${ARCHIVE_NAME}-build && make clean
-  COMMAND chmod -R u+w ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest
-  COMMAND rm -rf ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest
-  COMMAND echo "${ARCHIVE_NAME}.tar.gz is ready for distribution."
-  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-  )
-ADD_DEPENDENCIES(distcheck dist)
-ENDIF(NOT TARGET dist)
-
-IF(BUILD_SHARED_LIBS)
-  SET(HAVE_SHARED TRUE)
-ELSE()
-  SET(ZIP_STATIC TRUE)
-ENDIF()
-
-# Checks
-
-CHECK_FUNCTION_EXISTS(_chmod HAVE__CHMOD)
-CHECK_FUNCTION_EXISTS(_close HAVE__CLOSE)
-CHECK_FUNCTION_EXISTS(_dup HAVE__DUP)
-CHECK_FUNCTION_EXISTS(_fdopen HAVE__FDOPEN)
-CHECK_FUNCTION_EXISTS(_fileno HAVE__FILENO)
-CHECK_FUNCTION_EXISTS(_open HAVE__OPEN)
-CHECK_FUNCTION_EXISTS(_setmode HAVE__SETMODE)
-CHECK_FUNCTION_EXISTS(_snprintf HAVE__SNPRINTF)
-CHECK_FUNCTION_EXISTS(_strdup HAVE__STRDUP)
-CHECK_FUNCTION_EXISTS(_stricmp HAVE__STRICMP)
-CHECK_FUNCTION_EXISTS(_strtoi64 HAVE__STRTOI64)
-CHECK_FUNCTION_EXISTS(_strtoui64 HAVE__STRTOUI64)
-CHECK_FUNCTION_EXISTS(_unlink HAVE__UNLINK)
-CHECK_FUNCTION_EXISTS(arc4random HAVE_ARC4RANDOM)
-CHECK_FUNCTION_EXISTS(clonefile HAVE_CLONEFILE)
-CHECK_FUNCTION_EXISTS(explicit_bzero HAVE_EXPLICIT_BZERO)
-CHECK_FUNCTION_EXISTS(explicit_memset HAVE_EXPLICIT_MEMSET)
-CHECK_FUNCTION_EXISTS(fileno HAVE_FILENO)
-CHECK_FUNCTION_EXISTS(fseeko HAVE_FSEEKO)
-CHECK_FUNCTION_EXISTS(ftello HAVE_FTELLO)
-CHECK_FUNCTION_EXISTS(getprogname HAVE_GETPROGNAME)
-CHECK_FUNCTION_EXISTS(localtime_r HAVE_LOCALTIME_R)
-CHECK_FUNCTION_EXISTS(open HAVE_OPEN)
-CHECK_FUNCTION_EXISTS(setmode HAVE_SETMODE)
-CHECK_FUNCTION_EXISTS(snprintf HAVE_SNPRINTF)
-CHECK_FUNCTION_EXISTS(strcasecmp HAVE_STRCASECMP)
-CHECK_FUNCTION_EXISTS(strdup HAVE_STRDUP)
-CHECK_FUNCTION_EXISTS(stricmp HAVE_STRICMP)
-CHECK_FUNCTION_EXISTS(strtoll HAVE_STRTOLL)
-CHECK_FUNCTION_EXISTS(strtoull HAVE_STRTOULL)
-
-CHECK_INCLUDE_FILES("sys/types.h;sys/stat.h;fts.h" HAVE_FTS_H)
-CHECK_INCLUDE_FILES(stdbool.h HAVE_STDBOOL_H)
-CHECK_INCLUDE_FILES(strings.h HAVE_STRINGS_H)
-CHECK_INCLUDE_FILES(unistd.h HAVE_UNISTD_H)
-
-CHECK_INCLUDE_FILES(inttypes.h HAVE_INTTYPES_H_LIBZIP)
-CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H_LIBZIP)
-CHECK_INCLUDE_FILES(sys/types.h HAVE_SYS_TYPES_H_LIBZIP)
-
-# TODO: fix test
-# this test does not find __progname even when it exists
-#CHECK_SYMBOL_EXISTS(__progname stdlib.h HAVE___PROGNAME)
-
-CHECK_TYPE_SIZE(__int8 __INT8_LIBZIP)
-CHECK_TYPE_SIZE(int8_t INT8_T_LIBZIP)
-CHECK_TYPE_SIZE(uint8_t UINT8_T_LIBZIP)
-CHECK_TYPE_SIZE(__int16 __INT16_LIBZIP)
-CHECK_TYPE_SIZE(int16_t INT16_T_LIBZIP)
-CHECK_TYPE_SIZE(uint16_t UINT16_T_LIBZIP)
-CHECK_TYPE_SIZE(__int32 __INT32_LIBZIP)
-CHECK_TYPE_SIZE(int32_t INT32_T_LIBZIP)
-CHECK_TYPE_SIZE(uint32_t UINT32_T_LIBZIP)
-CHECK_TYPE_SIZE(__int64 __INT64_LIBZIP)
-CHECK_TYPE_SIZE(int64_t INT64_T_LIBZIP)
-CHECK_TYPE_SIZE(uint64_t UINT64_T_LIBZIP)
-CHECK_TYPE_SIZE("short" SHORT_LIBZIP)
-CHECK_TYPE_SIZE("int" INT_LIBZIP)
-CHECK_TYPE_SIZE("long" LONG_LIBZIP)
-CHECK_TYPE_SIZE("long long" LONG_LONG_LIBZIP)
-CHECK_TYPE_SIZE("off_t" SIZEOF_OFF_T)
-CHECK_TYPE_SIZE("size_t" SIZE_T_LIBZIP)
-CHECK_TYPE_SIZE("ssize_t" SSIZE_T_LIBZIP)
-
-CHECK_C_SOURCE_COMPILES("#include <sys/ioctl.h>
-#include <linux/fs.h>
-int main(int argc, char *argv[]) { unsigned long x = FICLONERANGE; }" HAVE_FICLONERANGE)
-
-CHECK_C_SOURCE_COMPILES("
-int foo(char * _Nullable bar);
-int main(int argc, char *argv[]) { }" HAVE_NULLABLE)
-
-TEST_BIG_ENDIAN(WORDS_BIGENDIAN)
-
-#FIND_PACKAGE(ZLIB 1.1.2 REQUIRED)
-INCLUDE_DIRECTORIES(../zlib/zlib)
-SET(CMAKE_REQUIRED_INCLUDES ../zlib/zlib)
-
-IF(ENABLE_BZIP2)
-  FIND_PACKAGE(BZip2)
-  IF(BZIP2_FOUND)
-    SET (HAVE_LIBBZ2 1)
-
-    INCLUDE_DIRECTORIES(${BZIP2_INCLUDE_DIR})
-    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${BZIP2_LIBRARIES})
-  ELSE()
-    MESSAGE(WARNING "-- bzip2 library not found; bzip2 support disabled")
-  ENDIF(BZIP2_FOUND)
-ENDIF(ENABLE_BZIP2)
-
-IF(ENABLE_LZMA)
-  FIND_PACKAGE(LibLZMA)
-  IF(LIBLZMA_FOUND)
-    SET (HAVE_LIBLZMA 1)
-
-    INCLUDE_DIRECTORIES(${LIBLZMA_INCLUDE_DIR})
-    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${LIBLZMA_LIBRARY})
-  ELSE()
-    MESSAGE(WARNING "-- lzma library not found; lzma support disabled")
-  ENDIF(LIBLZMA_FOUND)
-ENDIF(ENABLE_LZMA)
-
-
-IF (COMMONCRYPTO_FOUND)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_COMMONCRYPTO 1)
-ELSEIF (WINDOWS_CRYPTO_FOUND)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_WINDOWS_CRYPTO 1)
-ELSEIF (GNUTLS_FOUND AND NETTLE_FOUND)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_GNUTLS 1)
-  INCLUDE_DIRECTORIES(${GNUTLS_INCLUDE_DIR} ${NETTLE_INCLUDE_DIR})
-  SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${GNUTLS_LIBRARY} ${NETTLE_LIBRARY})
-ELSEIF (OPENSSL_FOUND)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_OPENSSL 1)
-  INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
-  SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${OPENSSL_LIBRARIES})
-ELSEIF (MBEDTLS_LIBRARIES)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_MBEDTLS 1)
-  INCLUDE_DIRECTORIES(${MBEDTLS_INCLUDE_DIR})
-  SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${MBEDTLS_LIBRARIES})
-ENDIF()
-
-IF (NOT HAVE_CRYPTO)
-  MESSAGE(WARNING "-- neither Common Crypto, GnuTLS, mbed TLS, OpenSSL, nor Windows Cryptography found; AES support disabled")
-ENDIF()
-
-IF(MSVC)
-ADD_DEFINITIONS("-D_CRT_SECURE_NO_WARNINGS")
-ADD_DEFINITIONS("-D_CRT_NONSTDC_NO_DEPRECATE")
-ENDIF(MSVC)
-
-if(WIN32)
-  if(HAVE_WINDOWS_CRYPTO)
-    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} bcrypt)
-  endif()
-  if(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
-    ADD_DEFINITIONS(-DMS_UWP)
-  else(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
-    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} advapi32)
-  endif(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
-endif(WIN32)
-
-ADD_DEFINITIONS("-DHAVE_CONFIG_H")
-
-# rpath handling: use rpath in installed binaries
-IF(NOT CMAKE_SYSTEM_NAME MATCHES Linux)
-	SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
-	SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-ENDIF()
-
-# fixed size integral types
-
-IF(HAVE_INTTYPES_H_LIBZIP)
-  SET(LIBZIP_TYPES_INCLUDE "#define __STDC_FORMAT_MACROS 1
-#include <inttypes.h>")
-ELSEIF(HAVE_STDINT_H_LIBZIP)
-  SET(LIBZIP_TYPES_INCLUDE "#include <stdint.h>")
-ELSEIF(HAVE_SYS_TYPES_H_LIBZIP)
-  SET(LIBZIP_TYPES_INCLUDE "#include <sys/types.h>")
-ENDIF()
-
-IF(HAVE_INT8_T_LIBZIP)
-  SET(ZIP_INT8_T int8_t)
-ELSEIF(HAVE___INT8_LIBZIP)
-  SET(ZIP_INT8_T __int8)
-ELSE()
-  SET(ZIP_INT8_T "signed char")
-ENDIF()
-
-IF(HAVE_UINT8_T_LIBZIP)
-  SET(ZIP_UINT8_T uint8_t)
-ELSEIF(HAVE___INT8_LIBZIP)
-  SET(ZIP_UINT8_T "unsigned __int8")
-ELSE()
-  SET(ZIP_UINT8_T "unsigned char")
-ENDIF()
-
-IF(HAVE_INT16_T_LIBZIP)
-  SET(ZIP_INT16_T int16_t)
-ELSEIF(HAVE___INT16_LIBZIP)
-  SET(INT16_T_LIBZIP __int16)
-ELSEIF(SHORT_LIBZIP EQUAL 2)
-  SET(INT16_T_LIBZIP short)
-ENDIF()
-
-IF(HAVE_UINT16_T_LIBZIP)
-  SET(ZIP_UINT16_T uint16_t)
-ELSEIF(HAVE___INT16_LIBZIP)
-  SET(UINT16_T_LIBZIP "unsigned __int16")
-ELSEIF(SHORT_LIBZIP EQUAL 2)
-  SET(UINT16_T_LIBZIP "unsigned short")
-ENDIF()
-
-IF(HAVE_INT32_T_LIBZIP)
-  SET(ZIP_INT32_T int32_t)
-ELSEIF(HAVE___INT32_LIBZIP)
-  SET(ZIP_INT32_T __int32)
-ELSEIF(INT_LIBZIP EQUAL 4)
-  SET(ZIP_INT32_T int)
-ELSEIF(LONG_LIBZIP EQUAL 4)
-  SET(ZIP_INT32_T long)
-ENDIF()
-
-IF(HAVE_UINT32_T_LIBZIP)
-SET(ZIP_UINT32_T uint32_t)
-ELSEIF(HAVE___INT32_LIBZIP)
-SET(ZIP_UINT32_T "unsigned __int32")
-ELSEIF(INT_LIBZIP EQUAL 4)
-SET(ZIP_UINT32_T "unsigned int")
-ELSEIF(LONG_LIBZIP EQUAL 4)
-SET(ZIP_UINT32_T "unsigned long")
-ENDIF()
-
-IF(HAVE_INT64_T_LIBZIP)
-  SET(ZIP_INT64_T int64_t)
-ELSEIF(HAVE___INT64_LIBZIP)
-  SET(ZIP_INT64_T __int64)
-ELSEIF(LONG_LIBZIP EQUAL 8)
-  SET(ZIP_INT64_T long)
-ELSEIF(LONG_LONG_LIBZIP EQUAL 8)
-  SET(ZIP_INT64_T "long long")
-ENDIF()
-
-IF(HAVE_UINT64_T_LIBZIP)
-  SET(ZIP_UINT64_T uint64_t)
-ELSEIF(HAVE___INT64_LIBZIP)
-  SET(ZIP_UINT64_T "unsigned __int64")
-ELSEIF(LONG_LIBZIP EQUAL 8)
-  SET(ZIP_UINT64_T "unsigned long")
-ELSEIF(LONG_LONG_LIBZIP EQUAL 8)
-  SET(ZIP_UINT64_T "unsigned long long")
-ENDIF()
-
-IF(HAVE_NULLABLE)
-  SET(ZIP_NULLABLE_DEFINES)
-ELSE()
-  SET(ZIP_NULLABLE_DEFINES "#define _Nullable
-#define _Nonnull")
-ENDIF()
-
-# write out config file
-CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/libzip/cmake-config.h.in ${CMAKE_CURRENT_BINARY_DIR}/libzip/config.h)
-CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/libzip/cmake-zipconf.h.in ${CMAKE_CURRENT_BINARY_DIR}/libzip/zipconf.h)
-
-# installation
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libzip/zipconf.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-INSTALL(FILES libzip/lib/zip.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-SET(CMAKE_C_VISIBILITY_PRESET hidden)
-
-ADD_LIBRARY(zip
-  libzip/lib/zip_add.c
-  libzip/lib/zip_add_dir.c
-  libzip/lib/zip_add_entry.c
-  libzip/lib/zip_algorithm_deflate.c
-  libzip/lib/zip_buffer.c
-  libzip/lib/zip_close.c
-  libzip/lib/zip_delete.c
-  libzip/lib/zip_dir_add.c
-  libzip/lib/zip_dirent.c
-  libzip/lib/zip_discard.c
-  libzip/lib/zip_entry.c
-  libzip/lib/zip_err_str.c
-  libzip/lib/zip_error.c
-  libzip/lib/zip_error_clear.c
-  libzip/lib/zip_error_get.c
-  libzip/lib/zip_error_get_sys_type.c
-  libzip/lib/zip_error_strerror.c
-  libzip/lib/zip_error_to_str.c
-  libzip/lib/zip_extra_field.c
-  libzip/lib/zip_extra_field_api.c
-  libzip/lib/zip_fclose.c
-  libzip/lib/zip_fdopen.c
-  libzip/lib/zip_file_add.c
-  libzip/lib/zip_file_error_clear.c
-  libzip/lib/zip_file_error_get.c
-  libzip/lib/zip_file_get_comment.c
-  libzip/lib/zip_file_get_external_attributes.c
-  libzip/lib/zip_file_get_offset.c
-  libzip/lib/zip_file_rename.c
-  libzip/lib/zip_file_replace.c
-  libzip/lib/zip_file_set_comment.c
-  libzip/lib/zip_file_set_encryption.c
-  libzip/lib/zip_file_set_external_attributes.c
-  libzip/lib/zip_file_set_mtime.c
-  libzip/lib/zip_file_strerror.c
-  libzip/lib/zip_filerange_crc.c
-  libzip/lib/zip_fopen.c
-  libzip/lib/zip_fopen_encrypted.c
-  libzip/lib/zip_fopen_index.c
-  libzip/lib/zip_fopen_index_encrypted.c
-  libzip/lib/zip_fread.c
-  libzip/lib/zip_fseek.c
-  libzip/lib/zip_ftell.c
-  libzip/lib/zip_get_archive_comment.c
-  libzip/lib/zip_get_archive_flag.c
-  libzip/lib/zip_get_encryption_implementation.c
-  libzip/lib/zip_get_file_comment.c
-  libzip/lib/zip_get_name.c
-  libzip/lib/zip_get_num_entries.c
-  libzip/lib/zip_get_num_files.c
-  libzip/lib/zip_hash.c
-  libzip/lib/zip_io_util.c
-  libzip/lib/zip_libzip_version.c
-  libzip/lib/zip_memdup.c
-  libzip/lib/zip_name_locate.c
-  libzip/lib/zip_new.c
-  libzip/lib/zip_open.c
-  libzip/lib/zip_progress.c
-  libzip/lib/zip_rename.c
-  libzip/lib/zip_replace.c
-  libzip/lib/zip_set_archive_comment.c
-  libzip/lib/zip_set_archive_flag.c
-  libzip/lib/zip_set_default_password.c
-  libzip/lib/zip_set_file_comment.c
-  libzip/lib/zip_set_file_compression.c
-  libzip/lib/zip_set_name.c
-  libzip/lib/zip_source_accept_empty.c
-  libzip/lib/zip_source_begin_write.c
-  libzip/lib/zip_source_begin_write_cloning.c
-  libzip/lib/zip_source_buffer.c
-  libzip/lib/zip_source_call.c
-  libzip/lib/zip_source_close.c
-  libzip/lib/zip_source_commit_write.c
-  libzip/lib/zip_source_compress.c
-  libzip/lib/zip_source_crc.c
-  libzip/lib/zip_source_error.c
-  libzip/lib/zip_source_filep.c
-  libzip/lib/zip_source_free.c
-  libzip/lib/zip_source_function.c
-  libzip/lib/zip_source_get_compression_flags.c
-  libzip/lib/zip_source_is_deleted.c
-  libzip/lib/zip_source_layered.c
-  libzip/lib/zip_source_open.c
-  libzip/lib/zip_source_pkware.c
-  libzip/lib/zip_source_read.c
-  libzip/lib/zip_source_remove.c
-  libzip/lib/zip_source_rollback_write.c
-  libzip/lib/zip_source_seek.c
-  libzip/lib/zip_source_seek_write.c
-  libzip/lib/zip_source_stat.c
-  libzip/lib/zip_source_supports.c
-  libzip/lib/zip_source_tell.c
-  libzip/lib/zip_source_tell_write.c
-  libzip/lib/zip_source_window.c
-  libzip/lib/zip_source_write.c
-  libzip/lib/zip_source_zip.c
-  libzip/lib/zip_source_zip_new.c
-  libzip/lib/zip_stat.c
-  libzip/lib/zip_stat_index.c
-  libzip/lib/zip_stat_init.c
-  libzip/lib/zip_strerror.c
-  libzip/lib/zip_string.c
-  libzip/lib/zip_unchange.c
-  libzip/lib/zip_unchange_all.c
-  libzip/lib/zip_unchange_archive.c
-  libzip/lib/zip_unchange_data.c
-  libzip/lib/zip_utf-8.c
-)
-
-IF(WIN32)
-  target_sources(zip PRIVATE
-    libzip/lib/zip_source_win32handle.c
-    libzip/lib/zip_source_win32utf8.c
-    libzip/lib/zip_source_win32w.c
-  )
-  IF(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
-  ELSE()
-    target_sources(zip PRIVATE libzip/lib/zip_source_win32a.c)
-  ENDIF()
-ELSE()
-  target_sources(zip PRIVATE
-    libzip/lib/zip_mkstempm.c
-    libzip/lib/zip_source_file.c
-    libzip/lib/zip_random_unix.c
-  )
-ENDIF()
-
-IF(HAVE_LIBBZ2)
-  target_sources(zip PRIVATE libzip/lib/zip_algorithm_bzip2.c)
-ENDIF()
-
-IF(HAVE_LIBLZMA)
-  target_sources(zip PRIVATE libzip/lib/zip_algorithm_xz.c)
-ENDIF()
-
-IF(HAVE_COMMONCRYPTO)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_commoncrypto.c)
-ELSEIF(HAVE_WINDOWS_CRYPTO)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_win.c)
-ELSEIF(HAVE_GNUTLS)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_gnutls.c)
-ELSEIF(HAVE_OPENSSL)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_openssl.c)
-ELSEIF(HAVE_MBEDTLS)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_mbedtls.c)
-ENDIF()
-
-IF(HAVE_CRYPTO)
-  target_sources(zip PRIVATE
-    libzip/lib/zip_winzip_aes.c
-    libzip/lib/zip_source_winzip_aes_decode.c
-    libzip/lib/zip_source_winzip_aes_encode.c
-  )
-ENDIF()
-
-target_include_directories(zip
-PUBLIC
-  libzip/lib
-  ${CMAKE_CURRENT_BINARY_DIR}/libzip
-)
-
-# pkgconfig file
-SET(prefix ${CMAKE_INSTALL_PREFIX})
-SET(exec_prefix \${prefix})
-SET(bindir \${exec_prefix}/${CMAKE_INSTALL_BINDIR})
-SET(libdir \${exec_prefix}/${CMAKE_INSTALL_LIBDIR})
-SET(includedir \${prefix}/${CMAKE_INSTALL_INCLUDEDIR})
-IF(CMAKE_SYSTEM_NAME MATCHES BSD)
-  SET(PKG_CONFIG_RPATH "-Wl,-R\${libdir}")
-ENDIF(CMAKE_SYSTEM_NAME MATCHES BSD)
-get_target_property(LIBS_PRIVATE zip LINK_LIBRARIES)
-foreach(LIB ${LIBS_PRIVATE})
-  if(LIB MATCHES "^/")
-    get_filename_component(LIB ${LIB} NAME_WE)
-    string(REGEX REPLACE "^lib" "" LIB ${LIB})
-  endif()
-  set(LIBS "${LIBS} -l${LIB}")
-endforeach()
-CONFIGURE_FILE(libzip/libzip.pc.in libzip/libzip.pc @ONLY)
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libzip.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-
-ADD_CUSTOM_TARGET(update_zip_err_str
-  COMMAND sh ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/make_zip_err_str.sh ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/zip.h ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/zip_err_str.c
-  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/zip.h ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/make_zip_err_str.sh
-)
-
-IF(SHARED_LIB_VERSIONNING)
-SET_TARGET_PROPERTIES(zip PROPERTIES VERSION 5.0 SOVERSION 5)
-ENDIF()
-
-TARGET_LINK_LIBRARIES(zip ${ZLIB_LIBRARIES} ${OPTIONAL_LIBRARY})
-INSTALL(TARGETS zip
-  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-)
-

src/common/CMakeLists.txt

@@ -53,6 +53,8 @@ add_library(common STATIC
     div_ceil.h
     dynamic_library.cpp
     dynamic_library.h
+    error.cpp
+    error.h
     fiber.cpp
     fiber.h
     fs/file.cpp
@@ -88,7 +90,6 @@ add_library(common STATIC
     microprofile.cpp
     microprofile.h
     microprofileui.h
-    misc.cpp
     nvidia_flags.cpp
     nvidia_flags.h
     page_table.cpp

src/common/alignment.h

@@ -9,41 +9,48 @@
 namespace Common {
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
     auto mod{static_cast<T>(value % size)};
     value -= mod;
     return static_cast<T>(mod == T{0} ? value : value + size);
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
     return static_cast<T>((value + ((1ULL << align_log2) - 1)) >> align_log2 << align_log2);
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
     return static_cast<T>(value - value % size);
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool Is4KBAligned(T value) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr bool Is4KBAligned(T value) {
     return (value & 0xFFF) == 0;
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool IsWordAligned(T value) {
+requires std::is_unsigned_v<T>
+[[nodiscard]] constexpr bool IsWordAligned(T value) {
     return (value & 0b11) == 0;
 }
 
 template <typename T>
-requires std::is_integral_v<T>[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
+requires std::is_integral_v<T>
+[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
     using U = typename std::make_unsigned_t<T>;
     const U mask = static_cast<U>(alignment - 1);
     return (value & mask) == 0;
 }
 
 template <typename T, typename U>
-requires std::is_integral_v<T>[[nodiscard]] constexpr T DivideUp(T x, U y) {
+requires std::is_integral_v<T>
+[[nodiscard]] constexpr T DivideUp(T x, U y) {
     return (x + (y - 1)) / y;
 }
 

src/common/common_funcs.h

@@ -4,9 +4,8 @@
 
 #pragma once
 
-#include <algorithm>
 #include <array>
-#include <string>
+#include <iterator>
 
 #if !defined(ARCHITECTURE_x86_64)
 #include <cstdlib> // for exit
@@ -49,16 +48,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 
 #endif // _MSC_VER ndef
 
-// Generic function to get last error message.
-// Call directly after the command or use the error num.
-// This function might change the error code.
-// Defined in misc.cpp.
-[[nodiscard]] std::string GetLastErrorMsg();
-
-// Like GetLastErrorMsg(), but passing an explicit error code.
-// Defined in misc.cpp.
-[[nodiscard]] std::string NativeErrorToString(int e);
-
 #define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
     [[nodiscard]] constexpr type operator|(type a, type b) noexcept {                              \
         using T = std::underlying_type_t<type>;                                                    \
@@ -72,6 +61,14 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
         using T = std::underlying_type_t<type>;                                                    \
         return static_cast<type>(static_cast<T>(a) ^ static_cast<T>(b));                           \
     }                                                                                              \
+    [[nodiscard]] constexpr type operator<<(type a, type b) noexcept {                             \
+        using T = std::underlying_type_t<type>;                                                    \
+        return static_cast<type>(static_cast<T>(a) << static_cast<T>(b));                          \
+    }                                                                                              \
+    [[nodiscard]] constexpr type operator>>(type a, type b) noexcept {                             \
+        using T = std::underlying_type_t<type>;                                                    \
+        return static_cast<type>(static_cast<T>(a) >> static_cast<T>(b));                          \
+    }                                                                                              \
     constexpr type& operator|=(type& a, type b) noexcept {                                         \
         a = a | b;                                                                                 \
         return a;                                                                                  \
@@ -84,6 +81,14 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
         a = a ^ b;                                                                                 \
         return a;                                                                                  \
     }                                                                                              \
+    constexpr type& operator<<=(type& a, type b) noexcept {                                        \
+        a = a << b;                                                                                \
+        return a;                                                                                  \
+    }                                                                                              \
+    constexpr type& operator>>=(type& a, type b) noexcept {                                        \
+        a = a >> b;                                                                                \
+        return a;                                                                                  \
+    }                                                                                              \
     [[nodiscard]] constexpr type operator~(type key) noexcept {                                    \
         using T = std::underlying_type_t<type>;                                                    \
         return static_cast<type>(~static_cast<T>(key));                                            \

src/common/div_ceil.h

@@ -11,15 +11,15 @@ namespace Common {
 
 /// Ceiled integer division.
 template <typename N, typename D>
-requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeil(N number,
-                                                                                        D divisor) {
+requires std::is_integral_v<N> && std::is_unsigned_v<D>
+[[nodiscard]] constexpr N DivCeil(N number, D divisor) {
     return static_cast<N>((static_cast<D>(number) + divisor - 1) / divisor);
 }
 
 /// Ceiled integer division with logarithmic divisor in base 2
 template <typename N, typename D>
-requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeilLog2(
-    N value, D alignment_log2) {
+requires std::is_integral_v<N> && std::is_unsigned_v<D>
+[[nodiscard]] constexpr N DivCeilLog2(N value, D alignment_log2) {
     return static_cast<N>((static_cast<D>(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
 }
 

src/common/error.cpp

@@ -10,7 +10,9 @@
 #include <cstring>
 #endif
 
-#include "common/common_funcs.h"
+#include "common/error.h"
+
+namespace Common {
 
 std::string NativeErrorToString(int e) {
 #ifdef _WIN32
@@ -50,3 +52,5 @@ std::string GetLastErrorMsg() {
     return NativeErrorToString(errno);
 #endif
 }
+
+} // namespace Common

src/common/error.h

@@ -0,0 +1,21 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+
+namespace Common {
+
+// Generic function to get last error message.
+// Call directly after the command or use the error num.
+// This function might change the error code.
+// Defined in error.cpp.
+[[nodiscard]] std::string GetLastErrorMsg();
+
+// Like GetLastErrorMsg(), but passing an explicit error code.
+// Defined in error.cpp.
+[[nodiscard]] std::string NativeErrorToString(int e);
+
+} // namespace Common

src/common/fs/fs_paths.h

@@ -21,6 +21,7 @@
 #define SCREENSHOTS_DIR "screenshots"
 #define SDMC_DIR "sdmc"
 #define SHADER_DIR "shader"
+#define TAS_DIR "tas"
 
 // yuzu-specific files
 

src/common/fs/path_util.cpp

@@ -116,6 +116,7 @@ private:
         GenerateYuzuPath(YuzuPath::ScreenshotsDir, yuzu_path / SCREENSHOTS_DIR);
         GenerateYuzuPath(YuzuPath::SDMCDir, yuzu_path / SDMC_DIR);
         GenerateYuzuPath(YuzuPath::ShaderDir, yuzu_path / SHADER_DIR);
+        GenerateYuzuPath(YuzuPath::TASDir, yuzu_path / TAS_DIR);
     }
 
     ~PathManagerImpl() = default;

src/common/fs/path_util.h

@@ -23,6 +23,7 @@ enum class YuzuPath {
     ScreenshotsDir, // Where yuzu screenshots are stored.
     SDMCDir,        // Where the emulated SDMC is stored.
     ShaderDir,      // Where shaders are stored.
+    TASDir,         // Where TAS scripts are stored.
 };
 
 /**

src/common/intrusive_red_black_tree.h

@@ -235,20 +235,19 @@ public:
 
 template <typename T>
 concept HasLightCompareType = requires {
-    { std::is_same<typename T::LightCompareType, void>::value }
-    ->std::convertible_to<bool>;
+    { std::is_same<typename T::LightCompareType, void>::value } -> std::convertible_to<bool>;
 };
 
 namespace impl {
 
-template <typename T, typename Default>
-consteval auto* GetLightCompareType() {
-    if constexpr (HasLightCompareType<T>) {
-        return static_cast<typename T::LightCompareType*>(nullptr);
-    } else {
-        return static_cast<Default*>(nullptr);
+    template <typename T, typename Default>
+    consteval auto* GetLightCompareType() {
+        if constexpr (HasLightCompareType<T>) {
+            return static_cast<typename T::LightCompareType*>(nullptr);
+        } else {
+            return static_cast<Default*>(nullptr);
+        }
     }
-}
 
 } // namespace impl
 

src/common/settings.cpp

@@ -54,14 +54,13 @@ void LogSettings() {
     log_setting("Renderer_GPUAccuracyLevel", values.gpu_accuracy.GetValue());
     log_setting("Renderer_UseAsynchronousGpuEmulation",
                 values.use_asynchronous_gpu_emulation.GetValue());
-    log_setting("Renderer_UseNvdecEmulation", values.use_nvdec_emulation.GetValue());
+    log_setting("Renderer_NvdecEmulation", values.nvdec_emulation.GetValue());
     log_setting("Renderer_AccelerateASTC", values.accelerate_astc.GetValue());
     log_setting("Renderer_UseVsync", values.use_vsync.GetValue());
     log_setting("Renderer_ShaderBackend", values.shader_backend.GetValue());
     log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
     log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
     log_setting("Audio_OutputEngine", values.sink_id.GetValue());
-    log_setting("Audio_EnableAudioStretching", values.enable_audio_stretching.GetValue());
     log_setting("Audio_OutputDevice", values.audio_device_id.GetValue());
     log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd.GetValue());
     log_path("DataStorage_CacheDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir));
@@ -70,8 +69,9 @@ void LogSettings() {
     log_path("DataStorage_NANDDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir));
     log_path("DataStorage_SDMCDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir));
     log_setting("Debugging_ProgramArgs", values.program_args.GetValue());
-    log_setting("Services_BCATBackend", values.bcat_backend.GetValue());
-    log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local.GetValue());
+    log_setting("Input_EnableMotion", values.motion_enabled.GetValue());
+    log_setting("Input_EnableVibration", values.vibration_enabled.GetValue());
+    log_setting("Input_EnableRawInput", values.enable_raw_input.GetValue());
 }
 
 bool IsConfiguringGlobal() {
@@ -112,7 +112,6 @@ void RestoreGlobalState(bool is_powered_on) {
     }
 
     // Audio
-    values.enable_audio_stretching.SetGlobal(true);
     values.volume.SetGlobal(true);
 
     // Core
@@ -136,7 +135,7 @@ void RestoreGlobalState(bool is_powered_on) {
     values.use_disk_shader_cache.SetGlobal(true);
     values.gpu_accuracy.SetGlobal(true);
     values.use_asynchronous_gpu_emulation.SetGlobal(true);
-    values.use_nvdec_emulation.SetGlobal(true);
+    values.nvdec_emulation.SetGlobal(true);
     values.accelerate_astc.SetGlobal(true);
     values.use_vsync.SetGlobal(true);
     values.shader_backend.SetGlobal(true);

src/common/settings.h

@@ -16,7 +16,6 @@
 
 #include "common/common_types.h"
 #include "common/settings_input.h"
-#include "input_common/udp/client.h"
 
 namespace Settings {
 
@@ -48,6 +47,12 @@ enum class FullscreenMode : u32 {
     Exclusive = 1,
 };
 
+enum class NvdecEmulation : u32 {
+    Off = 0,
+    CPU = 1,
+    GPU = 2,
+};
+
 /** The BasicSetting class is a simple resource manager. It defines a label and default value
  * alongside the actual value of the setting for simpler and less-error prone use with frontend
  * configurations. Setting a default value and label is required, though subclasses may deviate from
@@ -409,7 +414,6 @@ struct Values {
     BasicSetting<std::string> audio_device_id{"auto", "output_device"};
     BasicSetting<std::string> sink_id{"auto", "output_engine"};
     BasicSetting<bool> audio_muted{false, "audio_muted"};
-    Setting<bool> enable_audio_stretching{true, "enable_audio_stretching"};
     RangedSetting<u8> volume{100, 0, 100, "volume"};
 
     // Core
@@ -466,7 +470,7 @@ struct Values {
     RangedSetting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
                                             GPUAccuracy::Extreme, "gpu_accuracy"};
     Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
-    Setting<bool> use_nvdec_emulation{true, "use_nvdec_emulation"};
+    Setting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
     Setting<bool> accelerate_astc{true, "accelerate_astc"};
     Setting<bool> use_vsync{true, "use_vsync"};
     BasicRangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
@@ -498,14 +502,20 @@ struct Values {
 
     Setting<bool> use_docked_mode{true, "use_docked_mode"};
 
+    BasicSetting<bool> enable_raw_input{false, "enable_raw_input"};
+
     Setting<bool> vibration_enabled{true, "vibration_enabled"};
     Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
 
     Setting<bool> motion_enabled{true, "motion_enabled"};
     BasicSetting<std::string> motion_device{"engine:motion_emu,update_period:100,sensitivity:0.01",
                                             "motion_device"};
-    BasicSetting<std::string> udp_input_servers{InputCommon::CemuhookUDP::DEFAULT_SRV,
-                                                "udp_input_servers"};
+    BasicSetting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
+
+    BasicSetting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
+    BasicSetting<bool> tas_enable{false, "tas_enable"};
+    BasicSetting<bool> tas_loop{false, "tas_loop"};
+    BasicSetting<bool> tas_swap_controllers{true, "tas_swap_controllers"};
 
     BasicSetting<bool> mouse_panning{false, "mouse_panning"};
     BasicRangedSetting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
@@ -558,8 +568,6 @@ struct Values {
     BasicSetting<bool> use_dev_keys{false, "use_dev_keys"};
 
     // Network
-    BasicSetting<std::string> bcat_backend{"none", "bcat_backend"};
-    BasicSetting<bool> bcat_boxcat_local{false, "bcat_boxcat_local"};
     BasicSetting<std::string> network_interface{std::string(), "network_interface"};
 
     // WebService

src/common/thread.cpp

@@ -2,7 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "common/common_funcs.h"
+#include <string>
+
+#include "common/error.h"
 #include "common/logging/log.h"
 #include "common/thread.h"
 #ifdef __APPLE__
@@ -21,8 +23,6 @@
 #include <unistd.h>
 #endif
 
-#include <string>
-
 #ifdef __FreeBSD__
 #define cpu_set_t cpuset_t
 #endif

src/common/threadsafe_queue.h

@@ -14,7 +14,7 @@
 #include <utility>
 
 namespace Common {
-template <typename T>
+template <typename T, bool with_stop_token = false>
 class SPSCQueue {
 public:
     SPSCQueue() {
@@ -84,7 +84,7 @@ public:
     void Wait() {
         if (Empty()) {
             std::unique_lock lock{cv_mutex};
-            cv.wait(lock, [this]() { return !Empty(); });
+            cv.wait(lock, [this] { return !Empty(); });
         }
     }
 
@@ -95,6 +95,19 @@ public:
         return t;
     }
 
+    T PopWait(std::stop_token stop_token) {
+        if (Empty()) {
+            std::unique_lock lock{cv_mutex};
+            cv.wait(lock, stop_token, [this] { return !Empty(); });
+        }
+        if (stop_token.stop_requested()) {
+            return T{};
+        }
+        T t;
+        Pop(t);
+        return t;
+    }
+
     // not thread-safe
     void Clear() {
         size.store(0);
@@ -123,13 +136,13 @@ private:
     ElementPtr* read_ptr;
     std::atomic_size_t size{0};
     std::mutex cv_mutex;
-    std::condition_variable cv;
+    std::conditional_t<with_stop_token, std::condition_variable_any, std::condition_variable> cv;
 };
 
 // a simple thread-safe,
 // single reader, multiple writer queue
 
-template <typename T>
+template <typename T, bool with_stop_token = false>
 class MPSCQueue {
 public:
     [[nodiscard]] std::size_t Size() const {
@@ -166,13 +179,17 @@ public:
         return spsc_queue.PopWait();
     }
 
+    T PopWait(std::stop_token stop_token) {
+        return spsc_queue.PopWait(stop_token);
+    }
+
     // not thread-safe
     void Clear() {
         spsc_queue.Clear();
     }
 
 private:
-    SPSCQueue<T> spsc_queue;
+    SPSCQueue<T, with_stop_token> spsc_queue;
     std::mutex write_lock;
 };
 } // namespace Common

src/common/uuid.h

@@ -58,6 +58,13 @@ struct UUID {
         uuid = INVALID_UUID;
     }
 
+    [[nodiscard]] constexpr bool IsInvalid() const {
+        return uuid == INVALID_UUID;
+    }
+    [[nodiscard]] constexpr bool IsValid() const {
+        return !IsInvalid();
+    }
+
     // TODO(ogniK): Properly generate a Nintendo ID
     [[nodiscard]] constexpr u64 GetNintendoID() const {
         return uuid[0];

src/common/vector_math.h

@@ -667,8 +667,8 @@ template <typename T>
 
 // linear interpolation via float: 0.0=begin, 1.0=end
 template <typename X>
-[[nodiscard]] constexpr decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
-                                                                     const float t) {
+[[nodiscard]] constexpr decltype(X{} * float{} + X{} * float{})
+    Lerp(const X& begin, const X& end, const float t) {
     return begin * (1.f - t) + end * t;
 }
 

src/core/CMakeLists.txt

@@ -106,8 +106,6 @@ add_library(core STATIC
     file_sys/vfs_concat.h
     file_sys/vfs_layered.cpp
     file_sys/vfs_layered.h
-    file_sys/vfs_libzip.cpp
-    file_sys/vfs_libzip.h
     file_sys/vfs_offset.cpp
     file_sys/vfs_offset.h
     file_sys/vfs_real.cpp
@@ -263,6 +261,8 @@ add_library(core STATIC
     hle/service/acc/acc_u0.h
     hle/service/acc/acc_u1.cpp
     hle/service/acc/acc_u1.h
+    hle/service/acc/async_context.cpp
+    hle/service/acc/async_context.h
     hle/service/acc/errors.h
     hle/service/acc/profile_manager.cpp
     hle/service/acc/profile_manager.h
@@ -651,13 +651,6 @@ add_library(core STATIC
     tools/freezer.h
 )
 
-if (YUZU_ENABLE_BOXCAT)
-    target_sources(core PRIVATE
-        hle/service/bcat/backend/boxcat.cpp
-        hle/service/bcat/backend/boxcat.h
-    )
-endif()
-
 if (MSVC)
     target_compile_options(core PRIVATE
         /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
@@ -688,12 +681,7 @@ endif()
 create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus zip)
-
-if (YUZU_ENABLE_BOXCAT)
-    target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
-    target_link_libraries(core PRIVATE httplib nlohmann_json::nlohmann_json)
-endif()
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus)
 
 if (ENABLE_WEB_SERVICE)
     target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)

src/core/core.cpp

@@ -83,6 +83,12 @@ FileSys::StorageId GetStorageIdForFrontendSlot(
     }
 }
 
+void KProcessDeleter(Kernel::KProcess* process) {
+    process->Destroy();
+}
+
+using KProcessPtr = std::unique_ptr<Kernel::KProcess, decltype(&KProcessDeleter)>;
+
 } // Anonymous namespace
 
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
@@ -233,8 +239,8 @@ struct System::Impl {
         }
 
         telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-        auto main_process = Kernel::KProcess::Create(system.Kernel());
-        ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
+        main_process = KProcessPtr{Kernel::KProcess::Create(system.Kernel()), KProcessDeleter};
+        ASSERT(Kernel::KProcess::Initialize(main_process.get(), system, "main",
                                             Kernel::KProcess::ProcessType::Userland)
                    .IsSuccess());
         main_process->Open();
@@ -247,7 +253,7 @@ struct System::Impl {
                                              static_cast<u32>(load_result));
         }
         AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeCurrentProcess(main_process);
+        kernel.MakeCurrentProcess(main_process.get());
         kernel.InitializeCores();
 
         // Initialize cheat engine
@@ -299,10 +305,6 @@ struct System::Impl {
         is_powered_on = false;
         exit_lock = false;
 
-        if (gpu_core) {
-            gpu_core->ShutDown();
-        }
-
         services.reset();
         service_manager.reset();
         cheat_engine.reset();
@@ -311,11 +313,13 @@ struct System::Impl {
         time_manager.Shutdown();
         core_timing.Shutdown();
         app_loader.reset();
-        gpu_core.reset();
         perf_stats.reset();
+        gpu_core.reset();
         kernel.Shutdown();
         memory.Reset();
         applet_manager.ClearAll();
+        // TODO: The main process should be freed based on KAutoObject ref counting.
+        main_process.reset();
 
         LOG_DEBUG(Core, "Shutdown OK");
     }
@@ -374,6 +378,7 @@ struct System::Impl {
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
     std::unique_ptr<Core::DeviceMemory> device_memory;
+    KProcessPtr main_process{nullptr, KProcessDeleter};
     Core::Memory::Memory memory;
     CpuManager cpu_manager;
     std::atomic_bool is_powered_on{};

src/core/cpu_manager.cpp

@@ -21,34 +21,25 @@ namespace Core {
 CpuManager::CpuManager(System& system_) : system{system_} {}
 CpuManager::~CpuManager() = default;
 
-void CpuManager::ThreadStart(CpuManager& cpu_manager, std::size_t core) {
-    cpu_manager.RunThread(core);
+void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
+                             std::size_t core) {
+    cpu_manager.RunThread(stop_token, core);
 }
 
 void CpuManager::Initialize() {
     running_mode = true;
     if (is_multicore) {
         for (std::size_t core = 0; core < Core::Hardware::NUM_CPU_CORES; core++) {
-            core_data[core].host_thread =
-                std::make_unique<std::thread>(ThreadStart, std::ref(*this), core);
+            core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
         }
     } else {
-        core_data[0].host_thread = std::make_unique<std::thread>(ThreadStart, std::ref(*this), 0);
+        core_data[0].host_thread = std::jthread(ThreadStart, std::ref(*this), 0);
     }
 }
 
 void CpuManager::Shutdown() {
     running_mode = false;
     Pause(false);
-    if (is_multicore) {
-        for (auto& data : core_data) {
-            data.host_thread->join();
-            data.host_thread.reset();
-        }
-    } else {
-        core_data[0].host_thread->join();
-        core_data[0].host_thread.reset();
-    }
 }
 
 std::function<void(void*)> CpuManager::GetGuestThreadStartFunc() {
@@ -317,7 +308,7 @@ void CpuManager::Pause(bool paused) {
     }
 }
 
-void CpuManager::RunThread(std::size_t core) {
+void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
     /// Initialization
     system.RegisterCoreThread(core);
     std::string name;
@@ -361,6 +352,10 @@ void CpuManager::RunThread(std::size_t core) {
             return;
         }
 
+        if (stop_token.stop_requested()) {
+            break;
+        }
+
         auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
         data.is_running = true;
         Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());

src/core/cpu_manager.h

@@ -78,9 +78,9 @@ private:
     void SingleCoreRunSuspendThread();
     void SingleCorePause(bool paused);
 
-    static void ThreadStart(CpuManager& cpu_manager, std::size_t core);
+    static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);
 
-    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;
@@ -89,7 +89,7 @@ private:
         std::atomic<bool> is_running;
         std::atomic<bool> is_paused;
         std::atomic<bool> initialized;
-        std::unique_ptr<std::thread> host_thread;
+        std::jthread host_thread;
     };
 
     std::atomic<bool> running_mode{};

src/core/file_sys/kernel_executable.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include <string>
 #include <vector>
 
 #include "common/common_funcs.h"

src/core/file_sys/vfs.cpp

@@ -273,6 +273,10 @@ VirtualFile VfsDirectory::GetFile(std::string_view name) const {
     return iter == files.end() ? nullptr : *iter;
 }
 
+FileTimeStampRaw VfsDirectory::GetFileTimeStamp([[maybe_unused]] std::string_view path) const {
+    return {};
+}
+
 VirtualDir VfsDirectory::GetSubdirectory(std::string_view name) const {
     const auto& subs = GetSubdirectories();
     const auto iter = std::find_if(subs.begin(), subs.end(),

src/core/file_sys/vfs.h

@@ -199,6 +199,9 @@ public:
     // file with name.
     virtual VirtualFile GetFile(std::string_view name) const;
 
+    // Returns a struct containing the file's timestamp.
+    virtual FileTimeStampRaw GetFileTimeStamp(std::string_view path) const;
+
     // Returns a vector containing all of the subdirectories in this directory.
     virtual std::vector<VirtualDir> GetSubdirectories() const = 0;
     // Returns the directory with name matching name. Returns nullptr if directory dosen't have a

src/core/file_sys/vfs_libzip.cpp

@@ -1,88 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string>
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshadow"
-#endif
-#include <zip.h>
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-#include "common/fs/path_util.h"
-#include "core/file_sys/vfs.h"
-#include "core/file_sys/vfs_libzip.h"
-#include "core/file_sys/vfs_vector.h"
-
-namespace FileSys {
-
-VirtualDir ExtractZIP(VirtualFile file) {
-    zip_error_t error{};
-
-    const auto data = file->ReadAllBytes();
-    std::unique_ptr<zip_source_t, decltype(&zip_source_close)> src{
-        zip_source_buffer_create(data.data(), data.size(), 0, &error), zip_source_close};
-    if (src == nullptr)
-        return nullptr;
-
-    std::unique_ptr<zip_t, decltype(&zip_close)> zip{zip_open_from_source(src.get(), 0, &error),
-                                                     zip_close};
-    if (zip == nullptr)
-        return nullptr;
-
-    std::shared_ptr<VectorVfsDirectory> out = std::make_shared<VectorVfsDirectory>();
-
-    const auto num_entries = static_cast<std::size_t>(zip_get_num_entries(zip.get(), 0));
-
-    zip_stat_t stat{};
-    zip_stat_init(&stat);
-
-    for (std::size_t i = 0; i < num_entries; ++i) {
-        const auto stat_res = zip_stat_index(zip.get(), i, 0, &stat);
-        if (stat_res == -1)
-            return nullptr;
-
-        const std::string name(stat.name);
-        if (name.empty())
-            continue;
-
-        if (name.back() != '/') {
-            std::unique_ptr<zip_file_t, decltype(&zip_fclose)> file2{
-                zip_fopen_index(zip.get(), i, 0), zip_fclose};
-
-            std::vector<u8> buf(stat.size);
-            if (zip_fread(file2.get(), buf.data(), buf.size()) != s64(buf.size()))
-                return nullptr;
-
-            const auto parts = Common::FS::SplitPathComponents(stat.name);
-            const auto new_file = std::make_shared<VectorVfsFile>(buf, parts.back());
-
-            std::shared_ptr<VectorVfsDirectory> dtrv = out;
-            for (std::size_t j = 0; j < parts.size() - 1; ++j) {
-                if (dtrv == nullptr)
-                    return nullptr;
-                const auto subdir = dtrv->GetSubdirectory(parts[j]);
-                if (subdir == nullptr) {
-                    const auto temp = std::make_shared<VectorVfsDirectory>(
-                        std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, parts[j]);
-                    dtrv->AddDirectory(temp);
-                    dtrv = temp;
-                } else {
-                    dtrv = std::dynamic_pointer_cast<VectorVfsDirectory>(subdir);
-                }
-            }
-
-            if (dtrv == nullptr)
-                return nullptr;
-            dtrv->AddFile(new_file);
-        }
-    }
-
-    return out;
-}
-
-} // namespace FileSys

src/core/file_sys/vfs_libzip.h

@@ -1,13 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/file_sys/vfs_types.h"
-
-namespace FileSys {
-
-VirtualDir ExtractZIP(VirtualFile zip);
-
-} // namespace FileSys

src/core/file_sys/vfs_real.cpp

@@ -13,6 +13,13 @@
 #include "common/logging/log.h"
 #include "core/file_sys/vfs_real.h"
 
+// For FileTimeStampRaw
+#include <sys/stat.h>
+
+#ifdef _MSC_VER
+#define stat _stat64
+#endif
+
 namespace FileSys {
 
 namespace FS = Common::FS;
@@ -392,6 +399,28 @@ std::vector<VirtualFile> RealVfsDirectory::GetFiles() const {
     return IterateEntries<RealVfsFile, VfsFile>();
 }
 
+FileTimeStampRaw RealVfsDirectory::GetFileTimeStamp(std::string_view path_) const {
+    const auto full_path = FS::SanitizePath(path + '/' + std::string(path_));
+    const auto fs_path = std::filesystem::path{FS::ToU8String(full_path)};
+    struct stat file_status;
+
+#ifdef _WIN32
+    const auto stat_result = _wstat64(fs_path.c_str(), &file_status);
+#else
+    const auto stat_result = stat(fs_path.c_str(), &file_status);
+#endif
+
+    if (stat_result != 0) {
+        return {};
+    }
+
+    return {
+        .created{static_cast<u64>(file_status.st_ctime)},
+        .accessed{static_cast<u64>(file_status.st_atime)},
+        .modified{static_cast<u64>(file_status.st_mtime)},
+    };
+}
+
 std::vector<VirtualDir> RealVfsDirectory::GetSubdirectories() const {
     return IterateEntries<RealVfsDirectory, VfsDirectory>();
 }

src/core/file_sys/vfs_real.h

@@ -86,6 +86,7 @@ public:
     VirtualDir CreateDirectoryRelative(std::string_view relative_path) override;
     bool DeleteSubdirectoryRecursive(std::string_view name) override;
     std::vector<VirtualFile> GetFiles() const override;
+    FileTimeStampRaw GetFileTimeStamp(std::string_view path) const override;
     std::vector<VirtualDir> GetSubdirectories() const override;
     bool IsWritable() const override;
     bool IsReadable() const override;

src/core/file_sys/vfs_types.h

@@ -6,6 +6,8 @@
 
 #include <memory>
 
+#include "common/common_types.h"
+
 namespace FileSys {
 
 class VfsDirectory;
@@ -18,4 +20,11 @@ using VirtualDir = std::shared_ptr<VfsDirectory>;
 using VirtualFile = std::shared_ptr<VfsFile>;
 using VirtualFilesystem = std::shared_ptr<VfsFilesystem>;
 
+struct FileTimeStampRaw {
+    u64 created{};
+    u64 accessed{};
+    u64 modified{};
+    u64 padding{};
+};
+
 } // namespace FileSys

src/core/frontend/applets/profile_select.cpp

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

src/core/hle/api_version.h

@@ -28,13 +28,20 @@ constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 12.1.0-1.0";
 
 // Atmosphere version constants.
 
-constexpr u8 ATMOSPHERE_RELEASE_VERSION_MAJOR = 0;
-constexpr u8 ATMOSPHERE_RELEASE_VERSION_MINOR = 19;
-constexpr u8 ATMOSPHERE_RELEASE_VERSION_MICRO = 5;
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MAJOR = 1;
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MINOR = 0;
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MICRO = 0;
+
+constexpr u32 AtmosphereTargetFirmwareWithRevision(u8 major, u8 minor, u8 micro, u8 rev) {
+    return u32{major} << 24 | u32{minor} << 16 | u32{micro} << 8 | u32{rev};
+}
+
+constexpr u32 AtmosphereTargetFirmware(u8 major, u8 minor, u8 micro) {
+    return AtmosphereTargetFirmwareWithRevision(major, minor, micro, 0);
+}
 
 constexpr u32 GetTargetFirmware() {
-    return u32{HOS_VERSION_MAJOR} << 24 | u32{HOS_VERSION_MINOR} << 16 |
-           u32{HOS_VERSION_MICRO} << 8 | 0U;
+    return AtmosphereTargetFirmware(HOS_VERSION_MAJOR, HOS_VERSION_MINOR, HOS_VERSION_MICRO);
 }
 
 } // namespace HLE::ApiVersion

src/core/hle/kernel/k_priority_queue.h

@@ -22,12 +22,10 @@ class KThread;
 
 template <typename T>
 concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T & t) {
-    { t.GetAffinityMask() }
-    ->Common::ConvertibleTo<u64>;
+    { t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
     {t.SetAffinityMask(0)};
 
-    { t.GetAffinity(0) }
-    ->std::same_as<bool>;
+    { t.GetAffinity(0) } -> std::same_as<bool>;
     {t.SetAffinity(0, false)};
     {t.SetAll()};
 };
@@ -38,25 +36,20 @@ concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T & t) {
     {(typename T::QueueEntry()).Initialize()};
     {(typename T::QueueEntry()).SetPrev(std::addressof(t))};
     {(typename T::QueueEntry()).SetNext(std::addressof(t))};
-    { (typename T::QueueEntry()).GetNext() }
-    ->std::same_as<T*>;
-    { (typename T::QueueEntry()).GetPrev() }
-    ->std::same_as<T*>;
-    { t.GetPriorityQueueEntry(0) }
-    ->std::same_as<typename T::QueueEntry&>;
+    { (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>;
+    { (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>;
+    { t.GetPriorityQueueEntry(0) } -> std::same_as<typename T::QueueEntry&>;
 
     {t.GetAffinityMask()};
-    { std::remove_cvref_t<decltype(t.GetAffinityMask())>() }
-    ->KPriorityQueueAffinityMask;
+    { std::remove_cvref_t<decltype(t.GetAffinityMask())>() } -> KPriorityQueueAffinityMask;
 
-    { t.GetActiveCore() }
-    ->Common::ConvertibleTo<s32>;
-    { t.GetPriority() }
-    ->Common::ConvertibleTo<s32>;
+    { t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
+    { t.GetPriority() } -> Common::ConvertibleTo<s32>;
 };
 
 template <typename Member, size_t NumCores_, int LowestPriority, int HighestPriority>
-requires KPriorityQueueMember<Member> class KPriorityQueue {
+requires KPriorityQueueMember<Member>
+class KPriorityQueue {
 public:
     using AffinityMaskType = std::remove_cv_t<
         std::remove_reference_t<decltype(std::declval<Member>().GetAffinityMask())>>;

src/core/hle/kernel/k_scheduler.h

@@ -197,7 +197,7 @@ private:
 
 class [[nodiscard]] KScopedSchedulerLock : KScopedLock<GlobalSchedulerContext::LockType> {
 public:
-    explicit KScopedSchedulerLock(KernelCore & kernel);
+    explicit KScopedSchedulerLock(KernelCore& kernel);
     ~KScopedSchedulerLock();
 };
 

src/core/hle/kernel/k_scoped_lock.h

@@ -13,19 +13,18 @@ namespace Kernel {
 
 template <typename T>
 concept KLockable = !std::is_reference_v<T> && requires(T & t) {
-    { t.Lock() }
-    ->std::same_as<void>;
-    { t.Unlock() }
-    ->std::same_as<void>;
+    { t.Lock() } -> std::same_as<void>;
+    { t.Unlock() } -> std::same_as<void>;
 };
 
 template <typename T>
-requires KLockable<T> class [[nodiscard]] KScopedLock {
+requires KLockable<T>
+class [[nodiscard]] KScopedLock {
 public:
-    explicit KScopedLock(T * l) : lock_ptr(l) {
+    explicit KScopedLock(T* l) : lock_ptr(l) {
         this->lock_ptr->Lock();
     }
-    explicit KScopedLock(T & l) : KScopedLock(std::addressof(l)) {}
+    explicit KScopedLock(T& l) : KScopedLock(std::addressof(l)) {}
 
     ~KScopedLock() {
         this->lock_ptr->Unlock();
@@ -34,7 +33,7 @@ public:
     KScopedLock(const KScopedLock&) = delete;
     KScopedLock& operator=(const KScopedLock&) = delete;
 
-    KScopedLock(KScopedLock &&) = delete;
+    KScopedLock(KScopedLock&&) = delete;
     KScopedLock& operator=(KScopedLock&&) = delete;
 
 private:

src/core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h

@@ -17,7 +17,7 @@ namespace Kernel {
 
 class [[nodiscard]] KScopedSchedulerLockAndSleep {
 public:
-    explicit KScopedSchedulerLockAndSleep(KernelCore & kernel_, KThread * t, s64 timeout)
+    explicit KScopedSchedulerLockAndSleep(KernelCore& kernel_, KThread* t, s64 timeout)
         : kernel(kernel_), thread(t), timeout_tick(timeout) {
         // Lock the scheduler.
         kernel.GlobalSchedulerContext().scheduler_lock.Lock();

src/core/hle/kernel/kernel.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include <functional>
 #include <memory>
 #include <string>
 #include <unordered_map>

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

@@ -23,6 +23,7 @@
 #include "core/hle/service/acc/acc_su.h"
 #include "core/hle/service/acc/acc_u0.h"
 #include "core/hle/service/acc/acc_u1.h"
+#include "core/hle/service/acc/async_context.h"
 #include "core/hle/service/acc/errors.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/glue/arp.h"
@@ -454,22 +455,6 @@ public:
         : IProfileCommon{system_, "IProfileEditor", true, user_id_, profile_manager_} {}
 };
 
-class IAsyncContext final : public ServiceFramework<IAsyncContext> {
-public:
-    explicit IAsyncContext(Core::System& system_) : ServiceFramework{system_, "IAsyncContext"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetSystemEvent"},
-            {1, nullptr, "Cancel"},
-            {2, nullptr, "HasDone"},
-            {3, nullptr, "GetResult"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
 class ISessionObject final : public ServiceFramework<ISessionObject> {
 public:
     explicit ISessionObject(Core::System& system_, Common::UUID)
@@ -504,16 +489,44 @@ public:
     }
 };
 
+class EnsureTokenIdCacheAsyncInterface final : public IAsyncContext {
+public:
+    explicit EnsureTokenIdCacheAsyncInterface(Core::System& system_) : IAsyncContext{system_} {
+        MarkComplete();
+    }
+    ~EnsureTokenIdCacheAsyncInterface() = default;
+
+    void LoadIdTokenCache(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+protected:
+    bool IsComplete() const override {
+        return true;
+    }
+
+    void Cancel() override {}
+
+    ResultCode GetResult() const override {
+        return ResultSuccess;
+    }
+};
+
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
     explicit IManagerForApplication(Core::System& system_, Common::UUID user_id_)
-        : ServiceFramework{system_, "IManagerForApplication"}, user_id{user_id_} {
+        : ServiceFramework{system_, "IManagerForApplication"},
+          ensure_token_id{std::make_shared<EnsureTokenIdCacheAsyncInterface>(system)},
+          user_id{user_id_} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
             {1, &IManagerForApplication::GetAccountId, "GetAccountId"},
-            {2, nullptr, "EnsureIdTokenCacheAsync"},
-            {3, nullptr, "LoadIdTokenCache"},
+            {2, &IManagerForApplication::EnsureIdTokenCacheAsync, "EnsureIdTokenCacheAsync"},
+            {3, &IManagerForApplication::LoadIdTokenCache, "LoadIdTokenCache"},
             {130, &IManagerForApplication::GetNintendoAccountUserResourceCacheForApplication, "GetNintendoAccountUserResourceCacheForApplication"},
             {150, nullptr, "CreateAuthorizationRequest"},
             {160, &IManagerForApplication::StoreOpenContext, "StoreOpenContext"},
@@ -540,6 +553,20 @@ private:
         rb.PushRaw<u64>(user_id.GetNintendoID());
     }
 
+    void EnsureIdTokenCacheAsync(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface(ensure_token_id);
+    }
+
+    void LoadIdTokenCache(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+
+        ensure_token_id->LoadIdTokenCache(ctx);
+    }
+
     void GetNintendoAccountUserResourceCacheForApplication(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_ACC, "(STUBBED) called");
 
@@ -562,6 +589,7 @@ private:
         rb.Push(ResultSuccess);
     }
 
+    std::shared_ptr<EnsureTokenIdCacheAsyncInterface> ensure_token_id{};
     Common::UUID user_id{Common::INVALID_UUID};
 };
 
@@ -901,8 +929,7 @@ void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContex
     }
 
     const auto user_list = profile_manager->GetAllUsers();
-    if (std::all_of(user_list.begin(), user_list.end(),
-                    [](const auto& user) { return user.uuid == Common::INVALID_UUID; })) {
+    if (std::ranges::all_of(user_list, [](const auto& user) { return user.IsInvalid(); })) {
         rb.Push(ResultUnknown); // TODO(ogniK): Find the correct error code
         rb.PushRaw<u128>(Common::INVALID_UUID);
         return;

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

@@ -0,0 +1,68 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/core.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/acc/async_context.h"
+
+namespace Service::Account {
+IAsyncContext::IAsyncContext(Core::System& system_)
+    : ServiceFramework{system_, "IAsyncContext"}, compeletion_event{system_.Kernel()} {
+
+    Kernel::KAutoObject::Create(std::addressof(compeletion_event));
+    compeletion_event.Initialize("IAsyncContext:CompletionEvent");
+
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, &IAsyncContext::GetSystemEvent, "GetSystemEvent"},
+        {1, &IAsyncContext::Cancel, "Cancel"},
+        {2, &IAsyncContext::HasDone, "HasDone"},
+        {3, &IAsyncContext::GetResult, "GetResult"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+void IAsyncContext::GetSystemEvent(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_ACC, "called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(compeletion_event.GetReadableEvent());
+}
+
+void IAsyncContext::Cancel(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_ACC, "called");
+
+    Cancel();
+    MarkComplete();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void IAsyncContext::HasDone(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_ACC, "called");
+
+    is_complete.store(IsComplete());
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(is_complete.load());
+}
+
+void IAsyncContext::GetResult(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_ACC, "called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(GetResult());
+}
+
+void IAsyncContext::MarkComplete() {
+    is_complete.store(true);
+    compeletion_event.GetWritableEvent().Signal();
+}
+
+} // namespace Service::Account

src/core/hle/service/acc/async_context.h

@@ -0,0 +1,37 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <atomic>
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Account {
+
+class IAsyncContext : public ServiceFramework<IAsyncContext> {
+public:
+    explicit IAsyncContext(Core::System& system_);
+
+    void GetSystemEvent(Kernel::HLERequestContext& ctx);
+    void Cancel(Kernel::HLERequestContext& ctx);
+    void HasDone(Kernel::HLERequestContext& ctx);
+    void GetResult(Kernel::HLERequestContext& ctx);
+
+protected:
+    virtual bool IsComplete() const = 0;
+    virtual void Cancel() = 0;
+    virtual ResultCode GetResult() const = 0;
+
+    void MarkComplete();
+
+    std::atomic<bool> is_complete{false};
+    Kernel::KEvent compeletion_event;
+};
+
+} // namespace Service::Account

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

@@ -208,9 +208,10 @@ bool ProfileManager::UserExists(UUID uuid) const {
 }
 
 bool ProfileManager::UserExistsIndex(std::size_t index) const {
-    if (index >= MAX_USERS)
+    if (index >= MAX_USERS) {
         return false;
-    return profiles[index].user_uuid.uuid != Common::INVALID_UUID;
+    }
+    return profiles[index].user_uuid.IsValid();
 }
 
 /// Opens a specific user
@@ -304,7 +305,7 @@ bool ProfileManager::RemoveUser(UUID uuid) {
 
 bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
     const auto index = GetUserIndex(uuid);
-    if (!index || profile_new.user_uuid == UUID(Common::INVALID_UUID)) {
+    if (!index || profile_new.user_uuid.IsInvalid()) {
         return false;
     }
 
@@ -346,7 +347,7 @@ void ProfileManager::ParseUserSaveFile() {
     }
 
     for (const auto& user : data.users) {
-        if (user.uuid == UUID(Common::INVALID_UUID)) {
+        if (user.uuid.IsInvalid()) {
             continue;
         }
 

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

@@ -275,12 +275,14 @@ ISelfController::ISelfController(Core::System& system_, NVFlinger::NVFlinger& nv
         {18, nullptr, "SetRequiresCaptureButtonShortPressedMessage"},
         {19, &ISelfController::SetAlbumImageOrientation, "SetAlbumImageOrientation"},
         {20, nullptr, "SetDesirableKeyboardLayout"},
+        {21, nullptr, "GetScreenShotProgramId"},
         {40, &ISelfController::CreateManagedDisplayLayer, "CreateManagedDisplayLayer"},
         {41, nullptr, "IsSystemBufferSharingEnabled"},
         {42, nullptr, "GetSystemSharedLayerHandle"},
         {43, nullptr, "GetSystemSharedBufferHandle"},
         {44, &ISelfController::CreateManagedDisplaySeparableLayer, "CreateManagedDisplaySeparableLayer"},
         {45, nullptr, "SetManagedDisplayLayerSeparationMode"},
+        {46, nullptr, "SetRecordingLayerCompositionEnabled"},
         {50, &ISelfController::SetHandlesRequestToDisplay, "SetHandlesRequestToDisplay"},
         {51, nullptr, "ApproveToDisplay"},
         {60, nullptr, "OverrideAutoSleepTimeAndDimmingTime"},
@@ -302,6 +304,7 @@ ISelfController::ISelfController(Core::System& system_, NVFlinger::NVFlinger& nv
         {100, &ISelfController::SetAlbumImageTakenNotificationEnabled, "SetAlbumImageTakenNotificationEnabled"},
         {110, nullptr, "SetApplicationAlbumUserData"},
         {120, nullptr, "SaveCurrentScreenshot"},
+        {130, nullptr, "SetRecordVolumeMuted"},
         {1000, nullptr, "GetDebugStorageChannel"},
     };
     // clang-format on
@@ -683,6 +686,7 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_,
         {91, nullptr, "GetCurrentPerformanceConfiguration"},
         {100, nullptr, "SetHandlingHomeButtonShortPressedEnabled"},
         {110, nullptr, "OpenMyGpuErrorHandler"},
+        {120, nullptr, "GetAppletLaunchedHistory"},
         {200, nullptr, "GetOperationModeSystemInfo"},
         {300, nullptr, "GetSettingsPlatformRegion"},
         {400, nullptr, "ActivateMigrationService"},
@@ -1270,7 +1274,8 @@ void ILibraryAppletCreator::CreateHandleStorage(Kernel::HLERequestContext& ctx)
 IApplicationFunctions::IApplicationFunctions(Core::System& system_)
     : ServiceFramework{system_, "IApplicationFunctions"}, gpu_error_detected_event{system.Kernel()},
       friend_invitation_storage_channel_event{system.Kernel()},
-      health_warning_disappeared_system_event{system.Kernel()} {
+      notification_storage_channel_event{system.Kernel()}, health_warning_disappeared_system_event{
+                                                               system.Kernel()} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
@@ -1322,7 +1327,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
         {131, nullptr, "SetDelayTimeToAbortOnGpuError"},
         {140, &IApplicationFunctions::GetFriendInvitationStorageChannelEvent, "GetFriendInvitationStorageChannelEvent"},
         {141, &IApplicationFunctions::TryPopFromFriendInvitationStorageChannel, "TryPopFromFriendInvitationStorageChannel"},
-        {150, nullptr, "GetNotificationStorageChannelEvent"},
+        {150, &IApplicationFunctions::GetNotificationStorageChannelEvent, "GetNotificationStorageChannelEvent"},
         {151, nullptr, "TryPopFromNotificationStorageChannel"},
         {160, &IApplicationFunctions::GetHealthWarningDisappearedSystemEvent, "GetHealthWarningDisappearedSystemEvent"},
         {170, nullptr, "SetHdcpAuthenticationActivated"},
@@ -1340,11 +1345,14 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
 
     Kernel::KAutoObject::Create(std::addressof(gpu_error_detected_event));
     Kernel::KAutoObject::Create(std::addressof(friend_invitation_storage_channel_event));
+    Kernel::KAutoObject::Create(std::addressof(notification_storage_channel_event));
     Kernel::KAutoObject::Create(std::addressof(health_warning_disappeared_system_event));
 
     gpu_error_detected_event.Initialize("IApplicationFunctions:GpuErrorDetectedSystemEvent");
     friend_invitation_storage_channel_event.Initialize(
         "IApplicationFunctions:FriendInvitationStorageChannelEvent");
+    notification_storage_channel_event.Initialize(
+        "IApplicationFunctions:NotificationStorageChannelEvent");
     health_warning_disappeared_system_event.Initialize(
         "IApplicationFunctions:HealthWarningDisappearedSystemEvent");
 }
@@ -1762,6 +1770,14 @@ void IApplicationFunctions::TryPopFromFriendInvitationStorageChannel(
     rb.Push(ERR_NO_DATA_IN_CHANNEL);
 }
 
+void IApplicationFunctions::GetNotificationStorageChannelEvent(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(notification_storage_channel_event.GetReadableEvent());
+}
+
 void IApplicationFunctions::GetHealthWarningDisappearedSystemEvent(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_AM, "called");
 

src/core/hle/service/am/am.h

@@ -295,6 +295,7 @@ private:
     void GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx);
     void GetFriendInvitationStorageChannelEvent(Kernel::HLERequestContext& ctx);
     void TryPopFromFriendInvitationStorageChannel(Kernel::HLERequestContext& ctx);
+    void GetNotificationStorageChannelEvent(Kernel::HLERequestContext& ctx);
     void GetHealthWarningDisappearedSystemEvent(Kernel::HLERequestContext& ctx);
 
     bool launch_popped_application_specific = false;
@@ -302,6 +303,7 @@ private:
     s32 previous_program_index{-1};
     Kernel::KEvent gpu_error_detected_event;
     Kernel::KEvent friend_invitation_storage_channel_event;
+    Kernel::KEvent notification_storage_channel_event;
     Kernel::KEvent health_warning_disappeared_system_event;
 };
 

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

@@ -60,7 +60,7 @@ void ProfileSelect::Execute() {
 void ProfileSelect::SelectionComplete(std::optional<Common::UUID> uuid) {
     UserSelectionOutput output{};
 
-    if (uuid.has_value() && uuid->uuid != Common::INVALID_UUID) {
+    if (uuid.has_value() && uuid->IsValid()) {
         output.result = 0;
         output.uuid_selected = uuid->uuid;
     } else {

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

@@ -41,6 +41,14 @@ AudCtl::AudCtl(Core::System& system_) : ServiceFramework{system_, "audctl"} {
         {27, nullptr, "SetVolumeMappingTableForDev"},
         {28, nullptr, "GetAudioOutputChannelCountForPlayReport"},
         {29, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"},
+        {30, nullptr, "Unknown30"},
+        {31, nullptr, "Unknown31"},
+        {32, nullptr, "Unknown32"},
+        {33, nullptr, "Unknown33"},
+        {34, nullptr, "Unknown34"},
+        {10000, nullptr, "Unknown10000"},
+        {10001, nullptr, "Unknown10001"},
+        {10002, nullptr, "Unknown10002"},
     };
     // clang-format on
 

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

@@ -3,38 +3,65 @@
 // Refer to the license.txt file included.
 
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
+#include "core/hle/kernel/k_event.h"
 #include "core/hle/service/audio/audin_u.h"
 
 namespace Service::Audio {
 
-class IAudioIn final : public ServiceFramework<IAudioIn> {
-public:
-    explicit IAudioIn(Core::System& system_) : ServiceFramework{system_, "IAudioIn"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetAudioInState"},
-            {1, nullptr, "Start"},
-            {2, nullptr, "Stop"},
-            {3, nullptr, "AppendAudioInBuffer"},
-            {4, nullptr, "RegisterBufferEvent"},
-            {5, nullptr, "GetReleasedAudioInBuffer"},
-            {6, nullptr, "ContainsAudioInBuffer"},
-            {7, nullptr, "AppendUacInBuffer"},
-            {8, nullptr, "AppendAudioInBufferAuto"},
-            {9, nullptr, "GetReleasedAudioInBuffersAuto"},
-            {10, nullptr, "AppendUacInBufferAuto"},
-            {11, nullptr, "GetAudioInBufferCount"},
-            {12, nullptr, "SetDeviceGain"},
-            {13, nullptr, "GetDeviceGain"},
-            {14, nullptr, "FlushAudioInBuffers"},
-        };
-        // clang-format on
+IAudioIn::IAudioIn(Core::System& system_)
+    : ServiceFramework{system_, "IAudioIn"}, buffer_event{system_.Kernel()} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetAudioInState"},
+        {1, &IAudioIn::Start, "Start"},
+        {2, nullptr, "Stop"},
+        {3, nullptr, "AppendAudioInBuffer"},
+        {4, &IAudioIn::RegisterBufferEvent, "RegisterBufferEvent"},
+        {5, nullptr, "GetReleasedAudioInBuffer"},
+        {6, nullptr, "ContainsAudioInBuffer"},
+        {7, nullptr, "AppendUacInBuffer"},
+        {8, &IAudioIn::AppendAudioInBufferAuto, "AppendAudioInBufferAuto"},
+        {9, nullptr, "GetReleasedAudioInBuffersAuto"},
+        {10, nullptr, "AppendUacInBufferAuto"},
+        {11, nullptr, "GetAudioInBufferCount"},
+        {12, nullptr, "SetDeviceGain"},
+        {13, nullptr, "GetDeviceGain"},
+        {14, nullptr, "FlushAudioInBuffers"},
+    };
+    // clang-format on
 
-        RegisterHandlers(functions);
-    }
-};
+    RegisterHandlers(functions);
+
+    Kernel::KAutoObject::Create(std::addressof(buffer_event));
+    buffer_event.Initialize("IAudioIn:BufferEvent");
+}
+
+IAudioIn::~IAudioIn() = default;
+
+void IAudioIn::Start(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void IAudioIn::RegisterBufferEvent(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(buffer_event.GetReadableEvent());
+}
+
+void IAudioIn::AppendAudioInBufferAuto(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
 
 AudInU::AudInU(Core::System& system_) : ServiceFramework{system_, "audin:u"} {
     // clang-format off

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

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "core/hle/kernel/k_event.h"
 #include "core/hle/service/service.h"
 
 namespace Core {
@@ -16,6 +17,19 @@ class HLERequestContext;
 
 namespace Service::Audio {
 
+class IAudioIn final : public ServiceFramework<IAudioIn> {
+public:
+    explicit IAudioIn(Core::System& system_);
+    ~IAudioIn() override;
+
+private:
+    void Start(Kernel::HLERequestContext& ctx);
+    void RegisterBufferEvent(Kernel::HLERequestContext& ctx);
+    void AppendAudioInBufferAuto(Kernel::HLERequestContext& ctx);
+
+    Kernel::KEvent buffer_event;
+};
+
 class AudInU final : public ServiceFramework<AudInU> {
 public:
     explicit AudInU(Core::System& system_);

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

@@ -187,7 +187,8 @@ public:
             {10, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceNameAuto"},
             {11, &IAudioDevice::QueryAudioDeviceInputEvent, "QueryAudioDeviceInputEvent"},
             {12, &IAudioDevice::QueryAudioDeviceOutputEvent, "QueryAudioDeviceOutputEvent"},
-            {13, nullptr, "GetAudioSystemMasterVolumeSetting"},
+            {13, nullptr, "GetActiveAudioOutputDeviceName"},
+            {14, nullptr, "ListAudioOutputDeviceName"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/bcat/backend/boxcat.cpp

@@ -1,548 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <fmt/ostream.h>
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshadow"
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-#endif
-#include <httplib.h>
-#include <mbedtls/sha256.h>
-#include <nlohmann/json.hpp>
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-#include "common/fs/file.h"
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
-#include "common/hex_util.h"
-#include "common/logging/log.h"
-#include "common/settings.h"
-#include "core/core.h"
-#include "core/file_sys/vfs.h"
-#include "core/file_sys/vfs_libzip.h"
-#include "core/file_sys/vfs_vector.h"
-#include "core/frontend/applets/error.h"
-#include "core/hle/service/am/applets/applets.h"
-#include "core/hle/service/bcat/backend/boxcat.h"
-
-namespace Service::BCAT {
-namespace {
-
-// Prevents conflicts with windows macro called CreateFile
-FileSys::VirtualFile VfsCreateFileWrap(FileSys::VirtualDir dir, std::string_view name) {
-    return dir->CreateFile(name);
-}
-
-// Prevents conflicts with windows macro called DeleteFile
-bool VfsDeleteFileWrap(FileSys::VirtualDir dir, std::string_view name) {
-    return dir->DeleteFile(name);
-}
-
-constexpr ResultCode ERROR_GENERAL_BCAT_FAILURE{ErrorModule::BCAT, 1};
-
-constexpr char BOXCAT_HOSTNAME[] = "api.yuzu-emu.org";
-
-// Formatted using fmt with arg[0] = hex title id
-constexpr char BOXCAT_PATHNAME_DATA[] = "/game-assets/{:016X}/boxcat";
-constexpr char BOXCAT_PATHNAME_LAUNCHPARAM[] = "/game-assets/{:016X}/launchparam";
-
-constexpr char BOXCAT_PATHNAME_EVENTS[] = "/game-assets/boxcat/events";
-
-constexpr char BOXCAT_API_VERSION[] = "1";
-constexpr char BOXCAT_CLIENT_TYPE[] = "yuzu";
-
-// HTTP status codes for Boxcat
-enum class ResponseStatus {
-    Ok = 200,               ///< Operation completed successfully.
-    BadClientVersion = 301, ///< The Boxcat-Client-Version doesn't match the server.
-    NoUpdate = 304,         ///< The digest provided would match the new data, no need to update.
-    NoMatchTitleId = 404,   ///< The title ID provided doesn't have a boxcat implementation.
-    NoMatchBuildId = 406,   ///< The build ID provided is blacklisted (potentially because of format
-                            ///< issues or whatnot) and has no data.
-};
-
-enum class DownloadResult {
-    Success = 0,
-    NoResponse,
-    GeneralWebError,
-    NoMatchTitleId,
-    NoMatchBuildId,
-    InvalidContentType,
-    GeneralFSError,
-    BadClientVersion,
-};
-
-constexpr std::array<const char*, 8> DOWNLOAD_RESULT_LOG_MESSAGES{
-    "Success",
-    "There was no response from the server.",
-    "There was a general web error code returned from the server.",
-    "The title ID of the current game doesn't have a boxcat implementation. If you believe an "
-    "implementation should be added, contact yuzu support.",
-    "The build ID of the current version of the game is marked as incompatible with the current "
-    "BCAT distribution. Try upgrading or downgrading your game version or contacting yuzu support.",
-    "The content type of the web response was invalid.",
-    "There was a general filesystem error while saving the zip file.",
-    "The server is either too new or too old to serve the request. Try using the latest version of "
-    "an official release of yuzu.",
-};
-
-std::ostream& operator<<(std::ostream& os, DownloadResult result) {
-    return os << DOWNLOAD_RESULT_LOG_MESSAGES.at(static_cast<std::size_t>(result));
-}
-
-constexpr u32 PORT = 443;
-constexpr u32 TIMEOUT_SECONDS = 30;
-[[maybe_unused]] constexpr u64 VFS_COPY_BLOCK_SIZE = 1ULL << 24; // 4MB
-
-std::filesystem::path GetBINFilePath(u64 title_id) {
-    return Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir) / "bcat" /
-           fmt::format("{:016X}/launchparam.bin", title_id);
-}
-
-std::filesystem::path GetZIPFilePath(u64 title_id) {
-    return Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir) / "bcat" /
-           fmt::format("{:016X}/data.zip", title_id);
-}
-
-// If the error is something the user should know about (build ID mismatch, bad client version),
-// display an error.
-void HandleDownloadDisplayResult(const AM::Applets::AppletManager& applet_manager,
-                                 DownloadResult res) {
-    if (res == DownloadResult::Success || res == DownloadResult::NoResponse ||
-        res == DownloadResult::GeneralWebError || res == DownloadResult::GeneralFSError ||
-        res == DownloadResult::NoMatchTitleId || res == DownloadResult::InvalidContentType) {
-        return;
-    }
-
-    const auto& frontend{applet_manager.GetAppletFrontendSet()};
-    frontend.error->ShowCustomErrorText(
-        ResultUnknown, "There was an error while attempting to use Boxcat.",
-        DOWNLOAD_RESULT_LOG_MESSAGES[static_cast<std::size_t>(res)], [] {});
-}
-
-bool VfsRawCopyProgress(FileSys::VirtualFile src, FileSys::VirtualFile dest,
-                        std::string_view dir_name, ProgressServiceBackend& progress,
-                        std::size_t block_size = 0x1000) {
-    if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable())
-        return false;
-    if (!dest->Resize(src->GetSize()))
-        return false;
-
-    progress.StartDownloadingFile(dir_name, src->GetName(), src->GetSize());
-
-    std::vector<u8> temp(std::min(block_size, src->GetSize()));
-    for (std::size_t i = 0; i < src->GetSize(); i += block_size) {
-        const auto read = std::min(block_size, src->GetSize() - i);
-
-        if (src->Read(temp.data(), read, i) != read) {
-            return false;
-        }
-
-        if (dest->Write(temp.data(), read, i) != read) {
-            return false;
-        }
-
-        progress.UpdateFileProgress(i);
-    }
-
-    progress.FinishDownloadingFile();
-
-    return true;
-}
-
-bool VfsRawCopyDProgressSingle(FileSys::VirtualDir src, FileSys::VirtualDir dest,
-                               ProgressServiceBackend& progress, std::size_t block_size = 0x1000) {
-    if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable())
-        return false;
-
-    for (const auto& file : src->GetFiles()) {
-        const auto out_file = VfsCreateFileWrap(dest, file->GetName());
-        if (!VfsRawCopyProgress(file, out_file, src->GetName(), progress, block_size)) {
-            return false;
-        }
-    }
-    progress.CommitDirectory(src->GetName());
-
-    return true;
-}
-
-bool VfsRawCopyDProgress(FileSys::VirtualDir src, FileSys::VirtualDir dest,
-                         ProgressServiceBackend& progress, std::size_t block_size = 0x1000) {
-    if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable())
-        return false;
-
-    for (const auto& dir : src->GetSubdirectories()) {
-        const auto out = dest->CreateSubdirectory(dir->GetName());
-        if (!VfsRawCopyDProgressSingle(dir, out, progress, block_size)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-} // Anonymous namespace
-
-class Boxcat::Client {
-public:
-    Client(std::filesystem::path path_, u64 title_id_, u64 build_id_)
-        : path(std::move(path_)), title_id(title_id_), build_id(build_id_) {}
-
-    DownloadResult DownloadDataZip() {
-        return DownloadInternal(fmt::format(BOXCAT_PATHNAME_DATA, title_id), TIMEOUT_SECONDS,
-                                "application/zip");
-    }
-
-    DownloadResult DownloadLaunchParam() {
-        return DownloadInternal(fmt::format(BOXCAT_PATHNAME_LAUNCHPARAM, title_id),
-                                TIMEOUT_SECONDS / 3, "application/octet-stream");
-    }
-
-private:
-    DownloadResult DownloadInternal(const std::string& resolved_path, u32 timeout_seconds,
-                                    const std::string& content_type_name) {
-        if (client == nullptr) {
-            client = std::make_unique<httplib::SSLClient>(BOXCAT_HOSTNAME, PORT);
-            client->set_connection_timeout(timeout_seconds);
-            client->set_read_timeout(timeout_seconds);
-            client->set_write_timeout(timeout_seconds);
-        }
-
-        httplib::Headers headers{
-            {std::string("Game-Assets-API-Version"), std::string(BOXCAT_API_VERSION)},
-            {std::string("Boxcat-Client-Type"), std::string(BOXCAT_CLIENT_TYPE)},
-            {std::string("Game-Build-Id"), fmt::format("{:016X}", build_id)},
-        };
-
-        if (Common::FS::Exists(path)) {
-            Common::FS::IOFile file{path, Common::FS::FileAccessMode::Read,
-                                    Common::FS::FileType::BinaryFile};
-            if (file.IsOpen()) {
-                std::vector<u8> bytes(file.GetSize());
-                void(file.Read(bytes));
-                const auto digest = DigestFile(bytes);
-                headers.insert({std::string("If-None-Match"), Common::HexToString(digest, false)});
-            }
-        }
-
-        const auto response = client->Get(resolved_path.c_str(), headers);
-        if (response == nullptr)
-            return DownloadResult::NoResponse;
-
-        if (response->status == static_cast<int>(ResponseStatus::NoUpdate))
-            return DownloadResult::Success;
-        if (response->status == static_cast<int>(ResponseStatus::BadClientVersion))
-            return DownloadResult::BadClientVersion;
-        if (response->status == static_cast<int>(ResponseStatus::NoMatchTitleId))
-            return DownloadResult::NoMatchTitleId;
-        if (response->status == static_cast<int>(ResponseStatus::NoMatchBuildId))
-            return DownloadResult::NoMatchBuildId;
-        if (response->status != static_cast<int>(ResponseStatus::Ok))
-            return DownloadResult::GeneralWebError;
-
-        const auto content_type = response->headers.find("content-type");
-        if (content_type == response->headers.end() ||
-            content_type->second.find(content_type_name) == std::string::npos) {
-            return DownloadResult::InvalidContentType;
-        }
-
-        if (!Common::FS::CreateDirs(path)) {
-            return DownloadResult::GeneralFSError;
-        }
-
-        Common::FS::IOFile file{path, Common::FS::FileAccessMode::Append,
-                                Common::FS::FileType::BinaryFile};
-        if (!file.IsOpen()) {
-            return DownloadResult::GeneralFSError;
-        }
-
-        if (!file.SetSize(response->body.size())) {
-            return DownloadResult::GeneralFSError;
-        }
-
-        if (file.Write(response->body) != response->body.size()) {
-            return DownloadResult::GeneralFSError;
-        }
-
-        return DownloadResult::Success;
-    }
-
-    using Digest = std::array<u8, 0x20>;
-    static Digest DigestFile(std::vector<u8> bytes) {
-        Digest out{};
-        mbedtls_sha256_ret(bytes.data(), bytes.size(), out.data(), 0);
-        return out;
-    }
-
-    std::unique_ptr<httplib::SSLClient> client;
-    std::filesystem::path path;
-    u64 title_id;
-    u64 build_id;
-};
-
-Boxcat::Boxcat(AM::Applets::AppletManager& applet_manager_, DirectoryGetter getter)
-    : Backend(std::move(getter)), applet_manager{applet_manager_} {}
-
-Boxcat::~Boxcat() = default;
-
-void SynchronizeInternal(AM::Applets::AppletManager& applet_manager, DirectoryGetter dir_getter,
-                         TitleIDVersion title, ProgressServiceBackend& progress,
-                         std::optional<std::string> dir_name = {}) {
-    progress.SetNeedHLELock(true);
-
-    if (Settings::values.bcat_boxcat_local) {
-        LOG_INFO(Service_BCAT, "Boxcat using local data by override, skipping download.");
-        const auto dir = dir_getter(title.title_id);
-        if (dir)
-            progress.SetTotalSize(dir->GetSize());
-        progress.FinishDownload(ResultSuccess);
-        return;
-    }
-
-    const auto zip_path = GetZIPFilePath(title.title_id);
-    Boxcat::Client client{zip_path, title.title_id, title.build_id};
-
-    progress.StartConnecting();
-
-    const auto res = client.DownloadDataZip();
-    if (res != DownloadResult::Success) {
-        LOG_ERROR(Service_BCAT, "Boxcat synchronization failed with error '{}'!", res);
-
-        if (res == DownloadResult::NoMatchBuildId || res == DownloadResult::NoMatchTitleId) {
-            Common::FS::RemoveFile(zip_path);
-        }
-
-        HandleDownloadDisplayResult(applet_manager, res);
-        progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
-        return;
-    }
-
-    progress.StartProcessingDataList();
-
-    Common::FS::IOFile zip{zip_path, Common::FS::FileAccessMode::Read,
-                           Common::FS::FileType::BinaryFile};
-    const auto size = zip.GetSize();
-    std::vector<u8> bytes(size);
-    if (!zip.IsOpen() || size == 0 || zip.Read(bytes) != bytes.size()) {
-        LOG_ERROR(Service_BCAT, "Boxcat failed to read ZIP file at path '{}'!",
-                  Common::FS::PathToUTF8String(zip_path));
-        progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
-        return;
-    }
-
-    const auto extracted = FileSys::ExtractZIP(std::make_shared<FileSys::VectorVfsFile>(bytes));
-    if (extracted == nullptr) {
-        LOG_ERROR(Service_BCAT, "Boxcat failed to extract ZIP file!");
-        progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
-        return;
-    }
-
-    if (dir_name == std::nullopt) {
-        progress.SetTotalSize(extracted->GetSize());
-
-        const auto target_dir = dir_getter(title.title_id);
-        if (target_dir == nullptr || !VfsRawCopyDProgress(extracted, target_dir, progress)) {
-            LOG_ERROR(Service_BCAT, "Boxcat failed to copy extracted ZIP to target directory!");
-            progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
-            return;
-        }
-    } else {
-        const auto target_dir = dir_getter(title.title_id);
-        if (target_dir == nullptr) {
-            LOG_ERROR(Service_BCAT, "Boxcat failed to get directory for title ID!");
-            progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
-            return;
-        }
-
-        const auto target_sub = target_dir->GetSubdirectory(*dir_name);
-        const auto source_sub = extracted->GetSubdirectory(*dir_name);
-
-        progress.SetTotalSize(source_sub->GetSize());
-
-        std::vector<std::string> filenames;
-        {
-            const auto files = target_sub->GetFiles();
-            std::transform(files.begin(), files.end(), std::back_inserter(filenames),
-                           [](const auto& vfile) { return vfile->GetName(); });
-        }
-
-        for (const auto& filename : filenames) {
-            VfsDeleteFileWrap(target_sub, filename);
-        }
-
-        if (target_sub == nullptr || source_sub == nullptr ||
-            !VfsRawCopyDProgressSingle(source_sub, target_sub, progress)) {
-            LOG_ERROR(Service_BCAT, "Boxcat failed to copy extracted ZIP to target directory!");
-            progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
-            return;
-        }
-    }
-
-    progress.FinishDownload(ResultSuccess);
-}
-
-bool Boxcat::Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) {
-    is_syncing.exchange(true);
-
-    std::thread([this, title, &progress] {
-        SynchronizeInternal(applet_manager, dir_getter, title, progress);
-    }).detach();
-
-    return true;
-}
-
-bool Boxcat::SynchronizeDirectory(TitleIDVersion title, std::string name,
-                                  ProgressServiceBackend& progress) {
-    is_syncing.exchange(true);
-
-    std::thread([this, title, name, &progress] {
-        SynchronizeInternal(applet_manager, dir_getter, title, progress, name);
-    }).detach();
-
-    return true;
-}
-
-bool Boxcat::Clear(u64 title_id) {
-    if (Settings::values.bcat_boxcat_local) {
-        LOG_INFO(Service_BCAT, "Boxcat using local data by override, skipping clear.");
-        return true;
-    }
-
-    const auto dir = dir_getter(title_id);
-
-    std::vector<std::string> dirnames;
-
-    for (const auto& subdir : dir->GetSubdirectories())
-        dirnames.push_back(subdir->GetName());
-
-    for (const auto& subdir : dirnames) {
-        if (!dir->DeleteSubdirectoryRecursive(subdir))
-            return false;
-    }
-
-    return true;
-}
-
-void Boxcat::SetPassphrase(u64 title_id, const Passphrase& passphrase) {
-    LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, passphrase={}", title_id,
-              Common::HexToString(passphrase));
-}
-
-std::optional<std::vector<u8>> Boxcat::GetLaunchParameter(TitleIDVersion title) {
-    const auto bin_file_path = GetBINFilePath(title.title_id);
-
-    if (Settings::values.bcat_boxcat_local) {
-        LOG_INFO(Service_BCAT, "Boxcat using local data by override, skipping download.");
-    } else {
-        Client launch_client{bin_file_path, title.title_id, title.build_id};
-
-        const auto res = launch_client.DownloadLaunchParam();
-        if (res != DownloadResult::Success) {
-            LOG_ERROR(Service_BCAT, "Boxcat synchronization failed with error '{}'!", res);
-
-            if (res == DownloadResult::NoMatchBuildId || res == DownloadResult::NoMatchTitleId) {
-                Common::FS::RemoveFile(bin_file_path);
-            }
-
-            HandleDownloadDisplayResult(applet_manager, res);
-            return std::nullopt;
-        }
-    }
-
-    Common::FS::IOFile bin{bin_file_path, Common::FS::FileAccessMode::Read,
-                           Common::FS::FileType::BinaryFile};
-    const auto size = bin.GetSize();
-    std::vector<u8> bytes(size);
-    if (!bin.IsOpen() || size == 0 || bin.Read(bytes) != bytes.size()) {
-        LOG_ERROR(Service_BCAT, "Boxcat failed to read launch parameter binary at path '{}'!",
-                  Common::FS::PathToUTF8String(bin_file_path));
-        return std::nullopt;
-    }
-
-    return bytes;
-}
-
-Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global,
-                                       std::map<std::string, EventStatus>& games) {
-    httplib::SSLClient client{BOXCAT_HOSTNAME, static_cast<int>(PORT)};
-    client.set_connection_timeout(static_cast<int>(TIMEOUT_SECONDS));
-    client.set_read_timeout(static_cast<int>(TIMEOUT_SECONDS));
-    client.set_write_timeout(static_cast<int>(TIMEOUT_SECONDS));
-
-    httplib::Headers headers{
-        {std::string("Game-Assets-API-Version"), std::string(BOXCAT_API_VERSION)},
-        {std::string("Boxcat-Client-Type"), std::string(BOXCAT_CLIENT_TYPE)},
-    };
-
-    if (!client.is_valid()) {
-        LOG_ERROR(Service_BCAT, "Client is invalid, going offline!");
-        return StatusResult::Offline;
-    }
-
-    if (!client.is_socket_open()) {
-        LOG_ERROR(Service_BCAT, "Failed to open socket, going offline!");
-        return StatusResult::Offline;
-    }
-
-    const auto response = client.Get(BOXCAT_PATHNAME_EVENTS, headers);
-    if (response == nullptr)
-        return StatusResult::Offline;
-
-    if (response->status == static_cast<int>(ResponseStatus::BadClientVersion))
-        return StatusResult::BadClientVersion;
-
-    try {
-        nlohmann::json json = nlohmann::json::parse(response->body);
-
-        if (!json["online"].get<bool>())
-            return StatusResult::Offline;
-
-        if (json["global"].is_null())
-            global = std::nullopt;
-        else
-            global = json["global"].get<std::string>();
-
-        if (json["games"].is_array()) {
-            for (const auto& object : json["games"]) {
-                if (object.is_object() && object.find("name") != object.end()) {
-                    EventStatus detail{};
-                    if (object["header"].is_string()) {
-                        detail.header = object["header"].get<std::string>();
-                    } else {
-                        detail.header = std::nullopt;
-                    }
-
-                    if (object["footer"].is_string()) {
-                        detail.footer = object["footer"].get<std::string>();
-                    } else {
-                        detail.footer = std::nullopt;
-                    }
-
-                    if (object["events"].is_array()) {
-                        for (const auto& event : object["events"]) {
-                            if (!event.is_string())
-                                continue;
-                            detail.events.push_back(event.get<std::string>());
-                        }
-                    }
-
-                    games.insert_or_assign(object["name"], std::move(detail));
-                }
-            }
-        }
-
-        return StatusResult::Success;
-    } catch (const nlohmann::json::parse_error& error) {
-        LOG_ERROR(Service_BCAT, "{}", error.what());
-        return StatusResult::ParseError;
-    }
-}
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/backend/boxcat.h

@@ -1,64 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <atomic>
-#include <map>
-#include <optional>
-#include "core/hle/service/bcat/backend/backend.h"
-
-namespace Service::AM::Applets {
-class AppletManager;
-}
-
-namespace Service::BCAT {
-
-struct EventStatus {
-    std::optional<std::string> header;
-    std::optional<std::string> footer;
-    std::vector<std::string> events;
-};
-
-/// Boxcat is yuzu's custom backend implementation of Nintendo's BCAT service. It is free to use and
-/// doesn't require a switch or nintendo account. The content is controlled by the yuzu team.
-class Boxcat final : public Backend {
-    friend void SynchronizeInternal(AM::Applets::AppletManager& applet_manager,
-                                    DirectoryGetter dir_getter, TitleIDVersion title,
-                                    ProgressServiceBackend& progress,
-                                    std::optional<std::string> dir_name);
-
-public:
-    explicit Boxcat(AM::Applets::AppletManager& applet_manager_, DirectoryGetter getter);
-    ~Boxcat() override;
-
-    bool Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) override;
-    bool SynchronizeDirectory(TitleIDVersion title, std::string name,
-                              ProgressServiceBackend& progress) override;
-
-    bool Clear(u64 title_id) override;
-
-    void SetPassphrase(u64 title_id, const Passphrase& passphrase) override;
-
-    std::optional<std::vector<u8>> GetLaunchParameter(TitleIDVersion title) override;
-
-    enum class StatusResult {
-        Success,
-        Offline,
-        ParseError,
-        BadClientVersion,
-    };
-
-    static StatusResult GetStatus(std::optional<std::string>& global,
-                                  std::map<std::string, EventStatus>& games);
-
-private:
-    std::atomic_bool is_syncing{false};
-
-    class Client;
-    std::unique_ptr<Client> client;
-    AM::Applets::AppletManager& applet_manager;
-};
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_module.cpp

@@ -4,7 +4,6 @@
 
 #include <cctype>
 #include <mbedtls/md5.h>
-#include "backend/boxcat.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
@@ -578,12 +577,6 @@ void Module::Interface::CreateDeliveryCacheStorageServiceWithApplicationId(
 
 std::unique_ptr<Backend> CreateBackendFromSettings([[maybe_unused]] Core::System& system,
                                                    DirectoryGetter getter) {
-#ifdef YUZU_ENABLE_BOXCAT
-    if (Settings::values.bcat_backend.GetValue() == "boxcat") {
-        return std::make_unique<Boxcat>(system.GetAppletManager(), std::move(getter));
-    }
-#endif
-
     return std::make_unique<NullBackend>(std::move(getter));
 }
 

src/core/hle/service/btdrv/btdrv.cpp

@@ -175,6 +175,10 @@ public:
             {143, nullptr, "GetAudioControlInputState"},
             {144, nullptr, "AcquireAudioConnectionStateChangedEvent"},
             {145, nullptr, "GetConnectedAudioDevice"},
+            {146, nullptr, "CloseAudioControlInput"},
+            {147, nullptr, "RegisterAudioControlNotification"},
+            {148, nullptr, "SendAudioControlPassthroughCommand"},
+            {149, nullptr, "SendAudioControlSetAbsoluteVolumeCommand"},
             {256, nullptr, "IsManufacturingMode"},
             {257, nullptr, "EmulateBluetoothCrash"},
             {258, nullptr, "GetBleChannelMap"},

src/core/hle/service/caps/caps_ss.cpp

@@ -15,6 +15,7 @@ CAPS_SS::CAPS_SS(Core::System& system_) : ServiceFramework{system_, "caps:ss"} {
         {204, nullptr, "SaveEditedScreenShotEx0"},
         {206, nullptr, "Unknown206"},
         {208, nullptr, "SaveScreenShotOfMovieEx1"},
+        {1000, nullptr, "Unknown1000"},
     };
     // clang-format on
 

src/core/hle/service/es/es.cpp

@@ -55,6 +55,8 @@ public:
             {36, nullptr, "DeleteAllInactiveELicenseRequiredPersonalizedTicket"},
             {37, nullptr, "OwnTicket2"},
             {38, nullptr, "OwnTicket3"},
+            {39, nullptr, "DeleteAllInactivePersonalizedTicket"},
+            {40, nullptr, "DeletePrepurchaseRecordByNintendoAccountId"},
             {501, nullptr, "Unknown501"},
             {502, nullptr, "Unknown502"},
             {503, nullptr, "GetTitleKey"},
@@ -88,11 +90,15 @@ public:
             {1503, nullptr, "Unknown1503"},
             {1504, nullptr, "Unknown1504"},
             {1505, nullptr, "Unknown1505"},
+            {1506, nullptr, "Unknown1506"},
             {2000, nullptr, "Unknown2000"},
             {2001, nullptr, "Unknown2001"},
+            {2002, nullptr, "Unknown2002"},
+            {2003, nullptr, "Unknown2003"},
             {2100, nullptr, "Unknown2100"},
             {2501, nullptr, "Unknown2501"},
             {2502, nullptr, "Unknown2502"},
+            {2601, nullptr, "Unknown2601"},
             {3001, nullptr, "Unknown3001"},
             {3002, nullptr, "Unknown3002"},
         };

src/core/hle/service/filesystem/filesystem.cpp

@@ -97,14 +97,24 @@ ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) cons
 
 ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path_) const {
     std::string path(Common::FS::SanitizePath(path_));
-    auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
-    if (dir == nullptr || Common::FS::GetFilename(Common::FS::GetParentPath(path)).empty()) {
-        dir = backing;
-    }
-    auto new_dir = dir->CreateSubdirectory(Common::FS::GetFilename(path));
-    if (new_dir == nullptr) {
-        // TODO(DarkLordZach): Find a better error code for this
-        return ResultUnknown;
+
+    // NOTE: This is inaccurate behavior. CreateDirectory is not recursive.
+    // CreateDirectory should return PathNotFound if the parent directory does not exist.
+    // This is here temporarily in order to have UMM "work" in the meantime.
+    // TODO (Morph): Remove this when a hardware test verifies the correct behavior.
+    const auto components = Common::FS::SplitPathComponents(path);
+    std::string relative_path;
+    for (const auto& component : components) {
+        // Skip empty path components
+        if (component.empty()) {
+            continue;
+        }
+        relative_path = Common::FS::SanitizePath(relative_path + '/' + component);
+        auto new_dir = backing->CreateSubdirectory(relative_path);
+        if (new_dir == nullptr) {
+            // TODO(DarkLordZach): Find a better error code for this
+            return ResultUnknown;
+        }
     }
     return ResultSuccess;
 }
@@ -251,6 +261,18 @@ ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
     return FileSys::ERROR_PATH_NOT_FOUND;
 }
 
+ResultVal<FileSys::FileTimeStampRaw> VfsDirectoryServiceWrapper::GetFileTimeStampRaw(
+    const std::string& path) const {
+    auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
+    if (dir == nullptr) {
+        return FileSys::ERROR_PATH_NOT_FOUND;
+    }
+    if (GetEntryType(path).Failed()) {
+        return FileSys::ERROR_PATH_NOT_FOUND;
+    }
+    return MakeResult(dir->GetFileTimeStamp(Common::FS::GetFilename(path)));
+}
+
 FileSystemController::FileSystemController(Core::System& system_) : system{system_} {}
 
 FileSystemController::~FileSystemController() = default;

src/core/hle/service/filesystem/filesystem.h

@@ -240,6 +240,12 @@ public:
      */
     ResultVal<FileSys::EntryType> GetEntryType(const std::string& path) const;
 
+    /**
+     * Get the timestamp of the specified path
+     * @return The timestamp of the specified path or error code
+     */
+    ResultVal<FileSys::FileTimeStampRaw> GetFileTimeStampRaw(const std::string& path) const;
+
 private:
     FileSys::VirtualDir backing;
 };

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -326,7 +326,7 @@ public:
             {11, &IFileSystem::GetFreeSpaceSize, "GetFreeSpaceSize"},
             {12, &IFileSystem::GetTotalSpaceSize, "GetTotalSpaceSize"},
             {13, &IFileSystem::CleanDirectoryRecursively, "CleanDirectoryRecursively"},
-            {14, nullptr, "GetFileTimeStampRaw"},
+            {14, &IFileSystem::GetFileTimeStampRaw, "GetFileTimeStampRaw"},
             {15, nullptr, "QueryEntry"},
         };
         RegisterHandlers(functions);
@@ -501,6 +501,24 @@ public:
         rb.Push(size.get_total_size());
     }
 
+    void GetFileTimeStampRaw(Kernel::HLERequestContext& ctx) {
+        const auto file_buffer = ctx.ReadBuffer();
+        const std::string name = Common::StringFromBuffer(file_buffer);
+
+        LOG_WARNING(Service_FS, "(Partial Implementation) called. file={}", name);
+
+        auto result = backend.GetFileTimeStampRaw(name);
+        if (result.Failed()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(result.Code());
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, 10};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(*result);
+    }
+
 private:
     VfsDirectoryServiceWrapper backend;
     SizeGetter size;

src/core/hle/service/hid/controllers/npad.h

@@ -507,6 +507,7 @@ private:
         LarkNesRight = 18,
         Lucia = 19,
         Verification = 20,
+        Lagon = 21,
     };
 
     struct NPadEntry {

src/core/hle/service/hid/controllers/touchscreen.h

@@ -15,6 +15,20 @@
 namespace Service::HID {
 class Controller_Touchscreen final : public ControllerBase {
 public:
+    enum class TouchScreenModeForNx : u8 {
+        UseSystemSetting,
+        Finger,
+        Heat2,
+    };
+
+    struct TouchScreenConfigurationForNx {
+        TouchScreenModeForNx mode;
+        INSERT_PADDING_BYTES_NOINIT(0x7);
+        INSERT_PADDING_BYTES_NOINIT(0xF); // Reserved
+    };
+    static_assert(sizeof(TouchScreenConfigurationForNx) == 0x17,
+                  "TouchScreenConfigurationForNx is an invalid size");
+
     explicit Controller_Touchscreen(Core::System& system_);
     ~Controller_Touchscreen() override;
 

src/core/hle/service/hid/hid.cpp

@@ -239,6 +239,12 @@ Hid::Hid(Core::System& system_)
         {81, &Hid::ResetGyroscopeZeroDriftMode, "ResetGyroscopeZeroDriftMode"},
         {82, &Hid::IsSixAxisSensorAtRest, "IsSixAxisSensorAtRest"},
         {83, &Hid::IsFirmwareUpdateAvailableForSixAxisSensor, "IsFirmwareUpdateAvailableForSixAxisSensor"},
+        {84, nullptr, "EnableSixAxisSensorUnalteredPassthrough"},
+        {85, nullptr, "IsSixAxisSensorUnalteredPassthroughEnabled"},
+        {86, nullptr, "StoreSixAxisSensorCalibrationParameter"},
+        {87, nullptr, "LoadSixAxisSensorCalibrationParameter"},
+        {88, nullptr, "GetSixAxisSensorIcInformation"},
+        {89, nullptr, "ResetIsSixAxisSensorDeviceNewlyAssigned"},
         {91, &Hid::ActivateGesture, "ActivateGesture"},
         {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
         {101, &Hid::GetSupportedNpadStyleSet, "GetSupportedNpadStyleSet"},
@@ -331,7 +337,7 @@ Hid::Hid(Core::System& system_)
         {529, nullptr, "SetDisallowedPalmaConnection"},
         {1000, &Hid::SetNpadCommunicationMode, "SetNpadCommunicationMode"},
         {1001, &Hid::GetNpadCommunicationMode, "GetNpadCommunicationMode"},
-        {1002, nullptr, "SetTouchScreenConfiguration"},
+        {1002, &Hid::SetTouchScreenConfiguration, "SetTouchScreenConfiguration"},
         {1003, nullptr, "IsFirmwareUpdateNeededForNotification"},
         {2000, nullptr, "ActivateDigitizer"},
     };
@@ -1631,6 +1637,18 @@ void Hid::GetNpadCommunicationMode(Kernel::HLERequestContext& ctx) {
                     .GetNpadCommunicationMode());
 }
 
+void Hid::SetTouchScreenConfiguration(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto touchscreen_mode{rp.PopRaw<Controller_Touchscreen::TouchScreenConfigurationForNx>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_WARNING(Service_HID, "(STUBBED) called, touchscreen_mode={}, applet_resource_user_id={}",
+                touchscreen_mode.mode, applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
 class HidDbg final : public ServiceFramework<HidDbg> {
 public:
     explicit HidDbg(Core::System& system_) : ServiceFramework{system_, "hid:dbg"} {
@@ -1644,6 +1662,9 @@ public:
             {12, nullptr, "UnsetTouchScreenAutoPilotState"},
             {13, nullptr, "GetTouchScreenConfiguration"},
             {14, nullptr, "ProcessTouchScreenAutoTune"},
+            {15, nullptr, "ForceStopTouchScreenManagement"},
+            {16, nullptr, "ForceRestartTouchScreenManagement"},
+            {17, nullptr, "IsTouchScreenManaged"},
             {20, nullptr, "DeactivateMouse"},
             {21, nullptr, "SetMouseAutoPilotState"},
             {22, nullptr, "UnsetMouseAutoPilotState"},

src/core/hle/service/hid/hid.h

@@ -159,6 +159,7 @@ private:
     void SetPalmaBoostMode(Kernel::HLERequestContext& ctx);
     void SetNpadCommunicationMode(Kernel::HLERequestContext& ctx);
     void GetNpadCommunicationMode(Kernel::HLERequestContext& ctx);
+    void SetTouchScreenConfiguration(Kernel::HLERequestContext& ctx);
 
     enum class VibrationDeviceType : u32 {
         Unknown = 0,

src/core/hle/service/ngct/ngct.cpp

@@ -15,7 +15,7 @@ public:
     explicit IService(Core::System& system_) : ServiceFramework{system_, "ngct:u"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Match"},
+            {0, &IService::Match, "Match"},
             {1, &IService::Filter, "Filter"},
         };
         // clang-format on
@@ -24,6 +24,19 @@ public:
     }
 
 private:
+    void Match(Kernel::HLERequestContext& ctx) {
+        const auto buffer = ctx.ReadBuffer();
+        const auto text = Common::StringFromFixedZeroTerminatedBuffer(
+            reinterpret_cast<const char*>(buffer.data()), buffer.size());
+
+        LOG_WARNING(Service_NGCT, "(STUBBED) called, text={}", text);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        // Return false since we don't censor anything
+        rb.Push(false);
+    }
+
     void Filter(Kernel::HLERequestContext& ctx) {
         const auto buffer = ctx.ReadBuffer();
         const auto text = Common::StringFromFixedZeroTerminatedBuffer(

src/core/hle/service/npns/npns.cpp

@@ -31,6 +31,7 @@ public:
             {24, nullptr, "DestroyTokenWithApplicationId"},
             {25, nullptr, "QueryIsTokenValid"},
             {26, nullptr, "ListenToMyApplicationId"},
+            {27, nullptr, "DestroyTokenAll"},
             {31, nullptr, "UploadTokenToBaaS"},
             {32, nullptr, "DestroyTokenForBaaS"},
             {33, nullptr, "CreateTokenForBaaS"},

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -42,15 +42,14 @@ void nvdisp_disp0::OnClose(DeviceFD fd) {}
 void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height,
                         u32 stride, NVFlinger::BufferQueue::BufferTransformFlags transform,
                         const Common::Rectangle<int>& crop_rect) {
-    VAddr addr = nvmap_dev->GetObjectAddress(buffer_handle);
+    const VAddr addr = nvmap_dev->GetObjectAddress(buffer_handle);
     LOG_TRACE(Service,
               "Drawing from address {:X} offset {:08X} Width {} Height {} Stride {} Format {}",
               addr, offset, width, height, stride, format);
 
-    using PixelFormat = Tegra::FramebufferConfig::PixelFormat;
-    const Tegra::FramebufferConfig framebuffer{
-        addr,      offset,   width, height, stride, static_cast<PixelFormat>(format),
-        transform, crop_rect};
+    const auto pixel_format = static_cast<Tegra::FramebufferConfig::PixelFormat>(format);
+    const Tegra::FramebufferConfig framebuffer{addr,   offset,       width,     height,
+                                               stride, pixel_format, transform, crop_rect};
 
     system.GetPerfStats().EndSystemFrame();
     system.GPU().SwapBuffers(&framebuffer);

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -9,17 +9,20 @@
 #include "core/core.h"
 #include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/kernel.h"
+#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 
 namespace Service::NVFlinger {
 
-BufferQueue::BufferQueue(Kernel::KernelCore& kernel, u32 id_, u64 layer_id_)
-    : id(id_), layer_id(layer_id_), buffer_wait_event{kernel} {
-    Kernel::KAutoObject::Create(std::addressof(buffer_wait_event));
-    buffer_wait_event.Initialize("BufferQueue:WaitEvent");
+BufferQueue::BufferQueue(Kernel::KernelCore& kernel, u32 id_, u64 layer_id_,
+                         KernelHelpers::ServiceContext& service_context_)
+    : id(id_), layer_id(layer_id_), service_context{service_context_} {
+    buffer_wait_event = service_context.CreateEvent("BufferQueue:WaitEvent");
 }
 
-BufferQueue::~BufferQueue() = default;
+BufferQueue::~BufferQueue() {
+    service_context.CloseEvent(buffer_wait_event);
+}
 
 void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer) {
     ASSERT(slot < buffer_slots);
@@ -41,7 +44,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
         .multi_fence = {},
     };
 
-    buffer_wait_event.GetWritableEvent().Signal();
+    buffer_wait_event->GetWritableEvent().Signal();
 }
 
 std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::DequeueBuffer(u32 width,
@@ -119,7 +122,7 @@ void BufferQueue::CancelBuffer(u32 slot, const Service::Nvidia::MultiFence& mult
     }
     free_buffers_condition.notify_one();
 
-    buffer_wait_event.GetWritableEvent().Signal();
+    buffer_wait_event->GetWritableEvent().Signal();
 }
 
 std::optional<std::reference_wrapper<const BufferQueue::Buffer>> BufferQueue::AcquireBuffer() {
@@ -154,7 +157,7 @@ void BufferQueue::ReleaseBuffer(u32 slot) {
     }
     free_buffers_condition.notify_one();
 
-    buffer_wait_event.GetWritableEvent().Signal();
+    buffer_wait_event->GetWritableEvent().Signal();
 }
 
 void BufferQueue::Connect() {
@@ -169,7 +172,7 @@ void BufferQueue::Disconnect() {
         std::unique_lock lock{queue_sequence_mutex};
         queue_sequence.clear();
     }
-    buffer_wait_event.GetWritableEvent().Signal();
+    buffer_wait_event->GetWritableEvent().Signal();
     is_connect = false;
     free_buffers_condition.notify_one();
 }
@@ -189,11 +192,11 @@ u32 BufferQueue::Query(QueryType type) {
 }
 
 Kernel::KWritableEvent& BufferQueue::GetWritableBufferWaitEvent() {
-    return buffer_wait_event.GetWritableEvent();
+    return buffer_wait_event->GetWritableEvent();
 }
 
 Kernel::KReadableEvent& BufferQueue::GetBufferWaitEvent() {
-    return buffer_wait_event.GetReadableEvent();
+    return buffer_wait_event->GetReadableEvent();
 }
 
 } // namespace Service::NVFlinger

src/core/hle/service/nvflinger/buffer_queue.h

@@ -24,6 +24,10 @@ class KReadableEvent;
 class KWritableEvent;
 } // namespace Kernel
 
+namespace Service::KernelHelpers {
+class ServiceContext;
+} // namespace Service::KernelHelpers
+
 namespace Service::NVFlinger {
 
 constexpr u32 buffer_slots = 0x40;
@@ -38,7 +42,9 @@ struct IGBPBuffer {
     u32_le index;
     INSERT_PADDING_WORDS(3);
     u32_le gpu_buffer_id;
-    INSERT_PADDING_WORDS(17);
+    INSERT_PADDING_WORDS(6);
+    u32_le external_format;
+    INSERT_PADDING_WORDS(10);
     u32_le nvmap_handle;
     u32_le offset;
     INSERT_PADDING_WORDS(60);
@@ -54,7 +60,8 @@ public:
         NativeWindowFormat = 2,
     };
 
-    explicit BufferQueue(Kernel::KernelCore& kernel, u32 id_, u64 layer_id_);
+    explicit BufferQueue(Kernel::KernelCore& kernel, u32 id_, u64 layer_id_,
+                         KernelHelpers::ServiceContext& service_context_);
     ~BufferQueue();
 
     enum class BufferTransformFlags : u32 {
@@ -130,12 +137,14 @@ private:
     std::list<u32> free_buffers;
     std::array<Buffer, buffer_slots> buffers;
     std::list<u32> queue_sequence;
-    Kernel::KEvent buffer_wait_event;
+    Kernel::KEvent* buffer_wait_event{};
 
     std::mutex free_buffers_mutex;
     std::condition_variable free_buffers_condition;
 
     std::mutex queue_sequence_mutex;
+
+    KernelHelpers::ServiceContext& service_context;
 };
 
 } // namespace Service::NVFlinger

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -61,12 +61,13 @@ void NVFlinger::SplitVSync() {
     }
 }
 
-NVFlinger::NVFlinger(Core::System& system_) : system(system_) {
-    displays.emplace_back(0, "Default", system);
-    displays.emplace_back(1, "External", system);
-    displays.emplace_back(2, "Edid", system);
-    displays.emplace_back(3, "Internal", system);
-    displays.emplace_back(4, "Null", system);
+NVFlinger::NVFlinger(Core::System& system_)
+    : system(system_), service_context(system_, "nvflinger") {
+    displays.emplace_back(0, "Default", service_context, system);
+    displays.emplace_back(1, "External", service_context, system);
+    displays.emplace_back(2, "Edid", service_context, system);
+    displays.emplace_back(3, "Internal", service_context, system);
+    displays.emplace_back(4, "Null", service_context, system);
     guard = std::make_shared<std::mutex>();
 
     // Schedule the screen composition events
@@ -146,7 +147,7 @@ std::optional<u64> NVFlinger::CreateLayer(u64 display_id) {
 void NVFlinger::CreateLayerAtId(VI::Display& display, u64 layer_id) {
     const u32 buffer_queue_id = next_buffer_queue_id++;
     buffer_queues.emplace_back(
-        std::make_unique<BufferQueue>(system.Kernel(), buffer_queue_id, layer_id));
+        std::make_unique<BufferQueue>(system.Kernel(), buffer_queue_id, layer_id, service_context));
     display.CreateLayer(layer_id, *buffer_queues.back());
 }
 
@@ -297,7 +298,7 @@ void NVFlinger::Compose() {
         auto nvdisp = nvdrv->GetDevice<Nvidia::Devices::nvdisp_disp0>("/dev/nvdisp_disp0");
         ASSERT(nvdisp);
 
-        nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.format,
+        nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.external_format,
                      igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride,
                      buffer->get().transform, buffer->get().crop_rect);
 

src/core/hle/service/nvflinger/nvflinger.h

@@ -15,6 +15,7 @@
 #include <vector>
 
 #include "common/common_types.h"
+#include "core/hle/service/kernel_helpers.h"
 
 namespace Common {
 class Event;
@@ -135,6 +136,8 @@ private:
     std::unique_ptr<std::thread> vsync_thread;
     std::unique_ptr<Common::Event> wait_event;
     std::atomic<bool> is_running{};
+
+    KernelHelpers::ServiceContext service_context;
 };
 
 } // namespace Service::NVFlinger

src/core/hle/service/sockets/bsd.cpp

@@ -415,6 +415,18 @@ void BSD::Write(Kernel::HLERequestContext& ctx) {
                      });
 }
 
+void BSD::Read(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const s32 fd = rp.Pop<s32>();
+
+    LOG_WARNING(Service, "(STUBBED) called. fd={} len={}", fd, ctx.GetWriteBufferSize());
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.Push<u32>(0); // ret
+    rb.Push<u32>(0); // bsd errno
+}
+
 void BSD::Close(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
@@ -855,7 +867,7 @@ BSD::BSD(Core::System& system_, const char* name) : ServiceFramework{system_, na
         {22, &BSD::Shutdown, "Shutdown"},
         {23, nullptr, "ShutdownAllSockets"},
         {24, &BSD::Write, "Write"},
-        {25, nullptr, "Read"},
+        {25, &BSD::Read, "Read"},
         {26, &BSD::Close, "Close"},
         {27, nullptr, "DuplicateSocket"},
         {28, nullptr, "GetResourceStatistics"},

src/core/hle/service/sockets/bsd.h

@@ -135,6 +135,7 @@ private:
     void Send(Kernel::HLERequestContext& ctx);
     void SendTo(Kernel::HLERequestContext& ctx);
     void Write(Kernel::HLERequestContext& ctx);
+    void Read(Kernel::HLERequestContext& ctx);
     void Close(Kernel::HLERequestContext& ctx);
     void EventFd(Kernel::HLERequestContext& ctx);
 

src/core/hle/service/usb/usb.cpp

@@ -97,7 +97,7 @@ public:
             {3, nullptr, "GetAlternateInterface"},
             {4, nullptr, "GetCurrentFrame"},
             {5, nullptr, "CtrlXferAsync"},
-            {6, nullptr, "Unknown6"},
+            {6, nullptr, "GetCtrlXferCompletionEvent"},
             {7, nullptr, "GetCtrlXferReport"},
             {8, nullptr, "ResetDevice"},
             {9, nullptr, "OpenUsbEp"},
@@ -183,8 +183,8 @@ public:
             {4, nullptr, "GetHostPdcFirmwareRevision"},
             {5, nullptr, "GetHostPdcManufactureId"},
             {6, nullptr, "GetHostPdcDeviceId"},
-            {7, nullptr, "AwakeCradle"},
-            {8, nullptr, "SleepCradle"},
+            {7, nullptr, "EnableCradleRecovery"},
+            {8, nullptr, "DisableCradleRecovery"},
         };
         // clang-format on
 

src/core/hle/service/vi/display/vi_display.cpp

@@ -12,18 +12,21 @@
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/k_writable_event.h"
+#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/vi/display/vi_display.h"
 #include "core/hle/service/vi/layer/vi_layer.h"
 
 namespace Service::VI {
 
-Display::Display(u64 id, std::string name_, Core::System& system)
-    : display_id{id}, name{std::move(name_)}, vsync_event{system.Kernel()} {
-    Kernel::KAutoObject::Create(std::addressof(vsync_event));
-    vsync_event.Initialize(fmt::format("Display VSync Event {}", id));
+Display::Display(u64 id, std::string name_, KernelHelpers::ServiceContext& service_context_,
+                 Core::System& system_)
+    : display_id{id}, name{std::move(name_)}, service_context{service_context_} {
+    vsync_event = service_context.CreateEvent(fmt::format("Display VSync Event {}", id));
 }
 
-Display::~Display() = default;
+Display::~Display() {
+    service_context.CloseEvent(vsync_event);
+}
 
 Layer& Display::GetLayer(std::size_t index) {
     return *layers.at(index);
@@ -34,11 +37,11 @@ const Layer& Display::GetLayer(std::size_t index) const {
 }
 
 Kernel::KReadableEvent& Display::GetVSyncEvent() {
-    return vsync_event.GetReadableEvent();
+    return vsync_event->GetReadableEvent();
 }
 
 void Display::SignalVSyncEvent() {
-    vsync_event.GetWritableEvent().Signal();
+    vsync_event->GetWritableEvent().Signal();
 }
 
 void Display::CreateLayer(u64 layer_id, NVFlinger::BufferQueue& buffer_queue) {

src/core/hle/service/vi/display/vi_display.h

@@ -18,6 +18,9 @@ class KEvent;
 namespace Service::NVFlinger {
 class BufferQueue;
 }
+namespace Service::KernelHelpers {
+class ServiceContext;
+} // namespace Service::KernelHelpers
 
 namespace Service::VI {
 
@@ -31,10 +34,13 @@ class Display {
 public:
     /// Constructs a display with a given unique ID and name.
     ///
-    /// @param id   The unique ID for this display.
+    /// @param id The unique ID for this display.
+    /// @param service_context_ The ServiceContext for the owning service.
     /// @param name_ The name for this display.
+    /// @param system_ The global system instance.
     ///
-    Display(u64 id, std::string name_, Core::System& system);
+    Display(u64 id, std::string name_, KernelHelpers::ServiceContext& service_context_,
+            Core::System& system_);
     ~Display();
 
     /// Gets the unique ID assigned to this display.
@@ -98,9 +104,10 @@ public:
 private:
     u64 display_id;
     std::string name;
+    KernelHelpers::ServiceContext& service_context;
 
     std::vector<std::shared_ptr<Layer>> layers;
-    Kernel::KEvent vsync_event;
+    Kernel::KEvent* vsync_event{};
 };
 
 } // namespace Service::VI

src/core/hle/service/vi/vi.cpp

@@ -831,6 +831,7 @@ public:
             {6010, nullptr, "GetLayerPresentationAllFencesExpiredEvent"},
             {6011, nullptr, "EnableLayerAutoClearTransitionBuffer"},
             {6012, nullptr, "DisableLayerAutoClearTransitionBuffer"},
+            {6013, nullptr, "SetLayerOpacity"},
             {7000, nullptr, "SetContentVisibility"},
             {8000, nullptr, "SetConductorLayer"},
             {8001, nullptr, "SetTimestampTracking"},

src/core/network/network.cpp

@@ -7,7 +7,8 @@
 #include <limits>
 #include <utility>
 #include <vector>
-#include "common/common_funcs.h"
+
+#include "common/error.h"
 
 #ifdef _WIN32
 #include <winsock2.h>
@@ -223,7 +224,7 @@ Errno GetAndLogLastError() {
     if (err == Errno::AGAIN) {
         return err;
     }
-    LOG_ERROR(Network, "Socket operation error: {}", NativeErrorToString(e));
+    LOG_ERROR(Network, "Socket operation error: {}", Common::NativeErrorToString(e));
     return err;
 }
 

src/core/telemetry_session.cpp

@@ -72,6 +72,18 @@ static const char* TranslateGPUAccuracyLevel(Settings::GPUAccuracy backend) {
     return "Unknown";
 }
 
+static const char* TranslateNvdecEmulation(Settings::NvdecEmulation backend) {
+    switch (backend) {
+    case Settings::NvdecEmulation::Off:
+        return "Off";
+    case Settings::NvdecEmulation::CPU:
+        return "CPU";
+    case Settings::NvdecEmulation::GPU:
+        return "GPU";
+    }
+    return "Unknown";
+}
+
 u64 GetTelemetryId() {
     u64 telemetry_id{};
     const auto filename = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir) / "telemetry_id";
@@ -214,8 +226,6 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
     // Log user configuration information
     constexpr auto field_type = Telemetry::FieldType::UserConfig;
     AddField(field_type, "Audio_SinkId", Settings::values.sink_id.GetValue());
-    AddField(field_type, "Audio_EnableAudioStretching",
-             Settings::values.enable_audio_stretching.GetValue());
     AddField(field_type, "Core_UseMultiCore", Settings::values.use_multi_core.GetValue());
     AddField(field_type, "Renderer_Backend",
              TranslateRenderer(Settings::values.renderer_backend.GetValue()));
@@ -229,8 +239,8 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
              TranslateGPUAccuracyLevel(Settings::values.gpu_accuracy.GetValue()));
     AddField(field_type, "Renderer_UseAsynchronousGpuEmulation",
              Settings::values.use_asynchronous_gpu_emulation.GetValue());
-    AddField(field_type, "Renderer_UseNvdecEmulation",
-             Settings::values.use_nvdec_emulation.GetValue());
+    AddField(field_type, "Renderer_NvdecEmulation",
+             TranslateNvdecEmulation(Settings::values.nvdec_emulation.GetValue()));
     AddField(field_type, "Renderer_AccelerateASTC", Settings::values.accelerate_astc.GetValue());
     AddField(field_type, "Renderer_UseVsync", Settings::values.use_vsync.GetValue());
     AddField(field_type, "Renderer_ShaderBackend",

src/input_common/CMakeLists.txt

@@ -21,6 +21,10 @@ add_library(input_common STATIC
     mouse/mouse_poller.h
     sdl/sdl.cpp
     sdl/sdl.h
+    tas/tas_input.cpp
+    tas/tas_input.h
+    tas/tas_poller.cpp
+    tas/tas_poller.h
     udp/client.cpp
     udp/client.h
     udp/protocol.cpp

src/input_common/main.cpp

@@ -5,6 +5,7 @@
 #include <memory>
 #include <thread>
 #include "common/param_package.h"
+#include "common/settings.h"
 #include "input_common/analog_from_button.h"
 #include "input_common/gcadapter/gc_adapter.h"
 #include "input_common/gcadapter/gc_poller.h"
@@ -13,6 +14,8 @@
 #include "input_common/motion_from_button.h"
 #include "input_common/mouse/mouse_input.h"
 #include "input_common/mouse/mouse_poller.h"
+#include "input_common/tas/tas_input.h"
+#include "input_common/tas/tas_poller.h"
 #include "input_common/touch_from_button.h"
 #include "input_common/udp/client.h"
 #include "input_common/udp/udp.h"
@@ -60,6 +63,12 @@ struct InputSubsystem::Impl {
         Input::RegisterFactory<Input::MotionDevice>("mouse", mousemotion);
         mousetouch = std::make_shared<MouseTouchFactory>(mouse);
         Input::RegisterFactory<Input::TouchDevice>("mouse", mousetouch);
+
+        tas = std::make_shared<TasInput::Tas>();
+        tasbuttons = std::make_shared<TasButtonFactory>(tas);
+        Input::RegisterFactory<Input::ButtonDevice>("tas", tasbuttons);
+        tasanalog = std::make_shared<TasAnalogFactory>(tas);
+        Input::RegisterFactory<Input::AnalogDevice>("tas", tasanalog);
     }
 
     void Shutdown() {
@@ -94,6 +103,12 @@ struct InputSubsystem::Impl {
         mouseanalog.reset();
         mousemotion.reset();
         mousetouch.reset();
+
+        Input::UnregisterFactory<Input::ButtonDevice>("tas");
+        Input::UnregisterFactory<Input::AnalogDevice>("tas");
+
+        tasbuttons.reset();
+        tasanalog.reset();
     }
 
     [[nodiscard]] std::vector<Common::ParamPackage> GetInputDevices() const {
@@ -101,6 +116,10 @@ struct InputSubsystem::Impl {
             Common::ParamPackage{{"display", "Any"}, {"class", "any"}},
             Common::ParamPackage{{"display", "Keyboard/Mouse"}, {"class", "keyboard"}},
         };
+        if (Settings::values.tas_enable) {
+            devices.emplace_back(
+                Common::ParamPackage{{"display", "TAS Controller"}, {"class", "tas"}});
+        }
 #ifdef HAVE_SDL2
         auto sdl_devices = sdl->GetInputDevices();
         devices.insert(devices.end(), sdl_devices.begin(), sdl_devices.end());
@@ -120,6 +139,9 @@ struct InputSubsystem::Impl {
         if (params.Get("class", "") == "gcpad") {
             return gcadapter->GetAnalogMappingForDevice(params);
         }
+        if (params.Get("class", "") == "tas") {
+            return tas->GetAnalogMappingForDevice(params);
+        }
 #ifdef HAVE_SDL2
         if (params.Get("class", "") == "sdl") {
             return sdl->GetAnalogMappingForDevice(params);
@@ -136,6 +158,9 @@ struct InputSubsystem::Impl {
         if (params.Get("class", "") == "gcpad") {
             return gcadapter->GetButtonMappingForDevice(params);
         }
+        if (params.Get("class", "") == "tas") {
+            return tas->GetButtonMappingForDevice(params);
+        }
 #ifdef HAVE_SDL2
         if (params.Get("class", "") == "sdl") {
             return sdl->GetButtonMappingForDevice(params);
@@ -174,9 +199,12 @@ struct InputSubsystem::Impl {
     std::shared_ptr<MouseAnalogFactory> mouseanalog;
     std::shared_ptr<MouseMotionFactory> mousemotion;
     std::shared_ptr<MouseTouchFactory> mousetouch;
+    std::shared_ptr<TasButtonFactory> tasbuttons;
+    std::shared_ptr<TasAnalogFactory> tasanalog;
     std::shared_ptr<CemuhookUDP::Client> udp;
     std::shared_ptr<GCAdapter::Adapter> gcadapter;
     std::shared_ptr<MouseInput::Mouse> mouse;
+    std::shared_ptr<TasInput::Tas> tas;
 };
 
 InputSubsystem::InputSubsystem() : impl{std::make_unique<Impl>()} {}
@@ -207,6 +235,14 @@ const MouseInput::Mouse* InputSubsystem::GetMouse() const {
     return impl->mouse.get();
 }
 
+TasInput::Tas* InputSubsystem::GetTas() {
+    return impl->tas.get();
+}
+
+const TasInput::Tas* InputSubsystem::GetTas() const {
+    return impl->tas.get();
+}
+
 std::vector<Common::ParamPackage> InputSubsystem::GetInputDevices() const {
     return impl->GetInputDevices();
 }
@@ -287,6 +323,22 @@ const MouseTouchFactory* InputSubsystem::GetMouseTouch() const {
     return impl->mousetouch.get();
 }
 
+TasButtonFactory* InputSubsystem::GetTasButtons() {
+    return impl->tasbuttons.get();
+}
+
+const TasButtonFactory* InputSubsystem::GetTasButtons() const {
+    return impl->tasbuttons.get();
+}
+
+TasAnalogFactory* InputSubsystem::GetTasAnalogs() {
+    return impl->tasanalog.get();
+}
+
+const TasAnalogFactory* InputSubsystem::GetTasAnalogs() const {
+    return impl->tasanalog.get();
+}
+
 void InputSubsystem::ReloadInputDevices() {
     if (!impl->udp) {
         return;
@@ -294,8 +346,8 @@ void InputSubsystem::ReloadInputDevices() {
     impl->udp->ReloadSockets();
 }
 
-std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers([
-    [maybe_unused]] Polling::DeviceType type) const {
+std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers(
+    [[maybe_unused]] Polling::DeviceType type) const {
 #ifdef HAVE_SDL2
     return impl->sdl->GetPollers(type);
 #else

src/input_common/main.h

@@ -29,6 +29,10 @@ namespace MouseInput {
 class Mouse;
 }
 
+namespace TasInput {
+class Tas;
+}
+
 namespace InputCommon {
 namespace Polling {
 
@@ -64,6 +68,8 @@ class MouseButtonFactory;
 class MouseAnalogFactory;
 class MouseMotionFactory;
 class MouseTouchFactory;
+class TasButtonFactory;
+class TasAnalogFactory;
 class Keyboard;
 
 /**
@@ -103,6 +109,11 @@ public:
     /// Retrieves the underlying mouse device.
     [[nodiscard]] const MouseInput::Mouse* GetMouse() const;
 
+    /// Retrieves the underlying tas device.
+    [[nodiscard]] TasInput::Tas* GetTas();
+
+    /// Retrieves the underlying tas device.
+    [[nodiscard]] const TasInput::Tas* GetTas() const;
     /**
      * Returns all available input devices that this Factory can create a new device with.
      * Each returned ParamPackage should have a `display` field used for display, a class field for
@@ -144,30 +155,42 @@ public:
     /// Retrieves the underlying udp touch handler.
     [[nodiscard]] const UDPTouchFactory* GetUDPTouch() const;
 
-    /// Retrieves the underlying GameCube button handler.
+    /// Retrieves the underlying mouse button handler.
     [[nodiscard]] MouseButtonFactory* GetMouseButtons();
 
-    /// Retrieves the underlying GameCube button handler.
+    /// Retrieves the underlying mouse button handler.
     [[nodiscard]] const MouseButtonFactory* GetMouseButtons() const;
 
-    /// Retrieves the underlying udp touch handler.
+    /// Retrieves the underlying mouse analog handler.
     [[nodiscard]] MouseAnalogFactory* GetMouseAnalogs();
 
-    /// Retrieves the underlying udp touch handler.
+    /// Retrieves the underlying mouse analog handler.
     [[nodiscard]] const MouseAnalogFactory* GetMouseAnalogs() const;
 
-    /// Retrieves the underlying udp motion handler.
+    /// Retrieves the underlying mouse motion handler.
     [[nodiscard]] MouseMotionFactory* GetMouseMotions();
 
-    /// Retrieves the underlying udp motion handler.
+    /// Retrieves the underlying mouse motion handler.
     [[nodiscard]] const MouseMotionFactory* GetMouseMotions() const;
 
-    /// Retrieves the underlying udp touch handler.
+    /// Retrieves the underlying mouse touch handler.
     [[nodiscard]] MouseTouchFactory* GetMouseTouch();
 
-    /// Retrieves the underlying udp touch handler.
+    /// Retrieves the underlying mouse touch handler.
     [[nodiscard]] const MouseTouchFactory* GetMouseTouch() const;
 
+    /// Retrieves the underlying tas button handler.
+    [[nodiscard]] TasButtonFactory* GetTasButtons();
+
+    /// Retrieves the underlying tas button handler.
+    [[nodiscard]] const TasButtonFactory* GetTasButtons() const;
+
+    /// Retrieves the underlying tas analogs handler.
+    [[nodiscard]] TasAnalogFactory* GetTasAnalogs();
+
+    /// Retrieves the underlying tas analogs handler.
+    [[nodiscard]] const TasAnalogFactory* GetTasAnalogs() const;
+
     /// Reloads the input devices
     void ReloadInputDevices();
 

src/input_common/sdl/sdl_impl.cpp

@@ -21,7 +21,7 @@
 #include "common/logging/log.h"
 #include "common/math_util.h"
 #include "common/param_package.h"
-#include "common/settings_input.h"
+#include "common/settings.h"
 #include "common/threadsafe_queue.h"
 #include "core/frontend/input.h"
 #include "input_common/motion_input.h"
@@ -889,8 +889,10 @@ SDLState::SDLState() {
     RegisterFactory<VibrationDevice>("sdl", vibration_factory);
     RegisterFactory<MotionDevice>("sdl", motion_factory);
 
-    // Disable raw input. When enabled this setting causes SDL to die when a web applet opens
-    SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
+    if (!Settings::values.enable_raw_input) {
+        // Disable raw input. When enabled this setting causes SDL to die when a web applet opens
+        SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
+    }
 
     // Enable HIDAPI rumble. This prevents SDL from disabling motion on PS4 and PS5 controllers
     SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, "1");
@@ -898,10 +900,10 @@ SDLState::SDLState() {
 
     // Tell SDL2 to use the hidapi driver. This will allow joycons to be detected as a
     // GameController and not a generic one
-    SDL_SetHint("SDL_JOYSTICK_HIDAPI_JOY_CONS", "1");
+    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "1");
 
     // Turn off Pro controller home led
-    SDL_SetHint("SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED", "0");
+    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED, "0");
 
     // If the frontend is going to manage the event loop, then we don't start one here
     start_thread = SDL_WasInit(SDL_INIT_JOYSTICK) == 0;

src/input_common/tas/tas_input.cpp

@@ -0,0 +1,455 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include <regex>
+
+#include "common/fs/file.h"
+#include "common/fs/fs_types.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+#include "common/settings.h"
+#include "input_common/tas/tas_input.h"
+
+namespace TasInput {
+
+// Supported keywords and buttons from a TAS file
+constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_button = {
+    std::pair{"KEY_A", TasButton::BUTTON_A},
+    {"KEY_B", TasButton::BUTTON_B},
+    {"KEY_X", TasButton::BUTTON_X},
+    {"KEY_Y", TasButton::BUTTON_Y},
+    {"KEY_LSTICK", TasButton::STICK_L},
+    {"KEY_RSTICK", TasButton::STICK_R},
+    {"KEY_L", TasButton::TRIGGER_L},
+    {"KEY_R", TasButton::TRIGGER_R},
+    {"KEY_PLUS", TasButton::BUTTON_PLUS},
+    {"KEY_MINUS", TasButton::BUTTON_MINUS},
+    {"KEY_DLEFT", TasButton::BUTTON_LEFT},
+    {"KEY_DUP", TasButton::BUTTON_UP},
+    {"KEY_DRIGHT", TasButton::BUTTON_RIGHT},
+    {"KEY_DDOWN", TasButton::BUTTON_DOWN},
+    {"KEY_SL", TasButton::BUTTON_SL},
+    {"KEY_SR", TasButton::BUTTON_SR},
+    {"KEY_CAPTURE", TasButton::BUTTON_CAPTURE},
+    {"KEY_HOME", TasButton::BUTTON_HOME},
+    {"KEY_ZL", TasButton::TRIGGER_ZL},
+    {"KEY_ZR", TasButton::TRIGGER_ZR},
+};
+
+Tas::Tas() {
+    if (!Settings::values.tas_enable) {
+        needs_reset = true;
+        return;
+    }
+    LoadTasFiles();
+}
+
+Tas::~Tas() {
+    Stop();
+};
+
+void Tas::LoadTasFiles() {
+    script_length = 0;
+    for (size_t i = 0; i < commands.size(); i++) {
+        LoadTasFile(i);
+        if (commands[i].size() > script_length) {
+            script_length = commands[i].size();
+        }
+    }
+}
+
+void Tas::LoadTasFile(size_t player_index) {
+    if (!commands[player_index].empty()) {
+        commands[player_index].clear();
+    }
+    std::string file =
+        Common::FS::ReadStringFromFile(Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) /
+                                           fmt::format("script0-{}.txt", player_index + 1),
+                                       Common::FS::FileType::BinaryFile);
+    std::stringstream command_line(file);
+    std::string line;
+    int frame_no = 0;
+    while (std::getline(command_line, line, '\n')) {
+        if (line.empty()) {
+            continue;
+        }
+        LOG_DEBUG(Input, "Loading line: {}", line);
+        std::smatch m;
+
+        std::stringstream linestream(line);
+        std::string segment;
+        std::vector<std::string> seglist;
+
+        while (std::getline(linestream, segment, ' ')) {
+            seglist.push_back(segment);
+        }
+
+        if (seglist.size() < 4) {
+            continue;
+        }
+
+        while (frame_no < std::stoi(seglist.at(0))) {
+            commands[player_index].push_back({});
+            frame_no++;
+        }
+
+        TASCommand command = {
+            .buttons = ReadCommandButtons(seglist.at(1)),
+            .l_axis = ReadCommandAxis(seglist.at(2)),
+            .r_axis = ReadCommandAxis(seglist.at(3)),
+        };
+        commands[player_index].push_back(command);
+        frame_no++;
+    }
+    LOG_INFO(Input, "TAS file loaded! {} frames", frame_no);
+}
+
+void Tas::WriteTasFile(std::u8string file_name) {
+    std::string output_text;
+    for (size_t frame = 0; frame < record_commands.size(); frame++) {
+        if (!output_text.empty()) {
+            output_text += "\n";
+        }
+        const TASCommand& line = record_commands[frame];
+        output_text += std::to_string(frame) + " " + WriteCommandButtons(line.buttons) + " " +
+                       WriteCommandAxis(line.l_axis) + " " + WriteCommandAxis(line.r_axis);
+    }
+    const auto bytes_written = Common::FS::WriteStringToFile(
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name,
+        Common::FS::FileType::TextFile, output_text);
+    if (bytes_written == output_text.size()) {
+        LOG_INFO(Input, "TAS file written to file!");
+    } else {
+        LOG_ERROR(Input, "Writing the TAS-file has failed! {} / {} bytes written", bytes_written,
+                  output_text.size());
+    }
+}
+
+std::pair<float, float> Tas::FlipAxisY(std::pair<float, float> old) {
+    auto [x, y] = old;
+    return {x, -y};
+}
+
+void Tas::RecordInput(u32 buttons, const std::array<std::pair<float, float>, 2>& axes) {
+    last_input = {buttons, FlipAxisY(axes[0]), FlipAxisY(axes[1])};
+}
+
+std::tuple<TasState, size_t, size_t> Tas::GetStatus() const {
+    TasState state;
+    if (is_recording) {
+        return {TasState::Recording, 0, record_commands.size()};
+    }
+
+    if (is_running) {
+        state = TasState::Running;
+    } else {
+        state = TasState::Stopped;
+    }
+
+    return {state, current_command, script_length};
+}
+
+std::string Tas::DebugButtons(u32 buttons) const {
+    return fmt::format("{{ {} }}", TasInput::Tas::ButtonsToString(buttons));
+}
+
+std::string Tas::DebugJoystick(float x, float y) const {
+    return fmt::format("[ {} , {} ]", std::to_string(x), std::to_string(y));
+}
+
+std::string Tas::DebugInput(const TasData& data) const {
+    return fmt::format("{{ {} , {} , {} }}", DebugButtons(data.buttons),
+                       DebugJoystick(data.axis[0], data.axis[1]),
+                       DebugJoystick(data.axis[2], data.axis[3]));
+}
+
+std::string Tas::DebugInputs(const std::array<TasData, PLAYER_NUMBER>& arr) const {
+    std::string returns = "[ ";
+    for (size_t i = 0; i < arr.size(); i++) {
+        returns += DebugInput(arr[i]);
+        if (i != arr.size() - 1) {
+            returns += " , ";
+        }
+    }
+    return returns + "]";
+}
+
+std::string Tas::ButtonsToString(u32 button) const {
+    std::string returns;
+    for (auto [text_button, tas_button] : text_to_tas_button) {
+        if ((button & static_cast<u32>(tas_button)) != 0)
+            returns += fmt::format(", {}", text_button.substr(4));
+    }
+    return returns.empty() ? "" : returns.substr(2);
+}
+
+void Tas::UpdateThread() {
+    if (!Settings::values.tas_enable) {
+        if (is_running) {
+            Stop();
+        }
+        return;
+    }
+
+    if (is_recording) {
+        record_commands.push_back(last_input);
+    }
+    if (needs_reset) {
+        current_command = 0;
+        needs_reset = false;
+        LoadTasFiles();
+        LOG_DEBUG(Input, "tas_reset done");
+    }
+
+    if (!is_running) {
+        tas_data.fill({});
+        return;
+    }
+    if (current_command < script_length) {
+        LOG_DEBUG(Input, "Playing TAS {}/{}", current_command, script_length);
+        size_t frame = current_command++;
+        for (size_t i = 0; i < commands.size(); i++) {
+            if (frame < commands[i].size()) {
+                TASCommand command = commands[i][frame];
+                tas_data[i].buttons = command.buttons;
+                auto [l_axis_x, l_axis_y] = command.l_axis;
+                tas_data[i].axis[0] = l_axis_x;
+                tas_data[i].axis[1] = l_axis_y;
+                auto [r_axis_x, r_axis_y] = command.r_axis;
+                tas_data[i].axis[2] = r_axis_x;
+                tas_data[i].axis[3] = r_axis_y;
+            } else {
+                tas_data[i] = {};
+            }
+        }
+    } else {
+        is_running = Settings::values.tas_loop.GetValue();
+        current_command = 0;
+        tas_data.fill({});
+        if (!is_running) {
+            SwapToStoredController();
+        }
+    }
+    LOG_DEBUG(Input, "TAS inputs: {}", DebugInputs(tas_data));
+}
+
+TasAnalog Tas::ReadCommandAxis(const std::string& line) const {
+    std::stringstream linestream(line);
+    std::string segment;
+    std::vector<std::string> seglist;
+
+    while (std::getline(linestream, segment, ';')) {
+        seglist.push_back(segment);
+    }
+
+    const float x = std::stof(seglist.at(0)) / 32767.0f;
+    const float y = std::stof(seglist.at(1)) / 32767.0f;
+
+    return {x, y};
+}
+
+u32 Tas::ReadCommandButtons(const std::string& data) const {
+    std::stringstream button_text(data);
+    std::string line;
+    u32 buttons = 0;
+    while (std::getline(button_text, line, ';')) {
+        for (auto [text, tas_button] : text_to_tas_button) {
+            if (text == line) {
+                buttons |= static_cast<u32>(tas_button);
+                break;
+            }
+        }
+    }
+    return buttons;
+}
+
+std::string Tas::WriteCommandAxis(TasAnalog data) const {
+    auto [x, y] = data;
+    std::string line;
+    line += std::to_string(static_cast<int>(x * 32767));
+    line += ";";
+    line += std::to_string(static_cast<int>(y * 32767));
+    return line;
+}
+
+std::string Tas::WriteCommandButtons(u32 data) const {
+    if (data == 0) {
+        return "NONE";
+    }
+
+    std::string line;
+    u32 index = 0;
+    while (data > 0) {
+        if ((data & 1) == 1) {
+            for (auto [text, tas_button] : text_to_tas_button) {
+                if (tas_button == static_cast<TasButton>(1 << index)) {
+                    if (line.size() > 0) {
+                        line += ";";
+                    }
+                    line += text;
+                    break;
+                }
+            }
+        }
+        index++;
+        data >>= 1;
+    }
+    return line;
+}
+
+void Tas::StartStop() {
+    if (!Settings::values.tas_enable) {
+        return;
+    }
+    if (is_running) {
+        Stop();
+    } else {
+        is_running = true;
+        SwapToTasController();
+    }
+}
+
+void Tas::Stop() {
+    is_running = false;
+    SwapToStoredController();
+}
+
+void Tas::SwapToTasController() {
+    if (!Settings::values.tas_swap_controllers) {
+        return;
+    }
+    auto& players = Settings::values.players.GetValue();
+    for (std::size_t index = 0; index < players.size(); index++) {
+        auto& player = players[index];
+        player_mappings[index] = player;
+
+        // Only swap active controllers
+        if (!player.connected) {
+            continue;
+        }
+
+        Common::ParamPackage tas_param;
+        tas_param.Set("pad", static_cast<u8>(index));
+        auto button_mapping = GetButtonMappingForDevice(tas_param);
+        auto analog_mapping = GetAnalogMappingForDevice(tas_param);
+        auto& buttons = player.buttons;
+        auto& analogs = player.analogs;
+
+        for (std::size_t i = 0; i < buttons.size(); ++i) {
+            buttons[i] = button_mapping[static_cast<Settings::NativeButton::Values>(i)].Serialize();
+        }
+        for (std::size_t i = 0; i < analogs.size(); ++i) {
+            analogs[i] = analog_mapping[static_cast<Settings::NativeAnalog::Values>(i)].Serialize();
+        }
+    }
+    is_old_input_saved = true;
+    Settings::values.is_device_reload_pending.store(true);
+}
+
+void Tas::SwapToStoredController() {
+    if (!is_old_input_saved) {
+        return;
+    }
+    auto& players = Settings::values.players.GetValue();
+    for (std::size_t index = 0; index < players.size(); index++) {
+        players[index] = player_mappings[index];
+    }
+    is_old_input_saved = false;
+    Settings::values.is_device_reload_pending.store(true);
+}
+
+void Tas::Reset() {
+    if (!Settings::values.tas_enable) {
+        return;
+    }
+    needs_reset = true;
+}
+
+bool Tas::Record() {
+    if (!Settings::values.tas_enable) {
+        return true;
+    }
+    is_recording = !is_recording;
+    return is_recording;
+}
+
+void Tas::SaveRecording(bool overwrite_file) {
+    if (is_recording) {
+        return;
+    }
+    if (record_commands.empty()) {
+        return;
+    }
+    WriteTasFile(u8"record.txt");
+    if (overwrite_file) {
+        WriteTasFile(u8"script0-1.txt");
+    }
+    needs_reset = true;
+    record_commands.clear();
+}
+
+InputCommon::ButtonMapping Tas::GetButtonMappingForDevice(
+    const Common::ParamPackage& params) const {
+    // This list is missing ZL/ZR since those are not considered buttons.
+    // We will add those afterwards
+    // This list also excludes any button that can't be really mapped
+    static constexpr std::array<std::pair<Settings::NativeButton::Values, TasButton>, 20>
+        switch_to_tas_button = {
+            std::pair{Settings::NativeButton::A, TasButton::BUTTON_A},
+            {Settings::NativeButton::B, TasButton::BUTTON_B},
+            {Settings::NativeButton::X, TasButton::BUTTON_X},
+            {Settings::NativeButton::Y, TasButton::BUTTON_Y},
+            {Settings::NativeButton::LStick, TasButton::STICK_L},
+            {Settings::NativeButton::RStick, TasButton::STICK_R},
+            {Settings::NativeButton::L, TasButton::TRIGGER_L},
+            {Settings::NativeButton::R, TasButton::TRIGGER_R},
+            {Settings::NativeButton::Plus, TasButton::BUTTON_PLUS},
+            {Settings::NativeButton::Minus, TasButton::BUTTON_MINUS},
+            {Settings::NativeButton::DLeft, TasButton::BUTTON_LEFT},
+            {Settings::NativeButton::DUp, TasButton::BUTTON_UP},
+            {Settings::NativeButton::DRight, TasButton::BUTTON_RIGHT},
+            {Settings::NativeButton::DDown, TasButton::BUTTON_DOWN},
+            {Settings::NativeButton::SL, TasButton::BUTTON_SL},
+            {Settings::NativeButton::SR, TasButton::BUTTON_SR},
+            {Settings::NativeButton::Screenshot, TasButton::BUTTON_CAPTURE},
+            {Settings::NativeButton::Home, TasButton::BUTTON_HOME},
+            {Settings::NativeButton::ZL, TasButton::TRIGGER_ZL},
+            {Settings::NativeButton::ZR, TasButton::TRIGGER_ZR},
+        };
+
+    InputCommon::ButtonMapping mapping{};
+    for (const auto& [switch_button, tas_button] : switch_to_tas_button) {
+        Common::ParamPackage button_params({{"engine", "tas"}});
+        button_params.Set("pad", params.Get("pad", 0));
+        button_params.Set("button", static_cast<int>(tas_button));
+        mapping.insert_or_assign(switch_button, std::move(button_params));
+    }
+
+    return mapping;
+}
+
+InputCommon::AnalogMapping Tas::GetAnalogMappingForDevice(
+    const Common::ParamPackage& params) const {
+
+    InputCommon::AnalogMapping mapping = {};
+    Common::ParamPackage left_analog_params;
+    left_analog_params.Set("engine", "tas");
+    left_analog_params.Set("pad", params.Get("pad", 0));
+    left_analog_params.Set("axis_x", static_cast<int>(TasAxes::StickX));
+    left_analog_params.Set("axis_y", static_cast<int>(TasAxes::StickY));
+    mapping.insert_or_assign(Settings::NativeAnalog::LStick, std::move(left_analog_params));
+    Common::ParamPackage right_analog_params;
+    right_analog_params.Set("engine", "tas");
+    right_analog_params.Set("pad", params.Get("pad", 0));
+    right_analog_params.Set("axis_x", static_cast<int>(TasAxes::SubstickX));
+    right_analog_params.Set("axis_y", static_cast<int>(TasAxes::SubstickY));
+    mapping.insert_or_assign(Settings::NativeAnalog::RStick, std::move(right_analog_params));
+    return mapping;
+}
+
+const TasData& Tas::GetTasState(std::size_t pad) const {
+    return tas_data[pad];
+}
+} // namespace TasInput

src/input_common/tas/tas_input.h

@@ -0,0 +1,237 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+
+#include "common/common_types.h"
+#include "common/settings_input.h"
+#include "core/frontend/input.h"
+#include "input_common/main.h"
+
+/*
+To play back TAS scripts on Yuzu, select the folder with scripts in the configuration menu below
+Tools -> Configure TAS. The file itself has normal text format and has to be called script0-1.txt
+for controller 1, script0-2.txt for controller 2 and so forth (with max. 8 players).
+
+A script file has the same format as TAS-nx uses, so final files will look like this:
+
+1 KEY_B 0;0 0;0
+6 KEY_ZL 0;0 0;0
+41 KEY_ZL;KEY_Y 0;0 0;0
+43 KEY_X;KEY_A 32767;0 0;0
+44 KEY_A 32767;0 0;0
+45 KEY_A 32767;0 0;0
+46 KEY_A 32767;0 0;0
+47 KEY_A 32767;0 0;0
+
+After placing the file at the correct location, it can be read into Yuzu with the (default) hotkey
+CTRL+F6 (refresh). In the bottom left corner, it will display the amount of frames the script file
+has. Playback can be started or stopped using CTRL+F5.
+
+However, for playback to actually work, the correct input device has to be selected: In the Controls
+menu, select TAS from the device list for the controller that the script should be played on.
+
+Recording a new script file is really simple: Just make sure that the proper device (not TAS) is
+connected on P1, and press CTRL+F7 to start recording. When done, just press the same keystroke
+again (CTRL+F7). The new script will be saved at the location previously selected, as the filename
+record.txt.
+
+For debugging purposes, the common controller debugger can be used (View -> Debugging -> Controller
+P1).
+*/
+
+namespace TasInput {
+
+constexpr size_t PLAYER_NUMBER = 8;
+
+using TasAnalog = std::pair<float, float>;
+
+enum class TasState {
+    Running,
+    Recording,
+    Stopped,
+};
+
+enum class TasButton : u32 {
+    BUTTON_A = 1U << 0,
+    BUTTON_B = 1U << 1,
+    BUTTON_X = 1U << 2,
+    BUTTON_Y = 1U << 3,
+    STICK_L = 1U << 4,
+    STICK_R = 1U << 5,
+    TRIGGER_L = 1U << 6,
+    TRIGGER_R = 1U << 7,
+    TRIGGER_ZL = 1U << 8,
+    TRIGGER_ZR = 1U << 9,
+    BUTTON_PLUS = 1U << 10,
+    BUTTON_MINUS = 1U << 11,
+    BUTTON_LEFT = 1U << 12,
+    BUTTON_UP = 1U << 13,
+    BUTTON_RIGHT = 1U << 14,
+    BUTTON_DOWN = 1U << 15,
+    BUTTON_SL = 1U << 16,
+    BUTTON_SR = 1U << 17,
+    BUTTON_HOME = 1U << 18,
+    BUTTON_CAPTURE = 1U << 19,
+};
+
+enum class TasAxes : u8 {
+    StickX,
+    StickY,
+    SubstickX,
+    SubstickY,
+    Undefined,
+};
+
+struct TasData {
+    u32 buttons{};
+    std::array<float, 4> axis{};
+};
+
+class Tas {
+public:
+    Tas();
+    ~Tas();
+
+    // Changes the input status that will be stored in each frame
+    void RecordInput(u32 buttons, const std::array<std::pair<float, float>, 2>& axes);
+
+    // Main loop that records or executes input
+    void UpdateThread();
+
+    //  Sets the flag to start or stop the TAS command excecution and swaps controllers profiles
+    void StartStop();
+
+    //  Stop the TAS and reverts any controller profile
+    void Stop();
+
+    // Sets the flag to reload the file and start from the begining in the next update
+    void Reset();
+
+    /**
+     * Sets the flag to enable or disable recording of inputs
+     * @return Returns true if the current recording status is enabled
+     */
+    bool Record();
+
+    // Saves contents of record_commands on a file if overwrite is enabled player 1 will be
+    // overwritten with the recorded commands
+    void SaveRecording(bool overwrite_file);
+
+    /**
+     * Returns the current status values of TAS playback/recording
+     * @return Tuple of
+     * TasState indicating the current state out of Running, Recording or Stopped ;
+     * Current playback progress or amount of frames (so far) for Recording ;
+     * Total length of script file currently loaded or amount of frames (so far) for Recording
+     */
+    std::tuple<TasState, size_t, size_t> GetStatus() const;
+
+    // Retuns an array of the default button mappings
+    InputCommon::ButtonMapping GetButtonMappingForDevice(const Common::ParamPackage& params) const;
+
+    // Retuns an array of the default analog mappings
+    InputCommon::AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) const;
+    [[nodiscard]] const TasData& GetTasState(std::size_t pad) const;
+
+private:
+    struct TASCommand {
+        u32 buttons{};
+        TasAnalog l_axis{};
+        TasAnalog r_axis{};
+    };
+
+    // Loads TAS files from all players
+    void LoadTasFiles();
+
+    // Loads TAS file from the specified player
+    void LoadTasFile(size_t player_index);
+
+    // Writes a TAS file from the recorded commands
+    void WriteTasFile(std::u8string file_name);
+
+    /**
+     * Parses a string containing the axis values with the following format "x;y"
+     * X and Y have a range from -32767 to 32767
+     * @return Returns a TAS analog object with axis values with range from -1.0 to 1.0
+     */
+    TasAnalog ReadCommandAxis(const std::string& line) const;
+
+    /**
+     * Parses a string containing the button values with the following format "a;b;c;d..."
+     * Each button is represented by it's text format specified in text_to_tas_button array
+     * @return Returns a u32 with each bit representing the status of a button
+     */
+    u32 ReadCommandButtons(const std::string& line) const;
+
+    /**
+     * Converts an u32 containing the button status into the text equivalent
+     * @return Returns a string with the name of the buttons to be written to the file
+     */
+    std::string WriteCommandButtons(u32 data) const;
+
+    /**
+     * Converts an TAS analog object containing the axis status into the text equivalent
+     * @return Returns a string with the value of the axis to be written to the file
+     */
+    std::string WriteCommandAxis(TasAnalog data) const;
+
+    // Inverts the Y axis polarity
+    std::pair<float, float> FlipAxisY(std::pair<float, float> old);
+
+    /**
+     * Converts an u32 containing the button status into the text equivalent
+     * @return Returns a string with the name of the buttons to be printed on console
+     */
+    std::string DebugButtons(u32 buttons) const;
+
+    /**
+     * Converts an TAS analog object containing the axis status into the text equivalent
+     * @return Returns a string with the value of the axis to be printed on console
+     */
+    std::string DebugJoystick(float x, float y) const;
+
+    /**
+     * Converts the given TAS status into the text equivalent
+     * @return Returns a string with the value of the TAS status to be printed on console
+     */
+    std::string DebugInput(const TasData& data) const;
+
+    /**
+     * Converts the given TAS status of multiple players into the text equivalent
+     * @return Returns a string with the value of the status of all TAS players to be printed on
+     * console
+     */
+    std::string DebugInputs(const std::array<TasData, PLAYER_NUMBER>& arr) const;
+
+    /**
+     * Converts an u32 containing the button status into the text equivalent
+     * @return Returns a string with the name of the buttons
+     */
+    std::string ButtonsToString(u32 button) const;
+
+    // Stores current controller configuration and sets a TAS controller for every active controller
+    // to the current config
+    void SwapToTasController();
+
+    // Sets the stored controller configuration to the current config
+    void SwapToStoredController();
+
+    size_t script_length{0};
+    std::array<TasData, PLAYER_NUMBER> tas_data;
+    bool is_old_input_saved{false};
+    bool is_recording{false};
+    bool is_running{false};
+    bool needs_reset{false};
+    std::array<std::vector<TASCommand>, PLAYER_NUMBER> commands{};
+    std::vector<TASCommand> record_commands{};
+    size_t current_command{0};
+    TASCommand last_input{}; // only used for recording
+
+    // Old settings for swapping controllers
+    std::array<Settings::PlayerInput, 10> player_mappings;
+};
+} // namespace TasInput

src/input_common/tas/tas_poller.cpp

@@ -0,0 +1,101 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <mutex>
+#include <utility>
+
+#include "common/settings.h"
+#include "common/threadsafe_queue.h"
+#include "input_common/tas/tas_input.h"
+#include "input_common/tas/tas_poller.h"
+
+namespace InputCommon {
+
+class TasButton final : public Input::ButtonDevice {
+public:
+    explicit TasButton(u32 button_, u32 pad_, const TasInput::Tas* tas_input_)
+        : button(button_), pad(pad_), tas_input(tas_input_) {}
+
+    bool GetStatus() const override {
+        return (tas_input->GetTasState(pad).buttons & button) != 0;
+    }
+
+private:
+    const u32 button;
+    const u32 pad;
+    const TasInput::Tas* tas_input;
+};
+
+TasButtonFactory::TasButtonFactory(std::shared_ptr<TasInput::Tas> tas_input_)
+    : tas_input(std::move(tas_input_)) {}
+
+std::unique_ptr<Input::ButtonDevice> TasButtonFactory::Create(const Common::ParamPackage& params) {
+    const auto button_id = params.Get("button", 0);
+    const auto pad = params.Get("pad", 0);
+
+    return std::make_unique<TasButton>(button_id, pad, tas_input.get());
+}
+
+class TasAnalog final : public Input::AnalogDevice {
+public:
+    explicit TasAnalog(u32 pad_, u32 axis_x_, u32 axis_y_, const TasInput::Tas* tas_input_)
+        : pad(pad_), axis_x(axis_x_), axis_y(axis_y_), tas_input(tas_input_) {}
+
+    float GetAxis(u32 axis) const {
+        std::lock_guard lock{mutex};
+        return tas_input->GetTasState(pad).axis.at(axis);
+    }
+
+    std::pair<float, float> GetAnalog(u32 analog_axis_x, u32 analog_axis_y) const {
+        float x = GetAxis(analog_axis_x);
+        float y = GetAxis(analog_axis_y);
+
+        // Make sure the coordinates are in the unit circle,
+        // otherwise normalize it.
+        float r = x * x + y * y;
+        if (r > 1.0f) {
+            r = std::sqrt(r);
+            x /= r;
+            y /= r;
+        }
+
+        return {x, y};
+    }
+
+    std::tuple<float, float> GetStatus() const override {
+        return GetAnalog(axis_x, axis_y);
+    }
+
+    Input::AnalogProperties GetAnalogProperties() const override {
+        return {0.0f, 1.0f, 0.5f};
+    }
+
+private:
+    const u32 pad;
+    const u32 axis_x;
+    const u32 axis_y;
+    const TasInput::Tas* tas_input;
+    mutable std::mutex mutex;
+};
+
+/// An analog device factory that creates analog devices from GC Adapter
+TasAnalogFactory::TasAnalogFactory(std::shared_ptr<TasInput::Tas> tas_input_)
+    : tas_input(std::move(tas_input_)) {}
+
+/**
+ * Creates analog device from joystick axes
+ * @param params contains parameters for creating the device:
+ *     - "port": the nth gcpad on the adapter
+ *     - "axis_x": the index of the axis to be bind as x-axis
+ *     - "axis_y": the index of the axis to be bind as y-axis
+ */
+std::unique_ptr<Input::AnalogDevice> TasAnalogFactory::Create(const Common::ParamPackage& params) {
+    const auto pad = static_cast<u32>(params.Get("pad", 0));
+    const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
+    const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
+
+    return std::make_unique<TasAnalog>(pad, axis_x, axis_y, tas_input.get());
+}
+
+} // namespace InputCommon

src/input_common/tas/tas_poller.h

@@ -0,0 +1,43 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include "core/frontend/input.h"
+#include "input_common/tas/tas_input.h"
+
+namespace InputCommon {
+
+/**
+ * A button device factory representing a tas bot. It receives tas events and forward them
+ * to all button devices it created.
+ */
+class TasButtonFactory final : public Input::Factory<Input::ButtonDevice> {
+public:
+    explicit TasButtonFactory(std::shared_ptr<TasInput::Tas> tas_input_);
+
+    /**
+     * Creates a button device from a button press
+     * @param params contains parameters for creating the device:
+     *     - "code": the code of the key to bind with the button
+     */
+    std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override;
+
+private:
+    std::shared_ptr<TasInput::Tas> tas_input;
+};
+
+/// An analog device factory that creates analog devices from tas
+class TasAnalogFactory final : public Input::Factory<Input::AnalogDevice> {
+public:
+    explicit TasAnalogFactory(std::shared_ptr<TasInput::Tas> tas_input_);
+
+    std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override;
+
+private:
+    std::shared_ptr<TasInput::Tas> tas_input;
+};
+
+} // namespace InputCommon

src/input_common/udp/client.h

@@ -21,8 +21,6 @@
 
 namespace InputCommon::CemuhookUDP {
 
-constexpr char DEFAULT_SRV[] = "127.0.0.1:26760";
-
 class Socket;
 
 namespace Response {

src/shader_recompiler/backend/glsl/emit_glsl_warp.cpp

@@ -11,6 +11,8 @@
 
 namespace Shader::Backend::GLSL {
 namespace {
+constexpr char THREAD_ID[]{"gl_SubGroupInvocationARB"};
+
 void SetInBoundsFlag(EmitContext& ctx, IR::Inst& inst) {
     IR::Inst* const in_bounds{inst.GetAssociatedPseudoOperation(IR::Opcode::GetInBoundsFromOp)};
     if (!in_bounds) {
@@ -43,84 +45,100 @@ void UseShuffleNv(EmitContext& ctx, IR::Inst& inst, std::string_view shfl_op,
     ctx.AddU32("{}={}({},{},{},shfl_in_bounds);", inst, shfl_op, value, index, width);
     SetInBoundsFlag(ctx, inst);
 }
+
+std::string_view BallotIndex(EmitContext& ctx) {
+    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
+        return ".x";
+    }
+    return "[gl_SubGroupInvocationARB>>5]";
+}
+
+std::string GetMask(EmitContext& ctx, std::string_view mask) {
+    const auto ballot_index{BallotIndex(ctx)};
+    return fmt::format("uint(uvec2({}){})", mask, ballot_index);
+}
 } // Anonymous namespace
 
 void EmitLaneId(EmitContext& ctx, IR::Inst& inst) {
-    ctx.AddU32("{}=gl_SubGroupInvocationARB&31u;", inst);
+    ctx.AddU32("{}={}&31u;", inst, THREAD_ID);
 }
 
 void EmitVoteAll(EmitContext& ctx, IR::Inst& inst, std::string_view pred) {
     if (!ctx.profile.warp_size_potentially_larger_than_guest) {
         ctx.AddU1("{}=allInvocationsEqualARB({});", inst, pred);
-    } else {
-        const auto active_mask{fmt::format("uvec2(ballotARB(true))[gl_SubGroupInvocationARB]")};
-        const auto ballot{fmt::format("uvec2(ballotARB({}))[gl_SubGroupInvocationARB]", pred)};
-        ctx.AddU1("{}=({}&{})=={};", inst, ballot, active_mask, active_mask);
+        return;
     }
+    const auto ballot_index{BallotIndex(ctx)};
+    const auto active_mask{fmt::format("uvec2(ballotARB(true)){}", ballot_index)};
+    const auto ballot{fmt::format("uvec2(ballotARB({})){}", pred, ballot_index)};
+    ctx.AddU1("{}=({}&{})=={};", inst, ballot, active_mask, active_mask);
 }
 
 void EmitVoteAny(EmitContext& ctx, IR::Inst& inst, std::string_view pred) {
     if (!ctx.profile.warp_size_potentially_larger_than_guest) {
         ctx.AddU1("{}=anyInvocationARB({});", inst, pred);
-    } else {
-        const auto active_mask{fmt::format("uvec2(ballotARB(true))[gl_SubGroupInvocationARB]")};
-        const auto ballot{fmt::format("uvec2(ballotARB({}))[gl_SubGroupInvocationARB]", pred)};
-        ctx.AddU1("{}=({}&{})!=0u;", inst, ballot, active_mask, active_mask);
+        return;
     }
+    const auto ballot_index{BallotIndex(ctx)};
+    const auto active_mask{fmt::format("uvec2(ballotARB(true)){}", ballot_index)};
+    const auto ballot{fmt::format("uvec2(ballotARB({})){}", pred, ballot_index)};
+    ctx.AddU1("{}=({}&{})!=0u;", inst, ballot, active_mask, active_mask);
 }
 
 void EmitVoteEqual(EmitContext& ctx, IR::Inst& inst, std::string_view pred) {
     if (!ctx.profile.warp_size_potentially_larger_than_guest) {
         ctx.AddU1("{}=allInvocationsEqualARB({});", inst, pred);
-    } else {
-        const auto active_mask{fmt::format("uvec2(ballotARB(true))[gl_SubGroupInvocationARB]")};
-        const auto ballot{fmt::format("uvec2(ballotARB({}))[gl_SubGroupInvocationARB]", pred)};
-        const auto value{fmt::format("({}^{})", ballot, active_mask)};
-        ctx.AddU1("{}=({}==0)||({}=={});", inst, value, value, active_mask);
+        return;
     }
+    const auto ballot_index{BallotIndex(ctx)};
+    const auto active_mask{fmt::format("uvec2(ballotARB(true)){}", ballot_index)};
+    const auto ballot{fmt::format("uvec2(ballotARB({})){}", pred, ballot_index)};
+    const auto value{fmt::format("({}^{})", ballot, active_mask)};
+    ctx.AddU1("{}=({}==0)||({}=={});", inst, value, value, active_mask);
 }
 
 void EmitSubgroupBallot(EmitContext& ctx, IR::Inst& inst, std::string_view pred) {
-    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
-        ctx.AddU32("{}=uvec2(ballotARB({})).x;", inst, pred);
-    } else {
-        ctx.AddU32("{}=uvec2(ballotARB({}))[gl_SubGroupInvocationARB];", inst, pred);
-    }
+    const auto ballot_index{BallotIndex(ctx)};
+    ctx.AddU32("{}=uvec2(ballotARB({})){};", inst, pred, ballot_index);
 }
 
 void EmitSubgroupEqMask(EmitContext& ctx, IR::Inst& inst) {
-    ctx.AddU32("{}=uint(gl_SubGroupEqMaskARB.x);", inst);
+    ctx.AddU32("{}={};", inst, GetMask(ctx, "gl_SubGroupEqMaskARB"));
 }
 
 void EmitSubgroupLtMask(EmitContext& ctx, IR::Inst& inst) {
-    ctx.AddU32("{}=uint(gl_SubGroupLtMaskARB.x);", inst);
+    ctx.AddU32("{}={};", inst, GetMask(ctx, "gl_SubGroupLtMaskARB"));
 }
 
 void EmitSubgroupLeMask(EmitContext& ctx, IR::Inst& inst) {
-    ctx.AddU32("{}=uint(gl_SubGroupLeMaskARB.x);", inst);
+    ctx.AddU32("{}={};", inst, GetMask(ctx, "gl_SubGroupLeMaskARB"));
 }
 
 void EmitSubgroupGtMask(EmitContext& ctx, IR::Inst& inst) {
-    ctx.AddU32("{}=uint(gl_SubGroupGtMaskARB.x);", inst);
+    ctx.AddU32("{}={};", inst, GetMask(ctx, "gl_SubGroupGtMaskARB"));
 }
 
 void EmitSubgroupGeMask(EmitContext& ctx, IR::Inst& inst) {
-    ctx.AddU32("{}=uint(gl_SubGroupGeMaskARB.x);", inst);
+    ctx.AddU32("{}={};", inst, GetMask(ctx, "gl_SubGroupGeMaskARB"));
 }
 
 void EmitShuffleIndex(EmitContext& ctx, IR::Inst& inst, std::string_view value,
-                      std::string_view index, std::string_view clamp,
-                      std::string_view segmentation_mask) {
+                      std::string_view index, std::string_view clamp, std::string_view seg_mask) {
     if (ctx.profile.support_gl_warp_intrinsics) {
-        UseShuffleNv(ctx, inst, "shuffleNV", value, index, clamp, segmentation_mask);
+        UseShuffleNv(ctx, inst, "shuffleNV", value, index, clamp, seg_mask);
         return;
     }
-    const auto not_seg_mask{fmt::format("(~{})", segmentation_mask)};
-    const auto thread_id{"gl_SubGroupInvocationARB"};
-    const auto min_thread_id{ComputeMinThreadId(thread_id, segmentation_mask)};
-    const auto max_thread_id{ComputeMaxThreadId(min_thread_id, clamp, not_seg_mask)};
+    const bool big_warp{ctx.profile.warp_size_potentially_larger_than_guest};
+    const auto is_upper_partition{"int(gl_SubGroupInvocationARB)>=32"};
+    const auto upper_index{fmt::format("{}?{}+32:{}", is_upper_partition, index, index)};
+    const auto upper_clamp{fmt::format("{}?{}+32:{}", is_upper_partition, clamp, clamp)};
 
-    const auto lhs{fmt::format("({}&{})", index, not_seg_mask)};
+    const auto not_seg_mask{fmt::format("(~{})", seg_mask)};
+    const auto min_thread_id{ComputeMinThreadId(THREAD_ID, seg_mask)};
+    const auto max_thread_id{
+        ComputeMaxThreadId(min_thread_id, big_warp ? upper_clamp : clamp, not_seg_mask)};
+
+    const auto lhs{fmt::format("({}&{})", big_warp ? upper_index : index, not_seg_mask)};
     const auto src_thread_id{fmt::format("({})|({})", lhs, min_thread_id)};
     ctx.Add("shfl_in_bounds=int({})<=int({});", src_thread_id, max_thread_id);
     SetInBoundsFlag(ctx, inst);
@@ -128,29 +146,34 @@ void EmitShuffleIndex(EmitContext& ctx, IR::Inst& inst, std::string_view value,
 }
 
 void EmitShuffleUp(EmitContext& ctx, IR::Inst& inst, std::string_view value, std::string_view index,
-                   std::string_view clamp, std::string_view segmentation_mask) {
+                   std::string_view clamp, std::string_view seg_mask) {
     if (ctx.profile.support_gl_warp_intrinsics) {
-        UseShuffleNv(ctx, inst, "shuffleUpNV", value, index, clamp, segmentation_mask);
+        UseShuffleNv(ctx, inst, "shuffleUpNV", value, index, clamp, seg_mask);
         return;
     }
-    const auto thread_id{"gl_SubGroupInvocationARB"};
-    const auto max_thread_id{GetMaxThreadId(thread_id, clamp, segmentation_mask)};
-    const auto src_thread_id{fmt::format("({}-{})", thread_id, index)};
+    const bool big_warp{ctx.profile.warp_size_potentially_larger_than_guest};
+    const auto is_upper_partition{"int(gl_SubGroupInvocationARB)>=32"};
+    const auto upper_clamp{fmt::format("{}?{}+32:{}", is_upper_partition, clamp, clamp)};
+
+    const auto max_thread_id{GetMaxThreadId(THREAD_ID, big_warp ? upper_clamp : clamp, seg_mask)};
+    const auto src_thread_id{fmt::format("({}-{})", THREAD_ID, index)};
     ctx.Add("shfl_in_bounds=int({})>=int({});", src_thread_id, max_thread_id);
     SetInBoundsFlag(ctx, inst);
     ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
 }
 
 void EmitShuffleDown(EmitContext& ctx, IR::Inst& inst, std::string_view value,
-                     std::string_view index, std::string_view clamp,
-                     std::string_view segmentation_mask) {
+                     std::string_view index, std::string_view clamp, std::string_view seg_mask) {
     if (ctx.profile.support_gl_warp_intrinsics) {
-        UseShuffleNv(ctx, inst, "shuffleDownNV", value, index, clamp, segmentation_mask);
+        UseShuffleNv(ctx, inst, "shuffleDownNV", value, index, clamp, seg_mask);
         return;
     }
-    const auto thread_id{"gl_SubGroupInvocationARB"};
-    const auto max_thread_id{GetMaxThreadId(thread_id, clamp, segmentation_mask)};
-    const auto src_thread_id{fmt::format("({}+{})", thread_id, index)};
+    const bool big_warp{ctx.profile.warp_size_potentially_larger_than_guest};
+    const auto is_upper_partition{"int(gl_SubGroupInvocationARB)>=32"};
+    const auto upper_clamp{fmt::format("{}?{}+32:{}", is_upper_partition, clamp, clamp)};
+
+    const auto max_thread_id{GetMaxThreadId(THREAD_ID, big_warp ? upper_clamp : clamp, seg_mask)};
+    const auto src_thread_id{fmt::format("({}+{})", THREAD_ID, index)};
     ctx.Add("shfl_in_bounds=int({})<=int({});", src_thread_id, max_thread_id);
     SetInBoundsFlag(ctx, inst);
     ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
@@ -158,14 +181,17 @@ void EmitShuffleDown(EmitContext& ctx, IR::Inst& inst, std::string_view value,
 
 void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, std::string_view value,
                           std::string_view index, std::string_view clamp,
-                          std::string_view segmentation_mask) {
+                          std::string_view seg_mask) {
     if (ctx.profile.support_gl_warp_intrinsics) {
-        UseShuffleNv(ctx, inst, "shuffleXorNV", value, index, clamp, segmentation_mask);
+        UseShuffleNv(ctx, inst, "shuffleXorNV", value, index, clamp, seg_mask);
         return;
     }
-    const auto thread_id{"gl_SubGroupInvocationARB"};
-    const auto max_thread_id{GetMaxThreadId(thread_id, clamp, segmentation_mask)};
-    const auto src_thread_id{fmt::format("({}^{})", thread_id, index)};
+    const bool big_warp{ctx.profile.warp_size_potentially_larger_than_guest};
+    const auto is_upper_partition{"int(gl_SubGroupInvocationARB)>=32"};
+    const auto upper_clamp{fmt::format("{}?{}+32:{}", is_upper_partition, clamp, clamp)};
+
+    const auto max_thread_id{GetMaxThreadId(THREAD_ID, big_warp ? upper_clamp : clamp, seg_mask)};
+    const auto src_thread_id{fmt::format("({}^{})", THREAD_ID, index)};
     ctx.Add("shfl_in_bounds=int({})<=int({});", src_thread_id, max_thread_id);
     SetInBoundsFlag(ctx, inst);
     ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);

src/shader_recompiler/backend/spirv/emit_context.cpp

@@ -15,6 +15,8 @@
 
 namespace Shader::Backend::SPIRV {
 namespace {
+constexpr size_t NUM_FIXEDFNCTEXTURE = 10;
+
 enum class Operation {
     Increment,
     Decrement,
@@ -427,6 +429,16 @@ Id DescType(EmitContext& ctx, Id sampled_type, Id pointer_type, u32 count) {
         return pointer_type;
     }
 }
+
+size_t FindNextUnusedLocation(const std::bitset<IR::NUM_GENERICS>& used_locations,
+                              size_t start_offset) {
+    for (size_t location = start_offset; location < used_locations.size(); ++location) {
+        if (!used_locations.test(location)) {
+            return location;
+        }
+    }
+    throw RuntimeError("Unable to get an unused location for legacy attribute");
+}
 } // Anonymous namespace
 
 void VectorTypes::Define(Sirit::Module& sirit_ctx, Id base_type, std::string_view name) {
@@ -1227,6 +1239,7 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         loads[IR::Attribute::TessellationEvaluationPointV]) {
         tess_coord = DefineInput(*this, F32[3], false, spv::BuiltIn::TessCoord);
     }
+    std::bitset<IR::NUM_GENERICS> used_locations{};
     for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
         const AttributeType input_type{runtime_info.generic_input_types[index]};
         if (!runtime_info.previous_stage_stores.Generic(index)) {
@@ -1238,6 +1251,7 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         if (input_type == AttributeType::Disabled) {
             continue;
         }
+        used_locations.set(index);
         const Id type{GetAttributeType(*this, input_type)};
         const Id id{DefineInput(*this, type, true)};
         Decorate(id, spv::Decoration::Location, static_cast<u32>(index));
@@ -1263,6 +1277,26 @@ void EmitContext::DefineInputs(const IR::Program& program) {
             break;
         }
     }
+    size_t previous_unused_location = 0;
+    if (loads.AnyComponent(IR::Attribute::ColorFrontDiffuseR)) {
+        const size_t location = FindNextUnusedLocation(used_locations, previous_unused_location);
+        previous_unused_location = location;
+        used_locations.set(location);
+        const Id id{DefineInput(*this, F32[4], true)};
+        Decorate(id, spv::Decoration::Location, location);
+        input_front_color = id;
+    }
+    for (size_t index = 0; index < NUM_FIXEDFNCTEXTURE; ++index) {
+        if (loads.AnyComponent(IR::Attribute::FixedFncTexture0S + index * 4)) {
+            const size_t location =
+                FindNextUnusedLocation(used_locations, previous_unused_location);
+            previous_unused_location = location;
+            used_locations.set(location);
+            const Id id{DefineInput(*this, F32[4], true)};
+            Decorate(id, spv::Decoration::Location, location);
+            input_fixed_fnc_textures[index] = id;
+        }
+    }
     if (stage == Stage::TessellationEval) {
         for (size_t index = 0; index < info.uses_patches.size(); ++index) {
             if (!info.uses_patches[index]) {
@@ -1313,9 +1347,31 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
         viewport_mask = DefineOutput(*this, TypeArray(U32[1], Const(1u)), std::nullopt,
                                      spv::BuiltIn::ViewportMaskNV);
     }
+    std::bitset<IR::NUM_GENERICS> used_locations{};
     for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
         if (info.stores.Generic(index)) {
             DefineGenericOutput(*this, index, invocations);
+            used_locations.set(index);
+        }
+    }
+    size_t previous_unused_location = 0;
+    if (info.stores.AnyComponent(IR::Attribute::ColorFrontDiffuseR)) {
+        const size_t location = FindNextUnusedLocation(used_locations, previous_unused_location);
+        previous_unused_location = location;
+        used_locations.set(location);
+        const Id id{DefineOutput(*this, F32[4], invocations)};
+        Decorate(id, spv::Decoration::Location, static_cast<u32>(location));
+        output_front_color = id;
+    }
+    for (size_t index = 0; index < NUM_FIXEDFNCTEXTURE; ++index) {
+        if (info.stores.AnyComponent(IR::Attribute::FixedFncTexture0S + index * 4)) {
+            const size_t location =
+                FindNextUnusedLocation(used_locations, previous_unused_location);
+            previous_unused_location = location;
+            used_locations.set(location);
+            const Id id{DefineOutput(*this, F32[4], invocations)};
+            Decorate(id, spv::Decoration::Location, location);
+            output_fixed_fnc_textures[index] = id;
         }
     }
     switch (stage) {

src/shader_recompiler/backend/spirv/emit_context.h

@@ -268,10 +268,14 @@ public:
     Id write_global_func_u32x4{};
 
     Id input_position{};
+    Id input_front_color{};
+    std::array<Id, 10> input_fixed_fnc_textures{};
     std::array<Id, 32> input_generics{};
 
     Id output_point_size{};
     Id output_position{};
+    Id output_front_color{};
+    std::array<Id, 10> output_fixed_fnc_textures{};
     std::array<std::array<GenericElementInfo, 4>, 32> output_generics{};
 
     Id output_tess_level_outer{};

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -43,6 +43,25 @@ Id AttrPointer(EmitContext& ctx, Id pointer_type, Id vertex, Id base, Args&&...
     }
 }
 
+bool IsFixedFncTexture(IR::Attribute attribute) {
+    return attribute >= IR::Attribute::FixedFncTexture0S &&
+           attribute <= IR::Attribute::FixedFncTexture9Q;
+}
+
+u32 FixedFncTextureAttributeIndex(IR::Attribute attribute) {
+    if (!IsFixedFncTexture(attribute)) {
+        throw InvalidArgument("Attribute {} is not a FixedFncTexture", attribute);
+    }
+    return (static_cast<u32>(attribute) - static_cast<u32>(IR::Attribute::FixedFncTexture0S)) / 4u;
+}
+
+u32 FixedFncTextureAttributeElement(IR::Attribute attribute) {
+    if (!IsFixedFncTexture(attribute)) {
+        throw InvalidArgument("Attribute {} is not a FixedFncTexture", attribute);
+    }
+    return static_cast<u32>(attribute) % 4u;
+}
+
 template <typename... Args>
 Id OutputAccessChain(EmitContext& ctx, Id result_type, Id base, Args&&... args) {
     if (ctx.stage == Stage::TessellationControl) {
@@ -74,6 +93,13 @@ std::optional<OutAttr> OutputAttrPointer(EmitContext& ctx, IR::Attribute attr) {
             return OutputAccessChain(ctx, ctx.output_f32, info.id, index_id);
         }
     }
+    if (IsFixedFncTexture(attr)) {
+        const u32 index{FixedFncTextureAttributeIndex(attr)};
+        const u32 element{FixedFncTextureAttributeElement(attr)};
+        const Id element_id{ctx.Const(element)};
+        return OutputAccessChain(ctx, ctx.output_f32, ctx.output_fixed_fnc_textures[index],
+                                 element_id);
+    }
     switch (attr) {
     case IR::Attribute::PointSize:
         return ctx.output_point_size;
@@ -85,6 +111,14 @@ std::optional<OutAttr> OutputAttrPointer(EmitContext& ctx, IR::Attribute attr) {
         const Id element_id{ctx.Const(element)};
         return OutputAccessChain(ctx, ctx.output_f32, ctx.output_position, element_id);
     }
+    case IR::Attribute::ColorFrontDiffuseR:
+    case IR::Attribute::ColorFrontDiffuseG:
+    case IR::Attribute::ColorFrontDiffuseB:
+    case IR::Attribute::ColorFrontDiffuseA: {
+        const u32 element{static_cast<u32>(attr) % 4};
+        const Id element_id{ctx.Const(element)};
+        return OutputAccessChain(ctx, ctx.output_f32, ctx.output_front_color, element_id);
+    }
     case IR::Attribute::ClipDistance0:
     case IR::Attribute::ClipDistance1:
     case IR::Attribute::ClipDistance2:
@@ -307,6 +341,12 @@ Id EmitGetAttribute(EmitContext& ctx, IR::Attribute attr, Id vertex) {
         const Id value{ctx.OpLoad(type->id, pointer)};
         return type->needs_cast ? ctx.OpBitcast(ctx.F32[1], value) : value;
     }
+    if (IsFixedFncTexture(attr)) {
+        const u32 index{FixedFncTextureAttributeIndex(attr)};
+        const Id attr_id{ctx.input_fixed_fnc_textures[index]};
+        const Id attr_ptr{AttrPointer(ctx, ctx.input_f32, vertex, attr_id, ctx.Const(element))};
+        return ctx.OpLoad(ctx.F32[1], attr_ptr);
+    }
     switch (attr) {
     case IR::Attribute::PrimitiveId:
         return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.primitive_id));
@@ -316,6 +356,13 @@ Id EmitGetAttribute(EmitContext& ctx, IR::Attribute attr, Id vertex) {
     case IR::Attribute::PositionW:
         return ctx.OpLoad(ctx.F32[1], AttrPointer(ctx, ctx.input_f32, vertex, ctx.input_position,
                                                   ctx.Const(element)));
+    case IR::Attribute::ColorFrontDiffuseR:
+    case IR::Attribute::ColorFrontDiffuseG:
+    case IR::Attribute::ColorFrontDiffuseB:
+    case IR::Attribute::ColorFrontDiffuseA: {
+        return ctx.OpLoad(ctx.F32[1], AttrPointer(ctx, ctx.input_f32, vertex, ctx.input_front_color,
+                                                  ctx.Const(element)));
+    }
     case IR::Attribute::InstanceId:
         if (ctx.profile.support_vertex_instance_id) {
             return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.instance_id));
@@ -430,7 +477,13 @@ void EmitSetSampleMask(EmitContext& ctx, Id value) {
 }
 
 void EmitSetFragDepth(EmitContext& ctx, Id value) {
-    ctx.OpStore(ctx.frag_depth, value);
+    if (!ctx.runtime_info.convert_depth_mode) {
+        ctx.OpStore(ctx.frag_depth, value);
+        return;
+    }
+    const Id unit{ctx.Const(0.5f)};
+    const Id new_depth{ctx.OpFma(ctx.F32[1], value, unit, unit)};
+    ctx.OpStore(ctx.frag_depth, new_depth);
 }
 
 void EmitGetZFlag(EmitContext&) {

src/shader_recompiler/backend/spirv/emit_spirv_warp.cpp

@@ -7,8 +7,13 @@
 
 namespace Shader::Backend::SPIRV {
 namespace {
+Id GetThreadId(EmitContext& ctx) {
+    return ctx.OpLoad(ctx.U32[1], ctx.subgroup_local_invocation_id);
+}
+
 Id WarpExtract(EmitContext& ctx, Id value) {
-    const Id local_index{ctx.OpLoad(ctx.U32[1], ctx.subgroup_local_invocation_id)};
+    const Id thread_id{GetThreadId(ctx)};
+    const Id local_index{ctx.OpShiftRightArithmetic(ctx.U32[1], thread_id, ctx.Const(5U))};
     return ctx.OpVectorExtractDynamic(ctx.U32[1], value, local_index);
 }
 
@@ -48,10 +53,17 @@ Id SelectValue(EmitContext& ctx, Id in_range, Id value, Id src_thread_id) {
     return ctx.OpSelect(ctx.U32[1], in_range,
                         ctx.OpSubgroupReadInvocationKHR(ctx.U32[1], value, src_thread_id), value);
 }
+
+Id GetUpperClamp(EmitContext& ctx, Id invocation_id, Id clamp) {
+    const Id thirty_two{ctx.Const(32u)};
+    const Id is_upper_partition{ctx.OpSGreaterThanEqual(ctx.U1, invocation_id, thirty_two)};
+    const Id upper_clamp{ctx.OpIAdd(ctx.U32[1], thirty_two, clamp)};
+    return ctx.OpSelect(ctx.U32[1], is_upper_partition, upper_clamp, clamp);
+}
 } // Anonymous namespace
 
 Id EmitLaneId(EmitContext& ctx) {
-    const Id id{ctx.OpLoad(ctx.U32[1], ctx.subgroup_local_invocation_id)};
+    const Id id{GetThreadId(ctx)};
     if (!ctx.profile.warp_size_potentially_larger_than_guest) {
         return id;
     }
@@ -123,7 +135,15 @@ Id EmitSubgroupGeMask(EmitContext& ctx) {
 Id EmitShuffleIndex(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                     Id segmentation_mask) {
     const Id not_seg_mask{ctx.OpNot(ctx.U32[1], segmentation_mask)};
-    const Id thread_id{ctx.OpLoad(ctx.U32[1], ctx.subgroup_local_invocation_id)};
+    const Id thread_id{GetThreadId(ctx)};
+    if (ctx.profile.warp_size_potentially_larger_than_guest) {
+        const Id thirty_two{ctx.Const(32u)};
+        const Id is_upper_partition{ctx.OpSGreaterThanEqual(ctx.U1, thread_id, thirty_two)};
+        const Id upper_index{ctx.OpIAdd(ctx.U32[1], thirty_two, index)};
+        const Id upper_clamp{ctx.OpIAdd(ctx.U32[1], thirty_two, clamp)};
+        index = ctx.OpSelect(ctx.U32[1], is_upper_partition, upper_index, index);
+        clamp = ctx.OpSelect(ctx.U32[1], is_upper_partition, upper_clamp, clamp);
+    }
     const Id min_thread_id{ComputeMinThreadId(ctx, thread_id, segmentation_mask)};
     const Id max_thread_id{ComputeMaxThreadId(ctx, min_thread_id, clamp, not_seg_mask)};
 
@@ -137,7 +157,10 @@ Id EmitShuffleIndex(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id cla
 
 Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                  Id segmentation_mask) {
-    const Id thread_id{ctx.OpLoad(ctx.U32[1], ctx.subgroup_local_invocation_id)};
+    const Id thread_id{GetThreadId(ctx)};
+    if (ctx.profile.warp_size_potentially_larger_than_guest) {
+        clamp = GetUpperClamp(ctx, thread_id, clamp);
+    }
     const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
     const Id src_thread_id{ctx.OpISub(ctx.U32[1], thread_id, index)};
     const Id in_range{ctx.OpSGreaterThanEqual(ctx.U1, src_thread_id, max_thread_id)};
@@ -148,7 +171,10 @@ Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
 
 Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                    Id segmentation_mask) {
-    const Id thread_id{ctx.OpLoad(ctx.U32[1], ctx.subgroup_local_invocation_id)};
+    const Id thread_id{GetThreadId(ctx)};
+    if (ctx.profile.warp_size_potentially_larger_than_guest) {
+        clamp = GetUpperClamp(ctx, thread_id, clamp);
+    }
     const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
     const Id src_thread_id{ctx.OpIAdd(ctx.U32[1], thread_id, index)};
     const Id in_range{ctx.OpSLessThanEqual(ctx.U1, src_thread_id, max_thread_id)};
@@ -159,7 +185,10 @@ Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clam
 
 Id EmitShuffleButterfly(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                         Id segmentation_mask) {
-    const Id thread_id{ctx.OpLoad(ctx.U32[1], ctx.subgroup_local_invocation_id)};
+    const Id thread_id{GetThreadId(ctx)};
+    if (ctx.profile.warp_size_potentially_larger_than_guest) {
+        clamp = GetUpperClamp(ctx, thread_id, clamp);
+    }
     const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
     const Id src_thread_id{ctx.OpBitwiseXor(ctx.U32[1], thread_id, index)};
     const Id in_range{ctx.OpSLessThanEqual(ctx.U1, src_thread_id, max_thread_id)};

src/shader_recompiler/object_pool.h

@@ -11,14 +11,16 @@
 namespace Shader {
 
 template <typename T>
-requires std::is_destructible_v<T> class ObjectPool {
+requires std::is_destructible_v<T>
+class ObjectPool {
 public:
     explicit ObjectPool(size_t chunk_size = 8192) : new_chunk_size{chunk_size} {
         node = &chunks.emplace_back(new_chunk_size);
     }
 
     template <typename... Args>
-    requires std::is_constructible_v<T, Args...>[[nodiscard]] T* Create(Args&&... args) {
+    requires std::is_constructible_v<T, Args...>
+    [[nodiscard]] T* Create(Args&&... args) {
         return std::construct_at(Memory(), std::forward<Args>(args)...);
     }
 

src/video_core/CMakeLists.txt

@@ -231,6 +231,7 @@ endif()
 
 target_include_directories(video_core PRIVATE ${FFmpeg_INCLUDE_DIR})
 target_link_libraries(video_core PRIVATE ${FFmpeg_LIBRARIES})
+target_link_options(video_core PRIVATE ${FFmpeg_LDFLAGS})
 
 add_dependencies(video_core host_shaders)
 target_include_directories(video_core PRIVATE ${HOST_SHADERS_INCLUDE})

src/video_core/command_classes/codecs/codec.cpp

@@ -5,6 +5,7 @@
 #include <fstream>
 #include <vector>
 #include "common/assert.h"
+#include "common/settings.h"
 #include "video_core/command_classes/codecs/codec.h"
 #include "video_core/command_classes/codecs/h264.h"
 #include "video_core/command_classes/codecs/vp9.h"
@@ -16,44 +17,28 @@ extern "C" {
 }
 
 namespace Tegra {
-#if defined(LIBVA_FOUND)
-// Hardware acceleration code from FFmpeg/doc/examples/hw_decode.c originally under MIT license
 namespace {
-constexpr std::array<const char*, 2> VAAPI_DRIVERS = {
-    "i915",
-    "amdgpu",
-};
+constexpr AVPixelFormat PREFERRED_GPU_FMT = AV_PIX_FMT_NV12;
+constexpr AVPixelFormat PREFERRED_CPU_FMT = AV_PIX_FMT_YUV420P;
 
-AVPixelFormat GetHwFormat(AVCodecContext*, const AVPixelFormat* pix_fmts) {
+void AVPacketDeleter(AVPacket* ptr) {
+    av_packet_free(&ptr);
+}
+
+using AVPacketPtr = std::unique_ptr<AVPacket, decltype(&AVPacketDeleter)>;
+
+AVPixelFormat GetGpuFormat(AVCodecContext* av_codec_ctx, const AVPixelFormat* pix_fmts) {
     for (const AVPixelFormat* p = pix_fmts; *p != AV_PIX_FMT_NONE; ++p) {
-        if (*p == AV_PIX_FMT_VAAPI) {
-            return AV_PIX_FMT_VAAPI;
+        if (*p == av_codec_ctx->pix_fmt) {
+            return av_codec_ctx->pix_fmt;
         }
     }
     LOG_INFO(Service_NVDRV, "Could not find compatible GPU AV format, falling back to CPU");
-    return *pix_fmts;
-}
-
-bool CreateVaapiHwdevice(AVBufferRef** av_hw_device) {
-    AVDictionary* hwdevice_options = nullptr;
-    av_dict_set(&hwdevice_options, "connection_type", "drm", 0);
-    for (const auto& driver : VAAPI_DRIVERS) {
-        av_dict_set(&hwdevice_options, "kernel_driver", driver, 0);
-        const int hwdevice_error = av_hwdevice_ctx_create(av_hw_device, AV_HWDEVICE_TYPE_VAAPI,
-                                                          nullptr, hwdevice_options, 0);
-        if (hwdevice_error >= 0) {
-            LOG_INFO(Service_NVDRV, "Using VA-API with {}", driver);
-            av_dict_free(&hwdevice_options);
-            return true;
-        }
-        LOG_DEBUG(Service_NVDRV, "VA-API av_hwdevice_ctx_create failed {}", hwdevice_error);
-    }
-    LOG_DEBUG(Service_NVDRV, "VA-API av_hwdevice_ctx_create failed for all drivers");
-    av_dict_free(&hwdevice_options);
-    return false;
+    av_buffer_unref(&av_codec_ctx->hw_device_ctx);
+    av_codec_ctx->pix_fmt = PREFERRED_CPU_FMT;
+    return PREFERRED_CPU_FMT;
 }
 } // namespace
-#endif
 
 void AVFrameDeleter(AVFrame* ptr) {
     av_frame_free(&ptr);
@@ -68,56 +53,110 @@ Codec::~Codec() {
         return;
     }
     // Free libav memory
-    avcodec_send_packet(av_codec_ctx, nullptr);
-    AVFrame* av_frame = av_frame_alloc();
-    avcodec_receive_frame(av_codec_ctx, av_frame);
-    avcodec_flush_buffers(av_codec_ctx);
-    av_frame_free(&av_frame);
-    avcodec_close(av_codec_ctx);
-    av_buffer_unref(&av_hw_device);
+    avcodec_free_context(&av_codec_ctx);
+    av_buffer_unref(&av_gpu_decoder);
 }
 
-void Codec::InitializeHwdec() {
-    // Prioritize integrated GPU to mitigate bandwidth bottlenecks
+bool Codec::CreateGpuAvDevice() {
 #if defined(LIBVA_FOUND)
-    if (CreateVaapiHwdevice(&av_hw_device)) {
-        const auto hw_device_ctx = av_buffer_ref(av_hw_device);
-        ASSERT_MSG(hw_device_ctx, "av_buffer_ref failed");
-        av_codec_ctx->hw_device_ctx = hw_device_ctx;
-        av_codec_ctx->get_format = GetHwFormat;
+    static constexpr std::array<const char*, 3> VAAPI_DRIVERS = {
+        "i915",
+        "iHD",
+        "amdgpu",
+    };
+    AVDictionary* hwdevice_options = nullptr;
+    av_dict_set(&hwdevice_options, "connection_type", "drm", 0);
+    for (const auto& driver : VAAPI_DRIVERS) {
+        av_dict_set(&hwdevice_options, "kernel_driver", driver, 0);
+        const int hwdevice_error = av_hwdevice_ctx_create(&av_gpu_decoder, AV_HWDEVICE_TYPE_VAAPI,
+                                                          nullptr, hwdevice_options, 0);
+        if (hwdevice_error >= 0) {
+            LOG_INFO(Service_NVDRV, "Using VA-API with {}", driver);
+            av_dict_free(&hwdevice_options);
+            av_codec_ctx->pix_fmt = AV_PIX_FMT_VAAPI;
+            return true;
+        }
+        LOG_DEBUG(Service_NVDRV, "VA-API av_hwdevice_ctx_create failed {}", hwdevice_error);
+    }
+    LOG_DEBUG(Service_NVDRV, "VA-API av_hwdevice_ctx_create failed for all drivers");
+    av_dict_free(&hwdevice_options);
+#endif
+    static constexpr auto HW_CONFIG_METHOD = AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX;
+    static constexpr std::array GPU_DECODER_TYPES{
+        AV_HWDEVICE_TYPE_CUDA,
+#ifdef _WIN32
+        AV_HWDEVICE_TYPE_D3D11VA,
+#else
+        AV_HWDEVICE_TYPE_VDPAU,
+#endif
+    };
+    for (const auto& type : GPU_DECODER_TYPES) {
+        const int hwdevice_res = av_hwdevice_ctx_create(&av_gpu_decoder, type, nullptr, nullptr, 0);
+        if (hwdevice_res < 0) {
+            LOG_DEBUG(Service_NVDRV, "{} av_hwdevice_ctx_create failed {}",
+                      av_hwdevice_get_type_name(type), hwdevice_res);
+            continue;
+        }
+        for (int i = 0;; i++) {
+            const AVCodecHWConfig* config = avcodec_get_hw_config(av_codec, i);
+            if (!config) {
+                LOG_DEBUG(Service_NVDRV, "{} decoder does not support device type {}.",
+                          av_codec->name, av_hwdevice_get_type_name(type));
+                break;
+            }
+            if (config->methods & HW_CONFIG_METHOD && config->device_type == type) {
+                av_codec_ctx->pix_fmt = config->pix_fmt;
+                LOG_INFO(Service_NVDRV, "Using {} GPU decoder", av_hwdevice_get_type_name(type));
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+void Codec::InitializeAvCodecContext() {
+    av_codec_ctx = avcodec_alloc_context3(av_codec);
+    av_opt_set(av_codec_ctx->priv_data, "tune", "zerolatency", 0);
+}
+
+void Codec::InitializeGpuDecoder() {
+    if (!CreateGpuAvDevice()) {
+        av_buffer_unref(&av_gpu_decoder);
         return;
     }
-#endif
-    // TODO more GPU accelerated decoders
+    auto* hw_device_ctx = av_buffer_ref(av_gpu_decoder);
+    ASSERT_MSG(hw_device_ctx, "av_buffer_ref failed");
+    av_codec_ctx->hw_device_ctx = hw_device_ctx;
+    av_codec_ctx->get_format = GetGpuFormat;
 }
 
 void Codec::Initialize() {
-    AVCodecID codec;
-    switch (current_codec) {
-    case NvdecCommon::VideoCodec::H264:
-        codec = AV_CODEC_ID_H264;
-        break;
-    case NvdecCommon::VideoCodec::Vp9:
-        codec = AV_CODEC_ID_VP9;
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unknown codec {}", current_codec);
+    const AVCodecID codec = [&] {
+        switch (current_codec) {
+        case NvdecCommon::VideoCodec::H264:
+            return AV_CODEC_ID_H264;
+        case NvdecCommon::VideoCodec::Vp9:
+            return AV_CODEC_ID_VP9;
+        default:
+            UNIMPLEMENTED_MSG("Unknown codec {}", current_codec);
+            return AV_CODEC_ID_NONE;
+        }
+    }();
+    av_codec = avcodec_find_decoder(codec);
+
+    InitializeAvCodecContext();
+    if (Settings::values.nvdec_emulation.GetValue() == Settings::NvdecEmulation::GPU) {
+        InitializeGpuDecoder();
+    }
+    if (const int res = avcodec_open2(av_codec_ctx, av_codec, nullptr); res < 0) {
+        LOG_ERROR(Service_NVDRV, "avcodec_open2() Failed with result {}", res);
+        avcodec_free_context(&av_codec_ctx);
+        av_buffer_unref(&av_gpu_decoder);
         return;
     }
-    av_codec = avcodec_find_decoder(codec);
-    av_codec_ctx = avcodec_alloc_context3(av_codec);
-    av_opt_set(av_codec_ctx->priv_data, "tune", "zerolatency", 0);
-    InitializeHwdec();
     if (!av_codec_ctx->hw_device_ctx) {
         LOG_INFO(Service_NVDRV, "Using FFmpeg software decoding");
     }
-    const auto av_error = avcodec_open2(av_codec_ctx, av_codec, nullptr);
-    if (av_error < 0) {
-        LOG_ERROR(Service_NVDRV, "avcodec_open2() Failed.");
-        avcodec_close(av_codec_ctx);
-        av_buffer_unref(&av_hw_device);
-        return;
-    }
     initialized = true;
 }
 
@@ -133,6 +172,9 @@ void Codec::Decode() {
     if (is_first_frame) {
         Initialize();
     }
+    if (!initialized) {
+        return;
+    }
     bool vp9_hidden_frame = false;
     std::vector<u8> frame_data;
     if (current_codec == NvdecCommon::VideoCodec::H264) {
@@ -141,50 +183,48 @@ void Codec::Decode() {
         frame_data = vp9_decoder->ComposeFrameHeader(state);
         vp9_hidden_frame = vp9_decoder->WasFrameHidden();
     }
-    AVPacket packet{};
-    av_init_packet(&packet);
-    packet.data = frame_data.data();
-    packet.size = static_cast<s32>(frame_data.size());
-    if (const int ret = avcodec_send_packet(av_codec_ctx, &packet); ret) {
-        LOG_DEBUG(Service_NVDRV, "avcodec_send_packet error {}", ret);
+    AVPacketPtr packet{av_packet_alloc(), AVPacketDeleter};
+    if (!packet) {
+        LOG_ERROR(Service_NVDRV, "av_packet_alloc failed");
+        return;
+    }
+    packet->data = frame_data.data();
+    packet->size = static_cast<s32>(frame_data.size());
+    if (const int res = avcodec_send_packet(av_codec_ctx, packet.get()); res != 0) {
+        LOG_DEBUG(Service_NVDRV, "avcodec_send_packet error {}", res);
         return;
     }
     // Only receive/store visible frames
     if (vp9_hidden_frame) {
         return;
     }
-    AVFrame* hw_frame = av_frame_alloc();
-    AVFrame* sw_frame = hw_frame;
-    ASSERT_MSG(hw_frame, "av_frame_alloc hw_frame failed");
-    if (const int ret = avcodec_receive_frame(av_codec_ctx, hw_frame); ret) {
+    AVFramePtr initial_frame{av_frame_alloc(), AVFrameDeleter};
+    AVFramePtr final_frame{nullptr, AVFrameDeleter};
+    ASSERT_MSG(initial_frame, "av_frame_alloc initial_frame failed");
+    if (const int ret = avcodec_receive_frame(av_codec_ctx, initial_frame.get()); ret) {
         LOG_DEBUG(Service_NVDRV, "avcodec_receive_frame error {}", ret);
-        av_frame_free(&hw_frame);
         return;
     }
-    if (!hw_frame->width || !hw_frame->height) {
+    if (initial_frame->width == 0 || initial_frame->height == 0) {
         LOG_WARNING(Service_NVDRV, "Zero width or height in frame");
-        av_frame_free(&hw_frame);
         return;
     }
-#if defined(LIBVA_FOUND)
-    // Hardware acceleration code from FFmpeg/doc/examples/hw_decode.c under MIT license
-    if (hw_frame->format == AV_PIX_FMT_VAAPI) {
-        sw_frame = av_frame_alloc();
-        ASSERT_MSG(sw_frame, "av_frame_alloc sw_frame failed");
+    if (av_codec_ctx->hw_device_ctx) {
+        final_frame = AVFramePtr{av_frame_alloc(), AVFrameDeleter};
+        ASSERT_MSG(final_frame, "av_frame_alloc final_frame failed");
         // Can't use AV_PIX_FMT_YUV420P and share code with software decoding in vic.cpp
         // because Intel drivers crash unless using AV_PIX_FMT_NV12
-        sw_frame->format = AV_PIX_FMT_NV12;
-        const int transfer_data_ret = av_hwframe_transfer_data(sw_frame, hw_frame, 0);
-        ASSERT_MSG(!transfer_data_ret, "av_hwframe_transfer_data error {}", transfer_data_ret);
-        av_frame_free(&hw_frame);
+        final_frame->format = PREFERRED_GPU_FMT;
+        const int ret = av_hwframe_transfer_data(final_frame.get(), initial_frame.get(), 0);
+        ASSERT_MSG(!ret, "av_hwframe_transfer_data error {}", ret);
+    } else {
+        final_frame = std::move(initial_frame);
     }
-#endif
-    if (sw_frame->format != AV_PIX_FMT_YUV420P && sw_frame->format != AV_PIX_FMT_NV12) {
-        UNIMPLEMENTED_MSG("Unexpected video format from host graphics: {}", sw_frame->format);
-        av_frame_free(&sw_frame);
+    if (final_frame->format != PREFERRED_CPU_FMT && final_frame->format != PREFERRED_GPU_FMT) {
+        UNIMPLEMENTED_MSG("Unexpected video format: {}", final_frame->format);
         return;
     }
-    av_frames.push(AVFramePtr{sw_frame, AVFrameDeleter});
+    av_frames.push(std::move(final_frame));
     if (av_frames.size() > 10) {
         LOG_TRACE(Service_NVDRV, "av_frames.push overflow dropped frame");
         av_frames.pop();

src/video_core/command_classes/codecs/codec.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <memory>
+#include <string_view>
 #include <queue>
 #include "common/common_types.h"
 #include "video_core/command_classes/nvdec_common.h"
@@ -50,18 +51,23 @@ public:
 
     /// Returns the value of current_codec
     [[nodiscard]] NvdecCommon::VideoCodec GetCurrentCodec() const;
+
     /// Return name of the current codec
     [[nodiscard]] std::string_view GetCurrentCodecName() const;
 
 private:
-    void InitializeHwdec();
+    void InitializeAvCodecContext();
+
+    void InitializeGpuDecoder();
+
+    bool CreateGpuAvDevice();
 
     bool initialized{};
     NvdecCommon::VideoCodec current_codec{NvdecCommon::VideoCodec::None};
 
     AVCodec* av_codec{nullptr};
-    AVBufferRef* av_hw_device{nullptr};
     AVCodecContext* av_codec_ctx{nullptr};
+    AVBufferRef* av_gpu_decoder{nullptr};
 
     GPU& gpu;
     const NvdecCommon::NvdecRegisters& state;

src/video_core/command_classes/codecs/h264.cpp

@@ -95,7 +95,8 @@ const std::vector<u8>& H264::ComposeFrameHeader(const NvdecCommon::NvdecRegister
     const s32 pic_height = context.h264_parameter_set.frame_height_in_map_units /
                            (context.h264_parameter_set.frame_mbs_only_flag ? 1 : 2);
 
-    writer.WriteUe(16);
+    // TODO (ameerj): Where do we get this number, it seems to be particular for each stream
+    writer.WriteUe(6); // Max number of reference frames
     writer.WriteBit(false);
     writer.WriteUe(context.h264_parameter_set.pic_width_in_mbs - 1);
     writer.WriteUe(pic_height - 1);