input_common: Treat warnings as errors

Migrates over warnings as errors for input common to match how the common library treats warnings as errors.
Merge pull request #4944 from lioncash/system-rem
2020-11-22 04:50:03 -05:00 · 2020-11-21 22:12:34 -08:00 · 2020-11-22 09:55:23 +08:00 · 2020-11-21 01:21:08 -08:00 · 2020-11-21 03:47:17 -03:00 · 2020-11-20 22:15:44 -08:00
346 changed files with 12233 additions and 6235 deletions
@@ -4,6 +4,8 @@ parameters:
  version: ''

 steps:
+- script: choco install vulkan-sdk && refreshenv
+  displayName: 'Install vulkan-sdk'
 - script: python -m pip install --upgrade pip conan
  displayName: 'Install conan'
 - script: mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
@@ -1,15 +1,12 @@
 [submodule "inih"]
    path = externals/inih/inih
-    url = https://github.com/svn2github/inih
+    url = https://github.com/benhoyt/inih.git
 [submodule "cubeb"]
    path = externals/cubeb
    url = https://github.com/kinetiknz/cubeb.git
 [submodule "dynarmic"]
    path = externals/dynarmic
    url = https://github.com/MerryMage/dynarmic.git
-[submodule "unicorn"]
-    path = externals/unicorn
-    url = https://github.com/yuzu-emu/unicorn
 [submodule "soundtouch"]
    path = externals/soundtouch
    url = https://github.com/citra-emu/ext-soundtouch.git
@@ -4,16 +4,8 @@ cd /yuzu
 # override Travis CI unreasonable ccache size
 echo 'max_size = 3.0G' > "$HOME/.ccache/ccache.conf"

-# Dirty hack to trick unicorn makefile into believing we are in a MINGW system
-mv /bin/uname /bin/uname1 && echo -e '#!/bin/sh\necho MINGW64' >> /bin/uname
-chmod +x /bin/uname
-
-# Dirty hack to trick unicorn makefile into believing we have cmd
-echo '' >> /bin/cmd
-chmod +x /bin/cmd
-
 mkdir build && cd build
-cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
 ninja

 # Clean up the dirty hacks
@@ -3,7 +3,7 @@
 cd /yuzu

 mkdir build && cd build
-cmake .. -G Ninja -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
+cmake .. -G Ninja -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
 ninja

 ccache -s
@@ -4,13 +4,12 @@ set -o pipefail

 export MACOSX_DEPLOYMENT_TARGET=10.14
 export Qt5_DIR=$(brew --prefix)/opt/qt5
-export UNICORNDIR=$(pwd)/externals/unicorn
 export PATH="/usr/local/opt/ccache/libexec:$PATH"

 # TODO: Build using ninja instead of make
 mkdir build && cd build
 cmake --version
-cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
+cmake .. -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
 make -j4

 ccache -s
@@ -18,8 +18,6 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "EN

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

-option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
-
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)

 option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implementation of BCAT" ON)
@@ -161,7 +159,7 @@ macro(yuzu_find_packages)
    #    Cmake Pkg Prefix  Version     Conan Pkg
        "Boost             1.73        boost/1.73.0"
        "Catch2            2.13        catch2/2.13.0"
-        "fmt               7.0         fmt/7.0.3"
+        "fmt               7.1         fmt/7.1.2"
    # can't use until https://github.com/bincrafters/community/issues/1173
        #"libzip            1.5         libzip/1.5.2@bincrafters/stable"
        "lz4               1.8         lz4/1.9.2"
@@ -263,6 +261,7 @@ if (CONAN_REQUIRED_LIBS)
        libzip:with_openssl=False
        libzip:enable_windows_crypto=False
    )
+
    conan_check(VERSION 1.24.0 REQUIRED)
    # Add the bincrafters remote
    conan_add_remote(NAME bincrafters
@@ -354,85 +353,23 @@ if (NOT LIBUSB_FOUND)
    set(LIBUSB_LIBRARIES usb)
 endif()

+# Use system installed ffmpeg.
+if (NOT MSVC)
+    find_package(FFmpeg REQUIRED)
+else()
+    set(FFMPEG_EXT_NAME "ffmpeg-4.2.1")
+    set(FFMPEG_PATH "${CMAKE_BINARY_DIR}/externals/${FFMPEG_EXT_NAME}")
+    download_bundled_external("ffmpeg/" ${FFMPEG_EXT_NAME} "")
+    set(FFMPEG_FOUND YES)
+    set(FFMPEG_INCLUDE_DIR "${FFMPEG_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
+    set(FFMPEG_LIBRARY_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg library" FORCE)
+    set(FFMPEG_DLL_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
+endif()
+
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)

-# If unicorn isn't found, msvc -> download bundled unicorn; everyone else -> build external
-if (YUZU_USE_BUNDLED_UNICORN)
-    if (MSVC)
-        message(STATUS "unicorn not found, falling back to bundled")
-        # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
-            set(UNICORN_VER "unicorn-yuzu")
-        else()
-            message(FATAL_ERROR "No bundled Unicorn binaries for your toolchain. Disable YUZU_USE_BUNDLED_UNICORN and provide your own.")
-        endif()
-
-        if (DEFINED UNICORN_VER)
-            download_bundled_external("unicorn/" ${UNICORN_VER} UNICORN_PREFIX)
-        endif()
-
-        if (DEFINED UNICORN_VER)
-            download_bundled_external("unicorn/" ${UNICORN_VER} UNICORN_PREFIX)
-        endif()
-
-        set(UNICORN_FOUND YES)
-        set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
-        set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/lib/x64/unicorn_dynload.lib" CACHE PATH "Path to Unicorn library" FORCE)
-        set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/lib/x64/" CACHE PATH "Path to unicorn.dll" FORCE)
-    else()
-        message(STATUS "unicorn not found, falling back to externals")
-        if (MINGW)
-            set(UNICORN_LIB_NAME "unicorn.a")
-        else()
-            set(UNICORN_LIB_NAME "libunicorn.a")
-        endif()
-
-        set(UNICORN_FOUND YES)
-        set(UNICORN_PREFIX ${PROJECT_SOURCE_DIR}/externals/unicorn)
-        set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/${UNICORN_LIB_NAME}" CACHE PATH "Path to Unicorn library" FORCE)
-        set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
-        set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/" CACHE PATH "Path to unicorn dynamic library" FORCE)
-
-        find_package(PythonInterp 2.7 REQUIRED)
-
-        if (MINGW)
-            # Intentionally call the unicorn makefile directly instead of using make.sh so that we can override the
-            # UNAME_S makefile variable to MINGW. This way we don't have to hack at the uname binary to build
-            # Additionally, overriding DO_WINDOWS_EXPORT prevents unicorn from patching the static unicorn.a by using msvc and cmd,
-            # which are both things we don't have in a mingw cross compiling environment.
-            add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
-                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" CC=x86_64-w64-mingw32-gcc AR=x86_64-w64-mingw32-gcc-ar RANLIB=x86_64-w64-mingw32-gcc-ranlib make UNAME_S=MINGW DO_WINDOWS_EXPORT=0
-                WORKING_DIRECTORY ${UNICORN_PREFIX}
-            )
-        else()
-            add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
-                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh macos-universal-no
-                WORKING_DIRECTORY ${UNICORN_PREFIX}
-            )
-        endif()
-
-        # ALL makes this custom target build every time
-        # but it won't actually build if LIBUNICORN_LIBRARY is up to date
-        add_custom_target(unicorn-build ALL
-            DEPENDS ${LIBUNICORN_LIBRARY}
-        )
-        unset(UNICORN_LIB_NAME)
-    endif()
-else()
-    find_package(Unicorn REQUIRED)
-endif()
-
-if (UNICORN_FOUND)
-    add_library(unicorn INTERFACE)
-    add_dependencies(unicorn unicorn-build)
-    target_link_libraries(unicorn INTERFACE "${LIBUNICORN_LIBRARY}")
-    target_include_directories(unicorn INTERFACE "${LIBUNICORN_INCLUDE_DIR}")
-else()
-    message(FATAL_ERROR "Could not find or build unicorn which is required.")
-endif()
-
 # Platform-specific library requirements
 # ======================================

@@ -0,0 +1,10 @@
+function(copy_yuzu_FFmpeg_deps target_dir)
+    include(WindowsCopyFiles)
+    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
+    windows_copy_files(${target_dir} ${FFMPEG_DLL_DIR} ${DLL_DEST}
+        avcodec-58.dll
+        avutil-56.dll
+        swresample-3.dll
+        swscale-5.dll
+    )
+endfunction(copy_yuzu_FFmpeg_deps)
@@ -1,9 +0,0 @@
-function(copy_yuzu_unicorn_deps target_dir)
-    include(WindowsCopyFiles)
-    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
-    windows_copy_files(${target_dir} ${UNICORN_DLL_DIR} ${DLL_DEST}
-        libgcc_s_seh-1.dll
-        libwinpthread-1.dll
-        unicorn.dll
-    )
-endfunction(copy_yuzu_unicorn_deps)
@@ -1,3 +1,7 @@
+QAbstractSpinBox {
+    min-height: 19px;
+}
+
 QPushButton#TogglableStatusBarButton {
    color: #959595;
    border: 1px solid transparent;
@@ -35,10 +39,10 @@ QPushButton#RendererStatusBarButton:!checked {
 }

 QPushButton#buttonRefreshDevices {
-    min-width: 20px;
-    min-height: 20px;
-    max-width: 20px;
-    max-height: 20px;
+    min-width: 21px;
+    min-height: 21px;
+    max-width: 21px;
+    max-height: 21px;
 }

 QWidget#bottomPerGameInput,
@@ -71,7 +75,7 @@ QWidget#middleControllerApplet {

 QWidget#topPerGameInput QComboBox,
 QWidget#middleControllerApplet QComboBox {
-    width: 123px;
+    width: 120px;
 }

 QWidget#connectedControllers {
@@ -99,12 +99,19 @@ QGroupBox::indicator:unchecked:disabled {
 }

 QRadioButton {
-    spacing: 5px;
-    outline: none;
    color: #eff0f1;
+    spacing: 3px;
+    padding: 0px;
+    border: none;
+    outline: none;
    margin-bottom: 2px;
 }

+QGroupBox QRadioButton {
+    padding-left: 0px;
+    padding-right: 7px;
+}
+
 QRadioButton:disabled {
    color: #76797C;
 }
@@ -522,13 +529,12 @@ QToolButton#qt_toolbar_ext_button {

 QPushButton {
    color: #eff0f1;
-    border-width: 1px;
-    border-color: #54575B;
-    border-style: solid;
-    padding: 6px 4px;
+    border: 1px solid #54575B;
    border-radius: 2px;
+    padding: 5px 0px 5px 0px;
    outline: none;
    min-width: 100px;
+    min-height: 13px;
    background-color: #232629;
 }

@@ -553,8 +559,9 @@ QComboBox {
    selection-background-color: #3daee9;
    border: 1px solid #54575B;
    border-radius: 2px;
-    padding: 4px 6px;
-    min-width: 75px;
+    padding: 0px 4px 0px 4px;
+    min-width: 60px;
+    min-height: 23px;
    background-color: #232629;
 }

@@ -608,26 +615,26 @@ QComboBox::down-arrow:focus {
 }

 QAbstractSpinBox {
-    padding: 4px 6px;
    border: 1px solid #54575B;
    background-color: #232629;
    color: #eff0f1;
    border-radius: 2px;
-    min-width: 75px;
+    min-width: 52px;
+    min-height: 23px;
 }

 QAbstractSpinBox:up-button {
    background-color: transparent;
    subcontrol-origin: border;
    subcontrol-position: center right;
-    left: -6px;
+    left: -2px;
 }

 QAbstractSpinBox:down-button {
    background-color: transparent;
    subcontrol-origin: border;
    subcontrol-position: center left;
-    right: -6px;
+    right: -2px;
 }

 QAbstractSpinBox::up-arrow,
@@ -1277,41 +1284,33 @@ QPushButton#RendererStatusBarButton:!checked {
 }

 QPushButton#buttonRefreshDevices {
-    min-width: 24px;
-    min-height: 24px;
-    max-width: 24px;
-    max-height: 24px;
+    min-width: 23px;
+    min-height: 23px;
+    max-width: 23px;
+    max-height: 23px;
    padding: 0px 0px;
 }

 QSpinBox#spinboxLStickRange,
-QSpinBox#spinboxRStickRange {
-    padding: 4px 0px 5px 0px;
-    min-width: 63px;
-}
-
-QSpinBox#vibrationSpin {
-    padding: 4px 0px 5px 0px;
-    min-width: 63px;
-}
-
-QSpinBox#spinboxLStickRange:up-button,
-QSpinBox#spinboxRStickRange:up-button,
-QSpinBox#vibrationSpin:up-button {
-    left: -2px;
-}
-
-QSpinBox#spinboxLStickRange:down-button,
-QSpinBox#spinboxRStickRange:down-button,
-QSpinBox#vibrationSpin:down-button {
-    right: -1px;
+QSpinBox#spinboxRStickRange,
+QSpinBox#vibrationSpinPlayer1,
+QSpinBox#vibrationSpinPlayer2,
+QSpinBox#vibrationSpinPlayer3,
+QSpinBox#vibrationSpinPlayer4,
+QSpinBox#vibrationSpinPlayer5,
+QSpinBox#vibrationSpinPlayer6,
+QSpinBox#vibrationSpinPlayer7,
+QSpinBox#vibrationSpinPlayer8 {
+    min-width: 68px;
 }

+QDialog#ConfigureVibration QGroupBox::indicator,
 QGroupBox#motionGroup::indicator,
 QGroupBox#vibrationGroup::indicator {
    margin-left: 0px;
 }

+QDialog#ConfigureVibration QGroupBox::title,
 QGroupBox#motionGroup::title,
 QGroupBox#vibrationGroup::title {
    spacing: 2px;
@@ -1340,16 +1339,7 @@ QWidget#middleControllerApplet {

 QWidget#topPerGameInput QComboBox,
 QWidget#middleControllerApplet QComboBox {
-    width: 119px;
-}
-
-QRadioButton#radioDocked {
-    margin-left: -3px;
-}
-
-
-QRadioButton#radioUndocked {
-    margin-right: 5px;
+    width: 120px;
 }

 QWidget#connectedControllers {
@@ -172,8 +172,8 @@ QCheckBox {
  color: #F0F0F0;
  spacing: 4px;
  outline: none;
-  padding-top: 4px;
-  padding-bottom: 4px;
+  padding-top: 2px;
+  padding-bottom: 2px;
 }

 QCheckBox:focus {
@@ -239,7 +239,7 @@ QGroupBox {
  border: 1px solid #32414B;
  border-radius: 4px;
  margin-top: 12px;
-  padding: 4px;
+  padding: 2px;
 }

 QGroupBox::title {
@@ -247,7 +247,7 @@ QGroupBox::title {
  subcontrol-position: top left;
  padding-left: 3px;
  padding-right: 5px;
-  padding-top: 4px;
+  padding-top: 2px;
 }

 QGroupBox::indicator {
@@ -298,6 +298,11 @@ QRadioButton {
  outline: none;
 }

+QGroupBox QRadioButton {
+  padding-left: 0px;
+  padding-right: 7px;
+}
+
 QRadioButton:focus {
  border: none;
 }
@@ -321,7 +326,6 @@ QRadioButton QWidget {
 QRadioButton::indicator {
  border: none;
  outline: none;
-  margin-left: 4px;
  height: 16px;
  width: 16px;
 }
@@ -785,14 +789,8 @@ QAbstractSpinBox {
  background-color: #19232D;
  border: 1px solid #32414B;
  color: #F0F0F0;
-  /* This fixes 103, 111 */
-  padding-top: 2px;
-  /* This fixes 103, 111 */
-  padding-bottom: 2px;
-  padding-left: 4px;
-  padding-right: 4px;
  border-radius: 4px;
-  /* min-width: 5px; removed to fix 109 */
+  min-height: 19px;
 }

 QAbstractSpinBox:up-button {
@@ -997,10 +995,11 @@ QPushButton {
  border: 1px solid #32414B;
  color: #F0F0F0;
  border-radius: 4px;
-  padding: 3px;
+  padding: 3px 0px 3px 0px;
  outline: none;
  /* Issue #194 - Special case of QPushButton inside dialogs, for better UI */
  min-width: 80px;
+  min-height: 13px;
 }

 QPushButton:disabled {
@@ -1008,14 +1007,14 @@ QPushButton:disabled {
  border: 1px solid #32414B;
  color: #787878;
  border-radius: 4px;
-  padding: 3px;
+  padding: 3px 0px 3px 0px;
 }

 QPushButton:checked {
  background-color: #32414B;
  border: 1px solid #32414B;
  border-radius: 4px;
-  padding: 3px;
+  padding: 3px 0px 3px 0px;
  outline: none;
 }

@@ -1024,7 +1023,7 @@ QPushButton:checked:disabled {
  border: 1px solid #32414B;
  color: #787878;
  border-radius: 4px;
-  padding: 3px;
+  padding: 3px 0px 3px 0px;
  outline: none;
 }

@@ -1197,15 +1196,9 @@ QComboBox {
  border: 1px solid #32414B;
  border-radius: 4px;
  selection-background-color: #1464A0;
-  padding-left: 4px;
-  padding-right: 36px;
-  /* 4 + 16*2 See scrollbar size */
-  /* Fixes #103, #111 */
-  min-height: 1.5em;
-  /* padding-top: 2px;     removed to fix #132 */
-  /* padding-bottom: 2px;  removed to fix #132 */
-  /* min-width: 75px;      removed to fix #109 */
-  /* Needed to remove indicator - fix #132 */
+  padding: 0px 4px 0px 4px;
+  min-width: 60px;
+  min-height: 19px;
 }

 QComboBox QAbstractItemView {
@@ -2198,29 +2191,40 @@ QPushButton#RendererStatusBarButton:!checked {
 }

 QPushButton#buttonRefreshDevices {
-  min-width: 20px;
-  min-height: 20px;
-  max-width: 20px;
-  max-height: 20px;
+  min-width: 19px;
+  min-height: 19px;
+  max-width: 19px;
+  max-height: 19px;
  padding: 0px 0px;
 }

 QSpinBox#spinboxLStickRange,
-QSpinBox#spinboxRStickRange {
-  min-width: 38px;
+QSpinBox#spinboxRStickRange,
+QSpinBox#vibrationSpinPlayer1,
+QSpinBox#vibrationSpinPlayer2,
+QSpinBox#vibrationSpinPlayer3,
+QSpinBox#vibrationSpinPlayer4,
+QSpinBox#vibrationSpinPlayer5,
+QSpinBox#vibrationSpinPlayer6,
+QSpinBox#vibrationSpinPlayer7,
+QSpinBox#vibrationSpinPlayer8 {
+  min-width: 68px;
 }

+QDialog#ConfigureVibration QGroupBox::indicator,
 QGroupBox#motionGroup::indicator,
 QGroupBox#vibrationGroup::indicator {
  margin-left: 0px;
 }

+QDialog#ConfigureVibration QGroupBox,
 QWidget#bottomPerGameInput QGroupBox#motionGroup,
 QWidget#bottomPerGameInput QGroupBox#vibrationGroup,
 QWidget#bottomPerGameInput QGroupBox#inputConfigGroup {
  padding: 0px;
 }

+QDialog#ConfigureVibration QGroupBox::title,
 QGroupBox#motionGroup::title,
 QGroupBox#vibrationGroup::title {
  spacing: 2px;
@@ -2260,26 +2264,7 @@ QWidget#middleControllerApplet {

 QWidget#topPerGameInput QComboBox,
 QWidget#middleControllerApplet QComboBox {
-  padding-right: 2px;
-  width: 127px;
-}
-
-QGroupBox#handheldGroup {
-  padding-left: 0px;
-}
-
-QRadioButton#radioDocked {
-  margin-left: -1px;
-  padding-left: 0px;
-}
-
-QRadioButton#radioDocked::indicator {
-  margin-left: 0px;
-}
-
-
-QRadioButton#radioUndocked {
-  margin-right: 2px;
+  width: 120px;
 }

 QWidget#connectedControllers {
@@ -2352,7 +2337,7 @@ QCheckBox#checkboxPlayer5Connected,
 QCheckBox#checkboxPlayer6Connected,
 QCheckBox#checkboxPlayer7Connected,
 QCheckBox#checkboxPlayer8Connected {
-    spacing: 0px;
+  spacing: 0px;
 }

 QWidget#connectedControllers QLabel {
@@ -2427,7 +2412,7 @@ QCheckBox#checkboxPlayer7Connected::indicator,
 QCheckBox#checkboxPlayer8Connected::indicator {
  width: 14px;
  height: 14px;
-  margin-left: 2px;
+  margin-left: 0px;
 }

 QWidget#Player1LEDs QCheckBox::indicator:checked,
@@ -73,17 +73,20 @@ if (NOT LIBZIP_FOUND)
 endif()

 if (ENABLE_WEB_SERVICE)
-    # LibreSSL
-    set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
-    add_subdirectory(libressl EXCLUDE_FROM_ALL)
-    target_include_directories(ssl INTERFACE ./libressl/include)
-    target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
-    get_directory_property(OPENSSL_LIBRARIES
-        DIRECTORY libressl
-        DEFINITION OPENSSL_LIBS)
-
-    # lurlparser
-    add_subdirectory(lurlparser EXCLUDE_FROM_ALL)
+    find_package(OpenSSL 1.1)
+    if (OPENSSL_FOUND)
+        set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
+    else()
+        # LibreSSL
+        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
+        set(OPENSSLDIR "/etc/ssl/")
+        add_subdirectory(libressl EXCLUDE_FROM_ALL)
+        target_include_directories(ssl INTERFACE ./libressl/include)
+        target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
+        get_directory_property(OPENSSL_LIBRARIES
+            DIRECTORY libressl
+            DEFINITION OPENSSL_LIBS)
+    endif()

    # httplib
    add_library(httplib INTERFACE)
