vk_memory_manager,vk_stream_buffer: Use persistent memory maps

yuzu originally mapped and unmapped when memory had to be used from the
host. This was originally used to reduce overhead on debugging tools
(renderdoc and Nsight), but at the same time it broke compatibility with
Nsight because this is not handled properly.

After measuring recently, there isn't much of a difference in capture
and replay performance on renderdoc by avoiding persistent memory maps.

This commit replaces previous memory maps with a persistent memory map,
but the API is kept intact to be able to rollback in case it's needed.

.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 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -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

@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s
 
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_QT_TRANSLATION=ON
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_QT_TRANSLATION=ON
 ninja
 
 ccache -s
@@ -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

@@ -4,11 +4,9 @@ parameters:
   version: ''
 
 steps:
-- script: choco install vulkan-sdk
-  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: mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_UNICORN=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

@@ -1,12 +1,15 @@
 [submodule "inih"]
     path = externals/inih/inih
-    url = https://github.com/benhoyt/inih.git
+    url = https://github.com/svn2github/inih
 [submodule "cubeb"]
     path = externals/cubeb
     url = https://github.com/kinetiknz/cubeb.git
 [submodule "dynarmic"]
     path = externals/dynarmic
     url = https://github.com/MerryMage/dynarmic.git
+[submodule "unicorn"]
+    path = externals/unicorn
+    url = https://github.com/yuzu-emu/unicorn
 [submodule "soundtouch"]
     path = externals/soundtouch
     url = https://github.com/citra-emu/ext-soundtouch.git
@@ -37,6 +40,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-mingw/docker.sh

@@ -4,8 +4,16 @@ cd /yuzu
 # override Travis CI unreasonable ccache size
 echo 'max_size = 3.0G' > "$HOME/.ccache/ccache.conf"
 
+# Dirty hack to trick unicorn makefile into believing we are in a MINGW system
+mv /bin/uname /bin/uname1 && echo -e '#!/bin/sh\necho MINGW64' >> /bin/uname
+chmod +x /bin/uname
+
+# Dirty hack to trick unicorn makefile into believing we have cmd
+echo '' >> /bin/cmd
+chmod +x /bin/cmd
+
 mkdir build && cd build
-cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
 ninja
 
 # Clean up the dirty hacks

.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

.travis/linux/docker.sh

@@ -3,7 +3,7 @@
 cd /yuzu
 
 mkdir build && cd build
-cmake .. -G Ninja -DYUZU_USE_QT_WEB_ENGINE=ON -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
+cmake .. -G Ninja -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -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
 ninja
 
 ccache -s

.travis/macos/build.sh

@@ -4,12 +4,13 @@ set -o pipefail
 
 export MACOSX_DEPLOYMENT_TARGET=10.14
 export Qt5_DIR=$(brew --prefix)/opt/qt5
+export UNICORNDIR=$(pwd)/externals/unicorn
 export PATH="/usr/local/opt/ccache/libexec:$PATH"
 
 # TODO: Build using ninja instead of make
 mkdir build && cd build
 cmake --version
-cmake .. -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
+cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
 make -j4
 
 ccache -s

CMakeLists.txt

@@ -18,7 +18,7 @@ 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_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
 
@@ -26,11 +26,9 @@ option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implemen
 
 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)
@@ -117,9 +115,6 @@ if (NOT DEFINED ARCHITECTURE)
 endif()
 message(STATUS "Target architecture: ${ARCHITECTURE}")
 
-if (UNIX)
-    add_definitions(-DYUZU_UNIX=1)
-endif()
 
 # Configure C++ standard
 # ===========================
@@ -164,14 +159,15 @@ 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"
+        "fmt               7.0         fmt/7.0.3"
     # can't use until https://github.com/bincrafters/community/issues/1173
         #"libzip            1.5         libzip/1.5.2@bincrafters/stable"
         "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 +194,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 +225,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 +243,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()
 
@@ -283,7 +263,6 @@ if (CONAN_REQUIRED_LIBS)
         libzip:with_openssl=False
         libzip:enable_windows_crypto=False
     )
-
     conan_check(VERSION 1.24.0 REQUIRED)
     # Add the bincrafters remote
     conan_add_remote(NAME bincrafters
@@ -318,17 +297,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,145 +354,85 @@ 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()
-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)
 
+# If unicorn isn't found, msvc -> download bundled unicorn; everyone else -> build external
+if (YUZU_USE_BUNDLED_UNICORN)
+    if (MSVC)
+        message(STATUS "unicorn not found, falling back to bundled")
+        # Detect toolchain and platform
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+            set(UNICORN_VER "unicorn-yuzu")
+        else()
+            message(FATAL_ERROR "No bundled Unicorn binaries for your toolchain. Disable YUZU_USE_BUNDLED_UNICORN and provide your own.")
+        endif()
+
+        if (DEFINED UNICORN_VER)
+            download_bundled_external("unicorn/" ${UNICORN_VER} UNICORN_PREFIX)
+        endif()
+
+        if (DEFINED UNICORN_VER)
+            download_bundled_external("unicorn/" ${UNICORN_VER} UNICORN_PREFIX)
+        endif()
+
+        set(UNICORN_FOUND YES)
+        set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
+        set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/lib/x64/unicorn_dynload.lib" CACHE PATH "Path to Unicorn library" FORCE)
+        set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/lib/x64/" CACHE PATH "Path to unicorn.dll" FORCE)
+    else()
+        message(STATUS "unicorn not found, falling back to externals")
+        if (MINGW)
+            set(UNICORN_LIB_NAME "unicorn.a")
+        else()
+            set(UNICORN_LIB_NAME "libunicorn.a")
+        endif()
+
+        set(UNICORN_FOUND YES)
+        set(UNICORN_PREFIX ${PROJECT_SOURCE_DIR}/externals/unicorn)
+        set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/${UNICORN_LIB_NAME}" CACHE PATH "Path to Unicorn library" FORCE)
+        set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
+        set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/" CACHE PATH "Path to unicorn dynamic library" FORCE)
+
+        find_package(PythonInterp 2.7 REQUIRED)
+
+        if (MINGW)
+            # Intentionally call the unicorn makefile directly instead of using make.sh so that we can override the
+            # UNAME_S makefile variable to MINGW. This way we don't have to hack at the uname binary to build
+            # Additionally, overriding DO_WINDOWS_EXPORT prevents unicorn from patching the static unicorn.a by using msvc and cmd,
+            # which are both things we don't have in a mingw cross compiling environment.
+            add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
+                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" CC=x86_64-w64-mingw32-gcc AR=x86_64-w64-mingw32-gcc-ar RANLIB=x86_64-w64-mingw32-gcc-ranlib make UNAME_S=MINGW DO_WINDOWS_EXPORT=0
+                WORKING_DIRECTORY ${UNICORN_PREFIX}
+            )
+        else()
+            add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
+                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh macos-universal-no
+                WORKING_DIRECTORY ${UNICORN_PREFIX}
+            )
+        endif()
+
+        # ALL makes this custom target build every time
+        # but it won't actually build if LIBUNICORN_LIBRARY is up to date
+        add_custom_target(unicorn-build ALL
+            DEPENDS ${LIBUNICORN_LIBRARY}
+        )
+        unset(UNICORN_LIB_NAME)
+    endif()
+else()
+    find_package(Unicorn REQUIRED)
+endif()
+
+if (UNICORN_FOUND)
+    add_library(unicorn INTERFACE)
+    add_dependencies(unicorn unicorn-build)
+    target_link_libraries(unicorn INTERFACE "${LIBUNICORN_LIBRARY}")
+    target_include_directories(unicorn INTERFACE "${LIBUNICORN_INCLUDE_DIR}")
+else()
+    message(FATAL_ERROR "Could not find or build unicorn which is required.")
+endif()
+
 # Platform-specific library requirements
 # ======================================
 

CMakeModules/CopyYuzuFFmpegDeps.cmake

@@ -1,6 +0,0 @@
-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})
-endfunction(copy_yuzu_FFmpeg_deps)

CMakeModules/CopyYuzuUnicornDeps.cmake

@@ -0,0 +1,9 @@
+function(copy_yuzu_unicorn_deps target_dir)
+    include(WindowsCopyFiles)
+    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
+    windows_copy_files(${target_dir} ${UNICORN_DLL_DIR} ${DLL_DEST}
+        libgcc_s_seh-1.dll
+        libwinpthread-1.dll
+        unicorn.dll
+    )
+endfunction(copy_yuzu_unicorn_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/default/style.qss

@@ -1,7 +1,3 @@
-QAbstractSpinBox {
-    min-height: 19px;
-}
-
 QPushButton#TogglableStatusBarButton {
     color: #959595;
     border: 1px solid transparent;
@@ -39,10 +35,10 @@ QPushButton#RendererStatusBarButton:!checked {
 }
 
 QPushButton#buttonRefreshDevices {
-    min-width: 21px;
-    min-height: 21px;
-    max-width: 21px;
-    max-height: 21px;
+    min-width: 20px;
+    min-height: 20px;
+    max-width: 20px;
+    max-height: 20px;
 }
 
 QWidget#bottomPerGameInput,
@@ -75,7 +71,7 @@ QWidget#middleControllerApplet {
 
 QWidget#topPerGameInput QComboBox,
 QWidget#middleControllerApplet QComboBox {
-    width: 120px;
+    width: 123px;
 }
 
 QWidget#connectedControllers {

dist/qt_themes/qdarkstyle/style.qss

@@ -99,19 +99,12 @@ QGroupBox::indicator:unchecked:disabled {
 }
 
 QRadioButton {
-    color: #eff0f1;
-    spacing: 3px;
-    padding: 0px;
-    border: none;
+    spacing: 5px;
     outline: none;
+    color: #eff0f1;
     margin-bottom: 2px;
 }
 
-QGroupBox QRadioButton {
-    padding-left: 0px;
-    padding-right: 7px;
-}
-
 QRadioButton:disabled {
     color: #76797C;
 }
@@ -529,12 +522,13 @@ QToolButton#qt_toolbar_ext_button {
 
 QPushButton {
     color: #eff0f1;
-    border: 1px solid #54575B;
+    border-width: 1px;
+    border-color: #54575B;
+    border-style: solid;
+    padding: 6px 4px;
     border-radius: 2px;
-    padding: 5px 0px 5px 0px;
     outline: none;
     min-width: 100px;
-    min-height: 13px;
     background-color: #232629;
 }
 
@@ -559,9 +553,8 @@ QComboBox {
     selection-background-color: #3daee9;
     border: 1px solid #54575B;
     border-radius: 2px;
-    padding: 0px 4px 0px 4px;
-    min-width: 60px;
-    min-height: 23px;
+    padding: 4px 6px;
+    min-width: 75px;
     background-color: #232629;
 }
 
@@ -615,26 +608,26 @@ QComboBox::down-arrow:focus {
 }
 
 QAbstractSpinBox {
+    padding: 4px 6px;
     border: 1px solid #54575B;
     background-color: #232629;
     color: #eff0f1;
     border-radius: 2px;
-    min-width: 52px;
-    min-height: 23px;
+    min-width: 75px;
 }
 
 QAbstractSpinBox:up-button {
     background-color: transparent;
     subcontrol-origin: border;
     subcontrol-position: center right;
-    left: -2px;
+    left: -6px;
 }
 
 QAbstractSpinBox:down-button {
     background-color: transparent;
     subcontrol-origin: border;
     subcontrol-position: center left;
-    right: -2px;
+    right: -6px;
 }
 
 QAbstractSpinBox::up-arrow,
@@ -1284,33 +1277,41 @@ QPushButton#RendererStatusBarButton:!checked {
 }
 
 QPushButton#buttonRefreshDevices {
-    min-width: 23px;
-    min-height: 23px;
-    max-width: 23px;
-    max-height: 23px;
+    min-width: 24px;
+    min-height: 24px;
+    max-width: 24px;
+    max-height: 24px;
     padding: 0px 0px;
 }
 
 QSpinBox#spinboxLStickRange,
