fixup! kernel: memory: Improve implementation of device shared memory.

.ci/scripts/format/exec.sh

@@ -1,7 +1,4 @@
 #!/bin/bash -ex
 
 chmod a+x ./.ci/scripts/format/docker.sh
-# the UID for the container yuzu user is 1027
-sudo chown -R 1027 ./
 docker run -v $(pwd):/yuzu yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh
-sudo chown -R $UID ./

.ci/scripts/linux/docker.sh

@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s
 
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_VULKAN=No
 
 ninja
 

.ci/scripts/linux/exec.sh

@@ -2,7 +2,4 @@
 
 mkdir -p "ccache"  || true
 chmod a+x ./.ci/scripts/linux/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/linux/docker.sh $1
-sudo chown -R $UID ./

.ci/scripts/windows/docker.sh

@@ -4,10 +4,22 @@ cd /yuzu
 
 ccache -s
 
+# Dirty hack to trick unicorn makefile into believing we are in a MINGW system
+mv /bin/uname /bin/uname1 && echo -e '#!/bin/sh\necho MINGW64' >> /bin/uname
+chmod +x /bin/uname
+
+# Dirty hack to trick unicorn makefile into believing we have cmd
+echo '' >> /bin/cmd
+chmod +x /bin/cmd
+
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_VULKAN=No
 ninja
 
+# Clean up the dirty hacks
+rm /bin/uname && mv /bin/uname1 /bin/uname
+rm /bin/cmd
+
 ccache -s
 
 echo "Tests skipped"
@@ -17,13 +29,7 @@ echo 'Prepare binaries...'
 cd ..
 mkdir package
 
-if [ -d "/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/" ]; then
-  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
-else
-  #fallback to qt
-  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt/plugins/platforms/'
-fi
-
+QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
 find build/ -name "yuzu*.exe" -exec cp {} 'package' \;
 
 # copy Qt plugins

.ci/scripts/windows/exec.sh

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

.ci/templates/build-msvc.yml

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

.ci/yuzu-patreon-step2.yml

@@ -5,7 +5,18 @@ variables:
   DisplayVersion: $[counter(variables['DisplayPrefix'], 1)]
 
 stages:
+- stage: format
+  displayName: 'format'
+  jobs:
+  - job: format
+    displayName: 'clang'
+    continueOnError: true
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - template: ./templates/format-check.yml
 - stage: build
+  dependsOn: format
   displayName: 'build'
   jobs:
   - job: build

.gitmodules

@@ -1,15 +1,33 @@
 [submodule "inih"]
     path = externals/inih/inih
     url = https://github.com/svn2github/inih
+[submodule "boost"]
+    path = externals/boost
+    url = https://github.com/yuzu-emu/ext-boost.git
+[submodule "catch"]
+    path = externals/catch
+    url = https://github.com/philsquared/Catch.git
 [submodule "cubeb"]
     path = externals/cubeb
     url = https://github.com/kinetiknz/cubeb.git
 [submodule "dynarmic"]
     path = externals/dynarmic
     url = https://github.com/MerryMage/dynarmic.git
+[submodule "fmt"]
+    path = externals/fmt
+    url = https://github.com/fmtlib/fmt.git
+[submodule "lz4"]
+    path = externals/lz4
+    url = https://github.com/lz4/lz4.git
 [submodule "unicorn"]
     path = externals/unicorn
     url = https://github.com/yuzu-emu/unicorn
+[submodule "mbedtls"]
+    path = externals/mbedtls
+    url = https://github.com/DarkLordZach/mbedtls
+[submodule "opus"]
+    path = externals/opus/opus
+    url = https://github.com/xiph/opus.git
 [submodule "soundtouch"]
     path = externals/soundtouch
     url = https://github.com/citra-emu/ext-soundtouch.git
@@ -22,15 +40,15 @@
 [submodule "Vulkan-Headers"]
     path = externals/Vulkan-Headers
     url = https://github.com/KhronosGroup/Vulkan-Headers.git
+[submodule "externals/zstd"]
+    path = externals/zstd
+    url = https://github.com/facebook/zstd
 [submodule "sirit"]
     path = externals/sirit
     url = https://github.com/ReinUsesLisp/sirit
-[submodule "mbedtls"]
-    path = externals/mbedtls
-    url = https://github.com/DarkLordZach/mbedtls
 [submodule "libzip"]
     path = externals/libzip/libzip
     url = https://github.com/nih-at/libzip.git
-[submodule "xbyak"]
-    path = externals/xbyak
-    url = https://github.com/herumi/xbyak.git
+[submodule "zlib"]
+    path = externals/zlib/zlib
+    url = https://github.com/madler/zlib.git

CMakeLists.txt

@@ -1,8 +1,7 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.7)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/find-modules")
 include(DownloadExternals)
 include(CMakeDependentOption)
 
@@ -11,6 +10,7 @@ project(yuzu)
 # Set bundled sdl2/qt as dependent options.
 # OFF by default, but if ENABLE_SDL2 and MSVC are true then ON
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
 
 option(ENABLE_QT "Enable the Qt frontend" ON)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
@@ -29,13 +29,6 @@ option(ENABLE_VULKAN "Enables Vulkan backend" ON)
 
 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
-# Default to a Release build
-get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
-    message(STATUS "Defaulting to a Release build")
-endif()
-
 if(EXISTS ${PROJECT_SOURCE_DIR}/hooks/pre-commit AND NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
     message(STATUS "Copying pre-commit hook")
     file(COPY hooks/pre-commit
@@ -60,6 +53,7 @@ endfunction()
 if(EXISTS ${PROJECT_SOURCE_DIR}/.gitmodules)
     check_submodules_present()
 endif()
+
 configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
                ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
                COPYONLY)
@@ -121,217 +115,63 @@ message(STATUS "Target architecture: ${ARCHITECTURE}")
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+# System imported libraries
+# ======================
+
+find_package(Boost 1.66.0 QUIET)
+if (NOT Boost_FOUND)
+    message(STATUS "Boost 1.66.0 or newer not found, falling back to externals")
+
+    set(BOOST_ROOT "${PROJECT_SOURCE_DIR}/externals/boost")
+    set(Boost_NO_SYSTEM_PATHS OFF)
+    find_package(Boost QUIET REQUIRED)
+endif()
+
 # Output binaries to bin/
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 
-# System imported libraries
-# If not found, download any missing through Conan
-# =======================================================================
-set(CONAN_CMAKE_SILENT_OUTPUT TRUE)
-set(CMAKE_FIND_PACKAGE_PREFER_CONFIG TRUE)
-if (YUZU_CONAN_INSTALLED)
-    if (IS_MULTI_CONFIG)
-        include(${CMAKE_BINARY_DIR}/conanbuildinfo_multi.cmake)
-    else()
-        include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-    endif()
-    list(APPEND CMAKE_MODULE_PATH "${CMAKE_BINARY_DIR}")
-    list(APPEND CMAKE_PREFIX_PATH "${CMAKE_BINARY_DIR}")
-    conan_basic_setup()
-    message(STATUS "Adding conan installed libraries to the search path")
-endif()
-
-macro(yuzu_find_packages)
-    set(options FORCE_REQUIRED)
-    cmake_parse_arguments(FN "${options}" "" "" ${ARGN})
-
-    # Cmake has a *serious* lack of 2D array or associative array...
-    # Capitalization matters here. We need the naming to match the generated paths from Conan
-    set(REQUIRED_LIBS
-    #    Cmake Pkg Prefix  Version     Conan Pkg
-        "Boost             1.71        boost/1.72.0"
-        "Catch2            2.11        catch2/2.11.0"
-        "fmt               6.2         fmt/6.2.0"
-    # can't use until https://github.com/bincrafters/community/issues/1173
-        #"libzip            1.5         libzip/1.5.2@bincrafters/stable"
-        "lz4               1.8         lz4/1.9.2"
-        "nlohmann_json     3.7         nlohmann_json/3.7.3"
-    # we need to be careful as the version check might be broken https://github.com/xiph/opus/issues/110
-        "opus              1.3         opus/1.3.1"
-        "ZLIB              1.2         zlib/1.2.11"
-        "zstd              1.4         zstd/1.4.4"
-    )
-
-    foreach(PACKAGE ${REQUIRED_LIBS})
-        string(REGEX REPLACE "[ \t\r\n]+" ";" PACKAGE_SPLIT ${PACKAGE})
-        list(GET PACKAGE_SPLIT 0 PACKAGE_PREFIX)
-        list(GET PACKAGE_SPLIT 1 PACKAGE_VERSION)
-        list(GET PACKAGE_SPLIT 2 PACKAGE_CONAN)
-        # This function is called twice, once to check if the packages exist on the system already
-        # and a second time to check if conan installed them properly. The second check passes in FORCE_REQUIRED
-        if (NOT ${PACKAGE_PREFIX}_FOUND)
-            if (FN_FORCE_REQUIRED)
-                find_package(${PACKAGE_PREFIX} ${PACKAGE_VERSION} REQUIRED)
-            else()
-                find_package(${PACKAGE_PREFIX} ${PACKAGE_VERSION})
-            endif()
-        endif()
-        if (NOT ${PACKAGE_PREFIX}_FOUND)
-            list(APPEND CONAN_REQUIRED_LIBS ${PACKAGE_CONAN})
-        else()
-            # Set a legacy findPackage.cmake style PACKAGE_LIBRARIES variable for subprojects that rely on this
-            set(${PACKAGE_PREFIX}_LIBRARIES "${PACKAGE_PREFIX}::${PACKAGE_PREFIX}")
-        endif()
-    endforeach()
-    unset(FN_FORCE_REQUIRED)
-endmacro()
-
-# Attempt to locate any packages that are required and report the missing ones in CONAN_REQUIRED_LIBS
-yuzu_find_packages()
-
-# Qt5 requires that we find components, so it doesn't fit our pretty little find package function
-if(ENABLE_QT)
-    # We want to load the generated conan qt config so that we get the QT_ROOT var so that we can use the official
-    # Qt5Config inside the root folder instead of the conan generated one.
-    if(EXISTS ${CMAKE_BINARY_DIR}/qtConfig.cmake)
-        include(${CMAKE_BINARY_DIR}/qtConfig.cmake)
-        list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
-        list(APPEND CMAKE_PREFIX_PATH "${CONAN_QT_ROOT_RELEASE}")
-    endif()
-    # Workaround for an issue where conan tries to build Qt from scratch instead of download prebuilt binaries
-    set(QT_PREFIX_HINT)
-    if(YUZU_USE_BUNDLED_QT)
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
-            set(QT_VER qt-5.12.0-msvc2017_64)
-        else()
-            message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
-        endif()
-
-        if (DEFINED QT_VER)
-            download_bundled_external("qt/" ${QT_VER} QT_PREFIX)
-        endif()
-
-        set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
-    endif()
-    find_package(Qt5 5.9 COMPONENTS Widgets OpenGL ${QT_PREFIX_HINT})
-    if (NOT Qt5_FOUND)
-        list(APPEND CONAN_REQUIRED_LIBS "qt/5.14.1@bincrafters/stable")
-    endif()
-endif()
-# find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the yuzu_find_package
-if(ENABLE_SDL2)
-    if(EXISTS ${CMAKE_BINARY_DIR}/sdl2Config.cmake)
-        include(${CMAKE_BINARY_DIR}/sdl2Config.cmake)
-        list(APPEND CMAKE_MODULE_PATH "${CONAN_SDL2_ROOT_RELEASE}")
-        list(APPEND CMAKE_PREFIX_PATH "${CONAN_SDL2_ROOT_RELEASE}")
-    endif()
-    find_package(SDL2)
-    if (NOT SDL2_FOUND)
-        # otherwise add this to the list of libraries to install
-        list(APPEND CONAN_REQUIRED_LIBS "sdl2/2.0.12@bincrafters/stable")
-    endif()
-endif()
-
-# Install any missing dependencies with conan install
-if (CONAN_REQUIRED_LIBS)
-    message(STATUS "Packages ${CONAN_REQUIRED_LIBS} not found!")
-    # Use Conan to fetch the libraries that aren't found
-    # Download conan.cmake automatically, you can also just copy the conan.cmake file
-    if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
-        message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
-        file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.15/conan.cmake"
-                        "${CMAKE_BINARY_DIR}/conan.cmake")
-    endif()
-    include(${CMAKE_BINARY_DIR}/conan.cmake)
-
-    set(CONAN_LIB_OPTIONS
-        libzip:with_openssl=False
-        libzip:enable_windows_crypto=False
-    )
-    conan_check(VERSION 1.24.0 REQUIRED)
-    # Add the bincrafters remote
-    conan_add_remote(NAME bincrafters
-                    URL https://api.bintray.com/conan/bincrafters/public-conan)
-
-    # Manually add iconv to fix a dep conflict between qt and sdl2
-    # We don't need to add it through find_package or anything since the other two can find it just fine
-    if ("${CONAN_REQUIRED_LIBS}" MATCHES "qt" AND "${CONAN_REQUIRED_LIBS}" MATCHES "sdl")
-        list(APPEND CONAN_REQUIRED_LIBS "libiconv/1.16")
-    endif()
-    if (IS_MULTI_CONFIG)
-        conan_cmake_run(REQUIRES ${CONAN_REQUIRED_LIBS}
-                        OPTIONS ${CONAN_LIB_OPTIONS}
-                        BUILD missing
-                        CONFIGURATION_TYPES "Release;Debug"
-                        GENERATORS cmake_multi cmake_find_package_multi)
-        include(${CMAKE_BINARY_DIR}/conanbuildinfo_multi.cmake)
-    else()
-        conan_cmake_run(REQUIRES ${CONAN_REQUIRED_LIBS}
-                        OPTIONS ${CONAN_LIB_OPTIONS}
-                        BUILD missing
-                        GENERATORS cmake cmake_find_package_multi)
-        include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-    endif()
-    list(APPEND CMAKE_MODULE_PATH "${CMAKE_BINARY_DIR}")
-    list(APPEND CMAKE_PREFIX_PATH "${CMAKE_BINARY_DIR}")
-    conan_basic_setup()
-
-    set(YUZU_CONAN_INSTALLED TRUE CACHE BOOL "If true, the following builds will add conan to the lib search path" FORCE)
-
-    # Now that we've installed what we are missing, try to locate them again,
-    # this time with required, so we bail if its not found.
-    yuzu_find_packages(FORCE_REQUIRED)
-
-    # Due to issues with variable scopes in functions, we need to also find_package(qt5) outside of the function
-    if(ENABLE_QT)
-        list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
-        list(APPEND CMAKE_PREFIX_PATH "${CONAN_QT_ROOT_RELEASE}")
-        find_package(Qt5 5.9 REQUIRED COMPONENTS Widgets OpenGL)
-        if (YUZU_USE_QT_WEB_ENGINE)
-            find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets)
-        endif()
-    endif()
-    if(ENABLE_SDL2)
-        list(APPEND CMAKE_MODULE_PATH "${CONAN_SDL2_ROOT_RELEASE}")
-        list(APPEND CMAKE_PREFIX_PATH "${CONAN_SDL2_ROOT_RELEASE}")
-        find_package(SDL2 REQUIRED)
-    endif()
-
-endif()
-
-# Reexport some targets that are named differently when using the upstream CmakeConfig vs the generated Conan config
-# In order to ALIAS targets to a new name, they first need to be IMPORTED_GLOBAL
-# Dynarmic checks for target `boost` and so we want to make sure it can find it through our system instead of using their external
-if (TARGET Boost::Boost)
-    set_target_properties(Boost::Boost PROPERTIES IMPORTED_GLOBAL TRUE)
-    add_library(Boost::boost ALIAS Boost::Boost)
-    add_library(boost ALIAS Boost::Boost)
-elseif (TARGET Boost::boost)
-    set_target_properties(Boost::boost PROPERTIES IMPORTED_GLOBAL TRUE)
-    add_library(boost ALIAS Boost::boost)
-endif()
-
-if (TARGET sdl2::sdl2)
-    # imported from the conan generated sdl2Config.cmake
-    set_target_properties(sdl2::sdl2 PROPERTIES IMPORTED_GLOBAL TRUE)
-    add_library(SDL2 ALIAS sdl2::sdl2)
-elseif(SDL2_FOUND)
-    # found through the system package manager
-    # Some installations don't set SDL2_LIBRARIES
-    if("${SDL2_LIBRARIES}" STREQUAL "")
-        message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
-        set(SDL2_LIBRARIES "SDL2::SDL2")
-    endif()
-
-    include_directories(SYSTEM ${SDL2_INCLUDE_DIRS})
-    add_library(SDL2 INTERFACE)
-    target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
-endif()
-
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
 
+if (ENABLE_SDL2)
+    if (YUZU_USE_BUNDLED_SDL2)
+        # Detect toolchain and platform
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+            set(SDL2_VER "SDL2-2.0.8")
+        else()
+            message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
+        endif()
+
+        if (DEFINED SDL2_VER)
+            download_bundled_external("sdl2/" ${SDL2_VER} SDL2_PREFIX)
+        endif()
+
+        set(SDL2_FOUND YES)
+        set(SDL2_INCLUDE_DIR "${SDL2_PREFIX}/include" CACHE PATH "Path to SDL2 headers")
+        set(SDL2_LIBRARY "${SDL2_PREFIX}/lib/x64/SDL2.lib" CACHE PATH "Path to SDL2 library")
+        set(SDL2_DLL_DIR "${SDL2_PREFIX}/lib/x64/" CACHE PATH "Path to SDL2.dll")
+
+        add_library(SDL2 INTERFACE)
+        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARY}")
+        target_include_directories(SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
+    else()
+        find_package(SDL2 REQUIRED)
+
+        # Some installations don't set SDL2_LIBRARIES
+        if("${SDL2_LIBRARIES}" STREQUAL "")
+            message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
+            set(SDL2_LIBRARIES "SDL2::SDL2")
+        endif()
+
+        include_directories(${SDL2_INCLUDE_DIRS})
+        add_library(SDL2 INTERFACE)
+        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
+    endif()
+else()
+    set(SDL2_FOUND NO)
+endif()
+
 # If unicorn isn't found, msvc -> download bundled unicorn; everyone else -> build external
 if (YUZU_USE_BUNDLED_UNICORN)
     if (MSVC)
@@ -372,12 +212,8 @@ if (YUZU_USE_BUNDLED_UNICORN)
         find_package(PythonInterp 2.7 REQUIRED)
 
         if (MINGW)
-            # Intentionally call the unicorn makefile directly instead of using make.sh so that we can override the
-            # UNAME_S makefile variable to MINGW. This way we don't have to hack at the uname binary to build
-            # Additionally, overriding DO_WINDOWS_EXPORT prevents unicorn from patching the static unicorn.a by using msvc and cmd,
-            # which are both things we don't have in a mingw cross compiling environment.
             add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
-                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" CC=x86_64-w64-mingw32-gcc AR=x86_64-w64-mingw32-gcc-ar RANLIB=x86_64-w64-mingw32-gcc-ranlib make UNAME_S=MINGW DO_WINDOWS_EXPORT=0
+                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh cross-win64
                 WORKING_DIRECTORY ${UNICORN_PREFIX}
             )
         else()
@@ -407,6 +243,32 @@ else()
     message(FATAL_ERROR "Could not find or build unicorn which is required.")
 endif()
 
+if (ENABLE_QT)
+    if (YUZU_USE_BUNDLED_QT)
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+            set(QT_VER qt-5.12.0-msvc2017_64)
+        else()
+            message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
+        endif()
+
+        if (DEFINED QT_VER)
+            download_bundled_external("qt/" ${QT_VER} QT_PREFIX)
+        endif()
+
+        set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
+    else()
+        # Passing an empty HINTS seems to cause default system paths to get ignored in CMake 2.8 so
+        # make sure to not pass anything if we don't have one.
+        set(QT_PREFIX_HINT)
+    endif()
+
+    find_package(Qt5 REQUIRED COMPONENTS Widgets OpenGL ${QT_PREFIX_HINT})
+
+    if (YUZU_USE_QT_WEB_ENGINE)
+        find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets ${QT_PREFIX_HINT})
+    endif ()
+endif()
+
 # Platform-specific library requirements
 # ======================================
 
@@ -437,7 +299,7 @@ find_program(CLANG_FORMAT
     PATHS ${PROJECT_BINARY_DIR}/externals)
 # if find_program doesn't find it, try to download from externals
 if (NOT CLANG_FORMAT)
