file_util: Make ForeachDirectoryEntry() use directory iterators

Simplifies the implementing code so that we don't need to explicitly
handle platform-specifics.

.ci/scripts/clang/docker.sh

@@ -1,18 +0,0 @@
-#!/bin/bash -ex
-
-# Exit on error, rather than continuing with the rest of the script.
-set -e
-
-cd /yuzu
-
-ccache -s
-
-mkdir build || true && cd build
-cmake .. -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/clang -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_INSTALL_PREFIX="/usr"
-
-make -j$(nproc)
-
-ccache -s
-
-ctest -VV -C Release
-

.ci/scripts/clang/exec.sh

@@ -1,8 +0,0 @@
-#!/bin/bash -ex
-
-mkdir -p "ccache"  || true
-chmod a+x ./.ci/scripts/clang/docker.sh
-# the UID for the container yuzu user is 1027
-sudo chown -R 1027 ./
-docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/clang/docker.sh $1
-sudo chown -R $UID ./

.ci/scripts/clang/upload.sh

@@ -1,20 +0,0 @@
-#!/bin/bash -ex
-
-. .ci/scripts/common/pre-upload.sh
-
-REV_NAME="yuzu-linux-${GITDATE}-${GITREV}"
-ARCHIVE_NAME="${REV_NAME}.tar.xz"
-COMPRESSION_FLAGS="-cJvf"
-
-if [ "${RELEASE_NAME}" = "mainline" ]; then
-    DIR_NAME="${REV_NAME}"
-else
-    DIR_NAME="${REV_NAME}_${RELEASE_NAME}"
-fi
-
-mkdir "$DIR_NAME"
-
-cp build/bin/yuzu-cmd "$DIR_NAME"
-cp build/bin/yuzu "$DIR_NAME"
-
-. .ci/scripts/common/post-upload.sh

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

@@ -15,5 +15,5 @@ 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}/"
+mv "$ARCHIVE_NAME" artifacts/
+mv "$REV_NAME.7z" artifacts/

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

@@ -2,6 +2,5 @@
 
 GITDATE="`git show -s --date=short --format='%ad' | sed 's/-//g'`"
 GITREV="`git show -s --format='%h'`"
-ARTIFACTS_DIR="artifacts"
 
-mkdir -p "${ARTIFACTS_DIR}/"
+mkdir -p artifacts

.ci/scripts/linux/docker.sh

@@ -1,49 +1,14 @@
 #!/bin/bash -ex
 
-# Exit on error, rather than continuing with the rest of the script.
-set -e
-
 cd /yuzu
 
 ccache -s
 
 mkdir build || true && cd build
-cmake .. -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_INSTALL_PREFIX="/usr"
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON
 
-make -j$(nproc)
+ninja
 
 ccache -s
 
 ctest -VV -C Release
-
-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/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 \
-    exec-x86_64.so \
-    linuxdeploy-x86_64.AppImage \
-    linuxdeploy-plugin-qt-x86_64.AppImage
-
-# Workaround for https://github.com/AppImage/AppImageKit/issues/828
-export APPIMAGE_EXTRACT_AND_RUN=1
-
-mkdir -p AppDir/usr/optional
-mkdir -p AppDir/usr/optional/libstdc++
-mkdir -p AppDir/usr/optional/libgcc_s
-
-# Deploy yuzu's needed dependencies
-./linuxdeploy-x86_64.AppImage --appdir AppDir --plugin qt
-
-# Workaround for building yuzu with GCC 10 but also trying to distribute it to Ubuntu 18.04 et al.
-# See https://github.com/darealshinji/AppImageKit-checkrt
-cp exec-x86_64.so AppDir/usr/optional/exec.so
-cp AppRun-patched-x86_64 AppDir/AppRun
-cp --dereference /usr/lib/x86_64-linux-gnu/libstdc++.so.6 AppDir/usr/optional/libstdc++/libstdc++.so.6
-cp --dereference /lib/x86_64-linux-gnu/libgcc_s.so.1 AppDir/usr/optional/libgcc_s/libgcc_s.so.1

.ci/scripts/linux/upload.sh

@@ -2,7 +2,6 @@
 
 . .ci/scripts/common/pre-upload.sh
 
-APPIMAGE_NAME="yuzu-${GITDATE}-${GITREV}.AppImage"
 REV_NAME="yuzu-linux-${GITDATE}-${GITREV}"
 ARCHIVE_NAME="${REV_NAME}.tar.xz"
 COMPRESSION_FLAGS="-cJvf"
@@ -18,24 +17,4 @@ mkdir "$DIR_NAME"
 cp build/bin/yuzu-cmd "$DIR_NAME"
 cp build/bin/yuzu "$DIR_NAME"
 
-# Build an AppImage
-cd build
-
-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
-    # Generate update information if releasing to mainline
-    ./appimagetool-x86_64.AppImage -u "gh-releases-zsync|yuzu-emu|yuzu-${RELEASE_NAME}|latest|yuzu-*.AppImage.zsync" AppDir "${APPIMAGE_NAME}"
-else
-    ./appimagetool-x86_64.AppImage AppDir "${APPIMAGE_NAME}"
-fi
-cd ..
-
-# Copy the AppImage and update info to the artifacts directory and avoid compressing it
-cp "build/${APPIMAGE_NAME}" "${ARTIFACTS_DIR}/"
-if [ -f "build/${APPIMAGE_NAME}.zsync" ]; then
-    cp "build/${APPIMAGE_NAME}.zsync" "${ARTIFACTS_DIR}/"
-fi
-
 . .ci/scripts/common/post-upload.sh

.ci/scripts/windows/docker.sh

