random space

more clang
i'm going to love condensing these commits
2021-02-06 09:59:00 -05:00 · 2021-02-06 09:54:57 -05:00 · 2021-02-06 09:49:43 -05:00 · 2021-02-06 09:14:07 -05:00 · 2021-02-05 22:08:12 -05:00 · 2021-02-05 22:04:33 -05:00
526 changed files with 9855 additions and 19905 deletions
--- a/.ci/scripts/clang/docker.sh
+++ b/.ci/scripts/clang/docker.sh
@@ -1,18 +0,0 @@
-#!/bin/bash -ex
-
-# Exit on error, rather than continuing with the rest of the script.
-set -e
-
-cd /yuzu
-
-ccache -s
-
-mkdir build || true && cd build
-cmake .. -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/clang -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_INSTALL_PREFIX="/usr"
-
-make -j$(nproc)
-
-ccache -s
-
-ctest -VV -C Release
-
--- a/.ci/scripts/clang/exec.sh
+++ b/.ci/scripts/clang/exec.sh
@@ -1,8 +0,0 @@
-#!/bin/bash -ex
-
-mkdir -p "ccache"  || true
-chmod a+x ./.ci/scripts/clang/docker.sh
-# the UID for the container yuzu user is 1027
-sudo chown -R 1027 ./
-docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/clang/docker.sh $1
-sudo chown -R $UID ./
--- a/.ci/scripts/clang/upload.sh
+++ b/.ci/scripts/clang/upload.sh
@@ -1,20 +0,0 @@
-#!/bin/bash -ex
-
-. .ci/scripts/common/pre-upload.sh
-
-REV_NAME="yuzu-linux-${GITDATE}-${GITREV}"
-ARCHIVE_NAME="${REV_NAME}.tar.xz"
-COMPRESSION_FLAGS="-cJvf"
-
-if [ "${RELEASE_NAME}" = "mainline" ]; then
-    DIR_NAME="${REV_NAME}"
-else
-    DIR_NAME="${REV_NAME}_${RELEASE_NAME}"
-fi
-
-mkdir "$DIR_NAME"
-
-cp build/bin/yuzu-cmd "$DIR_NAME"
-cp build/bin/yuzu "$DIR_NAME"
-
-. .ci/scripts/common/post-upload.sh
--- a/.ci/scripts/windows/docker.sh
+++ b/.ci/scripts/windows/docker.sh
@@ -42,8 +42,3 @@ done
 pip3 install pefile
 python3 .ci/scripts/windows/scan_dll.py package/*.exe "package/"
 python3 .ci/scripts/windows/scan_dll.py package/imageformats/*.dll "package/"
-
-# copy FFmpeg libraries
-EXTERNALS_PATH="$(pwd)/build/externals"
-FFMPEG_DLL_PATH="$(find ${EXTERNALS_PATH} -maxdepth 1 -type d | grep ffmpeg)/bin"
-find ${FFMPEG_DLL_PATH} -type f -regex ".*\.dll" -exec cp -v {} package/ ';'
--- a/.ci/templates/build-msvc.yml
+++ b/.ci/templates/build-msvc.yml
@@ -8,7 +8,7 @@ steps:
  displayName: 'Install vulkan-sdk'
 - script: python -m pip install --upgrade pip conan
  displayName: 'Install conan'
- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cmake --install . --config Release && cd ..
+- 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 ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
--- a/.ci/templates/build-standard.yml
+++ b/.ci/templates/build-standard.yml
@@ -12,9 +12,6 @@ jobs:
      windows:
        BuildSuffix: 'windows-mingw'
        ScriptFolder: 'windows'
-      clang:
-        BuildSuffix: 'clang'
-        ScriptFolder: 'clang'
      linux:
        BuildSuffix: 'linux'
        ScriptFolder: 'linux'
@@ -27,4 +24,4 @@ jobs:
    parameters:
      artifactSource: 'false'
      cache: $(parameters.cache)
-      version: $(parameters.version)
+      version: $(parameters.version)
--- a/.gitmodules
+++ b/.gitmodules
@@ -27,7 +27,7 @@
    url = https://github.com/ReinUsesLisp/sirit
 [submodule "mbedtls"]
    path = externals/mbedtls
-    url = https://github.com/yuzu-emu/mbedtls
+    url = https://github.com/DarkLordZach/mbedtls
 [submodule "libzip"]
    path = externals/libzip/libzip
    url = https://github.com/nih-at/libzip.git
@@ -37,6 +37,3 @@
 [submodule "opus"]
 	path = externals/opus/opus
 	url = https://github.com/xiph/opus.git
-[submodule "ffmpeg"]
-	path = externals/ffmpeg
-	url = https://git.ffmpeg.org/ffmpeg.git
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,8 +18,6 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "EN

 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)

-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled yuzu" ON "WIN32" OFF)
-
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)

 option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implementation of BCAT" ON)
@@ -172,8 +170,6 @@ macro(yuzu_find_packages)
        "nlohmann_json     3.8         nlohmann_json/3.8.0"
        "ZLIB              1.2         zlib/1.2.11"
        "zstd              1.4         zstd/1.4.8"
-    # can't use opus until AVX check is fixed: https://github.com/yuzu-emu/yuzu/pull/4068
-        #"opus              1.3         opus/1.3.1"
    )

    foreach(PACKAGE ${REQUIRED_LIBS})
@@ -388,141 +384,19 @@ if (NOT LIBUSB_FOUND)
    set(LIBUSB_LIBRARIES usb)
 endif()

-# List of all FFmpeg components required
-set(FFmpeg_COMPONENTS
-    avcodec
-    avutil
-    swscale)
-
-if (NOT YUZU_USE_BUNDLED_FFMPEG)
-    # Use system installed FFmpeg
-    find_package(FFmpeg REQUIRED COMPONENTS ${FFmpeg_COMPONENTS})
-
-    if (FFmpeg_FOUND)
-        # Overwrite aggregate defines from FFmpeg module to avoid over-linking libraries.
-        # Prevents shipping too many libraries with the AppImage.
-        set(FFmpeg_LIBRARIES "")
-        set(FFmpeg_INCLUDE_DIR "")
-
-        foreach(COMPONENT ${FFmpeg_COMPONENTS})
-            set(FFmpeg_LIBRARIES ${FFmpeg_LIBRARIES} ${FFmpeg_LIBRARY_${COMPONENT}} CACHE PATH "Paths to FFmpeg libraries" FORCE)
-            set(FFmpeg_INCLUDE_DIR ${FFmpeg_INCLUDE_DIR} ${FFmpeg_INCLUDE_${COMPONENT}} CACHE PATH "Path to FFmpeg headers" FORCE)
-        endforeach()
-    else()
-        message(WARNING "FFmpeg not found, falling back to externals")
-        set(YUZU_USE_BUNDLED_FFMPEG ON)
-    endif()
+# Use system installed ffmpeg.
+if (NOT MSVC)
+    find_package(FFmpeg REQUIRED)
+else()
+    set(FFMPEG_EXT_NAME "ffmpeg-4.2.1")
+    set(FFMPEG_PATH "${CMAKE_BINARY_DIR}/externals/${FFMPEG_EXT_NAME}")
+    download_bundled_external("ffmpeg/" ${FFMPEG_EXT_NAME} "")
+    set(FFMPEG_FOUND YES)
+    set(FFMPEG_INCLUDE_DIR "${FFMPEG_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
+    set(FFMPEG_LIBRARY_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg library" FORCE)
+    set(FFMPEG_DLL_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
 endif()

-if (YUZU_USE_BUNDLED_FFMPEG)
-    if (NOT WIN32)
-        # Build FFmpeg from externals
-        message(STATUS "Using FFmpeg from externals")
-
-        # FFmpeg has source that requires one of nasm or yasm to assemble it.
-        # REQUIRED throws an error if not found here during configuration rather than during compilation.
-        find_program(ASSEMBLER NAMES nasm yasm REQUIRED)
-
-        set(FFmpeg_PREFIX ${PROJECT_SOURCE_DIR}/externals/ffmpeg)
-        set(FFmpeg_BUILD_DIR ${PROJECT_BINARY_DIR}/externals/ffmpeg)
-        set(FFmpeg_MAKEFILE ${FFmpeg_BUILD_DIR}/Makefile)
-        make_directory(${FFmpeg_BUILD_DIR})
-
-        # Read version string from external
-        file(READ ${FFmpeg_PREFIX}/RELEASE FFmpeg_VERSION)
-        set(FFmpeg_FOUND NO)
-        if (NOT FFmpeg_VERSION STREQUAL "")
-            set(FFmpeg_FOUND YES)
-        endif()
-
-        foreach(COMPONENT ${FFmpeg_COMPONENTS})
-            set(FFmpeg_${COMPONENT}_PREFIX "${FFmpeg_BUILD_DIR}/lib${COMPONENT}")
-            set(FFmpeg_${COMPONENT}_LIB_NAME "lib${COMPONENT}.a")
-            set(FFmpeg_${COMPONENT}_LIBRARY "${FFmpeg_${COMPONENT}_PREFIX}/${FFmpeg_${COMPONENT}_LIB_NAME}")
-
-            set(FFmpeg_LIBRARIES
-                ${FFmpeg_LIBRARIES}
-                ${FFmpeg_${COMPONENT}_LIBRARY}
-                CACHE PATH "Paths to FFmpeg libraries" FORCE)
-        endforeach()
-
-        set(FFmpeg_INCLUDE_DIR
-            ${FFmpeg_PREFIX}
-            CACHE PATH "Path to FFmpeg headers" FORCE)
-
-        # `configure` parameters builds only exactly what yuzu needs from FFmpeg
-        # `--disable-{vaapi,vdpau}` is needed to avoid linking issues
-        add_custom_command(
-            OUTPUT
-                ${FFmpeg_MAKEFILE}
-            COMMAND
-                /bin/bash ${FFmpeg_PREFIX}/configure
-                    --disable-avdevice
-                    --disable-avfilter
-                    --disable-avformat
-                    --disable-doc
-                    --disable-everything
-                    --disable-ffmpeg
-                    --disable-ffprobe
-                    --disable-network
-                    --disable-postproc
-                    --disable-swresample
-                    --disable-vaapi
-                    --disable-vdpau
-                    --enable-decoder=h264
-                    --enable-decoder=vp9
-            WORKING_DIRECTORY
-                ${FFmpeg_BUILD_DIR}
-        )
-
-        # Workaround for Ubuntu 18.04's older version of make not being able to call make as a child
-        # with context of the jobserver. Also helps ninja users.
-        execute_process(
-            COMMAND
-                nproc
-            OUTPUT_VARIABLE
-                SYSTEM_THREADS)
-
-        add_custom_command(
-            OUTPUT
-                ${FFmpeg_LIBRARIES}
-            COMMAND
-                make -j${SYSTEM_THREADS}
-            WORKING_DIRECTORY
-                ${FFmpeg_BUILD_DIR}
-        )
-
-        # ALL makes this custom target build every time
-        # but it won't actually build if the DEPENDS parameter is up to date
-        add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_LIBRARIES})
-        add_custom_target(ffmpeg-configure ALL DEPENDS ${FFmpeg_MAKEFILE})
-
-        if (FFmpeg_FOUND)
-            message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
-
-            add_dependencies(ffmpeg-build ffmpeg-configure)
-        else()
-            message(FATAL_ERROR "FFmpeg not found")
-        endif()
-    else() # WIN32
-        # Use yuzu FFmpeg binaries
-        set(FFmpeg_EXT_NAME "ffmpeg-4.3.1")
-        set(FFmpeg_PATH "${CMAKE_BINARY_DIR}/externals/${FFmpeg_EXT_NAME}")
-        download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "")
-        set(FFmpeg_FOUND YES)
-        set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
-        set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg library directory" FORCE)
-        set(FFmpeg_DLL_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
-        set(FFmpeg_LIBRARIES
-            ${FFmpeg_LIBRARY_DIR}/swscale.lib
-            ${FFmpeg_LIBRARY_DIR}/avcodec.lib
-            ${FFmpeg_LIBRARY_DIR}/avutil.lib
-            CACHE PATH "Paths to FFmpeg libraries" FORCE)
-    endif()
-endif()
-
-unset(FFmpeg_COMPONENTS)
-
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
--- a/CMakeModules/CopyYuzuFFmpegDeps.cmake
+++ b/CMakeModules/CopyYuzuFFmpegDeps.cmake
@@ -1,6 +1,10 @@
 function(copy_yuzu_FFmpeg_deps target_dir)
    include(WindowsCopyFiles)
    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
-    file(READ "${FFmpeg_PATH}/requirements.txt" FFmpeg_REQUIRED_DLLS)
-    windows_copy_files(${target_dir} ${FFmpeg_DLL_DIR} ${DLL_DEST} ${FFmpeg_REQUIRED_DLLS})
+    windows_copy_files(${target_dir} ${FFMPEG_DLL_DIR} ${DLL_DEST}
+        avcodec-58.dll
+        avutil-56.dll
+        swresample-3.dll
+        swscale-5.dll
+    )
 endfunction(copy_yuzu_FFmpeg_deps)
--- a/README.md
+++ b/README.md
@@ -33,7 +33,7 @@ If you want to contribute to the user interface translation, please check out th


 ### 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
--- a/dist/icons/controller/controller.qrc
+++ b/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>	
--- a/dist/icons/controller/dual_joycon.png
+++ b/dist/icons/controller/dual_joycon.png
--- a/dist/icons/controller/dual_joycon_dark.png
+++ b/dist/icons/controller/dual_joycon_dark.png
--- a/dist/icons/controller/dual_joycon_midnight.png
+++ b/dist/icons/controller/dual_joycon_midnight.png
--- a/dist/icons/controller/handheld.png
+++ b/dist/icons/controller/handheld.png
--- a/dist/icons/controller/handheld_dark.png
+++ b/dist/icons/controller/handheld_dark.png
--- a/dist/icons/controller/handheld_midnight.png
+++ b/dist/icons/controller/handheld_midnight.png
--- a/dist/icons/controller/pro_controller.png
+++ b/dist/icons/controller/pro_controller.png
--- a/dist/icons/controller/pro_controller_dark.png
+++ b/dist/icons/controller/pro_controller_dark.png
--- a/dist/icons/controller/pro_controller_midnight.png
+++ b/dist/icons/controller/pro_controller_midnight.png
--- a/dist/icons/controller/single_joycon_left.png
+++ b/dist/icons/controller/single_joycon_left.png
--- a/dist/icons/controller/single_joycon_left_dark.png
+++ b/dist/icons/controller/single_joycon_left_dark.png
--- a/dist/icons/controller/single_joycon_left_midnight.png
+++ b/dist/icons/controller/single_joycon_left_midnight.png
--- a/dist/icons/controller/single_joycon_left_vertical.png
+++ b/dist/icons/controller/single_joycon_left_vertical.png
--- a/dist/icons/controller/single_joycon_left_vertical_dark.png
+++ b/dist/icons/controller/single_joycon_left_vertical_dark.png
--- a/dist/icons/controller/single_joycon_left_vertical_midnight.png
+++ b/dist/icons/controller/single_joycon_left_vertical_midnight.png
--- a/dist/icons/controller/single_joycon_right.png
+++ b/dist/icons/controller/single_joycon_right.png
--- a/dist/icons/controller/single_joycon_right_dark.png
+++ b/dist/icons/controller/single_joycon_right_dark.png
--- a/dist/icons/controller/single_joycon_right_midnight.png
+++ b/dist/icons/controller/single_joycon_right_midnight.png
--- a/dist/icons/controller/single_joycon_right_vertical.png
+++ b/dist/icons/controller/single_joycon_right_vertical.png
--- a/dist/icons/controller/single_joycon_right_vertical_dark.png
+++ b/dist/icons/controller/single_joycon_right_vertical_dark.png
--- a/dist/icons/controller/single_joycon_right_vertical_midnight.png
+++ b/dist/icons/controller/single_joycon_right_vertical_midnight.png
--- a/dist/license.md
+++ b/dist/license.md
@@ -12,7 +12,6 @@ qt_themes/default/icons/48x48/chip.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/48x48/folder.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/48x48/plus.png | CC0 1.0 | Designed by BreadFish64 from the Citra team
 qt_themes/default/icons/48x48/sd_card.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/default/icons/48x48/star.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/qdarkstyle/icons/16x16/lock.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/qdarkstyle/icons/16x16/view-refresh.png | Apache 2.0 | https://material.io
 qt_themes/qdarkstyle/icons/256x256/plus_folder.png | CC BY-ND 3.0 | https://icons8.com
@@ -21,7 +20,6 @@ qt_themes/qdarkstyle/icons/48x48/chip.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/qdarkstyle/icons/48x48/folder.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/qdarkstyle/icons/48x48/plus.png | CC0 1.0 | Designed by BreadFish64 from the Citra team
 qt_themes/qdarkstyle/icons/48x48/sd_card.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/qdarkstyle/icons/48x48/star.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/colorful/icons/16x16/lock.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/colorful/icons/16x16/view-refresh.png | Apache 2.0 | https://material.io
 qt_themes/colorful/icons/256x256/plus_folder.png | CC BY-ND 3.0 | https://icons8.com
@@ -30,6 +28,5 @@ qt_themes/colorful/icons/48x48/chip.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/colorful/icons/48x48/folder.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/colorful/icons/48x48/plus.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/colorful/icons/48x48/sd_card.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/colorful/icons/48x48/star.png | CC BY-ND 3.0 | https://icons8.com

 <!-- TODO: Add the license of the yuzu icon -->
--- a/dist/qt_themes/colorful/icons/48x48/star.png
+++ b/dist/qt_themes/colorful/icons/48x48/star.png
--- a/dist/qt_themes/colorful/style.qrc
+++ b/dist/qt_themes/colorful/style.qrc
@@ -7,7 +7,6 @@
        <file alias="48x48/folder.png">icons/48x48/folder.png</file>
        <file alias="48x48/plus.png">icons/48x48/plus.png</file>
        <file alias="48x48/sd_card.png">icons/48x48/sd_card.png</file>
-        <file alias="48x48/star.png">icons/48x48/star.png</file>
        <file alias="256x256/plus_folder.png">icons/256x256/plus_folder.png</file>
    </qresource>
    <qresource prefix="colorful">
--- a/dist/qt_themes/colorful_dark/icons/index.theme
+++ b/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]
--- a/dist/qt_themes/colorful_midnight_blue/icons/index.theme
+++ b/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]
--- a/dist/qt_themes/default/default.qrc
+++ b/dist/qt_themes/default/default.qrc
@@ -10,7 +10,6 @@
        <file alias="48x48/folder.png">icons/48x48/folder.png</file>
        <file alias="48x48/plus.png">icons/48x48/plus.png</file>
        <file alias="48x48/sd_card.png">icons/48x48/sd_card.png</file>
-        <file alias="48x48/star.png">icons/48x48/star.png</file>
        <file alias="256x256/yuzu.png">icons/256x256/yuzu.png</file>
        <file alias="256x256/plus_folder.png">icons/256x256/plus_folder.png</file>
    </qresource>
--- a/dist/qt_themes/default/icons/48x48/star.png
+++ b/dist/qt_themes/default/icons/48x48/star.png
--- a/dist/qt_themes/qdarkstyle/icons/48x48/star.png
+++ b/dist/qt_themes/qdarkstyle/icons/48x48/star.png
--- a/dist/qt_themes/qdarkstyle/style.qrc
+++ b/dist/qt_themes/qdarkstyle/style.qrc
@@ -8,7 +8,6 @@
    <file alias="48x48/folder.png">icons/48x48/folder.png</file>
    <file alias="48x48/plus.png">icons/48x48/plus.png</file>
    <file alias="48x48/sd_card.png">icons/48x48/sd_card.png</file>
-    <file alias="48x48/star.png">icons/48x48/star.png</file>
    <file alias="256x256/plus_folder.png">icons/256x256/plus_folder.png</file>
  </qresource>
  <qresource prefix="qss_icons">
--- a/dist/qt_themes/qdarkstyle_midnight_blue/icons/48x48/star.png
+++ b/dist/qt_themes/qdarkstyle_midnight_blue/icons/48x48/star.png
--- a/dist/qt_themes/qdarkstyle_midnight_blue/style.qrc
+++ b/dist/qt_themes/qdarkstyle_midnight_blue/style.qrc
@@ -8,7 +8,6 @@
    <file alias="48x48/folder.png">icons/48x48/folder.png</file>
    <file alias="48x48/plus.png">icons/48x48/plus.png</file>
    <file alias="48x48/sd_card.png">icons/48x48/sd_card.png</file>
-    <file alias="48x48/star.png">icons/48x48/star.png</file>
    <file alias="256x256/plus_folder.png">icons/256x256/plus_folder.png</file>
  </qresource>
  <qresource prefix="qss_icons">
--- a/dist/qt_themes/qdarkstyle_midnight_blue/style.qss
+++ b/dist/qt_themes/qdarkstyle_midnight_blue/style.qss
@@ -1257,6 +1257,10 @@ QComboBox::item:alternate {
  background: #19232D;
 }

+QComboBox::item:checked {
+  font-weight: bold;
+}
+
 QComboBox::item:selected {
  border: 0px solid transparent;
 }
--- a/dist/yuzu.bmp
+++ b/dist/yuzu.bmp
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -64,8 +64,8 @@ endif()
 add_subdirectory(sirit)

 # libzip
-find_package(libzip 1.5)
-if (NOT libzip_FOUND)
+find_package(Libzip 1.5)
+if (NOT LIBZIP_FOUND)
    message(STATUS "libzip 1.5 or newer not found, falling back to externals")
    add_subdirectory(libzip EXCLUDE_FROM_ALL)
 endif()
@@ -97,8 +97,4 @@ if (ENABLE_WEB_SERVICE)
 endif()

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

 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(FFmpeg
-  REQUIRED_VARS ${_FFmpeg_REQUIRED_VARS}
-  HANDLE_COMPONENTS
+
+find_package_handle_standard_args(FFMPEG
+  FOUND_VAR FFMPEG_FOUND
+  REQUIRED_VARS
+      FFMPEG_LIBRARY
+      FFMPEG_INCLUDE_DIR
+  VERSION_VAR FFMPEG_VERSION
 )

-foreach(c ${_FFmpeg_ALL_COMPONENTS})
-  unset(_FFmpeg_DEPS_${c})
-endforeach()
-unset(_FFmpeg_ALL_COMPONENTS)
-unset(_FFmpeg_REQUIRED_VARS)
+if(FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
+  # in cache already
+  set(FFMPEG_FOUND TRUE)
+else()
+  # use pkg-config to get the directories and then use these values
+  # in the FIND_PATH() and FIND_LIBRARY() calls
+  find_package(PkgConfig)
+  if(PKG_CONFIG_FOUND)
+    pkg_check_modules(_FFMPEG_AVCODEC libavcodec)
+    pkg_check_modules(_FFMPEG_AVUTIL libavutil)
+    pkg_check_modules(_FFMPEG_SWSCALE libswscale)
+  endif()
+
+  find_path(FFMPEG_AVCODEC_INCLUDE_DIR
+    NAMES libavcodec/avcodec.h
+    PATHS ${_FFMPEG_AVCODEC_INCLUDE_DIRS}
+      /usr/include
+      /usr/local/include
+      /opt/local/include
+      /sw/include
+    PATH_SUFFIXES ffmpeg libav)
+
+  find_library(FFMPEG_LIBAVCODEC
+    NAMES avcodec
+    PATHS ${_FFMPEG_AVCODEC_LIBRARY_DIRS}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib)
+
+  find_library(FFMPEG_LIBAVUTIL
+    NAMES avutil
+    PATHS ${_FFMPEG_AVUTIL_LIBRARY_DIRS}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib)
+
+  find_library(FFMPEG_LIBSWSCALE
+    NAMES swscale
+    PATHS ${_FFMPEG_SWSCALE_LIBRARY_DIRS}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib)
+
+  if(FFMPEG_LIBAVCODEC AND FFMPEG_LIBAVUTIL AND FFMPEG_LIBSWSCALE)
+    set(FFMPEG_FOUND TRUE)
+  endif()
+
+  if(FFMPEG_FOUND)
+    set(FFMPEG_INCLUDE_DIR ${FFMPEG_AVCODEC_INCLUDE_DIR})
+    set(FFMPEG_LIBRARIES
+      ${FFMPEG_LIBAVCODEC}
+      ${FFMPEG_LIBAVUTIL}
+      ${FFMPEG_LIBSWSCALE})
+  endif()
+
+  if(FFMPEG_FOUND)
+    if(NOT FFMPEG_FIND_QUIETLY)
+      message(STATUS
+      "Found FFMPEG or Libav: ${FFMPEG_LIBRARIES}, ${FFMPEG_INCLUDE_DIR}")
+    endif()
+  else()
+    if(FFMPEG_FIND_REQUIRED)
+      message(FATAL_ERROR
+      "Could not find libavcodec or libavutil or libswscale")
+    endif()
+  endif()
+endif()
--- a/externals/find-modules/FindLibzip.cmake
+++ b/externals/find-modules/FindLibzip.cmake
@@ -0,0 +1,72 @@
+
+find_package(PkgConfig QUIET)
+pkg_check_modules(PC_LIBZIP QUIET libzip)
+
+find_path(LIBZIP_INCLUDE_DIR
+  NAMES zip.h
+  PATHS ${PC_LIBZIP_INCLUDE_DIRS}
+  "$ENV{LIB_DIR}/include"
+  "$ENV{INCLUDE}"
+  /usr/local/include
+  /usr/include
+)
+find_path(LIBZIP_INCLUDE_DIR_ZIPCONF
+  NAMES zipconf.h
+  HINTS ${PC_LIBZIP_INCLUDE_DIRS}
+  "$ENV{LIB_DIR}/include"
+  "$ENV{LIB_DIR}/lib/libzip/include"
+  "$ENV{LIB}/lib/libzip/include"
+  /usr/local/lib/libzip/include
+  /usr/lib/libzip/include
+  /usr/local/include
+  /usr/include
+  "$ENV{INCLUDE}"
+)
+find_library(LIBZIP_LIBRARY
+  NAMES zip
+  PATHS ${PC_LIBZIP_LIBRARY_DIRS}
+  "$ENV{LIB_DIR}/lib" "$ENV{LIB}" /usr/local/lib /usr/lib
+)
+
+if (LIBZIP_INCLUDE_DIR_ZIPCONF)
+  FILE(READ "${LIBZIP_INCLUDE_DIR_ZIPCONF}/zipconf.h" _LIBZIP_VERSION_CONTENTS)
+  if (_LIBZIP_VERSION_CONTENTS)
+    STRING(REGEX REPLACE ".*#define LIBZIP_VERSION \"([0-9.]+)\".*" "\\1" LIBZIP_VERSION "${_LIBZIP_VERSION_CONTENTS}")
+  endif()
+  unset(_LIBZIP_VERSION_CONTENTS)
+endif()
+
+set(LIBZIP_VERSION ${LIBZIP_VERSION} CACHE STRING "Version number of libzip")
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Libzip
+  FOUND_VAR LIBZIP_FOUND
+  REQUIRED_VARS
+    LIBZIP_LIBRARY
+    LIBZIP_INCLUDE_DIR
+    LIBZIP_INCLUDE_DIR_ZIPCONF
+    LIBZIP_VERSION
+  VERSION_VAR LIBZIP_VERSION
+)
+
+if(LIBZIP_FOUND)
+  set(LIBZIP_LIBRARIES ${LIBZIP_LIBRARY})
+  set(LIBZIP_INCLUDE_DIRS ${LIBZIP_INCLUDE_DIR})
+  set(LIBZIP_DEFINITIONS ${PC_LIBZIP_CFLAGS_OTHER})
+endif()
+
+if(LIBZIP_FOUND AND NOT TARGET libzip::libzip)
+  add_library(libzip::libzip UNKNOWN IMPORTED)
+  set_target_properties(libzip::libzip PROPERTIES
+    IMPORTED_LOCATION "${LIBZIP_LIBRARY}"
+    INTERFACE_COMPILE_OPTIONS "${PC_LIBZIP_CFLAGS_OTHER}"
+    INTERFACE_INCLUDE_DIRECTORIES "${LIBZIP_INCLUDE_DIR}"
+  )
+endif()
+
+mark_as_advanced(
+    LIBZIP_INCLUDE_DIR
+    LIBZIP_INCLUDE_DIR_ZIPCONF
+    LIBZIP_LIBRARY
+    LIBZIP_VERSION
+)
--- a/externals/find-modules/Findlibzip.cmake
+++ b/externals/find-modules/Findlibzip.cmake
@@ -1,72 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_libzip QUIET libzip)
-
-find_path(libzip_INCLUDE_DIR
-  NAMES zip.h
-  PATHS ${PC_libzip_INCLUDE_DIRS}
-  "$ENV{LIB_DIR}/include"
-  "$ENV{INCLUDE}"
-  /usr/local/include
-  /usr/include
-)
-find_path(libzip_INCLUDE_DIR_ZIPCONF
-  NAMES zipconf.h
-  HINTS ${PC_libzip_INCLUDE_DIRS}
-  "$ENV{LIB_DIR}/include"
-  "$ENV{LIB_DIR}/lib/libzip/include"
-  "$ENV{LIB}/lib/libzip/include"
-  /usr/local/lib/libzip/include
-  /usr/lib/libzip/include
-  /usr/local/include
-  /usr/include
-  "$ENV{INCLUDE}"
-)
-find_library(libzip_LIBRARY
-  NAMES zip
-  PATHS ${PC_libzip_LIBRARY_DIRS}
-  "$ENV{LIB_DIR}/lib" "$ENV{LIB}" /usr/local/lib /usr/lib
-)
-
-if (libzip_INCLUDE_DIR_ZIPCONF)
-  FILE(READ "${libzip_INCLUDE_DIR_ZIPCONF}/zipconf.h" _libzip_VERSION_CONTENTS)
-  if (_libzip_VERSION_CONTENTS)
-    STRING(REGEX REPLACE ".*#define LIBZIP_VERSION \"([0-9.]+)\".*" "\\1" libzip_VERSION "${_libzip_VERSION_CONTENTS}")
-  endif()
-  unset(_libzip_VERSION_CONTENTS)
-endif()
-
-set(libzip_VERSION ${libzip_VERSION} CACHE STRING "Version number of libzip")
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(libzip
-  FOUND_VAR libzip_FOUND
-  REQUIRED_VARS
-    libzip_LIBRARY
-    libzip_INCLUDE_DIR
-    libzip_INCLUDE_DIR_ZIPCONF
-    libzip_VERSION
-  VERSION_VAR libzip_VERSION
-)
-
-if(libzip_FOUND)
-  set(libzip_LIBRARIES ${libzip_LIBRARY})
-  set(libzip_INCLUDE_DIRS ${libzip_INCLUDE_DIR})
-  set(libzip_DEFINITIONS ${PC_libzip_CFLAGS_OTHER})
-endif()
-
-if(libzip_FOUND AND NOT TARGET libzip::libzip)
-  add_library(libzip::libzip UNKNOWN IMPORTED)
-  set_target_properties(libzip::libzip PROPERTIES
-    IMPORTED_LOCATION "${libzip_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_libzip_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${libzip_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    libzip_INCLUDE_DIR
-    libzip_INCLUDE_DIR_ZIPCONF
-    libzip_LIBRARY
-    libzip_VERSION
-)
--- a/externals/find-modules/Findopus.cmake
+++ b/externals/find-modules/Findopus.cmake
@@ -28,7 +28,7 @@ if(opus_FOUND)
 endif()

 if(opus_FOUND AND NOT TARGET Opus::Opus)
-  add_library(Opus::Opus UNKNOWN IMPORTED GLOBAL)
+  add_library(Opus::Opus UNKNOWN IMPORTED)
  set_target_properties(Opus::Opus PROPERTIES
    IMPORTED_LOCATION "${opus_LIBRARY}"
    INTERFACE_COMPILE_OPTIONS "${PC_opus_CFLAGS_OTHER}"
--- a/externals/glad/include/glad/glad.h
+++ b/externals/glad/include/glad/glad.h
@@ -5156,9 +5156,6 @@ GLAPI PFNGLDEPTHRANGEARRAYVPROC glad_glDepthRangeArrayv;
 typedef void (APIENTRYP PFNGLDEPTHRANGEINDEXEDPROC)(GLuint index, GLdouble n, GLdouble f);
 GLAPI PFNGLDEPTHRANGEINDEXEDPROC glad_glDepthRangeIndexed;
 #define glDepthRangeIndexed glad_glDepthRangeIndexed
-typedef void (APIENTRYP PFNGLDEPTHRANGEINDEXEDDNVPROC)(GLuint index, GLdouble n, GLdouble f);
-GLAPI PFNGLDEPTHRANGEINDEXEDDNVPROC glad_glDepthRangeIndexeddNV;
-#define glDepthRangeIndexeddNV glad_glDepthRangeIndexeddNV
 typedef void (APIENTRYP PFNGLGETFLOATI_VPROC)(GLenum target, GLuint index, GLfloat *data);
 GLAPI PFNGLGETFLOATI_VPROC glad_glGetFloati_v;
 #define glGetFloati_v glad_glGetFloati_v
--- a/externals/glad/src/glad.c
+++ b/externals/glad/src/glad.c
@@ -1044,7 +1044,6 @@ PFNGLDEPTHMASKPROC glad_glDepthMask = NULL;
 PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL;
 PFNGLDEPTHRANGEARRAYVPROC glad_glDepthRangeArrayv = NULL;
 PFNGLDEPTHRANGEINDEXEDPROC glad_glDepthRangeIndexed = NULL;
-PFNGLDEPTHRANGEINDEXEDDNVPROC glad_glDepthRangeIndexeddNV = NULL;
 PFNGLDEPTHRANGEFPROC glad_glDepthRangef = NULL;
 PFNGLDETACHSHADERPROC glad_glDetachShader = NULL;
 PFNGLDISABLEPROC glad_glDisable = NULL;
@@ -7972,7 +7971,6 @@ static void load_GL_NV_depth_buffer_float(GLADloadproc load) {
 	glad_glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)load("glDepthRangedNV");
 	glad_glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)load("glClearDepthdNV");
 	glad_glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)load("glDepthBoundsdNV");
-	glad_glDepthRangeIndexeddNV = (PFNGLDEPTHRANGEINDEXEDDNVPROC)load("glDepthRangeIndexeddNV");
 }
 static void load_GL_NV_draw_texture(GLADloadproc load) {
 	if(!GLAD_GL_NV_draw_texture) return;
--- a/externals/libusb/CMakeLists.txt
+++ b/externals/libusb/CMakeLists.txt
@@ -1,8 +1,3 @@
-# Ensure libusb compiles with UTF-8 encoding on MSVC
-if(MSVC)
-    add_compile_options(/utf-8)
-endif()
-
 add_library(usb STATIC EXCLUDE_FROM_ALL
    libusb/libusb/core.c
    libusb/libusb/core.c
--- a/externals/mbedtls
+++ b/externals/mbedtls
--- a/externals/opus/CMakeLists.txt
+++ b/externals/opus/CMakeLists.txt
@@ -252,5 +252,3 @@ PRIVATE
    opus/silk/float
    opus/src
 )
-
-add_library(Opus::Opus ALIAS opus)
--- a/license.txt
+++ b/license.txt
@@ -358,7 +358,6 @@ chip.png (Colorful, Colorful Dark)          | CC BY-ND 3.0  | https://icons8.com
 folder.png (Colorful, Colorful Dark)        | CC BY-ND 3.0  | https://icons8.com
 plus.png (Colorful, Colorful Dark)          | CC BY-ND 3.0  | https://icons8.com
 sd_card.png (Colorful, Colorful Dark)       | CC BY-ND 3.0  | https://icons8.com
-star.png                                    | CC BY-ND 3.0  | https://icons8.com

 Note:
 Some icons are different in different themes, and they are separately listed
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -27,7 +27,6 @@ if (MSVC)
    # /Zo                 - Enhanced debug info for optimized builds
    # /permissive-        - Enables stricter C++ standards conformance checks
    # /EHsc               - C++-only exception handling semantics
-    # /utf-8              - Set source and execution character sets to UTF-8
    # /volatile:iso       - Use strict standards-compliant volatile semantics.
    # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
    # /Zc:inline          - Let codegen omit inline functions in object files
@@ -39,7 +38,6 @@ if (MSVC)
        /permissive-
        /EHsc
        /std:c++latest
-        /utf-8
        /volatile:iso
        /Zc:externConstexpr
        /Zc:inline
--- a/src/audio_core/CMakeLists.txt
+++ b/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
--- a/src/audio_core/audio_renderer.cpp
+++ b/src/audio_core/audio_renderer.cpp
@@ -2,7 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <future>
 #include <limits>
+#include <mutex>
 #include <vector>

 #include "audio_core/audio_out.h"
@@ -315,9 +317,18 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
 }

 void AudioRenderer::ReleaseAndQueueBuffers() {
+    std::size_t thread_counter = 0;
    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream)};
+    queue_mixed_multithread.resize(released_buffers.size());
    for (const auto& tag : released_buffers) {
-        QueueMixedBuffer(tag);
+        queue_mixed_multithread[thread_counter] =
+            std::async(std::launch::async, [this, tag, voice_context = voice_context,
+                                            splitter_context = splitter_context,
+                                            mix_context = mix_context] { QueueMixedBuffer(tag); });
+        thread_counter++;
+    }
+    for (std::size_t thread = 0; thread < released_buffers.size(); thread++) {
+        queue_mixed_multithread[thread].wait();
    }
 }

--- a/src/audio_core/audio_renderer.h
+++ b/src/audio_core/audio_renderer.h
@@ -5,7 +5,9 @@
 #pragma once

 #include <array>
+#include <future>
 #include <memory>
+#include <mutex>
 #include <vector>

 #include "audio_core/behavior_info.h"
@@ -68,6 +70,7 @@ private:
    Core::Memory::Memory& memory;
    CommandGenerator command_generator;
    std::size_t elapsed_frame_count{};
+    std::vector<std::future<void>> queue_mixed_multithread;
 };

 } // namespace AudioCore
--- a/src/audio_core/command_generator.cpp
+++ b/src/audio_core/command_generator.cpp
@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <cmath>
-#include <numbers>
 #include "audio_core/algorithm/interpolate.h"
 #include "audio_core/command_generator.h"
 #include "audio_core/effect_context.h"
@@ -15,20 +13,6 @@ namespace AudioCore {
 namespace {
 constexpr std::size_t MIX_BUFFER_SIZE = 0x3f00;
 constexpr std::size_t SCALED_MIX_BUFFER_SIZE = MIX_BUFFER_SIZE << 15ULL;
-using DelayLineTimes = std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT>;
-
-constexpr DelayLineTimes FDN_MIN_DELAY_LINE_TIMES{5.0f, 6.0f, 13.0f, 14.0f};
-constexpr DelayLineTimes FDN_MAX_DELAY_LINE_TIMES{45.704f, 82.782f, 149.94f, 271.58f};
-constexpr DelayLineTimes DECAY0_MAX_DELAY_LINE_TIMES{17.0f, 13.0f, 9.0f, 7.0f};
-constexpr DelayLineTimes DECAY1_MAX_DELAY_LINE_TIMES{19.0f, 11.0f, 10.0f, 6.0f};
-constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_TAP_TIMES{
-    0.017136f, 0.059154f, 0.161733f, 0.390186f, 0.425262f, 0.455411f, 0.689737f,
-    0.745910f, 0.833844f, 0.859502f, 0.000000f, 0.075024f, 0.168788f, 0.299901f,
-    0.337443f, 0.371903f, 0.599011f, 0.716741f, 0.817859f, 0.851664f};
-constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_GAIN{
-    0.67096f, 0.61027f, 1.0f,     0.35680f, 0.68361f, 0.65978f, 0.51939f,
-    0.24712f, 0.45945f, 0.45021f, 0.64196f, 0.54879f, 0.92925f, 0.38270f,
-    0.72867f, 0.69794f, 0.5464f,  0.24563f, 0.45214f, 0.44042f};

 template <std::size_t N>
 void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
@@ -81,154 +65,6 @@ s32 ApplyMixDepop(s32* output, s32 first_sample, s32 delta, s32 sample_count) {
    }
 }

-float Pow10(float x) {
-    if (x >= 0.0f) {
-        return 1.0f;
-    } else if (x <= -5.3f) {
-        return 0.0f;
-    }
-    return std::pow(10.0f, x);
-}
-
-float SinD(float degrees) {
-    return std::sin(degrees * std::numbers::pi_v<float> / 180.0f);
-}
-
-float CosD(float degrees) {
-    return std::cos(degrees * std::numbers::pi_v<float> / 180.0f);
-}
-
-float ToFloat(s32 sample) {
-    return static_cast<float>(sample) / 65536.f;
-}
-
-s32 ToS32(float sample) {
-    constexpr auto min = -8388608.0f;
-    constexpr auto max = 8388607.f;
-    float rescaled_sample = sample * 65536.0f;
-    if (rescaled_sample < min) {
-        rescaled_sample = min;
-    }
-    if (rescaled_sample > max) {
-        rescaled_sample = max;
-    }
-    return static_cast<s32>(rescaled_sample);
-}
-
-constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_1CH{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-
-constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_2CH{0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
-                                                           1, 1, 1, 0, 0, 0, 0, 1, 1, 1};
-
-constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_4CH{0, 0, 0, 1, 1, 1, 1, 2, 2, 2,
-                                                           1, 1, 1, 0, 0, 0, 0, 3, 3, 3};
-
-constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_6CH{4, 0, 0, 1, 1, 1, 1, 2, 2, 2,
-                                                           1, 1, 1, 0, 0, 0, 0, 3, 3, 3};
-
-template <std::size_t CHANNEL_COUNT>
-void ApplyReverbGeneric(I3dl2ReverbState& state,
-                        const std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT>& input,
-                        const std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT>& output,
-                        s32 sample_count) {
-
-    auto GetTapLookup = []() {
-        if constexpr (CHANNEL_COUNT == 1) {
-            return REVERB_TAP_INDEX_1CH;
-        } else if constexpr (CHANNEL_COUNT == 2) {
-            return REVERB_TAP_INDEX_2CH;
-        } else if constexpr (CHANNEL_COUNT == 4) {
-            return REVERB_TAP_INDEX_4CH;
-        } else if constexpr (CHANNEL_COUNT == 6) {
-            return REVERB_TAP_INDEX_6CH;
-        }
-    };
-
-    const auto& tap_index_lut = GetTapLookup();
-    for (s32 sample = 0; sample < sample_count; sample++) {
-        std::array<f32, CHANNEL_COUNT> out_samples{};
-        std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> fsamp{};
-        std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> mixed{};
-        std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> osamp{};
-
-        // Mix everything into a single sample
-        s32 temp_mixed_sample = 0;
-        for (std::size_t i = 0; i < CHANNEL_COUNT; i++) {
-            temp_mixed_sample += input[i][sample];
-        }
-        const auto current_sample = ToFloat(temp_mixed_sample);
-        const auto early_tap = state.early_delay_line.TapOut(state.early_to_late_taps);
-
-        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_TAPS; i++) {
-            const auto tapped_samp =
-                state.early_delay_line.TapOut(state.early_tap_steps[i]) * EARLY_GAIN[i];
-            out_samples[tap_index_lut[i]] += tapped_samp;
-
-            if constexpr (CHANNEL_COUNT == 6) {
-                // handle lfe
-                out_samples[5] += tapped_samp;
-            }
-        }
-
-        state.lowpass_0 = current_sample * state.lowpass_2 + state.lowpass_0 * state.lowpass_1;
-        state.early_delay_line.Tick(state.lowpass_0);
-
-        for (std::size_t i = 0; i < CHANNEL_COUNT; i++) {
-            out_samples[i] *= state.early_gain;
-        }
-
-        // Two channel seems to apply a latet gain, we require to save this
-        f32 filter{};
-        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
-            filter = state.fdn_delay_line[i].GetOutputSample();
-            const auto computed = filter * state.lpf_coefficients[0][i] + state.shelf_filter[i];
-            state.shelf_filter[i] =
-                filter * state.lpf_coefficients[1][i] + computed * state.lpf_coefficients[2][i];
-            fsamp[i] = computed;
-        }
-
-        // Mixing matrix
-        mixed[0] = fsamp[1] + fsamp[2];
-        mixed[1] = -fsamp[0] - fsamp[3];
-        mixed[2] = fsamp[0] - fsamp[3];
-        mixed[3] = fsamp[1] - fsamp[2];
-
-        if constexpr (CHANNEL_COUNT == 2) {
-            for (auto& mix : mixed) {
-                mix *= (filter * state.late_gain);
-            }
-        }
-
-        for (std::size_t i = 0; i < AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT; i++) {
-            const auto late = early_tap * state.late_gain;
-            osamp[i] = state.decay_delay_line0[i].Tick(late + mixed[i]);
-            osamp[i] = state.decay_delay_line1[i].Tick(osamp[i]);
-            state.fdn_delay_line[i].Tick(osamp[i]);
-        }
-
-        if constexpr (CHANNEL_COUNT == 1) {
-            output[0][sample] = ToS32(state.dry_gain * ToFloat(input[0][sample]) +
-                                      (out_samples[0] + osamp[0] + osamp[1]));
-        } else if constexpr (CHANNEL_COUNT == 2 || CHANNEL_COUNT == 4) {
-            for (std::size_t i = 0; i < CHANNEL_COUNT; i++) {
-                output[i][sample] =
-                    ToS32(state.dry_gain * ToFloat(input[i][sample]) + (out_samples[i] + osamp[i]));
-            }
-        } else if constexpr (CHANNEL_COUNT == 6) {
-            const auto temp_center = state.center_delay_line.Tick(0.5f * (osamp[2] - osamp[3]));
-            for (std::size_t i = 0; i < 4; i++) {
-                output[i][sample] =
-                    ToS32(state.dry_gain * ToFloat(input[i][sample]) + (out_samples[i] + osamp[i]));
-            }
-            output[4][sample] =
-                ToS32(state.dry_gain * ToFloat(input[4][sample]) + (out_samples[4] + temp_center));
-            output[5][sample] =
-                ToS32(state.dry_gain * ToFloat(input[5][sample]) + (out_samples[5] + osamp[3]));
-        }
-    }
-}
-
 } // namespace

 CommandGenerator::CommandGenerator(AudioCommon::AudioRendererParameter& worker_params_,
@@ -435,10 +271,11 @@ void CommandGenerator::GenerateBiquadFilterCommandForVoice(ServerVoiceInfo& voic
        }

        // Generate biquad filter
-        // GenerateBiquadFilterCommand(mix_buffer_count, biquad_filter,
-        // dsp_state.biquad_filter_state,
-        //                            mix_buffer_count + channel, mix_buffer_count + channel,
-        //                            worker_params.sample_count, voice_info.GetInParams().node_id);
+        //        GenerateBiquadFilterCommand(mix_buffer_count, biquad_filter,
+        //        dsp_state.biquad_filter_state,
+        //                                    mix_buffer_count + channel, mix_buffer_count +
+        //                                    channel, worker_params.sample_count,
+        //                                    voice_info.GetInParams().node_id);
    }
 }

@@ -539,54 +376,21 @@ 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);
+        }*/
+        auto* output = GetMixBuffer(mix_buffer_offset + params.output[i]);
+        std::memset(output, 0, worker_params.sample_count * sizeof(s32));
    }
 }

