"Merge Tagged PR 1012"

"Merge Tagged PR 1340"
"Merge Tagged PR 1703"
2020-01-30 13:01:11 +00:00 · 2020-01-30 13:01:10 +00:00 · 2020-01-30 13:01:09 +00:00 · 2020-01-30 13:01:08 +00:00
552 changed files with 16053 additions and 31556 deletions
@@ -29,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
@@ -4,7 +4,7 @@ parameters:
  version: ''

 steps:
- 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 ..
+- script: mkdir build && cd build && cmake -G "Visual Studio 15 2017 Win64" --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'
@@ -45,7 +45,7 @@ stages:
  - job: build
    displayName: 'msvc'
    pool:
-      vmImage: windows-2019
+      vmImage: vs2017-win2016
    steps:
    - template: ./templates/sync-source.yml
      parameters:
@@ -22,7 +22,7 @@ stages:
  - job: build
    displayName: 'windows-msvc'
    pool:
-      vmImage: windows-2019
+      vmImage: vs2017-win2016
    steps:
    - template: ./templates/sync-source.yml
      parameters:
@@ -151,22 +151,15 @@ if (ENABLE_SDL2)
        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")
+    else()
+        find_package(SDL2 REQUIRED)
+    endif()

+    if (SDL2_FOUND)
+        # TODO(yuriks): Make FindSDL2.cmake export an IMPORTED library instead
        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(SYSTEM ${SDL2_INCLUDE_DIRS})
-        add_library(SDL2 INTERFACE)
-        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
    endif()
 else()
    set(SDL2_FOUND NO)
@@ -6,9 +6,9 @@ function(copy_yuzu_Qt5_deps target_dir)
    set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
    set(Qt5_IMAGEFORMATS_DIR "${Qt5_DIR}/../../../plugins/imageformats/")
    set(Qt5_RESOURCES_DIR "${Qt5_DIR}/../../../resources/")
-    set(PLATFORMS ${DLL_DEST}plugins/platforms/)
-    set(STYLES ${DLL_DEST}plugins/styles/)
-    set(IMAGEFORMATS ${DLL_DEST}plugins/imageformats/)
+    set(PLATFORMS ${DLL_DEST}platforms/)
+    set(STYLES ${DLL_DEST}styles/)
+    set(IMAGEFORMATS ${DLL_DEST}imageformats/)
    windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
        icudt*.dll
        icuin*.dll
@@ -42,15 +42,11 @@ function(copy_yuzu_Qt5_deps target_dir)
            icudtl.dat
        )
    endif ()
+
    windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
    windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
    windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS}
        qjpeg$<$<CONFIG:Debug>:d>.*
        qgif$<$<CONFIG:Debug>:d>.*
        )
-    # Create an empty qt.conf file. Qt will detect that this file exists, and use the folder that its in as the root folder.
-    # This way it'll look for plugins in the root/plugins/ folder
-    add_custom_command(TARGET yuzu POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E touch ${DLL_DEST}qt.conf
-    )
 endfunction(copy_yuzu_Qt5_deps)
@@ -57,6 +57,8 @@ set(HASH_FILES
    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.h"
    "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
    "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
    "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
@@ -89,6 +91,8 @@ set(HASH_FILES
    "${VIDEO_CORE}/shader/ast.h"
    "${VIDEO_CORE}/shader/compiler_settings.cpp"
    "${VIDEO_CORE}/shader/compiler_settings.h"
+    "${VIDEO_CORE}/shader/const_buffer_locker.cpp"
+    "${VIDEO_CORE}/shader/const_buffer_locker.h"
    "${VIDEO_CORE}/shader/control_flow.cpp"
    "${VIDEO_CORE}/shader/control_flow.h"
    "${VIDEO_CORE}/shader/decode.cpp"
@@ -97,13 +101,9 @@ set(HASH_FILES
    "${VIDEO_CORE}/shader/node.h"
    "${VIDEO_CORE}/shader/node_helper.cpp"
    "${VIDEO_CORE}/shader/node_helper.h"
-    "${VIDEO_CORE}/shader/registry.cpp"
-    "${VIDEO_CORE}/shader/registry.h"
    "${VIDEO_CORE}/shader/shader_ir.cpp"
    "${VIDEO_CORE}/shader/shader_ir.h"
    "${VIDEO_CORE}/shader/track.cpp"
-    "${VIDEO_CORE}/shader/transform_feedback.cpp"
-    "${VIDEO_CORE}/shader/transform_feedback.h"
 )
 set(COMBINED "")
 foreach (F IN LISTS HASH_FILES)
@@ -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
@@ -1,8 +1,7 @@
 yuzu emulator
 =============
-[![Travis CI Build Status](https://travis-ci.com/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.com/yuzu-emu/yuzu)
+[![Travis CI Build Status](https://travis-ci.org/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.org/yuzu-emu/yuzu)
 [![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
-[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.gg/XQV6dn9)

 yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).

@@ -22,7 +21,7 @@ For development discussion, please join us on [Discord](https://discord.gg/XQV6d

 Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted.

-If you want to contribute please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should also contact any of the developers on Discord in order to know about the current state of the emulator.
+If you want to contribute please take a look at the [Contributor's Guide](CONTRIBUTING.md) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should as well contact any of the developers on Discord in order to know about the current state of the emulator.

 ### Building

@@ -2,8 +2,8 @@ The icons in this folder and its subfolders have the following licenses:

 Icon Name | License | Origin/Author
 --- | --- | ---
-qt_themes/default/icons/16x16/checked.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/default/icons/16x16/failed.png | CC BY-ND 3.0 | https://icons8.com
+qt_themes/default/icons/16x16/checked.png | Free for non-commercial use
+qt_themes/default/icons/16x16/failed.png | Free for non-commercial use
 qt_themes/default/icons/16x16/lock.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/256x256/plus_folder.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/48x48/bad_folder.png | CC BY-ND 3.0 | https://icons8.com
@@ -11,6 +11,8 @@ qt_themes/default/icons/48x48/chip.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/48x48/folder.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/48x48/plus.png | CC0 1.0 | Designed by BreadFish64 from the Citra team
 qt_themes/default/icons/48x48/sd_card.png | CC BY-ND 3.0 | https://icons8.com
+qt_themes/qdarkstyle/icons/16x16/checked.png | Free for non-commercial use
+qt_themes/qdarkstyle/icons/16x16/failed.png | Free for non-commercial use
 qt_themes/qdarkstyle/icons/16x16/lock.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/qdarkstyle/icons/256x256/plus_folder.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/qdarkstyle/icons/48x48/bad_folder.png | CC BY-ND 3.0 | https://icons8.com
@@ -10,6 +10,6 @@
        <file alias="256x256/plus_folder.png">icons/256x256/plus_folder.png</file>
    </qresource>
    <qresource prefix="colorful">
-        <file alias="style.qss">../default/style.qss</file>
+        <file>style.qss</file>
    </qresource>
 </RCC>
@@ -0,0 +1,4 @@
+/*
+    This file is intentionally left blank.
+    We do not want to apply any stylesheet for colorful, only icons.
+*/
@@ -1,18 +1,25 @@
 <RCC>
    <qresource prefix="icons/default">
        <file alias="index.theme">icons/index.theme</file>
+      
        <file alias="16x16/checked.png">icons/16x16/checked.png</file>
+
        <file alias="16x16/failed.png">icons/16x16/failed.png</file>
+
        <file alias="16x16/lock.png">icons/16x16/lock.png</file>
+
        <file alias="48x48/bad_folder.png">icons/48x48/bad_folder.png</file>
+      
        <file alias="48x48/chip.png">icons/48x48/chip.png</file>
+
        <file alias="48x48/folder.png">icons/48x48/folder.png</file>
+
        <file alias="48x48/plus.png">icons/48x48/plus.png</file>
+      
        <file alias="48x48/sd_card.png">icons/48x48/sd_card.png</file>
+      
        <file alias="256x256/yuzu.png">icons/256x256/yuzu.png</file>
+
        <file alias="256x256/plus_folder.png">icons/256x256/plus_folder.png</file>
    </qresource>
-    <qresource prefix="default">
-        <file>style.qss</file>
-    </qresource>
 </RCC>
@@ -1,35 +0,0 @@
-QPushButton#TogglableStatusBarButton {
-    color: #959595;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#TogglableStatusBarButton:checked {
-    color: #000000;
-}
-
-QPushButton#TogglableStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#RendererStatusBarButton {
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#RendererStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#RendererStatusBarButton:checked {
-    color: #e85c00;
-}
-
-QPushButton#RendererStatusBarButton:!checked{
-    color: #0066ff;
-}
@@ -1236,41 +1236,3 @@ QToolButton:disabled,
 QPlainTextEdit:disabled {
    background-color: #2b2e31;
 }
-
-QPushButton#TogglableStatusBarButton {
-    min-width: 0px;
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#TogglableStatusBarButton:checked {
-    color: #ffffff;
-}
-
-QPushButton#TogglableStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#RendererStatusBarButton {
-    min-width: 0px;
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#RendererStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#RendererStatusBarButton:checked {
-    color: #e85c00;
-}
-
-QPushButton#RendererStatusBarButton:!checked{
-   color: #00ccdd;
-}
@@ -3,27 +3,13 @@
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/CMakeModules)
 include(DownloadExternals)

-# 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.2.0)
-if (FMT_FOUND)
-    add_library(fmt::fmt ALIAS PkgConfig::FMT)
-else()
-    message(STATUS "fmt 6.2.0 or newer not found, falling back to externals")
-    add_subdirectory(fmt)
-    add_library(fmt::fmt ALIAS fmt)
-endif()
+add_subdirectory(fmt)
+add_library(fmt::fmt ALIAS fmt)

 # Dynarmic
 if (ARCHITECTURE_x86_64)
@@ -44,15 +30,9 @@ add_subdirectory(glad)
 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()
+set(LZ4_BUNDLED_MODE ON)
+add_subdirectory(lz4/contrib/cmake_unofficial EXCLUDE_FROM_ALL)
+target_include_directories(lz4_static INTERFACE ./lz4/lib)

 # mbedtls
 add_subdirectory(mbedtls EXCLUDE_FROM_ALL)
@@ -67,27 +47,15 @@ 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()
+add_subdirectory(zstd/build/cmake EXCLUDE_FROM_ALL)
+target_include_directories(libzstd_static INTERFACE ./zstd/lib)

 # 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()
+add_subdirectory(opus)
+target_include_directories(opus INTERFACE ./opus/include)

 # Cubeb
 if(ENABLE_CUBEB)
@@ -107,35 +75,18 @@ if (ENABLE_VULKAN)
 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()
+add_subdirectory(zlib EXCLUDE_FROM_ALL)
+set(ZLIB_LIBRARIES z)

 # libzip
-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()
+add_subdirectory(libzip EXCLUDE_FROM_ALL)

 if (ENABLE_WEB_SERVICE)
    # LibreSSL
-    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()
+    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)

    # lurlparser
    add_subdirectory(lurlparser EXCLUDE_FROM_ALL)
@@ -143,8 +94,6 @@ if (ENABLE_WEB_SERVICE)
    # httplib
    add_library(httplib INTERFACE)
    target_include_directories(httplib INTERFACE ./httplib)
-    target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
-    target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})

    # JSON
    add_library(json-headers INTERFACE)
@@ -0,0 +1,239 @@
+
+# This module defines
+# SDL2_LIBRARY, the name of the library to link against
+# SDL2_FOUND, if false, do not try to link to SDL2
+# SDL2_INCLUDE_DIR, where to find SDL.h
+# SDL2_DLL_DIR, where to find SDL2.dll if it exists
+#
+# This module responds to the the flag:
+# SDL2_BUILDING_LIBRARY
+# If this is defined, then no SDL2main will be linked in because
+# only applications need main().
+# Otherwise, it is assumed you are building an application and this
+# module will attempt to locate and set the the proper link flags
+# as part of the returned SDL2_LIBRARY variable.
+#
+# Don't forget to include SDLmain.h and SDLmain.m your project for the
+# OS X framework based version. (Other versions link to -lSDL2main which
+# this module will try to find on your behalf.) Also for OS X, this
+# module will automatically add the -framework Cocoa on your behalf.
+#
+#
+# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
+# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
+# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
+# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
+# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
+# as appropriate. These values are used to generate the final SDL2_LIBRARY
+# variable, but when these values are unset, SDL2_LIBRARY does not get created.
+#
+#
+# $SDL2DIR is an environment variable that would
+# correspond to the ./configure --prefix=$SDL2DIR
+# used in building SDL2.
+# l.e.galup  9-20-02
+#
+# Modified by Eric Wing.
+# Added code to assist with automated building by using environmental variables
+# and providing a more controlled/consistent search behavior.
+# Added new modifications to recognize OS X frameworks and
+# additional Unix paths (FreeBSD, etc).
+# Also corrected the header search path to follow "proper" SDL guidelines.
+# Added a search for SDL2main which is needed by some platforms.
+# Added a search for threads which is needed by some platforms.
+# Added needed compile switches for MinGW.
+#
+# On OSX, this will prefer the Framework version (if found) over others.
+# People will have to manually change the cache values of
+# SDL2_LIBRARY to override this selection or set the CMake environment
+# CMAKE_INCLUDE_PATH to modify the search paths.
+#
+# Note that the header path has changed from SDL2/SDL.h to just SDL.h
+# This needed to change because "proper" SDL convention
+# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
+# reasons because not all systems place things in SDL2/ (see FreeBSD).
+
+#=============================================================================
+# Copyright 2003-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License").
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# CMake - Cross Platform Makefile Generator
+# Copyright 2000-2016 Kitware, Inc.
+# Copyright 2000-2011 Insight Software Consortium
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 
+# * Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# 
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# 
+# * Neither the names of Kitware, Inc., the Insight Software Consortium,
+#   nor the names of their contributors may be used to endorse or promote
+#   products derived from this software without specific prior written
+#   permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# 
+# ------------------------------------------------------------------------------
+# 
+# The above copyright and license notice applies to distributions of
+# CMake in source and binary form.  Some source files contain additional
+# notices of original copyright by their contributors; see each source
+# for details.  Third-party software packages supplied with CMake under
+# compatible licenses provide their own copyright notices documented in
+# corresponding subdirectories.
+# 
+# ------------------------------------------------------------------------------
+# 
+# CMake was initially developed by Kitware with the following sponsorship:
+# 
+#  * National Library of Medicine at the National Institutes of Health
+#    as part of the Insight Segmentation and Registration Toolkit (ITK).
+# 
+#  * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel
+#    Visualization Initiative.
+# 
+#  * National Alliance for Medical Image Computing (NAMIC) is funded by the
+#    National Institutes of Health through the NIH Roadmap for Medical Research,
+#    Grant U54 EB005149.
+# 
+#  * Kitware, Inc.
+#
+
+message("<FindSDL2.cmake>")
+
+SET(SDL2_SEARCH_PATHS
+    ~/Library/Frameworks
+    /Library/Frameworks
+    /usr/local
+    /usr
+    /sw # Fink
+    /opt/local # DarwinPorts
+    /opt/csw # Blastwave
+    /opt
+    ${SDL2_PATH}
+)
+
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(VC_LIB_PATH_SUFFIX lib/x64)
+else()
+    set(VC_LIB_PATH_SUFFIX lib/x86)
+endif()
+
+FIND_LIBRARY(SDL2_LIBRARY_TEMP
+    NAMES SDL2
+    HINTS
+    $ENV{SDL2DIR}
+    PATH_SUFFIXES lib64 lib ${VC_LIB_PATH_SUFFIX}
+    PATHS ${SDL2_SEARCH_PATHS}
+)
+
+IF(SDL2_LIBRARY_TEMP)
+    if(MSVC)
+        get_filename_component(SDL2_DLL_DIR_TEMP ${SDL2_LIBRARY_TEMP} DIRECTORY)
+        if(EXISTS ${SDL2_DLL_DIR_TEMP}/SDL2.dll)
+            set(SDL2_DLL_DIR ${SDL2_DLL_DIR_TEMP})
+            unset(SDL2_DLL_DIR_TEMP)
+        endif()
+    endif()
+
+    FIND_PATH(SDL2_INCLUDE_DIR SDL.h
+        HINTS
+        $ENV{SDL2DIR}
+        PATH_SUFFIXES include/SDL2 include
+        PATHS ${SDL2_SEARCH_PATHS}
+    )
+
+    IF(NOT SDL2_BUILDING_LIBRARY)
+        IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
+            # Non-OS X framework versions expect you to also dynamically link to
+            # SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
+            # seem to provide SDL2main for compatibility even though they don't
+            # necessarily need it.
+            FIND_LIBRARY(SDL2MAIN_LIBRARY
+                NAMES SDL2main
+                HINTS
+                $ENV{SDL2DIR}
+                PATH_SUFFIXES lib64 lib
+                PATHS ${SDL2_SEARCH_PATHS}
+            )
+        ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
+    ENDIF(NOT SDL2_BUILDING_LIBRARY)
+
+    # SDL2 may require threads on your system.
+    # The Apple build may not need an explicit flag because one of the
+    # frameworks may already provide it.
+    # But for non-OSX systems, I will use the CMake Threads package.
+    IF(NOT APPLE)
+        FIND_PACKAGE(Threads)
+    ENDIF(NOT APPLE)
+
+    # MinGW needs an additional library, mwindows
+    # It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -lmwindows
+    # (Actually on second look, I think it only needs one of the m* libraries.)
+    IF(MINGW)
+        SET(MINGW32_LIBRARY mingw32 CACHE STRING "mwindows for MinGW")
+    ENDIF(MINGW)
+
+    # For SDL2main
+    IF(NOT SDL2_BUILDING_LIBRARY)
+        IF(SDL2MAIN_LIBRARY)
+            SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
+        ENDIF(SDL2MAIN_LIBRARY)
+    ENDIF(NOT SDL2_BUILDING_LIBRARY)
+
+    # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
+    # CMake doesn't display the -framework Cocoa string in the UI even
+    # though it actually is there if I modify a pre-used variable.
+    # I think it has something to do with the CACHE STRING.
+    # So I use a temporary variable until the end so I can set the
+    # "real" variable in one-shot.
+    IF(APPLE)
+        SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
+    ENDIF(APPLE)
+
+    # For threads, as mentioned Apple doesn't need this.
+    # In fact, there seems to be a problem if I used the Threads package
+    # and try using this line, so I'm just skipping it entirely for OS X.
+    IF(NOT APPLE)
+        SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
+    ENDIF(NOT APPLE)
+
+    # For MinGW library
+    IF(MINGW)
+        SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
+    ENDIF(MINGW)
+
+    # Set the final string here so the GUI reflects the final state.
+    SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL2 Library can be found")
+
+    # Unset the temp variable to INTERNAL so it is not seen in the CMake GUI
+    UNSET(SDL2_LIBRARY_TEMP)
+ENDIF(SDL2_LIBRARY_TEMP)
+
+message("</FindSDL2.cmake>")
+
+INCLUDE(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2 REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)
@@ -1,4 +1,4 @@
-From https://github.com/yhirose/cpp-httplib/tree/fce8e6fefdab4ad48bc5b25c98e5ebfda4f3cf53
+From https://github.com/yhirose/cpp-httplib/commit/d9479bc0b12e8a1e8bce2d34da4feeef488581f3

 MIT License

@@ -243,7 +243,6 @@ typedef uint32_t ThreadIdType;
 #define MICROPROFILE_DEFINE_GPU(var, name, color) MicroProfileToken g_mp_##var = MicroProfileGetToken("GPU", name, color, MicroProfileTokenTypeGpu)
 #define MICROPROFILE_TOKEN_PASTE0(a, b) a ## b
 #define MICROPROFILE_TOKEN_PASTE(a, b)  MICROPROFILE_TOKEN_PASTE0(a,b)
