From 59bee8d18762fefaf3fef460c13955ce1eb61777 Mon Sep 17 00:00:00 2001 From: boykopovar Date: Thu, 20 Aug 2026 23:18:16 +0300 Subject: [PATCH] feat(libs): add libs function signatures --- core/libs/CMakeLists.txt | 29 +- core/libs/SceTypes.hpp | 1395 ++++++++++++ core/libs/prx/CMakeLists.txt | 40 + .../Export.cpp | 46 + .../prx/libReactNative.Modules.Vsh/Export.cpp | 30 + core/libs/prx/libSceAcm/Export.cpp | 42 + core/libs/prx/libSceAgc/Export.cpp | 780 +++++++ core/libs/prx/libSceAgcDriver/Export.cpp | 119 ++ core/libs/prx/libSceAgcVsh/Export.cpp | 780 +++++++ core/libs/prx/libSceAjm.native/Export.cpp | 266 +++ core/libs/prx/libSceAjm/Export.cpp | 89 + core/libs/prx/libSceAjmi/Export.cpp | 89 + core/libs/prx/libSceAppContent/Export.cpp | 54 + core/libs/{ => prx}/libSceAudio/Export.cpp | 1 + core/libs/prx/libSceAudio3d/Export.cpp | 49 + core/libs/prx/libSceAudioIn/Export.cpp | 28 + core/libs/prx/libSceAudioOut/Export.cpp | 217 ++ .../prx/libSceAudioPropagation/Export.cpp | 47 + .../libs/prx/libSceAudiodec.native/Export.cpp | 39 + core/libs/prx/libSceAudiodec/Export.cpp | 39 + .../libs/prx/libSceAvPlayer.native/Export.cpp | 166 ++ core/libs/prx/libSceAvPlayer/Export.cpp | 151 ++ core/libs/prx/libSceCesCs/Export.cpp | 29 + core/libs/prx/libSceCommonDialog/Export.cpp | 15 + core/libs/prx/libSceContentDelete/Export.cpp | 12 + core/libs/prx/libSceContentExport/Export.cpp | 12 + core/libs/prx/libSceContentSearch/Export.cpp | 12 + core/libs/prx/libSceErrorDialog/Export.cpp | 32 + core/libs/prx/libSceFiber/Export.cpp | 68 + core/libs/prx/libSceFont.native/Export.cpp | 451 ++++ core/libs/prx/libSceFont/Export.cpp | 451 ++++ core/libs/prx/libSceFontFt/Export.cpp | 17 + .../prx/libSceGameLiveStreaming/Export.cpp | 16 + core/libs/prx/libSceGameUpdate/Export.cpp | 43 + core/libs/prx/libSceHttp/Export.cpp | 245 +++ core/libs/prx/libSceHttp2/Export.cpp | 201 ++ core/libs/prx/libSceIme/Export.cpp | 79 + core/libs/prx/libSceImeDialog/Export.cpp | 50 + core/libs/prx/libSceKeyboard/Export.cpp | 47 + core/libs/prx/libSceLibcInternal/Export.cpp | 210 ++ core/libs/prx/libSceLoginDialog/Export.cpp | 37 + core/libs/prx/libSceMouse/Export.cpp | 31 + core/libs/prx/libSceMsgDialog/Export.cpp | 55 + core/libs/prx/libSceNet/Export.cpp | 178 ++ core/libs/prx/libSceNetCtl/Export.cpp | 57 + core/libs/prx/libSceNgs2.native/Export.cpp | 190 ++ core/libs/prx/libSceNgs2/Export.cpp | 177 ++ core/libs/prx/libSceNpAuth/Export.cpp | 53 + core/libs/prx/libSceNpCommerce/Export.cpp | 11 + .../prx/libSceNpEntitlementAccess/Export.cpp | 33 + core/libs/prx/libSceNpGameIntent/Export.cpp | 29 + core/libs/prx/libSceNpManager/Export.cpp | 149 ++ .../prx/libSceNpSessionSignaling/Export.cpp | 12 + core/libs/prx/libSceNpTrophy2/Export.cpp | 122 ++ .../libSceNpUniversalDataSystem/Export.cpp | 266 +++ core/libs/prx/libSceNpWebApi2/Export.cpp | 124 ++ core/libs/prx/libScePad/Export.cpp | 126 ++ core/libs/prx/libScePlayGo/Export.cpp | 129 ++ core/libs/prx/libScePngDec/Export.cpp | 38 + core/libs/prx/libSceRandom/Export.cpp | 13 + core/libs/prx/libSceRazorCpu/Export.cpp | 11 + core/libs/prx/libSceRemoteplay/Export.cpp | 23 + core/libs/prx/libSceRtc/Export.cpp | 159 ++ core/libs/prx/libSceRudp/Export.cpp | 25 + .../libs/prx/libSceSaveData.native/Export.cpp | 139 ++ core/libs/prx/libSceSaveData/Export.cpp | 100 + .../libSceSaveDataDialog.native/Export.cpp | 54 + core/libs/prx/libSceSaveDataDialog/Export.cpp | 54 + core/libs/prx/libSceShare.native/Export.cpp | 81 + core/libs/prx/libSceSharePlay/Export.cpp | 17 + core/libs/prx/libSceSigninDialog/Export.cpp | 37 + core/libs/prx/libSceSsl/Export.cpp | 29 + core/libs/prx/libSceSysmodule/Export.cpp | 38 + core/libs/prx/libSceSystemGesture/Export.cpp | 144 ++ core/libs/prx/libSceSystemService/Export.cpp | 66 + core/libs/prx/libSceUlt/Export.cpp | 175 ++ core/libs/prx/libSceUserService/Export.cpp | 86 + core/libs/prx/libSceVideoOut/Export.cpp | 191 ++ core/libs/prx/libSceVoice/Export.cpp | 101 + core/libs/prx/libSceVoiceQoS/Export.cpp | 14 + .../prx/libSceWebBrowserDialog/Export.cpp | 15 + core/libs/prx/libkernel/Export.cpp | 1876 +++++++++++++++++ core/libs/prx/libkernel_sys/Export.cpp | 1876 +++++++++++++++++ core/libs/prx/libkernel_web/Export.cpp | 1876 +++++++++++++++++ 84 files changed, 15489 insertions(+), 14 deletions(-) create mode 100644 core/libs/SceTypes.hpp create mode 100644 core/libs/prx/CMakeLists.txt create mode 100644 core/libs/prx/libReactNative.Modules.Vsh.WebAppLauncher/Export.cpp create mode 100644 core/libs/prx/libReactNative.Modules.Vsh/Export.cpp create mode 100644 core/libs/prx/libSceAcm/Export.cpp create mode 100644 core/libs/prx/libSceAgc/Export.cpp create mode 100644 core/libs/prx/libSceAgcDriver/Export.cpp create mode 100644 core/libs/prx/libSceAgcVsh/Export.cpp create mode 100644 core/libs/prx/libSceAjm.native/Export.cpp create mode 100644 core/libs/prx/libSceAjm/Export.cpp create mode 100644 core/libs/prx/libSceAjmi/Export.cpp create mode 100644 core/libs/prx/libSceAppContent/Export.cpp rename core/libs/{ => prx}/libSceAudio/Export.cpp (96%) create mode 100644 core/libs/prx/libSceAudio3d/Export.cpp create mode 100644 core/libs/prx/libSceAudioIn/Export.cpp create mode 100644 core/libs/prx/libSceAudioOut/Export.cpp create mode 100644 core/libs/prx/libSceAudioPropagation/Export.cpp create mode 100644 core/libs/prx/libSceAudiodec.native/Export.cpp create mode 100644 core/libs/prx/libSceAudiodec/Export.cpp create mode 100644 core/libs/prx/libSceAvPlayer.native/Export.cpp create mode 100644 core/libs/prx/libSceAvPlayer/Export.cpp create mode 100644 core/libs/prx/libSceCesCs/Export.cpp create mode 100644 core/libs/prx/libSceCommonDialog/Export.cpp create mode 100644 core/libs/prx/libSceContentDelete/Export.cpp create mode 100644 core/libs/prx/libSceContentExport/Export.cpp create mode 100644 core/libs/prx/libSceContentSearch/Export.cpp create mode 100644 core/libs/prx/libSceErrorDialog/Export.cpp create mode 100644 core/libs/prx/libSceFiber/Export.cpp create mode 100644 core/libs/prx/libSceFont.native/Export.cpp create mode 100644 core/libs/prx/libSceFont/Export.cpp create mode 100644 core/libs/prx/libSceFontFt/Export.cpp create mode 100644 core/libs/prx/libSceGameLiveStreaming/Export.cpp create mode 100644 core/libs/prx/libSceGameUpdate/Export.cpp create mode 100644 core/libs/prx/libSceHttp/Export.cpp create mode 100644 core/libs/prx/libSceHttp2/Export.cpp create mode 100644 core/libs/prx/libSceIme/Export.cpp create mode 100644 core/libs/prx/libSceImeDialog/Export.cpp create mode 100644 core/libs/prx/libSceKeyboard/Export.cpp create mode 100644 core/libs/prx/libSceLibcInternal/Export.cpp create mode 100644 core/libs/prx/libSceLoginDialog/Export.cpp create mode 100644 core/libs/prx/libSceMouse/Export.cpp create mode 100644 core/libs/prx/libSceMsgDialog/Export.cpp create mode 100644 core/libs/prx/libSceNet/Export.cpp create mode 100644 core/libs/prx/libSceNetCtl/Export.cpp create mode 100644 core/libs/prx/libSceNgs2.native/Export.cpp create mode 100644 core/libs/prx/libSceNgs2/Export.cpp create mode 100644 core/libs/prx/libSceNpAuth/Export.cpp create mode 100644 core/libs/prx/libSceNpCommerce/Export.cpp create mode 100644 core/libs/prx/libSceNpEntitlementAccess/Export.cpp create mode 100644 core/libs/prx/libSceNpGameIntent/Export.cpp create mode 100644 core/libs/prx/libSceNpManager/Export.cpp create mode 100644 core/libs/prx/libSceNpSessionSignaling/Export.cpp create mode 100644 core/libs/prx/libSceNpTrophy2/Export.cpp create mode 100644 core/libs/prx/libSceNpUniversalDataSystem/Export.cpp create mode 100644 core/libs/prx/libSceNpWebApi2/Export.cpp create mode 100644 core/libs/prx/libScePad/Export.cpp create mode 100644 core/libs/prx/libScePlayGo/Export.cpp create mode 100644 core/libs/prx/libScePngDec/Export.cpp create mode 100644 core/libs/prx/libSceRandom/Export.cpp create mode 100644 core/libs/prx/libSceRazorCpu/Export.cpp create mode 100644 core/libs/prx/libSceRemoteplay/Export.cpp create mode 100644 core/libs/prx/libSceRtc/Export.cpp create mode 100644 core/libs/prx/libSceRudp/Export.cpp create mode 100644 core/libs/prx/libSceSaveData.native/Export.cpp create mode 100644 core/libs/prx/libSceSaveData/Export.cpp create mode 100644 core/libs/prx/libSceSaveDataDialog.native/Export.cpp create mode 100644 core/libs/prx/libSceSaveDataDialog/Export.cpp create mode 100644 core/libs/prx/libSceShare.native/Export.cpp create mode 100644 core/libs/prx/libSceSharePlay/Export.cpp create mode 100644 core/libs/prx/libSceSigninDialog/Export.cpp create mode 100644 core/libs/prx/libSceSsl/Export.cpp create mode 100644 core/libs/prx/libSceSysmodule/Export.cpp create mode 100644 core/libs/prx/libSceSystemGesture/Export.cpp create mode 100644 core/libs/prx/libSceSystemService/Export.cpp create mode 100644 core/libs/prx/libSceUlt/Export.cpp create mode 100644 core/libs/prx/libSceUserService/Export.cpp create mode 100644 core/libs/prx/libSceVideoOut/Export.cpp create mode 100644 core/libs/prx/libSceVoice/Export.cpp create mode 100644 core/libs/prx/libSceVoiceQoS/Export.cpp create mode 100644 core/libs/prx/libSceWebBrowserDialog/Export.cpp create mode 100644 core/libs/prx/libkernel/Export.cpp create mode 100644 core/libs/prx/libkernel_sys/Export.cpp create mode 100644 core/libs/prx/libkernel_web/Export.cpp diff --git a/core/libs/CMakeLists.txt b/core/libs/CMakeLists.txt index 0c9090840..d62bd5c71 100644 --- a/core/libs/CMakeLists.txt +++ b/core/libs/CMakeLists.txt @@ -1,12 +1,12 @@ add_executable(nid_patcher - ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/Sha1.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/NidCompute.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/main.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/Sha1.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/NidCompute.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/main.cpp ) target_include_directories(nid_patcher PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/nid/include) target_compile_features(nid_patcher PRIVATE cxx_std_20) -file(GLOB LIBS_DIRS LIST_DIRECTORIES true ${CMAKE_CURRENT_SOURCE_DIR}/lib*) +file(GLOB LIBS_DIRS LIST_DIRECTORIES true ${CMAKE_CURRENT_SOURCE_DIR}/prx/*) set(PATCHED_STAMPS) @@ -15,22 +15,23 @@ foreach(LIB_DIR ${LIBS_DIRS}) get_filename_component(LIB_NAME ${LIB_DIR} NAME) add_library(${LIB_NAME} SHARED EXCLUDE_FROM_ALL ${LIB_DIR}/Export.cpp) + target_include_directories(${LIB_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) set_target_properties(${LIB_NAME} PROPERTIES - PREFIX "" - SUFFIX .rpx - RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs - LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs + PREFIX "" + SUFFIX .rpx + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs ) - set(RPX_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.rpx) + set(RPX_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.prx) set(STAMP_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.patched) add_custom_command( - OUTPUT ${STAMP_FILE} - COMMAND $ ${LIB_NAME} ${RPX_FILE} - COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_FILE} - DEPENDS nid_patcher ${LIB_NAME} - COMMENT "Patching NIDs for ${LIB_NAME}" + OUTPUT ${STAMP_FILE} + COMMAND $ ${LIB_NAME} ${RPX_FILE} + COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_FILE} + DEPENDS nid_patcher ${LIB_NAME} + COMMENT "Patching NIDs for ${LIB_NAME}" ) list(APPEND PATCHED_STAMPS ${STAMP_FILE}) diff --git a/core/libs/SceTypes.hpp b/core/libs/SceTypes.hpp new file mode 100644 index 000000000..3b44d1cbb --- /dev/null +++ b/core/libs/SceTypes.hpp @@ -0,0 +1,1395 @@ +#ifndef CORE_LIBS_SCE_TYPES_HPP +#define CORE_LIBS_SCE_TYPES_HPP + +#include +#include +#include + +typedef float __m128 __attribute__((__vector_size__(16), __aligned__(16))); + +using Bool = std::uint8_t; + +using KernelModule = std::int32_t; +using KernelCpumask = std::uint64_t; +using KernelUseconds = unsigned int; +using KernelClockid = std::int32_t; +using KernelEqueue = std::int64_t; +using KernelKey = int; + +struct KernelTimespec { + std::int64_t tv_sec; + std::int64_t tv_nsec; +}; + +struct KernelTimeval { + std::int64_t tv_sec; + std::int64_t tv_usec; +}; + +struct KernelTimezone { + std::int32_t tz_minuteswest; + std::int32_t tz_dsttime; +}; + +struct KernelTimesec { + std::int64_t t; + std::uint32_t west_sec; + std::uint32_t dst_sec; +}; + +struct KernelEvent { + std::uintptr_t ident = 0; + std::int16_t filter = 0; + std::uint16_t flags = 0; + std::uint32_t fflags = 0; + std::intptr_t data = 0; + void* udata = nullptr; +}; + +struct KernelSchedParam { + int sched_priority; +}; + +struct KernelLoadModuleOpt { + std::size_t size; +}; + +struct KernelUnloadModuleOpt { + std::size_t size; +}; + +struct KernelAioResult { + std::int64_t return_value; + std::uint32_t state; +}; + +struct KernelAioRwRequest { + std::int64_t offset; + std::size_t nbyte; + void* buf; + KernelAioResult* result; + std::int32_t fd; +}; + +struct KernelBatchMapEntry { + void* start; + std::uint64_t offset; + std::uint64_t length; + char protection; + char type; + std::int16_t reserved; + std::int32_t operation; +}; + +struct KernelMemoryPoolBatchEntry { + std::uint32_t op; + std::uint32_t flags; + union { + struct { + void* addr; + std::uint64_t len; + std::uint8_t prot; + std::uint8_t type; + } commit; + struct { + void* addr; + std::uint64_t len; + } decommit; + struct { + void* addr; + std::uint64_t len; + std::uint8_t prot; + } protect; + struct { + void* addr; + std::uint64_t len; + std::uint8_t prot; + std::uint8_t type; + } type_protect; + struct { + void* dst; + void* src; + std::uint64_t len; + } move; + std::uintptr_t padding[3]; + }; +}; + +struct KernelMemoryPoolBlockStats { + std::int32_t available_flushed_blocks; + std::int32_t available_cached_blocks; + std::int32_t allocated_flushed_blocks; + std::int32_t allocated_cached_blocks; +}; + +struct VirtualQueryInfo { + std::uintptr_t start; + std::uintptr_t end; + std::uint64_t offset; + std::int32_t protection; + std::int32_t memory_type; + std::uint32_t is_flexible : 1; + std::uint32_t is_direct : 1; + std::uint32_t is_stack : 1; + std::uint32_t is_pooled : 1; + std::uint32_t is_committed : 1; + std::uint32_t is_gpu_prt : 1; + std::uint32_t amm_usage : 1; + std::uint32_t reserved : 1; + char name[32]; + std::uint8_t gpu_mask_id; + std::uint8_t reserved2; +}; + +struct KernelSemaPrivate; +struct KernelEventFlagPrivate; +struct PthreadAttrPrivate; +struct PthreadPrivate; +struct PthreadMutexPrivate; +struct PthreadMutexattrPrivate; +struct PthreadRwlockPrivate; +struct PthreadRwlockattrPrivate; +struct PthreadCondattrPrivate; +struct PthreadCondPrivate; + +using KernelSema = KernelSemaPrivate*; +using KernelEventFlag = KernelEventFlagPrivate*; +using Pthread = PthreadPrivate*; +using PthreadAttr = PthreadAttrPrivate*; +using PthreadMutex = PthreadMutexPrivate*; +using PthreadMutexattr = PthreadMutexattrPrivate*; +using PthreadRwlock = PthreadRwlockPrivate*; +using PthreadRwlockattr = PthreadRwlockattrPrivate*; +using PthreadCond = PthreadCondPrivate*; +using PthreadCondattr = PthreadCondattrPrivate*; +using PthreadKey = int; + +struct FileStat { + std::uint32_t st_dev; + std::uint32_t st_ino; + std::uint16_t st_mode; + std::uint16_t st_nlink; + std::uint32_t st_uid; + std::uint32_t st_gid; + std::uint32_t st_rdev; + KernelTimespec st_atim; + KernelTimespec st_mtim; + KernelTimespec st_ctim; + std::int64_t st_size; + std::int64_t st_blocks; + std::uint32_t st_blksize; + std::uint32_t st_flags; + std::uint32_t st_gen; + std::int32_t st_lspare; + KernelTimespec st_birthtim; +}; + +struct ModuleInfo { + std::uint64_t size; + std::uint64_t info[32]; + KernelModule handle; + std::uint8_t pad[156]; +}; + +struct ModuleInfoForUnwind { + std::uint64_t st_size; + char name[256]; + std::uint64_t eh_frame_hdr_addr; + std::uint64_t eh_frame_addr; + std::uint64_t eh_frame_size; + std::uint64_t seg0_addr; + std::uint64_t seg0_size; +}; + +struct MallocReplace { + std::uint64_t size = sizeof(MallocReplace); + void* malloc_initialize = nullptr; + void* malloc_finalize = nullptr; + void* malloc = nullptr; + void* free = nullptr; + void* calloc = nullptr; + void* realloc = nullptr; + void* memalign = nullptr; + void* reallocalign = nullptr; + void* posix_memalign = nullptr; + void* malloc_stats = nullptr; + void* malloc_stats_fast = nullptr; + void* malloc_usable_size = nullptr; + void* aligned_alloc = nullptr; +}; + +struct NewReplace { + std::uint64_t size = sizeof(NewReplace); + void* new_p = nullptr; + void* new_nothrow = nullptr; + void* new_array = nullptr; + void* new_array_nothrow = nullptr; + void* delete_p = nullptr; + void* delete_nothrow = nullptr; + void* delete_array = nullptr; + void* delete_array_nothrow = nullptr; + void* delete_with_size = nullptr; + void* delete_with_size_nothrow = nullptr; + void* delete_array_with_size = nullptr; + void* delete_array_with_size_nothrow = nullptr; +}; + +#pragma pack(push, 1) +struct VaList { + std::uint32_t gp_offset; + std::uint32_t fp_offset; + void* overflow_arg_area; + void* reg_save_area; +}; +#pragma pack(pop) + +using FiberEntry = void* (*)(std::uint64_t, void*); + +struct FiberOptParam { + std::uint32_t magic; +}; + +struct FiberCpuContext { + std::uint64_t rip; + std::uint64_t rsp; + std::uint64_t rbp; + std::uint64_t rbx; + std::uint64_t r12; + std::uint64_t r13; + std::uint64_t r14; + std::uint64_t r15; +}; + +constexpr std::uint32_t FIBER_MAX_NAME_LENGTH = 31; + +struct FiberObject { + std::uint32_t magic_start; + std::uint32_t state; + FiberEntry entry; + std::uint64_t arg_on_initialize; + void* addr_context; + std::uint64_t size_context; + char name[FIBER_MAX_NAME_LENGTH + 1]; + void* context; + std::uint32_t flags; + std::uint32_t padding; + void* context_start; + void* context_end; + FiberCpuContext saved_context; + std::uint64_t arg_on_run; + std::uint64_t arg_on_return; + bool context_valid; + std::uint32_t magic_end; +}; + +struct FiberInfo { + std::uint64_t size; + FiberEntry entry; + std::uint64_t arg_on_initialize; + void* addr_context; + std::uint64_t size_context; + char name[FIBER_MAX_NAME_LENGTH + 1]; + std::uint64_t size_context_margin; + std::uint8_t padding[48]; +}; + +struct RtcDateTime { + std::uint16_t year; + std::uint16_t month; + std::uint16_t day; + std::uint16_t hour; + std::uint16_t minute; + std::uint16_t second; + std::uint32_t microsecond; +}; + +struct RtcTick { + std::uint64_t tick; +}; + +struct CommandBuffer { + std::uint8_t opaque[256]; +}; + +struct Label { + volatile std::uint64_t value; +}; + +struct Shader { + std::uint8_t opaque[128]; +}; + +struct ShaderRegister { + std::uint32_t offset; + std::uint32_t value; +}; + +struct ShareCurrentRecordingStatus { + std::uint32_t recording_2k_status; + std::uint32_t recording_4k_status; + std::uint8_t reserved[8]; +}; + +union ShareCurrentStatus { + ShareCurrentRecordingStatus recording_status; + std::uint8_t reserved[16]; +}; + +using AcmContextId = std::uint32_t; +using AcmBatchId = std::uint32_t; + +struct AcmBatchError { + std::uint8_t opaque[64]; +}; + +struct AcmBatchInfo { + std::uint8_t opaque[64]; +}; + +struct AjmBatchError { + std::uint8_t opaque[64]; +}; + +struct AjmBatchInfo { + std::uint8_t opaque[128]; +}; + +struct AjmBuffer { + void* ptr; + std::size_t size; +}; + +struct AjmDecAt9ConfigDataInfo { + std::uint32_t channels; + std::uint32_t sample_rate; + std::uint32_t frame_samples_per_channel; + std::uint32_t superframe_samples_per_channel; + std::uint32_t superframe_size; +}; + +using AudioOut2ContextHandle = std::uint64_t; +using AudioOut2PortHandle = std::uint64_t; +using AudioOut2UserHandle = std::uintptr_t; +using AudioOut2SpeakerArrayHandle = void*; + +struct AudioOut2ContextParam { std::uint8_t opaque[128]; }; +struct AudioOut2PortParam { std::uint8_t opaque[128]; }; +struct AudioOut2Attribute { std::uint8_t opaque[64]; }; +struct AudioOut2PortState { std::uint8_t opaque[64]; }; +struct AudioOut2SystemState { std::uint8_t opaque[64]; }; +struct AudioOut2Position { float x; float y; float z; }; +struct AudioOut2SpeakerInfo { std::uint8_t opaque[256]; }; +struct AudioOut2SystemDebugStateParam { std::uint8_t opaque[64]; }; +struct AudioOut2MasteringParamsHeader { std::uint8_t opaque[128]; }; +struct AudioOut2MasteringStatesHeader { std::uint8_t opaque[128]; }; + +struct AudioOutOutputParam { + int handle; + const void* ptr; +}; + +struct AudioOutPortState { + std::uint16_t output; + std::uint8_t channel; + std::uint8_t reserved[1]; + std::int16_t volume; + std::uint16_t rerouteCounter; + std::uint64_t flag; + std::uint64_t activeState; +}; + +struct Audio3dOpenParameters { std::uint8_t opaque[256]; }; + +using AudioPropagationHandle = std::uint64_t; + +struct AudioPropagationStructDescriptor { + std::uint32_t id; + std::size_t size; +}; + +struct AudioPropagationSystemMemory { + AudioPropagationStructDescriptor desc; + void* p_cpu_mem; + std::size_t size_cpu_mem; + void* p_gpu_mem; + std::size_t size_gpu_mem; +}; + +struct Ngs2SystemOption { std::uint8_t opaque[128]; }; +struct Ngs2SystemInfo { std::uint8_t opaque[128]; }; +struct Ngs2RackOption { std::uint8_t opaque[128]; }; +struct Ngs2BufferAllocator { std::uint8_t opaque[64]; }; +struct Ngs2VoiceParamHeader { std::uint8_t opaque[64]; }; +struct Ngs2RenderBufferInfo { std::uint8_t opaque[64]; }; +struct Ngs2ContextBufferInfo { std::uint8_t opaque[64]; }; +struct Ngs2VoiceState { std::uint8_t opaque[128]; }; +struct Ngs2WaveformFormat { std::uint8_t opaque[64]; }; +struct Ngs2WaveformBlock { std::uint8_t opaque[64]; }; +struct Ngs2WaveformInfo { std::uint8_t opaque[128]; }; +struct Ngs2PanWork { std::uint8_t opaque[256]; }; +struct Ngs2PanParam { std::uint8_t opaque[64]; }; +struct Ngs2GeomListenerParam { std::uint8_t opaque[128]; }; +struct Ngs2GeomListenerWork { std::uint8_t opaque[256]; }; +struct Ngs2GeomSourceParam { std::uint8_t opaque[128]; }; +struct Ngs2GeomAttribute { std::uint8_t opaque[128]; }; + +struct AvPlayerInitData { std::uint8_t opaque[256]; }; +struct AvPlayerFrameInfoEx { std::uint8_t opaque[256]; }; +struct AvPlayerFrameInfo { std::uint8_t opaque[256]; }; +struct AvPlayerInternal { std::uint8_t opaque[1]; }; + +struct AudiodecAuInfo { std::uint8_t opaque[64]; }; +struct AudiodecPcmItem { std::uint8_t opaque[64]; }; + +struct AudiodecCtrl { + void* pParam; + void* pBsiInfo; + AudiodecAuInfo* pAuInfo; + AudiodecPcmItem* pPcmItem; +}; + +struct VoiceInitParam { + std::int32_t app_type; + std::uint64_t on_event; + void* user_data; + std::uint8_t reserved[32 - sizeof(std::int32_t) - sizeof(std::uint64_t) - sizeof(void*)]; +}; + +struct VoicePortParam { + std::int32_t port_type; + std::uint16_t threshold; + std::uint16_t mute; + float volume; + union { + struct { std::int32_t bitrate; } voice; + struct { std::uint32_t buffer_size; std::int32_t data_type; std::int32_t sample_rate; } pcmaudio; + struct { std::int32_t user_id; std::int32_t type; std::int32_t index; } device; + }; +}; + +struct VoicePortInfo { + std::int32_t port_type; + std::int32_t state; + std::uint32_t* edge; + std::uint32_t byte_count; + std::uint32_t frame_size; + std::uint16_t edge_count; + std::uint16_t reserved; +}; + +struct VoiceStartParam { + void* container; + std::uint32_t mem_size; + std::uint8_t reserved[32 - sizeof(void*) - sizeof(std::uint32_t)]; +}; + +struct PadControllerInformation { std::uint8_t opaque[136]; }; +struct PadVibrationParam { std::uint8_t large_motor; std::uint8_t small_motor; }; +struct PadLightBarParam { std::uint8_t r; std::uint8_t g; std::uint8_t b; }; +struct PadDeviceClassData { std::uint8_t opaque[64]; }; +struct PadDeviceClassExtendedInformation { std::uint8_t opaque[64]; }; +struct PadTriggerEffectStateInformation { std::uint8_t opaque[64]; }; + +struct PadData { + std::uint32_t buttons; + std::uint8_t left_stick_x; + std::uint8_t left_stick_y; + std::uint8_t right_stick_x; + std::uint8_t right_stick_y; + std::uint8_t analog_buttons_l2; + std::uint8_t analog_buttons_r2; + std::uint8_t padding[2]; + float orientation_x; + float orientation_y; + float orientation_z; + float orientation_w; + float acceleration_x; + float acceleration_y; + float acceleration_z; + float angular_velocity_x; + float angular_velocity_y; + float angular_velocity_z; + std::uint8_t touch_data_touch_num; + std::uint8_t touch_data_reserve[3]; + std::uint32_t touch_data_reserve1; + std::uint16_t touch_data_touch0_x; + std::uint16_t touch_data_touch0_y; + std::uint8_t touch_data_touch0_id; + std::uint8_t touch_data_touch0_reserve[3]; + std::uint16_t touch_data_touch1_x; + std::uint16_t touch_data_touch1_y; + std::uint8_t touch_data_touch1_id; + std::uint8_t touch_data_touch1_reserve[3]; + bool connected; + std::uint64_t timestamp; + std::uint32_t extension_unit_data_extension_unit_id; + std::uint8_t extension_unit_data_reserve[1]; + std::uint8_t extension_unit_data_data_length; + std::uint8_t extension_unit_data_data[10]; + std::uint8_t connected_count; + std::uint8_t reserve[2]; + std::uint8_t device_unique_data_len; + std::uint8_t device_unique_data[12]; +}; + +struct MouseData { + std::uint64_t timestamp; + bool connected; + std::uint8_t padding[3]; + std::uint32_t buttons; + std::int32_t x_axis; + std::int32_t y_axis; + std::int32_t wheel; + std::int32_t tilt; + std::uint8_t reserved[8]; +}; + +constexpr std::uint32_t KEYBOARD_MAX_KEYCODES = 6; + +struct KeyboardData { + std::uint64_t timestamp; + bool intercepted; + std::uint8_t reserve1[7]; + bool connected; + std::int32_t length; + std::uint32_t led; + std::uint32_t modifier_key; + std::uint16_t key_code[KEYBOARD_MAX_KEYCODES]; + std::uint8_t reserve2[32]; +}; + +struct KeyboardCharData { + bool processed; + std::int32_t length; + std::uint16_t char_code; + std::uint8_t reserve[8]; +}; + +struct ImeColor { + std::uint8_t r; + std::uint8_t g; + std::uint8_t b; + std::uint8_t a; +}; + +struct ImeKeycode { + std::uint16_t keycode; + char16_t character; + std::uint32_t status; + std::uint32_t type; + std::int32_t user_id; + std::uint32_t resource_id; + std::uint64_t timestamp; +}; + +using ImeTextFilter = std::int32_t (*)(char16_t* out_text, std::uint32_t* out_text_length, const char16_t* source_text, std::uint32_t source_text_length); +using ImeExtKeyboardFilter = int (*)(const ImeKeycode* source_keycode, std::uint16_t* out_keycode, std::uint32_t* out_status, void* reserved); + +struct ImeExtendedParam { + std::uint32_t option; + ImeColor color_base; + ImeColor color_line; + ImeColor color_text_field; + ImeColor color_preedit; + ImeColor color_button_default; + ImeColor color_button_function; + ImeColor color_button_symbol; + ImeColor color_text; + ImeColor color_special; + std::uint32_t priority; + const char* additional_dictionary_path; + ImeExtKeyboardFilter ext_keyboard_filter; + std::uint32_t disable_device; + std::uint32_t ext_keyboard_mode; + std::int8_t reserved[60]; +}; + +using ExtendedParam = ImeExtendedParam; + +struct ImeCaret { + float x; + float y; + std::uint32_t height; + std::uint32_t index; +}; + +using Caret = ImeCaret; + +struct ImeTextGeometry { + float x; + float y; + std::uint32_t width; + std::uint32_t height; +}; + +using TextGeometry = ImeTextGeometry; + +struct ImeRect { + float x; + float y; + std::uint32_t width; + std::uint32_t height; +}; + +enum class TextAreaMode : std::uint32_t { Disable = 0, Edit = 1, Preedit = 2, Select = 3 }; + +struct ImeTextAreaProperty { + TextAreaMode mode; + std::uint32_t index; + std::int32_t length; +}; + +struct ImeEditText { + char16_t* str; + std::uint32_t caret_index; + std::uint32_t area_num; + ImeTextAreaProperty text_area[4]; +}; + +struct KeyboardResourceIdArray { + std::int32_t user_id; + std::uint32_t resource_id[5]; +}; + +union ImeEventParam { + ImeRect rect; + ImeEditText text; + std::uint32_t caret_move; + ImeKeycode keycode; + KeyboardResourceIdArray resource_id_array; + std::uint64_t reserved[8]; +}; + +struct ImeEvent { + std::uint32_t id; + ImeEventParam param; +}; + +using EventHandler = void (*)(void* arg, const ImeEvent* event); + +struct Param { + std::int32_t user_id; + std::uint32_t type; + std::uint64_t supported_languages; + std::uint32_t enter_label; + std::uint32_t input_method; + ImeTextFilter filter; + std::uint32_t option; + std::uint32_t max_text_length; + char16_t* input_text_buffer; + float posx; + float posy; + std::uint32_t horizontal_alignment; + std::uint32_t vertical_alignment; + void* work; + void* arg; + EventHandler handler; + std::int8_t reserved[8]; +}; + +struct KeyboardParam { + std::uint32_t option; + std::int8_t reserved1[4]; + void* arg; + EventHandler handler; + std::int8_t reserved2[8]; +}; + +struct KeyboardInfo { + std::int32_t user_id; + std::uint32_t device; + std::uint32_t type; + std::uint32_t repeat_delay; + std::uint32_t repeat_rate; + std::uint32_t status; + std::int8_t reserved[12]; +}; + +struct ImeDialogResult { + std::uint32_t endstatus; + std::int8_t reserved[12]; +}; + +using Result = ImeDialogResult; + +struct PositionAndForm { + std::uint32_t type; + float posx; + float posy; + std::uint32_t horizontal_alignment; + std::uint32_t vertical_alignment; + std::uint32_t width; + std::uint32_t height; +}; + +using FontHandle = void*; +using FontLibrary = void*; +using FontLibrarySelection = void*; +using FontRenderer = void*; +using FontRendererSelection = void*; + +using FontMemoryDestroyCallback = void (*)(void*); + +struct FontMemoryInterface { + void* (*malloc_func)(std::size_t); + void (*free_func)(void*); +}; + +struct FontMemory { + std::uint16_t type; + std::uint16_t attr; + std::uint32_t size; + void* address; + void* mspace_object; + const FontMemoryInterface* mem_interface; + FontMemoryDestroyCallback destroy_callback; + void* destroy_object; + void* user_object; + void* parent_object; +}; + +struct FontOpenDetail { std::uint8_t opaque[64]; }; +struct FontHorizontalLayout { std::uint8_t opaque[64]; }; +struct FontVerticalLayout { std::uint8_t opaque[64]; }; +struct FontGlyphMetrics { std::uint8_t opaque[128]; }; +struct FontRenderSurface { std::uint8_t opaque[128]; }; +struct FontRenderCharacter { std::uint8_t opaque[128]; }; +struct FontRenderResult { std::uint8_t opaque[64]; }; +struct FontCreateStringDetail { std::uint8_t opaque[64]; }; +struct FontGenerateGlyphDetail { std::uint8_t opaque[64]; }; +struct FontString { std::uint8_t opaque[256]; }; +struct FontWriting { std::uint8_t opaque[256]; }; +struct FontWritingMetrics { std::uint8_t opaque[128]; }; +struct FontWritingStep { std::uint8_t opaque[64]; }; +struct FontWritingLine { std::uint8_t opaque[128]; }; +struct FontWritingLineStep { std::uint8_t opaque[64]; }; +struct FontTextSource { std::uint8_t opaque[256]; }; +struct FontTextCharacter { std::uint8_t opaque[64]; }; +struct FontTextCodes { std::uint8_t opaque[64]; }; + +using FontTextParseFunction = int (*)(void*, std::uint32_t, void*); + +struct NetEtherAddr { std::uint8_t data[6]; }; + +union NetEpollData { + void* ptr; + std::uint32_t u32; + int fd; + std::uint64_t u64; +}; + +struct NetEpollEvent { + std::uint32_t events; + std::uint32_t reserved; + std::uint64_t ident; + NetEpollData data; +}; + +struct NetCtlNatInfo { std::uint8_t opaque[128]; }; + +union NetCtlInfo { std::uint8_t opaque[256]; }; + +using NetCtlCallback = void (*)(int, void*); + +struct HttpEpoll {}; +using HttpEpollHandle = HttpEpoll*; +using HttpsCallback = int (*)(int, unsigned int, void* const*, int, void*); + +struct HttpNBEvent { std::uint8_t opaque[64]; }; + +struct SceHttpUriElement { + int opaque = 0; + char* scheme = nullptr; + char* username = nullptr; + char* password = nullptr; + char* hostname = nullptr; + char* path = nullptr; + char* query = nullptr; + char* fragment = nullptr; + std::uint16_t port = 0; + std::uint8_t reserved[10]{}; +}; + +struct Http2AsyncResult { + int event_type; + int req_id; + int result; + std::uint8_t padding[4]; + void* reserved; +}; + +struct NpTitleId { char data[13]; char pad[3]; }; +struct NpTitleSecret { std::uint8_t data[128]; }; +struct NpContentRestriction { std::uint8_t opaque[128]; }; +struct NpOnlineId { char data[17]; char pad[3]; }; +struct NpId { NpOnlineId online_id; std::uint8_t opaque[4]; }; +struct NpCreateAsyncRequestParameter { std::uint8_t opaque[64]; }; +struct NpCheckPremiumParameter { std::uint8_t opaque[64]; }; +struct NpCheckPremiumResult { std::uint8_t opaque[64]; }; + +struct NpUnifiedEntitlementLabel { + char data[17]; + char padding[3]; +}; + +struct NpEntitlementAccessInitParam { char reserved[32]; }; +struct NpEntitlementAccessBootParam { char reserved[32]; }; + +struct NpEntitlementAccessAddcontEntitlementInfo { + NpUnifiedEntitlementLabel entitlement_label; + std::uint32_t package_type; + std::uint32_t download_status; +}; + +struct NpTrophy2Progress { std::uint32_t value; }; + +struct NpTrophy2GameDetails { + std::uint32_t num_groups; + std::uint32_t num_trophies; + std::uint32_t num_platinum; + std::uint32_t num_gold; + std::uint32_t num_silver; + std::uint32_t num_bronze; + char title[128]; +}; + +struct NpTrophy2GameData { + std::uint32_t unlocked_trophies; + std::uint32_t unlocked_platinum; + std::uint32_t unlocked_gold; + std::uint32_t unlocked_silver; + std::uint32_t unlocked_bronze; + std::uint32_t progress_percentage; +}; + +struct NpTrophy2GroupDetails { + std::int32_t group_id; + std::uint32_t num_trophies; + std::uint32_t num_platinum; + std::uint32_t num_gold; + std::uint32_t num_silver; + std::uint32_t num_bronze; + char title[128]; +}; + +struct NpTrophy2GroupData { + std::int32_t group_id; + std::uint32_t unlocked_trophies; + std::uint32_t unlocked_platinum; + std::uint32_t unlocked_gold; + std::uint32_t unlocked_silver; + std::uint32_t unlocked_bronze; + std::uint32_t progress_percentage; + std::uint8_t reserved[4]; +}; + +struct NpTrophy2Details { + std::int32_t trophy_id; + std::int32_t trophy_grade; + std::int32_t group_id; + bool hidden; + bool has_reward; + std::uint8_t reserved2[2]; + NpTrophy2Progress target; + char name[128]; + char description[1024]; + char reward[128]; +}; + +struct NpTrophy2Data { + std::int32_t trophy_id; + bool unlocked; + std::uint8_t reserved[3]; + NpTrophy2Progress progress; + std::uint64_t timestamp_tick; +}; + +struct NpUniversalDataSystemInitParam { + std::size_t size; + std::size_t pool_size; +}; + +struct NpUniversalDataSystemMemoryStat { + std::size_t pool_size; + std::size_t max_inuse_size; + std::size_t current_inuse_size; +}; + +struct NpUniversalDataSystemEvent {}; +struct NpUniversalDataSystemEventPropertyObject {}; +struct NpUniversalDataSystemEventPropertyArray {}; + +struct NpUniversalDataSystemStorageStat { + std::size_t in_events; + std::size_t out_events; + std::size_t lost_events; + std::size_t max_inuse_size; + std::size_t current_events; + std::size_t current_inuse_size; + std::size_t current_free_size; +}; + +constexpr std::uint32_t NP_GAME_INTENT_DATA_MAX_SIZE = 1024; +constexpr std::uint32_t NP_GAME_INTENT_TYPE_MAX_SIZE = 64; + +struct NpGameIntentData { + std::uint8_t data[NP_GAME_INTENT_DATA_MAX_SIZE]; + std::uint8_t padding[7]; +}; + +struct NpGameIntentInfo { + std::size_t size; + std::int32_t user_id; + char intent_type[NP_GAME_INTENT_TYPE_MAX_SIZE]; + std::uint8_t padding[7]; + std::uint8_t reserved[256]; + NpGameIntentData intent_data; +}; + +struct NpWebApi2ResponseInformationOption { + std::int32_t http_status; + char* error_object; + std::size_t error_object_size; + std::size_t response_data_size; +}; + +struct GameUpdateCheckParam { + std::size_t size; + std::uint32_t option; + std::uint32_t reserved[9]; +}; + +struct GameUpdateCheckResult { + std::size_t size; + bool found; + bool addcont_found; + char padding[2]; + char content_version[11]; + char padding2[1]; + std::uint32_t reserved[6]; +}; + +struct GameUpdateAddcontVersionInfo { + std::size_t size; + bool found; + char content_version[11]; + std::uint32_t reserved[6]; +}; + +struct SaveDataMountPoint { char data[16]; }; + +struct SaveDataParam { + char title[128]; + char sub_title[128]; + char detail[1024]; + std::uint32_t user_param; + int pad; + std::int64_t mtime; + std::uint8_t reserved[32]; +}; + +struct SaveDataIcon { + void* buf; + std::size_t buf_size; + std::size_t data_size; + std::uint8_t reserved[32]; +}; + +struct SaveDataMountResult { + SaveDataMountPoint mount_point; + std::uint64_t required_blocks; + std::uint32_t unused; + std::uint32_t mount_status; + std::uint8_t reserved[28]; + int pad; +}; + +struct SaveDataMountInfo { + std::uint64_t blocks; + std::uint64_t free_blocks; + std::uint8_t reserved[32]; +}; + +struct SceSaveDataTitleId { char data[10]; char pad[2]; }; +struct SceSaveDataDirName { char data[33]; char pad[3]; }; +struct SaveDataSearchInfo { std::uint8_t opaque[128]; }; +struct SaveDataMemoryData { void* buf; std::size_t buf_size; std::size_t offset; }; + +struct SaveDataMount3 { + int user_id; + int pad; + const SceSaveDataDirName* dir_name; + std::uint64_t blocks; + std::uint64_t system_blocks; + std::uint32_t mount_mode; + int pad2; + std::int32_t resource; + std::uint8_t reserved[32]; +}; + +struct SaveDataDirNameSearchCond { + std::int32_t user_id; + std::int32_t pad; + const SceSaveDataTitleId* title_id; + const SceSaveDataDirName* dir_name; + std::uint32_t key; + std::uint32_t order; + std::uint8_t reserved[32]; +}; + +struct SaveDataDirNameSearchResult { + std::uint32_t hit_num; + std::int32_t pad; + SceSaveDataDirName* dir_names; + std::uint32_t dir_names_num; + std::uint32_t set_num; + SaveDataParam* params; + SaveDataSearchInfo* infos; + std::uint8_t reserved[12]; + std::int32_t pad2; +}; + +struct SaveDataMemoryGet2 { + std::int32_t user_id; + std::uint8_t padding[4]; + SaveDataMemoryData* data; + SaveDataParam* param; + SaveDataIcon* icon; + std::uint32_t slot_id; + std::uint8_t reserved[28]; +}; + +struct SaveDataMemorySetup2 { + std::uint32_t option; + std::int32_t user_id; + std::size_t memory_size; + std::size_t icon_memory_size; + const SaveDataParam* init_param; + const SaveDataIcon* init_icon; + std::uint32_t slot_id; + std::uint8_t reserved[20]; +}; + +struct SaveDataMemorySetupResult { + std::size_t existed_memory_size; + std::uint8_t reserved[16]; +}; + +struct SaveDataMemorySet2 { + std::int32_t user_id; + std::uint8_t padding[4]; + const SaveDataMemoryData* data; + const SaveDataParam* param; + const SaveDataIcon* icon; + std::uint32_t data_num; + std::uint32_t slot_id; + std::uint8_t reserved[24]; +}; + +struct SaveDataTransferringMount { + std::int32_t user_id; + const SceSaveDataTitleId* title_id; + const SceSaveDataDirName* dir_name; + const void* fingerprint; + std::uint8_t reserved[32]; +}; + +struct SaveDataPrepareParam { + std::int32_t resource; + std::uint32_t prepare_mode; + std::uint8_t reserved[32]; +}; + +struct SaveDataCommitParam { + std::int32_t resource; + std::uint32_t commit_mode; + std::uint8_t reserved[32]; +}; + +struct SaveDataDelete { + std::int32_t user_id; + std::int32_t pad; + const SceSaveDataTitleId* title_id; + const SceSaveDataDirName* dir_name; + std::uint32_t unused; + std::uint8_t reserved[32]; + std::int32_t pad2; +}; + +struct SaveDataEvent { + std::uint32_t type; + std::int32_t error_code; + std::int32_t user_id; + std::uint8_t padding[4]; + SceSaveDataTitleId title_id; + SceSaveDataDirName dir_name; + std::uint8_t reserved[40]; +}; + +struct SaveDataBackup { + std::int32_t user_id; + std::int32_t pad; + const SceSaveDataTitleId* title_id; + const SceSaveDataDirName* dir_name; + const void* fingerprint; + std::uint8_t reserved[32]; +}; + +struct AppContentInitParam { char reserved[32]; }; + +struct AppContentBootParam { + char reserved1[4]; + std::uint32_t attr; + char reserved2[32]; +}; + +struct AppContentMountPoint { char data[16]; }; + +struct ContentExportInitParam2 { + void* malloc_func; + void* free_func; + void* user_data; + std::size_t buffer_size; + std::int64_t reserved0; + std::int64_t reserved1; +}; + +struct ContentSearchInitParam { std::size_t memory_size; }; + +struct ContentDeleteInitParam { + char reserved1[4]; + std::size_t heap_size; + char reserved2[32]; +}; + +struct PngDecCreateParam { + std::uint32_t this_size; + std::uint32_t attribute; + std::uint32_t max_image_width; +}; + +struct PngDecParseParam { + const void* png_mem_addr; + std::uint32_t png_mem_size; + std::uint32_t reserved0; +}; + +struct PngDecDecodeParam { + const void* png_mem_addr; + void* image_mem_addr; + std::uint32_t png_mem_size; + std::uint32_t image_mem_size; + std::uint16_t pixel_format; + std::uint16_t alpha_value; + std::uint32_t image_pitch; +}; + +struct PngDecImageInfo { + std::uint32_t image_width; + std::uint32_t image_height; + std::uint16_t color_space; + std::uint16_t bit_depth; + std::uint32_t image_flag; +}; + +struct PlayGoInitParams { + const void* buf_addr; + std::uint32_t buf_size; + std::uint32_t reserved; +}; + +struct PlayGoToDo { + std::uint16_t chunk_id; + std::int8_t locus; + std::int8_t reserved; +}; + +struct PlayGoProgress { + std::uint64_t progress_size; + std::uint64_t total_size; +}; + +union PlayGoOptionalChunk { + std::uint64_t bitmask; + std::uint64_t languages; + std::uint64_t scenarios; +}; + +using RudpEventHandler = void (*)(int ctx_id, int event_id, int error_code, void* arg); + +struct SystemServiceStatus { + std::int32_t event_num = 0; + bool is_system_ui_overlaid = false; + bool is_in_background_execution = false; + bool is_vr_play_area_overlaid = false; + std::uint8_t reserved[127] = {}; +}; + +struct SystemServiceEvent { + std::int32_t event_type; + std::uint8_t data[8192]; +}; + +struct SystemServiceDisplaySafeAreaInfo { + float ratio; + std::uint8_t reserved[128]; +}; + +struct SystemServiceHdrToneMapLuminance { + float max_full_frame_tone_map_luminance; + float max_tone_map_luminance; + float min_tone_map_luminance; +}; + +struct SystemGestureVector2 { float x; float y; }; + +struct SystemGesturePrimitiveTouchEvent { + std::int32_t event_state; + std::uint16_t primitive_id; + std::uint8_t is_updated; + std::uint8_t reserved0; + SystemGestureVector2 pressed_position; + SystemGestureVector2 current_position; + SystemGestureVector2 delta_vector; + std::uint64_t delta_time; + std::uint64_t elapsed_time; + std::uint8_t reserve[32]; +}; + +struct SystemGestureRectangle { + float x; + float y; + float width; + float height; + std::uint8_t reserve[8]; +}; + +struct SystemGestureTouchRecognizer { std::uint64_t reserve[361]; }; + +struct SystemGestureTouchRecognizerInformation { + std::int32_t gesture_type; + SystemGestureRectangle rectangle; + std::uint64_t updated_time; + std::uint8_t reserve[256]; +}; + +struct SystemGestureTouchEvent { std::uint8_t reserve[168]; }; + +struct UserServiceLoginUserIdList { int user_id[4]; }; + +struct SceUserServiceEvent { + std::uint32_t event_type; + int user_id; +}; + +struct UserServiceGamePresets { + std::size_t this_size; + std::uint32_t difficulty; + std::uint32_t priority; + std::uint32_t invert_vertical_view_for_1st_person_view; + std::uint32_t invert_horizontal_view_for_1st_person_view; + std::uint32_t invert_vertical_view_for_3rd_person_view; + std::uint32_t invert_horizontal_view_for_3rd_person_view; + std::uint32_t display_sub_titles; + std::uint32_t audio_language; +}; + +struct UltMutexOptParam { + std::uint32_t reserved_header[2]; + std::uint32_t attribute; + std::uint32_t reserved0; +}; + +struct UltUlthreadRuntimeOptParam { std::uint8_t bytes[128]; }; + +using UltUlthreadEntry = std::int32_t (*)(std::uint64_t); + +struct VideoOutBufferAttribute2 { + std::uint32_t reserved0; + std::uint32_t tiling_mode; + std::uint32_t aspect_ratio; + std::uint32_t width; + std::uint32_t height; + std::uint32_t pitch_in_pixel; + std::uint64_t option; + std::uint64_t pixel_format; + std::uint64_t dcc_cb_register_clear_color; + std::uint32_t dcc_control; + std::uint32_t pad0; + std::uint64_t reserved1[3]; +}; + +struct VideoOutBuffers { + const void* data; + const void* metadata; + const void* reserved[2]; +}; + +struct VideoOutFlipStatus { + std::uint64_t count = 0; + std::uint64_t processTime = 0; + std::uint64_t reserved0 = 0; + std::int64_t flipArg = 0; + std::uint64_t reserved1 = 0; + std::uint64_t processTimeCounter = 0; + std::int32_t gcQueueNum = 0; + std::int32_t flipPendingNum = 0; + std::int32_t currentBuffer = 0; + std::uint32_t reserved2 = 0; + std::uint64_t submitProcessTimeCounter = 0; + std::uint64_t reserved3[7] = {}; +}; + +struct VideoOutVblankStatus { + std::uint64_t count = 0; + std::uint64_t processTime = 0; + std::uint64_t reserved = 0; + std::uint64_t processTimeCounter = 0; + std::uint8_t flags = 0; + std::uint8_t phase = 0; + std::uint8_t pad1[6] = {}; +}; + +struct VideoOutOutputStatus { + std::uint32_t resolution = 0; + std::uint32_t dynamicRange = 0; + std::uint64_t refreshRate = 0; + std::uint64_t flags = 0; + std::uint64_t reserved[3] = {}; +}; + +struct VideoOutOutputOptions { std::uint32_t internalData[16] = {}; }; + + +using atexit_func_t = void (*)(); + +struct InitEnvParams { + int argc; + std::uint32_t pad; + const char* argv[3]; +}; + +struct LibcHeapInfo { + std::uint64_t size; + std::uint32_t unknown1; + std::uint32_t unknown2; + std::uint64_t* mspace_atomic_id_mask; + std::uint64_t* mstate_table; +}; + +using Info = LibcHeapInfo; + +#define VA_ARGS \ + std::uint64_t rdi, std::uint64_t rsi, std::uint64_t rdx, std::uint64_t rcx, \ + std::uint64_t r8, std::uint64_t r9, std::uint64_t overflow_arg_area, \ + __m128 xmm0, __m128 xmm1, __m128 xmm2, __m128 xmm3, \ + __m128 xmm4, __m128 xmm5, __m128 xmm6, __m128 xmm7, ... + +struct Packet { + std::uint32_t* addr; + std::uint32_t dw_num; + std::uint8_t flags; + std::uint8_t reserved[3]; +}; + +#endif diff --git a/core/libs/prx/CMakeLists.txt b/core/libs/prx/CMakeLists.txt new file mode 100644 index 000000000..f31ca0f04 --- /dev/null +++ b/core/libs/prx/CMakeLists.txt @@ -0,0 +1,40 @@ +add_executable(nid_patcher + ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/Sha1.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/NidCompute.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/nid/src/main.cpp +) +target_include_directories(nid_patcher PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/nid/include) +target_compile_features(nid_patcher PRIVATE cxx_std_20) + +file(GLOB LIBS_DIRS LIST_DIRECTORIES true ${CMAKE_CURRENT_SOURCE_DIR}/lib*) + +set(PATCHED_STAMPS) + +foreach(LIB_DIR ${LIBS_DIRS}) + if(IS_DIRECTORY ${LIB_DIR}) + get_filename_component(LIB_NAME ${LIB_DIR} NAME) + + add_library(${LIB_NAME} SHARED EXCLUDE_FROM_ALL ${LIB_DIR}/Export.cpp) + set_target_properties(${LIB_NAME} PROPERTIES + PREFIX "" + SUFFIX .rpx + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs + ) + + set(RPX_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.prx) + set(STAMP_FILE ${CMAKE_CURRENT_BINARY_DIR}/libs/${LIB_NAME}.patched) + + add_custom_command( + OUTPUT ${STAMP_FILE} + COMMAND $ ${LIB_NAME} ${RPX_FILE} + COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_FILE} + DEPENDS nid_patcher ${LIB_NAME} + COMMENT "Patching NIDs for ${LIB_NAME}" + ) + + list(APPEND PATCHED_STAMPS ${STAMP_FILE}) + endif() +endforeach() + +add_custom_target(libs DEPENDS ${PATCHED_STAMPS}) diff --git a/core/libs/prx/libReactNative.Modules.Vsh.WebAppLauncher/Export.cpp b/core/libs/prx/libReactNative.Modules.Vsh.WebAppLauncher/Export.cpp new file mode 100644 index 000000000..642996310 --- /dev/null +++ b/core/libs/prx/libReactNative.Modules.Vsh.WebAppLauncher/Export.cpp @@ -0,0 +1,46 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int ErrorDialogClose(void) { + return 0; +} + +int ErrorDialogOpen(const void* param) { + (void)param; + return 0; +} + +int ShareGetCurrentStatus(uint32_t feature_flag, ShareCurrentStatus* status) { + (void)feature_flag; + (void)status; + return 0; +} + +int ShareInitialize(size_t heap_size, int thread_priority, uint64_t affinity_mask) { + (void)heap_size; + (void)thread_priority; + (void)affinity_mask; + return 0; +} + +int ShareTerminate(void) { + return 0; +} + +int SystemServiceParamGetInt(int param_id, int* value) { + (void)param_id; + (void)value; + return 0; +} + +int SystemServiceParamGetString(int param_id, char* buf, size_t buf_size) { + (void)param_id; + (void)buf; + (void)buf_size; + return 0; +} + +} diff --git a/core/libs/prx/libReactNative.Modules.Vsh/Export.cpp b/core/libs/prx/libReactNative.Modules.Vsh/Export.cpp new file mode 100644 index 000000000..eea4db07b --- /dev/null +++ b/core/libs/prx/libReactNative.Modules.Vsh/Export.cpp @@ -0,0 +1,30 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int RemotePlayGetConnectionStatus(int user_id, int* status) { + (void)user_id; + (void)status; + return 0; +} + +int ShareGetCurrentStatus(uint32_t feature_flag, ShareCurrentStatus* status) { + (void)feature_flag; + (void)status; + return 0; +} + +int ShareInitialize(size_t heap_size, int thread_priority, uint64_t affinity_mask) { + (void)heap_size; + (void)thread_priority; + (void)affinity_mask; + return 0; +} + +int ShareTerminate(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceAcm/Export.cpp b/core/libs/prx/libSceAcm/Export.cpp new file mode 100644 index 000000000..c8cd42299 --- /dev/null +++ b/core/libs/prx/libSceAcm/Export.cpp @@ -0,0 +1,42 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAcmBatchStartBuffer(AcmContextId context, const void* batch_commands, size_t batch_size, AcmBatchError* batch_error, AcmBatchId* batch) { + (void)context; + (void)batch_commands; + (void)batch_size; + (void)batch_error; + (void)batch; + return 0; +} + +int sceAcmBatchStartBuffers(AcmContextId context, uint32_t batch_info_count, const AcmBatchInfo* const batch_info[], AcmBatchError* batch_error, AcmBatchId* batch) { + (void)context; + (void)batch_info_count; + (void)batch_info; + (void)batch_error; + (void)batch; + return 0; +} + +int sceAcmBatchWait(AcmContextId context, AcmBatchId batch, uint32_t timeout) { + (void)context; + (void)batch; + (void)timeout; + return 0; +} + +int sceAcmContextCreate(AcmContextId* context) { + (void)context; + return 0; +} + +int sceAcmContextDestroy(AcmContextId context) { + (void)context; + return 0; +} + +} diff --git a/core/libs/prx/libSceAgc/Export.cpp b/core/libs/prx/libSceAgc/Export.cpp new file mode 100644 index 000000000..3b65df648 --- /dev/null +++ b/core/libs/prx/libSceAgc/Export.cpp @@ -0,0 +1,780 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +uint32_t* sceAgcAcbAcquireMem(CommandBuffer* buf, uint32_t gcr_cntl, const volatile void* base, uint64_t size_bytes, uint32_t poll_cycles) { + (void)buf; + (void)gcr_cntl; + (void)base; + (void)size_bytes; + (void)poll_cycles; + return nullptr; +} + +uint32_t sceAgcAcbAcquireMemGetSize(void) { + return 0; +} + +uint32_t* sceAgcAcbCondExec(CommandBuffer* buf, const volatile uint32_t* address, uint32_t num_dwords) { + (void)buf; + (void)address; + (void)num_dwords; + return nullptr; +} + +uint32_t sceAgcAcbCondExecGetSize(void) { + return 0; +} + +uint32_t* sceAgcAcbCopyData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_immediate, uint8_t item_size, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)dst_cache_policy; + (void)dst_address; + (void)src; + (void)src_cache_policy; + (void)src_address_or_immediate; + (void)item_size; + (void)write_confirm; + return nullptr; +} + +uint32_t* sceAgcAcbDispatchIndirect(CommandBuffer* buf, const volatile void* indirect_args, uint32_t modifier) { + (void)buf; + (void)indirect_args; + (void)modifier; + return nullptr; +} + +uint32_t* sceAgcAcbDmaData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address_or_offset, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_offset_or_immediate, uint32_t num_bytes, uint8_t wait_for_previous, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)dst_cache_policy; + (void)dst_address_or_offset; + (void)src; + (void)src_cache_policy; + (void)src_address_or_offset_or_immediate; + (void)num_bytes; + (void)wait_for_previous; + (void)write_confirm; + return nullptr; +} + +uint32_t* sceAgcAcbEventWrite(CommandBuffer* buf, uint8_t event_type, const volatile void* address) { + (void)buf; + (void)event_type; + (void)address; + return nullptr; +} + +uint32_t sceAgcAcbJumpGetSize(void) { + return 0; +} + +uint32_t* sceAgcAcbPopMarker(CommandBuffer* buf) { + (void)buf; + return nullptr; +} + +uint32_t* sceAgcAcbPushMarker(CommandBuffer* buf, const char* str, uint32_t color) { + (void)buf; + (void)str; + (void)color; + return nullptr; +} + +uint32_t* sceAgcAcbResetQueue(CommandBuffer* buf, uint32_t op) { + (void)buf; + (void)op; + return nullptr; +} + +uint32_t* sceAgcAcbSetMarker(CommandBuffer* buf, const char* str, uint32_t color) { + (void)buf; + (void)str; + (void)color; + return nullptr; +} + +uint32_t* sceAgcAcbWaitRegMem(CommandBuffer* buf, uint8_t size, uint8_t compare_function, uint8_t cache_policy, const volatile void* address, uint64_t reference, uint64_t mask, uint32_t poll_cycles) { + (void)buf; + (void)size; + (void)compare_function; + (void)cache_policy; + (void)address; + (void)reference; + (void)mask; + (void)poll_cycles; + return nullptr; +} + +uint32_t* sceAgcAcbWriteData(CommandBuffer* buf, uint8_t dst, uint8_t cache_policy, uint64_t address_or_offset, const void* data, uint32_t num_dwords, uint8_t increment, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)cache_policy; + (void)address_or_offset; + (void)data; + (void)num_dwords; + (void)increment; + (void)write_confirm; + return nullptr; +} + +uint32_t* sceAgcCbBranch(CommandBuffer* buf, uint8_t mode, uint8_t compare_function, const volatile uint64_t* compare_addr, uint64_t mask, uint64_t reference, uint8_t cache_policy1, const volatile uint32_t* buffer1, uint32_t size_in_dwords1, uint8_t cache_policy2, const volatile uint32_t* buffer2, uint32_t size_in_dwords2) { + (void)buf; + (void)mode; + (void)compare_function; + (void)compare_addr; + (void)mask; + (void)reference; + (void)cache_policy1; + (void)buffer1; + (void)size_in_dwords1; + (void)cache_policy2; + (void)buffer2; + (void)size_in_dwords2; + return nullptr; +} + +uint32_t* sceAgcCbDispatch(CommandBuffer* buf, uint32_t thread_group_x, uint32_t thread_group_y, uint32_t thread_group_z, uint32_t modifier) { + (void)buf; + (void)thread_group_x; + (void)thread_group_y; + (void)thread_group_z; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcCbDispatchGetSize(void) { + return 0; +} + +uint32_t* sceAgcCbNop(CommandBuffer* buf, uint32_t size_in_dwords) { + (void)buf; + (void)size_in_dwords; + return nullptr; +} + +uint32_t sceAgcCbNopGetSize(uint32_t size_in_dwords) { + (void)size_in_dwords; + return 0; +} + +uint32_t sceAgcCbQueueEndOfPipeActionGetSize(void) { + return 0; +} + +uint32_t* sceAgcCbReleaseMem(CommandBuffer* buf, uint8_t action, uint16_t gcr_cntl, uint8_t dst, uint8_t cache_policy, const volatile Label* address, uint8_t data_sel, uint64_t data, uint16_t gds_offset, uint16_t gds_size, uint8_t interrupt, uint32_t interrupt_ctx_id) { + (void)buf; + (void)action; + (void)gcr_cntl; + (void)dst; + (void)cache_policy; + (void)address; + (void)data_sel; + (void)data; + (void)gds_offset; + (void)gds_size; + (void)interrupt; + (void)interrupt_ctx_id; + return nullptr; +} + +uint32_t* sceAgcCbSetShRegisterRangeDirect(CommandBuffer* buf, uint32_t offset, const uint32_t* values, uint32_t num_values) { + (void)buf; + (void)offset; + (void)values; + (void)num_values; + return nullptr; +} + +uint32_t sceAgcCbSetShRegisterRangeDirectGetSize(uint32_t num_values) { + (void)num_values; + return 0; +} + +uint32_t* sceAgcCbSetShRegistersDirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) { + (void)buf; + (void)regs; + (void)num_regs; + return nullptr; +} + +int sceAgcCondExecPatchSetCommandAddress(uint32_t* cmd, const volatile uint32_t* command) { + (void)cmd; + (void)command; + return 0; +} + +int sceAgcCondExecPatchSetEnd(uint32_t* cmd, const volatile uint32_t* buffer) { + (void)cmd; + (void)buffer; + return 0; +} + +int sceAgcCreateInterpolantMapping(ShaderRegister* regs, const Shader* gs, const Shader* ps) { + (void)regs; + (void)gs; + (void)ps; + return 0; +} + +int sceAgcCreatePrimState(ShaderRegister* cx_regs, ShaderRegister* uc_regs, const Shader* hs, const Shader* gs, uint32_t prim_type) { + (void)cx_regs; + (void)uc_regs; + (void)hs; + (void)gs; + (void)prim_type; + return 0; +} + +int sceAgcCreateShader(Shader** dst, void* header, const volatile void* code) { + (void)dst; + (void)header; + (void)code; + return 0; +} + +uint32_t* sceAgcDcbAcquireMem(CommandBuffer* buf, uint8_t engine, uint32_t cb_db_op, uint32_t gcr_cntl, const volatile void* base, uint64_t size_bytes, uint32_t poll_cycles) { + (void)buf; + (void)engine; + (void)cb_db_op; + (void)gcr_cntl; + (void)base; + (void)size_bytes; + (void)poll_cycles; + return nullptr; +} + +uint32_t sceAgcDcbAcquireMemGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbCondExec(CommandBuffer* buf, const volatile uint32_t* address, uint32_t num_dwords) { + (void)buf; + (void)address; + (void)num_dwords; + return nullptr; +} + +uint32_t sceAgcDcbCondExecGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbContextStateOp(CommandBuffer* buf, uint32_t operation) { + (void)buf; + (void)operation; + return nullptr; +} + +uint64_t sceAgcDcbContextStateOpGetSize(uint32_t operation) { + (void)operation; + return 0; +} + +uint32_t* sceAgcDcbCopyData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_immediate, uint8_t item_size, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)dst_cache_policy; + (void)dst_address; + (void)src; + (void)src_cache_policy; + (void)src_address_or_immediate; + (void)item_size; + (void)write_confirm; + return nullptr; +} + +uint32_t* sceAgcDcbDispatchIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint32_t flags) { + (void)buf; + (void)data_offset_in_bytes; + (void)flags; + return nullptr; +} + +uint32_t sceAgcDcbDispatchIndirectGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbDmaData(CommandBuffer* buf, uint8_t engine, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address_or_offset, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_offset_or_immediate, uint32_t num_bytes, uint8_t wait_for_previous, uint8_t write_confirm, uint8_t block_engine) { + (void)buf; + (void)engine; + (void)dst; + (void)dst_cache_policy; + (void)dst_address_or_offset; + (void)src; + (void)src_cache_policy; + (void)src_address_or_offset_or_immediate; + (void)num_bytes; + (void)wait_for_previous; + (void)write_confirm; + (void)block_engine; + return nullptr; +} + +uint32_t* sceAgcDcbDrawIndex(CommandBuffer* buf, uint32_t index_count, const volatile void* index_addr, uint64_t modifier) { + (void)buf; + (void)index_count; + (void)index_addr; + (void)modifier; + return nullptr; +} + +uint32_t* sceAgcDcbDrawIndexAuto(CommandBuffer* buf, uint32_t index_count, uint64_t modifier) { + (void)buf; + (void)index_count; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcDcbDrawIndexAutoGetSize(void) { + return 0; +} + +uint32_t sceAgcDcbDrawIndexGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbDrawIndexIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint64_t modifier) { + (void)buf; + (void)data_offset_in_bytes; + (void)modifier; + return nullptr; +} + +uint32_t* sceAgcDcbDrawIndexIndirectMulti(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint32_t count_indirect, uint32_t max_count_or_count, const volatile void* count_addr, uint32_t stride_in_bytes, uint64_t modifier) { + (void)buf; + (void)data_offset_in_bytes; + (void)count_indirect; + (void)max_count_or_count; + (void)count_addr; + (void)stride_in_bytes; + (void)modifier; + return nullptr; +} + +uint32_t* sceAgcDcbDrawIndexMultiInstanced(CommandBuffer* buf, uint32_t index_count, const volatile void* index_addr, const volatile void* object_ids, uint32_t instance_count, uint64_t modifier) { + (void)buf; + (void)index_count; + (void)index_addr; + (void)object_ids; + (void)instance_count; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcDcbDrawIndexMultiInstancedGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbDrawIndexOffset(CommandBuffer* buf, uint32_t index_offset, uint32_t index_count, uint64_t modifier) { + (void)buf; + (void)index_offset; + (void)index_count; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcDcbDrawIndexOffsetGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbDrawIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint64_t modifier) { + (void)buf; + (void)data_offset_in_bytes; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcDcbDrawIndirectGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbEventWrite(CommandBuffer* buf, uint8_t event_type, const volatile void* address) { + (void)buf; + (void)event_type; + (void)address; + return nullptr; +} + +uint32_t* sceAgcDcbGetLodStats(CommandBuffer* buf, uint8_t cache_policy, const volatile void* buffer, uint32_t buffer_size_in_bytes, uint32_t reset_count, uint8_t force_reset, uint8_t report_and_reset, uint32_t reporting_interval_in_100k_clocks) { + (void)buf; + (void)cache_policy; + (void)buffer; + (void)buffer_size_in_bytes; + (void)reset_count; + (void)force_reset; + (void)report_and_reset; + (void)reporting_interval_in_100k_clocks; + return nullptr; +} + +uint32_t* sceAgcDcbJump(CommandBuffer* buf, uint8_t mode, uint8_t cache_policy, const uint32_t* target, uint32_t size_in_dwords) { + (void)buf; + (void)mode; + (void)cache_policy; + (void)target; + (void)size_in_dwords; + return nullptr; +} + +uint32_t sceAgcDcbJumpGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbPopMarker(CommandBuffer* buf) { + (void)buf; + return nullptr; +} + +uint32_t* sceAgcDcbPushMarker(CommandBuffer* buf, const char* str, uint32_t color) { + (void)buf; + (void)str; + (void)color; + return nullptr; +} + +uint32_t* sceAgcDcbResetQueue(CommandBuffer* buf, uint32_t op, uint32_t state) { + (void)buf; + (void)op; + (void)state; + return nullptr; +} + +uint32_t* sceAgcDcbRewind(CommandBuffer* buf, uint32_t initial_state) { + (void)buf; + (void)initial_state; + return nullptr; +} + +uint32_t sceAgcDcbRewindGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbSetBaseIndirectArgs(CommandBuffer* buf, uint32_t shader_type, const volatile void* indirect_base_addr) { + (void)buf; + (void)shader_type; + (void)indirect_base_addr; + return nullptr; +} + +uint32_t* sceAgcDcbSetCxRegisterDirect(CommandBuffer* buf, ShaderRegister reg) { + (void)buf; + (void)reg; + return nullptr; +} + +uint32_t sceAgcDcbSetCxRegisterDirectGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbSetCxRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) { + (void)buf; + (void)regs; + (void)num_regs; + return nullptr; +} + +uint32_t* sceAgcDcbSetFlip(CommandBuffer* buf, uint32_t video_out_handle, int32_t display_buffer_index, uint32_t flip_mode, int64_t flip_arg) { + (void)buf; + (void)video_out_handle; + (void)display_buffer_index; + (void)flip_mode; + (void)flip_arg; + return nullptr; +} + +uint32_t* sceAgcDcbSetIndexBuffer(CommandBuffer* buf, uint64_t index_addr) { + (void)buf; + (void)index_addr; + return nullptr; +} + +uint32_t* sceAgcDcbSetIndexCount(CommandBuffer* buf, uint32_t index_count) { + (void)buf; + (void)index_count; + return nullptr; +} + +uint32_t* sceAgcDcbSetIndexSize(CommandBuffer* buf, uint8_t index_size, uint8_t cache_policy) { + (void)buf; + (void)index_size; + (void)cache_policy; + return nullptr; +} + +uint32_t* sceAgcDcbSetMarker(CommandBuffer* buf, const char* str, uint32_t color) { + (void)buf; + (void)str; + (void)color; + return nullptr; +} + +uint32_t* sceAgcDcbSetNumInstances(CommandBuffer* buf, uint32_t num_instances) { + (void)buf; + (void)num_instances; + return nullptr; +} + +uint32_t sceAgcDcbSetNumInstancesGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbSetPredication(CommandBuffer* buf, uint8_t condition, uint8_t op, uint8_t wait_op, const volatile void* address, uint32_t count_in_dwords) { + (void)buf; + (void)condition; + (void)op; + (void)wait_op; + (void)address; + (void)count_in_dwords; + return nullptr; +} + +uint32_t* sceAgcDcbSetShRegisterDirect(CommandBuffer* buf, ShaderRegister reg) { + (void)buf; + (void)reg; + return nullptr; +} + +uint32_t* sceAgcDcbSetShRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) { + (void)buf; + (void)regs; + (void)num_regs; + return nullptr; +} + +uint32_t* sceAgcDcbSetUcRegisterDirect(CommandBuffer* buf, ShaderRegister reg) { + (void)buf; + (void)reg; + return nullptr; +} + +uint32_t* sceAgcDcbSetUcRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) { + (void)buf; + (void)regs; + (void)num_regs; + return nullptr; +} + +uint32_t* sceAgcDcbSetWorkloadComplete(CommandBuffer* buf, uint32_t stream_id, uint32_t workload_id) { + (void)buf; + (void)stream_id; + (void)workload_id; + return nullptr; +} + +uint32_t* sceAgcDcbSetWorkloadsActive(CommandBuffer* buf, uint32_t stream_id, const uint32_t* workload_ids, uint32_t workload_count) { + (void)buf; + (void)stream_id; + (void)workload_ids; + (void)workload_count; + return nullptr; +} + +uint32_t* sceAgcDcbStallCommandBufferParser(CommandBuffer* buf) { + (void)buf; + return nullptr; +} + +uint32_t sceAgcDcbWaitOnAddressGetSize(uint32_t size) { + (void)size; + return 0; +} + +uint32_t* sceAgcDcbWaitRegMem(CommandBuffer* buf, uint8_t size, uint8_t compare_function, uint8_t op, uint8_t cache_policy, const volatile void* address, uint64_t reference, uint64_t mask, uint32_t poll_cycles) { + (void)buf; + (void)size; + (void)compare_function; + (void)op; + (void)cache_policy; + (void)address; + (void)reference; + (void)mask; + (void)poll_cycles; + return nullptr; +} + +uint32_t* sceAgcDcbWaitUntilSafeForRendering(CommandBuffer* buf, uint32_t video_out_handle, uint32_t display_buffer_index) { + (void)buf; + (void)video_out_handle; + (void)display_buffer_index; + return nullptr; +} + +uint32_t* sceAgcDcbWriteData(CommandBuffer* buf, uint8_t dst, uint8_t cache_policy, uint64_t address_or_offset, const void* data, uint32_t num_dwords, uint8_t increment, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)cache_policy; + (void)address_or_offset; + (void)data; + (void)num_dwords; + (void)increment; + (void)write_confirm; + return nullptr; +} + +uint32_t sceAgcDcbWriteDataGetSize(uint32_t num_dwords) { + (void)num_dwords; + return 0; +} + +int sceAgcDmaDataPatchSetDstAddressOrOffset(uint32_t* cmd, uint64_t dst_address_or_offset) { + (void)cmd; + (void)dst_address_or_offset; + return 0; +} + +int sceAgcDmaDataPatchSetSrcAddressOrOffsetOrImmediate(uint32_t* cmd, uint64_t src_address_or_offset_or_immediate) { + (void)cmd; + (void)src_address_or_offset_or_immediate; + return 0; +} + +int sceAgcGetDataPacketPayloadAddress(uint32_t** addr, uint32_t* cmd, int type) { + (void)addr; + (void)cmd; + (void)type; + return 0; +} + +uint32_t sceAgcGetPacketSize(uint32_t* packet) { + (void)packet; + return 0; +} + +void* sceAgcGetRegisterDefaults2(uint32_t ver) { + (void)ver; + return nullptr; +} + +void* sceAgcGetRegisterDefaults2Internal(uint32_t ver) { + (void)ver; + return nullptr; +} + +int sceAgcInit(uint32_t* state, uint32_t ver) { + (void)state; + (void)ver; + return 0; +} + +int sceAgcJumpPatchSetTarget(uint32_t* cmd, const volatile uint32_t* target, uint32_t size_in_dwords) { + (void)cmd; + (void)target; + (void)size_in_dwords; + return 0; +} + +int sceAgcQueueEndOfPipeActionPatchAddress(uint32_t* cmd, const volatile Label* address) { + (void)cmd; + (void)address; + return 0; +} + +int sceAgcQueueEndOfPipeActionPatchData(uint32_t* cmd, uint32_t context_id, uint32_t data_sel, uint64_t data) { + (void)cmd; + (void)context_id; + (void)data_sel; + (void)data; + return 0; +} + +int sceAgcRewindPatchSetRewindState(uint32_t* cmd, uint8_t state) { + (void)cmd; + (void)state; + return 0; +} + +int sceAgcSetCxRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetCxRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) { + (void)cmd; + (void)regs; + return 0; +} + +int sceAgcSetCxRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetPacketPredication(uint32_t* packet, uint32_t predication) { + (void)packet; + (void)predication; + return 0; +} + +int sceAgcSetRangePredication(uint32_t* start, const volatile uint32_t* end, uint32_t predication) { + (void)start; + (void)end; + (void)predication; + return 0; +} + +int sceAgcSetShRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetShRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) { + (void)cmd; + (void)regs; + return 0; +} + +int sceAgcSetShRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetUcRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetUcRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) { + (void)cmd; + (void)regs; + return 0; +} + +int sceAgcSetUcRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSuspendPoint(void) { + return 0; +} + +int sceAgcUpdatePrimState(ShaderRegister* cx_regs, ShaderRegister* uc_regs, uint32_t prim_type) { + (void)cx_regs; + (void)uc_regs; + (void)prim_type; + return 0; +} + +int sceAgcWaitRegMemPatchAddress(uint32_t* cmd, const volatile void* address) { + (void)cmd; + (void)address; + return 0; +} + +int sceAgcWaitRegMemPatchReference(uint32_t* cmd, uint64_t reference) { + (void)cmd; + (void)reference; + return 0; +} + +} diff --git a/core/libs/prx/libSceAgcDriver/Export.cpp b/core/libs/prx/libSceAgcDriver/Export.cpp new file mode 100644 index 000000000..f48ebd559 --- /dev/null +++ b/core/libs/prx/libSceAgcDriver/Export.cpp @@ -0,0 +1,119 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAgcDriverAddEqEvent(KernelEqueue eq, int id, void* udata) { + (void)eq; + (void)id; + (void)udata; + return 0; +} + +int sceAgcDriverDeleteEqEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +uint32_t sceAgcDriverGetEqContextId(const KernelEvent* ev) { + (void)ev; + return 0; +} + +int sceAgcDriverGetEqEventType(const KernelEvent* ev) { + (void)ev; + return 0; +} + +uint32_t sceAgcDriverInitResourceRegistration(void) { + return 0; +} + +bool sceAgcDriverIsCaptureInProgress(void) { + return false; +} + +uint32_t sceAgcDriverQueryResourceRegistrationUserMemoryRequirements(uint64_t* size_in_bytes) { + (void)size_in_bytes; + return 0; +} + +int sceAgcDriverRegisterOwner(void) { + return 0; +} + +int sceAgcDriverRegisterResource(void) { + return 0; +} + +int sceAgcDriverRegisterWorkloadStream(uint32_t stream_id, const void* stream) { + (void)stream_id; + (void)stream; + return 0; +} + +int sceAgcDriverSetHsOffchipParam(uint64_t value0, uint64_t value1, uint64_t value2) { + (void)value0; + (void)value1; + (void)value2; + return 0; +} + +int sceAgcDriverSetTFRing(const volatile void* base, uint32_t size) { + (void)base; + (void)size; + return 0; +} + +int sceAgcDriverSubmitAcb(uint32_t queue, const Packet* packet) { + (void)queue; + (void)packet; + return 0; +} + +int sceAgcDriverSubmitCommandBuffer(void* queue_context, const Packet* packet) { + (void)queue_context; + (void)packet; + return 0; +} + +int sceAgcDriverSubmitDcb(const Packet* packet) { + (void)packet; + return 0; +} + +int sceAgcDriverSubmitMultiAcbs(uint32_t queue, uint32_t* const* acbs, const uint32_t* sizes_in_dwords, uint32_t count) { + (void)queue; + (void)acbs; + (void)sizes_in_dwords; + (void)count; + return 0; +} + +int sceAgcDriverSubmitMultiCommandBuffers(void* queue_context, uint32_t* const* command_buffers, const uint32_t* sizes_in_dwords, uint32_t count) { + (void)queue_context; + (void)command_buffers; + (void)sizes_in_dwords; + (void)count; + return 0; +} + +int sceAgcDriverSubmitMultiDcbs(uint32_t* const* dcb_gpu_addrs, const uint32_t* dcb_sizes_in_dwords, uint32_t count) { + (void)dcb_gpu_addrs; + (void)dcb_sizes_in_dwords; + (void)count; + return 0; +} + +int sceAgcDriverUnregisterOwnerAndResources(uint32_t owner_handle) { + (void)owner_handle; + return 0; +} + +int sceAgcDriverUnregisterResource(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceAgcVsh/Export.cpp b/core/libs/prx/libSceAgcVsh/Export.cpp new file mode 100644 index 000000000..3b65df648 --- /dev/null +++ b/core/libs/prx/libSceAgcVsh/Export.cpp @@ -0,0 +1,780 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +uint32_t* sceAgcAcbAcquireMem(CommandBuffer* buf, uint32_t gcr_cntl, const volatile void* base, uint64_t size_bytes, uint32_t poll_cycles) { + (void)buf; + (void)gcr_cntl; + (void)base; + (void)size_bytes; + (void)poll_cycles; + return nullptr; +} + +uint32_t sceAgcAcbAcquireMemGetSize(void) { + return 0; +} + +uint32_t* sceAgcAcbCondExec(CommandBuffer* buf, const volatile uint32_t* address, uint32_t num_dwords) { + (void)buf; + (void)address; + (void)num_dwords; + return nullptr; +} + +uint32_t sceAgcAcbCondExecGetSize(void) { + return 0; +} + +uint32_t* sceAgcAcbCopyData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_immediate, uint8_t item_size, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)dst_cache_policy; + (void)dst_address; + (void)src; + (void)src_cache_policy; + (void)src_address_or_immediate; + (void)item_size; + (void)write_confirm; + return nullptr; +} + +uint32_t* sceAgcAcbDispatchIndirect(CommandBuffer* buf, const volatile void* indirect_args, uint32_t modifier) { + (void)buf; + (void)indirect_args; + (void)modifier; + return nullptr; +} + +uint32_t* sceAgcAcbDmaData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address_or_offset, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_offset_or_immediate, uint32_t num_bytes, uint8_t wait_for_previous, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)dst_cache_policy; + (void)dst_address_or_offset; + (void)src; + (void)src_cache_policy; + (void)src_address_or_offset_or_immediate; + (void)num_bytes; + (void)wait_for_previous; + (void)write_confirm; + return nullptr; +} + +uint32_t* sceAgcAcbEventWrite(CommandBuffer* buf, uint8_t event_type, const volatile void* address) { + (void)buf; + (void)event_type; + (void)address; + return nullptr; +} + +uint32_t sceAgcAcbJumpGetSize(void) { + return 0; +} + +uint32_t* sceAgcAcbPopMarker(CommandBuffer* buf) { + (void)buf; + return nullptr; +} + +uint32_t* sceAgcAcbPushMarker(CommandBuffer* buf, const char* str, uint32_t color) { + (void)buf; + (void)str; + (void)color; + return nullptr; +} + +uint32_t* sceAgcAcbResetQueue(CommandBuffer* buf, uint32_t op) { + (void)buf; + (void)op; + return nullptr; +} + +uint32_t* sceAgcAcbSetMarker(CommandBuffer* buf, const char* str, uint32_t color) { + (void)buf; + (void)str; + (void)color; + return nullptr; +} + +uint32_t* sceAgcAcbWaitRegMem(CommandBuffer* buf, uint8_t size, uint8_t compare_function, uint8_t cache_policy, const volatile void* address, uint64_t reference, uint64_t mask, uint32_t poll_cycles) { + (void)buf; + (void)size; + (void)compare_function; + (void)cache_policy; + (void)address; + (void)reference; + (void)mask; + (void)poll_cycles; + return nullptr; +} + +uint32_t* sceAgcAcbWriteData(CommandBuffer* buf, uint8_t dst, uint8_t cache_policy, uint64_t address_or_offset, const void* data, uint32_t num_dwords, uint8_t increment, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)cache_policy; + (void)address_or_offset; + (void)data; + (void)num_dwords; + (void)increment; + (void)write_confirm; + return nullptr; +} + +uint32_t* sceAgcCbBranch(CommandBuffer* buf, uint8_t mode, uint8_t compare_function, const volatile uint64_t* compare_addr, uint64_t mask, uint64_t reference, uint8_t cache_policy1, const volatile uint32_t* buffer1, uint32_t size_in_dwords1, uint8_t cache_policy2, const volatile uint32_t* buffer2, uint32_t size_in_dwords2) { + (void)buf; + (void)mode; + (void)compare_function; + (void)compare_addr; + (void)mask; + (void)reference; + (void)cache_policy1; + (void)buffer1; + (void)size_in_dwords1; + (void)cache_policy2; + (void)buffer2; + (void)size_in_dwords2; + return nullptr; +} + +uint32_t* sceAgcCbDispatch(CommandBuffer* buf, uint32_t thread_group_x, uint32_t thread_group_y, uint32_t thread_group_z, uint32_t modifier) { + (void)buf; + (void)thread_group_x; + (void)thread_group_y; + (void)thread_group_z; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcCbDispatchGetSize(void) { + return 0; +} + +uint32_t* sceAgcCbNop(CommandBuffer* buf, uint32_t size_in_dwords) { + (void)buf; + (void)size_in_dwords; + return nullptr; +} + +uint32_t sceAgcCbNopGetSize(uint32_t size_in_dwords) { + (void)size_in_dwords; + return 0; +} + +uint32_t sceAgcCbQueueEndOfPipeActionGetSize(void) { + return 0; +} + +uint32_t* sceAgcCbReleaseMem(CommandBuffer* buf, uint8_t action, uint16_t gcr_cntl, uint8_t dst, uint8_t cache_policy, const volatile Label* address, uint8_t data_sel, uint64_t data, uint16_t gds_offset, uint16_t gds_size, uint8_t interrupt, uint32_t interrupt_ctx_id) { + (void)buf; + (void)action; + (void)gcr_cntl; + (void)dst; + (void)cache_policy; + (void)address; + (void)data_sel; + (void)data; + (void)gds_offset; + (void)gds_size; + (void)interrupt; + (void)interrupt_ctx_id; + return nullptr; +} + +uint32_t* sceAgcCbSetShRegisterRangeDirect(CommandBuffer* buf, uint32_t offset, const uint32_t* values, uint32_t num_values) { + (void)buf; + (void)offset; + (void)values; + (void)num_values; + return nullptr; +} + +uint32_t sceAgcCbSetShRegisterRangeDirectGetSize(uint32_t num_values) { + (void)num_values; + return 0; +} + +uint32_t* sceAgcCbSetShRegistersDirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) { + (void)buf; + (void)regs; + (void)num_regs; + return nullptr; +} + +int sceAgcCondExecPatchSetCommandAddress(uint32_t* cmd, const volatile uint32_t* command) { + (void)cmd; + (void)command; + return 0; +} + +int sceAgcCondExecPatchSetEnd(uint32_t* cmd, const volatile uint32_t* buffer) { + (void)cmd; + (void)buffer; + return 0; +} + +int sceAgcCreateInterpolantMapping(ShaderRegister* regs, const Shader* gs, const Shader* ps) { + (void)regs; + (void)gs; + (void)ps; + return 0; +} + +int sceAgcCreatePrimState(ShaderRegister* cx_regs, ShaderRegister* uc_regs, const Shader* hs, const Shader* gs, uint32_t prim_type) { + (void)cx_regs; + (void)uc_regs; + (void)hs; + (void)gs; + (void)prim_type; + return 0; +} + +int sceAgcCreateShader(Shader** dst, void* header, const volatile void* code) { + (void)dst; + (void)header; + (void)code; + return 0; +} + +uint32_t* sceAgcDcbAcquireMem(CommandBuffer* buf, uint8_t engine, uint32_t cb_db_op, uint32_t gcr_cntl, const volatile void* base, uint64_t size_bytes, uint32_t poll_cycles) { + (void)buf; + (void)engine; + (void)cb_db_op; + (void)gcr_cntl; + (void)base; + (void)size_bytes; + (void)poll_cycles; + return nullptr; +} + +uint32_t sceAgcDcbAcquireMemGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbCondExec(CommandBuffer* buf, const volatile uint32_t* address, uint32_t num_dwords) { + (void)buf; + (void)address; + (void)num_dwords; + return nullptr; +} + +uint32_t sceAgcDcbCondExecGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbContextStateOp(CommandBuffer* buf, uint32_t operation) { + (void)buf; + (void)operation; + return nullptr; +} + +uint64_t sceAgcDcbContextStateOpGetSize(uint32_t operation) { + (void)operation; + return 0; +} + +uint32_t* sceAgcDcbCopyData(CommandBuffer* buf, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_immediate, uint8_t item_size, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)dst_cache_policy; + (void)dst_address; + (void)src; + (void)src_cache_policy; + (void)src_address_or_immediate; + (void)item_size; + (void)write_confirm; + return nullptr; +} + +uint32_t* sceAgcDcbDispatchIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint32_t flags) { + (void)buf; + (void)data_offset_in_bytes; + (void)flags; + return nullptr; +} + +uint32_t sceAgcDcbDispatchIndirectGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbDmaData(CommandBuffer* buf, uint8_t engine, uint8_t dst, uint8_t dst_cache_policy, uint64_t dst_address_or_offset, uint8_t src, uint8_t src_cache_policy, uint64_t src_address_or_offset_or_immediate, uint32_t num_bytes, uint8_t wait_for_previous, uint8_t write_confirm, uint8_t block_engine) { + (void)buf; + (void)engine; + (void)dst; + (void)dst_cache_policy; + (void)dst_address_or_offset; + (void)src; + (void)src_cache_policy; + (void)src_address_or_offset_or_immediate; + (void)num_bytes; + (void)wait_for_previous; + (void)write_confirm; + (void)block_engine; + return nullptr; +} + +uint32_t* sceAgcDcbDrawIndex(CommandBuffer* buf, uint32_t index_count, const volatile void* index_addr, uint64_t modifier) { + (void)buf; + (void)index_count; + (void)index_addr; + (void)modifier; + return nullptr; +} + +uint32_t* sceAgcDcbDrawIndexAuto(CommandBuffer* buf, uint32_t index_count, uint64_t modifier) { + (void)buf; + (void)index_count; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcDcbDrawIndexAutoGetSize(void) { + return 0; +} + +uint32_t sceAgcDcbDrawIndexGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbDrawIndexIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint64_t modifier) { + (void)buf; + (void)data_offset_in_bytes; + (void)modifier; + return nullptr; +} + +uint32_t* sceAgcDcbDrawIndexIndirectMulti(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint32_t count_indirect, uint32_t max_count_or_count, const volatile void* count_addr, uint32_t stride_in_bytes, uint64_t modifier) { + (void)buf; + (void)data_offset_in_bytes; + (void)count_indirect; + (void)max_count_or_count; + (void)count_addr; + (void)stride_in_bytes; + (void)modifier; + return nullptr; +} + +uint32_t* sceAgcDcbDrawIndexMultiInstanced(CommandBuffer* buf, uint32_t index_count, const volatile void* index_addr, const volatile void* object_ids, uint32_t instance_count, uint64_t modifier) { + (void)buf; + (void)index_count; + (void)index_addr; + (void)object_ids; + (void)instance_count; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcDcbDrawIndexMultiInstancedGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbDrawIndexOffset(CommandBuffer* buf, uint32_t index_offset, uint32_t index_count, uint64_t modifier) { + (void)buf; + (void)index_offset; + (void)index_count; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcDcbDrawIndexOffsetGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbDrawIndirect(CommandBuffer* buf, uint32_t data_offset_in_bytes, uint64_t modifier) { + (void)buf; + (void)data_offset_in_bytes; + (void)modifier; + return nullptr; +} + +uint32_t sceAgcDcbDrawIndirectGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbEventWrite(CommandBuffer* buf, uint8_t event_type, const volatile void* address) { + (void)buf; + (void)event_type; + (void)address; + return nullptr; +} + +uint32_t* sceAgcDcbGetLodStats(CommandBuffer* buf, uint8_t cache_policy, const volatile void* buffer, uint32_t buffer_size_in_bytes, uint32_t reset_count, uint8_t force_reset, uint8_t report_and_reset, uint32_t reporting_interval_in_100k_clocks) { + (void)buf; + (void)cache_policy; + (void)buffer; + (void)buffer_size_in_bytes; + (void)reset_count; + (void)force_reset; + (void)report_and_reset; + (void)reporting_interval_in_100k_clocks; + return nullptr; +} + +uint32_t* sceAgcDcbJump(CommandBuffer* buf, uint8_t mode, uint8_t cache_policy, const uint32_t* target, uint32_t size_in_dwords) { + (void)buf; + (void)mode; + (void)cache_policy; + (void)target; + (void)size_in_dwords; + return nullptr; +} + +uint32_t sceAgcDcbJumpGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbPopMarker(CommandBuffer* buf) { + (void)buf; + return nullptr; +} + +uint32_t* sceAgcDcbPushMarker(CommandBuffer* buf, const char* str, uint32_t color) { + (void)buf; + (void)str; + (void)color; + return nullptr; +} + +uint32_t* sceAgcDcbResetQueue(CommandBuffer* buf, uint32_t op, uint32_t state) { + (void)buf; + (void)op; + (void)state; + return nullptr; +} + +uint32_t* sceAgcDcbRewind(CommandBuffer* buf, uint32_t initial_state) { + (void)buf; + (void)initial_state; + return nullptr; +} + +uint32_t sceAgcDcbRewindGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbSetBaseIndirectArgs(CommandBuffer* buf, uint32_t shader_type, const volatile void* indirect_base_addr) { + (void)buf; + (void)shader_type; + (void)indirect_base_addr; + return nullptr; +} + +uint32_t* sceAgcDcbSetCxRegisterDirect(CommandBuffer* buf, ShaderRegister reg) { + (void)buf; + (void)reg; + return nullptr; +} + +uint32_t sceAgcDcbSetCxRegisterDirectGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbSetCxRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) { + (void)buf; + (void)regs; + (void)num_regs; + return nullptr; +} + +uint32_t* sceAgcDcbSetFlip(CommandBuffer* buf, uint32_t video_out_handle, int32_t display_buffer_index, uint32_t flip_mode, int64_t flip_arg) { + (void)buf; + (void)video_out_handle; + (void)display_buffer_index; + (void)flip_mode; + (void)flip_arg; + return nullptr; +} + +uint32_t* sceAgcDcbSetIndexBuffer(CommandBuffer* buf, uint64_t index_addr) { + (void)buf; + (void)index_addr; + return nullptr; +} + +uint32_t* sceAgcDcbSetIndexCount(CommandBuffer* buf, uint32_t index_count) { + (void)buf; + (void)index_count; + return nullptr; +} + +uint32_t* sceAgcDcbSetIndexSize(CommandBuffer* buf, uint8_t index_size, uint8_t cache_policy) { + (void)buf; + (void)index_size; + (void)cache_policy; + return nullptr; +} + +uint32_t* sceAgcDcbSetMarker(CommandBuffer* buf, const char* str, uint32_t color) { + (void)buf; + (void)str; + (void)color; + return nullptr; +} + +uint32_t* sceAgcDcbSetNumInstances(CommandBuffer* buf, uint32_t num_instances) { + (void)buf; + (void)num_instances; + return nullptr; +} + +uint32_t sceAgcDcbSetNumInstancesGetSize(void) { + return 0; +} + +uint32_t* sceAgcDcbSetPredication(CommandBuffer* buf, uint8_t condition, uint8_t op, uint8_t wait_op, const volatile void* address, uint32_t count_in_dwords) { + (void)buf; + (void)condition; + (void)op; + (void)wait_op; + (void)address; + (void)count_in_dwords; + return nullptr; +} + +uint32_t* sceAgcDcbSetShRegisterDirect(CommandBuffer* buf, ShaderRegister reg) { + (void)buf; + (void)reg; + return nullptr; +} + +uint32_t* sceAgcDcbSetShRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) { + (void)buf; + (void)regs; + (void)num_regs; + return nullptr; +} + +uint32_t* sceAgcDcbSetUcRegisterDirect(CommandBuffer* buf, ShaderRegister reg) { + (void)buf; + (void)reg; + return nullptr; +} + +uint32_t* sceAgcDcbSetUcRegistersIndirect(CommandBuffer* buf, const volatile ShaderRegister* regs, uint32_t num_regs) { + (void)buf; + (void)regs; + (void)num_regs; + return nullptr; +} + +uint32_t* sceAgcDcbSetWorkloadComplete(CommandBuffer* buf, uint32_t stream_id, uint32_t workload_id) { + (void)buf; + (void)stream_id; + (void)workload_id; + return nullptr; +} + +uint32_t* sceAgcDcbSetWorkloadsActive(CommandBuffer* buf, uint32_t stream_id, const uint32_t* workload_ids, uint32_t workload_count) { + (void)buf; + (void)stream_id; + (void)workload_ids; + (void)workload_count; + return nullptr; +} + +uint32_t* sceAgcDcbStallCommandBufferParser(CommandBuffer* buf) { + (void)buf; + return nullptr; +} + +uint32_t sceAgcDcbWaitOnAddressGetSize(uint32_t size) { + (void)size; + return 0; +} + +uint32_t* sceAgcDcbWaitRegMem(CommandBuffer* buf, uint8_t size, uint8_t compare_function, uint8_t op, uint8_t cache_policy, const volatile void* address, uint64_t reference, uint64_t mask, uint32_t poll_cycles) { + (void)buf; + (void)size; + (void)compare_function; + (void)op; + (void)cache_policy; + (void)address; + (void)reference; + (void)mask; + (void)poll_cycles; + return nullptr; +} + +uint32_t* sceAgcDcbWaitUntilSafeForRendering(CommandBuffer* buf, uint32_t video_out_handle, uint32_t display_buffer_index) { + (void)buf; + (void)video_out_handle; + (void)display_buffer_index; + return nullptr; +} + +uint32_t* sceAgcDcbWriteData(CommandBuffer* buf, uint8_t dst, uint8_t cache_policy, uint64_t address_or_offset, const void* data, uint32_t num_dwords, uint8_t increment, uint8_t write_confirm) { + (void)buf; + (void)dst; + (void)cache_policy; + (void)address_or_offset; + (void)data; + (void)num_dwords; + (void)increment; + (void)write_confirm; + return nullptr; +} + +uint32_t sceAgcDcbWriteDataGetSize(uint32_t num_dwords) { + (void)num_dwords; + return 0; +} + +int sceAgcDmaDataPatchSetDstAddressOrOffset(uint32_t* cmd, uint64_t dst_address_or_offset) { + (void)cmd; + (void)dst_address_or_offset; + return 0; +} + +int sceAgcDmaDataPatchSetSrcAddressOrOffsetOrImmediate(uint32_t* cmd, uint64_t src_address_or_offset_or_immediate) { + (void)cmd; + (void)src_address_or_offset_or_immediate; + return 0; +} + +int sceAgcGetDataPacketPayloadAddress(uint32_t** addr, uint32_t* cmd, int type) { + (void)addr; + (void)cmd; + (void)type; + return 0; +} + +uint32_t sceAgcGetPacketSize(uint32_t* packet) { + (void)packet; + return 0; +} + +void* sceAgcGetRegisterDefaults2(uint32_t ver) { + (void)ver; + return nullptr; +} + +void* sceAgcGetRegisterDefaults2Internal(uint32_t ver) { + (void)ver; + return nullptr; +} + +int sceAgcInit(uint32_t* state, uint32_t ver) { + (void)state; + (void)ver; + return 0; +} + +int sceAgcJumpPatchSetTarget(uint32_t* cmd, const volatile uint32_t* target, uint32_t size_in_dwords) { + (void)cmd; + (void)target; + (void)size_in_dwords; + return 0; +} + +int sceAgcQueueEndOfPipeActionPatchAddress(uint32_t* cmd, const volatile Label* address) { + (void)cmd; + (void)address; + return 0; +} + +int sceAgcQueueEndOfPipeActionPatchData(uint32_t* cmd, uint32_t context_id, uint32_t data_sel, uint64_t data) { + (void)cmd; + (void)context_id; + (void)data_sel; + (void)data; + return 0; +} + +int sceAgcRewindPatchSetRewindState(uint32_t* cmd, uint8_t state) { + (void)cmd; + (void)state; + return 0; +} + +int sceAgcSetCxRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetCxRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) { + (void)cmd; + (void)regs; + return 0; +} + +int sceAgcSetCxRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetPacketPredication(uint32_t* packet, uint32_t predication) { + (void)packet; + (void)predication; + return 0; +} + +int sceAgcSetRangePredication(uint32_t* start, const volatile uint32_t* end, uint32_t predication) { + (void)start; + (void)end; + (void)predication; + return 0; +} + +int sceAgcSetShRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetShRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) { + (void)cmd; + (void)regs; + return 0; +} + +int sceAgcSetShRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetUcRegIndirectPatchAddRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSetUcRegIndirectPatchSetAddress(uint32_t* cmd, const volatile ShaderRegister* regs) { + (void)cmd; + (void)regs; + return 0; +} + +int sceAgcSetUcRegIndirectPatchSetNumRegisters(uint32_t* cmd, uint32_t num_regs) { + (void)cmd; + (void)num_regs; + return 0; +} + +int sceAgcSuspendPoint(void) { + return 0; +} + +int sceAgcUpdatePrimState(ShaderRegister* cx_regs, ShaderRegister* uc_regs, uint32_t prim_type) { + (void)cx_regs; + (void)uc_regs; + (void)prim_type; + return 0; +} + +int sceAgcWaitRegMemPatchAddress(uint32_t* cmd, const volatile void* address) { + (void)cmd; + (void)address; + return 0; +} + +int sceAgcWaitRegMemPatchReference(uint32_t* cmd, uint64_t reference) { + (void)cmd; + (void)reference; + return 0; +} + +} diff --git a/core/libs/prx/libSceAjm.native/Export.cpp b/core/libs/prx/libSceAjm.native/Export.cpp new file mode 100644 index 000000000..d7138159e --- /dev/null +++ b/core/libs/prx/libSceAjm.native/Export.cpp @@ -0,0 +1,266 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAjmBatchCancel(uint32_t context, uint32_t batch) { + (void)context; + (void)batch; + return 0; +} + +int sceAjmBatchErrorDump(const AjmBatchInfo* info, AjmBatchError* error) { + (void)info; + (void)error; + return 0; +} + +int sceAjmBatchInitialize(void* buffer, size_t size, AjmBatchInfo* info) { + (void)buffer; + (void)size; + (void)info; + return 0; +} + +int sceAjmBatchJobClearContext(AjmBatchInfo* info, uint32_t instance, void* result) { + (void)info; + (void)instance; + (void)result; + return 0; +} + +int sceAjmBatchJobControl(AjmBatchInfo* info, uint32_t instance, uint64_t flags, const void* sideband_input, size_t sideband_input_size, void* sideband_output, size_t sideband_output_size) { + (void)info; + (void)instance; + (void)flags; + (void)sideband_input; + (void)sideband_input_size; + (void)sideband_output; + (void)sideband_output_size; + return 0; +} + +int sceAjmBatchJobDecode(AjmBatchInfo* info, uint32_t instance, const void* bitstream_input, size_t bitstream_input_size, void* pcm_output, size_t pcm_output_size, void* result) { + (void)info; + (void)instance; + (void)bitstream_input; + (void)bitstream_input_size; + (void)pcm_output; + (void)pcm_output_size; + (void)result; + return 0; +} + +int sceAjmBatchJobDecodeSingle(AjmBatchInfo* info, uint32_t instance, const void* bitstream_input, size_t bitstream_input_size, void* pcm_output, size_t pcm_output_size, void* result) { + (void)info; + (void)instance; + (void)bitstream_input; + (void)bitstream_input_size; + (void)pcm_output; + (void)pcm_output_size; + (void)result; + return 0; +} + +int sceAjmBatchJobDecodeSplit(AjmBatchInfo* info, uint32_t instance, const AjmBuffer* input_buffers, size_t input_buffers_num, const AjmBuffer* output_buffers, size_t output_buffers_num, void* result) { + (void)info; + (void)instance; + (void)input_buffers; + (void)input_buffers_num; + (void)output_buffers; + (void)output_buffers_num; + (void)result; + return 0; +} + +int sceAjmBatchJobEncode(AjmBatchInfo* info, uint32_t instance, const void* pcm_input, size_t pcm_input_size, void* bitstream_output, size_t bitstream_output_size, void* result) { + (void)info; + (void)instance; + (void)pcm_input; + (void)pcm_input_size; + (void)bitstream_output; + (void)bitstream_output_size; + (void)result; + return 0; +} + +int sceAjmBatchJobGetCodecInfo(AjmBatchInfo* info, uint32_t instance, void* result, size_t result_size) { + (void)info; + (void)instance; + (void)result; + (void)result_size; + return 0; +} + +int sceAjmBatchJobGetGaplessDecode(AjmBatchInfo* info, uint32_t instance, void* result) { + (void)info; + (void)instance; + (void)result; + return 0; +} + +int sceAjmBatchJobGetInfo(AjmBatchInfo* info, uint32_t instance, void* result) { + (void)info; + (void)instance; + (void)result; + return 0; +} + +int sceAjmBatchJobGetResampleInfo(AjmBatchInfo* info, uint32_t instance, void* result) { + (void)info; + (void)instance; + (void)result; + return 0; +} + +int sceAjmBatchJobGetStatistics(AjmBatchInfo* info, float interval, void* result) { + (void)info; + (void)interval; + (void)result; + return 0; +} + +int sceAjmBatchJobInitialize(AjmBatchInfo* info, uint32_t instance, const void* codec_parameters, size_t codec_parameters_size, void* result) { + (void)info; + (void)instance; + (void)codec_parameters; + (void)codec_parameters_size; + (void)result; + return 0; +} + +int sceAjmBatchJobRun(AjmBatchInfo* info, uint32_t instance, uint64_t flags, const void* data_input, size_t data_input_size, void* data_output, size_t data_output_size, void* sideband_output, size_t sideband_output_size) { + (void)info; + (void)instance; + (void)flags; + (void)data_input; + (void)data_input_size; + (void)data_output; + (void)data_output_size; + (void)sideband_output; + (void)sideband_output_size; + return 0; +} + +int sceAjmBatchJobRunSplit(AjmBatchInfo* info, uint32_t instance, uint64_t flags, const AjmBuffer* input_buffers, size_t input_buffers_num, const AjmBuffer* output_buffers, size_t output_buffers_num, void* sideband_output, size_t sideband_output_size) { + (void)info; + (void)instance; + (void)flags; + (void)input_buffers; + (void)input_buffers_num; + (void)output_buffers; + (void)output_buffers_num; + (void)sideband_output; + (void)sideband_output_size; + return 0; +} + +int sceAjmBatchJobSetGaplessDecode(AjmBatchInfo* info, uint32_t instance, const void* gapless_decode, int reset, void* result) { + (void)info; + (void)instance; + (void)gapless_decode; + (void)reset; + (void)result; + return 0; +} + +int sceAjmBatchJobSetResampleParameters(AjmBatchInfo* info, uint32_t instance, float ratio, uint32_t flags, void* result) { + (void)info; + (void)instance; + (void)ratio; + (void)flags; + (void)result; + return 0; +} + +int sceAjmBatchJobSetResampleParametersEx(AjmBatchInfo* info, uint32_t instance, float ratio_start, float ratio_change_per_sample, uint32_t flags, void* result) { + (void)info; + (void)instance; + (void)ratio_start; + (void)ratio_change_per_sample; + (void)flags; + (void)result; + return 0; +} + +int sceAjmBatchStart(uint32_t context, const AjmBatchInfo* info, int priority, AjmBatchError* error, uint32_t* batch) { + (void)context; + (void)info; + (void)priority; + (void)error; + (void)batch; + return 0; +} + +int sceAjmBatchWait(uint32_t context, uint32_t batch, uint32_t timeout, AjmBatchError* error) { + (void)context; + (void)batch; + (void)timeout; + (void)error; + return 0; +} + +int sceAjmDecAt9ParseConfigData(const void* config_data, AjmDecAt9ConfigDataInfo* config_info) { + (void)config_data; + (void)config_info; + return 0; +} + +int sceAjmFinalize(uint32_t context) { + (void)context; + return 0; +} + +int sceAjmInitialize(int64_t reserved, uint32_t* context) { + (void)reserved; + (void)context; + return 0; +} + +int sceAjmInstanceCreate(uint32_t context, uint32_t codec, uint64_t flags, uint32_t* instance) { + (void)context; + (void)codec; + (void)flags; + (void)instance; + return 0; +} + +int sceAjmInstanceDestroy(uint32_t context, uint32_t instance) { + (void)context; + (void)instance; + return 0; +} + +int sceAjmMemoryRegister(uint32_t context, void* ptr, size_t pages) { + (void)context; + (void)ptr; + (void)pages; + return 0; +} + +int sceAjmMemoryUnregister(uint32_t context, void* ptr) { + (void)context; + (void)ptr; + return 0; +} + +int sceAjmModuleRegister(uint32_t context, uint32_t codec, int64_t reserved) { + (void)context; + (void)codec; + (void)reserved; + return 0; +} + +int sceAjmModuleUnregister(uint32_t context, uint32_t codec) { + (void)context; + (void)codec; + return 0; +} + +const char* sceAjmStrError(int error) { + (void)error; + return nullptr; +} + +} diff --git a/core/libs/prx/libSceAjm/Export.cpp b/core/libs/prx/libSceAjm/Export.cpp new file mode 100644 index 000000000..04c335774 --- /dev/null +++ b/core/libs/prx/libSceAjm/Export.cpp @@ -0,0 +1,89 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAjmBatchCancel(uint32_t context, uint32_t batch) { + (void)context; + (void)batch; + return 0; +} + +int sceAjmBatchErrorDump(const AjmBatchInfo* info, AjmBatchError* error) { + (void)info; + (void)error; + return 0; +} + +int sceAjmBatchWait(uint32_t context, uint32_t batch, uint32_t timeout, AjmBatchError* error) { + (void)context; + (void)batch; + (void)timeout; + (void)error; + return 0; +} + +int sceAjmDecAt9ParseConfigData(const void* config_data, AjmDecAt9ConfigDataInfo* config_info) { + (void)config_data; + (void)config_info; + return 0; +} + +int sceAjmFinalize(uint32_t context) { + (void)context; + return 0; +} + +int sceAjmInitialize(int64_t reserved, uint32_t* context) { + (void)reserved; + (void)context; + return 0; +} + +int sceAjmInstanceCreate(uint32_t context, uint32_t codec, uint64_t flags, uint32_t* instance) { + (void)context; + (void)codec; + (void)flags; + (void)instance; + return 0; +} + +int sceAjmInstanceDestroy(uint32_t context, uint32_t instance) { + (void)context; + (void)instance; + return 0; +} + +int sceAjmMemoryRegister(uint32_t context, void* ptr, size_t pages) { + (void)context; + (void)ptr; + (void)pages; + return 0; +} + +int sceAjmMemoryUnregister(uint32_t context, void* ptr) { + (void)context; + (void)ptr; + return 0; +} + +int sceAjmModuleRegister(uint32_t context, uint32_t codec, int64_t reserved) { + (void)context; + (void)codec; + (void)reserved; + return 0; +} + +int sceAjmModuleUnregister(uint32_t context, uint32_t codec) { + (void)context; + (void)codec; + return 0; +} + +const char* sceAjmStrError(int error) { + (void)error; + return nullptr; +} + +} diff --git a/core/libs/prx/libSceAjmi/Export.cpp b/core/libs/prx/libSceAjmi/Export.cpp new file mode 100644 index 000000000..04c335774 --- /dev/null +++ b/core/libs/prx/libSceAjmi/Export.cpp @@ -0,0 +1,89 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAjmBatchCancel(uint32_t context, uint32_t batch) { + (void)context; + (void)batch; + return 0; +} + +int sceAjmBatchErrorDump(const AjmBatchInfo* info, AjmBatchError* error) { + (void)info; + (void)error; + return 0; +} + +int sceAjmBatchWait(uint32_t context, uint32_t batch, uint32_t timeout, AjmBatchError* error) { + (void)context; + (void)batch; + (void)timeout; + (void)error; + return 0; +} + +int sceAjmDecAt9ParseConfigData(const void* config_data, AjmDecAt9ConfigDataInfo* config_info) { + (void)config_data; + (void)config_info; + return 0; +} + +int sceAjmFinalize(uint32_t context) { + (void)context; + return 0; +} + +int sceAjmInitialize(int64_t reserved, uint32_t* context) { + (void)reserved; + (void)context; + return 0; +} + +int sceAjmInstanceCreate(uint32_t context, uint32_t codec, uint64_t flags, uint32_t* instance) { + (void)context; + (void)codec; + (void)flags; + (void)instance; + return 0; +} + +int sceAjmInstanceDestroy(uint32_t context, uint32_t instance) { + (void)context; + (void)instance; + return 0; +} + +int sceAjmMemoryRegister(uint32_t context, void* ptr, size_t pages) { + (void)context; + (void)ptr; + (void)pages; + return 0; +} + +int sceAjmMemoryUnregister(uint32_t context, void* ptr) { + (void)context; + (void)ptr; + return 0; +} + +int sceAjmModuleRegister(uint32_t context, uint32_t codec, int64_t reserved) { + (void)context; + (void)codec; + (void)reserved; + return 0; +} + +int sceAjmModuleUnregister(uint32_t context, uint32_t codec) { + (void)context; + (void)codec; + return 0; +} + +const char* sceAjmStrError(int error) { + (void)error; + return nullptr; +} + +} diff --git a/core/libs/prx/libSceAppContent/Export.cpp b/core/libs/prx/libSceAppContent/Export.cpp new file mode 100644 index 000000000..faf6d1471 --- /dev/null +++ b/core/libs/prx/libSceAppContent/Export.cpp @@ -0,0 +1,54 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAppContentAddcontMount(uint32_t service_label, const NpUnifiedEntitlementLabel* entitlement_label, AppContentMountPoint* mount_point) { + (void)service_label; + (void)entitlement_label; + (void)mount_point; + return 0; +} + +int sceAppContentAddcontUnmount(const AppContentMountPoint* mount_point) { + (void)mount_point; + return 0; +} + +int sceAppContentAppParamGetInt(uint32_t param_id, int32_t* value) { + (void)param_id; + (void)value; + return 0; +} + +int sceAppContentDownloadDataGetAvailableSpaceKb(const AppContentMountPoint* mount_point, size_t* available_space_kb) { + (void)mount_point; + (void)available_space_kb; + return 0; +} + +int sceAppContentInitialize(const AppContentInitParam* init_param, AppContentBootParam* boot_param) { + (void)init_param; + (void)boot_param; + return 0; +} + +int sceAppContentTemporaryDataFormat(const AppContentMountPoint* mount_point) { + (void)mount_point; + return 0; +} + +int sceAppContentTemporaryDataGetAvailableSpaceKb(const AppContentMountPoint* mount_point, size_t* available_space_kb) { + (void)mount_point; + (void)available_space_kb; + return 0; +} + +int sceAppContentTemporaryDataMount2(uint32_t option, AppContentMountPoint* mount_point) { + (void)option; + (void)mount_point; + return 0; +} + +} diff --git a/core/libs/libSceAudio/Export.cpp b/core/libs/prx/libSceAudio/Export.cpp similarity index 96% rename from core/libs/libSceAudio/Export.cpp rename to core/libs/prx/libSceAudio/Export.cpp index fe585c304..0eb2b2072 100644 --- a/core/libs/libSceAudio/Export.cpp +++ b/core/libs/prx/libSceAudio/Export.cpp @@ -1,4 +1,5 @@ #include +#include "SceTypes.hpp" extern "C" { diff --git a/core/libs/prx/libSceAudio3d/Export.cpp b/core/libs/prx/libSceAudio3d/Export.cpp new file mode 100644 index 000000000..829b7c8f5 --- /dev/null +++ b/core/libs/prx/libSceAudio3d/Export.cpp @@ -0,0 +1,49 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +void sceAudio3dGetDefaultOpenParameters(Audio3dOpenParameters* p) { + (void)p; +} + +int sceAudio3dInitialize(int64_t reserved) { + (void)reserved; + return 0; +} + +int sceAudio3dPortAdvance(uint32_t port_id) { + (void)port_id; + return 0; +} + +int sceAudio3dPortGetQueueLevel(uint32_t port_id, uint32_t* queue_level, uint32_t* queue_available) { + (void)port_id; + (void)queue_level; + (void)queue_available; + return 0; +} + +int sceAudio3dPortOpen(int user_id, const Audio3dOpenParameters* parameters, uint32_t* id) { + (void)user_id; + (void)parameters; + (void)id; + return 0; +} + +int sceAudio3dPortPush(uint32_t port_id, uint32_t blocking) { + (void)port_id; + (void)blocking; + return 0; +} + +int sceAudio3dPortSetAttribute(uint32_t port_id, uint32_t attribute_id, const void* attribute, size_t attribute_size) { + (void)port_id; + (void)attribute_id; + (void)attribute; + (void)attribute_size; + return 0; +} + +} diff --git a/core/libs/prx/libSceAudioIn/Export.cpp b/core/libs/prx/libSceAudioIn/Export.cpp new file mode 100644 index 000000000..e69870da5 --- /dev/null +++ b/core/libs/prx/libSceAudioIn/Export.cpp @@ -0,0 +1,28 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAudioInGetSilentState(int handle) { + (void)handle; + return 0; +} + +int sceAudioInInput(int handle, void* dest) { + (void)handle; + (void)dest; + return 0; +} + +int sceAudioInOpen(int user_id, uint32_t type, uint32_t index, uint32_t len, uint32_t freq, uint32_t param) { + (void)user_id; + (void)type; + (void)index; + (void)len; + (void)freq; + (void)param; + return 0; +} + +} diff --git a/core/libs/prx/libSceAudioOut/Export.cpp b/core/libs/prx/libSceAudioOut/Export.cpp new file mode 100644 index 000000000..ca12cf612 --- /dev/null +++ b/core/libs/prx/libSceAudioOut/Export.cpp @@ -0,0 +1,217 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAudioOut2ContextAdvance(AudioOut2ContextHandle ctx) { + (void)ctx; + return 0; +} + +int sceAudioOut2ContextCreate(const AudioOut2ContextParam* params, void* buffer, size_t buffer_size, AudioOut2ContextHandle* ctx) { + (void)params; + (void)buffer; + (void)buffer_size; + (void)ctx; + return 0; +} + +int sceAudioOut2ContextDestroy(AudioOut2ContextHandle ctx) { + (void)ctx; + return 0; +} + +int sceAudioOut2ContextGetQueueLevel(AudioOut2ContextHandle ctx, uint32_t* queue_level, uint32_t* available_queues) { + (void)ctx; + (void)queue_level; + (void)available_queues; + return 0; +} + +int sceAudioOut2ContextPush(AudioOut2ContextHandle ctx, uint32_t blocking) { + (void)ctx; + (void)blocking; + return 0; +} + +int sceAudioOut2ContextQueryMemory(const AudioOut2ContextParam* params, size_t* memory_size) { + (void)params; + (void)memory_size; + return 0; +} + +int sceAudioOut2ContextResetParam(AudioOut2ContextParam* params) { + (void)params; + return 0; +} + +int sceAudioOut2ContextSetAttributes(AudioOut2ContextHandle ctx, const AudioOut2Attribute* attributes, uint32_t num) { + (void)ctx; + (void)attributes; + (void)num; + return 0; +} + +int sceAudioOut2GetSpeakerArrayAmbisonicsCoefficients(AudioOut2SpeakerArrayHandle handle, uint32_t ambisonics_channel, float* coefficients, uint32_t num_coefficients) { + (void)handle; + (void)ambisonics_channel; + (void)coefficients; + (void)num_coefficients; + return 0; +} + +int sceAudioOut2GetSpeakerArrayCoefficients(AudioOut2SpeakerArrayHandle handle, AudioOut2Position pos, float spread, float* coefficients, uint32_t num_coefficients, uint8_t height_aware, float downmix_spread_radius) { + (void)handle; + (void)pos; + (void)spread; + (void)coefficients; + (void)num_coefficients; + (void)height_aware; + (void)downmix_spread_radius; + return 0; +} + +size_t sceAudioOut2GetSpeakerArrayMemorySize(uint32_t num_speakers, uint8_t is_3d, uint8_t is_ambisonics) { + (void)num_speakers; + (void)is_3d; + (void)is_ambisonics; + return 0; +} + +int sceAudioOut2GetSpeakerInfo(AudioOut2SpeakerInfo* info, uint32_t flags) { + (void)info; + (void)flags; + return 0; +} + +int sceAudioOut2GetSystemState(AudioOut2SystemState* state) { + (void)state; + return 0; +} + +int sceAudioOut2Initialize(void) { + return 0; +} + +int sceAudioOut2MasteringGetState(AudioOut2MasteringStatesHeader* state, uint32_t output, AudioOut2UserHandle user) { + (void)state; + (void)output; + (void)user; + return 0; +} + +int sceAudioOut2MasteringInit(uint32_t flags) { + (void)flags; + return 0; +} + +int sceAudioOut2MasteringSetParam(const AudioOut2MasteringParamsHeader* param, uint32_t output, uint32_t flags) { + (void)param; + (void)output; + (void)flags; + return 0; +} + +int sceAudioOut2MasteringTerm(void) { + return 0; +} + +int sceAudioOut2PortCreate(AudioOut2ContextHandle ctx, const AudioOut2PortParam* params, AudioOut2PortHandle* port) { + (void)ctx; + (void)params; + (void)port; + return 0; +} + +int sceAudioOut2PortDestroy(AudioOut2PortHandle port) { + (void)port; + return 0; +} + +int sceAudioOut2PortGetState(AudioOut2PortHandle port, AudioOut2PortState* state) { + (void)port; + (void)state; + return 0; +} + +int sceAudioOut2PortSetAttributes(AudioOut2PortHandle port, const AudioOut2Attribute* attributes, uint32_t num) { + (void)port; + (void)attributes; + (void)num; + return 0; +} + +int sceAudioOut2SetSystemDebugState(const AudioOut2SystemDebugStateParam* param) { + (void)param; + return 0; +} + +int sceAudioOut2SpeakerArrayCreate(AudioOut2SpeakerArrayHandle* handle, const void* vbap_params, const void* ambi_params) { + (void)handle; + (void)vbap_params; + (void)ambi_params; + return 0; +} + +int sceAudioOut2SpeakerArrayDestroy(AudioOut2SpeakerArrayHandle handle) { + (void)handle; + return 0; +} + +int sceAudioOut2UserCreate(uint32_t user_id, AudioOut2UserHandle* handle) { + (void)user_id; + (void)handle; + return 0; +} + +int sceAudioOut2UserDestroy(AudioOut2UserHandle handle) { + (void)handle; + return 0; +} + +int sceAudioOutClose(int handle) { + (void)handle; + return 0; +} + +int sceAudioOutGetPortState(int handle, AudioOutPortState* state) { + (void)handle; + (void)state; + return 0; +} + +int sceAudioOutInit(void) { + return 0; +} + +int sceAudioOutOpen(int user_id, int type, int index, uint32_t len, uint32_t freq, uint32_t param) { + (void)user_id; + (void)type; + (void)index; + (void)len; + (void)freq; + (void)param; + return 0; +} + +int sceAudioOutOutput(int handle, const void* ptr) { + (void)handle; + (void)ptr; + return 0; +} + +int sceAudioOutOutputs(AudioOutOutputParam* param, uint32_t num) { + (void)param; + (void)num; + return 0; +} + +int sceAudioOutSetVolume(int handle, uint32_t flag, int* vol) { + (void)handle; + (void)flag; + (void)vol; + return 0; +} + +} diff --git a/core/libs/prx/libSceAudioPropagation/Export.cpp b/core/libs/prx/libSceAudioPropagation/Export.cpp new file mode 100644 index 000000000..3764e5b10 --- /dev/null +++ b/core/libs/prx/libSceAudioPropagation/Export.cpp @@ -0,0 +1,47 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int32_t sceAudioPropagationRoomCreate(AudioPropagationHandle system_handle, AudioPropagationHandle* out_room_handle) { + (void)system_handle; + (void)out_room_handle; + return 0; +} + +int32_t sceAudioPropagationSystemCreate(const void* options, AudioPropagationSystemMemory* memory, AudioPropagationHandle* out_system_handle) { + (void)options; + (void)memory; + (void)out_system_handle; + return 0; +} + +int32_t sceAudioPropagationSystemGetRays(AudioPropagationHandle system_handle, void* rays, uint32_t* num_rays) { + (void)system_handle; + (void)rays; + (void)num_rays; + return 0; +} + +int32_t sceAudioPropagationSystemQueryMemory(const void* options, AudioPropagationSystemMemory* out_memory) { + (void)options; + (void)out_memory; + return 0; +} + +int32_t sceAudioPropagationSystemRegisterMaterial(AudioPropagationHandle system_handle, const void* material, AudioPropagationHandle* out_material_handle) { + (void)system_handle; + (void)material; + (void)out_material_handle; + return 0; +} + +int32_t sceAudioPropagationSystemSetAttributes(AudioPropagationHandle system_handle, const void* attributes, uint32_t num_attributes) { + (void)system_handle; + (void)attributes; + (void)num_attributes; + return 0; +} + +} diff --git a/core/libs/prx/libSceAudiodec.native/Export.cpp b/core/libs/prx/libSceAudiodec.native/Export.cpp new file mode 100644 index 000000000..388cda8f3 --- /dev/null +++ b/core/libs/prx/libSceAudiodec.native/Export.cpp @@ -0,0 +1,39 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int32_t sceAudiodecClearContext(int32_t handle) { + (void)handle; + return 0; +} + +int32_t sceAudiodecCreateDecoder(AudiodecCtrl* ctrl, uint32_t codec_type) { + (void)ctrl; + (void)codec_type; + return 0; +} + +int32_t sceAudiodecDecode(int32_t handle, AudiodecCtrl* ctrl) { + (void)handle; + (void)ctrl; + return 0; +} + +int32_t sceAudiodecDeleteDecoder(int32_t handle) { + (void)handle; + return 0; +} + +int32_t sceAudiodecInitLibrary(uint32_t codec_type) { + (void)codec_type; + return 0; +} + +int32_t sceAudiodecTermLibrary(uint32_t codec_type) { + (void)codec_type; + return 0; +} + +} diff --git a/core/libs/prx/libSceAudiodec/Export.cpp b/core/libs/prx/libSceAudiodec/Export.cpp new file mode 100644 index 000000000..388cda8f3 --- /dev/null +++ b/core/libs/prx/libSceAudiodec/Export.cpp @@ -0,0 +1,39 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int32_t sceAudiodecClearContext(int32_t handle) { + (void)handle; + return 0; +} + +int32_t sceAudiodecCreateDecoder(AudiodecCtrl* ctrl, uint32_t codec_type) { + (void)ctrl; + (void)codec_type; + return 0; +} + +int32_t sceAudiodecDecode(int32_t handle, AudiodecCtrl* ctrl) { + (void)handle; + (void)ctrl; + return 0; +} + +int32_t sceAudiodecDeleteDecoder(int32_t handle) { + (void)handle; + return 0; +} + +int32_t sceAudiodecInitLibrary(uint32_t codec_type) { + (void)codec_type; + return 0; +} + +int32_t sceAudiodecTermLibrary(uint32_t codec_type) { + (void)codec_type; + return 0; +} + +} diff --git a/core/libs/prx/libSceAvPlayer.native/Export.cpp b/core/libs/prx/libSceAvPlayer.native/Export.cpp new file mode 100644 index 000000000..77145800f --- /dev/null +++ b/core/libs/prx/libSceAvPlayer.native/Export.cpp @@ -0,0 +1,166 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAvPlayerAddSource(AvPlayerInternal* h, const char* filename) { + (void)h; + (void)filename; + return 0; +} + +int sceAvPlayerAddSourceEx(AvPlayerInternal* h, uint32_t uri_type, const void* source_details) { + (void)h; + (void)uri_type; + (void)source_details; + return 0; +} + +int sceAvPlayerChangeStream(AvPlayerInternal* h, uint32_t old_stream_id, uint32_t new_stream_id) { + (void)h; + (void)old_stream_id; + (void)new_stream_id; + return 0; +} + +int sceAvPlayerClose(AvPlayerInternal* h) { + (void)h; + return 0; +} + +uint64_t sceAvPlayerCurrentTime(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerDisableStream(AvPlayerInternal* h, uint32_t stream_id) { + (void)h; + (void)stream_id; + return 0; +} + +int sceAvPlayerEnableStream(AvPlayerInternal* h, uint32_t stream_id) { + (void)h; + (void)stream_id; + return 0; +} + +Bool sceAvPlayerGetAudioData(AvPlayerInternal* h, AvPlayerFrameInfo* audio_info) { + (void)h; + (void)audio_info; + return {}; +} + +int sceAvPlayerGetStreamInfo(AvPlayerInternal* h, uint32_t stream_id, void* info) { + (void)h; + (void)stream_id; + (void)info; + return 0; +} + +int sceAvPlayerGetStreamInfoEx(AvPlayerInternal* h, uint32_t stream_id, void* info) { + (void)h; + (void)stream_id; + (void)info; + return 0; +} + +Bool sceAvPlayerGetVideoDataEx(AvPlayerInternal* h, AvPlayerFrameInfoEx* video_info) { + (void)h; + (void)video_info; + return {}; +} + +AvPlayerInternal* sceAvPlayerInit(AvPlayerInitData* init) { + (void)init; + return nullptr; +} + +int sceAvPlayerInitEx(const void* init_ex, AvPlayerInternal** handle) { + (void)init_ex; + (void)handle; + return 0; +} + +Bool sceAvPlayerIsActive(AvPlayerInternal* h) { + (void)h; + return {}; +} + +int sceAvPlayerJumpToTime(AvPlayerInternal* h, uint64_t time_ms) { + (void)h; + (void)time_ms; + return 0; +} + +int sceAvPlayerPause(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerPostInit(AvPlayerInternal* h, const void* post_init) { + (void)h; + (void)post_init; + return 0; +} + +int sceAvPlayerResume(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerSetAvailableBandwidth(AvPlayerInternal* h, uint32_t start_bandwidth, uint32_t minimum_bandwidth, uint32_t maximum_bandwidth) { + (void)h; + (void)start_bandwidth; + (void)minimum_bandwidth; + (void)maximum_bandwidth; + return 0; +} + +int sceAvPlayerSetAvSyncMode(AvPlayerInternal* h, uint32_t sync_mode) { + (void)h; + (void)sync_mode; + return 0; +} + +int sceAvPlayerSetLogCallback(void* callback, void* user_data) { + (void)callback; + (void)user_data; + return 0; +} + +int sceAvPlayerSetLooping(AvPlayerInternal* h, Bool loop) { + (void)h; + (void)loop; + return 0; +} + +int sceAvPlayerSetTrickSpeed(AvPlayerInternal* h, int32_t trick_speed) { + (void)h; + (void)trick_speed; + return 0; +} + +int sceAvPlayerStart(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerStartEx(AvPlayerInternal* h, const void* start_info_ex) { + (void)h; + (void)start_info_ex; + return 0; +} + +int sceAvPlayerStop(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerStreamCount(AvPlayerInternal* h) { + (void)h; + return 0; +} + +} diff --git a/core/libs/prx/libSceAvPlayer/Export.cpp b/core/libs/prx/libSceAvPlayer/Export.cpp new file mode 100644 index 000000000..a6240f81e --- /dev/null +++ b/core/libs/prx/libSceAvPlayer/Export.cpp @@ -0,0 +1,151 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceAvPlayerAddSource(AvPlayerInternal* h, const char* filename) { + (void)h; + (void)filename; + return 0; +} + +int sceAvPlayerAddSourceEx(AvPlayerInternal* h, uint32_t uri_type, const void* source_details) { + (void)h; + (void)uri_type; + (void)source_details; + return 0; +} + +int sceAvPlayerChangeStream(AvPlayerInternal* h, uint32_t old_stream_id, uint32_t new_stream_id) { + (void)h; + (void)old_stream_id; + (void)new_stream_id; + return 0; +} + +int sceAvPlayerClose(AvPlayerInternal* h) { + (void)h; + return 0; +} + +uint64_t sceAvPlayerCurrentTime(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerDisableStream(AvPlayerInternal* h, uint32_t stream_id) { + (void)h; + (void)stream_id; + return 0; +} + +int sceAvPlayerEnableStream(AvPlayerInternal* h, uint32_t stream_id) { + (void)h; + (void)stream_id; + return 0; +} + +Bool sceAvPlayerGetAudioData(AvPlayerInternal* h, AvPlayerFrameInfo* audio_info) { + (void)h; + (void)audio_info; + return {}; +} + +int sceAvPlayerGetStreamInfo(AvPlayerInternal* h, uint32_t stream_id, void* info) { + (void)h; + (void)stream_id; + (void)info; + return 0; +} + +Bool sceAvPlayerGetVideoData(AvPlayerInternal* h, AvPlayerFrameInfo* video_info) { + (void)h; + (void)video_info; + return {}; +} + +Bool sceAvPlayerGetVideoDataEx(AvPlayerInternal* h, AvPlayerFrameInfoEx* video_info) { + (void)h; + (void)video_info; + return {}; +} + +AvPlayerInternal* sceAvPlayerInit(AvPlayerInitData* init) { + (void)init; + return nullptr; +} + +int sceAvPlayerInitEx(const void* init_ex, AvPlayerInternal** handle) { + (void)init_ex; + (void)handle; + return 0; +} + +Bool sceAvPlayerIsActive(AvPlayerInternal* h) { + (void)h; + return {}; +} + +int sceAvPlayerJumpToTime(AvPlayerInternal* h, uint64_t time_ms) { + (void)h; + (void)time_ms; + return 0; +} + +int sceAvPlayerPause(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerPostInit(AvPlayerInternal* h, const void* post_init) { + (void)h; + (void)post_init; + return 0; +} + +int sceAvPlayerResume(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerSetAvSyncMode(AvPlayerInternal* h, uint32_t sync_mode) { + (void)h; + (void)sync_mode; + return 0; +} + +int sceAvPlayerSetLogCallback(void* callback, void* user_data) { + (void)callback; + (void)user_data; + return 0; +} + +int sceAvPlayerSetLooping(AvPlayerInternal* h, Bool loop) { + (void)h; + (void)loop; + return 0; +} + +int sceAvPlayerSetTrickSpeed(AvPlayerInternal* h, int32_t trick_speed) { + (void)h; + (void)trick_speed; + return 0; +} + +int sceAvPlayerStart(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerStop(AvPlayerInternal* h) { + (void)h; + return 0; +} + +int sceAvPlayerStreamCount(AvPlayerInternal* h) { + (void)h; + return 0; +} + +} diff --git a/core/libs/prx/libSceCesCs/Export.cpp b/core/libs/prx/libSceCesCs/Export.cpp new file mode 100644 index 000000000..6a47655b7 --- /dev/null +++ b/core/libs/prx/libSceCesCs/Export.cpp @@ -0,0 +1,29 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +const uint8_t* sceCesRefersUcsProfileCp1252(void) { + return nullptr; +} + +int sceCesSbcToUtf8(const uint8_t* profile, uint8_t sbc, uint8_t* utf8, uint32_t utf8max, uint32_t* utf8_len) { + (void)profile; + (void)sbc; + (void)utf8; + (void)utf8max; + (void)utf8_len; + return 0; +} + +int sceCesUtf8ToSbc(const uint8_t* utf8, uint32_t utf8max, uint32_t* utf8_len, const uint8_t* profile, uint8_t* sbc) { + (void)utf8; + (void)utf8max; + (void)utf8_len; + (void)profile; + (void)sbc; + return 0; +} + +} diff --git a/core/libs/prx/libSceCommonDialog/Export.cpp b/core/libs/prx/libSceCommonDialog/Export.cpp new file mode 100644 index 000000000..10342c22c --- /dev/null +++ b/core/libs/prx/libSceCommonDialog/Export.cpp @@ -0,0 +1,15 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceCommonDialogInitialize(void) { + return 0; +} + +bool sceCommonDialogIsUsed(void) { + return false; +} + +} diff --git a/core/libs/prx/libSceContentDelete/Export.cpp b/core/libs/prx/libSceContentDelete/Export.cpp new file mode 100644 index 000000000..09c0307af --- /dev/null +++ b/core/libs/prx/libSceContentDelete/Export.cpp @@ -0,0 +1,12 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceContentDeleteInitialize(const ContentDeleteInitParam* init_param) { + (void)init_param; + return 0; +} + +} diff --git a/core/libs/prx/libSceContentExport/Export.cpp b/core/libs/prx/libSceContentExport/Export.cpp new file mode 100644 index 000000000..40d4467bd --- /dev/null +++ b/core/libs/prx/libSceContentExport/Export.cpp @@ -0,0 +1,12 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceContentExportInit2(const ContentExportInitParam2* init_param) { + (void)init_param; + return 0; +} + +} diff --git a/core/libs/prx/libSceContentSearch/Export.cpp b/core/libs/prx/libSceContentSearch/Export.cpp new file mode 100644 index 000000000..598334408 --- /dev/null +++ b/core/libs/prx/libSceContentSearch/Export.cpp @@ -0,0 +1,12 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceContentSearchInit(const ContentSearchInitParam* init_param) { + (void)init_param; + return 0; +} + +} diff --git a/core/libs/prx/libSceErrorDialog/Export.cpp b/core/libs/prx/libSceErrorDialog/Export.cpp new file mode 100644 index 000000000..f987be55c --- /dev/null +++ b/core/libs/prx/libSceErrorDialog/Export.cpp @@ -0,0 +1,32 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceErrorDialogClose(void) { + return 0; +} + +int sceErrorDialogGetStatus(void) { + return 0; +} + +int sceErrorDialogInitialize(void) { + return 0; +} + +int sceErrorDialogOpen(const void* param) { + (void)param; + return 0; +} + +int sceErrorDialogTerminate(void) { + return 0; +} + +int sceErrorDialogUpdateStatus(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceFiber/Export.cpp b/core/libs/prx/libSceFiber/Export.cpp new file mode 100644 index 000000000..1c444c22a --- /dev/null +++ b/core/libs/prx/libSceFiber/Export.cpp @@ -0,0 +1,68 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int32_t sceFiberFinalize(FiberObject* fiber) { + (void)fiber; + return 0; +} + +int32_t sceFiberGetInfo(FiberObject* fiber, FiberInfo* fiber_info) { + (void)fiber; + (void)fiber_info; + return 0; +} + +int32_t sceFiberGetSelf(FiberObject** fiber) { + (void)fiber; + return 0; +} + +int32_t sceFiberGetThreadFramePointerAddress(uint64_t* addr_frame_pointer) { + (void)addr_frame_pointer; + return 0; +} + +int32_t sceFiberOptParamInitialize(FiberOptParam* opt_param) { + (void)opt_param; + return 0; +} + +int32_t sceFiberRename(FiberObject* fiber, const char* name) { + (void)fiber; + (void)name; + return 0; +} + +int32_t sceFiberReturnToThread(uint64_t arg_on_return, uint64_t* arg_on_run) { + (void)arg_on_return; + (void)arg_on_run; + return 0; +} + +int32_t sceFiberRun(FiberObject* fiber, uint64_t arg_on_run, uint64_t* arg_on_return) { + (void)fiber; + (void)arg_on_run; + (void)arg_on_return; + return 0; +} + +int32_t sceFiberStartContextSizeCheck(uint32_t flags) { + (void)flags; + return 0; +} + +int32_t sceFiberStopContextSizeCheck(void) { + return 0; +} + +int32_t sceFiberSwitch(FiberObject* fiber, uint64_t arg_on_run, uint64_t* arg_on_return) { + (void)fiber; + (void)arg_on_run; + (void)arg_on_return; + return 0; +} + +} diff --git a/core/libs/prx/libSceFont.native/Export.cpp b/core/libs/prx/libSceFont.native/Export.cpp new file mode 100644 index 000000000..df78c5098 --- /dev/null +++ b/core/libs/prx/libSceFont.native/Export.cpp @@ -0,0 +1,451 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceFontAttachDeviceCacheBuffer(FontLibrary library, void* buffer, uint32_t size) { + (void)library; + (void)buffer; + (void)size; + return 0; +} + +int sceFontBindRenderer(FontHandle font_handle, FontRenderer renderer) { + (void)font_handle; + (void)renderer; + return 0; +} + +int sceFontCharacterGetBidiLevel(FontTextCharacter text_character, int* bidi_level) { + (void)text_character; + (void)bidi_level; + return 0; +} + +int sceFontCharacterGetSyllableStringState(FontTextCharacter text_character, int* syllable_string_state) { + (void)text_character; + (void)syllable_string_state; + return 0; +} + +int sceFontCharacterGetTextFontCode(FontTextCharacter text_character, FontHandle* font_handle, uint32_t* text_code) { + (void)text_character; + (void)font_handle; + (void)text_code; + return 0; +} + +int sceFontCharacterGetTextOrder(FontTextCharacter text_character, void** text_order) { + (void)text_character; + (void)text_order; + return 0; +} + +uint32_t sceFontCharacterLooksFormatCharacters(FontTextCharacter text_character) { + (void)text_character; + return 0; +} + +uint32_t sceFontCharacterLooksWhiteSpace(FontTextCharacter text_character) { + (void)text_character; + return 0; +} + +FontTextCharacter sceFontCharacterRefersTextBack(FontTextCharacter text_character) { + (void)text_character; + return {}; +} + +FontTextCharacter sceFontCharacterRefersTextNext(FontTextCharacter text_character) { + (void)text_character; + return {}; +} + +FontTextCodes* sceFontCharactersRefersTextCodes(FontTextCharacter text_character, FontTextCharacter term_character, FontTextCodes* text_codes) { + (void)text_character; + (void)term_character; + (void)text_codes; + return nullptr; +} + +int sceFontCloseFont(FontHandle font_handle) { + (void)font_handle; + return 0; +} + +int sceFontCreateLibrary(const FontMemory* memory, FontLibrarySelection selection, FontLibrary* library) { + (void)memory; + (void)selection; + (void)library; + return 0; +} + +int sceFontCreateLibraryWithEdition(const FontMemory* memory, FontLibrarySelection selection, uint64_t edition, FontLibrary* library) { + (void)memory; + (void)selection; + (void)edition; + (void)library; + return 0; +} + +int sceFontCreateRendererWithEdition(const FontMemory* memory, FontRendererSelection selection, uint64_t edition, FontRenderer* renderer) { + (void)memory; + (void)selection; + (void)edition; + (void)renderer; + return 0; +} + +int sceFontCreateString(const FontMemory* memory, FontTextSource* font_text_source, const FontCreateStringDetail* string_detail, FontString* font_string) { + (void)memory; + (void)font_text_source; + (void)string_detail; + (void)font_string; + return 0; +} + +int sceFontCreateWritingLine(const FontMemory* memory, int writing_form, const void* writing_line_detail, FontWritingLine* writing_line) { + (void)memory; + (void)writing_form; + (void)writing_line_detail; + (void)writing_line; + return 0; +} + +int sceFontDefineAttribute(FontHandle font_handle, int attribute, int* old_attribute) { + (void)font_handle; + (void)attribute; + (void)old_attribute; + return 0; +} + +int sceFontDeleteGlyph(const FontMemory* memory, void** font_glyph) { + (void)memory; + (void)font_glyph; + return 0; +} + +int sceFontDestroyLibrary(FontLibrary* library) { + (void)library; + return 0; +} + +int sceFontDestroyRenderer(FontRenderer* renderer) { + (void)renderer; + return 0; +} + +int sceFontDestroyString(FontString* font_string) { + (void)font_string; + return 0; +} + +int sceFontDestroyWritingLine(FontWritingLine* writing_line) { + (void)writing_line; + return 0; +} + +int sceFontGenerateCharGlyph(FontHandle font_handle, uint32_t code, const FontGenerateGlyphDetail* detail, void** font_glyph) { + (void)font_handle; + (void)code; + (void)detail; + (void)font_glyph; + return 0; +} + +int sceFontGetCharGlyphMetrics(FontHandle font_handle, uint32_t code, FontGlyphMetrics* metrics) { + (void)font_handle; + (void)code; + (void)metrics; + return 0; +} + +int sceFontGetHorizontalLayout(FontHandle font_handle, FontHorizontalLayout* layout) { + (void)font_handle; + (void)layout; + return 0; +} + +int sceFontGetRenderCharGlyphMetrics(FontHandle font_handle, uint32_t code, FontGlyphMetrics* metrics) { + (void)font_handle; + (void)code; + (void)metrics; + return 0; +} + +int sceFontGetVerticalLayout(FontHandle font_handle, FontVerticalLayout* layout) { + (void)font_handle; + (void)layout; + return 0; +} + +int sceFontGlyphDefineAttribute(void* font_glyph, int attribute, int* old_attribute) { + (void)font_glyph; + (void)attribute; + (void)old_attribute; + return 0; +} + +int sceFontMemoryInit(FontMemory* font_memory, void* address, uint32_t size_byte, const FontMemoryInterface* mem_interface, void* mspace_object, FontMemoryDestroyCallback destroy_callback, void* destroy_object) { + (void)font_memory; + (void)address; + (void)size_byte; + (void)mem_interface; + (void)mspace_object; + (void)destroy_callback; + (void)destroy_object; + return 0; +} + +int sceFontMemoryTerm(FontMemory* font_memory) { + (void)font_memory; + return 0; +} + +int sceFontOpenFontInstance(FontHandle font_handle, void* setup_font, FontHandle* out_font_handle) { + (void)font_handle; + (void)setup_font; + (void)out_font_handle; + return 0; +} + +int sceFontOpenFontMemory(FontLibrary library, const void* font_address, uint32_t font_size, const FontOpenDetail* detail, FontHandle* handle) { + (void)library; + (void)font_address; + (void)font_size; + (void)detail; + (void)handle; + return 0; +} + +int sceFontOpenFontSet(FontLibrary library, uint32_t font_set_type, uint32_t open_mode, const FontOpenDetail* detail, FontHandle* handle) { + (void)library; + (void)font_set_type; + (void)open_mode; + (void)detail; + (void)handle; + return 0; +} + +int sceFontRebindRenderer(FontHandle font_handle) { + (void)font_handle; + return 0; +} + +int sceFontRenderCharGlyphImageHorizontal(FontHandle font_handle, uint32_t code, FontRenderSurface* surf, float x, float y, FontGlyphMetrics* metrics, FontRenderResult* result) { + (void)font_handle; + (void)code; + (void)surf; + (void)x; + (void)y; + (void)metrics; + (void)result; + return 0; +} + +void sceFontRenderSurfaceInit(FontRenderSurface* surf, void* buffer, int buf_width_byte, int pixel_size_byte, int width, int height) { + (void)surf; + (void)buffer; + (void)buf_width_byte; + (void)pixel_size_byte; + (void)width; + (void)height; +} + +void sceFontRenderSurfaceSetScissor(FontRenderSurface* surf, uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1) { + (void)surf; + (void)x0; + (void)y0; + (void)x1; + (void)y1; +} + +int sceFontSetEffectSlant(FontHandle font_handle, float slant_ratio) { + (void)font_handle; + (void)slant_ratio; + return 0; +} + +int sceFontSetEffectWeight(FontHandle font_handle, float weight_x_scale, float weight_y_scale, uint32_t mode) { + (void)font_handle; + (void)weight_x_scale; + (void)weight_y_scale; + (void)mode; + return 0; +} + +int sceFontSetScalePixel(FontHandle font_handle, float w, float h) { + (void)font_handle; + (void)w; + (void)h; + return 0; +} + +int sceFontSetupRenderEffectSlant(FontHandle font_handle, float slant_ratio) { + (void)font_handle; + (void)slant_ratio; + return 0; +} + +int sceFontSetupRenderEffectWeight(FontHandle font_handle, float weight_x_scale, float weight_y_scale, uint32_t mode) { + (void)font_handle; + (void)weight_x_scale; + (void)weight_y_scale; + (void)mode; + return 0; +} + +int sceFontSetupRenderScalePixel(FontHandle font_handle, float w, float h) { + (void)font_handle; + (void)w; + (void)h; + return 0; +} + +uint32_t sceFontStringGetTerminateCode(FontString font_string) { + (void)font_string; + return 0; +} + +void* sceFontStringGetTerminateOrder(FontString font_string) { + (void)font_string; + return nullptr; +} + +int sceFontStringGetWritingForm(FontString font_string) { + (void)font_string; + return 0; +} + +FontRenderCharacter sceFontStringRefersRenderCharacters(FontString font_string, FontTextCharacter start_character, FontTextCharacter last_character, uint32_t* character_count) { + (void)font_string; + (void)start_character; + (void)last_character; + (void)character_count; + return {}; +} + +FontTextCharacter sceFontStringRefersTextCharacters(FontString font_string, uint32_t* character_count) { + (void)font_string; + (void)character_count; + return {}; +} + +int sceFontSupportExternalFonts(FontLibrary library, uint32_t font_max, uint32_t formats) { + (void)library; + (void)font_max; + (void)formats; + return 0; +} + +int sceFontSupportSystemFonts(FontLibrary library) { + (void)library; + return 0; +} + +FontTextCodes* sceFontTextCodesStepBack(FontTextCodes* text_codes_step) { + (void)text_codes_step; + return nullptr; +} + +FontTextCodes* sceFontTextCodesStepNext(FontTextCodes* text_codes_step) { + (void)text_codes_step; + return nullptr; +} + +int sceFontTextSourceInit(FontTextSource* font_text_source, const void* text_address, uint32_t text_size_byte, FontTextParseFunction text_parser, void* text_object) { + (void)font_text_source; + (void)text_address; + (void)text_size_byte; + (void)text_parser; + (void)text_object; + return 0; +} + +int sceFontTextSourceRewind(FontTextSource* font_text_source) { + (void)font_text_source; + return 0; +} + +int sceFontTextSourceSetDefaultFont(FontTextSource* font_text_source, FontHandle default_font) { + (void)font_text_source; + (void)default_font; + return 0; +} + +int sceFontTextSourceSetWritingForm(FontTextSource* font_text_source, int writing_form) { + (void)font_text_source; + (void)writing_form; + return 0; +} + +int sceFontUnbindRenderer(FontHandle font_handle) { + (void)font_handle; + return 0; +} + +int sceFontWritingGetRenderMetrics(FontWriting* font_writing, FontWritingMetrics* writing_metrics) { + (void)font_writing; + (void)writing_metrics; + return 0; +} + +int sceFontWritingInit(FontWriting* font_writing, FontString font_string, FontRenderCharacter font_character) { + (void)font_writing; + (void)font_string; + (void)font_character; + return 0; +} + +int sceFontWritingLineClear(FontWritingLine writing_line) { + (void)writing_line; + return 0; +} + +int sceFontWritingLineGetOrderingSpace(FontWritingLine writing_line, float* head_space, float* inline_space, float* tail_space, float* advance_space) { + (void)writing_line; + (void)head_space; + (void)inline_space; + (void)tail_space; + (void)advance_space; + return 0; +} + +int sceFontWritingLineGetRenderMetrics(FontWritingLine writing_line, FontWritingMetrics* writing_metrics) { + (void)writing_line; + (void)writing_metrics; + return 0; +} + +FontWritingLineStep* sceFontWritingLineRefersRenderStep(FontWritingLine writing_line) { + (void)writing_line; + return nullptr; +} + +int sceFontWritingLineWritesOrder(FontWritingLine writing_line, uint64_t writing_attribute, const FontWritingMetrics* writing_metrics, void* writing_orderer) { + (void)writing_line; + (void)writing_attribute; + (void)writing_metrics; + (void)writing_orderer; + return 0; +} + +const FontWritingStep* sceFontWritingRefersRenderStep(FontWriting* font_writing) { + (void)font_writing; + return nullptr; +} + +FontTextCharacter sceFontWritingRefersRenderStepCharacter(FontWriting* font_writing, const void** letter_step) { + (void)font_writing; + (void)letter_step; + return {}; +} + +int sceFontWritingSetMaskInvisible(FontWriting* font_writing, int mask) { + (void)font_writing; + (void)mask; + return 0; +} + +} diff --git a/core/libs/prx/libSceFont/Export.cpp b/core/libs/prx/libSceFont/Export.cpp new file mode 100644 index 000000000..df78c5098 --- /dev/null +++ b/core/libs/prx/libSceFont/Export.cpp @@ -0,0 +1,451 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceFontAttachDeviceCacheBuffer(FontLibrary library, void* buffer, uint32_t size) { + (void)library; + (void)buffer; + (void)size; + return 0; +} + +int sceFontBindRenderer(FontHandle font_handle, FontRenderer renderer) { + (void)font_handle; + (void)renderer; + return 0; +} + +int sceFontCharacterGetBidiLevel(FontTextCharacter text_character, int* bidi_level) { + (void)text_character; + (void)bidi_level; + return 0; +} + +int sceFontCharacterGetSyllableStringState(FontTextCharacter text_character, int* syllable_string_state) { + (void)text_character; + (void)syllable_string_state; + return 0; +} + +int sceFontCharacterGetTextFontCode(FontTextCharacter text_character, FontHandle* font_handle, uint32_t* text_code) { + (void)text_character; + (void)font_handle; + (void)text_code; + return 0; +} + +int sceFontCharacterGetTextOrder(FontTextCharacter text_character, void** text_order) { + (void)text_character; + (void)text_order; + return 0; +} + +uint32_t sceFontCharacterLooksFormatCharacters(FontTextCharacter text_character) { + (void)text_character; + return 0; +} + +uint32_t sceFontCharacterLooksWhiteSpace(FontTextCharacter text_character) { + (void)text_character; + return 0; +} + +FontTextCharacter sceFontCharacterRefersTextBack(FontTextCharacter text_character) { + (void)text_character; + return {}; +} + +FontTextCharacter sceFontCharacterRefersTextNext(FontTextCharacter text_character) { + (void)text_character; + return {}; +} + +FontTextCodes* sceFontCharactersRefersTextCodes(FontTextCharacter text_character, FontTextCharacter term_character, FontTextCodes* text_codes) { + (void)text_character; + (void)term_character; + (void)text_codes; + return nullptr; +} + +int sceFontCloseFont(FontHandle font_handle) { + (void)font_handle; + return 0; +} + +int sceFontCreateLibrary(const FontMemory* memory, FontLibrarySelection selection, FontLibrary* library) { + (void)memory; + (void)selection; + (void)library; + return 0; +} + +int sceFontCreateLibraryWithEdition(const FontMemory* memory, FontLibrarySelection selection, uint64_t edition, FontLibrary* library) { + (void)memory; + (void)selection; + (void)edition; + (void)library; + return 0; +} + +int sceFontCreateRendererWithEdition(const FontMemory* memory, FontRendererSelection selection, uint64_t edition, FontRenderer* renderer) { + (void)memory; + (void)selection; + (void)edition; + (void)renderer; + return 0; +} + +int sceFontCreateString(const FontMemory* memory, FontTextSource* font_text_source, const FontCreateStringDetail* string_detail, FontString* font_string) { + (void)memory; + (void)font_text_source; + (void)string_detail; + (void)font_string; + return 0; +} + +int sceFontCreateWritingLine(const FontMemory* memory, int writing_form, const void* writing_line_detail, FontWritingLine* writing_line) { + (void)memory; + (void)writing_form; + (void)writing_line_detail; + (void)writing_line; + return 0; +} + +int sceFontDefineAttribute(FontHandle font_handle, int attribute, int* old_attribute) { + (void)font_handle; + (void)attribute; + (void)old_attribute; + return 0; +} + +int sceFontDeleteGlyph(const FontMemory* memory, void** font_glyph) { + (void)memory; + (void)font_glyph; + return 0; +} + +int sceFontDestroyLibrary(FontLibrary* library) { + (void)library; + return 0; +} + +int sceFontDestroyRenderer(FontRenderer* renderer) { + (void)renderer; + return 0; +} + +int sceFontDestroyString(FontString* font_string) { + (void)font_string; + return 0; +} + +int sceFontDestroyWritingLine(FontWritingLine* writing_line) { + (void)writing_line; + return 0; +} + +int sceFontGenerateCharGlyph(FontHandle font_handle, uint32_t code, const FontGenerateGlyphDetail* detail, void** font_glyph) { + (void)font_handle; + (void)code; + (void)detail; + (void)font_glyph; + return 0; +} + +int sceFontGetCharGlyphMetrics(FontHandle font_handle, uint32_t code, FontGlyphMetrics* metrics) { + (void)font_handle; + (void)code; + (void)metrics; + return 0; +} + +int sceFontGetHorizontalLayout(FontHandle font_handle, FontHorizontalLayout* layout) { + (void)font_handle; + (void)layout; + return 0; +} + +int sceFontGetRenderCharGlyphMetrics(FontHandle font_handle, uint32_t code, FontGlyphMetrics* metrics) { + (void)font_handle; + (void)code; + (void)metrics; + return 0; +} + +int sceFontGetVerticalLayout(FontHandle font_handle, FontVerticalLayout* layout) { + (void)font_handle; + (void)layout; + return 0; +} + +int sceFontGlyphDefineAttribute(void* font_glyph, int attribute, int* old_attribute) { + (void)font_glyph; + (void)attribute; + (void)old_attribute; + return 0; +} + +int sceFontMemoryInit(FontMemory* font_memory, void* address, uint32_t size_byte, const FontMemoryInterface* mem_interface, void* mspace_object, FontMemoryDestroyCallback destroy_callback, void* destroy_object) { + (void)font_memory; + (void)address; + (void)size_byte; + (void)mem_interface; + (void)mspace_object; + (void)destroy_callback; + (void)destroy_object; + return 0; +} + +int sceFontMemoryTerm(FontMemory* font_memory) { + (void)font_memory; + return 0; +} + +int sceFontOpenFontInstance(FontHandle font_handle, void* setup_font, FontHandle* out_font_handle) { + (void)font_handle; + (void)setup_font; + (void)out_font_handle; + return 0; +} + +int sceFontOpenFontMemory(FontLibrary library, const void* font_address, uint32_t font_size, const FontOpenDetail* detail, FontHandle* handle) { + (void)library; + (void)font_address; + (void)font_size; + (void)detail; + (void)handle; + return 0; +} + +int sceFontOpenFontSet(FontLibrary library, uint32_t font_set_type, uint32_t open_mode, const FontOpenDetail* detail, FontHandle* handle) { + (void)library; + (void)font_set_type; + (void)open_mode; + (void)detail; + (void)handle; + return 0; +} + +int sceFontRebindRenderer(FontHandle font_handle) { + (void)font_handle; + return 0; +} + +int sceFontRenderCharGlyphImageHorizontal(FontHandle font_handle, uint32_t code, FontRenderSurface* surf, float x, float y, FontGlyphMetrics* metrics, FontRenderResult* result) { + (void)font_handle; + (void)code; + (void)surf; + (void)x; + (void)y; + (void)metrics; + (void)result; + return 0; +} + +void sceFontRenderSurfaceInit(FontRenderSurface* surf, void* buffer, int buf_width_byte, int pixel_size_byte, int width, int height) { + (void)surf; + (void)buffer; + (void)buf_width_byte; + (void)pixel_size_byte; + (void)width; + (void)height; +} + +void sceFontRenderSurfaceSetScissor(FontRenderSurface* surf, uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1) { + (void)surf; + (void)x0; + (void)y0; + (void)x1; + (void)y1; +} + +int sceFontSetEffectSlant(FontHandle font_handle, float slant_ratio) { + (void)font_handle; + (void)slant_ratio; + return 0; +} + +int sceFontSetEffectWeight(FontHandle font_handle, float weight_x_scale, float weight_y_scale, uint32_t mode) { + (void)font_handle; + (void)weight_x_scale; + (void)weight_y_scale; + (void)mode; + return 0; +} + +int sceFontSetScalePixel(FontHandle font_handle, float w, float h) { + (void)font_handle; + (void)w; + (void)h; + return 0; +} + +int sceFontSetupRenderEffectSlant(FontHandle font_handle, float slant_ratio) { + (void)font_handle; + (void)slant_ratio; + return 0; +} + +int sceFontSetupRenderEffectWeight(FontHandle font_handle, float weight_x_scale, float weight_y_scale, uint32_t mode) { + (void)font_handle; + (void)weight_x_scale; + (void)weight_y_scale; + (void)mode; + return 0; +} + +int sceFontSetupRenderScalePixel(FontHandle font_handle, float w, float h) { + (void)font_handle; + (void)w; + (void)h; + return 0; +} + +uint32_t sceFontStringGetTerminateCode(FontString font_string) { + (void)font_string; + return 0; +} + +void* sceFontStringGetTerminateOrder(FontString font_string) { + (void)font_string; + return nullptr; +} + +int sceFontStringGetWritingForm(FontString font_string) { + (void)font_string; + return 0; +} + +FontRenderCharacter sceFontStringRefersRenderCharacters(FontString font_string, FontTextCharacter start_character, FontTextCharacter last_character, uint32_t* character_count) { + (void)font_string; + (void)start_character; + (void)last_character; + (void)character_count; + return {}; +} + +FontTextCharacter sceFontStringRefersTextCharacters(FontString font_string, uint32_t* character_count) { + (void)font_string; + (void)character_count; + return {}; +} + +int sceFontSupportExternalFonts(FontLibrary library, uint32_t font_max, uint32_t formats) { + (void)library; + (void)font_max; + (void)formats; + return 0; +} + +int sceFontSupportSystemFonts(FontLibrary library) { + (void)library; + return 0; +} + +FontTextCodes* sceFontTextCodesStepBack(FontTextCodes* text_codes_step) { + (void)text_codes_step; + return nullptr; +} + +FontTextCodes* sceFontTextCodesStepNext(FontTextCodes* text_codes_step) { + (void)text_codes_step; + return nullptr; +} + +int sceFontTextSourceInit(FontTextSource* font_text_source, const void* text_address, uint32_t text_size_byte, FontTextParseFunction text_parser, void* text_object) { + (void)font_text_source; + (void)text_address; + (void)text_size_byte; + (void)text_parser; + (void)text_object; + return 0; +} + +int sceFontTextSourceRewind(FontTextSource* font_text_source) { + (void)font_text_source; + return 0; +} + +int sceFontTextSourceSetDefaultFont(FontTextSource* font_text_source, FontHandle default_font) { + (void)font_text_source; + (void)default_font; + return 0; +} + +int sceFontTextSourceSetWritingForm(FontTextSource* font_text_source, int writing_form) { + (void)font_text_source; + (void)writing_form; + return 0; +} + +int sceFontUnbindRenderer(FontHandle font_handle) { + (void)font_handle; + return 0; +} + +int sceFontWritingGetRenderMetrics(FontWriting* font_writing, FontWritingMetrics* writing_metrics) { + (void)font_writing; + (void)writing_metrics; + return 0; +} + +int sceFontWritingInit(FontWriting* font_writing, FontString font_string, FontRenderCharacter font_character) { + (void)font_writing; + (void)font_string; + (void)font_character; + return 0; +} + +int sceFontWritingLineClear(FontWritingLine writing_line) { + (void)writing_line; + return 0; +} + +int sceFontWritingLineGetOrderingSpace(FontWritingLine writing_line, float* head_space, float* inline_space, float* tail_space, float* advance_space) { + (void)writing_line; + (void)head_space; + (void)inline_space; + (void)tail_space; + (void)advance_space; + return 0; +} + +int sceFontWritingLineGetRenderMetrics(FontWritingLine writing_line, FontWritingMetrics* writing_metrics) { + (void)writing_line; + (void)writing_metrics; + return 0; +} + +FontWritingLineStep* sceFontWritingLineRefersRenderStep(FontWritingLine writing_line) { + (void)writing_line; + return nullptr; +} + +int sceFontWritingLineWritesOrder(FontWritingLine writing_line, uint64_t writing_attribute, const FontWritingMetrics* writing_metrics, void* writing_orderer) { + (void)writing_line; + (void)writing_attribute; + (void)writing_metrics; + (void)writing_orderer; + return 0; +} + +const FontWritingStep* sceFontWritingRefersRenderStep(FontWriting* font_writing) { + (void)font_writing; + return nullptr; +} + +FontTextCharacter sceFontWritingRefersRenderStepCharacter(FontWriting* font_writing, const void** letter_step) { + (void)font_writing; + (void)letter_step; + return {}; +} + +int sceFontWritingSetMaskInvisible(FontWriting* font_writing, int mask) { + (void)font_writing; + (void)mask; + return 0; +} + +} diff --git a/core/libs/prx/libSceFontFt/Export.cpp b/core/libs/prx/libSceFontFt/Export.cpp new file mode 100644 index 000000000..8960cb3c1 --- /dev/null +++ b/core/libs/prx/libSceFontFt/Export.cpp @@ -0,0 +1,17 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +void* sceFontSelectLibraryFt(int value) { + (void)value; + return nullptr; +} + +void* sceFontSelectRendererFt(int value) { + (void)value; + return nullptr; +} + +} diff --git a/core/libs/prx/libSceGameLiveStreaming/Export.cpp b/core/libs/prx/libSceGameLiveStreaming/Export.cpp new file mode 100644 index 000000000..de3407c34 --- /dev/null +++ b/core/libs/prx/libSceGameLiveStreaming/Export.cpp @@ -0,0 +1,16 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceGameLiveStreamingInitialize(size_t heap_size) { + (void)heap_size; + return 0; +} + +int sceGameLiveStreamingTerminate(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceGameUpdate/Export.cpp b/core/libs/prx/libSceGameUpdate/Export.cpp new file mode 100644 index 000000000..92772950e --- /dev/null +++ b/core/libs/prx/libSceGameUpdate/Export.cpp @@ -0,0 +1,43 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceGameUpdateAbortRequest(int request_id) { + (void)request_id; + return 0; +} + +int sceGameUpdateCheck(int request_id, const GameUpdateCheckParam* param, GameUpdateCheckResult* result) { + (void)request_id; + (void)param; + (void)result; + return 0; +} + +int sceGameUpdateCreateRequest(void) { + return 0; +} + +int sceGameUpdateDeleteRequest(int request_id) { + (void)request_id; + return 0; +} + +int sceGameUpdateGetAddcontLatestVersion(uint32_t service_label, const void* entitlement_label, GameUpdateAddcontVersionInfo* info) { + (void)service_label; + (void)entitlement_label; + (void)info; + return 0; +} + +int sceGameUpdateInitialize(void) { + return 0; +} + +int sceGameUpdateTerminate(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceHttp/Export.cpp b/core/libs/prx/libSceHttp/Export.cpp new file mode 100644 index 000000000..bdb9afc7b --- /dev/null +++ b/core/libs/prx/libSceHttp/Export.cpp @@ -0,0 +1,245 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceHttpAbortRequest(int request_id) { + (void)request_id; + return 0; +} + +int sceHttpAddRequestHeader(int id, const char* name, const char* value, uint32_t mode) { + (void)id; + (void)name; + (void)value; + (void)mode; + return 0; +} + +int sceHttpCreateConnection(int tmpl_id, const char* server_name, const char* scheme, uint16_t port, int enable_keep_alive) { + (void)tmpl_id; + (void)server_name; + (void)scheme; + (void)port; + (void)enable_keep_alive; + return 0; +} + +int sceHttpCreateConnectionWithURL(int tmpl_id, const char* url, int enable_keep_alive) { + (void)tmpl_id; + (void)url; + (void)enable_keep_alive; + return 0; +} + +int sceHttpCreateEpoll(int http_ctx_id, HttpEpollHandle* eh) { + (void)http_ctx_id; + (void)eh; + return 0; +} + +int sceHttpCreateRequest(int conn_id, int method, const char* path, uint64_t content_length) { + (void)conn_id; + (void)method; + (void)path; + (void)content_length; + return 0; +} + +int sceHttpCreateRequestWithURL2(int conn_id, const char* method, const char* url, uint64_t content_length) { + (void)conn_id; + (void)method; + (void)url; + (void)content_length; + return 0; +} + +int sceHttpCreateTemplate(int http_ctx_id, const char* user_agent, int http_ver, int is_auto_proxy_conf) { + (void)http_ctx_id; + (void)user_agent; + (void)http_ver; + (void)is_auto_proxy_conf; + return 0; +} + +int sceHttpDeleteConnection(int conn_id) { + (void)conn_id; + return 0; +} + +int sceHttpDeleteRequest(int req_id) { + (void)req_id; + return 0; +} + +int sceHttpDeleteTemplate(int tmpl_id) { + (void)tmpl_id; + return 0; +} + +int sceHttpDestroyEpoll(int http_ctx_id, HttpEpollHandle eh) { + (void)http_ctx_id; + (void)eh; + return 0; +} + +int sceHttpGetAllResponseHeaders(int request_id, char** header, size_t* header_size) { + (void)request_id; + (void)header; + (void)header_size; + return 0; +} + +int sceHttpGetResponseContentLength(int request_id, int* result, uint64_t* content_length) { + (void)request_id; + (void)result; + (void)content_length; + return 0; +} + +int sceHttpGetStatusCode(int request_id, int* status_code) { + (void)request_id; + (void)status_code; + return 0; +} + +int sceHttpInit(int memid, int ssl_ctx_id, uint64_t pool_size) { + (void)memid; + (void)ssl_ctx_id; + (void)pool_size; + return 0; +} + +int sceHttpsDisableOption(int id, uint32_t ssl_flags) { + (void)id; + (void)ssl_flags; + return 0; +} + +int sceHttpSendRequest(int request_id, const void* post_data, size_t size) { + (void)request_id; + (void)post_data; + (void)size; + return 0; +} + +int sceHttpSetAuthEnabled(int id, int enable) { + (void)id; + (void)enable; + return 0; +} + +int sceHttpSetAutoRedirect(int id, int enable) { + (void)id; + (void)enable; + return 0; +} + +int sceHttpSetConnectTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttpSetEpoll(int id, HttpEpollHandle eh, void* user_arg) { + (void)id; + (void)eh; + (void)user_arg; + return 0; +} + +int sceHttpSetNonblock(int id, int enable) { + (void)id; + (void)enable; + return 0; +} + +int sceHttpSetRecvTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttpSetRequestContentLength(int request_id, uint64_t content_length) { + (void)request_id; + (void)content_length; + return 0; +} + +int sceHttpSetResolveRetry(int id, int32_t retry) { + (void)id; + (void)retry; + return 0; +} + +int sceHttpSetResolveTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttpSetSendTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttpsSetMinSslVersion(int id, uint32_t ssl_version) { + (void)id; + (void)ssl_version; + return 0; +} + +int sceHttpsSetSslCallback(int id, HttpsCallback cbfunc, void* user_arg) { + (void)id; + (void)cbfunc; + (void)user_arg; + return 0; +} + +int sceHttpTerm(int http_ctx_id) { + (void)http_ctx_id; + return 0; +} + +int sceHttpUnsetEpoll(int id) { + (void)id; + return 0; +} + +int sceHttpUriBuild(char* out, size_t* require, size_t prepare, const SceHttpUriElement* src_element, uint32_t option) { + (void)out; + (void)require; + (void)prepare; + (void)src_element; + (void)option; + return 0; +} + +int sceHttpUriEscape(char* out, size_t* require, size_t prepare, const char* in) { + (void)out; + (void)require; + (void)prepare; + (void)in; + return 0; +} + +int sceHttpUriParse(SceHttpUriElement* out, const char* src_url, void* pool, size_t* require, size_t prepare) { + (void)out; + (void)src_url; + (void)pool; + (void)require; + (void)prepare; + return 0; +} + +int sceHttpWaitRequest(HttpEpollHandle eh, HttpNBEvent* nbev, int maxevents, int timeout) { + (void)eh; + (void)nbev; + (void)maxevents; + (void)timeout; + return 0; +} + +} diff --git a/core/libs/prx/libSceHttp2/Export.cpp b/core/libs/prx/libSceHttp2/Export.cpp new file mode 100644 index 000000000..a05762fa8 --- /dev/null +++ b/core/libs/prx/libSceHttp2/Export.cpp @@ -0,0 +1,201 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceHttp2AddRequestHeader(int id, const char* name, const char* value, uint32_t mode) { + (void)id; + (void)name; + (void)value; + (void)mode; + return 0; +} + +int sceHttp2CreateRequestWithURL(int tmpl_id, const char* method, const char* url, uint64_t content_length) { + (void)tmpl_id; + (void)method; + (void)url; + (void)content_length; + return 0; +} + +int sceHttp2CreateTemplate(int lib_http2_ctx_id, const char* user_agent, int http_ver, int is_auto_proxy_conf) { + (void)lib_http2_ctx_id; + (void)user_agent; + (void)http_ver; + + (void)is_auto_proxy_conf; + return 0; +} + +int sceHttp2DeleteRequest(int req_id) { + (void)req_id; + return 0; +} + +int sceHttp2DeleteTemplate(int tmpl_id) { + (void)tmpl_id; + return 0; +} + +int sceHttp2GetAllResponseHeaders(int req_id, char** header, size_t* header_size) { + (void)req_id; + (void)header; + (void)header_size; + return 0; +} + +int sceHttp2GetResponseContentLength(int req_id, int* result, uint64_t* content_length) { + (void)req_id; + (void)result; + (void)content_length; + return 0; +} + +int sceHttp2GetStatusCode(int req_id, int* status_code) { + (void)req_id; + (void)status_code; + return 0; +} + +int sceHttp2Init(int libnet_mem_id, int libssl_ctx_id, size_t pool_size, int max_concurrent_request) { + (void)libnet_mem_id; + (void)libssl_ctx_id; + (void)pool_size; + (void)max_concurrent_request; + return 0; +} + +int sceHttp2ReadData(int req_id, void* data, size_t size) { + (void)req_id; + (void)data; + (void)size; + return 0; +} + +int sceHttp2ReadDataAsync(int req_id, void* data, size_t size, void* kqueue_option, void* option) { + (void)req_id; + (void)data; + (void)size; + (void)kqueue_option; + (void)option; + return 0; +} + +int sceHttp2SendRequest(int req_id, const void* post_data, size_t size) { + (void)req_id; + (void)post_data; + (void)size; + return 0; +} + +int sceHttp2SendRequestAsync(int req_id, const void* post_data, size_t size, void* kqueue_option, void* option) { + (void)req_id; + (void)post_data; + (void)size; + (void)kqueue_option; + (void)option; + return 0; +} + +int sceHttp2SetAuthEnabled(int id, int is_enable) { + (void)id; + (void)is_enable; + return 0; +} + +int sceHttp2SetAutoRedirect(int id, int enable) { + (void)id; + (void)enable; + return 0; +} + +int sceHttp2SetConnectionWaitTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttp2SetConnectTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttp2SetInflateGZIPEnabled(int id, int enable) { + (void)id; + (void)enable; + return 0; +} + +int sceHttp2SetRecvTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttp2SetRedirectCallback(int id, void* cb_func, void* user_arg) { + (void)id; + (void)cb_func; + (void)user_arg; + return 0; +} + +int sceHttp2SetRequestContentLength(int id, uint64_t content_length) { + (void)id; + (void)content_length; + return 0; +} + +int sceHttp2SetResolveTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttp2SetSendTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttp2SetSslCallback(int id, void* cb_func, void* user_arg) { + (void)id; + (void)cb_func; + (void)user_arg; + return 0; +} + +int sceHttp2SetTimeOut(int id, uint32_t usec) { + (void)id; + (void)usec; + return 0; +} + +int sceHttp2SslDisableOption(int id, uint32_t ssl_flags) { + (void)id; + (void)ssl_flags; + return 0; +} + +int sceHttp2SslEnableOption(int id, uint32_t ssl_flags) { + (void)id; + (void)ssl_flags; + return 0; +} + +int sceHttp2Term(int lib_http2_ctx_id) { + (void)lib_http2_ctx_id; + return 0; +} + +int sceHttp2WaitAsync(int req_id, Http2AsyncResult* result, uint32_t* timeout, void* option) { + (void)req_id; + (void)result; + (void)timeout; + (void)option; + return 0; +} + +} diff --git a/core/libs/prx/libSceIme/Export.cpp b/core/libs/prx/libSceIme/Export.cpp new file mode 100644 index 000000000..902640bdf --- /dev/null +++ b/core/libs/prx/libSceIme/Export.cpp @@ -0,0 +1,79 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceImeClose(void) { + return 0; +} + +int sceImeGetPanelSize(const Param* param, uint32_t* width, uint32_t* height) { + (void)param; + (void)width; + (void)height; + return 0; +} + +int sceImeKeyboardClose(int32_t user_id) { + (void)user_id; + return 0; +} + +int sceImeKeyboardGetInfo(uint32_t resource_id, KeyboardInfo* info) { + (void)resource_id; + (void)info; + return 0; +} + +int sceImeKeyboardGetResourceId(int32_t user_id, KeyboardResourceIdArray* resource_ids) { + (void)user_id; + (void)resource_ids; + return 0; +} + +int sceImeKeyboardOpen(int32_t user_id, const KeyboardParam* param) { + (void)user_id; + (void)param; + return 0; +} + +int sceImeKeyboardSetMode(int32_t user_id, uint32_t mode) { + (void)user_id; + (void)mode; + return 0; +} + +int sceImeOpen(const Param* param, const ExtendedParam* extended) { + (void)param; + (void)extended; + return 0; +} + +void sceImeParamInit(Param* param) { + (void)param; +} + +int sceImeSetCaret(const Caret* caret) { + (void)caret; + return 0; +} + +int sceImeSetText(const char16_t* text, uint32_t length) { + (void)text; + (void)length; + return 0; +} + +int sceImeSetTextGeometry(TextAreaMode mode, const TextGeometry* geometry) { + (void)mode; + (void)geometry; + return 0; +} + +int sceImeUpdate(EventHandler handler) { + (void)handler; + return 0; +} + +} diff --git a/core/libs/prx/libSceImeDialog/Export.cpp b/core/libs/prx/libSceImeDialog/Export.cpp new file mode 100644 index 000000000..df411c356 --- /dev/null +++ b/core/libs/prx/libSceImeDialog/Export.cpp @@ -0,0 +1,50 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceImeDialogAbort(void) { + return 0; +} + +int sceImeDialogGetPanelPositionAndForm(PositionAndForm* form) { + (void)form; + return 0; +} + +int sceImeDialogGetPanelSize(const Param* param, uint32_t* width, uint32_t* height) { + (void)param; + (void)width; + (void)height; + return 0; +} + +int sceImeDialogGetPanelSizeExtended(const Param* param, const ExtendedParam* extended, uint32_t* width, uint32_t* height) { + (void)param; + (void)extended; + (void)width; + (void)height; + return 0; +} + +int sceImeDialogGetResult(Result* result) { + (void)result; + return 0; +} + +int sceImeDialogGetStatus(void) { + return 0; +} + +int sceImeDialogInit(const Param* param, const ExtendedParam* extended) { + (void)param; + (void)extended; + return 0; +} + +int sceImeDialogTerm(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceKeyboard/Export.cpp b/core/libs/prx/libSceKeyboard/Export.cpp new file mode 100644 index 000000000..0c2a4a45d --- /dev/null +++ b/core/libs/prx/libSceKeyboard/Export.cpp @@ -0,0 +1,47 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceKeyboardClose(int32_t handle) { + (void)handle; + return 0; +} + +int sceKeyboardGetKey2Char(int32_t handle, int32_t arrange, uint32_t led, uint32_t modifier_key, uint16_t key_code, KeyboardCharData* char_data) { + (void)handle; + (void)arrange; + (void)led; + (void)modifier_key; + (void)key_code; + (void)char_data; + return 0; +} + +int sceKeyboardInit(void) { + return 0; +} + +int sceKeyboardOpen(int user_id, int32_t type, int32_t index, const void* param) { + (void)user_id; + (void)type; + (void)index; + (void)param; + return 0; +} + +int sceKeyboardRead(int32_t handle, KeyboardData* data, int32_t num) { + (void)handle; + (void)data; + (void)num; + return 0; +} + +int sceKeyboardReadState(int32_t handle, KeyboardData* data) { + (void)handle; + (void)data; + return 0; +} + +} diff --git a/core/libs/prx/libSceLibcInternal/Export.cpp b/core/libs/prx/libSceLibcInternal/Export.cpp new file mode 100644 index 000000000..b56bbc019 --- /dev/null +++ b/core/libs/prx/libSceLibcInternal/Export.cpp @@ -0,0 +1,210 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +[[noreturn]] void abort(uint64_t arg0, uint64_t arg1, uint64_t arg2, uint64_t arg3, uint64_t arg4, uint64_t arg5) { + (void)arg0; + (void)arg1; + (void)arg2; + (void)arg3; + (void)arg4; + (void)arg5; + __builtin_unreachable(); +} + +int atexit(atexit_func_t func) { + (void)func; + return 0; +} + +int atoi(const char* str) { + (void)str; + return 0; +} + +double cos(double x) { + (void)x; + return 0; +} + +float cosf(float x) { + (void)x; + return 0; +} + +void Exit(int code) { + (void)code; +} + +void exit(int code) { + (void)code; +} + +int fflush(FILE* stream) { + (void)stream; + return 0; +} + +void init_env(const InitEnvParams* params) { + (void)params; +} + +int memcmp(const void* s1, const void* s2, size_t n) { + (void)s1; + (void)s2; + (void)n; + return 0; +} + +void* memcpy(void* dest, const void* src, size_t n) { + (void)dest; + (void)src; + (void)n; + return nullptr; +} + +void* memmove(void* dest, const void* src, size_t n) { + (void)dest; + (void)src; + (void)n; + return nullptr; +} + +void* memset(void* s, int c, size_t n) { + (void)s; + (void)c; + (void)n; + return nullptr; +} + +int puts(const char* s) { + (void)s; + return 0; +} + +void sceLibcHeapGetTraceInfo(Info* info) { + (void)info; +} + +int setenv(const char* name, const char* value, int overwrite) { + (void)name; + (void)value; + (void)overwrite; + return 0; +} + +double Sin(double x) { + (void)x; + return 0; +} + +double sin(double x) { + (void)x; + return 0; +} + +void Sincos(double x, double* sinp, double* cosp) { + (void)x; + (void)sinp; + (void)cosp; +} + +void sincos(double x, double* sinp, double* cosp) { + (void)x; + (void)sinp; + (void)cosp; +} + +void sincosf(float x, float* sinp, float* cosp) { + (void)x; + (void)sinp; + (void)cosp; +} + +float sinf(float x) { + (void)x; + return 0; +} + +int snprintf(VA_ARGS) { + return 0; +} + +char* strcat(char* dest, const char* src) { + (void)dest; + (void)src; + return nullptr; +} + +const char* strchr(const char* s, int c) { + (void)s; + (void)c; + return nullptr; +} + +int strcmp(const char* s1, const char* s2) { + (void)s1; + (void)s2; + return 0; +} + +char* strcpy(char* dest, const char* src) { + (void)dest; + (void)src; + return nullptr; +} + +size_t strlen(const char* s) { + (void)s; + return 0; +} + +int strncmp(const char* s1, const char* s2, size_t n) { + (void)s1; + (void)s2; + (void)n; + return 0; +} + +char* strncpy(char* dest, const char* src, size_t count) { + (void)dest; + (void)src; + (void)count; + return nullptr; +} + +char* strrchr(const char* s, int c) { + (void)s; + (void)c; + return nullptr; +} + +char* strstr(const char* haystack, const char* needle) { + (void)haystack; + (void)needle; + return nullptr; +} + +long strtol(const char* str, char** endptr, int base) { + (void)str; + (void)endptr; + (void)base; + return 0; +} + +unsigned long strtoul(const char* str, char** endptr, int base) { + (void)str; + (void)endptr; + (void)base; + return 0; +} + +int vprintf(const char* str, VaList* c) { + (void)str; + (void)c; + return 0; +} + +} diff --git a/core/libs/prx/libSceLoginDialog/Export.cpp b/core/libs/prx/libSceLoginDialog/Export.cpp new file mode 100644 index 000000000..43dcbbd8d --- /dev/null +++ b/core/libs/prx/libSceLoginDialog/Export.cpp @@ -0,0 +1,37 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceLoginDialogClose(void) { + return 0; +} + +int sceLoginDialogGetResult(void* result) { + (void)result; + return 0; +} + +int sceLoginDialogGetStatus(void) { + return 0; +} + +int sceLoginDialogInitialize(void) { + return 0; +} + +int sceLoginDialogOpen(const void* param) { + (void)param; + return 0; +} + +int sceLoginDialogTerminate(void) { + return 0; +} + +int sceLoginDialogUpdateStatus(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceMouse/Export.cpp b/core/libs/prx/libSceMouse/Export.cpp new file mode 100644 index 000000000..a49cbfe5a --- /dev/null +++ b/core/libs/prx/libSceMouse/Export.cpp @@ -0,0 +1,31 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceMouseClose(int32_t handle) { + (void)handle; + return 0; +} + +int sceMouseInit(void) { + return 0; +} + +int sceMouseOpen(int user_id, int32_t type, int32_t index, const void* param) { + (void)user_id; + (void)type; + (void)index; + (void)param; + return 0; +} + +int sceMouseRead(int32_t handle, MouseData* data, int32_t num) { + (void)handle; + (void)data; + (void)num; + return 0; +} + +} diff --git a/core/libs/prx/libSceMsgDialog/Export.cpp b/core/libs/prx/libSceMsgDialog/Export.cpp new file mode 100644 index 000000000..70653772f --- /dev/null +++ b/core/libs/prx/libSceMsgDialog/Export.cpp @@ -0,0 +1,55 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceMsgDialogClose(void) { + return 0; +} + +int sceMsgDialogGetResult(void* result) { + (void)result; + return 0; +} + +int sceMsgDialogGetStatus(void) { + return 0; +} + +int sceMsgDialogInitialize(void) { + return 0; +} + +int sceMsgDialogOpen(const void* param) { + (void)param; + return 0; +} + +int sceMsgDialogProgressBarInc(int target, uint32_t delta) { + (void)target; + (void)delta; + return 0; +} + +int sceMsgDialogProgressBarSetMsg(int target, const char* msg) { + (void)target; + (void)msg; + return 0; +} + +int sceMsgDialogProgressBarSetValue(int target, uint32_t rate) { + (void)target; + (void)rate; + return 0; +} + +int sceMsgDialogTerminate(void) { + return 0; +} + +int sceMsgDialogUpdateStatus(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceNet/Export.cpp b/core/libs/prx/libSceNet/Export.cpp new file mode 100644 index 000000000..5de7f7258 --- /dev/null +++ b/core/libs/prx/libSceNet/Export.cpp @@ -0,0 +1,178 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNetAccept(int s, void* addr, uint32_t* addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int sceNetBind(int s, const void* addr, uint32_t addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int sceNetEpollControl(int eid, int op, int id, const NetEpollEvent* event) { + (void)eid; + (void)op; + (void)id; + (void)event; + return 0; +} + +int sceNetEpollCreate(const char* name, int flags) { + (void)name; + (void)flags; + return 0; +} + +int sceNetEpollDestroy(int eid) { + (void)eid; + return 0; +} + +int sceNetEpollWait(int eid, NetEpollEvent* events, int maxevents, int timeout) { + (void)eid; + (void)events; + (void)maxevents; + (void)timeout; + return 0; +} + +int sceNetEtherNtostr(const NetEtherAddr* n, char* str, size_t len) { + (void)n; + (void)str; + (void)len; + return 0; +} + +int sceNetGetMacAddress(NetEtherAddr* addr, int flags) { + (void)addr; + (void)flags; + return 0; +} + +int sceNetGetSockInfo(int s, void* info, int n, int flags) { + (void)s; + (void)info; + (void)n; + (void)flags; + return 0; +} + +int sceNetGetsockname(int s, void* addr, uint32_t* addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +uint32_t sceNetHtonl(uint32_t host32) { + (void)host32; + return 0; +} + +uint16_t sceNetHtons(uint16_t host16) { + (void)host16; + return 0; +} + +const char* sceNetInetNtop(int af, const void* src, char* dst, uint32_t size) { + (void)af; + (void)src; + (void)dst; + (void)size; + return nullptr; +} + +int sceNetInetPton(int af, const char* src, void* dst) { + (void)af; + (void)src; + (void)dst; + return 0; +} + +int sceNetInit(void) { + return 0; +} + +int sceNetListen(int s, int backlog) { + (void)s; + (void)backlog; + return 0; +} + +uint32_t sceNetNtohl(uint32_t net32) { + (void)net32; + return 0; +} + +uint16_t sceNetNtohs(uint16_t net16) { + (void)net16; + return 0; +} + +int sceNetPoolCreate(const char* name, int size, int flags) { + (void)name; + (void)size; + (void)flags; + return 0; +} + +int sceNetPoolDestroy(int memid) { + (void)memid; + return 0; +} + +int sceNetResolverCreate(const char* name, int memid, int flags) { + (void)name; + (void)memid; + (void)flags; + return 0; +} + +int sceNetResolverStartNtoa(int rid, const char* hostname, void* addr, int timeout, int retry, int flags) { + (void)rid; + (void)hostname; + (void)addr; + (void)timeout; + (void)retry; + (void)flags; + return 0; +} + +int sceNetSetsockopt(int s, int level, int optname, const void* optval, uint32_t optlen) { + (void)s; + (void)level; + (void)optname; + (void)optval; + (void)optlen; + return 0; +} + +int sceNetShutdown(int s, int how) { + (void)s; + (void)how; + return 0; +} + +int sceNetSocket(const char* name, int family, int type, int protocol) { + (void)name; + (void)family; + (void)type; + (void)protocol; + return 0; +} + +int sceNetSocketClose(int s) { + (void)s; + return 0; +} + +} diff --git a/core/libs/prx/libSceNetCtl/Export.cpp b/core/libs/prx/libSceNetCtl/Export.cpp new file mode 100644 index 000000000..f16fc3d63 --- /dev/null +++ b/core/libs/prx/libSceNetCtl/Export.cpp @@ -0,0 +1,57 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNetCtlCheckCallback(void) { + return 0; +} + +int sceNetCtlGetInfo(int code, NetCtlInfo* info) { + (void)code; + (void)info; + return 0; +} + +int sceNetCtlGetNatInfo(NetCtlNatInfo* nat_info) { + (void)nat_info; + return 0; +} + +int sceNetCtlGetResult(int event_type, int* error_code) { + (void)event_type; + (void)error_code; + return 0; +} + +int sceNetCtlGetState(int* state) { + (void)state; + return 0; +} + +int sceNetCtlGetStateV6(int* state) { + (void)state; + return 0; +} + +int sceNetCtlInit(void) { + return 0; +} + +int sceNetCtlRegisterCallback(NetCtlCallback func, void* arg, int* cid) { + (void)func; + (void)arg; + (void)cid; + return 0; +} + +void sceNetCtlTerm(void) { +} + +int sceNetCtlUnregisterCallback(int cid) { + (void)cid; + return 0; +} + +} diff --git a/core/libs/prx/libSceNgs2.native/Export.cpp b/core/libs/prx/libSceNgs2.native/Export.cpp new file mode 100644 index 000000000..c9a1f171b --- /dev/null +++ b/core/libs/prx/libSceNgs2.native/Export.cpp @@ -0,0 +1,190 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNgs2CalcWaveformBlock(const Ngs2WaveformFormat* format, uint32_t sample_pos, uint32_t num_samples, Ngs2WaveformBlock* block) { + (void)format; + (void)sample_pos; + (void)num_samples; + (void)block; + return 0; +} + +int sceNgs2GeomApply(const Ngs2GeomListenerWork* listener, const Ngs2GeomSourceParam* source, Ngs2GeomAttribute* out_attrib, uint32_t flags) { + (void)listener; + (void)source; + (void)out_attrib; + (void)flags; + return 0; +} + +int sceNgs2GeomCalcListener(const Ngs2GeomListenerParam* param, Ngs2GeomListenerWork* out_work, uint32_t flags) { + (void)param; + (void)out_work; + (void)flags; + return 0; +} + +int sceNgs2GeomResetListenerParam(Ngs2GeomListenerParam* out_listener_param) { + (void)out_listener_param; + return 0; +} + +int sceNgs2GeomResetSourceParam(Ngs2GeomSourceParam* out_source_param) { + (void)out_source_param; + return 0; +} + +int sceNgs2PanGetVolumeMatrix(Ngs2PanWork* work, const Ngs2PanParam* params, uint32_t num_params, uint32_t matrix_format, float* out_volume_matrix) { + (void)work; + (void)params; + (void)num_params; + (void)matrix_format; + (void)out_volume_matrix; + return 0; +} + +int sceNgs2PanInit(Ngs2PanWork* work, const float* speaker_angles, float unit_angle, uint32_t num_speakers) { + (void)work; + (void)speaker_angles; + (void)unit_angle; + (void)num_speakers; + return 0; +} + +int sceNgs2ParseWaveformData(const void* data, size_t data_size, Ngs2WaveformInfo* info) { + (void)data; + (void)data_size; + (void)info; + return 0; +} + +int sceNgs2RackCreate(uintptr_t system_handle, uint32_t rack_id, const Ngs2RackOption* option, const Ngs2ContextBufferInfo* buffer_info, uintptr_t* handle) { + (void)system_handle; + (void)rack_id; + (void)option; + (void)buffer_info; + (void)handle; + return 0; +} + +int sceNgs2RackCreateWithAllocator(uintptr_t system_handle, uint32_t rack_id, const Ngs2RackOption* option, const Ngs2BufferAllocator* allocator, uintptr_t* handle) { + (void)system_handle; + (void)rack_id; + (void)option; + (void)allocator; + (void)handle; + return 0; +} + +int sceNgs2RackDestroy(uintptr_t rack_handle, Ngs2ContextBufferInfo* buffer_info) { + (void)rack_handle; + (void)buffer_info; + return 0; +} + +int sceNgs2RackGetVoiceHandle(uintptr_t rack_handle, uint32_t voice_id, uintptr_t* handle) { + (void)rack_handle; + (void)voice_id; + (void)handle; + return 0; +} + +int sceNgs2RackLock(uintptr_t rack_handle) { + (void)rack_handle; + return 0; +} + +int sceNgs2RackQueryBufferSize(uint32_t rack_id, const Ngs2RackOption* option, Ngs2ContextBufferInfo* buffer_info) { + (void)rack_id; + (void)option; + (void)buffer_info; + return 0; +} + +int sceNgs2RackUnlock(uintptr_t rack_handle) { + (void)rack_handle; + return 0; +} + +int sceNgs2SystemCreate(const Ngs2SystemOption* option, const Ngs2ContextBufferInfo* buffer_info, uintptr_t* handle) { + (void)option; + (void)buffer_info; + (void)handle; + return 0; +} + +int sceNgs2SystemCreateWithAllocator(const Ngs2SystemOption* option, const Ngs2BufferAllocator* allocator, uintptr_t* handle) { + (void)option; + (void)allocator; + (void)handle; + return 0; +} + +int sceNgs2SystemDestroy(uintptr_t system_handle, Ngs2ContextBufferInfo* buffer_info) { + (void)system_handle; + (void)buffer_info; + return 0; +} + +int sceNgs2SystemGetInfo(uintptr_t system_handle, Ngs2SystemInfo* info, size_t info_size) { + (void)system_handle; + (void)info; + (void)info_size; + return 0; +} + +int sceNgs2SystemQueryBufferSize(const Ngs2SystemOption* option, Ngs2ContextBufferInfo* buffer_info) { + (void)option; + (void)buffer_info; + return 0; +} + +int sceNgs2SystemRender(uintptr_t system_handle, const Ngs2RenderBufferInfo* buffer_info, uint32_t num_buffer_info) { + (void)system_handle; + (void)buffer_info; + (void)num_buffer_info; + return 0; +} + +int sceNgs2SystemResetOption(Ngs2SystemOption* option) { + (void)option; + return 0; +} + +int sceNgs2SystemSetGrainSamples(uintptr_t system_handle, uint32_t num_samples) { + (void)system_handle; + (void)num_samples; + return 0; +} + +int sceNgs2VoiceControl(uintptr_t voice_handle, const Ngs2VoiceParamHeader* param_list) { + (void)voice_handle; + (void)param_list; + return 0; +} + +int sceNgs2VoiceGetState(uintptr_t voice_handle, Ngs2VoiceState* state, size_t state_size) { + (void)voice_handle; + (void)state; + (void)state_size; + return 0; +} + +int sceNgs2VoiceGetStateFlags(uintptr_t voice_handle, uint32_t* state_flags) { + (void)voice_handle; + (void)state_flags; + return 0; +} + +int sceNgs2VoiceRunCommands(uintptr_t voice_handle, const void* commands, uint32_t num_commands, uint32_t flags) { + (void)voice_handle; + (void)commands; + (void)num_commands; + (void)flags; + return 0; +} + +} diff --git a/core/libs/prx/libSceNgs2/Export.cpp b/core/libs/prx/libSceNgs2/Export.cpp new file mode 100644 index 000000000..fd4906b20 --- /dev/null +++ b/core/libs/prx/libSceNgs2/Export.cpp @@ -0,0 +1,177 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNgs2CalcWaveformBlock(const Ngs2WaveformFormat* format, uint32_t sample_pos, uint32_t num_samples, Ngs2WaveformBlock* block) { + (void)format; + (void)sample_pos; + (void)num_samples; + (void)block; + return 0; +} + +int sceNgs2GeomApply(const Ngs2GeomListenerWork* listener, const Ngs2GeomSourceParam* source, Ngs2GeomAttribute* out_attrib, uint32_t flags) { + (void)listener; + (void)source; + (void)out_attrib; + (void)flags; + return 0; +} + +int sceNgs2GeomCalcListener(const Ngs2GeomListenerParam* param, Ngs2GeomListenerWork* out_work, uint32_t flags) { + (void)param; + (void)out_work; + (void)flags; + return 0; +} + +int sceNgs2GeomResetListenerParam(Ngs2GeomListenerParam* out_listener_param) { + (void)out_listener_param; + return 0; +} + +int sceNgs2GeomResetSourceParam(Ngs2GeomSourceParam* out_source_param) { + (void)out_source_param; + return 0; +} + +int sceNgs2PanGetVolumeMatrix(Ngs2PanWork* work, const Ngs2PanParam* params, uint32_t num_params, uint32_t matrix_format, float* out_volume_matrix) { + (void)work; + (void)params; + (void)num_params; + (void)matrix_format; + (void)out_volume_matrix; + return 0; +} + +int sceNgs2PanInit(Ngs2PanWork* work, const float* speaker_angles, float unit_angle, uint32_t num_speakers) { + (void)work; + (void)speaker_angles; + (void)unit_angle; + (void)num_speakers; + return 0; +} + +int sceNgs2ParseWaveformData(const void* data, size_t data_size, Ngs2WaveformInfo* info) { + (void)data; + (void)data_size; + (void)info; + return 0; +} + +int sceNgs2RackCreate(uintptr_t system_handle, uint32_t rack_id, const Ngs2RackOption* option, const Ngs2ContextBufferInfo* buffer_info, uintptr_t* handle) { + (void)system_handle; + (void)rack_id; + (void)option; + (void)buffer_info; + (void)handle; + return 0; +} + +int sceNgs2RackCreateWithAllocator(uintptr_t system_handle, uint32_t rack_id, const Ngs2RackOption* option, const Ngs2BufferAllocator* allocator, uintptr_t* handle) { + (void)system_handle; + (void)rack_id; + (void)option; + (void)allocator; + (void)handle; + return 0; +} + +int sceNgs2RackDestroy(uintptr_t rack_handle, Ngs2ContextBufferInfo* buffer_info) { + (void)rack_handle; + (void)buffer_info; + return 0; +} + +int sceNgs2RackGetVoiceHandle(uintptr_t rack_handle, uint32_t voice_id, uintptr_t* handle) { + (void)rack_handle; + (void)voice_id; + (void)handle; + return 0; +} + +int sceNgs2RackLock(uintptr_t rack_handle) { + (void)rack_handle; + return 0; +} + +int sceNgs2RackQueryBufferSize(uint32_t rack_id, const Ngs2RackOption* option, Ngs2ContextBufferInfo* buffer_info) { + (void)rack_id; + (void)option; + (void)buffer_info; + return 0; +} + +int sceNgs2RackUnlock(uintptr_t rack_handle) { + (void)rack_handle; + return 0; +} + +int sceNgs2SystemCreate(const Ngs2SystemOption* option, const Ngs2ContextBufferInfo* buffer_info, uintptr_t* handle) { + (void)option; + (void)buffer_info; + (void)handle; + return 0; +} + +int sceNgs2SystemCreateWithAllocator(const Ngs2SystemOption* option, const Ngs2BufferAllocator* allocator, uintptr_t* handle) { + (void)option; + (void)allocator; + (void)handle; + return 0; +} + +int sceNgs2SystemDestroy(uintptr_t system_handle, Ngs2ContextBufferInfo* buffer_info) { + (void)system_handle; + (void)buffer_info; + return 0; +} + +int sceNgs2SystemGetInfo(uintptr_t system_handle, Ngs2SystemInfo* info, size_t info_size) { + (void)system_handle; + (void)info; + (void)info_size; + return 0; +} + +int sceNgs2SystemQueryBufferSize(const Ngs2SystemOption* option, Ngs2ContextBufferInfo* buffer_info) { + (void)option; + (void)buffer_info; + return 0; +} + +int sceNgs2SystemRender(uintptr_t system_handle, const Ngs2RenderBufferInfo* buffer_info, uint32_t num_buffer_info) { + (void)system_handle; + (void)buffer_info; + (void)num_buffer_info; + return 0; +} + +int sceNgs2SystemSetGrainSamples(uintptr_t system_handle, uint32_t num_samples) { + (void)system_handle; + (void)num_samples; + return 0; +} + +int sceNgs2VoiceControl(uintptr_t voice_handle, const Ngs2VoiceParamHeader* param_list) { + (void)voice_handle; + (void)param_list; + return 0; +} + +int sceNgs2VoiceGetState(uintptr_t voice_handle, Ngs2VoiceState* state, size_t state_size) { + (void)voice_handle; + (void)state; + (void)state_size; + return 0; +} + +int sceNgs2VoiceGetStateFlags(uintptr_t voice_handle, uint32_t* state_flags) { + (void)voice_handle; + (void)state_flags; + return 0; +} + +} diff --git a/core/libs/prx/libSceNpAuth/Export.cpp b/core/libs/prx/libSceNpAuth/Export.cpp new file mode 100644 index 000000000..ff75d94f4 --- /dev/null +++ b/core/libs/prx/libSceNpAuth/Export.cpp @@ -0,0 +1,53 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNpAuthAbortRequest(int req_id) { + (void)req_id; + return 0; +} + +int sceNpAuthCreateAsyncRequest(const void* param) { + (void)param; + return 0; +} + +int sceNpAuthCreateRequest(void) { + return 0; +} + +int sceNpAuthDeleteRequest(int req_id) { + (void)req_id; + return 0; +} + +int sceNpAuthGetAuthorizationCodeV3(int req_id, const void* param, void* auth_code, int* issuer_id) { + (void)req_id; + (void)param; + (void)auth_code; + (void)issuer_id; + return 0; +} + +int sceNpAuthGetIdTokenV3(int req_id, const void* param, void* id_token) { + (void)req_id; + (void)param; + (void)id_token; + return 0; +} + +int sceNpAuthPollAsync(int req_id, int* result) { + (void)req_id; + (void)result; + return 0; +} + +int sceNpAuthWaitAsync(int req_id, int* result) { + (void)req_id; + (void)result; + return 0; +} + +} diff --git a/core/libs/prx/libSceNpCommerce/Export.cpp b/core/libs/prx/libSceNpCommerce/Export.cpp new file mode 100644 index 000000000..c0cbd5a12 --- /dev/null +++ b/core/libs/prx/libSceNpCommerce/Export.cpp @@ -0,0 +1,11 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNpCommerceDialogUpdateStatus(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceNpEntitlementAccess/Export.cpp b/core/libs/prx/libSceNpEntitlementAccess/Export.cpp new file mode 100644 index 000000000..c10e7beac --- /dev/null +++ b/core/libs/prx/libSceNpEntitlementAccess/Export.cpp @@ -0,0 +1,33 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNpEntitlementAccessGetAddcontEntitlementInfo(uint32_t service_label, const NpUnifiedEntitlementLabel* entitlement_label, NpEntitlementAccessAddcontEntitlementInfo* info) { + (void)service_label; + (void)entitlement_label; + (void)info; + return 0; +} + +int sceNpEntitlementAccessGetAddcontEntitlementInfoList(uint32_t service_label, NpEntitlementAccessAddcontEntitlementInfo* list, uint32_t list_num, uint32_t* hit_num) { + (void)service_label; + (void)list; + (void)list_num; + (void)hit_num; + return 0; +} + +int sceNpEntitlementAccessGetSkuFlag(uint32_t* sku_flag) { + (void)sku_flag; + return 0; +} + +int sceNpEntitlementAccessInitialize(const NpEntitlementAccessInitParam* init_param, NpEntitlementAccessBootParam* boot_param) { + (void)init_param; + (void)boot_param; + return 0; +} + +} diff --git a/core/libs/prx/libSceNpGameIntent/Export.cpp b/core/libs/prx/libSceNpGameIntent/Export.cpp new file mode 100644 index 000000000..9613c67a2 --- /dev/null +++ b/core/libs/prx/libSceNpGameIntent/Export.cpp @@ -0,0 +1,29 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNpGameIntentGetPropertyValueString(const NpGameIntentData* intent_data, const char* key, char* value_buf, size_t buf_size) { + (void)intent_data; + (void)key; + (void)value_buf; + (void)buf_size; + return 0; +} + +int sceNpGameIntentInitialize(const void* init_param) { + (void)init_param; + return 0; +} + +int sceNpGameIntentReceiveIntent(NpGameIntentInfo* intent_info) { + (void)intent_info; + return 0; +} + +int sceNpGameIntentTerminate(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceNpManager/Export.cpp b/core/libs/prx/libSceNpManager/Export.cpp new file mode 100644 index 000000000..e2615e46f --- /dev/null +++ b/core/libs/prx/libSceNpManager/Export.cpp @@ -0,0 +1,149 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNpAbortRequest(int req_id) { + (void)req_id; + return 0; +} + +int sceNpCheckCallback(void) { + return 0; +} + +int sceNpCheckNpAvailability(int req_id, const char* user, void* result) { + (void)req_id; + (void)user; + (void)result; + return 0; +} + +int sceNpCheckNpReachability(int req_id, int user_id) { + (void)req_id; + (void)user_id; + return 0; +} + +int sceNpCheckPremium(int req_id, const NpCheckPremiumParameter* param, NpCheckPremiumResult* result) { + (void)req_id; + (void)param; + (void)result; + return 0; +} + +int sceNpCreateAsyncRequest(const NpCreateAsyncRequestParameter* param) { + (void)param; + return 0; +} + +int sceNpCreateRequest(void) { + return 0; +} + +int sceNpDeleteRequest(int req_id) { + (void)req_id; + return 0; +} + +int sceNpGetAccountAge(int req_id, int user_id, uint8_t* age) { + (void)req_id; + (void)user_id; + (void)age; + return 0; +} + +int sceNpGetAccountCountryA(int user_id, void* country_code) { + (void)user_id; + (void)country_code; + return 0; +} + +int sceNpGetAccountIdA(int user_id, uint64_t* account_id) { + (void)user_id; + (void)account_id; + return 0; +} + +int sceNpGetNpId(int user_id, NpId* np_id) { + (void)user_id; + (void)np_id; + return 0; +} + +int sceNpGetNpReachabilityState(int user_id, uint32_t* state) { + (void)user_id; + (void)state; + return 0; +} + +int sceNpGetOnlineId(int user_id, NpOnlineId* online_id) { + (void)user_id; + (void)online_id; + return 0; +} + +int sceNpGetState(int user_id, uint32_t* state) { + (void)user_id; + (void)state; + return 0; +} + +int sceNpHasSignedUp(int user_id, bool* has_signed_up) { + (void)user_id; + (void)has_signed_up; + return 0; +} + +int sceNpPollAsync(int req_id, int* result) { + (void)req_id; + (void)result; + return 0; +} + +void sceNpRegisterGamePresenceCallback(void* callback, void* userdata) { + (void)callback; + (void)userdata; +} + +int sceNpRegisterNpReachabilityStateCallback(void* callback, void* userdata) { + (void)callback; + (void)userdata; + return 0; +} + +int sceNpRegisterPlusEventCallback(void* callback, void* userdata) { + (void)callback; + (void)userdata; + return 0; +} + +int sceNpRegisterPremiumEventCallback(void* callback, void* userdata) { + (void)callback; + (void)userdata; + return 0; +} + +int sceNpRegisterStateCallback(void* callback, void* userdata) { + (void)callback; + (void)userdata; + return 0; +} + +int sceNpSetContentRestriction(const NpContentRestriction* restriction) { + (void)restriction; + return 0; +} + +int sceNpSetNpTitleId(const NpTitleId* title_id, const NpTitleSecret* title_secret) { + (void)title_id; + (void)title_secret; + return 0; +} + +int sceNpUnregisterStateCallback(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceNpSessionSignaling/Export.cpp b/core/libs/prx/libSceNpSessionSignaling/Export.cpp new file mode 100644 index 000000000..551526129 --- /dev/null +++ b/core/libs/prx/libSceNpSessionSignaling/Export.cpp @@ -0,0 +1,12 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNpSessionSignalingInitialize(void* param) { + (void)param; + return 0; +} + +} diff --git a/core/libs/prx/libSceNpTrophy2/Export.cpp b/core/libs/prx/libSceNpTrophy2/Export.cpp new file mode 100644 index 000000000..37aaba44d --- /dev/null +++ b/core/libs/prx/libSceNpTrophy2/Export.cpp @@ -0,0 +1,122 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNpTrophy2AbortHandle(int handle) { + (void)handle; + return 0; +} + +int sceNpTrophy2CreateContext(int* context, int user_id, uint32_t service_label, uint64_t options) { + (void)context; + (void)user_id; + (void)service_label; + (void)options; + return 0; +} + +int sceNpTrophy2CreateHandle(int* handle) { + (void)handle; + return 0; +} + +int sceNpTrophy2DestroyContext(int context) { + (void)context; + return 0; +} + +int sceNpTrophy2DestroyHandle(int handle) { + (void)handle; + return 0; +} + +int sceNpTrophy2GetGameIcon(int context, int handle, void* buffer, size_t* size) { + (void)context; + (void)handle; + (void)buffer; + (void)size; + return 0; +} + +int sceNpTrophy2GetGameInfo(int context, int handle, NpTrophy2GameDetails* details, NpTrophy2GameData* data) { + (void)context; + (void)handle; + (void)details; + (void)data; + return 0; +} + +int sceNpTrophy2GetGroupIcon(int context, int handle, int group_id, void* buffer, size_t* size) { + (void)context; + (void)handle; + (void)group_id; + (void)buffer; + (void)size; + return 0; +} + +int sceNpTrophy2GetGroupInfo(int context, int handle, int group_id, NpTrophy2GroupDetails* details, NpTrophy2GroupData* data) { + (void)context; + (void)handle; + (void)group_id; + (void)details; + (void)data; + return 0; +} + +int sceNpTrophy2GetGroupInfoArray(int context, int handle, uint32_t offset, uint32_t limit, NpTrophy2GroupDetails* details_array, NpTrophy2GroupData* data_array, uint32_t* count) { + (void)context; + (void)handle; + (void)offset; + (void)limit; + (void)details_array; + (void)data_array; + (void)count; + return 0; +} + +int sceNpTrophy2GetTrophyIcon(int context, int handle, int trophy_id, void* buffer, size_t* size) { + (void)context; + (void)handle; + (void)trophy_id; + (void)buffer; + (void)size; + return 0; +} + +int sceNpTrophy2GetTrophyInfo(int context, int handle, int trophy_id, NpTrophy2Details* details, NpTrophy2Data* data) { + (void)context; + (void)handle; + (void)trophy_id; + (void)details; + (void)data; + return 0; +} + +int sceNpTrophy2GetTrophyInfoArray(int context, int handle, uint32_t offset, uint32_t limit, NpTrophy2Details* details_array, NpTrophy2Data* data_array, uint32_t* count) { + (void)context; + (void)handle; + (void)offset; + (void)limit; + (void)details_array; + (void)data_array; + (void)count; + return 0; +} + +int sceNpTrophy2RegisterContext(int context, int handle, uint64_t options) { + (void)context; + (void)handle; + (void)options; + return 0; +} + +int sceNpTrophy2RegisterUnlockCallback(void* callback, void* userdata) { + (void)callback; + (void)userdata; + return 0; +} + +} diff --git a/core/libs/prx/libSceNpUniversalDataSystem/Export.cpp b/core/libs/prx/libSceNpUniversalDataSystem/Export.cpp new file mode 100644 index 000000000..9e79d4821 --- /dev/null +++ b/core/libs/prx/libSceNpUniversalDataSystem/Export.cpp @@ -0,0 +1,266 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNpUniversalDataSystemAbortHandle(int handle) { + (void)handle; + return 0; +} + +int sceNpUniversalDataSystemCreateContext(int* context, int user_id, uint32_t service_label, uint64_t options) { + (void)context; + (void)user_id; + (void)service_label; + (void)options; + return 0; +} + +int sceNpUniversalDataSystemCreateEvent(const char* event_name, const NpUniversalDataSystemEventPropertyObject* prop, NpUniversalDataSystemEvent** new_event, NpUniversalDataSystemEventPropertyObject** prop_ptr) { + (void)event_name; + (void)prop; + (void)new_event; + (void)prop_ptr; + return 0; +} + +int sceNpUniversalDataSystemCreateEventPropertyArray(NpUniversalDataSystemEventPropertyArray** new_array) { + (void)new_array; + return 0; +} + +int sceNpUniversalDataSystemCreateEventPropertyObject(NpUniversalDataSystemEventPropertyObject** new_object) { + (void)new_object; + return 0; +} + +int sceNpUniversalDataSystemCreateHandle(int* handle) { + (void)handle; + return 0; +} + +int sceNpUniversalDataSystemDestroyContext(int context) { + (void)context; + return 0; +} + +int sceNpUniversalDataSystemDestroyEvent(NpUniversalDataSystemEvent* event) { + (void)event; + return 0; +} + +int sceNpUniversalDataSystemDestroyEventPropertyArray(NpUniversalDataSystemEventPropertyArray* array) { + (void)array; + return 0; +} + +int sceNpUniversalDataSystemDestroyEventPropertyObject(NpUniversalDataSystemEventPropertyObject* object) { + (void)object; + return 0; +} + +int sceNpUniversalDataSystemDestroyHandle(int handle) { + (void)handle; + return 0; +} + +int sceNpUniversalDataSystemEventEstimateSize(const NpUniversalDataSystemEvent* event, size_t* size) { + (void)event; + (void)size; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetArray(NpUniversalDataSystemEventPropertyArray* array, const NpUniversalDataSystemEventPropertyArray* value, NpUniversalDataSystemEventPropertyArray** value_ptr) { + (void)array; + (void)value; + (void)value_ptr; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetBinary(NpUniversalDataSystemEventPropertyArray* array, const void* value, size_t value_size) { + (void)array; + (void)value; + (void)value_size; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetBool(NpUniversalDataSystemEventPropertyArray* array, bool value) { + (void)array; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetFloat32(NpUniversalDataSystemEventPropertyArray* array, float value) { + (void)array; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetFloat64(NpUniversalDataSystemEventPropertyArray* array, double value) { + (void)array; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetInt32(NpUniversalDataSystemEventPropertyArray* array, int32_t value) { + (void)array; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetInt64(NpUniversalDataSystemEventPropertyArray* array, int64_t value) { + (void)array; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetObject(NpUniversalDataSystemEventPropertyArray* array, const NpUniversalDataSystemEventPropertyObject* value, NpUniversalDataSystemEventPropertyObject** value_ptr) { + (void)array; + (void)value; + (void)value_ptr; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetString(NpUniversalDataSystemEventPropertyArray* array, const char* value) { + (void)array; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetUInt32(NpUniversalDataSystemEventPropertyArray* array, uint32_t value) { + (void)array; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyArraySetUInt64(NpUniversalDataSystemEventPropertyArray* array, uint64_t value) { + (void)array; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetArray(NpUniversalDataSystemEventPropertyObject* object, const char* key, const NpUniversalDataSystemEventPropertyArray* value, NpUniversalDataSystemEventPropertyArray** value_ptr) { + (void)object; + (void)key; + (void)value; + (void)value_ptr; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetBinary(NpUniversalDataSystemEventPropertyObject* object, const char* key, const void* value, size_t value_size) { + (void)object; + (void)key; + (void)value; + (void)value_size; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetBool(NpUniversalDataSystemEventPropertyObject* object, const char* key, bool value) { + (void)object; + (void)key; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetFloat32(NpUniversalDataSystemEventPropertyObject* object, const char* key, float value) { + (void)object; + (void)key; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetFloat64(NpUniversalDataSystemEventPropertyObject* object, const char* key, double value) { + (void)object; + (void)key; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetInt32(NpUniversalDataSystemEventPropertyObject* object, const char* key, int32_t value) { + (void)object; + (void)key; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetInt64(NpUniversalDataSystemEventPropertyObject* object, const char* key, int64_t value) { + (void)object; + (void)key; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetObject(NpUniversalDataSystemEventPropertyObject* object, const char* key, const NpUniversalDataSystemEventPropertyObject* value, NpUniversalDataSystemEventPropertyObject** value_ptr) { + (void)object; + (void)key; + (void)value; + (void)value_ptr; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetString(NpUniversalDataSystemEventPropertyObject* object, const char* key, const char* value) { + (void)object; + (void)key; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetUInt32(NpUniversalDataSystemEventPropertyObject* object, const char* key, uint32_t value) { + (void)object; + (void)key; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventPropertyObjectSetUInt64(NpUniversalDataSystemEventPropertyObject* object, const char* key, uint64_t value) { + (void)object; + (void)key; + (void)value; + return 0; +} + +int sceNpUniversalDataSystemEventToString(const NpUniversalDataSystemEvent* event, char* buf, size_t buf_size, size_t* string_size) { + (void)event; + (void)buf; + (void)buf_size; + (void)string_size; + return 0; +} + +int sceNpUniversalDataSystemGetMemoryStat(NpUniversalDataSystemMemoryStat* stat) { + (void)stat; + return 0; +} + +int sceNpUniversalDataSystemGetStorageStat(int context, NpUniversalDataSystemStorageStat* stat) { + (void)context; + (void)stat; + return 0; +} + +int sceNpUniversalDataSystemInitialize(const NpUniversalDataSystemInitParam* param) { + (void)param; + return 0; +} + +int sceNpUniversalDataSystemPostEvent(int context, int handle, const void* event, uint64_t options) { + (void)context; + (void)handle; + (void)event; + (void)options; + return 0; +} + +int sceNpUniversalDataSystemRegisterContext(int context, int handle, uint64_t options) { + (void)context; + (void)handle; + (void)options; + return 0; +} + +int sceNpUniversalDataSystemTerminate(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceNpWebApi2/Export.cpp b/core/libs/prx/libSceNpWebApi2/Export.cpp new file mode 100644 index 000000000..668883128 --- /dev/null +++ b/core/libs/prx/libSceNpWebApi2/Export.cpp @@ -0,0 +1,124 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceNpWebApi2AbortRequest(int64_t request_id) { + (void)request_id; + return 0; +} + +int sceNpWebApi2AddHttpRequestHeader(int64_t request_id, const char* field_name, const char* value) { + (void)request_id; + (void)field_name; + (void)value; + return 0; +} + +void sceNpWebApi2CheckTimeout(void) { +} + +int sceNpWebApi2CreateRequest(int user_context_id, const char* api_group, const char* path, const char* method, const void* content_parameter, int64_t* request_id) { + (void)user_context_id; + (void)api_group; + (void)path; + (void)method; + (void)content_parameter; + (void)request_id; + return 0; +} + +int sceNpWebApi2CreateUserContext(int lib_ctx_id, int user_id) { + (void)lib_ctx_id; + (void)user_id; + return 0; +} + +int sceNpWebApi2DeleteRequest(int64_t request_id) { + (void)request_id; + return 0; +} + +int sceNpWebApi2DeleteUserContext(int user_context_id) { + (void)user_context_id; + return 0; +} + +int sceNpWebApi2GetHttpResponseHeaderValue(int64_t request_id, const char* field_name, char* value, size_t value_size) { + (void)request_id; + (void)field_name; + (void)value; + (void)value_size; + return 0; +} + +int sceNpWebApi2GetHttpResponseHeaderValueLength(int64_t request_id, const char* field_name, size_t* value_length) { + (void)request_id; + (void)field_name; + (void)value_length; + return 0; +} + +int sceNpWebApi2Initialize(int lib_http_ctx_id, size_t pool_size) { + (void)lib_http_ctx_id; + (void)pool_size; + return 0; +} + +int sceNpWebApi2PushEventCreateFilter(int lib_ctx_id, int handle_id, const char* np_service_name, uint32_t np_service_label, const void* filter_param, size_t filter_param_num) { + (void)lib_ctx_id; + (void)handle_id; + (void)np_service_name; + (void)np_service_label; + (void)filter_param; + (void)filter_param_num; + return 0; +} + +int sceNpWebApi2PushEventCreateHandle(int lib_ctx_id) { + (void)lib_ctx_id; + return 0; +} + +int sceNpWebApi2PushEventDeleteHandle(int lib_ctx_id, int handle_id) { + (void)lib_ctx_id; + (void)handle_id; + return 0; +} + +int sceNpWebApi2PushEventDeletePushContext(int user_context_id, const void* push_context_id) { + (void)user_context_id; + (void)push_context_id; + return 0; +} + +int sceNpWebApi2PushEventRegisterCallback(int user_context_id, int filter_id, void* callback, void* user_arg) { + (void)user_context_id; + (void)filter_id; + (void)callback; + (void)user_arg; + return 0; +} + +int sceNpWebApi2ReadData(int64_t request_id, void* data, size_t size) { + (void)request_id; + (void)data; + (void)size; + return 0; +} + +int sceNpWebApi2SendRequest(int64_t request_id, const void* data, size_t data_size, NpWebApi2ResponseInformationOption* response_info_option) { + (void)request_id; + (void)data; + (void)data_size; + (void)response_info_option; + return 0; +} + +int sceNpWebApi2Terminate(int lib_ctx_id) { + (void)lib_ctx_id; + return 0; +} + +} diff --git a/core/libs/prx/libScePad/Export.cpp b/core/libs/prx/libScePad/Export.cpp new file mode 100644 index 000000000..8ea47556d --- /dev/null +++ b/core/libs/prx/libScePad/Export.cpp @@ -0,0 +1,126 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int scePadClose(int handle) { + (void)handle; + return 0; +} + +int scePadDeviceClassGetExtendedInformation(int handle, PadDeviceClassExtendedInformation* info) { + (void)handle; + (void)info; + return 0; +} + +int scePadDeviceClassParseData(int handle, const PadData* data, PadDeviceClassData* class_data) { + (void)handle; + (void)data; + (void)class_data; + return 0; +} + +int scePadGetControllerInformation(int handle, PadControllerInformation* info) { + (void)handle; + (void)info; + return 0; +} + +int scePadGetHandle(int user_id, int type, int index) { + (void)user_id; + (void)type; + (void)index; + return 0; +} + +int scePadGetTriggerEffectState(int handle, PadTriggerEffectStateInformation* info) { + (void)handle; + (void)info; + return 0; +} + +int scePadInit(void) { + return 0; +} + +int scePadOpen(int user_id, int type, int index, const void* param) { + (void)user_id; + (void)type; + (void)index; + (void)param; + return 0; +} + +int scePadRead(int handle, PadData* data, int num) { + (void)handle; + (void)data; + (void)num; + return 0; +} + +int scePadReadState(int handle, PadData* data) { + (void)handle; + (void)data; + return 0; +} + +int scePadResetLightBar(int handle) { + (void)handle; + return 0; +} + +int scePadResetOrientation(int handle) { + (void)handle; + return 0; +} + +int scePadSetAngularVelocityDeadbandState(int handle, bool enable) { + (void)handle; + (void)enable; + return 0; +} + +int scePadSetLightBar(int handle, const PadLightBarParam* param) { + (void)handle; + (void)param; + return 0; +} + +int scePadSetMotionSensorState(int handle, bool enable) { + (void)handle; + (void)enable; + return 0; +} + +int scePadSetTiltCorrectionState(int handle, bool enabled) { + (void)handle; + (void)enabled; + return 0; +} + +int scePadSetTriggerEffect(int handle, const void* param) { + (void)handle; + (void)param; + return 0; +} + +int scePadSetVibration(int handle, const PadVibrationParam* param) { + (void)handle; + (void)param; + return 0; +} + +int scePadSetVibrationMode(int handle, int mode) { + (void)handle; + (void)mode; + return 0; +} + +int scePadSetVibrationTriggerEffectWeakWhileEmbeddedMicInUse(bool enabled) { + (void)enabled; + return 0; +} + +} diff --git a/core/libs/prx/libScePlayGo/Export.cpp b/core/libs/prx/libScePlayGo/Export.cpp new file mode 100644 index 000000000..a20300b78 --- /dev/null +++ b/core/libs/prx/libScePlayGo/Export.cpp @@ -0,0 +1,129 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int scePlayGoClose(int handle) { + (void)handle; + return 0; +} + +int scePlayGoGetChunkId(int handle, uint16_t* out_chunk_id_list, uint32_t number_of_entries, uint32_t* out_entries) { + (void)handle; + (void)out_chunk_id_list; + (void)number_of_entries; + (void)out_entries; + return 0; +} + +int scePlayGoGetEta(int handle, const uint16_t* chunk_ids, uint32_t number_of_entries, int64_t* out_eta) { + (void)handle; + (void)chunk_ids; + (void)number_of_entries; + (void)out_eta; + return 0; +} + +int scePlayGoGetInstallChunkId(int handle, uint16_t* out_chunk_id_list, uint32_t number_of_entries, uint32_t* out_entries) { + (void)handle; + (void)out_chunk_id_list; + (void)number_of_entries; + (void)out_entries; + return 0; +} + +int scePlayGoGetInstallSpeed(int handle, int32_t* out_speed) { + (void)handle; + (void)out_speed; + return 0; +} + +int scePlayGoGetLanguageMask(int handle, uint64_t* out_language_mask) { + (void)handle; + (void)out_language_mask; + return 0; +} + +int scePlayGoGetLocus(int handle, const uint16_t* chunk_ids, uint32_t number_of_entries, int8_t* out_loci) { + (void)handle; + (void)chunk_ids; + (void)number_of_entries; + (void)out_loci; + return 0; +} + +int scePlayGoGetOptionalChunk(int handle, int32_t type, PlayGoOptionalChunk* option) { + (void)handle; + (void)type; + (void)option; + return 0; +} + +int scePlayGoGetProgress(int handle, const uint16_t* chunk_ids, uint32_t number_of_entries, PlayGoProgress* out_progress) { + (void)handle; + (void)chunk_ids; + (void)number_of_entries; + (void)out_progress; + return 0; +} + +int scePlayGoGetSupportedOptionalChunk(int handle, int32_t type, PlayGoOptionalChunk* option) { + (void)handle; + (void)type; + (void)option; + return 0; +} + +int scePlayGoGetToDoList(int handle, PlayGoToDo* out_todo_list, uint32_t number_of_entries, uint32_t* out_entries) { + (void)handle; + (void)out_todo_list; + (void)number_of_entries; + (void)out_entries; + return 0; +} + +int scePlayGoInitialize(const PlayGoInitParams* init) { + (void)init; + return 0; +} + +int scePlayGoOpen(int* out_handle, const void* param) { + (void)out_handle; + (void)param; + return 0; +} + +int scePlayGoPrefetch(int handle, const uint16_t* chunk_ids, uint32_t number_of_entries, int8_t minimum_locus) { + (void)handle; + (void)chunk_ids; + (void)number_of_entries; + (void)minimum_locus; + return 0; +} + +int scePlayGoPrefetchOptionalChunk(int handle, int32_t type, const PlayGoOptionalChunk* option) { + (void)handle; + (void)type; + (void)option; + return 0; +} + +int scePlayGoSetInstallSpeed(int handle, int32_t speed) { + (void)handle; + (void)speed; + return 0; +} + +int scePlayGoSetToDoList(int handle, const PlayGoToDo* todo_list, uint32_t number_of_entries) { + (void)handle; + (void)todo_list; + (void)number_of_entries; + return 0; +} + +int scePlayGoTerminate(void) { + return 0; +} + +} diff --git a/core/libs/prx/libScePngDec/Export.cpp b/core/libs/prx/libScePngDec/Export.cpp new file mode 100644 index 000000000..4c7f7c375 --- /dev/null +++ b/core/libs/prx/libScePngDec/Export.cpp @@ -0,0 +1,38 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int32_t scePngDecCreate(const PngDecCreateParam* param, void* memory_address, uint32_t memory_size, void** handle) { + (void)param; + (void)memory_address; + (void)memory_size; + (void)handle; + return 0; +} + +int32_t scePngDecDecode(void* handle, const PngDecDecodeParam* param, PngDecImageInfo* image_info) { + (void)handle; + (void)param; + (void)image_info; + return 0; +} + +int32_t scePngDecDelete(void* handle) { + (void)handle; + return 0; +} + +int32_t scePngDecParseHeader(const PngDecParseParam* param, PngDecImageInfo* image_info) { + (void)param; + (void)image_info; + return 0; +} + +int32_t scePngDecQueryMemorySize(const PngDecCreateParam* param) { + (void)param; + return 0; +} + +} diff --git a/core/libs/prx/libSceRandom/Export.cpp b/core/libs/prx/libSceRandom/Export.cpp new file mode 100644 index 000000000..40495d904 --- /dev/null +++ b/core/libs/prx/libSceRandom/Export.cpp @@ -0,0 +1,13 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceRandomGetRandomNumber(void* buf, size_t size) { + (void)buf; + (void)size; + return 0; +} + +} diff --git a/core/libs/prx/libSceRazorCpu/Export.cpp b/core/libs/prx/libSceRazorCpu/Export.cpp new file mode 100644 index 000000000..b8290ce18 --- /dev/null +++ b/core/libs/prx/libSceRazorCpu/Export.cpp @@ -0,0 +1,11 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +uint32_t sceRazorCpuIsCapturing(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceRemoteplay/Export.cpp b/core/libs/prx/libSceRemoteplay/Export.cpp new file mode 100644 index 000000000..f43ee0acd --- /dev/null +++ b/core/libs/prx/libSceRemoteplay/Export.cpp @@ -0,0 +1,23 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceRemoteplayGetConnectionStatus(int user_id, int* status) { + (void)user_id; + (void)status; + return 0; +} + +int sceRemoteplayInitialize(void* heap, size_t heap_size) { + (void)heap; + (void)heap_size; + return 0; +} + +int sceRemoteplayTerminate(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceRtc/Export.cpp b/core/libs/prx/libSceRtc/Export.cpp new file mode 100644 index 000000000..e11099b9b --- /dev/null +++ b/core/libs/prx/libSceRtc/Export.cpp @@ -0,0 +1,159 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceRtcCheckValid(const RtcDateTime* time) { + (void)time; + return 0; +} + +int sceRtcConvertLocalTimeToUtc(const RtcTick* local_time, RtcTick* utc) { + (void)local_time; + (void)utc; + return 0; +} + +int sceRtcConvertUtcToLocalTime(const RtcTick* utc, RtcTick* local_time) { + (void)utc; + (void)local_time; + return 0; +} + +int sceRtcFormatRFC3339(char* date_time, const RtcTick* utc, int time_zone_minutes) { + (void)date_time; + (void)utc; + (void)time_zone_minutes; + return 0; +} + +int sceRtcGetCurrentClock(RtcDateTime* time, int time_zone_minutes) { + (void)time; + (void)time_zone_minutes; + return 0; +} + +int sceRtcGetCurrentClockLocalTime(RtcDateTime* time) { + (void)time; + return 0; +} + +int sceRtcGetCurrentNetworkTick(RtcTick* tick) { + (void)tick; + return 0; +} + +int sceRtcGetCurrentTick(RtcTick* tick) { + (void)tick; + return 0; +} + +int sceRtcGetDayOfWeek(int year, int month, int day) { + (void)year; + (void)month; + (void)day; + return 0; +} + +int sceRtcGetTick(const RtcDateTime* time, RtcTick* tick) { + (void)time; + (void)tick; + return 0; +} + +int sceRtcGetTickResolution(void) { + return 0; +} + +int sceRtcGetTime_t(const RtcDateTime* time, int64_t* seconds) { + (void)time; + (void)seconds; + return 0; +} + +int sceRtcGetWin32FileTime(const RtcDateTime* time, uint64_t* win32_time) { + (void)time; + (void)win32_time; + return 0; +} + +int sceRtcIsLeapYear(int year) { + (void)year; + return 0; +} + +int sceRtcParseRFC3339(RtcTick* utc, const char* date_time) { + (void)utc; + (void)date_time; + return 0; +} + +int sceRtcSetTick(RtcDateTime* time, const RtcTick* tick) { + (void)time; + (void)tick; + return 0; +} + +int sceRtcSetTime_t(RtcDateTime* time, int64_t seconds) { + (void)time; + (void)seconds; + return 0; +} + +int sceRtcSetWin32FileTime(RtcDateTime* time, uint64_t win32_time) { + (void)time; + (void)win32_time; + return 0; +} + +int sceRtcTickAddDays(RtcTick* dst, const RtcTick* src, int32_t days) { + (void)dst; + (void)src; + (void)days; + return 0; +} + +int sceRtcTickAddHours(RtcTick* dst, const RtcTick* src, int32_t hours) { + (void)dst; + (void)src; + (void)hours; + return 0; +} + +int sceRtcTickAddMicroseconds(RtcTick* dst, const RtcTick* src, int64_t usec) { + (void)dst; + (void)src; + (void)usec; + return 0; +} + +int sceRtcTickAddMinutes(RtcTick* dst, const RtcTick* src, int64_t minutes) { + (void)dst; + (void)src; + (void)minutes; + return 0; +} + +int sceRtcTickAddSeconds(RtcTick* dst, const RtcTick* src, int64_t seconds) { + (void)dst; + (void)src; + (void)seconds; + return 0; +} + +int sceRtcTickAddTicks(RtcTick* dst, const RtcTick* src, int64_t ticks) { + (void)dst; + (void)src; + (void)ticks; + return 0; +} + +int sceRtcTickAddWeeks(RtcTick* dst, const RtcTick* src, int32_t weeks) { + (void)dst; + (void)src; + (void)weeks; + return 0; +} + +} diff --git a/core/libs/prx/libSceRudp/Export.cpp b/core/libs/prx/libSceRudp/Export.cpp new file mode 100644 index 000000000..cc7e71c80 --- /dev/null +++ b/core/libs/prx/libSceRudp/Export.cpp @@ -0,0 +1,25 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceRudpEnableInternalIOThread(uint32_t stack_size, uint32_t priority) { + (void)stack_size; + (void)priority; + return 0; +} + +int sceRudpInit(void* mem_pool, int mem_pool_size) { + (void)mem_pool; + (void)mem_pool_size; + return 0; +} + +int sceRudpSetEventHandler(RudpEventHandler handler, void* arg) { + (void)handler; + (void)arg; + return 0; +} + +} diff --git a/core/libs/prx/libSceSaveData.native/Export.cpp b/core/libs/prx/libSceSaveData.native/Export.cpp new file mode 100644 index 000000000..53b26e12c --- /dev/null +++ b/core/libs/prx/libSceSaveData.native/Export.cpp @@ -0,0 +1,139 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSaveDataBackup(const SaveDataBackup* backup) { + (void)backup; + return 0; +} + +int sceSaveDataCommit(const SaveDataCommitParam* param) { + (void)param; + return 0; +} + +int sceSaveDataCreateTransactionResource(uint32_t size) { + (void)size; + return 0; +} + +int sceSaveDataDelete(const SaveDataDelete* del) { + (void)del; + return 0; +} + +int sceSaveDataDeleteTransactionResource(int32_t resource) { + (void)resource; + return 0; +} + +int sceSaveDataDirNameSearch(const SaveDataDirNameSearchCond* cond, SaveDataDirNameSearchResult* result) { + (void)cond; + (void)result; + return 0; +} + +int sceSaveDataGetEventResult(const void* event_param, SaveDataEvent* event) { + (void)event_param; + (void)event; + return 0; +} + +int sceSaveDataGetMountInfo(const SaveDataMountPoint* mount_point, SaveDataMountInfo* info) { + (void)mount_point; + (void)info; + return 0; +} + +int sceSaveDataGetParam(const SaveDataMountPoint* mount_point, uint32_t param_type, void* param_buf, size_t param_buf_size, size_t* got_size) { + (void)mount_point; + (void)param_type; + (void)param_buf; + (void)param_buf_size; + (void)got_size; + return 0; +} + +int sceSaveDataGetSaveDataMemory2(SaveDataMemoryGet2* get_param) { + (void)get_param; + return 0; +} + +int sceSaveDataInitialize3(const void* init) { + (void)init; + return 0; +} + +int sceSaveDataLoadIcon(const SaveDataMountPoint* mount_point, SaveDataIcon* icon) { + (void)mount_point; + (void)icon; + return 0; +} + +int sceSaveDataMount3(const SaveDataMount3* mount, SaveDataMountResult* mount_result) { + (void)mount; + (void)mount_result; + return 0; +} + +int sceSaveDataPrepare(const SaveDataMountPoint* mount_point, const SaveDataPrepareParam* param) { + (void)mount_point; + (void)param; + return 0; +} + +int sceSaveDataSaveIcon(const SaveDataMountPoint* mount_point, const SaveDataIcon* icon) { + (void)mount_point; + (void)icon; + return 0; +} + +int sceSaveDataSaveIconByPath(const SaveDataMountPoint* mount_point, const char* path) { + (void)mount_point; + (void)path; + return 0; +} + +int sceSaveDataSetParam(const SaveDataMountPoint* mount_point, uint32_t param_type, const void* param_buf, size_t param_buf_size) { + (void)mount_point; + (void)param_type; + (void)param_buf; + (void)param_buf_size; + return 0; +} + +int sceSaveDataSetSaveDataMemory2(const SaveDataMemorySet2* set_param) { + (void)set_param; + return 0; +} + +int sceSaveDataSetupSaveDataMemory2(const SaveDataMemorySetup2* setup_param, SaveDataMemorySetupResult* result) { + (void)setup_param; + (void)result; + return 0; +} + +int sceSaveDataSyncSaveDataMemory(const void* sync_param) { + (void)sync_param; + return 0; +} + +int sceSaveDataTerminate(void) { + return 0; +} + +int sceSaveDataTransferringMount(const SaveDataTransferringMount* mount, SaveDataMountResult* mount_result) { + (void)mount; + (void)mount_result; + return 0; +} + +int sceSaveDataUmount2(uint32_t mode, const SaveDataMountPoint* mount_point) { + (void)mode; + (void)mount_point; + return 0; +} + +} diff --git a/core/libs/prx/libSceSaveData/Export.cpp b/core/libs/prx/libSceSaveData/Export.cpp new file mode 100644 index 000000000..16597a7dc --- /dev/null +++ b/core/libs/prx/libSceSaveData/Export.cpp @@ -0,0 +1,100 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSaveDataBackup(const SaveDataBackup* backup) { + (void)backup; + return 0; +} + +int sceSaveDataDelete(const SaveDataDelete* del) { + (void)del; + return 0; +} + +int sceSaveDataDirNameSearch(const SaveDataDirNameSearchCond* cond, SaveDataDirNameSearchResult* result) { + (void)cond; + (void)result; + return 0; +} + +int sceSaveDataGetEventResult(const void* event_param, SaveDataEvent* event) { + (void)event_param; + (void)event; + return 0; +} + +int sceSaveDataGetMountInfo(const SaveDataMountPoint* mount_point, SaveDataMountInfo* info) { + (void)mount_point; + (void)info; + return 0; +} + +int sceSaveDataGetParam(const SaveDataMountPoint* mount_point, uint32_t param_type, void* param_buf, size_t param_buf_size, size_t* got_size) { + (void)mount_point; + (void)param_type; + (void)param_buf; + (void)param_buf_size; + (void)got_size; + return 0; +} + +int sceSaveDataGetSaveDataMemory2(SaveDataMemoryGet2* get_param) { + (void)get_param; + return 0; +} + +int sceSaveDataInitialize3(const void* init) { + (void)init; + return 0; +} + +int sceSaveDataLoadIcon(const SaveDataMountPoint* mount_point, SaveDataIcon* icon) { + (void)mount_point; + (void)icon; + return 0; +} + +int sceSaveDataSaveIcon(const SaveDataMountPoint* mount_point, const SaveDataIcon* icon) { + (void)mount_point; + (void)icon; + return 0; +} + +int sceSaveDataSetParam(const SaveDataMountPoint* mount_point, uint32_t param_type, const void* param_buf, size_t param_buf_size) { + (void)mount_point; + (void)param_type; + (void)param_buf; + (void)param_buf_size; + return 0; +} + +int sceSaveDataSetSaveDataMemory2(const SaveDataMemorySet2* set_param) { + (void)set_param; + return 0; +} + +int sceSaveDataSetupSaveDataMemory2(const SaveDataMemorySetup2* setup_param, SaveDataMemorySetupResult* result) { + (void)setup_param; + (void)result; + return 0; +} + +int sceSaveDataSyncSaveDataMemory(const void* sync_param) { + (void)sync_param; + return 0; +} + +int sceSaveDataTerminate(void) { + return 0; +} + +int sceSaveDataTransferringMount(const SaveDataTransferringMount* mount, SaveDataMountResult* mount_result) { + (void)mount; + (void)mount_result; + return 0; +} + +} diff --git a/core/libs/prx/libSceSaveDataDialog.native/Export.cpp b/core/libs/prx/libSceSaveDataDialog.native/Export.cpp new file mode 100644 index 000000000..1ddf55904 --- /dev/null +++ b/core/libs/prx/libSceSaveDataDialog.native/Export.cpp @@ -0,0 +1,54 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSaveDataDialogClose(const void* close_param) { + (void)close_param; + return 0; +} + +int sceSaveDataDialogGetResult(void* result) { + (void)result; + return 0; +} + +int sceSaveDataDialogGetStatus(void) { + return 0; +} + +int sceSaveDataDialogInitialize(void) { + return 0; +} + +int sceSaveDataDialogIsReadyToDisplay(void) { + return 0; +} + +int sceSaveDataDialogOpen(const void* param) { + (void)param; + return 0; +} + +int sceSaveDataDialogProgressBarInc(int target, uint32_t delta) { + (void)target; + (void)delta; + return 0; +} + +int sceSaveDataDialogProgressBarSetValue(int target, uint32_t rate) { + (void)target; + (void)rate; + return 0; +} + +int sceSaveDataDialogTerminate(void) { + return 0; +} + +int sceSaveDataDialogUpdateStatus(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceSaveDataDialog/Export.cpp b/core/libs/prx/libSceSaveDataDialog/Export.cpp new file mode 100644 index 000000000..1ddf55904 --- /dev/null +++ b/core/libs/prx/libSceSaveDataDialog/Export.cpp @@ -0,0 +1,54 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSaveDataDialogClose(const void* close_param) { + (void)close_param; + return 0; +} + +int sceSaveDataDialogGetResult(void* result) { + (void)result; + return 0; +} + +int sceSaveDataDialogGetStatus(void) { + return 0; +} + +int sceSaveDataDialogInitialize(void) { + return 0; +} + +int sceSaveDataDialogIsReadyToDisplay(void) { + return 0; +} + +int sceSaveDataDialogOpen(const void* param) { + (void)param; + return 0; +} + +int sceSaveDataDialogProgressBarInc(int target, uint32_t delta) { + (void)target; + (void)delta; + return 0; +} + +int sceSaveDataDialogProgressBarSetValue(int target, uint32_t rate) { + (void)target; + (void)rate; + return 0; +} + +int sceSaveDataDialogTerminate(void) { + return 0; +} + +int sceSaveDataDialogUpdateStatus(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceShare.native/Export.cpp b/core/libs/prx/libSceShare.native/Export.cpp new file mode 100644 index 000000000..d789c632a --- /dev/null +++ b/core/libs/prx/libSceShare.native/Export.cpp @@ -0,0 +1,81 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceShareCaptureScreenshot(const void* param, int32_t* req_id) { + (void)param; + (void)req_id; + return 0; +} + +int sceShareCaptureVideoClip(const void* param, int32_t* req_id) { + (void)param; + (void)req_id; + return 0; +} + +int sceShareFeaturePermit(uint32_t feature_flags) { + (void)feature_flags; + return 0; +} + +int sceShareFeatureProhibit(uint32_t feature_flags) { + (void)feature_flags; + return 0; +} + +int sceShareGetCurrentStatus(uint32_t feature_flag, ShareCurrentStatus* status) { + (void)feature_flag; + (void)status; + return 0; +} + +int sceShareInitialize(size_t heap_size, int thread_priority, uint64_t affinity_mask) { + (void)heap_size; + (void)thread_priority; + (void)affinity_mask; + return 0; +} + +int sceShareOpenMenuForContent(const void* content_id) { + (void)content_id; + return 0; +} + +int sceShareRegisterContentEventCallback(void* callback, void* user_data) { + (void)callback; + (void)user_data; + return 0; +} + +int sceShareSetCaptureSource(uint32_t feature_flags, const void* tap_point) { + (void)feature_flags; + (void)tap_point; + return 0; +} + +int sceShareSetContentParam(const char* content_param) { + (void)content_param; + return 0; +} + +int sceShareSetScreenshotOverlayImage(const char* file_path, int32_t margin_x, int32_t margin_y, int32_t origin) { + (void)file_path; + (void)margin_x; + (void)margin_y; + (void)origin; + return 0; +} + +int sceShareTerminate(void) { + return 0; +} + +int sceShareUnregisterContentEventCallback(void* callback) { + (void)callback; + return 0; +} + +} diff --git a/core/libs/prx/libSceSharePlay/Export.cpp b/core/libs/prx/libSceSharePlay/Export.cpp new file mode 100644 index 000000000..618e9c0b4 --- /dev/null +++ b/core/libs/prx/libSceSharePlay/Export.cpp @@ -0,0 +1,17 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSharePlayInitialize(void* heap, size_t heap_size) { + (void)heap; + (void)heap_size; + return 0; +} + +int sceSharePlayTerminate(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceSigninDialog/Export.cpp b/core/libs/prx/libSceSigninDialog/Export.cpp new file mode 100644 index 000000000..27c0685ab --- /dev/null +++ b/core/libs/prx/libSceSigninDialog/Export.cpp @@ -0,0 +1,37 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSigninDialogClose(void) { + return 0; +} + +int sceSigninDialogGetResult(void* result) { + (void)result; + return 0; +} + +int sceSigninDialogGetStatus(void) { + return 0; +} + +int sceSigninDialogInitialize(void) { + return 0; +} + +int sceSigninDialogOpen(const void* param) { + (void)param; + return 0; +} + +int sceSigninDialogTerminate(void) { + return 0; +} + +int sceSigninDialogUpdateStatus(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceSsl/Export.cpp b/core/libs/prx/libSceSsl/Export.cpp new file mode 100644 index 000000000..636179538 --- /dev/null +++ b/core/libs/prx/libSceSsl/Export.cpp @@ -0,0 +1,29 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSslFreeCaCerts(int ssl_ctx_id, void* ca_certs) { + (void)ssl_ctx_id; + (void)ca_certs; + return 0; +} + +int sceSslGetCaCerts(int ssl_ctx_id, void* ca_certs) { + (void)ssl_ctx_id; + (void)ca_certs; + return 0; +} + +int sceSslInit(uint64_t pool_size) { + (void)pool_size; + return 0; +} + +int sceSslTerm(int ssl_ctx_id) { + (void)ssl_ctx_id; + return 0; +} + +} diff --git a/core/libs/prx/libSceSysmodule/Export.cpp b/core/libs/prx/libSceSysmodule/Export.cpp new file mode 100644 index 000000000..84dc25eb4 --- /dev/null +++ b/core/libs/prx/libSceSysmodule/Export.cpp @@ -0,0 +1,38 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSysmoduleGetModuleInfoForUnwind(uint64_t addr, int flags, ModuleInfoForUnwind* info) { + (void)addr; + (void)flags; + (void)info; + return 0; +} + +int sceSysmoduleIsLoaded(uint16_t id) { + (void)id; + return 0; +} + +int sceSysmoduleLoadModule(uint16_t id) { + (void)id; + return 0; +} + +int sceSysmoduleLoadModuleInternalWithArg(uint16_t id, int arg1, int arg2, int arg3, int* ret) { + (void)id; + (void)arg1; + (void)arg2; + (void)arg3; + (void)ret; + return 0; +} + +int sceSysmoduleUnloadModule(uint16_t id) { + (void)id; + return 0; +} + +} diff --git a/core/libs/prx/libSceSystemGesture/Export.cpp b/core/libs/prx/libSceSystemGesture/Export.cpp new file mode 100644 index 000000000..9c0a4ae48 --- /dev/null +++ b/core/libs/prx/libSceSystemGesture/Export.cpp @@ -0,0 +1,144 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSystemGestureAppendTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer) { + (void)gesture_handle; + (void)recognizer; + return 0; +} + +int sceSystemGestureClose(int32_t gesture_handle) { + (void)gesture_handle; + return 0; +} + +int sceSystemGestureCreateTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer, int32_t, const SystemGestureRectangle*, const void*) { + (void)gesture_handle; + (void)recognizer; + (void)int32_t; + (void)SystemGestureRectangle; + return 0; +} + +int sceSystemGestureFinalizePrimitiveTouchRecognizer(void) { + return 0; +} + +int sceSystemGestureGetPrimitiveTouchEventByIndex(int32_t gesture_handle, uint32_t, SystemGesturePrimitiveTouchEvent* event) { + (void)gesture_handle; + (void)uint32_t; + (void)event; + return 0; +} + +int sceSystemGestureGetPrimitiveTouchEventByPrimitiveID(int32_t gesture_handle, uint16_t, SystemGesturePrimitiveTouchEvent* event) { + (void)gesture_handle; + (void)uint16_t; + (void)event; + return 0; +} + +int sceSystemGestureGetPrimitiveTouchEvents(int32_t gesture_handle, SystemGesturePrimitiveTouchEvent* event_buffer, uint32_t capacity_of_buffer, uint32_t* number_of_event) { + (void)gesture_handle; + (void)event_buffer; + (void)capacity_of_buffer; + (void)number_of_event; + return 0; +} + +int sceSystemGestureGetPrimitiveTouchEventsCount(int32_t gesture_handle) { + (void)gesture_handle; + return 0; +} + +int sceSystemGestureGetTouchEventByEventID(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer, uint32_t, SystemGestureTouchEvent* event) { + (void)gesture_handle; + (void)recognizer; + (void)uint32_t; + (void)event; + return 0; +} + +int sceSystemGestureGetTouchEventByIndex(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer, uint32_t, SystemGestureTouchEvent* event) { + (void)gesture_handle; + (void)recognizer; + (void)uint32_t; + (void)event; + return 0; +} + +int sceSystemGestureGetTouchEvents(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer, SystemGestureTouchEvent* event_buffer, uint32_t capacity_of_buffer, uint32_t* number_of_event) { + (void)gesture_handle; + (void)recognizer; + (void)event_buffer; + (void)capacity_of_buffer; + (void)number_of_event; + return 0; +} + +int sceSystemGestureGetTouchEventsCount(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer) { + (void)gesture_handle; + (void)recognizer; + return 0; +} + +int sceSystemGestureGetTouchRecognizerInformation(int32_t gesture_handle, const SystemGestureTouchRecognizer* recognizer, SystemGestureTouchRecognizerInformation* information) { + (void)gesture_handle; + (void)recognizer; + (void)information; + return 0; +} + +int sceSystemGestureInitializePrimitiveTouchRecognizer(const void*) { + return 0; +} + +int32_t sceSystemGestureOpen(int32_t input_type, const void*) { + (void)input_type; + return 0; +} + +int sceSystemGestureRemoveTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer) { + (void)gesture_handle; + (void)recognizer; + return 0; +} + +int sceSystemGestureResetPrimitiveTouchRecognizer(int32_t gesture_handle) { + (void)gesture_handle; + return 0; +} + +int sceSystemGestureResetTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer) { + (void)gesture_handle; + (void)recognizer; + return 0; +} + +int sceSystemGestureUpdateAllTouchRecognizer(int32_t gesture_handle) { + (void)gesture_handle; + return 0; +} + +int sceSystemGestureUpdatePrimitiveTouchRecognizer(int32_t gesture_handle, const void*) { + (void)gesture_handle; + return 0; +} + +int sceSystemGestureUpdateTouchRecognizer(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer) { + (void)gesture_handle; + (void)recognizer; + return 0; +} + +int sceSystemGestureUpdateTouchRecognizerRectangle(int32_t gesture_handle, SystemGestureTouchRecognizer* recognizer, const SystemGestureRectangle* rectangle) { + (void)gesture_handle; + (void)recognizer; + (void)rectangle; + return 0; +} + +} diff --git a/core/libs/prx/libSceSystemService/Export.cpp b/core/libs/prx/libSceSystemService/Export.cpp new file mode 100644 index 000000000..9bc29a24b --- /dev/null +++ b/core/libs/prx/libSceSystemService/Export.cpp @@ -0,0 +1,66 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceSystemServiceDisableNoticeScreenSkipFlagAutoSet(void) { + return 0; +} + +int sceSystemServiceGetDisplaySafeAreaInfo(SystemServiceDisplaySafeAreaInfo* info) { + (void)info; + return 0; +} + +int sceSystemServiceGetHdrToneMapLuminance(SystemServiceHdrToneMapLuminance* luminance) { + (void)luminance; + return 0; +} + +int sceSystemServiceGetNoticeScreenSkipFlag(bool* value) { + (void)value; + return 0; +} + +int sceSystemServiceGetStatus(SystemServiceStatus* status) { + (void)status; + return 0; +} + +int sceSystemServiceHideSplashScreen(void) { + return 0; +} + +int sceSystemServiceParamGetInt(int param_id, int* value) { + (void)param_id; + (void)value; + return 0; +} + +int sceSystemServiceParamGetString(int param_id, char* buf, size_t buf_size) { + (void)param_id; + (void)buf; + (void)buf_size; + return 0; +} + +int sceSystemServicePowerTick(void) { + return 0; +} + +int sceSystemServiceReceiveEvent(SystemServiceEvent* event) { + (void)event; + return 0; +} + +int sceSystemServiceReportAbnormalTermination(const void* info) { + (void)info; + return 0; +} + +int sceSystemServiceSetNoticeScreenSkipFlag(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceUlt/Export.cpp b/core/libs/prx/libSceUlt/Export.cpp new file mode 100644 index 000000000..6daa7a912 --- /dev/null +++ b/core/libs/prx/libSceUlt/Export.cpp @@ -0,0 +1,175 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceUltFinalize(void) { + return 0; +} + +int sceUltInitialize(void) { + return 0; +} + +int sceUltMutexCreate(void* mutex, const char* name, void* waiting_queue_resource_pool, const UltMutexOptParam* opt_param, uint32_t build_version) { + (void)mutex; + (void)name; + (void)waiting_queue_resource_pool; + (void)opt_param; + (void)build_version; + return 0; +} + +int sceUltMutexLock(void* mutex) { + (void)mutex; + return 0; +} + +int sceUltMutexOptParamInitialize(UltMutexOptParam* opt_param, uint32_t build_version) { + (void)opt_param; + (void)build_version; + return 0; +} + +int sceUltMutexUnlock(void* mutex) { + (void)mutex; + return 0; +} + +int sceUltQueueCreate(void* queue, const char* name, uint64_t data_size, void* waiting_queue_resource_pool, void* queue_data_resource_pool, const void* opt_param, uint32_t build_version) { + (void)queue; + (void)name; + (void)data_size; + (void)waiting_queue_resource_pool; + (void)queue_data_resource_pool; + (void)opt_param; + (void)build_version; + return 0; +} + +int sceUltQueueDataResourcePoolCreate(void* pool, const char* name, uint32_t num_data, uint64_t data_size, uint32_t num_queue_object, void* waiting_queue_resource_pool, void* work_area, const void* opt_param, uint32_t build_version) { + (void)pool; + (void)name; + (void)num_data; + (void)data_size; + (void)num_queue_object; + (void)waiting_queue_resource_pool; + (void)work_area; + (void)opt_param; + (void)build_version; + return 0; +} + +uint64_t sceUltQueueDataResourcePoolGetWorkAreaSize(uint32_t num_data, uint64_t data_size, uint32_t num_queue_object) { + (void)num_data; + (void)data_size; + (void)num_queue_object; + return 0; +} + +int sceUltQueuePush(void* queue, const void* data) { + (void)queue; + (void)data; + return 0; +} + +int sceUltQueueTryPop(void* queue, void* data) { + (void)queue; + (void)data; + return 0; +} + +int sceUltSemaphoreAcquire(void* semaphore, int32_t num_resource) { + (void)semaphore; + (void)num_resource; + return 0; +} + +int sceUltSemaphoreCreate(void* semaphore, const char* name, int32_t num_initial_resource, void* waiting_queue_resource_pool, const void* opt_param, uint32_t build_version) { + (void)semaphore; + (void)name; + (void)num_initial_resource; + (void)waiting_queue_resource_pool; + (void)opt_param; + (void)build_version; + return 0; +} + +int sceUltSemaphoreDestroy(void* semaphore) { + (void)semaphore; + return 0; +} + +int sceUltSemaphoreRelease(void* semaphore, int32_t num_resource) { + (void)semaphore; + (void)num_resource; + return 0; +} + +int sceUltSemaphoreTryAcquire(void* semaphore, int32_t num_resource) { + (void)semaphore; + (void)num_resource; + return 0; +} + +int sceUltUlthreadCreate(void* ulthread, const char* name, UltUlthreadEntry entry, uint64_t arg, void* context, uint64_t size_context, void* runtime, const void* opt_param, uint32_t build_version) { + (void)ulthread; + (void)name; + (void)entry; + (void)arg; + (void)context; + (void)size_context; + (void)runtime; + (void)opt_param; + (void)build_version; + return 0; +} + +int sceUltUlthreadJoin(void* ulthread, int32_t* status) { + (void)ulthread; + (void)status; + return 0; +} + +int sceUltUlthreadRuntimeCreate(void* runtime, const char* name, uint32_t max_num_ulthread, uint32_t num_worker_thread, void* work_area, const void* opt_param, uint32_t build_version) { + (void)runtime; + (void)name; + (void)max_num_ulthread; + (void)num_worker_thread; + (void)work_area; + (void)opt_param; + (void)build_version; + return 0; +} + +uint64_t sceUltUlthreadRuntimeGetWorkAreaSize(uint32_t max_num_ulthread, uint32_t num_worker_thread) { + (void)max_num_ulthread; + (void)num_worker_thread; + return 0; +} + +int sceUltUlthreadRuntimeOptParamInitialize(UltUlthreadRuntimeOptParam* opt_param, uint32_t build_version) { + (void)opt_param; + (void)build_version; + return 0; +} + +int sceUltWaitingQueueResourcePoolCreate(void* pool, const char* name, uint32_t num_threads, uint32_t num_sync_objects, void* work_area, const void* opt_param, uint32_t build_version) { + (void)pool; + (void)name; + (void)num_threads; + (void)num_sync_objects; + (void)work_area; + (void)opt_param; + (void)build_version; + return 0; +} + +uint64_t sceUltWaitingQueueResourcePoolGetWorkAreaSize(uint32_t num_threads, uint32_t num_sync_objects) { + (void)num_threads; + (void)num_sync_objects; + return 0; +} + +} diff --git a/core/libs/prx/libSceUserService/Export.cpp b/core/libs/prx/libSceUserService/Export.cpp new file mode 100644 index 000000000..c297b940c --- /dev/null +++ b/core/libs/prx/libSceUserService/Export.cpp @@ -0,0 +1,86 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceUserServiceGetAccessibilityChatTranscription(int user_id, int32_t* chat_transcription) { + (void)user_id; + (void)chat_transcription; + return 0; +} + +int sceUserServiceGetAccessibilityPressAndHoldDelay(int user_id, int32_t* press_and_hold_delay) { + (void)user_id; + (void)press_and_hold_delay; + return 0; +} + +int sceUserServiceGetAccessibilityTriggerEffect(int user_id, int32_t* trigger_effect) { + (void)user_id; + (void)trigger_effect; + return 0; +} + +int sceUserServiceGetAccessibilityVibration(int user_id, int32_t* vibration) { + (void)user_id; + (void)vibration; + return 0; +} + +int sceUserServiceGetAccessibilityZoomEnabled(int user_id, int32_t* zoom_enabled) { + (void)user_id; + (void)zoom_enabled; + return 0; +} + +int sceUserServiceGetAgeLevel(int user_id, uint32_t* age_level) { + (void)user_id; + (void)age_level; + return 0; +} + +int sceUserServiceGetEvent(SceUserServiceEvent* event) { + (void)event; + return 0; +} + +int sceUserServiceGetGamePresets(int user_id, UserServiceGamePresets* presets) { + (void)user_id; + (void)presets; + return 0; +} + +int sceUserServiceGetInitialUser(int* user_id) { + (void)user_id; + return 0; +} + +int sceUserServiceGetLoginUserIdList(UserServiceLoginUserIdList* user_id_list) { + (void)user_id_list; + return 0; +} + +int sceUserServiceGetUserName(int user_id, char* name, size_t size) { + (void)user_id; + (void)name; + (void)size; + return 0; +} + +int sceUserServiceGetUserNumber(int user_id, int32_t* number) { + (void)user_id; + (void)number; + return 0; +} + +int sceUserServiceInitialize(const void* params) { + (void)params; + return 0; +} + +int sceUserServiceInitialize2(void) { + return 0; +} + +} diff --git a/core/libs/prx/libSceVideoOut/Export.cpp b/core/libs/prx/libSceVideoOut/Export.cpp new file mode 100644 index 000000000..89a6b17a9 --- /dev/null +++ b/core/libs/prx/libSceVideoOut/Export.cpp @@ -0,0 +1,191 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceVideoOutAddFlipEvent(KernelEqueue eq, int handle, void* udata) { + (void)eq; + (void)handle; + (void)udata; + return 0; +} + +int sceVideoOutAddOutputModeEvent(KernelEqueue eq, int handle, void* udata) { + (void)eq; + (void)handle; + (void)udata; + return 0; +} + +int sceVideoOutAddPreVblankStartEvent(KernelEqueue eq, int handle, void* udata) { + (void)eq; + (void)handle; + (void)udata; + return 0; +} + +int sceVideoOutAddVblankEvent(KernelEqueue eq, int handle, void* udata) { + (void)eq; + (void)handle; + (void)udata; + return 0; +} + +int sceVideoOutClose(int handle) { + (void)handle; + return 0; +} + +int sceVideoOutConfigureOutput(int handle, uint64_t mode, const VideoOutOutputOptions* options, void* reserved_ptr, uint64_t reserved) { + (void)handle; + (void)mode; + (void)options; + (void)reserved_ptr; + (void)reserved; + return 0; +} + +int sceVideoOutDeleteFlipEvent(KernelEqueue eq, int handle) { + (void)eq; + (void)handle; + return 0; +} + +int sceVideoOutDeletePreVblankStartEvent(KernelEqueue eq, int handle) { + (void)eq; + (void)handle; + return 0; +} + +int sceVideoOutDeleteVblankEvent(KernelEqueue eq, int handle) { + (void)eq; + (void)handle; + return 0; +} + +int sceVideoOutGetEventCount(const KernelEvent* ev) { + (void)ev; + return 0; +} + +int sceVideoOutGetEventData(const KernelEvent* ev, int64_t* data) { + (void)ev; + (void)data; + return 0; +} + +int sceVideoOutGetEventId(const KernelEvent* ev) { + (void)ev; + return 0; +} + +int sceVideoOutGetFlipStatus(int handle, VideoOutFlipStatus* status) { + (void)handle; + (void)status; + return 0; +} + +int sceVideoOutGetOutputStatus(int handle, VideoOutOutputStatus* status) { + (void)handle; + (void)status; + return 0; +} + +int sceVideoOutGetVblankStatus(int handle, VideoOutVblankStatus* status) { + (void)handle; + (void)status; + return 0; +} + +int sceVideoOutInitializeOutputOptions(VideoOutOutputOptions* options) { + (void)options; + return 0; +} + +int sceVideoOutIsFlipPending(int handle) { + (void)handle; + return 0; +} + +int sceVideoOutIsOutputSupported(int handle, uint64_t mode, const VideoOutOutputOptions* options, void* reserved_ptr, uint64_t reserved) { + (void)handle; + (void)mode; + (void)options; + (void)reserved_ptr; + (void)reserved; + return 0; +} + +int sceVideoOutOpen(int user_id, int bus_type, int index, const void* param) { + (void)user_id; + (void)bus_type; + (void)index; + (void)param; + return 0; +} + +int sceVideoOutRegisterBuffers2(int handle, int set_index, int buffer_index_start, const VideoOutBuffers* buffers, int buffer_num, const VideoOutBufferAttribute2* attribute, int category, void* option) { + (void)handle; + (void)set_index; + (void)buffer_index_start; + (void)buffers; + (void)buffer_num; + (void)attribute; + (void)category; + (void)option; + return 0; +} + +void sceVideoOutSetBufferAttribute2(VideoOutBufferAttribute2* attribute, uint64_t pixel_format, uint32_t tiling_mode, uint32_t width, uint32_t height, uint64_t option, uint32_t dcc_control, uint64_t dcc_cb_register_clear_color) { + (void)attribute; + (void)pixel_format; + (void)tiling_mode; + (void)width; + (void)height; + (void)option; + (void)dcc_control; + (void)dcc_cb_register_clear_color; +} + +int sceVideoOutSetFlipRate(int handle, int rate) { + (void)handle; + (void)rate; + return 0; +} + +int sceVideoOutSetWindowModeMargins(int handle, int top, int bottom) { + (void)handle; + (void)top; + (void)bottom; + return 0; +} + +int sceVideoOutSubmitChangeBufferAttribute2(int handle, int set_index, const VideoOutBufferAttribute2* attribute, void* option) { + (void)handle; + (void)set_index; + (void)attribute; + (void)option; + return 0; +} + +int sceVideoOutSubmitFlip(int handle, int index, int flip_mode, int64_t flip_arg) { + (void)handle; + (void)index; + (void)flip_mode; + (void)flip_arg; + return 0; +} + +int sceVideoOutUnregisterBuffers(int handle, int set_index) { + (void)handle; + (void)set_index; + return 0; +} + +int sceVideoOutWaitVblank(int handle) { + (void)handle; + return 0; +} + +} diff --git a/core/libs/prx/libSceVoice/Export.cpp b/core/libs/prx/libSceVoice/Export.cpp new file mode 100644 index 000000000..83e6d2ac3 --- /dev/null +++ b/core/libs/prx/libSceVoice/Export.cpp @@ -0,0 +1,101 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceVoiceConnectIPortToOPort(uint32_t input_port_id, uint32_t output_port_id) { + (void)input_port_id; + (void)output_port_id; + return 0; +} + +int sceVoiceCreatePort(uint32_t* port_id, const VoicePortParam* param) { + (void)port_id; + (void)param; + return 0; +} + +int sceVoiceDeletePort(uint32_t port_id) { + (void)port_id; + return 0; +} + +int sceVoiceDisconnectIPortFromOPort(uint32_t input_port_id, uint32_t output_port_id) { + (void)input_port_id; + (void)output_port_id; + return 0; +} + +int sceVoiceEnd(void) { + return 0; +} + +int sceVoiceGetBitRate(uint32_t port_id, uint32_t* bitrate) { + (void)port_id; + (void)bitrate; + return 0; +} + +int sceVoiceGetPortAttr(uint32_t port_id, int32_t attr, void* value, int32_t size) { + (void)port_id; + (void)attr; + (void)value; + (void)size; + return 0; +} + +int sceVoiceGetPortInfo(uint32_t port_id, VoicePortInfo* info) { + (void)port_id; + (void)info; + return 0; +} + +int sceVoiceGetVolume(uint32_t port_id, float* volume) { + (void)port_id; + (void)volume; + return 0; +} + +int sceVoiceInit(VoiceInitParam* param, int32_t version) { + (void)param; + (void)version; + return 0; +} + +int sceVoiceReadFromOPort(uint32_t output_port_id, void* data, uint32_t* size) { + (void)output_port_id; + (void)data; + (void)size; + return 0; +} + +int sceVoiceSetThreadsParams(void* params) { + (void)params; + return 0; +} + +int sceVoiceSetVolume(uint32_t port_id, float volume) { + (void)port_id; + (void)volume; + return 0; +} + +int sceVoiceStart(const VoiceStartParam* param) { + (void)param; + return 0; +} + +int sceVoiceStop(void) { + return 0; +} + +int sceVoiceWriteToIPort(uint32_t input_port_id, const void* data, uint32_t* size, int16_t frame_gaps) { + (void)input_port_id; + (void)data; + (void)size; + (void)frame_gaps; + return 0; +} + +} diff --git a/core/libs/prx/libSceVoiceQoS/Export.cpp b/core/libs/prx/libSceVoiceQoS/Export.cpp new file mode 100644 index 000000000..71da69777 --- /dev/null +++ b/core/libs/prx/libSceVoiceQoS/Export.cpp @@ -0,0 +1,14 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceVoiceQoSInit(void* mem_block, uint32_t mem_size, int32_t app_type) { + (void)mem_block; + (void)mem_size; + (void)app_type; + return 0; +} + +} diff --git a/core/libs/prx/libSceWebBrowserDialog/Export.cpp b/core/libs/prx/libSceWebBrowserDialog/Export.cpp new file mode 100644 index 000000000..8fbc97f68 --- /dev/null +++ b/core/libs/prx/libSceWebBrowserDialog/Export.cpp @@ -0,0 +1,15 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int sceWebBrowserDialogInitialize(void) { + return 0; +} + +int sceWebBrowserDialogTerminate(void) { + return 0; +} + +} diff --git a/core/libs/prx/libkernel/Export.cpp b/core/libs/prx/libkernel/Export.cpp new file mode 100644 index 000000000..718712b00 --- /dev/null +++ b/core/libs/prx/libkernel/Export.cpp @@ -0,0 +1,1876 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int accept(int s, void* addr, uint32_t* addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int bind(int s, const void* addr, uint32_t addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int chmod(const char* path, int mode) { + (void)path; + (void)mode; + return 0; +} + +int clock_getres(int clock_id, KernelTimespec* res) { + (void)clock_id; + (void)res; + return 0; +} + +int clock_gettime(int clock_id, KernelTimespec* time) { + (void)clock_id; + (void)time; + return 0; +} + +int close(int d) { + (void)d; + return 0; +} + +int connect(int s, const void* addr, uint32_t addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +void exit(int code) { + (void)code; +} + +int flock(int d, int operation) { + (void)d; + (void)operation; + return 0; +} + +int64_t fstat(int d, FileStat* sb) { + (void)d; + (void)sb; + return 0; +} + +int ftruncate(int d, int64_t length) { + (void)d; + (void)length; + return 0; +} + +int getargc(void) { + return 0; +} + +const char** getargv(void) { + return nullptr; +} + +int getpagesize(void) { + return 0; +} + +int getpid(void) { + return 0; +} + +int getsockname(int s, void* addr, uint32_t* addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int getsockopt(int s, int level, int optname, void* optval, uint32_t* optlen) { + (void)s; + (void)level; + (void)optname; + (void)optval; + (void)optlen; + return 0; +} + +int gettimeofday(KernelTimeval* time, KernelTimezone* timezone) { + (void)time; + (void)timezone; + return 0; +} + +const char* inet_ntop(int af, const void* src, char* dst, uint32_t size) { + (void)af; + (void)src; + (void)dst; + (void)size; + return nullptr; +} + +int inet_pton(int af, const char* src, void* dst) { + (void)af; + (void)src; + (void)dst; + return 0; +} + +int listen(int s, int backlog) { + (void)s; + (void)backlog; + return 0; +} + +int64_t lseek(int d, int64_t offset, int whence) { + (void)d; + (void)offset; + (void)whence; + return 0; +} + +int mkdir(const char* path, uint16_t mode) { + (void)path; + (void)mode; + return 0; +} + +int nanosleep(const KernelTimespec* rqtp, KernelTimespec* rmtp) { + (void)rqtp; + (void)rmtp; + return 0; +} + +int open(const char* path, int flags, int mode) { + (void)path; + (void)flags; + (void)mode; + return 0; +} + +int64_t pread(int d, void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int pthread_attr_destroy(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int pthread_attr_get_np(Pthread thread, PthreadAttr* attr) { + (void)thread; + (void)attr; + return 0; +} + +int pthread_attr_getdetachstate(const PthreadAttr* attr, int* state) { + (void)attr; + (void)state; + return 0; +} + +int pthread_attr_getguardsize(const PthreadAttr* attr, size_t* guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int pthread_attr_getschedparam(const PthreadAttr* attr, KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int pthread_attr_getschedpolicy(const PthreadAttr* attr, int* policy) { + (void)attr; + (void)policy; + return 0; +} + +int pthread_attr_getstack(const PthreadAttr* __restrict attr, void** __restrict stack_addr, size_t* __restrict stack_size) { + (void)attr; + (void)stack_addr; + (void)stack_size; + return 0; +} + +int pthread_attr_getstacksize(const PthreadAttr* attr, size_t* stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int pthread_attr_init(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int pthread_attr_setdetachstate(PthreadAttr* attr, int state) { + (void)attr; + (void)state; + return 0; +} + +int pthread_attr_setguardsize(PthreadAttr* attr, size_t guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int pthread_attr_setinheritsched(PthreadAttr* attr, int inherit_sched) { + (void)attr; + (void)inherit_sched; + return 0; +} + +int pthread_attr_setschedparam(PthreadAttr* attr, const KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int pthread_attr_setschedpolicy(PthreadAttr* attr, int policy) { + (void)attr; + (void)policy; + return 0; +} + +int pthread_attr_setstacksize(PthreadAttr* attr, size_t stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int pthread_cond_broadcast(PthreadCond* cond) { + (void)cond; + return 0; +} + +int pthread_cond_init(PthreadCond* cond, const PthreadCondattr* attr) { + (void)cond; + (void)attr; + return 0; +} + +int pthread_cond_signal(PthreadCond* cond) { + (void)cond; + return 0; +} + +int pthread_cond_timedwait(PthreadCond* cond, PthreadMutex* mutex, const KernelTimespec* abstime) { + (void)cond; + (void)mutex; + (void)abstime; + return 0; +} + +int pthread_cond_wait(PthreadCond* cond, PthreadMutex* mutex) { + (void)cond; + (void)mutex; + return 0; +} + +int pthread_condattr_destroy(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int pthread_condattr_init(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int pthread_condattr_setclock(PthreadCondattr* attr, KernelClockid clock_id) { + (void)attr; + (void)clock_id; + return 0; +} + +int pthread_create(Pthread* thread, const PthreadAttr* attr, pthread_entry_func_t entry, void* arg) { + (void)thread; + (void)attr; + (void)entry; + (void)arg; + return 0; +} + +int pthread_create_name_np(Pthread* thread, const PthreadAttr* attr, pthread_entry_func_t entry, void* arg, const char* name) { + (void)thread; + (void)attr; + (void)entry; + (void)arg; + (void)name; + return 0; +} + +int pthread_detach(Pthread thread) { + (void)thread; + return 0; +} + +void pthread_exit(void* value) { + (void)value; +} + +int pthread_getschedparam(Pthread thread, int* policy, KernelSchedParam* param) { + (void)thread; + (void)policy; + (void)param; + return 0; +} + +void* pthread_getspecific(PthreadKey key) { + (void)key; + return nullptr; +} + +int pthread_join(Pthread thread, void** value) { + (void)thread; + (void)value; + return 0; +} + +int pthread_key_create(PthreadKey* key, pthread_key_destructor_func_t destructor) { + (void)key; + (void)destructor; + return 0; +} + +int pthread_key_delete(PthreadKey key) { + (void)key; + return 0; +} + +int pthread_mutex_destroy(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutex_init(PthreadMutex* mutex, const PthreadMutexattr* attr) { + (void)mutex; + (void)attr; + return 0; +} + +int pthread_mutex_lock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutex_timedlock(PthreadMutex* mutex, const KernelTimespec* abstime) { + (void)mutex; + (void)abstime; + return 0; +} + +int pthread_mutex_trylock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutex_unlock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutexattr_destroy(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int pthread_mutexattr_init(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int pthread_mutexattr_setprotocol(PthreadMutexattr* attr, int protocol) { + (void)attr; + (void)protocol; + return 0; +} + +int pthread_mutexattr_settype(PthreadMutexattr* attr, int type) { + (void)attr; + (void)type; + return 0; +} + +int pthread_once(void* once_control, void(KYTY_SYSV_ABI* init_routine)()) { + (void)once_control; + (void)init_routine; + return 0; +} + +int pthread_rename_np(Pthread thread, const char* name) { + (void)thread; + (void)name; + return 0; +} + +int pthread_rwlock_destroy(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int pthread_rwlock_init(PthreadRwlock* rwlock, const PthreadRwlockattr* attr) { + (void)rwlock; + (void)attr; + return 0; +} + +int pthread_rwlock_wrlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +Pthread pthread_self(void) { + return {}; +} + +int pthread_setcancelstate(int state, int* old_state) { + (void)state; + (void)old_state; + return 0; +} + +int pthread_setprio(Pthread thread, int prio) { + (void)thread; + (void)prio; + return 0; +} + +int pthread_setschedparam(Pthread thread, int policy, const KernelSchedParam* param) { + (void)thread; + (void)policy; + (void)param; + return 0; +} + +int pthread_setspecific(PthreadKey key, void* value) { + (void)key; + (void)value; + return 0; +} + +void pthread_yield(void) { +} + +int64_t pwrite(int d, const void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int64_t read(int d, void* buf, uint64_t nbytes) { + (void)d; + (void)buf; + (void)nbytes; + return 0; +} + +int64_t recv(int s, void* buf, uint64_t len, int flags) { + (void)s; + (void)buf; + (void)len; + (void)flags; + return 0; +} + +int64_t recvfrom(int s, void* buf, uint64_t len, int flags, void* addr, uint32_t* addrlen) { + (void)s; + (void)buf; + (void)len; + (void)flags; + (void)addr; + (void)addrlen; + return 0; +} + +int sceCoredumpRegisterCoredumpHandler(uint64_t handler, size_t stack_size, uint64_t context) { + (void)handler; + (void)stack_size; + (void)context; + return 0; +} + +int sceCoredumpUnregisterCoredumpHandler(void) { + return 0; +} + +int sceKernelAddAmprEvent(KernelEqueue eq, int id, void* udata) { + (void)eq; + (void)id; + (void)udata; + return 0; +} + +int sceKernelAddHRTimerEvent(KernelEqueue eq, int id, const KernelTimespec* ts, void* udata) { + (void)eq; + (void)id; + (void)ts; + (void)udata; + return 0; +} + +int sceKernelAddUserEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelAddUserEventEdge(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelAioDeleteRequest(int32_t id, int32_t* ret) { + (void)id; + (void)ret; + return 0; +} + +int sceKernelAioInitializeImpl(void* param, int32_t size) { + (void)param; + (void)size; + return 0; +} + +void sceKernelAioInitializeParam(void* param) { + (void)param; +} + +int sceKernelAioSubmitReadCommands(KernelAioRwRequest* req, int32_t size, int32_t prio, int32_t* id) { + (void)req; + (void)size; + (void)prio; + (void)id; + return 0; +} + +int sceKernelAioSubmitWriteCommands(KernelAioRwRequest* req, int32_t size, int32_t prio, int32_t* id) { + (void)req; + (void)size; + (void)prio; + (void)id; + return 0; +} + +int sceKernelAioWaitRequest(int32_t id, int32_t* state, uint32_t* usec) { + (void)id; + (void)state; + (void)usec; + return 0; +} + +int sceKernelAllocateDirectMemory(int64_t search_start, int64_t search_end, size_t len, size_t alignment, int memory_type, int64_t* phys_addr_out) { + (void)search_start; + (void)search_end; + (void)len; + (void)alignment; + (void)memory_type; + (void)phys_addr_out; + return 0; +} + +int sceKernelAllocateMainDirectMemory(size_t len, size_t alignment, int memory_type, int64_t* phys_addr_out) { + (void)len; + (void)alignment; + (void)memory_type; + (void)phys_addr_out; + return 0; +} + +int sceKernelAvailableDirectMemorySize(int64_t search_start, int64_t search_end, size_t alignment, int64_t* phys_addr_out, size_t* size_out) { + (void)search_start; + (void)search_end; + (void)alignment; + (void)phys_addr_out; + (void)size_out; + return 0; +} + +int sceKernelAvailableFlexibleMemorySize(size_t* size) { + (void)size; + return 0; +} + +int sceKernelBatchMap(KernelBatchMapEntry* entries, int num_entries, int* num_entries_out) { + (void)entries; + (void)num_entries; + (void)num_entries_out; + return 0; +} + +int sceKernelBatchMap2(KernelBatchMapEntry* entries, int num_entries, int* num_entries_out, int flags) { + (void)entries; + (void)num_entries; + (void)num_entries_out; + (void)flags; + return 0; +} + +int sceKernelCancelEventFlag(KernelEventFlag ef, uint64_t set_pattern, int* num_wait_threads) { + (void)ef; + (void)set_pattern; + (void)num_wait_threads; + return 0; +} + +int sceKernelCancelSema(KernelSema sem, int count, int* threads) { + (void)sem; + (void)count; + (void)threads; + return 0; +} + +int sceKernelCheckedReleaseDirectMemory(int64_t start, size_t len) { + (void)start; + (void)len; + return 0; +} + +int sceKernelCheckReachability(const char* path) { + (void)path; + return 0; +} + +int sceKernelClearEventFlag(KernelEventFlag ef, uint64_t bit_pattern) { + (void)ef; + (void)bit_pattern; + return 0; +} + +int sceKernelClockGetres(KernelClockid clock_id, KernelTimespec* tp) { + (void)clock_id; + (void)tp; + return 0; +} + +int sceKernelClockGettime(KernelClockid clock_id, KernelTimespec* tp) { + (void)clock_id; + (void)tp; + return 0; +} + +int sceKernelClose(int d) { + (void)d; + return 0; +} + +int sceKernelConfiguredFlexibleMemorySize(size_t* size) { + (void)size; + return 0; +} + +int sceKernelConvertLocaltimeToUtc(int64_t local_time, int64_t reserved, int64_t* utc_time, KernelTimezone* timezone, int32_t* dst_seconds) { + (void)local_time; + (void)reserved; + (void)utc_time; + (void)timezone; + (void)dst_seconds; + return 0; +} + +int sceKernelConvertUtcToLocaltime(int64_t utc_time, int64_t* local_time, KernelTimesec* st, uint64_t* dst_sec) { + (void)utc_time; + (void)local_time; + (void)st; + (void)dst_sec; + return 0; +} + +int sceKernelCreateEqueue(KernelEqueue* eq, const char* name) { + (void)eq; + (void)name; + return 0; +} + +int sceKernelCreateEventFlag(KernelEventFlag* ef, const char* name, uint32_t attr, uint64_t init_pattern, const void* param) { + (void)ef; + (void)name; + (void)attr; + (void)init_pattern; + (void)param; + return 0; +} + +int sceKernelCreateSema(KernelSema* sem, const char* name, uint32_t attr, int init, int max, void* opt) { + (void)sem; + (void)name; + (void)attr; + (void)init; + (void)max; + (void)opt; + return 0; +} + +void sceKernelDebugRaiseException(int c1, int c2) { + (void)c1; + (void)c2; +} + +void sceKernelDebugRaiseExceptionOnReleaseMode(int c1, int c2) { + (void)c1; + (void)c2; +} + +int sceKernelDeleteAmprEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelDeleteEqueue(KernelEqueue eq) { + (void)eq; + return 0; +} + +int sceKernelDeleteEventFlag(KernelEventFlag ef) { + (void)ef; + return 0; +} + +int sceKernelDeleteHRTimerEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelDeleteSema(KernelSema sem) { + (void)sem; + return 0; +} + +int sceKernelDeleteUserEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelDirectMemoryQuery(int64_t offset, int flags, void* info, size_t info_size) { + (void)offset; + (void)flags; + (void)info; + (void)info_size; + return 0; +} + +int sceKernelDlsym(KernelModule handle, const char* symbol, void** addr) { + (void)handle; + (void)symbol; + (void)addr; + return 0; +} + +int sceKernelFstat(int d, FileStat* sb) { + (void)d; + (void)sb; + return 0; +} + +int sceKernelFsync(int fd) { + (void)fd; + return 0; +} + +int sceKernelGetCurrentCpu(void) { + return 0; +} + +int sceKernelGetdents(int fd, char* buf, int nbytes) { + (void)fd; + (void)buf; + (void)nbytes; + return 0; +} + +size_t sceKernelGetDirectMemorySize(void) { + return 0; +} + +int sceKernelGetdirentries(int fd, char* buf, int nbytes, int64_t* basep) { + (void)fd; + (void)buf; + (void)nbytes; + (void)basep; + return 0; +} + +intptr_t sceKernelGetEventData(const KernelEvent* ev) { + (void)ev; + return 0; +} + +int sceKernelGetEventError(const KernelEvent* ev) { + (void)ev; + return 0; +} + +intptr_t sceKernelGetEventFflags(const KernelEvent* ev) { + (void)ev; + return 0; +} + +int sceKernelGetEventFilter(const KernelEvent* ev) { + (void)ev; + return 0; +} + +uintptr_t sceKernelGetEventId(const KernelEvent* ev) { + (void)ev; + return 0; +} + +void* sceKernelGetEventUserData(const KernelEvent* ev) { + (void)ev; + return nullptr; +} + +uint64_t sceKernelGetGPI(void) { + return 0; +} + +int sceKernelGetModuleInfoForUnwind(uint64_t addr, int flags, ModuleInfoForUnwind* info) { + (void)addr; + (void)flags; + (void)info; + return 0; +} + +int sceKernelGetModuleInfoFromAddr(uint64_t addr, int n, ModuleInfo* r) { + (void)addr; + (void)n; + (void)r; + return 0; +} + +int sceKernelGetOpenPsId(void* open_ps_id) { + (void)open_ps_id; + return 0; +} + +int sceKernelGetPageTableStats(int* cpu_total, int* cpu_available, int* gpu_total, int* gpu_available) { + (void)cpu_total; + (void)cpu_available; + (void)gpu_total; + (void)gpu_available; + return 0; +} + +uint64_t sceKernelGetProcessTime(void) { + return 0; +} + +uint64_t sceKernelGetProcessTimeCounter(void) { + return 0; +} + +uint64_t sceKernelGetProcessTimeCounterFrequency(void) { + return 0; +} + +void* sceKernelGetProcParam(void) { + return nullptr; +} + +int sceKernelGetPrtAperture(int index, void** addr, size_t* len) { + (void)index; + (void)addr; + (void)len; + return 0; +} + +MallocReplace* sceKernelGetSanitizerMallocReplaceExternal(void) { + return nullptr; +} + +NewReplace* sceKernelGetSanitizerNewReplaceExternal(void) { + return nullptr; +} + +int sceKernelGettimeofday(KernelTimeval* tp) { + (void)tp; + return 0; +} + +int sceKernelGettimezone(KernelTimezone* tz) { + (void)tz; + return 0; +} + +uint64_t sceKernelGetTscFrequency(void) { + return 0; +} + +int sceKernelInstallExceptionHandler(int signum, void* handler) { + (void)signum; + (void)handler; + return 0; +} + +int sceKernelIsAddressSanitizerEnabled(void) { + return 0; +} + +int sceKernelIsStack(void* addr, void** start, void** end) { + (void)addr; + (void)start; + (void)end; + return 0; +} + +KernelModule sceKernelLoadStartModule(const char* module_file_name, size_t args, const void* argp, uint32_t flags, const KernelLoadModuleOpt* opt, int* res) { + (void)module_file_name; + (void)args; + (void)argp; + (void)flags; + (void)opt; + (void)res; + return {}; +} + +int64_t sceKernelLseek(int d, int64_t offset, int whence) { + (void)d; + (void)offset; + (void)whence; + return 0; +} + +int sceKernelMapDirectMemory(void** addr, size_t len, int prot, int flags, int64_t direct_memory_start, size_t alignment) { + (void)addr; + (void)len; + (void)prot; + (void)flags; + (void)direct_memory_start; + (void)alignment; + return 0; +} + +int sceKernelMapDirectMemory2(void** addr, size_t len, int type, int prot, int flags, int64_t direct_memory_start, size_t alignment) { + (void)addr; + (void)len; + (void)type; + (void)prot; + (void)flags; + (void)direct_memory_start; + (void)alignment; + return 0; +} + +int sceKernelMapFlexibleMemory(void** addr_in_out, size_t len, int prot, int flags) { + (void)addr_in_out; + (void)len; + (void)prot; + (void)flags; + return 0; +} + +int sceKernelMapNamedDirectMemory(void** addr, size_t len, int prot, int flags, int64_t direct_memory_start, size_t alignment, const char* name) { + (void)addr; + (void)len; + (void)prot; + (void)flags; + (void)direct_memory_start; + (void)alignment; + (void)name; + return 0; +} + +int32_t sceKernelMapNamedFlexibleMemory(void** addr_in_out, size_t len, int prot, int flags, const char* name) { + (void)addr_in_out; + (void)len; + (void)prot; + (void)flags; + (void)name; + return 0; +} + +int sceKernelMemoryPoolBatch(const KernelMemoryPoolBatchEntry* entries, int num_entries, int* num_entries_out, int flags) { + (void)entries; + (void)num_entries; + (void)num_entries_out; + (void)flags; + return 0; +} + +int sceKernelMemoryPoolCommit(void* addr, size_t len, int type, int prot, int flags) { + (void)addr; + (void)len; + (void)type; + (void)prot; + (void)flags; + return 0; +} + +int sceKernelMemoryPoolDecommit(void* addr, size_t len, int flags) { + (void)addr; + (void)len; + (void)flags; + return 0; +} + +int sceKernelMemoryPoolExpand(int64_t search_start, int64_t search_end, size_t len, size_t alignment, int64_t* phys_addr_out) { + (void)search_start; + (void)search_end; + (void)len; + (void)alignment; + (void)phys_addr_out; + return 0; +} + +int sceKernelMemoryPoolGetBlockStats(KernelMemoryPoolBlockStats* output, size_t output_size) { + (void)output; + (void)output_size; + return 0; +} + +int sceKernelMemoryPoolReserve(void* addr_in, size_t len, size_t alignment, int flags, void** addr_out) { + (void)addr_in; + (void)len; + (void)alignment; + (void)flags; + (void)addr_out; + return 0; +} + +int sceKernelMkdir(const char* path, uint16_t mode) { + (void)path; + (void)mode; + return 0; +} + +int sceKernelMprotect(const void* addr, size_t len, int prot) { + (void)addr; + (void)len; + (void)prot; + return 0; +} + +int sceKernelMtypeprotect(const void* addr, size_t len, int type, int prot) { + (void)addr; + (void)len; + (void)type; + (void)prot; + return 0; +} + +int sceKernelMunmap(uint64_t vaddr, size_t len) { + (void)vaddr; + (void)len; + return 0; +} + +int sceKernelNanosleep(const KernelTimespec* rqtp, KernelTimespec* rmtp) { + (void)rqtp; + (void)rmtp; + return 0; +} + +int sceKernelOpen(const char* path, int flags, uint16_t mode) { + (void)path; + (void)flags; + (void)mode; + return 0; +} + +int sceKernelPollEventFlag(KernelEventFlag ef, uint64_t bit_pattern, uint32_t wait_mode, uint64_t* result_pat) { + (void)ef; + (void)bit_pattern; + (void)wait_mode; + (void)result_pat; + return 0; +} + +int sceKernelPollSema(KernelSema sem, int need) { + (void)sem; + (void)need; + return 0; +} + +int64_t sceKernelPread(int d, void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int64_t sceKernelPwrite(int d, const void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int sceKernelQueryMemoryProtection(void* addr, void** start, void** end, int* prot) { + (void)addr; + (void)start; + (void)end; + (void)prot; + return 0; +} + +int sceKernelRaiseException(Pthread thread, int signum) { + (void)thread; + (void)signum; + return 0; +} + +int64_t sceKernelRead(int d, void* buf, size_t nbytes) { + (void)d; + (void)buf; + (void)nbytes; + return 0; +} + +uint64_t sceKernelReadTsc(void) { + return 0; +} + +int sceKernelReleaseDirectMemory(int64_t start, size_t len) { + (void)start; + (void)len; + return 0; +} + +int sceKernelRemoveExceptionHandler(int signum) { + (void)signum; + return 0; +} + +int sceKernelRename(const char* from, const char* to) { + (void)from; + (void)to; + return 0; +} + +int sceKernelReserveVirtualRange(void** addr, size_t len, int flags, size_t alignment) { + (void)addr; + (void)len; + (void)flags; + (void)alignment; + return 0; +} + +int sceKernelRmdir(const char* path) { + (void)path; + return 0; +} + +void sceKernelRtldSetApplicationHeapAPI(void* api[]) { + (void)api; +} + +int sceKernelRtldThreadAtexitDecrement(uint64_t* c) { + (void)c; + return 0; +} + +int sceKernelRtldThreadAtexitIncrement(uint64_t* c) { + (void)c; + return 0; +} + +int sceKernelSetEventFlag(KernelEventFlag ef, uint64_t bit_pattern) { + (void)ef; + (void)bit_pattern; + return 0; +} + +void sceKernelSetGPO(uint32_t bits) { + (void)bits; +} + +int sceKernelSetPrtAperture(int index, void* addr, size_t len) { + (void)index; + (void)addr; + (void)len; + return 0; +} + +void sceKernelSetThreadAtexitCount(get_thread_atexit_count_func_t func) { + (void)func; +} + +void sceKernelSetThreadAtexitReport(thread_atexit_report_func_t func) { + (void)func; +} + +void sceKernelSetThreadDtors(thread_dtors_func_t dtors) { + (void)dtors; +} + +int sceKernelSetVirtualRangeName(const void* addr, uint64_t len, const char* name) { + (void)addr; + (void)len; + (void)name; + return 0; +} + +int sceKernelSignalSema(KernelSema sem, int count) { + (void)sem; + (void)count; + return 0; +} + +unsigned int sceKernelSleep(unsigned int seconds) { + (void)seconds; + return 0; +} + +int sceKernelStat(const char* path, FileStat* sb) { + (void)path; + (void)sb; + return 0; +} + +int sceKernelStopUnloadModule(KernelModule handle, size_t args, const void* argp, uint32_t flags, const KernelUnloadModuleOpt* opt, int* res) { + (void)handle; + (void)args; + (void)argp; + (void)flags; + (void)opt; + (void)res; + return 0; +} + +void sceKernelSync(void) { +} + +int sceKernelTriggerUserEvent(KernelEqueue eq, int id, void* udata) { + (void)eq; + (void)id; + (void)udata; + return 0; +} + +int sceKernelUnlink(const char* path) { + (void)path; + return 0; +} + +int sceKernelUsleep(KernelUseconds microseconds) { + (void)microseconds; + return 0; +} + +int sceKernelUuidCreate(uint32_t* uuid) { + (void)uuid; + return 0; +} + +int sceKernelVirtualQuery(const void* addr, int flags, VirtualQueryInfo* info, uint64_t info_size) { + (void)addr; + (void)flags; + (void)info; + (void)info_size; + return 0; +} + +int sceKernelWaitEqueue(KernelEqueue eq, KernelEvent* ev, int num, int* out, const KernelUseconds* timo) { + (void)eq; + (void)ev; + (void)num; + (void)out; + (void)timo; + return 0; +} + +int sceKernelWaitEventFlag(KernelEventFlag ef, uint64_t bit_pattern, uint32_t wait_mode, uint64_t* result_pat, KernelUseconds* timeout) { + (void)ef; + (void)bit_pattern; + (void)wait_mode; + (void)result_pat; + (void)timeout; + return 0; +} + +int sceKernelWaitSema(KernelSema sem, int need, KernelUseconds* time) { + (void)sem; + (void)need; + (void)time; + return 0; +} + +int64_t sceKernelWrite(int d, const void* buf, size_t nbytes) { + (void)d; + (void)buf; + (void)nbytes; + return 0; +} + +int scePthreadAttrDestroy(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int scePthreadAttrGet(Pthread thread, PthreadAttr* attr) { + (void)thread; + (void)attr; + return 0; +} + +int scePthreadAttrGetaffinity(const PthreadAttr* attr, KernelCpumask* mask) { + (void)attr; + (void)mask; + return 0; +} + +int scePthreadAttrGetdetachstate(const PthreadAttr* attr, int* state) { + (void)attr; + (void)state; + return 0; +} + +int scePthreadAttrGetguardsize(const PthreadAttr* attr, size_t* guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int scePthreadAttrGetschedparam(const PthreadAttr* attr, KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int scePthreadAttrGetsolosched(const PthreadAttr* attr, int* solosched) { + (void)attr; + (void)solosched; + return 0; +} + +int scePthreadAttrGetstack(const PthreadAttr* __restrict attr, void** __restrict stack_addr, size_t* __restrict stack_size) { + (void)attr; + (void)stack_addr; + (void)stack_size; + return 0; +} + +int scePthreadAttrGetstackaddr(const PthreadAttr* attr, void** stack_addr) { + (void)attr; + (void)stack_addr; + return 0; +} + +int scePthreadAttrGetstacksize(const PthreadAttr* attr, size_t* stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int scePthreadAttrInit(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int scePthreadAttrSetaffinity(PthreadAttr* attr, KernelCpumask mask) { + (void)attr; + (void)mask; + return 0; +} + +int scePthreadAttrSetdetachstate(PthreadAttr* attr, int state) { + (void)attr; + (void)state; + return 0; +} + +int scePthreadAttrSetguardsize(PthreadAttr* attr, size_t guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int scePthreadAttrSetinheritsched(PthreadAttr* attr, int inherit_sched) { + (void)attr; + (void)inherit_sched; + return 0; +} + +int scePthreadAttrSetschedparam(PthreadAttr* attr, const KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int scePthreadAttrSetschedpolicy(PthreadAttr* attr, int policy) { + (void)attr; + (void)policy; + return 0; +} + +int scePthreadAttrSetsolosched(PthreadAttr* attr, int solosched) { + (void)attr; + (void)solosched; + return 0; +} + +int scePthreadAttrSetstack(PthreadAttr* attr, void* addr, size_t size) { + (void)attr; + (void)addr; + (void)size; + return 0; +} + +int scePthreadAttrSetstackaddr(PthreadAttr* attr, void* addr) { + (void)attr; + (void)addr; + return 0; +} + +int scePthreadAttrSetstacksize(PthreadAttr* attr, size_t stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int scePthreadCancel(Pthread thread) { + (void)thread; + return 0; +} + +int scePthreadCondattrDestroy(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int scePthreadCondattrInit(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int scePthreadCondBroadcast(PthreadCond* cond) { + (void)cond; + return 0; +} + +int scePthreadCondDestroy(PthreadCond* cond) { + (void)cond; + return 0; +} + +int scePthreadCondInit(PthreadCond* cond, const PthreadCondattr* attr, const char* name) { + (void)cond; + (void)attr; + (void)name; + return 0; +} + +int scePthreadCondSignal(PthreadCond* cond) { + (void)cond; + return 0; +} + +int scePthreadCondSignalto(PthreadCond* cond, Pthread thread) { + (void)cond; + (void)thread; + return 0; +} + +int scePthreadCondTimedwait(PthreadCond* cond, PthreadMutex* mutex, KernelUseconds usec) { + (void)cond; + (void)mutex; + (void)usec; + return 0; +} + +int scePthreadCondWait(PthreadCond* cond, PthreadMutex* mutex) { + (void)cond; + (void)mutex; + return 0; +} + +int scePthreadCreate(Pthread* thread, const PthreadAttr* attr, pthread_entry_func_t entry, void* arg, const char* name) { + (void)thread; + (void)attr; + (void)entry; + (void)arg; + (void)name; + return 0; +} + +int scePthreadDetach(Pthread thread) { + (void)thread; + return 0; +} + +int scePthreadEqual(Pthread thread1, Pthread thread2) { + (void)thread1; + (void)thread2; + return 0; +} + +void scePthreadExit(void* value) { + (void)value; +} + +int scePthreadGetaffinity(Pthread thread, KernelCpumask* mask) { + (void)thread; + (void)mask; + return 0; +} + +int scePthreadGetname(Pthread thread, char* name) { + (void)thread; + (void)name; + return 0; +} + +int scePthreadGetprio(Pthread thread, int* prio) { + (void)thread; + (void)prio; + return 0; +} + +void* scePthreadGetspecific(PthreadKey key) { + (void)key; + return nullptr; +} + +int scePthreadGetthreadid(void) { + return 0; +} + +int scePthreadJoin(Pthread thread, void** value) { + (void)thread; + (void)value; + return 0; +} + +int scePthreadKeyCreate(PthreadKey* key, pthread_key_destructor_func_t destructor) { + (void)key; + (void)destructor; + return 0; +} + +int scePthreadKeyDelete(PthreadKey key) { + (void)key; + return 0; +} + +int scePthreadMutexattrDestroy(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int scePthreadMutexattrInit(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int scePthreadMutexattrSetprotocol(PthreadMutexattr* attr, int protocol) { + (void)attr; + (void)protocol; + return 0; +} + +int scePthreadMutexattrSettype(PthreadMutexattr* attr, int type) { + (void)attr; + (void)type; + return 0; +} + +int scePthreadMutexDestroy(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadMutexInit(PthreadMutex* mutex, const PthreadMutexattr* attr, const char* name) { + (void)mutex; + (void)attr; + (void)name; + return 0; +} + +int scePthreadMutexLock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadMutexTimedlock(PthreadMutex* mutex, KernelUseconds usec) { + (void)mutex; + (void)usec; + return 0; +} + +int scePthreadMutexTrylock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadMutexUnlock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadRename(Pthread thread, const char* name) { + (void)thread; + (void)name; + return 0; +} + +int scePthreadRwlockattrDestroy(PthreadRwlockattr* attr) { + (void)attr; + return 0; +} + +int scePthreadRwlockattrInit(PthreadRwlockattr* attr) { + (void)attr; + return 0; +} + +int scePthreadRwlockattrSettype(PthreadRwlockattr* attr, int type) { + (void)attr; + (void)type; + return 0; +} + +int scePthreadRwlockDestroy(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockInit(PthreadRwlock* rwlock, const PthreadRwlockattr* attr, const char* name) { + (void)rwlock; + (void)attr; + (void)name; + return 0; +} + +int scePthreadRwlockRdlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockTryrdlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockTrywrlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockUnlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockWrlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +Pthread scePthreadSelf(void) { + return {}; +} + +int scePthreadSemDestroy(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSemGetvalue(void* sem, int* value) { + (void)sem; + (void)value; + return 0; +} + +int scePthreadSemInit(void* sem, int flag, unsigned int value, const char* name) { + (void)sem; + (void)flag; + (void)value; + (void)name; + return 0; +} + +int scePthreadSemPost(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSemTimedwait(void* sem, KernelUseconds usec) { + (void)sem; + (void)usec; + return 0; +} + +int scePthreadSemTrywait(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSemWait(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSetaffinity(Pthread thread, KernelCpumask mask) { + (void)thread; + (void)mask; + return 0; +} + +int scePthreadSetcancelstate(int state, int* old_state) { + (void)state; + (void)old_state; + return 0; +} + +int scePthreadSetcanceltype(int type, int* old_type) { + (void)type; + (void)old_type; + return 0; +} + +int scePthreadSetprio(Pthread thread, int prio) { + (void)thread; + (void)prio; + return 0; +} + +int scePthreadSetspecific(PthreadKey key, void* value) { + (void)key; + (void)value; + return 0; +} + +void scePthreadYield(void) { +} + +int sched_get_priority_max(int policy) { + (void)policy; + return 0; +} + +int sched_get_priority_min(int policy) { + (void)policy; + return 0; +} + +int select(int nfds, void* readfds, void* writefds, void* exceptfds, const void* timeout) { + (void)nfds; + (void)readfds; + (void)writefds; + (void)exceptfds; + (void)timeout; + return 0; +} + +int sem_destroy(void* sem) { + (void)sem; + return 0; +} + +int sem_getvalue(void* sem, int* value) { + (void)sem; + (void)value; + return 0; +} + +int sem_init(void* sem, int pshared, unsigned int value) { + (void)sem; + (void)pshared; + (void)value; + return 0; +} + +int sem_post(void* sem) { + (void)sem; + return 0; +} + +int sem_reltimedwait_np(void* sem, uint32_t usec) { + (void)sem; + (void)usec; + return 0; +} + +int sem_timedwait(void* sem, const KernelTimespec* abstime) { + (void)sem; + (void)abstime; + return 0; +} + +int sem_trywait(void* sem) { + (void)sem; + return 0; +} + +int sem_wait(void* sem) { + (void)sem; + return 0; +} + +int64_t send(int s, const void* buf, uint64_t len, int flags) { + (void)s; + (void)buf; + (void)len; + (void)flags; + return 0; +} + +int64_t sendto(int s, const void* buf, uint64_t len, int flags, const void* addr, uint32_t addrlen) { + (void)s; + (void)buf; + (void)len; + (void)flags; + (void)addr; + (void)addrlen; + return 0; +} + +int setsockopt(int s, int level, int optname, const void* optval, uint32_t optlen) { + (void)s; + (void)level; + (void)optname; + (void)optval; + (void)optlen; + return 0; +} + +int sigprocmask(int how, const void* set, void* oset) { + (void)how; + (void)set; + (void)oset; + return 0; +} + +int socket(int family, int type, int protocol) { + (void)family; + (void)type; + (void)protocol; + return 0; +} + +int stat(const char* path, FileStat* sb) { + (void)path; + (void)sb; + return 0; +} + +int64_t write(int d, const char* str, int64_t size) { + (void)d; + (void)str; + (void)size; + return 0; +} + +} diff --git a/core/libs/prx/libkernel_sys/Export.cpp b/core/libs/prx/libkernel_sys/Export.cpp new file mode 100644 index 000000000..718712b00 --- /dev/null +++ b/core/libs/prx/libkernel_sys/Export.cpp @@ -0,0 +1,1876 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int accept(int s, void* addr, uint32_t* addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int bind(int s, const void* addr, uint32_t addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int chmod(const char* path, int mode) { + (void)path; + (void)mode; + return 0; +} + +int clock_getres(int clock_id, KernelTimespec* res) { + (void)clock_id; + (void)res; + return 0; +} + +int clock_gettime(int clock_id, KernelTimespec* time) { + (void)clock_id; + (void)time; + return 0; +} + +int close(int d) { + (void)d; + return 0; +} + +int connect(int s, const void* addr, uint32_t addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +void exit(int code) { + (void)code; +} + +int flock(int d, int operation) { + (void)d; + (void)operation; + return 0; +} + +int64_t fstat(int d, FileStat* sb) { + (void)d; + (void)sb; + return 0; +} + +int ftruncate(int d, int64_t length) { + (void)d; + (void)length; + return 0; +} + +int getargc(void) { + return 0; +} + +const char** getargv(void) { + return nullptr; +} + +int getpagesize(void) { + return 0; +} + +int getpid(void) { + return 0; +} + +int getsockname(int s, void* addr, uint32_t* addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int getsockopt(int s, int level, int optname, void* optval, uint32_t* optlen) { + (void)s; + (void)level; + (void)optname; + (void)optval; + (void)optlen; + return 0; +} + +int gettimeofday(KernelTimeval* time, KernelTimezone* timezone) { + (void)time; + (void)timezone; + return 0; +} + +const char* inet_ntop(int af, const void* src, char* dst, uint32_t size) { + (void)af; + (void)src; + (void)dst; + (void)size; + return nullptr; +} + +int inet_pton(int af, const char* src, void* dst) { + (void)af; + (void)src; + (void)dst; + return 0; +} + +int listen(int s, int backlog) { + (void)s; + (void)backlog; + return 0; +} + +int64_t lseek(int d, int64_t offset, int whence) { + (void)d; + (void)offset; + (void)whence; + return 0; +} + +int mkdir(const char* path, uint16_t mode) { + (void)path; + (void)mode; + return 0; +} + +int nanosleep(const KernelTimespec* rqtp, KernelTimespec* rmtp) { + (void)rqtp; + (void)rmtp; + return 0; +} + +int open(const char* path, int flags, int mode) { + (void)path; + (void)flags; + (void)mode; + return 0; +} + +int64_t pread(int d, void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int pthread_attr_destroy(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int pthread_attr_get_np(Pthread thread, PthreadAttr* attr) { + (void)thread; + (void)attr; + return 0; +} + +int pthread_attr_getdetachstate(const PthreadAttr* attr, int* state) { + (void)attr; + (void)state; + return 0; +} + +int pthread_attr_getguardsize(const PthreadAttr* attr, size_t* guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int pthread_attr_getschedparam(const PthreadAttr* attr, KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int pthread_attr_getschedpolicy(const PthreadAttr* attr, int* policy) { + (void)attr; + (void)policy; + return 0; +} + +int pthread_attr_getstack(const PthreadAttr* __restrict attr, void** __restrict stack_addr, size_t* __restrict stack_size) { + (void)attr; + (void)stack_addr; + (void)stack_size; + return 0; +} + +int pthread_attr_getstacksize(const PthreadAttr* attr, size_t* stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int pthread_attr_init(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int pthread_attr_setdetachstate(PthreadAttr* attr, int state) { + (void)attr; + (void)state; + return 0; +} + +int pthread_attr_setguardsize(PthreadAttr* attr, size_t guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int pthread_attr_setinheritsched(PthreadAttr* attr, int inherit_sched) { + (void)attr; + (void)inherit_sched; + return 0; +} + +int pthread_attr_setschedparam(PthreadAttr* attr, const KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int pthread_attr_setschedpolicy(PthreadAttr* attr, int policy) { + (void)attr; + (void)policy; + return 0; +} + +int pthread_attr_setstacksize(PthreadAttr* attr, size_t stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int pthread_cond_broadcast(PthreadCond* cond) { + (void)cond; + return 0; +} + +int pthread_cond_init(PthreadCond* cond, const PthreadCondattr* attr) { + (void)cond; + (void)attr; + return 0; +} + +int pthread_cond_signal(PthreadCond* cond) { + (void)cond; + return 0; +} + +int pthread_cond_timedwait(PthreadCond* cond, PthreadMutex* mutex, const KernelTimespec* abstime) { + (void)cond; + (void)mutex; + (void)abstime; + return 0; +} + +int pthread_cond_wait(PthreadCond* cond, PthreadMutex* mutex) { + (void)cond; + (void)mutex; + return 0; +} + +int pthread_condattr_destroy(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int pthread_condattr_init(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int pthread_condattr_setclock(PthreadCondattr* attr, KernelClockid clock_id) { + (void)attr; + (void)clock_id; + return 0; +} + +int pthread_create(Pthread* thread, const PthreadAttr* attr, pthread_entry_func_t entry, void* arg) { + (void)thread; + (void)attr; + (void)entry; + (void)arg; + return 0; +} + +int pthread_create_name_np(Pthread* thread, const PthreadAttr* attr, pthread_entry_func_t entry, void* arg, const char* name) { + (void)thread; + (void)attr; + (void)entry; + (void)arg; + (void)name; + return 0; +} + +int pthread_detach(Pthread thread) { + (void)thread; + return 0; +} + +void pthread_exit(void* value) { + (void)value; +} + +int pthread_getschedparam(Pthread thread, int* policy, KernelSchedParam* param) { + (void)thread; + (void)policy; + (void)param; + return 0; +} + +void* pthread_getspecific(PthreadKey key) { + (void)key; + return nullptr; +} + +int pthread_join(Pthread thread, void** value) { + (void)thread; + (void)value; + return 0; +} + +int pthread_key_create(PthreadKey* key, pthread_key_destructor_func_t destructor) { + (void)key; + (void)destructor; + return 0; +} + +int pthread_key_delete(PthreadKey key) { + (void)key; + return 0; +} + +int pthread_mutex_destroy(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutex_init(PthreadMutex* mutex, const PthreadMutexattr* attr) { + (void)mutex; + (void)attr; + return 0; +} + +int pthread_mutex_lock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutex_timedlock(PthreadMutex* mutex, const KernelTimespec* abstime) { + (void)mutex; + (void)abstime; + return 0; +} + +int pthread_mutex_trylock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutex_unlock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutexattr_destroy(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int pthread_mutexattr_init(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int pthread_mutexattr_setprotocol(PthreadMutexattr* attr, int protocol) { + (void)attr; + (void)protocol; + return 0; +} + +int pthread_mutexattr_settype(PthreadMutexattr* attr, int type) { + (void)attr; + (void)type; + return 0; +} + +int pthread_once(void* once_control, void(KYTY_SYSV_ABI* init_routine)()) { + (void)once_control; + (void)init_routine; + return 0; +} + +int pthread_rename_np(Pthread thread, const char* name) { + (void)thread; + (void)name; + return 0; +} + +int pthread_rwlock_destroy(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int pthread_rwlock_init(PthreadRwlock* rwlock, const PthreadRwlockattr* attr) { + (void)rwlock; + (void)attr; + return 0; +} + +int pthread_rwlock_wrlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +Pthread pthread_self(void) { + return {}; +} + +int pthread_setcancelstate(int state, int* old_state) { + (void)state; + (void)old_state; + return 0; +} + +int pthread_setprio(Pthread thread, int prio) { + (void)thread; + (void)prio; + return 0; +} + +int pthread_setschedparam(Pthread thread, int policy, const KernelSchedParam* param) { + (void)thread; + (void)policy; + (void)param; + return 0; +} + +int pthread_setspecific(PthreadKey key, void* value) { + (void)key; + (void)value; + return 0; +} + +void pthread_yield(void) { +} + +int64_t pwrite(int d, const void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int64_t read(int d, void* buf, uint64_t nbytes) { + (void)d; + (void)buf; + (void)nbytes; + return 0; +} + +int64_t recv(int s, void* buf, uint64_t len, int flags) { + (void)s; + (void)buf; + (void)len; + (void)flags; + return 0; +} + +int64_t recvfrom(int s, void* buf, uint64_t len, int flags, void* addr, uint32_t* addrlen) { + (void)s; + (void)buf; + (void)len; + (void)flags; + (void)addr; + (void)addrlen; + return 0; +} + +int sceCoredumpRegisterCoredumpHandler(uint64_t handler, size_t stack_size, uint64_t context) { + (void)handler; + (void)stack_size; + (void)context; + return 0; +} + +int sceCoredumpUnregisterCoredumpHandler(void) { + return 0; +} + +int sceKernelAddAmprEvent(KernelEqueue eq, int id, void* udata) { + (void)eq; + (void)id; + (void)udata; + return 0; +} + +int sceKernelAddHRTimerEvent(KernelEqueue eq, int id, const KernelTimespec* ts, void* udata) { + (void)eq; + (void)id; + (void)ts; + (void)udata; + return 0; +} + +int sceKernelAddUserEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelAddUserEventEdge(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelAioDeleteRequest(int32_t id, int32_t* ret) { + (void)id; + (void)ret; + return 0; +} + +int sceKernelAioInitializeImpl(void* param, int32_t size) { + (void)param; + (void)size; + return 0; +} + +void sceKernelAioInitializeParam(void* param) { + (void)param; +} + +int sceKernelAioSubmitReadCommands(KernelAioRwRequest* req, int32_t size, int32_t prio, int32_t* id) { + (void)req; + (void)size; + (void)prio; + (void)id; + return 0; +} + +int sceKernelAioSubmitWriteCommands(KernelAioRwRequest* req, int32_t size, int32_t prio, int32_t* id) { + (void)req; + (void)size; + (void)prio; + (void)id; + return 0; +} + +int sceKernelAioWaitRequest(int32_t id, int32_t* state, uint32_t* usec) { + (void)id; + (void)state; + (void)usec; + return 0; +} + +int sceKernelAllocateDirectMemory(int64_t search_start, int64_t search_end, size_t len, size_t alignment, int memory_type, int64_t* phys_addr_out) { + (void)search_start; + (void)search_end; + (void)len; + (void)alignment; + (void)memory_type; + (void)phys_addr_out; + return 0; +} + +int sceKernelAllocateMainDirectMemory(size_t len, size_t alignment, int memory_type, int64_t* phys_addr_out) { + (void)len; + (void)alignment; + (void)memory_type; + (void)phys_addr_out; + return 0; +} + +int sceKernelAvailableDirectMemorySize(int64_t search_start, int64_t search_end, size_t alignment, int64_t* phys_addr_out, size_t* size_out) { + (void)search_start; + (void)search_end; + (void)alignment; + (void)phys_addr_out; + (void)size_out; + return 0; +} + +int sceKernelAvailableFlexibleMemorySize(size_t* size) { + (void)size; + return 0; +} + +int sceKernelBatchMap(KernelBatchMapEntry* entries, int num_entries, int* num_entries_out) { + (void)entries; + (void)num_entries; + (void)num_entries_out; + return 0; +} + +int sceKernelBatchMap2(KernelBatchMapEntry* entries, int num_entries, int* num_entries_out, int flags) { + (void)entries; + (void)num_entries; + (void)num_entries_out; + (void)flags; + return 0; +} + +int sceKernelCancelEventFlag(KernelEventFlag ef, uint64_t set_pattern, int* num_wait_threads) { + (void)ef; + (void)set_pattern; + (void)num_wait_threads; + return 0; +} + +int sceKernelCancelSema(KernelSema sem, int count, int* threads) { + (void)sem; + (void)count; + (void)threads; + return 0; +} + +int sceKernelCheckedReleaseDirectMemory(int64_t start, size_t len) { + (void)start; + (void)len; + return 0; +} + +int sceKernelCheckReachability(const char* path) { + (void)path; + return 0; +} + +int sceKernelClearEventFlag(KernelEventFlag ef, uint64_t bit_pattern) { + (void)ef; + (void)bit_pattern; + return 0; +} + +int sceKernelClockGetres(KernelClockid clock_id, KernelTimespec* tp) { + (void)clock_id; + (void)tp; + return 0; +} + +int sceKernelClockGettime(KernelClockid clock_id, KernelTimespec* tp) { + (void)clock_id; + (void)tp; + return 0; +} + +int sceKernelClose(int d) { + (void)d; + return 0; +} + +int sceKernelConfiguredFlexibleMemorySize(size_t* size) { + (void)size; + return 0; +} + +int sceKernelConvertLocaltimeToUtc(int64_t local_time, int64_t reserved, int64_t* utc_time, KernelTimezone* timezone, int32_t* dst_seconds) { + (void)local_time; + (void)reserved; + (void)utc_time; + (void)timezone; + (void)dst_seconds; + return 0; +} + +int sceKernelConvertUtcToLocaltime(int64_t utc_time, int64_t* local_time, KernelTimesec* st, uint64_t* dst_sec) { + (void)utc_time; + (void)local_time; + (void)st; + (void)dst_sec; + return 0; +} + +int sceKernelCreateEqueue(KernelEqueue* eq, const char* name) { + (void)eq; + (void)name; + return 0; +} + +int sceKernelCreateEventFlag(KernelEventFlag* ef, const char* name, uint32_t attr, uint64_t init_pattern, const void* param) { + (void)ef; + (void)name; + (void)attr; + (void)init_pattern; + (void)param; + return 0; +} + +int sceKernelCreateSema(KernelSema* sem, const char* name, uint32_t attr, int init, int max, void* opt) { + (void)sem; + (void)name; + (void)attr; + (void)init; + (void)max; + (void)opt; + return 0; +} + +void sceKernelDebugRaiseException(int c1, int c2) { + (void)c1; + (void)c2; +} + +void sceKernelDebugRaiseExceptionOnReleaseMode(int c1, int c2) { + (void)c1; + (void)c2; +} + +int sceKernelDeleteAmprEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelDeleteEqueue(KernelEqueue eq) { + (void)eq; + return 0; +} + +int sceKernelDeleteEventFlag(KernelEventFlag ef) { + (void)ef; + return 0; +} + +int sceKernelDeleteHRTimerEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelDeleteSema(KernelSema sem) { + (void)sem; + return 0; +} + +int sceKernelDeleteUserEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelDirectMemoryQuery(int64_t offset, int flags, void* info, size_t info_size) { + (void)offset; + (void)flags; + (void)info; + (void)info_size; + return 0; +} + +int sceKernelDlsym(KernelModule handle, const char* symbol, void** addr) { + (void)handle; + (void)symbol; + (void)addr; + return 0; +} + +int sceKernelFstat(int d, FileStat* sb) { + (void)d; + (void)sb; + return 0; +} + +int sceKernelFsync(int fd) { + (void)fd; + return 0; +} + +int sceKernelGetCurrentCpu(void) { + return 0; +} + +int sceKernelGetdents(int fd, char* buf, int nbytes) { + (void)fd; + (void)buf; + (void)nbytes; + return 0; +} + +size_t sceKernelGetDirectMemorySize(void) { + return 0; +} + +int sceKernelGetdirentries(int fd, char* buf, int nbytes, int64_t* basep) { + (void)fd; + (void)buf; + (void)nbytes; + (void)basep; + return 0; +} + +intptr_t sceKernelGetEventData(const KernelEvent* ev) { + (void)ev; + return 0; +} + +int sceKernelGetEventError(const KernelEvent* ev) { + (void)ev; + return 0; +} + +intptr_t sceKernelGetEventFflags(const KernelEvent* ev) { + (void)ev; + return 0; +} + +int sceKernelGetEventFilter(const KernelEvent* ev) { + (void)ev; + return 0; +} + +uintptr_t sceKernelGetEventId(const KernelEvent* ev) { + (void)ev; + return 0; +} + +void* sceKernelGetEventUserData(const KernelEvent* ev) { + (void)ev; + return nullptr; +} + +uint64_t sceKernelGetGPI(void) { + return 0; +} + +int sceKernelGetModuleInfoForUnwind(uint64_t addr, int flags, ModuleInfoForUnwind* info) { + (void)addr; + (void)flags; + (void)info; + return 0; +} + +int sceKernelGetModuleInfoFromAddr(uint64_t addr, int n, ModuleInfo* r) { + (void)addr; + (void)n; + (void)r; + return 0; +} + +int sceKernelGetOpenPsId(void* open_ps_id) { + (void)open_ps_id; + return 0; +} + +int sceKernelGetPageTableStats(int* cpu_total, int* cpu_available, int* gpu_total, int* gpu_available) { + (void)cpu_total; + (void)cpu_available; + (void)gpu_total; + (void)gpu_available; + return 0; +} + +uint64_t sceKernelGetProcessTime(void) { + return 0; +} + +uint64_t sceKernelGetProcessTimeCounter(void) { + return 0; +} + +uint64_t sceKernelGetProcessTimeCounterFrequency(void) { + return 0; +} + +void* sceKernelGetProcParam(void) { + return nullptr; +} + +int sceKernelGetPrtAperture(int index, void** addr, size_t* len) { + (void)index; + (void)addr; + (void)len; + return 0; +} + +MallocReplace* sceKernelGetSanitizerMallocReplaceExternal(void) { + return nullptr; +} + +NewReplace* sceKernelGetSanitizerNewReplaceExternal(void) { + return nullptr; +} + +int sceKernelGettimeofday(KernelTimeval* tp) { + (void)tp; + return 0; +} + +int sceKernelGettimezone(KernelTimezone* tz) { + (void)tz; + return 0; +} + +uint64_t sceKernelGetTscFrequency(void) { + return 0; +} + +int sceKernelInstallExceptionHandler(int signum, void* handler) { + (void)signum; + (void)handler; + return 0; +} + +int sceKernelIsAddressSanitizerEnabled(void) { + return 0; +} + +int sceKernelIsStack(void* addr, void** start, void** end) { + (void)addr; + (void)start; + (void)end; + return 0; +} + +KernelModule sceKernelLoadStartModule(const char* module_file_name, size_t args, const void* argp, uint32_t flags, const KernelLoadModuleOpt* opt, int* res) { + (void)module_file_name; + (void)args; + (void)argp; + (void)flags; + (void)opt; + (void)res; + return {}; +} + +int64_t sceKernelLseek(int d, int64_t offset, int whence) { + (void)d; + (void)offset; + (void)whence; + return 0; +} + +int sceKernelMapDirectMemory(void** addr, size_t len, int prot, int flags, int64_t direct_memory_start, size_t alignment) { + (void)addr; + (void)len; + (void)prot; + (void)flags; + (void)direct_memory_start; + (void)alignment; + return 0; +} + +int sceKernelMapDirectMemory2(void** addr, size_t len, int type, int prot, int flags, int64_t direct_memory_start, size_t alignment) { + (void)addr; + (void)len; + (void)type; + (void)prot; + (void)flags; + (void)direct_memory_start; + (void)alignment; + return 0; +} + +int sceKernelMapFlexibleMemory(void** addr_in_out, size_t len, int prot, int flags) { + (void)addr_in_out; + (void)len; + (void)prot; + (void)flags; + return 0; +} + +int sceKernelMapNamedDirectMemory(void** addr, size_t len, int prot, int flags, int64_t direct_memory_start, size_t alignment, const char* name) { + (void)addr; + (void)len; + (void)prot; + (void)flags; + (void)direct_memory_start; + (void)alignment; + (void)name; + return 0; +} + +int32_t sceKernelMapNamedFlexibleMemory(void** addr_in_out, size_t len, int prot, int flags, const char* name) { + (void)addr_in_out; + (void)len; + (void)prot; + (void)flags; + (void)name; + return 0; +} + +int sceKernelMemoryPoolBatch(const KernelMemoryPoolBatchEntry* entries, int num_entries, int* num_entries_out, int flags) { + (void)entries; + (void)num_entries; + (void)num_entries_out; + (void)flags; + return 0; +} + +int sceKernelMemoryPoolCommit(void* addr, size_t len, int type, int prot, int flags) { + (void)addr; + (void)len; + (void)type; + (void)prot; + (void)flags; + return 0; +} + +int sceKernelMemoryPoolDecommit(void* addr, size_t len, int flags) { + (void)addr; + (void)len; + (void)flags; + return 0; +} + +int sceKernelMemoryPoolExpand(int64_t search_start, int64_t search_end, size_t len, size_t alignment, int64_t* phys_addr_out) { + (void)search_start; + (void)search_end; + (void)len; + (void)alignment; + (void)phys_addr_out; + return 0; +} + +int sceKernelMemoryPoolGetBlockStats(KernelMemoryPoolBlockStats* output, size_t output_size) { + (void)output; + (void)output_size; + return 0; +} + +int sceKernelMemoryPoolReserve(void* addr_in, size_t len, size_t alignment, int flags, void** addr_out) { + (void)addr_in; + (void)len; + (void)alignment; + (void)flags; + (void)addr_out; + return 0; +} + +int sceKernelMkdir(const char* path, uint16_t mode) { + (void)path; + (void)mode; + return 0; +} + +int sceKernelMprotect(const void* addr, size_t len, int prot) { + (void)addr; + (void)len; + (void)prot; + return 0; +} + +int sceKernelMtypeprotect(const void* addr, size_t len, int type, int prot) { + (void)addr; + (void)len; + (void)type; + (void)prot; + return 0; +} + +int sceKernelMunmap(uint64_t vaddr, size_t len) { + (void)vaddr; + (void)len; + return 0; +} + +int sceKernelNanosleep(const KernelTimespec* rqtp, KernelTimespec* rmtp) { + (void)rqtp; + (void)rmtp; + return 0; +} + +int sceKernelOpen(const char* path, int flags, uint16_t mode) { + (void)path; + (void)flags; + (void)mode; + return 0; +} + +int sceKernelPollEventFlag(KernelEventFlag ef, uint64_t bit_pattern, uint32_t wait_mode, uint64_t* result_pat) { + (void)ef; + (void)bit_pattern; + (void)wait_mode; + (void)result_pat; + return 0; +} + +int sceKernelPollSema(KernelSema sem, int need) { + (void)sem; + (void)need; + return 0; +} + +int64_t sceKernelPread(int d, void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int64_t sceKernelPwrite(int d, const void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int sceKernelQueryMemoryProtection(void* addr, void** start, void** end, int* prot) { + (void)addr; + (void)start; + (void)end; + (void)prot; + return 0; +} + +int sceKernelRaiseException(Pthread thread, int signum) { + (void)thread; + (void)signum; + return 0; +} + +int64_t sceKernelRead(int d, void* buf, size_t nbytes) { + (void)d; + (void)buf; + (void)nbytes; + return 0; +} + +uint64_t sceKernelReadTsc(void) { + return 0; +} + +int sceKernelReleaseDirectMemory(int64_t start, size_t len) { + (void)start; + (void)len; + return 0; +} + +int sceKernelRemoveExceptionHandler(int signum) { + (void)signum; + return 0; +} + +int sceKernelRename(const char* from, const char* to) { + (void)from; + (void)to; + return 0; +} + +int sceKernelReserveVirtualRange(void** addr, size_t len, int flags, size_t alignment) { + (void)addr; + (void)len; + (void)flags; + (void)alignment; + return 0; +} + +int sceKernelRmdir(const char* path) { + (void)path; + return 0; +} + +void sceKernelRtldSetApplicationHeapAPI(void* api[]) { + (void)api; +} + +int sceKernelRtldThreadAtexitDecrement(uint64_t* c) { + (void)c; + return 0; +} + +int sceKernelRtldThreadAtexitIncrement(uint64_t* c) { + (void)c; + return 0; +} + +int sceKernelSetEventFlag(KernelEventFlag ef, uint64_t bit_pattern) { + (void)ef; + (void)bit_pattern; + return 0; +} + +void sceKernelSetGPO(uint32_t bits) { + (void)bits; +} + +int sceKernelSetPrtAperture(int index, void* addr, size_t len) { + (void)index; + (void)addr; + (void)len; + return 0; +} + +void sceKernelSetThreadAtexitCount(get_thread_atexit_count_func_t func) { + (void)func; +} + +void sceKernelSetThreadAtexitReport(thread_atexit_report_func_t func) { + (void)func; +} + +void sceKernelSetThreadDtors(thread_dtors_func_t dtors) { + (void)dtors; +} + +int sceKernelSetVirtualRangeName(const void* addr, uint64_t len, const char* name) { + (void)addr; + (void)len; + (void)name; + return 0; +} + +int sceKernelSignalSema(KernelSema sem, int count) { + (void)sem; + (void)count; + return 0; +} + +unsigned int sceKernelSleep(unsigned int seconds) { + (void)seconds; + return 0; +} + +int sceKernelStat(const char* path, FileStat* sb) { + (void)path; + (void)sb; + return 0; +} + +int sceKernelStopUnloadModule(KernelModule handle, size_t args, const void* argp, uint32_t flags, const KernelUnloadModuleOpt* opt, int* res) { + (void)handle; + (void)args; + (void)argp; + (void)flags; + (void)opt; + (void)res; + return 0; +} + +void sceKernelSync(void) { +} + +int sceKernelTriggerUserEvent(KernelEqueue eq, int id, void* udata) { + (void)eq; + (void)id; + (void)udata; + return 0; +} + +int sceKernelUnlink(const char* path) { + (void)path; + return 0; +} + +int sceKernelUsleep(KernelUseconds microseconds) { + (void)microseconds; + return 0; +} + +int sceKernelUuidCreate(uint32_t* uuid) { + (void)uuid; + return 0; +} + +int sceKernelVirtualQuery(const void* addr, int flags, VirtualQueryInfo* info, uint64_t info_size) { + (void)addr; + (void)flags; + (void)info; + (void)info_size; + return 0; +} + +int sceKernelWaitEqueue(KernelEqueue eq, KernelEvent* ev, int num, int* out, const KernelUseconds* timo) { + (void)eq; + (void)ev; + (void)num; + (void)out; + (void)timo; + return 0; +} + +int sceKernelWaitEventFlag(KernelEventFlag ef, uint64_t bit_pattern, uint32_t wait_mode, uint64_t* result_pat, KernelUseconds* timeout) { + (void)ef; + (void)bit_pattern; + (void)wait_mode; + (void)result_pat; + (void)timeout; + return 0; +} + +int sceKernelWaitSema(KernelSema sem, int need, KernelUseconds* time) { + (void)sem; + (void)need; + (void)time; + return 0; +} + +int64_t sceKernelWrite(int d, const void* buf, size_t nbytes) { + (void)d; + (void)buf; + (void)nbytes; + return 0; +} + +int scePthreadAttrDestroy(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int scePthreadAttrGet(Pthread thread, PthreadAttr* attr) { + (void)thread; + (void)attr; + return 0; +} + +int scePthreadAttrGetaffinity(const PthreadAttr* attr, KernelCpumask* mask) { + (void)attr; + (void)mask; + return 0; +} + +int scePthreadAttrGetdetachstate(const PthreadAttr* attr, int* state) { + (void)attr; + (void)state; + return 0; +} + +int scePthreadAttrGetguardsize(const PthreadAttr* attr, size_t* guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int scePthreadAttrGetschedparam(const PthreadAttr* attr, KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int scePthreadAttrGetsolosched(const PthreadAttr* attr, int* solosched) { + (void)attr; + (void)solosched; + return 0; +} + +int scePthreadAttrGetstack(const PthreadAttr* __restrict attr, void** __restrict stack_addr, size_t* __restrict stack_size) { + (void)attr; + (void)stack_addr; + (void)stack_size; + return 0; +} + +int scePthreadAttrGetstackaddr(const PthreadAttr* attr, void** stack_addr) { + (void)attr; + (void)stack_addr; + return 0; +} + +int scePthreadAttrGetstacksize(const PthreadAttr* attr, size_t* stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int scePthreadAttrInit(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int scePthreadAttrSetaffinity(PthreadAttr* attr, KernelCpumask mask) { + (void)attr; + (void)mask; + return 0; +} + +int scePthreadAttrSetdetachstate(PthreadAttr* attr, int state) { + (void)attr; + (void)state; + return 0; +} + +int scePthreadAttrSetguardsize(PthreadAttr* attr, size_t guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int scePthreadAttrSetinheritsched(PthreadAttr* attr, int inherit_sched) { + (void)attr; + (void)inherit_sched; + return 0; +} + +int scePthreadAttrSetschedparam(PthreadAttr* attr, const KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int scePthreadAttrSetschedpolicy(PthreadAttr* attr, int policy) { + (void)attr; + (void)policy; + return 0; +} + +int scePthreadAttrSetsolosched(PthreadAttr* attr, int solosched) { + (void)attr; + (void)solosched; + return 0; +} + +int scePthreadAttrSetstack(PthreadAttr* attr, void* addr, size_t size) { + (void)attr; + (void)addr; + (void)size; + return 0; +} + +int scePthreadAttrSetstackaddr(PthreadAttr* attr, void* addr) { + (void)attr; + (void)addr; + return 0; +} + +int scePthreadAttrSetstacksize(PthreadAttr* attr, size_t stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int scePthreadCancel(Pthread thread) { + (void)thread; + return 0; +} + +int scePthreadCondattrDestroy(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int scePthreadCondattrInit(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int scePthreadCondBroadcast(PthreadCond* cond) { + (void)cond; + return 0; +} + +int scePthreadCondDestroy(PthreadCond* cond) { + (void)cond; + return 0; +} + +int scePthreadCondInit(PthreadCond* cond, const PthreadCondattr* attr, const char* name) { + (void)cond; + (void)attr; + (void)name; + return 0; +} + +int scePthreadCondSignal(PthreadCond* cond) { + (void)cond; + return 0; +} + +int scePthreadCondSignalto(PthreadCond* cond, Pthread thread) { + (void)cond; + (void)thread; + return 0; +} + +int scePthreadCondTimedwait(PthreadCond* cond, PthreadMutex* mutex, KernelUseconds usec) { + (void)cond; + (void)mutex; + (void)usec; + return 0; +} + +int scePthreadCondWait(PthreadCond* cond, PthreadMutex* mutex) { + (void)cond; + (void)mutex; + return 0; +} + +int scePthreadCreate(Pthread* thread, const PthreadAttr* attr, pthread_entry_func_t entry, void* arg, const char* name) { + (void)thread; + (void)attr; + (void)entry; + (void)arg; + (void)name; + return 0; +} + +int scePthreadDetach(Pthread thread) { + (void)thread; + return 0; +} + +int scePthreadEqual(Pthread thread1, Pthread thread2) { + (void)thread1; + (void)thread2; + return 0; +} + +void scePthreadExit(void* value) { + (void)value; +} + +int scePthreadGetaffinity(Pthread thread, KernelCpumask* mask) { + (void)thread; + (void)mask; + return 0; +} + +int scePthreadGetname(Pthread thread, char* name) { + (void)thread; + (void)name; + return 0; +} + +int scePthreadGetprio(Pthread thread, int* prio) { + (void)thread; + (void)prio; + return 0; +} + +void* scePthreadGetspecific(PthreadKey key) { + (void)key; + return nullptr; +} + +int scePthreadGetthreadid(void) { + return 0; +} + +int scePthreadJoin(Pthread thread, void** value) { + (void)thread; + (void)value; + return 0; +} + +int scePthreadKeyCreate(PthreadKey* key, pthread_key_destructor_func_t destructor) { + (void)key; + (void)destructor; + return 0; +} + +int scePthreadKeyDelete(PthreadKey key) { + (void)key; + return 0; +} + +int scePthreadMutexattrDestroy(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int scePthreadMutexattrInit(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int scePthreadMutexattrSetprotocol(PthreadMutexattr* attr, int protocol) { + (void)attr; + (void)protocol; + return 0; +} + +int scePthreadMutexattrSettype(PthreadMutexattr* attr, int type) { + (void)attr; + (void)type; + return 0; +} + +int scePthreadMutexDestroy(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadMutexInit(PthreadMutex* mutex, const PthreadMutexattr* attr, const char* name) { + (void)mutex; + (void)attr; + (void)name; + return 0; +} + +int scePthreadMutexLock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadMutexTimedlock(PthreadMutex* mutex, KernelUseconds usec) { + (void)mutex; + (void)usec; + return 0; +} + +int scePthreadMutexTrylock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadMutexUnlock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadRename(Pthread thread, const char* name) { + (void)thread; + (void)name; + return 0; +} + +int scePthreadRwlockattrDestroy(PthreadRwlockattr* attr) { + (void)attr; + return 0; +} + +int scePthreadRwlockattrInit(PthreadRwlockattr* attr) { + (void)attr; + return 0; +} + +int scePthreadRwlockattrSettype(PthreadRwlockattr* attr, int type) { + (void)attr; + (void)type; + return 0; +} + +int scePthreadRwlockDestroy(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockInit(PthreadRwlock* rwlock, const PthreadRwlockattr* attr, const char* name) { + (void)rwlock; + (void)attr; + (void)name; + return 0; +} + +int scePthreadRwlockRdlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockTryrdlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockTrywrlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockUnlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockWrlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +Pthread scePthreadSelf(void) { + return {}; +} + +int scePthreadSemDestroy(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSemGetvalue(void* sem, int* value) { + (void)sem; + (void)value; + return 0; +} + +int scePthreadSemInit(void* sem, int flag, unsigned int value, const char* name) { + (void)sem; + (void)flag; + (void)value; + (void)name; + return 0; +} + +int scePthreadSemPost(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSemTimedwait(void* sem, KernelUseconds usec) { + (void)sem; + (void)usec; + return 0; +} + +int scePthreadSemTrywait(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSemWait(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSetaffinity(Pthread thread, KernelCpumask mask) { + (void)thread; + (void)mask; + return 0; +} + +int scePthreadSetcancelstate(int state, int* old_state) { + (void)state; + (void)old_state; + return 0; +} + +int scePthreadSetcanceltype(int type, int* old_type) { + (void)type; + (void)old_type; + return 0; +} + +int scePthreadSetprio(Pthread thread, int prio) { + (void)thread; + (void)prio; + return 0; +} + +int scePthreadSetspecific(PthreadKey key, void* value) { + (void)key; + (void)value; + return 0; +} + +void scePthreadYield(void) { +} + +int sched_get_priority_max(int policy) { + (void)policy; + return 0; +} + +int sched_get_priority_min(int policy) { + (void)policy; + return 0; +} + +int select(int nfds, void* readfds, void* writefds, void* exceptfds, const void* timeout) { + (void)nfds; + (void)readfds; + (void)writefds; + (void)exceptfds; + (void)timeout; + return 0; +} + +int sem_destroy(void* sem) { + (void)sem; + return 0; +} + +int sem_getvalue(void* sem, int* value) { + (void)sem; + (void)value; + return 0; +} + +int sem_init(void* sem, int pshared, unsigned int value) { + (void)sem; + (void)pshared; + (void)value; + return 0; +} + +int sem_post(void* sem) { + (void)sem; + return 0; +} + +int sem_reltimedwait_np(void* sem, uint32_t usec) { + (void)sem; + (void)usec; + return 0; +} + +int sem_timedwait(void* sem, const KernelTimespec* abstime) { + (void)sem; + (void)abstime; + return 0; +} + +int sem_trywait(void* sem) { + (void)sem; + return 0; +} + +int sem_wait(void* sem) { + (void)sem; + return 0; +} + +int64_t send(int s, const void* buf, uint64_t len, int flags) { + (void)s; + (void)buf; + (void)len; + (void)flags; + return 0; +} + +int64_t sendto(int s, const void* buf, uint64_t len, int flags, const void* addr, uint32_t addrlen) { + (void)s; + (void)buf; + (void)len; + (void)flags; + (void)addr; + (void)addrlen; + return 0; +} + +int setsockopt(int s, int level, int optname, const void* optval, uint32_t optlen) { + (void)s; + (void)level; + (void)optname; + (void)optval; + (void)optlen; + return 0; +} + +int sigprocmask(int how, const void* set, void* oset) { + (void)how; + (void)set; + (void)oset; + return 0; +} + +int socket(int family, int type, int protocol) { + (void)family; + (void)type; + (void)protocol; + return 0; +} + +int stat(const char* path, FileStat* sb) { + (void)path; + (void)sb; + return 0; +} + +int64_t write(int d, const char* str, int64_t size) { + (void)d; + (void)str; + (void)size; + return 0; +} + +} diff --git a/core/libs/prx/libkernel_web/Export.cpp b/core/libs/prx/libkernel_web/Export.cpp new file mode 100644 index 000000000..718712b00 --- /dev/null +++ b/core/libs/prx/libkernel_web/Export.cpp @@ -0,0 +1,1876 @@ +#include +#include +#include "SceTypes.hpp" + +extern "C" { + +int accept(int s, void* addr, uint32_t* addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int bind(int s, const void* addr, uint32_t addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int chmod(const char* path, int mode) { + (void)path; + (void)mode; + return 0; +} + +int clock_getres(int clock_id, KernelTimespec* res) { + (void)clock_id; + (void)res; + return 0; +} + +int clock_gettime(int clock_id, KernelTimespec* time) { + (void)clock_id; + (void)time; + return 0; +} + +int close(int d) { + (void)d; + return 0; +} + +int connect(int s, const void* addr, uint32_t addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +void exit(int code) { + (void)code; +} + +int flock(int d, int operation) { + (void)d; + (void)operation; + return 0; +} + +int64_t fstat(int d, FileStat* sb) { + (void)d; + (void)sb; + return 0; +} + +int ftruncate(int d, int64_t length) { + (void)d; + (void)length; + return 0; +} + +int getargc(void) { + return 0; +} + +const char** getargv(void) { + return nullptr; +} + +int getpagesize(void) { + return 0; +} + +int getpid(void) { + return 0; +} + +int getsockname(int s, void* addr, uint32_t* addrlen) { + (void)s; + (void)addr; + (void)addrlen; + return 0; +} + +int getsockopt(int s, int level, int optname, void* optval, uint32_t* optlen) { + (void)s; + (void)level; + (void)optname; + (void)optval; + (void)optlen; + return 0; +} + +int gettimeofday(KernelTimeval* time, KernelTimezone* timezone) { + (void)time; + (void)timezone; + return 0; +} + +const char* inet_ntop(int af, const void* src, char* dst, uint32_t size) { + (void)af; + (void)src; + (void)dst; + (void)size; + return nullptr; +} + +int inet_pton(int af, const char* src, void* dst) { + (void)af; + (void)src; + (void)dst; + return 0; +} + +int listen(int s, int backlog) { + (void)s; + (void)backlog; + return 0; +} + +int64_t lseek(int d, int64_t offset, int whence) { + (void)d; + (void)offset; + (void)whence; + return 0; +} + +int mkdir(const char* path, uint16_t mode) { + (void)path; + (void)mode; + return 0; +} + +int nanosleep(const KernelTimespec* rqtp, KernelTimespec* rmtp) { + (void)rqtp; + (void)rmtp; + return 0; +} + +int open(const char* path, int flags, int mode) { + (void)path; + (void)flags; + (void)mode; + return 0; +} + +int64_t pread(int d, void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int pthread_attr_destroy(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int pthread_attr_get_np(Pthread thread, PthreadAttr* attr) { + (void)thread; + (void)attr; + return 0; +} + +int pthread_attr_getdetachstate(const PthreadAttr* attr, int* state) { + (void)attr; + (void)state; + return 0; +} + +int pthread_attr_getguardsize(const PthreadAttr* attr, size_t* guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int pthread_attr_getschedparam(const PthreadAttr* attr, KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int pthread_attr_getschedpolicy(const PthreadAttr* attr, int* policy) { + (void)attr; + (void)policy; + return 0; +} + +int pthread_attr_getstack(const PthreadAttr* __restrict attr, void** __restrict stack_addr, size_t* __restrict stack_size) { + (void)attr; + (void)stack_addr; + (void)stack_size; + return 0; +} + +int pthread_attr_getstacksize(const PthreadAttr* attr, size_t* stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int pthread_attr_init(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int pthread_attr_setdetachstate(PthreadAttr* attr, int state) { + (void)attr; + (void)state; + return 0; +} + +int pthread_attr_setguardsize(PthreadAttr* attr, size_t guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int pthread_attr_setinheritsched(PthreadAttr* attr, int inherit_sched) { + (void)attr; + (void)inherit_sched; + return 0; +} + +int pthread_attr_setschedparam(PthreadAttr* attr, const KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int pthread_attr_setschedpolicy(PthreadAttr* attr, int policy) { + (void)attr; + (void)policy; + return 0; +} + +int pthread_attr_setstacksize(PthreadAttr* attr, size_t stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int pthread_cond_broadcast(PthreadCond* cond) { + (void)cond; + return 0; +} + +int pthread_cond_init(PthreadCond* cond, const PthreadCondattr* attr) { + (void)cond; + (void)attr; + return 0; +} + +int pthread_cond_signal(PthreadCond* cond) { + (void)cond; + return 0; +} + +int pthread_cond_timedwait(PthreadCond* cond, PthreadMutex* mutex, const KernelTimespec* abstime) { + (void)cond; + (void)mutex; + (void)abstime; + return 0; +} + +int pthread_cond_wait(PthreadCond* cond, PthreadMutex* mutex) { + (void)cond; + (void)mutex; + return 0; +} + +int pthread_condattr_destroy(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int pthread_condattr_init(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int pthread_condattr_setclock(PthreadCondattr* attr, KernelClockid clock_id) { + (void)attr; + (void)clock_id; + return 0; +} + +int pthread_create(Pthread* thread, const PthreadAttr* attr, pthread_entry_func_t entry, void* arg) { + (void)thread; + (void)attr; + (void)entry; + (void)arg; + return 0; +} + +int pthread_create_name_np(Pthread* thread, const PthreadAttr* attr, pthread_entry_func_t entry, void* arg, const char* name) { + (void)thread; + (void)attr; + (void)entry; + (void)arg; + (void)name; + return 0; +} + +int pthread_detach(Pthread thread) { + (void)thread; + return 0; +} + +void pthread_exit(void* value) { + (void)value; +} + +int pthread_getschedparam(Pthread thread, int* policy, KernelSchedParam* param) { + (void)thread; + (void)policy; + (void)param; + return 0; +} + +void* pthread_getspecific(PthreadKey key) { + (void)key; + return nullptr; +} + +int pthread_join(Pthread thread, void** value) { + (void)thread; + (void)value; + return 0; +} + +int pthread_key_create(PthreadKey* key, pthread_key_destructor_func_t destructor) { + (void)key; + (void)destructor; + return 0; +} + +int pthread_key_delete(PthreadKey key) { + (void)key; + return 0; +} + +int pthread_mutex_destroy(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutex_init(PthreadMutex* mutex, const PthreadMutexattr* attr) { + (void)mutex; + (void)attr; + return 0; +} + +int pthread_mutex_lock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutex_timedlock(PthreadMutex* mutex, const KernelTimespec* abstime) { + (void)mutex; + (void)abstime; + return 0; +} + +int pthread_mutex_trylock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutex_unlock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int pthread_mutexattr_destroy(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int pthread_mutexattr_init(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int pthread_mutexattr_setprotocol(PthreadMutexattr* attr, int protocol) { + (void)attr; + (void)protocol; + return 0; +} + +int pthread_mutexattr_settype(PthreadMutexattr* attr, int type) { + (void)attr; + (void)type; + return 0; +} + +int pthread_once(void* once_control, void(KYTY_SYSV_ABI* init_routine)()) { + (void)once_control; + (void)init_routine; + return 0; +} + +int pthread_rename_np(Pthread thread, const char* name) { + (void)thread; + (void)name; + return 0; +} + +int pthread_rwlock_destroy(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int pthread_rwlock_init(PthreadRwlock* rwlock, const PthreadRwlockattr* attr) { + (void)rwlock; + (void)attr; + return 0; +} + +int pthread_rwlock_wrlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +Pthread pthread_self(void) { + return {}; +} + +int pthread_setcancelstate(int state, int* old_state) { + (void)state; + (void)old_state; + return 0; +} + +int pthread_setprio(Pthread thread, int prio) { + (void)thread; + (void)prio; + return 0; +} + +int pthread_setschedparam(Pthread thread, int policy, const KernelSchedParam* param) { + (void)thread; + (void)policy; + (void)param; + return 0; +} + +int pthread_setspecific(PthreadKey key, void* value) { + (void)key; + (void)value; + return 0; +} + +void pthread_yield(void) { +} + +int64_t pwrite(int d, const void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int64_t read(int d, void* buf, uint64_t nbytes) { + (void)d; + (void)buf; + (void)nbytes; + return 0; +} + +int64_t recv(int s, void* buf, uint64_t len, int flags) { + (void)s; + (void)buf; + (void)len; + (void)flags; + return 0; +} + +int64_t recvfrom(int s, void* buf, uint64_t len, int flags, void* addr, uint32_t* addrlen) { + (void)s; + (void)buf; + (void)len; + (void)flags; + (void)addr; + (void)addrlen; + return 0; +} + +int sceCoredumpRegisterCoredumpHandler(uint64_t handler, size_t stack_size, uint64_t context) { + (void)handler; + (void)stack_size; + (void)context; + return 0; +} + +int sceCoredumpUnregisterCoredumpHandler(void) { + return 0; +} + +int sceKernelAddAmprEvent(KernelEqueue eq, int id, void* udata) { + (void)eq; + (void)id; + (void)udata; + return 0; +} + +int sceKernelAddHRTimerEvent(KernelEqueue eq, int id, const KernelTimespec* ts, void* udata) { + (void)eq; + (void)id; + (void)ts; + (void)udata; + return 0; +} + +int sceKernelAddUserEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelAddUserEventEdge(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelAioDeleteRequest(int32_t id, int32_t* ret) { + (void)id; + (void)ret; + return 0; +} + +int sceKernelAioInitializeImpl(void* param, int32_t size) { + (void)param; + (void)size; + return 0; +} + +void sceKernelAioInitializeParam(void* param) { + (void)param; +} + +int sceKernelAioSubmitReadCommands(KernelAioRwRequest* req, int32_t size, int32_t prio, int32_t* id) { + (void)req; + (void)size; + (void)prio; + (void)id; + return 0; +} + +int sceKernelAioSubmitWriteCommands(KernelAioRwRequest* req, int32_t size, int32_t prio, int32_t* id) { + (void)req; + (void)size; + (void)prio; + (void)id; + return 0; +} + +int sceKernelAioWaitRequest(int32_t id, int32_t* state, uint32_t* usec) { + (void)id; + (void)state; + (void)usec; + return 0; +} + +int sceKernelAllocateDirectMemory(int64_t search_start, int64_t search_end, size_t len, size_t alignment, int memory_type, int64_t* phys_addr_out) { + (void)search_start; + (void)search_end; + (void)len; + (void)alignment; + (void)memory_type; + (void)phys_addr_out; + return 0; +} + +int sceKernelAllocateMainDirectMemory(size_t len, size_t alignment, int memory_type, int64_t* phys_addr_out) { + (void)len; + (void)alignment; + (void)memory_type; + (void)phys_addr_out; + return 0; +} + +int sceKernelAvailableDirectMemorySize(int64_t search_start, int64_t search_end, size_t alignment, int64_t* phys_addr_out, size_t* size_out) { + (void)search_start; + (void)search_end; + (void)alignment; + (void)phys_addr_out; + (void)size_out; + return 0; +} + +int sceKernelAvailableFlexibleMemorySize(size_t* size) { + (void)size; + return 0; +} + +int sceKernelBatchMap(KernelBatchMapEntry* entries, int num_entries, int* num_entries_out) { + (void)entries; + (void)num_entries; + (void)num_entries_out; + return 0; +} + +int sceKernelBatchMap2(KernelBatchMapEntry* entries, int num_entries, int* num_entries_out, int flags) { + (void)entries; + (void)num_entries; + (void)num_entries_out; + (void)flags; + return 0; +} + +int sceKernelCancelEventFlag(KernelEventFlag ef, uint64_t set_pattern, int* num_wait_threads) { + (void)ef; + (void)set_pattern; + (void)num_wait_threads; + return 0; +} + +int sceKernelCancelSema(KernelSema sem, int count, int* threads) { + (void)sem; + (void)count; + (void)threads; + return 0; +} + +int sceKernelCheckedReleaseDirectMemory(int64_t start, size_t len) { + (void)start; + (void)len; + return 0; +} + +int sceKernelCheckReachability(const char* path) { + (void)path; + return 0; +} + +int sceKernelClearEventFlag(KernelEventFlag ef, uint64_t bit_pattern) { + (void)ef; + (void)bit_pattern; + return 0; +} + +int sceKernelClockGetres(KernelClockid clock_id, KernelTimespec* tp) { + (void)clock_id; + (void)tp; + return 0; +} + +int sceKernelClockGettime(KernelClockid clock_id, KernelTimespec* tp) { + (void)clock_id; + (void)tp; + return 0; +} + +int sceKernelClose(int d) { + (void)d; + return 0; +} + +int sceKernelConfiguredFlexibleMemorySize(size_t* size) { + (void)size; + return 0; +} + +int sceKernelConvertLocaltimeToUtc(int64_t local_time, int64_t reserved, int64_t* utc_time, KernelTimezone* timezone, int32_t* dst_seconds) { + (void)local_time; + (void)reserved; + (void)utc_time; + (void)timezone; + (void)dst_seconds; + return 0; +} + +int sceKernelConvertUtcToLocaltime(int64_t utc_time, int64_t* local_time, KernelTimesec* st, uint64_t* dst_sec) { + (void)utc_time; + (void)local_time; + (void)st; + (void)dst_sec; + return 0; +} + +int sceKernelCreateEqueue(KernelEqueue* eq, const char* name) { + (void)eq; + (void)name; + return 0; +} + +int sceKernelCreateEventFlag(KernelEventFlag* ef, const char* name, uint32_t attr, uint64_t init_pattern, const void* param) { + (void)ef; + (void)name; + (void)attr; + (void)init_pattern; + (void)param; + return 0; +} + +int sceKernelCreateSema(KernelSema* sem, const char* name, uint32_t attr, int init, int max, void* opt) { + (void)sem; + (void)name; + (void)attr; + (void)init; + (void)max; + (void)opt; + return 0; +} + +void sceKernelDebugRaiseException(int c1, int c2) { + (void)c1; + (void)c2; +} + +void sceKernelDebugRaiseExceptionOnReleaseMode(int c1, int c2) { + (void)c1; + (void)c2; +} + +int sceKernelDeleteAmprEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelDeleteEqueue(KernelEqueue eq) { + (void)eq; + return 0; +} + +int sceKernelDeleteEventFlag(KernelEventFlag ef) { + (void)ef; + return 0; +} + +int sceKernelDeleteHRTimerEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelDeleteSema(KernelSema sem) { + (void)sem; + return 0; +} + +int sceKernelDeleteUserEvent(KernelEqueue eq, int id) { + (void)eq; + (void)id; + return 0; +} + +int sceKernelDirectMemoryQuery(int64_t offset, int flags, void* info, size_t info_size) { + (void)offset; + (void)flags; + (void)info; + (void)info_size; + return 0; +} + +int sceKernelDlsym(KernelModule handle, const char* symbol, void** addr) { + (void)handle; + (void)symbol; + (void)addr; + return 0; +} + +int sceKernelFstat(int d, FileStat* sb) { + (void)d; + (void)sb; + return 0; +} + +int sceKernelFsync(int fd) { + (void)fd; + return 0; +} + +int sceKernelGetCurrentCpu(void) { + return 0; +} + +int sceKernelGetdents(int fd, char* buf, int nbytes) { + (void)fd; + (void)buf; + (void)nbytes; + return 0; +} + +size_t sceKernelGetDirectMemorySize(void) { + return 0; +} + +int sceKernelGetdirentries(int fd, char* buf, int nbytes, int64_t* basep) { + (void)fd; + (void)buf; + (void)nbytes; + (void)basep; + return 0; +} + +intptr_t sceKernelGetEventData(const KernelEvent* ev) { + (void)ev; + return 0; +} + +int sceKernelGetEventError(const KernelEvent* ev) { + (void)ev; + return 0; +} + +intptr_t sceKernelGetEventFflags(const KernelEvent* ev) { + (void)ev; + return 0; +} + +int sceKernelGetEventFilter(const KernelEvent* ev) { + (void)ev; + return 0; +} + +uintptr_t sceKernelGetEventId(const KernelEvent* ev) { + (void)ev; + return 0; +} + +void* sceKernelGetEventUserData(const KernelEvent* ev) { + (void)ev; + return nullptr; +} + +uint64_t sceKernelGetGPI(void) { + return 0; +} + +int sceKernelGetModuleInfoForUnwind(uint64_t addr, int flags, ModuleInfoForUnwind* info) { + (void)addr; + (void)flags; + (void)info; + return 0; +} + +int sceKernelGetModuleInfoFromAddr(uint64_t addr, int n, ModuleInfo* r) { + (void)addr; + (void)n; + (void)r; + return 0; +} + +int sceKernelGetOpenPsId(void* open_ps_id) { + (void)open_ps_id; + return 0; +} + +int sceKernelGetPageTableStats(int* cpu_total, int* cpu_available, int* gpu_total, int* gpu_available) { + (void)cpu_total; + (void)cpu_available; + (void)gpu_total; + (void)gpu_available; + return 0; +} + +uint64_t sceKernelGetProcessTime(void) { + return 0; +} + +uint64_t sceKernelGetProcessTimeCounter(void) { + return 0; +} + +uint64_t sceKernelGetProcessTimeCounterFrequency(void) { + return 0; +} + +void* sceKernelGetProcParam(void) { + return nullptr; +} + +int sceKernelGetPrtAperture(int index, void** addr, size_t* len) { + (void)index; + (void)addr; + (void)len; + return 0; +} + +MallocReplace* sceKernelGetSanitizerMallocReplaceExternal(void) { + return nullptr; +} + +NewReplace* sceKernelGetSanitizerNewReplaceExternal(void) { + return nullptr; +} + +int sceKernelGettimeofday(KernelTimeval* tp) { + (void)tp; + return 0; +} + +int sceKernelGettimezone(KernelTimezone* tz) { + (void)tz; + return 0; +} + +uint64_t sceKernelGetTscFrequency(void) { + return 0; +} + +int sceKernelInstallExceptionHandler(int signum, void* handler) { + (void)signum; + (void)handler; + return 0; +} + +int sceKernelIsAddressSanitizerEnabled(void) { + return 0; +} + +int sceKernelIsStack(void* addr, void** start, void** end) { + (void)addr; + (void)start; + (void)end; + return 0; +} + +KernelModule sceKernelLoadStartModule(const char* module_file_name, size_t args, const void* argp, uint32_t flags, const KernelLoadModuleOpt* opt, int* res) { + (void)module_file_name; + (void)args; + (void)argp; + (void)flags; + (void)opt; + (void)res; + return {}; +} + +int64_t sceKernelLseek(int d, int64_t offset, int whence) { + (void)d; + (void)offset; + (void)whence; + return 0; +} + +int sceKernelMapDirectMemory(void** addr, size_t len, int prot, int flags, int64_t direct_memory_start, size_t alignment) { + (void)addr; + (void)len; + (void)prot; + (void)flags; + (void)direct_memory_start; + (void)alignment; + return 0; +} + +int sceKernelMapDirectMemory2(void** addr, size_t len, int type, int prot, int flags, int64_t direct_memory_start, size_t alignment) { + (void)addr; + (void)len; + (void)type; + (void)prot; + (void)flags; + (void)direct_memory_start; + (void)alignment; + return 0; +} + +int sceKernelMapFlexibleMemory(void** addr_in_out, size_t len, int prot, int flags) { + (void)addr_in_out; + (void)len; + (void)prot; + (void)flags; + return 0; +} + +int sceKernelMapNamedDirectMemory(void** addr, size_t len, int prot, int flags, int64_t direct_memory_start, size_t alignment, const char* name) { + (void)addr; + (void)len; + (void)prot; + (void)flags; + (void)direct_memory_start; + (void)alignment; + (void)name; + return 0; +} + +int32_t sceKernelMapNamedFlexibleMemory(void** addr_in_out, size_t len, int prot, int flags, const char* name) { + (void)addr_in_out; + (void)len; + (void)prot; + (void)flags; + (void)name; + return 0; +} + +int sceKernelMemoryPoolBatch(const KernelMemoryPoolBatchEntry* entries, int num_entries, int* num_entries_out, int flags) { + (void)entries; + (void)num_entries; + (void)num_entries_out; + (void)flags; + return 0; +} + +int sceKernelMemoryPoolCommit(void* addr, size_t len, int type, int prot, int flags) { + (void)addr; + (void)len; + (void)type; + (void)prot; + (void)flags; + return 0; +} + +int sceKernelMemoryPoolDecommit(void* addr, size_t len, int flags) { + (void)addr; + (void)len; + (void)flags; + return 0; +} + +int sceKernelMemoryPoolExpand(int64_t search_start, int64_t search_end, size_t len, size_t alignment, int64_t* phys_addr_out) { + (void)search_start; + (void)search_end; + (void)len; + (void)alignment; + (void)phys_addr_out; + return 0; +} + +int sceKernelMemoryPoolGetBlockStats(KernelMemoryPoolBlockStats* output, size_t output_size) { + (void)output; + (void)output_size; + return 0; +} + +int sceKernelMemoryPoolReserve(void* addr_in, size_t len, size_t alignment, int flags, void** addr_out) { + (void)addr_in; + (void)len; + (void)alignment; + (void)flags; + (void)addr_out; + return 0; +} + +int sceKernelMkdir(const char* path, uint16_t mode) { + (void)path; + (void)mode; + return 0; +} + +int sceKernelMprotect(const void* addr, size_t len, int prot) { + (void)addr; + (void)len; + (void)prot; + return 0; +} + +int sceKernelMtypeprotect(const void* addr, size_t len, int type, int prot) { + (void)addr; + (void)len; + (void)type; + (void)prot; + return 0; +} + +int sceKernelMunmap(uint64_t vaddr, size_t len) { + (void)vaddr; + (void)len; + return 0; +} + +int sceKernelNanosleep(const KernelTimespec* rqtp, KernelTimespec* rmtp) { + (void)rqtp; + (void)rmtp; + return 0; +} + +int sceKernelOpen(const char* path, int flags, uint16_t mode) { + (void)path; + (void)flags; + (void)mode; + return 0; +} + +int sceKernelPollEventFlag(KernelEventFlag ef, uint64_t bit_pattern, uint32_t wait_mode, uint64_t* result_pat) { + (void)ef; + (void)bit_pattern; + (void)wait_mode; + (void)result_pat; + return 0; +} + +int sceKernelPollSema(KernelSema sem, int need) { + (void)sem; + (void)need; + return 0; +} + +int64_t sceKernelPread(int d, void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int64_t sceKernelPwrite(int d, const void* buf, size_t nbytes, int64_t offset) { + (void)d; + (void)buf; + (void)nbytes; + (void)offset; + return 0; +} + +int sceKernelQueryMemoryProtection(void* addr, void** start, void** end, int* prot) { + (void)addr; + (void)start; + (void)end; + (void)prot; + return 0; +} + +int sceKernelRaiseException(Pthread thread, int signum) { + (void)thread; + (void)signum; + return 0; +} + +int64_t sceKernelRead(int d, void* buf, size_t nbytes) { + (void)d; + (void)buf; + (void)nbytes; + return 0; +} + +uint64_t sceKernelReadTsc(void) { + return 0; +} + +int sceKernelReleaseDirectMemory(int64_t start, size_t len) { + (void)start; + (void)len; + return 0; +} + +int sceKernelRemoveExceptionHandler(int signum) { + (void)signum; + return 0; +} + +int sceKernelRename(const char* from, const char* to) { + (void)from; + (void)to; + return 0; +} + +int sceKernelReserveVirtualRange(void** addr, size_t len, int flags, size_t alignment) { + (void)addr; + (void)len; + (void)flags; + (void)alignment; + return 0; +} + +int sceKernelRmdir(const char* path) { + (void)path; + return 0; +} + +void sceKernelRtldSetApplicationHeapAPI(void* api[]) { + (void)api; +} + +int sceKernelRtldThreadAtexitDecrement(uint64_t* c) { + (void)c; + return 0; +} + +int sceKernelRtldThreadAtexitIncrement(uint64_t* c) { + (void)c; + return 0; +} + +int sceKernelSetEventFlag(KernelEventFlag ef, uint64_t bit_pattern) { + (void)ef; + (void)bit_pattern; + return 0; +} + +void sceKernelSetGPO(uint32_t bits) { + (void)bits; +} + +int sceKernelSetPrtAperture(int index, void* addr, size_t len) { + (void)index; + (void)addr; + (void)len; + return 0; +} + +void sceKernelSetThreadAtexitCount(get_thread_atexit_count_func_t func) { + (void)func; +} + +void sceKernelSetThreadAtexitReport(thread_atexit_report_func_t func) { + (void)func; +} + +void sceKernelSetThreadDtors(thread_dtors_func_t dtors) { + (void)dtors; +} + +int sceKernelSetVirtualRangeName(const void* addr, uint64_t len, const char* name) { + (void)addr; + (void)len; + (void)name; + return 0; +} + +int sceKernelSignalSema(KernelSema sem, int count) { + (void)sem; + (void)count; + return 0; +} + +unsigned int sceKernelSleep(unsigned int seconds) { + (void)seconds; + return 0; +} + +int sceKernelStat(const char* path, FileStat* sb) { + (void)path; + (void)sb; + return 0; +} + +int sceKernelStopUnloadModule(KernelModule handle, size_t args, const void* argp, uint32_t flags, const KernelUnloadModuleOpt* opt, int* res) { + (void)handle; + (void)args; + (void)argp; + (void)flags; + (void)opt; + (void)res; + return 0; +} + +void sceKernelSync(void) { +} + +int sceKernelTriggerUserEvent(KernelEqueue eq, int id, void* udata) { + (void)eq; + (void)id; + (void)udata; + return 0; +} + +int sceKernelUnlink(const char* path) { + (void)path; + return 0; +} + +int sceKernelUsleep(KernelUseconds microseconds) { + (void)microseconds; + return 0; +} + +int sceKernelUuidCreate(uint32_t* uuid) { + (void)uuid; + return 0; +} + +int sceKernelVirtualQuery(const void* addr, int flags, VirtualQueryInfo* info, uint64_t info_size) { + (void)addr; + (void)flags; + (void)info; + (void)info_size; + return 0; +} + +int sceKernelWaitEqueue(KernelEqueue eq, KernelEvent* ev, int num, int* out, const KernelUseconds* timo) { + (void)eq; + (void)ev; + (void)num; + (void)out; + (void)timo; + return 0; +} + +int sceKernelWaitEventFlag(KernelEventFlag ef, uint64_t bit_pattern, uint32_t wait_mode, uint64_t* result_pat, KernelUseconds* timeout) { + (void)ef; + (void)bit_pattern; + (void)wait_mode; + (void)result_pat; + (void)timeout; + return 0; +} + +int sceKernelWaitSema(KernelSema sem, int need, KernelUseconds* time) { + (void)sem; + (void)need; + (void)time; + return 0; +} + +int64_t sceKernelWrite(int d, const void* buf, size_t nbytes) { + (void)d; + (void)buf; + (void)nbytes; + return 0; +} + +int scePthreadAttrDestroy(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int scePthreadAttrGet(Pthread thread, PthreadAttr* attr) { + (void)thread; + (void)attr; + return 0; +} + +int scePthreadAttrGetaffinity(const PthreadAttr* attr, KernelCpumask* mask) { + (void)attr; + (void)mask; + return 0; +} + +int scePthreadAttrGetdetachstate(const PthreadAttr* attr, int* state) { + (void)attr; + (void)state; + return 0; +} + +int scePthreadAttrGetguardsize(const PthreadAttr* attr, size_t* guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int scePthreadAttrGetschedparam(const PthreadAttr* attr, KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int scePthreadAttrGetsolosched(const PthreadAttr* attr, int* solosched) { + (void)attr; + (void)solosched; + return 0; +} + +int scePthreadAttrGetstack(const PthreadAttr* __restrict attr, void** __restrict stack_addr, size_t* __restrict stack_size) { + (void)attr; + (void)stack_addr; + (void)stack_size; + return 0; +} + +int scePthreadAttrGetstackaddr(const PthreadAttr* attr, void** stack_addr) { + (void)attr; + (void)stack_addr; + return 0; +} + +int scePthreadAttrGetstacksize(const PthreadAttr* attr, size_t* stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int scePthreadAttrInit(PthreadAttr* attr) { + (void)attr; + return 0; +} + +int scePthreadAttrSetaffinity(PthreadAttr* attr, KernelCpumask mask) { + (void)attr; + (void)mask; + return 0; +} + +int scePthreadAttrSetdetachstate(PthreadAttr* attr, int state) { + (void)attr; + (void)state; + return 0; +} + +int scePthreadAttrSetguardsize(PthreadAttr* attr, size_t guard_size) { + (void)attr; + (void)guard_size; + return 0; +} + +int scePthreadAttrSetinheritsched(PthreadAttr* attr, int inherit_sched) { + (void)attr; + (void)inherit_sched; + return 0; +} + +int scePthreadAttrSetschedparam(PthreadAttr* attr, const KernelSchedParam* param) { + (void)attr; + (void)param; + return 0; +} + +int scePthreadAttrSetschedpolicy(PthreadAttr* attr, int policy) { + (void)attr; + (void)policy; + return 0; +} + +int scePthreadAttrSetsolosched(PthreadAttr* attr, int solosched) { + (void)attr; + (void)solosched; + return 0; +} + +int scePthreadAttrSetstack(PthreadAttr* attr, void* addr, size_t size) { + (void)attr; + (void)addr; + (void)size; + return 0; +} + +int scePthreadAttrSetstackaddr(PthreadAttr* attr, void* addr) { + (void)attr; + (void)addr; + return 0; +} + +int scePthreadAttrSetstacksize(PthreadAttr* attr, size_t stack_size) { + (void)attr; + (void)stack_size; + return 0; +} + +int scePthreadCancel(Pthread thread) { + (void)thread; + return 0; +} + +int scePthreadCondattrDestroy(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int scePthreadCondattrInit(PthreadCondattr* attr) { + (void)attr; + return 0; +} + +int scePthreadCondBroadcast(PthreadCond* cond) { + (void)cond; + return 0; +} + +int scePthreadCondDestroy(PthreadCond* cond) { + (void)cond; + return 0; +} + +int scePthreadCondInit(PthreadCond* cond, const PthreadCondattr* attr, const char* name) { + (void)cond; + (void)attr; + (void)name; + return 0; +} + +int scePthreadCondSignal(PthreadCond* cond) { + (void)cond; + return 0; +} + +int scePthreadCondSignalto(PthreadCond* cond, Pthread thread) { + (void)cond; + (void)thread; + return 0; +} + +int scePthreadCondTimedwait(PthreadCond* cond, PthreadMutex* mutex, KernelUseconds usec) { + (void)cond; + (void)mutex; + (void)usec; + return 0; +} + +int scePthreadCondWait(PthreadCond* cond, PthreadMutex* mutex) { + (void)cond; + (void)mutex; + return 0; +} + +int scePthreadCreate(Pthread* thread, const PthreadAttr* attr, pthread_entry_func_t entry, void* arg, const char* name) { + (void)thread; + (void)attr; + (void)entry; + (void)arg; + (void)name; + return 0; +} + +int scePthreadDetach(Pthread thread) { + (void)thread; + return 0; +} + +int scePthreadEqual(Pthread thread1, Pthread thread2) { + (void)thread1; + (void)thread2; + return 0; +} + +void scePthreadExit(void* value) { + (void)value; +} + +int scePthreadGetaffinity(Pthread thread, KernelCpumask* mask) { + (void)thread; + (void)mask; + return 0; +} + +int scePthreadGetname(Pthread thread, char* name) { + (void)thread; + (void)name; + return 0; +} + +int scePthreadGetprio(Pthread thread, int* prio) { + (void)thread; + (void)prio; + return 0; +} + +void* scePthreadGetspecific(PthreadKey key) { + (void)key; + return nullptr; +} + +int scePthreadGetthreadid(void) { + return 0; +} + +int scePthreadJoin(Pthread thread, void** value) { + (void)thread; + (void)value; + return 0; +} + +int scePthreadKeyCreate(PthreadKey* key, pthread_key_destructor_func_t destructor) { + (void)key; + (void)destructor; + return 0; +} + +int scePthreadKeyDelete(PthreadKey key) { + (void)key; + return 0; +} + +int scePthreadMutexattrDestroy(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int scePthreadMutexattrInit(PthreadMutexattr* attr) { + (void)attr; + return 0; +} + +int scePthreadMutexattrSetprotocol(PthreadMutexattr* attr, int protocol) { + (void)attr; + (void)protocol; + return 0; +} + +int scePthreadMutexattrSettype(PthreadMutexattr* attr, int type) { + (void)attr; + (void)type; + return 0; +} + +int scePthreadMutexDestroy(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadMutexInit(PthreadMutex* mutex, const PthreadMutexattr* attr, const char* name) { + (void)mutex; + (void)attr; + (void)name; + return 0; +} + +int scePthreadMutexLock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadMutexTimedlock(PthreadMutex* mutex, KernelUseconds usec) { + (void)mutex; + (void)usec; + return 0; +} + +int scePthreadMutexTrylock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadMutexUnlock(PthreadMutex* mutex) { + (void)mutex; + return 0; +} + +int scePthreadRename(Pthread thread, const char* name) { + (void)thread; + (void)name; + return 0; +} + +int scePthreadRwlockattrDestroy(PthreadRwlockattr* attr) { + (void)attr; + return 0; +} + +int scePthreadRwlockattrInit(PthreadRwlockattr* attr) { + (void)attr; + return 0; +} + +int scePthreadRwlockattrSettype(PthreadRwlockattr* attr, int type) { + (void)attr; + (void)type; + return 0; +} + +int scePthreadRwlockDestroy(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockInit(PthreadRwlock* rwlock, const PthreadRwlockattr* attr, const char* name) { + (void)rwlock; + (void)attr; + (void)name; + return 0; +} + +int scePthreadRwlockRdlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockTryrdlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockTrywrlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockUnlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +int scePthreadRwlockWrlock(PthreadRwlock* rwlock) { + (void)rwlock; + return 0; +} + +Pthread scePthreadSelf(void) { + return {}; +} + +int scePthreadSemDestroy(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSemGetvalue(void* sem, int* value) { + (void)sem; + (void)value; + return 0; +} + +int scePthreadSemInit(void* sem, int flag, unsigned int value, const char* name) { + (void)sem; + (void)flag; + (void)value; + (void)name; + return 0; +} + +int scePthreadSemPost(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSemTimedwait(void* sem, KernelUseconds usec) { + (void)sem; + (void)usec; + return 0; +} + +int scePthreadSemTrywait(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSemWait(void* sem) { + (void)sem; + return 0; +} + +int scePthreadSetaffinity(Pthread thread, KernelCpumask mask) { + (void)thread; + (void)mask; + return 0; +} + +int scePthreadSetcancelstate(int state, int* old_state) { + (void)state; + (void)old_state; + return 0; +} + +int scePthreadSetcanceltype(int type, int* old_type) { + (void)type; + (void)old_type; + return 0; +} + +int scePthreadSetprio(Pthread thread, int prio) { + (void)thread; + (void)prio; + return 0; +} + +int scePthreadSetspecific(PthreadKey key, void* value) { + (void)key; + (void)value; + return 0; +} + +void scePthreadYield(void) { +} + +int sched_get_priority_max(int policy) { + (void)policy; + return 0; +} + +int sched_get_priority_min(int policy) { + (void)policy; + return 0; +} + +int select(int nfds, void* readfds, void* writefds, void* exceptfds, const void* timeout) { + (void)nfds; + (void)readfds; + (void)writefds; + (void)exceptfds; + (void)timeout; + return 0; +} + +int sem_destroy(void* sem) { + (void)sem; + return 0; +} + +int sem_getvalue(void* sem, int* value) { + (void)sem; + (void)value; + return 0; +} + +int sem_init(void* sem, int pshared, unsigned int value) { + (void)sem; + (void)pshared; + (void)value; + return 0; +} + +int sem_post(void* sem) { + (void)sem; + return 0; +} + +int sem_reltimedwait_np(void* sem, uint32_t usec) { + (void)sem; + (void)usec; + return 0; +} + +int sem_timedwait(void* sem, const KernelTimespec* abstime) { + (void)sem; + (void)abstime; + return 0; +} + +int sem_trywait(void* sem) { + (void)sem; + return 0; +} + +int sem_wait(void* sem) { + (void)sem; + return 0; +} + +int64_t send(int s, const void* buf, uint64_t len, int flags) { + (void)s; + (void)buf; + (void)len; + (void)flags; + return 0; +} + +int64_t sendto(int s, const void* buf, uint64_t len, int flags, const void* addr, uint32_t addrlen) { + (void)s; + (void)buf; + (void)len; + (void)flags; + (void)addr; + (void)addrlen; + return 0; +} + +int setsockopt(int s, int level, int optname, const void* optval, uint32_t optlen) { + (void)s; + (void)level; + (void)optname; + (void)optval; + (void)optlen; + return 0; +} + +int sigprocmask(int how, const void* set, void* oset) { + (void)how; + (void)set; + (void)oset; + return 0; +} + +int socket(int family, int type, int protocol) { + (void)family; + (void)type; + (void)protocol; + return 0; +} + +int stat(const char* path, FileStat* sb) { + (void)path; + (void)sb; + return 0; +} + +int64_t write(int d, const char* str, int64_t size) { + (void)d; + (void)str; + (void)size; + return 0; +} + +}