Merge branch 'master' of https://github.com/yuzu-emu/yuzu

.ci/scripts/common/post-upload.sh

@@ -9,5 +9,11 @@ cp "${REV_NAME}-source.tar.xz" "$DIR_NAME"
 
 tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$DIR_NAME"
 
+mv "$DIR_NAME" $RELEASE_NAME
+mv "${REV_NAME}-source.tar.xz" $RELEASE_NAME
+
+7z a "$REV_NAME.7z" $RELEASE_NAME
+
 # move the compiled archive into the artifacts directory to be uploaded by travis releases
 mv "$ARCHIVE_NAME" "${ARTIFACTS_DIR}/"
+mv "$REV_NAME.7z" "${ARTIFACTS_DIR}/"

.ci/scripts/linux/docker.sh

@@ -30,10 +30,10 @@ make install DESTDIR=AppDir
 rm -vf AppDir/usr/bin/yuzu-cmd AppDir/usr/bin/yuzu-tester
 
 # Download tools needed to build an AppImage
-wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/linuxdeploy-x86_64.AppImage
-wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/linuxdeploy-plugin-qt-x86_64.AppImage
-wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/AppRun-patched-x86_64
-wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/exec-x86_64.so
+wget -nc https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
+wget -nc https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-x86_64.AppImage
+wget -nc https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/AppRun-patched-x86_64
+wget -nc https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/exec-x86_64.so
 # Set executable bit
 chmod 755 \
     AppRun-patched-x86_64 \

.ci/scripts/linux/upload.sh

@@ -21,7 +21,7 @@ cp build/bin/yuzu "$DIR_NAME"
 # Build an AppImage
 cd build
 
-wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/appimagetool-x86_64.AppImage
+wget -nc https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
 chmod 755 appimagetool-x86_64.AppImage
 
 if [ "${RELEASE_NAME}" = "mainline" ]; then

.ci/scripts/windows/docker.sh

@@ -18,20 +18,19 @@ cd ..
 mkdir package
 
 if [ -d "/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/" ]; then
-  QT_PLUGINS_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins'
+  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
 else
   #fallback to qt
-  QT_PLUGINS_PATH='/usr/x86_64-w64-mingw32/lib/qt/plugins'
+  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt/plugins/platforms/'
 fi
 
 find build/ -name "yuzu*.exe" -exec cp {} 'package' \;
 
 # copy Qt plugins
 mkdir package/platforms
-cp -v "${QT_PLUGINS_PATH}/platforms/qwindows.dll" package/platforms/
-cp -rv "${QT_PLUGINS_PATH}/mediaservice/" package/
-cp -rv "${QT_PLUGINS_PATH}/imageformats/" package/
-cp -rv "${QT_PLUGINS_PATH}/styles/" package/
+cp "${QT_PLATFORM_DLL_PATH}/qwindows.dll" package/platforms/
+cp -rv "${QT_PLATFORM_DLL_PATH}/../mediaservice/" package/
+cp -rv "${QT_PLATFORM_DLL_PATH}/../imageformats/" package/
 rm -f package/mediaservice/*d.dll
 
 for i in package/*.exe; do
@@ -48,6 +47,3 @@ python3 .ci/scripts/windows/scan_dll.py package/imageformats/*.dll "package/"
 EXTERNALS_PATH="$(pwd)/build/externals"
 FFMPEG_DLL_PATH="$(find ${EXTERNALS_PATH} -maxdepth 1 -type d | grep ffmpeg)/bin"
 find ${FFMPEG_DLL_PATH} -type f -regex ".*\.dll" -exec cp -v {} package/ ';'
-
-# copy libraries from yuzu.exe path
-find "$(pwd)/build/bin/" -type f -regex ".*\.dll" -exec cp -v {} package/ ';'

.ci/scripts/windows/upload.sh

@@ -3,8 +3,8 @@
 . .ci/scripts/common/pre-upload.sh
 
 REV_NAME="yuzu-windows-mingw-${GITDATE}-${GITREV}"
-ARCHIVE_NAME="${REV_NAME}.tar.xz"
-COMPRESSION_FLAGS="-cJvf"
+ARCHIVE_NAME="${REV_NAME}.tar.gz"
+COMPRESSION_FLAGS="-czvf"
 
 if [ "${RELEASE_NAME}" = "mainline" ]; then
     DIR_NAME="${REV_NAME}"

.ci/templates/build-msvc.yml

@@ -8,7 +8,7 @@ steps:
   displayName: 'Install vulkan-sdk'
 - script: python -m pip install --upgrade pip conan
   displayName: 'Install conan'
-- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release .. && cd ..
+- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cmake --install . --config Release && cd ..
   displayName: 'Configure CMake'
 - task: MSBuild@1
   displayName: 'Build'

.ci/yuzu-mainline-step2.yml

@@ -19,7 +19,6 @@ stages:
   displayName: 'build'
   jobs:
   - job: build
-    timeoutInMinutes: 120
     displayName: 'standard'
     pool:
       vmImage: ubuntu-latest
@@ -44,7 +43,6 @@ stages:
   displayName: 'build-windows'
   jobs:
   - job: build
-    timeoutInMinutes: 120
     displayName: 'msvc'
     pool:
       vmImage: windows-2019
@@ -67,4 +65,4 @@ stages:
   - job: github
     displayName: 'github'
     steps:
-    - template: ./templates/release-github.yml
+    - template: ./templates/release-github.yml

.gitmodules

@@ -18,7 +18,7 @@
 	url = https://github.com/libusb/libusb.git
 [submodule "discord-rpc"]
     path = externals/discord-rpc
-    url = https://github.com/discord/discord-rpc.git
+    url = https://github.com/discordapp/discord-rpc.git
 [submodule "Vulkan-Headers"]
     path = externals/Vulkan-Headers
     url = https://github.com/KhronosGroup/Vulkan-Headers.git
@@ -43,6 +43,3 @@
 [submodule "SDL"]
 	path = externals/SDL
 	url = https://github.com/libsdl-org/SDL.git
-[submodule "externals/cpp-httplib"]
-	path = externals/cpp-httplib
-	url = https://github.com/yhirose/cpp-httplib.git

CMakeLists.txt

@@ -12,19 +12,15 @@ project(yuzu)
 # OFF by default, but if ENABLE_SDL2 and MSVC are true then ON
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
-# On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
-CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)
 
 option(ENABLE_QT "Enable the Qt frontend" ON)
 option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSVC}" "ENABLE_QT" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
 
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
 option(YUZU_USE_BUNDLED_BOOST "Download bundled Boost" OFF)
 
-option(YUZU_USE_BUNDLED_LIBUSB "Compile bundled libusb" OFF)
-
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" ON "WIN32" OFF)
 
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
@@ -47,10 +43,9 @@ if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
 endif()
 
 if(EXISTS ${PROJECT_SOURCE_DIR}/hooks/pre-commit AND NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
-    if (EXISTS ${PROJECT_SOURCE_DIR}/.git/)
-        message(STATUS "Copying pre-commit hook")
-        file(COPY hooks/pre-commit DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
-    endif()
+    message(STATUS "Copying pre-commit hook")
+    file(COPY hooks/pre-commit
+        DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
 endif()
 
 # Sanity check : Check that all submodules are present
@@ -173,11 +168,11 @@ macro(yuzu_find_packages)
     set(REQUIRED_LIBS
     #    Cmake Pkg Prefix  Version     Conan Pkg
         "Catch2            2.13        catch2/2.13.0"
-        "fmt               8.0         fmt/8.0.0"
+        "fmt               7.1         fmt/7.1.2"
         "lz4               1.8         lz4/1.9.2"
         "nlohmann_json     3.8         nlohmann_json/3.8.0"
         "ZLIB              1.2         zlib/1.2.11"
-        "zstd              1.5         zstd/1.5.0"
+        "zstd              1.4         zstd/1.4.8"
     # can't use opus until AVX check is fixed: https://github.com/yuzu-emu/yuzu/pull/4068
         #"opus              1.3         opus/1.3.1"
     )
@@ -207,7 +202,7 @@ macro(yuzu_find_packages)
 endmacro()
 
 if (NOT YUZU_USE_BUNDLED_BOOST)
-    find_package(Boost 1.73.0 CONFIG COMPONENTS context headers QUIET)
+    find_package(Boost 1.73.0 COMPONENTS context headers QUIET)
 endif()
 if (Boost_FOUND)
     set(Boost_LIBRARIES Boost::boost)
@@ -229,7 +224,7 @@ elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" OR YUZU_USE_BUNDLED_BOOST)
     download_bundled_external("boost/" ${Boost_EXT_NAME} "")
     set(Boost_USE_DEBUG_RUNTIME FALSE)
     set(Boost_USE_STATIC_LIBS ON)
-    find_package(Boost 1.75.0 CONFIG REQUIRED COMPONENTS context headers PATHS ${Boost_PATH} NO_DEFAULT_PATH)
+    find_package(Boost 1.75.0 REQUIRED COMPONENTS context headers PATHS ${Boost_PATH} NO_DEFAULT_PATH)
     # Manually set the include dirs since the find_package sets it incorrectly
     set(Boost_INCLUDE_DIRS ${Boost_PATH}/include CACHE PATH "Path to Boost headers" FORCE)
     include_directories(SYSTEM "${Boost_INCLUDE_DIRS}")
@@ -243,7 +238,6 @@ yuzu_find_packages()
 
 # Qt5 requires that we find components, so it doesn't fit our pretty little find package function
 if(ENABLE_QT)
-    set(QT_VERSION 5.12)
     # We want to load the generated conan qt config so that we get the QT_ROOT var so that we can use the official
     # Qt5Config inside the root folder instead of the conan generated one.
     if(EXISTS ${CMAKE_BINARY_DIR}/qtConfig.cmake)
@@ -251,117 +245,22 @@ if(ENABLE_QT)
         list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
         list(APPEND CMAKE_PREFIX_PATH "${CONAN_QT_ROOT_RELEASE}")
     endif()
-
-    # Check for system Qt on Linux, fallback to bundled Qt
-    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-        if (NOT YUZU_USE_BUNDLED_QT)
-            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets)
-        endif()
-        if (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT)
-            # Check for dependencies, then enable bundled Qt download
-
-            # Check that the system GLIBCXX version is compatible
-            find_program(OBJDUMP objdump)
-            if ("${OBJDUMP}" STREQUAL "OBJDUMP-NOTFOUND")
-                message(FATAL_ERROR "Required program `objdump` not found.")
-            endif()
-            find_library(LIBSTDCXX libstdc++.so.6)
-            execute_process(
-                COMMAND
-                    ${OBJDUMP} -T ${LIBSTDCXX}
-                COMMAND
-                    grep GLIBCXX_3.4.28
-                COMMAND
-                    sed "s/[0-9a-f]*.*  //"
-                COMMAND
-                    sed "s/ .*//"
-                COMMAND
-                    sort -u
-                OUTPUT_VARIABLE
-                    GLIBCXX_MET
-            )
-            if (NOT GLIBCXX_MET)
-                message(FATAL_ERROR "Qt too old or not found, and bundled Qt package is not \
-                    compatible with this system. Either install Qt ${QT_VERSION}, or provide the path \
-                    to Qt by setting the variable Qt5_ROOT.")
-            endif()
-
-            # Check for headers
-            Include(FindPkgConfig REQUIRED)
-            pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
-            if (NOT QT_DEP_GLU_FOUND)
-                message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
-                    Perhaps `libglu1-mesa-dev` needs to be installed?")
-            endif()
-            pkg_check_modules(QT_DEP_MESA QUIET dri>=20.0.8)
-            if (NOT QT_DEP_MESA_FOUND)
-                message(FATAL_ERROR "Qt bundled pacakge dependency `dri` not found. \
-                    Perhaps `mesa-common-dev` needs to be installed?")
-            endif()
-
-            # Check for X libraries
-            set(BUNDLED_QT_REQUIREMENTS
-                libxcb-icccm.so.4
-                libxcb-image.so.0
-                libxcb-keysyms.so.1
-                libxcb-randr.so.0
-                libxcb-render-util.so.0
-                libxcb-render.so.0
-                libxcb-shape.so.0
-                libxcb-shm.so.0
-                libxcb-sync.so.1
-                libxcb-xfixes.so.0
-                libxcb-xinerama.so.0
-                libxcb-xkb.so.1
-                libxcb.so.1
-                libxkbcommon-x11.so.0
-                libxkbcommon.so.0
-            )
-            set(UNRESOLVED_QT_DEPS "")
-            foreach (REQUIREMENT ${BUNDLED_QT_REQUIREMENTS})
-                find_library(BUNDLED_QT_${REQUIREMENT} ${REQUIREMENT})
-                if ("${BUNDLED_QT_${REQUIREMENT}}" STREQUAL "BUNDLED_QT_${REQUIREMENT}-NOTFOUND")
-                    set(UNRESOLVED_QT_DEPS ${UNRESOLVED_QT_DEPS} ${REQUIREMENT})
-                endif()
-                unset(BUNDLED_QT_${REQUIREMENT})
-            endforeach()
-            unset(BUNDLED_QT_REQUIREMENTS)
-
-            if (NOT "${UNRESOLVED_QT_DEPS}" STREQUAL "")
-                message(FATAL_ERROR "Bundled Qt package missing required dependencies: ${UNRESOLVED_QT_DEPS}")
-            endif()
-
-            set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
-        endif()
-        if (YUZU_USE_BUNDLED_QT)
-            # Binary package currently does not support Qt webengine, so make sure it's disabled
-            set(YUZU_USE_QT_WEB_ENGINE OFF CACHE BOOL "Use Qt Webengine" FORCE)
-        endif()
-    endif()
-
-    set(YUZU_QT_NO_CMAKE_SYSTEM_PATH)
-
     # Workaround for an issue where conan tries to build Qt from scratch instead of download prebuilt binaries
     set(QT_PREFIX_HINT)
-
     if(YUZU_USE_BUNDLED_QT)
         if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
-            set(QT_BUILD qt-5.12.8-msvc2017_64)
-        elseif ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND NOT MINGW AND ARCHITECTURE_x86_64)
-            set(QT_BUILD qt5_5_15_2)
+            set(QT_VER qt-5.12.8-msvc2017_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
         endif()
 
-        if (DEFINED QT_BUILD)
-            download_bundled_external("qt/" ${QT_BUILD} QT_PREFIX)
+        if (DEFINED QT_VER)
+            download_bundled_external("qt/" ${QT_VER} QT_PREFIX)
         endif()
 
         set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
-
-        set(YUZU_QT_NO_CMAKE_SYSTEM_PATH "NO_CMAKE_SYSTEM_PATH")
     endif()
-    find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
+    find_package(Qt5 5.9 COMPONENTS Widgets ${QT_PREFIX_HINT})
     if (YUZU_USE_QT_WEB_ENGINE)
         find_package(Qt5 COMPONENTS WebEngineCore WebEngineWidgets)
     endif()
@@ -370,13 +269,12 @@ if(ENABLE_QT)
         find_package(Qt5 REQUIRED COMPONENTS LinguistTools ${QT_PREFIX_HINT})
     endif()
 endif()
-
 # find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the yuzu_find_package
 if (ENABLE_SDL2)
     if (YUZU_USE_BUNDLED_SDL2)
         # Detect toolchain and platform
         if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.0.15-prerelease")
+            set(SDL2_VER "SDL2-2.0.14")
         else()
             message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
         endif()
@@ -393,20 +291,22 @@ if (ENABLE_SDL2)
         add_library(SDL2 INTERFACE)
         target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARY}")
         target_include_directories(SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
-    elseif (YUZU_USE_EXTERNAL_SDL2)
-        message(STATUS "Using SDL2 from externals.")
     else()
-        find_package(SDL2 2.0.15 REQUIRED)
+        find_package(SDL2 2.0.14 QUIET)
 
-        # Some installations don't set SDL2_LIBRARIES
-        if("${SDL2_LIBRARIES}" STREQUAL "")
-            message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
-            set(SDL2_LIBRARIES "SDL2::SDL2")
+        if (SDL2_FOUND)
+            # Some installations don't set SDL2_LIBRARIES
+            if("${SDL2_LIBRARIES}" STREQUAL "")
+                message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
+                set(SDL2_LIBRARIES "SDL2::SDL2")
+            endif()
+
+            include_directories(SYSTEM ${SDL2_INCLUDE_DIRS})
+            add_library(SDL2 INTERFACE)
+            target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
+        else()
+            message(STATUS "SDL2 2.0.14 or newer not found, falling back to externals.")
         endif()
-
-        include_directories(SYSTEM ${SDL2_INCLUDE_DIRS})
-        add_library(SDL2 INTERFACE)
-        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
     endif()
 endif()
 
@@ -473,7 +373,7 @@ if (CONAN_REQUIRED_LIBS)
     if(ENABLE_QT)
         list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
         list(APPEND CMAKE_PREFIX_PATH "${CONAN_QT_ROOT_RELEASE}")
-        find_package(Qt5 5.12 REQUIRED COMPONENTS Widgets)
+        find_package(Qt5 5.9 REQUIRED COMPONENTS Widgets)
         if (YUZU_USE_QT_WEB_ENGINE)
             find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets)
         endif()
@@ -494,22 +394,14 @@ elseif (TARGET Boost::boost)
 endif()
 
 # Ensure libusb is properly configured (based on dolphin libusb include)
-if(NOT APPLE AND NOT YUZU_USE_BUNDLED_LIBUSB)
+if(NOT APPLE)
     include(FindPkgConfig)
-    if (PKG_CONFIG_FOUND)
-        pkg_check_modules(LIBUSB QUIET libusb-1.0>=1.0.24)
-    else()
-        find_package(LibUSB)
-    endif()
-
-    if (LIBUSB_FOUND)
-        add_library(usb INTERFACE)
-        target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")
-        target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARIES}")
-    else()
-        message(WARNING "libusb not found, falling back to externals")
-        set(YUZU_USE_BUNDLED_LIBUSB ON)
-    endif()
+    find_package(LibUSB)
+endif()
+if (NOT LIBUSB_FOUND)
+    add_subdirectory(externals/libusb)
+    set(LIBUSB_INCLUDE_DIR "")
+    set(LIBUSB_LIBRARIES usb)
 endif()
 
 # List of all FFmpeg components required
@@ -545,15 +437,7 @@ if (YUZU_USE_BUNDLED_FFMPEG)
 
         # FFmpeg has source that requires one of nasm or yasm to assemble it.
         # REQUIRED throws an error if not found here during configuration rather than during compilation.
-        find_program(ASSEMBLER NAMES nasm yasm)
-        if ("${ASSEMBLER}" STREQUAL "ASSEMBLER-NOTFOUND")
-            message(FATAL_ERROR "One of either `nasm` or `yasm` not found but is required.")
-        endif()
-
-        find_program(AUTOCONF autoconf)
-        if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
-            message(FATAL_ERROR "Required program `autoconf` not found.")
-        endif()
+        find_program(ASSEMBLER NAMES nasm yasm REQUIRED)
 
         set(FFmpeg_PREFIX ${PROJECT_SOURCE_DIR}/externals/ffmpeg)
         set(FFmpeg_BUILD_DIR ${PROJECT_BINARY_DIR}/externals/ffmpeg)

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -1,111 +1,52 @@
 function(copy_yuzu_Qt5_deps target_dir)
     include(WindowsCopyFiles)
-    if (MSVC)
-        set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
-        set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
-    else()
-        set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/")
-        set(Qt5_DLL_DIR "${Qt5_DIR}/../../../lib/")
-    endif()
+    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
+    set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
     set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
-    set(Qt5_PLATFORMTHEMES_DIR "${Qt5_DIR}/../../../plugins/platformthemes/")
-    set(Qt5_PLATFORMINPUTCONTEXTS_DIR "${Qt5_DIR}/../../../plugins/platforminputcontexts/")
-    set(Qt5_XCBGLINTEGRATIONS_DIR "${Qt5_DIR}/../../../plugins/xcbglintegrations/")
     set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
     set(Qt5_IMAGEFORMATS_DIR "${Qt5_DIR}/../../../plugins/imageformats/")
     set(Qt5_RESOURCES_DIR "${Qt5_DIR}/../../../resources/")
     set(PLATFORMS ${DLL_DEST}plugins/platforms/)
     set(STYLES ${DLL_DEST}plugins/styles/)
     set(IMAGEFORMATS ${DLL_DEST}plugins/imageformats/)
-    if (MSVC)
-        windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
-            icudt*.dll
-            icuin*.dll
-            icuuc*.dll
-            Qt5Core$<$<CONFIG:Debug>:d>.*
-            Qt5Gui$<$<CONFIG:Debug>:d>.*
-            Qt5Widgets$<$<CONFIG:Debug>:d>.*
+    windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
+        icudt*.dll
+        icuin*.dll
+        icuuc*.dll
+        Qt5Core$<$<CONFIG:Debug>:d>.*
+        Qt5Gui$<$<CONFIG:Debug>:d>.*
+        Qt5Widgets$<$<CONFIG:Debug>:d>.*
+    )
+
+    if (YUZU_USE_QT_WEB_ENGINE)
+        windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST} 
+            Qt5Network$<$<CONFIG:Debug>:d>.*
+            Qt5Positioning$<$<CONFIG:Debug>:d>.*
+            Qt5PrintSupport$<$<CONFIG:Debug>:d>.*
+            Qt5Qml$<$<CONFIG:Debug>:d>.*
+            Qt5Quick$<$<CONFIG:Debug>:d>.*
+            Qt5QuickWidgets$<$<CONFIG:Debug>:d>.*
+            Qt5WebChannel$<$<CONFIG:Debug>:d>.*
+            Qt5WebEngine$<$<CONFIG:Debug>:d>.*
+            Qt5WebEngineCore$<$<CONFIG:Debug>:d>.*
+            Qt5WebEngineWidgets$<$<CONFIG:Debug>:d>.*
+            QtWebEngineProcess$<$<CONFIG:Debug>:d>.*
         )
 