-#define MICROPROFILE_TOKEN(var) g_mp_##var
 #define MICROPROFILE_SCOPE(var) MicroProfileScopeHandler MICROPROFILE_TOKEN_PASTE(foo, __LINE__)(g_mp_##var)
 #define MICROPROFILE_SCOPE_TOKEN(token) MicroProfileScopeHandler MICROPROFILE_TOKEN_PASTE(foo, __LINE__)(token)
 #define MICROPROFILE_SCOPEI(group, name, color) static MicroProfileToken MICROPROFILE_TOKEN_PASTE(g_mp,__LINE__) = MicroProfileGetToken(group, name, color, MicroProfileTokenTypeCpu); MicroProfileScopeHandler MICROPROFILE_TOKEN_PASTE(foo,__LINE__)( MICROPROFILE_TOKEN_PASTE(g_mp,__LINE__))
@@ -828,7 +827,7 @@ inline MicroProfileLogEntry MicroProfileMakeLogIndex(uint64_t nBegin, MicroProfi
    MicroProfileLogEntry Entry =  (nBegin<<62) | ((0x3fff&nToken)<<48) | (MP_LOG_TICK_MASK&nTick);
    int t = MicroProfileLogType(Entry);
    uint64_t nTimerIndex = MicroProfileLogTimerIndex(Entry);
-    MP_ASSERT((uint64_t)t == nBegin);
+    MP_ASSERT(t == nBegin);
    MP_ASSERT(nTimerIndex == (nToken&0x3fff));
    return Entry;

@@ -910,14 +909,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 +929,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 +1130,7 @@ inline void MicroProfileSetThreadLog(MicroProfileThreadLog* pLog)
    pthread_setspecific(g_MicroProfileThreadLogKey, pLog);
 }
 #else
-inline MicroProfileThreadLog* MicroProfileGetThreadLog()
+MicroProfileThreadLog* MicroProfileGetThreadLog()
 {
    return g_MicroProfileThreadLog;
 }
@@ -1247,7 +1246,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 +1275,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 +1441,7 @@ void MicroProfileGpuLeave(MicroProfileToken nToken_, uint64_t nTickStart)
    }
 }

-inline void MicroProfileContextSwitchPut(MicroProfileContextSwitch* pContextSwitch)
+void MicroProfileContextSwitchPut(MicroProfileContextSwitch* pContextSwitch)
 {
    if(S.nRunning || pContextSwitch->nTicks <= S.nPauseTicks)
    {
@@ -1556,10 +1555,10 @@ void MicroProfileFlip()

        pFramePut->nFrameStartCpu = MP_TICK();
        pFramePut->nFrameStartGpu = (uint32_t)MicroProfileGpuInsertTimeStamp();
-        if(pFrameNext->nFrameStartGpu != -1)
+        if(pFrameNext->nFrameStartGpu != (uint64_t)-1)
            pFrameNext->nFrameStartGpu = MicroProfileGpuGetTimeStamp((uint32_t)pFrameNext->nFrameStartGpu);

-        if(pFrameCurrent->nFrameStartGpu == -1)
+        if(pFrameCurrent->nFrameStartGpu == (uint64_t)-1)
            pFrameCurrent->nFrameStartGpu = pFrameNext->nFrameStartGpu + 1;

        uint64_t nFrameStartCpu = pFrameCurrent->nFrameStartCpu;
@@ -1894,7 +1893,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 +2003,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)
    {
@@ -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)
    {
@@ -203,11 +203,7 @@ endif()
 target_compile_definitions(opus PRIVATE OPUS_BUILD ENABLE_HARDENING)

 if(NOT MSVC)
-    if(MINGW)
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=0)
-    else()
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=2)
-    endif()
+    target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=2)
 endif()

 # It is strongly recommended to uncomment one of these VAR_ARRAYS: Use C99
@@ -343,8 +343,8 @@ The icons used in this project have the following licenses:

 Icon Name                                   | License       | Origin/Author
 ---                                         | ---           | ---
-checked.png                                 | CC BY-ND 3.0  | https://icons8.com
-failed.png                                  | CC BY-ND 3.0  | https://icons8.com
+checked.png                                 | Free for non-commercial use
+failed.png                                  | Free for non-commercial use
 lock.png                                    | CC BY-ND 3.0  | https://icons8.com
 plus_folder.png (Default, Dark)             | CC BY-ND 3.0  | https://icons8.com
 bad_folder.png (Default, Dark)              | CC BY-ND 3.0  | https://icons8.com
@@ -53,13 +53,7 @@ if (MSVC)
 else()
    add_compile_options(
        -Wall
-        -Werror=implicit-fallthrough
-        -Werror=missing-declarations
-        -Werror=reorder
-        -Wextra
-        -Wmissing-declarations
        -Wno-attributes
-        -Wno-unused-parameter
    )

    if (APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
@@ -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
@@ -5,141 +5,21 @@
 #define _USE_MATH_DEFINES

 #include <algorithm>
-#include <climits>
 #include <cmath>
 #include <vector>
-
 #include "audio_core/algorithm/interpolate.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"

 namespace AudioCore {

-constexpr std::array<s16, 512> curve_lut0{
-    6600,  19426, 6722,  3,     6479,  19424, 6845,  9,     6359,  19419, 6968,  15,    6239,
-    19412, 7093,  22,    6121,  19403, 7219,  28,    6004,  19391, 7345,  34,    5888,  19377,
-    7472,  41,    5773,  19361, 7600,  48,    5659,  19342, 7728,  55,    5546,  19321, 7857,
-    62,    5434,  19298, 7987,  69,    5323,  19273, 8118,  77,    5213,  19245, 8249,  84,
-    5104,  19215, 8381,  92,    4997,  19183, 8513,  101,   4890,  19148, 8646,  109,   4785,
-    19112, 8780,  118,   4681,  19073, 8914,  127,   4579,  19031, 9048,  137,   4477,  18988,
-    9183,  147,   4377,  18942, 9318,  157,   4277,  18895, 9454,  168,   4179,  18845, 9590,
-    179,   4083,  18793, 9726,  190,   3987,  18738, 9863,  202,   3893,  18682, 10000, 215,
-    3800,  18624, 10137, 228,   3709,  18563, 10274, 241,   3618,  18500, 10411, 255,   3529,
-    18436, 10549, 270,   3441,  18369, 10687, 285,   3355,  18300, 10824, 300,   3269,  18230,
-    10962, 317,   3186,  18157, 11100, 334,   3103,  18082, 11238, 351,   3022,  18006, 11375,
-    369,   2942,  17927, 11513, 388,   2863,  17847, 11650, 408,   2785,  17765, 11788, 428,
-    2709,  17681, 11925, 449,   2635,  17595, 12062, 471,   2561,  17507, 12198, 494,   2489,
-    17418, 12334, 517,   2418,  17327, 12470, 541,   2348,  17234, 12606, 566,   2280,  17140,
-    12741, 592,   2213,  17044, 12876, 619,   2147,  16946, 13010, 647,   2083,  16846, 13144,
-    675,   2020,  16745, 13277, 704,   1958,  16643, 13409, 735,   1897,  16539, 13541, 766,
-    1838,  16434, 13673, 798,   1780,  16327, 13803, 832,   1723,  16218, 13933, 866,   1667,
-    16109, 14062, 901,   1613,  15998, 14191, 937,   1560,  15885, 14318, 975,   1508,  15772,
-    14445, 1013,  1457,  15657, 14571, 1052,  1407,  15540, 14695, 1093,  1359,  15423, 14819,
-    1134,  1312,  15304, 14942, 1177,  1266,  15185, 15064, 1221,  1221,  15064, 15185, 1266,
-    1177,  14942, 15304, 1312,  1134,  14819, 15423, 1359,  1093,  14695, 15540, 1407,  1052,
-    14571, 15657, 1457,  1013,  14445, 15772, 1508,  975,   14318, 15885, 1560,  937,   14191,
-    15998, 1613,  901,   14062, 16109, 1667,  866,   13933, 16218, 1723,  832,   13803, 16327,
-    1780,  798,   13673, 16434, 1838,  766,   13541, 16539, 1897,  735,   13409, 16643, 1958,
-    704,   13277, 16745, 2020,  675,   13144, 16846, 2083,  647,   13010, 16946, 2147,  619,
-    12876, 17044, 2213,  592,   12741, 17140, 2280,  566,   12606, 17234, 2348,  541,   12470,
-    17327, 2418,  517,   12334, 17418, 2489,  494,   12198, 17507, 2561,  471,   12062, 17595,
-    2635,  449,   11925, 17681, 2709,  428,   11788, 17765, 2785,  408,   11650, 17847, 2863,
-    388,   11513, 17927, 2942,  369,   11375, 18006, 3022,  351,   11238, 18082, 3103,  334,
-    11100, 18157, 3186,  317,   10962, 18230, 3269,  300,   10824, 18300, 3355,  285,   10687,
-    18369, 3441,  270,   10549, 18436, 3529,  255,   10411, 18500, 3618,  241,   10274, 18563,
-    3709,  228,   10137, 18624, 3800,  215,   10000, 18682, 3893,  202,   9863,  18738, 3987,
-    190,   9726,  18793, 4083,  179,   9590,  18845, 4179,  168,   9454,  18895, 4277,  157,
-    9318,  18942, 4377,  147,   9183,  18988, 4477,  137,   9048,  19031, 4579,  127,   8914,
-    19073, 4681,  118,   8780,  19112, 4785,  109,   8646,  19148, 4890,  101,   8513,  19183,
-    4997,  92,    8381,  19215, 5104,  84,    8249,  19245, 5213,  77,    8118,  19273, 5323,
-    69,    7987,  19298, 5434,  62,    7857,  19321, 5546,  55,    7728,  19342, 5659,  48,
-    7600,  19361, 5773,  41,    7472,  19377, 5888,  34,    7345,  19391, 6004,  28,    7219,
-    19403, 6121,  22,    7093,  19412, 6239,  15,    6968,  19419, 6359,  9,     6845,  19424,
-    6479,  3,     6722,  19426, 6600};
-
-constexpr std::array<s16, 512> curve_lut1{
-    -68,   32639, 69,    -5,    -200,  32630, 212,   -15,   -328,  32613, 359,   -26,   -450,
-    32586, 512,   -36,   -568,  32551, 669,   -47,   -680,  32507, 832,   -58,   -788,  32454,
-    1000,  -69,   -891,  32393, 1174,  -80,   -990,  32323, 1352,  -92,   -1084, 32244, 1536,
-    -103,  -1173, 32157, 1724,  -115,  -1258, 32061, 1919,  -128,  -1338, 31956, 2118,  -140,
-    -1414, 31844, 2322,  -153,  -1486, 31723, 2532,  -167,  -1554, 31593, 2747,  -180,  -1617,
-    31456, 2967,  -194,  -1676, 31310, 3192,  -209,  -1732, 31157, 3422,  -224,  -1783, 30995,
-    3657,  -240,  -1830, 30826, 3897,  -256,  -1874, 30649, 4143,  -272,  -1914, 30464, 4393,
-    -289,  -1951, 30272, 4648,  -307,  -1984, 30072, 4908,  -325,  -2014, 29866, 5172,  -343,
-    -2040, 29652, 5442,  -362,  -2063, 29431, 5716,  -382,  -2083, 29203, 5994,  -403,  -2100,
-    28968, 6277,  -424,  -2114, 28727, 6565,  -445,  -2125, 28480, 6857,  -468,  -2133, 28226,
-    7153,  -490,  -2139, 27966, 7453,  -514,  -2142, 27700, 7758,  -538,  -2142, 27428, 8066,
-    -563,  -2141, 27151, 8378,  -588,  -2136, 26867, 8694,  -614,  -2130, 26579, 9013,  -641,
-    -2121, 26285, 9336,  -668,  -2111, 25987, 9663,  -696,  -2098, 25683, 9993,  -724,  -2084,
-    25375, 10326, -753,  -2067, 25063, 10662, -783,  -2049, 24746, 11000, -813,  -2030, 24425,
-    11342, -844,  -2009, 24100, 11686, -875,  -1986, 23771, 12033, -907,  -1962, 23438, 12382,
-    -939,  -1937, 23103, 12733, -972,  -1911, 22764, 13086, -1005, -1883, 22422, 13441, -1039,
-    -1855, 22077, 13798, -1072, -1825, 21729, 14156, -1107, -1795, 21380, 14516, -1141, -1764,
-    21027, 14877, -1176, -1732, 20673, 15239, -1211, -1700, 20317, 15602, -1246, -1667, 19959,
-    15965, -1282, -1633, 19600, 16329, -1317, -1599, 19239, 16694, -1353, -1564, 18878, 17058,
-    -1388, -1530, 18515, 17423, -1424, -1495, 18151, 17787, -1459, -1459, 17787, 18151, -1495,
-    -1424, 17423, 18515, -1530, -1388, 17058, 18878, -1564, -1353, 16694, 19239, -1599, -1317,
-    16329, 19600, -1633, -1282, 15965, 19959, -1667, -1246, 15602, 20317, -1700, -1211, 15239,
-    20673, -1732, -1176, 14877, 21027, -1764, -1141, 14516, 21380, -1795, -1107, 14156, 21729,
-    -1825, -1072, 13798, 22077, -1855, -1039, 13441, 22422, -1883, -1005, 13086, 22764, -1911,
-    -972,  12733, 23103, -1937, -939,  12382, 23438, -1962, -907,  12033, 23771, -1986, -875,
-    11686, 24100, -2009, -844,  11342, 24425, -2030, -813,  11000, 24746, -2049, -783,  10662,
-    25063, -2067, -753,  10326, 25375, -2084, -724,  9993,  25683, -2098, -696,  9663,  25987,
-    -2111, -668,  9336,  26285, -2121, -641,  9013,  26579, -2130, -614,  8694,  26867, -2136,
-    -588,  8378,  27151, -2141, -563,  8066,  27428, -2142, -538,  7758,  27700, -2142, -514,
-    7453,  27966, -2139, -490,  7153,  28226, -2133, -468,  6857,  28480, -2125, -445,  6565,
-    28727, -2114, -424,  6277,  28968, -2100, -403,  5994,  29203, -2083, -382,  5716,  29431,
-    -2063, -362,  5442,  29652, -2040, -343,  5172,  29866, -2014, -325,  4908,  30072, -1984,
-    -307,  4648,  30272, -1951, -289,  4393,  30464, -1914, -272,  4143,  30649, -1874, -256,
-    3897,  30826, -1830, -240,  3657,  30995, -1783, -224,  3422,  31157, -1732, -209,  3192,
-    31310, -1676, -194,  2967,  31456, -1617, -180,  2747,  31593, -1554, -167,  2532,  31723,
-    -1486, -153,  2322,  31844, -1414, -140,  2118,  31956, -1338, -128,  1919,  32061, -1258,
-    -115,  1724,  32157, -1173, -103,  1536,  32244, -1084, -92,   1352,  32323, -990,  -80,
-    1174,  32393, -891,  -69,   1000,  32454, -788,  -58,   832,   32507, -680,  -47,   669,
-    32551, -568,  -36,   512,   32586, -450,  -26,   359,   32613, -328,  -15,   212,   32630,
-    -200,  -5,    69,    32639, -68};
-
-constexpr std::array<s16, 512> curve_lut2{
-    3195,  26287, 3329,  -32,   3064,  26281, 3467,  -34,   2936,  26270, 3608,  -38,   2811,
-    26253, 3751,  -42,   2688,  26230, 3897,  -46,   2568,  26202, 4046,  -50,   2451,  26169,
-    4199,  -54,   2338,  26130, 4354,  -58,   2227,  26085, 4512,  -63,   2120,  26035, 4673,
-    -67,   2015,  25980, 4837,  -72,   1912,  25919, 5004,  -76,   1813,  25852, 5174,  -81,
-    1716,  25780, 5347,  -87,   1622,  25704, 5522,  -92,   1531,  25621, 5701,  -98,   1442,
-    25533, 5882,  -103,  1357,  25440, 6066,  -109,  1274,  25342, 6253,  -115,  1193,  25239,
-    6442,  -121,  1115,  25131, 6635,  -127,  1040,  25018, 6830,  -133,  967,   24899, 7027,
-    -140,  897,   24776, 7227,  -146,  829,   24648, 7430,  -153,  764,   24516, 7635,  -159,
-    701,   24379, 7842,  -166,  641,   24237, 8052,  -174,  583,   24091, 8264,  -181,  526,
-    23940, 8478,  -187,  472,   23785, 8695,  -194,  420,   23626, 8914,  -202,  371,   23462,
-    9135,  -209,  324,   23295, 9358,  -215,  279,   23123, 9583,  -222,  236,   22948, 9809,
-    -230,  194,   22769, 10038, -237,  154,   22586, 10269, -243,  117,   22399, 10501, -250,
-    81,    22208, 10735, -258,  47,    22015, 10970, -265,  15,    21818, 11206, -271,  -16,
-    21618, 11444, -277,  -44,   21415, 11684, -283,  -71,   21208, 11924, -290,  -97,   20999,
-    12166, -296,  -121,  20786, 12409, -302,  -143,  20571, 12653, -306,  -163,  20354, 12898,
-    -311,  -183,  20134, 13143, -316,  -201,  19911, 13389, -321,  -218,  19686, 13635, -325,
-    -234,  19459, 13882, -328,  -248,  19230, 14130, -332,  -261,  18998, 14377, -335,  -273,
-    18765, 14625, -337,  -284,  18531, 14873, -339,  -294,  18295, 15121, -341,  -302,  18057,
-    15369, -341,  -310,  17817, 15617, -341,  -317,  17577, 15864, -340,  -323,  17335, 16111,
-    -340,  -328,  17092, 16357, -338,  -332,  16848, 16603, -336,  -336,  16603, 16848, -332,
-    -338,  16357, 17092, -328,  -340,  16111, 17335, -323,  -340,  15864, 17577, -317,  -341,
-    15617, 17817, -310,  -341,  15369, 18057, -302,  -341,  15121, 18295, -294,  -339,  14873,
-    18531, -284,  -337,  14625, 18765, -273,  -335,  14377, 18998, -261,  -332,  14130, 19230,
-    -248,  -328,  13882, 19459, -234,  -325,  13635, 19686, -218,  -321,  13389, 19911, -201,
-    -316,  13143, 20134, -183,  -311,  12898, 20354, -163,  -306,  12653, 20571, -143,  -302,
-    12409, 20786, -121,  -296,  12166, 20999, -97,   -290,  11924, 21208, -71,   -283,  11684,
-    21415, -44,   -277,  11444, 21618, -16,   -271,  11206, 21818, 15,    -265,  10970, 22015,
-    47,    -258,  10735, 22208, 81,    -250,  10501, 22399, 117,   -243,  10269, 22586, 154,
-    -237,  10038, 22769, 194,   -230,  9809,  22948, 236,   -222,  9583,  23123, 279,   -215,
-    9358,  23295, 324,   -209,  9135,  23462, 371,   -202,  8914,  23626, 420,   -194,  8695,
-    23785, 472,   -187,  8478,  23940, 526,   -181,  8264,  24091, 583,   -174,  8052,  24237,
-    641,   -166,  7842,  24379, 701,   -159,  7635,  24516, 764,   -153,  7430,  24648, 829,
-    -146,  7227,  24776, 897,   -140,  7027,  24899, 967,   -133,  6830,  25018, 1040,  -127,
-    6635,  25131, 1115,  -121,  6442,  25239, 1193,  -115,  6253,  25342, 1274,  -109,  6066,
-    25440, 1357,  -103,  5882,  25533, 1442,  -98,   5701,  25621, 1531,  -92,   5522,  25704,
-    1622,  -87,   5347,  25780, 1716,  -81,   5174,  25852, 1813,  -76,   5004,  25919, 1912,
-    -72,   4837,  25980, 2015,  -67,   4673,  26035, 2120,  -63,   4512,  26085, 2227,  -58,
-    4354,  26130, 2338,  -54,   4199,  26169, 2451,  -50,   4046,  26202, 2568,  -46,   3897,
-    26230, 2688,  -42,   3751,  26253, 2811,  -38,   3608,  26270, 2936,  -34,   3467,  26281,
-    3064,  -32,   3329,  26287, 3195};
+/// The Lanczos kernel
+static double Lanczos(std::size_t a, double x) {
+    if (x == 0.0)
+        return 1.0;
+    const double px = M_PI * x;
+    return a * std::sin(px) * std::sin(px / a) / (px * px);
+}

 std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input, double ratio) {
    if (input.size() < 2)
@@ -147,51 +27,43 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,

    if (ratio <= 0) {
        LOG_CRITICAL(Audio, "Nonsensical interpolation ratio {}", ratio);
-        return input;
+        ratio = 1.0;
    }

-    const s32 step{static_cast<s32>(ratio * 0x8000)};
-    const std::array<s16, 512>& lut = [step] {
-        if (step > 0xaaaa) {
-            return curve_lut0;
-        }
-        if (step <= 0x8000) {
-            return curve_lut1;
-        }
-        return curve_lut2;
-    }();
+    if (ratio != state.current_ratio) {
+        const double cutoff_frequency = std::min(0.5 / ratio, 0.5 * ratio);
+        state.nyquist = CascadingFilter::LowPass(std::clamp(cutoff_frequency, 0.0, 0.4), 3);
+        state.current_ratio = ratio;
+    }
+    state.nyquist.Process(input);

-    const std::size_t num_frames{input.size() / 2};
+    constexpr std::size_t taps = InterpolationState::lanczos_taps;
+    const std::size_t num_frames = input.size() / 2;

    std::vector<s16> output;
-    output.reserve(static_cast<std::size_t>(input.size() / ratio + InterpolationState::taps));
+    output.reserve(static_cast<std::size_t>(input.size() / ratio + 4));

-    for (std::size_t frame{}; frame < num_frames; ++frame) {
-        const std::size_t lut_index{(state.fraction >> 8) * InterpolationState::taps};
+    double& pos = state.position;
+    auto& h = state.history;
+    for (std::size_t i = 0; i < num_frames; ++i) {
+        std::rotate(h.begin(), h.end() - 1, h.end());
+        h[0][0] = input[i * 2 + 0];
+        h[0][1] = input[i * 2 + 1];

-        std::rotate(state.history.begin(), state.history.end() - 1, state.history.end());
-        state.history[0][0] = input[frame * 2 + 0];
-        state.history[0][1] = input[frame * 2 + 1];
+        while (pos <= 1.0) {
+            double l = 0.0;
+            double r = 0.0;
+            for (std::size_t j = 0; j < h.size(); j++) {
+                const double lanczos_calc = Lanczos(taps, pos + j - taps + 1);
+                l += lanczos_calc * h[j][0];
+                r += lanczos_calc * h[j][1];
+            }
+            output.emplace_back(static_cast<s16>(std::clamp(l, -32768.0, 32767.0)));
+            output.emplace_back(static_cast<s16>(std::clamp(r, -32768.0, 32767.0)));

-        while (state.position <= 1.0) {
-            const s32 left{state.history[0][0] * lut[lut_index + 0] +
-                           state.history[1][0] * lut[lut_index + 1] +
-                           state.history[2][0] * lut[lut_index + 2] +
-                           state.history[3][0] * lut[lut_index + 3]};
-            const s32 right{state.history[0][1] * lut[lut_index + 0] +
-                            state.history[1][1] * lut[lut_index + 1] +
-                            state.history[2][1] * lut[lut_index + 2] +
-                            state.history[3][1] * lut[lut_index + 3]};
-            const s32 new_offset{state.fraction + step};
-
-            state.fraction = new_offset & 0x7fff;
-
-            output.emplace_back(static_cast<s16>(std::clamp(left >> 15, SHRT_MIN, SHRT_MAX)));
-            output.emplace_back(static_cast<s16>(std::clamp(right >> 15, SHRT_MIN, SHRT_MAX)));
-
-            state.position += ratio;
+            pos += ratio;
        }
-        state.position -= 1.0;
+        pos -= 1.0;
    }

    return output;
@@ -6,17 +6,19 @@

 #include <array>
 #include <vector>
-
+#include "audio_core/algorithm/filter.h"
 #include "common/common_types.h"

 namespace AudioCore {

 struct InterpolationState {
-    static constexpr std::size_t taps{4};
-    static constexpr std::size_t history_size{taps * 2 - 1};
-    std::array<std::array<s16, 2>, history_size> history{};
-    double position{};
-    s32 fraction{};
+    static constexpr std::size_t lanczos_taps = 4;
+    static constexpr std::size_t history_size = lanczos_taps * 2 - 1;
+
+    double current_ratio = 0.0;
+    CascadingFilter nyquist;
+    std::array<std::array<s16, 2>, history_size> history = {};
+    double position = 0;
 };

 /// Interpolates input signal to produce output signal.
@@ -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, Memory::Memory& memory);
    void UpdateState();
-    void RefreshBuffer(Core::Memory::Memory& memory, const VoiceChannelHolder& voice_resources);
+    void RefreshBuffer(Memory::Memory& memory);

 private:
    bool is_in_use{};
@@ -68,20 +66,19 @@ public:
        return info;
    }

-    void UpdateState(Core::Memory::Memory& memory);
+    void UpdateState(Memory::Memory& memory);

 private:
    EffectOutStatus out_status{};
    EffectInStatus info{};
 };
-
-AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
+AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Memory::Memory& memory_,
                             AudioRendererParameter params,
                             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 +108,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};
@@ -181,7 +172,8 @@ ResultVal<std::vector<u8>> AudioRenderer::UpdateAudioRenderer(const std::vector<
    // Copy output header
    UpdateDataHeader response_data{worker_params};
    std::vector<u8> output_params(response_data.total_size);
-    if (behavior_info.IsElapsedFrameCountSupported()) {
+    const auto audren_revision = VersionFromRevision(config.revision);
+    if (audren_revision >= 5) {
        response_data.frame_count = 0x10;
        response_data.total_size += 0x10;
    }
@@ -207,19 +199,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;
-    }
-
-    return MakeResult(output_params);
+    return output_params;
 }

 void AudioRenderer::VoiceState::SetWaveIndex(std::size_t index) {
@@ -227,15 +207,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,
+                                                           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};
@@ -279,8 +258,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(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));
@@ -305,77 +283,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:
@@ -392,7 +310,7 @@ void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory,
    is_refresh_pending = false;
 }