-    if (WIN32 AND NOT CMAKE_CROSSCOMPILING)
+    if (WIN32)
         message(STATUS "Clang format not found! Downloading...")
         set(CLANG_FORMAT "${PROJECT_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
         file(DOWNLOAD

CMakeModules/GenerateSCMRev.cmake

@@ -51,8 +51,6 @@ endif()
 # The variable SRC_DIR must be passed into the script (since it uses the current build directory for all values of CMAKE_*_DIR)
 set(VIDEO_CORE "${SRC_DIR}/src/video_core")
 set(HASH_FILES
-    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
-    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
     "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
     "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
     "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"

CMakeModules/MinGWCross.cmake

@@ -10,8 +10,8 @@ set(SDL2_PATH                       ${MINGW_PREFIX})
 set(MINGW_TOOL_PREFIX               ${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-)
 
 # Specify the cross compiler
-set(CMAKE_C_COMPILER            ${MINGW_TOOL_PREFIX}gcc)
-set(CMAKE_CXX_COMPILER          ${MINGW_TOOL_PREFIX}g++)
+set(CMAKE_C_COMPILER            ${MINGW_TOOL_PREFIX}gcc-posix)
+set(CMAKE_CXX_COMPILER          ${MINGW_TOOL_PREFIX}g++-posix)
 set(CMAKE_RC_COMPILER           ${MINGW_TOOL_PREFIX}windres)
 
 # Mingw tools

dist/qt_themes/qdarkstyle/style.qss

@@ -673,6 +673,10 @@ QTabWidget::pane {
     border-bottom-left-radius: 2px;
 }
 
+QTabWidget::tab-bar {
+    overflow: visible;
+}
+
 QTabBar {
     qproperty-drawBase: 0;
     border-radius: 3px;

externals/CMakeLists.txt

@@ -1,20 +1,30 @@
 # Definitions for all external bundled libraries
 
-list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules")
-list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/externals/find-modules")
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/CMakeModules)
 include(DownloadExternals)
 
-# xbyak
-if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    add_library(xbyak INTERFACE)
-    target_include_directories(xbyak SYSTEM INTERFACE ./xbyak/xbyak)
-    target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
+# pkgconfig -- it is used to find shared libraries without cmake modules on linux systems
+find_package(PkgConfig)
+if (NOT PkgConfig_FOUND)
+    function(pkg_check_modules)
+        # STUB
+    endfunction()
 endif()
 
 # Catch
 add_library(catch-single-include INTERFACE)
 target_include_directories(catch-single-include INTERFACE catch/single_include)
 
+# libfmt
+pkg_check_modules(FMT IMPORTED_TARGET GLOBAL fmt>=6.1.0)
+if (FMT_FOUND)
+    add_library(fmt::fmt ALIAS PkgConfig::FMT)
+else()
+    message(STATUS "fmt 6.1.0 or newer not found, falling back to externals")
+    add_subdirectory(fmt)
+    add_library(fmt::fmt ALIAS fmt)
+endif()
+
 # Dynarmic
 if (ARCHITECTURE_x86_64)
     set(DYNARMIC_TESTS OFF)
@@ -33,6 +43,17 @@ add_subdirectory(glad)
 # inih
 add_subdirectory(inih)
 
+# lz4
+pkg_check_modules(LIBLZ4 IMPORTED_TARGET GLOBAL liblz4>=1.8.0)
+if (LIBLZ4_FOUND)
+    add_library(lz4_static ALIAS PkgConfig::LIBLZ4)
+else()
+    message(STATUS "liblz4 1.8.0 or newer not found, falling back to externals")
+    set(LZ4_BUNDLED_MODE ON)
+    add_subdirectory(lz4/contrib/cmake_unofficial EXCLUDE_FROM_ALL)
+    target_include_directories(lz4_static INTERFACE ./lz4/lib)
+endif()
+
 # mbedtls
 add_subdirectory(mbedtls EXCLUDE_FROM_ALL)
 target_include_directories(mbedtls PUBLIC ./mbedtls/include)
@@ -45,9 +66,29 @@ target_include_directories(microprofile INTERFACE ./microprofile)
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
 
+# Zstandard
+pkg_check_modules(LIBZSTD IMPORTED_TARGET GLOBAL libzstd>=1.3.8)
+if (LIBZSTD_FOUND)
+    add_library(libzstd_static ALIAS PkgConfig::LIBZSTD)
+else()
+    message(STATUS "libzstd 1.3.8 or newer not found, falling back to externals")
+    add_subdirectory(zstd/build/cmake EXCLUDE_FROM_ALL)
+    target_include_directories(libzstd_static INTERFACE ./zstd/lib)
+endif()
+
 # SoundTouch
 add_subdirectory(soundtouch)
 
+# Opus
+pkg_check_modules(OPUS IMPORTED_TARGET GLOBAL opus>=1.3.1)
+if (OPUS_FOUND)
+    add_library(opus ALIAS PkgConfig::OPUS)
+else()
+    message(STATUS "opus 1.3.1 or newer not found, falling back to externals")
+    add_subdirectory(opus)
+    target_include_directories(opus INTERFACE ./opus/include)
+endif()
+
 # Cubeb
 if(ENABLE_CUBEB)
     set(BUILD_TESTS OFF CACHE BOOL "")
@@ -65,22 +106,36 @@ if (ENABLE_VULKAN)
     add_subdirectory(sirit)
 endif()
 
+# zlib
+find_package(ZLIB 1.2.11)
+if (NOT ZLIB_FOUND)
+    message(STATUS "zlib 1.2.11 or newer not found, falling back to externals")
+    add_subdirectory(zlib EXCLUDE_FROM_ALL)
+    set(ZLIB_LIBRARIES z)
+endif()
+
 # libzip
-find_package(Libzip 1.5)
-if (NOT LIBZIP_FOUND)
-    message(STATUS "libzip 1.5 or newer not found, falling back to externals")
+pkg_check_modules(LIBZIP IMPORTED_TARGET GLOBAL libzip>=1.5.3)
+if (LIBZIP_FOUND)
+    add_library(zip ALIAS PkgConfig::LIBZIP)
+else()
+    message(STATUS "libzip 1.5.3 or newer not found, falling back to externals")
     add_subdirectory(libzip EXCLUDE_FROM_ALL)
 endif()
 
 if (ENABLE_WEB_SERVICE)
     # LibreSSL
-    set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
-    add_subdirectory(libressl EXCLUDE_FROM_ALL)
-    target_include_directories(ssl INTERFACE ./libressl/include)
-    target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
-    get_directory_property(OPENSSL_LIBRARIES
-        DIRECTORY libressl
-        DEFINITION OPENSSL_LIBS)
+    find_package(OpenSSL COMPONENTS Crypto SSL)
+    if (NOT OpenSSL_FOUND)
+        message(STATUS "OpenSSL not found, falling back to externals")
+        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
+        add_subdirectory(libressl EXCLUDE_FROM_ALL)
+        target_include_directories(ssl INTERFACE ./libressl/include)
+        target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
+        get_directory_property(OPENSSL_LIBRARIES
+            DIRECTORY libressl
+            DEFINITION OPENSSL_LIBS)
+    endif()
 
     # lurlparser
     add_subdirectory(lurlparser EXCLUDE_FROM_ALL)
@@ -90,4 +145,8 @@ if (ENABLE_WEB_SERVICE)
     target_include_directories(httplib INTERFACE ./httplib)
     target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
     target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
+
+    # JSON
+    add_library(json-headers INTERFACE)
+    target_include_directories(json-headers INTERFACE ./json)
 endif()

externals/find-modules/FindCatch2.cmake

@@ -1,49 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_Catch2 QUIET Catch2)
-
-find_path(Catch2_INCLUDE_DIR
-  NAMES catch.hpp
-  PATHS ${PC_Catch2_INCLUDE_DIRS} ${CONAN_CATCH2_ROOT}
-  PATH_SUFFIXES catch2
-)
-
-if(Catch2_INCLUDE_DIR)
-  file(STRINGS "${Catch2_INCLUDE_DIR}/catch.hpp" _Catch2_version_lines
-    REGEX "#define[ \t]+CATCH_VERSION_(MAJOR|MINOR|PATCH)")
-  string(REGEX REPLACE ".*CATCH_VERSION_MAJOR +\([0-9]+\).*" "\\1" _Catch2_version_major "${_Catch2_version_lines}")
-  string(REGEX REPLACE ".*CATCH_VERSION_MINOR +\([0-9]+\).*" "\\1" _Catch2_version_minor "${_Catch2_version_lines}")
-  string(REGEX REPLACE ".*CATCH_VERSION_PATCH +\([0-9]+\).*" "\\1" _Catch2_version_patch "${_Catch2_version_lines}")
-  set(Catch2_VERSION "${_Catch2_version_major}.${_Catch2_version_minor}.${_Catch2_version_patch}")
-  unset(_Catch2_version_major)
-  unset(_Catch2_version_minor)
-  unset(_Catch2_version_patch)
-  unset(_Catch2_version_lines)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Catch2
-  FOUND_VAR Catch2_FOUND
-  REQUIRED_VARS
-    Catch2_INCLUDE_DIR
-    Catch2_VERSION
-  VERSION_VAR Catch2_VERSION
-)
-
-if(Catch2_FOUND)
-  set(Catch2_INCLUDE_DIRS ${Catch2_INCLUDE_DIR})
-  set(Catch2_DEFINITIONS ${PC_Catch2_CFLAGS_OTHER})
-endif()
-
-if(Catch2_FOUND AND NOT TARGET Catch2::Catch2)
-  add_library(Catch2::Catch2 UNKNOWN IMPORTED)
-  set_target_properties(Catch2::Catch2 PROPERTIES
-    IMPORTED_LOCATION "${Catch2_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_Catch2_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${Catch2_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    Catch2_INCLUDE_DIR
-)

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
-)

externals/find-modules/Findfmt.cmake

@@ -1,69 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_fmt QUIET fmt)
-
-find_path(fmt_INCLUDE_DIR
-  NAMES format.h
-  PATHS ${PC_fmt_INCLUDE_DIRS} ${CONAN_INCLUDE_DIRS_fmt}
-  PATH_SUFFIXES fmt
-)
-
-find_library(fmt_LIBRARY
-  NAMES fmt
-  PATHS ${PC_fmt_LIBRARY_DIRS} ${CONAN_LIB_DIRS_fmt}
-)
-
-if(fmt_INCLUDE_DIR)
-  set(_fmt_version_file "${fmt_INCLUDE_DIR}/core.h")
-  if(NOT EXISTS "${_fmt_version_file}")
-    set(_fmt_version_file "${fmt_INCLUDE_DIR}/format.h")
-  endif()
-  if(EXISTS "${_fmt_version_file}")
-    # parse "#define FMT_VERSION 60200" to 6.2.0
-    file(STRINGS "${_fmt_version_file}" fmt_VERSION_LINE
-      REGEX "^#define[ \t]+FMT_VERSION[ \t]+[0-9]+$")
-    string(REGEX REPLACE "^#define[ \t]+FMT_VERSION[ \t]+([0-9]+)$"
-      "\\1" fmt_VERSION "${fmt_VERSION_LINE}")
-    foreach(ver "fmt_VERSION_PATCH" "fmt_VERSION_MINOR" "fmt_VERSION_MAJOR")
-      math(EXPR ${ver} "${fmt_VERSION} % 100")
-      math(EXPR fmt_VERSION "(${fmt_VERSION} - ${${ver}}) / 100")
-    endforeach()
-    set(fmt_VERSION
-      "${fmt_VERSION_MAJOR}.${fmt_VERSION_MINOR}.${fmt_VERSION_PATCH}")
-  endif()
-  unset(_fmt_version_file)
-  unset(fmt_VERSION_LINE)
-  unset(fmt_VERSION_MAJOR)
-  unset(fmt_VERSION_MINOR)
-  unset(fmt_VERSION_PATCH)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(fmt
-  FOUND_VAR fmt_FOUND
-  REQUIRED_VARS
-    fmt_LIBRARY
-    fmt_INCLUDE_DIR
-    fmt_VERSION
-  VERSION_VAR fmt_VERSION
-)
-
-if(fmt_FOUND)
-  set(fmt_LIBRARIES ${fmt_LIBRARY})
-  set(fmt_INCLUDE_DIRS ${fmt_INCLUDE_DIR})
-  set(fmt_DEFINITIONS ${PC_fmt_CFLAGS_OTHER})
-endif()
-
-if(fmt_FOUND AND NOT TARGET fmt::fmt)
-  add_library(fmt::fmt UNKNOWN IMPORTED)
-  set_target_properties(fmt::fmt PROPERTIES
-    IMPORTED_LOCATION "${fmt_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_fmt_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${fmt_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    fmt_INCLUDE_DIR
-    fmt_LIBRARY
-)

externals/find-modules/Findlz4.cmake

@@ -1,54 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_lz4 QUIET lz4)
-
-find_path(lz4_INCLUDE_DIR
-  NAMES lz4.h
-  PATHS ${PC_lz4_INCLUDE_DIRS}
-)
-find_library(lz4_LIBRARY
-  NAMES lz4
-  PATHS ${PC_lz4_LIBRARY_DIRS}
-)
-
-if(lz4_INCLUDE_DIR)
-  file(STRINGS "${lz4_INCLUDE_DIR}/lz4.h" _lz4_version_lines
-    REGEX "#define[ \t]+LZ4_VERSION_(MAJOR|MINOR|RELEASE)")
-  string(REGEX REPLACE ".*LZ4_VERSION_MAJOR *\([0-9]*\).*" "\\1" _lz4_version_major "${_lz4_version_lines}")
-  string(REGEX REPLACE ".*LZ4_VERSION_MINOR *\([0-9]*\).*" "\\1" _lz4_version_minor "${_lz4_version_lines}")
-  string(REGEX REPLACE ".*LZ4_VERSION_RELEASE *\([0-9]*\).*" "\\1" _lz4_version_release "${_lz4_version_lines}")
-  set(lz4_VERSION "${_lz4_version_major}.${_lz4_version_minor}.${_lz4_version_release}")
-  unset(_lz4_version_major)
-  unset(_lz4_version_minor)
-  unset(_lz4_version_release)
-  unset(_lz4_version_lines)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(lz4
-  FOUND_VAR lz4_FOUND
-  REQUIRED_VARS
-    lz4_LIBRARY
-    lz4_INCLUDE_DIR
-  VERSION_VAR lz4_VERSION
-)
-
-if(lz4_FOUND)
-  set(lz4_LIBRARIES ${lz4_LIBRARY})
-  set(lz4_INCLUDE_DIRS ${lz4_INCLUDE_DIR})
-  set(lz4_DEFINITIONS ${PC_lz4_CFLAGS_OTHER})
-endif()
-
-if(lz4_FOUND AND NOT TARGET lz4::lz4)
-  add_library(lz4::lz4 UNKNOWN IMPORTED)
-  set_target_properties(lz4::lz4 PROPERTIES
-    IMPORTED_LOCATION "${lz4_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_lz4_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${lz4_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    lz4_INCLUDE_DIR
-    lz4_LIBRARY
-)

externals/find-modules/Findnlohmann_json.cmake

@@ -1,49 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_nlohmann_json QUIET nlohmann_json)
-
-find_path(nlohmann_json_INCLUDE_DIR
-  NAMES json.hpp
-  PATHS ${PC_nlohmann_json_INCLUDE_DIRS}
-  PATH_SUFFIXES nlohmann
-)
-
-if(nlohmann_json_INCLUDE_DIR)
-  file(STRINGS "${nlohmann_json_INCLUDE_DIR}/json.hpp" _nlohmann_json_version_lines
-    REGEX "#define[ \t]+NLOHMANN_JSON_VERSION_(MAJOR|MINOR|PATCH)")
-  string(REGEX REPLACE ".*NLOHMANN_JSON_VERSION_MAJOR +\([0-9]+\).*" "\\1" _nlohmann_json_version_major "${_nlohmann_json_version_lines}")
-  string(REGEX REPLACE ".*NLOHMANN_JSON_VERSION_MINOR +\([0-9]+\).*" "\\1" _nlohmann_json_version_minor "${_nlohmann_json_version_lines}")
-  string(REGEX REPLACE ".*NLOHMANN_JSON_VERSION_PATCH +\([0-9]+\).*" "\\1" _nlohmann_json_version_patch "${_nlohmann_json_version_lines}")
-  set(nlohmann_json_VERSION "${_nlohmann_json_version_major}.${_nlohmann_json_version_minor}.${_nlohmann_json_version_patch}")
-  unset(_nlohmann_json_version_major)
-  unset(_nlohmann_json_version_minor)
-  unset(_nlohmann_json_version_patch)
-  unset(_nlohmann_json_version_lines)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(nlohmann_json
-  FOUND_VAR nlohmann_json_FOUND
-  REQUIRED_VARS
-    nlohmann_json_INCLUDE_DIR
-    nlohmann_json_VERSION
-  VERSION_VAR nlohmann_json_VERSION
-)
-
-if(nlohmann_json_FOUND)
-  set(nlohmann_json_INCLUDE_DIRS ${nlohmann_json_INCLUDE_DIR})
-  set(nlohmann_json_DEFINITIONS ${PC_nlohmann_json_CFLAGS_OTHER})
-endif()
-
-if(nlohmann_json_FOUND AND NOT TARGET nlohmann_json::nlohmann_json)
-  add_library(nlohmann_json::nlohmann_json UNKNOWN IMPORTED)
-  set_target_properties(nlohmann_json::nlohmann_json PROPERTIES
-    IMPORTED_LOCATION "${nlohmann_json_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_nlohmann_json_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${nlohmann_json_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    nlohmann_json_INCLUDE_DIR
-)

externals/find-modules/Findopus.cmake

@@ -1,42 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_opus QUIET opus)
-
-find_path(opus_INCLUDE_DIR
-  NAMES opus.h
-  PATHS ${PC_opus_INCLUDE_DIRS}
-  PATH_SUFFIXES opus
-)
-find_library(opus_LIBRARY
-  NAMES opus
-  PATHS ${PC_opus_LIBRARY_DIRS}
-)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(opus
-  FOUND_VAR opus_FOUND
-  REQUIRED_VARS
-    opus_LIBRARY
-    opus_INCLUDE_DIR
-  VERSION_VAR opus_VERSION
-)
-
-if(opus_FOUND)
-  set(Opus_LIBRARIES ${opus_LIBRARY})
-  set(Opus_INCLUDE_DIRS ${opus_INCLUDE_DIR})
-  set(Opus_DEFINITIONS ${PC_opus_CFLAGS_OTHER})
-endif()
-
-if(opus_FOUND AND NOT TARGET Opus::Opus)
-  add_library(Opus::Opus UNKNOWN IMPORTED)
-  set_target_properties(Opus::Opus PROPERTIES
-    IMPORTED_LOCATION "${opus_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_opus_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${opus_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    opus_INCLUDE_DIR
-    opus_LIBRARY
-)

externals/find-modules/Findzstd.cmake

@@ -1,55 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_zstd QUIET libzstd)
-
-find_path(zstd_INCLUDE_DIR
-  NAMES zstd.h
-  PATHS ${PC_zstd_INCLUDE_DIRS}
-)
-find_library(zstd_LIBRARY
-  NAMES zstd
-  PATHS ${PC_zstd_LIBRARY_DIRS}
-)
-
-if(zstd_INCLUDE_DIR)
-  file(STRINGS "${zstd_INCLUDE_DIR}/zstd.h" _zstd_version_lines
-    REGEX "#define[ \t]+ZSTD_VERSION_(MAJOR|MINOR|RELEASE)")
-  string(REGEX REPLACE ".*ZSTD_VERSION_MAJOR *\([0-9]*\).*" "\\1" _zstd_version_major "${_zstd_version_lines}")
-  string(REGEX REPLACE ".*ZSTD_VERSION_MINOR *\([0-9]*\).*" "\\1" _zstd_version_minor "${_zstd_version_lines}")
-  string(REGEX REPLACE ".*ZSTD_VERSION_RELEASE *\([0-9]*\).*" "\\1" _zstd_version_release "${_zstd_version_lines}")
-  set(zstd_VERSION "${_zstd_version_major}.${_zstd_version_minor}.${_zstd_version_release}")
-  unset(_zstd_version_major)
-  unset(_zstd_version_minor)
-  unset(_zstd_version_release)
-  unset(_zstd_version_lines)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(zstd
-  FOUND_VAR zstd_FOUND
-  REQUIRED_VARS
-    zstd_LIBRARY
-    zstd_INCLUDE_DIR
-    zstd_VERSION
-  VERSION_VAR zstd_VERSION
-)
-
-if(zstd_FOUND)
-  set(zstd_LIBRARIES ${zstd_LIBRARY})
-  set(zstd_INCLUDE_DIRS ${zstd_INCLUDE_DIR})
-  set(zstd_DEFINITIONS ${PC_zstd_CFLAGS_OTHER})
-endif()
-
-if(zstd_FOUND AND NOT TARGET zstd::zstd)
-  add_library(zstd::zstd UNKNOWN IMPORTED)
-  set_target_properties(zstd::zstd PROPERTIES
-    IMPORTED_LOCATION "${zstd_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_zstd_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${zstd_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    zstd_INCLUDE_DIR
-    zstd_LIBRARY
-)

externals/json/README.md

@@ -0,0 +1,9 @@
+JSON for Modern C++
+===================
+
+v3.1.2
+
+This is a mirror providing the single required header file.
+
+The original repository can be found at:
+https://github.com/nlohmann/json/commit/d2dd27dc3b8472dbaa7d66f83619b3ebcd9185fe

externals/microprofile/microprofile.h

@@ -910,14 +910,14 @@ typedef void* (*MicroProfileThreadFunc)(void*);
 
 #ifndef _WIN32
 typedef pthread_t MicroProfileThread;
-inline void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
+void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
 {
     pthread_attr_t Attr;
     int r  = pthread_attr_init(&Attr);
     MP_ASSERT(r == 0);
     pthread_create(pThread, &Attr, Func, 0);
 }
-inline void MicroProfileThreadJoin(MicroProfileThread* pThread)
+void MicroProfileThreadJoin(MicroProfileThread* pThread)
 {
     int r = pthread_join(*pThread, 0);
     MP_ASSERT(r == 0);
@@ -930,11 +930,11 @@ DWORD _stdcall ThreadTrampoline(void* pFunc)
     return (uint32_t)F(0);
 }
 
-inline void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
+void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
 {
     *pThread = CreateThread(0, 0, ThreadTrampoline, Func, 0, 0);
 }
-inline void MicroProfileThreadJoin(MicroProfileThread* pThread)
+void MicroProfileThreadJoin(MicroProfileThread* pThread)
 {
     WaitForSingleObject(*pThread, INFINITE);
     CloseHandle(*pThread);
@@ -1131,7 +1131,7 @@ inline void MicroProfileSetThreadLog(MicroProfileThreadLog* pLog)
     pthread_setspecific(g_MicroProfileThreadLogKey, pLog);
 }
 #else
-inline MicroProfileThreadLog* MicroProfileGetThreadLog()
+MicroProfileThreadLog* MicroProfileGetThreadLog()
 {
     return g_MicroProfileThreadLog;
 }
@@ -1247,7 +1247,7 @@ MicroProfileToken MicroProfileFindToken(const char* pGroup, const char* pName)
     return MICROPROFILE_INVALID_TOKEN;
 }
 