-        if (YUZU_USE_QT_WEB_ENGINE)
-            windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
-                Qt5Network$<$<CONFIG:Debug>:d>.*
-                Qt5Positioning$<$<CONFIG:Debug>:d>.*
-                Qt5PrintSupport$<$<CONFIG:Debug>:d>.*
-                Qt5Qml$<$<CONFIG:Debug>:d>.*
-                Qt5Quick$<$<CONFIG:Debug>:d>.*
-                Qt5QuickWidgets$<$<CONFIG:Debug>:d>.*
-                Qt5WebChannel$<$<CONFIG:Debug>:d>.*
-                Qt5WebEngine$<$<CONFIG:Debug>:d>.*
-                Qt5WebEngineCore$<$<CONFIG:Debug>:d>.*
-                Qt5WebEngineWidgets$<$<CONFIG:Debug>:d>.*
-                QtWebEngineProcess$<$<CONFIG:Debug>:d>.*
-            )
-
-            windows_copy_files(${target_dir} ${Qt5_RESOURCES_DIR} ${DLL_DEST}
-                qtwebengine_resources.pak
-                qtwebengine_devtools_resources.pak
-                qtwebengine_resources_100p.pak
-                qtwebengine_resources_200p.pak
-                icudtl.dat
-            )
-        endif ()
-        windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
-        windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
-        windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS}
-            qjpeg$<$<CONFIG:Debug>:d>.*
-            qgif$<$<CONFIG:Debug>:d>.*
-            )
-    else()
-        set(Qt5_DLLS
-            "${Qt5_DLL_DIR}libQt5Core.so.5"
-            "${Qt5_DLL_DIR}libQt5DBus.so.5"
-            "${Qt5_DLL_DIR}libQt5Gui.so.5"
-            "${Qt5_DLL_DIR}libQt5Widgets.so.5"
-            "${Qt5_DLL_DIR}libQt5XcbQpa.so.5"
-            "${Qt5_DLL_DIR}libicudata.so.60"
-            "${Qt5_DLL_DIR}libicui18n.so.60"
-            "${Qt5_DLL_DIR}libicuuc.so.60"
-            )
-        set(Qt5_IMAGEFORMAT_DLLS
-            "${Qt5_IMAGEFORMATS_DIR}libqjpeg.so"
-            "${Qt5_IMAGEFORMATS_DIR}libqgif.so"
-            "${Qt5_IMAGEFORMATS_DIR}libqico.so"
-            )
-        set(Qt5_PLATFORMTHEME_DLLS
-            "${Qt5_PLATFORMTHEMES_DIR}libqgtk3.so"
-            "${Qt5_PLATFORMTHEMES_DIR}libqxdgdesktopportal.so"
-            )
-        set(Qt5_PLATFORM_DLLS
-            "${Qt5_PLATFORMS_DIR}libqxcb.so"
-            )
-        set(Qt5_PLATFORMINPUTCONTEXT_DLLS
-            "${Qt5_PLATFORMINPUTCONTEXTS_DIR}libcomposeplatforminputcontextplugin.so"
-            "${Qt5_PLATFORMINPUTCONTEXTS_DIR}libibusplatforminputcontextplugin.so"
-            )
-        set(Qt5_XCBGLINTEGRATION_DLLS
-            "${Qt5_XCBGLINTEGRATIONS_DIR}libqxcb-glx-integration.so"
-            )
-        foreach(LIB ${Qt5_DLLS})
-            file(COPY ${LIB} DESTINATION "${DLL_DEST}/lib" FOLLOW_SYMLINK_CHAIN)
-        endforeach()
-        foreach(LIB ${Qt5_IMAGEFORMAT_DLLS})
-            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/imageformats/" FOLLOW_SYMLINK_CHAIN)
-        endforeach()
-        foreach(LIB ${Qt5_PLATFORMTHEME_DLLS})
-            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/platformthemes/" FOLLOW_SYMLINK_CHAIN)
-        endforeach()
-        foreach(LIB ${Qt5_PLATFORM_DLLS})
-            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/platforms/" FOLLOW_SYMLINK_CHAIN)
-        endforeach()
-        foreach(LIB ${Qt5_PLATFORMINPUTCONTEXT_DLLS})
-            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/platforminputcontexts/" FOLLOW_SYMLINK_CHAIN)
-        endforeach()
-        foreach(LIB ${Qt5_XCBGLINTEGRATION_DLLS})
-            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/xcbglintegrations/" FOLLOW_SYMLINK_CHAIN)
-        endforeach()
-
-    endif()
+        windows_copy_files(${target_dir} ${Qt5_RESOURCES_DIR} ${DLL_DEST}
+            qtwebengine_resources.pak
+            qtwebengine_devtools_resources.pak
+            qtwebengine_resources_100p.pak
+            qtwebengine_resources_200p.pak
+            icudtl.dat
+        )
+    endif ()
+    windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
+    windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
+    windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS}
+        qjpeg$<$<CONFIG:Debug>:d>.*
+        qgif$<$<CONFIG:Debug>:d>.*
+        )
     # Create an empty qt.conf file. Qt will detect that this file exists, and use the folder that its in as the root folder.
     # This way it'll look for plugins in the root/plugins/ folder
     add_custom_command(TARGET yuzu POST_BUILD

CMakeModules/GenerateSCMRev.cmake

@@ -48,6 +48,69 @@ if (BUILD_REPOSITORY)
   endif()
 endif()
 
-# The variable SRC_DIR must be passed into the script
-# (since it uses the current build directory for all values of CMAKE_*_DIR)
+# The variable SRC_DIR must be passed into the script (since it uses the current build directory for all values of CMAKE_*_DIR)
+set(VIDEO_CORE "${SRC_DIR}/src/video_core")
+set(HASH_FILES
+    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+    "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_immediate.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_integer.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_integer_immediate.cpp"
+    "${VIDEO_CORE}/shader/decode/bfe.cpp"
+    "${VIDEO_CORE}/shader/decode/bfi.cpp"
+    "${VIDEO_CORE}/shader/decode/conversion.cpp"
+    "${VIDEO_CORE}/shader/decode/ffma.cpp"
+    "${VIDEO_CORE}/shader/decode/float_set.cpp"
+    "${VIDEO_CORE}/shader/decode/float_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/half_set.cpp"
+    "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/hfma2.cpp"
+    "${VIDEO_CORE}/shader/decode/image.cpp"
+    "${VIDEO_CORE}/shader/decode/integer_set.cpp"
+    "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/memory.cpp"
+    "${VIDEO_CORE}/shader/decode/texture.cpp"
+    "${VIDEO_CORE}/shader/decode/other.cpp"
+    "${VIDEO_CORE}/shader/decode/predicate_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/predicate_set_register.cpp"
+    "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/shift.cpp"
+    "${VIDEO_CORE}/shader/decode/video.cpp"
+    "${VIDEO_CORE}/shader/decode/warp.cpp"
+    "${VIDEO_CORE}/shader/decode/xmad.cpp"
+    "${VIDEO_CORE}/shader/ast.cpp"
+    "${VIDEO_CORE}/shader/ast.h"
+    "${VIDEO_CORE}/shader/compiler_settings.cpp"
+    "${VIDEO_CORE}/shader/compiler_settings.h"
+    "${VIDEO_CORE}/shader/control_flow.cpp"
+    "${VIDEO_CORE}/shader/control_flow.h"
+    "${VIDEO_CORE}/shader/decode.cpp"
+    "${VIDEO_CORE}/shader/expr.cpp"
+    "${VIDEO_CORE}/shader/expr.h"
+    "${VIDEO_CORE}/shader/node.h"
+    "${VIDEO_CORE}/shader/node_helper.cpp"
+    "${VIDEO_CORE}/shader/node_helper.h"
+    "${VIDEO_CORE}/shader/registry.cpp"
+    "${VIDEO_CORE}/shader/registry.h"
+    "${VIDEO_CORE}/shader/shader_ir.cpp"
+    "${VIDEO_CORE}/shader/shader_ir.h"
+    "${VIDEO_CORE}/shader/track.cpp"
+    "${VIDEO_CORE}/shader/transform_feedback.cpp"
+    "${VIDEO_CORE}/shader/transform_feedback.h"
+)
+set(COMBINED "")
+foreach (F IN LISTS HASH_FILES)
+    file(READ ${F} TMP)
+    set(COMBINED "${COMBINED}${TMP}")
+endforeach()
+string(MD5 SHADER_CACHE_VERSION "${COMBINED}")
 configure_file("${SRC_DIR}/src/common/scm_rev.cpp.in" "scm_rev.cpp" @ONLY)

README.md

@@ -1,82 +1,43 @@
-<h1 align="center">
-  <br>
-  <a href="https://yuzu-emu.org/"><img src="https://raw.githubusercontent.com/yuzu-emu/yuzu-assets/master/icons/icon.png" alt="yuzu" width="200"></a>
-  <br>
-  <b>yuzu</b>
-  <br>
-</h1>
+yuzu emulator
+=============
+[![Travis CI Build Status](https://travis-ci.com/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.com/yuzu-emu/yuzu)
+[![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
+[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.com/invite/u77vRWY)
 
-<h4 align="center"><b>yuzu</b> is the world's most popular, open-source, Nintendo Switch emulator — started by the creators of <a href="https://citra-emu.org" target="_blank">Citra</a>.
-<br>
-It is written in C++ with portability in mind, and we actively maintain builds for Windows and Linux.
-</h4>
+yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).
 
-<p align="center">
-    <a href="https://dev.azure.com/yuzu-emu/yuzu/">
-        <img src="https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master"
-            alt="Azure Mainline CI Build Status">
-    </a>
-    <a href="https://discord.com/invite/u77vRWY">
-        <img src="https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white"
-            alt="Discord">
-    </a>
-</p>
+It is written in C++ with portability in mind, with builds actively maintained for Windows and Linux. The emulator is capable of running several commercial games.
 
-<p align="center">
-  <a href="#compatibility">Compatibility</a> |
-  <a href="#development">Development</a> |
-  <a href="#building">Building</a> |
-  <a href="#download">Download</a> |
-  <a href="#support">Support</a> |
-  <a href="#license">License</a>
-</p>
+yuzu only emulates a subset of Switch hardware and therefore most commercial games **do not** run at full speed or are not fully functional.
 
-## Compatibility
+Do you want to check which games are compatible and which ones are not? Please visit our [Compatibility page](https://yuzu-emu.org/game/)!
 
-The emulator is capable of running most commercial games at full speed, provided you meet the [necessary hardware requirements](https://yuzu-emu.org/help/quickstart/#hardware-requirements).
+yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 
-For a full list of games yuzu support, please visit our [Compatibility page](https://yuzu-emu.org/game/)
+Check out our [website](https://yuzu-emu.org/)!
 
-Check out our [website](https://yuzu-emu.org/) for the latest news on exciting features, monthly progress reports, and more!
+For development discussion, please join us on [Discord](https://discord.com/invite/u77vRWY).
 
-## Development
+### Development
 
-Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted. For development discussion, please join us on [Discord](https://discord.com/invite/u77vRWY).
+Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted.
 
-If you want to contribute, please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information).
-You can also contact any of the developers on Discord in order to know about the current state of the emulator.
+If you want to contribute please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should also contact any of the developers on Discord in order to know about the current state of the emulator.
 
-If you want to contribute to the user interface translation project, please check out the [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu). We centralize translation work there, and periodically upstream translations.
+If you want to contribute to the user interface translation, please check out the [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu). We centralize translation work there, and periodically upstream translations.
 
-## Building
+### Building
 
 * __Windows__: [Windows Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Windows)
 * __Linux__: [Linux Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Linux)
 
-## Download
 
-You can download the latest releases automatically via the installer on our [downloads](https://yuzu-emu.org/downloads/) page.
-
-
-## Support
-
-If you enjoy the project and want to support us financially, check out our Patreon!
-
-<a href="https://www.patreon.com/yuzuteam">
-    <img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" width="160">
-</a>
-
-Any donations received will go towards things like:
+### Support
+We happily accept monetary donations, or donated games and hardware. Please see our [donations page](https://yuzu-emu.org/donate/) for more information on how you can contribute to yuzu. Any donations received will go towards things like:
 * Switch consoles to explore and reverse-engineer the hardware
 * Switch games for testing, reverse-engineering, and implementing new features
 * Web hosting and infrastructure setup
 * Software licenses (e.g. Visual Studio, IDA Pro, etc.)
 * Additional hardware (e.g. GPUs as-needed to improve rendering support, other peripherals to add support for, etc.)
 
-If you wish to support us a different way, please join our [Discord](https://discord.gg/u77vRWY) and talk to bunnei. You may also contact: donations@yuzu-emu.org.
-
-## License
-
-yuzu is licensed under the GPLv2 (or any later version). Refer to the [license.txt](https://github.com/yuzu-emu/yuzu/blob/master/license.txt) file.
-
-The [Skyline-Emulator Team](https://github.com/skyline-emu/skyline) is exempt from GPLv2 for the contributions from all these contributors [FernandoS27](https://github.com/FernandoS27), [lioncash](https://github.com/lioncash), [bunnei](https://github.com/bunnei), [ReinUsesLisp](https://github.com/ReinUsesLisp), [Morph1984](https://github.com/Morph1984), [ogniK5377](https://github.com/ogniK5377), [german77](https://github.com/german77), [ameerj](https://github.com/ameerj), [Kelebek1](https://github.com/Kelebek1) and [lat9nq](https://github.com/lat9nq). They may only use the code from these contributors under Mozilla Public License, version 2.0.
+We also more than gladly accept used Switch consoles, preferably ones with firmware 3.0.0 or lower! If you would like to give yours away, don't hesitate to join our [Discord](https://discord.gg/VXqngT3) and talk to bunnei. You may also contact: donations@yuzu-emu.org.

dist/qt_themes/default/style.qss

@@ -38,26 +38,6 @@ QPushButton#RendererStatusBarButton:!checked {
     color: #0066ff;
 }
 
-QPushButton#GPUStatusBarButton {
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-    color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-    color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
     min-width: 21px;
     min-height: 21px;
@@ -535,35 +515,45 @@ QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_num:pressed {
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_shift,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_num {
-    image: url(:/overlay/osk_button_B.png);
-    image-position: right;
+    background-position: right top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_B.png);
     qproperty-icon: url(:/overlay/osk_button_backspace.png);
     qproperty-iconSize: 36px;
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space_shift {
-    image: url(:/overlay/osk_button_Y.png);
-    image-position: right;
+    background-position: right top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_Y.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_shift,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_num {
-    image: url(:/overlay/osk_button_plus.png);
-    image-position: right;
+    background-position: right top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_plus.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_shift {
-    image: url(:/overlay/osk_button_shift_lock_off.png);
-    image-position: left;
+    background-position: left top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_shift_lock_off.png);
     qproperty-icon: url(:/overlay/osk_button_shift.png);
     qproperty-iconSize: 36px;
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_shift_shift {
-    image: url(:/overlay/osk_button_shift_lock_off.png);
-    image-position: left;
+    background-position: left top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_shift_lock_off.png);
     qproperty-icon: url(:/overlay/osk_button_shift_on.png);
     qproperty-iconSize: 36px;
 }
@@ -655,16 +645,16 @@ QDialog#QtSoftwareKeyboardDialog QPushButton#button_return:disabled {
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_shift:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_num:disabled {
-    image: url(:/overlay/osk_button_plus_disabled.png);
+    background-image: url(:/overlay/osk_button_plus_disabled.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_shift:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_num:disabled {
-    image: url(:/overlay/osk_button_B_disabled.png);
+    background-image: url(:/overlay/osk_button_B_disabled.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space_shift:disabled {
-    image: url(:/overlay/osk_button_Y_disabled.png);
+    background-image: url(:/overlay/osk_button_Y_disabled.png);
 }

dist/qt_themes/qdarkstyle/style.qss

@@ -1283,27 +1283,6 @@ QPushButton#RendererStatusBarButton:!checked {
     color: #00ccdd;
 }
 
-QPushButton#GPUStatusBarButton {
-    min-width: 0px;
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-    color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-    color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
     min-width: 23px;
     min-height: 23px;
@@ -1826,36 +1805,46 @@ QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_num:pressed {
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_shift,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_num {
-    image: url(:/overlay/osk_button_B_dark.png);
-    image-position: right;
+    background-position: right top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_B_dark.png);
     qproperty-icon: url(:/overlay/osk_button_backspace_dark.png);
     qproperty-iconSize: 36px;
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space_shift {
-    image: url(:/overlay/osk_button_Y_dark.png);
-    image-position: right;
+    background-position: right top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_Y_dark.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_shift,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_num {
     color: rgba(44, 44, 44, 1);
-    image: url(:/overlay/osk_button_plus_dark.png);
-    image-position: right;
+    background-position: right top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_plus_dark.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_shift {
-    image: url(:/overlay/osk_button_shift_lock_off.png);
-    image-position: left;
+    background-position: left top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_shift_lock_off.png);
     qproperty-icon: url(:/overlay/osk_button_shift_dark.png);
     qproperty-iconSize: 36px;
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_shift_shift {
-    image: url(:/overlay/osk_button_shift_lock_off.png);
-    image-position: left;
+    background-position: left top;
+    background-repeat: no-repeat;
+    background-origin: content;
+    background-image: url(:/overlay/osk_button_shift_lock_off.png);
     qproperty-icon: url(:/overlay/osk_button_shift_on_dark.png);
     qproperty-iconSize: 36px;
 }
@@ -1947,18 +1936,18 @@ QDialog#QtSoftwareKeyboardDialog QPushButton#button_return:disabled {
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_shift:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_num:disabled {
-    image: url(:/overlay/osk_button_plus_dark_disabled.png);
+    background-image: url(:/overlay/osk_button_plus_dark_disabled.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_shift:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_num:disabled {
-    image: url(:/overlay/osk_button_B_dark_disabled.png);
+    background-image: url(:/overlay/osk_button_B_dark_disabled.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space_shift:disabled {
-    image: url(:/overlay/osk_button_Y_dark_disabled.png);
+    background-image: url(:/overlay/osk_button_Y_dark_disabled.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QFrame,

dist/qt_themes/qdarkstyle_midnight_blue/style.qss

@@ -2186,27 +2186,6 @@ QPushButton#RendererStatusBarButton:!checked {
   color: #00ccdd;
 }
 
-QPushButton#GPUStatusBarButton {
-  min-width: 0px;
-  color: #656565;
-  border: 1px solid transparent;
-  background-color: transparent;
-  padding: 0px 3px 0px 3px;
-  text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-  border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-  color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-  color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
   min-width: 19px;
   min-height: 19px;
@@ -2761,36 +2740,46 @@ QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_num:pressed {
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_shift,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_num {
-  image: url(:/overlay/osk_button_B_dark.png);
-  image-position: right;
+  background-position: right top;
+  background-repeat: no-repeat;
+  background-origin: content;
+  background-image: url(:/overlay/osk_button_B_dark.png);
   qproperty-icon: url(:/overlay/osk_button_backspace_dark.png);
   qproperty-iconSize: 36px;
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space_shift {
-  image: url(:/overlay/osk_button_Y_dark.png);
-  image-position: right;
+  background-position: right top;
+  background-repeat: no-repeat;
+  background-origin: content;
+  background-image: url(:/overlay/osk_button_Y_dark.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_shift,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_num {
   color: rgba(44, 44, 44, 1);
-  image: url(:/overlay/osk_button_plus_dark.png);
-  image-position: right;
+  background-position: right top;
+  background-repeat: no-repeat;
+  background-origin: content;
+  background-image: url(:/overlay/osk_button_plus_dark.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_shift {
-  image: url(:/overlay/osk_button_shift_lock_off.png);
-  image-position: left;
+  background-position: left top;
+  background-repeat: no-repeat;
+  background-origin: content;
+  background-image: url(:/overlay/osk_button_shift_lock_off.png);
   qproperty-icon: url(:/overlay/osk_button_shift_dark.png);
   qproperty-iconSize: 36px;
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_shift_shift {
-  image: url(:/overlay/osk_button_shift_lock_off.png);
-  image-position: left;
+  background-position: left top;
+  background-repeat: no-repeat;
+  background-origin: content;
+  background-image: url(:/overlay/osk_button_shift_lock_off.png);
   qproperty-icon: url(:/overlay/osk_button_shift_on_dark.png);
   qproperty-iconSize: 36px;
 }
@@ -2882,16 +2871,16 @@ QDialog#QtSoftwareKeyboardDialog QPushButton#button_return:disabled {
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_shift:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_ok_num:disabled {
-  image: url(:/overlay/osk_button_plus_dark_disabled.png);
+  background-image: url(:/overlay/osk_button_plus_dark_disabled.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_shift:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_backspace_num:disabled {
-  image: url(:/overlay/osk_button_B_dark_disabled.png);
+  background-image: url(:/overlay/osk_button_B_dark_disabled.png);
 }
 
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space_shift:disabled {
-  image: url(:/overlay/osk_button_Y_dark_disabled.png);
+  background-image: url(:/overlay/osk_button_Y_dark_disabled.png);
 }

externals/CMakeLists.txt

@@ -45,31 +45,9 @@ target_include_directories(microprofile INTERFACE ./microprofile)
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
 
-# libusb
-if (NOT LIBUSB_FOUND OR YUZU_USE_BUNDLED_LIBUSB)
-    add_subdirectory(libusb)
-endif()
-
 # SDL2
-if (YUZU_USE_EXTERNAL_SDL2)
-    if (NOT WIN32)
-        # Yuzu itself needs: Events Joystick Haptic Sensor Timers Audio
-        # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
-        set(SDL_UNUSED_SUBSYSTEMS
-            Atomic Render Power Threads
-            File CPUinfo Filesystem Locale)
-        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
-          string(TOUPPER ${_SUB} _OPT)
-          option(SDL_${_OPT} "" OFF)
-        endforeach()
-
-        option(HIDAPI "" ON)
-    endif()
-    set(SDL_STATIC ON)
-    set(SDL_SHARED OFF)
-
+if (NOT SDL2_FOUND AND ENABLE_SDL2)
     add_subdirectory(SDL EXCLUDE_FROM_ALL)
-    add_library(SDL2 ALIAS SDL2-static)
 endif()
 
 # SoundTouch
@@ -115,7 +93,7 @@ if (ENABLE_WEB_SERVICE)
 
     # httplib
     add_library(httplib INTERFACE)
-    target_include_directories(httplib INTERFACE ./cpp-httplib)
+    target_include_directories(httplib INTERFACE ./httplib)
     target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
     target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
     if (WIN32)

externals/httplib/README.md

@@ -0,0 +1,15 @@
+From https://github.com/yhirose/cpp-httplib/tree/ff5677ad197947177c158fe857caff4f0e242045 with https://github.com/yhirose/cpp-httplib/pull/701
+
+MIT License
+
+===
+
+cpp-httplib
+
+A C++11 header-only HTTP library.
+
+It's extremely easy to setup. Just include httplib.h file in your code!
+
+Inspired by Sinatra and express.
+
+© 2017 Yuji Hirose

externals/libusb/CMakeLists.txt

@@ -1,270 +1,155 @@
-if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)
-    set(LIBUSB_FOUND ON CACHE BOOL "libusb is present" FORCE)
-    set(LIBUSB_VERSION "1.0.24" CACHE STRING "libusb version string" FORCE)
+# Ensure libusb compiles with UTF-8 encoding on MSVC
+if(MSVC)
+    add_compile_options(/utf-8)
+endif()
 
-    # GNU toolchains for some reason doesn't work with the later half of this CMakeLists after
-    # updating to 1.0.24, so we do it the old-fashioned way for now.
+add_library(usb STATIC EXCLUDE_FROM_ALL
+    libusb/libusb/core.c
+    libusb/libusb/core.c
+    libusb/libusb/descriptor.c
+    libusb/libusb/hotplug.c
+    libusb/libusb/io.c
+    libusb/libusb/strerror.c
+    libusb/libusb/sync.c
+)
+set_target_properties(usb PROPERTIES VERSION 1.0.23)
+if(WIN32)
+    target_include_directories(usb
+        BEFORE
+        PUBLIC
+          libusb/libusb
 
-    # Require autoconf and libtoolize here, rather than crash during compilation
-    find_program(AUTOCONF autoconf)
-    if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
-        message(FATAL_ERROR "Required program `autoconf` not found.")
-    endif()
+        PRIVATE
+          "${CMAKE_CURRENT_BINARY_DIR}"
+    )
 
-    find_program(LIBTOOLIZE libtoolize)
-    if ("${LIBTOOLIZE}" STREQUAL "LIBTOOLIZE-NOTFOUND")
-        message(FATAL_ERROR "Required program `libtoolize` not found.")
-    endif()
-
-    set(LIBUSB_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/libusb")
-    set(LIBUSB_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libusb")
-
-    # Workarounds for MSYS/MinGW
-    if (MSYS)
-        # CMake on Windows passes `C:/`, but we need `/C/` or `/c/` to use `configure`
-        string(REPLACE ":/" "/" LIBUSB_SRC_DIR "${LIBUSB_SRC_DIR}")
-        set(LIBUSB_SRC_DIR "/${LIBUSB_SRC_DIR}")
-
-        # And now that we are using /C/ for srcdir but everything else is using C:/, we need to
-        # compile everything in the source directory, else `configure` won't think the build
-        # environment is sane.
-        set(LIBUSB_PREFIX "${LIBUSB_SRC_DIR}")
-    endif()
-
-    set(LIBUSB_CONFIGURE "${LIBUSB_SRC_DIR}/configure")
-    set(LIBUSB_MAKEFILE "${LIBUSB_PREFIX}/Makefile")
-
-    if (MINGW)
-        set(LIBUSB_LIBRARIES "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.dll.a" CACHE PATH "libusb library path" FORCE)
-        set(LIBUSB_SHARED_LIBRARY "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.dll")
-        set(LIBUSB_SHARED_LIBRARY_DEST "${CMAKE_BINARY_DIR}/bin/libusb-1.0.dll")
-
-        set(LIBUSB_CONFIGURE_ARGS --host=x86_64-w64-mingw32 --build=x86_64-windows)
-    else()
-        set(LIBUSB_LIBRARIES "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.a" CACHE PATH "libusb library path" FORCE)
-    endif()
-
-    set(LIBUSB_INCLUDE_DIRS "${LIBUSB_SRC_DIR}/libusb" CACHE PATH "libusb headers path" FORCE)
-
-    # MINGW: causes "externals/libusb/libusb/libusb/os/windows_winusb.c:1427:2: error: conversion to non-scalar type requested", so cannot statically link it for now.
     if (NOT MINGW)
-        set(LIBUSB_CFLAGS "-DGUID_DEVINTERFACE_USB_DEVICE=\\(GUID\\){0xA5DCBF10,0x6530,0x11D2,{0x90,0x1F,0x00,0xC0,0x4F,0xB9,0x51,0xED}}")
+        target_include_directories(usb BEFORE PRIVATE libusb/msvc)
     endif()
 
-    make_directory("${LIBUSB_PREFIX}")
+    # Works around other libraries providing their own definition of USB GUIDs (e.g. SDL2)
+    target_compile_definitions(usb PRIVATE "-DGUID_DEVINTERFACE_USB_DEVICE=(GUID){ 0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED}}")
+else()
+target_include_directories(usb
+    # turns out other projects also have "config.h", so make sure the
+    # LibUSB one comes first
+    BEFORE
 
-    add_custom_command(
-        OUTPUT
-            "${LIBUSB_LIBRARIES}"
-        COMMAND
-            make
-        WORKING_DIRECTORY
-            "${LIBUSB_PREFIX}"
+    PUBLIC
+      libusb/libusb
+
+    PRIVATE
+      "${CMAKE_CURRENT_BINARY_DIR}"
+)
+endif()
+
+if(WIN32 OR CYGWIN)
+    target_sources(usb PRIVATE
+      libusb/libusb/os/threads_windows.c
+      libusb/libusb/os/windows_winusb.c
+      libusb/libusb/os/windows_usbdk.c
+      libusb/libusb/os/windows_nt_common.c
     )
-
-    add_custom_command(
-        OUTPUT
-            "${LIBUSB_MAKEFILE}"
-        COMMAND
-            env
-                CFLAGS="${LIBUSB_CFLAGS}"
-            sh "${LIBUSB_CONFIGURE}"
-                ${LIBUSB_CONFIGURE_ARGS}
-                --srcdir="${LIBUSB_SRC_DIR}"
-        WORKING_DIRECTORY
-            "${LIBUSB_PREFIX}"
+    set(OS_WINDOWS TRUE)
+elseif(APPLE)
+    target_sources(usb PRIVATE
+        libusb/libusb/os/darwin_usb.c
     )
-
-    add_custom_command(
-        OUTPUT
-            "${LIBUSB_CONFIGURE}"
-        COMMAND
-            sh "${LIBUSB_SRC_DIR}/bootstrap.sh"
-        WORKING_DIRECTORY
-            "${LIBUSB_SRC_DIR}"
+    find_library(COREFOUNDATION_LIBRARY CoreFoundation)
+    find_library(IOKIT_LIBRARY IOKit)
+    find_library(OBJC_LIBRARY objc)
+    target_link_libraries(usb PRIVATE
+        ${COREFOUNDATION_LIBRARY}
+        ${IOKIT_LIBRARY}
+        ${OBJC_LIBRARY}
     )
-
-    add_custom_command(
-        OUTPUT
-            "${LIBUSB_SHARED_LIBRARY_DEST}"
-        COMMAND
-            cp "${LIBUSB_SHARED_LIBRARY}" "${LIBUSB_SHARED_LIBRARY_DEST}"
+    set(OS_DARWIN TRUE)
+elseif(ANDROID)
+    target_sources(usb PRIVATE
+        libusb/libusb/os/linux_usbfs.c
+        libusb/libusb/os/linux_netlink.c
     )
-
-    add_custom_target(usb-bootstrap DEPENDS "${LIBUSB_CONFIGURE}")
-    add_custom_target(usb-configure DEPENDS "${LIBUSB_MAKEFILE}" usb-bootstrap)
-    add_custom_target(usb-build ALL DEPENDS "${LIBUSB_LIBRARIES}" usb-configure)
-    # Workaround since static linking didn't work out -- We need to copy the DLL to the bin directory
-    add_custom_target(usb-copy ALL DEPENDS "${LIBUSB_SHARED_LIBRARY_DEST}" usb-build)
-
-    add_library(usb INTERFACE)
-    add_dependencies(usb usb-copy)
-    target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARIES}")
-    target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")
-
-    if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-        Include(FindPkgConfig)
-        pkg_check_modules(LIBUDEV REQUIRED libudev)
-
-        if (LIBUDEV_FOUND)
-            target_include_directories(usb INTERFACE "${LIBUDEV_INCLUDE_DIRS}")
-            target_link_libraries(usb INTERFACE "${LIBUDEV_STATIC_LIBRARIES}")
-        endif()
-    endif()
-else() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-    # Ensure libusb compiles with UTF-8 encoding on MSVC
-    if(MSVC)
-        add_compile_options(/utf-8)
-    endif()
-
-    add_library(usb STATIC EXCLUDE_FROM_ALL
-        libusb/libusb/core.c
-        libusb/libusb/core.c
-        libusb/libusb/descriptor.c
-        libusb/libusb/hotplug.c
-        libusb/libusb/io.c
-        libusb/libusb/strerror.c
-        libusb/libusb/sync.c
+    find_library(LOG_LIBRARY log)
+    target_link_libraries(usb PRIVATE ${LOG_LIBRARY})
+    set(OS_LINUX TRUE)
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    target_sources(usb PRIVATE
+        libusb/libusb/os/linux_usbfs.c
     )
-    set_target_properties(usb PROPERTIES VERSION 1.0.24)
-    if(WIN32)
-        target_include_directories(usb
-            BEFORE
-            PUBLIC
-              libusb/libusb
-
-            PRIVATE
-              "${CMAKE_CURRENT_BINARY_DIR}"
+    find_package(Libudev)
+    if(LIBUDEV_FOUND)
+        target_sources(usb PRIVATE
+            libusb/libusb/os/linux_udev.c
         )
-
-        if (NOT MINGW)
-            target_include_directories(usb BEFORE PRIVATE libusb/msvc)
-        endif()
-
-        # Works around other libraries providing their own definition of USB GUIDs (e.g. SDL2)
-        target_compile_definitions(usb PRIVATE "-DGUID_DEVINTERFACE_USB_DEVICE=(GUID){ 0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED}}")
+        target_link_libraries(usb PRIVATE "${LIBUDEV_LIBRARIES}")
+        target_include_directories(usb PRIVATE "${LIBUDEV_INCLUDE_DIR}")
+        set(HAVE_LIBUDEV TRUE)
+        set(USE_UDEV TRUE)
     else()
-        target_include_directories(usb
-            # turns out other projects also have "config.h", so make sure the
-            # LibUSB one comes first
-            BEFORE
-
-            PUBLIC
-              libusb/libusb
-
-            PRIVATE
-              "${CMAKE_CURRENT_BINARY_DIR}"
-        )
-    endif()
-
-    if(WIN32 OR CYGWIN)
         target_sources(usb PRIVATE
-          libusb/libusb/os/threads_windows.c
-          libusb/libusb/os/windows_winusb.c
-          libusb/libusb/os/windows_usbdk.c
-          libusb/libusb/os/windows_common.c
-        )
-        set(OS_WINDOWS TRUE)
-    elseif(APPLE)
-        target_sources(usb PRIVATE
-            libusb/libusb/os/darwin_usb.c
-        )
-        find_library(COREFOUNDATION_LIBRARY CoreFoundation)
-        find_library(IOKIT_LIBRARY IOKit)
-        find_library(OBJC_LIBRARY objc)
-        target_link_libraries(usb PRIVATE
-            ${COREFOUNDATION_LIBRARY}
-            ${IOKIT_LIBRARY}
-            ${OBJC_LIBRARY}
-        )
-        set(OS_DARWIN TRUE)
-    elseif(ANDROID)
-        target_sources(usb PRIVATE
-            libusb/libusb/os/linux_usbfs.c
             libusb/libusb/os/linux_netlink.c
         )
-        find_library(LOG_LIBRARY log)
-        target_link_libraries(usb PRIVATE ${LOG_LIBRARY})
-        set(OS_LINUX TRUE)
-    elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-        target_sources(usb PRIVATE
-            libusb/libusb/os/linux_usbfs.c
-        )
-        find_package(Libudev)
-        if(LIBUDEV_FOUND)
-            target_sources(usb PRIVATE
-                libusb/libusb/os/linux_udev.c
-            )
-            target_link_libraries(usb PRIVATE "${LIBUDEV_LIBRARIES}")
-            target_include_directories(usb PRIVATE "${LIBUDEV_INCLUDE_DIR}")
-            set(HAVE_LIBUDEV TRUE)
-            set(USE_UDEV TRUE)
-        else()
-            target_sources(usb PRIVATE
-                libusb/libusb/os/linux_netlink.c
-            )
-        endif()
-        set(OS_LINUX TRUE)
-    elseif(${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
-        target_sources(usb PRIVATE
-            libusb/libusb/os/netbsd_usb.c
-        )
-        set(OS_NETBSD TRUE)
-    elseif(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
-        target_sources(usb PRIVATE
-            libusb/libusb/os/openbsd_usb.c
-        )
-        set(OS_OPENBSD TRUE)
     endif()
+    set(OS_LINUX TRUE)
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
+    target_sources(usb PRIVATE
+        libusb/libusb/os/netbsd_usb.c
+    )
+    set(OS_NETBSD TRUE)
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
+    target_sources(usb PRIVATE
+        libusb/libusb/os/openbsd_usb.c
+    )
+    set(OS_OPENBSD TRUE)
+endif()
 
-    if(UNIX)
-        target_sources(usb PRIVATE
-            libusb/libusb/os/events_posix.c
-            libusb/libusb/os/threads_posix.c
-        )
-        find_package(Threads REQUIRED)
-        if(THREADS_HAVE_PTHREAD_ARG)
-          target_compile_options(usb PUBLIC "-pthread")
-        endif()
-        if(CMAKE_THREAD_LIBS_INIT)
-          target_link_libraries(usb PRIVATE "${CMAKE_THREAD_LIBS_INIT}")
-        endif()
-        set(THREADS_POSIX TRUE)
-    elseif(WIN32)
-        target_sources(usb PRIVATE
-            libusb/libusb/os/events_windows.c
-            libusb/libusb/os/threads_windows.c
-        )
+if(UNIX)
+    target_sources(usb PRIVATE
+        libusb/libusb/os/poll_posix.c
+        libusb/libusb/os/threads_posix.c
+    )
+    find_package(Threads REQUIRED)
+    if(THREADS_HAVE_PTHREAD_ARG)
+      target_compile_options(usb PUBLIC "-pthread")
     endif()
-
-    include(CheckFunctionExists)
-    include(CheckIncludeFiles)
-    include(CheckTypeSize)
-    check_include_files(asm/types.h HAVE_ASM_TYPES_H)
-    check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
-    check_include_files(linux/filter.h HAVE_LINUX_FILTER_H)
-    check_include_files(linux/netlink.h HAVE_LINUX_NETLINK_H)
-    check_include_files(poll.h HAVE_POLL_H)
-    check_include_files(signal.h HAVE_SIGNAL_H)
-    check_include_files(strings.h HAVE_STRINGS_H)
-    check_type_size("struct timespec" STRUCT_TIMESPEC)
-    check_function_exists(syslog HAVE_SYSLOG_FUNC)
-    check_include_files(syslog.h HAVE_SYSLOG_H)
-    check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
-    check_include_files(sys/time.h HAVE_SYS_TIME_H)
-    check_include_files(sys/types.h HAVE_SYS_TYPES_H)
-
-    set(CMAKE_EXTRA_INCLUDE_FILES poll.h)
-    check_type_size("nfds_t" nfds_t)
-    unset(CMAKE_EXTRA_INCLUDE_FILES)
-    if(HAVE_NFDS_T)
-        set(POLL_NFDS_TYPE "nfds_t")
-    else()
-        set(POLL_NFDS_TYPE "unsigned int")
+    if(CMAKE_THREAD_LIBS_INIT)
+      target_link_libraries(usb PRIVATE "${CMAKE_THREAD_LIBS_INIT}")
     endif()
+    set(THREADS_POSIX TRUE)
+elseif(WIN32)
+    target_sources(usb PRIVATE
+        libusb/libusb/os/poll_windows.c
+        libusb/libusb/os/threads_windows.c
+    )
+endif()
 
-    check_include_files(sys/timerfd.h USBI_TIMERFD_AVAILABLE)
+include(CheckFunctionExists)
+include(CheckIncludeFiles)
+include(CheckTypeSize)
+check_include_files(asm/types.h HAVE_ASM_TYPES_H)
+check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
+check_include_files(linux/filter.h HAVE_LINUX_FILTER_H)
+check_include_files(linux/netlink.h HAVE_LINUX_NETLINK_H)
+check_include_files(poll.h HAVE_POLL_H)
+check_include_files(signal.h HAVE_SIGNAL_H)
+check_include_files(strings.h HAVE_STRINGS_H)
+check_type_size("struct timespec" STRUCT_TIMESPEC)
+check_function_exists(syslog HAVE_SYSLOG_FUNC)
+check_include_files(syslog.h HAVE_SYSLOG_H)
+check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
+check_include_files(sys/time.h HAVE_SYS_TIME_H)
+check_include_files(sys/types.h HAVE_SYS_TYPES_H)
+
+set(CMAKE_EXTRA_INCLUDE_FILES poll.h)
+check_type_size("nfds_t" nfds_t)
+unset(CMAKE_EXTRA_INCLUDE_FILES)
+if(HAVE_NFDS_T)
+    set(POLL_NFDS_TYPE "nfds_t")
+else()
+    set(POLL_NFDS_TYPE "unsigned int")
+endif()
+
+check_include_files(sys/timerfd.h USBI_TIMERFD_AVAILABLE)
 
 
-    configure_file(config.h.in config.h)
-endif() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+configure_file(config.h.in config.h)

src/CMakeLists.txt

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

src/audio_core/CMakeLists.txt

@@ -42,7 +42,6 @@ add_library(audio_core STATIC
     voice_context.h
 
     $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
-    $<$<BOOL:${ENABLE_SDL2}>:sdl2_sink.cpp sdl2_sink.h>
 )
 
 create_target_directory_groups(audio_core)
@@ -51,6 +50,9 @@ if (NOT MSVC)
     target_compile_options(audio_core PRIVATE
         -Werror=conversion
         -Werror=ignored-qualifiers
+        -Werror=implicit-fallthrough
+        -Werror=reorder
+        -Werror=sign-compare
         -Werror=shadow
         -Werror=unused-parameter
         -Werror=unused-variable
@@ -69,7 +71,3 @@ if(ENABLE_CUBEB)
     target_link_libraries(audio_core PRIVATE cubeb)
     target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
-if(ENABLE_SDL2)
-    target_link_libraries(audio_core PRIVATE SDL2)
-    target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
-endif()

src/audio_core/audio_out.cpp

@@ -30,8 +30,7 @@ StreamPtr AudioOut::OpenStream(Core::Timing::CoreTiming& core_timing, u32 sample
                                u32 num_channels, std::string&& name,
                                Stream::ReleaseCallback&& release_callback) {
     if (!sink) {
-        sink = CreateSinkFromID(Settings::values.sink_id.GetValue(),
-                                Settings::values.audio_device_id.GetValue());
+        sink = CreateSinkFromID(Settings::values.sink_id, Settings::values.audio_device_id);
     }
 
     return std::make_shared<Stream>(

src/audio_core/audio_renderer.cpp

@@ -12,7 +12,6 @@
 #include "audio_core/voice_context.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
-#include "core/core_timing.h"
 #include "core/memory.h"
 
 namespace {
@@ -29,9 +28,10 @@ namespace {
                                        (static_cast<float>(r_channel) * r_mix_amount)));
 }
 
-[[maybe_unused, nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(
-    s16 fl_channel, s16 fr_channel, s16 fc_channel, [[maybe_unused]] s16 lf_channel, s16 bl_channel,
-    s16 br_channel) {
+[[nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(s16 fl_channel, s16 fr_channel,
+                                                            s16 fc_channel,
+                                                            [[maybe_unused]] s16 lf_channel,
+                                                            s16 bl_channel, s16 br_channel) {
     // Front channels are mixed 36.94%, Center channels are mixed to be 26.12% & the back channels
     // are mixed to be 36.94%
 
@@ -56,11 +56,11 @@ namespace {
     const std::array<float_le, 4>& coeff) {
     const auto left =
         static_cast<float>(fl_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[3];
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[0];
 
     const auto right =
         static_cast<float>(fr_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[3];
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[0];
 
     return {ClampToS16(static_cast<s32>(left)), ClampToS16(static_cast<s32>(right))};
 }
@@ -68,9 +68,7 @@ namespace {
 } // namespace
 
 namespace AudioCore {
-constexpr s32 NUM_BUFFERS = 2;
-
-AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_,
+AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
                              AudioCommon::AudioRendererParameter params,
                              Stream::ReleaseCallback&& release_callback,
                              std::size_t instance_number)
@@ -79,8 +77,7 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memor
       sink_context(params.sink_count), splitter_context(),
       voices(params.voice_count), memory{memory_},
       command_generator(worker_params, voice_context, mix_context, splitter_context, effect_context,
-                        memory),
-      core_timing{core_timing_} {
+                        memory) {
     behavior_info.SetUserRevision(params.revision);
     splitter_context.Initialize(behavior_info, params.splitter_count,
                                 params.num_splitter_send_channels);
@@ -89,27 +86,16 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memor
     stream = audio_out->OpenStream(
         core_timing, params.sample_rate, AudioCommon::STREAM_NUM_CHANNELS,
         fmt::format("AudioRenderer-Instance{}", instance_number), std::move(release_callback));
-    process_event = Core::Timing::CreateEvent(
-        fmt::format("AudioRenderer-Instance{}-Process", instance_number),
-        [this](std::uintptr_t, std::chrono::nanoseconds) { ReleaseAndQueueBuffers(); });
-    for (s32 i = 0; i < NUM_BUFFERS; ++i) {
-        QueueMixedBuffer(i);
-    }
+    audio_out->StartStream(stream);
+
+    QueueMixedBuffer(0);
+    QueueMixedBuffer(1);
+    QueueMixedBuffer(2);
+    QueueMixedBuffer(3);
 }
 
 AudioRenderer::~AudioRenderer() = default;
 
-ResultCode AudioRenderer::Start() {
-    audio_out->StartStream(stream);
-    ReleaseAndQueueBuffers();
-    return ResultSuccess;
-}
-
-ResultCode AudioRenderer::Stop() {
-    audio_out->StopStream(stream);
-    return ResultSuccess;
-}
-
 u32 AudioRenderer::GetSampleRate() const {
     return worker_params.sample_rate;
 }
@@ -128,7 +114,7 @@ Stream::State AudioRenderer::GetStreamState() const {
 
 ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params,
                                               std::vector<u8>& output_params) {
-    std::scoped_lock lock{mutex};
+
     InfoUpdater info_updater{input_params, output_params, behavior_info};
 
     if (!info_updater.UpdateBehaviorInfo(behavior_info)) {
@@ -208,7 +194,10 @@ ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_param
         LOG_ERROR(Audio, "Audio buffers were not consumed!");
         return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
     }
-    return ResultSuccess;
+
+    ReleaseAndQueueBuffers();
+
+    return RESULT_SUCCESS;
 }
 
 void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
@@ -231,8 +220,10 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
     command_generator.PostCommand();
     // Base sample size
     std::size_t BUFFER_SIZE{worker_params.sample_count};
-    // Samples, making sure to clear
-    std::vector<s16> buffer(BUFFER_SIZE * stream->GetNumChannels(), 0);
+    // Samples
+    std::vector<s16> buffer(BUFFER_SIZE * stream->GetNumChannels());
+    // Make sure to clear our samples
+    std::memset(buffer.data(), 0, buffer.size() * sizeof(s16));
 
     if (sink_context.InUse()) {
         const auto stream_channel_count = stream->GetNumChannels();
@@ -240,7 +231,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
         const auto channel_count = buffer_offsets.size();
         const auto& final_mix = mix_context.GetFinalMixInfo();
         const auto& in_params = final_mix.GetInParams();
-        std::vector<std::span<s32>> mix_buffers(channel_count);
+        std::vector<s32*> mix_buffers(channel_count);
         for (std::size_t i = 0; i < channel_count; i++) {
             mix_buffers[i] =
                 command_generator.GetMixBuffer(in_params.buffer_offset + buffer_offsets[i]);
@@ -293,11 +284,18 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                     buffer[i * stream_channel_count + 0] = Mix2To1(fl_sample, fr_sample);
                 } else if (stream_channel_count == 2) {
                     // Mix all channels into 2 channels
-                    const auto [left, right] = Mix6To2WithCoefficients(
-                        fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
-                        sink_context.GetDownmixCoefficients());
-                    buffer[i * stream_channel_count + 0] = left;
-                    buffer[i * stream_channel_count + 1] = right;
+                    if (sink_context.HasDownMixingCoefficients()) {
+                        const auto [left, right] = Mix6To2WithCoefficients(
+                            fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
+                            sink_context.GetDownmixCoefficients());
+                        buffer[i * stream_channel_count + 0] = left;
+                        buffer[i * stream_channel_count + 1] = right;
+                    } else {
+                        const auto [left, right] = Mix6To2(fl_sample, fr_sample, fc_sample,
+                                                           lf_sample, bl_sample, br_sample);
+                        buffer[i * stream_channel_count + 0] = left;
+                        buffer[i * stream_channel_count + 1] = right;
+                    }
                 } else if (stream_channel_count == 6) {
                     // Pass through
                     buffer[i * stream_channel_count + 0] = fl_sample;
@@ -317,24 +315,10 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
 }
 
 void AudioRenderer::ReleaseAndQueueBuffers() {
-    if (!stream->IsPlaying()) {
-        return;
+    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream)};
+    for (const auto& tag : released_buffers) {
+        QueueMixedBuffer(tag);
     }
-
-    {
-        std::scoped_lock lock{mutex};
-        const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream)};
-        for (const auto& tag : released_buffers) {
-            QueueMixedBuffer(tag);
-        }
-    }
-
-    const f32 sample_rate = static_cast<f32>(GetSampleRate());
-    const f32 sample_count = static_cast<f32>(GetSampleCount());
-    const f32 consume_rate = sample_rate / (sample_count * (sample_count / 240));
-    const s32 ms = (1000 / static_cast<s32>(consume_rate)) - 1;
-    const std::chrono::milliseconds next_event_time(std::max(ms / NUM_BUFFERS, 1));
-    core_timing.ScheduleEvent(next_event_time, process_event, {});
 }
 
 } // namespace AudioCore

src/audio_core/audio_renderer.h

@@ -6,7 +6,6 @@
 
 #include <array>
 #include <memory>
-#include <mutex>
 #include <vector>
 
 #include "audio_core/behavior_info.h"
@@ -46,8 +45,6 @@ public:
 
     [[nodiscard]] ResultCode UpdateAudioRenderer(const std::vector<u8>& input_params,
                                                  std::vector<u8>& output_params);
-    [[nodiscard]] ResultCode Start();
-    [[nodiscard]] ResultCode Stop();
     void QueueMixedBuffer(Buffer::Tag tag);
     void ReleaseAndQueueBuffers();
     [[nodiscard]] u32 GetSampleRate() const;
@@ -71,9 +68,6 @@ private:
     Core::Memory::Memory& memory;
     CommandGenerator command_generator;
     std::size_t elapsed_frame_count{};
-    Core::Timing::CoreTiming& core_timing;
-    std::shared_ptr<Core::Timing::EventType> process_event;
-    std::mutex mutex;
 };
 
 } // namespace AudioCore

src/audio_core/command_generator.cpp

@@ -31,7 +31,7 @@ constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_GAIN{
     0.72867f, 0.69794f, 0.5464f,  0.24563f, 0.45214f, 0.44042f};
 
 template <std::size_t N>
-void ApplyMix(std::span<s32> output, std::span<const s32> input, s32 gain, s32 sample_count) {
+void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
     for (std::size_t i = 0; i < static_cast<std::size_t>(sample_count); i += N) {
         for (std::size_t j = 0; j < N; j++) {
             output[i + j] +=
@@ -40,17 +40,7 @@ void ApplyMix(std::span<s32> output, std::span<const s32> input, s32 gain, s32 s
     }
 }
 
-s32 ApplyMixRamp(std::span<s32> output, std::span<const s32> input, float gain, float delta,
-                 s32 sample_count) {
-    // XC2 passes in NaN mix volumes, causing further issues as we handle everything as s32 rather
-    // than float, so the NaN propogation is lost. As the samples get further modified for
-    // volume etc, they can get out of NaN range, so a later heuristic for catching this is
-    // more difficult. Handle it here by setting these samples to silence.
-    if (std::isnan(gain)) {
-        gain = 0.0f;
-        delta = 0.0f;
-    }
-
+s32 ApplyMixRamp(s32* output, const s32* input, float gain, float delta, s32 sample_count) {
     s32 x = 0;
     for (s32 i = 0; i < sample_count; i++) {
         x = static_cast<s32>(static_cast<float>(input[i]) * gain);
@@ -60,22 +50,20 @@ s32 ApplyMixRamp(std::span<s32> output, std::span<const s32> input, float gain,
     return x;
 }
 
-void ApplyGain(std::span<s32> output, std::span<const s32> input, s32 gain, s32 delta,
-               s32 sample_count) {
+void ApplyGain(s32* output, const s32* input, s32 gain, s32 delta, s32 sample_count) {
     for (s32 i = 0; i < sample_count; i++) {
         output[i] = static_cast<s32>((static_cast<s64>(input[i]) * gain + 0x4000) >> 15);
         gain += delta;
     }
 }
 
-void ApplyGainWithoutDelta(std::span<s32> output, std::span<const s32> input, s32 gain,
-                           s32 sample_count) {
+void ApplyGainWithoutDelta(s32* output, const s32* input, s32 gain, s32 sample_count) {
     for (s32 i = 0; i < sample_count; i++) {
         output[i] = static_cast<s32>((static_cast<s64>(input[i]) * gain + 0x4000) >> 15);
     }
 }
 
-s32 ApplyMixDepop(std::span<s32> output, s32 first_sample, s32 delta, s32 sample_count) {
+s32 ApplyMixDepop(s32* output, s32 first_sample, s32 delta, s32 sample_count) {
     const bool positive = first_sample > 0;
     auto final_sample = std::abs(first_sample);
     for (s32 i = 0; i < sample_count; i++) {
@@ -140,10 +128,10 @@ constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_6CH{4, 0, 0, 1, 1, 1, 1,
                                                            1, 1, 1, 0, 0, 0, 0, 3, 3, 3};
 
 template <std::size_t CHANNEL_COUNT>
-void ApplyReverbGeneric(
-    I3dl2ReverbState& state,
-    const std::array<std::span<const s32>, AudioCommon::MAX_CHANNEL_COUNT>& input,
-    const std::array<std::span<s32>, AudioCommon::MAX_CHANNEL_COUNT>& output, s32 sample_count) {
+void ApplyReverbGeneric(I3dl2ReverbState& state,
+                        const std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT>& input,
+                        const std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT>& output,
+                        s32 sample_count) {
 
     auto GetTapLookup = []() {
         if constexpr (CHANNEL_COUNT == 1) {
@@ -412,10 +400,7 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo
         }
     } else {
         switch (in_params.sample_format) {
-        case SampleFormat::Pcm8:
         case SampleFormat::Pcm16:
-        case SampleFormat::Pcm32:
-        case SampleFormat::PcmFloat:
             DecodeFromWaveBuffers(voice_info, GetChannelMixBuffer(channel), dsp_state, channel,
                                   worker_params.sample_rate, worker_params.sample_count,
                                   in_params.node_id);
@@ -469,8 +454,8 @@ void CommandGenerator::GenerateBiquadFilterCommand([[maybe_unused]] s32 mix_buff
                   "input_mix_buffer={}, output_mix_buffer={}",
                   node_id, input_offset, output_offset);
     }
-    std::span<const s32> input = GetMixBuffer(input_offset);
-    std::span<s32> output = GetMixBuffer(output_offset);
+    const auto* input = GetMixBuffer(input_offset);
+    auto* output = GetMixBuffer(output_offset);
 
     // Biquad filter parameters
     const auto [n0, n1, n2] = params.numerator;
@@ -563,8 +548,8 @@ void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, E
         return;
     }
 
-    std::array<std::span<const s32>, AudioCommon::MAX_CHANNEL_COUNT> input{};
-    std::array<std::span<s32>, AudioCommon::MAX_CHANNEL_COUNT> output{};
+    std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT> input{};
+    std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT> output{};
 
     const auto status = params.status;
     for (s32 i = 0; i < channel_count; i++) {
@@ -599,8 +584,7 @@ void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, E
         for (s32 i = 0; i < channel_count; i++) {
             // Only copy if the buffer input and output do not match!
             if ((mix_buffer_offset + params.input[i]) != (mix_buffer_offset + params.output[i])) {
-                std::memcpy(output[i].data(), input[i].data(),
-                            worker_params.sample_count * sizeof(s32));
+                std::memcpy(output[i], input[i], worker_params.sample_count * sizeof(s32));
             }
         }
     }
@@ -616,8 +600,8 @@ void CommandGenerator::GenerateBiquadFilterEffectCommand(s32 mix_buffer_offset,
     for (s32 i = 0; i < channel_count; i++) {
         // TODO(ogniK): Actually implement biquad filter
         if (params.input[i] != params.output[i]) {
-            std::span<const s32> input = GetMixBuffer(mix_buffer_offset + params.input[i]);
-            std::span<s32> output = GetMixBuffer(mix_buffer_offset + params.output[i]);
+            const auto* input = GetMixBuffer(mix_buffer_offset + params.input[i]);
+            auto* output = GetMixBuffer(mix_buffer_offset + params.output[i]);
             ApplyMix<1>(output, input, 32768, worker_params.sample_count);
         }
     }
@@ -656,15 +640,14 @@ void CommandGenerator::GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* inf
 
                 if (samples_read != static_cast<int>(worker_params.sample_count) &&
                     samples_read <= params.sample_count) {
-                    std::memset(GetMixBuffer(output_index).data(), 0,
-                                params.sample_count - samples_read);
+                    std::memset(GetMixBuffer(output_index), 0, params.sample_count - samples_read);
                 }
             } else {
                 AuxInfoDSP empty{};
                 memory.WriteBlock(aux->GetSendInfo(), &empty, sizeof(AuxInfoDSP));
                 memory.WriteBlock(aux->GetRecvInfo(), &empty, sizeof(AuxInfoDSP));
                 if (output_index != input_index) {
-                    std::memcpy(GetMixBuffer(output_index).data(), GetMixBuffer(input_index).data(),
+                    std::memcpy(GetMixBuffer(output_index), GetMixBuffer(input_index),
                                 worker_params.sample_count * sizeof(s32));
                 }
             }
@@ -682,7 +665,7 @@ ServerSplitterDestinationData* CommandGenerator::GetDestinationData(s32 splitter
 }
 
 s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples,
-                                     std::span<const s32> data, u32 sample_count, u32 write_offset,
+                                     const s32* data, u32 sample_count, u32 write_offset,
                                      u32 write_count) {
     if (max_samples == 0) {
         return 0;
@@ -692,14 +675,14 @@ s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u3
         return 0;
     }
 
-    s32 data_offset{};
+    std::size_t data_offset{};
     u32 remaining = sample_count;
     while (remaining > 0) {
         // Get position in buffer
         const auto base = send_buffer + (offset * sizeof(u32));
         const auto samples_to_grab = std::min(max_samples - offset, remaining);
         // Write to output
-        memory.WriteBlock(base, (data.data() + data_offset), samples_to_grab * sizeof(u32));
+        memory.WriteBlock(base, (data + data_offset), samples_to_grab * sizeof(u32));
         offset = (offset + samples_to_grab) % max_samples;
         remaining -= samples_to_grab;
         data_offset += samples_to_grab;
@@ -712,7 +695,7 @@ s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u3
 }
 
 s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples,
-                                    std::span<s32> out_data, u32 sample_count, u32 read_offset,
+                                    s32* out_data, u32 sample_count, u32 read_offset,
                                     u32 read_count) {
     if (max_samples == 0) {
         return 0;
@@ -724,16 +707,15 @@ s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u3
     }
 
     u32 remaining = sample_count;
-    s32 data_offset{};
     while (remaining > 0) {
         const auto base = recv_buffer + (offset * sizeof(u32));
         const auto samples_to_grab = std::min(max_samples - offset, remaining);
         std::vector<s32> buffer(samples_to_grab);
         memory.ReadBlock(base, buffer.data(), buffer.size() * sizeof(u32));
-        std::memcpy(out_data.data() + data_offset, buffer.data(), buffer.size() * sizeof(u32));
+        std::memcpy(out_data, buffer.data(), buffer.size() * sizeof(u32));
+        out_data += samples_to_grab;
         offset = (offset + samples_to_grab) % max_samples;
         remaining -= samples_to_grab;
-        data_offset += samples_to_grab;
     }
 
     if (read_count != 0) {
@@ -813,7 +795,7 @@ void CommandGenerator::UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbSta
         state.lowpass_1 = 0.0f;
     } else {
         const auto a = 1.0f - hf_gain;
-        const auto b = 2.0f * (2.0f - hf_gain * CosD(256.0f * info.hf_reference /
+        const auto b = 2.0f * (1.0f - hf_gain * CosD(256.0f * info.hf_reference /
                                                      static_cast<f32>(info.sample_rate)));
         const auto c = std::sqrt(b * b - 4.0f * a * a);
 
@@ -861,7 +843,7 @@ void CommandGenerator::UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbSta
     }
 
     const auto max_early_delay = state.early_delay_line.GetMaxDelay();
-    const auto reflection_time = 1000.0f * (0.9998f * info.reverb_delay + 0.02f);
+    const auto reflection_time = 1000.0f * (0.0098f * info.reverb_delay + 0.02f);
     for (std::size_t tap = 0; tap < AudioCommon::I3DL2REVERB_TAPS; tap++) {
         const auto length = AudioCommon::CalculateDelaySamples(
             sample_rate, 1000.0f * info.reflection_delay + reflection_time * EARLY_TAP_TIMES[tap]);
@@ -980,8 +962,8 @@ void CommandGenerator::GenerateMixCommand(std::size_t output_offset, std::size_t
                   node_id, input_offset, output_offset, volume);
     }
 
-    std::span<s32> output = GetMixBuffer(output_offset);
-    std::span<const s32> input = GetMixBuffer(input_offset);
+    auto* output = GetMixBuffer(output_offset);
+    const auto* input = GetMixBuffer(input_offset);
 
     const s32 gain = static_cast<s32>(volume * 32768.0f);
     // Mix with loop unrolling
@@ -1021,10 +1003,8 @@ void CommandGenerator::GenerateFinalMixCommand() {
     }
 }
 
-template <typename T>
-s32 CommandGenerator::DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                s32 sample_start_offset, s32 sample_end_offset, s32 sample_count,
-                                s32 channel, std::size_t mix_offset) {
+s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
+                                  s32 sample_count, s32 channel, std::size_t mix_offset) {
     const auto& in_params = voice_info.GetInParams();
     const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
     if (wave_buffer.buffer_address == 0) {
@@ -1033,41 +1013,30 @@ s32 CommandGenerator::DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_sta
     if (wave_buffer.buffer_size == 0) {
         return 0;
     }
-    if (sample_end_offset < sample_start_offset) {
+    if (wave_buffer.end_sample_offset < wave_buffer.start_sample_offset) {
         return 0;
     }
-    const auto samples_remaining = (sample_end_offset - sample_start_offset) - dsp_state.offset;
+    const auto samples_remaining =
+        (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) - dsp_state.offset;
     const auto start_offset =
-        ((dsp_state.offset + sample_start_offset) * in_params.channel_count) * sizeof(T);
+        ((wave_buffer.start_sample_offset + dsp_state.offset) * in_params.channel_count) *
+        sizeof(s16);
     const auto buffer_pos = wave_buffer.buffer_address + start_offset;
     const auto samples_processed = std::min(sample_count, samples_remaining);
 
-    const auto channel_count = in_params.channel_count;
-    std::vector<T> buffer(samples_processed * channel_count);
-    memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(T));
-
-    if constexpr (std::is_floating_point_v<T>) {
-        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
-            sample_buffer[mix_offset + i] = static_cast<s32>(buffer[i * channel_count + channel] *
-                                                             std::numeric_limits<s16>::max());
-        }
-    } else if constexpr (sizeof(T) == 1) {
-        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
-            sample_buffer[mix_offset + i] =
-                static_cast<s32>(static_cast<f32>(buffer[i * channel_count + channel] /
-                                                  std::numeric_limits<s8>::max()) *
-                                 std::numeric_limits<s16>::max());
-        }
-    } else if constexpr (sizeof(T) == 2) {
-        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
-            sample_buffer[mix_offset + i] = buffer[i * channel_count + channel];
+    if (in_params.channel_count == 1) {
+        std::vector<s16> buffer(samples_processed);
+        memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));
+        for (std::size_t i = 0; i < buffer.size(); i++) {
+            sample_buffer[mix_offset + i] = buffer[i];
         }
     } else {
+        const auto channel_count = in_params.channel_count;
+        std::vector<s16> buffer(samples_processed * channel_count);
+        memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));
+
         for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
-            sample_buffer[mix_offset + i] =
-                static_cast<s32>(static_cast<f32>(buffer[i * channel_count + channel] /
-                                                  std::numeric_limits<s32>::max()) *
-                                 std::numeric_limits<s16>::max());
+            sample_buffer[mix_offset + i] = buffer[i * channel_count + channel];
         }
     }
 
@@ -1075,8 +1044,8 @@ s32 CommandGenerator::DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_sta
 }
 
 s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                  s32 sample_start_offset, s32 sample_end_offset, s32 sample_count,
-                                  [[maybe_unused]] s32 channel, std::size_t mix_offset) {
+                                  s32 sample_count, [[maybe_unused]] s32 channel,
+                                  std::size_t mix_offset) {
     const auto& in_params = voice_info.GetInParams();
     const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
     if (wave_buffer.buffer_address == 0) {
@@ -1085,7 +1054,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
     if (wave_buffer.buffer_size == 0) {
         return 0;
     }
-    if (sample_end_offset < sample_start_offset) {
+    if (wave_buffer.end_sample_offset < wave_buffer.start_sample_offset) {
         return 0;
     }
 
@@ -1110,9 +1079,10 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
     s32 coef1 = coeffs[idx * 2];
     s32 coef2 = coeffs[idx * 2 + 1];
 
-    const auto samples_remaining = (sample_end_offset - sample_start_offset) - dsp_state.offset;
+    const auto samples_remaining =
+        (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) - dsp_state.offset;
     const auto samples_processed = std::min(sample_count, samples_remaining);
-    const auto sample_pos = dsp_state.offset + sample_start_offset;
+    const auto sample_pos = wave_buffer.start_sample_offset + dsp_state.offset;
 
     const auto samples_remaining_in_frame = sample_pos % SAMPLES_PER_FRAME;
     auto position_in_frame = ((sample_pos / SAMPLES_PER_FRAME) * NIBBLES_PER_SAMPLE) +
@@ -1187,14 +1157,12 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
     return samples_processed;
 }
 
-std::span<s32> CommandGenerator::GetMixBuffer(std::size_t index) {
-    return std::span<s32>(mix_buffer.data() + (index * worker_params.sample_count),
-                          worker_params.sample_count);
+s32* CommandGenerator::GetMixBuffer(std::size_t index) {
+    return mix_buffer.data() + (index * worker_params.sample_count);
 }
 
-std::span<const s32> CommandGenerator::GetMixBuffer(std::size_t index) const {
-    return std::span<const s32>(mix_buffer.data() + (index * worker_params.sample_count),
-                                worker_params.sample_count);
+const s32* CommandGenerator::GetMixBuffer(std::size_t index) const {
+    return mix_buffer.data() + (index * worker_params.sample_count);
 }
 
 std::size_t CommandGenerator::GetMixChannelBufferOffset(s32 channel) const {
@@ -1205,15 +1173,15 @@ std::size_t CommandGenerator::GetTotalMixBufferCount() const {
     return worker_params.mix_buffer_count + AudioCommon::MAX_CHANNEL_COUNT;
 }
 
-std::span<s32> CommandGenerator::GetChannelMixBuffer(s32 channel) {
+s32* CommandGenerator::GetChannelMixBuffer(s32 channel) {
     return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }
 
-std::span<const s32> CommandGenerator::GetChannelMixBuffer(s32 channel) const {
+const s32* CommandGenerator::GetChannelMixBuffer(s32 channel) const {
     return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }
 
-void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::span<s32> output,
+void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* output,
                                              VoiceState& dsp_state, s32 channel,
                                              s32 target_sample_rate, s32 sample_count,
                                              s32 node_id) {
@@ -1225,7 +1193,7 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
                   node_id, channel, in_params.sample_format, sample_count, in_params.sample_rate,
                   in_params.mix_id, in_params.splitter_info_id);
     }
-    ASSERT_OR_EXECUTE(output.data() != nullptr, { return; });
+    ASSERT_OR_EXECUTE(output != nullptr, { return; });
 
     const auto resample_rate = static_cast<s32>(
         static_cast<float>(in_params.sample_rate) / static_cast<float>(target_sample_rate) *
@@ -1242,9 +1210,9 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
     }
 
     std::size_t temp_mix_offset{};
-    s32 samples_output{};
+    bool is_buffer_completed{false};
     auto samples_remaining = sample_count;
-    while (samples_remaining > 0) {
+    while (samples_remaining > 0 && !is_buffer_completed) {
         const auto samples_to_output = std::min(samples_remaining, min_required_samples);
         const auto samples_to_read = (samples_to_output * resample_rate + dsp_state.fraction) >> 15;
 
@@ -1261,53 +1229,24 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
             const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
             // No more data can be read
             if (!dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index]) {
+                is_buffer_completed = true;
                 break;
             }
 
             if (in_params.sample_format == SampleFormat::Adpcm && dsp_state.offset == 0 &&
                 wave_buffer.context_address != 0 && wave_buffer.context_size != 0) {
-                memory.ReadBlock(wave_buffer.context_address, &dsp_state.context,
-                                 sizeof(ADPCMContext));
-            }
-
-            s32 samples_offset_start;
-            s32 samples_offset_end;
-            if (dsp_state.loop_count > 0 && wave_buffer.loop_start_sample != 0 &&
-                wave_buffer.loop_end_sample != 0 &&
-                wave_buffer.loop_start_sample <= wave_buffer.loop_end_sample) {
-                samples_offset_start = wave_buffer.loop_start_sample;
-                samples_offset_end = wave_buffer.loop_end_sample;
-            } else {
-                samples_offset_start = wave_buffer.start_sample_offset;
-                samples_offset_end = wave_buffer.end_sample_offset;
+                // TODO(ogniK): ADPCM loop context
             }
 
             s32 samples_decoded{0};
             switch (in_params.sample_format) {
-            case SampleFormat::Pcm8:
-                samples_decoded =
-                    DecodePcm<s8>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                  samples_to_read - samples_read, channel, temp_mix_offset);
-                break;
             case SampleFormat::Pcm16:
-                samples_decoded =
-                    DecodePcm<s16>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                   samples_to_read - samples_read, channel, temp_mix_offset);
-                break;
-            case SampleFormat::Pcm32:
-                samples_decoded =
-                    DecodePcm<s32>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                   samples_to_read - samples_read, channel, temp_mix_offset);
-                break;
-            case SampleFormat::PcmFloat:
-                samples_decoded =
-                    DecodePcm<f32>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                   samples_to_read - samples_read, channel, temp_mix_offset);
+                samples_decoded = DecodePcm16(voice_info, dsp_state, samples_to_read - samples_read,
+                                              channel, temp_mix_offset);
                 break;
             case SampleFormat::Adpcm:
-                samples_decoded =
-                    DecodeAdpcm(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                samples_to_read - samples_read, channel, temp_mix_offset);
+                samples_decoded = DecodeAdpcm(voice_info, dsp_state, samples_to_read - samples_read,
+                                              channel, temp_mix_offset);
                 break;
             default:
                 UNREACHABLE_MSG("Unimplemented sample format={}", in_params.sample_format);
@@ -1318,19 +1257,15 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
             dsp_state.offset += samples_decoded;
             dsp_state.played_sample_count += samples_decoded;
 
-            if (dsp_state.offset >= (samples_offset_end - samples_offset_start) ||
+            if (dsp_state.offset >=
+                    (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) ||
                 samples_decoded == 0) {
                 // Reset our sample offset
                 dsp_state.offset = 0;
                 if (wave_buffer.is_looping) {
-                    dsp_state.loop_count++;
-                    if (wave_buffer.loop_count > 0 &&
-                        (dsp_state.loop_count > wave_buffer.loop_count || samples_decoded == 0)) {
-                        // End of our buffer
-                        voice_info.SetWaveBufferCompleted(dsp_state, wave_buffer);
-                    }
-
                     if (samples_decoded == 0) {
+                        // End of our buffer
+                        is_buffer_completed = true;
                         break;
                     }
 
@@ -1338,29 +1273,35 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
                         dsp_state.played_sample_count = 0;
                     }
                 } else {
+
                     // Update our wave buffer states
-                    voice_info.SetWaveBufferCompleted(dsp_state, wave_buffer);
+                    dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index] = false;
+                    dsp_state.wave_buffer_consumed++;
+                    dsp_state.wave_buffer_index =
+                        (dsp_state.wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS;
+                    if (wave_buffer.end_of_stream) {
+                        dsp_state.played_sample_count = 0;
+                    }
                 }
             }
         }
 
         if (in_params.behavior_flags.is_pitch_and_src_skipped.Value()) {
             // No need to resample
-            std::memcpy(output.data() + samples_output, sample_buffer.data(),
-                        samples_read * sizeof(s32));
+            std::memcpy(output, sample_buffer.data(), samples_read * sizeof(s32));
         } else {
             std::fill(sample_buffer.begin() + temp_mix_offset,
                       sample_buffer.begin() + temp_mix_offset + (samples_to_read - samples_read),
                       0);
-            AudioCore::Resample(output.data() + samples_output, sample_buffer.data(), resample_rate,
-                                dsp_state.fraction, samples_to_output);
+            AudioCore::Resample(output, sample_buffer.data(), resample_rate, dsp_state.fraction,
+                                samples_to_output);
             // Resample
             for (std::size_t i = 0; i < AudioCommon::MAX_SAMPLE_HISTORY; i++) {
                 dsp_state.sample_history[i] = sample_buffer[samples_to_read + i];
             }
         }
+        output += samples_to_output;
         samples_remaining -= samples_to_output;
-        samples_output += samples_to_output;
     }
 }
 

src/audio_core/command_generator.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <array>
-#include <span>
 #include "audio_core/common.h"
 #include "audio_core/voice_context.h"
 #include "common/common_types.h"
@@ -42,10 +41,10 @@ public:
     void PreCommand();
     void PostCommand();
 
-    [[nodiscard]] std::span<s32> GetChannelMixBuffer(s32 channel);
-    [[nodiscard]] std::span<const s32> GetChannelMixBuffer(s32 channel) const;
-    [[nodiscard]] std::span<s32> GetMixBuffer(std::size_t index);
-    [[nodiscard]] std::span<const s32> GetMixBuffer(std::size_t index) const;
+    [[nodiscard]] s32* GetChannelMixBuffer(s32 channel);
+    [[nodiscard]] const s32* GetChannelMixBuffer(s32 channel) const;
+    [[nodiscard]] s32* GetMixBuffer(std::size_t index);
+    [[nodiscard]] const s32* GetMixBuffer(std::size_t index) const;
     [[nodiscard]] std::size_t GetMixChannelBufferOffset(s32 channel) const;
 
     [[nodiscard]] std::size_t GetTotalMixBufferCount() const;
@@ -78,24 +77,21 @@ private:
     void GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
     [[nodiscard]] ServerSplitterDestinationData* GetDestinationData(s32 splitter_id, s32 index);
 
-    s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples,
-                       std::span<const s32> data, u32 sample_count, u32 write_offset,
-                       u32 write_count);
-    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples,
-                      std::span<s32> out_data, u32 sample_count, u32 read_offset, u32 read_count);
+    s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples, const s32* data,
+                       u32 sample_count, u32 write_offset, u32 write_count);
+    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples, s32* out_data,
+                      u32 sample_count, u32 read_offset, u32 read_count);
 
     void InitializeI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
                                std::vector<u8>& work_buffer);
     void UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state, bool should_clear);
     // DSP Code
-    template <typename T>
-    s32 DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_start_offset,
-                  s32 sample_end_offset, s32 sample_count, s32 channel, std::size_t mix_offset);
-    s32 DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_start_offset,
-                    s32 sample_end_offset, s32 sample_count, s32 channel, std::size_t mix_offset);
-    void DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::span<s32> output,
-                               VoiceState& dsp_state, s32 channel, s32 target_sample_rate,
-                               s32 sample_count, s32 node_id);
+    s32 DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
+                    s32 channel, std::size_t mix_offset);
+    s32 DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
+                    s32 channel, std::size_t mix_offset);
+    void DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* output, VoiceState& dsp_state,
+                               s32 channel, s32 target_sample_rate, s32 sample_count, s32 node_id);
 
     AudioCommon::AudioRendererParameter& worker_params;
     VoiceContext& voice_context;

src/audio_core/common.h

@@ -15,7 +15,7 @@ constexpr ResultCode ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
 constexpr ResultCode ERR_SPLITTER_SORT_FAILED{ErrorModule::Audio, 43};
 } // namespace Audren
 
-constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '9');
+constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '8');
 constexpr std::size_t MAX_MIX_BUFFERS = 24;
 constexpr std::size_t MAX_BIQUAD_FILTERS = 2;
 constexpr std::size_t MAX_CHANNEL_COUNT = 6;

src/audio_core/info_updater.cpp

@@ -189,6 +189,9 @@ bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
         if (voice_in_params.is_new) {
             // Default our values for our voice
             voice_info.Initialize();
+            if (channel_count == 0 || channel_count > AudioCommon::MAX_CHANNEL_COUNT) {
+                continue;
+            }
 
             // Zero out our voice states
             for (std::size_t channel = 0; channel < channel_count; channel++) {
@@ -404,7 +407,7 @@ ResultCode InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buf
 
     // TODO(ogniK): Sort when splitter is suppoorted
 
-    return ResultSuccess;
+    return RESULT_SUCCESS;
 }
 
 bool InfoUpdater::UpdateSinks(SinkContext& sink_context) {

src/audio_core/sdl2_sink.cpp

@@ -1,163 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <atomic>
-#include <cstring>
-#include "audio_core/sdl2_sink.h"
-#include "audio_core/stream.h"
-#include "audio_core/time_stretch.h"
-#include "common/assert.h"
-#include "common/logging/log.h"
-//#include "common/settings.h"
-
-// Ignore -Wimplicit-fallthrough due to https://github.com/libsdl-org/SDL/issues/4307
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
-#endif
-#include <SDL.h>
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-namespace AudioCore {
-
-class SDLSinkStream final : public SinkStream {
-public:
-    SDLSinkStream(u32 sample_rate, u32 num_channels_, const std::string& output_device)
-        : num_channels{std::min(num_channels_, 6u)}, time_stretch{sample_rate, num_channels} {
-
-        SDL_AudioSpec spec;
-        spec.freq = sample_rate;
-        spec.channels = static_cast<u8>(num_channels);
-        spec.format = AUDIO_S16SYS;
-        spec.samples = 4096;
-        spec.callback = nullptr;
-
-        SDL_AudioSpec obtained;
-        if (output_device.empty()) {
-            dev = SDL_OpenAudioDevice(nullptr, 0, &spec, &obtained, 0);
-        } else {
-            dev = SDL_OpenAudioDevice(output_device.c_str(), 0, &spec, &obtained, 0);
-        }
-
-        if (dev == 0) {
-            LOG_CRITICAL(Audio_Sink, "Error opening sdl audio device: {}", SDL_GetError());
-            return;
-        }
-
-        SDL_PauseAudioDevice(dev, 0);
-    }
-
-    ~SDLSinkStream() override {
-        if (dev == 0) {
-            return;
-        }
-
-        SDL_CloseAudioDevice(dev);
-    }
-
-    void EnqueueSamples(u32 source_num_channels, const std::vector<s16>& samples) override {
-        if (source_num_channels > num_channels) {
-            // Downsample 6 channels to 2
-            ASSERT_MSG(source_num_channels == 6, "Channel count must be 6");
-
-            std::vector<s16> buf;
-            buf.reserve(samples.size() * num_channels / source_num_channels);
-            for (std::size_t i = 0; i < samples.size(); i += source_num_channels) {
-                // Downmixing implementation taken from the ATSC standard
-                const s16 left{samples[i + 0]};
-                const s16 right{samples[i + 1]};
-                const s16 center{samples[i + 2]};
-                const s16 surround_left{samples[i + 4]};
-                const s16 surround_right{samples[i + 5]};
-                // Not used in the ATSC reference implementation
-                [[maybe_unused]] const s16 low_frequency_effects{samples[i + 3]};
-
-                constexpr s32 clev{707}; // center mixing level coefficient
-                constexpr s32 slev{707}; // surround mixing level coefficient
-
-                buf.push_back(static_cast<s16>(left + (clev * center / 1000) +
-                                               (slev * surround_left / 1000)));
-                buf.push_back(static_cast<s16>(right + (clev * center / 1000) +
-                                               (slev * surround_right / 1000)));
-            }
-            int ret = SDL_QueueAudio(dev, static_cast<const void*>(buf.data()),
-                                     static_cast<u32>(buf.size() * sizeof(s16)));
-            if (ret < 0)
-                LOG_WARNING(Audio_Sink, "Could not queue audio buffer: {}", SDL_GetError());
-            return;
-        }
-
-        int ret = SDL_QueueAudio(dev, static_cast<const void*>(samples.data()),
-                                 static_cast<u32>(samples.size() * sizeof(s16)));
-        if (ret < 0)
-            LOG_WARNING(Audio_Sink, "Could not queue audio buffer: {}", SDL_GetError());
-    }
-
-    std::size_t SamplesInQueue(u32 channel_count) const override {
-        if (dev == 0)
-            return 0;
-
-        return SDL_GetQueuedAudioSize(dev) / (channel_count * sizeof(s16));
-    }
-
-    void Flush() override {
-        should_flush = true;
-    }
-
-    u32 GetNumChannels() const {
-        return num_channels;
-    }
-
-private:
-    SDL_AudioDeviceID dev = 0;
-    u32 num_channels{};
-    std::atomic<bool> should_flush{};
-    TimeStretcher time_stretch;
-};
-
-SDLSink::SDLSink(std::string_view target_device_name) {
-    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
-        if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
-            LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
-            return;
-        }
-    }
-
-    if (target_device_name != auto_device_name && !target_device_name.empty()) {
-        output_device = target_device_name;
-    } else {
-        output_device.clear();
-    }
-}
-
-SDLSink::~SDLSink() = default;
-
-SinkStream& SDLSink::AcquireSinkStream(u32 sample_rate, u32 num_channels, const std::string&) {
-    sink_streams.push_back(
-        std::make_unique<SDLSinkStream>(sample_rate, num_channels, output_device));
-    return *sink_streams.back();
-}
-
-std::vector<std::string> ListSDLSinkDevices() {
-    std::vector<std::string> device_list;
-
-    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
-        if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
-            LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
-            return {};
-        }
-    }
-
-    const int device_count = SDL_GetNumAudioDevices(0);
-    for (int i = 0; i < device_count; ++i) {
-        device_list.emplace_back(SDL_GetAudioDeviceName(i, 0));
-    }
-
-    return device_list;
-}
-
-} // namespace AudioCore

src/audio_core/sdl2_sink.h

@@ -1,29 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include "audio_core/sink.h"
-
-namespace AudioCore {
-
-class SDLSink final : public Sink {
-public:
-    explicit SDLSink(std::string_view device_id);
-    ~SDLSink() override;
-
-    SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels,
-                                  const std::string& name) override;
-
-private:
-    std::string output_device;
-    std::vector<SinkStreamPtr> sink_streams;
-};
-
-std::vector<std::string> ListSDLSinkDevices();
-
-} // namespace AudioCore

src/audio_core/sink_context.cpp

@@ -15,17 +15,10 @@ std::size_t SinkContext::GetCount() const {
 void SinkContext::UpdateMainSink(const SinkInfo::InParams& in) {
     ASSERT(in.type == SinkTypes::Device);
 
-    if (in.device.down_matrix_enabled) {
+    has_downmix_coefs = in.device.down_matrix_enabled;
+    if (has_downmix_coefs) {
         downmix_coefficients = in.device.down_matrix_coef;
-    } else {
-        downmix_coefficients = {
-            1.0f,   // front
-            0.707f, // center
-            0.0f,   // lfe
-            0.707f, // back
-        };
     }
-
     in_use = in.in_use;
     use_count = in.device.input_count;
     buffers = in.device.input;
@@ -41,6 +34,10 @@ std::vector<u8> SinkContext::OutputBuffers() const {
     return buffer_ret;
 }
 
+bool SinkContext::HasDownMixingCoefficients() const {
+    return has_downmix_coefs;
+}
+
 const DownmixCoefficients& SinkContext::GetDownmixCoefficients() const {
     return downmix_coefficients;
 }

src/audio_core/sink_context.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <array>
-#include <vector>
 #include "audio_core/common.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -84,6 +82,7 @@ public:
     [[nodiscard]] bool InUse() const;
     [[nodiscard]] std::vector<u8> OutputBuffers() const;
 
+    [[nodiscard]] bool HasDownMixingCoefficients() const;
     [[nodiscard]] const DownmixCoefficients& GetDownmixCoefficients() const;
 
 private:
@@ -91,6 +90,7 @@ private:
     s32 use_count{};
     std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> buffers{};
     std::size_t sink_count{};
+    bool has_downmix_coefs{false};
     DownmixCoefficients downmix_coefficients{};
 };
 } // namespace AudioCore

src/audio_core/sink_details.cpp

@@ -11,9 +11,6 @@
 #ifdef HAVE_CUBEB
 #include "audio_core/cubeb_sink.h"
 #endif
-#ifdef HAVE_SDL2
-#include "audio_core/sdl2_sink.h"
-#endif
 #include "common/logging/log.h"
 
 namespace AudioCore {
@@ -38,13 +35,6 @@ constexpr SinkDetails sink_details[] = {
                     return std::make_unique<CubebSink>(device_id);
                 },
                 &ListCubebSinkDevices},
-#endif
-#ifdef HAVE_SDL2
-    SinkDetails{"sdl2",
-                [](std::string_view device_id) -> std::unique_ptr<Sink> {
-                    return std::make_unique<SDLSink>(device_id);
-                },
-                &ListSDLSinkDevices},
 #endif
     SinkDetails{"null",
                 [](std::string_view device_id) -> std::unique_ptr<Sink> {

src/audio_core/stream.cpp

@@ -107,12 +107,9 @@ void Stream::PlayNextBuffer(std::chrono::nanoseconds ns_late) {
     active_buffer = queued_buffers.front();
     queued_buffers.pop();
 
-    auto& samples = active_buffer->GetSamples();
+    VolumeAdjustSamples(active_buffer->GetSamples(), game_volume);
 
-    VolumeAdjustSamples(samples, game_volume);
-
-    sink_stream.EnqueueSamples(GetNumChannels(), samples);
-    played_samples += samples.size();
+    sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
 
     const auto buffer_release_ns = GetBufferReleaseNS(*active_buffer);
 

src/audio_core/stream.h

@@ -89,11 +89,6 @@ public:
         return sample_rate;
     }
 
-    /// Gets the number of samples played so far
-    [[nodiscard]] u64 GetPlayedSampleCount() const {
-        return played_samples;
-    }
-
     /// Gets the number of channels
     [[nodiscard]] u32 GetNumChannels() const;
 
@@ -111,7 +106,6 @@ private:
     [[nodiscard]] std::chrono::nanoseconds GetBufferReleaseNS(const Buffer& buffer) const;
 
     u32 sample_rate;                  ///< Sample rate of the stream
-    u64 played_samples{};             ///< The current played sample count
     Format format;                    ///< Format of the stream
     float game_volume = 1.0f;         ///< The volume the game currently has set
     ReleaseCallback release_callback; ///< Buffer release callback for the stream

src/audio_core/voice_context.cpp

@@ -66,7 +66,7 @@ void ServerVoiceInfo::Initialize() {
     in_params.last_volume = 0.0f;
     in_params.biquad_filter.fill({});
     in_params.wave_buffer_count = 0;
-    in_params.wave_buffer_head = 0;
+    in_params.wave_bufffer_head = 0;
     in_params.mix_id = AudioCommon::NO_MIX;
     in_params.splitter_info_id = AudioCommon::NO_SPLITTER;
     in_params.additional_params_address = 0;
@@ -75,7 +75,7 @@ void ServerVoiceInfo::Initialize() {
     out_params.played_sample_count = 0;
     out_params.wave_buffer_consumed = 0;
     in_params.voice_drop_flag = false;
-    in_params.buffer_mapped = true;
+    in_params.buffer_mapped = false;
     in_params.wave_buffer_flush_request_count = 0;
     in_params.was_biquad_filter_enabled.fill(false);
 
@@ -126,7 +126,7 @@ void ServerVoiceInfo::UpdateParameters(const VoiceInfo::InParams& voice_in,
     in_params.volume = voice_in.volume;
     in_params.biquad_filter = voice_in.biquad_filter;
     in_params.wave_buffer_count = voice_in.wave_buffer_count;
-    in_params.wave_buffer_head = voice_in.wave_buffer_head;
+    in_params.wave_bufffer_head = voice_in.wave_buffer_head;
     if (behavior_info.IsFlushVoiceWaveBuffersSupported()) {
         const auto in_request_count = in_params.wave_buffer_flush_request_count;
         const auto voice_request_count = voice_in.wave_buffer_flush_request_count;
@@ -185,16 +185,14 @@ void ServerVoiceInfo::UpdateWaveBuffers(
             wave_buffer.buffer_size = 0;
             wave_buffer.context_address = 0;
             wave_buffer.context_size = 0;
-            wave_buffer.loop_start_sample = 0;
-            wave_buffer.loop_end_sample = 0;
             wave_buffer.sent_to_dsp = true;
         }
 
         // Mark all our wave buffers as invalid
         for (std::size_t channel = 0; channel < static_cast<std::size_t>(in_params.channel_count);
              channel++) {
-            for (std::size_t i = 0; i < AudioCommon::MAX_WAVE_BUFFERS; ++i) {
-                voice_states[channel]->is_wave_buffer_valid[i] = false;
+            for (auto& is_valid : voice_states[channel]->is_wave_buffer_valid) {
+                is_valid = false;
             }
         }
     }
@@ -213,7 +211,7 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
                                        const WaveBuffer& in_wave_buffer, SampleFormat sample_format,
                                        bool is_buffer_valid,
                                        [[maybe_unused]] BehaviorInfo& behavior_info) {
-    if (!is_buffer_valid && out_wavebuffer.sent_to_dsp && out_wavebuffer.buffer_address != 0) {
+    if (!is_buffer_valid && out_wavebuffer.sent_to_dsp) {
         out_wavebuffer.buffer_address = 0;
         out_wavebuffer.buffer_size = 0;
     }
@@ -221,40 +219,11 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
     if (!in_wave_buffer.sent_to_server || !in_params.buffer_mapped) {
         // Validate sample offset sizings
         if (sample_format == SampleFormat::Pcm16) {
-            const s64 buffer_size = static_cast<s64>(in_wave_buffer.buffer_size);
-            const s64 start = sizeof(s16) * in_wave_buffer.start_sample_offset;
-            const s64 end = sizeof(s16) * in_wave_buffer.end_sample_offset;
-            if (0 > start || start > buffer_size || 0 > end || end > buffer_size) {
+            const auto buffer_size = in_wave_buffer.buffer_size;
+            if (in_wave_buffer.start_sample_offset < 0 || in_wave_buffer.end_sample_offset < 0 ||
+                (buffer_size < (sizeof(s16) * in_wave_buffer.start_sample_offset)) ||
+                (buffer_size < (sizeof(s16) * in_wave_buffer.end_sample_offset))) {
                 // TODO(ogniK): Write error info
-                LOG_ERROR(Audio,
-                          "PCM16 wavebuffer has an invalid size. Buffer has size 0x{:08X}, but "
-                          "offsets were "
-                          "{:08X} - 0x{:08X}",
-                          buffer_size, sizeof(s16) * in_wave_buffer.start_sample_offset,
-                          sizeof(s16) * in_wave_buffer.end_sample_offset);
-                return;
-            }
-        } else if (sample_format == SampleFormat::Adpcm) {
-            const s64 buffer_size = static_cast<s64>(in_wave_buffer.buffer_size);
-            const s64 start_frames = in_wave_buffer.start_sample_offset / 14;
-            const s64 start_extra = in_wave_buffer.start_sample_offset % 14 == 0
-                                        ? 0
-                                        : (in_wave_buffer.start_sample_offset % 14) / 2 + 1 +
-                                              (in_wave_buffer.start_sample_offset % 2);
-            const s64 start = start_frames * 8 + start_extra;
-            const s64 end_frames = in_wave_buffer.end_sample_offset / 14;
-            const s64 end_extra = in_wave_buffer.end_sample_offset % 14 == 0
-                                      ? 0
-                                      : (in_wave_buffer.end_sample_offset % 14) / 2 + 1 +
-                                            (in_wave_buffer.end_sample_offset % 2);
-            const s64 end = end_frames * 8 + end_extra;
-            if (in_wave_buffer.start_sample_offset < 0 || start > buffer_size ||
-                in_wave_buffer.end_sample_offset < 0 || end > buffer_size) {
-                LOG_ERROR(Audio,
-                          "ADPMC wavebuffer has an invalid size. Buffer has size 0x{:08X}, but "
-                          "offsets were "
-                          "{:08X} - 0x{:08X}",
-                          in_wave_buffer.buffer_size, start, end);
                 return;
             }
         }
@@ -270,34 +239,29 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
         out_wavebuffer.buffer_size = in_wave_buffer.buffer_size;
         out_wavebuffer.context_address = in_wave_buffer.context_address;
         out_wavebuffer.context_size = in_wave_buffer.context_size;
-        out_wavebuffer.loop_start_sample = in_wave_buffer.loop_start_sample;
-        out_wavebuffer.loop_end_sample = in_wave_buffer.loop_end_sample;
         in_params.buffer_mapped =
             in_wave_buffer.buffer_address != 0 && in_wave_buffer.buffer_size != 0;
         // TODO(ogniK): Pool mapper attachment
         // TODO(ogniK): IsAdpcmLoopContextBugFixed
-        if (sample_format == SampleFormat::Adpcm && in_wave_buffer.context_address != 0 &&
-            in_wave_buffer.context_size != 0 && behavior_info.IsAdpcmLoopContextBugFixed()) {
-        } else {
-            out_wavebuffer.context_address = 0;
-            out_wavebuffer.context_size = 0;
-        }
     }
 }
 
 void ServerVoiceInfo::WriteOutStatus(
     VoiceInfo::OutParams& voice_out, VoiceInfo::InParams& voice_in,
     std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>& voice_states) {
-    if (voice_in.is_new || in_params.is_new) {
+    if (voice_in.is_new) {
         in_params.is_new = true;
         voice_out.wave_buffer_consumed = 0;
         voice_out.played_sample_count = 0;
         voice_out.voice_dropped = false;
+    } else if (!in_params.is_new) {
+        voice_out.wave_buffer_consumed = voice_states[0]->wave_buffer_consumed;
+        voice_out.played_sample_count = voice_states[0]->played_sample_count;
+        voice_out.voice_dropped = in_params.voice_drop_flag;
     } else {
-        const auto& state = voice_states[0];
-        voice_out.wave_buffer_consumed = state->wave_buffer_consumed;
-        voice_out.played_sample_count = state->played_sample_count;
-        voice_out.voice_dropped = state->voice_dropped;
+        voice_out.wave_buffer_consumed = 0;
+        voice_out.played_sample_count = 0;
+        voice_out.voice_dropped = false;
     }
 }
 
@@ -319,8 +283,7 @@ ServerVoiceInfo::OutParams& ServerVoiceInfo::GetOutParams() {
 
 bool ServerVoiceInfo::ShouldSkip() const {
     // TODO(ogniK): Handle unmapped wave buffers or parameters
-    return !in_params.in_use || in_params.wave_buffer_count == 0 || !in_params.buffer_mapped ||
-           in_params.voice_drop_flag;
+    return !in_params.in_use || (in_params.wave_buffer_count == 0) || in_params.voice_drop_flag;
 }
 
 bool ServerVoiceInfo::UpdateForCommandGeneration(VoiceContext& voice_context) {
@@ -418,7 +381,7 @@ bool ServerVoiceInfo::UpdateParametersForCommandGeneration(
 void ServerVoiceInfo::FlushWaveBuffers(
     u8 flush_count, std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>& dsp_voice_states,
     s32 channel_count) {
-    auto wave_head = in_params.wave_buffer_head;
+    auto wave_head = in_params.wave_bufffer_head;
 
     for (u8 i = 0; i < flush_count; i++) {
         in_params.wave_buffer[wave_head].sent_to_dsp = true;
@@ -438,17 +401,6 @@ bool ServerVoiceInfo::HasValidWaveBuffer(const VoiceState* state) const {
     return std::find(valid_wb.begin(), valid_wb.end(), true) != valid_wb.end();
 }
 
-void ServerVoiceInfo::SetWaveBufferCompleted(VoiceState& dsp_state,
-                                             const ServerWaveBuffer& wave_buffer) {
-    dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index] = false;
-    dsp_state.wave_buffer_consumed++;
-    dsp_state.wave_buffer_index = (dsp_state.wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS;
-    dsp_state.loop_count = 0;
-    if (wave_buffer.end_of_stream) {
-        dsp_state.played_sample_count = 0;
-    }
-}
-
 VoiceContext::VoiceContext(std::size_t voice_count_) : voice_count{voice_count_} {
     for (std::size_t i = 0; i < voice_count; i++) {
         voice_channel_resources.emplace_back(static_cast<s32>(i));

src/audio_core/voice_context.h

@@ -60,12 +60,10 @@ struct WaveBuffer {
     u8 is_looping{};
     u8 end_of_stream{};
     u8 sent_to_server{};
-    INSERT_PADDING_BYTES(1);
-    s32 loop_count{};
+    INSERT_PADDING_BYTES(5);
     u64 context_address{};
     u64 context_size{};
-    u32 loop_start_sample{};
-    u32 loop_end_sample{};
+    INSERT_PADDING_BYTES(8);
 };
 static_assert(sizeof(WaveBuffer) == 0x38, "WaveBuffer is an invalid size");
 
@@ -78,9 +76,6 @@ struct ServerWaveBuffer {
     bool end_of_stream{};
     VAddr context_address{};
     std::size_t context_size{};
-    s32 loop_count{};
-    u32 loop_start_sample{};
-    u32 loop_end_sample{};
     bool sent_to_dsp{true};
 };
 
@@ -113,7 +108,6 @@ struct VoiceState {
     u32 external_context_size;
     bool is_external_context_used;
     bool voice_dropped;
-    s32 loop_count;
 };
 
 class VoiceChannelResource {
@@ -212,7 +206,7 @@ public:
         float last_volume{};
         std::array<BiquadFilterParameter, AudioCommon::MAX_BIQUAD_FILTERS> biquad_filter{};
         s32 wave_buffer_count{};
-        s16 wave_buffer_head{};
+        s16 wave_bufffer_head{};
         INSERT_PADDING_BYTES(2);
         BehaviorFlags behavior_flags{};
         VAddr additional_params_address{};
@@ -258,7 +252,6 @@ public:
     void FlushWaveBuffers(u8 flush_count,
                           std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>& dsp_voice_states,
                           s32 channel_count);
-    void SetWaveBufferCompleted(VoiceState& dsp_state, const ServerWaveBuffer& wave_buffer);
 
 private:
     std::vector<s16> stored_samples;

src/common/CMakeLists.txt

@@ -1,3 +1,8 @@
+# Add a custom command to generate a new shader_cache_version hash when any of the following files change
+# NOTE: This is an approximation of what files affect shader generation, its possible something else
+# could affect the result, but much more unlikely than the following files. Keeping a list of files
+# like this allows for much better caching since it doesn't force the user to recompile binary shaders every update
+set(VIDEO_CORE "${CMAKE_SOURCE_DIR}/src/video_core")
 if (DEFINED ENV{AZURECIREPO})
   set(BUILD_REPOSITORY $ENV{AZURECIREPO})
 endif()
@@ -16,21 +21,77 @@ find_package(Git QUIET)
 
 add_custom_command(OUTPUT scm_rev.cpp
     COMMAND ${CMAKE_COMMAND}
-      -DSRC_DIR=${CMAKE_SOURCE_DIR}
-      -DBUILD_REPOSITORY=${BUILD_REPOSITORY}
-      -DTITLE_BAR_FORMAT_IDLE=${TITLE_BAR_FORMAT_IDLE}
-      -DTITLE_BAR_FORMAT_RUNNING=${TITLE_BAR_FORMAT_RUNNING}
-      -DBUILD_TAG=${BUILD_TAG}
-      -DBUILD_ID=${DISPLAY_VERSION}
-      -DGIT_EXECUTABLE=${GIT_EXECUTABLE}
-      -P ${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake
+      -DSRC_DIR="${CMAKE_SOURCE_DIR}"
+      -DBUILD_REPOSITORY="${BUILD_REPOSITORY}"
+      -DTITLE_BAR_FORMAT_IDLE="${TITLE_BAR_FORMAT_IDLE}"
+      -DTITLE_BAR_FORMAT_RUNNING="${TITLE_BAR_FORMAT_RUNNING}"
+      -DBUILD_TAG="${BUILD_TAG}"
+      -DBUILD_ID="${DISPLAY_VERSION}"
+      -DGIT_EXECUTABLE="${GIT_EXECUTABLE}"
+      -P "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
     DEPENDS
-      # Check that the scm_rev files haven't changed
+      # WARNING! It was too much work to try and make a common location for this list,
+      # so if you need to change it, please update CMakeModules/GenerateSCMRev.cmake as well
+      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+      "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_immediate.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_integer.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_integer_immediate.cpp"
+      "${VIDEO_CORE}/shader/decode/bfe.cpp"
+      "${VIDEO_CORE}/shader/decode/bfi.cpp"
+      "${VIDEO_CORE}/shader/decode/conversion.cpp"
+      "${VIDEO_CORE}/shader/decode/ffma.cpp"
+      "${VIDEO_CORE}/shader/decode/float_set.cpp"
+      "${VIDEO_CORE}/shader/decode/float_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/half_set.cpp"
+      "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/hfma2.cpp"
+      "${VIDEO_CORE}/shader/decode/image.cpp"
+      "${VIDEO_CORE}/shader/decode/integer_set.cpp"
+      "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/memory.cpp"
+      "${VIDEO_CORE}/shader/decode/texture.cpp"
+      "${VIDEO_CORE}/shader/decode/other.cpp"
+      "${VIDEO_CORE}/shader/decode/predicate_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/predicate_set_register.cpp"
+      "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/shift.cpp"
+      "${VIDEO_CORE}/shader/decode/video.cpp"
+      "${VIDEO_CORE}/shader/decode/warp.cpp"
+      "${VIDEO_CORE}/shader/decode/xmad.cpp"
+      "${VIDEO_CORE}/shader/ast.cpp"
+      "${VIDEO_CORE}/shader/ast.h"
+      "${VIDEO_CORE}/shader/compiler_settings.cpp"
+      "${VIDEO_CORE}/shader/compiler_settings.h"
+      "${VIDEO_CORE}/shader/control_flow.cpp"
+      "${VIDEO_CORE}/shader/control_flow.h"
+      "${VIDEO_CORE}/shader/decode.cpp"
+      "${VIDEO_CORE}/shader/expr.cpp"
+      "${VIDEO_CORE}/shader/expr.h"
+      "${VIDEO_CORE}/shader/node.h"
+      "${VIDEO_CORE}/shader/node_helper.cpp"
+      "${VIDEO_CORE}/shader/node_helper.h"
+      "${VIDEO_CORE}/shader/registry.cpp"
+      "${VIDEO_CORE}/shader/registry.h"
+      "${VIDEO_CORE}/shader/shader_ir.cpp"
+      "${VIDEO_CORE}/shader/shader_ir.h"
+      "${VIDEO_CORE}/shader/track.cpp"
+      "${VIDEO_CORE}/shader/transform_feedback.cpp"
+      "${VIDEO_CORE}/shader/transform_feedback.h"
+      # and also check that the scm_rev files haven't changed
       "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in"
       "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
       # technically we should regenerate if the git version changed, but its not worth the effort imo
       "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
-    VERBATIM
 )
 
 add_library(common STATIC
@@ -48,6 +109,8 @@ add_library(common STATIC
     cityhash.cpp
     cityhash.h
     common_funcs.h
+    common_paths.h
+    common_sizes.h
     common_types.h
     concepts.h
     div_ceil.h
@@ -55,23 +118,12 @@ add_library(common STATIC
     dynamic_library.h
     fiber.cpp
     fiber.h
-    fs/file.cpp
-    fs/file.h
-    fs/fs.cpp
-    fs/fs.h
-    fs/fs_paths.h
-    fs/fs_types.h
-    fs/fs_util.cpp
-    fs/fs_util.h
-    fs/path_util.cpp
-    fs/path_util.h
+    file_util.cpp
+    file_util.h
     hash.h
     hex_util.cpp
     hex_util.h
-    host_memory.cpp
-    host_memory.h
     intrusive_red_black_tree.h
-    literals.h
     logging/backend.cpp
     logging/backend.h
     logging/filter.cpp
@@ -79,7 +131,6 @@ add_library(common STATIC
     logging/log.h
     logging/text_formatter.cpp
     logging/text_formatter.h
-    logging/types.h
     lz4_compression.cpp
     lz4_compression.h
     math_util.h
@@ -96,7 +147,6 @@ add_library(common STATIC
     param_package.cpp
     param_package.h
     parent_of_member.h
-    point.h
     quaternion.h
     ring_buffer.h
     scm_rev.cpp
@@ -118,6 +168,7 @@ add_library(common STATIC
     thread.cpp
     thread.h
     thread_queue_list.h
+    thread_worker.cpp
     thread_worker.h
     threadsafe_queue.h
     time_zone.cpp
@@ -125,7 +176,6 @@ add_library(common STATIC
     tiny_mt.h
     tree.h
     uint128.h
-    unique_function.h
     uuid.cpp
     uuid.h
     vector_math.h
@@ -169,7 +219,7 @@ endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
+target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile)
 target_link_libraries(common PRIVATE lz4::lz4 xbyak)
 if (MSVC)
   target_link_libraries(common PRIVATE zstd::zstd)

src/common/common_funcs.h

@@ -97,13 +97,30 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
         return static_cast<T>(key) == 0;                                                           \
     }
 
-#define YUZU_NON_COPYABLE(cls)                                                                     \
-    cls(const cls&) = delete;                                                                      \
-    cls& operator=(const cls&) = delete
+/// Evaluates a boolean expression, and returns a result unless that expression is true.
+#define R_UNLESS(expr, res)                                                                        \
+    {                                                                                              \
+        if (!(expr)) {                                                                             \
+            if (res.IsError()) {                                                                   \
+                LOG_ERROR(Kernel, "Failed with result: {}", res.raw);                              \
+            }                                                                                      \
+            return res;                                                                            \
+        }                                                                                          \
+    }
 
-#define YUZU_NON_MOVEABLE(cls)                                                                     \
-    cls(cls&&) = delete;                                                                           \
-    cls& operator=(cls&&) = delete
+#define R_SUCCEEDED(res) (res.IsSuccess())
+
+/// Evaluates an expression that returns a result, and returns the result if it would fail.
+#define R_TRY(res_expr)                                                                            \
+    {                                                                                              \
+        const auto _tmp_r_try_rc = (res_expr);                                                     \
+        if (_tmp_r_try_rc.IsError()) {                                                             \
+            return _tmp_r_try_rc;                                                                  \
+        }                                                                                          \
+    }
+
+/// Evaluates a boolean expression, and succeeds if that expression is true.
+#define R_SUCCEED_IF(expr) R_UNLESS(!(expr), RESULT_SUCCESS)
 
 namespace Common {
 
@@ -111,19 +128,4 @@ namespace Common {
     return u32(a) | u32(b) << 8 | u32(c) << 16 | u32(d) << 24;
 }
 
-// std::size() does not support zero-size C arrays. We're fixing that.
-template <class C>
-constexpr auto Size(const C& c) -> decltype(c.size()) {
-    return std::size(c);
-}
-
-template <class C>
-constexpr std::size_t Size(const C& c) {
-    if constexpr (sizeof(C) == 0) {
-        return 0;
-    } else {
-        return std::size(c);
-    }
-}
-
 } // namespace Common

src/common/common_paths.h

@@ -0,0 +1,52 @@
+// 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
+
+// Directory separators, do we need this?
+#define DIR_SEP "/"
+#define DIR_SEP_CHR '/'
+
+#ifndef MAX_PATH
+#define MAX_PATH 260
+#endif
+
+// The user data dir
+#define ROOT_DIR "."
+#define USERDATA_DIR "user"
+#ifdef USER_DIR
+#define EMU_DATA_DIR USER_DIR
+#else
+#define EMU_DATA_DIR "yuzu"
+#endif
+
+// Dirs in both User and Sys
+#define EUR_DIR "EUR"
+#define USA_DIR "USA"
+#define JAP_DIR "JAP"
+
+// Subdirs in the User dir returned by GetUserPath(UserPath::UserDir)
+#define CONFIG_DIR "config"
+#define CACHE_DIR "cache"
+#define SDMC_DIR "sdmc"
+#define NAND_DIR "nand"
+#define SYSDATA_DIR "sysdata"
+#define KEYS_DIR "keys"
+#define LOAD_DIR "load"
+#define DUMP_DIR "dump"
+#define SCREENSHOTS_DIR "screenshots"
+#define SHADER_DIR "shader"
+#define LOG_DIR "log"
+
+// Filenames
+// Files in the directory returned by GetUserPath(UserPath::ConfigDir)
+#define EMU_CONFIG "emu.ini"
+#define DEBUGGER_CONFIG "debugger.ini"
+#define LOGGER_CONFIG "logger.ini"
+// Files in the directory returned by GetUserPath(UserPath::LogDir)
+#define LOG_FILE "yuzu_log.txt"
+
+// Sys files
+#define SHARED_FONT "shared_font.bin"
+#define AES_KEYS "aes_keys.txt"

src/common/common_sizes.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 <limits>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+enum : u64 {
+    Size_1_KB = 0x400ULL,
+    Size_64_KB = 64ULL * Size_1_KB,
+    Size_128_KB = 128ULL * Size_1_KB,
+    Size_1_MB = 0x100000ULL,
+    Size_2_MB = 2ULL * Size_1_MB,
+    Size_4_MB = 4ULL * Size_1_MB,
+    Size_5_MB = 5ULL * Size_1_MB,
+    Size_14_MB = 14ULL * Size_1_MB,
+    Size_32_MB = 32ULL * Size_1_MB,
+    Size_33_MB = 33ULL * Size_1_MB,
+    Size_128_MB = 128ULL * Size_1_MB,
+    Size_448_MB = 448ULL * Size_1_MB,
+    Size_507_MB = 507ULL * Size_1_MB,
+    Size_562_MB = 562ULL * Size_1_MB,
+    Size_1554_MB = 1554ULL * Size_1_MB,
+    Size_2048_MB = 2048ULL * Size_1_MB,
+    Size_2193_MB = 2193ULL * Size_1_MB,
+    Size_3285_MB = 3285ULL * Size_1_MB,
+    Size_4916_MB = 4916ULL * Size_1_MB,
+    Size_1_GB = 0x40000000ULL,
+    Size_2_GB = 2ULL * Size_1_GB,
+    Size_4_GB = 4ULL * Size_1_GB,
+    Size_6_GB = 6ULL * Size_1_GB,
+    Size_8_GB = 8ULL * Size_1_GB,
+    Size_64_GB = 64ULL * Size_1_GB,
+    Size_512_GB = 512ULL * Size_1_GB,
+    Size_Invalid = std::numeric_limits<u64>::max(),
+};
+
+} // namespace Common

src/common/detached_tasks.cpp

@@ -21,8 +21,6 @@ void DetachedTasks::WaitForAllTasks() {
 }
 
 DetachedTasks::~DetachedTasks() {
-    WaitForAllTasks();
-
     std::unique_lock lock{mutex};
     ASSERT(count == 0);
     instance = nullptr;

src/common/file_util.h

@@ -0,0 +1,298 @@
+// 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 <array>
+#include <cstdio>
+#include <fstream>
+#include <functional>
+#include <limits>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+#include "common/common_types.h"
+#ifdef _MSC_VER
+#include "common/string_util.h"
+#endif
+
+namespace Common::FS {
+
+// User paths for GetUserPath
+enum class UserPath {
+    CacheDir,
+    ConfigDir,
+    KeysDir,
+    LogDir,
+    NANDDir,
+    RootDir,
+    SDMCDir,
+    LoadDir,
+    DumpDir,
+    ScreenshotsDir,
+    ShaderDir,
+    SysDataDir,
+    UserDir,
+};
+
+// FileSystem tree node/
+struct FSTEntry {
+    bool isDirectory;
+    u64 size;                 // file length or number of entries from children
+    std::string physicalName; // name on disk
+    std::string virtualName;  // name in FST names table
+    std::vector<FSTEntry> children;
+};
+
+// Returns true if file filename exists
+[[nodiscard]] bool Exists(const std::string& filename);
+
+// Returns true if filename is a directory
+[[nodiscard]] bool IsDirectory(const std::string& filename);
+
+// Returns the size of filename (64bit)
+[[nodiscard]] u64 GetSize(const std::string& filename);
+
+// Overloaded GetSize, accepts file descriptor
+[[nodiscard]] u64 GetSize(int fd);
+
+// Overloaded GetSize, accepts FILE*
+[[nodiscard]] u64 GetSize(FILE* f);
+
+// Returns true if successful, or path already exists.
+bool CreateDir(const std::string& filename);
+
+// Creates the full path of fullPath returns true on success
+bool CreateFullPath(const std::string& fullPath);
+
+// Deletes a given filename, return true on success
+// Doesn't supports deleting a directory
+bool Delete(const std::string& filename);
+
+// Deletes a directory filename, returns true on success
+bool DeleteDir(const std::string& filename);
+
+// renames file srcFilename to destFilename, returns true on success
+bool Rename(const std::string& srcFilename, const std::string& destFilename);
+
+// copies file srcFilename to destFilename, returns true on success
+bool Copy(const std::string& srcFilename, const std::string& destFilename);
+
+// creates an empty file filename, returns true on success
+bool CreateEmptyFile(const std::string& filename);
+
+/**
+ * @param num_entries_out to be assigned by the callable with the number of iterated directory
+ * entries, never null
+ * @param directory the path to the enclosing directory
+ * @param virtual_name the entry name, without any preceding directory info
+ * @return whether handling the entry succeeded
+ */
+using DirectoryEntryCallable = std::function<bool(
+    u64* num_entries_out, const std::string& directory, const std::string& virtual_name)>;
+
+/**
+ * Scans a directory, calling the callback for each file/directory contained within.
+ * If the callback returns failure, scanning halts and this function returns failure as well
+ * @param num_entries_out assigned by the function with the number of iterated directory entries,
+ * can be null
+ * @param directory the directory to scan
+ * @param callback The callback which will be called for each entry
+ * @return whether scanning the directory succeeded
+ */
+bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
+                           DirectoryEntryCallable callback);
+
+/**
+ * Scans the directory tree, storing the results.
+ * @param directory the parent directory to start scanning from
+ * @param parent_entry FSTEntry where the filesystem tree results will be stored.
+ * @param recursion Number of children directories to read before giving up.
+ * @return the total number of files/directories found
+ */
+u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
+                      unsigned int recursion = 0);
+
+// deletes the given directory and anything under it. Returns true on success.
+bool DeleteDirRecursively(const std::string& directory, unsigned int recursion = 256);
+
+// Returns the current directory
+[[nodiscard]] std::optional<std::string> GetCurrentDir();
+
+// Create directory and copy contents (does not overwrite existing files)
+void CopyDir(const std::string& source_path, const std::string& dest_path);
+
+// Set the current directory to given directory
+bool SetCurrentDir(const std::string& directory);
+
+// Returns a pointer to a string with a yuzu data dir in the user's home
+// directory. To be used in "multi-user" mode (that is, installed).
+const std::string& GetUserPath(UserPath path, const std::string& new_path = "");
+
+[[nodiscard]] std::string GetHactoolConfigurationPath();
+
+[[nodiscard]] std::string GetNANDRegistrationDir(bool system = false);
+
+// Returns the path to where the sys file are
+[[nodiscard]] std::string GetSysDirectory();
+
+#ifdef __APPLE__
+[[nodiscard]] std::string GetBundleDirectory();
+#endif
+
+#ifdef _WIN32
+[[nodiscard]] const std::string& GetExeDirectory();
+[[nodiscard]] std::string AppDataRoamingDirectory();
+#endif
+
+std::size_t WriteStringToFile(bool text_file, const std::string& filename, std::string_view str);
+
+std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str);
+
+/**
+ * Splits the filename into 8.3 format
+ * Loosely implemented following https://en.wikipedia.org/wiki/8.3_filename
+ * @param filename The normal filename to use
+ * @param short_name A 9-char array in which the short name will be written
+ * @param extension A 4-char array in which the extension will be written
+ */
+void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
+                     std::array<char, 4>& extension);
+
+// Splits the path on '/' or '\' and put the components into a vector
+// i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
+[[nodiscard]] std::vector<std::string> SplitPathComponents(std::string_view filename);
+
+// Gets all of the text up to the last '/' or '\' in the path.
+[[nodiscard]] std::string_view GetParentPath(std::string_view path);
+
+// Gets all of the text after the first '/' or '\' in the path.
+[[nodiscard]] std::string_view GetPathWithoutTop(std::string_view path);
+
+// Gets the filename of the path
+[[nodiscard]] std::string_view GetFilename(std::string_view path);
+
+// Gets the extension of the filename
+[[nodiscard]] std::string_view GetExtensionFromFilename(std::string_view name);
+
+// Removes the final '/' or '\' if one exists
+[[nodiscard]] std::string_view RemoveTrailingSlash(std::string_view path);
+
+// Creates a new vector containing indices [first, last) from the original.
+template <typename T>
+[[nodiscard]] std::vector<T> SliceVector(const std::vector<T>& vector, std::size_t first,
+                                         std::size_t last) {
+    if (first >= last) {
+        return {};
+    }
+    last = std::min<std::size_t>(last, vector.size());
+    return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
+}
+
+enum class DirectorySeparator {
+    ForwardSlash,
+    BackwardSlash,
+    PlatformDefault,
+};
+
+// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
+// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
+[[nodiscard]] std::string SanitizePath(
+    std::string_view path,
+    DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
+
+// To deal with Windows being dumb at Unicode
+template <typename T>
+void OpenFStream(T& fstream, const std::string& filename, std::ios_base::openmode openmode) {
+#ifdef _MSC_VER
+    fstream.open(Common::UTF8ToUTF16W(filename), openmode);
+#else
+    fstream.open(filename, openmode);
+#endif
+}
+
+// simple wrapper for cstdlib file functions to
+// hopefully will make error checking easier
+// and make forgetting an fclose() harder
+class IOFile : public NonCopyable {
+public:
+    IOFile();
+    // flags is used for windows specific file open mode flags, which
+    // allows yuzu to open the logs in shared write mode, so that the file
+    // isn't considered "locked" while yuzu is open and people can open the log file and view it
+    IOFile(const std::string& filename, const char openmode[], int flags = 0);
+
+    ~IOFile();
+
+    IOFile(IOFile&& other) noexcept;
+    IOFile& operator=(IOFile&& other) noexcept;
+
+    void Swap(IOFile& other) noexcept;
+
+    bool Open(const std::string& filename, const char openmode[], int flags = 0);
+    bool Close();
+
+    template <typename T>
+    std::size_t ReadArray(T* data, std::size_t length) const {
+        static_assert(std::is_trivially_copyable_v<T>,
+                      "Given array does not consist of trivially copyable objects");
+
+        return ReadImpl(data, length, sizeof(T));
+    }
+
+    template <typename T>
+    std::size_t WriteArray(const T* data, std::size_t length) {
+        static_assert(std::is_trivially_copyable_v<T>,
+                      "Given array does not consist of trivially copyable objects");
+
+        return WriteImpl(data, length, sizeof(T));
+    }
+
+    template <typename T>
+    std::size_t ReadBytes(T* data, std::size_t length) const {
+        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+        return ReadArray(reinterpret_cast<char*>(data), length);
+    }
+
+    template <typename T>
+    std::size_t WriteBytes(const T* data, std::size_t length) {
+        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+        return WriteArray(reinterpret_cast<const char*>(data), length);
+    }
+
+    template <typename T>
+    std::size_t WriteObject(const T& object) {
+        static_assert(!std::is_pointer_v<T>, "WriteObject arguments must not be a pointer");
+        return WriteArray(&object, 1);
+    }
+
+    std::size_t WriteString(std::string_view str) {
+        return WriteArray(str.data(), str.length());
+    }
+
+    [[nodiscard]] bool IsOpen() const {
+        return nullptr != m_file;
+    }
+
+    bool Seek(s64 off, int origin) const;
+    [[nodiscard]] u64 Tell() const;
+    [[nodiscard]] u64 GetSize() const;
+    bool Resize(u64 size);
+    bool Flush();
+
+    // clear error state
+    void Clear() {
+        std::clearerr(m_file);
+    }
+
+private:
+    std::size_t ReadImpl(void* data, std::size_t length, std::size_t data_size) const;
+    std::size_t WriteImpl(const void* data, std::size_t length, std::size_t data_size);
+
+    std::FILE* m_file = nullptr;
+};
+
+} // namespace Common::FS

src/common/fs/file.cpp

@@ -1,417 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/fs/file.h"
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
-#include "common/logging/log.h"
-
-#ifdef _WIN32
-#include <io.h>
-#include <share.h>
-#else
-#include <unistd.h>
-#endif
-
-#ifdef _MSC_VER
-#define fileno _fileno
-#define fseeko _fseeki64
-#define ftello _ftelli64
-#endif
-
-namespace Common::FS {
-
-namespace fs = std::filesystem;
-
-namespace {
-
-#ifdef _WIN32
-
-/**
- * Converts the file access mode and file type enums to a file access mode wide string.
- *
- * @param mode File access mode
- * @param type File type
- *
- * @returns A pointer to a wide string representing the file access mode.
- */
-[[nodiscard]] constexpr const wchar_t* AccessModeToWStr(FileAccessMode mode, FileType type) {
-    switch (type) {
-    case FileType::BinaryFile:
-        switch (mode) {
-        case FileAccessMode::Read:
-            return L"rb";
-        case FileAccessMode::Write:
-            return L"wb";
-        case FileAccessMode::Append:
-            return L"ab";
-        case FileAccessMode::ReadWrite:
-            return L"r+b";
-        case FileAccessMode::ReadAppend:
-            return L"a+b";
-        }
-        break;
-    case FileType::TextFile:
-        switch (mode) {
-        case FileAccessMode::Read:
-            return L"r";
-        case FileAccessMode::Write:
-            return L"w";
-        case FileAccessMode::Append:
-            return L"a";
-        case FileAccessMode::ReadWrite:
-            return L"r+";
-        case FileAccessMode::ReadAppend:
-            return L"a+";
-        }
-        break;
-    }
-
-    return L"";
-}
-
-/**
- * Converts the file-share access flag enum to a Windows defined file-share access flag.
- *
- * @param flag File-share access flag
- *
- * @returns Windows defined file-share access flag.
- */
-[[nodiscard]] constexpr int ToWindowsFileShareFlag(FileShareFlag flag) {
-    switch (flag) {
-    case FileShareFlag::ShareNone:
-    default:
-        return _SH_DENYRW;
-    case FileShareFlag::ShareReadOnly:
-        return _SH_DENYWR;
-    case FileShareFlag::ShareWriteOnly:
-        return _SH_DENYRD;
-    case FileShareFlag::ShareReadWrite:
-        return _SH_DENYNO;
-    }
-}
-
-#else
-
-/**
- * Converts the file access mode and file type enums to a file access mode string.
- *
- * @param mode File access mode
- * @param type File type
- *
- * @returns A pointer to a string representing the file access mode.
- */
-[[nodiscard]] constexpr const char* AccessModeToStr(FileAccessMode mode, FileType type) {
-    switch (type) {
-    case FileType::BinaryFile:
-        switch (mode) {
-        case FileAccessMode::Read:
-            return "rb";
-        case FileAccessMode::Write:
-            return "wb";
-        case FileAccessMode::Append:
-            return "ab";
-        case FileAccessMode::ReadWrite:
-            return "r+b";
-        case FileAccessMode::ReadAppend:
-            return "a+b";
-        }
-        break;
-    case FileType::TextFile:
-        switch (mode) {
-        case FileAccessMode::Read:
-            return "r";
-        case FileAccessMode::Write:
-            return "w";
-        case FileAccessMode::Append:
-            return "a";
-        case FileAccessMode::ReadWrite:
-            return "r+";
-        case FileAccessMode::ReadAppend:
-            return "a+";
-        }
-        break;
-    }
-
-    return "";
-}
-
-#endif
-
-/**
- * Converts the seek origin enum to a seek origin integer.
- *
- * @param origin Seek origin
- *
- * @returns Seek origin integer.
- */
-[[nodiscard]] constexpr int ToSeekOrigin(SeekOrigin origin) {
-    switch (origin) {
-    case SeekOrigin::SetOrigin:
-    default:
-        return SEEK_SET;
-    case SeekOrigin::CurrentPosition:
-        return SEEK_CUR;
-    case SeekOrigin::End:
-        return SEEK_END;
-    }
-}
-
-} // Anonymous namespace
-
-std::string ReadStringFromFile(const std::filesystem::path& path, FileType type) {
-    if (!IsFile(path)) {
-        return "";
-    }
-
-    IOFile io_file{path, FileAccessMode::Read, type};
-
-    return io_file.ReadString(io_file.GetSize());
-}
-
-size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
-                         std::string_view string) {
-    if (Exists(path) && !IsFile(path)) {
-        return 0;
-    }
-
-    IOFile io_file{path, FileAccessMode::Write, type};
-
-    return io_file.WriteString(string);
-}
-
-size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
-                          std::string_view string) {
-    if (Exists(path) && !IsFile(path)) {
-        return 0;
-    }
-
-    IOFile io_file{path, FileAccessMode::Append, type};
-
-    return io_file.WriteString(string);
-}
-
-IOFile::IOFile() = default;
-
-IOFile::IOFile(const std::string& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
-    Open(path, mode, type, flag);
-}
-
-IOFile::IOFile(std::string_view path, FileAccessMode mode, FileType type, FileShareFlag flag) {
-    Open(path, mode, type, flag);
-}
-
-IOFile::IOFile(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
-    Open(path, mode, type, flag);
-}
-
-IOFile::~IOFile() {
-    Close();
-}
-
-IOFile::IOFile(IOFile&& other) noexcept {
-    std::swap(file_path, other.file_path);
-    std::swap(file_access_mode, other.file_access_mode);
-    std::swap(file_type, other.file_type);
-    std::swap(file, other.file);
-}
-
-IOFile& IOFile::operator=(IOFile&& other) noexcept {
-    std::swap(file_path, other.file_path);
-    std::swap(file_access_mode, other.file_access_mode);
-    std::swap(file_type, other.file_type);
-    std::swap(file, other.file);
-    return *this;
-}
-
-fs::path IOFile::GetPath() const {
-    return file_path;
-}
-
-FileAccessMode IOFile::GetAccessMode() const {
-    return file_access_mode;
-}
-
-FileType IOFile::GetType() const {
-    return file_type;
-}
-
-void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
-    Close();
-
-    file_path = path;
-    file_access_mode = mode;
-    file_type = type;
-
-    errno = 0;
-
-#ifdef _WIN32
-    if (flag != FileShareFlag::ShareNone) {
-        file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
-    } else {
-        _wfopen_s(&file, path.c_str(), AccessModeToWStr(mode, type));
-    }
-#else
-    file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
-#endif
-
-    if (!IsOpen()) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to open the file at path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
-    }
-}
-
-void IOFile::Close() {
-    if (!IsOpen()) {
-        return;
-    }
-
-    errno = 0;
-
-    const auto close_result = std::fclose(file) == 0;
-
-    if (!close_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to close the file at path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
-    }
-
-    file = nullptr;
-}
-
-bool IOFile::IsOpen() const {
-    return file != nullptr;
-}
-
-std::string IOFile::ReadString(size_t length) const {
-    std::vector<char> string_buffer(length);
-
-    const auto chars_read = ReadSpan<char>(string_buffer);
-    const auto string_size = chars_read != length ? chars_read : length;
-
-    return std::string{string_buffer.data(), string_size};
-}
-
-size_t IOFile::WriteString(std::span<const char> string) const {
-    return WriteSpan(string);
-}
-
-bool IOFile::Flush() const {
-    if (!IsOpen()) {
-        return false;
-    }
-
-    errno = 0;
-
-#ifdef _WIN32
-    const auto flush_result = std::fflush(file) == 0;
-#else
-    const auto flush_result = std::fflush(file) == 0;
-#endif
-
-    if (!flush_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to flush the file at path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
-    }
-
-    return flush_result;
-}
-
-bool IOFile::Commit() const {
-    if (!IsOpen()) {
-        return false;
-    }
-
-    errno = 0;
-
-#ifdef _WIN32
-    const auto commit_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
-#else
-    const auto commit_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
-#endif
-
-    if (!commit_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to commit the file at path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
-    }
-
-    return commit_result;
-}
-
-bool IOFile::SetSize(u64 size) const {
-    if (!IsOpen()) {
-        return false;
-    }
-
-    errno = 0;
-
-#ifdef _WIN32
-    const auto set_size_result = _chsize_s(fileno(file), static_cast<s64>(size)) == 0;
-#else
-    const auto set_size_result = ftruncate(fileno(file), static_cast<s64>(size)) == 0;
-#endif
-
-    if (!set_size_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={}, size={}, ec_message={}",
-                  PathToUTF8String(file_path), size, ec.message());
-    }
-
-    return set_size_result;
-}
-
-u64 IOFile::GetSize() const {
-    if (!IsOpen()) {
-        return 0;
-    }
-
-    // Flush any unwritten buffered data into the file prior to retrieving the file size.
-    std::fflush(file);
-
-    std::error_code ec;
-
-    const auto file_size = fs::file_size(file_path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
-        return 0;
-    }
-
-    return file_size;
-}
-
-bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
-    if (!IsOpen()) {
-        return false;
-    }
-
-    errno = 0;
-
-    const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
-
-    if (!seek_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to seek the file at path={}, offset={}, origin={}, ec_message={}",
-                  PathToUTF8String(file_path), offset, origin, ec.message());
-    }
-
-    return seek_result;
-}
-
-s64 IOFile::Tell() const {
-    if (!IsOpen()) {
-        return 0;
-    }
-
-    errno = 0;
-
-    return ftello(file);
-}
-
-} // namespace Common::FS

src/common/fs/file.h

@@ -1,463 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstdio>
-#include <filesystem>
-#include <fstream>
-#include <span>
-#include <type_traits>
-#include <vector>
-
-#include "common/concepts.h"
-#include "common/fs/fs_types.h"
-#include "common/fs/fs_util.h"
-
-namespace Common::FS {
-
-enum class SeekOrigin {
-    SetOrigin,       // Seeks from the start of the file.
-    CurrentPosition, // Seeks from the current file pointer position.
-    End,             // Seeks from the end of the file.
-};
-
-/**
- * Opens a file stream at path with the specified open mode.
- *
- * @param file_stream Reference to file stream
- * @param path Filesystem path
- * @param open_mode File stream open mode
- */
-template <typename FileStream>
-void OpenFileStream(FileStream& file_stream, const std::filesystem::path& path,
-                    std::ios_base::openmode open_mode) {
-    file_stream.open(path, open_mode);
-}
-
-#ifdef _WIN32
-template <typename FileStream, typename Path>
-void OpenFileStream(FileStream& file_stream, const Path& path, std::ios_base::openmode open_mode) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        file_stream.open(ToU8String(path), open_mode);
-    } else {
-        file_stream.open(std::filesystem::path{path}, open_mode);
-    }
-}
-#endif
-
-/**
- * Reads an entire file at path and returns a string of the contents read from the file.
- * If the filesystem object at path is not a regular file, this function returns an empty string.
- *
- * @param path Filesystem path
- * @param type File type
- *
- * @returns A string of the contents read from the file.
- */
-[[nodiscard]] std::string ReadStringFromFile(const std::filesystem::path& path, FileType type);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] std::string ReadStringFromFile(const Path& path, FileType type) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return ReadStringFromFile(ToU8String(path), type);
-    } else {
-        return ReadStringFromFile(std::filesystem::path{path}, type);
-    }
-}
-#endif
-
-/**
- * Writes a string to a file at path and returns the number of characters successfully written.
- * If a file already exists at path, its contents will be erased.
- * If a file does not exist at path, it creates and opens a new empty file for writing.
- * If the filesystem object at path exists and is not a regular file, this function returns 0.
- *
- * @param path Filesystem path
- * @param type File type
- *
- * @returns Number of characters successfully written.
- */
-[[nodiscard]] size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
-                                       std::string_view string);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] size_t WriteStringToFile(const Path& path, FileType type, std::string_view string) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return WriteStringToFile(ToU8String(path), type, string);
-    } else {
-        return WriteStringToFile(std::filesystem::path{path}, type, string);
-    }
-}
-#endif
-
-/**
- * Appends a string to a file at path and returns the number of characters successfully written.
- * If a file does not exist at path, it creates and opens a new empty file for appending.
- * If the filesystem object at path exists and is not a regular file, this function returns 0.
- *
- * @param path Filesystem path
- * @param type File type
- *
- * @returns Number of characters successfully written.
- */
-[[nodiscard]] size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
-                                        std::string_view string);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] size_t AppendStringToFile(const Path& path, FileType type, std::string_view string) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return AppendStringToFile(ToU8String(path), type, string);
-    } else {
-        return AppendStringToFile(std::filesystem::path{path}, type, string);
-    }
-}
-#endif
-
-class IOFile final {
-public:
-    IOFile();
-
-    explicit IOFile(const std::string& path, FileAccessMode mode,
-                    FileType type = FileType::BinaryFile,
-                    FileShareFlag flag = FileShareFlag::ShareReadOnly);
-
-    explicit IOFile(std::string_view path, FileAccessMode mode,
-                    FileType type = FileType::BinaryFile,
-                    FileShareFlag flag = FileShareFlag::ShareReadOnly);
-
-    /**
-     * An IOFile is a lightweight wrapper on C Library file operations.
-     * Automatically closes an open file on the destruction of an IOFile object.
-     *
-     * @param path Filesystem path
-     * @param mode File access mode
-     * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
-     * @param flag (Windows only) File-share access flag, default is ShareReadOnly
-     */
-    explicit IOFile(const std::filesystem::path& path, FileAccessMode mode,
-                    FileType type = FileType::BinaryFile,
-                    FileShareFlag flag = FileShareFlag::ShareReadOnly);
-
-    ~IOFile();
-
-    IOFile(const IOFile&) = delete;
-    IOFile& operator=(const IOFile&) = delete;
-
-    IOFile(IOFile&& other) noexcept;
-    IOFile& operator=(IOFile&& other) noexcept;
-
-    /**
-     * Gets the path of the file.
-     *
-     * @returns The path of the file.
-     */
-    [[nodiscard]] std::filesystem::path GetPath() const;
-
-    /**
-     * Gets the access mode of the file.
-     *
-     * @returns The access mode of the file.
-     */
-    [[nodiscard]] FileAccessMode GetAccessMode() const;
-
-    /**
-     * Gets the type of the file.
-     *
-     * @returns The type of the file.
-     */
-    [[nodiscard]] FileType GetType() const;
-
-    /**
-     * Opens a file at path with the specified file access mode.
-     * This function behaves differently depending on the FileAccessMode.
-     * These behaviors are documented in each enum value of FileAccessMode.
-     *
-     * @param path Filesystem path
-     * @param mode File access mode
-     * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
-     * @param flag (Windows only) File-share access flag, default is ShareReadOnly
-     */
-    void Open(const std::filesystem::path& path, FileAccessMode mode,
-              FileType type = FileType::BinaryFile,
-              FileShareFlag flag = FileShareFlag::ShareReadOnly);
-
-#ifdef _WIN32
-    template <typename Path>
-    [[nodiscard]] void Open(const Path& path, FileAccessMode mode,
-                            FileType type = FileType::BinaryFile,
-                            FileShareFlag flag = FileShareFlag::ShareReadOnly) {
-        using ValueType = typename Path::value_type;
-        if constexpr (IsChar<ValueType>) {
-            Open(ToU8String(path), mode, type, flag);
-        } else {
-            Open(std::filesystem::path{path}, mode, type, flag);
-        }
-    }
-#endif
-
-    /// Closes the file if it is opened.
-    void Close();
-
-    /**
-     * Checks whether the file is open.
-     * Use this to check whether the calls to Open() or Close() succeeded.
-     *
-     * @returns True if the file is open, false otherwise.
-     */
-    [[nodiscard]] bool IsOpen() const;
-
-    /**
-     * Helper function which deduces the value type of a contiguous STL container used in ReadSpan.
-     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
-     * ReadObject and T must be a trivially copyable object.
-     *
-     * See ReadSpan for more details if T is a contiguous container.
-     * See ReadObject for more details if T is a trivially copyable object.
-     *
-     * @tparam T Contiguous container or trivially copyable object
-     *
-     * @param data Container of T::value_type data or reference to object
-     *
-     * @returns Count of T::value_type data or objects successfully read.
-     */
-    template <typename T>
-    [[nodiscard]] size_t Read(T& data) const {
-        if constexpr (IsSTLContainer<T>) {
-            using ContiguousType = typename T::value_type;
-            static_assert(std::is_trivially_copyable_v<ContiguousType>,
-                          "Data type must be trivially copyable.");
-            return ReadSpan<ContiguousType>(data);
-        } else {
-            return ReadObject(data) ? 1 : 0;
-        }
-    }
-
-    /**
-     * Helper function which deduces the value type of a contiguous STL container used in WriteSpan.
-     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
-     * WriteObject and T must be a trivially copyable object.
-     *
-     * See WriteSpan for more details if T is a contiguous container.
-     * See WriteObject for more details if T is a trivially copyable object.
-     *
-     * @tparam T Contiguous container or trivially copyable object
-     *
-     * @param data Container of T::value_type data or const reference to object
-     *
-     * @returns Count of T::value_type data or objects successfully written.
-     */
-    template <typename T>
-    [[nodiscard]] size_t Write(const T& data) const {
-        if constexpr (IsSTLContainer<T>) {
-            using ContiguousType = typename T::value_type;
-            static_assert(std::is_trivially_copyable_v<ContiguousType>,
-                          "Data type must be trivially copyable.");
-            return WriteSpan<ContiguousType>(data);
-        } else {
-            static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-            return WriteObject(data) ? 1 : 0;
-        }
-    }
-
-    /**
-     * Reads a span of T data from a file sequentially.
-     * This function reads from the current position of the file pointer and
-     * advances it by the (count of T * sizeof(T)) bytes successfully read.
-     *
-     * Failures occur when:
-     * - The file is not open
-     * - The opened file lacks read permissions
-     * - Attempting to read beyond the end-of-file
-     *
-     * @tparam T Data type
-     *
-     * @param data Span of T data
-     *
-     * @returns Count of T data successfully read.
-     */
-    template <typename T>
-    [[nodiscard]] size_t ReadSpan(std::span<T> data) const {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-
-        if (!IsOpen()) {
-            return 0;
-        }
-
-        return std::fread(data.data(), sizeof(T), data.size(), file);
-    }
-
-    /**
-     * Writes a span of T data to a file sequentially.
-     * This function writes from the current position of the file pointer and
-     * advances it by the (count of T * sizeof(T)) bytes successfully written.
-     *
-     * Failures occur when:
-     * - The file is not open
-     * - The opened file lacks write permissions
-     *
-     * @tparam T Data type
-     *
-     * @param data Span of T data
-     *
-     * @returns Count of T data successfully written.
-     */
-    template <typename T>
-    [[nodiscard]] size_t WriteSpan(std::span<const T> data) const {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-
-        if (!IsOpen()) {
-            return 0;
-        }
-
-        return std::fwrite(data.data(), sizeof(T), data.size(), file);
-    }
-
-    /**
-     * Reads a T object from a file sequentially.
-     * This function reads from the current position of the file pointer and
-     * advances it by the sizeof(T) bytes successfully read.
-     *
-     * Failures occur when:
-     * - The file is not open
-     * - The opened file lacks read permissions
-     * - Attempting to read beyond the end-of-file
-     *
-     * @tparam T Data type
-     *
-     * @param object Reference to object
-     *
-     * @returns True if the object is successfully read from the file, false otherwise.
-     */
-    template <typename T>
-    [[nodiscard]] bool ReadObject(T& object) const {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-        static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
-
-        if (!IsOpen()) {
-            return false;
-        }
-
-        return std::fread(&object, sizeof(T), 1, file) == 1;
-    }
-
-    /**
-     * Writes a T object to a file sequentially.
-     * This function writes from the current position of the file pointer and
-     * advances it by the sizeof(T) bytes successfully written.
-     *
-     * Failures occur when:
-     * - The file is not open
-     * - The opened file lacks write permissions
-     *
-     * @tparam T Data type
-     *
-     * @param object Const reference to object
-     *
-     * @returns True if the object is successfully written to the file, false otherwise.
-     */
-    template <typename T>
-    [[nodiscard]] bool WriteObject(const T& object) const {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-        static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
-
-        if (!IsOpen()) {
-            return false;
-        }
-
-        return std::fwrite(&object, sizeof(T), 1, file) == 1;
-    }
-
-    /**
-     * Specialized function to read a string of a given length from a file sequentially.
-     * This function writes from the current position of the file pointer and
-     * advances it by the number of characters successfully read.
-     * The size of the returned string may not match length if not all bytes are successfully read.
-     *
-     * @param length Length of the string
-     *
-     * @returns A string read from the file.
-     */
-    [[nodiscard]] std::string ReadString(size_t length) const;
-
-    /**
-     * Specialized function to write a string to a file sequentially.
-     * This function writes from the current position of the file pointer and
-     * advances it by the number of characters successfully written.
-     *
-     * @param string Span of const char backed std::string or std::string_view
-     *
-     * @returns Number of characters successfully written.
-     */
-    [[nodiscard]] size_t WriteString(std::span<const char> string) const;
-
-    /**
-     * Attempts to flush any unwritten buffered data into the file.
-     *
-     * @returns True if the flush was successful, false otherwise.
-     */
-    bool Flush() const;
-
-    /**
-     * Attempts to commit the file into the disk.
-     * Note that this is an expensive operation as this forces the operating system to write
-     * the contents of the file associated with the file descriptor into the disk.
-     *
-     * @returns True if the commit was successful, false otherwise.
-     */
-    bool Commit() const;
-
-    /**
-     * Resizes the file to a given size.
-     * If the file is resized to a smaller size, the remainder of the file is discarded.
-     * If the file is resized to a larger size, the new area appears as if zero-filled.
-     *
-     * Failures occur when:
-     * - The file is not open
-     *
-     * @param size File size in bytes
-     *
-     * @returns True if the file resize succeeded, false otherwise.
-     */
-    [[nodiscard]] bool SetSize(u64 size) const;
-
-    /**
-     * Gets the size of the file.
-     *
-     * Failures occur when:
-     * - The file is not open
-     *
-     * @returns The file size in bytes of the file. Returns 0 on failure.
-     */
-    [[nodiscard]] u64 GetSize() const;
-
-    /**
-     * Moves the current position of the file pointer with the specified offset and seek origin.
-     *
-     * @param offset Offset from seek origin
-     * @param origin Seek origin
-     *
-     * @returns True if the file pointer has moved to the specified offset, false otherwise.
-     */
-    [[nodiscard]] bool Seek(s64 offset, SeekOrigin origin = SeekOrigin::SetOrigin) const;
-
-    /**
-     * Gets the current position of the file pointer.
-     *
-     * @returns The current position of the file pointer.
-     */
-    [[nodiscard]] s64 Tell() const;
-
-private:
-    std::filesystem::path file_path;
-    FileAccessMode file_access_mode{};
-    FileType file_type{};
-
-    std::FILE* file = nullptr;
-};
-
-} // namespace Common::FS

src/common/fs/fs.cpp

@@ -1,625 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/fs/file.h"
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
-#include "common/logging/log.h"
-
-namespace Common::FS {
-
-namespace fs = std::filesystem;
-
-// File Operations
-
-bool NewFile(const fs::path& path, u64 size) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return false;
-    }
-
-    if (!Exists(path.parent_path())) {
-        LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
-                  PathToUTF8String(path));
-        return false;
-    }
-
-    if (Exists(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} exists", PathToUTF8String(path));
-        return false;
-    }
-
-    IOFile io_file{path, FileAccessMode::Write};
-
-    if (!io_file.IsOpen()) {
-        LOG_ERROR(Common_Filesystem, "Failed to create a file at path={}", PathToUTF8String(path));
-        return false;
-    }
-
-    if (!io_file.SetSize(size)) {
-        LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={} to size={}",
-                  PathToUTF8String(path), size);
-        return false;
-    }
-
-    io_file.Close();
-
-    LOG_DEBUG(Common_Filesystem, "Successfully created a file at path={} with size={}",
-              PathToUTF8String(path), size);
-
-    return true;
-}
-
-bool RemoveFile(const fs::path& path) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return false;
-    }
-
-    if (!Exists(path)) {
-        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
-                  PathToUTF8String(path));
-        return true;
-    }
-
-    if (!IsFile(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a file",
-                  PathToUTF8String(path));
-        return false;
-    }
-
-    std::error_code ec;
-
-    fs::remove(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to remove the file at path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return false;
-    }
-
-    LOG_DEBUG(Common_Filesystem, "Successfully removed the file at path={}",
-              PathToUTF8String(path));
-
-    return true;
-}
-
-bool RenameFile(const fs::path& old_path, const fs::path& new_path) {
-    if (!ValidatePath(old_path) || !ValidatePath(new_path)) {
-        LOG_ERROR(Common_Filesystem,
-                  "One or both input path(s) is not valid, old_path={}, new_path={}",
-                  PathToUTF8String(old_path), PathToUTF8String(new_path));
-        return false;
-    }
-
-    if (!Exists(old_path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} does not exist",
-                  PathToUTF8String(old_path));
-        return false;
-    }
-
-    if (!IsFile(old_path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} is not a file",
-                  PathToUTF8String(old_path));
-        return false;
-    }
-
-    if (Exists(new_path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} exists",
-                  PathToUTF8String(new_path));
-        return false;
-    }
-
-    std::error_code ec;
-
-    fs::rename(old_path, new_path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to rename the file from old_path={} to new_path={}, ec_message={}",
-                  PathToUTF8String(old_path), PathToUTF8String(new_path), ec.message());
-        return false;
-    }
-
-    LOG_DEBUG(Common_Filesystem, "Successfully renamed the file from old_path={} to new_path={}",
-              PathToUTF8String(old_path), PathToUTF8String(new_path));
-
-    return true;
-}
-
-std::shared_ptr<IOFile> FileOpen(const fs::path& path, FileAccessMode mode, FileType type,
-                                 FileShareFlag flag) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return nullptr;
-    }
-
-    if (Exists(path) && !IsFile(path)) {
-        LOG_ERROR(Common_Filesystem,
-                  "Filesystem object at path={} exists and is not a regular file",
-                  PathToUTF8String(path));
-        return nullptr;
-    }
-
-    auto io_file = std::make_shared<IOFile>(path, mode, type, flag);
-
-    if (!io_file->IsOpen()) {
-        io_file.reset();
-
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to open the file at path={} with mode={}, type={}, flag={}",
-                  PathToUTF8String(path), mode, type, flag);
-
-        return nullptr;
-    }
-
-    LOG_DEBUG(Common_Filesystem,
-              "Successfully opened the file at path={} with mode={}, type={}, flag={}",
-              PathToUTF8String(path), mode, type, flag);
-
-    return io_file;
-}
-
-// Directory Operations
-
-bool CreateDir(const fs::path& path) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return false;
-    }
-
-    if (!Exists(path.parent_path())) {
-        LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
-                  PathToUTF8String(path));
-        return false;
-    }
-
-    if (IsDir(path)) {
-        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",
-                  PathToUTF8String(path));
-        return true;
-    }
-
-    std::error_code ec;
-
-    fs::create_directory(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to create the directory at path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return false;
-    }
-
-    LOG_DEBUG(Common_Filesystem, "Successfully created the directory at path={}",
-              PathToUTF8String(path));
-
-    return true;
-}
-
-bool CreateDirs(const fs::path& path) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return false;
-    }
-
-    if (IsDir(path)) {
-        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",
-                  PathToUTF8String(path));
-        return true;
-    }
-
-    std::error_code ec;
-
-    fs::create_directories(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to create the directories at path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return false;
-    }
-
-    LOG_DEBUG(Common_Filesystem, "Successfully created the directories at path={}",
-              PathToUTF8String(path));
-
-    return true;
-}
-
-bool CreateParentDir(const fs::path& path) {
-    return CreateDir(path.parent_path());
-}
-
-bool CreateParentDirs(const fs::path& path) {
-    return CreateDirs(path.parent_path());
-}
-
-bool RemoveDir(const fs::path& path) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return false;
-    }
-
-    if (!Exists(path)) {
-        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
-                  PathToUTF8String(path));
-        return true;
-    }
-
-    if (!IsDir(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
-                  PathToUTF8String(path));
-        return false;
-    }
-
-    std::error_code ec;
-
-    fs::remove(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to remove the directory at path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return false;
-    }
-
-    LOG_DEBUG(Common_Filesystem, "Successfully removed the directory at path={}",
-              PathToUTF8String(path));
-
-    return true;
-}
-
-bool RemoveDirRecursively(const fs::path& path) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return false;
-    }
-
-    if (!Exists(path)) {
-        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
-                  PathToUTF8String(path));
-        return true;
-    }
-
-    if (!IsDir(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
-                  PathToUTF8String(path));
-        return false;
-    }
-
-    std::error_code ec;
-
-    fs::remove_all(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to remove the directory and its contents at path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return false;
-    }
-
-    LOG_DEBUG(Common_Filesystem, "Successfully removed the directory and its contents at path={}",
-              PathToUTF8String(path));
-
-    return true;
-}
-
-bool RemoveDirContentsRecursively(const fs::path& path) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return false;
-    }
-
-    if (!Exists(path)) {
-        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
-                  PathToUTF8String(path));
-        return true;
-    }
-
-    if (!IsDir(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
-                  PathToUTF8String(path));
-        return false;
-    }
-
-    std::error_code ec;
-
-    // TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
-    for (const auto& entry : fs::directory_iterator(path, ec)) {
-        if (ec) {
-            LOG_ERROR(Common_Filesystem,
-                      "Failed to completely enumerate the directory at path={}, ec_message={}",
-                      PathToUTF8String(path), ec.message());
-            break;
-        }
-
-        fs::remove(entry.path(), ec);
-
-        if (ec) {
-            LOG_ERROR(Common_Filesystem,
-                      "Failed to remove the filesystem object at path={}, ec_message={}",
-                      PathToUTF8String(entry.path()), ec.message());
-            break;
-        }
-
-        // TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
-        // recursive_directory_iterator throws an exception despite passing in a std::error_code.
-        if (entry.status().type() == fs::file_type::directory) {
-            return RemoveDirContentsRecursively(entry.path());
-        }
-    }
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to remove all the contents of the directory at path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return false;
-    }
-
-    LOG_DEBUG(Common_Filesystem,
-              "Successfully removed all the contents of the directory at path={}",
-              PathToUTF8String(path));
-
-    return true;
-}
-
-bool RenameDir(const fs::path& old_path, const fs::path& new_path) {
-    if (!ValidatePath(old_path) || !ValidatePath(new_path)) {
-        LOG_ERROR(Common_Filesystem,
-                  "One or both input path(s) is not valid, old_path={}, new_path={}",
-                  PathToUTF8String(old_path), PathToUTF8String(new_path));
-        return false;
-    }
-
-    if (!Exists(old_path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} does not exist",
-                  PathToUTF8String(old_path));
-        return false;
-    }
-
-    if (!IsDir(old_path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} is not a directory",
-                  PathToUTF8String(old_path));
-        return false;
-    }
-
-    if (Exists(new_path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} exists",
-                  PathToUTF8String(new_path));
-        return false;
-    }
-
-    std::error_code ec;
-
-    fs::rename(old_path, new_path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to rename the file from old_path={} to new_path={}, ec_message={}",
-                  PathToUTF8String(old_path), PathToUTF8String(new_path), ec.message());
-        return false;
-    }
-
-    LOG_DEBUG(Common_Filesystem, "Successfully renamed the file from old_path={} to new_path={}",
-              PathToUTF8String(old_path), PathToUTF8String(new_path));
-
-    return true;
-}
-
-void IterateDirEntries(const std::filesystem::path& path, const DirEntryCallable& callback,
-                       DirEntryFilter filter) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return;
-    }
-
-    if (!Exists(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} does not exist",
-                  PathToUTF8String(path));
-        return;
-    }
-
-    if (!IsDir(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
-                  PathToUTF8String(path));
-        return;
-    }
-
-    bool callback_error = false;
-
-    std::error_code ec;
-
-    for (const auto& entry : fs::directory_iterator(path, ec)) {
-        if (ec) {
-            break;
-        }
-
-        if (True(filter & DirEntryFilter::File) &&
-            entry.status().type() == fs::file_type::regular) {
-            if (!callback(entry.path())) {
-                callback_error = true;
-                break;
-            }
-        }
-
-        if (True(filter & DirEntryFilter::Directory) &&
-            entry.status().type() == fs::file_type::directory) {
-            if (!callback(entry.path())) {
-                callback_error = true;
-                break;
-            }
-        }
-    }
-
-    if (callback_error || ec) {
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to visit all the directory entries of path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return;
-    }
-
-    LOG_DEBUG(Common_Filesystem, "Successfully visited all the directory entries of path={}",
-              PathToUTF8String(path));
-}
-
-void IterateDirEntriesRecursively(const std::filesystem::path& path,
-                                  const DirEntryCallable& callback, DirEntryFilter filter) {
-    if (!ValidatePath(path)) {
-        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
-        return;
-    }
-
-    if (!Exists(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} does not exist",
-                  PathToUTF8String(path));
-        return;
-    }
-
-    if (!IsDir(path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
-                  PathToUTF8String(path));
-        return;
-    }
-
-    bool callback_error = false;
-
-    std::error_code ec;
-
-    // TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
-    for (const auto& entry : fs::directory_iterator(path, ec)) {
-        if (ec) {
-            break;
-        }
-
-        if (True(filter & DirEntryFilter::File) &&
-            entry.status().type() == fs::file_type::regular) {
-            if (!callback(entry.path())) {
-                callback_error = true;
-                break;
-            }
-        }
-
-        if (True(filter & DirEntryFilter::Directory) &&
-            entry.status().type() == fs::file_type::directory) {
-            if (!callback(entry.path())) {
-                callback_error = true;
-                break;
-            }
-        }
-
-        // TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
-        // recursive_directory_iterator throws an exception despite passing in a std::error_code.
-        if (entry.status().type() == fs::file_type::directory) {
-            IterateDirEntriesRecursively(entry.path(), callback, filter);
-        }
-    }
-
-    if (callback_error || ec) {
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to visit all the directory entries of path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return;
-    }
-
-    LOG_DEBUG(Common_Filesystem, "Successfully visited all the directory entries of path={}",
-              PathToUTF8String(path));
-}
-
-// Generic Filesystem Operations
-
-bool Exists(const fs::path& path) {
-    return fs::exists(path);
-}
-
-bool IsFile(const fs::path& path) {
-    return fs::is_regular_file(path);
-}
-
-bool IsDir(const fs::path& path) {
-    return fs::is_directory(path);
-}
-
-fs::path GetCurrentDir() {
-    std::error_code ec;
-
-    const auto current_path = fs::current_path(ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to get the current path, ec_message={}", ec.message());
-        return {};
-    }
-
-    return current_path;
-}
-
-bool SetCurrentDir(const fs::path& path) {
-    std::error_code ec;
-
-    fs::current_path(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to set the current path to path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return false;
-    }
-
-    return true;
-}
-
-fs::file_type GetEntryType(const fs::path& path) {
-    std::error_code ec;
-
-    const auto file_status = fs::status(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to retrieve the entry type of path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return fs::file_type::not_found;
-    }
-
-    return file_status.type();
-}
-
-u64 GetSize(const fs::path& path) {
-    std::error_code ec;
-
-    const auto file_size = fs::file_size(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return 0;
-    }
-
-    return file_size;
-}
-
-u64 GetFreeSpaceSize(const fs::path& path) {
-    std::error_code ec;
-
-    const auto space_info = fs::space(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to retrieve the available free space of path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return 0;
-    }
-
-    return space_info.free;
-}
-
-u64 GetTotalSpaceSize(const fs::path& path) {
-    std::error_code ec;
-
-    const auto space_info = fs::space(path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to retrieve the total capacity of path={}, ec_message={}",
-                  PathToUTF8String(path), ec.message());
-        return 0;
-    }
-
-    return space_info.capacity;
-}
-
-} // namespace Common::FS