-void AudioRenderer::EffectState::UpdateState(Core::Memory::Memory& memory) {
+void AudioRenderer::EffectState::UpdateState(Memory::Memory& memory) {
    if (info.is_new) {
        out_status.state = EffectStatus::New;
    } else {
@@ -421,17 +339,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;
@@ -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;
@@ -25,7 +22,7 @@ namespace Kernel {
 class WritableEvent;
 }

-namespace Core::Memory {
+namespace Memory {
 class Memory;
 }

@@ -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;
@@ -200,7 +189,7 @@ struct UpdateDataHeader {
    UpdateDataHeader() {}

    explicit UpdateDataHeader(const AudioRendererParameter& config) {
-        revision = Common::MakeMagic('R', 'E', 'V', '8'); // 9.2.0 Revision
+        revision = Common::MakeMagic('R', 'E', 'V', '4'); // 5.1.0 Revision
        behavior_size = 0xb0;
        memory_pools_size = (config.effect_count + (config.voice_count * 4)) * 0x10;
        voices_size = config.voice_count * 0x10;
@@ -232,12 +221,12 @@ static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size

 class AudioRenderer {
 public:
-    AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
+    AudioRenderer(Core::Timing::CoreTiming& core_timing, Memory::Memory& memory_,
                  AudioRendererParameter params,
                  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;
@@ -248,16 +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;
+    Memory::Memory& memory;
 };

 } // namespace AudioCore
@@ -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
@@ -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
@@ -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
@@ -8,7 +8,6 @@
 #include "audio_core/cubeb_sink.h"
 #include "audio_core/stream.h"
 #include "audio_core/time_stretch.h"
-#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/ring_buffer.h"
 #include "core/settings.h"
@@ -66,25 +65,12 @@ public:
    void EnqueueSamples(u32 source_num_channels, const std::vector<s16>& samples) override {
        if (source_num_channels > num_channels) {
            // Downsample 6 channels to 2
-            ASSERT_MSG(source_num_channels == 6, "Channel count must be 6");
-
            std::vector<s16> buf;
            buf.reserve(samples.size() * num_channels / source_num_channels);
            for (std::size_t i = 0; i < samples.size(); i += source_num_channels) {
-                // Downmixing implementation taken from the ATSC standard
-                const s16 left{samples[i + 0]};
-                const s16 right{samples[i + 1]};
-                const s16 center{samples[i + 2]};
-                const s16 surround_left{samples[i + 4]};
-                const s16 surround_right{samples[i + 5]};
-                // Not used in the ATSC reference implementation
-                [[maybe_unused]] const s16 low_frequency_effects { samples[i + 3] };
-
-                constexpr s32 clev{707}; // center mixing level coefficient
-                constexpr s32 slev{707}; // surround mixing level coefficient
-
-                buf.push_back(left + (clev * center / 1000) + (slev * surround_left / 1000));
-                buf.push_back(right + (clev * center / 1000) + (slev * surround_right / 1000));
+                for (std::size_t ch = 0; ch < num_channels; ch++) {
+                    buf.push_back(samples[i + ch]);
+                }
            }
            queue.Push(buf);
            return;
@@ -11,10 +11,8 @@
 #include "audio_core/stream.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
-#include "core/perf_stats.h"
 #include "core/settings.h"

 namespace AudioCore {
@@ -63,11 +61,8 @@ Stream::State Stream::GetState() const {

 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
    const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
-    const double time_scale{Settings::values.enable_realtime_audio
-                                ? Core::System::GetInstance().GetPerfStats().GetLastFrameTimeScale()
-                                : 1.0f};
-    const auto us{std::chrono::microseconds(
-        (static_cast<u64>(num_samples) * static_cast<u64>(1000000 / time_scale)) / sample_rate)};
+    const auto us =
+        std::chrono::microseconds((static_cast<u64>(num_samples) * 1000000) / sample_rate);
    return Core::Timing::usToCycles(us);
 }

@@ -38,6 +38,8 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.h"
      "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
      "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
      "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
@@ -70,6 +72,8 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/shader/ast.h"
      "${VIDEO_CORE}/shader/compiler_settings.cpp"
      "${VIDEO_CORE}/shader/compiler_settings.h"
+      "${VIDEO_CORE}/shader/const_buffer_locker.cpp"
+      "${VIDEO_CORE}/shader/const_buffer_locker.h"
      "${VIDEO_CORE}/shader/control_flow.cpp"
      "${VIDEO_CORE}/shader/control_flow.h"
      "${VIDEO_CORE}/shader/decode.cpp"
@@ -78,13 +82,9 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/shader/node.h"
      "${VIDEO_CORE}/shader/node_helper.cpp"
      "${VIDEO_CORE}/shader/node_helper.h"
-      "${VIDEO_CORE}/shader/registry.cpp"
-      "${VIDEO_CORE}/shader/registry.h"
      "${VIDEO_CORE}/shader/shader_ir.cpp"
      "${VIDEO_CORE}/shader/shader_ir.h"
      "${VIDEO_CORE}/shader/track.cpp"
-      "${VIDEO_CORE}/shader/transform_feedback.cpp"
-      "${VIDEO_CORE}/shader/transform_feedback.h"
      # and also check that the scm_rev files haven't changed
      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in"
      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
@@ -106,8 +106,6 @@ add_library(common STATIC
    common_funcs.h
    common_paths.h
    common_types.h
-    dynamic_library.cpp
-    dynamic_library.h
    file_util.cpp
    file_util.h
    hash.h
@@ -155,8 +153,6 @@ add_library(common STATIC
    uuid.cpp
    uuid.h
    vector_math.h
-    virtual_buffer.cpp
-    virtual_buffer.h
    web_result.h
    zstd_compression.cpp
    zstd_compression.h
@@ -38,13 +38,6 @@ constexpr bool IsWordAligned(T value) {
    return (value & 0b11) == 0;
 }

-template <typename T>
-constexpr bool IsAligned(T value, std::size_t alignment) {
-    using U = typename std::make_unsigned<T>::type;
-    const U mask = static_cast<U>(alignment - 1);
-    return (value & mask) == 0;
-}
-
 template <typename T, std::size_t Align = 16>
 class AlignmentAllocator {
 public:
@@ -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 {
@@ -55,38 +55,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 // Defined in Misc.cpp.
 std::string GetLastErrorMsg();

-#define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
-    constexpr type operator|(type a, type b) noexcept {                                            \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(static_cast<T>(a) | static_cast<T>(b));                           \
-    }                                                                                              \
-    constexpr type operator&(type a, type b) noexcept {                                            \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(static_cast<T>(a) & static_cast<T>(b));                           \
-    }                                                                                              \
-    constexpr type& operator|=(type& a, type b) noexcept {                                         \
-        using T = std::underlying_type_t<type>;                                                    \
-        a = static_cast<type>(static_cast<T>(a) | static_cast<T>(b));                              \
-        return a;                                                                                  \
-    }                                                                                              \
-    constexpr type& operator&=(type& a, type b) noexcept {                                         \
-        using T = std::underlying_type_t<type>;                                                    \
-        a = static_cast<type>(static_cast<T>(a) & static_cast<T>(b));                              \
-        return a;                                                                                  \
-    }                                                                                              \
-    constexpr type operator~(type key) noexcept {                                                  \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(~static_cast<T>(key));                                            \
-    }                                                                                              \
-    constexpr bool True(type key) noexcept {                                                       \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<T>(key) != 0;                                                           \
-    }                                                                                              \
-    constexpr bool False(type key) noexcept {                                                      \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<T>(key) == 0;                                                           \
-    }
-
 namespace Common {

 constexpr u32 MakeMagic(char a, char b, char c, char d) {
@@ -1,106 +0,0 @@
-// Copyright 2019 Dolphin Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <string>
-#include <utility>
-
-#include <fmt/format.h>
-
-#include "common/dynamic_library.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#endif
-
-namespace Common {
-
-DynamicLibrary::DynamicLibrary() = default;
-
-DynamicLibrary::DynamicLibrary(const char* filename) {
-    Open(filename);
-}
-
-DynamicLibrary::DynamicLibrary(DynamicLibrary&& rhs) noexcept
-    : handle{std::exchange(rhs.handle, nullptr)} {}
-
-DynamicLibrary& DynamicLibrary::operator=(DynamicLibrary&& rhs) noexcept {
-    Close();
-    handle = std::exchange(rhs.handle, nullptr);
-    return *this;
-}
-
-DynamicLibrary::~DynamicLibrary() {
-    Close();
-}
-
-std::string DynamicLibrary::GetUnprefixedFilename(const char* filename) {
-#if defined(_WIN32)
-    return std::string(filename) + ".dll";
-#elif defined(__APPLE__)
-    return std::string(filename) + ".dylib";
-#else
-    return std::string(filename) + ".so";
-#endif
-}
-
-std::string DynamicLibrary::GetVersionedFilename(const char* libname, int major, int minor) {
-#if defined(_WIN32)
-    if (major >= 0 && minor >= 0)
-        return fmt::format("{}-{}-{}.dll", libname, major, minor);
-    else if (major >= 0)
-        return fmt::format("{}-{}.dll", libname, major);
-    else
-        return fmt::format("{}.dll", libname);
-#elif defined(__APPLE__)
-    const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
-    if (major >= 0 && minor >= 0)
-        return fmt::format("{}{}.{}.{}.dylib", prefix, libname, major, minor);
-    else if (major >= 0)
-        return fmt::format("{}{}.{}.dylib", prefix, libname, major);
-    else
-        return fmt::format("{}{}.dylib", prefix, libname);
-#else
-    const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
-    if (major >= 0 && minor >= 0)
-        return fmt::format("{}{}.so.{}.{}", prefix, libname, major, minor);
-    else if (major >= 0)
-        return fmt::format("{}{}.so.{}", prefix, libname, major);
-    else
-        return fmt::format("{}{}.so", prefix, libname);
-#endif
-}
-
-bool DynamicLibrary::Open(const char* filename) {
-#ifdef _WIN32
-    handle = reinterpret_cast<void*>(LoadLibraryA(filename));
-#else
-    handle = dlopen(filename, RTLD_NOW);
-#endif
-    return handle != nullptr;
-}
-
-void DynamicLibrary::Close() {
-    if (!IsOpen())
-        return;
-
-#ifdef _WIN32
-    FreeLibrary(reinterpret_cast<HMODULE>(handle));
-#else
-    dlclose(handle);
-#endif
-    handle = nullptr;
-}
-
-void* DynamicLibrary::GetSymbolAddress(const char* name) const {
-#ifdef _WIN32
-    return reinterpret_cast<void*>(GetProcAddress(reinterpret_cast<HMODULE>(handle), name));
-#else
-    return reinterpret_cast<void*>(dlsym(handle, name));
-#endif
-}
-
-} // namespace Common
@@ -1,75 +0,0 @@
-// Copyright 2019 Dolphin Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-
-namespace Common {
-
-/**
- * Provides a platform-independent interface for loading a dynamic library and retrieving symbols.
- * The interface maintains an internal reference count to allow one handle to be shared between
- * multiple users.
- */
-class DynamicLibrary final {
-public:
-    /// Default constructor, does not load a library.
-    explicit DynamicLibrary();
-
-    /// Automatically loads the specified library. Call IsOpen() to check validity before use.
-    explicit DynamicLibrary(const char* filename);
-
-    /// Moves the library.
-    DynamicLibrary(DynamicLibrary&&) noexcept;
-    DynamicLibrary& operator=(DynamicLibrary&&) noexcept;
-
-    /// Delete copies, we can't copy a dynamic library.
-    DynamicLibrary(const DynamicLibrary&) = delete;
-    DynamicLibrary& operator=(const DynamicLibrary&) = delete;
-
-    /// Closes the library.
-    ~DynamicLibrary();
-
-    /// Returns the specified library name with the platform-specific suffix added.
-    static std::string GetUnprefixedFilename(const char* filename);
-
-    /// Returns the specified library name in platform-specific format.
-    /// Major/minor versions will not be included if set to -1.
-    /// If libname already contains the "lib" prefix, it will not be added again.
-    /// Windows: LIBNAME-MAJOR-MINOR.dll
-    /// Linux: libLIBNAME.so.MAJOR.MINOR
-    /// Mac: libLIBNAME.MAJOR.MINOR.dylib
-    static std::string GetVersionedFilename(const char* libname, int major = -1, int minor = -1);
-
-    /// Returns true if a module is loaded, otherwise false.
-    bool IsOpen() const {
-        return handle != nullptr;
-    }
-
-    /// Loads (or replaces) the handle with the specified library file name.
-    /// Returns true if the library was loaded and can be used.
-    bool Open(const char* filename);
-
-    /// Unloads the library, any function pointers from this library are no longer valid.
-    void Close();
-
-    /// Returns the address of the specified symbol (function or variable) as an untyped pointer.
-    /// If the specified symbol does not exist in this library, nullptr is returned.
-    void* GetSymbolAddress(const char* name) const;
-
-    /// Obtains the address of the specified symbol, automatically casting to the correct type.
-    /// Returns true if the symbol was found and assigned, otherwise false.
-    template <typename T>
-    bool GetSymbol(const char* name, T* ptr) const {
-        *ptr = reinterpret_cast<T>(GetSymbolAddress(name));
-        return *ptr != nullptr;
-    }
-
-private:
-    /// Platform-dependent data type representing a dynamic library handle.
-    void* handle = nullptr;
-};
-
-} // namespace Common
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.

 #include <array>
-#include <limits>
 #include <memory>
 #include <sstream>
 #include <unordered_map>
@@ -531,11 +530,11 @@ void CopyDir(const std::string& source_path, const std::string& dest_path) {
 std::optional<std::string> GetCurrentDir() {
 // Get the current working directory (getcwd uses malloc)
 #ifdef _WIN32
-    wchar_t* dir = _wgetcwd(nullptr, 0);
-    if (!dir) {
+    wchar_t* dir;
+    if (!(dir = _wgetcwd(nullptr, 0))) {
 #else
-    char* dir = getcwd(nullptr, 0);
-    if (!dir) {
+    char* dir;
+    if (!(dir = getcwd(nullptr, 0))) {
 #endif
        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
        return {};
@@ -888,14 +887,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));
@@ -926,22 +918,19 @@ void IOFile::Swap(IOFile& other) noexcept {

 bool IOFile::Open(const std::string& filename, const char openmode[], int flags) {
    Close();
-    bool m_good;
 #ifdef _WIN32
    if (flags != 0) {
        m_file = _wfsopen(Common::UTF8ToUTF16W(filename).c_str(),
                          Common::UTF8ToUTF16W(openmode).c_str(), flags);
-        m_good = m_file != nullptr;
    } else {
-        m_good = _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
-                           Common::UTF8ToUTF16W(openmode).c_str()) == 0;
+        _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
+                  Common::UTF8ToUTF16W(openmode).c_str());
    }
 #else
-    m_file = std::fopen(filename.c_str(), openmode);
-    m_good = m_file != nullptr;
+    m_file = fopen(filename.c_str(), openmode);
 #endif

-    return m_good;
+    return IsOpen();
 }

 bool IOFile::Close() {
@@ -967,41 +956,13 @@ u64 IOFile::Tell() const {
    if (IsOpen())
        return ftello(m_file);

-    return std::numeric_limits<u64>::max();
+    return -1;
 }

 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
@@ -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;
 };

@@ -24,29 +24,17 @@ struct Rectangle {
        : left(left), top(top), right(right), bottom(bottom) {}

    T GetWidth() const {
-        if constexpr (std::is_floating_point_v<T>) {
-            return std::abs(right - left);
-        } else {
-            return std::abs(static_cast<std::make_signed_t<T>>(right - left));
-        }
+        return std::abs(static_cast<std::make_signed_t<T>>(right - left));
    }
-
    T GetHeight() const {
-        if constexpr (std::is_floating_point_v<T>) {
-            return std::abs(bottom - top);
-        } else {
-            return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
-        }
+        return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
    }
-
    Rectangle<T> TranslateX(const T x) const {
        return Rectangle{left + x, top, right + x, bottom};
    }
-
    Rectangle<T> TranslateY(const T y) const {
        return Rectangle{left, top + y, right, bottom + y};
    }
-
    Rectangle<T> Scale(const float s) const {
        return Rectangle{left, top, static_cast<T>(left + GetWidth() * s),
                         static_cast<T>(top + GetHeight() * s)};
@@ -6,20 +6,26 @@

 namespace Common {

-PageTable::PageTable() = default;
+PageTable::PageTable(std::size_t page_size_in_bits) : page_size_in_bits{page_size_in_bits} {}

 PageTable::~PageTable() = default;

-void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
-                       bool has_attribute) {
-    const std::size_t num_page_table_entries{1ULL
-                                             << (address_space_width_in_bits - page_size_in_bits)};
+void PageTable::Resize(std::size_t address_space_width_in_bits) {
+    const std::size_t num_page_table_entries = 1ULL
+                                               << (address_space_width_in_bits - page_size_in_bits);
+
    pointers.resize(num_page_table_entries);
+    attributes.resize(num_page_table_entries);
    backing_addr.resize(num_page_table_entries);

-    if (has_attribute) {
-        attributes.resize(num_page_table_entries);
-    }
+    // The default is a 39-bit address space, which causes an initial 1GB allocation size. If the
+    // vector size is subsequently decreased (via resize), the vector might not automatically
+    // actually reallocate/resize its underlying allocation, which wastes up to ~800 MB for
+    // 36-bit titles. Call shrink_to_fit to reduce capacity to what's actually in use.
+
+    pointers.shrink_to_fit();
+    attributes.shrink_to_fit();
+    backing_addr.shrink_to_fit();
 }

 } // namespace Common
@@ -5,12 +5,9 @@
 #pragma once

 #include <vector>
-
 #include <boost/icl/interval_map.hpp>
-
 #include "common/common_types.h"
 #include "common/memory_hook.h"
-#include "common/virtual_buffer.h"

 namespace Common {

@@ -50,7 +47,7 @@ struct SpecialRegion {
 * mimics the way a real CPU page table works.
 */
 struct PageTable {
-    PageTable();
+    explicit PageTable(std::size_t page_size_in_bits);
    ~PageTable();

    /**
@@ -59,18 +56,29 @@ struct PageTable {
     *
     * @param address_space_width_in_bits The address size width in bits.
     */
-    void Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
-                bool has_attribute);
+    void Resize(std::size_t address_space_width_in_bits);

    /**
     * Vector of memory pointers backing each page. An entry can only be non-null if the
     * corresponding entry in the `attributes` vector is of type `Memory`.
     */
-    VirtualBuffer<u8*> pointers;
+    std::vector<u8*> pointers;

-    VirtualBuffer<u64> backing_addr;
+    /**
+     * Contains MMIO handlers that back memory regions whose entries in the `attribute` vector is
+     * of type `Special`.
+     */
+    boost::icl::interval_map<u64, std::set<SpecialRegion>> special_regions;

-    VirtualBuffer<PageType> attributes;
+    /**
+     * Vector of fine grained page attributes. If it is set to any value other than `Memory`, then
+     * the corresponding entry in `pointers` MUST be set to null.
+     */
+    std::vector<PageType> attributes;
+
+    std::vector<u64> backing_addr;
+
+    const std::size_t page_size_in_bits{};
 };

 } // namespace Common
@@ -12,17 +12,10 @@ template <typename Func>
 struct ScopeExitHelper {
    explicit ScopeExitHelper(Func&& func) : func(std::move(func)) {}
    ~ScopeExitHelper() {
-        if (active) {
-            func();
-        }
-    }
-
-    void Cancel() {
-        active = false;
+        func();
    }

    Func func;
-    bool active{true};
 };

 template <typename Func>
@@ -28,8 +28,11 @@ namespace Common {
 #ifdef _MSC_VER

 // Sets the debugger-visible name of the current thread.
-// Uses trick documented in:
-// https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-set-a-thread-name-in-native-code
+// Uses undocumented (actually, it is now documented) trick.
+// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsdebug/html/vxtsksettingthreadname.asp
+
+// This is implemented much nicer in upcoming msvc++, see:
+// http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.100).aspx
 void SetCurrentThreadName(const char* name) {
    static const DWORD MS_VC_EXCEPTION = 0x406D1388;

@@ -44,7 +47,7 @@ void SetCurrentThreadName(const char* name) {

    info.dwType = 0x1000;
    info.szName = name;
-    info.dwThreadID = std::numeric_limits<DWORD>::max();
+    info.dwThreadID = -1; // dwThreadID;
    info.dwFlags = 0;

    __try {
@@ -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;
 };
@@ -1,52 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <stdio.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-#if defined __APPLE__ || defined __FreeBSD__ || defined __OpenBSD__
-#include <sys/sysctl.h>
-#elif defined __HAIKU__
-#include <OS.h>
-#else
-#include <sys/sysinfo.h>
-#endif
-#endif
-
-#include "common/assert.h"
-#include "common/virtual_buffer.h"
-
-namespace Common {
-
-void* AllocateMemoryPages(std::size_t size) {
-#ifdef _WIN32
-    void* base{VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE)};
-#else
-    void* base{mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0)};
-
-    if (base == MAP_FAILED) {
-        base = nullptr;
-    }
-#endif
-
-    ASSERT(base);
-
-    return base;
-}
-
-void FreeMemoryPages(void* base, std::size_t size) {
-    if (!base) {
-        return;
-    }
-#ifdef _WIN32
-    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
-#else
-    ASSERT(munmap(base, size) == 0);
-#endif
-}
-
-} // namespace Common
@@ -1,58 +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"
-
-namespace Common {
-
-void* AllocateMemoryPages(std::size_t size);
-void FreeMemoryPages(void* base, std::size_t size);
-
-template <typename T>
-class VirtualBuffer final : NonCopyable {
-public:
-    constexpr VirtualBuffer() = default;
-    explicit VirtualBuffer(std::size_t count) : alloc_size{count * sizeof(T)} {
-        base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
-    }
-
-    ~VirtualBuffer() {
-        FreeMemoryPages(base_ptr, alloc_size);
-    }
-
-    void resize(std::size_t count) {
-        FreeMemoryPages(base_ptr, alloc_size);
-
-        alloc_size = count * sizeof(T);
-        base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
-    }
-
-    constexpr const T& operator[](std::size_t index) const {
-        return base_ptr[index];
-    }
-
-    constexpr T& operator[](std::size_t index) {
-        return base_ptr[index];
-    }
-
-    constexpr T* data() {
-        return base_ptr;
-    }
-
-    constexpr const T* data() const {
-        return base_ptr;
-    }
-
-    constexpr std::size_t size() const {
-        return alloc_size / sizeof(T);
-    }
-
-private:
-    std::size_t alloc_size{};
-    T* base_ptr{};
-};
-
-} // namespace Common
@@ -15,14 +15,14 @@ add_library(core STATIC
    constants.h
    core.cpp
    core.h
-    core_manager.cpp
-    core_manager.h
+    core_cpu.cpp
+    core_cpu.h
    core_timing.cpp
    core_timing.h
    core_timing_util.cpp
    core_timing_util.h
-    cpu_manager.cpp
-    cpu_manager.h
+    cpu_core_manager.cpp
+    cpu_core_manager.h
    crypto/aes_util.cpp
    crypto/aes_util.h
    crypto/encryption_layer.cpp
@@ -35,8 +35,6 @@ add_library(core STATIC
    crypto/ctr_encryption_layer.h
    crypto/xts_encryption_layer.cpp
    crypto/xts_encryption_layer.h
-    device_memory.cpp
-    device_memory.h
    file_sys/bis_factory.cpp
    file_sys/bis_factory.h
    file_sys/card_image.cpp
@@ -133,6 +131,8 @@ add_library(core STATIC
    frontend/framebuffer_layout.cpp
    frontend/framebuffer_layout.h
    frontend/input.h
+    frontend/scope_acquire_window_context.cpp
+    frontend/scope_acquire_window_context.h
    gdbstub/gdbstub.cpp
    gdbstub/gdbstub.h
    hardware_interrupt_manager.cpp
@@ -154,29 +154,10 @@ add_library(core STATIC
    hle/kernel/hle_ipc.h
    hle/kernel/kernel.cpp
    hle/kernel/kernel.h
-    hle/kernel/memory/address_space_info.cpp
-    hle/kernel/memory/address_space_info.h
-    hle/kernel/memory/memory_block.h
-    hle/kernel/memory/memory_block_manager.cpp
-    hle/kernel/memory/memory_block_manager.h
-    hle/kernel/memory/memory_layout.h
-    hle/kernel/memory/memory_manager.cpp
-    hle/kernel/memory/memory_manager.h
-    hle/kernel/memory/memory_types.h
-    hle/kernel/memory/page_linked_list.h
-    hle/kernel/memory/page_heap.cpp
-    hle/kernel/memory/page_heap.h
-    hle/kernel/memory/page_table.cpp
-    hle/kernel/memory/page_table.h
-    hle/kernel/memory/slab_heap.h
-    hle/kernel/memory/system_control.cpp
-    hle/kernel/memory/system_control.h
    hle/kernel/mutex.cpp
    hle/kernel/mutex.h
    hle/kernel/object.cpp
    hle/kernel/object.h
-    hle/kernel/physical_core.cpp
-    hle/kernel/physical_core.h
    hle/kernel/process.cpp
    hle/kernel/process.h
    hle/kernel/process_capability.cpp
@@ -197,18 +178,15 @@ add_library(core STATIC
    hle/kernel/shared_memory.h
    hle/kernel/svc.cpp
    hle/kernel/svc.h
-    hle/kernel/svc_types.h
    hle/kernel/svc_wrap.h
-    hle/kernel/synchronization_object.cpp
-    hle/kernel/synchronization_object.h
-    hle/kernel/synchronization.cpp
-    hle/kernel/synchronization.h
    hle/kernel/thread.cpp
    hle/kernel/thread.h
-    hle/kernel/time_manager.cpp
-    hle/kernel/time_manager.h
    hle/kernel/transfer_memory.cpp
    hle/kernel/transfer_memory.h
+    hle/kernel/vm_manager.cpp
+    hle/kernel/vm_manager.h
+    hle/kernel/wait_object.cpp
+    hle/kernel/wait_object.h
    hle/kernel/writable_event.cpp
    hle/kernel/writable_event.h
    hle/lock.cpp
@@ -303,18 +281,6 @@ add_library(core STATIC
    hle/service/btm/btm.h
    hle/service/caps/caps.cpp
    hle/service/caps/caps.h
-    hle/service/caps/caps_a.cpp
-    hle/service/caps/caps_a.h
-    hle/service/caps/caps_c.cpp
-    hle/service/caps/caps_c.h
-    hle/service/caps/caps_u.cpp
-    hle/service/caps/caps_u.h
-    hle/service/caps/caps_sc.cpp
-    hle/service/caps/caps_sc.h
-    hle/service/caps/caps_ss.cpp
-    hle/service/caps/caps_ss.h
-    hle/service/caps/caps_su.cpp
-    hle/service/caps/caps_su.h
    hle/service/erpt/erpt.cpp
    hle/service/erpt/erpt.h
    hle/service/es/es.cpp
@@ -609,8 +575,11 @@ target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
 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 json-headers zip)
+    get_directory_property(OPENSSL_LIBS
+        DIRECTORY ${PROJECT_SOURCE_DIR}/externals/libressl
+        DEFINITION OPENSSL_LIBS)
+    target_compile_definitions(core PRIVATE -DCPPHTTPLIB_OPENSSL_SUPPORT -DYUZU_ENABLE_BOXCAT)
+    target_link_libraries(core PRIVATE httplib json-headers ${OPENSSL_LIBS} zip)
 endif()

 if (ENABLE_WEB_SERVICE)
@@ -620,12 +589,8 @@ endif()

 if (ARCHITECTURE_x86_64)
    target_sources(core PRIVATE
-        arm/dynarmic/arm_dynarmic_32.cpp
-        arm/dynarmic/arm_dynarmic_32.h
-        arm/dynarmic/arm_dynarmic_64.cpp
-        arm/dynarmic/arm_dynarmic_64.h
-        arm/dynarmic/arm_dynarmic_cp15.cpp
-        arm/dynarmic/arm_dynarmic_cp15.h
+        arm/dynarmic/arm_dynarmic.cpp
+        arm/dynarmic/arm_dynarmic.h
    )
    target_link_libraries(core PRIVATE dynarmic)
 endif()
@@ -60,7 +60,7 @@ static_assert(sizeof(ELFSymbol) == 0x18, "ELFSymbol has incorrect size.");

 using Symbols = std::vector<std::pair<ELFSymbol, std::string>>;

-Symbols GetSymbols(VAddr text_offset, Core::Memory::Memory& memory) {
+Symbols GetSymbols(VAddr text_offset, Memory::Memory& memory) {
    const auto mod_offset = text_offset + memory.Read32(text_offset + 4);

    if (mod_offset < text_offset || (mod_offset & 0b11) != 0 ||
@@ -123,7 +123,7 @@ Symbols GetSymbols(VAddr text_offset, Core::Memory::Memory& memory) {
 std::optional<std::string> GetSymbolName(const Symbols& symbols, VAddr func_address) {
    const auto iter =
        std::find_if(symbols.begin(), symbols.end(), [func_address](const auto& pair) {
-            const auto& symbol = pair.first;
+            const auto& [symbol, name] = pair;
            const auto end_address = symbol.value + symbol.size;
            return func_address >= symbol.value && func_address < end_address;
        });
@@ -146,7 +146,7 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Interface::GetBacktrace() const {
    auto fp = GetReg(29);
    auto lr = GetReg(30);
    while (true) {
-        out.push_back({"", 0, lr, 0, ""});
+        out.push_back({"", 0, lr, 0});
        if (!fp) {
            break;
        }
@@ -25,33 +25,20 @@ public:
    explicit ARM_Interface(System& system_) : system{system_} {}
    virtual ~ARM_Interface() = default;

-    struct ThreadContext32 {
-        std::array<u32, 16> cpu_registers{};
-        u32 cpsr{};
-        std::array<u8, 4> padding{};
-        std::array<u64, 32> fprs{};
-        u32 fpscr{};
-        u32 fpexc{};
-        u32 tpidr{};
-    };
-    // Internally within the kernel, it expects the AArch32 version of the
-    // thread context to be 344 bytes in size.
-    static_assert(sizeof(ThreadContext32) == 0x158);
-
-    struct ThreadContext64 {
-        std::array<u64, 31> cpu_registers{};
-        u64 sp{};
-        u64 pc{};
-        u32 pstate{};
-        std::array<u8, 4> padding{};
-        std::array<u128, 32> vector_registers{};
-        u32 fpcr{};
-        u32 fpsr{};
-        u64 tpidr{};
+    struct ThreadContext {
+        std::array<u64, 31> cpu_registers;
+        u64 sp;
+        u64 pc;
+        u32 pstate;
+        std::array<u8, 4> padding;
+        std::array<u128, 32> vector_registers;
+        u32 fpcr;
+        u32 fpsr;
+        u64 tpidr;
    };
    // Internally within the kernel, it expects the AArch64 version of the
    // thread context to be 800 bytes in size.
-    static_assert(sizeof(ThreadContext64) == 0x320);
+    static_assert(sizeof(ThreadContext) == 0x320);

    /// Runs the CPU until an event happens
    virtual void Run() = 0;
@@ -143,10 +130,17 @@ public:
     */
    virtual void SetTPIDR_EL0(u64 value) = 0;

-    virtual void SaveContext(ThreadContext32& ctx) = 0;
-    virtual void SaveContext(ThreadContext64& ctx) = 0;
-    virtual void LoadContext(const ThreadContext32& ctx) = 0;
-    virtual void LoadContext(const ThreadContext64& ctx) = 0;
+    /**
+     * Saves the current CPU context
+     * @param ctx Thread context to save
+     */
+    virtual void SaveContext(ThreadContext& ctx) = 0;
+
+    /**
+     * Loads a CPU context
+     * @param ctx Thread context to load
+     */
+    virtual void LoadContext(const ThreadContext& ctx) = 0;

    /// Clears the exclusive monitor's state.
    virtual void ClearExclusiveState() = 0;
@@ -8,27 +8,24 @@
 #include <dynarmic/A64/config.h>
 #include "common/logging/log.h"
 #include "common/microprofile.h"
-#include "common/page_table.h"
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
+#include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/core.h"
-#include "core/core_manager.h"
+#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/gdbstub/gdbstub.h"
-#include "core/hardware_properties.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
-#include "core/settings.h"

 namespace Core {

 using Vector = Dynarmic::A64::Vector;

-class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
+class ARM_Dynarmic_Callbacks : public Dynarmic::A64::UserCallbacks {
 public:
-    explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent) : parent(parent) {}
+    explicit ARM_Dynarmic_Callbacks(ARM_Dynarmic& parent) : parent(parent) {}

    u8 MemoryRead8(u64 vaddr) override {
        return parent.system.Memory().Read8(vaddr);
@@ -69,7 +66,7 @@ public:
        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
                 num_instructions, MemoryReadCode(pc));

-        ARM_Interface::ThreadContext64 ctx;
+        ARM_Interface::ThreadContext ctx;
        parent.SaveContext(ctx);
        parent.inner_unicorn.LoadContext(ctx);
        parent.inner_unicorn.ExecuteInstructions(num_instructions);
@@ -90,8 +87,8 @@ public:
            if (GDBStub::IsServerEnabled()) {
                parent.jit->HaltExecution();
                parent.SetPC(pc);
-                Kernel::Thread* const thread = parent.system.CurrentScheduler().GetCurrentThread();
-                parent.SaveContext(thread->GetContext64());
+                Kernel::Thread* thread = Kernel::GetCurrentThread();
+                parent.SaveContext(thread->GetContext());
                GDBStub::Break();
                GDBStub::SendTrap(thread, 5);
                return;
@@ -104,7 +101,7 @@ public:
    }

    void CallSVC(u32 swi) override {
-        Kernel::Svc::Call(parent.system, swi);
+        Kernel::CallSVC(parent.system, swi);
    }

    void AddTicks(u64 ticks) override {
@@ -127,14 +124,14 @@ public:
        return Timing::CpuCyclesToClockCycles(parent.system.CoreTiming().GetTicks());
    }

-    ARM_Dynarmic_64& parent;
+    ARM_Dynarmic& parent;
    std::size_t num_interpreted_instructions = 0;
    u64 tpidrro_el0 = 0;
    u64 tpidr_el0 = 0;
 };

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

    // Callbacks
@@ -145,8 +142,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;
@@ -157,89 +152,84 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable&
    config.tpidr_el0 = &cb->tpidr_el0;
    config.dczid_el0 = 4;
    config.ctr_el0 = 0x8444c004;
-    config.cntfrq_el0 = Hardware::CNTFREQ;
+    config.cntfrq_el0 = Timing::CNTFREQ;

    // Unpredictable instructions
    config.define_unpredictable_behaviour = true;

-    // Optimizations
-    if (Settings::values.disable_cpu_opt) {
-        config.enable_optimizations = false;
-        config.enable_fast_dispatch = false;
-    }
-
-    return std::make_shared<Dynarmic::A64::Jit>(config);
+    return std::make_unique<Dynarmic::A64::Jit>(config);
 }

-MICROPROFILE_DEFINE(ARM_Jit_Dynarmic_64, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64));
+MICROPROFILE_DEFINE(ARM_Jit_Dynarmic, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64));

-void ARM_Dynarmic_64::Run() {
-    MICROPROFILE_SCOPE(ARM_Jit_Dynarmic_64);
+void ARM_Dynarmic::Run() {
+    MICROPROFILE_SCOPE(ARM_Jit_Dynarmic);

    jit->Run();
 }

-void ARM_Dynarmic_64::Step() {
+void ARM_Dynarmic::Step() {
    cb->InterpreterFallback(jit->GetPC(), 1);
 }

-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_Dynarmic::ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor,
+                           std::size_t core_index)
+    : ARM_Interface{system},
+      cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), inner_unicorn{system},
+      core_index{core_index}, exclusive_monitor{
+                                  dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}

-ARM_Dynarmic_64::~ARM_Dynarmic_64() = default;
+ARM_Dynarmic::~ARM_Dynarmic() = default;

-void ARM_Dynarmic_64::SetPC(u64 pc) {
+void ARM_Dynarmic::SetPC(u64 pc) {
    jit->SetPC(pc);
 }

-u64 ARM_Dynarmic_64::GetPC() const {
+u64 ARM_Dynarmic::GetPC() const {
    return jit->GetPC();
 }

-u64 ARM_Dynarmic_64::GetReg(int index) const {
+u64 ARM_Dynarmic::GetReg(int index) const {
    return jit->GetRegister(index);
 }

-void ARM_Dynarmic_64::SetReg(int index, u64 value) {
+void ARM_Dynarmic::SetReg(int index, u64 value) {
    jit->SetRegister(index, value);
 }

-u128 ARM_Dynarmic_64::GetVectorReg(int index) const {
+u128 ARM_Dynarmic::GetVectorReg(int index) const {
    return jit->GetVector(index);
 }

-void ARM_Dynarmic_64::SetVectorReg(int index, u128 value) {
+void ARM_Dynarmic::SetVectorReg(int index, u128 value) {
    jit->SetVector(index, value);
 }

-u32 ARM_Dynarmic_64::GetPSTATE() const {
+u32 ARM_Dynarmic::GetPSTATE() const {
    return jit->GetPstate();
 }

-void ARM_Dynarmic_64::SetPSTATE(u32 pstate) {
+void ARM_Dynarmic::SetPSTATE(u32 pstate) {
    jit->SetPstate(pstate);
 }

-u64 ARM_Dynarmic_64::GetTlsAddress() const {
+u64 ARM_Dynarmic::GetTlsAddress() const {
    return cb->tpidrro_el0;
 }

-void ARM_Dynarmic_64::SetTlsAddress(VAddr address) {
+void ARM_Dynarmic::SetTlsAddress(VAddr address) {
    cb->tpidrro_el0 = address;
 }

-u64 ARM_Dynarmic_64::GetTPIDR_EL0() const {
+u64 ARM_Dynarmic::GetTPIDR_EL0() const {
    return cb->tpidr_el0;
 }

-void ARM_Dynarmic_64::SetTPIDR_EL0(u64 value) {
+void ARM_Dynarmic::SetTPIDR_EL0(u64 value) {
    cb->tpidr_el0 = value;
 }

-void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) {
+void ARM_Dynarmic::SaveContext(ThreadContext& ctx) {
    ctx.cpu_registers = jit->GetRegisters();
    ctx.sp = jit->GetSP();
    ctx.pc = jit->GetPC();
@@ -250,7 +240,7 @@ void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) {
    ctx.tpidr = cb->tpidr_el0;
 }

-void ARM_Dynarmic_64::LoadContext(const ThreadContext64& ctx) {
+void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
    jit->SetRegisters(ctx.cpu_registers);
    jit->SetSP(ctx.sp);
    jit->SetPC(ctx.pc);
@@ -261,32 +251,25 @@ void ARM_Dynarmic_64::LoadContext(const ThreadContext64& ctx) {
    SetTPIDR_EL0(ctx.tpidr);
 }

-void ARM_Dynarmic_64::PrepareReschedule() {
+void ARM_Dynarmic::PrepareReschedule() {
    jit->HaltExecution();
 }

-void ARM_Dynarmic_64::ClearInstructionCache() {
+void ARM_Dynarmic::ClearInstructionCache() {
    jit->ClearCache();
 }

-void ARM_Dynarmic_64::ClearExclusiveState() {
+void ARM_Dynarmic::ClearExclusiveState() {
    jit->ClearExclusiveState();
 }

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

-DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(Memory::Memory& memory, std::size_t core_count)
-    : monitor(core_count), memory{memory} {}
+DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(Memory::Memory& memory_, std::size_t core_count)
+    : monitor(core_count), memory{memory_} {}

 DynarmicExclusiveMonitor::~DynarmicExclusiveMonitor() = default;

@@ -5,30 +5,27 @@
 #pragma once

 #include <memory>
-#include <unordered_map>
-
 #include <dynarmic/A64/a64.h>
 #include <dynarmic/A64/exclusive_monitor.h>
 #include "common/common_types.h"
-#include "common/hash.h"
 #include "core/arm/arm_interface.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"

-namespace Core::Memory {
+namespace Memory {
 class Memory;
 }

 namespace Core {

-class DynarmicCallbacks64;
+class ARM_Dynarmic_Callbacks;
 class DynarmicExclusiveMonitor;
 class System;

-class ARM_Dynarmic_64 final : public ARM_Interface {
+class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic_64(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
-    ~ARM_Dynarmic_64() override;
+    ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
+    ~ARM_Dynarmic() override;

    void SetPC(u64 pc) override;
    u64 GetPC() const override;
@@ -45,10 +42,8 @@ public:
    void SetTPIDR_EL0(u64 value) override;
    u64 GetTPIDR_EL0() const override;

-    void SaveContext(ThreadContext32& ctx) override {}
-    void SaveContext(ThreadContext64& ctx) override;
-    void LoadContext(const ThreadContext32& ctx) override {}
-    void LoadContext(const ThreadContext64& ctx) override;
+    void SaveContext(ThreadContext& ctx) override;
+    void LoadContext(const ThreadContext& ctx) override;

    void PrepareReschedule() override;
    void ClearExclusiveState() override;
@@ -58,17 +53,12 @@ public:
                          std::size_t new_address_space_size_in_bits) override;

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

-    using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
-    using JitCacheType =
-        std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A64::Jit>, Common::PairHash>;
-
-    friend class DynarmicCallbacks64;
-    std::unique_ptr<DynarmicCallbacks64> cb;
-    JitCacheType jit_cache;
-    std::shared_ptr<Dynarmic::A64::Jit> jit;
+    friend class ARM_Dynarmic_Callbacks;
+    std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
+    std::unique_ptr<Dynarmic::A64::Jit> jit;
    ARM_Unicorn inner_unicorn;

    std::size_t core_index;
@@ -77,7 +67,7 @@ private:

 class DynarmicExclusiveMonitor final : public ExclusiveMonitor {
 public:
-    explicit DynarmicExclusiveMonitor(Memory::Memory& memory, std::size_t core_count);
+    explicit DynarmicExclusiveMonitor(Memory::Memory& memory_, std::size_t core_count);
    ~DynarmicExclusiveMonitor() override;

    void SetExclusive(std::size_t core_index, VAddr addr) override;
@@ -90,9 +80,9 @@ public:
    bool ExclusiveWrite128(std::size_t core_index, VAddr vaddr, u128 value) override;

 private:
-    friend class ARM_Dynarmic_64;
+    friend class ARM_Dynarmic;
    Dynarmic::A64::ExclusiveMonitor monitor;
-    Core::Memory::Memory& memory;
+    Memory::Memory& memory;
 };

 } // namespace Core
@@ -1,208 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cinttypes>
-#include <memory>
-#include <dynarmic/A32/a32.h>
-#include <dynarmic/A32/config.h>
-#include <dynarmic/A32/context.h>
-#include "common/microprofile.h"
-#include "core/arm/dynarmic/arm_dynarmic_32.h"
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
-#include "core/arm/dynarmic/arm_dynarmic_cp15.h"
-#include "core/core.h"
-#include "core/core_manager.h"
-#include "core/core_timing.h"
-#include "core/hle/kernel/svc.h"
-#include "core/memory.h"
-
-namespace Core {
-
-class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
-public:
-    explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent) : parent(parent) {}
-
-    u8 MemoryRead8(u32 vaddr) override {
-        return parent.system.Memory().Read8(vaddr);
-    }
-    u16 MemoryRead16(u32 vaddr) override {
-        return parent.system.Memory().Read16(vaddr);
-    }
-    u32 MemoryRead32(u32 vaddr) override {
-        return parent.system.Memory().Read32(vaddr);
-    }
-    u64 MemoryRead64(u32 vaddr) override {
-        return parent.system.Memory().Read64(vaddr);
-    }
-
-    void MemoryWrite8(u32 vaddr, u8 value) override {
-        parent.system.Memory().Write8(vaddr, value);
-    }
-    void MemoryWrite16(u32 vaddr, u16 value) override {
-        parent.system.Memory().Write16(vaddr, value);
-    }
-    void MemoryWrite32(u32 vaddr, u32 value) override {
-        parent.system.Memory().Write32(vaddr, value);
-    }
-    void MemoryWrite64(u32 vaddr, u64 value) override {
-        parent.system.Memory().Write64(vaddr, value);
-    }
-
-    void InterpreterFallback(u32 pc, std::size_t num_instructions) override {
-        UNIMPLEMENTED();
-    }
-
-    void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
-        switch (exception) {
-        case Dynarmic::A32::Exception::UndefinedInstruction:
-        case Dynarmic::A32::Exception::UnpredictableInstruction:
-            break;
-        case Dynarmic::A32::Exception::Breakpoint:
-            break;
-        }
-        LOG_CRITICAL(HW_GPU, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
-                     static_cast<std::size_t>(exception), pc, MemoryReadCode(pc));
-        UNIMPLEMENTED();
-    }
-
-    void CallSVC(u32 swi) override {
-        Kernel::Svc::Call(parent.system, swi);
-    }
-
-    void AddTicks(u64 ticks) override {
-        // Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a
-        // rough approximation of the amount of executed ticks in the system, it may be thrown off
-        // if not all cores are doing a similar amount of work. Instead of doing this, we should
-        // device a way so that timing is consistent across all cores without increasing the ticks 4
-        // times.
-        u64 amortized_ticks = (ticks - num_interpreted_instructions) / Core::NUM_CPU_CORES;
-        // Always execute at least one tick.
-        amortized_ticks = std::max<u64>(amortized_ticks, 1);
-
-        parent.system.CoreTiming().AddTicks(amortized_ticks);
-        num_interpreted_instructions = 0;
-    }
-    u64 GetTicksRemaining() override {
-        return std::max(parent.system.CoreTiming().GetDowncount(), {});
-    }
-
-    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,
-                                                             std::size_t address_space_bits) const {
-    Dynarmic::A32::UserConfig config;
-    config.callbacks = cb.get();
-    // TODO(bunnei): Implement page table for 32-bit
-    // config.page_table = &page_table.pointers;
-    config.coprocessors[15] = std::make_shared<DynarmicCP15>((u32*)&CP15_regs[0]);
-    config.define_unpredictable_behaviour = true;
-    return std::make_unique<Dynarmic::A32::Jit>(config);
-}
-
-MICROPROFILE_DEFINE(ARM_Jit_Dynarmic_32, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64));
-
-void ARM_Dynarmic_32::Run() {
-    MICROPROFILE_SCOPE(ARM_Jit_Dynarmic_32);
-    jit->Run();
-}
-
-void ARM_Dynarmic_32::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)), core_index{core_index},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
-
-ARM_Dynarmic_32::~ARM_Dynarmic_32() = default;
-
-void ARM_Dynarmic_32::SetPC(u64 pc) {
-    jit->Regs()[15] = static_cast<u32>(pc);
-}
-
-u64 ARM_Dynarmic_32::GetPC() const {
-    return jit->Regs()[15];
-}
-
-u64 ARM_Dynarmic_32::GetReg(int index) const {
-    return jit->Regs()[index];
-}
-
-void ARM_Dynarmic_32::SetReg(int index, u64 value) {
-    jit->Regs()[index] = static_cast<u32>(value);
-}
-
-u128 ARM_Dynarmic_32::GetVectorReg(int index) const {
-    return {};
-}
-
-void ARM_Dynarmic_32::SetVectorReg(int index, u128 value) {}
-
-u32 ARM_Dynarmic_32::GetPSTATE() const {
-    return jit->Cpsr();
-}
-
-void ARM_Dynarmic_32::SetPSTATE(u32 cpsr) {
-    jit->SetCpsr(cpsr);
-}
-
-u64 ARM_Dynarmic_32::GetTlsAddress() const {
-    return CP15_regs[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)];
-}
-
-void ARM_Dynarmic_32::SetTlsAddress(VAddr address) {
-    CP15_regs[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)] = static_cast<u32>(address);
-}
-
-u64 ARM_Dynarmic_32::GetTPIDR_EL0() const {
-    return cb->tpidr_el0;
-}
-
-void ARM_Dynarmic_32::SetTPIDR_EL0(u64 value) {
-    cb->tpidr_el0 = value;
-}
-
-void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) {
-    Dynarmic::A32::Context context;
-    jit->SaveContext(context);
-    ctx.cpu_registers = context.Regs();
-    ctx.cpsr = context.Cpsr();
-}
-
-void ARM_Dynarmic_32::LoadContext(const ThreadContext32& ctx) {
-    Dynarmic::A32::Context context;
-    context.Regs() = ctx.cpu_registers;
-    context.SetCpsr(ctx.cpsr);
-    jit->LoadContext(context);
-}
-
-void ARM_Dynarmic_32::PrepareReschedule() {
-    jit->HaltExecution();
-}
-
-void ARM_Dynarmic_32::ClearInstructionCache() {
-    jit->ClearCache();
-}
-
-void ARM_Dynarmic_32::ClearExclusiveState() {}
-
-void ARM_Dynarmic_32::PageTableChanged(Common::PageTable& page_table,
-                                       std::size_t new_address_space_size_in_bits) {
-    auto key = std::make_pair(&page_table, new_address_space_size_in_bits);
-    auto iter = jit_cache.find(key);
-    if (iter != jit_cache.end()) {
-        jit = iter->second;
-        return;
-    }
-    jit = MakeJit(page_table, new_address_space_size_in_bits);
-    jit_cache.emplace(key, jit);
-}
-
-} // namespace Core
@@ -1,77 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <unordered_map>
-
-#include <dynarmic/A32/a32.h>
-#include <dynarmic/A64/a64.h>
-#include <dynarmic/A64/exclusive_monitor.h>
-#include "common/common_types.h"
-#include "common/hash.h"
-#include "core/arm/arm_interface.h"
-#include "core/arm/exclusive_monitor.h"
-
-namespace Core::Memory {
-class Memory;
-}
-
-namespace Core {
-
-class DynarmicCallbacks32;
-class DynarmicExclusiveMonitor;
-class System;
-
-class ARM_Dynarmic_32 final : public ARM_Interface {
-public:
-    ARM_Dynarmic_32(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
-    ~ARM_Dynarmic_32() override;
-
-    void SetPC(u64 pc) override;
-    u64 GetPC() const override;
-    u64 GetReg(int index) const override;
-    void SetReg(int index, u64 value) override;
-    u128 GetVectorReg(int index) const override;
-    void SetVectorReg(int index, u128 value) override;
-    u32 GetPSTATE() const override;
-    void SetPSTATE(u32 pstate) override;
-    void Run() override;
-    void Step() override;
-    VAddr GetTlsAddress() const override;
-    void SetTlsAddress(VAddr address) override;
-    void SetTPIDR_EL0(u64 value) override;
-    u64 GetTPIDR_EL0() const override;
-
-    void SaveContext(ThreadContext32& ctx) override;
-    void SaveContext(ThreadContext64& ctx) override {}
-    void LoadContext(const ThreadContext32& ctx) override;
-    void LoadContext(const ThreadContext64& ctx) override {}
-
-    void PrepareReschedule() override;
-    void ClearExclusiveState() override;
-
-    void ClearInstructionCache() override;
-    void PageTableChanged(Common::PageTable& new_page_table,
-                          std::size_t new_address_space_size_in_bits) override;
-
-private:
-    std::shared_ptr<Dynarmic::A32::Jit> MakeJit(Common::PageTable& page_table,
-                                                std::size_t address_space_bits) const;
-
-    using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
-    using JitCacheType =
-        std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A32::Jit>, Common::PairHash>;
-
-    friend class DynarmicCallbacks32;
-    std::unique_ptr<DynarmicCallbacks32> cb;
-    JitCacheType jit_cache;
-    std::shared_ptr<Dynarmic::A32::Jit> jit;
-    std::size_t core_index;
-    DynarmicExclusiveMonitor& exclusive_monitor;
-    std::array<u32, 84> CP15_regs{};
-};
-
-} // namespace Core
@@ -1,80 +0,0 @@
-// Copyright 2017 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/arm/dynarmic/arm_dynarmic_cp15.h"
-
-using Callback = Dynarmic::A32::Coprocessor::Callback;
-using CallbackOrAccessOneWord = Dynarmic::A32::Coprocessor::CallbackOrAccessOneWord;
-using CallbackOrAccessTwoWords = Dynarmic::A32::Coprocessor::CallbackOrAccessTwoWords;
-
-std::optional<Callback> DynarmicCP15::CompileInternalOperation(bool two, unsigned opc1,
-                                                               CoprocReg CRd, CoprocReg CRn,
-                                                               CoprocReg CRm, unsigned 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) {
-        // This is a dummy write, we ignore the value written here.
-        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:
-            // This is a dummy write, we ignore the value written here.
-            return &CP15[static_cast<std::size_t>(CP15Register::CP15_DATA_SYNC_BARRIER)];
-        case 5:
-            // This is a dummy write, we ignore the value written here.
-            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) {
-        return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_UPRW)];
-    }
-
-    return {};
-}
-
-CallbackOrAccessTwoWords DynarmicCP15::CompileSendTwoWords(bool two, unsigned opc, CoprocReg 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:
-            return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_UPRW)];
-        case 3:
-            return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)];
-        default:
-            return {};
-        }
-    }
-
-    return {};
-}
-
-CallbackOrAccessTwoWords DynarmicCP15::CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) {
-    return {};
-}
-
-std::optional<Callback> DynarmicCP15::CompileLoadWords(bool two, bool long_transfer, CoprocReg CRd,
-                                                       std::optional<u8> option) {
-    return {};
-}
-
-std::optional<Callback> DynarmicCP15::CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
-                                                        std::optional<u8> option) {
-    return {};
-}
@@ -1,152 +0,0 @@
-// Copyright 2017 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <optional>
-
-#include <dynarmic/A32/coprocessor.h>
-#include "common/common_types.h"
-
-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,
-
-    // 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(u32* cp15) : CP15(cp15){};
-
-    std::optional<Callback> CompileInternalOperation(bool two, unsigned opc1, CoprocReg CRd,
-                                                     CoprocReg CRn, CoprocReg CRm,
-                                                     unsigned opc2) override;
-    CallbackOrAccessOneWord CompileSendOneWord(bool two, unsigned opc1, CoprocReg CRn,
-                                               CoprocReg CRm, unsigned opc2) override;
-    CallbackOrAccessTwoWords CompileSendTwoWords(bool two, unsigned opc, CoprocReg CRm) override;
-    CallbackOrAccessOneWord CompileGetOneWord(bool two, unsigned opc1, CoprocReg CRn, CoprocReg CRm,
-                                              unsigned opc2) override;
-    CallbackOrAccessTwoWords CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) override;
-    std::optional<Callback> CompileLoadWords(bool two, bool long_transfer, CoprocReg CRd,
-                                             std::optional<u8> option) override;
-    std::optional<Callback> CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
-                                              std::optional<u8> option) override;
-
-private:
-    u32* CP15{};
-};
@@ -2,24 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#ifdef ARCHITECTURE_x86_64
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
-#endif
 #include "core/arm/exclusive_monitor.h"
-#include "core/memory.h"

 namespace Core {

 ExclusiveMonitor::~ExclusiveMonitor() = default;

-std::unique_ptr<Core::ExclusiveMonitor> MakeExclusiveMonitor(Memory::Memory& memory,
-                                                             std::size_t num_cores) {
-#ifdef ARCHITECTURE_x86_64
-    return std::make_unique<Core::DynarmicExclusiveMonitor>(memory, num_cores);
-#else
-    // TODO(merry): Passthrough exclusive monitor
-    return nullptr;
-#endif
-}
-
 } // namespace Core
@@ -4,14 +4,8 @@

 #pragma once

-#include <memory>
-
 #include "common/common_types.h"

-namespace Core::Memory {
-class Memory;
-}
-
 namespace Core {

 class ExclusiveMonitor {
@@ -28,7 +22,4 @@ public:
    virtual bool ExclusiveWrite128(std::size_t core_index, VAddr vaddr, u128 value) = 0;
 };

-std::unique_ptr<Core::ExclusiveMonitor> MakeExclusiveMonitor(Memory::Memory& memory,
-                                                             std::size_t num_cores);
-
 } // namespace Core
@@ -9,9 +9,7 @@
 #include "core/arm/unicorn/arm_unicorn.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/svc.h"
-#include "core/memory.h"

 namespace Core {

@@ -54,7 +52,7 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
                               void* user_data) {
    auto* const system = static_cast<System*>(user_data);

-    ARM_Interface::ThreadContext64 ctx{};
+    ARM_Interface::ThreadContext ctx{};
    system->CurrentArmInterface().SaveContext(ctx);
    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x{:X}, pc=0x{:X}, lr=0x{:X}", addr,
               ctx.pc, ctx.cpu_registers[30]);
@@ -62,9 +60,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,25 +170,15 @@ 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) {
            uc_reg_write(uc, UC_ARM64_REG_PC, &last_bkpt.address);
        }

-        Kernel::Thread* const thread = system.CurrentScheduler().GetCurrentThread();
-        SaveContext(thread->GetContext64());
+        Kernel::Thread* thread = Kernel::GetCurrentThread();
+        SaveContext(thread->GetContext());
        if (last_bkpt_hit || GDBStub::IsMemoryBreak() || GDBStub::GetCpuStepFlag()) {
            last_bkpt_hit = false;
            GDBStub::Break();
@@ -200,7 +187,7 @@ void ARM_Unicorn::ExecuteInstructions(std::size_t num_instructions) {
    }
 }

-void ARM_Unicorn::SaveContext(ThreadContext64& ctx) {
+void ARM_Unicorn::SaveContext(ThreadContext& ctx) {
    int uregs[32];
    void* tregs[32];

@@ -227,7 +214,7 @@ void ARM_Unicorn::SaveContext(ThreadContext64& ctx) {
    CHECKED(uc_reg_read_batch(uc, uregs, tregs, 32));
 }

-void ARM_Unicorn::LoadContext(const ThreadContext64& ctx) {
+void ARM_Unicorn::LoadContext(const ThreadContext& ctx) {
    int uregs[32];
    void* tregs[32];

@@ -278,7 +265,7 @@ void ARM_Unicorn::InterruptHook(uc_engine* uc, u32 int_no, void* user_data) {

    switch (ec) {
    case 0x15: // SVC
-        Kernel::Svc::Call(arm_instance->system, iss);
+        Kernel::CallSVC(arm_instance->system, iss);
        break;
    }
 }
@@ -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;
@@ -35,6 +30,8 @@ public:
    void SetTlsAddress(VAddr address) override;
    void SetTPIDR_EL0(u64 value) override;
    u64 GetTPIDR_EL0() const override;
+    void SaveContext(ThreadContext& ctx) override;
+    void LoadContext(const ThreadContext& ctx) override;
    void PrepareReschedule() override;
    void ClearExclusiveState() override;
    void ExecuteInstructions(std::size_t num_instructions);
@@ -44,11 +41,6 @@ public:
    void PageTableChanged(Common::PageTable&, std::size_t) override {}
    void RecordBreak(GDBStub::BreakpointAddress bkpt);

-    void SaveContext(ThreadContext32& ctx) override {}
-    void SaveContext(ThreadContext64& ctx) override;
-    void LoadContext(const ThreadContext32& ctx) override {}
-    void LoadContext(const ThreadContext64& ctx) override;
-
 private:
    static void InterruptHook(uc_engine* uc, u32 int_no, void* user_data);

@@ -11,10 +11,9 @@
 #include "common/string_util.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
-#include "core/core_manager.h"
+#include "core/core_cpu.h"
 #include "core/core_timing.h"
-#include "core/cpu_manager.h"
-#include "core/device_memory.h"
+#include "core/cpu_core_manager.h"
 #include "core/file_sys/bis_factory.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/mode.h"
@@ -29,7 +28,6 @@
 #include "core/hardware_interrupt_manager.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
@@ -115,25 +113,16 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 struct System::Impl {
    explicit Impl(System& system)
        : kernel{system}, fs_controller{system}, memory{system},
-          cpu_manager{system}, reporter{system}, applet_manager{system} {}
+          cpu_core_manager{system}, reporter{system}, applet_manager{system} {}

-    CoreManager& CurrentCoreManager() {
-        return cpu_manager.GetCurrentCoreManager();
-    }
-
-    Kernel::PhysicalCore& CurrentPhysicalCore() {
-        const auto index = cpu_manager.GetActiveCoreIndex();
-        return kernel.PhysicalCore(index);
-    }
-
-    Kernel::PhysicalCore& GetPhysicalCore(std::size_t index) {
-        return kernel.PhysicalCore(index);
+    Cpu& CurrentCpuCore() {
+        return cpu_core_manager.GetCurrentCore();
    }

    ResultStatus RunLoop(bool tight_loop) {
        status = ResultStatus::Success;

-        cpu_manager.RunLoop(tight_loop);
+        cpu_core_manager.RunLoop(tight_loop);

        return status;
    }
@@ -141,11 +130,9 @@ struct System::Impl {
    ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
        LOG_DEBUG(HW_Memory, "initialized OK");

-        device_memory = std::make_unique<Core::DeviceMemory>(system);
-
        core_timing.Initialize();
+        cpu_core_manager.Initialize();
        kernel.Initialize();
-        cpu_manager.Initialize();

        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::system_clock::now().time_since_epoch());
@@ -168,14 +155,14 @@ struct System::Impl {
        service_manager = std::make_shared<Service::SM::ServiceManager>();

        Service::Init(service_manager, system);
-        GDBStub::DeferStart();
+        GDBStub::Init();

-        interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
-        gpu_core = VideoCore::CreateGPU(emu_window, system);
-        if (!gpu_core) {
+        renderer = VideoCore::CreateRenderer(emu_window, system);
+        if (!renderer->Init()) {
            return ResultStatus::ErrorVideoCore;
        }
-        gpu_core->Renderer().Rasterizer().SetupDirtyFlags();
+        interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
+        gpu_core = VideoCore::CreateGPU(system);

        is_powered_on = true;
        exit_lock = false;
@@ -215,6 +202,11 @@ struct System::Impl {
        AddGlueRegistrationForProcess(*app_loader, *main_process);
        kernel.MakeCurrentProcess(main_process.get());

+        // Main process has been loaded and been made current.
+        // Begin GPU and CPU execution.
+        gpu_core->Start();
+        cpu_core_manager.StartThreads();
+
        // Initialize cheat engine
        if (cheat_engine) {
            cheat_engine->Initialize();
@@ -267,11 +259,10 @@ struct System::Impl {
        is_powered_on = false;
        exit_lock = false;

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

        // Shutdown emulation session
+        renderer.reset();
        GDBStub::Shutdown();
        Service::Shutdown();
        service_manager.reset();
@@ -279,10 +270,9 @@ struct System::Impl {
        telemetry_session.reset();
        perf_stats.reset();
        gpu_core.reset();
-        device_memory.reset();

        // Close all CPU/threading state
-        cpu_manager.Shutdown();
+        cpu_core_manager.Shutdown();

        // Shutdown kernel and core timing
        kernel.Shutdown();
@@ -348,11 +338,11 @@ struct System::Impl {
    Service::FileSystem::FileSystemController fs_controller;
    /// AppLoader used to load the current executing application
    std::unique_ptr<Loader::AppLoader> app_loader;
+    std::unique_ptr<VideoCore::RendererBase> renderer;
    std::unique_ptr<Tegra::GPU> gpu_core;
    std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
-    std::unique_ptr<Core::DeviceMemory> device_memory;
-    Core::Memory::Memory memory;
-    CpuManager cpu_manager;
+    Memory::Memory memory;
+    CpuCoreManager cpu_core_manager;
    bool is_powered_on = false;
    bool exit_lock = false;

@@ -387,12 +377,12 @@ struct System::Impl {
 System::System() : impl{std::make_unique<Impl>(*this)} {}
 System::~System() = default;

-CoreManager& System::CurrentCoreManager() {
-    return impl->CurrentCoreManager();
+Cpu& System::CurrentCpuCore() {
+    return impl->CurrentCpuCore();
 }

-const CoreManager& System::CurrentCoreManager() const {
-    return impl->CurrentCoreManager();
+const Cpu& System::CurrentCpuCore() const {
+    return impl->CurrentCpuCore();
 }

 System::ResultStatus System::RunLoop(bool tight_loop) {
@@ -404,7 +394,7 @@ System::ResultStatus System::SingleStep() {
 }

 void System::InvalidateCpuInstructionCaches() {
-    impl->kernel.InvalidateAllInstructionCaches();
+    impl->cpu_core_manager.InvalidateAllInstructionCaches();
 }

 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
@@ -416,11 +406,13 @@ bool System::IsPoweredOn() const {
 }

 void System::PrepareReschedule() {
-    impl->CurrentPhysicalCore().Stop();
+    CurrentCpuCore().PrepareReschedule();
 }

 void System::PrepareReschedule(const u32 core_index) {
-    impl->kernel.PrepareReschedule(core_index);
+    if (core_index < GlobalScheduler().CpuCoresCount()) {
+        CpuCore(core_index).PrepareReschedule();
+    }
 }

 PerfStatsResults System::GetAndResetPerfStats() {
@@ -436,31 +428,31 @@ const TelemetrySession& System::TelemetrySession() const {
 }

 ARM_Interface& System::CurrentArmInterface() {
-    return impl->CurrentPhysicalCore().ArmInterface();
+    return CurrentCpuCore().ArmInterface();
 }

 const ARM_Interface& System::CurrentArmInterface() const {
-    return impl->CurrentPhysicalCore().ArmInterface();
+    return CurrentCpuCore().ArmInterface();
 }

 std::size_t System::CurrentCoreIndex() const {
-    return impl->cpu_manager.GetActiveCoreIndex();
+    return CurrentCpuCore().CoreIndex();
 }

 Kernel::Scheduler& System::CurrentScheduler() {
-    return impl->CurrentPhysicalCore().Scheduler();
+    return CurrentCpuCore().Scheduler();
 }

 const Kernel::Scheduler& System::CurrentScheduler() const {
-    return impl->CurrentPhysicalCore().Scheduler();
+    return CurrentCpuCore().Scheduler();
 }

 Kernel::Scheduler& System::Scheduler(std::size_t core_index) {
-    return impl->GetPhysicalCore(core_index).Scheduler();
+    return CpuCore(core_index).Scheduler();
 }

 const Kernel::Scheduler& System::Scheduler(std::size_t core_index) const {
-    return impl->GetPhysicalCore(core_index).Scheduler();
+    return CpuCore(core_index).Scheduler();
 }

 /// Gets the global scheduler
@@ -477,48 +469,40 @@ Kernel::Process* System::CurrentProcess() {
    return impl->kernel.CurrentProcess();
 }

-Core::DeviceMemory& System::DeviceMemory() {
-    return *impl->device_memory;
-}
-
-const Core::DeviceMemory& System::DeviceMemory() const {
-    return *impl->device_memory;
-}
-
 const Kernel::Process* System::CurrentProcess() const {
    return impl->kernel.CurrentProcess();
 }

 ARM_Interface& System::ArmInterface(std::size_t core_index) {
-    return impl->GetPhysicalCore(core_index).ArmInterface();
+    return CpuCore(core_index).ArmInterface();
 }

 const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
-    return impl->GetPhysicalCore(core_index).ArmInterface();
+    return CpuCore(core_index).ArmInterface();
 }

-CoreManager& System::GetCoreManager(std::size_t core_index) {
-    return impl->cpu_manager.GetCoreManager(core_index);
+Cpu& System::CpuCore(std::size_t core_index) {
+    return impl->cpu_core_manager.GetCore(core_index);
 }

-const CoreManager& System::GetCoreManager(std::size_t core_index) const {
+const Cpu& System::CpuCore(std::size_t core_index) const {
    ASSERT(core_index < NUM_CPU_CORES);
-    return impl->cpu_manager.GetCoreManager(core_index);
+    return impl->cpu_core_manager.GetCore(core_index);
 }

 ExclusiveMonitor& System::Monitor() {
-    return impl->kernel.GetExclusiveMonitor();
+    return impl->cpu_core_manager.GetExclusiveMonitor();
 }

 const ExclusiveMonitor& System::Monitor() const {
-    return impl->kernel.GetExclusiveMonitor();
+    return impl->cpu_core_manager.GetExclusiveMonitor();
 }

 Memory::Memory& System::Memory() {
    return impl->memory;
 }

-const Core::Memory::Memory& System::Memory() const {
+const Memory::Memory& System::Memory() const {
    return impl->memory;
 }

@@ -539,11 +523,11 @@ const Core::Hardware::InterruptManager& System::InterruptManager() const {
 }

 VideoCore::RendererBase& System::Renderer() {
-    return impl->gpu_core->Renderer();
+    return *impl->renderer;
 }

 const VideoCore::RendererBase& System::Renderer() const {
-    return impl->gpu_core->Renderer();
+    return *impl->renderer;
 }

 Kernel::KernelCore& System::Kernel() {
@@ -714,12 +698,4 @@ const Service::SM::ServiceManager& System::ServiceManager() const {
    return *impl->service_manager;
 }

-void System::RegisterCoreThread(std::size_t id) {
-    impl->kernel.RegisterCoreThread(id);
-}
-
-void System::RegisterHostThread() {
-    impl->kernel.RegisterHostThread();
-}
-
 } // namespace Core
@@ -36,10 +36,9 @@ class AppLoader;
 enum class ResultStatus : u16;
 } // namespace Loader

-namespace Core::Memory {
+namespace Memory {
 struct CheatEntry;
-class Memory;
-} // namespace Core::Memory
+} // namespace Memory

 namespace Service {

@@ -87,11 +86,14 @@ namespace Core::Hardware {
 class InterruptManager;
 }

+namespace Memory {
+class Memory;
+}
+
 namespace Core {

 class ARM_Interface;
-class CoreManager;
-class DeviceMemory;
+class Cpu;
 class ExclusiveMonitor;
 class FrameLimiter;
 class PerfStats;
@@ -216,10 +218,10 @@ public:
    const ARM_Interface& ArmInterface(std::size_t core_index) const;

    /// Gets a CPU interface to the CPU core with the specified index
-    CoreManager& GetCoreManager(std::size_t core_index);
+    Cpu& CpuCore(std::size_t core_index);

    /// Gets a CPU interface to the CPU core with the specified index
-    const CoreManager& GetCoreManager(std::size_t core_index) const;
+    const Cpu& CpuCore(std::size_t core_index) const;

    /// Gets a reference to the exclusive monitor
    ExclusiveMonitor& Monitor();
@@ -228,10 +230,10 @@ public:
    const ExclusiveMonitor& Monitor() const;

    /// Gets a mutable reference to the system memory instance.
-    Core::Memory::Memory& Memory();
+    Memory::Memory& Memory();

    /// Gets a constant reference to the system memory instance.
-    const Core::Memory::Memory& Memory() const;
+    const Memory::Memory& Memory() const;

    /// Gets a mutable reference to the GPU interface
    Tegra::GPU& GPU();
@@ -257,12 +259,6 @@ public:
    /// Gets the global scheduler
    const Kernel::GlobalScheduler& GlobalScheduler() const;

-    /// Gets the manager for the guest device memory
-    Core::DeviceMemory& DeviceMemory();
-
-    /// Gets the manager for the guest device memory
-    const Core::DeviceMemory& DeviceMemory() const;
-
    /// Provides a pointer to the current process
    Kernel::Process* CurrentProcess();

@@ -364,20 +360,14 @@ public:

    const CurrentBuildProcessID& GetCurrentProcessBuildID() const;

-    /// Register a host thread as an emulated CPU Core.
-    void RegisterCoreThread(std::size_t id);
-
-    /// Register a host thread as an auxiliary thread.
-    void RegisterHostThread();
-
 private:
    System();

    /// Returns the currently running CPU core
-    CoreManager& CurrentCoreManager();
+    Cpu& CurrentCpuCore();

    /// Returns the currently running CPU core
-    const CoreManager& CurrentCoreManager() const;
+    const Cpu& CurrentCpuCore() const;

    /**
     * Initialize the emulated system.
@@ -0,0 +1,127 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <condition_variable>
+#include <mutex>
+
+#include "common/logging/log.h"
+#ifdef ARCHITECTURE_x86_64
+#include "core/arm/dynarmic/arm_dynarmic.h"
+#endif
+#include "core/arm/exclusive_monitor.h"
+#include "core/arm/unicorn/arm_unicorn.h"
+#include "core/core.h"
+#include "core/core_cpu.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/scheduler.h"
+#include "core/hle/kernel/thread.h"
+#include "core/hle/lock.h"
+#include "core/settings.h"
+
+namespace Core {
+
+void CpuBarrier::NotifyEnd() {
+    std::unique_lock lock{mutex};
+    end = true;
+    condition.notify_all();
+}
+
+bool CpuBarrier::Rendezvous() {
+    if (!Settings::values.use_multi_core) {
+        // Meaningless when running in single-core mode
+        return true;
+    }
+
+    if (!end) {
+        std::unique_lock lock{mutex};
+
+        --cores_waiting;
+        if (!cores_waiting) {
+            cores_waiting = NUM_CPU_CORES;
+            condition.notify_all();
+            return true;
+        }
+
+        condition.wait(lock);
+        return true;
+    }
+
+    return false;
+}
+
+Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
+         std::size_t core_index)
+    : cpu_barrier{cpu_barrier}, global_scheduler{system.GlobalScheduler()},
+      core_timing{system.CoreTiming()}, core_index{core_index} {
+#ifdef ARCHITECTURE_x86_64
+    arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
+#else
+    arm_interface = std::make_unique<ARM_Unicorn>(system);
+    LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
+#endif
+
+    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
+}
+
+Cpu::~Cpu() = default;
+
+std::unique_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(
+    [[maybe_unused]] Memory::Memory& memory, [[maybe_unused]] std::size_t num_cores) {
+#ifdef ARCHITECTURE_x86_64
+    return std::make_unique<DynarmicExclusiveMonitor>(memory, num_cores);
+#else
+    // TODO(merry): Passthrough exclusive monitor
+    return nullptr;
+#endif
+}
+
+void Cpu::RunLoop(bool tight_loop) {
+    // Wait for all other CPU cores to complete the previous slice, such that they run in lock-step
+    if (!cpu_barrier.Rendezvous()) {
+        // If rendezvous failed, session has been killed
+        return;
+    }
+
+    Reschedule();
+
+    // If we don't have a currently active thread then don't execute instructions,
+    // instead advance to the next event and try to yield to the next thread
+    if (Kernel::GetCurrentThread() == nullptr) {
+        LOG_TRACE(Core, "Core-{} idling", core_index);
+        core_timing.Idle();
+    } else {
+        if (tight_loop) {
+            arm_interface->Run();
+        } else {
+            arm_interface->Step();
+        }
+        // We are stopping a run, exclusive state must be cleared
+        arm_interface->ClearExclusiveState();
+    }
+    core_timing.Advance();
+
+    Reschedule();
+}
+
+void Cpu::SingleStep() {
+    return RunLoop(false);
+}
+
+void Cpu::PrepareReschedule() {
+    arm_interface->PrepareReschedule();
+}
+
+void Cpu::Reschedule() {
+    // Lock the global kernel mutex when we manipulate the HLE state
+    std::lock_guard lock(HLE::g_hle_lock);
+
+    global_scheduler.SelectThread(core_index);
+    scheduler->TryDoContextSwitch();
+}
+
+void Cpu::Shutdown() {
+    scheduler->Shutdown();
+}
+
+} // namespace Core
@@ -0,0 +1,120 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <atomic>
+#include <condition_variable>
+#include <cstddef>
+#include <memory>
+#include <mutex>
+#include "common/common_types.h"
+
+namespace Kernel {
+class GlobalScheduler;
+class Scheduler;
+} // namespace Kernel
+
+namespace Core {
+class System;
+}
+
+namespace Core::Timing {
+class CoreTiming;
+}
+
+namespace Memory {
+class Memory;
+}
+
+namespace Core {
+
+class ARM_Interface;
+class ExclusiveMonitor;
+
+constexpr unsigned NUM_CPU_CORES{4};
+
+class CpuBarrier {
+public:
+    bool IsAlive() const {
+        return !end;
+    }
+
+    void NotifyEnd();
+
+    bool Rendezvous();
+
+private:
+    unsigned cores_waiting{NUM_CPU_CORES};
+    std::mutex mutex;
+    std::condition_variable condition;
+    std::atomic<bool> end{};
+};
+
+class Cpu {
+public:
+    Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
+        std::size_t core_index);
+    ~Cpu();
+
+    void RunLoop(bool tight_loop = true);
+
+    void SingleStep();
+
+    void PrepareReschedule();
+
+    ARM_Interface& ArmInterface() {
+        return *arm_interface;
+    }
+
+    const ARM_Interface& ArmInterface() const {
+        return *arm_interface;
+    }
+
+    Kernel::Scheduler& Scheduler() {
+        return *scheduler;
+    }
+
+    const Kernel::Scheduler& Scheduler() const {
+        return *scheduler;
+    }
+
+    bool IsMainCore() const {
+        return core_index == 0;
+    }
+
+    std::size_t CoreIndex() const {
+        return core_index;
+    }
+
+    void Shutdown();
+
+    /**
+     * Creates an exclusive monitor to handle exclusive reads/writes.
+     *
+     * @param memory The current memory subsystem that the monitor may wish
+     *               to keep track of.
+     *
+     * @param num_cores The number of cores to assume about the CPU.
+     *
+     * @returns The constructed exclusive monitor instance, or nullptr if the current
+     *          CPU backend is unable to use an exclusive monitor.
+     */
+    static std::unique_ptr<ExclusiveMonitor> MakeExclusiveMonitor(Memory::Memory& memory,
+                                                                  std::size_t num_cores);
+
+private:
+    void Reschedule();
+
+    std::unique_ptr<ARM_Interface> arm_interface;
+    CpuBarrier& cpu_barrier;
+    Kernel::GlobalScheduler& global_scheduler;
+    std::unique_ptr<Kernel::Scheduler> scheduler;
+    Timing::CoreTiming& core_timing;
+
+    std::atomic<bool> reschedule_pending = false;
+    std::size_t core_index;
+};
+
+} // namespace Core
@@ -1,67 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <condition_variable>
-#include <mutex>
-
-#include "common/logging/log.h"
-#include "core/arm/exclusive_monitor.h"
-#include "core/arm/unicorn/arm_unicorn.h"
-#include "core/core.h"
-#include "core/core_manager.h"
-#include "core/core_timing.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/physical_core.h"
-#include "core/hle/kernel/scheduler.h"
-#include "core/hle/kernel/thread.h"
-#include "core/hle/lock.h"
-#include "core/settings.h"
-
-namespace Core {
-
-CoreManager::CoreManager(System& system, std::size_t core_index)
-    : global_scheduler{system.GlobalScheduler()}, physical_core{system.Kernel().PhysicalCore(
-                                                      core_index)},
-      core_timing{system.CoreTiming()}, core_index{core_index} {}
-
-CoreManager::~CoreManager() = default;
-
-void CoreManager::RunLoop(bool tight_loop) {
-    Reschedule();
-
-    // If we don't have a currently active thread then don't execute instructions,
-    // instead advance to the next event and try to yield to the next thread
-    if (Kernel::GetCurrentThread() == nullptr) {
-        LOG_TRACE(Core, "Core-{} idling", core_index);
-        core_timing.Idle();
-    } else {
-        if (tight_loop) {
-            physical_core.Run();
-        } else {
-            physical_core.Step();
-        }
-    }
-    core_timing.Advance();
-
-    Reschedule();
-}
-
-void CoreManager::SingleStep() {
-    return RunLoop(false);
-}
-
-void CoreManager::PrepareReschedule() {
-    physical_core.Stop();
-}
-
-void CoreManager::Reschedule() {
-    // Lock the global kernel mutex when we manipulate the HLE state
-    std::lock_guard lock(HLE::g_hle_lock);
-
-    global_scheduler.SelectThread(core_index);
-
-    physical_core.Scheduler().TryDoContextSwitch();
-}
-
-} // namespace Core
@@ -1,63 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <atomic>
-#include <cstddef>
-#include <memory>
-#include "common/common_types.h"
-
-namespace Kernel {
-class GlobalScheduler;
-class PhysicalCore;
-} // namespace Kernel
-
-namespace Core {
-class System;
-}
-
-namespace Core::Timing {
-class CoreTiming;
-}
-
-namespace Core::Memory {
-class Memory;
-}
-
-namespace Core {
-
-constexpr unsigned NUM_CPU_CORES{4};
-
-class CoreManager {
-public:
-    CoreManager(System& system, std::size_t core_index);
-    ~CoreManager();
-
-    void RunLoop(bool tight_loop = true);
-
-    void SingleStep();
-
-    void PrepareReschedule();
-
-    bool IsMainCore() const {
-        return core_index == 0;
-    }
-
-    std::size_t CoreIndex() const {
-        return core_index;
-    }
-
-private:
-    void Reschedule();
-
-    Kernel::GlobalScheduler& global_scheduler;
-    Kernel::PhysicalCore& physical_core;
-    Timing::CoreTiming& core_timing;
-
-    std::atomic<bool> reschedule_pending = false;
-    std::size_t core_index;
-};
-
-} // namespace Core
@@ -12,7 +12,6 @@
 #include "common/assert.h"
 #include "common/thread.h"
 #include "core/core_timing_util.h"
-#include "core/hardware_properties.h"

 namespace Core::Timing {

@@ -216,7 +215,7 @@ void CoreTiming::Idle() {
 }

 std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const {
-    return std::chrono::microseconds{GetTicks() * 1000000 / Hardware::BASE_CLOCK_RATE};
+    return std::chrono::microseconds{GetTicks() * 1000000 / BASE_CLOCK_RATE};
 }

 s64 CoreTiming::GetDowncount() const {
@@ -11,7 +11,7 @@

 namespace Core::Timing {

-constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / Hardware::BASE_CLOCK_RATE;
+constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;

 s64 msToCycles(std::chrono::milliseconds ms) {
    if (static_cast<u64>(ms.count() / 1000) > MAX_VALUE_TO_MULTIPLY) {
@@ -20,9 +20,9 @@ s64 msToCycles(std::chrono::milliseconds ms) {
    }
    if (static_cast<u64>(ms.count()) > MAX_VALUE_TO_MULTIPLY) {
        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return Hardware::BASE_CLOCK_RATE * (ms.count() / 1000);
+        return BASE_CLOCK_RATE * (ms.count() / 1000);
    }
-    return (Hardware::BASE_CLOCK_RATE * ms.count()) / 1000;
+    return (BASE_CLOCK_RATE * ms.count()) / 1000;
 }

 s64 usToCycles(std::chrono::microseconds us) {
@@ -32,9 +32,9 @@ s64 usToCycles(std::chrono::microseconds us) {
    }
    if (static_cast<u64>(us.count()) > MAX_VALUE_TO_MULTIPLY) {
        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return Hardware::BASE_CLOCK_RATE * (us.count() / 1000000);
+        return BASE_CLOCK_RATE * (us.count() / 1000000);
    }
-    return (Hardware::BASE_CLOCK_RATE * us.count()) / 1000000;
+    return (BASE_CLOCK_RATE * us.count()) / 1000000;
 }

 s64 nsToCycles(std::chrono::nanoseconds ns) {
@@ -44,14 +44,14 @@ s64 nsToCycles(std::chrono::nanoseconds ns) {
    }
    if (static_cast<u64>(ns.count()) > MAX_VALUE_TO_MULTIPLY) {
        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return Hardware::BASE_CLOCK_RATE * (ns.count() / 1000000000);
+        return BASE_CLOCK_RATE * (ns.count() / 1000000000);
    }
-    return (Hardware::BASE_CLOCK_RATE * ns.count()) / 1000000000;
+    return (BASE_CLOCK_RATE * ns.count()) / 1000000000;
 }

 u64 CpuCyclesToClockCycles(u64 ticks) {
-    const u128 temporal = Common::Multiply64Into128(ticks, Hardware::CNTFREQ);
-    return Common::Divide128On32(temporal, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
+    const u128 temporal = Common::Multiply64Into128(ticks, CNTFREQ);
+    return Common::Divide128On32(temporal, static_cast<u32>(BASE_CLOCK_RATE)).first;
 }

 } // namespace Core::Timing
@@ -6,24 +6,28 @@

 #include <chrono>
 #include "common/common_types.h"
-#include "core/hardware_properties.h"

 namespace Core::Timing {

+// The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
+// The exact value used is of course unverified.
+constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
+constexpr u64 CNTFREQ = 19200000;           // Value from fusee.
+
 s64 msToCycles(std::chrono::milliseconds ms);
 s64 usToCycles(std::chrono::microseconds us);
 s64 nsToCycles(std::chrono::nanoseconds ns);

 inline std::chrono::milliseconds CyclesToMs(s64 cycles) {
-    return std::chrono::milliseconds(cycles * 1000 / Hardware::BASE_CLOCK_RATE);
+    return std::chrono::milliseconds(cycles * 1000 / BASE_CLOCK_RATE);
 }

 inline std::chrono::nanoseconds CyclesToNs(s64 cycles) {
-    return std::chrono::nanoseconds(cycles * 1000000000 / Hardware::BASE_CLOCK_RATE);
+    return std::chrono::nanoseconds(cycles * 1000000000 / BASE_CLOCK_RATE);
 }

 inline std::chrono::microseconds CyclesToUs(s64 cycles) {
-    return std::chrono::microseconds(cycles * 1000000 / Hardware::BASE_CLOCK_RATE);
+    return std::chrono::microseconds(cycles * 1000000 / BASE_CLOCK_RATE);
 }

 u64 CpuCyclesToClockCycles(u64 ticks);
@@ -0,0 +1,152 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "core/arm/exclusive_monitor.h"
+#include "core/core.h"
+#include "core/core_cpu.h"
+#include "core/core_timing.h"
+#include "core/cpu_core_manager.h"
+#include "core/gdbstub/gdbstub.h"
+#include "core/settings.h"
+
+namespace Core {
+namespace {
+void RunCpuCore(const System& system, Cpu& cpu_state) {
+    while (system.IsPoweredOn()) {
+        cpu_state.RunLoop(true);
+    }
+}
+} // Anonymous namespace
+
+CpuCoreManager::CpuCoreManager(System& system) : system{system} {}
+CpuCoreManager::~CpuCoreManager() = default;
+
+void CpuCoreManager::Initialize() {
+    barrier = std::make_unique<CpuBarrier>();
+    exclusive_monitor = Cpu::MakeExclusiveMonitor(system.Memory(), cores.size());
+
+    for (std::size_t index = 0; index < cores.size(); ++index) {
+        cores[index] = std::make_unique<Cpu>(system, *exclusive_monitor, *barrier, index);
+    }
+}
+
+void CpuCoreManager::StartThreads() {
+    // Create threads for CPU cores 1-3, and build thread_to_cpu map
+    // CPU core 0 is run on the main thread
+    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
+    if (!Settings::values.use_multi_core) {
+        return;
+    }
+
+    for (std::size_t index = 0; index < core_threads.size(); ++index) {
+        core_threads[index] = std::make_unique<std::thread>(RunCpuCore, std::cref(system),
+                                                            std::ref(*cores[index + 1]));
+        thread_to_cpu[core_threads[index]->get_id()] = cores[index + 1].get();
+    }
+}
+
+void CpuCoreManager::Shutdown() {
+    barrier->NotifyEnd();
+    if (Settings::values.use_multi_core) {
+        for (auto& thread : core_threads) {
+            thread->join();
+            thread.reset();
+        }
+    }
+
+    thread_to_cpu.clear();
+    for (auto& cpu_core : cores) {
+        cpu_core->Shutdown();
+        cpu_core.reset();
+    }
+
+    exclusive_monitor.reset();
+    barrier.reset();
+}
+
+Cpu& CpuCoreManager::GetCore(std::size_t index) {
+    return *cores.at(index);
+}
+
+const Cpu& CpuCoreManager::GetCore(std::size_t index) const {
+    return *cores.at(index);
+}
+
+ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() {
+    return *exclusive_monitor;
+}
+
+const ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() const {
+    return *exclusive_monitor;
+}
+
+Cpu& CpuCoreManager::GetCurrentCore() {
+    if (Settings::values.use_multi_core) {
+        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+        ASSERT(search != thread_to_cpu.end());
+        ASSERT(search->second);
+        return *search->second;
+    }
+
+    // Otherwise, use single-threaded mode active_core variable
+    return *cores[active_core];
+}
+
+const Cpu& CpuCoreManager::GetCurrentCore() const {
+    if (Settings::values.use_multi_core) {
+        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+        ASSERT(search != thread_to_cpu.end());
+        ASSERT(search->second);
+        return *search->second;
+    }
+
+    // Otherwise, use single-threaded mode active_core variable
+    return *cores[active_core];
+}
+
+void CpuCoreManager::RunLoop(bool tight_loop) {
+    // Update thread_to_cpu in case Core 0 is run from a different host thread
+    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
+
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::HandlePacket();
+
+        // If the loop is halted and we want to step, use a tiny (1) number of instructions to
+        // execute. Otherwise, get out of the loop function.
+        if (GDBStub::GetCpuHaltFlag()) {
+            if (GDBStub::GetCpuStepFlag()) {
+                tight_loop = false;
+            } else {
+                return;
+            }
+        }
+    }
+
+    auto& core_timing = system.CoreTiming();
+    core_timing.ResetRun();
+    bool keep_running{};
+    do {
+        keep_running = false;
+        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
+            core_timing.SwitchContext(active_core);
+            if (core_timing.CanCurrentContextRun()) {
+                cores[active_core]->RunLoop(tight_loop);
+            }
+            keep_running |= core_timing.CanCurrentContextRun();
+        }
+    } while (keep_running);
+
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::SetCpuStepFlag(false);
+    }
+}
+
+void CpuCoreManager::InvalidateAllInstructionCaches() {
+    for (auto& cpu : cores) {
+        cpu->ArmInterface().ClearInstructionCache();
+    }
+}
+
+} // namespace Core
@@ -0,0 +1,62 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <map>
+#include <memory>
+#include <thread>
+
+namespace Core {
+
+class Cpu;
+class CpuBarrier;
+class ExclusiveMonitor;
+class System;
+
+class CpuCoreManager {
+public:
+    explicit CpuCoreManager(System& system);
+    CpuCoreManager(const CpuCoreManager&) = delete;
+    CpuCoreManager(CpuCoreManager&&) = delete;
+
+    ~CpuCoreManager();
+
+    CpuCoreManager& operator=(const CpuCoreManager&) = delete;
+    CpuCoreManager& operator=(CpuCoreManager&&) = delete;
+
+    void Initialize();
+    void StartThreads();
+    void Shutdown();
+
+    Cpu& GetCore(std::size_t index);
+    const Cpu& GetCore(std::size_t index) const;
+
+    Cpu& GetCurrentCore();
+    const Cpu& GetCurrentCore() const;
+
+    ExclusiveMonitor& GetExclusiveMonitor();
+    const ExclusiveMonitor& GetExclusiveMonitor() const;
+
+    void RunLoop(bool tight_loop);
+
+    void InvalidateAllInstructionCaches();
+
+private:
+    static constexpr std::size_t NUM_CPU_CORES = 4;
+
+    std::unique_ptr<ExclusiveMonitor> exclusive_monitor;
+    std::unique_ptr<CpuBarrier> barrier;
+    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cores;
+    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> core_threads;
+    std::size_t active_core{}; ///< Active core, only used in single thread mode
+
+    /// Map of guest threads to CPU cores
+    std::map<std::thread::id, Cpu*> thread_to_cpu;
+
+    System& system;
+};
+
+} // namespace Core
@@ -1,81 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/arm/exclusive_monitor.h"
-#include "core/core.h"
-#include "core/core_manager.h"
-#include "core/core_timing.h"
-#include "core/cpu_manager.h"
-#include "core/gdbstub/gdbstub.h"
-
-namespace Core {
-
-CpuManager::CpuManager(System& system) : system{system} {}
-CpuManager::~CpuManager() = default;
-
-void CpuManager::Initialize() {
-    for (std::size_t index = 0; index < core_managers.size(); ++index) {
-        core_managers[index] = std::make_unique<CoreManager>(system, index);
-    }
-}
-
-void CpuManager::Shutdown() {
-    for (auto& cpu_core : core_managers) {
-        cpu_core.reset();
-    }
-}
-
-CoreManager& CpuManager::GetCoreManager(std::size_t index) {
-    return *core_managers.at(index);
-}
-
-const CoreManager& CpuManager::GetCoreManager(std::size_t index) const {
-    return *core_managers.at(index);
-}
-
-CoreManager& CpuManager::GetCurrentCoreManager() {
-    // Otherwise, use single-threaded mode active_core variable
-    return *core_managers[active_core];
-}
-
-const CoreManager& CpuManager::GetCurrentCoreManager() const {
-    // Otherwise, use single-threaded mode active_core variable
-    return *core_managers[active_core];
-}
-
-void CpuManager::RunLoop(bool tight_loop) {
-    if (GDBStub::IsServerEnabled()) {
-        GDBStub::HandlePacket();
-
-        // If the loop is halted and we want to step, use a tiny (1) number of instructions to
-        // execute. Otherwise, get out of the loop function.
-        if (GDBStub::GetCpuHaltFlag()) {
-            if (GDBStub::GetCpuStepFlag()) {
-                tight_loop = false;
-            } else {
-                return;
-            }
-        }
-    }
-
-    auto& core_timing = system.CoreTiming();
-    core_timing.ResetRun();
-    bool keep_running{};
-    do {
-        keep_running = false;
-        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
-            core_timing.SwitchContext(active_core);
-            if (core_timing.CanCurrentContextRun()) {
-                core_managers[active_core]->RunLoop(tight_loop);
-            }
-            keep_running |= core_timing.CanCurrentContextRun();
-        }
-    } while (keep_running);
-
-    if (GDBStub::IsServerEnabled()) {
-        GDBStub::SetCpuStepFlag(false);
-    }
-}
-
-} // namespace Core
@@ -1,49 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include "core/hardware_properties.h"
-
-namespace Core {
-
-class CoreManager;
-class System;
-
-class CpuManager {
-public:
-    explicit CpuManager(System& system);
-    CpuManager(const CpuManager&) = delete;
-    CpuManager(CpuManager&&) = delete;
-
-    ~CpuManager();
-
-    CpuManager& operator=(const CpuManager&) = delete;
-    CpuManager& operator=(CpuManager&&) = delete;
-
-    void Initialize();
-    void Shutdown();
-
-    CoreManager& GetCoreManager(std::size_t index);
-    const CoreManager& GetCoreManager(std::size_t index) const;
-
-    CoreManager& GetCurrentCoreManager();
-    const CoreManager& GetCurrentCoreManager() const;
-
-    std::size_t GetActiveCoreIndex() const {
-        return active_core;
-    }
-
-    void RunLoop(bool tight_loop);
-
-private:
-    std::array<std::unique_ptr<CoreManager>, Hardware::NUM_CPU_CORES> core_managers;
-    std::size_t active_core{}; ///< Active core, only used in single thread mode
-
-    System& system;
-};
-
-} // namespace Core
@@ -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}},
@@ -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);
@@ -1,15 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/core.h"
-#include "core/device_memory.h"
-#include "core/memory.h"
-
-namespace Core {
-
-DeviceMemory::DeviceMemory(System& system) : buffer{DramMemoryMap::Size}, system{system} {}
-
-DeviceMemory::~DeviceMemory() = default;
-
-} // namespace Core
@@ -1,51 +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/assert.h"
-#include "common/common_funcs.h"
-#include "common/virtual_buffer.h"
-
-namespace Core {
-
-class System;
-
-namespace DramMemoryMap {
-enum : u64 {
-    Base = 0x80000000ULL,
-    Size = 0x100000000ULL,
-    End = Base + Size,
-    KernelReserveBase = Base + 0x60000,
-    SlabHeapBase = KernelReserveBase + 0x85000,
-    SlapHeapSize = 0xa21000,
-    SlabHeapEnd = SlabHeapBase + SlapHeapSize,
-};
-}; // namespace DramMemoryMap
-
-class DeviceMemory : NonCopyable {
-public:
-    explicit DeviceMemory(Core::System& system);
-    ~DeviceMemory();
-
-    template <typename T>
-    PAddr GetPhysicalAddr(const T* ptr) const {
-        return (reinterpret_cast<uintptr_t>(ptr) - reinterpret_cast<uintptr_t>(buffer.data())) +
-               DramMemoryMap::Base;
-    }
-
-    u8* GetPointer(PAddr addr) {
-        return buffer.data() + (addr - DramMemoryMap::Base);
-    }
-
-    const u8* GetPointer(PAddr addr) const {
-        return buffer.data() + (addr - DramMemoryMap::Base);
-    }
-
-private:
-    Common::VirtualBuffer<u8> buffer;
-    Core::System& system;
-};
-
-} // namespace Core
@@ -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));
@@ -113,7 +113,6 @@ public:
    u32 GetSupportedLanguages() const;
    std::vector<u8> GetRawBytes() const;
    bool GetUserAccountSwitchLock() const;
-    u64 GetDeviceSaveDataSize() const;

 private:
    RawNACP raw{};
@@ -249,7 +249,7 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
 }

 namespace {
-std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
+std::optional<std::vector<Memory::CheatEntry>> ReadCheatFileFromFolder(
    const Core::System& system, u64 title_id, const std::array<u8, 0x20>& build_id_,
    const VirtualDir& base_path, bool upper) {
    const auto build_id_raw = Common::HexToString(build_id_, upper);
@@ -269,14 +269,14 @@ std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
        return std::nullopt;
    }

-    Core::Memory::TextCheatParser parser;
+    Memory::TextCheatParser parser;
    return parser.Parse(
        system, std::string_view(reinterpret_cast<const char* const>(data.data()), data.size()));
 }

 } // Anonymous namespace

-std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
+std::vector<Memory::CheatEntry> PatchManager::CreateCheatList(
    const Core::System& system, const std::array<u8, 32>& build_id_) const {
    const auto load_dir = system.GetFileSystemController().GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
@@ -289,7 +289,7 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
    std::sort(patch_dirs.begin(), patch_dirs.end(),
              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });

-    std::vector<Core::Memory::CheatEntry> out;
+    std::vector<Memory::CheatEntry> out;
    for (const auto& subdir : patch_dirs) {
        if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend()) {
            continue;
@@ -348,12 +348,6 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
        if (ext_dir != nullptr)
            layers_ext.push_back(std::move(ext_dir));
    }
-
-    // When there are no layers to apply, return early as there is no need to rebuild the RomFS
-    if (layers.empty() && layers_ext.empty()) {
-        return;
-    }
-
    layers.push_back(std::move(extracted));

    auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
@@ -440,8 +434,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
    // Game Updates
    const auto update_tid = GetUpdateTitleID(title_id);
    PatchManager update{update_tid};
-    const auto metadata = update.GetControlMetadata();
-    const auto& nacp = metadata.first;
+    auto [nacp, discard_icon_file] = update.GetControlMetadata();

    const auto update_disabled =
        std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
@@ -51,8 +51,8 @@ public:
    bool HasNSOPatch(const std::array<u8, 0x20>& build_id) const;

    // Creates a CheatList object with all
-    std::vector<Core::Memory::CheatEntry> CreateCheatList(
-        const Core::System& system, const std::array<u8, 0x20>& build_id) const;
+    std::vector<Memory::CheatEntry> CreateCheatList(const Core::System& system,
+                                                    const std::array<u8, 0x20>& build_id) const;

    // Currently tracked RomFS patches:
    // - Game Updates
@@ -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,
@@ -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);
@@ -591,18 +591,14 @@ InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_ex
 InstallResult RegisteredCache::InstallEntry(const NCA& nca, TitleType type,
                                            bool overwrite_if_exists, const VfsCopyFunction& copy) {
    CNMTHeader header{
-        nca.GetTitleId(), // Title ID
-        0,                // Ignore/Default title version
-        type,             // Type
-        {},               // Padding
-        0x10,             // Default table offset
-        1,                // 1 Content Entry
-        0,                // No Meta Entries
-        {},               // Padding
-        {},               // Reserved 1
-        0,                // Is committed
-        0,                // Required download system version
-        {},               // Reserved 2
+        nca.GetTitleId(), ///< Title ID
+        0,                ///< Ignore/Default title version
+        type,             ///< Type
+        {},               ///< Padding
+        0x10,             ///< Default table offset
+        1,                ///< 1 Content Entry
+        0,                ///< No Meta Entries
+        {},               ///< Padding
    };
    OptionalHeader opt_header{0, 0};
    ContentRecord c_rec{{}, {}, {}, GetCRTypeFromNCAType(nca.GetType()), {}};
@@ -852,8 +848,7 @@ VirtualFile ManualContentProvider::GetEntryUnparsed(u64 title_id, ContentRecordT
 VirtualFile ManualContentProvider::GetEntryRaw(u64 title_id, ContentRecordType type) const {
    const auto iter =
        std::find_if(entries.begin(), entries.end(), [title_id, type](const auto& entry) {
-            const auto content_type = std::get<1>(entry.first);
-            const auto e_title_id = std::get<2>(entry.first);
+            const auto [title_type, content_type, e_title_id] = entry.first;
            return content_type == type && e_title_id == title_id;
        });
    if (iter == entries.end())
@@ -5,7 +5,6 @@
 #include <memory>

 #include "common/common_types.h"
-#include "common/string_util.h"
 #include "common/swap.h"
 #include "core/file_sys/fsmitm_romfsbuild.h"
 #include "core/file_sys/romfs.h"
@@ -127,7 +126,7 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
        return out->GetSubdirectories().front();

    while (out->GetSubdirectories().size() == 1 && out->GetFiles().empty()) {
-        if (Common::ToLower(out->GetSubdirectories().front()->GetName()) == "data" &&
+        if (out->GetSubdirectories().front()->GetName() == "data" &&
            type == RomFSExtractionType::Truncated)
            break;
        out = out->GetSubdirectories().front();
@@ -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);
@@ -42,11 +42,11 @@ VirtualDir ExtractZIP(VirtualFile file) {
            continue;

        if (name.back() != '/') {
-            std::unique_ptr<zip_file_t, decltype(&zip_fclose)> file2{
+            std::unique_ptr<zip_file_t, decltype(&zip_fclose)> file{
                zip_fopen_index(zip.get(), i, 0), zip_fclose};

            std::vector<u8> buf(stat.size);
-            if (zip_fread(file2.get(), buf.data(), buf.size()) != s64(buf.size()))
+            if (zip_fread(file.get(), buf.data(), buf.size()) != buf.size())
                return nullptr;

            const auto parts = FileUtil::SplitPathComponents(stat.name);
@@ -12,49 +12,23 @@

 namespace Core::Frontend {

-/// Information for the Graphics Backends signifying what type of screen pointer is in
-/// WindowInformation
-enum class WindowSystemType {
-    Headless,
-    Windows,
-    X11,
-    Wayland,
-};
-
 /**
- * Represents a drawing context that supports graphics operations.
+ * Represents a graphics context that can be used for background computation or drawing. If the
+ * graphics backend doesn't require the context, then the implementation of these methods can be
+ * stubs
 */
 class GraphicsContext {
 public:
    virtual ~GraphicsContext();

-    /// Inform the driver to swap the front/back buffers and present the current image
-    virtual void SwapBuffers() {}
-
    /// Makes the graphics context current for the caller thread
-    virtual void MakeCurrent() {}
+    virtual void MakeCurrent() = 0;

    /// Releases (dunno if this is the "right" word) the context from the caller thread
-    virtual void DoneCurrent() {}
+    virtual void DoneCurrent() = 0;

-    class Scoped {
-    public:
-        explicit Scoped(GraphicsContext& context_) : context(context_) {
-            context.MakeCurrent();
-        }
-        ~Scoped() {
-            context.DoneCurrent();
-        }
-
-    private:
-        GraphicsContext& context;
-    };
-
-    /// Calls MakeCurrent on the context and calls DoneCurrent when the scope for the returned value
-    /// ends
-    Scoped Acquire() {
-        return Scoped{*this};
-    }
+    /// Swap buffers to display the next frame
+    virtual void SwapBuffers() = 0;
 };

 /**
@@ -75,7 +49,7 @@ public:
 * - DO NOT TREAT THIS CLASS AS A GUI TOOLKIT ABSTRACTION LAYER. That's not what it is. Please
 *   re-read the upper points again and think about it if you don't see this.
 */
-class EmuWindow {
+class EmuWindow : public GraphicsContext {
 public:
    /// Data structure to store emuwindow configuration
    struct WindowConfig {
@@ -85,33 +59,21 @@ public:
        std::pair<unsigned, unsigned> min_client_area_size;
    };

-    /// Data describing host window system information
-    struct WindowSystemInfo {
-        // Window system type. Determines which GL context or Vulkan WSI is used.
-        WindowSystemType type = WindowSystemType::Headless;
-
-        // Connection to a display server. This is used on X11 and Wayland platforms.
-        void* display_connection = nullptr;
-
-        // Render surface. This is a pointer to the native window handle, which depends
-        // on the platform. e.g. HWND for Windows, Window for X11. If the surface is
-        // set to nullptr, the video backend will run in headless mode.
-        void* render_surface = nullptr;
-
-        // Scale of the render surface. For hidpi systems, this will be >1.
-        float render_surface_scale = 1.0f;
-    };
-
    /// Polls window events
    virtual void PollEvents() = 0;

    /**
-     * Returns a GraphicsContext that the frontend provides to be used for rendering.
+     * Returns a GraphicsContext that the frontend provides that is shared with the emu window. This
+     * context can be used from other threads for background graphics computation. If the frontend
+     * is using a graphics backend that doesn't need anything specific to run on a different thread,
+     * then it can use a stubbed implemenation for GraphicsContext.
+     *
+     * If the return value is null, then the core should assume that the frontend cannot provide a
+     * Shared Context
     */
-    virtual std::unique_ptr<GraphicsContext> CreateSharedContext() const = 0;
-
-    /// Returns if window is shown (not minimized)
-    virtual bool IsShown() const = 0;
+    virtual std::unique_ptr<GraphicsContext> CreateSharedContext() const {
+        return nullptr;
+    }

    /**
     * Signal that a touch pressed event has occurred (e.g. mouse click pressed)
@@ -149,13 +111,6 @@ public:
        config = val;
    }

-    /**
-     * Returns system information about the drawing area.
-     */
-    const WindowSystemInfo& GetWindowInfo() const {
-        return window_info;
-    }
-
    /**
     * Gets the framebuffer layout (width, height, and screen regions)
     * @note This method is thread-safe
@@ -171,7 +126,7 @@ public:
    void UpdateCurrentFramebufferLayout(unsigned width, unsigned height);

 protected:
-    explicit EmuWindow();
+    EmuWindow();
    virtual ~EmuWindow();

    /**
@@ -208,8 +163,6 @@ protected:
        client_area_height = size.second;
    }

-    WindowSystemInfo window_info;
-
 private:
    /**
     * Handler called when the minimal client area was requested to be changed via SetConfig.
@@ -25,11 +25,11 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
    ASSERT(height > 0);
    // The drawing code needs at least somewhat valid values for both screens
    // so just calculate them both even if the other isn't showing.
-    FramebufferLayout res{width, height, false, {}};
+    FramebufferLayout res{width, height};

-    const float window_aspect_ratio = static_cast<float>(height) / width;
-    const float emulation_aspect_ratio = EmulationAspectRatio(
-        static_cast<AspectRatio>(Settings::values.aspect_ratio), window_aspect_ratio);
+    const float emulation_aspect_ratio{static_cast<float>(ScreenUndocked::Height) /
+                                       ScreenUndocked::Width};
+    const auto window_aspect_ratio = static_cast<float>(height) / width;

    const Common::Rectangle<u32> screen_window_area{0, 0, width, height};
    Common::Rectangle<u32> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
@@ -48,8 +48,8 @@ FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
    u32 width, height;

    if (Settings::values.use_docked_mode) {
-        width = ScreenDocked::Width * res_scale;
-        height = ScreenDocked::Height * res_scale;
+        width = ScreenDocked::WidthDocked * res_scale;
+        height = ScreenDocked::HeightDocked * res_scale;
    } else {
        width = ScreenUndocked::Width * res_scale;
        height = ScreenUndocked::Height * res_scale;
@@ -58,19 +58,4 @@ FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
    return DefaultFrameLayout(width, height);
 }

-float EmulationAspectRatio(AspectRatio aspect, float window_aspect_ratio) {
-    switch (aspect) {
-    case AspectRatio::Default:
-        return static_cast<float>(ScreenUndocked::Height) / ScreenUndocked::Width;
-    case AspectRatio::R4_3:
-        return 3.0f / 4.0f;
-    case AspectRatio::R21_9:
-        return 9.0f / 21.0f;
-    case AspectRatio::StretchToWindow:
-        return window_aspect_ratio;
-    default:
-        return static_cast<float>(ScreenUndocked::Height) / ScreenUndocked::Width;
-    }
-}
-
 } // namespace Layout
Author	SHA1	Message	Date
yuzubot	55ce8dbe0c	"Merge Tagged PR 1012"	2020-01-30 13:01:11 +00:00
yuzubot	fa9a1131e8	"Merge Tagged PR 1340"	2020-01-30 13:01:10 +00:00
yuzubot	d5b0bce7e5	"Merge Tagged PR 1703"	2020-01-30 13:01:09 +00:00
yuzubot	e847433f0f	"Merge Tagged PR 2710"	2020-01-30 13:01:08 +00:00