@@ -42,8 +42,3 @@ done
 pip3 install pefile
 python3 .ci/scripts/windows/scan_dll.py package/*.exe "package/"
 python3 .ci/scripts/windows/scan_dll.py package/imageformats/*.dll "package/"
-
-# copy FFmpeg libraries
-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/ ';'

.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 --config Release -DYUZU_USE_BUNDLED_QT=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'] }} .. && cd ..
+- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
   displayName: 'Configure CMake'
 - task: MSBuild@1
   displayName: 'Build'

.ci/templates/build-standard.yml

@@ -12,9 +12,6 @@ jobs:
       windows:
         BuildSuffix: 'windows-mingw'
         ScriptFolder: 'windows'
-      clang:
-        BuildSuffix: 'clang'
-        ScriptFolder: 'clang'
       linux:
         BuildSuffix: 'linux'
         ScriptFolder: 'linux'
@@ -27,4 +24,4 @@ jobs:
     parameters:
       artifactSource: 'false'
       cache: $(parameters.cache)
-      version: $(parameters.version)
+      version: $(parameters.version)

.gitmodules

@@ -27,7 +27,7 @@
     url = https://github.com/ReinUsesLisp/sirit
 [submodule "mbedtls"]
     path = externals/mbedtls
-    url = https://github.com/yuzu-emu/mbedtls
+    url = https://github.com/DarkLordZach/mbedtls
 [submodule "libzip"]
     path = externals/libzip/libzip
     url = https://github.com/nih-at/libzip.git
@@ -37,6 +37,3 @@
 [submodule "opus"]
 	path = externals/opus/opus
 	url = https://github.com/xiph/opus.git
-[submodule "ffmpeg"]
-	path = externals/ffmpeg
-	url = https://git.ffmpeg.org/ffmpeg.git

.travis/linux/build.sh

@@ -1,4 +1,4 @@
 #!/bin/bash -ex
 
 mkdir -p "$HOME/.ccache"
-docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/home/yuzu/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh

CMakeLists.txt

@@ -18,19 +18,15 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "EN
 
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled yuzu" ON "WIN32" OFF)
-
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
 
 option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implementation of BCAT" ON)
 
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
-option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
+option(ENABLE_VULKAN "Enables Vulkan backend" ON)
 
-if (NOT ENABLE_WEB_SERVICE)
-    set(YUZU_ENABLE_BOXCAT OFF)
-endif()
+option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
 # Default to a Release build
 get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
@@ -164,6 +160,7 @@ macro(yuzu_find_packages)
     # Capitalization matters here. We need the naming to match the generated paths from Conan
     set(REQUIRED_LIBS
     #    Cmake Pkg Prefix  Version     Conan Pkg
+        "Boost             1.73        boost/1.73.0"
         "Catch2            2.13        catch2/2.13.0"
         "fmt               7.1         fmt/7.1.2"
     # can't use until https://github.com/bincrafters/community/issues/1173
@@ -171,7 +168,7 @@ macro(yuzu_find_packages)
         "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.4         zstd/1.4.8"
+        "zstd              1.4         zstd/1.4.5"
     )
 
     foreach(PACKAGE ${REQUIRED_LIBS})
@@ -198,22 +195,6 @@ macro(yuzu_find_packages)
     unset(FN_FORCE_REQUIRED)
 endmacro()
 
-find_package(Boost 1.73.0 COMPONENTS context headers QUIET)
-if (Boost_FOUND)
-    set(Boost_LIBRARIES Boost::boost)
-    # Conditionally add Boost::context only if the active version of the Conan or system Boost package provides it
-    # The old version is missing Boost::context, so we want to avoid adding in that case
-    # The new version requires adding Boost::context to prevent linking issues
-    #
-    # This one is used by Conan on subsequent CMake configures, not the first configure.
-    if (TARGET Boost::context)
-        list(APPEND Boost_LIBRARIES Boost::context)
-    endif()
-else()
-    message(STATUS "Boost 1.73.0 or newer not found, falling back to Conan")
-    list(APPEND CONAN_REQUIRED_LIBS "boost/1.73.0")
-endif()
-
 # Attempt to locate any packages that are required and report the missing ones in CONAN_REQUIRED_LIBS
 yuzu_find_packages()
 
@@ -245,7 +226,7 @@ if(ENABLE_QT)
     if (YUZU_USE_QT_WEB_ENGINE)
         find_package(Qt5 COMPONENTS WebEngineCore WebEngineWidgets)
     endif()
-
+	
     if (ENABLE_QT_TRANSLATION)
         find_package(Qt5 REQUIRED COMPONENTS LinguistTools ${QT_PREFIX_HINT})
     endif()
@@ -263,7 +244,7 @@ if(ENABLE_SDL2)
     find_package(SDL2)
     if (NOT SDL2_FOUND)
         # otherwise add this to the list of libraries to install
-        list(APPEND CONAN_REQUIRED_LIBS "sdl2/2.0.14@bincrafters/stable")
+        list(APPEND CONAN_REQUIRED_LIBS "sdl2/2.0.12@bincrafters/stable")
     endif()
 endif()
 
@@ -318,17 +299,6 @@ if (CONAN_REQUIRED_LIBS)
     # this time with required, so we bail if its not found.
     yuzu_find_packages(FORCE_REQUIRED)
 
-    if (NOT Boost_FOUND)
-        find_package(Boost 1.73.0 REQUIRED COMPONENTS context headers)
-        set(Boost_LIBRARIES Boost::boost)
-        # Conditionally add Boost::context only if the active version of the Conan Boost package provides it
-        # The old version is missing Boost::context, so we want to avoid adding in that case
-        # The new version requires adding Boost::context to prevent linking issues
-        if (TARGET Boost::context)
-            list(APPEND Boost_LIBRARIES Boost::context)
-        endif()
-    endif()
-
     # Due to issues with variable scopes in functions, we need to also find_package(qt5) outside of the function
     if(ENABLE_QT)
         list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
@@ -386,141 +356,19 @@ if (NOT LIBUSB_FOUND)
     set(LIBUSB_LIBRARIES usb)
 endif()
 
-# List of all FFmpeg components required
-set(FFmpeg_COMPONENTS
-    avcodec
-    avutil
-    swscale)
-
-if (NOT YUZU_USE_BUNDLED_FFMPEG)
-    # Use system installed FFmpeg
-    find_package(FFmpeg REQUIRED COMPONENTS ${FFmpeg_COMPONENTS})
-
-    if (FFmpeg_FOUND)
-        # Overwrite aggregate defines from FFmpeg module to avoid over-linking libraries.
-        # Prevents shipping too many libraries with the AppImage.
-        set(FFmpeg_LIBRARIES "")
-        set(FFmpeg_INCLUDE_DIR "")
-
-        foreach(COMPONENT ${FFmpeg_COMPONENTS})
-            set(FFmpeg_LIBRARIES ${FFmpeg_LIBRARIES} ${FFmpeg_LIBRARY_${COMPONENT}} CACHE PATH "Paths to FFmpeg libraries" FORCE)
-            set(FFmpeg_INCLUDE_DIR ${FFmpeg_INCLUDE_DIR} ${FFmpeg_INCLUDE_${COMPONENT}} CACHE PATH "Path to FFmpeg headers" FORCE)
-        endforeach()
-    else()
-        message(WARNING "FFmpeg not found, falling back to externals")
-        set(YUZU_USE_BUNDLED_FFMPEG ON)
-    endif()
+# Use system installed ffmpeg.
+if (NOT MSVC)
+    find_package(FFmpeg REQUIRED)
+else()
+    set(FFMPEG_EXT_NAME "ffmpeg-4.2.1")
+    set(FFMPEG_PATH "${CMAKE_BINARY_DIR}/externals/${FFMPEG_EXT_NAME}")
+    download_bundled_external("ffmpeg/" ${FFMPEG_EXT_NAME} "")
+    set(FFMPEG_FOUND YES)
+    set(FFMPEG_INCLUDE_DIR "${FFMPEG_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
+    set(FFMPEG_LIBRARY_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg library" FORCE)
+    set(FFMPEG_DLL_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
 endif()
 
-if (YUZU_USE_BUNDLED_FFMPEG)
-    if (NOT WIN32)
-        # Build FFmpeg from externals
-        message(STATUS "Using FFmpeg from externals")
-
-        # FFmpeg has source that requires one of nasm or yasm to assemble it.
-        # REQUIRED throws an error if not found here during configuration rather than during compilation.
-        find_program(ASSEMBLER NAMES nasm yasm REQUIRED)
-
-        set(FFmpeg_PREFIX ${PROJECT_SOURCE_DIR}/externals/ffmpeg)
-        set(FFmpeg_BUILD_DIR ${PROJECT_BINARY_DIR}/externals/ffmpeg)
-        set(FFmpeg_MAKEFILE ${FFmpeg_BUILD_DIR}/Makefile)
-        make_directory(${FFmpeg_BUILD_DIR})
-
-        # Read version string from external
-        file(READ ${FFmpeg_PREFIX}/RELEASE FFmpeg_VERSION)
-        set(FFmpeg_FOUND NO)
-        if (NOT FFmpeg_VERSION STREQUAL "")
-            set(FFmpeg_FOUND YES)
-        endif()
-
-        foreach(COMPONENT ${FFmpeg_COMPONENTS})
-            set(FFmpeg_${COMPONENT}_PREFIX "${FFmpeg_BUILD_DIR}/lib${COMPONENT}")
-            set(FFmpeg_${COMPONENT}_LIB_NAME "lib${COMPONENT}.a")
-            set(FFmpeg_${COMPONENT}_LIBRARY "${FFmpeg_${COMPONENT}_PREFIX}/${FFmpeg_${COMPONENT}_LIB_NAME}")
-
-            set(FFmpeg_LIBRARIES
-                ${FFmpeg_LIBRARIES}
-                ${FFmpeg_${COMPONENT}_LIBRARY}
-                CACHE PATH "Paths to FFmpeg libraries" FORCE)
-        endforeach()
-
-        set(FFmpeg_INCLUDE_DIR
-            ${FFmpeg_PREFIX}
-            CACHE PATH "Path to FFmpeg headers" FORCE)
-
-        # `configure` parameters builds only exactly what yuzu needs from FFmpeg
-        # `--disable-{vaapi,vdpau}` is needed to avoid linking issues
-        add_custom_command(
-            OUTPUT
-                ${FFmpeg_MAKEFILE}
-            COMMAND
-                /bin/bash ${FFmpeg_PREFIX}/configure
-                    --disable-avdevice
-                    --disable-avfilter
-                    --disable-avformat
-                    --disable-doc
-                    --disable-everything
-                    --disable-ffmpeg
-                    --disable-ffprobe
-                    --disable-network
-                    --disable-postproc
-                    --disable-swresample
-                    --disable-vaapi
-                    --disable-vdpau
-                    --enable-decoder=h264
-                    --enable-decoder=vp9
-            WORKING_DIRECTORY
-                ${FFmpeg_BUILD_DIR}
-        )
-
-        # Workaround for Ubuntu 18.04's older version of make not being able to call make as a child
-        # with context of the jobserver. Also helps ninja users.
-        execute_process(
-            COMMAND
-                nproc
-            OUTPUT_VARIABLE
-                SYSTEM_THREADS)
-
-        add_custom_command(
-            OUTPUT
-                ${FFmpeg_LIBRARIES}
-            COMMAND
-                make -j${SYSTEM_THREADS}
-            WORKING_DIRECTORY
-                ${FFmpeg_BUILD_DIR}
-        )
-
-        # ALL makes this custom target build every time
-        # but it won't actually build if the DEPENDS parameter is up to date
-        add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_LIBRARIES})
-        add_custom_target(ffmpeg-configure ALL DEPENDS ${FFmpeg_MAKEFILE})
-
-        if (FFmpeg_FOUND)
-            message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
-
-            add_dependencies(ffmpeg-build ffmpeg-configure)
-        else()
-            message(FATAL_ERROR "FFmpeg not found")
-        endif()
-    else() # WIN32
-        # Use yuzu FFmpeg binaries
-        set(FFmpeg_EXT_NAME "ffmpeg-4.3.1")
-        set(FFmpeg_PATH "${CMAKE_BINARY_DIR}/externals/${FFmpeg_EXT_NAME}")
-        download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "")
-        set(FFmpeg_FOUND YES)
-        set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
-        set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg library directory" FORCE)
-        set(FFmpeg_DLL_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
-        set(FFmpeg_LIBRARIES
-            ${FFmpeg_LIBRARY_DIR}/swscale.lib
-            ${FFmpeg_LIBRARY_DIR}/avcodec.lib
-            ${FFmpeg_LIBRARY_DIR}/avutil.lib
-            CACHE PATH "Paths to FFmpeg libraries" FORCE)
-    endif()
-endif()
-
-unset(FFmpeg_COMPONENTS)
-
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)

CMakeModules/CopyYuzuFFmpegDeps.cmake

@@ -1,6 +1,10 @@
 function(copy_yuzu_FFmpeg_deps target_dir)
     include(WindowsCopyFiles)
     set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
-    file(READ "${FFmpeg_PATH}/requirements.txt" FFmpeg_REQUIRED_DLLS)
-    windows_copy_files(${target_dir} ${FFmpeg_DLL_DIR} ${DLL_DEST} ${FFmpeg_REQUIRED_DLLS})
+    windows_copy_files(${target_dir} ${FFMPEG_DLL_DIR} ${DLL_DEST}
+        avcodec-58.dll
+        avutil-56.dll
+        swresample-3.dll
+        swscale-5.dll
+    )
 endfunction(copy_yuzu_FFmpeg_deps)

README.md

@@ -30,10 +30,11 @@ If you want to contribute to the user interface translation, please check out th
 
 * __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)
+* __macOS__: [macOS Build](https://github.com/yuzu-emu/yuzu/wiki/Building-for-macOS)
 
 
 ### 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:
+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

dist/icons/controller/controller.qrc

@@ -1,5 +1,26 @@
 <RCC>
   <qresource prefix="controller">
+    <file alias="dual_joycon">dual_joycon.png</file>
+    <file alias="dual_joycon_dark">dual_joycon_dark.png</file>
+    <file alias="dual_joycon_midnight">dual_joycon_midnight.png</file>
+    <file alias="handheld">handheld.png</file>
+    <file alias="handheld_dark">handheld_dark.png</file>
+    <file alias="handheld_midnight">handheld_midnight.png</file>
+    <file alias="pro_controller">pro_controller.png</file>
+    <file alias="pro_controller_dark">pro_controller_dark.png</file>
+    <file alias="pro_controller_midnight">pro_controller_midnight.png</file>
+    <file alias="single_joycon_left">single_joycon_left.png</file>
+    <file alias="single_joycon_left_dark">single_joycon_left_dark.png</file>
+    <file alias="single_joycon_left_midnight">single_joycon_left_midnight.png</file>
+    <file alias="single_joycon_right">single_joycon_right.png</file>
+    <file alias="single_joycon_right_dark">single_joycon_right_dark.png</file>
+    <file alias="single_joycon_right_midnight">single_joycon_right_midnight.png</file>
+    <file alias="single_joycon_left_vertical">single_joycon_left_vertical.png</file>
+    <file alias="single_joycon_left_vertical_dark">single_joycon_left_vertical_dark.png</file>
+    <file alias="single_joycon_left_vertical_midnight">single_joycon_left_vertical_midnight.png</file>
+    <file alias="single_joycon_right_vertical">single_joycon_right_vertical.png</file>
+    <file alias="single_joycon_right_vertical_dark">single_joycon_right_vertical_dark.png</file>
+    <file alias="single_joycon_right_vertical_midnight">single_joycon_right_vertical_midnight.png</file>
     <file alias="applet_dual_joycon">applet_dual_joycon.png</file>
     <file alias="applet_dual_joycon_dark">applet_dual_joycon_dark.png</file>	
     <file alias="applet_dual_joycon_midnight">applet_dual_joycon_midnight.png</file>	

dist/qt_themes/colorful_dark/icons/index.theme

@@ -1,7 +1,7 @@
 [Icon Theme]
 Name=colorful_dark
 Comment=Colorful theme (Dark style)
-Inherits=colorful
+Inherits=default
 Directories=16x16
  
 [16x16]

dist/qt_themes/colorful_midnight_blue/icons/index.theme

@@ -1,7 +1,7 @@
 [Icon Theme]
 Name=colorful_midnight_blue
 Comment=Colorful theme (Midnight Blue style)
-Inherits=colorful
+Inherits=default
 Directories=16x16
 
 [16x16]

dist/qt_themes/qdarkstyle_midnight_blue/style.qss

@@ -1257,6 +1257,10 @@ QComboBox::item:alternate {
   background: #19232D;
 }
 
+QComboBox::item:checked {
+  font-weight: bold;
+}
+
 QComboBox::item:selected {
   border: 0px solid transparent;
 }

externals/CMakeLists.txt

@@ -61,7 +61,9 @@ if (USE_DISCORD_PRESENCE)
 endif()
 
 # Sirit
-add_subdirectory(sirit)
+if (ENABLE_VULKAN)
+    add_subdirectory(sirit)
+endif()
 
 # libzip
 find_package(Libzip 1.5)

externals/find-modules/FindFFmpeg.cmake

@@ -1,187 +1,100 @@
-# FindFFmpeg
-# ----------
+# - Try to find ffmpeg libraries (libavcodec, libavformat and libavutil)
+# Once done this will define
 #
-# Copyright 2019 Citra Emulator Project
-# Licensed under GPLv2 or any later version
+# FFMPEG_FOUND - system has ffmpeg or libav
+# FFMPEG_INCLUDE_DIR - the ffmpeg include directory
+# FFMPEG_LIBRARIES - Link these to use ffmpeg
+# FFMPEG_LIBAVCODEC
+# FFMPEG_LIBAVFORMAT
+# FFMPEG_LIBAVUTIL
 #
-# Find the native FFmpeg includes and libraries
+# Copyright (c) 2008 Andreas Schneider <mail@cynapses.org>
+# Modified for other libraries by Lasse Kärkkäinen <tronic>
+# Modified for Hedgewars by Stepik777
+# Modified for FFmpeg-example Tuukka Pasanen 2018
+# Modified for yuzu toastUnlimted 2020
 #
-# This module defines the following variables:
+# Redistribution and use is allowed according to the terms of the New
+# BSD license.
 #
-#  FFmpeg_INCLUDE_<component>: where to find <component>.h
-#  FFmpeg_LIBRARY_<component>: where to find the <component> library
-#  FFmpeg_INCLUDE_DIR: aggregate all the include paths
-#  FFmpeg_LIBRARIES: aggregate all the paths to the libraries
-#  FFmpeg_FOUND: True if all components have been found
-#
-# This module defines the following targets, which are prefered over variables:
-#
-#  FFmpeg::<component>: Target to use <component> directly, with include path,
-#    library and dependencies set up. If you are using a static build, you are
-#    responsible for adding any external dependencies (such as zlib, bzlib...).
-#
-# <component> can be one of:
-#   avcodec
-#   avdevice
-#   avfilter
-#   avformat
-#   avutil
-#   postproc
-#   swresample
-#   swscale
-#
-
-set(_FFmpeg_ALL_COMPONENTS
-    avcodec
-    avdevice
-    avfilter
-    avformat
-    avutil
-    postproc
-    swresample
-    swscale
-)
-
-set(_FFmpeg_DEPS_avcodec avutil)
-set(_FFmpeg_DEPS_avdevice avcodec avformat avutil)
-set(_FFmpeg_DEPS_avfilter avutil)
-set(_FFmpeg_DEPS_avformat avcodec avutil)
-set(_FFmpeg_DEPS_postproc avutil)
-set(_FFmpeg_DEPS_swresample avutil)
-set(_FFmpeg_DEPS_swscale avutil)
-
-function(find_ffmpeg LIBNAME)
-  if(DEFINED ENV{FFMPEG_DIR})
-    set(FFMPEG_DIR $ENV{FFMPEG_DIR})
-  endif()
-
-  if(FFMPEG_DIR)
-    list(APPEND INCLUDE_PATHS
-      ${FFMPEG_DIR}
-      ${FFMPEG_DIR}/ffmpeg
-      ${FFMPEG_DIR}/lib${LIBNAME}
-      ${FFMPEG_DIR}/include/lib${LIBNAME}
-      ${FFMPEG_DIR}/include/ffmpeg
-      ${FFMPEG_DIR}/include
-      NO_DEFAULT_PATH
-      NO_CMAKE_FIND_ROOT_PATH
-    )
-    list(APPEND LIB_PATHS
-      ${FFMPEG_DIR}
-      ${FFMPEG_DIR}/lib
-      ${FFMPEG_DIR}/lib${LIBNAME}
-      NO_DEFAULT_PATH
-      NO_CMAKE_FIND_ROOT_PATH
-    )
-  else()
-    list(APPEND INCLUDE_PATHS
-      /usr/local/include/ffmpeg
-      /usr/local/include/lib${LIBNAME}
-      /usr/include/ffmpeg
-      /usr/include/lib${LIBNAME}
-      /usr/include/ffmpeg/lib${LIBNAME}
-    )
-
-    list(APPEND LIB_PATHS
-      /usr/local/lib
-      /usr/lib
-    )
-  endif()
-
-  find_path(FFmpeg_INCLUDE_${LIBNAME} lib${LIBNAME}/${LIBNAME}.h
-    HINTS ${INCLUDE_PATHS}
-  )
-
-  find_library(FFmpeg_LIBRARY_${LIBNAME} ${LIBNAME}
-    HINTS ${LIB_PATHS}
-  )
-
-  if(NOT FFMPEG_DIR AND (NOT FFmpeg_LIBRARY_${LIBNAME} OR NOT FFmpeg_INCLUDE_${LIBNAME}))
-    # Didn't find it in the usual paths, try pkg-config
-    find_package(PkgConfig QUIET)
-    pkg_check_modules(FFmpeg_PKGCONFIG_${LIBNAME} QUIET lib${LIBNAME})
-
-    find_path(FFmpeg_INCLUDE_${LIBNAME} lib${LIBNAME}/${LIBNAME}.h
-      ${FFmpeg_PKGCONFIG_${LIBNAME}_INCLUDE_DIRS}
-    )
-
-    find_library(FFmpeg_LIBRARY_${LIBNAME} ${LIBNAME}
-      ${FFmpeg_PKGCONFIG_${LIBNAME}_LIBRARY_DIRS}
-    )
-  endif()
-
-  if(FFmpeg_INCLUDE_${LIBNAME} AND FFmpeg_LIBRARY_${LIBNAME})
-    set(FFmpeg_INCLUDE_${LIBNAME} "${FFmpeg_INCLUDE_${LIBNAME}}" PARENT_SCOPE)
-    set(FFmpeg_LIBRARY_${LIBNAME} "${FFmpeg_LIBRARY_${LIBNAME}}" PARENT_SCOPE)
-
-    # Extract FFmpeg version from version.h
-    foreach(v MAJOR MINOR MICRO)
-      set(FFmpeg_${LIBNAME}_VERSION_${v} 0)
-    endforeach()
-    string(TOUPPER ${LIBNAME} LIBNAME_UPPER)
-    file(STRINGS "${FFmpeg_INCLUDE_${LIBNAME}}/lib${LIBNAME}/version.h" _FFmpeg_VERSION_H_CONTENTS REGEX "#define LIB${LIBNAME_UPPER}_VERSION_(MAJOR|MINOR|MICRO) ")
-    set(_FFmpeg_VERSION_REGEX "([0-9]+)")
-    foreach(v MAJOR MINOR MICRO)
-      if("${_FFmpeg_VERSION_H_CONTENTS}" MATCHES "#define LIB${LIBNAME_UPPER}_VERSION_${v}[\\t ]+${_FFmpeg_VERSION_REGEX}")
-        set(FFmpeg_${LIBNAME}_VERSION_${v} "${CMAKE_MATCH_1}")
-      endif()
-    endforeach()
-    set(FFmpeg_${LIBNAME}_VERSION "${FFmpeg_${LIBNAME}_VERSION_MAJOR}.${FFmpeg_${LIBNAME}_VERSION_MINOR}.${FFmpeg_${LIBNAME}_VERSION_MICRO}")
-    set(FFmpeg_${c}_VERSION "${FFmpeg_${LIBNAME}_VERSION}" PARENT_SCOPE)
-    unset(_FFmpeg_VERSION_REGEX)
-    unset(_FFmpeg_VERSION_H_CONTENTS)
-
-    set(FFmpeg_${c}_FOUND TRUE PARENT_SCOPE)
-    if(NOT FFmpeg_FIND_QUIETLY)
-      message("--  Found ${LIBNAME}: ${FFmpeg_INCLUDE_${LIBNAME}} ${FFmpeg_LIBRARY_${LIBNAME}} (version: ${FFmpeg_${LIBNAME}_VERSION})")
-    endif()
-  endif()
-endfunction()
-
-foreach(c ${_FFmpeg_ALL_COMPONENTS})
-  find_ffmpeg(${c})
-endforeach()
-
-foreach(c ${_FFmpeg_ALL_COMPONENTS})
-  if(FFmpeg_${c}_FOUND)
-    list(APPEND FFmpeg_INCLUDE_DIR ${FFmpeg_INCLUDE_${c}})
-    list(APPEND FFmpeg_LIBRARIES ${FFmpeg_LIBRARY_${c}})
-
-    add_library(FFmpeg::${c} IMPORTED UNKNOWN)
-    set_target_properties(FFmpeg::${c} PROPERTIES
-      IMPORTED_LOCATION ${FFmpeg_LIBRARY_${c}}
-      INTERFACE_INCLUDE_DIRECTORIES ${FFmpeg_INCLUDE_${c}}
-    )
-    if(_FFmpeg_DEPS_${c})
-      set(deps)
-      foreach(dep ${_FFmpeg_DEPS_${c}})
-        list(APPEND deps FFmpeg::${dep})
-      endforeach()
-
-      set_target_properties(FFmpeg::${c} PROPERTIES
-        INTERFACE_LINK_LIBRARIES "${deps}"
-      )
-      unset(deps)
-    endif()
-  endif()
-endforeach()
-
-if(FFmpeg_INCLUDE_DIR)
-  list(REMOVE_DUPLICATES FFmpeg_INCLUDE_DIR)
-endif()
-
-foreach(c ${FFmpeg_FIND_COMPONENTS})
-  list(APPEND _FFmpeg_REQUIRED_VARS FFmpeg_INCLUDE_${c} FFmpeg_LIBRARY_${c})
-endforeach()
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(FFmpeg
-  REQUIRED_VARS ${_FFmpeg_REQUIRED_VARS}
-  HANDLE_COMPONENTS
+
+find_package_handle_standard_args(FFMPEG
+  FOUND_VAR FFMPEG_FOUND
+  REQUIRED_VARS
+      FFMPEG_LIBRARY
+      FFMPEG_INCLUDE_DIR
+  VERSION_VAR FFMPEG_VERSION
 )
 
-foreach(c ${_FFmpeg_ALL_COMPONENTS})
-  unset(_FFmpeg_DEPS_${c})
-endforeach()
-unset(_FFmpeg_ALL_COMPONENTS)
-unset(_FFmpeg_REQUIRED_VARS)
+if(FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
+  # in cache already
+  set(FFMPEG_FOUND TRUE)
+else()
+  # use pkg-config to get the directories and then use these values
+  # in the FIND_PATH() and FIND_LIBRARY() calls
+  find_package(PkgConfig)
+  if(PKG_CONFIG_FOUND)
+    pkg_check_modules(_FFMPEG_AVCODEC libavcodec)
+    pkg_check_modules(_FFMPEG_AVUTIL libavutil)
+    pkg_check_modules(_FFMPEG_SWSCALE libswscale)
+  endif()
+
+  find_path(FFMPEG_AVCODEC_INCLUDE_DIR
+    NAMES libavcodec/avcodec.h
+    PATHS ${_FFMPEG_AVCODEC_INCLUDE_DIRS}
+      /usr/include
+      /usr/local/include
+      /opt/local/include
+      /sw/include
+    PATH_SUFFIXES ffmpeg libav)
+
+  find_library(FFMPEG_LIBAVCODEC
+    NAMES avcodec
+    PATHS ${_FFMPEG_AVCODEC_LIBRARY_DIRS}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib)
+
+  find_library(FFMPEG_LIBAVUTIL
+    NAMES avutil
+    PATHS ${_FFMPEG_AVUTIL_LIBRARY_DIRS}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib)
+
+  find_library(FFMPEG_LIBSWSCALE
+    NAMES swscale
+    PATHS ${_FFMPEG_SWSCALE_LIBRARY_DIRS}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib)
+
+  if(FFMPEG_LIBAVCODEC AND FFMPEG_LIBAVUTIL AND FFMPEG_LIBSWSCALE)
+    set(FFMPEG_FOUND TRUE)
+  endif()
+
+  if(FFMPEG_FOUND)
+    set(FFMPEG_INCLUDE_DIR ${FFMPEG_AVCODEC_INCLUDE_DIR})
+    set(FFMPEG_LIBRARIES
+      ${FFMPEG_LIBAVCODEC}
+      ${FFMPEG_LIBAVUTIL}
+      ${FFMPEG_LIBSWSCALE})
+  endif()
+
+  if(FFMPEG_FOUND)
+    if(NOT FFMPEG_FIND_QUIETLY)
+      message(STATUS
+      "Found FFMPEG or Libav: ${FFMPEG_LIBRARIES}, ${FFMPEG_INCLUDE_DIR}")
+    endif()
+  else()
+    if(FFMPEG_FIND_REQUIRED)
+      message(FATAL_ERROR
+      "Could not find libavcodec or libavutil or libswscale")
+    endif()
+  endif()
+endif()

externals/glad/include/glad/glad.h

@@ -5156,9 +5156,6 @@ GLAPI PFNGLDEPTHRANGEARRAYVPROC glad_glDepthRangeArrayv;
 typedef void (APIENTRYP PFNGLDEPTHRANGEINDEXEDPROC)(GLuint index, GLdouble n, GLdouble f);
 GLAPI PFNGLDEPTHRANGEINDEXEDPROC glad_glDepthRangeIndexed;
 #define glDepthRangeIndexed glad_glDepthRangeIndexed
-typedef void (APIENTRYP PFNGLDEPTHRANGEINDEXEDDNVPROC)(GLuint index, GLdouble n, GLdouble f);
-GLAPI PFNGLDEPTHRANGEINDEXEDDNVPROC glad_glDepthRangeIndexeddNV;
-#define glDepthRangeIndexeddNV glad_glDepthRangeIndexeddNV
 typedef void (APIENTRYP PFNGLGETFLOATI_VPROC)(GLenum target, GLuint index, GLfloat *data);
 GLAPI PFNGLGETFLOATI_VPROC glad_glGetFloati_v;
 #define glGetFloati_v glad_glGetFloati_v

externals/glad/src/glad.c

@@ -1044,7 +1044,6 @@ PFNGLDEPTHMASKPROC glad_glDepthMask = NULL;
 PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL;
 PFNGLDEPTHRANGEARRAYVPROC glad_glDepthRangeArrayv = NULL;
 PFNGLDEPTHRANGEINDEXEDPROC glad_glDepthRangeIndexed = NULL;
-PFNGLDEPTHRANGEINDEXEDDNVPROC glad_glDepthRangeIndexeddNV = NULL;
 PFNGLDEPTHRANGEFPROC glad_glDepthRangef = NULL;
 PFNGLDETACHSHADERPROC glad_glDetachShader = NULL;
 PFNGLDISABLEPROC glad_glDisable = NULL;
@@ -7972,7 +7971,6 @@ static void load_GL_NV_depth_buffer_float(GLADloadproc load) {
 	glad_glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)load("glDepthRangedNV");
 	glad_glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)load("glClearDepthdNV");
 	glad_glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)load("glDepthBoundsdNV");
-	glad_glDepthRangeIndexeddNV = (PFNGLDEPTHRANGEINDEXEDDNVPROC)load("glDepthRangeIndexeddNV");
 }
 static void load_GL_NV_draw_texture(GLADloadproc load) {
 	if(!GLAD_GL_NV_draw_texture) return;

src/CMakeLists.txt

@@ -27,7 +27,6 @@ if (MSVC)
     # /Zo                 - Enhanced debug info for optimized builds
     # /permissive-        - Enables stricter C++ standards conformance checks
     # /EHsc               - C++-only exception handling semantics
-    # /utf-8              - Set source and execution character sets to UTF-8
     # /volatile:iso       - Use strict standards-compliant volatile semantics.
     # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
     # /Zc:inline          - Let codegen omit inline functions in object files
@@ -39,7 +38,6 @@ if (MSVC)
         /permissive-
         /EHsc
         /std:c++latest
-        /utf-8
         /volatile:iso
         /Zc:externConstexpr
         /Zc:inline
@@ -47,15 +45,10 @@ if (MSVC)
 
         # Warnings
         /W3
-        /we4062 # enumerator 'identifier' in a switch of enum 'enumeration' is not handled
-        /we4101 # 'identifier': unreferenced local variable
-        /we4265 # 'class': class has virtual functions, but destructor is not virtual
-        /we4388 # signed/unsigned mismatch
         /we4547 # 'operator' : operator before comma has no effect; expected operator with side-effect
         /we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
         /we4555 # Expression has no effect; expected expression with side-effect
         /we4834 # Discarding return value of function with 'nodiscard' attribute
-        /we5038 # data member 'member1' will be initialized after data member 'member2'
     )
 
     # /GS- - No stack buffer overflow checks
@@ -66,16 +59,10 @@ if (MSVC)
 else()
     add_compile_options(
         -Wall
-        -Werror=array-bounds
         -Werror=implicit-fallthrough
         -Werror=missing-declarations
-        -Werror=missing-field-initializers
         -Werror=reorder
-        -Werror=switch
-        -Werror=uninitialized
-        -Werror=unused-function
         -Werror=unused-result
-        -Werror=unused-variable
         -Wextra
         -Wmissing-declarations
         -Wno-attributes
@@ -134,6 +121,7 @@ add_subdirectory(tests)
 
 if (ENABLE_SDL2)
     add_subdirectory(yuzu_cmd)
+    add_subdirectory(yuzu_tester)
 endif()
 
 if (ENABLE_QT)

src/audio_core/CMakeLists.txt

@@ -15,8 +15,6 @@ add_library(audio_core STATIC
     command_generator.cpp
     command_generator.h
     common.h
-    delay_line.cpp
-    delay_line.h
     effect_context.cpp
     effect_context.h
     info_updater.cpp

src/audio_core/algorithm/interpolate.cpp

@@ -218,7 +218,7 @@ void Resample(s32* output, const s32* input, s32 pitch, s32& fraction, std::size
         const auto l2 = lut[lut_index + 2];
         const auto l3 = lut[lut_index + 3];
 
-        const auto s0 = static_cast<s32>(input[index + 0]);
+        const auto s0 = static_cast<s32>(input[index]);
         const auto s1 = static_cast<s32>(input[index + 1]);
         const auto s2 = static_cast<s32>(input[index + 2]);
         const auto s3 = static_cast<s32>(input[index + 3]);

src/audio_core/audio_renderer.cpp

@@ -11,6 +11,7 @@
 #include "audio_core/info_updater.h"
 #include "audio_core/voice_context.h"
 #include "common/logging/log.h"
+#include "core/hle/kernel/writable_event.h"
 #include "core/memory.h"
 #include "core/settings.h"
 
@@ -70,9 +71,10 @@ namespace {
 namespace AudioCore {
 AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
                              AudioCommon::AudioRendererParameter params,
-                             Stream::ReleaseCallback&& release_callback,
+                             std::shared_ptr<Kernel::WritableEvent> buffer_event_,
                              std::size_t instance_number)
-    : worker_params{params}, memory_pool_info(params.effect_count + params.voice_count * 4),
+    : worker_params{params}, buffer_event{buffer_event_},
+      memory_pool_info(params.effect_count + params.voice_count * 4),
       voice_context(params.voice_count), effect_context(params.effect_count), mix_context(),
       sink_context(params.sink_count), splitter_context(),
       voices(params.voice_count), memory{memory_},
@@ -83,9 +85,10 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory
                                 params.num_splitter_send_channels);
     mix_context.Initialize(behavior_info, params.submix_count + 1, params.effect_count);
     audio_out = std::make_unique<AudioCore::AudioOut>();
-    stream = audio_out->OpenStream(
-        core_timing, params.sample_rate, AudioCommon::STREAM_NUM_CHANNELS,
-        fmt::format("AudioRenderer-Instance{}", instance_number), std::move(release_callback));
+    stream =
+        audio_out->OpenStream(core_timing, params.sample_rate, AudioCommon::STREAM_NUM_CHANNELS,
+                              fmt::format("AudioRenderer-Instance{}", instance_number),
+                              [=]() { buffer_event_->Signal(); });
     audio_out->StartStream(stream);
 
     QueueMixedBuffer(0);

src/audio_core/audio_renderer.h

@@ -27,6 +27,10 @@ namespace Core::Timing {
 class CoreTiming;
 }
 
+namespace Kernel {
+class WritableEvent;
+}
+
 namespace Core::Memory {
 class Memory;
 }
@@ -40,7 +44,8 @@ class AudioRenderer {
 public:
     AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
                   AudioCommon::AudioRendererParameter params,
-                  Stream::ReleaseCallback&& release_callback, std::size_t instance_number);
+                  std::shared_ptr<Kernel::WritableEvent> buffer_event_,
+                  std::size_t instance_number);
     ~AudioRenderer();
 
     [[nodiscard]] ResultCode UpdateAudioRenderer(const std::vector<u8>& input_params,
@@ -56,6 +61,7 @@ private:
     BehaviorInfo behavior_info{};
 
     AudioCommon::AudioRendererParameter worker_params;
+    std::shared_ptr<Kernel::WritableEvent> buffer_event;
     std::vector<ServerMemoryPoolInfo> memory_pool_info;
     VoiceContext voice_context;
     EffectContext effect_context;

src/audio_core/command_generator.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cmath>
-#include <numbers>
 #include "audio_core/algorithm/interpolate.h"
 #include "audio_core/command_generator.h"
 #include "audio_core/effect_context.h"
@@ -15,20 +13,6 @@ namespace AudioCore {
 namespace {
 constexpr std::size_t MIX_BUFFER_SIZE = 0x3f00;
 constexpr std::size_t SCALED_MIX_BUFFER_SIZE = MIX_BUFFER_SIZE << 15ULL;
-using DelayLineTimes = std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT>;
-
-constexpr DelayLineTimes FDN_MIN_DELAY_LINE_TIMES{5.0f, 6.0f, 13.0f, 14.0f};
-constexpr DelayLineTimes FDN_MAX_DELAY_LINE_TIMES{45.704f, 82.782f, 149.94f, 271.58f};
-constexpr DelayLineTimes DECAY0_MAX_DELAY_LINE_TIMES{17.0f, 13.0f, 9.0f, 7.0f};
-constexpr DelayLineTimes DECAY1_MAX_DELAY_LINE_TIMES{19.0f, 11.0f, 10.0f, 6.0f};
-constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_TAP_TIMES{
-    0.017136f, 0.059154f, 0.161733f, 0.390186f, 0.425262f, 0.455411f, 0.689737f,
-    0.745910f, 0.833844f, 0.859502f, 0.000000f, 0.075024f, 0.168788f, 0.299901f,
-    0.337443f, 0.371903f, 0.599011f, 0.716741f, 0.817859f, 0.851664f};
-constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_GAIN{
-    0.67096f, 0.61027f, 1.0f,     0.35680f, 0.68361f, 0.65978f, 0.51939f,
-    0.24712f, 0.45945f, 0.45021f, 0.64196f, 0.54879f, 0.92925f, 0.38270f,
-    0.72867f, 0.69794f, 0.5464f,  0.24563f, 0.45214f, 0.44042f};
 
 template <std::size_t N>
 void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
@@ -81,154 +65,6 @@ s32 ApplyMixDepop(s32* output, s32 first_sample, s32 delta, s32 sample_count) {
     }
 }
 
-float Pow10(float x) {
-    if (x >= 0.0f) {
-        return 1.0f;
-    } else if (x <= -5.3f) {
-        return 0.0f;
-    }
-    return std::pow(10.0f, x);
-}
-
-float SinD(float degrees) {
-    return std::sin(degrees * std::numbers::pi_v<float> / 180.0f);
-}
-
-float CosD(float degrees) {
-    return std::cos(degrees * std::numbers::pi_v<float> / 180.0f);
-}
-
-float ToFloat(s32 sample) {
-    return static_cast<float>(sample) / 65536.f;
-}
-
-s32 ToS32(float sample) {
-    constexpr auto min = -8388608.0f;
-    constexpr auto max = 8388607.f;
-    float rescaled_sample = sample * 65536.0f;
-    if (rescaled_sample < min) {
-        rescaled_sample = min;
-    }
-    if (rescaled_sample > max) {
-        rescaled_sample = max;
-    }
-    return static_cast<s32>(rescaled_sample);
-}
-
-constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_1CH{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-
-constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_2CH{0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
-                                                           1, 1, 1, 0, 0, 0, 0, 1, 1, 1};
-
-constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_4CH{0, 0, 0, 1, 1, 1, 1, 2, 2, 2,
-                                                           1, 1, 1, 0, 0, 0, 0, 3, 3, 3};
-
-constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_6CH{4, 0, 0, 1, 1, 1, 1, 2, 2, 2,
-                                                           1, 1, 1, 0, 0, 0, 0, 3, 3, 3};
-
-template <std::size_t CHANNEL_COUNT>
-void ApplyReverbGeneric(I3dl2ReverbState& state,
-                        const std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT>& input,
-                        const std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT>& output,
-                        s32 sample_count) {
-
-    auto GetTapLookup = []() {
-        if constexpr (CHANNEL_COUNT == 1) {
-            return REVERB_TAP_INDEX_1CH;
-        } else if constexpr (CHANNEL_COUNT == 2) {
-            return REVERB_TAP_INDEX_2CH;
-        } else if constexpr (CHANNEL_COUNT == 4) {
-            return REVERB_TAP_INDEX_4CH;
-        } else if constexpr (CHANNEL_COUNT == 6) {
-            return REVERB_TAP_INDEX_6CH;
-        }
-    };
-
-    const auto& tap_index_lut = GetTapLookup();
-    for (s32 sample = 0; sample < sample_count; sample++) {
-        std::array<f32, CHANNEL_COUNT> out_samples{};
-        std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> fsamp{};
-        std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> mixed{};
-        std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> osamp{};
-
-        // Mix everything into a single sample
-        s32 temp_mixed_sample = 0;
-        for (std::size_t i = 0; i < CHANNEL_COUNT; i++) {
-            temp_mixed_sample += input[i][sample];
-        }
-        const auto current_sample = ToFloat(temp_mixed_sample);
-        const auto early_tap = state.early_delay_line.TapOut(state.early_to_late_taps);
-
-        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_TAPS; i++) {
-            const auto tapped_samp =
-                state.early_delay_line.TapOut(state.early_tap_steps[i]) * EARLY_GAIN[i];
-            out_samples[tap_index_lut[i]] += tapped_samp;
-
-            if constexpr (CHANNEL_COUNT == 6) {
-                // handle lfe
-                out_samples[5] += tapped_samp;
-            }
-        }
-
-        state.lowpass_0 = current_sample * state.lowpass_2 + state.lowpass_0 * state.lowpass_1;
-        state.early_delay_line.Tick(state.lowpass_0);
-
-        for (std::size_t i = 0; i < CHANNEL_COUNT; i++) {
-            out_samples[i] *= state.early_gain;
-        }
-
-        // Two channel seems to apply a latet gain, we require to save this
-        f32 filter{};
-        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
-            filter = state.fdn_delay_line[i].GetOutputSample();
-            const auto computed = filter * state.lpf_coefficients[0][i] + state.shelf_filter[i];
-            state.shelf_filter[i] =
-                filter * state.lpf_coefficients[1][i] + computed * state.lpf_coefficients[2][i];
-            fsamp[i] = computed;
-        }
-
-        // Mixing matrix
-        mixed[0] = fsamp[1] + fsamp[2];
-        mixed[1] = -fsamp[0] - fsamp[3];
-        mixed[2] = fsamp[0] - fsamp[3];
-        mixed[3] = fsamp[1] - fsamp[2];
-
-        if constexpr (CHANNEL_COUNT == 2) {
-            for (auto& mix : mixed) {
-                mix *= (filter * state.late_gain);
-            }
-        }
-
-        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
-            const auto late = early_tap * state.late_gain;
-            osamp[i] = state.decay_delay_line0[i].Tick(late + mixed[i]);
-            osamp[i] = state.decay_delay_line1[i].Tick(osamp[i]);
-            state.fdn_delay_line[i].Tick(osamp[i]);
-        }
-
-        if constexpr (CHANNEL_COUNT == 1) {
-            output[0][sample] = ToS32(state.dry_gain * ToFloat(input[0][sample]) +
-                                      (out_samples[0] + osamp[0] + osamp[1]));
-        } else if constexpr (CHANNEL_COUNT == 2 || CHANNEL_COUNT == 4) {
-            for (std::size_t i = 0; i < CHANNEL_COUNT; i++) {
-                output[i][sample] =
-                    ToS32(state.dry_gain * ToFloat(input[i][sample]) + (out_samples[i] + osamp[i]));
-            }
-        } else if constexpr (CHANNEL_COUNT == 6) {
-            const auto temp_center = state.center_delay_line.Tick(0.5f * (osamp[2] - osamp[3]));
-            for (std::size_t i = 0; i < 4; i++) {
-                output[i][sample] =
-                    ToS32(state.dry_gain * ToFloat(input[i][sample]) + (out_samples[i] + osamp[i]));
-            }
-            output[4][sample] =
-                ToS32(state.dry_gain * ToFloat(input[4][sample]) + (out_samples[4] + temp_center));
-            output[5][sample] =
-                ToS32(state.dry_gain * ToFloat(input[5][sample]) + (out_samples[5] + osamp[3]));
-        }
-    }
-}
-
 } // namespace
 
 CommandGenerator::CommandGenerator(AudioCommon::AudioRendererParameter& worker_params_,
@@ -435,10 +271,11 @@ void CommandGenerator::GenerateBiquadFilterCommandForVoice(ServerVoiceInfo& voic
         }
 
         // Generate biquad filter
-        // GenerateBiquadFilterCommand(mix_buffer_count, biquad_filter,
-        // dsp_state.biquad_filter_state,
-        //                            mix_buffer_count + channel, mix_buffer_count + channel,
-        //                            worker_params.sample_count, voice_info.GetInParams().node_id);
+        //        GenerateBiquadFilterCommand(mix_buffer_count, biquad_filter,
+        //        dsp_state.biquad_filter_state,
+        //                                    mix_buffer_count + channel, mix_buffer_count +
+        //                                    channel, worker_params.sample_count,
+        //                                    voice_info.GetInParams().node_id);
     }
 }
 
@@ -539,53 +376,17 @@ void CommandGenerator::GenerateEffectCommand(ServerMixInfo& mix_info) {
 
 void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, EffectBase* info,
                                                         bool enabled) {
-    auto* reverb = dynamic_cast<EffectI3dl2Reverb*>(info);
-    const auto& params = reverb->GetParams();
-    auto& state = reverb->GetState();
-    const auto channel_count = params.channel_count;
-
-    if (channel_count != 1 && channel_count != 2 && channel_count != 4 && channel_count != 6) {
+    if (!enabled) {
         return;
     }
-
-    std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT> input{};
-    std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT> output{};
-
-    const auto status = params.status;
+    const auto& params = dynamic_cast<EffectI3dl2Reverb*>(info)->GetParams();
+    const auto channel_count = params.channel_count;
     for (s32 i = 0; i < channel_count; i++) {
-        input[i] = GetMixBuffer(mix_buffer_offset + params.input[i]);
-        output[i] = GetMixBuffer(mix_buffer_offset + params.output[i]);
-    }
-
-    if (enabled) {
-        if (status == ParameterStatus::Initialized) {
-            InitializeI3dl2Reverb(reverb->GetParams(), state, info->GetWorkBuffer());
-        } else if (status == ParameterStatus::Updating) {
-            UpdateI3dl2Reverb(reverb->GetParams(), state, false);
-        }
-    }
-
-    if (enabled) {
-        switch (channel_count) {
-        case 1:
-            ApplyReverbGeneric<1>(state, input, output, worker_params.sample_count);
-            break;
-        case 2:
-            ApplyReverbGeneric<2>(state, input, output, worker_params.sample_count);
-            break;
-        case 4:
-            ApplyReverbGeneric<4>(state, input, output, worker_params.sample_count);
-            break;
-        case 6:
-            ApplyReverbGeneric<6>(state, input, output, worker_params.sample_count);
-            break;
-        }
-    } else {
-        for (s32 i = 0; i < channel_count; i++) {
-            // Only copy if the buffer input and output do not match!
-            if ((mix_buffer_offset + params.input[i]) != (mix_buffer_offset + params.output[i])) {
-                std::memcpy(output[i], input[i], worker_params.sample_count * sizeof(s32));
-            }
+        // TODO(ogniK): Actually implement reverb
+        if (params.input[i] != params.output[i]) {
+            const auto* input = GetMixBuffer(mix_buffer_offset + params.input[i]);
+            auto* output = GetMixBuffer(mix_buffer_offset + params.output[i]);
+            ApplyMix<1>(output, input, 32768, worker_params.sample_count);
         }
     }
 }
@@ -724,133 +525,6 @@ s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u3
     return sample_count;
 }
 
-void CommandGenerator::InitializeI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
-                                             std::vector<u8>& work_buffer) {
-    // Reset state
-    state.lowpass_0 = 0.0f;
-    state.lowpass_1 = 0.0f;
-    state.lowpass_2 = 0.0f;
-
-    state.early_delay_line.Reset();
-    state.early_tap_steps.fill(0);
-    state.early_gain = 0.0f;
-    state.late_gain = 0.0f;
-    state.early_to_late_taps = 0;
-    for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
-        state.fdn_delay_line[i].Reset();
-        state.decay_delay_line0[i].Reset();
-        state.decay_delay_line1[i].Reset();
-    }
-    state.last_reverb_echo = 0.0f;
-    state.center_delay_line.Reset();
-    for (auto& coef : state.lpf_coefficients) {
-        coef.fill(0.0f);
-    }
-    state.shelf_filter.fill(0.0f);
-    state.dry_gain = 0.0f;
-
-    const auto sample_rate = info.sample_rate / 1000;
-    f32* work_buffer_ptr = reinterpret_cast<f32*>(work_buffer.data());
-
-    s32 delay_samples{};
-    for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
-        delay_samples =
-            AudioCommon::CalculateDelaySamples(sample_rate, FDN_MAX_DELAY_LINE_TIMES[i]);
-        state.fdn_delay_line[i].Initialize(delay_samples, work_buffer_ptr);
-        work_buffer_ptr += delay_samples + 1;
-
-        delay_samples =
-            AudioCommon::CalculateDelaySamples(sample_rate, DECAY0_MAX_DELAY_LINE_TIMES[i]);
-        state.decay_delay_line0[i].Initialize(delay_samples, 0.0f, work_buffer_ptr);
-        work_buffer_ptr += delay_samples + 1;
-
-        delay_samples =
-            AudioCommon::CalculateDelaySamples(sample_rate, DECAY1_MAX_DELAY_LINE_TIMES[i]);
-        state.decay_delay_line1[i].Initialize(delay_samples, 0.0f, work_buffer_ptr);
-        work_buffer_ptr += delay_samples + 1;
-    }
-    delay_samples = AudioCommon::CalculateDelaySamples(sample_rate, 5.0f);
-    state.center_delay_line.Initialize(delay_samples, work_buffer_ptr);
-    work_buffer_ptr += delay_samples + 1;
-
-    delay_samples = AudioCommon::CalculateDelaySamples(sample_rate, 400.0f);
-    state.early_delay_line.Initialize(delay_samples, work_buffer_ptr);
-
-    UpdateI3dl2Reverb(info, state, true);
-}
-
-void CommandGenerator::UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
-                                         bool should_clear) {
-
-    state.dry_gain = info.dry_gain;
-    state.shelf_filter.fill(0.0f);
-    state.lowpass_0 = 0.0f;
-    state.early_gain = Pow10(std::min(info.room + info.reflection, 5000.0f) / 2000.0f);
-    state.late_gain = Pow10(std::min(info.room + info.reverb, 5000.0f) / 2000.0f);
-
-    const auto sample_rate = info.sample_rate / 1000;
-    const f32 hf_gain = Pow10(info.room_hf / 2000.0f);
-    if (hf_gain >= 1.0f) {
-        state.lowpass_2 = 1.0f;
-        state.lowpass_1 = 0.0f;
-    } else {
-        const auto a = 1.0f - hf_gain;
-        const auto b = 2.0f * (1.0f - hf_gain * CosD(256.0f * info.hf_reference /
-                                                     static_cast<f32>(info.sample_rate)));
-        const auto c = std::sqrt(b * b - 4.0f * a * a);
-
-        state.lowpass_1 = (b - c) / (2.0f * a);
-        state.lowpass_2 = 1.0f - state.lowpass_1;
-    }
-    state.early_to_late_taps = AudioCommon::CalculateDelaySamples(
-        sample_rate, 1000.0f * (info.reflection_delay + info.reverb_delay));
-
-    state.last_reverb_echo = 0.6f * info.diffusion * 0.01f;
-    for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
-        const auto length =
-            FDN_MIN_DELAY_LINE_TIMES[i] +
-            (info.density / 100.0f) * (FDN_MAX_DELAY_LINE_TIMES[i] - FDN_MIN_DELAY_LINE_TIMES[i]);
-        state.fdn_delay_line[i].SetDelay(AudioCommon::CalculateDelaySamples(sample_rate, length));
-
-        const auto delay_sample_counts = state.fdn_delay_line[i].GetDelay() +
-                                         state.decay_delay_line0[i].GetDelay() +
-                                         state.decay_delay_line1[i].GetDelay();
-
-        float a = (-60.0f * static_cast<f32>(delay_sample_counts)) /
-                  (info.decay_time * static_cast<f32>(info.sample_rate));
-        float b = a / info.hf_decay_ratio;
-        float c = CosD(128.0f * 0.5f * info.hf_reference / static_cast<f32>(info.sample_rate)) /
-                  SinD(128.0f * 0.5f * info.hf_reference / static_cast<f32>(info.sample_rate));
-        float d = Pow10((b - a) / 40.0f);
-        float e = Pow10((b + a) / 40.0f) * 0.7071f;
-
-        state.lpf_coefficients[0][i] = e * ((d * c) + 1.0f) / (c + d);
-        state.lpf_coefficients[1][i] = e * (1.0f - (d * c)) / (c + d);
-        state.lpf_coefficients[2][i] = (c - d) / (c + d);
-
-        state.decay_delay_line0[i].SetCoefficient(state.last_reverb_echo);
-        state.decay_delay_line1[i].SetCoefficient(-0.9f * state.last_reverb_echo);
-    }
-
-    if (should_clear) {
-        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
-            state.fdn_delay_line[i].Clear();
-            state.decay_delay_line0[i].Clear();
-            state.decay_delay_line1[i].Clear();
-        }
-        state.early_delay_line.Clear();
-        state.center_delay_line.Clear();
-    }
-
-    const auto max_early_delay = state.early_delay_line.GetMaxDelay();
-    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]);
-        state.early_tap_steps[tap] = std::min(length, max_early_delay);
-    }
-}
-
 void CommandGenerator::GenerateVolumeRampCommand(float last_volume, float current_volume,
                                                  s32 channel, s32 node_id) {
     const auto last = static_cast<s32>(last_volume * 32768.0f);

src/audio_core/command_generator.h

@@ -21,8 +21,6 @@ class ServerMixInfo;
 class EffectContext;
 class EffectBase;
 struct AuxInfoDSP;
-struct I3dl2ReverbParams;
-struct I3dl2ReverbState;
 using MixVolumeBuffer = std::array<float, AudioCommon::MAX_MIX_BUFFERS>;
 
 class CommandGenerator {
@@ -82,9 +80,6 @@ private:
     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
     s32 DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
                     s32 channel, std::size_t mix_offset);

src/audio_core/common.h

@@ -33,29 +33,6 @@ constexpr std::size_t TEMP_MIX_BASE_SIZE = 0x3f00; // TODO(ogniK): Work out this
 // and our const ends up being 0x3f04, the 4 bytes are most
 // likely the sample history
 constexpr std::size_t TOTAL_TEMP_MIX_SIZE = TEMP_MIX_BASE_SIZE + AudioCommon::MAX_SAMPLE_HISTORY;
-constexpr f32 I3DL2REVERB_MAX_LEVEL = 5000.0f;
-constexpr f32 I3DL2REVERB_MIN_REFLECTION_DURATION = 0.02f;
-constexpr std::size_t I3DL2REVERB_TAPS = 20;
-constexpr std::size_t I3DL2REVERB_DELAY_LINE_COUNT = 4;
-using Fractional = s32;
-
-template <typename T>
-constexpr Fractional ToFractional(T x) {
-    return static_cast<Fractional>(x * static_cast<T>(0x4000));
-}
-
-constexpr Fractional MultiplyFractional(Fractional lhs, Fractional rhs) {
-    return static_cast<Fractional>(static_cast<s64>(lhs) * rhs >> 14);
-}
-
-constexpr s32 FractionalToFixed(Fractional x) {
-    const auto s = x & (1 << 13);
-    return static_cast<s32>(x >> 14) + s;
-}
-
-constexpr s32 CalculateDelaySamples(s32 sample_rate_khz, float time) {
-    return FractionalToFixed(MultiplyFractional(ToFractional(sample_rate_khz), ToFractional(time)));
-}
 
 static constexpr u32 VersionFromRevision(u32_le rev) {
     // "REV7" -> 7

src/audio_core/delay_line.cpp

@@ -1,104 +0,0 @@
-#include <cstring>
-#include "audio_core/delay_line.h"
-
-namespace AudioCore {
-DelayLineBase::DelayLineBase() = default;
-DelayLineBase::~DelayLineBase() = default;
-
-void DelayLineBase::Initialize(s32 max_delay_, float* src_buffer) {
-    buffer = src_buffer;
-    buffer_end = buffer + max_delay_;
-    max_delay = max_delay_;
-    output = buffer;
-    SetDelay(max_delay_);
-    Clear();
-}
-
-void DelayLineBase::SetDelay(s32 new_delay) {
-    if (max_delay < new_delay) {
-        return;
-    }
-    delay = new_delay;
-    input = (buffer + ((output - buffer) + new_delay) % (max_delay + 1));
-}
-
-s32 DelayLineBase::GetDelay() const {
-    return delay;
-}
-
-s32 DelayLineBase::GetMaxDelay() const {
-    return max_delay;
-}
-
-f32 DelayLineBase::TapOut(s32 last_sample) {
-    const float* ptr = input - (last_sample + 1);
-    if (ptr < buffer) {
-        ptr += (max_delay + 1);
-    }
-
-    return *ptr;
-}
-
-f32 DelayLineBase::Tick(f32 sample) {
-    *(input++) = sample;
-    const auto out_sample = *(output++);
-
-    if (buffer_end < input) {
-        input = buffer;
-    }
-
-    if (buffer_end < output) {
-        output = buffer;
-    }
-
-    return out_sample;
-}
-
-float* DelayLineBase::GetInput() {
-    return input;
-}
-
-const float* DelayLineBase::GetInput() const {
-    return input;
-}
-
-f32 DelayLineBase::GetOutputSample() const {
-    return *output;
-}
-
-void DelayLineBase::Clear() {
-    std::memset(buffer, 0, sizeof(float) * max_delay);
-}
-
-void DelayLineBase::Reset() {
-    buffer = nullptr;
-    buffer_end = nullptr;
-    max_delay = 0;
-    input = nullptr;
-    output = nullptr;
-    delay = 0;
-}
-
-DelayLineAllPass::DelayLineAllPass() = default;
-DelayLineAllPass::~DelayLineAllPass() = default;
-
-void DelayLineAllPass::Initialize(u32 delay_, float coeffcient_, f32* src_buffer) {
-    DelayLineBase::Initialize(delay_, src_buffer);
-    SetCoefficient(coeffcient_);
-}
-
-void DelayLineAllPass::SetCoefficient(float coeffcient_) {
-    coefficient = coeffcient_;
-}
-
-f32 DelayLineAllPass::Tick(f32 sample) {
-    const auto temp = sample - coefficient * *output;
-    return coefficient * temp + DelayLineBase::Tick(temp);
-}
-
-void DelayLineAllPass::Reset() {
-    coefficient = 0.0f;
-    DelayLineBase::Reset();
-}
-
-} // namespace AudioCore

src/audio_core/delay_line.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-class DelayLineBase {
-public:
-    DelayLineBase();
-    ~DelayLineBase();
-
-    void Initialize(s32 max_delay_, float* src_buffer);
-    void SetDelay(s32 new_delay);
-    s32 GetDelay() const;
-    s32 GetMaxDelay() const;
-    f32 TapOut(s32 last_sample);
-    f32 Tick(f32 sample);
-    float* GetInput();
-    const float* GetInput() const;
-    f32 GetOutputSample() const;
-    void Clear();
-    void Reset();
-
-protected:
-    float* buffer{nullptr};
-    float* buffer_end{nullptr};
-    s32 max_delay{};
-    float* input{nullptr};
-    float* output{nullptr};
-    s32 delay{};
-};
-
-class DelayLineAllPass final : public DelayLineBase {
-public:
-    DelayLineAllPass();
-    ~DelayLineAllPass();
-
-    void Initialize(u32 delay, float coeffcient_, f32* src_buffer);
-    void SetCoefficient(float coeffcient_);
-    f32 Tick(f32 sample);
-    void Reset();
-
-private:
-    float coefficient{};
-};
-} // namespace AudioCore

src/audio_core/effect_context.cpp

@@ -90,14 +90,6 @@ s32 EffectBase::GetProcessingOrder() const {
     return processing_order;
 }
 
-std::vector<u8>& EffectBase::GetWorkBuffer() {
-    return work_buffer;
-}
-
-const std::vector<u8>& EffectBase::GetWorkBuffer() const {
-    return work_buffer;
-}
-
 EffectI3dl2Reverb::EffectI3dl2Reverb() : EffectGeneric(EffectType::I3dl2Reverb) {}
 EffectI3dl2Reverb::~EffectI3dl2Reverb() = default;
 
@@ -125,12 +117,6 @@ void EffectI3dl2Reverb::Update(EffectInfo::InParams& in_params) {
         usage = UsageState::Initialized;
         params.status = ParameterStatus::Initialized;
         skipped = in_params.buffer_address == 0 || in_params.buffer_size == 0;
-        if (!skipped) {
-            auto& cur_work_buffer = GetWorkBuffer();
-            // Has two buffers internally
-            cur_work_buffer.resize(in_params.buffer_size * 2);
-            std::fill(cur_work_buffer.begin(), cur_work_buffer.end(), 0);
-        }
     }
 }
 
@@ -143,14 +129,6 @@ void EffectI3dl2Reverb::UpdateForCommandGeneration() {
     GetParams().status = ParameterStatus::Updated;
 }
 
-I3dl2ReverbState& EffectI3dl2Reverb::GetState() {
-    return state;
-}
-
-const I3dl2ReverbState& EffectI3dl2Reverb::GetState() const {
-    return state;
-}
-
 EffectBiquadFilter::EffectBiquadFilter() : EffectGeneric(EffectType::BiquadFilter) {}
 EffectBiquadFilter::~EffectBiquadFilter() = default;
 

src/audio_core/effect_context.h

@@ -8,7 +8,6 @@
 #include <memory>
 #include <vector>
 #include "audio_core/common.h"
-#include "audio_core/delay_line.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -195,8 +194,6 @@ public:
     [[nodiscard]] bool IsEnabled() const;
     [[nodiscard]] s32 GetMixID() const;
     [[nodiscard]] s32 GetProcessingOrder() const;
-    [[nodiscard]] std::vector<u8>& GetWorkBuffer();
-    [[nodiscard]] const std::vector<u8>& GetWorkBuffer() const;
 
 protected:
     UsageState usage{UsageState::Invalid};
@@ -204,7 +201,6 @@ protected:
     s32 mix_id{};
     s32 processing_order{};
     bool enabled = false;
-    std::vector<u8> work_buffer{};
 };
 
 template <typename T>
@@ -216,7 +212,7 @@ public:
         return internal_params;
     }
 
-    const T& GetParams() const {
+    const I3dl2ReverbParams& GetParams() const {
         return internal_params;
     }
 
@@ -233,27 +229,6 @@ public:
     void UpdateForCommandGeneration() override;
 };
 
-struct I3dl2ReverbState {
-    f32 lowpass_0{};
-    f32 lowpass_1{};
-    f32 lowpass_2{};
-
-    DelayLineBase early_delay_line{};
-    std::array<u32, AudioCommon::I3DL2REVERB_TAPS> early_tap_steps{};
-    f32 early_gain{};
-    f32 late_gain{};
-
-    u32 early_to_late_taps{};
-    std::array<DelayLineBase, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> fdn_delay_line{};
-    std::array<DelayLineAllPass, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> decay_delay_line0{};
-    std::array<DelayLineAllPass, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> decay_delay_line1{};
-    f32 last_reverb_echo{};
-    DelayLineBase center_delay_line{};
-    std::array<std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT>, 3> lpf_coefficients{};
-    std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> shelf_filter{};
-    f32 dry_gain{};
-};
-
 class EffectI3dl2Reverb : public EffectGeneric<I3dl2ReverbParams> {
 public:
     explicit EffectI3dl2Reverb();
@@ -262,12 +237,8 @@ public:
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
 
-    I3dl2ReverbState& GetState();
-    const I3dl2ReverbState& GetState() const;
-
 private:
     bool skipped = false;
-    I3dl2ReverbState state{};
 };
 
 class EffectBiquadFilter : public EffectGeneric<BiquadFilterParams> {

src/audio_core/sink_context.h

@@ -40,17 +40,17 @@ public:
         SinkSampleFormat sample_format;
         std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> input;
         bool in_use;
-        INSERT_PADDING_BYTES_NOINIT(5);
+        INSERT_UNION_PADDING_BYTES(5);
     };
     static_assert(sizeof(CircularBufferIn) == 0x28,
                   "SinkInfo::CircularBufferIn is in invalid size");
 
     struct DeviceIn {
         std::array<u8, 255> device_name;
-        INSERT_PADDING_BYTES_NOINIT(1);
+        INSERT_UNION_PADDING_BYTES(1);
         s32_le input_count;
         std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> input;
-        INSERT_PADDING_BYTES_NOINIT(1);
+        INSERT_UNION_PADDING_BYTES(1);
         bool down_matrix_enabled;
         DownmixCoefficients down_matrix_coef;
     };

src/audio_core/stream.cpp

@@ -51,14 +51,6 @@ void Stream::Stop() {
     UNIMPLEMENTED();
 }
 
-bool Stream::Flush() {
-    const bool had_buffers = !queued_buffers.empty();
-    while (!queued_buffers.empty()) {
-        queued_buffers.pop();
-    }
-    return had_buffers;
-}
-
 void Stream::SetVolume(float volume) {
     game_volume = volume;
 }
@@ -111,14 +103,7 @@ void Stream::PlayNextBuffer(std::chrono::nanoseconds ns_late) {
 
     sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
 
-    const auto buffer_release_ns = GetBufferReleaseNS(*active_buffer);
-
-    // If ns_late is higher than the update rate ignore the delay
-    if (ns_late > buffer_release_ns) {
-        ns_late = {};
-    }
-
-    core_timing.ScheduleEvent(buffer_release_ns - ns_late, release_event, {});
+    core_timing.ScheduleEvent(GetBufferReleaseNS(*active_buffer) - ns_late, release_event, {});
 }
 
 void Stream::ReleaseActiveBuffer(std::chrono::nanoseconds ns_late) {
@@ -145,11 +130,7 @@ bool Stream::ContainsBuffer([[maybe_unused]] Buffer::Tag tag) const {
 std::vector<Buffer::Tag> Stream::GetTagsAndReleaseBuffers(std::size_t max_count) {
     std::vector<Buffer::Tag> tags;
     for (std::size_t count = 0; count < max_count && !released_buffers.empty(); ++count) {
-        if (released_buffers.front()) {
-            tags.push_back(released_buffers.front()->GetTag());
-        } else {
-            ASSERT_MSG(false, "Invalid tag in released_buffers!");
-        }
+        tags.push_back(released_buffers.front()->GetTag());
         released_buffers.pop();
     }
     return tags;
@@ -159,11 +140,7 @@ std::vector<Buffer::Tag> Stream::GetTagsAndReleaseBuffers() {
     std::vector<Buffer::Tag> tags;
     tags.reserve(released_buffers.size());
     while (!released_buffers.empty()) {
-        if (released_buffers.front()) {
-            tags.push_back(released_buffers.front()->GetTag());
-        } else {
-            ASSERT_MSG(false, "Invalid tag in released_buffers!");
-        }
+        tags.push_back(released_buffers.front()->GetTag());
         released_buffers.pop();
     }
     return tags;

src/audio_core/stream.h

@@ -56,9 +56,6 @@ public:
     /// Queues a buffer into the audio stream, returns true on success
     bool QueueBuffer(BufferPtr&& buffer);
 
-    /// Flush audio buffers
-    bool Flush();
-
     /// Returns true if the audio stream contains a buffer with the specified tag
     [[nodiscard]] bool ContainsBuffer(Buffer::Tag tag) const;
 

src/audio_core/voice_context.h

@@ -86,28 +86,28 @@ struct BehaviorFlags {
 static_assert(sizeof(BehaviorFlags) == 0x4, "BehaviorFlags is an invalid size");
 
 struct ADPCMContext {
-    u16 header;
-    s16 yn1;
-    s16 yn2;
+    u16 header{};
+    s16 yn1{};
+    s16 yn2{};
 };
 static_assert(sizeof(ADPCMContext) == 0x6, "ADPCMContext is an invalid size");
 
 struct VoiceState {
-    s64 played_sample_count;
-    s32 offset;
-    s32 wave_buffer_index;
-    std::array<bool, AudioCommon::MAX_WAVE_BUFFERS> is_wave_buffer_valid;
-    s32 wave_buffer_consumed;
-    std::array<s32, AudioCommon::MAX_SAMPLE_HISTORY> sample_history;
-    s32 fraction;
-    VAddr context_address;
-    Codec::ADPCM_Coeff coeff;
-    ADPCMContext context;
-    std::array<s64, 2> biquad_filter_state;
-    std::array<s32, AudioCommon::MAX_MIX_BUFFERS> previous_samples;
-    u32 external_context_size;
-    bool is_external_context_used;
-    bool voice_dropped;
+    s64 played_sample_count{};
+    s32 offset{};
+    s32 wave_buffer_index{};
+    std::array<bool, AudioCommon::MAX_WAVE_BUFFERS> is_wave_buffer_valid{};
+    s32 wave_buffer_consumed{};
+    std::array<s32, AudioCommon::MAX_SAMPLE_HISTORY> sample_history{};
+    s32 fraction{};
+    VAddr context_address{};
+    Codec::ADPCM_Coeff coeff{};
+    ADPCMContext context{};
+    std::array<s64, 2> biquad_filter_state{};
+    std::array<s32, AudioCommon::MAX_MIX_BUFFERS> previous_samples{};
+    u32 external_context_size{};
+    bool is_external_context_used{};
+    bool voice_dropped{};
 };
 
 class VoiceChannelResource {

src/common/CMakeLists.txt

@@ -98,15 +98,16 @@ add_library(common STATIC
     algorithm.h
     alignment.h
     assert.h
+    atomic_ops.cpp
     atomic_ops.h
     detached_tasks.cpp
     detached_tasks.h
     bit_cast.h
     bit_field.h
-    bit_set.h
     bit_util.h
     cityhash.cpp
     cityhash.h
+    color.h
     common_funcs.h
     common_paths.h
     common_types.h
@@ -121,7 +122,6 @@ add_library(common STATIC
     hash.h
     hex_util.cpp
     hex_util.h
-    intrusive_red_black_tree.h
     logging/backend.cpp
     logging/backend.h
     logging/filter.cpp
@@ -134,17 +134,17 @@ add_library(common STATIC
     math_util.h
     memory_detect.cpp
     memory_detect.h
+    memory_hook.cpp
+    memory_hook.h
     microprofile.cpp
     microprofile.h
     microprofileui.h
     misc.cpp
-    nvidia_flags.cpp
-    nvidia_flags.h
+    multi_level_queue.h
     page_table.cpp
     page_table.h
     param_package.cpp
     param_package.h
-    parent_of_member.h
     quaternion.h
     ring_buffer.h
     scm_rev.cpp
@@ -162,13 +162,12 @@ add_library(common STATIC
     thread.cpp
     thread.h
     thread_queue_list.h
-    thread_worker.cpp
-    thread_worker.h
     threadsafe_queue.h
     time_zone.cpp
     time_zone.h
-    tiny_mt.h
-    tree.h
+    timer.cpp
+    timer.h
+    uint128.cpp
     uint128.h
     uuid.cpp
     uuid.h
@@ -206,12 +205,11 @@ if (MSVC)
 else()
   target_compile_options(common PRIVATE
     -Werror
-
-    $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
   )
 endif()
 
 create_target_directory_groups(common)
+find_package(Boost 1.71 COMPONENTS context headers REQUIRED)
 
 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile)
 target_link_libraries(common PRIVATE lz4::lz4 xbyak)

src/common/alignment.h

@@ -9,50 +9,50 @@
 namespace Common {
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
+[[nodiscard]] constexpr T AlignUp(T value, std::size_t size) {
+    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     auto mod{static_cast<T>(value % size)};
     value -= mod;
     return static_cast<T>(mod == T{0} ? value : value + size);
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
-    return static_cast<T>((value + ((1ULL << align_log2) - 1)) >> align_log2 << align_log2);
-}
-
-template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
+[[nodiscard]] constexpr T AlignDown(T value, std::size_t size) {
+    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     return static_cast<T>(value - value % size);
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool Is4KBAligned(T value) {
+[[nodiscard]] constexpr T AlignBits(T value, std::size_t align) {
+    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+    return static_cast<T>((value + ((1ULL << align) - 1)) >> align << align);
+}
+
+template <typename T>
+[[nodiscard]] constexpr bool Is4KBAligned(T value) {
+    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     return (value & 0xFFF) == 0;
 }
 
 template <typename T>
-requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool IsWordAligned(T value) {
+[[nodiscard]] constexpr bool IsWordAligned(T value) {
+    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     return (value & 0b11) == 0;
 }
 
 template <typename T>
-requires std::is_integral_v<T>[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
-    using U = typename std::make_unsigned_t<T>;
+[[nodiscard]] constexpr bool IsAligned(T value, std::size_t alignment) {
+    using U = typename std::make_unsigned<T>::type;
     const U mask = static_cast<U>(alignment - 1);
     return (value & mask) == 0;
 }
 
-template <typename T, typename U>
-requires std::is_integral_v<T>[[nodiscard]] constexpr T DivideUp(T x, U y) {
-    return (x + (y - 1)) / y;
-}
-
-template <typename T, size_t Align = 16>
+template <typename T, std::size_t Align = 16>
 class AlignmentAllocator {
 public:
     using value_type = T;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
 
     using propagate_on_container_copy_assignment = std::true_type;
     using propagate_on_container_move_assignment = std::true_type;

src/common/atomic_ops.cpp

@@ -0,0 +1,75 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+
+#include "common/atomic_ops.h"
+
+#if _MSC_VER
+#include <intrin.h>
+#endif
+
+namespace Common {
+
+#if _MSC_VER
+
+bool AtomicCompareAndSwap(volatile u8* pointer, u8 value, u8 expected) {
+    const u8 result =
+        _InterlockedCompareExchange8(reinterpret_cast<volatile char*>(pointer), value, expected);
+    return result == expected;
+}
+
+bool AtomicCompareAndSwap(volatile u16* pointer, u16 value, u16 expected) {
+    const u16 result =
+        _InterlockedCompareExchange16(reinterpret_cast<volatile short*>(pointer), value, expected);
+    return result == expected;
+}
+
+bool AtomicCompareAndSwap(volatile u32* pointer, u32 value, u32 expected) {
+    const u32 result =
+        _InterlockedCompareExchange(reinterpret_cast<volatile long*>(pointer), value, expected);
+    return result == expected;
+}
+
+bool AtomicCompareAndSwap(volatile u64* pointer, u64 value, u64 expected) {
+    const u64 result = _InterlockedCompareExchange64(reinterpret_cast<volatile __int64*>(pointer),
+                                                     value, expected);
+    return result == expected;
+}
+
+bool AtomicCompareAndSwap(volatile u64* pointer, u128 value, u128 expected) {
+    return _InterlockedCompareExchange128(reinterpret_cast<volatile __int64*>(pointer), value[1],
+                                          value[0],
+                                          reinterpret_cast<__int64*>(expected.data())) != 0;
+}
+
+#else
+
+bool AtomicCompareAndSwap(volatile u8* pointer, u8 value, u8 expected) {
+    return __sync_bool_compare_and_swap(pointer, expected, value);
+}
+
+bool AtomicCompareAndSwap(volatile u16* pointer, u16 value, u16 expected) {
+    return __sync_bool_compare_and_swap(pointer, expected, value);
+}
+
+bool AtomicCompareAndSwap(volatile u32* pointer, u32 value, u32 expected) {
+    return __sync_bool_compare_and_swap(pointer, expected, value);
+}
+
+bool AtomicCompareAndSwap(volatile u64* pointer, u64 value, u64 expected) {
+    return __sync_bool_compare_and_swap(pointer, expected, value);
+}
+
+bool AtomicCompareAndSwap(volatile u64* pointer, u128 value, u128 expected) {
+    unsigned __int128 value_a;
+    unsigned __int128 expected_a;
+    std::memcpy(&value_a, value.data(), sizeof(u128));
+    std::memcpy(&expected_a, expected.data(), sizeof(u128));
+    return __sync_bool_compare_and_swap((unsigned __int128*)pointer, expected_a, value_a);
+}
+
+#endif
+
+} // namespace Common

src/common/atomic_ops.h

@@ -4,75 +4,14 @@
 
 #pragma once
 
-#include <cstring>
-#include <memory>
-
 #include "common/common_types.h"
 
-#if _MSC_VER
-#include <intrin.h>
-#endif
-
 namespace Common {
 
-#if _MSC_VER
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u8* pointer, u8 value, u8 expected) {
-    const u8 result =
-        _InterlockedCompareExchange8(reinterpret_cast<volatile char*>(pointer), value, expected);
-    return result == expected;
-}
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u16* pointer, u16 value, u16 expected) {
-    const u16 result =
-        _InterlockedCompareExchange16(reinterpret_cast<volatile short*>(pointer), value, expected);
-    return result == expected;
-}
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u32* pointer, u32 value, u32 expected) {
-    const u32 result =
-        _InterlockedCompareExchange(reinterpret_cast<volatile long*>(pointer), value, expected);
-    return result == expected;
-}
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u64* pointer, u64 value, u64 expected) {
-    const u64 result = _InterlockedCompareExchange64(reinterpret_cast<volatile __int64*>(pointer),
-                                                     value, expected);
-    return result == expected;
-}
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u64* pointer, u128 value, u128 expected) {
-    return _InterlockedCompareExchange128(reinterpret_cast<volatile __int64*>(pointer), value[1],
-                                          value[0],
-                                          reinterpret_cast<__int64*>(expected.data())) != 0;
-}
-
-#else
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u8* pointer, u8 value, u8 expected) {
-    return __sync_bool_compare_and_swap(pointer, expected, value);
-}
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u16* pointer, u16 value, u16 expected) {
-    return __sync_bool_compare_and_swap(pointer, expected, value);
-}
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u32* pointer, u32 value, u32 expected) {
-    return __sync_bool_compare_and_swap(pointer, expected, value);
-}
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u64* pointer, u64 value, u64 expected) {
-    return __sync_bool_compare_and_swap(pointer, expected, value);
-}
-
-[[nodiscard]] inline bool AtomicCompareAndSwap(volatile u64* pointer, u128 value, u128 expected) {
-    unsigned __int128 value_a;
-    unsigned __int128 expected_a;
-    std::memcpy(&value_a, value.data(), sizeof(u128));
-    std::memcpy(&expected_a, expected.data(), sizeof(u128));
-    return __sync_bool_compare_and_swap((unsigned __int128*)pointer, expected_a, value_a);
-}
-
-#endif
+[[nodiscard]] bool AtomicCompareAndSwap(volatile u8* pointer, u8 value, u8 expected);
+[[nodiscard]] bool AtomicCompareAndSwap(volatile u16* pointer, u16 value, u16 expected);
+[[nodiscard]] bool AtomicCompareAndSwap(volatile u32* pointer, u32 value, u32 expected);
+[[nodiscard]] bool AtomicCompareAndSwap(volatile u64* pointer, u64 value, u64 expected);
+[[nodiscard]] bool AtomicCompareAndSwap(volatile u64* pointer, u128 value, u128 expected);
 
 } // namespace Common

src/common/bit_set.h

@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <array>
-#include <bit>
-
-#include "common/alignment.h"
-#include "common/bit_util.h"
-#include "common/common_types.h"
-
-namespace Common {
-
-namespace impl {
-
-template <typename Storage, size_t N>
-class BitSet {
-
-public:
-    constexpr BitSet() = default;
-
-    constexpr void SetBit(size_t i) {
-        this->words[i / FlagsPerWord] |= GetBitMask(i % FlagsPerWord);
-    }
-
-    constexpr void ClearBit(size_t i) {
-        this->words[i / FlagsPerWord] &= ~GetBitMask(i % FlagsPerWord);
-    }
-
-    constexpr size_t CountLeadingZero() const {
-        for (size_t i = 0; i < NumWords; i++) {
-            if (this->words[i]) {
-                return FlagsPerWord * i + CountLeadingZeroImpl(this->words[i]);
-            }
-        }
-        return FlagsPerWord * NumWords;
-    }
-
-    constexpr size_t GetNextSet(size_t n) const {
-        for (size_t i = (n + 1) / FlagsPerWord; i < NumWords; i++) {
-            Storage word = this->words[i];
-            if (!IsAligned(n + 1, FlagsPerWord)) {
-                word &= GetBitMask(n % FlagsPerWord) - 1;
-            }
-            if (word) {
-                return FlagsPerWord * i + CountLeadingZeroImpl(word);
-            }
-        }
-        return FlagsPerWord * NumWords;
-    }
-
-private:
-    static_assert(std::is_unsigned_v<Storage>);
-    static_assert(sizeof(Storage) <= sizeof(u64));
-
-    static constexpr size_t FlagsPerWord = BitSize<Storage>();
-    static constexpr size_t NumWords = AlignUp(N, FlagsPerWord) / FlagsPerWord;
-
-    static constexpr auto CountLeadingZeroImpl(Storage word) {
-        return std::countl_zero(static_cast<unsigned long long>(word)) -
-               (BitSize<unsigned long long>() - FlagsPerWord);
-    }
-
-    static constexpr Storage GetBitMask(size_t bit) {
-        return Storage(1) << (FlagsPerWord - 1 - bit);
-    }
-
-    std::array<Storage, NumWords> words{};
-};
-
-} // namespace impl
-
-template <size_t N>
-using BitSet8 = impl::BitSet<u8, N>;
-
-template <size_t N>
-using BitSet16 = impl::BitSet<u16, N>;
-
-template <size_t N>
-using BitSet32 = impl::BitSet<u32, N>;
-
-template <size_t N>
-using BitSet64 = impl::BitSet<u64, N>;
-
-} // namespace Common

src/common/bit_util.h

@@ -4,10 +4,13 @@
 
 #pragma once
 
-#include <bit>
 #include <climits>
 #include <cstddef>
 
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
 #include "common/common_types.h"
 
 namespace Common {
@@ -18,30 +21,124 @@ template <typename T>
     return sizeof(T) * CHAR_BIT;
 }
 
-[[nodiscard]] constexpr u32 MostSignificantBit32(const u32 value) {
-    return 31U - static_cast<u32>(std::countl_zero(value));
+#ifdef _MSC_VER
+[[nodiscard]] inline u32 CountLeadingZeroes32(u32 value) {
+    unsigned long leading_zero = 0;
+
+    if (_BitScanReverse(&leading_zero, value) != 0) {
+        return 31 - leading_zero;
+    }
+
+    return 32;
 }
 
-[[nodiscard]] constexpr u32 MostSignificantBit64(const u64 value) {
-    return 63U - static_cast<u32>(std::countl_zero(value));
+[[nodiscard]] inline u32 CountLeadingZeroes64(u64 value) {
+    unsigned long leading_zero = 0;
+
+    if (_BitScanReverse64(&leading_zero, value) != 0) {
+        return 63 - leading_zero;
+    }
+
+    return 64;
+}
+#else
+[[nodiscard]] inline u32 CountLeadingZeroes32(u32 value) {
+    if (value == 0) {
+        return 32;
+    }
+
+    return static_cast<u32>(__builtin_clz(value));
 }
 
-[[nodiscard]] constexpr u32 Log2Floor32(const u32 value) {
+[[nodiscard]] inline u32 CountLeadingZeroes64(u64 value) {
+    if (value == 0) {
+        return 64;
+    }
+
+    return static_cast<u32>(__builtin_clzll(value));
+}
+#endif
+
+#ifdef _MSC_VER
+[[nodiscard]] inline u32 CountTrailingZeroes32(u32 value) {
+    unsigned long trailing_zero = 0;
+
+    if (_BitScanForward(&trailing_zero, value) != 0) {
+        return trailing_zero;
+    }
+
+    return 32;
+}
+
+[[nodiscard]] inline u32 CountTrailingZeroes64(u64 value) {
+    unsigned long trailing_zero = 0;
+
+    if (_BitScanForward64(&trailing_zero, value) != 0) {
+        return trailing_zero;
+    }
+
+    return 64;
+}
+#else
+[[nodiscard]] inline u32 CountTrailingZeroes32(u32 value) {
+    if (value == 0) {
+        return 32;
+    }
+
+    return static_cast<u32>(__builtin_ctz(value));
+}
+
+[[nodiscard]] inline u32 CountTrailingZeroes64(u64 value) {
+    if (value == 0) {
+        return 64;
+    }
+
+    return static_cast<u32>(__builtin_ctzll(value));
+}
+#endif
+
+#ifdef _MSC_VER
+
+[[nodiscard]] inline u32 MostSignificantBit32(const u32 value) {
+    unsigned long result;
+    _BitScanReverse(&result, value);
+    return static_cast<u32>(result);
+}
+
+[[nodiscard]] inline u32 MostSignificantBit64(const u64 value) {
+    unsigned long result;
+    _BitScanReverse64(&result, value);
+    return static_cast<u32>(result);
+}
+
+#else
+
+[[nodiscard]] inline u32 MostSignificantBit32(const u32 value) {
+    return 31U - static_cast<u32>(__builtin_clz(value));
+}
+
+[[nodiscard]] inline u32 MostSignificantBit64(const u64 value) {
+    return 63U - static_cast<u32>(__builtin_clzll(value));
+}
+
+#endif
+
+[[nodiscard]] inline u32 Log2Floor32(const u32 value) {
     return MostSignificantBit32(value);
 }
 
-[[nodiscard]] constexpr u32 Log2Floor64(const u64 value) {
+[[nodiscard]] inline u32 Log2Ceil32(const u32 value) {
+    const u32 log2_f = Log2Floor32(value);
+    return log2_f + ((value ^ (1U << log2_f)) != 0U);
+}
+
+[[nodiscard]] inline u32 Log2Floor64(const u64 value) {
     return MostSignificantBit64(value);
 }
 
-[[nodiscard]] constexpr u32 Log2Ceil32(const u32 value) {
-    const u32 log2_f = Log2Floor32(value);
-    return log2_f + static_cast<u32>((value ^ (1U << log2_f)) != 0U);
-}
-
-[[nodiscard]] constexpr u32 Log2Ceil64(const u64 value) {
-    const u64 log2_f = Log2Floor64(value);
-    return static_cast<u32>(log2_f + static_cast<u64>((value ^ (1ULL << log2_f)) != 0ULL));
+[[nodiscard]] inline u32 Log2Ceil64(const u64 value) {
+    const u64 log2_f = static_cast<u64>(Log2Floor64(value));
+    return static_cast<u32>(log2_f + ((value ^ (1ULL << log2_f)) != 0ULL));
 }
 
 } // namespace Common

src/common/cityhash.cpp

@@ -28,10 +28,8 @@
 // compromising on hash quality.
 
 #include <algorithm>
-#include <cstring>
-#include <utility>
-
-#include "common/cityhash.h"
+#include <string.h> // for memcpy and memset
+#include "cityhash.h"
 #include "common/swap.h"
 
 // #include "config.h"
@@ -44,17 +42,21 @@
 
 using namespace std;
 
+typedef uint8_t uint8;
+typedef uint32_t uint32;
+typedef uint64_t uint64;
+
 namespace Common {
 
-static u64 unaligned_load64(const char* p) {
-    u64 result;
-    std::memcpy(&result, p, sizeof(result));
+static uint64 UNALIGNED_LOAD64(const char* p) {
+    uint64 result;
+    memcpy(&result, p, sizeof(result));
     return result;
 }
 
-static u32 unaligned_load32(const char* p) {
-    u32 result;
-    std::memcpy(&result, p, sizeof(result));
+static uint32 UNALIGNED_LOAD32(const char* p) {
+    uint32 result;
+    memcpy(&result, p, sizeof(result));
     return result;
 }
 
@@ -74,64 +76,64 @@ static u32 unaligned_load32(const char* p) {
 #endif
 #endif
 
-static u64 Fetch64(const char* p) {
-    return uint64_in_expected_order(unaligned_load64(p));
+static uint64 Fetch64(const char* p) {
+    return uint64_in_expected_order(UNALIGNED_LOAD64(p));
 }
 
-static u32 Fetch32(const char* p) {
-    return uint32_in_expected_order(unaligned_load32(p));
+static uint32 Fetch32(const char* p) {
+    return uint32_in_expected_order(UNALIGNED_LOAD32(p));
 }
 
 // Some primes between 2^63 and 2^64 for various uses.
-static constexpr u64 k0 = 0xc3a5c85c97cb3127ULL;
-static constexpr u64 k1 = 0xb492b66fbe98f273ULL;
-static constexpr u64 k2 = 0x9ae16a3b2f90404fULL;
+static const uint64 k0 = 0xc3a5c85c97cb3127ULL;
+static const uint64 k1 = 0xb492b66fbe98f273ULL;
+static const uint64 k2 = 0x9ae16a3b2f90404fULL;
 
 // Bitwise right rotate.  Normally this will compile to a single
 // instruction, especially if the shift is a manifest constant.
-static u64 Rotate(u64 val, int shift) {
+static uint64 Rotate(uint64 val, int shift) {
     // Avoid shifting by 64: doing so yields an undefined result.
     return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
 }
 
-static u64 ShiftMix(u64 val) {
+static uint64 ShiftMix(uint64 val) {
     return val ^ (val >> 47);
 }
 
-static u64 HashLen16(u64 u, u64 v) {
-    return Hash128to64(u128{u, v});
+static uint64 HashLen16(uint64 u, uint64 v) {
+    return Hash128to64(uint128(u, v));
 }
 
-static u64 HashLen16(u64 u, u64 v, u64 mul) {
+static uint64 HashLen16(uint64 u, uint64 v, uint64 mul) {
     // Murmur-inspired hashing.
-    u64 a = (u ^ v) * mul;
+    uint64 a = (u ^ v) * mul;
     a ^= (a >> 47);
-    u64 b = (v ^ a) * mul;
+    uint64 b = (v ^ a) * mul;
     b ^= (b >> 47);
     b *= mul;
     return b;
 }
 
-static u64 HashLen0to16(const char* s, size_t len) {
+static uint64 HashLen0to16(const char* s, std::size_t len) {
     if (len >= 8) {
-        u64 mul = k2 + len * 2;
-        u64 a = Fetch64(s) + k2;
-        u64 b = Fetch64(s + len - 8);
-        u64 c = Rotate(b, 37) * mul + a;
-        u64 d = (Rotate(a, 25) + b) * mul;
+        uint64 mul = k2 + len * 2;
+        uint64 a = Fetch64(s) + k2;
+        uint64 b = Fetch64(s + len - 8);
+        uint64 c = Rotate(b, 37) * mul + a;
+        uint64 d = (Rotate(a, 25) + b) * mul;
         return HashLen16(c, d, mul);
     }
     if (len >= 4) {
-        u64 mul = k2 + len * 2;
-        u64 a = Fetch32(s);
+        uint64 mul = k2 + len * 2;
+        uint64 a = Fetch32(s);
         return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
     }
     if (len > 0) {
-        u8 a = s[0];
-        u8 b = s[len >> 1];
-        u8 c = s[len - 1];
-        u32 y = static_cast<u32>(a) + (static_cast<u32>(b) << 8);
-        u32 z = static_cast<u32>(len) + (static_cast<u32>(c) << 2);
+        uint8 a = s[0];
+        uint8 b = s[len >> 1];
+        uint8 c = s[len - 1];
+        uint32 y = static_cast<uint32>(a) + (static_cast<uint32>(b) << 8);
+        uint32 z = static_cast<uint32>(len) + (static_cast<uint32>(c) << 2);
         return ShiftMix(y * k2 ^ z * k0) * k2;
     }
     return k2;
@@ -139,21 +141,22 @@ static u64 HashLen0to16(const char* s, size_t len) {
 
 // This probably works well for 16-byte strings as well, but it may be overkill
 // in that case.
-static u64 HashLen17to32(const char* s, size_t len) {
-    u64 mul = k2 + len * 2;
-    u64 a = Fetch64(s) * k1;
-    u64 b = Fetch64(s + 8);
-    u64 c = Fetch64(s + len - 8) * mul;
-    u64 d = Fetch64(s + len - 16) * k2;
+static uint64 HashLen17to32(const char* s, std::size_t len) {
+    uint64 mul = k2 + len * 2;
+    uint64 a = Fetch64(s) * k1;
+    uint64 b = Fetch64(s + 8);
+    uint64 c = Fetch64(s + len - 8) * mul;
+    uint64 d = Fetch64(s + len - 16) * k2;
     return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d, a + Rotate(b + k2, 18) + c, mul);
 }
 
 // Return a 16-byte hash for 48 bytes.  Quick and dirty.
 // Callers do best to use "random-looking" values for a and b.
-static pair<u64, u64> WeakHashLen32WithSeeds(u64 w, u64 x, u64 y, u64 z, u64 a, u64 b) {
+static pair<uint64, uint64> WeakHashLen32WithSeeds(uint64 w, uint64 x, uint64 y, uint64 z, uint64 a,
+                                                   uint64 b) {
     a += w;
     b = Rotate(b + a + z, 21);
-    u64 c = a;
+    uint64 c = a;
     a += x;
     a += y;
     b += Rotate(a, 44);
@@ -161,34 +164,34 @@ static pair<u64, u64> WeakHashLen32WithSeeds(u64 w, u64 x, u64 y, u64 z, u64 a,
 }
 
 // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-static pair<u64, u64> WeakHashLen32WithSeeds(const char* s, u64 a, u64 b) {
+static pair<uint64, uint64> WeakHashLen32WithSeeds(const char* s, uint64 a, uint64 b) {
     return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16), Fetch64(s + 24), a,
                                   b);
 }
 
 // Return an 8-byte hash for 33 to 64 bytes.
-static u64 HashLen33to64(const char* s, size_t len) {
-    u64 mul = k2 + len * 2;
-    u64 a = Fetch64(s) * k2;
-    u64 b = Fetch64(s + 8);
-    u64 c = Fetch64(s + len - 24);
-    u64 d = Fetch64(s + len - 32);
-    u64 e = Fetch64(s + 16) * k2;
-    u64 f = Fetch64(s + 24) * 9;
-    u64 g = Fetch64(s + len - 8);
-    u64 h = Fetch64(s + len - 16) * mul;
-    u64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
-    u64 v = ((a + g) ^ d) + f + 1;
-    u64 w = swap64((u + v) * mul) + h;
-    u64 x = Rotate(e + f, 42) + c;
-    u64 y = (swap64((v + w) * mul) + g) * mul;
-    u64 z = e + f + c;
+static uint64 HashLen33to64(const char* s, std::size_t len) {
+    uint64 mul = k2 + len * 2;
+    uint64 a = Fetch64(s) * k2;
+    uint64 b = Fetch64(s + 8);
+    uint64 c = Fetch64(s + len - 24);
+    uint64 d = Fetch64(s + len - 32);
+    uint64 e = Fetch64(s + 16) * k2;
+    uint64 f = Fetch64(s + 24) * 9;
+    uint64 g = Fetch64(s + len - 8);
+    uint64 h = Fetch64(s + len - 16) * mul;
+    uint64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
+    uint64 v = ((a + g) ^ d) + f + 1;
+    uint64 w = swap64((u + v) * mul) + h;
+    uint64 x = Rotate(e + f, 42) + c;
+    uint64 y = (swap64((v + w) * mul) + g) * mul;
+    uint64 z = e + f + c;
     a = swap64((x + z) * mul + y) + b;
     b = ShiftMix((z + a) * mul + d + h) * mul;
     return b + x;
 }
 
-u64 CityHash64(const char* s, size_t len) {
+uint64 CityHash64(const char* s, std::size_t len) {
     if (len <= 32) {
         if (len <= 16) {
             return HashLen0to16(s, len);
@@ -201,15 +204,15 @@ u64 CityHash64(const char* s, size_t len) {
 
     // For strings over 64 bytes we hash the end first, and then as we
     // loop we keep 56 bytes of state: v, w, x, y, and z.
-    u64 x = Fetch64(s + len - 40);
-    u64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
-    u64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-    pair<u64, u64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
-    pair<u64, u64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
+    uint64 x = Fetch64(s + len - 40);
+    uint64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
+    uint64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
+    pair<uint64, uint64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
+    pair<uint64, uint64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
     x = x * k1 + Fetch64(s);
 
     // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
-    len = (len - 1) & ~static_cast<size_t>(63);
+    len = (len - 1) & ~static_cast<std::size_t>(63);
     do {
         x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
         y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
@@ -226,21 +229,21 @@ u64 CityHash64(const char* s, size_t len) {
                      HashLen16(v.second, w.second) + x);
 }
 
-u64 CityHash64WithSeed(const char* s, size_t len, u64 seed) {
+uint64 CityHash64WithSeed(const char* s, std::size_t len, uint64 seed) {
     return CityHash64WithSeeds(s, len, k2, seed);
 }
 
-u64 CityHash64WithSeeds(const char* s, size_t len, u64 seed0, u64 seed1) {
+uint64 CityHash64WithSeeds(const char* s, std::size_t len, uint64 seed0, uint64 seed1) {
     return HashLen16(CityHash64(s, len) - seed0, seed1);
 }
 
 // A subroutine for CityHash128().  Returns a decent 128-bit hash for strings
 // of any length representable in signed long.  Based on City and Murmur.
-static u128 CityMurmur(const char* s, size_t len, u128 seed) {
-    u64 a = seed[0];
-    u64 b = seed[1];
-    u64 c = 0;
-    u64 d = 0;
+static uint128 CityMurmur(const char* s, std::size_t len, uint128 seed) {
+    uint64 a = Uint128Low64(seed);
+    uint64 b = Uint128High64(seed);
+    uint64 c = 0;
+    uint64 d = 0;
     signed long l = static_cast<long>(len) - 16;
     if (l <= 0) { // len <= 16
         a = ShiftMix(a * k1) * k1;
@@ -263,20 +266,20 @@ static u128 CityMurmur(const char* s, size_t len, u128 seed) {
     }
     a = HashLen16(a, c);
     b = HashLen16(d, b);
-    return u128{a ^ b, HashLen16(b, a)};
+    return uint128(a ^ b, HashLen16(b, a));
 }
 
-u128 CityHash128WithSeed(const char* s, size_t len, u128 seed) {
+uint128 CityHash128WithSeed(const char* s, std::size_t len, uint128 seed) {
     if (len < 128) {
         return CityMurmur(s, len, seed);
     }
 
     // We expect len >= 128 to be the common case.  Keep 56 bytes of state:
     // v, w, x, y, and z.
-    pair<u64, u64> v, w;
-    u64 x = seed[0];
-    u64 y = seed[1];
-    u64 z = len * k1;
+    pair<uint64, uint64> v, w;
+    uint64 x = Uint128Low64(seed);
+    uint64 y = Uint128High64(seed);
+    uint64 z = len * k1;
     v.first = Rotate(y ^ k1, 49) * k1 + Fetch64(s);
     v.second = Rotate(v.first, 42) * k1 + Fetch64(s + 8);
     w.first = Rotate(y + z, 35) * k1 + x;
@@ -310,7 +313,7 @@ u128 CityHash128WithSeed(const char* s, size_t len, u128 seed) {
     w.first *= 9;
     v.first *= k0;
     // If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
-    for (size_t tail_done = 0; tail_done < len;) {
+    for (std::size_t tail_done = 0; tail_done < len;) {
         tail_done += 32;
         y = Rotate(x + y, 42) * k0 + v.second;
         w.first += Fetch64(s + len - tail_done + 16);
@@ -325,12 +328,13 @@ u128 CityHash128WithSeed(const char* s, size_t len, u128 seed) {
     // different 56-byte-to-8-byte hashes to get a 16-byte final result.
     x = HashLen16(x, v.first);
     y = HashLen16(y + z, w.first);
-    return u128{HashLen16(x + v.second, w.second) + y, HashLen16(x + w.second, y + v.second)};
+    return uint128(HashLen16(x + v.second, w.second) + y, HashLen16(x + w.second, y + v.second));
 }
 
-u128 CityHash128(const char* s, size_t len) {
-    return len >= 16 ? CityHash128WithSeed(s + 16, len - 16, u128{Fetch64(s), Fetch64(s + 8) + k0})
-                     : CityHash128WithSeed(s, len, u128{k0, k1});
+uint128 CityHash128(const char* s, std::size_t len) {
+    return len >= 16
+               ? CityHash128WithSeed(s + 16, len - 16, uint128(Fetch64(s), Fetch64(s + 8) + k0))
+               : CityHash128WithSeed(s, len, uint128(k0, k1));
 }
 
 } // namespace Common

src/common/cityhash.h

@@ -62,38 +62,49 @@
 #pragma once
 
 #include <cstddef>
-#include "common/common_types.h"
+#include <cstdint>
+#include <utility>
 
 namespace Common {
 
+using uint128 = std::pair<uint64_t, uint64_t>;
+
+[[nodiscard]] inline uint64_t Uint128Low64(const uint128& x) {
+    return x.first;
+}
+[[nodiscard]] inline uint64_t Uint128High64(const uint128& x) {
+    return x.second;
+}
+
 // Hash function for a byte array.
-[[nodiscard]] u64 CityHash64(const char* buf, size_t len);
+[[nodiscard]] uint64_t CityHash64(const char* buf, std::size_t len);
 
 // Hash function for a byte array.  For convenience, a 64-bit seed is also
 // hashed into the result.
-[[nodiscard]] u64 CityHash64WithSeed(const char* buf, size_t len, u64 seed);
+[[nodiscard]] uint64_t CityHash64WithSeed(const char* buf, std::size_t len, uint64_t seed);
 
 // Hash function for a byte array.  For convenience, two seeds are also
 // hashed into the result.
-[[nodiscard]] u64 CityHash64WithSeeds(const char* buf, size_t len, u64 seed0, u64 seed1);
+[[nodiscard]] uint64_t CityHash64WithSeeds(const char* buf, std::size_t len, uint64_t seed0,
+                                           uint64_t seed1);
 
 // Hash function for a byte array.
-[[nodiscard]] u128 CityHash128(const char* s, size_t len);
+[[nodiscard]] uint128 CityHash128(const char* s, std::size_t len);
 
 // Hash function for a byte array.  For convenience, a 128-bit seed is also
 // hashed into the result.
-[[nodiscard]] u128 CityHash128WithSeed(const char* s, size_t len, u128 seed);
+[[nodiscard]] uint128 CityHash128WithSeed(const char* s, std::size_t len, uint128 seed);
 
 // Hash 128 input bits down to 64 bits of output.
 // This is intended to be a reasonably good hash function.
-[[nodiscard]] inline u64 Hash128to64(const u128& x) {
+[[nodiscard]] inline uint64_t Hash128to64(const uint128& x) {
     // Murmur-inspired hashing.
-    const u64 mul = 0x9ddfea08eb382d69ULL;
-    u64 a = (x[0] ^ x[1]) * mul;
+    const uint64_t kMul = 0x9ddfea08eb382d69ULL;
+    uint64_t a = (Uint128Low64(x) ^ Uint128High64(x)) * kMul;
     a ^= (a >> 47);
-    u64 b = (x[1] ^ a) * mul;
+    uint64_t b = (Uint128High64(x) ^ a) * kMul;
     b ^= (b >> 47);
-    b *= mul;
+    b *= kMul;
     return b;
 }
 

src/common/color.h

@@ -0,0 +1,271 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <cstring>
+
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "common/vector_math.h"
+
+namespace Common::Color {
+
+/// Convert a 1-bit color component to 8 bit
+[[nodiscard]] constexpr u8 Convert1To8(u8 value) {
+    return value * 255;
+}
+
+/// Convert a 4-bit color component to 8 bit
+[[nodiscard]] constexpr u8 Convert4To8(u8 value) {
+    return (value << 4) | value;
+}
+
+/// Convert a 5-bit color component to 8 bit
+[[nodiscard]] constexpr u8 Convert5To8(u8 value) {
+    return (value << 3) | (value >> 2);
+}
+
+/// Convert a 6-bit color component to 8 bit
+[[nodiscard]] constexpr u8 Convert6To8(u8 value) {
+    return (value << 2) | (value >> 4);
+}
+
+/// Convert a 8-bit color component to 1 bit
+[[nodiscard]] constexpr u8 Convert8To1(u8 value) {
+    return value >> 7;
+}
+
+/// Convert a 8-bit color component to 4 bit
+[[nodiscard]] constexpr u8 Convert8To4(u8 value) {
+    return value >> 4;
+}
+
+/// Convert a 8-bit color component to 5 bit
+[[nodiscard]] constexpr u8 Convert8To5(u8 value) {
+    return value >> 3;
+}
+
+/// Convert a 8-bit color component to 6 bit
+[[nodiscard]] constexpr u8 Convert8To6(u8 value) {
+    return value >> 2;
+}
+
+/**
+ * Decode a color stored in RGBA8 format
+ * @param bytes Pointer to encoded source color
+ * @return Result color decoded as Common::Vec4<u8>
+ */
+[[nodiscard]] inline Common::Vec4<u8> DecodeRGBA8(const u8* bytes) {
+    return {bytes[3], bytes[2], bytes[1], bytes[0]};
+}
+
+/**
+ * Decode a color stored in RGB8 format
+ * @param bytes Pointer to encoded source color
+ * @return Result color decoded as Common::Vec4<u8>
+ */
+[[nodiscard]] inline Common::Vec4<u8> DecodeRGB8(const u8* bytes) {
+    return {bytes[2], bytes[1], bytes[0], 255};
+}
+
+/**
+ * Decode a color stored in RG8 (aka HILO8) format
+ * @param bytes Pointer to encoded source color
+ * @return Result color decoded as Common::Vec4<u8>
+ */
+[[nodiscard]] inline Common::Vec4<u8> DecodeRG8(const u8* bytes) {
+    return {bytes[1], bytes[0], 0, 255};
+}
+
+/**
+ * Decode a color stored in RGB565 format
+ * @param bytes Pointer to encoded source color
+ * @return Result color decoded as Common::Vec4<u8>
+ */
+[[nodiscard]] inline Common::Vec4<u8> DecodeRGB565(const u8* bytes) {
+    u16_le pixel;
+    std::memcpy(&pixel, bytes, sizeof(pixel));
+    return {Convert5To8((pixel >> 11) & 0x1F), Convert6To8((pixel >> 5) & 0x3F),
+            Convert5To8(pixel & 0x1F), 255};
+}
+
+/**
+ * Decode a color stored in RGB5A1 format
+ * @param bytes Pointer to encoded source color
+ * @return Result color decoded as Common::Vec4<u8>
+ */
+[[nodiscard]] inline Common::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
+    u16_le pixel;
+    std::memcpy(&pixel, bytes, sizeof(pixel));
+    return {Convert5To8((pixel >> 11) & 0x1F), Convert5To8((pixel >> 6) & 0x1F),
+            Convert5To8((pixel >> 1) & 0x1F), Convert1To8(pixel & 0x1)};
+}
+
+/**
+ * Decode a color stored in RGBA4 format
+ * @param bytes Pointer to encoded source color
+ * @return Result color decoded as Common::Vec4<u8>
+ */
+[[nodiscard]] inline Common::Vec4<u8> DecodeRGBA4(const u8* bytes) {
+    u16_le pixel;
+    std::memcpy(&pixel, bytes, sizeof(pixel));
+    return {Convert4To8((pixel >> 12) & 0xF), Convert4To8((pixel >> 8) & 0xF),
+            Convert4To8((pixel >> 4) & 0xF), Convert4To8(pixel & 0xF)};
+}
+
+/**
+ * Decode a depth value stored in D16 format
+ * @param bytes Pointer to encoded source value
+ * @return Depth value as an u32
+ */
+[[nodiscard]] inline u32 DecodeD16(const u8* bytes) {
+    u16_le data;
+    std::memcpy(&data, bytes, sizeof(data));
+    return data;
+}
+
+/**
+ * Decode a depth value stored in D24 format
+ * @param bytes Pointer to encoded source value
+ * @return Depth value as an u32
+ */
+[[nodiscard]] inline u32 DecodeD24(const u8* bytes) {
+    return (bytes[2] << 16) | (bytes[1] << 8) | bytes[0];
+}
+
+/**
+ * Decode a depth value and a stencil value stored in D24S8 format
+ * @param bytes Pointer to encoded source values
+ * @return Resulting values stored as a Common::Vec2
+ */
+[[nodiscard]] inline Common::Vec2<u32> DecodeD24S8(const u8* bytes) {
+    return {static_cast<u32>((bytes[2] << 16) | (bytes[1] << 8) | bytes[0]), bytes[3]};
+}
+
+/**
+ * Encode a color as RGBA8 format
+ * @param color Source color to encode
+ * @param bytes Destination pointer to store encoded color
+ */
+inline void EncodeRGBA8(const Common::Vec4<u8>& color, u8* bytes) {
+    bytes[3] = color.r();
+    bytes[2] = color.g();
+    bytes[1] = color.b();
+    bytes[0] = color.a();
+}
+
+/**
+ * Encode a color as RGB8 format
+ * @param color Source color to encode
+ * @param bytes Destination pointer to store encoded color
+ */
+inline void EncodeRGB8(const Common::Vec4<u8>& color, u8* bytes) {
+    bytes[2] = color.r();
+    bytes[1] = color.g();
+    bytes[0] = color.b();
+}
+
+/**
+ * Encode a color as RG8 (aka HILO8) format
+ * @param color Source color to encode
+ * @param bytes Destination pointer to store encoded color
+ */
+inline void EncodeRG8(const Common::Vec4<u8>& color, u8* bytes) {
+    bytes[1] = color.r();
+    bytes[0] = color.g();
+}
+/**
+ * Encode a color as RGB565 format
+ * @param color Source color to encode
+ * @param bytes Destination pointer to store encoded color
+ */
+inline void EncodeRGB565(const Common::Vec4<u8>& color, u8* bytes) {
+    const u16_le data =
+        (Convert8To5(color.r()) << 11) | (Convert8To6(color.g()) << 5) | Convert8To5(color.b());
+
+    std::memcpy(bytes, &data, sizeof(data));
+}
+
+/**
+ * Encode a color as RGB5A1 format
+ * @param color Source color to encode
+ * @param bytes Destination pointer to store encoded color
+ */
+inline void EncodeRGB5A1(const Common::Vec4<u8>& color, u8* bytes) {
+    const u16_le data = (Convert8To5(color.r()) << 11) | (Convert8To5(color.g()) << 6) |
+                        (Convert8To5(color.b()) << 1) | Convert8To1(color.a());
+
+    std::memcpy(bytes, &data, sizeof(data));
+}
+
+/**
+ * Encode a color as RGBA4 format
+ * @param color Source color to encode
+ * @param bytes Destination pointer to store encoded color
+ */
+inline void EncodeRGBA4(const Common::Vec4<u8>& color, u8* bytes) {
+    const u16 data = (Convert8To4(color.r()) << 12) | (Convert8To4(color.g()) << 8) |
+                     (Convert8To4(color.b()) << 4) | Convert8To4(color.a());
+
+    std::memcpy(bytes, &data, sizeof(data));
+}
+
+/**
+ * Encode a 16 bit depth value as D16 format
+ * @param value 16 bit source depth value to encode
+ * @param bytes Pointer where to store the encoded value
+ */
+inline void EncodeD16(u32 value, u8* bytes) {
+    const u16_le data = static_cast<u16>(value);
+    std::memcpy(bytes, &data, sizeof(data));
+}
+
+/**
+ * Encode a 24 bit depth value as D24 format
+ * @param value 24 bit source depth value to encode
+ * @param bytes Pointer where to store the encoded value
+ */
+inline void EncodeD24(u32 value, u8* bytes) {
+    bytes[0] = value & 0xFF;
+    bytes[1] = (value >> 8) & 0xFF;
+    bytes[2] = (value >> 16) & 0xFF;
+}
+
+/**
+ * Encode a 24 bit depth and 8 bit stencil values as D24S8 format
+ * @param depth 24 bit source depth value to encode
+ * @param stencil 8 bit source stencil value to encode
+ * @param bytes Pointer where to store the encoded value
+ */
+inline void EncodeD24S8(u32 depth, u8 stencil, u8* bytes) {
+    bytes[0] = depth & 0xFF;
+    bytes[1] = (depth >> 8) & 0xFF;
+    bytes[2] = (depth >> 16) & 0xFF;
+    bytes[3] = stencil;
+}
+
+/**
+ * Encode a 24 bit depth value as D24X8 format (32 bits per pixel with 8 bits unused)
+ * @param depth 24 bit source depth value to encode
+ * @param bytes Pointer where to store the encoded value
+ * @note unused bits will not be modified
+ */
+inline void EncodeD24X8(u32 depth, u8* bytes) {
+    bytes[0] = depth & 0xFF;
+    bytes[1] = (depth >> 8) & 0xFF;
+    bytes[2] = (depth >> 16) & 0xFF;
+}
+
+/**
+ * Encode an 8 bit stencil value as X24S8 format (32 bits per pixel with 24 bits unused)
+ * @param stencil 8 bit source stencil value to encode
+ * @param bytes Pointer where to store the encoded value
+ * @note unused bits will not be modified
+ */
+inline void EncodeX24S8(u8 stencil, u8* bytes) {
+    bytes[3] = stencil;
+}
+
+} // namespace Common::Color

