NvHost: Remake Ctrl Implementation.

NvHost: Try a different approach to blocking.
NvHost: Fix some regressions and correct signaling on timeout.
2021-11-01 00:51:29 +01:00 · 2021-10-30 16:32:51 +02:00 · 2021-10-30 11:16:49 +02:00
604 changed files with 31892 additions and 63414 deletions
@@ -25,7 +25,7 @@ def check_individual(repo_id, pr_id):

 def merge_pr(pn, ref):
    print("Matched PR# %s" % pn)
-    print(subprocess.check_output(["git", "fetch", "https://%sdev.azure.com/%s/_git/%s" % (user, org, repo), ref, "-f", "--no-recurse-submodules"]))
+    print(subprocess.check_output(["git", "fetch", "https://%sdev.azure.com/%s/_git/%s" % (user, org, repo), ref, "-f"]))
    print(subprocess.check_output(["git", "merge", "--squash", 'origin/' + ref.replace('refs/heads/','')]))
    print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))

@@ -1,7 +1,7 @@
 # Download all pull requests as patches that match a specific label
 # Usage: python download-patches-by-label.py <Label to Match> <Root Path Folder to DL to>

-import requests, sys, json, urllib3.request, shutil, subprocess, os, traceback
+import requests, sys, json, urllib3.request, shutil, subprocess, os

 tagline = sys.argv[2]

@@ -25,7 +25,7 @@ def do_page(page):
            if (check_individual(pr["labels"])):
                pn = pr["number"]
                print("Matched PR# %s" % pn)
-                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f", "--no-recurse-submodules"]))
+                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f"]))
                print(subprocess.check_output(["git", "merge", "--squash", "pr-%s" % pn]))
                print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))

@@ -33,5 +33,4 @@ try:
    for i in range(1,30):
        do_page(i)
 except:
-    traceback.print_exc(file=sys.stdout)
    sys.exit(-1)