@@ -0,0 +1,100 @@
+# - Try to find ffmpeg libraries (libavcodec, libavformat and libavutil)
+# Once done this will define
+#
+# FFMPEG_FOUND - system has ffmpeg or libav
+# FFMPEG_INCLUDE_DIR - the ffmpeg include directory
+# FFMPEG_LIBRARIES - Link these to use ffmpeg
+# FFMPEG_LIBAVCODEC
+# FFMPEG_LIBAVFORMAT
+# FFMPEG_LIBAVUTIL
+#
+# Copyright (c) 2008 Andreas Schneider <mail@cynapses.org>
+# Modified for other libraries by Lasse Kärkkäinen <tronic>
+# Modified for Hedgewars by Stepik777
+# Modified for FFmpeg-example Tuukka Pasanen 2018
+# Modified for yuzu toastUnlimted 2020
+#
+# Redistribution and use is allowed according to the terms of the New
+# BSD license.
+#
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(FFMPEG
+  FOUND_VAR FFMPEG_FOUND
+  REQUIRED_VARS
+      FFMPEG_LIBRARY
+      FFMPEG_INCLUDE_DIR
+  VERSION_VAR FFMPEG_VERSION
+)
+
+if(FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
+  # in cache already
+  set(FFMPEG_FOUND TRUE)
+else()
+  # use pkg-config to get the directories and then use these values
+  # in the FIND_PATH() and FIND_LIBRARY() calls
+  find_package(PkgConfig)
+  if(PKG_CONFIG_FOUND)
+    pkg_check_modules(_FFMPEG_AVCODEC libavcodec)
+    pkg_check_modules(_FFMPEG_AVUTIL libavutil)
+    pkg_check_modules(_FFMPEG_SWSCALE libswscale)
+  endif()
+
+  find_path(FFMPEG_AVCODEC_INCLUDE_DIR
+    NAMES libavcodec/avcodec.h
+    PATHS ${_FFMPEG_AVCODEC_INCLUDE_DIRS}
+      /usr/include
+      /usr/local/include
+      /opt/local/include
+      /sw/include
+    PATH_SUFFIXES ffmpeg libav)
+
+  find_library(FFMPEG_LIBAVCODEC
+    NAMES avcodec
+    PATHS ${_FFMPEG_AVCODEC_LIBRARY_DIRS}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib)
+
+  find_library(FFMPEG_LIBAVUTIL
+    NAMES avutil
+    PATHS ${_FFMPEG_AVUTIL_LIBRARY_DIRS}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib)
+
+  find_library(FFMPEG_LIBSWSCALE
+    NAMES swscale
+    PATHS ${_FFMPEG_SWSCALE_LIBRARY_DIRS}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib)
+
+  if(FFMPEG_LIBAVCODEC AND FFMPEG_LIBAVUTIL AND FFMPEG_LIBSWSCALE)
+    set(FFMPEG_FOUND TRUE)
+  endif()
+
+  if(FFMPEG_FOUND)
+    set(FFMPEG_INCLUDE_DIR ${FFMPEG_AVCODEC_INCLUDE_DIR})
+    set(FFMPEG_LIBRARIES
+      ${FFMPEG_LIBAVCODEC}
+      ${FFMPEG_LIBAVUTIL}
+      ${FFMPEG_LIBSWSCALE})
+  endif()
+
+  if(FFMPEG_FOUND)
+    if(NOT FFMPEG_FIND_QUIETLY)
+      message(STATUS
+      "Found FFMPEG or Libav: ${FFMPEG_LIBRARIES}, ${FFMPEG_INCLUDE_DIR}")
+    endif()
+  else()
+    if(FFMPEG_FIND_REQUIRED)
+      message(FATAL_ERROR
+      "Could not find libavcodec or libavutil or libswscale")
+    endif()
+  endif()
+endif()
@@ -1,4 +1,4 @@
-From https://github.com/yhirose/cpp-httplib/tree/fce8e6fefdab4ad48bc5b25c98e5ebfda4f3cf53
+From https://github.com/yhirose/cpp-httplib/tree/ff5677ad197947177c158fe857caff4f0e242045 with https://github.com/yhirose/cpp-httplib/pull/701

 MIT License

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

@@ -868,7 +868,7 @@ inline int64_t MicroProfileLogGetTick(MicroProfileLogEntry e)

 inline int64_t MicroProfileLogSetTick(MicroProfileLogEntry e, int64_t nTick)
 {
-    return static_cast<int64_t>((MP_LOG_TICK_MASK & static_cast<uint64_t>(nTick)) | (e & static_cast<uint64_t>(~MP_LOG_TICK_MASK)));
+    return (MP_LOG_TICK_MASK & nTick) | (e & ~MP_LOG_TICK_MASK);
 }

 template<typename T>
@@ -902,8 +902,10 @@ inline uint16_t MicroProfileGetGroupIndex(MicroProfileToken t)
 #include <windows.h>
 #define snprintf _snprintf

+#ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable: 4244)
+#endif
 int64_t MicroProfileTicksPerSecondCpu()
 {
    static int64_t nTicksPerSecond = 0;
@@ -946,7 +948,11 @@ typedef HANDLE MicroProfileThread;
 DWORD _stdcall ThreadTrampoline(void* pFunc)
 {
    MicroProfileThreadFunc F = (MicroProfileThreadFunc)pFunc;
-    return (uint32_t)F(0);
+
+    // The return value of F will always return a void*, however, this is for
+    // compatibility with pthreads. The underlying "address" of the pointer
+    // is always a 32-bit value, so this cast is safe to perform.
+    return static_cast<DWORD>(reinterpret_cast<uint64_t>(F(0)));
 }

 inline void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
@@ -1742,10 +1748,10 @@ void MicroProfileFlip()
                            }
                        }
                    }
-                    for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUPS; ++i)
+                    for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
                    {
-                        pLog->nGroupTicks[i] += nGroupTicks[i];
-                        pFrameGroup[i] += nGroupTicks[i];
+                        pLog->nGroupTicks[j] += nGroupTicks[j];
+                        pFrameGroup[j] += nGroupTicks[j];
                    }
                    pLog->nStackPos = nStackPos;
                }
@@ -3328,7 +3334,7 @@ bool MicroProfileIsLocalThread(uint32_t nThreadId)
 #endif
 #else

-bool MicroProfileIsLocalThread(uint32_t nThreadId){return false;}
+bool MicroProfileIsLocalThread([[maybe_unused]] uint32_t nThreadId) { return false; }
 void MicroProfileStopContextSwitchTrace(){}
 void MicroProfileStartContextSwitchTrace(){}

@@ -3576,7 +3582,7 @@ int MicroProfileGetGpuTickReference(int64_t* pOutCpu, int64_t* pOutGpu)

 #undef S

-#ifdef _WIN32
+#ifdef _MSC_VER
 #pragma warning(pop)
 #endif

@@ -32,7 +32,6 @@ if (MSVC)
    # /Zc:inline          - Let codegen omit inline functions in object files
    # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
    add_compile_options(
-        /W3
        /MP
        /Zi
        /Zo
@@ -43,6 +42,13 @@ if (MSVC)
        /Zc:externConstexpr
        /Zc:inline
        /Zc:throwingNew
+
+        # Warnings
+        /W3
+        /we4547 # 'operator' : operator before comma has no effect; expected operator with side-effect
+        /we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
+        /we4555 # Expression has no effect; expected expression with side-effect
+        /we4834 # Discarding return value of function with 'nodiscard' attribute
    )

    # /GS- - No stack buffer overflow checks
@@ -56,6 +62,7 @@ else()
        -Werror=implicit-fallthrough
        -Werror=missing-declarations
        -Werror=reorder
+        -Werror=unused-result
        -Wextra
        -Wmissing-declarations
        -Wno-attributes
@@ -51,10 +51,12 @@ if (NOT MSVC)
        -Werror=implicit-fallthrough
        -Werror=reorder
        -Werror=sign-compare
-        -Werror=sign-conversion
+        -Werror=unused-variable
+
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
-        -Werror=unused-variable
+
+        -Wno-sign-conversion
    )
 endif()

@@ -167,8 +167,8 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
    output.reserve(static_cast<std::size_t>(static_cast<double>(input.size()) / ratio +
                                            InterpolationState::taps));