-inline uint16_t MicroProfileGetGroup(const char* pGroup, MicroProfileTokenType Type)
+uint16_t MicroProfileGetGroup(const char* pGroup, MicroProfileTokenType Type)
 {
     for(uint32_t i = 0; i < S.nGroupCount; ++i)
     {
@@ -1276,7 +1276,7 @@ inline uint16_t MicroProfileGetGroup(const char* pGroup, MicroProfileTokenType T
     return nGroupIndex;
 }
 
-inline void MicroProfileRegisterGroup(const char* pGroup, const char* pCategory, uint32_t nColor)
+void MicroProfileRegisterGroup(const char* pGroup, const char* pCategory, uint32_t nColor)
 {
     int nCategoryIndex = -1;
     for(uint32_t i = 0; i < S.nCategoryCount; ++i)
@@ -1442,7 +1442,7 @@ void MicroProfileGpuLeave(MicroProfileToken nToken_, uint64_t nTickStart)
     }
 }
 
-inline void MicroProfileContextSwitchPut(MicroProfileContextSwitch* pContextSwitch)
+void MicroProfileContextSwitchPut(MicroProfileContextSwitch* pContextSwitch)
 {
     if(S.nRunning || pContextSwitch->nTicks <= S.nPauseTicks)
     {
@@ -1894,7 +1894,7 @@ void MicroProfileSetEnableAllGroups(bool bEnableAllGroups)
     S.nAllGroupsWanted = bEnableAllGroups ? 1 : 0;
 }
 
-inline void MicroProfileEnableCategory(const char* pCategory, bool bEnabled)
+void MicroProfileEnableCategory(const char* pCategory, bool bEnabled)
 {
     int nCategoryIndex = -1;
     for(uint32_t i = 0; i < S.nCategoryCount; ++i)
@@ -2004,7 +2004,7 @@ void MicroProfileForceDisableGroup(const char* pGroup, MicroProfileTokenType Typ
 }
 
 
-inline void MicroProfileCalcAllTimers(float* pTimers, float* pAverage, float* pMax, float* pCallAverage, float* pExclusive, float* pAverageExclusive, float* pMaxExclusive, float* pTotal, uint32_t nSize)
+void MicroProfileCalcAllTimers(float* pTimers, float* pAverage, float* pMax, float* pCallAverage, float* pExclusive, float* pAverageExclusive, float* pMaxExclusive, float* pTotal, uint32_t nSize)
 {
     for(uint32_t i = 0; i < S.nTotalTimers && i < nSize; ++i)
     {

externals/microprofile/microprofileui.h

@@ -417,19 +417,19 @@ void MicroProfileToggleDisplayMode()
 }
 
 
-inline void MicroProfileStringArrayClear(MicroProfileStringArray* pArray)
+void MicroProfileStringArrayClear(MicroProfileStringArray* pArray)
 {
     pArray->nNumStrings = 0;
     pArray->pBufferPos = &pArray->Buffer[0];
 }
 
-inline void MicroProfileStringArrayAddLiteral(MicroProfileStringArray* pArray, const char* pLiteral)
+void MicroProfileStringArrayAddLiteral(MicroProfileStringArray* pArray, const char* pLiteral)
 {
     MP_ASSERT(pArray->nNumStrings < MICROPROFILE_TOOLTIP_MAX_STRINGS);
     pArray->ppStrings[pArray->nNumStrings++] = pLiteral;
 }
 
-inline void MicroProfileStringArrayFormat(MicroProfileStringArray* pArray, const char* fmt, ...)
+void MicroProfileStringArrayFormat(MicroProfileStringArray* pArray, const char* fmt, ...)
 {
     MP_ASSERT(pArray->nNumStrings < MICROPROFILE_TOOLTIP_MAX_STRINGS);
     pArray->ppStrings[pArray->nNumStrings++] = pArray->pBufferPos;
@@ -439,7 +439,7 @@ inline void MicroProfileStringArrayFormat(MicroProfileStringArray* pArray, const
     va_end(args);
     MP_ASSERT(pArray->pBufferPos < pArray->Buffer + MICROPROFILE_TOOLTIP_STRING_BUFFER_SIZE);
 }
-inline void MicroProfileStringArrayCopy(MicroProfileStringArray* pDest, MicroProfileStringArray* pSrc)
+void MicroProfileStringArrayCopy(MicroProfileStringArray* pDest, MicroProfileStringArray* pSrc)
 {
     memcpy(&pDest->ppStrings[0], &pSrc->ppStrings[0], sizeof(pDest->ppStrings));
     memcpy(&pDest->Buffer[0], &pSrc->Buffer[0], sizeof(pDest->Buffer));
@@ -456,7 +456,7 @@ inline void MicroProfileStringArrayCopy(MicroProfileStringArray* pDest, MicroPro
     pDest->nNumStrings = pSrc->nNumStrings;
 }
 
-inline void MicroProfileFloatWindowSize(const char** ppStrings, uint32_t nNumStrings, uint32_t* pColors, uint32_t& nWidth, uint32_t& nHeight, uint32_t* pStringLengths = 0)
+void MicroProfileFloatWindowSize(const char** ppStrings, uint32_t nNumStrings, uint32_t* pColors, uint32_t& nWidth, uint32_t& nHeight, uint32_t* pStringLengths = 0)
 {
     uint32_t* nStringLengths = pStringLengths ? pStringLengths : (uint32_t*)alloca(nNumStrings * sizeof(uint32_t));
     uint32_t nTextCount = nNumStrings/2;
@@ -474,7 +474,7 @@ inline void MicroProfileFloatWindowSize(const char** ppStrings, uint32_t nNumStr
     nHeight = (MICROPROFILE_TEXT_HEIGHT+1) * nTextCount + 2 * MICROPROFILE_BORDER_SIZE;
 }
 
-inline void MicroProfileDrawFloatWindow(uint32_t nX, uint32_t nY, const char** ppStrings, uint32_t nNumStrings, uint32_t nColor, uint32_t* pColors = 0)
+void MicroProfileDrawFloatWindow(uint32_t nX, uint32_t nY, const char** ppStrings, uint32_t nNumStrings, uint32_t nColor, uint32_t* pColors = 0)
 {
     uint32_t nWidth = 0, nHeight = 0;
     uint32_t* nStringLengths = (uint32_t*)alloca(nNumStrings * sizeof(uint32_t));
@@ -503,7 +503,7 @@ inline void MicroProfileDrawFloatWindow(uint32_t nX, uint32_t nY, const char** p
         nY += (MICROPROFILE_TEXT_HEIGHT+1);
     }
 }
-inline void MicroProfileDrawTextBox(uint32_t nX, uint32_t nY, const char** ppStrings, uint32_t nNumStrings, uint32_t nColor, uint32_t* pColors = 0)
+void MicroProfileDrawTextBox(uint32_t nX, uint32_t nY, const char** ppStrings, uint32_t nNumStrings, uint32_t nColor, uint32_t* pColors = 0)
 {
     uint32_t nWidth = 0, nHeight = 0;
     uint32_t* nStringLengths = (uint32_t*)alloca(nNumStrings * sizeof(uint32_t));
@@ -529,7 +529,7 @@ inline void MicroProfileDrawTextBox(uint32_t nX, uint32_t nY, const char** ppStr
 
 
 
-inline void MicroProfileToolTipMeta(MicroProfileStringArray* pToolTip)
+void MicroProfileToolTipMeta(MicroProfileStringArray* pToolTip)
 {
     MicroProfile& S = *MicroProfileGet();
     if(UI.nRangeBeginIndex != UI.nRangeEndIndex && UI.pRangeLog)
@@ -608,7 +608,7 @@ inline void MicroProfileToolTipMeta(MicroProfileStringArray* pToolTip)
     }
 }
 
-inline void MicroProfileDrawFloatTooltip(uint32_t nX, uint32_t nY, uint32_t nToken, uint64_t nTime)
+void MicroProfileDrawFloatTooltip(uint32_t nX, uint32_t nY, uint32_t nToken, uint64_t nTime)
 {
     MicroProfile& S = *MicroProfileGet();
 
@@ -718,7 +718,7 @@ inline void MicroProfileDrawFloatTooltip(uint32_t nX, uint32_t nY, uint32_t nTok
 }
 
 
-inline void MicroProfileZoomTo(int64_t nTickStart, int64_t nTickEnd)
+void MicroProfileZoomTo(int64_t nTickStart, int64_t nTickEnd)
 {
     MicroProfile& S = *MicroProfileGet();
 
@@ -728,7 +728,7 @@ inline void MicroProfileZoomTo(int64_t nTickStart, int64_t nTickEnd)
     UI.fDetailedRangeTarget = MicroProfileLogTickDifference(nTickStart, nTickEnd) * fToMs;
 }
 
-inline void MicroProfileCenter(int64_t nTickCenter)
+void MicroProfileCenter(int64_t nTickCenter)
 {
     MicroProfile& S = *MicroProfileGet();
     int64_t nStart = S.Frames[S.nFrameCurrent].nFrameStartCpu;
@@ -739,7 +739,7 @@ inline void MicroProfileCenter(int64_t nTickCenter)
 #ifdef MICROPROFILE_DEBUG
 uint64_t* g_pMicroProfileDumpStart = 0;
 uint64_t* g_pMicroProfileDumpEnd = 0;
-inline void MicroProfileDebugDumpRange()
+void MicroProfileDebugDumpRange()
 {
     MicroProfile& S = *MicroProfileGet();
     if(g_pMicroProfileDumpStart != g_pMicroProfileDumpEnd)
@@ -777,7 +777,7 @@ inline void MicroProfileDebugDumpRange()
 
 #define MICROPROFILE_HOVER_DIST 0.5f
 
-inline void MicroProfileDrawDetailedContextSwitchBars(uint32_t nY, uint32_t nThreadId, uint32_t nContextSwitchStart, uint32_t nContextSwitchEnd, int64_t nBaseTicks, uint32_t nBaseY)
+void MicroProfileDrawDetailedContextSwitchBars(uint32_t nY, uint32_t nThreadId, uint32_t nContextSwitchStart, uint32_t nContextSwitchEnd, int64_t nBaseTicks, uint32_t nBaseY)
 {
     MicroProfile& S = *MicroProfileGet();
     int64_t nTickIn = -1;
@@ -841,7 +841,7 @@ inline void MicroProfileDrawDetailedContextSwitchBars(uint32_t nY, uint32_t nThr
     }
 }
 
-inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY, int nSelectedFrame)
+void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int nBaseY, int nSelectedFrame)
 {
     MicroProfile& S = *MicroProfileGet();
     MP_DEBUG_DUMP_RANGE();
@@ -1325,7 +1325,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
 }
 
 
-inline void MicroProfileDrawDetailedFrameHistory(uint32_t nWidth, uint32_t nHeight, uint32_t nBaseY, uint32_t nSelectedFrame)
+void MicroProfileDrawDetailedFrameHistory(uint32_t nWidth, uint32_t nHeight, uint32_t nBaseY, uint32_t nSelectedFrame)
 {
     MicroProfile& S = *MicroProfileGet();
 
@@ -1379,7 +1379,7 @@ inline void MicroProfileDrawDetailedFrameHistory(uint32_t nWidth, uint32_t nHeig
     }
     MicroProfileDrawBox(fSelectionStart, nBaseY, fSelectionEnd, nBaseY+MICROPROFILE_FRAME_HISTORY_HEIGHT, MICROPROFILE_FRAME_HISTORY_COLOR_HIGHTLIGHT, MicroProfileBoxTypeFlat);
 }
-inline void MicroProfileDrawDetailedView(uint32_t nWidth, uint32_t nHeight)
+void MicroProfileDrawDetailedView(uint32_t nWidth, uint32_t nHeight)
 {
     MicroProfile& S = *MicroProfileGet();
 
@@ -1416,11 +1416,11 @@ inline void MicroProfileDrawDetailedView(uint32_t nWidth, uint32_t nHeight)
     MicroProfileDrawDetailedFrameHistory(nWidth, nHeight, nBaseY, nSelectedFrame);
 }
 
-inline void MicroProfileDrawTextRight(uint32_t nX, uint32_t nY, uint32_t nColor, const char* pStr, uint32_t nStrLen)
+void MicroProfileDrawTextRight(uint32_t nX, uint32_t nY, uint32_t nColor, const char* pStr, uint32_t nStrLen)
 {
     MicroProfileDrawText(nX - nStrLen * (MICROPROFILE_TEXT_WIDTH+1), nY, nColor, pStr, nStrLen);
 }
-inline void MicroProfileDrawHeader(int32_t nX, uint32_t nWidth, const char* pName)
+void MicroProfileDrawHeader(int32_t nX, uint32_t nWidth, const char* pName)
 {
     if(pName)
     {
@@ -1432,7 +1432,7 @@ inline void MicroProfileDrawHeader(int32_t nX, uint32_t nWidth, const char* pNam
 
 typedef void (*MicroProfileLoopGroupCallback)(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pData);
 
-inline void MicroProfileLoopActiveGroupsDraw(int32_t nX, int32_t nY, const char* pName, MicroProfileLoopGroupCallback CB, void* pData)
+void MicroProfileLoopActiveGroupsDraw(int32_t nX, int32_t nY, const char* pName, MicroProfileLoopGroupCallback CB, void* pData)
 {
     MicroProfile& S = *MicroProfileGet();
     nY += MICROPROFILE_TEXT_HEIGHT + 2;
@@ -1465,7 +1465,7 @@ inline void MicroProfileLoopActiveGroupsDraw(int32_t nX, int32_t nY, const char*
 }
 
 
-inline void MicroProfileCalcTimers(float* pTimers, float* pAverage, float* pMax, float* pCallAverage, float* pExclusive, float* pAverageExclusive, float* pMaxExclusive, uint64_t nGroup, uint32_t nSize)
+void MicroProfileCalcTimers(float* pTimers, float* pAverage, float* pMax, float* pCallAverage, float* pExclusive, float* pAverageExclusive, float* pMaxExclusive, uint64_t nGroup, uint32_t nSize)
 {
     MicroProfile& S = *MicroProfileGet();
 
@@ -1527,7 +1527,7 @@ inline void MicroProfileCalcTimers(float* pTimers, float* pAverage, float* pMax,
 
 #define SBUF_MAX 32
 
-inline void MicroProfileDrawBarArrayCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
+void MicroProfileDrawBarArrayCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
 {
     const uint32_t nHeight = MICROPROFILE_TEXT_HEIGHT;
     const uint32_t nTextWidth = 6 * (1+MICROPROFILE_TEXT_WIDTH);
@@ -1547,7 +1547,7 @@ inline void MicroProfileDrawBarArrayCallback(uint32_t nTimer, uint32_t nIdx, uin
 }
 
 
-inline uint32_t MicroProfileDrawBarArray(int32_t nX, int32_t nY, float* pTimers, const char* pName, uint32_t nTotalHeight, float* pTimers2 = NULL)
+uint32_t MicroProfileDrawBarArray(int32_t nX, int32_t nY, float* pTimers, const char* pName, uint32_t nTotalHeight, float* pTimers2 = NULL)
 {
     const uint32_t nTextWidth = 6 * (1+MICROPROFILE_TEXT_WIDTH);
     const uint32_t nWidth = MICROPROFILE_BAR_WIDTH;
@@ -1559,7 +1559,7 @@ inline uint32_t MicroProfileDrawBarArray(int32_t nX, int32_t nY, float* pTimers,
     return nWidth + 5 + nTextWidth;
 
 }
-inline void MicroProfileDrawBarCallCountCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
+void MicroProfileDrawBarCallCountCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
 {
     MicroProfile& S = *MicroProfileGet();
     char sBuffer[SBUF_MAX];
@@ -1567,7 +1567,7 @@ inline void MicroProfileDrawBarCallCountCallback(uint32_t nTimer, uint32_t nIdx,
     MicroProfileDrawText(nX, nY, (uint32_t)-1, sBuffer, nLen);
 }
 
-inline uint32_t MicroProfileDrawBarCallCount(int32_t nX, int32_t nY, const char* pName)
+uint32_t MicroProfileDrawBarCallCount(int32_t nX, int32_t nY, const char* pName)
 {
     MicroProfileLoopActiveGroupsDraw(nX, nY, pName, MicroProfileDrawBarCallCountCallback, 0);
     const uint32_t nTextWidth = 6 * MICROPROFILE_TEXT_WIDTH;
@@ -1581,7 +1581,7 @@ struct MicroProfileMetaAverageArgs
     float fRcpFrames;
 };
 
-inline void MicroProfileDrawBarMetaAverageCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
+void MicroProfileDrawBarMetaAverageCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
 {
     MicroProfileMetaAverageArgs* pArgs = (MicroProfileMetaAverageArgs*)pExtra;
     uint64_t* pCounters = pArgs->pCounters;
@@ -1591,7 +1591,7 @@ inline void MicroProfileDrawBarMetaAverageCallback(uint32_t nTimer, uint32_t nId
     MicroProfileDrawText(nX - nLen * (MICROPROFILE_TEXT_WIDTH+1), nY, (uint32_t)-1, sBuffer, nLen);
 }
 
-inline uint32_t MicroProfileDrawBarMetaAverage(int32_t nX, int32_t nY, uint64_t* pCounters, const char* pName, uint32_t nTotalHeight)
+uint32_t MicroProfileDrawBarMetaAverage(int32_t nX, int32_t nY, uint64_t* pCounters, const char* pName, uint32_t nTotalHeight)
 {
     if(!pName)
         return 0;
@@ -1605,7 +1605,7 @@ inline uint32_t MicroProfileDrawBarMetaAverage(int32_t nX, int32_t nY, uint64_t*
 }
 
 
-inline void MicroProfileDrawBarMetaCountCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
+void MicroProfileDrawBarMetaCountCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
 {
     uint64_t* pCounters = (uint64_t*)pExtra;
     char sBuffer[SBUF_MAX];
@@ -1613,7 +1613,7 @@ inline void MicroProfileDrawBarMetaCountCallback(uint32_t nTimer, uint32_t nIdx,
     MicroProfileDrawText(nX - nLen * (MICROPROFILE_TEXT_WIDTH+1), nY, (uint32_t)-1, sBuffer, nLen);
 }
 
-inline uint32_t MicroProfileDrawBarMetaCount(int32_t nX, int32_t nY, uint64_t* pCounters, const char* pName, uint32_t nTotalHeight)
+uint32_t MicroProfileDrawBarMetaCount(int32_t nX, int32_t nY, uint64_t* pCounters, const char* pName, uint32_t nTotalHeight)
 {
     if(!pName)
         return 0;
@@ -1625,7 +1625,7 @@ inline uint32_t MicroProfileDrawBarMetaCount(int32_t nX, int32_t nY, uint64_t* p
     return 5 + nTextWidth;
 }
 
-inline void MicroProfileDrawBarLegendCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
+void MicroProfileDrawBarLegendCallback(uint32_t nTimer, uint32_t nIdx, uint64_t nGroupMask, uint32_t nX, uint32_t nY, void* pExtra)
 {
     MicroProfile& S = *MicroProfileGet();
     if (S.TimerInfo[nTimer].bGraph)
@@ -1640,7 +1640,7 @@ inline void MicroProfileDrawBarLegendCallback(uint32_t nTimer, uint32_t nIdx, ui
     }
 }
 
-inline uint32_t MicroProfileDrawBarLegend(int32_t nX, int32_t nY, uint32_t nTotalHeight, uint32_t nMaxWidth)
+uint32_t MicroProfileDrawBarLegend(int32_t nX, int32_t nY, uint32_t nTotalHeight, uint32_t nMaxWidth)
 {
     MicroProfileDrawLineVertical(nX-5, nY, nTotalHeight, UI.nOpacityBackground | g_nMicroProfileBackColors[0]|g_nMicroProfileBackColors[1]);
     MicroProfileLoopActiveGroupsDraw(nMaxWidth, nY, 0, MicroProfileDrawBarLegendCallback, 0);
@@ -1807,7 +1807,7 @@ void MicroProfileDumpTimers()
     }
 }
 
-inline void MicroProfileDrawBarView(uint32_t nScreenWidth, uint32_t nScreenHeight)
+void MicroProfileDrawBarView(uint32_t nScreenWidth, uint32_t nScreenHeight)
 {
     MicroProfile& S = *MicroProfileGet();
 
@@ -1951,7 +1951,7 @@ typedef const char* (*MicroProfileSubmenuCallback)(int, bool* bSelected);
 typedef void (*MicroProfileClickCallback)(int);
 
 
-inline const char* MicroProfileUIMenuMode(int nIndex, bool* bSelected)
+const char* MicroProfileUIMenuMode(int nIndex, bool* bSelected)
 {
     MicroProfile& S = *MicroProfileGet();
     switch(nIndex)
@@ -1979,7 +1979,7 @@ inline const char* MicroProfileUIMenuMode(int nIndex, bool* bSelected)
     }
 }
 
-inline const char* MicroProfileUIMenuGroups(int nIndex, bool* bSelected)
+const char* MicroProfileUIMenuGroups(int nIndex, bool* bSelected)
 {
     MicroProfile& S = *MicroProfileGet();
     *bSelected = false;
@@ -2012,7 +2012,7 @@ inline const char* MicroProfileUIMenuGroups(int nIndex, bool* bSelected)
     }
 }
 
-inline const char* MicroProfileUIMenuAggregate(int nIndex, bool* bSelected)
+const char* MicroProfileUIMenuAggregate(int nIndex, bool* bSelected)
 {
     MicroProfile& S = *MicroProfileGet();
     if(nIndex < sizeof(g_MicroProfileAggregatePresets)/sizeof(g_MicroProfileAggregatePresets[0]))
@@ -2032,7 +2032,7 @@ inline const char* MicroProfileUIMenuAggregate(int nIndex, bool* bSelected)
 
 }
 
-inline const char* MicroProfileUIMenuTimers(int nIndex, bool* bSelected)
+const char* MicroProfileUIMenuTimers(int nIndex, bool* bSelected)
 {
     MicroProfile& S = *MicroProfileGet();
     *bSelected = 0 != (S.nBars & (1 << nIndex));
@@ -2054,7 +2054,7 @@ inline const char* MicroProfileUIMenuTimers(int nIndex, bool* bSelected)
     return 0;
 }
 
-inline const char* MicroProfileUIMenuOptions(int nIndex, bool* bSelected)
+const char* MicroProfileUIMenuOptions(int nIndex, bool* bSelected)
 {
     MicroProfile& S = *MicroProfileGet();
     if(nIndex >= MICROPROFILE_OPTION_SIZE) return 0;
@@ -2094,7 +2094,7 @@ inline const char* MicroProfileUIMenuOptions(int nIndex, bool* bSelected)
     return UI.Options[nIndex].Text;
 }
 
-inline const char* MicroProfileUIMenuPreset(int nIndex, bool* bSelected)
+const char* MicroProfileUIMenuPreset(int nIndex, bool* bSelected)
 {
     static char buf[128];
     *bSelected = false;
@@ -2118,7 +2118,7 @@ inline const char* MicroProfileUIMenuPreset(int nIndex, bool* bSelected)
     }
 }
 
-inline const char* MicroProfileUIMenuCustom(int nIndex, bool* bSelected)
+const char* MicroProfileUIMenuCustom(int nIndex, bool* bSelected)
 {
     if((uint32_t)-1 == UI.nCustomActive)
     {
@@ -2145,13 +2145,13 @@ inline const char* MicroProfileUIMenuCustom(int nIndex, bool* bSelected)
     }
 }
 
-inline const char* MicroProfileUIMenuEmpty(int nIndex, bool* bSelected)
+const char* MicroProfileUIMenuEmpty(int nIndex, bool* bSelected)
 {
     return 0;
 }
 
 
-inline void MicroProfileUIClickMode(int nIndex)
+void MicroProfileUIClickMode(int nIndex)
 {
     MicroProfile& S = *MicroProfileGet();
     switch(nIndex)
@@ -2176,7 +2176,7 @@ inline void MicroProfileUIClickMode(int nIndex)
     }
 }
 
-inline void MicroProfileUIClickGroups(int nIndex)
+void MicroProfileUIClickGroups(int nIndex)
 {
     MicroProfile& S = *MicroProfileGet();
     if(nIndex == 0)
@@ -2208,7 +2208,7 @@ inline void MicroProfileUIClickGroups(int nIndex)
     }
 }
 
-inline void MicroProfileUIClickAggregate(int nIndex)
+void MicroProfileUIClickAggregate(int nIndex)
 {
     MicroProfile& S = *MicroProfileGet();
     S.nAggregateFlip = g_MicroProfileAggregatePresets[nIndex];
@@ -2218,13 +2218,13 @@ inline void MicroProfileUIClickAggregate(int nIndex)
     }
 }
 
-inline void MicroProfileUIClickTimers(int nIndex)
+void MicroProfileUIClickTimers(int nIndex)
 {
     MicroProfile& S = *MicroProfileGet();
     S.nBars ^= (1 << nIndex);
 }
 
-inline void MicroProfileUIClickOptions(int nIndex)
+void MicroProfileUIClickOptions(int nIndex)
 {
     MicroProfile& S = *MicroProfileGet();
     switch(UI.Options[nIndex].nSubType)
@@ -2271,7 +2271,7 @@ inline void MicroProfileUIClickOptions(int nIndex)
     }
 }
 
-inline void MicroProfileUIClickPreset(int nIndex)
+void MicroProfileUIClickPreset(int nIndex)
 {
     int nNumPresets = sizeof(g_MicroProfilePresetNames) / sizeof(g_MicroProfilePresetNames[0]);
     int nIndexSave = nIndex - nNumPresets - 1;
@@ -2285,7 +2285,7 @@ inline void MicroProfileUIClickPreset(int nIndex)
     }
 }
 
-inline void MicroProfileUIClickCustom(int nIndex)
+void MicroProfileUIClickCustom(int nIndex)
 {
     if(nIndex == 0)
     {
@@ -2298,13 +2298,13 @@ inline void MicroProfileUIClickCustom(int nIndex)
 
 }
 
-inline void MicroProfileUIClickEmpty(int nIndex)
+void MicroProfileUIClickEmpty(int nIndex)
 {
 
 }
 
 
-inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
+void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
 {
     MicroProfile& S = *MicroProfileGet();
 
@@ -2489,7 +2489,7 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
 }
 
 
-inline void MicroProfileMoveGraph()
+void MicroProfileMoveGraph()
 {
 
     int nZoom = UI.nMouseWheelDelta;
@@ -2536,7 +2536,7 @@ inline void MicroProfileMoveGraph()
         UI.nOffsetY = 0;
 }
 
-inline void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
+void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
 {
     if((uint32_t)-1 != UI.nCustomActive)
     {
@@ -2633,7 +2633,7 @@ inline void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
         }
     }
 }
-inline void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
+void MicroProfileDraw(uint32_t nWidth, uint32_t nHeight)
 {
     MICROPROFILE_SCOPE(g_MicroProfileDraw);
     MicroProfile& S = *MicroProfileGet();
@@ -3226,7 +3226,7 @@ void MicroProfileLoadPreset(const char* pSuffix)
     }
 }
 
-inline uint32_t MicroProfileCustomGroupFind(const char* pCustomName)
+uint32_t MicroProfileCustomGroupFind(const char* pCustomName)
 {
     for(uint32_t i = 0; i < UI.nCustomCount; ++i)
     {
@@ -3238,7 +3238,7 @@ inline uint32_t MicroProfileCustomGroupFind(const char* pCustomName)
     return (uint32_t)-1;
 }
 
-inline uint32_t MicroProfileCustomGroup(const char* pCustomName)
+uint32_t MicroProfileCustomGroup(const char* pCustomName)
 {
     for(uint32_t i = 0; i < UI.nCustomCount; ++i)
     {
@@ -3271,7 +3271,7 @@ void MicroProfileCustomGroup(const char* pCustomName, uint32_t nMaxTimers, uint3
     UI.Custom[nIndex].nAggregateFlip = nAggregateFlip;
 }
 
-inline void MicroProfileCustomGroupEnable(uint32_t nIndex)
+void MicroProfileCustomGroupEnable(uint32_t nIndex)
 {
     if(nIndex < UI.nCustomCount)
     {

externals/opus/CMakeLists.txt

@@ -0,0 +1,250 @@
+cmake_minimum_required(VERSION 3.8)
+
+project(opus)
+
+option(OPUS_STACK_PROTECTOR "Use stack protection" OFF)
+option(OPUS_USE_ALLOCA "Use alloca for stack arrays (on non-C99 compilers)" OFF)
+option(OPUS_CUSTOM_MODES "Enable non-Opus modes, e.g. 44.1 kHz & 2^n frames" OFF)
+option(OPUS_FIXED_POINT "Compile as fixed-point (for machines without a fast enough FPU)" OFF)
+option(OPUS_ENABLE_FLOAT_API "Compile with the floating point API (for machines with float library" ON)
+
+include(opus/opus_functions.cmake)
+
+if(OPUS_STACK_PROTECTOR)
+    if(NOT MSVC) # GC on by default on MSVC
+        check_and_set_flag(STACK_PROTECTION_STRONG -fstack-protector-strong)
+    endif()
+else()
+    if(MSVC)
+        check_and_set_flag(BUFFER_SECURITY_CHECK /GS-)
+    endif()
+endif()
+
+add_library(opus STATIC
+    # CELT sources
+    opus/celt/bands.c
+    opus/celt/celt.c
+    opus/celt/celt_decoder.c
+    opus/celt/celt_encoder.c
+    opus/celt/celt_lpc.c
+    opus/celt/cwrs.c
+    opus/celt/entcode.c
+    opus/celt/entdec.c
+    opus/celt/entenc.c
+    opus/celt/kiss_fft.c
+    opus/celt/laplace.c
+    opus/celt/mathops.c
+    opus/celt/mdct.c
+    opus/celt/modes.c
+    opus/celt/pitch.c
+    opus/celt/quant_bands.c
+    opus/celt/rate.c
+    opus/celt/vq.c
+
+    # SILK sources
+    opus/silk/A2NLSF.c
+    opus/silk/CNG.c
+    opus/silk/HP_variable_cutoff.c
+    opus/silk/LPC_analysis_filter.c
+    opus/silk/LPC_fit.c
+    opus/silk/LPC_inv_pred_gain.c
+    opus/silk/LP_variable_cutoff.c
+    opus/silk/NLSF2A.c
+    opus/silk/NLSF_VQ.c
+    opus/silk/NLSF_VQ_weights_laroia.c
+    opus/silk/NLSF_decode.c
+    opus/silk/NLSF_del_dec_quant.c
+    opus/silk/NLSF_encode.c
+    opus/silk/NLSF_stabilize.c
+    opus/silk/NLSF_unpack.c
+    opus/silk/NSQ.c
+    opus/silk/NSQ_del_dec.c
+    opus/silk/PLC.c
+    opus/silk/VAD.c
+    opus/silk/VQ_WMat_EC.c
+    opus/silk/ana_filt_bank_1.c
+    opus/silk/biquad_alt.c
+    opus/silk/bwexpander.c
+    opus/silk/bwexpander_32.c
+    opus/silk/check_control_input.c
+    opus/silk/code_signs.c
+    opus/silk/control_SNR.c
+    opus/silk/control_audio_bandwidth.c
+    opus/silk/control_codec.c
+    opus/silk/dec_API.c
+    opus/silk/decode_core.c
+    opus/silk/decode_frame.c
+    opus/silk/decode_indices.c
+    opus/silk/decode_parameters.c
+    opus/silk/decode_pitch.c
+    opus/silk/decode_pulses.c
+    opus/silk/decoder_set_fs.c
+    opus/silk/enc_API.c
+    opus/silk/encode_indices.c
+    opus/silk/encode_pulses.c
+    opus/silk/gain_quant.c
+    opus/silk/init_decoder.c
+    opus/silk/init_encoder.c
+    opus/silk/inner_prod_aligned.c
+    opus/silk/interpolate.c
+    opus/silk/lin2log.c
+    opus/silk/log2lin.c
+    opus/silk/pitch_est_tables.c
+    opus/silk/process_NLSFs.c
+    opus/silk/quant_LTP_gains.c
+    opus/silk/resampler.c
+    opus/silk/resampler_down2.c
+    opus/silk/resampler_down2_3.c
+    opus/silk/resampler_private_AR2.c
+    opus/silk/resampler_private_IIR_FIR.c
+    opus/silk/resampler_private_down_FIR.c
+    opus/silk/resampler_private_up2_HQ.c
+    opus/silk/resampler_rom.c
+    opus/silk/shell_coder.c
+    opus/silk/sigm_Q15.c
+    opus/silk/sort.c
+    opus/silk/stereo_LR_to_MS.c
+    opus/silk/stereo_MS_to_LR.c
+    opus/silk/stereo_decode_pred.c
+    opus/silk/stereo_encode_pred.c
+    opus/silk/stereo_find_predictor.c
+    opus/silk/stereo_quant_pred.c
+    opus/silk/sum_sqr_shift.c
+    opus/silk/table_LSF_cos.c
+    opus/silk/tables_LTP.c
+    opus/silk/tables_NLSF_CB_NB_MB.c
+    opus/silk/tables_NLSF_CB_WB.c
+    opus/silk/tables_gain.c
+    opus/silk/tables_other.c
+    opus/silk/tables_pitch_lag.c
+    opus/silk/tables_pulses_per_block.c
+
+    # Opus sources
+    opus/src/analysis.c
+    opus/src/mapping_matrix.c
+    opus/src/mlp.c
+    opus/src/mlp_data.c
+    opus/src/opus.c
+    opus/src/opus_decoder.c
+    opus/src/opus_encoder.c
+    opus/src/opus_multistream.c
+    opus/src/opus_multistream_decoder.c
+    opus/src/opus_multistream_encoder.c
+    opus/src/opus_projection_decoder.c
+    opus/src/opus_projection_encoder.c
+    opus/src/repacketizer.c
+)
+
+if (DEBUG)
+    target_sources(opus PRIVATE opus/silk/debug.c)
+endif()
+
+if (OPUS_FIXED_POINT)
+    target_sources(opus PRIVATE
+        opus/silk/fixed/LTP_analysis_filter_FIX.c
+        opus/silk/fixed/LTP_scale_ctrl_FIX.c
+        opus/silk/fixed/apply_sine_window_FIX.c
+        opus/silk/fixed/autocorr_FIX.c
+        opus/silk/fixed/burg_modified_FIX.c
+        opus/silk/fixed/corrMatrix_FIX.c
+        opus/silk/fixed/encode_frame_FIX.c
+        opus/silk/fixed/find_LPC_FIX.c
+        opus/silk/fixed/find_LTP_FIX.c
+        opus/silk/fixed/find_pitch_lags_FIX.c
+        opus/silk/fixed/find_pred_coefs_FIX.c
+        opus/silk/fixed/k2a_FIX.c
+        opus/silk/fixed/k2a_Q16_FIX.c
+        opus/silk/fixed/noise_shape_analysis_FIX.c
+        opus/silk/fixed/pitch_analysis_core_FIX.c
+        opus/silk/fixed/prefilter_FIX.c
+        opus/silk/fixed/process_gains_FIX.c
+        opus/silk/fixed/regularize_correlations_FIX.c
+        opus/silk/fixed/residual_energy16_FIX.c
+        opus/silk/fixed/residual_energy_FIX.c
+        opus/silk/fixed/schur64_FIX.c
+        opus/silk/fixed/schur_FIX.c
+        opus/silk/fixed/solve_LS_FIX.c
+        opus/silk/fixed/vector_ops_FIX.c
+        opus/silk/fixed/warped_autocorrelation_FIX.c
+    )
+else()
+    target_sources(opus PRIVATE
+        opus/silk/float/LPC_analysis_filter_FLP.c
+        opus/silk/float/LPC_inv_pred_gain_FLP.c
+        opus/silk/float/LTP_analysis_filter_FLP.c
+        opus/silk/float/LTP_scale_ctrl_FLP.c
+        opus/silk/float/apply_sine_window_FLP.c
+        opus/silk/float/autocorrelation_FLP.c
+        opus/silk/float/burg_modified_FLP.c
+        opus/silk/float/bwexpander_FLP.c
+        opus/silk/float/corrMatrix_FLP.c
+        opus/silk/float/encode_frame_FLP.c
+        opus/silk/float/energy_FLP.c
+        opus/silk/float/find_LPC_FLP.c
+        opus/silk/float/find_LTP_FLP.c
+        opus/silk/float/find_pitch_lags_FLP.c
+        opus/silk/float/find_pred_coefs_FLP.c
+        opus/silk/float/inner_product_FLP.c
+        opus/silk/float/k2a_FLP.c
+        opus/silk/float/noise_shape_analysis_FLP.c
+        opus/silk/float/pitch_analysis_core_FLP.c
+        opus/silk/float/process_gains_FLP.c
+        opus/silk/float/regularize_correlations_FLP.c
+        opus/silk/float/residual_energy_FLP.c
+        opus/silk/float/scale_copy_vector_FLP.c
+        opus/silk/float/scale_vector_FLP.c
+        opus/silk/float/schur_FLP.c
+        opus/silk/float/sort_FLP.c
+        opus/silk/float/warped_autocorrelation_FLP.c
+        opus/silk/float/wrappers_FLP.c
+    )
+endif()
+
+target_compile_definitions(opus PRIVATE OPUS_BUILD ENABLE_HARDENING)
+
+if(NOT MSVC)
+    target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=2)
+endif()
+
+# It is strongly recommended to uncomment one of these VAR_ARRAYS: Use C99
+# variable-length arrays for stack allocation USE_ALLOCA: Use alloca() for stack
+# allocation If none is defined, then the fallback is a non-threadsafe global
+# array
+if(OPUS_USE_ALLOCA OR MSVC)
+    target_compile_definitions(opus PRIVATE USE_ALLOCA)
+else()
+    target_compile_definitions(opus PRIVATE VAR_ARRAYS)
+endif()
+
+if(OPUS_CUSTOM_MODES)
+    target_compile_definitions(opus PRIVATE CUSTOM_MODES)
+endif()
+
+if(NOT OPUS_ENABLE_FLOAT_API)
+    target_compile_definitions(opus PRIVATE DISABLE_FLOAT_API)
+endif()
+
+target_compile_definitions(opus
+PUBLIC
+    -DOPUS_VERSION="\\"1.3.1\\""
+
+PRIVATE
+    # Use C99 intrinsics to speed up float-to-int conversion
+    HAVE_LRINTF
+)
+
+if (FIXED_POINT)
+    target_compile_definitions(opus PRIVATE -DFIXED_POINT=1 -DDISABLE_FLOAT_API)
+endif()
+
+target_include_directories(opus
+PUBLIC
+    opus/include
+
+PRIVATE
+    opus/celt
+    opus/silk
+    opus/silk/fixed
+    opus/silk/float
+    opus/src
+)

externals/zlib/CMakeLists.txt

@@ -0,0 +1,81 @@
+project(zlib C)
+
+include(CheckTypeSize)
+include(CheckFunctionExists)
+include(CheckIncludeFile)
+
+check_include_file(sys/types.h HAVE_SYS_TYPES_H)
+check_include_file(stdint.h    HAVE_STDINT_H)
+check_include_file(stddef.h    HAVE_STDDEF_H)
+
+# Check to see if we have large file support
+set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1)
+# We add these other definitions here because CheckTypeSize.cmake
+# in CMake 2.4.x does not automatically do so and we want
+# compatibility with CMake 2.4.x.
+if(HAVE_SYS_TYPES_H)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H)
+endif()
+if(HAVE_STDINT_H)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H)
+endif()
+if(HAVE_STDDEF_H)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H)
+endif()
+check_type_size(off64_t OFF64_T)
+if(HAVE_OFF64_T)
+   add_definitions(-D_LARGEFILE64_SOURCE=1)
+endif()
+set(CMAKE_REQUIRED_DEFINITIONS) # clear variable
+
+# Check for fseeko
+check_function_exists(fseeko HAVE_FSEEKO)
+if(NOT HAVE_FSEEKO)
+    add_definitions(-DNO_FSEEKO)
+endif()
+
+# Check for unistd.h
+check_include_file(unistd.h HAVE_UNISTD_H)
+if(HAVE_UNISTD_H)
+    add_definitions(-DHAVE_UNISTD_H)
+endif()
+
+if(MSVC)
+    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
+    add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
+endif()
+
+add_library(z STATIC
+    zlib/adler32.c
+    zlib/compress.c
+    zlib/crc32.c
+    zlib/crc32.h
+    zlib/deflate.c
+    zlib/deflate.h
+    zlib/gzclose.c
+    zlib/gzguts.h
+    zlib/gzlib.c
+    zlib/gzread.c
+    zlib/gzwrite.c
+    zlib/inffast.h
+    zlib/inffixed.h
+    zlib/inflate.c
+    zlib/inflate.h
+    zlib/infback.c
+    zlib/inftrees.c
+    zlib/inftrees.h
+    zlib/inffast.c
+    zlib/trees.c
+    zlib/trees.h
+    zlib/uncompr.c
+    zlib/zconf.h
+    zlib/zlib.h
+    zlib/zutil.c
+    zlib/zutil.h
+)
+add_library(ZLIB::ZLIB ALIAS z)
+
+target_include_directories(z
+PUBLIC
+    zlib/
+)

src/CMakeLists.txt

@@ -54,10 +54,8 @@ else()
     add_compile_options(
         -Wall
         -Werror=implicit-fallthrough
-        -Werror=missing-declarations
         -Werror=reorder
         -Wextra
-        -Wmissing-declarations
         -Wno-attributes
         -Wno-unused-parameter
     )

src/audio_core/CMakeLists.txt

@@ -7,12 +7,9 @@ add_library(audio_core STATIC
     audio_out.h
     audio_renderer.cpp
     audio_renderer.h
-    behavior_info.cpp
-    behavior_info.h
     buffer.h
     codec.cpp
     codec.h
-    common.h
     null_sink.h
     sink.h
     sink_details.cpp

src/audio_core/audio_renderer.cpp

@@ -6,7 +6,6 @@
 #include "audio_core/audio_out.h"
 #include "audio_core/audio_renderer.h"
 #include "audio_core/codec.h"
-#include "audio_core/common.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
@@ -17,7 +16,7 @@ namespace AudioCore {
 
 constexpr u32 STREAM_SAMPLE_RATE{48000};
 constexpr u32 STREAM_NUM_CHANNELS{2};
-using VoiceChannelHolder = std::array<VoiceResourceInformation*, 6>;
+
 class AudioRenderer::VoiceState {
 public:
     bool IsPlaying() const {
@@ -37,10 +36,9 @@ public:
     }
 
     void SetWaveIndex(std::size_t index);
-    std::vector<s16> DequeueSamples(std::size_t sample_count, Core::Memory::Memory& memory,
-                                    const VoiceChannelHolder& voice_resources);
+    std::vector<s16> DequeueSamples(std::size_t sample_count, Core::Memory::Memory& memory);
     void UpdateState();
-    void RefreshBuffer(Core::Memory::Memory& memory, const VoiceChannelHolder& voice_resources);
+    void RefreshBuffer(Core::Memory::Memory& memory);
 
 private:
     bool is_in_use{};
@@ -80,8 +78,8 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory
                              std::shared_ptr<Kernel::WritableEvent> buffer_event,
                              std::size_t instance_number)
     : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
-      voice_resources(params.voice_count), effects(params.effect_count), memory{memory_} {
-    behavior_info.SetUserRevision(params.revision);
+      effects(params.effect_count), memory{memory_} {
+
     audio_out = std::make_unique<AudioCore::AudioOut>();
     stream = audio_out->OpenStream(core_timing, STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS,
                                    fmt::format("AudioRenderer-Instance{}", instance_number),
@@ -111,29 +109,23 @@ Stream::State AudioRenderer::GetStreamState() const {
     return stream->GetState();
 }
 
-ResultVal<std::vector<u8>> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params) {
+static constexpr u32 VersionFromRevision(u32_le rev) {
+    // "REV7" -> 7
+    return ((rev >> 24) & 0xff) - 0x30;
+}
+
+std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params) {
     // Copy UpdateDataHeader struct
     UpdateDataHeader config{};
     std::memcpy(&config, input_params.data(), sizeof(UpdateDataHeader));
     u32 memory_pool_count = worker_params.effect_count + (worker_params.voice_count * 4);
 
-    if (!behavior_info.UpdateInput(input_params, sizeof(UpdateDataHeader))) {
-        LOG_ERROR(Audio, "Failed to update behavior info input parameters");
-        return Audren::ERR_INVALID_PARAMETERS;
-    }
-
     // Copy MemoryPoolInfo structs
     std::vector<MemoryPoolInfo> mem_pool_info(memory_pool_count);
     std::memcpy(mem_pool_info.data(),
                 input_params.data() + sizeof(UpdateDataHeader) + config.behavior_size,
                 memory_pool_count * sizeof(MemoryPoolInfo));
 
-    // Copy voice resources
-    const std::size_t voice_resource_offset{sizeof(UpdateDataHeader) + config.behavior_size +
-                                            config.memory_pools_size};
-    std::memcpy(voice_resources.data(), input_params.data() + voice_resource_offset,
-                sizeof(VoiceResourceInformation) * voice_resources.size());
-
     // Copy VoiceInfo structs
     std::size_t voice_offset{sizeof(UpdateDataHeader) + config.behavior_size +
                              config.memory_pools_size + config.voice_resource_size};
@@ -180,12 +172,12 @@ ResultVal<std::vector<u8>> AudioRenderer::UpdateAudioRenderer(const std::vector<
 
     // Copy output header
     UpdateDataHeader response_data{worker_params};
-    if (behavior_info.IsElapsedFrameCountSupported()) {
-        response_data.render_info = sizeof(RendererInfo);
-        response_data.total_size += sizeof(RendererInfo);
-    }
-
     std::vector<u8> output_params(response_data.total_size);
+    const auto audren_revision = VersionFromRevision(config.revision);
+    if (audren_revision >= 5) {
+        response_data.frame_count = 0x10;
+        response_data.total_size += 0x10;
+    }
     std::memcpy(output_params.data(), &response_data, sizeof(UpdateDataHeader));
 
     // Copy output memory pool entries
@@ -208,30 +200,7 @@ ResultVal<std::vector<u8>> AudioRenderer::UpdateAudioRenderer(const std::vector<
                     sizeof(EffectOutStatus));
         effect_out_status_offset += sizeof(EffectOutStatus);
     }
-
-    // Update behavior info output
-    const std::size_t behavior_out_status_offset{
-        sizeof(UpdateDataHeader) + response_data.memory_pools_size + response_data.voices_size +
-        response_data.effects_size + response_data.sinks_size +
-        response_data.performance_manager_size};
-
-    if (!behavior_info.UpdateOutput(output_params, behavior_out_status_offset)) {
-        LOG_ERROR(Audio, "Failed to update behavior info output parameters");
-        return Audren::ERR_INVALID_PARAMETERS;
-    }
-
-    if (behavior_info.IsElapsedFrameCountSupported()) {
-        const std::size_t renderer_info_offset{
-            sizeof(UpdateDataHeader) + response_data.memory_pools_size + response_data.voices_size +
-            response_data.effects_size + response_data.sinks_size +
-            response_data.performance_manager_size + response_data.behavior_size};
-        RendererInfo renderer_info{};
-        renderer_info.elasped_frame_count = elapsed_frame_count;
-        std::memcpy(output_params.data() + renderer_info_offset, &renderer_info,
-                    sizeof(RendererInfo));
-    }
-
-    return MakeResult(output_params);
+    return output_params;
 }
 
 void AudioRenderer::VoiceState::SetWaveIndex(std::size_t index) {
@@ -239,15 +208,14 @@ void AudioRenderer::VoiceState::SetWaveIndex(std::size_t index) {
     is_refresh_pending = true;
 }
 
-std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(
-    std::size_t sample_count, Core::Memory::Memory& memory,
-    const VoiceChannelHolder& voice_resources) {
+std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(std::size_t sample_count,
+                                                           Core::Memory::Memory& memory) {
     if (!IsPlaying()) {
         return {};
     }
 
     if (is_refresh_pending) {
-        RefreshBuffer(memory, voice_resources);
+        RefreshBuffer(memory);
     }
 
     const std::size_t max_size{samples.size() - offset};
@@ -291,8 +259,7 @@ void AudioRenderer::VoiceState::UpdateState() {
     is_in_use = info.is_in_use;
 }
 
-void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory,
-                                              const VoiceChannelHolder& voice_resources) {
+void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory) {
     const auto wave_buffer_address = info.wave_buffer[wave_index].buffer_addr;
     const auto wave_buffer_size = info.wave_buffer[wave_index].buffer_sz;
     std::vector<s16> new_samples(wave_buffer_size / sizeof(s16));
@@ -317,77 +284,17 @@ void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory,
     }
 
     switch (info.channel_count) {
-    case 1: {
+    case 1:
         // 1 channel is upsampled to 2 channel
         samples.resize(new_samples.size() * 2);
-
         for (std::size_t index = 0; index < new_samples.size(); ++index) {
-            auto sample = static_cast<float>(new_samples[index]);
-            if (voice_resources[0]->in_use) {
-                sample *= voice_resources[0]->mix_volumes[0];
-            }
-
-            samples[index * 2] = static_cast<s16>(sample * info.volume);
-            samples[index * 2 + 1] = static_cast<s16>(sample * info.volume);
+            samples[index * 2] = new_samples[index];
+            samples[index * 2 + 1] = new_samples[index];
         }
         break;
-    }
     case 2: {
         // 2 channel is played as is
         samples = std::move(new_samples);
-        const std::size_t sample_count = (samples.size() / 2);
-        for (std::size_t index = 0; index < sample_count; ++index) {
-            const std::size_t index_l = index * 2;
-            const std::size_t index_r = index * 2 + 1;
-
-            auto sample_l = static_cast<float>(samples[index_l]);
-            auto sample_r = static_cast<float>(samples[index_r]);
-
-            if (voice_resources[0]->in_use) {
-                sample_l *= voice_resources[0]->mix_volumes[0];
-            }
-
-            if (voice_resources[1]->in_use) {
-                sample_r *= voice_resources[1]->mix_volumes[1];
-            }
-
-            samples[index_l] = static_cast<s16>(sample_l * info.volume);
-            samples[index_r] = static_cast<s16>(sample_r * info.volume);
-        }
-        break;
-    }
-    case 6: {
-        samples.resize((new_samples.size() / 6) * 2);
-        const std::size_t sample_count = samples.size() / 2;
-
-        for (std::size_t index = 0; index < sample_count; ++index) {
-            auto FL = static_cast<float>(new_samples[index * 6]);
-            auto FR = static_cast<float>(new_samples[index * 6 + 1]);
-            auto FC = static_cast<float>(new_samples[index * 6 + 2]);
-            auto BL = static_cast<float>(new_samples[index * 6 + 4]);
-            auto BR = static_cast<float>(new_samples[index * 6 + 5]);
-
-            if (voice_resources[0]->in_use) {
-                FL *= voice_resources[0]->mix_volumes[0];
-            }
-            if (voice_resources[1]->in_use) {
-                FR *= voice_resources[1]->mix_volumes[1];
-            }
-            if (voice_resources[2]->in_use) {
-                FC *= voice_resources[2]->mix_volumes[2];
-            }
-            if (voice_resources[4]->in_use) {
-                BL *= voice_resources[4]->mix_volumes[4];
-            }
-            if (voice_resources[5]->in_use) {
-                BR *= voice_resources[5]->mix_volumes[5];
-            }
-
-            samples[index * 2] =
-                static_cast<s16>((0.3694f * FL + 0.2612f * FC + 0.3694f * BL) * info.volume);
-            samples[index * 2 + 1] =
-                static_cast<s16>((0.3694f * FR + 0.2612f * FC + 0.3694f * BR) * info.volume);
-        }
         break;
     }
     default:
@@ -433,17 +340,11 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
         if (!voice.IsPlaying()) {
             continue;
         }
-        VoiceChannelHolder resources{};
-        for (u32 channel = 0; channel < voice.GetInfo().channel_count; channel++) {
-            const auto channel_resource_id = voice.GetInfo().voice_channel_resource_ids[channel];
-            resources[channel] = &voice_resources[channel_resource_id];
-        }
 
         std::size_t offset{};
         s64 samples_remaining{BUFFER_SIZE};
         while (samples_remaining > 0) {
-            const std::vector<s16> samples{
-                voice.DequeueSamples(samples_remaining, memory, resources)};
+            const std::vector<s16> samples{voice.DequeueSamples(samples_remaining, memory)};
 
             if (samples.empty()) {
                 break;
@@ -459,7 +360,6 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
         }
     }
     audio_out->QueueBuffer(stream, tag, std::move(buffer));
-    elapsed_frame_count++;
 }
 
 void AudioRenderer::ReleaseAndQueueBuffers() {

src/audio_core/audio_renderer.h

@@ -8,14 +8,11 @@
 #include <memory>
 #include <vector>
 
-#include "audio_core/behavior_info.h"
-#include "audio_core/common.h"
 #include "audio_core/stream.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/kernel/object.h"
-#include "core/hle/result.h"
 
 namespace Core::Timing {
 class CoreTiming;
@@ -117,14 +114,6 @@ struct WaveBuffer {
 };
 static_assert(sizeof(WaveBuffer) == 0x38, "WaveBuffer has wrong size");
 
-struct VoiceResourceInformation {
-    s32_le id{};
-    std::array<float_le, MAX_MIX_BUFFERS> mix_volumes{};
-    bool in_use{};
-    INSERT_PADDING_BYTES(11);
-};
-static_assert(sizeof(VoiceResourceInformation) == 0x70, "VoiceResourceInformation has wrong size");
-
 struct VoiceInfo {
     u32_le id;
     u32_le node_id;
@@ -196,12 +185,6 @@ struct EffectOutStatus {
 };
 static_assert(sizeof(EffectOutStatus) == 0x10, "EffectOutStatus is an invalid size");
 
-struct RendererInfo {
-    u64_le elasped_frame_count{};
-    INSERT_PADDING_WORDS(2);
-};
-static_assert(sizeof(RendererInfo) == 0x10, "RendererInfo is an invalid size");
-
 struct UpdateDataHeader {
     UpdateDataHeader() {}
 
@@ -215,7 +198,7 @@ struct UpdateDataHeader {
         mixes_size = 0x0;
         sinks_size = config.sink_count * 0x20;
         performance_manager_size = 0x10;
-        render_info = 0;
+        frame_count = 0;
         total_size = sizeof(UpdateDataHeader) + behavior_size + memory_pools_size + voices_size +
                      effects_size + sinks_size + performance_manager_size;
     }
@@ -229,8 +212,8 @@ struct UpdateDataHeader {
     u32_le mixes_size{};
     u32_le sinks_size{};
     u32_le performance_manager_size{};
-    u32_le splitter_size{};
-    u32_le render_info{};
+    INSERT_PADDING_WORDS(1);
+    u32_le frame_count{};
     INSERT_PADDING_WORDS(4);
     u32_le total_size{};
 };
@@ -243,7 +226,7 @@ public:
                   std::shared_ptr<Kernel::WritableEvent> buffer_event, std::size_t instance_number);
     ~AudioRenderer();
 
-    ResultVal<std::vector<u8>> UpdateAudioRenderer(const std::vector<u8>& input_params);
+    std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);
     void QueueMixedBuffer(Buffer::Tag tag);
     void ReleaseAndQueueBuffers();
     u32 GetSampleRate() const;
@@ -254,17 +237,14 @@ public:
 private:
     class EffectState;
     class VoiceState;
-    BehaviorInfo behavior_info{};
 
     AudioRendererParameter worker_params;
     std::shared_ptr<Kernel::WritableEvent> buffer_event;
     std::vector<VoiceState> voices;
-    std::vector<VoiceResourceInformation> voice_resources;
     std::vector<EffectState> effects;
     std::unique_ptr<AudioOut> audio_out;
     StreamPtr stream;
     Core::Memory::Memory& memory;
-    std::size_t elapsed_frame_count{};
 };
 
 } // namespace AudioCore

src/audio_core/behavior_info.cpp

@@ -1,100 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "audio_core/behavior_info.h"
-#include "audio_core/common.h"
-#include "common/logging/log.h"
-
-namespace AudioCore {
-
-BehaviorInfo::BehaviorInfo() : process_revision(CURRENT_PROCESS_REVISION) {}
-BehaviorInfo::~BehaviorInfo() = default;
-
-bool BehaviorInfo::UpdateInput(const std::vector<u8>& buffer, std::size_t offset) {
-    if (!CanConsumeBuffer(buffer.size(), offset, sizeof(InParams))) {
-        LOG_ERROR(Audio, "Buffer is an invalid size!");
-        return false;
-    }
-    InParams params{};
-    std::memcpy(&params, buffer.data() + offset, sizeof(InParams));
-
-    if (!IsValidRevision(params.revision)) {
-        LOG_ERROR(Audio, "Invalid input revision, revision=0x{:08X}", params.revision);
-        return false;
-    }
-
-    if (user_revision != params.revision) {
-        LOG_ERROR(Audio,
-                  "User revision differs from input revision, expecting 0x{:08X} but got 0x{:08X}",
-                  user_revision, params.revision);
-        return false;
-    }
-
-    ClearError();
-    UpdateFlags(params.flags);
-
-    // TODO(ogniK): Check input params size when InfoUpdater is used
-
-    return true;
-}
-
-bool BehaviorInfo::UpdateOutput(std::vector<u8>& buffer, std::size_t offset) {
-    if (!CanConsumeBuffer(buffer.size(), offset, sizeof(OutParams))) {
-        LOG_ERROR(Audio, "Buffer is an invalid size!");
-        return false;
-    }
-
-    OutParams params{};
-    std::memcpy(params.errors.data(), errors.data(), sizeof(ErrorInfo) * errors.size());
-    params.error_count = static_cast<u32_le>(error_count);
-    std::memcpy(buffer.data() + offset, &params, sizeof(OutParams));
-    return true;
-}
-
-void BehaviorInfo::ClearError() {
-    error_count = 0;
-}
-
-void BehaviorInfo::UpdateFlags(u64_le dest_flags) {
-    flags = dest_flags;
-}
-
-void BehaviorInfo::SetUserRevision(u32_le revision) {
-    user_revision = revision;
-}
-
-bool BehaviorInfo::IsAdpcmLoopContextBugFixed() const {
-    return IsRevisionSupported(2, user_revision);
-}
-
-bool BehaviorInfo::IsSplitterSupported() const {
-    return IsRevisionSupported(2, user_revision);
-}
-
-bool BehaviorInfo::IsLongSizePreDelaySupported() const {
-    return IsRevisionSupported(3, user_revision);
-}
-
-bool BehaviorInfo::IsAudioRenererProcessingTimeLimit80PercentSupported() const {
-    return IsRevisionSupported(5, user_revision);
-}
-
-bool BehaviorInfo::IsAudioRenererProcessingTimeLimit75PercentSupported() const {
-    return IsRevisionSupported(4, user_revision);
-}
-
-bool BehaviorInfo::IsAudioRenererProcessingTimeLimit70PercentSupported() const {
-    return IsRevisionSupported(1, user_revision);
-}
-
-bool BehaviorInfo::IsElapsedFrameCountSupported() const {
-    return IsRevisionSupported(5, user_revision);
-}
-
-bool BehaviorInfo::IsMemoryPoolForceMappingEnabled() const {
-    return (flags & 1) != 0;
-}
-
-} // namespace AudioCore

src/audio_core/behavior_info.h

@@ -1,66 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-#include <vector>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-
-namespace AudioCore {
-class BehaviorInfo {
-public:
-    explicit BehaviorInfo();
-    ~BehaviorInfo();
-
-    bool UpdateInput(const std::vector<u8>& buffer, std::size_t offset);
-    bool UpdateOutput(std::vector<u8>& buffer, std::size_t offset);
-
-    void ClearError();
-    void UpdateFlags(u64_le dest_flags);
-    void SetUserRevision(u32_le revision);
-
-    bool IsAdpcmLoopContextBugFixed() const;
-    bool IsSplitterSupported() const;
-    bool IsLongSizePreDelaySupported() const;
-    bool IsAudioRenererProcessingTimeLimit80PercentSupported() const;
-    bool IsAudioRenererProcessingTimeLimit75PercentSupported() const;
-    bool IsAudioRenererProcessingTimeLimit70PercentSupported() const;
-    bool IsElapsedFrameCountSupported() const;
-    bool IsMemoryPoolForceMappingEnabled() const;
-
-private:
-    u32_le process_revision{};
-    u32_le user_revision{};
-    u64_le flags{};
-
-    struct ErrorInfo {
-        u32_le result{};
-        INSERT_PADDING_WORDS(1);
-        u64_le result_info{};
-    };
-    static_assert(sizeof(ErrorInfo) == 0x10, "ErrorInfo is an invalid size");
-
-    std::array<ErrorInfo, 10> errors{};
-    std::size_t error_count{};
-
-    struct InParams {
-        u32_le revision{};
-        u32_le padding{};
-        u64_le flags{};
-    };
-    static_assert(sizeof(InParams) == 0x10, "InParams is an invalid size");
-
-    struct OutParams {
-        std::array<ErrorInfo, 10> errors{};
-        u32_le error_count{};
-        INSERT_PADDING_BYTES(12);
-    };
-    static_assert(sizeof(OutParams) == 0xb0, "OutParams is an invalid size");
-};
-
-} // namespace AudioCore

src/audio_core/common.h

@@ -1,48 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/result.h"
-
-namespace AudioCore {
-namespace Audren {
-constexpr ResultCode ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
-}
-
-constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '8');
-constexpr std::size_t MAX_MIX_BUFFERS = 24;
-
-static constexpr u32 VersionFromRevision(u32_le rev) {
-    // "REV7" -> 7
-    return ((rev >> 24) & 0xff) - 0x30;
-}
-
-static constexpr bool IsRevisionSupported(u32 required, u32_le user_revision) {
-    const auto base = VersionFromRevision(user_revision);
-    return required <= base;
-}
-
-static constexpr bool IsValidRevision(u32_le revision) {
-    const auto base = VersionFromRevision(revision);
-    constexpr auto max_rev = VersionFromRevision(CURRENT_PROCESS_REVISION);
-    return base <= max_rev;
-}
-
-static constexpr bool CanConsumeBuffer(std::size_t size, std::size_t offset, std::size_t required) {
-    if (offset > size) {
-        return false;
-    }
-    if (size < required) {
-        return false;
-    }
-    if ((size - offset) < required) {
-        return false;
-    }
-    return true;
-}
-
-} // namespace AudioCore

src/common/CMakeLists.txt

@@ -32,8 +32,6 @@ add_custom_command(OUTPUT scm_rev.cpp
     DEPENDS
       # WARNING! It was too much work to try and make a common location for this list,
       # so if you need to change it, please update CMakeModules/GenerateSCMRev.cmake as well
-      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
-      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
       "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
       "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
       "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
@@ -125,8 +123,6 @@ add_library(common STATIC
     lz4_compression.cpp
     lz4_compression.h
     math_util.h
-    memory_detect.cpp
-    memory_detect.h
     memory_hook.cpp
     memory_hook.h
     microprofile.cpp
@@ -152,8 +148,6 @@ add_library(common STATIC
     thread.h
     thread_queue_list.h
     threadsafe_queue.h
-    time_zone.cpp
-    time_zone.h
     timer.cpp
     timer.h
     uint128.cpp
@@ -173,12 +167,10 @@ if(ARCHITECTURE_x86_64)
         PRIVATE
             x64/cpu_detect.cpp
             x64/cpu_detect.h
-            x64/xbyak_abi.h
-            x64/xbyak_util.h
     )
 endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC Boost::boost fmt::fmt microprofile)
-target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd xbyak)
+target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
+target_link_libraries(common PRIVATE lz4_static libzstd_static)

src/common/bit_field.h

@@ -180,7 +180,7 @@ public:
     }
 
     constexpr void Assign(const T& value) {
-        storage = static_cast<StorageType>((storage & ~mask) | FormatValue(value));
+        storage = (static_cast<StorageType>(storage) & ~mask) | FormatValue(value);
     }
 
     constexpr T Value() const {

src/common/file_util.cpp

@@ -888,14 +888,7 @@ std::string SanitizePath(std::string_view path_, DirectorySeparator directory_se
     }
 
     std::replace(path.begin(), path.end(), type1, type2);
-
-    auto start = path.begin();
-#ifdef _WIN32
-    // allow network paths which start with a double backslash (e.g. \\server\share)
-    if (start != path.end())
-        ++start;
-#endif
-    path.erase(std::unique(start, path.end(),
+    path.erase(std::unique(path.begin(), path.end(),
                            [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
                path.end());
     return std::string(RemoveTrailingSlash(path));
@@ -974,34 +967,6 @@ bool IOFile::Flush() {
     return IsOpen() && 0 == std::fflush(m_file);
 }
 
-std::size_t IOFile::ReadImpl(void* data, std::size_t length, std::size_t data_size) const {
-    if (!IsOpen()) {
-        return std::numeric_limits<std::size_t>::max();
-    }
-
-    if (length == 0) {
-        return 0;
-    }
-
-    DEBUG_ASSERT(data != nullptr);
-
-    return std::fread(data, data_size, length, m_file);
-}
-
-std::size_t IOFile::WriteImpl(const void* data, std::size_t length, std::size_t data_size) {
-    if (!IsOpen()) {
-        return std::numeric_limits<std::size_t>::max();
-    }
-
-    if (length == 0) {
-        return 0;
-    }
-
-    DEBUG_ASSERT(data != nullptr);
-
-    return std::fwrite(data, data_size, length, m_file);
-}
-
 bool IOFile::Resize(u64 size) {
     return IsOpen() && 0 ==
 #ifdef _WIN32

src/common/file_util.h

@@ -222,15 +222,22 @@ public:
         static_assert(std::is_trivially_copyable_v<T>,
                       "Given array does not consist of trivially copyable objects");
 
-        return ReadImpl(data, length, sizeof(T));
+        if (!IsOpen()) {
+            return std::numeric_limits<std::size_t>::max();
+        }
+
+        return std::fread(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
     std::size_t WriteArray(const T* data, std::size_t length) {
         static_assert(std::is_trivially_copyable_v<T>,
                       "Given array does not consist of trivially copyable objects");
+        if (!IsOpen()) {
+            return std::numeric_limits<std::size_t>::max();
+        }
 
-        return WriteImpl(data, length, sizeof(T));
+        return std::fwrite(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
@@ -271,9 +278,6 @@ public:
     }
 
 private:
-    std::size_t ReadImpl(void* data, std::size_t length, std::size_t data_size) const;
-    std::size_t WriteImpl(const void* data, std::size_t length, std::size_t data_size);
-
     std::FILE* m_file = nullptr;
 };
 

src/common/memory_detect.cpp

@@ -1,60 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#ifdef _WIN32
-// clang-format off
-#include <windows.h>
-#include <sysinfoapi.h>
-// clang-format on
-#else
-#include <sys/types.h>
-#ifdef __APPLE__
-#include <sys/sysctl.h>
-#else
-#include <sys/sysinfo.h>
-#endif
-#endif
-
-#include "common/memory_detect.h"
-
-namespace Common {
-
-// Detects the RAM and Swapfile sizes
-static MemoryInfo Detect() {
-    MemoryInfo mem_info{};
-
-#ifdef _WIN32
-    MEMORYSTATUSEX memorystatus;
-    memorystatus.dwLength = sizeof(memorystatus);
-    GlobalMemoryStatusEx(&memorystatus);
-    mem_info.TotalPhysicalMemory = memorystatus.ullTotalPhys;
-    mem_info.TotalSwapMemory = memorystatus.ullTotalPageFile - mem_info.TotalPhysicalMemory;
-#elif defined(__APPLE__)
-    u64 ramsize;
-    struct xsw_usage vmusage;
-    std::size_t sizeof_ramsize = sizeof(ramsize);
-    std::size_t sizeof_vmusage = sizeof(vmusage);
-    // hw and vm are defined in sysctl.h
-    // https://github.com/apple/darwin-xnu/blob/master/bsd/sys/sysctl.h#L471
-    // sysctlbyname(const char *, void *, size_t *, void *, size_t);
-    sysctlbyname("hw.memsize", &ramsize, &sizeof_ramsize, NULL, 0);
-    sysctlbyname("vm.swapusage", &vmusage, &sizeof_vmusage, NULL, 0);
-    mem_info.TotalPhysicalMemory = ramsize;
-    mem_info.TotalSwapMemory = vmusage.xsu_total;
-#else
-    struct sysinfo meminfo;
-    sysinfo(&meminfo);
-    mem_info.TotalPhysicalMemory = meminfo.totalram;
-    mem_info.TotalSwapMemory = meminfo.totalswap;
-#endif
-
-    return mem_info;
-}
-
-const MemoryInfo& GetMemInfo() {
-    static MemoryInfo mem_info = Detect();
-    return mem_info;
-}
-
-} // namespace Common

src/common/memory_detect.h

@@ -1,22 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Common {
-
-struct MemoryInfo {
-    u64 TotalPhysicalMemory{};
-    u64 TotalSwapMemory{};
-};
-
-/**
- * Gets the memory info of the host system
- * @return Reference to a MemoryInfo struct with the physical and swap memory sizes in bytes
- */
-const MemoryInfo& GetMemInfo();
-
-} // namespace Common

src/common/time_zone.cpp

@@ -1,49 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <chrono>
-#include <iomanip>
-#include <sstream>
-
-#include "common/logging/log.h"
-#include "common/time_zone.h"
-
-namespace Common::TimeZone {
-
-std::string GetDefaultTimeZone() {
-    return "GMT";
-}
-
-static std::string GetOsTimeZoneOffset() {
-    const std::time_t t{std::time(nullptr)};
-    const std::tm tm{*std::localtime(&t)};
-
-    std::stringstream ss;
-    ss << std::put_time(&tm, "%z"); // Get the current timezone offset, e.g. "-400", as a string
-
-    return ss.str();
-}
-
-static int ConvertOsTimeZoneOffsetToInt(const std::string& timezone) {
-    try {
-        return std::stoi(timezone);
-    } catch (const std::invalid_argument&) {
-        LOG_CRITICAL(Common, "invalid_argument with {}!", timezone);
-        return 0;
-    } catch (const std::out_of_range&) {
-        LOG_CRITICAL(Common, "out_of_range with {}!", timezone);
-        return 0;
-    }
-}
-
-std::chrono::seconds GetCurrentOffsetSeconds() {
-    const int offset{ConvertOsTimeZoneOffsetToInt(GetOsTimeZoneOffset())};
-
-    int seconds{(offset / 100) * 60 * 60}; // Convert hour component to seconds
-    seconds += (offset % 100) * 60;        // Convert minute component to seconds
-
-    return std::chrono::seconds{seconds};
-}
-
-} // namespace Common::TimeZone

src/common/time_zone.h

@@ -1,18 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <chrono>
-#include <string>
-
-namespace Common::TimeZone {
-
-/// Gets the default timezone, i.e. "GMT"
-std::string GetDefaultTimeZone();
-
-/// Gets the offset of the current timezone (from the default), in seconds
-std::chrono::seconds GetCurrentOffsetSeconds();
-
-} // namespace Common::TimeZone

src/common/uuid.h

@@ -40,11 +40,6 @@ struct UUID {
         uuid = INVALID_UUID;
     }
 
-    // TODO(ogniK): Properly generate a Nintendo ID
-    constexpr u64 GetNintendoID() const {
-        return uuid[0];
-    }
-
     std::string Format() const;
     std::string FormatSwitch() const;
 };

src/common/x64/xbyak_abi.h

@@ -1,229 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <bitset>
-#include <initializer_list>
-#include <xbyak.h>
-#include "common/assert.h"
-
-namespace Common::X64 {
-
-inline std::size_t RegToIndex(const Xbyak::Reg& reg) {
-    using Kind = Xbyak::Reg::Kind;
-    ASSERT_MSG((reg.getKind() & (Kind::REG | Kind::XMM)) != 0,
-               "RegSet only support GPRs and XMM registers.");
-    ASSERT_MSG(reg.getIdx() < 16, "RegSet only supports XXM0-15.");
-    return reg.getIdx() + (reg.getKind() == Kind::REG ? 0 : 16);
-}
-
-inline Xbyak::Reg64 IndexToReg64(std::size_t reg_index) {
-    ASSERT(reg_index < 16);
-    return Xbyak::Reg64(static_cast<int>(reg_index));
-}
-
-inline Xbyak::Xmm IndexToXmm(std::size_t reg_index) {
-    ASSERT(reg_index >= 16 && reg_index < 32);
-    return Xbyak::Xmm(static_cast<int>(reg_index - 16));
-}
-
-inline Xbyak::Reg IndexToReg(std::size_t reg_index) {
-    if (reg_index < 16) {
-        return IndexToReg64(reg_index);
-    } else {
-        return IndexToXmm(reg_index);
-    }
-}
-
-inline std::bitset<32> BuildRegSet(std::initializer_list<Xbyak::Reg> regs) {
-    std::bitset<32> bits;
-    for (const Xbyak::Reg& reg : regs) {
-        bits[RegToIndex(reg)] = true;
-    }
-    return bits;
-}
-
-const std::bitset<32> ABI_ALL_GPRS(0x0000FFFF);
-const std::bitset<32> ABI_ALL_XMMS(0xFFFF0000);
-
-#ifdef _WIN32
-
-// Microsoft x64 ABI
-const Xbyak::Reg ABI_RETURN = Xbyak::util::rax;
-const Xbyak::Reg ABI_PARAM1 = Xbyak::util::rcx;
-const Xbyak::Reg ABI_PARAM2 = Xbyak::util::rdx;
-const Xbyak::Reg ABI_PARAM3 = Xbyak::util::r8;
-const Xbyak::Reg ABI_PARAM4 = Xbyak::util::r9;
-
-const std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rcx,
-    Xbyak::util::rdx,
-    Xbyak::util::r8,
-    Xbyak::util::r9,
-    Xbyak::util::r10,
-    Xbyak::util::r11,
-    // XMMs
-    Xbyak::util::xmm0,
-    Xbyak::util::xmm1,
-    Xbyak::util::xmm2,
-    Xbyak::util::xmm3,
-    Xbyak::util::xmm4,
-    Xbyak::util::xmm5,
-});
-
-const std::bitset<32> ABI_ALL_CALLEE_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rbx,
-    Xbyak::util::rsi,
-    Xbyak::util::rdi,
-    Xbyak::util::rbp,
-    Xbyak::util::r12,
-    Xbyak::util::r13,
-    Xbyak::util::r14,
-    Xbyak::util::r15,
-    // XMMs
-    Xbyak::util::xmm6,
-    Xbyak::util::xmm7,
-    Xbyak::util::xmm8,
-    Xbyak::util::xmm9,
-    Xbyak::util::xmm10,
-    Xbyak::util::xmm11,
-    Xbyak::util::xmm12,
-    Xbyak::util::xmm13,
-    Xbyak::util::xmm14,
-    Xbyak::util::xmm15,
-});
-
-constexpr size_t ABI_SHADOW_SPACE = 0x20;
-
-#else
-
-// System V x86-64 ABI
-const Xbyak::Reg ABI_RETURN = Xbyak::util::rax;
-const Xbyak::Reg ABI_PARAM1 = Xbyak::util::rdi;
-const Xbyak::Reg ABI_PARAM2 = Xbyak::util::rsi;
-const Xbyak::Reg ABI_PARAM3 = Xbyak::util::rdx;
-const Xbyak::Reg ABI_PARAM4 = Xbyak::util::rcx;
-
-const std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rcx,
-    Xbyak::util::rdx,
-    Xbyak::util::rdi,
-    Xbyak::util::rsi,
-    Xbyak::util::r8,
-    Xbyak::util::r9,
-    Xbyak::util::r10,
-    Xbyak::util::r11,
-    // XMMs
-    Xbyak::util::xmm0,
-    Xbyak::util::xmm1,
-    Xbyak::util::xmm2,
-    Xbyak::util::xmm3,
-    Xbyak::util::xmm4,
-    Xbyak::util::xmm5,
-    Xbyak::util::xmm6,
-    Xbyak::util::xmm7,
-    Xbyak::util::xmm8,
-    Xbyak::util::xmm9,
-    Xbyak::util::xmm10,
-    Xbyak::util::xmm11,
-    Xbyak::util::xmm12,
-    Xbyak::util::xmm13,
-    Xbyak::util::xmm14,
-    Xbyak::util::xmm15,
-});
-
-const std::bitset<32> ABI_ALL_CALLEE_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rbx,
-    Xbyak::util::rbp,
-    Xbyak::util::r12,
-    Xbyak::util::r13,
-    Xbyak::util::r14,
-    Xbyak::util::r15,
-});
-
-constexpr size_t ABI_SHADOW_SPACE = 0;
-
-#endif
-
-struct ABIFrameInfo {
-    s32 subtraction;
-    s32 xmm_offset;
-};
-
-inline ABIFrameInfo ABI_CalculateFrameSize(std::bitset<32> regs, size_t rsp_alignment,
-                                           size_t needed_frame_size) {
-    const auto count = (regs & ABI_ALL_GPRS).count();
-    rsp_alignment -= count * 8;
-    size_t subtraction = 0;
-    const auto xmm_count = (regs & ABI_ALL_XMMS).count();
-    if (xmm_count) {
-        // If we have any XMMs to save, we must align the stack here.
-        subtraction = rsp_alignment & 0xF;
-    }
-    subtraction += 0x10 * xmm_count;
-    size_t xmm_base_subtraction = subtraction;
-    subtraction += needed_frame_size;
-    subtraction += ABI_SHADOW_SPACE;
-    // Final alignment.
-    rsp_alignment -= subtraction;
-    subtraction += rsp_alignment & 0xF;
-
-    return ABIFrameInfo{static_cast<s32>(subtraction),
-                        static_cast<s32>(subtraction - xmm_base_subtraction)};
-}
-
-inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bitset<32> regs,
-                                              size_t rsp_alignment, size_t needed_frame_size = 0) {
-    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);
-
-    for (std::size_t i = 0; i < regs.size(); ++i) {
-        if (regs[i] && ABI_ALL_GPRS[i]) {
-            code.push(IndexToReg64(i));
-        }
-    }
-
-    if (frame_info.subtraction != 0) {
-        code.sub(code.rsp, frame_info.subtraction);
-    }
-
-    for (std::size_t i = 0; i < regs.size(); ++i) {
-        if (regs[i] && ABI_ALL_XMMS[i]) {
-            code.movaps(code.xword[code.rsp + frame_info.xmm_offset], IndexToXmm(i));
-            frame_info.xmm_offset += 0x10;
-        }
-    }
-
-    return ABI_SHADOW_SPACE;
-}
-
-inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bitset<32> regs,
-                                           size_t rsp_alignment, size_t needed_frame_size = 0) {
-    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);
-
-    for (std::size_t i = 0; i < regs.size(); ++i) {
-        if (regs[i] && ABI_ALL_XMMS[i]) {
-            code.movaps(IndexToXmm(i), code.xword[code.rsp + frame_info.xmm_offset]);
-            frame_info.xmm_offset += 0x10;
-        }
-    }
-
-    if (frame_info.subtraction != 0) {
-        code.add(code.rsp, frame_info.subtraction);
-    }
-
-    // GPRs need to be popped in reverse order
-    for (std::size_t j = 0; j < regs.size(); ++j) {
-        const std::size_t i = regs.size() - j - 1;
-        if (regs[i] && ABI_ALL_GPRS[i]) {
-            code.pop(IndexToReg64(i));
-        }
-    }
-}
-
-} // namespace Common::X64

src/common/x64/xbyak_util.h

@@ -1,47 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <type_traits>
-#include <xbyak.h>
-#include "common/x64/xbyak_abi.h"
-
-namespace Common::X64 {
-
-// Constants for use with cmpps/cmpss
-enum {
-    CMP_EQ = 0,
-    CMP_LT = 1,
-    CMP_LE = 2,
-    CMP_UNORD = 3,
-    CMP_NEQ = 4,
-    CMP_NLT = 5,
-    CMP_NLE = 6,
-    CMP_ORD = 7,
-};
-
-constexpr bool IsWithin2G(uintptr_t ref, uintptr_t target) {
-    const u64 distance = target - (ref + 5);
-    return !(distance >= 0x8000'0000ULL && distance <= ~0x8000'0000ULL);
-}
-
-inline bool IsWithin2G(const Xbyak::CodeGenerator& code, uintptr_t target) {
-    return IsWithin2G(reinterpret_cast<uintptr_t>(code.getCurr()), target);
-}
-
-template <typename T>
-inline void CallFarFunction(Xbyak::CodeGenerator& code, const T f) {
-    static_assert(std::is_pointer_v<T>, "Argument must be a (function) pointer.");
-    size_t addr = reinterpret_cast<size_t>(f);
-    if (IsWithin2G(code, addr)) {
-        code.call(f);
-    } else {
-        // ABI_RETURN is a safe temp register to use before a call
-        code.mov(ABI_RETURN, addr);
-        code.call(ABI_RETURN);
-    }
-}
-
-} // namespace Common::X64

src/core/CMakeLists.txt

@@ -606,11 +606,11 @@ 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 unicorn)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt json-headers mbedtls opus unicorn)
 
 if (YUZU_ENABLE_BOXCAT)
     target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
-    target_link_libraries(core PRIVATE httplib nlohmann_json::nlohmann_json zip)
+    target_link_libraries(core PRIVATE httplib json-headers zip)
 endif()
 
 if (ENABLE_WEB_SERVICE)

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -50,8 +50,7 @@ public:
     }
 
     void InterpreterFallback(u32 pc, std::size_t num_instructions) override {
-        UNIMPLEMENTED_MSG("This should never happen, pc = {:08X}, code = {:08X}", pc,
-                          MemoryReadCode(pc));
+        UNIMPLEMENTED();
     }
 
     void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
@@ -90,6 +89,8 @@ public:
 
     ARM_Dynarmic_32& parent;
     std::size_t num_interpreted_instructions{};
+    u64 tpidrro_el0{};
+    u64 tpidr_el0{};
 };
 
 std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable& page_table,
@@ -98,7 +99,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable&
     config.callbacks = cb.get();
     // TODO(bunnei): Implement page table for 32-bit
     // config.page_table = &page_table.pointers;
-    config.coprocessors[15] = cp15;
+    config.coprocessors[15] = std::make_shared<DynarmicCP15>((u32*)&CP15_regs[0]);
     config.define_unpredictable_behaviour = true;
     return std::make_unique<Dynarmic::A32::Jit>(config);
 }
@@ -111,13 +112,13 @@ void ARM_Dynarmic_32::Run() {
 }
 
 void ARM_Dynarmic_32::Step() {
-    jit->Step();
+    cb->InterpreterFallback(jit->Regs()[15], 1);
 }
 
 ARM_Dynarmic_32::ARM_Dynarmic_32(System& system, ExclusiveMonitor& exclusive_monitor,
                                  std::size_t core_index)
-    : ARM_Interface{system}, cb(std::make_unique<DynarmicCallbacks32>(*this)),
-      cp15(std::make_shared<DynarmicCP15>(*this)), core_index{core_index},
+    : ARM_Interface{system},
+      cb(std::make_unique<DynarmicCallbacks32>(*this)), core_index{core_index},
       exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
 
 ARM_Dynarmic_32::~ARM_Dynarmic_32() = default;
@@ -153,19 +154,19 @@ void ARM_Dynarmic_32::SetPSTATE(u32 cpsr) {
 }
 
 u64 ARM_Dynarmic_32::GetTlsAddress() const {
-    return cp15->uro;
+    return CP15_regs[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)];
 }
 
 void ARM_Dynarmic_32::SetTlsAddress(VAddr address) {
-    cp15->uro = static_cast<u32>(address);
+    CP15_regs[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)] = static_cast<u32>(address);
 }
 
 u64 ARM_Dynarmic_32::GetTPIDR_EL0() const {
-    return cp15->uprw;
+    return cb->tpidr_el0;
 }
 
 void ARM_Dynarmic_32::SetTPIDR_EL0(u64 value) {
-    cp15->uprw = static_cast<u32>(value);
+    cb->tpidr_el0 = value;
 }
 
 void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) {

src/core/arm/dynarmic/arm_dynarmic_32.h

@@ -22,7 +22,6 @@ class Memory;
 namespace Core {
 
 class DynarmicCallbacks32;
-class DynarmicCP15;
 class DynarmicExclusiveMonitor;
 class System;
 
@@ -67,14 +66,12 @@ private:
         std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A32::Jit>, Common::PairHash>;
 
     friend class DynarmicCallbacks32;
-    friend class DynarmicCP15;
-
     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::array<u32, 84> CP15_regs{};
 };
 
 } // namespace Core

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -20,7 +20,6 @@
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
-#include "core/settings.h"
 
 namespace Core {
 
@@ -145,8 +144,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable&
     config.page_table_address_space_bits = address_space_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;
@@ -162,11 +159,8 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable&
     // Unpredictable instructions
     config.define_unpredictable_behaviour = true;
 
-    // Optimizations
-    if (Settings::values.disable_cpu_opt) {
-        config.enable_optimizations = false;
-        config.enable_fast_dispatch = false;
-    }
+    config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
+    config.only_detect_misalignment_via_page_table_on_page_boundary = true;
 
     return std::make_shared<Dynarmic::A64::Jit>(config);
 }
@@ -185,9 +179,10 @@ void ARM_Dynarmic_64::Step() {
 
 ARM_Dynarmic_64::ARM_Dynarmic_64(System& system, ExclusiveMonitor& exclusive_monitor,
                                  std::size_t core_index)
-    : ARM_Interface{system}, cb(std::make_unique<DynarmicCallbacks64>(*this)),
-      inner_unicorn{system, ARM_Unicorn::Arch::AArch64}, core_index{core_index},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
+    : ARM_Interface{system},
+      cb(std::make_unique<DynarmicCallbacks64>(*this)), inner_unicorn{system},
+      core_index{core_index}, exclusive_monitor{
+                                  dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
 
 ARM_Dynarmic_64::~ARM_Dynarmic_64() = default;
 

src/core/arm/dynarmic/arm_dynarmic_cp15.cpp

@@ -2,132 +2,79 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <fmt/format.h>
-#include "common/logging/log.h"
-#include "core/arm/dynarmic/arm_dynarmic_32.h"
 #include "core/arm/dynarmic/arm_dynarmic_cp15.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/core_timing_util.h"
 
 using Callback = Dynarmic::A32::Coprocessor::Callback;
 using CallbackOrAccessOneWord = Dynarmic::A32::Coprocessor::CallbackOrAccessOneWord;
 using CallbackOrAccessTwoWords = Dynarmic::A32::Coprocessor::CallbackOrAccessTwoWords;
 
-template <>
-struct fmt::formatter<Dynarmic::A32::CoprocReg> {
-    constexpr auto parse(format_parse_context& ctx) {
-        return ctx.begin();
-    }
-    template <typename FormatContext>
-    auto format(const Dynarmic::A32::CoprocReg& reg, FormatContext& ctx) {
-        return format_to(ctx.out(), "cp{}", static_cast<size_t>(reg));
-    }
-};
-
-namespace Core {
-
-static u32 dummy_value;
-
 std::optional<Callback> DynarmicCP15::CompileInternalOperation(bool two, unsigned opc1,
                                                                CoprocReg CRd, CoprocReg CRn,
                                                                CoprocReg CRm, unsigned opc2) {
-    LOG_CRITICAL(Core_ARM, "CP15: cdp{} p15, {}, {}, {}, {}, {}", two ? "2" : "", opc1, CRd, CRn,
-                 CRm, opc2);
     return {};
 }
 
 CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1, CoprocReg CRn,
                                                          CoprocReg CRm, unsigned opc2) {
+    // TODO(merry): Privileged CP15 registers
+
     if (!two && CRn == CoprocReg::C7 && opc1 == 0 && CRm == CoprocReg::C5 && opc2 == 4) {
-        // CP15_FLUSH_PREFETCH_BUFFER
         // This is a dummy write, we ignore the value written here.
-        return &dummy_value;
+        return &CP15[static_cast<std::size_t>(CP15Register::CP15_FLUSH_PREFETCH_BUFFER)];
     }
 
     if (!two && CRn == CoprocReg::C7 && opc1 == 0 && CRm == CoprocReg::C10) {
         switch (opc2) {
         case 4:
-            // CP15_DATA_SYNC_BARRIER
             // This is a dummy write, we ignore the value written here.
-            return &dummy_value;
+            return &CP15[static_cast<std::size_t>(CP15Register::CP15_DATA_SYNC_BARRIER)];
         case 5:
-            // CP15_DATA_MEMORY_BARRIER
             // This is a dummy write, we ignore the value written here.
-            return &dummy_value;
+            return &CP15[static_cast<std::size_t>(CP15Register::CP15_DATA_MEMORY_BARRIER)];
+        default:
+            return {};
         }
     }
 
     if (!two && CRn == CoprocReg::C13 && opc1 == 0 && CRm == CoprocReg::C0 && opc2 == 2) {
-        // CP15_THREAD_UPRW
-        return &uprw;
+        return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_UPRW)];
     }
 
-    LOG_CRITICAL(Core_ARM, "CP15: mcr{} p15, {}, <Rt>, {}, {}, {}", two ? "2" : "", opc1, CRn, CRm,
-                 opc2);
     return {};
 }
 
 CallbackOrAccessTwoWords DynarmicCP15::CompileSendTwoWords(bool two, unsigned opc, CoprocReg CRm) {
-    LOG_CRITICAL(Core_ARM, "CP15: mcrr{} p15, {}, <Rt>, <Rt2>, {}", two ? "2" : "", opc, CRm);
     return {};
 }
 
 CallbackOrAccessOneWord DynarmicCP15::CompileGetOneWord(bool two, unsigned opc1, CoprocReg CRn,
                                                         CoprocReg CRm, unsigned opc2) {
+    // TODO(merry): Privileged CP15 registers
+
     if (!two && CRn == CoprocReg::C13 && opc1 == 0 && CRm == CoprocReg::C0) {
         switch (opc2) {
         case 2:
-            // CP15_THREAD_UPRW
-            return &uprw;
+            return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_UPRW)];
         case 3:
-            // CP15_THREAD_URO
-            return &uro;
+            return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)];
+        default:
+            return {};
         }
     }
 