@@ -724,133 +528,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);
--- a/src/audio_core/command_generator.h
+++ b/src/audio_core/command_generator.h
@@ -21,8 +21,6 @@ class ServerMixInfo;
 class EffectContext;
 class EffectBase;
 struct AuxInfoDSP;
-struct I3dl2ReverbParams;
-struct I3dl2ReverbState;
 using MixVolumeBuffer = std::array<float, AudioCommon::MAX_MIX_BUFFERS>;

 class CommandGenerator {
@@ -82,9 +80,6 @@ private:
    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples, s32* out_data,
                      u32 sample_count, u32 read_offset, u32 read_count);

-    void InitializeI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
-                               std::vector<u8>& work_buffer);
-    void UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state, bool should_clear);
    // DSP Code
    s32 DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_count,
                    s32 channel, std::size_t mix_offset);
--- a/src/audio_core/common.h
+++ b/src/audio_core/common.h
@@ -33,29 +33,6 @@ constexpr std::size_t TEMP_MIX_BASE_SIZE = 0x3f00; // TODO(ogniK): Work out this
 // and our const ends up being 0x3f04, the 4 bytes are most
 // likely the sample history
 constexpr std::size_t TOTAL_TEMP_MIX_SIZE = TEMP_MIX_BASE_SIZE + AudioCommon::MAX_SAMPLE_HISTORY;