-QSpinBox#spinboxRStickRange,
-QSpinBox#vibrationSpinPlayer1,
-QSpinBox#vibrationSpinPlayer2,
-QSpinBox#vibrationSpinPlayer3,
-QSpinBox#vibrationSpinPlayer4,
-QSpinBox#vibrationSpinPlayer5,
-QSpinBox#vibrationSpinPlayer6,
-QSpinBox#vibrationSpinPlayer7,
-QSpinBox#vibrationSpinPlayer8 {
-    min-width: 68px;
+QSpinBox#spinboxRStickRange {
+    padding: 4px 0px 5px 0px;
+    min-width: 63px;
+}
+
+QSpinBox#vibrationSpin {
+    padding: 4px 0px 5px 0px;
+    min-width: 63px;
+}
+
+QSpinBox#spinboxLStickRange:up-button,
+QSpinBox#spinboxRStickRange:up-button,
+QSpinBox#vibrationSpin:up-button {
+    left: -2px;
+}
+
+QSpinBox#spinboxLStickRange:down-button,
+QSpinBox#spinboxRStickRange:down-button,
+QSpinBox#vibrationSpin:down-button {
+    right: -1px;
 }
 
-QDialog#ConfigureVibration QGroupBox::indicator,
 QGroupBox#motionGroup::indicator,
 QGroupBox#vibrationGroup::indicator {
     margin-left: 0px;
 }
 
-QDialog#ConfigureVibration QGroupBox::title,
 QGroupBox#motionGroup::title,
 QGroupBox#vibrationGroup::title {
     spacing: 2px;
@@ -1339,7 +1340,16 @@ QWidget#middleControllerApplet {
 
 QWidget#topPerGameInput QComboBox,
 QWidget#middleControllerApplet QComboBox {
-    width: 120px;
+    width: 119px;
+}
+
+QRadioButton#radioDocked {
+    margin-left: -3px;
+}
+
+
+QRadioButton#radioUndocked {
+    margin-right: 5px;
 }
 
 QWidget#connectedControllers {

dist/qt_themes/qdarkstyle_midnight_blue/style.qss

@@ -172,8 +172,8 @@ QCheckBox {
   color: #F0F0F0;
   spacing: 4px;
   outline: none;
-  padding-top: 2px;
-  padding-bottom: 2px;
+  padding-top: 4px;
+  padding-bottom: 4px;
 }
 
 QCheckBox:focus {
@@ -239,7 +239,7 @@ QGroupBox {
   border: 1px solid #32414B;
   border-radius: 4px;
   margin-top: 12px;
-  padding: 2px;
+  padding: 4px;
 }
 
 QGroupBox::title {
@@ -247,7 +247,7 @@ QGroupBox::title {
   subcontrol-position: top left;
   padding-left: 3px;
   padding-right: 5px;
-  padding-top: 2px;
+  padding-top: 4px;
 }
 
 QGroupBox::indicator {
@@ -298,11 +298,6 @@ QRadioButton {
   outline: none;
 }
 
-QGroupBox QRadioButton {
-  padding-left: 0px;
-  padding-right: 7px;
-}
-
 QRadioButton:focus {
   border: none;
 }
@@ -326,6 +321,7 @@ QRadioButton QWidget {
 QRadioButton::indicator {
   border: none;
   outline: none;
+  margin-left: 4px;
   height: 16px;
   width: 16px;
 }
@@ -789,8 +785,14 @@ QAbstractSpinBox {
   background-color: #19232D;
   border: 1px solid #32414B;
   color: #F0F0F0;
+  /* This fixes 103, 111 */
+  padding-top: 2px;
+  /* This fixes 103, 111 */
+  padding-bottom: 2px;
+  padding-left: 4px;
+  padding-right: 4px;
   border-radius: 4px;
-  min-height: 19px;
+  /* min-width: 5px; removed to fix 109 */
 }
 
 QAbstractSpinBox:up-button {
@@ -995,11 +997,10 @@ QPushButton {
   border: 1px solid #32414B;
   color: #F0F0F0;
   border-radius: 4px;
-  padding: 3px 0px 3px 0px;
+  padding: 3px;
   outline: none;
   /* Issue #194 - Special case of QPushButton inside dialogs, for better UI */
   min-width: 80px;
-  min-height: 13px;
 }
 
 QPushButton:disabled {
@@ -1007,14 +1008,14 @@ QPushButton:disabled {
   border: 1px solid #32414B;
   color: #787878;
   border-radius: 4px;
-  padding: 3px 0px 3px 0px;
+  padding: 3px;
 }
 
 QPushButton:checked {
   background-color: #32414B;
   border: 1px solid #32414B;
   border-radius: 4px;
-  padding: 3px 0px 3px 0px;
+  padding: 3px;
   outline: none;
 }
 
@@ -1023,7 +1024,7 @@ QPushButton:checked:disabled {
   border: 1px solid #32414B;
   color: #787878;
   border-radius: 4px;
-  padding: 3px 0px 3px 0px;
+  padding: 3px;
   outline: none;
 }
 
@@ -1196,9 +1197,15 @@ QComboBox {
   border: 1px solid #32414B;
   border-radius: 4px;
   selection-background-color: #1464A0;
-  padding: 0px 4px 0px 4px;
-  min-width: 60px;
-  min-height: 19px;
+  padding-left: 4px;
+  padding-right: 36px;
+  /* 4 + 16*2 See scrollbar size */
+  /* Fixes #103, #111 */
+  min-height: 1.5em;
+  /* padding-top: 2px;     removed to fix #132 */
+  /* padding-bottom: 2px;  removed to fix #132 */
+  /* min-width: 75px;      removed to fix #109 */
+  /* Needed to remove indicator - fix #132 */
 }
 
 QComboBox QAbstractItemView {
@@ -1257,6 +1264,10 @@ QComboBox::item:alternate {
   background: #19232D;
 }
 
+QComboBox::item:checked {
+  font-weight: bold;
+}
+
 QComboBox::item:selected {
   border: 0px solid transparent;
 }
@@ -2187,40 +2198,29 @@ QPushButton#RendererStatusBarButton:!checked {
 }
 
 QPushButton#buttonRefreshDevices {
-  min-width: 19px;
-  min-height: 19px;
-  max-width: 19px;
-  max-height: 19px;
+  min-width: 20px;
+  min-height: 20px;
+  max-width: 20px;
+  max-height: 20px;
   padding: 0px 0px;
 }
 
 QSpinBox#spinboxLStickRange,
-QSpinBox#spinboxRStickRange,
-QSpinBox#vibrationSpinPlayer1,
-QSpinBox#vibrationSpinPlayer2,
-QSpinBox#vibrationSpinPlayer3,
-QSpinBox#vibrationSpinPlayer4,
-QSpinBox#vibrationSpinPlayer5,
-QSpinBox#vibrationSpinPlayer6,
-QSpinBox#vibrationSpinPlayer7,
-QSpinBox#vibrationSpinPlayer8 {
-  min-width: 68px;
+QSpinBox#spinboxRStickRange {
+  min-width: 38px;
 }
 
-QDialog#ConfigureVibration QGroupBox::indicator,
 QGroupBox#motionGroup::indicator,
 QGroupBox#vibrationGroup::indicator {
   margin-left: 0px;
 }
 
-QDialog#ConfigureVibration QGroupBox,
 QWidget#bottomPerGameInput QGroupBox#motionGroup,
 QWidget#bottomPerGameInput QGroupBox#vibrationGroup,
 QWidget#bottomPerGameInput QGroupBox#inputConfigGroup {
   padding: 0px;
 }
 
-QDialog#ConfigureVibration QGroupBox::title,
 QGroupBox#motionGroup::title,
 QGroupBox#vibrationGroup::title {
   spacing: 2px;
@@ -2260,7 +2260,26 @@ QWidget#middleControllerApplet {
 
 QWidget#topPerGameInput QComboBox,
 QWidget#middleControllerApplet QComboBox {
-  width: 120px;
+  padding-right: 2px;
+  width: 127px;
+}
+
+QGroupBox#handheldGroup {
+  padding-left: 0px;
+}
+
+QRadioButton#radioDocked {
+  margin-left: -1px;
+  padding-left: 0px;
+}
+
+QRadioButton#radioDocked::indicator {
+  margin-left: 0px;
+}
+
+
+QRadioButton#radioUndocked {
+  margin-right: 2px;
 }
 
 QWidget#connectedControllers {
@@ -2333,7 +2352,7 @@ QCheckBox#checkboxPlayer5Connected,
 QCheckBox#checkboxPlayer6Connected,
 QCheckBox#checkboxPlayer7Connected,
 QCheckBox#checkboxPlayer8Connected {
-  spacing: 0px;
+    spacing: 0px;
 }
 
 QWidget#connectedControllers QLabel {
@@ -2408,7 +2427,7 @@ QCheckBox#checkboxPlayer7Connected::indicator,
 QCheckBox#checkboxPlayer8Connected::indicator {
   width: 14px;
   height: 14px;
-  margin-left: 0px;
+  margin-left: 2px;
 }
 
 QWidget#Player1LEDs QCheckBox::indicator:checked,

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)
@@ -71,20 +73,17 @@ if (NOT LIBZIP_FOUND)
 endif()
 
 if (ENABLE_WEB_SERVICE)
-    find_package(OpenSSL 1.1)
-    if (OPENSSL_FOUND)
-        set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
-    else()
-        # LibreSSL
-        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
-        set(OPENSSLDIR "/etc/ssl/")
-        add_subdirectory(libressl EXCLUDE_FROM_ALL)
-        target_include_directories(ssl INTERFACE ./libressl/include)
-        target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
-        get_directory_property(OPENSSL_LIBRARIES
-            DIRECTORY libressl
-            DEFINITION OPENSSL_LIBS)
-    endif()
+    # LibreSSL
+    set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
+    add_subdirectory(libressl EXCLUDE_FROM_ALL)
+    target_include_directories(ssl INTERFACE ./libressl/include)
+    target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
+    get_directory_property(OPENSSL_LIBRARIES
+        DIRECTORY libressl
+        DEFINITION OPENSSL_LIBS)
+
+    # lurlparser
+    add_subdirectory(lurlparser EXCLUDE_FROM_ALL)
 
     # httplib
     add_library(httplib INTERFACE)

externals/find-modules/FindFFmpeg.cmake

@@ -1,187 +0,0 @@
-# FindFFmpeg
-# ----------
-#
-# Copyright 2019 Citra Emulator Project
-# Licensed under GPLv2 or any later version
-#
-# Find the native FFmpeg includes and libraries
-#
-# This module defines the following variables:
-#
-#  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
-)
-
-foreach(c ${_FFmpeg_ALL_COMPONENTS})
-  unset(_FFmpeg_DEPS_${c})
-endforeach()
-unset(_FFmpeg_ALL_COMPONENTS)
-unset(_FFmpeg_REQUIRED_VARS)

externals/httplib/README.md

@@ -1,4 +1,4 @@
-From https://github.com/yhirose/cpp-httplib/tree/ff5677ad197947177c158fe857caff4f0e242045 with https://github.com/yhirose/cpp-httplib/pull/701
+From https://github.com/yhirose/cpp-httplib/tree/fce8e6fefdab4ad48bc5b25c98e5ebfda4f3cf53
 
 MIT License
 