-    LOG_CRITICAL(Core_ARM, "CP15: mrc{} p15, {}, <Rt>, {}, {}, {}", two ? "2" : "", opc1, CRn, CRm,
-                 opc2);
     return {};
 }
 
 CallbackOrAccessTwoWords DynarmicCP15::CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) {
-    if (!two && opc == 0 && CRm == CoprocReg::C14) {
-        // CNTPCT
-        const auto callback = static_cast<u64 (*)(Dynarmic::A32::Jit*, void*, u32, u32)>(
-            [](Dynarmic::A32::Jit*, void* arg, u32, u32) -> u64 {
-                ARM_Dynarmic_32& parent = *(ARM_Dynarmic_32*)arg;
-                return Timing::CpuCyclesToClockCycles(parent.system.CoreTiming().GetTicks());
-            });
-        return Dynarmic::A32::Coprocessor::Callback{callback, (void*)&parent};
-    }
-
-    LOG_CRITICAL(Core_ARM, "CP15: mrrc{} p15, {}, <Rt>, <Rt2>, {}", two ? "2" : "", opc, CRm);
     return {};
 }
 
 std::optional<Callback> DynarmicCP15::CompileLoadWords(bool two, bool long_transfer, CoprocReg CRd,
                                                        std::optional<u8> option) {
-    if (option) {
-        LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...], {}", two ? "2" : "",
-                     long_transfer ? "l" : "", CRd, *option);
-    } else {
-        LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...]", two ? "2" : "",
-                     long_transfer ? "l" : "", CRd);
-    }
     return {};
 }
 
 std::optional<Callback> DynarmicCP15::CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
                                                         std::optional<u8> option) {
-    if (option) {
-        LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...], {}", two ? "2" : "",
-                     long_transfer ? "l" : "", CRd, *option);
-    } else {
-        LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...]", two ? "2" : "",
-                     long_transfer ? "l" : "", CRd);
-    }
     return {};
 }