-constexpr f32 I3DL2REVERB_MAX_LEVEL = 5000.0f;
-constexpr f32 I3DL2REVERB_MIN_REFLECTION_DURATION = 0.02f;
-constexpr std::size_t I3DL2REVERB_TAPS = 20;
-constexpr std::size_t I3DL2REVERB_DELAY_LINE_COUNT = 4;
-using Fractional = s32;
-
-template <typename T>
-constexpr Fractional ToFractional(T x) {
-    return static_cast<Fractional>(x * static_cast<T>(0x4000));
-}
-
-constexpr Fractional MultiplyFractional(Fractional lhs, Fractional rhs) {
-    return static_cast<Fractional>(static_cast<s64>(lhs) * rhs >> 14);
-}
-
-constexpr s32 FractionalToFixed(Fractional x) {
-    const auto s = x & (1 << 13);
-    return static_cast<s32>(x >> 14) + s;
-}
-
-constexpr s32 CalculateDelaySamples(s32 sample_rate_khz, float time) {
-    return FractionalToFixed(MultiplyFractional(ToFractional(sample_rate_khz), ToFractional(time)));
-}

 static constexpr u32 VersionFromRevision(u32_le rev) {
    // "REV7" -> 7
--- a/src/audio_core/delay_line.cpp
+++ b/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
--- a/src/audio_core/delay_line.h
+++ b/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
--- a/src/audio_core/effect_context.cpp
+++ b/src/audio_core/effect_context.cpp
@@ -90,14 +90,6 @@ s32 EffectBase::GetProcessingOrder() const {
    return processing_order;
 }

-std::vector<u8>& EffectBase::GetWorkBuffer() {
-    return work_buffer;
-}
-
-const std::vector<u8>& EffectBase::GetWorkBuffer() const {
-    return work_buffer;
-}
-
 EffectI3dl2Reverb::EffectI3dl2Reverb() : EffectGeneric(EffectType::I3dl2Reverb) {}
 EffectI3dl2Reverb::~EffectI3dl2Reverb() = default;

@@ -125,12 +117,6 @@ void EffectI3dl2Reverb::Update(EffectInfo::InParams& in_params) {
        usage = UsageState::Initialized;
        params.status = ParameterStatus::Initialized;
        skipped = in_params.buffer_address == 0 || in_params.buffer_size == 0;
-        if (!skipped) {
-            auto& cur_work_buffer = GetWorkBuffer();
-            // Has two buffers internally
-            cur_work_buffer.resize(in_params.buffer_size * 2);
-            std::fill(cur_work_buffer.begin(), cur_work_buffer.end(), 0);
-        }
    }
 }