-    for (std::size_t frame = 0; frame < num_frames; ++frame) {
-        const auto lut_index{static_cast<size_t>(state.fraction >> 8) * InterpolationState::taps};
+    for (std::size_t frame{}; frame < num_frames; ++frame) {
+        const std::size_t lut_index{(state.fraction >> 8) * InterpolationState::taps};

        std::rotate(state.history.begin(), state.history.end() - 1, state.history.end());
        state.history[0][0] = input[frame * 2 + 0];
@@ -225,7 +225,7 @@ void Resample(s32* output, const s32* input, s32 pitch, s32& fraction, std::size

        output[i] = (l0 * s0 + l1 * s1 + l2 * s2 + l3 * s3) >> 15;
        fraction += pitch;
-        index += static_cast<size_t>(fraction >> 15);
+        index += (fraction >> 15);
        fraction &= 0x7fff;
    }
 }
@@ -187,8 +187,8 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
        const auto& in_params = final_mix.GetInParams();
        std::vector<s32*> mix_buffers(channel_count);
        for (std::size_t i = 0; i < channel_count; i++) {
-            mix_buffers[i] = command_generator.GetMixBuffer(
-                static_cast<u32>(in_params.buffer_offset) + buffer_offsets[i]);
+            mix_buffers[i] =
+                command_generator.GetMixBuffer(in_params.buffer_offset + buffer_offsets[i]);
        }

        for (std::size_t i = 0; i < BUFFER_SIZE; i++) {
@@ -32,7 +32,7 @@ std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM
    for (std::size_t framei = 0; framei < NUM_FRAMES; framei++) {
        const int frame_header = data[framei * FRAME_LEN];
        const int scale = 1 << (frame_header & 0xF);
-        const auto idx = static_cast<size_t>((frame_header >> 4) & 0x7);
+        const int idx = (frame_header >> 4) & 0x7;

        // Coefficients are fixed point with 11 bits fractional part.
        const int coef1 = coeff[idx * 2 + 0];
@@ -57,11 +57,11 @@ std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM
        std::size_t outputi = framei * SAMPLES_PER_FRAME;
        std::size_t datai = framei * FRAME_LEN + 1;
        for (std::size_t i = 0; i < SAMPLES_PER_FRAME && outputi < sample_count; i += 2) {
-            const s16 sample1 = decode_sample(SIGNED_NIBBLES[static_cast<u32>(data[datai] >> 4)]);
+            const s16 sample1 = decode_sample(SIGNED_NIBBLES[data[datai] >> 4]);
            ret[outputi] = sample1;
            outputi++;

-            const s16 sample2 = decode_sample(SIGNED_NIBBLES[static_cast<u32>(data[datai] & 0xF)]);
+            const s16 sample2 = decode_sample(SIGNED_NIBBLES[data[datai] & 0xF]);
            ret[outputi] = sample2;
            outputi++;

@@ -15,8 +15,8 @@ constexpr std::size_t MIX_BUFFER_SIZE = 0x3f00;
 constexpr std::size_t SCALED_MIX_BUFFER_SIZE = MIX_BUFFER_SIZE << 15ULL;

 template <std::size_t N>
-void ApplyMix(s32* output, const s32* input, s32 gain, std::size_t sample_count) {
-    for (std::size_t i = 0; i < sample_count; i += N) {
+void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
+    for (std::size_t i = 0; i < static_cast<std::size_t>(sample_count); i += N) {
        for (std::size_t j = 0; j < N; j++) {
            output[i + j] +=
                static_cast<s32>((static_cast<s64>(input[i + j]) * gain + 0x4000) >> 15);
@@ -111,8 +111,7 @@ void CommandGenerator::GenerateVoiceCommand(ServerVoiceInfo& voice_info) {
    const auto channel_count = in_params.channel_count;

    for (s32 channel = 0; channel < channel_count; channel++) {
-        const auto resource_id =
-            static_cast<u32>(in_params.voice_channel_resource_id[static_cast<u32>(channel)]);
+        const auto resource_id = in_params.voice_channel_resource_id[channel];
        auto& dsp_state = voice_context.GetDspSharedState(resource_id);
        auto& channel_resource = voice_context.GetChannelResource(resource_id);

@@ -133,15 +132,14 @@ void CommandGenerator::GenerateVoiceCommand(ServerVoiceInfo& voice_info) {

            if (in_params.mix_id != AudioCommon::NO_MIX) {
                // If we're using a mix id
-                auto& mix_info = mix_context.GetInfo(static_cast<u32>(in_params.mix_id));
+                auto& mix_info = mix_context.GetInfo(in_params.mix_id);
                const auto& dest_mix_params = mix_info.GetInParams();

                // Voice Mixing
                GenerateVoiceMixCommand(
                    channel_resource.GetCurrentMixVolume(), channel_resource.GetLastMixVolume(),
-                    dsp_state, static_cast<u32>(dest_mix_params.buffer_offset),
-                    static_cast<u32>(dest_mix_params.buffer_count),
-                    worker_params.mix_buffer_count + static_cast<u32>(channel), in_params.node_id);
+                    dsp_state, dest_mix_params.buffer_offset, dest_mix_params.buffer_count,
+                    worker_params.mix_buffer_count + channel, in_params.node_id);

                // Update last mix volumes
                channel_resource.UpdateLastMixVolumes();
@@ -158,15 +156,12 @@ void CommandGenerator::GenerateVoiceCommand(ServerVoiceInfo& voice_info) {
                        continue;
                    }

-                    const auto& mix_info =
-                        mix_context.GetInfo(static_cast<u32>(destination_data->GetMixId()));
+                    const auto& mix_info = mix_context.GetInfo(destination_data->GetMixId());
                    const auto& dest_mix_params = mix_info.GetInParams();
                    GenerateVoiceMixCommand(
                        destination_data->CurrentMixVolumes(), destination_data->LastMixVolumes(),
-                        dsp_state, static_cast<u32>(dest_mix_params.buffer_offset),
-                        static_cast<u32>(dest_mix_params.buffer_count),
-                        worker_params.mix_buffer_count + static_cast<u32>(channel),
-                        in_params.node_id);
+                        dsp_state, dest_mix_params.buffer_offset, dest_mix_params.buffer_count,
+                        worker_params.mix_buffer_count + channel, in_params.node_id);
                    destination_data->MarkDirty();
                }
            }
@@ -224,10 +219,9 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo

    if (depop) {
        if (in_params.mix_id != AudioCommon::NO_MIX) {
-            auto& mix_info = mix_context.GetInfo(static_cast<u32>(in_params.mix_id));
+            auto& mix_info = mix_context.GetInfo(in_params.mix_id);
            const auto& mix_in = mix_info.GetInParams();
-            GenerateDepopPrepareCommand(dsp_state, static_cast<u32>(mix_in.buffer_count),
-                                        static_cast<u32>(mix_in.buffer_offset));
+            GenerateDepopPrepareCommand(dsp_state, mix_in.buffer_count, mix_in.buffer_offset);
        } else if (in_params.splitter_info_id != AudioCommon::NO_SPLITTER) {
            s32 index{};
            while (const auto* destination =
@@ -235,24 +229,23 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo
                if (!destination->IsConfigured()) {
                    continue;
                }
-                auto& mix_info = mix_context.GetInfo(static_cast<u32>(destination->GetMixId()));
+                auto& mix_info = mix_context.GetInfo(destination->GetMixId());
                const auto& mix_in = mix_info.GetInParams();
-                GenerateDepopPrepareCommand(dsp_state, static_cast<u32>(mix_in.buffer_count),
-                                            static_cast<u32>(mix_in.buffer_offset));
+                GenerateDepopPrepareCommand(dsp_state, mix_in.buffer_count, mix_in.buffer_offset);
            }
        }
    } else {
        switch (in_params.sample_format) {
        case SampleFormat::Pcm16:
            DecodeFromWaveBuffers(voice_info, GetChannelMixBuffer(channel), dsp_state, channel,
-                                  static_cast<s32>(worker_params.sample_rate),
-                                  static_cast<s32>(worker_params.sample_count), in_params.node_id);
+                                  worker_params.sample_rate, worker_params.sample_count,
+                                  in_params.node_id);
            break;
        case SampleFormat::Adpcm:
            ASSERT(channel == 0 && in_params.channel_count == 1);
            DecodeFromWaveBuffers(voice_info, GetChannelMixBuffer(0), dsp_state, 0,
-                                  static_cast<s32>(worker_params.sample_rate),
-                                  static_cast<s32>(worker_params.sample_count), in_params.node_id);
+                                  worker_params.sample_rate, worker_params.sample_count,
+                                  in_params.node_id);
            break;
        default:
            UNREACHABLE_MSG("Unimplemented sample format={}", in_params.sample_format);
@@ -262,7 +255,7 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo

 void CommandGenerator::GenerateBiquadFilterCommandForVoice(ServerVoiceInfo& voice_info,
                                                           VoiceState& dsp_state,
-                                                           u32 mix_buffer_count, s32 channel) {
+                                                           s32 mix_buffer_count, s32 channel) {
    for (std::size_t i = 0; i < AudioCommon::MAX_BIQUAD_FILTERS; i++) {
        const auto& in_params = voice_info.GetInParams();
        auto& biquad_filter = in_params.biquad_filter[i];
@@ -342,8 +335,8 @@ void CommandGenerator::GenerateDepopForMixBuffersCommand(std::size_t mix_buffer_
            continue;
        }

-        depop_buffer[i] = ApplyMixDepop(GetMixBuffer(i), depop_buffer[i], delta,
-                                        static_cast<s32>(worker_params.sample_count));
+        depop_buffer[i] =
+            ApplyMixDepop(GetMixBuffer(i), depop_buffer[i], delta, worker_params.sample_count);
    }
 }

@@ -355,7 +348,7 @@ void CommandGenerator::GenerateEffectCommand(ServerMixInfo& mix_info) {
        if (index == AudioCommon::NO_EFFECT_ORDER) {
            break;
        }
-        auto* info = effect_context.GetInfo(static_cast<u32>(index));
+        auto* info = effect_context.GetInfo(index);
        const auto type = info->GetType();

        // TODO(ogniK): Finish remaining effects
@@ -384,11 +377,11 @@ void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, E
    }
    const auto& params = dynamic_cast<EffectI3dl2Reverb*>(info)->GetParams();
    const auto channel_count = params.channel_count;
-    for (size_t i = 0; i < channel_count; i++) {
+    for (s32 i = 0; i < channel_count; i++) {
        // TODO(ogniK): Actually implement reverb
        if (params.input[i] != params.output[i]) {
-            const auto* input = GetMixBuffer(static_cast<u32>(mix_buffer_offset + params.input[i]));
-            auto* output = GetMixBuffer(static_cast<u32>(mix_buffer_offset + params.output[i]));
+            const auto* input = GetMixBuffer(mix_buffer_offset + params.input[i]);
+            auto* output = GetMixBuffer(mix_buffer_offset + params.output[i]);
            ApplyMix<1>(output, input, 32768, worker_params.sample_count);
        }
    }
@@ -399,14 +392,13 @@ void CommandGenerator::GenerateBiquadFilterEffectCommand(s32 mix_buffer_offset,
    if (!enabled) {
        return;
    }
-
    const auto& params = dynamic_cast<EffectBiquadFilter*>(info)->GetParams();
-    const auto channel_count = static_cast<u32>(params.channel_count);
-    for (size_t i = 0; i < channel_count; i++) {
+    const auto channel_count = params.channel_count;
+    for (s32 i = 0; i < channel_count; i++) {
        // TODO(ogniK): Actually implement biquad filter
        if (params.input[i] != params.output[i]) {
-            const auto* input = GetMixBuffer(static_cast<u32>(mix_buffer_offset + params.input[i]));
-            auto* output = GetMixBuffer(static_cast<u32>(mix_buffer_offset + params.output[i]));
+            const auto* input = GetMixBuffer(mix_buffer_offset + params.input[i]);
+            auto* output = GetMixBuffer(mix_buffer_offset + params.output[i]);
            ApplyMix<1>(output, input, 32768, worker_params.sample_count);
        }
    }
@@ -433,30 +425,26 @@ void CommandGenerator::GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* inf
                memory.ReadBlock(aux->GetSendInfo(), &send_info, sizeof(AuxInfoDSP));
                memory.ReadBlock(aux->GetRecvInfo(), &recv_info, sizeof(AuxInfoDSP));

-                WriteAuxBuffer(send_info, aux->GetSendBuffer(),
-                               static_cast<u32>(params.sample_count),
-                               GetMixBuffer(static_cast<u32>(input_index)),
-                               worker_params.sample_count, offset, write_count);
+                WriteAuxBuffer(send_info, aux->GetSendBuffer(), params.sample_count,
+                               GetMixBuffer(input_index), worker_params.sample_count, offset,
+                               write_count);
                memory.WriteBlock(aux->GetSendInfo(), &send_info, sizeof(AuxInfoDSP));

                const auto samples_read = ReadAuxBuffer(
-                    recv_info, aux->GetRecvBuffer(), static_cast<u32>(params.sample_count),
-                    GetMixBuffer(static_cast<u32>(output_index)), worker_params.sample_count,
-                    offset, write_count);
+                    recv_info, aux->GetRecvBuffer(), params.sample_count,
+                    GetMixBuffer(output_index), worker_params.sample_count, offset, write_count);
                memory.WriteBlock(aux->GetRecvInfo(), &recv_info, sizeof(AuxInfoDSP));

                if (samples_read != static_cast<int>(worker_params.sample_count) &&
                    samples_read <= params.sample_count) {
-                    std::memset(GetMixBuffer(static_cast<u32>(output_index)), 0,
-                                static_cast<size_t>(params.sample_count - samples_read));
+                    std::memset(GetMixBuffer(output_index), 0, params.sample_count - samples_read);
                }
            } else {
                AuxInfoDSP empty{};
                memory.WriteBlock(aux->GetSendInfo(), &empty, sizeof(AuxInfoDSP));
                memory.WriteBlock(aux->GetRecvInfo(), &empty, sizeof(AuxInfoDSP));
                if (output_index != input_index) {
-                    std::memcpy(GetMixBuffer(static_cast<u32>(output_index)),
-                                GetMixBuffer(static_cast<u32>(input_index)),
+                    std::memcpy(GetMixBuffer(output_index), GetMixBuffer(input_index),
                                worker_params.sample_count * sizeof(s32));
                }
            }
@@ -470,8 +458,7 @@ ServerSplitterDestinationData* CommandGenerator::GetDestinationData(s32 splitter
    if (splitter_id == AudioCommon::NO_SPLITTER) {
        return nullptr;
    }
-    return splitter_context.GetDestinationData(static_cast<u32>(splitter_id),
-                                               static_cast<u32>(index));
+    return splitter_context.GetDestinationData(splitter_id, index);
 }

 s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples,
@@ -501,7 +488,7 @@ s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u3
    if (write_count != 0) {
        dsp_info.write_offset = (dsp_info.write_offset + write_count) % max_samples;
    }
-    return static_cast<s32>(sample_count);
+    return sample_count;
 }

 s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples,
@@ -531,7 +518,7 @@ s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u3
    if (read_count != 0) {
        recv_info.read_offset = (recv_info.read_offset + read_count) % max_samples;
    }
-    return static_cast<s32>(sample_count);
+    return sample_count;
 }

 void CommandGenerator::GenerateVolumeRampCommand(float last_volume, float current_volume,
@@ -550,15 +537,15 @@ void CommandGenerator::GenerateVolumeRampCommand(float last_volume, float curren
    }
    // Apply generic gain on samples
    ApplyGain(GetChannelMixBuffer(channel), GetChannelMixBuffer(channel), last, delta,
-              static_cast<s32>(worker_params.sample_count));
+              worker_params.sample_count);
 }

 void CommandGenerator::GenerateVoiceMixCommand(const MixVolumeBuffer& mix_volumes,
                                               const MixVolumeBuffer& last_mix_volumes,
-                                               VoiceState& dsp_state, u32 mix_buffer_offset,
-                                               u32 mix_buffer_count, u32 voice_index, s32 node_id) {
+                                               VoiceState& dsp_state, s32 mix_buffer_offset,
+                                               s32 mix_buffer_count, s32 voice_index, s32 node_id) {
    // Loop all our mix buffers
-    for (size_t i = 0; i < mix_buffer_count; i++) {
+    for (s32 i = 0; i < mix_buffer_count; i++) {
        if (last_mix_volumes[i] != 0.0f || mix_volumes[i] != 0.0f) {
            const auto delta = static_cast<float>((mix_volumes[i] - last_mix_volumes[i])) /
                               static_cast<float>(worker_params.sample_count);
@@ -571,9 +558,9 @@ void CommandGenerator::GenerateVoiceMixCommand(const MixVolumeBuffer& mix_volume
                          mix_volumes[i]);
            }

-            dsp_state.previous_samples[i] = ApplyMixRamp(
-                GetMixBuffer(mix_buffer_offset + i), GetMixBuffer(voice_index), last_mix_volumes[i],
-                delta, static_cast<s32>(worker_params.sample_count));
+            dsp_state.previous_samples[i] =
+                ApplyMixRamp(GetMixBuffer(mix_buffer_offset + i), GetMixBuffer(voice_index),
+                             last_mix_volumes[i], delta, worker_params.sample_count);
        } else {
            dsp_state.previous_samples[i] = 0;
        }
@@ -585,8 +572,7 @@ void CommandGenerator::GenerateSubMixCommand(ServerMixInfo& mix_info) {
        LOG_DEBUG(Audio, "(DSP_TRACE) GenerateSubMixCommand");
    }
    const auto& in_params = mix_info.GetInParams();
-    GenerateDepopForMixBuffersCommand(static_cast<u32>(in_params.buffer_count),
-                                      static_cast<u32>(in_params.buffer_offset),
+    GenerateDepopForMixBuffersCommand(in_params.buffer_count, in_params.buffer_offset,
                                      in_params.sample_rate);

    GenerateEffectCommand(mix_info);
@@ -600,18 +586,18 @@ void CommandGenerator::GenerateMixCommands(ServerMixInfo& mix_info) {
    }
    const auto& in_params = mix_info.GetInParams();
    if (in_params.dest_mix_id != AudioCommon::NO_MIX) {
-        const auto& dest_mix = mix_context.GetInfo(static_cast<u32>(in_params.dest_mix_id));
+        const auto& dest_mix = mix_context.GetInfo(in_params.dest_mix_id);
        const auto& dest_in_params = dest_mix.GetInParams();

-        const auto buffer_count = static_cast<u32>(in_params.buffer_count);
+        const auto buffer_count = in_params.buffer_count;

-        for (u32 i = 0; i < buffer_count; i++) {
-            for (u32 j = 0; j < static_cast<u32>(dest_in_params.buffer_count); j++) {
+        for (s32 i = 0; i < buffer_count; i++) {
+            for (s32 j = 0; j < dest_in_params.buffer_count; j++) {
                const auto mixed_volume = in_params.volume * in_params.mix_volume[i][j];
                if (mixed_volume != 0.0f) {
-                    GenerateMixCommand(static_cast<size_t>(dest_in_params.buffer_offset) + j,
-                                       static_cast<size_t>(in_params.buffer_offset) + i,
-                                       mixed_volume, static_cast<s32>(in_params.node_id));
+                    GenerateMixCommand(dest_in_params.buffer_offset + j,
+                                       in_params.buffer_offset + i, mixed_volume,
+                                       in_params.node_id);
                }
            }
        }
@@ -622,17 +608,15 @@ void CommandGenerator::GenerateMixCommands(ServerMixInfo& mix_info) {
                continue;
            }

-            const auto& dest_mix =
-                mix_context.GetInfo(static_cast<u32>(destination_data->GetMixId()));
+            const auto& dest_mix = mix_context.GetInfo(destination_data->GetMixId());
            const auto& dest_in_params = dest_mix.GetInParams();
            const auto mix_index = (base - 1) % in_params.buffer_count + in_params.buffer_offset;
            for (std::size_t i = 0; i < static_cast<std::size_t>(dest_in_params.buffer_count);
                 i++) {
                const auto mixed_volume = in_params.volume * destination_data->GetMixVolume(i);
                if (mixed_volume != 0.0f) {
-                    GenerateMixCommand(static_cast<size_t>(dest_in_params.buffer_offset) + i,
-                                       static_cast<size_t>(mix_index), mixed_volume,
-                                       static_cast<s32>(in_params.node_id));
+                    GenerateMixCommand(dest_in_params.buffer_offset + i, mix_index, mixed_volume,
+                                       in_params.node_id);
                }
            }
        }
@@ -651,8 +635,7 @@ void CommandGenerator::GenerateMixCommand(std::size_t output_offset, std::size_t
    auto* output = GetMixBuffer(output_offset);
    const auto* input = GetMixBuffer(input_offset);

-    const auto gain = static_cast<s32>(volume * 32768.0f);
-
+    const s32 gain = static_cast<s32>(volume * 32768.0f);
    // Mix with loop unrolling
    if (worker_params.sample_count % 4 == 0) {
        ApplyMix<4>(output, input, gain, worker_params.sample_count);
@@ -670,8 +653,7 @@ void CommandGenerator::GenerateFinalMixCommand() {
    auto& mix_info = mix_context.GetFinalMixInfo();
    const auto& in_params = mix_info.GetInParams();

-    GenerateDepopForMixBuffersCommand(static_cast<u32>(in_params.buffer_count),
-                                      static_cast<u32>(in_params.buffer_offset),
+    GenerateDepopForMixBuffersCommand(in_params.buffer_count, in_params.buffer_offset,
                                      in_params.sample_rate);

    GenerateEffectCommand(mix_info);
@@ -685,16 +667,16 @@ void CommandGenerator::GenerateFinalMixCommand() {
                in_params.node_id, in_params.buffer_offset + i, in_params.buffer_offset + i,
                in_params.volume);
        }
-        ApplyGainWithoutDelta(GetMixBuffer(static_cast<size_t>(in_params.buffer_offset + i)),
-                              GetMixBuffer(static_cast<size_t>(in_params.buffer_offset + i)), gain,
-                              static_cast<s32>(worker_params.sample_count));
+        ApplyGainWithoutDelta(GetMixBuffer(in_params.buffer_offset + i),
+                              GetMixBuffer(in_params.buffer_offset + i), gain,
+                              worker_params.sample_count);
    }
 }

 s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
                                  s32 sample_count, s32 channel, std::size_t mix_offset) {
    const auto& in_params = voice_info.GetInParams();
-    const auto& wave_buffer = in_params.wave_buffer[static_cast<u32>(dsp_state.wave_buffer_index)];
+    const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
    if (wave_buffer.buffer_address == 0) {
        return 0;
    }
@@ -707,26 +689,24 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    const auto samples_remaining =
        (wave_buffer.end_sample_offset - wave_buffer.start_sample_offset) - dsp_state.offset;
    const auto start_offset =
-        static_cast<size_t>((wave_buffer.start_sample_offset + dsp_state.offset) *
-                            in_params.channel_count) *
+        ((wave_buffer.start_sample_offset + dsp_state.offset) * in_params.channel_count) *
        sizeof(s16);
    const auto buffer_pos = wave_buffer.buffer_address + start_offset;
    const auto samples_processed = std::min(sample_count, samples_remaining);

    if (in_params.channel_count == 1) {
-        std::vector<s16> buffer(static_cast<size_t>(samples_processed));
+        std::vector<s16> buffer(samples_processed);
        memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));
        for (std::size_t i = 0; i < buffer.size(); i++) {
            sample_buffer[mix_offset + i] = buffer[i];
        }
    } else {
        const auto channel_count = in_params.channel_count;
-        std::vector<s16> buffer(static_cast<size_t>(samples_processed * channel_count));
+        std::vector<s16> buffer(samples_processed * channel_count);
        memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));

        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
-            sample_buffer[mix_offset + i] =
-                buffer[i * static_cast<u32>(channel_count) + static_cast<u32>(channel)];
+            sample_buffer[mix_offset + i] = buffer[i * channel_count + channel];
        }
    }

@@ -736,7 +716,7 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
 s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
                                  s32 sample_count, s32 channel, std::size_t mix_offset) {
    const auto& in_params = voice_info.GetInParams();
-    const auto& wave_buffer = in_params.wave_buffer[static_cast<u32>(dsp_state.wave_buffer_index)];
+    const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
    if (wave_buffer.buffer_address == 0) {
        return 0;
    }
@@ -756,7 +736,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    constexpr std::size_t SAMPLES_PER_FRAME = 14;

    auto frame_header = dsp_state.context.header;
-    auto idx = static_cast<size_t>((frame_header >> 4) & 0xf);
+    s32 idx = (frame_header >> 4) & 0xf;
    s32 scale = frame_header & 0xf;
    s16 yn1 = dsp_state.context.yn1;
    s16 yn2 = dsp_state.context.yn2;
@@ -773,10 +753,9 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
    const auto samples_processed = std::min(sample_count, samples_remaining);
    const auto sample_pos = wave_buffer.start_sample_offset + dsp_state.offset;

-    const auto samples_remaining_in_frame = static_cast<u32>(sample_pos) % SAMPLES_PER_FRAME;
-    auto position_in_frame =
-        ((static_cast<u32>(sample_pos) / SAMPLES_PER_FRAME) * NIBBLES_PER_SAMPLE) +
-        samples_remaining_in_frame + (samples_remaining_in_frame != 0 ? 2 : 0);
+    const auto samples_remaining_in_frame = sample_pos % SAMPLES_PER_FRAME;
+    auto position_in_frame = ((sample_pos / SAMPLES_PER_FRAME) * NIBBLES_PER_SAMPLE) +
+                             samples_remaining_in_frame + (samples_remaining_in_frame != 0 ? 2 : 0);

    const auto decode_sample = [&](const int nibble) -> s16 {
        const int xn = nibble * (1 << scale);
@@ -795,7 +774,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s

    std::size_t buffer_offset{};
    std::vector<u8> buffer(
-        std::max((static_cast<u32>(samples_processed) / FRAME_LEN) * SAMPLES_PER_FRAME, FRAME_LEN));
+        std::max((samples_processed / FRAME_LEN) * SAMPLES_PER_FRAME, FRAME_LEN));
    memory.ReadBlock(wave_buffer.buffer_address + (position_in_frame / 2), buffer.data(),
                     buffer.size());
    std::size_t cur_mix_offset = mix_offset;
@@ -805,7 +784,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
        if (position_in_frame % NIBBLES_PER_SAMPLE == 0) {
            // Read header
            frame_header = buffer[buffer_offset++];
-            idx = static_cast<size_t>((frame_header >> 4) & 0xf);
+            idx = (frame_header >> 4) & 0xf;
            scale = frame_header & 0xf;
            coef1 = coeffs[idx * 2];
            coef2 = coeffs[idx * 2 + 1];
@@ -815,8 +794,8 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
            if (remaining_samples >= static_cast<int>(SAMPLES_PER_FRAME)) {
                for (std::size_t i = 0; i < SAMPLES_PER_FRAME / 2; i++) {
                    // Sample 1
-                    const s32 s0 = SIGNED_NIBBLES[static_cast<u32>(buffer[buffer_offset] >> 4)];
-                    const s32 s1 = SIGNED_NIBBLES[static_cast<u32>(buffer[buffer_offset++] & 0xf)];
+                    const s32 s0 = SIGNED_NIBBLES[buffer[buffer_offset] >> 4];
+                    const s32 s1 = SIGNED_NIBBLES[buffer[buffer_offset++] & 0xf];
                    const s16 sample_1 = decode_sample(s0);
                    const s16 sample_2 = decode_sample(s1);
                    sample_buffer[cur_mix_offset++] = sample_1;
@@ -828,14 +807,14 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
            }
        }
        // Decode mid frame
-        auto current_nibble = static_cast<s32>(buffer[buffer_offset]);
-        if ((position_in_frame++ & 1) != 0) {
+        s32 current_nibble = buffer[buffer_offset];
+        if (position_in_frame++ & 0x1) {
            current_nibble &= 0xf;
            buffer_offset++;
        } else {
            current_nibble >>= 4;
        }
-        const s16 sample = decode_sample(SIGNED_NIBBLES[static_cast<u32>(current_nibble)]);
+        const s16 sample = decode_sample(SIGNED_NIBBLES[current_nibble]);
        sample_buffer[cur_mix_offset++] = sample;
        remaining_samples--;
    }
@@ -856,7 +835,7 @@ const s32* CommandGenerator::GetMixBuffer(std::size_t index) const {
 }

 std::size_t CommandGenerator::GetMixChannelBufferOffset(s32 channel) const {
-    return worker_params.mix_buffer_count + static_cast<u32>(channel);
+    return worker_params.mix_buffer_count + channel;
 }

 std::size_t CommandGenerator::GetTotalMixBufferCount() const {
@@ -864,11 +843,11 @@ std::size_t CommandGenerator::GetTotalMixBufferCount() const {
 }

 s32* CommandGenerator::GetChannelMixBuffer(s32 channel) {
-    return GetMixBuffer(worker_params.mix_buffer_count + static_cast<u32>(channel));
+    return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }

 const s32* CommandGenerator::GetChannelMixBuffer(s32 channel) const {
-    return GetMixBuffer(worker_params.mix_buffer_count + static_cast<u32>(channel));
+    return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }

 void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* output,
@@ -916,10 +895,9 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o

        s32 samples_read{};
        while (samples_read < samples_to_read) {
-            const auto& wave_buffer =
-                in_params.wave_buffer[static_cast<u32>(dsp_state.wave_buffer_index)];
+            const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
            // No more data can be read
-            if (!dsp_state.is_wave_buffer_valid[static_cast<u32>(dsp_state.wave_buffer_index)]) {
+            if (!dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index]) {
                is_buffer_completed = true;
                break;
            }
@@ -943,7 +921,7 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
                UNREACHABLE_MSG("Unimplemented sample format={}", in_params.sample_format);
            }

-            temp_mix_offset += static_cast<size_t>(samples_decoded);
+            temp_mix_offset += samples_decoded;
            samples_read += samples_decoded;
            dsp_state.offset += samples_decoded;
            dsp_state.played_sample_count += samples_decoded;
@@ -966,12 +944,10 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
                } else {

                    // Update our wave buffer states
-                    dsp_state.is_wave_buffer_valid[static_cast<u32>(dsp_state.wave_buffer_index)] =
-                        false;
+                    dsp_state.is_wave_buffer_valid[dsp_state.wave_buffer_index] = false;
                    dsp_state.wave_buffer_consumed++;
                    dsp_state.wave_buffer_index =
-                        static_cast<u32>(dsp_state.wave_buffer_index + 1) %
-                        AudioCommon::MAX_WAVE_BUFFERS;
+                        (dsp_state.wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS;
                    if (wave_buffer.end_of_stream) {
                        dsp_state.played_sample_count = 0;
                    }
@@ -981,20 +957,16 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o

        if (in_params.behavior_flags.is_pitch_and_src_skipped.Value()) {
            // No need to resample
-            std::memcpy(output, sample_buffer.data(),
-                        static_cast<size_t>(samples_read) * sizeof(s32));
+            std::memcpy(output, sample_buffer.data(), samples_read * sizeof(s32));
        } else {
-            {
-                const auto begin = sample_buffer.begin() + static_cast<ptrdiff_t>(temp_mix_offset);
-                const auto end = begin + (samples_to_read - samples_read);
-                std::fill(begin, end, 0);
-            }
+            std::fill(sample_buffer.begin() + temp_mix_offset,
+                      sample_buffer.begin() + temp_mix_offset + (samples_to_read - samples_read),
+                      0);
            AudioCore::Resample(output, sample_buffer.data(), resample_rate, dsp_state.fraction,
-                                static_cast<size_t>(samples_to_output));
+                                samples_to_output);
            // Resample
            for (std::size_t i = 0; i < AudioCommon::MAX_SAMPLE_HISTORY; i++) {
-                dsp_state.sample_history[i] =
-                    sample_buffer[static_cast<size_t>(samples_to_read) + i];
+                dsp_state.sample_history[i] = sample_buffer[samples_to_read + i];
            }
        }
        output += samples_to_output;
@@ -50,12 +50,12 @@ public:
 private:
    void GenerateDataSourceCommand(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 channel);
    void GenerateBiquadFilterCommandForVoice(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                             u32 mix_buffer_count, s32 channel);
+                                             s32 mix_buffer_count, s32 channel);
    void GenerateVolumeRampCommand(float last_volume, float current_volume, s32 channel,
                                   s32 node_id);
    void GenerateVoiceMixCommand(const MixVolumeBuffer& mix_volumes,
                                 const MixVolumeBuffer& last_mix_volumes, VoiceState& dsp_state,
-                                 u32 mix_buffer_offset, u32 mix_buffer_count, u32 voice_index,
+                                 s32 mix_buffer_offset, s32 mix_buffer_count, s32 voice_index,
                                 s32 node_id);
    void GenerateSubMixCommand(ServerMixInfo& mix_info);
    void GenerateMixCommands(ServerMixInfo& mix_info);
@@ -202,7 +202,7 @@ long CubebSinkStream::DataCallback(cubeb_stream* stream, void* user_data, const
    }

    const std::size_t num_channels = impl->GetNumChannels();
-    const std::size_t samples_to_write = num_channels * static_cast<u64>(num_frames);
+    const std::size_t samples_to_write = num_channels * num_frames;
    std::size_t samples_written;

    /*
@@ -27,7 +27,7 @@ private:
    std::vector<SinkStreamPtr> sink_streams;

 #ifdef _WIN32
-    s32 com_init_result = 0;
+    u32 com_init_result = 0;
 #endif
 };

@@ -350,7 +350,7 @@ ResultCode InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buf
        std::size_t total_buffer_count{};
        for (std::size_t i = 0; i < mix_count; i++) {
            const auto& in = mix_in_params[i];
-            total_buffer_count += static_cast<size_t>(in.buffer_count);
+            total_buffer_count += in.buffer_count;
            if (static_cast<std::size_t>(in.dest_mix_id) > mix_count &&
                in.dest_mix_id != AudioCommon::NO_MIX && in.mix_id != AudioCommon::FINAL_MIX) {
                LOG_ERROR(
@@ -379,7 +379,7 @@ ResultCode InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buf
        const auto& mix_in = mix_in_params[i];
        std::size_t target_mix{};
        if (behavior_info.IsMixInParameterDirtyOnlyUpdateSupported()) {
-            target_mix = static_cast<size_t>(mix_in.mix_id);
+            target_mix = mix_in.mix_id;
        } else {
            // Non dirty supported games just use i instead of the actual mix_id
            target_mix = i;
@@ -62,7 +62,7 @@ void MixContext::UpdateDistancesFromFinalMix() {
                distance_to_final_mix = AudioCommon::NO_FINAL_MIX;
                break;
            } else {
-                const auto& dest_mix = GetInfo(static_cast<u32>(mix_id));
+                const auto& dest_mix = GetInfo(mix_id);
                const auto dest_mix_distance = dest_mix.GetInParams().final_mix_distance;

                if (dest_mix_distance == AudioCommon::NO_FINAL_MIX) {
@@ -129,7 +129,7 @@ bool MixContext::TsortInfo(SplitterContext& splitter_context) {
    std::size_t info_id{};
    for (auto itr = sorted_list.rbegin(); itr != sorted_list.rend(); ++itr) {
        // Set our sorted info
-        sorted_info[info_id++] = &GetInfo(static_cast<u32>(*itr));
+        sorted_info[info_id++] = &GetInfo(*itr);
    }

    // Calculate the mix buffer offset
@@ -218,8 +218,7 @@ bool ServerMixInfo::Update(EdgeMatrix& edge_matrix, const MixInfo::InParams& mix
    for (std::size_t i = 0; i < effect_count; i++) {
        auto* effect_info = effect_context.GetInfo(i);
        if (effect_info->GetMixID() == in_params.mix_id) {
-            const auto processing_order = static_cast<u32>(effect_info->GetProcessingOrder());
-            effect_processing_order[processing_order] = static_cast<s32>(i);
+            effect_processing_order[effect_info->GetProcessingOrder()] = static_cast<s32>(i);
        }
    }

@@ -266,7 +265,7 @@ bool ServerMixInfo::UpdateConnection(EdgeMatrix& edge_matrix, const MixInfo::InP
    if (in_params.dest_mix_id == mix_in.dest_mix_id &&
        in_params.splitter_id == mix_in.splitter_id &&
        ((in_params.splitter_id == AudioCommon::NO_SPLITTER) ||
-         !splitter_context.GetInfo(static_cast<u32>(in_params.splitter_id)).HasNewConnection())) {
+         !splitter_context.GetInfo(in_params.splitter_id).HasNewConnection())) {
        return false;
    }
    // Remove current edges for mix id
@@ -276,11 +275,11 @@ bool ServerMixInfo::UpdateConnection(EdgeMatrix& edge_matrix, const MixInfo::InP
        edge_matrix.Connect(in_params.mix_id, mix_in.dest_mix_id);
    } else if (mix_in.splitter_id != AudioCommon::NO_SPLITTER) {
        // Recurse our splitter linked and set our edges
-        auto& splitter_info = splitter_context.GetInfo(static_cast<u32>(mix_in.splitter_id));
-        const auto length = static_cast<size_t>(splitter_info.GetLength());
-        for (size_t i = 0; i < length; i++) {
+        auto& splitter_info = splitter_context.GetInfo(mix_in.splitter_id);
+        const auto length = splitter_info.GetLength();
+        for (s32 i = 0; i < length; i++) {
            const auto* splitter_destination =
-                splitter_context.GetDestinationData(static_cast<u32>(mix_in.splitter_id), i);
+                splitter_context.GetDestinationData(mix_in.splitter_id, i);
            if (splitter_destination == nullptr) {
                continue;
            }
@@ -23,9 +23,8 @@ bool SinkContext::InUse() const {
 }

 std::vector<u8> SinkContext::OutputBuffers() const {
-    const auto output_use_count = static_cast<size_t>(use_count);
-    std::vector<u8> buffer_ret(output_use_count);
-    std::memcpy(buffer_ret.data(), buffers.data(), output_use_count);
+    std::vector<u8> buffer_ret(use_count);
+    std::memcpy(buffer_ret.data(), buffers.data(), use_count);
    return buffer_ret;
 }

@@ -109,7 +109,7 @@ std::size_t ServerSplitterInfo::Update(SplitterInfo::InInfoPrams& header) {
    new_connection = true;
    // We need to update the size here due to the splitter bug being present and providing an
    // incorrect size. We're suppose to also update the header here but we just ignore and continue
-    return (sizeof(s32_le) * static_cast<size_t>(header.length - 1)) + (sizeof(s32_le) * 3);
+    return (sizeof(s32_le) * (header.length - 1)) + (sizeof(s32_le) * 3);
 }

 ServerSplitterDestinationData* ServerSplitterInfo::GetHead() {
@@ -306,14 +306,13 @@ bool SplitterContext::UpdateInfo(const std::vector<u8>& input, std::size_t& inpu
            break;
        }

-        const auto send_id = static_cast<std::size_t>(header.send_id);
-        if (header.send_id < 0 || send_id > info_count) {
+        if (header.send_id < 0 || static_cast<std::size_t>(header.send_id) > info_count) {
            LOG_ERROR(Audio, "Bad splitter data id");
            break;
        }

        UpdateOffsets(sizeof(SplitterInfo::InInfoPrams));
-        auto& info = GetInfo(send_id);
+        auto& info = GetInfo(header.send_id);
        if (!RecomposeDestination(info, header, input, input_offset)) {
            LOG_ERROR(Audio, "Failed to recompose destination for splitter!");
            return false;
@@ -349,12 +348,11 @@ bool SplitterContext::UpdateData(const std::vector<u8>& input, std::size_t& inpu
            break;
        }

-        const auto splitter_id = static_cast<std::size_t>(header.splitter_id);
-        if (header.splitter_id < 0 || splitter_id > data_count) {
+        if (header.splitter_id < 0 || static_cast<std::size_t>(header.splitter_id) > data_count) {
            LOG_ERROR(Audio, "Bad splitter data id");
            break;
        }
-        GetData(splitter_id).Update(header);
+        GetData(header.splitter_id).Update(header);
    }
    return true;
 }
@@ -388,9 +386,9 @@ bool SplitterContext::RecomposeDestination(ServerSplitterInfo& info,
        return true;
    }

-    auto* start_head = &GetData(static_cast<u32>(header.resource_id_base));
+    auto* start_head = &GetData(header.resource_id_base);
    current_head = start_head;
-    std::vector<s32_le> resource_ids(static_cast<size_t>(size - 1));
+    std::vector<s32_le> resource_ids(size - 1);
    if (!AudioCommon::CanConsumeBuffer(input.size(), input_offset,
                                       resource_ids.size() * sizeof(s32_le))) {
        LOG_ERROR(Audio, "Buffer is an invalid size!");
@@ -399,8 +397,8 @@ bool SplitterContext::RecomposeDestination(ServerSplitterInfo& info,
    std::memcpy(resource_ids.data(), input.data() + input_offset,
                resource_ids.size() * sizeof(s32_le));

-    for (const auto resource_id : resource_ids) {
-        auto* head = &GetData(static_cast<u32>(resource_id));
+    for (auto resource_id : resource_ids) {
+        auto* head = &GetData(resource_id);
        current_head->SetNextDestination(head);
        current_head = head;
    }
@@ -446,7 +444,7 @@ bool NodeStates::DepthFirstSearch(EdgeMatrix& edge_matrix) {
        const auto node_id = static_cast<s32>(i);

        // If we don't have a state, send to our index stack for work
-        if (GetState(i) == State::NoState) {
+        if (GetState(i) == NodeStates::State::NoState) {
            index_stack.push(node_id);
        }

@@ -455,19 +453,19 @@ bool NodeStates::DepthFirstSearch(EdgeMatrix& edge_matrix) {
            // Get the current node
            const auto current_stack_index = index_stack.top();
            // Check if we've seen the node yet
-            const auto index_state = GetState(static_cast<u32>(current_stack_index));
-            if (index_state == State::NoState) {
+            const auto index_state = GetState(current_stack_index);
+            if (index_state == NodeStates::State::NoState) {
                // Mark the node as seen
-                UpdateState(State::InFound, static_cast<u32>(current_stack_index));
-            } else if (index_state == State::InFound) {
+                UpdateState(NodeStates::State::InFound, current_stack_index);
+            } else if (index_state == NodeStates::State::InFound) {
                // We've seen this node before, mark it as completed
-                UpdateState(State::InCompleted, static_cast<u32>(current_stack_index));
+                UpdateState(NodeStates::State::InCompleted, current_stack_index);
                // Update our index list
                PushTsortResult(current_stack_index);
                // Pop the stack
                index_stack.pop();
                continue;
-            } else if (index_state == State::InCompleted) {
+            } else if (index_state == NodeStates::State::InCompleted) {
                // If our node is already sorted, clear it
                index_stack.pop();
                continue;
@@ -481,11 +479,11 @@ bool NodeStates::DepthFirstSearch(EdgeMatrix& edge_matrix) {
                }

                // Check if our node exists
-                const auto node_state = GetState(static_cast<u32>(j));
-                if (node_state == State::NoState) {
+                const auto node_state = GetState(j);
+                if (node_state == NodeStates::State::NoState) {
                    // Add more work
                    index_stack.push(j);
-                } else if (node_state == State::InFound) {
+                } else if (node_state == NodeStates::State::InFound) {
                    UNREACHABLE_MSG("Node start marked as found");
                    ResetState();
                    return false;
@@ -509,17 +507,17 @@ void NodeStates::ResetState() {
    }
 }

-void NodeStates::UpdateState(State state, std::size_t i) {
+void NodeStates::UpdateState(NodeStates::State state, std::size_t i) {
    switch (state) {
-    case State::NoState:
+    case NodeStates::State::NoState:
        was_node_found[i] = false;
        was_node_completed[i] = false;
        break;
-    case State::InFound:
+    case NodeStates::State::InFound:
        was_node_found[i] = true;
        was_node_completed[i] = false;
        break;
-    case State::InCompleted:
+    case NodeStates::State::InCompleted:
        was_node_found[i] = false;
        was_node_completed[i] = true;
        break;
@@ -530,13 +528,13 @@ NodeStates::State NodeStates::GetState(std::size_t i) {
    ASSERT(i < node_count);
    if (was_node_found[i]) {
        // If our node exists in our found list
-        return State::InFound;
+        return NodeStates::State::InFound;
    } else if (was_node_completed[i]) {
        // If node is in the completed list
-        return State::InCompleted;
+        return NodeStates::State::InCompleted;
    } else {
        // If in neither
-        return State::NoState;
+        return NodeStates::State::NoState;
    }
 }

@@ -603,16 +601,16 @@ std::size_t EdgeMatrix::GetNodeCount() const {

 void EdgeMatrix::SetState(s32 a, s32 b, bool state) {
    ASSERT(InRange(a, b));
-    edge_matrix.at(static_cast<u32>(a) * node_count + static_cast<u32>(b)) = state;
+    edge_matrix.at(a * node_count + b) = state;
 }

 bool EdgeMatrix::GetState(s32 a, s32 b) {
    ASSERT(InRange(a, b));
-    return edge_matrix.at(static_cast<u32>(a) * node_count + static_cast<u32>(b));
+    return edge_matrix.at(a * node_count + b);
 }

 bool EdgeMatrix::InRange(s32 a, s32 b) const {
-    const std::size_t pos = static_cast<u32>(a) * node_count + static_cast<u32>(b);
+    const std::size_t pos = a * node_count + b;
    return pos < (node_count * node_count);
 }

@@ -5,16 +5,8 @@
 #pragma once

 #include <cstddef>
-#include "common/common_types.h"
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wsign-conversion"
-#endif
 #include <SoundTouch.h>
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
+#include "common/common_types.h"

 namespace AudioCore {

@@ -98,7 +98,7 @@ void ServerVoiceInfo::UpdateParameters(const VoiceInfo::InParams& voice_in,
                                       BehaviorInfo& behavior_info) {
    in_params.in_use = voice_in.is_in_use;
    in_params.id = voice_in.id;
-    in_params.node_id = static_cast<s32>(voice_in.node_id);
+    in_params.node_id = voice_in.node_id;
    in_params.last_playstate = in_params.current_playstate;
    switch (voice_in.play_state) {
    case PlayState::Paused:
@@ -220,10 +220,8 @@ void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
        if (sample_format == SampleFormat::Pcm16) {
            const auto buffer_size = in_wave_buffer.buffer_size;
            if (in_wave_buffer.start_sample_offset < 0 || in_wave_buffer.end_sample_offset < 0 ||
-                (buffer_size <
-                 (sizeof(s16) * static_cast<u32>(in_wave_buffer.start_sample_offset))) ||
-                (buffer_size <
-                 (sizeof(s16) * static_cast<u32>(in_wave_buffer.end_sample_offset)))) {
+                (buffer_size < (sizeof(s16) * in_wave_buffer.start_sample_offset)) ||
+                (buffer_size < (sizeof(s16) * in_wave_buffer.end_sample_offset))) {
                // TODO(ogniK): Write error info
                return;
            }
@@ -256,8 +254,8 @@ void ServerVoiceInfo::WriteOutStatus(
        voice_out.played_sample_count = 0;
        voice_out.voice_dropped = false;
    } else if (!in_params.is_new) {
-        voice_out.wave_buffer_consumed = static_cast<u32>(voice_states[0]->wave_buffer_consumed);
-        voice_out.played_sample_count = static_cast<u64>(voice_states[0]->played_sample_count);
+        voice_out.wave_buffer_consumed = voice_states[0]->wave_buffer_consumed;
+        voice_out.played_sample_count = voice_states[0]->played_sample_count;
        voice_out.voice_dropped = in_params.voice_drop_flag;
    } else {
        voice_out.wave_buffer_consumed = 0;
@@ -295,8 +293,8 @@ bool ServerVoiceInfo::UpdateForCommandGeneration(VoiceContext& voice_context) {
        in_params.is_new = false;
    }

-    const auto channel_count = static_cast<size_t>(in_params.channel_count);
-    for (size_t i = 0; i < channel_count; i++) {
+    const s32 channel_count = in_params.channel_count;
+    for (s32 i = 0; i < channel_count; i++) {
        const auto channel_resource = in_params.voice_channel_resource_id[i];
        dsp_voice_states[i] =
            &voice_context.GetDspSharedState(static_cast<std::size_t>(channel_resource));
@@ -305,9 +303,8 @@ bool ServerVoiceInfo::UpdateForCommandGeneration(VoiceContext& voice_context) {
 }

 void ServerVoiceInfo::ResetResources(VoiceContext& voice_context) {
-    const auto channel_count = static_cast<size_t>(in_params.channel_count);
-
-    for (size_t i = 0; i < channel_count; i++) {
+    const s32 channel_count = in_params.channel_count;
+    for (s32 i = 0; i < channel_count; i++) {
        const auto channel_resource = in_params.voice_channel_resource_id[i];
        auto& dsp_state =
            voice_context.GetDspSharedState(static_cast<std::size_t>(channel_resource));
@@ -328,9 +325,9 @@ bool ServerVoiceInfo::UpdateParametersForCommandGeneration(

    switch (in_params.current_playstate) {
    case ServerPlayState::Play: {
-        for (size_t i = 0; i < AudioCommon::MAX_WAVE_BUFFERS; i++) {
+        for (std::size_t i = 0; i < AudioCommon::MAX_WAVE_BUFFERS; i++) {
            if (!in_params.wave_buffer[i].sent_to_dsp) {
-                for (size_t channel = 0; channel < static_cast<size_t>(channel_count); channel++) {
+                for (s32 channel = 0; channel < channel_count; channel++) {
                    dsp_voice_states[channel]->is_wave_buffer_valid[i] = true;
                }
                in_params.wave_buffer[i].sent_to_dsp = true;
@@ -347,13 +344,12 @@ bool ServerVoiceInfo::UpdateParametersForCommandGeneration(
    case ServerPlayState::RequestStop: {
        for (std::size_t i = 0; i < AudioCommon::MAX_WAVE_BUFFERS; i++) {
            in_params.wave_buffer[i].sent_to_dsp = true;
-            for (std::size_t channel = 0; channel < static_cast<size_t>(channel_count); channel++) {
+            for (s32 channel = 0; channel < channel_count; channel++) {
                auto* dsp_state = dsp_voice_states[channel];

                if (dsp_state->is_wave_buffer_valid[i]) {
                    dsp_state->wave_buffer_index =
-                        static_cast<s32>(static_cast<u32>(dsp_state->wave_buffer_index + 1) %
-                                         AudioCommon::MAX_WAVE_BUFFERS);
+                        (dsp_state->wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS;
                    dsp_state->wave_buffer_consumed++;
                }

@@ -361,7 +357,7 @@ bool ServerVoiceInfo::UpdateParametersForCommandGeneration(
            }
        }

-        for (size_t channel = 0; channel < static_cast<size_t>(channel_count); channel++) {
+        for (s32 channel = 0; channel < channel_count; channel++) {
            auto* dsp_state = dsp_voice_states[channel];
            dsp_state->offset = 0;
            dsp_state->played_sample_count = 0;
@@ -387,16 +383,15 @@ void ServerVoiceInfo::FlushWaveBuffers(
    auto wave_head = in_params.wave_bufffer_head;

    for (u8 i = 0; i < flush_count; i++) {
-        in_params.wave_buffer[static_cast<u16>(wave_head)].sent_to_dsp = true;
-        for (size_t channel = 0; channel < static_cast<size_t>(channel_count); channel++) {
+        in_params.wave_buffer[wave_head].sent_to_dsp = true;
+        for (s32 channel = 0; channel < channel_count; channel++) {
            auto* dsp_state = dsp_voice_states[channel];
            dsp_state->wave_buffer_consumed++;
-            dsp_state->is_wave_buffer_valid[static_cast<u16>(wave_head)] = false;
-            dsp_state->wave_buffer_index = static_cast<s32>(
-                static_cast<u32>(dsp_state->wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS);
+            dsp_state->is_wave_buffer_valid[wave_head] = false;
+            dsp_state->wave_buffer_index =
+                (dsp_state->wave_buffer_index + 1) % AudioCommon::MAX_WAVE_BUFFERS;
        }
-        wave_head =
-            static_cast<s16>(static_cast<u32>(wave_head + 1) % AudioCommon::MAX_WAVE_BUFFERS);
+        wave_head = (wave_head + 1) % AudioCommon::MAX_WAVE_BUFFERS;
    }
 }

@@ -488,7 +483,7 @@ s32 VoiceContext::DecodePcm16(s32* output_buffer, ServerWaveBuffer* wave_buffer,
    const auto samples_remaining =
        (wave_buffer->end_sample_offset - wave_buffer->start_sample_offset) - buffer_offset;
    const auto start_offset = (wave_buffer->start_sample_offset + buffer_offset) * channel_count;
-    const auto buffer_pos = wave_buffer->buffer_address + static_cast<VAddr>(start_offset);
+    const auto buffer_pos = wave_buffer->buffer_address + start_offset;

    s16* buffer_data = reinterpret_cast<s16*>(memory.GetPointer(buffer_pos));

@@ -102,6 +102,7 @@ add_library(common STATIC
    atomic_ops.h
    detached_tasks.cpp
    detached_tasks.h
+    bit_cast.h
    bit_field.h
    bit_util.h
    cityhash.cpp
@@ -150,6 +151,8 @@ add_library(common STATIC
    scope_exit.h
    spin_lock.cpp
    spin_lock.h
+    stream.cpp
+    stream.h
    string_util.cpp
    string_util.h
    swap.h
@@ -188,6 +191,22 @@ if(ARCHITECTURE_x86_64)
    )
 endif()

+if (MSVC)
+  target_compile_definitions(common PRIVATE
+    # The standard library doesn't provide any replacement for codecvt yet
+    # so we can disable this deprecation warning for the time being.
+    _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING
+  )
+  target_compile_options(common PRIVATE
+    /W4
+    /WX
+  )
+else()
+  target_compile_options(common PRIVATE
+    -Werror
+  )
+endif()
+
 create_target_directory_groups(common)
 find_package(Boost 1.71 COMPONENTS context headers REQUIRED)

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

 #include "common/assert.h"
 #include "common/fiber.h"
+#include "common/spin_lock.h"
+
 #if defined(_WIN32) || defined(WIN32)
 #include <windows.h>
 #else
@@ -14,18 +16,45 @@ namespace Common {

 constexpr std::size_t default_stack_size = 256 * 1024; // 256kb

-#if defined(_WIN32) || defined(WIN32)
-
 struct Fiber::FiberImpl {
+    SpinLock guard{};
+    std::function<void(void*)> entry_point;
+    std::function<void(void*)> rewind_point;
+    void* rewind_parameter{};
+    void* start_parameter{};
+    std::shared_ptr<Fiber> previous_fiber;
+    bool is_thread_fiber{};
+    bool released{};
+
+#if defined(_WIN32) || defined(WIN32)
    LPVOID handle = nullptr;
    LPVOID rewind_handle = nullptr;
+#else
+    alignas(64) std::array<u8, default_stack_size> stack;
+    alignas(64) std::array<u8, default_stack_size> rewind_stack;
+    u8* stack_limit;
+    u8* rewind_stack_limit;
+    boost::context::detail::fcontext_t context;
+    boost::context::detail::fcontext_t rewind_context;
+#endif
 };

+void Fiber::SetStartParameter(void* new_parameter) {
+    impl->start_parameter = new_parameter;
+}
+
+void Fiber::SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param) {
+    impl->rewind_point = std::move(rewind_func);
+    impl->rewind_parameter = rewind_param;
+}
+
+#if defined(_WIN32) || defined(WIN32)
+
 void Fiber::Start() {
-    ASSERT(previous_fiber != nullptr);
-    previous_fiber->guard.unlock();
-    previous_fiber.reset();
-    entry_point(start_parameter);
+    ASSERT(impl->previous_fiber != nullptr);
+    impl->previous_fiber->impl->guard.unlock();
+    impl->previous_fiber.reset();
+    impl->entry_point(impl->start_parameter);
    UNREACHABLE();
 }

@@ -34,99 +63,86 @@ void Fiber::OnRewind() {
    DeleteFiber(impl->handle);
    impl->handle = impl->rewind_handle;
    impl->rewind_handle = nullptr;
-    rewind_point(rewind_parameter);
+    impl->rewind_point(impl->rewind_parameter);
    UNREACHABLE();
 }

 void Fiber::FiberStartFunc(void* fiber_parameter) {
-    auto fiber = static_cast<Fiber*>(fiber_parameter);
+    auto* fiber = static_cast<Fiber*>(fiber_parameter);
    fiber->Start();
 }

 void Fiber::RewindStartFunc(void* fiber_parameter) {
-    auto fiber = static_cast<Fiber*>(fiber_parameter);
+    auto* fiber = static_cast<Fiber*>(fiber_parameter);
    fiber->OnRewind();
 }

 Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter)
-    : entry_point{std::move(entry_point_func)}, start_parameter{start_parameter} {
-    impl = std::make_unique<FiberImpl>();
+    : impl{std::make_unique<FiberImpl>()} {
+    impl->entry_point = std::move(entry_point_func);
+    impl->start_parameter = start_parameter;
    impl->handle = CreateFiber(default_stack_size, &FiberStartFunc, this);
 }

 Fiber::Fiber() : impl{std::make_unique<FiberImpl>()} {}

 Fiber::~Fiber() {
-    if (released) {
+    if (impl->released) {
        return;
    }
    // Make sure the Fiber is not being used
-    const bool locked = guard.try_lock();
+    const bool locked = impl->guard.try_lock();
    ASSERT_MSG(locked, "Destroying a fiber that's still running");
    if (locked) {
-        guard.unlock();
+        impl->guard.unlock();
    }
    DeleteFiber(impl->handle);
 }

 void Fiber::Exit() {
-    ASSERT_MSG(is_thread_fiber, "Exitting non main thread fiber");
-    if (!is_thread_fiber) {
+    ASSERT_MSG(impl->is_thread_fiber, "Exitting non main thread fiber");
+    if (!impl->is_thread_fiber) {
        return;
    }
    ConvertFiberToThread();
-    guard.unlock();
-    released = true;
-}
-
-void Fiber::SetRewindPoint(std::function<void(void*)>&& rewind_func, void* start_parameter) {
-    rewind_point = std::move(rewind_func);
-    rewind_parameter = start_parameter;
+    impl->guard.unlock();
+    impl->released = true;
 }

 void Fiber::Rewind() {
-    ASSERT(rewind_point);
+    ASSERT(impl->rewind_point);
    ASSERT(impl->rewind_handle == nullptr);
    impl->rewind_handle = CreateFiber(default_stack_size, &RewindStartFunc, this);
    SwitchToFiber(impl->rewind_handle);
 }

-void Fiber::YieldTo(std::shared_ptr<Fiber>& from, std::shared_ptr<Fiber>& to) {
+void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) {
    ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
    ASSERT_MSG(to != nullptr, "Next fiber is null!");
-    to->guard.lock();
-    to->previous_fiber = from;
+    to->impl->guard.lock();
+    to->impl->previous_fiber = from;
    SwitchToFiber(to->impl->handle);
-    ASSERT(from->previous_fiber != nullptr);
-    from->previous_fiber->guard.unlock();
-    from->previous_fiber.reset();
+    ASSERT(from->impl->previous_fiber != nullptr);
+    from->impl->previous_fiber->impl->guard.unlock();
+    from->impl->previous_fiber.reset();
 }

 std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
    std::shared_ptr<Fiber> fiber = std::shared_ptr<Fiber>{new Fiber()};
-    fiber->guard.lock();
+    fiber->impl->guard.lock();
    fiber->impl->handle = ConvertThreadToFiber(nullptr);
-    fiber->is_thread_fiber = true;
+    fiber->impl->is_thread_fiber = true;
    return fiber;
 }

 #else

-struct Fiber::FiberImpl {
-    alignas(64) std::array<u8, default_stack_size> stack;
-    alignas(64) std::array<u8, default_stack_size> rewind_stack;
-    u8* stack_limit;
-    u8* rewind_stack_limit;
-    boost::context::detail::fcontext_t context;
-    boost::context::detail::fcontext_t rewind_context;
-};
-
 void Fiber::Start(boost::context::detail::transfer_t& transfer) {
-    ASSERT(previous_fiber != nullptr);
-    previous_fiber->impl->context = transfer.fctx;
-    previous_fiber->guard.unlock();
-    previous_fiber.reset();
-    entry_point(start_parameter);
+    ASSERT(impl->previous_fiber != nullptr);
+    impl->previous_fiber->impl->context = transfer.fctx;
+    impl->previous_fiber->impl->guard.unlock();
+    impl->previous_fiber.reset();
+    impl->entry_point(impl->start_parameter);
    UNREACHABLE();
 }

@@ -137,23 +153,24 @@ void Fiber::OnRewind([[maybe_unused]] boost::context::detail::transfer_t& transf
    u8* tmp = impl->stack_limit;
    impl->stack_limit = impl->rewind_stack_limit;
    impl->rewind_stack_limit = tmp;
-    rewind_point(rewind_parameter);
+    impl->rewind_point(impl->rewind_parameter);
    UNREACHABLE();
 }

 void Fiber::FiberStartFunc(boost::context::detail::transfer_t transfer) {
-    auto fiber = static_cast<Fiber*>(transfer.data);
+    auto* fiber = static_cast<Fiber*>(transfer.data);
    fiber->Start(transfer);
 }

 void Fiber::RewindStartFunc(boost::context::detail::transfer_t transfer) {
-    auto fiber = static_cast<Fiber*>(transfer.data);
+    auto* fiber = static_cast<Fiber*>(transfer.data);
    fiber->OnRewind(transfer);
 }

 Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter)
-    : entry_point{std::move(entry_point_func)}, start_parameter{start_parameter} {
-    impl = std::make_unique<FiberImpl>();
+    : impl{std::make_unique<FiberImpl>()} {
+    impl->entry_point = std::move(entry_point_func);
+    impl->start_parameter = start_parameter;
    impl->stack_limit = impl->stack.data();
    impl->rewind_stack_limit = impl->rewind_stack.data();
    u8* stack_base = impl->stack_limit + default_stack_size;
@@ -161,37 +178,31 @@ Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_paramete
        boost::context::detail::make_fcontext(stack_base, impl->stack.size(), FiberStartFunc);
 }

-void Fiber::SetRewindPoint(std::function<void(void*)>&& rewind_func, void* start_parameter) {
-    rewind_point = std::move(rewind_func);
-    rewind_parameter = start_parameter;
-}
-
 Fiber::Fiber() : impl{std::make_unique<FiberImpl>()} {}

 Fiber::~Fiber() {
-    if (released) {
+    if (impl->released) {
        return;
    }
    // Make sure the Fiber is not being used
-    const bool locked = guard.try_lock();
+    const bool locked = impl->guard.try_lock();
    ASSERT_MSG(locked, "Destroying a fiber that's still running");
    if (locked) {
-        guard.unlock();
+        impl->guard.unlock();
    }
 }

 void Fiber::Exit() {
-
-    ASSERT_MSG(is_thread_fiber, "Exitting non main thread fiber");
-    if (!is_thread_fiber) {
+    ASSERT_MSG(impl->is_thread_fiber, "Exitting non main thread fiber");
+    if (!impl->is_thread_fiber) {
        return;
    }
-    guard.unlock();
-    released = true;
+    impl->guard.unlock();
+    impl->released = true;
 }

 void Fiber::Rewind() {
-    ASSERT(rewind_point);
+    ASSERT(impl->rewind_point);
    ASSERT(impl->rewind_context == nullptr);
    u8* stack_base = impl->rewind_stack_limit + default_stack_size;
    impl->rewind_context =
@@ -199,22 +210,22 @@ void Fiber::Rewind() {
    boost::context::detail::jump_fcontext(impl->rewind_context, this);
 }

-void Fiber::YieldTo(std::shared_ptr<Fiber>& from, std::shared_ptr<Fiber>& to) {
+void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) {
    ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
    ASSERT_MSG(to != nullptr, "Next fiber is null!");
-    to->guard.lock();
-    to->previous_fiber = from;
+    to->impl->guard.lock();
+    to->impl->previous_fiber = from;
    auto transfer = boost::context::detail::jump_fcontext(to->impl->context, to.get());
-    ASSERT(from->previous_fiber != nullptr);
-    from->previous_fiber->impl->context = transfer.fctx;
-    from->previous_fiber->guard.unlock();
-    from->previous_fiber.reset();
+    ASSERT(from->impl->previous_fiber != nullptr);
+    from->impl->previous_fiber->impl->context = transfer.fctx;
+    from->impl->previous_fiber->impl->guard.unlock();
+    from->impl->previous_fiber.reset();
 }

 std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
    std::shared_ptr<Fiber> fiber = std::shared_ptr<Fiber>{new Fiber()};
-    fiber->guard.lock();
-    fiber->is_thread_fiber = true;
+    fiber->impl->guard.lock();
+    fiber->impl->is_thread_fiber = true;
    return fiber;
 }

@@ -7,9 +7,6 @@
 #include <functional>
 #include <memory>

-#include "common/common_types.h"
-#include "common/spin_lock.h"
-
 #if !defined(_WIN32) && !defined(WIN32)
 namespace boost::context::detail {
 struct transfer_t;
@@ -41,15 +38,15 @@ public:
    Fiber(const Fiber&) = delete;
    Fiber& operator=(const Fiber&) = delete;

-    Fiber(Fiber&&) = delete;
-    Fiber& operator=(Fiber&&) = delete;
+    Fiber(Fiber&&) = default;
+    Fiber& operator=(Fiber&&) = default;

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

-    void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* start_parameter);
+    void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param);

    void Rewind();

@@ -57,9 +54,7 @@ public:
    void Exit();

    /// Changes the start parameter of the fiber. Has no effect if the fiber already started
-    void SetStartParameter(void* new_parameter) {
-        start_parameter = new_parameter;
-    }
+    void SetStartParameter(void* new_parameter);

 private:
    Fiber();
@@ -77,16 +72,7 @@ private:
 #endif

    struct FiberImpl;
-
-    SpinLock guard{};
-    std::function<void(void*)> entry_point;
-    std::function<void(void*)> rewind_point;
-    void* rewind_parameter{};
-    void* start_parameter{};
-    std::shared_ptr<Fiber> previous_fiber;
    std::unique_ptr<FiberImpl> impl;
-    bool is_thread_fiber{};
-    bool released{};
 };

 } // namespace Common
@@ -472,13 +472,14 @@ u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
 }

 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion) {
-    const auto callback = [recursion](u64* num_entries_out, const std::string& directory,
-                                      const std::string& virtual_name) -> bool {
-        std::string new_path = directory + DIR_SEP_CHR + virtual_name;
+    const auto callback = [recursion](u64*, const std::string& directory,
+                                      const std::string& virtual_name) {
+        const std::string new_path = directory + DIR_SEP_CHR + virtual_name;

        if (IsDirectory(new_path)) {
-            if (recursion == 0)
+            if (recursion == 0) {
                return false;
+            }
            return DeleteDirRecursively(new_path, recursion - 1);
        }
        return Delete(new_path);
@@ -492,7 +493,8 @@ bool DeleteDirRecursively(const std::string& directory, unsigned int recursion)
    return true;
 }

-void CopyDir(const std::string& source_path, const std::string& dest_path) {
+void CopyDir([[maybe_unused]] const std::string& source_path,
+             [[maybe_unused]] const std::string& dest_path) {
 #ifndef _WIN32
    if (source_path == dest_path) {
        return;
@@ -553,7 +555,7 @@ std::optional<std::string> GetCurrentDir() {
    std::string strDir = dir;
 #endif
    free(dir);
-    return std::move(strDir);
+    return strDir;
 }

 bool SetCurrentDir(const std::string& directory) {
@@ -772,21 +774,23 @@ std::size_t ReadFileToString(bool text_file, const std::string& filename, std::s

 void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
                     std::array<char, 4>& extension) {
-    const std::string forbidden_characters = ".\"/\\[]:;=, ";
+    static constexpr std::string_view forbidden_characters = ".\"/\\[]:;=, ";

    // On a FAT32 partition, 8.3 names are stored as a 11 bytes array, filled with spaces.
    short_name = {{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0'}};
    extension = {{' ', ' ', ' ', '\0'}};

-    std::string::size_type point = filename.rfind('.');
-    if (point == filename.size() - 1)
+    auto point = filename.rfind('.');
+    if (point == filename.size() - 1) {
        point = filename.rfind('.', point);
+    }

    // Get short name.
    int j = 0;
    for (char letter : filename.substr(0, point)) {
-        if (forbidden_characters.find(letter, 0) != std::string::npos)
+        if (forbidden_characters.find(letter, 0) != std::string::npos) {
            continue;
+        }
        if (j == 8) {
            // TODO(Link Mauve): also do that for filenames containing a space.
            // TODO(Link Mauve): handle multiple files having the same short name.
@@ -794,14 +798,15 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
            short_name[7] = '1';
            break;
        }
-        short_name[j++] = toupper(letter);
+        short_name[j++] = static_cast<char>(std::toupper(letter));
    }

    // Get extension.
    if (point != std::string::npos) {
        j = 0;
-        for (char letter : filename.substr(point + 1, 3))
-            extension[j++] = toupper(letter);
+        for (char letter : filename.substr(point + 1, 3)) {
+            extension[j++] = static_cast<char>(std::toupper(letter));
+        }
    }
 }

@@ -189,8 +189,7 @@ template <typename T>
        return {};
    }
    last = std::min<std::size_t>(last, vector.size());
-    return std::vector<T>(vector.begin() + static_cast<std::ptrdiff_t>(first),
-                          vector.begin() + static_cast<std::ptrdiff_t>(first + last));
+    return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
 }

 enum class DirectorySeparator {
@@ -233,7 +232,7 @@ public:

    void Swap(IOFile& other) noexcept;

-    [[nodiscard]] bool Open(const std::string& filename, const char openmode[], int flags = 0);
+    bool Open(const std::string& filename, const char openmode[], int flags = 0);
    bool Close();

    template <typename T>
@@ -222,6 +222,7 @@ void DebuggerBackend::Write(const Entry& entry) {
    SUB(Service, NPNS)                                                                             \
    SUB(Service, NS)                                                                               \
    SUB(Service, NVDRV)                                                                            \
+    SUB(Service, OLSC)                                                                             \
    SUB(Service, PCIE)                                                                             \
    SUB(Service, PCTL)                                                                             \
    SUB(Service, PCV)                                                                              \
@@ -274,7 +275,6 @@ const char* GetLogClassName(Class log_class) {
    case Class::Count:
        break;
    }
-    UNREACHABLE();
    return "Invalid";
 }

@@ -293,7 +293,6 @@ const char* GetLevelName(Level log_level) {
        break;
    }
 #undef LVL
-    UNREACHABLE();
    return "Invalid";
 }

@@ -95,6 +95,7 @@ enum class Class : ClassType {
    Service_NPNS,      ///< The NPNS service
    Service_NS,        ///< The NS services
    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
+    Service_OLSC,      ///< The OLSC service
    Service_PCIE,      ///< The PCIe service
    Service_PCTL,      ///< The PCTL (Parental control) service
    Service_PCV,       ///< The PCV service
@@ -16,16 +16,23 @@
 // Call directly after the command or use the error num.
 // This function might change the error code.
 std::string GetLastErrorMsg() {
-    static const std::size_t buff_size = 255;
+    static constexpr std::size_t buff_size = 255;
    char err_str[buff_size];

 #ifdef _WIN32
    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(),
                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err_str, buff_size, nullptr);
+    return std::string(err_str, buff_size);
+#elif defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))
+    // Thread safe (GNU-specific)
+    const char* str = strerror_r(errno, err_str, buff_size);
+    return std::string(str);
 #else
    // Thread safe (XSI-compliant)
-    strerror_r(errno, err_str, buff_size);
+    const int success = strerror_r(errno, err_str, buff_size);
+    if (success != 0) {
+        return {};
+    }
+    return std::string(err_str);
 #endif
-
-    return std::string(err_str, buff_size);
 }
@@ -320,7 +320,7 @@ private:
        }

        const auto begin_range = list.begin();
-        const auto end_range = std::next(begin_range, static_cast<std::ptrdiff_t>(shift));
+        const auto end_range = std::next(begin_range, shift);
        list.splice(list.end(), list, begin_range, end_range);
    }

@@ -8,7 +8,7 @@ namespace Common {

 PageTable::PageTable() = default;

-PageTable::~PageTable() = default;
+PageTable::~PageTable() noexcept = default;

 void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
                       bool has_attribute) {
@@ -4,9 +4,7 @@

 #pragma once

-#include <vector>
-
-#include <boost/icl/interval_map.hpp>
+#include <tuple>

 #include "common/common_types.h"
 #include "common/memory_hook.h"
@@ -51,13 +49,21 @@ struct SpecialRegion {
 */
 struct PageTable {
    PageTable();
-    ~PageTable();
+    ~PageTable() noexcept;
+
+    PageTable(const PageTable&) = delete;
+    PageTable& operator=(const PageTable&) = delete;
+
+    PageTable(PageTable&&) noexcept = default;
+    PageTable& operator=(PageTable&&) noexcept = default;

    /**
     * Resizes the page table to be able to accomodate enough pages within
     * a given address space.
     *
     * @param address_space_width_in_bits The address size width in bits.
+     * @param page_size_in_bits           The page size in bits.
+     * @param has_attribute               Whether or not this page has any backing attributes.
     */
    void Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
                bool has_attribute);
@@ -0,0 +1,47 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <stdexcept>
+#include "common/common_types.h"
+#include "common/stream.h"
+
+namespace Common {
+
+Stream::Stream() = default;
+Stream::~Stream() = default;
+
+void Stream::Seek(s32 offset, SeekOrigin origin) {
+    if (origin == SeekOrigin::SetOrigin) {
+        if (offset < 0) {
+            position = 0;
+        } else if (position >= buffer.size()) {
+            position = buffer.size();
+        } else {
+            position = offset;
+        }
+    } else if (origin == SeekOrigin::FromCurrentPos) {
+        Seek(static_cast<s32>(position) + offset, SeekOrigin::SetOrigin);
+    } else if (origin == SeekOrigin::FromEnd) {
+        Seek(static_cast<s32>(buffer.size()) - offset, SeekOrigin::SetOrigin);
+    }
+}
+
+u8 Stream::ReadByte() {
+    if (position < buffer.size()) {
+        return buffer[position++];
+    } else {
+        throw std::out_of_range("Attempting to read a byte not within the buffer range");
+    }
+}
+
+void Stream::WriteByte(u8 byte) {
+    if (position == buffer.size()) {
+        buffer.push_back(byte);
+        position++;
+    } else {
+        buffer.insert(buffer.begin() + position, byte);
+    }
+}
+
+} // namespace Common
@@ -0,0 +1,56 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+#include "common/common_types.h"
+
+namespace Common {
+
+enum class SeekOrigin {
+    SetOrigin,
+    FromCurrentPos,
+    FromEnd,
+};
+
+class Stream {
+public:
+    /// Stream creates a bitstream and provides common functionality on the stream.
+    explicit Stream();
+    ~Stream();
+
+    Stream(const Stream&) = delete;
+    Stream& operator=(const Stream&) = delete;
+
+    Stream(Stream&&) = default;
+    Stream& operator=(Stream&&) = default;
+
+    /// Reposition bitstream "cursor" to the specified offset from origin
+    void Seek(s32 offset, SeekOrigin origin);
+
+    /// Reads next byte in the stream buffer and increments position
+    u8 ReadByte();
+
+    /// Writes byte at current position
+    void WriteByte(u8 byte);
+
+    [[nodiscard]] std::size_t GetPosition() const {
+        return position;
+    }
+
+    [[nodiscard]] std::vector<u8>& GetBuffer() {
+        return buffer;
+    }
+
+    [[nodiscard]] const std::vector<u8>& GetBuffer() const {
+        return buffer;
+    }
+
+private:
+    std::vector<u8> buffer;
+    std::size_t position{0};
+};
+
+} // namespace Common
@@ -8,6 +8,7 @@
 #include <cstdlib>
 #include <locale>
 #include <sstream>
+
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
@@ -21,14 +22,14 @@ namespace Common {
 /// Make a string lowercase
 std::string ToLower(std::string str) {
    std::transform(str.begin(), str.end(), str.begin(),
-                   [](unsigned char c) { return std::tolower(c); });
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
    return str;
 }

 /// Make a string uppercase
 std::string ToUpper(std::string str) {
    std::transform(str.begin(), str.end(), str.begin(),
-                   [](unsigned char c) { return std::toupper(c); });
+                   [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
    return str;
 }

@@ -504,35 +504,35 @@ bool operator==(const S& p, const swap_struct_t<T, F> v) {
 template <typename T>
 struct swap_64_t {
    static T swap(T x) {
-        return static_cast<T>(Common::swap64(static_cast<u64>(x)));
+        return static_cast<T>(Common::swap64(x));
    }
 };

 template <typename T>
 struct swap_32_t {
    static T swap(T x) {
-        return static_cast<T>(Common::swap32(static_cast<u32>(x)));
+        return static_cast<T>(Common::swap32(x));
    }
 };

 template <typename T>
 struct swap_16_t {
    static T swap(T x) {
-        return static_cast<T>(Common::swap16(static_cast<u16>(x)));
+        return static_cast<T>(Common::swap16(x));
    }
 };

 template <typename T>
 struct swap_float_t {
    static T swap(T x) {
-        return static_cast<T>(Common::swapf(static_cast<float>(x)));
+        return static_cast<T>(Common::swapf(x));
    }
 };

 template <typename T>
 struct swap_double_t {
    static T swap(T x) {
-        return static_cast<T>(Common::swapd(static_cast<double>(x)));
+        return static_cast<T>(Common::swapd(x));
    }
 };

@@ -33,7 +33,7 @@ struct ThreadQueueList {
            }
        }

-        return static_cast<Priority>(-1);
+        return -1;
    }

    [[nodiscard]] T get_first() const {
@@ -156,7 +156,7 @@ private:
    void link(Priority priority) {
        Queue* cur = &queues[priority];

-        for (auto i = static_cast<int>(priority - 1); i >= 0; --i) {
+        for (int i = priority - 1; i >= 0; --i) {
            if (queues[i].next_nonempty != UnlinkedTag()) {
                cur->next_nonempty = queues[i].next_nonempty;
                queues[i].next_nonempty = cur;
@@ -142,20 +142,18 @@ std::string Timer::GetTimeFormatted() {
 // ----------------
 double Timer::GetDoubleTime() {
    // Get continuous timestamp
-    u64 TmpSeconds = static_cast<u64>(Common::Timer::GetTimeSinceJan1970().count());
-    double ms = static_cast<u64>(GetTimeMs().count()) % 1000;
+    auto tmp_seconds = static_cast<u64>(GetTimeSinceJan1970().count());
+    const auto ms = static_cast<double>(static_cast<u64>(GetTimeMs().count()) % 1000);

    // Remove a few years. We only really want enough seconds to make
    // sure that we are detecting actual actions, perhaps 60 seconds is
    // enough really, but I leave a year of seconds anyway, in case the
    // user's clock is incorrect or something like that.
-    TmpSeconds = TmpSeconds - (38 * 365 * 24 * 60 * 60);
+    tmp_seconds = tmp_seconds - (38 * 365 * 24 * 60 * 60);

    // Make a smaller integer that fits in the double
-    u32 Seconds = static_cast<u32>(TmpSeconds);
-    double TmpTime = Seconds + ms;
-
-    return TmpTime;
+    const auto seconds = static_cast<u32>(tmp_seconds);
+    return seconds + ms;
 }

 } // Namespace Common
@@ -13,7 +13,7 @@

 namespace Common {

-void* AllocateMemoryPages(std::size_t size) {
+void* AllocateMemoryPages(std::size_t size) noexcept {
 #ifdef _WIN32
    void* base{VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE)};
 #else
@@ -29,7 +29,7 @@ void* AllocateMemoryPages(std::size_t size) {
    return base;
 }

-void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) {
+void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
    if (!base) {
        return;
    }
@@ -4,29 +4,53 @@

 #pragma once

-#include "common/common_funcs.h"
+#include <type_traits>
+#include <utility>

 namespace Common {

-void* AllocateMemoryPages(std::size_t size);
-void FreeMemoryPages(void* base, std::size_t size);
+void* AllocateMemoryPages(std::size_t size) noexcept;
+void FreeMemoryPages(void* base, std::size_t size) noexcept;

 template <typename T>
-class VirtualBuffer final : NonCopyable {
+class VirtualBuffer final {
 public:
+    static_assert(
+        std::is_trivially_constructible_v<T>,
+        "T must be trivially constructible, as non-trivial constructors will not be executed "
+        "with the current allocator");
+
    constexpr VirtualBuffer() = default;
    explicit VirtualBuffer(std::size_t count) : alloc_size{count * sizeof(T)} {
        base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
    }

-    ~VirtualBuffer() {
+    ~VirtualBuffer() noexcept {
        FreeMemoryPages(base_ptr, alloc_size);
    }

+    VirtualBuffer(const VirtualBuffer&) = delete;
+    VirtualBuffer& operator=(const VirtualBuffer&) = delete;
+
+    VirtualBuffer(VirtualBuffer&& other) noexcept
+        : alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr),
+                                                                   nullptr} {}
+
+    VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
+        alloc_size = std::exchange(other.alloc_size, 0);
+        base_ptr = std::exchange(other.base_ptr, nullptr);
+        return *this;
+    }
+
    void resize(std::size_t count) {
+        const auto new_size = count * sizeof(T);
+        if (new_size == alloc_size) {
+            return;
+        }
+
        FreeMemoryPages(base_ptr, alloc_size);

-        alloc_size = count * sizeof(T);
+        alloc_size = new_size;
        base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
    }

@@ -53,7 +53,7 @@ public:
        return Common::Divide128On32(temporary, 1000000000).first;
    }

-    void Pause(bool is_paused) override {
+    void Pause([[maybe_unused]] bool is_paused) override {
        // Do nothing in this clock type.
    }

@@ -34,7 +34,7 @@ private:
    /// value used to reduce the native clocks accuracy as some apss rely on
    /// undefined behavior where the level of accuracy in the clock shouldn't
    /// be higher.
-    static constexpr u64 inaccuracy_mask = ~(0x400 - 1);
+    static constexpr u64 inaccuracy_mask = ~(UINT64_C(0x400) - 1);

    SpinLock rtsc_serialize{};
    u64 last_measure{};
@@ -13,8 +13,6 @@ add_library(core STATIC
    arm/dynarmic/arm_exclusive_monitor.h
    arm/exclusive_monitor.cpp
    arm/exclusive_monitor.h
-    arm/unicorn/arm_unicorn.cpp
-    arm/unicorn/arm_unicorn.h
    constants.cpp
    constants.h
    core.cpp
@@ -439,6 +437,8 @@ add_library(core STATIC
    hle/service/nvdrv/devices/nvhost_gpu.h
    hle/service/nvdrv/devices/nvhost_nvdec.cpp
    hle/service/nvdrv/devices/nvhost_nvdec.h
+    hle/service/nvdrv/devices/nvhost_nvdec_common.cpp
+    hle/service/nvdrv/devices/nvhost_nvdec_common.h
    hle/service/nvdrv/devices/nvhost_nvjpg.cpp
    hle/service/nvdrv/devices/nvhost_nvjpg.h
    hle/service/nvdrv/devices/nvhost_vic.cpp
@@ -452,10 +452,14 @@ add_library(core STATIC
    hle/service/nvdrv/nvdrv.h
    hle/service/nvdrv/nvmemp.cpp
    hle/service/nvdrv/nvmemp.h
+    hle/service/nvdrv/syncpoint_manager.cpp
+    hle/service/nvdrv/syncpoint_manager.h
    hle/service/nvflinger/buffer_queue.cpp
    hle/service/nvflinger/buffer_queue.h
    hle/service/nvflinger/nvflinger.cpp
    hle/service/nvflinger/nvflinger.h
+    hle/service/olsc/olsc.cpp
+    hle/service/olsc/olsc.h
    hle/service/pcie/pcie.cpp
    hle/service/pcie/pcie.h
    hle/service/pctl/module.cpp
@@ -630,17 +634,19 @@ else()
        -Werror=implicit-fallthrough
        -Werror=reorder
        -Werror=sign-compare
-        -Werror=sign-conversion
+        -Werror=unused-variable
+
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
-        -Werror=unused-variable
+
+        -Wno-sign-conversion
    )
 endif()

 create_target_directory_groups(core)

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

 if (YUZU_ENABLE_BOXCAT)
    target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
@@ -152,7 +152,7 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Interface::GetBacktraceFromContex
            .address = 0,
            .original_address = lr,
            .offset = 0,
-            .name = "",
+            .name = {},
        });

        if (fp == 0) {
@@ -211,18 +211,10 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Interface::GetBacktrace() const {
    auto fp = GetReg(29);
    auto lr = GetReg(30);
    while (true) {
-        out.push_back({
-            .module = "",
-            .address = 0,
-            .original_address = lr,
-            .offset = 0,
-            .name = "",
-        });
-
-        if (fp == 0) {
+        out.push_back({"", 0, lr, 0, ""});
+        if (!fp) {
            break;
        }
-
        lr = memory.Read64(fp + 8) - 4;
        fp = memory.Read64(fp);
    }
@@ -93,14 +93,14 @@ public:
     * @param index Register index
     * @return Returns the value in the register
     */
-    virtual u64 GetReg(std::size_t index) const = 0;
+    virtual u64 GetReg(int index) const = 0;

    /**
     * Set an ARM register
     * @param index Register index
     * @param value Value to set register to
     */
-    virtual void SetReg(std::size_t index, u64 value) = 0;
+    virtual void SetReg(int index, u64 value) = 0;

    /**
     * Gets the value of a specified vector register.
@@ -108,7 +108,7 @@ public:
     * @param index The index of the vector register.
     * @return the value within the vector register.
     */
-    virtual u128 GetVectorReg(std::size_t index) const = 0;
+    virtual u128 GetVectorReg(int index) const = 0;

    /**
     * Sets a given value into a vector register.
@@ -116,7 +116,7 @@ public:
     * @param index The index of the vector register.
     * @param value The new value to place in the register.
     */
-    virtual void SetVectorReg(std::size_t index, u128 value) = 0;
+    virtual void SetVectorReg(int index, u128 value) = 0;

    /**
     * Get the current PSTATE register
@@ -7,6 +7,7 @@
 #include <dynarmic/A32/a32.h>
 #include <dynarmic/A32/config.h>
 #include <dynarmic/A32/context.h>
+#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "core/arm/cpu_interrupt_handler.h"
@@ -111,7 +112,7 @@ public:
            }
            return 0U;
        }
-        return static_cast<u64>(std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0));
+        return std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0);
    }

    ARM_Dynarmic_32& parent;
@@ -210,19 +211,19 @@ u64 ARM_Dynarmic_32::GetPC() const {
    return jit->Regs()[15];
 }

-u64 ARM_Dynarmic_32::GetReg(std::size_t index) const {
+u64 ARM_Dynarmic_32::GetReg(int index) const {
    return jit->Regs()[index];
 }

-void ARM_Dynarmic_32::SetReg(std::size_t index, u64 value) {
+void ARM_Dynarmic_32::SetReg(int index, u64 value) {
    jit->Regs()[index] = static_cast<u32>(value);
 }

-u128 ARM_Dynarmic_32::GetVectorReg(std::size_t index) const {
+u128 ARM_Dynarmic_32::GetVectorReg(int index) const {
    return {};
 }

-void ARM_Dynarmic_32::SetVectorReg(std::size_t index, u128 value) {}
+void ARM_Dynarmic_32::SetVectorReg(int index, u128 value) {}

 u32 ARM_Dynarmic_32::GetPSTATE() const {
    return jit->Cpsr();
@@ -35,10 +35,10 @@ public:

    void SetPC(u64 pc) override;
    u64 GetPC() const override;
-    u64 GetReg(std::size_t index) const override;
-    void SetReg(std::size_t index, u64 value) override;
-    u128 GetVectorReg(std::size_t index) const override;
-    void SetVectorReg(std::size_t index, u128 value) 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;
@@ -6,6 +6,7 @@
 #include <memory>
 #include <dynarmic/A64/a64.h>
 #include <dynarmic/A64/config.h>
+#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "core/arm/cpu_interrupt_handler.h"
@@ -13,7 +14,6 @@
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #include "core/core.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"
@@ -82,16 +82,9 @@ public:
    }

    void InterpreterFallback(u64 pc, std::size_t num_instructions) override {
-        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
-                 num_instructions, MemoryReadCode(pc));
-
-        ARM_Interface::ThreadContext64 ctx;
-        parent.SaveContext(ctx);
-        parent.inner_unicorn.LoadContext(ctx);
-        parent.inner_unicorn.ExecuteInstructions(num_instructions);
-        parent.inner_unicorn.SaveContext(ctx);
-        parent.LoadContext(ctx);
-        num_interpreted_instructions += num_instructions;
+        LOG_ERROR(Core_ARM,
+                  "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
+                  num_instructions, MemoryReadCode(pc));
    }

    void ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) override {
@@ -127,18 +120,17 @@ public:
        if (parent.uses_wall_clock) {
            return;
        }
+
        // 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::Hardware::NUM_CPU_CORES;
+        u64 amortized_ticks = ticks / Core::Hardware::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 {
@@ -148,7 +140,7 @@ public:
            }
            return 0U;
        }
-        return static_cast<u64>(std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0));
+        return std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0);
    }

    u64 GetCNTPCT() override {
@@ -156,7 +148,6 @@ public:
    }

    ARM_Dynarmic_64& parent;
-    std::size_t num_interpreted_instructions = 0;
    u64 tpidrro_el0 = 0;
    u64 tpidr_el0 = 0;
    static constexpr u64 minimum_run_cycles = 1000U;
@@ -248,12 +239,8 @@ ARM_Dynarmic_64::ARM_Dynarmic_64(System& system, CPUInterrupts& interrupt_handle
                                 bool uses_wall_clock, ExclusiveMonitor& exclusive_monitor,
                                 std::size_t core_index)
    : ARM_Interface{system, interrupt_handlers, uses_wall_clock},
-      cb(std::make_unique<DynarmicCallbacks64>(*this)), inner_unicorn{system, interrupt_handlers,
-                                                                      uses_wall_clock,
-                                                                      ARM_Unicorn::Arch::AArch64,
-                                                                      core_index},
-      core_index{core_index}, exclusive_monitor{
-                                  dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
+      cb(std::make_unique<DynarmicCallbacks64>(*this)), core_index{core_index},
+      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}

 ARM_Dynarmic_64::~ARM_Dynarmic_64() = default;

@@ -265,19 +252,19 @@ u64 ARM_Dynarmic_64::GetPC() const {
    return jit->GetPC();
 }

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

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

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

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

@@ -12,7 +12,6 @@
 #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 {
 class Memory;
@@ -33,10 +32,10 @@ public:

    void SetPC(u64 pc) override;
    u64 GetPC() const override;
-    u64 GetReg(std::size_t index) const override;
-    void SetReg(std::size_t index, u64 value) override;
-    u128 GetVectorReg(std::size_t index) const override;
-    void SetVectorReg(std::size_t index, u128 value) 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;
@@ -71,7 +70,6 @@ private:
    std::unique_ptr<DynarmicCallbacks64> cb;
    JitCacheType jit_cache;
    std::shared_ptr<Dynarmic::A64::Jit> jit;
-    ARM_Unicorn inner_unicorn;

    std::size_t core_index;
    DynarmicExclusiveMonitor& exclusive_monitor;
@@ -1,295 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <unicorn/arm64.h>
-#include "common/assert.h"
-#include "common/microprofile.h"
-#include "core/arm/cpu_interrupt_handler.h"
-#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 {
-
-// Load Unicorn DLL once on Windows using RAII
-#ifdef _MSC_VER
-#include <unicorn_dynload.h>
-struct LoadDll {
-private:
-    LoadDll() {
-        ASSERT(uc_dyn_load(NULL, 0));
-    }
-    ~LoadDll() {
-        ASSERT(uc_dyn_free());
-    }
-    static LoadDll g_load_dll;
-};
-LoadDll LoadDll::g_load_dll;
-#endif
-
-#define CHECKED(expr)                                                                              \
-    do {                                                                                           \
-        if (auto _cerr = (expr)) {                                                                 \
-            ASSERT_MSG(false, "Call " #expr " failed with error: {} ({})\n", _cerr,                \
-                       uc_strerror(_cerr));                                                        \
-        }                                                                                          \
-    } while (0)
-
-static void CodeHook(uc_engine* uc, uint64_t address, uint32_t size, void* user_data) {
-    GDBStub::BreakpointAddress bkpt =
-        GDBStub::GetNextBreakpointFromAddress(address, GDBStub::BreakpointType::Execute);
-    if (GDBStub::IsMemoryBreak() ||
-        (bkpt.type != GDBStub::BreakpointType::None && address == bkpt.address)) {
-        auto core = static_cast<ARM_Unicorn*>(user_data);
-        core->RecordBreak(bkpt);
-        uc_emu_stop(uc);
-    }
-}
-
-static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int size, u64 value,
-                               void* user_data) {
-    auto* const system = static_cast<System*>(user_data);
-
-    ARM_Interface::ThreadContext64 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]);
-
-    return false;
-}
-
-ARM_Unicorn::ARM_Unicorn(System& system, CPUInterrupts& interrupt_handlers, bool uses_wall_clock,
-                         Arch architecture, std::size_t core_index)
-    : ARM_Interface{system, interrupt_handlers, uses_wall_clock}, core_index{core_index} {
-    const auto arch = architecture == Arch::AArch32 ? UC_ARCH_ARM : UC_ARCH_ARM64;
-    CHECKED(uc_open(arch, UC_MODE_ARM, &uc));
-
-    auto fpv = 3 << 20;
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_CPACR_EL1, &fpv));
-
-    uc_hook hook{};
-    CHECKED(uc_hook_add(uc, &hook, UC_HOOK_INTR, (void*)InterruptHook, this, 0, UINT64_MAX));
-    CHECKED(uc_hook_add(uc, &hook, UC_HOOK_MEM_INVALID, (void*)UnmappedMemoryHook, &system, 0,
-                        UINT64_MAX));
-    if (GDBStub::IsServerEnabled()) {
-        CHECKED(uc_hook_add(uc, &hook, UC_HOOK_CODE, (void*)CodeHook, this, 0, UINT64_MAX));
-        last_bkpt_hit = false;
-    }
-}
-
-ARM_Unicorn::~ARM_Unicorn() {
-    CHECKED(uc_close(uc));
-}
-
-void ARM_Unicorn::SetPC(u64 pc) {
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_PC, &pc));
-}
-
-u64 ARM_Unicorn::GetPC() const {
-    u64 val{};
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_PC, &val));
-    return val;
-}
-
-u64 ARM_Unicorn::GetReg(std::size_t index) const {
-    u64 val{};
-    auto treg = UC_ARM64_REG_SP;
-    if (index <= 28) {
-        treg = static_cast<uc_arm64_reg>(UC_ARM64_REG_X0 + static_cast<int>(index));
-    } else if (index < 31) {
-        treg = static_cast<uc_arm64_reg>(UC_ARM64_REG_X29 + static_cast<int>(index) - 29);
-    }
-    CHECKED(uc_reg_read(uc, treg, &val));
-    return val;
-}
-
-void ARM_Unicorn::SetReg(std::size_t index, u64 value) {
-    auto treg = UC_ARM64_REG_SP;
-    if (index <= 28) {
-        treg = static_cast<uc_arm64_reg>(UC_ARM64_REG_X0 + static_cast<int>(index));
-    } else if (index < 31) {
-        treg = static_cast<uc_arm64_reg>(UC_ARM64_REG_X29 + static_cast<int>(index) - 29);
-    }
-    CHECKED(uc_reg_write(uc, treg, &value));
-}
-
-u128 ARM_Unicorn::GetVectorReg(std::size_t /*index*/) const {
-    UNIMPLEMENTED();
-    static constexpr u128 res{};
-    return res;
-}
-
-void ARM_Unicorn::SetVectorReg(std::size_t /*index*/, u128 /*value*/) {
-    UNIMPLEMENTED();
-}
-
-u32 ARM_Unicorn::GetPSTATE() const {
-    u64 nzcv{};
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_NZCV, &nzcv));
-    return static_cast<u32>(nzcv);
-}
-
-void ARM_Unicorn::SetPSTATE(u32 pstate) {
-    u64 nzcv = pstate;
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_NZCV, &nzcv));
-}
-
-VAddr ARM_Unicorn::GetTlsAddress() const {
-    u64 base{};
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
-    return base;
-}
-
-void ARM_Unicorn::SetTlsAddress(VAddr base) {
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
-}
-
-u64 ARM_Unicorn::GetTPIDR_EL0() const {
-    u64 value{};
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_TPIDR_EL0, &value));
-    return value;
-}
-
-void ARM_Unicorn::SetTPIDR_EL0(u64 value) {
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDR_EL0, &value));
-}
-
-void ARM_Unicorn::ChangeProcessorID(std::size_t new_core_id) {
-    core_index = new_core_id;
-}
-
-void ARM_Unicorn::Run() {
-    if (GDBStub::IsServerEnabled()) {
-        ExecuteInstructions(std::max(4000000U, 0U));
-    } else {
-        while (true) {
-            if (interrupt_handlers[core_index].IsInterrupted()) {
-                return;
-            }
-            ExecuteInstructions(10);
-        }
-    }
-}
-
-void ARM_Unicorn::Step() {
-    ExecuteInstructions(1);
-}
-
-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()));
-    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());
-        if (last_bkpt_hit || GDBStub::IsMemoryBreak() || GDBStub::GetCpuStepFlag()) {
-            last_bkpt_hit = false;
-            GDBStub::Break();
-            GDBStub::SendTrap(thread, 5);
-        }
-    }
-}
-
-void ARM_Unicorn::SaveContext(ThreadContext64& ctx) {
-    int uregs[32];
-    void* tregs[32];
-
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_SP, &ctx.sp));
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_PC, &ctx.pc));
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_NZCV, &ctx.pstate));
-
-    for (std::size_t i = 0; i < 29; ++i) {
-        uregs[i] = UC_ARM64_REG_X0 + static_cast<int>(i);
-        tregs[i] = &ctx.cpu_registers[i];
-    }
-    uregs[29] = UC_ARM64_REG_X29;
-    tregs[29] = (void*)&ctx.cpu_registers[29];
-    uregs[30] = UC_ARM64_REG_X30;
-    tregs[30] = (void*)&ctx.cpu_registers[30];
-
-    CHECKED(uc_reg_read_batch(uc, uregs, tregs, 31));
-
-    for (std::size_t i = 0; i < 32; ++i) {
-        uregs[i] = UC_ARM64_REG_Q0 + static_cast<int>(i);
-        tregs[i] = &ctx.vector_registers[i];
-    }
-
-    CHECKED(uc_reg_read_batch(uc, uregs, tregs, 32));
-}
-
-void ARM_Unicorn::LoadContext(const ThreadContext64& ctx) {
-    int uregs[32];
-    void* tregs[32];
-
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_SP, &ctx.sp));
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_PC, &ctx.pc));
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_NZCV, &ctx.pstate));
-
-    for (std::size_t i = 0; i < 29; ++i) {
-        uregs[i] = UC_ARM64_REG_X0 + static_cast<int>(i);
-        tregs[i] = (void*)&ctx.cpu_registers[i];
-    }
-    uregs[29] = UC_ARM64_REG_X29;
-    tregs[29] = (void*)&ctx.cpu_registers[29];
-    uregs[30] = UC_ARM64_REG_X30;
-    tregs[30] = (void*)&ctx.cpu_registers[30];
-
-    CHECKED(uc_reg_write_batch(uc, uregs, tregs, 31));
-
-    for (std::size_t i = 0; i < 32; ++i) {
-        uregs[i] = UC_ARM64_REG_Q0 + static_cast<int>(i);
-        tregs[i] = (void*)&ctx.vector_registers[i];
-    }
-
-    CHECKED(uc_reg_write_batch(uc, uregs, tregs, 32));
-}
-
-void ARM_Unicorn::PrepareReschedule() {
-    CHECKED(uc_emu_stop(uc));
-}
-
-void ARM_Unicorn::ClearExclusiveState() {}
-
-void ARM_Unicorn::ClearInstructionCache() {}
-
-void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {
-    last_bkpt = bkpt;
-    last_bkpt_hit = true;
-}
-
-void ARM_Unicorn::InterruptHook(uc_engine* uc, u32 int_no, void* user_data) {
-    u32 esr{};
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_ESR, &esr));
-
-    const auto ec = esr >> 26;
-    const auto iss = esr & 0xFFFFFF;
-
-    auto* const arm_instance = static_cast<ARM_Unicorn*>(user_data);
-
-    switch (ec) {
-    case 0x15: // SVC
-        Kernel::Svc::Call(arm_instance->system, iss);
-        break;
-    }
-}
-
-} // 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 <unicorn/unicorn.h>
-#include "common/common_types.h"
-#include "core/arm/arm_interface.h"
-#include "core/gdbstub/gdbstub.h"
-
-namespace Core {
-
-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, CPUInterrupts& interrupt_handlers, bool uses_wall_clock,
-                         Arch architecture, std::size_t core_index);
-    ~ARM_Unicorn() override;
-
-    void SetPC(u64 pc) override;
-    u64 GetPC() const override;
-    u64 GetReg(std::size_t index) const override;
-    void SetReg(std::size_t index, u64 value) override;
-    u128 GetVectorReg(std::size_t index) const override;
-    void SetVectorReg(std::size_t index, u128 value) override;
-    u32 GetPSTATE() const override;
-    void SetPSTATE(u32 pstate) override;
-    VAddr GetTlsAddress() const override;
-    void SetTlsAddress(VAddr address) override;
-    void SetTPIDR_EL0(u64 value) override;
-    u64 GetTPIDR_EL0() const override;
-    void ChangeProcessorID(std::size_t new_core_id) override;
-    void PrepareReschedule() override;
-    void ClearExclusiveState() override;
-    void ExecuteInstructions(std::size_t num_instructions);
-    void Run() override;
-    void Step() override;
-    void ClearInstructionCache() override;
-    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);
-
-    uc_engine* uc{};
-    GDBStub::BreakpointAddress last_bkpt{};
-    bool last_bkpt_hit = false;
-    std::size_t core_index;
-};
-
-} // namespace Core
@@ -40,6 +40,7 @@
 #include "core/hle/service/lm/manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