-
-} // namespace Core

src/core/arm/dynarmic/arm_dynarmic_cp15.h

@@ -10,15 +10,128 @@
 #include <dynarmic/A32/coprocessor.h>
 #include "common/common_types.h"
 
-namespace Core {
+enum class CP15Register {
+    // c0 - Information registers
+    CP15_MAIN_ID,
+    CP15_CACHE_TYPE,
+    CP15_TCM_STATUS,
+    CP15_TLB_TYPE,
+    CP15_CPU_ID,
+    CP15_PROCESSOR_FEATURE_0,
+    CP15_PROCESSOR_FEATURE_1,
+    CP15_DEBUG_FEATURE_0,
+    CP15_AUXILIARY_FEATURE_0,
+    CP15_MEMORY_MODEL_FEATURE_0,
+    CP15_MEMORY_MODEL_FEATURE_1,
+    CP15_MEMORY_MODEL_FEATURE_2,
+    CP15_MEMORY_MODEL_FEATURE_3,
+    CP15_ISA_FEATURE_0,
+    CP15_ISA_FEATURE_1,
+    CP15_ISA_FEATURE_2,
+    CP15_ISA_FEATURE_3,
+    CP15_ISA_FEATURE_4,
 
-class ARM_Dynarmic_32;
+    // c1 - Control registers
+    CP15_CONTROL,
+    CP15_AUXILIARY_CONTROL,
+    CP15_COPROCESSOR_ACCESS_CONTROL,
+
+    // c2 - Translation table registers
+    CP15_TRANSLATION_BASE_TABLE_0,
+    CP15_TRANSLATION_BASE_TABLE_1,
+    CP15_TRANSLATION_BASE_CONTROL,
+    CP15_DOMAIN_ACCESS_CONTROL,
+    CP15_RESERVED,
+
+    // c5 - Fault status registers
+    CP15_FAULT_STATUS,
+    CP15_INSTR_FAULT_STATUS,
+    CP15_COMBINED_DATA_FSR = CP15_FAULT_STATUS,
+    CP15_INST_FSR,
+
+    // c6 - Fault Address registers
+    CP15_FAULT_ADDRESS,
+    CP15_COMBINED_DATA_FAR = CP15_FAULT_ADDRESS,
+    CP15_WFAR,
+    CP15_IFAR,
+
+    // c7 - Cache operation registers
+    CP15_WAIT_FOR_INTERRUPT,
+    CP15_PHYS_ADDRESS,
+    CP15_INVALIDATE_INSTR_CACHE,
+    CP15_INVALIDATE_INSTR_CACHE_USING_MVA,
+    CP15_INVALIDATE_INSTR_CACHE_USING_INDEX,
+    CP15_FLUSH_PREFETCH_BUFFER,
+    CP15_FLUSH_BRANCH_TARGET_CACHE,
+    CP15_FLUSH_BRANCH_TARGET_CACHE_ENTRY,
+    CP15_INVALIDATE_DATA_CACHE,
+    CP15_INVALIDATE_DATA_CACHE_LINE_USING_MVA,
+    CP15_INVALIDATE_DATA_CACHE_LINE_USING_INDEX,
+    CP15_INVALIDATE_DATA_AND_INSTR_CACHE,
+    CP15_CLEAN_DATA_CACHE,
+    CP15_CLEAN_DATA_CACHE_LINE_USING_MVA,
+    CP15_CLEAN_DATA_CACHE_LINE_USING_INDEX,
+    CP15_DATA_SYNC_BARRIER,
+    CP15_DATA_MEMORY_BARRIER,
+    CP15_CLEAN_AND_INVALIDATE_DATA_CACHE,
+    CP15_CLEAN_AND_INVALIDATE_DATA_CACHE_LINE_USING_MVA,
+    CP15_CLEAN_AND_INVALIDATE_DATA_CACHE_LINE_USING_INDEX,
+
+    // c8 - TLB operations
+    CP15_INVALIDATE_ITLB,
+    CP15_INVALIDATE_ITLB_SINGLE_ENTRY,
+    CP15_INVALIDATE_ITLB_ENTRY_ON_ASID_MATCH,
+    CP15_INVALIDATE_ITLB_ENTRY_ON_MVA,
+    CP15_INVALIDATE_DTLB,
+    CP15_INVALIDATE_DTLB_SINGLE_ENTRY,
+    CP15_INVALIDATE_DTLB_ENTRY_ON_ASID_MATCH,
+    CP15_INVALIDATE_DTLB_ENTRY_ON_MVA,
+    CP15_INVALIDATE_UTLB,
+    CP15_INVALIDATE_UTLB_SINGLE_ENTRY,
+    CP15_INVALIDATE_UTLB_ENTRY_ON_ASID_MATCH,
+    CP15_INVALIDATE_UTLB_ENTRY_ON_MVA,
+
+    // c9 - Data cache lockdown register
+    CP15_DATA_CACHE_LOCKDOWN,
+
+    // c10 - TLB/Memory map registers
+    CP15_TLB_LOCKDOWN,
+    CP15_PRIMARY_REGION_REMAP,
+    CP15_NORMAL_REGION_REMAP,
+
+    // c13 - Thread related registers
+    CP15_PID,
+    CP15_CONTEXT_ID,
+    CP15_THREAD_UPRW, // Thread ID register - User/Privileged Read/Write
+    CP15_THREAD_URO,  // Thread ID register - User Read Only (Privileged R/W)
+    CP15_THREAD_PRW,  // Thread ID register - Privileged R/W only.
+
+    // c15 - Performance and TLB lockdown registers
+    CP15_PERFORMANCE_MONITOR_CONTROL,
+    CP15_CYCLE_COUNTER,
+    CP15_COUNT_0,
+    CP15_COUNT_1,
+    CP15_READ_MAIN_TLB_LOCKDOWN_ENTRY,
+    CP15_WRITE_MAIN_TLB_LOCKDOWN_ENTRY,
+    CP15_MAIN_TLB_LOCKDOWN_VIRT_ADDRESS,
+    CP15_MAIN_TLB_LOCKDOWN_PHYS_ADDRESS,
+    CP15_MAIN_TLB_LOCKDOWN_ATTRIBUTE,
+    CP15_TLB_DEBUG_CONTROL,
+
+    // Skyeye defined
+    CP15_TLB_FAULT_ADDR,
+    CP15_TLB_FAULT_STATUS,
+
+    // Not an actual register.
+    // All registers should be defined above this.
+    CP15_REGISTER_COUNT,
+};
 
 class DynarmicCP15 final : public Dynarmic::A32::Coprocessor {
 public:
     using CoprocReg = Dynarmic::A32::CoprocReg;
 
-    explicit DynarmicCP15(ARM_Dynarmic_32& parent) : parent(parent) {}
+    explicit DynarmicCP15(u32* cp15) : CP15(cp15){};
 
     std::optional<Callback> CompileInternalOperation(bool two, unsigned opc1, CoprocReg CRd,
                                                      CoprocReg CRn, CoprocReg CRm,
@@ -34,9 +147,6 @@ public:
     std::optional<Callback> CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
                                               std::optional<u8> option) override;
 
-    ARM_Dynarmic_32& parent;
-    u32 uprw;
-    u32 uro;
+private:
+    u32* CP15{};
 };
-
-} // namespace Core