src/common/common_funcs.h

@@ -24,10 +24,10 @@
 #define INSERT_PADDING_WORDS(num_words)                                                            \
     std::array<u32, num_words> CONCAT2(pad, __LINE__) {}
 
-/// These are similar to the INSERT_PADDING_* macros but do not zero-initialize the contents.
-/// This keeps the structure trivial to construct.
-#define INSERT_PADDING_BYTES_NOINIT(num_bytes) std::array<u8, num_bytes> CONCAT2(pad, __LINE__)
-#define INSERT_PADDING_WORDS_NOINIT(num_words) std::array<u32, num_words> CONCAT2(pad, __LINE__)
+/// These are similar to the INSERT_PADDING_* macros, but are needed for padding unions. This is
+/// because unions can only be initialized by one member.
+#define INSERT_UNION_PADDING_BYTES(num_bytes) std::array<u8, num_bytes> CONCAT2(pad, __LINE__)
+#define INSERT_UNION_PADDING_WORDS(num_words) std::array<u32, num_words> CONCAT2(pad, __LINE__)
 
 #ifndef _MSC_VER
 
@@ -52,13 +52,9 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
-// Defined in misc.cpp.
+// Defined in Misc.cpp.
 [[nodiscard]] std::string GetLastErrorMsg();
 