externals/lurlparser/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_library(lurlparser
+        LUrlParser.cpp
+        LUrlParser.h
+)
+
+create_target_directory_groups(lurlparser)
+
+target_include_directories(lurlparser INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

externals/lurlparser/LUrlParser.cpp

@@ -0,0 +1,265 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "LUrlParser.h"
+
+#include <algorithm>
+#include <cstring>
+#include <stdlib.h>
+
+// check if the scheme name is valid
+static bool IsSchemeValid( const std::string& SchemeName )
+{
+    for ( auto c : SchemeName  )
+    {
+        if ( !isalpha( c ) && c != '+' && c != '-' && c != '.' ) return false;
+    }
+
+    return true;
+}
+
+bool LUrlParser::clParseURL::GetPort( int* OutPort ) const
+{
+    if ( !IsValid() ) { return false; }
+
+    int Port = atoi( m_Port.c_str() );
+
+    if ( Port <= 0 || Port > 65535 ) { return false; }
+
+    if ( OutPort ) { *OutPort = Port; }
+
+    return true;
+}
+
+// based on RFC 1738 and RFC 3986
+LUrlParser::clParseURL LUrlParser::clParseURL::ParseURL( const std::string& URL )
+{
+    LUrlParser::clParseURL Result;
+
+    const char* CurrentString = URL.c_str();
+
+    /*
+     *	<scheme>:<scheme-specific-part>
+     *	<scheme> := [a-z\+\-\.]+
+     *	For resiliency, programs interpreting URLs should treat upper case letters as equivalent to lower case in scheme names
+     */
+
+    // try to read scheme
+    {
+        const char* LocalString = strchr( CurrentString, ':' );
+
+        if ( !LocalString )
+        {
+            return clParseURL( LUrlParserError_NoUrlCharacter );
+        }
+
+        // save the scheme name
+        Result.m_Scheme = std::string( CurrentString, LocalString - CurrentString );
+
+        if ( !IsSchemeValid( Result.m_Scheme ) )
+        {
+            return clParseURL( LUrlParserError_InvalidSchemeName );
+        }
+
+        // scheme should be lowercase
+        std::transform( Result.m_Scheme.begin(), Result.m_Scheme.end(), Result.m_Scheme.begin(), ::tolower );
+
+        // skip ':'
+        CurrentString = LocalString+1;
+    }
+
+    /*
+     *	//<user>:<password>@<host>:<port>/<url-path>
+     *	any ":", "@" and "/" must be normalized
+     */
+
+    // skip "//"
+    if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+    if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+
+    // check if the user name and password are specified
+    bool bHasUserName = false;
+
+    const char* LocalString = CurrentString;
+
+    while ( *LocalString )
+    {
+        if ( *LocalString == '@' )
+        {
+            // user name and password are specified
+            bHasUserName = true;
+            break;
+        }
+        else if ( *LocalString == '/' )
+        {
+            // end of <host>:<port> specification
+            bHasUserName = false;
+            break;
+        }
+
+        LocalString++;
+    }
+
+    // user name and password
+    LocalString = CurrentString;
+
+    if ( bHasUserName )
+    {
+        // read user name
+        while ( *LocalString && *LocalString != ':' && *LocalString != '@' ) LocalString++;
+
+        Result.m_UserName = std::string( CurrentString, LocalString - CurrentString );
+
+        // proceed with the current pointer
+        CurrentString = LocalString;
+
+        if ( *CurrentString == ':' )
+        {
+            // skip ':'
+            CurrentString++;
+
+            // read password
+            LocalString = CurrentString;
+
+            while ( *LocalString && *LocalString != '@' ) LocalString++;
+
+            Result.m_Password = std::string( CurrentString, LocalString - CurrentString );
+
+            CurrentString = LocalString;
+        }
+
+        // skip '@'
+        if ( *CurrentString != '@' )
+        {
+            return clParseURL( LUrlParserError_NoAtSign );
+        }
+
+        CurrentString++;
+    }
+
+    bool bHasBracket = ( *CurrentString == '[' );
+
+    // go ahead, read the host name
+    LocalString = CurrentString;
+
+    while ( *LocalString )
+    {
+        if ( bHasBracket && *LocalString == ']' )
+        {
+            // end of IPv6 address
+            LocalString++;
+            break;
+        }
+        else if ( !bHasBracket && ( *LocalString == ':' || *LocalString == '/' ) )
+        {
+            // port number is specified
+            break;
+        }
+
+        LocalString++;
+    }
+
+    Result.m_Host = std::string( CurrentString, LocalString - CurrentString );
+
+    CurrentString = LocalString;
+
+    // is port number specified?
+    if ( *CurrentString == ':' )
+    {
+        CurrentString++;
+
+        // read port number
+        LocalString = CurrentString;
+
+        while ( *LocalString && *LocalString != '/' ) LocalString++;
+
+        Result.m_Port = std::string( CurrentString, LocalString - CurrentString );
+
+        CurrentString = LocalString;
+    }
+
+    // end of string
+    if ( !*CurrentString )
+    {
+        Result.m_ErrorCode = LUrlParserError_Ok;
+
+        return Result;
+    }
+
+    // skip '/'
+    if ( *CurrentString != '/' )
+    {
+        return clParseURL( LUrlParserError_NoSlash );
+    }
+
+    CurrentString++;
+
+    // parse the path
+    LocalString = CurrentString;
+
+    while ( *LocalString && *LocalString != '#' && *LocalString != '?' ) LocalString++;
+
+    Result.m_Path = std::string( CurrentString, LocalString - CurrentString );
+
+    CurrentString = LocalString;
+
+    // check for query
+    if ( *CurrentString == '?' )
+    {
+        // skip '?'
+        CurrentString++;
+
+        // read query
+        LocalString = CurrentString;
+
+        while ( *LocalString && *LocalString != '#' ) LocalString++;
+
+        Result.m_Query = std::string( CurrentString, LocalString - CurrentString );
+
+        CurrentString = LocalString;
+    }
+
+    // check for fragment
+    if ( *CurrentString == '#' )
+    {
+        // skip '#'
+        CurrentString++;
+
+        // read fragment
+        LocalString = CurrentString;
+
+        while ( *LocalString ) LocalString++;
+
+        Result.m_Fragment = std::string( CurrentString, LocalString - CurrentString );
+
+        CurrentString = LocalString;
+    }
+
+    Result.m_ErrorCode = LUrlParserError_Ok;
+
+    return Result;
+}

externals/lurlparser/LUrlParser.h

@@ -0,0 +1,78 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace LUrlParser
+{
+enum LUrlParserError
+{
+    LUrlParserError_Ok = 0,
+    LUrlParserError_Uninitialized = 1,
+    LUrlParserError_NoUrlCharacter = 2,
+    LUrlParserError_InvalidSchemeName = 3,
+    LUrlParserError_NoDoubleSlash = 4,
+    LUrlParserError_NoAtSign = 5,
+    LUrlParserError_UnexpectedEndOfLine = 6,
+    LUrlParserError_NoSlash = 7,
+};
+
+class clParseURL
+{
+public:
+    LUrlParserError m_ErrorCode;
+    std::string m_Scheme;
+    std::string m_Host;
+    std::string m_Port;
+    std::string m_Path;
+    std::string m_Query;
+    std::string m_Fragment;
+    std::string m_UserName;
+    std::string m_Password;
+
+    clParseURL()
+            : m_ErrorCode( LUrlParserError_Uninitialized )
+    {}
+
+    /// return 'true' if the parsing was successful
+    bool IsValid() const { return m_ErrorCode == LUrlParserError_Ok; }
+
+    /// helper to convert the port number to int, return 'true' if the port is valid (within the 0..65535 range)
+    bool GetPort( int* OutPort ) const;
+
+    /// parse the URL
+    static clParseURL ParseURL( const std::string& URL );
+
+private:
+    explicit clParseURL( LUrlParserError ErrorCode )
+            : m_ErrorCode( ErrorCode )
+    {}
+};
+
+} // namespace LUrlParser

externals/lurlparser/README.md

@@ -0,0 +1,19 @@
+From https://github.com/corporateshark/LUrlParser/commit/455d5e2d27e3946f11ad0328fee9ee2628e6a8e2
+
+MIT License
+
+===
+
+Lightweight URL & URI parser (RFC 1738, RFC 3986)
+
+(C) Sergey Kosarevsky, 2015
+
+@corporateshark sk@linderdaum.com
+
+http://www.linderdaum.com
+
+http://blog.linderdaum.com
+
+=============================
+
+A tiny and lightweight URL & URI parser (RFC 1738, RFC 3986) written in C++.

externals/microprofile/microprofile.h

@@ -902,10 +902,8 @@ inline uint16_t MicroProfileGetGroupIndex(MicroProfileToken t)
 #include <windows.h>
 #define snprintf _snprintf
 
-#ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable: 4244)
-#endif
 int64_t MicroProfileTicksPerSecondCpu()
 {
     static int64_t nTicksPerSecond = 0;
@@ -948,11 +946,7 @@ typedef HANDLE MicroProfileThread;
 DWORD _stdcall ThreadTrampoline(void* pFunc)
 {
     MicroProfileThreadFunc F = (MicroProfileThreadFunc)pFunc;
-
-    // The return value of F will always return a void*, however, this is for
-    // compatibility with pthreads. The underlying "address" of the pointer
-    // is always a 32-bit value, so this cast is safe to perform.
-    return static_cast<DWORD>(reinterpret_cast<uint64_t>(F(0)));
+    return (uint32_t)F(0);
 }
 
 inline void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
@@ -1748,10 +1742,10 @@ void MicroProfileFlip()
                             }
                         }
                     }
-                    for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
+                    for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUPS; ++i)
                     {
-                        pLog->nGroupTicks[j] += nGroupTicks[j];
-                        pFrameGroup[j] += nGroupTicks[j];
+                        pLog->nGroupTicks[i] += nGroupTicks[i];
+                        pFrameGroup[i] += nGroupTicks[i];
                     }
                     pLog->nStackPos = nStackPos;
                 }
@@ -3334,7 +3328,7 @@ bool MicroProfileIsLocalThread(uint32_t nThreadId)
 #endif
 #else
 
-bool MicroProfileIsLocalThread([[maybe_unused]] uint32_t nThreadId) { return false; }
+bool MicroProfileIsLocalThread(uint32_t nThreadId){return false;}
 void MicroProfileStopContextSwitchTrace(){}
 void MicroProfileStartContextSwitchTrace(){}
 
@@ -3582,7 +3576,7 @@ int MicroProfileGetGpuTickReference(int64_t* pOutCpu, int64_t* pOutGpu)
 
 #undef S
 
-#ifdef _MSC_VER
+#ifdef _WIN32
 #pragma warning(pop)
 #endif
 

src/CMakeLists.txt

@@ -32,6 +32,7 @@ if (MSVC)
     # /Zc:inline          - Let codegen omit inline functions in object files
     # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
     add_compile_options(
+        /W3
         /MP
         /Zi
         /Zo
@@ -42,18 +43,6 @@ if (MSVC)
         /Zc:externConstexpr
         /Zc:inline
         /Zc:throwingNew
-
-        # 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
@@ -64,20 +53,12 @@ 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
-        -Wno-invalid-offsetof
         -Wno-unused-parameter
     )
 
@@ -132,6 +113,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
@@ -53,14 +51,9 @@ if (NOT MSVC)
         -Werror=implicit-fallthrough
         -Werror=reorder
         -Werror=sign-compare
-        -Werror=shadow
-        -Werror=unused-parameter
+        -Werror=unused-but-set-parameter
+        -Werror=unused-but-set-variable
         -Werror=unused-variable
-
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
-
-        -Wno-sign-conversion
     )
 endif()
 

src/audio_core/algorithm/filter.cpp

