Fix typo

.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'

.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,29 +73,23 @@ 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)
     target_include_directories(httplib INTERFACE ./httplib)
     target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
     target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
-    if (WIN32)
-        target_link_libraries(httplib INTERFACE crypt32 cryptui ws2_32)
-    endif()
 endif()
 
 # Opus

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
@@ -48,19 +46,11 @@ create_target_directory_groups(audio_core)
 
 if (NOT MSVC)
     target_compile_options(audio_core PRIVATE
-        -Werror=conversion
         -Werror=ignored-qualifiers
         -Werror=implicit-fallthrough
         -Werror=reorder
         -Werror=sign-compare
-        -Werror=shadow
-        -Werror=unused-parameter
         -Werror=unused-variable
-
-        $<$<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;
@@ -55,8 +55,7 @@ void Filter::Process(std::vector<s16>& signal) {
 /// @param total_count The total number of biquads to be cascaded.
 /// @param index 0-index of the biquad to calculate the Q value for.
 static double CascadingBiquadQ(std::size_t total_count, std::size_t index) {
-    const auto pole =
-        M_PI * static_cast<double>(2 * index + 1) / (4.0 * static_cast<double>(total_count));
+    const double pole = M_PI * (2 * index + 1) / (4.0 * total_count);
     return 1.0 / (2.0 * std::cos(pole));
 }
 
@@ -69,7 +68,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

@@ -146,7 +146,7 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
         return {};
 
     if (ratio <= 0) {
-        LOG_ERROR(Audio, "Nonsensical interpolation ratio {}", ratio);
+        LOG_CRITICAL(Audio, "Nonsensical interpolation ratio {}", ratio);
         return input;
     }
 
@@ -164,8 +164,7 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
     const std::size_t num_frames{input.size() / 2};
 
     std::vector<s16> output;
-    output.reserve(static_cast<std::size_t>(static_cast<double>(input.size()) / ratio +
-                                            InterpolationState::taps));
+    output.reserve(static_cast<std::size_t>(input.size() / ratio + InterpolationState::taps));
 
     for (std::size_t frame{}; frame < num_frames; ++frame) {
         const std::size_t lut_index{(state.fraction >> 8) * InterpolationState::taps};
@@ -218,7 +217,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) {
@@ -1124,6 +793,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
             // Decode entire frame
             if (remaining_samples >= static_cast<int>(SAMPLES_PER_FRAME)) {
                 for (std::size_t i = 0; i < SAMPLES_PER_FRAME / 2; i++) {
+
                     // Sample 1
                     const s32 s0 = SIGNED_NIBBLES[buffer[buffer_offset] >> 4];
                     const s32 s1 = SIGNED_NIBBLES[buffer[buffer_offset++] & 0xf];
@@ -1132,7 +802,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
                     sample_buffer[cur_mix_offset++] = sample_1;
                     sample_buffer[cur_mix_offset++] = sample_2;
                 }
-                remaining_samples -= static_cast<int>(SAMPLES_PER_FRAME);
+                remaining_samples -= SAMPLES_PER_FRAME;
                 position_in_frame += SAMPLES_PER_FRAME;
                 continue;
             }

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;
@@ -94,10 +93,8 @@ public:
                 constexpr s32 clev{707}; // center mixing level coefficient
                 constexpr s32 slev{707}; // surround mixing level coefficient
 
-                buf.push_back(static_cast<s16>(left + (clev * center / 1000) +
-                                               (slev * surround_left / 1000)));
-                buf.push_back(static_cast<s16>(right + (clev * center / 1000) +
-                                               (slev * surround_right / 1000)));
+                buf.push_back(left + (clev * center / 1000) + (slev * surround_left / 1000));
+                buf.push_back(right + (clev * center / 1000) + (slev * surround_right / 1000));
             }
             queue.Push(buf);
             return;
@@ -193,9 +190,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 +234,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 {
@@ -128,10 +128,7 @@ void ServerVoiceInfo::UpdateParameters(const VoiceInfo::InParams& voice_in,
     in_params.wave_buffer_count = voice_in.wave_buffer_count;
     in_params.wave_bufffer_head = voice_in.wave_buffer_head;
     if (behavior_info.IsFlushVoiceWaveBuffersSupported()) {
-        const auto in_request_count = in_params.wave_buffer_flush_request_count;
-        const auto voice_request_count = voice_in.wave_buffer_flush_request_count;
-        in_params.wave_buffer_flush_request_count =
-            static_cast<u8>(in_request_count + voice_request_count);
+        in_params.wave_buffer_flush_request_count += voice_in.wave_buffer_flush_request_count;
     }
     in_params.mix_id = voice_in.mix_id;
     if (behavior_info.IsSplitterSupported()) {
@@ -209,8 +206,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 +397,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());