@@ -143,14 +129,6 @@ void EffectI3dl2Reverb::UpdateForCommandGeneration() {
    GetParams().status = ParameterStatus::Updated;
 }

-I3dl2ReverbState& EffectI3dl2Reverb::GetState() {
-    return state;
-}
-
-const I3dl2ReverbState& EffectI3dl2Reverb::GetState() const {
-    return state;
-}
-
 EffectBiquadFilter::EffectBiquadFilter() : EffectGeneric(EffectType::BiquadFilter) {}
 EffectBiquadFilter::~EffectBiquadFilter() = default;

--- a/src/audio_core/effect_context.h
+++ b/src/audio_core/effect_context.h
@@ -8,7 +8,6 @@
 #include <memory>
 #include <vector>
 #include "audio_core/common.h"
-#include "audio_core/delay_line.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -195,8 +194,6 @@ public:
    [[nodiscard]] bool IsEnabled() const;
    [[nodiscard]] s32 GetMixID() const;
    [[nodiscard]] s32 GetProcessingOrder() const;
-    [[nodiscard]] std::vector<u8>& GetWorkBuffer();
-    [[nodiscard]] const std::vector<u8>& GetWorkBuffer() const;

 protected:
    UsageState usage{UsageState::Invalid};
@@ -204,7 +201,6 @@ protected:
    s32 mix_id{};
    s32 processing_order{};
    bool enabled = false;
-    std::vector<u8> work_buffer{};
 };

 template <typename T>
@@ -216,7 +212,7 @@ public:
        return internal_params;
    }

-    const T& GetParams() const {
+    const I3dl2ReverbParams& GetParams() const {
        return internal_params;
    }

@@ -233,27 +229,6 @@ public:
    void UpdateForCommandGeneration() override;
 };