+#include "core/hle/service/time/time_manager.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
 #include "core/memory/cheat_engine.h"
@@ -121,7 +122,7 @@ 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_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}

    ResultStatus Run() {
        status = ResultStatus::Success;
@@ -178,16 +179,21 @@ struct System::Impl {
        arp_manager.ResetAll();

        telemetry_session = std::make_unique<Core::TelemetrySession>();
+
+        gpu_core = VideoCore::CreateGPU(emu_window, system);
+        if (!gpu_core) {
+            return ResultStatus::ErrorVideoCore;
+        }
+
        service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);

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

        interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
-        gpu_core = VideoCore::CreateGPU(emu_window, system);
-        if (!gpu_core) {
-            return ResultStatus::ErrorVideoCore;
-        }
+
+        // Initialize time manager, which must happen after kernel is created
+        time_manager.Initialize();

        is_powered_on = true;
        exit_lock = false;
@@ -204,7 +210,7 @@ struct System::Impl {

    ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
                      const std::string& filepath) {
-        app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
+        app_loader = Loader::GetLoader(system, GetGameFileFromPath(virtual_filesystem, filepath));
        if (!app_loader) {
            LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
            return ResultStatus::ErrorGetLoader;
@@ -218,7 +224,7 @@ struct System::Impl {
            return init_result;
        }

-        telemetry_session->AddInitialInfo(*app_loader);
+        telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
        auto main_process =
            Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
        const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
@@ -332,7 +338,7 @@ struct System::Impl {
        Service::Glue::ApplicationLaunchProperty launch{};
        launch.title_id = process.GetTitleID();

-        FileSys::PatchManager pm{launch.title_id};
+        FileSys::PatchManager pm{launch.title_id, fs_controller, *content_provider};
        launch.version = pm.GetGameVersion().value_or(0);

        // TODO(DarkLordZach): When FSController/Game Card Support is added, if
@@ -387,6 +393,7 @@ struct System::Impl {
    /// Service State
    Service::Glue::ARPManager arp_manager;
    Service::LM::Manager lm_manager{reporter};
+    Service::Time::TimeManager time_manager;

    /// Service manager
    std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -717,6 +724,14 @@ const Service::LM::Manager& System::GetLogManager() const {
    return impl->lm_manager;
 }

+Service::Time::TimeManager& System::GetTimeManager() {
+    return impl->time_manager;
+}
+
+const Service::Time::TimeManager& System::GetTimeManager() const {
+    return impl->time_manager;
+}
+
 void System::SetExitLock(bool locked) {
    impl->exit_lock = locked;
 }
@@ -69,6 +69,10 @@ namespace SM {
 class ServiceManager;
 } // namespace SM

+namespace Time {
+class TimeManager;
+} // namespace Time
+
 } // namespace Service

 namespace Tegra {
@@ -361,6 +365,10 @@ public:

    const Service::LM::Manager& GetLogManager() const;

+    Service::Time::TimeManager& GetTimeManager();
+
+    const Service::Time::TimeManager& GetTimeManager() const;
+
    void SetExitLock(bool locked);

    bool GetExitLock() const;
@@ -140,8 +140,7 @@ void CoreTiming::AddTicks(u64 ticks) {
 void CoreTiming::Idle() {
    if (!event_queue.empty()) {
        const u64 next_event_time = event_queue.front().time;
-        const u64 next_ticks =
-            static_cast<u64>(nsToCycles(std::chrono::nanoseconds(next_event_time))) + 10;
+        const u64 next_ticks = nsToCycles(std::chrono::nanoseconds(next_event_time)) + 10U;
        if (next_ticks > ticks) {
            ticks = next_ticks;
        }
@@ -188,7 +187,7 @@ void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {

 std::optional<s64> CoreTiming::Advance() {
    std::scoped_lock lock{advance_lock, basic_lock};
-    global_timer = static_cast<u64>(GetGlobalTimeNs().count());
+    global_timer = GetGlobalTimeNs().count();

    while (!event_queue.empty() && event_queue.front().time <= global_timer) {
        Event evt = std::move(event_queue.front());
@@ -202,11 +201,11 @@ std::optional<s64> CoreTiming::Advance() {
        }

        basic_lock.lock();
-        global_timer = static_cast<u64>(GetGlobalTimeNs().count());
+        global_timer = GetGlobalTimeNs().count();
    }

    if (!event_queue.empty()) {
-        const auto next_time = static_cast<s64>(event_queue.front().time - global_timer);
+        const s64 next_time = event_queue.front().time - global_timer;
        return next_time;
    } else {
        return std::nullopt;
@@ -241,14 +240,14 @@ std::chrono::nanoseconds CoreTiming::GetGlobalTimeNs() const {
    if (is_multicore) {
        return clock->GetTimeNS();
    }
-    return CyclesToNs(static_cast<s64>(ticks));
+    return CyclesToNs(ticks);
 }

 std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const {
    if (is_multicore) {
        return clock->GetTimeUS();
    }
-    return CyclesToUs(static_cast<s64>(ticks));
+    return CyclesToUs(ticks);
 }

 } // namespace Core::Timing
@@ -21,9 +21,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 static_cast<s64>(Hardware::BASE_CLOCK_RATE * static_cast<u64>(ms.count() / 1000));
+        return Hardware::BASE_CLOCK_RATE * (ms.count() / 1000);
    }
-    return static_cast<s64>((Hardware::BASE_CLOCK_RATE * static_cast<u64>(ms.count())) / 1000);
+    return (Hardware::BASE_CLOCK_RATE * ms.count()) / 1000;
 }

 s64 usToCycles(std::chrono::microseconds us) {
@@ -33,55 +33,51 @@ 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 static_cast<s64>(Hardware::BASE_CLOCK_RATE * static_cast<u64>(us.count() / 1000000));
+        return Hardware::BASE_CLOCK_RATE * (us.count() / 1000000);
    }
-    return static_cast<s64>((Hardware::BASE_CLOCK_RATE * static_cast<u64>(us.count())) / 1000000);
+    return (Hardware::BASE_CLOCK_RATE * us.count()) / 1000000;
 }

 s64 nsToCycles(std::chrono::nanoseconds ns) {
-    const u128 temp =
-        Common::Multiply64Into128(static_cast<u64>(ns.count()), Hardware::BASE_CLOCK_RATE);
-    return static_cast<s64>(Common::Divide128On32(temp, static_cast<u32>(1000000000)).first);
+    const u128 temporal = Common::Multiply64Into128(ns.count(), Hardware::BASE_CLOCK_RATE);
+    return Common::Divide128On32(temporal, static_cast<u32>(1000000000)).first;
 }

-u64 msToClockCycles(std::chrono::milliseconds ms) {
-    const auto count = static_cast<u64>(ms.count());
-    const u128 temp = Common::Multiply64Into128(count, Hardware::CNTFREQ);
+u64 msToClockCycles(std::chrono::milliseconds ns) {
+    const u128 temp = Common::Multiply64Into128(ns.count(), Hardware::CNTFREQ);
    return Common::Divide128On32(temp, 1000).first;
 }

-u64 usToClockCycles(std::chrono::microseconds us) {
-    const auto count = static_cast<u64>(us.count());
-    const u128 temp = Common::Multiply64Into128(count, Hardware::CNTFREQ);
+u64 usToClockCycles(std::chrono::microseconds ns) {
+    const u128 temp = Common::Multiply64Into128(ns.count(), Hardware::CNTFREQ);
    return Common::Divide128On32(temp, 1000000).first;
 }

 u64 nsToClockCycles(std::chrono::nanoseconds ns) {
-    const auto count = static_cast<u64>(ns.count());
-    const u128 temp = Common::Multiply64Into128(count, Hardware::CNTFREQ);
+    const u128 temp = Common::Multiply64Into128(ns.count(), Hardware::CNTFREQ);
    return Common::Divide128On32(temp, 1000000000).first;
 }

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

 std::chrono::milliseconds CyclesToMs(s64 cycles) {
-    const u128 temp = Common::Multiply64Into128(static_cast<u64>(cycles), 1000);
-    const u64 ms = Common::Divide128On32(temp, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
+    const u128 temporal = Common::Multiply64Into128(cycles, 1000);
+    u64 ms = Common::Divide128On32(temporal, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
    return std::chrono::milliseconds(ms);
 }

 std::chrono::nanoseconds CyclesToNs(s64 cycles) {
-    const u128 temp = Common::Multiply64Into128(static_cast<u64>(cycles), 1000000000);
-    const u64 ns = Common::Divide128On32(temp, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
+    const u128 temporal = Common::Multiply64Into128(cycles, 1000000000);
+    u64 ns = Common::Divide128On32(temporal, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
    return std::chrono::nanoseconds(ns);
 }

 std::chrono::microseconds CyclesToUs(s64 cycles) {
-    const u128 temp = Common::Multiply64Into128(static_cast<u64>(cycles), 1000000);
-    const u64 us = Common::Divide128On32(temp, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
+    const u128 temporal = Common::Multiply64Into128(cycles, 1000000);
+    u64 us = Common::Divide128On32(temporal, static_cast<u32>(Hardware::BASE_CLOCK_RATE)).first;
    return std::chrono::microseconds(us);
 }

@@ -12,8 +12,8 @@ namespace Core::Timing {
 s64 msToCycles(std::chrono::milliseconds ms);
 s64 usToCycles(std::chrono::microseconds us);
 s64 nsToCycles(std::chrono::nanoseconds ns);
-u64 msToClockCycles(std::chrono::milliseconds ms);
-u64 usToClockCycles(std::chrono::microseconds us);
+u64 msToClockCycles(std::chrono::milliseconds ns);
+u64 usToClockCycles(std::chrono::microseconds ns);
 u64 nsToClockCycles(std::chrono::nanoseconds ns);
 std::chrono::milliseconds CyclesToMs(s64 cycles);
 std::chrono::nanoseconds CyclesToNs(s64 cycles);
@@ -365,6 +365,8 @@ void CpuManager::RunThread(std::size_t core) {
    data.enter_barrier.reset();
    data.exit_barrier.reset();
    data.initialized = false;
+
+    MicroProfileOnThreadExit();
 }

 } // namespace Core
@@ -143,7 +143,6 @@ u64 GetSignatureTypeDataSize(SignatureType type) {
        return 0x3C;
    }
    UNREACHABLE();
-    return 0;
 }

 u64 GetSignatureTypePaddingSize(SignatureType type) {
@@ -158,7 +157,6 @@ u64 GetSignatureTypePaddingSize(SignatureType type) {
        return 0x40;
    }
    UNREACHABLE();
-    return 0;
 }

 SignatureType Ticket::GetSignatureType() const {
@@ -173,7 +171,6 @@ SignatureType Ticket::GetSignatureType() const {
    }

    UNREACHABLE();
-    return {};
 }

 TicketData& Ticket::GetData() {
@@ -351,7 +348,7 @@ std::optional<Key128> DeriveSDSeed() {
    std::array<u8, 0x10> buffer{};
    std::size_t offset = 0;
    for (; offset + 0x10 < save_43.GetSize(); ++offset) {
-        if (!save_43.Seek(static_cast<s64>(offset), SEEK_SET)) {
+        if (!save_43.Seek(offset, SEEK_SET)) {
            return std::nullopt;
        }

@@ -361,7 +358,7 @@ std::optional<Key128> DeriveSDSeed() {
        }
    }

-    if (!save_43.Seek(static_cast<s64>(offset + 0x10), SEEK_SET)) {
+    if (!save_43.Seek(offset + 0x10, SEEK_SET)) {
        return std::nullopt;
    }

@@ -161,7 +161,7 @@ static constexpr u8 CalculateMaxKeyblobSourceHash() {
        return true;
    };

-    for (std::size_t i = 0x1F; i <= 0x1F; --i) {
+    for (s8 i = 0x1F; i >= 0; --i) {
        if (!is_zero(keyblob_source_hashes[i])) {
            return static_cast<u8>(i + 1);
        }
@@ -201,9 +201,9 @@ bool NCA::HandlePotentialHeaderDecryption() {
 }

 std::vector<NCASectionHeader> NCA::ReadSectionHeaders() const {
-    const auto number_sections = static_cast<std::size_t>(
+    const std::ptrdiff_t number_sections =
        std::count_if(std::begin(header.section_tables), std::end(header.section_tables),
-                      [](NCASectionTableEntry entry) { return entry.media_offset > 0; }));
+                      [](NCASectionTableEntry entry) { return entry.media_offset > 0; });

    std::vector<NCASectionHeader> sections(number_sections);
    const auto length_sections = SECTION_HEADER_SIZE * number_sections;
@@ -103,7 +103,7 @@ static u32 romfs_calc_path_hash(u32 parent, std::string_view path, u32 start,
    u32 hash = parent ^ 123456789;
    for (u32 i = 0; i < path_len; i++) {
        hash = (hash >> 5) | (hash << 27);
-        hash ^= static_cast<u32>(path[start + i]);
+        hash ^= path[start + i];
    }

    return hash;
@@ -66,14 +66,12 @@ static bool IsEOF(IPSFileType type, const std::vector<u8>& data) {
 }

 VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
-    if (in == nullptr || ips == nullptr) {
+    if (in == nullptr || ips == nullptr)
        return nullptr;
-    }

    const auto type = IdentifyMagic(ips->ReadBytes(0x5));
-    if (type == IPSFileType::Error) {
+    if (type == IPSFileType::Error)
        return nullptr;
-    }

    auto in_data = in->ReadAllBytes();

@@ -86,46 +84,37 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
        }

        u32 real_offset{};
-        if (type == IPSFileType::IPS32) {
-            real_offset = static_cast<u32>(temp[0] << 24) | static_cast<u32>(temp[1] << 16) |
-                          static_cast<u32>(temp[2] << 8) | temp[3];
-        } else {
-            real_offset =
-                static_cast<u32>(temp[0] << 16) | static_cast<u32>(temp[1] << 8) | temp[2];
-        }
+        if (type == IPSFileType::IPS32)
+            real_offset = (temp[0] << 24) | (temp[1] << 16) | (temp[2] << 8) | temp[3];
+        else
+            real_offset = (temp[0] << 16) | (temp[1] << 8) | temp[2];

        u16 data_size{};
-        if (ips->ReadObject(&data_size, offset) != sizeof(u16)) {
+        if (ips->ReadObject(&data_size, offset) != sizeof(u16))
            return nullptr;
-        }
        data_size = Common::swap16(data_size);
        offset += sizeof(u16);

        if (data_size == 0) { // RLE
            u16 rle_size{};
-            if (ips->ReadObject(&rle_size, offset) != sizeof(u16)) {
+            if (ips->ReadObject(&rle_size, offset) != sizeof(u16))
                return nullptr;
-            }
            rle_size = Common::swap16(rle_size);
            offset += sizeof(u16);

            const auto data = ips->ReadByte(offset++);
-            if (!data) {
+            if (!data)
                return nullptr;
-            }

-            if (real_offset + rle_size > in_data.size()) {
+            if (real_offset + rle_size > in_data.size())
                rle_size = static_cast<u16>(in_data.size() - real_offset);
-            }
            std::memset(in_data.data() + real_offset, *data, rle_size);
        } else { // Standard Patch
            auto read = data_size;
-            if (real_offset + read > in_data.size()) {
+            if (real_offset + read > in_data.size())
                read = static_cast<u16>(in_data.size() - real_offset);
-            }
-            if (ips->Read(in_data.data() + real_offset, read, offset) != data_size) {
+            if (ips->Read(in_data.data() + real_offset, read, offset) != data_size)
                return nullptr;
-            }
            offset += data_size;
        }
    }
@@ -193,16 +182,14 @@ void IPSwitchCompiler::ParseFlag(const std::string& line) {
 void IPSwitchCompiler::Parse() {
    const auto bytes = patch_text->ReadAllBytes();
    std::stringstream s;
-    s.write(reinterpret_cast<const char*>(bytes.data()),
-            static_cast<std::streamsize>(bytes.size()));
+    s.write(reinterpret_cast<const char*>(bytes.data()), bytes.size());

    std::vector<std::string> lines;
    std::string stream_line;
    while (std::getline(s, stream_line)) {
        // Remove a trailing \r
-        if (!stream_line.empty() && stream_line.back() == '\r') {
+        if (!stream_line.empty() && stream_line.back() == '\r')
            stream_line.pop_back();
-        }
        lines.push_back(std::move(stream_line));
    }

@@ -36,14 +36,14 @@ bool DecompressBLZ(std::vector<u8>& data) {
    while (out_index > 0) {
        --index;
        auto control = data[index + start_offset];
-        for (std::size_t i = 0; i < 8; ++i) {
+        for (size_t i = 0; i < 8; ++i) {
            if (((control << i) & 0x80) > 0) {
                if (index < 2) {
                    return false;
                }
                index -= 2;
-                std::size_t segment_offset = static_cast<u32>(data[index + start_offset]) |
-                                             static_cast<u32>(data[index + start_offset + 1] << 8);
+                std::size_t segment_offset =
+                    data[index + start_offset] | data[index + start_offset + 1] << 8;
                std::size_t segment_size = ((segment_offset >> 12) & 0xF) + 3;
                segment_offset &= 0xFFF;
                segment_offset += 3;
@@ -25,9 +25,9 @@ std::pair<std::size_t, std::size_t> SearchBucketEntry(u64 offset, const BlockTyp
        ASSERT_MSG(offset <= block.size, "Offset is out of bounds in BKTR relocation block.");
    }

-    const auto bucket_id = static_cast<std::size_t>(std::count_if(
+    std::size_t bucket_id = std::count_if(
        block.base_offsets.begin() + 1, block.base_offsets.begin() + block.number_buckets,
-        [&offset](u64 base_offset) { return base_offset <= offset; }));
+        [&offset](u64 base_offset) { return base_offset <= offset; });

    const auto& bucket = buckets[bucket_id];

@@ -53,7 +53,6 @@ std::pair<std::size_t, std::size_t> SearchBucketEntry(u64 offset, const BlockTyp
    }

    UNREACHABLE_MSG("Offset could not be found in BKTR block.");
-    return {};
 }
 } // Anonymous namespace

@@ -137,7 +136,7 @@ std::size_t BKTR::Read(u8* data, std::size_t length, std::size_t offset) const {

    const auto block_offset = section_offset & 0xF;
    if (block_offset != 0) {
-        auto block = bktr_romfs->ReadBytes(0x10, section_offset & ~0xFU);
+        auto block = bktr_romfs->ReadBytes(0x10, section_offset & ~0xF);
        cipher.Transcode(block.data(), block.size(), block.data(), Core::Crypto::Op::Decrypt);
        if (length + block_offset < 0x10) {
            std::memcpy(data, block.data() + block_offset, std::min(length, block.size()));
@@ -112,7 +112,10 @@ bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
 }
 } // Anonymous namespace

-PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
+PatchManager::PatchManager(u64 title_id_,
+                           const Service::FileSystem::FileSystemController& fs_controller_,
+                           const ContentProvider& content_provider_)
+    : title_id{title_id_}, fs_controller{fs_controller_}, content_provider{content_provider_} {}

 PatchManager::~PatchManager() = default;

@@ -128,34 +131,30 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {

    if (Settings::values.dump_exefs) {
        LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
-        const auto dump_dir =
-            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
+        const auto dump_dir = fs_controller.GetModificationDumpRoot(title_id);
        if (dump_dir != nullptr) {
            const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
            VfsRawCopyD(exefs, exefs_dir);
        }
    }

-    const auto& installed = Core::System::GetInstance().GetContentProvider();
-
    const auto& disabled = Settings::values.disabled_addons[title_id];
    const auto update_disabled =
        std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();

    // Game Updates
    const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed.GetEntry(update_tid, ContentRecordType::Program);
+    const auto update = content_provider.GetEntry(update_tid, ContentRecordType::Program);

    if (!update_disabled && update != nullptr && update->GetExeFS() != nullptr &&
        update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
        LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                 FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
+                 FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
        exefs = update->GetExeFS();
    }

    // LayeredExeFS
-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir != nullptr && load_dir->GetSize() > 0) {
        auto patch_dirs = load_dir->GetSubdirectories();
        std::sort(
@@ -241,8 +240,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
    if (Settings::values.dump_nso) {
        LOG_INFO(Loader, "Dumping NSO for name={}, build_id={}, title_id={:016X}", name, build_id,
                 title_id);
-        const auto dump_dir =
-            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
+        const auto dump_dir = fs_controller.GetModificationDumpRoot(title_id);
        if (dump_dir != nullptr) {
            const auto nso_dir = GetOrCreateDirectoryRelative(dump_dir, "/nso");
            const auto file = nso_dir->CreateFile(fmt::format("{}-{}.nso", name, build_id));
@@ -254,8 +252,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st

    LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);

-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
        return nso;
@@ -298,8 +295,7 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {

    LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);

-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
        return false;
@@ -313,8 +309,8 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
 }

 std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
-    const Core::System& system, const BuildID& build_id_) const {
-    const auto load_dir = system.GetFileSystemController().GetModificationLoadRoot(title_id);
+    const BuildID& build_id_) const {
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
        return {};
@@ -347,9 +343,9 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
    return out;
 }

-static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type,
+                           const Service::FileSystem::FileSystemController& fs_controller) {
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if ((type != ContentRecordType::Program && type != ContentRecordType::Data) ||
        load_dir == nullptr || load_dir->GetSize() <= 0) {
        return;
@@ -411,19 +407,19 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
    const auto log_string = fmt::format("Patching RomFS for title_id={:016X}, type={:02X}",
                                        title_id, static_cast<u8>(type));

-    if (type == ContentRecordType::Program || type == ContentRecordType::Data)
+    if (type == ContentRecordType::Program || type == ContentRecordType::Data) {
        LOG_INFO(Loader, "{}", log_string);
-    else
+    } else {
        LOG_DEBUG(Loader, "{}", log_string);
+    }

-    if (romfs == nullptr)
+    if (romfs == nullptr) {
        return romfs;
-
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
+    }

    // Game Updates
    const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed.GetEntryRaw(update_tid, type);
+    const auto update = content_provider.GetEntryRaw(update_tid, type);

    const auto& disabled = Settings::values.disabled_addons[title_id];
    const auto update_disabled =
@@ -434,7 +430,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
        if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
            new_nca->GetRomFS() != nullptr) {
            LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
+                     FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
            romfs = new_nca->GetRomFS();
        }
    } else if (!update_disabled && update_raw != nullptr) {
@@ -447,7 +443,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
    }

    // LayeredFS
-    ApplyLayeredFS(romfs, title_id, type);
+    ApplyLayeredFS(romfs, title_id, type, fs_controller);

    return romfs;
 }
@@ -458,12 +454,11 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
    }

    std::map<std::string, std::string, std::less<>> out;
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
    const auto& disabled = Settings::values.disabled_addons[title_id];

    // Game Updates
    const auto update_tid = GetUpdateTitleID(title_id);
-    PatchManager update{update_tid};
+    PatchManager update{update_tid, fs_controller, content_provider};
    const auto metadata = update.GetControlMetadata();
    const auto& nacp = metadata.first;

@@ -474,8 +469,8 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
    if (nacp != nullptr) {
        out.insert_or_assign(update_label, nacp->GetVersionString());
    } else {
-        if (installed.HasEntry(update_tid, ContentRecordType::Program)) {
-            const auto meta_ver = installed.GetEntryVersion(update_tid);
+        if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
+            const auto meta_ver = content_provider.GetEntryVersion(update_tid);
            if (meta_ver.value_or(0) == 0) {
                out.insert_or_assign(update_label, "");
            } else {
@@ -487,8 +482,7 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
    }

    // General Mods (LayeredFS and IPS)
-    const auto mod_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto mod_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (mod_dir != nullptr && mod_dir->GetSize() > 0) {
        for (const auto& mod : mod_dir->GetSubdirectories()) {
            std::string types;
@@ -532,13 +526,15 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
    }

    // DLC
-    const auto dlc_entries = installed.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
+    const auto dlc_entries =
+        content_provider.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
    std::vector<ContentProviderEntry> dlc_match;
    dlc_match.reserve(dlc_entries.size());
    std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
-                 [this, &installed](const ContentProviderEntry& entry) {
+                 [this](const ContentProviderEntry& entry) {
                     return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == title_id &&
-                            installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
+                            content_provider.GetEntry(entry)->GetStatus() ==
+                                Loader::ResultStatus::Success;
                 });
    if (!dlc_match.empty()) {
        // Ensure sorted so DLC IDs show in order.
@@ -559,19 +555,16 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
 }

 std::optional<u32> PatchManager::GetGameVersion() const {
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
    const auto update_tid = GetUpdateTitleID(title_id);
-    if (installed.HasEntry(update_tid, ContentRecordType::Program)) {
-        return installed.GetEntryVersion(update_tid);
+    if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
+        return content_provider.GetEntryVersion(update_tid);
    }

-    return installed.GetEntryVersion(title_id);
+    return content_provider.GetEntryVersion(title_id);
 }

 PatchManager::Metadata PatchManager::GetControlMetadata() const {
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
-
-    const auto base_control_nca = installed.GetEntry(title_id, ContentRecordType::Control);
+    const auto base_control_nca = content_provider.GetEntry(title_id, ContentRecordType::Control);
    if (base_control_nca == nullptr) {
        return {};
    }
@@ -17,8 +17,13 @@ namespace Core {
 class System;
 }

+namespace Service::FileSystem {
+class FileSystemController;
+}
+
 namespace FileSys {

+class ContentProvider;
 class NCA;
 class NACP;

@@ -29,7 +34,9 @@ public:
    using Metadata = std::pair<std::unique_ptr<NACP>, VirtualFile>;
    using PatchVersionNames = std::map<std::string, std::string, std::less<>>;

-    explicit PatchManager(u64 title_id);
+    explicit PatchManager(u64 title_id_,
+                          const Service::FileSystem::FileSystemController& fs_controller_,
+                          const ContentProvider& content_provider_);
    ~PatchManager();

    [[nodiscard]] u64 GetTitleID() const;
@@ -50,7 +57,7 @@ public:

    // Creates a CheatList object with all
    [[nodiscard]] std::vector<Core::Memory::CheatEntry> CreateCheatList(
-        const Core::System& system, const BuildID& build_id) const;
+        const BuildID& build_id) const;

    // Currently tracked RomFS patches:
    // - Game Updates
@@ -80,6 +87,8 @@ private:
                                                          const std::string& build_id) const;

    u64 title_id;
+    const Service::FileSystem::FileSystemController& fs_controller;
+    const ContentProvider& content_provider;
 };

 } // namespace FileSys
@@ -37,10 +37,12 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw) {
 }

 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
-    if (!updatable)
+    if (!updatable) {
        return MakeResult<VirtualFile>(file);
+    }

-    const PatchManager patch_manager(current_process_title_id);
+    const PatchManager patch_manager{current_process_title_id, filesystem_controller,
+                                     content_provider};
    return MakeResult<VirtualFile>(
        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }
@@ -19,7 +19,7 @@ DefaultControllerApplet::DefaultControllerApplet(Service::SM::ServiceManager& se
 DefaultControllerApplet::~DefaultControllerApplet() = default;

 void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callback,
-                                                     ControllerParameters parameters) const {
+                                                     const ControllerParameters& parameters) const {
    LOG_INFO(Service_HID, "called, deducing the best configuration based on the given parameters!");

    auto& npad =
@@ -27,19 +27,19 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
            ->GetAppletResource()
            ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad);

-    auto& players = Settings::values.players;
+    auto& players = Settings::values.players.GetValue();

    const std::size_t min_supported_players =
-        parameters.enable_single_mode ? 1 : static_cast<std::size_t>(parameters.min_players);
+        parameters.enable_single_mode ? 1 : parameters.min_players;

    // Disconnect Handheld first.
-    npad.DisconnectNPadAtIndex(8);
+    npad.DisconnectNpadAtIndex(8);

    // Deduce the best configuration based on the input parameters.
    for (std::size_t index = 0; index < players.size() - 2; ++index) {
        // First, disconnect all controllers regardless of the value of keep_controllers_connected.
        // This makes it easy to connect the desired controllers.
-        npad.DisconnectNPadAtIndex(index);
+        npad.DisconnectNpadAtIndex(index);

        // Only connect the minimum number of required players.
        if (index >= min_supported_players) {
@@ -66,7 +66,7 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
                    npad.MapSettingsTypeToNPad(Settings::ControllerType::RightJoycon), index);
            }
        } else if (index == 0 && parameters.enable_single_mode && parameters.allow_handheld &&
-                   !Settings::values.use_docked_mode) {
+                   !Settings::values.use_docked_mode.GetValue()) {
            // We should *never* reach here under any normal circumstances.
            npad.AddNewControllerAt(npad.MapSettingsTypeToNPad(Settings::ControllerType::Handheld),
                                    index);
@@ -38,7 +38,7 @@ public:
    virtual ~ControllerApplet();

    virtual void ReconfigureControllers(std::function<void()> callback,
-                                        ControllerParameters parameters) const = 0;
+                                        const ControllerParameters& parameters) const = 0;
 };

 class DefaultControllerApplet final : public ControllerApplet {
@@ -47,7 +47,7 @@ public:
    ~DefaultControllerApplet() override;

    void ReconfigureControllers(std::function<void()> callback,
-                                ControllerParameters parameters) const override;
+                                const ControllerParameters& parameters) const override;

 private:
    Service::SM::ServiceManager& service_manager;
@@ -12,9 +12,8 @@ ProfileSelectApplet::~ProfileSelectApplet() = default;

 void DefaultProfileSelectApplet::SelectProfile(
    std::function<void(std::optional<Common::UUID>)> callback) const {
-    const auto user_index = static_cast<std::size_t>(Settings::values.current_user);
    Service::Account::ProfileManager manager;
-    callback(manager.GetUser(user_index).value_or(Common::UUID{}));
+    callback(manager.GetUser(Settings::values.current_user).value_or(Common::UUID{}));
    LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
 }

@@ -47,7 +47,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
 FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
    u32 width, height;

-    if (Settings::values.use_docked_mode) {
+    if (Settings::values.use_docked_mode.GetValue()) {
        width = ScreenDocked::Width * res_scale;
        height = ScreenDocked::Height * res_scale;
    } else {
@@ -30,10 +30,10 @@ public:
    virtual StatusType GetStatus() const {
        return {};
    }
-    virtual bool GetAnalogDirectionStatus(AnalogDirection direction) const {
+    virtual bool GetAnalogDirectionStatus([[maybe_unused]] AnalogDirection direction) const {
        return {};
    }
-    virtual bool SetRumblePlay(f32 amp_high, f32 amp_low, f32 freq_high, f32 freq_low) const {
+    virtual bool SetRumblePlay(f32 amp_low, f32 freq_low, f32 amp_high, f32 freq_high) const {
        return {};
    }
 };
@@ -121,6 +121,13 @@ using ButtonDevice = InputDevice<bool>;
 */
 using AnalogDevice = InputDevice<std::tuple<float, float>>;

+/**
+ * A vibration device is an input device that returns an unsigned byte as status.
+ * It represents whether the vibration device supports vibration or not.
+ * If the status returns 1, it supports vibration. Otherwise, it does not support vibration.
+ */
+using VibrationDevice = InputDevice<u8>;
+
 /**
 * A motion status is an object that returns a tuple of accelerometer state vector,
 * gyroscope state vector, rotation state vector and orientation state matrix.
@@ -205,7 +205,7 @@ static Kernel::Thread* FindThreadById(s64 id) {
    const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
    for (auto& thread : threads) {
        if (thread->GetThreadID() == static_cast<u64>(id)) {
-            current_core = static_cast<u32>(thread->GetProcessorID());
+            current_core = thread->GetProcessorID();
            return thread.get();
        }
    }
@@ -457,14 +457,7 @@ static u128 GdbHexToU128(const u8* src) {
 /// Read a byte from the gdb client.
 static u8 ReadByte() {
    u8 c;
-
-#ifdef WIN32
-    const auto socket_id = static_cast<SOCKET>(gdbserver_socket);
-#else
-    const auto socket_id = gdbserver_socket;
-#endif
-
-    const auto received_size = recv(socket_id, reinterpret_cast<char*>(&c), 1, MSG_WAITALL);
+    std::size_t received_size = recv(gdbserver_socket, reinterpret_cast<char*>(&c), 1, MSG_WAITALL);
    if (received_size != 1) {
        LOG_ERROR(Debug_GDBStub, "recv failed: {}", received_size);
        Shutdown();
@@ -581,13 +574,7 @@ bool CheckBreakpoint(VAddr addr, BreakpointType type) {
 * @param packet Packet to be sent to client.
 */
 static void SendPacket(const char packet) {
-#ifdef WIN32
-    const auto socket_id = static_cast<SOCKET>(gdbserver_socket);
-#else
-    const auto socket_id = gdbserver_socket;
-#endif
-
-    const auto sent_size = send(socket_id, &packet, 1, 0);
+    std::size_t sent_size = send(gdbserver_socket, &packet, 1, 0);
    if (sent_size != 1) {
        LOG_ERROR(Debug_GDBStub, "send failed");
    }
@@ -624,13 +611,7 @@ static void SendReply(const char* reply) {
    u8* ptr = command_buffer;
    u32 left = command_length + 4;
    while (left > 0) {
-#ifdef WIN32
-        const auto socket_id = static_cast<SOCKET>(gdbserver_socket);
-#else
-        const auto socket_id = gdbserver_socket;
-#endif
-        const auto sent_size =
-            send(socket_id, reinterpret_cast<char*>(ptr), static_cast<socklen_t>(left), 0);
+        const auto sent_size = send(gdbserver_socket, reinterpret_cast<char*>(ptr), left, 0);
        if (sent_size < 0) {
            LOG_ERROR(Debug_GDBStub, "gdb: send failed");
            return Shutdown();
@@ -1313,13 +1294,8 @@ static void Init(u16 port) {
    WSAStartup(MAKEWORD(2, 2), &InitData);
 #endif

-#ifdef WIN32
-    using socket_type = SOCKET;
-#else
-    using socket_type = int;
-#endif
-    const auto tmpsock = static_cast<socket_type>(socket(PF_INET, SOCK_STREAM, 0));
-    if (tmpsock == static_cast<socket_type>(-1)) {
+    int tmpsock = static_cast<int>(socket(PF_INET, SOCK_STREAM, 0));
+    if (tmpsock == -1) {
        LOG_ERROR(Debug_GDBStub, "Failed to create gdb socket");
    }

@@ -1359,7 +1335,7 @@ static void Init(u16 port) {
    }

    // Clean up temporary socket if it's still alive at this point.
-    if (tmpsock != static_cast<socket_type>(-1)) {
+    if (tmpsock != -1) {
        shutdown(tmpsock, SHUT_RDWR);
    }
 }
@@ -1376,12 +1352,7 @@ void Shutdown() {

    LOG_INFO(Debug_GDBStub, "Stopping GDB ...");
    if (gdbserver_socket != -1) {
-#ifdef WIN32
-        const auto tmpsock = static_cast<SOCKET>(socket(PF_INET, SOCK_STREAM, 0));
-#else
-        const auto tmpsock = static_cast<int>(socket(PF_INET, SOCK_STREAM, 0));
-#endif
-        shutdown(tmpsock, SHUT_RDWR);
+        shutdown(gdbserver_socket, SHUT_RDWR);
        gdbserver_socket = -1;
    }

@@ -1412,7 +1383,7 @@ void SetCpuStepFlag(bool is_step) {
    step_loop = is_step;
 }

-void SendTrap(Kernel::Thread* thread, u32 trap) {
+void SendTrap(Kernel::Thread* thread, int trap) {
    if (!send_trap) {
        return;
    }
@@ -110,5 +110,5 @@ void SetCpuStepFlag(bool is_step);
 * @param thread Sending thread.
 * @param trap Trap no.
 */
-void SendTrap(Kernel::Thread* thread, u32 trap);
+void SendTrap(Kernel::Thread* thread, int trap);
 } // namespace GDBStub
@@ -12,7 +12,6 @@
 #include <utility>
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "core/core.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
@@ -73,14 +72,12 @@ public:
        AlwaysMoveHandles = 1,
    };

-    explicit ResponseBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
-
    explicit ResponseBuilder(Kernel::HLERequestContext& context, u32 normal_params_size,
                             u32 num_handles_to_copy = 0, u32 num_objects_to_move = 0,
                             Flags flags = Flags::None)
-
        : RequestHelperBase(context), normal_params_size(normal_params_size),
-          num_handles_to_copy(num_handles_to_copy), num_objects_to_move(num_objects_to_move) {
+          num_handles_to_copy(num_handles_to_copy),
+          num_objects_to_move(num_objects_to_move), kernel{context.kernel} {

        memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);

@@ -140,7 +137,6 @@ public:
        if (context->Session()->IsDomain()) {
            context->AddDomainObject(std::move(iface));
        } else {
-            auto& kernel = Core::System::GetInstance().Kernel();
            auto [client, server] = Kernel::Session::Create(kernel, iface->GetServiceName());
            context->AddMoveObject(std::move(client));
            iface->ClientConnected(std::move(server));
@@ -214,6 +210,7 @@ private:
    u32 num_handles_to_copy{};
    u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
    std::ptrdiff_t datapayload_index{};
+    Kernel::KernelCore& kernel;
 };

 /// Push ///
@@ -233,7 +230,7 @@ void ResponseBuilder::PushRaw(const T& value) {
    static_assert(std::is_trivially_copyable_v<T>,
                  "It's undefined behavior to use memcpy with non-trivially copyable objects");
    std::memcpy(cmdbuf + index, &value, sizeof(T));
-    index += static_cast<std::ptrdiff_t>((sizeof(T) + 3) / 4); // round up to word length
+    index += (sizeof(T) + 3) / 4; // round up to word length
 }

 template <>
@@ -390,7 +387,7 @@ void RequestParser::PopRaw(T& value) {
    static_assert(std::is_trivially_copyable_v<T>,
                  "It's undefined behavior to use memcpy with non-trivially copyable objects");
    std::memcpy(&value, cmdbuf + index, sizeof(T));
-    index += static_cast<std::ptrdiff_t>((sizeof(T) + 3) / 4); // round up to word length
+    index += (sizeof(T) + 3) / 4; // round up to word length
 }

 template <typename T>
@@ -108,7 +108,7 @@ ResultCode AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr a
    auto& monitor = system.Monitor();
    s32 updated_value;
    do {
-        updated_value = static_cast<s32>(monitor.ExclusiveRead32(current_core, address));
+        updated_value = monitor.ExclusiveRead32(current_core, address);

        if (updated_value != value) {
            return ERR_INVALID_STATE;
@@ -129,7 +129,7 @@ ResultCode AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr a
                updated_value = value;
            }
        }
-    } while (!monitor.ExclusiveWrite32(current_core, address, static_cast<u32>(updated_value)));
+    } while (!monitor.ExclusiveWrite32(current_core, address, updated_value));

    WakeThreads(waiting_threads, num_to_wake);
    return RESULT_SUCCESS;
@@ -68,7 +68,7 @@ ResultVal<Handle> HandleTable::Create(std::shared_ptr<Object> obj) {
    generations[slot] = generation;
    objects[slot] = std::move(obj);

-    const auto handle = static_cast<Handle>(generation | static_cast<u16>(slot << 15));
+    Handle handle = generation | (slot << 15);
    return MakeResult<Handle>(handle);
 }

@@ -58,7 +58,7 @@ std::shared_ptr<WritableEvent> HLERequestContext::SleepClientThread(

    {
        Handle event_handle = InvalidHandle;
-        SchedulerLockAndSleep lock(kernel, event_handle, thread.get(), static_cast<s64>(timeout));
+        SchedulerLockAndSleep lock(kernel, event_handle, thread.get(), timeout);
        thread->SetHLECallback(
            [context = *this, callback](std::shared_ptr<Thread> thread) mutable -> bool {
                ThreadWakeupReason reason = thread->GetSignalingResult() == RESULT_TIMEOUT
@@ -24,6 +24,10 @@ namespace Core::Memory {
 class Memory;
 }

+namespace IPC {
+class ResponseBuilder;
+}
+
 namespace Service {
 class ServiceFrameworkBase;
 }
@@ -287,6 +291,8 @@ public:
    }

 private:
+    friend class IPC::ResponseBuilder;
+
    void ParseCommandBuffer(const HandleTable& handle_table, u32_le* src_cmdbuf, bool incoming);

    std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
@@ -86,8 +86,6 @@ struct KernelCore::Impl {
        }
        cores.clear();

-        registered_core_threads.reset();
-
        process_list.clear();
        current_process = nullptr;

@@ -171,7 +169,7 @@ struct KernelCore::Impl {
            const auto type =
                static_cast<ThreadType>(THREADTYPE_KERNEL | THREADTYPE_HLE | THREADTYPE_SUSPEND);
            auto thread_res =
-                Thread::Create(system, type, std::move(name), 0, 0, 0, static_cast<s32>(i), 0,
+                Thread::Create(system, type, std::move(name), 0, 0, 0, static_cast<u32>(i), 0,
                               nullptr, std::move(init_func), init_func_parameter);

            suspend_threads[i] = std::move(thread_res).Unwrap();
@@ -199,9 +197,7 @@ struct KernelCore::Impl {
        const auto it = std::find(register_host_thread_keys.begin(), end, this_id);
        ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
        ASSERT(it == end);
-        ASSERT(!registered_core_threads[core_id]);
        InsertHostThread(static_cast<u32>(core_id));
-        registered_core_threads.set(core_id);
    }

    void RegisterHostThread() {
@@ -332,7 +328,6 @@ struct KernelCore::Impl {

    // 0-3 IDs represent core threads, >3 represent others
    std::atomic<u32> registered_thread_ids{Core::Hardware::NUM_CPU_CORES};
-    std::bitset<Core::Hardware::NUM_CPU_CORES> registered_core_threads;

    // Number of host threads is a relatively high number to avoid overflowing
    static constexpr size_t NUM_REGISTRABLE_HOST_THREADS = 64;
@@ -96,7 +96,6 @@ u64 AddressSpaceInfo::GetAddressSpaceStart(std::size_t width, Type type) {
        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].address;
    }
    UNREACHABLE();
-    return 0;
 }

 std::size_t AddressSpaceInfo::GetAddressSpaceSize(std::size_t width, Type type) {
@@ -113,7 +112,6 @@ std::size_t AddressSpaceInfo::GetAddressSpaceSize(std::size_t width, Type type)
        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].size;
    }
    UNREACHABLE();
-    return 0;
 }

 } // namespace Kernel::Memory
@@ -71,7 +71,7 @@ VAddr MemoryManager::AllocateContinuous(std::size_t num_pages, std::size_t align
    }

    // If we allocated more than we need, free some
-    const auto allocated_pages{PageHeap::GetBlockNumPages(static_cast<u32>(heap_index))};
+    const auto allocated_pages{PageHeap::GetBlockNumPages(heap_index)};
    if (allocated_pages > num_pages) {
        chosen_manager.Free(allocated_block + num_pages * PageSize, allocated_pages - num_pages);
    }
@@ -112,7 +112,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa

    // Keep allocating until we've allocated all our pages
    for (s32 index{heap_index}; index >= 0 && num_pages > 0; index--) {
-        const auto pages_per_alloc{PageHeap::GetBlockNumPages(static_cast<u32>(index))};
+        const auto pages_per_alloc{PageHeap::GetBlockNumPages(index)};

        while (num_pages >= pages_per_alloc) {
            // Allocate a block
--- a/Show More
+++ b/Show More