src/core/arm/unicorn/arm_unicorn.cpp

@@ -11,7 +11,6 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/svc.h"
-#include "core/memory.h"
 
 namespace Core {
 
@@ -62,9 +61,8 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
     return false;
 }
 
-ARM_Unicorn::ARM_Unicorn(System& system, Arch architecture) : ARM_Interface{system} {
-    const auto arch = architecture == Arch::AArch32 ? UC_ARCH_ARM : UC_ARCH_ARM64;
-    CHECKED(uc_open(arch, UC_MODE_ARM, &uc));
+ARM_Unicorn::ARM_Unicorn(System& system) : ARM_Interface{system} {
+    CHECKED(uc_open(UC_ARCH_ARM64, UC_MODE_ARM, &uc));
 
     auto fpv = 3 << 20;
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_CPACR_EL1, &fpv));
@@ -173,17 +171,7 @@ MICROPROFILE_DEFINE(ARM_Jit_Unicorn, "ARM JIT", "Unicorn", MP_RGB(255, 64, 64));
 
 void ARM_Unicorn::ExecuteInstructions(std::size_t num_instructions) {
     MICROPROFILE_SCOPE(ARM_Jit_Unicorn);
-
-    // Temporarily map the code page for Unicorn
-    u64 map_addr{GetPC() & ~Memory::PAGE_MASK};
-    std::vector<u8> page_buffer(Memory::PAGE_SIZE);
-    system.Memory().ReadBlock(map_addr, page_buffer.data(), page_buffer.size());
-
-    CHECKED(uc_mem_map_ptr(uc, map_addr, page_buffer.size(),
-                           UC_PROT_READ | UC_PROT_WRITE | UC_PROT_EXEC, page_buffer.data()));
     CHECKED(uc_emu_start(uc, GetPC(), 1ULL << 63, 0, num_instructions));
-    CHECKED(uc_mem_unmap(uc, map_addr, page_buffer.size()));
-
     system.CoreTiming().AddTicks(num_instructions);
     if (GDBStub::IsServerEnabled()) {
         if (last_bkpt_hit && last_bkpt.type == GDBStub::BreakpointType::Execute) {

src/core/arm/unicorn/arm_unicorn.h

@@ -15,12 +15,7 @@ class System;
 
 class ARM_Unicorn final : public ARM_Interface {
 public:
-    enum class Arch {
-        AArch32, // 32-bit ARM
-        AArch64, // 64-bit ARM
-    };
-
-    explicit ARM_Unicorn(System& system, Arch architecture);
+    explicit ARM_Unicorn(System& system);
     ~ARM_Unicorn() override;
 
     void SetPC(u64 pc) override;

src/core/crypto/key_manager.cpp

@@ -1202,8 +1202,7 @@ const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> KeyManager:
      {S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyAreaKey),
       static_cast<u64>(KeyAreaKeyType::System)}},
     {"titlekek_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::Titlekek), 0}},
-    {"keyblob_mac_key_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyblobMAC), 0}},
+    {"keyblob_mac_key_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyblobMAC)}},
     {"tsec_key", {S128KeyType::TSEC, 0, 0}},
     {"secure_boot_key", {S128KeyType::SecureBoot, 0, 0}},
     {"sd_seed", {S128KeyType::SDSeed, 0, 0}},

src/core/crypto/partition_data_manager.cpp

@@ -202,8 +202,8 @@ static std::array<Key128, 0x20> FindEncryptedMasterKeyFromHex(const std::vector<
     return out;
 }
 
-static FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir,
-                                                   const std::string& name) {
+FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir,
+                                            const std::string& name) {
     const auto upper = Common::ToUpper(name);
 
     for (const auto& fname : {name, name + ".bin", upper, upper + ".BIN"}) {
@@ -345,7 +345,8 @@ FileSys::VirtualFile PartitionDataManager::GetPackage2Raw(Package2Type type) con
     return package2.at(static_cast<size_t>(type));
 }
 
-static bool AttemptDecrypt(const std::array<u8, 16>& key, Package2Header& header) {
+bool AttemptDecrypt(const std::array<u8, 16>& key, Package2Header& header) {
+
     const std::vector<u8> iv(header.header_ctr.begin(), header.header_ctr.end());
     Package2Header temp = header;
     AESCipher<Key128> cipher(key, Mode::CTR);

src/core/file_sys/control_metadata.cpp

@@ -95,10 +95,6 @@ u32 NACP::GetSupportedLanguages() const {
     return raw.supported_languages;
 }
 
-u64 NACP::GetDeviceSaveDataSize() const {
-    return raw.device_save_data_size;
-}
-
 std::vector<u8> NACP::GetRawBytes() const {
     std::vector<u8> out(sizeof(RawNACP));
     std::memcpy(out.data(), &raw, sizeof(RawNACP));

src/core/file_sys/control_metadata.h

@@ -113,7 +113,6 @@ public:
     u32 GetSupportedLanguages() const;
     std::vector<u8> GetRawBytes() const;
     bool GetUserAccountSwitchLock() const;
-    u64 GetDeviceSaveDataSize() const;
 
 private:
     RawNACP raw{};

src/core/file_sys/patch_manager.cpp

@@ -10,7 +10,6 @@
 #include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
@@ -49,23 +48,6 @@ std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
     return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
 }
 
-std::shared_ptr<VfsDirectory> FindSubdirectoryCaseless(const std::shared_ptr<VfsDirectory> dir,
-                                                       std::string_view name) {
-#ifdef _WIN32
-    return dir->GetSubdirectory(name);
-#else
-    const auto subdirs = dir->GetSubdirectories();
-    for (const auto& subdir : subdirs) {
-        std::string dir_name = Common::ToLower(subdir->GetName());
-        if (dir_name == name) {
-            return subdir;
-        }
-    }
-
-    return nullptr;
-#endif
-}
-
 PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
 
 PatchManager::~PatchManager() = default;
@@ -122,7 +104,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
             if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
                 continue;
 
-            auto exefs_dir = FindSubdirectoryCaseless(subdir, "exefs");
+            auto exefs_dir = subdir->GetSubdirectory("exefs");
             if (exefs_dir != nullptr)
                 layers.push_back(std::move(exefs_dir));
         }
@@ -148,7 +130,7 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
         if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend())
             continue;
 
-        auto exefs_dir = FindSubdirectoryCaseless(subdir, "exefs");
+        auto exefs_dir = subdir->GetSubdirectory("exefs");
         if (exefs_dir != nullptr) {
             for (const auto& file : exefs_dir->GetFiles()) {
                 if (file->GetExtension() == "ips") {
@@ -313,7 +295,7 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
             continue;
         }
 
-        auto cheats_dir = FindSubdirectoryCaseless(subdir, "cheats");
+        auto cheats_dir = subdir->GetSubdirectory("cheats");
         if (cheats_dir != nullptr) {
             auto res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, true);
             if (res.has_value()) {
@@ -358,11 +340,11 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
             continue;
         }
 
-        auto romfs_dir = FindSubdirectoryCaseless(subdir, "romfs");
+        auto romfs_dir = subdir->GetSubdirectory("romfs");
         if (romfs_dir != nullptr)
             layers.push_back(std::move(romfs_dir));
 
-        auto ext_dir = FindSubdirectoryCaseless(subdir, "romfs_ext");
+        auto ext_dir = subdir->GetSubdirectory("romfs_ext");
         if (ext_dir != nullptr)
             layers_ext.push_back(std::move(ext_dir));
     }
@@ -488,7 +470,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
         for (const auto& mod : mod_dir->GetSubdirectories()) {
             std::string types;
 
-            const auto exefs_dir = FindSubdirectoryCaseless(mod, "exefs");
+            const auto exefs_dir = mod->GetSubdirectory("exefs");
             if (IsDirValidAndNonEmpty(exefs_dir)) {
                 bool ips = false;
                 bool ipswitch = false;
@@ -512,9 +494,9 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
                 if (layeredfs)
                     AppendCommaIfNotEmpty(types, "LayeredExeFS");
             }
-            if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "romfs")))
+            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("romfs")))
                 AppendCommaIfNotEmpty(types, "LayeredFS");
-            if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "cheats")))
+            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("cheats")))
                 AppendCommaIfNotEmpty(types, "Cheats");
 
             if (types.empty())