-struct I3dl2ReverbState {
-    f32 lowpass_0{};
-    f32 lowpass_1{};
-    f32 lowpass_2{};
-
-    DelayLineBase early_delay_line{};
-    std::array<u32, AudioCommon::I3DL2REVERB_TAPS> early_tap_steps{};
-    f32 early_gain{};
-    f32 late_gain{};
-
-    u32 early_to_late_taps{};
-    std::array<DelayLineBase, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> fdn_delay_line{};
-    std::array<DelayLineAllPass, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> decay_delay_line0{};
-    std::array<DelayLineAllPass, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> decay_delay_line1{};
-    f32 last_reverb_echo{};
-    DelayLineBase center_delay_line{};
-    std::array<std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT>, 3> lpf_coefficients{};
-    std::array<f32, AudioCommon::I3DL2REVERB_DELAY_LINE_COUNT> shelf_filter{};
-    f32 dry_gain{};
-};
-
 class EffectI3dl2Reverb : public EffectGeneric<I3dl2ReverbParams> {
 public:
    explicit EffectI3dl2Reverb();
@@ -262,12 +237,8 @@ public:
    void Update(EffectInfo::InParams& in_params) override;
    void UpdateForCommandGeneration() override;

-    I3dl2ReverbState& GetState();
-    const I3dl2ReverbState& GetState() const;
-
 private:
    bool skipped = false;
-    I3dl2ReverbState state{};
 };

 class EffectBiquadFilter : public EffectGeneric<BiquadFilterParams> {
--- a/src/audio_core/stream.cpp
+++ b/src/audio_core/stream.cpp
@@ -111,14 +111,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) {
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -97,7 +97,6 @@ add_custom_command(OUTPUT scm_rev.cpp
 add_library(common STATIC
    algorithm.h
    alignment.h
-    assert.cpp
    assert.h
    atomic_ops.h
    detached_tasks.cpp
@@ -110,7 +109,6 @@ add_library(common STATIC
    cityhash.h
    common_funcs.h
    common_paths.h
-    common_sizes.h
    common_types.h
    concepts.h
    div_ceil.h
@@ -169,8 +167,8 @@ add_library(common STATIC
    threadsafe_queue.h
    time_zone.cpp
    time_zone.h
-    tiny_mt.h
    tree.h
+    uint128.cpp
    uint128.h
    uuid.cpp
    uuid.h
@@ -208,8 +206,6 @@ if (MSVC)
 else()
  target_compile_options(common PRIVATE
    -Werror
-
-    $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
  )
 endif()

--- a/src/common/alignment.h
+++ b/src/common/alignment.h
@@ -42,11 +42,6 @@ requires std::is_integral_v<T>[[nodiscard]] constexpr bool IsAligned(T value, si
    return (value & mask) == 0;
 }

-template <typename T, typename U>
-requires std::is_integral_v<T>[[nodiscard]] constexpr T DivideUp(T x, U y) {
-    return (x + (y - 1)) / y;
-}
-
 template <typename T, size_t Align = 16>
 class AlignmentAllocator {
 public:
--- a/src/common/assert.cpp
+++ b/src/common/assert.cpp
@@ -1,11 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-
-#include "common/common_funcs.h"
-
-void assert_handle_failure() {
-    Crash();
-}
--- a/src/common/assert.h
+++ b/src/common/assert.h
@@ -4,13 +4,10 @@

 #pragma once

+#include <cstdlib>
+#include "common/common_funcs.h"
 #include "common/logging/log.h"

-// Sometimes we want to try to continue even after hitting an assert.
-// However touching this file yields a global recompilation as this header is included almost
-// everywhere. So let's just move the handling of the failed assert to a single cpp file.
-void assert_handle_failure();
-
 // For asserts we'd like to keep all the junk executed when an assert happens away from the
 // important code in the function. One way of doing this is to put all the relevant code inside a
 // lambda and force the compiler to not inline it. Unfortunately, MSVC seems to have no syntax to
@@ -20,14 +17,15 @@ void assert_handle_failure();
 // enough for our purposes.
 template <typename Fn>
 #if defined(_MSC_VER)
-[[msvc::noinline]]
+[[msvc::noinline, noreturn]]
 #elif defined(__GNUC__)
-[[gnu::cold, gnu::noinline]]
+[[gnu::cold, gnu::noinline, noreturn]]
 #endif
 static void
 assert_noinline_call(const Fn& fn) {
    fn();
-    assert_handle_failure();
+    Crash();
+    exit(1); // Keeps GCC's mouth shut about this actually returning
 }

 #define ASSERT(_a_)                                                                                \
--- a/src/common/cityhash.cpp
+++ b/src/common/cityhash.cpp
@@ -28,10 +28,8 @@
 // compromising on hash quality.

 #include <algorithm>
-#include <cstring>
-#include <utility>
-
-#include "common/cityhash.h"
+#include <string.h> // for memcpy and memset
+#include "cityhash.h"
 #include "common/swap.h"

 // #include "config.h"
@@ -44,17 +42,21 @@

 using namespace std;

+typedef uint8_t uint8;
+typedef uint32_t uint32;
+typedef uint64_t uint64;
+
 namespace Common {

-static u64 unaligned_load64(const char* p) {
-    u64 result;
-    std::memcpy(&result, p, sizeof(result));
+static uint64 UNALIGNED_LOAD64(const char* p) {
+    uint64 result;
+    memcpy(&result, p, sizeof(result));
    return result;
 }

-static u32 unaligned_load32(const char* p) {
-    u32 result;
-    std::memcpy(&result, p, sizeof(result));
+static uint32 UNALIGNED_LOAD32(const char* p) {
+    uint32 result;
+    memcpy(&result, p, sizeof(result));
    return result;
 }

@@ -74,64 +76,64 @@ static u32 unaligned_load32(const char* p) {
 #endif
 #endif

-static u64 Fetch64(const char* p) {
-    return uint64_in_expected_order(unaligned_load64(p));
+static uint64 Fetch64(const char* p) {
+    return uint64_in_expected_order(UNALIGNED_LOAD64(p));
 }

-static u32 Fetch32(const char* p) {
-    return uint32_in_expected_order(unaligned_load32(p));
+static uint32 Fetch32(const char* p) {
+    return uint32_in_expected_order(UNALIGNED_LOAD32(p));
 }

 // Some primes between 2^63 and 2^64 for various uses.
-static constexpr u64 k0 = 0xc3a5c85c97cb3127ULL;
-static constexpr u64 k1 = 0xb492b66fbe98f273ULL;
-static constexpr u64 k2 = 0x9ae16a3b2f90404fULL;
+static const uint64 k0 = 0xc3a5c85c97cb3127ULL;
+static const uint64 k1 = 0xb492b66fbe98f273ULL;
+static const uint64 k2 = 0x9ae16a3b2f90404fULL;

 // Bitwise right rotate.  Normally this will compile to a single
 // instruction, especially if the shift is a manifest constant.
-static u64 Rotate(u64 val, int shift) {
+static uint64 Rotate(uint64 val, int shift) {
    // Avoid shifting by 64: doing so yields an undefined result.
    return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
 }

-static u64 ShiftMix(u64 val) {
+static uint64 ShiftMix(uint64 val) {
    return val ^ (val >> 47);
 }

-static u64 HashLen16(u64 u, u64 v) {
-    return Hash128to64(u128{u, v});
+static uint64 HashLen16(uint64 u, uint64 v) {
+    return Hash128to64(uint128(u, v));
 }

-static u64 HashLen16(u64 u, u64 v, u64 mul) {
+static uint64 HashLen16(uint64 u, uint64 v, uint64 mul) {
    // Murmur-inspired hashing.
-    u64 a = (u ^ v) * mul;
+    uint64 a = (u ^ v) * mul;
    a ^= (a >> 47);
-    u64 b = (v ^ a) * mul;
+    uint64 b = (v ^ a) * mul;
    b ^= (b >> 47);
    b *= mul;
    return b;
 }

-static u64 HashLen0to16(const char* s, size_t len) {
+static uint64 HashLen0to16(const char* s, std::size_t len) {
    if (len >= 8) {
-        u64 mul = k2 + len * 2;
-        u64 a = Fetch64(s) + k2;
-        u64 b = Fetch64(s + len - 8);
-        u64 c = Rotate(b, 37) * mul + a;
-        u64 d = (Rotate(a, 25) + b) * mul;
+        uint64 mul = k2 + len * 2;
+        uint64 a = Fetch64(s) + k2;
+        uint64 b = Fetch64(s + len - 8);
+        uint64 c = Rotate(b, 37) * mul + a;
+        uint64 d = (Rotate(a, 25) + b) * mul;
        return HashLen16(c, d, mul);
    }
    if (len >= 4) {
-        u64 mul = k2 + len * 2;
-        u64 a = Fetch32(s);
+        uint64 mul = k2 + len * 2;
+        uint64 a = Fetch32(s);
        return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
    }
    if (len > 0) {
-        u8 a = s[0];
-        u8 b = s[len >> 1];
-        u8 c = s[len - 1];
-        u32 y = static_cast<u32>(a) + (static_cast<u32>(b) << 8);
-        u32 z = static_cast<u32>(len) + (static_cast<u32>(c) << 2);
+        uint8 a = s[0];
+        uint8 b = s[len >> 1];
+        uint8 c = s[len - 1];
+        uint32 y = static_cast<uint32>(a) + (static_cast<uint32>(b) << 8);
+        uint32 z = static_cast<uint32>(len) + (static_cast<uint32>(c) << 2);
        return ShiftMix(y * k2 ^ z * k0) * k2;
    }
    return k2;
@@ -139,21 +141,22 @@ static u64 HashLen0to16(const char* s, size_t len) {

 // This probably works well for 16-byte strings as well, but it may be overkill
 // in that case.
-static u64 HashLen17to32(const char* s, size_t len) {
-    u64 mul = k2 + len * 2;
-    u64 a = Fetch64(s) * k1;
-    u64 b = Fetch64(s + 8);
-    u64 c = Fetch64(s + len - 8) * mul;
-    u64 d = Fetch64(s + len - 16) * k2;
+static uint64 HashLen17to32(const char* s, std::size_t len) {
+    uint64 mul = k2 + len * 2;
+    uint64 a = Fetch64(s) * k1;
+    uint64 b = Fetch64(s + 8);
+    uint64 c = Fetch64(s + len - 8) * mul;
+    uint64 d = Fetch64(s + len - 16) * k2;
    return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d, a + Rotate(b + k2, 18) + c, mul);
 }

 // Return a 16-byte hash for 48 bytes.  Quick and dirty.
 // Callers do best to use "random-looking" values for a and b.
-static pair<u64, u64> WeakHashLen32WithSeeds(u64 w, u64 x, u64 y, u64 z, u64 a, u64 b) {
+static pair<uint64, uint64> WeakHashLen32WithSeeds(uint64 w, uint64 x, uint64 y, uint64 z, uint64 a,
+                                                   uint64 b) {
    a += w;
    b = Rotate(b + a + z, 21);
-    u64 c = a;
+    uint64 c = a;
    a += x;
    a += y;
    b += Rotate(a, 44);
@@ -161,34 +164,34 @@ static pair<u64, u64> WeakHashLen32WithSeeds(u64 w, u64 x, u64 y, u64 z, u64 a,
 }

 // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-static pair<u64, u64> WeakHashLen32WithSeeds(const char* s, u64 a, u64 b) {
+static pair<uint64, uint64> WeakHashLen32WithSeeds(const char* s, uint64 a, uint64 b) {
    return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16), Fetch64(s + 24), a,
                                  b);
 }

 // Return an 8-byte hash for 33 to 64 bytes.
-static u64 HashLen33to64(const char* s, size_t len) {
-    u64 mul = k2 + len * 2;
-    u64 a = Fetch64(s) * k2;
-    u64 b = Fetch64(s + 8);
-    u64 c = Fetch64(s + len - 24);
-    u64 d = Fetch64(s + len - 32);
-    u64 e = Fetch64(s + 16) * k2;
-    u64 f = Fetch64(s + 24) * 9;
-    u64 g = Fetch64(s + len - 8);
-    u64 h = Fetch64(s + len - 16) * mul;
-    u64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
-    u64 v = ((a + g) ^ d) + f + 1;
-    u64 w = swap64((u + v) * mul) + h;
-    u64 x = Rotate(e + f, 42) + c;
-    u64 y = (swap64((v + w) * mul) + g) * mul;
-    u64 z = e + f + c;
+static uint64 HashLen33to64(const char* s, std::size_t len) {
+    uint64 mul = k2 + len * 2;
+    uint64 a = Fetch64(s) * k2;
+    uint64 b = Fetch64(s + 8);
+    uint64 c = Fetch64(s + len - 24);
+    uint64 d = Fetch64(s + len - 32);
+    uint64 e = Fetch64(s + 16) * k2;
+    uint64 f = Fetch64(s + 24) * 9;
+    uint64 g = Fetch64(s + len - 8);
+    uint64 h = Fetch64(s + len - 16) * mul;
+    uint64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
+    uint64 v = ((a + g) ^ d) + f + 1;
+    uint64 w = swap64((u + v) * mul) + h;
+    uint64 x = Rotate(e + f, 42) + c;
+    uint64 y = (swap64((v + w) * mul) + g) * mul;
+    uint64 z = e + f + c;
    a = swap64((x + z) * mul + y) + b;
    b = ShiftMix((z + a) * mul + d + h) * mul;
    return b + x;
 }

-u64 CityHash64(const char* s, size_t len) {
+uint64 CityHash64(const char* s, std::size_t len) {
    if (len <= 32) {
        if (len <= 16) {
            return HashLen0to16(s, len);
@@ -201,15 +204,15 @@ u64 CityHash64(const char* s, size_t len) {

    // For strings over 64 bytes we hash the end first, and then as we
    // loop we keep 56 bytes of state: v, w, x, y, and z.
-    u64 x = Fetch64(s + len - 40);
-    u64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
-    u64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-    pair<u64, u64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
-    pair<u64, u64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
+    uint64 x = Fetch64(s + len - 40);
+    uint64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
+    uint64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
+    pair<uint64, uint64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
+    pair<uint64, uint64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
    x = x * k1 + Fetch64(s);

    // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
-    len = (len - 1) & ~static_cast<size_t>(63);
+    len = (len - 1) & ~static_cast<std::size_t>(63);
    do {
        x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
        y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
@@ -226,21 +229,21 @@ u64 CityHash64(const char* s, size_t len) {
                     HashLen16(v.second, w.second) + x);
 }

-u64 CityHash64WithSeed(const char* s, size_t len, u64 seed) {
+uint64 CityHash64WithSeed(const char* s, std::size_t len, uint64 seed) {
    return CityHash64WithSeeds(s, len, k2, seed);
 }

-u64 CityHash64WithSeeds(const char* s, size_t len, u64 seed0, u64 seed1) {
+uint64 CityHash64WithSeeds(const char* s, std::size_t len, uint64 seed0, uint64 seed1) {
    return HashLen16(CityHash64(s, len) - seed0, seed1);
 }

 // A subroutine for CityHash128().  Returns a decent 128-bit hash for strings
 // of any length representable in signed long.  Based on City and Murmur.
-static u128 CityMurmur(const char* s, size_t len, u128 seed) {
-    u64 a = seed[0];
-    u64 b = seed[1];
-    u64 c = 0;
-    u64 d = 0;
+static uint128 CityMurmur(const char* s, std::size_t len, uint128 seed) {
+    uint64 a = Uint128Low64(seed);
+    uint64 b = Uint128High64(seed);
+    uint64 c = 0;
+    uint64 d = 0;
    signed long l = static_cast<long>(len) - 16;
    if (l <= 0) { // len <= 16
        a = ShiftMix(a * k1) * k1;
@@ -263,20 +266,20 @@ static u128 CityMurmur(const char* s, size_t len, u128 seed) {
    }
    a = HashLen16(a, c);
    b = HashLen16(d, b);
-    return u128{a ^ b, HashLen16(b, a)};
+    return uint128(a ^ b, HashLen16(b, a));
 }

-u128 CityHash128WithSeed(const char* s, size_t len, u128 seed) {
+uint128 CityHash128WithSeed(const char* s, std::size_t len, uint128 seed) {
    if (len < 128) {
        return CityMurmur(s, len, seed);
    }

    // We expect len >= 128 to be the common case.  Keep 56 bytes of state:
    // v, w, x, y, and z.
-    pair<u64, u64> v, w;
-    u64 x = seed[0];
-    u64 y = seed[1];
-    u64 z = len * k1;
+    pair<uint64, uint64> v, w;
+    uint64 x = Uint128Low64(seed);
+    uint64 y = Uint128High64(seed);
+    uint64 z = len * k1;
    v.first = Rotate(y ^ k1, 49) * k1 + Fetch64(s);
    v.second = Rotate(v.first, 42) * k1 + Fetch64(s + 8);
    w.first = Rotate(y + z, 35) * k1 + x;
@@ -310,7 +313,7 @@ u128 CityHash128WithSeed(const char* s, size_t len, u128 seed) {
    w.first *= 9;
    v.first *= k0;
    // If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
-    for (size_t tail_done = 0; tail_done < len;) {
+    for (std::size_t tail_done = 0; tail_done < len;) {
        tail_done += 32;
        y = Rotate(x + y, 42) * k0 + v.second;
        w.first += Fetch64(s + len - tail_done + 16);
@@ -325,12 +328,13 @@ u128 CityHash128WithSeed(const char* s, size_t len, u128 seed) {
    // different 56-byte-to-8-byte hashes to get a 16-byte final result.
    x = HashLen16(x, v.first);
    y = HashLen16(y + z, w.first);
-    return u128{HashLen16(x + v.second, w.second) + y, HashLen16(x + w.second, y + v.second)};
+    return uint128(HashLen16(x + v.second, w.second) + y, HashLen16(x + w.second, y + v.second));
 }

-u128 CityHash128(const char* s, size_t len) {
-    return len >= 16 ? CityHash128WithSeed(s + 16, len - 16, u128{Fetch64(s), Fetch64(s + 8) + k0})
-                     : CityHash128WithSeed(s, len, u128{k0, k1});
+uint128 CityHash128(const char* s, std::size_t len) {
+    return len >= 16
+               ? CityHash128WithSeed(s + 16, len - 16, uint128(Fetch64(s), Fetch64(s + 8) + k0))
+               : CityHash128WithSeed(s, len, uint128(k0, k1));
 }

 } // namespace Common
--- a/src/common/cityhash.h
+++ b/src/common/cityhash.h
@@ -62,38 +62,49 @@
 #pragma once

 #include <cstddef>
-#include "common/common_types.h"
+#include <cstdint>
+#include <utility>

 namespace Common {

+using uint128 = std::pair<uint64_t, uint64_t>;
+
+[[nodiscard]] inline uint64_t Uint128Low64(const uint128& x) {
+    return x.first;
+}
+[[nodiscard]] inline uint64_t Uint128High64(const uint128& x) {
+    return x.second;
+}
+
 // Hash function for a byte array.
-[[nodiscard]] u64 CityHash64(const char* buf, size_t len);
+[[nodiscard]] uint64_t CityHash64(const char* buf, std::size_t len);

 // Hash function for a byte array.  For convenience, a 64-bit seed is also
 // hashed into the result.
-[[nodiscard]] u64 CityHash64WithSeed(const char* buf, size_t len, u64 seed);
+[[nodiscard]] uint64_t CityHash64WithSeed(const char* buf, std::size_t len, uint64_t seed);

 // Hash function for a byte array.  For convenience, two seeds are also
 // hashed into the result.
-[[nodiscard]] u64 CityHash64WithSeeds(const char* buf, size_t len, u64 seed0, u64 seed1);
+[[nodiscard]] uint64_t CityHash64WithSeeds(const char* buf, std::size_t len, uint64_t seed0,
+                                           uint64_t seed1);

 // Hash function for a byte array.
-[[nodiscard]] u128 CityHash128(const char* s, size_t len);
+[[nodiscard]] uint128 CityHash128(const char* s, std::size_t len);

 // Hash function for a byte array.  For convenience, a 128-bit seed is also
 // hashed into the result.
-[[nodiscard]] u128 CityHash128WithSeed(const char* s, size_t len, u128 seed);
+[[nodiscard]] uint128 CityHash128WithSeed(const char* s, std::size_t len, uint128 seed);

 // Hash 128 input bits down to 64 bits of output.
 // This is intended to be a reasonably good hash function.
-[[nodiscard]] inline u64 Hash128to64(const u128& x) {
+[[nodiscard]] inline uint64_t Hash128to64(const uint128& x) {
    // Murmur-inspired hashing.
-    const u64 mul = 0x9ddfea08eb382d69ULL;
-    u64 a = (x[0] ^ x[1]) * mul;
+    const uint64_t kMul = 0x9ddfea08eb382d69ULL;
+    uint64_t a = (Uint128Low64(x) ^ Uint128High64(x)) * kMul;
    a ^= (a >> 47);
-    u64 b = (x[1] ^ a) * mul;
+    uint64_t b = (Uint128High64(x) ^ a) * kMul;
    b ^= (b >> 47);
-    b *= mul;
+    b *= kMul;
    return b;
 }

--- a/src/common/common_funcs.h
+++ b/src/common/common_funcs.h
@@ -52,13 +52,9 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
-// Defined in misc.cpp.
+// Defined in Misc.cpp.
 [[nodiscard]] std::string GetLastErrorMsg();

-// Like GetLastErrorMsg(), but passing an explicit error code.
-// Defined in misc.cpp.
-[[nodiscard]] std::string NativeErrorToString(int e);
-
 #define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
    [[nodiscard]] constexpr type operator|(type a, type b) noexcept {                              \
        using T = std::underlying_type_t<type>;                                                    \
--- a/src/common/common_sizes.h
+++ b/src/common/common_sizes.h
@@ -1,43 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <limits>
-
-#include "common/common_types.h"
-
-namespace Common {
-
-enum : u64 {
-    Size_1_KB = 0x400ULL,
-    Size_64_KB = 64ULL * Size_1_KB,
-    Size_128_KB = 128ULL * Size_1_KB,
-    Size_1_MB = 0x100000ULL,
-    Size_2_MB = 2ULL * Size_1_MB,
-    Size_4_MB = 4ULL * Size_1_MB,
-    Size_5_MB = 5ULL * Size_1_MB,
-    Size_14_MB = 14ULL * Size_1_MB,
-    Size_32_MB = 32ULL * Size_1_MB,
-    Size_33_MB = 33ULL * Size_1_MB,
-    Size_128_MB = 128ULL * Size_1_MB,
-    Size_448_MB = 448ULL * Size_1_MB,
-    Size_507_MB = 507ULL * Size_1_MB,
-    Size_562_MB = 562ULL * Size_1_MB,
-    Size_1554_MB = 1554ULL * Size_1_MB,
-    Size_2048_MB = 2048ULL * Size_1_MB,
-    Size_2193_MB = 2193ULL * Size_1_MB,
-    Size_3285_MB = 3285ULL * Size_1_MB,
-    Size_4916_MB = 4916ULL * Size_1_MB,
-    Size_1_GB = 0x40000000ULL,
-    Size_2_GB = 2ULL * Size_1_GB,
-    Size_4_GB = 4ULL * Size_1_GB,
-    Size_6_GB = 6ULL * Size_1_GB,
-    Size_8_GB = 8ULL * Size_1_GB,
-    Size_64_GB = 64ULL * Size_1_GB,
-    Size_512_GB = 512ULL * Size_1_GB,
-    Size_Invalid = std::numeric_limits<u64>::max(),
-};
-
-} // namespace Common
--- a/src/common/fiber.cpp
+++ b/src/common/fiber.cpp
@@ -11,7 +11,7 @@

 namespace Common {

-constexpr std::size_t default_stack_size = 512 * 1024;
+constexpr std::size_t default_stack_size = 256 * 1024;

 struct Fiber::FiberImpl {
    FiberImpl() : stack{default_stack_size}, rewind_stack{default_stack_size} {}
@@ -116,19 +116,16 @@ void Fiber::Rewind() {
    boost::context::detail::jump_fcontext(impl->rewind_context, this);
 }

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

 std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
--- a/src/common/fiber.h
+++ b/src/common/fiber.h
@@ -41,7 +41,7 @@ public:

    /// Yields control from Fiber 'from' to Fiber 'to'
    /// Fiber 'from' must be the currently running fiber.
-    static void YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to);
+    static void YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to);
    [[nodiscard]] static std::shared_ptr<Fiber> ThreadToFiber();

    void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param);
--- a/src/common/logging/backend.cpp
+++ b/src/common/logging/backend.cpp
@@ -212,7 +212,6 @@ void DebuggerBackend::Write(const Entry& entry) {
    SUB(Service, ARP)                                                                              \
    SUB(Service, BCAT)                                                                             \
    SUB(Service, BPC)                                                                              \
-    SUB(Service, BGTC)                                                                             \
    SUB(Service, BTDRV)                                                                            \
    SUB(Service, BTM)                                                                              \
    SUB(Service, Capture)                                                                          \
--- a/src/common/logging/log.h
+++ b/src/common/logging/log.h
@@ -66,7 +66,6 @@ enum class Class : ClassType {
    Service_ARP,       ///< The ARP service
    Service_Audio,     ///< The Audio (Audio control) service
    Service_BCAT,      ///< The BCAT service
-    Service_BGTC,      ///< The BGTC (Background Task Controller) service
    Service_BPC,       ///< The BPC service
    Service_BTDRV,     ///< The Bluetooth driver service
    Service_BTM,       ///< The BTM service
--- a/src/common/misc.cpp
+++ b/src/common/misc.cpp
@@ -12,41 +12,27 @@

 #include "common/common_funcs.h"

-std::string NativeErrorToString(int e) {
-#ifdef _WIN32
-    LPSTR err_str;
+// Generic function to get last error message.
+// Call directly after the command or use the error num.
+// This function might change the error code.
+std::string GetLastErrorMsg() {
+    static constexpr std::size_t buff_size = 255;
+    char err_str[buff_size];

-    DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                                   FORMAT_MESSAGE_IGNORE_INSERTS,
-                               nullptr, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
-    if (!res) {
-        return "(FormatMessageA failed to format error)";
-    }
-    std::string ret(err_str);
-    LocalFree(err_str);
-    return ret;
-#else
-    char err_str[255];
-#if defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))
+#ifdef _WIN32
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(),
+                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err_str, buff_size, nullptr);
+    return std::string(err_str, buff_size);
+#elif defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))
    // Thread safe (GNU-specific)
-    const char* str = strerror_r(e, err_str, sizeof(err_str));
+    const char* str = strerror_r(errno, err_str, buff_size);
    return std::string(str);
 #else
    // Thread safe (XSI-compliant)
-    int second_err = strerror_r(e, err_str, sizeof(err_str));
-    if (second_err != 0) {
-        return "(strerror_r failed to format error)";
+    const int success = strerror_r(errno, err_str, buff_size);
+    if (success != 0) {
+        return {};
    }
    return std::string(err_str);
-#endif // GLIBC etc.
-#endif // _WIN32
-}
-
-std::string GetLastErrorMsg() {
-#ifdef _WIN32
-    return NativeErrorToString(GetLastError());
-#else
-    return NativeErrorToString(errno);
 #endif
 }
--- a/src/common/nvidia_flags.h
+++ b/src/common/nvidia_flags.h
@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#pragma once
-
 namespace Common {

 /// Configure platform specific flags for Nvidia's driver
--- a/src/common/ring_buffer.h
+++ b/src/common/ring_buffer.h
@@ -19,14 +19,15 @@ namespace Common {
 /// SPSC ring buffer
 /// @tparam T            Element type
 /// @tparam capacity     Number of slots in ring buffer
-template <typename T, std::size_t capacity>
+/// @tparam granularity  Slot size in terms of number of elements
+template <typename T, std::size_t capacity, std::size_t granularity = 1>
 class RingBuffer {
-    /// A "slot" is made of a single `T`.
-    static constexpr std::size_t slot_size = sizeof(T);
+    /// A "slot" is made of `granularity` elements of `T`.
+    static constexpr std::size_t slot_size = granularity * sizeof(T);
    // T must be safely memcpy-able and have a trivial default constructor.
    static_assert(std::is_trivial_v<T>);
    // Ensure capacity is sensible.
-    static_assert(capacity < std::numeric_limits<std::size_t>::max() / 2);
+    static_assert(capacity < std::numeric_limits<std::size_t>::max() / 2 / granularity);
    static_assert((capacity & (capacity - 1)) == 0, "capacity must be a power of two");
    // Ensure lock-free.
    static_assert(std::atomic_size_t::is_always_lock_free);
@@ -46,7 +47,7 @@ public:
        const std::size_t second_copy = push_count - first_copy;

        const char* in = static_cast<const char*>(new_slots);
-        std::memcpy(m_data.data() + pos, in, first_copy * slot_size);
+        std::memcpy(m_data.data() + pos * granularity, in, first_copy * slot_size);
        in += first_copy * slot_size;
        std::memcpy(m_data.data(), in, second_copy * slot_size);

@@ -73,7 +74,7 @@ public:
        const std::size_t second_copy = pop_count - first_copy;

        char* out = static_cast<char*>(output);
-        std::memcpy(out, m_data.data() + pos, first_copy * slot_size);
+        std::memcpy(out, m_data.data() + pos * granularity, first_copy * slot_size);
        out += first_copy * slot_size;
        std::memcpy(out, m_data.data(), second_copy * slot_size);

@@ -83,9 +84,9 @@ public:
    }

    std::vector<T> Pop(std::size_t max_slots = ~std::size_t(0)) {
-        std::vector<T> out(std::min(max_slots, capacity));
-        const std::size_t count = Pop(out.data(), out.size());
-        out.resize(count);
+        std::vector<T> out(std::min(max_slots, capacity) * granularity);
+        const std::size_t count = Pop(out.data(), out.size() / granularity);
+        out.resize(count * granularity);
        return out;
    }

@@ -112,7 +113,7 @@ private:
    alignas(128) std::atomic_size_t m_write_index{0};
 #endif

-    std::array<T, capacity> m_data;
+    std::array<T, granularity * capacity> m_data;
 };

 } // namespace Common
--- a/src/common/scope_exit.h
+++ b/src/common/scope_exit.h
@@ -49,9 +49,3 @@ ScopeExitHelper<Func> ScopeExit(Func&& func) {
 * \endcode
 */
 #define SCOPE_EXIT(body) auto CONCAT2(scope_exit_helper_, __LINE__) = detail::ScopeExit([&]() body)
-
-/**
- * This macro is similar to SCOPE_EXIT, except the object is caller managed. This is intended to be
- * used when the caller might want to cancel the ScopeExit.
- */
-#define SCOPE_GUARD(body) detail::ScopeExit([&]() body)
--- a/src/common/string_util.cpp
+++ b/src/common/string_util.cpp
@@ -141,13 +141,27 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 }

 std::string UTF16ToUTF8(const std::u16string& input) {
+#ifdef _MSC_VER
+    // Workaround for missing char16_t/char32_t instantiations in MSVC2017
+    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
+    std::basic_string<__int16> tmp_buffer(input.cbegin(), input.cend());
+    return convert.to_bytes(tmp_buffer);
+#else
    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
    return convert.to_bytes(input);
+#endif
 }

 std::u16string UTF8ToUTF16(const std::string& input) {
+#ifdef _MSC_VER
+    // Workaround for missing char16_t/char32_t instantiations in MSVC2017
+    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
+    auto tmp_buffer = convert.from_bytes(input);
+    return std::u16string(tmp_buffer.cbegin(), tmp_buffer.cend());
+#else
    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
    return convert.from_bytes(input);
+#endif
 }

 #ifdef _WIN32
--- a/src/common/threadsafe_queue.h
+++ b/src/common/threadsafe_queue.h
@@ -83,15 +83,11 @@ public:
        return true;
    }

-    void Wait() {
+    T PopWait() {
        if (Empty()) {
            std::unique_lock lock{cv_mutex};
            cv.wait(lock, [this]() { return !Empty(); });
        }
-    }
-
-    T PopWait() {
-        Wait();
        T t;
        Pop(t);
        return t;
@@ -160,10 +156,6 @@ public:
        return spsc_queue.Pop(t);
    }

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

 #pragma once

-#include <cstring>
 #include <utility>
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#pragma intrinsic(__umulh)
-#pragma intrinsic(_umul128)
-#pragma intrinsic(_udiv128)
-#else
-#include <x86intrin.h>
-#endif
-
 #include "common/common_types.h"

 namespace Common {

 // This function multiplies 2 u64 values and divides it by a u64 value.
-[[nodiscard]] static inline u64 MultiplyAndDivide64(u64 a, u64 b, u64 d) {
-#ifdef _MSC_VER
-    u128 r{};
-    r[0] = _umul128(a, b, &r[1]);
-    u64 remainder;
-#if _MSC_VER < 1923
-    return udiv128(r[1], r[0], d, &remainder);
-#else
-    return _udiv128(r[1], r[0], d, &remainder);
-#endif
-#else
-    const u64 diva = a / d;
-    const u64 moda = a % d;
-    const u64 divb = b / d;
-    const u64 modb = b % d;
-    return diva * b + moda * divb + moda * modb / d;
-#endif
-}
+[[nodiscard]] u64 MultiplyAndDivide64(u64 a, u64 b, u64 d);

 // This function multiplies 2 u64 values and produces a u128 value;
-[[nodiscard]] static inline u128 Multiply64Into128(u64 a, u64 b) {
-    u128 result;
-#ifdef _MSC_VER
-    result[0] = _umul128(a, b, &result[1]);
-#else
-    unsigned __int128 tmp = a;
-    tmp *= b;
-    std::memcpy(&result, &tmp, sizeof(u128));
-#endif
-    return result;
-}
-
-[[nodiscard]] static inline u64 GetFixedPoint64Factor(u64 numerator, u64 divisor) {
-#ifdef __SIZEOF_INT128__
-    const auto base = static_cast<unsigned __int128>(numerator) << 64ULL;
-    return static_cast<u64>(base / divisor);
-#elif defined(_M_X64) || defined(_M_ARM64)
-    std::array<u64, 2> r = {0, numerator};
-    u64 remainder;
-#if _MSC_VER < 1923
-    return udiv128(r[1], r[0], divisor, &remainder);
-#else
-    return _udiv128(r[1], r[0], divisor, &remainder);
-#endif
-#else
-    // This one is bit more inaccurate.
-    return MultiplyAndDivide64(std::numeric_limits<u64>::max(), numerator, divisor);
-#endif
-}
-
-[[nodiscard]] static inline u64 MultiplyHigh(u64 a, u64 b) {
-#ifdef __SIZEOF_INT128__
-    return (static_cast<unsigned __int128>(a) * static_cast<unsigned __int128>(b)) >> 64;
-#elif defined(_M_X64) || defined(_M_ARM64)
-    return __umulh(a, b); // MSVC
-#else
-    // Generic fallback
-    const u64 a_lo = u32(a);
-    const u64 a_hi = a >> 32;
-    const u64 b_lo = u32(b);
-    const u64 b_hi = b >> 32;
-
-    const u64 a_x_b_hi = a_hi * b_hi;
-    const u64 a_x_b_mid = a_hi * b_lo;
-    const u64 b_x_a_mid = b_hi * a_lo;
-    const u64 a_x_b_lo = a_lo * b_lo;
-
-    const u64 carry_bit = (static_cast<u64>(static_cast<u32>(a_x_b_mid)) +
-                           static_cast<u64>(static_cast<u32>(b_x_a_mid)) + (a_x_b_lo >> 32)) >>
-                          32;
-
-    const u64 multhi = a_x_b_hi + (a_x_b_mid >> 32) + (b_x_a_mid >> 32) + carry_bit;
-
-    return multhi;
-#endif
-}
+[[nodiscard]] u128 Multiply64Into128(u64 a, u64 b);

 // This function divides a u128 by a u32 value and produces two u64 values:
 // the result of division and the remainder
-[[nodiscard]] static inline std::pair<u64, u64> Divide128On32(u128 dividend, u32 divisor) {
-    u64 remainder = dividend[0] % divisor;
-    u64 accum = dividend[0] / divisor;
-    if (dividend[1] == 0)
-        return {accum, remainder};
-    // We ignore dividend[1] / divisor as that overflows
-    const u64 first_segment = (dividend[1] % divisor) << 32;
-    accum += (first_segment / divisor) << 32;
-    const u64 second_segment = (first_segment % divisor) << 32;
-    accum += (second_segment / divisor);
-    remainder += second_segment % divisor;
-    if (remainder >= divisor) {
-        accum++;
-        remainder -= divisor;
-    }
-    return {accum, remainder};
-}
+[[nodiscard]] std::pair<u64, u64> Divide128On32(u128 dividend, u32 divisor);

 } // namespace Common
--- a/src/common/wall_clock.cpp
+++ b/src/common/wall_clock.cpp
@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <cstdint>
-
 #include "common/uint128.h"
 #include "common/wall_clock.h"

--- a/src/common/x64/native_clock.cpp
+++ b/src/common/x64/native_clock.cpp
@@ -8,10 +8,68 @@
 #include <mutex>
 #include <thread>

+#ifdef _MSC_VER
+#include <intrin.h>
+
+#pragma intrinsic(__umulh)
+#pragma intrinsic(_udiv128)
+#else
+#include <x86intrin.h>
+#endif
+
 #include "common/atomic_ops.h"
 #include "common/uint128.h"
 #include "common/x64/native_clock.h"

+namespace {
+
+[[nodiscard]] u64 GetFixedPoint64Factor(u64 numerator, u64 divisor) {
+#ifdef __SIZEOF_INT128__
+    const auto base = static_cast<unsigned __int128>(numerator) << 64ULL;
+    return static_cast<u64>(base / divisor);
+#elif defined(_M_X64) || defined(_M_ARM64)
+    std::array<u64, 2> r = {0, numerator};
+    u64 remainder;
+#if _MSC_VER < 1923
+    return udiv128(r[1], r[0], divisor, &remainder);
+#else
+    return _udiv128(r[1], r[0], divisor, &remainder);
+#endif
+#else
+    // This one is bit more inaccurate.
+    return MultiplyAndDivide64(std::numeric_limits<u64>::max(), numerator, divisor);
+#endif
+}
+
+[[nodiscard]] u64 MultiplyHigh(u64 a, u64 b) {
+#ifdef __SIZEOF_INT128__
+    return (static_cast<unsigned __int128>(a) * static_cast<unsigned __int128>(b)) >> 64;
+#elif defined(_M_X64) || defined(_M_ARM64)
+    return __umulh(a, b); // MSVC
+#else
+    // Generic fallback
+    const u64 a_lo = u32(a);
+    const u64 a_hi = a >> 32;
+    const u64 b_lo = u32(b);
+    const u64 b_hi = b >> 32;
+
+    const u64 a_x_b_hi = a_hi * b_hi;
+    const u64 a_x_b_mid = a_hi * b_lo;
+    const u64 b_x_a_mid = b_hi * a_lo;
+    const u64 a_x_b_lo = a_lo * b_lo;
+
+    const u64 carry_bit = (static_cast<u64>(static_cast<u32>(a_x_b_mid)) +
+                           static_cast<u64>(static_cast<u32>(b_x_a_mid)) + (a_x_b_lo >> 32)) >>
+                          32;
+
+    const u64 multhi = a_x_b_hi + (a_x_b_mid >> 32) + (b_x_a_mid >> 32) + carry_bit;
+
+    return multhi;
+#endif
+}
+
+} // namespace
+
 namespace Common {

 u64 EstimateRDTSCFrequency() {
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -19,6 +19,7 @@ add_library(core STATIC
    core.h
    core_timing.cpp
    core_timing.h
+    core_timing_util.cpp
    core_timing_util.h
    cpu_manager.cpp
    cpu_manager.h
@@ -141,16 +142,13 @@ add_library(core STATIC
    hardware_interrupt_manager.h
    hle/ipc.h
    hle/ipc_helpers.h
-    hle/kernel/board/nintendo/nx/k_system_control.cpp
-    hle/kernel/board/nintendo/nx/k_system_control.h
-    hle/kernel/board/nintendo/nx/secure_monitor.h
    hle/kernel/client_port.cpp
    hle/kernel/client_port.h
    hle/kernel/client_session.cpp
    hle/kernel/client_session.h
    hle/kernel/code_set.cpp
    hle/kernel/code_set.h
-    hle/kernel/svc_results.h
+    hle/kernel/errors.h
    hle/kernel/global_scheduler_context.cpp
    hle/kernel/global_scheduler_context.h
    hle/kernel/handle_table.cpp
@@ -159,60 +157,44 @@ add_library(core STATIC
    hle/kernel/hle_ipc.h
    hle/kernel/k_address_arbiter.cpp
    hle/kernel/k_address_arbiter.h
-    hle/kernel/k_address_space_info.cpp
-    hle/kernel/k_address_space_info.h
    hle/kernel/k_affinity_mask.h
    hle/kernel/k_condition_variable.cpp
    hle/kernel/k_condition_variable.h
-    hle/kernel/k_event.cpp
-    hle/kernel/k_event.h
    hle/kernel/k_light_condition_variable.h
    hle/kernel/k_light_lock.cpp
    hle/kernel/k_light_lock.h
-    hle/kernel/k_memory_block.h
-    hle/kernel/k_memory_block_manager.cpp
-    hle/kernel/k_memory_block_manager.h
-    hle/kernel/k_memory_layout.cpp
-    hle/kernel/k_memory_layout.board.nintendo_nx.cpp
-    hle/kernel/k_memory_layout.h
-    hle/kernel/k_memory_manager.cpp
-    hle/kernel/k_memory_manager.h
-    hle/kernel/k_memory_region.h
-    hle/kernel/k_memory_region_type.h
-    hle/kernel/k_page_bitmap.h
-    hle/kernel/k_page_heap.cpp
-    hle/kernel/k_page_heap.h
-    hle/kernel/k_page_linked_list.h
-    hle/kernel/k_page_table.cpp
-    hle/kernel/k_page_table.h
    hle/kernel/k_priority_queue.h
-    hle/kernel/k_readable_event.cpp
-    hle/kernel/k_readable_event.h
    hle/kernel/k_resource_limit.cpp
    hle/kernel/k_resource_limit.h
    hle/kernel/k_scheduler.cpp
    hle/kernel/k_scheduler.h
    hle/kernel/k_scheduler_lock.h
    hle/kernel/k_scoped_lock.h
-    hle/kernel/k_scoped_resource_reservation.h
    hle/kernel/k_scoped_scheduler_lock_and_sleep.h
-    hle/kernel/k_shared_memory.cpp
-    hle/kernel/k_shared_memory.h
-    hle/kernel/k_slab_heap.h
-    hle/kernel/k_spin_lock.cpp
-    hle/kernel/k_spin_lock.h
    hle/kernel/k_synchronization_object.cpp
    hle/kernel/k_synchronization_object.h
-    hle/kernel/k_system_control.h
    hle/kernel/k_thread.cpp
    hle/kernel/k_thread.h
    hle/kernel/k_thread_queue.h
-    hle/kernel/k_trace.h
-    hle/kernel/k_writable_event.cpp
-    hle/kernel/k_writable_event.h
    hle/kernel/kernel.cpp
    hle/kernel/kernel.h
-    hle/kernel/memory_types.h
+    hle/kernel/memory/address_space_info.cpp
+    hle/kernel/memory/address_space_info.h
+    hle/kernel/memory/memory_block.h
+    hle/kernel/memory/memory_block_manager.cpp
+    hle/kernel/memory/memory_block_manager.h
+    hle/kernel/memory/memory_layout.h
+    hle/kernel/memory/memory_manager.cpp
+    hle/kernel/memory/memory_manager.h
+    hle/kernel/memory/memory_types.h
+    hle/kernel/memory/page_linked_list.h
+    hle/kernel/memory/page_heap.cpp
+    hle/kernel/memory/page_heap.h
+    hle/kernel/memory/page_table.cpp
+    hle/kernel/memory/page_table.h
+    hle/kernel/memory/slab_heap.h
+    hle/kernel/memory/system_control.cpp
+    hle/kernel/memory/system_control.h
    hle/kernel/object.cpp
    hle/kernel/object.h
    hle/kernel/physical_core.cpp
@@ -222,6 +204,8 @@ add_library(core STATIC
    hle/kernel/process.h
    hle/kernel/process_capability.cpp
    hle/kernel/process_capability.h
+    hle/kernel/readable_event.cpp
+    hle/kernel/readable_event.h
    hle/kernel/server_port.cpp
    hle/kernel/server_port.h
    hle/kernel/server_session.cpp
@@ -230,15 +214,20 @@ add_library(core STATIC
    hle/kernel/service_thread.h
    hle/kernel/session.cpp
    hle/kernel/session.h
+    hle/kernel/shared_memory.cpp
+    hle/kernel/shared_memory.h
    hle/kernel/svc.cpp
    hle/kernel/svc.h
    hle/kernel/svc_common.h
+    hle/kernel/svc_results.h
    hle/kernel/svc_types.h
    hle/kernel/svc_wrap.h
    hle/kernel/time_manager.cpp
    hle/kernel/time_manager.h
    hle/kernel/transfer_memory.cpp
    hle/kernel/transfer_memory.h
+    hle/kernel/writable_event.cpp
+    hle/kernel/writable_event.h
    hle/lock.cpp
    hle/lock.h
    hle/result.h
@@ -275,7 +264,6 @@ add_library(core STATIC
    hle/service/am/applets/software_keyboard.h
    hle/service/am/applets/web_browser.cpp
    hle/service/am/applets/web_browser.h
-    hle/service/am/applets/web_types.h
    hle/service/am/idle.cpp
    hle/service/am/idle.h
    hle/service/am/omm.cpp
@@ -410,7 +398,6 @@ add_library(core STATIC
    hle/service/hid/controllers/xpad.h
    hle/service/lbl/lbl.cpp
    hle/service/lbl/lbl.h
-    hle/service/ldn/errors.h
    hle/service/ldn/ldn.cpp
    hle/service/ldn/ldn.h
    hle/service/ldr/ldr.cpp
@@ -664,8 +651,6 @@ else()
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>

-        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
-
        -Wno-sign-conversion
    )
 endif()
@@ -673,7 +658,7 @@ endif()
 create_target_directory_groups(core)

 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus zip)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls opus zip)

 if (YUZU_ENABLE_BOXCAT)
    target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -114,17 +114,18 @@ public:
    static constexpr u64 minimum_run_cycles = 1000U;
 };

-std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable* page_table) const {
+std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable& page_table,
+                                                             std::size_t address_space_bits) const {
    Dynarmic::A32::UserConfig config;
    config.callbacks = cb.get();
+    // TODO(bunnei): Implement page table for 32-bit
+    // config.page_table = &page_table.pointers;
    config.coprocessors[15] = cp15;
    config.define_unpredictable_behaviour = true;
    static constexpr std::size_t PAGE_BITS = 12;
    static constexpr std::size_t NUM_PAGE_TABLE_ENTRIES = 1 << (32 - PAGE_BITS);
-    if (page_table) {
-        config.page_table = reinterpret_cast<std::array<std::uint8_t*, NUM_PAGE_TABLE_ENTRIES>*>(
-            page_table->pointers.data());
-    }
+    config.page_table = reinterpret_cast<std::array<std::uint8_t*, NUM_PAGE_TABLE_ENTRIES>*>(
+        page_table.pointers.data());
    config.absolute_offset_page_table = true;
    config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
    config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
@@ -137,10 +138,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
    // Timing
    config.wall_clock_cntpct = uses_wall_clock;

-    // Code cache size
-    config.code_cache_size = 512 * 1024 * 1024;
-    config.far_code_offset = 256 * 1024 * 1024;
-
    // Safe optimizations
    if (Settings::values.cpu_accuracy == Settings::CPUAccuracy::DebugMode) {
        if (!Settings::values.cpuopt_page_tables) {
@@ -204,8 +201,7 @@ ARM_Dynarmic_32::ARM_Dynarmic_32(System& system, CPUInterrupts& interrupt_handle
    : ARM_Interface{system, interrupt_handlers, uses_wall_clock},
      cb(std::make_unique<DynarmicCallbacks32>(*this)),
      cp15(std::make_shared<DynarmicCP15>(*this)), core_index{core_index},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)},
-      jit(MakeJit(nullptr)) {}
+      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}

 ARM_Dynarmic_32::~ARM_Dynarmic_32() = default;

@@ -260,6 +256,9 @@ void ARM_Dynarmic_32::ChangeProcessorID(std::size_t new_core_id) {
 }

 void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) {
+    if (!jit) {
+        return;
+    }
    Dynarmic::A32::Context context;
    jit->SaveContext(context);
    ctx.cpu_registers = context.Regs();
@@ -269,6 +268,9 @@ void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) {
 }

 void ARM_Dynarmic_32::LoadContext(const ThreadContext32& ctx) {
+    if (!jit) {
+        return;
+    }
    Dynarmic::A32::Context context;
    context.Regs() = ctx.cpu_registers;
    context.ExtRegs() = ctx.extension_registers;
@@ -282,31 +284,35 @@ void ARM_Dynarmic_32::PrepareReschedule() {
 }

 void ARM_Dynarmic_32::ClearInstructionCache() {
+    if (!jit) {
+        return;
+    }
    jit->ClearCache();
 }

 void ARM_Dynarmic_32::InvalidateCacheRange(VAddr addr, std::size_t size) {
+    if (!jit) {
+        return;
+    }
    jit->InvalidateCacheRange(static_cast<u32>(addr), size);
 }

 void ARM_Dynarmic_32::ClearExclusiveState() {
+    if (!jit) {
+        return;
+    }
    jit->ClearExclusiveState();
 }

 void ARM_Dynarmic_32::PageTableChanged(Common::PageTable& page_table,
                                       std::size_t new_address_space_size_in_bits) {
-    ThreadContext32 ctx{};
-    SaveContext(ctx);
-
    auto key = std::make_pair(&page_table, new_address_space_size_in_bits);
    auto iter = jit_cache.find(key);
    if (iter != jit_cache.end()) {
        jit = iter->second;
-        LoadContext(ctx);
        return;
    }
-    jit = MakeJit(&page_table);
-    LoadContext(ctx);
+    jit = MakeJit(page_table, new_address_space_size_in_bits);
    jit_cache.emplace(key, jit);
 }

--- a/src/core/arm/dynarmic/arm_dynarmic_32.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.h
@@ -68,7 +68,8 @@ public:
                          std::size_t new_address_space_size_in_bits) override;

 private:
-    std::shared_ptr<Dynarmic::A32::Jit> MakeJit(Common::PageTable* page_table) const;
+    std::shared_ptr<Dynarmic::A32::Jit> MakeJit(Common::PageTable& page_table,
+                                                std::size_t address_space_bits) const;

    using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
    using JitCacheType =
@@ -79,10 +80,10 @@ private:

    std::unique_ptr<DynarmicCallbacks32> cb;
    JitCacheType jit_cache;
+    std::shared_ptr<Dynarmic::A32::Jit> jit;
    std::shared_ptr<DynarmicCP15> cp15;
    std::size_t core_index;
    DynarmicExclusiveMonitor& exclusive_monitor;
-    std::shared_ptr<Dynarmic::A32::Jit> jit;
 };

 } // namespace Core
--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
@@ -142,7 +142,7 @@ public:
    static constexpr u64 minimum_run_cycles = 1000U;
 };

-std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable* page_table,
+std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable& page_table,
                                                             std::size_t address_space_bits) const {
    Dynarmic::A64::UserConfig config;

@@ -150,15 +150,13 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
    config.callbacks = cb.get();

    // Memory
-    if (page_table) {
-        config.page_table = reinterpret_cast<void**>(page_table->pointers.data());
-        config.page_table_address_space_bits = address_space_bits;
-        config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
-        config.silently_mirror_page_table = false;
-        config.absolute_offset_page_table = true;
-        config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
-        config.only_detect_misalignment_via_page_table_on_page_boundary = true;
-    }
+    config.page_table = reinterpret_cast<void**>(page_table.pointers.data());
+    config.page_table_address_space_bits = address_space_bits;
+    config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
+    config.silently_mirror_page_table = false;
+    config.absolute_offset_page_table = true;
+    config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
+    config.only_detect_misalignment_via_page_table_on_page_boundary = true;

    // Multi-process state
    config.processor_id = core_index;
@@ -177,10 +175,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
    // Timing
    config.wall_clock_cntpct = uses_wall_clock;

-    // Code cache size
-    config.code_cache_size = 512 * 1024 * 1024;
-    config.far_code_offset = 256 * 1024 * 1024;
-
    // Safe optimizations
    if (Settings::values.cpu_accuracy == Settings::CPUAccuracy::DebugMode) {
        if (!Settings::values.cpuopt_page_tables) {
@@ -243,8 +237,7 @@ ARM_Dynarmic_64::ARM_Dynarmic_64(System& system, CPUInterrupts& interrupt_handle
                                 std::size_t core_index)
    : ARM_Interface{system, interrupt_handlers, uses_wall_clock},
      cb(std::make_unique<DynarmicCallbacks64>(*this)), core_index{core_index},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)},
-      jit(MakeJit(nullptr, 48)) {}
+      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}

 ARM_Dynarmic_64::~ARM_Dynarmic_64() = default;

@@ -301,6 +294,9 @@ void ARM_Dynarmic_64::ChangeProcessorID(std::size_t new_core_id) {
 }

 void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) {
+    if (!jit) {
+        return;
+    }
    ctx.cpu_registers = jit->GetRegisters();
    ctx.sp = jit->GetSP();
    ctx.pc = jit->GetPC();
@@ -312,6 +308,9 @@ void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) {
 }

 void ARM_Dynarmic_64::LoadContext(const ThreadContext64& ctx) {
+    if (!jit) {
+        return;
+    }
    jit->SetRegisters(ctx.cpu_registers);
    jit->SetSP(ctx.sp);
    jit->SetPC(ctx.pc);
@@ -327,31 +326,35 @@ void ARM_Dynarmic_64::PrepareReschedule() {
 }

 void ARM_Dynarmic_64::ClearInstructionCache() {
+    if (!jit) {
+        return;
+    }
    jit->ClearCache();
 }

 void ARM_Dynarmic_64::InvalidateCacheRange(VAddr addr, std::size_t size) {
+    if (!jit) {
+        return;
+    }
    jit->InvalidateCacheRange(addr, size);
 }

 void ARM_Dynarmic_64::ClearExclusiveState() {
+    if (!jit) {
+        return;
+    }
    jit->ClearExclusiveState();
 }

 void ARM_Dynarmic_64::PageTableChanged(Common::PageTable& page_table,
                                       std::size_t new_address_space_size_in_bits) {
-    ThreadContext64 ctx{};
-    SaveContext(ctx);
-
    auto key = std::make_pair(&page_table, new_address_space_size_in_bits);
    auto iter = jit_cache.find(key);
    if (iter != jit_cache.end()) {
        jit = iter->second;
-        LoadContext(ctx);
        return;
    }
-    jit = MakeJit(&page_table, new_address_space_size_in_bits);
-    LoadContext(ctx);
+    jit = MakeJit(page_table, new_address_space_size_in_bits);
    jit_cache.emplace(key, jit);
 }

--- a/src/core/arm/dynarmic/arm_dynarmic_64.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.h
@@ -61,7 +61,7 @@ public:
                          std::size_t new_address_space_size_in_bits) override;

 private:
-    std::shared_ptr<Dynarmic::A64::Jit> MakeJit(Common::PageTable* page_table,
+    std::shared_ptr<Dynarmic::A64::Jit> MakeJit(Common::PageTable& page_table,
                                                std::size_t address_space_bits) const;

    using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
@@ -71,11 +71,10 @@ private:
    friend class DynarmicCallbacks64;
    std::unique_ptr<DynarmicCallbacks64> cb;
    JitCacheType jit_cache;
+    std::shared_ptr<Dynarmic::A64::Jit> jit;

    std::size_t core_index;
    DynarmicExclusiveMonitor& exclusive_monitor;
-
-    std::shared_ptr<Dynarmic::A64::Jit> jit;
 };

 } // namespace Core
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -296,20 +296,28 @@ struct System::Impl {
        exit_lock = false;

        if (gpu_core) {
-            gpu_core->ShutDown();
+            gpu_core->WaitIdle();
        }

+        // Shutdown emulation session
        services.reset();
        service_manager.reset();
        cheat_engine.reset();
        telemetry_session.reset();
+
+        // Close all CPU/threading state
        cpu_manager.Shutdown();
-        time_manager.Shutdown();
+
+        // Shutdown kernel and core timing
        core_timing.Shutdown();
+        kernel.Shutdown();
+
+        // Close app loader
        app_loader.reset();
        gpu_core.reset();
        perf_stats.reset();
-        kernel.Shutdown();
+
+        // Clear all applets
        applet_manager.ClearAll();

        LOG_DEBUG(Core, "Shutdown OK");
--- a/src/core/core_timing_util.cpp
+++ b/src/core/core_timing_util.cpp
@@ -0,0 +1,84 @@
+// Copyright 2008 Dolphin Emulator Project / 2017 Citra Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "core/core_timing_util.h"
+
+#include <cinttypes>
+#include <limits>
+#include "common/logging/log.h"
+#include "common/uint128.h"
+#include "core/hardware_properties.h"
+
+namespace Core::Timing {
+
+constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / Hardware::BASE_CLOCK_RATE;
+
+s64 msToCycles(std::chrono::milliseconds ms) {
+    if (static_cast<u64>(ms.count() / 1000) > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (static_cast<u64>(ms.count()) > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return Hardware::BASE_CLOCK_RATE * (ms.count() / 1000);
+    }
+    return (Hardware::BASE_CLOCK_RATE * ms.count()) / 1000;
+}
+
+s64 usToCycles(std::chrono::microseconds us) {
+    if (static_cast<u64>(us.count() / 1000000) > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (static_cast<u64>(us.count()) > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return Hardware::BASE_CLOCK_RATE * (us.count() / 1000000);
+    }
+    return (Hardware::BASE_CLOCK_RATE * us.count()) / 1000000;
+}
+
+s64 nsToCycles(std::chrono::nanoseconds ns) {
+    const u128 temporal = Common::Multiply64Into128(ns.count(), Hardware::BASE_CLOCK_RATE);
+    return Common::Divide128On32(temporal, static_cast<u32>(1000000000)).first;
+}
+
+u64 msToClockCycles(std::chrono::milliseconds ns) {
+    const u128 temp = Common::Multiply64Into128(ns.count(), Hardware::CNTFREQ);
+    return Common::Divide128On32(temp, 1000).first;
+}
+
+u64 usToClockCycles(std::chrono::microseconds ns) {
+    const u128 temp = Common::Multiply64Into128(ns.count(), Hardware::CNTFREQ);
+    return Common::Divide128On32(temp, 1000000).first;
+}
+
+u64 nsToClockCycles(std::chrono::nanoseconds ns) {
+    const u128 temp = Common::Multiply64Into128(ns.count(), Hardware::CNTFREQ);
+    return Common::Divide128On32(temp, 1000000000).first;
+}
+
+u64 CpuCyclesToClockCycles(u64 ticks) {
+    const u128 temporal = Common::Multiply64Into128(ticks, Hardware::CNTFREQ);
+    return Common::Divide128On32(temporal, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
+}
+
+std::chrono::milliseconds CyclesToMs(s64 cycles) {
+    const u128 temporal = Common::Multiply64Into128(cycles, 1000);
+    u64 ms = Common::Divide128On32(temporal, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
+    return std::chrono::milliseconds(ms);
+}
+
+std::chrono::nanoseconds CyclesToNs(s64 cycles) {
+    const u128 temporal = Common::Multiply64Into128(cycles, 1000000000);
+    u64 ns = Common::Divide128On32(temporal, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
+    return std::chrono::nanoseconds(ns);
+}
+
+std::chrono::microseconds CyclesToUs(s64 cycles) {
+    const u128 temporal = Common::Multiply64Into128(cycles, 1000000);
+    u64 us = Common::Divide128On32(temporal, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
+    return std::chrono::microseconds(us);
+}
+
+} // namespace Core::Timing
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
16-Bit-Dog	21f7bd3ca7	random space	2021-02-06 09:59:00 -05:00
16-Bit-Dog	66578f1ffc	more clang i'm going to love condensing these commits	2021-02-06 09:54:57 -05:00
16-Bit-Dog	8b0b7168a0	clang	2021-02-06 09:49:43 -05:00
16-Bit-Dog	5dc02022c5	more fixes yes-I will squash all commits, just will do it when all is proper	2021-02-06 09:14:07 -05:00
16-Bit-Dog	e14bfb31bc	clang	2021-02-05 22:08:12 -05:00
16-Bit-Dog	5c103f7b01	same as previous commit...	2021-02-05 22:04:33 -05:00
16-Bit-Dog	c5b83ffed8	accidental test code parts I left yes I will squash these commits... just want to get the errors out of the way	2021-02-05 22:04:05 -05:00
16-Bit-Dog	acc00771d9	sigh...	2021-02-05 21:21:08 -05:00
16-Bit-Dog	ec32cedb61	the alphabet...	2021-02-05 20:35:42 -05:00
16-Bit-Dog	78cd4dae0a	this PR will eventually abide by clang formatting...	2021-02-05 20:30:00 -05:00
16-Bit-Dog	9cb42fc08d	oh wait, more than 1 thing was wrong; neat	2021-02-05 20:24:53 -05:00
16-Bit-Dog	a9add84a79	clang formatting...	2021-02-05 20:22:32 -05:00
16-Bit-Dog	84a1aad50b	ordering ;)	2021-02-05 20:18:52 -05:00
16-Bit-Dog	bad4e3efcf	thread from the outdated naming previously used	2021-02-05 20:12:35 -05:00
16-Bit-Dog	724e495724	Update src/audio_core/audio_renderer.cpp Co-authored-by: LC <mathew1800@gmail.com>	2021-02-05 20:09:50 -05:00
16-Bit-Dog	8063377c1c	Merge pull request #2 from 16-Bit-Dog/16-Bit-Dog-patch-2 small asyncronous addition to queue buffer release	2021-02-05 19:46:52 -05:00
16-Bit-Dog	c647ed6af9	small asyncronous addition to queue buffer release ReleaseAndQueueBuffers is not additive, nor does it rely on previous math from the loop... despite this, the function it calls (GenerateVoiceCommands and GenerateSubMixCommands) both can take a reasonable amount of time to complete; the use of std::async allows (since a thread pool was already previously made) threads to be pulled from the existing pool, and use it to asynchronously process this specific buffer system for minor improvements I used global lambda copy captures for the reason that the data may not be changed based on previous data, but the variables are still reused finally, I call .wait() rather than a .get() for the std::future due to the way each works; I don't care to return the result, and nor do I want .get() to do the other more hidden actions it does (which results .get() to be consistently slower when profiled versus .wait())	2021-02-05 19:46:40 -05:00
16-Bit-Dog	cd723659d7	Merge pull request #1 from 16-Bit-Dog/16-Bit-Dog-patch-1 future vector added to audio_renderer.h	2021-02-05 19:31:24 -05:00
16-Bit-Dog	3050e64170	future vector added to audio_renderer.h vector of futures to use with std::async	2021-02-05 19:29:42 -05:00