Merge branch 'shadps4-emu:main' into knack2-menu-fixes

Author: w1naenator

CMakeLists.txt

@@ -694,6 +694,9 @@ set(NP_LIBS src/core/libraries/np/np_error.h
             src/core/libraries/np/np_tus/np_tus.cpp
             src/core/libraries/np/np_tus/np_tus.h
             src/core/libraries/np/np_tus/np_tus_ctx.h
+            src/core/libraries/np/np_utility/np_utility.cpp
+            src/core/libraries/np/np_utility/np_utility.h
+            src/core/libraries/np/np_utility/np_utility_ctx.h
 )
 
 set(ZLIB_LIB src/core/libraries/zlib/zlib.cpp
@@ -1020,7 +1023,6 @@ set(SHADER_RECOMPILER src/shader_recompiler/profile.h
                       src/shader_recompiler/ir/passes/dead_code_elimination_pass.cpp
                       src/shader_recompiler/ir/passes/flatten_extended_userdata_pass.cpp
                       src/shader_recompiler/ir/passes/hull_shader_transform.cpp
-                      src/shader_recompiler/ir/passes/identity_removal_pass.cpp
                       src/shader_recompiler/ir/passes/inject_clip_distance_attributes.cpp
                       src/shader_recompiler/ir/passes/ir_passes.h
                       src/shader_recompiler/ir/passes/lower_buffer_format_to_raw.cpp
@@ -1033,6 +1035,8 @@ set(SHADER_RECOMPILER src/shader_recompiler/profile.h
                       src/shader_recompiler/ir/passes/shared_memory_barrier_pass.cpp
                       src/shader_recompiler/ir/passes/shared_memory_simplify_pass.cpp
                       src/shader_recompiler/ir/passes/shared_memory_to_storage_pass.cpp
+                      src/shader_recompiler/ir/passes/lower_phis_to_regs_pass.cpp
+                      src/shader_recompiler/ir/passes/ssa_repair_pass.cpp
                       src/shader_recompiler/ir/passes/ssa_rewrite_pass.cpp
                       src/shader_recompiler/ir/abstract_syntax_list.cpp
                       src/shader_recompiler/ir/abstract_syntax_list.h
@@ -1042,9 +1046,12 @@ set(SHADER_RECOMPILER src/shader_recompiler/profile.h
                       src/shader_recompiler/ir/basic_block.h
                       src/shader_recompiler/ir/breadth_first_search.h
                       src/shader_recompiler/ir/condition.h
+                      src/shader_recompiler/ir/dominance.cpp
+                      src/shader_recompiler/ir/dominance.h
                       src/shader_recompiler/ir/ir_emitter.cpp
                       src/shader_recompiler/ir/ir_emitter.h
                       src/shader_recompiler/ir/microinstruction.cpp
+                      src/shader_recompiler/ir/microinstruction.h
                       src/shader_recompiler/ir/opcodes.cpp
                       src/shader_recompiler/ir/opcodes.h
                       src/shader_recompiler/ir/opcodes.inc
@@ -1057,6 +1064,8 @@ set(SHADER_RECOMPILER src/shader_recompiler/profile.h
                       src/shader_recompiler/ir/program.cpp
                       src/shader_recompiler/ir/program.h
                       src/shader_recompiler/ir/reinterpret.h
+                      src/shader_recompiler/ir/srt_gvn_table.h
+                      src/shader_recompiler/ir/ssa.h
                       src/shader_recompiler/ir/reg.h
                       src/shader_recompiler/ir/type.cpp
                       src/shader_recompiler/ir/type.h

README.md

@@ -160,7 +160,8 @@ The following firmware modules are supported and must be placed in shadPS4's `sy
 | libSceFreeTypeOt.sprx          | libSceJpegDec.sprx             | libSceJpegEnc.sprx             | libSceJson.sprx                |
 | libSceJson2.sprx               | libSceLibcInternal.sprx        | libSceNgs2.sprx                | libScePngEnc.sprx              |
 | libScePsmKitSystem.sprx        | libSceRtc.sprx                 | libSceRudp.sprx                | libSceSystemGesture.sprx       |
-| libSceUlt.sprx                 | libSceWkFontConfig.sprx        | libSceXml.sprx                 |
+| libSceUlt.sprx                 | libSceWkFontConfig.sprx        | libSceXml.sprx                 | libSceDepth.sprx               |
+| libScePadTracker.sprx          | libSceMoveTracker.sprx         |
 </div>
 
 > [!Caution]

documents/Debugging/Debugging.md

@@ -131,7 +131,7 @@ This section will provide some preliminary steps to take and tips on what to do
     - **Logs aren't always accurate in determining the reason for a crash.**\
       Some log entries are reported as errors but may not be fatal for the execution to stop. `Critical` entries are most likely to be the cause for crashes.
 
-    - Pinpoint the area of the emulator where the crash occured\
+    - Pinpoint the area of the emulator where the crash occurred\
       If the stack trace ends with functions that are relevant to rendering, it is safe to assume that the issue is with **rendering**.\
       Similarly, if a crash is in a library responsible for playing videos, your issue can be narrowed down to the scope of video playback in the emulator.
 

src/common/logging/classes.h

@@ -75,6 +75,7 @@ constexpr auto Lib_NpScore = "Lib.NpScore";                         ///< The Lib
 constexpr auto Lib_NpSnsFacebookDialog = "Lib.NpSnsFacebookDialog"; ///< The LibSceNpSnsFacebookDialog implementation
 constexpr auto Lib_NpTrophy = "Lib.NpTrophy";                       ///< The LibSceNpTrophy implementation
 constexpr auto Lib_NpTus = "Lib.NpTus";                             ///< The LibSceNpTus implementation
+constexpr auto Lib_NpUtility = "Lib.NpUtility";                     ///< The LibSceNpUtility implementation
 constexpr auto Lib_NpWebApi = "Lib.NpWebApi";                       ///< The LibSceWebApi implementation
 constexpr auto Lib_NpWebApi2 = "Lib.NpWebApi2";                     ///< The LibSceWebApi2 implementation
 constexpr auto Lib_Pad = "Lib.Pad";                                 ///< The LibScePad implementation.

src/common/logging/log.cpp

@@ -99,6 +99,7 @@ std::unordered_map<std::string_view, std::shared_ptr<spdlog::logger>> ALL_LOGGER
     {Class::Lib_NpSnsFacebookDialog, nullptr},
     {Class::Lib_NpTrophy, nullptr},
     {Class::Lib_NpTus, nullptr},
+    {Class::Lib_NpUtility, nullptr},
     {Class::Lib_NpWebApi, nullptr},
     {Class::Lib_NpWebApi2, nullptr},
     {Class::Lib_Pad, nullptr},

src/common/logging/log.h

@@ -53,7 +53,8 @@ static constexpr std::array level_string_views{"Trace", "Debug",    "Info", "War
 // Define the fmt lib macros
 #define LOG_GENERIC(log_class, log_level, format, ...)                                             \
     do {                                                                                           \
-        if (auto logger = Common::Log::ALL_LOGGERS[log_class]) {                                   \
+        if (auto logger = Common::Log::ALL_LOGGERS[log_class];                                     \
+            logger && logger->should_log(log_level)) {                                             \
             logger->log(log_level, "[{}] <{}> ({}) {}:{} {}: " format, log_class,                  \
                         Common::Log::to_string_view(log_level), Common::GetCurrentThreadName(),    \
                         spdlog::source_loc::basename(__FILE__), __LINE__,                          \

src/common/memory_patcher.cpp

@@ -230,8 +230,31 @@ void OnGameLoaded() {
             if (!repo.is_directory()) {
                 continue;
             }
-            std::ifstream json_file{repo.path() / "files.json"};
-            nlohmann::json available_patches = nlohmann::json::parse(json_file);
+
+            const auto files_json_path = repo.path() / "files.json";
+
+            if (!std::filesystem::is_regular_file(files_json_path)) {
+                LOG_ERROR(Loader, "The folder '{}' does not contain the files.json file.",
+                          repo.path().filename().string());
+                continue;
+            }
+
+            std::ifstream json_file{files_json_path};
+            nlohmann::json available_patches;
+
+            if (!json_file.is_open()) {
+                LOG_ERROR(Loader, "Could not open patch index: {}", files_json_path.string());
+                continue;
+            }
+
+            try {
+                available_patches = nlohmann::json::parse(json_file);
+            } catch (const nlohmann::json::parse_error& e) {
+                LOG_ERROR(Loader, "Could not parse patch index {}: {}", files_json_path.string(),
+                          e.what());
+                continue;
+            }
+
             std::filesystem::path game_patch_file;
             for (auto const& [filename, serials] : available_patches.items()) {
                 if (std::find(serials.begin(), serials.end(), g_game_serial) != serials.end()) {

src/core/libraries/camera/camera.cpp

@@ -7,8 +7,10 @@
 #include "core/libraries/camera/camera.h"
 #include "core/libraries/camera/camera_error.h"
 #include "core/libraries/error_codes.h"
+#include "core/libraries/kernel/memory.h"
 #include "core/libraries/kernel/process.h"
 #include "core/libraries/libs.h"
+#include "core/memory.h"
 
 #include <utility>
 
@@ -22,6 +24,9 @@ static s32 g_firmware_version = 0;
 static s32 g_handles = 0;
 static constexpr s32 c_width = 1280, c_height = 800;
 
+static u16 *raw16_buffer1{}, *raw16_buffer2{};
+static u8 *raw8_buffer1{}, *raw8_buffer2{};
+
 SDL_Camera* sdl_camera = nullptr;
 OrbisCameraConfigExtention output_config0, output_config1;
 
@@ -180,9 +185,37 @@ s32 PS4_SYSV_ABI sceCameraGetAutoWhiteBalance(s32 handle, OrbisCameraChannel cha
     return ORBIS_OK;
 }
 
-s32 PS4_SYSV_ABI sceCameraGetCalibData() {
-    LOG_ERROR(Lib_Camera, "(STUBBED) called");
-    return ORBIS_CAMERA_ERROR_NOT_CONNECTED;
+s32 PS4_SYSV_ABI sceCameraGetCalibData(s32 id, void* calib_data, void* maybe_reserved) {
+    LOG_WARNING(Lib_Camera, "(DUMMY) called, id: {}", id);
+    if (calib_data == nullptr) {
+        return ORBIS_CAMERA_ERROR_PARAM;
+    }
+    if (id != 1 && id != 2) {
+        return ORBIS_OK;
+    }
+    static constexpr u64 dumped_calib_data1[32]{
+        0x000000000b0b0200, 0x00000000bc128639, 0x000000003de79766, 0x00000000be6e2869,
+        0x3ca0ce1f3e30521c, 0x4452d55e3d0160b6, 0x3cf7fdaa4453abf1, 0x000000003ce3f40f,
+        0x000000003cdbcaa6, 0x000000003d635f4e, 0x00000000be299439, 0xbb98ddc23e1159b4,
+        0x44523b6c3c87d83c, 0x3c8d1c46445308a2, 0xbbb83fe03c9bcc40, 0xbab0ed65b8fe93b0,
+        0xba677004bb598091, 0x3c0eb61e3b49d173, 0xba1bac9f3c67af0b, 0x00000000b9d0e64d,
+        0x0000000000000000, 0x0000000000000000, 0xb97653e400000000, 0x00000000ba95460e,
+        0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+        0x0000000000000000, 0x0000000000000000, 0xbab5330000000000, 0x000001013b07a47f,
+    };
+    static constexpr u64 dumped_calib_data2[32]{
+        0x002d000000ff0009, 0x002d0ff70ffd0f14, 0x002d0efe00010008, 0x002f0ffe0f020008,
+        0x002f000800060105, 0x002e00fc0001000a, 0x0000000000000000, 0x0000000000000000,
+        0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+        0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+        0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+        0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+        0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+        0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+    };
+    std::memcpy(calib_data, id == 1 ? dumped_calib_data1 : dumped_calib_data2,
+                sizeof(dumped_calib_data1));
+    return ORBIS_OK;
 }
 
 s32 PS4_SYSV_ABI sceCameraGetCalibDataFromDevice() {
@@ -335,9 +368,6 @@ s32 PS4_SYSV_ABI sceCameraGetExposureGain(s32 handle, OrbisCameraChannel channel
     return ORBIS_OK;
 }
 
-static std::vector<u16> raw16_buffer1, raw16_buffer2;
-static std::vector<u8> raw8_buffer1, raw8_buffer2;
-
 static void ConvertRGBA8888ToRAW16(const u8* src, u16* dst, int width, int height) {
     for (int y = 0; y < height; ++y) {
         const u8* row = src + y * width * 4;
@@ -446,30 +476,32 @@ s32 PS4_SYSV_ABI sceCameraGetFrameData(s32 handle, OrbisCameraFrameData* frame_d
 
     switch (output_config0.format.formatLevel0) {
     case ORBIS_CAMERA_FORMAT_YUV422:
-        frame_data->pFramePointerList[0][0] = frame->pixels;
+        std::memcpy(raw16_buffer1, frame->pixels, c_width * c_height * sizeof(u16));
+        frame_data->pFramePointerList[0][0] = raw16_buffer1;
         break;
     case ORBIS_CAMERA_FORMAT_RAW16:
-        ConvertRGBA8888ToRAW16((u8*)frame->pixels, raw16_buffer1.data(), c_width, c_height);
-        frame_data->pFramePointerList[0][0] = raw16_buffer1.data();
+        ConvertRGBA8888ToRAW16((u8*)frame->pixels, raw16_buffer1, c_width, c_height);
+        frame_data->pFramePointerList[0][0] = raw16_buffer1;
         break;
     case ORBIS_CAMERA_FORMAT_RAW8:
-        ConvertRGBA8888ToRAW8((u8*)frame->pixels, raw8_buffer1.data(), c_width, c_height);
-        frame_data->pFramePointerList[0][0] = raw8_buffer1.data();
+        ConvertRGBA8888ToRAW8((u8*)frame->pixels, raw8_buffer1, c_width, c_height);
+        frame_data->pFramePointerList[0][0] = raw8_buffer1;
         break;
     default:
         UNREACHABLE();
     }
     switch (output_config1.format.formatLevel0) {
     case ORBIS_CAMERA_FORMAT_YUV422:
-        frame_data->pFramePointerList[1][0] = frame->pixels;
+        std::memcpy(raw16_buffer2, frame->pixels, c_width * c_height * sizeof(u16));
+        frame_data->pFramePointerList[1][0] = raw16_buffer2;
         break;
     case ORBIS_CAMERA_FORMAT_RAW16:
-        ConvertRGBA8888ToRAW16((u8*)frame->pixels, raw16_buffer2.data(), c_width, c_height);
-        frame_data->pFramePointerList[1][0] = raw16_buffer2.data();
+        ConvertRGBA8888ToRAW16((u8*)frame->pixels, raw16_buffer2, c_width, c_height);
+        frame_data->pFramePointerList[1][0] = raw16_buffer2;
         break;
     case ORBIS_CAMERA_FORMAT_RAW8:
-        ConvertRGBA8888ToRAW8((u8*)frame->pixels, raw8_buffer2.data(), c_width, c_height);
-        frame_data->pFramePointerList[1][0] = raw8_buffer2.data();
+        ConvertRGBA8888ToRAW8((u8*)frame->pixels, raw8_buffer2, c_width, c_height);
+        frame_data->pFramePointerList[1][0] = raw8_buffer2;
         break;
     default:
         UNREACHABLE();
@@ -688,6 +720,30 @@ s32 PS4_SYSV_ABI sceCameraOpen(Libraries::UserService::OrbisUserServiceUserId us
         return ORBIS_CAMERA_ERROR_PARAM;
     }
 
+    constexpr s32 camera_system_mem_size = 0xfd0000;
+    void* camera_garlic_pool = (void*)0xfd0000000;
+
+    s32 ret = Libraries::Kernel::sceKernelMapNamedSystemFlexibleMemory(
+        &camera_garlic_pool, camera_system_mem_size,
+        (s32)(Core::MemoryProt::CpuReadWrite | Core::MemoryProt::GpuRead), 0,
+        "SceCameraGpuGarlicPool");
+    ASSERT(ret == ORBIS_OK);
+
+    constexpr s32 raw8_buffer_size = c_width * c_height * sizeof(u8);
+    constexpr s32 raw16_buffer_size = c_width * c_height * sizeof(u16);
+
+    u8* remaining_camera_buf = (u8*)camera_garlic_pool;
+
+    raw8_buffer1 = remaining_camera_buf += raw8_buffer_size;
+    raw8_buffer2 = remaining_camera_buf += raw8_buffer_size;
+    raw16_buffer1 = (u16*)(remaining_camera_buf += raw16_buffer_size);
+    raw16_buffer2 = (u16*)(remaining_camera_buf += raw16_buffer_size);
+
+    ASSERT(remaining_camera_buf <= (u8*)camera_garlic_pool + camera_system_mem_size);
+
+    ASSERT(Core::Memory::Instance()->IsValidGpuMapping((VAddr)camera_garlic_pool,
+                                                       camera_system_mem_size));
+
     g_library_opened = true;
     return ++g_handles;
 }
@@ -1075,10 +1131,6 @@ s32 PS4_SYSV_ABI sceCameraStart(s32 handle, OrbisCameraStartParameter* param) {
         LOG_INFO(Lib_Camera, "No camera devices connected");
         return ORBIS_CAMERA_ERROR_NOT_CONNECTED;
     }
-    raw8_buffer1.resize(c_width * c_height);
-    raw16_buffer1.resize(c_width * c_height);
-    raw8_buffer2.resize(c_width * c_height);
-    raw16_buffer2.resize(c_width * c_height);
     SDL_CameraSpec cam_spec{};
     switch (output_config0.format.formatLevel0) {
     case ORBIS_CAMERA_FORMAT_YUV422:

src/core/libraries/camera/camera.h

@@ -367,7 +367,7 @@ s32 PS4_SYSV_ABI sceCameraGetAutoExposureGain(s32 handle, OrbisCameraChannel cha
                                               OrbisCameraAutoExposureGainTarget* option);
 s32 PS4_SYSV_ABI sceCameraGetAutoWhiteBalance(s32 handle, OrbisCameraChannel channel, u32* enable,
                                               void* option);
-s32 PS4_SYSV_ABI sceCameraGetCalibData();
+s32 PS4_SYSV_ABI sceCameraGetCalibData(s32 handle, void* calib_data, void* maybe_reserved);
 s32 PS4_SYSV_ABI sceCameraGetCalibDataFromDevice();
 s32 PS4_SYSV_ABI sceCameraGetCalibrationData(const OrbisCameraGetCalibrationDataParameter* param,
                                              OrbisCameraCalibrationData* calibration_data);

src/core/libraries/kernel/memory.h

@@ -152,6 +152,8 @@ s32 PS4_SYSV_ABI sceKernelReserveVirtualRange(void** addr, u64 len, s32 flags, u
 s32 PS4_SYSV_ABI sceKernelMapNamedFlexibleMemory(void** addr_in_out, u64 len, s32 prot, s32 flags,
                                                  const char* name);
 s32 PS4_SYSV_ABI sceKernelMapFlexibleMemory(void** addr_in_out, u64 len, s32 prot, s32 flags);
+s32 PS4_SYSV_ABI sceKernelMapNamedSystemFlexibleMemory(void** addr_in_out, u64 len, s32 prot,
+                                                       s32 flags, const char* name);
 s32 PS4_SYSV_ABI sceKernelQueryMemoryProtection(void* addr, void** start, void** end, u32* prot);
 
 s32 PS4_SYSV_ABI sceKernelMprotect(const void* addr, u64 size, s32 prot);