src/core/file_sys/patch_manager.h

@@ -29,11 +29,6 @@ enum class TitleVersionFormat : u8 {
 std::string FormatTitleVersion(u32 version,
                                TitleVersionFormat format = TitleVersionFormat::ThreeElements);
 
-// Returns a directory with name matching name case-insensitive. Returns nullptr if directory
-// doesn't have a directory with name.
-std::shared_ptr<VfsDirectory> FindSubdirectoryCaseless(const std::shared_ptr<VfsDirectory> dir,
-                                                       std::string_view name);
-
 // A centralized class to manage patches to games.
 class PatchManager {
 public:

src/core/file_sys/program_metadata.cpp

@@ -51,17 +51,6 @@ Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
     return Loader::ResultStatus::Success;
 }
 
-/*static*/ ProgramMetadata ProgramMetadata::GetDefault() {
-    ProgramMetadata result;
-
-    result.LoadManual(
-        true /*is_64_bit*/, FileSys::ProgramAddressSpaceType::Is39Bit /*address_space*/,
-        0x2c /*main_thread_prio*/, 0 /*main_thread_core*/, 0x00100000 /*main_thread_stack_size*/,
-        {}, 0xFFFFFFFFFFFFFFFF /*filesystem_permissions*/, {} /*capabilities*/);
-
-    return result;
-}
-
 void ProgramMetadata::LoadManual(bool is_64_bit, ProgramAddressSpaceType address_space,
                                  s32 main_thread_prio, u32 main_thread_core,
                                  u32 main_thread_stack_size, u64 title_id,

src/core/file_sys/program_metadata.h

@@ -44,13 +44,9 @@ public:
     ProgramMetadata();
     ~ProgramMetadata();
 
-    /// Gets a default ProgramMetadata configuration, should only be used for homebrew formats where
-    /// we do not have an NPDM file
-    static ProgramMetadata GetDefault();
-
     Loader::ResultStatus Load(VirtualFile file);
 
-    /// Load from parameters instead of NPDM file, used for KIP
+    // Load from parameters instead of NPDM file, used for KIP
     void LoadManual(bool is_64_bit, ProgramAddressSpaceType address_space, s32 main_thread_prio,
                     u32 main_thread_core, u32 main_thread_stack_size, u64 title_id,
                     u64 filesystem_permissions, KernelCapabilityDescriptors capabilities);

src/core/file_sys/savedata_factory.cpp

@@ -57,8 +57,7 @@ void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
 bool ShouldSaveDataBeAutomaticallyCreated(SaveDataSpaceId space, const SaveDataDescriptor& desc) {
     return desc.type == SaveDataType::CacheStorage || desc.type == SaveDataType::TemporaryStorage ||
            (space == SaveDataSpaceId::NandUser && ///< Normal Save Data -- Current Title & User
-            (desc.type == SaveDataType::SaveData || desc.type == SaveDataType::DeviceSaveData) &&
-            desc.title_id == 0 && desc.save_id == 0);
+            desc.type == SaveDataType::SaveData && desc.title_id == 0 && desc.save_id == 0);
 }
 
 } // Anonymous namespace