-// Like GetLastErrorMsg(), but passing an explicit error code.
-// Defined in misc.cpp.
-[[nodiscard]] std::string NativeErrorToString(int e);
-
 #define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
     [[nodiscard]] constexpr type operator|(type a, type b) noexcept {                              \
         using T = std::underlying_type_t<type>;                                                    \
@@ -97,31 +93,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
         return static_cast<T>(key) == 0;                                                           \
     }
 
-/// 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 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 {
 
 [[nodiscard]] constexpr u32 MakeMagic(char a, char b, char c, char d) {

src/common/concepts.h

@@ -31,8 +31,4 @@ concept DerivedFrom = requires {
     std::is_convertible_v<const volatile Derived*, const volatile Base*>;
 };
 
-// TODO: Replace with std::convertible_to when libc++ implements it.
-template <typename From, typename To>
-concept ConvertibleTo = std::is_convertible_v<From, To>;
-
 } // namespace Common

src/common/div_ceil.h

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

src/common/fiber.cpp

@@ -116,19 +116,16 @@ void Fiber::Rewind() {
     boost::context::detail::jump_fcontext(impl->rewind_context, this);
 }
 
-void Fiber::YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to) {
-    to.impl->guard.lock();
-    to.impl->previous_fiber = weak_from.lock();
-
-    auto transfer = boost::context::detail::jump_fcontext(to.impl->context, &to);
-
-    // "from" might no longer be valid if the thread was killed
-    if (auto from = weak_from.lock()) {
-        ASSERT(from->impl->previous_fiber != nullptr);
-        from->impl->previous_fiber->impl->context = transfer.fctx;
-        from->impl->previous_fiber->impl->guard.unlock();
-        from->impl->previous_fiber.reset();
-    }
+void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) {
+    ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
+    ASSERT_MSG(to != nullptr, "Next fiber is null!");
+    to->impl->guard.lock();
+    to->impl->previous_fiber = from;
+    auto transfer = boost::context::detail::jump_fcontext(to->impl->context, to.get());
+    ASSERT(from->impl->previous_fiber != nullptr);
+    from->impl->previous_fiber->impl->context = transfer.fctx;
+    from->impl->previous_fiber->impl->guard.unlock();
+    from->impl->previous_fiber.reset();
 }
 
 std::shared_ptr<Fiber> Fiber::ThreadToFiber() {

src/common/fiber.h

@@ -41,7 +41,7 @@ public:
 
     /// Yields control from Fiber 'from' to Fiber 'to'
     /// Fiber 'from' must be the currently running fiber.
-    static void YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to);
+    static void YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to);
     [[nodiscard]] static std::shared_ptr<Fiber> ThreadToFiber();
 
     void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param);