@@ -31,8 +31,8 @@ Filter Filter::LowPass(double cutoff, double Q) {
 
 Filter::Filter() : Filter(1.0, 0.0, 0.0, 1.0, 0.0, 0.0) {}
 
-Filter::Filter(double a0_, double a1_, double a2_, double b0_, double b1_, double b2_)
-    : a1(a1_ / a0_), a2(a2_ / a0_), b0(b0_ / a0_), b1(b1_ / a0_), b2(b2_ / a0_) {}
+Filter::Filter(double a0, double a1, double a2, double b0, double b1, double b2)
+    : a1(a1 / a0), a2(a2 / a0), b0(b0 / a0), b1(b1 / a0), b2(b2 / a0) {}
 
 void Filter::Process(std::vector<s16>& signal) {
     const std::size_t num_frames = signal.size() / 2;
@@ -69,7 +69,7 @@ CascadingFilter CascadingFilter::LowPass(double cutoff, std::size_t cascade_size
 }
 
 CascadingFilter::CascadingFilter() = default;
-CascadingFilter::CascadingFilter(std::vector<Filter> filters_) : filters(std::move(filters_)) {}
+CascadingFilter::CascadingFilter(std::vector<Filter> filters) : filters(std::move(filters)) {}
 
 void CascadingFilter::Process(std::vector<s16>& signal) {
     for (auto& filter : filters) {

src/audio_core/algorithm/filter.h

@@ -25,7 +25,7 @@ public:
     /// Passthrough filter.
     Filter();
 
-    Filter(double a0_, double a1_, double a2_, double b0_, double b1_, double b2_);
+    Filter(double a0, double a1, double a2, double b0, double b1, double b2);
 
     void Process(std::vector<s16>& signal);
 
@@ -51,7 +51,7 @@ public:
     /// Passthrough.
     CascadingFilter();
 
-    explicit CascadingFilter(std::vector<Filter> filters_);
+    explicit CascadingFilter(std::vector<Filter> filters);
 
     void Process(std::vector<s16>& signal);
 

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_out.cpp

@@ -43,10 +43,6 @@ std::vector<Buffer::Tag> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream,
     return stream->GetTagsAndReleaseBuffers(max_count);
 }
 
-std::vector<Buffer::Tag> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream) {
-    return stream->GetTagsAndReleaseBuffers();
-}
-
 void AudioOut::StartStream(StreamPtr stream) {
     stream->Play();
 }

src/audio_core/audio_out.h

@@ -31,9 +31,6 @@ public:
     /// Returns a vector of recently released buffers specified by tag for the specified stream
     std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(StreamPtr stream, std::size_t max_count);
 
-    /// Returns a vector of all recently released buffers specified by tag for the specified stream
-    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(StreamPtr stream);
-
     /// Starts an audio stream for playback
     void StartStream(StreamPtr stream);
 

src/audio_core/audio_renderer.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <limits>
 #include <vector>
 
 #include "audio_core/audio_out.h"
@@ -11,81 +10,32 @@
 #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"
 
-namespace {
-[[nodiscard]] static constexpr s16 ClampToS16(s32 value) {
-    return static_cast<s16>(std::clamp(value, s32{std::numeric_limits<s16>::min()},
-                                       s32{std::numeric_limits<s16>::max()}));
-}
-
-[[nodiscard]] static constexpr s16 Mix2To1(s16 l_channel, s16 r_channel) {
-    // Mix 50% from left and 50% from right channel
-    constexpr float l_mix_amount = 50.0f / 100.0f;
-    constexpr float r_mix_amount = 50.0f / 100.0f;
-    return ClampToS16(static_cast<s32>((static_cast<float>(l_channel) * l_mix_amount) +
-                                       (static_cast<float>(r_channel) * r_mix_amount)));
-}
-
-[[nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(s16 fl_channel, s16 fr_channel,
-                                                            s16 fc_channel,
-                                                            [[maybe_unused]] s16 lf_channel,
-                                                            s16 bl_channel, s16 br_channel) {
-    // Front channels are mixed 36.94%, Center channels are mixed to be 26.12% & the back channels
-    // are mixed to be 36.94%
-
-    constexpr float front_mix_amount = 36.94f / 100.0f;
-    constexpr float center_mix_amount = 26.12f / 100.0f;
-    constexpr float back_mix_amount = 36.94f / 100.0f;
-
-    // Mix 50% from left and 50% from right channel
-    const auto left = front_mix_amount * static_cast<float>(fl_channel) +
-                      center_mix_amount * static_cast<float>(fc_channel) +
-                      back_mix_amount * static_cast<float>(bl_channel);
-
-    const auto right = front_mix_amount * static_cast<float>(fr_channel) +
-                       center_mix_amount * static_cast<float>(fc_channel) +
-                       back_mix_amount * static_cast<float>(br_channel);
-
-    return {ClampToS16(static_cast<s32>(left)), ClampToS16(static_cast<s32>(right))};
-}
-
-[[nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2WithCoefficients(
-    s16 fl_channel, s16 fr_channel, s16 fc_channel, s16 lf_channel, s16 bl_channel, s16 br_channel,
-    const std::array<float_le, 4>& coeff) {
-    const auto left =
-        static_cast<float>(fl_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[0];
-
-    const auto right =
-        static_cast<float>(fr_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[0];
-
-    return {ClampToS16(static_cast<s32>(left)), ClampToS16(static_cast<s32>(right))};
-}
-
-} // 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_},
       command_generator(worker_params, voice_context, mix_context, splitter_context, effect_context,
-                        memory) {
+                        memory),
+      temp_mix_buffer(AudioCommon::TOTAL_TEMP_MIX_SIZE) {
     behavior_info.SetUserRevision(params.revision);
     splitter_context.Initialize(behavior_info, params.splitter_count,
                                 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);
@@ -112,6 +62,10 @@ Stream::State AudioRenderer::GetStreamState() const {
     return stream->GetState();
 }
 
+static constexpr s16 ClampToS16(s32 value) {
+    return static_cast<s16>(std::clamp(value, -32768, 32767));
+}
+
 ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params,
                                               std::vector<u8>& output_params) {
 
@@ -150,8 +104,8 @@ ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_param
         }
     }
 
-    const auto mix_result = info_updater.UpdateMixes(mix_context, worker_params.mix_buffer_count,
-                                                     splitter_context, effect_context);
+    auto mix_result = info_updater.UpdateMixes(mix_context, worker_params.mix_buffer_count,
+                                               splitter_context, effect_context);
 
     if (mix_result.IsError()) {
         LOG_ERROR(Audio, "Failed to update mix parameters");
@@ -240,22 +194,20 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
         for (std::size_t i = 0; i < BUFFER_SIZE; i++) {
             if (channel_count == 1) {
                 const auto sample = ClampToS16(mix_buffers[0][i]);
-
-                // Place sample in all channels
-                for (u32 channel = 0; channel < stream_channel_count; channel++) {
-                    buffer[i * stream_channel_count + channel] = sample;
+                buffer[i * stream_channel_count + 0] = sample;
+                if (stream_channel_count > 1) {
+                    buffer[i * stream_channel_count + 1] = sample;
                 }
-
                 if (stream_channel_count == 6) {
-                    // Output stream has a LF channel, mute it!
-                    buffer[i * stream_channel_count + 3] = 0;
+                    buffer[i * stream_channel_count + 2] = sample;
+                    buffer[i * stream_channel_count + 4] = sample;
+                    buffer[i * stream_channel_count + 5] = sample;
                 }
-
             } else if (channel_count == 2) {
                 const auto l_sample = ClampToS16(mix_buffers[0][i]);
                 const auto r_sample = ClampToS16(mix_buffers[1][i]);
                 if (stream_channel_count == 1) {
-                    buffer[i * stream_channel_count + 0] = Mix2To1(l_sample, r_sample);
+                    buffer[i * stream_channel_count + 0] = l_sample;
                 } else if (stream_channel_count == 2) {
                     buffer[i * stream_channel_count + 0] = l_sample;
                     buffer[i * stream_channel_count + 1] = r_sample;
@@ -263,8 +215,8 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                     buffer[i * stream_channel_count + 0] = l_sample;
                     buffer[i * stream_channel_count + 1] = r_sample;
 
-                    // Combine both left and right channels to the center channel
-                    buffer[i * stream_channel_count + 2] = Mix2To1(l_sample, r_sample);
+                    buffer[i * stream_channel_count + 2] =
+                        ClampToS16((static_cast<s32>(l_sample) + static_cast<s32>(r_sample)) / 2);
 
                     buffer[i * stream_channel_count + 4] = l_sample;
                     buffer[i * stream_channel_count + 5] = r_sample;
@@ -279,25 +231,17 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                 const auto br_sample = ClampToS16(mix_buffers[5][i]);
 
                 if (stream_channel_count == 1) {
-                    // Games seem to ignore the center channel half the time, we use the front left
-                    // and right channel for mixing as that's where majority of the audio goes
-                    buffer[i * stream_channel_count + 0] = Mix2To1(fl_sample, fr_sample);
+                    buffer[i * stream_channel_count + 0] = fc_sample;
                 } else if (stream_channel_count == 2) {
-                    // Mix all channels into 2 channels
-                    if (sink_context.HasDownMixingCoefficients()) {
-                        const auto [left, right] = Mix6To2WithCoefficients(
-                            fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
-                            sink_context.GetDownmixCoefficients());
-                        buffer[i * stream_channel_count + 0] = left;
-                        buffer[i * stream_channel_count + 1] = right;
-                    } else {
-                        const auto [left, right] = Mix6To2(fl_sample, fr_sample, fc_sample,
-                                                           lf_sample, bl_sample, br_sample);
-                        buffer[i * stream_channel_count + 0] = left;
-                        buffer[i * stream_channel_count + 1] = right;
-                    }
+                    buffer[i * stream_channel_count + 0] =
+                        static_cast<s16>(0.3694f * static_cast<float>(fl_sample) +
+                                         0.2612f * static_cast<float>(fc_sample) +
+                                         0.3694f * static_cast<float>(bl_sample));
+                    buffer[i * stream_channel_count + 1] =
+                        static_cast<s16>(0.3694f * static_cast<float>(fr_sample) +
+                                         0.2612f * static_cast<float>(fc_sample) +
+                                         0.3694f * static_cast<float>(br_sample));
                 } else if (stream_channel_count == 6) {
-                    // Pass through
                     buffer[i * stream_channel_count + 0] = fl_sample;
                     buffer[i * stream_channel_count + 1] = fr_sample;
                     buffer[i * stream_channel_count + 2] = fc_sample;
@@ -315,7 +259,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
 }
 
 void AudioRenderer::ReleaseAndQueueBuffers() {
-    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream)};
+    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream, 2)};
     for (const auto& tag : released_buffers) {
         QueueMixedBuffer(tag);
     }

src/audio_core/audio_renderer.h

@@ -27,35 +27,46 @@ namespace Core::Timing {
 class CoreTiming;
 }
 
+namespace Kernel {
+class WritableEvent;
+}
+
 namespace Core::Memory {
 class Memory;
 }
 
 namespace AudioCore {
-using DSPStateHolder = std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>;
+using DSPStateHolder = std::array<VoiceState*, 6>;
 
 class AudioOut;
 
+struct RendererInfo {
+    u64_le elasped_frame_count{};
+    INSERT_PADDING_WORDS(2);
+};
+static_assert(sizeof(RendererInfo) == 0x10, "RendererInfo is an invalid size");
+
 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,
-                                                 std::vector<u8>& output_params);
+    ResultCode UpdateAudioRenderer(const std::vector<u8>& input_params,
+                                   std::vector<u8>& output_params);
     void QueueMixedBuffer(Buffer::Tag tag);
     void ReleaseAndQueueBuffers();
-    [[nodiscard]] u32 GetSampleRate() const;
-    [[nodiscard]] u32 GetSampleCount() const;
-    [[nodiscard]] u32 GetMixBufferCount() const;
-    [[nodiscard]] Stream::State GetStreamState() const;
+    u32 GetSampleRate() const;
+    u32 GetSampleCount() const;
+    u32 GetMixBufferCount() const;
+    Stream::State GetStreamState() const;
 
 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;
@@ -68,6 +79,7 @@ private:
     Core::Memory::Memory& memory;
     CommandGenerator command_generator;
     std::size_t elapsed_frame_count{};
+    std::vector<s32> temp_mix_buffer{};
 };
 
 } // namespace AudioCore

src/audio_core/behavior_info.h

@@ -43,22 +43,22 @@ public:
     void ClearError();
     void UpdateFlags(u64_le dest_flags);
     void SetUserRevision(u32_le revision);
-    [[nodiscard]] u32_le GetUserRevision() const;
-    [[nodiscard]] u32_le GetProcessRevision() const;
+    u32_le GetUserRevision() const;
+    u32_le GetProcessRevision() const;
 
-    [[nodiscard]] bool IsAdpcmLoopContextBugFixed() const;
-    [[nodiscard]] bool IsSplitterSupported() const;
-    [[nodiscard]] bool IsLongSizePreDelaySupported() const;
-    [[nodiscard]] bool IsAudioRendererProcessingTimeLimit80PercentSupported() const;
-    [[nodiscard]] bool IsAudioRendererProcessingTimeLimit75PercentSupported() const;
-    [[nodiscard]] bool IsAudioRendererProcessingTimeLimit70PercentSupported() const;
-    [[nodiscard]] bool IsElapsedFrameCountSupported() const;
-    [[nodiscard]] bool IsMemoryPoolForceMappingEnabled() const;
-    [[nodiscard]] bool IsFlushVoiceWaveBuffersSupported() const;
-    [[nodiscard]] bool IsVoicePlayedSampleCountResetAtLoopPointSupported() const;
-    [[nodiscard]] bool IsVoicePitchAndSrcSkippedSupported() const;
-    [[nodiscard]] bool IsMixInParameterDirtyOnlyUpdateSupported() const;
-    [[nodiscard]] bool IsSplitterBugFixed() const;
+    bool IsAdpcmLoopContextBugFixed() const;
+    bool IsSplitterSupported() const;
+    bool IsLongSizePreDelaySupported() const;
+    bool IsAudioRendererProcessingTimeLimit80PercentSupported() const;
+    bool IsAudioRendererProcessingTimeLimit75PercentSupported() const;
+    bool IsAudioRendererProcessingTimeLimit70PercentSupported() const;
+    bool IsElapsedFrameCountSupported() const;
+    bool IsMemoryPoolForceMappingEnabled() const;
+    bool IsFlushVoiceWaveBuffersSupported() const;
+    bool IsVoicePlayedSampleCountResetAtLoopPointSupported() const;
+    bool IsVoicePitchAndSrcSkippedSupported() const;
+    bool IsMixInParameterDirtyOnlyUpdateSupported() const;
+    bool IsSplitterBugFixed() const;
     void CopyErrorInfo(OutParams& dst);
 
 private:

src/audio_core/buffer.h

@@ -18,7 +18,7 @@ class Buffer {
 public:
     using Tag = u64;
 
-    Buffer(Tag tag_, std::vector<s16>&& samples_) : tag{tag_}, samples{std::move(samples_)} {}
+    Buffer(Tag tag, std::vector<s16>&& samples) : tag{tag}, samples{std::move(samples)} {}
 
     /// Returns the raw audio data for the buffer
     std::vector<s16>& GetSamples() {

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,162 +65,14 @@ 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_,
-                                   VoiceContext& voice_context_, MixContext& mix_context_,
-                                   SplitterContext& splitter_context_,
-                                   EffectContext& effect_context_, Core::Memory::Memory& memory_)
-    : worker_params(worker_params_), voice_context(voice_context_), mix_context(mix_context_),
-      splitter_context(splitter_context_), effect_context(effect_context_), memory(memory_),
+CommandGenerator::CommandGenerator(AudioCommon::AudioRendererParameter& worker_params,
+                                   VoiceContext& voice_context, MixContext& mix_context,
+                                   SplitterContext& splitter_context, EffectContext& effect_context,
+                                   Core::Memory::Memory& memory)
+    : worker_params(worker_params), voice_context(voice_context), mix_context(mix_context),
+      splitter_context(splitter_context), effect_context(effect_context), memory(memory),
       mix_buffer((worker_params.mix_buffer_count + AudioCommon::MAX_CHANNEL_COUNT) *
                  worker_params.sample_count),
       sample_buffer(MIX_BUFFER_SIZE),
@@ -419,8 +255,7 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo
 
 void CommandGenerator::GenerateBiquadFilterCommandForVoice(ServerVoiceInfo& voice_info,
                                                            VoiceState& dsp_state,
-                                                           [[maybe_unused]] s32 mix_buffer_count,
-                                                           [[maybe_unused]] s32 channel) {
+                                                           s32 mix_buffer_count, s32 channel) {
     for (std::size_t i = 0; i < AudioCommon::MAX_BIQUAD_FILTERS; i++) {
         const auto& in_params = voice_info.GetInParams();
         auto& biquad_filter = in_params.biquad_filter[i];
@@ -435,19 +270,17 @@ 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);
     }
 }
 
-void CommandGenerator::GenerateBiquadFilterCommand([[maybe_unused]] s32 mix_buffer_id,
-                                                   const BiquadFilterParameter& params,
-                                                   std::array<s64, 2>& state,
-                                                   std::size_t input_offset,
-                                                   std::size_t output_offset, s32 sample_count,
-                                                   s32 node_id) {
+void AudioCore::CommandGenerator::GenerateBiquadFilterCommand(
+    s32 mix_buffer, const BiquadFilterParameter& params, std::array<s64, 2>& state,
+    std::size_t input_offset, std::size_t output_offset, s32 sample_count, s32 node_id) {
     if (dumping_frame) {
         LOG_DEBUG(Audio,
                   "(DSP_TRACE) GenerateBiquadFilterCommand node_id={}, "
@@ -539,53 +372,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 +521,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);
@@ -1044,8 +714,7 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
 }
 
 s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                  s32 sample_count, [[maybe_unused]] s32 channel,
-                                  std::size_t mix_offset) {
+                                  s32 sample_count, s32 channel, std::size_t mix_offset) {
     const auto& in_params = voice_info.GetInParams();
     const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
     if (wave_buffer.buffer_address == 0) {

src/audio_core/command_generator.h

@@ -21,16 +21,14 @@ class ServerMixInfo;
 class EffectContext;
 class EffectBase;
 struct AuxInfoDSP;
-struct I3dl2ReverbParams;
-struct I3dl2ReverbState;
 using MixVolumeBuffer = std::array<float, AudioCommon::MAX_MIX_BUFFERS>;
 
 class CommandGenerator {
 public:
-    explicit CommandGenerator(AudioCommon::AudioRendererParameter& worker_params_,
-                              VoiceContext& voice_context_, MixContext& mix_context_,
-                              SplitterContext& splitter_context_, EffectContext& effect_context_,
-                              Core::Memory::Memory& memory_);
+    explicit CommandGenerator(AudioCommon::AudioRendererParameter& worker_params,
+                              VoiceContext& voice_context, MixContext& mix_context,
+                              SplitterContext& splitter_context, EffectContext& effect_context,
+                              Core::Memory::Memory& memory);
     ~CommandGenerator();
 
     void ClearMixBuffers();
@@ -41,13 +39,13 @@ public:
     void PreCommand();
     void PostCommand();
 
-    [[nodiscard]] s32* GetChannelMixBuffer(s32 channel);
-    [[nodiscard]] const s32* GetChannelMixBuffer(s32 channel) const;
-    [[nodiscard]] s32* GetMixBuffer(std::size_t index);
-    [[nodiscard]] const s32* GetMixBuffer(std::size_t index) const;
-    [[nodiscard]] std::size_t GetMixChannelBufferOffset(s32 channel) const;
+    s32* GetChannelMixBuffer(s32 channel);
+    const s32* GetChannelMixBuffer(s32 channel) const;
+    s32* GetMixBuffer(std::size_t index);
+    const s32* GetMixBuffer(std::size_t index) const;
+    std::size_t GetMixChannelBufferOffset(s32 channel) const;
 
-    [[nodiscard]] std::size_t GetTotalMixBufferCount() const;
+    std::size_t GetTotalMixBufferCount() const;
 
 private:
     void GenerateDataSourceCommand(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 channel);
@@ -75,16 +73,13 @@ private:
     void GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
     void GenerateBiquadFilterEffectCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
     void GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
-    [[nodiscard]] ServerSplitterDestinationData* GetDestinationData(s32 splitter_id, s32 index);
+    ServerSplitterDestinationData* GetDestinationData(s32 splitter_id, s32 index);
 
     s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples, const s32* data,
                        u32 sample_count, u32 write_offset, u32 write_count);
     s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples, s32* out_data,
                       u32 sample_count, u32 read_offset, u32 read_count);
 
-    void InitializeI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
-                               std::vector<u8>& work_buffer);
-    void UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state, bool should_clear);
     // DSP Code
     s32 DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
                     s32 channel, std::size_t mix_offset);

src/audio_core/common.h

@@ -22,7 +22,7 @@ constexpr std::size_t MAX_CHANNEL_COUNT = 6;
 constexpr std::size_t MAX_WAVE_BUFFERS = 4;
 constexpr std::size_t MAX_SAMPLE_HISTORY = 4;
 constexpr u32 STREAM_SAMPLE_RATE = 48000;
-constexpr u32 STREAM_NUM_CHANNELS = 2;
+constexpr u32 STREAM_NUM_CHANNELS = 6;
 constexpr s32 NO_SPLITTER = -1;
 constexpr s32 NO_MIX = 0x7fffffff;
 constexpr s32 NO_FINAL_MIX = std::numeric_limits<s32>::min();
@@ -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/cubeb_sink.cpp

@@ -21,16 +21,15 @@ namespace AudioCore {
 
 class CubebSinkStream final : public SinkStream {
 public:
-    CubebSinkStream(cubeb* ctx_, u32 sample_rate, u32 num_channels_, cubeb_devid output_device,
+    CubebSinkStream(cubeb* ctx, u32 sample_rate, u32 num_channels_, cubeb_devid output_device,
                     const std::string& name)
-        : ctx{ctx_}, num_channels{std::min(num_channels_, 6u)}, time_stretch{sample_rate,
-                                                                             num_channels} {
+        : ctx{ctx}, num_channels{std::min(num_channels_, 6u)}, time_stretch{sample_rate,
+                                                                            num_channels} {
 
         cubeb_stream_params params{};
         params.rate = sample_rate;
         params.channels = num_channels;
         params.format = CUBEB_SAMPLE_S16NE;
-        params.prefs = CUBEB_STREAM_PREF_PERSIST;
         switch (num_channels) {
         case 1:
             params.layout = CUBEB_LAYOUT_MONO;
@@ -193,9 +192,8 @@ SinkStream& CubebSink::AcquireSinkStream(u32 sample_rate, u32 num_channels,
     return *sink_streams.back();
 }
 
-long CubebSinkStream::DataCallback([[maybe_unused]] cubeb_stream* stream, void* user_data,
-                                   [[maybe_unused]] const void* input_buffer, void* output_buffer,
-                                   long num_frames) {
+long CubebSinkStream::DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
+                                   void* output_buffer, long num_frames) {
     auto* impl = static_cast<CubebSinkStream*>(user_data);
     auto* buffer = static_cast<u8*>(output_buffer);
 
@@ -238,9 +236,7 @@ long CubebSinkStream::DataCallback([[maybe_unused]] cubeb_stream* stream, void*
     return num_frames;
 }
 
-void CubebSinkStream::StateCallback([[maybe_unused]] cubeb_stream* stream,
-                                    [[maybe_unused]] void* user_data,
-                                    [[maybe_unused]] cubeb_state state) {}
+void CubebSinkStream::StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state) {}
 
 std::vector<std::string> ListCubebSinkDevices() {
     std::vector<std::string> device_list;

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

@@ -12,7 +12,7 @@ bool ValidChannelCountForEffect(s32 channel_count) {
 }
 } // namespace
 
-EffectContext::EffectContext(std::size_t effect_count_) : effect_count(effect_count_) {
+EffectContext::EffectContext(std::size_t effect_count) : effect_count(effect_count) {
     effects.reserve(effect_count);
     std::generate_n(std::back_inserter(effects), effect_count,
                     [] { return std::make_unique<EffectStubbed>(); });
@@ -61,13 +61,13 @@ const EffectBase* EffectContext::GetInfo(std::size_t i) const {
     return effects.at(i).get();
 }
 
-EffectStubbed::EffectStubbed() : EffectBase(EffectType::Invalid) {}
+EffectStubbed::EffectStubbed() : EffectBase::EffectBase(EffectType::Invalid) {}
 EffectStubbed::~EffectStubbed() = default;
 
-void EffectStubbed::Update([[maybe_unused]] EffectInfo::InParams& in_params) {}
+void EffectStubbed::Update(EffectInfo::InParams& in_params) {}
 void EffectStubbed::UpdateForCommandGeneration() {}
 
-EffectBase::EffectBase(EffectType effect_type_) : effect_type(effect_type_) {}
+EffectBase::EffectBase(EffectType effect_type) : effect_type(effect_type) {}
 EffectBase::~EffectBase() = default;
 
 UsageState EffectBase::GetUsage() const {
@@ -90,47 +90,33 @@ 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() : EffectGeneric::EffectGeneric(EffectType::I3dl2Reverb) {}
 EffectI3dl2Reverb::~EffectI3dl2Reverb() = default;
 
 void EffectI3dl2Reverb::Update(EffectInfo::InParams& in_params) {
-    auto& params = GetParams();
+    auto& internal_params = GetParams();
     const auto* reverb_params = reinterpret_cast<I3dl2ReverbParams*>(in_params.raw.data());
     if (!ValidChannelCountForEffect(reverb_params->max_channels)) {
         UNREACHABLE_MSG("Invalid reverb max channel count {}", reverb_params->max_channels);
         return;
     }
 
-    const auto last_status = params.status;
+    const auto last_status = internal_params.status;
     mix_id = in_params.mix_id;
     processing_order = in_params.processing_order;
-    params = *reverb_params;
+    internal_params = *reverb_params;
     if (!ValidChannelCountForEffect(reverb_params->channel_count)) {
-        params.channel_count = params.max_channels;
+        internal_params.channel_count = internal_params.max_channels;
     }
     enabled = in_params.is_enabled;
     if (last_status != ParameterStatus::Updated) {
-        params.status = last_status;
+        internal_params.status = last_status;
     }
 
     if (in_params.is_new || skipped) {
         usage = UsageState::Initialized;
-        params.status = ParameterStatus::Initialized;
+        internal_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,23 +129,15 @@ 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() : EffectGeneric::EffectGeneric(EffectType::BiquadFilter) {}
 EffectBiquadFilter::~EffectBiquadFilter() = default;
 
 void EffectBiquadFilter::Update(EffectInfo::InParams& in_params) {
-    auto& params = GetParams();
+    auto& internal_params = GetParams();
     const auto* biquad_params = reinterpret_cast<BiquadFilterParams*>(in_params.raw.data());
     mix_id = in_params.mix_id;
     processing_order = in_params.processing_order;
-    params = *biquad_params;
+    internal_params = *biquad_params;
     enabled = in_params.is_enabled;
 }
 
@@ -172,7 +150,7 @@ void EffectBiquadFilter::UpdateForCommandGeneration() {
     GetParams().status = ParameterStatus::Updated;
 }
 
-EffectAuxInfo::EffectAuxInfo() : EffectGeneric(EffectType::Aux) {}
+EffectAuxInfo::EffectAuxInfo() : EffectGeneric::EffectGeneric(EffectType::Aux) {}
 EffectAuxInfo::~EffectAuxInfo() = default;
 
 void EffectAuxInfo::Update(EffectInfo::InParams& in_params) {
@@ -222,32 +200,32 @@ VAddr EffectAuxInfo::GetRecvBuffer() const {
     return recv_buffer;
 }
 
-EffectDelay::EffectDelay() : EffectGeneric(EffectType::Delay) {}
+EffectDelay::EffectDelay() : EffectGeneric::EffectGeneric(EffectType::Delay) {}
 EffectDelay::~EffectDelay() = default;
 
 void EffectDelay::Update(EffectInfo::InParams& in_params) {
     const auto* delay_params = reinterpret_cast<DelayParams*>(in_params.raw.data());
-    auto& params = GetParams();
+    auto& internal_params = GetParams();
     if (!ValidChannelCountForEffect(delay_params->max_channels)) {
         return;
     }
 
-    const auto last_status = params.status;
+    const auto last_status = internal_params.status;
     mix_id = in_params.mix_id;
     processing_order = in_params.processing_order;
-    params = *delay_params;
+    internal_params = *delay_params;
     if (!ValidChannelCountForEffect(delay_params->channels)) {
-        params.channels = params.max_channels;
+        internal_params.channels = internal_params.max_channels;
     }
     enabled = in_params.is_enabled;
 
     if (last_status != ParameterStatus::Updated) {
-        params.status = last_status;
+        internal_params.status = last_status;
     }
 
     if (in_params.is_new || skipped) {
         usage = UsageState::Initialized;
-        params.status = ParameterStatus::Initialized;
+        internal_params.status = ParameterStatus::Initialized;
         skipped = in_params.buffer_address == 0 || in_params.buffer_size == 0;
     }
 }
@@ -261,7 +239,7 @@ void EffectDelay::UpdateForCommandGeneration() {
     GetParams().status = ParameterStatus::Updated;
 }
 
-EffectBufferMixer::EffectBufferMixer() : EffectGeneric(EffectType::BufferMixer) {}
+EffectBufferMixer::EffectBufferMixer() : EffectGeneric::EffectGeneric(EffectType::BufferMixer) {}
 EffectBufferMixer::~EffectBufferMixer() = default;
 
 void EffectBufferMixer::Update(EffectInfo::InParams& in_params) {
@@ -279,32 +257,32 @@ void EffectBufferMixer::UpdateForCommandGeneration() {
     }
 }
 
-EffectReverb::EffectReverb() : EffectGeneric(EffectType::Reverb) {}
+EffectReverb::EffectReverb() : EffectGeneric::EffectGeneric(EffectType::Reverb) {}
 EffectReverb::~EffectReverb() = default;
 
 void EffectReverb::Update(EffectInfo::InParams& in_params) {
     const auto* reverb_params = reinterpret_cast<ReverbParams*>(in_params.raw.data());
-    auto& params = GetParams();
+    auto& internal_params = GetParams();
     if (!ValidChannelCountForEffect(reverb_params->max_channels)) {
         return;
     }
 
-    const auto last_status = params.status;
+    const auto last_status = internal_params.status;
     mix_id = in_params.mix_id;
     processing_order = in_params.processing_order;
-    params = *reverb_params;
+    internal_params = *reverb_params;
     if (!ValidChannelCountForEffect(reverb_params->channels)) {
-        params.channels = params.max_channels;
+        internal_params.channels = internal_params.max_channels;
     }
     enabled = in_params.is_enabled;
 
     if (last_status != ParameterStatus::Updated) {
-        params.status = last_status;
+        internal_params.status = last_status;
     }
 
     if (in_params.is_new || skipped) {
         usage = UsageState::Initialized;
-        params.status = ParameterStatus::Initialized;
+        internal_params.status = ParameterStatus::Initialized;
         skipped = in_params.buffer_address == 0 || in_params.buffer_size == 0;
     }
 }

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"
@@ -185,18 +184,16 @@ struct AuxAddress {
 
 class EffectBase {
 public:
-    explicit EffectBase(EffectType effect_type_);
+    explicit EffectBase(EffectType effect_type);
     virtual ~EffectBase();
 
     virtual void Update(EffectInfo::InParams& in_params) = 0;
     virtual void UpdateForCommandGeneration() = 0;
-    [[nodiscard]] UsageState GetUsage() const;
-    [[nodiscard]] EffectType GetType() const;
-    [[nodiscard]] bool IsEnabled() const;
-    [[nodiscard]] s32 GetMixID() const;
-    [[nodiscard]] s32 GetProcessingOrder() const;
-    [[nodiscard]] std::vector<u8>& GetWorkBuffer();
-    [[nodiscard]] const std::vector<u8>& GetWorkBuffer() const;
+    UsageState GetUsage() const;
+    EffectType GetType() const;
+    bool IsEnabled() const;
+    s32 GetMixID() const;
+    s32 GetProcessingOrder() const;
 
 protected:
     UsageState usage{UsageState::Invalid};
@@ -204,19 +201,18 @@ protected:
     s32 mix_id{};
     s32 processing_order{};
     bool enabled = false;
-    std::vector<u8> work_buffer{};
 };
 
 template <typename T>
 class EffectGeneric : public EffectBase {
 public:
-    explicit EffectGeneric(EffectType effect_type_) : EffectBase(effect_type_) {}
+    explicit EffectGeneric(EffectType effect_type) : EffectBase(effect_type) {}
 
     T& GetParams() {
         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> {
@@ -286,10 +257,10 @@ public:
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
-    [[nodiscard]] VAddr GetSendInfo() const;
-    [[nodiscard]] VAddr GetSendBuffer() const;
-    [[nodiscard]] VAddr GetRecvInfo() const;
-    [[nodiscard]] VAddr GetRecvBuffer() const;
+    VAddr GetSendInfo() const;
+    VAddr GetSendBuffer() const;
+    VAddr GetRecvInfo() const;
+    VAddr GetRecvBuffer() const;
 
 private:
     VAddr send_info{};
@@ -335,13 +306,13 @@ private:
 
 class EffectContext {
 public:
-    explicit EffectContext(std::size_t effect_count_);
+    explicit EffectContext(std::size_t effect_count);
     ~EffectContext();
 
-    [[nodiscard]] std::size_t GetCount() const;
-    [[nodiscard]] EffectBase* GetInfo(std::size_t i);
-    [[nodiscard]] EffectBase* RetargetEffect(std::size_t i, EffectType effect);
-    [[nodiscard]] const EffectBase* GetInfo(std::size_t i) const;
+    std::size_t GetCount() const;
+    EffectBase* GetInfo(std::size_t i);
+    EffectBase* RetargetEffect(std::size_t i, EffectType effect);
+    const EffectBase* GetInfo(std::size_t i) const;
 
 private:
     std::size_t effect_count{};

src/audio_core/info_updater.cpp

@@ -14,9 +14,9 @@
 
 namespace AudioCore {
 
-InfoUpdater::InfoUpdater(const std::vector<u8>& in_params_, std::vector<u8>& out_params_,
-                         BehaviorInfo& behavior_info_)
-    : in_params(in_params_), out_params(out_params_), behavior_info(behavior_info_) {
+InfoUpdater::InfoUpdater(const std::vector<u8>& in_params, std::vector<u8>& out_params,
+                         BehaviorInfo& behavior_info)
+    : in_params(in_params), out_params(out_params), behavior_info(behavior_info) {
     ASSERT(
         AudioCommon::CanConsumeBuffer(in_params.size(), 0, sizeof(AudioCommon::UpdateDataHeader)));
     std::memcpy(&input_header, in_params.data(), sizeof(AudioCommon::UpdateDataHeader));
@@ -135,8 +135,8 @@ bool InfoUpdater::UpdateVoiceChannelResources(VoiceContext& voice_context) {
 }
 
 bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
-                               [[maybe_unused]] std::vector<ServerMemoryPoolInfo>& memory_pool_info,
-                               [[maybe_unused]] VAddr audio_codec_dsp_addr) {
+                               std::vector<ServerMemoryPoolInfo>& memory_pool_info,
+                               VAddr audio_codec_dsp_addr) {
     const auto voice_count = voice_context.GetVoiceCount();
     std::vector<VoiceInfo::InParams> voice_in(voice_count);
     std::vector<VoiceInfo::OutParams> voice_out(voice_count);
@@ -165,28 +165,28 @@ bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
 
     // Update our voices
     for (std::size_t i = 0; i < voice_count; i++) {
-        auto& voice_in_params = voice_in[i];
-        const auto channel_count = static_cast<std::size_t>(voice_in_params.channel_count);
+        auto& in_params = voice_in[i];
+        const auto channel_count = static_cast<std::size_t>(in_params.channel_count);
         // Skip if it's not currently in use
-        if (!voice_in_params.is_in_use) {
+        if (!in_params.is_in_use) {
             continue;
         }
         // Voice states for each channel
         std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT> voice_states{};
-        ASSERT(static_cast<std::size_t>(voice_in_params.id) < voice_count);
+        ASSERT(static_cast<std::size_t>(in_params.id) < voice_count);
 
         // Grab our current voice info
-        auto& voice_info = voice_context.GetInfo(static_cast<std::size_t>(voice_in_params.id));
+        auto& voice_info = voice_context.GetInfo(static_cast<std::size_t>(in_params.id));
 
         ASSERT(channel_count <= AudioCommon::MAX_CHANNEL_COUNT);
 
         // Get all our channel voice states
         for (std::size_t channel = 0; channel < channel_count; channel++) {
             voice_states[channel] =
-                &voice_context.GetState(voice_in_params.voice_channel_resource_ids[channel]);
+                &voice_context.GetState(in_params.voice_channel_resource_ids[channel]);
         }
 
-        if (voice_in_params.is_new) {
+        if (in_params.is_new) {
             // Default our values for our voice
             voice_info.Initialize();
             if (channel_count == 0 || channel_count > AudioCommon::MAX_CHANNEL_COUNT) {
@@ -200,12 +200,12 @@ bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
         }
 
         // Update our voice
-        voice_info.UpdateParameters(voice_in_params, behavior_info);
+        voice_info.UpdateParameters(in_params, behavior_info);
         // TODO(ogniK): Handle mapping errors with behavior info based on in params response
 
         // Update our wave buffers
-        voice_info.UpdateWaveBuffers(voice_in_params, voice_states, behavior_info);
-        voice_info.WriteOutStatus(voice_out[i], voice_in_params, voice_states);
+        voice_info.UpdateWaveBuffers(in_params, voice_states, behavior_info);
+        voice_info.WriteOutStatus(voice_out[i], in_params, voice_states);
     }
 
     if (!AudioCommon::CanConsumeBuffer(out_params.size(), output_offset, voice_out_size)) {
@@ -445,7 +445,7 @@ bool InfoUpdater::UpdatePerformanceBuffer() {
     return true;
 }
 
-bool InfoUpdater::UpdateErrorInfo([[maybe_unused]] BehaviorInfo& in_behavior_info) {
+bool InfoUpdater::UpdateErrorInfo(BehaviorInfo& in_behavior_info) {
     const auto total_beahvior_info_out = sizeof(BehaviorInfo::OutParams);
 
     if (!AudioCommon::CanConsumeBuffer(out_params.size(), output_offset, total_beahvior_info_out)) {

src/audio_core/info_updater.h

@@ -21,8 +21,8 @@ class SplitterContext;
 class InfoUpdater {
 public:
     // TODO(ogniK): Pass process handle when we support it
-    InfoUpdater(const std::vector<u8>& in_params_, std::vector<u8>& out_params_,
-                BehaviorInfo& behavior_info_);
+    InfoUpdater(const std::vector<u8>& in_params, std::vector<u8>& out_params,
+                BehaviorInfo& behavior_info);
     ~InfoUpdater();
 
     bool UpdateBehaviorInfo(BehaviorInfo& in_behavior_info);

src/audio_core/memory_pool.cpp

@@ -10,10 +10,11 @@ namespace AudioCore {
 
 ServerMemoryPoolInfo::ServerMemoryPoolInfo() = default;
 ServerMemoryPoolInfo::~ServerMemoryPoolInfo() = default;
-
-bool ServerMemoryPoolInfo::Update(const InParams& in_params, OutParams& out_params) {
+bool ServerMemoryPoolInfo::Update(const ServerMemoryPoolInfo::InParams& in_params,
+                                  ServerMemoryPoolInfo::OutParams& out_params) {
     // Our state does not need to be changed
-    if (in_params.state != State::RequestAttach && in_params.state != State::RequestDetach) {
+    if (in_params.state != ServerMemoryPoolInfo::State::RequestAttach &&
+        in_params.state != ServerMemoryPoolInfo::State::RequestDetach) {
         return true;
     }
 
@@ -31,11 +32,11 @@ bool ServerMemoryPoolInfo::Update(const InParams& in_params, OutParams& out_para
         return false;
     }
 
-    if (in_params.state == State::RequestAttach) {
+    if (in_params.state == ServerMemoryPoolInfo::State::RequestAttach) {
         cpu_address = in_params.address;
         size = in_params.size;
         used = true;
-        out_params.state = State::Attached;
+        out_params.state = ServerMemoryPoolInfo::State::Attached;
     } else {
         // Unexpected address
         if (cpu_address != in_params.address) {
@@ -53,7 +54,7 @@ bool ServerMemoryPoolInfo::Update(const InParams& in_params, OutParams& out_para
         cpu_address = 0;
         size = 0;
         used = false;
-        out_params.state = State::Detached;
+        out_params.state = ServerMemoryPoolInfo::State::Detached;
     }
     return true;
 }

src/audio_core/memory_pool.h

@@ -28,18 +28,19 @@ public:
     struct InParams {
         u64_le address{};
         u64_le size{};
-        State state{};
+        ServerMemoryPoolInfo::State state{};
         INSERT_PADDING_WORDS(3);
     };
-    static_assert(sizeof(InParams) == 0x20, "InParams are an invalid size");
+    static_assert(sizeof(ServerMemoryPoolInfo::InParams) == 0x20, "InParams are an invalid size");
 
     struct OutParams {
-        State state{};
+        ServerMemoryPoolInfo::State state{};
         INSERT_PADDING_WORDS(3);
     };
-    static_assert(sizeof(OutParams) == 0x10, "OutParams are an invalid size");
+    static_assert(sizeof(ServerMemoryPoolInfo::OutParams) == 0x10, "OutParams are an invalid size");
 
-    bool Update(const InParams& in_params, OutParams& out_params);
+    bool Update(const ServerMemoryPoolInfo::InParams& in_params,
+                ServerMemoryPoolInfo::OutParams& out_params);
 
 private:
     // There's another entry here which is the DSP address, however since we're not talking to the

src/audio_core/mix_context.h

@@ -62,17 +62,17 @@ public:
     ServerMixInfo();
     ~ServerMixInfo();
 
-    [[nodiscard]] const ServerMixInfo::InParams& GetInParams() const;
-    [[nodiscard]] ServerMixInfo::InParams& GetInParams();
+    const ServerMixInfo::InParams& GetInParams() const;
+    ServerMixInfo::InParams& GetInParams();
 
     bool Update(EdgeMatrix& edge_matrix, const MixInfo::InParams& mix_in,
                 BehaviorInfo& behavior_info, SplitterContext& splitter_context,
                 EffectContext& effect_context);
-    [[nodiscard]] bool HasAnyConnection() const;
+    bool HasAnyConnection() const;
     void Cleanup();
     void SetEffectCount(std::size_t count);
     void ResetEffectProcessingOrder();
-    [[nodiscard]] s32 GetEffectOrder(std::size_t i) const;
+    s32 GetEffectOrder(std::size_t i) const;
 
 private:
     std::vector<s32> effect_processing_order;
@@ -91,15 +91,15 @@ public:
     void SortInfo();
     bool TsortInfo(SplitterContext& splitter_context);
 
-    [[nodiscard]] std::size_t GetCount() const;
-    [[nodiscard]] ServerMixInfo& GetInfo(std::size_t i);
-    [[nodiscard]] const ServerMixInfo& GetInfo(std::size_t i) const;
-    [[nodiscard]] ServerMixInfo& GetSortedInfo(std::size_t i);
-    [[nodiscard]] const ServerMixInfo& GetSortedInfo(std::size_t i) const;
-    [[nodiscard]] ServerMixInfo& GetFinalMixInfo();
-    [[nodiscard]] const ServerMixInfo& GetFinalMixInfo() const;
-    [[nodiscard]] EdgeMatrix& GetEdgeMatrix();
-    [[nodiscard]] const EdgeMatrix& GetEdgeMatrix() const;
+    std::size_t GetCount() const;
+    ServerMixInfo& GetInfo(std::size_t i);
+    const ServerMixInfo& GetInfo(std::size_t i) const;
+    ServerMixInfo& GetSortedInfo(std::size_t i);
+    const ServerMixInfo& GetSortedInfo(std::size_t i) const;
+    ServerMixInfo& GetFinalMixInfo();
+    const ServerMixInfo& GetFinalMixInfo() const;
+    EdgeMatrix& GetEdgeMatrix();
+    const EdgeMatrix& GetEdgeMatrix() const;
 
 private:
     void CalcMixBufferOffset();

src/audio_core/sink_context.cpp

@@ -5,23 +5,17 @@
 #include "audio_core/sink_context.h"
 
 namespace AudioCore {
-SinkContext::SinkContext(std::size_t sink_count_) : sink_count{sink_count_} {}
+SinkContext::SinkContext(std::size_t sink_count) : sink_count(sink_count) {}
 SinkContext::~SinkContext() = default;
 
 std::size_t SinkContext::GetCount() const {
     return sink_count;
 }
 
-void SinkContext::UpdateMainSink(const SinkInfo::InParams& in) {
-    ASSERT(in.type == SinkTypes::Device);
-
-    has_downmix_coefs = in.device.down_matrix_enabled;
-    if (has_downmix_coefs) {
-        downmix_coefficients = in.device.down_matrix_coef;
-    }
+void SinkContext::UpdateMainSink(SinkInfo::InParams& in) {
     in_use = in.in_use;
     use_count = in.device.input_count;
-    buffers = in.device.input;
+    std::memcpy(buffers.data(), in.device.input.data(), AudioCommon::MAX_CHANNEL_COUNT);
 }
 
 bool SinkContext::InUse() const {
@@ -34,12 +28,4 @@ std::vector<u8> SinkContext::OutputBuffers() const {
     return buffer_ret;
 }
 
-bool SinkContext::HasDownMixingCoefficients() const {
-    return has_downmix_coefs;
-}
-
-const DownmixCoefficients& SinkContext::GetDownmixCoefficients() const {
-    return downmix_coefficients;
-}
-
 } // namespace AudioCore

src/audio_core/sink_context.h

@@ -11,8 +11,6 @@
 
 namespace AudioCore {
 
-using DownmixCoefficients = std::array<float_le, 4>;
-
 enum class SinkTypes : u8 {
     Invalid = 0,
     Device = 1,
@@ -40,21 +38,21 @@ 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,
+    static_assert(sizeof(SinkInfo::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;
+        std::array<float_le, 4> down_matrix_coef;
     };
-    static_assert(sizeof(DeviceIn) == 0x11c, "SinkInfo::DeviceIn is an invalid size");
+    static_assert(sizeof(SinkInfo::DeviceIn) == 0x11c, "SinkInfo::DeviceIn is an invalid size");
 
     struct InParams {
         SinkTypes type{};
@@ -64,33 +62,28 @@ public:
         INSERT_PADDING_WORDS(6);
         union {
             // std::array<u8, 0x120> raw{};
-            DeviceIn device;
-            CircularBufferIn circular_buffer;
+            SinkInfo::DeviceIn device;
+            SinkInfo::CircularBufferIn circular_buffer;
         };
     };
-    static_assert(sizeof(InParams) == 0x140, "SinkInfo::InParams are an invalid size!");
+    static_assert(sizeof(SinkInfo::InParams) == 0x140, "SinkInfo::InParams are an invalid size!");
 };
 
 class SinkContext {
 public:
-    explicit SinkContext(std::size_t sink_count_);
+    explicit SinkContext(std::size_t sink_count);
     ~SinkContext();
 
-    [[nodiscard]] std::size_t GetCount() const;
+    std::size_t GetCount() const;
 
-    void UpdateMainSink(const SinkInfo::InParams& in);
-    [[nodiscard]] bool InUse() const;
-    [[nodiscard]] std::vector<u8> OutputBuffers() const;
-
-    [[nodiscard]] bool HasDownMixingCoefficients() const;
-    [[nodiscard]] const DownmixCoefficients& GetDownmixCoefficients() const;
+    void UpdateMainSink(SinkInfo::InParams& in);
+    bool InUse() const;
+    std::vector<u8> OutputBuffers() const;
 
 private:
     bool in_use{false};
     s32 use_count{};
     std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> buffers{};
     std::size_t sink_count{};
-    bool has_downmix_coefs{false};
-    DownmixCoefficients downmix_coefficients{};
 };
 } // namespace AudioCore

src/audio_core/splitter_context.cpp

@@ -10,7 +10,7 @@
 
 namespace AudioCore {
 
-ServerSplitterDestinationData::ServerSplitterDestinationData(s32 id_) : id{id_} {}
+ServerSplitterDestinationData::ServerSplitterDestinationData(s32 id) : id(id) {}
 ServerSplitterDestinationData::~ServerSplitterDestinationData() = default;
 
 void ServerSplitterDestinationData::Update(SplitterInfo::InDestinationParams& header) {
@@ -87,7 +87,7 @@ void ServerSplitterDestinationData::UpdateInternalState() {
     needs_update = false;
 }
 
-ServerSplitterInfo::ServerSplitterInfo(s32 id_) : id(id_) {}
+ServerSplitterInfo::ServerSplitterInfo(s32 id) : id(id) {}
 ServerSplitterInfo::~ServerSplitterInfo() = default;
 
 void ServerSplitterInfo::InitializeInfos() {
@@ -121,7 +121,7 @@ const ServerSplitterDestinationData* ServerSplitterInfo::GetHead() const {
 }
 
 ServerSplitterDestinationData* ServerSplitterInfo::GetData(std::size_t depth) {
-    auto* current_head = head;
+    auto current_head = head;
     for (std::size_t i = 0; i < depth; i++) {
         if (current_head == nullptr) {
             return nullptr;
@@ -132,7 +132,7 @@ ServerSplitterDestinationData* ServerSplitterInfo::GetData(std::size_t depth) {
 }
 
 const ServerSplitterDestinationData* ServerSplitterInfo::GetData(std::size_t depth) const {
-    auto* current_head = head;
+    auto current_head = head;
     for (std::size_t i = 0; i < depth; i++) {
         if (current_head == nullptr) {
             return nullptr;
@@ -245,7 +245,7 @@ ServerSplitterDestinationData* SplitterContext::GetDestinationData(std::size_t i
 const ServerSplitterDestinationData* SplitterContext::GetDestinationData(std::size_t info,
                                                                          std::size_t data) const {
     ASSERT(info < info_count);
-    const auto& cur_info = GetInfo(info);
+    auto& cur_info = GetInfo(info);
     return cur_info.GetData(data);
 }
 
@@ -267,11 +267,11 @@ std::size_t SplitterContext::GetDataCount() const {
     return data_count;
 }
 
-void SplitterContext::Setup(std::size_t info_count_, std::size_t data_count_,
+void SplitterContext::Setup(std::size_t _info_count, std::size_t _data_count,
                             bool is_splitter_bug_fixed) {
 
-    info_count = info_count_;
-    data_count = data_count_;
+    info_count = _info_count;
+    data_count = _data_count;
 
     for (std::size_t i = 0; i < info_count; i++) {
         auto& splitter = infos.emplace_back(static_cast<s32>(i));
@@ -364,7 +364,7 @@ bool SplitterContext::RecomposeDestination(ServerSplitterInfo& info,
     // Clear our current destinations
     auto* current_head = info.GetHead();
     while (current_head != nullptr) {
-        auto* next_head = current_head->GetNextDestination();
+        auto next_head = current_head->GetNextDestination();
         current_head->SetNextDestination(nullptr);
         current_head = next_head;
     }
@@ -471,8 +471,8 @@ bool NodeStates::DepthFirstSearch(EdgeMatrix& edge_matrix) {
                 continue;
             }
 
-            const auto edge_node_count = edge_matrix.GetNodeCount();
-            for (s32 j = 0; j < static_cast<s32>(edge_node_count); j++) {
+            const auto node_count = edge_matrix.GetNodeCount();
+            for (s32 j = 0; j < static_cast<s32>(node_count); j++) {
                 // Check if our node is connected to our edge matrix
                 if (!edge_matrix.Connected(current_stack_index, j)) {
                     continue;

src/audio_core/splitter_context.h

@@ -63,7 +63,7 @@ public:
     NodeStates();
     ~NodeStates();
 
-    void Initialize(std::size_t node_count_);
+    void Initialize(std::size_t _node_count);
     bool Tsort(EdgeMatrix& edge_matrix);
     std::size_t GetIndexPos() const;
     const std::vector<s32>& GetIndexList() const;
@@ -72,15 +72,15 @@ private:
     void PushTsortResult(s32 index);
     bool DepthFirstSearch(EdgeMatrix& edge_matrix);
     void ResetState();
-    void UpdateState(State state, std::size_t i);
-    State GetState(std::size_t i);
+    void UpdateState(NodeStates::State state, std::size_t i);
+    NodeStates::State GetState(std::size_t i);
 
     std::size_t node_count{};
     std::vector<bool> was_node_found{};
     std::vector<bool> was_node_completed{};
     std::size_t index_pos{};
     std::vector<s32> index_list{};
-    Stack index_stack{};
+    NodeStates::Stack index_stack{};
 };
 
 enum class SplitterMagic : u32_le {
@@ -97,7 +97,8 @@ public:
         s32_le data_count{};
         INSERT_PADDING_WORDS(5);
     };
-    static_assert(sizeof(InHeader) == 0x20, "SplitterInfo::InHeader is an invalid size");
+    static_assert(sizeof(SplitterInfo::InHeader) == 0x20,
+                  "SplitterInfo::InHeader is an invalid size");
 
     struct InInfoPrams {
         SplitterMagic magic{};
@@ -106,7 +107,8 @@ public:
         s32_le length{};
         s32_le resource_id_base{};
     };
-    static_assert(sizeof(InInfoPrams) == 0x14, "SplitterInfo::InInfoPrams is an invalid size");
+    static_assert(sizeof(SplitterInfo::InInfoPrams) == 0x14,
+                  "SplitterInfo::InInfoPrams is an invalid size");
 
     struct InDestinationParams {
         SplitterMagic magic{};
@@ -116,13 +118,13 @@ public:
         bool in_use{};
         INSERT_PADDING_BYTES(3);
     };
-    static_assert(sizeof(InDestinationParams) == 0x70,
+    static_assert(sizeof(SplitterInfo::InDestinationParams) == 0x70,
                   "SplitterInfo::InDestinationParams is an invalid size");
 };
 
 class ServerSplitterDestinationData {
 public:
-    explicit ServerSplitterDestinationData(s32 id_);
+    explicit ServerSplitterDestinationData(s32 id);
     ~ServerSplitterDestinationData();
 
     void Update(SplitterInfo::InDestinationParams& header);
@@ -151,7 +153,7 @@ private:
 
 class ServerSplitterInfo {
 public:
-    explicit ServerSplitterInfo(s32 id_);
+    explicit ServerSplitterInfo(s32 id);
     ~ServerSplitterInfo();
 
     void InitializeInfos();

src/audio_core/stream.cpp

@@ -31,10 +31,10 @@ u32 Stream::GetNumChannels() const {
     return {};
 }
 
-Stream::Stream(Core::Timing::CoreTiming& core_timing_, u32 sample_rate_, Format format_,
-               ReleaseCallback&& release_callback_, SinkStream& sink_stream_, std::string&& name_)
-    : sample_rate{sample_rate_}, format{format_}, release_callback{std::move(release_callback_)},
-      sink_stream{sink_stream_}, core_timing{core_timing_}, name{std::move(name_)} {
+Stream::Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format format,
+               ReleaseCallback&& release_callback, SinkStream& sink_stream, std::string&& name_)
+    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
+      sink_stream{sink_stream}, core_timing{core_timing}, name{std::move(name_)} {
     release_event =
         Core::Timing::CreateEvent(name, [this](std::uintptr_t, std::chrono::nanoseconds ns_late) {
             ReleaseActiveBuffer(ns_late);
@@ -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) {
@@ -137,7 +122,7 @@ bool Stream::QueueBuffer(BufferPtr&& buffer) {
     return false;
 }
 
-bool Stream::ContainsBuffer([[maybe_unused]] Buffer::Tag tag) const {
+bool Stream::ContainsBuffer(Buffer::Tag tag) const {
     UNIMPLEMENTED();
     return {};
 }
@@ -145,25 +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!");
-        }
-        released_buffers.pop();
-    }
-    return tags;
-}
-
-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

@@ -44,8 +44,8 @@ public:
     /// Callback function type, used to change guest state on a buffer being released
     using ReleaseCallback = std::function<void()>;
 
-    Stream(Core::Timing::CoreTiming& core_timing_, u32 sample_rate_, Format format_,
-           ReleaseCallback&& release_callback_, SinkStream& sink_stream_, std::string&& name_);
+    Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format format,
+           ReleaseCallback&& release_callback, SinkStream& sink_stream, std::string&& name_);
 
     /// Plays the audio stream
     void Play();
@@ -56,44 +56,38 @@ 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;
+    bool ContainsBuffer(Buffer::Tag tag) const;
 
     /// Returns a vector of recently released buffers specified by tag
-    [[nodiscard]] std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(std::size_t max_count);
-
-    /// Returns a vector of all recently released buffers specified by tag
-    [[nodiscard]] std::vector<Buffer::Tag> GetTagsAndReleaseBuffers();
+    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(std::size_t max_count);
 
     void SetVolume(float volume);
 
-    [[nodiscard]] float GetVolume() const {
+    float GetVolume() const {
         return game_volume;
     }
 
     /// Returns true if the stream is currently playing
-    [[nodiscard]] bool IsPlaying() const {
+    bool IsPlaying() const {
         return state == State::Playing;
     }
 
     /// Returns the number of queued buffers
-    [[nodiscard]] std::size_t GetQueueSize() const {
+    std::size_t GetQueueSize() const {
         return queued_buffers.size();
     }
 
     /// Gets the sample rate
-    [[nodiscard]] u32 GetSampleRate() const {
+    u32 GetSampleRate() const {
         return sample_rate;
     }
 
     /// Gets the number of channels
-    [[nodiscard]] u32 GetNumChannels() const;
+    u32 GetNumChannels() const;
 
     /// Get the state
-    [[nodiscard]] State GetState() const;
+    State GetState() const;
 
 private:
     /// Plays the next queued buffer in the audio stream, starting playback if necessary
@@ -103,7 +97,7 @@ private:
     void ReleaseActiveBuffer(std::chrono::nanoseconds ns_late = {});
 
     /// Gets the number of core cycles when the specified buffer will be released
-    [[nodiscard]] std::chrono::nanoseconds GetBufferReleaseNS(const Buffer& buffer) const;
+    std::chrono::nanoseconds GetBufferReleaseNS(const Buffer& buffer) const;
 
     u32 sample_rate;                  ///< Sample rate of the stream
     Format format;                    ///< Format of the stream

src/audio_core/voice_context.cpp

@@ -8,7 +8,7 @@
 
 namespace AudioCore {
 
-ServerVoiceChannelResource::ServerVoiceChannelResource(s32 id_) : id(id_) {}
+ServerVoiceChannelResource::ServerVoiceChannelResource(s32 id) : id(id) {}
 ServerVoiceChannelResource::~ServerVoiceChannelResource() = default;
 
 bool ServerVoiceChannelResource::InUse() const {
@@ -209,8 +209,7 @@ void ServerVoiceInfo::UpdateWaveBuffers(
 
 void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
                                        const WaveBuffer& in_wave_buffer, SampleFormat sample_format,
-                                       bool is_buffer_valid,
-                                       [[maybe_unused]] BehaviorInfo& behavior_info) {
+                                       bool is_buffer_valid, BehaviorInfo& behavior_info) {
     if (!is_buffer_valid && out_wavebuffer.sent_to_dsp) {
         out_wavebuffer.buffer_address = 0;
         out_wavebuffer.buffer_size = 0;
@@ -401,7 +400,7 @@ bool ServerVoiceInfo::HasValidWaveBuffer(const VoiceState* state) const {
     return std::find(valid_wb.begin(), valid_wb.end(), true) != valid_wb.end();
 }
 
-VoiceContext::VoiceContext(std::size_t voice_count_) : voice_count{voice_count_} {
+VoiceContext::VoiceContext(std::size_t voice_count) : voice_count(voice_count) {
     for (std::size_t i = 0; i < voice_count; i++) {
         voice_channel_resources.emplace_back(static_cast<s32>(i));
         sorted_voice_info.push_back(&voice_info.emplace_back());

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 {
@@ -118,12 +118,12 @@ public:
         bool in_use{};
         INSERT_PADDING_BYTES(11);
     };
-    static_assert(sizeof(InParams) == 0x70, "InParams is an invalid size");
+    static_assert(sizeof(VoiceChannelResource::InParams) == 0x70, "InParams is an invalid size");
 };
 
 class ServerVoiceChannelResource {
 public:
-    explicit ServerVoiceChannelResource(s32 id_);
+    explicit ServerVoiceChannelResource(s32 id);
     ~ServerVoiceChannelResource();
 
     bool InUse() const;
@@ -174,7 +174,7 @@ public:
         BehaviorFlags behavior_flags{};
         INSERT_PADDING_BYTES(16);
     };
-    static_assert(sizeof(InParams) == 0x170, "InParams is an invalid size");
+    static_assert(sizeof(VoiceInfo::InParams) == 0x170, "InParams is an invalid size");
 
     struct OutParams {
         u64_le played_sample_count{};
@@ -182,7 +182,7 @@ public:
         u8 voice_dropped{};
         INSERT_PADDING_BYTES(3);
     };
-    static_assert(sizeof(OutParams) == 0x10, "OutParams is an invalid size");
+    static_assert(sizeof(VoiceInfo::OutParams) == 0x10, "OutParams is an invalid size");
 };
 
 class ServerVoiceInfo {
@@ -263,7 +263,7 @@ private:
 
 class VoiceContext {
 public:
-    explicit VoiceContext(std::size_t voice_count_);
+    VoiceContext(std::size_t voice_count);
     ~VoiceContext();
 
     std::size_t GetVoiceCount() const;

src/common/CMakeLists.txt

@@ -98,20 +98,19 @@ 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
     concepts.h
-    div_ceil.h
     dynamic_library.cpp
     dynamic_library.h
     fiber.cpp
@@ -121,7 +120,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 +132,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
@@ -152,8 +150,6 @@ add_library(common STATIC
     scope_exit.h
     spin_lock.cpp
     spin_lock.h
-    stream.cpp
-    stream.h
     string_util.cpp
     string_util.h
     swap.h
@@ -162,12 +158,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
-    tree.h
+    timer.cpp
+    timer.h
+    uint128.cpp
     uint128.h
     uuid.cpp
     uuid.h
@@ -192,25 +188,8 @@ if(ARCHITECTURE_x86_64)
     )
 endif()
 
-if (MSVC)
-  target_compile_definitions(common PRIVATE
-    # The standard library doesn't provide any replacement for codecvt yet
-    # so we can disable this deprecation warning for the time being.
-    _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING
-  )
-  target_compile_options(common PRIVATE
-    /W4
-    /WX
-  )
-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,45 +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, 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_cast.h

@@ -1,22 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstring>
-#include <type_traits>
-
-namespace Common {
-
-template <typename To, typename From>
-[[nodiscard]] std::enable_if_t<sizeof(To) == sizeof(From) && std::is_trivially_copyable_v<From> &&
-                                   std::is_trivially_copyable_v<To>,
-                               To>
-BitCast(const From& src) noexcept {
-    To dst;
-    std::memcpy(&dst, &src, sizeof(To));
-    return dst;
-}
-
-} // 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