@@ -41,11 +41,12 @@ for i in package/*.exe; do
 done

 pip3 install pefile
-python3 .ci/scripts/windows/scan_dll.py package/*.exe package/imageformats/*.dll "package/"
+python3 .ci/scripts/windows/scan_dll.py package/*.exe "package/"
+python3 .ci/scripts/windows/scan_dll.py package/imageformats/*.dll "package/"

 # copy FFmpeg libraries
 EXTERNALS_PATH="$(pwd)/build/externals"
-FFMPEG_DLL_PATH="$(find "${EXTERNALS_PATH}" -maxdepth 1 -type d | grep 'ffmpeg-')/bin"
+FFMPEG_DLL_PATH="$(find ${EXTERNALS_PATH} -maxdepth 1 -type d | grep ffmpeg)/bin"
 find ${FFMPEG_DLL_PATH} -type f -regex ".*\.dll" -exec cp -v {} package/ ';'

 # copy libraries from yuzu.exe path
@@ -34,12 +34,12 @@
 [submodule "opus"]
 	path = externals/opus/opus
 	url = https://github.com/xiph/opus.git
+[submodule "ffmpeg"]
+	path = externals/ffmpeg
+	url = https://git.ffmpeg.org/ffmpeg.git
 [submodule "SDL"]
 	path = externals/SDL
 	url = https://github.com/libsdl-org/SDL.git
 [submodule "externals/cpp-httplib"]
 	path = externals/cpp-httplib
 	url = https://github.com/yhirose/cpp-httplib.git
-[submodule "externals/ffmpeg/ffmpeg"]
-	path = externals/ffmpeg/ffmpeg
-	url = https://git.ffmpeg.org/ffmpeg.git
@@ -57,7 +57,7 @@ function(check_submodules_present)
        string(REGEX REPLACE "path *= *" "" module ${module})
        if (NOT EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
            message(FATAL_ERROR "Git submodule ${module} not found. "
-                    "Please run: \ngit submodule update --init --recursive")
+                    "Please run: git submodule update --init --recursive")
        endif()
    endforeach()
 endfunction()
@@ -131,7 +131,7 @@ add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
 if (MSVC)
    add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/std:c++latest>)

-    # boost still makes use of deprecated result_of.
+    # cubeb and boost still make use of deprecated result_of.
    add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
 else()
    set(CMAKE_CXX_STANDARD 20)
@@ -166,8 +166,8 @@ macro(yuzu_find_packages)
    # Capitalization matters here. We need the naming to match the generated paths from Conan
    set(REQUIRED_LIBS
    #    Cmake Pkg Prefix  Version     Conan Pkg
-        "Catch2            2.13.7      catch2/2.13.7"
-        "fmt               8.0.1       fmt/8.0.1"
+        "Catch2            2.13        catch2/2.13.0"
+        "fmt               8.0         fmt/8.0.0"
        "lz4               1.8         lz4/1.9.2"
        "nlohmann_json     3.8         nlohmann_json/3.8.0"
        "ZLIB              1.2         zlib/1.2.11"
@@ -249,7 +249,7 @@ if(ENABLE_QT)
    # Check for system Qt on Linux, fallback to bundled Qt
    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
        if (NOT YUZU_USE_BUNDLED_QT)
-            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets DBus)
+            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets)
        endif()
        if (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT)
            # Check for dependencies, then enable bundled Qt download
@@ -370,7 +370,7 @@ if (ENABLE_SDL2)
    if (YUZU_USE_BUNDLED_SDL2)
        # Detect toolchain and platform
        if ((MSVC_VERSION GREATER_EQUAL 1920 AND MSVC_VERSION LESS 1940) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.0.18")
+            set(SDL2_VER "SDL2-2.0.16")
        else()
            message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
        endif()
@@ -390,7 +390,7 @@ if (ENABLE_SDL2)
    elseif (YUZU_USE_EXTERNAL_SDL2)
        message(STATUS "Using SDL2 from externals.")
    else()
-        find_package(SDL2 2.0.18 REQUIRED)
+        find_package(SDL2 2.0.16 REQUIRED)

        # Some installations don't set SDL2_LIBRARIES
        if("${SDL2_LIBRARIES}" STREQUAL "")
@@ -508,13 +508,13 @@ set(FFmpeg_COMPONENTS
    avutil
    swscale)

-if (UNIX AND NOT APPLE)
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
    Include(FindPkgConfig REQUIRED)
    pkg_check_modules(LIBVA libva)
 endif()
 if (NOT YUZU_USE_BUNDLED_FFMPEG)
    # Use system installed FFmpeg
-    find_package(FFmpeg 4.3 QUIET COMPONENTS ${FFmpeg_COMPONENTS})
+    find_package(FFmpeg QUIET COMPONENTS ${FFmpeg_COMPONENTS})

    if (FFmpeg_FOUND)
        # Overwrite aggregate defines from FFmpeg module to avoid over-linking libraries.
@@ -527,11 +527,222 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
            set(FFmpeg_INCLUDE_DIR ${FFmpeg_INCLUDE_DIR} ${FFmpeg_INCLUDE_${COMPONENT}} CACHE PATH "Path to FFmpeg headers" FORCE)
        endforeach()
    else()
-        message(WARNING "FFmpeg not found or too old, falling back to externals")
+        message(WARNING "FFmpeg not found, falling back to externals")
        set(YUZU_USE_BUNDLED_FFMPEG ON)
    endif()
 endif()

+if (YUZU_USE_BUNDLED_FFMPEG)
+    if (NOT WIN32)
+        # TODO(lat9nq): Move this to externals/ffmpeg/CMakeLists.txt (and move externals/ffmpeg to
+        # externals/ffmpeg/ffmpeg)
+
+        # Build FFmpeg from externals
+        message(STATUS "Using FFmpeg from externals")
+
+        # FFmpeg has source that requires one of nasm or yasm to assemble it.
+        # REQUIRED throws an error if not found here during configuration rather than during compilation.
+        find_program(ASSEMBLER NAMES nasm yasm)
+        if ("${ASSEMBLER}" STREQUAL "ASSEMBLER-NOTFOUND")
+            message(FATAL_ERROR "One of either `nasm` or `yasm` not found but is required.")
+        endif()
+
+        find_program(AUTOCONF autoconf)
+        if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
+            message(FATAL_ERROR "Required program `autoconf` not found.")
+        endif()
+
+        set(FFmpeg_PREFIX ${PROJECT_SOURCE_DIR}/externals/ffmpeg)
+        set(FFmpeg_BUILD_DIR ${PROJECT_BINARY_DIR}/externals/ffmpeg)
+        set(FFmpeg_MAKEFILE ${FFmpeg_BUILD_DIR}/Makefile)
+        make_directory(${FFmpeg_BUILD_DIR})
+
+        # Read version string from external
+        file(READ ${FFmpeg_PREFIX}/RELEASE FFmpeg_VERSION)
+        set(FFmpeg_FOUND NO)
+        if (NOT FFmpeg_VERSION STREQUAL "")
+            set(FFmpeg_FOUND YES)
+        endif()
+
+        unset(FFmpeg_LIBRARIES CACHE)
+        foreach(COMPONENT ${FFmpeg_COMPONENTS})
+            set(FFmpeg_${COMPONENT}_PREFIX "${FFmpeg_BUILD_DIR}/lib${COMPONENT}")
+            set(FFmpeg_${COMPONENT}_LIB_NAME "lib${COMPONENT}.a")
+            set(FFmpeg_${COMPONENT}_LIBRARY "${FFmpeg_${COMPONENT}_PREFIX}/${FFmpeg_${COMPONENT}_LIB_NAME}")
+
+            set(FFmpeg_LIBRARIES
+                ${FFmpeg_LIBRARIES}
+                ${FFmpeg_${COMPONENT}_LIBRARY}
+                CACHE PATH "Paths to FFmpeg libraries" FORCE)
+        endforeach()
+
+        Include(FindPkgConfig REQUIRED)
+        pkg_check_modules(LIBVA libva)
+        pkg_check_modules(CUDA cuda)
+        pkg_check_modules(FFNVCODEC ffnvcodec)
+        pkg_check_modules(VDPAU vdpau)
+
+        set(FFmpeg_HWACCEL_LIBRARIES)
+        set(FFmpeg_HWACCEL_FLAGS)
+        set(FFmpeg_HWACCEL_INCLUDE_DIRS)
+        set(FFmpeg_HWACCEL_LDFLAGS)
+
+        if(LIBVA_FOUND)
+            pkg_check_modules(LIBDRM libdrm REQUIRED)
+            find_package(X11 REQUIRED)
+            pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
+            pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES
+                ${LIBDRM_LIBRARIES}
+                ${X11_LIBRARIES}
+                ${LIBVA-DRM_LIBRARIES}
+                ${LIBVA-X11_LIBRARIES}
+                ${LIBVA_LIBRARIES})
+            set(FFmpeg_HWACCEL_FLAGS
+                --enable-hwaccel=h264_vaapi
+                --enable-hwaccel=vp9_vaapi
+                --enable-libdrm)
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+                ${LIBDRM_INCLUDE_DIRS}
+                ${X11_INCLUDE_DIRS}
+                ${LIBVA-DRM_INCLUDE_DIRS}
+                ${LIBVA-X11_INCLUDE_DIRS}
+                ${LIBVA_INCLUDE_DIRS}
+            )
+            message(STATUS "VA-API found")
+        else()
+            set(FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+        endif()
+
+        if (FFNVCODEC_FOUND AND CUDA_FOUND)
+            list(APPEND FFmpeg_HWACCEL_FLAGS
+                --enable-cuvid
+                --enable-ffnvcodec
+                --enable-nvdec
+                --enable-hwaccel=h264_nvdec
+                --enable-hwaccel=vp9_nvdec
+                --extra-cflags=-I${CUDA_INCLUDE_DIRS}
+            )
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES
+                ${FFNVCODEC_LIBRARIES}
+                ${CUDA_LIBRARIES}
+            )
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+                ${FFNVCODEC_INCLUDE_DIRS}
+                ${CUDA_INCLUDE_DIRS}
+            )
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS
+                ${FFNVCODEC_LDFLAGS}
+                ${CUDA_LDFLAGS}
+            )
+            message(STATUS "ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
+        endif()
+
+        if (VDPAU_FOUND)
+            list(APPEND FFmpeg_HWACCEL_FLAGS
+                --enable-vdpau
+                --enable-hwaccel=h264_vdpau
+                --enable-hwaccel=vp9_vdpau
+            )
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
+            message(STATUS "vdpau libraries version ${VDPAU_VERSION} found")
+        else()
+            list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
+        endif()
+
+        # `configure` parameters builds only exactly what yuzu needs from FFmpeg
+        # `--disable-vdpau` is needed to avoid linking issues
+        add_custom_command(
+            OUTPUT
+                ${FFmpeg_MAKEFILE}
+            COMMAND
+                /bin/bash ${FFmpeg_PREFIX}/configure
+                    --disable-avdevice
+                    --disable-avfilter
+                    --disable-avformat
+                    --disable-doc
+                    --disable-everything
+                    --disable-ffmpeg
+                    --disable-ffprobe
+                    --disable-network
+                    --disable-postproc
+                    --disable-swresample
+                    --enable-decoder=h264
+                    --enable-decoder=vp9
+                    --cc="${CMAKE_C_COMPILER}"
+                    --cxx="${CMAKE_CXX_COMPILER}"
+                    ${FFmpeg_HWACCEL_FLAGS}
+            WORKING_DIRECTORY
+                ${FFmpeg_BUILD_DIR}
+        )
+        unset(FFmpeg_HWACCEL_FLAGS)
+
+        # Workaround for Ubuntu 18.04's older version of make not being able to call make as a child
+        # with context of the jobserver. Also helps ninja users.
+        execute_process(
+            COMMAND
+                nproc
+            OUTPUT_VARIABLE
+                SYSTEM_THREADS)
+
+        set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
+        add_custom_command(
+            OUTPUT
+                ${FFmpeg_BUILD_LIBRARIES}
+            COMMAND
+                make -j${SYSTEM_THREADS}
+            WORKING_DIRECTORY
+                ${FFmpeg_BUILD_DIR}
+        )
+
+        set(FFmpeg_INCLUDE_DIR
+            "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR};${FFmpeg_HWACCEL_INCLUDE_DIRS}"
+            CACHE PATH "Path to FFmpeg headers" FORCE)
+
+        set(FFmpeg_LDFLAGS
+            "${FFmpeg_HWACCEL_LDFLAGS}"
+            CACHE STRING "FFmpeg linker flags" FORCE)
+
+        # ALL makes this custom target build every time
+        # but it won't actually build if the DEPENDS parameter is up to date
+        add_custom_target(ffmpeg-configure ALL DEPENDS ${FFmpeg_MAKEFILE})
+        add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_BUILD_LIBRARIES} ffmpeg-configure)
+        link_libraries(${FFmpeg_LIBVA_LIBRARIES})
+        set(FFmpeg_LIBRARIES ${FFmpeg_BUILD_LIBRARIES} ${FFmpeg_HWACCEL_LIBRARIES}
+            CACHE PATH "Paths to FFmpeg libraries" FORCE)
+        unset(FFmpeg_BUILD_LIBRARIES)
+        unset(FFmpeg_HWACCEL_FLAGS)
+        unset(FFmpeg_HWACCEL_INCLUDE_DIRS)
+        unset(FFmpeg_HWACCEL_LDFLAGS)
+        unset(FFmpeg_HWACCEL_LIBRARIES)
+
+        if (FFmpeg_FOUND)
+            message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
+        else()
+            message(FATAL_ERROR "FFmpeg not found")
+        endif()
+    else() # WIN32
+        # Use yuzu FFmpeg binaries
+        set(FFmpeg_EXT_NAME "ffmpeg-4.4")
+        set(FFmpeg_PATH "${CMAKE_BINARY_DIR}/externals/${FFmpeg_EXT_NAME}")
+        download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "")
+        set(FFmpeg_FOUND YES)
+        set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
+        set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg library directory" FORCE)
+        set(FFmpeg_LDFLAGS "" CACHE STRING "FFmpeg linker flags" FORCE)
+        set(FFmpeg_DLL_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
+        set(FFmpeg_LIBRARIES
+            ${FFmpeg_LIBRARY_DIR}/swscale.lib
+            ${FFmpeg_LIBRARY_DIR}/avcodec.lib
+            ${FFmpeg_LIBRARY_DIR}/avutil.lib
+            CACHE PATH "Paths to FFmpeg libraries" FORCE)
+    endif()
+endif()
+
+unset(FFmpeg_COMPONENTS)
+
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
@@ -11,15 +11,9 @@ find_package(Git QUIET PATHS "${GIT_EXECUTABLE}")

 # generate git/build information
 include(GetGitRevisionDescription)
-if(NOT GIT_REF_SPEC)
-    get_git_head_revision(GIT_REF_SPEC GIT_REV)
-endif()
-if(NOT GIT_DESC)
-    git_describe(GIT_DESC --always --long --dirty)
-endif()
-if (NOT GIT_BRANCH)
-  git_branch_name(GIT_BRANCH)
-endif()
+get_git_head_revision(GIT_REF_SPEC GIT_REV)
+git_describe(GIT_DESC --always --long --dirty)
+git_branch_name(GIT_BRANCH)
 get_timestamp(BUILD_DATE)

 # Generate cpp with Git revision from template
@@ -17,7 +17,7 @@ It is written in C++ with portability in mind, and we actively maintain builds f
            alt="Azure Mainline CI Build Status">
    </a>
    <a href="https://discord.com/invite/u77vRWY">
-        <img src="https://img.shields.io/discord/398318088170242053?color=5865F2&label=yuzu&logo=discord&logoColor=white"
+        <img src="https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white"
            alt="Discord">
    </a>
 </p>
@@ -8,5 +8,5 @@ Icon=yuzu
 TryExec=yuzu
 Exec=yuzu %f
 Categories=Game;Emulator;Qt;
-MimeType=application/x-nx-nro;application/x-nx-nso;application/x-nx-nsp;application/x-nx-xci;
+MimeType=application/x-nx-nro;application/x-nx-nso;
 Keywords=Switch;Nintendo;
@@ -15,19 +15,4 @@
        <glob pattern="*.nso"/>
        <magic><match value="NSO" type="string" offset="0"/></magic>
    </mime-type>
-
-    <mime-type type="application/x-nx-nsp">
-        <comment>Nintendo Switch Package</comment>
-        <acronym>NSP</acronym>
-        <icon name="yuzu"/>
-        <glob pattern="*.nsp"/>
-        <magic><match value="PFS" type="string" offset="0"/></magic>
-    </mime-type>
-
-    <mime-type type="application/x-nx-xci">
-        <comment>Nintendo Switch Card Image</comment>
-        <acronym>XCI</acronym>
-        <icon name="yuzu"/>
-        <glob pattern="*.xci"/>
-    </mime-type>
 </mime-info>
@@ -44,6 +44,10 @@ target_include_directories(mbedtls PUBLIC ./mbedtls/include)
 add_library(microprofile INTERFACE)
 target_include_directories(microprofile INTERFACE ./microprofile)

+# Unicorn
+add_library(unicorn-headers INTERFACE)
+target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
+
 # libusb
 if (NOT LIBUSB_FOUND OR YUZU_USE_BUNDLED_LIBUSB)
    add_subdirectory(libusb)
@@ -52,12 +56,11 @@ endif()
 # SDL2
 if (YUZU_USE_EXTERNAL_SDL2)
    if (NOT WIN32)
-        # Yuzu itself needs: Atomic Audio Events Joystick Haptic Sensor Threads Timers
-        # Since 2.0.18 Atomic+Threads required for HIDAPI/libusb (see https://github.com/libsdl-org/SDL/issues/5095)
+        # Yuzu itself needs: Events Joystick Haptic Sensor Timers Audio
        # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
        set(SDL_UNUSED_SUBSYSTEMS
-            CPUinfo File Filesystem
-            Locale Power Render)
+            Atomic Render Power Threads
+            File CPUinfo Filesystem Locale)
        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
          string(TOUPPER ${_SUB} _OPT)
          option(SDL_${_OPT} "" OFF)
@@ -122,12 +125,3 @@ if (NOT opus_FOUND)
    message(STATUS "opus 1.3 or newer not found, falling back to externals")
    add_subdirectory(opus EXCLUDE_FROM_ALL)
 endif()
-
-# FFMpeg
-if (YUZU_USE_BUNDLED_FFMPEG)
-    add_subdirectory(ffmpeg)
-    set(FFmpeg_PATH "${FFmpeg_PATH}" PARENT_SCOPE)
-    set(FFmpeg_LDFLAGS "${FFmpeg_LDFLAGS}" PARENT_SCOPE)
-    set(FFmpeg_LIBRARIES "${FFmpeg_LIBRARIES}" PARENT_SCOPE)
-    set(FFmpeg_INCLUDE_DIR "${FFmpeg_INCLUDE_DIR}" PARENT_SCOPE)
-endif()
@@ -1,19 +0,0 @@
-Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
-
-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.
@@ -1,214 +0,0 @@
-if (NOT WIN32)
-    # Build FFmpeg from externals
-    message(STATUS "Using FFmpeg from externals")
-
-    if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64|amd64)")
-        # FFmpeg has source that requires one of nasm or yasm to assemble it.
-        # REQUIRED throws an error if not found here during configuration rather than during compilation.
-        find_program(ASSEMBLER NAMES nasm yasm)
-        if ("${ASSEMBLER}" STREQUAL "ASSEMBLER-NOTFOUND")
-            message(FATAL_ERROR "One of either `nasm` or `yasm` not found but is required.")
-        endif()
-    endif()
-
-    find_program(AUTOCONF autoconf)
-    if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
-        message(FATAL_ERROR "Required program `autoconf` not found.")
-    endif()
-
-    set(FFmpeg_PREFIX ${PROJECT_SOURCE_DIR}/externals/ffmpeg/ffmpeg)
-    set(FFmpeg_BUILD_DIR ${PROJECT_BINARY_DIR}/externals/ffmpeg-build)
-    set(FFmpeg_MAKEFILE ${FFmpeg_BUILD_DIR}/Makefile)
-    make_directory(${FFmpeg_BUILD_DIR})
-
-    # Read version string from external
-    file(READ ${FFmpeg_PREFIX}/RELEASE FFmpeg_VERSION)
-    set(FFmpeg_FOUND NO)
-    if (NOT FFmpeg_VERSION STREQUAL "")
-        set(FFmpeg_FOUND YES)
-    endif()
-
-    unset(FFmpeg_LIBRARIES CACHE)
-    foreach(COMPONENT ${FFmpeg_COMPONENTS})
-        set(FFmpeg_${COMPONENT}_PREFIX "${FFmpeg_BUILD_DIR}/lib${COMPONENT}")
-        set(FFmpeg_${COMPONENT}_LIB_NAME "lib${COMPONENT}.a")
-        set(FFmpeg_${COMPONENT}_LIBRARY "${FFmpeg_${COMPONENT}_PREFIX}/${FFmpeg_${COMPONENT}_LIB_NAME}")
-
-        set(FFmpeg_LIBRARIES
-            ${FFmpeg_LIBRARIES}
-            ${FFmpeg_${COMPONENT}_LIBRARY}
-            CACHE PATH "Paths to FFmpeg libraries" FORCE)
-    endforeach()
-
-    Include(FindPkgConfig REQUIRED)
-    pkg_check_modules(LIBVA libva)
-    pkg_check_modules(CUDA cuda)
-    pkg_check_modules(FFNVCODEC ffnvcodec)
-    pkg_check_modules(VDPAU vdpau)
-
-    set(FFmpeg_HWACCEL_LIBRARIES)
-    set(FFmpeg_HWACCEL_FLAGS)
-    set(FFmpeg_HWACCEL_INCLUDE_DIRS)
-    set(FFmpeg_HWACCEL_LDFLAGS)
-
-    if(LIBVA_FOUND)
-        pkg_check_modules(LIBDRM libdrm REQUIRED)
-        find_package(X11 REQUIRED)
-        pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
-        pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
-        list(APPEND FFmpeg_HWACCEL_LIBRARIES
-            ${LIBDRM_LIBRARIES}
-            ${X11_LIBRARIES}
-            ${LIBVA-DRM_LIBRARIES}
-            ${LIBVA-X11_LIBRARIES}
-            ${LIBVA_LIBRARIES})
-        set(FFmpeg_HWACCEL_FLAGS
-            --enable-hwaccel=h264_vaapi
-            --enable-hwaccel=vp8_vaapi
-            --enable-hwaccel=vp9_vaapi
-            --enable-libdrm)
-        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-            ${LIBDRM_INCLUDE_DIRS}
-            ${X11_INCLUDE_DIRS}
-            ${LIBVA-DRM_INCLUDE_DIRS}
-            ${LIBVA-X11_INCLUDE_DIRS}
-            ${LIBVA_INCLUDE_DIRS}
-        )
-        message(STATUS "VA-API found")
-    else()
-        set(FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-    endif()
-
-    if (FFNVCODEC_FOUND)
-        list(APPEND FFmpeg_HWACCEL_FLAGS
-            --enable-cuvid
-            --enable-ffnvcodec
-            --enable-nvdec
-            --enable-hwaccel=h264_nvdec
-            --enable-hwaccel=vp8_nvdec
-            --enable-hwaccel=vp9_nvdec
-        )
-        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${FFNVCODEC_LIBRARIES})
-        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${FFNVCODEC_INCLUDE_DIRS})
-        list(APPEND FFmpeg_HWACCEL_LDFLAGS ${FFNVCODEC_LDFLAGS})
-        message(STATUS "ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
-        # ffnvenc could load CUDA libraries at the runtime using dlopen/dlsym or LoadLibrary/GetProcAddress
-        # here we handle the hard-linking senario where CUDA is linked during compilation
-        if (CUDA_FOUND)
-            list(APPEND FFmpeg_HWACCEL_FLAGS --extra-cflags=-I${CUDA_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${CUDA_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${CUDA_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${CUDA_LDFLAGS})
-            message(STATUS "CUDA libraries found, hard-linking will be performed")
-        endif(CUDA_FOUND)
-    endif()
-
-    if (VDPAU_FOUND)
-        list(APPEND FFmpeg_HWACCEL_FLAGS
-            --enable-vdpau
-            --enable-hwaccel=h264_vdpau
-            --enable-hwaccel=vp9_vdpau
-        )
-        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
-        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
-        list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
-        message(STATUS "vdpau libraries version ${VDPAU_VERSION} found")
-    else()
-        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
-    endif()
-
-    # `configure` parameters builds only exactly what yuzu needs from FFmpeg
-    # `--disable-vdpau` is needed to avoid linking issues
-    add_custom_command(
-        OUTPUT
-            ${FFmpeg_MAKEFILE}
-        COMMAND
-            /bin/bash ${FFmpeg_PREFIX}/configure
-                --disable-avdevice
-                --disable-avfilter
-                --disable-avformat
-                --disable-doc
-                --disable-everything
-                --disable-ffmpeg
-                --disable-ffprobe
-                --disable-network
-                --disable-postproc
-                --disable-swresample
-                --enable-decoder=h264
-                --enable-decoder=vp8
-                --enable-decoder=vp9
-                --cc="${CMAKE_C_COMPILER}"
-                --cxx="${CMAKE_CXX_COMPILER}"
-                ${FFmpeg_HWACCEL_FLAGS}
-        WORKING_DIRECTORY
-            ${FFmpeg_BUILD_DIR}
-    )
-    unset(FFmpeg_HWACCEL_FLAGS)
-
-    # Workaround for Ubuntu 18.04's older version of make not being able to call make as a child
-    # with context of the jobserver. Also helps ninja users.
-    execute_process(
-        COMMAND
-            nproc
-        OUTPUT_VARIABLE
-            SYSTEM_THREADS)
-
-    set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
-    add_custom_command(
-        OUTPUT
-            ${FFmpeg_BUILD_LIBRARIES}
-        COMMAND
-            make -j${SYSTEM_THREADS}
-        WORKING_DIRECTORY
-            ${FFmpeg_BUILD_DIR}
-    )
-
-    set(FFmpeg_INCLUDE_DIR
-        "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR};${FFmpeg_HWACCEL_INCLUDE_DIRS}"
-        CACHE PATH "Path to FFmpeg headers" FORCE)
-
-    set(FFmpeg_LDFLAGS
-        "${FFmpeg_HWACCEL_LDFLAGS}"
-        CACHE STRING "FFmpeg linker flags" FORCE)
-
-    # ALL makes this custom target build every time
-    # but it won't actually build if the DEPENDS parameter is up to date
-    add_custom_target(ffmpeg-configure ALL DEPENDS ${FFmpeg_MAKEFILE})
-    add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_BUILD_LIBRARIES} ffmpeg-configure)
-    link_libraries(${FFmpeg_LIBVA_LIBRARIES})
-    set(FFmpeg_LIBRARIES ${FFmpeg_BUILD_LIBRARIES} ${FFmpeg_HWACCEL_LIBRARIES}
-        CACHE PATH "Paths to FFmpeg libraries" FORCE)
-    unset(FFmpeg_BUILD_LIBRARIES)
-    unset(FFmpeg_HWACCEL_FLAGS)
-    unset(FFmpeg_HWACCEL_INCLUDE_DIRS)
-    unset(FFmpeg_HWACCEL_LDFLAGS)
-    unset(FFmpeg_HWACCEL_LIBRARIES)
-
-    if (FFmpeg_FOUND)
-        message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
-    else()
-        message(FATAL_ERROR "FFmpeg not found")
-    endif()
-else(WIN32)
-    # Use yuzu FFmpeg binaries
-    set(FFmpeg_EXT_NAME "ffmpeg-4.4")
-    set(FFmpeg_PATH "${CMAKE_BINARY_DIR}/externals/${FFmpeg_EXT_NAME}")
-    download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "")
-    set(FFmpeg_FOUND YES)
-    set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
-    set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg library directory" FORCE)
-    set(FFmpeg_LDFLAGS "" CACHE STRING "FFmpeg linker flags" FORCE)
-    set(FFmpeg_DLL_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
-    set(FFmpeg_LIBRARIES
-    ${FFmpeg_LIBRARY_DIR}/swscale.lib
-    ${FFmpeg_LIBRARY_DIR}/avcodec.lib
-    ${FFmpeg_LIBRARY_DIR}/avutil.lib
-    CACHE PATH "Paths to FFmpeg libraries" FORCE)
-    # exported variables
-    set(FFmpeg_PATH "${FFmpeg_PATH}" PARENT_SCOPE)
-    set(FFmpeg_LDFLAGS "${FFmpeg_LDFLAGS}" PARENT_SCOPE)
-    set(FFmpeg_LIBRARIES "${FFmpeg_LIBRARIES}" PARENT_SCOPE)
-    set(FFmpeg_INCLUDE_DIR "${FFmpeg_INCLUDE_DIR}" PARENT_SCOPE)
-endif(WIN32)
-
-unset(FFmpeg_COMPONENTS)
@@ -0,0 +1,18 @@
+# Exports:
+#  LIBUNICORN_FOUND
+#  LIBUNICORN_INCLUDE_DIR
+#  LIBUNICORN_LIBRARY
+
+find_path(LIBUNICORN_INCLUDE_DIR
+          unicorn/unicorn.h
+          HINTS $ENV{UNICORNDIR}
+          PATH_SUFFIXES include)
+
+find_library(LIBUNICORN_LIBRARY
+             NAMES unicorn
+             HINTS $ENV{UNICORNDIR})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(unicorn DEFAULT_MSG
+                                  LIBUNICORN_LIBRARY LIBUNICORN_INCLUDE_DIR)
+mark_as_advanced(LIBUNICORN_INCLUDE_DIR LIBUNICORN_LIBRARY)
@@ -24,7 +24,6 @@ if (MSVC)
    # /W3                 - Level 3 warnings
    # /MP                 - Multi-threaded compilation
    # /Zi                 - Output debugging information
-    # /Zm                 - Specifies the precompiled header memory allocation limit
    # /Zo                 - Enhanced debug info for optimized builds
    # /permissive-        - Enables stricter C++ standards conformance checks
    # /EHsc               - C++-only exception handling semantics
@@ -33,11 +32,9 @@ if (MSVC)
    # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
    # /Zc:inline          - Let codegen omit inline functions in object files
    # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
-    # /GT                 - Supports fiber safety for data allocated using static thread-local storage
    add_compile_options(
        /MP
        /Zi
-        /Zm200
        /Zo
        /permissive-
        /EHsc
@@ -47,7 +44,6 @@ if (MSVC)
        /Zc:externConstexpr
        /Zc:inline
        /Zc:throwingNew
-        /GT

        # External headers diagnostics
        /experimental:external  # Enables the external headers options. This option isn't required in Visual Studio 2019 version 16.10 and later
@@ -73,10 +69,6 @@ if (MSVC)
        /we5038 # data member 'member1' will be initialized after data member 'member2'
    )

-    if (ARCHITECTURE_x86_64)
-        add_compile_options(/QIntel-jcc-erratum)
-    endif()
-
    # /GS- - No stack buffer overflow checks
    add_compile_options("$<$<CONFIG:Release>:/GS->")

@@ -1,7 +1,3 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
 #include <cstring>
 #include "audio_core/delay_line.h"

@@ -1,7 +1,3 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
 #pragma once

 #include "common/common_types.h"
@@ -22,11 +22,6 @@ add_custom_command(OUTPUT scm_rev.cpp
      -DTITLE_BAR_FORMAT_RUNNING=${TITLE_BAR_FORMAT_RUNNING}
      -DBUILD_TAG=${BUILD_TAG}
      -DBUILD_ID=${DISPLAY_VERSION}
-      -DGIT_REF_SPEC=${GIT_REF_SPEC}
-      -DGIT_REV=${GIT_REV}
-      -DGIT_DESC=${GIT_DESC}
-      -DGIT_BRANCH=${GIT_BRANCH}
-      -DBUILD_FULLNAME=${BUILD_FULLNAME}
      -DGIT_EXECUTABLE=${GIT_EXECUTABLE}
      -P ${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake
    DEPENDS
@@ -60,7 +55,6 @@ add_library(common STATIC
    dynamic_library.h
    error.cpp
    error.h
-    expected.h
    fiber.cpp
    fiber.h
    fs/file.cpp
@@ -78,7 +72,6 @@ add_library(common STATIC
    hex_util.h
    host_memory.cpp
    host_memory.h
-    input.h
    intrusive_red_black_tree.h
    literals.h
    logging/backend.cpp
@@ -7,7 +7,6 @@
 #include <bit>
 #include <climits>
 #include <cstddef>
-#include <type_traits>

 #include "common/common_types.h"

@@ -45,10 +44,4 @@ template <typename T>
    return static_cast<u32>(log2_f + static_cast<u64>((value ^ (1ULL << log2_f)) != 0ULL));
 }

-template <typename T>
-requires std::is_integral_v<T>
-[[nodiscard]] T NextPow2(T value) {
-    return static_cast<T>(1ULL << ((8U * sizeof(T)) - std::countl_zero(value - 1U)));
-}
-
 } // namespace Common
@@ -1,987 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This is based on the proposed implementation of std::expected (P0323)
-// https://github.com/TartanLlama/expected/blob/master/include/tl/expected.hpp
-
-#pragma once
-
-#include <type_traits>
-#include <utility>
-
-namespace Common {
-
-template <typename T, typename E>
-class Expected;
-
-template <typename E>
-class Unexpected {
-public:
-    Unexpected() = delete;
-
-    constexpr explicit Unexpected(const E& e) : m_val{e} {}
-
-    constexpr explicit Unexpected(E&& e) : m_val{std::move(e)} {}
-
-    constexpr E& value() & {
-        return m_val;
-    }
-
-    constexpr const E& value() const& {
-        return m_val;
-    }
-
-    constexpr E&& value() && {
-        return std::move(m_val);
-    }
-
-    constexpr const E&& value() const&& {
-        return std::move(m_val);
-    }
-
-private:
-    E m_val;
-};
-
-template <typename E>
-constexpr auto operator<=>(const Unexpected<E>& lhs, const Unexpected<E>& rhs) {
-    return lhs.value() <=> rhs.value();
-}
-
-struct unexpect_t {
-    constexpr explicit unexpect_t() = default;
-};
-
-namespace detail {
-
-struct no_init_t {
-    constexpr explicit no_init_t() = default;
-};
-
-/**
- * This specialization is for when T is not trivially destructible,
- * so the destructor must be called on destruction of `expected'
- * Additionally, this requires E to be trivially destructible
- */
-template <typename T, typename E, bool = std::is_trivially_destructible_v<T>>
-requires std::is_trivially_destructible_v<E>
-struct expected_storage_base {
-    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
-
-    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr expected_storage_base(std::in_place_t, Args&&... args)
-        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
-        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
-                                             Args&&... args)
-        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
-
-    ~expected_storage_base() {
-        if (m_has_val) {
-            m_val.~T();
-        }
-    }
-
-    union {
-        T m_val;
-        Unexpected<E> m_unexpect;
-    };
-
-    bool m_has_val;
-};
-
-/**
- * This specialization is for when T is trivially destructible,
- * so the destructor of `expected` can be trivial
- * Additionally, this requires E to be trivially destructible
- */
-template <typename T, typename E>
-requires std::is_trivially_destructible_v<E>
-struct expected_storage_base<T, E, true> {
-    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
-
-    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr expected_storage_base(std::in_place_t, Args&&... args)
-        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
-        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
-                                             Args&&... args)
-        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
-
-    ~expected_storage_base() = default;
-
-    union {
-        T m_val;
-        Unexpected<E> m_unexpect;
-    };
-
-    bool m_has_val;
-};
-
-template <typename T, typename E>
-struct expected_operations_base : expected_storage_base<T, E> {
-    using expected_storage_base<T, E>::expected_storage_base;
-
-    template <typename... Args>
-    void construct(Args&&... args) noexcept {
-        new (std::addressof(this->m_val)) T{std::forward<Args>(args)...};
-        this->m_has_val = true;
-    }
-
-    template <typename Rhs>
-    void construct_with(Rhs&& rhs) noexcept {
-        new (std::addressof(this->m_val)) T{std::forward<Rhs>(rhs).get()};
-        this->m_has_val = true;
-    }
-
-    template <typename... Args>
-    void construct_error(Args&&... args) noexcept {
-        new (std::addressof(this->m_unexpect)) Unexpected<E>{std::forward<Args>(args)...};
-        this->m_has_val = false;
-    }
-
-    void assign(const expected_operations_base& rhs) noexcept {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~Unexpected<E>();
-            construct(rhs.get());
-        } else {
-            assign_common(rhs);
-        }
-    }
-
-    void assign(expected_operations_base&& rhs) noexcept {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~Unexpected<E>();
-            construct(std::move(rhs).get());
-        } else {
-            assign_common(rhs);
-        }
-    }
-
-    template <typename Rhs>
-    void assign_common(Rhs&& rhs) {
-        if (this->m_has_val) {
-            if (rhs.m_has_val) {
-                get() = std::forward<Rhs>(rhs).get();
-            } else {
-                destroy_val();
-                construct_error(std::forward<Rhs>(rhs).geterr());
-            }
-        } else {
-            if (!rhs.m_has_val) {
-                geterr() = std::forward<Rhs>(rhs).geterr();
-            }
-        }
-    }
-
-    bool has_value() const {
-        return this->m_has_val;
-    }
-
-    constexpr T& get() & {
-        return this->m_val;
-    }
-
-    constexpr const T& get() const& {
-        return this->m_val;
-    }
-
-    constexpr T&& get() && {
-        return std::move(this->m_val);
-    }
-
-    constexpr const T&& get() const&& {
-        return std::move(this->m_val);
-    }
-
-    constexpr Unexpected<E>& geterr() & {
-        return this->m_unexpect;
-    }
-
-    constexpr const Unexpected<E>& geterr() const& {
-        return this->m_unexpect;
-    }
-
-    constexpr Unexpected<E>&& geterr() && {
-        return std::move(this->m_unexpect);
-    }
-
-    constexpr const Unexpected<E>&& geterr() const&& {
-        return std::move(this->m_unexpect);
-    }
-
-    constexpr void destroy_val() {
-        get().~T();
-    }
-};
-
-/**
- * This manages conditionally having a trivial copy constructor
- * This specialization is for when T is trivially copy constructible
- * Additionally, this requires E to be trivially copy constructible
- */
-template <typename T, typename E, bool = std::is_trivially_copy_constructible_v<T>>
-requires std::is_trivially_copy_constructible_v<E>
-struct expected_copy_base : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-};
-
-/**
- * This specialization is for when T is not trivially copy constructible
- * Additionally, this requires E to be trivially copy constructible
- */
-template <typename T, typename E>
-requires std::is_trivially_copy_constructible_v<E>
-struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-
-    expected_copy_base() = default;
-
-    expected_copy_base(const expected_copy_base& rhs)
-        : expected_operations_base<T, E>{no_init_t{}} {
-        if (rhs.has_value()) {
-            this->construct_with(rhs);
-        } else {
-            this->construct_error(rhs.geterr());
-        }
-    }
-
-    expected_copy_base(expected_copy_base&&) = default;
-
-    expected_copy_base& operator=(const expected_copy_base&) = default;
-
-    expected_copy_base& operator=(expected_copy_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial move constructor
- * This specialization is for when T is trivially move constructible
- * Additionally, this requires E to be trivially move constructible
- */
-template <typename T, typename E, bool = std::is_trivially_move_constructible_v<T>>
-requires std::is_trivially_move_constructible_v<E>
-struct expected_move_base : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
-};
-
-/**
- * This specialization is for when T is not trivially move constructible
- * Additionally, this requires E to be trivially move constructible
- */
-template <typename T, typename E>
-requires std::is_trivially_move_constructible_v<E>
-struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
-
-    expected_move_base() = default;
-
-    expected_move_base(const expected_move_base&) = default;
-
-    expected_move_base(expected_move_base&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
-        : expected_copy_base<T, E>{no_init_t{}} {
-        if (rhs.has_value()) {
-            this->construct_with(std::move(rhs));
-        } else {
-            this->construct_error(std::move(rhs.geterr()));
-        }
-    }
-
-    expected_move_base& operator=(const expected_move_base&) = default;
-
-    expected_move_base& operator=(expected_move_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial copy assignment operator
- * This specialization is for when T is trivially copy assignable
- * Additionally, this requires E to be trivially copy assignable
- */
-template <typename T, typename E,
-          bool = std::conjunction_v<std::is_trivially_copy_assignable<T>,
-                                    std::is_trivially_copy_constructible<T>,
-                                    std::is_trivially_destructible<T>>>
-requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
-                            std::is_trivially_copy_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_copy_assign_base : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-};
-
-/**
- * This specialization is for when T is not trivially copy assignable
- * Additionally, this requires E to be trivially copy assignable
- */
-template <typename T, typename E>
-requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
-                            std::is_trivially_copy_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-
-    expected_copy_assign_base() = default;
-
-    expected_copy_assign_base(const expected_copy_assign_base&) = default;
-
-    expected_copy_assign_base(expected_copy_assign_base&&) = default;
-
-    expected_copy_assign_base& operator=(const expected_copy_assign_base& rhs) {
-        this->assign(rhs);
-        return *this;
-    }
-
-    expected_copy_assign_base& operator=(expected_copy_assign_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial move assignment operator
- * This specialization is for when T is trivially move assignable
- * Additionally, this requires E to be trivially move assignable
- */
-template <typename T, typename E,
-          bool = std::conjunction_v<std::is_trivially_move_assignable<T>,
-                                    std::is_trivially_move_constructible<T>,
-                                    std::is_trivially_destructible<T>>>
-requires std::conjunction_v<std::is_trivially_move_assignable<E>,
-                            std::is_trivially_move_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_move_assign_base : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-};
-
-/**
- * This specialization is for when T is not trivially move assignable
- * Additionally, this requires E to be trivially move assignable
- */
-template <typename T, typename E>
-requires std::conjunction_v<std::is_trivially_move_assignable<E>,
-                            std::is_trivially_move_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_move_assign_base<T, E, false> : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-
-    expected_move_assign_base() = default;
-
-    expected_move_assign_base(const expected_move_assign_base&) = default;
-
-    expected_move_assign_base(expected_move_assign_base&&) = default;
-
-    expected_move_assign_base& operator=(const expected_move_assign_base&) = default;
-
-    expected_move_assign_base& operator=(expected_move_assign_base&& rhs) noexcept(
-        std::conjunction_v<std::is_nothrow_move_constructible<T>,
-                           std::is_nothrow_move_assignable<T>>) {
-        this->assign(std::move(rhs));
-        return *this;
-    }
-};
-
-/**
- * expected_delete_ctor_base will conditionally delete copy and move constructors
- * depending on whether T is copy/move constructible
- * Additionally, this requires E to be copy/move constructible
- */
-template <typename T, typename E, bool EnableCopy = std::is_copy_constructible_v<T>,
-          bool EnableMove = std::is_move_constructible_v<T>>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, true, false> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, false, true> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, false, false> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-/**
- * expected_delete_assign_base will conditionally delete copy and move assignment operators
- * depending on whether T is copy/move constructible + assignable
- * Additionally, this requires E to be copy/move constructible + assignable
- */
-template <
-    typename T, typename E,
-    bool EnableCopy = std::conjunction_v<std::is_copy_constructible<T>, std::is_copy_assignable<T>>,
-    bool EnableMove = std::conjunction_v<std::is_move_constructible<T>, std::is_move_assignable<T>>>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, true, false> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, false, true> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, false, false> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
-};
-
-/**
- * This is needed to be able to construct the expected_default_ctor_base which follows,
- * while still conditionally deleting the default constructor.
- */
-struct default_constructor_tag {
-    constexpr explicit default_constructor_tag() = default;
-};
-
-/**
- * expected_default_ctor_base will ensure that expected
- * has a deleted default constructor if T is not default constructible
- * This specialization is for when T is default constructible
- */
-template <typename T, typename E, bool Enable = std::is_default_constructible_v<T>>
-struct expected_default_ctor_base {
-    constexpr expected_default_ctor_base() noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-template <typename T, typename E>
-struct expected_default_ctor_base<T, E, false> {
-    constexpr expected_default_ctor_base() noexcept = delete;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-template <typename T, typename E, typename U>
-using expected_enable_forward_value =
-    std::enable_if_t<std::is_constructible_v<T, U&&> &&
-                     !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&
-                     !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                     !std::is_same_v<Unexpected<E>, std::remove_cvref_t<U>>>;
-
-template <typename T, typename E, typename U, typename G, typename UR, typename GR>
-using expected_enable_from_other = std::enable_if_t<
-    std::is_constructible_v<T, UR> && std::is_constructible_v<E, GR> &&
-    !std::is_constructible_v<T, Expected<U, G>&> && !std::is_constructible_v<T, Expected<U, G>&&> &&
-    !std::is_constructible_v<T, const Expected<U, G>&> &&
-    !std::is_constructible_v<T, const Expected<U, G>&&> &&
-    !std::is_convertible_v<Expected<U, G>&, T> && !std::is_convertible_v<Expected<U, G>&&, T> &&
-    !std::is_convertible_v<const Expected<U, G>&, T> &&
-    !std::is_convertible_v<const Expected<U, G>&&, T>>;
-
-} // namespace detail
-
-template <typename T, typename E>
-class Expected : private detail::expected_move_assign_base<T, E>,
-                 private detail::expected_delete_ctor_base<T, E>,
-                 private detail::expected_delete_assign_base<T, E>,
-                 private detail::expected_default_ctor_base<T, E> {
-public:
-    using value_type = T;
-    using error_type = E;
-    using unexpected_type = Unexpected<E>;
-
-    constexpr Expected() = default;
-    constexpr Expected(const Expected&) = default;
-    constexpr Expected(Expected&&) = default;
-    Expected& operator=(const Expected&) = default;
-    Expected& operator=(Expected&&) = default;
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr Expected(std::in_place_t, Args&&... args)
-        : impl_base{std::in_place, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr Expected(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : impl_base{std::in_place, il, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
-              std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr>
-    constexpr explicit Expected(const Unexpected<G>& e)
-        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
-              std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr>
-    constexpr Expected(Unexpected<G> const& e)
-        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
-              std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
-    constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-                                                             detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
-              std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
-    constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-                                                             detail::default_constructor_tag{}} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit Expected(unexpect_t, Args&&... args)
-        : impl_base{unexpect_t{}, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit Expected(unexpect_t, std::initializer_list<U> il, Args&&... args)
-        : impl_base{unexpect_t{}, il, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename G,
-              std::enable_if_t<!(std::is_convertible_v<U const&, T> &&
-                                 std::is_convertible_v<G const&, E>)>* = nullptr,
-              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
-    constexpr explicit Expected(const Expected<U, G>& rhs)
-        : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<(std::is_convertible_v<U const&, T> &&
-                                std::is_convertible_v<G const&, E>)>* = nullptr,
-              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
-    constexpr Expected(const Expected<U, G>& rhs) : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<!(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
-                  nullptr,
-              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
-    constexpr explicit Expected(Expected<U, G>&& rhs)
-        : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
-                  nullptr,
-              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
-    constexpr Expected(Expected<U, G>&& rhs) : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template <typename U = T, std::enable_if_t<!std::is_convertible_v<U&&, T>>* = nullptr,
-              detail::expected_enable_forward_value<T, E, U>* = nullptr>
-    constexpr explicit Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
-
-    template <typename U = T, std::enable_if_t<std::is_convertible_v<U&&, T>>* = nullptr,
-              detail::expected_enable_forward_value<T, E, U>* = nullptr>
-    constexpr Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
-
-    template <typename U = T, typename G = T,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
-              std::enable_if_t<(
-                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
-                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
-                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
-    Expected& operator=(U&& v) {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<U>(v)};
-            this->m_has_val = true;
-        }
-
-        return *this;
-    }
-
-    template <typename U = T, typename G = T,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
-              std::enable_if_t<(
-                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
-                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
-                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
-    Expected& operator=(U&& v) {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<U>(v)};
-            this->m_has_val = true;
-        }
-
-        return *this;
-    }
-
-    template <typename G = E, std::enable_if_t<std::is_nothrow_copy_constructible_v<G> &&
-                                               std::is_assignable_v<G&, G>>* = nullptr>
-    Expected& operator=(const Unexpected<G>& rhs) {
-        if (!has_value()) {
-            err() = rhs;
-        } else {
-            this->destroy_val();
-            new (errptr()) Unexpected<E>{rhs};
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template <typename G = E, std::enable_if_t<std::is_nothrow_move_constructible_v<G> &&
-                                               std::is_move_assignable_v<G>>* = nullptr>
-    Expected& operator=(Unexpected<G>&& rhs) noexcept {
-        if (!has_value()) {
-            err() = std::move(rhs);
-        } else {
-            this->destroy_val();
-            new (errptr()) Unexpected<E>{std::move(rhs)};
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template <typename... Args,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
-    void emplace(Args&&... args) {
-        if (has_value()) {
-            val() = T{std::forward<Args>(args)...};
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename... Args,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
-    void emplace(Args&&... args) {
-        if (has_value()) {
-            val() = T{std::forward<Args>(args)...};
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
-                                                               Args&&...>>* = nullptr>
-    void emplace(std::initializer_list<U> il, Args&&... args) {
-        if (has_value()) {
-            T t{il, std::forward<Args>(args)...};
-            val() = std::move(t);
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{il, std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename U, typename... Args,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
-                                                                Args&&...>>* = nullptr>
-    void emplace(std::initializer_list<U> il, Args&&... args) {
-        if (has_value()) {
-            T t{il, std::forward<Args>(args)...};
-            val() = std::move(t);
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{il, std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    constexpr T* operator->() {
-        return valptr();
-    }
-
-    constexpr const T* operator->() const {
-        return valptr();
-    }
-
-    template <typename U = T>
-    constexpr U& operator*() & {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr const U& operator*() const& {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr U&& operator*() && {
-        return std::move(val());
-    }
-
-    template <typename U = T>
-    constexpr const U&& operator*() const&& {
-        return std::move(val());
-    }
-
-    constexpr bool has_value() const noexcept {
-        return this->m_has_val;
-    }
-
-    constexpr explicit operator bool() const noexcept {
-        return this->m_has_val;
-    }
-
-    template <typename U = T>
-    constexpr U& value() & {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr const U& value() const& {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr U&& value() && {
-        return std::move(val());
-    }
-
-    template <typename U = T>
-    constexpr const U&& value() const&& {
-        return std::move(val());
-    }
-
-    constexpr E& error() & {
-        return err().value();
-    }
-
-    constexpr const E& error() const& {
-        return err().value();
-    }
-
-    constexpr E&& error() && {
-        return std::move(err().value());
-    }
-
-    constexpr const E&& error() const&& {
-        return std::move(err().value());
-    }
-
-    template <typename U>
-    constexpr T value_or(U&& v) const& {
-        static_assert(std::is_copy_constructible_v<T> && std::is_convertible_v<U&&, T>,
-                      "T must be copy-constructible and convertible from U&&");
-        return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
-    }
-
-    template <typename U>
-    constexpr T value_or(U&& v) && {
-        static_assert(std::is_move_constructible_v<T> && std::is_convertible_v<U&&, T>,
-                      "T must be move-constructible and convertible from U&&");
-        return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
-    }
-
-private:
-    static_assert(!std::is_reference_v<T>, "T must not be a reference");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<std::in_place_t>>,
-                  "T must not be std::in_place_t");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<unexpect_t>>, "T must not be unexpect_t");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<Unexpected<E>>>,
-                  "T must not be Unexpected<E>");
-    static_assert(!std::is_reference_v<E>, "E must not be a reference");
-
-    T* valptr() {
-        return std::addressof(this->m_val);
-    }
-
-    const T* valptr() const {
-        return std::addressof(this->m_val);
-    }
-
-    Unexpected<E>* errptr() {
-        return std::addressof(this->m_unexpect);
-    }
-
-    const Unexpected<E>* errptr() const {
-        return std::addressof(this->m_unexpect);
-    }
-
-    template <typename U = T>
-    constexpr U& val() {
-        return this->m_val;
-    }
-
-    template <typename U = T>
-    constexpr const U& val() const {
-        return this->m_val;
-    }
-
-    constexpr Unexpected<E>& err() {
-        return this->m_unexpect;
-    }
-
-    constexpr const Unexpected<E>& err() const {
-        return this->m_unexpect;
-    }
-
-    using impl_base = detail::expected_move_assign_base<T, E>;
-    using ctor_base = detail::expected_default_ctor_base<T, E>;
-};
-
-template <typename T, typename E, typename U, typename F>
-constexpr bool operator==(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
-    return (lhs.has_value() != rhs.has_value())
-               ? false
-               : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);
-}
-
-template <typename T, typename E, typename U, typename F>
-constexpr bool operator!=(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
-    return !operator==(lhs, rhs);
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator==(const Expected<T, E>& x, const U& v) {
-    return x.has_value() ? *x == v : false;
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator==(const U& v, const Expected<T, E>& x) {
-    return x.has_value() ? *x == v : false;
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator!=(const Expected<T, E>& x, const U& v) {
-    return !operator==(x, v);
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator!=(const U& v, const Expected<T, E>& x) {
-    return !operator==(v, x);
-}
-
-template <typename T, typename E>
-constexpr bool operator==(const Expected<T, E>& x, const Unexpected<E>& e) {
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template <typename T, typename E>
-constexpr bool operator==(const Unexpected<E>& e, const Expected<T, E>& x) {
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template <typename T, typename E>
-constexpr bool operator!=(const Expected<T, E>& x, const Unexpected<E>& e) {
-    return !operator==(x, e);
-}
-
-template <typename T, typename E>
-constexpr bool operator!=(const Unexpected<E>& e, const Expected<T, E>& x) {
-    return !operator==(e, x);
-}
-
-} // namespace Common
@@ -1,7 +1,3 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
 #ifdef _WIN32

 #include <iterator>
@@ -1,366 +0,0 @@
-// Copyright 2017 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include "common/logging/log.h"
-#include "common/param_package.h"
-#include "common/uuid.h"
-
-namespace Common::Input {
-
-// Type of data that is expected to recieve or send
-enum class InputType {
-    None,
-    Battery,
-    Button,
-    Stick,
-    Analog,
-    Trigger,
-    Motion,
-    Touch,
-    Color,
-    Vibration,
-    Nfc,
-    Ir,
-};
-
-// Internal battery charge level
-enum class BatteryLevel : u32 {
-    None,
-    Empty,
-    Critical,
-    Low,
-    Medium,
-    Full,
-    Charging,
-};
-
-enum class PollingMode {
-    // Constant polling of buttons, analogs and motion data
-    Active,
-    // Only update on button change, digital analogs
-    Pasive,
-    // Enable near field communication polling
-    NFC,
-    // Enable infrared camera polling
-    IR,
-};
-
-// Vibration reply from the controller
-enum class VibrationError {
-    None,
-    NotSupported,
-    Disabled,
-    Unknown,
-};
-
-// Polling mode reply from the controller
-enum class PollingError {
-    None,
-    NotSupported,
-    Unknown,
-};
-
-// Hint for amplification curve to be used
-enum class VibrationAmplificationType {
-    Linear,
-    Exponential,
-};
-
-// Analog properties for calibration
-struct AnalogProperties {
-    // Anything below this value will be detected as zero
-    float deadzone{};
-    // Anyting above this values will be detected as one
-    float range{1.0f};
-    // Minimum value to be detected as active
-    float threshold{0.5f};
-    // Drift correction applied to the raw data
-    float offset{};
-    // Invert direction of the sensor data
-    bool inverted{};
-};
-
-// Single analog sensor data
-struct AnalogStatus {
-    float value{};
-    float raw_value{};
-    AnalogProperties properties{};
-};
-
-// Button data
-struct ButtonStatus {
-    Common::UUID uuid{};
-    bool value{};
-    bool inverted{};
-    bool toggle{};
-    bool locked{};
-};
-
-// Internal battery data
-using BatteryStatus = BatteryLevel;
-
-// Analog and digital joystick data
-struct StickStatus {
-    Common::UUID uuid{};
-    AnalogStatus x{};
-    AnalogStatus y{};
-    bool left{};
-    bool right{};
-    bool up{};
-    bool down{};
-};
-
-// Analog and digital trigger data
-struct TriggerStatus {
-    Common::UUID uuid{};
-    AnalogStatus analog{};
-    ButtonStatus pressed{};
-};
-
-// 3D vector representing motion input
-struct MotionSensor {
-    AnalogStatus x{};
-    AnalogStatus y{};
-    AnalogStatus z{};
-};
-
-// Motion data used to calculate controller orientation
-struct MotionStatus {
-    // Gyroscope vector measurement in radians/s.
-    MotionSensor gyro{};
-    // Acceleration vector measurement in G force
-    MotionSensor accel{};
-    // Time since last measurement in microseconds
-    u64 delta_timestamp{};
-    // Request to update after reading the value
-    bool force_update{};
-};
-
-// Data of a single point on a touch screen
-struct TouchStatus {
-    ButtonStatus pressed{};
-    AnalogStatus x{};
-    AnalogStatus y{};
-    int id{};
-};
-
-// Physical controller color in RGB format
-struct BodyColorStatus {
-    u32 body{};
-    u32 buttons{};
-};
-
-// HD rumble data
-struct VibrationStatus {
-    f32 low_amplitude{};
-    f32 low_frequency{};
-    f32 high_amplitude{};
-    f32 high_frequency{};
-    VibrationAmplificationType type;
-};
-
-// Physical controller LED pattern
-struct LedStatus {
-    bool led_1{};
-    bool led_2{};
-    bool led_3{};
-    bool led_4{};
-};
-
-// List of buttons to be passed to Qt that can be translated
-enum class ButtonNames {
-    Undefined,
-    Invalid,
-    // This will display the engine name instead of the button name
-    Engine,
-    // This will display the button by value instead of the button name
-    Value,
-    ButtonLeft,
-    ButtonRight,
-    ButtonDown,
-    ButtonUp,
-    TriggerZ,
-    TriggerR,
-    TriggerL,
-    ButtonA,
-    ButtonB,
-    ButtonX,
-    ButtonY,
-    ButtonStart,
-
-    // DS4 button names
-    L1,
-    L2,
-    L3,
-    R1,
-    R2,
-    R3,
-    Circle,
-    Cross,
-    Square,
-    Triangle,
-    Share,
-    Options,
-};
-
-// Callback data consisting of an input type and the equivalent data status
-struct CallbackStatus {
-    InputType type{InputType::None};
-    ButtonStatus button_status{};
-    StickStatus stick_status{};
-    AnalogStatus analog_status{};
-    TriggerStatus trigger_status{};
-    MotionStatus motion_status{};
-    TouchStatus touch_status{};
-    BodyColorStatus color_status{};
-    BatteryStatus battery_status{};
-    VibrationStatus vibration_status{};
-};
-
-// Triggered once every input change
-struct InputCallback {
-    std::function<void(const CallbackStatus&)> on_change;
-};
-
-/// An abstract class template for an input device (a button, an analog input, etc.).
-class InputDevice {
-public:
-    virtual ~InputDevice() = default;
-
-    // Request input device to update if necessary
-    virtual void SoftUpdate() {}
-
-    // Force input device to update data regardless of the current state
-    virtual void ForceUpdate() {}
-
-    // Sets the function to be triggered when input changes
-    void SetCallback(InputCallback callback_) {
-        callback = std::move(callback_);
-    }
-
-    // Triggers the function set in the callback
-    void TriggerOnChange(const CallbackStatus& status) {
-        if (callback.on_change) {
-            callback.on_change(status);
-        }
-    }
-
-private:
-    InputCallback callback;
-};
-
-/// An abstract class template for an output device (rumble, LED pattern, polling mode).
-class OutputDevice {
-public:
-    virtual ~OutputDevice() = default;
-
-    virtual void SetLED([[maybe_unused]] const LedStatus& led_status) {}
-
-    virtual VibrationError SetVibration([[maybe_unused]] const VibrationStatus& vibration_status) {
-        return VibrationError::NotSupported;
-    }
-
-    virtual PollingError SetPollingMode([[maybe_unused]] PollingMode polling_mode) {
-        return PollingError::NotSupported;
-    }
-};
-
-/// An abstract class template for a factory that can create input devices.
-template <typename InputDeviceType>
-class Factory {
-public:
-    virtual ~Factory() = default;
-    virtual std::unique_ptr<InputDeviceType> Create(const Common::ParamPackage&) = 0;
-};
-
-namespace Impl {
-
-template <typename InputDeviceType>
-using FactoryListType = std::unordered_map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;
-
-template <typename InputDeviceType>
-struct FactoryList {
-    static FactoryListType<InputDeviceType> list;
-};
-
-template <typename InputDeviceType>
-FactoryListType<InputDeviceType> FactoryList<InputDeviceType>::list;
-
-} // namespace Impl
-
-/**
- * Registers an input device factory.
- * @tparam InputDeviceType the type of input devices the factory can create
- * @param name the name of the factory. Will be used to match the "engine" parameter when creating
- *     a device
- * @param factory the factory object to register
- */
-template <typename InputDeviceType>
-void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDeviceType>> factory) {
-    auto pair = std::make_pair(name, std::move(factory));
-    if (!Impl::FactoryList<InputDeviceType>::list.insert(std::move(pair)).second) {
-        LOG_ERROR(Input, "Factory '{}' already registered", name);
-    }
-}
-
-/**
- * Unregisters an input device factory.
- * @tparam InputDeviceType the type of input devices the factory can create
- * @param name the name of the factory to unregister
- */
-template <typename InputDeviceType>
-void UnregisterFactory(const std::string& name) {
-    if (Impl::FactoryList<InputDeviceType>::list.erase(name) == 0) {
-        LOG_ERROR(Input, "Factory '{}' not registered", name);
-    }
-}
-
-/**
- * Create an input device from given paramters.
- * @tparam InputDeviceType the type of input devices to create
- * @param params a serialized ParamPackage string that contains all parameters for creating the
- * device
- */
-template <typename InputDeviceType>
-std::unique_ptr<InputDeviceType> CreateDeviceFromString(const std::string& params) {
-    const Common::ParamPackage package(params);
-    const std::string engine = package.Get("engine", "null");
-    const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
-    const auto pair = factory_list.find(engine);
-    if (pair == factory_list.end()) {
-        if (engine != "null") {
-            LOG_ERROR(Input, "Unknown engine name: {}", engine);
-        }
-        return std::make_unique<InputDeviceType>();
-    }
-    return pair->second->Create(package);
-}
-
-/**
- * Create an input device from given paramters.
- * @tparam InputDeviceType the type of input devices to create
- * @param A ParamPackage that contains all parameters for creating the device
- */
-template <typename InputDeviceType>
-std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package) {
-    const std::string engine = package.Get("engine", "null");
-    const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
-    const auto pair = factory_list.find(engine);
-    if (pair == factory_list.end()) {
-        if (engine != "null") {
-            LOG_ERROR(Input, "Unknown engine name: {}", engine);
-        }
-        return std::make_unique<InputDeviceType>();
-    }
-    return pair->second->Create(package);
-}
-
-} // namespace Common::Input
@@ -6,7 +6,6 @@
 #include <chrono>
 #include <climits>
 #include <exception>
-#include <stop_token>
 #include <thread>
 #include <vector>

@@ -187,10 +186,6 @@ public:
        initialization_in_progress_suppress_logging = false;
    }

-    static void Start() {
-        instance->StartBackendThread();
-    }
-
    Impl(const Impl&) = delete;
    Impl& operator=(const Impl&) = delete;

@@ -206,7 +201,7 @@ public:
    }

    void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string&& message) {
+                   const char* function, std::string message) {
        if (!filter.CheckMessage(log_class, log_level))
            return;
        const Entry& entry =
@@ -216,41 +211,40 @@ public:

 private:
    Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
-        : filter{filter_}, file_backend{file_backend_filename} {}
+        : filter{filter_}, file_backend{file_backend_filename}, backend_thread{std::thread([this] {
+              Common::SetCurrentThreadName("yuzu:Log");
+              Entry entry;
+              const auto write_logs = [this, &entry]() {
+                  ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
+              };
+              while (true) {
+                  entry = message_queue.PopWait();
+                  if (entry.final_entry) {
+                      break;
+                  }
+                  write_logs();
+              }
+              // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
+              // case where a system is repeatedly spamming logs even on close.
+              int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
+              while (max_logs_to_write-- && message_queue.Pop(entry)) {
+                  write_logs();
+              }
+          })} {}

    ~Impl() {
        StopBackendThread();
    }

-    void StartBackendThread() {
-        backend_thread = std::thread([this] {
-            Common::SetCurrentThreadName("yuzu:Log");
-            Entry entry;
-            const auto write_logs = [this, &entry]() {
-                ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
-            };
-            while (!stop.stop_requested()) {
-                entry = message_queue.PopWait(stop.get_token());
-                if (entry.filename != nullptr) {
-                    write_logs();
-                }
-            }
-            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-            // case where a system is repeatedly spamming logs even on close.
-            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-            while (max_logs_to_write-- && message_queue.Pop(entry)) {
-                write_logs();
-            }
-        });
-    }
-
    void StopBackendThread() {
-        stop.request_stop();
+        Entry stop_entry{};
+        stop_entry.final_entry = true;
+        message_queue.Push(stop_entry);
        backend_thread.join();
    }

    Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                      const char* function, std::string&& message) const {
+                      const char* function, std::string message) const {
        using std::chrono::duration_cast;
        using std::chrono::microseconds;
        using std::chrono::steady_clock;
@@ -263,6 +257,7 @@ private:
            .line_num = line_nr,
            .function = function,
            .message = std::move(message),
+            .final_entry = false,
        };
    }

@@ -283,9 +278,8 @@ private:
    ColorConsoleBackend color_console_backend{};
    FileBackend file_backend;

-    std::stop_source stop;
    std::thread backend_thread;
-    MPSCQueue<Entry, true> message_queue{};
+    MPSCQueue<Entry> message_queue{};
    std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 } // namespace
@@ -294,10 +288,6 @@ void Initialize() {
    Impl::Initialize();
 }

-void Start() {
-    Impl::Start();
-}
-
 void DisableLoggingInTests() {
    initialization_in_progress_suppress_logging = true;
 }
@@ -14,8 +14,6 @@ class Filter;
 /// Initializes the logging system. This should be the first thing called in main.
 void Initialize();

-void Start();
-
 void DisableLoggingInTests();

 /**
@@ -114,7 +114,6 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
    SUB(Service, NGCT)                                                                             \
    SUB(Service, NIFM)                                                                             \
    SUB(Service, NIM)                                                                              \
-    SUB(Service, NOTIF)                                                                            \
    SUB(Service, NPNS)                                                                             \
    SUB(Service, NS)                                                                               \
    SUB(Service, NVDRV)                                                                            \
@@ -22,6 +22,7 @@ struct Entry {
    unsigned int line_num = 0;
    std::string function;
    std::string message;
+    bool final_entry = false;
 };

 } // namespace Common::Log
@@ -82,7 +82,6 @@ enum class Class : u8 {
    Service_NGCT,      ///< The NGCT (No Good Content for Terra) service
    Service_NIFM,      ///< The NIFM (Network interface) service
    Service_NIM,       ///< The NIM service
-    Service_NOTIF,     ///< The NOTIF (Notification) service
    Service_NPNS,      ///< The NPNS service
    Service_NS,        ///< The NS services
    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
@@ -48,8 +48,8 @@ struct Rectangle {
    }

    [[nodiscard]] Rectangle<T> Scale(const float s) const {
-        return Rectangle{left, top, static_cast<T>(static_cast<float>(left + GetWidth()) * s),
-                         static_cast<T>(static_cast<float>(top + GetHeight()) * s)};
+        return Rectangle{left, top, static_cast<T>(left + GetWidth() * s),
+                         static_cast<T>(top + GetHeight() * s)};
    }
 };

@@ -47,9 +47,7 @@ void LogSettings() {
    log_setting("System_TimeZoneIndex", values.time_zone_index.GetValue());
    log_setting("Core_UseMultiCore", values.use_multi_core.GetValue());
    log_setting("CPU_Accuracy", values.cpu_accuracy.GetValue());
-    log_setting("Renderer_UseResolutionScaling", values.resolution_setup.GetValue());
-    log_setting("Renderer_ScalingFilter", values.scaling_filter.GetValue());
-    log_setting("Renderer_AntiAliasing", values.anti_aliasing.GetValue());
+    log_setting("Renderer_UseResolutionFactor", values.resolution_factor.GetValue());
    log_setting("Renderer_UseSpeedLimit", values.use_speed_limit.GetValue());
    log_setting("Renderer_SpeedLimit", values.speed_limit.GetValue());
    log_setting("Renderer_UseDiskShaderCache", values.use_disk_shader_cache.GetValue());
@@ -107,55 +105,6 @@ float Volume() {
    return values.volume.GetValue() / 100.0f;
 }

-void UpdateRescalingInfo() {
-    const auto setup = values.resolution_setup.GetValue();
-    auto& info = values.resolution_info;
-    info.downscale = false;
-    switch (setup) {
-    case ResolutionSetup::Res1_2X:
-        info.up_scale = 1;
-        info.down_shift = 1;
-        info.downscale = true;
-        break;
-    case ResolutionSetup::Res3_4X:
-        info.up_scale = 3;
-        info.down_shift = 2;
-        info.downscale = true;
-        break;
-    case ResolutionSetup::Res1X:
-        info.up_scale = 1;
-        info.down_shift = 0;
-        break;
-    case ResolutionSetup::Res2X:
-        info.up_scale = 2;
-        info.down_shift = 0;
-        break;
-    case ResolutionSetup::Res3X:
-        info.up_scale = 3;
-        info.down_shift = 0;
-        break;
-    case ResolutionSetup::Res4X:
-        info.up_scale = 4;
-        info.down_shift = 0;
-        break;
-    case ResolutionSetup::Res5X:
-        info.up_scale = 5;
-        info.down_shift = 0;
-        break;
-    case ResolutionSetup::Res6X:
-        info.up_scale = 6;
-        info.down_shift = 0;
-        break;
-    default:
-        UNREACHABLE();
-        info.up_scale = 1;
-        info.down_shift = 0;
-    }
-    info.up_factor = static_cast<f32>(info.up_scale) / (1U << info.down_shift);
-    info.down_factor = static_cast<f32>(1U << info.down_shift) / info.up_scale;
-    info.active = info.up_scale != 1 || info.down_shift != 0;
-}
-
 void RestoreGlobalState(bool is_powered_on) {
    // If a game is running, DO NOT restore the global settings state
    if (is_powered_on) {
@@ -183,7 +132,6 @@ void RestoreGlobalState(bool is_powered_on) {
    values.max_anisotropy.SetGlobal(true);
    values.use_speed_limit.SetGlobal(true);
    values.speed_limit.SetGlobal(true);
-    values.fps_cap.SetGlobal(true);
    values.use_disk_shader_cache.SetGlobal(true);
    values.gpu_accuracy.SetGlobal(true);
    values.use_asynchronous_gpu_emulation.SetGlobal(true);
@@ -6,6 +6,7 @@

 #include <algorithm>
 #include <array>
+#include <atomic>
 #include <map>
 #include <optional>
 #include <string>
@@ -51,56 +52,6 @@ enum class NvdecEmulation : u32 {
    GPU = 2,
 };

-enum class ResolutionSetup : u32 {
-    Res1_2X = 0,
-    Res3_4X = 1,
-    Res1X = 2,
-    Res2X = 3,
-    Res3X = 4,
-    Res4X = 5,
-    Res5X = 6,
-    Res6X = 7,
-};
-
-enum class ScalingFilter : u32 {
-    NearestNeighbor = 0,
-    Bilinear = 1,
-    Bicubic = 2,
-    Gaussian = 3,
-    ScaleForce = 4,
-    Fsr = 5,
-    LastFilter = Fsr,
-};
-
-enum class AntiAliasing : u32 {
-    None = 0,
-    Fxaa = 1,
-    LastAA = Fxaa,
-};
-
-struct ResolutionScalingInfo {
-    u32 up_scale{1};
-    u32 down_shift{0};
-    f32 up_factor{1.0f};
-    f32 down_factor{1.0f};
-    bool active{};
-    bool downscale{};
-
-    s32 ScaleUp(s32 value) const {
-        if (value == 0) {
-            return 0;
-        }
-        return std::max((value * static_cast<s32>(up_scale)) >> static_cast<s32>(down_shift), 1);
-    }
-
-    u32 ScaleUp(u32 value) const {
-        if (value == 0U) {
-            return 0U;
-        }
-        return std::max((value * up_scale) >> down_shift, 1U);
-    }
-};
-
 /** The BasicSetting class is a simple resource manager. It defines a label and default value
 * alongside the actual value of the setting for simpler and less-error prone use with frontend
 * configurations. Setting a default value and label is required, though subclasses may deviate from
@@ -500,10 +451,7 @@ struct Values {
                                                         "disable_shader_loop_safety_checks"};
    Setting<int> vulkan_device{0, "vulkan_device"};

-    ResolutionScalingInfo resolution_info{};
-    Setting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
-    Setting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
-    Setting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
+    Setting<u16> resolution_factor{1, "resolution_factor"};
    // *nix platforms may have issues with the borderless windowed fullscreen mode.
    // Default to exclusive fullscreen on these platforms for now.
    RangedSetting<FullscreenMode> fullscreen_mode{
@@ -514,7 +462,7 @@ struct Values {
 #endif
        FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
    RangedSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"};
-    RangedSetting<int> max_anisotropy{0, 0, 5, "max_anisotropy"};
+    RangedSetting<int> max_anisotropy{0, 0, 4, "max_anisotropy"};
    Setting<bool> use_speed_limit{true, "use_speed_limit"};
    RangedSetting<u16> speed_limit{100, 0, 9999, "speed_limit"};
    Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
@@ -524,7 +472,7 @@ struct Values {
    Setting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
    Setting<bool> accelerate_astc{true, "accelerate_astc"};
    Setting<bool> use_vsync{true, "use_vsync"};
-    RangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
+    BasicRangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
    BasicSetting<bool> disable_fps_limit{false, "disable_fps_limit"};
    RangedSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
                                                ShaderBackend::SPIRV, "shader_backend"};
@@ -559,19 +507,25 @@ struct Values {
    Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};

    Setting<bool> motion_enabled{true, "motion_enabled"};
+    BasicSetting<std::string> motion_device{"engine:motion_emu,update_period:100,sensitivity:0.01",
+                                            "motion_device"};
    BasicSetting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
-    BasicSetting<bool> enable_udp_controller{false, "enable_udp_controller"};

    BasicSetting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
    BasicSetting<bool> tas_enable{false, "tas_enable"};
    BasicSetting<bool> tas_loop{false, "tas_loop"};
+    BasicSetting<bool> tas_swap_controllers{true, "tas_swap_controllers"};

    BasicSetting<bool> mouse_panning{false, "mouse_panning"};
    BasicRangedSetting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
    BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
+    std::string mouse_device;
+    MouseButtonsRaw mouse_buttons;

    BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
    BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
+    KeyboardKeysRaw keyboard_keys;
+    KeyboardModsRaw keyboard_mods;

    BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
    ButtonsRaw debug_pad_buttons;
@@ -579,11 +533,14 @@ struct Values {

    TouchscreenInput touchscreen;

+    BasicSetting<bool> use_touch_from_button{false, "use_touch_from_button"};
    BasicSetting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850",
                                           "touch_device"};
    BasicSetting<int> touch_from_button_map_index{0, "touch_from_button_map"};
    std::vector<TouchFromButtonMap> touch_from_button_maps;

+    std::atomic_bool is_device_reload_pending{true};
+
    // Data Storage
    BasicSetting<bool> use_virtual_sd{true, "use_virtual_sd"};
    BasicSetting<bool> gamecard_inserted{false, "gamecard_inserted"};
@@ -604,7 +561,6 @@ struct Values {
    BasicSetting<bool> extended_logging{false, "extended_logging"};
    BasicSetting<bool> use_debug_asserts{false, "use_debug_asserts"};
    BasicSetting<bool> use_auto_stub{false, "use_auto_stub"};
-    BasicSetting<bool> enable_all_controllers{false, "enable_all_controllers"};

    // Miscellaneous
    BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
@@ -639,8 +595,6 @@ std::string GetTimeZoneString();

 void LogSettings();

-void UpdateRescalingInfo();
-
 // Restore the global state of all applicable settings in the Values struct
 void RestoreGlobalState(bool is_powered_on);

@@ -62,22 +62,11 @@ enum Values : int {

 constexpr int STICK_HID_BEGIN = LStick;
 constexpr int STICK_HID_END = NumAnalogs;
+constexpr int NUM_STICKS_HID = NumAnalogs;

 extern const std::array<const char*, NumAnalogs> mapping;
 } // namespace NativeAnalog

-namespace NativeTrigger {
-enum Values : int {
-    LTrigger,
-    RTrigger,
-
-    NumTriggers,
-};
-
-constexpr int TRIGGER_HID_BEGIN = LTrigger;
-constexpr int TRIGGER_HID_END = NumTriggers;
-} // namespace NativeTrigger
-
 namespace NativeVibration {
 enum Values : int {
    LeftVibrationDevice,
@@ -126,20 +115,10 @@ constexpr int NUM_MOUSE_HID = NumMouseButtons;
 extern const std::array<const char*, NumMouseButtons> mapping;
 } // namespace NativeMouseButton

-namespace NativeMouseWheel {
-enum Values {
-    X,
-    Y,
-
-    NumMouseWheels,
-};
-
-extern const std::array<const char*, NumMouseWheels> mapping;
-} // namespace NativeMouseWheel
-
 namespace NativeKeyboard {
 enum Keys {
    None,
+    Error,

    A = 4,
    B,
@@ -177,22 +156,22 @@ enum Keys {
    N8,
    N9,
    N0,
-    Return,
+    Enter,
    Escape,
    Backspace,
    Tab,
    Space,
    Minus,
-    Plus,
-    OpenBracket,
-    CloseBracket,
-    Pipe,
+    Equal,
+    LeftBrace,
+    RightBrace,
+    Backslash,
    Tilde,
    Semicolon,
-    Quote,
-    Backquote,
+    Apostrophe,
+    Grave,
    Comma,
-    Period,
+    Dot,
    Slash,
    CapsLockKey,

@@ -209,7 +188,7 @@ enum Keys {
    F11,
    F12,

-    PrintScreen,
+    SystemRequest,
    ScrollLockKey,
    Pause,
    Insert,
@@ -278,18 +257,8 @@ enum Keys {
    ScrollLockActive,
    KPComma,

-    Ro = 0x87,
-    KatakanaHiragana,
-    Yen,
-    Henkan,
-    Muhenkan,
-    NumPadCommaPc98,
-
-    HangulEnglish = 0x90,
-    Hanja,
-    KatakanaKey,
-    HiraganaKey,
-    ZenkakuHankaku,
+    KPLeftParenthesis,
+    KPRightParenthesis,

    LeftControlKey = 0xE0,
    LeftShiftKey,
@@ -338,8 +307,6 @@ enum Modifiers {
    CapsLock,
    ScrollLock,
    NumLock,
-    Katakana,
-    Hiragana,

    NumKeyboardMods,
 };
@@ -357,6 +324,11 @@ constexpr int NUM_KEYBOARD_MODS_HID = NumKeyboardMods;
 using AnalogsRaw = std::array<std::string, NativeAnalog::NumAnalogs>;
 using ButtonsRaw = std::array<std::string, NativeButton::NumButtons>;
 using MotionsRaw = std::array<std::string, NativeMotion::NumMotions>;
+using VibrationsRaw = std::array<std::string, NativeVibration::NumVibrations>;
+
+using MouseButtonsRaw = std::array<std::string, NativeMouseButton::NumMouseButtons>;
+using KeyboardKeysRaw = std::array<std::string, NativeKeyboard::NumKeyboardKeys>;
+using KeyboardModsRaw = std::array<std::string, NativeKeyboard::NumKeyboardMods>;

 constexpr u32 JOYCON_BODY_NEON_RED = 0xFF3C28;
 constexpr u32 JOYCON_BUTTONS_NEON_RED = 0x1E0A0A;
@@ -370,11 +342,6 @@ enum class ControllerType {
    RightJoycon,
    Handheld,
    GameCube,
-    Pokeball,
-    NES,
-    SNES,
-    N64,
-    SegaGenesis,
 };

 struct PlayerInput {
@@ -382,6 +349,7 @@ struct PlayerInput {
    ControllerType controller_type;
    ButtonsRaw buttons;
    AnalogsRaw analogs;
+    VibrationsRaw vibrations;
    MotionsRaw motions;

    bool vibration_enabled;
@@ -71,6 +71,9 @@ static CPUCaps Detect() {
    else
        caps.manufacturer = Manufacturer::Unknown;

+    u32 family = {};
+    u32 model = {};
+
    __cpuid(cpu_id, 0x80000000);

    u32 max_ex_fn = cpu_id[0];
@@ -81,6 +84,15 @@ static CPUCaps Detect() {
    // Detect family and other miscellaneous features
    if (max_std_fn >= 1) {
        __cpuid(cpu_id, 0x00000001);
+        family = (cpu_id[0] >> 8) & 0xf;
+        model = (cpu_id[0] >> 4) & 0xf;
+        if (family == 0xf) {
+            family += (cpu_id[0] >> 20) & 0xff;
+        }
+        if (family >= 6) {
+            model += ((cpu_id[0] >> 16) & 0xf) << 4;
+        }
+
        if ((cpu_id[3] >> 25) & 1)
            caps.sse = true;
        if ((cpu_id[3] >> 26) & 1)
@@ -15,26 +15,26 @@
 namespace Common {

 u64 EstimateRDTSCFrequency() {
-    // Discard the first result measuring the rdtsc.
+    const auto milli_10 = std::chrono::milliseconds{10};
+    // get current time
    _mm_mfence();
-    __rdtsc();
-    std::this_thread::sleep_for(std::chrono::milliseconds{1});
+    const u64 tscStart = __rdtsc();
+    const auto startTime = std::chrono::high_resolution_clock::now();
+    // wait roughly 3 seconds
+    while (true) {
+        auto milli = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::high_resolution_clock::now() - startTime);
+        if (milli.count() >= 3000)
+            break;
+        std::this_thread::sleep_for(milli_10);
+    }
+    const auto endTime = std::chrono::high_resolution_clock::now();
    _mm_mfence();
-    __rdtsc();
-
-    // Get the current time.
-    const auto start_time = std::chrono::steady_clock::now();
-    _mm_mfence();
-    const u64 tsc_start = __rdtsc();
-    // Wait for 200 milliseconds.
-    std::this_thread::sleep_for(std::chrono::milliseconds{200});
-    const auto end_time = std::chrono::steady_clock::now();
-    _mm_mfence();
-    const u64 tsc_end = __rdtsc();
-    // Calculate differences.
-    const u64 timer_diff = static_cast<u64>(
-        std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time).count());
-    const u64 tsc_diff = tsc_end - tsc_start;
+    const u64 tscEnd = __rdtsc();
+    // calculate difference
+    const u64 timer_diff =
+        std::chrono::duration_cast<std::chrono::nanoseconds>(endTime - startTime).count();
+    const u64 tsc_diff = tscEnd - tscStart;
    const u64 tsc_freq = MultiplyAndDivide64(tsc_diff, 1000000000ULL, timer_diff);
    return tsc_freq;
 }
@@ -132,23 +132,11 @@ add_library(core STATIC
    frontend/emu_window.h
    frontend/framebuffer_layout.cpp
    frontend/framebuffer_layout.h
+    frontend/input_interpreter.cpp
+    frontend/input_interpreter.h
+    frontend/input.h
    hardware_interrupt_manager.cpp
    hardware_interrupt_manager.h
-    hid/emulated_console.cpp
-    hid/emulated_console.h
-    hid/emulated_controller.cpp
-    hid/emulated_controller.h
-    hid/emulated_devices.cpp
-    hid/emulated_devices.h
-    hid/hid_core.cpp
-    hid/hid_core.h
-    hid/hid_types.h
-    hid/input_converter.cpp
-    hid/input_converter.h
-    hid/input_interpreter.cpp
-    hid/input_interpreter.h
-    hid/motion_input.cpp
-    hid/motion_input.h
    hle/api_version.h
    hle/ipc.h
    hle/ipc_helpers.h
@@ -179,15 +167,12 @@ add_library(core STATIC
    hle/kernel/k_client_port.h
    hle/kernel/k_client_session.cpp
    hle/kernel/k_client_session.h
-    hle/kernel/k_code_memory.cpp
-    hle/kernel/k_code_memory.h
    hle/kernel/k_condition_variable.cpp
    hle/kernel/k_condition_variable.h
    hle/kernel/k_event.cpp
    hle/kernel/k_event.h
    hle/kernel/k_handle_table.cpp
    hle/kernel/k_handle_table.h
-    hle/kernel/k_light_condition_variable.cpp
    hle/kernel/k_light_condition_variable.h
    hle/kernel/k_light_lock.cpp
    hle/kernel/k_light_lock.h
@@ -240,7 +225,6 @@ add_library(core STATIC
    hle/kernel/k_system_control.h
    hle/kernel/k_thread.cpp
    hle/kernel/k_thread.h
-    hle/kernel/k_thread_queue.cpp
    hle/kernel/k_thread_queue.h
    hle/kernel/k_trace.h
    hle/kernel/k_transfer_memory.cpp
@@ -265,6 +249,8 @@ add_library(core STATIC
    hle/kernel/svc_wrap.h
    hle/kernel/time_manager.cpp
    hle/kernel/time_manager.h
+    hle/lock.cpp
+    hle/lock.h
    hle/result.h
    hle/service/acc/acc.cpp
    hle/service/acc/acc.h
@@ -410,15 +396,12 @@ add_library(core STATIC
    hle/service/glue/glue.h
    hle/service/glue/glue_manager.cpp
    hle/service/glue/glue_manager.h
-    hle/service/glue/notif.cpp
-    hle/service/glue/notif.h
    hle/service/grc/grc.cpp
    hle/service/grc/grc.h
    hle/service/hid/hid.cpp
    hle/service/hid/hid.h
    hle/service/hid/irs.cpp
    hle/service/hid/irs.h
-    hle/service/hid/ring_lifo.h
    hle/service/hid/xcd.cpp
    hle/service/hid/xcd.h
    hle/service/hid/errors.h
@@ -483,8 +466,6 @@ add_library(core STATIC
    hle/service/ns/language.h
    hle/service/ns/ns.cpp
    hle/service/ns/ns.h
-    hle/service/ns/pdm_qry.cpp
-    hle/service/ns/pdm_qry.h
    hle/service/ns/pl_u.cpp
    hle/service/ns/pl_u.h
    hle/service/nvdrv/devices/nvdevice.h
@@ -9,6 +9,7 @@

 #include <dynarmic/interface/A32/a32.h>
 #include <dynarmic/interface/A64/a64.h>
+#include <dynarmic/interface/exclusive_monitor.h>
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"
@@ -18,6 +18,7 @@
 #include "core/core_timing.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/k_process.h"
+#include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"

@@ -86,26 +87,6 @@ public:
                  num_instructions, MemoryReadCode(pc));
    }

-    void InstructionCacheOperationRaised(Dynarmic::A64::InstructionCacheOperation op,
-                                         VAddr value) override {
-        switch (op) {
-        case Dynarmic::A64::InstructionCacheOperation::InvalidateByVAToPoU: {
-            static constexpr u64 ICACHE_LINE_SIZE = 64;
-
-            const u64 cache_line_start = value & ~(ICACHE_LINE_SIZE - 1);
-            parent.InvalidateCacheRange(cache_line_start, ICACHE_LINE_SIZE);
-            break;
-        }
-        case Dynarmic::A64::InstructionCacheOperation::InvalidateAllToPoU:
-            parent.ClearInstructionCache();
-            break;
-        case Dynarmic::A64::InstructionCacheOperation::InvalidateAllToPoUInnerSharable:
-        default:
-            LOG_DEBUG(Core_ARM, "Unprocesseed instruction cache operation: {}", op);
-            break;
-        }
-    }
-
    void ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) override {
        switch (exception) {
        case Dynarmic::A64::Exception::WaitForInterrupt:
@@ -8,6 +8,7 @@
 #include "core/arm/dynarmic/arm_dynarmic_cp15.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"

 using Callback = Dynarmic::A32::Coprocessor::Callback;
 using CallbackOrAccessOneWord = Dynarmic::A32::Coprocessor::CallbackOrAccessOneWord;
@@ -4,6 +4,7 @@

 #pragma once

+#include <memory>
 #include <optional>

 #include <dynarmic/interface/A32/coprocessor.h>
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <cinttypes>
+#include <memory>
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #include "core/memory.h"

@@ -4,6 +4,7 @@

 #pragma once

+#include <memory>
 #include <unordered_map>

 #include <dynarmic/interface/exclusive_monitor.h>
@@ -19,17 +19,20 @@
 #include "core/cpu_manager.h"
 #include "core/device_memory.h"
 #include "core/file_sys/bis_factory.h"
+#include "core/file_sys/card_image.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs_factory.h"
 #include "core/file_sys/savedata_factory.h"
+#include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/hardware_interrupt_manager.h"
-#include "core/hid/hid_core.h"
+#include "core/hle/kernel/k_client_port.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_scheduler.h"
+#include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/service/am/applets/applets.h"
@@ -80,6 +83,12 @@ FileSys::StorageId GetStorageIdForFrontendSlot(
    }
 }

+void KProcessDeleter(Kernel::KProcess* process) {
+    process->Destroy();
+}
+
+using KProcessPtr = std::unique_ptr<Kernel::KProcess, decltype(&KProcessDeleter)>;
+
 } // Anonymous namespace

 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
@@ -127,7 +136,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,

 struct System::Impl {
    explicit Impl(System& system)
-        : kernel{system}, fs_controller{system}, memory{system}, hid_core{},
+        : kernel{system}, fs_controller{system}, memory{system},
          cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}

    SystemResultStatus Run() {
@@ -252,10 +261,11 @@ struct System::Impl {
        }

        telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-        auto main_process = Kernel::KProcess::Create(system.Kernel());
-        ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
+        main_process = KProcessPtr{Kernel::KProcess::Create(system.Kernel()), KProcessDeleter};
+        ASSERT(Kernel::KProcess::Initialize(main_process.get(), system, "main",
                                            Kernel::KProcess::ProcessType::Userland)
                   .IsSuccess());
+        main_process->Open();
        const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
        if (load_result != Loader::ResultStatus::Success) {
            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
@@ -265,7 +275,7 @@ struct System::Impl {
                static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
        }
        AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeCurrentProcess(main_process);
+        kernel.MakeCurrentProcess(main_process.get());
        kernel.InitializeCores();

        // Initialize cheat engine
@@ -325,11 +335,13 @@ struct System::Impl {
        time_manager.Shutdown();
        core_timing.Shutdown();
        app_loader.reset();
-        gpu_core.reset();
        perf_stats.reset();
+        gpu_core.reset();
        kernel.Shutdown();
        memory.Reset();
        applet_manager.ClearAll();
+        // TODO: The main process should be freed based on KAutoObject ref counting.
+        main_process.reset();

        LOG_DEBUG(Core, "Shutdown OK");
    }
@@ -350,7 +362,7 @@ struct System::Impl {
        }

        Service::Glue::ApplicationLaunchProperty launch{};
-        launch.title_id = process.GetProgramID();
+        launch.title_id = process.GetTitleID();

        FileSys::PatchManager pm{launch.title_id, fs_controller, *content_provider};
        launch.version = pm.GetGameVersion().value_or(0);
@@ -391,8 +403,8 @@ struct System::Impl {
    std::unique_ptr<Tegra::GPU> gpu_core;
    std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
    std::unique_ptr<Core::DeviceMemory> device_memory;
+    KProcessPtr main_process{nullptr, KProcessDeleter};
    Core::Memory::Memory memory;
-    Core::HID::HIDCore hid_core;
    CpuManager cpu_manager;
    std::atomic_bool is_powered_on{};
    bool exit_lock = false;
@@ -521,6 +533,12 @@ const ARM_Interface& System::CurrentArmInterface() const {
    return impl->kernel.CurrentPhysicalCore().ArmInterface();
 }

+std::size_t System::CurrentCoreIndex() const {
+    std::size_t core = impl->kernel.GetCurrentHostThreadID();
+    ASSERT(core < Core::Hardware::NUM_CPU_CORES);
+    return core;
+}
+
 Kernel::PhysicalCore& System::CurrentPhysicalCore() {
    return impl->kernel.CurrentPhysicalCore();
 }
@@ -611,14 +629,6 @@ const Kernel::KernelCore& System::Kernel() const {
    return impl->kernel;
 }

-HID::HIDCore& System::HIDCore() {
-    return impl->hid_core;
-}
-
-const HID::HIDCore& System::HIDCore() const {
-    return impl->hid_core;
-}
-
 Timing::CoreTiming& System::CoreTiming() {
    return impl->core_timing;
 }
@@ -643,10 +653,6 @@ const Core::SpeedLimiter& System::SpeedLimiter() const {
    return impl->speed_limiter;
 }

-u64 System::GetCurrentProcessProgramID() const {
-    return impl->kernel.CurrentProcess()->GetProgramID();
-}
-
 Loader::ResultStatus System::GetGameName(std::string& out) const {
    return impl->GetGameName(out);
 }
@@ -829,6 +835,8 @@ void System::ApplySettings() {
    if (IsPoweredOn()) {
        Renderer().RefreshBaseSettings();
    }
+
+    Service::HID::ReloadInputDevices();
 }

 } // namespace Core
@@ -89,10 +89,6 @@ namespace Core::Hardware {
 class InterruptManager;
 }

-namespace Core::HID {
-class HIDCore;
-}
-
 namespace Core {

 class ARM_Interface;
@@ -208,6 +204,9 @@ public:
    /// Gets an ARM interface to the CPU core that is currently running
    [[nodiscard]] const ARM_Interface& CurrentArmInterface() const;

+    /// Gets the index of the currently running CPU core
+    [[nodiscard]] std::size_t CurrentCoreIndex() const;
+
    /// Gets the physical core for the CPU core that is currently running
    [[nodiscard]] Kernel::PhysicalCore& CurrentPhysicalCore();

@@ -286,12 +285,6 @@ public:
    /// Provides a constant reference to the kernel instance.
    [[nodiscard]] const Kernel::KernelCore& Kernel() const;

-    /// Gets a mutable reference to the HID interface.
-    [[nodiscard]] HID::HIDCore& HIDCore();
-
-    /// Gets an immutable reference to the HID interface.
-    [[nodiscard]] const HID::HIDCore& HIDCore() const;
-
    /// Provides a reference to the internal PerfStats instance.
    [[nodiscard]] Core::PerfStats& GetPerfStats();

@@ -304,8 +297,6 @@ public:
    /// Provides a constant reference to the speed limiter
    [[nodiscard]] const Core::SpeedLimiter& SpeedLimiter() const;

-    [[nodiscard]] u64 GetCurrentProcessProgramID() const;
-
    /// Gets the name of the current game
    [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;

@@ -8,6 +8,7 @@
 #include <chrono>
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string>
 #include <thread>
@@ -6,6 +6,7 @@
 #include "common/microprofile.h"
 #include "common/scope_exit.h"
 #include "common/thread.h"
+#include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/cpu_manager.h"
@@ -117,18 +118,17 @@ void CpuManager::MultiCoreRunGuestLoop() {
            physical_core = &kernel.CurrentPhysicalCore();
        }
        system.ExitDynarmicProfile();
-        {
-            Kernel::KScopedDisableDispatch dd(kernel);
-            physical_core->ArmInterface().ClearExclusiveState();
-        }
+        physical_core->ArmInterface().ClearExclusiveState();
+        kernel.CurrentScheduler()->RescheduleCurrentCore();
    }
 }

 void CpuManager::MultiCoreRunIdleThread() {
    auto& kernel = system.Kernel();
    while (true) {
-        Kernel::KScopedDisableDispatch dd(kernel);
-        kernel.CurrentPhysicalCore().Idle();
+        auto& physical_core = kernel.CurrentPhysicalCore();
+        physical_core.Idle();
+        kernel.CurrentScheduler()->RescheduleCurrentCore();
    }
 }

@@ -136,12 +136,12 @@ void CpuManager::MultiCoreRunSuspendThread() {
    auto& kernel = system.Kernel();
    kernel.CurrentScheduler()->OnThreadStart();
    while (true) {
-        auto core = kernel.CurrentPhysicalCoreIndex();
+        auto core = kernel.GetCurrentHostThreadID();
        auto& scheduler = *kernel.CurrentScheduler();
        Kernel::KThread* current_thread = scheduler.GetCurrentThread();
        Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
        ASSERT(scheduler.ContextSwitchPending());
-        ASSERT(core == kernel.CurrentPhysicalCoreIndex());
+        ASSERT(core == kernel.GetCurrentHostThreadID());
        scheduler.RescheduleCurrentCore();
    }
 }
@@ -347,11 +347,15 @@ void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
            sc_sync_first_use = false;
        }

-        // Emulation was stopped
-        if (stop_token.stop_requested()) {
+        // Abort if emulation was killed before the session really starts
+        if (!system.IsPoweredOn()) {
            return;
        }

+        if (stop_token.stop_requested()) {
+            break;
+        }
+
        auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
        data.is_running = true;
        Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
@@ -4,6 +4,7 @@

 #include <algorithm>
 #include <cstring>
+#include "common/assert.h"
 #include "core/crypto/ctr_encryption_layer.h"

 namespace Core::Crypto {
@@ -10,12 +10,14 @@
 #include <locale>
 #include <map>
 #include <sstream>
+#include <string_view>
 #include <tuple>
 #include <vector>
 #include <mbedtls/bignum.h>
 #include <mbedtls/cipher.h>
 #include <mbedtls/cmac.h>
 #include <mbedtls/sha256.h>
+#include "common/common_funcs.h"
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
@@ -28,6 +30,7 @@
 #include "core/crypto/partition_data_manager.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
@@ -15,6 +15,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/crypto/partition_data_manager.h"
+#include "core/file_sys/vfs_types.h"

 namespace Common::FS {
 class IOFile;
@@ -12,6 +12,7 @@
 #include <cctype>
 #include <cstring>
 #include <mbedtls/sha256.h>
+#include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/hex_util.h"
@@ -4,6 +4,7 @@

 #include <algorithm>
 #include <cstring>
+#include "common/assert.h"
 #include "core/crypto/xts_encryption_layer.h"

 namespace Core::Crypto {
@@ -14,6 +14,7 @@
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/submission_package.h"
+#include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/file_sys/vfs_vector.h"
 #include "core/loader/loader.h"
@@ -9,7 +9,7 @@

 namespace FileSys {

-const std::array<const char*, 16> LANGUAGE_NAMES{{
+const std::array<const char*, 15> LANGUAGE_NAMES{{
    "AmericanEnglish",
    "BritishEnglish",
    "Japanese",
@@ -25,7 +25,6 @@ const std::array<const char*, 16> LANGUAGE_NAMES{{
    "Korean",
    "Taiwanese",
    "Chinese",
-    "BrazilianPortuguese",
 }};

 std::string LanguageEntry::GetApplicationName() const {
@@ -5,6 +5,7 @@
 #pragma once

 #include <array>
+#include <memory>
 #include <string>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -87,12 +88,11 @@ enum class Language : u8 {
    Korean = 12,
    Taiwanese = 13,
    Chinese = 14,
-    BrazilianPortuguese = 15,

    Default = 255,
 };

-extern const std::array<const char*, 16> LANGUAGE_NAMES;
+extern const std::array<const char*, 15> LANGUAGE_NAMES;

 // A class representing the format used by NX metadata files, typically named Control.nacp.
 // These store application name, dev name, title id, and other miscellaneous data.
@@ -6,6 +6,7 @@

 #include <cstddef>
 #include <iterator>
+#include <string_view>
 #include "common/common_funcs.h"
 #include "common/common_types.h"

@@ -5,6 +5,7 @@
 #pragma once

 #include <array>
+#include <memory>
 #include <vector>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -53,16 +53,13 @@ Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
 }

 /*static*/ ProgramMetadata ProgramMetadata::GetDefault() {
-    // Allow use of cores 0~3 and thread priorities 1~63.
-    constexpr u32 default_thread_info_capability = 0x30007F7;
-
    ProgramMetadata result;

    result.LoadManual(
        true /*is_64_bit*/, FileSys::ProgramAddressSpaceType::Is39Bit /*address_space*/,
        0x2c /*main_thread_prio*/, 0 /*main_thread_core*/, 0x00100000 /*main_thread_stack_size*/,
        0 /*title_id*/, 0xFFFFFFFFFFFFFFFF /*filesystem_permissions*/,
-        0x1FE00000 /*system_resource_size*/, {default_thread_info_capability} /*capabilities*/);
+        0x1FE00000 /*system_resource_size*/, {} /*capabilities*/);

    return result;
 }
@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/file_sys/card_image.h"
 #include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
@@ -38,12 +39,13 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw_file) {

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

    const PatchManager patch_manager{current_process_title_id, filesystem_controller,
                                     content_provider};
-    return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw);
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }

 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
@@ -56,7 +58,8 @@ ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor

    const PatchManager patch_manager{title_id, filesystem_controller, content_provider};

-    return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type);
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type));
 }

 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex(
@@ -80,7 +83,7 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
        return ResultUnknown;
    }

-    return romfs;
+    return MakeResult<VirtualFile>(romfs);
 }

 std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,
@@ -5,9 +5,8 @@
 #pragma once

 #include <memory>
-
 #include "common/common_types.h"
-#include "core/file_sys/vfs_types.h"
+#include "core/file_sys/vfs.h"
 #include "core/hle/result.h"

 namespace Loader {
@@ -9,6 +9,7 @@
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs.h"
+#include "core/hle/kernel/k_process.h"

 namespace FileSys {

@@ -93,7 +94,7 @@ ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
        return ResultUnknown;
    }

-    return out;
+    return MakeResult<VirtualDir>(std::move(out));
 }

 ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
@@ -114,7 +115,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
        return ResultUnknown;
    }

-    return out;
+    return MakeResult<VirtualDir>(std::move(out));
 }

 VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {
@@ -142,7 +143,7 @@ std::string SaveDataFactory::GetFullPath(Core::System& system, SaveDataSpaceId s
    // be interpreted as the title id of the current process.
    if (type == SaveDataType::SaveData || type == SaveDataType::DeviceSaveData) {
        if (title_id == 0) {
-            title_id = system.GetCurrentProcessProgramID();
+            title_id = system.CurrentProcess()->GetTitleID();
        }
    }

@@ -8,6 +8,7 @@
 #include <string>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/swap.h"
 #include "core/file_sys/vfs.h"
 #include "core/hle/result.h"

@@ -25,7 +25,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
 SDMCFactory::~SDMCFactory() = default;

 ResultVal<VirtualDir> SDMCFactory::Open() const {
-    return sd_dir;
+    return MakeResult<VirtualDir>(sd_dir);
 }

 VirtualDir SDMCFactory::GetSDMCModificationLoadRoot(u64 title_id) const {
@@ -4,6 +4,7 @@

 #include <algorithm>
 #include <cstring>
+#include <string_view>

 #include <fmt/ostream.h>

@@ -4,6 +4,7 @@

 #pragma once

+#include <string>
 #include "core/file_sys/vfs_types.h"

 namespace FileSys::SystemArchive {
@@ -9,6 +9,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <vector>

@@ -6,6 +6,7 @@

 #include <map>
 #include <memory>
+#include <string_view>
 #include "core/file_sys/vfs.h"

 namespace FileSys {
@@ -5,6 +5,7 @@
 #pragma once

 #include <memory>
+#include <string_view>

 #include "core/file_sys/vfs.h"

@@ -5,15 +5,16 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/frontend/applets/controller.h"
-#include "core/hid/emulated_controller.h"
-#include "core/hid/hid_core.h"
-#include "core/hid/hid_types.h"
+#include "core/hle/service/hid/controllers/npad.h"
+#include "core/hle/service/hid/hid.h"
+#include "core/hle/service/sm/sm.h"

 namespace Core::Frontend {

 ControllerApplet::~ControllerApplet() = default;

-DefaultControllerApplet::DefaultControllerApplet(HID::HIDCore& hid_core_) : hid_core{hid_core_} {}
+DefaultControllerApplet::DefaultControllerApplet(Service::SM::ServiceManager& service_manager_)
+    : service_manager{service_manager_} {}

 DefaultControllerApplet::~DefaultControllerApplet() = default;

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

+    auto& npad =
+        service_manager.GetService<Service::HID::Hid>("hid")
+            ->GetAppletResource()
+            ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad);
+
+    auto& players = Settings::values.players.GetValue();
+
    const std::size_t min_supported_players =
        parameters.enable_single_mode ? 1 : parameters.min_players;

    // Disconnect Handheld first.
-    auto* handheld = hid_core.GetEmulatedController(Core::HID::NpadIdType::Handheld);
-    handheld->Disconnect();
+    npad.DisconnectNpadAtIndex(8);

    // Deduce the best configuration based on the input parameters.
-    for (std::size_t index = 0; index < hid_core.available_controllers - 2; ++index) {
-        auto* controller = hid_core.GetEmulatedControllerByIndex(index);
-
+    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.
-        controller->Disconnect();
+        npad.DisconnectNpadAtIndex(index);

        // Only connect the minimum number of required players.
        if (index >= min_supported_players) {
@@ -44,27 +49,27 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
        // Connect controllers based on the following priority list from highest to lowest priority:
        // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld
        if (parameters.allow_pro_controller) {
-            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
-            controller->Connect();
+            npad.AddNewControllerAt(
+                npad.MapSettingsTypeToNPad(Settings::ControllerType::ProController), index);
        } else if (parameters.allow_dual_joycons) {
-            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconDual);
-            controller->Connect();
+            npad.AddNewControllerAt(
+                npad.MapSettingsTypeToNPad(Settings::ControllerType::DualJoyconDetached), index);
        } else if (parameters.allow_left_joycon && parameters.allow_right_joycon) {
            // Assign left joycons to even player indices and right joycons to odd player indices.
            // We do this since Captain Toad Treasure Tracker expects a left joycon for Player 1 and
            // a right Joycon for Player 2 in 2 Player Assist mode.
            if (index % 2 == 0) {
-                controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconLeft);
-                controller->Connect();
+                npad.AddNewControllerAt(
+                    npad.MapSettingsTypeToNPad(Settings::ControllerType::LeftJoycon), index);
            } else {
-                controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconRight);
-                controller->Connect();
+                npad.AddNewControllerAt(
+                    npad.MapSettingsTypeToNPad(Settings::ControllerType::RightJoycon), index);
            }
        } else if (index == 0 && parameters.enable_single_mode && parameters.allow_handheld &&
                   !Settings::values.use_docked_mode.GetValue()) {
            // We should *never* reach here under any normal circumstances.
-            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
-            controller->Connect();
+            npad.AddNewControllerAt(npad.MapSettingsTypeToNPad(Settings::ControllerType::Handheld),
+                                    index);
        } else {
            UNREACHABLE_MSG("Unable to add a new controller based on the given parameters!");
        }
@@ -8,8 +8,8 @@

 #include "common/common_types.h"

-namespace Core::HID {
-class HIDCore;
+namespace Service::SM {
+class ServiceManager;
 }

 namespace Core::Frontend {
@@ -44,14 +44,14 @@ public:

 class DefaultControllerApplet final : public ControllerApplet {
 public:
-    explicit DefaultControllerApplet(HID::HIDCore& hid_core_);
+    explicit DefaultControllerApplet(Service::SM::ServiceManager& service_manager_);
    ~DefaultControllerApplet() override;

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

 private:
-    HID::HIDCore& hid_core;
+    Service::SM::ServiceManager& service_manager;
 };

 } // namespace Core::Frontend
@@ -5,6 +5,7 @@
 #pragma once

 #include <functional>
+#include <optional>
 #include "common/common_types.h"

 namespace Core::Frontend {
@@ -16,8 +16,7 @@ DefaultSoftwareKeyboardApplet::~DefaultSoftwareKeyboardApplet() = default;

 void DefaultSoftwareKeyboardApplet::InitializeKeyboard(
    bool is_inline, KeyboardInitializeParameters initialize_parameters,
-    std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-        submit_normal_callback_,
+    std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)> submit_normal_callback_,
    std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
        submit_inline_callback_) {
    if (is_inline) {
@@ -129,7 +128,7 @@ void DefaultSoftwareKeyboardApplet::ExitKeyboard() const {
 }

 void DefaultSoftwareKeyboardApplet::SubmitNormalText(std::u16string text) const {
-    submit_normal_callback(Service::AM::Applets::SwkbdResult::Ok, text, true);
+    submit_normal_callback(Service::AM::Applets::SwkbdResult::Ok, text);
 }

 void DefaultSoftwareKeyboardApplet::SubmitInlineText(std::u16string_view text) const {
@@ -5,6 +5,7 @@
 #pragma once

 #include <functional>
+#include <thread>

 #include "common/common_types.h"

@@ -57,7 +58,7 @@ public:

    virtual void InitializeKeyboard(
        bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
+        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)>
            submit_normal_callback_,
        std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
            submit_inline_callback_) = 0;
@@ -82,7 +83,7 @@ public:

    void InitializeKeyboard(
        bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
+        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)>
            submit_normal_callback_,
        std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
            submit_inline_callback_) override;
@@ -106,7 +107,7 @@ private:

    KeyboardInitializeParameters parameters;

-    mutable std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
+    mutable std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)>
        submit_normal_callback;
    mutable std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
        submit_inline_callback;
@@ -5,6 +5,7 @@
 #pragma once

 #include <functional>
+#include <string_view>

 #include "core/hle/service/am/applets/applet_web_browser_types.h"

@@ -2,32 +2,68 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <cmath>
 #include <mutex>
+#include "common/settings.h"
 #include "core/frontend/emu_window.h"
+#include "core/frontend/input.h"

 namespace Core::Frontend {

 GraphicsContext::~GraphicsContext() = default;

+class EmuWindow::TouchState : public Input::Factory<Input::TouchDevice>,
+                              public std::enable_shared_from_this<TouchState> {
+public:
+    std::unique_ptr<Input::TouchDevice> Create(const Common::ParamPackage&) override {
+        return std::make_unique<Device>(shared_from_this());
+    }
+
+    std::mutex mutex;
+
+    Input::TouchStatus status;
+
+private:
+    class Device : public Input::TouchDevice {
+    public:
+        explicit Device(std::weak_ptr<TouchState>&& touch_state_) : touch_state(touch_state_) {}
+        Input::TouchStatus GetStatus() const override {
+            if (auto state = touch_state.lock()) {
+                std::lock_guard guard{state->mutex};
+                return state->status;
+            }
+            return {};
+        }
+
+    private:
+        std::weak_ptr<TouchState> touch_state;
+    };
+};
+
 EmuWindow::EmuWindow() {
    // TODO: Find a better place to set this.
    config.min_client_area_size =
        std::make_pair(Layout::MinimumSize::Width, Layout::MinimumSize::Height);
    active_config = config;
+    touch_state = std::make_shared<TouchState>();
+    Input::RegisterFactory<Input::TouchDevice>("emu_window", touch_state);
 }

-EmuWindow::~EmuWindow() {}
+EmuWindow::~EmuWindow() {
+    Input::UnregisterFactory<Input::TouchDevice>("emu_window");
+}

-std::pair<f32, f32> EmuWindow::MapToTouchScreen(u32 framebuffer_x, u32 framebuffer_y) const {
-    std::tie(framebuffer_x, framebuffer_y) = ClipToTouchScreen(framebuffer_x, framebuffer_y);
-    const float x =
-        static_cast<float>(framebuffer_x - framebuffer_layout.screen.left) /
-        static_cast<float>(framebuffer_layout.screen.right - framebuffer_layout.screen.left);
-    const float y =
-        static_cast<float>(framebuffer_y - framebuffer_layout.screen.top) /
-        static_cast<float>(framebuffer_layout.screen.bottom - framebuffer_layout.screen.top);
-
-    return std::make_pair(x, y);
+/**
+ * Check if the given x/y coordinates are within the touchpad specified by the framebuffer layout
+ * @param layout FramebufferLayout object describing the framebuffer size and screen positions
+ * @param framebuffer_x Framebuffer x-coordinate to check
+ * @param framebuffer_y Framebuffer y-coordinate to check
+ * @return True if the coordinates are within the touchpad, otherwise false
+ */
+static bool IsWithinTouchscreen(const Layout::FramebufferLayout& layout, u32 framebuffer_x,
+                                u32 framebuffer_y) {
+    return (framebuffer_y >= layout.screen.top && framebuffer_y < layout.screen.bottom &&
+            framebuffer_x >= layout.screen.left && framebuffer_x < layout.screen.right);
 }

 std::pair<u32, u32> EmuWindow::ClipToTouchScreen(u32 new_x, u32 new_y) const {
@@ -40,6 +76,49 @@ std::pair<u32, u32> EmuWindow::ClipToTouchScreen(u32 new_x, u32 new_y) const {
    return std::make_pair(new_x, new_y);
 }

+void EmuWindow::TouchPressed(u32 framebuffer_x, u32 framebuffer_y, size_t id) {
+    if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) {
+        return;
+    }
+    if (id >= touch_state->status.size()) {
+        return;
+    }
+
+    std::lock_guard guard{touch_state->mutex};
+    const float x =
+        static_cast<float>(framebuffer_x - framebuffer_layout.screen.left) /
+        static_cast<float>(framebuffer_layout.screen.right - framebuffer_layout.screen.left);
+    const float y =
+        static_cast<float>(framebuffer_y - framebuffer_layout.screen.top) /
+        static_cast<float>(framebuffer_layout.screen.bottom - framebuffer_layout.screen.top);
+
+    touch_state->status[id] = std::make_tuple(x, y, true);
+}
+
+void EmuWindow::TouchReleased(size_t id) {
+    if (id >= touch_state->status.size()) {
+        return;
+    }
+    std::lock_guard guard{touch_state->mutex};
+    touch_state->status[id] = std::make_tuple(0.0f, 0.0f, false);
+}
+
+void EmuWindow::TouchMoved(u32 framebuffer_x, u32 framebuffer_y, size_t id) {
+    if (id >= touch_state->status.size()) {
+        return;
+    }
+
+    if (!std::get<2>(touch_state->status[id])) {
+        return;
+    }
+
+    if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) {
+        std::tie(framebuffer_x, framebuffer_y) = ClipToTouchScreen(framebuffer_x, framebuffer_y);
+    }
+
+    TouchPressed(framebuffer_x, framebuffer_y, id);
+}
+
 void EmuWindow::UpdateCurrentFramebufferLayout(u32 width, u32 height) {
    NotifyFramebufferLayoutChanged(Layout::DefaultFrameLayout(width, height));
 }
@@ -5,6 +5,7 @@
 #pragma once

 #include <memory>
+#include <tuple>
 #include <utility>
 #include "common/common_types.h"
 #include "core/frontend/framebuffer_layout.h"
@@ -112,6 +113,28 @@ public:
    /// Returns if window is shown (not minimized)
    virtual bool IsShown() const = 0;

+    /**
+     * Signal that a touch pressed event has occurred (e.g. mouse click pressed)
+     * @param framebuffer_x Framebuffer x-coordinate that was pressed
+     * @param framebuffer_y Framebuffer y-coordinate that was pressed
+     * @param id Touch event ID
+     */
+    void TouchPressed(u32 framebuffer_x, u32 framebuffer_y, size_t id);
+
+    /**
+     * Signal that a touch released event has occurred (e.g. mouse click released)
+     * @param id Touch event ID
+     */
+    void TouchReleased(size_t id);
+
+    /**
+     * Signal that a touch movement event has occurred (e.g. mouse was moved over the emu window)
+     * @param framebuffer_x Framebuffer x-coordinate
+     * @param framebuffer_y Framebuffer y-coordinate
+     * @param id Touch event ID
+     */
+    void TouchMoved(u32 framebuffer_x, u32 framebuffer_y, size_t id);
+
    /**
     * Returns currently active configuration.
     * @note Accesses to the returned object need not be consistent because it may be modified in
@@ -190,11 +213,6 @@ protected:
        client_area_height = size.second;
    }

-    /**
-     * Converts a screen postion into the equivalent touchscreen position.
-     */
-    std::pair<f32, f32> MapToTouchScreen(u32 framebuffer_x, u32 framebuffer_y) const;
-
    WindowSystemInfo window_info;

 private:
@@ -220,6 +238,9 @@ private:
    WindowConfig config;        ///< Internal configuration (changes pending for being applied in
                                /// ProcessConfigurationChanges)
    WindowConfig active_config; ///< Internal active configuration
+
+    class TouchState;
+    std::shared_ptr<TouchState> touch_state;
 };

 } // namespace Core::Frontend
@@ -25,12 +25,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
    ASSERT(height > 0);
    // The drawing code needs at least somewhat valid values for both screens
    // so just calculate them both even if the other isn't showing.
-    FramebufferLayout res{
-        .width = width,
-        .height = height,
-        .screen = {},
-        .is_srgb = false,
-    };
+    FramebufferLayout res{width, height, false, {}};

    const float window_aspect_ratio = static_cast<float>(height) / static_cast<float>(width);
    const float emulation_aspect_ratio = EmulationAspectRatio(
@@ -49,13 +44,16 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
    return res;
 }

-FramebufferLayout FrameLayoutFromResolutionScale(f32 res_scale) {
-    const bool is_docked = Settings::values.use_docked_mode.GetValue();
-    const u32 screen_width = is_docked ? ScreenDocked::Width : ScreenUndocked::Width;
-    const u32 screen_height = is_docked ? ScreenDocked::Height : ScreenUndocked::Height;
+FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
+    u32 width, height;

-    const u32 width = static_cast<u32>(static_cast<f32>(screen_width) * res_scale);
-    const u32 height = static_cast<u32>(static_cast<f32>(screen_height) * res_scale);
+    if (Settings::values.use_docked_mode.GetValue()) {
+        width = ScreenDocked::Width * res_scale;
+        height = ScreenDocked::Height * res_scale;
+    } else {
+        width = ScreenUndocked::Width * res_scale;
+        height = ScreenUndocked::Height * res_scale;
+    }

    return DefaultFrameLayout(width, height);
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Fernando Sahmkow	ee47642488	NvHost: Remake Ctrl Implementation.	2021-11-01 00:51:29 +01:00
Fernando Sahmkow	8688c59239	NvHost: Try a different approach to blocking.	2021-10-30 16:32:51 +02:00
Fernando Sahmkow	63e7957bce	NvHost: Fix some regressions and correct signaling on timeout.	2021-10-30 11:16:49 +02:00