@@ -140,10 +139,8 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
                                          u128 user_id, u64 save_id) {
     // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
     // be interpreted as the title id of the current process.
-    if (type == SaveDataType::SaveData || type == SaveDataType::DeviceSaveData) {
-        if (title_id == 0) {
-            title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
-        }
+    if (type == SaveDataType::SaveData && title_id == 0) {
+        title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
     }
 
     std::string out = GetSaveDataSpaceIdPath(space);

src/core/file_sys/system_archive/system_version.cpp

@@ -12,17 +12,17 @@ namespace SystemVersionData {
 // This section should reflect the best system version to describe yuzu's HLE api.
 // TODO(DarkLordZach): Update when HLE gets better.
 
-constexpr u8 VERSION_MAJOR = 10;
-constexpr u8 VERSION_MINOR = 0;
-constexpr u8 VERSION_MICRO = 2;
+constexpr u8 VERSION_MAJOR = 5;
+constexpr u8 VERSION_MINOR = 1;
+constexpr u8 VERSION_MICRO = 0;
 
-constexpr u8 REVISION_MAJOR = 1;
+constexpr u8 REVISION_MAJOR = 3;
 constexpr u8 REVISION_MINOR = 0;
 
 constexpr char PLATFORM_STRING[] = "NX";
-constexpr char VERSION_HASH[] = "f90143fa8bbc061d4f68c35f95f04f8080c0ecdc";
-constexpr char DISPLAY_VERSION[] = "10.0.2";
-constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 10.0.2-1.0";
+constexpr char VERSION_HASH[] = "23f9df53e25709d756e0c76effcb2473bd3447dd";
+constexpr char DISPLAY_VERSION[] = "5.1.0";
+constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 5.1.0-3.0";
 
 } // namespace SystemVersionData
 

src/core/frontend/emu_window.cpp

@@ -46,7 +46,7 @@ private:
 EmuWindow::EmuWindow() {
     // TODO: Find a better place to set this.
     config.min_client_area_size =
-        std::make_pair(Layout::MinimumSize::Width, Layout::MinimumSize::Height);
+        std::make_pair(Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height);
     active_config = config;
     touch_state = std::make_shared<TouchState>();
     Input::RegisterFactory<Input::TouchDevice>("emu_window", touch_state);

src/core/frontend/framebuffer_layout.h

@@ -8,11 +8,6 @@
 
 namespace Layout {
 
-namespace MinimumSize {
-constexpr u32 Width = 640;
-constexpr u32 Height = 360;
-} // namespace MinimumSize
-
 namespace ScreenUndocked {
 constexpr u32 Width = 1280;
 constexpr u32 Height = 720;

src/core/gdbstub/gdbstub.cpp

@@ -1389,9 +1389,10 @@ void SendTrap(Kernel::Thread* thread, int trap) {
         return;
     }
 
-    current_thread = thread;
-    SendSignal(thread, trap);
-
+    if (!halt_loop || current_thread == thread) {
+        current_thread = thread;
+        SendSignal(thread, trap);
+    }
     halt_loop = true;
     send_trap = false;
 }

src/core/hle/kernel/handle_table.cpp

@@ -30,7 +30,6 @@ HandleTable::~HandleTable() = default;
 
 ResultCode HandleTable::SetSize(s32 handle_table_size) {
     if (static_cast<u32>(handle_table_size) > MAX_COUNT) {
-        LOG_ERROR(Kernel, "Handle table size {} is greater than {}", handle_table_size, MAX_COUNT);
         return ERR_OUT_OF_MEMORY;
     }
 
@@ -81,7 +80,6 @@ ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
 
 ResultCode HandleTable::Close(Handle handle) {
     if (!IsValid(handle)) {
-        LOG_ERROR(Kernel, "Handle is not valid! handle={:08X}", handle);
         return ERR_INVALID_HANDLE;
     }
 

src/core/hle/kernel/hle_ipc.cpp

@@ -13,6 +13,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
@@ -56,6 +57,7 @@ std::shared_ptr<WritableEvent> HLERequestContext::SleepClientThread(
             return true;
         });
 
+    auto& kernel = Core::System::GetInstance().Kernel();
     if (!writable_event) {
         // Create event if not provided
         const auto pair = WritableEvent::CreateEventPair(kernel, "HLE Pause Event: " + reason);
@@ -77,11 +79,9 @@ std::shared_ptr<WritableEvent> HLERequestContext::SleepClientThread(
     return writable_event;
 }
 
-HLERequestContext::HLERequestContext(KernelCore& kernel, Core::Memory::Memory& memory,
-                                     std::shared_ptr<ServerSession> server_session,
+HLERequestContext::HLERequestContext(std::shared_ptr<Kernel::ServerSession> server_session,
                                      std::shared_ptr<Thread> thread)
-    : server_session(std::move(server_session)),
-      thread(std::move(thread)), kernel{kernel}, memory{memory} {
+    : server_session(std::move(server_session)), thread(std::move(thread)) {
     cmd_buf[0] = 0;
 }
 
@@ -216,6 +216,7 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const HandleTabl
 ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
     auto& owner_process = *thread.GetOwnerProcess();
     auto& handle_table = owner_process.GetHandleTable();
+    auto& memory = Core::System::GetInstance().Memory();
 
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> dst_cmdbuf;
     memory.ReadBlock(owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
@@ -281,18 +282,19 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
     return RESULT_SUCCESS;
 }
 
-std::vector<u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
+std::vector<u8> HLERequestContext::ReadBuffer(int buffer_index) const {
     std::vector<u8> buffer;
-    const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
+    const bool is_buffer_a{BufferDescriptorA().size() > std::size_t(buffer_index) &&
                            BufferDescriptorA()[buffer_index].Size()};
+    auto& memory = Core::System::GetInstance().Memory();
 
     if (is_buffer_a) {
-        ASSERT_MSG(BufferDescriptorA().size() > buffer_index,
+        ASSERT_MSG(BufferDescriptorA().size() > std::size_t(buffer_index),
                    "BufferDescriptorA invalid buffer_index {}", buffer_index);
         buffer.resize(BufferDescriptorA()[buffer_index].Size());
         memory.ReadBlock(BufferDescriptorA()[buffer_index].Address(), buffer.data(), buffer.size());
     } else {
-        ASSERT_MSG(BufferDescriptorX().size() > buffer_index,
+        ASSERT_MSG(BufferDescriptorX().size() > std::size_t(buffer_index),
                    "BufferDescriptorX invalid buffer_index {}", buffer_index);
         buffer.resize(BufferDescriptorX()[buffer_index].Size());
         memory.ReadBlock(BufferDescriptorX()[buffer_index].Address(), buffer.data(), buffer.size());
@@ -302,13 +304,13 @@ std::vector<u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
 }
 
 std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
-                                           std::size_t buffer_index) const {
+                                           int buffer_index) const {
     if (size == 0) {
         LOG_WARNING(Core, "skip empty buffer write");
         return 0;
     }
 
-    const bool is_buffer_b{BufferDescriptorB().size() > buffer_index &&
+    const bool is_buffer_b{BufferDescriptorB().size() > std::size_t(buffer_index) &&
                            BufferDescriptorB()[buffer_index].Size()};
     const std::size_t buffer_size{GetWriteBufferSize(buffer_index)};
     if (size > buffer_size) {
@@ -317,14 +319,15 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
         size = buffer_size; // TODO(bunnei): This needs to be HW tested
     }
 
+    auto& memory = Core::System::GetInstance().Memory();
     if (is_buffer_b) {
-        ASSERT_MSG(BufferDescriptorB().size() > buffer_index,
+        ASSERT_MSG(BufferDescriptorB().size() > std::size_t(buffer_index),
                    "BufferDescriptorB invalid buffer_index {}", buffer_index);
         ASSERT_MSG(BufferDescriptorB()[buffer_index].Size() >= size,
                    "BufferDescriptorB buffer_index {} is not large enough", buffer_index);
         memory.WriteBlock(BufferDescriptorB()[buffer_index].Address(), buffer, size);
     } else {
-        ASSERT_MSG(BufferDescriptorC().size() > buffer_index,
+        ASSERT_MSG(BufferDescriptorC().size() > std::size_t(buffer_index),
                    "BufferDescriptorC invalid buffer_index {}", buffer_index);
         ASSERT_MSG(BufferDescriptorC()[buffer_index].Size() >= size,
                    "BufferDescriptorC buffer_index {} is not large enough", buffer_index);
@@ -334,17 +337,17 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
     return size;
 }
 
-std::size_t HLERequestContext::GetReadBufferSize(std::size_t buffer_index) const {
-    const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
+std::size_t HLERequestContext::GetReadBufferSize(int buffer_index) const {
+    const bool is_buffer_a{BufferDescriptorA().size() > std::size_t(buffer_index) &&
                            BufferDescriptorA()[buffer_index].Size()};
     if (is_buffer_a) {
-        ASSERT_MSG(BufferDescriptorA().size() > buffer_index,
+        ASSERT_MSG(BufferDescriptorA().size() > std::size_t(buffer_index),
                    "BufferDescriptorA invalid buffer_index {}", buffer_index);
         ASSERT_MSG(BufferDescriptorA()[buffer_index].Size() > 0,
                    "BufferDescriptorA buffer_index {} is empty", buffer_index);
         return BufferDescriptorA()[buffer_index].Size();
     } else {
-        ASSERT_MSG(BufferDescriptorX().size() > buffer_index,
+        ASSERT_MSG(BufferDescriptorX().size() > std::size_t(buffer_index),
                    "BufferDescriptorX invalid buffer_index {}", buffer_index);
         ASSERT_MSG(BufferDescriptorX()[buffer_index].Size() > 0,
                    "BufferDescriptorX buffer_index {} is empty", buffer_index);
@@ -352,15 +355,15 @@ std::size_t HLERequestContext::GetReadBufferSize(std::size_t buffer_index) const
     }
 }
 
-std::size_t HLERequestContext::GetWriteBufferSize(std::size_t buffer_index) const {
-    const bool is_buffer_b{BufferDescriptorB().size() > buffer_index &&
+std::size_t HLERequestContext::GetWriteBufferSize(int buffer_index) const {
+    const bool is_buffer_b{BufferDescriptorB().size() > std::size_t(buffer_index) &&
                            BufferDescriptorB()[buffer_index].Size()};
     if (is_buffer_b) {
-        ASSERT_MSG(BufferDescriptorB().size() > buffer_index,
+        ASSERT_MSG(BufferDescriptorB().size() > std::size_t(buffer_index),
                    "BufferDescriptorB invalid buffer_index {}", buffer_index);
         return BufferDescriptorB()[buffer_index].Size();
     } else {
-        ASSERT_MSG(BufferDescriptorC().size() > buffer_index,
+        ASSERT_MSG(BufferDescriptorC().size() > std::size_t(buffer_index),
                    "BufferDescriptorC invalid buffer_index {}", buffer_index);
         return BufferDescriptorC()[buffer_index].Size();
     }

src/core/hle/kernel/hle_ipc.h

@@ -19,10 +19,6 @@
 
 union ResultCode;
 
-namespace Core::Memory {
-class Memory;
-}
-
 namespace Service {
 class ServiceFrameworkBase;
 }
@@ -32,7 +28,6 @@ namespace Kernel {
 class Domain;
 class HandleTable;
 class HLERequestContext;
-class KernelCore;
 class Process;
 class ServerSession;
 class Thread;
@@ -103,8 +98,7 @@ protected:
  */
 class HLERequestContext {
 public:
-    explicit HLERequestContext(KernelCore& kernel, Core::Memory::Memory& memory,
-                               std::shared_ptr<ServerSession> session,
+    explicit HLERequestContext(std::shared_ptr<ServerSession> session,
                                std::shared_ptr<Thread> thread);
     ~HLERequestContext();
 
@@ -185,11 +179,10 @@ public:
     }
 
     /// Helper function to read a buffer using the appropriate buffer descriptor
-    std::vector<u8> ReadBuffer(std::size_t buffer_index = 0) const;
+    std::vector<u8> ReadBuffer(int buffer_index = 0) const;
 
     /// Helper function to write a buffer using the appropriate buffer descriptor
-    std::size_t WriteBuffer(const void* buffer, std::size_t size,
-                            std::size_t buffer_index = 0) const;
+    std::size_t WriteBuffer(const void* buffer, std::size_t size, int buffer_index = 0) const;
 
     /* Helper function to write a buffer using the appropriate buffer descriptor
      *
@@ -201,8 +194,7 @@ public:
      */
     template <typename ContiguousContainer,
               typename = std::enable_if_t<!std::is_pointer_v<ContiguousContainer>>>
-    std::size_t WriteBuffer(const ContiguousContainer& container,
-                            std::size_t buffer_index = 0) const {
+    std::size_t WriteBuffer(const ContiguousContainer& container, int buffer_index = 0) const {
         using ContiguousType = typename ContiguousContainer::value_type;
 
         static_assert(std::is_trivially_copyable_v<ContiguousType>,
@@ -213,10 +205,10 @@ public:
     }
 
     /// Helper function to get the size of the input buffer
-    std::size_t GetReadBufferSize(std::size_t buffer_index = 0) const;
+    std::size_t GetReadBufferSize(int buffer_index = 0) const;
 
     /// Helper function to get the size of the output buffer
-    std::size_t GetWriteBufferSize(std::size_t buffer_index = 0) const;
+    std::size_t GetWriteBufferSize(int buffer_index = 0) const;
 
     template <typename T>
     std::shared_ptr<T> GetCopyObject(std::size_t index) {
@@ -311,9 +303,6 @@ private:
 
     std::vector<std::shared_ptr<SessionRequestHandler>> domain_request_handlers;
     bool is_thread_waiting{};
-
-    KernelCore& kernel;
-    Core::Memory::Memory& memory;
 };
 
 } // namespace Kernel

src/core/hle/kernel/memory/address_space_info.cpp

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
 
 #include <array>
 
@@ -49,18 +49,18 @@ constexpr bool IsAllowedIndexForAddress(std::size_t index) {
     return index < std::size(AddressSpaceInfos) && AddressSpaceInfos[index].GetAddress() != Invalid;
 }
 
-constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
-    AddressSpaceIndices32Bit{
+constexpr std::size_t
+    AddressSpaceIndices32Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
         0, 1, 0, 2, 0, 3,
     };
 
-constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
-    AddressSpaceIndices36Bit{
+constexpr std::size_t
+    AddressSpaceIndices36Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
         4, 5, 4, 6, 4, 7,
     };
 
-constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
-    AddressSpaceIndices39Bit{
+constexpr std::size_t
+    AddressSpaceIndices39Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
         9, 8, 8, 10, 12, 11,
     };
 

src/core/hle/kernel/memory/address_space_info.h

@@ -2,11 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
 
 #pragma once
 
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Kernel::Memory {

src/core/hle/kernel/memory/memory_block.h

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
 
 #pragma once
 

src/core/hle/kernel/memory/memory_block_manager.cpp

@@ -67,6 +67,7 @@ void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState p
                                 MemoryPermission prev_perm, MemoryAttribute prev_attribute,
                                 MemoryState state, MemoryPermission perm,
                                 MemoryAttribute attribute) {
+    const std::size_t prev_count{memory_block_tree.size()};
     const VAddr end_addr{addr + num_pages * PageSize};
     iterator node{memory_block_tree.begin()};
 
@@ -108,6 +109,7 @@ void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState p
 
 void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState state,
                                 MemoryPermission perm, MemoryAttribute attribute) {
+    const std::size_t prev_count{memory_block_tree.size()};
     const VAddr end_addr{addr + num_pages * PageSize};
     iterator node{memory_block_tree.begin()};
 
@@ -143,6 +145,7 @@ void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState s
 
 void MemoryBlockManager::UpdateLock(VAddr addr, std::size_t num_pages, LockFunc&& lock_func,
                                     MemoryPermission perm) {
+    const std::size_t prev_count{memory_block_tree.size()};
     const VAddr end_addr{addr + num_pages * PageSize};
     iterator node{memory_block_tree.begin()};
 

src/core/hle/kernel/memory/memory_block_manager.h

@@ -6,6 +6,7 @@
 
 #include <functional>
 #include <list>
+#include <memory>
 
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/memory_block.h"

src/core/hle/kernel/memory/memory_manager.cpp

@@ -104,9 +104,9 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
     // Ensure that we don't leave anything un-freed
     auto group_guard = detail::ScopeExit([&] {
         for (const auto& it : page_list.Nodes()) {
-            const auto min_num_pages{std::min(
+            const auto num_pages{std::min(
                 it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-            chosen_manager.Free(it.GetAddress(), min_num_pages);
+            chosen_manager.Free(it.GetAddress(), num_pages);
         }
     });
 
@@ -165,9 +165,9 @@ ResultCode MemoryManager::Free(PageLinkedList& page_list, std::size_t num_pages,
 
     // Free all of the pages
     for (const auto& it : page_list.Nodes()) {
-        const auto min_num_pages{std::min(
+        const auto num_pages{std::min(
             it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-        chosen_manager.Free(it.GetAddress(), min_num_pages);
+        chosen_manager.Free(it.GetAddress(), num_pages);
     }
 
     return RESULT_SUCCESS;

src/core/hle/kernel/memory/memory_manager.h

@@ -7,6 +7,7 @@
 #include <array>
 #include <mutex>
 
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/page_heap.h"
 #include "core/hle/result.h"

src/core/hle/kernel/memory/page_heap.cpp

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
 
 #include "core/core.h"
 #include "core/hle/kernel/memory/page_heap.h"

src/core/hle/kernel/memory/page_heap.h

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
 
 #pragma once
 

src/core/hle/kernel/memory/page_linked_list.h

@@ -7,6 +7,7 @@
 #include <list>
 
 #include "common/assert.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/memory_types.h"
 #include "core/hle/result.h"

src/core/hle/kernel/memory/page_table.cpp

@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
+#include "core/device_memory.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory/address_space_info.h"
@@ -853,7 +854,7 @@ ResultCode PageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
     }
 
     block_manager->UpdateLock(addr, size / PageSize,
-                              [](MemoryBlockManager::iterator block, MemoryPermission perm) {
+                              [perm](MemoryBlockManager::iterator block, MemoryPermission perm) {
                                   block->ShareToDevice(perm);
                               },
                               perm);
@@ -875,7 +876,7 @@ ResultCode PageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size)
     }
 
     block_manager->UpdateLock(addr, size / PageSize,
-                              [](MemoryBlockManager::iterator block, MemoryPermission perm) {
+                              [perm](MemoryBlockManager::iterator block, MemoryPermission perm) {
                                   block->UnshareToDevice(perm);
                               },
                               perm);

src/core/hle/kernel/memory/page_table.h

@@ -4,15 +4,16 @@
 
 #pragma once
 
+#include <list>
 #include <memory>
 #include <mutex>
 
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/page_table.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/memory/memory_block.h"
 #include "core/hle/kernel/memory/memory_manager.h"
-#include "core/hle/result.h"
 
 namespace Core {
 class System;

src/core/hle/kernel/memory/slab_heap.h

@@ -2,14 +2,15 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
 
 #pragma once
 
 #include <atomic>
 
 #include "common/assert.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Kernel::Memory {
@@ -50,7 +51,7 @@ public:
     }
 
     void Free(void* obj) {
-        Node* node = static_cast<Node*>(obj);
+        Node* node = reinterpret_cast<Node*>(obj);
 
         Node* cur_head = head.load();
         do {
@@ -144,7 +145,7 @@ public:
     }
 
     T* Allocate() {
-        T* obj = static_cast<T*>(AllocateImpl());
+        T* obj = reinterpret_cast<T*>(AllocateImpl());
         if (obj != nullptr) {
             new (obj) T();
         }

src/core/hle/kernel/memory/system_control.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#pragma once
+
 #include <random>
 
 #include "core/hle/kernel/memory/system_control.h"

src/core/hle/kernel/mutex.cpp

@@ -7,7 +7,6 @@
 #include <vector>
 
 #include "common/assert.h"
-#include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
@@ -68,7 +67,6 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
                              Handle requesting_thread_handle) {
     // The mutex address must be 4-byte aligned
     if ((address % sizeof(u32)) != 0) {
-        LOG_ERROR(Kernel, "Address is not 4-byte aligned! address={:016X}", address);
         return ERR_INVALID_ADDRESS;
     }
 
@@ -90,8 +88,6 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
     }
 
     if (holding_thread == nullptr) {
-        LOG_ERROR(Kernel, "Holding thread does not exist! thread_handle={:08X}",
-                  holding_thread_handle);
         return ERR_INVALID_HANDLE;
     }
 
@@ -113,7 +109,6 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
 ResultCode Mutex::Release(VAddr address) {
     // The mutex address must be 4-byte aligned
     if ((address % sizeof(u32)) != 0) {
-        LOG_ERROR(Kernel, "Address is not 4-byte aligned! address={:016X}", address);
         return ERR_INVALID_ADDRESS;
     }
 

src/core/hle/kernel/physical_core.cpp

@@ -27,9 +27,7 @@ PhysicalCore::PhysicalCore(Core::System& system, std::size_t id,
         std::make_unique<Core::ARM_Dynarmic_64>(system, exclusive_monitor, core_index);
 
 #else
-    using Core::ARM_Unicorn;
-    arm_interface_32 = std::make_unique<ARM_Unicorn>(system, ARM_Unicorn::Arch::AArch32);
-    arm_interface_64 = std::make_unique<ARM_Unicorn>(system, ARM_Unicorn::Arch::AArch64);
+    arm_interface = std::make_shared<Core::ARM_Unicorn>(system);
     LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
 

src/core/hle/kernel/process.cpp

@@ -132,8 +132,7 @@ std::shared_ptr<ResourceLimit> Process::GetResourceLimit() const {
 
 u64 Process::GetTotalPhysicalMemoryAvailable() const {
     const u64 capacity{resource_limit->GetCurrentResourceValue(ResourceType::PhysicalMemory) +
-                       page_table->GetTotalHeapSize() + GetSystemResourceSize() + image_size +
-                       main_thread_stack_size};
+                       page_table->GetTotalHeapSize() + image_size + main_thread_stack_size};
 
     if (capacity < memory_usage_capacity) {
         return capacity;
@@ -147,8 +146,7 @@ u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
 }
 
 u64 Process::GetTotalPhysicalMemoryUsed() const {
-    return image_size + main_thread_stack_size + page_table->GetTotalHeapSize() +
-           GetSystemResourceSize();
+    return image_size + main_thread_stack_size + page_table->GetTotalHeapSize();
 }
 
 u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {

src/core/hle/kernel/process_capability.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/bit_util.h"
-#include "common/logging/log.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/memory/page_table.h"
@@ -120,30 +119,22 @@ ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
             // The MapPhysical type uses two descriptor flags for its parameters.
             // If there's only one, then there's a problem.
             if (i >= num_capabilities) {
-                LOG_ERROR(Kernel, "Invalid combination! i={}", i);
                 return ERR_INVALID_COMBINATION;
             }
 
             const auto size_flags = capabilities[i];
             if (GetCapabilityType(size_flags) != CapabilityType::MapPhysical) {
-                LOG_ERROR(Kernel, "Invalid capability type! size_flags={}", size_flags);
                 return ERR_INVALID_COMBINATION;
             }
 
             const auto result = HandleMapPhysicalFlags(descriptor, size_flags, page_table);
             if (result.IsError()) {
-                LOG_ERROR(Kernel, "Failed to map physical flags! descriptor={}, size_flags={}",
-                          descriptor, size_flags);
                 return result;
             }
         } else {
             const auto result =
                 ParseSingleFlagCapability(set_flags, set_svc_bits, descriptor, page_table);
             if (result.IsError()) {
-                LOG_ERROR(
-                    Kernel,
-                    "Failed to parse capability flag! set_flags={}, set_svc_bits={}, descriptor={}",
-                    set_flags, set_svc_bits, descriptor);
                 return result;
             }
         }
@@ -171,9 +162,6 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
     const u32 flag_length = GetFlagBitOffset(type);
     const u32 set_flag = 1U << flag_length;
     if ((set_flag & set_flags & InitializeOnceMask) != 0) {
-        LOG_ERROR(Kernel,
-                  "Attempted to initialize flags that may only be initialized once. set_flags={}",
-                  set_flags);
         return ERR_INVALID_COMBINATION;
     }
     set_flags |= set_flag;
@@ -199,7 +187,6 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
         break;
     }
 
-    LOG_ERROR(Kernel, "Invalid capability type! type={}", static_cast<u32>(type));
     return ERR_INVALID_CAPABILITY_DESCRIPTOR;
 }
 
@@ -221,31 +208,23 @@ void ProcessCapabilities::Clear() {
 
 ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
     if (priority_mask != 0 || core_mask != 0) {
-        LOG_ERROR(Kernel, "Core or priority mask are not zero! priority_mask={}, core_mask={}",
-                  priority_mask, core_mask);
         return ERR_INVALID_CAPABILITY_DESCRIPTOR;
     }
 
     const u32 core_num_min = (flags >> 16) & 0xFF;
     const u32 core_num_max = (flags >> 24) & 0xFF;
     if (core_num_min > core_num_max) {
-        LOG_ERROR(Kernel, "Core min is greater than core max! core_num_min={}, core_num_max={}",
-                  core_num_min, core_num_max);
         return ERR_INVALID_COMBINATION;
     }
 
     const u32 priority_min = (flags >> 10) & 0x3F;
     const u32 priority_max = (flags >> 4) & 0x3F;
     if (priority_min > priority_max) {
-        LOG_ERROR(Kernel,
-                  "Priority min is greater than priority max! priority_min={}, priority_max={}",
-                  core_num_min, priority_max);
         return ERR_INVALID_COMBINATION;
     }
 
     // The switch only has 4 usable cores.
     if (core_num_max >= 4) {
-        LOG_ERROR(Kernel, "Invalid max cores specified! core_num_max={}", core_num_max);
         return ERR_INVALID_PROCESSOR_ID;
     }
 
@@ -280,7 +259,6 @@ ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags)
         }
 
         if (svc_number >= svc_capabilities.size()) {
-            LOG_ERROR(Kernel, "Process svc capability is out of range! svc_number={}", svc_number);
             return ERR_OUT_OF_RANGE;
         }
 
@@ -317,8 +295,6 @@ ResultCode ProcessCapabilities::HandleInterruptFlags(u32 flags) {
         // emulate that, it's sufficient to mark every interrupt as defined.
 
         if (interrupt >= interrupt_capabilities.size()) {
-            LOG_ERROR(Kernel, "Process interrupt capability is out of range! svc_number={}",
-                      interrupt);
             return ERR_OUT_OF_RANGE;
         }
 
@@ -331,7 +307,6 @@ ResultCode ProcessCapabilities::HandleInterruptFlags(u32 flags) {
 ResultCode ProcessCapabilities::HandleProgramTypeFlags(u32 flags) {
     const u32 reserved = flags >> 17;
     if (reserved != 0) {
-        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
         return ERR_RESERVED_VALUE;
     }
 
@@ -349,9 +324,6 @@ ResultCode ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
     const u32 major_version = kernel_version >> 19;
 
     if (major_version != 0 || flags < 0x80000) {
-        LOG_ERROR(Kernel,
-                  "Kernel version is non zero or flags are too small! major_version={}, flags={}",
-                  major_version, flags);
         return ERR_INVALID_CAPABILITY_DESCRIPTOR;
     }
 
@@ -362,7 +334,6 @@ ResultCode ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
 ResultCode ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
     const u32 reserved = flags >> 26;
     if (reserved != 0) {
-        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
         return ERR_RESERVED_VALUE;
     }
 
@@ -373,7 +344,6 @@ ResultCode ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
 ResultCode ProcessCapabilities::HandleDebugFlags(u32 flags) {
     const u32 reserved = flags >> 19;
     if (reserved != 0) {
-        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
         return ERR_RESERVED_VALUE;
     }
 

src/core/hle/kernel/readable_event.cpp

@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include "common/assert.h"
-#include "common/logging/log.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/readable_event.h"
@@ -24,12 +23,10 @@ void ReadableEvent::Acquire(Thread* thread) {
 }
 
 void ReadableEvent::Signal() {
-    if (is_signaled) {
-        return;
-    }
-
-    is_signaled = true;
-    SynchronizationObject::Signal();
+    if (!is_signaled) {
+        is_signaled = true;
+        SynchronizationObject::Signal();
+    };
 }
 
 void ReadableEvent::Clear() {
@@ -38,8 +35,6 @@ void ReadableEvent::Clear() {
 
 ResultCode ReadableEvent::Reset() {
     if (!is_signaled) {
-        LOG_TRACE(Kernel, "Handle is not signaled! object_id={}, object_type={}, object_name={}",
-                  GetObjectId(), GetTypeName(), GetName());
         return ERR_INVALID_STATE;
     }