Compare commits
21 Commits
lle-cro
...
tex-filter
Author | SHA1 | Date | |
---|---|---|---|
b94374009e | |||
b10f3d96f5 | |||
b5d744bcae | |||
89d5d4a2b6 | |||
4284893044 | |||
79ea06b226 | |||
8d811913a5 | |||
ac9d72a95c | |||
d3ce43782d | |||
597a2e8ead | |||
b231a22ea5 | |||
1110c01657 | |||
45ef11654a | |||
259dbf17dc | |||
ec55807669 | |||
36146459f8 | |||
597297ffb4 | |||
4ac10c4a9d | |||
2416258117 | |||
6d4e462e42 | |||
ef43776c7b |
@ -1,5 +1,10 @@
|
||||
#!/bin/bash -ex
|
||||
|
||||
# TODO: Work around pip install issues with Python 3.12 in the GitHub runner image.
|
||||
# See: https://github.com/actions/runner-images/issues/8709
|
||||
PYTHON_PATH=$(brew --prefix python@3.11)
|
||||
export PATH=$PYTHON_PATH/bin:$PYTHON_PATH/libexec/bin:$PATH
|
||||
|
||||
mkdir build && cd build
|
||||
cmake .. -GNinja \
|
||||
-DCMAKE_BUILD_TYPE=Release \
|
||||
|
@ -5,6 +5,9 @@ cmake .. -G Ninja \
|
||||
-DCMAKE_BUILD_TYPE=Release \
|
||||
-DCMAKE_C_COMPILER_LAUNCHER=ccache \
|
||||
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
|
||||
-DCMAKE_CXX_COMPILER=clang++ \
|
||||
-DCMAKE_C_COMPILER=clang \
|
||||
-DCMAKE_LINKER=/etc/bin/ld.lld \
|
||||
-DENABLE_QT_TRANSLATION=ON \
|
||||
-DCITRA_ENABLE_COMPATIBILITY_REPORTING=ON \
|
||||
-DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
|
||||
|
@ -1,5 +1,10 @@
|
||||
#!/bin/bash -ex
|
||||
|
||||
# TODO: Work around pip install issues with Python 3.12 in the GitHub runner image.
|
||||
# See: https://github.com/actions/runner-images/issues/8709
|
||||
PYTHON_PATH=$(brew --prefix python@3.11)
|
||||
export PATH=$PYTHON_PATH/bin:$PYTHON_PATH/libexec/bin:$PATH
|
||||
|
||||
mkdir build && cd build
|
||||
cmake .. -GNinja \
|
||||
-DCMAKE_BUILD_TYPE=Release \
|
||||
|
8
.github/workflows/build.yml
vendored
8
.github/workflows/build.yml
vendored
@ -59,7 +59,7 @@ jobs:
|
||||
name: ${{ env.OS }}-${{ env.TARGET }}
|
||||
path: artifacts/
|
||||
macos:
|
||||
runs-on: macos-latest
|
||||
runs-on: macos-13
|
||||
strategy:
|
||||
matrix:
|
||||
target: ["x86_64", "arm64"]
|
||||
@ -92,7 +92,7 @@ jobs:
|
||||
path: ${{ env.OS }}-${{ env.TARGET }}
|
||||
key: ${{ runner.os }}-${{ matrix.target }}-${{ github.sha }}-${{ github.run_id }}-${{ github.run_attempt }}
|
||||
macos-universal:
|
||||
runs-on: macos-latest
|
||||
runs-on: macos-13
|
||||
needs: macos
|
||||
env:
|
||||
OS: macos
|
||||
@ -158,7 +158,7 @@ jobs:
|
||||
if: ${{ matrix.target == 'msvc' }}
|
||||
with:
|
||||
vulkan-query-version: latest
|
||||
vulkan-components: Glslang
|
||||
vulkan-components: SPIRV-Tools, Glslang
|
||||
vulkan-use-cache: true
|
||||
- name: Set up MSYS2
|
||||
uses: msys2/setup-msys2@v2
|
||||
@ -234,7 +234,7 @@ jobs:
|
||||
name: ${{ env.OS }}-${{ env.TARGET }}
|
||||
path: src/android/app/artifacts/
|
||||
ios:
|
||||
runs-on: macos-latest
|
||||
runs-on: macos-13
|
||||
if: ${{ !startsWith(github.ref, 'refs/tags/') }}
|
||||
env:
|
||||
CCACHE_DIR: ${{ github.workspace }}/.ccache
|
||||
|
@ -17,6 +17,12 @@ include(CMakeDependentOption)
|
||||
|
||||
project(citra LANGUAGES C CXX ASM)
|
||||
|
||||
# Some submodules like to pick their own default build type if not specified.
|
||||
# Make sure we default to Release build type always, unless the generator has custom types.
|
||||
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
|
||||
set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
|
||||
endif()
|
||||
|
||||
if (APPLE)
|
||||
# Silence warnings on empty objects, for example when platform-specific code is #ifdef'd out.
|
||||
set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
|
||||
@ -86,24 +92,7 @@ option(ENABLE_LTO "Enable link time optimization" ${DEFAULT_ENABLE_LTO})
|
||||
option(CITRA_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)
|
||||
option(CITRA_WARNINGS_AS_ERRORS "Enable warnings as errors" ON)
|
||||
|
||||
# System library options
|
||||
CMAKE_DEPENDENT_OPTION(USE_SYSTEM_QT "Use the system Qt lib (instead of the bundled one)" OFF "ENABLE_QT;MSVC OR APPLE" ON)
|
||||
CMAKE_DEPENDENT_OPTION(USE_SYSTEM_MOLTENVK "Use the system MoltenVK lib (instead of the bundled one)" OFF "APPLE" OFF)
|
||||
option(USE_SYSTEM_SDL2 "Use the system SDL2 lib (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_BOOST "Use the system Boost libs (instead of the bundled ones)" OFF)
|
||||
option(USE_SYSTEM_OPENSSL "Use the system OpenSSL libs (instead of the bundled LibreSSL)" OFF)
|
||||
option(USE_SYSTEM_LIBUSB "Use the system libusb (instead of the bundled libusb)" OFF)
|
||||
option(USE_SYSTEM_CPP_JWT "Use the system cpp-jwt (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_SOUNDTOUCH "Use the system SoundTouch (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_CPP_HTTPLIB "Use the system cpp-httplib (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_JSON "Use the system JSON (nlohmann-json3) package (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_DYNARMIC "Use the system dynarmic (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_FMT "Use the system fmt (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_XBYAK "Use the system xbyak (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_INIH "Use the system inih (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_FDK_AAC_HEADERS "Use the system fdk-aac headers (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_FFMPEG_HEADERS "Use the system FFmpeg headers (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_GLSLANG "Use the system glslang and SPIR-V libraries (instead of the bundled ones)" OFF)
|
||||
include(CitraHandleSystemLibs)
|
||||
|
||||
if (CITRA_USE_PRECOMPILED_HEADERS)
|
||||
message(STATUS "Using Precompiled Headers.")
|
||||
@ -247,7 +236,7 @@ find_package(Threads REQUIRED)
|
||||
|
||||
if (ENABLE_QT)
|
||||
if (NOT USE_SYSTEM_QT)
|
||||
download_qt(6.5.1)
|
||||
download_qt(6.6.0)
|
||||
endif()
|
||||
|
||||
find_package(Qt6 REQUIRED COMPONENTS Widgets Multimedia Concurrent)
|
||||
|
10
dist/qt_themes/colorful_dark/icons/index.theme
vendored
10
dist/qt_themes/colorful_dark/icons/index.theme
vendored
@ -2,7 +2,13 @@
|
||||
Name=colorful_dark
|
||||
Comment=Colorful theme (Dark style)
|
||||
Inherits=default
|
||||
Directories=16x16
|
||||
|
||||
Directories=16x16,48x48,256x256
|
||||
|
||||
[16x16]
|
||||
Size=16
|
||||
|
||||
[48x48]
|
||||
Size=48
|
||||
|
||||
[256x256]
|
||||
Size=256
|
||||
|
@ -2,7 +2,13 @@
|
||||
Name=colorful_midnight_blue
|
||||
Comment=Colorful theme (Midnight Blue style)
|
||||
Inherits=default
|
||||
Directories=16x16
|
||||
Directories=16x16,48x48,256x256
|
||||
|
||||
[16x16]
|
||||
Size=16
|
||||
|
||||
[48x48]
|
||||
Size=48
|
||||
|
||||
[256x256]
|
||||
Size=256
|
||||
|
67
externals/CMakeLists.txt
vendored
67
externals/CMakeLists.txt
vendored
@ -34,6 +34,10 @@ if (NOT USE_SYSTEM_BOOST)
|
||||
)
|
||||
target_link_libraries(boost_iostreams PUBLIC boost)
|
||||
# Add additional boost libs here; remember to ALIAS them in the root CMakeLists!
|
||||
else()
|
||||
unset(BOOST_ROOT CACHE)
|
||||
unset(Boost_INCLUDE_DIR CACHE)
|
||||
set(Boost_NO_SYSTEM_PATHS OFF CACHE BOOL "" FORCE)
|
||||
endif()
|
||||
|
||||
# Catch2
|
||||
@ -42,11 +46,17 @@ set(CATCH_INSTALL_EXTRAS OFF CACHE BOOL "")
|
||||
add_subdirectory(catch2)
|
||||
|
||||
# Crypto++
|
||||
set(CRYPTOPP_BUILD_DOCUMENTATION OFF CACHE BOOL "")
|
||||
set(CRYPTOPP_BUILD_TESTING OFF CACHE BOOL "")
|
||||
set(CRYPTOPP_INSTALL OFF CACHE BOOL "")
|
||||
set(CRYPTOPP_SOURCES "${CMAKE_SOURCE_DIR}/externals/cryptopp" CACHE STRING "")
|
||||
add_subdirectory(cryptopp-cmake)
|
||||
if(USE_SYSTEM_CRYPTOPP)
|
||||
find_package(cryptopp REQUIRED)
|
||||
add_library(cryptopp INTERFACE)
|
||||
target_link_libraries(cryptopp INTERFACE cryptopp::cryptopp)
|
||||
else()
|
||||
set(CRYPTOPP_BUILD_DOCUMENTATION OFF CACHE BOOL "")
|
||||
set(CRYPTOPP_BUILD_TESTING OFF CACHE BOOL "")
|
||||
set(CRYPTOPP_INSTALL OFF CACHE BOOL "")
|
||||
set(CRYPTOPP_SOURCES "${CMAKE_SOURCE_DIR}/externals/cryptopp" CACHE STRING "")
|
||||
add_subdirectory(cryptopp-cmake)
|
||||
endif()
|
||||
|
||||
# dds-ktx
|
||||
add_library(dds-ktx INTERFACE)
|
||||
@ -207,22 +217,47 @@ if (ENABLE_LIBUSB AND NOT USE_SYSTEM_LIBUSB)
|
||||
endif()
|
||||
|
||||
# Zstandard
|
||||
set(ZSTD_LEGACY_SUPPORT OFF)
|
||||
set(ZSTD_BUILD_PROGRAMS OFF)
|
||||
set(ZSTD_BUILD_SHARED OFF)
|
||||
add_subdirectory(zstd/build/cmake EXCLUDE_FROM_ALL)
|
||||
target_include_directories(libzstd_static INTERFACE $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/externals/zstd/lib>)
|
||||
if(USE_SYSTEM_ZSTD)
|
||||
find_package(zstd REQUIRED)
|
||||
add_library(zstd INTERFACE)
|
||||
if(TARGET zstd::libzstd_shared)
|
||||
message(STATUS "Found system Zstandard")
|
||||
endif()
|
||||
target_link_libraries(zstd INTERFACE zstd::libzstd_shared)
|
||||
else()
|
||||
set(ZSTD_LEGACY_SUPPORT OFF)
|
||||
set(ZSTD_BUILD_PROGRAMS OFF)
|
||||
set(ZSTD_BUILD_SHARED OFF)
|
||||
add_subdirectory(zstd/build/cmake EXCLUDE_FROM_ALL)
|
||||
target_include_directories(libzstd_static INTERFACE $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/externals/zstd/lib>)
|
||||
add_library(zstd ALIAS libzstd_static)
|
||||
endif()
|
||||
|
||||
# ENet
|
||||
add_subdirectory(enet)
|
||||
target_include_directories(enet INTERFACE ./enet/include)
|
||||
if(USE_SYSTEM_ENET)
|
||||
find_package(libenet REQUIRED)
|
||||
add_library(enet INTERFACE)
|
||||
target_link_libraries(enet INTERFACE libenet::libenet)
|
||||
else()
|
||||
add_subdirectory(enet)
|
||||
target_include_directories(enet INTERFACE ./enet/include)
|
||||
endif()
|
||||
|
||||
# Cubeb
|
||||
if (ENABLE_CUBEB)
|
||||
set(BUILD_TESTS OFF CACHE BOOL "")
|
||||
set(BUILD_TOOLS OFF CACHE BOOL "")
|
||||
set(BUNDLE_SPEEX ON CACHE BOOL "")
|
||||
add_subdirectory(cubeb EXCLUDE_FROM_ALL)
|
||||
if(USE_SYSTEM_CUBEB)
|
||||
find_package(cubeb REQUIRED)
|
||||
add_library(cubeb INTERFACE)
|
||||
target_link_libraries(cubeb INTERFACE cubeb::cubeb)
|
||||
if(TARGET cubeb::cubeb)
|
||||
message(STATUS "Found system cubeb")
|
||||
endif()
|
||||
else()
|
||||
set(BUILD_TESTS OFF CACHE BOOL "")
|
||||
set(BUILD_TOOLS OFF CACHE BOOL "")
|
||||
set(BUNDLE_SPEEX ON CACHE BOOL "")
|
||||
add_subdirectory(cubeb EXCLUDE_FROM_ALL)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# DiscordRPC
|
||||
|
88
externals/cmake-modules/CitraHandleSystemLibs.cmake
vendored
Normal file
88
externals/cmake-modules/CitraHandleSystemLibs.cmake
vendored
Normal file
@ -0,0 +1,88 @@
|
||||
option(USE_SYSTEM_LIBS "Use system libraries over bundled ones" OFF)
|
||||
|
||||
# System library options
|
||||
CMAKE_DEPENDENT_OPTION(USE_SYSTEM_QT "Use the system Qt lib (instead of the bundled one)" OFF "ENABLE_QT;MSVC OR APPLE" ON)
|
||||
CMAKE_DEPENDENT_OPTION(USE_SYSTEM_MOLTENVK "Use the system MoltenVK lib (instead of the bundled one)" OFF "APPLE" OFF)
|
||||
option(USE_SYSTEM_SDL2 "Use the system SDL2 lib (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_BOOST "Use the system Boost libs (instead of the bundled ones)" OFF)
|
||||
option(USE_SYSTEM_OPENSSL "Use the system OpenSSL libs (instead of the bundled LibreSSL)" OFF)
|
||||
option(USE_SYSTEM_LIBUSB "Use the system libusb (instead of the bundled libusb)" OFF)
|
||||
option(USE_SYSTEM_CPP_JWT "Use the system cpp-jwt (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_SOUNDTOUCH "Use the system SoundTouch (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_CPP_HTTPLIB "Use the system cpp-httplib (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_JSON "Use the system JSON (nlohmann-json3) package (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_DYNARMIC "Use the system dynarmic (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_FMT "Use the system fmt (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_XBYAK "Use the system xbyak (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_INIH "Use the system inih (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_FDK_AAC_HEADERS "Use the system fdk-aac headers (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_FFMPEG_HEADERS "Use the system FFmpeg headers (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_GLSLANG "Use the system glslang and SPIR-V libraries (instead of the bundled ones)" OFF)
|
||||
option(USE_SYSTEM_ZSTD "Use the system Zstandard library (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_ENET "Use the system libenet (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_CRYPTOPP "Use the system cryptopp (instead of the bundled one)" OFF)
|
||||
option(USE_SYSTEM_CUBEB "Use the system cubeb (instead of the bundled one)" OFF)
|
||||
|
||||
# Qt and MoltenVK are handled separately
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_SDL2 "Disable system SDL2" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_BOOST "Disable system Boost" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_OPENSSL "Disable system OpenSSL" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_LIBUSB "Disable system LibUSB" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_CPP_JWT "Disable system cpp-jwt" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_SOUNDTOUCH "Disable system SoundTouch" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_CPP_HTTPLIB "Disable system cpp-httplib" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_JSON "Disable system JSON" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_DYNARMIC "Disable system Dynarmic" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_FMT "Disable system fmt" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_XBYAK "Disable system xbyak" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_INIH "Disable system inih" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_FDK_AAC_HEADERS "Disable system fdk_aac" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_FFMPEG_HEADERS "Disable system ffmpeg" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_GLSLANG "Disable system glslang" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_ZSTD "Disable system Zstandard" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_ENET "Disable system libenet" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_CRYPTOPP "Disable system cryptopp" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
CMAKE_DEPENDENT_OPTION(DISABLE_SYSTEM_CUBEB "Disable system cubeb" OFF "USE_SYSTEM_LIBS" OFF)
|
||||
|
||||
set(LIB_VAR_LIST
|
||||
SDL2
|
||||
BOOST
|
||||
OPENSSL
|
||||
LIBUSB
|
||||
CPP_JWT
|
||||
SOUNDTOUCH
|
||||
CPP_HTTPLIB
|
||||
JSON
|
||||
DYNARMIC
|
||||
FMT
|
||||
XBYAK
|
||||
INIH
|
||||
FDK_AAC_HEADERS
|
||||
FFMPEG_HEADERS
|
||||
GLSLANG
|
||||
ZSTD
|
||||
ENET
|
||||
CRYPTOPP
|
||||
CUBEB
|
||||
)
|
||||
|
||||
# First, check that USE_SYSTEM_XXX is not used with USE_SYSTEM_LIBS
|
||||
|
||||
if(USE_SYSTEM_LIBS)
|
||||
foreach(CURRENT_LIB IN LISTS LIB_VAR_LIST)
|
||||
if(USE_SYSTEM_${CURRENT_LIB})
|
||||
unset(USE_SYSTEM_${CURRENT_LIB})
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
# Next, set which libraries to use
|
||||
|
||||
foreach(CURRENT_LIB IN LISTS LIB_VAR_LIST)
|
||||
if(NOT DISABLE_SYSTEM_${CURRENT_LIB})
|
||||
set(USE_SYSTEM_${CURRENT_LIB} ON CACHE BOOL "Using system ${CURRENT_LIB}" FORCE)
|
||||
else()
|
||||
# Explicitly disable this in case of multiple CMake invocations
|
||||
set(USE_SYSTEM_${CURRENT_LIB} OFF CACHE BOOL "Using system ${CURRENT_LIB}" FORCE)
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
36
externals/cmake-modules/Findcryptopp.cmake
vendored
Normal file
36
externals/cmake-modules/Findcryptopp.cmake
vendored
Normal file
@ -0,0 +1,36 @@
|
||||
if(NOT CRYPTOPP_FOUND)
|
||||
pkg_check_modules(CRYPTOPP_TMP libcrypto++)
|
||||
|
||||
find_path(CRYPTOPP_INCLUDE_DIRS NAMES cryptlib.h
|
||||
PATHS
|
||||
${CRYPTOPP_TMP_INCLUDE_DIRS}
|
||||
/usr/include
|
||||
/usr/include/crypto++
|
||||
/usr/local/include
|
||||
/usr/local/include/crypto++
|
||||
)
|
||||
|
||||
find_library(CRYPTOPP_LIBRARY_DIRS NAMES crypto++
|
||||
PATHS
|
||||
${CRYPTOPP_TMP_LIBRARY_DIRS}
|
||||
/usr/lib
|
||||
/usr/locallib
|
||||
)
|
||||
|
||||
if(CRYPTOPP_INCLUDE_DIRS AND CRYPTOPP_LIBRARY_DIRS)
|
||||
set(CRYPTOPP_FOUND TRUE CACHE INTERNAL "Found cryptopp")
|
||||
message(STATUS "Found cryptopp: ${CRYPTOPP_LIBRARY_DIRS}, ${CRYPTOPP_INCLUDE_DIRS}")
|
||||
else()
|
||||
set(CRYPTOPP_FOUND FALSE CACHE INTERNAL "Found cryptopp")
|
||||
message(STATUS "Cryptopp not found.")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(CRYPTOPP_FOUND AND NOT TARGET cryptopp::cryptopp)
|
||||
add_library(cryptopp::cryptopp UNKNOWN IMPORTED)
|
||||
set_target_properties(cryptopp::cryptopp PROPERTIES
|
||||
INCLUDE_DIRECTORIES ${CRYPTOPP_INCLUDE_DIRS}
|
||||
INTERFACE_LINK_LIBRARIES ${CRYPTOPP_LIBRARY_DIRS}
|
||||
IMPORTED_LOCATION ${CRYPTOPP_LIBRARY_DIRS}
|
||||
)
|
||||
endif()
|
34
externals/cmake-modules/Findlibenet.cmake
vendored
Normal file
34
externals/cmake-modules/Findlibenet.cmake
vendored
Normal file
@ -0,0 +1,34 @@
|
||||
if(NOT libenet_FOUND)
|
||||
pkg_check_modules(ENET_TMP libenet)
|
||||
|
||||
find_path(libenet_INCLUDE_DIRS NAMES enet.h PATH_SUFFIXES enet
|
||||
PATHS
|
||||
${ENET_TMP_INCLUDE_DIRS}
|
||||
/usr/include
|
||||
/usr/local/include
|
||||
)
|
||||
|
||||
find_library(libenet_LIBRARY_DIRS NAMES enet
|
||||
PATHS
|
||||
${ENET_TMP_LIBRARY_DIRS}
|
||||
/usr/lib
|
||||
/usr/local/lib
|
||||
)
|
||||
|
||||
if(libenet_INCLUDE_DIRS AND libenet_LIBRARY_DIRS)
|
||||
set(libenet_FOUND TRUE CACHE INTERNAL "Found libenet")
|
||||
message(STATUS "Found libenet ${libenet_LIBRARY_DIRS}, ${libenet_INCLUDE_DIRS}")
|
||||
else()
|
||||
set(libenet_FOUND FALSE CACHE INTERNAL "Found libenet")
|
||||
message(STATUS "Libenet not found.")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(libenet_FOUND AND NOT TARGET libenet::libenet)
|
||||
add_library(libenet::libenet UNKNOWN IMPORTED)
|
||||
set_target_properties(libenet::libenet PROPERTIES
|
||||
INCLUDE_DIRECTORIES ${libenet_INCLUDE_DIRS}
|
||||
INTERFACE_LINK_LIBRARIES ${libenet_LIBRARY_DIRS}
|
||||
IMPORTED_LOCATION ${libenet_LIBRARY_DIRS}
|
||||
)
|
||||
endif()
|
@ -66,18 +66,22 @@ void DspInterface::OutputSample(std::array<s16, 2> sample) {
|
||||
}
|
||||
|
||||
void DspInterface::OutputCallback(s16* buffer, std::size_t num_frames) {
|
||||
std::size_t frames_written;
|
||||
std::size_t frames_written = 0;
|
||||
if (perform_time_stretching) {
|
||||
const std::vector<s16> in{fifo.Pop()};
|
||||
const std::size_t num_in{in.size() / 2};
|
||||
frames_written = time_stretcher.Process(in.data(), num_in, buffer, num_frames);
|
||||
} else if (flushing_time_stretcher) {
|
||||
time_stretcher.Flush();
|
||||
frames_written = time_stretcher.Process(nullptr, 0, buffer, num_frames);
|
||||
frames_written += fifo.Pop(buffer, num_frames - frames_written);
|
||||
flushing_time_stretcher = false;
|
||||
} else {
|
||||
frames_written = fifo.Pop(buffer, num_frames);
|
||||
if (flushing_time_stretcher) {
|
||||
time_stretcher.Flush();
|
||||
frames_written = time_stretcher.Process(nullptr, 0, buffer, num_frames);
|
||||
flushing_time_stretcher = false;
|
||||
|
||||
// Make sure any frames that did not fit are cleared from the time stretcher,
|
||||
// so that they do not bleed into the next time the stretcher is enabled.
|
||||
time_stretcher.Clear();
|
||||
}
|
||||
frames_written += fifo.Pop(buffer, num_frames - frames_written);
|
||||
}
|
||||
|
||||
if (frames_written > 0) {
|
||||
|
@ -18,8 +18,7 @@
|
||||
|
||||
namespace AudioCore {
|
||||
|
||||
TimeStretcher::TimeStretcher()
|
||||
: sample_rate(native_sample_rate), sound_touch(std::make_unique<soundtouch::SoundTouch>()) {
|
||||
TimeStretcher::TimeStretcher() : sound_touch(std::make_unique<soundtouch::SoundTouch>()) {
|
||||
sound_touch->setChannels(2);
|
||||
sound_touch->setSampleRate(native_sample_rate);
|
||||
sound_touch->setPitch(1.0);
|
||||
@ -30,16 +29,15 @@ TimeStretcher::~TimeStretcher() = default;
|
||||
|
||||
void TimeStretcher::SetOutputSampleRate(unsigned int sample_rate) {
|
||||
sound_touch->setSampleRate(sample_rate);
|
||||
sample_rate = native_sample_rate;
|
||||
}
|
||||
|
||||
std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
|
||||
std::size_t num_out) {
|
||||
const double time_delta = static_cast<double>(num_out) / sample_rate; // seconds
|
||||
const double time_delta = static_cast<double>(num_out) / native_sample_rate; // seconds
|
||||
double current_ratio = static_cast<double>(num_in) / static_cast<double>(num_out);
|
||||
|
||||
const double max_latency = 0.25; // seconds
|
||||
const double max_backlog = sample_rate * max_latency;
|
||||
const double max_backlog = native_sample_rate * max_latency;
|
||||
const double backlog_fullness = sound_touch->numSamples() / max_backlog;
|
||||
if (backlog_fullness > 4.0) {
|
||||
// Too many samples in backlog: Don't push anymore on
|
||||
|
@ -34,7 +34,6 @@ public:
|
||||
void Flush();
|
||||
|
||||
private:
|
||||
unsigned int sample_rate;
|
||||
std::unique_ptr<soundtouch::SoundTouch> sound_touch;
|
||||
double stretch_ratio = 1.0;
|
||||
};
|
||||
|
@ -669,9 +669,9 @@ void GRenderWindow::CaptureScreenshot(u32 res_scale, const QString& screenshot_p
|
||||
screenshot_image = QImage(QSize(layout.width, layout.height), QImage::Format_RGB32);
|
||||
system.Renderer().RequestScreenshot(
|
||||
screenshot_image.bits(),
|
||||
[this, screenshot_path] {
|
||||
[this, screenshot_path](bool invert_y) {
|
||||
const std::string std_screenshot_path = screenshot_path.toStdString();
|
||||
if (screenshot_image.mirrored(false, true).save(screenshot_path)) {
|
||||
if (screenshot_image.mirrored(false, invert_y).save(screenshot_path)) {
|
||||
LOG_INFO(Frontend, "Screenshot saved to \"{}\"", std_screenshot_path);
|
||||
} else {
|
||||
LOG_ERROR(Frontend, "Failed to save screenshot to \"{}\"", std_screenshot_path);
|
||||
|
@ -184,11 +184,6 @@
|
||||
<string>Bicubic</string>
|
||||
</property>
|
||||
</item>
|
||||
<item>
|
||||
<property name="text">
|
||||
<string>Nearest Neighbor</string>
|
||||
</property>
|
||||
</item>
|
||||
<item>
|
||||
<property name="text">
|
||||
<string>ScaleForce</string>
|
||||
@ -199,11 +194,11 @@
|
||||
<string>xBRZ</string>
|
||||
</property>
|
||||
</item>
|
||||
<item>
|
||||
<property name="text">
|
||||
<string>MMPX</string>
|
||||
</property>
|
||||
</item>
|
||||
<item>
|
||||
<property name="text">
|
||||
<string>MMPX</string>
|
||||
</property>
|
||||
</item>
|
||||
</widget>
|
||||
</item>
|
||||
</layout>
|
||||
|
@ -71,11 +71,17 @@ void ConfigureGraphics::SetConfiguration() {
|
||||
!Settings::values.physical_device.UsingGlobal());
|
||||
ConfigurationShared::SetPerGameSetting(ui->physical_device_combo,
|
||||
&Settings::values.physical_device);
|
||||
ConfigurationShared::SetPerGameSetting(ui->texture_sampling_combobox,
|
||||
&Settings::values.texture_sampling);
|
||||
ConfigurationShared::SetHighlight(ui->widget_texture_sampling,
|
||||
!Settings::values.texture_sampling.UsingGlobal());
|
||||
} else {
|
||||
ui->graphics_api_combo->setCurrentIndex(
|
||||
static_cast<int>(Settings::values.graphics_api.GetValue()));
|
||||
ui->physical_device_combo->setCurrentIndex(
|
||||
static_cast<int>(Settings::values.physical_device.GetValue()));
|
||||
ui->texture_sampling_combobox->setCurrentIndex(
|
||||
static_cast<int>(Settings::values.texture_sampling.GetValue()));
|
||||
}
|
||||
|
||||
ui->toggle_hw_shader->setChecked(Settings::values.use_hw_shader.GetValue());
|
||||
@ -106,6 +112,8 @@ void ConfigureGraphics::ApplyConfiguration() {
|
||||
use_hw_shader);
|
||||
ConfigurationShared::ApplyPerGameSetting(&Settings::values.shaders_accurate_mul,
|
||||
ui->toggle_accurate_mul, shaders_accurate_mul);
|
||||
ConfigurationShared::ApplyPerGameSetting(&Settings::values.texture_sampling,
|
||||
ui->texture_sampling_combobox);
|
||||
ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_disk_shader_cache,
|
||||
ui->toggle_disk_shader_cache, use_disk_shader_cache);
|
||||
ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync_new, ui->toggle_vsync_new,
|
||||
@ -132,6 +140,7 @@ void ConfigureGraphics::SetupPerGameUI() {
|
||||
Settings::values.use_vsync_new.UsingGlobal());
|
||||
ui->toggle_async_shaders->setEnabled(
|
||||
Settings::values.async_shader_compilation.UsingGlobal());
|
||||
ui->widget_texture_sampling->setEnabled(Settings::values.texture_sampling.UsingGlobal());
|
||||
ui->toggle_async_present->setEnabled(Settings::values.async_presentation.UsingGlobal());
|
||||
ui->graphics_api_combo->setEnabled(Settings::values.graphics_api.UsingGlobal());
|
||||
ui->physical_device_combo->setEnabled(Settings::values.physical_device.UsingGlobal());
|
||||
@ -148,6 +157,10 @@ void ConfigureGraphics::SetupPerGameUI() {
|
||||
ui->physical_device_combo, ui->physical_device_group,
|
||||
static_cast<u32>(Settings::values.physical_device.GetValue(true)));
|
||||
|
||||
ConfigurationShared::SetColoredComboBox(
|
||||
ui->texture_sampling_combobox, ui->widget_texture_sampling,
|
||||
static_cast<int>(Settings::values.texture_sampling.GetValue(true)));
|
||||
|
||||
ConfigurationShared::SetColoredTristate(ui->toggle_hw_shader, Settings::values.use_hw_shader,
|
||||
use_hw_shader);
|
||||
ConfigurationShared::SetColoredTristate(
|
||||
|
@ -212,6 +212,53 @@
|
||||
<string>Advanced</string>
|
||||
</property>
|
||||
<layout class="QVBoxLayout" name="verticalLayout_2">
|
||||
<item>
|
||||
<widget class="QWidget" name="widget_texture_sampling" native="true">
|
||||
<layout class="QHBoxLayout" name="horizontalLayout_2">
|
||||
<property name="leftMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="topMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="rightMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<property name="bottomMargin">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<item>
|
||||
<widget class="QLabel" name="texture_sampling_label">
|
||||
<property name="toolTip">
|
||||
<string><html><head/><body><p>Overrides the sampling filter used by games. This can be useful in certain cases with poorly behaved games when upscaling. If unsure set this to Game Controlled</p></body></html></string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>Texture Sampling</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QComboBox" name="texture_sampling_combobox">
|
||||
<item>
|
||||
<property name="text">
|
||||
<string>Game Controlled</string>
|
||||
</property>
|
||||
</item>
|
||||
<item>
|
||||
<property name="text">
|
||||
<string>Nearest Neighbor</string>
|
||||
</property>
|
||||
</item>
|
||||
<item>
|
||||
<property name="text">
|
||||
<string>Linear</string>
|
||||
</property>
|
||||
</item>
|
||||
</widget>
|
||||
</item>
|
||||
</layout>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QCheckBox" name="toggle_disk_shader_cache">
|
||||
<property name="toolTip">
|
||||
|
@ -258,13 +258,15 @@ void GameList::OnUpdateThemedIcons() {
|
||||
for (int i = 0; i < item_model->invisibleRootItem()->rowCount(); i++) {
|
||||
QStandardItem* child = item_model->invisibleRootItem()->child(i);
|
||||
|
||||
const int icon_size = IconSizes.at(UISettings::values.game_list_icon_size.GetValue());
|
||||
switch (child->data(GameListItem::TypeRole).value<GameListItemType>()) {
|
||||
case GameListItemType::InstalledDir:
|
||||
child->setData(QIcon::fromTheme(QStringLiteral("sd_card")).pixmap(48),
|
||||
child->setData(QIcon::fromTheme(QStringLiteral("sd_card")).pixmap(icon_size),
|
||||
Qt::DecorationRole);
|
||||
break;
|
||||
case GameListItemType::SystemDir:
|
||||
child->setData(QIcon::fromTheme(QStringLiteral("chip")).pixmap(48), Qt::DecorationRole);
|
||||
child->setData(QIcon::fromTheme(QStringLiteral("chip")).pixmap(icon_size),
|
||||
Qt::DecorationRole);
|
||||
break;
|
||||
case GameListItemType::CustomDir: {
|
||||
const UISettings::GameDir& game_dir =
|
||||
@ -272,11 +274,12 @@ void GameList::OnUpdateThemedIcons() {
|
||||
const QString icon_name = QFileInfo::exists(game_dir.path)
|
||||
? QStringLiteral("folder")
|
||||
: QStringLiteral("bad_folder");
|
||||
child->setData(QIcon::fromTheme(icon_name).pixmap(48), Qt::DecorationRole);
|
||||
child->setData(QIcon::fromTheme(icon_name).pixmap(icon_size), Qt::DecorationRole);
|
||||
break;
|
||||
}
|
||||
case GameListItemType::AddDir:
|
||||
child->setData(QIcon::fromTheme(QStringLiteral("plus")).pixmap(48), Qt::DecorationRole);
|
||||
child->setData(QIcon::fromTheme(QStringLiteral("plus")).pixmap(icon_size),
|
||||
Qt::DecorationRole);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
@ -2741,7 +2741,10 @@ void GMainWindow::filterBarSetChecked(bool state) {
|
||||
}
|
||||
|
||||
void GMainWindow::UpdateUITheme() {
|
||||
const QString default_icons = QStringLiteral(":/icons/default");
|
||||
const QString icons_base_path = QStringLiteral(":/icons/");
|
||||
const QString default_theme = QStringLiteral("default");
|
||||
const QString default_theme_path = icons_base_path + default_theme;
|
||||
|
||||
const QString& current_theme = UISettings::values.theme;
|
||||
const bool is_default_theme = current_theme == QString::fromUtf8(UISettings::themes[0].second);
|
||||
QStringList theme_paths(default_theme_paths);
|
||||
@ -2759,8 +2762,8 @@ void GMainWindow::UpdateUITheme() {
|
||||
qApp->setStyleSheet({});
|
||||
setStyleSheet({});
|
||||
}
|
||||
theme_paths.append(default_icons);
|
||||
QIcon::setThemeName(default_icons);
|
||||
theme_paths.append(default_theme_path);
|
||||
QIcon::setThemeName(default_theme);
|
||||
} else {
|
||||
const QString theme_uri(QLatin1Char{':'} + current_theme + QStringLiteral("/style.qss"));
|
||||
QFile f(theme_uri);
|
||||
@ -2772,9 +2775,9 @@ void GMainWindow::UpdateUITheme() {
|
||||
LOG_ERROR(Frontend, "Unable to set style, stylesheet file not found");
|
||||
}
|
||||
|
||||
const QString theme_name = QStringLiteral(":/icons/") + current_theme;
|
||||
theme_paths.append({default_icons, theme_name});
|
||||
QIcon::setThemeName(theme_name);
|
||||
const QString current_theme_path = icons_base_path + current_theme;
|
||||
theme_paths.append({default_theme_path, current_theme_path});
|
||||
QIcon::setThemeName(current_theme);
|
||||
}
|
||||
|
||||
QIcon::setThemeSearchPaths(theme_paths);
|
||||
@ -2998,6 +3001,10 @@ int main(int argc, char* argv[]) {
|
||||
setlocale(LC_ALL, "C");
|
||||
|
||||
auto& system{Core::System::GetInstance()};
|
||||
|
||||
// Register Qt image interface
|
||||
system.RegisterImageInterface(std::make_shared<QtImageInterface>());
|
||||
|
||||
GMainWindow main_window(system);
|
||||
|
||||
// Register frontend applets
|
||||
@ -3006,9 +3013,6 @@ int main(int argc, char* argv[]) {
|
||||
system.RegisterMiiSelector(std::make_shared<QtMiiSelector>(main_window));
|
||||
system.RegisterSoftwareKeyboard(std::make_shared<QtKeyboard>(main_window));
|
||||
|
||||
// Register Qt image interface
|
||||
system.RegisterImageInterface(std::make_shared<QtImageInterface>());
|
||||
|
||||
#ifdef __APPLE__
|
||||
// Register microphone permission check.
|
||||
system.RegisterMicPermissionCheck(&AppleAuthorization::CheckAuthorizationForMicrophone);
|
||||
|
@ -17,7 +17,7 @@
|
||||
#include "common/file_util.h"
|
||||
#include "common/logging/log.h"
|
||||
|
||||
#ifdef Q_OS_OSX
|
||||
#ifdef Q_OS_MACOS
|
||||
#define DEFAULT_TOOL_PATH QStringLiteral("../../../../maintenancetool")
|
||||
#else
|
||||
#define DEFAULT_TOOL_PATH QStringLiteral("../maintenancetool")
|
||||
@ -102,7 +102,7 @@ QString UpdaterPrivate::ToSystemExe(QString base_path) {
|
||||
return base_path + QStringLiteral(".exe");
|
||||
else
|
||||
return base_path;
|
||||
#elif defined(Q_OS_OSX)
|
||||
#elif defined(Q_OS_MACOS)
|
||||
if (base_path.endsWith(QStringLiteral(".app")))
|
||||
base_path.truncate(base_path.lastIndexOf(QStringLiteral(".")));
|
||||
return base_path + QStringLiteral(".app/Contents/MacOS/") + QFileInfo(base_path).fileName();
|
||||
@ -112,7 +112,7 @@ QString UpdaterPrivate::ToSystemExe(QString base_path) {
|
||||
}
|
||||
|
||||
QFileInfo UpdaterPrivate::GetMaintenanceTool() const {
|
||||
#if defined(Q_OS_UNIX) && !defined(Q_OS_OSX)
|
||||
#if defined(Q_OS_UNIX) && !defined(Q_OS_MACOS)
|
||||
const auto appimage_path = QProcessEnvironment::systemEnvironment()
|
||||
.value(QStringLiteral("APPIMAGE"), {})
|
||||
.toStdString();
|
||||
|
@ -124,6 +124,7 @@ add_library(citra_common STATIC
|
||||
serialization/boost_flat_set.h
|
||||
serialization/boost_small_vector.hpp
|
||||
serialization/boost_vector.hpp
|
||||
static_lru_cache.h
|
||||
string_literal.h
|
||||
string_util.cpp
|
||||
string_util.h
|
||||
@ -174,7 +175,7 @@ endif()
|
||||
create_target_directory_groups(citra_common)
|
||||
|
||||
target_link_libraries(citra_common PUBLIC fmt library-headers microprofile Boost::boost Boost::serialization Boost::iostreams)
|
||||
target_link_libraries(citra_common PRIVATE libzstd_static)
|
||||
target_link_libraries(citra_common PRIVATE zstd)
|
||||
|
||||
if ("x86_64" IN_LIST ARCHITECTURE)
|
||||
target_link_libraries(citra_common PRIVATE xbyak)
|
||||
|
@ -1155,6 +1155,43 @@ std::size_t IOFile::ReadImpl(void* data, std::size_t length, std::size_t data_si
|
||||
return std::fread(data, data_size, length, m_file);
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
static std::size_t pread(int fd, void* buf, size_t count, uint64_t offset) {
|
||||
long unsigned int read_bytes = 0;
|
||||
OVERLAPPED overlapped = {0};
|
||||
HANDLE file = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
|
||||
|
||||
overlapped.OffsetHigh = static_cast<uint32_t>(offset >> 32);
|
||||
overlapped.Offset = static_cast<uint32_t>(offset & 0xFFFF'FFFFLL);
|
||||
SetLastError(0);
|
||||
bool ret = ReadFile(file, buf, static_cast<uint32_t>(count), &read_bytes, &overlapped);
|
||||
|
||||
if (!ret && GetLastError() != ERROR_HANDLE_EOF) {
|
||||
errno = GetLastError();
|
||||
return std::numeric_limits<std::size_t>::max();
|
||||
}
|
||||
return read_bytes;
|
||||
}
|
||||
#else
|
||||
#define pread ::pread
|
||||
#endif
|
||||
|
||||
std::size_t IOFile::ReadAtImpl(void* data, std::size_t length, std::size_t data_size,
|
||||
std::size_t offset) {
|
||||
if (!IsOpen()) {
|
||||
m_good = false;
|
||||
return std::numeric_limits<std::size_t>::max();
|
||||
}
|
||||
|
||||
if (length == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEBUG_ASSERT(data != nullptr);
|
||||
|
||||
return pread(fileno(m_file), data, data_size * length, offset);
|
||||
}
|
||||
|
||||
std::size_t IOFile::WriteImpl(const void* data, std::size_t length, std::size_t data_size) {
|
||||
if (!IsOpen()) {
|
||||
m_good = false;
|
||||
|
@ -294,6 +294,18 @@ public:
|
||||
return items_read;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
std::size_t ReadAtArray(T* data, std::size_t length, std::size_t offset) {
|
||||
static_assert(std::is_trivially_copyable_v<T>,
|
||||
"Given array does not consist of trivially copyable objects");
|
||||
|
||||
std::size_t items_read = ReadAtImpl(data, length, sizeof(T), offset);
|
||||
if (items_read != length)
|
||||
m_good = false;
|
||||
|
||||
return items_read;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
std::size_t WriteArray(const T* data, std::size_t length) {
|
||||
static_assert(std::is_trivially_copyable_v<T>,
|
||||
@ -312,6 +324,12 @@ public:
|
||||
return ReadArray(reinterpret_cast<char*>(data), length);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
std::size_t ReadAtBytes(T* data, std::size_t length, std::size_t offset) {
|
||||
static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
|
||||
return ReadAtArray(reinterpret_cast<char*>(data), length, offset);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
std::size_t WriteBytes(const T* data, std::size_t length) {
|
||||
static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
|
||||
@ -363,6 +381,8 @@ public:
|
||||
|
||||
private:
|
||||
std::size_t ReadImpl(void* data, std::size_t length, std::size_t data_size);
|
||||
std::size_t ReadAtImpl(void* data, std::size_t length, std::size_t data_size,
|
||||
std::size_t offset);
|
||||
std::size_t WriteImpl(const void* data, std::size_t length, std::size_t data_size);
|
||||
|
||||
bool Open();
|
||||
|
@ -46,8 +46,6 @@ std::string_view GetTextureFilterName(TextureFilter filter) {
|
||||
return "Anime4K";
|
||||
case TextureFilter::Bicubic:
|
||||
return "Bicubic";
|
||||
case TextureFilter::NearestNeighbor:
|
||||
return "NearestNeighbor";
|
||||
case TextureFilter::ScaleForce:
|
||||
return "ScaleForce";
|
||||
case TextureFilter::xBRZ:
|
||||
@ -59,6 +57,19 @@ std::string_view GetTextureFilterName(TextureFilter filter) {
|
||||
}
|
||||
}
|
||||
|
||||
std::string_view GetTextureSamplingName(TextureSampling sampling) {
|
||||
switch (sampling) {
|
||||
case TextureSampling::GameControlled:
|
||||
return "GameControlled";
|
||||
case TextureSampling::NearestNeighbor:
|
||||
return "NearestNeighbor";
|
||||
case TextureSampling::Linear:
|
||||
return "Linear";
|
||||
default:
|
||||
return "Invalid";
|
||||
}
|
||||
}
|
||||
|
||||
} // Anonymous namespace
|
||||
|
||||
Values values = {};
|
||||
@ -87,6 +98,8 @@ void LogSettings() {
|
||||
log_setting("Renderer_PostProcessingShader", values.pp_shader_name.GetValue());
|
||||
log_setting("Renderer_FilterMode", values.filter_mode.GetValue());
|
||||
log_setting("Renderer_TextureFilter", GetTextureFilterName(values.texture_filter.GetValue()));
|
||||
log_setting("Renderer_TextureSampling",
|
||||
GetTextureSamplingName(values.texture_sampling.GetValue()));
|
||||
log_setting("Stereoscopy_Render3d", values.render_3d.GetValue());
|
||||
log_setting("Stereoscopy_Factor3d", values.factor_3d.GetValue());
|
||||
log_setting("Stereoscopy_MonoRenderOption", values.mono_render_option.GetValue());
|
||||
@ -175,6 +188,7 @@ void RestoreGlobalState(bool is_powered_on) {
|
||||
values.resolution_factor.SetGlobal(true);
|
||||
values.frame_limit.SetGlobal(true);
|
||||
values.texture_filter.SetGlobal(true);
|
||||
values.texture_sampling.SetGlobal(true);
|
||||
values.layout_option.SetGlobal(true);
|
||||
values.swap_screen.SetGlobal(true);
|
||||
values.upright_screen.SetGlobal(true);
|
||||
|
@ -72,10 +72,15 @@ enum class TextureFilter : u32 {
|
||||
None = 0,
|
||||
Anime4K = 1,
|
||||
Bicubic = 2,
|
||||
NearestNeighbor = 3,
|
||||
ScaleForce = 4,
|
||||
xBRZ = 5,
|
||||
MMPX = 6
|
||||
ScaleForce = 3,
|
||||
xBRZ = 4,
|
||||
MMPX = 5,
|
||||
};
|
||||
|
||||
enum class TextureSampling : u32 {
|
||||
GameControlled = 0,
|
||||
NearestNeighbor = 1,
|
||||
Linear = 2,
|
||||
};
|
||||
|
||||
namespace NativeButton {
|
||||
@ -451,6 +456,8 @@ struct Values {
|
||||
SwitchableSetting<u32, true> resolution_factor{1, 0, 10, "resolution_factor"};
|
||||
SwitchableSetting<u16, true> frame_limit{100, 0, 1000, "frame_limit"};
|
||||
SwitchableSetting<TextureFilter> texture_filter{TextureFilter::None, "texture_filter"};
|
||||
SwitchableSetting<TextureSampling> texture_sampling{TextureSampling::GameControlled,
|
||||
"texture_sampling"};
|
||||
|
||||
SwitchableSetting<LayoutOption> layout_option{LayoutOption::Default, "layout_option"};
|
||||
SwitchableSetting<bool> swap_screen{false, "swap_screen"};
|
||||
|
113
src/common/static_lru_cache.h
Normal file
113
src/common/static_lru_cache.h
Normal file
@ -0,0 +1,113 @@
|
||||
// Modified version of: https://www.boost.org/doc/libs/1_79_0/boost/compute/detail/lru_cache.hpp
|
||||
// Most important change is the use of an array instead of a map, so that elements are
|
||||
// statically allocated. The insert and get methods have been merged into the request method.
|
||||
// Original license:
|
||||
//
|
||||
//---------------------------------------------------------------------------//
|
||||
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0
|
||||
// See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt
|
||||
//
|
||||
// See http://boostorg.github.com/compute for more information.
|
||||
//---------------------------------------------------------------------------//
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <list>
|
||||
#include <tuple>
|
||||
#include <utility>
|
||||
|
||||
namespace Common {
|
||||
|
||||
// a cache which evicts the least recently used item when it is full
|
||||
// the cache elements are statically allocated.
|
||||
template <class Key, class Value, size_t Size>
|
||||
class StaticLRUCache {
|
||||
public:
|
||||
using key_type = Key;
|
||||
using value_type = Value;
|
||||
using list_type = std::list<std::pair<Key, size_t>>;
|
||||
using array_type = std::array<Value, Size>;
|
||||
|
||||
StaticLRUCache() = default;
|
||||
|
||||
~StaticLRUCache() = default;
|
||||
|
||||
size_t size() const {
|
||||
return m_list.size();
|
||||
}
|
||||
|
||||
constexpr size_t capacity() const {
|
||||
return m_array.size();
|
||||
}
|
||||
|
||||
bool empty() const {
|
||||
return m_list.empty();
|
||||
}
|
||||
|
||||
bool contains(const key_type& key) const {
|
||||
return find(key) != m_list.end();
|
||||
}
|
||||
|
||||
// Requests an element from the cache. If it is not found,
|
||||
// the element is inserted using its key.
|
||||
// Returns whether the element was present in the cache
|
||||
// and a reference to the element itself.
|
||||
std::pair<bool, value_type&> request(const key_type& key) {
|
||||
// lookup value in the cache
|
||||
auto i = find(key);
|
||||
if (i == m_list.cend()) {
|
||||
size_t next_index = size();
|
||||
// insert item into the cache, but first check if it is full
|
||||
if (next_index >= capacity()) {
|
||||
// cache is full, evict the least recently used item
|
||||
next_index = evict();
|
||||
}
|
||||
|
||||
// insert the new item
|
||||
m_list.push_front(std::make_pair(key, next_index));
|
||||
return std::pair<bool, value_type&>(false, m_array[next_index]);
|
||||
}
|
||||
// return the value, but first update its place in the most
|
||||
// recently used list
|
||||
if (i != m_list.cbegin()) {
|
||||
// move item to the front of the most recently used list
|
||||
auto backup = *i;
|
||||
m_list.erase(i);
|
||||
m_list.push_front(backup);
|
||||
|
||||
// return the value
|
||||
return std::pair<bool, value_type&>(true, m_array[backup.second]);
|
||||
} else {
|
||||
// the item is already at the front of the most recently
|
||||
// used list so just return it
|
||||
return std::pair<bool, value_type&>(true, m_array[i->second]);
|
||||
}
|
||||
}
|
||||
|
||||
void clear() {
|
||||
m_list.clear();
|
||||
}
|
||||
|
||||
private:
|
||||
typename list_type::const_iterator find(const key_type& key) const {
|
||||
return std::find_if(m_list.cbegin(), m_list.cend(),
|
||||
[&key](const auto& el) { return el.first == key; });
|
||||
}
|
||||
|
||||
size_t evict() {
|
||||
// evict item from the end of most recently used list
|
||||
typename list_type::iterator i = --m_list.end();
|
||||
size_t evicted_index = i->second;
|
||||
m_list.erase(i);
|
||||
return evicted_index;
|
||||
}
|
||||
|
||||
private:
|
||||
array_type m_array;
|
||||
list_type m_list;
|
||||
};
|
||||
|
||||
} // namespace Common
|
@ -5,6 +5,7 @@
|
||||
#include <algorithm>
|
||||
#include <zstd.h>
|
||||
|
||||
#include "common/logging/log.h"
|
||||
#include "common/zstd_compression.h"
|
||||
|
||||
namespace Common::Compression {
|
||||
|
@ -86,6 +86,20 @@ public:
|
||||
*/
|
||||
virtual void Flush() const = 0;
|
||||
|
||||
/**
|
||||
* Whether the backend supports cached reads.
|
||||
*/
|
||||
virtual bool AllowsCachedReads() const {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the cache is ready for a specified offset and length.
|
||||
*/
|
||||
virtual bool CacheReady(std::size_t file_offset, std::size_t length) {
|
||||
return false;
|
||||
}
|
||||
|
||||
protected:
|
||||
std::unique_ptr<DelayGenerator> delay_generator;
|
||||
|
||||
|
@ -131,6 +131,14 @@ public:
|
||||
}
|
||||
void Flush() const override {}
|
||||
|
||||
bool AllowsCachedReads() const override {
|
||||
return romfs_file->AllowsCachedReads();
|
||||
}
|
||||
|
||||
bool CacheReady(std::size_t file_offset, std::size_t length) override {
|
||||
return romfs_file->CacheReady(file_offset, length);
|
||||
}
|
||||
|
||||
private:
|
||||
std::shared_ptr<RomFSReader> romfs_file;
|
||||
|
||||
|
@ -53,6 +53,14 @@ public:
|
||||
|
||||
bool DumpRomFS(const std::string& target_path);
|
||||
|
||||
bool AllowsCachedReads() const override {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CacheReady(std::size_t file_offset, std::size_t length) override {
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
struct File;
|
||||
struct Directory {
|
||||
|
@ -1,4 +1,5 @@
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <cryptopp/aes.h>
|
||||
#include <cryptopp/modes.h>
|
||||
#include "common/archives.h"
|
||||
@ -9,17 +10,102 @@ SERIALIZE_EXPORT_IMPL(FileSys::DirectRomFSReader)
|
||||
namespace FileSys {
|
||||
|
||||
std::size_t DirectRomFSReader::ReadFile(std::size_t offset, std::size_t length, u8* buffer) {
|
||||
length = std::min(length, static_cast<std::size_t>(data_size) - offset);
|
||||
if (length == 0)
|
||||
return 0; // Crypto++ does not like zero size buffer
|
||||
file.Seek(file_offset + offset, SEEK_SET);
|
||||
std::size_t read_length = std::min(length, static_cast<std::size_t>(data_size) - offset);
|
||||
read_length = file.ReadBytes(buffer, read_length);
|
||||
if (is_encrypted) {
|
||||
CryptoPP::CTR_Mode<CryptoPP::AES>::Decryption d(key.data(), key.size(), ctr.data());
|
||||
d.Seek(crypto_offset + offset);
|
||||
d.ProcessData(buffer, buffer, read_length);
|
||||
|
||||
const auto segments = BreakupRead(offset, length);
|
||||
size_t read_progress = 0;
|
||||
|
||||
// Skip cache if the read is too big
|
||||
if (segments.size() == 1 && segments[0].second > cache_line_size) {
|
||||
length = file.ReadAtBytes(buffer, length, file_offset + offset);
|
||||
if (is_encrypted) {
|
||||
CryptoPP::CTR_Mode<CryptoPP::AES>::Decryption d(key.data(), key.size(), ctr.data());
|
||||
d.Seek(crypto_offset + offset);
|
||||
d.ProcessData(buffer, buffer, length);
|
||||
}
|
||||
// LOG_INFO(Service_FS, "Cache SKIP: offset={}, length={}", offset, length);
|
||||
return length;
|
||||
}
|
||||
return read_length;
|
||||
|
||||
// TODO(PabloMK7): Make cache thread safe, read the comment in CacheReady function.
|
||||
// std::unique_lock<std::shared_mutex> read_guard(cache_mutex);
|
||||
for (const auto& seg : segments) {
|
||||
size_t read_size = cache_line_size;
|
||||
size_t page = OffsetToPage(seg.first);
|
||||
// Check if segment is in cache
|
||||
auto cache_entry = cache.request(page);
|
||||
if (!cache_entry.first) {
|
||||
// If not found, read from disk and cache the data
|
||||
read_size = file.ReadAtBytes(cache_entry.second.data(), read_size, file_offset + page);
|
||||
if (is_encrypted && read_size) {
|
||||
CryptoPP::CTR_Mode<CryptoPP::AES>::Decryption d(key.data(), key.size(), ctr.data());
|
||||
d.Seek(crypto_offset + page);
|
||||
d.ProcessData(cache_entry.second.data(), cache_entry.second.data(), read_size);
|
||||
}
|
||||
// LOG_INFO(Service_FS, "Cache MISS: page={}, length={}, into={}", page, seg.second,
|
||||
// (seg.first - page));
|
||||
} else {
|
||||
// LOG_INFO(Service_FS, "Cache HIT: page={}, length={}, into={}", page, seg.second,
|
||||
// (seg.first - page));
|
||||
}
|
||||
size_t copy_amount =
|
||||
(read_size > (seg.first - page))
|
||||
? std::min((seg.first - page) + seg.second, read_size) - (seg.first - page)
|
||||
: 0;
|
||||
std::memcpy(buffer + read_progress, cache_entry.second.data() + (seg.first - page),
|
||||
copy_amount);
|
||||
read_progress += copy_amount;
|
||||
}
|
||||
return read_progress;
|
||||
}
|
||||
|
||||
bool DirectRomFSReader::AllowsCachedReads() const {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool DirectRomFSReader::CacheReady(std::size_t file_offset, std::size_t length) {
|
||||
auto segments = BreakupRead(file_offset, length);
|
||||
if (segments.size() == 1 && segments[0].second > cache_line_size) {
|
||||
return false;
|
||||
} else {
|
||||
// TODO(PabloMK7): Since the LRU cache is not thread safe, a lock must be used.
|
||||
// However, this completely breaks the point of using a cache, because
|
||||
// smaller reads may be blocked by bigger reads. For now, always return
|
||||
// data being in cache to prevent the need of a lock, and only read data
|
||||
// asynchronously if it is too big to use the cache.
|
||||
/*
|
||||
std::shared_lock<std::shared_mutex> read_guard(cache_mutex);
|
||||
for (auto it = segments.begin(); it != segments.end(); it++) {
|
||||
if (!cache.contains(OffsetToPage(it->first)))
|
||||
return false;
|
||||
}
|
||||
*/
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::pair<std::size_t, std::size_t>> DirectRomFSReader::BreakupRead(
|
||||
std::size_t offset, std::size_t length) {
|
||||
|
||||
std::vector<std::pair<std::size_t, std::size_t>> ret;
|
||||
|
||||
// Reads bigger than the cache line size will probably never hit again
|
||||
if (length > cache_line_size) {
|
||||
ret.push_back(std::make_pair(offset, length));
|
||||
return ret;
|
||||
}
|
||||
|
||||
size_t curr_offset = offset;
|
||||
while (length) {
|
||||
size_t next_page = OffsetToPage(curr_offset + cache_line_size);
|
||||
size_t curr_page_len = std::min(length, next_page - curr_offset);
|
||||
ret.push_back(std::make_pair(curr_offset, curr_page_len));
|
||||
curr_offset = next_page;
|
||||
length -= curr_page_len;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
} // namespace FileSys
|
||||
|
@ -1,11 +1,14 @@
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <shared_mutex>
|
||||
#include <boost/serialization/array.hpp>
|
||||
#include <boost/serialization/base_object.hpp>
|
||||
#include <boost/serialization/export.hpp>
|
||||
#include "common/alignment.h"
|
||||
#include "common/common_types.h"
|
||||
#include "common/file_util.h"
|
||||
#include "common/static_lru_cache.h"
|
||||
|
||||
namespace FileSys {
|
||||
|
||||
@ -18,6 +21,8 @@ public:
|
||||
|
||||
virtual std::size_t GetSize() const = 0;
|
||||
virtual std::size_t ReadFile(std::size_t offset, std::size_t length, u8* buffer) = 0;
|
||||
virtual bool AllowsCachedReads() const = 0;
|
||||
virtual bool CacheReady(std::size_t file_offset, std::size_t length) = 0;
|
||||
|
||||
private:
|
||||
template <class Archive>
|
||||
@ -48,6 +53,10 @@ public:
|
||||
|
||||
std::size_t ReadFile(std::size_t offset, std::size_t length, u8* buffer) override;
|
||||
|
||||
bool AllowsCachedReads() const override;
|
||||
|
||||
bool CacheReady(std::size_t file_offset, std::size_t length) override;
|
||||
|
||||
private:
|
||||
bool is_encrypted;
|
||||
FileUtil::IOFile file;
|
||||
@ -57,8 +66,23 @@ private:
|
||||
u64 crypto_offset;
|
||||
u64 data_size;
|
||||
|
||||
// Total cache size: 128KB
|
||||
static constexpr size_t cache_line_size = (1 << 13); // About 8KB
|
||||
static constexpr size_t cache_line_count = 16;
|
||||
|
||||
Common::StaticLRUCache<std::size_t, std::array<u8, cache_line_size>, cache_line_count> cache;
|
||||
// TODO(PabloMK7): Make cache thread safe, read the comment in CacheReady function.
|
||||
// std::shared_mutex cache_mutex;
|
||||
|
||||
DirectRomFSReader() = default;
|
||||
|
||||
std::size_t OffsetToPage(std::size_t offset) {
|
||||
return Common::AlignDown<std::size_t>(offset, cache_line_size);
|
||||
}
|
||||
|
||||
std::vector<std::pair<std::size_t, std::size_t>> BreakupRead(std::size_t offset,
|
||||
std::size_t length);
|
||||
|
||||
template <class Archive>
|
||||
void serialize(Archive& ar, const unsigned int) {
|
||||
ar& boost::serialization::base_object<RomFSReader>(*this);
|
||||
|
@ -6,6 +6,7 @@
|
||||
#include "common/archives.h"
|
||||
#include "common/common_types.h"
|
||||
#include "common/logging/log.h"
|
||||
#include "core/global.h"
|
||||
#include "core/hle/kernel/address_arbiter.h"
|
||||
#include "core/hle/kernel/errors.h"
|
||||
#include "core/hle/kernel/kernel.h"
|
||||
@ -20,7 +21,7 @@ void AddressArbiter::WaitThread(std::shared_ptr<Thread> thread, VAddr wait_addre
|
||||
waiting_threads.emplace_back(std::move(thread));
|
||||
}
|
||||
|
||||
u64 AddressArbiter::ResumeAllThreads(VAddr address) {
|
||||
void AddressArbiter::ResumeAllThreads(VAddr address) {
|
||||
// Determine which threads are waiting on this address, those should be woken up.
|
||||
auto itr = std::stable_partition(waiting_threads.begin(), waiting_threads.end(),
|
||||
[address](const auto& thread) {
|
||||
@ -30,15 +31,13 @@ u64 AddressArbiter::ResumeAllThreads(VAddr address) {
|
||||
});
|
||||
|
||||
// Wake up all the found threads
|
||||
const u64 num_threads = std::distance(itr, waiting_threads.end());
|
||||
std::for_each(itr, waiting_threads.end(), [](auto& thread) { thread->ResumeFromWait(); });
|
||||
|
||||
// Remove the woken up threads from the wait list.
|
||||
waiting_threads.erase(itr, waiting_threads.end());
|
||||
return num_threads;
|
||||
}
|
||||
|
||||
bool AddressArbiter::ResumeHighestPriorityThread(VAddr address) {
|
||||
std::shared_ptr<Thread> AddressArbiter::ResumeHighestPriorityThread(VAddr address) {
|
||||
// Determine which threads are waiting on this address, those should be considered for wakeup.
|
||||
auto matches_start = std::stable_partition(
|
||||
waiting_threads.begin(), waiting_threads.end(), [address](const auto& thread) {
|
||||
@ -55,15 +54,14 @@ bool AddressArbiter::ResumeHighestPriorityThread(VAddr address) {
|
||||
return lhs->current_priority < rhs->current_priority;
|
||||
});
|
||||
|
||||
if (itr == waiting_threads.end()) {
|
||||
return false;
|
||||
}
|
||||
if (itr == waiting_threads.end())
|
||||
return nullptr;
|
||||
|
||||
auto thread = *itr;
|
||||
thread->ResumeFromWait();
|
||||
waiting_threads.erase(itr);
|
||||
|
||||
return true;
|
||||
waiting_threads.erase(itr);
|
||||
return thread;
|
||||
}
|
||||
|
||||
AddressArbiter::AddressArbiter(KernelSystem& kernel)
|
||||
@ -109,28 +107,17 @@ ResultCode AddressArbiter::ArbitrateAddress(std::shared_ptr<Thread> thread, Arbi
|
||||
switch (type) {
|
||||
|
||||
// Signal thread(s) waiting for arbitrate address...
|
||||
case ArbitrationType::Signal: {
|
||||
u64 num_threads{};
|
||||
|
||||
case ArbitrationType::Signal:
|
||||
// Negative value means resume all threads
|
||||
if (value < 0) {
|
||||
num_threads = ResumeAllThreads(address);
|
||||
ResumeAllThreads(address);
|
||||
} else {
|
||||
// Resume first N threads
|
||||
for (s32 i = 0; i < value; i++) {
|
||||
num_threads += ResumeHighestPriorityThread(address);
|
||||
}
|
||||
}
|
||||
|
||||
// Prevents lag from low priority threads that spam svcArbitrateAddress and wake no threads
|
||||
// The tick count is taken directly from official HOS kernel. The priority value is one less
|
||||
// than official kernel as the affected FMV threads dont meet the priority threshold of 50.
|
||||
// TODO: Revisit this when scheduler is rewritten and adjust if there isn't a problem there.
|
||||
if (num_threads == 0 && thread->current_priority >= 49) {
|
||||
kernel.current_cpu->GetTimer().AddTicks(1614u);
|
||||
for (int i = 0; i < value; i++)
|
||||
ResumeHighestPriorityThread(address);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// Wait current thread (acquire the arbiter)...
|
||||
case ArbitrationType::WaitIfLessThan:
|
||||
if ((s32)kernel.memory.Read32(address) < value) {
|
||||
|
@ -65,11 +65,11 @@ private:
|
||||
void WaitThread(std::shared_ptr<Thread> thread, VAddr wait_address);
|
||||
|
||||
/// Resume all threads found to be waiting on the address under this address arbiter
|
||||
u64 ResumeAllThreads(VAddr address);
|
||||
void ResumeAllThreads(VAddr address);
|
||||
|
||||
/// Resume one thread found to be waiting on the address under this address arbiter and return
|
||||
/// the resumed thread.
|
||||
bool ResumeHighestPriorityThread(VAddr address);
|
||||
std::shared_ptr<Thread> ResumeHighestPriorityThread(VAddr address);
|
||||
|
||||
/// Threads waiting for the address arbiter to be signaled.
|
||||
std::vector<std::shared_ptr<Thread>> waiting_threads;
|
||||
|
@ -221,6 +221,13 @@ public:
|
||||
return session;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the client thread that made the service request.
|
||||
*/
|
||||
std::shared_ptr<Thread> ClientThread() const {
|
||||
return thread;
|
||||
}
|
||||
|
||||
class WakeupCallback {
|
||||
public:
|
||||
virtual ~WakeupCallback() = default;
|
||||
|
@ -1,7 +1,7 @@
|
||||
// Copyright 2015 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
#include "core/hle/result.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <memory>
|
||||
#include <boost/serialization/array.hpp>
|
||||
@ -459,7 +459,8 @@ ResultVal<VAddr> Process::AllocateThreadLocalStorage() {
|
||||
return tls_address;
|
||||
}
|
||||
|
||||
ResultCode Process::Map(VAddr target, VAddr source, u32 size, VMAPermission perms, bool privileged) {
|
||||
ResultCode Process::Map(VAddr target, VAddr source, u32 size, VMAPermission perms,
|
||||
bool privileged) {
|
||||
LOG_DEBUG(Kernel, "Map memory target={:08X}, source={:08X}, size={:08X}, perms={:08X}", target,
|
||||
source, size, perms);
|
||||
if (!privileged && (source < Memory::HEAP_VADDR || source + size > Memory::HEAP_VADDR_END ||
|
||||
@ -501,10 +502,8 @@ ResultCode Process::Map(VAddr target, VAddr source, u32 size, VMAPermission perm
|
||||
CASCADE_CODE(vm_manager.ChangeMemoryState(source, size, MemoryState::Private,
|
||||
VMAPermission::ReadWrite, source_state, source_perm));
|
||||
|
||||
// Retrieve backing blocks from the source address space
|
||||
CASCADE_RESULT(auto backing_blocks, vm_manager.GetBackingBlocksForRange(source, size));
|
||||
VAddr interval_target = target;
|
||||
|
||||
for (const auto& backing_block : backing_blocks) {
|
||||
auto backing_memory = kernel.memory.GetFCRAMRef(backing_block.lower());
|
||||
auto block_size = backing_block.upper() - backing_block.lower();
|
||||
@ -517,36 +516,6 @@ ResultCode Process::Map(VAddr target, VAddr source, u32 size, VMAPermission perm
|
||||
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ResultCode Process::MapInterprocess(Process& src, VAddr target, VAddr source, u32 size, VMAPermission perms) {
|
||||
u32 cursor = 0;
|
||||
while (true) {
|
||||
const auto source_iter = src.vm_manager.FindVMA(source + cursor);
|
||||
auto& source_vma = source_iter->second;
|
||||
|
||||
// Skip non-allocated blocks
|
||||
if (source_vma.type == VMAType::Free) {
|
||||
cursor += source_vma.size;
|
||||
continue;
|
||||
}
|
||||
|
||||
ASSERT(source_vma.type == VMAType::BackingMemory);
|
||||
ASSERT(source_vma.backing_memory);
|
||||
ASSERT(source_vma.base == source + cursor);
|
||||
|
||||
if (source_vma.size + cursor > size) {
|
||||
break;
|
||||
}
|
||||
|
||||
const auto target_vma = vm_manager.MapBackingMemory(target + cursor, source_vma.backing_memory,
|
||||
source_vma.size, MemoryState::Shared);
|
||||
ASSERT(target_vma.Succeeded());
|
||||
cursor += source_vma.size;
|
||||
}
|
||||
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ResultCode Process::Unmap(VAddr target, VAddr source, u32 size, VMAPermission perms,
|
||||
bool privileged) {
|
||||
LOG_DEBUG(Kernel, "Unmap memory target={:08X}, source={:08X}, size={:08X}, perms={:08X}",
|
||||
|
@ -209,6 +209,9 @@ public:
|
||||
*/
|
||||
void Exit();
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Memory Management
|
||||
|
||||
VMManager vm_manager;
|
||||
|
||||
u32 memory_used = 0;
|
||||
@ -240,8 +243,6 @@ public:
|
||||
|
||||
ResultCode Map(VAddr target, VAddr source, u32 size, VMAPermission perms,
|
||||
bool privileged = false);
|
||||
ResultCode MapInterprocess(Process& src, VAddr target, VAddr source,
|
||||
u32 size, VMAPermission perms);
|
||||
ResultCode Unmap(VAddr target, VAddr source, u32 size, VMAPermission perms,
|
||||
bool privileged = false);
|
||||
|
||||
|
@ -1,16 +1,14 @@
|
||||
// Copyright 2014 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
#pragma optimize("", off)
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <fmt/format.h>
|
||||
#include "common/alignment.h"
|
||||
#include "common/archives.h"
|
||||
#include "common/logging/log.h"
|
||||
#include "common/microprofile.h"
|
||||
#include "common/scm_rev.h"
|
||||
#include "common/scope_exit.h"
|
||||
#include "core/arm/arm_interface.h"
|
||||
#include "core/core.h"
|
||||
#include "core/core_timing.h"
|
||||
@ -440,10 +438,6 @@ private:
|
||||
ResultCode UnmapProcessMemoryEx(Handle process, u32 dst_address, u32 size);
|
||||
ResultCode ControlProcess(Handle process_handle, u32 process_OP, u32 varg2, u32 varg3);
|
||||
|
||||
ResultCode ControlProcessMemory(Handle process, u32 addr0, u32 addr1, u32 size, u32 type, u32 perm);
|
||||
ResultCode MapProcessMemory(Handle process, u32 dest_address, u32 size);
|
||||
ResultCode UnmapProcessMemory(Handle process, u32 start_address, u32 size);
|
||||
|
||||
struct FunctionDef {
|
||||
using Func = void (SVC::*)();
|
||||
|
||||
@ -2109,283 +2103,6 @@ ResultCode SVC::ControlProcess(Handle process_handle, u32 process_OP, u32 varg2,
|
||||
}
|
||||
}
|
||||
|
||||
ResultCode SVC::ControlProcessMemory(Handle process, u32 addr0, u32 addr1, u32 size, u32 operation, u32 permissions) {
|
||||
LOG_DEBUG(Kernel_SVC,
|
||||
"called operation=0x{:08X}, addr0=0x{:08X}, addr1=0x{:08X}, "
|
||||
"size=0x{:X}, permissions=0x{:08X}",
|
||||
operation, addr0, addr1, size, permissions);
|
||||
|
||||
if (!addr0) {
|
||||
return ResultCode{0xD8E007F6};
|
||||
}
|
||||
|
||||
if ((addr0 & Memory::CITRA_PAGE_MASK) != 0 || (addr1 & Memory::CITRA_PAGE_MASK) != 0) {
|
||||
return ERR_MISALIGNED_ADDRESS;
|
||||
}
|
||||
if ((size & Memory::CITRA_PAGE_MASK) != 0) {
|
||||
return ERR_MISALIGNED_SIZE;
|
||||
}
|
||||
|
||||
u32 region = operation & MEMOP_REGION_MASK;
|
||||
operation &= ~MEMOP_REGION_MASK;
|
||||
|
||||
if (region != 0) {
|
||||
LOG_WARNING(Kernel_SVC, "ControlMemory with specified region not supported, region={:X}",
|
||||
region);
|
||||
}
|
||||
|
||||
VMAPermission vma_permissions = (VMAPermission)permissions;
|
||||
|
||||
const auto dst_process = kernel.GetCurrentProcess()->handle_table.Get<Process>(process);
|
||||
|
||||
SCOPE_EXIT({ system.GetRunningCore().ClearInstructionCache(); });
|
||||
|
||||
switch (operation & MEMOP_OPERATION_MASK) {
|
||||
case MEMOP_MAP: {
|
||||
CASCADE_CODE(dst_process->Map(addr0, addr1, size, vma_permissions, true));
|
||||
break;
|
||||
}
|
||||
case MEMOP_UNMAP: {
|
||||
CASCADE_CODE(dst_process->Unmap(addr0, addr1, size, vma_permissions, true));
|
||||
break;
|
||||
}
|
||||
case MEMOP_PROTECT: {
|
||||
CASCADE_CODE(dst_process->vm_manager.ReprotectRange(addr0, size, vma_permissions));
|
||||
break;
|
||||
}
|
||||
default:
|
||||
LOG_ERROR(Kernel_SVC, "unknown operation=0x%08X", operation);
|
||||
return ResultCode(ErrorDescription::NotImplemented, ErrorModule::Kernel,
|
||||
ErrorSummary::NotSupported, ErrorLevel::Fatal);
|
||||
}
|
||||
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ResultCode SVC::MapProcessMemory(Handle process, u32 start_addr, u32 size) {
|
||||
const auto dst_process = kernel.GetCurrentProcess();
|
||||
const auto src_process = kernel.GetCurrentProcess()->handle_table.Get<Process>(process);
|
||||
if (!dst_process) {
|
||||
return ERR_INVALID_HANDLE;
|
||||
}
|
||||
|
||||
// Map up to 0x3F00000 bytes starting from 0x100000 from the source process into the current
|
||||
// process' address space at the specified address. Note: Non-page aligned sizes do not return
|
||||
// an error, the lower bits are just discarded.
|
||||
const u32 code_size =
|
||||
Common::AlignDown(std::min<u32>(size, Memory::PROCESS_IMAGE_MAX_SIZE), Memory::CITRA_PAGE_SIZE);
|
||||
ResultCode result = dst_process->MapInterprocess(*src_process, start_addr, Memory::PROCESS_IMAGE_VADDR,
|
||||
code_size, VMAPermission::ReadWrite);
|
||||
ASSERT(result.IsSuccess());
|
||||
|
||||
static constexpr u32 MaxHeapSize = 0x6000000;
|
||||
static constexpr u32 HeapOffset = 0x7F00000;
|
||||
|
||||
// Now map up to 0x6000000 bytes starting from 0x8000000 from the source process into the
|
||||
// current process' address space at the specified address + 0x7F00000.
|
||||
const u32 heap_size =
|
||||
Common::AlignDown(std::min<u32>(size - HeapOffset, MaxHeapSize), Memory::CITRA_PAGE_SIZE);
|
||||
if (heap_size > 0) {
|
||||
result = dst_process->MapInterprocess(*src_process, start_addr + HeapOffset, Memory::HEAP_VADDR,
|
||||
heap_size, VMAPermission::ReadWrite);
|
||||
ASSERT(result.IsSuccess());
|
||||
}
|
||||
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ResultCode SVC::UnmapProcessMemory(Handle process, VAddr start_addr, u32 size) {
|
||||
const u32 code_size =
|
||||
Common::AlignDown(std::min<u32>(size, Memory::PROCESS_IMAGE_MAX_SIZE), Memory::CITRA_PAGE_SIZE);
|
||||
|
||||
ResultCode result = kernel.GetCurrentProcess()->vm_manager.UnmapRange(start_addr, code_size);
|
||||
ASSERT(result.IsSuccess());
|
||||
|
||||
static constexpr u32 MaxHeapSize = 0x6000000;
|
||||
static constexpr u32 HeapOffset = 0x7F00000;
|
||||
|
||||
const u32 heap_size =
|
||||
Common::AlignDown(std::min<u32>(size - HeapOffset, MaxHeapSize), Memory::CITRA_PAGE_SIZE);
|
||||
result = kernel.GetCurrentProcess()->vm_manager.UnmapRange(start_addr + HeapOffset, heap_size);
|
||||
ASSERT(result.IsSuccess());
|
||||
|
||||
system.GetRunningCore().ClearInstructionCache();
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
/*ResultCode SVC::ControlProcessMemory(Handle process, u32 addr0, u32 addr1, u32 size, u32 operation, u32 permissions) {
|
||||
LOG_DEBUG(Kernel_SVC,
|
||||
"called operation=0x{:08X}, addr0=0x{:08X}, addr1=0x{:08X}, "
|
||||
"size=0x{:X}, permissions=0x{:08X}",
|
||||
operation, addr0, addr1, size, permissions);
|
||||
|
||||
if (!addr0) {
|
||||
return ResultCode{0xD8E007F6};
|
||||
}
|
||||
|
||||
if ((addr0 & Memory::CITRA_PAGE_MASK) != 0 || (addr1 & Memory::CITRA_PAGE_MASK) != 0) {
|
||||
return ERR_MISALIGNED_ADDRESS;
|
||||
}
|
||||
if ((size & Memory::CITRA_PAGE_MASK) != 0) {
|
||||
return ERR_MISALIGNED_SIZE;
|
||||
}
|
||||
|
||||
u32 region = operation & MEMOP_REGION_MASK;
|
||||
operation &= ~MEMOP_REGION_MASK;
|
||||
|
||||
if (region != 0) {
|
||||
LOG_WARNING(Kernel_SVC, "ControlMemory with specified region not supported, region={:X}",
|
||||
region);
|
||||
}
|
||||
|
||||
VMAPermission vma_permissions = (VMAPermission)permissions;
|
||||
|
||||
const auto dst_process = kernel.GetCurrentProcess()->handle_table.Get<Process>(process);
|
||||
|
||||
SCOPE_EXIT({ system.GetRunningCore().ClearInstructionCache(); });
|
||||
|
||||
switch (operation) {
|
||||
case MEMOP_MAP: {
|
||||
|
||||
if (addr0 != addr1) {
|
||||
// TODO(Subv): Check if the addresses are valid.
|
||||
auto addr1_vma = dst_process->vm_manager.FindVMA(addr1);
|
||||
ASSERT(addr1_vma->second.meminfo_state == MemoryState::Private);
|
||||
ASSERT(addr1 + size <= addr1_vma->second.base + addr1_vma->second.size);
|
||||
ASSERT((static_cast<u32>(addr1_vma->second.permissions) &
|
||||
static_cast<u32>(VMAPermission::ReadWrite)) ==
|
||||
static_cast<u32>(VMAPermission::ReadWrite));
|
||||
|
||||
auto addr0_vma = dst_process->vm_manager.FindVMA(addr0);
|
||||
ASSERT(addr0_vma->second.meminfo_state == MemoryState::Free);
|
||||
ASSERT(addr0 + size <= addr0_vma->second.base + addr0_vma->second.size);
|
||||
|
||||
// Note: The real kernel will crash if this fails and the addresses are valid.
|
||||
auto result = dst_process->vm_manager.AliasMemory(
|
||||
addr0, addr1, size, MemoryState::AliasCode, MemoryState::Locked);
|
||||
ASSERT(result.Succeeded());
|
||||
ASSERT(dst_process->vm_manager.ReprotectRange(addr0, size, vma_permissions).IsSuccess());
|
||||
ASSERT(
|
||||
dst_process->vm_manager.ReprotectRange(addr1, size, VMAPermission::None).IsSuccess());
|
||||
} else {
|
||||
// This code path acts like PROTECT but also changes the memory state.
|
||||
CASCADE_CODE(dst_process->vm_manager.ChangeMemoryState(
|
||||
addr0, size, MemoryState::Private, VMAPermission::ReadWrite, MemoryState::AliasCode,
|
||||
vma_permissions));
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case MEMOP_UNMAP: {
|
||||
if (addr0 != addr1) {
|
||||
// TODO(Subv): Check if the addresses are valid.
|
||||
auto addr1_vma = dst_process->vm_manager.FindVMA(addr1);
|
||||
if (addr1_vma->second.meminfo_state != MemoryState::Locked) {
|
||||
return ResultCode(0xE0A01BF5);
|
||||
}
|
||||
ASSERT(addr1 + size <= addr1_vma->second.base + addr1_vma->second.size);
|
||||
|
||||
auto addr0_vma = dst_process->vm_manager.FindVMA(addr0);
|
||||
ASSERT(addr0_vma->second.meminfo_state == MemoryState::AliasCode);
|
||||
ASSERT(addr0 + size <= addr0_vma->second.base + addr0_vma->second.size);
|
||||
|
||||
ResultCode result = dst_process->vm_manager.UnmapRange(addr0, size);
|
||||
ASSERT(result.IsSuccess());
|
||||
|
||||
result = dst_process->vm_manager.ChangeMemoryState(addr1, size, MemoryState::Locked,
|
||||
VMAPermission::None,
|
||||
MemoryState::Private, vma_permissions);
|
||||
ASSERT(result.IsSuccess());
|
||||
return result;
|
||||
} else {
|
||||
// This code path acts like PROTECT but also changes the memory state.
|
||||
CASCADE_CODE(dst_process->vm_manager.ChangeMemoryState(
|
||||
addr0, size, MemoryState::AliasCode, VMAPermission::None, MemoryState::Private,
|
||||
vma_permissions));
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case MEMOP_PROTECT: {
|
||||
ResultCode result = dst_process->vm_manager.ReprotectRange(addr0, size, vma_permissions);
|
||||
if (result.IsError())
|
||||
return result;
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
LOG_ERROR(Kernel_SVC, "unknown operation=0x%08X", operation);
|
||||
return ResultCode(ErrorDescription::NotImplemented, ErrorModule::Kernel,
|
||||
ErrorSummary::NotSupported, ErrorLevel::Fatal);
|
||||
}
|
||||
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ResultCode SVC::MapProcessMemory(Handle process, u32 start_addr, u32 size) {
|
||||
const auto dst_process = kernel.GetCurrentProcess();
|
||||
const auto src_process = kernel.GetCurrentProcess()->handle_table.Get<Process>(process);
|
||||
if (!dst_process) {
|
||||
return ERR_INVALID_HANDLE;
|
||||
}
|
||||
|
||||
SCOPE_EXIT({ system.GetRunningCore().ClearInstructionCache(); });
|
||||
|
||||
// Map up to 0x3F00000 bytes starting from 0x100000 from the source process into the current
|
||||
// process' address space at the specified address. Note: Non-page aligned sizes do not return
|
||||
// an error, the lower bits are just discarded.
|
||||
u32 code_size =
|
||||
Common::AlignDown(std::min<u32>(size, Memory::PROCESS_IMAGE_MAX_SIZE), Memory::CITRA_PAGE_SIZE);
|
||||
|
||||
auto vma_handle = dst_process->vm_manager.FindVMA(start_addr);
|
||||
if (vma_handle->second.type != Kernel::VMAType::Free) {
|
||||
return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::OS,
|
||||
ErrorSummary::InvalidState, ErrorLevel::Usage);
|
||||
}
|
||||
|
||||
auto result = dst_process->vm_manager.AliasMemory(
|
||||
start_addr, Memory::PROCESS_IMAGE_VADDR, code_size, Kernel::MemoryState::Shared,
|
||||
Kernel::VMAPermission::ReadWrite, src_process->vm_manager);
|
||||
// TODO(Subv): Handle error cases.
|
||||
ASSERT(result.IsSuccess());
|
||||
|
||||
// Now map up to 0x6000000 bytes starting from 0x8000000 from the source process into the
|
||||
// current process' address space at the specified address + 0x7F00000.
|
||||
static constexpr u32 MaxHeapSize = 0x6000000;
|
||||
static constexpr u32 HeapOffset = 0x7F00000;
|
||||
u32 heap_size =
|
||||
Common::AlignDown(std::min<u32>(size - HeapOffset, MaxHeapSize), Memory::CITRA_PAGE_SIZE);
|
||||
if (heap_size > 0) {
|
||||
result = dst_process->vm_manager.AliasMemory(
|
||||
start_addr + HeapOffset, Memory::HEAP_VADDR, heap_size, Kernel::MemoryState::Shared,
|
||||
Kernel::VMAPermission::ReadWrite, src_process->vm_manager);
|
||||
// TODO(Subv): Handle error cases.
|
||||
ASSERT(result.IsSuccess());
|
||||
}
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ResultCode SVC::UnmapProcessMemory(Handle process, VAddr start_addr, u32 size) {
|
||||
const u32 code_size =
|
||||
Common::AlignDown(std::min<u32>(size, Memory::PROCESS_IMAGE_MAX_SIZE), Memory::CITRA_PAGE_SIZE);
|
||||
|
||||
SCOPE_EXIT({ system.GetRunningCore().ClearInstructionCache(); });
|
||||
|
||||
ResultCode result = kernel.GetCurrentProcess()->vm_manager.UnmapRange(start_addr, code_size);
|
||||
ASSERT(result.IsSuccess());
|
||||
|
||||
static constexpr u32 MaxHeapSize = 0x6000000;
|
||||
static constexpr u32 HeapOffset = 0x7F00000;
|
||||
|
||||
const u32 heap_size =
|
||||
Common::AlignDown(std::min<u32>(size - HeapOffset, MaxHeapSize), Memory::CITRA_PAGE_SIZE);
|
||||
result = kernel.GetCurrentProcess()->vm_manager.UnmapRange(start_addr + HeapOffset, heap_size);
|
||||
ASSERT(result.IsSuccess());
|
||||
|
||||
system.GetRunningCore().ClearInstructionCache();
|
||||
return RESULT_SUCCESS;
|
||||
}*/
|
||||
|
||||
const std::array<SVC::FunctionDef, 180> SVC::SVC_Table{{
|
||||
{0x00, nullptr, "Unknown"},
|
||||
{0x01, &SVC::Wrap<&SVC::ControlMemory>, "ControlMemory"},
|
||||
@ -2499,9 +2216,9 @@ const std::array<SVC::FunctionDef, 180> SVC::SVC_Table{{
|
||||
{0x6D, nullptr, "GetDebugThreadParam"},
|
||||
{0x6E, nullptr, "Unknown"},
|
||||
{0x6F, nullptr, "Unknown"},
|
||||
{0x70, &SVC::Wrap<&SVC::ControlProcessMemory>, "ControlProcessMemory"},
|
||||
{0x71, &SVC::Wrap<&SVC::MapProcessMemory>, "MapProcessMemory"},
|
||||
{0x72, &SVC::Wrap<&SVC::UnmapProcessMemory>, "UnmapProcessMemory"},
|
||||
{0x70, nullptr, "ControlProcessMemory"},
|
||||
{0x71, nullptr, "MapProcessMemory"},
|
||||
{0x72, nullptr, "UnmapProcessMemory"},
|
||||
{0x73, nullptr, "CreateCodeSet"},
|
||||
{0x74, nullptr, "RandomStub"},
|
||||
{0x75, nullptr, "CreateProcess"},
|
||||
|
@ -1,6 +1,7 @@
|
||||
// Copyright 2015 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
#include "common/assert.h"
|
||||
@ -306,11 +307,11 @@ ResultVal<VMManager::VMAIter> VMManager::CarveVMARange(VAddr target, u32 size) {
|
||||
ASSERT(size > 0);
|
||||
|
||||
VMAIter begin_vma = StripIterConstness(FindVMA(target));
|
||||
//const VMAIter i_end = vma_map.lower_bound(target_end);
|
||||
//if (std::any_of(begin_vma, i_end,
|
||||
// [](const auto& entry) { return entry.second.type == VMAType::Free; })) {
|
||||
// return ERR_INVALID_ADDRESS_STATE;
|
||||
//}
|
||||
const VMAIter i_end = vma_map.lower_bound(target_end);
|
||||
if (std::any_of(begin_vma, i_end,
|
||||
[](const auto& entry) { return entry.second.type == VMAType::Free; })) {
|
||||
return ERR_INVALID_ADDRESS_STATE;
|
||||
}
|
||||
|
||||
if (target != begin_vma->second.base) {
|
||||
begin_vma = SplitVMA(begin_vma, target - begin_vma->second.base);
|
||||
@ -341,7 +342,6 @@ VMManager::VMAIter VMManager::SplitVMA(VMAIter vma_handle, u32 offset_in_vma) {
|
||||
case VMAType::Free:
|
||||
break;
|
||||
case VMAType::BackingMemory:
|
||||
case VMAType::MemoryAlias:
|
||||
new_vma.backing_memory += offset_in_vma;
|
||||
break;
|
||||
case VMAType::MMIO:
|
||||
@ -379,7 +379,6 @@ void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) {
|
||||
memory.UnmapRegion(*page_table, vma.base, vma.size);
|
||||
break;
|
||||
case VMAType::BackingMemory:
|
||||
case VMAType::MemoryAlias:
|
||||
memory.MapMemoryRegion(*page_table, vma.base, vma.size, vma.backing_memory);
|
||||
break;
|
||||
case VMAType::MMIO:
|
||||
@ -397,97 +396,21 @@ ResultVal<MemoryRegionInfo::IntervalSet> VMManager::GetBackingBlocksForRange(VAd
|
||||
MemoryRegionInfo::IntervalSet backing_blocks;
|
||||
VAddr interval_target = address;
|
||||
while (interval_target != address + size) {
|
||||
const auto it = FindVMA(interval_target);
|
||||
if (it == vma_map.end() || (it->second.type != VMAType::BackingMemory && it->second.type != VMAType::Free)) {
|
||||
auto vma = FindVMA(interval_target);
|
||||
if (vma->second.type != VMAType::BackingMemory) {
|
||||
LOG_ERROR(Kernel, "Trying to use already freed memory");
|
||||
return ERR_INVALID_ADDRESS_STATE;
|
||||
}
|
||||
|
||||
const auto vma = it->second;
|
||||
const VAddr interval_end = std::min(address + size, vma.base + vma.size);
|
||||
const u32 interval_size = interval_end - interval_target;
|
||||
if (vma.type != VMAType::Free) {
|
||||
const auto backing_memory = memory.GetFCRAMOffset(vma.backing_memory + (interval_target - vma.base));
|
||||
backing_blocks +=
|
||||
MemoryRegionInfo::Interval(backing_memory, backing_memory + interval_size);
|
||||
}
|
||||
VAddr interval_end = std::min(address + size, vma->second.base + vma->second.size);
|
||||
u32 interval_size = interval_end - interval_target;
|
||||
auto backing_memory = memory.GetFCRAMOffset(vma->second.backing_memory +
|
||||
(interval_target - vma->second.base));
|
||||
backing_blocks +=
|
||||
MemoryRegionInfo::Interval(backing_memory, backing_memory + interval_size);
|
||||
|
||||
interval_target += interval_size;
|
||||
}
|
||||
return backing_blocks;
|
||||
}
|
||||
|
||||
ResultVal<VMManager::VMAHandle> VMManager::AliasMemory(VAddr target, VAddr source, u32 size,
|
||||
MemoryState alias_state,
|
||||
MemoryState aliased_state) {
|
||||
VMAIter source_iter = StripIterConstness(FindVMA(source));
|
||||
ASSERT(source_iter != vma_map.end());
|
||||
|
||||
auto& source_vma = source_iter->second;
|
||||
ASSERT(source_vma.type == VMAType::BackingMemory);
|
||||
ASSERT(source_vma.backing_memory != nullptr);
|
||||
ASSERT(source + size <= source_vma.base + source_vma.size);
|
||||
|
||||
CASCADE_RESULT(VMAIter vma_handle, CarveVMA(target, size));
|
||||
VirtualMemoryArea& final_vma = vma_handle->second;
|
||||
ASSERT(final_vma.size == size);
|
||||
|
||||
final_vma.type = VMAType::MemoryAlias;
|
||||
final_vma.permissions = VMAPermission::None;
|
||||
final_vma.meminfo_state = alias_state;
|
||||
final_vma.backing_memory = source_vma.backing_memory + (source - source_vma.base);
|
||||
UpdatePageTableForVMA(final_vma);
|
||||
|
||||
// Update the source VMA state with the new value
|
||||
CASCADE_RESULT(auto new_vma, CarveVMARange(source, size));
|
||||
new_vma->second.meminfo_state = aliased_state;
|
||||
UpdatePageTableForVMA(new_vma->second);
|
||||
|
||||
return MergeAdjacent(vma_handle);
|
||||
}
|
||||
|
||||
ResultCode VMManager::AliasMemory(VAddr target, VAddr source, u32 size, MemoryState alias_state,
|
||||
VMAPermission alias_permissions,
|
||||
const VMManager& source_address_space) {
|
||||
|
||||
u32 cursor = 0;
|
||||
|
||||
while (true) {
|
||||
VMAHandle source_iter = source_address_space.FindVMA(source + cursor);
|
||||
ASSERT(source_iter != vma_map.end());
|
||||
|
||||
auto& source_vma = source_iter->second;
|
||||
// Skip non-allocated blocks
|
||||
if (source_vma.type == VMAType::Free) {
|
||||
cursor += source_vma.size;
|
||||
continue;
|
||||
}
|
||||
|
||||
ASSERT(source_vma.type == VMAType::BackingMemory ||
|
||||
source_vma.type == VMAType::MemoryAlias);
|
||||
ASSERT(source_vma.backing_memory != nullptr);
|
||||
ASSERT(source_vma.base == source + cursor);
|
||||
|
||||
if (source_vma.size + cursor > size) {
|
||||
break;
|
||||
}
|
||||
|
||||
CASCADE_RESULT(VMAIter vma_handle, CarveVMA(target + cursor, source_vma.size));
|
||||
VirtualMemoryArea& final_vma = vma_handle->second;
|
||||
ASSERT(final_vma.size == source_vma.size);
|
||||
|
||||
final_vma.type = VMAType::MemoryAlias;
|
||||
final_vma.meminfo_state = alias_state;
|
||||
final_vma.permissions = alias_permissions;
|
||||
final_vma.backing_memory = source_vma.backing_memory;
|
||||
UpdatePageTableForVMA(final_vma);
|
||||
|
||||
MergeAdjacent(vma_handle);
|
||||
|
||||
cursor += source_vma.size;
|
||||
}
|
||||
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
} // namespace Kernel
|
||||
|
@ -27,8 +27,6 @@ enum class VMAType : u8 {
|
||||
BackingMemory,
|
||||
/// VMA is mapped to MMIO registers at a fixed PAddr.
|
||||
MMIO,
|
||||
/// VMA is an alias of another VMA.
|
||||
MemoryAlias,
|
||||
};
|
||||
|
||||
/// Permissions for mapped memory blocks
|
||||
@ -180,12 +178,6 @@ public:
|
||||
ResultVal<VMAHandle> MapMMIO(VAddr target, PAddr paddr, u32 size, MemoryState state,
|
||||
Memory::MMIORegionPointer mmio_handler);
|
||||
|
||||
ResultVal<VMAHandle> AliasMemory(VAddr target, VAddr source, u32 size, MemoryState alias_state,
|
||||
MemoryState aliased_state);
|
||||
|
||||
ResultCode AliasMemory(VAddr target, VAddr source, u32 size, MemoryState alias_state,
|
||||
VMAPermission alias_permissions, const VMManager& source_address_space);
|
||||
|
||||
/**
|
||||
* Updates the memory state and permissions of the specified range. The range's original memory
|
||||
* state and permissions must match the `expected` parameters.
|
||||
|
@ -57,7 +57,6 @@ void File::Read(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
u64 offset = rp.Pop<u64>();
|
||||
u32 length = rp.Pop<u32>();
|
||||
auto& buffer = rp.PopMappedBuffer();
|
||||
LOG_TRACE(Service_FS, "Read {}: offset=0x{:x} length=0x{:08X}", GetName(), offset, length);
|
||||
|
||||
const FileSessionSlot* file = GetSessionData(ctx.Session());
|
||||
@ -76,22 +75,94 @@ void File::Read(Kernel::HLERequestContext& ctx) {
|
||||
offset, length, backend->GetSize());
|
||||
}
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(2, 2);
|
||||
// Conventional reading if the backend does not support cache.
|
||||
if (!backend->AllowsCachedReads()) {
|
||||
auto& buffer = rp.PopMappedBuffer();
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(2, 2);
|
||||
std::unique_ptr<u8*> data = std::make_unique<u8*>(static_cast<u8*>(operator new(length)));
|
||||
const auto read = backend->Read(offset, length, *data);
|
||||
if (read.Failed()) {
|
||||
rb.Push(read.Code());
|
||||
rb.Push<u32>(0);
|
||||
} else {
|
||||
buffer.Write(*data, 0, *read);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.Push<u32>(static_cast<u32>(*read));
|
||||
}
|
||||
rb.PushMappedBuffer(buffer);
|
||||
|
||||
std::vector<u8> data(length);
|
||||
ResultVal<std::size_t> read = backend->Read(offset, data.size(), data.data());
|
||||
if (read.Failed()) {
|
||||
rb.Push(read.Code());
|
||||
rb.Push<u32>(0);
|
||||
} else {
|
||||
buffer.Write(data.data(), 0, *read);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.Push<u32>(static_cast<u32>(*read));
|
||||
std::chrono::nanoseconds read_timeout_ns{backend->GetReadDelayNs(length)};
|
||||
ctx.SleepClientThread("file::read", read_timeout_ns, nullptr);
|
||||
return;
|
||||
}
|
||||
rb.PushMappedBuffer(buffer);
|
||||
|
||||
std::chrono::nanoseconds read_timeout_ns{backend->GetReadDelayNs(length)};
|
||||
ctx.SleepClientThread("file::read", read_timeout_ns, nullptr);
|
||||
struct AsyncData {
|
||||
// Input
|
||||
u32 length;
|
||||
u64 offset;
|
||||
std::chrono::steady_clock::time_point pre_timer;
|
||||
bool cache_ready;
|
||||
|
||||
// Output
|
||||
ResultCode ret{0};
|
||||
Kernel::MappedBuffer* buffer;
|
||||
std::unique_ptr<u8*> data;
|
||||
size_t read_size;
|
||||
};
|
||||
|
||||
auto async_data = std::make_shared<AsyncData>();
|
||||
async_data->buffer = &rp.PopMappedBuffer();
|
||||
async_data->length = length;
|
||||
async_data->offset = offset;
|
||||
async_data->cache_ready = backend->CacheReady(offset, length);
|
||||
if (!async_data->cache_ready) {
|
||||
async_data->pre_timer = std::chrono::steady_clock::now();
|
||||
}
|
||||
|
||||
// LOG_DEBUG(Service_FS, "cache={}, offset={}, length={}", cache_ready, offset, length);
|
||||
ctx.RunAsync(
|
||||
[this, async_data](Kernel::HLERequestContext& ctx) {
|
||||
async_data->data =
|
||||
std::make_unique<u8*>(static_cast<u8*>(operator new(async_data->length)));
|
||||
const auto read =
|
||||
backend->Read(async_data->offset, async_data->length, *async_data->data);
|
||||
if (read.Failed()) {
|
||||
async_data->ret = read.Code();
|
||||
async_data->read_size = 0;
|
||||
} else {
|
||||
async_data->ret = RESULT_SUCCESS;
|
||||
async_data->read_size = *read;
|
||||
}
|
||||
|
||||
const auto read_delay = static_cast<s64>(backend->GetReadDelayNs(async_data->length));
|
||||
if (!async_data->cache_ready) {
|
||||
const auto time_took = std::chrono::duration_cast<std::chrono::nanoseconds>(
|
||||
std::chrono::steady_clock::now() - async_data->pre_timer)
|
||||
.count();
|
||||
/*
|
||||
if (time_took > read_delay) {
|
||||
LOG_DEBUG(Service_FS, "Took longer! length={}, time_took={}, read_delay={}",
|
||||
async_data->length, time_took, read_delay);
|
||||
}
|
||||
*/
|
||||
return static_cast<s64>((read_delay > time_took) ? (read_delay - time_took) : 0);
|
||||
} else {
|
||||
return static_cast<s64>(read_delay);
|
||||
}
|
||||
},
|
||||
[async_data](Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestBuilder rb(ctx, 0x0802, 2, 2);
|
||||
if (async_data->ret.IsError()) {
|
||||
rb.Push(async_data->ret);
|
||||
rb.Push<u32>(0);
|
||||
} else {
|
||||
async_data->buffer->Write(*async_data->data, 0, async_data->read_size);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.Push<u32>(static_cast<u32>(async_data->read_size));
|
||||
}
|
||||
rb.PushMappedBuffer(*async_data->buffer);
|
||||
},
|
||||
!async_data->cache_ready);
|
||||
}
|
||||
|
||||
void File::Write(Kernel::HLERequestContext& ctx) {
|
||||
|
@ -1,8 +1,7 @@
|
||||
// Copyright 2014 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
#pragma optimize("", off)
|
||||
#include <cryptopp/sha.h>
|
||||
|
||||
#include "common/archives.h"
|
||||
#include "common/assert.h"
|
||||
#include "common/common_types.h"
|
||||
@ -671,6 +670,26 @@ void FS_USER::GetFormatInfo(Kernel::HLERequestContext& ctx) {
|
||||
rb.Push<bool>(format_info->duplicate_data != 0);
|
||||
}
|
||||
|
||||
void FS_USER::GetProductInfo(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
|
||||
u32 process_id = rp.Pop<u32>();
|
||||
|
||||
LOG_DEBUG(Service_FS, "called, process_id={}", process_id);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(6, 0);
|
||||
|
||||
const auto product_info = GetProductInfo(process_id);
|
||||
if (!product_info.has_value()) {
|
||||
rb.Push(ResultCode(FileSys::ErrCodes::ArchiveNotMounted, ErrorModule::FS,
|
||||
ErrorSummary::NotFound, ErrorLevel::Status));
|
||||
return;
|
||||
}
|
||||
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushRaw<ProductInfo>(product_info.value());
|
||||
}
|
||||
|
||||
void FS_USER::GetProgramLaunchInfo(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const auto process_id = rp.Pop<u32>();
|
||||
@ -688,8 +707,20 @@ void FS_USER::GetProgramLaunchInfo(Kernel::HLERequestContext& ctx) {
|
||||
return;
|
||||
}
|
||||
|
||||
ProgramInfo program_info = program_info_result.Unwrap();
|
||||
|
||||
// Always report the launched program mediatype is SD if the friends module is requesting this
|
||||
// information and the media type is game card. Otherwise, friends will append a "romid" field
|
||||
// to the NASC request with a cartridge unique identifier. Using a dump of a game card and the
|
||||
// game card itself at the same time online is known to have caused issues in the past.
|
||||
auto process = ctx.ClientThread()->owner_process.lock();
|
||||
if (process && process->codeset->name == "friends" &&
|
||||
program_info.media_type == MediaType::GameCard) {
|
||||
program_info.media_type = MediaType::SDMC;
|
||||
}
|
||||
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushRaw(program_info_result.Unwrap());
|
||||
rb.PushRaw<ProgramInfo>(program_info);
|
||||
}
|
||||
|
||||
void FS_USER::ObsoletedCreateExtSaveData(Kernel::HLERequestContext& ctx) {
|
||||
@ -776,12 +807,12 @@ void FS_USER::AddSeed(Kernel::HLERequestContext& ctx) {
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void FS_USER::SetSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
void FS_USER::ObsoletedSetSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
u64 value = rp.Pop<u64>();
|
||||
u32 secure_value_slot = rp.Pop<u32>();
|
||||
u32 unique_id = rp.Pop<u32>();
|
||||
u8 title_variation = rp.Pop<u8>();
|
||||
const u64 value = rp.Pop<u64>();
|
||||
const u32 secure_value_slot = rp.Pop<u32>();
|
||||
const u32 unique_id = rp.Pop<u32>();
|
||||
const u8 title_variation = rp.Pop<u8>();
|
||||
|
||||
// TODO: Generate and Save the Secure Value
|
||||
|
||||
@ -795,12 +826,11 @@ void FS_USER::SetSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void FS_USER::GetSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
void FS_USER::ObsoletedGetSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
|
||||
u32 secure_value_slot = rp.Pop<u32>();
|
||||
u32 unique_id = rp.Pop<u32>();
|
||||
u8 title_variation = rp.Pop<u8>();
|
||||
const u32 secure_value_slot = rp.Pop<u32>();
|
||||
const u32 unique_id = rp.Pop<u32>();
|
||||
const u8 title_variation = rp.Pop<u8>();
|
||||
|
||||
LOG_WARNING(
|
||||
Service_FS,
|
||||
@ -817,7 +847,77 @@ void FS_USER::GetSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
rb.Push<u64>(0); // the secure value
|
||||
}
|
||||
|
||||
void FS_USER::Register(u32 process_id, u64 program_id, const std::string& filepath) {
|
||||
void FS_USER::SetThisSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const u32 secure_value_slot = rp.Pop<u32>();
|
||||
const u64 value = rp.Pop<u64>();
|
||||
|
||||
// TODO: Generate and Save the Secure Value
|
||||
|
||||
LOG_WARNING(Service_FS, "(STUBBED) called, value=0x{:016x} secure_value_slot=0x{:08X}", value,
|
||||
secure_value_slot);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void FS_USER::GetThisSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const u32 secure_value_slot = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_FS, "(STUBBED) called secure_value_slot=0x{:08X}", secure_value_slot);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(5, 0);
|
||||
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
// TODO: Implement Secure Value Lookup & Generation
|
||||
|
||||
rb.Push<bool>(false); // indicates that the secure value doesn't exist
|
||||
rb.Push<bool>(false); // looks like a boolean value, purpose unknown
|
||||
rb.Push<u64>(0); // the secure value
|
||||
}
|
||||
|
||||
void FS_USER::SetSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const auto archive_handle = rp.PopRaw<ArchiveHandle>();
|
||||
const u32 secure_value_slot = rp.Pop<u32>();
|
||||
const u64 value = rp.Pop<u64>();
|
||||
const bool flush = rp.Pop<bool>();
|
||||
|
||||
// TODO: Generate and Save the Secure Value
|
||||
|
||||
LOG_WARNING(Service_FS,
|
||||
"(STUBBED) called, value=0x{:016x} secure_value_slot=0x{:04X} "
|
||||
"archive_handle=0x{:08X} flush={}",
|
||||
value, secure_value_slot, archive_handle, flush);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void FS_USER::GetSaveDataSecureValue(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const auto archive_handle = rp.PopRaw<ArchiveHandle>();
|
||||
const u32 secure_value_slot = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_FS, "(STUBBED) called secure_value_slot=0x{:08X} archive_handle=0x{:08X}",
|
||||
secure_value_slot, archive_handle);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(5, 0);
|
||||
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
// TODO: Implement Secure Value Lookup & Generation
|
||||
|
||||
rb.Push<bool>(false); // indicates that the secure value doesn't exist
|
||||
rb.Push<bool>(false); // looks like a boolean value, purpose unknown
|
||||
rb.Push<u64>(0); // the secure value
|
||||
}
|
||||
|
||||
void FS_USER::RegisterProgramInfo(u32 process_id, u64 program_id, const std::string& filepath) {
|
||||
const MediaType media_type = GetMediaTypeFromPath(filepath);
|
||||
program_info_map.insert_or_assign(process_id, ProgramInfo{program_id, media_type});
|
||||
if (media_type == MediaType::GameCard) {
|
||||
@ -829,6 +929,19 @@ std::string FS_USER::GetCurrentGamecardPath() const {
|
||||
return current_gamecard_path;
|
||||
}
|
||||
|
||||
void FS_USER::RegisterProductInfo(u32 process_id, const ProductInfo& product_info) {
|
||||
product_info_map.insert_or_assign(process_id, product_info);
|
||||
}
|
||||
|
||||
std::optional<FS_USER::ProductInfo> FS_USER::GetProductInfo(u32 process_id) {
|
||||
auto it = product_info_map.find(process_id);
|
||||
if (it != product_info_map.end()) {
|
||||
return it->second;
|
||||
} else {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
ResultVal<u16> FS_USER::GetSpecialContentIndexFromGameCard(u64 title_id, SpecialContentType type) {
|
||||
// TODO(B3N30) check if on real 3DS NCSD is checked if partition exists
|
||||
|
||||
@ -879,24 +992,6 @@ ResultVal<u16> FS_USER::GetSpecialContentIndexFromTMD(MediaType media_type, u64
|
||||
return ResultCode(-1);
|
||||
}
|
||||
|
||||
void FS_USER::UpdateSha256Context(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
rp.Skip(8, false);
|
||||
[[maybe_unused]] const u32 size = rp.Pop<u32>();
|
||||
rp.Skip(4, false);
|
||||
auto input = rp.PopMappedBuffer();
|
||||
|
||||
std::array<u8, CryptoPP::SHA256::DIGESTSIZE> hash;
|
||||
std::vector<u8> data(size);
|
||||
input.Read(data.data(), 0, data.size());
|
||||
|
||||
CryptoPP::SHA256().CalculateDigest(hash.data(), data.data(), size);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(9, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushRaw(hash);
|
||||
}
|
||||
|
||||
FS_USER::FS_USER(Core::System& system)
|
||||
: ServiceFramework("fs:USER", 30), system(system), archives(system.ArchiveManager()) {
|
||||
static const FunctionInfo functions[] = {
|
||||
@ -948,7 +1043,7 @@ FS_USER::FS_USER(Core::System& system)
|
||||
{0x082B, nullptr, "CardNorDirectRead_4xIO"},
|
||||
{0x082C, nullptr, "CardNorDirectCpuWriteWithoutVerify"},
|
||||
{0x082D, nullptr, "CardNorDirectSectorEraseWithoutVerify"},
|
||||
{0x082E, nullptr, "GetProductInfo"},
|
||||
{0x082E, &FS_USER::GetProductInfo, "GetProductInfo"},
|
||||
{0x082F, &FS_USER::GetProgramLaunchInfo, "GetProgramLaunchInfo"},
|
||||
{0x0830, &FS_USER::ObsoletedCreateExtSaveData, "Obsoleted_3_0_CreateExtSaveData"},
|
||||
{0x0831, nullptr, "CreateSharedExtSaveData"},
|
||||
@ -980,7 +1075,7 @@ FS_USER::FS_USER(Core::System& system)
|
||||
{0x084B, nullptr, "ImportIntegrityVerificationSeed"},
|
||||
{0x084C, &FS_USER::FormatSaveData, "FormatSaveData"},
|
||||
{0x084D, nullptr, "GetLegacySubBannerData"},
|
||||
{0x084E, &FS_USER::UpdateSha256Context, "UpdateSha256Context"},
|
||||
{0x084E, nullptr, "UpdateSha256Context"},
|
||||
{0x084F, nullptr, "ReadSpecialFile"},
|
||||
{0x0850, nullptr, "GetSpecialFileSize"},
|
||||
{0x0851, &FS_USER::CreateExtSaveData, "CreateExtSaveData"},
|
||||
@ -1003,12 +1098,16 @@ FS_USER::FS_USER(Core::System& system)
|
||||
{0x0862, &FS_USER::SetPriority, "SetPriority"},
|
||||
{0x0863, &FS_USER::GetPriority, "GetPriority"},
|
||||
{0x0864, nullptr, "GetNandInfo"},
|
||||
{0x0865, &FS_USER::SetSaveDataSecureValue, "SetSaveDataSecureValue"},
|
||||
{0x0866, &FS_USER::GetSaveDataSecureValue, "GetSaveDataSecureValue"},
|
||||
{0x0865, &FS_USER::ObsoletedSetSaveDataSecureValue, "SetSaveDataSecureValue"},
|
||||
{0x0866, &FS_USER::ObsoletedGetSaveDataSecureValue, "GetSaveDataSecureValue"},
|
||||
{0x0867, nullptr, "ControlSecureSave"},
|
||||
{0x0868, nullptr, "GetMediaType"},
|
||||
{0x0869, nullptr, "GetNandEraseCount"},
|
||||
{0x086A, nullptr, "ReadNandReport"},
|
||||
{0x086E, &FS_USER::SetThisSaveDataSecureValue, "SetThisSaveDataSecureValue" },
|
||||
{0x086F, &FS_USER::GetThisSaveDataSecureValue, "GetThisSaveDataSecureValue" },
|
||||
{0x0875, &FS_USER::SetSaveDataSecureValue, "SetSaveDataSecureValue" },
|
||||
{0x0876, &FS_USER::GetSaveDataSecureValue, "GetSaveDataSecureValue" },
|
||||
{0x087A, &FS_USER::AddSeed, "AddSeed"},
|
||||
{0x087D, &FS_USER::GetNumSeeds, "GetNumSeeds"},
|
||||
{0x0886, nullptr, "CheckUpdatedDat"},
|
||||
|
@ -4,6 +4,7 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <optional>
|
||||
#include <unordered_map>
|
||||
#include <boost/serialization/base_object.hpp>
|
||||
#include "common/common_types.h"
|
||||
@ -48,12 +49,23 @@ class FS_USER final : public ServiceFramework<FS_USER, ClientSlot> {
|
||||
public:
|
||||
explicit FS_USER(Core::System& system);
|
||||
|
||||
// On real HW this is part of FS:Reg. But since that module is only used by loader and pm, which
|
||||
// we HLEed, we can just directly use it here
|
||||
void Register(u32 process_id, u64 program_id, const std::string& filepath);
|
||||
// On real HW this is part of FSReg (FSReg:Register). But since that module is only used by
|
||||
// loader and pm, which we HLEed, we can just directly use it here
|
||||
void RegisterProgramInfo(u32 process_id, u64 program_id, const std::string& filepath);
|
||||
|
||||
std::string GetCurrentGamecardPath() const;
|
||||
|
||||
struct ProductInfo {
|
||||
std::array<u8, 0x10> product_code;
|
||||
u16_le maker_code;
|
||||
u16_le remaster_version;
|
||||
};
|
||||
static_assert(sizeof(ProductInfo) == 0x14);
|
||||
|
||||
void RegisterProductInfo(u32 process_id, const ProductInfo& product_info);
|
||||
|
||||
std::optional<ProductInfo> GetProductInfo(u32 process_id);
|
||||
|
||||
/// Gets the registered program info of a process.
|
||||
ResultVal<ProgramInfo> GetProgramLaunchInfo(u32 process_id) const {
|
||||
auto info = program_info_map.find(process_id);
|
||||
@ -107,7 +119,7 @@ private:
|
||||
*/
|
||||
void OpenFileDirectly(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
/*
|
||||
* FS_User::DeleteFile service function
|
||||
* Inputs:
|
||||
* 1 : Transaction
|
||||
@ -121,7 +133,7 @@ private:
|
||||
*/
|
||||
void DeleteFile(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
/*
|
||||
* FS_User::RenameFile service function
|
||||
* Inputs:
|
||||
* 1 : Transaction
|
||||
@ -140,7 +152,7 @@ private:
|
||||
*/
|
||||
void RenameFile(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
/*
|
||||
* FS_User::DeleteDirectory service function
|
||||
* Inputs:
|
||||
* 1 : Transaction
|
||||
@ -154,7 +166,7 @@ private:
|
||||
*/
|
||||
void DeleteDirectory(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
/*
|
||||
* FS_User::DeleteDirectoryRecursively service function
|
||||
* Inputs:
|
||||
* 0 : Command header 0x08070142
|
||||
@ -169,7 +181,7 @@ private:
|
||||
*/
|
||||
void DeleteDirectoryRecursively(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
/*
|
||||
* FS_User::CreateFile service function
|
||||
* Inputs:
|
||||
* 0 : Command header 0x08080202
|
||||
@ -186,7 +198,7 @@ private:
|
||||
*/
|
||||
void CreateFile(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
/*
|
||||
* FS_User::CreateDirectory service function
|
||||
* Inputs:
|
||||
* 1 : Transaction
|
||||
@ -201,7 +213,7 @@ private:
|
||||
*/
|
||||
void CreateDirectory(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
/*
|
||||
* FS_User::RenameDirectory service function
|
||||
* Inputs:
|
||||
* 1 : Transaction
|
||||
@ -510,6 +522,17 @@ private:
|
||||
*/
|
||||
void GetFormatInfo(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* FS_User::GetProductInfo service function.
|
||||
* Inputs:
|
||||
* 0 : 0x082E0040
|
||||
* 1 : Process ID
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
* 2-6 : Product info
|
||||
*/
|
||||
void GetProductInfo(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* FS_User::GetProgramLaunchInfo service function.
|
||||
* Inputs:
|
||||
@ -601,7 +624,7 @@ private:
|
||||
* 0 : 0x08650140
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
*/
|
||||
void SetSaveDataSecureValue(Kernel::HLERequestContext& ctx);
|
||||
void ObsoletedSetSaveDataSecureValue(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* FS_User::GetSaveDataSecureValue service function.
|
||||
@ -616,24 +639,58 @@ private:
|
||||
* 2 : If Secure Value doesn't exist, 0, if it exists, 1
|
||||
* 3-4 : Secure Value
|
||||
*/
|
||||
void GetSaveDataSecureValue(Kernel::HLERequestContext& ctx);
|
||||
void ObsoletedGetSaveDataSecureValue(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* FS_User::UpdateSha256Context service function.
|
||||
* FS_User::SetThisSaveDataSecureValue service function.
|
||||
* Inputs:
|
||||
* 0 : 0x084E0342
|
||||
* 1-8 : Input Hash
|
||||
* 9 : Input Data Size
|
||||
* 10-12 : Flag, must be zero
|
||||
* 13 : Flag, must be non-zero
|
||||
* 14 : (Size << 4) | 0xA
|
||||
* 15 : Input Data Pointer
|
||||
* 1 : Secure Value Slot
|
||||
* 2-3 : Secure Value
|
||||
* Outputs:
|
||||
* 0 : 0x084E0342
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
* 2-9 : Output SHA-256 Hash
|
||||
*/
|
||||
void UpdateSha256Context(Kernel::HLERequestContext& ctx);
|
||||
void SetThisSaveDataSecureValue(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* FS_User::GetSaveDataSecureValue service function.
|
||||
* Inputs:
|
||||
* 1 : Secure Value Slot
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
* 2 : If Secure Value doesn't exist, 0, if it exists, 1
|
||||
* 3 : Unknown
|
||||
* 4-5 : Secure Value
|
||||
*/
|
||||
void GetThisSaveDataSecureValue(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* FS_User::SetSaveDataSecureValue service function.
|
||||
* Inputs:
|
||||
* 0 : 0x08750180
|
||||
* 1-2 : Archive
|
||||
* 3 : Secure Value Slot
|
||||
* 4 : value
|
||||
* 5 : flush
|
||||
* Outputs:
|
||||
* 0 : header
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
*/
|
||||
void SetSaveDataSecureValue(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* FS_User::GetSaveDataSecureValue service function.
|
||||
* Inputs:
|
||||
* 0 : 0x087600C0
|
||||
* 1-2 : Archive
|
||||
* 2 : Secure Value slot
|
||||
* Outputs:
|
||||
* 0 : Header
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
* 2 : If Secure Value doesn't exist, 0, if it exists, 1
|
||||
* 3 : unknown
|
||||
* 4-5 : Secure Value
|
||||
*/
|
||||
void GetSaveDataSecureValue(Kernel::HLERequestContext& ctx);
|
||||
|
||||
static ResultVal<u16> GetSpecialContentIndexFromGameCard(u64 title_id, SpecialContentType type);
|
||||
static ResultVal<u16> GetSpecialContentIndexFromTMD(MediaType media_type, u64 title_id,
|
||||
@ -642,6 +699,8 @@ private:
|
||||
std::unordered_map<u32, ProgramInfo> program_info_map;
|
||||
std::string current_gamecard_path;
|
||||
|
||||
std::unordered_map<u32, ProductInfo> product_info_map;
|
||||
|
||||
u32 priority = -1; ///< For SetPriority and GetPriority service functions
|
||||
|
||||
Core::System& system;
|
||||
|
@ -1,10 +1,9 @@
|
||||
// Copyright 2018 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
#pragma optimize("", off)
|
||||
|
||||
#include <cryptopp/aes.h>
|
||||
#include <cryptopp/modes.h>
|
||||
#include <cryptopp/rsa.h>
|
||||
#include "common/archives.h"
|
||||
#include "common/logging/log.h"
|
||||
#include "core/core.h"
|
||||
@ -14,7 +13,6 @@
|
||||
#include "core/hw/aes/key.h"
|
||||
|
||||
SERIALIZE_EXPORT_IMPL(Service::PS::PS_PS)
|
||||
SERVICE_CONSTRUCT_IMPL(Service::PS::PS_PS)
|
||||
|
||||
namespace Service::PS {
|
||||
|
||||
@ -148,50 +146,11 @@ void PS_PS::EncryptDecryptAes(Kernel::HLERequestContext& ctx) {
|
||||
rb.PushMappedBuffer(destination);
|
||||
}
|
||||
|
||||
void PS_PS::VerifyRsaSha256(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
std::array<u8, 32> sha;
|
||||
rp.PopRaw(sha);
|
||||
rp.Pop<u32>();
|
||||
const auto rsa_ctx_buf = rp.PopStaticBuffer();
|
||||
auto sig_buf = rp.PopMappedBuffer();
|
||||
|
||||
struct RsaContext {
|
||||
std::array<u8, 0x100> modulo;
|
||||
std::array<u8, 0x100> exponent;
|
||||
u32 rsa_bit_size;
|
||||
bool is_long_exponent;
|
||||
};
|
||||
static_assert(sizeof(RsaContext) == 520);
|
||||
|
||||
RsaContext rsa_ctx;
|
||||
std::memcpy(&rsa_ctx, rsa_ctx_buf.data(), rsa_ctx_buf.size());
|
||||
|
||||
std::vector<u8> signature_buffer(sig_buf.GetSize());
|
||||
sig_buf.Read(signature_buffer.data(), 0, sig_buf.GetSize());
|
||||
|
||||
ASSERT(!rsa_ctx.is_long_exponent);
|
||||
|
||||
u32 exponent;
|
||||
std::memcpy(&exponent, rsa_ctx.exponent.data(), sizeof(exponent));
|
||||
|
||||
using Verifier = CryptoPP::RSASS<CryptoPP::PKCS1v15, CryptoPP::SHA256>::Verifier;
|
||||
|
||||
const auto modulus = CryptoPP::Integer(rsa_ctx.modulo.data(), rsa_ctx.modulo.size());
|
||||
const auto verifier = Verifier(modulus, CryptoPP::Integer(exponent));
|
||||
const bool valid = verifier.VerifyMessage(sha.data(), sha.size(), signature_buffer.data(), signature_buffer.size());
|
||||
ASSERT(!valid);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushMappedBuffer(sig_buf);
|
||||
}
|
||||
|
||||
PS_PS::PS_PS(Core::System& system) : ServiceFramework("ps:ps", DefaultMaxSessions), memory{system.Memory()} {
|
||||
PS_PS::PS_PS() : ServiceFramework("ps:ps", DefaultMaxSessions) {
|
||||
static const FunctionInfo functions[] = {
|
||||
// clang-format off
|
||||
{0x0001, nullptr, "SignRsaSha256"},
|
||||
{0x0002, &PS_PS::VerifyRsaSha256, "VerifyRsaSha256"},
|
||||
{0x0002, nullptr, "VerifyRsaSha256"},
|
||||
{0x0004, &PS_PS::EncryptDecryptAes, "EncryptDecryptAes"},
|
||||
{0x0005, nullptr, "EncryptSignDecryptVerifyAesCcm"},
|
||||
{0x0006, nullptr, "GetRomId"},
|
||||
@ -214,7 +173,7 @@ PS_PS::PS_PS(Core::System& system) : ServiceFramework("ps:ps", DefaultMaxSession
|
||||
|
||||
void InstallInterfaces(Core::System& system) {
|
||||
auto& service_manager = system.ServiceManager();
|
||||
std::make_shared<PS_PS>(system)->InstallAsService(service_manager);
|
||||
std::make_shared<PS_PS>()->InstallAsService(service_manager);
|
||||
}
|
||||
|
||||
} // namespace Service::PS
|
||||
|
@ -14,10 +14,11 @@ namespace Service::PS {
|
||||
|
||||
class PS_PS final : public ServiceFramework<PS_PS> {
|
||||
public:
|
||||
PS_PS(Core::System& system);
|
||||
PS_PS();
|
||||
~PS_PS() = default;
|
||||
|
||||
private:
|
||||
SERVICE_SERIALIZATION_SIMPLE
|
||||
|
||||
/**
|
||||
* PS_PS::SignRsaSha256 service function
|
||||
@ -226,9 +227,6 @@ private:
|
||||
* 2 :
|
||||
*/
|
||||
void InterfaceForPXI_0x04040044(Kernel::HLERequestContext& ctx);
|
||||
|
||||
private:
|
||||
Memory::MemorySystem& memory;
|
||||
};
|
||||
|
||||
/// Initializes the PS_PS Service
|
||||
@ -237,4 +235,3 @@ void InstallInterfaces(Core::System& system);
|
||||
} // namespace Service::PS
|
||||
|
||||
BOOST_CLASS_EXPORT_KEY(Service::PS::PS_PS)
|
||||
SERVICE_CONSTRUCT(Service::PS::PS_PS)
|
||||
|
@ -58,8 +58,7 @@
|
||||
namespace Service {
|
||||
|
||||
const std::array<ServiceModuleInfo, 41> service_module_map{
|
||||
{{"CFG", 0x00040130'00001702, CFG::InstallInterfaces},
|
||||
{"FS", 0x00040130'00001102, FS::InstallInterfaces},
|
||||
{{"FS", 0x00040130'00001102, FS::InstallInterfaces},
|
||||
{"PM", 0x00040130'00001202, PM::InstallInterfaces},
|
||||
{"LDR", 0x00040130'00003702, LDR::InstallInterfaces},
|
||||
{"PXI", 0x00040130'00001402, PXI::InstallInterfaces},
|
||||
@ -75,6 +74,7 @@ const std::array<ServiceModuleInfo, 41> service_module_map{
|
||||
Y2R::InstallInterfaces(system);
|
||||
}},
|
||||
{"CECD", 0x00040130'00002602, CECD::InstallInterfaces},
|
||||
{"CFG", 0x00040130'00001702, CFG::InstallInterfaces},
|
||||
{"DLP", 0x00040130'00002802, DLP::InstallInterfaces},
|
||||
{"DSP", 0x00040130'00001A02, DSP::InstallInterfaces},
|
||||
{"FRD", 0x00040130'00003202, FRD::InstallInterfaces},
|
||||
|
@ -282,7 +282,7 @@ ResultStatus AppLoader_THREEDSX::Load(std::shared_ptr<Kernel::Process>& process)
|
||||
// On real HW this is done with FS:Reg, but we can be lazy
|
||||
auto fs_user =
|
||||
Core::System::GetInstance().ServiceManager().GetService<Service::FS::FS_USER>("fs:USER");
|
||||
fs_user->Register(process->GetObjectId(), process->codeset->program_id, filepath);
|
||||
fs_user->RegisterProgramInfo(process->GetObjectId(), process->codeset->program_id, filepath);
|
||||
|
||||
process->Run(48, Kernel::DEFAULT_STACK_SIZE);
|
||||
|
||||
|
@ -174,7 +174,16 @@ ResultStatus AppLoader_NCCH::LoadExec(std::shared_ptr<Kernel::Process>& process)
|
||||
auto fs_user =
|
||||
Core::System::GetInstance().ServiceManager().GetService<Service::FS::FS_USER>(
|
||||
"fs:USER");
|
||||
fs_user->Register(process->process_id, process->codeset->program_id, filepath);
|
||||
fs_user->RegisterProgramInfo(process->process_id, process->codeset->program_id, filepath);
|
||||
|
||||
Service::FS::FS_USER::ProductInfo product_info{};
|
||||
std::memcpy(product_info.product_code.data(), overlay_ncch->ncch_header.product_code,
|
||||
product_info.product_code.size());
|
||||
std::memcpy(&product_info.remaster_version,
|
||||
overlay_ncch->exheader_header.codeset_info.flags.remaster_version,
|
||||
sizeof(product_info.remaster_version));
|
||||
product_info.maker_code = overlay_ncch->ncch_header.maker_code;
|
||||
fs_user->RegisterProductInfo(process->process_id, product_info);
|
||||
|
||||
process->Run(priority, stack_size);
|
||||
return ResultStatus::Success;
|
||||
|
@ -1,7 +1,7 @@
|
||||
// Copyright 2015 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
#pragma optimize("", off)
|
||||
|
||||
#include <array>
|
||||
#include <cstring>
|
||||
#include <boost/serialization/array.hpp>
|
||||
@ -156,10 +156,6 @@ public:
|
||||
return system.GetRunningCore().GetPC();
|
||||
}
|
||||
|
||||
u32 GetLR() const noexcept {
|
||||
return system.GetRunningCore().GetReg(14);
|
||||
}
|
||||
|
||||
/**
|
||||
* This function should only be called for virtual addreses with attribute `PageType::Special`.
|
||||
*/
|
||||
@ -473,8 +469,8 @@ T MemorySystem::Read(const VAddr vaddr) {
|
||||
PageType type = impl->current_page_table->attributes[vaddr >> CITRA_PAGE_BITS];
|
||||
switch (type) {
|
||||
case PageType::Unmapped:
|
||||
LOG_ERROR(HW_Memory, "unmapped Read{} @ 0x{:08X} at PC 0x{:08X} with LR {:#08X}", sizeof(T) * 8, vaddr,
|
||||
impl->GetPC(), impl->GetLR());
|
||||
LOG_ERROR(HW_Memory, "unmapped Read{} @ 0x{:08X} at PC 0x{:08X}", sizeof(T) * 8, vaddr,
|
||||
impl->GetPC());
|
||||
return 0;
|
||||
case PageType::Memory:
|
||||
ASSERT_MSG(false, "Mapped memory page without a pointer @ {:08X}", vaddr);
|
||||
|
@ -11,6 +11,7 @@
|
||||
#include <span>
|
||||
#include <catch2/catch_approx.hpp>
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <fmt/format.h>
|
||||
#include <nihstro/inline_assembly.h>
|
||||
#include "video_core/shader/shader_interpreter.h"
|
||||
#include "video_core/shader/shader_jit_x64_compiler.h"
|
||||
@ -28,6 +29,15 @@ static constexpr Common::Vec4f vec4_nan = Common::Vec4f::AssignToAll(NAN);
|
||||
static constexpr Common::Vec4f vec4_one = Common::Vec4f::AssignToAll(1.0f);
|
||||
static constexpr Common::Vec4f vec4_zero = Common::Vec4f::AssignToAll(0.0f);
|
||||
|
||||
namespace Catch {
|
||||
template <>
|
||||
struct StringMaker<Common::Vec4f> {
|
||||
static std::string convert(Common::Vec4f value) {
|
||||
return fmt::format("({}, {}, {}, {})", value.r(), value.g(), value.b(), value.a());
|
||||
}
|
||||
};
|
||||
} // namespace Catch
|
||||
|
||||
static std::unique_ptr<Pica::Shader::ShaderSetup> CompileShaderSetup(
|
||||
std::initializer_list<nihstro::InlineAsm> code) {
|
||||
const auto shbin = nihstro::InlineAsm::CompileToRawBinary(code);
|
||||
@ -385,6 +395,56 @@ TEST_CASE("RSQ", "[video_core][shader][shader_jit]") {
|
||||
REQUIRE(shader.Run({0.0625f}).x == Catch::Approx(4.0f).margin(0.004f));
|
||||
}
|
||||
|
||||
TEST_CASE("Address Register Offset", "[video_core][shader][shader_jit]") {
|
||||
const auto sh_input = SourceRegister::MakeInput(0);
|
||||
const auto sh_c40 = SourceRegister::MakeFloat(40);
|
||||
const auto sh_output = DestRegister::MakeOutput(0);
|
||||
|
||||
auto shader = ShaderTest({
|
||||
// mova a0.x, sh_input.x
|
||||
{OpCode::Id::MOVA, DestRegister{}, "x", sh_input, "x", SourceRegister{}, "",
|
||||
nihstro::InlineAsm::RelativeAddress::A1},
|
||||
// mov sh_output.xyzw, c40[a0.x].xyzw
|
||||
{OpCode::Id::MOV, sh_output, "xyzw", sh_c40, "xyzw", SourceRegister{}, "",
|
||||
nihstro::InlineAsm::RelativeAddress::A1},
|
||||
{OpCode::Id::END},
|
||||
});
|
||||
|
||||
// Prepare shader uniforms
|
||||
const bool inverted = true;
|
||||
std::array<Common::Vec4f, 96> f_uniforms;
|
||||
for (u32 i = 0; i < 0x80; i++) {
|
||||
if (i >= 0x00 && i < 0x60) {
|
||||
const u32 base = inverted ? (0x60 - i) : i;
|
||||
const auto color = (base * 2.f) / 255.0f;
|
||||
const auto color_f24 = Pica::f24::FromFloat32(color);
|
||||
shader.shader_setup->uniforms.f[i] = {color_f24, color_f24, color_f24,
|
||||
Pica::f24::One()};
|
||||
f_uniforms[i] = {color, color, color, 1.f};
|
||||
} else if (i >= 0x60 && i < 0x64) {
|
||||
const u8 color = static_cast<u8>((i - 0x60) * 0x10);
|
||||
shader.shader_setup->uniforms.i[i - 0x60] = {color, color, color, 255};
|
||||
} else if (i >= 0x70 && i < 0x80) {
|
||||
shader.shader_setup->uniforms.b[i - 0x70] = i >= 0x78;
|
||||
}
|
||||
}
|
||||
|
||||
REQUIRE(shader.Run(0.f) == f_uniforms[40]);
|
||||
REQUIRE(shader.Run(13.f) == f_uniforms[53]);
|
||||
REQUIRE(shader.Run(50.f) == f_uniforms[90]);
|
||||
REQUIRE(shader.Run(60.f) == vec4_one);
|
||||
REQUIRE(shader.Run(74.f) == vec4_one);
|
||||
REQUIRE(shader.Run(87.f) == vec4_one);
|
||||
REQUIRE(shader.Run(88.f) == f_uniforms[0]);
|
||||
REQUIRE(shader.Run(128.f) == f_uniforms[40]);
|
||||
REQUIRE(shader.Run(-40.f) == f_uniforms[0]);
|
||||
REQUIRE(shader.Run(-42.f) == vec4_one);
|
||||
REQUIRE(shader.Run(-70.f) == vec4_one);
|
||||
REQUIRE(shader.Run(-73.f) == f_uniforms[95]);
|
||||
REQUIRE(shader.Run(-127.f) == f_uniforms[41]);
|
||||
REQUIRE(shader.Run(-129.f) == f_uniforms[40]);
|
||||
}
|
||||
|
||||
// TODO: Requires fix from https://github.com/neobrain/nihstro/issues/68
|
||||
// TEST_CASE("MAD", "[video_core][shader][shader_jit]") {
|
||||
// const auto sh_input1 = SourceRegister::MakeInput(0);
|
||||
|
@ -78,12 +78,11 @@ static void WriteUniformFloatReg(ShaderRegs& config, Shader::ShaderSetup& setup,
|
||||
(float_regs_counter >= 3 && !uniform_setup.IsFloat32())) {
|
||||
float_regs_counter = 0;
|
||||
|
||||
auto& uniform = setup.uniforms.f[uniform_setup.index];
|
||||
|
||||
if (uniform_setup.index >= 96) {
|
||||
if (uniform_setup.index >= setup.uniforms.f.size()) {
|
||||
LOG_ERROR(HW_GPU, "Invalid {} float uniform index {}", GetShaderSetupTypeName(setup),
|
||||
(int)uniform_setup.index);
|
||||
} else {
|
||||
auto& uniform = setup.uniforms.f[uniform_setup.index];
|
||||
|
||||
// NOTE: The destination component order indeed is "backwards"
|
||||
if (uniform_setup.IsFloat32()) {
|
||||
|
@ -7,7 +7,6 @@ set(SHADER_FILES
|
||||
format_reinterpreter/rgba4_to_rgb5a1.frag
|
||||
format_reinterpreter/vulkan_d24s8_to_rgba8.comp
|
||||
texture_filtering/bicubic.frag
|
||||
texture_filtering/nearest_neighbor.frag
|
||||
texture_filtering/refine.frag
|
||||
texture_filtering/scale_force.frag
|
||||
texture_filtering/xbrz_freescale.frag
|
||||
|
@ -1,15 +0,0 @@
|
||||
// Copyright 2023 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
//? #version 430 core
|
||||
precision mediump float;
|
||||
|
||||
layout(location = 0) in vec2 tex_coord;
|
||||
layout(location = 0) out vec4 frag_color;
|
||||
|
||||
layout(binding = 2) uniform sampler2D input_texture;
|
||||
|
||||
void main() {
|
||||
frag_color = texture(input_texture, tex_coord);
|
||||
}
|
@ -361,10 +361,25 @@ typename T::Sampler& RasterizerCache<T>::GetSampler(SamplerId sampler_id) {
|
||||
template <class T>
|
||||
typename T::Sampler& RasterizerCache<T>::GetSampler(
|
||||
const Pica::TexturingRegs::TextureConfig& config) {
|
||||
using TextureFilter = Pica::TexturingRegs::TextureConfig::TextureFilter;
|
||||
|
||||
const auto get_filter = [](TextureFilter filter) {
|
||||
switch (Settings::values.texture_sampling.GetValue()) {
|
||||
case Settings::TextureSampling::GameControlled:
|
||||
return filter;
|
||||
case Settings::TextureSampling::NearestNeighbor:
|
||||
return TextureFilter::Nearest;
|
||||
case Settings::TextureSampling::Linear:
|
||||
return TextureFilter::Linear;
|
||||
default:
|
||||
return filter;
|
||||
}
|
||||
};
|
||||
|
||||
const SamplerParams params = {
|
||||
.mag_filter = config.mag_filter,
|
||||
.min_filter = config.min_filter,
|
||||
.mip_filter = config.mip_filter,
|
||||
.mag_filter = get_filter(config.mag_filter),
|
||||
.min_filter = get_filter(config.min_filter),
|
||||
.mip_filter = get_filter(config.mip_filter),
|
||||
.wrap_s = config.wrap_s,
|
||||
.wrap_t = config.wrap_t,
|
||||
.border_color = config.border_color.raw,
|
||||
|
@ -59,7 +59,7 @@ bool RendererBase::IsScreenshotPending() const {
|
||||
return settings.screenshot_requested;
|
||||
}
|
||||
|
||||
void RendererBase::RequestScreenshot(void* data, std::function<void()> callback,
|
||||
void RendererBase::RequestScreenshot(void* data, std::function<void(bool)> callback,
|
||||
const Layout::FramebufferLayout& layout) {
|
||||
if (settings.screenshot_requested) {
|
||||
LOG_ERROR(Render, "A screenshot is already requested or in progress, ignoring the request");
|
||||
|
@ -28,7 +28,7 @@ struct RendererSettings {
|
||||
// Screenshot
|
||||
std::atomic_bool screenshot_requested{false};
|
||||
void* screenshot_bits{};
|
||||
std::function<void()> screenshot_complete_callback;
|
||||
std::function<void(bool)> screenshot_complete_callback;
|
||||
Layout::FramebufferLayout screenshot_framebuffer_layout;
|
||||
// Renderer
|
||||
std::atomic_bool bg_color_update_requested{false};
|
||||
@ -103,7 +103,7 @@ public:
|
||||
[[nodiscard]] bool IsScreenshotPending() const;
|
||||
|
||||
/// Request a screenshot of the next frame
|
||||
void RequestScreenshot(void* data, std::function<void()> callback,
|
||||
void RequestScreenshot(void* data, std::function<void(bool)> callback,
|
||||
const Layout::FramebufferLayout& layout);
|
||||
|
||||
protected:
|
||||
|
@ -15,7 +15,6 @@
|
||||
#include "video_core/host_shaders/full_screen_triangle_vert.h"
|
||||
#include "video_core/host_shaders/texture_filtering/bicubic_frag.h"
|
||||
#include "video_core/host_shaders/texture_filtering/mmpx_frag.h"
|
||||
#include "video_core/host_shaders/texture_filtering/nearest_neighbor_frag.h"
|
||||
#include "video_core/host_shaders/texture_filtering/refine_frag.h"
|
||||
#include "video_core/host_shaders/texture_filtering/scale_force_frag.h"
|
||||
#include "video_core/host_shaders/texture_filtering/x_gradient_frag.h"
|
||||
@ -58,7 +57,6 @@ BlitHelper::BlitHelper(const Driver& driver_)
|
||||
: driver{driver_}, linear_sampler{CreateSampler(GL_LINEAR)},
|
||||
nearest_sampler{CreateSampler(GL_NEAREST)}, bicubic_program{CreateProgram(
|
||||
HostShaders::BICUBIC_FRAG)},
|
||||
nearest_program{CreateProgram(HostShaders::NEAREST_NEIGHBOR_FRAG)},
|
||||
scale_force_program{CreateProgram(HostShaders::SCALE_FORCE_FRAG)},
|
||||
xbrz_program{CreateProgram(HostShaders::XBRZ_FREESCALE_FRAG)},
|
||||
mmpx_program{CreateProgram(HostShaders::MMPX_FRAG)}, gradient_x_program{CreateProgram(
|
||||
@ -175,9 +173,6 @@ bool BlitHelper::Filter(Surface& surface, const VideoCore::TextureBlit& blit) {
|
||||
case TextureFilter::Bicubic:
|
||||
FilterBicubic(surface, blit);
|
||||
break;
|
||||
case TextureFilter::NearestNeighbor:
|
||||
FilterNearest(surface, blit);
|
||||
break;
|
||||
case TextureFilter::ScaleForce:
|
||||
FilterScaleForce(surface, blit);
|
||||
break;
|
||||
@ -257,14 +252,6 @@ void BlitHelper::FilterBicubic(Surface& surface, const VideoCore::TextureBlit& b
|
||||
Draw(bicubic_program, surface.Handle(), draw_fbo.handle, blit.dst_level, blit.dst_rect);
|
||||
}
|
||||
|
||||
void BlitHelper::FilterNearest(Surface& surface, const VideoCore::TextureBlit& blit) {
|
||||
const OpenGLState prev_state = OpenGLState::GetCurState();
|
||||
SCOPE_EXIT({ prev_state.Apply(); });
|
||||
state.texture_units[2].texture_2d = surface.Handle(0);
|
||||
SetParams(nearest_program, surface.RealExtent(false), blit.src_rect);
|
||||
Draw(nearest_program, surface.Handle(), draw_fbo.handle, blit.dst_level, blit.dst_rect);
|
||||
}
|
||||
|
||||
void BlitHelper::FilterScaleForce(Surface& surface, const VideoCore::TextureBlit& blit) {
|
||||
const OpenGLState prev_state = OpenGLState::GetCurState();
|
||||
SCOPE_EXIT({ prev_state.Apply(); });
|
||||
|
@ -33,20 +33,13 @@ public:
|
||||
|
||||
private:
|
||||
void FilterAnime4K(Surface& surface, const VideoCore::TextureBlit& blit);
|
||||
|
||||
void FilterBicubic(Surface& surface, const VideoCore::TextureBlit& blit);
|
||||
|
||||
void FilterNearest(Surface& surface, const VideoCore::TextureBlit& blit);
|
||||
|
||||
void FilterScaleForce(Surface& surface, const VideoCore::TextureBlit& blit);
|
||||
|
||||
void FilterXbrz(Surface& surface, const VideoCore::TextureBlit& blit);
|
||||
|
||||
void FilterMMPX(Surface& surface, const VideoCore::TextureBlit& blit);
|
||||
|
||||
void SetParams(OGLProgram& program, const VideoCore::Extent& src_extent,
|
||||
Common::Rectangle<u32> src_rect);
|
||||
|
||||
void Draw(OGLProgram& program, GLuint dst_tex, GLuint dst_fbo, u32 dst_level,
|
||||
Common::Rectangle<u32> dst_rect);
|
||||
|
||||
@ -59,7 +52,6 @@ private:
|
||||
OGLSampler nearest_sampler;
|
||||
|
||||
OGLProgram bicubic_program;
|
||||
OGLProgram nearest_program;
|
||||
OGLProgram scale_force_program;
|
||||
OGLProgram xbrz_program;
|
||||
OGLProgram mmpx_program;
|
||||
|
@ -151,7 +151,7 @@ void RendererOpenGL::RenderScreenshot() {
|
||||
state.Apply();
|
||||
glDeleteRenderbuffers(1, &renderbuffer);
|
||||
|
||||
settings.screenshot_complete_callback();
|
||||
settings.screenshot_complete_callback(true);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -6,6 +6,7 @@
|
||||
#include "common/logging/log.h"
|
||||
#include "common/microprofile.h"
|
||||
#include "common/settings.h"
|
||||
#include "common/texture.h"
|
||||
#include "core/core.h"
|
||||
#include "core/frontend/emu_window.h"
|
||||
#include "core/hw/gpu.h"
|
||||
@ -18,6 +19,7 @@
|
||||
#include "video_core/host_shaders/vulkan_present_frag_spv.h"
|
||||
#include "video_core/host_shaders/vulkan_present_interlaced_frag_spv.h"
|
||||
#include "video_core/host_shaders/vulkan_present_vert_spv.h"
|
||||
#include "vulkan/vulkan_format_traits.hpp"
|
||||
|
||||
#include <vk_mem_alloc.h>
|
||||
|
||||
@ -867,20 +869,9 @@ void RendererVulkan::RenderScreenshot() {
|
||||
const u32 width = layout.width;
|
||||
const u32 height = layout.height;
|
||||
|
||||
const vk::ImageCreateInfo staging_image_info = {
|
||||
.imageType = vk::ImageType::e2D,
|
||||
.format = vk::Format::eB8G8R8A8Unorm,
|
||||
.extent{
|
||||
.width = width,
|
||||
.height = height,
|
||||
.depth = 1,
|
||||
},
|
||||
.mipLevels = 1,
|
||||
.arrayLayers = 1,
|
||||
.samples = vk::SampleCountFlagBits::e1,
|
||||
.tiling = vk::ImageTiling::eLinear,
|
||||
.usage = vk::ImageUsageFlagBits::eTransferDst,
|
||||
.initialLayout = vk::ImageLayout::eUndefined,
|
||||
const vk::BufferCreateInfo staging_buffer_info = {
|
||||
.size = width * height * 4,
|
||||
.usage = vk::BufferUsageFlagBits::eTransferDst,
|
||||
};
|
||||
|
||||
const VmaAllocationCreateInfo alloc_create_info = {
|
||||
@ -893,18 +884,18 @@ void RendererVulkan::RenderScreenshot() {
|
||||
.pUserData = nullptr,
|
||||
};
|
||||
|
||||
VkImage unsafe_image{};
|
||||
VkBuffer unsafe_buffer{};
|
||||
VmaAllocation allocation{};
|
||||
VmaAllocationInfo alloc_info;
|
||||
VkImageCreateInfo unsafe_image_info = static_cast<VkImageCreateInfo>(staging_image_info);
|
||||
VkBufferCreateInfo unsafe_buffer_info = static_cast<VkBufferCreateInfo>(staging_buffer_info);
|
||||
|
||||
VkResult result = vmaCreateImage(instance.GetAllocator(), &unsafe_image_info,
|
||||
&alloc_create_info, &unsafe_image, &allocation, &alloc_info);
|
||||
VkResult result = vmaCreateBuffer(instance.GetAllocator(), &unsafe_buffer_info,
|
||||
&alloc_create_info, &unsafe_buffer, &allocation, &alloc_info);
|
||||
if (result != VK_SUCCESS) [[unlikely]] {
|
||||
LOG_CRITICAL(Render_Vulkan, "Failed allocating texture with error {}", result);
|
||||
UNREACHABLE();
|
||||
}
|
||||
vk::Image staging_image{unsafe_image};
|
||||
vk::Buffer staging_buffer{unsafe_buffer};
|
||||
|
||||
Frame frame{};
|
||||
main_window.RecreateFrame(&frame, width, height);
|
||||
@ -912,73 +903,37 @@ void RendererVulkan::RenderScreenshot() {
|
||||
DrawScreens(&frame, layout, false);
|
||||
|
||||
scheduler.Record(
|
||||
[width, height, source_image = frame.image, staging_image](vk::CommandBuffer cmdbuf) {
|
||||
const std::array read_barriers = {
|
||||
vk::ImageMemoryBarrier{
|
||||
.srcAccessMask = vk::AccessFlagBits::eMemoryWrite,
|
||||
.dstAccessMask = vk::AccessFlagBits::eTransferRead,
|
||||
.oldLayout = vk::ImageLayout::eTransferSrcOptimal,
|
||||
.newLayout = vk::ImageLayout::eTransferSrcOptimal,
|
||||
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.image = source_image,
|
||||
.subresourceRange{
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.baseMipLevel = 0,
|
||||
.levelCount = VK_REMAINING_MIP_LEVELS,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = VK_REMAINING_ARRAY_LAYERS,
|
||||
},
|
||||
},
|
||||
vk::ImageMemoryBarrier{
|
||||
.srcAccessMask = vk::AccessFlagBits::eNone,
|
||||
.dstAccessMask = vk::AccessFlagBits::eTransferWrite,
|
||||
.oldLayout = vk::ImageLayout::eUndefined,
|
||||
.newLayout = vk::ImageLayout::eTransferDstOptimal,
|
||||
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.image = staging_image,
|
||||
.subresourceRange{
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.baseMipLevel = 0,
|
||||
.levelCount = VK_REMAINING_MIP_LEVELS,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = VK_REMAINING_ARRAY_LAYERS,
|
||||
},
|
||||
[width, height, source_image = frame.image, staging_buffer](vk::CommandBuffer cmdbuf) {
|
||||
const vk::ImageMemoryBarrier read_barrier = {
|
||||
.srcAccessMask = vk::AccessFlagBits::eMemoryWrite,
|
||||
.dstAccessMask = vk::AccessFlagBits::eTransferRead,
|
||||
.oldLayout = vk::ImageLayout::eTransferSrcOptimal,
|
||||
.newLayout = vk::ImageLayout::eTransferSrcOptimal,
|
||||
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.image = source_image,
|
||||
.subresourceRange{
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.baseMipLevel = 0,
|
||||
.levelCount = VK_REMAINING_MIP_LEVELS,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = VK_REMAINING_ARRAY_LAYERS,
|
||||
},
|
||||
};
|
||||
const std::array write_barriers = {
|
||||
vk::ImageMemoryBarrier{
|
||||
.srcAccessMask = vk::AccessFlagBits::eTransferRead,
|
||||
.dstAccessMask = vk::AccessFlagBits::eMemoryWrite,
|
||||
.oldLayout = vk::ImageLayout::eTransferSrcOptimal,
|
||||
.newLayout = vk::ImageLayout::eTransferSrcOptimal,
|
||||
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.image = source_image,
|
||||
.subresourceRange{
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.baseMipLevel = 0,
|
||||
.levelCount = VK_REMAINING_MIP_LEVELS,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = VK_REMAINING_ARRAY_LAYERS,
|
||||
},
|
||||
},
|
||||
vk::ImageMemoryBarrier{
|
||||
.srcAccessMask = vk::AccessFlagBits::eTransferWrite,
|
||||
.dstAccessMask = vk::AccessFlagBits::eMemoryRead,
|
||||
.oldLayout = vk::ImageLayout::eTransferDstOptimal,
|
||||
.newLayout = vk::ImageLayout::eGeneral,
|
||||
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.image = staging_image,
|
||||
.subresourceRange{
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.baseMipLevel = 0,
|
||||
.levelCount = VK_REMAINING_MIP_LEVELS,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = VK_REMAINING_ARRAY_LAYERS,
|
||||
},
|
||||
const vk::ImageMemoryBarrier write_barrier = {
|
||||
.srcAccessMask = vk::AccessFlagBits::eTransferRead,
|
||||
.dstAccessMask = vk::AccessFlagBits::eMemoryWrite,
|
||||
.oldLayout = vk::ImageLayout::eTransferSrcOptimal,
|
||||
.newLayout = vk::ImageLayout::eTransferSrcOptimal,
|
||||
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.image = source_image,
|
||||
.subresourceRange{
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.baseMipLevel = 0,
|
||||
.levelCount = VK_REMAINING_MIP_LEVELS,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = VK_REMAINING_ARRAY_LAYERS,
|
||||
},
|
||||
};
|
||||
static constexpr vk::MemoryBarrier memory_write_barrier = {
|
||||
@ -986,41 +941,29 @@ void RendererVulkan::RenderScreenshot() {
|
||||
.dstAccessMask = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite,
|
||||
};
|
||||
|
||||
const std::array src_offsets = {
|
||||
vk::Offset3D{0, 0, 0},
|
||||
vk::Offset3D{static_cast<s32>(width), static_cast<s32>(height), 1},
|
||||
};
|
||||
|
||||
const std::array dst_offsets = {
|
||||
vk::Offset3D{0, static_cast<s32>(height), 0},
|
||||
vk::Offset3D{static_cast<s32>(width), 0, 1},
|
||||
};
|
||||
|
||||
const vk::ImageBlit blit_area = {
|
||||
.srcSubresource{
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.mipLevel = 0,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = 1,
|
||||
},
|
||||
.srcOffsets = src_offsets,
|
||||
.dstSubresource{
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.mipLevel = 0,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = 1,
|
||||
},
|
||||
.dstOffsets = dst_offsets,
|
||||
const vk::BufferImageCopy image_copy = {
|
||||
.bufferOffset = 0,
|
||||
.bufferRowLength = 0,
|
||||
.bufferImageHeight = 0,
|
||||
.imageSubresource =
|
||||
{
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.mipLevel = 0,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = 1,
|
||||
},
|
||||
.imageOffset = {0, 0, 0},
|
||||
.imageExtent = {width, height, 1},
|
||||
};
|
||||
|
||||
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eAllCommands,
|
||||
vk::PipelineStageFlagBits::eTransfer,
|
||||
vk::DependencyFlagBits::eByRegion, {}, {}, read_barriers);
|
||||
cmdbuf.blitImage(source_image, vk::ImageLayout::eTransferSrcOptimal, staging_image,
|
||||
vk::ImageLayout::eTransferDstOptimal, blit_area, vk::Filter::eNearest);
|
||||
vk::DependencyFlagBits::eByRegion, {}, {}, read_barrier);
|
||||
cmdbuf.copyImageToBuffer(source_image, vk::ImageLayout::eTransferSrcOptimal,
|
||||
staging_buffer, image_copy);
|
||||
cmdbuf.pipelineBarrier(
|
||||
vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eAllCommands,
|
||||
vk::DependencyFlagBits::eByRegion, memory_write_barrier, {}, write_barriers);
|
||||
vk::DependencyFlagBits::eByRegion, memory_write_barrier, {}, write_barrier);
|
||||
});
|
||||
|
||||
// Ensure the copy is fully completed before saving the screenshot
|
||||
@ -1028,27 +971,16 @@ void RendererVulkan::RenderScreenshot() {
|
||||
|
||||
const vk::Device device = instance.GetDevice();
|
||||
|
||||
// Get layout of the image (including row pitch)
|
||||
const vk::ImageSubresource subresource = {
|
||||
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
||||
.mipLevel = 0,
|
||||
.arrayLayer = 0,
|
||||
};
|
||||
|
||||
const vk::SubresourceLayout subresource_layout =
|
||||
device.getImageSubresourceLayout(staging_image, subresource);
|
||||
|
||||
// Copy backing image data to the QImage screenshot buffer
|
||||
const u8* data = reinterpret_cast<const u8*>(alloc_info.pMappedData);
|
||||
std::memcpy(settings.screenshot_bits, data + subresource_layout.offset,
|
||||
subresource_layout.size);
|
||||
std::memcpy(settings.screenshot_bits, alloc_info.pMappedData, staging_buffer_info.size);
|
||||
|
||||
// Destroy allocated resources
|
||||
vmaDestroyBuffer(instance.GetAllocator(), unsafe_buffer, allocation);
|
||||
vmaDestroyImage(instance.GetAllocator(), frame.image, frame.allocation);
|
||||
device.destroyFramebuffer(frame.framebuffer);
|
||||
device.destroyImageView(frame.image_view);
|
||||
|
||||
settings.screenshot_complete_callback();
|
||||
settings.screenshot_complete_callback(false);
|
||||
}
|
||||
|
||||
} // namespace Vulkan
|
||||
|
@ -35,10 +35,7 @@ public:
|
||||
const VideoCore::BufferTextureCopy& copy);
|
||||
|
||||
private:
|
||||
/// Creates compute pipelines used for blit
|
||||
vk::Pipeline MakeComputePipeline(vk::ShaderModule shader, vk::PipelineLayout layout);
|
||||
|
||||
/// Creates graphics pipelines used for blit
|
||||
vk::Pipeline MakeDepthStencilBlitPipeline();
|
||||
|
||||
private:
|
||||
|
@ -150,8 +150,7 @@ void Swapchain::FindPresentFormat() {
|
||||
return;
|
||||
}
|
||||
|
||||
LOG_CRITICAL(Render_Vulkan, "Unable to find required swapchain format!");
|
||||
UNREACHABLE();
|
||||
UNREACHABLE_MSG("Unable to find required swapchain format!");
|
||||
}
|
||||
|
||||
void Swapchain::SetPresentMode() {
|
||||
|
@ -1562,7 +1562,7 @@ DebugScope::DebugScope(TextureRuntime& runtime, Common::Vec4f color, std::string
|
||||
if (!has_debug_tool) {
|
||||
return;
|
||||
}
|
||||
scheduler.Record([color, label](vk::CommandBuffer cmdbuf) {
|
||||
scheduler.Record([color, label = std::string(label)](vk::CommandBuffer cmdbuf) {
|
||||
const vk::DebugUtilsLabelEXT debug_label = {
|
||||
.pLabelName = label.data(),
|
||||
.color = std::array{color[0], color[1], color[2], color[3]},
|
||||
|
@ -232,21 +232,45 @@ void JitShader::Compile_SwizzleSrc(Instruction instr, unsigned src_num, SourceRe
|
||||
address_register_index = instr.common.address_register_index;
|
||||
}
|
||||
|
||||
if (src_num == offset_src && address_register_index != 0) {
|
||||
if (src_reg.GetRegisterType() == RegisterType::FloatUniform && src_num == offset_src &&
|
||||
address_register_index != 0) {
|
||||
Xbyak::Reg64 address_reg;
|
||||
switch (address_register_index) {
|
||||
case 1: // address offset 1
|
||||
movaps(dest, xword[src_ptr + ADDROFFS_REG_0 + src_offset_disp]);
|
||||
case 1:
|
||||
address_reg = ADDROFFS_REG_0;
|
||||
break;
|
||||
case 2: // address offset 2
|
||||
movaps(dest, xword[src_ptr + ADDROFFS_REG_1 + src_offset_disp]);
|
||||
case 2:
|
||||
address_reg = ADDROFFS_REG_1;
|
||||
break;
|
||||
case 3: // address offset 3
|
||||
movaps(dest, xword[src_ptr + LOOPCOUNT_REG.cvt64() + src_offset_disp]);
|
||||
case 3:
|
||||
address_reg = LOOPCOUNT_REG.cvt64();
|
||||
break;
|
||||
default:
|
||||
UNREACHABLE();
|
||||
break;
|
||||
}
|
||||
// s32 offset = address_reg >= -128 && address_reg <= 127 ? address_reg : 0;
|
||||
// u32 index = (src_reg.GetIndex() + offset) & 0x7f;
|
||||
|
||||
// First we add 128 to address_reg so the first comparison is turned to
|
||||
// address_reg >= 0 && address_reg < 256 which can be performed with
|
||||
// a single unsigned comparison (cmovb)
|
||||
lea(eax, ptr[address_reg + 128]);
|
||||
mov(ebx, src_reg.GetIndex());
|
||||
mov(ecx, address_reg.cvt32());
|
||||
add(ecx, ebx);
|
||||
cmp(eax, 256);
|
||||
cmovb(ebx, ecx);
|
||||
and_(ebx, 0x7f);
|
||||
|
||||
// index > 95 ? vec4(1.0) : uniforms.f[index];
|
||||
movaps(dest, ONE);
|
||||
cmp(ebx, 95);
|
||||
Label load_end;
|
||||
jg(load_end);
|
||||
shl(rbx, 4);
|
||||
movaps(dest, xword[src_ptr + rbx]);
|
||||
L(load_end);
|
||||
} else {
|
||||
// Load the source
|
||||
movaps(dest, xword[src_ptr + src_offset_disp]);
|
||||
@ -590,24 +614,14 @@ void JitShader::Compile_MOVA(Instruction instr) {
|
||||
// Move and sign-extend high 32 bits
|
||||
shr(rax, 32);
|
||||
movsxd(ADDROFFS_REG_1, eax);
|
||||
|
||||
// Multiply by 16 to be used as an offset later
|
||||
shl(ADDROFFS_REG_0, 4);
|
||||
shl(ADDROFFS_REG_1, 4);
|
||||
} else {
|
||||
if (swiz.DestComponentEnabled(0)) {
|
||||
// Move and sign-extend low 32 bits
|
||||
movsxd(ADDROFFS_REG_0, eax);
|
||||
|
||||
// Multiply by 16 to be used as an offset later
|
||||
shl(ADDROFFS_REG_0, 4);
|
||||
} else if (swiz.DestComponentEnabled(1)) {
|
||||
// Move and sign-extend high 32 bits
|
||||
shr(rax, 32);
|
||||
movsxd(ADDROFFS_REG_1, eax);
|
||||
|
||||
// Multiply by 16 to be used as an offset later
|
||||
shl(ADDROFFS_REG_1, 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -659,9 +673,6 @@ void JitShader::Compile_END(Instruction instr) {
|
||||
mov(byte[STATE + offsetof(UnitState, conditional_code[1])], COND1.cvt8());
|
||||
|
||||
// Save address/loop registers
|
||||
sar(ADDROFFS_REG_0, 4);
|
||||
sar(ADDROFFS_REG_1, 4);
|
||||
sar(LOOPCOUNT_REG, 4);
|
||||
mov(dword[STATE + offsetof(UnitState, address_registers[0])], ADDROFFS_REG_0.cvt32());
|
||||
mov(dword[STATE + offsetof(UnitState, address_registers[1])], ADDROFFS_REG_1.cvt32());
|
||||
mov(dword[STATE + offsetof(UnitState, address_registers[2])], LOOPCOUNT_REG);
|
||||
@ -813,11 +824,11 @@ void JitShader::Compile_LOOP(Instruction instr) {
|
||||
std::size_t offset = Uniforms::GetIntUniformOffset(instr.flow_control.int_uniform_id);
|
||||
mov(LOOPCOUNT, dword[UNIFORMS + offset]);
|
||||
mov(LOOPCOUNT_REG, LOOPCOUNT);
|
||||
shr(LOOPCOUNT_REG, 4);
|
||||
and_(LOOPCOUNT_REG, 0xFF0); // Y-component is the start
|
||||
shr(LOOPCOUNT_REG, 8);
|
||||
and_(LOOPCOUNT_REG, 0xFF); // Y-component is the start
|
||||
mov(LOOPINC, LOOPCOUNT);
|
||||
shr(LOOPINC, 12);
|
||||
and_(LOOPINC, 0xFF0); // Z-component is the incrementer
|
||||
shr(LOOPINC, 16);
|
||||
and_(LOOPINC, 0xFF); // Z-component is the incrementer
|
||||
movzx(LOOPCOUNT, LOOPCOUNT.cvt8()); // X-component is iteration count
|
||||
add(LOOPCOUNT, 1); // Iteration count is X-component + 1
|
||||
|
||||
@ -993,9 +1004,6 @@ void JitShader::Compile(const std::array<u32, MAX_PROGRAM_CODE_LENGTH>* program_
|
||||
movsxd(ADDROFFS_REG_0, dword[STATE + offsetof(UnitState, address_registers[0])]);
|
||||
movsxd(ADDROFFS_REG_1, dword[STATE + offsetof(UnitState, address_registers[1])]);
|
||||
mov(LOOPCOUNT_REG, dword[STATE + offsetof(UnitState, address_registers[2])]);
|
||||
shl(ADDROFFS_REG_0, 4);
|
||||
shl(ADDROFFS_REG_1, 4);
|
||||
shl(LOOPCOUNT_REG, 4);
|
||||
|
||||
// Load conditional code
|
||||
mov(COND0, byte[STATE + offsetof(UnitState, conditional_code[0])]);
|
||||
|
Reference in New Issue
Block a user