src/common/file_util.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <array>
+#include <filesystem>
 #include <limits>
 #include <memory>
 #include <sstream>
@@ -67,290 +68,128 @@
 #include <algorithm>
 #include <sys/stat.h>
 
-#ifndef S_ISDIR
-#define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR)
-#endif
-
-// This namespace has various generic functions related to files and paths.
-// The code still needs a ton of cleanup.
-// REMEMBER: strdup considered harmful!
 namespace Common::FS {
+namespace fs = std::filesystem;
 
-// Remove any ending forward slashes from directory paths
-// Modifies argument.
-static void StripTailDirSlashes(std::string& fname) {
-    if (fname.length() <= 1) {
-        return;
-    }
-
-    std::size_t i = fname.length();
-    while (i > 0 && fname[i - 1] == DIR_SEP_CHR) {
-        --i;
-    }
-    fname.resize(i);
+bool Exists(const fs::path& path) {
+    std::error_code ec;
+    return fs::exists(path, ec);
 }
 
-bool Exists(const std::string& filename) {
-    struct stat file_info;
-
-    std::string copy(filename);
-    StripTailDirSlashes(copy);
-
-#ifdef _WIN32
-    // Windows needs a slash to identify a driver root
-    if (copy.size() != 0 && copy.back() == ':')
-        copy += DIR_SEP_CHR;
-
-    int result = _wstat64(Common::UTF8ToUTF16W(copy).c_str(), &file_info);
-#else
-    int result = stat(copy.c_str(), &file_info);
-#endif
-
-    return (result == 0);
+bool IsDirectory(const fs::path& path) {
+    std::error_code ec;
+    return fs::is_directory(path, ec);
 }
 
-bool IsDirectory(const std::string& filename) {
-    struct stat file_info;
-
-    std::string copy(filename);
-    StripTailDirSlashes(copy);
-
-#ifdef _WIN32
-    // Windows needs a slash to identify a driver root
-    if (copy.size() != 0 && copy.back() == ':')
-        copy += DIR_SEP_CHR;
-
-    int result = _wstat64(Common::UTF8ToUTF16W(copy).c_str(), &file_info);
-#else
-    int result = stat(copy.c_str(), &file_info);
-#endif
-
-    if (result < 0) {
-        LOG_DEBUG(Common_Filesystem, "stat failed on {}: {}", filename, GetLastErrorMsg());
-        return false;
-    }
-
-    return S_ISDIR(file_info.st_mode);
-}
-
-bool Delete(const std::string& filename) {
-    LOG_TRACE(Common_Filesystem, "file {}", filename);
+bool Delete(const fs::path& path) {
+    LOG_TRACE(Common_Filesystem, "file {}", path.string());
 
     // Return true because we care about the file no
     // being there, not the actual delete.
-    if (!Exists(filename)) {
-        LOG_DEBUG(Common_Filesystem, "{} does not exist", filename);
+    if (!Exists(path)) {
+        LOG_DEBUG(Common_Filesystem, "{} does not exist", path.string());
         return true;
     }
 
-    // We can't delete a directory
-    if (IsDirectory(filename)) {
-        LOG_ERROR(Common_Filesystem, "Failed: {} is a directory", filename);
-        return false;
+    std::error_code ec;
+    return fs::remove(path, ec);
+}
+
+bool CreateDir(const fs::path& path) {
+    LOG_TRACE(Common_Filesystem, "directory {}", path.string());
+
+    if (Exists(path)) {
+        LOG_DEBUG(Common_Filesystem, "path exists {}", path.string());
+        return true;
     }
 
-#ifdef _WIN32
-    if (!DeleteFileW(Common::UTF8ToUTF16W(filename).c_str())) {
-        LOG_ERROR(Common_Filesystem, "DeleteFile failed on {}: {}", filename, GetLastErrorMsg());
+    std::error_code ec;
+    const bool success = fs::create_directory(path, ec);
+
+    if (!success) {
+        LOG_ERROR(Common_Filesystem, "Unable to create directory: {}", ec.message());
         return false;
     }
-#else
-    if (unlink(filename.c_str()) == -1) {
-        LOG_ERROR(Common_Filesystem, "unlink failed on {}: {}", filename, GetLastErrorMsg());
-        return false;
-    }
-#endif
 
     return true;
 }
 
-bool CreateDir(const std::string& path) {
-    LOG_TRACE(Common_Filesystem, "directory {}", path);
-#ifdef _WIN32
-    if (::CreateDirectoryW(Common::UTF8ToUTF16W(path).c_str(), nullptr))
-        return true;
-    DWORD error = GetLastError();
-    if (error == ERROR_ALREADY_EXISTS) {
-        LOG_DEBUG(Common_Filesystem, "CreateDirectory failed on {}: already exists", path);
-        return true;
-    }
-    LOG_ERROR(Common_Filesystem, "CreateDirectory failed on {}: {}", path, error);
-    return false;
-#else
-    if (mkdir(path.c_str(), 0755) == 0)
-        return true;
+bool CreateDirs(const fs::path& path) {
+    LOG_TRACE(Common_Filesystem, "path {}", path.string());
 
-    int err = errno;
-
-    if (err == EEXIST) {
-        LOG_DEBUG(Common_Filesystem, "mkdir failed on {}: already exists", path);
+    if (Exists(path)) {
+        LOG_DEBUG(Common_Filesystem, "path exists {}", path.string());
         return true;
     }
 
-    LOG_ERROR(Common_Filesystem, "mkdir failed on {}: {}", path, strerror(err));
-    return false;
-#endif
-}
+    std::error_code ec;
+    const bool success = fs::create_directories(path, ec);
 
-bool CreateFullPath(const std::string& fullPath) {
-    int panicCounter = 100;
-    LOG_TRACE(Common_Filesystem, "path {}", fullPath);
-
-    if (Exists(fullPath)) {
-        LOG_DEBUG(Common_Filesystem, "path exists {}", fullPath);
-        return true;
-    }
-
-    std::size_t position = 0;
-    while (true) {
-        // Find next sub path
-        position = fullPath.find(DIR_SEP_CHR, position);
-
-        // we're done, yay!
-        if (position == fullPath.npos)
-            return true;
-
-        // Include the '/' so the first call is CreateDir("/") rather than CreateDir("")
-        std::string const subPath(fullPath.substr(0, position + 1));
-        if (!IsDirectory(subPath) && !CreateDir(subPath)) {
-            LOG_ERROR(Common, "CreateFullPath: directory creation failed");
-            return false;
-        }
-
-        // A safety check
-        panicCounter--;
-        if (panicCounter <= 0) {
-            LOG_ERROR(Common, "CreateFullPath: directory structure is too deep");
-            return false;
-        }
-        position++;
-    }
-}
-
-bool DeleteDir(const std::string& filename) {
-    LOG_TRACE(Common_Filesystem, "directory {}", filename);
-
-    // check if a directory
-    if (!IsDirectory(filename)) {
-        LOG_ERROR(Common_Filesystem, "Not a directory {}", filename);
+    if (!success) {
+        LOG_ERROR(Common_Filesystem, "Unable to create directories: {}", ec.message());
         return false;
     }
 
-#ifdef _WIN32
-    if (::RemoveDirectoryW(Common::UTF8ToUTF16W(filename).c_str()))
-        return true;
-#else
-    if (rmdir(filename.c_str()) == 0)
-        return true;
-#endif
-    LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
-
-    return false;
-}
-
-bool Rename(const std::string& srcFilename, const std::string& destFilename) {
-    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
-#ifdef _WIN32
-    if (_wrename(Common::UTF8ToUTF16W(srcFilename).c_str(),
-                 Common::UTF8ToUTF16W(destFilename).c_str()) == 0)
-        return true;
-#else
-    if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)
-        return true;
-#endif
-    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
-              GetLastErrorMsg());
-    return false;
-}
-
-bool Copy(const std::string& srcFilename, const std::string& destFilename) {
-    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
-#ifdef _WIN32
-    if (CopyFileW(Common::UTF8ToUTF16W(srcFilename).c_str(),
-                  Common::UTF8ToUTF16W(destFilename).c_str(), FALSE))
-        return true;
-
-    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
-              GetLastErrorMsg());
-    return false;
-#else
-    using CFilePointer = std::unique_ptr<FILE, decltype(&std::fclose)>;
-
-    // Open input file
-    CFilePointer input{fopen(srcFilename.c_str(), "rb"), std::fclose};
-    if (!input) {
-        LOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
-                  destFilename, GetLastErrorMsg());
-        return false;
-    }
-
-    // open output file
-    CFilePointer output{fopen(destFilename.c_str(), "wb"), std::fclose};
-    if (!output) {
-        LOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
-                  destFilename, GetLastErrorMsg());
-        return false;
-    }
-
-    // copy loop
-    std::array<char, 1024> buffer;
-    while (!feof(input.get())) {
-        // read input
-        std::size_t rnum = fread(buffer.data(), sizeof(char), buffer.size(), input.get());
-        if (rnum != buffer.size()) {
-            if (ferror(input.get()) != 0) {
-                LOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
-                          srcFilename, destFilename, GetLastErrorMsg());
-                return false;
-            }
-        }
-
-        // write output
-        std::size_t wnum = fwrite(buffer.data(), sizeof(char), rnum, output.get());
-        if (wnum != rnum) {
-            LOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
-                      destFilename, GetLastErrorMsg());
-            return false;
-        }
-    }
-
     return true;
-#endif
 }
 
-u64 GetSize(const std::string& filename) {
-    if (!Exists(filename)) {
-        LOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
-        return 0;
-    }
+bool CreateFullPath(const fs::path& path) {
+    LOG_TRACE(Common_Filesystem, "path {}", path);
 
-    if (IsDirectory(filename)) {
-        LOG_ERROR(Common_Filesystem, "failed {}: is a directory", filename);
-        return 0;
-    }
+    // Removes trailing slashes and turns any '\' into '/'
+    const auto new_path = SanitizePath(path.string(), DirectorySeparator::ForwardSlash);
 
-    struct stat buf;
-#ifdef _WIN32
-    if (_wstat64(Common::UTF8ToUTF16W(filename).c_str(), &buf) == 0)
-#else
-    if (stat(filename.c_str(), &buf) == 0)
-#endif
-    {
-        LOG_TRACE(Common_Filesystem, "{}: {}", filename, buf.st_size);
-        return buf.st_size;
+    if (new_path.rfind('.') == std::string::npos) {
+        // The path is a directory
+        return CreateDirs(new_path);
+    } else {
+        // The path is a file
+        // Creates directory preceding the last '/'
+        return CreateDirs(new_path.substr(0, new_path.rfind('/')));
     }
-
-    LOG_ERROR(Common_Filesystem, "Stat failed {}: {}", filename, GetLastErrorMsg());
-    return 0;
 }
 
-u64 GetSize(const int fd) {
-    struct stat buf;
-    if (fstat(fd, &buf) != 0) {
-        LOG_ERROR(Common_Filesystem, "GetSize: stat failed {}: {}", fd, GetLastErrorMsg());
+bool Rename(const fs::path& src, const fs::path& dst) {
+    LOG_TRACE(Common_Filesystem, "{} --> {}", src.string(), dst.string());
+
+    std::error_code ec;
+    fs::rename(src, dst, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Unable to rename file from {} to {}: {}", src.string(),
+                  dst.string(), ec.message());
+        return false;
+    }
+
+    return true;
+}
+
+bool Copy(const fs::path& src, const fs::path& dst) {
+    LOG_TRACE(Common_Filesystem, "{} --> {}", src.string(), dst.string());
+
+    std::error_code ec;
+    const bool success = fs::copy_file(src, dst, fs::copy_options::overwrite_existing, ec);
+
+    if (!success) {
+        LOG_ERROR(Common_Filesystem, "Unable to copy file {} to {}: {}", src.string(), dst.string(),
+                  ec.message());
+        return false;
+    }
+
+    return true;
+}
+
+u64 GetSize(const fs::path& path) {
+    std::error_code ec;
+    const auto size = fs::file_size(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Unable to retrieve file size ({}): {}", path.string(),
+                  ec.message());
         return 0;
     }
-    return buf.st_size;
+
+    return size;
 }
 
 u64 GetSize(FILE* f) {
@@ -379,9 +218,9 @@ bool CreateEmptyFile(const std::string& filename) {
     return true;
 }
 
-bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
-                           DirectoryEntryCallable callback) {
-    LOG_TRACE(Common_Filesystem, "directory {}", directory);
+bool ForeachDirectoryEntry(u64* num_entries_out, const fs::path& directory,
+                           const DirectoryEntryCallable& callback) {
+    LOG_TRACE(Common_Filesystem, "directory {}", directory.string());
 
     // How many files + directories we found
     u64 found_entries = 0;
@@ -389,181 +228,86 @@ bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
     // Save the status of callback function
     bool callback_error = false;
 
-#ifdef _WIN32
-    // Find the first file in the directory.
-    WIN32_FIND_DATAW ffd;
-
-    HANDLE handle_find = FindFirstFileW(Common::UTF8ToUTF16W(directory + "\\*").c_str(), &ffd);
-    if (handle_find == INVALID_HANDLE_VALUE) {
-        FindClose(handle_find);
-        return false;
-    }
-    // windows loop
-    do {
-        const std::string virtual_name(Common::UTF16ToUTF8(ffd.cFileName));
-#else
-    DIR* dirp = opendir(directory.c_str());
-    if (!dirp)
-        return false;
-
-    // non windows loop
-    while (struct dirent* result = readdir(dirp)) {
-        const std::string virtual_name(result->d_name);
-#endif
-
-        if (virtual_name == "." || virtual_name == "..")
-            continue;
-
+    std::error_code ec;
+    for (const auto& entry : fs::directory_iterator(directory, ec)) {
         u64 ret_entries = 0;
-        if (!callback(&ret_entries, directory, virtual_name)) {
+        if (!callback(&ret_entries, directory, entry.path().filename())) {
             callback_error = true;
             break;
         }
         found_entries += ret_entries;
-
-#ifdef _WIN32
-    } while (FindNextFileW(handle_find, &ffd) != 0);
-    FindClose(handle_find);
-#else
     }
-    closedir(dirp);
-#endif
 
-    if (callback_error)
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Unable to completely enumerate directory {}: {}",
+                  directory.string(), ec.message());
         return false;
+    }
+
+    if (callback_error) {
+        return false;
+    }
 
     // num_entries_out is allowed to be specified nullptr, in which case we shouldn't try to set it
-    if (num_entries_out != nullptr)
+    if (num_entries_out != nullptr) {
         *num_entries_out = found_entries;
+    }
+
     return true;
 }
 
-u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
-                      unsigned int recursion) {
-    const auto callback = [recursion, &parent_entry](u64* num_entries_out,
-                                                     const std::string& directory,
-                                                     const std::string& virtual_name) -> bool {
-        FSTEntry entry;
-        entry.virtualName = virtual_name;
-        entry.physicalName = directory + DIR_SEP + virtual_name;
+bool DeleteDirRecursively(const fs::path& path) {
+    std::error_code ec;
+    fs::remove_all(path, ec);
 
-        if (IsDirectory(entry.physicalName)) {
-            entry.isDirectory = true;
-            // is a directory, lets go inside if we didn't recurse to often
-            if (recursion > 0) {
-                entry.size = ScanDirectoryTree(entry.physicalName, entry, recursion - 1);
-                *num_entries_out += entry.size;
-            } else {
-                entry.size = 0;
-            }
-        } else { // is a file
-            entry.isDirectory = false;
-            entry.size = GetSize(entry.physicalName);
-        }
-        (*num_entries_out)++;
-
-        // Push into the tree
-        parent_entry.children.push_back(std::move(entry));
-        return true;
-    };
-
-    u64 num_entries;
-    return ForeachDirectoryEntry(&num_entries, directory, callback) ? num_entries : 0;
-}
-
-bool DeleteDirRecursively(const std::string& directory, unsigned int recursion) {
-    const auto callback = [recursion](u64*, const std::string& directory,
-                                      const std::string& virtual_name) {
-        const std::string new_path = directory + DIR_SEP_CHR + virtual_name;
-
-        if (IsDirectory(new_path)) {
-            if (recursion == 0) {
-                return false;
-            }
-            return DeleteDirRecursively(new_path, recursion - 1);
-        }
-        return Delete(new_path);
-    };
-
-    if (!ForeachDirectoryEntry(nullptr, directory, callback))
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Unable to completely delete directory {}: {}", path.string(),
+                  ec.message());
         return false;
+    }
 
-    // Delete the outermost directory
-    DeleteDir(directory);
     return true;
 }
 
-void CopyDir([[maybe_unused]] const std::string& source_path,
-             [[maybe_unused]] const std::string& dest_path) {
-#ifndef _WIN32
-    if (source_path == dest_path) {
-        return;
-    }
-    if (!Exists(source_path)) {
-        return;
-    }
-    if (!Exists(dest_path)) {
-        CreateFullPath(dest_path);
-    }
+void CopyDir(const fs::path& src, const fs::path& dst) {
+    constexpr auto copy_flags = fs::copy_options::skip_existing | fs::copy_options::recursive;
 
-    DIR* dirp = opendir(source_path.c_str());
-    if (!dirp) {
+    std::error_code ec;
+    fs::copy(src, dst, copy_flags, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Error copying directory {} to {}: {}", src.string(),
+                  dst.string(), ec.message());
         return;
     }
 
-    while (struct dirent* result = readdir(dirp)) {
-        const std::string virtualName(result->d_name);
-        // check for "." and ".."
-        if (((virtualName[0] == '.') && (virtualName[1] == '\0')) ||
-            ((virtualName[0] == '.') && (virtualName[1] == '.') && (virtualName[2] == '\0'))) {
-            continue;
-        }
-
-        std::string source, dest;
-        source = source_path + virtualName;
-        dest = dest_path + virtualName;
-        if (IsDirectory(source)) {
-            source += '/';
-            dest += '/';
-            if (!Exists(dest)) {
-                CreateFullPath(dest);
-            }
-            CopyDir(source, dest);
-        } else if (!Exists(dest)) {
-            Copy(source, dest);
-        }
-    }
-    closedir(dirp);
-#endif
+    LOG_TRACE(Common_Filesystem, "Successfully copied directory.");
 }
 
-std::optional<std::string> GetCurrentDir() {
-// Get the current working directory (getcwd uses malloc)
-#ifdef _WIN32
-    wchar_t* dir = _wgetcwd(nullptr, 0);
-    if (!dir) {
-#else
-    char* dir = getcwd(nullptr, 0);
-    if (!dir) {
-#endif
-        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
+std::optional<fs::path> GetCurrentDir() {
+    std::error_code ec;
+    auto path = fs::current_path(ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Unable to retrieve current working directory: {}",
+                  ec.message());
         return std::nullopt;
     }
-#ifdef _WIN32
-    std::string strDir = Common::UTF16ToUTF8(dir);
-#else
-    std::string strDir = dir;
-#endif
-    free(dir);
-    return strDir;
+
+    return {std::move(path)};
 }
 
-bool SetCurrentDir(const std::string& directory) {
-#ifdef _WIN32
-    return _wchdir(Common::UTF8ToUTF16W(directory).c_str()) == 0;
-#else
-    return chdir(directory.c_str()) == 0;
-#endif
+bool SetCurrentDir(const fs::path& path) {
+    std::error_code ec;
+    fs::current_path(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Unable to set {} as working directory: {}", path.string(),
+                  ec.message());
+        return false;
+    }
+
+    return true;
 }
 
 #if defined(__APPLE__)

src/common/file_util.h

@@ -6,6 +6,7 @@
 
 #include <array>
 #include <cstdio>
+#include <filesystem>
 #include <fstream>
 #include <functional>
 #include <limits>
@@ -38,48 +39,40 @@ enum class UserPath {
     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 the path exists
+[[nodiscard]] bool Exists(const std::filesystem::path& path);
 
-// 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 true if path is a directory
+[[nodiscard]] bool IsDirectory(const std::filesystem::path& path);
 
 // Returns the size of filename (64bit)
-[[nodiscard]] u64 GetSize(const std::string& filename);
-
-// Overloaded GetSize, accepts file descriptor
-[[nodiscard]] u64 GetSize(int fd);
+[[nodiscard]] u64 GetSize(const std::filesystem::path& path);
 
 // Overloaded GetSize, accepts FILE*
 [[nodiscard]] u64 GetSize(FILE* f);
 
 // Returns true if successful, or path already exists.
-bool CreateDir(const std::string& filename);
+bool CreateDir(const std::filesystem::path& path);
 
-// Creates the full path of fullPath returns true on success
-bool CreateFullPath(const std::string& fullPath);
+// Create all directories in path
+// Returns true if successful, or path already exists.
+[[nodiscard("Directory creation can fail and must be tested")]] bool CreateDirs(
+    const std::filesystem::path& path);
 
-// Deletes a given filename, return true on success
-// Doesn't supports deleting a directory
-bool Delete(const std::string& filename);
+// Creates directories in path. Returns true on success.
+[[deprecated("This function is deprecated, use CreateDirs")]] bool CreateFullPath(
+    const std::filesystem::path& path);
 
-// Deletes a directory filename, returns true on success
-bool DeleteDir(const std::string& filename);
+// Deletes a given file at the path.
+// This will also delete empty directories.
+// Return true on success
+bool Delete(const std::filesystem::path& path);
 
-// renames file srcFilename to destFilename, returns true on success
-bool Rename(const std::string& srcFilename, const std::string& destFilename);
+// Renames file src to dst, returns true on success
+bool Rename(const std::filesystem::path& src, const std::filesystem::path& dst);
 
-// copies file srcFilename to destFilename, returns true on success
-bool Copy(const std::string& srcFilename, const std::string& destFilename);
+// copies file src to dst, returns true on success
+bool Copy(const std::filesystem::path& src, const std::filesystem::path& dst);
 
 // creates an empty file filename, returns true on success
 bool CreateEmptyFile(const std::string& filename);
@@ -91,42 +84,35 @@ bool CreateEmptyFile(const std::string& filename);
  * @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)>;
+using DirectoryEntryCallable =
+    std::function<bool(u64* num_entries_out, const std::filesystem::path& directory,
+                       const std::filesystem::path& 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
+ *
+ * @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);
+bool ForeachDirectoryEntry(u64* num_entries_out, const std::filesystem::path& directory,
+                           const 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);
+// Deletes the given path and anything under it. Returns true on success.
+bool DeleteDirRecursively(const std::filesystem::path& path);
 
 // Returns the current directory
-[[nodiscard]] std::optional<std::string> GetCurrentDir();
+[[nodiscard]] std::optional<std::filesystem::path> GetCurrentDir();
 
 // Create directory and copy contents (does not overwrite existing files)
-void CopyDir(const std::string& source_path, const std::string& dest_path);
+void CopyDir(const std::filesystem::path& src, const std::filesystem::path& dst);
 
-// Set the current directory to given directory
-bool SetCurrentDir(const std::string& directory);
+// Set the current directory to given path
+bool SetCurrentDir(const std::filesystem::path& path);
 
 // 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).

src/common/intrusive_red_black_tree.h

@@ -1,602 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/parent_of_member.h"
-#include "common/tree.h"
-
-namespace Common {
-
-namespace impl {
-
-class IntrusiveRedBlackTreeImpl;
-
-}
-
-struct IntrusiveRedBlackTreeNode {
-public:
-    using EntryType = RBEntry<IntrusiveRedBlackTreeNode>;
-
-    constexpr IntrusiveRedBlackTreeNode() = default;
-
-    void SetEntry(const EntryType& new_entry) {
-        entry = new_entry;
-    }
-
-    [[nodiscard]] EntryType& GetEntry() {
-        return entry;
-    }
-
-    [[nodiscard]] const EntryType& GetEntry() const {
-        return entry;
-    }
-
-private:
-    EntryType entry{};
-
-    friend class impl::IntrusiveRedBlackTreeImpl;
-
-    template <class, class, class>
-    friend class IntrusiveRedBlackTree;
-};
-
-template <class T, class Traits, class Comparator>
-class IntrusiveRedBlackTree;
-
-namespace impl {
-
-class IntrusiveRedBlackTreeImpl {
-private:
-    template <class, class, class>
-    friend class ::Common::IntrusiveRedBlackTree;
-
-    using RootType = RBHead<IntrusiveRedBlackTreeNode>;
-    RootType root;
-
-public:
-    template <bool Const>
-    class Iterator;
-
-    using value_type = IntrusiveRedBlackTreeNode;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-    using pointer = value_type*;
-    using const_pointer = const value_type*;
-    using reference = value_type&;
-    using const_reference = const value_type&;
-    using iterator = Iterator<false>;
-    using const_iterator = Iterator<true>;
-
-    template <bool Const>
-    class Iterator {
-    public:
-        using iterator_category = std::bidirectional_iterator_tag;
-        using value_type = typename IntrusiveRedBlackTreeImpl::value_type;
-        using difference_type = typename IntrusiveRedBlackTreeImpl::difference_type;
-        using pointer = std::conditional_t<Const, IntrusiveRedBlackTreeImpl::const_pointer,
-                                           IntrusiveRedBlackTreeImpl::pointer>;
-        using reference = std::conditional_t<Const, IntrusiveRedBlackTreeImpl::const_reference,
-                                             IntrusiveRedBlackTreeImpl::reference>;
-
-    private:
-        pointer node;
-
-    public:
-        explicit Iterator(pointer n) : node(n) {}
-
-        bool operator==(const Iterator& rhs) const {
-            return this->node == rhs.node;
-        }
-
-        bool operator!=(const Iterator& rhs) const {
-            return !(*this == rhs);
-        }
-
-        pointer operator->() const {
-            return this->node;
-        }
-
-        reference operator*() const {
-            return *this->node;
-        }
-
-        Iterator& operator++() {
-            this->node = GetNext(this->node);
-            return *this;
-        }
-
-        Iterator& operator--() {
-            this->node = GetPrev(this->node);
-            return *this;
-        }
-
-        Iterator operator++(int) {
-            const Iterator it{*this};
-            ++(*this);
-            return it;
-        }
-
-        Iterator operator--(int) {
-            const Iterator it{*this};
-            --(*this);
-            return it;
-        }
-
-        operator Iterator<true>() const {
-            return Iterator<true>(this->node);
-        }
-    };
-
-private:
-    // Define accessors using RB_* functions.
-    bool EmptyImpl() const {
-        return root.IsEmpty();
-    }
-
-    IntrusiveRedBlackTreeNode* GetMinImpl() const {
-        return RB_MIN(const_cast<RootType*>(&root));
-    }
-
-    IntrusiveRedBlackTreeNode* GetMaxImpl() const {
-        return RB_MAX(const_cast<RootType*>(&root));
-    }
-
-    IntrusiveRedBlackTreeNode* RemoveImpl(IntrusiveRedBlackTreeNode* node) {
-        return RB_REMOVE(&root, node);
-    }
-
-public:
-    static IntrusiveRedBlackTreeNode* GetNext(IntrusiveRedBlackTreeNode* node) {
-        return RB_NEXT(node);
-    }
-
-    static IntrusiveRedBlackTreeNode* GetPrev(IntrusiveRedBlackTreeNode* node) {
-        return RB_PREV(node);
-    }
-
-    static const IntrusiveRedBlackTreeNode* GetNext(const IntrusiveRedBlackTreeNode* node) {
-        return static_cast<const IntrusiveRedBlackTreeNode*>(
-            GetNext(const_cast<IntrusiveRedBlackTreeNode*>(node)));
-    }
-
-    static const IntrusiveRedBlackTreeNode* GetPrev(const IntrusiveRedBlackTreeNode* node) {
-        return static_cast<const IntrusiveRedBlackTreeNode*>(
-            GetPrev(const_cast<IntrusiveRedBlackTreeNode*>(node)));
-    }
-
-public:
-    constexpr IntrusiveRedBlackTreeImpl() {}
-
-    // Iterator accessors.
-    iterator begin() {
-        return iterator(this->GetMinImpl());
-    }
-
-    const_iterator begin() const {
-        return const_iterator(this->GetMinImpl());
-    }
-
-    iterator end() {
-        return iterator(static_cast<IntrusiveRedBlackTreeNode*>(nullptr));
-    }
-
-    const_iterator end() const {
-        return const_iterator(static_cast<const IntrusiveRedBlackTreeNode*>(nullptr));
-    }
-
-    const_iterator cbegin() const {
-        return this->begin();
-    }
-
-    const_iterator cend() const {
-        return this->end();
-    }
-
-    iterator iterator_to(reference ref) {
-        return iterator(&ref);
-    }
-
-    const_iterator iterator_to(const_reference ref) const {
-        return const_iterator(&ref);
-    }
-
-    // Content management.
-    bool empty() const {
-        return this->EmptyImpl();
-    }
-
-    reference back() {
-        return *this->GetMaxImpl();
-    }
-
-    const_reference back() const {
-        return *this->GetMaxImpl();
-    }
-
-    reference front() {
-        return *this->GetMinImpl();
-    }
-
-    const_reference front() const {
-        return *this->GetMinImpl();
-    }
-
-    iterator erase(iterator it) {
-        auto cur = std::addressof(*it);
-        auto next = GetNext(cur);
-        this->RemoveImpl(cur);
-        return iterator(next);
-    }
-};
-
-} // namespace impl
-
-template <typename T>
-concept HasLightCompareType = requires {
-    { std::is_same<typename T::LightCompareType, void>::value }
-    ->std::convertible_to<bool>;
-};
-
-namespace impl {
-
-template <typename T, typename Default>
-consteval auto* GetLightCompareType() {
-    if constexpr (HasLightCompareType<T>) {
-        return static_cast<typename T::LightCompareType*>(nullptr);
-    } else {
-        return static_cast<Default*>(nullptr);
-    }
-}
-
-} // namespace impl
-
-template <typename T, typename Default>
-using LightCompareType = std::remove_pointer_t<decltype(impl::GetLightCompareType<T, Default>())>;
-
-template <class T, class Traits, class Comparator>
-class IntrusiveRedBlackTree {
-
-public:
-    using ImplType = impl::IntrusiveRedBlackTreeImpl;
-
-private:
-    ImplType impl{};
-
-public:
-    template <bool Const>
-    class Iterator;
-
-    using value_type = T;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-    using pointer = T*;
-    using const_pointer = const T*;
-    using reference = T&;
-    using const_reference = const T&;
-    using iterator = Iterator<false>;
-    using const_iterator = Iterator<true>;
-
-    using light_value_type = LightCompareType<Comparator, value_type>;
-    using const_light_pointer = const light_value_type*;
-    using const_light_reference = const light_value_type&;
-
-    template <bool Const>
-    class Iterator {
-    public:
-        friend class IntrusiveRedBlackTree<T, Traits, Comparator>;
-
-        using ImplIterator =
-            std::conditional_t<Const, ImplType::const_iterator, ImplType::iterator>;
-
-        using iterator_category = std::bidirectional_iterator_tag;
-        using value_type = typename IntrusiveRedBlackTree::value_type;
-        using difference_type = typename IntrusiveRedBlackTree::difference_type;
-        using pointer = std::conditional_t<Const, IntrusiveRedBlackTree::const_pointer,
-                                           IntrusiveRedBlackTree::pointer>;
-        using reference = std::conditional_t<Const, IntrusiveRedBlackTree::const_reference,
-                                             IntrusiveRedBlackTree::reference>;
-
-    private:
-        ImplIterator iterator;
-
-    private:
-        explicit Iterator(ImplIterator it) : iterator(it) {}
-
-        explicit Iterator(typename std::conditional<Const, ImplType::const_iterator,
-                                                    ImplType::iterator>::type::pointer ptr)
-            : iterator(ptr) {}
-
-        ImplIterator GetImplIterator() const {
-            return this->iterator;
-        }
-
-    public:
-        bool operator==(const Iterator& rhs) const {
-            return this->iterator == rhs.iterator;
-        }
-
-        bool operator!=(const Iterator& rhs) const {
-            return !(*this == rhs);
-        }
-
-        pointer operator->() const {
-            return Traits::GetParent(std::addressof(*this->iterator));
-        }
-
-        reference operator*() const {
-            return *Traits::GetParent(std::addressof(*this->iterator));
-        }
-
-        Iterator& operator++() {
-            ++this->iterator;
-            return *this;
-        }
-
-        Iterator& operator--() {
-            --this->iterator;
-            return *this;
-        }
-
-        Iterator operator++(int) {
-            const Iterator it{*this};
-            ++this->iterator;
-            return it;
-        }
-
-        Iterator operator--(int) {
-            const Iterator it{*this};
-            --this->iterator;
-            return it;
-        }
-
-        operator Iterator<true>() const {
-            return Iterator<true>(this->iterator);
-        }
-    };
-
-private:
-    static int CompareImpl(const IntrusiveRedBlackTreeNode* lhs,
-                           const IntrusiveRedBlackTreeNode* rhs) {
-        return Comparator::Compare(*Traits::GetParent(lhs), *Traits::GetParent(rhs));
-    }
-
-    static int LightCompareImpl(const void* elm, const IntrusiveRedBlackTreeNode* rhs) {
-        return Comparator::Compare(*static_cast<const_light_pointer>(elm), *Traits::GetParent(rhs));
-    }
-
-    // Define accessors using RB_* functions.
-    IntrusiveRedBlackTreeNode* InsertImpl(IntrusiveRedBlackTreeNode* node) {
-        return RB_INSERT(&impl.root, node, CompareImpl);
-    }
-
-    IntrusiveRedBlackTreeNode* FindImpl(const IntrusiveRedBlackTreeNode* node) const {
-        return RB_FIND(const_cast<ImplType::RootType*>(&impl.root),
-                       const_cast<IntrusiveRedBlackTreeNode*>(node), CompareImpl);
-    }
-
-    IntrusiveRedBlackTreeNode* NFindImpl(const IntrusiveRedBlackTreeNode* node) const {
-        return RB_NFIND(const_cast<ImplType::RootType*>(&impl.root),
-                        const_cast<IntrusiveRedBlackTreeNode*>(node), CompareImpl);
-    }
-
-    IntrusiveRedBlackTreeNode* FindLightImpl(const_light_pointer lelm) const {
-        return RB_FIND_LIGHT(const_cast<ImplType::RootType*>(&impl.root),
-                             static_cast<const void*>(lelm), LightCompareImpl);
-    }
-
-    IntrusiveRedBlackTreeNode* NFindLightImpl(const_light_pointer lelm) const {
-        return RB_NFIND_LIGHT(const_cast<ImplType::RootType*>(&impl.root),
-                              static_cast<const void*>(lelm), LightCompareImpl);
-    }
-
-public:
-    constexpr IntrusiveRedBlackTree() = default;
-
-    // Iterator accessors.
-    iterator begin() {
-        return iterator(this->impl.begin());
-    }
-
-    const_iterator begin() const {
-        return const_iterator(this->impl.begin());
-    }
-
-    iterator end() {
-        return iterator(this->impl.end());
-    }
-
-    const_iterator end() const {
-        return const_iterator(this->impl.end());
-    }
-
-    const_iterator cbegin() const {
-        return this->begin();
-    }
-
-    const_iterator cend() const {
-        return this->end();
-    }
-
-    iterator iterator_to(reference ref) {
-        return iterator(this->impl.iterator_to(*Traits::GetNode(std::addressof(ref))));
-    }
-
-    const_iterator iterator_to(const_reference ref) const {
-        return const_iterator(this->impl.iterator_to(*Traits::GetNode(std::addressof(ref))));
-    }
-
-    // Content management.
-    bool empty() const {
-        return this->impl.empty();
-    }
-
-    reference back() {
-        return *Traits::GetParent(std::addressof(this->impl.back()));
-    }
-
-    const_reference back() const {
-        return *Traits::GetParent(std::addressof(this->impl.back()));
-    }
-
-    reference front() {
-        return *Traits::GetParent(std::addressof(this->impl.front()));
-    }
-
-    const_reference front() const {
-        return *Traits::GetParent(std::addressof(this->impl.front()));
-    }
-
-    iterator erase(iterator it) {
-        return iterator(this->impl.erase(it.GetImplIterator()));
-    }
-
-    iterator insert(reference ref) {
-        ImplType::pointer node = Traits::GetNode(std::addressof(ref));
-        this->InsertImpl(node);
-        return iterator(node);
-    }
-
-    iterator find(const_reference ref) const {
-        return iterator(this->FindImpl(Traits::GetNode(std::addressof(ref))));
-    }
-
-    iterator nfind(const_reference ref) const {
-        return iterator(this->NFindImpl(Traits::GetNode(std::addressof(ref))));
-    }
-
-    iterator find_light(const_light_reference ref) const {
-        return iterator(this->FindLightImpl(std::addressof(ref)));
-    }
-
-    iterator nfind_light(const_light_reference ref) const {
-        return iterator(this->NFindLightImpl(std::addressof(ref)));
-    }
-};
-
-template <auto T, class Derived = impl::GetParentType<T>>
-class IntrusiveRedBlackTreeMemberTraits;
-
-template <class Parent, IntrusiveRedBlackTreeNode Parent::*Member, class Derived>
-class IntrusiveRedBlackTreeMemberTraits<Member, Derived> {
-public:
-    template <class Comparator>
-    using TreeType = IntrusiveRedBlackTree<Derived, IntrusiveRedBlackTreeMemberTraits, Comparator>;
-    using TreeTypeImpl = impl::IntrusiveRedBlackTreeImpl;
-
-private:
-    template <class, class, class>
-    friend class IntrusiveRedBlackTree;
-
-    friend class impl::IntrusiveRedBlackTreeImpl;
-
-    static constexpr IntrusiveRedBlackTreeNode* GetNode(Derived* parent) {
-        return std::addressof(parent->*Member);
-    }
-
-    static constexpr IntrusiveRedBlackTreeNode const* GetNode(Derived const* parent) {
-        return std::addressof(parent->*Member);
-    }
-
-    static constexpr Derived* GetParent(IntrusiveRedBlackTreeNode* node) {
-        return GetParentPointer<Member, Derived>(node);
-    }
-
-    static constexpr Derived const* GetParent(const IntrusiveRedBlackTreeNode* node) {
-        return GetParentPointer<Member, Derived>(node);
-    }
-
-private:
-    static constexpr TypedStorage<Derived> DerivedStorage = {};
-    static_assert(GetParent(GetNode(GetPointer(DerivedStorage))) == GetPointer(DerivedStorage));
-};
-
-template <auto T, class Derived = impl::GetParentType<T>>
-class IntrusiveRedBlackTreeMemberTraitsDeferredAssert;
-
-template <class Parent, IntrusiveRedBlackTreeNode Parent::*Member, class Derived>
-class IntrusiveRedBlackTreeMemberTraitsDeferredAssert<Member, Derived> {
-public:
-    template <class Comparator>
-    using TreeType =
-        IntrusiveRedBlackTree<Derived, IntrusiveRedBlackTreeMemberTraitsDeferredAssert, Comparator>;
-    using TreeTypeImpl = impl::IntrusiveRedBlackTreeImpl;
-
-    static constexpr bool IsValid() {
-        TypedStorage<Derived> DerivedStorage = {};
-        return GetParent(GetNode(GetPointer(DerivedStorage))) == GetPointer(DerivedStorage);
-    }
-
-private:
-    template <class, class, class>
-    friend class IntrusiveRedBlackTree;
-
-    friend class impl::IntrusiveRedBlackTreeImpl;
-
-    static constexpr IntrusiveRedBlackTreeNode* GetNode(Derived* parent) {
-        return std::addressof(parent->*Member);
-    }
-
-    static constexpr IntrusiveRedBlackTreeNode const* GetNode(Derived const* parent) {
-        return std::addressof(parent->*Member);
-    }
-
-    static constexpr Derived* GetParent(IntrusiveRedBlackTreeNode* node) {
-        return GetParentPointer<Member, Derived>(node);
-    }
-
-    static constexpr Derived const* GetParent(const IntrusiveRedBlackTreeNode* node) {
-        return GetParentPointer<Member, Derived>(node);
-    }
-};
-
-template <class Derived>
-class IntrusiveRedBlackTreeBaseNode : public IntrusiveRedBlackTreeNode {
-public:
-    constexpr Derived* GetPrev() {
-        return static_cast<Derived*>(impl::IntrusiveRedBlackTreeImpl::GetPrev(this));
-    }
-    constexpr const Derived* GetPrev() const {
-        return static_cast<const Derived*>(impl::IntrusiveRedBlackTreeImpl::GetPrev(this));
-    }
-
-    constexpr Derived* GetNext() {
-        return static_cast<Derived*>(impl::IntrusiveRedBlackTreeImpl::GetNext(this));
-    }
-    constexpr const Derived* GetNext() const {
-        return static_cast<const Derived*>(impl::IntrusiveRedBlackTreeImpl::GetNext(this));
-    }
-};
-
-template <class Derived>
-class IntrusiveRedBlackTreeBaseTraits {
-public:
-    template <class Comparator>
-    using TreeType = IntrusiveRedBlackTree<Derived, IntrusiveRedBlackTreeBaseTraits, Comparator>;
-    using TreeTypeImpl = impl::IntrusiveRedBlackTreeImpl;
-
-private:
-    template <class, class, class>
-    friend class IntrusiveRedBlackTree;
-
-    friend class impl::IntrusiveRedBlackTreeImpl;
-
-    static constexpr IntrusiveRedBlackTreeNode* GetNode(Derived* parent) {
-        return static_cast<IntrusiveRedBlackTreeNode*>(parent);
-    }
-
-    static constexpr IntrusiveRedBlackTreeNode const* GetNode(Derived const* parent) {
-        return static_cast<const IntrusiveRedBlackTreeNode*>(parent);
-    }
-
-    static constexpr Derived* GetParent(IntrusiveRedBlackTreeNode* node) {
-        return static_cast<Derived*>(node);
-    }
-
-    static constexpr Derived const* GetParent(const IntrusiveRedBlackTreeNode* node) {
-        return static_cast<const Derived*>(node);
-    }
-};
-
-} // namespace Common

src/common/logging/backend.cpp

@@ -145,18 +145,10 @@ void ColorConsoleBackend::Write(const Entry& entry) {
     PrintColoredMessage(entry);
 }
 
-FileBackend::FileBackend(const std::string& filename) : bytes_written(0) {
-    if (Common::FS::Exists(filename + ".old.txt")) {
-        Common::FS::Delete(filename + ".old.txt");
-    }
-    if (Common::FS::Exists(filename)) {
-        Common::FS::Rename(filename, filename + ".old.txt");
-    }
-
-    // _SH_DENYWR allows read only access to the file for other programs.
-    // It is #defined to 0 on other platforms
-    file = Common::FS::IOFile(filename, "w", _SH_DENYWR);
-}
+// _SH_DENYWR allows read only access to the file for other programs.
+// It is #defined to 0 on other platforms
+FileBackend::FileBackend(const std::string& filename)
+    : file(filename, "w", _SH_DENYWR), bytes_written(0) {}
 
 void FileBackend::Write(const Entry& entry) {
     // prevent logs from going over the maximum size (in case its spamming and the user doesn't

src/common/memory_hook.cpp

@@ -0,0 +1,11 @@
+// Copyright 2018 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/memory_hook.h"
+
+namespace Common {
+
+MemoryHook::~MemoryHook() = default;
+
+} // namespace Common

src/common/memory_hook.h

@@ -0,0 +1,47 @@
+// Copyright 2016 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <optional>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+/**
+ * Memory hooks have two purposes:
+ * 1. To allow reads and writes to a region of memory to be intercepted. This is used to implement
+ *    texture forwarding and memory breakpoints for debugging.
+ * 2. To allow for the implementation of MMIO devices.
+ *
+ * A hook may be mapped to multiple regions of memory.
+ *
+ * If a std::nullopt or false is returned from a function, the read/write request is passed through
+ * to the underlying memory region.
+ */
+class MemoryHook {
+public:
+    virtual ~MemoryHook();
+
+    virtual std::optional<bool> IsValidAddress(VAddr addr) = 0;
+
+    virtual std::optional<u8> Read8(VAddr addr) = 0;
+    virtual std::optional<u16> Read16(VAddr addr) = 0;
+    virtual std::optional<u32> Read32(VAddr addr) = 0;
+    virtual std::optional<u64> Read64(VAddr addr) = 0;
+
+    virtual bool ReadBlock(VAddr src_addr, void* dest_buffer, std::size_t size) = 0;
+
+    virtual bool Write8(VAddr addr, u8 data) = 0;
+    virtual bool Write16(VAddr addr, u16 data) = 0;
+    virtual bool Write32(VAddr addr, u32 data) = 0;
+    virtual bool Write64(VAddr addr, u64 data) = 0;
+
+    virtual bool WriteBlock(VAddr dest_addr, const void* src_buffer, std::size_t size) = 0;
+};
+
+using MemoryHookPointer = std::shared_ptr<MemoryHook>;
+} // namespace Common

src/common/misc.cpp

@@ -12,41 +12,27 @@
 
 #include "common/common_funcs.h"
 
-std::string NativeErrorToString(int e) {
-#ifdef _WIN32
-    LPSTR err_str;
+// Generic function to get last error message.
+// Call directly after the command or use the error num.
+// This function might change the error code.
+std::string GetLastErrorMsg() {
+    static constexpr std::size_t buff_size = 255;
+    char err_str[buff_size];
 
-    DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                                   FORMAT_MESSAGE_IGNORE_INSERTS,
-                               nullptr, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
-    if (!res) {
-        return "(FormatMessageA failed to format error)";
-    }
-    std::string ret(err_str);
-    LocalFree(err_str);
-    return ret;
-#else
-    char err_str[255];
-#if defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))
+#ifdef _WIN32
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(),
+                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err_str, buff_size, nullptr);
+    return std::string(err_str, buff_size);
+#elif defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))
     // Thread safe (GNU-specific)
-    const char* str = strerror_r(e, err_str, sizeof(err_str));
+    const char* str = strerror_r(errno, err_str, buff_size);
     return std::string(str);
 #else
     // Thread safe (XSI-compliant)
-    int second_err = strerror_r(e, err_str, sizeof(err_str));
-    if (second_err != 0) {
-        return "(strerror_r failed to format error)";
+    const int success = strerror_r(errno, err_str, buff_size);
+    if (success != 0) {
+        return {};
     }
     return std::string(err_str);
-#endif // GLIBC etc.
-#endif // _WIN32
-}
-
-std::string GetLastErrorMsg() {
-#ifdef _WIN32
-    return NativeErrorToString(GetLastError());
-#else
-    return NativeErrorToString(errno);
 #endif
 }

src/common/multi_level_queue.h

@@ -0,0 +1,345 @@
+// Copyright 2019 TuxSH
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <iterator>
+#include <list>
+#include <utility>
+
+#include "common/bit_util.h"
+#include "common/common_types.h"
+
+namespace Common {
+
+/**
+ * A MultiLevelQueue is a type of priority queue which has the following characteristics:
+ * - iteratable through each of its elements.
+ * - back can be obtained.
+ * - O(1) add, lookup (both front and back)
+ * - discrete priorities and a max of 64 priorities (limited domain)
+ * This type of priority queue is normaly used for managing threads within an scheduler
+ */
+template <typename T, std::size_t Depth>
+class MultiLevelQueue {
+public:
+    using value_type = T;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using pointer = value_type*;
+    using const_pointer = const value_type*;
+
+    using difference_type = typename std::pointer_traits<pointer>::difference_type;
+    using size_type = std::size_t;
+
+    template <bool is_constant>
+    class iterator_impl {
+    public:
+        using iterator_category = std::bidirectional_iterator_tag;
+        using value_type = T;
+        using pointer = std::conditional_t<is_constant, T*, const T*>;
+        using reference = std::conditional_t<is_constant, const T&, T&>;
+        using difference_type = typename std::pointer_traits<pointer>::difference_type;
+
+        friend bool operator==(const iterator_impl& lhs, const iterator_impl& rhs) {
+            if (lhs.IsEnd() && rhs.IsEnd())
+                return true;
+            return std::tie(lhs.current_priority, lhs.it) == std::tie(rhs.current_priority, rhs.it);
+        }
+
+        friend bool operator!=(const iterator_impl& lhs, const iterator_impl& rhs) {
+            return !operator==(lhs, rhs);
+        }
+
+        reference operator*() const {
+            return *it;
+        }
+
+        pointer operator->() const {
+            return it.operator->();
+        }
+
+        iterator_impl& operator++() {
+            if (IsEnd()) {
+                return *this;
+            }
+
+            ++it;
+
+            if (it == GetEndItForPrio()) {
+                u64 prios = mlq.used_priorities;
+                prios &= ~((1ULL << (current_priority + 1)) - 1);
+                if (prios == 0) {
+                    current_priority = static_cast<u32>(mlq.depth());
+                } else {
+                    current_priority = CountTrailingZeroes64(prios);
+                    it = GetBeginItForPrio();
+                }
+            }
+            return *this;
+        }
+
+        iterator_impl& operator--() {
+            if (IsEnd()) {
+                if (mlq.used_priorities != 0) {
+                    current_priority = 63 - CountLeadingZeroes64(mlq.used_priorities);
+                    it = GetEndItForPrio();
+                    --it;
+                }
+            } else if (it == GetBeginItForPrio()) {
+                u64 prios = mlq.used_priorities;
+                prios &= (1ULL << current_priority) - 1;
+                if (prios != 0) {
+                    current_priority = CountTrailingZeroes64(prios);
+                    it = GetEndItForPrio();
+                    --it;
+                }
+            } else {
+                --it;
+            }
+            return *this;
+        }
+
+        iterator_impl operator++(int) {
+            const iterator_impl v{*this};
+            ++(*this);
+            return v;
+        }
+
+        iterator_impl operator--(int) {
+            const iterator_impl v{*this};
+            --(*this);
+            return v;
+        }
+
+        // allow implicit const->non-const
+        iterator_impl(const iterator_impl<false>& other)
+            : mlq(other.mlq), it(other.it), current_priority(other.current_priority) {}
+
+        iterator_impl(const iterator_impl<true>& other)
+            : mlq(other.mlq), it(other.it), current_priority(other.current_priority) {}
+
+        iterator_impl& operator=(const iterator_impl<false>& other) {
+            mlq = other.mlq;
+            it = other.it;
+            current_priority = other.current_priority;
+            return *this;
+        }
+
+        friend class iterator_impl<true>;
+        iterator_impl() = default;
+
+    private:
+        friend class MultiLevelQueue;
+        using container_ref =
+            std::conditional_t<is_constant, const MultiLevelQueue&, MultiLevelQueue&>;
+        using list_iterator = std::conditional_t<is_constant, typename std::list<T>::const_iterator,
+                                                 typename std::list<T>::iterator>;
+
+        explicit iterator_impl(container_ref mlq, list_iterator it, u32 current_priority)
+            : mlq(mlq), it(it), current_priority(current_priority) {}
+        explicit iterator_impl(container_ref mlq, u32 current_priority)
+            : mlq(mlq), it(), current_priority(current_priority) {}
+
+        bool IsEnd() const {
+            return current_priority == mlq.depth();
+        }
+
+        list_iterator GetBeginItForPrio() const {
+            return mlq.levels[current_priority].begin();
+        }
+
+        list_iterator GetEndItForPrio() const {
+            return mlq.levels[current_priority].end();
+        }
+
+        container_ref mlq;
+        list_iterator it;
+        u32 current_priority;
+    };
+
+    using iterator = iterator_impl<false>;
+    using const_iterator = iterator_impl<true>;
+
+    void add(const T& element, u32 priority, bool send_back = true) {
+        if (send_back)
+            levels[priority].push_back(element);
+        else
+            levels[priority].push_front(element);
+        used_priorities |= 1ULL << priority;
+    }
+
+    void remove(const T& element, u32 priority) {
+        auto it = ListIterateTo(levels[priority], element);
+        if (it == levels[priority].end())
+            return;
+        levels[priority].erase(it);
+        if (levels[priority].empty()) {
+            used_priorities &= ~(1ULL << priority);
+        }
+    }
+
+    void adjust(const T& element, u32 old_priority, u32 new_priority, bool adjust_front = false) {
+        remove(element, old_priority);
+        add(element, new_priority, !adjust_front);
+    }
+    void adjust(const_iterator it, u32 old_priority, u32 new_priority, bool adjust_front = false) {
+        adjust(*it, old_priority, new_priority, adjust_front);
+    }
+
+    void transfer_to_front(const T& element, u32 priority, MultiLevelQueue& other) {
+        ListSplice(other.levels[priority], other.levels[priority].begin(), levels[priority],
+                   ListIterateTo(levels[priority], element));
+
+        other.used_priorities |= 1ULL << priority;
+
+        if (levels[priority].empty()) {
+            used_priorities &= ~(1ULL << priority);
+        }
+    }
+
+    void transfer_to_front(const_iterator it, u32 priority, MultiLevelQueue& other) {
+        transfer_to_front(*it, priority, other);
+    }
+
+    void transfer_to_back(const T& element, u32 priority, MultiLevelQueue& other) {
+        ListSplice(other.levels[priority], other.levels[priority].end(), levels[priority],
+                   ListIterateTo(levels[priority], element));
+
+        other.used_priorities |= 1ULL << priority;
+
+        if (levels[priority].empty()) {
+            used_priorities &= ~(1ULL << priority);
+        }
+    }
+
+    void transfer_to_back(const_iterator it, u32 priority, MultiLevelQueue& other) {
+        transfer_to_back(*it, priority, other);
+    }
+
+    void yield(u32 priority, std::size_t n = 1) {
+        ListShiftForward(levels[priority], n);
+    }
+
+    [[nodiscard]] std::size_t depth() const {
+        return Depth;
+    }
+
+    [[nodiscard]] std::size_t size(u32 priority) const {
+        return levels[priority].size();
+    }
+
+    [[nodiscard]] std::size_t size() const {
+        u64 priorities = used_priorities;
+        std::size_t size = 0;
+        while (priorities != 0) {
+            const u64 current_priority = CountTrailingZeroes64(priorities);
+            size += levels[current_priority].size();
+            priorities &= ~(1ULL << current_priority);
+        }
+        return size;
+    }
+
+    [[nodiscard]] bool empty() const {
+        return used_priorities == 0;
+    }
+
+    [[nodiscard]] bool empty(u32 priority) const {
+        return (used_priorities & (1ULL << priority)) == 0;
+    }
+
+    [[nodiscard]] u32 highest_priority_set(u32 max_priority = 0) const {
+        const u64 priorities =
+            max_priority == 0 ? used_priorities : (used_priorities & ~((1ULL << max_priority) - 1));
+        return priorities == 0 ? Depth : static_cast<u32>(CountTrailingZeroes64(priorities));
+    }
+
+    [[nodiscard]] u32 lowest_priority_set(u32 min_priority = Depth - 1) const {
+        const u64 priorities = min_priority >= Depth - 1
+                                   ? used_priorities
+                                   : (used_priorities & ((1ULL << (min_priority + 1)) - 1));
+        return priorities == 0 ? Depth : 63 - CountLeadingZeroes64(priorities);
+    }
+
+    [[nodiscard]] const_iterator cbegin(u32 max_prio = 0) const {
+        const u32 priority = highest_priority_set(max_prio);
+        return priority == Depth ? cend()
+                                 : const_iterator{*this, levels[priority].cbegin(), priority};
+    }
+    [[nodiscard]] const_iterator begin(u32 max_prio = 0) const {
+        return cbegin(max_prio);
+    }
+    [[nodiscard]] iterator begin(u32 max_prio = 0) {
+        const u32 priority = highest_priority_set(max_prio);
+        return priority == Depth ? end() : iterator{*this, levels[priority].begin(), priority};
+    }
+
+    [[nodiscard]] const_iterator cend(u32 min_prio = Depth - 1) const {
+        return min_prio == Depth - 1 ? const_iterator{*this, Depth} : cbegin(min_prio + 1);
+    }
+    [[nodiscard]] const_iterator end(u32 min_prio = Depth - 1) const {
+        return cend(min_prio);
+    }
+    [[nodiscard]] iterator end(u32 min_prio = Depth - 1) {
+        return min_prio == Depth - 1 ? iterator{*this, Depth} : begin(min_prio + 1);
+    }
+
+    [[nodiscard]] T& front(u32 max_priority = 0) {
+        const u32 priority = highest_priority_set(max_priority);
+        return levels[priority == Depth ? 0 : priority].front();
+    }
+    [[nodiscard]] const T& front(u32 max_priority = 0) const {
+        const u32 priority = highest_priority_set(max_priority);
+        return levels[priority == Depth ? 0 : priority].front();
+    }
+
+    [[nodiscard]] T& back(u32 min_priority = Depth - 1) {
+        const u32 priority = lowest_priority_set(min_priority); // intended
+        return levels[priority == Depth ? 63 : priority].back();
+    }
+    [[nodiscard]] const T& back(u32 min_priority = Depth - 1) const {
+        const u32 priority = lowest_priority_set(min_priority); // intended
+        return levels[priority == Depth ? 63 : priority].back();
+    }
+
+    void clear() {
+        used_priorities = 0;
+        for (std::size_t i = 0; i < Depth; i++) {
+            levels[i].clear();
+        }
+    }
+
+private:
+    using const_list_iterator = typename std::list<T>::const_iterator;
+
+    static void ListShiftForward(std::list<T>& list, const std::size_t shift = 1) {
+        if (shift >= list.size()) {
+            return;
+        }
+
+        const auto begin_range = list.begin();
+        const auto end_range = std::next(begin_range, shift);
+        list.splice(list.end(), list, begin_range, end_range);
+    }
+
+    static void ListSplice(std::list<T>& in_list, const_list_iterator position,
+                           std::list<T>& out_list, const_list_iterator element) {
+        in_list.splice(position, out_list, element);
+    }
+
+    [[nodiscard]] static const_list_iterator ListIterateTo(const std::list<T>& list,
+                                                           const T& element) {
+        auto it = list.cbegin();
+        while (it != list.cend() && *it != element) {
+            ++it;
+        }
+        return it;
+    }
+
+    std::array<std::list<T>, Depth> levels;
+    u64 used_priorities = 0;
+};
+
+} // namespace Common

src/common/nvidia_flags.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 <filesystem>
-#include <stdlib.h>
-
-#include <fmt/format.h>
-
-#include "common/file_util.h"
-#include "common/nvidia_flags.h"
-
-namespace Common {
-
-void ConfigureNvidiaEnvironmentFlags() {
-#ifdef _WIN32
-    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
-}
-
-} // namespace Common

src/common/nvidia_flags.h

@@ -1,10 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-namespace Common {
-
-/// Configure platform specific flags for Nvidia's driver
-void ConfigureNvidiaEnvironmentFlags();
-
-} // namespace Common

src/common/page_table.cpp

@@ -10,10 +10,16 @@ PageTable::PageTable() = default;
 
 PageTable::~PageTable() noexcept = default;
 
-void PageTable::Resize(size_t address_space_width_in_bits, size_t page_size_in_bits) {
-    const size_t num_page_table_entries{1ULL << (address_space_width_in_bits - page_size_in_bits)};
+void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
+                       bool has_attribute) {
+    const std::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);
+
+    if (has_attribute) {
+        attributes.resize(num_page_table_entries);
+    }
 }
 
 } // namespace Common

src/common/page_table.h

@@ -4,10 +4,10 @@
 
 #pragma once
 
-#include <atomic>
 #include <tuple>
 
 #include "common/common_types.h"
+#include "common/memory_hook.h"
 #include "common/virtual_buffer.h"
 
 namespace Common {
@@ -20,6 +20,27 @@ enum class PageType : u8 {
     /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
     /// invalidation
     RasterizerCachedMemory,
+    /// Page is mapped to a I/O region. Writing and reading to this page is handled by functions.
+    Special,
+    /// Page is allocated for use.
+    Allocated,
+};
+
+struct SpecialRegion {
+    enum class Type {
+        DebugHook,
+        IODevice,
+    } type;
+
+    MemoryHookPointer handler;
+
+    [[nodiscard]] bool operator<(const SpecialRegion& other) const {
+        return std::tie(type, handler) < std::tie(other.type, other.handler);
+    }
+
+    [[nodiscard]] bool operator==(const SpecialRegion& other) const {
+        return std::tie(type, handler) == std::tie(other.type, other.handler);
+    }
 };
 
 /**
@@ -27,59 +48,6 @@ enum class PageType : u8 {
  * mimics the way a real CPU page table works.
  */
 struct PageTable {
-    /// Number of bits reserved for attribute tagging.
-    /// This can be at most the guaranteed alignment of the pointers in the page table.
-    static constexpr int ATTRIBUTE_BITS = 2;
-
-    /**
-     * Pair of host pointer and page type attribute.
-     * This uses the lower bits of a given pointer to store the attribute tag.
-     * Writing and reading the pointer attribute pair is guaranteed to be atomic for the same method
-     * call. In other words, they are guaranteed to be synchronized at all times.
-     */
-    class PageInfo {
-    public:
-        /// Returns the page pointer
-        [[nodiscard]] u8* Pointer() const noexcept {
-            return ExtractPointer(raw.load(std::memory_order_relaxed));
-        }
-
-        /// Returns the page type attribute
-        [[nodiscard]] PageType Type() const noexcept {
-            return ExtractType(raw.load(std::memory_order_relaxed));
-        }
-
-        /// Returns the page pointer and attribute pair, extracted from the same atomic read
-        [[nodiscard]] std::pair<u8*, PageType> PointerType() const noexcept {
-            const uintptr_t non_atomic_raw = raw.load(std::memory_order_relaxed);
-            return {ExtractPointer(non_atomic_raw), ExtractType(non_atomic_raw)};
-        }
-
-        /// Returns the raw representation of the page information.
-        /// Use ExtractPointer and ExtractType to unpack the value.
-        [[nodiscard]] uintptr_t Raw() const noexcept {
-            return raw.load(std::memory_order_relaxed);
-        }
-
-        /// Write a page pointer and type pair atomically
-        void Store(u8* pointer, PageType type) noexcept {
-            raw.store(reinterpret_cast<uintptr_t>(pointer) | static_cast<uintptr_t>(type));
-        }
-
-        /// Unpack a pointer from a page info raw representation
-        [[nodiscard]] static u8* ExtractPointer(uintptr_t raw) noexcept {
-            return reinterpret_cast<u8*>(raw & (~uintptr_t{0} << ATTRIBUTE_BITS));
-        }
-
-        /// Unpack a page type from a page info raw representation
-        [[nodiscard]] static PageType ExtractType(uintptr_t raw) noexcept {
-            return static_cast<PageType>(raw & ((uintptr_t{1} << ATTRIBUTE_BITS) - 1));
-        }
-
-    private:
-        std::atomic<uintptr_t> raw;
-    };
-
     PageTable();
     ~PageTable() noexcept;
 
@@ -90,21 +58,25 @@ struct PageTable {
     PageTable& operator=(PageTable&&) noexcept = default;
 
     /**
-     * Resizes the page table to be able to accommodate enough pages within
+     * Resizes the page table to be able to accomodate enough pages within
      * a given address space.
      *
      * @param address_space_width_in_bits The address size width in bits.
      * @param page_size_in_bits           The page size in bits.
+     * @param has_attribute               Whether or not this page has any backing attributes.
      */
-    void Resize(size_t address_space_width_in_bits, size_t page_size_in_bits);
+    void Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
+                bool has_attribute);
 
     /**
      * Vector of memory pointers backing each page. An entry can only be non-null if the
-     * corresponding attribute element is of type `Memory`.
+     * corresponding entry in the `attributes` vector is of type `Memory`.
      */
-    VirtualBuffer<PageInfo> pointers;
+    VirtualBuffer<u8*> pointers;
 
     VirtualBuffer<u64> backing_addr;
+
+    VirtualBuffer<PageType> attributes;
 };
 
 } // namespace Common

src/common/parent_of_member.h

@@ -1,191 +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>
-
-#include "common/assert.h"
-#include "common/common_types.h"
-
-namespace Common {
-namespace detail {
-template <typename T, size_t Size, size_t Align>
-struct TypedStorageImpl {
-    std::aligned_storage_t<Size, Align> storage_;
-};
-} // namespace detail
-
-template <typename T>
-using TypedStorage = detail::TypedStorageImpl<T, sizeof(T), alignof(T)>;
-
-template <typename T>
-static constexpr T* GetPointer(TypedStorage<T>& ts) {
-    return static_cast<T*>(static_cast<void*>(std::addressof(ts.storage_)));
-}
-
-template <typename T>
-static constexpr const T* GetPointer(const TypedStorage<T>& ts) {
-    return static_cast<const T*>(static_cast<const void*>(std::addressof(ts.storage_)));
-}
-
-namespace impl {
-
-template <size_t MaxDepth>
-struct OffsetOfUnionHolder {
-    template <typename ParentType, typename MemberType, size_t Offset>
-    union UnionImpl {
-        using PaddingMember = char;
-        static constexpr size_t GetOffset() {
-            return Offset;
-        }
-
-#pragma pack(push, 1)
-        struct {
-            PaddingMember padding[Offset];
-            MemberType members[(sizeof(ParentType) / sizeof(MemberType)) + 1];
-        } data;
-#pragma pack(pop)
-        UnionImpl<ParentType, MemberType, Offset + 1> next_union;
-    };
-
-    template <typename ParentType, typename MemberType>
-    union UnionImpl<ParentType, MemberType, 0> {
-        static constexpr size_t GetOffset() {
-            return 0;
-        }
-
-        struct {
-            MemberType members[(sizeof(ParentType) / sizeof(MemberType)) + 1];
-        } data;
-        UnionImpl<ParentType, MemberType, 1> next_union;
-    };
-
-    template <typename ParentType, typename MemberType>
-    union UnionImpl<ParentType, MemberType, MaxDepth> {};
-};
-
-template <typename ParentType, typename MemberType>
-struct OffsetOfCalculator {
-    using UnionHolder =
-        typename OffsetOfUnionHolder<sizeof(MemberType)>::template UnionImpl<ParentType, MemberType,
-                                                                             0>;
-    union Union {
-        char c{};
-        UnionHolder first_union;
-        TypedStorage<ParentType> parent;
-
-        constexpr Union() : c() {}
-    };
-    static constexpr Union U = {};
-
-    static constexpr const MemberType* GetNextAddress(const MemberType* start,
-                                                      const MemberType* target) {
-        while (start < target) {
-            start++;
-        }
-        return start;
-    }
-
-    static constexpr std::ptrdiff_t GetDifference(const MemberType* start,
-                                                  const MemberType* target) {
-        return (target - start) * sizeof(MemberType);
-    }
-
-    template <typename CurUnion>
-    static constexpr std::ptrdiff_t OffsetOfImpl(MemberType ParentType::*member,
-                                                 CurUnion& cur_union) {
-        constexpr size_t Offset = CurUnion::GetOffset();
-        const auto target = std::addressof(GetPointer(U.parent)->*member);
-        const auto start = std::addressof(cur_union.data.members[0]);
-        const auto next = GetNextAddress(start, target);
-
-        if (next != target) {
-            if constexpr (Offset < sizeof(MemberType) - 1) {
-                return OffsetOfImpl(member, cur_union.next_union);
-            } else {
-                UNREACHABLE();
-            }
-        }
-
-        return (next - start) * sizeof(MemberType) + Offset;
-    }
-
-    static constexpr std::ptrdiff_t OffsetOf(MemberType ParentType::*member) {
-        return OffsetOfImpl(member, U.first_union);
-    }
-};
-
-template <typename T>
-struct GetMemberPointerTraits;
-
-template <typename P, typename M>
-struct GetMemberPointerTraits<M P::*> {
-    using Parent = P;
-    using Member = M;
-};
-
-template <auto MemberPtr>
-using GetParentType = typename GetMemberPointerTraits<decltype(MemberPtr)>::Parent;
-
-template <auto MemberPtr>
-using GetMemberType = typename GetMemberPointerTraits<decltype(MemberPtr)>::Member;
-
-template <auto MemberPtr, typename RealParentType = GetParentType<MemberPtr>>
-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>;
-    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>;
-    return *static_cast<const RealParentType*>(static_cast<const void*>(
-        static_cast<const uint8_t*>(static_cast<const void*>(member)) - Offset));
-}
-
-template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
-constexpr RealParentType* GetParentPointer(impl::GetMemberType<MemberPtr>* member) {
-    return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
-}
-
-template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
-constexpr RealParentType const* GetParentPointer(impl::GetMemberType<MemberPtr> const* member) {
-    return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
-}
-
-template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
-constexpr RealParentType& GetParentReference(impl::GetMemberType<MemberPtr>& member) {
-    return GetParentReference<MemberPtr, RealParentType>(std::addressof(member));
-}
-
-template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
-constexpr RealParentType const& GetParentReference(impl::GetMemberType<MemberPtr> const& member) {
-    return GetParentReference<MemberPtr, RealParentType>(std::addressof(member));
-}
-
-template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
-constexpr RealParentType* GetParentPointer(impl::GetMemberType<MemberPtr>& member) {
-    return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
-}
-
-template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
-constexpr RealParentType const* GetParentPointer(impl::GetMemberType<MemberPtr> const& member) {
-    return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
-}
-
-} // namespace Common

src/common/ring_buffer.h

@@ -19,14 +19,15 @@ namespace Common {
 /// SPSC ring buffer
 /// @tparam T            Element type
 /// @tparam capacity     Number of slots in ring buffer
-template <typename T, std::size_t capacity>
+/// @tparam granularity  Slot size in terms of number of elements
+template <typename T, std::size_t capacity, std::size_t granularity = 1>
 class RingBuffer {
-    /// A "slot" is made of a single `T`.
-    static constexpr std::size_t slot_size = sizeof(T);
+    /// A "slot" is made of `granularity` elements of `T`.
+    static constexpr std::size_t slot_size = granularity * sizeof(T);
     // T must be safely memcpy-able and have a trivial default constructor.
     static_assert(std::is_trivial_v<T>);
     // Ensure capacity is sensible.
-    static_assert(capacity < std::numeric_limits<std::size_t>::max() / 2);
+    static_assert(capacity < std::numeric_limits<std::size_t>::max() / 2 / granularity);
     static_assert((capacity & (capacity - 1)) == 0, "capacity must be a power of two");
     // Ensure lock-free.
     static_assert(std::atomic_size_t::is_always_lock_free);
@@ -46,7 +47,7 @@ public:
         const std::size_t second_copy = push_count - first_copy;
 
         const char* in = static_cast<const char*>(new_slots);
-        std::memcpy(m_data.data() + pos, in, first_copy * slot_size);
+        std::memcpy(m_data.data() + pos * granularity, in, first_copy * slot_size);
         in += first_copy * slot_size;
         std::memcpy(m_data.data(), in, second_copy * slot_size);
 
@@ -73,7 +74,7 @@ public:
         const std::size_t second_copy = pop_count - first_copy;
 
         char* out = static_cast<char*>(output);
-        std::memcpy(out, m_data.data() + pos, first_copy * slot_size);
+        std::memcpy(out, m_data.data() + pos * granularity, first_copy * slot_size);
         out += first_copy * slot_size;
         std::memcpy(out, m_data.data(), second_copy * slot_size);
 
@@ -83,9 +84,9 @@ public:
     }
 
     std::vector<T> Pop(std::size_t max_slots = ~std::size_t(0)) {
-        std::vector<T> out(std::min(max_slots, capacity));
-        const std::size_t count = Pop(out.data(), out.size());
-        out.resize(count);
+        std::vector<T> out(std::min(max_slots, capacity) * granularity);
+        const std::size_t count = Pop(out.data(), out.size() / granularity);
+        out.resize(count * granularity);
         return out;
     }
 
@@ -112,7 +113,7 @@ private:
     alignas(128) std::atomic_size_t m_write_index{0};
 #endif
 
-    std::array<T, capacity> m_data;
+    std::array<T, granularity * capacity> m_data;
 };
 
 } // namespace Common

src/common/scope_exit.h

@@ -49,9 +49,3 @@ ScopeExitHelper<Func> ScopeExit(Func&& func) {
  * \endcode
  */
 #define SCOPE_EXIT(body) auto CONCAT2(scope_exit_helper_, __LINE__) = detail::ScopeExit([&]() body)
-
-/**
- * This macro is similar to SCOPE_EXIT, except the object is caller managed. This is intended to be
- * used when the caller might want to cancel the ScopeExit.
- */
-#define SCOPE_GUARD(body) detail::ScopeExit([&]() body)

src/common/string_util.cpp

@@ -141,13 +141,27 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 }
 
 std::string UTF16ToUTF8(const std::u16string& input) {
+#ifdef _MSC_VER
+    // Workaround for missing char16_t/char32_t instantiations in MSVC2017
+    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
+    std::basic_string<__int16> tmp_buffer(input.cbegin(), input.cend());
+    return convert.to_bytes(tmp_buffer);
+#else
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
     return convert.to_bytes(input);
+#endif
 }
 
 std::u16string UTF8ToUTF16(const std::string& input) {
+#ifdef _MSC_VER
+    // Workaround for missing char16_t/char32_t instantiations in MSVC2017
+    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
+    auto tmp_buffer = convert.from_bytes(input);
+    return std::u16string(tmp_buffer.cbegin(), tmp_buffer.cend());
+#else
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
     return convert.from_bytes(input);
+#endif
 }
 
 #ifdef _WIN32

src/common/swap.h

@@ -394,7 +394,7 @@ public:
     template <typename S, typename T2, typename F2>
     friend S operator%(const S& p, const swapped_t v);
 
-    // Arithmetics + assignments
+    // Arithmetics + assignements
     template <typename S, typename T2, typename F2>
     friend S operator+=(const S& p, const swapped_t v);
 
@@ -451,7 +451,7 @@ S operator%(const S& i, const swap_struct_t<T, F> v) {
     return i % v.swap();
 }
 
-// Arithmetics + assignments
+// Arithmetics + assignements
 template <typename S, typename T, typename F>
 S& operator+=(S& i, const swap_struct_t<T, F> v) {
     i += v.swap();

src/common/thread_worker.cpp

@@ -1,58 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/thread.h"
-#include "common/thread_worker.h"
-
-namespace Common {
-
-ThreadWorker::ThreadWorker(std::size_t num_workers, const std::string& name) {
-    for (std::size_t i = 0; i < num_workers; ++i)
-        threads.emplace_back([this, thread_name{std::string{name}}] {
-            Common::SetCurrentThreadName(thread_name.c_str());
-
-            // Wait for first request
-            {
-                std::unique_lock lock{queue_mutex};
-                condition.wait(lock, [this] { return stop || !requests.empty(); });
-            }
-
-            while (true) {
-                std::function<void()> task;
-
-                {
-                    std::unique_lock lock{queue_mutex};
-                    condition.wait(lock, [this] { return stop || !requests.empty(); });
-                    if (stop || requests.empty()) {
-                        return;
-                    }
-                    task = std::move(requests.front());
-                    requests.pop();
-                }
-
-                task();
-            }
-        });
-}
-
-ThreadWorker::~ThreadWorker() {
-    {
-        std::unique_lock lock{queue_mutex};
-        stop = true;
-    }
-    condition.notify_all();
-    for (std::thread& thread : threads) {
-        thread.join();
-    }
-}
-
-void ThreadWorker::QueueWork(std::function<void()>&& work) {
-    {
-        std::unique_lock lock{queue_mutex};
-        requests.emplace(work);
-    }
-    condition.notify_one();
-}
-
-} // namespace Common

src/common/thread_worker.h

@@ -1,30 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <atomic>
-#include <functional>
-#include <mutex>
-#include <string>
-#include <vector>
-#include <queue>
-
-namespace Common {
-
-class ThreadWorker final {
-public:
-    explicit ThreadWorker(std::size_t num_workers, const std::string& name);
-    ~ThreadWorker();
-    void QueueWork(std::function<void()>&& work);
-
-private:
-    std::vector<std::thread> threads;
-    std::queue<std::function<void()>> requests;
-    std::mutex queue_mutex;
-    std::condition_variable condition;
-    std::atomic_bool stop{};
-};
-
-} // namespace Common

src/common/timer.cpp

@@ -0,0 +1,159 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <ctime>
+#include <fmt/format.h>
+#include "common/common_types.h"
+#include "common/string_util.h"
+#include "common/timer.h"
+
+namespace Common {
+
+std::chrono::milliseconds Timer::GetTimeMs() {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch());
+}
+
+// --------------------------------------------
+// Initiate, Start, Stop, and Update the time
+// --------------------------------------------
+
+// Set initial values for the class
+Timer::Timer() : m_LastTime(0), m_StartTime(0), m_Running(false) {
+    Update();
+}
+
+// Write the starting time
+void Timer::Start() {
+    m_StartTime = GetTimeMs();
+    m_Running = true;
+}
+
+// Stop the timer
+void Timer::Stop() {
+    // Write the final time
+    m_LastTime = GetTimeMs();
+    m_Running = false;
+}
+
+// Update the last time variable
+void Timer::Update() {
+    m_LastTime = GetTimeMs();
+    // TODO(ector) - QPF
+}
+
+// -------------------------------------
+// Get time difference and elapsed time
+// -------------------------------------
+
+// Get the number of milliseconds since the last Update()
+std::chrono::milliseconds Timer::GetTimeDifference() {
+    return GetTimeMs() - m_LastTime;
+}
+
+// Add the time difference since the last Update() to the starting time.
+// This is used to compensate for a paused game.
+void Timer::AddTimeDifference() {
+    m_StartTime += GetTimeDifference();
+}
+
+// Get the time elapsed since the Start()
+std::chrono::milliseconds Timer::GetTimeElapsed() {
+    // If we have not started yet, return 1 (because then I don't
+    // have to change the FPS calculation in CoreRerecording.cpp .
+    if (m_StartTime.count() == 0)
+        return std::chrono::milliseconds(1);
+
+    // Return the final timer time if the timer is stopped
+    if (!m_Running)
+        return (m_LastTime - m_StartTime);
+
+    return (GetTimeMs() - m_StartTime);
+}
+
+// Get the formatted time elapsed since the Start()
+std::string Timer::GetTimeElapsedFormatted() const {
+    // If we have not started yet, return zero
+    if (m_StartTime.count() == 0)
+        return "00:00:00:000";
+
+    // The number of milliseconds since the start.
+    // Use a different value if the timer is stopped.
+    std::chrono::milliseconds Milliseconds;
+    if (m_Running)
+        Milliseconds = GetTimeMs() - m_StartTime;
+    else
+        Milliseconds = m_LastTime - m_StartTime;
+    // Seconds
+    std::chrono::seconds Seconds = std::chrono::duration_cast<std::chrono::seconds>(Milliseconds);
+    // Minutes
+    std::chrono::minutes Minutes = std::chrono::duration_cast<std::chrono::minutes>(Milliseconds);
+    // Hours
+    std::chrono::hours Hours = std::chrono::duration_cast<std::chrono::hours>(Milliseconds);
+
+    std::string TmpStr = fmt::format("{:02}:{:02}:{:02}:{:03}", Hours.count(), Minutes.count() % 60,
+                                     Seconds.count() % 60, Milliseconds.count() % 1000);
+    return TmpStr;
+}
+
+// Get the number of seconds since January 1 1970
+std::chrono::seconds Timer::GetTimeSinceJan1970() {
+    return std::chrono::duration_cast<std::chrono::seconds>(GetTimeMs());
+}
+
+std::chrono::seconds Timer::GetLocalTimeSinceJan1970() {
+    time_t sysTime, tzDiff, tzDST;
+    struct tm* gmTime;
+
+    time(&sysTime);
+
+    // Account for DST where needed
+    gmTime = localtime(&sysTime);
+    if (gmTime->tm_isdst == 1)
+        tzDST = 3600;
+    else
+        tzDST = 0;
+
+    // Lazy way to get local time in sec
+    gmTime = gmtime(&sysTime);
+    tzDiff = sysTime - mktime(gmTime);
+
+    return std::chrono::seconds(sysTime + tzDiff + tzDST);
+}
+
+// Return the current time formatted as Minutes:Seconds:Milliseconds
+// in the form 00:00:000.
+std::string Timer::GetTimeFormatted() {
+    time_t sysTime;
+    struct tm* gmTime;
+    char tmp[13];
+
+    time(&sysTime);
+    gmTime = localtime(&sysTime);
+
+    strftime(tmp, 6, "%M:%S", gmTime);
+
+    u64 milliseconds = static_cast<u64>(GetTimeMs().count()) % 1000;
+    return fmt::format("{}:{:03}", tmp, milliseconds);
+}
+
+// Returns a timestamp with decimals for precise time comparisons
+// ----------------
+double Timer::GetDoubleTime() {
+    // Get continuous timestamp
+    auto tmp_seconds = static_cast<u64>(GetTimeSinceJan1970().count());
+    const auto ms = static_cast<double>(static_cast<u64>(GetTimeMs().count()) % 1000);
+
+    // Remove a few years. We only really want enough seconds to make
+    // sure that we are detecting actual actions, perhaps 60 seconds is
+    // enough really, but I leave a year of seconds anyway, in case the
+    // user's clock is incorrect or something like that.
+    tmp_seconds = tmp_seconds - (38 * 365 * 24 * 60 * 60);
+
+    // Make a smaller integer that fits in the double
+    const auto seconds = static_cast<u32>(tmp_seconds);
+    return seconds + ms;
+}
+
+} // Namespace Common

src/common/timer.h

@@ -0,0 +1,41 @@
+// 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 <chrono>
+#include <string>
+#include "common/common_types.h"
+
+namespace Common {
+class Timer {
+public:
+    Timer();
+
+    void Start();
+    void Stop();
+    void Update();
+
+    // The time difference is always returned in milliseconds, regardless of alternative internal
+    // representation
+    [[nodiscard]] std::chrono::milliseconds GetTimeDifference();
+    void AddTimeDifference();
+
+    [[nodiscard]] static std::chrono::seconds GetTimeSinceJan1970();
+    [[nodiscard]] static std::chrono::seconds GetLocalTimeSinceJan1970();
+    [[nodiscard]] static double GetDoubleTime();
+
+    [[nodiscard]] static std::string GetTimeFormatted();
+    [[nodiscard]] std::string GetTimeElapsedFormatted() const;
+    [[nodiscard]] std::chrono::milliseconds GetTimeElapsed();
+
+    [[nodiscard]] static std::chrono::milliseconds GetTimeMs();
+
+private:
+    std::chrono::milliseconds m_LastTime;
+    std::chrono::milliseconds m_StartTime;
+    bool m_Running;
+};
+
+} // Namespace Common

src/common/tiny_mt.h

@@ -1,250 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-#include "common/alignment.h"
-#include "common/common_types.h"
-
-namespace Common {
-
-// Implementation of TinyMT (mersenne twister RNG).
-// Like Nintendo, we will use the sample parameters.
-class TinyMT {
-public:
-    static constexpr std::size_t NumStateWords = 4;
-
-    struct State {
-        std::array<u32, NumStateWords> data{};
-    };
-
-private:
-    static constexpr u32 ParamMat1 = 0x8F7011EE;
-    static constexpr u32 ParamMat2 = 0xFC78FF1F;
-    static constexpr u32 ParamTmat = 0x3793FDFF;
-
-    static constexpr u32 ParamMult = 0x6C078965;
-    static constexpr u32 ParamPlus = 0x0019660D;
-    static constexpr u32 ParamXor = 0x5D588B65;
-
-    static constexpr u32 TopBitmask = 0x7FFFFFFF;
-
-    static constexpr int MinimumInitIterations = 8;
-    static constexpr int NumDiscardedInitOutputs = 8;
-
-    static constexpr u32 XorByShifted27(u32 value) {
-        return value ^ (value >> 27);
-    }
-
-    static constexpr u32 XorByShifted30(u32 value) {
-        return value ^ (value >> 30);
-    }
-
-private:
-    State state{};
-
-private:
-    // Internal API.
-    void FinalizeInitialization() {
-        const u32 state0 = this->state.data[0] & TopBitmask;
-        const u32 state1 = this->state.data[1];
-        const u32 state2 = this->state.data[2];
-        const u32 state3 = this->state.data[3];
-
-        if (state0 == 0 && state1 == 0 && state2 == 0 && state3 == 0) {
-            this->state.data[0] = 'T';
-            this->state.data[1] = 'I';
-            this->state.data[2] = 'N';
-            this->state.data[3] = 'Y';
-        }
-
-        for (int i = 0; i < NumDiscardedInitOutputs; i++) {
-            this->GenerateRandomU32();
-        }
-    }
-
-    u32 GenerateRandomU24() {
-        return (this->GenerateRandomU32() >> 8);
-    }
-
-    static void GenerateInitialValuePlus(TinyMT::State* state, int index, u32 value) {
-        u32& state0 = state->data[(index + 0) % NumStateWords];
-        u32& state1 = state->data[(index + 1) % NumStateWords];
-        u32& state2 = state->data[(index + 2) % NumStateWords];
-        u32& state3 = state->data[(index + 3) % NumStateWords];
-
-        const u32 x = XorByShifted27(state0 ^ state1 ^ state3) * ParamPlus;
-        const u32 y = x + index + value;
-
-        state0 = y;
-        state1 += x;
-        state2 += y;
-    }
-
-    static void GenerateInitialValueXor(TinyMT::State* state, int index) {
-        u32& state0 = state->data[(index + 0) % NumStateWords];
-        u32& state1 = state->data[(index + 1) % NumStateWords];
-        u32& state2 = state->data[(index + 2) % NumStateWords];
-        u32& state3 = state->data[(index + 3) % NumStateWords];
-
-        const u32 x = XorByShifted27(state0 + state1 + state3) * ParamXor;
-        const u32 y = x - index;
-
-        state0 = y;
-        state1 ^= x;
-        state2 ^= y;
-    }
-
-public:
-    constexpr TinyMT() = default;
-
-    // Public API.
-
-    // Initialization.
-    void Initialize(u32 seed) {
-        this->state.data[0] = seed;
-        this->state.data[1] = ParamMat1;
-        this->state.data[2] = ParamMat2;
-        this->state.data[3] = ParamTmat;
-
-        for (int i = 1; i < MinimumInitIterations; i++) {
-            const u32 mixed = XorByShifted30(this->state.data[(i - 1) % NumStateWords]);
-            this->state.data[i % NumStateWords] ^= mixed * ParamMult + i;
-        }
-
-        this->FinalizeInitialization();
-    }
-
-    void Initialize(const u32* seed, int seed_count) {
-        this->state.data[0] = 0;
-        this->state.data[1] = ParamMat1;
-        this->state.data[2] = ParamMat2;
-        this->state.data[3] = ParamTmat;
-
-        {
-            const int num_init_iterations = std::max(seed_count + 1, MinimumInitIterations) - 1;
-
-            GenerateInitialValuePlus(&this->state, 0, seed_count);
-
-            for (int i = 0; i < num_init_iterations; i++) {
-                GenerateInitialValuePlus(&this->state, (i + 1) % NumStateWords,
-                                         (i < seed_count) ? seed[i] : 0);
-            }
-
-            for (int i = 0; i < static_cast<int>(NumStateWords); i++) {
-                GenerateInitialValueXor(&this->state,
-                                        (i + 1 + num_init_iterations) % NumStateWords);
-            }
-        }
-
-        this->FinalizeInitialization();
-    }
-
-    // State management.
-    void GetState(TinyMT::State& out) const {
-        out.data = this->state.data;
-    }
-
-    void SetState(const TinyMT::State& state_) {
-        this->state.data = state_.data;
-    }
-
-    // Random generation.
-    void GenerateRandomBytes(void* dst, std::size_t size) {
-        const uintptr_t start = reinterpret_cast<uintptr_t>(dst);
-        const uintptr_t end = start + size;
-        const uintptr_t aligned_start = Common::AlignUp(start, 4);
-        const uintptr_t aligned_end = Common::AlignDown(end, 4);
-
-        // Make sure we're aligned.
-        if (start < aligned_start) {
-            const u32 rnd = this->GenerateRandomU32();
-            std::memcpy(dst, &rnd, aligned_start - start);
-        }
-
-        // Write as many aligned u32s as we can.
-        {
-            u32* cur_dst = reinterpret_cast<u32*>(aligned_start);
-            u32* const end_dst = reinterpret_cast<u32*>(aligned_end);
-
-            while (cur_dst < end_dst) {
-                *(cur_dst++) = this->GenerateRandomU32();
-            }
-        }
-
-        // Handle any leftover unaligned data.
-        if (aligned_end < end) {
-            const u32 rnd = this->GenerateRandomU32();
-            std::memcpy(reinterpret_cast<void*>(aligned_end), &rnd, end - aligned_end);
-        }
-    }
-
-    u32 GenerateRandomU32() {
-        // Advance state.
-        const u32 x0 =
-            (this->state.data[0] & TopBitmask) ^ this->state.data[1] ^ this->state.data[2];
-        const u32 y0 = this->state.data[3];
-        const u32 x1 = x0 ^ (x0 << 1);
-        const u32 y1 = y0 ^ (y0 >> 1) ^ x1;
-
-        const u32 state0 = this->state.data[1];
-        u32 state1 = this->state.data[2];
-        u32 state2 = x1 ^ (y1 << 10);
-        const u32 state3 = y1;
-
-        if ((y1 & 1) != 0) {
-            state1 ^= ParamMat1;
-            state2 ^= ParamMat2;
-        }
-
-        this->state.data[0] = state0;
-        this->state.data[1] = state1;
-        this->state.data[2] = state2;
-        this->state.data[3] = state3;
-
-        // Temper.
-        const u32 t1 = state0 + (state2 >> 8);
-        u32 t0 = state3 ^ t1;
-
-        if ((t1 & 1) != 0) {
-            t0 ^= ParamTmat;
-        }
-
-        return t0;
-    }
-
-    u64 GenerateRandomU64() {
-        const u32 lo = this->GenerateRandomU32();
-        const u32 hi = this->GenerateRandomU32();
-        return (u64{hi} << 32) | u64{lo};
-    }
-
-    float GenerateRandomF32() {
-        // Floats have 24 bits of mantissa.
-        constexpr u32 MantissaBits = 24;
-        return static_cast<float>(GenerateRandomU24()) * (1.0f / (1U << MantissaBits));
-    }
-
-    double GenerateRandomF64() {
-        // Doubles have 53 bits of mantissa.
-        // The smart way to generate 53 bits of random would be to use 32 bits
-        // from the first rnd32() call, and then 21 from the second.
-        // Nintendo does not. They use (32 - 5) = 27 bits from the first rnd32()
-        // call, and (32 - 6) bits from the second. We'll do what they do, but
-        // There's not a clear reason why.
-        constexpr u32 MantissaBits = 53;
-        constexpr u32 Shift1st = (64 - MantissaBits) / 2;
-        constexpr u32 Shift2nd = (64 - MantissaBits) - Shift1st;
-
-        const u32 first = (this->GenerateRandomU32() >> Shift1st);
-        const u32 second = (this->GenerateRandomU32() >> Shift2nd);
-
-        return (1.0 * first * (u64{1} << (32 - Shift2nd)) + second) *
-               (1.0 / (u64{1} << MantissaBits));
-    }
-};
-
-} // namespace Common