src/common/fs/fs.h

@@ -1,584 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <filesystem>
-#include <memory>
-
-#include "common/fs/fs_types.h"
-#include "common/fs/fs_util.h"
-
-namespace Common::FS {
-
-class IOFile;
-
-// File Operations
-
-/**
- * Creates a new file at path with the specified size.
- *
- * Failures occur when:
- * - Input path is not valid
- * - The input path's parent directory does not exist
- * - Filesystem object at path exists
- * - Filesystem at path is read only
- *
- * @param path Filesystem path
- * @param size File size
- *
- * @returns True if the file creation succeeds, false otherwise.
- */
-[[nodiscard]] bool NewFile(const std::filesystem::path& path, u64 size = 0);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool NewFile(const Path& path, u64 size = 0) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return NewFile(ToU8String(path), size);
-    } else {
-        return NewFile(std::filesystem::path{path}, size);
-    }
-}
-#endif
-
-/**
- * Removes a file at path.
- *
- * Failures occur when:
- * - Input path is not valid
- * - Filesystem object at path is not a regular file
- * - Filesystem at path is read only
- *
- * @param path Filesystem path
- *
- * @returns True if file removal succeeds or file does not exist, false otherwise.
- */
-bool RemoveFile(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-bool RemoveFile(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return RemoveFile(ToU8String(path));
-    } else {
-        return RemoveFile(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Renames a file from old_path to new_path.
- *
- * Failures occur when:
- * - One or both input path(s) is not valid
- * - Filesystem object at old_path does not exist
- * - Filesystem object at old_path is not a regular file
- * - Filesystem object at new_path exists
- * - Filesystem at either path is read only
- *
- * @param old_path Old filesystem path
- * @param new_path New filesystem path
- *
- * @returns True if file rename succeeds, false otherwise.
- */
-[[nodiscard]] bool RenameFile(const std::filesystem::path& old_path,
-                              const std::filesystem::path& new_path);
-
-#ifdef _WIN32
-template <typename Path1, typename Path2>
-[[nodiscard]] bool RenameFile(const Path1& old_path, const Path2& new_path) {
-    using ValueType1 = typename Path1::value_type;
-    using ValueType2 = typename Path2::value_type;
-    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
-        return RenameFile(ToU8String(old_path), ToU8String(new_path));
-    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
-        return RenameFile(ToU8String(old_path), new_path);
-    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
-        return RenameFile(old_path, ToU8String(new_path));
-    } else {
-        return RenameFile(std::filesystem::path{old_path}, std::filesystem::path{new_path});
-    }
-}
-#endif
-
-/**
- * Opens a file at path with the specified file access mode.
- * This function behaves differently depending on the FileAccessMode.
- * These behaviors are documented in each enum value of FileAccessMode.
- *
- * Failures occur when:
- * - Input path is not valid
- * - Filesystem object at path exists and is not a regular file
- * - The file is not open
- *
- * @param path Filesystem path
- * @param mode File access mode
- * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
- * @param flag (Windows only) File-share access flag, default is ShareReadOnly
- *
- * @returns A shared pointer to the opened file. Returns nullptr on failure.
- */
-[[nodiscard]] std::shared_ptr<IOFile> FileOpen(const std::filesystem::path& path,
-                                               FileAccessMode mode,
-                                               FileType type = FileType::BinaryFile,
-                                               FileShareFlag flag = FileShareFlag::ShareReadOnly);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] std::shared_ptr<IOFile> FileOpen(const Path& path, FileAccessMode mode,
-                                               FileType type = FileType::BinaryFile,
-                                               FileShareFlag flag = FileShareFlag::ShareReadOnly) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return FileOpen(ToU8String(path), mode, type, flag);
-    } else {
-        return FileOpen(std::filesystem::path{path}, mode, type, flag);
-    }
-}
-#endif
-
-// Directory Operations
-
-/**
- * Creates a directory at path.
- * Note that this function will *always* assume that the input path is a directory. For example,
- * if the input path is /path/to/directory/file.txt, it will create a directory called "file.txt".
- * If you intend to create the parent directory of a file, use CreateParentDir instead.
- *
- * Failures occur when:
- * - Input path is not valid
- * - The input path's parent directory does not exist
- * - Filesystem at path is read only
- *
- * @param path Filesystem path
- *
- * @returns True if directory creation succeeds or directory already exists, false otherwise.
- */
-[[nodiscard]] bool CreateDir(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool CreateDir(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return CreateDir(ToU8String(path));
-    } else {
-        return CreateDir(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Recursively creates a directory at path.
- * Note that this function will *always* assume that the input path is a directory. For example,
- * if the input path is /path/to/directory/file.txt, it will create a directory called "file.txt".
- * If you intend to create the parent directory of a file, use CreateParentDirs instead.
- * Unlike CreateDir, this creates all of input path's parent directories if they do not exist.
- *
- * Failures occur when:
- * - Input path is not valid
- * - Filesystem at path is read only
- *
- * @param path Filesystem path
- *
- * @returns True if directory creation succeeds or directory already exists, false otherwise.
- */
-[[nodiscard]] bool CreateDirs(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool CreateDirs(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return CreateDirs(ToU8String(path));
-    } else {
-        return CreateDirs(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Creates the parent directory of a given path.
- * This function calls CreateDir(path.parent_path()), see CreateDir for more details.
- *
- * @param path Filesystem path
- *
- * @returns True if directory creation succeeds or directory already exists, false otherwise.
- */
-[[nodiscard]] bool CreateParentDir(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool CreateParentDir(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return CreateParentDir(ToU8String(path));
-    } else {
-        return CreateParentDir(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Recursively creates the parent directory of a given path.
- * This function calls CreateDirs(path.parent_path()), see CreateDirs for more details.
- *
- * @param path Filesystem path
- *
- * @returns True if directory creation succeeds or directory already exists, false otherwise.
- */
-[[nodiscard]] bool CreateParentDirs(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool CreateParentDirs(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return CreateParentDirs(ToU8String(path));
-    } else {
-        return CreateParentDirs(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Removes a directory at path.
- *
- * Failures occur when:
- * - Input path is not valid
- * - Filesystem object at path is not a directory
- * - The given directory is not empty
- * - Filesystem at path is read only
- *
- * @param path Filesystem path
- *
- * @returns True if directory removal succeeds or directory does not exist, false otherwise.
- */
-bool RemoveDir(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-bool RemoveDir(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return RemoveDir(ToU8String(path));
-    } else {
-        return RemoveDir(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Removes all the contents within the given directory and removes the directory itself.
- *
- * Failures occur when:
- * - Input path is not valid
- * - Filesystem object at path is not a directory
- * - Filesystem at path is read only
- *
- * @param path Filesystem path
- *
- * @returns True if the directory and all of its contents are removed successfully, false otherwise.
- */
-bool RemoveDirRecursively(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-bool RemoveDirRecursively(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return RemoveDirRecursively(ToU8String(path));
-    } else {
-        return RemoveDirRecursively(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Removes all the contents within the given directory without removing the directory itself.
- *
- * Failures occur when:
- * - Input path is not valid
- * - Filesystem object at path is not a directory
- * - Filesystem at path is read only
- *
- * @param path Filesystem path
- *
- * @returns True if all of the directory's contents are removed successfully, false otherwise.
- */
-bool RemoveDirContentsRecursively(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-bool RemoveDirContentsRecursively(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return RemoveDirContentsRecursively(ToU8String(path));
-    } else {
-        return RemoveDirContentsRecursively(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Renames a directory from old_path to new_path.
- *
- * Failures occur when:
- * - One or both input path(s) is not valid
- * - Filesystem object at old_path does not exist
- * - Filesystem object at old_path is not a directory
- * - Filesystem object at new_path exists
- * - Filesystem at either path is read only
- *
- * @param old_path Old filesystem path
- * @param new_path New filesystem path
- *
- * @returns True if directory rename succeeds, false otherwise.
- */
-[[nodiscard]] bool RenameDir(const std::filesystem::path& old_path,
-                             const std::filesystem::path& new_path);
-
-#ifdef _WIN32
-template <typename Path1, typename Path2>
-[[nodiscard]] bool RenameDir(const Path1& old_path, const Path2& new_path) {
-    using ValueType1 = typename Path1::value_type;
-    using ValueType2 = typename Path2::value_type;
-    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
-        return RenameDir(ToU8String(old_path), ToU8String(new_path));
-    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
-        return RenameDir(ToU8String(old_path), new_path);
-    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
-        return RenameDir(old_path, ToU8String(new_path));
-    } else {
-        return RenameDir(std::filesystem::path{old_path}, std::filesystem::path{new_path});
-    }
-}
-#endif
-
-/**
- * Iterates over the directory entries of a given directory.
- * This does not iterate over the sub-directories of the given directory.
- * The DirEntryCallable callback is called for each visited directory entry.
- * A filter can be set to control which directory entries are visited based on their type.
- * By default, both files and directories are visited.
- * If the callback returns false or there is an error, the iteration is immediately halted.
- *
- * Failures occur when:
- * - Input path is not valid
- * - Filesystem object at path is not a directory
- *
- * @param path Filesystem path
- * @param callback Callback to be called for each visited directory entry
- * @param filter Directory entry type filter
- */
-void IterateDirEntries(const std::filesystem::path& path, const DirEntryCallable& callback,
-                       DirEntryFilter filter = DirEntryFilter::All);
-
-#ifdef _WIN32
-template <typename Path>
-void IterateDirEntries(const Path& path, const DirEntryCallable& callback,
-                       DirEntryFilter filter = DirEntryFilter::All) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        IterateDirEntries(ToU8String(path), callback, filter);
-    } else {
-        IterateDirEntries(std::filesystem::path{path}, callback, filter);
-    }
-}
-#endif
-
-/**
- * Iterates over the directory entries of a given directory and its sub-directories.
- * The DirEntryCallable callback is called for each visited directory entry.
- * A filter can be set to control which directory entries are visited based on their type.
- * By default, both files and directories are visited.
- * If the callback returns false or there is an error, the iteration is immediately halted.
- *
- * Failures occur when:
- * - Input path is not valid
- * - Filesystem object at path does not exist
- * - Filesystem object at path is not a directory
- *
- * @param path Filesystem path
- * @param callback Callback to be called for each visited directory entry
- * @param filter Directory entry type filter
- */
-void IterateDirEntriesRecursively(const std::filesystem::path& path,
-                                  const DirEntryCallable& callback,
-                                  DirEntryFilter filter = DirEntryFilter::All);
-
-#ifdef _WIN32
-template <typename Path>
-void IterateDirEntriesRecursively(const Path& path, const DirEntryCallable& callback,
-                                  DirEntryFilter filter = DirEntryFilter::All) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        IterateDirEntriesRecursively(ToU8String(path), callback, filter);
-    } else {
-        IterateDirEntriesRecursively(std::filesystem::path{path}, callback, filter);
-    }
-}
-#endif
-
-// Generic Filesystem Operations
-
-/**
- * Returns whether a filesystem object at path exists.
- *
- * @param path Filesystem path
- *
- * @returns True if a filesystem object at path exists, false otherwise.
- */
-[[nodiscard]] bool Exists(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool Exists(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return Exists(ToU8String(path));
-    } else {
-        return Exists(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Returns whether a filesystem object at path is a regular file.
- * A regular file is a file that stores text or binary data.
- * It is not a directory, symlink, FIFO, socket, block device, or character device.
- *
- * @param path Filesystem path
- *
- * @returns True if a filesystem object at path is a regular file, false otherwise.
- */
-[[nodiscard]] bool IsFile(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool IsFile(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return IsFile(ToU8String(path));
-    } else {
-        return IsFile(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Returns whether a filesystem object at path is a directory.
- *
- * @param path Filesystem path
- *
- * @returns True if a filesystem object at path is a directory, false otherwise.
- */
-[[nodiscard]] bool IsDir(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool IsDir(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return IsDir(ToU8String(path));
-    } else {
-        return IsDir(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Gets the current working directory.
- *
- * @returns The current working directory. Returns an empty path on failure.
- */
-[[nodiscard]] std::filesystem::path GetCurrentDir();
-
-/**
- * Sets the current working directory to path.
- *
- * @returns True if the current working directory is successfully set, false otherwise.
- */
-[[nodiscard]] bool SetCurrentDir(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool SetCurrentDir(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return SetCurrentDir(ToU8String(path));
-    } else {
-        return SetCurrentDir(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Gets the entry type of the filesystem object at path.
- *
- * @param path Filesystem path
- *
- * @returns The entry type of the filesystem object. Returns file_type::not_found on failure.
- */
-[[nodiscard]] std::filesystem::file_type GetEntryType(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] std::filesystem::file_type GetEntryType(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return GetEntryType(ToU8String(path));
-    } else {
-        return GetEntryType(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Gets the size of the filesystem object at path.
- *
- * @param path Filesystem path
- *
- * @returns The size in bytes of the filesystem object. Returns 0 on failure.
- */
-[[nodiscard]] u64 GetSize(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] u64 GetSize(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return GetSize(ToU8String(path));
-    } else {
-        return GetSize(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Gets the free space size of the filesystem at path.
- *
- * @param path Filesystem path
- *
- * @returns The free space size in bytes of the filesystem at path. Returns 0 on failure.
- */
-[[nodiscard]] u64 GetFreeSpaceSize(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] u64 GetFreeSpaceSize(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return GetFreeSpaceSize(ToU8String(path));
-    } else {
-        return GetFreeSpaceSize(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Gets the total capacity of the filesystem at path.
- *
- * @param path Filesystem path
- *
- * @returns The total capacity in bytes of the filesystem at path. Returns 0 on failure.
- */
-[[nodiscard]] u64 GetTotalSpaceSize(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] u64 GetTotalSpaceSize(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return GetTotalSpaceSize(ToU8String(path));
-    } else {
-        return GetTotalSpaceSize(std::filesystem::path{path});
-    }
-}
-#endif
-
-} // namespace Common::FS

src/common/fs/fs_paths.h

@@ -1,27 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-// yuzu data directories
-
-#define YUZU_DIR "yuzu"
-#define PORTABLE_DIR "user"
-
-// Sub-directories contained within a yuzu data directory
-
-#define CACHE_DIR "cache"
-#define CONFIG_DIR "config"
-#define DUMP_DIR "dump"
-#define KEYS_DIR "keys"
-#define LOAD_DIR "load"
-#define LOG_DIR "log"
-#define NAND_DIR "nand"
-#define SCREENSHOTS_DIR "screenshots"
-#define SDMC_DIR "sdmc"
-#define SHADER_DIR "shader"
-
-// yuzu-specific files
-
-#define LOG_FILE "yuzu_log.txt"

src/common/fs/fs_types.h

@@ -1,73 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-
-namespace Common::FS {
-
-enum class FileAccessMode {
-    /**
-     * If the file at path exists, it opens the file for reading.
-     * If the file at path does not exist, it fails to open the file.
-     */
-    Read = 1 << 0,
-    /**
-     * If the file at path exists, the existing contents of the file are erased.
-     * The empty file is then opened for writing.
-     * If the file at path does not exist, it creates and opens a new empty file for writing.
-     */
-    Write = 1 << 1,
-    /**
-     * If the file at path exists, it opens the file for reading and writing.
-     * If the file at path does not exist, it fails to open the file.
-     */
-    ReadWrite = Read | Write,
-    /**
-     * If the file at path exists, it opens the file for appending.
-     * If the file at path does not exist, it creates and opens a new empty file for appending.
-     */
-    Append = 1 << 2,
-    /**
-     * If the file at path exists, it opens the file for both reading and appending.
-     * If the file at path does not exist, it creates and opens a new empty file for both
-     * reading and appending.
-     */
-    ReadAppend = Read | Append,
-};
-
-enum class FileType {
-    BinaryFile,
-    TextFile,
-};
-
-enum class FileShareFlag {
-    ShareNone,      // Provides exclusive access to the file.
-    ShareReadOnly,  // Provides read only shared access to the file.
-    ShareWriteOnly, // Provides write only shared access to the file.
-    ShareReadWrite, // Provides read and write shared access to the file.
-};
-
-enum class DirEntryFilter {
-    File = 1 << 0,
-    Directory = 1 << 1,
-    All = File | Directory,
-};
-DECLARE_ENUM_FLAG_OPERATORS(DirEntryFilter);
-
-/**
- * A callback function which takes in the path of a directory entry.
- *
- * @param path The path of a directory entry
- *
- * @returns A boolean value.
- *          Return true to indicate whether the callback is successful, false otherwise.
- */
-using DirEntryCallable = std::function<bool(const std::filesystem::path& path)>;
-
-} // namespace Common::FS

src/common/fs/fs_util.cpp

@@ -1,27 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-
-#include "common/fs/fs_util.h"
-
-namespace Common::FS {
-
-std::u8string ToU8String(std::string_view utf8_string) {
-    return std::u8string{utf8_string.begin(), utf8_string.end()};
-}
-
-std::u8string BufferToU8String(std::span<const u8> buffer) {
-    return std::u8string{buffer.begin(), std::ranges::find(buffer, u8{0})};
-}
-
-std::string ToUTF8String(std::u8string_view u8_string) {
-    return std::string{u8_string.begin(), u8_string.end()};
-}
-
-std::string PathToUTF8String(const std::filesystem::path& path) {
-    return ToUTF8String(path.u8string());
-}
-
-} // namespace Common::FS

src/common/fs/fs_util.h

@@ -1,58 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <concepts>
-#include <filesystem>
-#include <span>
-#include <string>
-#include <string_view>
-
-#include "common/common_types.h"
-
-namespace Common::FS {
-
-template <typename T>
-concept IsChar = std::same_as<T, char>;
-
-/**
- * Converts a UTF-8 encoded std::string or std::string_view to a std::u8string.
- *
- * @param utf8_string UTF-8 encoded string
- *
- * @returns UTF-8 encoded std::u8string.
- */
-[[nodiscard]] std::u8string ToU8String(std::string_view utf8_string);
-
-/**
- * Converts a buffer of bytes to a UTF8-encoded std::u8string.
- * This converts from the start of the buffer until the first encountered null-terminator.
- * If no null-terminator is found, this converts the entire buffer instead.
- *
- * @param buffer Buffer of bytes
- *
- * @returns UTF-8 encoded std::u8string.
- */
-[[nodiscard]] std::u8string BufferToU8String(std::span<const u8> buffer);
-
-/**
- * Converts a std::u8string or std::u8string_view to a UTF-8 encoded std::string.
- *
- * @param u8_string UTF-8 encoded u8string
- *
- * @returns UTF-8 encoded std::string.
- */
-[[nodiscard]] std::string ToUTF8String(std::u8string_view u8_string);
-
-/**
- * Converts a filesystem path to a UTF-8 encoded std::string.
- *
- * @param path Filesystem path
- *
- * @returns UTF-8 encoded std::string.
- */
-[[nodiscard]] std::string PathToUTF8String(const std::filesystem::path& path);
-
-} // namespace Common::FS

src/common/fs/path_util.cpp

@@ -1,426 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <unordered_map>
-
-#include "common/fs/fs.h"
-#include "common/fs/fs_paths.h"
-#include "common/fs/path_util.h"
-#include "common/logging/log.h"
-
-#ifdef _WIN32
-#include <shlobj.h> // Used in GetExeDirectory()
-#else
-#include <cstdlib>     // Used in Get(Home/Data)Directory()
-#include <pwd.h>       // Used in GetHomeDirectory()
-#include <sys/types.h> // Used in GetHomeDirectory()
-#include <unistd.h>    // Used in GetDataDirectory()
-#endif
-
-#ifdef __APPLE__
-#include <sys/param.h> // Used in GetBundleDirectory()
-
-// CFURL contains __attribute__ directives that gcc does not know how to parse, so we need to just
-// ignore them if we're not using clang. The macro is only used to prevent linking against
-// functions that don't exist on older versions of macOS, and the worst case scenario is a linker
-// error, so this is perfectly safe, just inconvenient.
-#ifndef __clang__
-#define availability(...)
-#endif
-#include <CoreFoundation/CFBundle.h> // Used in GetBundleDirectory()
-#include <CoreFoundation/CFString.h> // Used in GetBundleDirectory()
-#include <CoreFoundation/CFURL.h>    // Used in GetBundleDirectory()
-#ifdef availability
-#undef availability
-#endif
-#endif
-
-#ifndef MAX_PATH
-#ifdef _WIN32
-// This is the maximum number of UTF-16 code units permissible in Windows file paths
-#define MAX_PATH 260
-#else
-// This is the maximum number of UTF-8 code units permissible in all other OSes' file paths
-#define MAX_PATH 1024
-#endif
-#endif
-
-namespace Common::FS {
-
-namespace fs = std::filesystem;
-
-/**
- * The PathManagerImpl is a singleton allowing to manage the mapping of
- * YuzuPath enums to real filesystem paths.
- * This class provides 2 functions: GetYuzuPathImpl and SetYuzuPathImpl.
- * These are used by GetYuzuPath and SetYuzuPath respectively to get or modify
- * the path mapped by the YuzuPath enum.
- */
-class PathManagerImpl {
-public:
-    static PathManagerImpl& GetInstance() {
-        static PathManagerImpl path_manager_impl;
-
-        return path_manager_impl;
-    }
-
-    PathManagerImpl(const PathManagerImpl&) = delete;
-    PathManagerImpl& operator=(const PathManagerImpl&) = delete;
-
-    PathManagerImpl(PathManagerImpl&&) = delete;
-    PathManagerImpl& operator=(PathManagerImpl&&) = delete;
-
-    [[nodiscard]] const fs::path& GetYuzuPathImpl(YuzuPath yuzu_path) {
-        return yuzu_paths.at(yuzu_path);
-    }
-
-    void SetYuzuPathImpl(YuzuPath yuzu_path, const fs::path& new_path) {
-        yuzu_paths.insert_or_assign(yuzu_path, new_path);
-    }
-
-private:
-    PathManagerImpl() {
-#ifdef _WIN32
-        auto yuzu_path = GetExeDirectory() / PORTABLE_DIR;
-
-        if (!IsDir(yuzu_path)) {
-            yuzu_path = GetAppDataRoamingDirectory() / YUZU_DIR;
-        }
-
-        GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
-        GenerateYuzuPath(YuzuPath::CacheDir, yuzu_path / CACHE_DIR);
-        GenerateYuzuPath(YuzuPath::ConfigDir, yuzu_path / CONFIG_DIR);
-#else
-        auto yuzu_path = GetCurrentDir() / PORTABLE_DIR;
-
-        if (Exists(yuzu_path) && IsDir(yuzu_path)) {
-            GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
-            GenerateYuzuPath(YuzuPath::CacheDir, yuzu_path / CACHE_DIR);
-            GenerateYuzuPath(YuzuPath::ConfigDir, yuzu_path / CONFIG_DIR);
-        } else {
-            yuzu_path = GetDataDirectory("XDG_DATA_HOME") / YUZU_DIR;
-
-            GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
-            GenerateYuzuPath(YuzuPath::CacheDir, GetDataDirectory("XDG_CACHE_HOME") / YUZU_DIR);
-            GenerateYuzuPath(YuzuPath::ConfigDir, GetDataDirectory("XDG_CONFIG_HOME") / YUZU_DIR);
-        }
-#endif
-
-        GenerateYuzuPath(YuzuPath::DumpDir, yuzu_path / DUMP_DIR);
-        GenerateYuzuPath(YuzuPath::KeysDir, yuzu_path / KEYS_DIR);
-        GenerateYuzuPath(YuzuPath::LoadDir, yuzu_path / LOAD_DIR);
-        GenerateYuzuPath(YuzuPath::LogDir, yuzu_path / LOG_DIR);
-        GenerateYuzuPath(YuzuPath::NANDDir, yuzu_path / NAND_DIR);
-        GenerateYuzuPath(YuzuPath::ScreenshotsDir, yuzu_path / SCREENSHOTS_DIR);
-        GenerateYuzuPath(YuzuPath::SDMCDir, yuzu_path / SDMC_DIR);
-        GenerateYuzuPath(YuzuPath::ShaderDir, yuzu_path / SHADER_DIR);
-    }
-
-    ~PathManagerImpl() = default;
-
-    void GenerateYuzuPath(YuzuPath yuzu_path, const fs::path& new_path) {
-        void(FS::CreateDir(new_path));
-
-        SetYuzuPathImpl(yuzu_path, new_path);
-    }
-
-    std::unordered_map<YuzuPath, fs::path> yuzu_paths;
-};
-
-bool ValidatePath(const fs::path& path) {
-    if (path.empty()) {
-        LOG_ERROR(Common_Filesystem, "Input path is empty, path={}", PathToUTF8String(path));
-        return false;
-    }
-
-#ifdef _WIN32
-    if (path.u16string().size() >= MAX_PATH) {
-        LOG_ERROR(Common_Filesystem, "Input path is too long, path={}", PathToUTF8String(path));
-        return false;
-    }
-#else
-    if (path.u8string().size() >= MAX_PATH) {
-        LOG_ERROR(Common_Filesystem, "Input path is too long, path={}", PathToUTF8String(path));
-        return false;
-    }
-#endif
-
-    return true;
-}
-
-fs::path ConcatPath(const fs::path& first, const fs::path& second) {
-    const bool second_has_dir_sep = IsDirSeparator(second.u8string().front());
-
-    if (!second_has_dir_sep) {
-        return (first / second).lexically_normal();
-    }
-
-    fs::path concat_path = first;
-    concat_path += second;
-
-    return concat_path.lexically_normal();
-}
-
-fs::path ConcatPathSafe(const fs::path& base, const fs::path& offset) {
-    const auto concatenated_path = ConcatPath(base, offset);
-
-    if (!IsPathSandboxed(base, concatenated_path)) {
-        return base;
-    }
-
-    return concatenated_path;
-}
-
-bool IsPathSandboxed(const fs::path& base, const fs::path& path) {
-    const auto base_string = RemoveTrailingSeparators(base.lexically_normal()).u8string();
-    const auto path_string = RemoveTrailingSeparators(path.lexically_normal()).u8string();
-
-    if (path_string.size() < base_string.size()) {
-        return false;
-    }
-
-    return base_string.compare(0, base_string.size(), path_string, 0, base_string.size()) == 0;
-}
-
-bool IsDirSeparator(char character) {
-    return character == '/' || character == '\\';
-}
-
-bool IsDirSeparator(char8_t character) {
-    return character == u8'/' || character == u8'\\';
-}
-
-fs::path RemoveTrailingSeparators(const fs::path& path) {
-    if (path.empty()) {
-        return path;
-    }
-
-    auto string_path = path.u8string();
-
-    while (IsDirSeparator(string_path.back())) {
-        string_path.pop_back();
-    }
-
-    return fs::path{string_path};
-}
-
-const fs::path& GetYuzuPath(YuzuPath yuzu_path) {
-    return PathManagerImpl::GetInstance().GetYuzuPathImpl(yuzu_path);
-}
-
-std::string GetYuzuPathString(YuzuPath yuzu_path) {
-    return PathToUTF8String(GetYuzuPath(yuzu_path));
-}
-
-void SetYuzuPath(YuzuPath yuzu_path, const fs::path& new_path) {
-    if (!FS::IsDir(new_path)) {
-        LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} is not a directory",
-                  PathToUTF8String(new_path));
-        return;
-    }
-
-    PathManagerImpl::GetInstance().SetYuzuPathImpl(yuzu_path, new_path);
-}
-
-#ifdef _WIN32
-
-fs::path GetExeDirectory() {
-    wchar_t exe_path[MAX_PATH];
-
-    GetModuleFileNameW(nullptr, exe_path, MAX_PATH);
-
-    if (!exe_path) {
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to get the path to the executable of the current process");
-    }
-
-    return fs::path{exe_path}.parent_path();
-}
-
-fs::path GetAppDataRoamingDirectory() {
-    PWSTR appdata_roaming_path = nullptr;
-
-    SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &appdata_roaming_path);
-
-    auto fs_appdata_roaming_path = fs::path{appdata_roaming_path};
-
-    CoTaskMemFree(appdata_roaming_path);
-
-    if (fs_appdata_roaming_path.empty()) {
-        LOG_ERROR(Common_Filesystem, "Failed to get the path to the %APPDATA% directory");
-    }
-
-    return fs_appdata_roaming_path;
-}
-
-#else
-
-fs::path GetHomeDirectory() {
-    const char* home_env_var = getenv("HOME");
-
-    if (home_env_var) {
-        return fs::path{home_env_var};
-    }
-
-    LOG_INFO(Common_Filesystem,
-             "$HOME is not defined in the environment variables, "
-             "attempting to query passwd to get the home path of the current user");
-
-    const auto* pw = getpwuid(getuid());
-
-    if (!pw) {
-        LOG_ERROR(Common_Filesystem, "Failed to get the home path of the current user");
-        return {};
-    }
-
-    return fs::path{pw->pw_dir};
-}
-
-fs::path GetDataDirectory(const std::string& env_name) {
-    const char* data_env_var = getenv(env_name.c_str());
-
-    if (data_env_var) {
-        return fs::path{data_env_var};
-    }
-
-    if (env_name == "XDG_DATA_HOME") {
-        return GetHomeDirectory() / ".local/share";
-    } else if (env_name == "XDG_CACHE_HOME") {
-        return GetHomeDirectory() / ".cache";
-    } else if (env_name == "XDG_CONFIG_HOME") {
-        return GetHomeDirectory() / ".config";
-    }
-
-    return {};
-}
-
-#endif
-
-#ifdef __APPLE__
-
-fs::path GetBundleDirectory() {
-    char app_bundle_path[MAXPATHLEN];
-
-    // Get the main bundle for the app
-    CFURLRef bundle_ref = CFBundleCopyBundleURL(CFBundleGetMainBundle());
-    CFStringRef bundle_path = CFURLCopyFileSystemPath(bundle_ref, kCFURLPOSIXPathStyle);
-
-    CFStringGetFileSystemRepresentation(bundle_path, app_bundle_path, sizeof(app_bundle_path));
-
-    CFRelease(bundle_ref);
-    CFRelease(bundle_path);
-
-    return fs::path{app_bundle_path};
-}
-
-#endif
-
-// vvvvvvvvvv Deprecated vvvvvvvvvv //
-
-std::string_view RemoveTrailingSlash(std::string_view path) {
-    if (path.empty()) {
-        return path;
-    }
-
-    if (path.back() == '\\' || path.back() == '/') {
-        path.remove_suffix(1);
-        return path;
-    }
-
-    return path;
-}
-
-std::vector<std::string> SplitPathComponents(std::string_view filename) {
-    std::string copy(filename);
-    std::replace(copy.begin(), copy.end(), '\\', '/');
-    std::vector<std::string> out;
-
-    std::stringstream stream(copy);
-    std::string item;
-    while (std::getline(stream, item, '/')) {
-        out.push_back(std::move(item));
-    }
-
-    return out;
-}
-
-std::string SanitizePath(std::string_view path_, DirectorySeparator directory_separator) {
-    std::string path(path_);
-    char type1 = directory_separator == DirectorySeparator::BackwardSlash ? '/' : '\\';
-    char type2 = directory_separator == DirectorySeparator::BackwardSlash ? '\\' : '/';
-
-    if (directory_separator == DirectorySeparator::PlatformDefault) {
-#ifdef _WIN32
-        type1 = '/';
-        type2 = '\\';
-#endif
-    }
-
-    std::replace(path.begin(), path.end(), type1, type2);
-
-    auto start = path.begin();
-#ifdef _WIN32
-    // allow network paths which start with a double backslash (e.g. \\server\share)
-    if (start != path.end())
-        ++start;
-#endif
-    path.erase(std::unique(start, path.end(),
-                           [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
-               path.end());
-    return std::string(RemoveTrailingSlash(path));
-}
-
-std::string_view GetParentPath(std::string_view path) {
-    const auto name_bck_index = path.rfind('\\');
-    const auto name_fwd_index = path.rfind('/');
-    std::size_t name_index;
-
-    if (name_bck_index == std::string_view::npos || name_fwd_index == std::string_view::npos) {
-        name_index = std::min(name_bck_index, name_fwd_index);
-    } else {
-        name_index = std::max(name_bck_index, name_fwd_index);
-    }
-
-    return path.substr(0, name_index);
-}
-
-std::string_view GetPathWithoutTop(std::string_view path) {
-    if (path.empty()) {
-        return path;
-    }
-
-    while (path[0] == '\\' || path[0] == '/') {
-        path.remove_prefix(1);
-        if (path.empty()) {
-            return path;
-        }
-    }
-
-    const auto name_bck_index = path.find('\\');
-    const auto name_fwd_index = path.find('/');
-    return path.substr(std::min(name_bck_index, name_fwd_index) + 1);
-}
-
-std::string_view GetFilename(std::string_view path) {
-    const auto name_index = path.find_last_of("\\/");
-
-    if (name_index == std::string_view::npos) {
-        return {};
-    }
-
-    return path.substr(name_index + 1);
-}
-
-std::string_view GetExtensionFromFilename(std::string_view name) {
-    const std::size_t index = name.rfind('.');
-
-    if (index == std::string_view::npos) {
-        return {};
-    }
-
-    return name.substr(index + 1);
-}
-
-} // namespace Common::FS

src/common/fs/path_util.h

@@ -1,300 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <filesystem>
-#include <vector>
-
-#include "common/fs/fs_util.h"
-
-namespace Common::FS {
-
-enum class YuzuPath {
-    YuzuDir,        // Where yuzu stores its data.
-    CacheDir,       // Where cached filesystem data is stored.
-    ConfigDir,      // Where config files are stored.
-    DumpDir,        // Where dumped data is stored.
-    KeysDir,        // Where key files are stored.
-    LoadDir,        // Where cheat/mod files are stored.
-    LogDir,         // Where log files are stored.
-    NANDDir,        // Where the emulated NAND is stored.
-    ScreenshotsDir, // Where yuzu screenshots are stored.
-    SDMCDir,        // Where the emulated SDMC is stored.
-    ShaderDir,      // Where shaders are stored.
-};
-
-/**
- * Validates a given path.
- *
- * A given path is valid if it meets these conditions:
- * - The path is not empty
- * - The path is not too long
- *
- * @param path Filesystem path
- *
- * @returns True if the path is valid, false otherwise.
- */
-[[nodiscard]] bool ValidatePath(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] bool ValidatePath(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return ValidatePath(ToU8String(path));
-    } else {
-        return ValidatePath(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Concatenates two filesystem paths together.
- *
- * This is needed since the following occurs when using std::filesystem::path's operator/:
- * first: "/first/path"
- * second: "/second/path" (Note that the second path has a directory separator in the front)
- * first / second yields "/second/path" when the desired result is first/path/second/path
- *
- * @param first First filesystem path
- * @param second Second filesystem path
- *
- * @returns A concatenated filesystem path.
- */
-[[nodiscard]] std::filesystem::path ConcatPath(const std::filesystem::path& first,
-                                               const std::filesystem::path& second);
-
-#ifdef _WIN32
-template <typename Path1, typename Path2>
-[[nodiscard]] std::filesystem::path ConcatPath(const Path1& first, const Path2& second) {
-    using ValueType1 = typename Path1::value_type;
-    using ValueType2 = typename Path2::value_type;
-    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
-        return ConcatPath(ToU8String(first), ToU8String(second));
-    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
-        return ConcatPath(ToU8String(first), second);
-    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
-        return ConcatPath(first, ToU8String(second));
-    } else {
-        return ConcatPath(std::filesystem::path{first}, std::filesystem::path{second});
-    }
-}
-#endif
-
-/**
- * Safe variant of ConcatPath that takes in a base path and an offset path from the given base path.
- *
- * If ConcatPath(base, offset) resolves to a path that is sandboxed within the base path,
- * this will return the concatenated path. Otherwise this will return the base path.
- *
- * @param base Base filesystem path
- * @param offset Offset filesystem path
- *
- * @returns A concatenated filesystem path if it is within the base path,
- *          returns the base path otherwise.
- */
-[[nodiscard]] std::filesystem::path ConcatPathSafe(const std::filesystem::path& base,
-                                                   const std::filesystem::path& offset);
-
-#ifdef _WIN32
-template <typename Path1, typename Path2>
-[[nodiscard]] std::filesystem::path ConcatPathSafe(const Path1& base, const Path2& offset) {
-    using ValueType1 = typename Path1::value_type;
-    using ValueType2 = typename Path2::value_type;
-    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
-        return ConcatPathSafe(ToU8String(base), ToU8String(offset));
-    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
-        return ConcatPathSafe(ToU8String(base), offset);
-    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
-        return ConcatPathSafe(base, ToU8String(offset));
-    } else {
-        return ConcatPathSafe(std::filesystem::path{base}, std::filesystem::path{offset});
-    }
-}
-#endif
-
-/**
- * Checks whether a given path is sandboxed within a given base path.
- *
- * @param base Base filesystem path
- * @param path Filesystem path
- *
- * @returns True if the given path is sandboxed within the given base path, false otherwise.
- */
-[[nodiscard]] bool IsPathSandboxed(const std::filesystem::path& base,
-                                   const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path1, typename Path2>
-[[nodiscard]] bool IsPathSandboxed(const Path1& base, const Path2& path) {
-    using ValueType1 = typename Path1::value_type;
-    using ValueType2 = typename Path2::value_type;
-    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
-        return IsPathSandboxed(ToU8String(base), ToU8String(path));
-    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
-        return IsPathSandboxed(ToU8String(base), path);
-    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
-        return IsPathSandboxed(base, ToU8String(path));
-    } else {
-        return IsPathSandboxed(std::filesystem::path{base}, std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Checks if a character is a directory separator (either a forward slash or backslash).
- *
- * @param character Character
- *
- * @returns True if the character is a directory separator, false otherwise.
- */
-[[nodiscard]] bool IsDirSeparator(char character);
-
-/**
- * Checks if a character is a directory separator (either a forward slash or backslash).
- *
- * @param character Character
- *
- * @returns True if the character is a directory separator, false otherwise.
- */
-[[nodiscard]] bool IsDirSeparator(char8_t character);
-
-/**
- * Removes any trailing directory separators if they exist in the given path.
- *
- * @param path Filesystem path
- *
- * @returns The filesystem path without any trailing directory separators.
- */
-[[nodiscard]] std::filesystem::path RemoveTrailingSeparators(const std::filesystem::path& path);
-
-#ifdef _WIN32
-template <typename Path>
-[[nodiscard]] std::filesystem::path RemoveTrailingSeparators(const Path& path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        return RemoveTrailingSeparators(ToU8String(path));
-    } else {
-        return RemoveTrailingSeparators(std::filesystem::path{path});
-    }
-}
-#endif
-
-/**
- * Gets the filesystem path associated with the YuzuPath enum.
- *
- * @param yuzu_path YuzuPath enum
- *
- * @returns The filesystem path associated with the YuzuPath enum.
- */
-[[nodiscard]] const std::filesystem::path& GetYuzuPath(YuzuPath yuzu_path);
-
-/**
- * Gets the filesystem path associated with the YuzuPath enum as a UTF-8 encoded std::string.
- *
- * @param yuzu_path YuzuPath enum
- *
- * @returns The filesystem path associated with the YuzuPath enum as a UTF-8 encoded std::string.
- */
-[[nodiscard]] std::string GetYuzuPathString(YuzuPath yuzu_path);
-
-/**
- * Sets a new filesystem path associated with the YuzuPath enum.
- * If the filesystem object at new_path is not a directory, this function will not do anything.
- *
- * @param yuzu_path YuzuPath enum
- * @param new_path New filesystem path
- */
-void SetYuzuPath(YuzuPath yuzu_path, const std::filesystem::path& new_path);
-
-#ifdef _WIN32
-template <typename Path>
-void SetYuzuPath(YuzuPath yuzu_path, const Path& new_path) {
-    if constexpr (IsChar<typename Path::value_type>) {
-        SetYuzuPath(yuzu_path, ToU8String(new_path));
-    } else {
-        SetYuzuPath(yuzu_path, std::filesystem::path{new_path});
-    }
-}
-#endif
-
-#ifdef _WIN32
-
-/**
- * Gets the path of the directory containing the executable of the current process.
- *
- * @returns The path of the directory containing the executable of the current process.
- */
-[[nodiscard]] std::filesystem::path GetExeDirectory();
-
-/**
- * Gets the path of the current user's %APPDATA% directory (%USERPROFILE%/AppData/Roaming).
- *
- * @returns The path of the current user's %APPDATA% directory.
- */
-[[nodiscard]] std::filesystem::path GetAppDataRoamingDirectory();
-
-#else
-
-/**
- * Gets the path of the directory specified by the #HOME environment variable.
- * If $HOME is not defined, it will attempt to query the user database in passwd instead.
- *
- * @returns The path of the current user's home directory.
- */
-[[nodiscard]] std::filesystem::path GetHomeDirectory();
-
-/**
- * Gets the relevant paths for yuzu to store its data based on the given XDG environment variable.
- * See https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
- * Defaults to $HOME/.local/share for main application data,
- * $HOME/.cache for cached data, and $HOME/.config for configuration files.
- *
- * @param env_name XDG environment variable name
- *
- * @returns The path where yuzu should store its data.
- */
-[[nodiscard]] std::filesystem::path GetDataDirectory(const std::string& env_name);
-
-#endif
-
-#ifdef __APPLE__
-
-[[nodiscard]] std::filesystem::path GetBundleDirectory();
-
-#endif
-
-// vvvvvvvvvv Deprecated vvvvvvvvvv //
-
-// Removes the final '/' or '\' if one exists
-[[nodiscard]] std::string_view RemoveTrailingSlash(std::string_view path);
-
-enum class DirectorySeparator {
-    ForwardSlash,
-    BackwardSlash,
-    PlatformDefault,
-};
-
-// Splits the path on '/' or '\' and put the components into a vector
-// i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
-[[nodiscard]] std::vector<std::string> SplitPathComponents(std::string_view filename);
-
-// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
-// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
-[[nodiscard]] std::string SanitizePath(
-    std::string_view path,
-    DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
-
-// Gets all of the text up to the last '/' or '\' in the path.
-[[nodiscard]] std::string_view GetParentPath(std::string_view path);
-
-// Gets all of the text after the first '/' or '\' in the path.
-[[nodiscard]] std::string_view GetPathWithoutTop(std::string_view path);
-
-// Gets the filename of the path
-[[nodiscard]] std::string_view GetFilename(std::string_view path);
-
-// Gets the extension of the filename
-[[nodiscard]] std::string_view GetExtensionFromFilename(std::string_view name);
-
-} // namespace Common::FS

src/common/hex_util.h

@@ -53,9 +53,8 @@ template <typename ContiguousContainer>
     std::string out;
     out.reserve(std::size(data) * pad_width);
 
-    const auto format_str = fmt::runtime(upper ? "{:02X}" : "{:02x}");
     for (const u8 c : data) {
-        out += fmt::format(format_str, c);
+        out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
     }
 
     return out;

src/common/host_memory.cpp

@@ -1,538 +0,0 @@
-#ifdef _WIN32
-
-#include <iterator>
-#include <unordered_map>
-#include <boost/icl/separate_interval_set.hpp>
-#include <windows.h>
-#include "common/dynamic_library.h"
-
-#elif defined(__linux__) // ^^^ Windows ^^^ vvv Linux vvv
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <unistd.h>
-
-#endif // ^^^ Linux ^^^
-
-#include <mutex>
-
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/host_memory.h"
-#include "common/logging/log.h"
-#include "common/scope_exit.h"
-
-namespace Common {
-
-constexpr size_t PageAlignment = 0x1000;
-constexpr size_t HugePageSize = 0x200000;
-
-#ifdef _WIN32
-
-// Manually imported for MinGW compatibility
-#ifndef MEM_RESERVE_PLACEHOLDER
-#define MEM_RESERVE_PLACEHOLDER 0x00040000
-#endif
-#ifndef MEM_REPLACE_PLACEHOLDER
-#define MEM_REPLACE_PLACEHOLDER 0x00004000
-#endif
-#ifndef MEM_COALESCE_PLACEHOLDERS
-#define MEM_COALESCE_PLACEHOLDERS 0x00000001
-#endif
-#ifndef MEM_PRESERVE_PLACEHOLDER
-#define MEM_PRESERVE_PLACEHOLDER 0x00000002
-#endif
-
-using PFN_CreateFileMapping2 = _Ret_maybenull_ HANDLE(WINAPI*)(
-    _In_ HANDLE File, _In_opt_ SECURITY_ATTRIBUTES* SecurityAttributes, _In_ ULONG DesiredAccess,
-    _In_ ULONG PageProtection, _In_ ULONG AllocationAttributes, _In_ ULONG64 MaximumSize,
-    _In_opt_ PCWSTR Name,
-    _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
-    _In_ ULONG ParameterCount);
-
-using PFN_VirtualAlloc2 = _Ret_maybenull_ PVOID(WINAPI*)(
-    _In_opt_ HANDLE Process, _In_opt_ PVOID BaseAddress, _In_ SIZE_T Size,
-    _In_ ULONG AllocationType, _In_ ULONG PageProtection,
-    _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
-    _In_ ULONG ParameterCount);
-
-using PFN_MapViewOfFile3 = _Ret_maybenull_ PVOID(WINAPI*)(
-    _In_ HANDLE FileMapping, _In_opt_ HANDLE Process, _In_opt_ PVOID BaseAddress,
-    _In_ ULONG64 Offset, _In_ SIZE_T ViewSize, _In_ ULONG AllocationType, _In_ ULONG PageProtection,
-    _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
-    _In_ ULONG ParameterCount);
-
-using PFN_UnmapViewOfFile2 = BOOL(WINAPI*)(_In_ HANDLE Process, _In_ PVOID BaseAddress,
-                                           _In_ ULONG UnmapFlags);
-
-template <typename T>
-static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn) {
-    if (!dll.GetSymbol(name, &pfn)) {
-        LOG_CRITICAL(HW_Memory, "Failed to load {}", name);
-        throw std::bad_alloc{};
-    }
-}
-
-class HostMemory::Impl {
-public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
-        : backing_size{backing_size_}, virtual_size{virtual_size_}, process{GetCurrentProcess()},
-          kernelbase_dll("Kernelbase") {
-        if (!kernelbase_dll.IsOpen()) {
-            LOG_CRITICAL(HW_Memory, "Failed to load Kernelbase.dll");
-            throw std::bad_alloc{};
-        }
-        GetFuncAddress(kernelbase_dll, "CreateFileMapping2", pfn_CreateFileMapping2);
-        GetFuncAddress(kernelbase_dll, "VirtualAlloc2", pfn_VirtualAlloc2);
-        GetFuncAddress(kernelbase_dll, "MapViewOfFile3", pfn_MapViewOfFile3);
-        GetFuncAddress(kernelbase_dll, "UnmapViewOfFile2", pfn_UnmapViewOfFile2);
-
-        // Allocate backing file map
-        backing_handle =
-            pfn_CreateFileMapping2(INVALID_HANDLE_VALUE, nullptr, FILE_MAP_WRITE | FILE_MAP_READ,
-                                   PAGE_READWRITE, SEC_COMMIT, backing_size, nullptr, nullptr, 0);
-        if (!backing_handle) {
-            LOG_CRITICAL(HW_Memory, "Failed to allocate {} MiB of backing memory",
-                         backing_size >> 20);
-            throw std::bad_alloc{};
-        }
-        // Allocate a virtual memory for the backing file map as placeholder
-        backing_base = static_cast<u8*>(pfn_VirtualAlloc2(process, nullptr, backing_size,
-                                                          MEM_RESERVE | MEM_RESERVE_PLACEHOLDER,
-                                                          PAGE_NOACCESS, nullptr, 0));
-        if (!backing_base) {
-            Release();
-            LOG_CRITICAL(HW_Memory, "Failed to reserve {} MiB of virtual memory",
-                         backing_size >> 20);
-            throw std::bad_alloc{};
-        }
-        // Map backing placeholder
-        void* const ret = pfn_MapViewOfFile3(backing_handle, process, backing_base, 0, backing_size,
-                                             MEM_REPLACE_PLACEHOLDER, PAGE_READWRITE, nullptr, 0);
-        if (ret != backing_base) {
-            Release();
-            LOG_CRITICAL(HW_Memory, "Failed to map {} MiB of virtual memory", backing_size >> 20);
-            throw std::bad_alloc{};
-        }
-        // Allocate virtual address placeholder
-        virtual_base = static_cast<u8*>(pfn_VirtualAlloc2(process, nullptr, virtual_size,
-                                                          MEM_RESERVE | MEM_RESERVE_PLACEHOLDER,
-                                                          PAGE_NOACCESS, nullptr, 0));
-        if (!virtual_base) {
-            Release();
-            LOG_CRITICAL(HW_Memory, "Failed to reserve {} GiB of virtual memory",
-                         virtual_size >> 30);
-            throw std::bad_alloc{};
-        }
-    }
-
-    ~Impl() {
-        Release();
-    }
-
-    void Map(size_t virtual_offset, size_t host_offset, size_t length) {
-        std::unique_lock lock{placeholder_mutex};
-        if (!IsNiechePlaceholder(virtual_offset, length)) {
-            Split(virtual_offset, length);
-        }
-        ASSERT(placeholders.find({virtual_offset, virtual_offset + length}) == placeholders.end());
-        TrackPlaceholder(virtual_offset, host_offset, length);
-
-        MapView(virtual_offset, host_offset, length);
-    }
-
-    void Unmap(size_t virtual_offset, size_t length) {
-        std::lock_guard lock{placeholder_mutex};
-
-        // Unmap until there are no more placeholders
-        while (UnmapOnePlaceholder(virtual_offset, length)) {
-        }
-    }
-
-    void Protect(size_t virtual_offset, size_t length, bool read, bool write) {
-        DWORD new_flags{};
-        if (read && write) {
-            new_flags = PAGE_READWRITE;
-        } else if (read && !write) {
-            new_flags = PAGE_READONLY;
-        } else if (!read && !write) {
-            new_flags = PAGE_NOACCESS;
-        } else {
-            UNIMPLEMENTED_MSG("Protection flag combination read={} write={}", read, write);
-        }
-        const size_t virtual_end = virtual_offset + length;
-
-        std::lock_guard lock{placeholder_mutex};
-        auto [it, end] = placeholders.equal_range({virtual_offset, virtual_end});
-        while (it != end) {
-            const size_t offset = std::max(it->lower(), virtual_offset);
-            const size_t protect_length = std::min(it->upper(), virtual_end) - offset;
-            DWORD old_flags{};
-            if (!VirtualProtect(virtual_base + offset, protect_length, new_flags, &old_flags)) {
-                LOG_CRITICAL(HW_Memory, "Failed to change virtual memory protect rules");
-            }
-            ++it;
-        }
-    }
-
-    const size_t backing_size; ///< Size of the backing memory in bytes
-    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
-
-    u8* backing_base{};
-    u8* virtual_base{};
-
-private:
-    /// Release all resources in the object
-    void Release() {
-        if (!placeholders.empty()) {
-            for (const auto& placeholder : placeholders) {
-                if (!pfn_UnmapViewOfFile2(process, virtual_base + placeholder.lower(),
-                                          MEM_PRESERVE_PLACEHOLDER)) {
-                    LOG_CRITICAL(HW_Memory, "Failed to unmap virtual memory placeholder");
-                }
-            }
-            Coalesce(0, virtual_size);
-        }
-        if (virtual_base) {
-            if (!VirtualFree(virtual_base, 0, MEM_RELEASE)) {
-                LOG_CRITICAL(HW_Memory, "Failed to free virtual memory");
-            }
-        }
-        if (backing_base) {
-            if (!pfn_UnmapViewOfFile2(process, backing_base, MEM_PRESERVE_PLACEHOLDER)) {
-                LOG_CRITICAL(HW_Memory, "Failed to unmap backing memory placeholder");
-            }
-            if (!VirtualFreeEx(process, backing_base, 0, MEM_RELEASE)) {
-                LOG_CRITICAL(HW_Memory, "Failed to free backing memory");
-            }
-        }
-        if (!CloseHandle(backing_handle)) {
-            LOG_CRITICAL(HW_Memory, "Failed to free backing memory file handle");
-        }
-    }
-
-    /// Unmap one placeholder in the given range (partial unmaps are supported)
-    /// Return true when there are no more placeholders to unmap
-    bool UnmapOnePlaceholder(size_t virtual_offset, size_t length) {
-        const auto it = placeholders.find({virtual_offset, virtual_offset + length});
-        const auto begin = placeholders.begin();
-        const auto end = placeholders.end();
-        if (it == end) {
-            return false;
-        }
-        const size_t placeholder_begin = it->lower();
-        const size_t placeholder_end = it->upper();
-        const size_t unmap_begin = std::max(virtual_offset, placeholder_begin);
-        const size_t unmap_end = std::min(virtual_offset + length, placeholder_end);
-        ASSERT(unmap_begin >= placeholder_begin && unmap_begin < placeholder_end);
-        ASSERT(unmap_end <= placeholder_end && unmap_end > placeholder_begin);
-
-        const auto host_pointer_it = placeholder_host_pointers.find(placeholder_begin);
-        ASSERT(host_pointer_it != placeholder_host_pointers.end());
-        const size_t host_offset = host_pointer_it->second;
-
-        const bool split_left = unmap_begin > placeholder_begin;
-        const bool split_right = unmap_end < placeholder_end;
-
-        if (!pfn_UnmapViewOfFile2(process, virtual_base + placeholder_begin,
-                                  MEM_PRESERVE_PLACEHOLDER)) {
-            LOG_CRITICAL(HW_Memory, "Failed to unmap placeholder");
-        }
-        // If we have to remap memory regions due to partial unmaps, we are in a data race as
-        // Windows doesn't support remapping memory without unmapping first. Avoid adding any extra
-        // logic within the panic region described below.
-
-        // Panic region, we are in a data race right now
-        if (split_left || split_right) {
-            Split(unmap_begin, unmap_end - unmap_begin);
-        }
-        if (split_left) {
-            MapView(placeholder_begin, host_offset, unmap_begin - placeholder_begin);
-        }
-        if (split_right) {
-            MapView(unmap_end, host_offset + unmap_end - placeholder_begin,
-                    placeholder_end - unmap_end);
-        }
-        // End panic region
-
-        size_t coalesce_begin = unmap_begin;
-        if (!split_left) {
-            // Try to coalesce pages to the left
-            coalesce_begin = it == begin ? 0 : std::prev(it)->upper();
-            if (coalesce_begin != placeholder_begin) {
-                Coalesce(coalesce_begin, unmap_end - coalesce_begin);
-            }
-        }
-        if (!split_right) {
-            // Try to coalesce pages to the right
-            const auto next = std::next(it);
-            const size_t next_begin = next == end ? virtual_size : next->lower();
-            if (placeholder_end != next_begin) {
-                // We can coalesce to the right
-                Coalesce(coalesce_begin, next_begin - coalesce_begin);
-            }
-        }
-        // Remove and reinsert placeholder trackers
-        UntrackPlaceholder(it);
-        if (split_left) {
-            TrackPlaceholder(placeholder_begin, host_offset, unmap_begin - placeholder_begin);
-        }
-        if (split_right) {
-            TrackPlaceholder(unmap_end, host_offset + unmap_end - placeholder_begin,
-                             placeholder_end - unmap_end);
-        }
-        return true;
-    }
-
-    void MapView(size_t virtual_offset, size_t host_offset, size_t length) {
-        if (!pfn_MapViewOfFile3(backing_handle, process, virtual_base + virtual_offset, host_offset,
-                                length, MEM_REPLACE_PLACEHOLDER, PAGE_READWRITE, nullptr, 0)) {
-            LOG_CRITICAL(HW_Memory, "Failed to map placeholder");
-        }
-    }
-
-    void Split(size_t virtual_offset, size_t length) {
-        if (!VirtualFreeEx(process, reinterpret_cast<LPVOID>(virtual_base + virtual_offset), length,
-                           MEM_RELEASE | MEM_PRESERVE_PLACEHOLDER)) {
-            LOG_CRITICAL(HW_Memory, "Failed to split placeholder");
-        }
-    }
-
-    void Coalesce(size_t virtual_offset, size_t length) {
-        if (!VirtualFreeEx(process, reinterpret_cast<LPVOID>(virtual_base + virtual_offset), length,
-                           MEM_RELEASE | MEM_COALESCE_PLACEHOLDERS)) {
-            LOG_CRITICAL(HW_Memory, "Failed to coalesce placeholders");
-        }
-    }
-
-    void TrackPlaceholder(size_t virtual_offset, size_t host_offset, size_t length) {
-        placeholders.insert({virtual_offset, virtual_offset + length});
-        placeholder_host_pointers.emplace(virtual_offset, host_offset);
-    }
-
-    void UntrackPlaceholder(boost::icl::separate_interval_set<size_t>::iterator it) {
-        placeholders.erase(it);
-        placeholder_host_pointers.erase(it->lower());
-    }
-
-    /// Return true when a given memory region is a "nieche" and the placeholders don't have to be
-    /// splitted.
-    bool IsNiechePlaceholder(size_t virtual_offset, size_t length) const {
-        const auto it = placeholders.upper_bound({virtual_offset, virtual_offset + length});
-        if (it != placeholders.end() && it->lower() == virtual_offset + length) {
-            const bool is_root = it == placeholders.begin() && virtual_offset == 0;
-            return is_root || std::prev(it)->upper() == virtual_offset;
-        }
-        return false;
-    }
-
-    HANDLE process{};        ///< Current process handle
-    HANDLE backing_handle{}; ///< File based backing memory
-
-    DynamicLibrary kernelbase_dll;
-    PFN_CreateFileMapping2 pfn_CreateFileMapping2{};
-    PFN_VirtualAlloc2 pfn_VirtualAlloc2{};
-    PFN_MapViewOfFile3 pfn_MapViewOfFile3{};
-    PFN_UnmapViewOfFile2 pfn_UnmapViewOfFile2{};
-
-    std::mutex placeholder_mutex;                                 ///< Mutex for placeholders
-    boost::icl::separate_interval_set<size_t> placeholders;       ///< Mapped placeholders
-    std::unordered_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
-};
-
-#elif defined(__linux__) // ^^^ Windows ^^^ vvv Linux vvv
-
-class HostMemory::Impl {
-public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
-        : backing_size{backing_size_}, virtual_size{virtual_size_} {
-        bool good = false;
-        SCOPE_EXIT({
-            if (!good) {
-                Release();
-            }
-        });
-
-        // Backing memory initialization
-        fd = memfd_create("HostMemory", 0);
-        if (fd == -1) {
-            LOG_CRITICAL(HW_Memory, "memfd_create failed: {}", strerror(errno));
-            throw std::bad_alloc{};
-        }
-
-        // Defined to extend the file with zeros
-        int ret = ftruncate(fd, backing_size);
-        if (ret != 0) {
-            LOG_CRITICAL(HW_Memory, "ftruncate failed with {}, are you out-of-memory?",
-                         strerror(errno));
-            throw std::bad_alloc{};
-        }
-
-        backing_base = static_cast<u8*>(
-            mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
-        if (backing_base == MAP_FAILED) {
-            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
-            throw std::bad_alloc{};
-        }
-
-        // Virtual memory initialization
-        virtual_base = static_cast<u8*>(
-            mmap(nullptr, virtual_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
-        if (virtual_base == MAP_FAILED) {
-            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
-            throw std::bad_alloc{};
-        }
-
-        good = true;
-    }
-
-    ~Impl() {
-        Release();
-    }
-
-    void Map(size_t virtual_offset, size_t host_offset, size_t length) {
-
-        void* ret = mmap(virtual_base + virtual_offset, length, PROT_READ | PROT_WRITE,
-                         MAP_SHARED | MAP_FIXED, fd, host_offset);
-        ASSERT_MSG(ret != MAP_FAILED, "mmap failed: {}", strerror(errno));
-    }
-
-    void Unmap(size_t virtual_offset, size_t length) {
-        // The method name is wrong. We're still talking about the virtual range.
-        // We don't want to unmap, we want to reserve this memory.
-
-        void* ret = mmap(virtual_base + virtual_offset, length, PROT_NONE,
-                         MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
-        ASSERT_MSG(ret != MAP_FAILED, "mmap failed: {}", strerror(errno));
-    }
-
-    void Protect(size_t virtual_offset, size_t length, bool read, bool write) {
-        int flags = 0;
-        if (read) {
-            flags |= PROT_READ;
-        }
-        if (write) {
-            flags |= PROT_WRITE;
-        }
-        int ret = mprotect(virtual_base + virtual_offset, length, flags);
-        ASSERT_MSG(ret == 0, "mprotect failed: {}", strerror(errno));
-    }
-
-    const size_t backing_size; ///< Size of the backing memory in bytes
-    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
-
-    u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
-    u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
-
-private:
-    /// Release all resources in the object
-    void Release() {
-        if (virtual_base != MAP_FAILED) {
-            int ret = munmap(virtual_base, virtual_size);
-            ASSERT_MSG(ret == 0, "munmap failed: {}", strerror(errno));
-        }
-
-        if (backing_base != MAP_FAILED) {
-            int ret = munmap(backing_base, backing_size);
-            ASSERT_MSG(ret == 0, "munmap failed: {}", strerror(errno));
-        }
-
-        if (fd != -1) {
-            int ret = close(fd);
-            ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
-        }
-    }
-
-    int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
-};
-
-#else // ^^^ Linux ^^^ vvv Generic vvv
-
-class HostMemory::Impl {
-public:
-    explicit Impl(size_t /*backing_size */, size_t /* virtual_size */) {
-        // This is just a place holder.
-        // Please implement fastmem in a propper way on your platform.
-        throw std::bad_alloc{};
-    }
-
-    void Map(size_t virtual_offset, size_t host_offset, size_t length) {}
-
-    void Unmap(size_t virtual_offset, size_t length) {}
-
-    void Protect(size_t virtual_offset, size_t length, bool read, bool write) {}
-
-    u8* backing_base{nullptr};
-    u8* virtual_base{nullptr};
-};
-
-#endif // ^^^ Generic ^^^
-
-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
-    : backing_size(backing_size_), virtual_size(virtual_size_) {
-    try {
-        // Try to allocate a fastmem arena.
-        // The implementation will fail with std::bad_alloc on errors.
-        impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment),
-                                                  AlignUp(virtual_size, PageAlignment) +
-                                                      3 * HugePageSize);
-        backing_base = impl->backing_base;
-        virtual_base = impl->virtual_base;
-
-        if (virtual_base) {
-            virtual_base += 2 * HugePageSize - 1;
-            virtual_base -= reinterpret_cast<size_t>(virtual_base) & (HugePageSize - 1);
-            virtual_base_offset = virtual_base - impl->virtual_base;
-        }
-
-    } catch (const std::bad_alloc&) {
-        LOG_CRITICAL(HW_Memory,
-                     "Fastmem unavailable, falling back to VirtualBuffer for memory allocation");
-        fallback_buffer = std::make_unique<Common::VirtualBuffer<u8>>(backing_size);
-        backing_base = fallback_buffer->data();
-        virtual_base = nullptr;
-    }
-}
-
-HostMemory::~HostMemory() = default;
-
-HostMemory::HostMemory(HostMemory&&) noexcept = default;
-
-HostMemory& HostMemory::operator=(HostMemory&&) noexcept = default;
-
-void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length) {
-    ASSERT(virtual_offset % PageAlignment == 0);
-    ASSERT(host_offset % PageAlignment == 0);
-    ASSERT(length % PageAlignment == 0);
-    ASSERT(virtual_offset + length <= virtual_size);
-    ASSERT(host_offset + length <= backing_size);
-    if (length == 0 || !virtual_base || !impl) {
-        return;
-    }
-    impl->Map(virtual_offset + virtual_base_offset, host_offset, length);
-}
-
-void HostMemory::Unmap(size_t virtual_offset, size_t length) {
-    ASSERT(virtual_offset % PageAlignment == 0);
-    ASSERT(length % PageAlignment == 0);
-    ASSERT(virtual_offset + length <= virtual_size);
-    if (length == 0 || !virtual_base || !impl) {
-        return;
-    }
-    impl->Unmap(virtual_offset + virtual_base_offset, length);
-}
-
-void HostMemory::Protect(size_t virtual_offset, size_t length, bool read, bool write) {
-    ASSERT(virtual_offset % PageAlignment == 0);
-    ASSERT(length % PageAlignment == 0);
-    ASSERT(virtual_offset + length <= virtual_size);
-    if (length == 0 || !virtual_base || !impl) {
-        return;
-    }
-    impl->Protect(virtual_offset + virtual_base_offset, length, read, write);
-}
-
-} // namespace Common

src/common/host_memory.h

@@ -1,70 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "common/common_types.h"
-#include "common/virtual_buffer.h"
-
-namespace Common {
-
-/**
- * A low level linear memory buffer, which supports multiple mappings
- * Its purpose is to rebuild a given sparse memory layout, including mirrors.
- */
-class HostMemory {
-public:
-    explicit HostMemory(size_t backing_size_, size_t virtual_size_);
-    ~HostMemory();
-
-    /**
-     * Copy constructors. They shall return a copy of the buffer without the mappings.
-     * TODO: Implement them with COW if needed.
-     */
-    HostMemory(const HostMemory& other) = delete;
-    HostMemory& operator=(const HostMemory& other) = delete;
-
-    /**
-     * Move constructors. They will move the buffer and the mappings to the new object.
-     */
-    HostMemory(HostMemory&& other) noexcept;
-    HostMemory& operator=(HostMemory&& other) noexcept;
-
-    void Map(size_t virtual_offset, size_t host_offset, size_t length);
-
-    void Unmap(size_t virtual_offset, size_t length);
-
-    void Protect(size_t virtual_offset, size_t length, bool read, bool write);
-
-    [[nodiscard]] u8* BackingBasePointer() noexcept {
-        return backing_base;
-    }
-    [[nodiscard]] const u8* BackingBasePointer() const noexcept {
-        return backing_base;
-    }
-
-    [[nodiscard]] u8* VirtualBasePointer() noexcept {
-        return virtual_base;
-    }
-    [[nodiscard]] const u8* VirtualBasePointer() const noexcept {
-        return virtual_base;
-    }
-
-private:
-    size_t backing_size{};
-    size_t virtual_size{};
-
-    // Low level handler for the platform dependent memory routines
-    class Impl;
-    std::unique_ptr<Impl> impl;
-    u8* backing_base{};
-    u8* virtual_base{};
-    size_t virtual_base_offset{};
-
-    // Fallback if fastmem is not supported on this platform
-    std::unique_ptr<Common::VirtualBuffer<u8>> fallback_buffer;
-};
-
-} // namespace Common

src/common/intrusive_red_black_tree.h

@@ -509,6 +509,7 @@ private:
 
 private:
     static constexpr TypedStorage<Derived> DerivedStorage = {};
+    static_assert(GetParent(GetNode(GetPointer(DerivedStorage))) == GetPointer(DerivedStorage));
 };
 
 template <auto T, class Derived = impl::GetParentType<T>>

src/common/literals.h

@@ -1,31 +0,0 @@
-// Copyright 2021 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Common::Literals {
-
-constexpr u64 operator""_KiB(unsigned long long int x) {
-    return 1024ULL * x;
-}
-
-constexpr u64 operator""_MiB(unsigned long long int x) {
-    return 1024_KiB * x;
-}
-
-constexpr u64 operator""_GiB(unsigned long long int x) {
-    return 1024_MiB * x;
-}
-
-constexpr u64 operator""_TiB(unsigned long long int x) {
-    return 1024_GiB * x;
-}
-
-constexpr u64 operator""_PiB(unsigned long long int x) {
-    return 1024_TiB * x;
-}
-
-} // namespace Common::Literals

src/common/logging/backend.cpp

@@ -11,16 +11,13 @@
 #include <mutex>
 #include <thread>
 #include <vector>
-
 #ifdef _WIN32
+#include <share.h>   // For _SH_DENYWR
 #include <windows.h> // For OutputDebugStringW
+#else
+#define _SH_DENYWR 0
 #endif
-
 #include "common/assert.h"
-#include "common/fs/file.h"
-#include "common/fs/fs.h"
-#include "common/literals.h"
-
 #include "common/logging/backend.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
@@ -100,8 +97,8 @@ private:
                 write_logs(entry);
             }
 
-            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-            // case where a system is repeatedly spamming logs even on close.
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a case
+            // where a system is repeatedly spamming logs even on close.
             const int MAX_LOGS_TO_WRITE = filter.IsDebug() ? INT_MAX : 100;
             int logs_written = 0;
             while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
@@ -143,67 +140,186 @@ private:
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 
-ConsoleBackend::~ConsoleBackend() = default;
-
 void ConsoleBackend::Write(const Entry& entry) {
     PrintMessage(entry);
 }
 
-ColorConsoleBackend::~ColorConsoleBackend() = default;
-
 void ColorConsoleBackend::Write(const Entry& entry) {
     PrintColoredMessage(entry);
 }
 
-FileBackend::FileBackend(const std::filesystem::path& filename) {
-    auto old_filename = filename;
-    old_filename += ".old.txt";
+FileBackend::FileBackend(const std::string& filename) {
+    const auto old_filename = filename + ".old.txt";
 
-    // Existence checks are done within the functions themselves.
-    // We don't particularly care if these succeed or not.
-    FS::RemoveFile(old_filename);
-    void(FS::RenameFile(filename, old_filename));
+    if (FS::Exists(old_filename)) {
+        FS::Delete(old_filename);
+    }
+    if (FS::Exists(filename)) {
+        FS::Rename(filename, old_filename);
+    }
 
-    file =
-        std::make_unique<FS::IOFile>(filename, FS::FileAccessMode::Write, FS::FileType::TextFile);
+    // _SH_DENYWR allows read only access to the file for other programs.
+    // It is #defined to 0 on other platforms
+    file = FS::IOFile(filename, "w", _SH_DENYWR);
 }
 
-FileBackend::~FileBackend() = default;
-
 void FileBackend::Write(const Entry& entry) {
-    if (!file->IsOpen()) {
+    // prevent logs from going over the maximum size (in case its spamming and the user doesn't
+    // know)
+    constexpr std::size_t MAX_BYTES_WRITTEN = 100 * 1024 * 1024;
+    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1024 * 1024 * 1024;
+
+    if (!file.IsOpen()) {
         return;
     }
 
-    using namespace Common::Literals;
-    // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
-    constexpr std::size_t MAX_BYTES_WRITTEN = 100_MiB;
-    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1_GiB;
-
-    const bool write_limit_exceeded =
-        bytes_written > MAX_BYTES_WRITTEN_EXTENDED ||
-        (bytes_written > MAX_BYTES_WRITTEN && !Settings::values.extended_logging);
-
-    // Close the file after the write limit is exceeded.
-    if (write_limit_exceeded) {
-        file->Close();
+    if (Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN_EXTENDED) {
+        return;
+    } else if (!Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN) {
         return;
     }
 
-    bytes_written += file->WriteString(FormatLogMessage(entry).append(1, '\n'));
+    bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
     if (entry.log_level >= Level::Error) {
-        file->Flush();
+        file.Flush();
     }
 }
 
-DebuggerBackend::~DebuggerBackend() = default;
-
 void DebuggerBackend::Write(const Entry& entry) {
 #ifdef _WIN32
     ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
 #endif
 }
 
+/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
+#define ALL_LOG_CLASSES()                                                                          \
+    CLS(Log)                                                                                       \
+    CLS(Common)                                                                                    \
+    SUB(Common, Filesystem)                                                                        \
+    SUB(Common, Memory)                                                                            \
+    CLS(Core)                                                                                      \
+    SUB(Core, ARM)                                                                                 \
+    SUB(Core, Timing)                                                                              \
+    CLS(Config)                                                                                    \
+    CLS(Debug)                                                                                     \
+    SUB(Debug, Emulated)                                                                           \
+    SUB(Debug, GPU)                                                                                \
+    SUB(Debug, Breakpoint)                                                                         \
+    SUB(Debug, GDBStub)                                                                            \
+    CLS(Kernel)                                                                                    \
+    SUB(Kernel, SVC)                                                                               \
+    CLS(Service)                                                                                   \
+    SUB(Service, ACC)                                                                              \
+    SUB(Service, Audio)                                                                            \
+    SUB(Service, AM)                                                                               \
+    SUB(Service, AOC)                                                                              \
+    SUB(Service, APM)                                                                              \
+    SUB(Service, ARP)                                                                              \
+    SUB(Service, BCAT)                                                                             \
+    SUB(Service, BPC)                                                                              \
+    SUB(Service, BGTC)                                                                             \
+    SUB(Service, BTDRV)                                                                            \
+    SUB(Service, BTM)                                                                              \
+    SUB(Service, Capture)                                                                          \
+    SUB(Service, ERPT)                                                                             \
+    SUB(Service, ETicket)                                                                          \
+    SUB(Service, EUPLD)                                                                            \
+    SUB(Service, Fatal)                                                                            \
+    SUB(Service, FGM)                                                                              \
+    SUB(Service, Friend)                                                                           \
+    SUB(Service, FS)                                                                               \
+    SUB(Service, GRC)                                                                              \
+    SUB(Service, HID)                                                                              \
+    SUB(Service, IRS)                                                                              \
+    SUB(Service, LBL)                                                                              \
+    SUB(Service, LDN)                                                                              \
+    SUB(Service, LDR)                                                                              \
+    SUB(Service, LM)                                                                               \
+    SUB(Service, Migration)                                                                        \
+    SUB(Service, Mii)                                                                              \
+    SUB(Service, MM)                                                                               \
+    SUB(Service, NCM)                                                                              \
+    SUB(Service, NFC)                                                                              \
+    SUB(Service, NFP)                                                                              \
+    SUB(Service, NIFM)                                                                             \
+    SUB(Service, NIM)                                                                              \
+    SUB(Service, NPNS)                                                                             \
+    SUB(Service, NS)                                                                               \
+    SUB(Service, NVDRV)                                                                            \
+    SUB(Service, OLSC)                                                                             \
+    SUB(Service, PCIE)                                                                             \
+    SUB(Service, PCTL)                                                                             \
+    SUB(Service, PCV)                                                                              \
+    SUB(Service, PM)                                                                               \
+    SUB(Service, PREPO)                                                                            \
+    SUB(Service, PSC)                                                                              \
+    SUB(Service, PSM)                                                                              \
+    SUB(Service, SET)                                                                              \
+    SUB(Service, SM)                                                                               \
+    SUB(Service, SPL)                                                                              \
+    SUB(Service, SSL)                                                                              \
+    SUB(Service, TCAP)                                                                             \
+    SUB(Service, Time)                                                                             \
+    SUB(Service, USB)                                                                              \
+    SUB(Service, VI)                                                                               \
+    SUB(Service, WLAN)                                                                             \
+    CLS(HW)                                                                                        \
+    SUB(HW, Memory)                                                                                \
+    SUB(HW, LCD)                                                                                   \
+    SUB(HW, GPU)                                                                                   \
+    SUB(HW, AES)                                                                                   \
+    CLS(IPC)                                                                                       \
+    CLS(Frontend)                                                                                  \
+    CLS(Render)                                                                                    \
+    SUB(Render, Software)                                                                          \
+    SUB(Render, OpenGL)                                                                            \
+    SUB(Render, Vulkan)                                                                            \
+    CLS(Audio)                                                                                     \
+    SUB(Audio, DSP)                                                                                \
+    SUB(Audio, Sink)                                                                               \
+    CLS(Input)                                                                                     \
+    CLS(Network)                                                                                   \
+    CLS(Loader)                                                                                    \
+    CLS(CheatEngine)                                                                               \
+    CLS(Crypto)                                                                                    \
+    CLS(WebService)
+
+// GetClassName is a macro defined by Windows.h, grrr...
+const char* GetLogClassName(Class log_class) {
+    switch (log_class) {
+#define CLS(x)                                                                                     \
+    case Class::x:                                                                                 \
+        return #x;
+#define SUB(x, y)                                                                                  \
+    case Class::x##_##y:                                                                           \
+        return #x "." #y;
+        ALL_LOG_CLASSES()
+#undef CLS
+#undef SUB
+    case Class::Count:
+        break;
+    }
+    return "Invalid";
+}
+
+const char* GetLevelName(Level log_level) {
+#define LVL(x)                                                                                     \
+    case Level::x:                                                                                 \
+        return #x
+    switch (log_level) {
+        LVL(Trace);
+        LVL(Debug);
+        LVL(Info);
+        LVL(Warning);
+        LVL(Error);
+        LVL(Critical);
+    case Level::Count:
+        break;
+    }
+#undef LVL
+    return "Invalid";
+}
+
 void SetGlobalFilter(const Filter& filter) {
     Impl::Instance().SetGlobalFilter(filter);
 }

src/common/logging/backend.h

@@ -1,24 +1,35 @@
 // Copyright 2014 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-
 #pragma once
 
-#include <filesystem>
+#include <chrono>
 #include <memory>
 #include <string>
 #include <string_view>
+#include "common/file_util.h"
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
 
-namespace Common::FS {
-class IOFile;
-}
-
 namespace Common::Log {
 
 class Filter;
 
+/**
+ * A log entry. Log entries are store in a structured format to permit more varied output
+ * formatting on different frontends, as well as facilitating filtering and aggregation.
+ */
+struct Entry {
+    std::chrono::microseconds timestamp;
+    Class log_class{};
+    Level log_level{};
+    const char* filename = nullptr;
+    unsigned int line_num = 0;
+    std::string function;
+    std::string message;
+    bool final_entry = false;
+};
+
 /**
  * Interface for logging backends. As loggers can be created and removed at runtime, this can be
  * used by a frontend for adding a custom logging backend as needed
@@ -26,7 +37,6 @@ class Filter;
 class Backend {
 public:
     virtual ~Backend() = default;
-
     virtual void SetFilter(const Filter& new_filter) {
         filter = new_filter;
     }
@@ -42,8 +52,6 @@ private:
  */
 class ConsoleBackend : public Backend {
 public:
-    ~ConsoleBackend() override;
-
     static const char* Name() {
         return "console";
     }
@@ -58,8 +66,6 @@ public:
  */
 class ColorConsoleBackend : public Backend {
 public:
-    ~ColorConsoleBackend() override;
-
     static const char* Name() {
         return "color_console";
     }
@@ -75,8 +81,7 @@ public:
  */
 class FileBackend : public Backend {
 public:
-    explicit FileBackend(const std::filesystem::path& filename);
-    ~FileBackend() override;
+    explicit FileBackend(const std::string& filename);
 
     static const char* Name() {
         return "file";
@@ -89,7 +94,7 @@ public:
     void Write(const Entry& entry) override;
 
 private:
-    std::unique_ptr<FS::IOFile> file;
+    FS::IOFile file;
     std::size_t bytes_written = 0;
 };
 
@@ -98,8 +103,6 @@ private:
  */
 class DebuggerBackend : public Backend {
 public:
-    ~DebuggerBackend() override;
-
     static const char* Name() {
         return "debugger";
     }
@@ -115,6 +118,17 @@ void RemoveBackend(std::string_view backend_name);
 
 Backend* GetBackend(std::string_view backend_name);
 
+/**
+ * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
+ * instead of underscores as in the enumeration.
+ */
+const char* GetLogClassName(Class log_class);
+
+/**
+ * Returns the name of the passed log level as a C-string.
+ */
+const char* GetLevelName(Level log_level);
+
 /**
  * The global filter will prevent any messages from even being processed if they are filtered. Each
  * backend can have a filter, but if the level is lower than the global filter, the backend will

src/common/logging/filter.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include "common/logging/backend.h"
 #include "common/logging/filter.h"
 #include "common/string_util.h"
 
@@ -21,7 +22,7 @@ Level GetLevelByName(const It begin, const It end) {
 
 template <typename It>
 Class GetClassByName(const It begin, const It end) {
-    for (u8 i = 0; i < static_cast<u8>(Class::Count); ++i) {
+    for (ClassType i = 0; i < static_cast<ClassType>(Class::Count); ++i) {
         const char* level_name = GetLogClassName(static_cast<Class>(i));
         if (Common::ComparePartialString(begin, end, level_name)) {
             return static_cast<Class>(i);
@@ -61,139 +62,6 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
 }
 } // Anonymous namespace
 
-/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
-#define ALL_LOG_CLASSES()                                                                          \
-    CLS(Log)                                                                                       \
-    CLS(Common)                                                                                    \
-    SUB(Common, Filesystem)                                                                        \
-    SUB(Common, Memory)                                                                            \
-    CLS(Core)                                                                                      \
-    SUB(Core, ARM)                                                                                 \
-    SUB(Core, Timing)                                                                              \
-    CLS(Config)                                                                                    \
-    CLS(Debug)                                                                                     \
-    SUB(Debug, Emulated)                                                                           \
-    SUB(Debug, GPU)                                                                                \
-    SUB(Debug, Breakpoint)                                                                         \
-    SUB(Debug, GDBStub)                                                                            \
-    CLS(Kernel)                                                                                    \
-    SUB(Kernel, SVC)                                                                               \
-    CLS(Service)                                                                                   \
-    SUB(Service, ACC)                                                                              \
-    SUB(Service, Audio)                                                                            \
-    SUB(Service, AM)                                                                               \
-    SUB(Service, AOC)                                                                              \
-    SUB(Service, APM)                                                                              \
-    SUB(Service, ARP)                                                                              \
-    SUB(Service, BCAT)                                                                             \
-    SUB(Service, BPC)                                                                              \
-    SUB(Service, BGTC)                                                                             \
-    SUB(Service, BTDRV)                                                                            \
-    SUB(Service, BTM)                                                                              \
-    SUB(Service, Capture)                                                                          \
-    SUB(Service, ERPT)                                                                             \
-    SUB(Service, ETicket)                                                                          \
-    SUB(Service, EUPLD)                                                                            \
-    SUB(Service, Fatal)                                                                            \
-    SUB(Service, FGM)                                                                              \
-    SUB(Service, Friend)                                                                           \
-    SUB(Service, FS)                                                                               \
-    SUB(Service, GRC)                                                                              \
-    SUB(Service, HID)                                                                              \
-    SUB(Service, IRS)                                                                              \
-    SUB(Service, LBL)                                                                              \
-    SUB(Service, LDN)                                                                              \
-    SUB(Service, LDR)                                                                              \
-    SUB(Service, LM)                                                                               \
-    SUB(Service, Migration)                                                                        \
-    SUB(Service, Mii)                                                                              \
-    SUB(Service, MM)                                                                               \
-    SUB(Service, NCM)                                                                              \
-    SUB(Service, NFC)                                                                              \
-    SUB(Service, NFP)                                                                              \
-    SUB(Service, NIFM)                                                                             \
-    SUB(Service, NIM)                                                                              \
-    SUB(Service, NPNS)                                                                             \
-    SUB(Service, NS)                                                                               \
-    SUB(Service, NVDRV)                                                                            \
-    SUB(Service, OLSC)                                                                             \
-    SUB(Service, PCIE)                                                                             \
-    SUB(Service, PCTL)                                                                             \
-    SUB(Service, PCV)                                                                              \
-    SUB(Service, PM)                                                                               \
-    SUB(Service, PREPO)                                                                            \
-    SUB(Service, PSC)                                                                              \
-    SUB(Service, PSM)                                                                              \
-    SUB(Service, SET)                                                                              \
-    SUB(Service, SM)                                                                               \
-    SUB(Service, SPL)                                                                              \
-    SUB(Service, SSL)                                                                              \
-    SUB(Service, TCAP)                                                                             \
-    SUB(Service, Time)                                                                             \
-    SUB(Service, USB)                                                                              \
-    SUB(Service, VI)                                                                               \
-    SUB(Service, WLAN)                                                                             \
-    CLS(HW)                                                                                        \
-    SUB(HW, Memory)                                                                                \
-    SUB(HW, LCD)                                                                                   \
-    SUB(HW, GPU)                                                                                   \
-    SUB(HW, AES)                                                                                   \
-    CLS(IPC)                                                                                       \
-    CLS(Frontend)                                                                                  \
-    CLS(Render)                                                                                    \
-    SUB(Render, Software)                                                                          \
-    SUB(Render, OpenGL)                                                                            \
-    SUB(Render, Vulkan)                                                                            \
-    CLS(Shader)                                                                                    \
-    SUB(Shader, SPIRV)                                                                             \
-    SUB(Shader, GLASM)                                                                             \
-    SUB(Shader, GLSL)                                                                              \
-    CLS(Audio)                                                                                     \
-    SUB(Audio, DSP)                                                                                \
-    SUB(Audio, Sink)                                                                               \
-    CLS(Input)                                                                                     \
-    CLS(Network)                                                                                   \
-    CLS(Loader)                                                                                    \
-    CLS(CheatEngine)                                                                               \
-    CLS(Crypto)                                                                                    \
-    CLS(WebService)
-
-// GetClassName is a macro defined by Windows.h, grrr...
-const char* GetLogClassName(Class log_class) {
-    switch (log_class) {
-#define CLS(x)                                                                                     \
-    case Class::x:                                                                                 \
-        return #x;
-#define SUB(x, y)                                                                                  \
-    case Class::x##_##y:                                                                           \
-        return #x "." #y;
-        ALL_LOG_CLASSES()
-#undef CLS
-#undef SUB
-    case Class::Count:
-        break;
-    }
-    return "Invalid";
-}
-
-const char* GetLevelName(Level log_level) {
-#define LVL(x)                                                                                     \
-    case Level::x:                                                                                 \
-        return #x
-    switch (log_level) {
-        LVL(Trace);
-        LVL(Debug);
-        LVL(Info);
-        LVL(Warning);
-        LVL(Error);
-        LVL(Critical);
-    case Level::Count:
-        break;
-    }
-#undef LVL
-    return "Invalid";
-}
-
 Filter::Filter(Level default_level) {
     ResetAll(default_level);
 }

src/common/logging/filter.h

@@ -5,24 +5,12 @@
 #pragma once
 
 #include <array>
-#include <chrono>
 #include <cstddef>
 #include <string_view>
 #include "common/logging/log.h"
 
 namespace Common::Log {
 
-/**
- * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
- * instead of underscores as in the enumeration.
- */
-const char* GetLogClassName(Class log_class);
-
-/**
- * Returns the name of the passed log level as a C-string.
- */
-const char* GetLevelName(Level log_level);
-
 /**
  * Implements a log message filter which allows different log classes to have different minimum
  * severity levels. The filter can be changed at runtime and can be parsed from a string to allow

src/common/logging/log.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <fmt/format.h>
-#include "common/logging/types.h"
+#include "common/common_types.h"
 
 namespace Common::Log {
 
@@ -18,6 +18,124 @@ constexpr const char* TrimSourcePath(std::string_view source) {
     return source.data() + idx;
 }
 
+/// Specifies the severity or level of detail of the log message.
+enum class Level : u8 {
+    Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
+              ///< pollute logs.
+    Debug,    ///< Less detailed debugging information.
+    Info,     ///< Status information from important points during execution.
+    Warning,  ///< Minor or potential problems found during execution of a task.
+    Error,    ///< Major problems found during execution of a task that prevent it from being
+              ///< completed.
+    Critical, ///< Major problems during execution that threaten the stability of the entire
+              ///< application.
+
+    Count ///< Total number of logging levels
+};
+
+typedef u8 ClassType;
+
+/**
+ * Specifies the sub-system that generated the log message.
+ *
+ * @note If you add a new entry here, also add a corresponding one to `ALL_LOG_CLASSES` in
+ * backend.cpp.
+ */
+enum class Class : ClassType {
+    Log,               ///< Messages about the log system itself
+    Common,            ///< Library routines
+    Common_Filesystem, ///< Filesystem interface library
+    Common_Memory,     ///< Memory mapping and management functions
+    Core,              ///< LLE emulation core
+    Core_ARM,          ///< ARM CPU core
+    Core_Timing,       ///< CoreTiming functions
+    Config,            ///< Emulator configuration (including commandline)
+    Debug,             ///< Debugging tools
+    Debug_Emulated,    ///< Debug messages from the emulated programs
+    Debug_GPU,         ///< GPU debugging tools
+    Debug_Breakpoint,  ///< Logging breakpoints and watchpoints
+    Debug_GDBStub,     ///< GDB Stub
+    Kernel,            ///< The HLE implementation of the CTR kernel
+    Kernel_SVC,        ///< Kernel system calls
+    Service,           ///< HLE implementation of system services. Each major service
+                       ///< should have its own subclass.
+    Service_ACC,       ///< The ACC (Accounts) service
+    Service_AM,        ///< The AM (Applet manager) service
+    Service_AOC,       ///< The AOC (AddOn Content) service
+    Service_APM,       ///< The APM (Performance) service
+    Service_ARP,       ///< The ARP service
+    Service_Audio,     ///< The Audio (Audio control) service
+    Service_BCAT,      ///< The BCAT service
+    Service_BGTC,      ///< The BGTC (Background Task Controller) service
+    Service_BPC,       ///< The BPC service
+    Service_BTDRV,     ///< The Bluetooth driver service
+    Service_BTM,       ///< The BTM service
+    Service_Capture,   ///< The capture service
+    Service_ERPT,      ///< The error reporting service
+    Service_ETicket,   ///< The ETicket service
+    Service_EUPLD,     ///< The error upload service
+    Service_Fatal,     ///< The Fatal service
+    Service_FGM,       ///< The FGM service
+    Service_Friend,    ///< The friend service
+    Service_FS,        ///< The FS (Filesystem) service
+    Service_GRC,       ///< The game recording service
+    Service_HID,       ///< The HID (Human interface device) service
+    Service_IRS,       ///< The IRS service
+    Service_LBL,       ///< The LBL (LCD backlight) service
+    Service_LDN,       ///< The LDN (Local domain network) service
+    Service_LDR,       ///< The loader service
+    Service_LM,        ///< The LM (Logger) service
+    Service_Migration, ///< The migration service
+    Service_Mii,       ///< The Mii service
+    Service_MM,        ///< The MM (Multimedia) service
+    Service_NCM,       ///< The NCM service
+    Service_NFC,       ///< The NFC (Near-field communication) service
+    Service_NFP,       ///< The NFP service
+    Service_NIFM,      ///< The NIFM (Network interface) service
+    Service_NIM,       ///< The NIM service
+    Service_NPNS,      ///< The NPNS service
+    Service_NS,        ///< The NS services
+    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
+    Service_OLSC,      ///< The OLSC service
+    Service_PCIE,      ///< The PCIe service
+    Service_PCTL,      ///< The PCTL (Parental control) service
+    Service_PCV,       ///< The PCV service
+    Service_PM,        ///< The PM service
+    Service_PREPO,     ///< The PREPO (Play report) service
+    Service_PSC,       ///< The PSC service
+    Service_PSM,       ///< The PSM service
+    Service_SET,       ///< The SET (Settings) service
+    Service_SM,        ///< The SM (Service manager) service
+    Service_SPL,       ///< The SPL service
+    Service_SSL,       ///< The SSL service
+    Service_TCAP,      ///< The TCAP service.
+    Service_Time,      ///< The time service
+    Service_USB,       ///< The USB (Universal Serial Bus) service
+    Service_VI,        ///< The VI (Video interface) service
+    Service_WLAN,      ///< The WLAN (Wireless local area network) service
+    HW,                ///< Low-level hardware emulation
+    HW_Memory,         ///< Memory-map and address translation
+    HW_LCD,            ///< LCD register emulation
+    HW_GPU,            ///< GPU control emulation
+    HW_AES,            ///< AES engine emulation
+    IPC,               ///< IPC interface
+    Frontend,          ///< Emulator UI
+    Render,            ///< Emulator video output and hardware acceleration
+    Render_Software,   ///< Software renderer backend
+    Render_OpenGL,     ///< OpenGL backend
+    Render_Vulkan,     ///< Vulkan backend
+    Audio,             ///< Audio emulation
+    Audio_DSP,         ///< The HLE implementation of the DSP
+    Audio_Sink,        ///< Emulator audio output backend
+    Loader,            ///< ROM loader
+    CheatEngine,       ///< Memory manipulation and engine VM functions
+    Crypto,            ///< Cryptographic engine/functions
+    Input,             ///< Input emulation
+    Network,           ///< Network emulation
+    WebService,        ///< Interface to yuzu Web Services
+    Count              ///< Total number of logging classes
+};
+
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                        unsigned int line_num, const char* function, const char* format,

src/common/logging/text_formatter.cpp

@@ -11,7 +11,7 @@
 
 #include "common/assert.h"
 #include "common/common_funcs.h"
-#include "common/logging/filter.h"
+#include "common/logging/backend.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
 #include "common/string_util.h"

src/common/logging/types.h

@@ -1,148 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <chrono>
-
-#include "common/common_types.h"
-
-namespace Common::Log {
-
-/// Specifies the severity or level of detail of the log message.
-enum class Level : u8 {
-    Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
-              ///< pollute logs.
-    Debug,    ///< Less detailed debugging information.
-    Info,     ///< Status information from important points during execution.
-    Warning,  ///< Minor or potential problems found during execution of a task.
-    Error,    ///< Major problems found during execution of a task that prevent it from being
-              ///< completed.
-    Critical, ///< Major problems during execution that threaten the stability of the entire
-              ///< application.
-
-    Count ///< Total number of logging levels
-};
-
-/**
- * Specifies the sub-system that generated the log message.
- *
- * @note If you add a new entry here, also add a corresponding one to `ALL_LOG_CLASSES` in
- * filter.cpp.
- */
-enum class Class : u8 {
-    Log,               ///< Messages about the log system itself
-    Common,            ///< Library routines
-    Common_Filesystem, ///< Filesystem interface library
-    Common_Memory,     ///< Memory mapping and management functions
-    Core,              ///< LLE emulation core
-    Core_ARM,          ///< ARM CPU core
-    Core_Timing,       ///< CoreTiming functions
-    Config,            ///< Emulator configuration (including commandline)
-    Debug,             ///< Debugging tools
-    Debug_Emulated,    ///< Debug messages from the emulated programs
-    Debug_GPU,         ///< GPU debugging tools
-    Debug_Breakpoint,  ///< Logging breakpoints and watchpoints
-    Debug_GDBStub,     ///< GDB Stub
-    Kernel,            ///< The HLE implementation of the CTR kernel
-    Kernel_SVC,        ///< Kernel system calls
-    Service,           ///< HLE implementation of system services. Each major service
-                       ///< should have its own subclass.
-    Service_ACC,       ///< The ACC (Accounts) service
-    Service_AM,        ///< The AM (Applet manager) service
-    Service_AOC,       ///< The AOC (AddOn Content) service
-    Service_APM,       ///< The APM (Performance) service
-    Service_ARP,       ///< The ARP service
-    Service_Audio,     ///< The Audio (Audio control) service
-    Service_BCAT,      ///< The BCAT service
-    Service_BGTC,      ///< The BGTC (Background Task Controller) service
-    Service_BPC,       ///< The BPC service
-    Service_BTDRV,     ///< The Bluetooth driver service
-    Service_BTM,       ///< The BTM service
-    Service_Capture,   ///< The capture service
-    Service_ERPT,      ///< The error reporting service
-    Service_ETicket,   ///< The ETicket service
-    Service_EUPLD,     ///< The error upload service
-    Service_Fatal,     ///< The Fatal service
-    Service_FGM,       ///< The FGM service
-    Service_Friend,    ///< The friend service
-    Service_FS,        ///< The FS (Filesystem) service
-    Service_GRC,       ///< The game recording service
-    Service_HID,       ///< The HID (Human interface device) service
-    Service_IRS,       ///< The IRS service
-    Service_LBL,       ///< The LBL (LCD backlight) service
-    Service_LDN,       ///< The LDN (Local domain network) service
-    Service_LDR,       ///< The loader service
-    Service_LM,        ///< The LM (Logger) service
-    Service_Migration, ///< The migration service
-    Service_Mii,       ///< The Mii service
-    Service_MM,        ///< The MM (Multimedia) service
-    Service_NCM,       ///< The NCM service
-    Service_NFC,       ///< The NFC (Near-field communication) service
-    Service_NFP,       ///< The NFP service
-    Service_NIFM,      ///< The NIFM (Network interface) service
-    Service_NIM,       ///< The NIM service
-    Service_NPNS,      ///< The NPNS service
-    Service_NS,        ///< The NS services
-    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
-    Service_OLSC,      ///< The OLSC service
-    Service_PCIE,      ///< The PCIe service
-    Service_PCTL,      ///< The PCTL (Parental control) service
-    Service_PCV,       ///< The PCV service
-    Service_PM,        ///< The PM service
-    Service_PREPO,     ///< The PREPO (Play report) service
-    Service_PSC,       ///< The PSC service
-    Service_PSM,       ///< The PSM service
-    Service_SET,       ///< The SET (Settings) service
-    Service_SM,        ///< The SM (Service manager) service
-    Service_SPL,       ///< The SPL service
-    Service_SSL,       ///< The SSL service
-    Service_TCAP,      ///< The TCAP service.
-    Service_Time,      ///< The time service
-    Service_USB,       ///< The USB (Universal Serial Bus) service
-    Service_VI,        ///< The VI (Video interface) service
-    Service_WLAN,      ///< The WLAN (Wireless local area network) service
-    HW,                ///< Low-level hardware emulation
-    HW_Memory,         ///< Memory-map and address translation
-    HW_LCD,            ///< LCD register emulation
-    HW_GPU,            ///< GPU control emulation
-    HW_AES,            ///< AES engine emulation
-    IPC,               ///< IPC interface
-    Frontend,          ///< Emulator UI
-    Render,            ///< Emulator video output and hardware acceleration
-    Render_Software,   ///< Software renderer backend
-    Render_OpenGL,     ///< OpenGL backend
-    Render_Vulkan,     ///< Vulkan backend
-    Shader,            ///< Shader recompiler
-    Shader_SPIRV,      ///< Shader SPIR-V code generation
-    Shader_GLASM,      ///< Shader GLASM code generation
-    Shader_GLSL,       ///< Shader GLSL code generation
-    Audio,             ///< Audio emulation
-    Audio_DSP,         ///< The HLE implementation of the DSP
-    Audio_Sink,        ///< Emulator audio output backend
-    Loader,            ///< ROM loader
-    CheatEngine,       ///< Memory manipulation and engine VM functions
-    Crypto,            ///< Cryptographic engine/functions
-    Input,             ///< Input emulation
-    Network,           ///< Network emulation
-    WebService,        ///< Interface to yuzu Web Services
-    Count              ///< Total number of logging classes
-};
-
-/**
- * A log entry. Log entries are store in a structured format to permit more varied output
- * formatting on different frontends, as well as facilitating filtering and aggregation.
- */
-struct Entry {
-    std::chrono::microseconds timestamp;
-    Class log_class{};
-    Level log_level{};
-    const char* filename = nullptr;
-    unsigned int line_num = 0;
-    std::string function;
-    std::string message;
-    bool final_entry = false;
-};
-
-} // namespace Common::Log

src/common/lz4_compression.cpp

@@ -59,7 +59,8 @@ std::vector<u8> CompressDataLZ4HCMax(const u8* source, std::size_t source_size)
     return CompressDataLZ4HC(source, source_size, LZ4HC_CLEVEL_MAX);
 }
 
-std::vector<u8> DecompressDataLZ4(std::span<const u8> compressed, std::size_t uncompressed_size) {
+std::vector<u8> DecompressDataLZ4(const std::vector<u8>& compressed,
+                                  std::size_t uncompressed_size) {
     std::vector<u8> uncompressed(uncompressed_size);
     const int size_check = LZ4_decompress_safe(reinterpret_cast<const char*>(compressed.data()),
                                                reinterpret_cast<char*>(uncompressed.data()),

src/common/lz4_compression.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <span>
 #include <vector>
 
 #include "common/common_types.h"
@@ -54,7 +53,7 @@ namespace Common::Compression {
  *
  * @return the decompressed data.
  */
-[[nodiscard]] std::vector<u8> DecompressDataLZ4(std::span<const u8> compressed,
+[[nodiscard]] std::vector<u8> DecompressDataLZ4(const std::vector<u8>& compressed,
                                                 std::size_t uncompressed_size);
 
-} // namespace Common::Compression
+} // namespace Common::Compression

src/common/nvidia_flags.cpp

@@ -2,30 +2,24 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstdlib>
+#include <filesystem>
+#include <stdlib.h>
 
 #include <fmt/format.h>
 
-#include "common/fs/file.h"
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
+#include "common/file_util.h"
 #include "common/nvidia_flags.h"
 
 namespace Common {
 
 void ConfigureNvidiaEnvironmentFlags() {
 #ifdef _WIN32
-    const auto nvidia_shader_dir =
-        Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir) / "nvidia";
-
-    if (!Common::FS::CreateDirs(nvidia_shader_dir)) {
-        return;
-    }
-
-    const auto windows_path_string =
-        Common::FS::PathToUTF8String(nvidia_shader_dir.lexically_normal());
-
-    void(_putenv(fmt::format("__GL_SHADER_DISK_CACHE_PATH={}", windows_path_string).c_str()));
+    const std::string shader_path = Common::FS::SanitizePath(
+        fmt::format("{}/nvidia/", Common::FS::GetUserPath(Common::FS::UserPath::ShaderDir)));
+    const std::string windows_path =
+        Common::FS::SanitizePath(shader_path, Common::FS::DirectorySeparator::BackwardSlash);
+    void(Common::FS::CreateFullPath(shader_path + '/'));
+    void(_putenv(fmt::format("__GL_SHADER_DISK_CACHE_PATH={}", windows_path).c_str()));
     void(_putenv("__GL_SHADER_DISK_CACHE_SKIP_CLEANUP=1"));
 #endif
 }

src/common/page_table.cpp

@@ -14,7 +14,6 @@ void PageTable::Resize(size_t address_space_width_in_bits, size_t page_size_in_b
     const size_t num_page_table_entries{1ULL << (address_space_width_in_bits - page_size_in_bits)};
     pointers.resize(num_page_table_entries);
     backing_addr.resize(num_page_table_entries);
-    current_address_space_width_in_bits = address_space_width_in_bits;
 }
 
 } // namespace Common

src/common/page_table.h

@@ -98,10 +98,6 @@ struct PageTable {
      */
     void Resize(size_t address_space_width_in_bits, size_t page_size_in_bits);
 
-    size_t GetAddressSpaceBits() const {
-        return current_address_space_width_in_bits;
-    }
-
     /**
      * Vector of memory pointers backing each page. An entry can only be non-null if the
      * corresponding attribute element is of type `Memory`.
@@ -109,10 +105,6 @@ struct PageTable {
     VirtualBuffer<PageInfo> pointers;
 
     VirtualBuffer<u64> backing_addr;
-
-    size_t current_address_space_width_in_bits;
-
-    u8* fastmem_arena;
 };
 
 } // namespace Common

src/common/parent_of_member.h

@@ -109,8 +109,7 @@ struct OffsetOfCalculator {
             }
         }
 
-        return static_cast<ptrdiff_t>(static_cast<size_t>(next - start) * sizeof(MemberType) +
-                                      Offset);
+        return (next - start) * sizeof(MemberType) + Offset;
     }
 
     static constexpr std::ptrdiff_t OffsetOf(MemberType ParentType::*member) {
@@ -134,27 +133,27 @@ template <auto MemberPtr>
 using GetMemberType = typename GetMemberPointerTraits<decltype(MemberPtr)>::Member;
 
 template <auto MemberPtr, typename RealParentType = GetParentType<MemberPtr>>
-constexpr std::ptrdiff_t OffsetOf() {
+static inline std::ptrdiff_t OffsetOf = [] {
     using DeducedParentType = GetParentType<MemberPtr>;
     using MemberType = GetMemberType<MemberPtr>;
     static_assert(std::is_base_of<DeducedParentType, RealParentType>::value ||
                   std::is_same<RealParentType, DeducedParentType>::value);
 
     return OffsetOfCalculator<RealParentType, MemberType>::OffsetOf(MemberPtr);
-};
+}();
 
 } // namespace impl
 
 template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
 constexpr RealParentType& GetParentReference(impl::GetMemberType<MemberPtr>* member) {
-    std::ptrdiff_t Offset = impl::OffsetOf<MemberPtr, RealParentType>();
+    std::ptrdiff_t Offset = impl::OffsetOf<MemberPtr, RealParentType>;
     return *static_cast<RealParentType*>(
         static_cast<void*>(static_cast<uint8_t*>(static_cast<void*>(member)) - Offset));
 }
 
 template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
 constexpr RealParentType const& GetParentReference(impl::GetMemberType<MemberPtr> const* member) {
-    std::ptrdiff_t Offset = impl::OffsetOf<MemberPtr, RealParentType>();
+    std::ptrdiff_t Offset = impl::OffsetOf<MemberPtr, RealParentType>;
     return *static_cast<const RealParentType*>(static_cast<const void*>(
         static_cast<const uint8_t*>(static_cast<const void*>(member)) - Offset));
 }

src/common/point.h

@@ -1,57 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <type_traits>
-
-namespace Common {
-
-// Represents a point within a 2D space.
-template <typename T>
-struct Point {
-    static_assert(std::is_arithmetic_v<T>, "T must be an arithmetic type!");
-
-    T x{};
-    T y{};
-
-#define ARITHMETIC_OP(op, compound_op)                                                             \
-    friend constexpr Point operator op(const Point& lhs, const Point& rhs) noexcept {              \
-        return {                                                                                   \
-            .x = static_cast<T>(lhs.x op rhs.x),                                                   \
-            .y = static_cast<T>(lhs.y op rhs.y),                                                   \
-        };                                                                                         \
-    }                                                                                              \
-    friend constexpr Point operator op(const Point& lhs, T value) noexcept {                       \
-        return {                                                                                   \
-            .x = static_cast<T>(lhs.x op value),                                                   \
-            .y = static_cast<T>(lhs.y op value),                                                   \
-        };                                                                                         \
-    }                                                                                              \
-    friend constexpr Point operator op(T value, const Point& rhs) noexcept {                       \
-        return {                                                                                   \
-            .x = static_cast<T>(value op rhs.x),                                                   \
-            .y = static_cast<T>(value op rhs.y),                                                   \
-        };                                                                                         \
-    }                                                                                              \
-    friend constexpr Point& operator compound_op(Point& lhs, const Point& rhs) noexcept {          \
-        lhs.x = static_cast<T>(lhs.x op rhs.x);                                                    \
-        lhs.y = static_cast<T>(lhs.y op rhs.y);                                                    \
-        return lhs;                                                                                \
-    }                                                                                              \
-    friend constexpr Point& operator compound_op(Point& lhs, T value) noexcept {                   \
-        lhs.x = static_cast<T>(lhs.x op value);                                                    \
-        lhs.y = static_cast<T>(lhs.y op value);                                                    \
-        return lhs;                                                                                \
-    }
-    ARITHMETIC_OP(+, +=)
-    ARITHMETIC_OP(-, -=)
-    ARITHMETIC_OP(*, *=)
-    ARITHMETIC_OP(/, /=)
-#undef ARITHMETIC_OP
-
-    friend constexpr bool operator==(const Point&, const Point&) = default;
-};
-
-} // namespace Common

src/common/scm_rev.cpp.in

@@ -14,6 +14,7 @@
 #define BUILD_ID "@BUILD_ID@"
 #define TITLE_BAR_FORMAT_IDLE "@TITLE_BAR_FORMAT_IDLE@"
 #define TITLE_BAR_FORMAT_RUNNING "@TITLE_BAR_FORMAT_RUNNING@"
+#define SHADER_CACHE_VERSION "@SHADER_CACHE_VERSION@"
 
 namespace Common {
 
@@ -27,6 +28,7 @@ const char g_build_version[]  = BUILD_VERSION;
 const char g_build_id[] = BUILD_ID;
 const char g_title_bar_format_idle[] = TITLE_BAR_FORMAT_IDLE;
 const char g_title_bar_format_running[] = TITLE_BAR_FORMAT_RUNNING;
+const char g_shader_cache_version[] = SHADER_CACHE_VERSION;
 
 } // namespace
 

src/common/settings.cpp

@@ -5,7 +5,7 @@
 #include <string_view>
 
 #include "common/assert.h"
-#include "common/fs/path_util.h"
+#include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
 
@@ -34,45 +34,39 @@ void LogSettings() {
         LOG_INFO(Config, "{}: {}", name, value);
     };
 
-    const auto log_path = [](std::string_view name, const std::filesystem::path& path) {
-        LOG_INFO(Config, "{}: {}", name, Common::FS::PathToUTF8String(path));
-    };
-
     LOG_INFO(Config, "yuzu Configuration:");
     log_setting("Controls_UseDockedMode", values.use_docked_mode.GetValue());
     log_setting("System_RngSeed", values.rng_seed.GetValue().value_or(0));
-    log_setting("System_CurrentUser", values.current_user.GetValue());
+    log_setting("System_CurrentUser", values.current_user);
     log_setting("System_LanguageIndex", values.language_index.GetValue());
     log_setting("System_RegionIndex", values.region_index.GetValue());
     log_setting("System_TimeZoneIndex", values.time_zone_index.GetValue());
     log_setting("Core_UseMultiCore", values.use_multi_core.GetValue());
-    log_setting("CPU_Accuracy", values.cpu_accuracy.GetValue());
+    log_setting("CPU_Accuracy", values.cpu_accuracy);
     log_setting("Renderer_UseResolutionFactor", values.resolution_factor.GetValue());
-    log_setting("Renderer_UseSpeedLimit", values.use_speed_limit.GetValue());
-    log_setting("Renderer_SpeedLimit", values.speed_limit.GetValue());
+    log_setting("Renderer_UseFrameLimit", values.use_frame_limit.GetValue());
+    log_setting("Renderer_FrameLimit", values.frame_limit.GetValue());
     log_setting("Renderer_UseDiskShaderCache", values.use_disk_shader_cache.GetValue());
     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_AccelerateASTC", values.accelerate_astc.GetValue());
     log_setting("Renderer_UseVsync", values.use_vsync.GetValue());
-    log_setting("Renderer_ShaderBackend", values.shader_backend.GetValue());
+    log_setting("Renderer_UseAssemblyShaders", values.use_assembly_shaders.GetValue());
     log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
-    log_setting("Renderer_UseGarbageCollection", values.use_caches_gc.GetValue());
     log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
-    log_setting("Audio_OutputEngine", values.sink_id.GetValue());
+    log_setting("Audio_OutputEngine", values.sink_id);
     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));
-    log_path("DataStorage_ConfigDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir));
-    log_path("DataStorage_LoadDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::LoadDir));
-    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("Audio_OutputDevice", values.audio_device_id);
+    log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd);
+    log_setting("DataStorage_CacheDir", Common::FS::GetUserPath(Common::FS::UserPath::CacheDir));
+    log_setting("DataStorage_ConfigDir", Common::FS::GetUserPath(Common::FS::UserPath::ConfigDir));
+    log_setting("DataStorage_LoadDir", Common::FS::GetUserPath(Common::FS::UserPath::LoadDir));
+    log_setting("DataStorage_NandDir", Common::FS::GetUserPath(Common::FS::UserPath::NANDDir));
+    log_setting("DataStorage_SdmcDir", Common::FS::GetUserPath(Common::FS::UserPath::SDMCDir));
+    log_setting("Debugging_ProgramArgs", values.program_args);
+    log_setting("Services_BCATBackend", values.bcat_backend);
+    log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local);
 }
 
 bool IsConfiguringGlobal() {
@@ -92,18 +86,11 @@ bool IsGPULevelHigh() {
            values.gpu_accuracy.GetValue() == GPUAccuracy::High;
 }
 
-bool IsFastmemEnabled() {
-    if (values.cpu_debug_mode) {
-        return static_cast<bool>(values.cpuopt_fastmem);
-    }
-    return true;
-}
-
 float Volume() {
     if (values.audio_muted) {
         return 0.0f;
     }
-    return values.volume.GetValue() / 100.0f;
+    return values.volume.GetValue();
 }
 
 void RestoreGlobalState(bool is_powered_on) {
@@ -119,31 +106,21 @@ void RestoreGlobalState(bool is_powered_on) {
     // Core
     values.use_multi_core.SetGlobal(true);
 
-    // CPU
-    values.cpu_accuracy.SetGlobal(true);
-    values.cpuopt_unsafe_unfuse_fma.SetGlobal(true);
-    values.cpuopt_unsafe_reduce_fp_error.SetGlobal(true);
-    values.cpuopt_unsafe_ignore_standard_fpcr.SetGlobal(true);
-    values.cpuopt_unsafe_inaccurate_nan.SetGlobal(true);
-    values.cpuopt_unsafe_fastmem_check.SetGlobal(true);
-
     // Renderer
     values.renderer_backend.SetGlobal(true);
     values.vulkan_device.SetGlobal(true);
     values.aspect_ratio.SetGlobal(true);
     values.max_anisotropy.SetGlobal(true);
-    values.use_speed_limit.SetGlobal(true);
-    values.speed_limit.SetGlobal(true);
+    values.use_frame_limit.SetGlobal(true);
+    values.frame_limit.SetGlobal(true);
     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.accelerate_astc.SetGlobal(true);
     values.use_vsync.SetGlobal(true);
-    values.shader_backend.SetGlobal(true);
+    values.use_assembly_shaders.SetGlobal(true);
     values.use_asynchronous_shaders.SetGlobal(true);
     values.use_fast_gpu_time.SetGlobal(true);
-    values.use_caches_gc.SetGlobal(true);
     values.bg_red.SetGlobal(true);
     values.bg_green.SetGlobal(true);
     values.bg_blue.SetGlobal(true);
@@ -153,6 +130,7 @@ void RestoreGlobalState(bool is_powered_on) {
     values.region_index.SetGlobal(true);
     values.time_zone_index.SetGlobal(true);
     values.rng_seed.SetGlobal(true);
+    values.custom_rtc.SetGlobal(true);
     values.sound_index.SetGlobal(true);
 
     // Controls

src/common/settings.h

@@ -10,12 +10,10 @@
 #include <map>
 #include <optional>
 #include <string>
-#include <utility>
 #include <vector>
 
 #include "common/common_types.h"
 #include "common/settings_input.h"
-#include "input_common/udp/client.h"
 
 namespace Settings {
 
@@ -24,12 +22,6 @@ enum class RendererBackend : u32 {
     Vulkan = 1,
 };
 
-enum class ShaderBackend : u32 {
-    GLSL = 0,
-    GLASM = 1,
-    SPIRV = 2,
-};
-
 enum class GPUAccuracy : u32 {
     Normal = 0,
     High = 1,
@@ -37,240 +29,73 @@ enum class GPUAccuracy : u32 {
 };
 
 enum class CPUAccuracy : u32 {
-    Auto = 0,
-    Accurate = 1,
-    Unsafe = 2,
+    Accurate = 0,
+    Unsafe = 1,
+    DebugMode = 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
- * this requirement.
- */
 template <typename Type>
-class BasicSetting {
-protected:
-    BasicSetting() = default;
-
-    /**
-     * Only sets the setting to the given initializer, leaving the other members to their default
-     * initializers.
-     *
-     * @param global_val Initial value of the setting
-     */
-    explicit BasicSetting(const Type& global_val) : global{global_val} {}
-
+class Setting final {
 public:
-    /**
-     * Sets a default value, label, and setting value.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param name Label for the setting
-     */
-    explicit BasicSetting(const Type& default_val, const std::string& name)
-        : default_value{default_val}, global{default_val}, label{name} {}
-    ~BasicSetting() = default;
-
-    /**
-     *  Returns a reference to the setting's value.
-     *
-     * @returns A reference to the setting
-     */
-    [[nodiscard]] const Type& GetValue() const {
-        return global;
-    }
-
-    /**
-     * Sets the setting to the given value.
-     *
-     * @param value The desired value
-     */
-    void SetValue(const Type& value) {
-        Type temp{value};
-        std::swap(global, temp);
-    }
-
-    /**
-     * Returns the value that this setting was created with.
-     *
-     * @returns A reference to the default value
-     */
-    [[nodiscard]] const Type& GetDefault() const {
-        return default_value;
-    }
-
-    /**
-     * Returns the label this setting was created with.
-     *
-     * @returns A reference to the label
-     */
-    [[nodiscard]] const std::string& GetLabel() const {
-        return label;
-    }
-
-    /**
-     * Assigns a value to the setting.
-     *
-     * @param value The desired setting value
-     *
-     * @returns A reference to the setting
-     */
-    const Type& operator=(const Type& value) {
-        Type temp{value};
-        std::swap(global, temp);
-        return global;
-    }
-
-    /**
-     * Returns a reference to the setting.
-     *
-     * @returns A reference to the setting
-     */
-    explicit operator const Type&() const {
-        return global;
-    }
-
-protected:
-    const Type default_value{}; ///< The default value
-    Type global{};              ///< The setting
-    const std::string label{};  ///< The setting's label
-};
-
-/**
- * The Setting class is a slightly more complex version of the BasicSetting class. This adds a
- * custom setting to switch to when a guest application specifically requires it. The effect is that
- * other components of the emulator can access the setting's intended value without any need for the
- * component to ask whether the custom or global setting is needed at the moment.
- *
- * By default, the global setting is used.
- *
- * Like the BasicSetting, this requires setting a default value and label to use.
- */
-template <typename Type>
-class Setting final : public BasicSetting<Type> {
-public:
-    /**
-     * Sets a default value, label, and setting value.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param name Label for the setting
-     */
-    explicit Setting(const Type& default_val, const std::string& name)
-        : BasicSetting<Type>(default_val, name) {}
+    Setting() = default;
+    explicit Setting(Type val) : global{val} {}
     ~Setting() = default;
-
-    /**
-     * Tells this setting to represent either the global or custom setting when other member
-     * functions are used.
-     *
-     * @param to_global Whether to use the global or custom setting.
-     */
     void SetGlobal(bool to_global) {
         use_global = to_global;
     }
-
-    /**
-     * Returns whether this setting is using the global setting or not.
-     *
-     * @returns The global state
-     */
-    [[nodiscard]] bool UsingGlobal() const {
+    bool UsingGlobal() const {
         return use_global;
     }
-
-    /**
-     * Returns either the global or custom setting depending on the values of this setting's global
-     * state or if the global value was specifically requested.
-     *
-     * @param need_global Request global value regardless of setting's state; defaults to false
-     *
-     * @returns The required value of the setting
-     */
-    [[nodiscard]] const Type& GetValue(bool need_global = false) const {
+    Type GetValue(bool need_global = false) const {
         if (use_global || need_global) {
-            return this->global;
+            return global;
         }
-        return custom;
+        return local;
     }
-
-    /**
-     * Sets the current setting value depending on the global state.
-     *
-     * @param value The new value
-     */
     void SetValue(const Type& value) {
-        Type temp{value};
         if (use_global) {
-            std::swap(this->global, temp);
+            global = value;
         } else {
-            std::swap(custom, temp);
+            local = value;
         }
     }
 
-    /**
-     * Assigns the current setting value depending on the global state.
-     *
-     * @param value The new value
-     *
-     * @returns A reference to the current setting value
-     */
-    const Type& operator=(const Type& value) {
-        Type temp{value};
-        if (use_global) {
-            std::swap(this->global, temp);
-            return this->global;
-        }
-        std::swap(custom, temp);
-        return custom;
-    }
-
-    /**
-     * Returns the current setting value depending on the global state.
-     *
-     * @returns A reference to the current setting value
-     */
-    explicit operator const Type&() const {
-        if (use_global) {
-            return this->global;
-        }
-        return custom;
-    }
-
 private:
-    bool use_global{true}; ///< The setting's global state
-    Type custom{};         ///< The custom value of the setting
+    bool use_global = true;
+    Type global{};
+    Type local{};
 };
 
 /**
- * The InputSetting class allows for getting a reference to either the global or custom members.
+ * The InputSetting class allows for getting a reference to either the global or local members.
  * This is required as we cannot easily modify the values of user-defined types within containers
  * using the SetValue() member function found in the Setting class. The primary purpose of this
- * class is to store an array of 10 PlayerInput structs for both the global and custom setting and
- * allows for easily accessing and modifying both settings.
+ * class is to store an array of 10 PlayerInput structs for both the global and local (per-game)
+ * setting and allows for easily accessing and modifying both settings.
  */
 template <typename Type>
 class InputSetting final {
 public:
     InputSetting() = default;
-    explicit InputSetting(Type val) : BasicSetting<Type>(val) {}
+    explicit InputSetting(Type val) : global{val} {}
     ~InputSetting() = default;
     void SetGlobal(bool to_global) {
         use_global = to_global;
     }
-    [[nodiscard]] bool UsingGlobal() const {
+    bool UsingGlobal() const {
         return use_global;
     }
-    [[nodiscard]] Type& GetValue(bool need_global = false) {
+    Type& GetValue(bool need_global = false) {
         if (use_global || need_global) {
             return global;
         }
-        return custom;
+        return local;
     }
 
 private:
-    bool use_global{true}; ///< The setting's global state
-    Type global{};         ///< The setting
-    Type custom{};         ///< The custom setting value
+    bool use_global = true;
+    Type global{};
+    Type local{};
 };
 
 struct TouchFromButtonMap {
@@ -280,162 +105,137 @@ struct TouchFromButtonMap {
 
 struct Values {
     // Audio
-    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"};
-    Setting<u8> volume{100, "volume"};
+    std::string audio_device_id;
+    std::string sink_id;
+    bool audio_muted;
+    Setting<bool> enable_audio_stretching;
+    Setting<float> volume;
 
     // Core
-    Setting<bool> use_multi_core{true, "use_multi_core"};
+    Setting<bool> use_multi_core;
 
     // Cpu
-    Setting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, "cpu_accuracy"};
-    // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
-    BasicSetting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
-    BasicSetting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
+    CPUAccuracy cpu_accuracy;
 
-    BasicSetting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
-    BasicSetting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
-    BasicSetting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
-    BasicSetting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
-    BasicSetting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
-    BasicSetting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
-    BasicSetting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
-    BasicSetting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
-    BasicSetting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
+    bool cpuopt_page_tables;
+    bool cpuopt_block_linking;
+    bool cpuopt_return_stack_buffer;
+    bool cpuopt_fast_dispatcher;
+    bool cpuopt_context_elimination;
+    bool cpuopt_const_prop;
+    bool cpuopt_misc_ir;
+    bool cpuopt_reduce_misalign_checks;
 
-    Setting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
-    Setting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
-    Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true, "cpuopt_unsafe_ignore_standard_fpcr"};
-    Setting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
-    Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
+    bool cpuopt_unsafe_unfuse_fma;
+    bool cpuopt_unsafe_reduce_fp_error;
+    bool cpuopt_unsafe_inaccurate_nan;
 
     // Renderer
-    Setting<RendererBackend> renderer_backend{RendererBackend::OpenGL, "backend"};
-    BasicSetting<bool> renderer_debug{false, "debug"};
-    BasicSetting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
-    BasicSetting<bool> disable_shader_loop_safety_checks{false,
-                                                         "disable_shader_loop_safety_checks"};
-    Setting<int> vulkan_device{0, "vulkan_device"};
+    Setting<RendererBackend> renderer_backend;
+    bool renderer_debug;
+    Setting<int> vulkan_device;
 
-    Setting<u16> resolution_factor{1, "resolution_factor"};
-    // *nix platforms may have issues with the borderless windowed fullscreen mode.
-    // Default to exclusive fullscreen on these platforms for now.
-    Setting<int> fullscreen_mode{
-#ifdef _WIN32
-        0,
-#else
-        1,
-#endif
-        "fullscreen_mode"};
-    Setting<int> aspect_ratio{0, "aspect_ratio"};
-    Setting<int> max_anisotropy{0, "max_anisotropy"};
-    Setting<bool> use_speed_limit{true, "use_speed_limit"};
-    Setting<u16> speed_limit{100, "speed_limit"};
-    Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
-    Setting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, "gpu_accuracy"};
-    Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
-    Setting<bool> use_nvdec_emulation{true, "use_nvdec_emulation"};
-    Setting<bool> accelerate_astc{true, "accelerate_astc"};
-    Setting<bool> use_vsync{true, "use_vsync"};
-    BasicSetting<u16> fps_cap{1000, "fps_cap"};
-    BasicSetting<bool> disable_fps_limit{false, "disable_fps_limit"};
-    Setting<ShaderBackend> shader_backend{ShaderBackend::GLASM, "shader_backend"};
-    Setting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
-    Setting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
-    Setting<bool> use_caches_gc{false, "use_caches_gc"};
+    Setting<u16> resolution_factor{1};
+    Setting<int> fullscreen_mode;
+    Setting<int> aspect_ratio;
+    Setting<int> max_anisotropy;
+    Setting<bool> use_frame_limit;
+    Setting<u16> frame_limit;
+    Setting<bool> use_disk_shader_cache;
+    Setting<GPUAccuracy> gpu_accuracy;
+    Setting<bool> use_asynchronous_gpu_emulation;
+    Setting<bool> use_nvdec_emulation;
+    Setting<bool> use_vsync;
+    Setting<bool> use_assembly_shaders;
+    Setting<bool> use_asynchronous_shaders;
+    Setting<bool> use_fast_gpu_time;
 
-    Setting<u8> bg_red{0, "bg_red"};
-    Setting<u8> bg_green{0, "bg_green"};
-    Setting<u8> bg_blue{0, "bg_blue"};
+    Setting<float> bg_red;
+    Setting<float> bg_green;
+    Setting<float> bg_blue;
 
     // System
-    Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
+    Setting<std::optional<u32>> rng_seed;
     // Measured in seconds since epoch
-    std::optional<std::chrono::seconds> custom_rtc;
+    Setting<std::optional<std::chrono::seconds>> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
     std::chrono::seconds custom_rtc_differential;
 
-    BasicSetting<s32> current_user{0, "current_user"};
-    Setting<s32> language_index{1, "language_index"};
-    Setting<s32> region_index{1, "region_index"};
-    Setting<s32> time_zone_index{0, "time_zone_index"};
-    Setting<s32> sound_index{1, "sound_index"};
+    s32 current_user;
+    Setting<s32> language_index;
+    Setting<s32> region_index;
+    Setting<s32> time_zone_index;
+    Setting<s32> sound_index;
 
     // Controls
     InputSetting<std::array<PlayerInput, 10>> players;
 
-    Setting<bool> use_docked_mode{true, "use_docked_mode"};
+    Setting<bool> use_docked_mode;
 
-    Setting<bool> vibration_enabled{true, "vibration_enabled"};
-    Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
+    Setting<bool> vibration_enabled;
+    Setting<bool> 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"};
+    Setting<bool> motion_enabled;
+    std::string motion_device;
+    std::string udp_input_servers;
 
-    BasicSetting<bool> mouse_panning{false, "mouse_panning"};
-    BasicSetting<u8> mouse_panning_sensitivity{10, "mouse_panning_sensitivity"};
-    BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
+    bool mouse_panning;
+    float mouse_panning_sensitivity;
+    bool mouse_enabled;
     std::string mouse_device;
     MouseButtonsRaw mouse_buttons;
 
-    BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
-    BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
+    bool emulate_analog_keyboard;
+    bool keyboard_enabled;
     KeyboardKeysRaw keyboard_keys;
     KeyboardModsRaw keyboard_mods;
 
-    BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
+    bool debug_pad_enabled;
     ButtonsRaw debug_pad_buttons;
     AnalogsRaw debug_pad_analogs;
 
     TouchscreenInput touchscreen;
 
-    BasicSetting<bool> use_touch_from_button{false, "use_touch_from_button"};
-    BasicSetting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850",
-                                           "touch_device"};
-    BasicSetting<int> touch_from_button_map_index{0, "touch_from_button_map"};
+    bool use_touch_from_button;
+    std::string touch_device;
+    int touch_from_button_map_index;
     std::vector<TouchFromButtonMap> touch_from_button_maps;
 
     std::atomic_bool is_device_reload_pending{true};
 
     // Data Storage
-    BasicSetting<bool> use_virtual_sd{true, "use_virtual_sd"};
-    BasicSetting<bool> gamecard_inserted{false, "gamecard_inserted"};
-    BasicSetting<bool> gamecard_current_game{false, "gamecard_current_game"};
-    BasicSetting<std::string> gamecard_path{std::string(), "gamecard_path"};
+    bool use_virtual_sd;
+    bool gamecard_inserted;
+    bool gamecard_current_game;
+    std::string gamecard_path;
 
     // Debugging
     bool record_frame_times;
-    BasicSetting<bool> use_gdbstub{false, "use_gdbstub"};
-    BasicSetting<u16> gdbstub_port{0, "gdbstub_port"};
-    BasicSetting<std::string> program_args{std::string(), "program_args"};
-    BasicSetting<bool> dump_exefs{false, "dump_exefs"};
-    BasicSetting<bool> dump_nso{false, "dump_nso"};
-    BasicSetting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
-    BasicSetting<bool> reporting_services{false, "reporting_services"};
-    BasicSetting<bool> quest_flag{false, "quest_flag"};
-    BasicSetting<bool> disable_macro_jit{false, "disable_macro_jit"};
-    BasicSetting<bool> extended_logging{false, "extended_logging"};
-    BasicSetting<bool> use_debug_asserts{false, "use_debug_asserts"};
-    BasicSetting<bool> use_auto_stub{false, "use_auto_stub"};
+    bool use_gdbstub;
+    u16 gdbstub_port;
+    std::string program_args;
+    bool dump_exefs;
+    bool dump_nso;
+    bool reporting_services;
+    bool quest_flag;
+    bool disable_macro_jit;
+    bool extended_logging;
+    bool use_debug_asserts;
+    bool use_auto_stub;
 
     // Miscellaneous
-    BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
-    BasicSetting<bool> use_dev_keys{false, "use_dev_keys"};
+    std::string log_filter;
+    bool use_dev_keys;
 
     // Services
-    BasicSetting<std::string> bcat_backend{"none", "bcat_backend"};
-    BasicSetting<bool> bcat_boxcat_local{false, "bcat_boxcat_local"};
+    std::string bcat_backend;
+    bool bcat_boxcat_local;
 
     // WebService
-    BasicSetting<bool> enable_telemetry{true, "enable_telemetry"};
-    BasicSetting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
-    BasicSetting<std::string> yuzu_username{std::string(), "yuzu_username"};
-    BasicSetting<std::string> yuzu_token{std::string(), "yuzu_token"};
+    bool enable_telemetry;
+    std::string web_api_url;
+    std::string yuzu_username;
+    std::string yuzu_token;
 
     // Add-Ons
     std::map<u64, std::vector<std::string>> disabled_addons;
@@ -449,8 +249,6 @@ void SetConfiguringGlobal(bool is_global);
 bool IsGPULevelExtreme();
 bool IsGPULevelHigh();
 
-bool IsFastmemEnabled();
-
 float Volume();
 
 std::string GetTimeZoneString();

src/common/string_util.cpp

@@ -9,6 +9,7 @@
 #include <locale>
 #include <sstream>
 
+#include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 
@@ -92,6 +93,18 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     return true;
 }
 
+void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path,
+                           const std::string& _Filename) {
+    _CompleteFilename = _Path;
+
+    // check for seperator
+    if (DIR_SEP_CHR != *_CompleteFilename.rbegin())
+        _CompleteFilename += DIR_SEP_CHR;
+
+    // add the filename
+    _CompleteFilename += _Filename;
+}
+
 void SplitString(const std::string& str, const char delim, std::vector<std::string>& output) {
     std::istringstream iss(str);
     output.resize(1);